Bearbeiten von InDesign® Tabellen.
Ein allgemeines Beispiel zur Verwendung der Klasse table finden sie hier.
Bearbeiten von InDesign® Tabellen.
Für das Modul wird der Import
#include "internal/table.h"
#include "internal/text.h"
benötigt.
static Table table::alloc(Table org = 0)
Erzeuge ein neues Objekt vom Typ Table. Der Verweis zeigt noch nicht auf eine existierende Tabelle eines Indesign® Dokumentes. Das Objekt muss mit table::release wieder gelöscht werden.
| Name | Typ | Default | Beschreibung |
| Return | Table | Allokiertes Tabellenobjekt | |
| org | Table | 0 | Original 0 : Erzeuge einen neuen leeren Tabellenverweis sonst : Lege eine Kopie des Originales an. Es wird nur der Verweis kopiert, nicht die eigentliche Tabelle. |
static Table table::assign(Table dest, Table src)
übernehme den Inhalt eines Tabellenverweises in einen anderen Tabellenverweis. Der Inhalt der Variable src wird in dest kopiert. Es wird nur der Verweis kopiert, nicht die eigentliche Tabelle.
| Name | Typ | Default | Beschreibung |
| Return | Table | dest oder 0 im Fehlerfall | |
| dest | Table | - | Ziel der Zuweisung |
| src | Table | - | Original |
static int table::release(Table t)
Lösche ein Tabellenobjekt aus dem Speicher. Zeigt das Objekt auf eine existierende Dokumenttabelle, bleibt diese Referenz unberührt.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| t | Table | - | Gültiges Tabellenobjekt. Das Objekt muss nicht auf eine existierende Dokumenttabelle zeigen. |
static int table::defined(Table t)
Ist die Tabellenreferenz definiert?
| Name | Typ | Default | Beschreibung |
| Return | int | 0 Variable nicht definiert 1 Die Referenz ist definiert und zeigt auf eine gültige Tabelle |
|
| t | Table | - | Zu prüfende Tabellenreferenz |
static int table::is_valid(Table t)
Ist die Tabellenreferenz definiert? Der Aufruf ist identisch mit defined.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 Variable nicht definiert 1 Die Referenz ist definiert und zeigt auf eine gültige Tabelle |
|
| t | Table | - | Zu prüfende Tabellenreferenz |
static int table::create(
Table T,
ItemRef frameRef,
int rows,
int cols,
int insertion = 0,
int removes = 0,
float height = 20.0,
float width = 30.0,
int header = 0,
int footer = 0,
int placeholderRelative = 1,
char* tableStyle = 0)
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Mit table::alloc erzeugtes Tabellenobjekt |
| frameRef | ItemRef | - | [Ab Version 1.1.6] Rahmen, in dessen Text die Tabelle angelegt werden soll. 0 : Aktueller Skriptrahmen sonst : Gültige Referenz eines Textrahmens Von Illustrator® wird der Parameter ignoriert. |
| rows | int | - | Zeilenanzahl |
| cols | int | - | Spaltenzahl |
| insertion | int | 0 | Einfügeposition im Text |
| removes | int | 0 | Wieviele Zeichen sollen vor dem Einfügen gelöscht werden? kEnd : Bis zum Textende Von Illustrator® wird der Parameter ignoriert. |
| height | float | 20.0 | Höhe der Tabellenzellen in Punkten. bis v4.3 R34952
|
| width | float | 30.0 | Breite der Tabellenzellen in Punkten 0.0 : Spalten so breit machen, dass die Tabelle so breit wie der Rahmen wird. Entspricht dem manuellen Anlagen einer Tabelle in InDesign®. |
| header | int | 0 | Anzahl der Kopfzeilen |
| footer | int | 0 | Anzahl der Fusszeilen |
| placeholderRelative | int | 1 | Unbenutzt |
| tableStyle | char* oder String | 0 | Tabellenstil 0 oder "" : Basisstil für Tabellen verwenden |
Füge an den Anfang des Textes des aktuellen Rahmens eine 2x4-Tabelle ein.
int main ()
{
int T = table::alloc ();
if (!T) return 0;
if (table::create (T, 0, 2, 4) != 0)
{
showerror ("Die Tabelle konnte nicht angelegt werden");
}
table::release (T);
return 0;
}
Ersetze den aktuellen Platzhaltertext durch den Text "AAA(2x2-Tabelle)XXX.". In Skripten, die nicht durch Platzhalter ausgelöst werden (Palettenskripte, Gestaltzungsregeln, ...) wird der gesamte Text des aktuellen Skriptrahmen ersetzt.
#include "internal/types.h" #include "internal/text.h"
int main () { int T = table::alloc ();
if (!T) return 0;
textmodel::replace ("AAAXXX", 0, kEnd);
table::create (T, gFrame, 2, 2, 3, 0, 20.0, 20.0); table::release (T);
return 0; }
Das dritte Beispiel prüft die aktuelle Textauswahl des Dokumentes: Ist die Textauswahl innerhalb einer Tabellenzelle, wird der gesamte Inhalt dieser Zelle durch eine 2x2-Untertabelle mit einer Kopf- und einer Fußzeile ersetzt.
#include "internal/types.h" #include "internal/text.h"
int main () { Table t = table::alloc(); Table u = table::alloc(); ItemRef f = item::alloc(); int start, len, col, row;
if ( textmodel::selection (&start,&len,f,0,t,&col,&row)==0 && table::defined (t) && table::get_textpos (t,col,row,&start,&len) == 0) { table::create (u, f, 2 , 2, start, len, 20.0, 20.0, 1, 1, 0); } else beep ();
table::release (t); table::release (u); item::release (f);
return 0; }
static int table::remove(ItemRef frameRef, int index)
Löschen einer Tabelle und ihres gesamten Inhaltes.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| Index-definierte Tabelle | |||
| frameRef | ItemRef | - | [Ab Version 1.1.6] Rahmen, aus dessen Text die Tabelle entfernt werden soll. 0 : aktueller Skriptrahmen |
| index | int | - | 0-basierter Tabellenindex gemäß Textposition |
| Referenz-definierte Tabelle | |||
| tableRef | ItemRef | - | Gültige Tabellenreferenz |
static int table::get(
Table T,
ItemRef frameRef,
int nth,
int textStart = -1,
int textLen = -1)
Hole die n-te Tabelle des Textes des gegebenen Rahmens. Sortierreihenfolge ist die Textposition der Tabelle.
Beachten Sie bitte, dass Tabellen in Textketten immer zum Textmodel des ersten Rahmens der Kette gehören. Wird die Funktion table::get auf einen Fortsetzungrahmen einer Textkette angewendet, wird daher automatisch im Textmodell des ersten Rahmens der Textkette nach Tabellen gesucht.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Mit table::alloc erzeugtes Tabellenobjekt |
| frameRef | ItemRef | - | [Ab Version 1.1.6] Rahmen, in dessen Text die Tabelle gesucht werden soll. 0 : Aktueller Skriptrahmen sonst : Gültige Referenz eines Textrahmens |
| nth | int | - | 0-basierter Index der Tabelle gemäß ihrer Textposition |
| textStart | int | -1 | Suche die i-te Tabelle erst ab einer bestimmten Textposition. Der Index index ist
0-basiert. -1 : Suche im gesamten Text kSelection : Suche in der aktuellen Auswahl |
| textLen | int | -1 | Suche die i-te Tabelle nur in einem Teilbereich des Textes. Der Index index ist
0-basiert. kEnd : Suche bis zum Textende |
Hole die erste Tabelle des aktuellen Skriptrahmens und schreibe deren Größe ins Log.
int main ()
{
Table T = table::alloc ();
table::get (T, 0, 0);
if (table::is_valid (T)) wlog ("", "First table has size R%d x C%d\n",
table::rows (T),
table::columns (T));
else wlog ("", "No table found in frame %d\n", item::getint (gFrame));
table::release (T);
return 0;
}
Das Beispiel sammelt alle Tabellen, die ganz oder teilweise auf einer gegebenen Dokumentseite sichtbar sind. Zur Visualisierung werden die Inhalte der ersten Spalten der gefundenen Tabellenzeilen ins Log geschrieben.
#pragma plain
// ******************************************************************************
#include "internal/table.h" #include "internal/types.h" #include "internal/text.h"
// ******************************************************************************
int stPageNum = 1;
// ******************************************************************************
// Collect al tables visible on the give page // For every table found, the given int-array *tables* is filled with // four values: // UID of frame // UID of the table // First visible row // Last visible row // The function return the number of tables found // (not the number of elements filled in in *tables*!). // int get_table_on_page (int pg, int * tables) { int result = 0; // number of tables found int i; ItemList frames = itemlist::pageframes (pg); ItemRef fr = item::alloc (); int t, pos, len, fi, la; Table tin = table::alloc (); Table tout = table::alloc (); Table T = table::alloc ();
itemlist::sort (frames, kSortColwise); for (i = 0; i< itemlist::length (frames); i++) { itemlist::get (frames, fr, i); pos = frame::get_textpos (fr, &len, tin, &fi, tout, &la); if (pos >= 0 && len > 0) { if (table::is_valid (tin)) { tables [result] = item::getint (fr); tables [result + 1] = item::getint (tin); tables [result + 2] = fi; if (item::getint (tin) == item::getint (tout)) tables [result + 3] = la; else tables [result + 3] = table::rows (tin) - 1; result += 4; }
for (t = 0; t < table::count (fr, pos, len); t++) { table::get (T, fr, t, pos, len); tables [result] = item::getint (fr); tables [result + 1] = item::getint (T); tables [result + 2] = 0; if (item::getint (T) == item::getint (tout)) tables [result + 3] = la; else tables [result + 3] = table::rows (T) - 1; result += 4; } } }
itemlist::release (frames); item::release (fr); table::release (tin); table::release (tout); table::release (T);
return result / 4; }
// ****************************************************************************** // This is a simple example of writing a table cells text content. // int w_cell (Table T, int r, int c) { String txt = string::alloc ();
table::cell::get_text (T, c, r, txt);
wlog ("", " ");
if (r < table::rows (T, kHeaderRows)) { wlog ("", "Head %d x %d\t: ", r, c); } else if (r >= table::rows (T, kHeaderRows) + table::rows (T, kBodyRows)) { wlog ("", "Foot %d x %d\t: ", r - (table::rows (T, kHeaderRows) + table::rows (T, kBodyRows)), c); } else { wlog ("", "Body %d x %d\t: ", r - table::rows (T, kHeaderRows), c); }
wlog ("", "'%s'", txt); wlog ("", "\n");
string::release (txt); return 0; }
// ******************************************************************************
// Main function starts here // int main () { int tables [1000*4]; // allocate memory for 1000 entries int t; // number of tables found om the given page int i, r, idx; ItemRef docRef = document::current (); Table T = table::alloc ();
// Real work is done here // After the call, *tables* contains the *t* quadruplets // found on the specified page: // // *t* times: // UID of frame // UID of the table // First visible row // Last visible row // t = get_table_on_page (stPageNum, tables);
// Whatever is to be done with the tables found - // Here is an example of a simple output of the // first column in each frame. // // You can skip or replace that be *what ever you want*. // for (i = 0; i < t; i++) { // Pay attention to the index *idx*: Each entry in *tables* // occupies four elements of that int array. idx = 4 * i;
wlog ("", "=== Frame %d has table %d with rows %d - %d ===\n", tables [idx], tables [idx + 1], tables [idx + 2], tables [idx + 3]);
// Make T a valid ItemRef. For to do that, we need two things: // 1. The 'database' of the document. This we find in document::current // 2. The UID of the table. // item::define (T, docRef, tables [idx + 1]);
// In case of splited tables, write the header rows again // if (tables [idx + 2] > 0) { for (r = 0; r < table::rows (T, kHeaderRows); r++) { w_cell (T, r, 0); } }
// Write the visible rows // for (r = tables [idx + 2]; r <= tables [idx + 3]; r++) { w_cell (T, r, 0); }
// In case of splited tables, write the footer rows again if (tables [idx + 3] < table::rows (T) - 1) { for (r = table::rows (T, kHeaderRows) + table::rows (T, kBodyRows); r < table::rows (T); r++) { w_cell (T, r, 0); } } }
return 0; }
// ******************************************************************************
static int table::count(
ItemRef frameRef,
int textStart = -1,
int textLen = -1)
Anzahl der Tabellen im Text. Der erste Parameter der Funktion ist neu ab Version 1.1.6. Ältere Versionen verwenden die Funktion ohne diesen Parameter.
| Name | Typ | Default | Beschreibung |
| Return | int | Anzahl der Tabellen im Text | |
| frameRef | ItemRef | - | [Ab Version 1.1.6] Rahmen, in dessen Text die Tabelle angelegt werden soll. 0 : Aktueller Skriptrahmen sonst : Gültige Referenz eines Textrahmens |
| textStart | int | -1 | Suche die i-te Tabelle erst ab einer bestimmten Textposition. -1 : Zähle im gesamten Text kSelection : Zähle in der aktuellen Auswahl |
| textLen | int | -1 | Zähle nur in einem Teilbereich des Textes. kEnd : Zähle bis zum Textende |
Wieviele Tabellen enthält der Text und wie groß sind diese Tabellen?
int main ()
{
int i = 0;
Table T = table::alloc ();
int cnt = table::count (0);
if (!T) return 0;
showmessage ("%d",cnt);
while (i < cnt)
{
table::get (T, 0, i);
showmessage ("Tabelle %d : %d x %d",
i,
table::rows (T),
table::columns (T));
i++;
}
table::release (T);
return 0;
}
static int table::rows(Table T, int rowType = 0)
Anzahl der Zeilen einer Tabelle.
| Name | Typ | Default | Beschreibung |
| Return | int | Zeilenzahl | |
| T | Table | - | verwendete Tabelle |
| rowType | int | kAllRows | Welche Zeilen sollen gezählt werden? In InDesign® 2.0 gibt der Aufruf
immer die Anzahl aller Tabellenzeilen zurück. kAllRows kHeaderRows kBodyRows kFooterRows |
Zähle die Zeilen einer Tabelle.
#include "internal/table.h"
int main () { Table T = table::alloc ();
if (!T) return 0; if (table::get (T, 0, 0) != 0) { showmessage ("Keine Tabelle im Text"); table::release (T); return 0; }
showmessage ("%d Zeile(n)", table::rows (T, kAllRows)); showmessage ("%d Kopfzeile(n)", table::rows (T, kHeaderRows)); showmessage ("%d Bodyzeile(n)", table::rows (T, kBodyRows)); showmessage ("%d Fußzeile(n)", table::rows (T, kFooterRows));
table::release (T);
return 0; }
static int table::get_rows(Table T, int rowType = 0)
Synonym für rows.
static int table::columns(Table T)
Anzahl der Spalte einer Tabelle.
| Name | Typ | Default | Beschreibung |
| Return | int | Spaltenzahl | |
| T | Table | - | verwendete Tabelle |
static int table::get_columns(Table T)
Synonym für columns
static int table::get_cellsize(
Table T,
int x,
int y,
int insetRelative,
float* width,
float* height)
Größe einer Tabellenzelle in Punkten
static int table::get_cellbox(
Table T,
int x,
int y,
int insetRelative,
float* left,
float* top,
float* right,
float* bottom,
ItemRef parentRef = 0,
int* first_row_in_frame = 0,
int* pg = 0,
char* lay = 0)
Ermittle den Rahmen einer Tabellenzelle. Die Angaben erfolgen in Punkten.
static int table::get_cellinsets(
Table T,
int x,
int y,
float* left,
float* top,
float* right,
float* bottom)
Insets einer Tabellenzelle
static int table::insert_rows(
Table T,
int at,
int how_many,
int before_or_after = eAfter,
float height = 0.0,
int clearTags = 0)
Einfügen von Zeilen in eine Tabelle. Die Funktion fügt wahlweise vor oder nach der angegebenen Zeile die gewünschte Anzahl Zeilen in die Tabelle ein. Ist die angegebenen Zeile eine Kopf- oder Fußzeile werden entsprechend Kopf- oder Fußzeilen eingefügt.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| at | int | - | Wo sollen die Zeilen eingefügt werden? < 0 : Erste Körperzeile ≥ Zeilenzahl inkl. Kopf- und Fußzeilen : Letzte Körperzeile sonst : 0-basierter Zeilenindex. Zeigt der Index auf eine Kopf- oder Fußzeile, werden entsprechend Kopf- oder Fußzeilen angelegt. |
| how_many | int | - | Wieviele Zeilen sollen eingefügt werden? |
| before_or_after | int | eAfter | eBefore : vor der Zeile at einfügen eAfter : nach der Zeile at einfügen |
| height | float | InDesign® Einstellung | Zeilenhöhe. Fehlt der Wert oder ist 0.0, ermittelt InDesign® eine Standardhöhe |
| clearTags | int | 0 | Sollen eventuelle Platzhalter aus den neuen Tabellenzellen entfernt werden? 1 : Ja. Diese Einstellung ist dringend empfohlen. Sie ist nur aus Gründen der Rückwärts-Kombatibilität nicht Default. 0 : Nein |
Ersetze den Text des aktuellen Skriptrahmens durch eine 2x4 Tabelle. Zu Demonstrationszwecken werden danach vier weitere Zeilen an die neue Tabelle angefügt.
int main ()
{
int T = table::alloc ();
if (!T) return 0;
if (table::create (T, 2, 4, 0, -1) != 0)
{
table::release (T);
return 0;
}
table::insert_cols (T, 1, 4, eAfter, 12.0, 1);
table::release (T);
return 0;
}
static int table::insert_cols(
Table T,
int at,
int how_many,
int before_or_after = eAfter,
float width = 0.0,
int clearTags = 0)
Einfügen neuer Spalten in eine Tabelle. Die Funktion fügt wahlweise vor oder nach der angegebenen Spalte die gewünschte Anzahl Spalten in die Tabelle ein.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenrefefrenz |
| at | int | - | Wo sollen die Zeilen eingefügt werden? < 0 : Erste Spalte ≥ Spaltenzahl : Letzte Spalte sonst : 0-basierter Spaltenindex |
| how_many | int | - | Wieviele Zeilen sollen eingefügt werden? |
| before_or_after | int | eAfter | eBefore : vor der Spalte at einfügen eAfter : nach der Spalte at einfügen |
| width | float | InDesign®-Einstellung | Spaltenbreite. Fehlt der Wert oder ist 0.0, ermittelt InDesign® eine Standardbreite. |
| clearTags | int | 0 | Sollen eventuelle Platzhalter aus den neuen Tabellenzellen entfernt werden? 1 : Ja. Diese Einstellung ist dringend empfohlen. Sie ist nur aus Gründen der Rückwärts-Kombatibilität nicht Default. 0 : Nein |
static int table::resize_rows(
Table T,
int at,
int how_many,
float height,
float min_height =-1.0,
float max_height =-1.0)
Verändere die Höhe von Tabellenzeilen einer Tabelle. Neben der aktuellen Zeilehöhe sind auch die maximale und minimale Zeilenhöhe veränderbar. InDesign® nutzt diese Angaben, um das Aussehen von Tabellen zu optimieren. Liegt die neue Zeilenhöhe außerhalb der aktuellen Werte von Minimum und Maximum werden diese Grenzen entsprechend geändert. Wollen Sie Minimum und/oder Maximum verändern, geben sie für die Höhe den Wert 0.0 an. Zum Verändern von Spaltenbreiten verwenden sie die analoge Funktion resize_cols.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| at | int | - | Erste Zeile ,die geändert werden soll. |
| how_many | int | - | Wieviele Zeilen sollen verändert werden? -1 : Alle weiteren Zeilen inklusive at |
| height | float | - | Neue Höhe der Zeile(n) 0.0 : Angabe ignorieren und min_height und max_height verwenden Werte > 0.0 werden nur aus Gründen der Rückwärtskompatibilität unterstützt. Verwenden Sie bitte die Parameter min_height und max_height |
| min_height | float | -1.0 | Neue Minimalhöhe < 0.0 : Angabe ignorieren. Von Illustrator® wird der Parameter ignoriert. |
| max_height | float | -1.0 | Neue Maximalhöhe < 0.0 : Angabe ignorieren. Sind min_height und max_height gleich und größer 0, bekommen die Zeilen eine feste Höhe. Sonst kann InDesign® die Zeilenhöhe im gegebenen Bereich variieren. Von Illustrator® wird der Parameter ignoriert. |
table::resize_rows (T, at, rows, height, hmin, hmax);
Ändere alle Zeilenhöhen und Spaltenbreiten einer Tabelle.
int main ()
{
Table T = table::alloc ();
if (!T) return 0;
if (table::get (T, 0, 0) != 0)
{
table::release (T);
return 0;
}
table::resize_cols (T, 0, -1, 8.0);
table::resize_rows (T, 0, -1, 8.0);
table::release (T);
return 0;
}
static int table::resize_cols(
Table T,
int at,
int how_many,
float width)
Verändere die Breite von Tabellenspalten einer Tabelle.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| at | int | - | Erste Spalte, die geändert werden soll. |
| how_many | int | - | Wieviele Spalten sollen verändert werden? -1 : Alle weiteren Spalten inklusive at |
| width | float | - | Neue Breite der Spalte(n). |
Ändere alle Zeilenhöhen und Spaltenbreiten einer Tabelle.
int main ()
{
Table T = table::alloc ();
if (!T) return 0;
if (table::get (T, 0, 0) != 0)
{
table::release (T);
return 0;
}
table::resize_cols (T, 0, -1, 8.0);
table::resize_rows (T, 0, -1, 8.0);
table::release (T);
return 0;
}
static int table::move_rows(
Table T,
int at,
int how_many,
int to,
int duplicate = 0,
int* cl = 0,
int* cr = 0)
Verschieben von Zeilen innerhalb einer Tabelle.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| at | int | - | 0-basierter Zeilenindex der ersten zu verschiebenden Zeile |
| how_many | int | - | > 0 : Anzahl der Zeilen, die verschoben werden sollen. Durch diese Aktion können Zellverbindungen aufgelöst werden!
In comet_pdf wird diese Angabe ignoriert und immer 0 verwendet! ≤ 0 : Mindestens eine Zeile wird verschoben. Enthält die Zeile vertikale verbundene Zellen, werden die betroffenen Zeilen ebenfalls verschoben. |
| to | int | - | 0-basierter Zielindex der Verschiebung. Beachten Sie bitte, dass Kopfzeilen nur innerhalb
des Kopfbereiches der Tabelle verschoben werden können, Köperzeilen nur innerhalb des Tabellenkörpers und Fußzeilen nur
innerhalb des Tabellenfußes. -1 : Als letzte Zeile anfügen. Die Funktion prüft, ob Kopf-, Körper- oder Fußzeilen verschoben werden und berechnet den entsprechenden Index selbstständig. |
| duplicate | int | 0 | Zeilen kopieren (statt nur zu verschieben). Von comet_pdf wird der Parameter ignoriert! |
| cl | int* | 0 | Bei erfolgreicher Ausführung enthält die Variable den 0-basierten Index der ersten verschobenen (duplizierten) Zeile. |
| cr | int* | 0 | Bei erfolgreicher Ausführung enthält die Variable den 0-basierten Index der ersten Zeile hinter *cl, die nicht mehr verschoben/dupliziert wurde. |
static int table::move_cols(
Table T,
int at,
int how_many,
int to,
int duplicate = 0,
int* cl = 0,
int* cr = 0)
Verschieben von Spalten innerhalb einer Tabelle.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| at | int | - | 0-basierter Index der ersten zu verschiebenden Spalte |
| how_many | int | - | > 0 : Anzahl der Spalten, die verschoben werden sollen. Durch diese Aktion können Zellverbindungen aufgelöst werden!
In comet_pdf wird diese Angabe ignoriert und immer 0 verwendet! ≤ 0 : Mindestens eine Spalte wird verschoben. Enthält die Zeile horizontal verbundene Zellen, werden die betroffenen Spalten ebenfalls verschoben. |
| to | int | - | 0-basierter Zielindex der Verschiebung. -1 : Als letzte Spalte anfügen. |
| duplicate | int | 0 | Spalten kopieren (statt nur zu verschieben). Von comet_pdf wird der Parameter ignoriert! |
| ct | int* | 0 | Bei erfolgreicher Ausführung enthält die Variable den 0-basierten Index der ersten verschobenen (duplizierten) Spalte. |
| cb | int* | 0 | Bei erfolgreicher Ausführung enthält die Variable den 0-basierten Index der ersten Spalte hinter *ct, die nicht mehr verschoben/dupliziert wurde. |
static int table::mirror(Table T)
Vertausche die Spalten einer Tabelle. Die Funktion vertauscht außer den Spalten auch die rechten und linken Zellkanten miteinander. Zusätzlich werden die Angaben zu alternierenden Spalten an die Spieglung angepasst.
Beachten Sie bitte folgenden Einschränkugen der Funktion:
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
static int table::remove_rows(
Table T,
int at,
int how_many)
Löschen von Zeilen einer Tabelle. Die Funktion löscht auch Kopf- und Fußzeilen. Sie geben die erste zu löschende Zeile und die Anzahl an.
Beim Versuch, alle Body-Zeilen der Tabelle zu löschen, erzeugt die Funktion den Fehler tableIndexErr (= 12).
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| at | int | - | Wo sollen die Zeilen gelöscht werden? |
| how_many | int | - | > 0 : Anzahl der Zeilen, die gelöscht werden sollen -1 : Alle weiteren Zeilen inklusive at |
table::remove_rows (T, at, rows); table::remove_cols (T, at, cols);
Hole die erste Tabelle des aktuellen Textes. Wenn keine Tabelle enthalten ist, zeige eine Fehlermeldung. Aus der gefundenen Tabelle werden die dritte und vierte Spalte gelöscht.
int main ()
{
Table T = table::alloc ();
if (!T) return 0;
if (table::get (T, 0, 0) != 0)
{
table::release (T);
showerror ("Der Text enthält keine Tabelle.");
return 0;
}
table::remove_rows (T, 2, 2);
table::release (T);
return 0;
}
static int table::remove_cols(
Table T,
int at,
int how_many)
Löschen von Spalten in eine Tabelle. Sie geben die erste zu löschende Spalte und die Anzahl an.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| at | int | - | Wo sollen die Spalten gelöscht werden? |
| how_many | int | - | > 0 Anzahl der Spalten -1 : Alle weiteren Spalten inklusive at |
static int table::convert_to_headerrows(Table T, int rows = 1)
Umwandeln normaler Tabellenzeilen in Kopfzeilen. Als Anfangszeile wird immer die erste normale Tabellenzeile verwendet. Nach der Umwandlung muss die Tabelle noch mindestens eine normale Zeile enthalten. Die Funktion schränkt den Bereich der umzuwandelnden Zeilen bei Bedarf selbst ein.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Zieltabelle |
| rows | int | 1 | Anzahl der normalen Zeilen, die in Kopfzeilen umgewandelt werden sollen. Die Anzahl wird bei Bedarf auf rows (T, kBodyRows) - 1 eingeschränkt. |
static int table::convert_to_bodyrows(
Table T,
int at,
int rows = 1)
Umwandeln von Kopf- oder Fusszeilen in normale Tabellenzellen. Die Umwandlung muß immer so geschehen, dass die Kopf- bzw. Fußzeilenbereiche nicht unterbrochen werden.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Zieltabelle |
| at | int | - | Erste Zeile (0-basiert), die umgewandelt werden soll. |
| rows | int | 1 | Anzahl Zeilen, die in normale Zeilen umgewandelt werden sollen. Die Anzahl wird bei Bedarf auf rows (T, kBodyRows) - 1 eingeschränkt. |
static int table::convert_to_footerrows(Table T, int rows = 1)
Umwandeln normaler Tabellenzeilen in Fußzeilen. Als Anfangszeile wird immer die Zeile verwendet, die rows Zeilen über der ersten Fusszeile liegt. Die Funktion schränkt den Bereich der umzuwandelnden Zeilen bei Bedarf selbst ein.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Zieltabelle |
| rows | int | 1 | Anzahl der normalen Zeilen, die in Fusszeilen umgewandelt werden sollen. Die Anzahl wird bei Bedarf auf rows (T, kBodyRows) - 1 eingeschränkt. |
static int table::colorize(
Table T,
int left,
int top,
int rigth,
int bottom,
char* color_name,
float tint =0.0)
Setze die Füllfarbe von Tabellenzellen. Die Farbe kann wahlweise über die Farbfelder oder über RGB festgelegt werden. Um Zelln mit CMYK-Farben zu füllen, verwenden Sie table::colorize_cmyk.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| left | int | - | erste Spalte (0-basiert) |
| top | int | - | erste Zeile (0-basiert) |
| right | int | - | >= 0 : Erste Spalte, die nicht mehr bearbeitet werden soll (0-basiert) -1 : Alle weiteren Spalten der Tabelle |
| bottom | int | - | >= 0 : Erste Zeile, die nicht mehr bearbeitet werden soll(0-basiert) -1 : Alle weiteren Zeilen der Tabelle |
| Farbdefintion über den Namen eines Farbfeldes | |||
| color_name | String oder char* | - | Name einer Farbdefinition aus den Farbfeldern oder Standardfarbe "" : Farbe unverändert lassen |
| tint | float | 100.0 | Deckkraft der Farbe in % (0.0-100.0) -1.0 : unverändert lassen |
| Farbdefintion über RGB | |||
| red | int | - | Rotanteil der Farbe (0-255) |
| green | int | - | Grünanteil der Farbe (0-255) |
| blue | int | - | Blauanteil der Farbe (0-255) |
| tint | float | 100.0 | Deckkraft der Farbe in % (0.0-100.0). Die Angabe wird nur ausgewertet, wenn ein Farbefeldname (new_name)angegeben ist. -1.0 : unverändert lassen |
| new_name | String oder char* | "" | Ist ein Name angegeben wird die verwendete Farbe unter diesem Namen in den Farbfeldern abgelegt |
In der ersten Tabelle des Textes soll die zweite Spalte der zweiten und dritten Zeile rot gefärbt werden.
int main ()
{
Table T = table::alloc ();
if (!T) return 0;
if (table::get (T, 0, 0) != 0)
{
table::release (T);
return 0;
}
table::colorize (T, 1, 1, 2, 3, 255, 30, 30, 100.0);
table::release (T);
return 0;
}
static int table::colorize_cmyk(
Table T,
int left,
int top,
int right,
int bottom,
float c,
float m,
float y,
float k,
float tint = 100.0,
char* new_name = 0)
Setze die Füllfarbe von Tabellenzellen mit Hilfe der CMYK-Werte der Füllfarbe. Um Zellfarben mit Farbfeldern oder RGB-Farben zu setzen, verwenden Sie table::colorize.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| left | int | - | erste Spalte (0-basiert) |
| top | int | - | erste Zeile (0-basiert) |
| right | int | - | >= 0 : Erste Spalte, die nicht mehr bearbeitet werden soll (0-basiert) -1 : Alle weiteren Spalten der Tabelle |
| bottom | int | - | >= 0 : Erste Zeile, die nicht mehr bearbeitet werden soll(0-basiert) -1 : Alle weiteren Zeilen der Tabelle |
| c, m, y, k | float, float, float, float - | Farbanteile (0.0 - 1.0) | |
| tint | float | 100.0 | Deckkraft der Farbe in % (0.0-100.0). Die Angabe wird nur ausgewertet, wenn ein Farbefeldname (new_name)angegeben ist. -1.0 : unverändert lassen |
| new_name | String oder char* | "" | Ist ein Name angegeben wird die verwendete Farbe unter diesem Namen in den Farbfeldern abgelegt |
static int table::colorize_rows(
Table T,
int at,
int how_many,
char* color_name,
float tint = 100.0)
Setze die Füllfarbe von Tabellenzeilen. Die Farbangabe kann wahlweise über den Namen eines Farbfeldes oder über die RGB-Werte der Farbe erfolgen. Um Zellen mit CMYK-Farben zu füllen, verwenden Sie table::colorize_cmyk.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| at | int | - | Wo sollen die Zeilen verändert werden? |
| how_many | int | - | Wieviele Zeilen sollen verändert werden? -1 : Alle weiteren Zeilen inklusive at |
| Farbdefintion über den Namen eines Farbfeldes | |||
| color_name | String oder char* | - | Name einer Farbdefinition aus den Farbfeldern oderStandardfarbe "" : Unverändert lassen |
| tint | float | 100.0 | Deckkraft der Farbe in % (0.0 - 100.0) -1.0 : Unverändert lassen |
| Farbdefintion über RGB | |||
| red | int | - | Rotanteil der Farbe (0-255) |
| green | int | - | Grünanteil der Farbe (0-255) |
| blue | int | - | Blauanteil der Farbe (0-255) |
| tint | float | 100.0 | Deckkraft der Farbe in % (0.0-100.0) ,Werte ungleich 100% können nur angewendet werden,
wenn die Farbe auch einen Namen bekommt. -1.0 : Unverändert lassen |
| new_name | String oder char* | "" | Ist ein Name angegeben wird die verwendete Farbe unter diesem Namen in den Farbfeldern abgelegt |
In der ersten Tabelle des Textes sollen die zweite und dritte Zeile kräftig rot hinterlegt werden.
int main ()
{
Table T = table::alloc ();
if (!T) return 0;
if (table::get (T, 0, 0) != 0)
{
table::release (T);
return 0;
}
table::colorize_rows (T, 1, 2, 255, 30, 30, 100.0);
table::release (T);
return 0;
}
static int table::colorize_cols(
Table T,
int at,
int how_many,
char* color_name,
float tint = 100.0)
Hintergrundfarbe von Tabellenspalten setzen. Siehe colorize_rows.
static int table::set_overprint(
Table T,
int left,
int top,
int right,
int bottom,
int overprint)
Setze die "überdrucken"-Eigenschaft einer oder mehrerer Tabellenzellen.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 or ErrorCode | |
| T | Table | - | verwendete Tabelle |
| left | int | - | erste Spalte (0-basiert) |
| top | int | - | erste Zeile (0-basiert) |
| right | int | - | >= 0 : Erste Spalte, die nicht mehr bearbeitet werden soll (0-basiert) -1 : Alle weiteren Spalten der Tabelle |
| bottom | int | - | >= 0 : Erste Zeile, die nicht mehr bearbeitet werden soll(0-basiert) -1 : Alle weiteren Zeilen der Tabelle |
| overprint | int | - | 0 : Ausschalten 1 : Einschalten |
static int table::inset(
Table T,
int left,
int top,
int right,
int bottom,
int sides,
float new_inset)
Ändere die inneren Abstände des Inhaltes von Zeilen (inset_rows), Spalten (inset_cols) oder Tabellenzellen (inset) vom Zellenrand.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| Zeilen oder Spalten | |||
| at | int | - | Wo sollen die Zeilen/Spalten verändert werden? |
| how_many | int | - | Wieviele Zeilen/Spalten sollen verändert werden? -1 : Alle weiteren Zeilen/Spalten inklusive at |
| Tabellenzellen | |||
| left | int | - | erste Spalte (0-basiert) |
| top | int | - | erste Zeile (0-basiert) |
| right | int | - | >= 0 : Erste Spalte, die nicht mehr bearbeitet werden soll (0-basiert) -1 : Alle weiteren Spalten der Tabelle |
| bottom | int | - | >= 0 : Erste Zeile, die nicht mehr bearbeitet werden soll(0-basiert) -1 : Alle weiteren Zeilen der Tabelle |
| Allgemeine Parameter | |||
| sides | int | - | eLeftSide eRightSide eTopSide eBottomSide eAllSides |
| new_inset | float | - | Abstand in Punkten |
table::inset_rows (T, at, rows, sides, new_inset); table::inset_cols (T, at, cols, sides, new_inset); table::inset (T, l, t, r, b, sides, new_inset);
static int table::rotate(
Table T,
int left,
int top,
int right,
int bottom,
float degrees)
Ausrichtung von Zeilen (inset_rows), Spalten (inset_cols) oder Tabellenzellen (inset). Für die Drehung sind nur Vielfache von 90.0 zulässig.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| Zeilen oder Spalten | |||
| at | int | - | Wo sollen die Zeilen/Spalten verändert werden? |
| how_many | int | - | Wieviele Zeilen/Spalten sollen verändert werden? -1 : Alle weiteren Zeilen/Spalten inklusive at |
| Tabellenzellen | |||
| left | int | - | erste Spalte (0-basiert) |
| top | int | - | erste Zeile (0-basiert) |
| right | int | - | >= 0 : Erste Spalte, die nicht mehr bearbeitet werden soll (0-basiert) -1 : Alle weiteren Spalten der Tabelle |
| bottom | int | - | >= 0 : Erste Zeile, die nicht mehr bearbeitet werden soll(0-basiert) -1 : Alle weiteren Zeilen der Tabelle |
| Allgemeine Parameter | |||
| sides | int | - | Die betroffenen Seiten werden als Summe der folgenden Werte angegeben: eLeftSide eRightSide eTopSide eBottomSide eAllSides |
| degrees | float | - | Winkel in Grad. Für die Drehung sind nur Vielfache von 90.0 zulässig. |
table::rotate_rows (T, at, rows, degrees); table::rotate_cols (T, at, cols, degrees); table::rotate (T, l, t, r, b, degrees);
static int table::stroke(
Table T,
int left,
int top,
int right,
int bottom,
int sides,
...)
Umrahmung von Zeilen (stroke_rows), Spalten (stroke_cols) oder Tabellenzellen (stroke).
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| Zeilen oder Spalten | |||
| at | int | - | Wo sollen die Zeilen/Spalten verändert werden? |
| how_many | int | - | Wieviele Zeilen/Spalten sollen verändert werden? -1 : Alle weiteren Zeilen/Spalten inklusive at |
| Tabellenzellen | |||
| left | int | - | erste Spalte (0-basiert) |
| top | int | - | erste Zeile (0-basiert) |
| right | int | - | >= 0 : Erste Spalte, die nicht mehr bearbeitet werden soll (0-basiert) -1 : Alle weiteren Spalten der Tabelle |
| bottom | int | - | >= 0 : Erste Zeile, die nicht mehr bearbeitet werden soll(0-basiert) -1 : Alle weiteren Zeilen der Tabelle |
| Allgemeine Parameter | |||
| sides | int | - | Die betroffenen Seiten werden als Summe der folgenden Werte angegeben.
Die Angaben
eLeftSide, eRightSide, ... gelten dabei für die Außenkanten
des angegebenen Zellbereiches, nicht für jede einzelne Zelle. eLeftSide eRightSide eTopSide eBottomSide eInteriorRows eInteriorCols eBottomSide eAllSides |
| Es können beliebig viele Wertepaare der folgenden Art folgen | |||
| eWeight, weight | 1, float | - | Linienstärke in Punkten |
| eColor, colName | 2, String oder char* | - | Name einer im Dokument definierten Farbe oder Standardfarbe |
| eRGBColor, r, g, b | 256, int, int, int | - | RGB-Werte der Linienfarbe (jeweils 0-255) |
| eLineType, linetype | 4, int | - | Art der Linie(n) eNone eSolid eThickThick eThinThin eThickThin eThinThick eThickThinThick eThinThickThin seit Version 1.1.19 (8. April 2004): eDashed eDash4X4 eDash3X2 eDots eWavy eStraightHash eRightSlant eLeftSlant eDiamond eJapaneseDots eTriple eTableStrip Von Illustrator® wird der Parameter ignoriert. |
| eTint, tint | 8, float | - | Wie kräftig soll die Farbe sein (0.0-100.0) Der Faktor wird nur für Farben verwendet, die über ihren Namen ausgewählt werden. |
| eOverprint, ov | 16, int | - | Kantenfarbe überdrucken? 0: Nein 1: Ja Von Illustrator® wird der Parameter ignoriert. |
| eGapColor, name | 32, String oder char* | - | Name einer im Dokument definierten Farbe oder einer Standardfarbe für die Zwischenräume in den Kanten (seit Version 1.1.19 8. April 2004)
Von Illustrator® wird der Parameter ignoriert. |
| eGapRGBColor, r, g, b | 257, int, int, int | - | RGB-Farbwerte (jeweils 0-255) für die Zwischenräume in den Kanten (seit Version 1.1.19 8. April 2004)
Von Illustrator® wird der Parameter ignoriert. |
| eGapTint, tint | 64, float | - | Wie kräftig soll die Farbe der Kantenzwischenräume sein (0.0-100.0) (seit Version 1.1.19 8. April 2004) Der Faktor wird nur für Farben verwendet, die über ihren Namen ausgewählt werden. Von Illustrator® wird der Parameter ignoriert. |
| eGapOverprint, ov | 128, int | - | Farber der Kantenzwischenräume überdrucken? (seit Version 1.1.19 8. April 2004) 0: Nein 1: Ja Von Illustrator® wird der Parameter ignoriert. |
Ändere alle inneren Zellkanten eines gegbenenen Zellbereiches.
#include "internal/table.h"
int main () { Table T = table::alloc ();
if (!T) return 0;
if (table::get (T, 0, 0) != 0) { table::release (T); return 0; }
table::stroke ( T, 1, 1, 3, 3, eInteriorRows + eInteriorCols, eWeight, 3.0, eRGBColor, 255, 0, 0, eTint, 0.5 eLineType, eThickThick);
table::release (T);
return 0; }
static int table::reset_stroke(
Table T,
int left,
int top,
int right,
int bottom,
int sides,
int attrib)
Entferne Overrides von Zellumrahmungen eines bestimmten Bereiches. Für Tabellenzeilen/spalten verwenden Sie die Funktionen (reset_stroke_rows) bzw. (reset_stroke_cols).
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| Zeilen oder Spalten (reset_stroke_rows, reset_stroke_cols) | |||
| at | int | - | Wo sollen die Zeilen/Spalten verändert werden? |
| how_many | int | - | Wieviele Zeilen/Spalten sollen verändert werden? -1 : Alle weiteren Zeilen/Spalten inklusive at |
| Tabellenzellen (reset_stroke) | |||
| left | int | - | erste Spalte (0-basiert) |
| top | int | - | erste Zeile (0-basiert) |
| right | int | - | >= 0 : Erste Spalte, die nicht mehr bearbeitet werden soll (0-basiert) -1 : Alle weiteren Spalten der Tabelle |
| bottom | int | - | >= 0 : Erste Zeile, die nicht mehr bearbeitet werden soll(0-basiert) -1 : Alle weiteren Zeilen der Tabelle |
| Allgemeine Parameter | |||
| sides | int | - | Die betroffenen Seiten werden als Summe der folgenden Werte angegeben.
Die Angaben
eLeftSide, eRightSide, ... gelten dabei für die Außenkanten
des angegebenen Zellbereiches, nicht für jede einzelne Zelle. eLeftSide eRightSide eTopSide eBottomSide eInteriorRows eInteriorCols eBottomSide eAllSides |
| attrib | int | - | Summe aus den folgenden Werten: eWeight eColor eLineType eTint eOverprint |
table::reset_stroke_rows (T, at, rows, sides, attrib); table::reset_stroke_cols (T, at, cols, sides, attrib); table::reset_stroke (T, l, t, r, b, sides, attrib);
static int table::split(
Table T,
int left,
int top,
int direction)
Teilen einer Tabellenzellen in vertikaler oder horizontaler Richtung.
Durch das Teilen einer Zelle ensteht eine neue Zeile bzw. Spalte in der Tabelle und die Indizes aller nachfolgenden Zeilen bzw. Spalten verschieben sich um 1.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| left | int | - | Spalte (0-basiert) -1 : Letzte Tabellenspalte |
| top | int | - | Zeile (0-basiert) -1 : Letzte Tabellenzeile |
| direction | int | - | eVertical eHorizontal |
static int table::merge(
Table T,
int left,
int top,
int right,
int bottom,
int copyPolicy = 0,
char* delimText = 0,
int autoExtend = 0)
Verbinden eines Tabellenbereiches zu einer Zelle.
Werden die Zellen ganzer Zeilen und/oder Spalten verbunden, wird dadurch die Anzahl der Zeilen/Spalten der Tabelle geringer. Dadurch ändern sich nachfolgende Zeilen/Spaltenindexe!
Der gewünschte Zellbereich kann so gewählt sein, dass er selbst größere Zellbereiche enthält. Da Zellbereiche immer rechteckig sein müssen, kann InDesign® solche Bereiche nicht anlegen!
Hier ein Beispiel:

Die direkte Verbindung der roten Zelle mit der ersten pinkfarbenen würde zu einem nicht-rechteckigen
Zellbereich führen! Für einen rechteckigen Zellbereich müssten folgende Zeile/Spalten ebenfalls
zum Bereich gehören
Und damit würde die gesamte Tabelle zu einer einzigen Zelle zusammengefasst.
[Ab v4.1 R23334] Die oben beschriebene automatische Bereichsanpassung wird automatisch gemacht, wenn der Parameter autoExtend den Wert 1 bekommt. Sonst liefert die Funktion in den beschriebenen Fällen den Fehler 1303 (cannotMergeCellsErr).
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| left | int | - | Spalte (0-basiert) |
| top | int | - | Zeile (0-basiert) |
| right | int | - | >= 0 : Erste Spalte, die nicht mehr bearbeitet werden soll (0-basiert) -1 : Alle weiteren Spalten der Tabelle |
| bottom | int | - | >= 0 : Erste Zeile, die nicht mehr bearbeitet werden soll (0-basiert) -1 : Alle weiteren Zeilen der Tabelle |
| copyPolicy | int | 0 | Was soll mit den Inhalten der 'alten' Zellen geschehen? 0 : InDesign®-Standardverhalten. Die Inhalte der Zellen werden absatzgetrennt in die gemeinsame Zelle übernommen 1 und 2 : Die Inhalte der Zellen werden durch den Text delimText getrennt. Bei 1 wird dabei von links nach rechts durch alle Zeilen gewandert, bei 2 von oben nach unten durch die Spalten. Sind die Werte benachbarter Zellen gleich, wird der Inhalt jeweils nur einmal übertragen. Die Werte 1 und 2 werden von comet_pdf und Illustrator® nicht unterstützt. |
| delimText | String oder char* | 0 | Trenntext zwischen den Inhalten verschiedener Zellen. Der Trenntext darf
als TaggedText gegeben sein. Bei copyPolicy == 0 wird der Trenntext ignoriert. |
| autoExtend | int | 0 | Verhalten bei Bereichsfehlern, siehe hier 1 : Bereich automatisch vergrößern sonst : Abbruch mit Fehler 1303 (cannotMergeCellsErr) |
static int table::merge_equal(
Table T,
int direction = 0,
int ckeckPgBreaks = 0,
int compareFunction = 0,
int left = 0,
int top = 0,
int right = -1,
int bottom = -1,
int xjustify_h = -1,
int yjustify_h = -1,
int xjustify_v = -1,
int yjustify_v = -1,
int flags = 0,
int* counter = 0)
Verbinden von Zellen mit gleichem Inhalt.
Durch das Verbinden von Zellen können sich Zeilenhöhen ändern. Dadurch können sich Rahmenumbrüche ändern.
[ab v4.1.6 R25052] Neben dem Textinhalt werden auch die Inlines im Text geprüft. Es gilt:
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| direction | int | 0 | In welcher Richtung sollen Zellen verbunden werden? 0 : spaltenweise 1 : zeilenweise 2 : beide Richtungen. Das entspricht zwei Aufrufen der Funktion, zuerst zeilen-, dann spaltenweise |
| ckeckPgBreaks | int | 0 | Sollen beim Verbinden von Zellen Rahmenumbrüche beachtet werden oder nicht? 0 : Nein 1 : Ja. In diesem Fall werden nur Zellbereiche verbunden, die im selben Rahmen der Textkette liegen. Die Rahmenumrüche der Tabelle bleiben also erhalten. |
| compareFunction | int | 0 | Wie soll festgestellt werden ob Tabellenzellen gleich sind? 0 : TaggedText vergleichen 1 : Platzhalter prüfen. In diesem Fall sind Zellen nur dann gleich, wenn enthaltene Platzhalter darin gleich sind. Created/Modified der Platzhalter wird bei dieser Prüfung ignoriert. 2 : Plaintext der Zellen vergleichen. 3 : Plaintext als Nettogewicht der Zellen vergleichen. |
| left | int | 0 | Startspalte des Bereiches, der bearbeitet werden soll (0-basiert) |
| top | int | 0 | Startzeile des Bereiches, der bearbeitet werden soll (0-basiert) |
| right | int | -1 | Ende des Bereiches, der bearbeitet werden soll (0-basiert). Die Angabe enthält die erste Spalte, die nicht mehr bearbeitet werden soll -1 : Ende der Tabelle |
| bottom | int | -1 | Ende des Bereiches, der bearbeitet werden soll (0-basiert). Die Angabe enthält die erste Zeile, die nicht mehr bearbeitet werden soll -1 : Ende der Tabelle |
| xjustify_h | int | -1 | Horizontale Ausrichtung des Zellinhaltes beim Verbinden von Zellen gleicher Zeilen -1 : unverändert lassen 0 : links 1 : zentriert 2 : rechts 3 : Systemeinstellung 4 : Blocksatz, letzte Zeile links 5 : Blocksatz, letzte Zeile zentriert 6 : Blocksatz, letzte Zeile rechts 7 : automatisch 8 : zum Buchrücken 9 : vom Buchrücken weg |
| yjustify_h | int | -1 | Vertikale Ausrichtung des Zellinhaltes beim Verbinden von Zellen gleicher Zeilen -1 : unverändert lassen 0 : oben 1 : mitte 2 : unten |
| xjustify_v | int | -1 | Horizontale Ausrichtung des Zellinhaltes beim Verbinden von Zellen gleicher Spalten -1 : unverändert lassen 0 : links 1 : zentriert 2 : rechts 3 : Systemeinstellung 4 : Blocksatz, letzte Zeile links 5 : Blocksatz, letzte Zeile zentriert 6 : Blocksatz, letzte Zeile rechts 7 : automatisch 8 : zum Buchrücken 9 : vom Buchrücken weg |
| yjustify_v | int | -1 | Vertikale Ausrichtung des Zellinhaltes beim Verbinden von Zellen gleicher Spalten -1 : unverändert lassen 0 : oben 1 : mitte 2 : unten |
| flags | int | 0 | Bitfeld zum Anpassen des Verhaltens der Funktion 1 : Bereits gemergte Zellen dürfen in neue Merges aufgenommen werden. Ist die Option nicht gesetzt, werden Zellen unter einem Zellbereich gleichen Inhaltes nicht zum Zellbereich hinzugefügt. 2 : Suche auch unterhalb/hinter der Startzelle nach Zellbereichen gleichen Inhaltes. Beim Verbinden der Spalten aaa | aaa | bbb | bbb | ccc werden ohne die Option nur die Spalten aaa | aaa zusammengefügt, mit aktivierter Option werden auch die Spalten bbb | bbb zusammengefügt. = 4 : [seit v4.3 R37156] : Werden Merges über die gesamte Tabellenbreite gemacht, werden vor dem Mergen immer zuerst alle Zeilenwiederholungen gelöscht. Ist flags genau 4 werden nach dem Löschen identischer Zeilen keine Merges mehr gemacht. |
| counter | int* | 0 | Anzahl der neu angelegten Zell-Merges nach Ausführung der Funktion |
int main ()
{
Table T = table::alloc ();
int result;
result = table::get (T, 0, 0);
result = table::merge_equal (
T,
0,
1,
1,
0, 0, -1, -1,
1, 1,
1, 1);
wlog ("", "Result = %d\n", result);
return 0;
}
static int table::merge_equal_fr(
Table T,
ItemRef fr = 0,
int compareFunction = 0,
int left = 0,
int right = -1,
int xjustify_h = -1,
int yjustify_h = -1,
int xjustify_v = -1,
int yjustify_v = -1,
int flags = 0,
int* counter = 0)
Verbinden von Zellen mit gleichem Inhalt in einem gegebenen Rahmen. Im Unterschied zu table::merge_equal werden nur Zellen verbunden, die sich im gegebenen Rahmen befinden. Werden diese Zeilen durch den Merge niedriger, werden automatisch weitere mögliche Zellen aus den Folgerahmen in den Merge aufgenommen.
Die Funktion liefert nur in einspaltigen Textrahmen brauchbare Ergebnisse. Für mehrspaltige Textrahmen ist die Funktion nicht geeignet!
In comet_pdf ist die Funktion verfügbar, arbeitet aber wie table::merge_equal!
Im Screenshot sehen Sie eine Tabelle, bei der mit table::merge_equal einige Zellen so hoch werden, dass sie in keinem Rahmen der Textkette mehr angezeigt werden kann.
Im zweiten Screenshot wurde das Mergen nur auf die Zeilen des blauen Rahmens angewendet. Wie Sie sehen verbindet die merge_equal_fr nicht nur die ursprünglichen vier Zeilen des blauen Rahmens sondern "sieht" auch, dass weitere Zeilen in den blauen Rahmen passen, nachdem die ersten vier Zeilen zusammengefügt wurden.
Durch das Verbinden von Zellen können sich Zeilenhöhen ändern. Dadurch können sich Rahmenumbrüche ändern.
Neben dem Textinhalt werden auch die Inlines im Text geprüft. Es gilt:
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode 1244 : Die Tabelle ist nicht in der Textkette von fr Die Funktion liefert nur in einspaltigen Texte brauchbare Ergebnisse. Für mehrspaltige Textrahmen ist die Funktion nicht geeignet! |
|
| T | Table | - | verwendete Tabelle |
| fr | ItemRef | 0 | Gültige Rahmenreferenz. Enthält der Rahmen keine Zeilen der Tabelle T, wird die gesamte Tabelle bearbeitet. 0 : Aktueller Skriptrahmen |
| compareFunction | int | 0 | Wie soll festgestellt werden ob Tabellenzellen gleich sind? 0 : TaggedText vergleichen 1 : Platzhalter prüfen. In diesem Fall sind Zellen nur dann gleich, wenn enthaltene Platzhalter darin gleich sind. Created/Modified der Platzhalter wird bei dieser Prüfung ignoriert. 2 : Plaintext der Zellen vergleichen. 3 : Plaintext als Nettogewicht der Zellen vergleichen. |
| left | int | 0 | Startspalte des Bereiches, der bearbeitet werden soll (0-basiert) |
| right | int | -1 | Ende des Bereiches, der bearbeitet werden soll (0-basiert). Die Angabe enthält die erste Spalte, die nicht mehr bearbeitet werden soll -1 : Ende der Tabelle |
| xjustify_h | int | -1 | Horizontale Ausrichtung des Zellinhaltes beim Verbinden von Zellen gleicher Zeilen -1 : unverändert lassen 0 : links 1 : zentriert 2 : rechts 3 : Systemeinstellung 4 : Blocksatz, letzte Zeile links 5 : Blocksatz, letzte Zeile zentriert 6 : Blocksatz, letzte Zeile rechts 7 : automatisch 8 : zum Buchrücken 9 : vom Buchrücken weg |
| yjustify_h | int | -1 | Vertikale Ausrichtung des Zellinhaltes beim Verbinden von Zellen gleicher Zeilen -1 : unverändert lassen 0 : oben 1 : mitte 2 : unten |
| xjustify_v | int | -1 | Horizontale Ausrichtung des Zellinhaltes beim Verbinden von Zellen gleicher Spalten -1 : unverändert lassen 0 : links 1 : zentriert 2 : rechts 3 : Systemeinstellung 4 : Blocksatz, letzte Zeile links 5 : Blocksatz, letzte Zeile zentriert 6 : Blocksatz, letzte Zeile rechts 7 : automatisch 8 : zum Buchrücken 9 : vom Buchrücken weg |
| yjustify_v | int | -1 | Vertikale Ausrichtung des Zellinhaltes beim Verbinden von Zellen gleicher Spalten -1 : unverändert lassen 0 : oben 1 : mitte 2 : unten |
| flags | int | 0 | Bitfeld zum Anpassen des Verhaltens der Funktion 1 : Bereits gemergte Zellen dürfen in neue Merges aufgenommen werden. Ist die Option nicht gesetzt, werden Zellen unter einem Zellbereich gleichen Inhaltes nicht zum Zellbereich hinzugefügt. 2 : Suche auch unterhalb/hinter der Startzelle nach Zellbereichen gleichen Inhaltes. Beim Verbinden der Spalten aaa | aaa | bbb | bbb | ccc werden ohne die Option nur die Spalten aaa | aaa zusammengefügt, mit aktivierter Option werden auch die Spalten bbb | bbb zusammengefügt. = 4 : [seit v4.3 R37156] : Werden Merges über die gesamte Tabellenbreite gemacht, werden vor dem Mergen immer zuerst alle Zeilenwiederholungen gelöscht. Ist flags genau 4 werden nach dem Löschen identischer Zeilen keine Merges mehr gemacht. 8 : [seit v4.3 R37237 und nur InDesign®] Versuche, eventuell enstandenen Leerraum am unteren Rahmenende mit weiteren Zeilen der Tabelle zu füllen. Leerraum kann dann entstehen, wenn die unteren sichtbaren Zeilen der Tabelle Zellen mit sehr unterschiedlich hohen Inhalten haben und die hohen Inhalte durch Merges eliminiert werden. Das Verfahren ist sehr rechenintensiv. Vor der Verwendung sollten Sie unbedingt an einigen aussagekräften Beispielen ihrer Tabellen prüfen, ob Sie es wirklich benötigen. |
| counter | int* | 0 | Anzahl der neu angelegten Zell-Merges nach Ausführung der Funktion |
static int table::unmerge(
Table T,
int left,
int top)
Hebe die Verbindung mehrerer Tabellenzellen auf. Da sich beim Teilen von Zellen die Nummerierung der Zeilen und Spalten ändert und das Splitten von Zellbereichen dadurch überraschende Ergebnisse liefert, arbeiten die Methoden immer nur auf einzelnen Zellen.
Durch die Auflösung eines Zellbereiches entstehen neue Zeilen und/oder Spalten in der Tabelle. Die Tabelle wird also entsprechend größer und alle nachfolgenden Spalten/Zeilenindexe verschieben sich entsprechend.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| left | int | - | Spalte (0-basiert) |
| top | int | - | Zeile (0-basiert) |
static int table::clear(
Table T,
int left,
int top,
int right,
int bottom)
Lösche den Inhalt von Tabellenzellen.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| left | int | - | erste Spalte (0-basiert) |
| top | int | - | erste Zeile (0-basiert) |
| right | int | - | >= 0 : Erste Spalte, die nicht mehr bearbeitet werden soll (0-basiert) -1 : Alle weiteren Spalten der Tabelle |
| bottom | int | - | >= 0 : Erste Zeile, die nicht mehr bearbeitet werden soll(0-basiert) -1 : Alle weiteren Zeilen der Tabelle |
static int table::set_text(
Table T,
int left,
int top,
char* str,
int insert_pos =0,
int remove_len =-1,
int autoload = 0)
Setze den Text einer Tabellenzelle, siehe hier.
static char* table::get_text(
Table T,
int left,
int top,
char* str,
int fmt = kExportPlain)
Hole den Text einer Tabellenzelle, siehe hier. Der Ergebnisstring muss genügend groß sein, um das Ergebnis aufnehmen zu können.
static int table::get_textpos(
Table T,
int* start,
int* len)
Die Textinhalte von Tabellenzellen werden von InDesign® hinter dem eigentlichen Text als Return-getrennter Text aufbewahrt. Die Funktion gibt Textposition und Länge des kompletten Textinhaltes der Tabelle im Textmodell zurück. Um die Position der Tabelle selbst zu erhalten, verwenden Sie die Funktion table::get_anchorpos.
Die Funktion liefert auch bei Zellen im Übersatz Ergebnisse. Zellen im Übersatz können mit folgenden Anweisungen gefunden werden :
table::cell::get_textpos(T, col, row, &start, &len);
if (textmodel::position_visible (gFrame, start))
{
// Your code
}
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| start | int* | - | Position im Textmodell, an der der Text der Tabellenzellen beginnt. |
| len | int* | - | Länge aller Texte der Zellen der Tabelle. |
Hole alle Inlines der Tabellenzelle, in der sich der Textcursor gerade befindet.
ItemList inlines_of_cell (ItemRef frame, Table T, int row, int col)
{
ItemList inlines = itemlist::inlines (frame);
ItemList cellframes = itemlist::alloc ();
ItemRef f = item::alloc ();
int start, len, pos, i;
table::cell::get_textpos (T, col, row, &start, &len);
for (i = 0; i < itemlist::length (inlines); i++)
{
itemlist::get (inlines, f, i);
pos = frame::inlinepos (f);
if (pos >= start)
{
itemlist::append (cellframes, f);
}
}
itemlist::release (inlines);
return cellframes;
}
int main ()
{
int start, end, row, col;
Table T = table::alloc ();
ItemRef frame = item::alloc ();
ItemList inlines;
textmodel::selection (&start, &end, frame, 0, T, &col, &row);
if (table::is_valid (T))
{
inlines = inlines_of_cell (frame, T, row, col);
wlog ("", "# %d inlines in cell [r%d, c%d]\n", itemlist::length (inlines), row, col);
itemlist::release (inlines);
}
return 0;
}
static int table::get_anchorpos(Table T, int* len = 0)
Textposition und -länge eines Tabellenankers. Die Inhalte von Tabellenzellen werden von InDesign® hinter dem eigentlichen Text als Return-getrennter Text aufbewahrt. Im laufenden Text befindet sich lediglich ein Anker, der auf die Zellentext verweist. Die Textposition des Tabelleninhaltes erhalten Sie mit table::get_textpos.
| Name | Typ | Default | Beschreibung |
| Return | int | -1 oder Textindex des Ankeranfangs | |
| T | Table | - | Gültige Tabellenreferenz |
| len | int* | 0 | Ankerlänge |
static int table::style(
Table T,
int left,
int top,
int right,
int bottom,
int styl = 0,
int on_off= 1,
int start_pos = 0,
int len =-1)
Setze den Textstil von Tabellenzellen. Für bold und italic werden verschiedene Schriftschnitte verwendet. Es ist daher möglich, dass diese Einstellung für einen bestimmten Font nicht gesetzt werden kann. Wird ein nicht existierender Schnitt gesetzt, markiert InDesign® das entsprechende Textstück zwar mit diesem Font, bemerkt aber bei jedem Öffnen des Dokumentes, dass eine Schrift nicht gefunden werden konnte.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| left | int | - | Erste Spalte (0-basiert) |
| top | int | - | Erste Zeile (0-basiert) |
| right | int | - | >= 0 : Erste Spalte, die nicht mehr bearbeitet werden soll (0-basiert) -1 : Alle weiteren Spalten der Tabelle |
| bottom | int | - | >= 0 : Erste Zeile, die nicht mehr bearbeitet werden soll(0-basiert) -1 : Alle weiteren Zeilen der Tabelle |
| styl | int | - | Textstil, wähle eine beliebige Summe der folgenden Werte normal bold italic underline strikeout |
| on_off | int | on | on off |
| start_pos | int | 0 | Textposition pro Zelle, ab der die Formatierung der Zelltextes geändert werden soll |
| len | int | -1 | Länge des Textes pro Zelle, dessen Formatierung geändert werden soll -1 : Bis zum Ende des Zelltextes |
int main ()
{
Table T = table::alloc ();
if (!T) return 0;
if (table::get (T, 0, 0) != 0)
{
table::release (T);
return 0;
}
table::style (T, 0, 1, -1, 3, italic, on);
table::style_rows (T, 1, 0, 3, -1,
strikeout + underline,
on);
table::release (T);
return 0;
}
static int table::capital(
Table T,
int left,
int top,
int right,
int bottom,
int iCap =0,
int start_pos =0,
int len =-1)
Groß- und Kleinschreibung in Tabellenzellen
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| left | int | - | Erste Spalte (0-basiert) |
| top | int | - | Erste Zeile (0-basiert) |
| right | int | - | >= 0 : Erste Spalte, die nicht mehr bearbeitet werden soll (0-basiert) -1 : Alle weiteren Spalten der Tabelle |
| bottom | int | - | >= 0 : Erste Zeile, die nicht mehr bearbeitet werden soll(0-basiert) -1 : Alle weiteren Zeilen der Tabelle |
| iCap | int | - | Textstil, wähle einen beliebigen der folgenden Werte kCapNormal kCapLowercase kCapAll |
| start_pos | int | 0 | Textposition pro Zelle, ab der die Formatierung der Zelltextes geändert werden soll |
| len | int | -1 | Länge des Textes pro Zelle, dessen Formatierung geändert werden soll -1 : Bis zum Ende des Zelltextes |
int main ()
{Table T = table::alloc ();
if (!T) return 0;
if (table::get (T, 0, 0) != 0)
{
table::release (T);
return 0;
}
table::capital (T, 0, 0, 2, 2, kCapLowercase);
table::release (T);
return 0;
}
static int table::position(
Table T,
int left,
int top,
int right,
int bottom,
int iPos =0,
int start_pos =0,
int len =-1)
Textpositionierung in Tabellenzellen
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| left | int | - | Erste Spalte (0-basiert) |
| top | int | - | Erste Zeile (0-basiert) |
| right | int | - | >= 0 : Erste Spalte, die nicht mehr bearbeitet werden soll (0-basiert) -1 : Alle weiteren Spalten der Tabelle |
| bottom | int | - | >= 0 : Erste Zeile, die nicht mehr bearbeitet werden soll(0-basiert) -1 : Alle weiteren Zeilen der Tabelle |
| iCap | int | - | Textstil, wähle einen beliebigen der folgenden Werte kPosNormal kPosHigh kPosLow |
| start_pos | int | 0 | Textposition pro Zelle, ab der die Formatierung der Zelltextes geändert werden soll |
| len | int | -1 | Länge des Textes pro Zelle, dessen Formatierung geändert werden soll -1 : Bis zum Ende des Zelltextes |
int main ()
{
Table T = table::alloc ();
if (!T) return 0;
if (table::get (T, 0, 0) != 0)
{
table::release (T);
return 0;
}
table::position (T, 0, 0, 1, 1, kPosHigh, 1, 2);
table::position (T, 0, 0, 1, 1, kPosLow, 20, 1);
table::release (T);
return 0;
}
static int table::justification(
Table T,
int left,
int top,
int verticalJust,
int horizJust)
Platzierung des Zelleninhaltes. Mit Hilfe der Funktion können die Inhalte von Tabellenzellen sowohl
vertikal als auch horizontal innerhalb der jeweiligen Zelle platziert werden.Für die Funktion wird der Import
#include "internal/table.h"
#include "internal/text.h"
benötigt.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| Adressierung einer Zelle | |||
| left | int | - | 0-basierte Nummer der Spalte |
| top | int | - | 0-basierte Nummer der Zeile |
| Adressierung eines Zellenbereiches | |||
| left | int | - | 0-basierte Nummer der ersten Spalte |
| top | int | - | 0-basierte Nummer der ersten Zeile |
| right | int | - | 0-basierte erste Spaltennummer, die nicht mehr zum Bereich gehört -1 : bis zur letzten Tabellenspalte |
| bottom | int | - | 0-basierte erste Zeilennummer, die nicht mehr zum Bereich gehört -1 : bis zur letzten Zeile |
| verticalJust | int | - | Vertikale Position des Zelleninhaltes kIgnoreJustify Eigenschaft nicht verändern kTop kCenter kBottom kJustify Systemeinstellung |
| horizJust | int | - | Horizontale Position des Zelleninhaltes kIgnoreJustify Eigenschaft nicht verändern kLeft kCenter kRight kJustify systemabhängig kJustifyLeft systemabhängig, letzte Zeile linksbündig kJustifyCenter systemabhängig, letzte Zeile zenteriert kJustifyRight systemabhängig, letzte Zeile rechtsbündig kJustifyAuto systemabhängig, letzte Zeile systemabhängig kJustifyToBinding Am Bund ausrichten kJustifyAwayBinding An der Außenkante ausrichten |
Zentriere die Inhalte aller Zellen der zweiten Tabellenzeile.
table::justification ( t, 0, 1, //1.Spalte, 2. Zeile -1, 2, //bis letzte Spalte kCenter, kJustifyCenter);
static int table::cell_is_overset(
Table T,
int left,
int top,
int* ovIndex = 0)
Hat die Tabellenzelle einen Overset?
static int table::find_overset(
Table T,
int* left,
int* top)
Suche die erste Tabellenzelle, die einen Textoverset hat.
| Name | Typ | Default | Beschreibung |
| Return | int | - 0 : Kein Overset gefunden 1 : Mindestens eine Tabellenzelle hat einen Textoverset |
|
| T | Table | - | verwendete Tabelle |
| left | int* | - | Bei Rückgabewert 1 die 0-baiserte Spalte der ersten Tabellenzelle mit Overset |
| top | int* | - | Bei Rückgabewert 1 die 0-baiserte Zeile der ersten Tabellenzelle mit Overset |
Überprüfe, ob der aktuelle Text eine Tabelle hat und ob dort evtl. ein Text nicht in eine Tabellenzelle passt.
int main ()
{
Table T = table::alloc ();
int l, t;
if (table::get (T, 0, 0) != 0)
{
showmessage ("Keine Tabelle im Text");
table::release (T);
return 0;
}
if (table::find_overset (T, &l, &t))
{
showmessage ("overset (%d, %d)", t+1, l+1);
}
else showmessage ("Alle Zellinhalte passen");
table::release (T);
return 0;
}
static int table::size(
Table T,
int left,
int top,
int right,
int bottom,
float siz =10.0,
int start_pos =0,
int len =-1)
Schriftgröße in Tabellenzellen
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| left | int | - | Erste Spalte (0-basiert) |
| top | int | - | Erste Zeile (0-basiert) |
| right | int | - | >= 0 : Erste Spalte, die nicht mehr bearbeitet werden soll (0-basiert) -1 : Alle weiteren Spalten der Tabelle |
| bottom | int | - | >= 0 : Erste Zeile, die nicht mehr bearbeitet werden soll(0-basiert) -1 : Alle weiteren Zeilen der Tabelle |
| siz | float | - | Textgröße in Punkten |
| start_pos | int | 0 | Textposition pro Zelle, ab der die Formatierung der Zelltextes geändert werden soll |
| len | int | -1 | Länge des Textes pro Zelle, dessen Formatierung geändert werden soll -1 : Bis zum Ende des Zelltextes |
int main ()
{Table T = table::alloc ();
if (!T) return 0;
if (table::get (T, 0, 0) != 0)
{
table::release (T);
return 0;
}
table::size (T, 0, 0, 2, 2, 18.0);
table::release (T);
return 0;
}
static int table::font(
Table T,
int left,
int top,
int right,
int bottom,
char* font_name,
char* face=0,
float siz =-1.0,
int start_pos =0,
int len =-1)
Schriftart in Tabellenzellen. Zusätzlich können Schriftschnitt und -größe gesetzt werden.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| left | int | - | Erste Spalte (0-basiert) |
| top | int | - | Erste Zeile (0-basiert) |
| right | int | - | >= 0 : Erste Spalte, die nicht mehr bearbeitet werden soll (0-basiert) -1 : Alle weiteren Spalten der Tabelle |
| bottom | int | - | >= 0 : Erste Zeile, die nicht mehr bearbeitet werden soll(0-basiert) -1 : Alle weiteren Zeilen der Tabelle |
| font_name | String oder char* | - | Schriftname |
| face | String oder char* | Regular | Schriftschnitt, z.B "Bold Italic" |
| siz | float | - | Textgröße in Punkten |
| start_pos | int | 0 | Textposition pro Zelle, ab der die Formatierung der Zelltextes geändert werden soll |
| len | int | -1 | Länge des Textes pro Zelle, dessen Formatierung geändert werden soll -1 : Bis zum Ende des Zelltextes |
int main ()
{
Table T = table::alloc ();
if (!T) return 0;
if (table::get (T, 0, 0) != 0)
{
table::release (T);
return 0;
}
table::font (T, 0, 0, 2, 2, "Cochin", "Bold Italic", 18.0);
table::release (T);
return 0;
}
static int table::format(
Table T,
int left,
int top,
int right,
int bottom,
char* fmt,
int start_pos =0,
int len=-1,
int rmvOverrides = 1,
char* exceptThese = "")
Setze ein Absatzformat für Tabellenzellen.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| left | int | - | Erste Spalte (0-basiert) |
| top | int | - | Erste Zeile (0-basiert) |
| right | int | - | >= 0 : Erste Spalte, die nicht mehr bearbeitet werden soll (0-basiert) -1 : Alle weiteren Spalten der Tabelle |
| bottom | int | - | >= 0 : Erste Zeile, die nicht mehr bearbeitet werden soll(0-basiert) -1 : Alle weiteren Zeilen der Tabelle |
| fmt | String oder char* | - | Name eines definierten Absatzstiles |
| start_pos | int | Textanfang | Ab hier soll der Stil angewandt werden |
| len | int | bis Textende | Länge des Textes pro Zelle, dessen Formatierung geändert werden soll |
| rmvOverrides | int | 1 | Lokale überschreibungen wie Farbe, hochgestellt, etc. entfernen? 1 : Ja 0 : Nein, lokale überschreibungen behalten |
| exceptThese | String oder char* | "" | Diese Absatzstile nicht ändern. Die Angabe wird nur von comet_pdf ausgewertet! Der String kann mehrere, auch nicht existierende Absatzstile enthalten. Einzelne Stilnamen werden durch Leerzeichen getrennt. Enthält ein Stilname Leerzeichen, muß der Name in Anführungszeichen gesetzt werden. Eine gültige Angabe wäre z.B.: "aaa \"bbb\" ccc |
int main ()
{
Table T = table::alloc ();
if (!T) return 0;
if (table::get (T, 0, 0) != 0)
{
table::release (T);
return 0;
}
table::format (T, 0, 0, 2, 2, "TTT");
table::release (T);
return 0;
}
static int table::skew(
Table T,
int left,
int top,
int right,
int bottom,
float degrees,
int start_pos =0,
int len =-1)
Neigung der Schrift. Die Neigung wird in Grad gemessen von Senkrecht. Die Gradangabe muss im Bereich von -85° - +85° liegen. Negative Werte bewirken eine Textneigung nach links. Werte über 60° erzeugen in der Regel unleserlichen Text. Eigentlich ist die ganze Option fragwürdig.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| left | int | - | Erste Spalte (0-basiert) |
| top | int | - | Erste Zeile (0-basiert) |
| right | int | - | >= 0 : Erste Spalte, die nicht mehr bearbeitet werden soll (0-basiert) -1 : Alle weiteren Spalten der Tabelle |
| bottom | int | - | >= 0 : Erste Zeile, die nicht mehr bearbeitet werden soll(0-basiert) -1 : Alle weiteren Zeilen der Tabelle |
| degrees | char* | - | Neigungswinkel (Pseudo-Kursiv) der einzelnen Buchstaben im Bereich -85.0 - +85.0. |
| start_pos | int | 0 | Textposition pro Zelle, ab der die Formatierung der Zelltextes geändert werden soll |
| len | int | -1 | Länge des Textes pro Zelle, dessen Formatierung geändert werden soll -1 : Bis zum Ende des Zelltextes |
int main ()
{
Table T = table::alloc ();
if (!T) return 0;
if (table::get (T, 0, 0) != 0)
{
table::release (T);
return 0;
}
table::skew (T, 0, 0, 2, 2, 30.0);
table::release (T);
return 0;
}
static int (
Table T,
int left,
int top,
int right,
int bottom,
float degrees,
int start_pos =0,
int len =-1)
Mit spin können die einzelnen Buchstaben eines Textes gedreht werden. Der Text wird dadurch nicht leserlicher, aber wers mag ... . Hier werden die Gradzahlen in mathematischer Drehrichtung, also gegen den Urzeigersinn, erwartet.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| left | int | - | Erste Spalte (0-basiert) |
| top | int | - | Erste Zeile (0-basiert) |
| right | int | - | >= 0 : Erste Spalte, die nicht mehr bearbeitet werden soll (0-basiert) -1 : Alle weiteren Spalten der Tabelle |
| bottom | int | - | >= 0 : Erste Zeile, die nicht mehr bearbeitet werden soll(0-basiert) -1 : Alle weiteren Zeilen der Tabelle |
| degrees | float | - | Drehung der einzelnen Buchstaben dew Zelltextes im Bereich -85.0 - +85.0. |
| start_pos | int | 0 | Textposition pro Zelle, ab der die Formatierung der Zelltextes geändert werden soll |
| len | int | -1 | Länge des Textes pro Zelle, dessen Formatierung geändert werden soll -1 : Bis zum Ende des Zelltextes |
int main ()
{
Table T = table::alloc ();
if (!T) return 0;
if (table::get (T, 0, 0) != 0)
{
table::release (T);
return 0;
}
table::spin (t, 0, 0, 2, 2, 10.0);
table::release (T);
return 0;
}
static int table::textcolor(
Table T,
int left,
int top,
int right,
int bottom,
char* color_name,
float tint =100.0,
int start_pos =0,
int len=-1)
Setze die Farbe der Schrift und die Farbe der Umrahmung der Schrift. Beide Werte können darüberhinaus auch mit einer Transparenz versehen werden.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| left | int | - | erste Spalte (0-basiert) |
| top | int | - | erste Zeile (0-basiert) |
| right | int | - | >= 0 : Erste Spalte, die nicht mehr bearbeitet werden soll (0-basiert) -1 : Alle weiteren Spalten der Tabelle |
| bottom | int | - | >= 0 : Erste Zeile, die nicht mehr bearbeitet werden soll(0-basiert) -1 : Alle weiteren Zeilen der Tabelle |
| Farbdefintion über den Namen eines Farbfeldes | |||
| color_name | String oder char* | - | Name einer Farbdefinition aus den Farbfeldern oder Standardfarbe |
| tint | float | 100.0 | Deckkraft der Farbe in % (0.0-100.0) |
| Farbdefintion über RGB | |||
| red | int | - | Rotanteil der Farbe (0-255) |
| green | int | - | Grünanteil der Farbe (0-255) |
| blue | int | - | Blauanteil der Farbe (0-255) |
| tint | float | 100.0 | Deckkraft der Farbe in % (0.0-100.0) |
| Weitere allgemeine Parameter | |||
| start_pos | int | 0 | Textposition pro Zelle, ab der die Formatierung der Zelltextes geändert werden soll |
| len | int | -1 | Länge des Textes pro Zelle, dessen Formatierung geändert werden soll -1 : Bis zum Ende des Zelltextes |
int main ()
{
Table T = table::alloc ();
if (!T) return 0;
if (table::get (T, 0, 0) != 0)
{
table::release (T);
return 0;
}
table::textcolor_rgb (T,
1, 1, 2, 2,
255, 0, 0, 100.0, "",
0, 8);
table::textstroke_rgb (T,
1, 1, 2, 2,
0, 0, 255, 70.0, "",
"", 0, 8);
table::textcolor_rgb (T,
1, 1, 2, 2,
0, 255, 255, 100.0, "",
9, 5);
table::textstroke_rgb (T,
1, 1, 2, 2,
255, 0, 255, 70.0, "",
9, 5);
table::release (T);
return 0;
}
static int table::textstroke(
Table T,
int left,
int top,
int right,
int bottom,
char* color_name,
float tint=100.0,
int start_pos=0,
int len=-1)
Farbe für die Umrahmung der Buchstaben des Zelltextes.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| left | int | - | Erste Spalte (0-basiert) |
| top | int | - | Erste Zeile (0-basiert) |
| right | int | - | >= 0 : Erste Spalte, die nicht mehr bearbeitet werden soll (0-basiert) -1 : Alle weiteren Spalten der Tabelle |
| bottom | int | - | >= 0 : Erste Zeile, die nicht mehr bearbeitet werden soll (0-basiert) -1 : Alle weiteren Zeilen der Tabelle |
| Farbdefintion über den Namen eines Farbfeldes | |||
| color_name | String oder char* | - | Name einer Farbdefinition aus den Farbfeldern oder Standardfarbe |
| tint | float | 100.0 | Deckkraft der Farbe in % (0.0-100.0) |
| Farbdefintion über RGB | |||
| red | int | - | Rotanteil der Farbe (0-255) |
| green | int | - | Grünanteil der Farbe (0-255) |
| blue | int | - | Blauanteil der Farbe (0-255) |
| tint | float | 100.0 | Farbstärke in Prozent (0.0 - 100.0). Die Angabe wird nur ausgewertet, wenn new_name nicht leer ist. |
| new_name | String oder char* | "" | Name eines neu zu erzeugenden Farbfeldes 0 oder "" : Kein Farbfeld anlegen Sonst : Wenn das Farbfeld noch nicht existiert, lege für die Farbe ein neues Farbfeld an |
| Weitere allgemeine Parameter | |||
| start_pos | int | 0 | Textposition pro Zelle, ab der die Formatierung der Zelltextes geändert werden soll |
| len | int | -1 | Länge des Textes pro Zelle, dessen Formatierung geändert werden soll -1 : Bis zum Ende des Zelltextes |
static int table::align(
Table T,
int left,
int top,
int right,
int bottom,
int alignType,
int last_align,
int startPos = 0,
int len = -1)
Setze die Textausrichtung (links-, rechtsbündig, zentiert, Blocksatz).
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| left | int | - | Erste Spalte (0-basiert) |
| top | int | - | Erste Zeile (0-basiert) |
| right | int | - | >= 0 : Erste Spalte, die nicht mehr bearbeitet werden soll (0-basiert) -1 : Alle weiteren Spalten der Tabelle |
| bottom | int | - | >= 0 : Erste Zeile, die nicht mehr bearbeitet werden soll (0-basiert) -1 : Alle weiteren Zeilen der Tabelle |
| alignType | int | - | Textausrichtung kLeft : linksbündig kCenter : zentiert kRight : rechtsbündig kJustify : Blocksatz |
| last_align | int | - | Ausrichtung der letzten Textzeile von Absätzen.
Die Angabe wird nur im Blocksatz (kJustify) ausgewertet! kLeft kCenter kRight kJustify |
| startPos | int | Textanfang | Ab hier soll der Stil angewandt werden |
| len | int | bis Textende | Länge des Textes pro Zelle, dessen Formatierung geändert werden soll |
int main ()
{
Table T = table::alloc ();
if (!T) return 0;
if (table::get (T, 0, 0) != 0)
{
table::release (T);
return 0;
}
table::skew (T, 0, 0, 2, 2, "TTT");
table::release (T);
return 0;
}
static int table::insertimage(
Table T,
int col,
int row,
char* path,
float w = -1.0,
float h = -1.0,
int align = 5,
float boundingBox = 0.0,
int start = 0,
int len = -1,
int pindex = -2,
int clipToFrame = 0,
int flags = 4,
float tolerance = 0.0,
float minPathSz = 0.0,
float inset = 0.0)
Einfügen eines Bildes in eine Zelle einer Tabelle. Bestehender Text kann teilweise oder ganz gelöscht werden. Das Bild kann skaliert werden. Das Bild wird direkt in das Dokument eingesetzt, nicht als Referenz.
static int table::insert_taggedtext(
Table T,
int col,
int row,
char* text,
int start_pos =0,
int len =-1,
int autoload =0)
Einfügen TaggedText. Bestehender Text kann kann teilweise oder ganz gelöscht werden.
static int table::inserttext(
Table T,
int col,
int row,
char* text,
int start_pos =0,
int len =-1,
int autoload =0)
Wie cell::insert_taggedtext.
static int table::space_before(Table T, float space)
Setze den Abstand vor der Tabelle. Die Angabe erfolgt in Punkten (1/72 dpi).
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| space | float | - | Abstand in Punkten (1/72 dpi) |
static int table::space_after(Table T, float space)
Setze den Abstand nach der Tabelle. Die Angabe erfolgt in Punkten (1/72 dpi).
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| space | float | - | Abstand in Punkten (1/72 dpi) |
static int table::set_id(
Table T,
int id = 0,
int id2 = 0,
int id3 = 0,
char* stringid = 0)
Setze die RootTableRecord-ID der Tabelle.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Zieltabelle |
| ID des Objektes, mit dem die Tabelle verknüpft werden soll : | |||
| id | int | 0 | RootTableRecordID |
| id2 | int | 0 | RootTableRecordID2 |
| id3 | int | 0 | RootTableRecordID3 |
| stringid | String oder char* | 0 | RootTableRecordStringID |
static int table::setid(
Table T,
int id = 0,
int id2 = 0,
int id3 = 0,
char* stringid = 0)
Setze die RootTableRecord-ID der Tabelle (wie set_id).
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Zieltabelle |
| ID des Objektes, mit dem die Tabelle verknüpft werden soll : | |||
| id | int | 0 | RootTableRecordID |
| id2 | int | 0 | RootTableRecordID2 |
| id3 | int | 0 | RootTableRecordID3 |
| stringid | String oder char* | 0 | RootTableRecordStringID |
static int table::get_id(
Table T,
int* id = 0,
int* id2 = 0,
int* id3 = 0,
char* stringid = 0)
Hole die RootTableRecord-ID der Tabelle.
| Name | Typ | Default | Beschreibung |
| Return | int | -1 : error sonst : ID1 der RootTableRecordId der Tabelle |
|
| T | Table | - | Zieltabelle |
| ID des Objektes, mit dem die Tabelle verknüpft werden soll : | |||
| id | int* | 0 | Rückgabevariable für RootTableRecordID 0 : diesen Wert nicht abholen |
| id2 | int* | 0 | Rückgabevariable für RootTableRecordID2 0 : diesen Wert nicht abholen |
| id3 | int* | 0 | Rückgabevariable für RootTableRecordID3 0 : diesen Wert nicht abholen |
| stringid | String oder char* | 0 | Rückgabevariable für RootTableRecordStringID 0 : diesen Wert nicht abholen sonst : allokierter Speicher für den String |
static int table::getid(
Table T,
int* id = 0,
int* id2 = 0,
int* id3 = 0,
char* stringid = 0)
Hole die RootTableRecord-ID der Tabelle (wie get_id).
| Name | Typ | Default | Beschreibung |
| Return | int | -1 : error sonst : ID1 der RootTableRecordId der Tabelle |
|
| T | Table | - | Zieltabelle |
| ID des Objektes, mit dem die Tabelle verknüpft werden soll : | |||
| id | int* | 0 | Rückgabevariable für RootTableRecordID 0 : diesen Wert nicht abholen |
| id2 | int* | 0 | Rückgabevariable für RootTableRecordID2 0 : diesen Wert nicht abholen |
| id3 | int* | 0 | Rückgabevariable für RootTableRecordID3 0 : diesen Wert nicht abholen |
| stringid | String oder char* | 0 | Rückgabevariable für RootTableRecordStringID 0 : diesen Wert nicht abholen sonst : allokierter Speicher für den String |
static int table::get_templateid(Table T)
Hole die ID des Tabellentemplates, aus der die Tabelle eingefügt wurde. Der Wert ist nur in Tabellen definiert, die über Tabellenplatzhalter (mit einer Comet-Version ab 3.3) eingefügtwurden. In allen anderen Fällen ist der Wert 0.
| Name | Typ | Default | Beschreibung |
| Return | int | ID des Tabellentemplates, aus dem die Tabelle durch einen Tabellenplatzhalter eingefügt wurde oder 0. | |
| T | Table | - | Zieltabelle |
static int table::set_templateid(Table T, int id)
Setze die (angebliche) ID des Tabellentemplates, mit dem die Tabelle angelegt wurde.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Zieltabelle |
| id | int | - | neue ID |
static int table::get_placeholderid(Table T)
Hole die ID des Tabellenplatzhalters, der die Tabelle ins Dokument eingefügt hat.
| Name | Typ | Default | Beschreibung |
| Return | int | ID des Tabellenplatzhalters oder 0. | |
| T | Table | - | Zieltabelle |
static int table::set_placeholderid(Table T, int id)
Setze die ID des Platzhalters, der die Tabelle (angeblich) aufgebaut hat.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Zieltabelle |
| id | int | - | neue ID |
static int table::build(
Table T,
int row = -1,
int col = -1,
int execActionsOnly = -1)
Aufbau der Tabelle gemäß den Einstellungen der Palette Tabellenaufbau. Die Funktion ist identisch mit
dem Button
der Palette Tabellenaufbau
und den Menübefehlen
Plug-ins -> Tabellenaufbau -> Gesamte Tabelle aufbauen (Zusatzmodule statt Plug-ins in Versionen vor InDesign® 2025)
Plug-ins -> Tabellenaufbau -> Zeilen und Spalten anlegen
Gesamte Tabelle aufbauen der Palette Tabellenaufbau
Zeilen und Spalten anlegen der Palette Tabellenaufbau
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Zieltabelle |
| Aufbau der angegebenen Tabellenzelle : | |||
| row | int | -1 | 0-basierte Nummer der Zeile -1 : Gesamte Tabelle aufbauen |
| col | int | -1 | 0-basierte Nummer der Spalte Ist row=-1 wird die Angabe ignoriert. |
| execActionsOnly | int | -1 | Sollen nur die Tabellen-Gestaltungsregeln ausgeführt werden? -1 : Nein, Tabelle/Zelle aufbauen (und danach die Regeln ausführen) kPreAction : Nur die Pre-Regeln dieser Zelle ausführen kPostAction : Nur die Post-Regeln dieser Zelle ausführen kPreActionTable : Nur die Pre-Regeln der Tabelle ausführen, row und col werden in diesem Fall ignoriert kPostActionTable : Nur die Post-Regeln der Tabelle ausführen, row und col werden in diesem Fall ignoriert |
Baue die dritte Tabelle des aktuellen Textes komplett neu auf.
#include "internal/text.h" #include "internal/table.h"
int main () { Table T = table::alloc (); int result;
result = table::get (T, 0, 3); if (result) { showmessage ("%s", serror (result)); return 0; }
table::build (T); table::release (T);
return 0; }
static int table::reset(
Table T,
int row = -1,
int col = -1)
Lösche die beim Tabellenaufbau erzeugten Zeilen und Spalten aus der Tabelle. Die Funktion ist identisch mit
dem Button
der Palette Tabellenaufbau
und den
Menübefehlen
Plug-ins -> Tabellenaufbau -> Gesamte Tabelle aufräumen (Zusatzmodule statt Plug-ins in Versionen vor InDesign® 2025)
Plug-ins -> Tabellenaufbau -> Zeilen und Spalten entfernen
Gesamte Tabelle aufräumen der Palette Tabellenaufbau
Zeilen und Spalten entfernen der Palette Tabellenaufbau
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Zieltabelle |
| Lösche die Zeilen und Spalten der angegebenen Tabellenzelle : | |||
| row | int | -1 | 0-basierte Nummer der Zeile -1 : Gesamte Tabelle aufräumen |
| col | int | -1 | 0-basierte Nummer der Spalte Ist row=-1 wird die Angabe ignoriert. |
Setze die dritte Tabelle des aktuellen Textes zurück.
#include "internal/text.h" #include "internal/table.h"
int main () { Table T = table::alloc (); int result;
result = table::get (T, 0, 3); if (result) { showmessage ("%s", serror (result)); return 0; }
table::reset (T); table::release (T);
return 0; }
static Table table::get_parent(Table T)
Verweis auf die äussere Tabelle, die diese Tabelle aufgebaut hat. Der Verweis hat nur in Tabellen von automatisch aufgebauten Tabellen einen gültigen Wert. Er muss mit table::is_valid getestet werden. Es ist nicht nötig, eine Tabellenreferenz für das Ergebniss zu allokieren. Soll der Verweis für spätere Skriptverwendungen verwendet werden, muss sein Inhalt aber mit item::copy in eine allokierte Tabellenreferenz vom Typ Table übertragen werden.
| Name | Typ | Default | Beschreibung |
| Return | Table | Verweis auf die Elterntabelle der mit mit table::is_vaild getestet werden kann. | |
| Table | T | - | Gültige Tabelle |
static int table::has_parent(Table T)
Zusammenführung der Anweisungen table::is_valid (table::get_parent (T));
| Name | Typ | Default | Beschreibung |
| Return | int | 0 : Die Tabelle wurde nicht automatisch von einer anderen Tabelle aufgebaut 1 : Die Tabelle wurde automatisch aufgebaut |
|
| Table | T | - | Gültige Tabelle |
static int table::broaden_to_frame(
Table T,
int col,
int columnAware = 0,
List cols = 0)
Passe die Tabelle an die Rahmenbreite an, indem die Breite einer/aller Spalte(n) verändert wird.
[Ab v3.3 R2892, 8. Mai 2012] Ist die Tabelle Untertabelle einer anderen Tabelle, wird als Begrenzung nicht der Textrahmen verwendet. In diesem Fall wird die Zelle minus deren Zellen-Inset für die Bestimmung der neuen Tabellenbreite verwendet.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Zieltabelle |
| col | int | - | Spalte, deren Breite verändert werden soll -1 : die nötige Breitenänderung relativ zu bisherigen Spaltenbreiten auf alle Spalten verteilen -2 : die nötige Breitenänderung gleichmäßig auf alle Spalten verteilen. Bei Verkleinerung der Tabelle werden dabei Minimalbreiten von 3.0pt erzwungen! Dadurch kann der Fall eintreten, dass die Tabelle nie ganz in den Rahmen passt! |
| columnAware | int | 0 | In mehrspaltigen Texten an die aktuelle Spaltenbreite anpassen? 0 : Nein 1 : Ja |
| cols | List | 0 | Liste 0-basierter Spaltennummern. Ist die Liste nicht leer und der Parameter col < 0, werden nur die in der Liste angegebenen Spalten verändert. Alle anderen Spalten behalten ihre aktuelle Breite. Die Breitenänderung der angegebenen Spalten erfolgt gemäß der Angabe in col relativ zur alten Breite (-1) oder gleichmäßig (-2). |
int main ()
{
Table T = table::alloc ();
table::get (T, 0, 0);
table::broaden_to_frame (T, 1);
return 0;
}
static int table::equal_cols(
Table T,
int col = -1,
...)
Bringe alle gegebenen Spalten auf die selbe Breite. Die Tabellenbreite bleibt dabei erhalten.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Zieltabelle |
| col | int | -1 | Erste Spalte. Fehlt die Angabe oder ist -1, werden alle Tabellenspalten bearbeitet. |
| ... | int | Beliebig viele weitere Spalten -1 : bis zur letzten Spalten |
Alle Tabellenspalten auf die selbe Breite bringen
int main ()
{
Table T = table::alloc ();
table::get (T, 0, 0);
table::equal_cols (T);
return 0;
}
Alle Tabellenspalten außer den ersten beiden auf die selbe Breite bringen. Ohne die -1 als zweiten Parameter hat der Aufruf keine Wirkung.
int main ()
{
Table T = table::alloc ();
table::get (T, 0, 0);
table::equal_cols (T, 2, -1);
return 0;
}
static int table::equal_cols_by_list(Table T, List cols = 0)
Bringe alle gegebenen Spalten auf die selbe Breite. Die Tabellenbreite bleibt dabei erhalten. Die Funktion ist exaxt gleich zu equal_cols, außer dass die Spalten als Liste gegeben werden.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Zieltabelle |
| cols | List | 0 | Liste der (0-basierten) Spaltennummern, die verändert werden sollen. Ist die Liste leer, werden alle Spalten verändert. |
Verbreitere die ausgewählten Tabellenspalten so, dass die Tabelle danach den Rahmen genau ausfüllt.
int main ()
{
Table T = table::alloc ();
ItemRef frame = item::alloc();
List cols = list::alloc ();
int start, len, l, t, r, b, i;
textmodel::selection (&start, &len, frame, 0, T, &l, &t, &r, &b);
if (!table::is_valid (T)) return 0;
for (i = l; i < r; i++) list::insert (cols, i);
table::broaden_to_frame (T, l);
table::equal_cols_by_list (T, cols);
return 0;
}
static int table::fit_col(
Table T,
int col,
int canShrink = 0,
int keepLineHeights = 0,
float precision = 0.1,
float maxWidth = 1000.0,
int emergencyExit = 30)
Passe die Breite einer Spalte so an, dass keine Zelle der Spalte einen Textübersatz hat. Hat keine Zelle einen Textübersatz, kann die Spaltenbreite auch optimal verkleinert werden. Die Spaltenbreite wird auf 1/10 Punkt genau berechnet. Die Funktion kann nur für Tabellen angewendet werden, die im sichtbaren Bereich eines Textrahmens liegen. Tabellen im Overset des Textes können nicht angepasst werden. In diesem Fall wird der Fehler tableInOversetErr (= 1259) zurückgegeben.
ACHTUNG : Enthält die Tabelle verbundene Zellen, können bei einer unterschiedlichen Reihenfolge von Spaltenbreitenanpassungen unterschiedliche Ergebnisse entstehen!
Bedingt durch die leicht unterschiedlichen Textlaufweiten in InDesign® und comet_pdf können die erhaltenen Spaltenbreiten in InDesign® und comet_pdf leicht variieren.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Zieltabelle |
| col | int | - | Zielspalte (0-basiert) |
| canShrink | int | 0 | Soll die Spaltenbreite möglicherweise auch verkleinert werden? 0 : Nur Spalten mit Übersatz verbreitern 1 : Spalten ohne Übersatz können schmaller gemacht werden. |
| keepLineHeights | int | 0 | Spalten nur soweit verkleinern, dass keine Zelle der Tabelle höher wird?
Der Parameter wird nur bei canShrink = 1 ausgewertet. 0 : Zellen dürfen höher werden 1 : Spalten nur so weit verkleinern, dass keine Zelle höher wird Bei Zellen, deren Inhalt aus mehreren Absätzen besteht, kann der Übersatz mglw. nicht entfernt werden, ohne die entsprechende Zeile höher zu machen. Dieses Verhalten wird erkannt, die Funktion gibt in diesem Fall den Fehler 1277 (cannotRemoveOversetErr) zurück. Von comet_pdf wird die Angabe ignoriert. |
| precision | float | 0.1 | Wie genau soll die Spaltenbreite angepasst werden? Die Werte müssen >=0.001 sein. Beachten Sie,
dass größere Werte den Aufwand zur Berechnung der Spaltenbreite deutlich verkürzen können. Im Durchschnitt
gilt, eine Zehnerpotenz kleiner verdoppelt den Aufwand. <0.001 Verwende das alte (bis v3.3 R3636) verwendete Verfahren zur Berechnung der Spaltenbreite. Die Angaben für maxWidth und emergencyExit werden in diesem Fall ignoriert. Comet_pdf verwendet bei Werten <0.001 automatisch den Standardwert 0.1. |
| maxWidth | float | 1000.0 | Wie breit darf die Spalte maximal werden? Die Angabe wird nur verwendet, wenn mind. eine Zelle der Spalte einen Übersatz hat. Je näher der Wert am Ergebniswert liegt, desto schneller rechnet die Funktion. Wird die Maximalbreite erreicht, ohne dass der Übersatz beseitigt werden konnte, liefert die Funktion den Fehler 1278 (maxWidthTooSmallErr). |
| emergencyExit | int | 30 | Anzahl der Versuche. Inbesondere bei der Verwendung nicht installierter Schriften können Veränderungen der Spaltenbreite überraschende Ergebnisse zeigen. Um solche unerwarteten Ergebnisse abfangen zu können, hat die Funktion einen Notausgang und gibt in diesem Fall den Fehler 1279 (emergencyExitErr) zurück. |
Passe die dritte der Spalte der Tabelle an.
int main ()
{
Table T = table::alloc ();
table::get (T, 0, 0);
table::fit_col (T, 2, 1);
return 0;
}
static int table::apply_style(
Table T,
char* styleName,
int removeTableOverrides = 0,
int removeCellStyle = 0)
Wende einen Tabellenstil auf eine Tabelle an. Mit der Angabe eines leeren Stiles wird der bestehende Tabellenstil der Tabelle entfernt. Tabellenstile wurden erst in InDesign® CS3 eingeführt. Unter InDesign®-Versionen vor CS3 macht die Funktion nichts, liefert aber einen Fehlercode zurück.
| Name | Typ | Default | Beschreibung |
| T | Table | - | Gültige Tabellenreferenz |
| whichStyle | String oder char* | - | Name des Tabellenstils. Tabellenstile können hierarchisch geordnet sein. Geben Sie in diesem Fall den vollständigen, durch ':' getrennten Pfad des Tabellenstil an. "" : Entferne den Tabellenstil von der Tabelle |
| removeTableOverrides | int | 0 | Lokale überschreibungen sollen entfernt werden (1) oder erhalten bleiben(0)
Von Illustrator® wird der Parameter ignoriert. |
| removeCellStyle | int | 0 | Sollen Zellenstile ebenfalls entfernt werden?
Von Illustrator® wird der Parameter ignoriert. |
static char* table::get_style(Table T)
Ermittle Pfad und Namen des Stiles einer Tabelle. Die Funktion liefert erst ab InDesign® CS3 gültige Werte.
| Name | Typ | Default | Beschreibung |
| Return | char* | Pfad und Name des aktuellen Tabellenstiles. Als Pfadtenner wird ':' verwendet. "" : Kein Tabellenstil gesetzt oder InDesign®-Version vor CS3 Der Rückgabewert darf nicht verändert werden und wird bei folgenden Aufrufen der Funktion überschrieben. Hier finden Sie Informattingen zu readonly-Rückgaben von Funktionen. |
|
| T | Table | - | Gültige Tabellenreferenz |
strcpy (cname, table::get_style (T));
static int table::apply_cellstyle(
Table T,
char* styleName,
int l,
int t,
int r,
int b,
int removeOverrides = 0,
int applyParaStyle = 0)
Wende einen Zellstil auf eine Zellbereich an. Mit der Angabe eines leeren Stiles wird der bestehende Zellstil des Zellbereiches entfernt. Zellstile wurden erst in InDesign® CS3 eingeführt. Unter InDesign®-Versionen vor CS3 macht die Funktion nichts, liefert aber einen Fehlercode zurück.
static int table::clear_celloverrides(
Table T,
char* styleName,
int l,
int t,
int r,
int b,
int depth = 2,
int keepTableModuleData = 0,
int refreshPanel = 0)
Lösche alle Zellabweichungen aus dem angegebenen Bereich, die mit dem angewendeten Zellenstil in Konflikt stehen. Die Funktion ist identisch mit table::cell::clear_overrides.
static int table::clear_overrides(
Table T,
int clearCellStyles = 0,
int keepTableModuleData = 0,
int refreshPanel = 0)
Lösche alle lokalen Tabellenstilüberschreibungen für die angegebene Tabelle.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| clearCellStyles | int | 0 | 0 : Lokale Zellstile bewahren 1 : alle lokalen Zellenstile löschen |
| keepTableModuleData | int | 0 | Welche Daten des Tabellenmodules sollen aufbewahrt werden? kKeepAll : Alle Tabellenaufbau-Daten aufbewahren kKeepGroupsAndInfo : Nur Gruppen und Infos1/2 aufbewahren kKeepGroups : Nur Gruppen aufbewahren kKeepInfo : Nur Infos1/2 aufbewahren kKeepNothing : Alle Tabellenaufbau-Daten der Zelle entfernen |
| refreshPanel | int | 0 | Soll die Palette Tabellenaufbau aktualisert werden? 0 : Nein, schneller 1 : Zeigt die Palette eine Zelle der aktuellen Tabelle, wird sie nach der Änderung aktualisiert. |
static int table::compress_colwise(
Table T,
int firstCol = 0,
int colSpan = 1,
int flattenLastChunk = 0,
int copyColHeader = 0,
int fit_columns = 1,
float delimRowHeight = 0.0)
Komprimieren einer breiten Tabellen in den Textrahmen. Tabellen können mehrfach komprimiert werden. Ist der Textrahmen schmaler als die führenden Spalten oder schmaler als die führenden Spalten und ein erster Spaltenblock von colSpan Spalten, wird die Tabelle so komprimiert, dass sie genau einen Spaltenblock hat - der dann über den Rahmenrand hinausragt. In diesem Fall wird trotzdem der Fehlercode wrongColumnsForCompressErr (1266) zurückgegeben.
Entstehen durch das Komprimieren am Ende der Tabelle leere Zeilen, werden sie gelöscht.
Der Befehl kann nur für Tabellen angewendet werden, die sich nicht im Overset ihres Textrahmens befinden.
Beginnend an der Spalte firstCol werden zuerst alle Spalten der Tabelle so schmal wie möglich gemacht. Danach werden alle Spalten, die über den Textrahmen hinausragen unten an die Tabelle angehangen. Dabei wird versucht, die neu angelegten Zeilen möglichst mit den überstehenden Spalten zu füllen. Erst wenn die letzten Spalte der neuen Zeilen gefüllt ist, werden weitere Zeilen in der Tabelle angelegt. Beim übertragen der Spalten werden Kopf- und Fusszeilen der Tabelle übergangen.
Mit der Angabe colSpan können Sie festlegen, wieviele Spalten jeweils einen Block bilden sollen. Blöcke laufen jeweils über die gleichen Zeilen. Hinter firstCol muss aber nicht ein Vilefaches von colSpan folgen, in diesen Fällen ist der letzte Block der komprimierten Tabelle unvollständig.
Füllen die (letzten) überstehenden Blöcke nicht alle Spalten der neu(en) Zeile(n), können die Einträge der Spalten auch auf einer Zeile dargestellt werden. Setzen Sie dazu flattenLastChunk = 1. Das klappt natürlich nur, wenn die Tabelle nicht mehr Körperzeilen hat als Spalten hinter firstCol in den Rahmen passen.
Schliesslich können Sie mit copyColHeader = 1 bewirken, dass die Inhalte der Spalten vor firstCol in die neu angelegten Tabellenzeilen übertragen werden.
Nachdem die Tabelle umgebaut wurde, werden alle Spalten nochmal getrimmt. Dieser Schritt ist nötig, weil Zellen, die von hinten in eine vordere Spalte kopiert wurden, größer sein können, als die Zielspalte und dann in diesen Zellen wieder ein Overset entstehen würde. Dadurch kann es passieren, dass die Tabelle doch wieder über den Textrahmen hinausragt. Beim Auftreten dieses Problemes müsste die Tabelle eigentlich noch einmal komprimiert werden - wodurch sich leider die für get_keystring nötigen Informattingen über die Originaltabelle so verändern, dass get_keystring nicht mehr zuverlässig arbeiten kann. Für dieses Problem gibt es momentan noch keine Lösung! Ist finalBroaden gesetzt, wird restlicher Platz bis zum Textrahmen dagegen gleichmäßig auf alle Spalten ab firstCol verteilt.| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| firstCol | int | 0 | Beginne an dieser Spalte mit dem Tabellenumbau |
| colSpan | int | 1 | Wieviele Spalten bilden jeweils einen Block, der nicht durch Tabellenzeilen getrennt werden darf? |
| flattenLastChunk | int | 0 | Bei Bedarf und wenn möglich werden die Zellen der letzten Spalten nicht untereinander, sondern nebeneinander in eine Zeile verschoben. |
| copyColHeader | int | 0 | Inhalte der "Führungszellen" in die neuen Zeilen übernehmen? |
| fit_columns | int | kBroadenFirstLast | Anpassen der Spaltenbreite kBroadenFirstLast Vor dem Tabellenumbau alle Spalten auf ihr Minimum verkleinern. Nach dem Tabellenumbau werden die Spalten so weit vergrößert, dass die Tabelle den Rahmen genau ausfüllt. kBroadenFirst Vor dem Tabellenumbau alle Spalten auf ihr Minimum verkleinern kBroadenLast Nach dem Tabellenumbau werden die Spalten so weit vergrößert, dass die Tabelle den Rahmen genau ausfüllt. kBroadenNever Spaltenbreiten unverändert lassen |
| delimRowHeight | float | 0.0 | Einfügen einer Zwischenraumzeile mit der angegebenen Höhe 0.0 : Keine Zwischenraumzeile -1.0 : Benutze die Höhe der aktuellen Zeile |
static int table::decompress_colwise(Table T)
Rückgängigmachen einer Tabellen-Komprimierung durch compress_colwise oder woodoo. Änderungen der Spaltenbreiten zwischen dem letzten compress_colwise und decompress_colwise werden dabei überschrieben.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
static int table::woodoo(Table T, int adjustToFrame = 1)
Umgestaltung einer 4-spaltigen Tabelle, so dass sie möglichst schmal wird und in den umgebenenden Textrahmen passt. Die Wirkung der Anweisung sehen Sie in den folgenden Davor-Danach-Bildern :
Davor 
Danach 
Eben Woodoo. Der Gegenzauber heißt oodoow, damit wird die Tabelle in ihren Ursprungszustand zurückversetzt. Es gibt einige Einschränkungen :
Damit Sie es einfacher haben, kann als Gegenmittel auch der allgemeine Gegenzauber decompress_colwise verwendet werden. Und umgekehrt bringt oodoow auch Tabellen, die mit compress_colwise gepackt wurden, wieder in ihren Originalzustand.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| adjustToFrame | int | 1 | Soll die Tabelle an die Rahmenbreite angepasst werden? 0 : Nein 1 : Anpassen. Die erste und dritte Spalte der Tabelle werden so verbreitert, dass die rechte Außenkante des Rahmens die genau mit der rechten Begrenzungslinie der Tabelle abschließt. (Rahmenbreite, -typ und -farbe müssen in den Zellstilen der Zellen definiert sein!) Bei Tabellen, die breiter als der Rahmen bleiben, hat der Parameter keine Wirkung. |
static int table::oodoow(Table T)
Tabellen, die mit woodoo komprimiert wurden, werden wieder in ihren Originalzustand zurückversetzt. Manuelle Änderungen der Spaltenbreiten und Zellstile zwischen woodoo und oodoow werden überschrieben.
static int table::break_(
Table T,
int headerRows = 0,
int repeatHeaderRows = 1,
int headerColumns = 0,
int repeatHeaderColumns = 1,
int justifyRows = 0,
float delimiterHeight = 0.0,
int copyCellProperties = 1,
int flags = 0)
Umbruch einer Tabelle, so dass sie in den Rahmen paßt. Die Tabelle wird so umbrochen, dass keine Spalten übr den Textrahmen hinausragen. Überstehende Spalten werden unter der Tabelle als neue Zeilen angefügt und danach gelöscht. Vor dem Umbruch werden eventuell bestehenden Umordnungen der Tabelle (compress_colwise, woodoo, break_) rückgängig gemacht.
Bei der Tabellenumgestaltung können weiter rechts liegende breitere Spalten die Breite von vorderen Tabellenspalten ändern.
In den folgenden Bildern sehen Sie eine Tabelle vor und nach dem Umbruch. Die Spalten 1-10 haben nach dem Umbruch die
(größeren) Spaltenbreiten der Spalten 11-20:

Der Parameter justifyRows steuert die Verteilung der Spalten in den neuen Zeilen. Ist er 1, wird versucht, die neuen Zeilen möglichst gleichmäßig
zu füllen. Das kann natürlich nicht immer funktionieren, 41 Spalten sind nun mal nur auf eine oder 41 Zeilen gleichmäßig zu verteilen. In der Regel werden
Tabellen mit dieser Einstellung etwas schmaler - aber nie länger. Ist der Parameter 0, werden die neuen Zeilen nacheinander gefüllt, in der letzten Zeile
kann sich aber ein größerer Freiraum ergeben. In beiden Fällen werden Hintergrund und Ränder überzähliger Zellen auf "farblos" gestellt, so dass diese Tabellenzellen
unsichtbar werden. Die folgenden Bilder zeigen ein Beispiel :
Vorher

justifyRows = 0

justifyRows = 1

| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode 1266 : Schon die Header-Columns ragen über den Rahmen hinaus. |
|
| T | Table | - | Gültige Tabellenreferenz |
| headerRows | int | 0 | Anzahl der Kopfzeilen |
| repeatHeaderRows | int | 1 | Sollen die Kopfzeilen wiederholt werden? Diese Option abzustellen, macht in den wenigsten
Fällen Sinn. Tabellenspalten haben ja gewöhnlich unterschiedliche überschriften, die beim
Umbrechen der Spalten verloren gehen würden. Wie auch immer, wir heben die verlorengegangenen
Spaltenüberschriften auf und setzen Sie bei unbreak_ wieder ein. 0 : nicht wiederholen 1 : wiederholen |
| headerColumns | int | 0 | Anzahl der Kopfspalten |
| repeatHeaderColumns | int | 1 | Sollen die Kopfzeilen wiederholt werden? 0 : nicht wiederholen 1 : wiederholen |
| justifyRows | int | 0 | Möglichst gleich breite Tabellenzeilen (siehe oben)? 0 : nein 1 : ja |
| delimiterHeight | float | 0.0 | Die einzelnen Tabellenblöcke, die durch das Umbrechen entstehen, können durch Zwischenräume der angegenen Höhe (in Punkten) getrennt werden. Dafür wird jeweils eine zusätzliche Zeile in die Tabelle eingefügt, deren sämtliche Farben auf "Durchsichtig" gestellt werden. |
| copyCellProperties | int | 1 | Zelleinstellungen übernehmen? 0 : nein 1 : ja Folgende Einstellungen werden (in dieser Reihenfolge) übernommen :
|
| flags | int | 0 | Zusatzoptionen 0 : Nichts 1 : Im Fehlerfall Spaltenbreiten unverändert lassen |
int main ()
{
Table T = table::alloc ();
table::get (T, gFrame, 0);
table::break_ (T, 1, 1, 1, 1, 1, 12.3, 1);
return 0;
}
Als Alternative zu table::break: können Sie die Tabelle auch so in kleinere Tabellen teilen, dass jede kleine Tabelle in den aktuellen Rahmen passt. Allerdings ist dieses Vorgehen nicht reorganisations-fest.
// @@ICONID 626
// Check whether all columns are narrower than the frame width // int first_check (Table T, float w) { float wcol; int c;
for (c = 0; c < table::columns (T); c++) { wcol = table::get_col_width (T, c); if (wcol > w) { return c; } }
return -1; }
// Find the first column that extends beyond the right edge of the frame // int find_first_outer (Table T, float w) { float wcols; int c = 1;
while (1) { wcols = table::get_col_width (T, 0, c); if (wcols > w) return c - 1; ++c; if (c > table::columns (T)) return -1; } }
// Create a copy of a table and insert it directly behind the table. // int duplicate_table (ItemRef frame, Table T) { int len; int pos = table::get_anchorpos (T, &len); Scrap data = 0; String str1, str2;
if (system::version () == -1) { // comet_pdf str1 = string::alloc (); str2 = string::alloc ();
frame::gettext (frame, str1, pos, len, kExportW2); string::set (str2, "%%!TT%s", str1); frame::insert (frame, str2, pos+len, 0);
string::release (str1); string::release (str2); } else { data = textmodel::copy (frame, pos, len); textmodel::paste (frame, data, pos+len); }
return 0; }
// Main // int main () { Table T = table::alloc (); int tableIndex = 0; int c, first_out; float w, h;
// Is there even a table? // table::get (T, gFrame, tableIndex); if (!table::is_valid (T)) return 0;
// Determine frame size // frame::get_size (gFrame, &w, &h);
// Make sure that every column fit INDIVIDUALLY into the frame // c = first_check (T, w); if (c >= 0) { showmessage ("The table cannot be divided. At least column %d of the table is wider than the frame.", c+1); return 0; }
// Divide the table into smaller tables so that // each individual table fits into the frame. // while (1) { first_out = find_first_outer (T, w); if (first_out < 0) break; duplicate_table (gFrame, T); table::remove_cols (T, first_out, -1); ++tableIndex; table::get (T, gFrame, tableIndex); table::remove_cols (T, 0, first_out); }
return 0; }
static int table::unbreak_(Table T, int resetCellProperties = 1)
Tabelle entfalten.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| copyCellProperties | int | 1 | Zelleinstellungen wiederherstellen? 0 : nein 1 : ja Folgende Einstellungen werden (in dieser Reihenfolge) übernommen :
|
static int table::get_firstouter_column(Table T)
Ermittle die erste Nummer der ersten Spalte, die ganz oder teilweise über den rechten Rande des Textrahmens hinausragt.
| Name | Typ | Default | Beschreibung |
| Return | int | 0-basierte Nummer der ersten Tabellenspalte, die nicht mehr vollständig im Textrahmen liegt -1 : Alle Spalten sind vollständig sichtbar -2 : Fehler |
|
| T | Table | - | valid table reference |
static char* table::get_keystring(Table T, int infoType = 1)
Ermittle einen Schlüssel für eine Tabelle. Dabei wird die Tabelle zeilenweise durchlaufen und jeweils die gewünschte Informatting ermittelt und dem Ergebnissstring angefügt. Der Schlüssel ist unabhängig davon, ob die Tabelle mit compress_colwise oder woodoo bearbeitet wurde.
| Name | Typ | Default | Beschreibung |
| Return | char* | Schlüssel.
Der Rückgabewert darf nicht verändert werden und wird bei folgenden Aufrufen der Funktion überschrieben. Hier finden Sie Informattingen zu readonly-Rückgaben von Funktionen. |
|
| T | Table | - | Gültige Tabellenreferenz |
| infotype | int | 1 | Welche Angaben soll der Schlüssel enthalten 0 : Zeile Spalte ... 1 : PlaceholderID ID ID2 ... 2 : PlaceholderID ID ID2 ID3 ... 3 : PlaceholderID ID ID2 ID3 "StringID" ... 4 : "Zelltext" ... |
static int table::get_keep_with_next_row(Table T, int row)
Soll eine Tabellenzeile beim Tabellenumbruch mit der nachfolgenden Zeile zusammengehalten werden?
| Name | Typ | Default | Beschreibung |
| Return | int | Zeilen zusammenhalten 0 : Nein 1 : Ja |
|
| T | Table | - | Gültige Tabellenreferenz |
| row | int | - | Zeilennummer (0-basiert) |
int main ()
{
Table T = table::alloc ();
int keep;
int result;
table::get (T, 0, 0);
keep = table::get_keep_with_next_row (T, 11);
wlog ("", "old keep together = %d\n", keep);
if (keep) keep = 0;
else keep = 1;
result = table::set_keep_with_next_row (T, 11, keep);
wlog ("", "change keep together = %d\n", result);
keep = table::get_keep_with_next_row (T, 11);
wlog ("", "new keep together = %d\n", keep);
return 0;
}
static int table::set_keep_with_next_row(
Table T,
int row,
int newState)
Eine Tabellenzeile mit der Nachfolgezeile verbinden/sie von ihr trennen.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| row | int | - | Zeilennummer (0-basiert) |
| newState | int | - | 1 : Zeilen zusammenhalten 0 : Zeilen dürfen getrennt werden |
int main ()
{
Table T = table::alloc ();
int keep;
int result;
table::get (T, 0, 0);
keep = table::get_keep_with_next_row (T, 11);
wlog ("", "old keep together = %d\n", keep);
if (keep) keep = 0;
else keep = 1;
result = table::set_keep_with_next_row (T, 11, keep);
wlog ("", "change keep together = %d\n", result);
keep = table::get_keep_with_next_row (T, 11);
wlog ("", "new keep together = %d\n", keep);
return 0;
}
static int table::get_row_start(Table T, int row)
In welchem Rahmen oder welcher Textspalte des Textflusses wird eine Tabellenzeile dargestellt (oder dargestellt werden)? Die Funktion ermittelt die Einstellung des Dropdowns Umbruchoptionen: Startzeile einer gegebenen Tabellenzeile im InDesign-Dialog Tabelle -> Zellenoptionen -> Zeilen und Spalten. Die Tabellenzeile muss für diese Abfrage nicht sichtbar sein.
| Name | Typ | Default | Beschreibung |
| Return | int | eStartAnywhere eStartNextColumn eStartNextFrame eStartNextPage eStartNextOddPage eStartNextEvenPage Beachten Sie bitte, dass comet_pdf nur die Werte eStartAnywhere, eStartNextColumn and eStartNextFrame untertsützt. |
|
| T | Table | - | Gültige Tabellenreferenz |
| row | int | - | Zeilennummer (0-basiert) |
Ermittle die Umbruchoption einer Tabellenzeile und setze sie auf einen anderen Wert. Aktuelle und geänderte Umbruchoption werden ins Log geschrieben. Die Testtabelle sollte dazu mehr als zwölf Zeilen haben.
#include "internal/table.h"
int main () { Table T = table::alloc (); int start; int result;
table::get (T, 0, 0);
start = table::get_row_start (T, 11); wlog ("", "old row start = %d\n", start);
if (start == eStartAnywhere) start = eStartNextColumn; else if (start == eStartNextColumn) start = eStartNextFrame; else if (start == eStartNextFrame) start = eStartNextPage; else if (start == eStartNextPage) start = eStartAnywhere;
result = table::set_row_start (T, 11, start); wlog ("", "change row start = %d\n", result);
start = table::get_row_start (T, 11); wlog ("", "new row start = %d\n", start);
return 0; }
static int table::set_row_start(
Table T,
int row,
int newStart)
In welchem Rahmen oder welcher Textspalte des Textfluses soll die Tabellenzeile erscheinen? Setze die Umbruchoption einer Tabellenzeile. Die Einstellung entspricht dem Wert des des Dropdowns Umbruchoptionen: Startzeile des InDesign-Dialoges Tabelle -> Zellenoptionen -> Zeilen und Spalten.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| row | int | - | Zeilennummer (0-basiert) |
| newStart | int | - | eStartAnywhere eStartNextColumn eStartNextFrame eStartNextPage eStartNextOddPage eStartNextEvenPage Beachten Sie bitte, dass comet_pdf nur die Werte eStartAnywhere, eStartNextColumn and eStartNextFrame untertsützt. |
Ermittle die Umbruchoption einer Tabellenzeile und setze sie auf einen anderen Wert. Aktuelle und geänderte Umbruchoption werden ins Log geschrieben. Die Testtabelle sollte dazu mehr als zwölf Zeilen haben.
#include "internal/table.h"
int main () { Table T = table::alloc (); int start; int result;
table::get (T, 0, 0);
start = table::get_row_start (T, 11); wlog ("", "old row start = %d\n", start);
if (start == eStartAnywhere) start = eStartNextColumn; else if (start == eStartNextColumn) start = eStartNextFrame; else if (start == eStartNextFrame) start = eStartNextPage; else if (start == eStartNextPage) start = eStartAnywhere;
result = table::set_row_start (T, 11, start); wlog ("", "change row start = %d\n", result);
start = table::get_row_start (T, 11); wlog ("", "new row start = %d\n", start);
return 0; }
static int table::get_headers_start(Table T)
Wo werden bei Tabellenümbrüchen die Kopfzeilen der Tabelle wiederholt?
In comet_pdf hat der Aufruf keine Wirkung
| Name | Typ | Default | Beschreibung |
| Return | int | Wo werden die Kopfzeilen der Tabelle gezeigt? eStartEachTextColumn eStartEachTextFrame eStartEachPage |
|
| T | Table | - | Gültige Tabellenreferenz |
#include "internal/table.h"
int main () { Table T = table::alloc (); int s1, sn; int result;
table::get (T, 0, 0);
// Before s1 = table::get_headers_start (T); wlog ("", "headers start = %d\n", s1);
sn = table::get_footers_start (T); wlog ("", "footers start = %d\n", sn);
// Change if (s1 == eStartEachTextColumn) s1 = eStartEachTextFrame; else if (s1 == eStartEachTextFrame) s1 = eStartEachPage; else if (s1 == eStartEachPage) s1 = eStartEachTextColumn;
if (sn == eStartEachTextColumn) sn = eStartEachTextFrame; else if (sn == eStartEachTextFrame) sn = eStartEachPage; else if (sn == eStartEachPage) sn = eStartEachTextColumn;
result = table::set_headers_start (T, s1); result = table::set_footers_start (T, sn);
// After s1 = table::get_headers_start (T); wlog ("", "headers start changed = %d\n", s1);
sn = table::get_footers_start (T); wlog ("", "footers start changed = %d\n", sn);
return 0; }
static int table::get_footers_start(Table T)
Wo werden bei Tabellenümbrüchen die Fusszeilen der Tabelle wiederholt?
In comet_pdf hat der Aufruf keine Wirkung.
| Name | Typ | Default | Beschreibung |
| Return | int | Wo werden die Fusszeilen der Tabelle gezeigt? eStartEachTextColumn eStartEachTextFrame eStartEachPage |
|
| T | Table | - | Gültige Tabellenreferenz |
#include "internal/table.h"
int main () { Table T = table::alloc (); int s1, sn; int result;
table::get (T, 0, 0);
// Before s1 = table::get_headers_start (T); wlog ("", "headers start = %d\n", s1);
sn = table::get_footers_start (T); wlog ("", "footers start = %d\n", sn);
// Change if (s1 == eStartEachTextColumn) s1 = eStartEachTextFrame; else if (s1 == eStartEachTextFrame) s1 = eStartEachPage; else if (s1 == eStartEachPage) s1 = eStartEachTextColumn;
if (sn == eStartEachTextColumn) sn = eStartEachTextFrame; else if (sn == eStartEachTextFrame) sn = eStartEachPage; else if (sn == eStartEachPage) sn = eStartEachTextColumn;
result = table::set_headers_start (T, s1); result = table::set_footers_start (T, sn);
// After s1 = table::get_headers_start (T); wlog ("", "headers start changed = %d\n", s1);
sn = table::get_footers_start (T); wlog ("", "footers start changed = %d\n", sn);
return 0; }
static int table::set_headers_start(Table T, int newStart)
Wo sollen bei Tabellenümbrüchen die Kopfzeilen der Tabelle wiederholt werden?
In comet_pdf hat der Aufruf keine Wirkung.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| newStart | int | - | eStartEachTextColumn eStartEachTextFrame eStartEachPage |
#include "internal/table.h"
int main () { Table T = table::alloc (); int s1, sn; int result;
table::get (T, 0, 0);
// Before s1 = table::get_headers_start (T); wlog ("", "headers start = %d\n", s1);
sn = table::get_footers_start (T); wlog ("", "footers start = %d\n", sn);
// Change if (s1 == eStartEachTextColumn) s1 = eStartEachTextFrame; else if (s1 == eStartEachTextFrame) s1 = eStartEachPage; else if (s1 == eStartEachPage) s1 = eStartEachTextColumn;
if (sn == eStartEachTextColumn) sn = eStartEachTextFrame; else if (sn == eStartEachTextFrame) sn = eStartEachPage; else if (sn == eStartEachPage) sn = eStartEachTextColumn;
result = table::set_headers_start (T, s1); result = table::set_footers_start (T, sn);
// After s1 = table::get_headers_start (T); wlog ("", "headers start changed = %d\n", s1);
sn = table::get_footers_start (T); wlog ("", "footers start changed = %d\n", sn);
return 0; }
static int table::set_footers_start(Table T, int newStart)
Wo sollen bei Tabellenümbrüchen die Kopfzeilen der Tabelle wiederholt werden?
In comet_pdf hat der Aufruf keine Wirkung.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| newStart | int | - | eStartEachTextColumn eStartEachTextFrame eStartEachPage |
#include "internal/table.h"
int main () { Table T = table::alloc (); int s1, sn; int result;
table::get (T, 0, 0);
// Before s1 = table::get_headers_start (T); wlog ("", "headers start = %d\n", s1);
sn = table::get_footers_start (T); wlog ("", "footers start = %d\n", sn);
// Change if (s1 == eStartEachTextColumn) s1 = eStartEachTextFrame; else if (s1 == eStartEachTextFrame) s1 = eStartEachPage; else if (s1 == eStartEachPage) s1 = eStartEachTextColumn;
if (sn == eStartEachTextColumn) sn = eStartEachTextFrame; else if (sn == eStartEachTextFrame) sn = eStartEachPage; else if (sn == eStartEachPage) sn = eStartEachTextColumn;
result = table::set_headers_start (T, s1); result = table::set_footers_start (T, sn);
// After s1 = table::get_headers_start (T); wlog ("", "headers start changed = %d\n", s1);
sn = table::get_footers_start (T); wlog ("", "footers start changed = %d\n", sn);
return 0; }
static int table::get_skip_first_header(Table T)
Werden die Kopfzeilen der Tabelle am Tabellenanfang weggelassen?
In comet_pdf hat der Aufruf keine Wirkung.
| Name | Typ | Default | Beschreibung |
| Return | int | Werden die Kopfzeilen am Anfang weggelassen? 0 : Kopfzeilen zeigen 1 : Kopfzeilen weglassen |
|
| T | Table | - | Gültige Tabellenreferenz |
int main ()
{
Table T = table::alloc ();
int skip1, skipN;
int result;
table::get (T, 0, 0);
// Before
skip1 = table::get_skip_first_header (T);
wlog ("", "skip first = %d\n", skip1);
skipN = table::get_skip_last_footer (T);
wlog ("", "skip last = %d\n", skipN);
// Change
if (skip1) skip1 = 0;
else skip1 = 1;
if (skipN) skipN = 0;
else skipN = 1;
result = table::set_skip_first_header (T, skip1);
result = table::set_skip_last_footer (T, skipN);
// After
skip1 = table::get_skip_first_header (T);
wlog ("", "skip first changed = %d\n", skip1);
skipN = table::get_skip_last_footer (T);
wlog ("", "skip last changed = %d\n", skipN);
return 0;
}
static int table::get_skip_last_footer(Table T)
Werden die Fusszeilen der Tabelle am Tabellenende weggelassen?
In comet_pdf hat der Aufruf keine Wirkung.
| Name | Typ | Default | Beschreibung |
| Return | int | Werden die Fusszeilen am Anfang weggelassen? 0 : Fusszeilen zeigen 1 : Fusszeilen weglassen |
|
| T | Table | - | Gültige Tabellenreferenz |
int main ()
{
Table T = table::alloc ();
int skip1, skipN;
int result;
table::get (T, 0, 0);
// Before
skip1 = table::get_skip_first_header (T);
wlog ("", "skip first = %d\n", skip1);
skipN = table::get_skip_last_footer (T);
wlog ("", "skip last = %d\n", skipN);
// Change
if (skip1) skip1 = 0;
else skip1 = 1;
if (skipN) skipN = 0;
else skipN = 1;
result = table::set_skip_first_header (T, skip1);
result = table::set_skip_last_footer (T, skipN);
// After
skip1 = table::get_skip_first_header (T);
wlog ("", "skip first changed = %d\n", skip1);
skipN = table::get_skip_last_footer (T);
wlog ("", "skip last changed = %d\n", skipN);
return 0;
}
static int table::set_skip_first_header(Table T, int doSkip)
Sollen die Kopfzeilen der Tabelle am Tabellenanfang weggelassen werden?
In comet_pdf hat der Aufruf keine Wirkung.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| doSkip | int | - | 0 : Kopfzeilen am Tabllenstart zeigen 1 : Kopfzeilen am Tabellenstart weglassen |
int main ()
{
Table T = table::alloc ();
int skip1, skipN;
int result;
table::get (T, 0, 0);
// Before
skip1 = table::get_skip_first_header (T);
wlog ("", "skip first = %d\n", skip1);
skipN = table::get_skip_last_footer (T);
wlog ("", "skip last = %d\n", skipN);
// Change
if (skip1) skip1 = 0;
else skip1 = 1;
if (skipN) skipN = 0;
else skipN = 1;
result = table::set_skip_first_header (T, skip1);
result = table::set_skip_last_footer (T, skipN);
// After
skip1 = table::get_skip_first_header (T);
wlog ("", "skip first changed = %d\n", skip1);
skipN = table::get_skip_last_footer (T);
wlog ("", "skip last changed = %d\n", skipN);
return 0;
}
static int table::set_skip_last_footer(Table T, int doSkip)
Sollen die Fusszeilen der Tabelle am Tabellenende weggelassen werden?
In comet_pdf hat der Aufruf keine Wirkung.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| doSkip | int | - | 0 : Fusseilen am Tabellenende zeigen 1 : Fusszeilen am Tabellenende weglassen |
int main ()
{
Table T = table::alloc ();
int skip1, skipN;
int result;
table::get (T, 0, 0);
// Before
skip1 = table::get_skip_first_header (T);
wlog ("", "skip first = %d\n", skip1);
skipN = table::get_skip_last_footer (T);
wlog ("", "skip last = %d\n", skipN);
// Change
if (skip1) skip1 = 0;
else skip1 = 1;
if (skipN) skipN = 0;
else skipN = 1;
result = table::set_skip_first_header (T, skip1);
result = table::set_skip_last_footer (T, skipN);
// After
skip1 = table::get_skip_first_header (T);
wlog ("", "skip first changed = %d\n", skip1);
skipN = table::get_skip_last_footer (T);
wlog ("", "skip last changed = %d\n", skipN);
return 0;
}
static char* table::get_cellinfo(
Table T,
int left,
int top,
int which)
Experimentell Hole Informattingen über eine Tabellenzelle, die mit dem Tabellenmodul gesetzt wurden. Bisher iszt nur die Gruppenzugehörigkeit implementiert.
| Name | Typ | Default | Beschreibung |
| Return | char* | Wert.
Der Rückgabewert darf nicht verändert werden und wird bei folgenden Aufrufen der Funktion überschrieben. Hier finden Sie Informattingen zu readonly-Rückgaben von Funktionen. |
|
| T | Table | - | Gültige Tabellenreferenz |
| left, top | int | - | 0-basierter Zellenindex |
| which | int | - | Welche Eigeschaft soll erfragt werden? 1 : Gruppenzugehörigkeiten, eine Blank-gtrennte String-Liste der Gruppen, zu denen die Zelle gehört, z.B. "aaa" "bbb" (Die Anführungszeichen sind Teil des Strings.) |
static int table::set_cellinfo(
Table T,
int left,
int top,
char* property,
...)
Experimentell Setze für das Tabellenmodul Informattingen über eine Tabellenzelle.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| left | int | - | 0-basierter Spaltenindex |
| top | int | - | 0-basierter Zeilenindex |
| property | String oder char* | - | Welche Eigeschaft soll gesetzt werden? "groups" "rootTableRecordID" - nicht ganz eine Zelleneigenschaft, aber hier der Vollständigkeit halber "columnRecordID" "rowRecordID" "cellRecordID" |
| Eigenschaft "groups" | |||
| listOfGroups | String oder char* | "" | Vollständige Liste der Gruppen der Zelle. Die Gruppennamen werden jeweils in Anführungszeichen gesetzt und durch Leerzeichen getrennt, z.B. "\"Gruppe 1\" \"Gruppe 2\"" "'Gruppe 1' 'Gruppe 2'" Ein einzelner Gruppenname, der mit einem Buchstaben oder '_' beginnt und nur aus Buchstaben Zahlen und '_' besteht, darf auch ohne Anführungszeichen angegeben werden, z.B. "Gruppe_1" |
| refreshPanel | int | 0 | Soll die Palette Tabellenaufbau aktualisert werden? 0 : Nein, schneller 1 : Zeigt die Palette eine Zelle der aktuellen Tabelle, wird sie nach der Änderung aktualisiert. |
| Eigenschaften "rootTableRecordID", "columnRecordID", "rowRecordID", "cellRecordID" | |||
| id | int | 0 | ID1 der Tabelle, Zeile/Spalte/Zelle |
| id2, | int | 0 | ID2 der Tabelle, Zeile/Spalte/Zelle |
| id3 | int, | 0 | ID3 der Tabelle, Zeile/Spalte/Zelle |
| sid | String oder char* | "" | StringID der Tabelle, Zeile/Spalte/Zelle |
| refreshPanel | int | 0 | Soll die Palette Tabellenaufbau aktualisiert werden? 0 : Nein (schneller) 1 : Zeigt die Palette eine Zelle der aktuellen Tabelle, wird sie nach der Änderung aktualisiert. |
static int table::set_info1(
Table T,
char* info,
int refreshPanel = 0)
Setze die Informatting Info1 einer Tabelle.
Die Werte für Info1 und Info2 können auch direkt über den TaggedText gesetzt werden. Fügen Sie dazu in das TableStart-Tag folgende Informatting:
<TableStart:... <w2Table: Info1='your text' Info2=your text'> ... >
Die Texte müssen dabei richtig codiert sein:
Die Maskierung der < und > in \<0x00FC\gt; führt dazu, dass diese Strings nicht un-übersetzt eingesetzt werden können. Sie werden automatisch in das entsprechende UTF8-Zeichen übersetzt. Das liegt daran, dass die Stelle im Inneren der Plugins, die die Werte aus dem InDesign-Eingabe-Stream liest, von InDesign® für TaggedText und IDMS verwendet wird. Aber bei TaggedText gibt uns InDesign® hier bereits ein ü, bei IDMS aber noch ein <0x00FC> und wir können an dieser Stelle nicht erkennen, um welche Art Import es sich handelt.
Verwenden Sie in der Tabelle das Tabellenmodul der Plugins, muss der o.g. Inhalt für w2Table auch alle andreren Attribute des Tabellenmodules mit validen Werten enthalten. Exportieren Sie dazu die Tabelle einmal in TaggedText und übernehmen Sie das vollständige Tag aus dem exportierten Text.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| info | String oder char* | - | Setze diese Informatting für die Tabelle |
| refreshPanel | int | 0 | Soll die Palette Tabellenaufbau aktualisert werden? 0 : Nein, schneller 1 : Zeigt die Palette eine Zelle der aktuellen Tabelle, wird sie nach der Änderung aktualisiert. |
static int table::set_info2(
Table T,
char* info,
int refreshPanel = 0)
Setze die Informatting Info2 einer Tabelle.
Die Werte für Info1 und Info2 können auch direkt über den TaggedText gesetzt werden. Fügen Sie dazu in das TableStart-Tag folgende Informatting:
<TableStart:... <w2Table: Info1='your text' Info2=your text'> ... >
Die Texte müssen dabei richtig codiert sein:
Die Maskierung der < und > in \<0x00FC\gt; führt dazu, dass diese Strings nicht un-übersetzt eingesetzt werden können. Sie werden automatisch in das entsprechende UTF8-Zeichen übersetzt. Das liegt daran, dass die Stelle im Inneren der Plugins, die die Werte aus dem InDesign-Eingabe-Stream liest, von InDesign® für TaggedText und IDMS verwendet wird. Aber bei TaggedText gibt uns InDesign® hier bereits ein ü, bei IDMS aber noch ein <0x00FC> und wir können an dieser Stelle nicht erkennen, um welche Art Import es sich handelt.
Verwenden Sie in der Tabelle das Tabellenmodul der Plugins, muss der o.g. Inhalt für w2Table auch alle andreren Attribute des Tabellenmodules mit validen Werten enthalten. Exportieren Sie dazu die Tabelle einmal in TaggedText und übernehmen Sie das vollständige Tag aus dem exportierten Text.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| info | String oder char* | - | Setze diese Informatting für die Tabelle |
| refreshPanel | int | 0 | Soll die Palette Tabellenaufbau aktualisert werden? 0 : Nein, schneller 1 : Zeigt die Palette eine Zelle der aktuellen Tabelle, wird sie nach der Änderung aktualisiert. |
static char* table::get_info1(Table T)
Hole die in einer Tabelle hinterlegte Informatting Info1.
| Name | Typ | Default | Beschreibung |
| Return | char* | Info1 der Tabelle "" : Fehler oder leer Der Rückgabewert darf nicht verändert werden und wird bei folgenden Aufrufen der Funktion überschrieben. Hier finden Sie Informattingen zu readonly-Rückgaben von Funktionen. |
|
| T | Table | - | Gültige Tabellenreferenz |
static char* table::get_info2(Table T)
Hole die in einer Tabelle hinterlegte Informatting Info2.
| Name | Typ | Default | Beschreibung |
| Return | char* | Info2 der Tabelle "" : Fehler oder leer Der Rückgabewert darf nicht verändert werden und wird bei folgenden Aufrufen der Funktion überschrieben. Hier finden Sie Informattingen zu readonly-Rückgaben von Funktionen. |
|
| T | Table | - | Gültige Tabellenreferenz |
static int table::get_table_placeholder_id(Table T)
Hole die ID des Tabellenplatzhalters, mit der eine Tabelle aufgebaut wurde. Tabellen, die mit Hilfe eines Tabellenplatzhalters aufgebaut wurden, tragen diese PlatzhalterID als persistente Kennung. Diese Angabe kann nicht entfernt oder geändert werden und bleibt auch erhalten, wenn die Tabelle kopiert wird.
| Name | Typ | Default | Beschreibung |
| Return | int | ID des Tabellenplatzhalters, der diese Tabelle aufgebaut hat | |
| T | Table | - | gültige Tabellenreferenz |
Tabellenplatzhalter, der die erste Tabelle eines Textes aufgebaut hat.
int main ()
{
Table t = table::alloc ();
table::get (t, gFrame, 0);
wlog ("", "# Original placeholder of %d: %d ('%s')\n",
item::getint (t),
table::get_table_placeholder_id (t),
table::get_table_placeholder_text (t));
return 0;
}
static char* table::get_table_placeholder_text(Table T)
Hole den Ursprungstext des Tabellenplatzhaltern, mit der eine Tabelle aufgebaut wurde. Tabellen, die mit Hilfe eines Tabellenplatzhalters aufgebaut wurden, tragen diesn Text als persistente Kennung. Diese Angabe kann nicht entfernt oder geändert werden und bleibt auch erhalten, wenn die Tabelle kopiert wird.
| Name | Typ | Default | Beschreibung |
| Return | char* | Unformatierter Text des Platzhalters, der diese Tabelle aufgebaut hat. "" : Fehler oder leer Der Rückgabewert darf nicht verändert werden und wird bei folgenden Aufrufen der Funktion überschrieben. Hier finden Sie Informattingen zu readonly-Rückgaben von Funktionen. |
|
| T | Table | - | gültige Tabellenreferenz |
Tabellenplatzhalter, der die erste Tabelle eines Textes aufgebaut hat.
int main ()
{
Table t = table::alloc ();
table::get (t, gFrame, 0);
wlog ("", "# Original placeholder of %d: %d ('%s')\n",
item::getint (t),
table::get_table_placeholder_id (t),
table::get_table_placeholder_text (t));
return 0;
}
static float table::get_row_height(
Table T,
int startRow,
int count = 1)
Höhe von Tabellenzeilen. Die Funktion ermittelt die Höhe eines zusammenhängenden Bereiches von Tabellenzeilen.
Bei Verwendung der Funktion mit comet_pdf ermittelt die Funktion die Höhe, mit der die Zeile angelegt wurde bzw. den letzten Wert, den resize_rows gesetzt hat. Diese Angaben können von der tatsächlichen Zeilenhöhe im erzeugten PDF abweichen.
| Name | Typ | Default | Beschreibung |
| Return | float | > 0.0 : Aktuelle Höhe des Zeilenbereiches in Punkten (pts) 0.0 : Fehler |
|
| T | Table | - | gültige Tabellenreferenz |
| startRow | int | - | Ersten Zeile des Bereiches (0-basiert) |
| count | int | 1 | Wieviele Zeilen sollen in die Berechnung einfließen? |
static float table::get_row_max_height(
Table T,
int startRow,
int count = 1)
Maximale Höhe von Tabellenzeilen. Die Funktion ermittelt die maximale Höhe eines zusammenhängenden Bereiches von Tabellenzeilen.
| Name | Typ | Default | Beschreibung |
| Return | float | > 0.0 : Maximale Höhe des Zeilenbereiches in Punkten (pts) 0.0 : Fehler |
|
| T | Table | - | gültige Tabellenreferenz |
| startRow | int | - | Erste Zeile des Bereiches (0-basiert) |
| count | int | 1 | Wieviele Zeilen sollen in die Berechnung einfließen? |
static float table::get_row_min_height(
Table T,
int startRow,
int count = 1)
Minimale Höhe von Tabellenzeilen. Die Funktion ermittelt die minimale Höhe eines zusammenhängenden Bereiches von Tabellenzeilen.
| Name | Typ | Default | Beschreibung |
| Return | float | > 0.0 : Maximale Höhe des Zeilenbereiches in Punkten (pts) 0.0 : Fehler |
|
| T | Table | - | gültige Tabellenreferenz |
| startRow | int | - | Erste Zeile des Bereiches (0-basiert) |
| count | int | 1 | Wieviele Zeilen sollen in die Berechnung einfließen? |
static float table::get_col_width(
Table T,
int startCol,
int count = 1)
Breite von Tabellenspalten. Die Funktion ermittelt die Breite eines zusammenhängenden Bereiches von Tabellenspalten.
| Name | Typ | Default | Beschreibung |
| Return | float | > 0.0 : Breite des Spaltenbereiches in Punkten (pts) 0.0 : Fehler |
|
| T | Table | - | gültige Tabellenreferenz |
| startRow | int | - | Erste Spalte des Bereiches (0-basiert) |
| count | int | 1 | Wieviele Spalten sollen in die Berechnung einfließen? |
static int table::cell::set_text(
Table T,
int left,
int top,
char* str,
int insert_pos =0,
int remove_len =-1,
int autoload = 0)
Setze den Text eines Tabellenfeldes.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Verwendete Tabelle |
| left | int | - | Spalte (0-basiert) |
| top | int | - | Zeile (0-basiert) |
| str | String oder char* | - | Einzufügender Text. TaggedText (%!TT, ...) wird von dieser Funktion nicht unterstützt! Um TaggedText einzufügen, verwenden Sie die Funktion table::insert_taggedtext bzw. table::cell::insert_taggedtext. |
| insert_pos | int | Textanfang | Einfügeposition relativ zum Tabellenfeld |
| remove_len | int | bis Textende | Länge des vorher zu löschenden Textes |
| autoload | int | 0 | Sollen Platzhalter im Text automatisch neugeladen werden? 0 : nicht laden, default sonst : neu laden Von Illustrator® wird der Parameter ignoriert. |
int main ()
{
Table T = table::alloc ();
if (!T) return 0;
if (table::get (T, 0, 0) != 0)
{
table::release (T);
return 0 ;
}
table::set_text (T, 1, 1, "Hallo Clara");
table::release (T);
return 0;
}
static char* table::cell::get_text(
Table T,
int left,
int top,
char* str,
int fmt = kExportPlain)
Hole den Text eines Tabellenfeldes. Der Ergebnisstring muss genügend groß sein, um das Ergebnis aufnehmen zu können.
Textvariablen werden bei Exportformaten, die reinen Text exportieren (kExportPlain, ...) nicht ersetzt. Der exportierte Text enthält an den Stellen, an denen sich Variablen befinden, den von InDesign® verwendeten internen Zeichencode. Von den ab v3.3 R2883 eingeführten ~Plus~-Formaten werden die Variablen-Platzhalter durch den aktuell im Dokument angezeigten Text ersetzt.
| Name | Typ | Default | Beschreibung |
| Return | String oder char* (Abhängig von Parameter str) | Textinhalt des Tabellenfeldes (entspricht Parameter str) | |
| T | Table | - | verwendete Tabelle |
| left | int | - | Spalte (0-basiert) |
| top | int | - | Zeile (0-basiert) |
| str | String oder char* | - | Reservierter Speicher für das Ergebnis |
| fmt | int | kExportPlain | Exportformat, siehe hier |
int main ()
{
char s [1000];
Table T = table::alloc ();
if (!T) return 0;
if (table::get (T, 0, 0) != 0)
{
table::release (T);
return 0;
}
showmessage ("%s", table::get_text (T, 2,0, s));
showmessage (s);
table::release (T);
return 0;
}
static int table::cell::get_textpos(
Table T,
int cell_x,
int cell_y,
int* start,
int* len)
Textposition und -länge einer Tabellenzelle.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| cell_x | int | - | 0-basierte Tabellenspalte |
| cell_y | int | - | 0-basierte Tabellenzeile |
| start | int* | - | Position im Textmodell, an der der Text der Tabellenzelle beginnt. |
| len | int* | - | Länge des Textes der Tabellenzelle. |
Ein Beispiel zur Verwendung der Funktion finden Sie unter table::create.
static int table::cell::insertimage(
Table T,
int col,
int row,
char* path,
float w = -1.0,
float h = -1.0,
int align = 5,
float boundingBox = 0.0,
int start = 0,
int len = -1,
int pindex = -2,
int clipToFrame = 0,
int flags = 4,
float tolerance = 0.0,
float minPathSz = 0.0,
float inset = 0.0)
Einfügen eines Bildes in eine Zelle einer Tabelle. Bestehender Text kann teilweise oder ganz gelöscht werden. Das Bild kann skaliert werden. Das Bild wird direkt in das Dokument eingesetzt, nicht als Referenz.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| col | int | - | Spalte (0-basiert) |
| row | int | - | Zeile (0-basiert) |
| Allgemeine Bildangaben | |||
| path | String oder char* | - | Vollständiger Pfad auf die Bilddatei |
| w | float | -1.0 | Breite des Bildrahmens -1.0 : Breite der Tabellenspalte verwenden |
| h | float | -1.0 | Höhe des Bildrahmens -1.0 : Höhe der Tabellenspalte verwenden |
| align | int | kMiddle | Bildposition im Rahmen, siehe Bildpositionen |
| boundingBox | float | 0.0 | Angabe zur Größe des Bildes im Rahmen. Angabe in Punkten. 0.0 : Bild proportional in den Rahmen einpassen. Ist das Bild kleiner als der Rahmen, wird es nicht verändert. >0.0 : Bild proportional in einen quadratischen Rahmen dieser Größe einpassen. Ist das Bild kleiner, wird es nicht verändert. <0.0 : Bild proportional in einen quadratischen Rahmen des Betrages dieser Größe einpassen. Ist das Bild kleiner, wird es entsprechend vergössert. |
| Textangaben | |||
| start_pos | int | 0 | Einfügestelle für das Bild |
| len | int | kEnd | Länge des Textes, der vor dem Einfügen des Bildes gelöscht werden soll kEnd Bis Zellenende löschen |
| Freistellpfad | |||
| pindex | int | kIgnoreClipping | 0-basierter Freistellpfad kIgnoreClipping : Keinen Freistellpfad verwenden kResetClipping : Freistellpfad beim Einfügen des Bildes zurücksetzen. >=0 : 0-basierter Pfadindex |
| cliptoFrame | int | 0 | Soll der Freistellpfad als Rahmenbegrenzung verwendet werden? 0 : Bestehenden Rahmen behalten 1 : Rahmen ändern |
| tolerance | float | 0.0 | A tolerance value specifying how close to the original path we must be if we smooth
the path. 0.0 indicates a perfect match. Smoothing may simplify the path, reducing the number of points. |
| minPathSize | float | 0.0 | subpaths smaller than the minPathSize will be deleted |
| inset | float | 0.0 | how far to inset the path |
static int table::cell::insert_taggedtext(
Table T,
int col,
int row,
char* text,
int start_pos =0,
int len =-1,
int autoload =0)
Einfügen TaggedText. Bestehender Text kann kann teilweise oder ganz gelöscht werden.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| col | int | - | Spalte (0-basiert) |
| row | int | - | Zeile (0-basiert) |
| text | String oder char* | - | Tagged Text |
| start_pos | int | Textanfang | Ab hier soll der Stil angewandt werden |
| len | int | bis Textende | Länge des Textes pro Zelle, dessen Formatierung geändert werden soll |
| autoload | int | 0 | Sollen im Text enthaltene Platzhalter automatisch geladen werden? 0 : Nicht laden sonst : Laden |
int main ()
{
char tt[2000];
Table t = table::alloc ();
if (!T) return 0;
if (table::get (T, 0, 1) != 0)
{
table::release (T);
return 0;
}
strcpy (tt "" );
strcat (tt, "\r\n");
strcat (tt, "" );
strcat (tt, " );
strcat (tt, "0.000000,0.000000,0.000000,1.000000>>");
strcat (tt, "\r\n");
strcat (tt, "" );
strcat (tt, "" );
strcat (tt, "WERK II" );
strcat (tt, "" );
table::insert_taggedtext (T, 0, 1, p, 1, -1);
table::release (T);
return 0;
}
static int table::cell::inserttext(
Table T,
int col,
int row,
char* text,
int start_pos =0,
int len =-1,
int autoload =0)
Wie insert_taggedtext.
static int table::cell::is_overset(
Table T,
int left,
int top,
int* ovIndex = 0)
Hat die Tabellenzelle einen Overset?
Die Funktion ermittelt, ob eine Tabellenzelle einen Übersatz hat. Ob die ganze Zelle im Übersatz liegt, können Sie mit
folgenden Zeilen ermitteln:
table::cell::get_textpos (T, col, row, &start, &len);
if (textmodel::position_visible (gFrame, start))
| Name | Typ | Default | Beschreibung |
| Return | int | 0 : Text passt oder der Overset kann nicht ermittelt werden 1 : Der Text passt nicht in die Tabellenzeile |
|
| T | Table | - | verwendete Tabelle |
| left | int | - | Spalte (0-basiert) |
| top | int | - | Zeile (0-basiert) |
| ovIndex | int* | 0 | Index des ersten Zeichens im Übersatz. (Nur gesetzt, wenn die Zelle einen Übersatz hat). |
Beim Umbrechen von Tabellen entstehen bei hohen Tabellenzeilen mitunter große Leerräume in den Rahmen. Die Funktion fügt in diesem Fall eine weitere Zeile ein, die diesen Platz genau füllt und korrigiert dann die Zelleninhalte. Die Funktion behebt dieses Verhalten nur beim ersten Umbruch!
#include "internal/types.h" #include "internal/text.h" #include "internal/table.h"
int main () { Table T = table::alloc (); int result = 0; float minHeight = 20.0; float grace = 2.0; float l, t, r, b; float fl, ft, fr, fb; int i; ItemRef pref = item::alloc (); int firstRow = 0; int rowToBreak= -1; float newHeight = 0.0; int ovi, start, len; char* txt = 0;
frame::bbox (gFrame, &fl, &ft, &fr, &fb);
result = table::get (T, 0, 0); if (result) { showmessage ("Keine Tabelle"), return 0; }
for (i = 0; i < table::rows (T); i++) { firstRow = 0; table::cell::get_box (T, 0, i, kFrameRelative, &l, &t, &r, &b, pref, &firstRow); if (firstRow && i > 0) { // Die Zeile davor muss evtl. höher werden. table::cell::get_box (T, 0, i-1, kFrameRelative, &l, &t, &r, &b, pref, &firstRow); if (b < (fb-ft)- minHeight) rowToBreak = i; break; } } if (rowToBreak < 0) return 0;
// Neue Zeile einfügen und Höhe der Zeile *rowToBreak* anpassen // Diese Zeile hat danach einen Übersatz. // Die neue Höhe der Zeile wird ein bisschen kleiner gemacht. Hier muss / / eigentlich auch die Rahmenhöhe und die Breite der Zellränder beachtet werden. newHeight = ((fb-ft) - b) - grace; table::insert_rows (T, rowToBreak, 1); table::resize_rows (T, rowToBreak, 1, newHeight, -1.0, newHeight); textmodel::force_redraw (gFrame);
// übersätze aufheben txt = alloc (32768); for (i = 0; i < table::columns (T); i++) { if (table::cell::is_overset (T, i, rowToBreak, &ovi)) { table::cell::get_text (T, i, rowToBreak, txt, kExportTT); table::cell::insert_taggedtext (T, i, rowToBreak+1, txt);
// Übersatztext löschen table::cell::get_textpos (T, i, rowToBreak, &start, &len); frame::replace (gFrame, "", start+ovi, len -ovi);
// Doppelten Zelltext löschen table::cell::get_textpos (T, i, rowToBreak+1, &start, &len); frame::replace (gFrame, "", start, ovi);
textmodel::force_redraw (gFrame); } } release (txt);
// Höhe der neuen Zeile anpassen table::resize_rows (T, rowToBreak+1, 1, 0.0, -1.0, -1.0); textmodel::force_redraw (gFrame);
return 0; }
static int table::cell::get_size(
Table T,
int x,
int y,
int areaType,
float* width,
float* height)
Ermittle die Größe einer Tabellenzelle. Die Angaben erfolgen in Punkten.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| x | int | - | 0-basierte Nummer der Spalte |
| y | int | - | 0-basierte Nummer der Zeile |
| areaType | int | - | Welche Größe der Zelle soll berechnet werden?![]() 0 : Tatsächliche Größe der Zelle 1 : Größe des Inhaltsbereiches der Zelle. Der Inhaltsbereich ist an jeder Seite um das Maximum von Inset und halber Konturbreite kleiner als die tatsächliche Zellgröße. 2 : Größe innerhalb der Zellkontur. Für verdeckte Zellen von Zellverbindungen (Merges) ist die Größe des Zellinhaltes nicht eindeutig definiert. Unter InDesign® wird hier die Größe des Zellinhaltes des gesamten Zellverbundes ermittelt. comet_pdf liefert die hypotethische Zellgröße minus Zellkanten minus Zell-Insets. |
| width | float* | - | Bei return=0 : Breite der Spalte sonst undefiniert |
| heigth | float* | - | Bei return=0 : Höhe der Spalte sonst undefiniert |
Bestimme Breite und Höhe der ersten Spalte der zweiten Zeile. Ziehe dabei die Insets nicht ab.
int res; float cw, ch;
res = table::get_cellsize ( t, 0, 1, 0, &cw, &ch);
if (res == 0)showmessage ("%f x %f", cw, ch);
static int table::cell::get_box(
Table T,
int x,
int y,
int area,
float* left,
float* top,
float* right,
float* bottom,
ItemRef parentRef = 0,
int* first_row_in_frame = 0,
int* pg = 0,
char* lay = 0)
Ermittle die Fläche einer Tabellenzelle.
Die Funktion kann drei verschiedene Flächentypen berechnen. Die Auswahl wird mit Hilfe des Parameters area festgelegt.
Im Bild sehen die drei verschiedenen Flächen:
Die Angaben können relativ zu den folgenden Bezugspunkten berechnet werden:
Beachten Sie bitte, dass für Zellen im Übersatz natürlich keine rahmen- und seitenrelativen Berechnungen gemacht werden können. Für Zellen im Übersatz wird die Fläche immer relativ zur Tabelle berechnet und der Wert von parentRef auf undefined gesetzt. Das Ergebnis von parentRef kann mit item::defined geprüft werden.
Mit folgendem Code-Schnipsel können Sie auch voher schon prüfen, ob eine Zelle im Übersatz liegt:
table::cell::get_textpos (T, x, y, &start, &len);
if (!textmodel::position_visible (fr, start))
{
// Cell in overset
}
Für verdeckte Zellen von Zellverbindungen (Merges) wird automatisch die Ankerzelle zur Berechnung verwendet. Mit table::cell::is_anchor kann erfragt werden, ob einen Zelle eine Ankerzelle ist.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Verwendete Tabelle |
| x, y | int | -,- | Spalten- und Zeilenindex der Zelle (0-basiert). Für verdeckte Zellen von Zellverbindungen (Merges) wird automatisch die Ankerzelle zur Berechnung verwendet. Mit table::cell::is_anchor kann erfragt werden, ob einen Zelle eine Ankerzelle ist. |
| area | int | - | Welche Zellfläche soll berechnet werden? Folgende Angaben sind erlaubt:![]() tabellen-relativ kCellRect (0) kCellInner (6) kCellContent (1) rahmen-relativ kCellFrameRelRect (2) kCellFrameRelInner (4) kCellFrameRelContent (7) seiten-relativ kCellPageRelRect (3) kCellPageRelInner (5) kCellPageRelContent (8) Von comet_pdf werden die rahmen- und seitenreleativen Angaben ignoriert und immer tabellen-relative Werte berechnet. |
| left | float* | - | Bei return=0 : Linke Seite der Zellfläche in Punkten sonst undefiniert |
| top | float* | - | Bei return=0 : Obere Seite der Zellfläche in Punkten sonst undefiniert |
| right | float* | - | Bei return=0 : Rechte Seite der Zellfläche in Punkten sonst undefiniert |
| bottom | float* | - | Bei return=0 : Untere Seite der Zellfläche in Punkten sonst undefiniert |
| parentRef | ItemRef | 0 | Textrahmen, in der die Zelle liegt Bei Zellen im Übersatz ist die Angabe leer. Verwenden Sie item::defined zur Prüfung! Der Parameter wird von comet_pdf nicht unterstützt. |
| first_row_in_frame | int* | 0 | Ist die Zelle in der ersten Zeile des Rahmens? Der Parameter wird von comet_pdf nicht unterstützt. |
| pg | int* | 0 | 1-basierte Seitennummer des Rahmens in dem die Tabellenzelle liegt.
Bei Zellen im Übersatz bleibt die Angabe unverändert! Der Parameter wird von comet_pdf nicht unterstützt. |
| lay | String oder char* | 0 | Ebene des Rahmens, in dem die Tabellenzelle liegt.
Bei Zellen im Übersatz bleibt die Angabe unverändert! Der Parameter wird von comet_pdf nicht unterstützt. |
Setze über Zelle der aktuellen Textauswahl einen Rahmen. Der Rahmen (hier 397) muß im Dokument existieren! Beachten Sie insbesondere, dass tf als ItemRef bereits ein Pointer ist und deshalb beim Aufruf von table::cell::get_box kein & benötigt!
#include "internal/types.h"
int main () { int selStart; int row, col; // Table and cell insex float l, t, r, b; // Cell co-ordinates int isFirst; Table T = table::alloc (); ItemRef tf = item::alloc (); // Text frame containing the cell ItemRef fr = item::alloc (); // Use this frame to show the result
textmodel::selection (&selStart, 0, 0, 0, T, &col, &row);
if (!item::defined (T)) return 0; item::define (fr, gFrame, 397); // Fill in an existing UID!
table::cell::get_box (T, col, row, kCellPageRelInner, &l, &t, &r, &b, tf, &isFirst);
if (item::defined (tf)) { frame::moveto (fr, l, t); frame::resize (fr, r-l, b-t); if (isFirst) frame::color_rgb (fr, 0, 0, 255); else frame::color_rgb (fr, 0, 255, 0); } else { frame::color_rgb (fr, 255, 0, 0); }
return 0; }
Beim Umbrechen von Tabellen entstehen bei hohen Tabellenzeilen mitunter große Leerräume in den Rahmen. Die Funktion fügt in diesem Fall eine weitere Zeile ein, die diesen Platz genau füllt und korrigiert dann die Zelleninhalte. Die Funktion behebt dieses Verhalten nur beim ersten Umbruch!
#include "internal/types.h" #include "internal/text.h" #include "internal/table.h"
int main () { Table T = table::alloc (); int result = 0; float minHeight = 20.0; float grace = 2.0; float l, t, r, b; float fl, ft, fr, fb; int i; ItemRef pref = item::alloc (); int firstRow = 0; int rowToBreak= -1; float newHeight = 0.0; int ovi, start, len; char * txt = 0;
frame::bbox (gFrame, &fl, &ft, &fr, &fb);
result = table::get (T, 0, 0); if (result) { showmessage ("Keine Tabelle"), return 0; }
for (i = 0; i < table::rows (T); i++) { firstRow = 0; table::cell::get_box (T, 0, i, kFrameRelative, &l, &t, &r, &b, pref, &firstRow);
if (firstRow && i > 0) { // Die Zeile davor muss evtl. höher werden. table::cell::get_box (T, 0, i-1, kFrameRelative, &l, &t, &r, &b, pref, &firstRow); if (b < (fb-ft)- minHeight) rowToBreak = i; break; } } if (rowToBreak < 0) return 0;
// Neue Zeile einfügen und Höhe der Zeile *rowToBreak* anpassen // Diese Zeile hat danach einen Übersatz. // Die neue Höhe der Zeile wird ein bisschen kleiner gemacht. Hier muss // eigentlich auch die Rahmenhöhe und die Breite der Zellränder beachtet werden. newHeight = ((fb-ft) - b) - grace; table::insert_rows (T, rowToBreak, 1); table::resize_rows (T, rowToBreak, 1, newHeight, -1.0, newHeight); textmodel::force_redraw (gFrame);
// übersätze aufheben txt = alloc (32768); for (i = 0; i < table::columns (T); i++) { if (table::cell::is_overset (T, i, rowToBreak, &ovi)) { table::cell::get_text (T, i, rowToBreak, txt, kExportTT); table::cell::insert_taggedtext (T, i, rowToBreak+1, txt);
// Übersatztext löschen table::cell::get_textpos (T, i, rowToBreak, &start, &len); frame::replace (gFrame, "", start+ovi, len -ovi);
// Doppelten Zelltext löschen table::cell::get_textpos (T, i, rowToBreak+1, &start, &len); frame::replace (gFrame, "", start, ovi); textmodel::force_redraw (gFrame); } } release (txt);
// Höhe der neuen Zeile anpassen table::resize_rows (T, rowToBreak+1, 1, 0.0, -1.0, -1.0); textmodel::force_redraw (gFrame);
return 0; }
static int table::cell::get_insets(
Table T,
int x,
int y,
float* left,
float* top,
float* right,
float* bottom)
Ermittle die Insets einer Tabellenzelle in Punkten.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| x | int | - | 0-basierte Nummer der Spalte |
| y | int | - | 0-basierte Nummer der Zeile |
| left | float* | - | Bei return=0 : Linker Abstand sonst undefiniert |
| top | float* | - | Bei return=0 : Oberer Abstand sonst undefiniert |
| right | float* | - | Bei return=0 : Rechter Abstand sonst undefiniert |
| bottom | float* | - | Bei return=0 : Unterer Abstand sonst undefiniert |
static int table::cell::get_fillcolor_rgb(
Table T,
int row,
int col,
char* colName = 0,
int* r = 0,
int* g = 0,
int* b = 0,
float* tint = 0,
int* overprint = 0)
Füllfarbe einer Tabellenzelle ermitteln. Es werden die RGB-Werte der Farbe ermittelt. Zusätzlich kann der Farbton ermittelt werden und ob die Zelle Konturen überdrucken darf.
Die Funktion benötigt mglw. Farb-Konvertierungen. Für comet_pdf müssen dafür die Farbprofile vollständig konfiguriert sein und die Eingabe-W2ML muß mind. aus v4.0.5 R13799 sein.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| row | int | - | 0-basierte Tabellenzeile |
| col | int | - | 0-basierte Tabellenspalte |
| colName | String oder char* | 0 | Name der Farbe. Der Wert kann nur für Standardfarben und Farben ermittelt werden, die im Dokument definiert sind. |
| r, g, b | int* | 0 | RGB-Anteile der Farbe im Bereich 0-255 Verwendet die Zelle die "Farbe" [Ohne], erhalten r, g und b den Wert -254. |
| tint | float* | 0 | Farbton im Bereich 0.0 - 100.0 |
| overprint | int* | 0 | überdruckt die Füllfarbe? 0: Nein 1: Ja |
static int table::cell::get_fillcolor_cmyk(
Table T,
int row,
int col,
char* colName = 0,
float* c = 0,
float* m = 0,
float* y = 0,
float* k = 0,
float* tint = 0,
int* overprint = 0)
Füllfarbe einer Tabellenzelle ermitteln. Es werden die CMYK-Werte der Farbe ermittelt. Zusätzlich kann der Farbton ermittelt werden und ob die Zelle Konturen überdrucken darf.
Die Funktion benötigt mglw. Farb-Konvertierungen. Für comet_pdf müssen dafür die Farbprofile vollständig konfiguriert sein und die Eingabe-W2ML muß mind. aus v4.0.5 R13799 sein.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| row | int | - | 0-basierte Tabellenzeile |
| col | int | - | 0-basierte Tabellenspalte |
| colName | String oder char* | 0 | Name der Farbe. Der Wert kann nur für Standardfarben und Farben ermittelt werden, die im Dokument definiert sind. |
| c, m, y, k | float* | 0 | CMYK-Anteile der Farbe im Bereich 0.0 - 100.0 Verwendet die Zelle die "Farbe" [Ohne], erhalten c, m, y und k den Wert -100.0. |
| tint | float* | 0 | Farbton im Bereich 0.0 - 100.0 |
| overprint | int* | 0 | überdruckt die Füllfarbe? 0: Nein 1: Ja |
static int table::cell::get_fillcolor_lab(
Table T,
int row,
int col,
char* colName = 0,
int* L = 0,
int* a = 0,
int* b = 0,
float* tint = 0,
int* overprint = 0)
Füllfarbe einer Tabellenzelle ermitteln. Es werden die Lab-Werte der Farbe ermittelt. Zusätzlich kann der Farbton ermittelt werden und ob die Zelle Konturen überdrucken darf.
Die Funktion benötigt mglw. Farb-Konvertierungen. Für comet_pdf müssen dafür die Farbprofile vollständig konfiguriert sein und die Eingabe-W2ML muß mind. aus v4.0.5 R13799 sein.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| row | int | - | 0-basierte Tabellenzeile |
| col | int | - | 0-basierte Tabellenspalte |
| colName | String oder char* | 0 | Name der Farbe. Der Wert kann nur für Standardfarben und Farben ermittelt werden, die im Dokument definiert sind. |
| L | float* | 0 | L-Anteil der Farbe im Bereich 0.0 -100.0 Verwendet die Zelle die "Farbe" [Ohne], erhält L den Wert -1.0. |
| a, b | int* | 0 | a,b-Anteile der Farbe im Bereich -128 - 127
Verwendet die Zelle die "Farbe" [Ohne], erhalten a und b den Wert -1. |
| tint | float* | 0 | Farbton im Bereich 0.0 - 100.0 |
| overprint | int* | 0 | überdruckt die Füllfarbe? 0: Nein 1: Ja |
static int table::cell::get_stroke(
Table T,
int row,
int col,
int side,
int* linetype,
float* weight)
Rahmentyp und -stärke einer Seite einer Tabellenzelle ermitteln.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| row | int | - | 0-basierte Tabellenzeile |
| col | int | - | 0-basierte Tabellenspalte |
| side | int | - | Einer der folgenden Werte. Mit den negativen Werten wird die Farbe der Kanten-"Löcher" erfragt: eLeftSide eRightSide eTopSide eBottomSide eDiagonal |
| type | int* | 0 | Linientyp. Folgende Werte können zurückgegeben werden: eNone eSolid eThickThick eThinThin eThickThin eThinThick eThickThinThick eThinThickThin seit Version 1.1.19 (8. April 2004): eDashed eDash4X4 eDash3X2 eDots eWavy eStraightHash eRightSlant eLeftSlant eDiamond eJapaneseDots eTriple eTableStrip |
| weight | float* | 0 | Als Rückgabe Linienstärke in Punkten |
static int table::cell::get_strokecolor_rgb(
Table T,
int row,
int col,
int side,
char* colName = 0,
int* r = 0,
int* g = 0,
int* b = 0,
float* tint = 0,
int* overprint = 0)
Rahmenfarbe einer Seite einer Tabellenzelle ermitteln. Es werden die RGB-Werte der Farbe ermittelt. Zusätzlich kann der Farbton ermittelt werden und ob die Zelle Konturen überdrucken darf.
Die Funktion benötigt mglw. Farb-Konvertierungen. Für comet_pdf müssen dafür die Farbprofile vollständig konfiguriert sein und die Eingabe-W2ML muß mind. aus v4.0.5 R13799 sein.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| row | int | - | 0-basierte Tabellenzeile |
| col | int | - | 0-basierte Tabellenspalte |
| side | int | - | Einer der folgenden Werte. Mit den negativen Werten wird die Farbe der Kanten-"Löcher" erfragt: ±eLeftSide ±eRightSide ±eTopSide ±eBottomSide ±eDiagonal |
| colName | String oder char* | 0 | Name der Farbe. Der Wert kann nur für Standardfarben und Farben ermittelt werden, die im Dokument definiert sind. |
| r, g, b | int* | 0 | RGB-Anteile der Farbe im Bereich 0-255 |
| tint | float* | 0 | Farbton im Bereich 0.0 - 100.0 |
| overprint | int* | 0 | überdruckt die Konturfarbe? 0: Nein 1: Ja |
static int table::cell::get_strokecolor_cmyk(
Table T,
int row,
int col,
int side,
char* colName = 0,
float* c = 0,
float* m = 0,
float* y = 0,
float* k = 0,
float* tint = 0,
int* overprint = 0)
Rahmenfarbe einer Seite einer Tabellenzelle ermitteln. Es werden die CMYK-Werte der Farbe ermittelt. Zusätzlich kann der Farbton ermittelt werden und ob die Zelle Konturen überdrucken darf.
Die Funktion benötigt mglw. Farb-Konvertierungen. Für comet_pdf müssen dafür die Farbprofile vollständig konfiguriert sein und die Eingabe-W2ML muß mind. aus v4.0.5 R13799 sein.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| row | int | - | 0-basierte Tabellenzeile |
| col | int | - | 0-basierte Tabellenspalte |
| side | int | - | Einer der folgenden Werte. Mit den negativen Werten wird die Farbe der Kanten-"Löcher" erfragt: ±eLeftSide ±eRightSide ±eTopSide ±eBottomSide ±eDiagonal |
| colName | String oder char* | 0 | Name der Farbe. Der Wert kann nur für Standardfarben und Farben ermittelt werden, die im Dokument definiert sind. |
| c, m, y, k | float* | 0 | CMYK-Anteile der Farbe im Bereich 0.0 -100.0 |
| tint | float* | 0 | Farbton im Bereich 0.0 - 100.0 |
| overprint | int* | 0 | überdruckt die Konturfarbe? 0: Nein 1: Ja |
static int table::cell::get_strokecolor_lab(
Table T,
int row,
int col,
int side,
char* colName = 0,
int* L = 0,
int* a = 0,
int* b = 0,
float* tint = 0,
int* overprint = 0)
Rahmenfarbe einer Seite einer Tabellenzelle ermitteln. Es werden die Lab-Werte der Farbe ermittelt. Zusätzlich kann der Farbton ermittelt werden und ob die Zelle Konturen überdrucken darf.
Die Funktion benötigt mglw. Farb-Konvertierungen. Für comet_pdf müssen dafür die Farbprofile vollständig konfiguriert sein und die Eingabe-W2ML muß mind. aus v4.0.5 R13799 sein.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | verwendete Tabelle |
| row | int | - | 0-basierte Tabellenzeile |
| col | int | - | 0-basierte Tabellenspalte |
| side | int | - | Einer der folgenden Werte. Mit den negativen Werten wird die Farbe der Kanten-"Löcher" erfragt: ±eLeftSide ±eRightSide ±eTopSide ±eBottomSide ±eDiagonal |
| colName | String oder char* | 0 | Name der Farbe. Der Wert kann nur für Standardfarben und Farben ermittelt werden, die im Dokument definiert sind. |
| L | float* | 0 | L-Anteil der Farbe im Bereich 0.0 -100.0 |
| a, b | int* | 0 | ab-Anteile der Farbe im Bereich -128 - 127 |
| tint | float* | 0 | Farbton im Bereich 0.0 - 100.0 |
| overprint | int* | 0 | überdruckt die Konturfarbe? 0: Nein 1: Ja |
static float table::cell::get_rotate(
Table T,
int col,
int row)
Textdrehung in der Zelle.
| Name | Typ | Default | Beschreibung |
| Return | float | Die Funktion kann einen der möglichen Werte 0.0, 90.0, 180.0 oder 270.0 zurückgeben. | |
| T | Table | - | verwendete Tabelle |
| col | int | - | 0-basierte Tabellenspalte |
| row | int | - | 0-basierte Tabellenzeile |
static int table::cell::apply_style(
Table T,
char* styleName,
int left,
int top,
int right,
int bottom,
int removeOverrides = 0,
int applyParaStyle = 0)
xxxxx Wende einen Zellstil auf einen Zellbereich an. Mit der Angabe eines leeren Stiles wird der bestehende Zellstil des Zellbereiches entfernt. Zellstile können hierarchisch geordnet sein. Geben Sie in diesem Fall den vollständigen, durch ':' getrennten Pfad des Zellstils an. Tabellenzellenstil wurden erst in InDesign® CS3 eingeführt. Unter InDesign®-Versionen vor CS3 macht die Funktion nichts, liefert aber einen Fehlercode zurück.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| whichStyle | String oder char* | - | Name des Zellenstils. Zellstile können hierarchisch geordnet sein. Geben Sie in diesem Fall den vollständigen, durch ':' getrennten Pfad des Zellstils an. "" : Entferne den Zellenstil |
| left | int | - | Erste Spalte (0-basiert) |
| top | int | - | Erste Zeile (0-basiert) |
| right | int | - | >= 0 : Erste Spalte, die nicht mehr bearbeitet werden soll (0-basiert) -1 : Alle weiteren Spalten der Tabelle |
| bottom | int | - | >= 0 : Erste Zeile, die nicht mehr bearbeitet werden soll(0-basiert) -1 : Alle weiteren Zeilen der Tabelle |
| removeOverrides | int | 0 | Lokale überschreibungen sollen entfernt werden (1) oder erhalten bleiben(0)
Von Illustrator® wird der Parameter ignoriert. |
| applyParaStyle | int | 0 | 1 wenn der Zellenstil seinen eigenen Absatzstil anwenden soll, 0 sonst
Von Illustrator® wird der Parameter ignoriert. |
static char* table::cell::get_style(
Table T,
int col,
int row)
Ermittle Pfad und Namen des Stiles einer Tabellenzelle. Die Pfadteile sind durch ':' getrennt. Die Funktion liefert erst ab InDesign® CS3 gültige Werte.
| Name | Typ | Default | Beschreibung |
| Return | char* | Pfad und Name des aktuellen Zellenstiles. Als Pfadtrenner wird ':' verwendet. "" : Kein Zellenstil gesetzt oder InDesign®-Version vor CS3 Der Rückgabewert darf nicht verändert werden und wird bei folgenden Aufrufen der Funktion überschrieben. Hier finden Sie Informattingen zu readonly-Rückgaben von Funktionen. |
|
| T | Table | - | Gültige Tabellenreferenz |
| col, row | int | - | 0-basierte Tabellenzelle |
strcpy (cname, table::cell::get_style (T, 1, 2));
static int table::cell::clear_overrides(
Table T,
int l,
int t,
int r,
int b,
int depth = 2,
int keepTableModuleData = 0,
int refreshPanel = 0)
Lösche alle Zellabweichungen aus dem angegebenen Bereich, die mit dem angewendeten Zellenstil in Konflikt stehen.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| l, t, r, b | int | - | Zellenbereich. Die Indexe sind 0 basiert, r und b sind die ersten Zellen, die NICHT mehr bearbeitet werden sollen |
| depth | int | 2 | Welche Abweichungen sollen entfernt werden? 0 : Stilabweichungen unverändert lassen 1 : Löscht alle Zellüberschreibungen aus dem angegebenen Bereich, die im Konflikt mit dem angewandten Zellstil stehen. Wenn der Root-Zellenstil der angewandte Stil ist, werden werden alle überschreibungen gelöscht. Dies löscht auch alle überschreibenden Absatzstile und der Text innerhalb der Zelle wird auf den Absatzstil des Stils zurückgesetzt. Wenn kein Zellenstil angewendet wird oder der angewendete Zellenstil den Zellenstil nicht definiert, werden die Absätze unverändert gelassen. 2 : Löscht alle Zellattribute aus dem angegebenen Zellbereich. |
| keepTableModuleData | int | 0 | Welche Daten des Tabellenmodules sollen aufbewahrt werden? kKeepAll : Alle Tabellenaufbau-Daten aufbewahren kKeepGroupsAndInfo : Nur Gruppen und Infos1/2 aufbewahren kKeepGroups : Nur Gruppen aufbewahren kKeepInfo : Nur Infos1/2 aufbewahren kKeepNothing : Alle Tabellenaufbau-Daten der Zelle entfernen |
| refreshPanel | int | 0 | Soll die Palette Tabellenaufbau aktualisert werden? 0 : Nein, schneller 1 : Zeigt die Palette eine Zelle der aktuellen Tabelle, wird sie nach der Änderung aktualisiert. |
static int table::cell::is_member_of(
Table T,
int left,
int top,
char* groupName)
Prüfe die Gruppenzugehörigkeit einer Tabellenzelle.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 : Nein 1 : Ja |
|
| T | Table | - | Gültige Tabellenreferenz |
| left | int | - | Spaltennummer (0-basiert) |
| top | int | - | Zeilennumer (0-basiert) |
| groupName | String oder char* | - | Gruppenname (case sensitive) |
static int table::cell::clear_groups(
Table T,
int left,
int top,
int updatePanel = 0)
Entferne alle Gruppenzuordnungen einer Tabellenzelle.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| left | int | - | Spaltennummer (0-basiert) |
| top | int | - | Zeilennumer (0-basiert) |
| updatePanel | int | 0 | Muss die Gruppenliste der Palette "Tabellenaufbau" aktualisiert
werden? 0 : Nein 1 : Ja |
static int table::cell::clear(
Table T,
int left,
int top)
Lösche den Inhalt einer Tabellenzelle.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| left | int | - | Spaltennummer (0-basiert) |
| top | int | - | Zeilennumer (0-basiert) |
static int table::cell::copy_content(
Table T,
int from_left,
int from_top,
int to_left,
int to_top)
Kopiere den Inhalt einer Tabellenzelle in eine andere Zelle der gleichen Tabelle.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| from_left | int | - | Spaltennummer der Quelle (0-basiert) |
| from_top | int | - | Zeilennumer der Quelle (0-basiert) |
| to_left | int | - | Spaltennummer des Zieles(0-basiert) |
| to_top | int | - | Zeilennumer des Zieles (0-basiert) |
static int table::cell::get_rowid(
Table T,
int row,
int* id1 = 0,
int* id2 = 0,
int* id3 = 0,
char* stringid = 0)
Ermittle die ID einer Tabellenzeile.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| row | int | - | Zeilennumer (0-basiert) |
| id1 | int* | 0 | ID1 der Tabellenzeile |
| id2 | int* | 0 | ID2 der Tabellenzeile |
| id3 | int* | 0 | ID3 der Tabellenzeile |
| stringid | String oder char* | 0 | StringID der Tabellenzeile |
Zeige die IDs der Tabellenzelle [2, 3]
int main ()
{
Table T = table::alloc ();
int id, id2, id3;
char stringid[2000];
int row = 2;
int col = 1;
table::get (T, 0, 0);
table::cell::get_rowid (T, row, &id, &id2, &id3, stringid);
showmessage ("RowID of row %d\r\rid : %d\rid2 : %d\rid2 : %d\rsid : '%s'",
row+1, id, id2, id3, stringid);
table::cell::get_colid (T, col, &id, &id2, &id3, stringid);
showmessage ("ColumnID of column %d\r\rid : %d\rid2 : %d\rid2 : %d\rsid : '%s'",
col+1, id, id2, id3, stringid);
table::cell::get_cellid (T, col, row, &id, &id2, &id3, stringid);
showmessage ("CellID of cell [%d, %d]\r\rid : %d\rid2 : %d\rid2 : %d\rsid : '%s'",
col+1, row+1, id, id2, id3, stringid);
return 0;
}
static int table::cell::get_colid(
Table T,
int col,
int* id1 = 0,
int* id2 = 0,
int* id3 = 0,
char* stringid = 0)
Ermittle die ID einer Tabellenspalte.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| col | int | - | Spaltennummer (0-basiert) |
| id1 | int* | 0 | ID1 der Tabellenspalte |
| id2 | int* | 0 | ID2 der Tabellenspalte |
| id3 | int* | 0 | ID3 der Tabellenspalte |
| stringid | String oder char* | 0 | StringID der Tabellenspalte |
Zeige die IDs der Tabellenzelle [2, 3]
int main ()
{
Table T = table::alloc ();
int id, id2, id3;
char stringid[2000];
int row = 2;
int col = 1;
table::get (T, 0, 0);
table::cell::get_rowid (T, row, &id, &id2, &id3, stringid);
showmessage ("RowID of row %d\r\rid : %d\rid2 : %d\rid2 : %d\rsid : '%s'",
row+1, id, id2, id3, stringid);
table::cell::get_colid (T, col, &id, &id2, &id3, stringid);
showmessage ("ColumnID of column %d\r\rid : %d\rid2 : %d\rid2 : %d\rsid : '%s'",
col+1, id, id2, id3, stringid);
table::cell::get_cellid (T, col, row, &id, &id2, &id3, stringid);
showmessage ("CellID of cell [%d, %d]\r\rid : %d\rid2 : %d\rid2 : %d\rsid : '%s'",
col+1, row+1, id, id2, id3, stringid);
return 0;
}
static int table::cell::get_cellid(
Table T,
int left,
int top,
int* id1 = 0,
int* id2 = 0,
int* id3 = 0,
char* stringid = 0)
Ermittle die ID einer Tabellenzelle.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| left | int | - | Spaltennummer (0-basiert) |
| top | int | - | Zeilennummer (0-basiert) |
| id1 | int* | 0 | ID1 der Tabellenzelle |
| id2 | int* | 0 | ID2 der Tabellenzelle |
| id3 | int* | 0 | ID3 der Tabellenzelle |
| stringid | String oder char* | 0 | StringID der Tabellenzelle |
Zeige die IDs der Tabellenzelle [2, 3]
int main ()
{
Table T = table::alloc ();
int id, id2, id3;
char stringid[2000];
int row = 2;
int col = 1;
table::get (T, 0, 0);
table::cell::get_rowid (T, row, &id, &id2, &id3, stringid);
showmessage ("RowID of row %d\r\rid : %d\rid2 : %d\rid2 : %d\rsid : '%s'",
row+1, id, id2, id3, stringid);
table::cell::get_colid (T, col, &id, &id2, &id3, stringid);
showmessage ("ColumnID of column %d\r\rid : %d\rid2 : %d\rid2 : %d\rsid : '%s'",
col+1, id, id2, id3, stringid);
table::cell::get_cellid (T, col, row, &id, &id2, &id3, stringid);
showmessage ("CellID of cell [%d, %d]\r\rid : %d\rid2 : %d\rid2 : %d\rsid : '%s'",
col+1, row+1, id, id2, id3, stringid);
return 0;
}
static int table::cell::set_info1(
Table T,
int left,
int top,
char* info,
int refreshPanel = 0)
Setze die Informatting Info1 einer Tabellezellenzelle.
Die Werte für Info1 und Info2 können auch direkt über den TaggedText gesetzt werden. Fügen Sie dazu in das CellStart-Tag folgende Informatting:
<CellStart:... <w2Cell: Info1='your text' Info2=your text'> ... >
Die Texte müssen dabei richtig codiert sein:
Die Maskierung der < und > in \<0x00FC\gt; führt dazu, dass diese Strings nicht un-übersetzt eingesetzt werden können. Sie werden automatisch in das entsprechende UTF8-Zeichen übersetzt. Das liegt daran, dass die Stelle im Inneren der Plugins, die die Werte aus dem InDesign-Eingabe-Stream liest, von InDesign® für TaggedText und IDMS verwendet wird. Aber bei TaggedText gibt uns InDesign® hier bereits ein ü, bei IDMS aber noch ein <0x00FC> und wir können an dieser Stelle nicht erkennen, um welche Art Import es sich handelt.
Verwenden Sie in der Tabelle das Tabellenmodul der Plugins, muss der o.g. Inhalt für w2Cell auch alle andreren Attribute des Tabellenmodules mit validen Werten enthalten. Exportieren Sie dazu die Tabelle einmal in TaggedText und übernehmen Sie das vollständige Tag aus dem exportierten Text.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| left | int | - | 0-basierte Nummer der Spalte |
| top | int | - | 0-basierte Nummer der Zeile |
| info | String oder char* | - | Setze diese Informatting für die Tabelle |
| refreshPanel | int | 0 | Soll die Palette Tabellenaufbau aktualisert werden? 0 : Nein, schneller 1 : Zeigt die Palette eine Zelle der aktuellen Tabelle, wird sie nach der Änderung aktualisiert. |
static int table::cell::set_info2(
Table T,
int left,
int top,
char* info,
int refreshPanel = 0)
Setze die Informatting Info2 einer Tabellenzelle.
Die Werte für Info1 und Info2 können auch direkt über den TaggedText gesetzt werden. Fügen Sie dazu in das CellStart-Tag folgende Informatting:
<CellStart:... <w2Cell: Info1='your text' Info2=your text'> ... >
Die Texte müssen dabei richtig codiert sein:
Die Maskierung der < und > in \<0x00FC\gt; führt dazu, dass diese Strings nicht un-übersetzt eingesetzt werden können. Sie werden automatisch in das entsprechende UTF8-Zeichen übersetzt. Das liegt daran, dass die Stelle im Inneren der Plugins, die die Werte aus dem InDesign-Eingabe-Stream liest, von InDesign® für TaggedText und IDMS verwendet wird. Aber bei TaggedText gibt uns InDesign® hier bereits ein ü, bei IDMS aber noch ein <0x00FC> und wir können an dieser Stelle nicht erkennen, um welche Art Import es sich handelt.
Verwenden Sie in der Tabelle das Tabellenmodul der Plugins, muss der o.g. Inhalt für w2Cell auch alle andreren Attribute des Tabellenmodules mit validen Werten enthalten. Exportieren Sie dazu die Tabelle einmal in TaggedText und übernehmen Sie das vollständige Tag aus dem exportierten Text.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| left | int | - | 0-basierte Nummer der Spalte |
| top | int | - | 0-basierte Nummer der Zeile |
| info | String oder char* | - | Setze diese Informatting für die Tabelle |
| refreshPanel | int | 0 | Soll die Palette Tabellenaufbau aktualisert werden? 0 : Nein, schneller 1 : Zeigt die Palette eine Zelle der aktuellen Tabelle, wird sie nach der Änderung aktualisiert. |
static char* table::cell::get_info1(
Table T,
int left,
int top,
int refreshPanel = 0)
Hole die in einer Tabellenzelle hinterlegte Informatting Info1.
| Name | Typ | Default | Beschreibung |
| Return | char* | Info1 der Zelle "" : Fehler oder leer Der Rückgabewert darf nicht verändert werden und wird bei folgenden Aufrufen der Funktion überschrieben. Hier finden Sie Informattingen zu readonly-Rückgaben von Funktionen. |
|
| T | Table | - | Gültige Tabellenreferenz |
| left | int | - | 0-basierte Nummer der Spalte |
| top | int | - | 0-basierte Nummer der Zeile |
| refreshPanel | int | 0 | Soll die Palette Tabellenaufbau aktualisert werden? 0 : Nein, schneller 1 : Zeigt die Palette eine Zelle der aktuellen Tabelle, wird sie nach der Änderung aktualisiert. |
static char* table::cell::get_info2(
Table T,
int left,
int top,
int refreshPanel = 0)
Hole die in einer Tabellenzelle hinterlegte Informatting Info2.
| Name | Typ | Default | Beschreibung |
| Return | char* | Info2 der Tabelle "" : Fehler oder leer Der Rückgabewert darf nicht verändert werden und wird bei folgenden Aufrufen der Funktion überschrieben. Hier finden Sie Informattingen zu readonly-Rückgaben von Funktionen. |
|
| T | Table | - | Gültige Tabellenreferenz |
| left | int | - | 0-basierte Nummer der Spalte |
| top | int | - | 0-basierte Nummer der Zeile |
| refreshPanel | int | 0 | Soll die Palette Tabellenaufbau aktualisert werden? 0 : Nein, schneller 1 : Zeigt die Palette eine Zelle der aktuellen Tabelle, wird sie nach der Änderung aktualisiert. |
static int table::cell::is_anchor(
Table T,
int left,
int top,
int* anchor_left = 0,
int* anchor_top = 0)
Ist eine gegebene Tabellenzelle eine Ankerzelle oder nicht. Nicht verbundene Tabellenzellen sind ihr eigener Anker. Bei verbundenen Zellen ist die Zelle links oben des verbundenen Bereiches die Ankerzelle.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 : Keine Ankerzelle oder Fehler 1 : Ja, die Zelle ist Ankerzelle |
|
| T | Table | - | Gültige Tabellenreferenz |
| left | int | - | 0-basierte Nummer der Spalte |
| top | int | - | 0-basierte Nummer der Zeile |
| anchor_left | int* | 0 | [Rückgabe] 0-basierte Spaltennummer der Ankerzelle |
| anchor_top | int* | 0 | [Rückgabe] 0-basierte Zeilennummer der Ankerzelle |
int main ()
{
Table T = table::alloc ();
int col, row, i;
int l, t, r, b;
table::get (T, 0, 0);
for (i = 0; i < 2; i++)
{
if (i == 0)
{
row = 6;
col = 5;
}
else
{
row = 4;
col = 3;
}
wlog ("", "Cell [%d, %d] is anchor : %d\n", col, row, table::cell::is_anchor (T, col, row));
table::cell::get_anchor (T, col, row, &l, &t);
wlog ("", "Cell [%d, %d] anchor : [%d, %d]\n", col, row, l, t);
table::cell::get_span (T, col, row, &l, &t, &r, &b);
wlog ("", "Cell [%d, %d] span : [%d, %d, %d, %d]\n\n", col, row, l, t, r, b);
}
return 0;
}
static int table::cell::get_anchor(
Table T,
int left,
int top,
int* anchor_left = 0,
int* anchor_top = 0)
Ermittle die Ankerzelle einer Tabellenzelle. Nicht verbundene Tabellenzellen sind ihr eigener Anker. Bei verbundenen Zellen ist die Zelle links oben des verbundenen Bereiches die Ankerzelle.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| left | int | - | 0-basierte Nummer der Spalte |
| top | int | - | 0-basierte Nummer der Zeile |
| anchor_left | int* | 0 | [Rückgabe] 0-basierte Spaltennummer der Ankerzelle |
| anchor_top | int* | 0 | [Rückgabe] 0-basierte Zeilennummer der Ankerzelle |
int main ()
{
Table T = table::alloc ();
int col, row, i;
int l, t, r, b;
table::get (T, 0, 0);
for (i = 0; i < 2; i++)
{
if (i == 0)
{
row = 6;
col = 5;
}
else
{
row = 4;
col = 3;
}
wlog ("", "Cell [%d, %d] is anchor : %d\n", col, row, table::cell::is_anchor (T, col, row));
table::cell::get_anchor (T, col, row, &l, &t);
wlog ("", "Cell [%d, %d] anchor : [%d, %d]\n", col, row, l, t);
table::cell::get_span (T, col, row, &l, &t, &r, &b);
wlog ("", "Cell [%d, %d] span : [%d, %d, %d, %d]\n\n", col, row, l, t, r, b);
}
return 0;
}
static int table::cell::get_span(
Table T,
int left,
int top,
int* span_left = 0,
int* span_top = 0,
int* span_right = 0,
int* span_bottom = 0)
Ermittle die Größe des Zellbereiches, zu der eine Tabellezelle gehört. Unterer und rechter Wert des Zellbereiches geben die erste Zeile/Spalte an, die nicht mehr zum Bereich gehört.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| left | int | - | 0-basierte Nummer der Spalte |
| top | int | - | 0-basierte Nummer der Zeile |
| anchor_left | int* | 0 | [Rückgabe] 0-basierte Spaltennummer der Ankerzelle |
| anchor_top | int* | 0 | [Rückgabe] 0-basierte Zeilennummer der Ankerzelle |
| anchor_right | int* | 0 | [Rückgabe] 0-basierte erste Spalte, die nicht mehr zum Bereich gehört |
| anchor_bottom | int* | 0 | [Rückgabe] 0-basierte erste Zeile, die nicht mehr zum Bereich gehört |
int main ()
{
Table T = table::alloc ();
int col, row, i;
int l, t, r, b;
table::get (T, 0, 0);
for (i = 0; i < 2; i++)
{
if (i == 0)
{
row = 6;
col = 5;
}
else
{
row = 4;
col = 3;
}
wlog ("", "Cell [%d, %d] is anchor : %d\n", col, row, table::cell::is_anchor (T, col, row));
table::cell::get_anchor (T, col, row, &l, &t);
wlog ("", "Cell [%d, %d] anchor : [%d, %d]\n", col, row, l, t);
table::cell::get_span (T, col, row, &l, &t, &r, &b);
wlog ("", "Cell [%d, %d] span : [%d, %d, %d, %d]\n\n", col, row, l, t, r, b);
}
return 0;
}
static int table::cell::get_parent(
Table T,
int left,
int top,
int direction,
int* parent_row = 0,
int* parent_col = 0)
Ermittle die Eltern-Zelle einer Tabellenzelle. Die Elternzelle ist nicht die Zelle, die mit ihrer Zeilen- bzw. Spaltenaktion die Zelle angelegt hat. Vom Standpunkt der Tabelleninhalte sind diese Zellen Geschwister. Elternzellen sind die Zellen, deren IDs die Zeilen- und/oder Spaltenaktionen zum Anlegen der Geschwister (mglw.) verwendet haben können.
In der folgenden Tabelle ist die gelbe Zelle die Hotspot-Zelle, die die gesamte Tabelle aufbaut. Für die weissen Zellen gilt aber :
Hotspot für
|
rot | grün | blau |
| Small | 10 | 12 | 14 |
| Medium | 11 | 13 | 15 |
| Large | 12 | 13 | 16 |
Die Tabelle muss mind. mit v3.3.1 R3388 der Comet-Plugins aufgebaut worden sein.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| left | int | - | 0-basierte Nummer der Spalte |
| top | int | - | 0-basierte Nummer der Zeile |
| direction | int | - | Richtung 1 : Zeile 2 : Spalte |
| parent_row | int* | 0 | Ergebnis : 0-basierte Zeilennummer der nächsten Eltern-Zelle -1 : keine Elternzelle gefunden |
| parent_col | int* | 0 | Ergebnis : 0-basierte Spaltennummer der nächsten Eltern-Zelle -1 : keine Elternzelle gefunden |
Ermittle alle vertikalen und horizontalen Eltern einer der ersten ausgewählten Zelle des Dokumentes.
int main ()
{
Table T = table::alloc ();
ItemRef frame = item::alloc();
int start, len, cl, ct, cr, cb;
int r, c, pr, pc;
char tmp [10000];
char mess [10000];
int dir = 1;
if (!textmodel::available ()) return 0;
textmodel::selection (&start, &len, frame, 0, T, &cl, &ct, &cr, &cb);
if (!table::is_valid (T))
{
showmessage ("No table cell selected.");
return 0;
}
strcpy (mess, "");
for (dir = 1; dir < 3; dir++)
{
if (dir == 1) sprintf (tmp, "Row parents of cell [%d, %d]", ct, cl);
else sprintf (tmp, "\n\nColumn parents of cell [%d, %d]", ct, cl);
strcat (mess, tmp);
r = ct;
c = cl;
while (1)
{
table::cell::get_parent (T, c, r, dir, &pr, &pc);
if (pr < 0) break;
sprintf (tmp, "\n\t[%d, %d]", pr, pc);
strcat (mess, tmp);
r = pr;
c = pc;
}
}
showmessage (mess);
return 0;
}
static int table::set_type(
Table T,
int left,
int top,
int type,
ItemRef outRef = 0)
Setze den Typ Text- oder Grafikzelle einer Tabellenzelle.
Grafikzellen werden ab InDesign® CC 2015 unterstützt. In Versionen vor CC2015 hat der Aufruf keine Wirkung.
| Name | Typ | Default | Beschreibung |
| Return | int | 0 oder Fehlercode | |
| T | Table | - | Gültige Tabellenreferenz |
| left | int | - | 0-basierte Nummer der Spalte |
| top | int | - | 0-basierte Nummer der Zeile |
| type | int | - | Typ der Tabellenzelle 1 : Textzelle 2 : Grafikzelle |
| outRef | ItemRef | 0 | Nach erfolgreicher Ausführung und bei Grafikzellen enthält die Variable eine Referenz auf den
Rahmen Zelle. 0 : Rahmenreferenz ignorieren sonst : allokierte ItemRef für das Ergebnis |
static int table::get_type(
Table T,
int left,
int top,
ItemRef outRef = 0)
Ermitttle den Typ und (bei Grafikzellen) die Rahmenreferenz einer Tabellenzelle.
Grafikzellen werden ab InDesign® CC 2015 unterstützt. In Versionen vor CC2015 hat der Aufruf keine Wirkung und gibt immer die Werte 0 oder 1 zurück.
| Name | Typ | Default | Beschreibung |
| Return | int | Typ der Tabellenzelle 0 : Undefiniert (Fehler) 1 : Textzelle 2 : Grafikzelle |
|
| T | Table | - | Gültige Tabellenreferenz |
| left | int | - | 0-basierte Nummer der Spalte |
| top | int | - | 0-basierte Nummer der Zeile |
| outRef | ItemRef | 0 | Nach erfolgreicher Ausführung und bei Grafikzellen enthält die Variable eine Referenz auf den
Rahmen Zelle. 0 : Rahmenreferenz ignorieren sonst : allokierte ItemRef für das Ergebnis |
Erzeuge ein 16x16 Farbspectrum. Farbe A nimmt von links nach rechts zu.
Farbe B nimmt von oben nach unten ab. Farbe C bleibt konstant
int main ()
{
Table T = table::alloc ();
int A = 0;
int C = 0;
int B = 255;
int i, j;
if (!T) return 0;
if (table::create (T, 0, 16, 16, -1, 0, 20.0, 20.0) != 0)
{
table::release (T);
return 0;
}
for (i = 0; i < 16; i++)
{
for (j = 0; j < 16; j++)
{
table::colorize (T,
j, i, j+1, i+1,
B, A, C);
A += 16; --A;
}
A = 0;
++B; B -= 16;
}
table::release (T);
return 0;
}
Alphabetic index HTML hierarchy of classes or Java