C1FlexGrid - Saturday, April 28, 2012 8:51 AM - ComponentOne

User’s Guide

Copyright © 1991-2005 ComponentOne LLC. Alle Rechte vorbehalten.
Unternehmenszentrale
ComponentOne LLC
4516 Henry Street
Suite 500
Pittsburgh, PA 15213 USA
Internet: info@componentone.com
Webseite: http://www.componentone.com
Vertrieb: sales@componentone.com
+1 (800) 858-2739 oder +1 (412) 681-4343 (Pittsburgh, PA USA Office)
Technischer Support
Informationen zum Technischen Support finden Sie im Kapitel Technischer Support in diesem Handbuch.
Markenzeichen
ComponentOne FlexGrid für .NET und das ComponentOne FlexGrid für .NET-Logo sind Markenzeichen und
ComponentOne ist eine registrierte Handelsmarke von ComponentOne LLC. Alle anderen, in diesem Handbuch
verwendeten Markenzeichen sind Eigentum der entsprechenden Besitzer.
GARANTIE
ComponentOne garantiert für einen Zeitraum von 90 Tagen nach Kauf des Produktes, dass die originale CD oder
Diskette keine Material- oder Qualitätsschäden bei normalem Gebrauch aufweist. Sie können einen defekten Datenträger
zusammen mit dem datierten Kaufbeleg an ComponentOne einsenden, wenn ein Schaden während dieser Zeit auftritt.
Sie erhalten eine neue CD oder Diskette ohne weitere Kosten. Für Ersatzlieferungen nach Ablauf der 90 Tage können Sie
defekte Datenträger zusammen mit einem Scheck über US$25 für Porto und Verpackung an ComponentOne schicken.
Mit Ausnahme der oben genannten Garantiebestimmung für die originale CD oder Diskette, gibt ComponentOne keine
weiteren Garantien. Es wurde jede Anstrengung unternommen, um sicherzustellen, dass die vorliegenden Informationen
zum Zeitpunkt der Erstellung des Handbuches richtig sind. ComponentOne ist nicht für falsche oder fehlende
Informationen verantwortlich. ComponentOne haftet für den von ihnen entrichteten Kaufpreis für das Produkt.
ComponentOne ist unter keinen Umständen für Folgeschäden, außerordentliche oder andere Schäden haftbar.
Kopieren und vertreiben
Es ist gestattet, Sicherheitskopien der Software für den eigenen Gebrauch und Schutz anzulegen, allerdings dürfen diese
nicht an Dritte weitergegeben oder verwendet werden. ComponentOne hat viel Zeit und Aufwand in die Erstellung des
Produktes gesteckt und bedankt sich für Ihr Verständnis, dass nur lizenzierte Benutzer das Produkt verwenden dürfen.
Bitte lesen Sie die Abschnitte Lizenzvertrag und Lizenzierungsabschnitt in diesem Handbuch bevor Sie Kopien der
ComponentOne FlexGrid für .NET-Dateien anfertigen und vertreiben

Inhaltsverzeichnis
Inhaltsverzeichnis ...................................................................................................................... iii
Willkommen zu ComponentOne FlexGrid für .NET ............................................................ 1
Überblick ................................................................................................................................. 1
Was ist neu in der Version 2.5 .............................................................................................. 2
Installation............................................................................................................................... 3
ENDBENUTZER-LIZENZVERTRAG FÜR COMPONENTONE SOFTWARE............. 4
Häufig gestellte Fragen zur Lizenz (FAQs) ...................................................................... 12
Technische Unterstützung .................................................................................................. 16
Wiedervertreibbare Dateien................................................................................................ 17
Namensbereiche (Namespaces).......................................................................................... 17
Ein .NET-Projekt erstellen................................................................................................... 19
Die C1FlexGrid Component der Toolbox hinzufügen.................................................... 20
Die C1FlexGrid-Steuerung verwenden.................................................................................. 21
Layout .................................................................................................................................... 22
Auswahl................................................................................................................................. 24
Datenbindungen................................................................................................................... 26
Daten speichern und laden ................................................................................................. 27
Zellbereich............................................................................................................................. 28
Zellbilder ............................................................................................................................... 29
Zellen formatieren................................................................................................................ 29
Zellen bearbeiten .................................................................................................................. 37
Zusammenfassen und Gliedern ......................................................................................... 49
Zellen verbinden................................................................................................................... 56
Speichern, Laden und Drucken.......................................................................................... 62
FlexGrid-Eigenschaftsgruppen........................................................................................... 66
FlexGrid-Beispiele...................................................................................................................... 69
Visual Basic-Beispiele ..........................................................................................................69
C#-Beispiele .......................................................................................................................... 72
ComponentOne FlexGrid für mobile Gerätebeispiele..................................................... 77
FlexGrid-Übungen ..................................................................................................................... 78
Übung zur Bearbeitung ....................................................................................................... 78
Übung zur Gliederung ........................................................................................................ 88
Übung zur Datenanalyse..................................................................................................... 99
C1FlexGrid-Referenzverzeichnis........................................................................................... 109
C1FlexGrid-Klasse.............................................................................................................. 109
CellRange-Struct................................................................................................................. 292
HitTestInfo-Klasse..............................................................................................................302
RowCollection-Klasse ........................................................................................................ 304
ColumnCollection-Klasse.................................................................................................. 314
Row-Klassen........................................................................................................................ 324
Column-Klassen ................................................................................................................. 339
CellStyleCollection-Klasse................................................................................................. 365
CellStyle-Klasse .................................................................................................................. 376
CellBorderKlassen.............................................................................................................. 392
Node-Klasse ........................................................................................................................ 394
· iii

iv ·
GridGlyphs-Klasse ............................................................................................................. 405
GridTree-Klasse .................................................................................................................. 406
GridPrinter-Klasse..............................................................................................................412
C1FlexGrid-Aufzählungen................................................................................................ 419
C1FlexGrid-Schnittstellen.................................................................................................. 446
C1FlexGridClassic-Steuerung ................................................................................................ 449
C1FlexGridClassic-Referenzverzeichnis.............................................................................. 450
C1FlexGridClassic-Klassen ............................................................................................... 450
Cell-Klassen......................................................................................................................... 564
C1FlexGridClassic-Aufzählungen.................................................................................... 564
Index............................................................................................................................................ 579

Willkommen zu ComponentOne
FlexGrid für .NET
Überblick · 1
ComponentOne FlexGrid für .NET beinhaltet C1FlexGrid, eine voll ausgestattete Tabellensteuerung,
mit der Sie schnell und einfach Daten anzeigen, formatieren und bearbeiten können.
FlexGrid für .NET vereint die neuesten Datenbindungstechnologien – ADO.NET und ComponentOne
DataObjects – nahtlos innerhalb des Microsoft .NET Frameworks.
Die benutzerdefinierten Steuerungen von ComponentOne sind innovativ, flexibel und stark. Wenn Sie
FlexGrid mögen, dann sollten Sie sich auch unsere anderen preisgekrönten Produkte anschauen, welche
im Abschnitt „Produkte von ComponentOne“ beschrieben werden.
ComponentOne hat eine benutzerfreundliche Vertriebspolitik. Jeder Programmierer kann eine Kopie von
FlexGrid für .NET besitzen und diese so lange ausprobieren, wie er möchte. Diejenigen, denen das
Produkt gefällt und dieses nützlich finden, können eine Lizenz für einen günstigen Preis erwerben. Die
einzige Einschränkung einer nicht lizenzierten Kopie von FlexGrid für .NET ist der ComponentOne-
Banner, der bei jedem Programmstart angezeigt wird und den Entwickler auf die Lizenzierung des
Produktes hinweist.
Wir sind sicher, dass Sie ComponentOne FlexGrid für .NET mögen werden. Wenn Sie Vorschläge oder
Ideen für neue Funktionen oder Steuerungen haben, die in den zukünftigen Versionen integriert werden
sollten, dann rufen Sie uns an oder schreiben Sie uns an:
ComponentOne LLC
4516 Henry Street
Suite 500
Pittsburgh, PA 15213 USA
412.681.4343
412.681.4384 (Fax)
http://www.componentone.com
Überblick
Das ComponentOne FlexGrid für .NET-Paket besteht aus zwei Steuerungen:
C1FlexGrid-Steuerung
C1FlexGrid ist ein starkes voll ausgestattetes Tabellenprogramm. Es beinhaltet neue Wege, tabellarische
Daten anzuzeigen, zu bearbeiten, zu formatieren, zu organisieren, zusammenzufassen und zu drucken.
Es kann Tabellen von komprimierten Binärdateien oder Textdateien lesen und diese auch schreiben
(kompatibel mit Microsoft Access und Excel). C1FlexGrid beinhaltet alle Basisfunktionen und
fortgeschrittenen Funktionen, wie zum Beispiel Gliederungen, Sortieren, Zellenverbindungen,
Maskenbearbeitung, übersetzte Zusammenstellungen, Listenbilder und automatische
Datenzusammenfassung.

2 · Willkommen zu ComponentOne FlexGrid für .NET
C1FlexGrid kann im bound-Modus (gebunden), wo Daten von jeder beliebigen .Net-Datenquelle,
inklusive ADO.Net und ComponentOne DataObjects, angezeigt werden, oder im unbound-Modus
(ungebunden), wo die Tabellensteuerung selbst die Daten verwaltet, genutzt werden.
C1FlexGridClassic Control
C1FlexGridClassic ist eine von C1FlexGrid abgeleitet Steuerung und beinhaltet ein Objektmodel, das
genauso wie die VSFlexGrid ActiveX-Steuerung aussieht. C1FlexGridClassic wurde für die einfache
Migration von existierenden VSFlexGrid-Projekten entwickelt.
Der Quellcode für C1FlexGridClassic wird als Beispiel zur Verfügung gestellt. Sie können diesen als
Referenz verwenden, um zu sehen, wie die C1FlexGrid-Steuerung als Basisklasse bei der Entwicklung
einer benutzerdefinierten Tabellensteuerung verwendet wird.
Was ist neu in der Version 2.5
Die Version 2.5 von C1FlexGrid beinhaltet zwei neue Hauptfunktionen und einige nützliche
Erweiterungen.
Unterstützung von benutzerdefinierten Editoren
Sie können nun jede beliebige .NET-Steuerung als Tabelleneditor verwenden. Ordnen Sie einfach eine
Instanz der Steuerung der Editor-Eigenschaft einer Spalte zu und die Tabelle wird diese Steuerung dann
für die Bearbeitung der Zellen in dieser Spalte verwenden.
Sie können das Verhalten eines benutzerdefinierten Editors anpassen, indem Sie die
IC1EmbeddedEditor-Schnittstelle implementieren (definiert in C1Common.dll). Dadurch verbessern Sie
auch die Integration zwischen der Tabelle und den externen Editoren. Alle Steuerungen in der C1Input-
Bibliothek implementieren nun den IC1EmbeddedEditor und können somit als Tabelleneditoren
verwendet werden (es wird kein Quellcode benötigt).
Wir stellen Ihnen außerdem Beispiele zur Verfügung, die Ihnen zeigen, wie man UIType-Editorklassen
als Tabelleneditoren verwenden kann. (Schauen Sie unter „CustomEditors“ in unserer online
Beispielbibliothek nach).
Speichern und Öffnen von Microsoft Excel-Dateien
Die Methoden SaveGrid und LoadGrid haben nun überladene Versionen, mit denen Sie Microsoft Excel-
Dateien (*.xls) speichern und öffnen können. Die Tabellensteuerung nutzt reinen .NET-Code und
benötigt somit keine installierte Kopie von Excel auf ihrem Computer.
Es gibt zudem spezielle Methoden SaveExcel und LoadExcel, die zusätzliche Steuerungen für das
Speichern und Laden von Tabellen auf bestimmten Blättern in einer Excel-Arbeitsmappe beinhalten.
Unterstützung der automatischen Zwischenablage
Mit der neuen Eigenschaft AutoClipboard kann die Tabellensteuerung die Standardbefehle der
Zwischenablage - ausschneiden, kopieren, einfügen und löschen von Zellwerten - verwenden.
Benutzerdefiniertes Verhalten für Zellverbindungen und Gruppierungen
Mit der neuen Eigenschaft CustomComparer können Sie eine IComparer-Klasse festlegen, um
angrenzende Zellen entweder zu verbinden, oder zu gruppieren.

Einfacher Zugang zu Datenquellenobjekten
Installation · 3
Mit der neuen Eigenschaft Row.DataSource können Sie leicht auf die Quelldaten einer Zeile zugreifen.
Zum Beispiel, wenn die Tabellensteuerung an einen ADO.NET DataView gebunden ist, können Sie ganz
einfach an das an jede Zeile angehängte DataViewRow-Objekt kommen.
Noch stärkere CellStyle-Klassen
Die CellStyle-Klasse hat eine neue Editor-Eigenschaft, mit der Sie einen benutzerdefinierten Editor
festlegen können, und eine neue Render-Methode, mit der Sie den Stil verwenden können, der
Zeichenketten und Grafiken in jedem beliebige Graphics-Objekt anzeigt.
Neue Ereignisse
Die Tabellensteuerung gibt nun Meldungen, bevor und nachdem der Nutzer eine Zeile hinzufügt oder
löscht, aus, so dass Sie diese Aktionen überwachen oder abbrechen können (BeforeAddRow,
AfterAddRow, CancelAddRow, BeforeDeleteRow und AfterDeleteRow).
Außerdem gibt es neue Ereignisse um ungebundene Datenspalten zu unterstützen (GetUnboundValue
und SetUnboundValue).
Mehr Geschwindigkeit
Die Version 2.5 beinhaltet einige Optimierungen, so dass die Tabellensteuerung erheblich schneller
angezeigt und gescrollt werden kann, als zuvor.
Installation
Um FlexGrid für .NET zu installieren, starten Sie die C1FlexGrid.msi-Installationsdatei, die sich auf der
CD befindet (oder als Download aus dem Internet) und folgen Sie den Anweisungen.
Das Installationsprogramm wird ein Verzeichnis mit dem Namen „ComponentOne Studio.NET“ unter
„Programme“ erstellen. Dieses Verzeichnis wird die folgenden Unterverzeichnisse enthalten:
bin Enthält Kopien aller Binaries (*.dll, *.exe) aus dem ComponentOne Visual
Studio.NET-Paket.
Common Enthält Support- und Datendateien, die von vielen der Demoprogramme
genutzt werden.
Demos Enthält Beispielprojekte für alle Studio-Komponenten.
Help Enthält die online Handbücher aller Studio-Komponenten.
C1FlexGrid Enthält Beispiele und Anweisungen für die C1FlexGrid-Komponenten.
Other Enthält Beispiele und Anweisungen für andere Studio-Komponenten.
Installation von Demonstrationsversionen
Wenn Sie FlexGrid für .NET ausprobieren wollen, aber keinen Registrierungsschlüssel besitzen, dann
installieren Sie das Produkt ganz normal, geben aber keinen Registrierungsschlüssel ein. Der einzige
Unterschied zwischen einer nicht registrierten (Evaluation) und einer registrierten (gekauften) Version
der Software ist ein Banner, der beim Programmstart angezeigt wird.

4 · Willkommen zu ComponentOne FlexGrid für .NET
Deinstallation von FlexGrid für .NET
Um FlexGrid für .NET zu deinstallieren, müssen Sie die Systemsteuerung öffnen, auf Software klicken,
im Register „Programme ändern oder entfernen“ FlexGrid für .NET auswählen und auf „Entfernen“
klicken.
ENDBENUTZER-LIZENZVERTRAG FÜR COMPONENTONE
SOFTWARE
WICHTIG – BITTE SORGFÄLTIG LESEN: Dieser Endbenutzer-Lizenzvertrag (diese „EULA“) legt die
Bestimmungen fest, unter denen Sie berechtigt sind, die SOFTWARE wie nachfolgend definiert zu
nutzen. Diese EULA beinhaltet maßgebliche Grenzen hinsichtlich ihrer Endbenutzerrechte. Sie sollten
daher diese EULA sorgfältig lesen und Sie als wertvolles Eigentum ansehen.
I. DIESE EULA.
1. SOFTWARE definiert durch diese EULA. Diese EULA regelt die Nutzung der ComponentOne,
LLC („C1“) und alle anderen mitgelieferten Softwareprodukte (einzeln und gemeinsam, die
„SOFTWARE“). Der Begriff „SOFTWARE“ beinhaltet als Erweiterung zu der Definition von C1:
1) jede Art von dazugehörigen Überarbeitungen, Updates und/oder Verbesserungen; 2) jede Art
von Daten, Abbildungen oder ausführbaren Dateien, Datenbaken, Daten-Engines, Computer
Software oder ähnlichen Elementen, die üblicherweise genutzt oder mit Softwareprodukten
mitgeliefert werden; 3) jegliches, was auf irgendeine Art und Weise dafür vorgesehen ist, direkt
mit oder in Verbindung mit der SOFTWARE genutzt zu werden; und 4) jede Art von
dazugehörigen Medien, physikalischen, elektronischen und online Dokumentationen sowie
gedruckten Materialien (die „Dokumentation“).
2. Diese EULA ist ein rechtskräftiger Vertrag zwischen ihnen und C1. Sollten Sie als
Bevollmächtigter eines Unternehmens oder einer anderen juristischen Person, wie beispielsweise
als Angestellter im Auftrag ihres Arbeitsgebers, handeln, so bezieht sich „sie” und „ihr“ auf ihren
Auftraggeber, auf das Unternehmen oder eine andere juristische Person, in dessen Auftrag Sie
handeln. Dennoch können Sie für den Fall, dass Sie als Bevollmächtigter im Auftrag eines Dritten
handeln, persönlich für Verstöße gegen staatliche Gesetze wie Urheberrechtsverletzungen
haftbar gemacht werden.
Diese EULA ist ein rechtskräftiger Vertrag zwischen ihnen und C1. Sie sind rechtlich an diese
EULA gebunden, als hätten Sie und C1 persönlich diese EULA unterschrieben. Indem Sie die
SOFTWARE installieren, kopieren, oder Sie anderweitig verwenden, erklären Sie sich damit
einverstanden, durch die Bestimmungen dieser EULA gebunden zu sein. Falls Sie sich mit den
Bestimmungen dieser EULA nicht einverstanden erklären, sind Sie nicht berechtigt, die
SOFTWARE zu installieren oder zu verwenden. Falls Sie die Installation dieser SOFTWARE, aus
welchen Gründen auch immer, bereits begonnen oder gar schon abgeschlossen haben, sollten Sie
den Installationsvorgang abbrechen oder die SOFTWARE deinstallieren. (Klicken Sie auf die
Beenden- oder eine äquivalente Schaltfläche, um die Installation sofort zu beenden.) Falls Sie sich
mit den Bestimmungen dieser EULA nicht einverstanden erklären, müssen Sie die SOFTWARE
unverzüglich zu dem Geschäft, bei dem Sie die SOFTWARE erworben haben, gemäß deren
Rückgaberichtlinien zurückgeben. Rückgaberichtlinien können von Händler zu Händler
unterschiedlich sein. Sie müssen ihrer Rückgaberichtlinie, mit der Sie sich zum Kaufzeitpunkt
einverstanden erklärt haben, nachkommen. Falls das Geschäft, bei der Sie die SOFTWARE
erworben haben, der Rückerstattung des vollen Kaufpreises innerhalb eines Zeitraumes von
dreißig (30) Tagen seit dem nachweisbaren Kaufzeitpunkt nicht nachkommt, können Sie die
SOFTWARE direkt an C1 innerhalb einer Periode von dreißig (30) Tagen seit des
Kaufzeitpunktes zurückgeben. Um das Produkt direkt an C1 zurückzugeben, müssen Sie sich

ENDBENUTZER-LIZENZVERTRAG FÜR COMPONENTONE SOFTWARE · 5
eine C1 Rückgabeberechtigungsnummer beschaffen, indem Sie C1 zunächst kontaktieren. Sie
sind verpflichtet, alle erworbenen Teile des Produktes, den Kaufnachweis inbegriffen, direkt an
C1 zu senden. Das Porto dieser Rücksendung muss im Voraus bezahlt werden. Es muss
eindeutig erkennbar sein, dass die Rückgabe innerhalb der Frist von dreißig Tagen, beginnend
mit dem Tag des nachweisbaren Kaufes erfolgt, wobei diese Fristeinhaltung entscheidend für die
Vertragserfüllung ist. Die Möglichkeit der Rücksendung des Produktes an C1 wird nur den
Erstkäufern eines ungeöffneten, original verpackten Produktes gewährt.
II. IHRE LIZENZ ZU ENTWICKLEN UND ZU VERTREIBEN.
Wie im Folgenden noch ausführlicher erläutert wird, gewährt ihnen diese EULA zwei Lizenzen: 1) eine
Lizenz zur Nutzung der SOFTWARE, um andere Software Produkte zu entwickeln (die
„Entwicklungslizenz“); und 2) eine Lizenz, um die entwickelte Software zu nutzen und/oder zu
vertreiben (die „Vertriebslizenz“). Beide Lizenzen (einzeln und gemeinsam, die „Lizenzen“) werden im
Folgenden detaillierter erläutert und definiert.
3. Definitionen. Die folgenden Begriffe haben die entsprechende Bedeutung, wie diese in dieser
EULA festgelegt wird:
„Netzwerk Server” beschreibt einen Computer mit einem oder mehreren Prozessoren (CPU's),
die das Ziel verfolgen, andere Computer, die logisch oder physisch mit dieser CPU verbunden
sind, einschließlich, aber nicht ausschließlich anderer Computer, die über ein internes Netzwerk,
das Intranet oder das Internet mit dieser CPU verbunden sind, mit Daten zu beliefern. „Web
Server“ beschreibt eine Art Netzwerk Server, der andere Computer, die eher über das Intranet
oder das Internet mit diesem Netzwerk Server verbunden sind, mit Daten beliefert.
„Entwickelte Software“ beschreibt diejenigen Softwareprodukte, die unter Verwendung der
SOFTWARE entwickelt wurden. „entwickelte Web Server-Software“ beschreibt diejenigen
entwickelten Softwareprodukte, die logisch oder physisch auf mindestens einem Web Server
abgespeichert werden und vom Prozessor oder den Prozessoren des Web Servers bedient werden
(was bedeutet, dass die Anweisungsbefehle ausgeführt werden). „entwickelte Stammsoftware“
beschreibt diejenigen entwickelten Softwareprodukte, die keine entwickelte Web Server-Software
sind. Dies schließt beispielsweise selbständige Anwendungen sowie Anwendungen, die alleine
durch einen File-Server zugänglich gemacht werden können, ein. „Wiedervertreibbare Dateien“
beschreiben SOFTWARE-Dateien oder andere Bestandteile der SOFTWARE, die von C1 geliefert
werden und die Sie als beim Vertrieb der entwickelten Software in den zugehörigen schriftlichen
Materialien als wiedervertreibbare Dateien kennzeichnen müssen. „Entwickler“ beschreibt einen
Menschen oder jedes automatisierte Instrument, das die SOFTWARE gemäß den Bestimmungen
dieser EULA verwendet.
„Einzelentwicklerlizenz“ bedeutet, dass jeder Entwickler, der die programmatische Schnittstelle
oder die SOFTWARE nutzt oder anderweitigen Zugang zu diesen hat, eine separate
Benutzerlizenz erwerben muss.
„Quellcode” soll als Software-Code oder als Programm in einem visuell lesbaren Format
verstanden werden, wie z.B. eine gedruckte Auflistung eines solchen Programms, welches in
einer höheren Programmiersprache geschriebenen wurde. Der Begriff „Quellcode” umfasst nicht
nur Dokumente und Materialien, wie Flussdiagramme, Pseudo-Code und Programmnotizen, die
zur Unterstützung der SOFTWARE-Entwicklung dienen.
4. Ihre Entwicklungslizenz. Ihnen wird hiermit ein limitiertes, gebührenfreies und nicht-exklusives
Nutzungsrecht an der SOFTWARE gewährt, um mit dieser SOFTWARE entwickelte Software zu

6 · Willkommen zu ComponentOne FlexGrid für .NET
entwerfen, zu erstellen und zu testen. Dies gilt allerdings nur unter der Bedingung, dass Sie sich,
und nur dann, mit den Bestimmungen dieser EULA vollständig einverstanden erklären.
Die SOFTWARE ist für Sie auf einer Einzelentwicklerlizenzbasis lizenziert.
Die Einzelentwicklerlizenz berechtig Sie dazu, eine einzige Installation der SOFTWARE
durchzuführen, um diese zur Entwerfung, zur Erstellung und zur Testung von entwickelter
Software von einem einzigen Entwickler, auf einem oder mehreren Computern, mit jeweils
einem einzigen Satz an Eingabegeräten zu nutzen, solange wie der/die Computer nur von einem
Entwickler zu jedem Zeitpunkt und nicht gleichzeitig genutzt wird/werden. Dies bedeutet
gleichzeitig, dass Sie nicht dazu berechtigt sind, die SOFTWARE auf einem Computer, der als
Netzwerk Server oder Computer dient, auf welchem die SOFTWARE von mehr als nur einem
Entwickler genutzt werden kann, zu installieren oder zu nutzen. Sie sind nicht berechtigt, die
SOFTWARE oder eine Komponente der SOFTWARE zu vernetzen, wenn Sie dadurch von mehr
als nur einem Entwickler genutzt werden kann. Dies trifft nicht zu, wenn Sie für jeden weiteren
Nutzer jeweils eine weitere Entwicklungslizenz erworben haben. Zudem müssen Sie eine weitere
separate SOFTWARE Lizenz erwerben, um den zusätzlichen Nutzern Entwicklungsplätze
beifügen zu können. Diese Notwendigkeit ist unabhängig davon, ob die weiteren Nutzer die
SOFTWARE in einem unabhängigen Umfeld oder in einem Computer Netzwerk nutzen.
In keinem Fall ist es ihnen ohne das ausdrückliche, schriftliche Einverständnis von C1 gestattet,
den C1-Namen, das C1-Logo oder die C1-Markenzeichen zu verwenden, um ihre entwickelte
Software zu vertreiben; (b) Sie müssen den folgenden C1-Urheberrechtshinweis („Portions
Copyright © ComponentOne, LLC 1991-2002. Alle Rechte vorbehalten.”) in ihre Dokumentation
der entwickelten Software und/oder in die „Über-Text“ der entwickelten Software sowie an jeder
Stelle, an der der Rechtshinweis in der entwickelten Software platziert ist, einfügen; (c) Sie
stimmen hiermit einer Ausschlussklausel für finanzielle Haftung zu; Sie stimmen zu, dass Sie C1-
Schadensersatz leisten und dass Sie C1, seine Zulieferer und Händler vor jeglicher Art der
Anspruchsforderungen oder Gerichtsverfahren, die aus der Verwendung oder dem Vertrieb
ihrer entwickelten Software resultieren können, einschließlich der Anwaltskosten, zu schützen;
(d) Sie dürfen die SOFTWARE lediglich für die Erstellung von entwickelter Software, die
signifikante Unterschiede zur originalen SOFTWARE aufweist, verwenden.
5. Ihre Vertriebslizenz.
Lizenz zum Vertrieb der Entwickelten Stammsoftware. Gemäß den Bestimmungen dieser
EULA wird ihnen die Lizenz zur gebührenfreien Nutzung und zum Vertrieb von entwickelter
Stammsoftware gewährt, sofern die in einem maschinensprachigen Format entwickelte
Stammsoftware (üblicherweise ein „*.exe“- oder „*.dll“-Format), die SOFTWARE als inneren Teil
der entwickelten Software enthält. Es ist ihnen nicht gestattet, die SOFTWARE als entwickelte
Software zu versenden, zu bündeln, zu verpacken oder zu unterteilen, die sich als die
programmatische Schnittstelle der SOFTWARE herausstellt, wenn Sie in einer „designtime“-
Entwicklungsumgebung genutzt wird. Sie dürfen lediglich auf einer gebührenfreien Basis
wiedervertreibbare Dateien der entwickelten Stammsoftware vertreiben.
4. Spezifische Produkteinschränkungen. Falls die gekaufte Lizenz für eines der folgenden
Produkte gedacht ist, gelten die folgenden zusätzlichen Einschränkungen, ungeachtet jeglicher
Bestimmungen in dieser EULA, die diesen Einschränkungen zuwiderlaufen:
a. ComponentOne Reports für .NET Designer Edition. ComponentOne Reports für .NET
Designer Edition beinhaltet zumindest: 1) eine dynamische Link-Bibliotheksdatei
(c1.win.c1reportdesigner.dll), bekannt als C1ReportDesigner-Komponente, 2) eine
funktionsfähige Datei (ReportDesigner.exe), bekannt als C1ReportDesigner-Anwendung und 3)

ENDBENUTZER-LIZENZVERTRAG FÜR COMPONENTONE SOFTWARE · 7
den Quellcode der C1ReportDesigner-Anwendung. Die C1ReportDesigner-Komponente ist
Gegenstand der generellen, in dieser EULA dargelegten Begrifflichkeiten und Beschränkungen.
Die C1ReportDesigner-Anwendung ist eine funktionsfähige Datei, die verwendet wird, um
Berichte zu entwerfen und anzufertigen; die C1ReportDesigner-Anwendung kann gebührenfrei
nur in Verbindung mit der entwickelten Software vertrieben werden.
Gemäß den Bestimmungen in dieser EULA gewährt C1 ihnen hiermit das Recht, den
Anwendungsquellcode des C1ReportDesigners zu nutzen. Ihnen wird hiermit ebenso das Recht
gewährt, einen solchen Quellcode zu modifizieren und abgeleitete Arbeiten, die auf dem
lizenzierten Quellcode basieren, zu erstellen. Sie dürfen die von ihnen entwickelten und
abgeleiteten Arbeiten nur in einem Objektcodeformat und ausschließlich in Verbindung mit
und/oder als Teil der entwickelten Software vertreiben. Ihnen wird ausdrücklich das Recht
verwährt, den lizenzierten Quellcode, jegliche abgeänderte Versionen, abgeleitete Arbeiten oder
jeder Anteil dieser genannten Arbeiten in einem Quellcodeformat an eine dritte Partei zu
vertreiben, dieser den Quellcode bekannt zu geben, oder der dritten Partei den Quellcode auf
eine andere Weise zugänglich zu machen.
C1 behält alle Rechte, Ansprüche und Anteile an dem lizenzierten Quellcode, sowie an allen
Updates, Änderungen und Weiterentwicklungen, die von C1 stammen. In Bezug auf den
lizenzierten Quellcode gilt nichts als von C1 auf Sie transferierbares Eigentums- oder
Anspruchsrecht.
DER QUELLCODE IST WIE BESCHRIEBEN AUF SIE LIZENZIERT. C1 WIRD UND SOLL
IHENEN KEINEN TECHNISCHEN SUPPORT FÜR IHRE QUELLCODELIZENZ BIETEN.
b. VSView Reporting Edition. Die VS View Reporting Edition beinhaltet zumindest eine
funktionsfähige Datei, die als „VSRpt7.exe” (wobei X die Versionsnummer darstellt, z.B. 7,8,
usw.), gelistet und als „Designer” bekannt ist. Die Datei „VSRpt7.exe” oder jede Verbesserung
oder zukünftige Version des Designers sind Gegenstand der in dieser EULA dargestellten
Beschränkungen und dürfen nicht mit ihrer Entwickelten Software oder auf einem anderen Wege
vertrieben werden.
c. Doc-To-Help und ComponentOne Natural Search. Sie dürfen Doc-To-Help dazu nutzen,
Onlinehilfen, Handbücher oder andere Dokumentationen in elektronischem oder gedruckter
Form zu erstellen (die „Output Dokumente“). Sie können diejenigen Dateien, die in der
Dokumentation als wiedervertreibbare Dateien gekennzeichnet sind, in solche Output-
Dokumente fassen und vertreiben. Mit Ausnahme diesen speziellen wiedervertreibbaren
Dateien, DÜRFEN Sie die SOFTWARE NICHT an Dritte vertreiben, egal in welchem Format.
d. Studio Products. Es ist ihnen weder gestattet die Komponenten des Studio Products, für die
Sie eine Lizenz erhalten haben, mit anderen Entwicklern zu teilen, noch dürfen Sie die Nutzung
und/oder Installation dieser Komponenten durch andere Entwicklern erlauben.
e. ComponentOne Response und SOAP Channel. ComponentOne Response ist dafür
vorgesehen, auf einem Netzwerkserver installiert zu werden. C1 gibt ihnen folgende Rechte für
diese SOFTWARE: a) Installation: Sie dürfen eine Kopie der SOFTWARE auf einem
Netzwerkserver installieren; b) Verwendung: Wenn die SOFTWARE installiert und initialisiert
wurde, dann erstellt diese eine Datenbankdatei, welche eine Lösungs- und Wissensdatenbank
darstellt (Die Datenbank wird im Folgenden „Knowledge Base“ genannt).

8 · Willkommen zu ComponentOne FlexGrid für .NET
Sie dürfen die SOFTWARE nur dafür verwenden, um Knowledge Bases auf einem
Netzwerkserver zu erstellen. Um Knowledge Bases auf mehr als nur einem Netzwerkserver zu
erstellen und zu verwenden, müssen Sie zusätzliche SOFTWARE-Lizenzen für jeden zusätzlichen
Netzwerkserver erwerben.
5. Updates/Upgrades; Studio Abonnement. Gemäß den Bestimmungen in dieser EULA sind die
Lizenzen fortwährend. Updates und Verbesserungen der SOFTWARE können von Zeit zu Zeit
durch C1 zur Verfügung gestellt werden und welche in diesem Falle nach den Bestimmungen,
die zu diesem Zeitpunkt Gültigkeit besitzen und die ganz im Ermessen von C1 liegen, angeboten
werden. C1 wird diese Updates und Verbesserungen der SOFTWARE nie oder zu gegebenem
Zeitpunkt entweder kostenlos oder für eine Gebühr anbieten und über ihre gewählten
Vertriebswege vertreiben. Das Verfahren mit diesen Begebenheiten liegt im alleinigen und
vollständigen Ermessen von C1.
C1 lizenziert bestimmte, seiner separat lizenzierten Produkte in einem Produktbündel, welches
als C1 „Studio“-Produktlinie bezeichnet wird (die „Studio Products“). Die wirklich separat
lizenzierten Produkte, die als Studio Products zusammengestellt wurden, können sich von Zeit
zu Zeit ändern, da die Zusammenstellung ganz im Ermessen von C1 liegt. Sollte die SOFTWARE
als C1 „Studio” Produkt gekennzeichnet sein, so ist die SOFTWARE Teil der Studio Products. Die
SOFTWARE und die Studio Products werden von Zeit zu Zeit überarbeitet (was beispielsweise
eine Überarbeitung durch Updates, durch Verbesserungen und im Falle von Studio Products,
durch mögliche Änderungen bezüglich der spezifischen Zusammenstellung des Produktbündels,
bedeuten kann). Damit Sie berechtigt sind, eine solche Überarbeitung der SOFTWARE oder der
Studio Products zu erhalten, müssen Sie über eine gültige SOFTWARE Lizenz oder ein gültiges
Studio Abonnement verfügen. Der ursprüngliche Käufer der SOFTWARE oder eines Studio
Products erhält ein einjähriges Abonnement ab dem Zeitpunkt des Erwerbs der SOFTWARE.
Nach Ablauf des Jahres muss das Studio Abonnement und/oder die SOFTWARE-Lizenz
erneuert werden, um weiterhin berechtigt zu sein, die SOFTWARE und/oder die Revisionen der
Studio Products zu erhalten.
6. Seriennummer. Im Inneren der Verpackung der SOFTWARE ist eine einzigartige
Fabrikatsnummer (die „Seriennummer”) enthalten, welche die Registrierung für die
SOFTWARE ermöglicht. Die Seriennummer unterliegt den Beschränkungen, die in dieser EULA
dargelegt werden. Sie darf weder mit ihrer Entwickelten Software, noch auf anderem Wege
bekannt gegeben oder vertrieben werden. Die Bekanntgabe oder der Vertrieb der Seriennummer
stellt einen Verstoß gegen diese EULA dar und bewirkt automatisch die Beendigung und den
Entzug aller durch diese EULA garantierten Rechte.
7. Evaluations-Version. Sollten Sie eine „Evaluations-Version“ oder eine ähnliche Version
verwenden, die speziell als solche von C1 entweder auf dessen Webseite oder auf anderem Wege
ausgewiesen ist, so sind die Lizenzen auf folgendes beschränkt: a) ihnen wird eine Lizenz für die
Verwendung der SOFTWARE für einen Zeitraum von dreißig (30) Tage, beginnend mit dem Tag
der Installation (die „Evaluations-Periode”) gewährt; b) nach Ablauf der Evaluations-Periode
sollten Sie entweder i) die SOFTWARE von dem Computer, der die Installation enthält, löschen,
oder Sie können ii) C1 oder einen seiner autorisierten Händler kontaktieren, um eine SOFTWARE
Lizenz zu erwerben, welche den Bestimmungen dieser EULA unterliegt; und c) jede mit der
SOFTWARE entwickelte Software darf nicht vertrieben oder für einen kommerziellen Zweck
verwendet werden.
III. GEWERBLICHE SCHUTZRECHTE.
1. Urheberrecht. Alle Eigentumsrechte und gewerblichen Schutzrechte an der SOFTWARE
(einschließlich, aber nicht beschränkt auf Bilder, Fotografien, Animationen, Video, Audio, Musik,

ENDBENUTZER-LIZENZVERTRAG FÜR COMPONENTONE SOFTWARE · 9
Text und „Applets“, die in der SOFTWARE enthalten sind) sowie an jeder Kopie der SOFTWARE
und jede einbegriffenen Eigentumsrechte und anderes geistiges Eigentum oder der Bezug darauf,
liegen ausschließlich bei C1. Eine Ausnahme besteht in begrenzten Umfang, in dem C1 der
rechtmäßige Lizenzinhaber von bestimmten Technologien Dritter ist, die in der SOFTWARE
enthalten sind. Die SOFTWARE ist durch Urheberrechte und internationalen
Vertragsvorschriften geschützt. Die SOFTWARE wird lizenziert, nicht verkauft. C1 behält sich
alle Rechte, die nicht anderweitig ausdrücklich und spezifisch durch diese EULA gewährleistet
werden, vor.
2. Sicherungskopie. Sie sind berechtigt: (a) die SOFTWARE ausschließlich für den Zweck der
Erstellung einer Sicherungskopie oder der Archivierung zu kopieren; oder (b) die SOFTWARE
auf einem einzigen Computer zu installieren, vorausgesetzt, Sie bewahren das Original einzig für
den Zweck der Erstellung einer Sicherungskopie oder der Archivierung auf. Ungeachtet des
Voranstehendem sind Sie nicht berechtigt, die schriftlichen Materialien zu kopieren.
3. Allgemeine Beschränkungen. Es ist ihnen nicht gestattet, die SOFTWARE auseinander
zunehmen (Reverse Engineering), zu dekompilieren oder auseinander zu bauen, mit der
Ausnahme und nur zu dem durch das anwendbaren Rechtes ausdrücklich gestatteten Umfang,
zu dem solche Aktivitäten trotz dieser Beschränkungen zugelassen sind.
4. Software Übertragungen. Sie sind nicht berechtigt, die SOFTWARE zu vermieten oder zu
verleasen. Sie sind berechtigt, die SOFTWARE auf einen anderen Computer zu übertragen,
vorausgesetzt, dass die SOFTWARE vollständig von dem Computer entfernt wurde, von
welchen Sie übertragen wurde. Sie sind berechtigt, ihre gesamten Rechte unter dieser EULA
dauerhaft zu übertragen, vorausgesetzt, dass Sie keine Kopien zurückbehalten, dass Sie die
gesamte SOFTWARE übertragen (einschließlich aller Zubehörteile, dem Speichermedium und
den schriftlichen Materialien, alle Daten, Verbesserungen, diese EULA und, falls möglich, die
Echtheitsbescheinigung) und dass der Empfänger den Bestimmungen dieser EULA zustimmt,
wie von dieser EULA vorgesehen. Falls es sich bei der SOFTWARE um ein Update oder eine
Verbesserung handelt, muss eine Übertragung der SOFTWARE alle früheren Versionen der
SOFTWARE beinhalten.
5. Kündigung. Ohne sonstige Rechte zu beschaden oder zu beschränken ist C1 berechtigt, diese
EULA und die Lizenzen zu kündigen, sofern Sie die Bestimmungen dieser EULA nicht einhalten.
In einem solchen Fall sind Sie verpflichtet, sämtliche Kopien der SOFTWARE und alle ihre
Komponenten zu vernichten.
6. Ausfuhrbeschränkungen. Sie erkennen an, dass die SOFTWARE U.S. amerikanischen Ursprungs
ist. Sie erkennen an, dass die Lizenz und der Vertrieb der SOFTWARE dem Exportkontrollrecht,
den gesetzlichen Regulierungen und den diesbezüglichen Ergänzungen der Vereinigten Staaten
von Amerika unterliegen, welche die Exporte und Reexporte von Software, technischen Daten
und direkten Produkten technischer Daten, einschließlich den Services und entwickelter Software
begrenzen. Sie erklären sich damit einverstanden, dass Sie die SOFTWARE oder irgendeine
entwickelte Software oder irgendwelche Informationen, Dokumente und/oder gedruckte
Materialien, die entweder direkt oder indirekt in Zusammenhang mit der SOFTWARE oder einer
entwickelten Software stehen, nicht zu exportieren oder zu reexportieren, ohne zuvor hierfür
eine Genehmigung vom United States of America Department of Commerce's Bureau of Export
Administration („BXA“) oder von einer anderen zuständigen Regierungsbehörde erhalten zu
haben. Sollte der Export oder Reexport in einen Staat, zu Endbenutzern oder zwecks einer
Endbenutzung stattfinden, gegen welche das U.S. amerikanische Exportrecht, Regulierungen
oder irgendwelche diesbezüglich ergänzende Beschränkungen mit nachfolgenden Inhalt
vorsieht, dann ist folgendes zu beachten:

10 · Willkommen zu ComponentOne FlexGrid für .NET
Beschränkung gegen Staaten: Die Liste der beschränkten Staaten beinhaltet derzeit (nicht zwingend
vollständig): Kuba, Iran, Irak, Libyen, Montenegro, Nord Korea, Serbien, Sudan und Syrien.
Beschränkung gegen Endbenutzer: Jeder Endbenutzer, von dem Sie wissen, oder von dem Sie
Grund haben anzunehmen, dass er die SOFTWARE oder die entwickelte Software für den
Entwurf, die Entwicklung oder die Produktion von Flugkörpern und Flugkörpertechniken, von
Nuklearwaffen und Waffentechnologien oder chemischen und biologischen Waffen nutzt. Jeder
Bürger der beschränkten Staaten, wo auch immer er sich befindet, der beabsichtigt, die
SOFTWARE oder die entwickelte Software in eine der beschränkten Staaten zu senden oder zu
transportieren.
Beschränkung gegen Endbenutzungen: Jede Verwendung der SOFTWARE und der entwickelten
Software, die in Zusammenhang mit dem Entwurf, der Entwicklung oder der Produktion von
Flugkörpern und Flugkörpertechniken, von Nuklearwaffen und Waffentechnologien oder
chemischen und biologischen Waffen steht.
Diese Beschränkungen können sich mit der Zeit ändern. Sie müssen dafür Sorge tragen und
garantieren, dass weder das BXA noch irgendeine andere staatliche Behörde der Vereinigten
Staaten von Amerika ihr Exportsonderrecht aufgeschoben, aufgehoben oder verweigert hat. C1
erkennt an, dass es sich angemessen bemühen muss, um ihnen alle notwendig-relevanten
Informationen bezüglich der SOFTWARE und seinem Unternehmen bereitzustellen, um ihnen so
zu ermöglichen, vollständig den Bestimmungen dieses Kapitels nachzukommen. Sollten Sie
weitere Fragen hinsichtlich ihren Verpflichtungen unter den Exportvorschriften der Vereinigten
Staaten von Amerika haben, können Sie sich an das Bureau of Export Administration wenden;
Bureau of Export Administration United States Department of Commerce, Exporter Counseling
Division, Washington DC. U.S.A. (202) 482-4811, http://www.bxa.doc.gov.
7. U.S. Government Restricted Rights. Die SOFTWARE und ihre Dokumente werden mit
beschränkten Rechten geliefert. Für Erlässe, die von den Vereinigten Staaten von Amerika, seinen
Vertretungen und/oder Vermittlungen (die „Regierung“), mit Ausnahme des
Verteidigungsministerium, vor dem 1. Dezember 1995 ausgestellt wurden, unterliegen die
Nutzung, die Vervielfältigung oder die Bekanntmachung der Software und der Dokumente, die
der Regierung unter dieser EULA bereitgestellt wurden, den BESCHRÄNKTEN RECHTEN, wie
in den Unterparagraphen (c)(1) und (2) der Commercial Computer Software - Restricted Rights
clause in 48 CFR ch.1 52.227-19 dargelegt. Für Erlässe, die von dem Verteidigungsministerium
vor dem 29. September 1995 ausgestellt wurden, unterliegen die Nutzung, die Vervielfältigung
oder die Bekanntmachung der Software und der Dokumente, die der Regierung unter dieser
EULA bereitgestellt wurden, den BESCHRÄNKTEN RECHTEN, wie in den Unterparagraphen
(c)(1)(ii) des Rights in Technical Data and Computer Software clause in 48 CFR ch.2 252.227-7013
dargelegt. Sie werden jeder Anforderung der Regierung nachkommen, einschließlich und ohne
Einschränkung der Platzierung von beschränkenden Erklärungen in der SOFTWARE und in dem
Lizenz-Vertrag, welcher in Zusammenhang mit dem Vertrieb der SOFTWARE verwendet wird,
um den Schutz dieser BESCHRÄNKTEN RECHTEN zu erhalten. Der Hersteller ist
ComponentOne, LLC, 4516 Henry Street, Suite 501, Pittsburgh, Pennsylvania 15213 USA. Für
Erlässe, die von der Regierung am 1. Dezember 1995 oder später und vom
Verteidigungsministerium am 29. September 1995 oder später ausgestellt wurden, sind die
einzigen Rechte, die an der Software und an den Dokumenten übertragen werden, die in dieser
EULA enthalten sind. Unter keinen Umständen soll C1 dazu verpflichtet werden, einer
Regierungsanforderung hinsichtlich der Vorlage einer oder der Anfrage nach einer Befreiung von
der Einreichung von Kostendaten oder Preisgestaltungsdaten oder betrieblichen
Rechnungswesensanforderungen nachzukommen. Für jeden Vertrieb der SOFTWARE, der von

ENDBENUTZER-LIZENZVERTRAG FÜR COMPONENTONE SOFTWARE · 11
C1 die Einhaltung einer Regierungsanforderung bezüglich Kostendaten oder
Preisgestaltungsdaten oder Anforderungen hinsichtlich dem betrieblichen Rechnungswesen
erfordern würde, müssen Sie eine sachgerechte Befreiung oder Freistellung von solchen
Anforderungen zugunsten von C1 von der zuständigen Regierungsstelle einholen, bevor die
SOFTWARE an die Regierung vertrieben und/oder lizenziert wird.
IV. GARANTIEN UND ANSPRÜCHE.
1. Beschränkte Garantie. C1 garantiert, dass das originale Speichermedium für einen Zeitraum von
neunzig (90) Tagen ab dem Zeitpunkt der Lieferung der SOFTWARE keine Fehler aufweist.
SOFERN NICHT ANDERS IN DEM VORHERGEHENDEN SATZ BESCHRIEBEN UND IM
GRÖßTMÖGLICHEN DURCH DAS ANWENDBARE RECHT GESTATTETEN UMFANG,
SCHLIEßT C1 AUSDRÜCKLICH JEDE GARANTIE FÜR DIE SOFTWARE, FÜR DIE
SCHRIFTLICHEN MATERIALIEN UND ALLES ANDERE, WAS C1 HIERMIT GELIEFERT
HAT, AUS. C1 LIEFERT DIES ALLES MIT DER BESCHAFFENHEIT „OHNE
MÄNGELGEWÄHR“, OHNE JEDE ART VON GEWÄHRLEISTUNGEN, UNABHÄNGIG
DAVON, OB SIE AUSDRÜCKLICH ODER KONKLUDENT GEWÄHRT WORDEN SIND,
EINSCHLIEßLICH UND OHNE AUSNAHME KONKLUDENTER GEWÄHRLEISTUNGEN
IM HINBLICK AUF HANDELSÜBLICHKEIT UND EIGNUNG FÜR EINEN BESTIMMTEN
ZWECK. DAS GESAMTE RISIKO, WELCHES SICH AUS DER NUTZUNG ODER
AUSFÜHRUNG DER SOFTWARE UND DER SCHRIFTLICHEN MATERIALIEN ERGIBT,
MÜSSEN SIE TRAGEN. DIESE BESCHRÄNKTE GARANTIE GEWÄHRT IHNEN
BESTIMMTE RECHTE. JE NACH STAAT KÖNNEN SIE MÖGLICHERWEISE ANDERE
RECHTE HABEN.
2. Beschränkter Anspruch. Die gesamte Haftung von C1 und ihr alleiniger Anspruch unter dieser
EULA besteht nach Ermessen von C1 entweder (a) in der Rückerstattung des für die SOFTWARE
bezahlten Preises; (b) in der Reparatur der SOFTWARE durch Updates, die entweder online oder
je nach Wahl von C1 auf anderem Wege vertrieben werden; oder (c) in der Ersetzung der
SOFTWARE mit SOFTWARE, die so funktioniert, wie dies in der SOFTWARE-Dokumentation
beschrieben wird, vorausgesetzt, dass Sie die SOFTWARE in gleicher Weise zurücksenden, wie
unter Kapitel I.2 festgeschrieben ist, welches die Bestimmung für die Zurücksendung der
SOFTWARE, im Falle dass diese EULA nicht akzeptiert wird, enthält. Für jedes Speichermedium
einer reparierten oder ausgetauschten SOFTWARE wird entweder eine Garantie für den Rest der
ursprünglichen Garantiefrist oder für dreißig (30) Tage gewährt, je nach dem, welcher Zeitraum
länger ist. DIESE ANSPRÜCHE GELTEN NICHT AUSSERHALB DEN VEREINIGTEN
STAATEN VON AMERIKA. IM GRÖßTMÖGLICHEN DURCH DAS ANWENDBARE
RECHT GESTATTETEN UMFANG IST C1 IN KEINEM FALL HAFTBAR FÜR
IRGENDWELCHE SCHÄDEN WELCHER ART AUCH IMMER (EINSCHLIEßLICH UND
OHNE AUSNAHME, SCHÄDEN DURCH VERLUST VON GESCHÄFTLICHEM GEWINN,
DURCH GESCHÄFTSUNTERBRECHUNGEN, DURCH VERLUST VON
GESCHÄFTLICHEN INFORMATIONEN ODER FÜR IRGENDWELCHE ANDEREN
VERMÖGENSSCHÄDEN), DIE AUS DER VERWENDUNG DER SOFTWARE ODER DER
TATSACHE, DASS SIE NICHT VERWENDET WERDEN KANN, ENTSTEHEN, SELBST
WENN C1 AUF DIE MÖGLICHKEIT SOLCHER SCHÄDEN HINGEWIESEN WORDEN IST.
DA EINIGE STAATEN/RECHTSORDUNGEN DIE BESCHRÄNKUNG ODER DEN
AUSSCHLUSS DER HAFTUNG FÜR ZUFÄLLIGE ODER FOLGESCHÄDEN NICHT
GESTATTEN, GILT DIE VORSTEHENDE BESCHRÄNKUNG FÜR SIE MÖGLICHERWEISE
NICHT.
V. SONSTIGES.
1. Dieses ist das gesamte Vertragswerk. In Bezug auf die SOFTWARE ist diese EULA
(einschließlich der Ergänzungen oder Neufassungen zu dieser EULA, die dieser SOFTWARE
beigefügt sind) die endgültige, vollständige und ausschließliche Bescheinigung für das gesamte

12 · Willkommen zu ComponentOne FlexGrid für .NET
Vertragswerk zwischen ihnen und C1. Diese EULA ersetzt jede früheren sowie gleichzeitigen
Angebote, Kaufbestellungen, Anzeigen und alle anderen mündlichen oder schriftlichen
Mitteilungen, die in Zusammenhang mit dem Gegenstand dieser EULA stehen. Nur die
Bestimmungen, die in dieser EULA enthalten sind, das heißt keine anderen Vereinbarung oder
Vertragswerke, die auf irgendeine Weise diese Bestimmungen verändern, sollen für die
Vertragsparteien verbindlich sein. Dies trifft nicht zu, wenn die Vertragsparteien schriftlich oder
auf eine andere, nicht mündliche Weise in einen Vertragsprozess treten, wobei die
Vertragsparteien sachlich und endgültig in einer verbindlichen Weise handeln (wie
beispielsweise durch eine anhaltende Installation der SOFTWARE, „durchklicken” durch einen
Fragebogen, etc.). Den Mitarbeitern, Bevollmächtigten oder anderen Repräsentanten von C1 ist es
nicht gestattet, diese EULA mündlich zu verändern.
2. Sie leisten C1 Schadensersatz. Sie stimmen hiermit einer Ausschlussklausel für finanzielle
Haftung zu, Sie stimmen zu, dass Sie C1 Schadensersatz leisten, und dass Sie C1, seine Zulieferer
und Händler vor jeglicher Art der Anspruchsforderungen oder Gerichtsverfahren, die aus dem
Bruch von Bestimmungen und Bedingungen dieser EULA resultieren, einschließlich der
Anwaltskosten, zu schützen.
3. Interpretation dieser EULA. Falls aus irgendeinem Grund der Gerichtsstand eine Bestimmung
dieser EULA oder einen Bestandteil der Bestimmung für uneinklagbar befindet, wird diese
Bestimmung dieser EULA bis zu ihrem größtmöglichen gestatteten Umfang durchgesetzt, um die
Absicht der Vertragsparteien zu erwirken. Der Rest dieser EULA wird seine volle Gültigkeit
beibehalten. Misslingt es einer der beiden Vertragsparteien, eine Bestimmung dieser EULA
durchzusetzen, wird dies nicht als Verzicht von künftigen Durchsetzungen dieser oder anderer
Bestimmungen erachtet. Sofern gesetzlich nicht anders vorgeschrieben oder verändert, unterliegt
diese EULA den Gesetzen des Commonwealth von Pennsylvania, ohne den Konflikt der EULA
mit den Gesetzmäßigkeiten zu betrachten. Die Vertragsparteien willigen mit der Zuständigkeit
und dem Verhandlungsort des Commonwealth von Pennsylvania, dem County von Allegheny,
ein und stimmen zu, dass jegliche Gerichtsverfahren, die sich aus dieser EULA ergeben, einzig in
einem solchen Commonwealth ausgeführt werden. Wurde die SOFTWARE außerhalb den
Vereinigten Staaten erworben, so unterliegt sie dem lokalen Recht.
Häufig gestellte Fragen zur Lizenz (FAQs)
Dieser Abschnitt beschreibt die wichtigsten, technischen Aspekte der Lizenz. Diese werden dem
Anwender helfen, eventuelle Lizenzprobleme während der Verwendung von ComponentOne .NET und
ASP.NET-Produkten zu verstehen und zu lösen.
Was ist Lizenzierung?
Lizenzierung ist ein Mechanismus um intellektuelles Eigentum zu schützen und um dem Anwender die
Verwendung des Softwareproduktes zu gestatten.
Lizenzierung soll nicht nur den illegalen Vertrieb von Softwareprodukten verhindern. Viele
Softwarehersteller, darunter auch ComponentOne, verwenden Lizenzierung um einem potentiellen
Anwender die Möglichkeit zu geben, dass Produkt zu testen, bevor er es möglicherweise erwirbt.
Ohne Lizenzierung wäre diese Art des Vertriebes für den Hersteller unpraktisch und für den Anwender
unbequem. Hersteller müssten entweder Evaluationssoftware mit begrenzter Funktionalität vertreiben,
oder Sie übertragen die Lizenzverantwortung an den Kunden, der aber schnell vergessen kann, dass er
nur eine Evulationsversion besitzt und das Produkt noch nicht erworben hat.

Wie funktioniert Lizenzierung?
Häufig gestellte Fragen zur Lizenz (FAQs) · 13
ComponentOne verwendet ein auf eine Standardlizenz von Microsoft basierendes Lizenzmodel, welches
für alle Komponententypen gültig ist.
Wenn ein Anwender ein Produkt erwirbt, erhält er ein Installationsprogramm und eine Serial-Nummer.
Während dem Installationsprozess wird der Anwender nach der Serial-Nummer gefragt, die auf dem
System gespeichert ist. (Der Anwender kann die Serial-Nummer auch eingeben, indem er auf die
„License“-Schaltfläche im „Über“-Fenster eines beliebigen Produktes von ComponentOne klickt.)
Wenn eine lizenzierte Komponente zu einem Formular oder einer Webseite hinzugefügt wird, dann
erfragt Visual Studio die neu erstellte Komponente nach Lizenzinformationen. Die Komponente sucht
dann nach den Lizenzinformationen, die im System gespeichert sind, und erstellt einen Schlüssel, der von
Visual Studio in zwei Dateien gespeichert wird:
1. Eine „.licenses“- Ressourcendatei, welche den eigentlichen Schlüssel beinhaltet,
und
2. Eine „licenses.licx“-Datei, die Verweise zu diesen Ressourcen enthält.
Diese Dateien werden automatisch dem Projekt hinzugefügt.
Beachten Sie, dass die „licenses.licx“-Datei normalerweise nicht im Solution Explorer angezeigt wird; sie
erscheint nur, wenn Sie die „Show All Files“-Schaltfläche in der Toolbox des Solution Explorers drücken
oder Project | Show All Files aus dem Hauptmenü des Visual Studios auswählen.
Später, wenn die Komponente während der Runtime erstellt wird, erhält sie den Schlüssel, der in der
Erstellungsphase erstellt wurde und kann entscheiden, ob sie diesen einfach akzeptiert, oder eine Störung
meldet und den Prozess fehlschlagen lässt, oder ob sie eine Nachricht mit erinnernden Informationen
über die unlizenzierte Software ausgibt.
Alle ComponentOne-Produkte zeigen Lizenzinformationen an, wenn diese noch nicht lizenziert sind.
Allerdings wird keines dieser Ereignisse Störungen senden oder die Anwendung funktionsunfähig
machen.
Übliche Szenarien
Komponenten in der Erstellungsphase erstellen
Dies ist das weitverbreitetste und einfachste Szenario: Der Anwender fügt dem Formular eine oder
mehrere Steuerungen hinzu, die Lizenzinformationen werden in der „licenses.licx“-Datei gespeichert und
die Komponente funktioniert.
Der Mechanismus ist für „Windows Forms“ und „Web Forms“ (ASP.NET)-Projekte exakt der Gleiche.
Komponenten in der Runtime erstellen
Dies ist ebenfalls ein übliches Szenario. Sie benötigen keine Instanz der Komponente auf dem Formular,
aber erstellen eine oder mehrere Instanzen während der Runtime.
In diesem Fall wird das Projekt keine „licenses.licx“-Datei enthalten, oder die Datei wird keinen
passenden Schlüssel für die Komponente enthalten, und deswegen wird die Lizenzierung fehlschlagen.
Um dieses Problem zu beheben, müssen Sie eine Instanz der Komponente einem Formular in Ihrem
Projekt hinzufügen. Dies wird die „licenses.licx“-Datei erstellen und alles funktioniert wie erwartet. Die
Komponente kann, nachdem die „licenses.licx“-Datei erstellt wurde, wieder entfernt werden.

14 · Willkommen zu ComponentOne FlexGrid für .NET
Von lizenzierten Komponenten erben
Wenn eine Komponente, die von einer lizenzierten Komponente erbt, erstellt wird, so werden die
Lizenzinformationen, die im Formular gespeichert werden, immer noch benötigt. Dies kann auf zwei
Wegen getan werden:
1. Fügen Sie ein „LicenseProvider“-Attribut der Komponente hinzu.
Dieses Attribut wird die Komponente als lizenziert markieren. Wenn eine Komponente zu einem
Formular hinzugefügt wird, erstellt und verwaltet Visual Studio die „licenses.licx“-Datei, und
die „base-Klasse“ wird den Lizenzierungsprozess wie üblich handhaben. Es ist kein weiteres
Eingreifen nötig. Zum Beispiel:
[LicenseProvider(typeof(LicenseProvider))]
class MyGrid: C1.Win.C1FlexGrid.C1FlexGrid
{
// ...
}
2. Fügen Sie eine Instanz der Basiskomponente dem Formular hinzu.
Dies wird die Lizenzinformationen, wie in den vorhergehenden Szenarien in die „licenses.licx“-
Datei einbetten. Die Basiskomponente wird die Informationen finden und verwenden. Wie
zuvor, kann auch hier die zusätzliche Instanz, nachdem die „licenses.licx“-Datei erstellt wurde,
wieder gelöscht werden.
Lizenzierte Komponenten in Konsole-Anwendungen verwenden
Wenn eine Konsole-Anwendung erstellt wird, gibt es keine Formulare denen eine Komponente
hinzugefügt werden kann, so dass Visual Studio keine „licenses.licx“-Datei erstellt.
In diesen Fällen müssen Sie eine vorübergehende „Windows Forms“-Anwendung erstellen und alle
gewünschten und lizenzierten Komponenten einem Formular anhängen. Schließen Sie dann die
„Windows Forms“-Anwendung und kopieren Sie die „licenses.licx“-Datei in das Projekt der Konsole-
Anwendung.
Stellen Sie sicher, dass die „licensex.licx“-Datei als eingebettete Ressource konfiguriert ist. Dazu müssen
Sie die „licenses.licx“-Datei im Solution Explorer-Fenster rechtsklicken und Eigenschaften auswählen. Im
Eigenschaftsfenster müssen Sie anschließend die „Build Action“-Eigenschaft auf „Embedded Resource“
stellen.
Lizenzierte Komponenten in Visual C++-Anwendungen verwenden
Es scheint als wäre ein Fehler in VC++ 2003. Die „licenses.licx“-Datei wird während des
Erstellungsprozesses nicht berücksichtigt und daher die Lizenzinformationen in VC++-Anwendungen
nicht verarbeitet.
Um dieses Problem zu beheben, kompilieren Sie die Lizenzressourcen und verknüpfen diese mit dem
Projekt wie folgt:
1. Erstellen Sie das C++-Projekt wie üblich. Dies sollte eine *.exe-Datei und auch die „licenses.licx“-
Datei mit den Lizenzinformationen erzeugen.
2. Kopieren Sie die „licenses.licx“-Datei aus dem „app“-Verzeichnis in das Zielverzeichnis „Debug“
oder „Release“.
3. Kopieren Sie das C1Lc.exe-Werkzeug und die lizenzierten *.dlls in das Zielverzeichnis.
Verwenden Sie nicht die standard lc.exe. Diese hat einen Fehler.)

Häufig gestellte Fragen zur Lizenz (FAQs) · 15
4. Verwenden Sie C1Lc.exe um die „licenses.licx“-Datei zu kompilieren. Die Kommandozeile sollte
wie folgt aussehen:
c1lc /target:MyApp.exe /complist:licenses.licx /i:C1.Win.C1FlexGrid.dll
5. Verknüpfen Sie nun die Lizenz in das Projekt, indem Sie zurück zu Visual Studio gehen, das
Projekt rechtsklicken, Eigenschaften auswählen und bis zur Linker/Command Line-Option
gehen. Schreiben Sie nun Folgendes:
/ASSEMBLYRESOURCE:Debug\MyApp.exe.licenses
6. Erstellen Sie erneut die ausführbare Datei um die Lizenzinformationen in die Anwendung
einzuschließen.
Fehlerbehebung
Wir versuchen die Lizenzierungsmechanismen so unauffällig wie möglich zu gestallten, aber Probleme
werden aus verschiedenen Gründen auftreten.
Nachfolgend stehen Beschreibungen häufiger Probleme und deren Lösung.
Ich besitze eine lizenzierte Version eines ComponentOne-Produkts, aber ich bekomme immer noch den
Startbanner, wenn ich das Projekt ausführe.
Wenn dies passiert, dann muss es ein Problem mit der „licenses.licx“-Datei in ihrem Projekt geben.
Entweder existiert die Datei nicht, sie enthält die falschen Informationen oder sie ist nicht richtig
konfiguriert.
Versuchen Sie zunächst eine vollständig neue Kompilierung („Rebuild All“ aus dem Visual Studio Build-
Menü). Diese sollte normalerweise die richtigen Lizenzressourcen wiederherstellen.
Wenn dies fehlschlägt, dann folgen Sie diesen Schritten:
1. Öffnen Sie das Projekt und gehen Sie zu dem Solution Explorer-Fenster.
2. Klicken Sie oben im Fenster auf die „Show All Files“-Schaltfläche.
3. Suchen und löschen Sie die „licenses.licx“-Datei.
4. Schließen Sie das Projekt und öffnen Sie es wieder.
5. Öffnen Sie das Hauptformular und fügen Sie eine Instanz von jeder lizenzierten Steuerung hinzu.
6. Überprüfen Sie im Solution Explorer-Fenster, ob die „licenses.licx“-Datei vorhanden ist.
7. Erstellen Sie das Projekt mit der „Rebuild All“-Option erneut; nicht nur „Rebuild“.
Ich besitze eine lizenzierte Version eines ComponentOne-Produkts auf meinem Web Server, aber die
Komponenten verhalten sich immer noch wie nicht lizenziert.
Es muss keine Lizenz auf einem Computer, der als Server und nicht als Entwicklungsumgebung
verwendet wird, installiert sein.
Die Komponenten müssen auf dem Entwicklungscomputer lizenziert sein, da die Lizenzinformationen in
der ausführbaren Dateien (*:exe oder *.dll) während der Projektkompilierung gespeichert werden.
Danach kann die Anwendung auf jedem Computer und auch auf Web Servern ausgeführt werden.

16 · Willkommen zu ComponentOne FlexGrid für .NET
Ich lade mir eine neue Version einer Komponente, die ich gekauft habe, herunter und nun bekomme ich
das Banner wenn ich meine Projekte kompiliere.
Stellen Sie sicher, dass der Lizenzschlüssel immer noch gültig ist. Wenn Sie die Komponente vor mehr als
einem Jahr lizenziert haben, dann ist Ihr Abonnement eventuell abgelaufen. In diesem Fall haben Sie
zwei Möglichkeiten.
Option 1 – Erneuern Sie ihr Abonnement um einen neuen Lizenzschlüssel zu erhalten.
Wenn Sie diese Option wählen, erhalten Sie einen neuen Schlüssel. Mit diesem können Sie die neuen
Komponenten direkt im Installationsmenü oder im „Über“-Fenster lizenzieren.
Das neue Abonnement berechtigt Sie für ein ganzes Jahr die neusten Versionen und Builds direkt über
unsere Webseite http://prerelease.componentone.com/ zu erhalten.
Option 2 – Die bestehenden Komponenten weiterverwenden.
Abonnements laufen ab, Produkte aber nicht. Sie können weiterhin die Komponenten, die Sie erhalten
oder heruntergeladen haben, auch mit abgelaufenem Abonnement verwenden.
Technische Unterstützung
ComponentOne FlexGrid für .NET wurde von ComponentOne LLC - einem Zusammenschluss der
Firmen APEX Software Corporation und VideoSoft - entwickelt. Folgende Wege stehen Ihnen für die
technische Unterstützung offen:
ComponentOne Webseite
Die ComponentOne-Webseite www.componentone.com hält reichhaltige Informationen und
Softwaredownloads für FlexGrid .NET-Anwender bereit. Darunter befindet sich auch:
Per eMail
• Beschreibungen der verschiedenen Supportoptionen.
• Nach Funktionalität sortierte Antworten zu häufig gestellten Fragen „FAQ“ über unsere
Produkte. Bitte schauen Sie zunächst in den FAQ's nach, bevor Sie uns direkt kontaktieren, da
dies Ihnen möglicherweise viel Zeit erspart und Sie außerdem viele neue Informationen über
unsere Produkte erfahren können.
• Kostenlose Produktupdates mit Fehlerbehebungen und neuen Funktionen.
Für technische Unterstützung über das Internet, schreiben Sie eine eMail an:
Support.FlexGrid.NET@componentone.com
Um sicherzustellen, dass Sie die bestmögliche Unterstützung erhalten, schreiben Sie uns bitte folgende
Informationen, wenn Sie ComponentOne kontaktieren:
• Ihre ComponentOne Produktseriennummer.
• Die Version und den Namen Ihres Betriebssystems.
• Ihre Entwicklungsumgebung und die Version.
Für weitere Informationen zur technischen Unterstützung besuchen Sie bitte unsere Webseite unter:
www.componentone.com/support

Peer-to-Peer Newsgroup
Wiedervertreibbare Dateien · 17
ComponentOne unterstützt auch eine Peer-to-Peer Newsgroup für Anwender. ComponentOne bietet
allerdings keine formale technische Unterstützung in diesen Newsgroups an, sondern gibt Ihnen die
Möglichkeit, Fragen über unsere Produkte einzustellen und die Fragen anderer Teilnehmer zu
beantworten. Dennoch wird ComponentOne die Newsgroup-Einträge verfolgen, um die Richtigkeit der
Informationen sicherzustellen und eventuell Kommentare zu hinterlassen, wenn dies nötig ist. Sie
können die Newsgroup über die Webseite von ComponentOne erreichen:
www.componentone.com/newsgroups.
Wiedervertreibbare Dateien
ComponentOne FlexGrid für .NET wurde von ComponentOne LLC entwickelt und veröffentlicht. Sie
dürfen es verwenden, um Programme in Verbindung mit Microsoft Visual Studio oder jeder anderen
Programmierumgebung, die es dem Anwender ermöglicht, Steuerungen zu integrieren und zu
verwenden, zu erstellen. Sie dürfen weiterhin die folgenden wiedervertreibbaren Dateien gebührenfrei
mit der von Ihnen entwickelten Anwendung vertreiben, sofern diese auf einem separaten Computer mit
einer CPU auf der Client/Workstation-Seite des Netzwerkes läuft:
• C1.Common.dll
• C1.Win.C1Flexgrid.Classic.dll
• C1.Win.C1Flexgrid.dll
Platzlizenzen sind für Gruppen von mehreren Entwicklern verfügbar. Bitte kontaktieren Sie
Sales@ComponentOne.com für weitere Einzelheiten.
Namensbereiche (Namespaces)
Namensbereiche organisieren die in einer Assembly definierten Objekte. Assemblies können mehrere
Namensbereiche enthalten, die wiederum andere Namensbereiche enthalten können. Namensbereiche
verhindern Mehrdeutigkeit und vereinfachen die Referenzierung wenn Sie große Objektgruppen, wie
zum Beispiel Klassenbibliotheken, verwenden.
Der allgemeine Namensbereich für Windowsprodukte von ComponentOne ist C1.Win. Der
Namensbereich für die FlexGrid-Steuerung ist C1.Win.C1FlexGrid. Der folgende Quelltext zeigt, wie
eine C1FlexGrid-Steuerung unter Verwendung des vollständig qualifizierten Namens dieser Klasse
deklariert wird:
• Visual Basic
• C#
Dim flex As C1.Win.C1FlexGrid.C1FlexGrid
C1.Win.C1FlexGrid.C1FlexGrid flex;
• Delphi
uses C1.Win.C1FlexGrid;
Namensbereiche adressieren ein Problem, welches unter dem Namen namespace pollution bekannt ist.
Hierbei wird der Entwickler einer Klassenbibliothek durch die Verwendung von ähnlichen Namen in
anderen Bibliotheken behindert. Diese Konflikte mit existierenden Komponenten werden auch name
collisions genannt.

18 · Willkommen zu ComponentOne FlexGrid für .NET
Zum Beispiel, wenn Sie eine neue Klasse mit dem Namen Column erzeugen, dann können Sie diese
innerhalb Ihres Projektes ohne Qualifikation verwenden. Die C1FlexGrid-Assembly implementiert
allerdings auch eine Klasse namens Column. Wenn Sie also die C1FlexGrid-Klasse in demselben Projekt
verwenden wollen, dann müssen Sie eine vollständig qualifizierte Referenz verwenden, damit diese
einzigartig ist. Wenn die Referenz nicht einzigartig ist, dann wird Visual Studio .NET einen Fehler wegen
der Mehrdeutigkeit des Namens erzeugen. Der folgende Quellcode zeigt, wie diese Objekte deklariert
werden müssen:
• Visual Basic
• C#
' Define a new Column object (custom Column class)
Dim MyCol as Column
' Define a new C1FlexGrid.Column object.
Dim FlexCol as C1.Win.C1FlexGrid.Column
// Define a new Column object (custom Column class)
Column MyCol;
// Define a new C1FlexGrid.Column object.
C1.Win.C1FlexGrid.Column FlexCol;
• Delphi
var
FlexCol: C1.Win.C1FlexGrid.Column;
MyCol: Column;
Vollständig qualifizierte Namen sind Objektreferenzen mit dem Namen des Namensbereiches, wo das
Objekt definiert ist, als Vorsilbe. Sie können Objekte aus anderen Projekten verwenden, wenn Sie eine
Referenz zu der Klasse erstellen, indem Sie „Add Reference“ aus dem Project-Menü auswählen und dann
denn vollständig qualifizierten Namen für das Objekt in Ihren Quellcode einbauen.
Vollständig qualifizierte Namen verhindern Namenskonflikte, weil der Kompiler immer feststellen kann,
welches Objekt verwendet wird. Die Namen selbst können aber schnell lang und lästig werden. Um dies
zu umgehen, können Sie die Import-Anweisung „import in C#“ verwenden, um ein Alias zu definieren
— ein abgekürzter Name, den Sie anstelle des vollständig qualifizierte Namen einsetzen können. Zum
Beispiel, der folgende Quellcodeausschnitt erzeugt Aliasse für zwei vollständig qualifizierte Namen und
verwendet diese dann um zwei Objekte zu definieren:
• Visual Basic
• C#
Imports C1Column = C1.Win.C1FlexGrid.Column
Imports MyColumn = MyProject.Column
Dim c1 As C1Column
Dim c2 As MyColumn
using C1Column = C1.Win.C1FlexGrid.Column;
using MyColumn = MyProject.Column;
C1Column c1;
MyColumn c2;
• Delphi
uses C1.Win.C1FlexGrid.Column,
MyProject.Column;
var

c2: MyColumn;
c1: C1Column;
Ein .NET-Projekt erstellen · 19
Wenn Sie den Import-Befehl ohne einen Alias verwenden, dann können Sie alle Namen in diesem
Namensbereich ohne entsprechende Qualifikation aber trotzdem einzigartig in Ihrem Projekt nutzen.
Ein .NET-Projekt erstellen
Dieses Thema zeigt, wie ein neues .NET-Projekt erstellt wird.
1. Wählen Sie New aus dem File-Menü in Microsoft Visual Studio .NET aus, und klicken Sie auf
Project. Das New Project-Fenster öffnet sich.
2. Wählen Sie entweder Visual Basic-Projekts oder Visual C# Projects in der Project Types-Box aus
und klicken Sie auf Windows Application in der Vorlagenliste auf der rechten Seite.
3. Suchen Sie einen Ort für Ihre Anwendung im Location-Feld oder geben Sie einen Ort ein und
klicken Sie auf OK.
Ein neues Microsoft Visual Studio .NET-Projekt wird am angegebenen Ort erstellt. Außerdem
wird ein neues Form1 (Formular1) in der Designer-Ansicht angezeigt.
4. Doppelklicken Sie die C1FlexGrid-Komponente in der Toolbox, um diese dem Form1
hinzuzufügen. Für weitere Informationen über das Hinzufügen von Komponenten zur Toolbox
schauen Sie unter „Die C1FlexGrid Component der Toolbox hinzufügen“ (Seite 20) nach.

20 · Willkommen zu ComponentOne FlexGrid für .NET
Die C1FlexGrid Component der Toolbox hinzufügen
Wenn C1FlexGrid installiert wird, dann erscheinen folgende neue Komponenten in der Toolbox des
Anpassungsfensters von Visual Studio:
• C1FlexGrid
• C1FlexGridClassic
C1FlexGrid ist die Komponente, die neue Wege für das Anzeigen, Bearbeiten, Formatieren, Organisieren,
Zusammenfassen und Drucken von tabellarischen Daten bereitstellt.
Mit der C1FlexGridClassic-Komponente können Sie existierende VSFlexGrid-Projekte migrieren.
Um diese Komponenten verwenden zu können, müssen diese der Visual Studio-Toolbox hinzugefügt
werden:
Öffnen Sie die Visual Studio IDE (Microsoft Development Environment). Stellen Sie sicher, dass die
Toolbox angezeigt wird. Wählen Sie Toolbox im View (Ansicht)-Menü aus, wenn nötig. Rechtsklicken Sie
die Toolbox um das Kontextmenü der Toolbox zu öffnen.
Wenn Sie die C1FlexGrid- und C1FlexGridClassic-Komponente auf deren eigenen Reiter in der Toolbox
anzeigen lassen wollen, dann wählen Sie Add Tab aus dem Kontextmenü aus und schreiben Sie den
Namen des Reiters hinein: zum Beispiel „C1FlexGrid”. Wählen Sie den Reiter aus, in dem die
Komponente erscheinen soll. Rechtsklicken Sie diesen und wählen Sie Customize Toolbox… aus dem
Kontextmenü aus. Das Customize Toolbox-Fenster wird sich öffnen.
Gehen Sie zum .NET Framework Komponenten-Reiter im Customize Toolbox-Fenster. Sortieren Sie die
Liste nach Namensbereichen, klicken Sie auf die Spaltenüberschrift „Namensbereich“ und markieren Sie
das Auswahlfeld für die Komponente, die zu dem Namensbereich C1.Win.C1FlexGrid gehört.

Die C1FlexGrid-Steuerung verwenden · 21
Die C1FlexGrid-Steuerung verwenden
Mit der C1FlexGrid-Steuerung können Sie tabellarische Daten anzeigen, bearbeiten, gruppieren und
zusammenfassen. Die Tabellensteuerung kann an eine Datenquelle gebunden sein, oder Sie verwaltet
ihre eigenen Daten.
Die C1FlexGrid-Steuerung hat ein reichhaltiges Objektmodel mit den folgenden Elementen:
Der folgende Abschnitt begleitet Sie durch die Hauptfunktionen der C1FlexGrid-Steuerung:
Layout Beschreibt wie die Tabellengröße und das Layout festgelegt werden.
Auswahl Beschreibt die Konzepte „current cell“ (aktuelle Zelle) und „selection“
(Auswahl).

22 · Die C1FlexGrid-Steuerung verwenden
Zellen bearbeiten Beschreibt die Implementierung von einfacher Textbearbeitung, Drop-down-
Listen und Kombolisten, Zellschaltflächen, Maskenbearbeitung und
Datengültigkeit.
Zellen formatieren Beschreibt wie das Format einer Tabelle bearbeitet wird: Zahlenformate,
Datums und Wahrheitswerte, Schriftart und Schriftfarbe, Textausrichtung
und Grafiken für einzelne Zellen oder eine gesamte Auswahl.
Zellen verbinden Beschreibt wie die Tabellenansicht verändert wird, so dass Zellen mit
ähnlichen Inhalten verschmelzen und somit eine Art „gruppierte“ Ansicht die
verwandten Daten markiert.
Zusammenfassen
und Gliederung
Beschreibt wie Zwischensummen der Tabelle hinzugefügt und
Gliederungsbäume erstellt werden.
Datenbindungen Diskutiert die grundlegenden Aspekte der ADO/OLEDB- und DAO-
Datenbindungen.
Speichern, Laden
und Drucken
Layout
Beschreibt wie Sie den Inhalt oder die Formatierung einer Tabelle speichern
und später wieder laden, oder Tabellendaten mit anderen Anwendungen,
wie zum Beispiel Microsoft Access und Excel, austauschen können. Dieser
Abschnitt zeigt Ihnen auch, wie Sie Tabellen drucken können.
Eigenschaftsgruppen Zeigt eine Übersicht der mit Querverweisen referenzierten
Haupteigenschaften von C1FlexGrid.
Eine C1FlexGrid-Steuerung besteht aus Zeilen und Spalten. Alle Zeilen und Spalten werden durch die
Eigenschaften Rows und Cols festgelegt.
Wenn die Tabellensteuerung an eine Datenquelle gebunden ist, dann wird die Anzahl der Zeilen und
Spalten durch die vorhandenen Daten bestimmt. Im ungebundenen Modus können Sie diesen
willkürliche Werte mit der Count-Eigenschaft der „Collections“ zuordnen. Zum Beispiel der
nachstehende Quellcode legt die Tabellengröße auf 500 Zeilen und 10 Spalten fest:
• Visual Basic
• C#
fg.Rows.Count = 500
fg.Cols.Count = 10
fg.Rows.Count = 500;
fg.Cols.Count = 10;
• Delphi
fg.Rows.Count := 500;
fg.Cols.Count := 10;
Es gibt zwei grundlegende Typen von Zeilen und Spalten: fixed und scrollable. Feste Zeile verweilen
immer oben in der Tabelle, wenn der Anwender die Tabelle vertikal blättert. Feste Spalten verweilen
immer links, wenn der Anwender horizontal blättert. Feste Zellen sind für die Anzeige von Überschriften
nützlich. Die Anzahl, die von der Count-Eigenschaft zurückgegeben wird, enthält feste und scrollbare
Zellen.
Sie können die Anzahl der festen Zeilen und Spalten mit der Fixed-Eigenschaft in den Rows- und Cols-
Collections festlegen. Zum Beispiel der nachfolgende Quellcode erstellt eine Tabelle mit einer festen
Zeilen und keiner festen Spalte:

• Visual Basic
• C#
fg.Rows.Fixed = 1
fg.Cols.Fixed = 0
fg.Rows.Fixed = 1;
fg.Cols.Fixed = 0;
• Delphi
fg.Rows.Fixed := 1;
fg.Cols.Fixed := 0;
Layout · 23
Die Rows- und Cols-Collections enthalten auch Methoden zum Einfügen, Löschen und Verschieben von
Zeilen und Spalten in der Tabelle. Sie können deren Item-Eigenschaft verwenden (ein Zähler) um
einzelne Elemente (Zeilen und Spalten) in jeder Collection anzusprechen.
Spalten mit dem C1FlexGrid-Spalteneditor bearbeiten
Wenn Sie dies bevorzugen, können Sie die Tabellenspalten während der Erstellungsphase einrichten,
anstatt denn Quellcode hierfür zu schreiben. Wählen Sie die Tabelle in .Net aus, gehen Sie zu den
Eigenschaften und klicken Sie auf die Schaltfläche neben der Cols-Eigenschaft, oder rechtsklicken Sie die
Steuerung und wählen Sie das Edit Columns…-Menü aus. Dies wird den nachfolgend gezeigten Column
Editor öffnen:
Im gebundenen Modus kann der Editor verwendet werden, um festzulegen, welche Felder der
DataSource angezeigt werden, in welcher Reihenfolge, mit welchen Spaltenüberschriften, wie Breit und
mit welcher Ausrichtung. Im ungebundenen Modus kann im Editor zusätzlich der Datentyp der Spalte
bestimmt werden.
Mit dem Editor können Sie folgende Tätigkeiten durchführen:
1. Spalten neu anordnen: Sie können Spalten verschieben, indem Sie diese mit der Überschriftszelle
auf eine neue Position ziehen.
2. Spaltenbreiten anpassen: Sie können die Spaltenbreiten verändern, indem Sie die rechte Kante
der Überschriftszelle mit der Maus ziehen. Sie können auch mehrere Spalten auswählen, indem

24 · Die C1FlexGrid-Steuerung verwenden
Auswahl
Sie die Shift-Taste während der Klicks auf die Überschriften halten und anschließend alle
Spaltenbreiten auf einmal über das Eigenschaftsfenster festlegen. Wenn Sie die Spaltenbreite auf
–1 stellen, dann wird die Standardbreite verwendet.
3. Spalteneigenschaften festlegen: Immer wenn eine oder mehrere Spalten ausgewählt sind, dann
können Sie deren Eigenschaften im Eigenschaftsfenster auf der linken Seite des Editors einsehen
und verändern.
4. Spalten einfügen oder löschen: Verwenden Sie die Symbolleiste um Spalten vor oder nach einer
Auswahl einzufügen oder zu löschen. Dies ist oft im ungebundenen Modus nützlich.
5. Die Symbolleiste für gängige Aufgaben verwenden: Nachfolgende Tabelle beschreibt die
Funktionen der Schaltflächen in der Symbolleiste:
Diese Schaltflächen sind Umschalter, die das Eigenschaftsfenster steuern. Der
Erste legt fest, ob die Eigenschaften für die ausgewählten Spalten in
alphabetischer oder kategorisierter Reihenfolge angezeigt werden. Der Zweite legt
fest, ob die Eigenschaftstabelle Beschreibungen für die ausgewählten
Eigenschaften anzeigen soll.
Undo (Rückgängig): Setzt alle Änderungen zurück und stellt den
Ausgangszustand der Tabellenspalten wieder her.
Insert Column (Spalten einfügen): Fügt Spalten links oder rechts der Auswahl
ein. Diese Schaltflächen sind nur für ungebundene Tabellen verfügbar.
Remove Column (Spalten löschen): Löscht die ausgewählte Spalte.
Column Width (Spaltenbreite): Legt für alle ausgewählten Spalten dieselbe Breite
fest, macht diese breiter oder schmaler.
Make Visible (Einblenden): Blendet alle Spalten ein. Wenn Sie die Visible-
Eigenschaft einer Spalte auf FALSE stellen, dann wird diese ausgeblendet und
kann dadurch nicht mehr mit der Maus ausgewählt werden. Verwenden Sie diese
Schaltfläche um alle Spalten anzuzeigen, so dass Sie diese auswählen und
bearbeiten können.
Alignment (Ausrichtung): Richten Sie die Spalteninhalte links-, zentriert oder
rechtsbündig aus. Diese Befehle betreffen nur den scrollbaren Bereich der Tabelle.
Um die Ausrichtung der Spaltenüberschrift vorzunehmen, wählen Sie die Spalte
aus und setzen Sie die TextAlignFixed-Eigenschaft entsprechend.
AutoResize (Optimale Breite): Diese Schaltfläche legt fest, ob eine Tabelle mit
gebundener Datenquelle automatisch die optimalen Breiten der Spalten bestimmen
soll, um deren Inhalt anzuzeigen.
Reload from Datasource (Daten erneut laden): Überschreibt alle Spalten mit den
Informationen der aktuellen DataSource (Datenquelle). Diese Schaltfläche ist
nützlich, wenn die Tabellensteuerung an eine Datenquelle gebunden ist und sie mit
der Bearbeitung von vorn beginnen wollen. Diese Schaltfläche ist deaktiviert, wenn
die Tabellensteuerung nicht an eine Datenquelle gebunden ist.
Die Tabellensteuerung besitzt eine Cursorzelle, welche bei aktiver Tabelle von einem fokussierenden
Rechteck umgeben ist. Der Anwender kann den Cursor mit der Tastatur oder der Maus bewegen und
den Inhalt der markierten Zelle bearbeiten, wenn die Tabelle bearbeitbar ist.

Auswahl · 25
Sie können die aktuelle Zelle im Quellcode mit der Row- und Col-Eigenschaft festlegen. Wenn Sie eine
dieser Eigenschaften auf –1 stellen, dann wird der Cursor versteckt.
Die Tabellensteuerung unterstützt extended selections - eine erweiterte rechteckige Auswahl über
mehrere Zellen, die durch zwei sich gegenüberliegende Ecken definiert wird: Die Cursorzelle und die
Auswahlzelle. Sie können die Auswahlzelle mit der RowSel- und ColSel-Eigenschaft im Quellcode
auslesen und festlegen. Sie können die Auswahl im Quellcode auch mit der Select-Methode festlegen.
Achtung: Wenn sich die Cursorzelle ändert, dann wird die Auswahl automatisch zurückgesetzt. Um eine
erweiterte Auswahl im Quellcode zu erstellen, legen Sie entweder Row und Col vor der RowSel und
ColSel fest oder verwenden Sie die Select-Methode.
Die Erscheinung der Auswahl wird von den folgenden Eigenschaften bestimmt:
1. FocusRect legt den Typ des fokussierenden Rechtecks für die Markierung der aktuellen
Cursorzelle fest.
2. HighLight legt fest, wann die Auswahl markiert werden soll, beispielsweise immer dann, wenn
die Steuerung einen Fokus hat, oder niemals.
3. Styles.HighLight und Styles.Focus sind Zellformate, die die Erscheinung der Auswahl in
Schriftart, Schriftfarbe und Zellrahmen festlegen.
Der Typ der verfügbaren Auswahl wird durch die SelectionMode-Eigenschaft bestimmt. Standardmäßig
unterstützt die Tabellensteuerung normale Bereichsauswahl. Sie können dieses Verhalten verändern, um
der erweiterten Auswahl, der Auswahl nach Zeilen oder Spalten oder im Listenfeldmodus vorzubeugen.
Der Listenfeldmodus erlaubt die Auswahl einzelner Zeilen.
Wenn Sie den Listenfeldauswahlmodus wählen, dann können Sie den Auswahlstatus für einzelne Zeilen
festlegen oder auslesen, indem Sie die Rows(index).Selected-Eigenschaft verwenden. Sie können auch
alle ausgewählten Zeilen mit der Rows.Selected-Eigenschaft abrufen. Zum Beispiel der nachfolgende
Quellcode wählt alle Zeilen aus, die eine bestimmte Bedingung erfüllen:
• Visual Basic
• C#
fg.SelectionMode = SelectionModeEnum.ListBox
Dim index As Integer
For index = fg.Rows.Fixed To fg.Rows.Count – 1
If Val(fg(index, "Sales")) > 80000 Then
fg.Rows(index).Selected = True
End If
Next
Console.WriteLine("There are now {0} rows selected", _
fg.Rows.Selected.Count)
fg.SelectionMode = SelectionModeEnum.ListBox;
for (int index = fg.Rows.Fixed ; index < fg.Rows.Count; index++)
{
if ( Val(fg(index, "Sales")) > 80000) {
fg.Rows(index).Selected = true;
}
}
Console.WriteLine("There are now {0} rows selected",
fg.Rows.Selected.Count);

26 · Die C1FlexGrid-Steuerung verwenden
• Delphi
var
index: Integer;
begin
fg.SelectionMode := SelectionModeEnum.ListBox;
while (index 80000) then
fg.Rows(index).Selected := True;
Inc(index);
end;
Console.WriteLine('There are now {0} rows selected',
fg.Rows.Selected.Count);
end;
Datenbindungen
Datenbindung ist ein Prozess, der es mehreren Datennutzern ermöglicht, auf synchronisierte Weise an
eine Datenquelle gebunden zu sein. Wenn Sie den Cursor in einer datengebundenen Tabellensteuerung
bewegen, dann wird diese Bewegung in allen anderen, mit der Tabelle verbundenen Steuerungen
ebenfalls durchgeführt. Wenn Sie einen Zellwert in einer datengebundenen Tabellensteuerung
verändern, dann wird diese Veränderung auch in allen anderen, mit der Tabelle verbundenen
Steuerungen durchgeführt und der neue Wert angezeigt.
C1FlexGrid unterstützt Datenbindungen zu ADO.NET-Datenquellobjekten, wie zum Beispiel DataTable,
DataView, DataSet und DataViewManager.
C1FlexGrid unterstützt auch Datenbindungen zu ComponentOne-Datenobjektkomponenten, wie zum
Beispiel C1ExpressTable, C1ExpressVew, C1ExpressConnection, C1DataView, C1DataTableSource
und C1DataSet.
Um eine Tabellensteuerung an eine Datenquelle zu binden, müssen Sie das Datenquellobjekt in die
DataSource-Eigenschaft der Tabellensteuerung eintragen. Wenn das Datenquellobjekt mehr als eine
Tabelle beinhaltet, dann müssen Sie in der DataMember-Eigenschaft festlegen, welche Tabelle genutzt
werden soll.
Alternativ können Sie beide Eigenschaften gleichzeitig setzten, indem Sie die SetDataBinding-Methode
einmal aufrufen.
Wenn Sie eine neue Datenquelle einer Steuerung hinzufügen, dann wird diese automatisch ihre Spalten
aktualisieren, um sie dann an die Spalten der Datenquelle zu binden. Sie können die Spalten anpassen
indem Sie diese verschieben, verstecken oder löschen. Sie können auch die Spalteneigenschaften, wie
zum Beispiel Width, EditMask und Format, verändern.
Für ein Beispiel zur Neuordnung der Tabellenspalten nachdem eine Datenquelle verbunden wurde,
schauen Sie sich bitte das Beispiel „ColumnOrder“ in unserer online Beispielbibliothek an.
Für Details über das Erstellen von ADO.NET-Datenquellobjekten, schauen Sie bitte in der .NET
Framework-Dokumentation nach.
Für Details über ComponentOne-Datenobjekte, schauen Sie bitte in der C1DataObjects-Dokumentation
nach. Diese ist zu finden in der ComponentOne Studio für .NET-Dokumentation.

Daten speichern und laden
Daten speichern und laden · 27
Das C1FlexGrid kann im gebundenen und ungebundenen Modus verwendet werden. Im gebundenen
Modus ist die Tabellensteuerung mit einer Datenquelle verknüpft und alle in der Steuerung angezeigten
Daten stammen aus dieser Datenquelle. In diesem Modus werden die Daten, die mit der Steuerung
geändert werden, direkt in der zugrunde liegenden Datenquelle geändert. Im ungebundenen Modus
verwaltet die Tabellensteuerung ihre eigene Datenquelle.
Sowohl im gebundenen als auch im ungebundenen Modus sind die Row and Column-Zähler der
einfachste Weg, die Daten mit C1FlexGrid anzusprechen. Mit den Zählern können Sie eine Zelle in einer
Zeile oder einer Spalte auswählen und die Daten in dieser abrufen oder verändern. Zum Beispiel der
folgende Quellcode wählt die zweite Zelle in einer Zeile aus:
• Visual Basic
• C#
Row(2).Selected = True
Row[2].Selected = true;
• Delphi
Row[2].Selected := true;
Mit der Item-Eigenschaft können Sie ebenfalls die Daten in C1FlexGrid auswählen. Die Item-Eigenschaft
ist ein weiterer Zähler der Zeilen und Spalten indiziert und Zellwerte ausliest oder festlegt. Sie können
auch die Spaltennamen als Indizes verwenden. Zum Beispiel der folgende Quellcode speichert die
Zeilennummern in der ersten Tabellenspalte:
• Visual Basic
• C#
Dim r As Integer
For r = fg.Rows.Fixed To fg.Rows.Count – 1
fg(r, 0) = r
Next
int r;
for ( r = fg.Rows.Fixed ; r

28 · Die C1FlexGrid-Steuerung verwenden
Wenn Sie Daten mit den Zählern abrufen, dann wird die Tabellensteuerung den eigentlichen Wert der
Zelle wiedergeben. Um die formatierte Version der Daten, also das, was die Tabellensteuerung dem
Anwender anzeigt, zu erhalten, müssen Sie die GetDataDisplay-Methode verwenden.
Mit der Clip-Eigenschaft können Sie auch den Inhalt einer gesamten Auswahl abrufen. Diese Eigenschaft
ist besonders nützlich, wenn Sie die Zwischenablage oder Drag-und-drop-Operationen steuern wollen.
Standardmäßig gibt die Clip-Eigenschaft eine Zeichenkette, mit Tabulatorenzeichen (Chr(9)) zwischen
Zellen und Zeilenumbruchszeichen (Chr(13)) zwischen Zeilen, zurück. Um andere Trennzeichen zu
verwenden, müssen Sie die ClipSeparators-Eigenschaft anpassen.
Letztendlich können Sie die Inhalte eines willkürlichen Zellbereiches auch mit CellRange-Objekten
speichern und abrufen.
Zellbereich
Mit CellRange-Objekten können Sie an willkürlich ausgewählten Zellgruppen wie an einer einzelnen
Einheit arbeiten. Zum Beispiel der nachfolgende Quellcode erstellt ein CellRange-Objekt, löscht die
Daten in der Auswahl und legt ein benutzerdefiniertes Format fest:
• Visual Basic
• C#
Dim rg As CellRange = fg.GetCellRange(3, 3, 10, 10)
rg.Data = Nothing
rg.Style = fg.Styles("MyRangeStyle")
CellRange rg = fg.GetCellRange(3, 3, 10, 10);
rg.Data = null;
rg.Style = fg.Styles["MyRangeStyle"];
• Delphi
var
rg: CellRange;
begin
rg := fg.GetCellRange(3, 3, 10, 10);
rg.Data := nil;
rg.Style := fg.Styles['MyRangeStyle'];
end;
Die CellRange-Objekte haben eine StyleNew-Eigenschaft, die das Auswahlformat, wenn es existiert,
abfragt oder ein neues erstellt und dieses der Auswahl zuordnet und dann zurückgibt. Diese Eigenschaft
ist in Situationen hilfreich, in denen Sie keine richtige Kontrolle über die Formatierung benötigen. Zum
Beispiel dann, wenn Sie einem Zellbereich einen roten Hintergrund verpassen wollen:
• Visual Basic
• C#
Dim rg As CellRange = fg.GetCellRange(3, 3, 10, 10)
rg.StyleNew.BackColor = Color.Red
CellRange rg = fg.GetCellRange(3, 3, 10, 10);
rg.StyleNew.BackColor = Color.Red;
• Delphi
var
rg: CellRange;
begin
rg := fg.GetCellRange(3, 3, 10, 10);
rg.StyleNew.BackColor := Color.Red;

Zellbilder
end;
Zellbilder · 29
Jede Tabellenzelle kann neben ihren Daten auch ein Bild anzeigen. Dies kann auf zwei Wegen getan
werden:
1. Sie können einer Zelle ein Image-Objekt mit der SetCellImage-Methode zuordnen. Mit dieser
Methode können Sie willkürliche Bilder einer jeden Zelle anhängen, und sie ist nützlich, wenn
das Bild nicht mit den Daten in der Zelle in Verbindung steht. Zum Beispiel könnten Sie ein Bild
als Zellhintergrund verwenden, um zu signalisieren, dass die Daten in dieser Zelle ungültig sind.
2. Sie können ein ImageMap einer Spalte zuordnen und die Tabellensteuerung wird automatisch
die Zelldaten zu dem dazugehörigen Bild verknüpfen. Diese Methode ist in Situationen nützlich,
in denen das Bild die Zelldaten widerspiegelt. Zum Beispiel könnten die Bilder Symbole sein, die
Produkttypen darstellen.
Zellen formatieren
Eine der Stärken der C1FlexGrid-Steuerung ist die Möglichkeit, das Format der Tabelle und der
einzelnen Zellen bis ins kleinste Detail anzupassen.
Zellinhalt
Um das Format der Zellinhalte zu steuern, setzen Sie die Cols(index).Format-Eigenschaft auf eine
ähnliche Formatzeichenkette, wie Sie diese bei der String.Format-Method im .NET Framework
verwendet haben. Zum Beispiel der nachfolgende Quellcode zeigt ein kurzes Datum in der Spalte eins
und Währungen in der Spalte zwei:
• Visual Basic
• C#
fg.Cols(1).Format = "d" '

30 · Die C1FlexGrid-Steuerung verwenden
Zellformat
• C#
fg.Cols[1].Format = "d"; //

Zellen formatieren · 31
Sie können auch ihre eigenen Formatvorlagen erstellen und auf Zellen, Zeilen und Spalten anwenden.
Zum Beispiel der nachfolgende Quellcode erstellt eine benutzerdefinierte Zellformatvorlage und wendet
diese auf jede fünfte Zeile an:
• Visual Basic
• C#
Dim cs As CellStyle = fg.Styles.Add("Fifth")
cs.BackColor = Color.Gray
Dim idex%
For idex = fg.Rows.Fixed To fg.Rows.Count - 1 Schritt 5
fg.Rows(idex).Style = cs
Next
CellStyle cs = fg.Styles.Add("Fifth");
cs.BackColor = Color.Gray;
for (int index = fg.Rows.Fixed ; index

32 · Die C1FlexGrid-Steuerung verwenden
// assign new style to a row
_flex.Rows[3].Style = _flex.Styles["MyStyle"];
// assign new style to a cell range
CellRange rg = _flex.GetCellRange(4,4,6,6);
rg.Style = _flex.Styles["MyStyle"];
• Delphi
var
rg: CellRange;
s: CellStyle;
begin
s := _flex.Styles.Add('MyStyle');
s.BackColor := Color.Red;
s.ForeColor := Color.White;
_flex.Cols[3].Style := _flex.Styles['MyStyle'];
_flex.Rows[3].Style := _flex.Styles['MyStyle'];
rg := _flex.GetCellRange(4, 4, 6, 6);
rg.Style := _flex.Styles['MyStyle'];
end;
Sie können ihre Formatvorlagen auch während der Erstellungsphase erstellen, anstatt den Quellcode
hierfür zu schreiben. Wählen Sie einfach die Tabelle aus, gehen Sie in das Eigenschaftsfenster und klicken
Sie auf die Schaltfläche neben der Styles-Eigenschaft.
Die Tabellensteuerung wird das folgende style editor-Fenster anzeigen:
Mit dem Style-Editor können Sie bestehende Formatvorlagen verändern und eigene neue
Formatvorlagen, die später auf Zellen, Zeilen und Spalten angewendet werden können, erstellen.

Zellen formatieren · 33
Verwenden Sie die Add-Schaltfläche um eine benutzerdefinierte Formatvorlage hinzuzufügen.
Nachfolgend wird gezeigt, wie Ihre neue Vorlage im Vorschaufenster über den Formatierungsoptionen
erscheint.
Die Remove-Schaltfläche entfernt die ausgewählte Formatvorlage. Sie können die Vorlagen umbenennen,
indem Sie diese in der Liste auswählen und den neuen Namen eingeben. Die Clear-Schaltfläche entfernt
alle benutzerdefinierten Formatvorlagen und stellt die Einstellungen der vordefinierten Vorlagen wieder
her.
Die AutoFormat-Schaltfläche öffnet ein zweites Fenster, mit dem Sie einen neuen Satz vordefinierter
Formatvorlagen auswählen können. So sieht das AutoFormat-Fenster aus:

34 · Die C1FlexGrid-Steuerung verwenden
Bedingte Formatierung
Um Zellen nach ihrem Inhalt zu formatieren, können Sie das CellChanged-Ereignis verwenden. Zum
Beispiel der nachfolgende Quellcode erstellt eine neue Formatierung für große Währungswerte und
wendet diese auf Zellen mit bestimmten Inhalten an:
• Visual Basic
• C#
' create a custom style for large values
cs = fg.Styles.Add("LargeValue")
cs.Font = New Font(Font, FontStyle.Italic)
cs.BackColor = Color.Gold
' format cells based on their content
Private Sub fg_CellChanged(ByVal sender As Object,
ByVal e As RowColEventArgs) Handles fg.CellChanged
' mark currency values > 50,000 as LargeValues
' (reset others by setting their Style to Nothing)
Dim cs As CellStyle
If Val(fg(e.Row, e.Col)) >= 50000 Then
cs = fg.Styles("LargeValue")
End If
fg.SetCellStyle(e.Row, e.Col, cs)
End Sub
// create a custom style for large values
cs = fg.Styles.Add("LargeValue");
cs.Font = new Font(Font, FontStyle.Italic);
cs.BackColor = Color.Gold;
// format cells based on their content
private void fg_CellChanged( object sender, RowColEventArgs e) {
// mark currency values > 50,000 as LargeValues
// (reset others by setting their Style to null)
CellStyle cs;
if ( Val(fg(e.Row, e.Col)) >= 50000) {
cs = fg.Styles["LargeValue"];
}
fg.SetCellStyle(e.Row, e.Col, cs);
}
• Delphi
cs := fg.Styles.Add('LargeValue');
cs.Font := Font.Create(Font, FontStyle.Italic);
cs.BackColor := Color.Gold;
procedure fg_CellChanged(sender: System.Object; e: RowColEventArgs)
begin
// mark currency values > 50,000 as LargeValues
// (reset others by setting their Style to null)
if val(fg[e.Row, e.Col] >= 50000 then
cs := fg.Styles['LargeValue'];
fg.SetCellStyle(e.Row, e.Col, cs);
end;
Handgezeichnete Zellen
Obwohl die CellStyle-Objekte viele Formatierungsoptionen für Zellen abdecken, wie Hinter- und
Fordergrundfarben, Ausrichtung, Schriftart, Ränder, Rahmen usw., ist dies nicht genug. Vielleicht wollen
Sie einen Farbverlauf oder eine benutzerdefinierte Grafik als Hintergrund einsetzen. In diesen Fällen

können Sie die DrawMode-Eigenschaft und das OwnerDrawCell-Ereignis verwenden, um die
vollständige Kontrolle über den Aufbau der Zellen zu haben.
Zellen formatieren · 35
Die DrawMode-Eigenschaft legt fest, ob das OwnerDrawCell-Ereignis ausgeführt wird, oder nicht. Mit
diesem Ereignis können Sie jede Option der Zellformatierung überschreiben. Mit den Parametern des
OwnerDrawCell-Ereignisses können Sie nicht nur die angezeigten Daten und deren Formatierung
ändern, sondern Sie können auch die Zellen komplett neu zeichnen.
Die Parameter e.Text und e.Image im Ereignisablauf ändern den Text oder die Grafik, der/die in der
Zelle angezeigt wird. Mit der e.Style-Eigenschaft können Sie auch die verwendete Formatvorlage der
Zelle überschreiben.
Sie sollten allerdings nicht die Eigenschaften des Style-Parameters verändern, weil dies eventuell auch
andere Zellen betrifft. Ordnen Sie stattdessen ein neues CellStyle-Objekt dem Style-Parameter zu. Zum
Beispiel anstatt e.Style.ForeColor = Color.Red festzulegen, ordnen Sie dem Parameter ein neues Format
zu: e.Style = _flex.Styles["RedStyle"].
Sie können nicht nur Ihren eigenen Zeichencode verwenden, um die Zellen einzufärben, sondern auch
Ihren eigenen Code mit der e.DrawCell-Methode verbinden. Zum Beispiel können Sie Ihren
Zellhintergrund mit einem GDI-Aufruf erstellen und dann e.DrawCell aufrufen, um den Zellinhalt und
die Zellrahmen anzuzeigen.
Für ein Beispiel über fortgeschrittenen OwnerDraw-Quellcode, schauen Sie bitte im „RtfGrid“-Beispiel in
unserer online Beispielbibliothek nach.
Der nachfolgende Quellcode zeigt ein solches Beispiel. Es wird ein Farbverlauf für den Hintergrund der
ausgewählten Zelle angewendet. Zunächst wird die DrawMode-Eigenschaft gesetzt, das
LinearGradientBrush-Objekt deklariert und der Hintergrund immer dann angepasst, wenn die Größe
der Zelle verändert wird:
• Visual Basic
• C#
' use owner-draw to add gradients
fg.DrawMode = DrawModeEnum.OwnerDraw
' brush to use with owner-draw cells
Dim m_GradientBrush As LinearGradientBrush
Private Sub fg_Resize(ByVal sender As Object, ByVal e As
System.EventArgs) _
Handles fg.Resize
' update gradient brush when the control is resized
m_GradientBrush = New LinearGradientBrush(ClientRectangle, _
Color.SteelBlue, Color.White, 45)
End Sub
// use owner-draw to add gradients
fg.DrawMode = DrawModeEnum.OwnerDraw;
// brush to use with owner-draw cells
LinearGradientBrush m_GradientBrush;
private void fg_Resize( object sender, System.EventArgs e) fg.Resize
{
// update gradient brush when the control is resized
m_GradientBrush = new LinearGradientBrush(ClientRectangle,,
Color.SteelBlue, Color.White, 45);

36 · Die C1FlexGrid-Steuerung verwenden
}
• Delphi
// brush to use with owner-draw cells
m_GradientBrush: LinearGradientBrush;
// use owner-draw to add gradients
fg.DrawMode := DrawModeEnum.OwnerDraw;
procedure fg_Resize(sender: System.Object; e: System.EventArgs);
begin
m_GradientBrush := new LinearGradientBrush(ClientRectangle,
Color.SteelBlue, Color.White, 45);
end;
Im zweiten Schritt wird das OwnerDrawCell-Ereignis behandelt und der benutzerdefinierte Pinsel
verwendet, um den Zellhintergrund zu gestallten. In diesem Beispiel wird der Vordergrund von der
Tabellensteuerung mit der DrawCell-Methode im event-Argument festgelegt:
• Visual Basic
• C#
Private Sub fg_OwnerDrawCell(ByVal sender As Object, _
ByVal e As OwnerDrawCellEventArgs) Handles fg.OwnerDrawCell
' draw selected cell background using gradient brush
If fg.Selection.Contains(e.Row, e.Col) Then
e.Graphics.FillRectangle(m_GradientBrush, e.Bounds) ' draw
background
e.DrawCell(DrawCellFlags.Content) ' let the grid draw the
content
e.Handled = True ' we're done drawing this cell
End If
End Sub
private void fg_OwnerDrawCell( object sender, OwnerDrawCellEventArgs
e) fg.OwnerDrawCell {
// draw selected cell background using gradient brush
if (fg.Selection.Contains(e.Row, e.Col))
{
e.Graphics.FillRectangle(m_GradientBrush, e.Bounds); // draw
background
e.DrawCell(DrawCellFlags.Content); // let the grid draw the
content
e.Handled = true; // we're done drawing this cell
}
}
• Delphi
procedure fg_OwnerDrawCell(sender: System.Object; _
e: OwnerDrawCellEventArgs);
begin
// draw selected cell background using gradient brush
If fg.Selection.Contains(e.Row, e.Col) Then
begin
e.Graphics.FillRectangle(m_GradientBrush, e.Bounds); // draw
background
e.DrawCell(DrawCellFlags.Content); // let the grid draw the content
e.Handled := True // we're done drawing this cell
end;
end;

Zellen bearbeiten
Zellen bearbeiten · 37
Standardmäßig erlaubt die C1FlexGrid-Steuerung immer, dass Sie als Nutzer die Zellen verändern
können, indem Sie in diese hineinschreiben. Dies kann verhindert werden, indem Sie die AllowEditing-
Eigenschaft auf FALSE stellen. Es können auch nur bestimmte Spalten, die der Nutzer nicht verändern
soll, gesperrt werden, indem Sie die Cols(index).AllowEditing-Eigenschaft auf FALSE stellen. Wenn die
Tabellensteuerung an eine Datenquelle gebunden ist, dann wird automatisch bestimmt, welche Spalten
veränderbar sind und danach die AllowEditing-Eigenschaft eingestellt.
Um anzufangen, eine Zelle zu bearbeiten, kann der Nutzer:
1. Anfangen in die Zelle zu schreiben. Dies ersetzt den bisherigen Zellinhalt.
2. F2 oder Enter drücken. Dies versetzt die Tabellensteuerung in den Bearbeitungsmodus und
übergibt den bisherigen Zellinhalt dem Editor.
3. Doppelklick auf die Zelle. Dies hat dieselbe Wirkung wie F2 zu drücken, stellt aber den Cursor
neben das Zeichen, auf das geklickt wurde.
Im einfachen Bearbeitungsmodus kann der Nutzer Inhalte in die Zellen schreiben. Wenn die bearbeitete
Spalte einen bestimmten Datentyp besitzt, dann wir der vom Nutzer eingegebene Wert automatisch in
den entsprechenden Datentyp konvertiert. Wenn der vom Nutzer eingegebene Wert nicht konvertiert
werden kann, dann gibt die Tabellensteuerung den „GridError“ aus und übergeht den neuen Eintrag.
Der einfache Bearbeitungsmodus ist für die meisten Anwendungen ausreichend. Dennoch besitzt das
C1FlexGrid noch weitere Eigenschaften und Ereignisse, mit denen Sie den Bearbeitungsprozess steuern
können, und es stellt außerdem Auswahllisten, Befehlsschaltflächen und eine erweiterte
Gültigkeitskontrolle zur Verfügung.
Ab der Version 2.5 unterstützt C1FlexGrid auch externe Bearbeitungsprogramme. Somit können Sie jede
beliebige Tabellensteuerung für die Tabellenbearbeitung verwenden. Zum Beispiel können Sie nun die
C1Input-Steuerung als Tabelleneditor verwenden.
Diese Funktionen werden nachfolgend beschrieben.
Mit Listen- und Kombinationsfeldern arbeiten
Oft haben manche Zellen eine festgelegte Auswahl möglicher Werten. In diesen Fällen können Sie den
Nutzer einen Wert aus einem Auswahllistenfeld (drop-down list) wählen lassen. Dafür muss eine
Zeichenkette mit allen möglichen Werten, getrennt durch das Senkrechtstrichzeichen, z.B.
"Wahr|Falsch|Weis nicht", erstellen und diese der Cols(index).ComboList-Eigenschaft zugeordnet
werden. Jeder Spalte kann eine andere Liste zugeordnet werden. Wenn Sie die ComboList-Eigenschaft
festlegen, erstellt die Tabellensteuerung automatisch ein Auswahlfeld neben der Zelle. Der Nutzer kann
dieses Feld anklicken oder F2 drücken, um die Liste der möglichen Werte für die entsprechende Zelle
einzusehen.
In einer anderen, häufigen auftretenden Situation soll eine Zelle zwar eine Auswahl an verschiedenen
Werten besitzen, dennoch soll aber die Möglichkeit bestehen, einen nicht aufgeführten Wert
hinzuzufügen. Dies kann mit Auswahlkombinationsfeldern (drop-down combos), einer Kombination
aus Textfeld und Auswahlliste, erreicht werden. Um ein solches Kombinationsfeld zu erstellen, beginnen
Sie die Zeichenkette der Auswahlmöglichkeiten mit dem Senkrechtstrichzeichen, z.B.
"|Wahr|Falsch|Weis nicht", und ordnen Sie diese, wie zuvor der Cols(index).ComboList-Eigenschaft zu.
Zum Beispiel der nachfolgende Quellcode würde die Tabellensteuerung veranlassen, ein
Auswahllistenfeld mit verschiedenen Farben in Spalte eins und ein Auswahlkombinationsfeld in Spalte
zwei zu erstellen. Wenn eine Zelle aus Spalte eins bearbeitet werden soll, so muss der Nutzer einen Wert

38 · Die C1FlexGrid-Steuerung verwenden
aus der Liste wählen. Bearbeitet er hingegen Spalte zwei, so kann er neben der Auswahl auch einen
eigenen Wert in die Zelle schreiben:
• Visual Basic
• C#
fg.Cols(1).ComboList = "Red|Green|Blue|Red|White" ' drop-down list
fg.Cols(2).ComboList = "|Red|Green|Blue|Red|White" ' drop-down combo
fg.Cols[1].ComboList = "Red|Green|Blue|Red|White"; // drop-down list
fg.Cols[2].ComboList = "|Red|Green|Blue|Red|White"; // drop-down combo
• Delphi
fg.Cols[1].ComboList := 'Red|Green|Blue|Red|White';
fg.Cols[2].ComboList := '|Red|Green|Blue|Red|White';
Es ist auch möglich, dass verschiedene Zellen in einer Spalte verschiedene Listen benötigen. Zum Beispiel
stehe in einer Eigenschaftsliste in der ersten Spalte die Eigenschaft und in der zweiten Spalte die
dazugehörigen Werte. Wenn die Werte eigenschaftsspezifisch sind, so muss sich die Auswahlliste der
Werte an die entsprechende Eigenschaft in jeder Zeile anpassen. In diesem Fall sollten Sie das
BeforeEdit-Ereignis verwenden und die ComboList-Eigenschaft auf die entsprechende Liste für die
aktuelle Zelle setzen. Die ComboList-Eigenschaft wird auf die gesamte Tabelle angewendet.
Das integrierte Kombinationsfeld enthält standardmäßig eine automatische Suchfunktion. Wenn der
Nutzer anfängt, einen Wert zu schreiben, dann wird die Auswahl zu dem nächstpassenden Wert
springen. Diese Funktion können Sie mit der EditOptions-Eigenschaft deaktivieren und die Zeit, bis die
Tabelle den automatischen Suchpuffer löscht, mit der AutoSearchDelay-Eigenschaft steuern.
Das Kombinationsfeld enthält außerdem eine automatische Fortlauffunktion, wie die Editoren im Visual
Studio-Eigenschaftsfenster. Wenn man auf eine Zelle mit einer dazugehörigen Liste doppelt klickt, dann
wird die Tabellensteuerung automatisch den nächsten Wert auswählen. Diese Funktion können Sie
ebenfalls mit der EditOptions-Eigenschaft deaktivieren.
Kontrollkästchen
Standardmäßig zeigt die Tabellensteuerung Werte in Boolean-Spalten als Kontrollkästchen an. Der
Spaltentyp wird von der DataType-Eigenschaft des Column-Objekts festgelegt. Wenn Sie Boolean-Werte
nicht als Kontrollkästchen anzeigen lassen wollen, dann müssen Sie in die Format-Eigenschaft der Spalte
eine Zeichenkette mit den entsprechenden Wahr- und Falsch-Werten eintragen. Zum Beispiel:
• Visual Basic
• C#
fg.Cols("bools").Format = "Yes;No"
fg.Cols["bools"].Format = "Yes;No";
• Delphi
fg.Cols['bools'].Format := 'Yes;No';
Im ungebundenen Zustand können Sie die GetCellCheck- und SetCellCheck-Eigenschaften verwenden,
um Kontrollkästchen in Zellen einzufügen. Das Kontrollkästchen wird zusammen mit jedem beliebigen
Text in der Zelle angezeigt und Sie können deren Position mit der ImageAlign-Spalteneigenschaft
festlegen.
Es gibt zwei Kontrollkästchentypen: Boolean und Tri-State. Boolean-Kontrollkästchen schalten zwischen
den beiden Zuständen CheckEnum.Checked und CheckEnum.Unchecked um. Drei-Zustands-

Zellen bearbeiten · 39
Kontrollkästchen laufen durch die drei Zustände CheckEnum.TSChecked, CheckEnum.TSUnchecked
und CheckEnum.TSGrayed.
Wenn eine Zelle ein Kontrollkästchen besitzt und die AllowEditing-Eigenschaft auf TRUE steht, dann
kann der Nutzer dessen Zustand mit einem Mausklick oder mit der Leer- oder Entertaste ändern.
Standardmäßig werden alle in einer Auswahl befindlichen Kontrollkästchen umgeschaltet, wenn eins
dieser per Maus oder Tastatur umgeschaltet wird. Diese Funktion kann mit der EditOptions-Eigenschaft
deaktiviert werden.
Werteverknüpfte Listen
Die oben beschriebene ComboList-Eigenschaft stellt sicher, dass Zellwerte aus einer Liste ausgewählt
werden. Der vom Nutzer ausgewählte Wert wird in den entsprechenden Typ der Spalte konvertiert und
in der Tabelle so abgespeichert, wie als wenn der Nutzer diesen Wert eigenhändig eingegeben hätte.
In vielen Fällen könnten Zellen ihre Werte aus einer gut definierten Liste auswählen, Sie möchten
dennoch aber ein benutzerfreundliches Format der eigentlichen Werte anzeigen. Zum Beispiel, wenn eine
Spalte Produktnummern enthält, so sollen diese auch gespeichert, stattdessen aber der dazugehörige
Produktname angezeigt werden.
Dies wird mit der Cols(index).DataMap-Eigenschaft erreicht. Diese Eigenschaft enthält einen Verweis zu
einem IDictionary-Objekt, welches die Zuordnung zwischen dem, was gespeichert wird, und dem, was
dem Nutzer angezeigt wird, erstellt. Die IDictionary-Schnittstelle wird im System.Collections-
Namensbereich festgelegt und wird unter anderem durch Hashtable-Klassen implementiert.
Zum Beispiel der nachfolgende Quellcode erstellt eine Datenzuordnung zwischen Farbwerten und deren
Namen. Die Farben werden in der Tabelle gespeichert und deren Namen dem Nutzer angezeigt:
• Visual Basic
• C#
Dim dtMap As Hashtable = New Hashtable()
dtMap.Add(Color.Red, "Apple")
dtMap.Add(Color.Green, "Forest")
dtMap.Add(Color.Blue, "Sky")
dtMap.Add(Color.Black, "Coal")
dtMap.Add(Color.White, "Snow")
fg.Cols(1).DataType = GetType(Color)
fg.Cols(1).DataMap = dtMap
Hashtable Hashtable dtMap = new Hashtable();
dtMap.Add(Color.Red, "Apple");
dtMap.Add(Color.Green, "Forest");
dtMap.Add(Color.Blue, "Sky");
dtMap.Add(Color.Black, "Coal");
dtMap.Add(Color.White, "Snow");
fg.Cols[1].DataType = typeof(Color);
fg.Cols[1].DataMap = dtMap;
• Delphi
var
Hashtable: Hashtable;
begin
dtMap := Hashtable.Create;
dtMap.Add(Color.Red, 'Apple');
dtMap.Add(Color.Green, 'Forest');
dtMap.Add(Color.Blue, 'Sky');
dtMap.Add(Color.Black, 'Coal');

40 · Die C1FlexGrid-Steuerung verwenden
dtMap.Add(Color.White, 'Snow');
fg.Cols[1].DataType := TypeOf(Color);
fg.Cols[1].DataMap := dtMap;
end;
Jede Klasse, die das IDictionary implementiert, kann als DataMap verwendet werden. Zum Beispiel,
Hashtable, ListDictionary und SortedList. Alle diese Klassen stellen gültige Datenzuordnungen zur
Verfügung. Der Unterschied liegt allein in der klassenabhängigen Reihenfolge, in der die Werte in der
Auswahlliste angezeigt werden, wenn diese in bearbeitbaren Spalten angewendet werden.
Die SortedList-Klasse sortiert die Werte nach einem Schlüssel, Hashtable verwendet eine willkürliche
Reihenfolge und ListDictionary erhält die Reihenfolge, in der die Werte der Liste hinzugefügt wurden.
Daher ist ListDictionary meist die passendste Alternative für DataMaps.
Beachten Sie, dass die Schlüssel einer Datenzuordnung denselben Typ wie die zu bearbeitenden Zellen
besitzen müssen. Zum Beispiel wenn eine Spalte kurze Integer (Int16) enthält, dann müssen alle mit
dieser Spalte verknüpften Zuordnungen ebenfalls kurze Integer-Schlüssel besitzen. Übliche Integer
(Int32) würden als Schlüssel in diesem Fall nicht funktionieren.
Das folgende Beispiel zeigt diesen Unterschied:
• Visual Basic
private void Form1_Load(object sender, System.EventArgs e)
{
SortedList sl = new SortedList(); //

}
• Delphi
ld.Add(2, "Two");
ld.Add(3, "Three");
Hashtable ht = new Hashtable(); //

42 · Die C1FlexGrid-Steuerung verwenden
• C#
private enum Countries
{
NewYork;
Chicago;
NewOrleans;
London;
Paris;
};
fg.Cols(1).DataType = typeof(Countries);
• Delphi
Zellschaltflächen
type
Countries = (NewYork, Chicago, NewOrleans, London, Paris);
fg.Cols[1].DataType := TypeOf(Countries);
Manche Zellen benötigen eventuell kompliziertere Editoren im Vergleich zu einem Textfeld oder einer
Auswahlliste. Zum Beispiel wenn eine Spalte Dateinamen oder Farben beinhaltet, dann wird meist ein
Dialogfenster benötigt.
In diesen Fällen muss die ComboList-Eigenschaft auf Ellipsis („…“) gestellt werden. Die Steuerung wird
dann eine Schaltfläche neben der Zelle anzeigen und das CellButtonClick-Ereignis ausführen, wenn der
Nutzer auf diese klickt. Sie können das Ereignis abfangen, ein Dialogfenster anzeigen und den Zellinhalt
mit des Nutzers Auswahl abspeichern.
Wenn Sie das Senkrechtzeichen vor die Ellipsis stellen, dann kann der Nutzer den Zellinhalt durch
einfaches hineinschreiben verändern.
Standardmäßig wird die Zellschaltfläche mit der Ellipsis („…“) beschriftet. Mit der CellButtonImage-
Eigenschaft können Sie der Zellschaltfläche ein Bild zuordnen.
Das folgende Beispiel zeigt, wie Sie einen Kalender aufrufen, um ein Datum in einer Spalte
abzuspeichern. Das Beispiel geht davon aus, dass eine MonthCalendar-Steuerung mit dem Namen „cal“
auf Ihrem Formular vorhanden ist:
• Visual Basic
• C#
' set up date column
Dim c As Col = fg.Cols(1)
c.DataType = GetType(Color)
c.ComboList = "..." '

Zellen bearbeiten · 43
Dieser Quellcode erstellt eine Spalte, in welcher der Nutzer auf eine Schaltfläche klicken oder ein Datum
per Hand einfügen kann. Im nächsten Schritt wird ein Klick auf die besagte Schaltfläche abgewickelt:
• Visual Basic
• C#
Private Sub fg_CellButtonClick(ByVal sender As Object, _
ByVal e As RowColEventArgs) Handles fg.CellButtonClick
' create color picker dialog
Dim clrDlg As New ColorDialog()
' initialize the dialog
If fg(e.Row, e.Col) Is GetType(Color) Then
clrDlg.Color = fg(e.Row, e.Col)
End If
' get new color from dialog and assign it to the cell
If clrDlg.ShowDialog() = DialogResult.OK Then
fg(e.Row, e.Col) = clrDlg.Color
End If
End Sub
private void fg_CellButtonClick( object sender, RowColEventArgs e)
fg.CellButtonClick {
}
• Delphi
// create color picker dialog
ColorDialog clrDlg = new ColorDialog();
// initialize the dialog
if ( fg(e.Row, e.Col) Is typeof(Color))
{
clrDlg.Color = fg(e.Row, e.Col);
}
// get new color from dialog and assign it to the cell
if ( clrDlg.ShowDialog() = DialogResult.OK)
{
fg(e.Row, e.Col) = clrDlg.Color;
}
procedure fg_CellButtonClick(sender: System.Object; _
e: RowColEventArgs);
var
clrDlg: ColorDialog;
begin
// create color picker dialog
clrDlg := ColorDialog.Create;
// initialize the dialog
If fg[e.Row, e.Col] Is Color Then
clrDlg.Color := fg[e.Row, e.Col];
// get new color from dialog and assign it to the cell
If clrDlg.ShowDialog = System.Windows.Forms.DialogResult.OK Then
fg[e.Row, e.Col] := clrDlg.Color
end;

44 · Die C1FlexGrid-Steuerung verwenden
Masken
Die C1FlexGrid-Steuerung unterstützt auch Maskeneingaben. Diese Form der Bearbeitung verwendet
Eingabemasken um gewisse Vorlagen bereitzustellen und die Eingaben des Nutzers direkt automatisch
auf Gültigkeit zu prüfen. Die Maske wird durch die Col(index).EditMask-Eigenschaft festgelegt und kann
mit normalen Textfeldern und Auswahlkombinationsfeldern verwendet werden.
Die Zeichenketten von Eingabemasken besitzen zwei Zeichentypen: Wortzeichen, die ein Teil der
eigentlichen Eingabe darstellen, und Vorlagenzeichen, welche als Platzhalter für Zeichen, die zu einer
speziellen Kategorie gehören, dienen, z.B. Zahlen oder Buchstaben. Zum Beispiel der nachfolgende
Quellcode ordnet eine „(999) 999-9999“ Eingabemaske der Spalte eins zu, welche Telefonnummern
abspeichert. Die zahl „9“ ist ein Platzhalter, der für jede andere Zahl steht:
• Visual Basic
• C#
' set up phone number edit mask
fg.Cols(1).EditMask = "(999) 999-9999
// set up phone number edit mask
fg.Cols[1].EditMask = "(999) 999-9999;
• Delphi
fg.Cols(1).EditMask := '(999) 999-9999;';
Wenn Sie eine Zeichenkette in der EditMask-Eigenschaft eintragen, so wird automatisch der integrierte
Maskeneditor verwendet, auch wenn die Spalte Datums- oder Zeitwerte enthält. Gewöhnlich wird eine
DateTimePicker-Steuerung für solche Spalten verwendet. Dies ist besonders günstig, wenn es um
DateTime-Spalten geht, die nur Uhrzeiten enthalten, aber kein Datum. In diesen Fällen können Sie die
folgenden Eigenschaften setzen, um einen Maskeneditor anstatt der DateTimePicker-Steuerung zu
verwenden:
• Visual Basic
• C#
fg.Cols(1).DataType = GetType(DateTime) '
fg.Cols(1).Format = "hh:mm tt" '
fg.Cols(1).EditMask = "99:99 LL" '
fg.Cols[1].DataType=typeof(DateTime);
fg.Cols[1].Format="hh:mm tt";
fg.Cols[1].EditMask="99:99 LL";
• Delphi
fg.Cols[1].DataType := TypeOf(DateTime);
fg.Cols[1].Format := 'hh:mm tt';
fg.Cols[1].EditMask := '99:99 LL';
Für weitere Details zum Aufbau der Zeichenketten für Masken, schauen Sie bitte unter der EditMask-
Eigenschaft im Abschnitt „Steuerungsverweise“ nach.
Wenn verschiedene Zellen in derselben Spalte verschiedene Masken benötigen, müssen Sie das
BeforeEdit-Ereignis verwenden um die EditMask-Eigenschaft auf den entsprechenden Wert für die
aktuelle Zelle zu setzen.

Gültigkeit
Zellen bearbeiten · 45
In vielen Fällen sind Eingabemasken allein nicht genug um sicherzustellen, dass die vom Nutzer
eingegebenen Daten gültig sind. Zum Beispiel können Sie mit einer Maske nicht eine Spanne möglicher
Werte angeben oder die Daten der aktuellen Zelle aufgrund von Daten einer anderen Zelle bestätigen.
In diesen Fällen muss das ValidateEdit-Ereignis verwendet werden, um den Wert der Editor.Text-
Eigenschaft auf Gültigkeit für die aktuelle Zelle zu prüfen. An diesem Punkt besitzt die Zelle immer noch
ihren anfänglichen Wert. Wenn die Eingabe ungültig ist, muss der Cancel-Parameter auf TRUE gestellt
werden und die Steuerung verbleibt im Eingabemodus bis der Nutzer eine gültige Eingabe vornimmt.
Zum Beispiel der nachfolgende Quellcode prüft die Eingabe in einer Währungsspalte um sicherzustellen,
dass die eingegebenen Werte zwischen 1.000 und 10.000 liegen:
• Visual Basic
• C#
Private Sub fg_ValidateEdit(ByVal sender As Object, _
ByVal e As ValidateEditEventArgs) Handles fg.ValidateEdit
' validate amounts
If fg.Cols(e.Col).DataType Is GetType(Decimal) Then
10,000")
Try
End If
End Sub
Dim dec As Decimal = Decimal.Parse(fg.Editor.Text())
If dec < 1000 Or dec > 10000 Then
MessageBox.Show("Value must be between 1,000 and
e.Cancel = True
End If
Catch
MessageBox.Show("Value not recognized as a Currency")
e.Cancel = True
End Try
private void fg_ValidateEdit( object sender, ValidateEditEventArgs e)
{
{
// validate amounts
if (fg.Cols[e.Col].DataType is (Decimal))
try {
Decimal dec = Decimal.Parse(fg.Editor.Text);
if ( dec < 1000 || dec > 10000) {
MessageBox.Show("value must be between 1,000 and
10,000");
e.Cancel = true;
}
} catch{
MessageBox.Show("value not recognized as a Currency");
e.Cancel = true;
}
}
}

46 · Die C1FlexGrid-Steuerung verwenden
• Delphi
Private Sub fg_ValidateEdit(sender: System.Object; _
e: ValidateEditEventArgs);
var
dec: Decimal;
begin
// validate amounts
If fg.Cols(e.Col).DataType Is Decimal Then
Try
dec := Decimal.Parse(fg.Editor.Text())
If (dec < 1000) Or (dec > 10000) Then
begin
MessageBox.Show('Value must be between 1,000 and 10,000');
e.Cancel := True;
end;
except
MessageBox.Show('Value not recognized as a Currency');
e.Cancel := True
end;
end;
Benutzerdefinierte Editoren verwenden
Obwohl die integrierten Editoren sehr flexible und stark sind, möchten Sie vielleicht dennoch in einigen
Fällen externe Steuerungen als spezialisierte Editoren verwenden. Zum Beispiel können Sie die
C1NumericInput-Steuerung, die einen Drop-Down-Rechner für die Nummerneingabe bereit hält, einen
Editor für das Auswählen von Listen über mehrere Spalten hinweg, oder eine spezialisierte Steuerung,
die Sie für Ihre Bedürfnisse erstellt haben, verwenden.
Jede Steuerung, die von der Control-Basisklasse abgeleitet wird, kann als grundlegender Tabelleneditor
verwendet werden. Steuerungen, die die IC1EmbeddedEditor-Schnittstelle implementieren (in
C1Common.dll definiert), können zudem eine bessere Integration mit der Tabellensteuerung und
zusätzliche erweiterte Funktionen bieten. Für weitere Details über IC1EmbeddedEditor-Schnittstellen,
schauen Sie unter der Editor-Eigenschaft nach.
Um eine Steuerung als benutzerdefinierten Editor zu verwenden, müssen Sie eine Instanz der Steuerung
mit der Tabellenspalte oder einer Formatvorlage über deren Editor-Eigenschaft verknüpfen. Sie können
dies in der Erstellungsphase mit dem Spalteneditor oder während der Runtime tun. Danach wird die
entsprechende Steuerung automatisch von der Tabelle genutzt.
Um benutzerdefinierte Editoren während der Erstellungsphase festzulegen, müssen Sie eine Instanz der
Editorsteuerung dem Formular hinzufügen, dann die Tabelle rechtsklicken und „Edit Columns…“
auswählen. Wählen Sie die Spalten aus, die den benutzerdefinierten Editor verwenden sollen, und tragen
Sie den Namen der neuen Editorsteuerung in die Editor-Eigenschaften ein.
Folgen Sie den nachstehenden Schritten, um zum Beispiel die NumericUpDown-Steuerung als
Tabelleneditor zu verwenden:
1. Fügen Sie die C1FlexGrid-Steuerung dem Formular hinzu.
2. Fügen Sie eine NumericUpDown-Steuerung dem Formular hinzu und stellen Sie deren
BorderStyle-Eigenschaft auf „None“.
3. Rechtsklicken Sie die Tabellensteuerung und wählen Sie die Option „Edit Columns…“ aus.
4. Wählen Sie die erste, scrollbare Tabellenspalte im Spalteneditor aus, und stellen Sie die Editor-
Eigenschaft auf „numericUpDown1“.

Zellen bearbeiten · 47
Starten Sie das Projekt und schreiben Sie einige Werte in die erste Spalte. Beachten Sie, wie sich die
Tabelle positioniert und die NumericUpDown-Steuerung für die Zellbearbeitung initialisiert wird. Wenn
Sie mit der Bearbeitung einer Zelle fertig sind, dann klicken Sie auf eine andere Zelle oder drücken Sie die
Tabulatortaste um zur nächsten Zelle zu gelangen. Der neue Wert wird in der Zelle abgespeichert.
Sie können benutzerdefinierte Editoren auch während der Runtime mit Quellcode hinzufügen:
• Visual Basic
• C#
Private Sub Form_Load(EventArgs e)
End Sub
' create custom editor
Dim editor as New NuumericUpDown()
editor.BorderStyle = BorderStyle.None
' assign custom editor to the grid
fg.Cols(1).Editor = editor
private void Form_Load(EventArgs e)
{
// create custom editor
NumericUpDown editor = new NumericUpDown();
editor.BorderStyle = BorderStyle.None;
}
• Delphi
// assign custom editor to the grid
fg.Cols[1].Editor = editor;
procedure TWinForm.Form_Load(object sender; e: System.EventArgs);
var editor: NumericUpDown;
begin
// create custom editor
editor := NumericUpDown.Create;
editor.BorderStyle := BorderStyle.None;
// assign custom editor to the grid
fg.Cols[1].Editor := editor;
end;
Benutzerdefinierte Editoren erstellen
Jede Steuerung, die von der Control-Basisklasse abgeleitet wird, kann als Tabelleneditor verwendet
werden. Dies ist möglich, weil die Tabellensteuerung ausreichend Informationen über die Basisklasse
besitzt und daher auf Eigenschaften wie Text und Bounds und Ereignisse wie Leave und TextChanged
zugreifen kann. In vielen Fällen ist dieses Unterstützungsniveau ausreichend.
Manchmal ist es vielleicht nötig, dass Sie Steuerungen verwenden, die nicht vollständig auf der
Basisklasse beruhen. Zum Beispiel eine DateTimePicker-Steuerung besitzt eine Value-Eigenschaft, die
anstelle von Text für das Zurückholen von geänderten Werten verwendet werden sollte. In solchen
Fällen können Sie eine oder mehrere Methoden in die IC1EmbeddedEditor-Schnittstelle implementieren,
um das Standardverhalten zu überschreiben. Alle Steuerungen der C1Input-Bibliothek unterstützen
allerdings den IC1EmbeddedEditor und integrieren sich daher gut in die C1FlexGrid und
C1TrueDBGrid.

48 · Die C1FlexGrid-Steuerung verwenden
Die IC1EmbeddedEditor-Schnittstelle ist recht einfach gestrickt und weil die Tabellensteuerung an diese
über „late binding“ gebunden ist, müssen deren Mitglieder nicht einmal implementiert werden.
Implementieren Sie nur diejenigen, die für Ihre Editorsteuerung Sinn ergeben.
Die Schnittstelle ist derart flexibel, dass Sie so gut wie jede Steuerung als Tabelleneditor verwenden
können. Sie können sogar die UITypeEditor-Klassen als Tabelleneditor verwenden. Um dies zu tun,
benötigen Sie eine Wrapper-Klasse die von der Control abgeleitet wird (UITypeEditor tut dies nicht), die
die IC1EmbeddedEditor-Schnittstelle implementiert und den passenden UITypeEditor verkapselt. Wir
stellen den Quellcode für diese Wrapper-Klasse im „CustomEditors“-Beispiel zur Verfügung.
Wenn Sie die UITypeEditor-Wrapper-Klasse verwenden, können Sie jeden beliebigen UITypeEditor mit
C1FlexGrid einsetzen. .NET stellt einige UITypeEditoren für u.a. Farbanpassungen, Schriftarten und
Dateinamen zur Verfügung. Sie können auch Ihren eigenen UITypeEditor schreiben. Dies ist manchmal
einfacher als eine Steuerung zu erstellen.
Für Beispiele zur Verwendung von integrierten, benutzerdefinierten und UITypeEditor-Editoren mit
C1FlexGrid, schauen Sie bitte im „CustomEditors“-Beispiel in unserer online Beispielbibliothek nach.
Den Bearbeitungsmodus steuern
Um festzustellen, ob sich die Tabelle im Bearbeitungsmodus befindet, müssen Sie die Werte der Editor-
Eigenschaft auslesen. Wenn diese Eigenschaft „null“ zurückgibt, dann befindet sich die Tabelle nicht im
Bearbeitungsmodus. Andernfalls gibt die Eigenschaft einen Verweis auf die entsprechende Steuerung
zurück, die gerade verwendet wird, um die aktuelle Zelle zu bearbeiten. Diese Steuerung kann ein
Textfeld, ein Kombinationsfeld oder ein anderer Steuerungstyp sein.
Sie können die Tabelle programmatisch mit der StartEditing-Methode in den Bearbeitungsmodus
versetzen und diesen mit der FinishEditing-Methode wieder beenden.
Indem Sie die Bearbeitungsereignisse, die von der Tabelle gestartet werden, abfangen und verarbeiten,
können Sie den gesamten Bearbeitungsprozess noch stärker steuern. Während des Bearbeitungsprozesses
einer Zelle startet die Tabelle die folgende Abfolge an Ereignissen:
BeforeEdit-Ereignis (Seite 236)
Dieses Ereignis wird immer dann gestartet, wenn eine bearbeitbare Zelle ausgewählt wird. Sie können an
dieser Stelle die Bearbeitung dieser Zelle verhindern, indem Sie den Ereignisparameter Cancel auf TRUE
stellen. Sie können auch die ComboList-Eigenschaft verändern, so dass die passende
Auswahllistenschaltfläche in dieser Zelle angezeigt wird.
Beachten Sie aber, dass der Nutzer nicht zwingend diese Zelle auch bearbeiten will. Es kann sein, dass er
die Auswahl einfach auf einen andere Zelle oder Steuerung verschiebt.
StartEdit-Ereignis (Seite 274)
Dieses Ereignis ist ähnlich wie BeforeEdit, nur dass der Nutzer in diesem Fall bereits eine Taste gedrückt
oder auf die Auswahlschaltfläche der Zelle geklickt hat und wirklich die Zelle verändern will. Sie können
die Bearbeitung immer noch stoppen.
Die Editor-Eigenschaft ist an dieser Stelle immer noch „null“, weil die Steuerung noch nicht festgelegt
hat, welcher Editortyp verwendet werden sollte. Sie können daher auch noch einen benutzerdefinierten
Editor der Editor-Eigenschaft zuordnen.
SetupEditor-Ereignis (Seite 271)
Dieses Ereignis wird gestartet, wenn die Editorsteuerung erstellt und konfiguriert wurde, um die Zelle zu
bearbeiten, aber noch bevor dies sichtbar ist. An dieser Stelle können Sie die Editoreneinstellungen

Zusammenfassen und Gliedern · 49
verändern. Zum Beispiel die maximale Länge oder die zu verwendenden Passwortzeichen in einem
TextBox-Editor. Sie können auch Ihre eigene Ereignisverarbeitung dem Editor anhängen.
ValidateEdit-Ereignis (Seite 275)
Dieses Ereignis wird gestartet, wenn der Nutzer mit der Bearbeitung fertig ist und bevor der Editorwert
zurück in die Tabellenzelle kopiert wird. Sie können den ursprünglichen Wert prüfen, indem Sie diesen
aus der Tabelle auslesen. Das Ereignis stellt die Koordinaten der Zelle zur Verfügung. Den neuen Wert,
der der Tabelle hinzugefügt werden soll, können Sie mit den Editor-Eigenschaften, z.B. Editor.Text,
prüfen. Wenn der neue Wert für die entsprechende Zelle ungültig ist, dann muss nur der Cancel-
Parameter auf TRUE gestellt werden, und die Tabelle bleibt im Bearbeitungsmodus.
Wenn Sie stattdessen den Bearbeitungsmodus beenden und den ursprünglichen Wert wiederherstellen
wollen, so müssen Sie Cancel auf TRUE stellen und dann die FinishEditing-Methode aufrufen.
AfterEdit-Ereignis (Seite 222)
Dieses Ereignis wird gestartet, nachdem der neue Wert der Zelle zugewiesen und der Editor deaktiviert
wurde. Sie können dieses Ereignis verwenden, um alles, was auf den Wert dieser Zelle beruht, zu
aktualisieren (z.B. Zwischensummen oder Sortierung).
Zusammenfassen und Gliedern
Die FlexGrid-Steuerung besitzt Methoden und Eigenschaften, mit denen Sie Daten zusammenfassen oder
in hierarchischer Form anzeigen können. Um Daten zusammenzufassen und Zwischensummen
hinzuzufügen, müssen Sie die Subtotal-Methode verwenden. Für hierarchische Datenansichten ist die
Tree-Eigenschaft zuständig.
Zwischensummen erstellen
Die Subtotal-Methode fügt eine Zwischensummenzeile mit aggregierten Werten der normalen Zeilen,
aber keine Summen ein.
Subtotal unterstützt hierarchische Summen. Zum Beispiel wenn Ihre Tabelle Umsatzzahlen beinhaltet,
dann können Sie Subtotal dazu verwenden, um zusammengefasste Summen nach Produkten, Regionen
und Verkäufern zu erstellen. Der nachfolgende Quellcode illustriert dies:
• Visual Basic
Private Sub ShowTotals()
' show OutlineBar on column 0
fg.Tree.Column = 0
fg.Tree.Style = TreeStyleFlags.Simple
' clear existing subtotals
fg.Subtotal(AggregateEnum.Clear)
' get a Grand total (use -1 instead of column index)
fg.Subtotal(AggregateEnum.Sum, -1, -1, 3, "Grand Total")
' total per Product (column 0)
fg.Subtotal(AggregateEnum.Sum, 0, 0, 3, "Total {0}")
' total per Region (column 1)
fg.Subtotal(AggregateEnum.Sum, 1, 1, 3, "Total {0}")
' size column widths based on content
fg.AutoSizeCols()

50 · Die C1FlexGrid-Steuerung verwenden
• C#
End Sub
private void ShowTotals() {
}
• Delphi
// show OutlineBar on column 0
fg.Tree.Column = 0;
fg.Tree.Style = TreeStyleFlags.Simple;
// clear existing subtotals
fg.Subtotal(AggregateEnum.Clear);
// get a Grand total (use -1 instead of column index)
fg.Subtotal(AggregateEnum.Sum, -1, -1, 3, "Grand Total");
// total per Product (column 0)
fg.Subtotal(AggregateEnum.Sum, 0, 0, 3, "Total {0}");
// total per Region (column 1)
fg.Subtotal(AggregateEnum.Sum, 1, 1, 3, "Total {0}");
// size column widths based on content
fg.AutoSizeCols();
procedure ShowTotals()
begin
// show OutlineBar on column 0
fg.Tree.Column := 0;
fg.Tree.Style := TreeStyleFlags.Simple;
// clear existing subtotals
fg.Subtotal(AggregateEnum.Clear);
// get a Grand total (use -1 instead of column index)
fg.Subtotal(AggregateEnum.Sum, -1, -1, 3, 'Grand Total');
// total per Product (column 0)
fg.Subtotal(AggregateEnum.Sum, 0, 0, 3, 'Total {0}');
// total per Region (column 1)
fg.Subtotal(AggregateEnum.Sum, 1, 1, 3, 'Total {0}');
// size column widths based on content
fg.AutoSizeCols;
end;
Wenn die Subtotal-Methode Zeilen mit zusammengefassten Informationen hinzufügt, dann wird
automatisch das subtotal-Format auf diese neuen Zeilen angewendet. Es gibt fünf Standardformate für
fünf verschiedene Zwischensummenniveaus. Sie können die Formate der Zwischensummenzeilen
verändern, indem Sie die Eigenschaften der Gliederungsformate während der Designtime mit dem Style-
Editor oder während der Runtime mit Quellcode bearbeiten. Zum Beispiel:
• Visual Basic
' set styles for subtotals
Dim cs As CellStyle
cs = fg.Styles(CellStyleEnum.GrandTotal)
cs.BackColor = Color.Black
cs.ForeColor = Color.White
cs.Font = New Font(Font, FontStyle.Bold)
cs = fg.Styles(CellStyleEnum.Subtotal0)
cs.BackColor = Color.DarkRed
cs.ForeColor = Color.White

• C#
cs.Font = New Font(Font, FontStyle.Bold)
cs = fg.Styles(CellStyleEnum.Subtotal1)
cs.BackColor = Color.DarkBlue
cs.ForeColor = Color.White
// set styles for subtotals
CellStyle cs;
cs = fg.Styles[CellStyleEnum.GrandTotal];
cs.BackColor = Color.Black;
cs.ForeColor = Color.White;
cs.Font = new Font(Font, FontStyle.Bold);
cs = fg.Styles[CellStyleEnum.Subtotal0];
cs.BackColor = Color.DarkRed;
cs.ForeColor = Color.White;
cs.Font = new Font(Font, FontStyle.Bold);
cs = fg.Styles[CellStyleEnum.Subtotal1];
cs.BackColor = Color.DarkBlue;
cs.ForeColor = Color.White;
• Delphi
cs := fg.Styles[CellStyleEnum.GrandTotal);
cs.BackColor := Color.Black;
cs.ForeColor := Color.White;
cs.Font := Font.Create(Font, FontStyle.Bold);
cs := fg.Styles[CellStyleEnum.Subtotal0];
cs.BackColor := Color.DarkRed;
cs.ForeColor := Color.White;
cs.Font := Font.Create(Font, FontStyle.Bold);
cs := fg.Styles[CellStyleEnum.Subtotal1];
cs.BackColor := Color.DarkBlue;
cs.ForeColor := Color.White;
Nachdem dieser Quellcode ausgeführt wurde, sollte die Tabelle wie folgt aussehen:
Zusammenfassen und Gliedern · 51

52 · Die C1FlexGrid-Steuerung verwenden
Die Gesamtsummenzeile enthält den gesamten Umsatz für alle Produkte, Regionen und Verkäufer. Sie
wurde mit einer „–1“ für den groupOn-Parameter im Aufruf der Subtotal-Methode erstellt. Die anderen
Zwischensummen zeigen die Umsätze nach Produkten und Regionen. Diese wurden mit den Werten 0
und 1 für den groupOn-Parameter erstellt.
Sie können neben Summen auch noch weitere Aggregationen vornehmen, z.B. Durchschnitte oder
Prozente, und somit verschiedene Zusammenfassungen für jede Zeile vornehmen, z.B. Brutto- und
Nettoumsatz.
Zwischensummenzeilen, die von der Subtotal-Methode erstellt wurden, unterscheiden sich von
normalen Zeilen in drei Aspekten:
1) Zwischensummenzeilen können automatisch mit einem Aufruf der Subtotal-Methode mit dem
flexSTClear-Parameter entfernt werden. Damit wird eine dynamische Ansicht der Daten erstellt,
so dass der Nutzer Spalten verschieben oder Daten neu sortieren kann, und anschließend die
Summen neu berechnet werden.
2) Zwischensummenzeilen dienen als Knotenpunkt in einer Gliederung und können Zeilengruppen
ein- und ausblenden, um eine Übersichtsansicht zu erstellen oder Details zu zeigen. Um die
Gliederung zu sehen, müssen Sie die Tree.Column- und die Tree.Style-Eigenschaften setzen, um
die Position und das Format der Gliederung festzulegen.
3) Zwischensummenzeilen können als Knoten in Bäumen verwendet werden. Sie können das
Node-Objekt für jede Zwischensummenzeilen mit der Rows(index).Node-Eigenschaft abrufen.
4) Wenn die Tabelle an eine Datenquelle gebunden ist, dann entsprechen Zwischensummenzeilen
nicht den eigentlichen Daten. Wenn Sie den Cursor in der Datenquelle bewegen, dann werden
die Zwischensummenzeilen in der Tabelle ausgelassen.
Mit der Gliederung kann der Nutzer Teile der Tabelle ein- und ausblenden, indem er auf die
Knotenpunkte klickt. Sie können diese Gliederungen auch dafür verwenden, verschiedene

Zusammenfassen und Gliedern · 53
Informationstypen und nicht nur Zusammenfassungen anzuzeigen. Das nächste Beispiel zeigt, wie Sie
eine benutzerdefinierte Gliederung für die Anzeige von Verzeichnisinformationen erstellen können.
Benutzerdefinierte Gliederungsbäume erstellen
Um Gliederungen ohne die Subtotal-Methode zu erstellen, müssen Sie den folgenden 3 Schritten folgen:
1) Fügen Sie Zeilen in die Tabelle ein.
2) Ändern Sie einige Zeilen zu Gliederungsknoten, indem Sie deren Row(index).IsNode-Eigenschaft
auf TRUE stellen.
3) Rufen Sie das Node-Objekt für jede Knotenzeile ab und setzen Sie dessen Level-Eigenschaft, um
das Niveau und die Position in der Baumhierarchie festzulegen. Höhere Werte bedeuten, dass
der Knoten sich auf tieferen Ebenen in der Gliederung befinden wird.
Zum Beispiel, der nachfolgende Quellcode erstellt einen Verzeichnisbaum:
• Visual Basic
• C#
Private Sub Form1_Load(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles MyBase.Load
' initialize grid layout
fg.Cols.Fixed = 0
fg.Cols.Count = 1
fg.Rows.Count = 1
fg.ExtendLastCol = True
fg.Styles.Normal.TextAlign = TextAlignEnum.LeftCenter
fg.Styles.Normal.Border.Style = BorderStyleEnum.None
' initialize outline tree
fg.Tree.Column = 0
fg.Tree.Style = TreeStyleFlags.SimpleLeaf
' populate the grid
AddDirectory("c:\", 0)
End Sub
private void Form1_Load( System.object sender, System.EventArgs e)
base.Load {
// initialize grid layout
fg.Cols.Fixed = 0;
fg.Cols.Count = 1;
fg.Rows.Count = 1;
fg.ExtendLastCol = true;
fg.Styles.Normal.TextAlign = TextAlignEnum.LeftCenter;
fg.Styles.Normal.Border.Style = BorderStyleEnum.None;
// initialize outline tree
fg.Tree.Column = 0;
fg.Tree.Style = TreeStyleFlags.SimpleLeaf;
// populate the grid
AddDirectory("c:\", 0);
}

54 · Die C1FlexGrid-Steuerung verwenden
• Delphi
procedure Form1_Load(sender: System.Object; _
e: System.EventArgs);
begin
// initialize grid layout
fg.Cols.Fixed := 0;
fg.Cols.Count := 1;
fg.Rows.Count := 1;
fg.ExtendLastCol := True;
fg.Styles.Normal.TextAlign := TextAlignEnum.LeftCenter;
fg.Styles.Normal.Border.Style := BorderStyleEnum.None;
// initialize outline tree
fg.Tree.Column := 0;
fg.Tree.Style := TreeStyleFlags.SimpleLeaf;
// populate the grid
AddDirectory("c:\", 0)
end;
Der obenstehende Quelltext initialisiert das Tabellenformat und ruft die AddDirectory-Routine auf, die
die Tabelle erstellt und die Gliederungsstruktur einrichtet:
• Visual Basic
Private Sub AddDirectory(ByVal dir As String, ByVal level As Integer)
' add this directory
Dim thisDir As String
thisDir = Path.GetFileName(dir)
If thisDir.Length = 0 Then thisDir = dir
fg.AddItem(thisDir.ToUpper())
End Sub
' make this new row a node
Dim row As Row = fg.Rows(fg.Rows.Count - 1)
row.IsNode = True
' set node level
Dim nd As Node = row.Node
nd.Level = level
' add files in this directory
Dim file As String, cnt As Integer
cnt = 0
For Each file In Directory.GetFiles(dir)
fg.AddItem(Path.GetFileName(file).ToLower())
cnt = cnt + 1
If cnt > 10 Then Exit For
Next
' add subdirectories (up to level 4)
If level 10 Then Exit For
Next
End If

• C#
private void AddDirectory( string dir, int level) {
// add this directory
string thisDir = Path.GetFileName(dir);
if ( thisDir.Length == 0) thisDir = dir;
fg.AddItem(thisDir.ToUpper());
• Delphi
// make this new row a node
Row row = fg.Rows[fg.Rows.Count – 1];
row.IsNode = true;
// set node level
Node nd = row.Node;
nd.Level = level;
// add files in this directory
int cnt = 0;
foreach (string file In Directory.GetFiles(dir)
{
fg.AddItem(Path.GetFileName(file).ToLower());
cnt = cnt + 1;
if ( cnt > 10) break; }
procedure AddDirectory(dir: String; level: Integer);
var
thisDir: string;
r: Row;
nd: Node;
file: string;
cnt: Integer;
files: array of string;
subdir: string;
begin
// add this directory
thisDir := Path.GetFileName(dir);
If thisDir.Length = 0 Then thisDir := dir;
fg.AddItem(thisDir.ToUpper());
// make this new row a node
r := fg.Rows(fg.Rows.Count - 1);
r.IsNode := True;
// set node level
nd := r.Node;
nd.Level := level;
// add files in this directory
cnt := 0;
files := Directory.GetFiles(dir);
for I := 0 to High(Files) do
begin
fg.AddItem(Path.GetFileName(files[I].ToLower());
cnt := cnt + 1;
if cnt > 10 then
break;
end;
// add subdirectories (up to level 4)
If level

56 · Die C1FlexGrid-Steuerung verwenden
for I := 0 to High(files) do
begin
AddDirectory(subdir, level + 1);
cnt := cnt + 1;
if cnt > 10 then
break;
end;
end;
end;
AddDirectory ist eine rekursive Routine, die das aktuelle Verzeichnis und dessen Unterverzeichnisse
durchquert. In diesem Beispiel ist die Gliederungstiefe auf vier Ebenen beschränkt, um Zeit zu sparen. In
einer richtigen Anwendung sollte die Routine so geändert werden, dass Sie diese Gliederungsebenen nur
dann erstellt, wenn Sie aufgerufen, bzw. die Gliederung erweitert wird. Schauen Sie in den FlexGrid-
Anweisungen nach (Seite 78).
Der Quelltext erstellt eine Tabelle, die wie folgt aussieht:
Zellen verbinden
Mit der C1FlexGrid-Steuerung können Sie Zellen verbinden, so dass sich diese über mehrere Spalten
oder Zeile erstrecken. Diese Funktion kann dafür verwendet werden, die Daten der Tabelle deutlicher
und klarer anzuzeigen. Der Effekt dieser Funktion ähnelt dem des HTML „“- und
„“-Befehles.
Um Zellverbindungen zu aktivieren, müssen Sie zwei Dinge tun:
1. Setzen Sie die AllowMerging-Eigenschaft der Tabelle auf einen von Null verschiedenen Wert.
Das Ergebnis der verschiedenen Einstellungen wird im Referenzabschnitt erläutert.
2. Wenn Sie Spalten verbinden wollen, müssen Sie die Cols(index).AllowMerging-Eigenschaft von
jeder betroffenen Spalte auf TRUE stellen. Wollen Sie hingegen Zeilen verbinden, so müssen Sie
die Rows(index).AllowMerging-Eigenschaft von jeder betroffenen Zeile auf TRUE stellen.

Zellen verbinden · 57
Die Zellen werden verbunden, wenn die jeweils angrenzenden Zellen die gleiche nicht-leere Zeichenkette
besitzt. Es gibt keine Methode mit der Sie Zellenverbindungen erzwingen können. Die Verbindungen
werden automatisch aufgrund der Zellinhalte erstellt. Damit ist es leichter, aggregierte Ansichten für
sortierte Daten mit wiederholten Daten in aufeinanderfolgenden Zeilen bereitzustellen.
Zellverbindungen besitzen viele mögliche Anwendungen. Zum Beispiel können Sie für
Tabellenüberschriften über mehrere Spalten hinweg, verbundene Datenansichten oder Tabellen, in denen
der Text in angrenzende Spalten übergeht, verwendet werden.
Verbundene Tabellenüberschriften
Um verbundene Tabellenüberschriften zu erstellen, müssen Sie zunächst die Tabelleneigenschaft
AllowMerging auf FixedOnly setzen. Danach legen Sie die Zeilen und Spalten fest, die verbunden
werden sollen, indem Sie die Zeilen- und Spalteneigenschaft AllowMerging setzen. Schlussendlich
müssen Sie den Überschriftstext in jede Zelle der Tabellenüberschrift eintragen, so dass die Zellen, die Sie
verbinden wollen, denselben Inhalt haben.
Der nachfolgende Quelltext zeigt ein Beispiel hierfür:
• Visual Basic
Private Sub Form1_Load(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles MyBase.Load
Dim i%
' initialize control
fg.Styles.Normal.WordWrap = True
fg.Cols.Count = 9
fg.Rows.Fixed = 2
fg.AllowMerging = AllowMergingEnum.FixedOnly
' create row headers
fg.Rows(0).AllowMerging = True
' four cells with same contents, will merge
Dim rng As CellRange = fg.GetCellRange(0, 1, 0, 4)
rng.Data = "North"
' four cells with same contents, will merge
rng = fg.GetCellRange(0, 5, 0, 8)
rng.Data = "South"
For i = 1 To 4
fg(1, i) = "Qtr " & i
fg(1, i + 4) = "Qtr " & i
Next
' create column header
fg.Cols(0).AllowMerging = True
' two cells with same contents, will merge
rng = fg.GetCellRange(0, 0, 1, 0)
rng.Data = "Sales by Product"
' align and autosize the cells
fg.Styles.Fixed.TextAlign = TextAlignEnum.CenterCenter
fg.AutoSizeCols(1, fg.Cols.Count - 1, 10)
End Sub

58 · Die C1FlexGrid-Steuerung verwenden
• C#
private void Form1_Load( System.object sender, System.EventArgs e)
base.Load {
i%;
}
• Delphi
// initialize control
fg.Styles.Normal.WordWrap = true;
fg.Cols.Count = 9;
fg.Rows.Fixed = 2;
fg.AllowMerging = AllowMergingEnum.FixedOnly;
// create row headers
fg.Rows[0].AllowMerging = true;
// four cells with same contents, will merge
CellRange rng = fg.GetCellRange(0, 1, 0, 4);
rng.Data = "North";
// four cells with same contents, will merge
rng = fg.GetCellRange(0, 5, 0, 8);
rng.Data = "South";
for ( i = 1 ; i

fg[1, i] := 'Qtr ' + I;
fg[1, i + 4] = 'Qtr ' + I;
end;
// create column header
fg.Cols[0].AllowMerging := True;
// two cells with same contents, will merge
rng := fg.GetCellRange(0, 0, 1, 0);
rng.Data := 'Sales by Product';
// align and autosize the cells
fg.Styles.Fixed.TextAlign := TextAlignEnum.CenterCenter;
fg.AutoSizeCols(1, fg.Cols.Count - 1, 10);
end;
So sieht das Ergebnis aus:
Verbundene Datenansichten
Zellen verbinden · 59
Zellverbindungen funktionieren ebenso, wenn die Tabelle an eine Datenquelle gebunden ist. Der
nachfolgende Quelltext zeigt ein Beispiel hierfür. Der Quellcode verwendet ein DataAdapter-Objekt,
welches während der Designtime erstellt wurde:
• Visual Basic
• C#
Private Sub Form1_Load(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles MyBase.Load
Dim i%
' bind the grid to a data source
Dim ds As New DataSet()
SqlDataAdapter1.Fill(ds)
fg.DataSource = ds.Tables(0)
' set up cell merging
fg.AllowMerging = AllowMergingEnum.RestrictCols
For i = fg.Cols.Fixed To fg.Cols.Count – 1
fg.Cols(i).AllowMerging = True
Next
End Sub
private void Form1_Load( System.object sender, System.EventArgs e)
{
// bind the grid to a data source
DataSet ds = new DataSet();
SqlDataAdapter1.Fill(ds);

60 · Die C1FlexGrid-Steuerung verwenden
}
• Delphi
fg.DataSource = ds.Tables[0];
// set up cell merging
fg.AllowMerging = AllowMergingEnum.RestrictCols;
for (int i = fg.Cols.Fixed; i

Zellen verbinden · 61
1. Die Spill-Einstellung ermöglicht dem Text, der zu lang für eine Zelle ist, in angrenzende leere
Zellen überzugehen. Das Ergebnis ist dem von Microsoft Excel ähnlich. Wenn ein Eintrag in einer
Zelle zu lang ist, dann wird dieser über den angrenzenden leeren Zellen angezeigt.
Zum Beispiel die nachfolgende Grafik zeigt wie die Tabelle aussehen könnte, wenn die
AllowMerging-Eigenschaft auf Spill gesetzt wurde und ein Nutzer unterschiedlich lange
Einträge vornimmt:
2. Die Nodes-Einstellung ist der Spill-Einstellung ähnlich, wird aber nur auf Gliederungsknoten
angewendet. Diese Eigenschaft ist für gruppierte Daten nützlich, bei denen die Knotenzeilen
Informationen enthalten, die ein anderes Format als die Datenzeilen besitzen.
Zum Beispiel die nachfolgende Grafik zeigt, wie die Tabelle aussehen könnte, wenn die Daten
mit der Subtotal-Methode gruppiert und zusammengefasst sind, und die AllowMerging auf
Nodes gesetzt wurde:
Diese Grafik ist der im vorhergehenden Abschnitt über Zwischensummen ähnlich. Der
Unterschied liegt in den Zwischensummenzeilen (Knoten), deren Inhalte in die nun links
angrenzenden leeren Zellen übergehen und damit die Ansicht verbessert.
Benutzerdefinierte Verbindungen
Sie können das Standardverhalten der Verbindungen auf zwei Wegen anpassen:

62 · Die C1FlexGrid-Steuerung verwenden
1. Ordnen Sie eine benutzerdefinierte IComparer-Klasse der CustomComparer-Eigenschaft zu.
Standardmäßig verbindet die Tabellensteuerung Zellen mit demselben, aber von Null verschiedenen
Inhalt. Zeichenkettenvergleiche berücksichtigen Groß- und Kleinschreibung und Leerzeichen.
Wenn Sie möchten, dass die Tabellensteuerung Zellen verbindet, wobei beim Inhaltsvergleich sowohl
Groß- und Kleinschreibung als auch Leerzeichen unberücksichtig bleiben, dann müssen Sie eine eigene
Klasse schreiben, den IComparer implementieren und diese der CustomComparer-Eigenschaft
zuordnen.
2. Schreiben Sie eine neue Klasse, die von der C1FlexGrid abgleitet wird, und überschreiben Sie die
GetMergedRange-Virtualmethode mit Ihrer eigenen Verbindungslogik.
Für Beispiele, die zeigen, wie man benutzerdefinierte Verbindungslogiken implementiert, schauen Sie
bitte in den „CustomMerge“-Beispielen in unserer online Beispielbibliothek nach.
Speichern, Laden und Drucken
Die C1FlexGrid-Steuerung besitzt Methoden, mit denen Sie Tabellen speichern, laden und drucken
können.
Tabellen in Textdateien speichern und öffnen
Die SaveGrid-Methode speichert die Tabelle in einer Textdatei ab. Diese Methode besitzt verschiedene
Parameter, die u.a. das Trennzeichen festlegen (z.B. Kommas, Tabulatoren oder benutzerdefinierte
Trennzeichen), festlegen, ob die festen Zellen, oder nur die scrollbaren Zellen gespeichert werden und
den Encodertyp bestimmen (z.B. ASCII oder Unicode). Die erstellten Textdateien können später mit der
Tabellensteuerung oder mit jedem anderen Programm geladen werden, welches komma- oder
tabulatorengetrennte Textdateien, z.B. Microsoft Excel, unterstützt.
Die LoadGrid-Methode liest die Daten aus den Textdateien aus. Sie können alle Textdateien öffnen, die
entweder mit der SaveGrid-Methode oder einem anderen beliebigen Programm erstellt wurden.
Das Format der Textdateien ist recht einfach. Die Zellinhalte werden als formatierte Zeichenketten
gespeichert, genauso wie diese auf dem Bildschirm angezeigt werden. Wenn der Text der Zelle
Anführungszeichen oder Zelltrennzeichen enthält, dann wird die Zelle in Anführungszeichen
eingeschlossen, so dass alle Anführungszeichen im Zelltext verdoppelt werden. Diese Konvention wird
ebenfalls in Microsoft Excel-Textdateien verwendet.
Textdateien enthalten keine Bilder und keine Formatierungsinformationen.
Die SaveGrid-Methode besitzt den flags-Parameter, mit dem Sie festlegen können, ob die gesamte
Tabelle oder nur ein Teil (scrollbarer, sichtbarer oder ausgewählter Bereich) gespeichert werden soll.
Microsoft Excel-Dateien speichern und öffnen
Ab Version 2.5 können Sie die Methoden SaveGrid und LoadGrid verwenden, um sowohl Microsoft
Excel-Dateien (*.xls) als auch Textdateien abzuspeichern. Somit können neben den Daten auch die
Formatierungsinformationen abgespeichert werden.
Um Excel-Dateien mit den SaveGrid- und LoadGrid-Methoden zu speichern oder zu öffnen, müssen Sie
nur den format-Parameter auf FileFormatEnum.Excel stellen und die besagten Methoden wie üblich
aufrufen. Microsoft Excel muss hierfür nicht auf Ihrem Computer installiert sein.
Excel-Dateien enthalten „Arbeitsmappen“, die aus „Blättern“ bestehen. Die SaveGrid und LoadGrid-
Methoden speichern Tabellen auf nur einem Arbeitsblatt ab und öffnen immer nur das erste Blatt einer
Mappe. Wenn Sie die zu speichernden oder zu öffnenden Blätter festlegen wollen, so müssen Sie die

Speichern, Laden und Drucken · 63
SaveExcel-, LoadExcel- und LoadExcelSheetNames-Methoden verwenden. Der Speicher- und
Ladeprozess von Excel-Dateien wandelt die meisten Datentypen und Formatierungsinformationen um,
u.a. Zeilenhöhe und Spaltenbreite, Schriftarten, Farben, Formate und Zellausrichtungen. Dennoch
können nicht alle Formatierungselemente umgewandelt werden. Zum Beispiel wir die Tabellensteuerung
zwar die Werte in die Excel-Zellen laden, die darunter liegenden Formeln gehen dabei aber verloren.
Andere Funktionen, wie zum Beispiel eingefrorene und verbundene Zellen, Bilder, Datengliederungen
und Zellrahmen werden auch nicht übernommen.
Tabellen aus Datenbanken laden
Sie können Tabellendaten auch aus Datenbanken laden. Dies unterscheidet sich von Datenbindungen, bei
denen die Verbindung zwischen den Steuerungen und der zugrundeliegenden Datenquelle erhalten
bleiben. Um Daten aus Datenbanken zu laden, können Sie das DataReader-Objekt wie folgt verwenden:
• Visual Basic
• C#
Private Sub _btnData_Click(sender As Object, e As System.EventArgs)
' prepare DataReader
Dim strConn As String = "data source=MYMACHINE;initial
catalog=Northwind;"
Dim myConn As New SqlConnection(strConn)
Dim myCMD As New SqlCommand("SELECT * FROM Employees", myConn)
myConn.Open()
Dim myReader As SqlDataReader = myCMD.ExecuteReader()
' build grid structure from DB schema
Dim dt As DataTable = myReader.GetSchemaTable()
_flex.Cols.Count = 1
Dim dr As DataRow
For Each dr In dt.Rows
Dim c As Column = _flex.Cols.Add()
c.Caption =(c.Name

64 · Die C1FlexGrid-Steuerung verwenden
}
• Delphi
// build grid structure from DB schema
DataTable dt = myReader.GetSchemaTable();
_flex.Cols.Count = 1;
foreach (DataRow dr in dt.Rows)
{
Column c = _flex.Cols.Add();
c.Caption = c.Name = (string)dr["ColumnName"];
c.DataType = (Type)dr["DataType"];
}
// populate grid
_flex.Rows.Count = 1;
int row = 1;
int cols = dt.Columns.Count;
object[] v = (object[])Array.CreateInstance(typeof(object), cols);
while (myReader.Read())
{
myReader.GetValues(v);
_flex.AddItem(v, row++, 1);
}
// cleanup
_flex.AutoSizeCols();
myReader.Close();
myConn.Close();
var
v: System.Array;
cols: Integer;
row: Integer;
dt: DataTable;
dr: DataRow;
myReader: SqlDataReader;
myCMD: SqlCommand;
myConn: SqlConnection;
strConn: string;
c: Column;
begin
// prepare DataReader
strConn := 'data source=MYMACHINE;initial catalog=Northwind;';
myConn := SqlConnection.Create(strConn);
myCMD := SqlCommand.Create('SELECT * FROM Employees', myConn);
myConn.Open;
myReader := myCMD.ExecuteReader;
// build grid structure from DB schema
dt := myReader.GetSchemaTable;
_flex.Cols.Count = 1
for I := 0 to dt.Rows.Count – 1 do
begin
dr := dt.Rows[I];
c := flex.Cols.Add;
c.Caption := string(dr['ColumnName']);
c.Name := string(dr['ColumnName']);
c.DataType := System.Type(dr['DataType']);
end;
// populate grid
flex.Rows.Count := 1;
row := 1;
cols := dt.Columns.Count;

Tabellen drucken
Speichern, Laden und Drucken · 65
v := _ System.Array.CreateInstance(typeof(System.Object), cols),
cols);
While myReader.Read() do
begin
myReader.GetValues(v);
_flex.AddItem(v, row, 1);
row := row + 1;
end;
// cleanup
_flex.AutoSizeCols;
myReader.Close;
myConn.Close;
end; //_btnData_Click
Verwenden Sie die PrintGrid-Methode um die Inhalte einer Tabelle zu drucken. Diese Methode besitzt
Parameter, mit denen Sie u.a. den Skalierungsmodus auswählen können, das Druckvorschaufenster
anzeigen und Kopf- und Fußzeilen festlegen können.
Die PrintParameters-Eigenschaft beinhaltet weitere Druckeinstellungen, wie zum Beispiel die Schriftart
der Kopf- und Fußzeilen und ein PrintDocument-Objekt des .NET-Frameworks, mit dem u.a. der
Drucker, die Papiergröße und Ausrichtung sowie die Ränder ausgewählt werden können.
Der Nachfolgende Quelltext verwendet die PrintParameters-Eigenschaft, um die Seitenausrichtung, die
Ränder und die Kopf- und Fußzeilenschriftart festzulegen. Dann wird die PrintGrid-Methode
aufgerufen, um eine Druckvorschau anzuzeigen:
• Visual Basic
• C#
' get grid's PrintDocument object
Dim pd As PrintDocument
pd = fg.PrintParameters.PrintDocument()
' set up the page (landscape, 1.5" left margin)
With pd.DefaultPageSettings
.Landscape = True
.Margins.Left = 150
End With
' set up header and footer fonts
fg.PrintParameters.HeaderFont = New Font("Arial Black", 14,
FontStyle.Bold)
fg.PrintParameters.FooterFont = New Font("Arial Narrow", 8,
FontStyle.Italic)
' preview the grid
fg.PrintGrid("VB Tutorial", _
PrintGridFlags.FitToPageWidth + PrintGridFlags.ShowPreviewDialog, _
"VB Tutorial" + Chr(9) + Chr(9) + Format(DateTime.Now, "d"), _
Chr(9) + Chr(9) + "Page {0} of {1}")
// get grid's PrintDocument object
PrintDocument pd = fg.PrintParameters.PrintDocument();
// set up the page (landscape, 1.5" left margin)
pd.DefaultPageSettings;
.Landscape = true;
.Margins.Left = 150;
} With

66 · Die C1FlexGrid-Steuerung verwenden
// set up header and footer fonts
fg.PrintParameters.HeaderFont = new Font("Arial Black", 14,
FontStyle.Bold);
fg.PrintParameters.FooterFont = new Font("Arial Narrow", 8,
FontStyle.Italic);
// preview the grid
fg.PrintGrid("VB Tutorial",
PrintGridFlags.FitToPageWidth | PrintGridFlags.ShowPreviewDialog,
"VB Tutorial\t\t" + Format(DateTime.Now, "d"),
"\t\tPage {0} of {1}");
• Delphi
var
pd: PrintDocument;
begin
// get grid's PrintDocument object
pd := flex.PrintParameters.PrintDocument;
// set up the page (landscape, 1.5" left margin)
With pd.DefaultPageSettings do
begin
Landscape := True;
Margins.Left := 150;
End;
// set up header and footer fonts
flex.PrintParameters.HeaderFont := System.Drawing.Font.Create('Arial
Black', 14, FontStyle.Bold);
flex.PrintParameters.FooterFont := System.Drawing.Font.Create('Arial
Narrow', 8, FontStyle.Italic);
// preview the grid
flex.PrintGrid('VB Tutorial',
PrintGridFlags.FitToPageWidth or PrintGridFlags.ShowPreviewDialog,
'VB Tutorial'#9#9 + Format(DateTime.Now, 'd'),
#9#9 + 'Page {0} of {1}');
end;
FlexGrid-Eigenschaftsgruppen
Die C1FlexGrid-Steuerung besitzt sehr viele Eigenschaften, Methoden und Ereignisse, die Sie natürlich
nicht alle kennen müssen, um die Steuerung effektiv nutzen zu können.
Die nachfolgende Auflistung zeigt die wichtigsten Eigenschaften, Methoden und Ereignisse, gruppiert
nach Anwendungstyp. Einige Elemente tauchen in mehr als nur einer Gruppe auf. Für weitere Details
über bestimmte Elemente schauen Sie bitte im Referenzverzeichnis dieser Dokumentation nach.
1) Tabellenformatierung
Rows, Cols, AutoSizeCols, ScrollBars, ScrollTrack
2) Cursor und Auswahlen
SelectionMode, Select, ShowCell, Row, Col, RowSel, ColSel, SelectionBeforeMouseDown,
MouseRow, MouseCol,
BeforeRowColChange, AfterRowColChange, BeforeSelChange, AfterSelChange,
KeyActionTab, KeyActionEnter

3) Bearbeiten
AllowEditing, ComboList, EditMask,
BeforeEdit, StartEdit, ValidateEdit, AfterEdit,
StartEditing, FinishEditing, Editor, CellButtonClick,
KeyDownEdit, KeyPressEdit, KeyUpEdit, ChangeEdit
4) Werte abrufen und abspeichern
Item (indexer), GetData, GetDataDisplay, SetData, GetCellRange,
GetCellImage, SetCellImage, Clip, FindRow, Aggregate, CellChanged
5) Benutzerschnittstellen
AllowEditing, AllowMerging, AllowResizing, AllowDragging,
AllowSorting, BeforeSort, AfterSort, AutoSearch, AutoSearchDelay
BeforeDragColumn, AfterDragColumn, BeforeDragRow, AfterDragRow,
BeforeResizeColumn, AfterResizeColumn, BeforeResizeRow, AfterResizeRow,
ScrollTips, ScrollTipText, BeforeScrollTip
6) Gliederungen und Zusammenfassungen
Subtotal, Tree, Rows(index).IsNode, Node.Level,
Node.Collapsed, BeforeCollapse, AfterCollapse
7) Zellen verbinden
AllowMerging, GetMergedRange
8) Datenbindungen
DataSource, DataMember, AfterDataRefresh, AutoResize, GridError
9) Tabellen speichern, öffnen und drucken
LoadGrid, SaveGrid, LoadExcel, SaveExcel, ClipSeparators, PrintGrid
10) OLE-Drag-Drop
DragMode, DropMode, BeforeMouseDown
FlexGrid-Eigenschaftsgruppen · 67

FlexGrid-Beispiele
Visual Basic-Beispiele · 69
Die folgenden Beispiele sind in diesem Produkt enthalten. Verschiedene Produkte und Beispiele können
auch noch weitere ComponentOne-Steuerungen beinhalten. An dieser Stelle sind einige Beispiele
aufgeführt. Sie demonstrieren diverse Programmfunktionen und wie die entsprechende Steuerung in den
Rest der ComponentOne-Produktlinie integriert wird. Diese entsprechenden Steuerungen müssen aber
nicht zwingend in dem von Ihnen möglicherweise einzeln erworbenen Produkt enthalten sein.
Die ComponentOne-Beispiele sind auch unter http://www.componentone.com/samples verfügbar.
Visual Basic-Beispiele
AutoSizeEdit
BarChart
Benchmark
Blinker
BoundDelete
BoundFinishEdit
BoundImage
CellBorders
CellDataType
CellMerging
Clipboard
ColumnEditor
CustomDataMap
Ändert die Größe des Editors, während der Nutzer schreibt. Dieses
Beispiel verwendet die C1FlexGrid-Steuerung.
Erstellt Balkendiagramme mit Tabellenzellen. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.
Vergleicht die Stärke der Datenbindungen für FlexGrid und
MSDataGrid. Dieses Beispiel verwendet die C1FlexGrid- und die
C1TrueDBGrid-Steuerung.
Verwendet CellStyles um Zellen blinken zu lassen. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.
Löscht Zeilen aus einem gebundenen FlexGrid. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.
Übergibt Änderungen nach Bearbeitung an DataRow. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.
Knüpft die Tabelle an Grafikfelder, die als OLE-Objekte abgespeichert
sind. Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Verwendet OwnerDraw um benutzerdefinierte Zellrahmen
bereitzustellen. Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Ordnet Zelltypen (und Editoren) auf einer „pro Zelle“-Basis zu. Dieses
Beispiel verwendet die C1FlexGrid-Steuerung.
Zeigt verschiedene Typen von Zellverbindungen in einer FlexGrid-
Steuerung. Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Fügt die Unterstützung für Zwischenablagen der FlexGrid-Steuerung
hinzu. Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Zeigt den FlexGrid-Spalteneditor der Designtime in Ihrer Steuerung an.
Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Legt die Auswahloptionen in Auswahlfeldern unter Verwendung von
DataMaps fest. Dieses Beispiel verwendet die C1FlexGrid-Steuerung.

70 · FlexGrid-Beispiele
CustomEditor
CustomMerge
CustomMerge2
CustomMerge3
CustomMerge4
CustomPrint
CustomTree
DataIndex
DataMap
DataReader
DataTable
DataTableDictionary
DBDynamicStyles
DBImageField
DBSchemaChange
DBTree
Implementiert Ihren eigenen Zelleditor. Dieses Beispiel verwendet die
C1FlexGrid-Steuerung.
Implementiert Ihre eigene Verbindungslogik um einen Bildschirm für
einen TV-Führer zu erstellen. Dieses Beispiel ruft den
C1.Win.C1FlexGrid-Namensbereich auf.
Implementiert Ihre eigene Verbindungslogik um verschiedene
Verbindungsarten zu vermischen. Dieses Beispiel ruft den
C1.Win.C1FlexGrid-Namensbereich auf.
Zeigt, wie Gruppierung angepasst wird, indem man sich über die
GetData-Methode hinwegsetzt. Dieses Beispiel ruft den
C1.Win.C1FlexGrid-Namensbereich auf.
Zeigt, wie Gruppierung angepasst wird, indem man sich über die
GetData-Methode hinwegsetzt. Dieses Beispiel ruft den
C1.Win.C1FlexGrid-Namensbereich auf.
Verwendet die CreateImage-Methode, um Tabellen mit willkürlichen
Zeilen- und Spaltenumbrüchen zu drucken. Dieses Beispiel verwendet
die C1FlexGrid-Steuerung.
Verwendet die C1FlexGrid-Steuerung, um einen Gliederungsbaum zu
erstellen. Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Verwendet die Row.DataIndex-Eigenschaft, um die zugrunde liegende
Datenzeile zu ermitteln. Dieses Beispiel verwendet die C1FlexGrid-
Steuerung.
Verwendet auf Daten zugeordnete Spalten, wenn diese an eine
Datenquelle gebunden sind. Dieses Beispiel verwendet die
C1FlexGrid-Steuerung.
Füllt eine Tabelle aus einem DataReader aus. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.
Verknüpft zu DataTable, fügt Zeilen hinzu und löscht Zeilen. Dieses
Beispiel verwendet die C1FlexGrid-Steuerung.
Zeigt, wie DataMaps aus DataTable-Objekten erstellt werden. Dieses
Beispiel verwendet die C1FlexGrid-Steuerung.
Wendet Formatvorlagen auf Zellen, basierend auf deren Inhalten, an.
Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Zeigt in einer DataTable abgespeicherte Bilder. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.
Prüft die Tabellenreaktion auf Änderungen im Datenquellobjekt. Dieses
Beispiel verwendet die C1FlexGrid-Steuerung.
Zeigt gebundene Daten in einer hierarchischen Gliederungsansicht an.
Dieses Beispiel verwendet die C1FlexGrid-Steuerung.

DragDrop
DragRow
DynamicStyles
Editing
FlexByRow
FlexGroup
FreezeBottom
GridChart
HierData
Hyperlink
MapAndGroup
MergeStyles
MultiColumnDropDown
Outline
PrintPreview
ProductTree
RTFGrid
Visual Basic-Beispiele · 71
Passt automatisches Drag & Drop an. Dieses Beispiel verwendet die
C1FlexGrid-Steuerung.
Zieht Zeilen zwischen Tabellen. Dieses Beispiel verwendet die
C1FlexGrid-Steuerung.
Wendet Formatvorlagen auf Zellen, basierend auf Inhalten von
anderen Zellen an. Dieses Beispiel verwendet die C1FlexGrid-
Steuerung.
Bearbeitet Zellen mit Textfeldern, Listen, Masken und Kontrollfeldern.
Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Erstellt eine Tabelle im transponierten Format. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.
Implementiert Outlook-ähnliche Gruppierungs- und Filterfunktionen
unter Verwendung von FlexGrid. Dieses Beispiel verwendet die
C1FlexGrid-Steuerung.
Zeigt feste Zeilen am Ende der Tabelle. Dieses Beispiel verwendet die
C1FlexGrid-Steuerung.
Hängt ein FlexGrid an eine C1Chart-Steuerung an. Dieses Beispiel
verwendet die C1FlexGrid- und die C1Chart-Steuerung.
Bindet hierarchische Datenquellen an (master-detail-Style). Dieses
Beispiel verwendet die C1FlexGrid-Steuerung.
Fügt Hyperlinks in Zellen der FlexGrid ein. Dieses Beispiel verwendet
die C1FlexGrid-Steuerung.
Zeigt Gruppierungs- und Sortierungsverhalten, wenn mit Daten
verknüpfte Spalten verwendet werden. Dieses Beispiel verwendet die
C1FlexGrid-Steuerung.
Verbindet auf Zeilen, Spalten und Zellen angewendete CellStyles.
Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Mehrspaltenauswahleditor für die Verwendung mit dem C1FlexGrid.
Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Blendet wiederholte Daten in einer Gliederung aus. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.
Stellt Druckvorschau mit der C1PrintPreview-Steuerung auf drei
Wegen zur Verfügung. Dieses Beispiel verwendet die C1FlexGrid-,
C1PrintDocument-, C1PrintPreview- und PreviewToolBarButton-
Steuerung.
Erstellt eine benutzerdefinierte Gliederung mit Produktinformationen.
Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Zeigt *.RTF-Texte in Tabellenzellen an. Dieses Beispiel verwendet die
C1FlexGrid-Steuerung.

72 · FlexGrid-Beispiele
ScrollPosition
SelectionMode
Sorting
Splits
StartEditing
Styles
Subtotals
Transpose
TreeCheck
TreeNode
Tut_Analyze
Tut_Edit
Tut_XMLTree
Validate
C#-Beispiele
Analyze
AutoSizeEdit
Zeigt wie die ScrollPosition-Eigenschaft funktioniert. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.
Zeigt die Auswirkungen der SelectionMode-Eigenschaft. Dieses
Beispiel verwendet die C1FlexGrid-Steuerung.
Zeigt einige Sortierungstechniken. Dieses Beispiel verwendet die
C1FlexGrid-Steuerung.
Spaltet ein C1FlexGrid in mehrere Ansichten auf. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.
Implementiert eine Tabelle, die im Zellbearbeitungsmodus verweilt.
Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Zeigt wie man Formatvorlagen verwendet, um das Aussehen der
C1FlexGrid anzupassen. Dieses Beispiel verwendet die C1FlexGrid-
Steuerung.
Erstellt Zwischensummen in mehreren Spalten. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.
Transponiert Daten in einer Tabelle. Dieses Beispiel verwendet die
C1FlexGrid-Steuerung.
Fügt Kontrollkästchen einem Gliederungsbaum hinzu. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.
Verwaltet einen Gliederungsbaum unter Verwendung von FlexGrid-
Knotenobjekten. Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Stellt dynamisches Sortieren und Gruppieren zur Verfügung. Dieses
Beispiel verwendet die C1FlexGrid-Steuerung.
Bearbeitet Zellen mit Textfeldern, Listen, Masken und Kontrollfeldern.
Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Füllt die Tabelle mit Daten aus einem XML-Dokument. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.
Verwendet die ErrorProvider-Steuerung zusammen mit FlexGrid.
Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Stellt dynamisches Sortieren und Gruppieren zur Verfügung. Dieses
Beispiel verwendet die C1FlexGrid-Steuerung.
Ändert die Größe des Editors, während der Nutzer schreibt. Dieses
Beispiel verwendet die C1FlexGrid-Steuerung.

BarChart
Benchmark
BoundDelete
BoundFinishEdit
BoundImage
BoundImageMap
CellBorders
CellDataType
CellLabels
Clipboard
ColumnEditor
ColumnOrder
CustomData
CustomDataMap
CustomDataSource
CustomEditor
CustomMerge
Erstellt Balkendiagramme mit Tabellenzellen. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.
Vergleicht die Stärke der Datenbindungen für FlexGrid und
MSDataGrid. Dieses Beispiel verwendet die C1FlexGrid- und die
C1TrueDBGrid-Steuerung.
Löscht Zeilen aus einem gebundenen FlexGrid. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.
C#-Beispiele · 73
Übergibt Änderungen nach Bearbeitung an DataRow. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.
Knüpft die Tabelle an Grafikfelder, die als OLE-Objekte abgespeichert
sind. Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Verwendet die ImageMap-Eigenschaft mit einer datengebundenen
Tabelle. Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Verwendet OwnerDraw um benutzerdefinierte Zellrahmen
bereitzustellen. Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Ordnet Zelltypen (und Editoren) auf einer „pro Zelle“-Basis zu. Dieses
Beispiel verwendet die C1FlexGrid-Steuerung.
Zeigt Quickinfos für Texte, die zu lang für ihre Zelle sind, an. Dieses
Beispiel verwendet die C1FlexGrid-Steuerung.
Fügt die Unterstützung für Zwischenablagen der FlexGrid-Steuerung
hinzu. Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Zeigt den FlexGrid-Spalteneditor der Designtime in Ihrer Steuerung an.
Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Positioniert Spalten dynamisch. Dieses Beispiel verwendet die
C1FlexGrid-Steuerung.
Implementiert ein benutzerdefiniertes Datenquellobjekt. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.
Legt die Auswahloptionen in Auswahlfeldern unter Verwendung von
DataMaps fest. Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Implementiert ein benutzerdefiniertes Datenquellobjekt und verknüpft
diese mit der Tabelle. Dieses Beispiel verwendet die C1FlexGrid-
Steuerung.
Implementiert Ihren eigenen Zelleditor. Dieses Beispiel verwendet die
C1FlexGrid-Steuerung.
Implementiert Ihre eigene Verbindungslogik um einen Bildschirm für
einen TV-Führer zu erstellen. Dieses Beispiel ruft den
C1.Win.C1FlexGrid-Namensbereich auf.

74 · FlexGrid-Beispiele
CustomMerge2
CustomMerge3
CustomMerge4
CustomPrint
CustomSelection
CustomSort
DataIndex
DataMap
DataReader
DataTable
DataTableDictionary
DataTree
DBDynamicStyles
DBImageField
DBImages
Implementiert Ihre eigene Verbindungslogik um verschiedene
Verbindungsarten zu vermischen. Dieses Beispiel ruft den
C1.Win.C1FlexGrid-Namensbereich auf.
Zeigt, wie Gruppierung angepasst wird, indem man sich über die
GetData-Methode hinwegsetzt. Dieses Beispiel ruft den
C1.Win.C1FlexGrid-Namensbereich auf.
Zeigt, wie Gruppierung angepasst wird, indem man sich über die
GetData-Methode hinwegsetzt. Dieses Beispiel ruft den
C1.Win.C1FlexGrid-Namensbereich auf.
Verwendet die CreateImage-Methode um Tabellen mit willkürlichen
Zeilen- und Spaltenumbrüchen zu drucken. Dieses Beispiel verwendet
die C1FlexGrid-Steuerung.
Verwendet OwnerDraw um benutzerdefinierte (nicht rechteckige)
Auswahl zu implementieren. Dieses Beispiel ruft den
C1.Win.C1FlexGrid-Namensbereich auf.
Implementiert Ihre eigene Sortierungslogik mit einem
benutzerdefinierten IComparer-Objekt. Dieses Beispiel verwendet die
C1FlexGrid-Steuerung.
Verwendet die Row.DataIndex-Eigenschaft um die zugrunde liegende
Datenzeile zu ermitteln. Dieses Beispiel verwendet die C1FlexGrid-
Steuerung.
Verwendet auf Daten zugeordnete Spalten, wenn diese an eine
Datenquelle gebunden sind. Dieses Beispiel verwendet die
C1FlexGrid-Steuerung.
Füllt eine Tabelle aus einem DataReader aus. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.
Verknüpft zu DataTable, fügt Zeilen hinzu und löscht Zeilen. Dieses
Beispiel verwendet die C1FlexGrid-Steuerung.
Zeigt, wie DataMaps aus DataTable-Objekten erstellt werden. Dieses
Beispiel verwendet die C1FlexGrid-Steuerung.
Knüpft die Tabelle an eine hierarchische Datenquelle und zeigt Details
in Untertabellen. Dieses Beispiel ruft den C1.Win.C1FlexGrid-
Namensbereich auf.
Wendet Formatvorlagen auf Zellen, basierend auf deren Inhalte an.
Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Zeigt in einer DataTable abgespeicherte Bilder. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.
Knüpft die Tabelle an eine Datenbasis, in der Bilddateien als OLE-
Objekte gespeichert sind. Dieses Beispiel verwendet die C1FlexGrid-
Steuerung.

DBSchemaChange
DBTree
DBUpdate
DragDrop
DragMerged
DragRow
DynamicStyles
FilterRow
FindRow
FlexByRow
FlexGroup
FlexHierarchical
FlexHierC1Data
FreezeBottom
GridChart
HierData
HostControls
C#-Beispiele · 75
Prüft die Tabellenreaktion auf Änderungen im Datenquellobjekt. Dieses
Beispiel verwendet die C1FlexGrid-Steuerung.
Zeigt gebundene Daten in einer hierarchischen Gliederungsansicht an.
Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Speichert Änderungen in einer zugrundeliegenden Datenbank. Dieses
Beispiel verwendet die C1FlexGrid-Steuerung.
Passt automatisches Drag & Drop an. Dieses Beispiel verwendet die
C1FlexGrid-Steuerung.
Zieht gruppierte und verbundene Spalten. Dieses Beispiel verwendet
die C1FlexGrid-Steuerung.
Zieht Zeilen zwischen Tabellen. Dieses Beispiel verwendet die
C1FlexGrid-Steuerung.
Wendet Formatvorlagen auf Zellen, basierend auf Inhalten von
anderen Zellen an. Dieses Beispiel verwendet die C1FlexGrid-
Steuerung.
Implementiert eine FilterRow in einer FlexGrid-Steuerung. Dieses
Beispiel verwendet die C1FlexGrid-Steuerung.
Findet Zeilen in einer zugrundeliegenden Datenquelle. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.
Erstellt eine Tabelle im transponierten Format. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.
Implementiert Outlook-ähnliche Gruppierungsfunktionen unter
Verwendung von FlexGrid. Dieses Beispiel verwendet die C1FlexGrid-
Steuerung.
Implementiert hierarchische Datenbindungen unter Verwendung von
FlexGrid. Dieses Beispiel ruft den C1.Win.C1FlexGrid-Namensbereich
auf.
Implementiert hierarchische Datenbindungen unter Verwendung von
FlexGrid und C1Data. Dieses Beispiel verwendet die C1DataSet- und
C1SchemaDef-Steuerungen und ruft den C1.Win.C1FlexGrid-
Namensbereich auf.
Zeigt feste Zeilen am Ende der Tabelle. Dieses Beispiel verwendet die
C1FlexGrid-Steuerung.
Hängt ein FlexGrid an eine C1Chart-Steuerung an. Dieses Beispiel
verwendet die C1FlexGrid- und die C1Chart-Steuerung.
Bindet hierarchische Datenquellen an (master-detail-Style). Dieses
Beispiel verwendet die C1FlexGrid-Steuerung.
Host-Steuerungen in Tabellenzellen. Dieses Beispiel verwendet die
C1FlexGrid-Steuerung.

76 · FlexGrid-Beispiele
Hyperlink
MasterDetail
MergeStyles
MultiColumnDropDown
NumericInput
Outline
PasswordChar
PrintPreview
RowStateDisplay
RTFGrid
ScrollPosition
SelectionMode
SetupEditor
Sorting
Splits
StartEditing
Subtotals
Fügt Hyperlinks in Zellen der FlexGrid ein. Dieses Beispiel verwendet
die C1FlexGrid-Steuerung.
Zeigt wie master-detail DataSets im Quellcode erstellt und gebunden
werden. Dieses Beispiel ruft den C1.Win.C1FlexGrid-Namensbereich
auf.
Verbindet auf Zeilen, Spalten und Zellen angewendete CellStyles.
Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Mehrspaltenauswahleditor für die Verwendung mit dem C1FlexGrid.
Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Implementiert Ihren eigenen Zelleditor für numerische Eingaben.
Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Blendet wiederholte Daten in einer Gliederung aus. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.
Verwendet die C1FlexGrid, um Passwörter einzugeben und zu
bearbeiten. Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Stellt Druckvorschau mit der C1PrintPreview-Steuerung auf drei
Wegen zur Verfügung. Dieses Beispiel verwendet die C1FlexGrid-,
C1PrintDocument-, C1PrintPreview- und PreviewToolBarButton-
Steuerung.
Verwendet verschiedene Formatvorlagen, um DataRows in
verschiedenen Zuständen anzuzeigen. Dieses Beispiel verwendet die
C1FlexGrid-Steuerung.
Zeigt *.RTF-Texte in Tabellenzellen an. Dieses Beispiel verwendet die
C1FlexGrid-Steuerung.
Zeigt wie die ScrollPosition-Eigenschaft funktioniert. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.
Zeigt die Auswirkungen der SelectionMode-Eigenschaft. Dieses
Beispiel verwendet die C1FlexGrid-Steuerung.
Verwendet das SetupEditor-Ereignis, um die Tabelleneditoren
anzupassen. Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Zeigt einige Sortierungstechniken. Dieses Beispiel verwendet die
C1FlexGrid-Steuerung.
Spaltet ein C1FlexGrid in mehrere Ansichten auf. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.
Implementiert eine Tabelle, die im Zellbearbeitungsmodus verweilt.
Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Erstellt Zwischensummen in mehreren Spalten. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.

Transpose
TreeCheck
TreeNode
TriStateBound
ComponentOne FlexGrid für mobile Gerätebeispiele · 77
Transponiert Daten in einer Tabelle. Dieses Beispiel verwendet die
C1FlexGrid-Steuerung.
Fügt Kontrollkästchen einem Gliederungsbaum hinzu. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.
Verwaltet einen Gliederungsbaum unter Verwendung von FlexGrid-
Knotenobjekten. Dieses Beispiel verwendet die C1FlexGrid-Steuerung.
Stellt 3-Zustands-Werte (graubar) in Boolean-Spalten zur Verfügung.
Dieses Beispiel ruft den C1.Win.C1FlexGrid-Namensbereich auf.
ComponentOne FlexGrid für mobile Gerätebeispiele
Analyze
BarChart
EditData
Stellt dynamisches Sortieren und Gruppieren zur Verfügung. Dieses Beispiel
verwendet die C1FlexGrid-Steuerung.
Erstellt Balkendiagramme mit Tabellenzellen. Dieses Beispiel verwendet die
C1FlexGrid-Steuerung.
Zeigt verschiedene Typen der integrierten Editoren und der dynamischen
Formatierung. Dieses Beispiel verwendet die C1FlexGrid-Steuerung.

78 · FlexGrid-Übungen
FlexGrid-Übungen
Der folgende Abschnitt beinhaltet verschiedene Übungen zu einigen der wichtigsten Funktionen in der
C1FlexGrid-Steuerung. Die Anweisungen werden Sie durch die Erstellung einfacher Projekte mit Schrittfür-Schritt-Beschreibungen
begleiten. Die Software-CD enthält weitere, komplexere Beispiele, die Sie als
Referenz verwenden können.
Die folgenden Übungen sind in diesem Dokument enthalten:
Bearbeiten Diese Übung beginnt mit der einfachen Dateneingabe und zeigt, wie
Datenformatierungen, Kontrollkästchen, Auswahllistenfelder, Eingabemasken
Datengültigkeit und die Zwischenablage angewendet werden.
Gliederungen Hier wird gezeigt, wie man C1FlexGrid verwenden kann, um Gliederungen für
strukturierte oder hierarchische Daten anzuzeigen.
Daten
analysieren
Übung zur Bearbeitung
Ausgehend von einer Tabelle mit Umsatzzahlen für verschiedene Produkte,
Regionen und Vertriebsmitarbeitern, zeigt diese Anleitung, wie dynamische
Ansichten (Spaltenreihenfolge), automatische Sortierung, Zellverbindungen,
automatische Zwischensummen und Gliederungen implementiert werden können.
Diese Übung beginnt mit einer einfachen Dateneingabe und fügt dann folgende Funktionen hinzu:
1. Formatierung
2. Kontrollkästchen
3. Auswahllistenfelder
4. Komplexe Datengültigkeit
5. Zwischenablagenunterstützung
6. Benutzerdefinierte Editoren
So wird die endgültige Tabelle nach den Übungen aussehen:
Schritt 1: Erstelle die C1FlexGrid-Steuerung

Übung zur Bearbeitung · 79
Erstellen Sie ein neues Visual Basic-Projekt und fügen Sie eine C1FlexGrid-Steuerung dem Formular
hinzu, indem Sie auf das C1FlexGrid-Symbol in der Symbolleiste klicken. Klicken Sie dann auf das
Formular und ziehen Sie das Objekt in die richtige Größe.
Wenn Sie die C1FlexGrid-Steuerung in der Symbolleiste nicht finden können, dann rechtsklicken Sie auf
die Symbolleiste und wählen die Option Customize Toolbox (Anpassen…) aus. Suchen Sie die
C1FlexGrid-Steuerung in der Liste der .NET-Komponenten und stellen Sie sicher, dass diese aktiviert ist.
Wenn Sie die C1FlexGrid in der Komponentenliste nicht finden können, dann müssen Sie das Programm
eventuell erneut installieren.
Als nächstes legen Sie im .NET-Eigenschaftsfenster die folgenden Steuerungseigenschaften fest:
(Name) = fg
Dock = Fill
Cols.Count = 5
Cols.Fixed = 0
Klicken Sie nun doppelt auf den Titelbereich des Formulars, um das Quellcodefenster zu öffnen. Fügen
Sie folgende Anweisungen am oberen Ende der Datei ein:
• Visual Basic
• C#
Imports C1.Win.C1FlexGrid
using C1.Win.C1FlexGrid;
• Delphi
uses C1.Win.C1FlexGrid;
Damit werden die Objekte, die in der C1FlexGrid-Assembly definiert sind, im Projekt sichtbar und
erspart somit viel Schreibarbeit.
Folgender Quellcode erstellt die Tabelle, wenn das Formular geladen wird. Geben Sie diesen ein oder
kopieren Sie ihn:
• Visual Basic
• C#
Private Sub Form1_Load(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles MyBase.Load
' set up columns
Dim cols As String = "Product|Region|Salesperson|Sales|Bonus"
Dim colNames As String() = cols.Split("|")
Dim i%
For i = 0 To fg.Cols.Count – 1
fg(0, i) = colNames(i)
fg.Cols(i).Name = colNames(i)
Next
End Sub
private void Form1_Load( System.object sender, System.EventArgs e)
{
// set up columns
string cols = "Product|Region|Salesperson|Sales|Bonus";
string[]colNames = cols.Split("|");
for (int i = 0; i < fg.Cols.Count; i++)
{
fg[0, i] = colNames[i];
fg.Cols[i].Name = colNames[i];
}

80 · FlexGrid-Übungen
}
• Delphi
procedure Form1_Load(sender: System.Object;_
e: System.EventArgs);
var
cols: string;
colNames: array of string;
I: Integer;
begin
// set up columns
cols := 'Product|Region|Salesperson|Sales|Bonus';
colNames := cols.Split('|');
For i := 0 To fg.Cols.Count – 1 do
begin
fg[0, i] := colNames[i];
fg.Cols[i].Name := colNames[i];
end;
end;
Das ist alles. Drücken Sie nun F5 um das Projekt auszuführen und Daten in Ihre neue Steuerung
einzutragen. Drücken Sie F2 oder die Leertaste um existierende Einträge zu bearbeiten oder
überschreiben Sie diese einfach, indem Sie neue Einträge vornehmen.
Schritt 2: Spaltentypen und Formate festlegen
Wenn numerische oder andere Datenwerte angezeigt werden sollen, dann wollen Sie sicherlich ein
konsistentes Format für die entsprechenden Werte anwenden. Mit der C1FlexGrid-Steuerung können Sie
den DataType und das Format für jede Spalte festlegen.
Um den DataType und das Format für eine Spalte festzulegen, fügen Sie den folgenden Quelltext in das
Form_Load-Ereignis ein:
• Visual Basic
• C#
Private Sub Form1_Load(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles MyBase.Load
' set up columns
Dim cols As String = "Product|Region|Salesperson|Sales|Bonus"
Dim colNames As String() = cols.Split("|")
Dim i%
For i = 0 To fg.Cols.Count – 1
fg(0, i) = colNames(i)
fg.Cols(i).Name = colNames(i)
Next
' set column DataType and Format
Dim c As Column = fg.Cols("Sales")
c.DataType = GetType(Decimal)
c.Format = "c" '

}
• Delphi
for (int i = 0; i

82 · FlexGrid-Übungen
Wir nehmen einmal an, dass unser Beispielprojekt den Verkauf von drei Produkten (Applets, Widgets
und Gadgets) in vier Regionen (North, South, East und West) mit drei Vollzeitvertriebsmitarbeitern
(Mary, Sarah und Paula) umfasst.
Um diese Listen als Auswahl in der C1FlexGrid-Steuerung zu verwenden, erstellen Sie eine Zeichenkette
mit den jeweiligen Elementen der Liste (getrennt durch Senkrechtstriche) und ordnen diese der
ComboList-Eigenschaft von der entsprechenden Spalte zu.
Schreiben Sie den folgenden Quelltext in das Form_Load-Ereignis, um die Kombinationsliste
hinzuzufügen:
• Visual Basic
• C#
Private Sub Form1_Load(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles MyBase.Load
' set up columns
Dim cols As String = "Product|Region|Salesperson|Sales|Bonus"
Dim colNames As String() = cols.Split("|")
Dim i%
For i = 0 To fg.Cols.Count – 1
fg(0, i) = colNames(i)
fg.Cols(i).Name = colNames(i)
Next
' set column DataType and Format
Dim c As Column = fg.Cols("Sales")
c.DataType = GetType(Decimal)
c.Format = "c" '

}
• Delphi
procedure Form1_Load(sender: System.Object;
e: System.EventArgs);
var
cols: string;
colNames: array of string;
I: Integer;
begin
// set up columns
cols := 'Product|Region|Salesperson|Sales|Bonus';
colNames := cols.Split('|');
for i := 0 to fg.Cols.Count – 1 do
begin
fg[0, i] := colNames[i];
fg.Cols[i].Name := colNames[I];
Next
// set column DataType and Format
c := fg.Cols['Sales'];
c.DataType := typeof(Decimal);
c.Format := 'c' //

84 · FlexGrid-Übungen
• C#
' collect the data we need
Select Case e.Col
Case 0
prd = fg.Editor.Text
rgn = fg(e.Row, "Region")
Case 1
prd = fg(e.Row, "Product")
rgn = fg.Editor.Text
End Select
' we can't sell Applets in the North Region...
If prd = "Applets" And rgn = "North" Then
MsgBox("Warning: Regulation #12333AS/SDA-23 forbids " & _
"the sale of " & prd & " in region " & rgn & ". " & _
"Please verify input.")
e.Cancel = True
End If
End Sub
private void fg_ValidateEdit( object sender, ValidateEditEventArgs e)
{
string rgn = string.Empty;
string prd = string.Empty;
+
}
// collect the data we need
switch (e.Col)
{
case 0:
prd = fg.Editor.Text;
rgn = (string)fg[e.Row, "Region"];
break;
case 1:
prd = (string)fg[e.Row, "Product"];
rgn = fg.Editor.Text;
break;
}
// we can't sell Applets in the North Region...
if ( prd == "Applets" && rgn == "North") {
MessageBox.Show("Warning: Regulation #12333AS/SDA-23 forbids "
}
• Delphi
"the sale of " + prd + " in region " + rgn + ". " +
"Please verify input.");
e.Cancel = true;
procedure fg_ValidateEdit(sender: System.Object;
e: ValidateEditEventArgs);
var
rgn: string;
prd: string;
begin
// collect the data we need
case e.Col of
0:
begin
prd := fg.Editor.Text;
rgn := fg[e.Row, 'Region'];
end;

1:
begin
prd := fg[e.Row, 'Product'];
rgn := fg.Editor.Text;
end;
end;
Übung zur Bearbeitung · 85
// we can't sell Applets in the North Region...
If (prd = 'Applets') And (rgn = 'North') Then
begin
MsgBox('Warning: Regulation #12333AS/SDA-23 forbids ' + _
'the sale of ' + prd + ' in region ' + rgn + ". " + _
'Please verify input.');
e.Cancel := True;
end;
end;
Die Funktion beginnt mit dem Auslesen der Daten, die sie für die Gültigkeitsprüfung benötigt. Die zu
prüfenden Werte werden mit Hilfe der Editor.Text-Eigenschaft ausgelesen, da die eingegebenen Werte
noch nicht in der Tabelle abgespeichert wurden. Wenn der Test nicht bestanden wird, dann zeigt die
Funktion eine Warnung an und stellt den Cancel-Parameter auf TRUE, so dass die Bearbeitung
abgebrochen und die Zelle zurück in den edit-Modus versetzt wird. Der Nutzer kann nun die Eingabe
erneut versuchen.
Drücken Sie F5 um das Projekt zu starten und versuchen Sie, fehlerhafte Werte einzugeben. Sie werden
sehen, dass die Tabellensteuerung dies nicht akzeptiert.
Schritt 5: Unterstützung der Zwischenablage
Die Zwischenablage von Windows ist eine sehr nützliche Funktion, um Informationen zwischen
Anwendungen auszutauschen.
Es ist recht einfach, die Zwischenablagenunterstützung in FlexGrid-Projekten zu integrieren. Stellen Sie
nur die AutoClipboard-Eigenschaft auf TRUE und die Tabellensteuerung wird automatisch die
Standardbefehle und Tastenkombinationen der Zwischenablage hinzufügen: ctrl-X oder shift-Entfernen
um auszuschneiden, ctrl-C oder ctrl-Einfügen um zukopieren und ctrl-V oder shift-Einfügen um
einzufügen.
Eine weitere großartige Windowsfunktion, die mit der Zwischenablage eng zusammenarbeitet, ist das
OLE-Drag & Drop (Ziehen-und-fallen-lassen). C1FlexGrid besitzt zwei Eigenschaften, DragMode und
DropMode, die diese Funktion implementieren. Wenn Sie beide Eigenschaften auf Ihre automatische
Einstellung setzen, dann können Sie eine Auswahl mit deren Ecken ziehen und diese in anderen
Anwendungen, wie z.B. Microsoft Excel, fallen lassen. Sie können natürlich auch eine Auswahl von
Excel-Tabellen in die C1FlexGrid-Steuerung ziehen.
Drücken Sie F5 um das Projekt zu starten und versuchen Sie Zellen zu kopieren und wieder einzufügen.
Beachten Sie, dass Sie auch ungültige Daten einfügen können, da der Quelltext des Befehls Einfügen
keine Gültigkeitsprüfung vornimmt. Dies bleibt als Übung dem Leser erhalten.
Schritt 6: Benutzerdefinierte Editoren
Das C1FlexGrid besitzt sehr starke, integrierte Editors für die reine Texteingabe, Texteingabe mit
Masken, Auswahl durch Listen, Kontrollkästchen und weitere. Eventuell wollen Sie aber statt der
integrierten Editoren Ihre eigenen verwenden - vielleicht eine Eingabesteuerung aus der C1Input-
Bibliothek oder eine Steuerung, die Sie selbst geschrieben haben. Ab Version 2.5 können Sie mit FlexGrid
ganz einfach eigene Editoren verwenden. Um einen benutzerdefinierten Editor der „Sales“-Spalte in
unserem Beispiel zuzuordnen, müssen Sie zunächst eine NumericUpDown-Steuerung dem Formular
hinzufügen. Verwenden Sie nun das .NET-Eigenschaftsfenster um die neue Steuerung mit den folgenden
Einstellungen zu konfigurieren:

86 · FlexGrid-Übungen
BorderStyle = None
Visible = False
DecimalPlaces = 2
ThousandsSeparator = True
Maximum = 5000000
Rechtsklicken Sie anschließend die Tabelle und wählen Sie „Edit Columns…“ aus, um den Spalteneditor
der Tabelle aufzurufen.
Wählen Sie die dritte Spalte aus (in der Umsatzzahlen stehen werden) und stellen Sie die Editor-
Eigenschaft auf numericUpDown1, wie nachfolgend in der Grafik gezeigt:
Starten Sie nun das Projekt und versuchen Sie, einige Werte in der „Sales“-Spalte zu ändern. Die Tabelle
verwendet nun die NumericUpDown-Steuerung anstatt der integrierten Editoren. Die Steuerung ist
richtig positioniert, initialisiert und verwaltet. Wenn Sie den Cursor auf eine andere Zelle bewegen, dann
wird der entsprechende Wert in der Tabelle gespeichert.
Dennoch verhält sich der benutzerdefinierte Editor nicht exakt genauso wie die integrierten. Z.B.:
1. Wenn Sie die Bearbeitung mit dem eintippen einer Zahl beginnen, wird der ursprüngliche Wert
der Zelle nicht sofort gelöscht.
2. Die Größe des Editors ist nicht richtig. Er ist ein wenig zu klein.
3. Es ertönt ein störender Beep, wenn Sie Enter drücken, um die Eingabe zu bestätigen.
Sie können diese Probleme auf mehreren Wegen umgehen. Zum Beispiel könnten Sie die Ereignisse des
Editors verwenden, wobei es dann aber schwierig wird, diese Steuerung in anderen Projekten wieder zu
verwenden. Oder Sie könnten eine abgeleitete Klasse erstellen und einige Methoden in der
IC1EmbeddedEditor-Schnittstelle implementieren.
Zum Beispiel, der nachfolgende Quellcode implementiert drei Methoden:

Übung zur Bearbeitung · 87
C1EditorInitialize wird aufgerufen um den Editor zu initialisieren. Es setzt den ursprünglichen Wert
und wählt dann den gesamten Eintrag aus. Dies löst das erste Problem. Weil der gesamte Eintrag
ausgewählt ist, wird das Eintippen des ersten Zeichens den ursprünglichen Inhalt der Zelle ersetzen.
C1EditorUpdateBounds wird aufgerufen, um den Editor genau über der zu bearbeitenden Zelle zu
platzieren. Die Höhe der NumericUpDown-Steuerung wird automatisch an die Schriftgroße angepasst,
so dass diese für die Zelle zu kurz erscheint. Daher stellt der Quellcode die FontHeight-Eigenschaft des
Editors so ein, dass dieser exakt über der Zelle platziert wird.
Schlussendlich überschreibt der Quellcode die ProcessDialogKey-Methode um die störenden Beeps zu
unterdrücken, wenn der Nutzer die Enter-Taste drückt.
• Visual Basic
• C#
Public Class MyUpDown
Inherits NumericUpDown
' set initial value
Public Sub C1EditorInitialize(ByVal value As Object, _
ByVal editorAttributes As IDictionary)
value = Convert.ChangeType(value, GetType(Decimal))
MyBase.Select(0, Int32.MaxValue)
End Sub
' set FontHeight so the control honors the rectangle height
Public Sub C1EditorUpdateBounds(ByVal rc As Rectangle)
MyBase.FontHeight = rc.Height
Bounds = rc
End Sub
' suppress annoying beeps when user hits enter
Protected Overrides Function ProcessDialogKey(ByVal keyData As
Keys) As Boolean
If (keyData = Keys.Enter) Then
Parent.Focus()
If (Parent.Focused) Then SendKeys.Send("{Down}")
Return True
End If
Return MyBase.ProcessDialogKey(keyData)
End Function
End Class
internal class MyUpDown : NumericUpDown
{
// set initial value
public void C1EditorInitialize(object value, IDictionary
editorAttributes)
{
// apply initial value
Value = (decimal)Convert.ChangeType(value, typeof(decimal));
}
// select the whole entry
Select(0, int.MaxValue);
// set FontHeight so the control honors the rectangle height
public void C1EditorUpdateBounds(Rectangle rc)
{
base.FontHeight = rc.Height;
Bounds = rc;
}

88 · FlexGrid-Übungen
}
• Delphi
// suppress annoying beeps when user hits enter
override protected bool ProcessDialogKey(Keys keyData)
{
if (keyData == Keys.Enter)
{
Parent.Focus();
if (Parent.Focused) SendKeys.Send("{Down}");
return true;
}
return base.ProcessDialogKey(keyData);
}
type TMyUpDown = class(NumericUpDown)
public
procedure C1EditorInitialize(value: System.Object; editorAttributes:
IDictionary);
procedure C1EditorUpdateBounds(rc: Rectangle);
function ProcessDialogKey(keyData: Keys): boolean;
end;
procedure TMyUpDown.C1EditorInitialize(value: System.Object;
editorAttributes: IDictionary);
begin
// apply initial value
value := Currency(Convert.ChangeType(value, TypeOf(Currency)));
// select the whole entry
Select(0, System.Int32.MaxValue);
end;
procedure TMyUpDown.C1EditorUpdateBounds(rc: Rectangle);
begin
inherited FontHeight := rc.Height;
Bounds := rc;
end;
function TMyUpDown.ProcessDialogKey(keyData: Keys): boolean;
begin
if (keyData = Keys.Enter) then
begin
Parent.Focus;
if (Parent.Focused) then
SendKeys.Send(‘{Down}’);
Result := true;
Exit;
end;
Result := inherited ProcessDialogKey(keyData);
end;
Übung zur Gliederung
Dieses Beispiel zeigt, wie Sie C1FlexGrid als Gliederung für die Anzeige von strukturierten oder
hierarchischen Daten verwenden können. Die C1FlexGrid-Steuerung verhält sich wie eine
Baumsteuerung, wenn Sie als Gliederer verwendet wird, und zeigt Knoten, die erweitert oder gruppiert
werden können, um Teile mit untergeordneten Daten ein- oder auszublenden.
Mit dem folgendem Beispiel können Sie ein XML-Dokument in die Tabelle laden, wo diese als
Gliederungsbaum angezeigt wird. So wird die fertige Anwendung aussehen:

Schritt 1: Die Steuerung erstellen
Starten Sie ein neues Visual Basic-Projekt und fügen Sie zwei Steuerungen hinzu:
1. Eine Befehlsschaltfläche im oberen Teil des Formulars, und
2. Eine C1FlexGrid-Steuerung unterhalb der Schaltfläche.
Übung zur Gliederung · 89
Wenn Sie die C1FlexGrid-Steuerung in der Symbolleiste nicht finden können, dann rechtsklicken Sie auf
die Symbolleiste und wählen die Option Customize Toolbox (Anpassen…) aus. Suchen Sie die
C1FlexGrid-Steuerung in der Liste der .NET-Komponenten und stellen Sie sicher, dass diese aktiviert ist.
Wenn Sie die C1FlexGrid in der Komponentenliste nicht finden können, dann müssen Sie das Programm
eventuell erneut installieren.
Verwenden Sie nun das .NET-Eigenschaftsfenster um die folgenden Einstellungen vorzunehmen:
1. Command button
Text = "Open XML File…"
Dock = Top
2. C1FlexGrid
(Name) = fg
Dock = Fill
Doppelklicken Sie nun auf den Titelbereich des Formulars, um das Quellcodefenster zu öffnen. Fügen Sie
folgende Anweisungen am oberen Ende der Datei ein:
• Visual Basic
• C#
Imports C1.Win.C1FlexGrid
using C1.Win.C1FlexGrid;
• Delphi
uses C1.Win.C1FlexGrid;

90 · FlexGrid-Übungen
Damit werden die Objekte, die in der C1FlexGrid-Assembly definiert sind, im Projekt sichtbar und
ersparen somit viel Schreibarbeit.
Als nächsten geben Sie den folgenden Quellcode, der die Tabelle erstellt, wenn das Formular geladen
wird, ein oder kopieren Sie ihn:
• Visual Basic
• C#
Private Sub Form1_Load(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles MyBase.Load
End Sub
' initialize grid
fg.Rows.Count = 1
fg.Cols.Count = 2
fg.Cols.Fixed = 0
fg.ExtendLastCol = True
fg(0, 0) = "Element"
fg(0, 1) = "Text"
' initialize outline tree
fg.Tree.Column = 0
fg.Tree.Style = TreeStyleFlags.SimpleLeaf
fg.Cols(0).AllowEditing = False
' initialize styles
fg.Styles.Normal.Border.Style = BorderStyleEnum.None
fg.Styles.Normal.TextAlign = TextAlignEnum.LeftCenter
fg.Styles.Normal.WordWrap = False
Dim cs As CellStyle = fg.Styles.Add("Data")
cs.BackColor = SystemColors.Control
private void Form1_Load( System.object sender, System.EventArgs e)
{
// initialize grid
fg.Rows.Count = 1;
fg.Cols.Count = 2;
fg.Cols.Fixed = 0;
fg.ExtendLastCol = true;
fg[0, 0] = "Element";
fg[0, 1] = "Text";
}
• Delphi
// initialize outline tree
fg.Tree.Column = 0;
fg.Tree.Style = TreeStyleFlags.SimpleLeaf;
fg.Cols[0].AllowEditing = false;
// initialize styles
fg.Styles.Normal.Border.Style = BorderStyleEnum.None;
fg.Styles.Normal.TextAlign = TextAlignEnum.LeftCenter;
fg.Styles.Normal.WordWrap = false;
CellStyle cs = fg.Styles.Add("Data");
cs.BackColor = SystemColors.Control;
procedure Form1_Load(sender: System.Object;
e: System.EventArgs);
var
cs: CellStyle;

egin
// initialize grid
fg.Rows.Count := 1;
fg.Cols.Count := 2;
fg.Cols.Fixed := 0;
fg.ExtendLastCol := True;
fg[0, 0] := 'Element';
fg[0, 1] := 'Text';
// initialize outline tree
fg.Tree.Column := 0;
fg.Tree.Style := TreeStyleFlags.SimpleLeaf;
fg.Cols[0].AllowEditing := False;
// initialize styles
fg.Styles.Normal.Border.Style := BorderStyleEnum.None;
fg.Styles.Normal.TextAlign := TextAlignEnum.LeftCenter;
fg.Styles.Normal.WordWrap := False;
cs := fg.Styles.Add('Data');
cs.BackColor := SystemColors.Control;
End;
Der Quellcode erstellt zunächst die Tabelle und fügt die Spaltenüberschriften ein.
Übung zur Gliederung · 91
Danach wird der Gliederungsbaum mit der Tree-Eigenschaft initialisiert und es wird die Bearbeitung der
XML-Knoten verhindert, indem die AllowEditing-Eigenschaft der ersten Spalte auf FALSE gestellt wird.
Beachten Sie, dass der Nutzer immer noch die zweite Spalte mit den Daten eines jeden XML-Knotens
bearbeiten kann.
Nun ist die Steuerung fertig und wir können etwas Quellcode hinzufügen.
Schritt 2: Die Daten lesen und die Gliederung erstellen
Klicken Sie doppelt auf die Befehlsschaltfläche und fügen Sie folgenden Quellcode in das Button1_Click-
Ereignis ein:
• Visual Basic
Private Sub Button1_Click(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles Button1.Click
' get file name
Dim fo As OpenFileDialog = New OpenFileDialog()
fo.DefaultExt = "xml"
fo.Filter = "XML Files (*.xml)|*.xml"
If fo.ShowDialog() DialogResult.OK Then Exit Sub
' load XML file
Dim xdoc As Xml.XmlDocument = New Xml.XmlDocument()
xdoc.Load(fo.FileName)
' stop redrawing to improve speed
fg.Redraw = False
' populate grid
fg.Rows.Count = 1
GetXMLData(xdoc.ChildNodes(1), 0)
' autosize tree column
fg.AutoSizeCol(0)
' show levels 0,1,2
fg.Tree.Show(2)

92 · FlexGrid-Übungen
• C#
' ready to redraw
fg.Redraw = True
End Sub
private void Button1_Click( System.object sender, System.EventArgs e)
{
// get file name
OpenFileDialog fo = new OpenFileDialog();
fo.DefaultExt = "xml";
fo.Filter = "XML Files (*.xml)|*.xml";
if ( fo.ShowDialog() != DialogResult.OK) return
}
• Delphi
// load XML file
Xml.XmlDocument xdoc = new Xml.XmlDocument();
xdoc.Load(fo.FileName);
// stop redrawing to improve speed
fg.Redraw = false;
// populate grid
fg.Rows.Count = 1;
GetXMLData(xdoc.ChildNodes[1], 0)
// autosize tree column
fg.AutoSizeCol(0);
// show levels 0,1,2
fg.Tree.Show(2);
// ready to redraw
fg.Redraw = true;
procedure Button1_Click(sender: System.Object;
e: System.EventArgs);
var
fo: OpenFileDialog;
xdoc: Xml.XmlDocument;
begin
// get file name
fo := OpenFileDialog.Create;
fo.DefaultExt := 'xml';
fo.Filter := 'XML Files (*.xml)|*.xml';
If fo.ShowDialog System.Windows.Forms.DialogResult.OK Then
exit;
// load XML file
xdoc := Xml.XmlDocument.Create;
xdoc.Load(fo.FileName);
// stop redrawing to improve speed
fg.Redraw := False;
// populate grid
fg.Rows.Count := 1;
GetXMLData(xdoc.ChildNodes[1], 0);
// autosize tree column
fg.AutoSizeCol(0);

show levels 0,1,2
fg.Tree.Show(2);
// ready to redraw
fg.Redraw := True;
end;
Übung zur Gliederung · 93
Die Routine zeigt zunächst ein OpenFileDialog („Datei öffnen“-Fenster) mit dem der Nutzer eine XML-
Datei in die Tabelle laden kann. Wenn die Datei ausgewählt ist, dann lädt die Routine diese in ein
XmlDocument-Objekt, welches den Inhalt der Datei an den Speicher übergibt.
Die Routine stellt dann die Tabelleneigenschaft Redraw auf FALSE, um die aktualisierende Anzeige
auszuschalten, während die Tabelle gefüllt wird. Diese Technik verbessert erheblich die Geschwindigkeit
und Sie sollten diese immer verwenden, wenn Sie erhebliche Datenmengen dem C1FlexGrid hinzufügen.
Als nächstes löscht die Routine alle Daten, indem sie die Einstellung Rows.Count = 1 vornimmt, und ruft
anschließend die GetXMLData-Routine auf, um die Steuerung mit den Inhalten des Xml-Dokuments zu
füllen. Die GetXMLData-Routine ist die wichtigste in diesem Beispiel und wird nachfolgend aufgeführt.
Nachdem die Tabelle gefüllt wurde, verwendet die Routine die AutoSize-Methode, um die Breite der
ersten Spalte aufgrund ihres Inhaltes festzulegen, und die Tree.Show-Methode, um die Gliederung
aufzublättern und die Ebenen 0, 1 und 2 anzuzeigen. Dann wird die Redraw-Eigenschaft wieder auf
TRUE gestellt, so dass die Tabelle wieder normal und aktualisiert angezeigt wird.
Die GetXMLData-Routine ist die interessanteste in diesem Beispiel. Sie übersetzt das XMLDocument-
Objekt und erstellt den Gliederungsbaum. Dies ist der entsprechende Quellcode:
• Visual Basic
Private Sub GetXMLData(ByVal node As Xml.XmlNode, ByVal level As
Integer)
' skip comment nodes
If node.NodeType = Xml.XmlNodeType.Comment Then
Exit Sub
End If
' add new row for this node
Dim row As Integer = fg.Rows.Count
fg.Rows.Add()
' add data to new row
fg(row, 0) = node.Name
If node.ChildNodes.Count = 1 Then
fg(row, 1) = node.InnerText
fg.SetCellStyle(row, 1, fg.Styles("Data"))
End If
' if the node has a "Name" subnode, save it to use as a tooltip
If node.ChildNodes.Count > 0 Then
Dim ndName As Xml.XmlNode = node.SelectSingleNode("Name")
If Not (ndName Is Nothing) Then
fg.Rows(row).UserData = ndName.InnerText
End If
End If
' if this node has children, get them as well
If node.ChildNodes.Count > 1 Then
' make this row a node
fg.Rows(row).IsNode = True
fg.Rows(row).Node.Level = level
' recurse to get children

94 · FlexGrid-Übungen
• C#
Dim child As Xml.XmlNode
For Each child In node.ChildNodes
GetXMLData(child, level + 1)
Next
End If
End Sub
private void GetXMLData( Xml.XmlNode node, int level)
{
// skip comment nodes
if ( node.NodeType == Xml.XmlNodeType.Comment)
return;
}
}
// add new row for this node
int row = fg.Rows.Count;
fg.Rows.Add();
// add data to new row
fg(row, 0) = node.Name;
if ( node.ChildNodes.Count = 1) {
fg(row, 1) = node.InnerText;
fg.SetCellStyle(row, 1, fg.Styles["Data"]);
}
// if the node has a "Name" subnode, save it to use as a tooltip
if (node.ChildNodes.Count > 0) {
Xml.XmlNode ndName = node.SelectSingleNode("Name");
if (ndName != null) {
fg.Rows[row].UserData = ndName.InnerText;
}
}
// if this node has children, get them as well
if ( node.ChildNodes.Count > 1) {
}
• Delphi
// make this row a node
fg.Rows[row].IsNode = true;
fg.Rows[row].Node.Level = level;
// recurse to get children
Xml.XmlNode child;
foreach ( child In node.ChildNodes)
GetXMLData(child, level + 1)
procedure GetXMLData(node: Xml.XmlNode; level: Integer);
var
r: Integer;
ndName: Xml.XmlNode;
child: Xml.XmlNode;
begin
// skip comment nodes
if node.NodeType = Xml.XmlNodeType.Comment then
exit;
// add new row for this node
r := fg.Rows.Count;
fg.Rows.Add;

add data to new row
fg[row, 0] := node.Name;
if node.ChildNodes.Count = 1 then
begin
fg[row, 1] := node.InnerText;
fg.SetCellStyle(row, 1, fg.Styles['Data']);
end;
Übung zur Gliederung · 95
// if the node has a "Name" subnode, save it to use as a tooltip
if node.ChildNodes.Count > 0 then
begin
ndName := node.SelectSingleNode('Name');
if ndName nil then
begin
fg.Rows[row].UserData := ndName.InnerText;
end;
end;
// if this node has children, get them as well
if node.ChildNodes.Count > 1 then
begin
// make this row a node
fg.Rows[row].IsNode := True;
fg.Rows[row].Node.Level := level;
// recurse to get children
for I := 0 to node.ChildNodes.Count – 1 do
GetXMLData(node.ChildNodes[I], level + 1);
end;
end;
Die Routine beginnt damit, die XML-Kommentarknoten auszulassen und verwendet anschließend die
Rows.Add-Methode um eine neue Zeile der Tabelle hinzuzufügen.
Danach wird der Name des Knotens festgelegt und überprüft, ob dieser genau einen Unterknoten besitzt.
In diesem Falle wird der Knoten als ein Datenknoten interpretiert und die Knoteneigenschaft InnerText
wird in die zweite Spalte der neuen Zeile kopiert. Der Quelltext legt außerdem das Format der Zellen, die
Daten besitzen, auf den „Data“-Style fest, der beim Laden des Formulars erstellt wurde.
Der nächste Quellcodeabschnitt überprüft, ob dieser Knoten einen Unterknoten mit dem Namen „Name“
besitzt. Wenn dies der Fall ist, dann wird der Inhalt des „Name“-Knotens der UserData-Eigenschaft der
neuen Zeile zugeordnet. Dieser Wert wird später für die Implementierung von Quickinfos verwendet, so
dass die Nutzer den Knotennamen, obwohl dieser zusammengeklappt ist, sehen können.
Zuletzt ruft sich die GetXMLData-Routine selbst auf, um auch die Unterknoten der Tabelle
hinzuzufügen, wenn der Knoten weitere Unterknoten besitzt.
Wenn Sie das Projekt nun starten, werden Sie sehen, dass dieses bereits XML-Dateien laden und anzeigen
und der Nutzer die Knoten auf und zuklappen kann, indem er auf diese klickt. Der nächste Schritt fügt
ein paar Verbesserungen hinzu, damit die Anwendung einfacher wird.
Schritt 3: benutzerdefinierte Maus- und Tastatursteuerung
Das C1FlexGrid stellt zwar das Erweitern und Zusammenklappen der Knoten zur Verfügung, Sie
können aber dennoch dessen Verhalten erweitern und anpassen. Jedes Mal wenn ein Teil der Gliederung
aus- oder eingeklappt wird, startet die Steuerung die Ereignisse BeforeCollapse und AfterCollapse, die
Sie für diverse Aktionen verwenden können. Des Weiteren können Sie die Node.Collapsed-Eigenschaft
verwenden, um den Zustand eines Gliederungsteils im Quellcode abzufragen oder festzulegen.

96 · FlexGrid-Übungen
In diesem Beispiel fangen wir die DoubleClick- und KeyPress-Ereignisse ab, um die Knoten aus- und
einzuklappen, wenn der Nutzer doppelklickt, oder die Enter-Taste drückt. Dies ist der Quellcode:
• Visual Basic
• C#
Private Sub fg_DoubleClick(ByVal sender As Object, _
ByVal e As EventArgs) Handles fg.DoubleClick
If fg.MouseCol = 0 Then
ToggleNodeState()
End If
End Sub
Private Sub fg_KeyPress(ByVal sender As Object, _
ByVal e As KeyPressEventArgs) Handles fg.KeyPress
If e.KeyChar = vbCr Then
ToggleNodeState()
End If
End Sub
Private Sub ToggleNodeState()
' if the current row is not a node, no work
Dim r As Row = fg.Rows(fg.Row)
If Not r.IsNode Then Exit Sub
' toggle collapsed state
r.Node.Collapsed = Not r.Node.Collapsed
End Sub
private void fg_DoubleClick( object sender, EventArgs e)
fg.DoubleClick {
if ( fg.MouseCol == 0) {
ToggleNodeState();
}
}
private void fg_KeyPress( object sender, KeyPressEventArgs e)
fg.KeyPress {
if ( e.KeyChar == 13) {
ToggleNodeState();
}
}
private void ToggleNodeState() {
}
• Delphi
// if the current row is not a node, no work
Row r = fg.Rows[fg.Row];
if (! r.IsNode) return;
// toggle collapsed state
r.Node.Collapsed = !r.Node.Collapsed;
procedure fg_DoubleClick(sender: System.Object;
e: System.EventArgs);
begin
If fg.MouseCol = 0 Then
ToggleNodeState;
end;
procedure fg_KeyPress(sender: System.Object;

e: KeyPressEventArgs);
begin
If e.KeyChar = #13 Then
ToggleNodeState;
end;
procedure ToggleNodeState;
var
r: Row;
begin
// if the current row is not a node, no work
r := fg.Rows[fg.Row];
If Not r.IsNode Then
exit;
// toggle collapsed state
r.Node.Collapsed := Not r.Node.Collapsed;
end;
Übung zur Gliederung · 97
Der Ereignisabwickler prüft, ob der Nutzer auf die erste Spalte doppelgeklickt oder die Enter-Taste
gedrückt hat, und ruft dann die ToggleNodeState-Routine auf. ToggleNodeState prüft, ob die aktuelle
Zeile einen Knoten besitzt und schaltet den Wert der Node.Collapsed-Eigenschaft um, wenn es eine ist.
Schritt 4: Bearbeitung erlauben/verbieten
Erinnern Sie sich, dass wir die AllowEditing-Eigenschaft der ersten Spalte im Form_Load-Ereignis auf
FALSE gesetzt haben. Daher konnte der Nutzer die Zellen der ersten Spalte nicht mehr verändern. Wir
wollen nun den Nutzer auch davon abhalten, Werte in die zweite Spalte der Knotenzeilen einzutragen.
Um dies zu tun, geben Sie folgenden Quellcode in das BeforeEdit-Ereignis ein:
• Visual Basic
• C#
Private Sub fg_BeforeEdit(ByVal sender As Object, _
ByVal e As RowColEventArgs) Handles fg.BeforeEdit
' if the current row is a node, don't edit it
Dim r As Row = fg.Rows(fg.Row)
If r.IsNode Then e.Cancel = True
End Sub
private void fg_BeforeEdit( object sender, RowColEventArgs e)
fg.BeforeEdit {
}
• Delphi
// if the current row is a node, don't edit it
Row r = fg.Rows[fg.Row];
if (r.IsNode) e.Cancel = true;
procedure fg_BeforeEdit(sender: System.Object;
e: RowColEventArgs);
var
r: Row;
begin
// if the current row is a node, don't edit it
r := fg.Rows[fg.Row];
If r.IsNode Then
e.Cancel := True;
end;

98 · FlexGrid-Übungen
Schritt 5: Quickinfo implementieren
Um diese Übung zu beenden werden wir nun Quickinfos im Gliederungsbaum integrieren. Die
Quickinfo wird den Text, der von der oben beschriebenen GetXMLData-Routine in der UserData-
Eigenschaft abgespeichert wurde, von jeder Zeile anzeigen. Sie wird also den Inhalt des „Name“-Knotens
einblenden, wenn der Nutzer mit der Maus über dessen übergeordneten Knoten fährt. Dies ist nützlich,
wenn der übergeordnete Knoten zusammengeklappt und damit der „Name“-Knoten nicht sichtbar ist.
Um Quickinfo zu implementieren, müssen Sie zunächst eine ToolTip-Steuerung dem Formular
hinzufügen. Danach fügen Sie den folgenden Quellcode ein, um das Tabellenereignis MouseMove
abzufangen:
• Visual Basic
• C#
Private Sub fg_MouseMove(ByVal sender As Object, _
ByVal e As MouseEventArgs) Handles fg.MouseMove
' check tooltip for this cell
Dim tip As String
If fg.MouseCol = 0 And fg.MouseRow > 0 Then
tip = fg.Rows(fg.MouseRow).UserData
End If
' set it if different from current
If tip ToolTip1.GetToolTip(fg) Then
ToolTip1.SetToolTip(fg, tip)
End If
End Sub
private void fg_MouseMove( object sender, MouseEventArgs e)
fg.MouseMove {
}
• Delphi
// check tooltip for this cell
string tip;
if ( fg.MouseCol == 0 && fg.MouseRow > 0) {
tip = fg.Rows[fg.MouseRow].UserData;
}
// set it if different from current
if ( tip != ToolTip1.GetToolTip(fg)) {
ToolTip1.SetToolTip(fg, tip);
}
procedure fg_MouseMove(sender: System.Object;
e: System.MouseEventArgs);
var
tip: string;
begin
// check tooltip for this cell
If (fg.MouseCol = 0) And (fg.MouseRow > 0) Then
tip := fg.Rows[fg.MouseRow].UserData;
// set it if different from current
If tip ToolTip1.GetToolTip(fg) Then
ToolTip1.SetToolTip(fg, tip);
end;
Der Quellcode beginnt mit der Überprüfung der Zelle unter dem Mauszeiger mit der MouseRow- und
MouseCol-Eigenschaft. Wenn der Mauszeiger sich in der ersten Spalte und in einer Zeile, die eine

Übung zur Datenanalyse · 99
Quickinfo enthält, befindet, dann wird der entsprechende Text abgerufen. Sonst wird die Quickinfo auf
Nothing gestellt.
Danach vergleicht die Routine den aktuellen und den neuen Quickinfotext und aktualisiert diesen wenn
nötig, indem die SetToolTip-Methode auf die tooltip-Steuerung anwendet.
Damit ist diese Übung beendet. Sie können dieses Projekt noch auf vielen Wegen erweitern, z.B. so, dass
Änderungen wieder im XML-Dokument gespeichert werden, Knoten hinzugefügt, gelöscht oder
verschoben werden können, oder dass verschiedene Formate für verschiedene Datentypen angewendet
werden.
Übung zur Datenanalyse
Diese Übung deckt einige der nützlichsten Funktionen der C1FlexGrid-Steuerung ab, um dynamische
Ansichten von Datentabellen zur Verfügung zu stellen. Die Anwendung beginnt mit einer einfachen,
datengebundenen Tabelle mit Umsatzzahlen (aus der NorthWind-Datenbank) und fügt dann die
folgenden Funktionen hinzu:
• Dynamisches Gestaltung (Spaltenreihenfolge)
• Automatische Sortierung
• Zellverbindungen
• Automatische Zwischensummen
• Gliederungsbaum
Die nachfolgende Grafik zeigt, wie die endgültige Anwendung aussehen wird. Der Nutzer kann die
ersten drei Spalten ziehen, um die Daten nach Vertriebsmitarbeitern, Ländern und Produktnamen zu
gruppieren. Wenn ein Spalte gezogen wird, dann werden die Summen automatisch neu berechnet und
die Gliederung neu aufgebaut.

100 · FlexGrid-Übungen
Schritt 1: Die C1FlexGrid-Steuerung
Erstellen Sie ein neues Visual Basic-Projekt und fügen Sie eine C1FlexGrid-Steuerung dem Formular
hinzu, indem Sie auf das C1FlexGrid-Symbol in der Symbolleiste klicken. Klicken Sie dann auf das
Formular und ziehen Sie das Objekt in die richtige Größe.
Wenn Sie die C1FlexGrid-Steuerung in der Symbolleiste nicht finden können, dann rechtsklicken Sie auf
die Symbolleiste und wählen die Option Customize Toolbox (Anpassen…) aus. Suchen Sie die
C1FlexGrid-Steuerung in der Liste der .NET-Komponenten und stellen Sie sicher, dass diese aktiviert ist.
Wenn Sie die C1FlexGrid in der Komponentenliste nicht finden können, dann müssen Sie das Programm
eventuell erneut installieren.
Als nächstes müssen Sie im .NET-Eigenschaftsfenster die folgenden Steuerungseigenschaften festlegen:
(Name) = fg
Dock = Fill
Doppelklicken Sie nun auf den Titelbereich des Formulars um das Quellcodefenster zu öffnen. Fügen Sie
folgende Anweisungen am oberen Ende der Datei ein:
• Visual Basic
• C#
Imports System.Data.OleDb
Imports C1.Win.C1FlexGrid
using System.Data.OleDb;
using C1.Win.C1FlexGrid;
• Delphi
uses System.Data.OleDb,
C1.Win.C1FlexGrid;
Damit werden die Objekte, die in der C1FlexGrid- und der OleDb-Assembly definiert sind, im Projekt
sichtbar und ersparen somit viel Schreibarbeit.
Schritt 2: Die Tabelle initialisieren und mit Daten füllen
Fügen Sie den folgenden Quellcode in das Form_Load-Ereignis ein, um die Tabelle zu erstellen und mit
den zu analysierenden Umsatzdaten zu füllen:
• Visual Basic
Private Sub Form1_Load(ByVal sender As System.Object, _
ByVal e As EventArgs) Handles MyBase.Load
' set up grid layout/behavior
fg.AllowEditing = False
fg.AllowSorting = AllowSortingEnum.None
fg.AllowMerging = AllowMergingEnum.Nodes
fg.SelectionMode = SelectionModeEnum.Cell
fg.ExtendLastCol = True
fg.Cols(0).Width = fg.Cols.DefaultSize / 4
fg.Tree.Style = TreeStyleFlags.Simple
fg.Tree.Column = 1
' set up grid styles
fg.Styles.Normal.Border.Style = BorderStyleEnum.None
fg.Styles.Normal.Trimming = StringTrimming.EllipsisCharacter
Dim s As CellStyle = fg.Styles(CellStyleEnum.GrandTotal)
s.BackColor = Color.Black

• C#
s.ForeColor = Color.White
s = fg.Styles(CellStyleEnum.Subtotal0)
s.BackColor = Color.Gold
s.ForeColor = Color.Black
s = fg.Styles(CellStyleEnum.Subtotal1)
s.BackColor = Color.Khaki
s.ForeColor = Color.Black
s = fg.Styles(CellStyleEnum.Subtotal2)
s.BackColor = Color.LightGoldenrodYellow
s.ForeColor = Color.Black
' bind flex to data source
fg.DataSource = GetDataSource()
' prevent user from dragging last three columns
fg.Cols(4).AllowDragging = False
fg.Cols(5).AllowDragging = False
fg.Cols(6).AllowDragging = False
End Sub
Übung zur Datenanalyse · 101
private void Form1_Load( System.object sender, EventArgs e) base.Load
{
}
• Delphi
// set up grid layout/behavior
fg.AllowEditing = False
fg.AllowSorting = AllowSortingEnum.None;
fg.AllowMerging = AllowMergingEnum.Nodes;
fg.SelectionMode = SelectionModeEnum.Cell;
fg.ExtendLastCol = true;
fg.Cols[0].Width = fg.Cols.DefaultSize / 4;
fg.Tree.Style = TreeStyleFlags.Simple;
fg.Tree.Column = 1;
// set up grid styles
fg.Styles.Normal.Border.Style = BorderStyleEnum.None;
fg.Styles.Normal.Trimming = StringTrimming.EllipsisCharacter;
CellStyle s = fg.Styles[CellStyleEnum.GrandTotal];
s.BackColor = Color.Black;
s.ForeColor = Color.White;
s = fg.Styles[CellStyleEnum.Subtotal0];
s.BackColor = Color.Gold;
s.ForeColor = Color.Black;
s = fg.Styles[CellStyleEnum.Subtotal1];
s.BackColor = Color.Khaki;
s.ForeColor = Color.Black;
s = fg.Styles[CellStyleEnum.Subtotal2];
s.BackColor = Color.LightGoldenrodYellow;
s.ForeColor = Color.Black;
// bind flex to data source
fg.DataSource = GetDataSource();
// prevent user from dragging last three columns
fg.Cols[4].AllowDragging = false;
fg.Cols[5].AllowDragging = false;
fg.Cols[6].AllowDragging = false;
procedure Form1_Load(sender: System.Object;
e: System.EventArgs);

102 · FlexGrid-Übungen
var
s: CellStyle;
begin
// set up grid layout/behavior
fg.AllowEditing = False
fg.AllowSorting := AllowSortingEnum.None;
fg.AllowMerging := AllowMergingEnum.Nodes;
fg.SelectionMode := SelectionModeEnum.Cell;
fg.ExtendLastCol := True;
fg.Cols[0].Width := fg.Cols.DefaultSize / 4;
fg.Tree.Style := TreeStyleFlags.Simple;
fg.Tree.Column := 1;
// set up grid styles
fg.Styles.Normal.Border.Style := BorderStyleEnum.None;
fg.Styles.Normal.Trimming := StringTrimming.EllipsisCharacter;
s := fg.Styles[CellStyleEnum.GrandTotal];
s.BackColor := Color.Black;
s.ForeColor := Color.White;
s = fg.Styles[CellStyleEnum.Subtotal0];
s.BackColor := Color.Gold;
s.ForeColor := Color.Black;
s := fg.Styles[CellStyleEnum.Subtotal1];
s.BackColor := Color.Khaki;
s.ForeColor := Color.Black;
s := fg.Styles[CellStyleEnum.Subtotal2];
s.BackColor := Color.LightGoldenrodYellow;
s.ForeColor := Color.Black;
// bind flex to data source
fg.DataSource := GetDataSource;
// prevent user from dragging last three columns
fg.Cols[4].AllowDragging := False;
fg.Cols[5].AllowDragging := False;
fg.Cols[6].AllowDragging := False;
end;
Die Routine beginnt die Tabelle und einige Formate zu erstellen. Diese Eigenschaften können Sie, wenn
gewünscht, auch während der Designtime mit den integrierten Tabelleneditoren festlegen.
Nachdem die Tabelle erzeugt wurde, bindet die Routine diese an die, von der nachfolgend aufgelisteten
GetDataSource-Methode erstellten Datenquelle. Zuletzt werden noch die drei hinteren Spalten auf ihre
Position fixiert, indem ihre AllowDragging-Eigenschaft auf FALSE gestellt wird, so dass der Nutzer
nicht nach den Daten in diesen Spalten gruppieren kann. Die Werte in diesen Spalten sind in jeder Zeile
verschieden.
Die GetDataSource-Methode erstellt die Datentabelle, die von der Steuerung angezeigt wird. Diese
Routine ist, außer der SQL-Anweisung, die die Daten abruft, recht einfach. Die meisten Anwender
schreiben diesen SQL-Befehl nicht selbst, sondern verwenden einen Visual Designer, wie zum Beispiel
den in Visual Studio oder Microsoft Access.
Beachten Sie, dass Sie eventuell die Verbindungsanweisung etwas abändern müssen, weil diese einen
Verweis auf die NorthWind-Datenbank beinhaltet und die Dateien auf Ihrem System vielleicht in einem
anderen Verzeichnis liegen:
• Visual Basic
Private Function GetDataSource() As DataTable
' set up connection string
Dim conn As String = "Provider=Microsoft.Jet.OLEDB.4.0;" & _

"Data Source=C:\Program Files\Microsoft Visual
Studio\VB98\NWIND.MDB;"
& _
• C#
Übung zur Datenanalyse · 103
' set up SQL statement
Dim rs As String = _
"SELECT Employees.LastName,Orders.ShipCountry," & _
"Categories.CategoryName,Products.ProductName,Orders.OrderDate,"
"[Quantity]*[Products].[UnitPrice] AS [Sale Amount] " & _
"FROM (Categories INNER JOIN Products " & _
"ON Categories.CategoryID = Products.CategoryID) " & _
"INNER JOIN ((Employees INNER JOIN Orders " & _
"ON Employees.EmployeeID = Orders.EmployeeID) " & _
"INNER JOIN [Order Details] " & _
"ON Orders.OrderID = [Order Details].OrderID) " & _
"ON Products.ProductID = [Order Details].ProductID "
"ORDER BY Employees.LastName,Orders.ShipCountry," & _
"Categories.CategoryName;"
' retrieve data into DataSet
Dim da As OleDbDataAdapter = New OleDbDataAdapter(rs, conn)
Dim ds As DataSet = New DataSet()
da.Fill(ds)
' return data table
GetDataSource = ds.Tables(0)
End Function
private DataTable GetDataSource() {
// set up connection string
string conn = "Provider=Microsoft.Jet.OLEDB.4.0;" + "Data
Source=C:\Program Files\Microsoft Visual Studio\VB98\NWIND.MDB;";
+
// set up SQL statement
string rs =
"SELECT Employees.LastName,Orders.ShipCountry," +
"Categories.CategoryName,Products.ProductName,Orders.OrderDate,"
"[Quantity]*[Products].[UnitPrice] AS [Sale Amount] " +
"FROM (Categories INNER JOIN Products " +
"ON Categories.CategoryID = Products.CategoryID) " +
"INNER JOIN ((Employees INNER JOIN Orders " +
"ON Employees.EmployeeID = Orders.EmployeeID) " +
"INNER JOIN [Order Details] " +
"ON Orders.OrderID = [Order Details].OrderID) " +
"ON Products.ProductID = [Order Details].ProductID " +
"ORDER BY Employees.LastName,Orders.ShipCountry," +
"Categories.CategoryName;";
// retrieve data into DataSet
OleDbDataAdapter OleDbDataAdapter da = new OleDbDataAdapter(rs,
conn);
DataSet DataSet ds = new DataSet();
da.Fill(ds);
}
// return data table
GetDataSource = ds.Tables[0]

104 · FlexGrid-Übungen
• Delphi
function Class1.GetDataSource: DataTable;
var
DataSet: DataSet;
OleDbDataAdapter: OleDbDataAdapter;
rs: string;
conn: string;
begin
conn := ('Provider=Microsoft.Jet.OLEDB.4.0;' + 'Data
Source=C:\Program Files Microsoft Visual Studio B98 WIND.MDB;');
+
// set up SQL statement
rs :=
'SELECT Employees.LastName,Orders.ShipCountry,' +
'Categories.CategoryName,Products.ProductName,Orders.OrderDate,'
'[Quantity]*[Products].[UnitPrice] AS [Sale Amount] ' +
'FROM (Categories INNER JOIN Products ' +
'ON Categories.CategoryID = Products.CategoryID) ' +
'INNER JOIN ((Employees INNER JOIN Orders ' +
'ON Employees.EmployeeID = Orders.EmployeeID) ' +
'INNER JOIN [Order Details] ' +
'ON Orders.OrderID = [Order Details].OrderID) ' +
'ON Products.ProductID = [Order Details].ProductID ' +
'ORDER BY Employees.LastName,Orders.ShipCountry,' +
'Categories.CategoryName;';
da := OleDbDataAdapter.Create(rs, conn);
ds := DataSet.Create;
da.Fill(ds);
Self.GetDataSource := ds.Tables[0];
end;
Wenn Sie das Projekt nun starten, dann sehen Sie eine rohe Tabelle, in der Sie die Spalten verschieben
und sich durch die Daten klicken können. Da die Daten immer noch unstrukturiert sind und die Tabelle
mehrere tausend Einträge enthält, ist es schwer, einen Überblick über diese zu erhalten.
Schritt 3: Automatische Sortierung
Der erste Schritt in Richtung organisierte Daten ist die Sortierung. Zusätzlich würden wir gern die Daten
immer dann automatisch sortieren, wenn der Nutzer die Spaltenreihenfolge verändert.
Wenn der Nutzer die Spalten neu anordnet, dann startet die C1FlexGrid-Steuerung das
AfterDragColumn-Ereignis. Wir werden nun in dieses Ereignis einen Ereignisabwickler einzufügen, der
die Daten in der zugrunde liegenden Datentabelle sortiert. Wenn sich die Tabelle im ungebundenen
Modus befinden würde, dann hätten wir an dieser Stelle die Sort-Methode verwendet.
Der Quellcode ist recht einfach:
• Visual Basic
Private Sub fg_AfterDragColumn(ByVal sender As Object, _
ByVal e As DragRowColEventArgs) Handles fg.AfterDragColumn
' sort the recordset when the user drags columns
' this will cause a data refresh, removing all subtotals and
' firing the AfterDataRefresh event, which rebuilds the subtotals.
Dim sort As String = fg.Cols(1).Name & ", " & _
fg.Cols(2).Name & ", " & _
fg.Cols(3).Name
Dim dt As DataTable = fg.DataSource

• C#
dt.DefaultView.Sort = sort
End Sub
Übung zur Datenanalyse · 105
private void fg_AfterDragColumn( object sender, DragRowColEventArgs e)
fg.AfterDragColumn {
}
• Delphi
// sort the recordset when the user drags columns
// this will cause a data refresh, removing all subtotals and
// firing the AfterDataRefresh event, which rebuilds the subtotals.
string sort = fg.Cols[1].Name + ", " +
fg.Cols[2].Name + ", " +
fg.Cols(3).Name;
DataTable dt = fg.DataSource;
dt.DefaultView.Sort = sort;
procedure fg_AfterDragColumn(sender: Object;
e: DragRowColEventArgs);
var
sort: string;
dt: DataTable;
begin
// sort the recordset when the user drags columns
// this will cause a data refresh, removing all subtotals and
// firing the AfterDataRefresh event, which rebuilds the subtotals.
sort := fg.Cols[1].Name + ', ' +
fg.Cols[2].Name + ', ' +
fg.Cols[3].Name;
dt := fg.DataSource;
dt.DefaultView.Sort := sort;
end;
Starten Sie das Projekt und versuchen Sie die ersten drei Spalten neu anzuordnen, indem Sie deren
Überschriften an andere Stellen ziehen. Immer wenn Sie eine Spalte verschieben, werden die Daten nun
automatisch neu sortiert und können daher leichter interpretiert werden.
Im nächsten Schritt werden wir Zwischensummen und einen Gliederungsbaum hinzufügen.
Schritt 4: Zwischensumme und Gliederungsbaum
Wenn sich die Tabelle im gebunden Modus befindet, dann wird nach jeder Änderung der Datenquelle
das AfterDataRefresh-Ereignis gestartet. Dieses Ereignis eignet sich sehr gut, um den Quellcode für das
Einfügen von Zwischensummen und den Aufbau eines Gliederungsbaumes einzubringen.
Dies ist der AfterDataRefresh-Ereignisabwickler:
• Visual Basic
Private Sub fg_AfterDataRefresh(ByVal sender As Object, _
ByVal e As ListChangedEventArgs) Handles fg.AfterDataRefresh
' total on Sale Amount
Dim totalOn As Integer = fg.Cols("Sale Amount").SafeIndex
Dim caption As String = "Total for {0}"
' calculate three levels of totals
fg.Subtotal(AggregateEnum.Sum, 0, 1, totalOn, caption)
fg.Subtotal(AggregateEnum.Sum, 1, 2, totalOn, caption)
fg.Subtotal(AggregateEnum.Sum, 2, 3, totalOn, caption)
' collapse outline to level 2

106 · FlexGrid-Übungen
• C#
fg.Tree.Show(2)
' autosize the grid to accommodate tree
fg.AutoSizeCols(1, 1, 1000, 3, 30, AutoSizeFlags.IgnoreHidden)
End Sub
private void fg_AfterDataRefresh( object sender, ListChangedEventArgs
e) fg.AfterDataRefresh {
}
• Delphi
// total on Sale Amount
int totalOn = fg.Cols["Sale Amount"].SafeIndex;
string caption = "Total for {0}";
// calculate three levels of totals
fg.Subtotal(AggregateEnum.Sum, 0, 1, totalOn, caption);
fg.Subtotal(AggregateEnum.Sum, 1, 2, totalOn, caption);
fg.Subtotal(AggregateEnum.Sum, 2, 3, totalOn, caption);
// collapse outline to level 2
fg.Tree.Show(2);
// autosize the grid to accommodate tree
fg.AutoSizeCols(1, 1, 1000, 3, 30, AutoSizeFlags.IgnoreHidden);
procedure fg_AfterDataRefresh(sender: System.Object;
e: ListChangedEventArgs);
var
totalOn: Integer;
caption: string;
begin
// total on Sale Amount
totalOn := fg.Cols['Sale Amount'].SafeIndex;
caption := 'Total for {0}';
// calculate three levels of totals
fg.Subtotal(AggregateEnum.Sum, 0, 1, totalOn, caption);
fg.Subtotal(AggregateEnum.Sum, 1, 2, totalOn, caption);
fg.Subtotal(AggregateEnum.Sum, 2, 3, totalOn, caption);
// collapse outline to level 2
fg.Tree.Show(2);
// autosize the grid to accommodate tree
fg.AutoSizeCols(1, 1, 1000, 3, 30, AutoSizeFlags.IgnoreHidden);
end;
Dieser recht einfache Quelltext beginnt mit der Ermittlung des Index der „Sale Amount“-Spalte. In
diesem Beispiel ist dieser Index immer der gleiche (Spalte 6). Den Index zu ermitteln ist üblicherweise
besser als diesen fix im Quellcode zu hinterlegen, da er sich ändert, wenn einige Felder in der SQL-
Anweisung hinzugefügt werden.
Der Quellcode ruft anschließend die Subtotal-Methode auf, um die Daten zu gruppieren und neue Zeilen
mit den entsprechenden Zwischensummen einzufügen. Die neuen Zeilen werden automatisch als
Gliederungsknoten formatiert und deren IsNode-Eigenschaft steht auf TRUE, so dass die
Zwischensummen eingeklappt werden können.

Übung zur Datenanalyse · 107
Starten Sie nun das Projekt erneut und verschieben Sie einige Spalten. Sie können nun die Summen für
Länder, Produktkategorie und Vertriebsmitarbeiter sehen. Sie können außerdem die Gliederung
erweitern, um detailliertere Daten in unteren Ebenen einzusehen.
Beachten Sie auch, dass die Tabelle noch bearbeitbar ist. Wenn Sie einen Wert in der „Sale Amount“-
Spalte ändern, dann wird automatisch das AfterDataRefresh-Ereignis gestartet und die Summen werden
entsprechend aktualisiert.
Damit ist diese Übung beendet.

C1FlexGrid-Referenzverzeichnis
C1FlexGrid-Klasse · 109
Die C1FlexGrid-Komponente stellt die folgenden Eigenschaften, Ereignisse und Methoden zur
Verfügung:
C1FlexGrid-Klasse
Mit der C1FlexGrid-Steuerung können Sie tabellarische Daten anzeigen, bearbeiten, gruppieren und
zusammenfassen. Die Tabellensteuerung kann an eine Datenquelle gebunden sein, oder Sie verwaltet
ihre eigenen Daten.
Alle C1FlexGrid-Mitglieder
C1FlexGrid-Eigenschaften (public)
AllowAddNew Gibt zurück oder legt fest, ob die Tabelle eine Vorlage
für eine neue Zeile nach der letzten Zeile anzeigt.
AllowDelete Gibt zurück oder legt fest, ob die Tabelle die Tastatur
überwacht und die Entfernen-Taste kontrollieren soll.
AllowDragging
Unterstützt vom .NET-Compact-Framework.
AllowEditing
Unterstützt vom .NET-Compact-Framework.
Legt fest, ob der Nutzer Spalten/Zeilen mit der Maus
ziehen darf.
Legt fest, ob der Nutzer Zellen bearbeiten darf.
AllowFreezing Legt fest, ob der Nutzer Spalten und Zeilen mit der Maus
fixieren darf.
AllowMerging
Unterstützt vom .NET-Compact-Framework.
AllowResizing
Unterstützt vom .NET-Compact-Framework.
AllowSorting
Unterstützt vom .NET-Compact-Framework.
Legt fest, ob Zellen mit ähnlichem Inhalt verbunden
werden.
Legt fest, ob der Nutzer die Größe von Spalten und
Zeilen mit der Maus verändern darf.
Legt fest, ob der Nutzer Spalten mit der Maus sortieren
darf.
AutoClipboard Gibt zurück oder legt fest, ob die Tabelle die
Zwischenablagefunktionen steuern soll und automatisch
die Operationen Ausschneiden, Kopieren, Einfügen und
Löschen durchführen soll.
AutoGenerateColumns Legt fest, ob die Tabelle ihre Spalten aktualisiert, wenn
sie einer neuen Datenquelle zugeordnet wurde.
AutoResize Gibt zurück oder legt fest, ob die Spaltenbreiten
automatisch angepasst werden, wenn Daten geladen
werden.
AutoSearch
Unterstützt vom .NET-Compact-Framework.
AutoSearchDelay
Unterstützt vom .NET-Compact-Framework.
Legt fest, ob die Tabelle den Cursor bewegen soll, wenn
diese nach Einträgen sucht, während der Nutzer tippt.
Legt die zu verstreichende Zeit fest (in Sekunden), bevor
der AutoSearch-Puffer zurückgesetzt wird.

110 · C1FlexGrid-Referenzverzeichnis
BottomRow
Unterstützt vom .NET-Compact-Framework.
Gibt die letzte, sichtbare Zeile einer Tabelle zurück.
BorderStyle Gibt/legt den Rahmen-Stil der Steuerung zurück/fest.
CellButtonImage
Unterstützt vom .NET-Compact-Framework.
Clip
Unterstützt vom .NET-Compact-Framework.
ClipSeparators
Unterstützt vom .NET-Compact-Framework.
Col
Unterstützt vom .NET-Compact-Framework.
Cols
Unterstützt vom .NET-Compact-Framework.
ColSel
Unterstützt vom .NET-Compact-Framework.
ComboList
Unterstützt vom .NET-Compact-Framework.
CursorCell
Unterstützt vom .NET-Compact-Framework.
Legt die Grafik auf einer Zellschaltfläche fest.
Gibt/legt den Inhalt eines Zellbereichs zurück/fest.
Gibt/legt die Trennzeichen für Zeilen und Spalten im
Clip-Eintrag zurück/fest.
Gibt/legt den Index einer ausgewählten Spalte
zurück/fest.
Gibt alle Spalten einer Tabelle zurück.
Gibt/legt den Index der letzten Spalte in der aktuellen
Auswahl zurück/fest.
Gibt/legt die Liste der Elemente, die von einem Dropdown-Editor
verwendet werden zurück/fest.
Gibt ein CellRange-Objekt zurück, dass die Ankerzelle
in der aktuellen Auswahl enthält.
CustomComparer Gibt/legt ein benutzerdefiniertes IComparer-Objekt,
dass von der Tabelle für Gruppierung, Zellverbindung
und Suchoperationen verwendet wird, zurück/fest.
DataMember Gibt/legt eine bestimmte Liste eines DataSource-
Objekts, das die Tabelle anzeigen soll, zurück/fest.
DataSource
Unterstützt vom .NET-Compact-Framework.
Gibt/legt die Datenquelle der Steuerung zurück/fest.
DoubleBuffer Wenn diese Eigenschaft auf TRUE steht, dann wird die
Tabelle in einem Puffer gezeichnet und danach das
Ergebnis auf dem Bildschirm ausgegeben. Damit wird
mögliches Flackern verhindert, wenn die Tabelle von der
Steuerung erneut gezeichnet wird.
DragMode
Unterstützt vom .NET-Compact-Framework.
DrawMode
Unterstützt vom .NET-Compact-Framework.
DropMode
Unterstützt vom .NET-Compact-Framework.
EditMask
Unterstützt vom .NET-Compact-Framework.
Editor
Unterstützt vom .NET-Compact-Framework.
Gibt/legt einen Wert, der festlegt, ob der Nutzer Daten
aus der Steuerung ziehen kann, zurück/fest.
Legt fest, ob benutzerdefinierte Zeichen für
Tabellenzellen bereitgestellt werden.
Gibt/legt einen Wert zurück/fest, der festlegt, ob die
Steuerung Daten akzeptiert, die der Nutzer auf die
Tabelle zieht.
Gibt/legt die Eingabemaske zurück/fest, wenn Zellen
bearbeitet werden.
Gibt den aktuellen Zelleditor zurück, oder legt eine
Steuerung, die als Editor verwendet werden soll, fest
(kann nur während des StartEdit-Ereignisses gesetzt
werden).

C1FlexGrid-Klasse · 111
EditOptions Beinhaltet Flags, die das Verhalten der integrierten
Editoren anpassen können.
ExtendLastCol
Unterstützt vom .NET-Compact-Framework.
FocusRect
Unterstützt vom .NET-Compact-Framework.
Legt fest, ob die Breite der letzten Spalte an den zur
Verfügung stehenden Platz in der Steuerung angepasst
werden soll.
Legt den rechteckigen Fokustyp fest, der um die aktuelle
Zelle gelegt wird.
GetCellCheck Gibt einen Wert zurück, der anzeigt, ob die Zelle ein
Kontrollkästchen beinhaltet.
HighLight
Unterstützt vom .NET-Compact-Framework.
Item
Unterstützt vom .NET-Compact-Framework.
KeyActionEnter
Unterstützt vom .NET-Compact-Framework.
KeyActionTab
Unterstützt vom .NET-Compact-Framework.
LeftCol
Unterstützt vom .NET-Compact-Framework.
MouseCol
Unterstützt vom .NET-Compact-Framework.
MouseRow
Unterstützt vom .NET-Compact-Framework.
Legt fest, wann die ausgewählte Zelle markiert wird.
Gibt/legt die Daten in einer Tabellenzelle zurück/fest.
Legt die auszuführende Aktion fest, wenn der Nutzer die
Enter-Taste drückt.
Legt die auszuführende Aktion fest, wenn der Nutzer die
Tabulator-Taste drückt.
Gibt/legt den Index der am weitesten links liegenden,
nicht fixierten Spalte zurück/fest.
Gibt/legt den Index der Spalte unter dem Mauszeiger
zurück/fest.
Gibt/legt den Index der Zeile unter dem Mauszeiger
zurück/fest.
PrintParameters Gibt ein GridPrinter-Objekt zurück, das die
Druckparameter der Tabelle festlegt.
Redraw
Unterstützt vom .NET-Compact-Framework.
RightCol
Unterstützt vom .NET-Compact-Framework.
Row
Unterstützt vom .NET-Compact-Framework.
Rows
Unterstützt vom .NET-Compact-Framework.
RowSel
Unterstützt vom .NET-Compact-Framework.
Legt fest, ob die Tabelle ihren Inhalt zeichnen soll.
Gibt den Index der am weitesten rechtsstehenden Spalte
zurück.
Gibt/legt den Index der ausgewählten Zeile zurück/fest.
Gibt alle Zeilen der Tabelle zurück.
Gibt/legt den Index der letzten Zeile der aktuellen
Auswahl zurück/fest.
ScrollBars Gibt zurück/legt fest welche Bildlaufleisten in der Tabelle
angezeigt werden.
ScrollPosition Gibt/legt die Bildlaufleistenposition zurück/fest.
ScrollTrack Legt das Tabellenverhalten fest, während der Nutzer die
Bildlaufleisten zieht.
ScrollTips Gibt zurück/legt fest, ob Quickinfos angezeigt werden,
wenn der Nutzer die vertikale Bildlaufleiste zieht.

112 · C1FlexGrid-Referenzverzeichnis
ScrollTipText Gibt/legt die Quickinfo zurück/fest, die angezeigt wird,
wenn der Nutzer die vertikale Bildlaufleiste zieht.
Selection
Unterstützt vom .NET-Compact-Framework.
SelectionMode
Unterstützt vom .NET-Compact-Framework.
Gibt ein CellRange-Objekt mit der aktuellen Auswahl
zurück.
Legt das Auswahlverhalten der Tabelle fest.
SetCellCheck Legt den Zustand eines Kontrollkästchens in einer Zelle
fest.
ShowButtons Legt fest, wann die Tabelle Auswahl- und Popup-
Schaltflächen in bearbeitbaren Zellen anzeigen soll.
ShowCellLabels Zeigt eine Art Quickinfo an, wenn der Mauszeiger über
einer Zelle steht, die zu klein für ihren Inhalt ist.
ShowCursor Legt fest, ob die Tabelle eine
Datensatzmarkierungsgrafik anzeigen soll.
Styles
Unterstützt vom .NET-Compact-Framework.
Gibt alle Zellformate in einer Tabelle zurück.
SubTotalPosition Legt fest, ob die Subtotal-Methode die Knotenzeilen
unter oder über den Daten, die zusammengefasst
werden, einfügt.
TopRow
Unterstützt vom .NET-Compact-Framework.
Tree
Unterstützt vom .NET-Compact-Framework.
C1FlexGrid-Methoden (public)
AddItem
Unterstützt vom .NET-Compact-Framework.
Aggregate
Unterstützt vom .NET-Compact-Framework.
AutoSizeCol
Unterstützt vom .NET-Compact-Framework.
AutoSizeCols
Unterstützt vom .NET-Compact-Framework.
AutoSizeRow
Unterstützt vom .NET-Compact-Framework.
AutoSizeRows
Unterstützt vom .NET-Compact-Framework.
Clear
Unterstützt vom .NET-Compact-Framework.
CreateImage
Unterstützt vom .NET-Compact-Framework.
Gibt/legt den Index der obersten sichtbaren und nicht
fixierten Zeilen zurück/fest.
Gibt das GridTree-Objekt zurück, das die Ansicht des
Gliederungsbaums in einer Tabelle steuert.
Fügt eine neue Zeile der Tabelle hinzu und füllt
diese mit den gegebenen Daten.
Berechnet aggregierte Statistiken für einen
Zellbereich.
Passt die Breite der aktuellen Spalte an ihre Daten
an.
Passt die Breite aller Spalten an ihre Daten an.
Passt die Höhe einer einzelnen Zeile an ihre Daten
an.
Passt die Höhe einer Auswahl von Zeilen an ihre
Daten an.
Löscht die Inhalte einer Tabelle.
Erstellt eine Grafik von der gesamten Tabelle oder
einer Auswahl.

FindRow
Unterstützt vom .NET-Compact-Framework.
FinishEditing
Unterstützt vom .NET-Compact-Framework.
GetCellCheck
Unterstützt vom .NET-Compact-Framework.
GetCellImage
Unterstützt vom .NET-Compact-Framework.
GetCellRange
Unterstützt vom .NET-Compact-Framework.
GetCellRect
Unterstützt vom .NET-Compact-Framework.
GetCellStyle
Unterstützt vom .NET-Compact-Framework.
GetCellStyleDisplay
Unterstützt vom .NET-Compact-Framework.
GetData
Unterstützt vom .NET-Compact-Framework.
GetDataDisplay
Unterstützt vom .NET-Compact-Framework.
GetMergedRange
Unterstützt vom .NET-Compact-Framework.
C1FlexGrid-Klasse · 113
Sucht eine Zeile, die eine gegebene Zeichenkette
oder ein gegebenes Objekt enthält.
Beendet die Bearbeitung der aktuellen Zelle und
den Bearbeitungsmodus der Tabelle.
Gibt den Zustand eines Kontrollkästchens in einer
Tabellenzelle zurück.
Gibt die einer Zelle zugeordnete Grafik zurück.
Gibt ein CellRange-Objekt zurück, mit dem eine
Auswahl formatiert und verändert werden kann.
Gibt ein Rectangle-Objekt mit den Koordinaten der
Zellen auf dem Bildschirm zurück.
Gibt ein benutzerdefiniertes, einer bestimmten Zelle
zugeordnetes Format zurück, oder „null“, wenn
diese kein eigenes Format besitzt.
Gibt das Format zurück, das für das Rendern der
Zelle verwendet wird.
Gibt die Daten einer Tabellenzelle zurück.
Gibt die Daten einer Tabellenzelle als Zeichenkette
zurück.
Gibt die Auswahl der mit einer gegeben Zelle
verbundenen Zellen zurück.
HitTest Gibt Informationen über die Steuerung an einem
gegebenen Punkt auf der Steuerungsoberfläche
zurück.
Invalidate
Unterstützt vom .NET-Compact-Framework.
Erklärt einen bestimmten Teil der Tabelle als
ungültig und gibt eine Farbnachricht an die
Steuerung aus.
LoadExcel Lädt ein Arbeitsblatt aus einer Microsoft Excel-Datei
(*.xls).
LoadExcelSheetNames Gibt eine Liste aller Arbeitsblätter einer Microsoft
Excel-Datei zurück (*.xls).
LoadGrid Lädt eine Tabelle aus einer Datei.
PrintGrid
Unterstützt vom .NET-Compact-Framework.
Druckt die Tabelle und zeigt optional ein
Druckvorschaufenster an.
RemoveItem Löscht eine Zeile in der Steuerung.
SaveExcel Speichert die Tabelle in einer Microsoft Excel-Datei
(*.xls).
SaveGrid Speichert die Tabelle in eine Datei.
Select
Unterstützt vom .NET-Compact-Framework.
Wählt eine oder mehrere Zellen aus.

114 · C1FlexGrid-Referenzverzeichnis
SetCellImage
Unterstützt vom .NET-Compact-Framework.
SetCellStyle
Unterstützt vom .NET-Compact-Framework.
SetCellCheck
Unterstützt vom .NET-Compact-Framework.
SetData
Unterstützt vom .NET-Compact-Framework.
Ordnet eine Grafik einer Zelle zu.
Ordnet einen eigenen CellStyle der Zelle zu.
Legt den Zustand eines Kontrollkästchens, dass in
einer Zelle angezeigt wird, fest.
Ordnet Daten einer Tabellenzelle zu.
SetDataBinding Stellt die DataSource- und DataMember-
Eigenschaften ein.
ShowCell
Unterstützt vom .NET-Compact-Framework.
Scrollt die Tabelle, so dass eine bestimmt Zelle auf
dem Bildschirm angezeigt wird.
ShowSortAt Zeigt ein Sortierungszeichen in einer bestimmten
Spalte.
Sort
Unterstützt vom .NET-Compact-Framework.
StartEditing
Unterstützt vom .NET-Compact-Framework.
Sortiert die gesamte Tabelle oder eine Auswahl an
Zeilen, basierend auf dem Inhalt einer oder
mehrerer Spalten.
Versetzt die Tabelle in den Bearbeitungsmodus und
beginnt die Zelle zu bearbeiten.
Subtotal Gruppiert und summiert Zeilen nach ihrem Inhalt.
C1FlexGrid-Ereignisse (public)
AfterAddRow Wird gestartet, wenn die AllowAddNew-
Eigenschaft auf TRUE steht, und nachdem der
Nutzer eine neue Zeile in die Tabelle einfügt.
AfterDataRefresh
Unterstützt vom .NET-Compact-Framework.
Wird im gebundenen Modus gestartet, nachdem
sich die Tabelle durch die Änderung der
Datenquelle verändert.
AfterDeleteRow Wird gestartet, wenn die AllowDelete-Eigenschaft
auf TRUE steht, und nachdem der Nutzer eine Zeile
in der Tabelle gelöscht hat.
AfterDragColumn
Unterstützt vom .NET-Compact-Framework.
AfterDragRow
Unterstützt vom .NET-Compact-Framework.
AfterEdit
Unterstützt vom .NET-Compact-Framework.
Wird gestartet, nachdem der Nutzer eine Spalte mit
der Maus verschoben hat.
Wird gestartet, nachdem der Nutzer eine Zeile mit
der Maus verschoben hat.
Wird gestartet, nachdem der Nutzer die Zelle fertig
bearbeitet hat.
AfterFreezeColumn Wird gestartet, nachdem der Nutzer Spalten mit der
Maus fixiert hat.
AfterFreezeRow Wird gestartet, nachdem der Nutzer Zeilen mit der
Maus fixiert hat.

AfterResizeColumn
Unterstützt vom .NET-Compact-Framework.
AfterResizeRow
Unterstützt vom .NET-Compact-Framework.
AfterRowColChange
Unterstützt vom .NET-Compact-Framework.
AfterScroll
Unterstützt vom .NET-Compact-Framework.
AfterSelChange
Unterstützt vom .NET-Compact-Framework.
AfterSort
Unterstützt vom .NET-Compact-Framework.
C1FlexGrid-Klasse · 115
Wird gestartet, nachdem der Nutzer die Breite von
Spalten verändert hat.
Wird gestartet, nachdem der Nutzer die Höhe von
Zeilen verändert hat.
Wird gestartet, nachdem der Auswahlanker auf eine
andere Zelle festgelegt wurde.
Wird gestartet, nachdem die Tabelle gescrollt
wurde.
Wird gestartet, nachdem sich die Auswahl geändert
hat.
Wird gestartet, nachdem die Spalte durch einen
Klick des Nutzers auf die Überschrift sortiert wurde.
BeforeAddRow Wird gestartet, wenn die AllowAddNew-
Eigenschaft auf TRUE steht, bevor der Nutzer eine
neue Zeile in die Tabelle einfügt.
BeforeAutoSizeColumn Wird gestartet, bevor eine Spalte ihre Breite
aufgrund eines Doppelklicks automatisch anpasst.
BeforeAutoSizeRow Wird gestartet, bevor eine Zeile ihre Höhe aufgrund
eines Doppelklicks automatisch anpasst.
BeforeDeleteRow Wird gestartet, wenn die AllowDelete-Eigenschaft
auf TRUE steht, bevor der Nutzer eine Zeile in der
Tabelle löscht.
BeforeDragColumn
Unterstützt vom .NET-Compact-Framework.
BeforeDragRow
Unterstützt vom .NET-Compact-Framework.
BeforeEdit
Unterstützt vom .NET-Compact-Framework.
Wird gestartet, bevor der Nutzer eine Spalte mit der
Maus verschiebt und sich die Spalte an ihrer neuen
Position befindet.
Wird gestartet, bevor der Nutzer eine Zeile mit der
Maus verschieben will und sich die Zeile an ihrer
neuen Position befindet.
Wird gestartet, bevor die Steuerung in den
Bearbeitungsmodus geht.
BeforeFreezeColumn Wird gestartet, bevor der Nutzer Spalten mit der
Maus fixiert.
BeforeFreezeRow Wird gestartet, bevor der Nutzer Zeilen mit der
Maus fixiert.
BeforeMouseDown
Unterstützt vom .NET-Compact-Framework.
BeforePageBreak
Unterstützt vom .NET-Compact-Framework.
BeforeResizeColumn
Unterstützt vom .NET-Compact-Framework.
BeforeResizeRow
Unterstützt vom .NET-Compact-Framework.
BeforeRowColChange
Unterstützt vom .NET-Compact-Framework.
Wird gestartet, bevor die Steuerung das
MouseDown-Ereignis verarbeitet.
Wird gestartet, während die Tabelle gedruckt wird,
um die Seitenumbrüche zu steuern.
Wird gestartet, bevor die Breite von Spalten
verändert wird.
Wird gestartet, bevor die Höhe von Zeilen verändert
wird.
Wird gestartet, bevor eine andere Zelle zur
aktuellen Zelle (Row, Col) wird.

116 · C1FlexGrid-Referenzverzeichnis
BeforeScroll
Unterstützt vom .NET-Compact-Framework.
BeforeScrollTip
Unterstützt vom .NET-Compact-Framework.
BeforeSelChange
Unterstützt vom .NET-Compact-Framework.
BeforeSort
Unterstützt vom .NET-Compact-Framework.
BeginPrint
Unterstützt vom .NET-Compact-Framework.
Wird gestartet, bevor die Steuerung scrollt.
Wird gestartet, bevor ein Scroll-Tip angezeigt wird,
so dass Sie die ScrollTipText-Eigenschaft setzen
können.
Wird gestartet, bevor sich eine Auswahl (RowSel,
ColSel) ändert.
Wird gestartet, bevor die Spalte durch einen Klick
des Nutzers auf die Überschrift sortiert wird.
Wird gestartet, wenn die Tabelle zu drucken
beginnt.
CancelAddRow Wird gestartet, wenn die AllowAddNew-
Eigenschaft TRUE ist, und nachdem der Nutzer
eine Zeile hinzugefügt hat, diese aber wieder
entfernt, indem er sie ohne Änderungen verlässt.
CellButtonClick
Unterstützt vom .NET-Compact-Framework.
Wird gestartet, wenn der Nutzer auf die
Zellschaltfläche klickt.
CellChanged Wird gestartet, nachdem der Inhalt einer Zelle sich
verändert hat.
ChangeEdit
Unterstützt vom .NET-Compact-Framework.
ComboCloseUp
Unterstützt vom .NET-Compact-Framework.
ComboDropDown
Unterstützt vom .NET-Compact-Framework.
EndPrint
Unterstützt vom .NET-Compact-Framework.
EnterCell
Unterstützt vom .NET-Compact-Framework.
Wird gestartet, nachdem der Text im Editor sich
verändert hat.
Wird gestartet, wenn sich die Tabelle im
Bearbeitungsmodus befindet, und bevor der Nutzer
eine Auswahlkombinationsliste zuklappt.
Wird gestartet, wenn sich die Tabelle im
Bearbeitungsmodus befindet, und bevor der Nutzer
eine Auswahlkombinationsliste aufklappt.
Wird gestartet, wenn die Tabelle den Druckvorgang
beendet hat.
Wird gestartet, wenn eine Zelle aktiv wird.
GetCellErrorInfo Wird gestartet, wenn ShowErrors TRUE ist und die
Tabelle Fehlerinformationen für eine Zelle benötigt.
GetRowErrorInfo Wird gestartet, wenn ShowErrors TRUE ist und die
Tabelle Fehlerinformationen für eine Zeile benötigt.
GetUnboundValue Wird gestartet, wenn die Tabelle gebunden ist und
Werte von einer ungebundenen Tabelle abrufen
muss.
GridChanged Wird gestartet, wenn sich die Tabelle auf irgendeine
Weise verändert.
GridError
Unterstützt vom .NET-Compact-Framework.
KeyDownEdit
Unterstützt vom .NET-Compact-Framework.
Wird gestartet, wenn die Tabelle eine
Fehlerbedingung aufspürt.
Wird gestartet, wenn der Nutzer eine Taste im
Zellbearbeitungsmodus drückt.

KeyPressEdit
Unterstützt vom .NET-Compact-Framework.
KeyUpEdit
Unterstützt vom .NET-Compact-Framework.
LeaveCell
Unterstützt vom .NET-Compact-Framework.
C1FlexGrid-Klasse · 117
Wird gestartet, wenn der Nutzer eine Taste im
Zellbearbeitungsmodus drückt.
Wird gestartet, wenn der Nutzer eine Taste im
Zellbearbeitungsmodus drückt.
Wird gestartet, bevor die aktuelle Zelle eine andere
wird.
MouseHoverCell Wird gestartet, wenn der Mauszeiger über eine
Zelle fährt.
OwnerDrawCell
Unterstützt vom .NET-Compact-Framework.
PrintPage
Unterstützt vom .NET-Compact-Framework.
RowColChange
Unterstützt vom .NET-Compact-Framework.
SelChange
Unterstützt vom .NET-Compact-Framework.
Wird gestartet, bevor die Tabelle eine Zelle zeichnet
und die DrawMode-Eigenschaft auf OwnerDraw
steht.
Wird gestartet, wenn die Tabelle den Druckvorgang
für eine Seite beendet hat.
Wird gestartet, bevor die aktuelle Zelle (Row, Col)
eine andere wird.
Wird gestartet, nachdem sich die Auswahl (RowSel,
ColSel) geändert hat.
SetUnboundValue Wird gestartet, wenn die Tabelle gebunden ist und
einen Wert in einer ungebundenen Spalte setzt.
SetupEditor
Unterstützt vom .NET-Compact-Framework.
StartEdit
Unterstützt vom .NET-Compact-Framework.
ValidateEdit
Unterstützt vom .NET-Compact-Framework.
C1FlexGrid-Eigenschaften
AllowAddNew-Eigenschaft
Wird gestartet, nachdem der integrierte Editor
initialisiert wurde, aber bevor dieser angezeigt wird.
Wird gestartet, wenn die Steuerung in den
Zellbearbeitungsmodus übergeht (nach BeforeEdit).
Wird gestartet, wenn die Steuerung den
Zellbearbeitungsmodus verlässt.
Ermittelt oder legt fest, ob die Tabelle eine Vorlage für eine neue Zeile nach der letzten Zeile anzeigt.
Wenn der Nutzer in diese Vorlage Daten eingibt, dann wird der Tabelle eine neue Zeile angehängt.
Syntax
[VB]
Public AllowAddNew As Boolean
[C#]
public bool AllowAddNew { get; set;}
[Delphi]
property AllowAddNew: Boolean;

118 · C1FlexGrid-Referenzverzeichnis
Bemerkungen
Diese Eigenschaft funktioniert im gebundenen (wenn die Datenquelle das Hinzufügen von neuen Zeilen
unterstützt) und im ungebundenen Modus.
Beachten Sie, dass wenn diese Eigenschaft auf TRUE steht, die Rows.Count-Eigenschaft einen Wert
zurückgibt, der die Vorlage für die neue Zeile mitzählt. Wenn Sie hingegen die Rows.Count-Eigenschaft
setzen, dann wird die Tabelle dementsprechend viele Datenzeilen anlegen und automatisch die Vorlage
für die neue Zeile hinzufügen. Zum Beispiel:
• Visual Basic
• C#
flex.AllowAddNew = True
flex.Rows.Count = 10
Console.WriteLine(_flex.Rows.Count)
flex.AllowAddNew = true;
flex.Rows.Count = 10;
Console.WriteLine(_flex.Rows.Count);
• Delphi
begin
flex.AllowAddNew := True;
flex.Rows.Count := 10;
Console.WriteLine(_flex.Rows.Count);
end;
Dies wird „11“ Zeilen anlegen (10 Datenzeilen und eine Vorlage für eine neue Zeile).
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
AllowDelete-Eigenschaft
Ermittelt oder legt fest, ob die Tabelle die Tastatur überwacht und die Entfernen-Taste kontrollieren soll.
Wenn diese Eigenschaft auf TRUE steht, dann kann der Nutzer Zeilen löschen, indem er diese auswählt
und die Entfernen-Taste drückt.
Syntax
[VB]
Public AllowDelete As Boolean
[C#]
public bool AllowDelete { get; set;}
[Delphi]
property AllowDelete: Boolean;
Bemerkungen
Diese Eigenschaft funktioniert im gebundenen (wenn die Datenquelle das Löschen von Zeilen
unterstützt) und im ungebundenen Modus.

Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
AllowDragging-Eigenschaft
Legt fest, ob der Nutzer Spalten/Zeilen mit der Maus ziehen darf.
Syntax
[VB]
Public AllowDragging As AllowDraggingEnum
[C#]
public AllowDraggingEnum AllowDragging {get; set;}
[Delphi]
property AllowDragging: AllowDraggingEnum;
Eigenschaftswerte
AllowDragging-Eigenschaft · 119
Einer der AllowDraggingEnum-Werte. Der Standardwert ist AllowDraggingEnum.Columns.
Wert Beschreibung
None Der Nutzer kann mit der Maus Zeilen und Spalten nicht ziehen.
Columns Der Nutzer kann mit der Maus Spalten auf neue Positionen ziehen.
Rows Der Nutzer kann mit der Maus Zeilen auf neue Positionen ziehen.
Both Der Nutzer kann mit der Maus Zeilen und Spalten auf neue Positionen ziehen.
Bemerkungen
Sie können das Ziehen von bestimmten Zeilen und Spalten verhindern, indem Sie deren AllowDragging-
Eigenschaft auf FALSE setzen. Zum Beispiel:
• Visual Basic
• C#
flex.AllowDragging = AllowDraggingEnum.Columns
flex.Cols(2).AllowDragging = False
flex.AllowDragging = AllowDraggingEnum.Columns;
flex.Cols[2].AllowDragging = false;
• Delphi
flex.AllowDragging := AllowDraggingEnum.Columns;
flex.Cols[2].AllowDragging := false;
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGridClassic-Klasse (Seite 450)

120 · C1FlexGrid-Referenzverzeichnis
AllowEditing-Eigenschaft (C1FlexGrid)
Legt fest, ob der Nutzer Zellen bearbeiten darf.
Syntax
[VB]
Public AllowEditing As Boolean
[C#]
public bool AllowEditing { get; set;}
[Delphi]
property AllowEditing: Boolean;
Eigenschaftswerte
Der Standardwert ist TRUE.
Bemerkungen
Sie können das Bearbeiten von bestimmten Zeilen und Spalten verhindern, indem Sie deren
AllowEditing-Eigenschaft auf FALSE setzen. Zum Beispiel
• Visual Basic
• C#
flex.AllowEditing = True
flex.Cols(2).AllowEditing = False ' prevent editing column 2
flex.AllowEditing = true;
flex.Cols[2].AllowEditing = false; // prevent editing column 2
• Delphi
flex.AllowEditing := true;
flex.Cols[2].AllowEditing := false; // prevent editing column 2
Für mehr Details und Beispiele über Zellbearbeitung, schauen Sie bitte unter „Zellen bearbeiten“ (Seite
37) nach.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGridClassic-Klasse (Seite 450)
AllowFreezing-Eigenschaft
Legt fest, ob der Nutzer Spalten und Zeilen mit der Maus fixieren darf.
Syntax
[VB]
Public AllowFreezing As AllowFreezingEnum
[C#]
public AllowFreezingEnum AllowFreezing { get; set;}

[Delphi]
property AllowFreezing: AllowFreezingEnum;
Eigenschaftswerte
Einer der AllowFreezingEnum-Werte. Der Standardwert ist AllowFreezingEnum.None.
Bemerkungen
AllowMerging-Eigenschaft · 121
Eingefrorene Zellen bleiben an ihrer Stelle, wenn der Nutzer die Tabelle scrollt (wie fixierte Zellen),
können aber weiterhin wie normale Zellen ausgewählt und bearbeitet werden (wie scrollbare Zellen).
Diese Zellen werden mit dem Styles.Frozen-Style formatiert.
Um Zeilen oder Spalten einzufrieren, muss der Mauszeiger an der Kante des einzufrierenden Bereichs
stehen. Dieser wird sich dann in einen 'freeze'-Zeiger verwandeln (Sieht aus wie ein Vorhängeschloss), so
dass der Nutzer die Grenze der eingefrorenen Zellen auf eine neue Zeile oder Spalte ziehen kann.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
AllowMerging-Eigenschaft
Legt fest, ob Zellen mit ähnlichem Inhalt verbunden werden.
Syntax
[VB]
Public AllowMerging As AllowMergingEnum
[C#]
public AllowMergingEnum AllowMerging {get; set;}
[Delphi]
property AllowMerging: AllowMergingEnum;
Eigenschaftswerte
Einer der AllowMergingEnum-Werte. Der Standardwert ist AllowMergingEnum.None.
Wert Beschreibung
None Zellen nicht verbinden.
Free Angrenzende Zellen mit gleichem Inhalt verbinden.
RestrictRows Zeilen verbinden, wenn die Zellen darüber auch verbunden sind.
RestrictCols Spalten verbinden, wenn die Zellen links davon auch verbunden sind.
RestrictAll Zellen verbinden, wenn die Zellen darüber und links davon auch verbunden sind.
FixedOnly
Nur fixierte Zellen verbinden. Diese Einstellung ist für komplexe Überschriften
sinnvoll, ohne dabei die Datenzellen selbst zu verbinden.
Spill Langen Einträgen erlauben, in leere, angrenzende Zellen überzugehen.
Nodes
Langen Einträgen in Knotenzeilen erlauben, in leere, angrenzende Zellen
überzugehen.

122 · C1FlexGrid-Referenzverzeichnis
Bemerkungen
Verbunde Zellen dienen dazu, Daten auf eine klare und ansprechende Weise anzuzeigen, indem
Gruppen mit gleichen Informationen hervorgehoben werden. Somit sind Sie flexibel und können
ähnliche Tabellen wie die, die Sie in HTML oder mit Microsoft Word (beide unterstützen verbundene
Zellen) verwenden, erstellen.
Um Tabellen mit verbundenen Zellen zu erstellen, müssen Sie die AllowMerging-Eigenschaft auf einen
von AllowMergingEnum.None verschiedenen Wert, und die AllowMerging-Eigenschaft von den
jeweiligen Zeilen und Spalten, die Sie verbinden wollen, auf TRUE setzen. Nachdem diese Eigenschaften
gesetzt wurden, wird die Tabellensteuerung automatisch angrenzende Zellen mit gleichen Inhalten
verbinden. Immer wenn sich die Tabelleninhalte verändern, aktualisiert die Tabelle die Verbindungen.
Beispiel
Durch den nachfolgenden Quellcode verbindet die Tabellensteuerung angrenzende Zellen mit gleichen
Daten in Spalte 1:
• Visual Basic
• C#
flex.AllowMerging = AllowMergingEnum.Free
flex.Cols(1).AllowMerging = True ' merge values in column 1
flex.AllowMerging = AllowMergingEnum.Free;
flex.Cols[1].AllowMerging = true; // merge values in column 1
• Delphi
flex.AllowMerging := AllowMergingEnum.Free;
flex.Cols[1].AllowMerging := true; // merge values in column 1
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGridClassic-Klasse (Seite 450)
AllowResizing-Eigenschaft
Legt fest, ob der Nutzer die Größe von Spalten und Zeilen mit der Maus verändern darf.
Syntax
[VB]
Public AllowResizing As AllowResizingEnum
[C#]
public AllowResizingEnum AllowResizing {get; set;}
[Delphi]
property AllowResizing: AllowResizingEnum;
Eigenschaftswerte
Einer der AllowResizingEnum-Werte. Der Standardwert ist AllowResizingEnum.Columns.

Wert Beschreibung
None Der Nutzer kann die Größe von Zeilen und Spalten nicht verändern.
Columns
ColumnsUniform
Rows
Both
RowsUniform
BothUniform
Bemerkungen
AllowResizing-Eigenschaft · 123
Der Nutzer kann die Breite von Spalten verändern, indem er die Kanten der
fixierten Spalten oben in der Tabelle entsprechend zieht. Ein Doppelklick auf die
Kante der fixierten Zellen passt die Breite an deren breitesten Eintrag an.
Der Nutzer kann die Breite einer Spalte mit der Maus verändern. Wenn die
Größe einer Spalte verändert wurde, dann wird die neue Spaltenbreite auf alle
Spalten angewendet.
Der Nutzer kann die Höhe einer Zeile verändern, indem er die Kanten der
fixierten Zeilen links in der Tabelle entsprechend zieht. Ein Doppelklick auf die
Kante der fixierten Zellen passt die Höhe an deren höchsten Eintrag an.
Der Nutzer kann die Höhe von Zeilen und die Breite von Spalten mit der Maus
verändern.
Der Nutzer kann die Höhe einer Zeile mit der Maus verändern. Wenn die Größe
einer Zeile verändert wurde, dann wird die neue Zeilenhöhe auf alle Zeilen
angewendet.
Der Nutzer kann die Höhe von Zeilen und die Breite von Spalten mit der Maus
verändern. Wenn die Größe einer Zeile oder Spalte verändert wurde, dann wird
die neue Höhe oder Breite auf alle Zeilen oder Spalten angewendet.
Um Zeilen oder Spalten in ihrer Größe zu verändern, muss der Mauszeiger über den fixierten Zellen der
Tabelle und nahe einer Grenze zwischen Zeilen und Spalten stehen. Der Mauszeiger ändert sich dann zu
einem Größenzeiger und der Nutzer kann die Zeilen und Spalten ziehen, um deren Höhe oder Breite zu
verändern.
Wenn eine Spaltengruppe ausgewählt wurde (von der ersten bis zur letzten Zeile) und der Nutzer die
Größe einer Spalte davon verändert, dann werden alle ausgewählten Spalten ebenfalls angepasst. Das
Gleiche gilt für Zeilen.
Wenn die Anpassung der Größe für Spalten erlaubt ist, dann kann mit einem Doppelklick deren Breite
automatisch an den längsten Eintrag der entsprechenden Spalte angepasst werden.
Zeilen mit einer Höhe von Null und Spalten mit einer Breite von Null können vom Nutzer nicht mehr
verändert werden. Wenn diese Zeilen und Spalten zwar sehr klein, aber immer noch veränderbar sein
sollen, dann sollten Sie deren Höhe oder Breite auf einen Pixel stellen, und nicht Null.
Die BeforeResizeRow- und BeforeResizeColumn-Ereignisse werden vor der Veränderung gestartet und
können dazu verwendet werden, die Veränderung der Größe von bestimmten Zeilen und Spalten zu
verhindern. Die AfterResizeRow- und AfterResizeColumn-Ereignisse werden nach der
Größenanpassung gestartet und können für die Prüfung der Änderung oder das Aktualisieren der
Anzeige verwendet werden.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGridClassic-Klasse (Seite 450)

124 · C1FlexGrid-Referenzverzeichnis
AllowSorting-Eigenschaft (C1FlexGrid)
Legt fest, ob der Nutzer Spalten mit der Maus sortieren darf.
Syntax
[VB]
Public AllowSorting As AllowSortingEnum
[C#]
public AllowSortingEnum AllowSorting {get; set;}
[Delphi]
property AllowSorting: AllowSortingEnum;
Eigenschaftswerte
Einer der AllowSortingEnum-Werte. Der Standardwert ist AllowSortingEnum.SingleColumn.
Wert Beschreibung
None Der Nutzer kann Spalten nicht mit der Maus sortieren.
SingleColumn
MultiColumn
Bemerkungen
Der Nutzer kann Spalten mit der Maus sortieren. Klickt man auf die
Spaltenüberschrift, so werden diese jeweils auf- oder absteigend sortiert.
Diese Funktion ist gleich denen, die in den meisten Standardanwendungen, wie
zum Beispiel Windows Explorer, zu finden sind.
Der Nutzer kann Spalten mit der Maus sortieren. Klickt man auf die
Spaltenüberschrift, so werden alle Spalten von der Ersten bis zur zuvor
angeklickten auf- oder absteigend sortiert.
Diese Einstellung ist sinnvoll, wenn die Daten nach Kategorien von links nach
rechts gruppiert sind und Sie diese Gruppen trotz Sortierung erhalten wollen.
Wenn sich die Tabelle im gebundenen Modus befindet, so wird die Sortierung in der darunterliegenden
Datentabelle vorgenommen.
Wenn die Tabelle ungebunden ist, können Sie die Daten auch mit der Sort-Methode sortieren.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109 )
C1FlexGridClassic-Klasse (Seite 450)
AutoClipboard-Eigenschaft
Gibt zurück oder legt fest, ob die Tabelle die Zwischenablagefunktionen steuern soll und automatisch die
Operationen Ausschneiden, Kopieren, Einfügen und Löschen durchführen soll.
Syntax
[VB]

Public AutoClipboard As Boolean
[C#]
public bool AutoClipboard {get; set;}
[Delphi]
property AutoClipboard: Boolean;
Bemerkungen
AutoGenerateColumns-Eigenschaft · 125
Wenn Sie diese Eigenschaft auf TRUE setzen, dann überwacht die Tabellensteuerung die Tastatur für die
folgenden Tastenkombinationen:
Zwischenablagenoperation Tastenkombination
Kopieren Strg-Einfügen (Einfg), Strg-C
Ausschneiden Strg-X, Shift-Entfernen (Entf)
Einfügen Strg-V, Shift- Einfügen (Einfg)
Löschen Entfernen (Entf)
Die Operationen Einfügen, Ausschneiden und Löschen werden nur ausgeführt, wenn die AllowEditing-
Eigenschaft auf TRUE gesetzt ist.
Wenn Sie nur einen Teil der unterstützten Tastenkombinationen zur Verfügung stellen wollen, dann
können Sie einen entsprechenden Ereignisabwickler dem KeyDown-Ereignis hinzufügen und die
Handled-Parameter auf TRUE setzen um einige der Tastenkombinationen zu deaktivieren.
Die automatischen Zwischenablageoperationen betreffen nur die Tabellendaten. Formate und Bilder
werden weder mit kopiert, noch eingefügt oder gelöscht.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
AutoGenerateColumns-Eigenschaft
Legt fest, ob die Tabelle ihre Spalten aktualisiert, wenn sie einer neuen Datenquelle zugeordnet wurde.
Syntax
[VB]
Public-Eigenschaft AutoGenerateColumns As Boolean
[C#]
public bool AutoGenerateColumns {get; set;}
[Delphi]
property AutoGenerateColumns: Boolean;
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)

126 · C1FlexGrid-Referenzverzeichnis
AutoResize-Eigenschaft
Gibt zurück oder legt fest, ob die Spaltenbreiten automatisch angepasst werden, wenn Daten geladen
werden.
Syntax
[VB]
Public AutoResize As Boolean
[C#]
public bool AutoResize {get; set;}
[Delphi]
property AutoResize: Boolean;
Bemerkungen
Diese Eigenschaft funktioniert nur, wenn die Tabelle an eine Datenquelle gebunden ist. Wenn AutoResize
auf TRUE steht, dann passt die Tabellensteuerung beim Laden neuer Daten die Spaltenbreiten
automatisch an den breitesten Eintrag an.
Sie können weiterhin die Spaltenbreiten im Quelltext mit der AutoSizeCols-Methode anpassen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
AutoSearch-Eigenschaft
Legt fest, ob die Tabelle den Cursor bewegen soll, wenn diese nach Einträgen sucht, während der Nutzer
tippt.
Syntax
[VB]
Public AutoSearch As AutoSearchEnum
[C#]
public AutoSearchEnum AutoSearch {get; set;}
[Delphi]
property AutoSearch: AutoSearchEnum;
Eigenschaftswerte
Einer der AutoSearchEnum-Werte. Der Standardwert ist AutoSearchEnum.None.
Bemerkungen
Wenn AutoSearch eingeschaltet ist, dann durchsucht die Tabelle automatisch die aktuelle Spalte nach
dem Wert, den der Nutzer gerade eingibt, indem diese den Cursor bewegt und die Übereinstimmungen
mit dem Styles.Search-Zellformat markiert. Die Suche berücksichtigt Groß- und Kleinschreibung und
wird abgebrochen, wenn der Nutzer die Escape-Taste drückt oder die Auswahl mit der Maus oder den
Pfeiltasten bewegt.

AutoSearchDelay-Eigenschaft · 127
Hört der Nutzer kurz auf zu schreiben, so wird der Suchpuffer zurückgesetzt. Die Zeitspanne bis zum
Zurücksetzen des Puffers kann durch die AutoSearchDelay-Eigenschaft festgelegt werden.
Wenn AutoSearch eingeschaltet ist und die AllowEditing-Eigenschaft auf TRUE steht, so muss der
Nutzer die Enter-, Leer- oder F2-Taste drücken um die Zelle zu bearbeiten. Andere Tasten werden für die
Suche verwendet.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
AutoSearchDelay-Eigenschaft
Legt die zu verstreichende Zeit fest (in Sekunden), bevor der AutoSearch-Puffer zurückgesetzt wird.
Syntax
[VB]
Public AutoSearchDelay As double
[C#]
public double AutoSearchDelay {get; set;}
[Delphi]
property AutoSearchDelay: Double;
Bemerkungen
Schauen Sie unter der AutoSearch-Eigenschaft nach.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
BottomRow-Eigenschaft
Gibt die letzte, sichtbare Zeile einer Tabelle zurück.
Syntax
[VB]
Public BottomRow As Integer
[C#]
public int BottomRow {get;}
[Delphi]
property BottomRow: Integer;
Bemerkungen
Die zurückgegebene unterste Zeile ist vielleicht nur teilweise auf dem Bildschirm sichtbar.
Sie können diese Eigenschaft nicht festlegen. Um die Inhalte der Tabelle mit Quelltext zu scrollen,
verwenden Sie die TopRow- und LeftCol-Eigenschaften. Verwenden Sie die ShowCell-Methode, um
sicherzustellen, dass eine gegebene Zelle auf dem Bildschirm angezeigt wird.

128 · C1FlexGrid-Referenzverzeichnis
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
BorderStyle-Eigenschaft
Gibt/legt den Rahmen-Stil der Steuerung zurück/fest.
Syntax
[VB]
Public BorderStyle As BorderStyleEnum
[C#]
public BorderStyleEnum BorderStyle {get; set;}
[Delphi]
property BorderStyle: BorderStyleEnum;
Eigenschaftswerte
Einer der BorderStyleEnum-Werte. Der Standardwert ist BorderStyleEnum.Fixed3D.
Bemerkungen
Zusätzlich zu den Standardeinstellungen FixedSingle und Fixed3D, können Sie den Light3D-Rahmen
verwenden, der ein Pixel breit ist.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
CellButtonImage-Eigenschaft
Legt die Grafik auf einer Zellschaltfläche fest.
Syntax
[VB]
Public CellButtonImage As Image
[C#]
public Image CellButtonImage {get; set;}
[Delphi]
property CellButtonImage: Image;
Bemerkungen
Mit dieser Eigenschaft können Sie das Aussehen der Zellschaltflächen anpassen. Für Details über die
Handhabung von Zellschaltflächen, schauen Sie bitte unter CellButtonClick-Ereignis nach.
Wenn Sie nur eine Grafik für alle Zellschaltflächen in der Tabelle verwenden wollen, dann ordnen Sie
diese der CellButtonImage-Eigenschaft während der Designtime zu. Um die Grafiken je nach Spalte,
Zeile oder zu bearbeitender Zelle zu verändern, fangen Sie das BeforeEdit-Ereignis ab und legen Sie das
entsprechende Bild fest.

Clip-Eigenschaft · 129
Die für die Zellschaltflächen verwendete Grafik sollte auf die Schaltfläche passen (größere Grafiken
werden beschnitten). Diese sollten auch transparent sein, so dass die Schaltflächenoberfläche durch die
leeren Stellen der Grafik zu sehen ist. Für das beste Ergebnis, verwenden Sie kleine Symbole (16x16 Pixel)
und zeichnen Sie das Bild in das obere linke 12x12-Rechteck innerhalb des Symbols.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109 )
C1FlexGridClassic-Klasse (Seite 450)
Clip-Eigenschaft
Gibt/legt den Inhalt eines Zellbereichs zurück/fest.
Syntax
[VB]
Public Clip As String
[C#]
public string Clip {get; set;}
[Delphi]
property Clip: string;
Bemerkungen
Der Eintrag, welcher der Clip-Eigenschaft zugeordnet oder von dieser zurückgegeben wird, kann
mehrere Zellen umfassen. Standardmäßig stehen Tabulatorzeichen (\t) für eine neue Spalte und
Zeilenumschalterzeichen (\n) für Zeilenumbrüche.
Die Standard-Zeilen- und -Spaltenabgrenzer können in der ClipSeparators-Eigenschaft geändert werden.
Wenn eine Zeichenkette der Clip-Eigenschaft zugeordnet ist, dann sind nur die ausgewählten Zellen
betroffen. Wenn sich noch weitere Zellen neben denen, die im Clip-Eintrag gespeichert sind, in der
Auswahl befinden, dann werden diese ignoriert. Wenn im Clip-Eintrag mehr Zellen beschrieben werden,
als in der Auswahlregion vorhanden sind, dann wird der überschüssige Teil des Clip-Eintrags ebenfalls
ignoriert. Leere Clip-Einträge löschen die aktuellen Inhalte der Zellen.
Das nachfolgende Beispiel schreibt Text in einen ausgewählten Bereich, zwei Zeilen hoch und zwei
Spalten breit:
• Visual Basic
• C#
' build clip string
Dim s As String = "1st" + vbTab + "a" +vbLf + "2nd" +vbTab + "b"
' paste it over current selection
flex.Clip = s
// build clip string
string s = "1st" + "\t" + "a" + "\n" + "2nd" + "\t" + "b";
// paste it over current selection
flex.Clip = s;

130 · C1FlexGrid-Referenzverzeichnis
• Delphi
var
s: string;
begin
s := '1st' + #9 + 'a' + #10 + '2nd' + #9 + 'b';
flex.Clip := s;
end;
Sie können den Clip-Eintrag auch für jede willkürliche Auswahl (nicht zwingend ausgewählt) mit einem
CellRange-Objekt abrufen oder festlegen. Zum Beispiel:
• Visual Basic
• C#
' build clip string
Dim rg As CellRange = flex.GetCellRange(1, 1, 10, 10)
MessageBox.Show(rg.Text)
// build clip string
CellRange rg = flex.GetCellRange(1,1,10,10);
MessageBox.Show(rg.Text);
• Delphi
var
rg: CellRange;
begin
rg := flex.GetCellRange(1, 1, 10, 10);
MessageBox.Show(rg.Text);
end;
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
ClipSeparators-Eigenschaft
Gibt/legt die Trennzeichen für Zeilen und Spalten im Clip-Eintrag zurück/fest.
Syntax
[VB]
Public ClipSeparators As String
[C#]
public string ClipSeparators {get; set;}
[Delphi]
property ClipSeparators: string;
Bemerkungen
Schauen Sie auch unter Clip-Eigenschaft nach.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)

Col-Eigenschaft
Gibt/legt den Index einer ausgewählten Spalte zurück/fest.
Syntax
[VB]
Public Col As Integer
[C#]
public int Col {get; set;}
[Delphi]
property Col: Integer;
Bemerkungen
Col-Eigenschaft · 131
Verwenden Sie die Row- und Col-Eigenschaften um eine Zelle aktuell zu machen, oder herauszufinden,
in welcher Zeile oder Spalte sich die aktuelle Zelle befindet. Spalten und Zeilen werden von Null an,
beginnend von der obersten Zeile und der linken Spalte nummeriert.
Die Col-Eigenschaft kann auf -1, um die Auswahl auszublenden, oder auf einen Wert zwischen Null und
Cols.Fixed-1 gesetzt werden, um eine Zelle in einer fixierten Spalte auszuwählen. Sie kann auch auf einen
Wert zwischen Cols.Fixed und Cols.Count-1 gesetzt werden, um eine scrollbare Spalte auszuwählen.
Indem man die Row- und Col-Eigenschaften setzt, wird die Auswahl automatisch auf eine einzelne Zelle
beschränkt und damit die Eigenschaften RowSel und ColSel zurückgesetzt. Um eine Blockauswahl
vorzunehmen, müssen Sie zuerst Row und Col und dann RowSel und ColSel festlegen. Oder Sie
verwenden die Select-Methode, um eine willkürliche Auswahl mit einem einzigen Befehl vorzunehmen.
Indem die Row- und Col-Eigenschaften gesetzt werden, kann nicht sichergestellt werden, dass die Zelle
auf dem Bildschirm sichtbar ist. Um dies zu tun, müssen Sie die ShowCell-Methode anwenden.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
Cols-Eigenschaft
Gibt alle Spalten einer Tabelle zurück.
Syntax
[VB]
Public Cols As ColumnCollection
[C#]
public ColumnCollection Cols {get;}
[Delphi]
property Cols: ColumnCollection;
Bemerkungen
Mit der Cols-Eigenschaft können Sie eine Liste mit allen derzeit vorhandenen Spalten in einer Tabelle
abfragen. Mit dieser Referenz können Sie Spalten hinzufügen, entfernen, verschieben und zählen. Für

132 · C1FlexGrid-Referenzverzeichnis
weitere Informationen über die Funktionen dieser Sammlung, schauen Sie in den Referenzthemen der
ColumnCollection-Klasse nach.
Diese Eigenschaft kann nur gelesen werden. Die Tabelle erstellt und verwaltet diese Liste/Sammlung.
Upgradenotiz: In der VSFlexGrid-ActiveX-Steuerung zeigen die Cols- und FixedCols-Eigenschaften die
Anzahl der Spalten und der fixierten Spalten in einer Tabelle. Verwenden Sie in C1FlexGrid Cols.Count
und Cols.Fixed hierfür.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGridClassic-Klasse (Seite 450)
ColSel-Eigenschaft
Gibt/legt den Index der letzten Spalte in der aktuellen Auswahl zurück/fest.
Syntax
[VB]
Public ColSel As Integer
[C#]
public int ColSel {get; set;}
[Delphi]
property ColSel: Integer;
Bemerkungen
Verwenden Sie die RowSel- und ColSel-Eigenschaften um eine Auswahl zu verändern oder um zu
bestimmen, welche Zellen gerade ausgewählt sind. Spalten und Zeilen werden von Null an, beginnend
von der obersten Zeile und der linken Spalte numeriert.
Indem man die Row- und Col-Eigenschaften setzt, wird die Auswahl automatisch auf eine einzelne Zelle
beschränkt und damit die Eigenschaften RowSel und ColSel zurückgesetzt. Um eine Blockauswahl
vorzunehmen, müssen Sie zuerst Row und Col und dann RowSel und ColSel festlegen. Oder Sie
verwenden die Select-Methode, um eine willkürliche Auswahl mit einem einzigen Befehl vorzunehmen.
Wenn ein Bereich ausgewählt ist, dann kann der Wert von Row oder Col größer oder kleiner als der von
RowSel oder ColSel sein. Dies ist recht lästig, wenn Sie Grenzen für Schleifen setzen wollen. In diesen
Fällen können Sie die Selection-Eigenschaft verwenden, um ein normalisiertes CellRange-Objekt
abzufragen, indem r1

• C#
Next c
Next r
ComboList-Eigenschaft · 133
CellRange rg = flex.Selection;
for (int r = rg.r1; r

134 · C1FlexGrid-Referenzverzeichnis
• C#
flex.ComboList = "ListItem 1|ListItem 2"
flex.ComboList = "ListItem 1|ListItem 2";
• Delphi
flex.ComboList := 'ListItem 1|ListItem 2';
3. Setzen Sie die ComboList-Eigenschaft auf eine Zeichenkette mit den zur Verfügung stehenden
Optionen, getrennt und beginnend mit einem Senkrechtstrich ("|"), um die Zelle mit einer
Auswahlkombinationsliste zu bearbeiten. Zum Beispiel:
• Visual Basic
• C#
flex.ComboList = "|ComboItem 1|ComboItem 2"
flex.ComboList = "|ComboItem 1|ComboItem 2";
• Delphi
flex.ComboList := '|ComboItem 1|ComboItem 2';
4. Um eine Bearbeitungsschaltfläche anzuzeigen, müssen Sie die ComboList-Eigenschaft auf eine
Zechenkette mit einer Ellipsis („...“) setzen. Bearbeitungsschaltflächen sehen wie ganz normale
Schaltflächen aus, die rechts in der Zelle stehen, und besitzen drei Punkte (Ellipsis) als Aufdruck.
Wenn der Nutzer auf diese klickt, startet die Tabelle das CellButtonClick-Ereignis. In diesem
Fall kann der Nutzer den Zellinhalt nicht direkt bearbeiten. Zum Beispiel:
• Visual Basic
• C#
flexComboList = "..."
flexComboList = "...";
• Delphi
flexComboList := '...';
5. Um eine Bearbeitungsschaltfläche neben einer bearbeitbaren Zelle anzuzeigen, müssen Sie die
ComboList-Eigenschaft auf eine Zeichenkette mit einem Senkrechtstrich und der Ellipsis ("|...")
setzen. In diesem Fall erhalten Sie eine gewöhnliche Bearbeitungsschaltfläche, aber der Nutzer
kann außerdem den Zellinhalt direkt bearbeiten. Zum Beispiel:
• Visual Basic
• C#
flexComboList = "|..."
flexComboList = "|...";
• Delphi
flexComboList := '|...';
Die ComboList-Eigenschaft ist in solchen Fällen besonders sinnvoll, in denen Zeilen in der selben Spalte
verschiedene Datentypen enthalten (zum Beispiel eine Steuerung wie die Microsoft-PropertyGrid). In
diesem Fall können Sie den für die aktuelle Zeile entsprechenden Bearbeitungstyp in der ComboList-
Eigenschaft anpassen.

CursorCell-Eigenschaft · 135
Verwenden Sie die ComboList-Eigenschaft der Spalte, wenn alle Zeilen in einer Spalte den gleichen
Datentyp verwenden. Auf diesem Wege wählt die Tabellensteuerung automatisch die entsprechende
ComboList für die Spalte aus und Sie müssen keinerlei Ereignisse bearbeiten.
Beispiel
Der nachfolgende Quellcode fängt das BeforeEdit-Ereignis ab und ordnet der ComboList-Eigenschaft
einen Wert zu, so dass die Tabellensteuerung verschiedene Schaltflächen in jeder Zeile anzeigt.
• Visual Basic
• C#
Private Sub _flex_BeforeEdit(sender As Object, e As RowColEventArgs)
_flex.ComboList = ""
If e.Row Mod 2 = 0 Then
flex.ComboList = "..."
Else
flex.ComboList = ""
End If
End Sub '_flex_BeforeEdit
private void _flex_BeforeEdit(object sender, RowColEventArgs e)
{
_flex.ComboList = (e.Row % 2 == 0)? "..." : "";
}
• Delphi
procedure _flex_BeforeEdit(sender: System.Object; e: RowColEventArgs);
begin
_flex.ComboList := '';
If (e.Row Mod 2) = 0 Then
flex.ComboList = '...'
Else
flex.ComboList = '';
end; //_flex_BeforeEdit
Für mehr Details und Beispiele über Zellbearbeitung, schauen Sie bitte unter „Zellen bearbeiten“ (Seite
37) nach.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
CursorCell-Eigenschaft
Gibt ein CellRange-Objekt zurück, dass die Ankerzelle in der aktuellen Auswahl mit den Koordinaten
Row, Col enthält.
Syntax
[VB]
Public CursorCell As CellRange
[C#]
public CellRange CursorCell {get;}
[Delphi]
property CursorCell: CellRange;

136 · C1FlexGrid-Referenzverzeichnis
Eigenschaftswerte
Ein CellRange-Objekt, das für die Veränderung eines Zellbereiches verwendet werden kann.
Bemerkungen
Verwenden Sie die Selection-Eigenschaft, um ein CellRange-Objekt über die gesamte Auswahl zu
erhalten (definiert durch die Row, Col, RowSel und ColSel-Eigenschaften).
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
CustomComparer-Eigenschaft
Gibt/legt ein benutzerdefiniertes IComparer-Objekt, dass von der Tabelle für Gruppierung,
Zellverbindung und Suchoperationen verwendet wird, zurück/fest
Syntax
[VB]
Public CustomComparer As IComparer
[C#]
public IComparer CustomComparer {get;set;}
[Delphi]
property CustomComparer: IComparer;
Bemerkungen
Die Tabelle besitzt eine IComparer-Standardimplementation, die für Vergleiche zwischen Zellen
verwendet wird, um zu bestimmen, ob diese den gleichen Inhalt besitzen. Diese Implementation wird für
Zellverbindungen, Zellgruppierungen und für die Suche nach Werten verwendet (Schauen Sie ebenfalls
unter der AllowMerging-Eigenschaft und den Subtotal- und FindRow-Methoden nach).
Die Standardimplementation berücksichtigt sowohl Groß- und Kleinschreibung als auch voran- oder
nachstehende Leerzeichen.
Wenn Sie in den Vergleichen für Zellverbindungen Groß- und Kleinschreibung berücksichtigt wollen,
Leerzeichen aber nicht, dann müssen Sie eine eigene Klasse schreiben, die den IComparer implementiert,
und diese der CustomComparer-Eigenschaft zuordnen.
Setzen Sie diese Eigenschaft auf Null (Nothing in Visual Basic), um das Standardverhalten
wiederherzustellen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
DataMember-Eigenschaft
Gibt/legt eine bestimmte Liste eines DataSource-Objekts, das die Tabelle anzeigen soll, zurück/fest.
Syntax
[VB]

Public DataMember As String
[C#]
public string DataMember {get;set;}
[Delphi]
property DataMember: string;
Bemerkungen
DataSource-Eigenschaft (C1FlexGrid) · 137
Wenn eine DataSource mehrere Datenquellen (Tabellen) enthält, dann sollten Sie die DataMember-
Eigenschaft auf eine bestimmte Quelle festsetzen. Zum Beispiel, wenn die DataSource ein DataSet oder
DataViewManager ist, der drei Tabellen mit den Namen Customers, Orders und OrderDetails enthält,
dann müssen Sie eine Tabelle festlegen, an die Sie Ihre Tabelle binden möchten. Wenn die DataSet oder
DataViewManager nur eine DataTable beinhaltet, dann können Sie die DataMember-Eigenschaft leer
lassen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
DataSource-Eigenschaft (C1FlexGrid)
Gibt/legt die Datenquelle der Steuerung zurück/fest.
Syntax
[VB]
Public DataSource As object
[C#]
public object DataSource {get; set;}
[Delphi]
property DataSource: object;
Bemerkungen
Die folgenden ADO.NET-Datenquellen sind gültig: DataTable, DataView, DataSet, DataViewManager.
Die folgenden ComponentOne DataObjects-Komponenten sind ebenfalls gültige Datenquellen:
C1ExpressTable, C1ExpressVew, C1ExpressConnection, C1DataView, C1DataTableSource und
C1DataSet.
Wenn die DataSource-Referenz mehr als nur eine Tabelle enthält, dann müssen Sie in der DataMember-
Eigenschaft die entsprechende Tabelle festlegen, zu der Sie verbinden möchten. Zum Beispiel, wenn die
DataSource ein DataSet oder DataViewManager ist, der drei Tabellen mit den Namen Customers, Orders
und OrderDetails enthält, dann müssen Sie eine Tabelle festlegen, an die Sie Ihre Tabelle binden möchten.
Sie können auch ein weiteres C1FlexGrid-Objekt der DataSource-Eigenschaft zuordnen. In diesem Fall
werden die Steuerungen sich das gleiche Tabellenmodel, inklusive der Daten, Anzeigeformate,
Auswahlen, usw., teilen. Dies kann dazu verwendet werden, um geteilte Ansichten zu implementieren,
wobei verschiedene Steuerungen verschiedene Teile der Daten anzeigen.
Beispiel

138 · C1FlexGrid-Referenzverzeichnis
Dieser Quelltext bindet die Tabelle an eine ADO.NET-Datenquelle:
• Visual Basic
• C#
' replace with actual connection string
Dim conn As String = "
Provider=Microsoft.Jet.OLEDB.4.0;UserID=Admin;... "
'
Dim rs As String = "select * from customers"
Dim da As New OleDbDataAdapter(rs, conn)
Dim ds As New DataSet()
da.Fill(ds)
flex.DataSource = ds.Tables(0)
// replace with actual connection string
string conn = @"Provider=Microsoft.Jet.OLEDB.4.0; User ID=Admin; ...";
string rs = "select * from customers";
OleDbDataAdapter da = new OleDbDataAdapter(rs, conn);
DataSet ds = new DataSet();
da.Fill(ds);
flex.DataSource = ds.Tables[0];
• Delphi
var
ds: DataSet;
da: OleDbDataAdapter;
rs: string;
conn: string;
begin
conn := 'Provider=Microsoft.Jet.OLEDB.4.0;Password="";User ID=Admin;
...';
rs := 'select * from customers';
da := OleDbDataAdapter.Create(rs, conn);
ds := DataSet.Create;
da.Fill(ds);
flex.DataSource := ds.Tables[0];
end;
Dieser Quelltext bindet zwei Tabellen (fgLeft und fgRight) zusammen und synchronisiert deren
vertikalen Bildlauf (Die Nutzer können nur noch horizontal unabhängig scrollen).
• Visual Basic
• C#
' bind grids together
fgRight.DataSource = fgLeft
fgLeft.ScrollBars = ScrollBars.Horizontal
' synchronize vertical scrolling
Private Sub flex_AfterScroll(sender As Object,
e As C1.Win.C1FlexGrid.RangeEventArgs)
Dim fg As C1FlexGrid = CType(sender, C1FlexGrid)
fg.Update()
Dim y As Integer = fg.ScrollPosition.Y
If fg = fgLeft Then
fgRight.ScrollPosition = New Point(fgRight.ScrollPosition.X, y)
Else
fgLeft.ScrollPosition = New Point(fgLeft.ScrollPosition.X, y)
End If
End Sub
// bind grids together

fgRight.DataSource = fgLeft;
fgLeft.ScrollBars = ScrollBars.Horizontal;
DoubleBuffer-Eigenschaft · 139
// synchronize vertical scrolling
private void flex_AfterScroll(object sender,
C1.Win.C1FlexGrid.RangeEventArgs e)
{
C1FlexGrid fg = (C1FlexGrid)sender;
fg.Update();
int y = fg.ScrollPosition.Y;
if (fg == fgLeft)
fgRight.ScrollPosition = new Point(fgRight.ScrollPosition.X,
y);
else
fgLeft.ScrollPosition = new Point(fgLeft.ScrollPosition.X, y);
}
}
• Delphi
// bind grids together
fgRight.DataSource := fgLeft;
fgLeft.ScrollBars := ScrollBars.Horizontal;
procedure Class1.flex_AfterScroll(sender: System.Object; e:
C1.Win.C1FlexGrid.RangeEventArgs);
var
y: Integer;
fg: C1FlexGrid;
begin
fg := C1FlexGrid(sender);
fg.Update;
y := fg.ScrollPosition.Y;
if (fg = fgLeft) then
fgRight.ScrollPosition := Point.Create(fgRight.ScrollPosition.X, y)
else
fgLeft.ScrollPosition := Point.Create(fgLeft.ScrollPosition.X, y);
end;
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
DoubleBuffer-Eigenschaft
Wenn diese Eigenschaft auf TRUE steht, dann wird die Tabelle in einem Puffer gezeichnet und danach
das Ergebnis auf dem Bildschirm ausgegeben. Damit wird mögliches Flackern verhindert, wenn die
Tabelle von der Steuerung erneut gezeichnet wird.
Syntax
[VB]
Public-Eigenschaft DoubleBuffer As Boolean
[C#]
public Bool DoubleBuffer {get; set;}
[Delphi]
property DoubleBuffer: Boolean;

140 · C1FlexGrid-Referenzverzeichnis
Eigenschaftswerte
Mitglied der C1.Win.C1FlexGrid.C1FlexGridBase
Bemerkungen
Setzen Sie DoubleBuffer nicht auf FALSE, wenn die Tabelle folgendes besitzt:
• Verbundene Zellen, oder
• Transparente Bereiche, oder
• Ein Hintergrundbild.
Unter Einsatz von Anwendungen, die auf Terminalserven laufen, können Sie DoubleBuffer für eine
Leistungssteigerung auf FALSE setzen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGridBase
DragMode-Eigenschaft
Gibt/legt einen Wert, der festlegt, ob der Nutzer Daten aus der Steuerung ziehen kann, zurück/fest.
Syntax
[VB]
Public DragMode As DragModeEnum
[C#]
public DragModeEnum DragMode {get; set;}
[Delphi]
property DragMode: DragModeEnum;
Eigenschaftswerte
Einer der DragModeEnum-Werte.
Bemerkungen
Mit dieser Eigenschaft können Sie die Steuerung als Quelle für OLE-Drag-Drop-Operationen verwenden.
Wenn diese auf einen der automatischen Werte gesetzt ist, dann stellt die Steuerung folgende Funktionen
zur Verfügung:
1. Bemerken, wenn die Maus nah der Kante einer ausgewählten Zelle oder einer Auswahl steht und
den OLE-Ziehcursor anzeigen.
2. Wenn der Nutzer mit der Maus klickt, während der OLE-Ziehcursor angezeigt wird, dann wird
die Ziehoperation mit einem Objekt der aktuellen Auswahl initialisiert.
Im manuellen Modus ist der Programmierer für die Initialisierung der Drag-Drop-Operationen mit der
System.Windows.Forms.Control.DoDragDrop-Methode verantwortlich.
Schauen Sie ferner unter
DropMode-Eigenschaft (Seite 141)

C1FlexGrid-Klasse (Seite 109)
DrawMode-Eigenschaft
Legt fest, ob Sie benutzerdefiniertes Zeichnen für Tabellenzellen bereitstellen wollen.
Syntax
[VB]
Public DrawMode As DrawModeEnum
[C#]
public DrawModeEnum DrawMode {get; set;}
[Delphi]
property DrawMode: DrawModeEnum;
Eigenschaftswerte
Einer der DrawModeEnum-Werte. Der Standardwert ist DrawModeEnum.Default.
Bemerkungen
DrawMode-Eigenschaft · 141
Wenn Sie diese Eigenschaft auf DrawModeEnum OwnerDraw setzen, dann wird die Tabelle das
OwnerDrawCell-Ereignis starten. Sie können dieses Ereignis abfangen und die Art und Weise anpassen,
wie die Zelle gezeichnet wird, indem Sie deren Inhalt oder Format direkt, oder indem Sie das Zeichnen
selbst in die Hand nehmen, verändern.
Für mehr Details und Beispiele, schauen Sie unter OwnerDrawCell-Ereignis nach.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
DropMode-Eigenschaft
Gibt/legt einen Wert zurück/fest, der festlegt, ob die Steuerung Daten akzeptiert, die der Nutzer auf die
Tabelle zieht.
Syntax
[VB]
Public DropMode As DropModeEnum
[C#]
public DropModeEnum DropMode {get; set;}
[Delphi]
property DropMode: DropModeEnum;
Eigenschaftswerte
Einer der DropModeEnum-Werte.
Bemerkungen
Mit dieser Eigenschaft können Sie die Steuerung als Ziel der OLE-Drag-Drop-Operationen nutzen.

142 · C1FlexGrid-Referenzverzeichnis
Wenn sie auf None gesetzt ist (Standardwert), dann agiert die Steuerung nicht als Drop-Ziel.
Wenn sie auf Manual gesetzt ist, dann startet die Steuerung die Standardereignisse Drag-Drop und der
Programmierer muss diese abfangen. Die betreffenden Hauptereignisse sind DragOver und DragDrop.
Diese Ereignisse werden vom Standardobjekt System.Windows.Forms.Control bereitgestellt.
Wenn sie auf Automatic gesetzt ist, dann behandelt die Steuerung die Ereignisse DragOver und
DragDrop automatisch, indem die folgenden Maßnahmen ausgeführt werden:
1. Fragt das data-Objekt nach Daten im Text- oder Dateinamenformat.
2. Scrollt, wenn der Nutzer ein Objekt nah der Kante der Steuerung zieht.
3. Fügt den Inhalt des data-Objekts ein, wenn der Nutzer gültige Daten in der Tabelle fallen lässt.
NOTE: Diese Eigenschaft erweitert und ersetzt die AllowDrop-Eigenschaft, die vom Basisobjekt
Windows.Forms.Control bereitgestellt wird.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
EditMask-Eigenschaft (C1FlexGrid)
Gibt/legt die Eingabemaske zurück/fest, wenn Zellen bearbeitet werden.
Syntax
[VB]
Public EditMask As String
[C#]
public string EditMask {get; set;}
[Delphi]
property EditMask: string;
Bemerkungen
Mit der EditMask-Eigenschaft können Sie eine Eingabemaske festlegen, welche die Eingabe automatisch
formatiert und auf Gültigkeit prüft. Die Maskensyntax ist ähnlich der von der Microsoft MaskedEdit
ActiveX-Steuerung und von Microsoft Access verwendeten und wird nachfolgend beschrieben.
Setzen Sie die EditMask-Eigenschaft als Antwort auf das BeforeEdit-Ereignis, genauso wie Sie die
ComboList-Eigenschaft setzen würden.
Wenn dieselbe Maske für alle Werte in einer Spalte verwendet wird, dann verwenden Sie die EditMask-
Eigenschaft der entsprechenden Spalte. Dies vereinfacht den Quellcode, da Sie das BeforeEdit-Ereignis
nicht abfangen müssen.
Beendet der Nutzer die Bearbeitung einer Zelle in der Maske, so wird das ValidateEdit-Ereignis
gestartet. Die Cancel-Eigenschaft im Ereignis wird auf TRUE gesetzt, wenn die Maske nicht richtig
ausgefüllt wurde, so dass Sie nicht einmal den Abwickler implementieren müssen. Das
Standardverhalten stellt sicher, dass nur gültige Daten eingetragen werden.
Die EditMask muss eine Zeichenkette, bestehend aus folgenden Symbolen, sein:

1) Platzhalter
0 Ziffer
9 Ziffer oder Leerzeichen
# Ziffer oder Satzzeichen
L Buchstabe
? Buchstabe oder Leerzeichen
A Buchstabe oder Ziffer
a Buchstabe, Ziffer oder Leerzeichen
& beliebiges Zeichen
2) Ortsgebundene Zeichen
. ortsgebundenes Dezimaltrennzeichen
, ortsgebundenes Tausendertrennzeichen
: ortsgebundenes Zeittrennzeichen
/ ortsgebundenes Datumstrennzeichen
3) Befehlszeichen
\ nächstes Zeichen ist wird wörtlich genommen
> Buchstaben zu Großbuchstaben umformen
< Buchstaben zu Kleinbuchstaben umformen
4) Platzhaltereinstellungen
; Nächstes Zeichen wird als Platzhalter verwendet (Standard ist ein Unterstrich)
Zum Beispiel:
• Visual Basic
• C#
Editor-Eigenschaft (C1FlexGrid) · 143
' set the mask so the user can enter a phone number,
' with optional area code, and a state in uppercase letters.
' use an asterisk as a placeholder
flex.EditMask = "(###) 000-0000 St" + "ate" > LL '
// set the mask so the user can enter a phone number,
// with optional area code, and a state in uppercase letters.
// use an asterisk as a placeholder
flex.EditMask = "(###) 000-0000 St\ate\: >LL;*";
• Delphi
// set the mask so the user can enter a phone number,
// with optional area code, and a state in uppercase letters.
// use an asterisk as a placeholder
flex.EditMask := '(###) 000-0000 St'#7'te >LL;*';
Für mehr Details und Beispiele über Zellbearbeitung, schauen Sie bitte unter „Zellen bearbeiten“ (Seite
37.)
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
Editor-Eigenschaft (C1FlexGrid)
Gibt den aktuellen Zelleditor zurück, oder legt eine Steuerung, die als Editor verwendet werden soll, fest
(kann nur während des StartEdit-Ereignisses gesetzt werden).
Syntax

144 · C1FlexGrid-Referenzverzeichnis
[VB]
Public Editor As Control
[C#]
public Control Editor {get;set;}
[Delphi]
property Editor: Control;
Bemerkungen
Die Editor-Eigenschaft gibt einen Verweis auf einen Zelleditor zurück, der gerade aktiv ist. Dies kann
einer der integrierten Editoren (eine TextBox-, eine ComboBox- oder eine DateTimePicker-Steuerung),
ein externer Editor oder Null (wenn die Tabelle sich nicht im Bearbeitungsmodus befindet) sein.
Sie können diese Eigenschaft verwenden, um programmatisch Zugang zu den Editoren zu verschaffen
oder um herauszufinden, ob sich die Tabelle im Bearbeitungsmodus befindet.
Wenn Sie die integrierten Editoren nicht verwenden wollen, so können Sie stattdessen auch jede andere
Steuerung verwenden. Um dies zu tun, müssen Sie den externen Editor über die Editor-Eigenschaften
mit einer der Tabellen-Row, -Column oder einem CellStyle verknüpfen. Dies Informationen können Sie
jederzeit festlegen oder auch abrufen.
Alternativ können Sie auch das StartEdit-Ereignis abfangen und eine beliebige Steuerung direkt der
Editor-Tablleneigenschaft zuordnen. (Beachten Sie, dass die Editor-Eigenschaft der Tabelle nur während
des StartEdit-Ereignisses gesetzt werden kann und diese automatisch auf Null gesetzt wird, wenn die
Tabelle den Bearbeitungsmodus verlässt.)
Obwohl jede beliebige Steuerung als externen Editor verwendet werden kann, sollten diese dennoch die
IC1EmbeddedEditor-Schnittstelle implementieren, um die vollständige Integration mit der Tabelle
sicherzustellen. Einige Steuerungen implementieren diese Schnittstelle standardmäßig und benötigen
daher keinen weiteren Quellcode, um diese als Tabelleneditoren zu verwenden (wie z.B. die in der
C1Input-Bibliothek). Für die meisten jedoch müssen Sie einige der Methoden des IC1EmbeddedEditors
implementieren.
Zum Beispiel über eigene Editoren, schauen Sie bitte unter „Benutzerdefinierte Editoren verwenden“
(Seite 46 ) und „Benutzerdefinierte Editoren erstellen“ (Seite 47 )in dieser Dokumentation nach, oder
besuchen Sie unsere online Beispielbibliothek und laden Sie das „CustomEditors“-Beispiel herunter.
Beispiel
Dieser Quellcode verwendet die Editor-Eigenschaft um zu prüfen, ob sich die Tabelle im
Bearbeitungsmodus befindet und hindert den Benutzer zu scrollen, während eine Zelle bearbeitet wird:
• Visual Basic
• C#
Private flex_ As Sub New(sender As Object, e As RangeEventArgs)
If Not (flex.Editor Is Nothing) Then
e.Cancel = True
End If
End Sub 'New
private void flex_ BeforeScroll(object sender, RangeEventArgs e)
{
if (flex.Editor != null)
e.Cancel = true;

}
• Delphi
EditOptions-Eigenschaft · 145
procedure flex_BeforeScroll(sender: System.Object; e: RangeEventArgs);
begin
If flex.Editor nil Then
e.Cancel := True
end; // New
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
EditOptions-Eigenschaft
Beinhaltet Flags, die das Verhalten der integrierten Editoren anpassen können.
Syntax
[VB]
Public-Eigenschaft EditOptions As EditFlags
[C#]
public EditFlags EditOptions {get; set;}
[Delphi]
property EditOptions: EditFlags;
Eigenschaftswerte
Einer der EditFlags-Werte. Der Standardwert ist EditFlags.All, welcher das automatische Suchen und
das automatische Durchblättern in Kombinationsfeldern aktiviert, und Kontrollkästchen für einen
gesamten Auswahlbereich umschaltet.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
ExtendLastCol-Eigenschaft
Legt fest, ob die Breite der letzten Spalte an den zur Verfügung stehenden Platz in der Steuerung
angepasst werden soll.
Syntax
[VB]
Public ExtendLastCol As Boolean
[C#]
public bool ExtendLastCol {get; set;}
[Delphi]
property ExtendLastCol: Boolean;

146 · C1FlexGrid-Referenzverzeichnis
Bemerkungen
Diese Eigenschaft betrifft nur das Zeichnen/die Anzeige der Spalten. Sie verändert nicht die
Width.Column-Klasseneigenschaft der letzten Spalte.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
FocusRect-Eigenschaft
Legt den rechteckigen Fokustyp fest, der um die aktuelle Zelle gelegt wird.
Syntax
[VB]
Public FocusRect As FocusRectEnum
[C#]
public FocusRectEnum FocusRect {get; set;}
[Delphi]
property FocusRect: FocusRectEnum;
Eigenschaftswerte
Einer der FocusRectEnum-Werte. Der Standardwert ist FocusRectEnum.Light.
Bemerkungen
Wenn das Fokusrechteck um die aktuelle Zelle gezeichnet wird, dann erscheint diese im Focus-Format,
welches standardmäßig wie eine normale scrollbare Zelle aussieht (wie in den meisten Tabellen).
Wenn das Fokusrechteck versteckt ist (mit der FocusRectEnum.None-Einstellung), dann wird die
aktuelle Zelle mit dem Highlight-Format gezeichnet.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
GetCellCheck-Eigenschaft
Gibt einen Wert zurück, der anzeigt, ob die Zelle ein Kontrollkästchen beinhaltet.
Syntax
[VB]
Public GetCellCheck As CheckEnum
[C#]
public CheckEnum GetCellCheck(int row, int col)
[Delphi]
property GetCellCheck: CheckEnum

Bemerkungen
Diese Methode ruft Kontrollkästchenwerte einer Zell mit der SetCellCheck-Eigenschaft ab.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
Glyphs-Eigenschaft
Hiermit können Sie alle von der Tabelle angezeigten, integrierten Bilder anpassen.
Syntax
[VB]
Public Glyphs As GridGlyphs
[C#]
public GridGlyphs Glyphs {get;}
[Delphi]
property Glyphs: GridGlyphs;
Bemerkungen
Glyphs-Eigenschaft · 147
Die Glyphs-Eigenschaft gibt ein GridGlyphs-Objekt mit einem Index vom Typ GlyphEnum zurück, das
die Grafik festlegt oder abruft, die Spaltensortierung, erweiterte oder zusammengeklappte
Gliederungsgruppen, Kontrollkästchen, Cursor, Fehlerinformationen, usw., anzeigt.
Zum Beispiel, der nachfolgende Quellcode veranlasst die Tabelle, eine benutzerdefinerte Grafik für
Anzeige der Spaltensortierungsrichtung zu verwenden. (anstatt der üblichen, ausgehöhlten Dreiecke):
• Visual Basic
• C#
_flex.Glyphs(GlyphEnum.Ascending) = imgAscending '
_flex.Glyphs(GlyphEnum.Descending) = imgDescending '
_flex.Glyphs[GlyphEnum.Ascending] = imgAscending;
_flex.Glyphs[GlyphEnum.Descending] = imgDescending;
• Delphi
_flex.Glyphs[GlyphEnum.Ascending] := imgAscending;
_flex.Glyphs[GlyphEnum.Descending] := imgDescending;
Anmerkung: Die Standardgrafik wird wiederhergestellt, indem Sie den Glyph auf Null setzen. Wenn Sie
einen Glyph unsichtbar machen wollen, dann setzten Sie diesen auf eine kleine leere Grafik.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
HighLight-Eigenschaft
Legt fest, wann die ausgewählte Zelle markiert wird.

148 · C1FlexGrid-Referenzverzeichnis
Syntax
[VB]
Public HighLight As HighLightEnum
[C#]
public HighLightEnum HighLight {get; set;}
[Delphi]
property HighLight: HighLightEnum;
Eigenschaftswerte
Einer der HighLightEnum-Werte. Der Standardwert ist HighLightEnum.Always.
Bemerkungen
Hervorgehobene Zellen werden im Highlight-Format gezeichnet.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
Item-Eigenschaft
Gibt/legt die Daten in einer Tabellenzelle zurück/fest.
Syntax
[VB]
Public Item(Row As Integer, Col As Integer) As object
Public Item(Row As Integer, Col As String) As object
[C#]
public object this [ int row, int col ] {get; set;}
public object this [ int row, string col ] {get; set;}
[Delphi]
property Item(Row: Integer; Col: Integer): Object;
property Item(Row: Integer; Col: string): Object;
Bemerkungen
Diese Eigenschaft ist der Indizierer für die C1FlexGrid-Steuerung.
Sie können Zellen mit den row- und column-Indizes oder der Zeilennummer und dem Spaltenname
indizieren, wie im nachfolgendem Beispiel. Einerseits ist es effizienter, numerische Indizes zu
verwenden, da die Tabelle so die Namen der Spalten nicht nachschauen muss. Andererseits ist die
Verwendung von Namen flexibler, da Verweise gültig bleiben, selbst wenn der Nutzer eine Spalte auf
eine neue Position verschiebt.
Wenn ein Wert einer Zelle zugeordnet wird, dann versucht die Tabelle diesen in den entsprechenden Typ
für diese Spalte umzuwandeln. Schauen Sie unter der DataType-Eigenschaft für Spalten nach. Wenn die

KeyActionEnter-Eigenschaft · 149
Tabelle den Wert nicht umwandeln kann, dann startet diese das GridError-Ereignis und die Zuordnung
schlägt fehl.
Schauen Sie unter den GetData- und SetData-Methoden nach.
Upgradenotiz: In der VSFlexGrid ActiveX-Steuerung haben Sie die TextMatrix-Eigenschaft verwendet,
um auf Zellinhalte zuzugreifen und die ColIndex-Eigenschaft um Spalten mit Namen zu indizieren.
Verwenden Sie in C1FlexGrid nun stattdessen die Indizierer.
• Visual Basic
• C#
' create a column, assign it a name and get the new index
Dim myCol As Column = flex.Cols.Add()
myCol.Name = "address"
myCol.DataType = GetType(String)
Dim colIndex As Integer = myCol.Index
' assign a value to a cell using cell coordinates:
flex(1, colIndex) = "555, Broadway" '
' get the value using the column name
MessageBox.Show(("The address is " + flex(1, "address").ToString()))
// create a column, assign it a name and get the new index
Column myCol = flex.Cols.Add();
myCol.Name = "address";
myCol.DataType = typeof(string);
int colIndex = myCol.Index;
// assign a value to a cell using cell coordinates:
flex[1, colIndex] = "555, Broadway";
// get the value using the column name
MessageBox.Show("The address is " + flex[1, "address"].ToString());
• Delphi
var
colIndex: Integer;
myCol: Column;
begin
myCol := flex.Cols.Add;
myCol.Name := 'address';
myCol.DataType := TypeOf(string);
colIndex := myCol.Index;
flex[1] := '555, Broadway';
MessageBox.Show(('The address is ' + flex[1].ToString);
end;
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
Column-Klasse (Seite 339)
Row-Klasse (Seite 324)
KeyActionEnter-Eigenschaft
Legt die auszuführende Aktion fest, wenn der Nutzer die Enter-Taste drückt.

150 · C1FlexGrid-Referenzverzeichnis
Syntax
[VB]
Public KeyActionEnter As KeyActionEnum
[C#]
public KeyActionEnum KeyActionEnter {get; set;}
[Delphi]
property KeyActionEnter: KeyActionEnum;
Eigenschaftswerte
Einer der KeyActionEnum-Werte. Der Standardwert ist KeyActionEnum.MoveDown.
Wert Beschreibung
None
Keine Handlung (das System verwaltet die Zelle). Zum Beispiel, die Tabulatortaste
wird normalerweise für das Durchblättern der Steuerungen auf einem Formular
verwendet.
MoveDown Gehe zur nächsten Zeile, wenn die Taste gedrückt wird.
MoveAcross
MoveAcrossOut
Bemerkungen
Gehe zur nächsten Spalte, wenn die Taste gedrückt wird. Nach der letzten Spalte,
gehe zur nächsten Zeile und zurück zur ersten Spalte.
Gehe zur nächsten Spalte, wenn die Taste gedrückt wird. Nach der letzten Spalte,
gehe zur nächsten Zeile und zurück zur ersten Spalte. Nach der letzten Zeile und
Spalte verschiebe den Fokus zur nächsten Steuerung auf dem Formular.
Standardmäßig verschiebt die Tabelle den Fokus auf die nächste sichtbare Zeile, wenn der Nutzer die
Enter-Taste drückt. Wenn die Tabelle bearbeitbar ist, dann wird diese durch die Enter-Taste in den
Bearbeitungsmodus versetzt und, während sie in diesem Modus verweilt, verschiebt die Enter-Taste den
Cursor nach unten.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109 )
C1FlexGridClassic-Klasse (Seite 450)
KeyActionTab-Eigenschaft
Legt die auszuführende Aktion fest, wenn der Nutzer die Tabulator-Taste drückt.
Syntax
[VB]
Public KeyActionTab As KeyActionEnum
[C#]
public KeyActionEnum KeyActionTab {get; set;}

[Delphi]
property KeyActionTab: KeyActionEnum;
Eigenschaftswerte
Einer der KeyActionEnum-Werte. Der Standardwert ist KeyActionEnum.None.
Wert Beschreibung
None
KeyActionTab-Eigenschaft · 151
Keine Handlung (das System verwaltet die Zelle). Zum Beispiel, die Tabulatortaste
wird normalerweise für das Durchblättern der Steuerungen auf einem Formular
verwendet.
MoveDown Gehe zur nächsten Zeile, wenn die Taste gedrückt wird.
MoveAcross
MoveAcrossOut
Bemerkungen
Gehe zur nächsten Spalte, wenn die Taste gedrückt wird. Nach der letzten Spalte,
gehe zur nächsten Zeile und zurück zur ersten Spalte.
Gehe zur nächsten Spalte, wenn die Taste gedrückt wird. Nach der letzten Spalte,
gehe zur nächsten Zeile und zurück zur ersten Spalte. Nach der letzten Zeile und
Spalte verschiebe den Fokus zur nächsten Steuerung auf dem Formular.
Standardmäßig wird die Tabelle die Tabulator-Taste ignorieren. Sie wird durch das Formular
abgewickelt und verschiebt den Fokus auf die nächste Steuerung. Wenn Sie die KeyActionTab-
Eigenschaft auf einen von KeyActionEnum.None verschiedenen Wert setzen, dann wird die Tabelle die
Tabulator-Taste abfangen und diese für die Navigation durch die Zellen verwenden.
Beispiel
Der nachfolgende Quellcode ändert den Wert der KeyActionTab-Eigenschaft basierend auf der aktuellen
Zelle. Der Nutzer kann die Tabulator-Taste drücken, um durch die Zellen zu navigieren bis er am Ende
der Tabelle angelangt ist. Wenn er diese erneut drückt, dann wird der Fokus auf die nächste Steuerung
verschoben.
• Visual Basic
• C#
Private Sub flex_Enter(sender As Object, e As System.EventArgs)
flex.Select(flex.Rows.Fixed, flex.Cols.Fixed)
End Sub 'flex_Enter
Private Sub flex_RowColChange(sender As Object, e As System.EventArgs)
Dim lastCell As Boolean
lastCell = flex.Col = flex.Cols.Count - 1 And _
flex.Row = flex.Rows.Count - 1
If lastCell Then
flex.KeyActionTab = KeyActionEnum.None
Else
flex.KeyActionTab = KeyActionEnum.MoveAcross
End If
End Sub 'flex_RowColChange
private void flex_Enter(object sender, System.EventArgs e)
{
flex.Select(flex.Rows.Fixed, flex.Cols.Fixed);
}
private void flex_RowColChange(object sender, System.EventArgs e)

152 · C1FlexGrid-Referenzverzeichnis
{
}
• Delphi
bool lastCell = (flex.Col == flex.Cols.Count-1 &&
flex.Row == flex.Rows.Count-1);
flex.KeyActionTab = (lastCell)
? KeyActionEnum.None
: KeyActionEnum.MoveAcross;
procedure Class1.flex_Enter(sender: System.Object; e:
System.EventArgs);
begin
flex.Select(flex.Rows.Fixed, flex.Cols.Fixed);
end;
procedure flex_RowColChange(sender: System.Object; e:
System.EventArgs);
var
lastCell: Boolean;
begin
lastCell := (flex.Col = flex.Cols.Count – 1_ And
(flex.Row = flex.Rows.Count – 1);
If lastCell Then
flex.KeyActionTab := KeyActionEnum.None
Else
flex.KeyActionTab := KeyActionEnum.MoveAcross;
end; // flex_RowColChange
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109 )
C1FlexGridClassic-Klasse (Seite 450)
LeftCol-Eigenschaft
Gibt/legt den Index der am weitesten links liegenden, nicht fixierten Spalte zurück/fest.
Syntax
[VB]
Public LeftCol As Integer
[C#]
public int LeftCol {get; set;}
[Delphi]
property LeftCol: Integer;
Bemerkungen
Wenn die LeftCol-Eigenschaft gesetzt wird, dann scrollt die Tabelle horizontal, so dass die gegebenen
Spalten, die am äußersten linken Rand noch sichtbaren sind. Dies ist nützlich, wenn Sie zwei oder mehr
Tabellen synchronisieren wollen und somit, wenn die eine gescrollt wird, die andere sich mitbewegt.
Verwenden Sie die TopRow-Eigenschaft, um vertikal zu scrollen.
Der größte Wert dieser Eigenschaft ist die Summe aller Spalten, minus derer, die auf dem Bildschirm
gleichzeitig angezeigt werden können. Wenn Sie LeftCol auf einen größeren Wert stellen, dann wird die
Steuerung den größtmöglichen Wert für diese Tabelle ohne Fehlermeldung annehmen.

MouseCol-Eigenschaft · 153
Die Werte, die von den LeftCol- und TopRow-Eigenschaften zurückgegeben werden, entsprechen den
auf dem Bildschirm teilweise oder vollständig sichtbaren Zeilen und Spalten.
Verwenden Sie die LeftCol- und TopRow-Eigenschaften um mit Zellen als Einheiten, und die
ScrollPosition-Eigenschaft um mit Pixel als Einheiten zu scrollen.
Verwenden Sie die ShowCell-Methode um sicherzustellen, dass eine Zelle angezeigt wird.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
MouseCol-Eigenschaft
Gibt/legt den Index der Spalte unter dem Mauszeiger zurück/fest.
Syntax
[VB]
Public MouseCol As Integer
[C#]
public int MouseCol {get;}
[Delphi]
property MouseCol: Integer;
Bemerkungen
Die MouseRow- und MouseCol-Eigenschaften sind oft nützlich, wenn das BeforeMouseDown-Ereignis
abgefangen wird, um das Verhalten der Maus anzupassen. Sie sind für die Abwicklung von
Mausereignissen, welche die Auswahl nicht verändern, und für das Aufzuspüren von Klicks auf den
fixierten Bereich einer Tabelle nützlich.
Eine typische Verwendung für diese Eigenschaften beinhalten die Anzeige von Hilfeinformationen oder
Quickinfos, wenn der Nutzer den Mauszeiger über eine Auswahl schiebt, und die Implementation von
manuellen Drag-And-Drop Anpassungen von OLE-Objekten.
Die MouseRow- und MouseCol-Eigenschaften geben –1 zurück, wenn sich der Mauszeiger über keiner
Zelle befindet.
Beispiel
Dieser Quellcode wird eine Quickinfo mit den Koordinaten der Zelle unter dem Cursor anzeigen:
• Visual Basic
• C#
Private Sub flex_MouseMove(sender As Objec
t, e As System.Windows.Forms.MouseEventArgs)
' build tooltip text
Dim str As String = String.Format("This is cell {0}, {1}",
flex.MouseRow, flex.MouseCol)
' ttip is a Windows.Forms.ToolTip component
If str ttip.GetToolTip(flex) Then
ttip.SetToolTip(flex, str)
End If
End Sub 'flex_MouseMove

154 · C1FlexGrid-Referenzverzeichnis
private void flex_MouseMove(object sender,
System.Windows.Forms.MouseEventArgs e)
{
// build tooltip text
string str = string.Format("This is cell {0}, {1}",
flex.MouseRow, flex.MouseCol);
}
• Delphi
// ttip is a Windows.Forms.ToolTip component
if (str != ttip.GetToolTip(flex))
ttip.SetToolTip(flex, str);
procedure flex_MouseMove(sender: System.Object; e:
System.Windows.Forms.MouseEventArgs);
var
str: string;
begin
// build tooltip text
str := String.Format('This is cell {0}, {1}', flex.MouseRow,
flex.MouseCol);
// ttip is a Windows.Forms.ToolTip component
If str ttip.GetToolTip(flex) Then
ttip.SetToolTip(flex, str);
end; // flex_MouseMove
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
MouseRow-Eigenschaft
Gibt/legt den Index der Zeile unter dem Mauszeiger zurück/fest.
Syntax
[VB]
Public MouseRow As Integer
[C#]
public int MouseRow {get;}
[Delphi]
property MouseRow: Integer;
Bemerkungen
Die MouseRow- und MouseCol-Eigenschaften geben –1 zurück, wenn sich der Mauszeiger über keiner
Zelle befindet.
Für Details und ein Beispiel, schauen Sie bitte unter der MouseCol-Eigenschaft nach.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)

PrintParameters-Eigenschaft
Gibt ein GridPrinter-Objekt zurück, das die Druckparameter der Tabelle festlegt.
Syntax
[VB]
Public PrintParameters As GridPrinter
[C#]
public GridPrinter PrintParameters {get;}
[Delphi]
property PrintParameters: GridPrinter;
Bemerkungen
PrintParameters-Eigenschaft · 155
Verwenden Sie die PrintGrid-Methode, um die Tabelle zu drucken und um den Dokumentnamen,
allgemeine Druckoptionen, Kopf- und Fußzeilen festzulegen. Verwenden Sie hingegen die
PrintParameters-Eigenschaft, um weniger allgemeine Druckoptionen, wie z.B. Kopf- und
Fußzeilenschriftart, Seitenränder und Ausrichtung, festzulegen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
Redraw-Eigenschaft
Legt fest, ob die Tabelle ihren Inhalt zeichnen soll.
Syntax
[VB]
Public Redraw As Boolean
[C#]
public bool Redraw {get; set;}
[Delphi]
property Redraw: Boolean;
Bemerkungen
Die Redraw-Eigenschaft wird für die Leistungsoptimierung der Tabelle genutzt. Bevor Sie tiefgreifende
Änderungen in der Tabelle vornehmen, setzen Sie Redraw auf FALSE, um das Zeichnen der Zellen zu
verhindern. Wenn die Änderungen erledigt sind, dann setzen Sie Redraw wieder auf TRUE. Dies wird
das Flackern verhindern und die Leistung steigern. Diese Optimierung ist besonders effektiv, wenn viele
neue Zeilen der Tabelle angefügt werden, weil diese mit jeder neu hinzugefügten Zeile Bereiche neu
berechnen und die Bildlaufleisten aktualisieren muss.
Beispiel
Dieser nachfolgende Quellcode stellt die permanente Neuzeichnung aus, ändert den Inhalt der Tabelle
und stellt anschließend die Neuzeichnung wieder an, um das Ergebnis zu zeigen.
• Visual Basic

156 · C1FlexGrid-Referenzverzeichnis
• C#
Private Function UpdateGrid(flex As c1FlexGrid) As function
flex.Redraw = False ' suspend painting to avoid flicker
flex.Rows.Count = 1
Dim i As Integer
For i = 1 To 9999
flex.AddItem(("Row " + i.ToString()))
Next i
flex.Redraw = True ' resume painting
End Function 'UpdateGrid
private function UpdateGrid(c1FlexGrid flex)
{
flex.Redraw = false; // suspend painting to avoid flicker
flex.Rows.Count = 1;
for (int i = 1; i < 10000; i++)
flex.AddItem("Row " + i.ToString());
flex.Redraw = true; // resume painting
}
• Delphi
function Class1.UpdateGrid(flex: c1FlexGrid): &function;
var
i: Integer;
begin
flex.Redraw := False;
flex.Rows.Count := 1;
for I := 1 to 9999 do
flex.AddItem('Row ' + System.Object(i).ToString);
flex.Redraw := True;
end;
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109 )
C1FlexGridClassic-Klasse (Seite 450)
RightCol-Eigenschaft
Gibt den Index der am weitesten rechtsstehenden Spalte zurück.
Syntax
[VB]
Public RightCol As Integer
[C#]
public int RightCol {get;}
[Delphi]
property RightCol: Integer;
Bemerkungen
Die rechte, zurückgegebene Spalte ist möglicherweise nur teilweise sichtbar.

Row-Eigenschaft · 157
Sie können diese Eigenschaft nicht setzen. Verwenden Sie die TopRow und LeftCol-Eigenschaften, um
den Inhalt der Tabelle zu scrollen.
Verwenden Sie die ShowCell-Methode um sicherzustellen, dass eine Zelle angezeigt wird.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
Row-Eigenschaft
Gibt/legt den Index der ausgewählten Zeile zurück/fest.
Syntax
[VB]
Public Row As Integer
[C#]
public int Row {get; set;}
[Delphi]
property Row: Integer;
Bemerkungen
Verwenden Sie die Row- und Col-Eigenschaften um eine Zelle aktuell zu machen, oder herauszufinden,
in welcher Zeile oder Spalte sich die aktuelle Zelle befindet. Spalten und Zeilen werden von Null an,
beginnend von der obersten Zeile und der linken Spalte nummeriert.
Die Row-Eigenschaft kann auf -1, um die Auswahl auszublenden, auf einen Wert zwischen Null und
Rows.Fixed-1, um eine Zelle in einer fixierten Zeile, oder auf einen Wert zwischen Rows.Fixed und
Rows.Count-1, um eine scrollbare Zeile auszuwählen, gesetzt werden.
Indem man die Row- und Col-Eigenschaften setzt, wird die Auswahl automatisch auf eine einzelne Zelle
beschränkt und damit die Eigenschaften RowSel und ColSel zurückgesetzt. Um eine Blockauswahl
vorzunehmen, müssen Sie zuerst Row und Col und dann RowSel und ColSel festlegen. Oder Sie
verwenden die Select-Methode, um eine willkürliche Auswahl mit einem einzigen Befehl vorzunehmen.
Indem die Row- und Col-Eigenschaften gesetzt werden, kann nicht sichergestellt werden, dass die Zelle
auf dem Bildschirm sichtbar ist. Um dies zu tun, müssen Sie die ShowCell-Methode anwenden.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
Rows-Eigenschaft
Gibt die alle Zeilen der Tabelle zurück.
Syntax
[VB]
Public Rows As RowCollection
[C#]

158 · C1FlexGrid-Referenzverzeichnis
public RowCollection Rows {get;}
[Delphi]
property Rows: RowCollection;
Bemerkungen
Mit der Rows-Eigenschaft können Sie eine Liste mit allen derzeit vorhandenen Zeilen in einer Tabelle
abfragen. Mit dieser Referenz können Sie Zeilen hinzufügen, entfernen, verschieben und zählen. Für
weitere Informationen über die Funktionen dieser Sammlung, schauen Sie in den Referenzthemen der
RowCollection-Klasse nach.
Diese Eigenschaft kann nur gelesen werden. Die Tabelle erstellt und verwaltet diese Liste/Sammlung.
Upgradenotiz: In der VSFlexGrid-ActiveX-Steuerung zeigen die Rows- und FixedRows-Eigenschaften
die Anzahl der Zeilen und der fixierten Zeilen in einer Tabelle. Verwenden Sie in C1FlexGrid
Rows.Count und Rows.Fixed hierfür.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109 )
C1FlexGridClassic-Klasse (Seite 450)
RowSel-Eigenschaft
Gibt/legt den Index der letzt Zeile der aktuellen Auswahl zurück/fest.
Syntax
[VB]
Public RowSel As Integer
[C#]
public int RowSel {get; set;}
[Delphi]
property RowSel: Integer;
Bemerkungen
Verwenden Sie die RowSel- und ColSel-Eigenschaften, um eine Auswahl zu verändern oder um zu
bestimmen, welche Zellen gerade ausgewählt sind. Spalten und Zeilen werden von Null an, beginnend
von der obersten Zeile und der linken Spalte nummeriert.
Indem man die Row- und Col-Eigenschaften setzt, wird die Auswahl automatisch auf eine einzelne Zelle
beschränkt und damit die Eigenschaften RowSel und ColSel zurückgesetzt. Um eine Blockauswahl
vorzunehmen, müssen Sie zuerst Row und Col und dann RowSel und ColSel festlegen. Oder Sie
verwenden die Select-Methode, um eine willkürliche Auswahl mit einem einzigen Befehl vorzunehmen.
Wenn die SelectionMode-Eigenschaft auf Listbox gesetzt ist, dann sollten Sie die Selected-Eigenschaft
für die Auswahl einzelner Zeilenobjekte verwenden.
Wenn ein Bereich ausgewählt ist, dann kann der Wert von Row oder Col größer oder kleiner als der von
RowSel oder ColSel sein. Dies ist recht lästig, wenn Sie Grenzen für Schleifen setzen wollen. In diesen
Fällen können Sie die Selection-Eigenschaft verwenden, um ein normalisiertes CellRange-Objekt
abzufragen, indem r1

Schauen Sie unter der ColSel-Eigenschaft für ein Beispiel nach.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
ScrollBars-Eigenschaft
Gibt zurück/legt fest welche Bildlaufleisten in der Tabelle angezeigt werden.
Syntax
[VB]
Public ScrollBars As ScrollBars
[C#]
public ScrollBars ScrollBars {get; set;}
[Delphi]
property ScrollBars: ScrollBars;
Eigenschaftswerte
ScrollBars-Eigenschaft · 159
Einer der Aufzählungswerte von ScrollBars, die zeigen, ob die Tabelle keine Bildlaufleisten, eine
horizontale Bildlaufleiste, eine vertikale Bildlaufleiste oder beide haben soll. Der Standardwert ist
ScrollBars.Both.
Bemerkungen
Bildlaufleisten werden nur dann angezeigt, wenn die Inhalte der Steuerung die Grenzen überschreiten.
Zum Beispiel, wenn ScrollBars auf ScrollBars.Horizontal steht, dann wird die horizontale Bildlaufleiste
auch nur dann angezeigt, wenn die Steuerung nicht breit genug ist, um alle Spalten auf einmal auf dem
Bildschirm anzuzeigen.
Auch wenn die Tabelle keine Bildlaufleisten besitzt, wird die Steuerung immer noch scrollen, um eine
Auswahl vollständig anzuzeigen. Wenn Sie scrollen verhindern wollen, dann müssen Sie das
BeforeScroll-Ereignis abfangen und dessen Cancel-Parameter auf TRUE setzen.
Beachten Sie, dass wenn die ScrollBars-Eigenschaft auf ScrollBars.Both steht, nicht zwingend beide
Bildlaufleisten angezeigt werden. Diese werden nur erscheinen, wenn die Steuerung mehr Zeilen oder
Spalten besitzt, als auf einmal auf dem Bildschirm angezeigt werden können. Um festzustellen, ob die
Bildlaufleisten derzeit sichtbar sind, können Sie einen Quellcode wie den folgenden verwenden:
• Visual Basic
Function CheckScrollBars(fg As C1.Win.C1FlexGrid.C1FlexGrid) As
ScrollBars
Dim SBWID As Integer = SystemInformation.VerticalScrollBarWidth
Dim SBHEI As Integer = SystemInformation.HorizontalScrollBarHeight
Dim rcCtl As Rectangle = fg.Bounds
Dim rcClient As Rectangle = fg.ClientRectangle
Dim vbar As Boolean = rcCtl.Width - rcClient.Width >= SBWID
Dim hbar As Boolean = rcCtl.Height - rcClient.Height >= SBHEI
If vbar And hbar Then
Return ScrollBars.Both
End If

160 · C1FlexGrid-Referenzverzeichnis
• C#
If vbar Then
Return ScrollBars.Vertical
End If
If hbar Then
Return ScrollBars.Horizontal
End If
Return ScrollBars.None
End Function 'CheckScrollBars
ScrollBars CheckScrollBars(C1.Win.C1FlexGrid.C1FlexGrid fg)
{
int SBWID = SystemInformation.VerticalScrollBarWidth;
int SBHEI = SystemInformation.HorizontalScrollBarHeight;
}
• Delphi
Rectangle rcCtl = fg.Bounds;
Rectangle rcClient = fg.ClientRectangle;
bool vbar = (rcCtl.Width - rcClient.Width >=SBWID);
bool hbar = (rcCtl.Height - rcClient.Height >= SBHEI);
if (vbar && hbar) return ScrollBars.Both;
if (vbar) return ScrollBars.Vertical;
if (hbar) return ScrollBars.Horizontal;
return ScrollBars.None;
function CheckScrollBars(fg: C1.Win.C1FlexGrid.C1FlexGrid): ScrollBars;
var
hbar: Boolean;
vbar: Boolean;
rcClient: Rectangle;
rcCtl: Rectangle;
SBHEI: Integer;
SBWID: Integer;
CheckScrollBars: ScrollBars;
begin
SBWID := SystemInformation.VerticalScrollBarWidth;
SBHEI := SystemInformation.HorizontalScrollBarHeight;
rcCtl := fg.Bounds;
rcClient := fg.ClientRectangle;
vbar := rcCtl.Width - rcClient.Width >= SBWID;
hbar := rcCtl.Height - rcClient.Height >= SBHEI;
if vbar And hbar then
begin
Result := ScrollBars.Both;
exit;
end;
if vbar then
begin
Result := ScrollBars.Vertical;
exit;
end;
if hbar then
begin
Result := ScrollBars.Horizontal;
exit;

end;
Result := ScrollBars.None;
end; // CheckScrollBars
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
ScrollPosition-Eigenschaft
Gibt/legt die Bildlaufleistenposition zurück/fest.
Syntax
[VB]
Public ScrollPosition As Point
[C#]
public Point ScrollPosition {get; set;}
[Delphi]
property ScrollPosition: Point;
Eigenschaftswerte
Ein Point-Objekt, das die Bildlaufleistenposition in Pixeln enthält.
Bemerkungen
ScrollPosition-Eigenschaft · 161
Verwenden Sie die ScrollPosition-Eigenschaft um mit Pixel als Einheiten, und die LeftCol- und
TopRow-Eigenschaften, um mit Zellen als Einheiten zu scrollen.
Beispiel
Dieser Quelltext bindet zwei Tabellen (fgLeft und fgRight) zusammen und synchronisiert deren
vertikalen Bildlauf. Die Nutzer können nur noch horizontal unabhängig scrollen.
• Visual Basic
' bind grids together
fgRight.DataSource = fgLeft
fgLeft.ScrollBars = ScrollBars.Horizontal
' synchronize vertical scrolling
Private Sub flex_AfterScroll(sender As Object, _
e As C1.Win.C1FlexGrid.RangeEventArgs)
' update sender grid (could be fgLeft or fgRight)
Dim fg As C1FlexGrid.C1FlexGrid = CType(sender, C1FlexGrid) '
fg.Update()
' get new vertical position from sender grid
Dim y As Integer = fg.ScrollPosition.Y
' apply new vertical position to the other grid
If fg = fgLeft Then
fgRight.ScrollPosition = New Point(fgRight.ScrollPosition.X, y)
Else
fgLeft.ScrollPosition = New Point(fgLeft.ScrollPosition.X, y)

162 · C1FlexGrid-Referenzverzeichnis
• C#
End If
End Sub 'flex_AfterScroll
// bind grids together
fgRight.DataSource = fgLeft;
fgLeft.ScrollBars = ScrollBars.Horizontal;
// synchronize vertical scrolling
private void flex_AfterScroll(object sender,
C1.Win.C1FlexGrid.RangeEventArgs e)
{
// update sender grid (could be fgLeft or fgRight)
C1FlexGrid.C1FlexGrid fg = ((C1FlexGrid)sender);
fg.Update();
}
• Delphi
// get new vertical position from sender grid
int y = fg.ScrollPosition.Y;
// apply new vertical position to the other grid
if (fg == fgLeft)
fgRight.ScrollPosition = new Point(fgRight.ScrollPosition.X, y);
else
fgLeft.ScrollPosition = new Point(fgLeft.ScrollPosition.X, y);
// bind grids together
fgRight.DataSource := fgLeft;
fgLeft.ScrollBars := ScrollBars.Horizontal;
// synchronize vertical scrolling
procedure flex_AfterScroll(sender: System.Object;
e: C1.Win.C1FlexGrid.RangeEventArgs);
var
fg: C1FlexGrid;
begin
// update sender grid (could be fgLeft or fgRight)
fg := C1FlexGrid (sender);
fg.Update;
// get new vertical position from sender grid
y := fg.ScrollPosition.Y;
// apply new vertical position to the other grid
if fg = fgLeft then
fgRight.ScrollPosition := Point.Create(fgRight.ScrollPosition.X, y)
else
fgLeft.ScrollPosition := Point.Create(fgLeft.ScrollPosition.X, y);
end; // flex_AfterScroll
Upgradenotiz: Die VSFlexGrid-Steuerung hat immer genau eine Zelle gescrollt und hat nichts
Vergleichbares zur ScrollPosition-Eigenschaft besessen. Das C1FlexGrid kann in Pixeln scrollen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
ScrollTrack-Eigenschaft
Legt das Tabellenverhalten fest, während der Nutzer die Bildlaufleisten zieht.

Syntax
[VB]
Public ScrollTrack As Boolean
[C#]
public bool ScrollTrack {get; set;}
[Delphi]
property ScrollTrack: Boolean;
Bemerkungen
ScrollTips-Eigenschaft · 163
Wenn ScrollTrack auf TRUE steht (Standardwert), dann scrollt die Tabelle, während der Nutzer die
Bildlaufleisten zieht.
Wenn ScrollTrack auf FALSE steht, dann aktualisiert die Tabelle die Ansicht nicht, bis der Nutzer die
Bildlaufleisten los lässt.
Wenn die Tabelle sehr groß ist und viele Daten enthält, dann können Sie Scrollen beschleunigen, indem
Sie ScrollTrack auf FALSE setzen. In diesem Fall sollte die Verwendung der ScrollTips-Eigenschaft in
Betracht gezogen werden, um dem Nutzer eine Orientierung im Dokument zu geben, während er scrollt.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
ScrollTips-Eigenschaft
Gibt zurück/legt fest, ob Quickinfos angezeigt werden, wenn der Nutzer die vertikale Bildlaufleiste
zieht.
Syntax
[VB]
Public ScrollTips As Boolean
[C#]
public bool ScrollTips
[Delphi]
property ScrollTips: Boolean;
Bemerkungen
Verwenden Sie die ScrollTips-Eigenschaft, um eine Quickinfo über der vertikalen Bildlaufleiste
anzuzeigen, während der Nutzer den Bildlaufleistenbalken zieht. Diese zeigt ihm, welche Zeile sichtbar
wird, wenn er den Bildlaufbalken loslässt. Diese Funktion erleichtert die Suche nach bestimmten Zeilen
in großen Datentabellen und ist besonders sinnvoll, wenn die ScrollTrack-Eigenschaft auf FALSE steht,
weil dann die Tabelle solange nicht scrollt, bis der Nutzer den Balken loslässt.
Sie müssen folgende Schritte ausführen, um diese Funktion in Ihrem Programm zu implementieren:
1. Setzen Sie die ScrollTips-Eigenschaft auf TRUE.

164 · C1FlexGrid-Referenzverzeichnis
Beispiel
2. Fangen Sie das BeforeScrollTip-Ereignis ab, indem Sie die ScrollTipText-Eigenschaft auf einen
Text setzen, der die aktuelle Zeile nennt.
Dieser Quellcode zeigt eine Scrollinfo mit dem Index und den Daten der obersten sichtbar werdenden
Zeile, wenn der Nutzer den Balken freigeben würde, an.
• Visual Basic
• C#
flex.ScrollTips = True
flex.ScrollTrack = False
Private Sub flex_BeforeScrollTip(sender As Object, e As
RowColEventArgs)
Dim tip As String = String.Format("Row {0}" + ControlChars.Lf +
"{1}", e.Row, flex(e.Row, 1))
flex.ScrollTipText = tip
End Sub 'flex_BeforeScrollTip
flex.ScrollTips = True
flex.ScrollTrack = False
Private Sub flex_BeforeScrollTip(sender As Object, e As
RowColEventArgs)
Dim tip As String
tip = String.Format("Row {0}" + ControlChars.Lf + "{1}", _
e.Row, flex(e.Row, 1))
flex.ScrollTipText = tip
End Sub 'flex_BeforeScrollTip
• Delphi
flex.ScrollTips := True;
flex.ScrollTrack := False;
procedure Class1.flex_BeforeScrollTip(sender: System.Object; e:
RowColEventArgs);
var
tip: string;
begin
tip := Format('Row {0}'#10'{1}', e.Row, flex[e.Row]);
flex.ScrollTipText := tip;
end;
Scrollinfo ist ein besonderer Typ der Quickinfo, die an die vertikale Bildlaufleiste gebunden ist.
Verwenden Sie die ToolTip-Steuerung, um allgemeine Quickinfos anzuzeigen (z.B. über Zellen):
• Visual Basic
Private ttip As New ToolTip(Me.components)
Private Sub flex_MouseMove(sender As Object, e As
System.Windows.Forms.MouseEventArgs)
Dim str As String
str = String.Format("This is cell {0}, {1}", _
flex.MouseRow, flex.MouseCol)
If str ttip.GetToolTip(flex) Then
ttip.SetToolTip(flex, str)
End If
End Sub 'flex_MouseMove

• C#
private ToolTip ttip = new ToolTip(this.components);
private void flex_MouseMove(object sender,
System.Windows.Forms.MouseEventArgs e)
{
string str = string.Format("This is cell {0}, {1}",
flex.MouseRow, flex.MouseCol);
if (str != ttip.GetToolTip(flex))
ttip.SetToolTip(flex, str);
}
• Delphi
private
ttip: ToolTip;
procedure flex_MouseMove(sender: System.Object; e:
System.Windows.Forms.MouseEventArgs);
var
str: string;
begin
str := System.String.Format('This is cell {0}, {1}', _
flex.MouseRow, flex.MouseCol);
if str ttip.GetToolTip(flex) then
ttip.SetToolTip(flex, str);
end; // flex_MouseMove
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
ScrollTipText-Eigenschaft
ScrollTipText-Eigenschaft · 165
Gibt/legt die Quickinfo zurück/fest, die angezeigt wird, wenn der Nutzer die vertikale Bildlaufleiste
zieht.
Syntax
[VB]
Public ScrollTipText As String
[C#]
public string ScrollTipText {get; set;}
[Delphi]
property ScrollTipText: string;
Bemerkungen
Setzen Sie diese Eigenschaft als Antwort auf das BeforeScrollTip-Ereignis, um Information über eine
gegebene Zeile, während der Nutzer den Inhalt der Tabelle scrollt, anzuzeigen.
Für mehr Details und Beispiele schauen Sie bitte unter der ScrollTips-Eigenschaft nach.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)

166 · C1FlexGrid-Referenzverzeichnis
Selection-Eigenschaft
Gibt ein CellRange-Objekt mit der aktuellen Auswahl zurück.
Syntax
[VB]
Public Selection As CellRange
[C#]
public CellRange Selection {get;}
[Delphi]
property Selection: CellRange;
Eigenschaftswerte
Ein CellRange-Objekt, das für die Veränderung von Zellen in einer Auswahl verwendet werden kann.
Bemerkungen
Der Bereich entspricht der aktuellen Auswahl, die durch die Row-, Col-, RowSel- und ColSel-
Eigenschaften definiert ist. Dieser Bereich ist normalisiert, so dass r1

Die Ausführung des Quellcodes erzuegt folgendes Ergebnis:
SelectionMode-Eigenschaft · 167
Cursor CellRange: (1,1)-(1,1), Selection CellRange: (1,1)-(5,5)
Cursor CellRange: (5,5)-(5,5), Selection CellRange: (1,1)-(5,5)
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
SelectionMode-Eigenschaft
Legt das Auswahlverhalten der Tabelle fest.
Syntax
[VB]
Public SelectionMode As SelectionModeEnum
[C#]
public SelectionModeEnum SelectionMode {get; set;}
[Delphi]
property SelectionMode: SelectionModeEnum;
Eigenschaftswerte
Einer der SelectionModeEnum-Werte. Der Standardwert ist SelectionModeEnum.Default.
Bemerkungen
In den meisten Auswahlmodi können Sie die aktuelle Auswahl mit der Selection-Eigenschaft abfragen.
Wenn allerdings der SelectionMode auf SelectionModeEnum.ListBox gesetzt ist, dann muss die
Auswahl nicht zwingend aus einem ununterbrochenen Zeilenbereich bestehen. In diesem Fall können Sie
den Auswahlstatus von einzelnen oder allen ausgewählten Zeilen mit der Selected-Eigenschaft für Zeilen
abfragen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGridClassic-Klasse (Seite 450)
SetCellCheck-Eigenschaft
Legt den Zustand eines Kontrollkästchens in einer Zelle fest.
Syntax
[VB]
Public SetCellCheck As Integer
[C#]
public Integer SetCellCheck {get; set;}
[Delphi]
property SetCellCheck: Integer;

168 · C1FlexGrid-Referenzverzeichnis
Bemerkungen
Neben den gewöhnlichen Zellinhalten können Sie auch Kontrollkästchen anzeigen lassen. Hiefür stehen
Ihnen zwei Möglichkeiten zur Verfügung:
1. Um Kontrollkästchen direkt den Zellen zuzuordnen, können Sie die SetCellCheck- und
GetCellCheck-Eigenschaften verwenden. In diesem Fall sind der Zellinhalt und das
Kontrollkästchen unabhängig und Sie können Kästchen mit zwei oder drei Zuständen
verwenden.
2. Sie können aber auch die DataType-Eigenschaft des Spaltenobjekts auf Boolean setzen, so dass
alle Werte dieser Spalte als Kontrollkästchen mit zwei Zuständen angezeigt werden.
In beiden Modi kann der Nutzer die Kontrollkästchen mit der Maus und der Tastatur umschalten, wenn
die AllowEditing-Eigenschaft auf TRUE steht.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
ShowButtons-Eigenschaft
Legt fest, wann die Tabelle Auswahl- und Popup-Schaltflächen in bearbeitbaren Zellen anzeigen soll.
Syntax
[VB]
Public ShowButtons As ShowButtonsEnum
[C#]
public ShowButtonsEnum ShowButtons {get;}
[Delphi]
property ShowButtons: ShowButtonsEnum;
Eigenschaftswerte
Einer der ShowButtonsEnum-Werte. Der Standardwert ist ShowButtonsEnum.WithFocus.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
ShowCellLabels-Eigenschaft
Zeigt eine Art Quickinfo an, wenn der Mauszeiger über einer Zelle steht, die zu klein für ihren Inhalt ist.
Syntax
[VB]
Public-Eigenschaft ShowCellLabels As Boolean
[C#]
public bool ShowCellLabels {get; set;}
[Delphi]

property ShowCellLabels: Boolean;
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
ShowCursor-Eigenschaft
Legt fest, ob die Tabelle eine Datensatzmarkierungsgrafik anzeigen soll.
Syntax
[VB]
Public ShowCursor As Boolean
[C#]
public bool ShowCursor {get; set;}
[Delphi]
property ShowCursor: Boolean;
Bemerkungen
ShowCursor-Eigenschaft · 169
Legt fest, ob die Tabelle eine Datensatzmarkierungsgrafik auf der ersten fixierten Spalte der aktuellen
Zeile anzeigen soll. Der Datensatzmarkierer ist ein kleines Dreieck, vergleichbar mit denen, die in Access
und den meisten anderen datenbankbasierten Tabellen verwendet wird.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
ShowErrors-Eigenschaft
Ermittelt oder legt fest, ob die Tabelle Fehler in der Datenquelle überwacht und anzeigt. Die Fehler
werden vom Datenquellenobjekt über die IDataErrorInfo-Schnittstelle zur Verfügung gestellt. ADO.NET
und C1Data unterstützen dies.
Syntax
[VB]
Public ShowErrors As Boolean
[C#]
public bool ShowErrors {get; set;}
[Delphi]
property ShowErrors: Boolean;
Bemerkungen
Wenn diese Eigenschaft aktiviert ist, dann werden Zellen mit Fehlern ein Fehlersymbol anzeigen,
anpassbar mit der SetGlyph-Methode. Wenn der Nutzer den Mauszeiger über das Fehlersymbol zieht,
dann wird die Tabelle eine Quickinfo mit einer Fehlerbeschreibung anzeigen. Zum Beispiel:
• Visual Basic
Me._flex.ShowErrors = True

170 · C1FlexGrid-Referenzverzeichnis
• C#
dt.Rows(3).SetColumnError(_dt.Columns(0), "row 3, col 0 is bad") '
dt.Rows(4).SetColumnError(_dt.Columns(1), "this cell is bad too") '
dt.Rows(5).RowError = "This whole row is bad" '
this._flex.ShowErrors = true;
dt.Rows[3].SetColumnError(_dt.Columns[0], "row 3, col 0 is bad");
dt.Rows[4].SetColumnError(_dt.Columns[1], "this cell is bad too");
dt.Rows[5].RowError = "This whole row is bad";
• Delphi
Self._flex.ShowErrors := True;
dt.Rows[3].SetColumnError(_dt.Columns[0], 'row 3, col 0 is bad');
dt.Rows[4].SetColumnError(_dt.Columns[1], 'this cell is bad too');
dt.Rows[5].RowError := 'This whole row is bad';
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
Styles-Eigenschaft
Gibt alle Zellformate in einer Tabelle zurück.
Syntax
[VB]
Public Styles As CellStyleCollection
[C#]
public CellStyleCollection Styles {get;}
[Delphi]
property Styles: CellStyleCollection;
Bemerkungen
Mit der Styles-Eigenschaft können Sie einen Verweis auf eine Liste aller derzeit in der Tabelle definierten
Formate abfragen. Mit diesem Verweis können Sie Formatvorlagen hinzufügen, entfernen und zählen.
Für weitere Informationen über die Aufgaben, die mit dieser Liste ausgeführt werden können, schauen
Sie unter CellStyleCollection-Klassenreferenzthemen für Informationen über Zellformatierungen unter
CellStyle-Referenzthemen nach.
Diese Eigenschaft kann nur gelesen werden. Die Tabelle erstellt und verwaltet die Liste für Sie.
Upgradenotiz: Die VSFlexGrid ActiveX-Steuerung hatte viele Eigenschaften, welche die Anzeige der
Tabelle beeinflusst haben (z.B. BackColor, BackColorAlternate, BackColorBkg, BackColorFixed,
BackColorFrozen, BackColorSel, usw.). Die C1FlexGrid-Steuerung ersetzt all diese Eigenschaften mit
einer CellStyleCollection der CellStyle-Objekte. Damit ist das Objektmodel einfacher, konsistenter und
stärker. Sie können die bestehenden Formatvorlagen verändern oder Ihre eigenen definieren und diese
Zeilen, Spalten oder willkürlichen Zellebereichen zuordnen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGridClassic-Klasse (Seite 450)

SubTotalPosition-Eigenschaft
SubTotalPosition-Eigenschaft · 171
Legt fest, ob die Subtotal-Methode die Knotenzeilen unter oder über den Daten, die zusammengefasst
werden, einfügt.
Syntax
[VB]
Public SubTotalPosition As SubTotalPositionEnum
[C#]
public SubTotalPositionEnum SubTotalPosition {get; set;}
[Delphi]
property SubTotalPosition: SubTotalPositionEnum;
Eigenschaftswerte
Einer der SubTotalPositionEnum-Werte. Der Standardwert ist SubTotalPositionEnum.AboveData.
Bemerkungen
Diese Eigenschaft legt auch fest, wie der Gliederungsbaum gezeichnet wird. Eine Änderung dieser
Eigenschaft entfernt alle in der Tabelle enthaltenen Knotenzeilen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
TopRow-Eigenschaft
Gibt/legt den Index der obersten sichtbaren und nicht fixierten Zeilen zurück/fest.
Syntax
[VB]
Public TopRow As Integer
[C#]
public int TopRow {get; set;}
[Delphi]
property TopRow: Integer;
Bemerkungen
Wenn Sie einen Wert für die TopRow-Eigenschaft festlegen, dann wird die Tabelle vertikal gescrollt, bis
die eingegebene Zeile am obersten Rand der Anzeige sichtbar wird. Dies ist nützlich, wenn Sie zwei oder
mehr Tabellen synchronisieren wollen und somit, wenn die eine gescrollt wird, die andere sich
mitbewegt. Verwenden Sie die LeftCol-Eigenschaft, um horizontal zu scrollen.
Der größte Wert dieser Eigenschaft ist die Summe aller Zeilen, minus derer, die auf dem Bildschirm
gleichzeitig angezeigt werden können. Wenn Sie TopRow auf einen größeren Wert stellen, dann wird die
Steuerung den größtmöglichen Wert für diese Tabelle ohne Fehlermeldung annehmen.

172 · C1FlexGrid-Referenzverzeichnis
Die Werte, die von den LeftCol- und TopRow-Eigenschaften zurückgegeben werden, entsprechen den
auf dem Bildschirm teilweise oder vollständig sichtbaren Zeilen und Spalten.
Verwenden Sie die LeftCol- und TopRow-Eigenschaften um mit Zellen als Einheiten, und die
ScrollPosition-Eigenschaft um mit Pixel als Einheiten zu scrollen.
Verwenden Sie die ShowCell-Methode, um sicherzustellen, dass eine Zelle angezeigt wird.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
Tree-Eigenschaft
Gibt das GridTree-Objekt zurück, das die Ansicht des Gliederungsbaums in einer Tabelle steuert.
Syntax
[VB]
Public Tree As GridTree
[C#]
public GridTree Tree {get;}
[Delphi]
property Tree: GridTree;
Bemerkungen
Die C1FlexGrid-Steuerung kann Daten hierarchisch gruppieren und diese mit einem erweiterbaren
Gliederungsbaum, ähnlich dem in der Microsoft TreeView-Steuerung, anzeigen. Das GridTree-Objekt
wird für die Festlegung der Position und des Formats von Gliederungsbäumen verwendet.
Diese Eigenschaft kann nur gelesen werden.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGrid-Methoden
AddItem-Methode
Fügt eine neue Zeile der Tabelle hinzu und füllt diese mit den gegebenen Daten.
Syntax
[VB]
Public Function AddItem(item As String) As Row
Public Function AddItem(item As String, index As Integer) As Row
Public Function AddItem(items As Object( )) As Row
Public Function AddItem(items As Object( ), rowIndex As Integer, colIndex As Integer) As Row

[C#]
public Row AddItem (String item )
public Row AddItem (String item , Int index )
public Row AddItem ( object[] items )
public Row AddItem ( object[] items , Int rowIndex , Int colIndex )
[Delphi]
function AddItem(item: string): Row;
function AddItem(item: string; index: Integer): Row;
function AddItem(items: Object): Row;
function AddItems(items: Object; rowIndex: Integer; colIndex: Integer): Row;
Parameter Beschreibung
Item
index
Zeichenkette mit Daten für jede Zelle auf der neuen Zeile. Die Daten werden
standardmäßig von einem Tabulatorzeichen getrennt. Sie können das
Trennzeichen in der ClipSeparators-Eigenschaft ändern.
Position, an der die Zeile eingefügt wird. Wenn dieser Parameter weggelassen
wird, dann fügt die Steuerung die Zeile am Ende der Tabelle an.
items Array mit Objekten, die in die neue Zeile eingefügt werden.
colIndex
Bemerkungen
Erste Spalte, die mit den Daten des items-Array gefüllt wird. Dieser Parameter
ist normalerweise Null oder die erste scrollbare Spalte.
AddItem-Methode · 173
Sie können Zeilen auch mit der Rows-Collection hinzufügen oder entfernen. Die AddItem-Methode stellt
aber einen kurzen Syntax für das Einfügen einer Zeile, mit der Insert-Zeilenmethode, und das Ausfüllen
einer jeden Zelle, zur Verfügung.
Beispiel
Der nachfolgende Quellcode fügt der Tabelle drei Zeilen hinzu:
• Visual Basic
• C#
' add row at the bottom, using tabs as separators
flex.ClipSeparators = vbTab + vbLf '

174 · C1FlexGrid-Referenzverzeichnis
flex.AddItem("col 0\tcol1\tcol2");
// add row at the top, using pipes as separators
flex.ClipSeparators = "|;";
flex.AddItem("col 0|col1|col2", 0);
// add row at the bottom, using an object array
object[] items = { "col0", "col1", 12 };
flex.AddItem(items, flex.Rows.Count, 0);
• Delphi
var
items: array of System.Object;
begin
flex.ClipSeparators := #9#10;
flex.AddItem('col 0'#9'col1'#9'col2');
flex.ClipSeparators := '|;';
flex.AddItem('col 0|col1|col2', 0);
SetLength(items, 3);
items[0] := 'col0';
items[1] := 'col1';
items[2] := System.Object(12);
flex.AddItem(items, flex.Rows.Count, 0);
end;
Für weitere Beispiele, schauen Sie unter der Redraw-Eigenschaft und unter dem Thema „Tabellen in
Textdateien speichern und öffnen“ (Seite 62) nach.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
Aggregate-Methode
Berechnet aggregierte Statistiken für einen Zellbereich.
Syntax
[VB]
Public Function Aggregate(aggType As AggregateEnum) As Double
Public Function Aggregate(aggType As AggregateEnum, flags As AggregateFlags) As Double
Public Function Aggregate(aggType As.AggregateEnum, rg As CellRange) As Double
Public Function Aggregate(aggType As AggregateEnum, rg As CellRange, flags As AggregateFlags) As
Double
Public Function Aggregate(aggType As AggregateEnum, r1 As Integer, c1 As Integer, r2 As Integer, c2
As Integer) As Double
Public Function Aggregate(aggType As AggregateEnum, r1 As Integer, c1 As Integer, r2 As Integer, c2
As Integer, flags As AggregateFlags) As Double
[C#]
public Double Aggregate (AggregateEnum aggType, int r1, int c1, int r2, int c2)
public Double Aggregate (AggregateEnum aggType )
public Double Aggregate (AggregateEnum aggType, CellRange rg )

Aggregate-Methode · 175
public Double Aggregate (AggregateEnum aggType, int r1, int c1, int r2, int c2, AggregateFlags flags)
public Double Aggregate (AggregateEnum aggType, AggregateFlags flags)
public Double Aggregate (AggregateEnum aggType, CellRange rg, AggregateFlags flags)
[Delphi]
function Aggregate(aggType: AggregateEnum): Double;
function Aggregate(aggType: AggregateEnum; flags: AggregateFlags): Double;
function Aggregate(aggType: AggregateEnum; rg: CellRange): Double;
function Aggregate(aggType: AggregateEnum; rg: CellRange; flags: AggregateFlags): Double;
function Aggregate(aggType: AggregateEnum; r1: Integer; c1:Integer; r2: Integer; c2: Integer): Double;
function Aggregate(aggType: AggregateEnum; r1: Integer; c1:Integer; r2: Integer; c2: Integer; flags:
AggregateFlags): Double;
Parameter Beschreibung
Function
Einer der AggregateEnum-Werte. Dieser Parameter legt den zu
berechnenden Typ der Aggregierung fest.
row1, col1, row2, col2 Vier Integer-Werte, die den zu aggregierenden Zellbereich festlegen.
Rg Ein CellRange-Objekt, das den zu aggregierenden Zellbereich festlegt.
flags
Rückgabewert
Eine Kombination von Werten aus der AggregateFlags-Aufzählung. Der
Standardwert ist AggregateFlags.None.
Ein Double-Wert für die berechnete Gesamtmenge.
Beispiel
Dieser Quellcode verwendet die Aggregate-Methode um aggregierte Statistiken für willkürliche Bereiche
zu berechen. Immer wenn sich die Auswahl in der Tabelle verändert, dann werden die Gesamtmengen
neu berechnet und in die Konsole geschrieben.
• Visual Basic
• C#
Private Sub flex_SelChange(sender As Object, e As System.EventArgs)
Dim fmt As String = "Count {0:0}, Sum {1:#,##0.00}, " & _
"Avg {2:#,##0.00}, Stdev {3:#,##0.00}"
Dim agg As String = String.Format(fmt, _
flex.Aggregate(AggregateEnum.Count), _
flex.Aggregate(AggregateEnum.Sum), _
flex.Aggregate(AggregateEnum.Average), _
flex.Aggregate(AggregateEnum.Std))
Console.WriteLine(agg)
End Sub 'flex_SelChange
private void flex_SelChange(object sender, System.EventArgs e)
{

176 · C1FlexGrid-Referenzverzeichnis
}
• Delphi
string fmt = "Count {0:0}, Sum {1:#,##0.00}, " +
"Avg {2:#,##0.00}, Stdev {3:#,##0.00}";
string agg = string.Format(fmt,
flex.Aggregate(AggregateEnum.Count),
flex.Aggregate(AggregateEnum.Sum),
flex.Aggregate(AggregateEnum.Average),
flex.Aggregate(AggregateEnum.Std));
Console.WriteLine(agg);
procedure Class1.flex_SelChange(sender: System.Object; e:
System.EventArgs);
var
agg: string;
fmt: string;
begin
fmt := ('Count {0:0}, Sum {1:#,##0.00}, ' + 'Avg {2:#,##0.00}, Stdev
{3:#,##0.00}');
agg := System.String.Format(fmt, flex.Aggregate(AggregateEnum.Count),
flex.Aggregate(AggregateEnum.Sum),
flex.Aggregate(AggregateEnum.Average),
flex.Aggregate(AggregateEnum.Std));
Console.WriteLine(agg);
end;
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
AutoSizeCol-Methode
Passt die Breite der aktuellen Spalte an ihre Daten an.
Syntax
[VB]
Public Sub AutoSizeCol(col As Integer)
Public Sub AutoSizeCol(col As Integer, extraSpace As Integer)
[C#]
public virtual void AutoSizeCol ( int col )
public virtual void AutoSizeCol ( int col , int extraSpace )
[Delphi]
procedure AutoSizeCol(col: Integer);
procedure AutoSizeCol(col: Integer, extraSpace: Integer);
Parameter Beschreibung
col Der Index der anzupassenden Spalte.
extraSpace Die Anzahl der Pixel, die zusätzlich zur Breite hinzugefügt werden.

Bemerkungen
AutoSizeCols-Methode · 177
Diese Methode misst den Inhalt einer jeden Zelle in der Spalte aus, mit Rücksicht auf ihre Formatierung.
Wenn die Tabelle viele Zeilen besitzt, dann sollten Sie die AutoSizeCols-Methode in Betracht ziehen, mit
der Sie die einzelnen Spalten und Zeilen, die ausgemessen werden sollen, festlegen können.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
AutoSizeCols-Methode
Passt die Breite aller Spalte an ihre Daten an.
Syntax
[VB]
Public Sub AutoSizeCols()
Public Sub AutoSizeCols(extraSpace As Integer)
Public Sub AutoSizeCols(col1 As Integer, col2 As Integer, extraSpace As Integer)
Public Sub AutoSizeCols(row1 As Integer, col1 As Integer, row2 As Integer, col2 As Integer, extraSpace
As Integer, flags As AutoSizeFlags)
Protected Sub AutoSizeCols(g As Graphics, row1 As Integer, col1 As Integer, row2 As Integer, col2 As
Integer, extra As Integer, flags As AutoSizeFlags)
[C#]
public virtual void AutoSizeCols ( )
public virtual void AutoSizeCols ( int extraSpace )
public virtual void AutoSizeCols ( int col1 , int col2 , int extraSpace )
public virtual void AutoSizeCols ( int row1 , int col1 , int row2 , int col2 , int extraSpace , AutoSizeFlags
flags )
public protected internal virtual void AutoSizeCols (Graphics g , int row1 , int col1 , int row2 , int col2 ,
int extra ,AutoSizeFlags flags )
[Delphi]
procedure AutoSizeCols;
procedure AutoSizeCols(extraSpace: Integer);
procedure AutoSizeCols(col1: Integer; col2: Integer; extraSpace: Integer);
procedure AutoSizeCols(row1: Integer; col1: Integer; row2: Integer; col2: Integer; extraSpace: Integer;
flags: AutoSizeFlags);
procedure AutoSizeCols(g: Graphics; row1: Integer; col1: Integer; row2: Integer; col2: Integer; extra:
Integer; flags: AutoSizeFlags);
Parameter Beschreibung
col1, col2 Der Index der ersten und letzten anzupassenden Spalte.

178 · C1FlexGrid-Referenzverzeichnis
row1, row2
Die zu vermessenden Zeilen. Wenn nicht festgelegt, dann werden alle Zeilen
verwendet.
extraSpace Die Anzahl der Pixel, die zusätzlich zur Breite hinzugefügt werden.
flags
Bemerkungen
Eine Kombination von Werten der AutoSizeFlags-Aufzählung. Die Flags legen
Optionen, wie z.B. versteckte oder verbundene Spalten ignorieren oder allen
Spalten die gleiche Breite zuordnen, fest.
Standardmäßig misst diese Methode den Inhalt einer jeden Zelle in den Spalten aus, mit Rücksicht auf
deren Formatierung. Wenn die Tabelle viele Zeilen besitzt, dann sollten Sie die Version wählen, mit der
Sie einen Zeilenbereich festlegen können. Sie können allerdings nur ein paar hundert Zeilen und etwas
zusätzlichen Platz in den Prozess einbeziehen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
AutoSizeRow-Methode
Passt die Höhe einer einzelnen Zeile an ihre Daten an.
Syntax
[VB]
Public Sub AutoSizeRow(row As Integer)
[C#]
public virtual void AutoSizeRow ( int row )
[Delphi]
procedure AutoSizeRow(row: Integer);
Parameter Beschreibung
row Der Index der anzupassenden Zeile.
Bemerkungen
Diese Methode misst den Inhalt einer jeden Zelle in der Spalte aus, mit Rücksicht auf ihre Formatierung.
Wenn Sie viele Zeilen gleichzeitig anpassen wollen, dann sollten Sie die AutoSizeRows-Methode in
Betracht ziehen.
Beispiel
Schauen Sie im ChangeEdit-Ereignis nach.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)

AutoSizeRows-Methode
Passt die Höhe einer Auswahl von Zeilen an ihre Daten an.
Syntax
[VB]
Public Sub AutoSizeRows()
AutoSizeRows-Methode · 179
Public Sub AutoSizeRows(row1 As Integer, col1 As Integer, row2 As Integer, col2 As Integer, extra As
Integer, flags As AutoSizeFlags)
[C#]
public virtual void AutoSizeRows ( )
public protected internal virtual void AutoSizeRows (Graphics g , int row1 , int col1 , int row2 , int col2 ,
int extra , AutoSizeFlags flags )
[Delphi]
procedure AutoSizeRows;
procedure AutoSizeRows(g: Graphics; row1: Integer; col1: Integer; row2: Integer; col2: Integer; extra:
Integer; flags: AutoSizeFlags);
Parameter Beschreibung
col1, col2
Der Index der ersten und letzten zu vermessenden Spalte. Wenn nicht festgelegt,
dann werden alle Spalten verwendet.
row1, row2 Der Index der ersten und letzten anzupassenden Zeile.
extraSpace Die Anzahl der Pixel, die zusätzlich zur Höhe hinzugefügt werden.
flags
Bemerkungen
Eine Kombination von Werten der AutoSizeFlags-Aufzählung. Die Flags legen
Optionen fest, wie z.B. versteckte oder verbundene Zeilen ignorieren oder allen
Zeilen die gleiche Höhe zuordnen.
Diese Methode misst den Inhalt einer jeden Zelle in der Spalte aus, mit Rücksicht auf ihre Formatierung.
Um eine einzelne Zeile anzupassen, verwenden Sie die AutoSizeRow-Methode.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
Clear-Methode (C1FlexGrid)
Löscht die Inhalte einer Tabelle.
Syntax
[VB]
Public Sub Clear()

180 · C1FlexGrid-Referenzverzeichnis
Public Sub Clear(clearFlags As ClearFlags)
Public Sub Clear(clearFlags As ClearFlags, rg As CellRange)
Public Sub Clear(clearFlags As ClearFlags, row As Integer, col As Integer)
Public Sub Clear(clearFlags As ClearFlags, row1 As Integer, col1 As Integer, row2 As Integer, col2 As
Integer)
[C#]
public void Clear ()
public void Clear (ClearFlags clearFlags )
public void Clear (ClearFlags clearFlags , int row , int col )
public void Clear (ClearFlags clearFlags , int row1 , int col1 , int row2 , int col2 )
public void Clear (ClearFlags clearFlags , CellRange rg )
[Delphi]
procedure Clear;
procedure Clear(clearFlags: ClearFlags);
procedure Clear(clearFlags: ClearFlags; row: Integer; col: Integer);
procedure Clear(clearFlags: ClearFlags; row1: Integer; col1: Integer; row2: Integer; col2: Integer);
procedure Clear(clearFlags: ClearFlags; rg: CellRange);
Parameter Beschreibung
flags
rg
row1, col1, row2, col2
Bemerkungen
Eine Kombination von Werten der ClearFlags-Aufzählung. Die Flags legen
fest, was gelöscht werden soll. (Daten, Formatierung, usw.). Der Standard ist
ClearFlags.All, welcher alle Daten, Formate und Nutzerdaten aus den Zellen,
Zeilen und Spalten löscht.
Ein CellRange-Objekt, dass den zu löschenden Bereich festlegt.
Standardmäßig wird die gesamte Tabelle gelöscht.
Vier Indizes, die den zu löschenden Bereich festlegen. Standardmäßig wird die
gesamte Tabelle gelöscht.
Die Clear-Methode verändert nicht die Anzahl der Zeilen und Spalten in einer Tabelle und kann auch
nicht für das Löschen von Daten in an Datenquellen gebundene Tabellen verwendet werden.
Schauen Sie unter ClearFlags für detailliertere Information über die Elemente, die entfernent werden,
wenn diese Methode verwendet wird, nach.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)

CreateImage-Methode
Erstellt eine Grafik von der gesamten Tabelle oder einer Auswahl.
Syntax
[VB]
Public Function CreateImage() As Image
Public Function CreateImage(rg As CellRange) As Image
Public Function CreateImage(rg As CellRange, emfType As EmfType) As Image
CreateImage-Methode · 181
Public Function CreateImage(row1 As Integer, col1 As Integer, row2 As Integer, col2 As Integer) As
Image
Public Function CreateImage(row1 As Integer, col1 As Integer, row2 As Integer, col2 As Integer,
emfType As EmfType) As Image
[C#]
public Image CreateImage ( )
public Image CreateImage (CellRange rg )
public Image CreateImage (CellRange rg , EmfType emfType )
public Image CreateImage ( int row1 , System.Int32 col1 , int row2 , int col2 )
public Image CreateImage ( int row1 , int col1 , int row2 , int col2 , EmfType emfType )
[Delphi]
function CreateImage: Image;
function CreateImage(rg: CellRange): Image;
function CreateImage(rg: CellRange; emfType: EmfType): Integer;
function CreateImage(row1: Integer; col1: Integer; row2: Integer; col2: Integer): Image;
function CreateImage(row1: Integer; col1: Integer; row2: Integer; col2: Integer; emfType: EmfType):
Image;
Parameter Beschreibung
Range
row1, col1, row2, col2
emfType
Ein CellRange-Objekt, das den Zellbereich beinhaltet, der in die Grafik
eingeschlossen werden soll. Standardmäßig gibt diese Methode eine Grafik
über die gesamte Tabelle zurück.
Vier Indizes, die den Zellbereich beinhaltet, der in die Grafik eingeschlossen
werden soll. Standardmäßig gibt diese Methode eine Grafik über die gesamte
Tabelle zurück.
Ein Wert der EmfType-Aufzählung, der den Typ der zu erstellenden Metadatei
(GDI, GDI+ oder dual) festlegt. Der Standardwert für diesen Parameter ist
EmfType.EmfOnly.

182 · C1FlexGrid-Referenzverzeichnis
Rückgabewert
Ein Image-Objekt, das eine Metadateigrafik der Tabelle enthält.
Bemerkungen
Verwenden Sie diese Methode, um Tabellenbilder in die Zwischenablage zu kopieren und diese in
andere Anwendungen einzufügen.
Zum Beispiel, der nachfolgende Quellcode erstellt ein Bild eines Tabellenbereiches und speichert dieses
in eine *.png-Datei, so dass diese in andere Dokumente, z.B. Webseiten, eingefügt werden kann:
• Visual Basic
• C#
Private Sub button1_Click(sender As Object, e As System.EventArgs)
Dim img As Image = _flex.CreateImage(0, 0, 10, 5)
img.Save("c:\temp\flex.png") '
End Sub 'button1_Click
private void button1_Click(object sender, System.EventArgs e)
{
Image img = _flex.CreateImage(0,0,10,5);
img.Save(@"c:\temp\flex.png",
System.Drawing.Imaging.ImageFormat.Png);
}
• Delphi
procedure Class1.button1_Click(sender: System.Object; e:
System.EventArgs);
var
img: Image;
begin
img := _flex.CreateImage(0, 0, 10, 5);
img.Save('c:\temp\flex.png', System.Drawing.Imaging.ImageFormat.Png);
end;
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
DrawCell-Methode
Zeichnet eine ganze oder Teile einer Zelle.
Syntax
[VB]
Public Sub DrawCell()
Public Sub DrawCell(flags As DrawCellFlags)
[C#]
public void DrawCell ( )
public void DrawCell (DrawCellFlags flags )
[Delphi]
procedure DrawCell;

procedure DrawCell(flags: DrawCellFlags);
Bemerkungen
FindRow-Methode · 183
Diese Methode wird in Routinen verwendet, die das OwnerDrawCell-Ereignis abfangen, welches
gestartet wird, wenn die DrawMode-Eigenschaft auf OwnerDraw steht. Die DrawCell-Methode ist
nützlich, wenn Sie Teile der Zelle neben der standardmäßigen Zeichenroutine der Tabelle selbst zeichnen
wollen.
Die Flags-Parameter legen fest, welcher Zellteil gezeichnet werden soll. Die Optionen sind:
Parameter Beschreibung
Background Die Steuerung zeichnet den Hintergrund.
Border Die Steuerung zeichnet die Rahmen.
Content Die Steuerung zeichnet den Zellinhalt (Text und Grafiken).
All Die Steuerung zeichnet die gesamte Zelle.
Normalerweise wird der Quellcode (1) den Zellhintergrund zeichnen und die DrawCell aufrufen, um
Zellrahmen und –inhalt anzuzeigen, oder (2) die DrawCell aufrufen, um den Hintergrund und die
Rahmen zu zeichen, und anschließend benutzerdefinierten Code verwenden, um die Inhalte zu zeichnen.
Schauen Sie ferner unter
OwnerDrawCellEventArgs-Klasse (Seite 288)
FindRow-Methode
Sucht eine Zeile, die eine gegebene Zeichenkette oder ein gegebenes Objekt enthält.
Syntax
[VB]
Public Function FindRow(objFind As Object, rowStart As Integer, col As Integer, wrap As Boolean) As
Integer
Public Function FindRow(strFind As String, rowStart As Integer, col As Integer, caseSensitive As
Boolean, fullMatch As Boolean, wrap As Boolean) As Integer
[C#]
public Integer FindRow (Object objFind , int rowStart , int col , Boolean wrap )
public Integer FindRow (String strFind , int rowStart , int col , Boolean caseSensitive , Boolean fullMatch ,
Boolean wrap )
[Delphi]
function FindRow(objFind: Object; rowStart: Integer; col: Integer; wrap: Boolean): Integer;
function FindRow(strFind: string; rowStart: Integer; col: Integer; caseSensitive: Boolean; fullMatch:
Boolean; wrap: Boolean): Integer;

184 · C1FlexGrid-Referenzverzeichnis
Parameter Beschreibung
strFind Zeichenkette, nach der gesucht wird.
objFind Objekt, nach dem gesucht wird.
rowStart Index der Zeile, in der die Suche beginnen soll.
col Spalte, welche die gesuchten Daten enthält.
caseSensitive Ob die Suche Groß- und Kleinschreibung berücksichtigt.
fullMatch
wrap
Rückgabewert
Ob die Suchwörter genau gefunden werden müssen. Wenn dieser Parameter auf
FALSE steht, dann ergibt z.B. die Suche nach „John“ u.a. auch „Johnson".
Ob die Suche am Ende der Tabelle anhalten, oder in der ersten, scrollbaren Zeile
fortfahren soll.
Der Index der Zeile mit den gesuchten Daten oder –1, wenn die Daten nicht gefunden wurden.
Bemerkungen
Verwenden Sie die AutoSearch-Eigenschaft, um nach Daten zu suchen, während der Nutzer noch tippt.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGridClassic-Klasse (Seite 450)
FinishEditing-Methode
Beendet die Bearbeitung der aktuellen Zelle und den Bearbeitungsmodus der Tabelle.
Syntax
[VB]
Public Function FinishEditing() As Boolean
Public Function FinishEditing(cancel As Boolean) As Boolean
[C#]
public Boolean FinishEditing ( )
public Boolean FinishEditing (Boolean cancel )
[Delphi]
function FinishEditing: Boolean;
function FinishEditing(cancel: Boolean): Boolean;
Parameter Beschreibung
cancel
Gibt an, ob die aktuellen Veränderungen abgebrochen und der ursprüngliche Wert
wiederhergestellt werden soll.

Rückgabewert
GetCellCheck-Methode · 185
TRUE, wenn die Tabelle sich nicht mehr im Bearbeitungsmodus befindet; FALSE, wenn die
Gültigkeitsprüfung fehl schlägt und die Tabelle zurück in den Bearbeitungsmodus versetzt wird.
Bemerkungen
Überprüfen Sie ob die Editor-Eigenschaft Null ist, um festzustellen, ob die Tabelle sich im
Bearbeitungsmodus befindet.
Wenn der cancel-Parameter auf FALSE steht, dann wird die Tabelle die Ereignisse ValidateEdit und
AfterEdit wie üblich starten. Je nach dem, wie diese Ereignisse abgefangen werden, kehrt die Tabelle
eventuell in den Bearbeitungsmodus zurück. Wenn der cancel-Pparameter auf TRUE steht, dann verlässt
die Tabelle den Bearbeitungsmodus.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
GetCellCheck-Methode
Gibt den Zustand eines Kontrollkästchens in einer Tabellenzelle zurück.
Syntax
[VB]
Public Function GetCellCheck(row As Integer, col As Integer) As CheckEnum
[C#]
public virtual CheckEnum GetCellCheck ( int row , int col )
[Delphi]
function GetCellCheck(row: Integer; col: Integer): CheckEnum;
Parameter Beschreibung
row, col Die Koordinaten der Zelle.
Rückgabewert
Einer der Werte der CheckEnum-Aufzählung.
Bemerkungen
Standardmäßig zeigt die Tabellensteuerung Werte in Boolean-Spalten als Kontrollkästchen an. Der
Spaltentyp wird von der DataType-Eigenschaft des Column-Objekts festgelegt. Wenn Sie Boolean-Werte
nicht als Kontrollkästchen anzeigen lassen wollen, dann müssen Sie in die Format-Eigenschaft der Spalte
eine Zeichenkette mit den entsprechenden Wahr- und Falsch-Werten eintragen. Zum Beispiel:
• Visual Basic
fg.Cols("bools").Format = "Yes;No"

186 · C1FlexGrid-Referenzverzeichnis
• C#
fg.Cols("bools").Format = "Yes;No";
• Delphi
fg.Cols['bools'].Format := 'Yes;No';
Im ungebundenen Zustand können Sie die GetCellCheck- und SetCellCheck-Eigenschaften verwenden,
um Kontrollkästchen in Zellen einzufügen. Das Kontrollkästchen wird zusammen mit jedem beliebigen
Text in der Zelle angezeigt und Sie können deren Position mit der ImageAlign-Spalteneigenschaft
festlegen.
Es gibt zwei Kontrollkästchentypen: Boolean und Tri-State. Boolean-Kontrollkästchen schalten zwischen
den beiden Zuständen CheckEnum.Checked und CheckEnum.Unchecked um. Drei-Zustands-
Kontrollkästchen laufen durch die drei Zustände CheckEnum.TSChecked, CheckEnum.TSUnchecked
und CheckEnum.TSGrayed.
Zum Beispiel, der nachfolgende Quellcode erstellt ein Boolean-Kontrollkästchen in der Zelle (3,3) und ein
Drei-Zustands-Kontrollkästchen in der Zelle (4,3):
• Visual Basic
• C#
fg.SetCellCheck(3, 3, CheckEnum.Unchecked) ' boolean
fg.SetCellCheck(4, 3, CheckEnum.TSUnchecked) ' tri-state
fg.SetCellCheck(3, 3, CheckEnum.Unchecked) // boolean;
fg.SetCellCheck(4, 3, CheckEnum.TSUnchecked) // tri-state;
• Delphi
fg.SetCellCheck(3, 3, CheckEnum.Unchecked);
fg.SetCellCheck(4, 3, CheckEnum.TSUnchecked);
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
GetCellImage-Methode
Gibt die einer Zelle zugeordnete Grafik zurück.
Syntax
[VB]
Public Function GetCellImage(row As Integer, col As Integer) As Image
[C#]
public Image GetCellImage ( int row , int col )
[Delphi]
function GetCellImage(row: Integer; col: Integer): Image;
Parameter Beschreibung
row Zeile, welche die Grafik enthält.
col Spalte, welche die Grafik enthält.

Bemerkungen
GetCellRange-Methode · 187
Diese Methode ruft Grafiken ab, die einer Zelle mit der SetCellImage-Methode zugeordnet wurden.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
GetCellRange-Methode
Gibt ein CellRange-Objekt zurück, mit dem eine Auswahl formatiert und verändert werden kann.
Syntax
[VB]
Public Function GetCellRange(row As Integer, col As Integer) As CellRange
Public Function GetCellRange(row1 As Integer, col1 As Integer, row2 As Integer, col2 As Integer) As
CellRange
[C#]
public CellRange GetCellRange ( int row1 , int col1 , int row2 , int col2 )
public CellRange GetCellRange ( int row , int col )
[Delphi]
function GetCellRange(row: integer; col: Integer): CellRange;
function GetCellRange(row1: Integer; col1: Integer; row2: Integer; col2: Integer): CellRange;
Parameter Beschreibung
row, col Die Koordinaten einer einzigen Zelle, die den Bereich darstellt.
row1, col1, row2, col2 Vier Indizes, die einen Bereich festlegen.
Rückgabewert
Ein CellRange-Objekt, mit dem ein bestimmter Bereich formatiert und verändert werden kann.
Bemerkungen
Das CellRange-Objekt stellt den Zugang zu den Eigenschaften der Zellen in einem Bereich zur
Verfügung. Zum Beispiel, der nachfolgende Quellcode legt das Format (Style) eines Bereichs fest:
• Visual Basic
• C#
Dim rg As CellRange = flex.GetCellRange(5, 5, 20, 8)
rg.Style = flex.Styles("MyStyle")
CellRange rg = flex.GetCellRange(5, 5, 20, 8);
rg.Style = flex.Styles["MyStyle"];
• Delphi

188 · C1FlexGrid-Referenzverzeichnis
var
rg: CellRange;
begin
rg := flex.GetCellRange(5, 5, 20, 8);
rg.Style := flex.Styles['MyStyle'];
end;
Anmerkung: CellRange ist eine Klasse, keine Struktur. Deswegen müssen Sie den Wert einer Variable
zuordnen und dann diese Variable verwenden. Der folgende Quellcode, zum Beispiel, würde nicht
kompilieren:
• Visual Basic
• C#
' this does not compile!!!
flex.GetCellRange(5, 5, 20, 8).Style = flex.Styles("MyStyle")
// this does not compile!!!
flex.GetCellRange(5, 5, 20, 8).Style = flex.Styles["MyStyle"];
• Delphi
flex.GetCellRange(5, 5, 20, 8).Style := flex.Styles['MyStyle'];
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
GetCellRect-Methode
Gibt ein Rectangle-Objekt mit den Koordinaten der Zellen auf dem Bildschirm zurück.
Syntax
[VB]
Public Function GetCellRect(row As Integer, col As Integer) As Rectangle
Public Function GetCellRect(row As Integer, col As Integer, show As Boolean) As Rectangle
[C#]
public Rectangle GetCellRect ( int row , int col )
public Rectangle GetCellRect ( int row , int col , Boolean show )
[Delphi]
function GetCellRect(row: Integer; col: Integer): Rectangle;
function GetCellRect(row: Integer; col: Integer; show: Boolean): Rectangle;
Parameter Beschreibung
row, col Die Koordinaten der Zelle.
show
Ob die Zelle auf den Bildschirm gescrollt werden soll, bevor das Rechteck
berechnet wird.

Rückgabewert
GetCellStyle-Methode · 189
Ein Rectangle-Objekt, welches die Koordinaten des Zellrechtecks in Pixeln und relativ zum aktuellen
Tabellenbereich, enthält.
Bemerkungen
Diese Eigenschaft ist nützlich, wenn Sie benutzerdefinierte Editoren oder andere Elemente, die genau
über einer Zelle positioniert werden, implementieren müssen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
GetCellStyle-Methode
Gibt ein benutzerdefiniertes, einer bestimmten Zelle zugeordnetes Format zurück, oder „Null“, wenn
diese kein eigenes Format besitzt.
Syntax
[VB]
Public Function GetCellStyle(row As Integer, col As Integer) As CellStyle
[C#]
public CellStyle GetCellStyle ( int row , int col )
[Delphi]
function GetCellStyle(row: Integer; col: Integer): CellStyle;
Parameter Beschreibung
row, col Die Koordinaten der Zelle, die den Style enthalten soll.
Rückgabewert
Ein CellStyle-Objekt mit dem Format, das einer Zelle zugeordnet ist, oder „Null“, wenn diese kein
benutzerdefiniertes Format besitzt.
Bemerkungen
Wenn die Zelle kein benutzerdefiniertes Format besitzt, dann verwendet die Tabellensteuerung eine der
Standardformatvolagen. Die Standardformatvolagen werden je nach Zellposition und Zustand
ausgewählt (fixiert, scrollbar, markiert, usw.). Verwenden Sie die GetCellStyleDisplay-Methode, um das
Format, mit dem eine Zelle gezeichnet wird (benutzerdefiniert oder integriert) abzurufen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
GetCellStyleDisplay-Methode
Gibt das Format zurück, das für das Rendern der Zelle verwendet wird.
Syntax

190 · C1FlexGrid-Referenzverzeichnis
[VB]
Public Function GetCellStyleDisplay(row As Integer, col As Integer) As CellStyle
[C#]
public CellStyle GetCellStyleDisplay ( int row , int col )
[Delphi]
function GetcellStyleDisplay(row: Integer; col: Integer): CellStyle;
Parameter Beschreibung
row, col Die Koordinaten der Zelle, die den Style enthalten soll.
Rückgabewert
Ein CellStyle-Objekt mit einem Format, das für das Rendern der Zelle verwendet wird. Wenn die Zelle
einen benutzerdefiniertes Format besitzt, dann gibt GetCellStyleDisplay dieses zurück; andernfalls wird
das Standardformat (z.B. Normal, Fixed, usw.) ausgegeben.
Bemerkungen
Das zurückgegebene Format kann ein, einer Zelle zugeordnetes, benutzerdefiniertes oder, wenn die Zelle
kein eigenes besitzt, ein Standardformat sein. Diese Methode gibt niemals Null zurück. Verwenden Sie
die GetCellStyle-Methode um festzustellen, ob die Zelle einen benutzerdefiniertes Format besitzt, und
um dieses abzurufen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
GetData-Methode
Gibt die Daten einer Tabellenzelle zurück.
Syntax
[VB]
Public Function GetData(row As Integer, col As Integer) As Object
Public Function GetData(row As Integer, colName As String) As Object
[C#]
public Object GetData ( int row , int col )
public Object GetData ( int row , String colName )
[Delphi]
function GetData(row: Integer; col: Integer): Object;
function GetData(row: Integer; colName: string): Object;

Parameter Beschreibung
row, col Die Koordinaten der Zelle.
Rückgabewert
Die Daten einer gegebenen Zelle.
Bemerkungen
GetDataDisplay-Methode · 191
Die GetData-Methode gibt die rohen, in einer bestimmten Zelle gespeicherten Daten zurück. Dies
entspricht der Verwendung der Tabellenindizierer. Zum Beispiel:
• Visual Basic
• C#
Dim foo As Object
foo = fg.GetData(row, col) ' is equivalent to
foo = fg(row, col)
object foo;
foo = fg.GetData(row, col); // is equivalent to
foo = fg[row, col];
• Delphi
var
foo: System.Object;
begin
foo := fg.GetData(row, col);
foo := fg[row, col];
end;
Die von der Tabelle angezeigten Daten können von den rohen Daten, abhängig von den Format- und
DataMap-Eigenschaften des Column-Objekts, abweichen. Verwenden Sie stattdessen die
GetDataDisplay-Methode, um den angezeigten Wert als Zeichenkette abzurufen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
GetDataDisplay-Methode
Gibt die Daten einer Tabellenzelle als Zeichenkette zurück.
Syntax
[VB]
Public Function GetDataDisplay(row As Integer, col As Integer) As String
Public Function GetDataDisplay(row As Integer, colName As String) As String
[C#]
public String GetDataDisplay ( int row , int col )
public String GetDataDisplay ( int row , String colName )
[Delphi]

192 · C1FlexGrid-Referenzverzeichnis
function GetDataDisplay(row: Integer, col: Integer): string;
function GetDataDisplay(row: Integer, colName: string): string;
Parameter Beschreibung
row, col Die Koordinaten der Zelle.
Rückgabewert
Eine Zeichenkette der Daten, die in einer gegebenen Zelle angezeigt werden.
Bemerkungen
Verwenden Sie die GetData-Methode oder die Tabellenindizierer, um die rohen Daten vor jeglichen
Zuordnungen und Formatierungen abzurufen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
GetMergedRange-Methode (C1FlexGrid)
Gibt die Auswahl der mit einer gegeben Zelle verbundenen Zellen zurück.
Syntax
[VB]
Public Function GetMergedRange(row As Integer, col As Integer) As CellRange
Public Function GetMergedRange(row As Integer, col As Integer, clip As Boolean) As CellRange
[C#]
public CellRange GetMergedRange(int row , int col)
public CellRange GetMergedRange(int row , int col , Boolean clip)
[Delphi]
function GetMergedRange(row: Integer; col: Integer): CellRange;
function GetMergedRange(row: Integer; col: Integer; clip: Boolean); CellRange;
Parameter Beschreibung
row, col Die Koordinaten der Zelle.
Clip
Rückgabewert
Ob der zurückgegebene Wert alle verbundenen Zellen im Bereich (clip = FALSE)
oder nur die sichtbaren (clip = TRUE) enthalten soll.
Ein CellRange-Objekt mit allen Zellen des verbundenen Bereichs um die Zelle auf Position row, col.
Bemerkungen

HitTest-Methode · 193
Zellverbindungen werden von der AllowMerging-Eigenschaft gesteuert. Mit der GetMergedRange
können Sie nur feststellen, ob eine bestimmte Zelle mit ihren Nachbarzellen verbunden ist.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
HitTest-Methode
Gibt Informationen über die Steuerung an einem gegebenen Punkt auf der Steuerungsoberfläche zurück.
Syntax
[VB]
Public Function HitTest(x As Integer, y As Integer) As HitTestInfo
[C#]
public HitTestInfo HitTest(int x , int y)
[Delphi]
function HitTest(x: Integer; y: Integer): HitTestInfo;
Parameter Beschreibung
x, y Die Koordinaten eines Punktes auf der Steuerungsoberfläche in Pixeln.
row1, col1, row2, col2 Die Koordinaten des Bereichs, der geprüft werden soll.
range CellRange-Objekt, das den Bereich festlegt, der geprüft werden soll.
Rückgabewert
Eine HitTestInfo-Struct mit den Daten über den Punkt (Koordinaten, Zeile, Spalte, usw.).
Bemerkungen
Diese Methode ist besonders nützlich, wenn dass BeforeMouseDown-Ereignis abgefangen wird und
bestimmt werden soll, ob der Mauszeiger z.B. über einer bestimmten Zelle, Schaltfläche oder einem
Größenänderungselement steht.
Zum Beispiel, der nachfolgende Quellcode zeigt die HitTest-Information immer dann an, wenn der
Nutzer mit der Maus klickt:
• Visual Basic
• C#
Private Sub _flex_BeforeMouseDown(sender As Object, e As
BeforeMouseDownEventArgs)
Dim hti As HitTestInfo = _flex.HitTest(e.X, e.Y)
Console.WriteLine("at {0},{1}: row {2} col {3} type {4}", _
hti.X, hti.Y, hti.Row, hti.Column, hti.Type)
End Sub '_flex_BeforeMouseDown
private void _flex_BeforeMouseDown(object sender,
BeforeMouseDownEventArgs e)
{
HitTestInfo hti = _flex.HitTest(e.X, e.Y);

194 · C1FlexGrid-Referenzverzeichnis
}
• Delphi
Console.WriteLine("at {0},{1}: row {2} col {3} type {4}",
hti.X, hti.Y, hti.Row, hti.Column, hti.Type);
var
hti: HitTestInfo;
items: array of object;
begin
hti := _flex.HitTest(e.X, e.Y);
SetLength(items, 5);
items[0] := System.Object(hti.X);
items[1] := System.Object(hti.Y);
items[2] := System.Object(hti.Row);
items[3] := System.Object(hti.Column);
items[4] := System.Object(hti.Type);
Console.WriteLine('at {0},{1}: row {2} col {3} type {4}',
items);
end;
Bei Verwendung dieser Methode in einem Ereignis, dass die Mauszeigerkoordinaten nicht bereitstellt,
müssen Sie die Control.MousePosition-Eigenschaft nutzen und den Punkt von den Fenster- zu
Steuerungskordinaten umwandeln. Zum Beispiel:
• Visual Basic
• C#
Private Sub _flex_DoubleClick(sender As Object, e As System.EventArgs)
Dim pt As Point = Control.MousePosition
pt = _flex.PointToClient(pt)
Dim hti As HitTestInfo = _flex.HitTest(pt.X, pt.Y)
Console.WriteLine("at {0},{1}: row {2} col {3} type {4}", _
hti.X, hti.Y, hti.Row, hti.Column, hti.Type)
End Sub '_flex_DoubleClick
private void _flex_DoubleClick(object sender, System.EventArgs e)
{
Point pt = Control.MousePosition;
pt = _flex.PointToClient(pt);
HitTestInfo hti = _flex.HitTest(pt.X, pt.Y);
Console.WriteLine("at {0},{1}: row {2} col {3} type {4}",
hti.X, hti.Y, hti.Row, hti.Column, hti.Type);
}
• Delphi
var
hti: HitTestInfo;
pt: Point;
items: array of object;
begin
pt := Control.MousePosition;
pt := _flex.PointToClient(pt);
hti := _flex.HitTest(pt.X, pt.Y);
SetLength(items, 5);
items[0] := System.Object(hti.X);
items[1] := System.Object(hti.Y);
items[2] := System.Object(hti.Row);
items[3] := System.Object(hti.Column);
items[4] := System.Object(hti.Type);
Console.WriteLine('at {0},{1}: row {2} col {3} type {4}',
items);
end;

Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
Invalidate-Methode
Invalidate-Methode · 195
Erklärt einen bestimmten Teil der Tabelle als ungültig und gibt eine Farbnachricht an die Steuerung aus.
Syntax
[VB]
Public Sub Invalidate(row As Integer, col As Integer)
Public Sub Invalidate(rg As CellRange)
Public Sub Invalidate(row1 As Integer, col1 As Integer, row2 As Integer, col2 As Integer)
[C#]
public void Invalidate(int row , int col)
public void Invalidate(int row1 , int col1 , int row2 , int col2)
public virtual void Invalidate(CellRange rg)
[Delphi]
procedure Invalidate(row: integer; col: Integer);
procedure Invalidate(rg: CellRange);
procedure Invalidate(row1: Integer; col1: Integer; row2: Integer; col2: Integer);
Parameter Beschreibung
row, col Die Koordinaten der für ungültig zu erklärenden Zelle.
row1, col1, row2, col2 Die Koordinaten des für ungültig zu erklärenden Bereichs.
range Ein CellRange-Objekt mit dem für ungültig zu erklärenden Bereich.
Bemerkungen
Diese Methode wird kaum von Programmierern verwendet, da die Tabelle betreffende Zellen
automatisch für ungültig erklärt.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109 )
Column-Klasse (Seite 339)
Row-Klasse (Seite 324)
LoadExcel-Methode
Lädt ein Arbeitsblatt aus einer Microsoft Excel-Datei (*.xls).
Syntax

196 · C1FlexGrid-Referenzverzeichnis
[VB]
Public Sub LoadExcel(fileName As String)
Public Sub LoadExcel(fileName As String, sheetName As String)
Public Sub LoadExcel(fileName As String, sheetName As String, flags As FileFlags)
[C#]
public void LoadExcel(string fileName)
public void LoadExcel(string fileName, string sheetName)
public void LoadExcel(string fileName, string sheetName, FileFlags flags)
[Delphi]
procedure LoadExcel(fileName: string);
procedure LoadExcel(fileName: string; sheetName: string);
procedure LoadExcel(fileName: string; sheetName: string; flags: FileFlags);
Parameter Beschreibung
fileName Der Name der zu ladenden Datei und ihr Pfad.
sheetName
flags
Bemerkungen
Der Name der zu ladenden Tabelle in der Excel-Datei. Wenn dieser nicht
angegeben ist, wird die erste Tabelle geladen. Verwenden Sie die
LoadExcelSheetNames-Methode, um eine Liste aller Tabellen der Datei
abzufragen.
Einer der Werte aus der FileFlags-Aufzählung, die Ladeoptionen für die Datei
festlegen (z.B. ob feste Zellen geladen werden).
Auch die LoadGrid-Methode kann Excel-Dateien laden. Sie können da allerdings nicht das zu ladende
Arbeitsblatt angeben, so dass immer das erste in der Arbeitsmappe geladen wird.
Verwenden Sie die LoadExcelSheetNames-Methode, um eine Liste aller Tabellen der Datei abzufragen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
LoadExcelSheetNames-Methode
Gibt eine Liste aller Arbeitsblätter einer Microsoft Excel-Datei zurück (*.xls).
Syntax
[VB]
Public Function LoadExcelSheetNames(fileName As String) As String()
[C#]
public string() LoadExcelSheetNames(string fileName)

[Delphi]
function LoadExcelSheetNames(fileName: string): string[];
Parameter Beschreibung
fileName Der Name der zu ladenden Datei und ihr Pfad.
Bemerkungen
LoadGrid-Methode · 197
Diese Methode ist nützlich, wenn Sie eine bestimmt Tabelle aus einer Excel-Arbeitsmappe laden wollen.
Verwenden Sie hierfür zunächst die LoadExcelSheetNames, um eine Liste der vorhandenen Tabellen
abzurufen, wählen Sie die zu ladende Tabelle aus und rufen Sie diese anschließend mit der LoadExcel-
Methode ab.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
LoadGrid-Methode
Lädt eine Tabelle aus einer Datei.
Syntax
[VB]
Public Sub LoadGrid(fileName As String, format As FileFormatEnum)
Public Sub LoadGrid(fileName As String, format As FileFormatEnum, flags As FileFlags)
Public Sub LoadGrid(fileName As String, format As FileFormatEnum, flags As FileFlags, encoding As
Encoding)
[C#]
public void LoadGrid(string fileName , FileFormatEnum format)
public void LoadGrid(string fileName , FileFormatEnum format , FileFlags flags)
public void LoadGrid(string fileName , FileFormatEnum format , FileFlags flags, Encoding encoding)
[Delphi]
procedure LoadGrid(fileName: string; format: FileFormatEnum);
procedure LoadGrid(fileName: string; format: FileFormatEnum; flags: FileFlags);
procedure LoadGrid(fileName: string; format: FileFormatEnum; flags: FileFlags; encoding: Encoding);
Parameter Beschreibung
fileName Der Name der zu ladenden Datei und ihr Pfad.
format
Einer der Werte aus der FileFormatEnum-Aufzählung, die das Format der
Datei festlegen (z.B. komma- oder tabulatorengetrennte Textdateien, Excel).

198 · C1FlexGrid-Referenzverzeichnis
flags
encoding
Bemerkungen
Einer der Werte aus der FileFlags-Aufzählung, die Ladeoptionen für die Datei
festlegen (z.B. ob feste Zellen geladen werden).
Ein System.Text.Encoding-Objekt, welches festlegt, wie der Text in die Datei
codiert wird. (z.B. ASCII, Unicode, UTF-7, UTF-8). Dieser Parameter ist nicht
nötig, wenn Excel-Dateien geladen werden.
Diese Methode lädt eine Tabelle aus einer zuvor mit der SaveGrid-Methode gespeicherten,
kommagetrennten Textdatei (*.csv), wie z.B. eine Microsoft Excel-Datei, oder eine tabulatorgetrennte
Textdatei. Sie kann auch für das Laden von Microsoft Excel-Dateien (*.xls) verwendet werden.
Wenn eine Textdatei geladen wird, dann werden Zeilen und Spalten so hinzugefügt, dass der Inhalt der
Textdatei darin Platz findet.
Wenn Excel-Dateien geladen werden, dann ruft die Tabellensteuerung das erste Arbeitsblatt mit der
ersten Tabelle der *.xls-Datei ab. Mit der LoadExcel-Methode hingegen können Sie das gewünschte
Arbeitsblatt festlegen. Verwenden Sie zusätzlich die LoadExcelSheetNames-Methode, um eine Liste aller
Tabellen der *.xls-Datei abzufragen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
PrintGrid-Methode
Druckt die Tabelle und zeigt optional ein Druckvorschaufenster an.
Syntax
[VB]
Public Function PrintGrid(docName As String) As Boolean
Public Function PrintGrid(docName As String, flags As PrintGridFlags) As Boolean
Public Function PrintGrid(docName As String, flags As PrintGridFlags, header As String, footer As
String) As Boolean
[C#]
public Boolean PrintGrid(string docName)
public Boolean PrintGrid(string docName , PrintGridFlags flags)
public Boolean PrintGrid(string docName , PrintGridFlags flags , string header , string footer)
[Delphi]
function PrintGrid(docName: string): Boolean;
function PrintGrid(docName: string; flags: PrintGridFlags): Boolean;
function PrintGrid(docName: string; flags: PrintGridFlags; header: string; footer: string): Boolean;

Parameter Beschreibung
docName
flags
RemoveItem-Methode (C1FlexGrid) · 199
Der Dokumentname, der in den Fortschritts- und den Druckauftragsfenstern
angezeigt wird.
Eine Kombination von Werten der PrintGridFlags-Aufzählung, die den Typ der
anzuzeigenden Druck- und Vorschaufenster festlegen und bestimmen, wie die
Tabelle für den Ausdruck skaliert wird.
header, footer Zeichenketten, die oben und unten auf jede Seite gedruckt werden.
Rückgabewert
Ein Boolean-Wert der anzeigt, ob entweder die Tabelle gedruckt wurde, oder der Nutzer eines der
optionalen Einstellungsfenster abgbrochen hat.
Bemerkungen
Die Kopf- und Fußzeilentexte können bis zu drei tabulatorgetrennte Abschnitte besitzen, die
entsprechend linksbündig, mittig und rechtsbündig auf der Seite ausgerichtet werden. Die Texte können
weiterhin Platzhalter besitzen, die mit der aktuellen Seitenzahl oder der Gesamtseitenzahl (“{0}” und
“{1}”) ersetzt werden.
Mit der PrintParameters-Eigenschaft können Sie noch weitere Aspekte des Druckauftrags, wie z.B.
Seitenausrichtung, Ränder, Kopf- und Fußzeilenschriftarten, steuern.
Beispiel
Der folgende Aufruf skaliert die Tabelle auf eine Seitenbreite, platziert eine zentrierte Fußzeile mit dem
Text „Page n of m” am unteren Ende der Seite und druckt sie auf dem Standarddrucker aus.
• Visual Basic
• C#
flex.PrintGrid("My Grid", PrintGridFlags.FitPageWidth, _
"", vbTab + "Page {0} of {1}")
flex.PrintGrid("My Grid", PrintGridFlags.FitPageWidth,
"", "\tPage {0} of {1}");
• Delphi
flex.PrintGrid('My Grid', PrintGridFlags.FitPageWidth, '', #9'Page
{0} of {1}');
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109 )
C1FlexGridClassic-Klasse (Seite 450)
RemoveItem-Methode (C1FlexGrid)
Löscht eine Zeile in der Steuerung.
Syntax
[VB]
Public Sub RemoveItem()

200 · C1FlexGrid-Referenzverzeichnis
Public Sub RemoveItem(index As Integer)
[C#]
public void RemoveItem ( )
public void RemoveItem ( int index )
[Delphi]
procedure RemoveItem;
procedure RemoveItem(index: Integer);
Parameter Beschreibung
index
Bemerkungen
Der Index der zu löschenden Zeile. Wenn dieser Parameter unberücksichtigt bleibt,
dann wird die letzte Zeile der Tabelle gelöscht.
Sie können Zeilen auch mit der Rows-Collection löschen und hinzufügen. Die RemoveItem-Methode
wird hauptsächlich aus Konsistenzgründen zur Verfügung gestellt.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
SaveExcel-Methode
Speichert die Tabelle in einer Microsoft Excel-Datei (*.xls).
Syntax
[VB]
Public Sub SaveExcel(fileName As String)
Public Sub SaveExcel(fileName As String, sheetName As String)
Public Sub SaveExcel(fileName As String, sheetName As String, flags As FileFlags)
[C#]
public void SaveExcel(string fileName)
public void SaveExcel(string fileName, string sheetName)
public void SaveExcel(string fileName, string sheetName, FileFlags flags)
[Delphi]
procedure SaveExcel(fileName: string);
procedure SaveExcel(fileName: string; sheetName: string);
procedure SaveExcel(fileName: string; sheetName: string; flags: FileFlags);

Parameter Beschreibung
fileName Der Name der zu speichernden Datei und ihr Pfad.
sheetName
flags
Bemerkungen
SaveGrid-Methode · 201
Der Name der zu speichernden Tabelle in der Excel-Datei. Wenn dieser nicht
angegeben ist, dann wird eine Datei mit nur einem Arbeitsblatt erstellt,
andernfalls wird ein Arbeitsblatt mit dem angegebenen Namen der Datei
hinzugefügt.
Einer der Werte aus der FileFlags-Aufzählung, die Speicheroptionen für die
Datei festlegen (z.B. ob feste Zellen gespeichert werden).
Auch die SaveGrid-Methode kann Excel-Dateien speichern. Sie können da allerdings nicht das zu
speichernde Arbeitsblatt angeben, so dass immer Arbeitsmappen mit nur einem Arbeitsblatt erstellt
werden.
Mit der SaveExcel-Methode können Sie hingegen mehrere Tabellen auf verschiedenen Arbeitsbättern in
einer Datei speichern. Zum Beispiel, der nachfolgende Quellcode speichert alle Tabellen in einem
Datensatz in einer einzigen *.xls-Datei:
• Visual Basic
• C#
Dim ds As DataSet = GetDataSet()
Dim dt As DataTable
For Each dt In ds.Tables
_flex.DataSource = dt
_flex.SaveExcel(xlsFileName, dt.TableName)
Next
DataSet ds = GetDataSet();
foreach (DataTable dt in ds.Tables)
{
_flex.DataSource = dt;
_flex.SaveExcel(xlsFileName, dt.TableName);
}
• Delphi
var ds: DataSet;
dt: DataTable;
i: Integer;
ds := GetDataSet;
for i := 0 to ds.Tables.Count-1 do
begin
dt := ds.Tables[i];
_flex.DataSource := dt;
_flex.SaveExcel(xlsFileName, dt.TableName);
end;
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
SaveGrid-Methode
Speichert die Tabelle in eine Datei.

202 · C1FlexGrid-Referenzverzeichnis
Syntax
[VB]
Public Sub SaveGrid(fileName As String, format As FileFormatEnum)
Public Sub SaveGrid(fileName As String, format As FileFormatEnum, flags As FileFlags)
Public Sub SaveGrid(fileName As String, format As FileFormatEnum, flags As FileFlags, encoding As
Encoding)
[C#]
public void SaveGrid (String fileName , FileFormatEnum format )
public void SaveGrid (String fileName , FileFormatEnum format , FileFlags flags)
public void SaveGrid (String fileName , FileFormatEnum format ,FileFlags flags, Encoding encoding)
[Delphi]
procedure SaveGrid(fileName: string; format: FileFormatEnum);
procedure SaveGrid(fileName: string; format: FileFormatEnum; flags: FileFlags);
procedure SaveGrid(fileName: string; format: FileFormatEnum; flags: FileFlags; encoding: Encoding);
Parameter Beschreibung
fileName Der Name der zu speichernden Datei und ihr Pfad.
format
flags
encoding
Bemerkungen
Einer der Werte aus der FileFormatEnum-Aufzählung, die das Format der
Datei festlegen (z.B. komma- oder tabulatorengetrennte Textdateien, Excel).
Einer der Werte aus der FileFlags-Aufzählung, die Speicheroptionen für die
Datei festlegen (z.B. ob feste Zellen gespeichert werden).
Ein System.Text.Encoding-Objekt, welches festlegt, wie der Text in die Datei
codiert wird. (z.B. ASCII, Unicode, UTF-7, UTF-8). Der Standardwert ist
Encoding.ASCII. Dieser Parameter ist nicht nötig, wenn Excel-Dateien
gespeichert werden.
Wenn die Tabellensteuerung eine Textdatei speichert, dann werden alle Zellen, die Anführungszeichen
oder Zeilen- und Spaltentrennzeichen enthalten, in Anführungszeichen eingeschlossen.
Anführungszeichen im Zelltext werden durch doppelte Anführungszeichen ersetzt. Dies stellt die
Standardcodierung dar, wenn *.csv-Dateien geladen oder gespeichert werden. Wenn Excel-Dateien
gespeichert werden, dann erstellt die Tabellensteuerung eine neue *.xls-Datei mit einem Arbeitsblatt, auf
dem die Tabellendaten gespeichert werden.
Mit der SaveExcel-Methode können Sie hingegen mehrere Tabellen auf verschiedenen Arbeitsbättern in
einer *.xls-Datei speichern.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)

Select-Methode
Wählt eine oder mehrere Zellen aus.
Syntax
[VB]
Public Select(row As Integer, col As Integer)
Public Select(row As Integer, col As Integer, rowSel As Integer, colSel As Integer)
Public Select(rg As CellRange)
Public Select(row As Integer, col As Integer, show As Boolean)
Select-Methode · 203
Public Select(row As Integer, col As Integer, rowSel As Integer, colSel As Integer, show As Boolean)
Public Select(rg As CellRange, show As Boolean)
[C#]
public void Select ( int row , int col )
public void Select ( int row , int col , int rowSel , int colSel )
public void Select ( int row , int col , Boolean show )
public void Select (CellRange rg )
public void Select ( int row , int col , int rowSel , int colSel , Boolean show )
public void Select (CellRange rg , Boolean show )
[Delphi]
procedure Select(row: Integer; col: Integer);
procedure Select(row: Integer; col: Integer; rowSel: Integer; colSel: Integer);
procedure Select(row: Integer; col: Integer; show: Boolean);
procedure Select(rg: CellRange);
procedure Select(row: Integer; col: Integer; rowSel: Integer; colSel: Integer; show: Boolean);
procedure Select(rg: CellRange; show: Boolean);
Parameter Beschreibung
row, col Die Koordinaten der auszuwählenden Zelle.
row1, col1, row2, col2 Die Koordinaten des auszuwählenden Bereichs.
range Der für ungültig zu erklärende Bereich.
show
Ob die Auswahl auf den Bildschirm gescrollt werden soll. Der Standardwert für
diesen Parameter ist TRUE.

204 · C1FlexGrid-Referenzverzeichnis
Bemerkungen
Die Verwendung der Select-Methode ist gleich dem Setzen der Row, Col, RowSel und ColSel-
Eigenschaften.
Wenn Sie die SelectionMode-Eigenschaft auf ListBox setzen, dann verhält sich die Tabelle wie ein
Mehrfachauswahllistenfeld. In diesem Modus können Sie die Selected-Eigenschaft des Row-Objekts
verwenden, um den Auswahlzustand einer Zeile abzurufen oder zu setzen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
SetCellImage-Methode
Ordnet eine Grafik einer Zelle zu.
Syntax
[VB]
Public Sub SetCellImage(row As Integer, col As Integer, newImage As Image)
[C#]
public void SetCellImage ( int row , int col , Image newImage )
[Delphi]
procedure SetCellImage(row: Integer; col: Integer; newImage: Image);
Bemerkungen
Parameter Beschreibung
row Zeile, welche die Grafik beinhalten wird.
col Spalte, welche die Grafik beinhalten wird.
newImage Die der Zelle hinzuzufügende Grafik.
Bemerkungen
Jede Zelle der Tabelle kann neben ihren Daten auch ein Bild anzeigen. Dies kann auf zwei Wegen getan
werden:
1. Sie können die SetCellImage- und GetCellImage-Methoden verwenden, um Grafiken direkt der
Zelle zuzuordnen. In diesem Fall sind der Zellinhalt und die Grafik unabhängig. Um die Grafik
zu aktualisieren, müssen Sie die SetCellImage erneut aufrufen.
2. Sie können die ImageMap-Eigenschaft eines Column-Objekts verwenden, um Grafiken auf
bestimmte Zellwerte zuzuordnen. In diesem Fall wird die Grafik automatisch aktualisiert, wenn
sich der Zellinhalt ändert. Das column-Objekt besitzt außerdem eine ImageAndText-Eigenschaft,
mit der Sie festlegen können, ob die Steuerung die Grafik zusätzlich oder anstatt des Zelltextes
anzeigen soll.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)

SetCellStyle-Methode
Ordnet einen eigenen CellStyle der Zelle zu.
Syntax
[VB]
Public Sub SetCellStyle(row As Integer, col As Integer, newStyle As CellStyle)
[C#]
public void SetCellStyle ( int row , int col , CellStyle newStyle )
[Delphi]
procedure SetCellStyle(row: Integer; col: Integer; newStyle: CellStyle);
Parameter Beschreibung
row, col Die Koordinaten der Zelle, die das neue Format zugeordnet bekommt.
SetCellStyle-Methode · 205
newStyle Das neue Format für die Zelle, oder Null, um das Zellfomat zurückzusetzen.
Bemerkungen
Die SetCellStyle-Methode ist nützlich, wenn Sie einen neues Format einer Zelle zuordnen wollen. Sie
können das Zellformat auch zurücksetzen, indem Sie es auf Null setzen („Nothing“ in VB).
Um eine benutzerdefinierte Formatvorlage auf eine gesamte Zeile oder Spalte anzuwenden, müssen Sie
die Style-Eigenschaft der Row- oder Column-Objekte setzen.
Verwenden Sie das CellRange-Objekt, um eine benutzerdefinierte Formatvorlage auf einen Zellbereich
anzuwenden. Zum Beispiel:
• Visual Basic
• C#
Dim rg As CellRange = fg.GetCellRange(3, 3, 10, 10)
rg.Data = Nothing
rg.Style = fg.Styles("MyRangeStyle")
CellRange rg = fg.GetCellRange(3, 3, 10, 10);
rg.Data = null;
rg.Style = fg.Styles["MyRangeStyle"];
• Delphi
var
rg: CellRange;
begin
rg := fg.GetCellRange(3, 3, 10, 10);
rg.Data := nil;
rg.Style := fg.Styles['MyRangeStyle'];
end;
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)

206 · C1FlexGrid-Referenzverzeichnis
SetCellCheck-Methode
Legt den Zustand eines Kontrollkästchens, dass in einer Zelle angezeigt wird, fest.
Syntax
[VB]
Public Sub SetCellCheck(row As Integer, col As Integer, check As CheckEnum)
[C#]
public void SetCellCheck ( int row , int col , CheckEnum check )
[Delphi]
procedure SetCellCheck(row: Integer; col: Integer; check: CheckEnum);
Parameter Beschreibung
row, col Die Koordinaten der Zelle, deren Kontrollkästchenzustand verändert werden soll.
checkValue
Bemerkungen
Einer der Werte aus der CheckEnum-Aufzählung, die festlegen, ob ein
Kontrollkästchen in der Zelle angezeigt wird und welchen Zustand es haben soll.
Standardmäßig zeigt die Tabellensteuerung Werte in Boolean-Spalten als Kontrollkästchen an. Der
Spaltentyp wird von der DataType-Eigenschaft des Column-Objekts festgelegt. Wenn Sie Boolean-Werte
nicht als Kontrollkästchen anzeigen lassen wollen, dann müssen Sie in die Format-Eigenschaft der Spalte
eine Zeichenkette mit den entsprechenden Wahr- und Falsch-Werten eintragen. Zum Beispiel:
• Visual Basic
• C#
fg.Cols("bools").Format = "Yes;No"
fg.Cols["bools"].Format = "Yes;No";
• Delphi
fg.Cols['bools'].Format := 'Yes;No';
Im ungebundenen Zustand können Sie die GetCellCheck- und SetCellCheck-Eigenschaften verwenden,
um Kontrollkästchen in Zellen einzufügen. Das Kontrollkästchen wird zusammen mit jedem beliebigen
Text in der Zelle angezeigt und Sie können deren Position mit der ImageAlign-Spalteneigenschaft
festlegen.
Es gibt zwei Kontrollkästchentypen: Boolean und Tri-State. Boolean-Kontrollkästchen schalten zwischen
den beiden Zuständen CheckEnum.Checked und CheckEnum.Unchecked um. Drei-Zustands-
Kontrollkästchen laufen durch die drei Zustände CheckEnum.TSChecked, CheckEnum.TSUnchecked
und CheckEnum.TSGrayed.
Zum Beispiel, der nachfolgende Quellcode erstellt ein Boolean-Kontrollkästchen in der Zelle (3,3) und ein
Drei-Zustands-Kontrollkästchen in der Zelle (4,3):
• Visual Basic
fg.SetCellCheck(3, 3, CheckEnum.Unchecked) ' boolean

• C#
fg.SetCellCheck(4, 3, CheckEnum.TSUnchecked) ' tri-state
fg.SetCellCheck(3, 3, CheckEnum.Unchecked); // boolean
fg.SetCellCheck(4, 3, CheckEnum.TSUnchecked); // tri-state
• Delphi
fg.SetCellCheck(3, 3, CheckEnum.Unchecked); // boolean
fg.SetCellCheck(4, 3, CheckEnum.TSUnchecked); // tri-state
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
SetData-Methode
Ordnet Daten einer Tabellenzelle zu.
Syntax
[VB]
Public Function SetData(row As Integer, colName As String, data As Object) As Boolean
SetData-Methode · 207
Public Function SetData(row As Integer, colName As String, data As Object, coerce As Boolean) As
Boolean
Public Function SetData(rg As CellRange, data As Object) As Boolean
Public Function SetData(rg As CellRange, data As Object, coerce As Boolean) As Boolean
Public Function SetData(row As Integer, col As Integer, data As Object) As Boolean
Public Function SetData(row As Integer, col As Integer, data As Object, coerce As Boolean) As Boolean
[C#]
public Boolean SetData ( int row , String colName , Object data )
public Boolean SetData ( int row , String colName , Object data , Boolean coerce )
public Boolean SetData (CellRange rg , Object data )
public Boolean SetData ( int row , int col , Object data )
public Boolean SetData (CellRange rg , Object data , Boolean coerce )
public Boolean SetData (int row , int col , Object data , Boolean coerce )
[Delphi]
function SetData(row: Integer; colName: string; data: Object): Boolean;
function SetData(row: Integer; colName: string; data: Object; coerce: Boolean): Boolean;
function SetData(rg: CellRange; data: Object): Boolean;
function SetData(row: Integer; col: Integer; data: Object): Boolean;
function SetData(rg: CellRange; data: Object; coerce, Boolean): Boolean;
function SetData(row: Integer; col: Integer; data: Object; coerce: Boolean): Boolean;

208 · C1FlexGrid-Referenzverzeichnis
Parameter Beschreibung
row, col Die Koordinaten der Zelle, der die neuen Daten zugeordnet werden.
data Die der Zelle zuzuordnenden Daten.
coerce
Rückgabewert
Legt fest, ob das Objekt in den Datentyp der Spalte umgewandelt wird. Wenn
coerce auf TRUE steht, der Wert aber nicht in den richtigen Datentyp umgewandelt
werden kann, dann wird die Tabellensteuerung das GridError-Ereignis starten und
die Zelle ihren ursprünglichen Wert beibehalten. Der Standardwert für diesen
Parameter ist TRUE.
Ein Boolean-Wert der anzeigt, ob die Daten der Tabelle zugeordnet wurden. (siehe nachfolgende
Bemerkungen).
Bemerkungen
Die SetData-Methode ordnet Daten einer Tabellenzelle zu und entspricht der Verwendung der
Tabellenindizierer. Zum Beispiel:
• Visual Basic
• C#
fg.SetData(row, col, 12) ' is equivalent to
fg(row, col) = 12
fg.SetData(row, col, 12); // is equivalent to
fg[row, col] = 12;
• Delphi
fg.SetData(row, col, 12);
fg[row, col] := 12;
Wenn Sie einer Zelle einen Datenwert zuordnen, dann prüft die Tabelle den Datentyp der Spalten und
zwingt den Datenwert automatisch in den entsprechenden Typ. Zum Beispiel, wenn die DataType-
Eigenschaft einer Spalte auf Integer steht und Sie einer Zelle dieser Spalte einen String- oder Double-Wert
zuordnen, dann wird die Tabellensteuerung versuchen, diesen Wert in einen Integer umzuwandeln,
bevor er in der Tabelle abgespeichert wird. Wenn die Umwandlung fehl schlägt, gibt SetData FALSE
zurück.
Wenn Sie den optionalen Parameter coerce auf FALSE setzen, dann speichert die Steuerung die Daten
ohne Umwandlung in der Tabelle ab. Somit können Sie willkürliche Daten, ohne Rücksicht auf den
Datentyp der Spalte, in den Zellen abspeichern.
Sie können auch Ihre eigenen, willkürlichen Daten mit einem CellRange-Objekt und dessen UserData-
Eigenschaft den Zellen in einer Tabelle zuordnen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
SetDataBinding-Methode
Stellt die DataSource- und DataMember-Eigenschaften ein.

Syntax
[VB]
Public Sub SetDataBinding(ByVal dataSource As Object, ByVal dataMember As String)
[C#]
public void SetDataBinding (object dataSource, string dataMember)
[Delphi]
procedure SetDataBinding(dataSource: Object; dataMember: String);
Parameter Beschreibung
dataSource Die Datenquelle der Tabelle.
dataMember
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
ShowCell-Methode
ShowCell-Methode · 209
Eine bestimmte Liste in einem DataSource-Objekt, welche die Tabelle anzeigen
soll.
Scrollt die Tabelle, so dass eine bestimmte Zelle auf dem Bildschirm angezeigt wird.
Syntax
[VB]
Public Sub ShowCell(row As Integer, col As Integer)
[C#]
public void ShowCell ( int row , int col )
[Delphi]
procedure ShowCell(row: integer; col: Integer);
Parameter Beschreibung
row, col Die Koordinaten der Zelle, die auf den Bildschirm gescrollt wird.
Bemerkungen
Diese Methode betrifft nicht die aktuelle Auswahl. Verwenden Sie die Select-Methode, um einen Cursor
auf eine bestimmte Zelle zu setzen und diese optional auf den Bildschirm zu bringen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)

210 · C1FlexGrid-Referenzverzeichnis
ShowSortAt-Methode
Zeigt ein Sortierungszeichen in einer bestimmten Spalte.
Syntax
[VB]
Public Sub ShowSortAt(order As SortFlags, col As Integer)
[C#]
public void ShowSortAt (SortFlags order , int col )
[Delphi]
procedure ShowSortAt(order: SortFlags; col: Integer);
Parameter Beschreibung
glyph
Der Typ des anzuzeigenden Sortierungszeichens (z.B. SortFlags.Ascending oder
SortFlags.Descending).
col Die Spalte, in der das Zeichen angezeigt werden soll.
Bemerkungen
Diese Methode ist nützlich, wenn Sie eine benutzerdefinierte Sortierung vornehmen wollen und
Kontrolle über das Aussehen und die Position des Sortierungszeichens benötigen. Das kleine Dreieck
erscheint in der Kopfzeile der sortierten Spalten.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
Sort-Methode
Sortiert die gesamte Tabelle oder eine Auswahl an Zeilen, basierend auf dem Inhalt einer oder mehrerer
Spalten.
Syntax
[VB]
Public Overridable Sort(order As SortFlags, col As Integer)
Public Overridable Sort(order As SortFlags, col1 As Integer, col2 As Integer)
Public Overridable Sort(order As SortFlags, rg As CellRange)
Public Overridable Sort(index As Integer, count As Integer, comparer As IComparer)
Public Overridable Sort(comparer As IComparer)
[C#]
public void Sort (SortFlags order , int col )
public void Sort (SortFlags order , int col1 , int col2 )

public void Sort (SortFlags order , CellRange rg )
public void Sort ( int index , int count , IComparer comparer )
public void Sort (IComparer comparer )
[Delphi]
procedure Sort(order: SortFlags; col: Integer);
procedure Sort(order: SortFlags; col1: Integer; col2: Integer);
procedure Sort(order: SortFlags; rg: CellRange);
procedure Sort(index: Integer; count: Integer; comparer: Icomparer);
procedure Sort(comparer: Icomparer);
Parameter Beschreibung
SortFlags flags
Einer oder mehrere Werte aus der SortFlags-Aufzählung, die den
Sortierungstyp festlegen (z.B. aufsteigend, absteigend oder Groß- und
Kleinschreibung berücksichtigend).
int col Die Spalte, nach deren Daten sortiert werden soll.
int col1, col2 Ein Spaltenbereich, nach dem sortiert werden soll.
CellRange range
IComparer compare
Bemerkungen
Sort-Methode · 211
Ein Zellbereich, nach dem sortiert werden soll. Wenn ein Bereich festgelegt ist,
dann sortiert die Tabelle nur die Zeilen innerhalb des Bereichs.
Ein Objekt, dass die IComparer-Schnittstelle implementiert, um Row-Objekte
zu vergleichen. Dies kann für benutzerdefinierte Sortierung verwendet werden.
Mit der Sort-Methode können Sie Spalten oder Zellbereiche auf- oder absteigend sortieren. Die flags-
Parameter legen neben anderen Optionen auch die Sortierungsrichtung, wie nachfolgend beschrieben,
fest:
Flag Wirkung
Ascending Sortiert die Zeilen aufsteigend.
Descending Sortiert die Zeilen absteigend.
AsDisplayed Sortiert nach den angezeigten Werten. Wenn dieser Flag gesetzt ist, dann basiert
die Sortierung der Daten auf den, dem Nutzer angezeigten und formatierten
Zellinhalten. Wenn er nicht gesetzt wird, dann basiert die Sortierung auf den
zugrundeliegenden Datenwerten.
IgnoreCase Berücksichtigt keine Groß- und Kleinschreibung beim Vergleich der Zellinhalte.
UseColSort Verwendet den Wert der Sort-Eigenschaft von jeder Spalte in dem entsprechenden
Sortierungsbereich. Somit können Sie manche Spalten in auf- und andere in
absteigender Richtung sortieren.

212 · C1FlexGrid-Referenzverzeichnis
Wenn Sie mehrere Spalten sortieren, dann werden auf alle Spalten, beginnend von der linken Spalte des
Sortierungsbereichs und nach rechts fortfahrend, die gleichen Sortieroptionen angewendet.
Die Tabelle verwendet einen konstanten Sortieralgorythmus. Das bedeutet, dass die Sortierung die
relative Reiheinfolge der Daten beibehält, wenn der Sortierungsschlüssel der gleiche ist. Zum Beispiel,
wenn Sie zunächst eine Dateienliste nach Namen und anschließend nach Dateienerweiterungen sortieren,
dann werden die Dateinamen innerhalb der Dateienerweiterungsgruppe immer noch sortiert sein.
Um mehrere Spalten in unterschiedliche Richtungen zu sortieren, können Sie entweder die Sort-Methode
mehrfach hintereinander aufrufen, oder die Sort-Eigenschaft einer jeden Spalte festlegen und dann die
Sort-Methode mit dem UseColSort-Flag im flags-Pparameter aufrufen.
Um benutzerdefinierte Sortierungen zu integrieren, sollten Sie ein Objekt zur Verfügung stellen, dass die
IComparer-Schnittstelle implementiert. Diese einfache Schnittstelle besitzt nur eine Methode mit dem
Namen Compare. Diese nimmt zwei Objekte als Argumente an (In diesem Fall werden es Row-Objekte
sein) und gibt -1, 0 oder +1 zurück. Für weitere Details, schauen Sie bitte in der Dokumentation der
System.Collections.IComparer-Schnittstelle nach.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
StartEditing-Methode
Versetzt die Tabelle in den Bearbeitungsmodus und beginnt die Zelle zu bearbeiten.
Syntax
[VB]
Public Function StartEditing() As Boolean
Public Function StartEditing(row As Integer, col As Integer) As Boolean
Public Function StartEditing(row As Integer, col As Integer, key As Char) As Boolean
[C#]
public Boolean StartEditing ( )
public Boolean StartEditing ( int row , int col )
public Boolean StartEditing ( int row , int col , Char key )
[Delphi]
function StartEditing: Boolean;
function StartEditing(row: Integer; col: Integer): Boolean;
function StartEditing(row: Integer; col: Integer; key: Char): Boolean;
Parameter Beschreibung
row, col
charTyped
Die zu bearbeitende Zelle. Der Standardwert ist die aktuelle Auswahl, welche durch
die Eigenschaften Row und Col festgelegt ist.
Das zunächst im Editor angezeigte Zeichen. Wenn dieser Parameter nicht gesetzt
wird, dann beginnt der Editor mit dem aktuellen Wert der Zelle. Wenn ein Wert zur
Verfügung gestellt wird, dann sendet die Tabelle diesen an den Editor und ersetzt

Bemerkungen
StartEditing-Methode · 213
somit die aktuelle Auswahl in Textfeldeditoren oder wählt ein Element mit dem
entsprechendem Zeichen in Listeneditoren aus.
Wenn die AllowEditing-Eigenschaft auf einem von Null verschiedenen Wert steht, dann geht die
Steuerung automatisch in den Bearbeitungsmodus, wenn der Nutzer die Bearbeitungstaste (F2), die
Leertaste oder jede beliebige Taste druckbarer Zeichen drückt. Sie können außerdem die StartEditing-
Methode verwenden, um die Steuerung in den Bearbeitungsmodus zu zwingen.
Die StartEditing-Methode zwingt die Steuerung sogar in den Bearbeitungsmodus, wenn die
AllowEditing-Eigenschaft auf FALSE steht oder die Zellen fixiert sind.
Beispiel
Der nachfolgende Quellcode verwendet die StartEditing-Methode, um die Tabelle im
Bearbeitungsmodus zu halten, selbst wenn der Nutzer die Auswahl verändert (wie die .NET-DataGrid-
Steuerung):
• Visual Basic
• C#
Private Sub _flex_KeyDown(sender As Object, e As KeyEventArgs)
If e.KeyCode = Keys.Return Then
e.Handled = True ' ignore the event, we'll handle it ourselves
_flex.StartEditing() ' put the grid in edit mode
Dim tb As TextBox = _flex.Editor '
' if we got a textbox, then
If Not (tb Is Nothing) Then
tb.Select(tb.Text.Length, 0) ' move cursor to end
End If
End If
End Sub '_flex_KeyDown
Private Sub _flex_KeyPress(sender As Object, e As KeyPressEventArgs)
If e.KeyChar = CChar(13) Then ' ignore enter key
e.Handled = True ' (don't move the cursor)
End If
End Sub '_flex_KeyPress
private void _flex_KeyDown(object sender, KeyEventArgs e)
{
if (e.KeyCode == Keys.Return)
{
e.Handled = true; // ignore the event, we'll handle it ourselves
_flex.StartEditing(); // put the grid in edit mode
TextBox tb = _flex.Editor as TextBox; // if we got a textbox, then
if (tb != null) tb.Select(tb.Text.Length, 0); // move cursor to end
}
}
private void _flex_KeyPress(object sender, KeyPressEventArgs e)
{
if (e.KeyChar == (char)13) // ignore enter key
e.Handled = true; // (don't move the cursor)
}
• Delphi
procedure Class1._flex_KeyDown(sender: System.Object; e: KeyEventArgs);
var
tb: TextBox;

214 · C1FlexGrid-Referenzverzeichnis
begin
if (e.KeyCode = Keys.Return) then
begin
e.Handled := True;
_flex.StartEditing;
if (flex.Editor is TextBox) then
TextBox(tb).Select(tb.Text.Length, 0);
end;
end;
procedure Class1._flex_KeyPress(sender: System.Object; e:
KeyPressEventArgs);
begin
if (e.KeyChar = (WideChar(13))) then
e.Handled := True;
end;
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
Subtotal-Methode
Gruppiert und summiert Zeilen nach ihrem Inhalt.
Syntax
[VB]
Public Sub Subtotal(aggType As AggregateEnum)
Public Sub Subtotal(aggType As AggregateEnum, level As Integer, groupOn As Integer, totalOn As
Integer)
Public Sub Subtotal(aggType As AggregateEnum, level As Integer, groupFrom As Integer, groupTo As
Integer, totalOn As Integer, caption As String)
Public Sub Subtotal(aggType AggregateEnum, level As Integer, groupOn As Integer, totalOn As Integer,
caption As String)
[C#]
public void Subtotal (AggregateEnum aggType )
public void Subtotal (AggregateEnum aggType , int level , int groupOn , int totalOn )
public void Subtotal (AggregateEnum aggType , int level , int groupOn , int totalOn , String caption )
public void Subtotal (AggregateEnum aggType , int level , int groupFrom , int groupTo , int totalOn ,
String caption )
[Delphi]
procedure Subtotal(aggType: AggregateEnum);
procedure Subtotal(aggType: AggregateEnum; level: Integer; groupOn: Integer; totalOn: Integer);
procedure Subtotal(aggType: AggregateEnum; level: Integer; groupOn: Integer; totalOn: Integer;
caption: string);
procedure Subtotal(aggType: AggregateEnum; level: Integer; groupFrom: Integer; groupOn: Integer;
totalOn: Integer; caption: string);

Parameter Beschreibung
function
level
groupOn
groupFrom,
groupTo
totalOn
caption
Bemerkungen
Subtotal-Methode · 215
Einer der AggregateEnum-Werte. Dieser Parameter legt den zu berechnenden
Aggregierungstyp fest (z.B. Summe, Durchschnitt, Minimum, Maximum).
Die der neuen Zwischensummenzeile zuzuordnende Gliederungsebene. Mit
diesem Parameter können Sie Zwischensummen auf mehreren Ebenen erstellen
und damit die Ansicht des Gliederungsbaums verändern. Für weitere Details
über Gliederungen, schauen Sie bitte unter der Tree-Eigenschaft nach. Wenn
dieser Parameter auf einem negativen Werte steht, dann werden die
Zwischensummen nicht als Knoten im Gliederungsbaum angezeigt.
Der zu verwendende Spaltenindex, um Gruppen abzugrenzen. Wenn die
Zwischensummen eingefügt werden, dann durchsucht die Tabelle alle Zeilen und
fügt Zwischensummenzeilen ein, wenn sich der Wert dieser oder der links von
dieser stehenden Spalte ändert. Wenn dieser Parameter auf einem negativen
Wert steht, dann berechnet die Steuerung die Gesamtsumme für die Tabelle.
Der zu verwendende Spaltenbereich, um Gruppen abzugrenzen. Wenn die
Zwischensummen eingefügt werden, dann durchsucht die Tabelle alle Zeilen und
fügt Zwischensummenzeilen ein, wenn sich ein Wert in diesem Bereich ändert.
Die für die Aggregierung zu verwendende Spalte. Für die meisten
Aggregationstypen muss diese Spalte numerische Werte enthalten. Sie können
auch Zählungen für jeden Typ und Bereich der Datenspalten vornehmen.
Der in der Zwischensummenzeile einzufügende Text. Standardmäßig wird die
Tabelle die nach den zu gruppierenden Werte verwenden, festgelegt durch die
groupOn-, groupFrom oder groupTo-Parameter. Wenn Sie eine Bezeichnung
hierfür festlegen, dann wird diese in der Zwischensummenzeile derjenigen Spalte
zugewiesen, die in der Column-Eigenschaft der Gliederung steht. Die
Bezeichnung kann einen Platzhalter „{0}“ enthalten, der mit dem zu
gruppierenden Wert ersetzt wird.
Die Subtotal-Methode fügt Zeilen mit aggregierten Werten ein. Diese neuen Zeilen verhalten sich wie
Gliederungsknoten, so dass diese erweitert und zusammengeklappt werden können und eine
dynamische Gliederungshierarchie unterstützen.
Sie können die Ansicht und das Verhalten der Gliederungsbäume mit der Tree-Eigenschaft steuern.
Die Style-Eigenschaft der Knotenzeilen, die von der Subtotal-Methode hinzugefügt werden, steht
automatisch auf einem der Styles.Subtotal-Formate. Verwenden Sie diese Styles-Eigenschaft, um das
Format aller Zwischensummenzeilen in der Tabelle anzupassen.
Um einen Gliederungsbaum manuell zu erstellen, müssen Sie die IsNode-Eigenschaft der Zeile, die einen
Gliederungsknoten enthalten soll, auf TRUE setzen. Anschließend können Sie mit der Level-Eigenschaft
von Row.Node die Gliederungsebene des neuen Knotens festlegen.
Beispiel
Der nachfolgende Quellcode ist eine typische, gliederungsaktualisierende Routine, die aufgerufen wird,
wenn sich Daten geändert haben, oder der Nutzer Spalten verschoben hat, um die Ansicht der Daten
anzupassen.

216 · C1FlexGrid-Referenzverzeichnis
Die Routine beginnt damit, die alten Summen zu löschen und sortiert anschließend die Tabelle, um die
Daten in Gruppen zu organisieren. Schlussendlich werden drei Zwischensummenebenen für die „Sales“-
und „Credits“-Spalte erstellt.
• Visual Basic
• C#
Private Sub flex_AfterDragColumn(sender As Object, e As
DragRowColEventArgs)
updateTreeReport(True)
End Sub 'flex_AfterDragColumn
Sub updateTreeReport(setCaption As Boolean)
' avoid flicker
flex.Redraw = False
' clear old totals
flex.Subtotal(AggregateEnum.Clear)
' sort grid to organize into groups
flex.Sort(SortFlags.Ascending, flex.Cols.Fixed, flex.Cols.Count - 1)
' update subtotals
flex.Tree.Column = 1
Dim caption As String
If setCaption Then caption = "Total {0}"
' total on Sales, group on first three columns
Dim totalOn As Integer = flex.Cols("Sales").SafeIndex
flex.Subtotal(AggregateEnum.Sum, 0, 1, totalOn, caption)
flex.Subtotal(AggregateEnum.Sum, 1, 2, totalOn, caption)
flex.Subtotal(AggregateEnum.Sum, 2, 3, totalOn, caption)
' total on Credits, group on first three columns
totalOn = flex.Cols("Credits").SafeIndex
flex.Subtotal(AggregateEnum.Sum, 0, 1, totalOn, caption)
flex.Subtotal(AggregateEnum.Sum, 1, 2, totalOn, caption)
flex.Subtotal(AggregateEnum.Sum, 2, 3, totalOn, caption)
' ready to show the grid again
flex.Redraw = True
End Sub 'updateTreeReport
private void flex_AfterDragColumn(object sender, DragRowColEventArgs e)
{
updateTreeReport(true);
}
void updateTreeReport(bool setCaption)
{
// avoid flicker
flex.Redraw = false;
// clear old totals
flex.Subtotal(AggregateEnum.Clear);
// sort grid to organize into groups
flex.Sort(SortFlags.Ascending, flex.Cols.Fixed, flex.Cols.Count-1);
// update subtotals
flex.Tree.Column = 1;
string caption = (setCaption)? "Total {0}": "";
// total on Sales, group on first three columns

}
• Delphi
int totalOn = flex.Cols["Sales"].SafeIndex;
flex.Subtotal(AggregateEnum.Sum, 0, 1, totalOn, caption);
flex.Subtotal(AggregateEnum.Sum, 1, 2, totalOn, caption);
flex.Subtotal(AggregateEnum.Sum, 2, 3, totalOn, caption);
// total on Credits, group on first three columns
totalOn = flex.Cols["Credits"].SafeIndex;
flex.Subtotal(AggregateEnum.Sum, 0, 1, totalOn, caption);
flex.Subtotal(AggregateEnum.Sum, 1, 2, totalOn, caption);
flex.Subtotal(AggregateEnum.Sum, 2, 3, totalOn, caption);
// ready to show the grid again
flex.Redraw = true;
procedure flex_AfterDragColumn(sender: System.Object; e:
DragRowColEventArgs);
updateTreeReport(True);
end; // flex_AfterDragColumn
procedure updateTreeReport(setCaption: Boolean);
var
caption: string;
totalOn: Integer;
begin
// avoid flicker
flex.Redraw := False;
// clear old totals
flex.Subtotal(AggregateEnum.Clear);
Subtotal-Methode · 217
// sort grid to organize into groups
flex.Sort(SortFlags.Ascending, flex.Cols.Fixed, flex.Cols.Count - 1);
// update subtotals
flex.Tree.Column := 1;
If setCaption Then
caption := 'Total {0}';
// total on Sales, group on first three columns
totalOn := flex.Cols['Sales'].SafeIndex;
flex.Subtotal(AggregateEnum.Sum, 0, 1, totalOn, caption);
flex.Subtotal(AggregateEnum.Sum, 1, 2, totalOn, caption);
flex.Subtotal(AggregateEnum.Sum, 2, 3, totalOn, caption);
// total on Credits, group on first three columns
totalOn := flex.Cols['Credits'].SafeIndex;
flex.Subtotal(AggregateEnum.Sum, 0, 1, totalOn, caption);
flex.Subtotal(AggregateEnum.Sum, 1, 2, totalOn, caption);
flex.Subtotal(AggregateEnum.Sum, 2, 3, totalOn, caption);
// ready to show the grid again
flex.Redraw := True;
end; // updateTreeReport
Beachten Sie, dass mehrere Aggregierungen in einer Zwischensummenzeile angezeigt werden können.
(eine pro Spalte). Die Subtotal-Methode prüft auf leere Zellen in den vorhandenen
Zwischensummenzeilen und wird diese, wenn möglich verwenden. Das nachfolgende Beispiel zeigt
Summen für mehrere Spalten in jeder Zwischensummenzeile:

218 · C1FlexGrid-Referenzverzeichnis
• Visual Basic
• C#
flex.Subtotal(AggregateEnum.Clear)
flex.Subtotal(AggregateEnum.Count, 0, 1, 1, 1, "Count is {0}")
Dim c As Integer
For c = 2 To flex.Cols.Count - 1
flex.Subtotal(AggregateEnum.Sum, 0, 1, 1, c, "Sum is {0}")
Next c
flex.Subtotal(AggregateEnum.Clear);
flex.Subtotal(AggregateEnum.Count, 0, 1, 1, 1, "Count is {0}");
for (int c = 2; c < flex.Cols.Count; c++)
flex.Subtotal(AggregateEnum.Sum, 0, 1, 1, c, "Sum is {0}");
• Delphi
var
c: Integer;
begin
flex.Subtotal(AggregateEnum.Clear);
flex.Subtotal(AggregateEnum.Count, 0, 1, 1, 1, 'Count is {0}');
c := 2;
while (c < flex.Cols.Count) do
begin
flex.Subtotal(AggregateEnum.Sum, 0, 1, 1, c, 'Sum is {0}');
c := c + 1;
end;
end;
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGrid-Ereignisse
AfterAddRow-Ereignis
Wird gestartet, wenn die AllowAddNew-Eigenschaft auf TRUE steht, und nachdem der Nutzer eine
neue Zeile in die Tabelle eingefügt hat.
Syntax
[VB]
Public Event AfterAddRow(sender As Object, e As RowColEventArgs) As RowColEventHandler
[C#]
public event RowColEventHandler AfterAddRow
[Delphi]
property AfterAddRow: RowColEventHandler;
Bemerkungen
Dieses Ereignis wird nicht gestartet, wenn der Tabelle eine neue Zeile programmatisch oder durch die
Datenquelle der Tabelle hinzugefügt wurde. Um es zu starten, muss AllowAddNew auf TRUE stehen
und der Nutzer eine neue, leere Zeile erstellen, indem er den Cursor in die letzte Zeile der Tabelle stellt.

Sie können dieses Ereignis verwenden, um die neue Zeile zu initialisieren.
AfterCollapse-Ereignis · 219
Wenn eine neue Zeile auf diesem Wege erstellt wurde, dann ist diese zunächst leer und der Nutzer kann
den Vorgang abbrechen, indem er den Cursor aus der unveränderten Zeile herausnimmt. In diesem Fall
startet die Tabelle das CancelAddRow-Ereignis und die neue, leere Zeile wird wieder entfernt.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
AfterCollapse-Ereignis
Wird gestartet, nachdem eine Knotenzeile auf- oder zusammengklappt wurde.
Syntax
[VB]
Public Event AfterCollapse(sender As Object, e As RowColEventArgs) As RowColEventHandler
[C#]
public event RowColEventHandler AfterCollapse
[Delphi]
property AfterCollapse: RowColEventHandler;
Bemerkungen
Schauen Sie für Details und Beispiele unter dem BeforeCollapse-Ereignis nach.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
AfterDataRefresh-Ereignis
Wird im gebundenen Modus gestartet, nachdem sich die Tabelle durch die Änderung der Datenquelle
verändert.
Syntax
[VB]
Public Event AfterDataRefresh(sender As Object, e As ListChangedEventArgs) As
ListChangedEventHandler
[C#]
public ListChangedEventHandler AfterDataRefresh
[Delphi]
property AfterDataRefresh: ListChangedEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ ListChangedEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält.
Bemerkungen

220 · C1FlexGrid-Referenzverzeichnis
Wenn die Tabelle im gebundenen Modus verwendet wird, dann startet die Tabelle nach jeder Änderung
der Datenquelle das AfterDataRefresh-Ereignis. Dieses Ereignis eignet sich für Quellcode, der die Tabelle
mit datengebundenen Elementen, wie z.B. Zwischensummen oder Gliederungsbäumen, aktualisiert.
Schauen Sie in der Datenanalyseübung für ein Beispiel nach.
Anmerkung: Der ListChangedEventHandler-Delegierer wird in System.ComponentModel definiert.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
AfterDeleteRow-Ereignis
Wird gestartet, wenn die AllowDelete-Eigenschaft auf TRUE steht, und nachdem der Nutzer eine Zeile
in der Tabelle mit der Entfernen-Taste gelöscht hat.
Syntax
[VB]
Public Event AfterDeleteRow(sender As Object, e As RowColEventArgs) As RowColEventHandler
[C#]
public event RowColEventHandler AfterDeleteRow
[Delphi]
property AfterDeleteRow: RowColEventHandler;
Bemerkungen
Dieses Ereignis wird nicht gestartet, wenn aus der Tabelle eine Zeile programmatisch oder durch die
Datenquelle der Tabelle gelöscht wurde. Um es zu startet, muss die AllowDelete auf TRUE stehen, so
dass der Nutzer die Zeile mit der Entfernen-Tatse löschen kann.
Wenn dieses Ereignis gestartet wird, dann sind die Zeilen bereits aus der Tabelle entfernt, so dass der
Row-Parameter imm auf –1 steht.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
AfterDragColumn-Ereignis
Wird gestartet, nachdem der Nutzer eine Spalte mit der Maus verschoben hat.
Syntax
[VB]
Public Event AfterDragColumn(sender As Object, e As DragRowColEventArgs) As
DragRowColEventHandler
[C#]
public event DragRowColEventHandler AfterDragColumn
[Delphi]
property AfterDragColumn: DragRowColEventHandler;

Ereignisdaten
AfterDragRow-Ereignis · 221
Der Ereignisabwickler erhält ein Argument vom Typ DragRowColEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int Col Der ursprüngliche Index der Spalte, die vom Nutzer gezogen wurde.
int Position Der aktuelle Index der Spalte, die vom Nutzer gezogen wurde.
Bemerkungen
Dieses Ereignis wird nur gestartet, wenn eine Spalte vom Nutzer verschoben wird, indem er diese mit
der Maus zieht (Siehe AllowDragging-Eigenschaft). Es wird nicht gestartet, wenn eine Spalte mit der
Cols.Move-Methode verschoben wird.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
AfterDragRow-Ereignis
Wird gestartet, nachdem der Nutzer eine Zeile mit der Maus verschoben hat.
Syntax
[VB]
Public Event AfterDragRow(sender As Object, e As DragRowColEventArgs) As
DragRowColEventHandler
[C#]
public event DragRowColEventHandler AfterDragRow
[Delphi]
property AfterDragRow: DragRowColEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ DragRowColEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int Row Der ursprüngliche Index der Zeile, die vom Nutzer gezogen wurde.
int Position Der aktuelle Index der Zeile, die vom Nutzer gezogen wurde.
Bemerkungen

222 · C1FlexGrid-Referenzverzeichnis
Dieses Ereignis wird nur gestartet, wenn eine Zeile vom Nutzer verschoben wird, indem er diese mit der
Maus zieht (Siehe AllowDragging-Eigenschaft). Es wird nicht gestartet, wenn eine Zeile mit der
Rows.Move-Methode verschoben wird.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
AfterEdit-Ereignis
Wird gestartet, nachdem der Nutzer die Zelle fertig bearbeitet hat.
Syntax
[VB]
Public Event AfterEdit(sender As Object, e As RowColEventArgs) As RowColEventHandler
[C#]
public event RowColEventHandler AfterEdit
[Delphi]
property AfterEdit: RowColEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int Row, Col Die Koordinaten der Zelle, die bearbeitet wurde.
Bemerkungen
Dieses Ereignis wird gestartet, nachdem die Inhalte einer Zelle vom Nutzer verändert wurden. Es ist für
Eingriffe nützlich, wie z.B. neue Datensortierung oder Berechnung der Zwischensummen.
Das AfterEdit-Ereignis eignet sich nicht für Gültigkeitsprüfungen der Daten, da es erst gestartet wird,
nachdem die Änderungen in die Tabelle eingefügt wurden. Verwenden Sie stattdessen das ValidateEdit-
Ereignis, um vom Nutzer eingegebene Daten auf Gültigkeit zu prüfen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
AfterFreezeColumn-Ereignis
Wird gestartet, nachdem der Nutzer Spalten mit der Maus fixiert hat.
Syntax
[VB]
Public Event AfterFreezeColumn(sender As Object, e As RowColEventArgs) As RowColEventHandler

[C#]
public event RowColEventHandler AfterFreezeColumn
[Delphi]
property AfterFreezeColumn: RowColEventHandler;
Ereignisdaten
AfterFreezeRow-Ereignis · 223
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int Row, Col Die Koordinaten der Zelle, die bearbeitet wurde.
Bemerkungen
Schauen Sie auch unter der AllowFreezing-Eigenschaft (Seite 120) nach.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
AfterFreezeRow-Ereignis
Wird gestartet, nachdem der Nutzer Zeilen mit der Maus fixiert hat.
Syntax
[VB]
Public Event AfterFreezeRow(sender As Object, e As RowColEventArgs) As RowColEventHandler
[C#]
public event RowColEventHandler AfterFreezeRow
[Delphi]
property AfterFreezeRow: RowColEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int Row, Col Die Koordinaten der Zelle, die bearbeitet wurde.
Bemerkungen
Schauen Sie auch unter der AllowFreezing-Eigenschaft (Seite 120) nach.

224 · C1FlexGrid-Referenzverzeichnis
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
AfterResizeColumn-Ereignis
Wird gestartet, nachdem der Nutzer die Breite von Spalten verändert hat.
Syntax
[VB]
Public Event AfterResizeColumn(sender As Object, e As RowColEventArgs) As RowColEventHandler
[C#]
public event RowColEventHandler AfterResizeColumn
[Delphi]
property AfterResizeColumn: RowColEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int Col Der Index der Spalte, deren Höhe der Nutzer angepasst hat.
Bemerkungen
Dieses Ereignis wird nur gestartet, wenn der Nutzer die Größe der Spalte ändert, indem er die
Überschriftszelle an ihren Rändern mit der Maus zieht (Siehe AllowResizing-Eigenschaft). Es wird nicht
gestartet, wenn die Breite einer Spalte durch das Setzen eines neuen Wertes in der Col.Width-Eigenschaft
verändert wird.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
AfterResizeRow-Ereignis
Wird gestartet, nachdem der Nutzer die Höhe von Zeilen verändert hat.
Syntax
[VB]
Public Event AfterResizeRow(sender As Object, e As RowColEventArgs) As RowColEventHandler
[C#]
public event RowColEventHandler AfterResizeRow

[Delphi]
property AfterResizeRow: RowColEventHandler;
Ereignisdaten
AfterRowColChange-Ereignis · 225
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int Row Der Index der Zeile, deren Höhe der Nutzer angepasst hat.
Bemerkungen
Dieses Ereignis wird nur gestartet, wenn der Nutzer die Höhe der Zeile ändert, indem er die
Überschriftszelle an ihren Rändern mit der Maus zieht (Siehe AllowResizing-Eigenschaft). Es wird nicht
gestartet, wenn die Höhe einer Zeile durch das Setzen eines neuen Wertes in der Row.Height-
Eigenschaft verändert wird.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
AfterRowColChange-Ereignis
Wird gestartet, nachdem der Auswahlanker auf eine andere Zelle festgelegt wird.
Syntax
[VB]
Public Event AfterRowColChange(sender As Object, e As RangeEventArgs) As RangeEventHandler
[C#]
public event RangeEventHandler AfterRowColChange
[Delphi]
property AfterRowColChange: RangeEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ RangeEventArgs, welches die mit diesem Ereignis
zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle Informationen für
dieses Ereignis zur Verfügung.
Property Beschreibung
CellRange OldRange Die Auswahl vor dem Ereignis.
CellRange NewRange Die aktuelle Auswahl.

226 · C1FlexGrid-Referenzverzeichnis
Bemerkungen
Dieses Ereignis wird gestartet, nachdem sich die Row- oder Col-Eigenschaften durch entweder den
Nutzer mit einer Tastatur- oder Mauseingabe oder durch Quellcode geändert hat.
Dieses Ereignis ist nützlich, wenn Sie zusätzliche Informationen über die aktuell ausgewählte Zeile,
Spalte oder Zelle anzeigen wollen. Verwenden Sie hingegen die Ereignisse BeforeRowColChange und
BeforeSelChange, um eine Gültigkeitsprüfung vorzunehmen oder die Bearbeitung einer Zelle zu
verhindern.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
AfterScroll-Ereignis
Wird gestartet, nachdem die Tabelle gescrollt wurde.
Syntax
[VB]
Public Event AfterScroll(sender As Object, e As RangeEventArgs) As RangeEventHandler
[C#]
public event RangeEventHandler AfterScroll
[Delphi]
property AfterScroll: RangeEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ RangeEventArgs, welches die mit diesem Ereignis
zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle Informationen für
dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
CellRange OldRange
Der sichtbare Bereich (TopRow, LeftCol, BottomRow, RightCol) vor
dem Ereignis.
CellRange NewRange Der aktuell sichtbare Bereich.
Bemerkungen
Dieses Ereignis ist nützlich, wenn Sie synchronisierte Ansichten von zwei oder mehr Tabellen benötigen.
Beispiel
Dieser Quellcode verbindet zwei Tabellen (fgLeft und fgRight) und synchronisiert deren vertikalen
Bildlauf. Der Nutzer kann aber weiterhin unabhängig horizontal scrollen.
• Visual Basic
' bind grids together
fgRight.DataSource = fgLeft
fgLeft.ScrollBars = ScrollBars.Horizontal

• C#
AfterSelChange-Ereignis · 227
' synchronize vertical scrolling
Private Sub flex_AfterScroll(sender As Object, _
e As C1.Win.C1FlexGrid.RangeEventArgs)
Dim fg As C1FlexGrid.C1FlexGrid = CType(sender, C1FlexGrid)
fg.Update()
Dim y As Integer = fg.ScrollPosition.Y
If fg = fgLeft Then
fgRight.ScrollPosition = New Point(fgRight.ScrollPosition.X, y)
Else
fgLeft.ScrollPosition = New Point(fgLeft.ScrollPosition.X, y)
End If
End Sub 'flex_AfterScroll
// bind grids together
fgRight.DataSource = fgLeft;
fgLeft.ScrollBars = ScrollBars.Horizontal;
// synchronize vertical scrolling
private void flex_AfterScroll(object sender,
C1.Win.C1FlexGrid.RangeEventArgs e)
{
C1FlexGrid.C1FlexGrid fg = ((C1FlexGrid)sender);
fg.Update();
int y = fg.ScrollPosition.Y;
if (fg == fgLeft)
fgRight.ScrollPosition = new Point(fgRight.ScrollPosition.X, y);
else
fgLeft.ScrollPosition = new Point(fgLeft.ScrollPosition.X, y);
}
}
• Delphi
fgRight.DataSource := fgLeft;
fgLeft.ScrollBars := ScrollBars.Horizontal;
procedure Class1.flex_AfterScroll(sender: System.Object; e:
C1.Win.C1FlexGrid.RangeEventArgs);
var
y: Integer;
fg: C1FlexGrid.C1FlexGrid;
begin
fg := C1FlexGrid(sender);
fg.Update;
y := fg.ScrollPosition.Y;
if fg = fgLeft then
fgRight.ScrollPosition := Point.Create(fgRight.ScrollPosition.X, y)
else
fgLeft.ScrollPosition := Point.Create(fgLeft.ScrollPosition.X, y);
end;
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
AfterSelChange-Ereignis
Wird gestartet, nachdem sich die Auswahl geändert hat.

228 · C1FlexGrid-Referenzverzeichnis
Syntax
[VB]
Public Event AfterSelChange(sender As Object, e As RangeEventArgs) As RangeEventHandler
[C#]
public event RangeEventHandler AfterSelChange
[Delphi]
property AfterSelChange: RangeEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ RangeEventArgs, welches die mit diesem Ereignis
zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle Informationen für
dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
CellRange OldRange Die Auswahl vor dem Ereignis.
CellRange NewRange Die aktuelle Auswahl.
Bemerkungen
Dieses Ereignis wird gestartet, nachdem sich die RowSel oder ColSel-Eigenschaften durch entweder den
Nutzer mit einer Tastatur- oder Mauseingabe oder durch Quellcode geändert hat.
Dieses Ereignis ist nützlich, wenn Sie zusätzliche Informationen über die aktuell ausgewählte Zeile,
Spalte oder Zelle anzeigen wollen. Verwenden Sie hingegen die Ereignisse BeforeRowColChange und
BeforeSelChange, um eine Gültigkeitsprüfung vorzunehmen oder die Bearbeitung einer Zelle zu
verhindern.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
AfterSort-Ereignis
Wird gestartet, nachdem die Spalte durch einen Klick des Nutzers auf die Überschrift sortiert wurde.
Syntax
[VB]
Public Event AfterSort(sender As Object, e As SortColEventArgs) As SortColEventHandler
[C#]
public event SortColEventHandler AfterSort
[Delphi]
property AfterSort: SortColEventHandler;

Ereignisdaten
BeforeAddRow-Ereignis · 229
Der Ereignisabwickler erhält ein Argument vom Typ SortColEventArgs, welches die mit diesem Ereignis
zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle Informationen für
dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int Col Die Spalte, die sortiert wurde.
SortFlags Order Die neue Sortierungsrichtung der Spalte.
Bemerkungen
Dieses Ereignis wird nur gestartet, wenn die Spalte durch einen Klick des Nutzers auf die Überschrift
sortiert wurde (Siehe AllowSorting-Eigenschaft). Es wird nicht nach der Sortierung mit der Sort-
Methode gestartet.
Dieses Ereignis ist nützlich, wenn Sie Benutzerschnittstellenelemente aktualisieren wollen, um die neue
Sortierung anzuzeigen.
Verwenden Sie hingegen Col.AllowSorting oder wickeln Sie das BeforeSort-Ereignis ab, um die
Sortierung von bestimmten Spalten zu unterdrücken oder deren Standardsortierungsrichtung zu ändern.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
BeforeAddRow-Ereignis
Wird gestartet, wenn die AllowAddNew-Eigenschaft auf TRUE steht, und bevor der Nutzer eine neue
Zeile in die Tabelle einfügt.
Syntax
[VB]
Public Event BeforeAddRow(sender As Object, e As RowColEventArgs) As RowColEventHandler
[C#]
public event RowColEventHandler BeforeAddRow
[Delphi]
property BeforeAddRow: RowColEventHandler;
Bemerkungen
Dieses Ereignis wird nicht gestartet, wenn der Steuerung eine neue Zeile programmatisch oder durch die
Datenquelle der Tabelle hinzugefügt wurde. Um es zu startet, muss die AllowAddNew auf TRUE stehen
und der Nutzer eine neue, leere Zeile erstellen, indem er den Cursor in die letzte Zeile der Tabelle stellt.
Sie können dieses Ereignis verwenden, um die Erstellung der neuen Zeile zu verhindern, indem Sie den
Cancel-Parameter auf TRUE stellen. In diesem Fall lässt sich der Cursor nicht in die neue Zeile stellen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)

230 · C1FlexGrid-Referenzverzeichnis
BeforeAutoSizeColumn-Ereignis
Wird gestartet, bevor eine Spalte ihre Breite aufgrund eines Doppelklicks automatisch anpasst.
Syntax
[VB]
Public Event BeforeAutosizeColumn(sender As Object, e As RowColEventArgs) As
RowColEventHandler
[C#]
public event RowColEventHandler BeforeAutosizeColumn
[Delphi]
property BeforeAutosizeColumn: RowColEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int Row, Col Die Zelle, die gleich bearbeitet oder gezeichnet wird.
bool Cancel
Bemerkungen
Setzen Sie diesen Parameter auf TRUE, um die Bearbeitung der Zelle
nicht zuzulassen.
Standardmäßig ändert die Steuerung automatisch die Größe der Zeilen und Spalten hinsichtlich deren
Inhalts für die gesamte Tabelle. Wenn eine Tabelle mehrere Tausend Zeilen beinhaltet, dann können Sie
etwas Zeit sparen, indem Sie dieses Ereignis abfangen, die Größe der Spalten mit der AutoSizeCols-
Methode verändern und den Cancel-Parameter auf TRUE setzen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
BeforeAutoSizeRow-Ereignis
Wird gestartet, bevor eine Zeile ihre Höhe aufgrund eines Doppelklicks automatisch anpasst.
Syntax
[VB]
Public Event BeforeAutosizeRow(sender As Object, e As RowColEventArgs) As RowColEventHandler
[C#]
public event RowColEventHandler BeforeAutosizeRow

[Delphi]
property BeforeAutosizeRow: RowColEventHandler;
Ereignisdaten
BeforeCollapse-Ereignis · 231
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Property Beschreibung
int Row, Col Die Zelle, die gleich bearbeitet oder gezeichnet wird.
bool Cancel
Bemerkungen
Setzen Sie diesen Parameter auf TRUE, um die Bearbeitung der Zelle
nicht zuzulassen.
Standardmäßig ändert die Steuerung automatisch die Größe der Zeilen und Spalten hinsichtlich deren
Inhalts für die gesamte Tabelle. Wenn eine Tabelle mehrere Tausend Zeilen beinhaltet, dann können Sie
etwas Zeit sparen, indem Sie dieses Ereignis abfangen, die Größe der Spalten mit der AutoSizeCols-
Methode verändern und den Cancel-Parameter auf TRUE setzen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
BeforeCollapse-Ereignis
Wird gestartet, bevor eine Knotenzeile auf- oder zusammengeklappt wird.
Syntax
[VB]
Public Event BeforeCollapse(sender As Object, e As RowColEventArgs) As RowColEventHandler
[C#]
public event RowColEventHandler BeforeCollapse
[Delphi]
property BeforeCollapse: RowColEventHandler;
Bemerkungen
Die Ereignisse BeforeCollapse und AfterCollapse werden gestartet, bevor und nachdem ein Knoten
erweitert oder zusammengeklappt wird. Sie können ermitteln, ob der Knoten aus- oder eingeklappt ist,
indem Sie die Expanded-Eigenschaft überprüfen.
Mit diesen Ereignissen können Sie die Gliederung je nach Nachfrage aufbauen, so dass Sie nur die Zeilen
erstellen, die auch wirklich dem Nutzer angezeigt werden. Zum Beispiel, wenn Sie die Tabelle für einen
Verzeichnisbaum nutzen, dann würde es sehr lang dauern, bis jedes Verzeichnis aus dem Speicher
abgerufen wurde, um den Baum zu füllen. Der Nutzer wird dann anschließend wahrscheinlich nur auf
ein paar wenige Knoten schauen.

232 · C1FlexGrid-Referenzverzeichnis
Der nachfolgende Quellcode zeigt, wie Sie das BeforeCollapse-Ereignis abwickeln können, um einen
Baum auf Nachfrage hin zu füllen. Der Code geht davon aus, dass die Tabelle einen Quellknoten mit
einem Unterknoten besitzt. Der Unterknoten wird mit den eigentlichen Daten ersetzt, wenn der Nutzer
den Quellknoten erweitert.
• Visual Basic
• C#
Private m_ExpandingNode As Boolean = False
Private Sub flex_BeforeCollapse(sender As Object, e As RowColEventArgs)
' if we're working, ignore this
If m_ExpandingNode Then
Return
End If
' don't allow collapsing/expanding groups of rows (with shift-click)
If e.Row < 0 Then
e.Cancel = True
Return
End If
' if we're already collapsed, populate node
' before expanding
If flex.Rows(e.Row).Node.Collapsed Then
m_ExpandingNode = True
ExpandRow(e.Row)
m_ExpandingNode = False
End If
End Sub 'flex_BeforeCollapse
private bool m_ExpandingNode = false;
private void flex_BeforeCollapse(object sender, RowColEventArgs e)
{
// if we're working, ignore this
if (m_ExpandingNode)
return;
}
• Delphi
// don't allow collapsing/expanding groups of rows (with shift-click)
if (e.Row < 0)
{
e.Cancel = true;
return;
}
// if we're already collapsed, populate node
// before expanding
if (flex.Rows[e.Row].Node.Collapsed)
{
m_ExpandingNode = true;
ExpandRow(e.Row);
m_ExpandingNode = false;
}
procedure Class1.flex_BeforeCollapse(sender: System.Object; e:
RowColEventArgs);
begin
// if we're working, ignore this
if Self.m_ExpandingNode then
Exit;
// don't allow collapsing/expanding groups of rows (with shift-click)
if (e.Row < 0) then

egin
e.Cancel := True;
Exit;
end;
// if we're already collapsed, populate node
// before expanding
if flex.Rows[e.Row].Node.Collapsed then
begin
Self.m_ExpandingNode := True;
ExpandRow(e.Row);
Self.m_ExpandingNode := False;
end;
end;
BeforeCollapse-Ereignis · 233
Der Quellcode beginnt damit, ein m_ExpandingNode-Flag zu deklarieren, um rekursive Aufrufe zu
verhindern. Dies ist nötig, weil die im Code später aufgerufene ExpandRow-Routine ebenfalls Knoten
erweitert, und somit dieses Ereignis erneut anschiebt.
Danach wird der Wert des e.Row-Parameters geprüft. Dieser Parameter kann negativ sein, wenn viele
Zeilen gleichzeitig erweitert oder zusammengeklappt werden. Dies geschieht, wenn Sie die Tree.Show
Methode aufrufen.
Schlussendlich prüft der Code, ob die aktuelle Zeile zusammengeklappt ist. Wenn dies der Fall ist, dann
wird die Hilfsroutine ExpandRow aufgerufen, um den Knoten zu füllen, bevor dieser erweitert wird.
BeforeCollapse und AfterCollapse werden nun mit Row = -1 gestartet, um anzuzeigen, dass viele Zeilen
gleichzeitig erweitert oder zusammengeklappt werden.
Wenn der Nutzer auf eine Gliederungsschaltfläche klickt, dann werden möglicherweise mehrere Knoten
erweitert oder zusammengeklappt, um eine Zielebene anzuzeigen. In desem Fall startet die Steuerung
zunächst das BeforeCollapse-Ereignis mit dessen Row-Parameter auf -1 stehend, um anzuzeigen, dass
eine Abfolgeoperation mit mehrmaligem Auf-/Zuklappen gestartet wird. Abschließend wird das
AfterCollapse-Ereignis ebenfalls mit dessen Row-Parameter auf -1 stehend gestartet, um anzuzeigen,
dass die Abfolgeoperationen beendet sind. Zum Beispiel, wenn der Nutzer die Gliederung bis zu einer
betimmten Ebene erweitert, dann wird die Steuerung die folgende Ereignisabfolge starten:
• Visual Basic
• C#
BeforeCollapse(e.Row = - 1) ' ** batch started
BeforeCollapse(e.Row = 1) ' individual rows being collapsed/expanded
AfterCollapse(e.Row = 1)
BeforeCollapse(e.Row = 5)
AfterCollapse(e.Row = 5)
BeforeCollapse(e.Row = 15)
AfterCollapse(e.Row = 15)
AfterCollapse(e.Row = - 1) ' ** batch ended
BeforeCollapse (e.Row = -1) // ** batch started
BeforeCollapse (e.Row = 1) // individual rows being collapsed/expanded
AfterCollapse (e.Row = 1)
BeforeCollapse (e.Row = 5)
AfterCollapse (e.Row = 5)
BeforeCollapse (e.Row = 15)
AfterCollapse (e.Row = 15)
AfterCollapse (e.Row = -1) // ** batch ended
• Delphi
BeforeCollapse(e.Row = -1); // ** batch started

234 · C1FlexGrid-Referenzverzeichnis
BeforeCollapse(e.Row = 1); // individual rows being
collapsed/expanded
AfterCollapse(e.Row = 1);
BeforeCollapse(e.Row = 5);
AfterCollapse(e.Row = 5);
BeforeCollapse(e.Row = 15);
AfterCollapse(e.Row = 15);
AfterCollapse(e.Row = -1); // ** batch ended
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
BeforeDeleteRow-Ereignis
Wird gestartet, wenn die AllowDelete-Eigenschaft auf TRUE steht, und bevor der Nutzer eine Zeile in
der Tabelle mit der Entfernen-Taste löscht.
Syntax
[VB]
Public Event BeforeDeleteRow(sender As Object, e As RowColEventArgs) As RowColEventHandler
[C#]
public event RowColEventHandler BeforeDeleteRow
[Delphi]
property BeforeDeleteRow: RowColEventHandler;
Bemerkungen
Dieses Ereignis wird nicht gestartet, wenn die Steuerung eine Zeile programmatisch oder durch die
Datenquelle aus der Tabelle entfernt. Um es zu startet, muss die AllowAddNew auf TRUE stehen und
der Nutzer eine oder mehrere Zeilen mit der Entfernen-Taste löschen.
Verwenden Sie dieses Ereignis, um das Löschen von Zeilen zu verhindern, indem Sie den Cancel-
Parameter auf TRUE stellen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
BeforeDragColumn-Ereignis
Wird gestartet, bevor der Nutzer eine Spalte mit der Maus verschiebt und sich die Spalte an ihrer neuen
Position befindet.
Syntax
[VB]
Public Event BeforeDragColumn(sender As Object, e As DragRowColEventArgs) As
DragRowColEventHandler
[C#]
public event DragRowColEventHandler BeforeDragColumn

[Delphi]
property BeforeDragColumn: DragRowColEventHandler;
Ereignisdaten
BeforeDragRow-Ereignis · 235
Der Ereignisabwickler erhält ein Argument vom Typ DragRowColEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int Col Der aktuelle Index der Spalte, die vom Nutzer gezogen wurde.
int Position
Bemerkungen
Der neue Index der Spalte, die vom Nutzer gezogen wurde. Sie können diesen
Wert verändern, um die Spalte auf eine neue Position zu verschieben.
Dieses Ereignis wird nur gestartet, wenn eine Spalte vom Nutzer verschoben wird, indem er diese mit
der Maus zieht (Siehe AllowDragging-Eigenschaft). Es wird nicht gestartet, wenn eine Spalte mit der
Cols.Move-Methode verschoben wird.
Sie können das Ziehen von bestimmten Zeilen und Spalten verhindern, indem Sie deren AllowDragging-
Eigenschaft auf FALSE setzen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
BeforeDragRow-Ereignis
Wird gestartet, bevor der Nutzer eine Zeile mit der Maus verschieben will und sich die Zeile an ihrer
neuen Position befindet.
Syntax
[VB]
Public Event BeforeDragRow(sender As Object, e As DragRowColEventArgs) As
DragRowColEventHandlers
[C#]
public event DragRowColEventHandler BeforeDragRow
[Delphi]
property BeforeDragRow: DragRowColEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ DragRowColEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.

236 · C1FlexGrid-Referenzverzeichnis
Eigenschaft Beschreibung
int Row Der aktuelle Index der Zeile, die vom Nutzer gezogen wurde.
int Position
Bemerkungen
Der neue Index der Zeile, die vom Nutzer gezogen wurde. Sie können diesen Wert
verändern, um die Zeile auf eine neue Position zu verschieben.
Dieses Ereignis wird nur gestartet, wenn eine Zeile vom Nutzer verschoben wird, indem er diese mit der
Maus zieht (Siehe AllowDragging-Eigenschaft). Es wird nicht gestartet, wenn eine Zeile mit der
Rows.Move-Methode verschoben wird.
Sie können das Ziehen von bestimmten Zeilen und Spalten verhindern, indem Sie deren AllowDragging-
Eigenschaft auf FALSE setzen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
BeforeEdit-Ereignis
Wird gestartet, bevor die Steuerung in den Bearbeitungsmodus geht.
Syntax
[VB]
Public Event BeforeEdit(sender As Object, e As RowColEventArgs) As RowColEventHandler
[C#]
public event RowColEventHandler BeforeEdit
[Delphi]
property BeforeEdit: RowColEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int Row, Col Die Zelle, die gleich bearbeitet oder gezeichnet wird.
bool Cancel
Bemerkungen
Setzen Sie diesen Parameter auf TRUE, um die Bearbeitung der Zelle nicht
zuzulassen.
Dieses Ereignis wird gestartet, bevor die Steuerung in den Bearbeitungsmodus versetzt wird und bevor
eine veränderbare Zelle neu gezeichnet wird, wenn diese den Fokus erhält, um festzustellen, ob diese mit
einem Auswahlfeldpfeil versehen wird. Außerdem können Sie die Bearbeitung verhindern, indem Sie

BeforeFreezeColumn-Ereignis · 237
den Cancel-Parameter auf TRUE setzen, oder mit der ComboList-Eigenschaft eine Auswahlliste an
möglichen Elementen oder mit der EditMask-Eigenschaft eine Eingabemaske zur Verfügung stellen.
Wenn die Auswahl oder die Eingabemaske für die gesamte Spalte gleich ist, dann können Sie auch die
entsprechenden Eigenschaften (AllowEdit, ComboList und EditMask) des Column-Objekts setzen.
Weil das BeforeEdit-Ereignis vor jeder Neuzeichnung gestartet wird, kann dieses nicht garantieren, dass
die Tabelle in den Bearbeitungsmodus geht. Verwenden Sie hierfür stattdessen das StartEdit-Ereignis.
Beispiel
Der Nachfolgende Quellcode zeigt, wie Sie die Bearbeitung von bestimmten Zellen aufgrund deren
Inhalts verhindern können. Für eine ganze Spalte können Sie die Bearbeitung mit deren AllowEditing-
Eigenschaft verhindern, indem Sie diese auf FALSE setzen.
• Visual Basic
• C#
Private Sub c1FlexGrid1_BeforeEdit(sender As Object, e As
RowColEventArgs)
Dim value As Object = _flex(e.Row, e.Col)
If TypeOf value Is Integer And CInt(value) < 0 Then
e.Cancel = True
End If
End Sub 'c1FlexGrid1_BeforeEdit
private void c1FlexGrid1_BeforeEdit(object sender, RowColEventArgs e)
{
object value = _flex[e.Row, e.Col];
if (value is int && (int)value < 0)
e.Cancel = true;
}
• Delphi
var
value: System.Object;
begin
value := _flex[e.Row];
if ((value is System.Int32) and (Integer(value) < 0)) then
e.Cancel := True;
end;
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
BeforeFreezeColumn-Ereignis
Wird gestartet, bevor der Nutzer Spalten mit der Maus fixiert.
Syntax
[VB]
Public Event BeforeFreezeColumn(sender As Object, e As RowColEventArgs) As RowColEventHandler
[C#]
public event RowColEventHandler BeforeFreezeColumn

238 · C1FlexGrid-Referenzverzeichnis
[Delphi]
property BeforeFreezeColumn: RowColEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Property Beschreibung
int Row, Col Die Zelle, die gleich bearbeitet oder gezeichnet wird.
bool Cancel
Bemerkungen
Setzen Sie diesen Parameter auf TRUE, um die Bearbeitung der Zelle nicht
zuzulassen.
Siehe auch AllowFreezing-Eigenschaft (Seite 120).
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
BeforeFreezeRow-Ereignis
Wird gestartet, bevor der Nutzer Zeilen mit der Maus fixiert.
Syntax
[VB]
Public Event BeforeFreezeRow(sender As Object, e As RowColEventArgs) As RowColEventHandler
[C#]
public event RowColEventHandler BeforeFreezeRow
[Delphi]
property BeforeFreezeRow: RowColEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Property Beschreibung
int Row, Col Die Zelle, die gleich bearbeitet oder gezeichnet wird.
bool Cancel
Setzen Sie diesen Parameter auf TRUE, um die Bearbeitung der Zelle nicht
zuzulassen.

Bemerkungen
Schauen Sie auch unter der AllowFreezing-Eigenschaft (Seite 120) nach.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
BeforeMouseDown-Ereignis
Wird gestartet, bevor die Steuerung das MouseDown-Ereignis verarbeitet.
Syntax
[VB]
BeforeMouseDown-Ereignis · 239
Public Event BeforeMouseDown(sender As Object, e As BeforeMouseDownEventArgs) As
BeforeMouseDownEventHandler
[C#]
public BeforeMouseDownEventHandler BeforeMouseDown
[Delphi]
property BeforeMouseDown: BeforeMouseDownEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ BeforeMouseDownEventArgs, welches die mit
diesem Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
MouseButtons Button Ermittelt, welche Maustaste gedrückt wurde.
int Clicks, X, Y, Delta
bool Cancel
Bemerkungen
Weitere Informationen über die Mausoperationen (die gleichen Parameter
wie im MouseDown-Ereignis).
Setzen Sie diesen Parameter auf TRUE, um die Steuerung davon
abzuhalten, die Mausoperationen zu verarbeiten.
Die Parameter für dieses Ereignis sind gleich denen im MouseDown-Ereignis zuzüglich einem Cancel-
Parameter. Mit diesem können Sie das Standardvorgehen der Steuerung abbrechen und das Ereignis
selbst abwickeln.
Beispiel
Die folgende Routine deaktiviert die Auswahl per Maus, während die Tabelle im Bearbeitungsmodus ist:
• Visual Basic
Private Sub flex_BeforeMouseDown(sender As Object, e As
BeforeMouseDownEventArgs)
If Not (flex.Editor Is Nothing) Then
e.Cancel = True
End If

240 · C1FlexGrid-Referenzverzeichnis
• C#
End Sub 'flex_BeforeMouseDown
private void flex_BeforeMouseDown(object sender,
BeforeMouseDownEventArgs e)
{
if (flex.Editor != null)
e.Cancel = true;
}
• Delphi
procedure Class1.flex_BeforeMouseDown(sender: System.Object; e:
BeforeMouseDownEventArgs);
begin
if (flex.Editor nil) then
e.Cancel := True;
end;
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
BeforePageBreak-Ereignis
Wird gestartet, während die Tabelle gedruckt wird, um die Seitenumbrüche zu steuern.
Syntax
[VB]
Public Event BeforePageBreak(sender As Object, e As RowColEventArgs) As RowColEventHandler
[C#]
public event RowColEventHandler BeforePageBreak
[Delphi]
property BeforePageBreak: RowColEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int Row Die Zeile, die den Zeilenumbruch herbeiführt und die erste auf der neuen Seite ist.
bool Cancel
Bemerkungen
Setzen Sie diesen Parameter auf TRUE, um zu verhindern, dass die Zeile in Row
die erste auf einer neuen Seite ist.
Dieses Ereignis wird ausgeführt, während die Tabellensteuerung mit der PrintGrid-Methode druckt und
sie stellt die Kontrolle über Seitenumbrüche zur Verfügung.

BeforeResizeColumn-Ereignis · 241
Setzen Sie den Cancel-Parameter auf TRUE, um zu verhindern, dass die Zeile in Row die erste auf einer
neuen Seite ist. In diesem Fall wird die Steuerung den Umbruch nach oben verschieben und das Ereignis
erneut aufrufen, bis sie eine gültige Zeile für einen Umbruch gefunden hat.
Beispiel
Der folgende Code zeigt, wie das BeforePageBreak-Ereignis verwendet wird, um gewisse Zeilengruppen
auf einer Seite auszugeben.
• Visual Basic
• C#
Private Sub flex_BeforePageBreak(sender As Object, e As
RowColEventArgs)
' get content before and after the proposed page break
Dim s1 As String = CStr(flex(e.Row, 1))
Dim s2 As String = CStr(flex(e.Row - 1, 1))
' if contents are the same, set Cancel to true to
' keep rows together on a page
If s1 = s2 Then
e.Cancel = True
End If
End Sub 'flex_BeforePageBreak
private void flex_BeforePageBreak(object sender, RowColEventArgs e)
{
// get content before and after the proposed page break
string s1 = (string) flex[e.Row,1];
string s2 = (string) flex[e.Row-1,1];
}
• Delphi
// if contents are the same, set Cancel to true to
// keep rows together on a page
if (s1 == s2)
e.Cancel = true;
procedure Class1.flex_BeforePageBreak(sender: System.Object; e:
RowColEventArgs);
var
s2: string;
s1: string;
begin
s1 := string(flex[e.Row]);
s2 := string(flex[(e.Row - 1)]);
if (s1 = s2) then
e.Cancel := True;
end;
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
BeforeResizeColumn-Ereignis
Wird gestartet, bevor die Breite von Spalten verändert wird.

242 · C1FlexGrid-Referenzverzeichnis
Syntax
[VB]
Public Event BeforeResizeColumn(sender As Object, e As RowColEventArgs) As RowColEventHandler
[C#]
public event RowColEventHandler BeforeResizeColumn
[Delphi]
property BeforeResizeColumn: RowColEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Property Beschreibung
int Col Die Spalte, deren Breite verändert wird.
bool Cancel
Bemerkungen
Setzen Sie diesen Parameter auf TRUE, um die Größenänderung der Spalte in Col
zu verhindern.
Verwenden Sie die AllowResizing-Eigenschaft der Tabelle um festzustellen, ob Nutzer die Größe von
Zeilen, Spalten oder beides verändern dürfen. Row- und Column-Objekte besitzen ebenfalls eine
AllowResizing-Eigenschaft, mit der Sie die Änderung der Größe von Spalten verhindern können.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
BeforeResizeRow-Ereignis
Wird gestartet, bevor die Höhe von Zeilen verändert wird.
Syntax
[VB]
Public Event BeforeResizeRow(sender As Object, e As RowColEventArgs) As RowColEventHandler
[C#]
public event RowColEventHandler BeforeResizeRow
[Delphi]
property BeforeResizeRow: RowColEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.

Eigenschaft Beschreibung
int Row Die Zeile, deren Höhe verändert wird.
bool Cancel
Bemerkungen
BeforeRowColChange-Ereignis · 243
Setzen Sie diesen Parameter auf TRUE, um die Größenänderung der Zeile in Row
zu verhindern.
Verwenden Sie die AllowResizing-Eigenschaft der Tabelle um festzustellen, ob Nutzer die Größe von
Zeilen, Spalten oder beiden verändern dürfen. Row- und Column-Objekte besitzen ebenfalls eine
AllowResizing-Eigenschaft, mit der Sie die Änderung der Größe von Spalten verhindern können.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
BeforeRowColChange-Ereignis
Wird gestartet, bevor eine andere Zelle zur aktuellen Zelle (Row, Col) wird.
Syntax
[VB]
Public Event BeforeRowColChange(sender As Object, e As RangeEventArgs) As RangeEventHandler
[C#]
public event RangeEventHandler BeforeRowColChange
[Delphi]
property BeforeRowColChange: RangeEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ RangeEventArgs, welches die mit diesem Ereignis
zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle Informationen für
dieses Ereignis zur Verfügung.
Property Beschreibung
CellRange OldRange Die Auswahl vor dem Ereignis.
CellRange NewRange Die aktuelle Auswahl.
Bemerkungen
Dieses Ereignis wird gestartet, bevor sich die Row- oder Col-Eigenschaften durch entweder den Nutzer
oder durch Quellcode ändern. Außerdem können Sie die Auswahl von bestimmten Zellen verhindern
und einen geschützten Bereich auf der Tabelle erstellen.
BeforeRowColChange wird nur gestartet, wenn sich Row- und Col-Eigenschaften gerade ändern. Um
eine erweiterte Auswahl eines Bereichs zu verhindern, müssen Sie das BeforeSelChange-Ereignis
abfangen.

244 · C1FlexGrid-Referenzverzeichnis
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
BeforeScroll-Ereignis
Wird gestartet, bevor die Steuerung scrollt.
Syntax
[VB]
Public Event BeforeScroll(sender As Object, e As RangeEventArgs) As RangeEventHandler
[C#]
public event RangeEventHandler BeforeScroll
[Delphi]
property BeforeScroll: RangeEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ RangeEventHandler, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Bemerkungen
Mit diesem Ereignis können Sie den Nutzer daran hindern, die Tabelle zu scrollen, während eine
Operation in der aktuellen Auswahl ausgeführt wird.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
BeforeScrollTip-Ereignis
Wird gestartet, bevor ein Scroll-Tip angezeigt wird, so dass Sie die ScrollTipText-Eigenschaft setzen
können.
Syntax
[VB]
Public Event BeforeScrollTip(sender As Object, e As RowColEventArgs) As RowColEventHandler
[C#]
public event RowColEventHandler BeforeScrollTip
[Delphi]
property BeforeScrollTip: RangeEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.

Eigenschaft Beschreibung
int Row Die Zeile, in der die aktuelle Zelle platziert ist.
Bemerkungen
BeforeSelChange-Ereignis · 245
Dieses Ereignis wird nur ausgeführt, wenn die ScrollTips-Eigenschaft auf TRUE steht. Somit können Sie
die ScrollTipText-Eigenschaft auf einen, für eine gegebene Zeile beschreibenden, Text setzen. Zum
Beispiel:
• Visual Basic
• C#
flex.ScrollTips = True
flex.ScrollTrack = False
Private Sub flex_BeforeScrollTip(sender As Object, e As
RowColEventArgs)
Dim tip As String
tip = String.Format("Row {0}" + ControlChars.Lf + "{1}", _
e.Row, flex(e.Row, 1))
flex.ScrollTipText = tip
End Sub 'flex_BeforeScrollTip
flex.ScrollTips = true;
flex.ScrollTrack = false;
private void flex_BeforeScrollTip(object sender, RowColEventArgs e)
{
string tip = string.Format("Row {0}\n{1}", e.Row, flex[e.Row,1]);
flex.ScrollTipText = tip;
}
• Delphi
flex.ScrollTips := True;
flex.ScrollTrack := False;
procedure Class1.flex_BeforeScrollTip(sender: System.Object; e:
RowColEventArgs);
var
tip: string;
begin
tip := System.String.Format('Row {0}'#10'{1}', e.Row, flex[e.Row]);
flex.ScrollTipText := tip;
end;
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
BeforeSelChange-Ereignis
Wird gestartet, bevor sich eine Auswahl (RowSel, ColSel) ändert.

246 · C1FlexGrid-Referenzverzeichnis
Syntax
[VB]
Public Event BeforeSelChange(sender As Object, e As RangeEventArgs) As RangeEventHandler
[C#]
public event RangeEventHandler BeforeSelChange
[Delphi]
property BeforeSelChange: RangeEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ RangeEventArgs, welches die mit diesem Ereignis
zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle Informationen für
dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
CellRange OldRange Die Auswahl vor dem Ereignis.
CellRange NewRange Die aktuelle Auswahl.
Bemerkungen
Dieses Ereignis wird, bevor sich die Row- oder Col-Eigenschaften durch entweder den Nutzer oder
durch Quellcode ändert, gestartet. Außerdem können Sie die Auswahl von bestimmten Zellen
verhindern und einen geschützten Bereich auf der Tabelle erstellen.
Um eine Berichsauswahl zu verhindern, müssen Sie außerdem das BeforeRowColChange-Ereignis,
welches vor den Änderungen der Row- und Col-Eigenschaften gestartet wird, abfangen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
BeforeSort-Ereignis
Wird gestartet, bevor die Spalte durch einen Klick des Nutzers auf die Überschrift sortiert wird.
Syntax
[VB]
Public Event BeforeSort(sender As Object, e As SortColEventArgs) As SortColEventHandler
[C#]
public event SortColEventHandler BeforeSort
[Delphi]
property BeforeSort: SortColEventHandler;
Ereignisdaten

BeginPrint-Ereignis · 247
Der Ereignisabwickler erhält ein Argument vom Typ SortColEventArgs, welches die mit diesem Ereignis
zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle Informationen für
dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int Col Die zu sortierende Spalte.
SortFlags Order Die Sortierungsrichtung.
bool Cancel
bool Handled
Bemerkungen
Bricht das Sortieren ab. Wenn dieser Parameter auf TRUE gestellt wird, dann
bricht die Sortieroperation ab und das Sortierungszeichen bleibt unverändert.
Das Sortieren wurde vom Ereignisabwickler durchgeführt. Wenn dieser
Parameter auf TRUE gestellt wird, dann bricht das integrierte Sortieren ab,
Das Sortierungszeichen wird aber dennoch aktualisiert, so als ob das Sortieren
stattgefunden hätte. Dies ist nützlich, wenn Sie benutzerdefiniertes Sortieren
verwenden.
Dieses Ereignis wird nur gestartet, wenn das Sortieren durch einen Klick auf die Spaltenüberschrift
ausgelöst wurde. Es wird nicht gestartet, wenn das Sortieren mit der Sort-Eigenschaft stattgefunden hat.
Dieses Ereignis ist nützlich, wenn Sie das Sortieren von bestimmten Spalten durch den Nutzer
verhindern oder wenn Sie benutzerdefinierte Sortierungsrichtungen für bestimmte Spalten anwenden
wollen. Dies kann über den Wert des Order-Parameters gesteuert werden.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
BeginPrint-Ereignis
Wird gestartet, wenn die Tabelle beginnt zu drucken.
Syntax
[VB]
Public Event BeginPrint(sender As Object, e As PrintEventArgs) As PrintEventHandler
[C#]
public event PrintEventHandler BeginPrint
[Delphi]
property BeginPrint: PrintEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ PrintEventHandler, der im
System.Drawing.Printing-Namensbereich definiert ist.
Bemerkungen
Verwenden Sie die PrintGrid-Methode um die Tabelle zu drucken und um den Dokumentennamen,
allgemeine Druckoptionen, Kopf- und Fußzeilen festzulegen. Verwenden Sie hingegen die

248 · C1FlexGrid-Referenzverzeichnis
PrintParameters-Eigenschaft um weniger allgemeine Druckoptionen, wie z.B. Kopf- und
Fußzeilenschriftart, Seitenränder und Ausrichtung, festzulegen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
CancelAddRow-Ereignis
Wird gestartet, wenn die AllowAddNew-Eigenschaft TRUE ist, und nachdem der Nutzer eine Zeile
hinzugefügt hat, diese aber wieder entfernt, indem er sie ohne Änderungen verlässt.
Syntax
[VB]
Public Event CancelAddRow(sender As Object, e As RowColEventArgs) As RowColEventHandler
[C#]
public event RowColEventHandler CancelAddRow
[Delphi]
property CancelAddRow: RowColEventHandler;
Bemerkungen
Schauen Sie im AfterAddRow-Ereignis für Einzelheiten nach.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
CellButtonClick-Ereignis
Wird gestartet, wenn der Nutzer auf die Zellschaltfläche klickt.
Syntax
[VB]
Public Event CellButtonClick(sender As Object, e As RowColEventArgs) As RowColEventHandler
[C#]
public event RowColEventHandler CellButtonClick
[Delphi]
property CellButtonClick: RowColEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Property Beschreibung
int Row Die Zeile, in der die aktuelle Zelle platziert ist.

int Col Die Spalte, in der die aktuelle Zelle platziert ist.
Bemerkungen
CellChanged-Ereignis · 249
Dieses Ereignis wird gestartet, wenn der Nutzer eine Bearbeitungsschaltfläche in einer Zelle anklickt.
Typischerweise wird diese dazu verwendet, um einen benutzerdefinierten Editor vor der Zelle zu
platzieren (z.B. Fenster für Farbauswahl, Datum, Dateien, Bilder, usw.).
Standardmäßig werden Zellbearbeitungsschaltflächen rechts in der Zelle mit der Beschriftung
„...“angezeigt. Diese sind den Schaltflächen im Visual Basic-Eigenschaftsfenster neben den Picture-
Eigenschaften ähnlich. Sie können deren Aussehen anpassen, indem Sie eine Grafik in der
CellButtonImage-Eigenschaft festlegen.
Um eine Bearbeitungsschaltfläche in einer Zelle zu erstellen, müssen Sie die AllowEditing-Eigenschaft
auf TRUE stellen und die ComboList-Eigenschaft der Tabelle oder einer bestimmten Spalte auf eine
Ellipsis („…“) setzen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
CellChanged-Ereignis
Wird gestartet, nachdem der Inhalt einer Zelle sich verändert hat.
Syntax
[VB]
Public Event CellChanged(sender As Object, e As RowColEventArgs) As RowColEventHandler
[C#]
public event RowColEventHandler CellChanged
[Delphi]
property CellChanged: RowColEventHandler;
Bemerkungen
Mit diesem Ereignis können Sie Prozesse ausführen, wenn sich Zellinhalte ändern, egal auf welchem
Wege (z.B. ein Nutzer gibt Daten in eine Zelle ein, Daten werden aus Datenbanken geladen oder Daten
werden durch Quellcode eingefügt).
Dieses Ereignis kann dafür verwendet werden, um bedingte Formatierungen und dynamische
Datenzusammenfassungen zu implementieren, so dass diese automatisch aktualisiert werden, wenn
immer sich Daten ändern. Für ein Beispiel schauen Sie bitte unter „Zellen formatieren“ (Seite 29) nach.
Wichtige Anmerkung: In manchen Fällen wird CellChanged mit e.Col = -1 gestartet.
Wenn Sie eine Zelle in der Tabelle bearbeiten, dann wird das CellChanged-Ereignis gestartet und zeigt
Ihnen, welche Zeilen und Spalten verändert wurden. Dies funktioniert im gebundenen und
ungebundenen Modus.
Wenn die Tabelle an eine Datenquelle gebunden ist und sich Daten in dieser Datenquelle ändern, dann
informiert die Quelle die Tabelle, dass sich etwas in einer bestimmten Zeile geändert hat. Es wird
allerdings nicht die entsprechende Spalte übermittelt und es könnten eventuell auch mehrere Spalten

250 · C1FlexGrid-Referenzverzeichnis
betroffen sein. Dies wird durch die Definition der IBindingList-Schnittstelle in .NET determiniert.
Änderungshinweise werden auf Zeilenebene (Datensätze) und nicht auf Spaltenebene (Felder) gegeben.
Wenn die Tabelle gebunden ist und der Nutzer etwas in eine Zelle schreibt, dann werden zwei
Mittteilungen ausgegeben. Eine Mittteilung von der Tabelle mit der Zeile und Spalte der aktuellen Zelle
und eine weitere Mittteilung von der Datenquelle mit der aktuellen Zeile und -1 für die Spalte. Wenn das
einzige UI-Element, dass die Daten in Ihrer Anwendung ändern kann, die Tabelle ist, dann können Sie
die zweite Mittteilung ignorieren.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
ChangeEdit-Ereignis
Wird gestartet, nachdem der Text im Editor sich verändert hat.
Syntax
[VB]
Public Event ChangeEdit(sender As Object, e As EventArgs) As EventHandler
[C#]
public EventHandler ChangeEdit
[Delphi]
property ChangeEdit: EventHandler;
Ereignisdaten
Keine Parameter.
Bemerkungen
Dieses Ereignis wird gestartet, während sich die Tabelle im Bearbeitungsmodus befindet und sich die
Inhalte des Editors ändern, oder eine neue Auswahl aus einem Auswahlfeld getätigt wird.
Beispiel
Der nachfolgende Quellcode zeigt, wie Sie das ChangeEdit-Ereignis verwenden können, um die Größe
einer Zeile an den Inhalt ihrer Zellen anzupassen und die Zeilenhöhe automatisch anzupassen, während
der Nutzer Daten in die entsprechenden Zeilen eingibt:
• Visual Basic
' set up grid styles to allow wordwrapping:
Private Sub Form1_Load(sender As Object, e As System.EventArgs)
flex.Styles.Normal.WordWrap = True
End Sub 'Form1_Load
' after editing a row, do an AutoSizeRow
Private Sub flex_AfterEdit(sender As Object, e As RowColEventArgs)
flex.AutoSizeRow(e.Row)
End Sub 'flex_AfterEdit
' while editing, adjust the row height to fit the contents of the
editor
Private Sub flex_ChangeEdit(sender As Object, e As System.EventArgs)
Dim g As Graphics = flex.CreateGraphics()
Try

• C#
ChangeEdit-Ereignis · 251
' measure text height
Dim sf As New StringFormat()
Dim wid As Integer = flex.Cols(flex.Col).WidthDisplay - 2
Dim [text] As String = flex.Editor.Text
Dim sz As SizeF = g.MeasureString([text], flex.Font, wid, sf)
' adjust row height if necessary
Dim row As Row = flex.Rows(flex.Row)
If sz.Height + 4 > row.HeightDisplay Then
row.HeightDisplay = CInt(sz.Height) + 4
End If
Finally
g.Dispose()
End Try
End Sub 'flex_ChangeEdit
// set up grid styles to allow wordwrapping:
private void Form1_Load(object sender, System.EventArgs e)
{
flex.Styles.Normal.WordWrap = true;
}
// after editing a row, do an AutoSizeRow
private void flex_AfterEdit(object sender, RowColEventArgs e)
{
flex.AutoSizeRow(e.Row);
}
// while editing, adjust the row height to fit the contents of the
editor
private void flex_ChangeEdit(object sender, System.EventArgs e)
{
using (Graphics g = flex.CreateGraphics())
{
// measure text height
StringFormat sf = new StringFormat();
int wid = flex.Cols[flex.Col].WidthDisplay - 2;
string text = flex.Editor.Text;
SizeF sz = g.MeasureString(text, flex.Font, wid, sf);
}
}
• Delphi
// adjust row height if necessary
Row row = flex.Rows[flex.Row];
if (sz.Height + 4 > row.HeightDisplay)
row.HeightDisplay = (int)sz.Height + 4;
// set up grid styles to allow wordwrapping:
procedure Form1_Load(sender: System.Object; e: System.EventArgs);
begin
flex.Styles.Normal.WordWrap := True;
end; // Form1_Load
// after editing a row, do an AutoSizeRow
procedure flex_AfterEdit(sender: System.Object; e: RowColEventArgs);
begin
flex.AutoSizeRow(e.Row);
end; // flex_AfterEdit
// while editing, adjust the row height to fit the contents of the
editor
procedure flex_ChangeEdit(sender: System.Object; e: System.EventArgs);
var

252 · C1FlexGrid-Referenzverzeichnis
g: Graphics;
sf: StringFormat;
wid: Integer;
txt: string;
sz: SizeF;
r: Row;
begin
g := flex.CreateGraphics;
Try
// measure text height
sf := StringFormat.Create;
wid := flex.Cols[flex.Col].WidthDisplay – 2;
txt := flex.Editor.Text;
sz := g.MeasureString(txt, flex.Font, wid, sf);
// adjust row height if necessary
r := flex.Rows[flex.Row];
if sz.Height + 4 > row.HeightDisplay then
row.HeightDisplay := Integer(sz.Height) + 4;
Finally
g.Dispose;
end;
end; // flex_ChangeEdit
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
ComboCloseUp-Ereignis
Wird gestartet, wenn sich die Tabelle im Bearbeitungsmodus befindet, und bevor der Nutzer eine
Auswahlkombinationsliste zuklappt.
Syntax
[VB]
Public Event ComboCloseUp(sender As Object, e As RowColEventArgs) As RowColEventHandler
[C#]
public event RowColEventHandler ComboCloseUp
[Delphi]
property ComboCloseUp: RowColEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int Row Die Zeile, in der die aktuelle Zelle platziert ist.
int Col Die Spalte, in der die aktuelle Zelle platziert ist.

Bemerkungen
ComboDropDown-Ereignis · 253
Dieses Ereignis wird gestartet, während sich die Tabelle im Bearbeitungsmodus befindet und die Zelle
mit dem integrierten Auswahllisteneditor bearbeitet wird.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
ComboDropDown-Ereignis
Wird gestartet, wenn sich die Tabelle im Bearbeitungsmodus befindet, und bevor der Nutzer eine
Auswahlkombinationsliste aufklappt.
Syntax
[VB]
Public Event ComboDropDown(sender As Object, e As RowColEventArgs) As RowColEventHandler
[C#]
public event RowColEventHandler ComboDropDown
[Delphi]
property ComboDropDown: RowColEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int Row Die Zeile, in der die aktuelle Zelle platziert ist.
int Col Die Spalte, in der die aktuelle Zelle platziert ist.
Bemerkungen
Dieses Ereignis wird gestartet, während sich die Tabelle im Bearbeitungsmodus befindet und die Zelle
mit dem integrierten Auswahllisteneditor bearbeitet wird.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
EndPrint-Ereignis
Wird gestartet, wenn die Tabelle den Druckvorgang beendet hat.
Syntax
[VB]
Public Event EndPrint(sender As Object, e As PrintEventArgs) As PrintEventHandler

254 · C1FlexGrid-Referenzverzeichnis
[C#]
public event PrintEventHandler EndPrint
[Delphi]
property EndPrint: PrintEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ PrintEventHandler, welches im
System.Drawing.Printing-Namensbereich definiert ist.
Bemerkungen
Verwenden Sie die PrintGrid-Methode, um die Tabelle zu drucken und um den Dokumentennamen,
allgemeine Druckoptionen, Kopf- und Fußzeilen festzulegen. Verwenden Sie hingegen die
PrintParameters-Eigenschaft um weniger allgemeine Druckoptionen, wie z.B. Kopf- und
Fußzeilenschriftart, Seitenränder und Ausrichtung, festzulegen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
EnterCell-Ereignis
Wird gestartet, wenn eine Zelle aktiv wird.
Syntax
[VB]
Public Event EnterCell(sender As Object, e As EventArgs) As EventHandler
[C#]
public event EventHandler EnterCell
[Delphi]
property EnterCell: EventHandler;
Ereignisdaten
Keine Parameter.
Bemerkungen
Dieses Ereignis wird gestartet, nachdem eine Zelle aktuell geworden ist, entweder durch die
Maus/Tastatur, oder wenn die aktuelle Auswahl durch Programmcode verändert wurde.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
GetCellErrorInfo-Ereignis
Wird gestartet, wenn ShowErrors TRUE ist und die Tabelle Fehlerinformationen für eine Zelle benötigt.

Syntax
[VB]
GetRowErrorInfo-Ereignis · 255
Public Event GetCellErrorInfo(ByVal sender As Object, ByVal e As
C1.Win.C1FlexGrid.GetErrorInfoEventArgs) As C1.Win.C1FlexGrid.GetErrorInfoEventHandler
[C#]
public event GetErrorInfoEventHandler GetCellErrorInfo
[Delphi]
property GetCellErrorInfo: GetErrorInfoEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ GetErrorInfoEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int Row, Col Die Zeile oder Spalte, für die Fehlerinformationen benötigt werden.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
GetRowErrorInfo-Ereignis
Wird gestartet, wenn ShowErrors TRUE ist und die Tabelle Fehlerinformationen für eine Zeile benötigt.
Syntax
[VB]
Public Event GetRowErrorInfo(ByVal sender As Object, ByVal e As
C1.Win.C1FlexGrid.GetErrorInfoEventArgs) As C1.Win.C1FlexGrid.GetErrorInfoEventHandler
[C#]
public event GetErrorInfoEventHandler GetRowErrorInfo
[Delphi]
property GetRowErrorInfo: GetErrorInfoEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ GetErrorInfoEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int Row, Col Die Zeile oder Spalte, für die Fehlerinformationen benötigt werden.

256 · C1FlexGrid-Referenzverzeichnis
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
GetUnboundValue-Ereignis
Wird gestartet, wenn die Tabelle gebunden ist und Werte von einer ungebundenen Tabelle abrufen muss.
Syntax
[VB]
Public Event GetUnboundValue(sender As Object, e As EventArgs) As UnboundValueEventHandler
[C#]
public event UnboundValueEventHandler GetUnboundValue
[Delphi]
property GetUnboundValue: UnboundValueEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ UnboundValueEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int Row, Col Die ungebundene Zelle, die den Wert enthält.
object Value
Bemerkungen
Der Wert der ungebundenen Zelle. Der Ereignisabwickler sollte den
ungebundenen Wert abrufen oder berechnen und diesem Parameter
zuordnen.
Dieses Ereignis wird nur im gebundenen Modus gestartet, wenn die Tabelle ungebundene Spalten
enthält. Ungebundene Spalten verknüpfen ihre Werte nicht mit der Datenquelle. Sie können auf
gebundene Spalten basierende Informationen berechnen oder andere Information, die in der Tabelle
durch die Anwendung zur Verfügung gestellt werden, enthalten.
Die ADO.NET DataTable-Klasse unterstützt berechnete Spalten, die in vielen Situationen anstelle der
ungebundenen verwendet werden können. Dennoch sind berechnete Spalten etwas beschränkt. Die
Werte müssen einfache Funktionen von anderen Werten der gleichen Zeile sein. In diesen Fällen können
Sie eine ungebundene Spalte verwenden und den entsprechenden Wert mit diesem Ereignis bereitstellen.
Zum Beispiel, der nachfolgende Quellcode bindet die Tabelle an eine Datenquelle und fügt anschließend
eine ungebundene Spalte mit zusätzlichen Daten, die nicht in der Datenbank gespeichert sind, hinzu:
• Visual Basic
Private Sub Form1_Load(ByVal sender As System.Object,
ByVal e As System.EventArgs) Handles MyBase.Load
' load table from db
Dim dt As DataTable = GetProductDataTable()

• C#
End Sub
' bind to grid
_flex.Cols(0).Width = 20
_flex.ShowCursor = True
_flex.DataSource = dt
' add unbound column
Dim col As Column = _flex.Cols.Add()
col.Name = col.Caption = "Unbound"
' keep unbound values in a hashtable
Dim _hash As New Hashtable()
Private Sub _flex_GetUnboundValue(ByVal sender As Object, _
ByVal e As C1.Win.C1FlexGrid.UnboundValueEventArgs) _
Handles _flex.GetUnboundValue
Dim drv As DataRowView = _flex.Rows(e.Row).DataSource
e.Value = _hash(drv("ProductID"))
End Sub
GetUnboundValue-Ereignis · 257
Private Sub _flex_SetUnboundValue(ByVal sender As Object, _
ByVal e As C1.Win.C1FlexGrid.UnboundValueEventArgs) _
Handles _flex.SetUnboundValue
Dim drv As DataRowView = _flex.Rows(e.Row).DataSource
_hash(drv("ProductID")) = e.Value
End Sub
End Sub
private void Form1_Load(object sender, System.EventArgs e)
{
// load table from db
DataTable dt = GetProductDataTable();
}
// bind to grid
_flex.Cols[0].Width = 20;
_flex.ShowCursor = true;
_flex.DataSource = dt;
// add unbound column
Column col = _flex.Cols.Add();
col.Name = col.Caption = "Unbound";
// keep unbound values in a hashtable
Hashtable _hash = new Hashtable();
// get value from hashtable using ProductID as key
private void _flex_GetUnboundValue(object sender,
C1.Win.C1FlexGrid.UnboundValueEventArgs e)
{
DataRowView drv = (DataRowView)_flex.Rows[e.Row].DataSource;
e.Value = _hash[drv["ProductID"]];
}
// store value in hashtable using ProductID as key
private void _flex_SetUnboundValue(object sender,
C1.Win.C1FlexGrid.UnboundValueEventArgs e)
{
DataRowView drv = (DataRowView)_flex.Rows[e.Row].DataSource;
_hash[drv["ProductID"]] = e.Value;
}

258 · C1FlexGrid-Referenzverzeichnis
• Delphi
TWinForm1 = class(TWinForm)
private
// keep unbound values in a hashtable
Fhash: Hashtable;
end;
constructor TWinForm.Create;
begin
inherited Create;
//
// Required for Windows Form Designer support
//
InitializeComponent;
//
Fhash := Hashtable.Create;
end;
procedure TWinForm1.TWinForm_Load(sender: System.Object; e:
System.EventArgs);
var dt: DataTable;
col: Column;
begin
// load table from db
dt := GetProductDataTable;
// bind to grid
_flex.Cols[0].Width := 20;
_flex.ShowCursor := true;
_flex.DataSource := dt;
// add unbound column
col := _flex.Cols.Add;
col.Name := ‘Unbound’;
col.Caption := col.Name;
end;
// get value from hashtable using ProductID as key
procedure TWinForm1._flex_GetUnboundValue(sender: System.Object; e:
C1.Win.C1FlexGrid.UnboundValueEventArgs);
var drv: DataRowView;
begin
drv := DataRowView(_flex.Rows[e.Row].DataSource);
e.Value := Fhash[drv[‘ProductID’]];
end;
// store value in hashtable using ProductID as key
procedure TWinForm1._flex_SetUnboundValue(sender: System.Object; e:
C1.Win.C1FlexGrid.UnboundValueEventArgs);
var drv: DataRowView;
begin
drv := DataRowView(_flex.Rows[e.Row].DataSource);
Fhash[drv[‘ProductID’]] := e.Value;
end;
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)

GridChanged-Ereignis
Wird gestartet, wenn sich die Tabelle auf irgendeine Weise verändert.
Syntax
[VB]
Public Event GridChanged(sender As Object, e As GridChangedEventArgs) As
GridChangedEventHandler
[C#]
public event GridChangedEventHandler GridChanged
[Delphi]
property GridChanged: GridChangedEventHandler;
Ereignisdaten
GridChanged-Ereignis · 259
Der Ereignisabwickler erhält ein Argument vom Typ GridChangedEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int r1, c1, r2, c2 Der Zellbereich, der von dem Ereignis betroffen ist. Der Wert beträgt -1 für
Ereignisse, die die gesamte Tabelle betreffen.
GridChangedTypeEnum
GridChangedType
Bemerkungen
Der Typ der Änderung, der dieses Ereignis ausgelöst hat.
Dieses Ereignis wird zusätzlich zu spezifischeren Ereignissen gestartet. Zum Beispiel, wenn ein Nutzer
eine Spalte mit der Maus verschiebt, dann startet die Steuerung die Ereignisse BeforeDragColumn,
GridChanged und AfterDragColumn.
Das GridChanged-Ereignis stellt einen generischen, zentralisierten Abwickler für alle Typen der
Tabellenereignisse zur Verfügung. Es enthält für die Ereignisse allerdings keine detaillierteren
Argumente oder Optionen zum Abbruch von irgendwelchen Maßnahmen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
GridError-Ereignis
Wird gestartet, wenn die Tabelle eine Fehlerbedingung aufspürt.
Syntax
[VB]
Public Event GridError(sender As Object, e As GridErrorEventArgs) As GridErrorEventHandler

260 · C1FlexGrid-Referenzverzeichnis
[C#]
public event GridErrorEventHandler GridError
[Delphi]
property GridError: GridErrorEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ GridErrorEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int row, col Die Zelle, in der die Fehlerbedingung gefunden wurde.
Exception exception Die Beschreibung des gefundenen Fehlers.
bool handled Ob der Fehler behandelt wurde und die Tabelle ihn ignorieren kann. Wenn
dieser Parameter auf FALSE steht, dann stellt die Tabelle den Einwand in
den exception-Parameter.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
KeyDownEdit-Ereignis
Wird gestartet, wenn der Nutzer eine Taste im Zellbearbeitungsmodus drückt.
Syntax
[VB]
Public Event KeyDownEdit(sender As Object, e As KeyEditEventArgs) As KeyEditEventHandler
[C#]
public event KeyEditEventHandler KeyDownEdit
[Delphi]
property KeyDownEdit: KeyEditEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ KeyEditEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int Row Die Zeile, in der die aktuelle Zelle platziert ist.
int Col Die Spalte, in der die aktuelle Zelle platziert ist.
Keys KeyCode ASCII-Code für die gedrückte Taste.
bool Shift Bestimmt, ob die Strg-Taste gedrückt war.

Bemerkungen
KeyPressEdit-Ereignis · 261
Dieses Ereignis ist dem standard KeyDown-Ereignis ähnlich, wird aber nur gestartet, wenn sich die
Tabelle im Bearbeitungsmodus befindet.
Der Editor besitzt drei Modi: Text, Auswahlkombinationsliste oder Auswahlliste. Der verwendete Modus
wird durch die ComboList-Eigenschaften der Tabellen- und Spaltenobjekte festgelegt.
Während der Bearbeitung mit dem Texteditor oder dem Auswahlkombinationsfeld, können Sie die
Inhalte des Editors mit der Editor-Eigenschaft in der Editorsteuerung setzen und abfragen und diese in
den richtigen Typ umwandeln. Zum Beispiel, der nachfolgende Quellcode ruft die Inhalte der Auswahl
in der Editorsteuerung ab:
• Visual Basic
• C#
Dim selText As String = ""
Dim ctl As Control = flex.Editor
If TypeOf ctl Is TextBox Then
selText = CType(ctl, TextBox).SelectedText
End If
If TypeOf ctl Is ComboBox Then
selText = CType(ctl, ComboBox).SelectedText
End If
string selText = "";
Control ctl = flex.Editor
if (ctl is TextBox) selText = ((TextBox)ctl).SelectedText;
if (ctl is ComboBox) selText = ((ComboBox)ctl).SelectedText;
• Delphi
var
ctl: Control;
selText: string;
begin
selText := '';
ctl := flex.Editor;
if (ctl is TextBox) then selText := TextBox(ctl).SelectedText;
if (ctl is ComboBox) then selText := ComboBox(ctl).SelectedText;
end;
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
KeyPressEdit-Ereignis
Wird gestartet, wenn der Nutzer eine Taste im Zellbearbeitungsmodus drückt.
Syntax
[VB]
Public Event KeyPressEdit(sender As Object, e As KeyPressEditEventArgs) As
KeyPressEditEventHandler

262 · C1FlexGrid-Referenzverzeichnis
[C#]
public event KeyPressEditEventHandler KeyPressEdit
[Delphi]
property KeyPressEdit: KeyPressEditEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ KeyPressEditEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int Row Die Zeile, in der die aktuelle Zelle platziert ist.
int Col Die Spalte, in der die aktuelle Zelle platziert ist.
char KeyChar Die Taste, die der Nutzer gedrückt hat.
bool Handled Bestimmt, ob der Tastendruck verarbeitet wurde.
Bemerkungen
Dieses Ereignis ist dem standard KeyDown-Ereignis ähnlich, wird aber nur gestartet, wenn sich die
Tabelle im Bearbeitungsmodus befindet.
Der Editor besitzt drei Modi: Text, Auswahlkombinationsliste oder Auswahlliste. Der verwendete Modus
wird durch die ComboList-Eigenschaften der Tabellen- und Spaltenobjekte festgelegt.
Während der Bearbeitung mit dem Texteditor oder dem Auswahlkombinationsfeld, können Sie die
Inhalte des Editors mit der Editor-Eigenschaft in der Editorsteuerung setzen und abfragen und diese in
den richtigen Typ umwandeln. Zum Beispiel, der nachfolgende Quellcode ruft die Inhalte der Auswahl
in der Editorsteuerung ab:
• Visual Basic
• C#
Dim selText As String = ""
Dim ctl As Control = flex.Editor
If TypeOf ctl Is TextBox Then
selText = CType(ctl, TextBox).SelectedText
End If
If TypeOf ctl Is ComboBox Then
selText = CType(ctl, ComboBox).SelectedText
End If
string selText = "";
Control ctl = flex.Editor
if (ctl is TextBox) selText = ((TextBox)ctl).SelectedText;
if (ctl is ComboBox) selText = ((ComboBox)ctl).SelectedText;
• Delphi
var
ctl: Control;
selText: string;
begin

KeyUpEdit-Ereignis · 263
selText := '';
ctl := flex.Editor;
if (ctl is TextBox) then selText := TextBox(ctl).SelectedText;
if (ctl is ComboBox) then selText := ComboBox(ctl).SelectedText;
end;
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
KeyUpEdit-Ereignis
Wird gestartet, wenn der Nutzer eine Taste im Zellbearbeitungsmodus drückt.
Syntax
[VB]
Public Event KeyUpEdit(sender As Object, e As KeyEditEventArgs) As KeyEditEventHandler
[C#]
public event KeyEditEventHandler KeyUpEdit
[Delphi]
property KeyUpEdit: KeyEditEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ KeyEditEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int Row Die Zeile, in der die aktuelle Zelle platziert ist.
int Col Die Spalte, in der die aktuelle Zelle platziert ist.
Keys KeyCode ASCII-Code für die gedrückte Taste.
bool Shift Bestimmt, ob die Strg-Taste gedrückt war.
Bemerkungen
Dieses Ereignis ist dem Standard KeyDown-Ereignis ähnlich, wird aber nur gestartet, wenn sich die
Tabelle im Bearbeitungsmodus befindet.
Der Editor besitzt drei Modi: Text, Auswahlkombinationsliste oder Auswahlliste. Der verwendete Modus
wird durch die ComboList-Eigenschaften der Tabellen- und Spaltenobjekte festgelegt.
Während der Bearbeitung mit dem Texteditor oder dem Auswahlkombinationsfeld, können Sie die
Inhalte des Editors mit der Editor-Eigenschaft in der Editorsteuerung setzen und abfragen, und diese in
den richtigen Typ umwandeln. Zum Beispiel, der nachfolgende Quellcode ruft die Inhalte der Auswahl
in der Editorsteuerung ab:
• Visual Basic
Dim selText As String = ""
Dim ctl As Control = flex.Editor
If TypeOf ctl Is TextBox Then

264 · C1FlexGrid-Referenzverzeichnis
• C#
selText = CType(ctl, TextBox).SelectedText
End If
If TypeOf ctl Is ComboBox Then
selText = CType(ctl, ComboBox).SelectedText
End If
string selText = "";
Control ctl = flex.Editor
if (ctl is TextBox) selText = ((TextBox)ctl).SelectedText;
if (ctl is ComboBox) selText = ((ComboBox)ctl).SelectedText;
• Delphi
var
ctl: Control;
selText: string;
begin
selText := '';
ctl := flex.Editor;
if ctl is TextBox then
selText := TextBox(ctl).SelectedText;
if ctl is ComboBox then
selText := ComboBox(ctl).SelectedText;
end;
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
LeaveCell-Ereignis
Wird gestartet, bevor die aktuelle Zelle eine andere wird.
Syntax
[VB]
Public Event LeaveCell(sender As Object, e As EventArgs) As EventHandler
[C#]
public event EventHandler LeaveCell
[Delphi]
property LeaveCell: EventHandler;
Ereignisdaten
Keine Parameter.
Bemerkungen
Dieses Ereignis wird gestartet, bevor der Cursor die aktuelle Zelle verlässt, entweder durch die
Maus/Tastatur, oder wenn die aktuelle Auswahl durch Programmcode verändert wurde.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)

MouseHoverCell-Ereignis
Wird gestartet, wenn der Mauszeiger über eine Zelle fährt.
Syntax
[VB]
Public Event MouseHoverCell(ByVal sender As Object, ByVal e As System.EventArgs) As
System.EventHandler
[C#]
public event EventHandler MouseHoverCell
[Delphi]
property MouseHoverCell: EventHandler;
Ereignisdaten
Keine Parameter.
Schauen Sie ferner unter
C1FlexGrid-Klasse
OwnerDrawCell-Ereignis
MouseHoverCell-Ereignis · 265
Wird gestartet, bevor die Tabelle eine Zelle zeichnet und die DrawMode-Eigenschaft auf OwnerDraw
steht.
Syntax
[VB]
Public Event OwnerDrawCell(sender As Object, e As OwnerDrawCellEventArgs) As
OwnerDrawCellEventHandler
[C#]
public event OwnerDrawCellEventHandler OwnerDrawCell
[Delphi]
property OwnerDrawCell: OwnerDrawCellEventHandler;
Event Data
Der Ereignisabwickler erhält ein Argument vom Typ OwnerDrawCellEventArgs, welches die mit
diesem Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int Row, Col Ermittelt die Koordinaten der zu zeichnenden Zelle.
Graphics Graphics Ermittelt die zu verwendende grafische Oberfläche, um die Zelle zu
zeichnen.
Rectangle Bounds Ermittelt das Rechteck, wo die Zelle gezeichnet wird.

266 · C1FlexGrid-Referenzverzeichnis
Eigenschaft Beschreibung
string Text Ermittelt oder legt den Text fest, der in der Zelle angezeigt wird.
Image Image Ermittelt oder legt die Grafik fest, die in der Zelle angezeigt wird.
CellStyle Style Legt das zu verwendende CellStyle-Objekt fest, mit dem die Zelle
gezeichnet wird.
void DrawCell(DrawCellFlags flags) Veranlasst die Tabelle, Teile der Zelle zu zeichnen (Hintergrund,
Vordergrund, Rahmen, usw.).
void DrawCell() Veranlasst die Tabelle, die gesamte Zelle zu zeichnen.
bool Handled Ermittelt oder legt fest, ob das Ereignis das Zeichnen der Zelle
abgeschlossen hat.
bool Measuring Ermittelt einen Wert, der festlegt, ob das Ereignis nur aufgerufen wurde,
um eine Zelle auszumessen. Dies geschieht während die Größe von
Zeilen und Spalten automatisch angepasst wird.
Bemerkungen
Das OwnerDrawCell-Ereignis wird nur gestartet, wenn die DrawMode-Eigenschaft auf OwnerDraw
steht.
Sie können dieses Ereignis verwenden, um das Format einer jeden Zelle in der Tabelle anzupassen. Das
Ereignis stellt drei Haupttypen der Anpassung zur Verfügung:
1. Ändert die Text und Image-Parameter, um die Werte zu verändern, die von der Tabelle angezeigt
werden. Sie können diesen Typ der Anpassung verwenden, um zum Beispiel Passwörter durch
Sternzeichen („*“) zu ersetzen.
2. Ändert die Style-Eigenschaft, um die Zelle in einem anderen, als dem von der Tabelle festgelgtem
Standardformat, anzuzeigen. Sie können diesen Typ der Anpassung verwenden, um zum
Beispiel bedingte Formatierung zur Verfügung zu stellen.
3. Verwenden Sie die Graphics und Bounds-Parameter und zeichnen Sie die Zelle selbst. Wenn
Zellen auf diesem Weg gezeichnet werden, dann können Sie die DrawCell-Member aufrufen, um
die Tabelle zu zwingen, einige Teile der Zelle zu zeichnen, während ihr Quellcode andere Teile
zeichnet. Zum Beispiel, der nachfolgende Quellcode zeichnet eine Zelle mit einem Farbübergang
als Hintergrund:
• Visual Basic
' use owner-draw to add gradients
fg.DrawMode = DrawModeEnum.OwnerDraw
Private Sub fg_OwnerDrawCell(ByVal sender As Object, _
ByVal e As OwnerDrawCellEventArgs) Handles fg.OwnerDrawCell
' draw selected cell background using gradient brush
If fg.Selection.Contains(e.Row, e.Col) Then
e.Graphics.FillRectangle(m_GradientBrush, e.Bounds) ' draw
background
e.DrawCell(DrawCellFlags.Content) ' let the grid draw the
content
e.Handled = True ' we're done drawing this cell
End If

• C#
End Sub
// use owner-draw to add gradients
fg.DrawMode = DrawModeEnum.OwnerDraw;
private void fg_OwnerDrawCell( object sender,
OwnerDrawCellEventArgs e) fg.OwnerDrawCell {
OwnerDrawCell-Ereignis · 267
// draw selected cell background using gradient brush
if ( fg.Selection.Contains(e.Row, e.Col) ) {
e.Graphics.FillRectangle(m_GradientBrush, e.Bounds); // draw
background
e.DrawCell(DrawCellFlags.Content); // let the grid draw the
content
e.Handled = true; // we're done drawing this cell
}
}
• Delphi
' use owner-draw to add gradients
fg.DrawMode := DrawModeEnum.OwnerDraw;
procedure fg_OwnerDrawCell(sender: System.Object;
e: OwnerDrawCellEventArgs);
begin
// draw selected cell background using gradient brush
If fg.Selection.Contains(e.Row, e.Col) Then
begin
e.Graphics.FillRectangle(m_GradientBrush, e.Bounds); // draw
background
e.DrawCell(DrawCellFlags.Content); // let the grid draw the
content
e.Handled := True; // we're done drawing this cell
end;
end;
Das OwnerDrawCell-Ereignis wird auch gestartet, wenn die Tabelle die Größen der Zeilen und Spalten
automatisch anpasst (Siehe AutoSizeRows- und AutoSizeCols-Methoden). Dies wird getan, weil die
Tabelle die Zellen mit den selben text-, image- und style-Parametern ausmessen muss, die auch dazu
verwendet werden, die Zelle zu rendern. In diesen Fällen ist der Measuring-Parameter auf TRUE gesetzt
und das Bounds-Rechteck ist leer.
Beispiel
Dieses Beispiel zeichnet die Zellen wie üblich, und markiert die ersten zwei Zeichen in einer Zelle. Der
Quellcode beginnt damit, die Zeichenkette auszumessen und berücksichtigt dabei den Zellrahmen. Dann
wird die DrawCell-Methode verwendet, um den Hintergrund der Zelle, ein markiertes Rechteck und
schlussendlich den Zellinhalt und den Rahmen zu zeichnen:
• Visual Basic
Private Sub _flex_OwnerDrawCell(sender As Object, e As
OwnerDrawCellEventArgs)
' highlight all but the first two characters
Dim txt As String = _flex.GetDataDisplay(e.Row, e.Col)
If txt.Length < 2 Then
Return
End If
txt = txt.Substring(2)

268 · C1FlexGrid-Referenzverzeichnis
• C#
' measure the width of the highlight
Dim g As Graphics = e.Graphics
Dim wid As Integer = CInt(g.MeasureString(txt, e.Style.Font).Width)
wid += e.Style.Margins.Right
wid += e.Style.Border.Width - 1
' build the highlight rect
Dim rc As Rectangle = e.Bounds
rc.X = rc.Right - wid
rc.Width = wid
' draw background, highlight, draw content
e.DrawCell(DrawCellFlags.Background)
g.FillRectangle(Brushes.LightYellow, rc)
e.DrawCell((DrawCellFlags.Border Or DrawCellFlags.Content))
End Sub '_flex_OwnerDrawCell
private void _flex_OwnerDrawCell(object sender, OwnerDrawCellEventArgs
e)
{
// highlight all but the first two characters
string txt = _flex.GetDataDisplay(e.Row, e.Col);
if (txt.Length < 2) return;
txt = txt.Substring(2);
}
• Delphi
// measure the width of the highlight
Graphics g = e.Graphics;
int wid = (int)g.MeasureString(txt, e.Style.Font).Width;
wid += e.Style.Margins.Right;
wid += e.Style.Border.Width - 1;
// build the highlight rect
Rectangle rc = e.Bounds;
rc.X = rc.Right - wid;
rc.Width = wid;
// draw background, highlight, draw content
e.DrawCell(DrawCellFlags.Background);
g.FillRectangle(Brushes.LightYellow, rc);
e.DrawCell(DrawCellFlags.Border | DrawCellFlags.Content);
procedure_flex_OwnerDrawCell(sender: System.Object; e:
OwnerDrawCellEventArgs)
var
txt: string;
g: Graphics;
wid: Integer;
rc: Rectangle;
begin
// highlight all but the first two characters
txt := _flex.GetDataDisplay(e.Row, e.Col);
If txt.Length < 2 Then
exit;
txt := txt.Substring(2);
// measure the width of the highlight
g := e.Graphics;
wid := Round(g.MeasureString(txt, e.Style.Font).Width);
wid := wid + e.Style.Margins.Right;

wid := wid + e.Style.Border.Width – 1;
// build the highlight rect
rc := e.Bounds;
rc.X := rc.Right – wid;
rc.Width := wid;
// draw background, highlight, draw content
e.DrawCell(DrawCellFlags.Background);
g.FillRectangle(Brushes.LightYellow, rc);
e.DrawCell(DrawCellFlags.Border Or DrawCellFlags.Content);
end; //_flex_OwnerDrawCell
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
PrintPage-Ereignis
Wird gestartet, wenn die Tabelle den Druckvorgang für eine Seite beendet hat.
Syntax
[VB]
PrintPage-Ereignis · 269
Public Event PrintPage(sender As Object, e As PrintPageEventArgs) As PrintPageEventHandler
[C#]
public event PrintPageEventHandler PrintPage
[Delphi]
property PrintPage: PrintPageEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ PrintEventHandler, welcher im
System.Drawing.Printing-Namensbereich definiert ist.
Bemerkungen
Verwenden Sie die PrintGrid-Methode, um die Tabelle zu drucken und um den Dokumentennamen,
allgemeine Druckoptionen, Kopf- und Fußzeilen festzulegen. Verwenden Sie hingegen die
PrintParameters-Eigenschaft um weniger allgemeine Druckoptionen, wie z.B. Kopf- und
Fußzeilenschriftart, Seitenränder und Ausrichtung, festzulegen.
Mit diesem Ereignis können Sie benutzerdefinierte Grafiken zu einer gedruckten Seite hinzufügen oder
den Druckprozess abbrechen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
RowColChange-Ereignis
Wird gestartet, bevor die aktuelle Zelle (Row, Col) eine andere wird.

270 · C1FlexGrid-Referenzverzeichnis
Syntax
[VB]
Public Event RowColChange(sender As Object, e As EventArgs) As EventHandler
[C#]
public event EventHandler RowColChange
[Delphi]
property RowColChange: EventHandler;
Ereignisdaten
Keine Parameter
Bemerkungen
RowColChange wird nur gestartet, wenn sich die Row- und Col-Eigenschaften, entweder durch den
Nutzer mit Maus/Tastatur, oder durch Programmcode, ändern. Es wird nicht gestartet, wenn sich zwar
die Auswahl (RowSel- oder ColSel-Eigenschaften) ändert, die aktive Zelle (Row, Col) aber gleich bleibt.
In diesem Fall wird stattdessen das SelChange-Ereignis gestartet.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
SelChange-Ereignis
Wird gestartet, nachdem sich die Auswahl (RowSel, ColSel) geändert hat.
Syntax
[VB]
Public Event SelChange(sender As Object, e As EventArgs) As EventHandler
[C#]
public event EventHandler SelChange
[Delphi]
property SelChange: EventHandler;
Ereignisdaten
Keine Parameter
Bemerkungen
SelChange wird nur gestartet, wenn sich die Row-, Col-, RowSel- oder ColSel-Eigenschaften, entweder
durch den Nutzer mit Maus/Tastatur, oder durch Programmcode, ändern. Es wird auch gestartet, wenn
der Nutzer die Auswahl mit der Maus erweitert.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)

SetUnboundValue-Ereignis
SetUnboundValue-Ereignis · 271
Wird gestartet, wenn die Tabelle gebunden ist und einen Wert in einer ungebundenen Spalte setzt.
Syntax
[VB]
Public Event SetUnboundValue(sender As Object, e As EventArgs) As UnboundValueEventHandler
[C#]
public event UnboundValueEventHandler SetUnboundValue
[Delphi]
property SetUnboundValue: UnboundValueEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ UnboundValueEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int Row, Col Die ungebundene Zelle, die den Wert enthält.
object Value
Bemerkungen
Der Wert der ungebundenen Zelle. Der Ereignisabwickler sollte diesen
Wert der Zelle zuordnen.
Dieses Ereignis wird nur im gebundenen Modus gestartet, wenn die Tabelle ungebundene Spalten
enthält. Ungebundene Spalten verknüpfen ihre Werte nicht mit der Datenquelle. Sie können, auf
gebundene Spalten basierende Informationen berechnen oder andere Information enthalten, die in der
Tabelle durch die Anwendung zur Verfügung gestellt werden.
In den meisten Fällen können ungebundene Spalten nur gelesen werden, so dass Sie dieses Ereignis nicht
abfangen müssen. Wenn dennoch ein Wert entweder durch Bearbeitung oder durch Quellcode in einer
ungebundenen Zelle steht, dann startet die Tabelle dieses Ereignis, damit die Anwendung den Wert mit
dem entsprechendem Mechanismus speichern kann.
Schauen Sie im GetUnboundValue-Ereignis für ein Beispiel nach.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
SetupEditor-Ereignis
Wird gestartet, nachdem der integrierte Editor initialisiert wurde, aber bevor dieser angezeigt wird.
Syntax
[VB]
Public Event SetupEditor(sender As Object, e As RowColEventArgs) As RowColEventHandler

272 · C1FlexGrid-Referenzverzeichnis
[C#]
public event RowColEventHandler SetupEditor
[Delphi]
property SetupEditor: RowColEventHandler;
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int row, col Die Koordinaten der Zelle, die gleich bearbeitet wird.
Bemerkungen
Die Tabelle initialisiert den Editor je nach Format der Zelle, die bearbeitet werden soll. Standardmäßig
hat der Editor die gleiche Schriftart, Hintergrundfarbe, Ausrichtung, usw. wie die entsprechende Zelle.
Sie können das SetupEditor-Ereignis verwenden, um dieses Verhalten zu ändern und das Aussehen des
Editors anzupassen.
Beispiel
Der nachfolgende Quellcode formatiert die Schrift des Editors fett, fügt einen gelben Hintergrund ein
und legt die maximale Länge der Eingabe auf vier Zeichen fest:
• Visual Basic
• C#
Private Sub flex_SetupEditor(sender As Object, e As RowColEventArgs)
Dim ctl As Control = flex.Editor
ctl.Font = New Font(ctl.Font, FontStyle.Bold)
ctl.BackColor = Color.Yellow
If TypeOf ctl Is TextBox Then
CType(ctl, TextBox).MaxLength = 4
End If
End Sub 'flex_SetupEditor
private void flex_SetupEditor(object sender, RowColEventArgs e)
{
Control ctl = flex.Editor;
ctl.Font = new Font(ctl.Font, FontStyle.Bold);
ctl.BackColor = Color.Yellow;
if (ctl is TextBox) ((TextBox)ctl).MaxLength = 4;
}
• Delphi
procedure Class1.flex_SetupEditor(sender: System.Object; e:
RowColEventArgs);
var
ctl: Control;
begin
ctl := flex.Editor;
ctl.Font := Font.Create(ctl.Font, FontStyle.Bold);
ctl.BackColor := Color.Yellow;

if (ctl is TextBox) then TextBox(tl).MaxLength := 4;
end;
Dies ist ein etwas komplizierteres Beispiel, welches das SetupEditor-Ereignis verwendet, um
Ereignisabwickler für den Editor zu installieren:
• Visual Basic
• C#
SetupEditor-Ereignis · 273
' ** initialize and hook up event handlers for the grid editors
Private Sub flex_SetupEditor(sender As Object, e As RowColEventArgs)
' set up the grid's combo box
Dim cb As ComboBox = flex.Editor '
If Not (cb Is Nothing) Then
' make this a real combo, even if we're using a DataMap
cb.DropDownStyle = ComboBoxStyle.DropDown
' hook up combo event
cb.SelectedIndexChanged -= New
System.EventHandler(fe_SelectedValueChanged)
AddHandler cb.SelectedIndexChanged, AddressOf
fe_SelectedValueChanged
' hook up textbox event
cb.TextChanged -= New
System.EventHandler(fe_SelectedValueChanged)
AddHandler cb.TextChanged, AddressOf fe_SelectedValueChanged
End If
' set up the grid's text box
Dim tb As TextBox = flex.Editor '
If Not (tb Is Nothing) Then
tb.TextChanged -= New
System.EventHandler(fe_SelectedValueChanged)
AddHandler tb.TextChanged, AddressOf fe_SelectedValueChanged
End If
End Sub 'flex_SetupEditor
' ** event handlers for the grid editors
Private Sub fe_SelectedValueChanged(sender As Object, e As
System.EventArgs)
Console.WriteLine(("editor value changed to " + _flex.Editor.Text))
End Sub 'fe_SelectedValueChanged
// ** initialize and hook up event handlers for the grid editors
private void flex_SetupEditor(object sender, RowColEventArgs e)
{
// set up the grid's combo box
ComboBox cb = flex.Editor as ComboBox;
if (cb != null)
{
// make this a real combo, even if we're using a DataMap
cb.DropDownStyle = ComboBoxStyle.DropDown;
// hook up combo event
cb.SelectedIndexChanged -= new
System.EventHandler(fe_SelectedValueChanged);
cb.SelectedIndexChanged += new
System.EventHandler(fe_SelectedValueChanged);
// hook up textbox event
cb.TextChanged -= new System.EventHandler(fe_SelectedValueChanged);
cb.TextChanged += new System.EventHandler(fe_SelectedValueChanged);

274 · C1FlexGrid-Referenzverzeichnis
}
// set up the grid's text box
TextBox tb = flex.Editor as TextBox;
if (tb != null)
{
tb.TextChanged -= new System.EventHandler(fe_SelectedValueChanged);
tb.TextChanged += new System.EventHandler(fe_SelectedValueChanged);
}
}
// ** event handlers for the grid editors
private void fe_SelectedValueChanged(object sender, System.EventArgs e)
{
Console.WriteLine("editor value changed to " + _flex.Editor.Text);
}
• Delphi
// ** initialize and hook up event handlers for the grid editors
procedure flex_SetupEditor(sender: System.Object; e: RowColEventArgs);
var
cb: ComboBox;
tb: TextBox;
begin
// set up the grid's combo box
if cb Is ComboBox then
begin
cb := ComboBox(flex.Editor);
// make this a real combo, even if we're using a DataMap
cb.DropDownStyle := ComboBoxStyle.DropDown;
// hook up combo event
Exclude(cb.SelectedIndexChanged, fe_SelectedValueChanged);
Include(cb.SelectedIndexChanged, fe_SelectedValueChanged);
// hook up textbox event
Exclude(cb.TextChanged, fe_SelectedValueChanged);
Include(cb.TextChanged, fe_SelectedValueChanged);
End;
// set up the grid's text box
if tb Is TextBox then
begin
tb := TextBox(flex.Editor);
Exclude(tb.TextChanged, fe_SelectedValueChanged);
Include(tb.TextChanged, fe_SelectedValueChanged);
end;
end; // flex_SetupEditor
// ** event handlers for the grid editors
procedure fe_SelectedValueChanged(sender: System.Object; e:
System.EventArgs);
Console.WriteLine('editor value changed to ' + _flex.Editor.Text);
end; // fe_SelectedValueChanged
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
StartEdit-Ereignis
Wird gestartet, wenn die Steuerung in den Zellbearbeitungsmodus übergeht (nach BeforeEdit).

Syntax
[VB]
Public Event StartEdit(sender As Object, e As RowColEventArgs) As RowColEventHandler
[C#]
public event RowColEventHandler StartEdit
[Delphi]
property StartEdit: RowColEventHandler;
Ereignisdaten
ValidateEdit-Ereignis · 275
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int row, col Die Koordinaten der Zelle, die gleich bearbeitet wird.
bool Cancel Legt fest, ob die Bearbeitung abgebrochen wird.
Bemerkungen
Dieses Ereignis wird gestartet, bevor die Steuerung in den Bearbeitungsmodus versetzt wird. Sie können
die Bearbeitung verhindern, indem Sie den Cancel-Parameter auf TRUE setzen, oder mit der ComboList-
Eigenschaft eine Auswahlliste an möglichen Elementen oder mit der EditMask-Eigenschaft eine
Eingabemaske zur Verfügung stellen.
Wenn die Auswahl oder die Eingabemaske für die gesamte Spalte gleich ist, dann können Sie auch die
entsprechenden Eigenschaften (AllowEdit, ComboList und EditMask) des Column-Objekts setzen, so
dass Sie das StartEdit-Ereignis nicht abfangen müssen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
ValidateEdit-Ereignis
Wird gestartet, wenn die Steuerung den Zellbearbeitungsmodus verlässt.
Syntax
[VB]
Public Event ValidateEdit(sender As Object, e As ValidateEditEventArgs) As ValidateEditEventHandler
[C#]
public event ValidateEditEventHandler ValidateEdit
[Delphi]
property ValidateEdit: ValidateEditEventHandler;

276 · C1FlexGrid-Referenzverzeichnis
Ereignisdaten
Der Ereignisabwickler erhält ein Argument vom Typ ValidateEditEventArgs, welches die mit diesem
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung
int row, col Die Koordinaten der Zelle, die bearbeitet wird.
CheckEnum
Checkbox
bool Cancel
Bemerkungen
Wenn die Zelle ein Kontrollkästchen beinhaltet, dann enthält dieser Parameter
dessen Zustand, welcher der Zelle zugeordnet wird. Wenn die Zelle kein
Kontrollkästchen enthält, dann steht dieser Parameter auf CheckEnum.None.
Setzen Sie diesen Parameter auf TRUE, um die Bearbeitungen abzubrechen,
wenn der Wert im Editor für die Zelle ungültig ist.
Das ValidateEdit-Ereignis wird gestartet, bevor die Änderungen in der Zelle gespeichert werden. Der
Ereigniscode sollte den Wert der Editor.Text-Eigenschaft überprüfen. Wenn dieser Wert ungültig ist,
dann muss die Cancel-Parameter auf TRUE gesetzt werden, so dass die Tabelle im Bearbeitungsmodus
verweilt, bis der Nutzer einen gültigen Wert eingegeben hat.
Zum Beispiel der nachfolgende Quellcode prüft die Eingabe in einer Währungsspalte um sicherzustellen,
dass die eingegebenen Werte zwischen 1.000 und 10.000 liegen:
• Visual Basic
• C#
Private Sub fg_ValidateEdit(ByVal sender As Object, _
ByVal e As ValidateEditEventArgs) Handles fg.ValidateEdit
' validate amounts
If fg.Cols(e.Col).DataType Is GetType(Decimal) Then
10,000")
Try
End If
End Sub
Dim dec As Decimal = Decimal.Parse(fg.Editor.Text())
If dec < 1000 Or dec > 10000 Then
MessageBox.Show("Value must be between 1,000 and
e.Cancel = True
End If
Catch
MessageBox.Show("Value not recognized as a Currency")
e.Cancel = True
End Try
private void fg_ValidateEdit( object sender, ValidateEditEventArgs e)
{
// validate amounts
if ( fg.Cols[e.Col].DataType == typeof(Decimal) ) {
try {
Decimal dec = Decimal.Parse(fg.Editor.Text());
if ( dec < 1000 || dec > 10000 ) {

BeforeMouseDownEventHandler-Delegierer · 277
MessageBox.Show("value must be between 1,000 and
10,000");
e.Cancel = true;
}
} catch {
MessageBox.Show("value not recognized as a Currency");
e.Cancel = true;
}
}
}
• Delphi
procedure fg_ValidateEdit(sender: System.Object;
e: ValidateEditEventArgs);
var
dec: Decimal;
begin
// validate amounts
if fg.Cols(e.Col).DataType Is Decimal then
Try
dec := System.Decimal.Parse(fg.Editor.Text());
If (dec < 1000) Or (dec > 10000) Then
begin
MessageBox.Show('Value must be between 1,000 and 10,000');
e.Cancel := True;
end;
except
MessageBox.Show('Value not recognized as a Currency');
e.Cancel = True;
end;
end;
Wenn Sie Zeichen überprüfen wollen, während diese im Editor eingegeben werden, dann müssen Sie die
KeyPressEdit- oder die ChangeEdit-Ereignisse verwenden. Für weitere Einzelheiten über
Zellbearbeitung, schauen Sie unter „Zellen bearbeiten“ (Seite 37 ) nach.
C1FlexGrid-Ereignisabwickler
BeforeMouseDownEventHandler-Delegierer
Syntax
[VB]
Public Delegate Sub BeforeMouseDownEventHandler (object sender, BeforeMouseDownEventArgs e)
[C#]
public delegate BeforeMouseDownEventHandler : MulticastDelegate
[Delphi]
type BeforeMouseDownEventHandler = procedure(sender: System.Object, e:
BeforeMouseDownEventArgs) of object;

278 · C1FlexGrid-Referenzverzeichnis
Argumente
Argument Beschreibung
sender Der Auslöser des Ereignisses.
e Ein BeforeMouseDownEventArgs-Objekt, das die Ereignisdaten beinhaltet.
Schauen Sie ferner unter
BeforeMouseDown-Ereignis (Seite 239)
DragRowColEventHandler-Delegierer
Syntax
[VB]
Public Delegate Sub DragRowColEventHandler (object sender, DragRowColEventArgs e)
[C#]
public sealed delegate DragRowColEventHandler : System.MulticastDelegate
[Delphi]
type DragRowColEventHandler = procedure(sender: System.Object, e: DragRowColEventArgs) of
object;
Argumente
Argument Beschreibung
sender Der Auslöser des Ereignisses.
e Ein DragRowColEventArgs-Objekt, das die Ereignisdaten beinhaltet.
Schauen Sie ferner unter
AfterDragColumn-Ereignis (Seite 220)
AfterDragRow-Ereignis (Seite 221)
BeforeDragColumn-Ereignis (Seite 234)
BeforeDragRow-Ereignis (Seite 235)
GridChangedEventHandler-Delegierer
Syntax
[VB]
Public Delegate Sub GridChangedEventHander (object sender, GridChangedEventArgs e)

[C#]
public sealed delegate GridChangedEventHandler : System.MulticastDelegate
[Delphi]
GridErrorEventHandler-Delegierer · 279
type GridChangedEventHander = procedure(sender: System.Object, e: GridChangedEventArgs) of
object;
Argumente
Argument Beschreibung
sender Der Auslöser des Ereignisses.
e Ein GridChangedEventArgs-Objekt, das die Ereignisdaten beinhaltet.
Schauen Sie ferner unter
GridChanged-Ereignis (Seite 259)
GridErrorEventHandler-Delegierer
Syntax
[VB]
Public Delegate Sub GridErrorEventHander (object sender, GridErrorEventArgs e)
[C#]
public sealed delegate GridErrorEventHandler : System.MulticastDelegate
[Delphi]
type GridErrorEventHandler = procedure(sender: System.Object, e: GridErrorEventArgs) of object;
Argumente
Argument Beschreibung
sender Der Auslöser des Ereignisses.
e Ein GridErrorEventArgs-Objekt, das die Ereignisdaten beinhaltet.
Schauen Sie ferner unter
GridError-Ereignis (Seite 259)
KeyEditEventHandler-Delegierer
Syntax
[VB]
Public Delegate Sub KeyEditEventHandler (object sender, KeyEditEventHandler e)

280 · C1FlexGrid-Referenzverzeichnis
[C#]
public sealed delegate KeyEditEventHandler : System.MulticastDelegate
[Delphi]
type KeyEditEventHandler = procedure(sender: System.Object, e: KeyEditEventHandler) of object;
Argumente
Argument Beschreibung
sender Der Auslöser des Ereignisses.
e Ein KeyEditEventArgs-Objekt, das die Ereignisdaten beinhaltet.
Schauen Sie ferner unter
KeyDownEdit-Ereignis (Seite 260)
KeyUpEdit-Ereignis (Seite 263)
KeyPressEditEventHandler-Delegierer
Syntax
[VB]
Public Delegate Sub KeyPressEditEventHandler (object sender, KeyPressEditEventArgs e)
[C#]
public sealed delegate KeyPressEditEventHandler : System.MulticastDelegate
[Delphi]
type KeyPressEditEventHandler = procedure(sender: System.Object, e: KeyPressEditEventArgs) of
object;
Argumente
Argument Beschreibung
sender Der Auslöser des Ereignisses.
e Ein KeyPressEditEventArgs-Objekt, das die Ereignisdaten beinhaltet.
Schauen Sie ferner unter
KeyPressEdit-Ereignis (Seite 261)

OwnerDrawCellEventHandler-Delegierer
Syntax
[VB]
OwnerDrawCellEventHandler-Delegierer · 281
Public Delegate Sub OwnerDrawCellEventHandler (object sender, OwnerDrawCellEventArgs e)
[C#]
public sealed delegate OwnerDrawCellEventHandler : System.MulticastDelegate
[Delphi]
type OwnerDrawCellEventHandler = procedure(sender: System.Object, e: OwnerDrawCellEventArgs)
of object;
Argumente
Argument Beschreibung
sender Der Auslöser des Ereignisses.
e Ein OwnerDrawCellEventArgs-Objekt, das die Ereignisdaten beinhaltet.
Schauen Sie ferner unter
OwnerDrawCell-Ereignis (Seite 265)
PrintEventHandler-Delegierer
Syntax
[VB]
Public Delegate Sub PrintEventHandler (object sender, PrintEventArgs e)
[C#]
public sealed delegate PrintEventHandler : System.MulticastDelegate
[Delphi]
type PrintEventHandler = procedure(sender: System.Object, e: PrintEventArgs) of object;
Argumente
Argument Beschreibung
sender Der Auslöser des Ereignisses.
e Ein PrintEventArgs-Objekt, das die Ereignisdaten beinhaltet.
Schauen Sie ferner unter
BeginPrint-Ereignis (Seite 247)

282 · C1FlexGrid-Referenzverzeichnis
EndPrint-Ereignis (Seite 253)
PrintPageEventHandler-Delegierer
Syntax
[VB]
Public Delegate Sub PrintPageEventHandler (object sender, PrintPageEventArgs e)
[C#]
public sealed delegate PrintPageEventHandler : System.MulticastDelegate
[Delphi]
type PrintPageEventHandler = procedure(sender: System.Object, e: PrintPageEventArgs) of object;
Argumente
Argument Beschreibung
sender Der Auslöser des Ereignisses.
e Ein PrintPageEventArgs-Objekt, das die Ereignisdaten beinhaltet.
Schauen Sie ferner unter
PrintPage-Ereignis (Seite 269)
RangeEventHandler-Delegierer
Syntax
[VB]
Public Delegate Sub RangeEventHandler (object sender, RangeEventArgs e)
[C#]
public sealed delegate RangeEventHandler : System.MulticastDelegate
[Delphi]
type RangeEventHandler = procedure(sender: System.Object, e: RangeEventArgs) of object;
Argumente
Argument Beschreibung
sender Der Auslöser des Ereignisses.
e Ein RangeEventArgs-Objekt, das die Ereignisdaten beinhaltet.
Schauen Sie ferner unter
AfterRowColChange-Ereignis (Seite 225)

AfterScroll-Ereignis (Seite 226)
AfterSelChange-Ereignis (Seite 227)
BeforeRowColChange-Ereignis (Seite 243)
BeforeScroll-Ereignis (Seite 244)
BeforeSelChange-Ereignis (Seite 245)
RowColEventHandler-Delegierer
Syntax
[VB]
Public Delegate Sub RowColEventHandler (object sender, RowColEventArgs e)
[C#]
public sealed delegate RowColEventHandler : System.MulticastDelegate
[Delphi]
RowColEventHandler-Delegierer · 283
type RowColEventHandler = procedure(sender: System.Object, e: RowColEventArgs) of object;
Argumente
Argument Beschreibung
sender Der Auslöser des Ereignisses.
e Ein RowColEventArgs-Objekt, das die Ereignisdaten beinhaltet.
Schauen Sie ferner unter
AfterEdit-Ereignis (Seite 222)
AfterResizeColumn-Ereignis (Seite 224)
AfterResizeRow-Ereignis (Seite 224)
BeforeEdit-Ereignis (Seite 236)
BeforePageBreak-Ereignis (Seite 240)
BeforeResizeColumn-Ereignis (Seite 241)
BeforeResizeRow-Ereignis (Seite 242)
BeforeScrollTip-Ereignis (Seite 244)
CellButtonClick-Ereignis (Seite 248)
ComboCloseUp-Ereignis (Seite 252)
ComboDropDown-Ereignis (Seite 253)
SetupEditor-Ereignis (Seite 271)
StartEdit-Ereignis (Seite 274)

284 · C1FlexGrid-Referenzverzeichnis
SortColEventHandler-Delegierer
Syntax
[VB]
Public Delegate Sub SortColEventHandler (object sender, SortColEventArgs e)
[C#]
public sealed delegate SortColEventHandler : System.MulticastDelegate
[Delphi]
type SortColEventHandler = procedure(sender: System.Object, e: SortColEventArgs) of object;
Argumente
Argument Beschreibung
sender Der Auslöser des Ereignisses.
e Ein SortColEventArgs-Objekt, das die Ereignisdaten beinhaltet.
Schauen Sie ferner unter
AfterSort-Ereignis (Seite 228)
BeforeSort-Ereignis (Seite 246)
ValidateEditEventHandler-Delegierer
Syntax
[VB]
Public Delegate Sub ValidateEditEventHandler (object sender, ValidateEditEventArgs e)
[C#]
public sealed delegate ValidateEditEventHandler : System.MulticastDelegate
[Delphi]
type ValidateEditEventHandler = procedure(sender: System.Object, e: ValidateEditEventArgs) of object;
Argumente
Argument Beschreibung
sender Der Auslöser des Ereignisses.
e Ein ValidateEditEventArgs-Objekt, das die Ereignisdaten beinhaltet.

Schauen Sie ferner unter
ValidateEdit-Ereignis (Seite 275)
C1FlexGrid-Ereignisargumente
BeforeMouseDownEventArgs-Klasse
Syntax
[VB]
Public Class BeforeMouseDownEventArgs
[C#]
public class BeforeMouseDownEventArgs : EventArgs
[Delphi]
type BeforeMouseDownEventArgs: class(EventArgs);
Mitglieder
Mitglied Beschreibung
MouseButtons Button Ermittelt, welche Maustaste gedrückt wurde.
int Clicks, X, Y, Delta
bool Cancel
Schauen Sie ferner unter
BeforeMouseDownEventArgs-Klasse · 285
Weitere Informationen über Mausaktivitäten (gleich den Parametern im
MouseDown-Ereignis).
Setzen Sie diesen Parameter auf TRUE, damit die Steuerung die
Mausaktivitäten ignoriert.
BeforeMouseDownEventHandler-Delegierer (Seite 277)
DragRowColEventArgs-Klasse
Syntax
[VB]
Public Class DragRowColEventArgs
[C#]
public class DragRowColEventArgs : EventArgs
[Delphi]
type DragRowColEventArgs: class(EventArgs);

286 · C1FlexGrid-Referenzverzeichnis
Mitglieder
Mitglied Beschreibung
int Col Der ursprüngliche Index der Spalte, die vom Nutzer gezogen wurde.
int Row Der ursprüngliche Index der Zeile, die vom Nutzer gezogen wurde.
int Position Der aktuelle Index der Spalte, die vom Nutzer gezogen wurde.
bool Cancel Bricht die aktuellen Operationen ab.
Schauen Sie ferner unter
DragRowColEventHandler-Delegierer (Seite 278)
GridChangedEventArgs-Klasse
Syntax
[VB]
Public Class GridChangedEventArgs
[C#]
public class GridChangedEventArgs : EventArgs
[Delphi]
type GridChangedEventArgs: class(EventArgs);
Mitglieder
Mitglied Beschreibung
int r1, c1, r2, c2 Der Bereich, der von der Änderung betroffen war.
GridChangedTypeEnum
GridChangedType
Schauen Sie ferner unter
GridChangedEventHandler-Delegierer (Seite 278)
GridErrorEventArgs-Klasse
Syntax
[VB]
Public Class GridErrorEventArgs
[C#]
public class GridErrorEventArgs : EventArgs
Der Typ der Änderung, die das Ereignis gestartet hat.

[Delphi]
type GridErrorEventArgs: class(EventArgs);
Mitglieder
KeyEditEventArgs-Klasse · 287
Mitglied Beschreibung
int Row, Col Die Koordinaten der Zelle, in welcher der Fehler gefunden wurde.
Exception Exception Eine Fehlerbeschreibung.
bool Handled Ob der Fehler vom Quellcode behandelt oder eine Exception ausgegeben wurde.
Schauen Sie ferner unter
GridErrorEventHandler-Delegierer (Seite 279)
KeyEditEventArgs-Klasse
Syntax
[VB]
Public Class KeyEditEventArgs
[C#]
public class KeyEditEventArgs : EventArgs
[Delphi]
type KeyEditEventArgs: class(EventArgs);
Mitglieder
Mitglied Beschreibung
int Row, Col Die Koordinaten der zu bearbeitenden Zelle, wenn die Taste gedrückt wurde.
int Col Die Spalte, in der die aktuelle Zelle platziert ist.
int KeyValue Der Zahlwert, der die KeyData-Eigenschaft darstellt.
Keys KeyCode Der Tastencode für das Ereignis, welcher einer der Keys-Werte sein wird.
Keys KeyData
Der key-Code für die gedrückte Taste, zusammen mit Veränderungs-Flags, die
anzeigen, welche Kombination von CTRL-, Strg- und ALT-Tasten gleichzeitig
gedrückt wurde.
Keys Modifiers Einer oder mehrere Veränderungs-Flags, wie in Keys definiert.
bool Shift Ermittelt, ob die Strg-Taste gedrückt war.
bool Alt Ermittelt, ob die Alt-Taste gedrückt war.
bool Control Ermittelt, ob die Ctrl-Taste gedrückt war.
Handled Ermittelt, ob der Tastendruck abgewickelt wurde.

288 · C1FlexGrid-Referenzverzeichnis
Schauen Sie ferner unter
KeyEditEventHandler-Delegierer (Seite 279)
KeyPressEditEventArgs-Klasse
Syntax
[VB]
Public Class KeyPressEditEventArgs
[C#]
public class KeyPressEditEventArgs : EventArgs
[Delphi]
type KeyPressEditEventArgs: class(EventArgs);
Mitglieder
Mitglied Beschreibung
int Row, Col Die Koordinaten der zu bearbeitenden Zelle.
char KeyChar Das Zeichen, das zu der gedrückten Taste gehört.
bool Handled Ermittelt, ob der Tastendruck abgewickelt wurde.
Schauen Sie ferner unter
KeyPressEditEventHandler-Delegierer (Seite 280)
OwnerDrawCellEventArgs-Klasse
Syntax
[VB]
Public Class OwnerDrawCellEventArgs
[C#]
public class OwnerDrawCellEventArgs : EventArgs
[Delphi]
type OwnerDrawCellEventArgs: class(EventArgs);
Mitglieder
Mitglied Beschreibung
int Row, Col Ermittelt die Koordinaten der zu zeichnenden Zelle.
Graphics Graphics Ermittelt die zu verwendende grafische Oberfläche, um die Zelle zu
zeichnen.

Rectangle Bounds Ermittelt das Rechteck, wo die Zelle gezeichnet wird.
RangeEventArgs-Klasse · 289
string Text Ermittelt oder legt den Text fest, der in der Zelle angezeigt wird.
Image Image Ermittelt oder legt die Grafik fest, die in der Zelle angezeigt wird.
CellStyle Style Legt das zu verwendende CellStyle-Objekt fest, mit dem die Zelle
gezeichnet wird.
void DrawCell(DrawCellFlags
flags)
Veranlasst die Tabelle, Teile der Zelle zu zeichnen (Hintergrund,
Vordergrund, Rahmen, usw.).
void DrawCell() Veranlasst die Tabelle, die gesamte Zelle zu zeichnen.
bool Handled Ermittelt oder legt fest, ob das Ereignis das Zeichnen der Zelle
abgeschlossen hat.
bool Measuring Ermittelt einen Wert, der festlegt, ob das Ereignis nur aufgerufen wurde,
um eine Zelle auszumessen. Dies geschieht, während die Größe von
Zeilen und Spalten automatisch angepasst wird.
Bemerkungen
Der Nutzer kann den anzuzeigenden Inhalt, das zu verwendende Format oder das zur Verfügung
gestellte Graphics-Objekt verändern, um benutzerdefinierte Inhalte in die Zelle zu zeichnen.
Schauen Sie ferner unter
OwnerDrawCellEventHandler-Delegierer (Seite 281)
RangeEventArgs-Klasse
Syntax
[VB]
Public Class RangeEventArgs
[C#]
public class RangeEventArgs : EventArgs
[Delphi]
type RangeEventArgs: class(EventArgs);
Mitglieder
Mitglied Beschreibung
CellRange OldRange Die Auswahl vor dem Ereignis.
CellRange NewRange Die aktuelle Auswahl.
bool Cancel
Ein Wahrheitswert, der, wenn er auf WAHR steht, die anstehenden
Operationen abbricht.

290 · C1FlexGrid-Referenzverzeichnis
Schauen Sie ferner unter
RangeEventHandler-Delegierer (Seite 282)
RowColEventArgs-Klasse
Syntax
[VB]
Public Class RowColEventArgs
[C#]
public class RowColEventArgs : EventArgs
[Delphi]
type RowColEventArgs: class(EventArgs);
Mitglieder
Mitglied Beschreibung
int Row, Col Die Koordinaten der Zelle, auf die eine Operation angewendet wurde.
bool Cancel
Schauen Sie ferner unter
Ein Wahrheitswert, der, wenn er auf WAHR steht, die anstehenden Operationen
abbricht.
RowColEventHandler-Delegierer (Seite 283)
SortColEventArgs-Klasse
Syntax
[VB]
Public Class SortColEventArgs
[C#]
public class SortColEventArgs : EventArgs
[Delphi]
type SortColEventArgs: class(EventArgs);
Mitglieder
Mitglied Beschreibung
int Col Die zu sortierende Spalte.
SortFlags Order Die Sortierungsrichtung.
bool Cancel Bricht das Sortieren ab. Wenn dieser Parameter im BeforeSort-Ereignis

ool Handled
Schauen Sie ferner unter
SortColEventHandler-Delegierer (Seite 284)
ValidateEditEventArgs-Klasse
Syntax
[VB]
Public Class ValidateEditEventArgs
[C#]
public class ValidateEditEventArgs : EventArgs
[Delphi]
type ValidateEditEventArgs: class(EventArgs);
Mitglieder
Public Readonly Integer Row, Col
Public Readonly CheckEnum Checkbox
Public Boolean Cancel
Eigenschaft Beschreibung
ValidateEditEventArgs-Klasse · 291
auf TRUE gestellt wird, dann bricht die Sortieroperation ab und das
Sortierungszeichen bleibt unverändert
Die Sortierung wurde vom Ereignisabwickler durchgeführt. Wenn dieser
Parameter im BeforeSort-Ereignis auf TRUE gestellt wird, dann bricht die
integrierte Sortierung ab. Das Sortierungszeichen wird aber dennoch
aktualisiert, so als ob das Sortieren stattgefunden hätte. Dies ist nützlich,
wenn Sie benutzerdefiniertes Sortieren verwenden.
int Row Die Zeile, in der die aktuelle Zelle platziert ist.
int Col Die Spalte, in der die aktuelle Zelle platziert ist.
CheckEnum Checkbox
Wenn die Zelle ein Kontrollkästchen beinhaltet, dann enthält dieser Parameter
dessen Zustand, welcher der Zelle zugeordnet wird.
bool Cancel Legt fest, ob der Start des Ereignisses abgebrochen werden soll.
Schauen Sie ferner unter
ValidateEditEventHandler-Delegierer (Seite 284)

292 · C1FlexGrid-Referenzverzeichnis
CellRange-Struct
Das CellRange-Objekt stellt den Zugang zu den Eigenschaften von Zellbereichen zur Verfügung.
Verwenden Sie die GetCellRange-Methode von C1FlexGrid, um ein CellRange-Objekt zu erhalten.
Zum Beispiel, der nachfolgende Quellcode legt das Format einer Zellgruppe fest.
• Visual Basic
• C#
' create new custom cell style
Dim st As CellStyle = flex.Styles.Add("MyStyle")
st.Font = New Font("Tahoma", 14)
' assign new style to a group of cells
Dim rg As CellRange = flex.GetCellRange(1, 1, 10, 10)
rg.Style = st
// create new custom cell style
CellStyle st = flex.Styles.Add("MyStyle");
st.Font = new Font("Tahoma", 14);
// assign new style to a group of cells
CellRange rg = flex.GetCellRange(1,1,10,10);
rg.Style = st;
• Delphi
var
rg: CellRange;
st: CellStyle;
begin
st := flex.Styles.Add('MyStyle');
st.Font := Font.Create('Tahoma', 14);
// assign new style to a group of cells
rg := flex.GetCellRange(1, 1, 10, 10);
rg.Style := st;
end;
Beachten Sie, dass das CellRange-Objekt eine struct und keine class ist. Das bedeutet, dass das Objekt als
Wert und nicht als Referenz verwendet wird. Wenn Sie ein CellRange-Objekt an eine Methode
übergeben und das Objekt in der Methode verändern, dann wird der ursprüngliche Wert nicht geändert.
Alle CellRange-Mitglieder
CellRange-Struct-Eigenschaften (public)
BottomRow
Unterstützt vom .NET-Compact-Framework.
CheckBox
Unterstützt vom .NET-Compact-Framework.
Clip
Unterstützt vom .NET-Compact-Framework.
Data
Unterstützt vom .NET-Compact-Framework.
Gibt den Index der letzten Zeile des Bereichs zurück.
(der größere Wert von r1 und r2).
Gibt/legt den Zustand des Kontrollkästchens im
Bereich zurück/fest.
Gibt/legt den Inhalt eines Zellbereichs als
Zeichenkette zurück/fest.
Gibt/legt den rohen Inhalt des Bereichs zurück/fest.

DataDisplay
Unterstützt vom .NET-Compact-Framework.
Image
Unterstützt vom .NET-Compact-Framework.
BottomRow-Eigenschaft (CellRange) · 293
Gibt den Inhalt der Zelle in (r1,c1) zurück.
Gibt/legt die in dem Bereich angezeigte Grafik
zurück/fest.
IsSingleCell Ermittelt, ob der ausgewählte Bereich nur aus einer
Zelle besteht (r1 == r2 und c1 == c2).
IsValid Ermittelt ob das CellRange-Objekt eine gültige
Auswahl enthält.
LeftCol
Unterstützt vom .NET-Compact-Framework.
r1c1r2c2
Unterstützt vom .NET-Compact-Framework.
RightCol
Unterstützt vom .NET-Compact-Framework.
Style
Unterstützt vom .NET-Compact-Framework.
StyleDisplay
Unterstützt vom .NET-Compact-Framework.
StyleNew
Unterstützt vom .NET-Compact-Framework.
TopRow
Unterstützt vom .NET-Compact-Framework.
UserData
Unterstützt vom .NET-Compact-Framework.
CellRange-Struct-Methoden (public)
Contains
Unterstützt vom .NET-Compact-Framework.
ContainsCol
Unterstützt vom .NET-Compact-Framework.
ContainsRow
Unterstützt vom .NET-Compact-Framework.
Normalize
Unterstützt vom .NET-Compact-Framework.
CellRange-Eigenschaften
BottomRow-Eigenschaft (CellRange)
Gibt den Index der linken Spalte des Bereichs zurück
(der kleinere Wert von c1 und c2).
Index der Zellen, die den Bereich festlegen (nicht
zwingend in Reihenfolge, siehe Normalize-Methode).
Gibt den Index der rechten Spalte des Bereichs
zurück (der größere Wert von c1 und c2).
Gibt/legt ein benutzerdefiniertes Zellformat für den
Bereich zurück/fest.
Gibt das Zellformat zurück, das für die Anzeige des
Bereichs verwendet wird.
Gibt das benutzerdefinierte Zellformat, das für die
Anzeige des Bereichs verwendet wird, zurück und
erstellt eine neue Formatvorlage, wenn nötig.
Gibt den Index der ersten Zeile des Bereichs zurück.
(der kleinere Wert von r1 und r2).
Gibt/legt willkürliche Daten für die Zellen des Bereichs
zurück/fest.
Ermittelt, ob eine bestimmte Zelle in diesem Bereich
enthalten ist CellRange.
Ermittelt, ob eine bestimmte Spalte in diesem Bereich
enthalten ist CellRange.
Ermittelt, ob eine bestimmte Zeile in diesem Bereich
enthalten ist CellRange.
Stellt sicher, dass r1 = TopRow, r2 = BottomRow, c1
= LeftCol, c2 = RightCol ist.
Gibt den Index der letzten Zeile des Bereichs zurück. (der größere Wert von r1 und r2).

294 · C1FlexGrid-Referenzverzeichnis
Syntax
[VB]
Public BottomRow As Integer
[C#]
public int BottomRow {get;}
[Delphi]
property BottomRow: Integer;
Schauen Sie ferner unter
CellRange-Struct (Seite 292)
CheckBox-Eigenschaft
Gibt/legt den Zustand des Kontrollkästchens im Bereich zurück/fest.
Syntax
[VB]
Public Checkbox As CheckEnum
[C#]
public CheckEnum Checkbox {get; set;}
[Delphi]
property CheckBox: CheckEnum;
Bemerkungen
Diese Eigenschaft gibt den Zustand des Kontrollkästchens der ersten Zelle (r1, c1) des Bereichs zurück
und legt diesen für alle Kontrollkästchen im gesamten Bereich fest.
Schauen Sie ferner unter
CellRange-Struct (Seite 292)
Clip-Eigenschaft (CellRange)
Gibt/legt den Inhalt eines Zellbereichs als Zeichenkette zurück/fest.
Syntax
[VB]
Public Clip As String
[C#]
public string Clip {get; set;}
[Delphi]
property Clip: string;

Bemerkungen
Data-Eigenschaft (CellRange) · 295
Der Eintrag, welcher der Clip-Eigenschaft zugeordnet oder von dieser zurückgegeben wird, kann
mehrere Zellen umfassen. Standardmäßig stehen Tabulatorenzeichen (\t) für eine neue Spalte und
Zeilenumschalterzeichen (\n) für Zeilenumbrüche.
Die Standard Zeilen- und Spaltenabgrenzer können in der ClipSeparators-Eigenschaft geändert werden.
Schauen Sie ferner unter
CellRange-Struct (Seite 292)
Data-Eigenschaft (CellRange)
Gibt/legt den rohen Inhalt des Bereichs zurück/fest.
Syntax
[VB]
Public Data As Object
[C#]
public object Data {get; set;}
[Delphi]
property Data: Object;
Bemerkungen
Diese Eigenschaft gibt den Inhalt der ersten Zelle des Bereichs (r1, c1) zurück und legt diesen für den
gesamten Bereich fest.
Schauen Sie ferner unter
CellRange-Struct (Seite 292)
DataDisplay Property
Gibt den Inhalt der ersten Zelle (r1,c1) zurück und formatiert diesen als Zeichenkette.
Syntax
[VB]
Public DataDisplay As String
[C#]
public string DataDisplay {get;}
[Delphi]
property DataDisplay: string;
Bemerkungen
Diese Eigenschaft ist der Clip-Eigenschaft ähnlich, nur dass Clip eine geteilte Zeichenkette mit allen
Daten des gesamten Bereichs enthält und DataDisplay nur den Inhalt der ersten Zelle (r1, c1) zurückgibt.

296 · C1FlexGrid-Referenzverzeichnis
Schauen Sie ferner unter
CellRange-Struct (Seite 292)
Image Property
Gibt/legt die in dem Bereich angezeigte Grafik zurück/fest.
Syntax
[VB]
Public Image As Image
[C#]
public Image Image {get; set;}
[Delphi]
property Image: Image;
Bemerkungen
Diese Eigenschaft gibt die Grafik der ersten Zelle des Bereichs (r1, c1) zurück und legt diese für alle
Zellen des gesamten Bereichs fest.
Schauen Sie ferner unter
CellRange-Struct (Seite 292)
IsSingleCell Property
Ermittelt, ob der ausgewählte Bereich nur aus einer Zelle besteht (r1 == r2 und c1 == c2).
Syntax
[VB]
Public IsSingleCell As Boolean
[C#]
public bool IsSingleCell {get; }
[Delphi]
property IsSingleCell: Boolean;
Schauen Sie ferner unter
CellRange-Struct (Seite 292)
IsValid Property
Ermittelt ob das CellRange-Objekt eine gültige Auswahl enthält.
Syntax
[VB]
Public IsValid As Boolean

[C#]
public bool IsValid {get; }
[Delphi]
property IsValid: Boolean;
Bemerkungen
LeftCol-Eigenschaft (CellRange) · 297
Diese Eigenschaft gibt TRUE zurück, wenn die Koordinaten des Bereichs gültig sind (r1 und r2 zwischen
0 und Count -1; c1 und c2 zwischen 0 und Count – 1).
Schauen Sie ferner unter
CellRange-Struct (Seite 292)
LeftCol-Eigenschaft (CellRange)
Gibt den Index der linken Spalte des Bereichs zurück (der kleinere Wert von c1 und c2).
Syntax
[VB]
Public LeftCol As Integer
[C#]
public int LeftCol {get;}
[Delphi]
property LeftCol: Integer;
Schauen Sie ferner unter
CellRange-Struct (Seite 292)
r1,c1,r2,c2-Eigenschaft
Index der Zellen, die den Bereich festlegen (nicht zwingend in Reihenfolge, siehe Normalize-Methode).
Syntax
[VB]
Public r1, c1, r2, c2 As Integer
[C#]
Public int r1, c1, r2, c2; { get; set; }
[Delphi]
property r1, c1, r2, c2: Integer;
Schauen Sie ferner unter
CellRange-Struct (Seite 292)

298 · C1FlexGrid-Referenzverzeichnis
RightCol-Eigenschaft (CellRange)
Gibt den Index der rechten Spalte des Bereichs zurück (der größere Wert von c1 und c2).
Syntax
[VB]
Public RightCol As Integer
[C#]
public int RightCol {get;}
[Delphi]
property RightCol: Integer;
Schauen Sie ferner unter
CellRange-Struct (Seite 292)
Style-Eigenschaft (CellRange)
Gibt/legt ein benutzerdefiniertes Zellformat für den Bereich zurück/fest.
Syntax
[VB]
Public Style As CellStyle
[C#]
public CellStyle Style {get; set;}
[Delphi]
property Style: CellStyle;
Bemerkungen
Wenn abgefragt, dann gibt diese Eigenschaft das benutzerdefinierte Format der Zelle (r1, c1) zurück.
Wenn die Zelle kein eigenes Format besitzt, dann wird Null zurückgegeben. Wenn festgelegt, dann
ordnet diese Eigenschaft den neuen Wert für das Format allen Zellen im ausgewählten Bereich zu.
Schauen Sie ferner unter
CellRange-Struct (Seite 292)
StyleDisplay-Eigenschaft (CellRange)
Gibt das Zellformat zurück, dass für die Anzeige des Bereichs verwendet wird.
Syntax
[VB]
Public StyleDisplay As CellStyle

[C#]
public CellStyle StyleDisplay {get;}
[Delphi]
property StyleDisplay: CellStyle;
Bemerkungen
StyleNew-Eigenschaft (CellRange) · 299
Wenn abgefragt, dann gibt diese Eigenschaft ein CellStyle-Objekt mit einem Format zurück, das für das
Rendern der Zelle verwendet wird. Wenn die Zelle ein benutzerdefiniertes Format besitzt, dann gibt
StyleDisplay dieses zurück; andernfalls wird das Standardformat (z.B. Normal, Fixed, usw.)
zurückgegeben.
Schauen Sie ferner unter
CellRange-Struct (Seite 292)
StyleNew-Eigenschaft (CellRange)
Gibt das benutzerdefinierte Zellformat, dass für die Anzeige des Bereichs verwendet wird, zuück und
erstellt eine neue Formatvorlage, wenn nötig.
Syntax
[VB]
Public StyleNew As CellStyle
[C#]
public CellStyle StyleNew {get;}
[Delphi]
property StyleNew: CellStyle;
Bemerkungen
Wenn die Zelle (r1,c1) ein eigenes Format besitzt, dann wird es von dieser Eigenschaft zurückgegeben.
Wenn die Zelle kein eigenes Format besitzt, dann wird von StyleNew ein neues erstellt und dieses dem
gesamten Bereich zugeordnet.
Schauen Sie ferner unter
CellRange-Struct (Seite 292)
TopRow-Eigenschaft (CellRange)
Gibt den Index der ersten Zeile des Bereichs zurück. (der kleinere Wert von r1 und r2).
Syntax
[VB]
Public TopRow As Integer
[C#]
public int TopRow {get;}

300 · C1FlexGrid-Referenzverzeichnis
[Delphi]
property TopRow: Integer;
Schauen Sie ferner unter
CellRange-Struct (Seite 292)
UserData-Eigenschaft (CellRange)
Gibt/legt willkürliche Daten für die Zellen des Bereichs zurück/fest.
Syntax
[VB]
Public UserData As Object
[C#]
public object UserData {get; set;}
[Delphi]
property UserData: Object;
Bemerkungen
Wenn abgefragt, dann gibt diese Eigenschaft den Datenwert der ersten Zelle im Bereich (r1,c1) zurück
und wenn festgelegt, dann ordnet diese den neuen Wert allen Zellen im ausgewählten Bereich zu.
Schauen Sie ferner unter
CellRange-Struct (Seite 292)
CellRange-Methoden
Contains-Methode (CellRange)
Ermittelt, ob eine bestimmte Zelle in diesem Bereich enthalten ist CellRange.
Syntax
[VB]
Public Function Contains(row As Integer, col As Integer) As Boolean
[C#]
public Boolean Contains ( int row , int col )
[Delphi]
function Contains(row: Integer; col: Integer): Boolean;
Parameter Beschreibung
row, col Die Koordinaten der zu überprüfenden Zelle.

Rückgabewert
ContainsCol-Methode · 301
Boolean. Gibt TRUE zurück, wenn die Zell auf (row, col) im Bereich CellRange liegt. (sonst FALSE)
Schauen Sie ferner unter
CellRange-Struct (Seite 292)
ContainsCol-Methode
Ermittelt, ob eine bestimmte Spalte in diesem Bereich enthalten ist CellRange.
Syntax
[VB]
Public Function ContainsCol(col As Integer) As Boolean
[C#]
public Boolean ContainsCol ( int col )
[Delphi]
function ContainsCol(col: Integer): Boolean;
Parameter Beschreibung
col Der Index der zu überprüfenden Spalte.
Rückgabewert
Boolean. Gibt TRUE zurück, wenn die Spalte im Bereich CellRange liegt. (sonst FALSE)
Schauen Sie ferner unter
CellRange-Struct (Seite 292)
ContainsRow-Methode
Ermittelt, ob eine bestimmte Zeile in diesem Bereich enthalten ist CellRange.
Syntax
[VB]
Public Function ContainsRow(row As Integer) As Boolean
[C#]
public Boolean ContainsRow ( int row )
[Delphi]
function ContainsRow(row: Integer): Boolean;

302 · C1FlexGrid-Referenzverzeichnis
Parameter Beschreibung
row Der Index der zu überprüfenden Zeile.
Rückgabewert
Boolean. Gibt TRUE zurück, wenn die Zeile im Bereich CellRange liegt. (sonst FALSE)
Schauen Sie ferner unter
CellRange-Struct (Seite 292)
Normalize-Methode
Normalisiert den Bereich um sicherzustellen, dass r1

Syntax
[VB]
Public Column As Integer
[C#]
public int Column {get;}
[Delphi]
property Column: Integer;
Schauen Sie ferner unter
HitTestInfo-Klasse (Seite 302)
Row-Eigenschaft (HitTestInfo)
Row-Eigenschaft (HitTestInfo) · 303
Ermittelt die Zeile, in welcher der Punkt geprüft wird, oder gibt -1 zurück, wenn der Punkt in einem
leeren Bereich der Tabellensteuerung liegt.
Syntax
[VB]
Public Row As Integer
[C#]
public int Row {get;}
[Delphi]
property Row: Integer;
Schauen Sie ferner unter
HitTestInfo-Klasse (Seite 302)
Type-Eigenschaft (HitTestInfo)
Ermittelt den Typ des Elements am zu prüfendem Punkt.
Syntax
[VB]
Public Type As HitTestTypeEnum
[C#]
public HitTestTypeEnum Type {get;}
[Delphi]
property Type: HitTestTypeEnum;
Bemerkungen
Mit dieser Eigenschaft können Sie erfahren, ob der Punkt auf einer Zelle oder einem besonderem Element
liegt, wie z.B. dem Größenveränderungsbereichen von Spalten und Zeilen.

304 · C1FlexGrid-Referenzverzeichnis
Schauen Sie ferner unter
HitTestInfo-Klasse (Seite 302)
X-Eigenschaft (HitTestInfo)
Ermittelt die X-Koordinate des zu prüfenden Punktes.
Syntax
[VB]
Public X As Integer
[C#]
public int X {get;}
[Delphi]
property X: Integer;
Schauen Sie ferner unter
HitTestInfo-Klasse (Seite 302)
Y-Eigenschaft (HitTestInfo)
Ermittelt die Y-Koordinate des zu prüfenden Punktes.
Syntax
[VB]
Public Y As Integer
[C#]
public int Y {get;}
[Delphi]
property Y: Integer;
Schauen Sie ferner unter
HitTestInfo-Klasse (Seite 302)
RowCollection-Klasse
Alle RowCollection-Mitglieder
RowCollection-Klasseneigenschaften (public)
Count Ermittelt oder legt die Anzahl der Zeilen in der
Collection fest.
DefaultSize Ermittelt oder legt die Standardhöhe für alle Zeilen
der Collection fest.

Count-Eigenschaft (RowCollection) · 305
Fixed Ermittelt oder legt die Anzahl der fixierten Zeilen in
der Collection fest.
Frozen Ermittelt oder legt die Anzahl der eingefrorenen
Zeilen in der Collection fest.
Item Ermittelt das Zeilenobjekt an einem bestimmten
Index.
MaxSize Ermittelt oder legt die maximale Höhe einer Zeile
fest.
MinSize Ermittelt oder legt die minimale Höhe einer Zeile fest.
Selected
Unterstützt vom .NET-Compact-Framework.
RowCollection-Klassenmethoden (public)
Add
Unterstützt vom .NET-Compact-Framework.
Ermittelt eine Collection von Zeilen, die gerade
ausgewählt sind.
Fügt der Collection eine neue Zeile hinzu.
Contains Ermittelt, ob die Collection eine gegebene Zeile
enthält.
Insert
Unterstützt vom .NET-Compact-Framework.
Fügt einer Collection eine neue Zeile an einer
bestimmten Position hinzu.
InsertNode Fügt einer Collection eine neue Knotenzeile ein.
InsertRange
Unterstützt vom .NET-Compact-Framework.
Fügt einer Collection eine Zeilenauswahl an einer
bestimmten Position hinzu.
Move Verschiebt eine Zeile auf eine neue Position in der
Collection.
MoveRange Verschiebt eine Zeilenauswahl auf eine neue
Position in der Collection.
Remove
Unterstützt vom .NET-Compact-Framework.
RemoveRange
Unterstützt vom .NET-Compact-Framework.
RowCollection-Eigenschaften
Count-Eigenschaft (RowCollection)
Ermittelt oder legt die Anzahl der Zeilen in der Collection fest.
Syntax
[VB]
Public Count As Integer
Entfernt eine Zeile aus der Collection.
Entfernt eine Zeilenauswahl aus der Collection.

306 · C1FlexGrid-Referenzverzeichnis
[C#]
public int Count {get; set;}
[Delphi]
property Count: Integer;
Bemerkungen
Sie können Zeilen entfernen oder hinzufügen, indem Sie dieser Eigenschaft einen neuen Wert zurordnen,
oder die Add-, Insert-, InsertRange- und Remove-Methoden verwenden.
Schauen Sie ferner unter
RowCollection-Klasse (Seite 304)
DefaultSize-Eigenschaft (RowCollection)
Ermittelt oder legt die Standardhöhe für alle Zeilen der Collection fest.
Syntax
[VB]
Public DefaultSize As Integer
[C#]
public int DefaultSize {get; set;}
[Delphi]
property DefaultSize: Integer;
Bemerkungen
Die Standardhöhe wird verwendet, wenn die Row.Height-Eigenschaft den Wert -1 besitzt.
Wenn Sie einen neuen Wert der Font-Eigenschaft der Tabelle zuordnen, dann wird die DefaultSize-
Eigenschaft automatisch angepasst, so dass die neue Schriftgröße in die Zeile passt.
Schauen Sie ferner unter
RowCollection-Klasse (Seite 304)
Fixed-Eigenschaft (RowCollection)
Ermittelt oder legt die Anzahl der fixierten Zeilen in der Collection fest.
Syntax
[VB]
Public Fixed As Integer
[C#]
public int Fixed {get; set;}
[Delphi]
property Fixed: Integer;

Schauen Sie ferner unter
RowCollection-Klasse (Seite 304)
Frozen-Eigenschaft (RowCollection)
Ermittelt oder legt die Anzahl der eingefrorenen Zeilen in der Collection fest.
Syntax
[VB]
Public Frozen As Integer
[C#]
public int Frozen {get; set;}
[Delphi]
property Frozen: Integer;
Bemerkungen
Frozen-Eigenschaft (RowCollection) · 307
Verwenden Sie die AllowFreezing-Eigenschaft um festzulegen, ob Nutzer Zeilen mit der Maus einfrieren
können.
Schauen Sie ferner unter
RowCollection-Klasse (Seite 304)
Item-Eigenschaft (RowCollection)
Ermittelt das Zeilenobjekt an einem bestimmten Index.
Syntax
[VB]
Public Item As Row
[C#]
public Row this[int index] {get;}
[Delphi]
property Item: Row;
Bemerkungen
Sie können das von dieser Methode zurückgegebene Row-Objekt verwenden, um Attribute, wie z.B.
Zeilenhöhe, Sichtbarkeit, Format, Auswahlzustand, usw. zu setzen.
Schauen Sie ferner unter
RowCollection-Klasse (Seite 304)
MaxSize-Eigenschaft (RowCollection)
Ermittelt oder legt die maximale Höhe einer Zeile fest.

308 · C1FlexGrid-Referenzverzeichnis
Syntax
[VB]
Public MaxSize As Integer
[C#]
public int MaxSize {get; set;}
[Delphi]
property MaxSize: Integer;
Bemerkungen
Die MaxSize-Eigenschaft beschränkt die maximale Größe der Zeilen, wenn diese durch den Nutzer oder
durch die AutoSizeRows-Methode, welche die Größe der Zeilen an den Zellinhalt anpasst, verändert
wird.
Diese Eigenschaft ist deaktiviert, wenn sie auf Null gestellt ist.
Schauen Sie ferner unter
RowCollection-Klasse (Seite 304)
MinSize-Eigenschaft (RowCollection)
Ermittelt oder legt die minimale Höhe einer Zeile fest.
Syntax
[VB]
Public MinSize As Integer
[C#]
public int MinSize {get; set;}
[Delphi]
property MinSize: Integer;
Bemerkungen
Die MinSize-Eigenschaft beschränkt die Mindestgröße der Zeilen, wenn diese durch den Nutzer oder
durch die AutoSizeRows-Methode, welche die Größe der Zeilen an den Zellinhalt anpasst, verändert
wird.
Schauen Sie ferner unter
RowCollection-Klasse (Seite 304)
Selected-Eigenschaft (RowCollection)
Ermittelt eine Collection von Zeilen, die gerade ausgewählt sind.
Syntax
[VB]
Public Selected As RowCollection

[C#]
public RowCollection Selected
[Delphi]
property Selected: RowCollection;
Bemerkungen
Add-Methode (RowCollection) · 309
Diese Eigenschaft ist nützlich, wenn die Tabelle im Listenfeldmodus verwendet wird. Zum Beispiel, der
nachfolgende Quellcode gibt Informationen über die aktuell ausgewählten Zeilen zurück:
• Visual Basic
• C#
fg.SelectionMode = SelectionModeEnum.ListBox
Dim r As Row
For Each r In fg.Rows.Selected
Console.WriteLine(r.Index)
Next
fg.SelectionMode = SelectionModeEnum.ListBox;
foreach (Row row in fg.Rows.Selection)
Console.WriteLine(row.Index);
• Delphi
var
r: Row;
i: Integer;
begin
fg.SelectionMode := SelectionModeEnum.ListBox;
for I := 0 to fg.Rows.Count do
begin
r := fg.Rows[i];
Console.WriteLine(r.Index);
end;
end;
Schauen Sie ferner unter
RowCollection-Klasse (Seite 304)
RowCollection-Methoden
Add-Methode (RowCollection)
Fügt der Collection eine neue Zeile hinzu.
Syntax
[VB]
Public Function Add() As Row
[C#]
public Row Add ( )

310 · C1FlexGrid-Referenzverzeichnis
[Delphi]
property Add: Row;
Rückgabewert
Ein Verweis auf die Zeile, die der Collection hinzugefügt wurde.
Bemerkungen
Die Add-Methode hängt der Collection eine neue Zeile an. Verwenden Sie die Insert-Methode, um eine
Zeile an einer bestimmten Stelle einzufügen.
Schauen Sie ferner unter
RowCollection-Klasse (Seite 304)
Contains-Methode (RowCollection)
Ermittelt, ob die Collection eine gegebene Zeile enthält.
Syntax
[VB]
Public Function Contains(item As RowCol) As Boolean
[C#]
public Boolean Contains (RowCol item )
[Delphi]
function Contains(item: RowCol): Boolean;
Parameter Beschreibung
row Das zu prüfende Row-Objekt.
Rückgabewert
Boolean. Gibt TRUE zurück, wenn die Zeile ein Mitglied der Collection ist. (Sonst FALSE)
Schauen Sie ferner unter
RowCollection-Klasse (Seite 304)
Insert-Methode (RowCollection)
Fügt einer Collection eine neue Zeile an einer bestimmten Position hinzu.
Syntax
[VB]
Public Function Insert(index As Integer) As Row
[C#]
public Row Insert ( int index )

[Delphi]
function Insert (index: Integer): Row;
Parameter Beschreibung
index Die Position, auf der die neue Zeile eingefügt werden soll.
Rückgabewert
Ein Verweis auf die Zeile, die der Collection hinzugefügt wurde.
Schauen Sie ferner unter
RowCollection-Klasse (Seite 304)
InsertNode-Methode
Fügt in eine Collection eine neue Knotenzeile ein.
Syntax
[VB]
Public Function InsertNode(index As Integer, level As Integer) As Node
[C#]
public Node InsertNode ( int index , int level )
[Delphi]
function InsertNode (index: Integer; level: Integer): Node;
Rückgabewert
Ein Verweis auf den Knoten, welcher der Collection hinzugefügt wurde.
Bemerkungen
InsertNode-Methode · 311
Diese Methode ist besonders nützlich, wenn die Tabelle an eine Datenquelle gebunden ist, weil Sie in
diesem Fall nicht den Wert der Row.IsNode-Eigenschaft verändern können. Wenn die Tabelle
ungebundenen ist, können Sie Zeilen hinzufügen und diese später mit der Row.IsNode-Eigenschaft in
Knotenzeilen umwandeln.
Schauen Sie ferner unter
RowCollection-Klasse (Seite 304)
InsertRange-Methode (RowCollection)
Fügt einer Collection eine Zeilenauswahl an einer bestimmten Position hinzu.
Syntax
[VB]
Public Sub InsertRange(index As Integer, count As Integer)

312 · C1FlexGrid-Referenzverzeichnis
[C#]
public void InsertRange ( int index , int count )
[Delphi]
procedure InsertRange (index: Integer; count: Integer);
Parameter Beschreibung
index Die Position, an welcher der neue Bereich eingefügt wird.
count Die Anzahl der einzufügenden Zeilen.
Schauen Sie ferner unter
RowCollection-Klasse (Seite 304)
Move-Methode (RowCollection)
Verschiebt eine Zeile auf eine neue Position in der Collection.
Syntax
[VB]
Public Sub Move(indexOld As Integer, indexNew As Integer)
[C#]
public void Move ( int indexOld , int indexNew )
[Delphi]
procedure Move (indexOld: Integer; indexNew: Integer);
Parameter Beschreibung
oldindex Der aktuelle Index der zu verschiebenden Zeile.
newindex Der neue Zeilenindex.
Schauen Sie ferner unter
RowCollection-Klasse (Seite 304)
MoveRange-Methode (RowCollection)
Verschiebt eine Zeilenauswahl auf eine neue Position in der Collection.
Syntax
[VB]
Public Sub MoveRange(index As Integer, count As Integer, indexNew As Integer)

[C#]
public void MoveRange ( int index , int count , int indexNew )
[Delphi]
procedure MoveRange (index: Integer, count: Integer, indexNew: Integer);
Parameter Beschreibung
oldindex Der aktuelle Index der ersten Zeile des zu verschiebenden Bereichs.
count Die Anzahl der Zeilen, die verschoben werden.
newindex Der neue Index der ersten Zeile des Bereichs.
Schauen Sie ferner unter
RowCollection-Klasse (Seite 304)
Remove-Methode (RowCollection)
Entfernt eine Zeile aus der Collection.
Syntax
[VB]
Public Function Remove(index As Integer) As Row
[C#]
public Row Remove ( int index )
[Delphi]
function Remove(index: Integer): Row;
Parameter Beschreibung
index Der Index, der aus der Collection zu entfernenden Zeile.
Rückgabewert
Ein Verweis auf die Zeile, die aus der Collection entfernt wurde.
Schauen Sie ferner unter
RowCollection-Klasse (Seite 304)
RemoveRange-Methode (RowCollection)
Entfernt eine Zeilenauswahl aus der Collection.
Remove-Methode (RowCollection) · 313

314 · C1FlexGrid-Referenzverzeichnis
Syntax
[VB]
Public Sub RemoveRange(index As Integer, count As Integer)
[C#]
public void RemoveRange ( int index , int count )
[Delphi]
procedure RemoveRange(index: Integer; count: Integer);
Parameter Beschreibung
index Der aktuelle Index der ersten Zeile des zu entfernenden Bereichs.
count Die Anzahl der Zeilen, die aus der Collection entfernt werden.
Schauen Sie ferner unter
RowCollection-Klasse (Seite 304)
ColumnCollection-Klasse
Alle ColumnCollection-Mitglieder
ColumnCollection-Klassen-Eigenschaften (public)
Count Ermittelt oder legt die Anzahl der Spalten in der
Collection fest.
DefaultSize Ermittelt oder legt die Standardbreite für alle Spalten
der Collection fest.
Fixed Ermittelt oder legt die Anzahl der fixierten Spalten in
der Collection fest.
Frozen Ermittelt oder legt die Anzahl der eingefrorenen
Spalten in der Collection fest.
Item Ermittelt das Spaltenobjekt an einem bestimmten
Index.
MaxSize Ermittelt oder legt die maximale Breite einer Spalte
fest.
MinSize Ermittelt oder legt die minimale Breite einer Zeile fest.
Selected
Unterstützt vom .NET-Compact-Framework.
Ermittelt eine Collection von Spalten, die gerade
ausgewählt sind.

ColumnCollection-Klassenmethoden (public)
Add
Unterstützt vom .NET-Compact-Framework.
Count-Eigenschaft (ColumnCollection) · 315
Fügt der Collection eine neue Spalte hinzu.
ContainsCol Ermittelt, ob die Collection eine gegebene Spalte
enthält.
Insert
Unterstützt vom .NET-Compact-Framework.
InsertRange
Unterstützt vom .NET-Compact-Framework.
Fügt einer Collection eine neue Spalte an einer
bestimmten Position hinzu.
Fügt einer Collection eine Spaltenauswahl an einer
bestimmten Position hinzu.
Move Verschiebt eine Spalte auf eine neue Position in der
Collection.
MoveRange Verschiebt eine Spaltenauswahl auf eine neue Position
in der Collection.
Remove
Unterstützt vom .NET-Compact-Framework.
RemoveRange
Unterstützt vom .NET-Compact-Framework.
ColumnCollection-Eigenschaften
Count-Eigenschaft (ColumnCollection)
Ermittelt oder legt die Anzahl der Spalten in der Collection fest.
Syntax
[VB]
Public Count As Integer
[C#]
public int Count {get; set;}
[Delphi]
property Count: Integer;
Bemerkungen
Entfernt eine Spalte aus der Collection.
Entfernt eine Spaltenauswahl aus der Collection.
Sie können Spalten entfernen oder hinzufügen, indem Sie dieser Eigenschaft einen neuen Wert
zurordnen, oder die Add-, Insert-, InsertRange- und Remove-Methoden verwenden.
Schauen Sie ferner unter
ColumnCollection-Klasse (Seite 314)
DefaultSize-Eigenschaft (ColumnCollection)
Ermittelt oder legt die Standardbreite für alle Spalten der Collection fest.

316 · C1FlexGrid-Referenzverzeichnis
Syntax
[VB]
Public DefaultSize As Integer
[C#]
public int DefaultSize {get; set;}
[Delphi]
property DefaultSize: Integer;
Bemerkungen
Die Standardbreite wird verwendet, wenn die Column.Width-Eigenschaft den Wert -1 besitzt.
Wenn Sie einen neuen Wert der Font-Eigenschaft der Tabelle zuordnen, dann wird die DefaultSize-
Eigenschaft automatisch angepasst, so dass die neue Schriftgröße in die Spalte passt.
Schauen Sie ferner unter
ColumnCollection-Klasse (Seite 314)
Fixed-Eigenschaft (ColumnCollection)
Ermittelt oder legt die Anzahl der fixierten Spalten in der Collection fest.
Syntax
[VB]
Public Fixed As Integer
[C#]
public int Fixed {get; set;}
[Delphi]
property Fixed: Integer;
Schauen Sie ferner unter
ColumnCollection-Klasse (Seite 314)
Frozen-Eigenschaft (ColumnCollection)
Ermittelt oder legt die Anzahl der eingefrorenen Spalten in der Collection fest.
Syntax
[VB]
Public Frozen As Integer
[C#]
public int Frozen {get; set;}
[Delphi]
property Frozen: Integer;

Bemerkungen
Item-Eigenschaft (ColumnCollection) · 317
Verwenden Sie die AllowFreezing-Eigenschaft um festzulegen, ob Nutzer Spalten mit der Maus
einfrieren können.
Schauen Sie ferner unter
ColumnCollection-Klasse (Seite 314)
Item-Eigenschaft (ColumnCollection)
Ermittelt das Spaltenobjekt an einem bestimmten Index.
Syntax
[VB]
Public Item[int index] As Column
[C#]
public Column this[int index] {get; }
public Column this[string name] {get; }
[Delphi]
property Item: Column;
Bemerkungen
Sie können das von dieser Methode zurückgegebene Column-Objekt verwenden, um Attribute, wie z.B.
Spaltenbreite, Sichbarkeit, Format, Auswahlzustand, usw. zu setzen.
Der Zeichenkettenindizierer sucht nach einer Spalte mit einem festgelegten Name. Der Spaltenname wird
entweder automatisch gesetzt, wenn die Tabelle an eine Datenbank gebunden ist, oder er wird mit
Quellcode festgelegt. Zum Beispiel:
• Visual Basic
• C#
' set the column name
flex.Cols(2).Name = "bools" '
flex.Cols(2).DataType = GetType(Boolean) '
' show boolean column as text
flex.Cols("bools").Format = "Yes;No" '
// set the column name
flex.Cols[2].Name = "bools";
flex.Cols[2].DataType = typeof(bool);
// show boolean column as text
flex.Cols["bools"].Format = "Yes;No";
• Delphi
// set the column name
flex.Cols[2].Name := 'bools';
flex.Cols[2].DataType := TypeOf(Boolean);
// show boolean column as text

318 · C1FlexGrid-Referenzverzeichnis
flex.Cols['bools'].Format := 'Yes;No';
Schauen Sie ferner unter
ColumnCollection-Klasse (Seite 314)
MaxSize-Eigenschaft (ColumnCollection)
Ermittelt oder legt die maximale Breite einer Spalte fest.
Syntax
[VB]
Public MaxSize As Integer
[C#]
public int MaxSize {get; set;}
[Delphi]
property MaxSize: Integer;
Bemerkungen
Die MaxSize-Eigenschaft beschränkt die maximale Größe der Spalte, wenn diese durch den Nutzer oder
durch die AutoSizeCols-Methode, welche die Größe der Spalten an den Zellinhalt anpasst, verändert
wird.
Diese Eigenschaft ist deaktiviert, wenn sie auf Null gestellt wird.
Schauen Sie ferner unter
ColumnCollection-Klasse (Seite 314)
MinSize-Eigenschaft (ColumnCollection)
Ermittelt oder legt die minimale Breite einer Zeile fest.
Syntax
[VB]
Public MinSize As Integer
[C#]
public int MinSize {get; set;}
[Delphi]
property MinSize: Integer;
Bemerkungen
Die MinSize-Eigenschaft beschränkt die Mindestgröße der Spalte, wenn diese durch den Nutzer oder
durch die AutoSizeCols-Methode, welche die Größe der Spalten an den Zellinhalt anpasst, verändert
wird.
Schauen Sie ferner unter
ColumnCollection-Klasse (Seite 314)

Selected-Eigenschaft
Ermittelt eine Collection von Spalten, die gerade ausgewählt sind.
Syntax
[VB]
Public Selected As ColumnCollection
[C#]
public ColumnCollection Selected {get;}
[Delphi]
property Selected: ColumnCollection;
Schauen Sie ferner unter
ColumnCollection-Klasse (Seite 314)
ColumnCollection-Methoden
Add-Methode (ColumnCollection)
Fügt der Collection eine neue Spalte hinzu.
Syntax
[VB]
Public Function Add() As Column
[C#]
public Column Add ( )
[Delphi]
function Add: Column;
Rückgabewert
Ein Verweis auf die Spalte, die der Collection hinzugefügt wurde.
Bemerkungen
Selected-Eigenschaft · 319
Die Add-Methode hängt der Collection eine neue Spalte an. Verwenden Sie die Insert-Methode, um eine
Spalte an einer bestimmten Stelle einzufügen.
Schauen Sie ferner unter
ColumnCollection-Klasse (Seite 314)
Contains-Methode (ColumnCollection)
Ermittelt, ob die Collection eine gegebene Spalte enthält.

320 · C1FlexGrid-Referenzverzeichnis
Syntax
[VB]
Public Function Contains(columnName As String) As Boolean
[C#]
public Boolean Contains (String columnName )
[Delphi]
function Contains(columnName: string): Boolean;
Parameter Beschreibung
col Das zu prüfende Column-Objekt.
Rückgabewert
Boolean. Gibt TRUE zurück, wenn die Spalte ein Mitglied der Collection ist. (Sonst FALSE)
Schauen Sie ferner unter
ColumnCollection-Klasse (Seite 314)
Insert-Methode (ColumnCollection)
Fügt einer Collection eine neue Spalte an einer bestimmten Position hinzu.
Syntax
[VB]
Public Function Insert(index As Integer) As Column
[C#]
public Column Insert ( int index )
[Delphi]
function Insert(index: Integer): Column;
Parameter Beschreibung
index Die Position, auf der die neue Spalte eingefügt werden soll.
Rückgabewert
Ein Verweis auf die Spalte, die der Collection hinzugefügt wurde.
Schauen Sie ferner unter
ColumnCollection-Klasse (Seite 314)
InsertRange-Methode (ColumnCollection)
Fügt einer Collection eine Spaltenauswahl an einer bestimmten Position hinzu.

Syntax
[VB]
Public Sub InsertRange(index As Integer, count As Integer)
[C#]
public void InsertRange ( int index , int count )
[Delphi]
procedure InsertRange (index: Integer; count: Integer);
Parameter Beschreibung
index Die Position, an welcher der neue Bereich eingefügt wird.
count Die Anzahl der einzufügenden Spalten.
Schauen Sie ferner unter
ColumnCollection-Klasse (Seite 314)
Move-Methode (ColumnCollection)
Verschiebt eine Spalte auf eine neue Position in der Collection.
Syntax
[VB]
Public Sub Move(indexOld As Integer, indexNew As Integer)
[C#]
public void Move ( int indexOld , int indexNew )
[Delphi]
procedure Move (indexOld: Integer; IndexNew: Integer);
Parameter Beschreibung
oldindex Der aktuelle Index der zu verschiebenden Spalte.
newIndex Der neue Spaltenindex.
Schauen Sie ferner unter
ColumnCollection-Klasse (Seite 314)
MoveRange-Methode (ColumnCollection)
Verschiebt eine Spaltenauswahl auf eine neue Position in der Collection.
Move-Methode (ColumnCollection) · 321

322 · C1FlexGrid-Referenzverzeichnis
Syntax
[VB]
Public Sub MoveRange(index As Integer, count As Integer, indexNew As Integer)
[C#]
public void MoveRange ( int index , int count , int indexNew )
[Delphi]
procedure MoveRange(index: Integer; count: Integer, indexNew: Integer);
Parameter Beschreibung
oldindex Der aktuelle Index der ersten Spalte des zu verschiebenden Bereichs.
count Die Anzahl der Zeilen, die verschoben werden.
newIndex Der neue Index der ersten Spalte des Bereichs.
Schauen Sie ferner unter
ColumnCollection-Klasse (Seite 314)
Remove-Methode (ColumnCollection)
Entfernt eine Spalte aus der Collection.
Syntax
[VB]
Public Function Remove(index As Integer) As Column
[C#]
public Column Remove ( int index )
[Delphi]
function Remove(index: Integer): Column;
Parameter Beschreibung
index Der Index, der aus der Collection zu entfernenden Spalte.
Rückgabewert
Ein Verweis auf die Spalte, die aus der Collection entfernt wurde.
Schauen Sie ferner unter
ColumnCollection-Klasse (Seite 314)

RemoveRange-Methode (ColumnCollection)
Entfernt eine Spaltenauswahl aus der Collection.
Syntax
[VB]
Public Sub RemoveRange(index As Integer, count As Integer)
[C#]
public void RemoveRange ( int index , int count )
[Delphi]
procedure RemoveRange(index: Integer; count: Integer);
RemoveRange-Methode (ColumnCollection) · 323
Parameter Beschreibung
index Der aktuelle Index der ersten Spalte des zu entfernenden Bereichs.
count Die Anzahl der Spalten, die aus der Collection entfernt werden.
Schauen Sie ferner unter
ColumnCollection-Klasse (Seite 314)

324 · C1FlexGrid-Referenzverzeichnis
Row-Klassen
Alle Row-Mitglieder
Row-Klasseneigenschaften (public)
AllowDragging Ermittelt oder legt fest, ob der Nutzer diese Zeile mit
der Maus ziehen darf.
AllowEditing Ermittelt oder legt fest, ob der Nutzer die Zellen
dieser Zeilen bearbeiten darf.
AllowMerging Ermittelt oder legt fest, ob die Zellen mit den
benachbarten Zellen dieser Zeile verbunden werden.
AllowResizing Ermittelt oder legt fest, ob der Nutzer die Größe
dieser Zeile mit der Maus verändern darf.
Bottom
Unterstützt vom .NET-Compact-Framework.
Gibt die Position der unteren Grenze dieser Zeile in
Pixeln, relativ zur Tabelle zurück. (berücksichtigt
nicht den Bildlauf)
Caption Ermittelt oder legt den Text der ersten fixierten Zelle
in dieser Zeile fest.
DataIndex Gibt die Position dieser Zeile im Datenquellobjekt
zurück.
DataSource Gibt das Objekt zurück, welches die Daten für diese
Zeile zur Verfügung stellt.
Editor Ermittelt oder legt den benutzerdefinierten Editor
fest, der für die Bearbeitung der Zellen in dieser Zeile
verwendet werden soll.
Height
Unterstützt vom .NET-Compact-Framework.
HeightDisplay
Unterstützt vom .NET-Compact-Framework.
Ermittelt oder legt die Höhe dieser Zeile in Pixel fest.
Gibt -1 zurück, wenn die Zeile die Standardhöhe hat.
Ermittelt oder legt die angezeigte Höhe dieser Zeile
in Pixeln fest.
ImageAlign Ermittelt oder legt fest, wie Grafiken in scrollbaren
Zellen dieser Zeile ausgerichtet werden.
ImageAlignFixed Ermittelt oder legt fest, wie Grafiken in fixierten
Zellen dieser Zeile ausgerichtet werden.
Index Gibt den Index dieser Zeile in der Rows-Collection
zurück.
IsNew Zeigt an, dass die Zeile ein Platzhalter für das
Hinzufügen von neuen Zeilen zur Tabelle darstellt.
IsNode
Unterstützt vom .NET-Compact-Framework.
Node
Unterstützt vom .NET-Compact-Framework.
Ermittelt oder legt fest, ob diese Zeile eine
Knotenzeile in einer Gliederung ist.
Gibt ein Node-Objekt zurück.

AllowDragging-Eigenschaft (Row) · 325
SafeIndex Gibt den Index dieser Zeile in der Rows-Collection
zurück.
Selected Ermittelt oder legt fest, ob diese Zeile ausgewählt ist.
Style Ermittelt oder legt fest, welches Format verwendet
wird, um die Zeile anzuzeigen.
StyleDisplay Ermittelt das für die Anzeige der Zelle verwendete
Format.
StyleNew Ermittelt das benutzerdefinierte Format, das mit
dieser Zeile verknüpft ist, und erstellt, wenn nötig,
eine neue Formatvorlage.
Top
Unterstützt vom .NET-Compact-Framework.
Gibt die Position der oberen Grenze dieser Zeile in
Pixeln, relativ zur Tabelle zurück. (berücksichtigt
nicht den Bildlauf)
UserData Ermittelt oder legt die mit dieser Zeile verknüpften
Benutzerdaten fest.
Visible Ermittelt oder legt die Sichtbarkeit dieser Zeile fest.
Row-Klassenmethoden (public)
Clear
Unterstützt vom .NET-Compact-Framework.
Löscht die Inhalte dieser Zeile.
Move Verschiebt diese Zeile in der Collection auf eine
neue Position.
Row-Eigenschaften
AllowDragging-Eigenschaft (Row)
Ermittelt oder legt fest, ob der Nutzer diese Zeile mit der Maus ziehen darf.
Syntax
[VB]
Public AllowDragging As Boolean
[C#]
public bool AllowDragging {get; set;}
[Delphi]
property AllowDragging: Boolean;
Bemerkungen
Die Tabelle besitzt eine AllowDragging-Eigenschaft, die festlegt, ob Zeilen und Spalten gezogen werden
können. Die AllowDragging-Eigenschaft von Row- und Column-Objekten wird verwendet, um den
Nutzer daran zu hindern, bestimmte Zeilen und Spalten von ihrer eigentlichen Position zu ziehen.

326 · C1FlexGrid-Referenzverzeichnis
Schauen Sie ferner unter
Row-Klasse (Seite 324)
AllowEditing-Eigenschaft (Row)
Ermittelt oder legt fest, ob der Nutzer die Zellen dieser Zeilen bearbeiten darf.
Syntax
[VB]
Public AllowEditing As Boolean
[C#]
public bool AllowEditing {get; set;}
[Delphi]
property AllowEditing: Boolean;
Bemerkungen
Die Tabelle besitzt eine AllowEditing-Eigenschaft, die festlegt, ob Zellen bearbeitet werden können. Die
AllowEditing-Eigenschaft von Row- und Column-Objekten wird verwendet, um den Nutzer daran zu
hindern, Zellen in bestimmten Zeilen und Spalten zu bearbeiten.
Schauen Sie ferner unter
Row-Klasse (Seite 324)
AllowMerging-Eigenschaft (Row)
Ermittelt oder legt fest, ob die Zellen mit den benachbarten Zellen dieser Zeile verbunden werden.
Syntax
[VB]
Public AllowMerging As Boolean
[C#]
public bool AllowMerging {get; set;}
[Delphi]
property AllowMerging: Boolean;
Bemerkungen
Die Tabelle besitzt eine AllowMerging-Eigenschaft, die festlegt, ob Zellen verbunden werden können.
Die AllowMerging-Eigenschaft von Row- und Column-Objekten wird verwendet, um Zellen mit
angrenzenden Zellen in bestimmten Zeilen und Spalten zu verbinden.
Schauen Sie ferner unter
Row-Klasse (Seite 324)

AllowResizing-Eigenschaft (Row)
AllowResizing-Eigenschaft (Row) · 327
Ermittelt oder legt fest, ob der Nutzer die Größe dieser Zeile mit der Maus verändern darf.
Syntax
[VB]
Public AllowResizing As Boolean
[C#]
public bool AllowResizing {get; set;}
[Delphi]
property AllowResizing: Boolean;
Bemerkungen
Die Tabelle besitzt eine AllowResizing-Eigenschaft, die festlegt, ob die Größe von Zeilen und Spalten mit
Ziehen der Kanten der Überschriftszelle verändert werden kann. Die AllowResizing-Eigenschaft von
Row- und Column-Objekten wird verwendet, um den Nutzer daran zu hindern, die Größe von
bestimmten Zeilen und Spalten zu ändern.
Schauen Sie ferner unter
Row-Klasse (Seite 324)
Bottom-Eigenschaft
Gibt die Position der unteren Grenze dieser Zeile in Pixeln, relativ zur Tabelle zurück. (berücksichtigt
nicht den Bildlauf)
Syntax
[VB]
Public Bottom As Integer
[C#]
public int Bottom {get;}
[Delphi]
property Bottom: Integer;
Bemerkungen
Der zurückgegebene Wert ist die Summe der Zeilenhöhen vom oberen Ende der Tabelle. Um vertikalen
Bildlauf in Betracht zu ziehen, müssen Sie den Wert mit Hilfe der ScrollPosition-Tabelleneigenschaft
anpassen.
Verwenden Sie die GetCellRect-Methode, um die Größe und Position einer Zelle abzufragen.
Schauen Sie ferner unter
Row-Klasse (Seite 324)

328 · C1FlexGrid-Referenzverzeichnis
Caption-Eigenschaft (Row)
Ermittelt oder legt den Text der ersten fixierten Zelle in dieser Zeile fest.
Syntax
[VB]
Public Caption As String
[C#]
public string Caption {get; set;}
[Delphi]
property Caption: string;
Schauen Sie ferner unter
Row-Klasse (Seite 324)
DataIndex-Eigenschaft (Row)
Gibt die Position dieser Zeile, ausschließlich der fixierten und Knotenzeilen, in der Rows-Collection
zurück.
Syntax
[VB]
Public DataIndex As Integer
[C#]
public int DataIndex {get;}
[Delphi]
property DataIndex: Integer;
Bemerkungen
Diese Eigenschaft gibt –1 zurück, wenn die Zeile fixiert oder eine Knotenzeile ist.
Wenn die Tabelle an eine Datenquelle gebunden ist, dann kann der Rückgabewert als ein Indizierer in
dieser Quelle verwendet werden, um einen Verweis auf das an diese Zeile gebundene Element zu
erhalten.
Sie können das zugrunde liegende Datenobjekt auch direkt mit der DataSource-Eigenschaft der Zeile
abfragen.
Schauen Sie ferner unter
Row-Klasse (Seite 324)
Index-Eigenschaft (Row) (Seite 331)
DataSource-Eigenschaft (Row) (Seite 329)
SafeIndex-Eigenschaft (Row) (Seite 334)

DataSource-Eigenschaft (Row)
Gibt das Objekt zurück, welches die Daten für diese Zeile zur Verfügung stellt.
Syntax
[VB]
Public DataSource As Object
[C#]
public object DataSource {get;}
[Delphi]
property DataSource: Object;
Bemerkungen
DataSource-Eigenschaft (Row) · 329
Der Type des zurückgegebenen Objekts hängt vom Typ der, der Tabelle zugeordneten, DataSource ab.
Zum Beispiel, wenn die Tabelle an ein DataView-Objekt gebunden ist, dann wird diese Eigenschaft das
entsprechende DataRowView-Objekt zurückgeben, welches an diese Zeile gebunden ist.
Diese Eigenschaft gibt Null zurück („Nothing“ in VB), wenn die Tabelle ungebunden ist oder die Zeile
fixiert oder eine Knotenzeile ist, die zu keinem Objekt in der Datenquelle der Tabelle verknüpft ist.
Schauen Sie im GetUnboundValue-Ereignis für ein Beispiel nach.
Schauen Sie ferner unter
Row-Klasse (Seite 324)
Index-Eigenschaft (Row) (Seite 331)
DataIndex-Eigenschaft (Row) (Seite 328)
SafeIndex-Eigenschaft (Row) (Seite 334)
Editor-Eigenschaft (Row)
Ermittelt oder legt den benutzerdefinierten Editor fest, der für die Bearbeitung der Zellen in dieser Zeile
verwendet werden soll.
Syntax
[VB]
Public Editor As Control
[C#]
public Control Editor {get;set;}
[Delphi]
property Editor: Control;
Bemerkungen
Die Tabelle stellt einige integrierte Editoren zur Verfügung, aus denen automatisch einer aufgrund der
Eigenschaften der zu bearbeitenden Zelle ausgewählt wird.

330 · C1FlexGrid-Referenzverzeichnis
Mit dieser Eigenschaft können Sie für die Bearbeitung der Zellen einer gegebenen Zeile externe Editoren
verwenden. Es kann zwar jede beliebige Steuerung als externer Editor verwendet werden, um aber eine
vollständige Integration mit der Tabelle sicher zustellen, sollte der externe Editor die
IC1EmbeddedEditor-Schnittstelle implementieren.
Für weitere Einzelheiten, schauen Sie bitte unter Editor-Eigenschaft nach.
Schauen Sie ferner unter
Editor-Eigenschaft (Column) (Seite 349)
IC1EmbeddedEditor-Schnittstelle (Seite 446)
Height-Eigenschaft
Ermittelt oder legt die Höhe dieser Zeile in Pixeln fest. Gibt -1 zurück, wenn die Zeile die Standardhöhe
hat.
Syntax
[VB]
Public Height As Integer
[C#]
public int Height {get; set;}
[Delphi]
property Height: Integer;
Bemerkungen
Wenn Height auf -1 gesetzt wird, dann verwendet die Tabelle die Standardhöhe aus Rows.DefaultSize
für diese Zeile.
Height gibt die der Zeile zugeordnete Höhe zurück, auch wenn diese ausgeblendet ist und -1, wenn die
entsprechende Zeile die Standardhöhe besitzt. Verwenden Sie die HeightDisplay-Eigenschaft, um die
wirklich angezeigte und damit sichtbare Höhe einer Zeile abzufragen.
Schauen Sie ferner unter
Row-Klasse (Seite 324)
HeightDisplay-Eigenschaft
Ermittelt oder legt die angezeigte Höhe dieser Zeile in Pixel fest.
Syntax
[VB]
Public HeightDisplay As Integer
[C#]
public int HeightDisplay {get; set;}
[Delphi]
property HeightDisplay: Integer;

Bemerkungen
ImageAlign-Eigenschaft (Row) · 331
HeightDisplay gibt die dem Nutzer wirklich angezeigte Zeilenhöhe unter Berücksichtigung der
Standardhöhe und der Zeilensichtbarkeit zurück. Siehe auch Height-Eigenschaft.
Schauen Sie ferner unter
Row-Klasse (Seite 324)
ImageAlign-Eigenschaft (Row)
Ermittelt oder legt fest, wie Grafiken in scrollbaren Zellen dieser Zeile ausgerichtet werden.
Syntax
[VB]
Public-Eigenschaft ImageAlign As C1.Win.C1FlexGrid.ImageAlignEnum
[C#]
public ImageAlignEnum ImageAlign {get; set;}
[Delphi]
property ImageAlign: ImageAlignEnum;
Schauen Sie ferner unter
Row-Klasse (Seite 324)
ImageAlign-Eigenschaft (Column) (Seite 352)
ImageAlignFixed-Eigenschaft (Row)
Ermittelt oder legt fest, wie Grafiken in fixierten Zellen dieser Zeile ausgerichtet werden.
Syntax
[VB]
Public-Eigenschaft ImageAlignFixed As C1.Win.C1FlexGrid.ImageAlignEnum
[C#]
public ImageAlignEnum ImageAlignFixed {get; set;}
[Delphi]
property ImageAlignFixed: ImageAlignEnum;
Schauen Sie ferner unter
Row-Klasse (Seite 324)
ImageAlignFixed-Eigenschaft (Column) (Seite 352)
Index-Eigenschaft (Row)
Gibt den Index dieser Zeile in der Rows-Collection zurück.
Syntax

332 · C1FlexGrid-Referenzverzeichnis
[VB]
Public Index As Integer
[C#]
public int Index {get;}
[Delphi]
property Index: Integer;
Bemerkungen
Gibt –1 zurück, wenn die Zeile nicht Mitglied der Collection ist.
Siehe auch SafeIndex- und DataIndex-Eigenschaften.
• Visual Basic
• C#
Dim row As Row = _flex.Rows(12)
Console.WriteLine("*** Row index is {0}", row.Index)
Row row = _flex.Rows[12];
Console.WriteLine("*** Row index is {0}", row.Index);
*** Row index is 12
• Delphi
var
r: Row;
begin
r := _flex.Rows[12];
Console.WriteLine('*** Row index is {0}', r.Index);
end;
Schauen Sie ferner unter
Row-Klasse (Seite 324)
IsNew-Eigenschaft
Zeigt an, dass die Zeile ein Platzhalter für das Hinzufügen von neuen Zeilen zur Tabelle darstellt.
Syntax
[VB]
Public IsNew As Boolean
[C#]
public Bool IsNew {get; set;}
[Delphi]
property IsNew: Boolean;
Bemerkungen
Dies gilt nur für die letzte Zeile in der Tabelle und wenn die AllowAddNew-Eigenschaft auf TRUE steht.
In der ersten fixierten Spalte dieser Zeile steht ein Sternchen („*“).

Schauen Sie ferner unter
Row-Klasse (Seite 324)
IsNode-Eigenschaft
Ermittelt oder legt fest, ob diese Zeile eine Knotenzeile in einer Gliederung ist.
Syntax
[VB]
Public IsNode As Boolean
[C#]
public bool IsNode {get; set;}
[Delphi]
property IsNode: Boolean;
Bemerkungen
IsNode-Eigenschaft · 333
Die IsNode-Eigenschaft legt fest, ob die Zeile einen Knoten in einem Gliederungsbaum darstellt. Sie
können diese Eigenschaft verwenden, um benutzerdefinierte Gliederungen zu erstellen, oder mit der
Subtotal-Methode der Tabelle die Gliederungen automatisch erstellen.
Schauen Sie ferner unter
Row-Klasse (Seite 324)
Node-Eigenschaft
Gibt ein Node-Objekt zurück.
Syntax
[VB]
Public Node As Node
[C#]
public Node Node {get;}
[Delphi]
property Node: Node;
Bemerkungen
Wenn die Zeile ein Knoten ist (IsNode = TRUE), dann gibt diese Eigenschaft ein Node-Objekt zurück,
dass unter anderem dazu verwendet werden kann, diesen Knoten ein- oder auszuklappen oder dessen
Ebene in der Gliederung festzulegen. Wenn die Zeile kein Knoten ist (IsNode = FALSE), dann wird der
Überknoten dieser Zeile zurückgegeben.
Schauen Sie ferner unter
Row-Klasse (Seite 324)

334 · C1FlexGrid-Referenzverzeichnis
SafeIndex-Eigenschaft (Row)
Gibt den Index dieser Zeile in der Rows-Collection zurück.
Syntax
[VB]
Public SafeIndex As Integer
[C#]
public int SafeIndex {get;}
[Delphi]
property SafeIndex: Integer;
Bemerkungen
Diese Eigenschaft ist ähnlich der Index-Eigenschaft, nur dass diese eine Exception ausgibt, wenn die
Zeile kein Mitglied der Collection ist.
Schauen Sie ferner unter
Row-Klasse (Seite 324)
Selected-Eigenschaft (Row)
Ermittelt oder legt fest, ob diese Zeile ausgewählt ist.
Syntax
[VB]
Public Selected As Boolean
[C#]
public bool Selected {get; set;}
[Delphi]
property Selected: Boolean;
Bemerkungen
Verwenden Sie diese Eigenschaft um den Auswahlstatus für eine einzelne Zeile abzufragen oder
festzulegen, wenn die SelectionMode-Eigenschaft der Tabelle auf SelectionModeEnum.ListBox steht.
Schauen Sie ferner unter
Row-Klasse (Seite 324)
Style-Eigenschaft (Row)
Ermittelt oder legt fest, welches Format verwendet wird, um die Zeile anzuzeigen.
Syntax
[VB]
Public Style As CellStyle

[C#]
public CellStyle Style {get; set;}
[Delphi]
property Style: CellStyle;
Bemerkungen
StyleDisplay-Eigenschaft (Row) · 335
Wenn die Zeile ein eigenes Format besitzt, dann wird dieses von dieser Eigenschaft zurückgegeben.
Andernfalls wird Null zurückgegeben.
Siehe auch StyleDisplay und StyleNew-Eigenschaften.
Schauen Sie ferner unter
Row-Klasse (Seite 324)
StyleDisplay-Eigenschaft (Row)
Ermittelt das für die Anzeige der Zelle verwendete Format.
Syntax
[VB]
Public StyleDisplay As CellStyle
[C#]
public CellStyle StyleDisplay {get;}
[Delphi]
property StyleDisplay: CellStyle;
Bemerkungen
Wenn die Zeile ein eigenes Format besitzt, dann wird dieses von dieser Eigenschaft zurückgegeben.
Andernfalls wird das für diese Zeile verwendete Standardformat (z.B. Normal, Alternate, Fixed)
wiedergegeben.
Schauen Sie ferner unter
Row-Klasse (Seite 324)
StyleNew-Eigenschaft (Row)
Ermittelt das benutzerdefinierte Format, dass mit dieser Zeile verknüpft ist, und erstellt, wenn nötig, eine
neue Formatvorlage.
Syntax
[VB]
Public StyleNew As CellStyle
[C#]
public CellStyle StyleNew {get;}

336 · C1FlexGrid-Referenzverzeichnis
[Delphi]
property StyleNew: CellStyle;
Bemerkungen
Wenn die Zeile ein eigenes Format besitzt, dann wird dieses von dieser Eigenschaft zurückgegeben.
Andernfalls wird ein neues benutzerdefiniertes Format erstellt und ein Verweis auf dieses
wiedergegeben.
Schauen Sie ferner unter
Row-Klasse (Seite 324)
Top-Eigenschaft
Gibt die Position der oberen Grenze dieser Zeile in Pixeln, relativ zur Tabelle zurück. (berücksichtigt
nicht den Bildlauf)
Syntax
[VB]
Public Top As Integer
[C#]
public int Top {get;}
[Delphi]
property Top: Integer;
Bemerkungen
Der zurückgegebene Wert ist die Summe der Zeilenhöhen vom oberen Ende der Tabelle. Um vertikalen
Bildlauf in Betracht zu ziehen, müssen Sie den Wert mit Hilfe der ScrollPosition-Tabelleneigenschaft
anpassen.
Verwenden Sie die GetCellRect-Methode, um die Größe und Position einer Zelle abzufragen.
Schauen Sie ferner unter
Row-Klasse (Seite 324)
UserData-Eigenschaft (Row)
Ermittelt oder legt die mit dieser Zeile verknüpften Benutzerdaten fest.
Syntax
[VB]
Public UserData As Object
[C#]
public object UserData {get; set;}
[Delphi]
property UserData: Object;

Beispiel
Visible-Eigenschaft (Row) · 337
Der nachfolgende Quellcode sucht nach dem einer Zeile zugeordneten UserData und gibt den
entsprechenden Zeilenindex der Fundstelle zurück:
• Visual Basic
• C#
Private Function FindRow(fg As C1FlexGrid, data As Object) As Integer
' look for data in Row.UserData
Dim row As Row
For Each row In fg.Rows
If data.Equals(row.UserData) Then
Return row.Index
End If
Next row ' not found
Return - 1
End Function 'FindRow
private int FindRow(C1FlexGrid fg, object data)
{
// look for data in Row.UserData
foreach (Row row in fg.Rows)
if (data.Equals(row.UserData))
return row.Index;
}
• Delphi
// not found
return -1;
function Class1.FindRow(fg: C1FlexGrid; data: System.Object): Integer;
var
I: Integer;
r: Row;
begin
// look for data in Row.UserData
for I := 0 to fg.Rows.Count – 1 do
if (data.Equals(fg.Rows[I].UserData))
begin
Result := fg.Rows[I].Index;
exit;
end;
// not found
Result := -1;
end;
Bemerkungen
Der UserData-Wert wird von der Tabelle intern nicht verwendet. Dieser ist für zusätzliche Daten
reserviert, die Sie mit der Zeile verknüpfen wollen.
Schauen Sie ferner unter
Row-Klasse (Seite 324)
Visible-Eigenschaft (Row)
Ermittelt oder legt die Sichtbarkeit dieser Zeile fest.

338 · C1FlexGrid-Referenzverzeichnis
Syntax
[VB]
Public Visible As Boolean
[C#]
public bool Visible {get; set;}
[Delphi]
property Visible: Boolean;
Bemerkungen
Diese Eigenschaft gibt TRUE zurück, wenn die Zeile eine von Null verschiedene Höhe besitzt und auch
wenn diese aus dem sichtbaren Bereich gescrollt wurde. Verwenden Sie hingegen die TopRow- und
BottomRow-Eigenschaften, um festzustellen, ob eine Zeile derzeit auf dem Bildschirm angezeigt wird.
Schauen Sie ferner unter
Row-Klasse (Seite 324)
Row-Methoden
Clear-Methode (Row)
Löscht die Inhalte dieser Zeile.
Syntax
[VB]
Public Sub Clear(clearFlags As ClearFlags)
[C#]
public void Clear (ClearFlags clearFlags )
[Delphi]
procedure Clear(clearFlags: ClearFlags);
Parameter Beschreibung
flags
Bemerkungen
Ein oder mehrere Werte aus der ClearFlags-Aufzählung, die festlegen, was
gelöscht werden soll.
Verwenden Sie diese Methode um die Zeileneigenschaften (Höhe, Sichtbarkeit, Format, Nutzerdaten,
usw.) auf deren Standardwert zurückzusetzen. Diese Methode betrifft nicht die Inhalte der Zellen in der
Zeile.
Schauen Sie ferner unter
Row-Klasse (Seite 324)

Move-Methode (Row)
Verschiebt diese Zeile in der Collection auf eine neue Position.
Syntax
[VB]
Public Sub Move(indexNew As Integer)
[C#]
public void Move ( int indexNew )
[Delphi]
procedure Move(indexNew: Integer);
Parameter Beschreibung
indexNew Eine Integerzahl, welche die neue Position der Zeile festlegt.
Schauen Sie ferner unter
Row-Klasse (Seite 324)
Column-Klassen
Alle Column-Mitglieder
Column-Klasseneigenschaften (public)
Move-Methode (Row) · 339
AllowDragging Ermittelt oder legt fest, ob der Nutzer diese Spalte mit
der Maus ziehen darf.
AllowEditing Ermittelt oder legt fest, ob der Nutzer die Zellen dieser
Spalten bearbeiten darf.
AllowMerging Ermittelt oder legt fest, ob die Zellen mit den
benachbarten Zellen dieser Spalte verbunden werden.
AllowResizing Ermittelt oder legt fest, ob der Nutzer die Größe dieser
Spalte mit der Maus verändern darf.
AllowSorting
Unterstützt vom .NET-Compact-Framework.
Ermittelt oder legt fest, ob diese Spalte mit der Maus
sortiert werden darf.
Caption Ermittelt oder legt den Text der ersten fixierten Zelle in
dieser Spalte fest.
ComboList
Unterstützt vom .NET-Compact-Framework.
Ermittelt oder legt die Liste der Elemente fest, die vom
Auswahllisteneditor für diese Spalte verwendet wird.
DataIndex Gibt die Position dieser Spalte im Datenquellobjekt
zurück.

340 · C1FlexGrid-Referenzverzeichnis
DataMap
Unterstützt vom .NET-Compact-Framework.
DataType
Unterstützt vom .NET-Compact-Framework.
EditMask
Unterstützt vom .NET-Compact-Framework.
Ermittelt oder legt die Datenzuordnung fest, um die
Datenwerte in die anzuzeigenden Werte dieser Spalte
umzuwandeln.
Ermittelt oder legt den Datentyp dieser Spalte fest.
Ermittelt oder legt die zu verwendende Eingabemaske
für die Bearbeitung der Zellen in dieser Spalte fest.
Editor Ermittelt oder legt den benutzerdefinierten Editor fest,
der für die Bearbeitung der Zellen in dieser Spalte
verwendet werden soll.
Format
Unterstützt vom .NET-Compact-Framework.
ImageAlign
Unterstützt vom .NET-Compact-Framework.
Ermittelt oder legt eine Zeichenkette fest, die die
Formatierung der Daten in dieser Spalte bestimmt.
Ermittelt oder legt fest, wie Grafiken in scrollbaren
Zellen dieser Spalte ausgerichtet werden.
ImageAlignFixed Ermittelt oder legt fest, wie Grafiken in fixierten Zellen
dieser Spalte ausgerichtet werden.
ImageAndText
Unterstützt vom .NET-Compact-Framework.
ImageMap
Unterstützt vom .NET-Compact-Framework.
Legt fest, ob die Grafiken, die in der ImageMap der
Spalte gefunden werden, anstelle des oder zusätzlich
zum Zelltext angezeigt werden sollen.
Ermittelt oder legt die Datenzuordnung fest, um die
Datenwerte in die anzuzeigenden Grafiken dieser
Spalte umzuwandeln.
Index Gibt den Index dieser Spalte in der Cols-Collection
zurück.
Left
Unterstützt vom .NET-Compact-Framework.
Name
Unterstützt vom .NET-Compact-Framework.
Right
Unterstützt vom .NET-Compact-Framework.
Gibt die Position der linken Seite dieser Spalte in Pixels,
relativ zur Tabelle zurück.
Gibt oder legt den Namen dieser Spalte fest. Der Name
kann als Index im Cols-Eigenschaftsindizierer
verwendet werden.
Gibt die Position der rechten Seite dieser Spalte in
Pixeln, relativ zur Tabelle zurück.
SafeIndex Gibt den Index dieser Spalte in der Column-Collection
zurück.
Selected Ermittelt oder legt fest, ob diese Spalte ausgewählt ist.
Sort
Unterstützt vom .NET-Compact-Framework.
Legt fest, wie diese Spalte sortiert werden soll.
Style Ermittelt oder legt fest, welches Format verwendet wird,
um die Spalte anzuzeigen.
StyleFixed
Unterstützt vom .NET-Compact-Framework.
StyleFixedDisplay
Unterstützt vom .NET-Compact-Framework.
StyleFixedNew
Unterstützt vom .NET-Compact-Framework.
Gibt den Standard CellStyle zurück, mit dem fixierte
Zellen gezeichnet werden.
Gibt das Format zurück, mit dem fixierte Zellen in dieser
Spalte angezeigt werden.
Gibt das benutzerdefinierte Format zurück, das den
fixierten Zellen in dieser Spalte zugeordnet ist.

AllowDragging-Eigenschaft (Column) · 341
StyleNew Gibt das benutzerdefinierte Format zurück, das dieser
Spalte zugeordnet ist.
TextAlign
Unterstützt vom .NET-Compact-Framework.
TextAlignFixed
Unterstützt vom .NET-Compact-Framework.
Ermittelt oder legt fest, wie der Text in den Zellen dieser
Spalte ausgerichtet wird.
Ermittelt oder legt fest, wie der Text in den fixierten
Zellen dieser Spalte ausgerichtet wird.
UserData Ermittelt oder legt die mit dieser Spalte verknüpften
Benutzerdaten fest.
Visible Ermittelt oder legt die Sichtbarkeit dieser Spalte fest.
Width
Unterstützt vom .NET-Compact-Framework.
WidthDisplay
Unterstützt vom .NET-Compact-Framework.
Column-Klassenmethoden (public)
Clear
Unterstützt vom .NET-Compact-Framework.
Ermittelt oder legt die Breite dieser Spalte in Pixeln fest.
Ermittelt oder legt die angezeigte Breite dieser Spalte in
Pixeln fest.
Löscht die Inhalte dieser Spalte.
Move Verschiebt diese Spalte in der Collection auf eine neue
Position.
Column-Eigenschaften
AllowDragging-Eigenschaft (Column)
Ermittelt oder legt fest, ob der Nutzer diese Spalte mit der Maus ziehen darf.
Syntax
[VB]
Public AllowDragging As Boolean
[C#]
public bool AllowDragging {get; set;}
[Delphi]
property AllowDragging: Boolean;
Bemerkungen
Die Tabelle besitzt eine AllowDragging-Eigenschaft, die festlegt, ob Zeilen und Spalten gezogen werden
können. Die AllowDragging-Eigenschaft von Row- und Column-Objekten wird verwendet, um den
Nutzer daran zu hindern, bestimmte Zeilen und Spalten von ihrer eigentlichen Position zu ziehen.
Schauen Sie ferner unter
Column-Klasse (Seite 339)

342 · C1FlexGrid-Referenzverzeichnis
AllowEditing-Eigenschaft (Column)
Ermittelt oder legt fest, ob der Nutzer die Zellen dieser Spalten bearbeiten darf.
Syntax
[VB]
Public AllowEditing As Boolean
[C#]
public bool AllowEditing {get; set;}
[Delphi]
property AllowEditing: Boolean;
Bemerkungen
Die Tabelle besitzt eine AllowEditing-Eigenschaft, die festlegt, ob Zellen bearbeitet werden können. Die
AllowEditing-Eigenschaft von Row- und Column-Objekten wird verwendet, um den Nutzer daran zu
hindern, Zellen in bestimmten Zeilen und Spalten zu bearbeiten.
Schauen Sie ferner unter
Column-Klasse (Seite 339)
AllowMerging-Eigenschaft (Column)
Ermittelt oder legt fest, ob die Zellen mit den benachbarten Zellen dieser Spalte verbunden werden.
Syntax
[VB]
Public AllowMerging As Boolean
[C#]
public bool AllowMerging {get; set;}
[Delphi]
property AllowMerging: Boolean;
Bemerkungen
Die Tabelle besitzt eine AllowMerging-Eigenschaft, die festlegt, ob Zellen verbunden werden können.
Die AllowMerging-Eigenschaft von Row- und Column-Objekten wird verwendet, um Zellen mit
angrenzenden Zellen in bestimmten Zeilen und Spalten zu verbinden.
Schauen Sie ferner unter
Column-Klasse (Seite 339)
AllowResizing-Eigenschaft (Column)
Ermittelt oder legt fest, ob der Nutzer die Größe dieser Spalte mit der Maus verändern darf.

Syntax
[VB]
Public AllowResizing As Boolean
[C#]
public bool AllowResizing {get; set;}
[Delphi]
property AllowResizing: Boolean;
Bemerkungen
AllowSorting-Eigenschaft (Column) · 343
Die Tabelle besitzt eine AllowResizing-Eigenschaft, die festlegt, ob die Größe von Zeilen und Spalten mit
Ziehen der Kanten der Überschriftszelle verändert werden kann. Die AllowResizing-Eigenschaft von
Row- und Column-Objekten wird verwendet, um den Nutzer daran zu hindern, die Größe von
bestimmten Zeilen und Spalten zu ändern.
Schauen Sie ferner unter
Column-Klasse (Seite 339)
AllowSorting-Eigenschaft (Column)
Ermittelt oder legt fest, ob diese Spalte mit der Maus sortiert werden darf.
Syntax
[VB]
Public AllowSorting As Boolean
[C#]
public bool AllowSorting {get; set;}
[Delphi]
property AllowSorting: Boolean;
Bemerkungen
Die Tabelle besitzt eine AllowSorting-Eigenschaft, die festlegt, ob die Spalten mit einem Klick auf die
Überschriftszellen sortiert werden können. Die AllowSorting-Eigenschaft von Row- und Column-
Objekten wird verwendet, um den Nutzer daran zu hindern, bestimmte Spalten zu sortieren.
Schauen Sie ferner unter
Column-Klasse (Seite 339)
Caption-Eigenschaft
Ermittelt oder legt den Text der ersten fixierten Zelle in dieser Spalte fest.
Syntax
[VB]
Public Caption As String

344 · C1FlexGrid-Referenzverzeichnis
[C#]
public string Caption {get; set;}
[Delphi]
property Caption: string;
Schauen Sie ferner unter
Column-Klasse (Seite 339)
ComboList-Eigenschaft (Column)
Ermittelt oder legt die Liste der Elemente fest, die vom Auswahllisteneditor für diese Spalte verwendet
wird.
Syntax
[VB]
Public ComboList As String
[C#]
public string ComboList {get; set;}
[Delphi]
property ComboList: string;
Bemerkungen
Für Einzelheiten und Beispiele, schauen Sie bitte unter „Zellen bearbeiten“ (Seite 37)nach.
Schauen Sie ferner unter
Column-Klasse (Seite 339)
DataIndex-Eigenschaft (Column)
Gibt die Position dieser Spalte im Datenquellobjekt zurück.
Syntax
[VB]
Public DataIndex As Integer
[C#]
public int DataIndex {get;}
[Delphi]
property DataIndex: Integer;
Bemerkungen
In datengebundenen Tabellen besitzt jede Spalte einen Index zur Spalten-Collection (Cols) der Tabelle
und einen Index in die zugrundeliegende Datenquelle. Zum Beispiel, wenn eine Datenquelle drei Spalten

DataMap-Eigenschaft (Column) · 345
umfasst [Erste, Letzte, Mittlere] und Sie binden diese an eine Tabelle mit einer fixierten Spalte, dann
würde die DataIndex-Eigenschaft für jede Spalte wie folgt sein:
Tabellenindex Datenfeld DataIndex
0 (fixiert) -1
1 Erste 0
2 Letzte 1
3 Mittlere 2
Wenn der Nutzer anschließend die letzte Spalte (Mittlere) auf die erste Position zieht, dann würde die
DataIndex-Eigenschaft für jede Spalte wie folgt sein:
Tabellenindex Datenfeld DataIndex
0 (fixiert) -1
1 Mittlere 2
2 Erste 0
3
Anmerkung:
Letzte 1
Diese Eigenschaft gibt –1 zurück, wenn die Zeile fixiert ist.
Schauen Sie ferner unter
Column-Klasse (Seite 339)
DataMap-Eigenschaft (Column)
Ermittelt oder legt die Datenzuordnung (DataMap) fest, um die Datenwerte in die anzuzeigenden Werte
dieser Spalte umzuwandeln.
Syntax
[VB]
Public DataMap As IDictionary
[C#]
public IDictionary DataMap {get; set;}
[Delphi]
property DataMap: IDictionary;
Bemerkungen
Mit der DataMap-Eigenschaft können Sie „übersetzte” Spalten implementieren. In übersetzten Spalten
zeigt die Tabelle nicht die in der Zelle gespeicherten Werte an, sondern schlägt diese in der DataMap der
Spalte nach und zeigt die verknüpften Werte an.
Zum Beispiel können Sie die DataMap-Eigenschaft verwenden, um Produktschlüssel zu speichern, aber
stattdessen Produktnamen anzuzeigen:

346 · C1FlexGrid-Referenzverzeichnis
• Visual Basic
• C#
Dim employeeMap As New Hashtable()
Dim e As Employee
For Each e In EmployeeCollection
employeeMap.Add(e.ID, e.LastName)
Next e
flex.Cols(1).DataType = GetType(Employee)
flex.Cols(1).DataMap = employeeMap '
Hashtable employeeMap = new Hashtable();
foreach (Employee e in EmployeeCollection)
employeeMap.Add(e.ID, e.LastName);
flex.Cols[1].DataType = typeof(Employee);
flex.Cols[1].DataMap = employeeMap;
• Delphi
var
employeeMap: Hashtable;
I: Integer;
e: Employee;
begin
employeeMap := Hashtable.Create;
for I := 0 to EmployeeCollection.Count – 1 do
begin
e := Employee(EmployeeCollection[I]);
employeeMap.Add(System.Object(e.ID), System.Object(e.LastName));
end;
flex.Cols[1].DataType := TypeOf(Employee);
flex.Cols[1].DataMap := employeeMap;
end;
Die Tabelle verwendet die DataMap-Eigenschaft auch um die Auswahllisten zu füllen, wenn die Spalte
bearbeitbar ist.
Anmerkung: Die IDictionary-Schnittstelle ist im System.Collections-Namensbereich definiert und wird
unter anderem von der Hashtable-Klasse implementiert.
Schauen Sie ferner unter
Column-Klasse (Seite 339)
DataType-Eigenschaft
Ermittelt oder legt den Datentyp dieser Spalte fest.
Syntax
[VB]
Public DataType As Type
[C#]
public Type DataType {get; set;}
[Delphi]
property DataType: Type;

Bemerkungen
DataType-Eigenschaft · 347
Standardmäßig ist die DataType-Eigenschaft der Spalte auf object gesetzt, so dass Sie jeden beliebigen
Datenwert in der Spalte speichern können.
Wenn Sie DataType der Spalte auf einen bestimmten Typ setzen, dann wird die Tabelle versuchen, jeden
der Zellen dieser Spalte zugeordneten Werte in den entsprechenden Datentyp umzuwandeln. Wenn die
Umwandlung fehlschlägt, dann startet die Tabelle das GridError-Ereignis und der entsprechende
Zellwert bleibt unverändert.
Die DataType-Eigenschaft steuert, wie Werte intern in die Tabelle gespeichert werden, wie diese
gespeichert werden und betrifft den Steuerungstyp, der verwendet wird, um die Werte dieser Spalte zu
bearbeiten. Zum Beispiel, eine DateTimePicker-Steuerung wird verwendet um Werte in DateTime-
Spalten zu bearbeiten und Kontrollkästchen sind dafür da, um Wahrheitswerte in bearbeitbaren Boolean-
Spalten anzuzeigen.
Wenn Sie eine Zeit anstatt einem Datum in den Zellen einer Spalte speichern wollen, dann können Sie
immer noch den DateTime-Type verwenden. Sie sollten aber ein Format aussuchen, dass nur die Zeiten
und nicht das Datum anzeigt. Sie sollten außerdem verhindern, dass die Steuerung den DateTimePicker-
Editor verwendet, wenn die Spalte bearbeitbar ist. Dies kann erreicht werden, indem eine EditMask
verwendet wird oder der Editor im SetupEditor-Ereignis angepasst wird. Zum Beispiel:
• Visual Basic
• C#
' store times in column 1, use masked editor
fg.Cols(1).DataType = GetType(DateTime) '
fg.Cols(1).Format = "hh:mm tt"
fg.Cols(1).EditMask = "99:99 LL"
' store times in column 2, use DateTimePicker but prevent drop-down
fg.Cols(2).DataType = GetType(DateTime) '
fg.Cols(2).Format = "hh:mm tt"
Private Sub fg_SetupEditor(sender As Object, e As RowColEventArgs)
If e.Col = 2 Then
Dim ctl As DateTimePicker = flex.Editor '
If Not (ctl Is Nothing) Then
ctl.ShowUpDown = True
End If
End If
End Sub 'fg_SetupEditor
' store times in column 1, use masked editor
fg.Cols[1].DataType=typeof(DateTime);
fg.Cols[1].Format="hh:mm tt";
fg.Cols[1].EditMask="99:99 LL";
' store times in column 2, use DateTimePicker but prevent drop-down
fg.Cols[2].DataType=typeof(DateTime);
fg.Cols[2].Format="hh:mm tt";
private void fg_SetupEditor(object sender, RowColEventArgs e)
{
if (e.Col == 2)
{
DateTimePicker ctl = flex.Editor as DateTimePicker;
if (ctl != null)
ctl.ShowUpDown = true;
}
}

348 · C1FlexGrid-Referenzverzeichnis
• Delphi
// store times in column 1, use masked editor
fg.Cols[1].DataType := typeof(DateTime);
fg.Cols[1].Format := 'hh:mm tt';
fg.Cols[1].EditMask := '99:99 LL';
// store times in column 2, use DateTimePicker but prevent drop-down
fg.Cols[2].DataType := typeof(DateTime);
fg.Cols[2].Format := 'hh:mm tt';
procedure fg_SetupEditor(sender: System.Object; e: RowColEventArgs);
var
ctl: DateTimePicker;
begin
if e.Col = 2 then
begin
if ctl is DateTimePicker then
begin
ctl := DateTimePicker(flex.Editor);
ctl.ShowUpDown := True;
end;
end;
end; // fg_SetupEditor
Schauen Sie ferner unter
Column-Klasse (Seite 339)
EditMask-Eigenschaft (Column)
Ermittelt oder legt die zu verwendende Eingabemaske für die Bearbeitung der Zellen in dieser Spalte
fest.
Syntax
[VB]
Public EditMask As String
[C#]
public string EditMask {get; set;}
[Delphi]
property EditMask: string;
Bemerkungen
Die Tabelle besitzt auch eine EditMask-Eigenschaft, die auf die gesamte Tabelle angewandt wird.
Schauen Sie unter der EditMask-Eigenschaft der Tabelle und „Zellen bearbeiten“ (Seite 37) für
Einzelheiten über das Festlegen und die Verwendung von Eingabemasken nach.
Schauen Sie ferner unter
Column-Klasse (Seite 339)

Editor-Eigenschaft (Column)
Editor-Eigenschaft (Column) · 349
Ermittelt oder legt den benutzerdefinierten Editor fest, der für die Bearbeitung der Zellen in dieser Spalte
verwendet werden soll.
Syntax
[VB]
Public Editor As Control
[C#]
public Control Editor {get;set;}
[Delphi]
property Editor: Control;
Bemerkungen
Die Tabelle stellt einige integrierte Editoren zur Verfügung, aus denen automatisch einer aufgrund der
Eigenschaften der zu bearbeitenden Zelle ausgewählt wird.
Mit dieser Eigenschaft können Sie für die Bearbeitung der Zellen einer gegebenen Spalte externe Editoren
verwenden. Es kann zwar jede beliebige Steuerung als externer Editor verwendet werden, um aber eine
vollständige Integration mit der Tabelle sicherzustellen, sollte der externe Editor die
IC1EmbeddedEditor-Schnittstelle implementieren.
Sie können externe Editoren mit Spalten während der Designtime im Column Editor oder während der
Runtime verknüpfen.
Für weitere Einzelheiten, schauen Sie bitte unter Editor-Eigenschaft nach.
Schauen Sie ferner unter
Editor-Eigenschaft (Row) (Seite 329)
IC1EmbeddedEditor-Schnittstelle (Seite 446)
Format-Eigenschaft
Ermittelt oder legt eine Zeichenkette fest, welche die Formatierung der Daten in dieser Spalte bestimmt.
Syntax
[VB]
Public Format As String
[C#]
public string Format {get; set;}
[Delphi]
property Format: string;

350 · C1FlexGrid-Referenzverzeichnis
Bemerkungen
Die Format-Eigenschaft legt zwar fest, wie Werte für die Anzeige formatiert werden, betrifft aber nicht
die intern gespeicherten Werte. Verwenden Sie die GetDataDisplay-Eigenschaft, um die formatierten
Werte von Zellen abzurufen.
Die Format-Zeichenkette besitzt die gleiche Semantik wie die Formatierungsargumente in der .NET
String.Format-Methode. Für Einzelheiten und ein vollständiges Beispiel schauen Sie bitte in der .NET
Dokumentation nach. Eine kurze Übersicht über die am häufigsten verwendeten Optionen wird
nachfolgend gegeben.
Formatierung von numerischen Werten
Die folgenden Zeichenketten können verwendet werden, um Zahlen zu formatieren:
Zeichenkette Name Beschreibung
C oder c Währung Die Zahl wird in eine Zeichenkette umgewandelt, die einen
angepassten Währungsbetrag anzeigt.
E oder e Exponentialzahl Die Zahl wird in eine Zeichenkette der Form "-d.ddd…E+ddd" oder
"-d.ddd…e+ddd" umgewandelt, wobei jedes 'd' für eine Zahl
zwischen 0 und 9 steht.
F oder f Gleitkommazahl Die Zahl wird in eine Zeichenkette umgewandelt, die eine
Gleitkommazahl mit einer festgelegten Anzahl an Dezimalstellen
anzeigt.
N oder n Nummer Die Zahl wird in eine Zeichenkette umgewandelt, die eine
Kommazahl mit einer festgelegten Anzahl an Dezimalstellen und
1000er-Trennzeichen anzeigt.
P oder p Prozentzahl Die Zahl wird in eine Zeichenkette umgewandelt, die eine
Prozentzahl anzeigt.
Mit den folgenden Zeichen können Sie auch eigene Formate erstellen:
Zeichen Name Beschreibung
0 Nullplatzhalter Wenn ein formatierter Wert eine Ziffer an der Stelle besitzt, wo die
Formatierungszeichenkette eine Null aufweist, dann wird diese Ziffer
in die endgültige Zeichenkette kopiert. Die Position der am weitesten
links stehenden '0' vor dem Dezimalpunkt und die am weitesten
rechts stehende '0' nach dem Dezimalpunkt legt den Ziffernbereich
(Stellenanzahl) der endgültigen Zeichenkette fest.
# Ziffernplatzhalter Wenn ein formatierter Wert eine Ziffer an der Stelle besitzt, wo die
Formatierungszeichenkette ein ’#’ aufweist, dann wird diese Ziffer in
die endgültige Zeichkette kopiert. Andernfalls wird keine Ziffer an
dieser Stelle der endgültigen Zeichenkette gespeichert.
. Dezimalpunkt Das erste '.'-Zeichen in der Formatierungszeichenkette legt die
Position des lokal angepassten Dezimaltrennzeichens im formatierten
Wert fest. Jedes weitere '.'-Zeichen wird ignoriert.
, 1000er-
Trennzeichen
1000er-Trennzeichen werden zwischen jeder Dreiergruppe an Ziffern,
beginnend links neben dem Dezimaltrennzeichen, eingefügt. Wenn
die formatierte Zeichenkette ein oder mehrere ','-Zeichen direkt links

Format-Eigenschaft · 351
neben dem Dezimalpunkt besitzt, dann wird die Zahl durch die
Anzahl der ','-Zeichen, multipliziert mit 1000, geiteilt, bevor diese
formatiert wird.
% Prozentplatzhalter Wenn die Formatierungszeichenkette ein '%'-Zeichen enthält, dann
wir die Zahl mit 100 multipliziert, bevor sie formatiert wird.
; Abschnittstrennzeichen
Formatierung von Datumswerten
Das ';'-Zeichen wird verwendet, um Abschnitte für positive, negative
und Nullwerte in der Formatierungszeichenkette abzugrenzen.
Die folgenden Zeichenketten können verwendet werden, um Zeit und Datum zu formatieren:
String Name
d Kurzes Datum
D Langes Datum
t Kurze Zeit
T Lange Zeit
Mit den folgenden Zeichen können Sie auch eigene Formate erstellen:
Zeichen Beschreibung
d Zeigt den aktuellen Tag des Monats an, als eine Zahl zwischen 1 und 31. Wenn der Tag
nur eine Ziffer (1-9) hat, dann wird auch nur eine angezeigt.
dd Zeigt den aktuellen Tag des Monats an, als eine Zahl zwischen 1 und 31. Wenn der Tag
nur eine Ziffer hat, dann wird diese mit einer voranstehenden 0 (01-09) angezeigt.
ddd Zeigt den abgekürzten Namen des Tages an.
dddd Zeigt den vollständigen Namen des Tages an.
M Zeigt den aktuellen Monat an, als eine Zahl zwischen 1 und 12. Wenn der Monat nur eine
Ziffer (1-9) hat, dann wird auch nur eine angezeigt.
MM Zeigt den aktuellen Monat an, als eine Zahl zwischen 1 und 12. Wenn der Monat nur eine
Ziffer hat, dann wird dieser mit einer voranstehenden 0 (01-09) angezeigt.
MMM Zeigt den abgekürzten Namen des Monats an.
MMMM Zeigt den vollständigen Namen des Monats an.
y Zeigt das Jahr in maximal zwei Ziffern an. Die ersten zwei Ziffern werden unterdrückt.
Wenn das Jahr nur eine Ziffer (1-9) hat, dann wird auch nur eine angezeigt.
yy Zeigt das Jahr in zwei Zifern an. Die ersten zwei Ziffern werden unterdrückt. Wenn das
Jahr nur eine Ziffer hat, dann wird dieses mit einer voranstehenden 0 (01-09) angezeigt.
yyyy Zeigt die vollständige Jahreszahl mit vier Ziffern an.
/ Ortsgebundenes Datumstrennzeichen.

352 · C1FlexGrid-Referenzverzeichnis
Schauen Sie ferner unter
Column-Klasse (Seite 339)
ImageAlign-Eigenschaft (Column)
Ermittelt oder legt fest, wie Grafiken in scrollbaren Zellen dieser Spalte ausgerichtet werden.
Syntax
[VB]
Public ImageAlign As ImageAlignEnum
[C#]
public ImageAlignEnum ImageAlign {get; set;}
[Delphi]
property ImageAlign: ImageAlignEnum;
Bemerkungen
Diese Eigenschaft verknüpft zu dem, dieser Spalte zugeordneten CellStyle. Zum Beispiel:
• Visual Basic
• C#
flex.Cols(1).ImageAlign = ImageAlignEnum.RightTop '
Console.WriteLine(flex.Cols(1).Style.ImageAlign)
ImageAlignEnum.RightTop
flex.Cols[1].ImageAlign = ImageAlignEnum.RightTop;
Console.WriteLine(flex.Cols[1].Style.ImageAlign);
ImageAlignEnum.RightTop
• Delphi
flex.Cols[1].ImageAlign := ImageAlignEnum.RightTop;
Console.WriteLine(flex.Cols[1].Style.ImageAlign);
ImageAlignEnum.RightTop;
Schauen Sie ferner unter
Column-Klasse (Seite 339)
ImageAlign-Eigenschaft (Row) (Seite 331)
ImageAlignFixed-Eigenschaft (Column)
Ermittelt oder legt fest, wie Grafiken in fixierten Zellen dieser Spalte ausgerichtet werden.
Syntax
[VB]
Public-Eigenschaft ImageAlignFixed As C1.Win.C1FlexGrid.ImageAlignEnum
[C#]
public ImageAlignEnum ImageAlignFixed {get; set;}

[Delphi]
property ImageAlignFixed: ImageAlignEnum;
Schauen Sie ferner unter
Column-Klasse (Seite 339)
ImageAlignFixed-Eigenschaft (Row) (Seite 331)
ImageAndText-Eigenschaft
ImageAndText-Eigenschaft · 353
Legt fest, ob die Grafiken, die in der ImageMap der Spalte gefunden werden, anstelle oder zusätzlich
zum Zelltext angezeigt werden sollen.
Syntax
[VB]
Public ImageAndText As Boolean
[C#]
public bool ImageAndText {get; set;}
[Delphi]
property ImageAndText: Boolean;
Schauen Sie ferner unter
Column-Klasse (Seite 339)
ImageMap-Eigenschaft (Column) (Seite 353)
ImageMap-Eigenschaft (Column)
Ermittelt oder legt die Datenzuordnung fest, um die Datenwerte in die anzuzeigenden Grafiken dieser
Spalte umzuwandeln.
Syntax
[VB]
Public ImageMap As IDictionary
[C#]
public IDictionary ImageMap {get; set;}
[Delphi]
property ImageMap: IDictionary;
Bemerkungen
Verwenden Sie diese Eigenschaft um Datenwerte in einer Spalte mit Grafiken zu verknüpfen. Zum
Beispiel, wenn eine Spalte Ländernamen beinhaltet, dann können Sie diese Eigenschaft verwenden, um
die entsprechend dazugehörige Länderfahne anzuzeigen.
Verwenden Sie die ImageAndText-Eigenschaft um festzulegen, ob die Steuerung die Grafik zusätzlich
oder anstelle des Zelltextes anzeigen soll.

354 · C1FlexGrid-Referenzverzeichnis
Der nachfolgende Quellcode zeigt, wie Sie ein ImageMap für eine Spalte einrichten können. Das Beispiel
geht davon aus, dass Sie eine ImageList-Steuerung erstellt und diese mit den Grafiken der Länderfahnen
gefüllt haben:
• Visual Basic
• C#
Private Enum Countries
Australia
Brazil
Canada
Denmark
France
Germany
Italy
Japan
Korea
Mexico
Netherlands
Portugal
Russia
Spain
Turkey
USA
End Enum 'Countries
' set up image map
Dim imgMap As New Hashtable()
For i = 0 To imgListFlags.Images.Count - 1
imgMap.Add(CType(i, Countries), imgListFlags.Images(i))
Next i
Dim col As Column = flex.Cols("countries")
col.ImageMap = imgMap
col.ImageAndText = False
col.ImageAlign = ImageAlignEnum.CenterCenter
private enum Countries
{
Australia, Brazil, Canada, Denmark, France,
Germany, Italy, Japan, Korea, Mexico,
Netherlands, Portugal, Russia, Spain, Turkey, USA
};
// set up image map
Hashtable imgMap = new Hashtable();
for (i = 0; i < imgListFlags.Images.Count; i++)
imgMap.Add((Countries)i, imgListFlags.Images[i]);
Column col = flex.Cols["countries"];
col.ImageMap = imgMap;
col.ImageAndText = false;
col.ImageAlign = ImageAlignEnum.CenterCenter;
• Delphi
type
Countries = (Australia, Brazil, Canada, Denmark, France, Germany,
Italy, Japan, Korea, Mexico, Netherlands, Portugal, Russia, Spain,
Turkey, USA);
var
col: Column;
imgMap: Hashtable;
begin
imgMap := Hashtable.Create;

for i := 0 to imgListFlags.Images.Count – 1 do
imgMap.Add(System.Object(i), imgListFlags.Images[i]);
col := flex.Cols['countries'];
col.ImageMap := imgMap;
col.ImageAndText := False;
col.ImageAlign := ImageAlignEnum.CenterCenter;
end;
Schauen Sie ferner unter
Column-Klasse (Seite 339)
Index-Eigenschaft (Column)
Gibt den Index dieser Spalte in der Cols-Collection zurück.
Syntax
[VB]
Public Index As Integer
[C#]
public int Index {get;}
[Delphi]
property Index: Integer;
Bemerkungen
Gibt –1 zurück, wenn die Spalte nicht Mitglied der Collection ist.
Schauen Sie ferner unter
Column-Klasse (Seite 339)
SafeIndex-Eigenschaft (Column) (Seite 357)
Left-Eigenschaft
Index-Eigenschaft (Column) · 355
Gibt die Position der linken Seite dieser Spalte in Pixeln, relativ zur Tabelle zurück. (berücksichtigt nicht
den Bildlauf)
Syntax
[VB]
Public Left As Integer
[C#]
public int Left {get;}
[Delphi]
property Left: Integer;
Bemerkungen

356 · C1FlexGrid-Referenzverzeichnis
Der zurückgegebene Wert ist die Summe der Spaltenbreiten von der linken Seite der Tabelle. Um
horizontalen Bildlauf in Betracht zu ziehen, müssen Sie den Wert mit Hilfe der ScrollPosition-
Tabelleneigenschaft anpassen.
Verwenden Sie die GetCellRect-Methode, um die Größe und Position einer Zelle abzufragen.
Schauen Sie ferner unter
Column-Klasse (Seite 339)
Name-Eigenschaft (Column)
Gibt oder legt den Namen dieser Spalte zurück/fest. Der Name kann als Index im Cols-
Eigenschaftsindizierer verwendet werden.
Syntax
[VB]
Public Name As String
[C#]
public string Name {get; set;}
[Delphi]
property Name: string;
Bemerkungen
Wenn die Tabelle an eine DataSource gebunden ist, dann werden die Spaltennamen automatisch gesetzt.
Schauen Sie ferner unter
Column-Klasse (Seite 339)
Right-Eigenschaft
Gibt die Position der rechten Seite dieser Spalte in Pixeln, relativ zur Tabelle zurück. (berücksichtigt nicht
den Bildlauf)
Syntax
[VB]
Public Right As Integer
[C#]
public int Right {get;}
[Delphi]
property Right: Integer;
Bemerkungen
Der zurückgegebene Wert ist die Summe der Spaltenbreiten von der linken Seite der Tabelle. Um
horizontalen Bildlauf in Betracht zu ziehen, müssen Sie den Wert mit Hilfe der ScrollPosition-
Tabelleneigenschaft anpassen.

SafeIndex-Eigenschaft (Column) · 357
Verwenden Sie die GetCellRect-Methode, um die Größe und Position einer Zelle abzufragen.
Schauen Sie ferner unter
Column-Klasse (Seite 339)
SafeIndex-Eigenschaft (Column)
Gibt den Index dieser Spalte in der Column-Collection zurück.
Syntax
[VB]
Public SafeIndex As Integer
[C#]
public int SafeIndex {get;}
[Delphi]
property SafeIndex: Integer;
Bemerkungen
Diese Eigenschaft ist ähnlich der Index-Eigenschaft, nur dass diese eine Exception ausgibt, wenn die
Spalte kein Mitglied der Collection ist.
Schauen Sie ferner unter
Column-Klasse (Seite 339)
Selected-Eigenschaft (Column)
Ermittelt oder legt fest, ob diese Spalte ausgewählt ist.
Syntax
[VB]
Public Selected As Boolean
[C#]
public bool Selected {get; set;}
[Delphi]
property Selected: Boolean;
Schauen Sie ferner unter
Column-Klasse (Seite 339)
Sort-Eigenschaft (Column)
Legt fest, wie diese Spalte sortiert werden soll.

358 · C1FlexGrid-Referenzverzeichnis
Syntax
[VB]
Public Sort As SortFlags
[C#]
public SortFlags Sort {get; set;}
[Delphi]
property Sort: SortFlags;
Bemerkungen
Diese Eigenschaft wird verwendet, wenn Sie die Sort-Methode aufrufen und die SortFlags.UseColSort-
Flag nutzen.
Schauen Sie ferner unter
Column-Klasse (Seite 339)
Sort-Eigenschaft (C1FlexGridClassic) (Seite 518)
Style-Eigenschaft (Column)
Ermittelt oder legt fest, welches Format verwendet wird, um die Spalte anzuzeigen.
Syntax
[VB]
Public Style As CellStyle
[C#]
public CellStyle Style {get; set;}
[Delphi]
property Style: CellStyle;
Bemerkungen
Wenn die Spalte ein eigenes Format besitzt, dann wird es von dieser Eigenschaft zurückgegeben.
Andernfalls wird Null wiedergegeben.
Siehe auch StyleDisplay und StyleNew-Eigenschaften.
Schauen Sie ferner unter
Column-Klasse (Seite 339)
StyleDisplay-Eigenschaft (Column)
Ermittelt das Format, welches verwendet wird, um die scrollbaren Zellen in dieser Spalte anzuzeigen
Syntax
[VB]
Public StyleDisplay As CellStyle

[C#]
public CellStyle StyleDisplay {get;}
[Delphi]
property StyleDisplay: CellStyle;
Bemerkungen
StyleFixed-Eigenschaft · 359
Wenn die Spalte ein eigenes Format besitzt, dann wird es von dieser Eigenschaft zurückgegeben.
Andernfalls wird das für diese Spalte verwendete Standardformat (z.B. Normal, Alternate, Fixed)
wiedergegeben.
Schauen Sie ferner unter
Column-Klasse (Seite 339)
StyleFixed-Eigenschaft
Gibt den Standard CellStyle zurück, mit dem fixierte Zellen gezeichnet werden.
Syntax
[VB]
Public StyleFixed As CellStyle
[C#]
public CellStyle StyleFixed {get;}
[Delphi]
property StyleFixed: CellStyle;
Schauen Sie ferner unter
Column-Klasse (Seite 339)
Styles-Eigenschaft (Seite 170)
StyleFixedDisplay-Eigenschaft
Gibt das Format zurück, mit dem fixierte Zellen in dieser Spalte angezeigt werden.
Syntax
[VB]
Public StyleFixedDisplay As CellStyle
[C#]
public CellStyle StyleFixedDisplay {get;}
[Delphi]
property StyleFixedDisplay: CellStyle;

360 · C1FlexGrid-Referenzverzeichnis
Bemerkungen
Wenn die Spalte ein eigenes Format für ihre fixierte Zellen besitzt, dann wird es von dieser Eigenschaft
zurückgegeben. Andernfalls wird das für diese Spalte verwendete Standardformat (z.B. Normal,
Alternate, Fixed) wiedergegeben.
Schauen Sie ferner unter
Column-Klasse (Seite 339)
StyleFixedNew-Eigenschaft
Gibt das benutzerdefinierte Format zurück, das den fixierten Zellen in dieser Spalte zugeordnet ist.
Syntax
[VB]
Public StyleFixedNew As CellStyle
[C#]
public CellStyle StyleFixedNew {get;}
[Delphi]
property StyleFixedNew: CellStyle;
Bemerkungen
Wenn die Spalte ein eigenes Format für ihre fixierten Zellen besitzt, dann wird es von dieser Eigenschaft
zurückgegeben. Andernfalls wird ein neues benutzerdefiniertes Format erstellt und ein Verweis auf
dieses wiedergegeben.
Schauen Sie ferner unter
Column-Klasse (Seite 339)
StyleNew-Eigenschaft (Column)
Ermittelt das benutzerdefinierte Format, das mit dieser Spalte verknüpft ist, und erstellt, wenn nötig, eine
neue Formatvorlage.
Syntax
[VB]
Public StyleNew As CellStyle
[C#]
public CellStyle StyleNew {get;}
[Delphi]
property StyleNew: CellStyle;
Bemerkungen
Wenn die Spalte ein eigenes Format besitzt, dann wird es von dieser Eigenschaft zurückgegeben.
Andernfalls wird ein neues benutzerdefiniertes Format erstellt und ein Verweis auf dieses
wiedergegeben.

Schauen Sie ferner unter
Column-Klasse (Seite 339)
TextAlign-Eigenschaft (Column)
Ermittelt oder legt fest, wie der Text in den Zellen dieser Spalte ausgerichtet wird.
Syntax
[VB]
Public TextAlign As TextAlignEnum
[C#]
public TextAlignEnum TextAlign {get; set;}
[Delphi]
property TextAlign: TextAlignEnum;
Bemerkungen
TextAlign-Eigenschaft (Column) · 361
Diese Eigenschaft verknüpft mit dieser Spalte den zugeordneten CellStyle. Zum Beispiel:
• Visual Basic
• C#
flex.Cols(1).TextAlign = TextAlignEnum.RightTop '
Console.WriteLine(flex.Cols(1).Style.TextAlign)
flex.Cols[1].TextAlign = TextAlignEnum.RightTop;
Console.WriteLine(flex.Cols[1].Style.TextAlign);
TextAlignEnum.RightTop
• Delphi
flex.Cols[1].TextAlign := TextAlignEnum.RightTop;
Console.WriteLine(flex.Cols[1].Style.TextAlign);
TextAlignEnum.RightTop;
Schauen Sie ferner unter
Column-Klasse (Seite 339)
TextAlignFixed-Eigenschaft
Ermittelt oder legt fest, wie der Text in den fixierten Zellen dieser Spalte ausgerichtet wird.
Syntax
[VB]
Public TextAlignFixed As TextAlignEnum
[C#]
public TextAlignEnum TextAlignFixed {get; set;}
[Delphi]
property TextAlignFixed: TextAlignEnum;

362 · C1FlexGrid-Referenzverzeichnis
Bemerkungen
Diese Eigenschaft verknüpft mit dieser Spalte den zugeordneten CellStyle. Zum Beispiel:
• Visual Basic
• C#
flex.Cols(1).TextAlign = TextAlignEnum.RightTop '
Console.WriteLine(flex.Cols(1).StyleFixed.TextAlign)
flex.Cols[1].TextAlign = TextAlignEnum.RightTop;
Console.WriteLine(flex.Cols[1].StyleFixed.TextAlign);
TextAlignEnum.RightTop
• Delphi
flex.Cols[1].TextAlign := TextAlignEnum.RightTop;
Console.WriteLine(flex.Cols[1].StyleFixed.TextAlign);
TextAlignEnum.RightTop;
Schauen Sie ferner unter
Column-Klasse (Seite 339)
UserData-Eigenschaft (Column)
Ermittelt oder legt die mit dieser Spalte verknüpften Benutzerdaten fest.
Syntax
[VB]
Public UserData As Object
[C#]
public object UserData {get; set;}
[Delphi]
property UserData: Object;
Bemerkungen
Der UserData-Wert wird von der Tabelle intern nicht verwendet. Dieser ist für zusätzliche Daten
reserviert, die Sie mit der Spalte verknüpfen wollen.
Schauen Sie ferner unter
Column-Klasse (Seite 339)
Visible-Eigenschaft (Column)
Ermittelt oder legt die Sichtbarkeit dieser Spalte fest.
Syntax
[VB]
Public Visible As Boolean
[C#]

public bool Visible {get; set;}
[Delphi]
property Visible: Boolean;
Bemerkungen
Width-Eigenschaft (Column) · 363
Diese Eigenschaft gibt TRUE zurück, wenn die Spalte eine von Null verschiedene Breite besitzt und auch
wenn diese aus dem sichtbaren Bereich gescrollt wurde. Verwenden Sie hingegen die LeftCol- und
RightCol-Eigenschaften, um festzustellen, ob eine Zeile derzeit auf dem Bildschirm angezeigt wird.
Schauen Sie ferner unter
Column-Klasse (Seite 339)
Width-Eigenschaft (Column)
Ermittelt oder legt die Breite dieser Spalte in Pixeln fest. Gibt–1 zurück, wenn die Spalte die
Standardbreite besitzt.
Syntax
[VB]
Public Width As Integer
[C#]
public int Width {get; set;}
[Delphi]
property Width: Integer;
Bemerkungen
Wenn Width auf -1 gesetzt wird, dann verwendet die Tabelle die Standardbreite aus Cols.DefaultSize
für diese Spalte.
Width gibt die der Spalte zugeordnete Breite zurück, auch wenn diese ausgeblendet ist und -1, wenn die
entsprechende Spalte die Standardbreite besitzt. Verwenden Sie die WidthDisplay-Eigenschaft, um die
wirklich angezeigte und damit sichtbare Breite einer Spalte abzufragen.
Schauen Sie ferner unter
Column-Klasse (Seite 339)
WidthDisplay-Eigenschaft
Ermittelt oder legt die angezeigte Breite dieser Spalte in Pixeln fest.
Syntax
[VB]
Public WidthDisplay As Integer
[C#]
public int WidthDisplay {get; set;}

364 · C1FlexGrid-Referenzverzeichnis
[Delphi]
property WidthDisplay: Integer;
Bemerkungen
WidthDisplay gibt die dem Nutzer wirklich angezeigte Spaltenbreite unter Berücksichtigung der
Standardbreite und der Spaltensichtbarkeit zurück. Siehe auch Width-Eigenschaft.
Schauen Sie ferner unter
Column-Klasse (Seite 339)
Column-Methoden
Clear-Methode (Column)
Löscht die Inhalte dieser Spalte.
Syntax
[VB]
Public Sub Clear(clearFlags As ClearFlags)
[C#]
public void Clear (ClearFlags clearFlags )
[Delphi]
procedure Clear(clearFlags: ClearFlags);
Parameter Beschreibung
flags
Bemerkungen
Ein oder mehrere Werte aus der ClearFlags-Aufzählung, die festlegen, was
gelöscht werden soll.
Verwenden Sie diese Methode um die Spalteneigenschaften (Breite, Sichtbarkeit, Format, Nutzerdaten,
usw.) auf deren Standardwert zurückzusetzen. Diese Methode betrifft nicht den Inhalt der Zellen in der
Spalte.
Schauen Sie ferner unter
Column-Klasse (Seite 339)
Move-Methode (Column)
Verschiebt diese Spalte in der Collection auf eine neue Position.
Syntax
[VB]
Public Sub Move(indexNew As Integer)

[C#]
public void Move ( int indexNew )
[Delphi]
procedure Move(indexNew: Integer);
Parameter Beschreibung
indexNew Eine Integerzahl, welche die neue Position der Spalte festlegt.
Schauen Sie ferner unter
Column-Klasse (Seite 339)
CellStyleCollection-Klasse
Move-Methode (Column) · 365
Diese Klasse verwaltet die für das Rendern der Tabelle verwendete Collection der CellStyle-Objekte. Es
gibt zwei Zellformattypen: Standard (Stock) und benutzerdefinierte (Custom).
Standardformat
Standardformatvorlagen werden von der Tabelle erstellt. Sie können zwar deren Eigenschaften
verändern, aber diese weder löschen noch erstellen. Zellformate sind hierarchisch (ähnlich den
„cascadierenden Stylesheets“). Alle Formatvorlagen basieren auf dem Standardformat Normal. Jegliche
Änderungen, die Sie in der Normal-Formatvorlage vornehmen, werden von allen anderen
Formatvorlagen geerbt, außer wenn die spezielle Eigenschaft explizit im abgeleiteten Format
überschrieben wird. Zum Beispiel, wenn Sie die Font-Eigenschaft des Formats Normal ändern, dann
werden alle fixierten und markierten Zellen die neue Schriftart verwenden, da die Fixed- und Highlight-
Formatevolagen standardmäßig keinen eigenen Wert für ihre Font-Eigenschaft besitzen.
Das Erbverhalten von Formatvorlagen wird von der Tabelle auch für das dynamische Kombinieren von
Formaten verwendet. Zum Beispiel, eine könnte eine ausgewählte Zelle in einer geraden, scrollbaren
Zeile mit dem Selected-Format formatiert werden und damit vom Alternate- und Normal-Fomat erben.
Die von der Tabelle definierten Standardformate lauten: Normal, Fixed, Alternate, Highlight,
EmptyArea, Focus, Search, GrandTotal und Subtotal0 bis Subtotal5.
Sie können die Standardformate mit den Eigenschaften aus der Styles-Collection oder mit einem der
Indizierer (z.B. Styles.Normal, Styles[0], Styles[CellStyleEnum.Normal], Styles["Normal"]) ansprechen.
Benutzerdefinierte Format
Benutzerdefinierte Formate werden mit der Add-Methode aus der Styles-Collection erstellt und können
über die diese Styles-Collection per Name oder Index angesprochen werden. Sie können auf Row-,
Column- und CellRange-Objekte angewandt werden. Außerdem gilt für benutzerdefinierte Formate das
gleiche Erbverhalten wie für Standardformate. Zum Beispiel, wenn Sie ein benutzerdefiniertes Format
mit dem Namen „Small Number“ erstellen, dessen BackColor-Eigenschaft auf rot setzen und alle
anderen Eigenschaften unveränder lassen, dann wird diese Zelle mit diesem Format die Font- und
ForeGround-Eigenschaften aus dem entsprechenden, dem Row- oder Column-Objekten zugeordnen
Format erben. (entweder von Normal, Alternate, Focus, Highlight oder ein anderes benutzerdefiniertes
Format)

366 · C1FlexGrid-Referenzverzeichnis
Alle CellStyleCollection-Mitglieder
CellStyleCollection-Klasseneigenschaften (public)
Alternate
Unterstützt vom .NET-Compact-Framework.
Count
Unterstützt vom .NET-Compact-Framework.
Gibt den für das Zeichnen alternierender Zeilen
verwendeten CellStyle zurück.
Gibt die Anzahl der Formate in der Collection zurück.
Editor Gibt den für das Zeichnen von Zellen während deren
Bearbeitung verwendeten CellStyle zurück.
EmptyArea
Unterstützt vom .NET-Compact-Framework.
Fixed
Unterstützt vom .NET-Compact-Framework.
Focus
Unterstützt vom .NET-Compact-Framework.
Gibt den für das Zeichnen leerer Tabellenbereiche
verwendeten CellStyle zurück.
Gibt den für das Zeichnen fixierter Zellen (nicht
scrollbar) verwendeten CellStyle zurück.
Gibt den für das Zeichnen aktiver Zellen verwendeten
CellStyle zurück, wenn die Tabelle den Fokus hat.
Frozen Gibt den für das Zeichnen eingefrorener Zellen
verwendeten Standard CellStyle zurück.
Highlight
Unterstützt vom .NET-Compact-Framework.
Item
Unterstützt vom .NET-Compact-Framework.
Gibt den, für das Markieren von ausgewählten Zellen
verwendeten Standard CellStyle zurück.
Gibt einen Verweis auf ein Format in der Collection
zurück.
NewRow Integriertes Format der Vorlage für eine neue Zeile
(nur verfügbar, wenn AllowAddNew auf TRUE steht).
Normal
Unterstützt vom .NET-Compact-Framework.
Search
Unterstützt vom .NET-Compact-Framework.
CellStyleCollection-Klassenmethoden (public)
Add
Unterstützt vom .NET-Compact-Framework.
BuildString
Unterstützt vom .NET-Compact-Framework.
Clear
Unterstützt vom .NET-Compact-Framework.
Gibt den für gewöhnliche, scrollbare Zellen
verwendeten CellStyle zurück.
Gibt den für die aktuelle Zelle während laufendem
AutoSearch verwendeten CellStyle zurück.
Fügt der Collection ein benutzerdefiniertes Format
hinzu.
Gibt eine kompakte Zeichenkette mit allen in der
Collection enthaltenen Formaten zurück.
Entfernt alle benutzerdefinierten Formatvorlagen aus
der Collection und setzt die Standardformate auf deren
Standardwerte zurück.
ClearUnused Dies löscht unbenannte und ungenutze Formate.
Contains
Unterstützt vom .NET-Compact-Framework.
ParseString
Unterstützt vom .NET-Compact-Framework.
Remove
Unterstützt vom .NET-Compact-Framework.
Prüft die Collection, ob diese ein bestimmtes Format
mit einem gegebenen Namen enthält.
Erstellt die Style-Collection neu, basierend auf der in
einer Zeichenkette enthaltenen Beschreibung.
Löscht ein benutzerdefiniertes Format aus der
Collection.

CellStyleCollection-Eigenschaften
Alternate-Eigenschaft
Gibt den für das Zeichnen alternierender Zeilen verwendeten CellStyle zurück.
Syntax
[VB]
Public Alternate As CellStyle
[C#]
public CellStyle Alternate {get;}
[Delphi]
property Alternate: CellStyle;
Schauen Sie ferner unter
CellStyleCollection-Klasse (Seite 365)
Count-Eigenschaft (CellStyleCollection)
Gibt die Anzahl der Formate in der Collection zurück.
Syntax
[VB]
Public Count As Integer
[C#]
public int Count {get;}
[Delphi]
property Count: Integer;
Schauen Sie ferner unter
CellStyleCollection-Klasse (Seite 365)
Editor-Eigenschaft (CellStyleCollection)
Alternate-Eigenschaft · 367
Gibt den für das Zeichnen von Zellen während deren Bearbeitung verwendeten CellStyle zurück.
Syntax
[VB]
Public Editor As CellStyle
[C#]
public CellStyle Editor {get;}

368 · C1FlexGrid-Referenzverzeichnis
[Delphi]
property Editor: CellStyle;
Bemerkungen
Elemente in diesem Format werden auf aktive Zellen in der Editorsteuerung angewendet. Nicht alle
Editoren unterstützen alle Formatelemente. Die meisten Editoren unterstützen aber zumindest die
BackColor-, ForeColor- und Font-Eigenschaften.
Schauen Sie ferner unter
CellStyleCollection-Klasse (Seite 365)
EmptyArea-Eigenschaft
Gibt den für das Zeichnen leerer Tabellenbereiche verwendeten CellStyle zurück.
Syntax
[VB]
Public EmptyArea As CellStyle
[C#]
public CellStyle EmptyArea {get;}
[Delphi]
property EmptyArea: CellStyle;
Bemerkungen
Es werden nur die BackColor- und Border-Elemente von dieser Formatvorlage verwendet. Diese legt das
Format für den Bereich zwischen der letzten Zelle und dem Rahmen der Steuerung fest.
Das Border.Color-Element legt die Farbe der Rahmenlinien um die Kanten des Arbeitsblatts und
zwischen eingefrorenen und scrollbaren Zellen fest.
Schauen Sie ferner unter
CellStyleCollection-Klasse (Seite 365)
Frozen-Eigenschaft
Gibt den für das Zeichnen eingefrorener Zellen verwendeten Standard CellStyle zurück.
Syntax
[VB]
Public Frozen As CellStyle
[C#]
public CellStyle Frozen {get;}
[Delphi]
property Frozen: CellStyle;

Schauen Sie ferner unter
CellStyleCollection-Klasse (Seite 365)
AllowFreezing-Eigenschaft (Seite 120)
Fixed-Eigenschaft (CellStyleCollection)
Fixed-Eigenschaft (CellStyleCollection) · 369
Gibt den für das Zeichnen fixierter Zellen (nicht scrollbar) verwendeten CellStyle zurück.
Syntax
[VB]
Public Fixed As CellStyle
[C#]
public CellStyle Fixed {get;}
[Delphi]
property Fixed: CellStyle;
Schauen Sie ferner unter
CellStyleCollection-Klasse (Seite 365)
Focus-Eigenschaft
Gibt den für das Zeichnen aktiver Zellen verwendeten CellStyle zurück, wenn die Tabelle den Fokus hat.
Syntax
[VB]
Public Focus As CellStyle
[C#]
public CellStyle Focus {get;}
[Delphi]
property Focus: CellStyle;
Schauen Sie ferner unter
CellStyleCollection-Klasse (Seite 365)
Highlight-Eigenschaft (CellStyleCollection)
Gibt den für das Markieren von ausgewählten Zellen verwendeten Standard CellStyle zurück.
Syntax
[VB]
Public Highlight As CellStyle

370 · C1FlexGrid-Referenzverzeichnis
[C#]
public CellStyle Highlight {get;}
[Delphi]
property Highlight: CellStyle;
Schauen Sie ferner unter
CellStyleCollection-Klasse (Seite 365)
Item-Eigenschaft (CellStyleCollection)
Gibt einen Verweis auf ein Format in der Collection zurück. Gibt Null zurück, wenn das Format nicht
gefunden werden kann.
Syntax
[VB]
Public Item (index As Integer) As CellStyle
Public Item(index As CellStyleEnum) As CellStyle
Public Item(name As String) As CellStyle
[C#]
public CellStyle this[int styleIndex]
public CellStyle this[CellStyleEnum styleType]
public CellStyle this[string styleName]
[Delphi]
property Item(index: Integer): CellStyle;
property Item(index: CellStyleEnum): CellStyle;
property Item(name: string): CellStyle;
Schauen Sie ferner unter
CellStyleCollection-Klasse (Seite 365)
NewRow-Eigenschaft
Integriertes Format der Vorlage für eine neue Zeile (nur verfügbar, wenn AllowAddNew auf TRUE
steht).
Syntax
[VB]
Public NewRow As CellStyle
[C#]
public CellStyle NewRow {get; }

[Delphi]
property NewRow: CellStyle;
Bemerkungen
Normal-Eigenschaft · 371
Zum Beispiel, der nachfolgende Quellcode lässt eine Vorlage für eine neue Zeile mit einem gelben
Hintergrund anzeigen:
• Visual Basic
• C#
_flex.Styles.NewRow.BackColor = Color.Yellow
_flex.Styles.NewRow.BackColor = Color.Yellow;
• Delphi
_flex.Styles.NewRow.BackColor := Color.Yellow;
Schauen Sie ferner unter
CellStyleCollection-Klasse (Seite 365)
Normal-Eigenschaft
Gibt den für gewöhnliche, scrollbare Zellen verwendeten CellStyle zurück.
Syntax
[VB]
Public Normal As CellStyle
[C#]
public CellStyle Normal {get;}
[Delphi]
property Normal: CellStyle;
Bemerkungen
Dies ist das Mutterformat für die meisten Zellen. Wenn die BackColor-, ForeColor- oder Font-
Eigenschaften der Steuerung auf automatisch stehen, dann wird immer die entsprechende Eigenschaft
aus dem Normal-Format verwendet.
Wenn Sie eine beliebige Eigenschaft im Normal-Format ändern, dann wird diese Änderung in allen
weiteren Formatvorlagen, die diese Eigenschaft nicht explizit überschreiben, sichtbar sein. Zum Beispiel,
der nachfolgende Quellcode legt eine gewöhnliche „Arial“-Schriftart für alle Zellen der Tabelle,
Fettschrift für fixierte und Unterstreichung für fokussierte Zellen fest:
• Visual Basic
• C#
flex.Styles.Normal.Font = New Font("Arial", 9)
flex.Styles.Fixed.Font = New Font("Arial", 9, FontStyle.Bold)
flex.Styles.Focus.Font = New Font("Arial", 9, FontStyle.Underline)
flex.Styles.Normal.Font = new Font("Arial", 9);
flex.Styles.Fixed.Font = new Font("Arial", 9, FontStyle.Bold);
flex.Styles.Focus.Font = new Font("Arial", 9, FontStyle.Underline);

372 · C1FlexGrid-Referenzverzeichnis
• Delphi
flex.Styles.Normal.Font := Font.Create('Arial', 9);
flex.Styles.Fixed.Font := Font.Create('Arial', 9, FontStyle.Bold);
flex.Styles.Focus.Font := Font.Create('Arial', 9, FontStyle.Underline);
Schauen Sie ferner unter
CellStyleCollection-Klasse (Seite 365)
Search-Eigenschaft
Gibt den für die aktuelle Zelle bei laufendem AutoSearch verwendeten CellStyle zurück.
Syntax
[VB]
Public Search As CellStyle
[C#]
public CellStyle Search {get;}
[Delphi]
property Search: CellStyle;
Bemerkungen
Siehe auch AutoSearch-Eigenschaft.
Schauen Sie ferner unter
CellStyleCollection-Klasse (Seite 365)
CellStyleCollection-Methoden
Add-Methode (CellStyleCollection)
Fügt der Collection ein benutzerdefiniertes Format hinzu.
Syntax
[VB]
Public Function Add(name As String) As CellStyle
Public Function Add(name As String, basedOn As CellStyle) As CellStyle
[C#]
public CellStyle Add (String name )
public CellStyle Add (String name , CellStyle basedOn )
[Delphi]
function Add(name: string): CellStyle;
function Add(name: string; basedOn: CellStyle): CellStyle;

Parameter Beschreibung
styleName
basedOn
Bemerkungen
BuildString-Methode · 373
Der Name des neuen Formats. Der Name muss in der Collection einzigartig sein
und darf nur alphanumerische Zeichen oder Leerzeichen enthalten.
Eine existierende Formatvorlage, von welcher das hinzugefügte Format erbt. Wenn
dieser Paramter nicht gesetzt wird, dann basiert das neue Format auf dem
Standardformat Normal.
Wenn der styleName-Parameter zur Verfügung gestellt wird, dann muss dieser einzigartig sein und darf
keine geschweiften Klammern ("{" oder "}") enthalten.
Wenn der styleName-Parameter auf Null steht, dann wird ein einzigartiges „anonymous“-Format
erstellt. Dieser Formattyp wird nicht der Style-Collection hinzugefügt und kann daher nicht per Name
oder Index angesprochen werden. Dies ist in Anwendungen nützlich, die ihre eigenen Style-Collections
erstellen und verwalten.
Schauen Sie ferner unter
CellStyleCollection-Klasse (Seite 365)
BuildString-Methode
Gibt eine kompakte Zeichenkette mit allen in der Collection enthaltenen Formaten zurück.
Syntax
[VB]
Public Function BuildString(includeEmpty As Boolean) As String
[C#]
public String BuildString (Boolean includeEmpty )
[Delphi]
function BuildString(includeEmpty: Boolean): string;
Parameter Beschreibung
includeEmpties
Bemerkungen
Ein Wahrheitswert, der festlegt, ob leere Formate bei der Zeichenkettendefinition
berücksichtigt werden sollen. Leere Formate haben zwar Namen, definieren aber
keinerlei Eigenschaften. Diese können als Platzhalter verwendet werden.
Zeichenketten, die mit der BuildString-Methode erstellt werden, können später mit der ParseString-
Methode verwendet werden. Somit können Style-Collections als Vorlagen schnell und einfach
gespeichert und angewendet werden (auch als „Skins“ bekannt).

374 · C1FlexGrid-Referenzverzeichnis
Schauen Sie ferner unter
CellStyleCollection-Klasse (Seite 365)
Clear-Methode (CellStyleCollection)
Entfernt alle benutzerdefinierten Formatvorlagen aus der Collection und setzt die Standardformate auf
deren Standardwerte zurück.
Syntax
[VB]
Public Sub Clear()
[C#]
public void Clear ( )
[Delphi]
procedure Clear;
Bemerkungen
Die Clear-Methode entfernt auch alle benutzerdefinierten Formatvorlagen, die derzeit für Zeilen, Spalten
und Zellen verwendet werden.
Schauen Sie ferner unter
CellStyleCollection-Klasse (Seite 365)
ClearUnused-Methode
Dies löscht unbenannte und ungenutze Formate.
Syntax
[VB]
Public Sub ClearUnused()
[C#]
public void ClearUnused ( )
[Delphi]
procedure ClearUnused;
Bemerkungen
Diese Methode wird genutzt, wenn ein Format mit StyleNew erstellt wurde, dann aber auf keine Zeile,
Spalte oder einen Zellbereich angewendet wurde.
Schauen Sie ferner unter
CellStyleCollection-Klasse (Seite 365)
Contains-Methode (CellStyleCollection)
Prüft die Collection, ob diese ein bestimmtes Format mit einem gegebenen Namen enthält.

Syntax
[VB]
Public Function Contains(name As String) As Boolean
[C#]
public Boolean Contains (String name )
[Delphi]
function Contains(name: string): Boolean;
Schauen Sie ferner unter
CellStyleCollection-Klasse (Seite 365)
ParseString-Methode (CellStyleCollection)
ParseString-Methode (CellStyleCollection) · 375
Erstellt die Style-Collection neu, basierend auf der in einer Zeichenkette enthaltenen Beschreibung.
Syntax
[VB]
Public Function ParseString(str As String) As Boolean
[C#]
public Boolean ParseString (String str )
[Delphi]
function ParseString(str: string): Boolean;
Parameter Beschreibung
styleDefinition
Bemerkungen
Eine von einer Zelle an die BuildString-Methode zurückgegebene Zeichenkette,
die eine Beschreibung von einer Style-Collection enthält.
Die ParseString-Methode entfernt keine existierenden Formatvorlagen, wenn sie nicht in der
Zeichenkette mit den Formatdefinitionen enthalten ist. Verwenden Sie die Clear-Methode bevor Sie
ParseString aufrufen, um die aktuelle Style-Collection zurückzusetzen.
Schauen Sie ferner unter
CellStyleCollection-Klasse (Seite 365)
Remove-Methode (CellStyleCollection)
Löscht ein benutzerdefiniertes Format aus der Collection.
Syntax
[VB]
Public Sub Remove(index As Integer)

376 · C1FlexGrid-Referenzverzeichnis
Public Sub Remove(style As CellStyle)
[C#]
public void Remove ( int index )
public void Remove (CellStyle style )
[Delphi]
procedure Remove(index: Integer);
procedure Remove(style: CellStyle);
Parameter Beschreibung
index
Der Index des zu entfernenden Formats. Da die Formatvorlage ein
benutzerdefiniertes Format sein muss, ist der Index dieser größer oder gleich
(int)CellStyleEnum FirstCustomStyle.
name Der Name des zu entfernenden Formats.
Bemerkungen
Nur benutzerdefinierte Formate können aus der Collection entfernt werden. Die Remove-Methode
entfernt benutzerdefinierte Formate aus der Collection und von jeder Zeile, Spalte oder Zelle, die dieses
zu löschende Format verwendet.
Schauen Sie ferner unter
CellStyleCollection-Klasse (Seite 365)
CellStyle-Klasse
CellStyle-Objekte beinhalten Formatierungsinformationen für das Rendern der Tabellenzellen. Diese
Informationen betreffen unter anderem die Hintergrund- und Vordergrundfarben, die Schriftart und die
Text- und Grafikausrichtung. Die Styles-Eigenschaft verwaltet die Collection aller Formatvorlagen der
Tabelle und besitzt Methoden, mit denen Sie Formatvorlagen der Tabelle erstellen und entfernen können.
Einzelne Formate können auf CellRange-, Row- und Column-Objekte angewendet werden.
Formate folgen, ähnlich wie bei Formatvorlagen in Microsoft Word oder in „cascadierenden Stylesheets“,
einem hierarchischen Model. Die Eigenschaft in einem CellStyle-Objekt müssen nicht zwingend
festgelegt werden, so dass deren Werte aus den Mutterformaten geerbt werden. Das Mutterformat ist für
gewöhnlich das Standardformat Normal. Verwenden Sie die DefinedElements-Eigenschaft, um
festzulegen, welche Elemente in einer bestimmten Formatvorlage definiert werden.
Wenn Sie eine Eigenschaft eines CellStyle-Objekts verändern, dann werden alle Zellen, die dieses Format
verwenden, neu gezeichnet, um die Änderungen zu übernehmen.
Alle CellStyle-Mitglieder
CellStyle-Klasseneigenschaften (public)
BackColor
Unterstützt vom .NET-Compact-Framework.
Ermittelt oder legt die Hintergrundfarbe der Zelle fest.

Border
Unterstützt vom .NET-Compact-Framework.
Remove-Methode (CellStyleCollection) · 377
Gibt das für den Zellrahmen verwendete CellBorder-
Objekt zurück.
ComboList Ermittelt oder legt die ComboList fest, die für die
Bearbeitung der Zelle verwendet werden soll.
DataMap Ermittelt oder legt die Datenzuordnung fest, um die
anzuzeigenden Zeichenketten mit den Datenwerten
dieser Zelle zu verknüpfen.
DefinedElements
Unterstützt vom .NET-Compact-Framework.
Ermittelt oder legt die in diesem CellStyle definierten
Elemente fest.
Display Ermittelt oder legt fest, ob in der Zelle Text und/oder
Grafiken angezeigt werden und wie diese angeordnet
werden sollen.
EditMask Ermittelt oder legt die zu verwendende Eingabemaske
für die Bearbeitung der Zelle fest.
Editor Ermittelt oder legt den benutzerdefinierten Editor fest,
der für die Bearbeitung der Zelle verwendet werden
soll.
Font
Unterstützt vom .NET-Compact-Framework.
ForeColor
Unterstützt vom .NET-Compact-Framework.
Ermittelt oder legt die Schriftart des Textes in der Zelle
fest.
Ermittelt oder legt die Schriftfarbe des Textes in der
Zelle fest.
Format Ermittelt oder legt das Format fest, um Zellwerte in
anzuzeigende Zeichenketten umzuwandeln.
ImageAlign
Unterstützt vom .NET-Compact-Framework.
Ermittelt oder legt die Ausrichtung von Grafiken in einer
Zelle fest.
ImageMap Ermittelt oder erstellt das ImageMap, um Zellwerte mit
in dieser Zelle anzuzeigenden Grafiken zu verknüpfen.
ImageSpacing
Unterstützt vom .NET-Compact-Framework.
Margins
Unterstützt vom .NET-Compact-Framework.
Name
Unterstützt vom .NET-Compact-Framework.
TextAlign
Unterstützt vom .NET-Compact-Framework.
Ermittelt oder legt den Abstand in Pixeln zwischen der
Grafik und dem Text in der Zelle fest.
Ermittelt oder legt den Abstand in Pixeln zwischen den
Zellkanten und dem Zellinhalt fest.
Ermittelt oder legt den Name für diesen CellStyle fest.
Ermittelt oder legt die Ausrichtung des Textes in einer
Zelle fest.
TextDirection Hiermit kann Text in vertikaler Richtung angezeigt
werden (auf- oder abwärts orientiert).
TextEffect
Unterstützt vom .NET-Compact-Framework.
Trimming
Unterstützt vom .NET-Compact-Framework.
Ermittelt oder legt den 3D-Effekt für den Text in der
Zelle fest.
Legt fest, wie Texte beschnitten werden, wenn diese zu
lang für die Zelle sind.
UserData Ermittelt oder legt willkürliche Daten für diesen
CellStyle fest.

378 · C1FlexGrid-Referenzverzeichnis
WordWrap
Unterstützt vom .NET-Compact-Framework.
CellStyle-Klassenmethoden (public)
BuildString
Unterstützt vom .NET-Compact-Framework.
Clear
Unterstützt vom .NET-Compact-Framework.
Legt fest, ob lange Zeichenketten in der Zelle
umgebrochen werden.
Gibt eine kompakte Zeichenkette zurück, die diesen
CellStyle darstellt.
Entfernt ausgewählte Elemente aus diesem CellStyle.
MergeWith Kopiert alle in einem Quell-CellStyle definierten
Elemente in diese Formatvorlage. Formatelemente, die
nicht in diesem CellStyle enthalten sind, werden
bewahrt.
ParseString
Unterstützt vom .NET-Compact-Framework.
Erstellt diesen CellStyle neu, basierend auf der in einer
Zeichenkette enthaltenen Beschreibung.
Render Rendert Zeichenketten und Grafiken mit den in diesem
CellStyle definierten Attributen in ein Graphics-Objekt.
CellStyle-Eigenschaften
BackColor-Eigenschaft
Ermittelt oder legt die Hintergrundfarbe der Zelle fest.
Syntax
[VB]
Public BackColor As Color
[C#]
public Color BackColor {get; set;}
[Delphi]
property BackColor: Color;
Schauen Sie ferner unter
CellStyle-Klasse (Seite 376)
Border-Eigenschaft
Gibt das für den Zellrahmen verwendete CellBorder-Objekt zurück.
Syntax
[VB]
Public Border As CellBorder

[C#]
public CellBorder Border {get;}
[Delphi]
property Border: CellBorder;
Bemerkungen
ComboList-Eigenschaft (CellStyle) · 379
Mit dem CellBorder-Objekt können Sie den Rahmentyp, dessen Farbe und die Dicke einstellen.
Schauen Sie ferner unter
CellStyle-Klasse (Seite 376)
ComboList-Eigenschaft (CellStyle)
Ermittelt oder legt die ComboList fest, die für die Bearbeitung der Zelle verwendet werden soll.
Syntax
[VB]
Public ComboList As String
[C#]
public string ComboList {get; set}
[Delphi]
property ComboList: string;
Bemerkungen
• Visual Basic
• C#
Dim s As CellStyle = _flex.Styles.Add("TheList")
s.ComboList = "Fiat|Mercedes|Porsche|Pontiac"
Dim r As CellRange = _flex.GetCellRange(10, 10)
rg.Style = s
CellStyle s = _flex.Styles.Add("TheList");
s.ComboList = "Fiat|Mercedes|Porsche|Pontiac";
CellRange r = _flex.GetCellRange(10,10);
rg.Style = s;
• Delphi
var
r: CellRange;
s: CellStyle;
begin
s := _flex.Styles.Add('TheList');
s.ComboList := 'Fiat|Mercedes|Porsche|Pontiac';
r := _flex.GetCellRange(10, 10);
rg.Style := s;
end;
Schauen Sie ferner unter
CellStyle-Klasse (Seite 376)

380 · C1FlexGrid-Referenzverzeichnis
DataMap-Eigenschaft (CellStyle)
Ermittelt oder legt die Datenzuordnung fest, um die anzuzeigenden Zeichenketten mit den Datenwerten
einzelner Zellen und Zellbereiche zu verknüpfen (als Alternative zur Anwendung auf die gesamte
Tabelle, oder auf Zeilen oder Spalten, was immer noch verfügbar ist).
Syntax
[VB]
Public DataMap As IDictionary
[C#]
public IDictionary DataMap {get; set;}
[Delphi]
property DataMap: IDictionary;
Bemerkungen
Für Einzelheiten und Beispiele schauen Sie bitte unter der Column.DataMap-Eigenschaft nach.
Schauen Sie ferner unter
CellStyle-Klasse (Seite 376)
DefinedElements-Eigenschaft
Ermittelt oder legt die, in diesem CellStyle definierten Elemente fest (alle andern Elemente werden vom
Mutterformat geerbt).
Syntax
[VB]
Public DefinedElements As StyleElementFlags
[C#]
public StyleElementFlags DefinedElements {get; set;}
[Delphi]
property DefinedElements: StyleElementFlags;
Bemerkungen
Elemente, die in einer Formatvorlage nicht definiert sind, werden automatisch vom Mutterformat geerbt
(für gewöhnlich das Format Normal). Zum Beispiel, wenn Sie ein benutzerdefiniertes Format erstellen
und die Font-Eigenschaft festlegen, dann werden alle weiteren Elemente, wie Hintergrundfarbe und
Ausrichtung, aus der Formatvorlage Normal geerbt.
Schauen Sie ferner unter
CellStyle-Klasse (Seite 376)

Display-Eigenschaft
Display-Eigenschaft · 381
Ermittelt oder legt fest, ob in der Zelle Text und/oder Grafiken angezeigt und wie diese angeordnet
werden sollen.
Syntax
[VB]
Public Display As DisplayEnum
[C#]
public DisplayEnum Display {get; set;}
[Delphi]
property Display: DisplayEnum;
Schauen Sie ferner unter
CellStyle-Klasse (Seite 376)
Editor-Eigenschaft (CellStyle)
Ermittelt oder legt den benutzerdefinierten Editor fest, der für die Bearbeitung der Zelle verwendet
werden soll.
Syntax
[VB]
Public Editor As Control
[C#]
public Control Editor {get;set;}
[Delphi]
property Editor: Control;
Bemerkungen
Die Tabelle stellt einige integrierte Editoren zur Verfügung. Aus diesen wird automatisch einer aufgrund
der Eigenschaften der zu bearbeitenden Zelle ausgewählt.
Mit dieser Eigenschaft können Sie für die Bearbeitung der Zellen eines gegebenen CellStyles externe
Editoren verwenden. Es kann zwar jede beliebige Steuerung als externer Editor verwendet werden, um
aber eine vollständige Integration mit der Tabelle sicher zustellen, sollte der externe Editor die
IC1EmbeddedEditor-Schnittstelle implementieren.
Für weitere Einzelheiten schauen Sie bitte unter Editor-Eigenschaft nach.
Schauen Sie ferner unter
IC1EmbeddedEditor-Schnittstelle (Seite 446)
EditMask-Eigenschaft
Ermittelt oder legt die zu verwendende Eingabemaske für die Bearbeitung der Zelle fest.

382 · C1FlexGrid-Referenzverzeichnis
Syntax
[VB]
Public EditMask As String
[C#]
public string EditMask {get; set}
[Delphi]
property EditMask: string;
Bemerkungen
• Visual Basic
• C#
Dim s As CellStyle = _flex.Styles.Add("TheMask")
s.EditMask = "##-##-####"
Dim r As CellRange = _flex.GetCellRange(10, 10)
rg.Style = s
CellStyle s = _flex.Styles.Add("TheMask");
s.EditMask = "##-##-####";
CellRange r = _flex.GetCellRange(10,10);
rg.Style = s;
• Delphi
var
r: CellRange;
s: CellStyle;
begin
s := _flex.Styles.Add('TheMask');
s.EditMask := '##-##-####';
r := _flex.GetCellRange(10, 10);
rg.Style := s;
end;
Schauen Sie ferner unter
CellStyle-Klasse (Seite 376)
Font-Eigenschaft (CellStyle)
Ermittelt oder legt die Schriftart des Textes in der Zelle fest.
Syntax
[VB]
Public Font As Font
[C#]
public Font Font {get; set;}
[Delphi]
property Font: Font;

Bemerkungen
ForeColor-Eigenschaft · 383
Indem die Font-Eigenschaft der Tabelle festgelegt wird, ändert sich automatisch die Font-Eigenschaft der
Formatvorlage Normal.
Schauen Sie ferner unter
CellStyle-Klasse (Seite 376)
ForeColor-Eigenschaft
Ermittelt oder legt die Schriftfarbe des Textes in der Zelle fest.
Syntax
[VB]
Public ForeColor As Color
[C#]
public Color ForeColor {get; set;}
[Delphi]
property ForeColor: Color;
Bemerkungen
Indem die ForeColor-Eigenschaft der Tabelle festgelegt wird, ändert sich automatisch die ForeColor-
Eigenschaft der Formatvorlage Normal.
Schauen Sie ferner unter
CellStyle-Klasse (Seite 376)
Format-Eigenschaft (CellStyle)
Ermittelt oder legt das Format fest, um Zellwerte in anzuzeigende Zeichenketten umzuwandeln.
Syntax
[VB]
Public Format As String
[C#]
public string Format {get; set}
[Delphi]
property Format: string;
Bemerkungen
• Visual Basic
Dim s As CellStyle = _flex.Styles.Add("BigNumber")
s.Format = "#,##0.##"
Dim r As CellRange = _flex.GetCellRange(10, 10)
rg.Style = s

384 · C1FlexGrid-Referenzverzeichnis
• C#
CellStyle s = _flex.Styles.Add("BigNumber");
s.Format = "#,##0.##";
CellRange r = _flex.GetCellRange(10,10);
rg.Style = s;
• Delphi
var
r: CellRange;
s: CellStyle;
begin
s := _flex.Styles.Add('BigNumber');
s.Format := '#,##0.##';
r := _flex.GetCellRange(10, 10);
rg.Style := s;
end;
Schauen Sie ferner unter
CellStyle-Klasse (Seite 376)
ImageAlign-Eigenschaft (CellStyle)
Ermittelt oder legt die Ausrichtung von Grafiken in einer Zelle fest.
Syntax
[VB]
Public ImageAlign As ImageAlignEnum
[C#]
public ImageAlignEnum ImageAlign {get; set;}
[Delphi]
property ImageAlign: ImageAlignEnum;
Eigenschaftswert
Einer der ImageAlignEnum-Werte. Der Standardwert ist ImageAlignEnum.LeftCenter.
Schauen Sie ferner unter
CellStyle-Klasse (Seite 376)
ImageMap-Eigenschaft
Ermittelt oder erstellt das ImageMap, um Zellwerte mit in dieser Zelle anzuzeigenden Grafiken zu
verknüpfen.
Syntax
[VB]
Public ImageMap As Idictionary
[C#]
public.Idictionary ImageMap {get; set;}

[Delphi]
property ImageMap: Idictionary;
Schauen Sie ferner unter
CellStyle-Klasse (Seite 376)
ImageMap-Eigenschaft (Column) (Seite 353)
ImageSpacing-Eigenschaft
ImageSpacing-Eigenschaft · 385
Ermittelt oder legt den Abstand in Pixeln zwischen der Grafik und dem Text in der Zelle fest.
Syntax
[VB]
Public ImageSpacing As Integer
[C#]
public int ImageSpacing {get; set;}
[Delphi]
property ImageSpacing: Integer;
Schauen Sie ferner unter
CellStyle-Klasse (Seite 376)
Margins-Eigenschaft
Ermittelt oder legt den Abstand in Pixeln zwischen den Zellkanten und dem Zellinhalt fest.
Syntax
[VB]
Public Margins As Margins
[C#]
public Margins Margins {get; set;}
[Delphi]
property Margins: Margins;
Schauen Sie ferner unter
CellStyle-Klasse (Seite 376)
Name-Eigenschaft (CellStyle)
Ermittelt oder legt den Namen für diesen CellStyle fest.

386 · C1FlexGrid-Referenzverzeichnis
Syntax
[VB]
Public Name As String
[C#]
public string Name {get; set}
[Delphi]
property Name: string;
Bemerkungen
Der styleName-Parameter muss einzigartig sein und darf keine geschweiften Klammern enthalten.
Schauen Sie ferner unter
CellStyle-Klasse (Seite 376)
TextAlign-Eigenschaft (CellStyle)
Ermittelt oder legt die Ausrichtung des Textes in einer Zelle fest.
Syntax
[VB]
Public TextAlign As TextAlignEnum
[C#]
public TextAlignEnum TextAlign {get; set;}
[Delphi]
property TextAlign: TextAlignEnum;
Eigenschaftswert
Einer der TextAlignEnum-Werte. Der Standardwert ist TextAlignEnum.GeneralCenter.
Schauen Sie ferner unter
CellStyle-Klasse (Seite 376)
TextDirection-Eigenschaft
Hiermit kann Text in vertikaler Richtung angezeigt werden (auf- oder abwärts orientiert).
Syntax
[VB]
Public-Eigenschaft TextDirection As TextDirectionEnum
[C#]
public TextDirectionEnum TextDirection {get; set;}

[Delphi]
property TextDirection: TextDirectionEnum;
Bemerkungen
TextEffect-Eigenschaft · 387
Zellen mit vertikalem Text können wie gewöhnlich Zeilen umbrechen und die Zellgröße automatisch
anpassen.
Schauen Sie ferner unter
CellStyle-Klasse (Seite 376)
TextEffect-Eigenschaft
Ermittelt oder legt den 3D-Effekt für den Text in der Zelle fest.
Syntax
[VB]
Public TextEffect As TextEffectEnum
[C#]
public TextEffectEnum TextEffect {get; set;}
[Delphi]
property TextEffect: TextEffectEnum;
Eigenschaftswert
Einer der TextEffectEnum-Werte. Der Standardwert ist TextEffectEnum.Flat.
Schauen Sie ferner unter
CellStyle-Klasse (Seite 376)
Trimming-Eigenschaft
Legt fest, wie Texte beschnitten werden, wenn diese zu lang für die Zelle sind.
Syntax
[VB]
Public Trimming As StringTrimming
[C#]
public StringTrimming Trimming {get; set;}
[Delphi]
property Trimming: StringTrimming;
Eigenschaftswert
Einer der StringTrimming-Werte. Der Standardwert ist StringTrimming.None.
Bemerkungen
Die StringTrimming-Aufzählung wird im System.Drawing-Namensbereich definiert.

388 · C1FlexGrid-Referenzverzeichnis
Schauen Sie ferner unter
CellStyle-Klasse (Seite 376)
UserData-Eigenschaft (CellStyle)
Ermittelt oder legt willkürliche Daten für diesen CellStyle fest.
Syntax
[VB]
Public UserData As Object
[C#]
public object UserData {get; set;}
[Delphi]
property UserData: Object;
Bemerkungen
Der UserData-Wert wird von der Tabelle intern nicht verwendet. Dieser ist für zusätzliche Daten
reserviert, die Sie mit dem CellStyle verknüpfen wollen.
Schauen Sie ferner unter
CellStyle-Klasse (Seite 376)
WordWrap-Eigenschaft
Legt fest, ob lange Zeichenketten in der Zelle umgebrochen werden.
Syntax
[VB]
Public WordWrap As Boolean
[C#]
public bool WordWrap {get; set;}
[Delphi]
property WordWrap: Boolean;
Bemerkungen
Die WordWrap-Eigenschaft steuert weiche Zeilenumbrüche. Zeichenketten, die Zeilenumbruchszeichen
enthalten, werden immer umgebrochen.
Schauen Sie ferner unter
CellStyle-Klasse (Seite 376)

CellStyle-Methoden
BuildString-Methode (CellStyle)
Gibt eine kompakte Zeichenkette zurück, die diesen CellStyle darstellt.
Syntax
[VB]
Public Function BuildString() As String
[C#]
public String BuildString ( )
[Delphi]
function BuildString: string;
Bemerkungen
BuildString-Methode (CellStyle) · 389
Die Zeichenkette stellt nur die in diesem Format definierten Elemente dar. Verwenden Sie die
ParseString-Methode, um diese Zeichenkette auf einen vorhandenen CellStyle anzuwenden.
Schauen Sie ferner unter
CellStyle-Klasse (Seite 376)
Clear-Methode (CellStyle)
Entfernt ausgewählte Elemente aus diesem CellStyle.
Syntax
[VB]
Public Sub Clear(flags StyleElementFlags)
[C#]
public void Clear (StyleElementFlags flags )
[Delphi]
procedure Clear(flags: StyleElementFlags);
Parameter Beschreibung
flags
Schauen Sie ferner unter
CellStyle-Klasse (Seite 376)
Beinhaltet eine Kombination von Flags, die festlegen, welche Formatelemente aus
der Formatvorlage entfernt werden. Wenn diese Parameter nicht gesetzt sind,
dann werden alle Elemente entfernt.

390 · C1FlexGrid-Referenzverzeichnis
MergeWith-Methode
Kopiert alle in einem Quell-CellStyle definierten Elemente in diese Formatvorlage. Formatelemente, die
nicht in diesem CellStyle enthalten sind, werden bewahrt.
Syntax
[VB]
Public Sub MergeWith(sourceStyle As CellStyle)
[C#]
public void MergeWith (CellStyle sourceStyle )
[Delphi]
procedure MergeWith(sourceStyle: CellStyle);
Bemerkungen
Mit dieser Methode können Sie visuelle Formate auf Zeilen und Spalten anwenden, ohne bereits
vorhandene Formatattribute, wie z.b. ComboList und Format, zu zerstören.
• Visual Basic
• C#
' add a combo box to a column (saved with the column style)
_flex.Cols(2).ComboList = "A|B|C|D|E|F"
' apply a new style to the column without disturbing the combo
_flex.Cols(2).Style.MergeWith(flex.Styles.Frozen)
' ** this wouldn't work, it would remove the ComboList saved with the
column style
'_ flex.Cols(2).Style = flex.Styles.Frozen
' add a combo box to a column (saved with the column style)
_flex.Cols[2].ComboList = "A|B|C|D|E|F";
' apply a new style to the column without disturbing the combo
_flex.Cols[2].Style.MergeWith(flex.Styles.Frozen);
' ** this wouldn't work, it would remove the ComboList saved with the
column style
'_flex.Cols[2].Style = flex.Styles.Frozen;
• Delphi
// add a combo box to a column (saved with the column style)
_flex.Cols[2].ComboList := 'A|B|C|D|E|F';
// apply a new style to the column without disturbing the combo
_flex.Cols[2].Style.MergeWith(flex.Styles.Frozen);
// ** this wouldn't work, it would remove the ComboList saved with the
column style
//_ flex.Cols(2).Style = flex.Styles.Frozen
Schauen Sie ferner unter
CellStyle-Klasse (Seite 376)

ParseString-Methode (CellStyle)
ParseString-Methode (CellStyle) · 391
Erstellt diesen CellStyle neu, basierend auf der in einer Zeichenkette enthaltenen Beschreibung.
Syntax
[VB]
Public Function ParseString(str As String) As Boolean
[C#]
public Boolean ParseString(string str)
[Delphi]
function ParseString(str: string): Boolean;
Parameter Beschreibung
styleDefinition
Bemerkungen
Eine von einer Zelle an die BuildString-Methode zurückgegebene Zeichenkette,
die eine Beschreibung von einer Formatvorlage enthält.
Die ParseString-Methode entfernt keine existierenden Elemente, wenn diese nicht in der Zeichenkette
mit den Formatdefinitionen enthalten sind. Verwenden Sie die Clear-Methode bevor Sie ParseString
aufrufen, um das aktuelle Format zurückzusetzen.
Schauen Sie ferner unter
CellStyle-Klasse (Seite 376)
Render-Methode
Rendert Zeichenketten und Grafiken mit den in diesem CellStyle definierten Attributen in ein Graphics-
Objekt.
Syntax
[VB]
Public Sub Render(g As Graphics, rc As Rectangle, s as String, img As Image, DrawCellFlags flags)
Public Sub Render(g As Graphics, rc As Rectangle, s as String, img As Image)
Public Sub Render(g As Graphics, rc As Rectangle, s as String)
Public Sub Render(g As Graphics, rc As Rectangle, img As Image)
[C#]
public void Render(Graphics g, Rectangle rc, string s, Image img, DrawCellFlags flags);
public void Render(Graphics g, Rectangle rc, string s, Image img);
public void Render(Graphics g, Rectangle rc, string s);
public void Render(Graphics g, Rectangle rc, Image img);

392 · C1FlexGrid-Referenzverzeichnis
[Delphi]
procedure Render(g: Graphics, rc: Rectangle, s: String, img: Image, DrawCellFlags flags);
procedure Render(g: Graphics, rc: Rectangle, s: String, img: Image);
procedure Render(g: Graphics, rc: Rectangle, s: String);
procedure Render(g: Graphics, rc: Rectangle, img: Image);
Parameter Beschreibung
g Das Graphics-Objekt, in dem der Text und die Grafik gerendert werden soll.
rc Das Rectangle, in welchem der Text und die Grafik gerendert werden soll.
s Der Text, der gerendert werden soll.
img Die Garfik, die gerendert werden soll.
flags
Bemerkungen
EineKombination von einem oder mehreren Formatelementen die gerendert
werden sollen (Hintergrund, Rahmen, Inhalt). Wenn diese Parameter nicht gesetzt
sind, dann werden alle Elemente gerendert.
Diese Methode wird intern von der Tabelle verwendet, um alle Zellen zu rendern. Sie stellt einen
bequemen Mechanismus für das erneute Verwenden von CellStyle-Objekten zur Verfügung, um Text
und Grafiken in andere Steuerungen zu rendern.
Schauen Sie ferner unter
CellStyle-Klasse (Seite 376)
CellBorder-Klassen
Die CellBorder-Klasse legt das Aussehen des Rahmens in einem CellStyle-Objekt fest. CellBorder
definiert den Typ der Tabellenlinien in der Steuerung und kann über die Border-Eigenschaft von
CellStyle abgefragt werden.
Alle CellBorder-Mitglieder
CellBorder-Klasseneigenschaften (public)
Direction
Unterstützt vom .NET-Compact-Framework.
Color
Unterstützt vom .NET-Compact-Framework.
Legt die Ausrichtung des Rahmens fest.
Legt die Farbe des Rahmens fest.
Style Legt den Typ des Rahmens fest, der um die Zelle
gezeichnet wird.
Width
Unterstützt vom .NET-Compact-Framework.
Legt die Breite des Rahmens in Pixeln fest.

CellBorder-Eigenschaften
Direction-Eigenschaft
Legt die Ausrichtung des Rahmens fest.
Syntax
[VB]
Public Direction As BorderDirEnum
[C#]
public BorderDirEnum Direction {get; set;}
[Delphi]
property Direction: BorderDirEnum;
Eigenschaftswert
Einer der BorderStyleEnum-Werte. Der Standardwert ist BorderStyleEnum.Both.
Schauen Sie ferner unter
CellBorder-Klasse (Seite 392)
Color-Eigenschaft
Legt die Farbe des Rahmens fest.
Syntax
[VB]
Public Color As Color
[C#]
public Color Color {get; set;}
[Delphi]
property Color: Color;
Bemerkungen
Direction-Eigenschaft · 393
Die Color-Eigenschaft betrifft nicht die 3D-Rahmen, die mit Systemfarben gezeichnet werden.
Schauen Sie ferner unter
CellBorder-Klasse (Seite 392)
Style-Eigenschaft
Legt den Typ des Rahmens fest, der um die Zelle gezeichnet wird.

394 · C1FlexGrid-Referenzverzeichnis
Syntax
[VB]
Public Style As BorderStyleEnum
[C#]
public BorderStyleEnum Style {get; set;}
[Delphi]
property Style: BorderStyleEnum;
Eigenschaftswert
Einer der BorderStyleEnum-Werte. Der Standardwert ist BorderStyleEnum.Flat.
Schauen Sie ferner unter
CellBorder-Klasse (Seite 392)
Width-Eigenschaft (CellBorder)
Legt die Breite des Rahmens in Pixeln fest.
Syntax
[VB]
Public Width As Integer
[C#]
public int Width {get; set;}
[Delphi]
property Width: Integer;
Bemerkungen
Die Width-Eigenschaft betrifft nicht die 3D-Rahmen, die mit den vordefinierten Breiten (je nach
Rahmentyp: 1 oder 2 Pixel) gezeichnet werden.
Schauen Sie ferner unter
CellBorder-Klasse (Seite 392)
Node-Klasse
Wenn Sie die C1FlexGrid-Steuerung für eine Gliederung verwenden, dann können Zeilen als
Gliederungsknoten verwendet werden. Die Node-Klasse beinhaltet Eigenschaften, mit denen Sie diese
Zeilen verändern können (ein- und ausklappen, verschieben oder sortieren). Sie können Knotenzeilen mit
der Subtotal-Methode oder, indem Sie die IsNode-Eigenschaft der Zeile auf TRUE setzen, erstellen.

Alle Node-Mitglieder
Node-Klasseneigenschaften (public)
Children
Unterstützt vom .NET-Compact-Framework.
Collapsed
Unterstützt vom .NET-Compact-Framework.
Data
Unterstützt vom .NET-Compact-Framework.
Expanded
Unterstützt vom .NET-Compact-Framework.
Image
Unterstützt vom .NET-Compact-Framework.
Key
Unterstützt vom .NET-Compact-Framework.
Level
Unterstützt vom .NET-Compact-Framework.
Row
Unterstützt vom .NET-Compact-Framework.
Node-Klassenmethoden (public)
AddNode
Unterstützt vom .NET-Compact-Framework.
EnsureVisible
Unterstützt vom .NET-Compact-Framework.
GetCellRange
Unterstützt vom .NET-Compact-Framework.
GetNode
Unterstützt vom .NET-Compact-Framework.
Move
Unterstützt vom .NET-Compact-Framework.
RemoveNode
Unterstützt vom .NET-Compact-Framework.
Select
Unterstützt vom .NET-Compact-Framework.
Sort
Unterstützt vom .NET-Compact-Framework.
Width-Eigenschaft (CellBorder) · 395
Ermittelt die Anzahl der diesem Knoten
untergeordneten Knoten.
Ermittelt oder legt fest, ob dieser Knoten
zusammengeklappt ist.
Ermittelt oder legt die Daten in dieser Knotenzeile in
der Spalte fest, die den Gliederungsbaum enthält.
Ermittelt oder legt fest, ob dieser Knoten aufgeklappt
ist.
Ermittelt oder legt die Grafik in dieser Knotenzeile in
der Spalte fest, die den Gliederungsbaum enthält.
Ermittelt oder legt UserData von dieser Knotenzeile
fest.
Ermittelt oder legt die Gliederungsebene für diesen
Knoten fest.
Gibt einen Verweis auf das zu diesem Knoten
gehörende Zeilenobjekt zurück.
Erstellt eine Knotenzeile relative zu diesem Knoten
an einer bestimmten Position.
Stellt sicher, dass dieser Knoten sichtbar ist, so dass
dessen Mutterknoten aufgeklappt werden und die
Zeile auf den Bildschirm gescrollt wird.
Gibt ein CellRange-Objekt mit dieser Zeile und allen
untergeordneten Zeilen zurück.
Gibt einen Verweis auf eine Knotenzeile relativ zu
diesem Knoten an einer bestimmten Position zurück.
Verschiebt einen Knoten auf eine neue Position.
Entfernt diese und alle ihre untergeordneten
Knotenzeilen aus der Tabelle (Knoten und Daten).
Wählt den aktuellen Knoten aus.
Sortiert die aktuellen Knoten in bestimmter
Reihenfolge.

396 · C1FlexGrid-Referenzverzeichnis
Node-Eigenschaften
Children-Eigenschaft
Ermittelt die Anzahl der diesem Knoten untergeordneten Knoten. Die den untergeordneten Knoten
untergeordneten Knoten werden nicht mit gezählt.
Syntax
[VB]
Public Children As Integer
[C#]
public int Children {get;}
[Delphi]
property Children: Integer;
Bemerkungen
Schauen Sie unter „Benutzerdefinierte Gliederungsbäume erstellen“ (Seite 53) und „Übung zur
Gliederung“ (Seite 88) für Verwendungsbeispiele über Node-Objekte nach.
Schauen Sie ferner unter
Node-Klasse (Seite 394)
Collapsed-Eigenschaft
Ermittelt oder legt fest, ob dieser Knoten zusammengeklappt ist.
Syntax
[VB]
Public Collapsed As Boolean
[C#]
public bool Collapsed {get; set;}
[Delphi]
property Collapsed: Boolean;
Bemerkungen
Schauen Sie unter „Benutzerdefinierte Gliederungsbäume erstellen“ (Seite 53) und „Übung zur
Gliederung“ (Seite 88) für Verwendungsbeispiele über Node-Objekte nach.
Schauen Sie ferner unter
Node-Klasse (Seite 394)
Data-Eigenschaft (Node)
Ermittelt oder legt die Daten in dieser Knotenzeile in der Spalte fest, die den Gliederungsbaum enthält.

Syntax
[VB]
Public Data As Object
[C#]
public object Data {get; set;}
[Delphi]
property Data: Object;
Bemerkungen
Expanded-Eigenschaft · 397
Der nachfolgende Code zeigt die Beziehung zwischen der Node.Data-Eigenschaft und den GetData- und
SetData-Methoden der Tabelle:
• Visual Basic
• C#
Dim o1 As Object = node.Data
Dim row As Integer = nd.Row.SafeIndex
Dim col As Integer = flex.Tree.Column
Dim o2 As Object = flex(row, col)
Debug.Assert(o1.Equals(o2), "o1 and o2 refer to the same object")
object o1 = node.Data;
int row = nd.Row.SafeIndex;
int col = flex.Tree.Column;
object o2 = flex[row, col];
Debug.Assert(o1.Equals(o2), "o1 and o2 refer to the same object");
• Delphi
var
o2: System.Object;
col: Integer;
row: Integer;
o1: System.Object;
begin
o1 := node.Data;
row := nd.Row.SafeIndex;
col := flex.Tree.Column;
o2 := flex[row];
Debug.Assert(o1.Equals(o2), 'o1 and o2 refer to the same object');
end;
Schauen Sie ferner unter
Node-Klasse (Seite 394)
Expanded-Eigenschaft
Ermittelt oder legt fest, ob dieser Knoten aufgeklappt ist.
Syntax
[VB]
Public Expanded As Boolean

398 · C1FlexGrid-Referenzverzeichnis
[C#]
public bool Expanded {get; set;}
[Delphi]
property Expanded: Boolean;
Bemerkungen
Schauen Sie unter „Benutzerdefinierte Gliederungsbäume erstellen“ (Seite 53) und „Übung zur
Gliederung“ (Seite 88) für Verwendungsbeispiele über Node-Objekte nach.
Schauen Sie ferner unter
Node-Klasse (Seite 394)
Image-Eigenschaft (Node)
Ermittelt oder legt die Grafik in dieser Knotenzeile in der Spalte fest, die den Gliederungsbaum enthält.
Syntax
[VB]
Public Image As Image
[C#]
public Image Image {get; set;}
[Delphi]
property Image: Image;
Bemerkungen
Der nachfolgende Code zeigt die Beziehung zwischen der Node. Image-Eigenschaft und den
GetCellImage- und SetCellImage-Methoden der Tabelle:
• Visual Basic
• C#
Dim img1 As Image = node.Image
Dim row As Integer = nd.Row.SafeIndex
Dim col As Integer = flex.Tree.Column
Dim img2 As Image = flex.GetCellImage(row, col)
Debug.Assert(img1.Equals(img2), "img1 and img2 are the same image")
Image img1 = node.Image;
int row = nd.Row.SafeIndex;
int col = flex.Tree.Column;
Image img2 = flex.GetCellImage(row, col);
Debug.Assert(img1.Equals(img2), "img1 and img2 are the same image");
• Delphi
var
img2: Image;
col: Integer;
row: Integer;
img1: Image;

Key-Eigenschaft · 399
begin
img1 := node.Image;
row := nd.Row.SafeIndex;
col := flex.Tree.Column;
img2 := flex.GetCellImage(row, col);
Debug.Assert(img1.Equals(img2), 'img1 and img2 are the same image');
end;
Schauen Sie ferner unter
Node-Klasse (Seite 394)
Key-Eigenschaft
Ermittelt oder legt UserData von dieser Knotenzeile fest.
Syntax
[VB]
Public Key As Object
[C#]
public object Key {get; set;}
[Delphi]
property Key: Object;
Bemerkungen
Der nachfolgende Code zeigt die Beziehung zwischen der Node. Key-Eigenschaft und der
Row.UserData-Eigenschaft:
• Visual Basic
• C#
Dim o1 As Object = node.Key
Dim o2 As Object = nd.Row.UserData
Debug.Assert(o1.Equals(o2), "o1 and o2 refer to the same object")
object o1 = node.Key;
object o2 = nd.Row.UserData;
Debug.Assert(o1.Equals(o2), "o1 and o2 refer to the same object");
• Delphi
var
o2: System.Object;
o1: System.Object;
begin
o1 := node.Key;
o2 := nd.Row.UserData;
Debug.Assert(o1.Equals(o2), 'o1 and o2 refer to the same object');
end;
Schauen Sie ferner unter
Node-Klasse (Seite 394)

400 · C1FlexGrid-Referenzverzeichnis
Level-Eigenschaft
Ermittelt oder legt die Gliederungsebene für diesen Knoten fest.
Syntax
[VB]
Public Level As Integer
[C#]
public int Level {get; set;}
[Delphi]
property Level: Integer;
Bemerkungen
Höhere Ebenen stehen für tiefere Verschachtelungen. Setzen Sie die Ebene auf 0, um einen Quellknoten,
oder auf einen negativen Wert, um einen im Gliederungsbaum nicht sichtbaren Knoten zu erstellen.
Schauen Sie unter „Benutzerdefinierte Gliederungsbäume erstellen“ (Seite 53) und „Übung zur
Gliederung“ (Seite 88) für Verwendungsbeispiele über Node-Objekte nach.
Schauen Sie ferner unter
Node-Klasse (Seite 394)
Row-Eigenschaft (Node)
Gibt einen Verweis auf das zu diesem Knoten gehörende Zeilenobjekt zurück.
Syntax
[VB]
Public Row As Row
[C#]
public Row Row {get;}
[Delphi]
property Row: Row;
Schauen Sie ferner unter
Node-Klasse (Seite 394)
Node-Methoden
AddNode-Methode
Erstellt eine Knotenzeile relativ zu diesem Knoten an einer bestimmten Position.

Syntax
[VB]
Public Function AddNode(position As NodeTypeEnum, data As Object) As Node
EnsureVisible-Methode · 401
Public Function AddNode(position As NodeTypeEnum, data As Object, key As Object, img As Image)
As Node
[C#]
public Node AddNode (NodeTypeEnum position , Object data , Object key , Image img )
public Node AddNode (NodeTypeEnum position , Object data )
[Delphi]
function AddNode(position: NodeTypeEnum; data: Object): Node;
function AddNode(position: NodeTypeEnum; data: Object; key: Object; img: Image): Node;
Parameter Beschreibung
position
Ein Wert der NodeTypeEnum-Aufzählung, der festlegt, wo der neue Knoten in
Bezug auf diesen Knoten hinzugefügt werden soll (z.B. Kind oder Sibling).
data Wert der Data-Eigenschaft für den neuen Knoten.
key Wert der Key-Eigenschaft für den neuen Knoten.
image Wert der Image-Eigenschaft für den neuen Knoten.
Rückgabewert
Ein Verweis auf den neu der Tabelle hinzugefügten Node.
Schauen Sie ferner unter
Node-Klasse (Seite 394)
EnsureVisible-Methode
Stellt sicher, dass dieser Knoten sichtbar ist, so dass dessen Mutterknoten aufgeklappt werden und die
Zeile auf den Bildschirm gescrollt wird, wenn nötig.
Syntax
[VB]
Public Sub EnsureVisible()
[C#]
public void EnsureVisible ( )
[Delphi]
procedure EnsureVisible;

402 · C1FlexGrid-Referenzverzeichnis
Schauen Sie ferner unter
Node-Klasse (Seite 394)
GetCellRange-Methode (Node)
Gibt ein CellRange-Objekt mit dieser Zeile und allen untergeordneten Zeilen zurück (Knoten- und
Datenzeilen).
Syntax
[VB]
Public Function GetCellRange() As CellRange
[C#]
public CellRange GetCellRange ( )
[Delphi]
function GetCellRange: CellRange;
Bemerkungen
Das zurückgegebene CellRange-Objekt beinhaltet alle Spalten.
Schauen Sie ferner unter
Node-Klasse (Seite 394)
GetNode-Methode
Gibt einen Verweis auf eine Knotenzeile relativ zu diesem Knoten an einer bestimmten Position zurück
(z.B. erstes Kind, letzer Sibling).
Syntax
[VB]
Public Function GetNode(position As NodeTypeEnum) As Node
[C#]
public Node GetNode (NodeTypeEnum position )
[Delphi]
function GetNode(position: NodeTypeEnum): Node;
Bemerkungen
Wenn der gewünschte Knoten nicht exisitert, dann gibt GetNode Null zurück (z.B. der Quellknoten
besitzt keinen vorhergehenden Sibling).
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
Node-Klasse (Seite 394)

Move-Methode
Verschiebt einen Knoten auf eine neue Position.
Syntax
[VB]
Public Function Move(moveTo As NodeMoveEnum, targetNode As Node) As Boolean
Public Function Move(moveTo As NodeMoveEnum) As Boolean
[C#]
public Boolean Move (NodeMoveEnum moveTo , Node targetNode )
public Boolean Move (NodeMoveEnum moveTo )
[Delphi]
function Move(moveTo: NodeMoveEnum; tragetNode: Node): Boolean;
function Move(moveTo: NodeMoveEnum): Boolean;
Parameter Beschreibung
moveTo
targetNode
Rückgabewert
Ein Wert der NodeMoveEnum-Aufzählung, der festlegt, wohin der Knoten in
Bezug auf seine derzeitige Position verschoben wird.
Zu verwendendes Node-Zielobjekt, wenn der moveTo-Parameter auf
NodeMoveEnum.ChildOf steht.
Gibt TRUE zurück, wenn die Methode erfolgreich war, anderfalls wird FALSE ausgegeben.
Schauen Sie ferner unter
Node-Klasse (Seite 394)
RemoveNode-Methode
Entfernt diese und alle ihre untergeordneten Knotenzeilen aus der Tabelle (Knoten und Daten).
Syntax
[VB]
Public Sub RemoveNode()
[C#]
public void RemoveNode ( )
[Delphi]
procedure RemoveNode;
Move-Methode · 403

404 · C1FlexGrid-Referenzverzeichnis
Schauen Sie ferner unter
Node-Klasse (Seite 394)
Select-Methode (Node)
Wählt den aktuellen Knoten aus.
Syntax
[VB]
Public Sub Select()
[C#]
public void Select ( )
[Delphi]
procedure Select;
Schauen Sie ferner unter
Node-Klasse (Seite 394)
Sort-Methode (Node)
Sortiert die aktuellen Unterknoten in bestimmter Reihenfolge.
Syntax
[VB]
Public Sub Sort(order As SortFlags)
Public Sub Sort(order As SortFlags, col1 As Integer, col2 As Integer)
[C#]
public void Sort (SortFlags order )
public void Sort (SortFlags order , int col1 , int col2 )
[Delphi]
procedure Sort(order: SortFlags);
procedure Sort(order: SortFlags; col1: Integer; col2: Integer);
Parameter Beschreibung
order
col
Bemerkungen
Ein oder mehrere Flags aus der SortFlags-Aufzählung, die festlegen, wie die Knoten
sortiert werden.
Index der Spalte, nach deren Inhalten sortiert werden soll. Wenn dieser Parameter
nicht festgelegt ist, dann wird standardmäßig nach der Spalte sortiert, die den Baum
anzeigt. Diese Spalte wird von der Column-Eigenschaft des Trees bestimmt.
Diese Methode betrifft nicht die Reihenfolge der Zeilen, die keine Knoten sind.

Schauen Sie ferner unter
Node-Klasse (Seite 394)
GridGlyphs-Klasse
Item-Eigenschaft (GridGlyphs) · 405
Die GridGlyphs-Klasse stellt ein Array mit Glyphen (Grafiken) dar, die nach dem Glyphentyp indiziert
sind (GlyphEnum-Typ).
Dieses Feld enthält von der Tabelle verwendete Grafiken, um z.B. Spaltensortierung, ein- und
ausgeklappte Gliederungsgruppen, Kontrollkästchen, Cursor und Fehlerinformation anzuzeigen.
Verwenden Sie die Glyphs-Eigenschaft um ein GridGlyphs-Objekt zu holen und verwenden Sie den
Indizierer um eine Grafik abzurufen oder festzulegen.
Alle GridGlyphs-Mitglieder
GridGlyphs-Klasseneigenschaften (public)
Item Ermittelt oder legt den Glyph für ein bestimmtes GlyphEnum fest.
GridGlyphs-Eigenschaften
Item-Eigenschaft (GridGlyphs)
Eine, von der Tabelle verwendete Grafik, um Information über eine Zeile, Spalte oder Zelle zu verbreiten.
Syntax
[VB]
Public Item(type As GlyphEnum) As Image
[C#]
public Image this[GlyphEnum type] {get;set;}
[Delphi]
property Item(type: GlyphEnum): Image;
Bemerkungen
Verwenden Sie diese Eigenschaft um die von der Tabelle verwendete Grafik zu verändern, die
Information über eine Zeile, Spalte oder Zelle verbreiten. Zum Beispiel, der nachfolgende Quellcode
ändert die Grafik, welche die Richtung der Sortierung einer Spalte anzeigt:
• Visual Basic
• C#
_flex.Glyphs(GlyphEnum.Ascending) = imgAscending
_flex.Glyphs(GlyphEnum.Descending) = imgDescending
_flex.Glyphs[GlyphEnum.Ascending] = imgAscending;
_flex.Glyphs[GlyphEnum.Descending] = imgDescending;
• Delphi
_flex.Glyphs[GlyphEnum.Ascending] := imgAscending;

406 · C1FlexGrid-Referenzverzeichnis
_flex.Glyphs[GlyphEnum.Descending] := imgDescending;
Schauen Sie ferner unter
GridGlyphs-Klasse (Seite 405)
GridTree-Klasse
Wenn Sie die C1FlexGrid-Steuerung für eine Gliederung verwenden, dann können Zeilen als
Gliederungsknoten verwendet werden. Die GridTree-Klasse beinhaltet Eigenschaften, mit denen Sie das
Aussehen, die Position und das Verhalten des Gliederungbaums festlegen können. Jede Tabelle besitzt
ein einziges GridTree-Objekt, welches mit der Tree-Eigenschaft abgerufen werden kann.
Alle GridTree-Mitglieder
GridTree-Klasseneigenschaften (public)
Column
Indent
LineColor
LineStyle
NodeImageCollapsed
NodeImageExpanded
Ermittelt oder legt den Index der Spalte fest, in welcher der
Gliederungsbaum angezeigt werden soll.
Ermittelt oder legt den Einzug einer jeden Gliederungsebene
in Pixeln fest.
Ermittelt oder legt die Farbe der Linien im Gliederungsbaum
fest.
Ermittelt oder legt den Typ der Linien im Gliederungsbaum
fest.
Ermittelt oder legt die Grafik fest, die neben einem
eingeklappten Knoten angezeigt wird.
Ermittelt oder legt die Grafik fest, die neben einem
ausgeklappten Knoten angezeigt wird.
Style Ermittelt oder legt das Format des Gliederungsbaumes fest.
GridTree-Klassenmethoden (public)
Show
Klappt alle Knoten bis zu einer betimmten Ebene auf und alle
anderen zu.
Sort Sortiert alle Knoten auf einer gegebenen Ebene.
GridTree-Eigenschaften
Column-Eigenschaft
Ermittelt oder legt den Index der Spalte fest, in welcher der Gliederungsbaum angezeigt werden soll.

Syntax
[VB]
Public Column As Integer
[C#]
public int Column {get; set;}
[Delphi]
propery Column: Integer;
Bemerkungen
Indent-Eigenschaft · 407
Standardmäßig ist diese Eigenschaft auf -1 gesetzt, so dass der Gliederungsbaum ausgeblendet ist.
Schauen Sie ferner unter
GridTree-Klasse (Seite 406)
Indent-Eigenschaft
Ermittelt oder legt den Einzug einer jeden Gliederungsebene in Pixeln fest.
Syntax
[VB]
Public Indent As Integer
[C#]
public int Indent {get; set;}
[Delphi]
property Indent: Integer;
Bemerkungen
Wenn Sie die Indent-Eigenschaft auf einen Wert stellen, der zu klein ist, um die NodeImageCollapsed-
und NodeImageExpanded-Grafiken anzuzeigen, dann passt die Tabelle automatisch diesen an, so dass
die Grafiken in den Einzug passen.
Schauen Sie ferner unter
GridTree-Klasse (Seite 406)
LineColor-Eigenschaft
Ermittelt oder legt die Farbe der Linien im Gliederungsbaum fest.
Syntax
[VB]
Public LineColor As Color
[C#]
public Color LineColor {get; set;}

408 · C1FlexGrid-Referenzverzeichnis
[Delphi]
property LineColor: Color;
Bemerkungen
Siehe auch Style-Eigenschaft.
Schauen Sie ferner unter
GridTree-Klasse (Seite 406)
LineStyle-Eigenschaft
Ermittelt oder legt den Typ der Linien im Gliederungsbaum fest.
Syntax
[VB]
Public LineStyle As DashStyle
[C#]
public DashStyle LineStyle {get; set;}
[Delphi]
property LineStyle: DashStyle;
Bemerkungen
Legt das Format fest, mit dem der Gliederungsbaum gezeichnet wird. Standardmäßig ist diese
Eigenschaft auf DashStyle.Dot gesetzt, so dass der Baum mit einer gepunkteten Linie gezeichnet wird.
Schauen Sie ferner unter
GridTree-Klasse (Seite 406)
NodeImageCollapsed-Eigenschaft
Ermittelt oder legt die Grafik fest, die neben einem eingeklappten Knoten angezeigt wird.
Syntax
[VB]
Public NodeImageCollapsed As Image
[C#]
public Image NodeImageCollapsed {get; set;}
[Delphi]
property NodeImageCollapsed: Image;
Bemerkungen
Wenn Sie diese Eigenschaft auf Null stellen, dann wird sie zurückgesetzt und es werden die
Standardgrafiken der Tabelle verwendet (ein Pluszeichen). Verwenden Sie die Tree.Style-Eigenschaft,
um die Grafiken auszublenden.

Schauen Sie ferner unter
GridTree-Klasse (Seite 406)
NodeImageExpanded-Eigenschaft
NodeImageExpanded-Eigenschaft · 409
Ermittelt oder legt die Grafik fest, die neben einem ausgeklappten Knoten angezeigt wird.
Syntax
[VB]
Public NodeImageExpanded As Image
[C#]
public Image NodeImageExpanded {get; set;}
[Delphi]
property NodeImageExpanded: Image;
Bemerkungen
Wenn Sie diese Eigenschaft auf Null stellen, dann wird sie zurückgesetzt und es werden die
Standardgrafiken der Tabelle verwendet (ein Pluszeichen). Verwenden Sie die Tree.Style-Eigenschaft,
um die Grafiken auszublenden.
Schauen Sie ferner unter
GridTree-Klasse (Seite 406)
Style-Eigenschaft (GridTree)
Ermittelt oder legt das Format des Gliederungsbaumes fest.
Syntax
[VB]
Public Style As TreeStyleFlags
[C#]
public TreeStyleFlags Style {get; set;}
[Delphi]
property Style: TreeStyleFlags;
Bemerkungen
Verwenden Sie die Style-Eigenschaft um festzulegen, ob der Gliederungsbaum mit Linien die Knoten
und die Ein- und Ausklappschaltflächen verbinden soll, und die Column-Eigenschaft, um festzulegen, ob
die Tabelle den Gliederungsbaum anzeigen soll.
Schauen Sie ferner unter
GridTree-Klasse (Seite 406)

410 · C1FlexGrid-Referenzverzeichnis
GridTree-Methoden
Show-Methode
Klappt alle Knoten bis zu einer betimmten Ebene auf und alle anderen zu.
Syntax
[VB]
Public Sub Show(level As Integer)
[C#]
public void Show ( int level )
[Delphi]
procedure Show(level: Integer);
Parameter Beschreibung
level
Schauen Sie ferner unter
GridTree-Klasse (Seite 406)
Sort-Methode (GridTree)
Die anzuzeigende Ebene. Jeder Knoten mit einem tieferen Level als dieses wird
zusammengeklappt und alle anderen aufgeklappt.
Sortiert alle Knoten auf einer gegebenen Ebene.
Syntax
[VB]
Public Sub Sort(level As Integer, order As SortFlags, col1 As Integer, col2 As Integer)
[C#]
public void Sort ( int level , SortFlags order , int col1 , int col2 )
[Delphi]
procedure Sort(level: Integer; order: SortFlags; col12: Integer; col2: Integer);
Parameter Beschreibung
level Die zu sortierende Ebene. Alle Knoten auf dieser Ebene werden sortiert.
order
Ein oder mehrere Werte der SortFlags-Aufzählung, die festlegen, wie das
Sortieren erfolgt.
col1, col2 Ein Spaltenbereich, der die Werte enthält, nach denen sortiert werden soll.

Bemerkungen
Sort-Methode (GridTree) · 411
Die Tabellenmethode Sort sortiert Datenzeilen innerhalb eines Knotens. Sie verschiebt nicht die
Knotenzeilen.
Die Tree.Sort-Methode sortiert die Knotenzeilen und verschiebt alle Datenzeilen des Knotens mit. Zum
Beispiel, der nachfolgende Quellcode sortiert eine Datengliederung nach den Werten in der „Sales“-
Spalte in aufsteigender Richtung:
• Visual Basic
• C#
Private Sub SortTree(sf As SortFlags)
Dim col As Integer = flex.Cols("Sales").SafeIndex
flex.Tree.Sort(0, sf, col, col) '

412 · C1FlexGrid-Referenzverzeichnis
Gliederungsbaum absteigend nach „Sales“ sortiert.
Schauen Sie ferner unter
GridTree-Klasse (Seite 406)
GridPrinter-Klasse
Die PrintParameters-Eigenschaft gibt einen Verweis auf das GridPrinter-Objekt zurück, das den
Ausdruck der Tabelle verwaltet. Das GridPrinter-Objekt beinhaltet Eigenschaften, mit denen Sie
geringwertige Parameter des Druckvorgangs, z.B. Seiten- und Druckereinrichtungen, steuern können.
Alle GridPrinter-Mitglieder
GridPrinter-Klasseneigenschaften (public)
Footer Hiermit können Sie die Fußzeile vom PrintDocument-Objekt der Tabelle
anpassen.
FooterFont Legt die Schriftart für die Fußzeile fest, wenn die Tabelle mit der PrintGrid-
Methode gedruckt wird.
Header Hiermit können Sie die Kopfzeile vom PrintDocument-Objekt der Tabelle
anpassen.
HeaderFont Legt die Schriftart für die Kopfzeile fest, wenn die Tabelle mit der PrintGrid-
Methode gedruckt wird.
PageNumber Gibt die Seitenzahl der zu druckenden Seite zurück.
PageCount Gibt die Gesamtzahl der Seiten im zu druckenden Dokument zurück.
PrintDocument Gibt das PrintDocument-Objekt zurück, das die Seite und die
Druckereinstellungen festlegt.
PrintPreviewDialog Hiermit können Sie Eigenschaften für das integrierte Druckvorschaufenster
festlegen.

GridPrinter-Eigenschaften
Footer-Eigenschaft
Footer-Eigenschaft · 413
Hiermit können Sie die Fußzeile vom PrintDocument-Objekt der Tabelle anpassen, für den Fall, dass Sie
die Tabellenvorschau in ihrem eigenen Fenster anzeigen wollen.
Syntax
[VB]
Public-Eigenschaft Footer As String
[C#]
public string Footer {get; set;}
[Delphi]
property Footer: string;
Beispiel
Der folgende Quellcode passt die Fußzeile des PrintDocument-Objeks der Tabelle an:
• Visual Basic
• C#
Dim gp As GridPrinter = _flex.PrintParameters
gp.Footer = "Hello" + ControlChars.Tab + "World" + ControlChars.Tab +
"Footer"
gp.PrintGridFlags = C1.Win.C1FlexGrid.PrintGridFlags.FitToPageWidth
Dim dlg As New PrintPreviewDialog()
dlg.Document = gp.PrintDocument
dlg.ShowDialog()
GridPrinter gp = _flex.PrintParameters;
gp.Footer = "Hello\tWorld\tFooter";
gp.PrintGridFlags =
C1.Win.C1FlexGrid.PrintGridFlags.FitToPageWidth;
PrintPreviewDialog dlg = new PrintPreviewDialog();
dlg.Document = gp.PrintDocument;
dlg.ShowDialog();
• Delphi
var
dlg: PrintPreviewDialog;
gp: GridPrinter;
begin
gp := _flex.PrintParameters;
gp.Footer := 'Hello'#9'World'#9'Footer';
gp.PrintGridFlags := C1.Win.C1FlexGrid.PrintGridFlags.FitToPageWidth;
dlg := PrintPreviewDialog.Create;
dlg.Document := gp.PrintDocument;
dlg.ShowDialog;
end;
Schauen Sie ferner unter
GridPrinter-Klasse (Seite 412)

414 · C1FlexGrid-Referenzverzeichnis
FooterFont-Eigenschaft
Legt die Schriftart für die Fußzeile fest, wenn die Tabelle mit der PrintGrid-Methode gedruckt wird.
Syntax
[VB]
Public FooterFont As Font
[C#]
public Font FooterFont {get; set;}
[Delphi]
property FooterFont: Font;
Beispiel
Der folgende Quellcode druckt die Tabelle mit einer großen und fetten Fußzeile aus:
• Visual Basic
• C#
Dim gp As GridPrinter = flex.PrinterSettings
gp.FooterFont = New Font("Arial", 16, FontStyle.Bold)
flex.PrintGrid("my grid", PrintGridFlags.ActualSize, _
"Header" + vbTab + vbTab + "{0}", "Footer")
GridPrinter gp = flex.PrinterSettings;
gp.FooterFont = new Font("Arial", 16, FontStyle.Bold);
flex.PrintGrid("my grid",
PrintGridFlags.ActualSize, "Header\t\t{0}", "Footer");
• Delphi
var
gp: GridPrinter;
begin
gp := flex.PrinterSettings;
gp.FooterFont := Font.Create('Arial', 16, FontStyle.Bold);
flex.PrintGrid('my grid', PrintGridFlags.ActualSize,
'Header'#9#9'{0}', 'Footer');
end;
Schauen Sie ferner unter
GridPrinter-Klasse (Seite 412)
Header-Eigenschaft
Hiermit können Sie die Kopfzeile vom PrintDocument-Objekt der Tabelle, für den Fall, dass Sie die
Tabellenvorschau in ihrem eigenen Fenster anzeigen wollen, anpassen.
Syntax
[VB]
Public-Eigenschaft Header As String

[C#]
public string Header {get; set;}
[Delphi]
property Header: string;
Beispiel
Der folgende Quellcode passt die Kopfzeile des PrintDocument-Objeks der Tabelle an:
• Visual Basic
• C#
HeaderFont-Eigenschaft · 415
Dim gp As GridPrinter = _flex.PrintParameters
gp.Header = "Hello" & vbTab & "World" &_
vbTab + "Header"
gp.PrintGridFlags = C1.Win.C1FlexGrid.PrintGridFlags.FitToPageWidth
Dim dlg As New PrintPreviewDialog()
dlg.Document = gp.PrintDocument
dlg.ShowDialog()
GridPrinter gp = _flex.PrintParameters;
gp.Header = "Hello\tWorld\tHeader";
gp.PrintGridFlags =
C1.Win.C1FlexGrid.PrintGridFlags.FitToPageWidth;
PrintPreviewDialog dlg = new PrintPreviewDialog();
dlg.Document = gp.PrintDocument;
dlg.ShowDialog();
• Delphi
var
dlg: PrintPreviewDialog;
gp: GridPrinter;
begin
gp := _flex.PrintParameters;
gp.Header := 'Hello'#9'World'#9'Header';
gp.PrintGridFlags := C1.Win.C1FlexGrid.PrintGridFlags.FitToPageWidth;
dlg := PrintPreviewDialog.Create;
dlg.Document := gp.PrintDocument;
dlg.ShowDialog;
end;
Schauen Sie ferner unter
GridPrinter-Klasse (Seite 412)
HeaderFont-Eigenschaft
Legt die Schriftart für die Kopfzeile fest, wenn die Tabelle mit der PrintGrid-Methode gedruckt wird.
Syntax
[VB]
Public HeaderFont As Font
[C#]
public Font HeaderFont {get; set;}

416 · C1FlexGrid-Referenzverzeichnis
[Delphi]
property HeaderFont: Font;
Beispiel
Der folgende Quellcode druckt die Tabelle mit einer großen und fetten Kopfzeile aus:
• Visual Basic
• C#
Dim gp As GridPrinter = flex.PrinterSettings
gp.HeaderFont = New Font("Arial", 16, FontStyle.Bold)
flex.PrintGrid("my grid", PrintGridFlags.ActualSize, _
"Header" + vbTab + vbTab + "{0}", "Footer")
GridPrinter gp = flex.PrinterSettings;
gp.HeaderFont = new Font("Arial", 16, FontStyle.Bold);
flex.PrintGrid("my grid", PrintGridFlags.ActualSize,
"Header\t\t{0}", "Footer");
• Delphi
var
gp: GridPrinter;
begin
gp := flex.PrinterSettings;
gp.HeaderFont := Font.Create('Arial', 16, FontStyle.Bold);
flex.PrintGrid('my grid', PrintGridFlags.ActualSize,
'Header'#9#9'{0}', 'Footer');
end;
Schauen Sie ferner unter
GridPrinter-Klasse (Seite 412)
PageNumber-Eigenschaft
Gibt die Seitenzahl der zu druckenden Seite zurück.
Syntax
[VB]
Public PageNumber As Integer
[C#]
public int PageNumber {get;}
[Delphi]
property PageNumber: Integer;
Bemerkungen
Diese Eigenschaft kann auch dafür verwendet werden, dem Nutzer den Druckfortschritt während des
Druckvorgangs anzuzeigen.
Schauen Sie ferner unter
GridPrinter-Klasse (Seite 412)

PageCount-Eigenschaft
Gibt die Gesamtzahl der Seiten im zu druckenden Dokument zurück.
Syntax
[VB]
Public PageCount As Integer
[C#]
public int PageCount {get;}
[Delphi]
property PageCount: Integer;
Bemerkungen
PageCount-Eigenschaft · 417
Diese Eigenschaft kann auch dafür verwendet werden, dem Nutzer den Druckfortschritt während des
Druckvorgangs anzuzeigen.
Schauen Sie ferner unter
GridPrinter-Klasse (Seite 412)
PrintDocument-Eigenschaft
Gibt das PrintDocument-Objekt zurück, das die Seite und die Druckereinstellungen festlegt.
Syntax
[VB]
Public PrintDocument As PrintDocument
[C#]
public PrintDocument PrintDocument {get;}
[Delphi]
property PrintDocument: PrintDocument;
Bemerkungen
Die PrintDocument-Klasse ist Teil des .NET-Frameworks und wird im System.Drawing.Printing-
Namensbereich definiert. Es enthält Eigenschaften, mit denen die Seiten- und Druckereinrichtung eines
Dokuments gesteuert werden kann.
Beispiel
Der folgende Quellcode druckt die Tabelle im Querformat aus:
• Visual Basic
• C#
Dim gp As GridPrinter = flex.PrinterSettings
gp.DefaultPageSettings.Landscape = True
flex.PrintGrid("my grid")
GridPrinter gp = flex.PrinterSettings;

418 · C1FlexGrid-Referenzverzeichnis
gp.DefaultPageSettings.Landscape = true;
flex.PrintGrid("my grid");
• Delphi
var
gp: GridPrinter;
begin
gp := flex.PrinterSettings;
gp.DefaultPageSettings.Landscape := True;
flex.PrintGrid('my grid');
end;
Schauen Sie ferner unter
GridPrinter-Klasse (Seite 412)
PrintPreviewDialog-Eigenschaft
Hiermit können Sie Eigenschaften für das integrierte Druckvorschaufenster festlegen.
Syntax
[VB]
Public PrintPreviewDialog As PrintDocument
[C#]
public PrintDocument PrintPreviewDialog {get;}
[Delphi]
property PrintPreviewDialog: PrintDocument;
Bemerkungen
Zum Beispiel, der nachfolgende Quellcode legt die Überschrift und die Größe des integrierten
Druckvorschaufensters (PrintPreview dialog) fest:
• Visual Basic
• C#
Dim dlg As PrintPreviewDialog =
_flex.PrintParameters.PrintPreviewDialog
dlg.Text = "Custom Caption in Preview Dialog"
dlg.ClientSize = New Size(500, 500)
PrintPreviewDialog dlg = _flex.PrintParameters.PrintPreviewDialog;
dlg.Text = "Custom Caption in Preview Dialog";
dlg.ClientSize = new Size(500,500);
• Delphi
var
dlg: PrintPreviewDialog;
begin
dlg := _flex.PrintParameters.PrintPreviewDialog;
dlg.Text := 'Custom Caption in Preview Dialog';
dlg.ClientSize := Size.Create(500, 500);
end;
Schauen Sie ferner unter
GridPrinter-Klasse (Seite 412)

C1FlexGrid-Aufzählungen
AggregateEnum-Aufzählung
AggregateEnum-Aufzählung · 419
Legt den Typ der Aggregierungsfunktion für die Berechnungen in den Aggregate- und Subtotal-
Methoden fest.
Syntax
[VB]
Public Enum AggregateEnum
[C#]
public sealed enum AggregateEnum : System.Enum
[Delphi]
type AggregateEnum = (Average, Clear, Count, Max, Min, None, Percent, Std, StdPop, Sum, Var,
VarPop);
Mitglieder
Mitgliedsname Beschreibung
None
Clear
Keine Aggregierung. Diese Einstellung wird von der Subtotal-Methode verwendet,
um einen Gliederungsbaum ohne numerische Gesamtbeträge zu erstellen.
Löscht vorhandene Aggregierungen. Diese Einstellung wird von der Subtotal-
Methode verwendet, um vorhandene Zwischensummen, meistens vor einer
Neuberechnung, zu löschen.
Sum Gibt die Summe aller Werte in einem Bereich zurück.
Percent
Anteil an einer Gesamtsumme. Diese Einstellung wird von der Subtotal-Methode
verwendet, um den Anteil in Prozent einer Untergruppe an der Gesamtsumme zu
berechnen. Diese Einstellung kann nicht in der Aggregate-Methode verwendet
werden.
Count Gibt die Anzahl der von Null verschiedenen Zellen in einem Bereich zurück.
Average Gibt den Durchschnitt der von Null verschiedenen Zellen in einem Bereich zurück.
Max Gibt den größten Wert in einem Bereich zurück.
Min Gibt den kleinsten Wert in einem Bereich zurück.
Std
Var
StdPop
VarPop
Gibt die Standardabweichung der Werte einer Stichprobe in einem Bereich zurück
(Verwendet die auf (n-1) basierende Formel).
Gibt die Varianz der Werte einer Stichproben in einem Bereich zurück (Verwendet
die auf (n-1) basierende Formel).
Gibt die Standardabweichung der Werte einer Grundgesamtheit in einem Bereich
zurück (Verwendet die auf (n) basierende Formel).
Gibt die Varianz der Werte einer Grundgesamtheit in einem Bereich zurück
(Verwendet die auf (n) basierende Formel).

420 · C1FlexGrid-Referenzverzeichnis
AggregateFlags-Aufzählung
Legt die Optionen für die Berechnung der Gesamtbeträge mit der Aggregate-Methode fest.
Syntax
[VB]
Public Enum AggregateFlags
[C#]
public sealed enum AggregateFlags : System.Enum
[Delphi]
type AggregateFlags = (AggregateDates, ExcludeNodes, None);
Mitglieder
Mitgliedsname Beschreibung
None Verwendet alle Zeilen, aber nur numerische Werte.
ExcludeNodes
AggregateDates
Mitgliedsname Beschreibung
AggregateBooleans
AllowFreezingEnum-Aufzählung
Schließt die Knotenzeilen von der Berechnug aus. Diese Option ist nützlich,
wenn die Tabelle Zwischensummen in den Knotenzeilen enthält und diese daher
in die Berechnung des Gesamtbetrages nicht mit einfließen dürfen.
Berechnet Gesamtbeträge für Daten anstatt für numerische Wert. Nur wenige
Berechnugsfunktionen sind für Daten sinnvoll: count, maximum und minimum.
Zwingt die Steuerung dazu, Wahrheitswertzellen in Aggregierungen zu beachten:
TRUE-Werte zählen als 1, FALSE als 0. Zum Beispiel können Sie die Anzahl von
wahren Zellen in einem Bereich wie folgt abfragen:
// Summenwerte in einem Bereich, zähle TRUE-Werte als 1
double sum = _flex.Aggregate(AggregateEnum.Sum, 1, 1, 49, 1,
AggregateFlags.AggregateBooleans);
Legt fest, ob Zellen in der Tabelle eingefroren werden können.
Syntax
[VB]
Public Enum AllowFreezingEnum
[C#]
public sealed enum AllowFreezingEnum : System.Enum
[Delphi]
type AllowFreezingEnum = (Both, Columns, None, Rows);

Mitglieder
AllowMergingEnum-Aufzählung · 421
Mitgliedsname Beschreibung
None Der Nutzer kann Zeilen und Spalten mit der Maus nicht einfrieren (Standard).
Columns Der Nutzer kann Spalten mit der Maus einfrieren.
Rows Der Nutzer kann Zeilen mit der Maus einfrieren.
Both Der Nutzer kann Zeilen und Spalten mit der Maus einfrieren.
AllowMergingEnum-Aufzählung
Legt fest, welche Zellen sich verbinden dürfen.
Syntax
[VB]
Public Enum AllowMergingEnum
[C#]
public sealed enum AllowMergingEnum : System.Enum
[Delphi]
type AllowMergingEnum = (FixedOnly, Free, Nodes, None, RestrictAll, RestrictCols, RestrictRows,
Spill);
Mitglieder
Mitgliedsname Beschreibung
None Zellen nicht verbinden.
Free Angrenzende Zellen mit gleichem Inhalt verbinden.
RestrictRows Zeilen verbinden, wenn die Zellen darüber auch verbunden sind.
RestrictCols Spalten verbinden, wenn die Zellen links davon auch verbunden sind.
RestrictAll Zellen verbinden, wenn die Zellen darüber und links davon auch verbunden sind.
FixedOnly
Nur fixierte Zellen verbinden. Diese Einstellung ist für komplexe Überschriften
sinnvoll, ohne dabei die Datenzellen selbst zu verbinden.
Spill Langen Einträgen erlauben, in leere, angrenzende Zellen überzugehen.
Nodes
AllowResizingEnum-Aufzählung
Langen Einträgen in Knotenzeilen erlauben, in leere, angrenzende Zellen
überzugehen.
Legt fest, welche Tabellenelemente (Zeilen und/oder Spalten) mit der Maus in deren Größe verändert
werden dürfen.

422 · C1FlexGrid-Referenzverzeichnis
Syntax
[VB]
Public Enum AllowResizingEnum
[C#]
public sealed enum AllowResizingEnum : System.Enum
[Delphi]
type AllowResizingEnum = (Both, BothUniform, Columns, ColumnsUniform, None, Rows,
RowsUniform);
Mitglieder
Mitgliedsname Beschreibung
None Der Nutzer kann die Größe von Zeilen und Spalten nicht verändern.
Columns
ColumnsUniform
Rows
Both
RowsUniform
BothUniform
AllowDraggingEnum-Aufzählung
Der Nutzer kann die Breite von Spalten verändern, indem er die Kanten der
fixierten Spalten oben in der Tabelle entsprechend zieht. Ein Doppelklick auf die
Kante der fixierten Zellen passt die Breite an deren breitesten Eintrag an.
Der Nutzer kann die Breite einer Spalte mit der Maus verändern. Wenn die
Größe einer Spalte verändert wurde, dann wird die neue Spaltenbreite auf alle
Spalten angewendet.
Der Nutzer kann die Höhe von Zeile verändern, indem er die Kanten der fixierten
Zeilen links in der Tabelle entsprechend zieht. Ein Doppelklick auf die Kante der
fixierten Zellen passt die Höhe an deren höchsten Eintrag an.
Der Nutzer kann die Höhe von Zeilen und die Breite von Spalten mit der Maus
verändern.
Der Nutzer kann die Höhe einer Zeile mit der Maus verändern. Wenn die Größe
einer Zeile verändert wurde, dann wird die neue Zeilenhöhe auf alle Zeilen
angewendet.
Der Nutzer kann die Höhe von Zeilen und die Breite von Spalten mit der Maus
verändern. Wenn die Größe einer Zeile oder Spalte verändert wurde, dann wird
die neue Höhe oder Breite auf alle Zeilen oder Spalten angewendet.
Legt fest, welche Tabellenelemente (Zeilen und/oder Spalten) mit der Maus gezogen werden dürfen.
Syntax
[VB]
Public Enum AllowDraggingEnum
[C#]
public sealed enum AllowDraggingEnum : System.Enum
[Delphi]
type AllowDraggingEnum = (Both, Columns, None, Rows);

Mitglieder
Mitgliedsname Beschreibung
None Der Nutzer kann mit der Maus Zeilen und Spalten nicht ziehen.
Columns Der Nutzer kann mit der Maus Spalten auf neue Poitionen ziehen.
Rows Der Nutzer kann mit der Maus Zeilen auf neue Poitionen ziehen.
AllowSortingEnum-Aufzählung · 423
Both Der Nutzer kann mit der Maus Zeilen und Spalten auf neue Poitionen ziehen.
AllowSortingEnum-Aufzählung
Legt fest, ob der Nutzer Spalten mit der Maus sortieren darf.
Syntax
[VB]
Public Enum AllowSortingEnum
[C#]
public sealed enum AllowSortingEnum : System.Enum
[Delphi]
type AllowSortingEnum = (MultiColumn, SingleColumn, None);
Mitglieder
Mitgliedsname Beschreibung
None Der Nutzer kann Spalten nicht mit der Maus sortieren.
SingleColumn
MultiColumn
AutoSearchEnum-Aufzählung
Der Nutzer kann Spalten mit der Maus sortieren. Klickt man auf die
Spaltenüberschrift, so werden diese jeweils auf- oder absteigend sortiert.
Diese Funktion ist gleich denen, die in den meisten Standardanwendungen, wie
zum Beispiel Windows Explorer, zu finden sind.
Der Nutzer kann Spalten mit der Maus sortieren. Klickt man auf die
Spaltenüberschrift, so werden alle Spalten von der Ersten bis zu der, auf die man
klickte, auf- oder absteigend sortiert.
Diese Einstellung ist sinnvoll, wenn die Daten in Kategorien von links nach rechts
gruppiert sind und Sie diese Gruppen trotz Sortieren erhalten wollen.
Legt fest, wo die Tabelle anfangen soll, nach Zellen zu suchen, wenn die AutoSearch-Eigenschaft
verwendet wird.
Syntax
[VB]
Public Enum AutoSearchEnum

424 · C1FlexGrid-Referenzverzeichnis
[C#]
public sealed enum AutoSearchEnum : System.Enum
[Delphi]
type AutoSearchEnum = (FromCursor, FromTop, None);
Mitglieder
Mitgliedsname Beschreibung
None Automatisches Suchen deaktivieren.
FromTop
FromCursor
AutoSizeFlags-Aufzählung
Wenn der Nutzer anfängt zu schreiben, soll nach Übereinstimmungen von oben
nach unten in der Tabelle gesucht werden.
Wenn der Nutzer anfängt zu schreiben, soll nach Übereinstimmungen ab der
aktuellen Zeile gesucht werden.
Legt die Optionen fest, wenn die Größe von Zeilen und/oder Spalten automatisch angepasst wird.
Syntax
[VB]
Public Enum AutoSizeFlags
[C#]
public sealed enum AutoSizeFlags : System.Enum
[Delphi]
type AutoSizeFlags = (IgnoreHidden, IgnoreMerged, None, SameSize);
Mitglieder
Mitgliedsname Beschreibung
None Standardverhalten bei automatischer Größenanpassung.
SameSize
Wendet die gleiche Größe auf alle Zeilen oder Spalten an, deren Größe verändert
wird.
IgnoreHidden Übergeht versteckte Zeilen und Spalten, wenn Zellgrößen berechnet werden.
IgnoreMerged Übergeht verbundene Zeilen und Spalten, wenn Zellgrößen berechnet werden.
BorderDirEnum-Aufzählung
Legt die Ausrichtung der Zellrahmen fest.
Syntax
[VB]
Public Enum BorderDirEnum

[C#]
public sealed enum BorderDirEnum : System.Enum
[Delphi]
type BorderDirEnum = (Both, Horizontal, Vertical);
Mitglieder
Mitgliedsname Beschreibung
Both Zeichnet Zellrahmen in beide Richtungen.
Horizontal Zeichnet Zellrahmen nur in horizontaler Richtungen.
Vertical Zeichnet Zellrahmen nur in vertikaler Richtungen.
BorderStyleEnum-Aufzählung
Legt den Typ des Rahmens fest, der um die Zelle gezeichnet wird.
Syntax
[VB]
Public Enum BorderStyleEnum
[C#]
public sealed enum BorderStyleEnum : System.Enum
[Delphi]
type BorderStyleEnum = (Fixed, FixedSingle, Light3D, None, XpThemes);
Mitglieder
Mitgliedsname Beschreibung
Fixed3D Der Rahmen ist eine Linie mit 3D-Effekt.
FixedSingle Der Rahmen ist eine einfache Linie.
Light3D Der Rahmen ist eine schwache, ein Pixel breite 3D-Linie.
None Kein Rahmen.
XpThemes
CellStyleEnum-Aufzählung
BorderStyleEnum-Aufzählung · 425
Zwingt die Steuerung, XP-Motive für fixierte Zellen zu verwenden, Hot-Tracking
eingeschlossen.
Legt die Standardformate fest und kann als Index in der Styles-Eigenschaft verwendet werden.
Syntax
[VB]
Public Enum CellStyleEnum

426 · C1FlexGrid-Referenzverzeichnis
[C#]
public sealed enum CellStyleEnum : System.Enum
[Delphi]
type CellStyleEnum = (Alternate, EmptyArea, FirstCustomStyle, Fixed, Focus, Frozen, GrandTotal,
Highlight, NewRow, Normal, Search, Subtotal0,, Subtotal1, Subtotal2, Subtotal3, Subtotal4, Subtotal5);
Mitglieder
Mitgliedsname Beschreibung
Normal Formatvorlage, mit der scrollbare, normale Zellen gerendert werden.
Alternate
Fixed
Highlight
Focus
Editor
Search
Frozen
NewRow
EmptyArea
GrandTotal
Subtotal(0-5)
CheckEnum-Aufzählung
Formatvorlage, mit der scrollbare Zellen in gerade nummerierten Zeilen gerendert
werden. Standardmäßig ist diese Vorlage leer, so dass alle scrollbaren Zellen mit
der Formatvorlage Normal gerendert werden.
Formatvorlage, mit der fixierte Zellen gerendert werden. Standardmäßig besitzt
diese Vorlage eine eigene Hintergrundfarbe.
Formatvorlage, mit der ausgewählte und markierte Zellen gerendert werden.
Standardmäßig besitzt diese Vorlage eine eigene Hinter- und Vordergrundfarbe.
Formatvorlage, mit der Fokuszellen gerendert werden. Standardmäßig ist diese
Vorlage leer, so dass alle fokussierten Zellen mit der Formatvorlage Normal
gerendert werden.
Formatvorlage, mit der Zellen während ihrer Bearbeitung gerendert werden.
Standardmäßig ist diese Vorlage leer, so dass alle Zellen während ihrer
Bearbeitung mit der Formatvorlage Normal gerendert werden.
Formatvorlage, mit der Zellen gerendert werden, die ausgewählt sind, während der
Nutzer im AutoSerach-Modus eine Eingabe vornimmt. Standardmäßig besitzt diese
Vorlage eine eigene Hintergrundfarbe.
Formatvorlage, mit der eingefrorene Zellen (bearbeitbar, aber nicht scrollbar)
gerendert werden. Standardmäßig besitzt diese Vorlage eine eigene
Hintergrundfarbe.
Formatvorlage, mit der die letzte Zeile in der Tabelle gerendert wird, wenn die
AllowAddNew-Eigenschaft auf TRUE steht. Diese Zeile wird dafür verwendet, neue
Elemente der Tabelle hinzuzufügen.
Formatvorlage, mit der der Bereich in der Tabelle gerenderet wird, wo keine Zellen
mehr sind. Der für diese Vorlage verwendete Rahmentyp legt die Umrandung, die
um alle Zellen in der Tabelle gezeichnet wird, fest.
Formatvorlage, die automatisch auf die von der Subtotal-Methode erstellten
Gesamtsummenzeile angewendet wird. Standardmäßig besitzt diese Vorlage eine
eigene Hinter- und Vordergrundfarbe.
Formatvorlage, die automatisch auf die von der Subtotal-Methode erstellten
Zwischensummenzeilen angewendet wird. Standardmäßig besitzt diese Vorlage
eine eigene Hinter- und Vordergrundfarbe.
Legt den Typ des Kontrollkästchens einer Zelle fest.

Syntax
[VB]
Public Enum CheckEnum
[C#]
public sealed enum CheckEnum : System.Enum
[Delphi]
type CheckEnum = (Checked, None, TSChecked, TSGrayed, TSUnchecked, Unchecked);
Bemerkungen
Es gibt zwei Kontrollkästchentypen: Boolean und Tri-State.
ClearFlags-Aufzählung · 427
Normale Kontrollkästchen werden verwendet, um normale Wahrheitswerte anzuzeigen. Sie schalten
zwischen den beiden Zuständen Aktiviert und Deaktiviert um, wenn sie mit der Maus angeklickt werden.
Drei-Zustands-Kontrollkästchen werden verwendet, um Werte, die wahr, falsch oder unbestimmt (grau)
sein können, anzuzeigen. Sie schalten zwischen den beiden Zuständen TSChecked, TSGrayed und
TSUnchecked um, wenn sie mit der Maus angeklickt werden.
Die Zustände Checked und Unchecked sehen äußerlich genauso wie TSChecked und TSUnchecked aus.
Mitglieder
Mitgliedsname Beschreibung
None Kein Kontrollkästchen.
Checked Kontrollkästchen mit einem Häkchen drin.
Unchecked Leeres Kontrollkästchen.
TSChecked Drei-Zustands-Kontrollkästchen mit einem Häkchen drin.
TSUnchecked Leeres drei-Zustands-Kontrollkästchen.
TSGrayed Drei-Zustands-Kontrollkästchen im grauen Zustand.
ClearFlags-Aufzählung
Legt fest, welche Elemente mit der Clear-Methode gelöscht werden.
Syntax
[VB]
Public Enum ClearFlags
[C#]
public sealed enum ClearFlags : System.Enum
[Delphi]
type ClearFlags = (All, Content, Style, UserData);

428 · C1FlexGrid-Referenzverzeichnis
Mitglieder
Mitgliedsname Beschreibung
Content Löscht Zelldaten, inklusive Grafiken uns Kontrollkästchen, wenn vorhanden.
Style Löscht die einer Zelle zugeordnete benutzerdefinierte Formatvorlage.
UserData Löscht die einer Zelle zugeordneten Benutzerdaten.
All Alle der oben genannten.
DisplayEnum-Aufzählung
Ein Typ der CellStyle.Display-Eigenschaft. Jede Tabellenzelle kann einen als Text angezeigten Wert und
eine Grafik beinhalten. Die Display-Eigenschaft legt fest, was angezeigt und wie es in der Zelle
angeordnet wird.
Syntax
[VB]
Public enum DisplayEnum
[C#]
public sealed enum DisplayEnum : System.Enum
[Delphi]
type DisplayEnum = (ImageOnly, None, OverLay, Stack, TextOnly);
Bemerkungen
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert eines Arguments der Display-
Eigenschaft in der C1FlexGrid-Steuerung zu setzen.
Mitgliedsname Beschreibung
ImageOnly Zeigt nur die Grafik an (kein Wert).
None Nichts (Zelle bleibt leer).
OverLay Grafik und Wert (übereinander).
Stack Grafik und Wert (nebeneinander).
TextOnly Zeigt nur den Wert an (keine Grafik).
DragModeEnum-Aufzählung
Legt fest, wie OLE-Drag-und-Drop-Operationen gehandhabt werden.
Syntax
[VB]
Public Enum DragModeEnum

[C#]
public sealed enum DragModeEnum : System.Enum
[Delphi]
type DragModeEnum = (Automatic, AutomaticCopy, AutomaticMove, Manual);
Mitglieder
DrawCellFlags-Aufzählung · 429
Mitgliedsname Beschreibung
Manual Die Steuerung stellt keine Unterstützung für Ziehen von Objekten zur Verfügung.
Automatic
Die Steuerung stellt Ziehen automatisch als Verschieben und als Kopieren zur
Verfügung.
AutomaticCopy Die Steuerung stellt Ziehen automatisch als Kopieren zur Verfügung.
AutomaticMove Die Steuerung stellt Ziehen automatisch als Verschieben zur Verfügung.
DrawCellFlags-Aufzählung
Legt fest, welches Tabellenelement gezeichnet wird.
Syntax
[VB]
Public Enum DrawCellFlags
[C#]
public sealed enum DrawCellFlags : System.Enum
[Delphi]
type DrawCellFlags = (All, Background, Border, Content);
Bemerkungen
Diese Aufzählung wird verwendet, wenn vom Nutzer gezeichnete Zellen gerendert werden.
Wenn Sie die DrawMode-Eigenschaft auf DrawModeEnum.OwnerDraw setzen, dann wird die Tabelle
das OwnerDrawCell-Ereignis starten, um benutzerdefiniertes Zeichnen der Zellen zu erlauben. Die
OwnerDrawCellEventArgs-Parameter besitzen eine DrawCell-Methode, mit der Sie die
Standardroutinen für das Zeichnen auch für das Rendern des Zellhintergrunds, der Rahmen und/oder
der Zellinhalte verwenden können. Zum Beispiel können Sie einen eigenen Hintergrund zeichnen und
dennoch die Standardroutinen für das Zeichnen des Zellrahmens und des Inhalts verwenden.
Schauen Sie im OwnerDrawCell-Ereignis für ein Beispiel nach.
Mitglieder
Mitgliedsname Beschreibung
Background Zeichnet den Zellhintergrund.
Border Zeichnet den Zellrahmen.
Content Zeichnet den Zellinhalt (Text, Grafik und Kontrollkästchen).

430 · C1FlexGrid-Referenzverzeichnis
All Alle der oben genannten.
DrawModeEnum-Aufzählung
Legt fest, wie Tabellenzellen gezeichnet werden.
Syntax
[VB]
Public Enum DrawModeEnum
[C#]
public sealed enum DrawModeEnum : System.Enum
[Delphi]
type DrawModeEnum = (Normal, OwnerDraw);
Mitglieder
Mitgliedsname Beschreibung
Normal Tabellenzellen werden von der Steuerung gezeichnet.
OwnerDraw
DropModeEnum-Aufzählung
Die Tabelle startet das OwnerDrawCell-Ereignis, um benutzerdefiniertes Zeichnen
von Zellen zu erlauben.
Legt fest, wie OLE-Drag-und-Drop-Operationen gehandhabt werden.
Syntax
[VB]
Public Enum DropModeEnum
[C#]
public sealed enum DropModeEnum : System.Enum
[Delphi]
type DropModeEnum = (Automatic, Manual, None);
Mitglieder
Mitgliedsname Beschreibung
None Die Steuerung ist kein Ziel zum Ablegen von Objekten.
Manual Die Steuerung startet Ereignisse.
Automatic Die Steuerung wickelt automatisch das Ablegen von Text und Dateinamen ab.

EditFlags-Aufzählung
Legt Optionen für die Verwendung der EditOptions-Eigenschaft fest.
Syntax
[VB]
Public Enum EditFlags
[C#]
public sealed enum EditFlags : System.Enum
[Delphi]
type EditFlags = (Automatic, Manual, None);
Mitglieder
Mitgliedsname Beschreibung
None Keine Flags, deaktiviert alle Optionen.
AutoSearch
CycleOnDoubleClick
MultiCheck
All
FileFlags-Aufzählung
EditFlags-Aufzählung · 431
Stellt die automatische Suchefunktion zur Verfügung, wenn mit den integrierten
ComboBox-Feldern bearbeitet wird. Diese Option zwingt die Tabelle dazu,
Einträge zu suchen und auszuwählen, während Sie diese eingeben. Das
Intervall, bevor der Suchpuffer geleert wird, kann mit der AutoSearchDelay-
Eigenschaft festgelegt werden.
Wählt automatisch den nächsten Wert aus, wenn der Nutzer auf eine Zelle
doppelklickt, der eine ComboList oder DataMap zugeordnet ist.
Schaltet alle ausgewählten Kontrollkästchen um, wenn ein beliebiges
Kontrollkästchen umgeschaltet wird.
Aktiviert alle Optionen. Dies ist die Standardeinstellung für die EditOptions-
Eigenschaft.
Legt Optionen für die Verwendung der SaveGrid- und LoadGrid-Methoden fest.
Syntax
[VB]
Public Enum FileFlags
[C#]
public sealed enum FileFlags : System.Enum
[Delphi]
type FileFlags = (None, IncludeFixedCells, VisibleOnly, SelectedRowsOnly);

432 · C1FlexGrid-Referenzverzeichnis
Mitglieder
Mitgliedsname Beschreibung
None Keine Flags, verwendet Standardeinstellungen.
IncludeFixedCells Schließt fixierte Zellen ein, wenn eine Tabelle geladen oder gespeichert wird.
VisibleOnly Speichert nur sichtbare Zeilen und Spalten. Gilt nicht für Excel-Dateien.
SelectedRowsOnly Speichert nur ausgewählte Zeilen. Gilt nicht für Excel-Dateien.
FileFormatEnum-Aufzählung
Legt den mit den SaveGrid- und LoadGrid-Methoden zu speichernden oder zu öffnenden Dateityp fest.
Syntax
[VB]
Public Enum FileFormatEnum
[C#]
public sealed enum FileFormatEnum : System.Enum
[Delphi]
type FileFormatEnum = (TextComma, TextCustom, TextTab);
Mitglieder
Mitgliedsname Beschreibung
TextComma Zellen werden mit Kommata abgegrenzt.
TextTab Zellen werden mit Tabulatoren abgegrenzt.
TextCustom Zellen werden mit dem Zeichen aus der ClipSeparators-Eigenschaft abgegrenzt.
Excel Speichert und lädt Microsoft Excel-Dateien (*:xls).
FocusRectEnum-Aufzählung
Legt das Aussehen des Fokusrechtecks auf der Tabelle fest.
Syntax
[VB]
Public Enum FocusRectEnum
[C#]
public sealed enum FocusRectEnum : System.Enum
[Delphi]
type FocusRectEnum = (Heavy, Inset, Light, None, Raised, Solid);

Mitglieder
Mitgliedsname Beschreibung
None Kein Fokusrechteck.
Light Ein ein Pixel breites, gestricheltes Rechteck.
Heavy Ein zwei Pixel breites, gestricheltes Rechteck.
Solid
GlyphEnum-Aufzählung · 433
Ein ein Pixel breites, durchgängiges Rechteck. Die Farbe ist die gleiche, wie die des
Hintergrunds einer Auswahl (Styles.Highlight.BackColor).
Raised Ein ein Pixel breites, erhobenes Rechteck, das mit Systemfarben gezeichnet wird.
Inset
GlyphEnum-Aufzählung
Ein ein Pixel breites, eingelassenes Rechteck, das mit Systemfarben gezeichnet
wird.
Legt den von der Tabelle verwendeten Typ eines Glyphs (Grafik) fest, um Information über eine Zeile,
Spalte oder Zelle zu verbreiten.
Syntax
[VB]
Public Enum GlyphEnum
[C#]
public sealed enum GlyphEnum : System.Enum
[Delphi]
type GlyphEnum = (Ascending, Checked, Collapsed, DBAdd, DBCursor, Descending, ErrorInfo,
Expanded, Grayed, Unchecked);
Mitglieder
Mitgliedsname Beschreibung
Ascending
Descending
Zeigt aufsteigende Spaltensortierung an (Standard ist eine hohles, nach oben
gerichtetes Dreieck).
Zeigt absteigende Spaltensortierung an (Standard ist eine hohles, nach unten
gerichtetes Dreieck).
Checked Kontrollkästchen mit Haken (aktivierter Zustand).
Unchecked Kontrollkästchen ohne Haken (deaktivierter Zustand).
Grayed Kontrollkästchen mit grauem Feld (undefinierter Zustand).
Collapsed Eingeklappter Baumknoten (Standard ist ein Pluszeichen).
Expanded Ausgeklappter Baumknoten (Standard ist ein Minuszeichen).
DBCursor
Zeigt aktuellen Datensatz an (Standard ist ein schwarzes, nach rechts zeigendes
Dreieck).

434 · C1FlexGrid-Referenzverzeichnis
Mitgliedsname Beschreibung
DBAdd
Zeigt den der Datenquelle hinzuzufügenden Datensatz an (Standard ist ein Asteriks
(*)).
ErrorInfo Zeigt Zeilen- oder Zellfehler an (Standard ist ein rotes Ausrufezeichen).
GridChangedTypeEnum-Aufzählung
Legt den Typ der Änderung fest, der das GridChanged-Ereignis startet.
Syntax
[VB]
Public Enum GridChangedTypeEnum
[C#]
public sealed enum GridChangedTypeEnum : System.Enum
[Delphi]
type GridChangedTypeEnum = (AfterCollapse, AfterSelChange, BeforeCollapse, BeforeSetChange,
ColAdded, ColMoved, ColRemoved, ColSelected, EnsureVisible, GridChanged, LayoutChanged, None,
RepaintCell, RepaintGrid, RepaintRange, RowAdded, RowMoved, RowRemoved, RowSelected, Select,
StyleChanged, update);
Mitglieder
Mitgliedsname Beschreibung
None Keine Maßnahme.
GridChanged Die Anzahl der geänderten Zeilen oder Spalten.
LayoutChanged Die Anzahl der geänderten fixen Zeilen oder Spalten.
StyleChanged Ein oder mehrere Formatvorlagen haben sich geändert.
StyleApplied Eine neue Formatvorlage wurde auf den Bereich angewendet.
RepaintGrid Die Tabelle wird gleich neu gezeichnet.
RepaintCell Eine Zelle wird gleich neu gezeichnet.
RepaintRange Ein Zellbereich wird gleich neu gezeichnet .
Update Das Tabellenfenster wird aktualisiert.
BeforeCollapse Eine Knotenzeile wird gleich aus- oder eingeklappt.
AfterCollapse Eine Knotenzeile wurde eben aus- oder eingeklappt.
EnsureVisible Eine Knotenzeile wird auf den Bildschirm gebracht.
Select Eine Knotenzeile wird gleich ausgewählt.
RowMoved Eine Zeile wurde verschoben.
RowAdded Eine Zeile wurde hinzugefügt.
RowRemoved Eine Zeile wurde gelöscht.

Mitgliedsname Beschreibung
RowSelected Eine Zeile wurde ausgewählt.
ColMoved Eine Spalte wurde verschoben.
ColAdded Eine Spalte wurde hinzugefügt.
ColRemoved Eine Spalte wurde gelöscht.
ColSelected Eine Spalte wurde ausgewählt.
BeforeSelChange Die Auswahl ändert sich gleich.
AfterSelChange Die Auswahl hat sich geändert.
HighLightEnum-Aufzählung
Legt fest, wann die aktuelle Auswahl markiert wird.
Syntax
[VB]
Public Enum HighLightEnum
[C#]
public sealed enum HighLightEnum : System.Enum
[Delphi]
type HighLightEnum = (Always, Never, WithFocus);
Mitglieder
Mitgliedsname Beschreibung
Never Markiert nie eine Auswahl.
Always Markiert immer eine Auswahl.
WithFocus Markiert eine Auswahl, wenn die Steuerung den Fokus hat.
HitTestTypeEnum-Aufzählung
Typ eines Tabellenelements, das einen Punkt in der Steuerung festlegt.
Syntax
[VB]
Public Enum HitTestTypeEnum
[C#]
public sealed enum HitTestTypeEnum : System.Enum
[Delphi]
HighLightEnum-Aufzählung · 435
type HitTestTypeEnum = (Cell, Checkbox, ColumnFreeze, ColumnHeader, ColumnResize, EditButton,
None, OutlineBar, OutlineTree, RowFreeze, RowHeader, RowResize);

436 · C1FlexGrid-Referenzverzeichnis
Mitglieder
Mitgliedsname Beschreibung
None Der Punkt liegt im leeren Bereich der Tabelle.
Cell
Der Punkt liegt auf einer Tabellenzelle. Die Zellkoordinaten werden in den Row-,
Column-Eigenschaften des HitTestInfo-Objekts gespeichert.
ColumnHeader Der Punkt liegt auf einer fixierten Zeile über einer Spalte.
ColumnResize
ColumnFreeze
Der Punkt liegt nah der rechten Kante einer fixierten Zelle im
Größenänderungsbereich der Spalte.
Der Punkt liegt nah der rechten Kante der letzten eingefrorenen Spalte im
Spalteneinfrierbereich.
RowHeader Der Punkt liegt auf einer fixierten Spalte neben einer Zeile.
RowResize
RowFreeze
Der Punkt liegt nah der unteren Kante einer fixierten Zelle im
Größenänderungsbereich der Zeile.
Der Punkt liegt nah der unteren Kante der letzten eingefrorenen Zeile im
Zeileneinfrierbereich.
CheckBox Der Punkt liegt auf einem Kontrollkästchen.
EditButton Der Punkt liegt auf einer Bearbeitungsschaltfläche (Auswahl- oder Popup-Editoren).
OutlineBar
OutlineTree
ImageAlignEnum-Aufzählung
Der Punkt liegt auf der Gliederungsleiste (Sichtbar wenn die Tree.Style-Eigenschaft
der Tabelle den ButtonBar-Flag enthält).
Der Punkt liegt auf der Ein-/Ausklappschaltfläche eines Gleiderungbaums (Sichtbar
wenn die Tree.Style-Eigenschaft der Tabelle den Symbols-Flag enthält).
Legt fest, wie Grafiken in Zellen ausgerichtet werden.
Syntax
[VB]
Public Enum ImageAlignEnum
[C#]
public sealed enum ImageAlignEnum : System.Enum
[Delphi]
type ImageAlignEnum = (CenterBottom, CenterCenter, CenterTop, Hide, LeftBottom, LeftCenter,
LeftTop, RightBottom, RightCenter, RightTop, Scale, Stretch, Tile);
Mitglieder
Mitgliedsname Beschreibung
LeftTop Die Grafik wird horizontal links und vertikal oben in der Zelle ausgerichtet.
LeftCenter Die Grafik wird horizontal links und vertikal zentriert in der Zelle ausgerichtet.

Mitgliedsname Beschreibung
KeyActionEnum-Aufzählung · 437
LeftBottom Die Grafik wird horizontal links und vertikal unten in der Zelle ausgerichtet.
CenterTop Die Grafik wird horizontal zentriert und vertikal oben in der Zelle ausgerichtet..
CenterCenter Die Grafik wird horizontal zentriert und vertikal zentriert in der Zelle ausgerichtet.
CenterBottom Die Grafik wird horizontal zentriert und vertikal unten in der Zelle ausgerichtet.
RightTop Die Grafik wird horizontal rechts und vertikal oben in der Zelle ausgerichtet.
RightCenter Die Grafik wird horizontal rechts und vertikal zentriert in der Zelle ausgerichtet.
RightBottom Die Grafik wird horizontal rechts und vertikal unten in der Zelle ausgerichtet.
Scale Die Garfik wird skaliert, damit sie den maxiamlen Bereich der Zelle ausfüllt, wobei das
Seitenverhältnis des Originalbildes beibehalten wird.
Stretch Die Garfik wird skaliert, damit sie den gesamten Bereich der Zelle ausfüllt.
Tile Die Garfik wird nebeneinander angeordnet damit sie die gesamte Zelle ausfüllt.
Hide Die Garfik wird nicht angezeigt.
KeyActionEnum-Aufzählung
Legt die auszuführenden Maßnahmen fest, wenn eine besimmte Taste gedrückt wird.
Syntax
[VB]
Public Enum KeyActionEnum
[C#]
public sealed enum KeyActionEnum : System.Enum
[Delphi]
type KeyActionEnum = (None, MoveAcross, MoveDown);
Mitglieder
Mitgliedsname Beschreibung
None
Keine Handlung (das System verwaltet die Zelle). Zum Beispiel, die Tabulatortaste
wird normalerweise für das Durchblättern der Steuerungen auf einem Formular
verwendet.
MoveDown Gehe zur nächsten Zeile, wenn die Taste gedrückt wird.
MoveAcross
MoveAcrossOut
Gehe zur nächsten Spalte, wenn die Taste gedrückt wird. Gehe nach der letzten
Spalte zur nächsten Zeile und zurück zur ersten Spalte.
Gehe zur nächsten Spalte, wenn die Taste gedrückt wird. Gehe nach der letzten
Spalte zur nächsten Zeile und zurück zur ersten Spalte. Verschiebe nach der letzten
Zeile und Spalte den Fokus zur nächsten Steuerung auf dem Formular.

438 · C1FlexGrid-Referenzverzeichnis
NodeMoveEnum-Aufzählung
Legt das Ziel eines Knotens fest, wenn dieser mit der Node.Move-Methode verschoben wird.
Syntax
[VB]
Public Enum NodeMoveEnum
[C#]
public sealed enum NodeMoveEnum : System.Enum
[Delphi]
type NodeMoveEnum = (ChildOf, Down, First, In, Last, Out, up);
Mitglieder
Mitgliedsname Beschreibung
In Verschiebt den Knoten in der Gliederung eine Ebene tiefer.
Out Verschiebt den Knoten in der Gliederung eine Ebene höher in Richtung Quellknoten.
Up Verschiebt den Knoten auf eine Position vor seinem vorhergehenden Sibling.
Down Verschiebt den Knoten auf eine Position nach seinem nächsten Sibling.
First Verschiebt den Knoten auf eine Position vor seinem ersten Sibling.
Last Verschiebt den Knoten auf eine Position vor seinem letzten Sibling.
ChildOf Verwandelt den Knoten zu einem Unterknoten eines bestimmten Knotens.
NodeTypeEnum-Aufzählung
Legt den Knoten fest, der mit der Node.GetNode-Methode abgefragt wird.
Syntax
[VB]
Public Enum NodeTypeEnum
[C#]
public sealed enum NodeTypeEnum : System.Enum
[Delphi]
type NodeTypeEnum = (FirstChild, FirstSibling, LastChild, LastSibling, NextSibling, Parent,
PreviousSibling, Root);
Mitglieder
Mitgliedsname Beschreibung
Root Des Knotens Quellknoten.

Mitgliedsname Beschreibung
Parent Des Knotens direkter Vorgänger.
FirstChild Des Knotens erster Nachfolger.
LastChild Des Knotens letzter Nachfolger.
PrintGridFlags-Aufzählung · 439
FirstSibling Des Knotens erster Sibling (Knoten auf der selben Ebene mit dem selben
übergeordneten Knoten).
LastSibling Des Knotens letzter Sibling.
NextSibling Des Knotens nächster Sibling.
PreviousSibling Des Knotens vorhergehender Sibling.
PrintGridFlags-Aufzählung
Beinhaltet Flags, welche die mit der PrintGrid-Methode zu verwendenden Druckoptionen festlegen.
Syntax
[VB]
Public Enum PrintGridFlags
[C#]
public sealed enum PrintGridFlags : System.Enum
[Delphi]
type PrintGridFlags = (ActualSize, FitToPage, FitToPageWidth, ShowPageSetupDialog,
ShowPrintDialog, ShowPreviewDialog);
Mitglieder
Mitgliedsname Beschreibung
ActualSize
FitToPageWidth
Druckt die Tabelle in Bildschirmgröße aus. Wenn die Tabelle zu breit und/oder
zu lang für eine Seite ist, dann werden die weiteren Spalten und/oder Zeilen auf
neue Seiten gedruckt.
Skaliert die Tabelle damit sie in der Breite auf eine Seite passt. Wenn die
Tabelle zu lang für eine Seite ist, dann werden die weiteren Zeilen auf neue
Seiten gedruckt.
FitToPage Skaliert die Tabelle damit sie in der Breite und höhe auf eine Seite passt.
ShowHighlight
ShowPageSetupDialog
ShowPrintDialog
ShowPreviewDialog
Zeigt die Auswahl während des Druckvorganges an. Standardmäßig zeigt die
Tabelle die Auswahl nicht an.
Zeigt das Seiteneinrichtungsfenster an, bevor die Tabelle gedruckt wird, sodass
der Nutzer das Papierformat, die Ausrichtung und die Ränder einstellen kann.
Zeigt das Druckereinrichtungsfenster an, bevor die Tabelle gedruckt wird ,
sodass der Nutzer den zu verwendenden Drucker einstellen kann.
Zeigt das Druckvorschaufenster an, bevor die Tabelle gedruckt wird, sodass der
Nutzer das Dokument prüfen kann.

440 · C1FlexGrid-Referenzverzeichnis
SelectionModeEnum-Aufzählung
Legt die zu verwendende Tabellenauswahl fest.
Syntax
[VB]
Public Enum SelectionModeEnum
[C#]
public sealed enum SelectionModeEnum : System.Enum
[Delphi]
type SelectionModeEnum = (Cell, CellRange, Column, ColumnRange, Default, ListBox, Row,
RowRange);
Mitglieder
Mitgliedsname Beschreibung
Default
Der Nutzer kann ununterbrochene Blöcke von Zellen mit der Tastatur und der Maus
auswählen. Wenn Sie die Überschriftszellen anklicken, dann wird die gesamte Zeile
oder Spalte ausgewählt.
Cell Der Nutzer kann immer nur eine Zelle auswählen.
CellRange
Der Nutzer kann ununterbrochene Blöcke von Zellen mit der Tastatur und der Maus
auswählen. Wenn auf die Überschriftszellen geklickt wird, bleibt die Auswahl
unverändert.
Row Der Nutzer kann immer nur eine Zeile auswählen.
RowRange Der Nutzer kann immer nur einen fortlaufenden Zeilenbereich auswählen.
Column Der Nutzer kann immer nur eine Spalte auswählen.
ColumnRange Der Nutzer kann immer nur einen fortlaufenden Spaltenbereich auswählen.
ListBox
Der Nutzer kann auch nicht fortlaufende Zeilenbereiche auswählen, indem er die
Ctrl-Taste hält, während er auf die Zeilen klickt.
ShowButtonsEnum-Aufzählung
Legt fest, wann die Tabelle Auswahllisten- und Popup-Schaltflächen in bearbeitbaren Zellen anzeigen
soll.
Syntax
[VB]
Public Enum ShowButtonsEnum
[C#]
public sealed enum ShowButtonsEnum : System.Enum

[Delphi]
type ShowButtonsEnum = (Always, WhenEditing, WithFocus);
Mitglieder
SortFlags-Aufzählung · 441
Mitgliedsname Beschreibung
WhenEditing Schaltflächen werden nur angezeigt, während der Nutzer die Zelle bearbeitet.
WithFocus Schaltflächen werden nur angezeigt, wenn der Fokus auf der Zelle liegt (Standard).
Always Schaltflächen werden immer angezeigt, wenn die Zelle sichtbar ist.
SortFlags-Aufzählung
Beinhaltet Flags, die Sortierungsoptionen bei der Verwendung der Sort-Methode festlegen.
Syntax
[VB]
Public Enum SortFlags
[C#]
public sealed enum SortFlags : System.Enum
[Delphi]
type SortFlags = (Ascending, AsDisplayed, Descending, IgnoreCase, None, UseColSort);
Mitglieder
Mitgliedsname Beschreibung
None
Sortiert nicht. Diese Einstellung ist sinnvoll, um Spalten auszulassen, wenn ein
Spaltenbereich sortiert wird.
Ascending Sortiert aufsteigend.
Descending Sortiert absteigend.
AsDisplayed Sortiert nach den Zeichenketten der Daten. In diesem Fall steht die „100“ vor der " „2“.
IgnoreCase Berücksichtigt keine Groß- und Kleinschreibung, wenn Zeichenketten sortiert werden.
UseColSort Verwendet die sort-Flags der Sort-Eigenschaft eines jeden Spaltenobjekts.
StyleElementFlags-Aufzählung
Beinhaltet Flags, die festlegen, welche Formatelemente in einem CellStyle-Objekt verwendet werden.
Syntax
[VB]
Public Enum StyleElementFlags

442 · C1FlexGrid-Referenzverzeichnis
[C#]
public sealed enum StyleElementFlags : System.Enum
[Delphi]
type StyleElementFlags = (All, BackColor, Border, ComboList, DataMap, DataType, Display, EditMask,
Font, ForeColor, Format, ImageAlign, ImageMap, ImageSpacing, Margins, None, TextAlign,
TextEffect,Trimming, WordWrap);
Bemerkungen
CellStyle-Objekte legen die für das Rendern der Tabellenzellen zu verwendenden Elemente fest.
Elemente, die nicht in einer Formatvorlage festgelegt sind, werden vom Mutterformat geerbt.
Verwenden Sie die DefinedElements-Eigenschaft, um festzulegen, welche Elemente in einer bestimmten
Formatvorlage definiert werden.
Mitglieder
Mitgliedsname Beschreibung
None Keine Elemente sind festgelegt.
Font Die Formatvorlage legt eine Schriftart fest.
BackColor Die Formatvorlage legt eine Hintergrundfarbe fest.
ForeColor Die Formatvorlage legt eine Vordergrundfarbe fest.
Margins Die Formatvorlage legt Ränder fest.
Border Die Formatvorlage legt Rahmen fest.
TextAlign Die Formatvorlage legt die Textausrichtung fest.
TextEffect Die Formatvorlage legt einen 3D-Effekt für den Text fest.
ImageAlign Die Formatvorlage legt die Grafikausrichtung fest.
ImageSpacing Die Formatvorlage legt den Abstand zwischen Grafik und Text in der Zelle fest.
Trimming Die Formatvorlage legt fest, wie Texte beschnitten werden, wenn sie zu lang für die
Zelle sind.
WordWrap Die Formatvorlage legt fest, ob lange Zeichenketten in der Zelle umgebrochen
werden.
Display Die Formatvorlage legt fest, ob in der Zelle Text und/oder Grafiken angezeigt
werden.
Format Die Formatvorlage legt eine Formatzeichenkette fest, um Daten in Zeichenketten
umzuwandeln.
EditMask Die Formatvorlage legt eine Eingabemaske für die Bearbeitung der Zelle fest.
ComboList Die Formatvorlage legt eine Liste mit Auswahlmöglichkeiten für den
Auswahllisteneditor fest.
ImageMap Die Formatvorlage legt ein zu verwendendes IDictionary fest, um Zellwerte mit
Grafiken zu verknüpfen.
DataMap Die Formatvorlage legt ein zu verwendendes IDictionary fest, um Zellwerte mit
anzuzeigenden Werten zu verknüpfen.

DataType Die Formatvorlage legt den Typ der Werte in der Zelle fest.
SubTotalPositionEnum-Aufzählung · 443
TextDirection Die Formatvorlage legt fest, ob Text horizontal oder vertikal gerendert wird.
Editor Die Formatvorlage legt eine externe Steuerung fest, die als Editor für die Zelle
verwendet werden soll.
UserData Die Formatvorlage enthält willkürliche Benutzerdaten, die nicht von der Steuerung
verwendet werden.
All Die Formatvorlage legt alle Elemente fest.
SubTotalPositionEnum-Aufzählung
Legt fest, ob die Subtotal-Methode Knotenzeilen über oder unter den zusammengefassten Zeilen
hinzufügen soll.
Syntax
[VB]
Public Enum SubTotalPositionEnum
[C#]
public sealed enum SubtotalPositionEnum : System.Enum
[Delphi]
type SubtotalPositionEnum = (AboveData, BelowData);
Mitglieder
Mitgliedsname Beschreibung
AboveData Knotenzeilen erscheinen über den Datenzeilen (Standard).
BelowData Knotenzeilen erscheinen unter den Datenzeilen.
TextAlignEnum-Aufzählung
Legt fest, wie Texte in Zellen ausgerichtet werden.
Syntax
[VB]
Public Enum TextAlignEnum
[C#]
public sealed enum TextAlignEnum : System.Enum
[Delphi]
type TextAlignEnum = (CenterBottom, CenterCenter, CenterTop, GeneralBottom, GeneralCenter,
GeneralTop, LeftBottom, LeftCenter, LeftTop, RightBottom, Rightcenter, RightTop);

444 · C1FlexGrid-Referenzverzeichnis
Mitglieder
Mitgliedsname Beschreibung
LeftTop Der Text wird horizontal links und vertikal oben in der Zelle ausgerichtet.
LeftCenter Der Text wird horizontal links und vertikal zentriert in der Zelle ausgerichtet.
LeftBottom Der Text wird horizontal links und vertikal unten in der Zelle ausgerichtet.
CenterTop Der Text wird horizontal zentriert und vertikal oben in der Zelle ausgerichtet..
CenterCenter Der Text wird horizontal zentriert und vertikal zentriert in der Zelle ausgerichtet.
CenterBottom Der Text wird horizontal zentriert und vertikal unten in der Zelle ausgerichtet.
RightTop Der Text wird horizontal rechts und vertikal oben in der Zelle ausgerichtet.
RightCenter Der Text wird horizontal rechts und vertikal zentriert in der Zelle ausgerichtet.
RightBottom Der Text wird horizontal rechts und vertikal unten in der Zelle ausgerichtet.
GeneralTop Zahlen werden rechts oben und alle anderen Werte links oben ausgerichtet.
GeneralCenter Zahlen werden rechts zentriert und alle anderen Werte links zentriert ausgerichtet.
GeneralBottom Zahlen werden rechts unten und alle anderen Werte links unten ausgerichtet.
TextDirectionEnum-Aufzählung
Legt die zu verwendende Richtung fest, wenn Text in einer Tabellenzelle gerendert wird.
Syntax
[VB]
Public Enum TextDirectionEnum
[C#]
public sealed enum TextDirectionEnum : System.Enum
[Delphi]
type TextDirectionEnum = (Normal, Up, Down);
Bemerkungen
Die Textrichtung beeinflusst auch die automatische Größenanpassung von Zeilen und Spalten.
Mitglieder
Mitgliedsname Beschreibung
Normal Text wird in horizontaler Richtung gerendert.
Up Text wird in vertikaler Richtung von unten nach oben in der Zelle gerendert.
Down Text wird in vertikaler Richtung von oben nach unten in der Zelle gerendert.
TextEffectEnum-Aufzählung
Legt den zu verwendenden 3D-Effekt fest, wenn der Text der Zelle gerendert wird.

Syntax
[VB]
Public Enum TextEffectEnum
[C#]
public sealed enum TextEffectEnum : System.Enum
[Delphi]
type TextEffectEnum = (Flag, Inset, Raised);
Bemerkungen
TreeStyleFlags-Aufzählung · 445
Um einen 3D-Effekt für Texte zu erstellen, legt die Tabelle einen Streifen mit einem Farbübergang von
der Vordergrundfarbe zur Hintergrundfarbe an und erstellt damit einen Schatten. Die Qualität des
Effekts hängt von den verwendeten Farben und Schriftarten ab.
Mitglieder
Mitgliedsname Beschreibung
Flat Kein 3D-Effekt.
Raised Der Text wird mit einem, um einen Pixel nach rechts unten versetzten Schatten unterlegt.
Inset Der Text wird mit einem, um einen Pixel nach links oben versetzten Schatten unterlegt.
TreeStyleFlags-Aufzählung
Legt das Aussehen des Gliederungsbaums mit der Tree-Eigenschaft fest.
Syntax
[VB]
Public Enum TreeStyleFlags
[C#]
public sealed enum TreeStyleFlags : System.Enum
[Delphi]
type TreeStyleFlags = (ButtonBar, Complete, CompleteLeaf, Leaf, Lines, None, Simple, SimpleLeaf,
Symbols);
Mitglieder
Mitgliedsname Beschreibung
None Zeigt den Gliederungsbaum nicht an.
Lines Zeigt Baumlinien neben den Knotenzeilen an.
Symbols Zeigt Ein-/Ausklappsymbole an.
ButtonBar Zeigt Gliederungsschaltflächen in der obersten fixierten Zeile an.
Leaf Zeigt Baumlinien neben allen Zeilen an (Knoten- und Datenzeilen).

446 · C1FlexGrid-Referenzverzeichnis
Complete Kombination von Lines, Symbols und ButtonBar.
Simple Kombination von Lines und Symbols.
CompleteLeaf Kombination von Lines, Symbols, ButtonBar und Leaf.
SimpleLeaf Kombination von Lines, Symbols und Leaf.
C1FlexGrid-Schnittstellen
IC1EmbeddedEditor-Schnittstelle
IC1EmbeddedEditor ist eine öffentliche Schnittstelle, die in der C1Common.dll deklariert wird.
Steuerungen, die diese Schnittstelle implementieren, besitzen eine bessere Integration in der Tabelle. Zum
Beispiel können diese visuelle Formate der Host-Steuerung annehmen und benutzerdefinierte Verhalten
für Tastatureingaben, Gültigkeitsprüfungen und Positionierung bereitstellen.
Die IC1EmbeddedEditor-Schnittstelle enthält die folgenden Mitglieder:
• void C1EditorInitialize(object value, IDictionary editorAttributes)
Diese Methode wird aufgerufen, um den Editorinhalt und das Format zu initialisieren.
Der Parameter ‚value’ enthält die Tabellendaten, die vom Editor angezeigt werden sollen.
Der Parameter ‚editorAttributes’ beinhaltet ein IDictionary-Objekt mit Schlüsseln für die
Formatelementenamen und die Werte für die zu bearbeitende Zelle (z.B. Schriftart,
Hintergrundfarbe). Der Editor kann diese Formatvorlagen verwenden, um die Ansicht und das
Verhalten der Host-Steuerung der Tabelle nachzustellen. Der Editor kann jedes beliebige, aber
sinnvolle Attribut verwenden und andere ignorieren.
Das ‚editorAttributes’-Wörterbuch beinhaltet die folgenden Elemente:
Schlüssel Typ Beschreibung
BackColor Color Zellhintergrund
ContentAlignment ContentAlignment Textausrichtung in der Zelle
DataType Type zu bearbeitender Datentyp
EditMask String Zellbearbeitungsmaske (z.B. „(999) 999-9999“)
Font Font Zellschriftart
ForeColor Color Zellvordergrund
Format String Zellformatierungszeichenkette (z.B. „#,##0.##“)
Margins Margins zusätzlicher Rand um den Zellinhalt in Pixeln
WordWrap Boolean Der Editor soll Zeilenumbüche einfügen.
Der Standardabwickler setzt die Text-Eigenschaft des Editors und ignoriert alle Formatvorlagen.

• object C1EditorGetValue()
IC1EmbeddedEditor-Schnittstelle · 447
Gibt den aktuellen Wert des Editors zurück. Dieser kann von jedem beliebigen Datentyp sein.
Der Standardabwickler gibt die Text-Eigenschaft des Editors zurück.
• object C1EditorSetValue()
Setzt den aktuellen Wert des Editors. Dieser kann von jedem beliebigen Datentyp sein.
Der Standardabwickler setzt die Text-Eigenschaft des Editors.
• bool C1EditorValueIsValid()
Gibt TRUE zurück, wenn der Editor gerade gültigen Inhalt besitzt (z.B. beinhaltet dieser eine
EditMask und alle benötigten Positionen sind ausgefüllt).
Der Standardabwickler gibt immer TRUE zurück.
• UITypeEditorEditStyle C1EditorGetStyle()
Gibt das Editorformat zurück, welches den Schaltflächentyp festlegt, der in der Zelle vor und
während der Bearbeitung angezeigt wird (DropDown, Modal, None).
Der Standardabwickler gibt DropDown für ComboBoxes, DateTimePickers und UpDown-
Steuerungen zurück. Er gibt NONE für alle anderen Steuerungstypen zurück.
Anmerkung: Die UITypeEditorEditStyle-Aufzählung wird im System.Drawing.Design-
Namensbereich definiert. Die möglichen Einstellungen sind DropDown, Modal und None.
• void C1EditorUpdateBounds(Rectangle rc)
Verschiebt den Editor auf ein gegebenes Rechteck, sodass dieser nach der Initialisierung und
immer dann, wenn die Tabelle scrollt, genau über der Zelle steht.
Der Standardabwickler legt die Bounds-Eigenschaft der Steuerung fest.
• bool C1EditorKeyDownFinishEdit(KeyEventArgs e)
Gitb TRUE zurück, wenn eine gegebene Taste die Bearbeitung abschließen und dies von der
Tabelle abgewickelt werden soll.
Der Standardabwickler gibt TRUE für die Tabulator-, Enter- und Escape-Taste zurück. Er wickelt
auch die Pfeiltasten für Editoren ab, basierend auf TextBox-, ComboBox- und DateTimePicker-
Steuerungen.
• string C1EditorFormat(object value, string mask)
Formatiert einen gegebenen Wert mit der Angabenmaske.
Der Standardabwickler gibt eine Zeichenkette der Werte zurück (C1EditorGetValue().ToString()).

C1FlexGridClassic-Steuerung
C1FlexGridClassic-Steuerung · 449
C1FlexGridClassic ist eine von C1FlexGrid abgeleitete Steuerung und beinhaltet ein Objektmodel, das
genauso wie die VSFlexGrid ActiveX-Steuerung aussieht. C1FlexGridClassic wurde für die einfache
Migration von existierenden VSFlexGrid-Projekten entwickelt.
Der Quellcode für C1FlexGridClassic wird als Beispiel zur Verfügung gestellt. Sie können diesen als
Referenz verwenden, um zu sehen, wie die C1FlexGrid-Steuerung als Basisklasse bei der Entwicklung
einer benutzerdefinierten Tabellensteuerung verwendet wird.

450 · C1FlexGridClassic-Referenzverzeichnis
C1FlexGridClassic-Referenzverzeichnis
C1FlexGridClassic-Klassen
Alle C1FlexGridClassic-Mitglieder
C1FlexGridClassic-Eigenschaften
AllowBigSelection Ermittelt oder legt fest, ob ein Klick auf einen fixierten
Bereich die gesamte Zeile oder Spalte auswählt.
AllowDragging
Unterstützt vom .NET-Compact-Framework.
AllowEditing
Unterstützt vom .NET-Compact-Framework.
AllowMerging
Unterstützt vom .NET-Compact-Framework.
AllowResizing
Unterstützt vom .NET-Compact-Framework.
Legt fest, ob der Nutzer Spalten/Zeilen mit der Maus
ziehen darf.
Legt fest, ob der Nutzer Zellen bearbeiten darf.
Legt fest, ob Zellen mit ähnlichem Inhalt verbunden
werden.
Legt fest, ob der Nutzer die Größe von Spalten und
Zeilen mit der Maus verändern darf.
AllowSelection Ermittelt oder legt fest, ob der Nutzer Zellbereiche mit
der Maus oder der Tastatur auswählen darf.
AllowSorting
Unterstützt vom .NET-Compact-Framework.
Legt fest, ob der Nutzer Spalten mit der Maus sortieren
darf.
AllowUserResizing Legt fest, ob der Nutzer die Größe von Spalten und
Zeilen mit der Maus verändern darf.
AutoSizeMode Ermittelt oder legt fest, ob Spaltenbreiten und
Zeilenhöhen automatisch von AutoSize an die
Zellinhalte angepasst werden.
BackColorAlternate Gibt oder legt die Hintergrundfarbe für alternierende
Zeilen zurück/fest (0 für deaktivieren).
BackColorBkg Gibt oder legt die Hintergrundfarbe für den Bereich, der
nicht mit Zellen bedeckt ist, zurück/fest.
BackColorFixed Gibt oder legt die Hintergrundfarbe für fixierte Zeilen
und Spalten zurück/fest.
BackColorSel Gibt oder legt die Hintergrundfarbe für ausgewählte
Zellen zurück/fest.
BackgroundImage Gibt oder legt ein Hintergrundbild für die ausgewählte
Zelle zurück/fest.
Cell Gibt ein Cell-Objekt zurück.
CellAlignment Ermittelt oder legt die Ausrichtung von Texten in der
ausgewählten Zelle oder dem Bereich fest.

IC1EmbeddedEditor-Schnittstelle · 451
CellBackColor Gibt zurück oder setzt die Hintergrundfarbe für die
ausgewählte Zelle oder den Bereich.
CellButtonImage Legt die Grafik auf einer Zellschaltfläche fest.
CellButtonPicture Legt das Bild auf einer Zellschaltflächen fest.
CellChecked Ermittelt oder legt fest, ob eine Tabellenzelle ein
Häkchen hat.
CellFont Ermittelt oder legt das Schriftartattribut der
ausgewählten Zelle oder des Bereichs fest.
CellFontBold Ermittelt oder legt das Fettschriftattribut der Schriftart
in der ausgewählten Zelle oder dem Bereich fest.
CellFontItalic Ermittelt oder legt das Kursivarttribut der Schriftart in
der ausgewählten Zelle oder dem Bereich fest.
CellFontName Ermittelt oder legt den Namen der Schriftart in der
ausgewählten Zelle oder des Bereichs fest.
CellFontSize Ermittelt oder legt die Größe der Schriftart in der
ausgewählten Zelle oder des Bereichs fest.
CellFontStrikeThru Ermittelt oder legt das Strikethruarttribut der Schriftart
in der ausgewählten Zelle oder dem Bereich fest.
CellFontUnderline Ermittelt oder legt das Unterstreichungsarttribut der
Schriftart in der ausgewählten Zelle oder dem Bereich
fest.
CellForeColor Ermittelt oder legt die Vordergrundfarbe der
ausgewählten Zelle oder des Bereichs fest.
CellHeight Gibt die Höhe der ausgewählten Zelle in Twips zurück.
Bringt die Zelle, wenn nötig mit Bildlauf, auf den
Bildschirm.
CellLeft Der linke Teil der Zelle.
CellPicture Ermittelt oder legt das in einer ausgewählten Zelle oder
einem Bereich anzuzeigende Bild fest.
CellPictureAlignment Ermittelt oder legt die Ausrichtung von Grafiken in der
ausgewählten Zelle oder dem Bereich fest.
CellTextStyle Ermittelt oder legt den 3D-Effekt für den Text in einer
ausgewählten Zelle oder einem Bereich fest.
CellTop Der obere Teil der Zelle.
CellWidth Gibt die Breite der ausgewählten Zelle in Twips zurück.
Bringt die Zelle, wenn nötig mit Bildlauf, auf den
Bildschirm.
Cols
Unterstützt vom .NET-Compact-Framework.
Gibt alle Spalten einer Tabelle zurück.
ColumnCollection Ermittelt oder legt die ColumnCollection fest.
ColWidthMax Ermittelt oder legt die maximale Spaltenbreite in Twips
fest.

452 · C1FlexGridClassic-Referenzverzeichnis
ColWidthMin Ermittelt oder legt die minimale Spaltenbreite in Twips
fest.
ComboCount Gibt die Anzahl der Einträge in der Auswahlliste des
Auswahllisteneditors zurück.
ComboIndex Ermittelt oder legt den bei Null beginnenden Index der
aktuellen Auswahl in der Auswahlliste des Editors fest.
Editable Ermittelt oder legt fest, ob die Steuerung
Zellbearbeitung zulässt.
EditSelLength Ermittelt oder legt die Anzahl der im Editor
ausgewählten Zeichen fest.
EditSelStart Ermittelt oder legt das erste Zeichen der Auswahl im
Editor fest.
EditSelText Ermittelt oder legt die Zeichenkette der aktuellen
Auswahl im Editor fest.
EditText Ermittelt oder legt den Text im Editor fest.
EditWindow Gibt einen Abwickler an das Bearbeitungsfenster der
Tabelle zurück, oder 0 wenn die Tabelle sich nicht im
Bearbeitungsmodus befindet.
Ellipsis Ermittelt oder legt fest, ob die Steuerung Ellipsis („...“)
nach langen Zeichenketten anzeigen soll.
ExplorerBar Ermittelt oder legt fest, ob Spaltenüberschriften für
Sortieren und/oder Verschieben verwendet werden.
FillStyle Ermittelt oder legt fest, ob Änderungen in den Text-
oder Format-Eigenschaften auf die aktuelle Zelle oder
die gesamte Auswahl angewendet werden sollen.
FixedCols Ermittelt oder legt die Anzahl der fixierten Spalten
(nicht scrollbar) fest.
FixedRows Ermittelt oder legt die Anzahl der fixierten Zeilen (nicht
scrollbar) fest.
FontBold Legt fest, ob Text fett ist.
FontItalic Legt fest, ob Text kursiv ist.
FontName Legt den Namen der für den Text verwendeten
Schriftart fest.
FontSize Legt die Schriftgröße für den Text fest, der mit
Objekten angezeigt wird.
FontStrikeThru Legt fest, ob Text das Strikethru-Format besitzt.
FontUnderline Legt fest, ob Text unterstrichen ist.
ForeColorFixed Ermittelt oder legt die Vordergrundfarbe von fixierten
Zeilen und Spalten fest.
ForeColorSel Ermittelt oder legt die Vordergrundfarbe von
ausgewählten Zellen fest.
FrozenCols Ermittelt oder legt die Anzahl der eingefrorenen
Spalten (bearbeitbar, aber nicht scrollbar) fest.

IC1EmbeddedEditor-Schnittstelle · 453
FrozenRows Ermittelt oder legt die Anzahl der eingefrorenen Zeilen
(bearbeitbar, aber nicht scrollbar) fest.
GridColor Ermittelt oder legt die Farbe der Gitterlinien zwischen
den nicht fixierten Zellen fest.
GridColorFixed Ermittelt oder legt die Farbe der Gitterlinien zwischen
den fixierten Zellen fest.
GridLines Ermittelt oder legt den Typ der Gitterlinien zwischen
den nicht fixierten Zellen fest.
GridLinesFixed Ermittelt oder legt den Typ der Gitterlinien zwischen
den fixierten Zellen fest.
GridLineWidth Ermittelt oder legt die Breite der Gitterlinien in Pixeln
fest.
KeyActionEnter
Unterstützt vom .NET-Compact-Framework.
KeyActionTab
Unterstützt vom .NET-Compact-Framework.
Legt die auszuführende Aktion fest, wenn der Nutzer
die Enter-Taste drückt.
Legt die auszuführende Aktion fest, wenn der Nutzer
die Tabulator-Taste drückt.
MergeCells Ermittelt oder legt fest, ob Zellen mit gleichem Inhalt zu
einer Zelle verbunden werden.
NodeClosedPicture Ermittelt oder legt das Bild für einen geschlossenen
Gliederungsknoten fest.
NodeOpenPicture Ermittelt oder legt das Bild für einen offenen
Gliederungsknoten fest.
OutlineBar Ermittelt oder legt den Typ der anzuzeigenden
Gliederungsleiste fest.
OutlineCol Ermittelt oder legt die für den Gliederungsbaum zu
verwendende Spalte fest.
Picture Gibt ein Abbild der gesamten Steuerung zurück.
Redraw Legt fest, ob die Tabelle ihre Inhalte zeichnen soll.
PicturesOver Der Standardwert dieser Eigenschaft ist FALSE.
RowHeightMax Ermittelt oder legt die maximale Zeilenhöhe in Twips
fest.
RowHeightMin Ermittelt oder legt die minimale Zeilenhöhe in Twips
fest.
Rows Gibt alle Zeilen einer Tabelle zurück.
SelectedRows Gibt die Anzahl der ausgewählten Zeilen zurück, wenn
der SelectionMode auf flexSelectionListBox steht.
SelectionMode Legt das Auswahlverhalten der Tabelle fest.
SheetBorder Ermittelt oder legt die Farbe des Rahmens um das
Arbeitsblatt fest.
Sort Legt die Sortierungsrichtung fest.
Styles Gibt alle Formatvorlagen einer Tabelle zurück.

454 · C1FlexGridClassic-Referenzverzeichnis
TabBehavior Ermittelt oder legt fest, ob die Tabulator-Taste den
Fokus zwischen den Steuerungen (VB-Standard) oder
zwischen Tabellenzellen verschiebt.
Text Ermittelt oder legt den Inhalt der ausgewählten Zelle
oder des Bereichs fest.
TextStyle Ermittelt oder legt den 3D-Effekt für den Text in nicht
fixierten Zellen fest.
TextStyleFixed Ermittelt oder legt den 3D-Effekt für den Text in
fixierten Zellen fest.
TreeColor Ermittelt oder legt die Farbe für den Gliederungsbaum
fest.
Value Gibt den numerischen Wert der aktuellen Zelle zurück.
WallPaper Ermittelt oder legt eine Hintergrundgrafik für den
scrollbaren Bereich der Tabelle fest.
WordWrap Legt fest, ob lange Zeichenketten in der Zelle
umgebrochen werden.
C1FlexGridClassic-Methoden
AutoSize Passt die Breite von Spalten und die Höhe von Zeilen an den
Zellinhalt an.
Clear Löscht den Inhalt einer Steuerung. Optionale Parameter legen fest,
was wo gelöscht werden soll.
ComboItem Gibt die mit einem Element verknüpfte Zeichenkette aus der
Auswahlliste des Editors zurück.
EditCell Aktiviert den Bearbeitungsmodus.
FindRow Sucht eine Zeile mit einer bestimmten Zeichenkette oder einem
bestimmten Objekt.
get_Cell Ermittelt die cell-Eigenschaften für einen willkürlichen Bereich.
get_ColAlignment Ermittelt die Ausrichtung einer gegebenen Spalte.
get_ColComboList Ermittelt die für ein Auswahlfeld zu verwendende Liste von einer
bestimmten Spalte.
get_ColData Ermittelt ein benutzerdefiniertes, mit einer Spalte verknüpftes Variant.
get_ColDataType Ermittelt den Datentyp einer Spalte.
get_ColEditMask Ermittelt die Eingabemaske, die für die Bearbeitung der Zellen in einer
bestimmten Spalte verwendet wird.
get_ColFormat Ermittelt das für numerische Werte verwendete Format.
get_ColHidden Ermittelt ob eine Spalte ausgeblendet ist.
get_ColIndent Ermittelt den Einzug einer gegebenen Spalte in Twips.
get_ColIndex Ermittelt den Spaltenindex der zu einer gegebenen Taste passt.
get_ColIsVisible Ermittelt ob eine gegebene Spalte derzeit auf dem Bildschirm ist.

IC1EmbeddedEditor-Schnittstelle · 455
get_ColKey Ermittelt einen Taste, mit der eine gegebene Spalte identifiziert wird.
get_ColPos Ermittelt die linke (x) Koordinate einer Spalte, relativ zur Kante der
Steuerung in Twips.
get_ColSort Ermittelt die Sortierungsrichtung für jede Spalte (zur Verwendung mit
der Sort-Eigenschaft).
get_ColWidth Ermittelt die Breite einer bestimmten Spalte in Twips.
get_FixedAlignment Ermittelt die Ausrichtung für fixierte Zeilen in einer Spalte.
get_IsCollapsed Ermittelt ob eine Zeile eingeklappt ist.
get_IsSelected Ermittelt ob eine Zeile ausgewählt ist (für listbox-Auswahltypen).
get_IsSubtotal Ermittelt ob eine Zeile Zwischensummen beinhaltet (anstelle von
Daten).
get_MergeCol Ermittelt ob die Zellen einer Spalte verbunden werden (Siehe auch
MergeCells-Eigenschaft).
GetMergedRange Ermittelt ob die Zellen eines Bereichs verbunden werden.
get_MergeRow Ermittelt ob die Zellen einer Zeile verbunden werden (Siehe auch
MergeCells-Eigenschaft).
GetNode Ermittelt ein Gliederungsknotenobjekt für eine gegebene
Zwischensummenzeile.
GetNodeRow Ermittelt die Anzahl der einer Zeile übergeordneten und
untergeordneten ersten und letzten Zeilen in der Gliederung.
get_RowData Ermittelt ein benutzerdefiniertes, mit einer gegebenen Zeile
verknüpftes Variant.
get_RowHeight Ermittelt die Höhe einer bestimmten Zeile in Twips.
get_RowHidden Ermittelt ob eine Zeile versteckt ist.
get_RowIsVisible Ermittelt ob eine gegebene Zeile derzeit auf dem Bildschirm ist.
get_RowOutlineLevel Ermittelt die Gliederungsebene für eine Zwischensummenzeile.
get_RowPos Ermittelt die obere (y) Koordinate einer Zeile, relativ zur Kante der
Steuerung in Twips.
GetSelection Ermittelt die sortierte aktuelle Auswahl, so dass Row1

456 · C1FlexGridClassic-Referenzverzeichnis
set_ColAlignment Legt die Ausrichtung einer gegebenen Spalte fest.
set_ColComboList Legt die für ein Auswahlfeld zu verwendende Liste von einer
bestimmten Spalte fest.
set_ColData Legt ein benutzerdefiniertes, mit einer Spalte verknüpftes Variant fest.
set_ColDataType Legt den Datentyp einer Spalte fest.
set_ColEditMask Legt die Eingabemaske fest, die für die Bearbeitung der Zellen in einer
bestimmten Spalte verwendet wird.
set_ColFormat Legt das für numerische Werte verwendete Format fest.
set_ColHidden Legt fest, ob eine Spalte ausgeblendet ist.
set_ColImageList Legt einen zu verwendenden Abwickler auf eine ImageList als Quelle
des Bildes für eine gegebene Spalte fest.
set_ColIndent Legt den Einzug einer gegebenen Spalte in Twips fest.
set_ColKey Legt eine Taste fest, mit der eine gegebene Spalte identifiziert wird.
set_ColPosition Verschiebt eine gegebene Spalte auf eine neue Position.
set_ColSort Legt die Sortierungsrichtung für jede Spalte fest (zur Verwendung mit
der Sort-Eigenschaft).
set_ColWidth Legt die Breite einer bestimmten Spalte in Twips fest.
set_FixedAlignment Legt die Ausrichtung für fixierte Zeilen in einer Spalte fest.
set_IsCollapsed Legt fest, ob eine Zeile eingeklappt ist.
set_IsSelected Legt fest,ob eine Zeile ausgewählt ist (für listbox-Auswahltypen).
set_IsSubtotal Legt fest, ob eine Zeile Zwischensummen beinhaltet (anstatt Daten).
set_MergeCol Legt fest, ob die Zellen einer Spalte verbunden werden (Siehe auch
MergeCells-Eigenschaft).
set_MergeRow Legt fest, ob die Zellen einer Zeile verbunden werden (Siehe auch
MergeCells-Eigenschaft).
set_RowData Legt ein benutzerdefiniertes, mit einer gegebenen Zeile verknüpftes
Variant fest.
set_RowHeight Legt die Höhe einer bestimmten Zeile in Twips fest.
set_RowHidden Legt fest, ob eine Zeile versteckt ist.
set_RowOutlineLevel Legt die Gliederungsebene für eine Zwischensummenzeile fest.
set_RowPosition Verschiebt eine gegebene Zeile auf eine neue Position.
set_TextMatrix Legt den Inhalt einer Zelle fest, die durch ihre Zeilen- und
Spaltenkoordinaten definiert wird.
C1FlexGridClassic-Eigenschaften
AllowBigSelection-Eigenschaft
Ermittelt oder legt fest, ob ein Klick auf den fixierten Bereich die gesamte Zeile oder Spalte auswählt.

Syntax
[VB]
Public-Eigenschaft AllowBigSelection As Boolean
[C#]
public bool AllowBigSelection {get; set;}
[Delphi]
property AllowBigSelection: Boolean;
Bemerkungen
AllowDragging-Eigenschaft (C1FlexGridClassic) · 457
Wenn AllowBigSelection auf TRUE steht, dann wählt ein Klick auf die linke, obere, fixierte Zelle die
gesamte Tabelle aus.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
SelectionMode-Eigenschaft (Seite 167)
AllowDragging-Eigenschaft (C1FlexGridClassic)
Legt fest, ob der Nutzer Spalten/Zeilen mit der Maus ziehen darf.
Syntax
[VB]
Public AllowDragging As AllowDraggingEnum
[C#]
public AllowDraggingEnum AllowDragging {get; set;}
[Delphi]
property AllowDragging: AllowDraggingEnum;
Eigenschaftswert
Einer der AllowDraggingEnum-Werte. Der Standardwert ist AllowDraggingEnum.Columns.
Wert Beschreibung
None Der Nutzer kann mit der Maus Zeilen und Spalten nicht ziehen.
Columns Der Nutzer kann mit der Maus Spalten auf neue Positionen ziehen.
Rows Der Nutzer kann mit der Maus Zeilen auf neue Positionen ziehen.
Both Der Nutzer kann mit der Maus Zeilen und Spalten auf neue Positionen ziehen.
Bemerkungen
Sie können das Ziehen von bestimmten Zeilen und Spalten verhindern, indem Sie deren AllowDragging-
Eigenschaft auf FALSE setzen. Zum Beispiel:

458 · C1FlexGridClassic-Referenzverzeichnis
• Visual Basic
• C#
flex.AllowDragging = AllowDraggingEnum.Columns
flex.Cols(2).AllowDragging = False
flex.AllowDragging = AllowDraggingEnum.Columns;
flex.Cols[2].AllowDragging = false;
• Delphi
flex.AllowDragging := AllowDraggingEnum.Columns;
flex.Cols[2].AllowDragging := false;
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGridClassic-Klasse (Seite 450)
AllowEditing-Eigenschaft (C1FlexGridClassic)
Legt fest, ob der Nutzer Zellen bearbeiten darf.
Syntax
[VB]
Public AllowEditing As Boolean
[C#]
public bool AllowEditing { get; set;}
[Delphi]
property AllowEditing: Boolean;
Eigenschaftswert
Der Standardwert ist TRUE.
Bemerkungen
Sie können das Bearbeiten von bestimmten Zeilen und Spalten verhindern, indem Sie deren
AllowEditing-Eigenschaft auf FALSE setzen. Zum Beispiel
• Visual Basic
• C#
flex.AllowEditing = True
flex.Cols(2).AllowEditing = False ' prevent editing column 2
flex.AllowEditing = true;
flex.Cols[2].AllowEditing = false; // prevent editing column 2
• Delphi
flex.AllowEditing := true;
flex.Cols[2].AllowEditing := false; // prevent editing column 2
Für mehr Details und Beispiele über Zellbearbeitung, schauen Sie bitte unter „Zellen bearbeiten“ (Seite
37) nach.

Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGridClassic-Klasse (Seite 450)
AllowMerging-Eigenschaft (C1FlexGridClassic)
Legt fest, ob Zellen mit ähnlichem Inhalt verbunden werden.
Syntax
[VB]
Public AllowMerging As AllowMergingEnum
[C#]
public AllowMergingEnum AllowMerging {get; set;}
[Delphi]
property AllowMerging: AllowMergingEnum;
Eigenschaftswerte
AllowMerging-Eigenschaft (C1FlexGridClassic) · 459
Einer der AllowMergingEnum-Werte. Der Standardwert ist AllowMergingEnum.None.
Wert Beschreibung
None Zellen nicht verbinden.
Free Angrenzende Zellen mit gleichem Inhalt verbinden.
RestrictRows Zeilen verbinden, wenn die Zellen darüber auch verbunden sind.
RestrictCols Spalten verbinden, wenn die Zellen links davon auch verbunden sind.
RestrictAll Zellen verbinden, wenn die Zellen darüber und links davon auch verbunden sind.
FixedOnly
Nur fixierte Zellen verbinden. Diese Einstellung ist für komplexe Überschriften
sinnvoll, ohne dabei die Datenzellen selbst zu verbinden.
Spill Langen Einträgen erlauben, in leere, angrenzende Zellen überzugehen.
Nodes
Bemerkungen
Langen Einträgen in Knotenzeilen erlauben, in leere, angrenzende Zellen
überzugehen.
Verbunde Zellen dienen dazu, Daten auf eine klare und ansprechende Weise anzuzeigen, indem
Gruppen mit gleichen Informationen hervorgehoben werden. Somit sind Sie felxibel und können
ähnliche Tabellen wie die, die Sie in HTML oder mit Microsoft Word (beide unterstützen verbundene
Zellen) verwenden, erstellen.
Um Tabellen mit verbundenen Zellen zu erstellen, müssen Sie die AllowMerging-Eigenschaft auf einen
von AllowMergingEnum.None verschiedenen Wert, und die AllowMerging-Eigenschaft von den
jeweiligen Zeilen und Spalten, die Sie verbinden wollen, auf TRUE setzen. Nachdem diese Eigenschaften
gesetzt wurden, wird die Tabellensteuerung automatisch angrenzende Zellen mit gleichen Inhalten
verbinden. Immer wenn sich die Tabelleninhalte verändern, aktualisiert die Tabelle die Verbindungen.

460 · C1FlexGridClassic-Referenzverzeichnis
Beispiel
Durch den nachfolgenden Quellcode verbindet die Tabellensteuerung angrenzende Zellen mit gleichen
Daten in Spalte 1:
• Visual Basic
• C#
flex.AllowMerging = AllowMergingEnum.Free
flex.Cols(1).AllowMerging = True ' merge values in column 1
flex.AllowMerging = AllowMergingEnum.Free;
flex.Cols[1].AllowMerging = true; // merge values in column 1
• Delphi
flex.AllowMerging := AllowMergingEnum.Free;
flex.Cols[1].AllowMerging := true; // merge values in column 1
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGridClassic-Klasse (Seite 450)
AllowResizing-Eigenschaft (C1FlexGridClassic)
Legt fest, ob der Nutzer die Größe von Spalten und Zeilen mit der Maus verändern darf.
Syntax
[VB]
Public AllowResizing As AllowResizingEnum
[C#]
public AllowResizingEnum AllowResizing {get; set;}
[Delphi]
property AllowResizing: AllowResizingEnum;
Eigenschaftswerte
Einer der AllowResizingEnum-Werte. Der Standardwert ist AllowResizingEnum.Columns.
Wert Beschreibung
None Der Nutzer kann die Größe von Zeilen und Spalten nicht verändern.
Columns
ColumnsUniform
Rows
Der Nutzer kann die Breite von Spalten verändern, indem er die Kanten der
fixierten Spalten oben in der Tabelle entsprechend zieht. Ein Doppelklick auf die
Kante der fixierten Zellen passt die Breite an den breitesten Eintrag dieser an.
Der Nutzer kann die Breite einer Spalte mit der Maus verändern. Wenn die
Größe einer Spalte verändert wurde, dann wird die neue Spaltenbreite auf alle
Spalten angewendet.
Der Nutzer kann die Höhe von Zeile verändern, indem er die Kanten der fixierten
Zeilen links in der Tabelle entsprechend zieht. Ein Doppelklick auf die Kante der
fixierten Zellen passt die Höhe an deren höchsten Eintrag an.

Wert Beschreibung
Both
RowsUniform
BothUniform
Bemerkungen
AllowSelection-Eigenschaft · 461
Der Nutzer kann die Höhe von Zeilen und die Breite von Spalten mit der Maus
verändern.
Der Nutzer kann die Höhe einer Zeile mit der Maus verändern. Wenn die Größe
einer Zeile verändert wurde, dann wird die neue Zeilenhöhe auf alle Zeilen
angewendet.
Der Nutzer kann die Höhe von Zeilen und die Breite von Spalten mit der Maus
verändern. Wenn die Größe einer Zeile oder Spalte verändert wurde, dann wird
die neue Höhe oder Breite auf alle Zeilen oder Spalten angewendet.
Um Zeilen oder Spalten in ihrer Größe zu verändern, muss der Mauszeiger über den fixierten Zellen der
Tabelle und nahe einer Grenze zwischen Zeilen und Spalten stehen. Der Mauszeiger ändert sich dann zu
einem Größenzeiger und der Nutzer kann die Zeilen und Spalten ziehen, um deren Höhe oder Breite zu
verändern.
Wenn eine Spaltengruppe ausgewählt wurde (von der ersten bis zur letzten Zeile) und der Nutzer die
Größe einer davon verändert, dann werden alle ausgewählten Spalten ebenfalls angepasst. Das selbe gilt
für Zeilen.
Wenn die Anpassung der Größe für Spalten erlaubt ist, dann kann mit einem Doppelklick deren Breite
automatisch an den längsten Eintrag der entsprechenden Spalte angepasst werden.
Zeilen mit einer Höhe von Null und Spalten mit einer Breite von Null können vom Nutzer nicht mehr
verändert werden. Wenn Sie diese Zeilen und Spalten zwar sehr klein, aber immer noch veränderbar
haben wollen, dann sollten Sie deren Höhe oder Breite auf einen Pixel stellen, und nicht Null.
Die BeforeResizeRow- und BeforeResizeColumn-Ereignisse werden vor der Veränderung gestartet und
können dazu verwendet werden, die Veränderung der Größe von bestimmten Zeilen und Spalten zu
verhindern. Die AfterResizeRow- und AfterResizeColumn-Ereignisse werden nach der
Größenanpassung gestartet und können für die Prüfung der Änderung oder das Aktualisieren der
Anzeige verwendet werden.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGridClassic-Klasse (Seite 450)
AllowSelection-Eigenschaft
Ermittelt oder legt fest, ob der Nutzer Zellbereiche mit der Maus oder der Tastatur auswählen darf.
Syntax
[VB]
Public AllowSelection As Boolean
[C#]
public bool AllowSelection {get; set;}

462 · C1FlexGridClassic-Referenzverzeichnis
[Delphi]
property AllowSelection: Boolean;
Bemerkungen
Setzen Sie diese Eigenschaft auf FALSE um den Nutzer daran zu hindern, eine Auswahl per Klick und
Ziehen oder mit den Shift- und Plus-Cursortasten zu erweitern. In diesem Fall wird Klicken und Ziehen
mit der Maus die aktuelle Zelle verschieben, aber nicht die Auswahl erweitern.
Diese Funktion ist nützlich, wenn Sie die C1FlexGridClassic-Steuerung verwenden, um bestimmte
Benutzerschnittstellen, wie z.B. Menüs, Eigenschaftsblätter oder explorerähnliche Bäume, zu
implementieren.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
SelectionMode-Eigenschaft (Seite 167)
AllowSorting-Eigenschaft (C1FlexGridClassic)
Legt fest, ob der Nutzer Spalten mit der Maus sortieren darf.
Syntax
[VB]
Public AllowSorting As AllowSortingEnum
[C#]
public AllowSortingEnum AllowSorting {get; set;}
[Delphi]
property AllowSorting: AllowSortingEnum;
Eigenschaftswerte
Einer der AllowSortingEnum-Werte. Der Standardwert ist AllowSortingEnum.SingleColumn.
Wert Beschreibung
None Der Nutzer kann Spalten nicht mit der Maus sortieren.
SingleColumn
MultiColumn
Der Nutzer kann Spalten mit der Maus sortieren. Klickt man auf die
Spaltenüberschrift, so werden diese jeweils auf- oder absteigend sortiert.
Diese Funktion ist gleich denen, die in den meisten Standardanwendungen, wie
zum Beispiel Windows Explorer, zu finden sind.
Der Nutzer kann Spalten mit der Maus sortieren. Klickt man auf die
Spaltenüberschrift, so werden alle Spalten von der Ersten bis zu der, auf die man
geklickt hat auf- oder absteigend sortiert.
Diese Einstellung ist sinnvoll, wenn die Daten nach Kategorien von links nach
rechts gruppiert sind und Sie diese Gruppen trotz Sortieren erhalten wollen.

Bemerkungen
AllowUserResizing-Eigenschaft · 463
Wenn sich die Tabelle im gebundenen Modus befindet, so wird das Sortieren in der darunterliegenden
Datentabelle vorgenommen.
Wenn die Tabelle ungebundenen ist, können Sie die Daten auch mit der Sort-Methode sortieren.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGridClassic-Klasse (Seite 450)
AllowUserResizing-Eigenschaft
Legt fest, ob der Nutzer die Größe von Spalten und Zeilen mit der Maus verändern darf.
Syntax
[VB]
Public AllowUserResizing As AllowUserResizeSettings
[C#]
public AllowUserResizeSettings AllowUserResizing {get; set;}
[Delphi]
property AllowUserResizing: AllowUserResizeSettings;
Bemerkungen
Gültige Einstellungen für die AllowUserResizing-Eigenschaft:
Mitgliedsname Beschreibung
flexResizeNone (0)
Der Nutzer kann die Größe von Zeilen und Spalten
nicht verändern.
flexResizeColumns (1) Der Nutzer kann die Spaltenbreite verändern.
flexResizeRows (2) Der Nutzer kann die Zeilenhöhe verändern.
flexResizeBoth (3)
flexResizeBothUniform (4)
flexResizeRowsUniform (5)
Der Nutzer kann die Größe von Zeilen und Spalten
verändern.
Der Nutzer kann die Größe von Zeilen und Spalten
verändern.
Wenn die Zeilenhöhe geändert wird, dann wird diese
Höhe auf alle Zeilen angewendet.
Um Zeilen oder Spalten in ihrer Größe zu verändern, muss der Mauszeiger über den fixierten Zellen der
Tabelle und nahe einer Grenze zwischen Zeilen und Spalten stehen. Der Mauszeiger ändert sich dann zu
einem Größenzeiger und der Nutzer kann die Zeilen und Spalten ziehen, um deren Höhe oder Breite zu
verändern.
Wenn ein Bereich an Spalten ausgewählt ist (von der ersten bis zur letzten Zeile) und der Nutzer deren
Größe ändert, dann wird die neue Größe auf alle ausgwählten Spalten angewendet. Das gleiche gilt für

464 · C1FlexGridClassic-Referenzverzeichnis
Zeilen. Setzen Sie die AllowBigSelection-Eigenschaft auf TRUE, um Nutzern zu erlauben, ganze Zeilen
und Spalten auszuwählen.
Wenn die Größe von Spalten verändert werden darf und die AutoSizeMouse-Eigenschaft auf TRUE
steht, dann kann der Nutzer auf den Größenveränderungsbereich einer Spalte doppelklicken, um die
Breite der Spalte an ihren breitesten Eintrag anzupassen.
Die Größe von Zeilen, mit einer Höhe von Null, und Spalten, mit einer Breite von Null, können vom
Nutzer nicht mehr geändert werden. Wenn Sie Zeilen und Spalten sehr klein machen, die Änderung der
Größe durch den Nutzer aber immer noch erlauben wollen, dann stellen Sie deren Höhe und Breite auf
einen Pixel, und nicht auf Null. Zum Beispiel:
• Visual Basic
• C#
fg.set_ColWidth(5,1)
fg.set_ColWidth(5,1);
• Delphi
fg.set_ColWidth(5, 1);
Das BeforeUserResize-Ereignis wird gestartet, bevor die Größenänderung stattfindet und kann dafür
verwendet werden, diesen Vorgang für bestimmte Zeilen und Spalten zu verhindern. Das
AfterUserResize-Ereignis wird gestartet, nachdem die Größenänderung stattgefunden hat und kann für
die Gültigkeitsprüfung der Eingaben des Nutzers verwendet werden.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
AllowResizing-Eigenschaft (Seite 122)
AutoSizeMode-Eigenschaft
Ermittelt oder legt fest, ob Spaltenbreiten und Zeilenhöhen automatisch von AutoSize an die Zellinhalte
angepasst werden.
Syntax
[VB]
Public AutoSizeMode As AutoSizeSettings
[C#]
public AutoSizeSettings AutoSizeMode {get; set;}
[Delphi]
property AutoSizeMode: AutoSizeSettings;
Bemerkungen
Gültige Einstellungen für die AutoSizeMode-Eigenschaft:
Mitgliedsname Beschreibung
flexAutoSizeColWidth Der Nutzer kann die Breite von Spalten verändern.

flexAutoSizeRowHeight Der Nutzer kann die Höhe von Zeilen verändern.
BackColorAlternate-Eigenschaft · 465
Die flexAutoSizeRowHeight-Einstellung ist nützlich, wenn Text in einer Zelle umgebrochen wird (Siehe
WordWrap-Eigenschaft) oder wenn Zellen verschiedene Schriftgrößen haben (Siehe Cell-Eigenschaft).
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
AutoSizeCol-Methode (Seite 176)
BackColorAlternate-Eigenschaft
Gibt oder legt die Hintergrundfarbe für alternierende Zeilen zurück/fest (0 für deaktivieren).
Syntax
[VB]
Public BackColorAlternate As Color
[C#]
public Color BackColorAlternate {get; set;}
[Delphi]
property BackColorAlternate: Color;
Bemerkungen
Wenn Sie die BackColorAlternate-Eigenschaft auf einen von Null verschiedenen Wert setzen, dann wird
die festgelegte Farbe für den Hintergrund jeder zweiten Zeile der Steuerung verwendet.
Diese Eigenschaft zu verwenden ist schneller und effizienter, als die CellBackColor-Eigenschaft einer
jeden zweiten Zeile festzulegen. Außerdem bleiben die alternierenden Farben erhalten, wenn Sie die
Tabelle sortieren, oder Zeilen entfernen oder hinzufügen.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
CellStyle-Klasse (Seite 376)
BackColorBkg-Eigenschaft
Gibt oder legt die Hintergrundfarbe für den Bereich, der nicht mit Zellen bedeckt ist, zurück/fest.
Syntax
[VB]
Public BackColorBkg As Color
[C#]
public Color BackColorBkg {get; set}
[Delphi]
property BackColorBkg: Color;

466 · C1FlexGridClassic-Referenzverzeichnis
Bemerkungen
Schauen Sie unter der BackColor-Eigenschaft nach, um eine Übersicht über die Farben zu erhalten, und
für welche Bereiche der Tabelle diese verwendet werden.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
CellStyle-Klasse (Seite 376)
BackColorFixed-Eigenschaft
Gibt oder legt die Hintergrundfarbe für fixierte Zeilen und Spalten zurück/fest.
Syntax
[VB]
Public BackColorFixed As Color
[C#]
public Color BackColorFixed {get; set}
[Delphi]
property BackColorFixed: Color;
Bemerkungen
Schauen Sie unter der BackColor-Eigenschaft nach, um eine Übersicht über die Farben zu erhalten, und
für welche Bereiche der Tabelle diese verwendet werden.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
CellStyle-Klasse (Seite 376)
BackColorSel-Eigenschaft
Gibt oder legt die Hintergrundfarbe für ausgewählte Zellen zurück/fest.
Syntax
[VB]
Public BackColorSel As Color
[C#]
public Color BackColorSel {get; set}
[Delphi]
property BackColorSel: Color;
Bemerkungen
Schauen Sie unter der BackColor-Eigenschaft nach, um eine Übersicht über die Farben zu erhalten, und
für welche Bereiche der Tabelle diese verwendet werden.

Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
CellStyle-Klasse (Seite 376)
BackgroundImage-Eigenschaft
Gibt oder legt ein Hintergrundbild für die ausgewählte Zelle zurück/fest.
Syntax
[VB]
Public-Eigenschaft BackgroundImage As Image
[C#]
public Image BackgroundImage {get; set;}
[Delphi]
property BackgroundImage: Image;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
Cell-Eigenschaft
Gibt ein Cell-Objekt zurück.
Syntax
[VB]
Public ReadOnly-Eigenschaft Cell As C1.Win.C1FlexGrid.Classic.Cell
[C#]
public C1.Win.C1FlexGrid.Classic.Cell Cell {get;}
[Delphi]
property Cell: C1.Win.C1FlexGrid.Classic.Cell;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
CellAlignment-Eigenschaft
BackgroundImage-Eigenschaft · 467
Ermittelt oder legt die Ausrichtung von Texten in der ausgewählten Zelle oder dem Bereich fest.
Syntax
[VB]
Public CellAlignment As AlignmentSettings

468 · C1FlexGridClassic-Referenzverzeichnis
[C#]
public AlignmentSettings CellAlignment {get; set;}
[Delphi]
property CellAlignment: AlignmentSettings;
Bemerkungen
Gültige Einstellungen für die CellAlignment-Eigenschaft:
Mitgliedsname Beschreibung
flexAlignLeftTop Richtet Text links oben aus.
flexAlignLeftCenter Richtet Text links zentriert aus.
flexAlignLeftBottom Richtet Text links unten aus.
flexAlignCenterTop Richtet Text zentriert oben aus.
flexAlignCenterCenter Richtet Text zentriert aus.
flexAlignCenterBottom Richtet Text zentriert unten aus.
flexAlignRightTop Richtet Text rechts oben aus.
flexAlignRightCenter Richtet Text rechts zentriert aus.
flexAlignRightBottom Richtet Text rechts unten aus.
flexAlignGeneral Richtet Text links und Zahlen und Daten rechts aus.
Wenn diese Eigenschaft geändert wird, dann betrifft dies die aktuelle Zelle oder Auswahl, je nach
Einstellung der FillStyle-Eigenschaft. Verwenden Sie stattdessen die Cell-Eigenschaft, um die
Ausrichtung für einen willkürlichen Zellbereich festzulegen (nicht zwingend die aktuelle Auswahl).
Dieses Beispiel wählt die ersten sieben Zellen in der 3. Spalte aus und zentriert den Textinhalt.
• Visual Basic
• C#
With fg
'select rows 1 through 7 in Column 3
.Select 1, 3, 7, 3
.FillStyle = FillStyleSettings.flexFillRepeat
.CellAlignment = AlignmentSettings.flexAlignCenterCenter
'return .FillStyle to its default (if needed)
.FillStyle = FillStyleSettings.flexFillSingle
End With
//select rows 1 through 7 in Column 3
fg.Select 1, 3, 7, 3;
fg.FillStyle = FillStyleSettings.flexFillRepeat;
df.CellAlignment = AlignmentSettings.flexAlignCenterCenter;
//return .FillStyle to its default (if needed)
fg.FillStyle = FillStyleSettings.flexFillSingle;
} With
• Delphi
With fg do

CellBackColor-Eigenschaft · 469
begin
// select rows 1 through 7 in Column 3
Select(1, 3, 7, 3);
FillStyle := FillStyleSettings.flexFillRepeat;
CellAlignment := AlignmentSettings.flexAlignCenterCenter;
// return .FillStyle to its default (if needed)
FillStyle := FillStyleSettings.flexFillSingle;
end;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
CellStyle-Klasse (Seite 376)
CellBackColor-Eigenschaft
Gibt zurück oder setzt die Hintergrundfarbe für die ausgewählte Zelle oder den Bereich.
Syntax
[VB]
Public CellBackColor As Color
[C#]
public Color CellBackColor {get; set;}
[Delphi]
property CellBackColor: Color;
Bemerkungen
Wenn diese Eigenschaft auf Null (schwarz) gestellt wird, dann verwendet die Steuerung die
Standardfarben, die durch die BackColor- und BackColorAlternate-Eigenschaften festgelegt sind.
Verwenden Sie daher RGB(1,1,1) anstatt RGB(0,0,0), um diese Eigenschaft auf schwarz zu stellen.
Der folgende Quellcode ändert die Hintergrundfarbe der aktuellen Zelle:
• Visual Basic
• C#
fg.CellBackColor = System.Drawing.Color.Red
fg.CellBackColor = System.Drawing.Color.Red;
• Delphi
fg.CellBackColor := System.Drawing.Color.Red;
Wenn diese Eigenschaft geändert wird, dann betrifft dies die aktuelle Zelle oder Auswahl, je nach
Einstellung der FillStyle-Eigenschaft. Verwenden Sie stattdessen die Cell-Eigenschaft, um die
Hintergrundfarbe für einen willkürlichen Zellbereich festzulegen (nicht zwingend die aktuelle Auswahl).
Dieses Beispiel wählt die ersten sieben Zellen in der 3. Spalte aus und legt deren Hintergrundfarbe fest.

470 · C1FlexGridClassic-Referenzverzeichnis
• Visual Basic
• C#
With fg
.Select (1, 3, 7, 3)
.FillStyle = FillStyleSettings.flexFillRepeat
.CellBackColor = System.Drawing.Color.Red
'return .FillStyle to its default (if needed)
.FillStyle = FillStyleSettings.flexFillSingle
'Make cell 1, 1 the current cell so we can view the change
.Select (1, 1)
End With
fg.Select (1, 3, 7, 3);
fg.FillStyle = FillStyleSettings.flexFillRepeat;
fg.CellBackColor = System.Drawing.Color.Red;
//return .FillStyle to its default (if needed)
fg.FillStyle = FillStyleSettings.flexFillSingle;
//Make cell 1, 1 the current cell so we can view the change
fg.Select (1, 1);
• Delphi
With fg do
begin
Select (1, 3, 7, 3);
FillStyle := FillStyleSettings.flexFillRepeat;
CellBackColor := System.Drawing.Color.Red;
// return .FillStyle to its default (if needed)
FillStyle := FillStyleSettings.flexFillSingle;
// Make cell 1, 1 the current cell so we can view the change
Select (1, 1);
end;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
CellStyle-Klasse (Seite 376)
CellButtonImage-Eigenschaft (C1FlexGridClassic)
Legt die Grafik auf einer Zellschaltfläche fest.
Syntax
[VB]
Public CellButtonImage As Image
[C#]
public Image CellButtonImage {get; set;}
[Delphi]
property CellButtonImage: Image;
Bemerkungen
Mit dieser Eigenschaft können Sie das Aussehen der Zellschaltflächen anpassen. Für Details über die
Handhabung von Zellschaltflächen schauen Sie bitte unter CellButtonClick-Ereignis nach.

CellButtonPicture-Eigenschaft · 471
Wenn Sie nur eine Grafik für alle Zellschaltflächen in der Tabelle verwenden wollen, dann ordnen Sie
diese der CellButtonImage-Eigenschaft während der Designtime zu. Um die Grafiken je nach Spalte,
Zeile oder zu bearbeitender Zelle zu verändern, fangen Sie das BeforeEdit-Ereignis ab und legen Sie das
entsprechende Bild fest.
Die für die Zellschaltflächen verwendete Grafik sollte auf die Schaltfläche passen (größere Grafiken
werden beschnitten). Diese sollten auch transparent sein, so dass die Schaltflächenoberfläche durch die
leeren Stellen der Grafik zu sehen ist. Für das beste Ergebnis, verwenden Sie kleine Symbole (16x16 Pixel)
und zeichnen Sie das Bild in das obere linke12x12-Rechteck innerhalb des Symbols.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGridClassic-Klasse (Seite 450)
CellButtonPicture-Eigenschaft
Legt das Bild auf einer Zellschaltfläche fest.
Syntax
[VB]
Public-Eigenschaft CellButtonPicture As System.Drawing.Image
[C#]
public Image CellButtonPicture {get; set;}
[Delphi]
property CellButtonPicture: Image;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
CellChecked-Eigenschaft
Ermittelt oder legt fest, ob eine Tabellenzelle ein Häkchen hat.
Syntax
[VB]
Public CellChecked As CellCheckedSettings
[C#]
public CellCheckedSettings CellChecked {get; set;}
[Delphi]
property CellChecked: CellCheckedSettings;
Bemerkungen
Gültige Einstellungen für die CellChecked-Eigenschaft:

472 · C1FlexGridClassic-Referenzverzeichnis
Mitgliedsname Beschreibung
flexNoCheckbox Die Zelle besitzt kein Kontrollkästchen. (Standardeinstellung)
flexChecked Die Zelle besitzt ein Kontrollkästchen mit Häkchen.
flexUnchecked Die Zelle besitzt ein Kontrollkästchen ohne Häkchen.
Wenn eine Zelle ein Kontrollkästchen besitzt und die AllowEditing-Eigenschaft auf TRUE steht, dann
kann der Nutzer dessen Zustand mit einem Mausklick oder mit der Leer- oder Entertaste ändern. Egal
auf welchem Wege das Kästchen umgeschaltet wird, das AfterEdit-Ereignis wird gestartet und Sie
können entsprechende Maßnahmen vornehmen.
Das Kontrollkästchen kann sich links, rechts oder zentriert, je nach Einstellung der
CellPictureAlignment-Eigenschaft, befinden.
Wenn diese Eigenschaft geändert wird, dann betrifft dies die aktuelle Zelle oder Auswahl, je nach
Einstellung der FillStyle-Eigenschaft. Verwenden Sie stattdessen die Cell-Eigenschaft, um die
Kontrollkästchenzustände für einen willkürlichen Zellbereich festzulegen (nicht zwingend die aktuelle
Auswahl).
Zum Beispiel, der nachfolgende Quellcode erstellt Spalte eins:
• Visual Basic
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As
System.EventArgs)
Dim r&
For r = fg.FixedRows To fg.Rows - 1
fg.set_Cell(CellPropertySettings.flexcpChecked, _
r, 1, CellPropertySettings.flexcpChecked)
fg.set_Cell(CellPropertySettings.flexcpText, r, 1, "Row " &
r)
Next
fg.Editable = EditableSettings.flexEDKbdMouse
End Sub
_
• C#
Private Sub Button1_Click(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles Button1.Click
Dim r&
For r = fg.FixedRows To fg.Rows - 1
If fg.get_Cell(CellPropertySettings.flexcpChecked, r, 1) =
checked")
End If
Next
End Sub
CellPropertySettings.flexcpChecked Then
Debug.WriteLine(fg.get_TextMatrix(1, 1) & " is
private void Form1_Load( System.object sender, System.EventArgs e) {
r&;
for ( r = fg.FixedRows; r

CellFont-Eigenschaft · 473
}
private void Button1_Click( System.object sender, System.EventArgs e)
{
for (int r = fg.FixedRows; r

474 · C1FlexGridClassic-Referenzverzeichnis
[Delphi]
property CellFont: Boolean;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
CellStyle-Klasse (Seite 376)
CellFontBold-Eigenschaft
Ermittelt oder legt das Fettschriftattribut der Schriftart in der ausgewählten Zelle oder dem Bereich fest.
Syntax
[VB]
Public CellFontBold As Boolean
[C#]
public bool CellFontBold {get; set;}
[Delphi]
property CellFontBold: Boolean;
Bemerkungen
Wenn diese Eigenschaft geändert wird, dann betrifft dies die aktuelle Zelle oder Auswahl, je nach
Einstellung der FillStyle-Eigenschaft. Verwenden Sie stattdessen die Cell-Eigenschaft, um Fettschrift für
einen willkürlichen Zellbereich festzulegen (nicht zwingend die aktuelle Auswahl)
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
CellStyle-Klasse (Seite 376)
CellFontItalic-Eigenschaft
Ermittelt oder legt das Kursivarttribut der Schriftart in der ausgewählten Zelle oder dem Bereich fest.
Syntax
[VB]
Public CellFontItalic As Boolean
[C#]
public bool CellFontItalic {get; set;}
[Delphi]
property CellFontItalic: Boolean;
Bemerkungen
Wenn diese Eigenschaft geändert wird, dann betrifft dies die aktuelle Zelle oder Auswahl, je nach
Einstellung der FillStyle-Eigenschaft. Verwenden Sie stattdessen die Cell-Eigenschaft, um die
Kursivschrift für einen willkürlichen Zellbereich festzulegen (nicht zwingend die aktuelle Auswahl).

Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
CellStyle-Klasse (Seite 376)
CellFontName-Eigenschaft
CellFontName-Eigenschaft · 475
Ermittelt oder legt den Namen der Schriftart in der ausgewählten Zelle oder des Bereichs fest.
Syntax
[VB]
Public CellFontName As String
[C#]
public string CellFontName {get; set;}
[Delphi]
property CellFontName: string;
Bemerkungen
Wenn diese Eigenschaft geändert wird, dann betrifft dies die aktuelle Zelle oder Auswahl, je nach
Einstellung der FillStyle-Eigenschaft. Verwenden Sie stattdessen die Cell-Eigenschaft, um den
Schriftartnamen für einen willkürlichen Zellbereich festzulegen (nicht zwingend die aktuelle Auswahl).
Wenn diese Eigenschaft auf eine leere Zeichenkette gesetzt wird, dann wird die Zellformatierung
zurückgesetzt und die Standardschriftart verwendet.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
CellStyle-Klasse (Seite 376)
CellFontSize-Eigenschaft
Ermittelt oder legt die Größe der Schriftart in der ausgewählten Zelle oder des Bereichs fest.
Syntax
[VB]
Public CellFontSize As Integer
[C#]
public int CellFontSize {get; set;}
[Delphi]
property CellFontSize: Integer;
Bemerkungen
Wenn diese Eigenschaft geändert wird, dann betrifft dies die aktuelle Zelle oder Auswahl, je nach
Einstellung der FillStyle-Eigenschaft. Verwenden Sie stattdessen die Cell-Eigenschaft, um die
Schriftgröße für einen willkürlichen Zellbereich festzulegen (nicht zwingend die aktuelle Auswahl).

476 · C1FlexGridClassic-Referenzverzeichnis
Wenn diese Eigenschaft auf Null gesetzt wird, dann wird die Zellformatierung zurückgesetzt und die
Standardschriftgröße verwendet.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
CellStyle-Klasse (Seite 376)
CellFontStrikeThru-Eigenschaft
Ermittelt oder legt das Strikethruarttribut der Schriftart in der ausgewählten Zelle oder dem Bereich fest.
Syntax
[VB]
Public CellFontStrikeThru As Boolean
[C#]
public bool CellFontStrikeThru {get; set;}
[Delphi]
property CellFontStrikeThru: Boolean;
Bemerkungen
Wenn diese Eigenschaft geändert wird, dann betrifft dies die aktuelle Zelle oder Auswahl, je nach
Einstellung der FillStyle-Eigenschaft. Verwenden Sie stattdessen die Cell-Eigenschaft, um die Schriftart
für einen willkürlichen Zellbereich festzulegen (nicht zwingend die aktuelle Auswahl).
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
CellStyle-Klasse (Seite 376)
CellFontUnderline-Eigenschaft
Ermittelt oder legt das Unterstreichungsarttribut der Schriftart in der ausgewählten Zelle oder dem
Bereich fest.
Syntax
[VB]
Public CellFontUnderline As Boolean
[C#]
public bool CellFontUnderline {get; set;}
[Delphi]
property CellFontUnderline: Boolean;

Bemerkungen
CellForeColor-Eigenschaft · 477
Wenn diese Eigenschaft geändert wird, dann betrifft dies die aktuelle Zelle oder Auswahl, je nach
Einstellung der FillStyle-Eigenschaft. Verwenden Sie stattdessen die Cell-Eigenschaft, um Unterstreichen
für einen willkürlichen Zellbereich festzulegen (nicht zwingend die aktuelle Auswahl).
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
CellStyle-Klasse (Seite 376)
CellForeColor-Eigenschaft
Ermittelt oder legt die Vordergrundfarbe der ausgewählten Zelle oder des Bereichs fest.
Syntax
[VB]
Public CellForeColor As Color
[C#]
public Color CellForeColor {get; set;}
[Delphi]
property CellForeColor: Color;
Bemerkungen
Wenn diese Eigenschaft geändert wird, dann betrifft dies die aktuelle Zelle oder Auswahl, je nach
Einstellung der FillStyle-Eigenschaft. Verwenden Sie stattdessen die Cell-Eigenschaft, um die
Vordergrundfarbe für einen willkürlichen Zellbereich festzulegen (nicht zwingend die aktuelle
Auswahl).
Wenn diese Eigenschaft auf Null (schwarz) gestellt wird, dann verwendet die Steuerung die
Standardfarbe, die durch die ForeColor-Eigenschaften festgelegt ist. Verwenden Sie RGB(1,1,1) anstatt
RGB(0,0,0) oder vbBlack, um diese Eigenschaft auf schwarz zu stellen.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
CellStyle-Klasse (Seite 376)
CellHeight-Eigenschaft
Gibt die Höhe der ausgewählten Zelle in Twips zurück. Bringt die Zelle, wenn nötig mit Bildlauf, auf den
Bildschirm.
Syntax
[VB]
Public CellHeight As Integer
[C#]
public int CellHeight {get; set;}

478 · C1FlexGridClassic-Referenzverzeichnis
[Delphi]
property CellHeight: Integer;
Bemerkungen
Die CellHeight-, CellWidth-, CellTop- und CellLeft-Eigenschaften sind nützlich, um andere
Steuerungen über oder nah einer Zelle zu platzieren. Immer wenn Sie eine dieser Eigenschaften auslesen,
geht die Steuerung davon aus, dass Sie an der aktuellen Zelle arbeiten wollen und zeigt diese somit,
wenn nötig mit Bildlauf, auf dem Bildschirm an.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
GetCellRect-Methode (Seite 188)
CellLeft-Eigenschaft
Der linke Teil der Zelle.
Syntax
[VB]
Public CellLeft As Integer
[C#]
public int CellLeft {get; set;}
[Delphi]
property CellLeft: Integer;
Bemerkungen
Die CellHeight-, CellWidth-, CellTop- und CellLeft-Eigenschaften sind nützlich, um andere
Steuerungen über oder nah einer Zelle zu platzieren. Immer wenn Sie eine dieser Eigenschaften auslesen,
geht die Steuerung davon aus, dass Sie an der aktuellen Zelle arbeiten wollen und zeigt diese somit,
wenn nötig mit Bildlauf, auf dem Bildschirm an.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
GetCellRect-Methode (Seite 188)
CellPicture-Eigenschaft
Ermittelt oder legt das in einer ausgewählten Zelle oder einem Bereich anzuzeigende Bild fest.
Syntax
[VB]
Public CellPicture As Image
[C#]
public Image CellPicture {get; set;}

[Delphi]
property CellPicture: Image;
Bemerkungen
CellPictureAlignment-Eigenschaft · 479
Das Grafikobjekt, dass dieser Eigenschaft zugeordnet ist, kann von anderen Steuerungen abgerufen (z.B.
durch die Picture-Eigenschaft der Image-Steuerung) oder aus einer Datei von der Festplatte mit der
LoadPicture-Funktion von Visual Basic geladen werden.
Jede Zelle kann Text und eine Grafik enthalten. Die relative Position des Textes und der Grafik wird
durch die CellAlignment-Eigenschaft und CellPictureAlignment-Eigenschaft festgelegt. Wenn Sie den
Text über der Grafik anzeigen wollen, müssen Sie die PicturesOver-Eigenschaft auf TRUE setzen.
Wenn diese Eigenschaft geändert wird, dann betrifft dies die aktuelle Zelle oder Auswahl, je nach
Einstellung der FillStyle-Eigenschaft. Verwenden Sie stattdessen die Cell-Eigenschaft, um Bilder für
einen willkürlichen Zellbereich festzulegen (nicht zwingend die aktuelle Auswahl).
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
CellStyle-Klasse (Seite 376)
CellPictureAlignment-Eigenschaft
Ermittelt oder legt die Ausrichtung von Grafiken in der ausgewählten Zelle oder dem Bereich fest.
Syntax
[VB]
Public CellPictureAlignment As PictureAlignmentSettings
[C#]
public PictureAlignmentSettings CellPictureAlignment {get; set;}
[Delphi]
property CellPictureAlignment: PictureAlignmentSettings;
Bemerkungen
Gültige Einstellungen für die CellPictureAlignment-Eigenschaft:
Mitgliedsname Beschreibung
flexPicAlignLeftTop Richtet Grafiken links oben aus.
flexPicAlignLeftCenter Richtet Grafiken links zentriert aus.
flexPicAlignLeftBottom Richtet Grafiken links unten aus.
flexPicAlignCenterTop Richtet Grafiken zentriert oben aus.
flexPicAlignCenterCenter Richtet Grafiken zentriert aus.
flexPicAlignCenterBottom Richtet Grafiken zentriert unten aus.
flexPicAlignRightTop Richtet Grafiken rechts oben aus.
flexPicAlignRightCenter Richtet Grafiken rechts zentriert aus.

480 · C1FlexGridClassic-Referenzverzeichnis
flexPicAlignRightBottom Richtet Grafiken rechts unten aus.
flexPicAlignStretch Streckt das Bild, damit es die Zelle ausfüllt.
flexPicAlignTile Ordnet die Grafik nebeneinander an, um die Zelle auszufüllen.
Diese Eigenschaft legt auch die Ausrichtung von Kontrollkästchen in Zellen fest (Siehe CellChecked-
Eigenschaft).
Wenn diese Eigenschaft geändert wird, dann betrifft dies die aktuelle Zelle oder Auswahl, je nach
Einstellung der FillStyle-Eigenschaft. Verwenden Sie stattdessen die Cell-Eigenschaft, um die
Bilderausrichtung für einen willkürlichen Zellbereich festzulegen (nicht zwingend die aktuelle Auswahl).
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
CellStyle-Klasse (Seite 376)
CellTextStyle-Eigenschaft
Ermittelt oder legt den 3D-Effekt für den Text in einer ausgewählten Zelle oder einem Bereich fest.
Syntax
[VB]
Public CellTextStyle As TextStyleSettings
[C#]
public TextStyleSettings CellTextStyle {get; set;}
[Delphi]
property CellTextStyle: TextStyleSettings;
Bemerkungen
Die Effekte der CellTextStyle-Eigenschaftseinstellungen werden nachfolgend beschrieben:
Mitgliedsname Beschreibung
flexTextFlat Zeichnet Text normal.
flexTextRaised Zeichnet Text mit einem stark gehobenen 3D-Effekt.
flexTextInset Zeichnet Text mit einem stark eingelassenen 3D-Effekt.
flexTextRaisedLight Zeichnet Text mit einem schwach gehobenen 3D-Effekt.
flexTextInsetLight Zeichnet Text mit einem schwach eingelassenen 3D-Effekt.
Die Konstanten flexTextRaised und flexTextInset passen gut zu großen und fetten Schriftarten und
flexTextRaisedLight und flexTextInsetLight eher zu kleineren, normalen Schriftarten.

CellTop-Eigenschaft · 481
Wenn diese Eigenschaft geändert wird, dann betrifft dies die aktuelle Zelle oder Auswahl, je nach
Einstellung der FillStyle-Eigenschaft. Verwenden Sie stattdessen die Cell-Eigenschaft, um die
Textausrichtung für einen willkürlichen Zellbereich festzulegen (nicht zwingend die aktuelle Auswahl).
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
CellStyle-Klasse (Seite 376)
CellTop-Eigenschaft
Der obere Teil der Zelle.
Syntax
[VB]
Public CellTop As Integer
[C#]
public int CellTop {get; set;}
[Delphi]
property CellTop: Integer;
Bemerkungen
Die CellHeight-, CellWidth-, CellTop- und CellLeft-Eigenschaften sind nützlich, um andere
Steuerungen über oder nah einer Zelle zu platzieren. Immer wenn Sie eine dieser Eigenschaften auslesen,
geht die Steuerung davon aus, dass Sie an der aktuellen Zelle arbeiten wollen und zeigt diese somit,
wenn nötig mit Bildlauf, auf dem Bildschirm an.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
GetCellRect-Methode (Seite 188)
CellWidth-Eigenschaft
Gibt die Breite der ausgewählten Zelle in Twips zurück. Bringt die Zelle, wenn nötig mit Bildlauf, auf den
Bildschirm.
Syntax
[VB]
Public CellWidth As Integer
[C#]
public int CellWidth {get; set;}
[Delphi]
property CellWidth: Integer;

482 · C1FlexGridClassic-Referenzverzeichnis
Bemerkungen
Die CellHeight-, CellWidth-, CellTop- und CellLeft-Eigenschaften sind nützlich, um andere
Steuerungen über oder nah einer Zelle zu platzieren. Immer wenn Sie eine dieser Eigenschaften auslesen,
geht die Steuerung davon aus, dass Sie an der aktuellen Zelle arbeiten wollen und zeigt diese somit,
wenn nötig mit Bildlauf, auf dem Bildschirm an.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
GetCellRect-Methode (Seite 188)
Cols-Eigenschaft (C1FlexGridClassic)
Gibt alle Spalten einer Tabelle zurück.
Syntax
[VB]
Public Cols As ColumnCollection
[C#]
public ColumnCollection Cols {get;}
[Delphi]
property Cols: ColumnCollection;
Bemerkungen
Mit der Cols-Eigenschaft können Sie eine Liste mit allen derzeit vorhandenen Spalten in einer Tabelle
abfragen. Mit dieser Referenz können Sie Spalten hinzufügen, entfernen, verschieben und zählen. Für
weitere Informationen über die Funktionen dieser Sammlung schauen Sie in den Referenzthemen der
ColumnCollection-Klasse nach.
Diese Eigenschaft kann nur gelesen werden. Die Tabelle erstellt und verwaltet diese Liste/Sammlung.
Upgradenotiz: In der VSFlexGrid-ActiveX-Steuerung zeigen die Cols- und FixedCols-Eigenschaften die
Anzahl der Spalten und der fixierten Spalten in einer Tabelle. Verwenden Sie in C1FlexGrid hierfür
Cols.Count und Cols.Fixed.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGridClassic-Klasse (Seite 450)
ColumnCollection-Eigenschaft
Ermittelt oder legt die ColumnCollection fest.
Syntax
[VB]
Public-Eigenschaft ColumnCollection As C1.Win.C1FlexGrid.ColumnCollection

[C#]
public C1.Win.C1FlexGrid.ColumnCollection ColumnCollection {get; set;}
[Delphi]
property ColumnCollection: C1.Win.C1FlexGrid.ColumnCollection;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
ColWidthMax-Eigenschaft
Ermittelt oder legt die maximale Spaltenbreite in Twips fest.
Syntax
[VB]
Public ColWidthMax As Integer
[C#]
public int ColWidthMax {get; set;}
[Delphi]
property ColWidthMax: Integer;
Bemerkungen
ColWidthMax-Eigenschaft · 483
Setzen Sie diese Eigenschaft auf einen von Null verschiedenen Wert, um die maximale Breite von Spalten,
und auf Null, um keinen Grenzwert festzulegen. Verwenden Sie die ColWidthMin-Eigenschaft um die
Mindestgröße der Spalten festzusetzen.
Das Aufstellen von Grenzwerten für Spaltenbreiten kann in Verbindung mit der AutoSize-Methode
sinnvoll sein, um zu breite Spalten durch extrem lange Einträge, und zu schmale Spalten durch leere
Zellen zu verhindern.
Dieses Beispiel setzt die maximale Spaltenbreite auf zwei Inch (2880 Twips) fest:
• Visual Basic
• C#
fg.ColWidthMax = 2880
fg.ColWidthMax = 2880;
• Delphi
fg.ColWidthMax := 2880;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
MaxSize-Eigenschaft (ColumnCollection) (Seite 318)
ColWidthMin-Eigenschaft
Ermittelt oder legt die minimale Spaltenbreite in Twips fest.

484 · C1FlexGridClassic-Referenzverzeichnis
Syntax
[VB]
Public ColWidthMin As Integer
[C#]
public int ColWidthMin {get; set;}
[Delphi]
property ColWidthMin: Integer;
Bemerkungen
Setzen Sie diese Eigenschaft auf einen von Null verschiedenen Wert, um die Mindestbreite von Spalten,
und auf Null, um keinen Grenzwert festzulegen. Verwenden Sie die ColWidthMax-Eigenschaft, um die
maximale Breite der Spalten festzusetzen.
Das Aufstellen von Grenzwerten für Spaltenbreiten kann in Verbindung mit der AutoSize-Methode
sinnvoll sein, um zu breite Spalten duch extrem lange Einträge und zu schmale Spalten durch leere
Zellen zu verhindern.
Dieses Beispiel setzt die maximale Spaltenbreite auf ein halbes Inch (720 Twips) fest:
• Visual Basic
• C#
fg.ColWidthMin = 720
fg.ColWidthMin = 720;
• Delphi
fg.ColWidthMin := 720;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
MinSize-Eigenschaft (ColumnCollection) (Seite 318)
ComboCount-Eigenschaft
Gibt die Anzahl der Einträge in der Auswahlliste des Auswahllisteneditors zurück.
Syntax
[VB]
Public ReadOnly-Eigenschaft ComboCount As Integer
[C#]
public int ComboCount {get;}
[Delphi]
property ComboCount: Integer;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)

ComboIndex-Eigenschaft
ComboIndex-Eigenschaft · 485
Ermittelt oder legt den bei Null beginnenden Index der aktuellen Auswahl in der Auswahlliste des
Editors fest.
Syntax
[VB]
Public-Eigenschaft ComboIndex As Integer
[C#]
public int ComboIndex {get; set;}
[Delphi]
property ComboIndex: Integer;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
Editable-Eigenschaft
Ermittelt oder legt fest, ob die Steuerung Zellbearbeitung zulässt.
Syntax
[VB]
Public Editable As EditableSettings
[C#]
public EditableSettings Editable {get; set;}
[Delphi]
property Editable: EditableSettings;
Bemerkungen
Wenn die Editable-Eigenschaft auf einem von Null verschiedenen Wert steht, dann kann der Nutzer die
Zellinhalte bearbeiten, indem er in die Tabelle schreibt.
Die möglichen Einstellungen der Editable-Eigenschaft werden nachfolgend beschrieben:
Mitgliedsname Beschreibung
flexEDNone Der Tabelleninhalt kann vom Nutzer nicht bearbeitet werden.
flexEDKbd
flexEDKbdMouse
Der Nutzer kann den Bearbeitungsmodus initialisieren, wenn er in die
aktuelle Zelle schreibt.
Der Nutzer kann den Bearbeitungsmodus initialisieren, wenn er in die
aktuelle Zelle schreibt oder mit der Maus darauf doppelklickt.

486 · C1FlexGridClassic-Referenzverzeichnis
Standardmäßig geht die Steuerung in den Bearbeitungsmodus wenn der Nutzer die F2-, die Leer- oder
jede beliebige Zeichentaste drückt. Wenn die Editable-Eigenschaft auf flexEDKbdMouse (2) steht, dann
geht die Steuerung auch in den Bearbeitungsmodus, wenn der Nutzer auf eine Zelle doppelklickt.
Sie können die Steuerung mit der StartEditing-Methode in den Bearbeitungsmodus zwingen oder diesen
Modus verhindern, indem Sie das BeforeEdit-Ereignis abfangen und den Cancel-Parameter auf TRUE
setzen. Sie können den Bearbeitungsmodus abbrechen, indem Sie mit der Select-Anweisung eine andere
Zelle auswählen (inklusive der, die gerade bearbeitet wird).
Je nach Einstellung der get_ColComboList-Methode, können Sie ein gewöhnliches Textfenster, eine
Auswahlliste oder eine Kombinationsliste verwenden. Die Bearbeitungsmaske kann auch in der
EditMask-Eigenschaft als Antwort auf das BeforeEdit-Ereignis festgelegt werden.
Mit dem ValidateEdit-Ereignis können Daten auf Gültigkeit geprüft werden und mit dem AfterEdit-
Ereignis Anpassungen nach der Bearbeitung, wie z.B. Neusortierung, vorgenommen werden.
Verwenden Sie die EditWindow-Eigenschaft, um zu ermitteln, ob die Steuerung sich im
Bearbeitungsmodus befindet. In diesem Fall hat die Eigenschaft einen von Null verschiedenen Wert.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
AllowEditing-Eigenschaft (C1FlexGrid) (Seite 120)
EditSelLength-Eigenschaft
Ermittelt oder legt die Anzahl der im Editor ausgewählten Zeichen fest.
Syntax
[VB]
Public EditSelLength As Integer
[C#]
public int EditSelLength {get; set;}
[Delphi]
property EditSelLength: Integer;
Bemerkungen
Diese Eigenschaft arbeitet zusammen mit den EditSelStart- und EditSelText-Eigenschaften, während die
Steuerung sich im Zellbearbeitungsmodus befindet.
Verwenden Sie diese Eigenschaften für Aufgaben, wie das Festlegen einer Einfügestelle, Erstellen eines
Einfügebereichs, Auswahl von Zeichenkettenteilen in Editoren oder Entfernen von Text. Zusammen mit
dem Visual Basic-Clipboard-Objekt können diese für Kopieren, Ausschneiden und Einfügen nützlich
sein.
Anmerkungen:
1. Die SelLength auf einen Wert kleiner als 0 zu setzen, verursacht einen Runtimefehler.
2. Wenn die SelLength auf einen Wert größer als die Textlänge gesetzt wird, dann passt die
Steuerung diesen an die maximale Textlänge an.
3. Eine Änderung in SelStart ändert die Auswahl einer Einfügestelle und setzt SelLength auf 0.

EditSelStart-Eigenschaft · 487
4. Wenn SelText auf einen neuen Wert gesetzt wird, dann wird der aktuelle Text mit dem neuen
Wert ersetzt und SelLength auf 0 gestellt.
Der folgende Quellcode markiert immer dann Zeichen 6 bis 8, wenn die Zelle angeklickt wird.
• Visual Basic
Private Sub fg_Click(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles fg.Click
fg.EditCell
fg.EditSelStart = 5
fg.EditSelLength = 3
End Sub
• C#
private void fg_Click( System.object sender, System.EventArgs e)
fg.Click {
fg.EditCell;
fg.EditSelStart = 5;
fg.EditSelLength = 3;
}
• Delphi
procedure fg_Click(sender: System.Object;
e: System.EventArgs);
begin
fg.EditCell;
fg.EditSelStart := 5;
fg.EditSelLength := 3;
end;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
Editor-Eigenschaft (C1FlexGrid) (Seite 143)
EditSelStart-Eigenschaft
Ermittelt oder legt das erste Zeichen der Auswahl im Editor fest.
Syntax
[VB]
Public EditSelStart As Integer
[C#]
public int EditSelStart {get; set;}
[Delphi]
property EditSelStart: Integer;
Bemerkungen
Diese Eigenschaft arbeitet zusammen mit den EditSelLength- und EditSelText-Eigenschaften, während
die Steuerung sich im Zellbearbeitungsmodus befindet.
Verwenden Sie diese Eigenschaften für Aufgaben, wie das Festlegen einer Einfügestelle, Erstellen eines
Einfügebereichs, Auswahl von Zeichenkettenteilen in Editoren oder Entfernen von Text. Zusammen mit

488 · C1FlexGridClassic-Referenzverzeichnis
dem Visual Basic-Clipboard-Objekt können diese für Kopieren, Ausschneiden und Einfügen nützlich
sein.
Anmerkungen:
1. Die SelLength auf einen Wert kleiner als 0 zu setzen, verursacht einen Runtimefehler.
2. Wenn die SelLength auf einen Wert größer als die Textlänge gesetzt wird, dann passt die
Steuerung diesen an die maximale Textlänge an.
3. Eine Änderung in SelStart ändert die Auswahl einer Einfügestelle und setzt SelLength auf 0.
4. Wenn SelText auf einen neuen Wert gesetzt wird, dann wird der aktuelle Text mit dem neuen
Wert ersetzt und SelLength auf 0 gestellt.
Der folgende Quellcode markiert immer dann Zeichen 6 bis 8, wenn die Zelle angeklickt wird.
• Visual Basic
Private Sub fg_Click(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles fg.Click
fg.EditCell
fg.EditSelStart = 5
fg.EditSelLength = 3
End Sub
• C#
private void fg_Click( System.object sender, System.EventArgs e)
fg.Click {
fg.EditCell;
fg.EditSelStart = 5;
fg.EditSelLength = 3;
}
• Delphi
procedure fg_Click(sender: System.Object;
e: System.EventArgs);
begin
fg.EditCell;
fg.EditSelStart := 5;
fg.EditSelLength := 3;
end;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
Editor-Eigenschaft (C1FlexGrid) (Seite 143)
EditSelText-Eigenschaft
Ermittelt oder legt die Zeichenkette der aktuellen Auswahl im Editor fest.
Syntax
[VB]
Public EditSelText As String
[C#]
public string EditSelText {get; set;}

[Delphi]
property EditSelText: string;
Bemerkungen
EditSelText-Eigenschaft · 489
Diese Eigenschaft arbeitet zusammen mit den EditSelStart- und EditSelLength-Eigenschaften, während
die Steuerung sich im Zellbearbeitungsmodus befindet.
Verwenden Sie diese Eigenschaften für Aufgaben, wie das Festlegen einer Einfügestelle, Erstellen eines
Einfügebereichs, Auswahl von Zeichenkettenteilen in Editoren oder Entfernen von Text. Zusammen mit
dem Visual Basic-Clipboard-Objekt können diese für Kopieren, Ausschneiden und Einfügen nützlich
sein.
Anmerkungen:
1. Die SelLength auf einen Wert kleiner als 0 zu setzen, verursacht einen Runtimefehler.
2. Wenn die SelLength auf einen Wert größer als die Textlänge gesetzt wird, dann passt die
Steuerung diesen an die maximale Textlänge an.
3. Eine Änderung in SelStart ändert die Auswahl einer Einfügestelle und setzt SelLength auf 0.
4. Wenn SelText auf einen neuen Wert gesetzt wird, dann wird der aktuelle Text mit dem neuen
Wert ersetzt und SelLength auf 0 gestellt.
Der folgende Quellcode ersetzt immer dann Zeichen 6 bis 8 mit dem Wort „COW“, wenn die
Zelle angeklickt wird.
• Visual Basic
Private Sub fg_Click(ByVal sender As System.Object,
ByVal e As System.EventArgs) Handles fg.Click
fg.EditCell
fg.EditSelStart = 5
fg.EditSelLength = 3
fg.EditSelText = "COW"
End Sub
• C#
private void fg_Click( System.object sender,
System.EventArgs e)
{
fg.EditCell;
fg.EditSelStart = 5;
fg.EditSelLength = 3;
fg.EditSelText = "COW";
}
• Delphi
procedure fg_Click(sender: System.Object;
e: System.EventArgs);
begin
fg.EditCell;
fg.EditSelStart := 5;
fg.EditSelLength := 3;
fg.EditSelText := 'COW';
end;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)

490 · C1FlexGridClassic-Referenzverzeichnis
Editor-Eigenschaft (C1FlexGrid) (Seite 143)
EditText-Eigenschaft
Ermittelt oder legt den Text im Editor fest.
Syntax
[VB]
Public EditText As String
[C#]
public string EditText {get; set;}
[Delphi]
property EditText: string;
Bemerkungen
Mit der EditText-Eigenschaft können Sie den Inhalt des Zelleditors auslesen und verändern, während
dieser aktiv ist.
Diese Eigenschaft ist für die Verarbeitung des ValidateEdit-Ereignisses nützlich. Wenn das ValidateEdit-
Ereignis gestartet wird, dann enthält die Zelle immer noch ihren anfänglichen Wert. Der neue, bearbeitete
Wert steht nur über die EditText-Eigenschaft zur Verfügung.
Zum Beispiel, der nachfolgende Quellcode zeigt einen gängigen Abwickler für das ValidateEdit-Ereignis.
In diesem Fall nimmt Spalte eins nur Zeichenketten und Spalte zwei nur Zahlen größer als Null an:
• Visual Basic
• C#
Private Sub fg_ValidateEdit(ByVal sender As Object, _
ByVal e As C1.Win.C1FlexGrid.ValidateEditEventArgs) _
Handles fg.ValidateEdit
Dim c$
Select Case e.Col ' different validation rules for each column
Case 1 ' column 1 only accepts strings
c = Left$(fg.EditText, 1)
If UCaseS(c) < "A" Or UCase$(c) > "Z" Then Beep: e.Cancel = True
Case 2 ' column 2 only accepts numbers > 0
If Val(fg.EditText) "Z" ) e.Cancel = true;
case 2: // column 2 only accepts numbers > 0
try
{
int i = int.Parse(fg.EditText);
} catch {
e.Cancel = true;
}

}
}
• Delphi
procedure fg_ValidateEdit(sender: System.Object; _
e: C1.Win.C1FlexGrid.ValidateEditEventArgs);
var
c: char;
begin
case e.Col of // column 1 only accepts strings
1:
begin
c := fg.EditText.SubString(0, 1).ToUpper();
If (c < 'A') Or (c > 'Z') Then
e.Cancel := True;
end;
2:
begin
If Val(fg.EditText)

492 · C1FlexGridClassic-Referenzverzeichnis
• C#
ByVal e As C1.Win.C1FlexGrid.RangeEventArgs) Handles
fg.BeforeScroll
If Not fg.EditWindow.Equals(0) AndAlso e.OldRange.TopRow
e.NewRange.TopRow Then
e.Cancel = True
End Sub
private void fg_BeforeScroll( object sender,
C1.Win.C1FlexGrid.RangeEventArgs e) fg.BeforeScroll {
if (!fg.EditWindow.Equals(0) && e.OldRange.TopRow !=
e.NewRange.TopRow ) {
e.Cancel = true;
}
• Delphi
procedure fg_BeforeScroll(sender: System.Object;
e: C1.Win.C1FlexGrid.RangeEventArgs);
begin
If Not fg.EditWindow.Equals(0) and (e.OldRange.TopRow
e.NewRange.TopRow) Then
e.Cancel := True;
end;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
Editor-Eigenschaft (C1FlexGrid) (Seite 143)
Ellipsis-Eigenschaft
Ermittelt oder legt fest, ob die Steuerung Ellipsis („...“) nach langen Zeichenketten anzeigen soll.
Syntax
[VB]
Public Ellipsis As EllipsisSettings
[C#]
public EllipsisSettings Ellipsis {get; set;}
[Delphi]
property Ellipsis: EllipsisSettings;
Bemerkungen
Die Ellipsis-Eigenschaft legt fest, wie die Steuerung Zeichenketten anzeigt, die zu lang für den Platz in
einer Zelle sind. Indem Sie diese Eigenschaft auf einen von Null verschiedenen Wert setzen, zwingen Sie
die Tabelle mit einem Ellipsis-Symbol („...“) anzuzeigen, dass ein Teil des Textes abgeschnitten wurde.
Die möglichen Einstellungen der Ellipsis-Eigenschaft werden nachfolgend beschrieben:
Mitgliedsname Beschreibung
flexNoEllipsis
Lange Zeichenketten werden abgeschnitten und es werden keine Ellipsis-
Zeichen angezeigt.

ExplorerBar-Eigenschaft · 493
flexEllipsisEnd Ellipsis-Zeichen werden am Ende von langen Zeichenketten angezeigt.
flexEllipsisPath Ellipsis-Zeichen werden in der Mitte von langen Zeichenketten angezeigt.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
Trimming-Eigenschaft (Seite 387)
ExplorerBar-Eigenschaft
Ermittelt oder legt fest, ob Spaltenüberschriften für Sortieren und/oder Verschieben verwendet werden.
Syntax
[VB]
Public ExplorerBar As ExplorerBarSettings
[C#]
public ExplorerBarSettings ExplorerBar {get; set;}
[Delphi]
property ExplorerBar: ExplorerBarSettings;
Bemerkungen
Mit der ExplorerBar-Eigenschaft können Nutzer über Spaltenüberschriften die entsprechenden Spalten
ohne Quellcode sortieren und verschieben. Gültige Einstellungen werden nachfolgend beschrieben:
Mitgliedsname Beschreibung
flexExNone Nutzer können Spalten weder sortieren noch verschieben.
flexExSort Nutzer können Spalten sortieren.
flexExMove Nutzer können Spalten verschieben.
flexExSortAndMove Nutzer können Spalten sortieren und verschieben.
flexExSortShow
flexExSortShowAndMove
flexExMoveRows *
Nutzer können Spalten mit einem Klick auf deren Überschirft sortieren.
Die Steuerung zeigt die aktuelle Sortierungsrichtung mit einem Pfeil in
der Spaltenüberschrift an.
Nutzer können Spalten sortieren und verschieben. Die Steuerung zeigt
die aktuelle Sortierungsrichtung mit einem Pfeil in der
Spaltenüberschrift an.
Nutzer können Zeilen verschieben, indem sie die fixierten Zellen der
entsprechenden Zeile auf eine neue Position ziehen.
* Die Einstellung flexExMoveRows ist eigentlich ein Flag und kann mit anderen Einstellungen durch eine
„Or“-Anweisung verknüpft werden. Zum Beispiel:

494 · C1FlexGridClassic-Referenzverzeichnis
• Visual Basic
• C#
'allow sorting, moving rows, and moving columns
fg.ExplorerBar = ExplorerBarSettings.flexExMoveRows Or
ExplorerBarSettings.flexExSortShowAndMove
//allow sorting, moving rows, and moving columns
fg.ExplorerBar = ExplorerBarSettings.flexExMoveRows ||
ExplorerBarSettings.flexExSortShowAndMove;
• Delphi
//allow sorting, moving rows, and moving columns
fg.ExplorerBar := (ExplorerBarSettings.flexExMoveRows or
ExplorerBarSettings.flexExSortShowAndMove);
Beachten Sie, dass diese Werte eine Kombination von binären Flags und nicht sequentiell sind.
Standardmäßig funktioniert die ExplorerBar wie die im Dateiexplorer von Microsoft Windows. Ein Klick
sortiert die Spalte in aufsteigender Richtung, der nächste in absteigender Richtung. Jede nicht fixierte
Spalte kann auf eine andere nicht fixierte Position gezogen werden. Die Steuerung startet verschiedene
Ereignisse, mit denen Sie dieses Verhalten anpassen können. Diese Ereignisse sind BeforeSort, AfterSort,
BeforeDragColumn und AfterDragColumn.
Die neue ExplorerBar ist leichter zu bedienen. Zum Beispiel, wenn eine Spalte sortiert ist, dann wird ein
Dreiecksglyph in Richtung der Sortierung angezeigt. Außerdem wird nun deutlich die neue
Spaltenposition angezeigt und die Tabelle, wenn nötig, auch gescrollt, um Spalten auf jede beliebige
Position ziehen zu können, wenn eine Spalte verschoben werden soll.
Sie müssen mindestens eine fixierte Zeile haben, damit Sie ExplorerBar verwenden können.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
AllowResizing-Eigenschaft (Seite 122)
AllowSorting-Eigenschaft (C1FlexGrid) (Seite 124)
FillStyle-Eigenschaft
Ermittelt oder legt fest, ob Änderungen in den Text- oder Format-Eigenschaften auf die aktuelle Zelle
oder die gesamte Auswahl angewendet werden sollen.
Syntax
[VB]
Public FillStyle As FillStyleSettings
[C#]
public FillStyleSettings FillStyle {get; set;}
[Delphi]
property FillStyle: FillStyleSettings;
Bemerkungen
Die möglichen Einstellungen der FillStyle-Eigenschaft werden nachfolgend beschrieben:

Mitgliedsname Beschreibung
flexFillSingle
flexFillRepeat
FixedCols-Eigenschaft · 495
Das Setzen der Text- oder einer beliebigen Zellformatierungseigenschaft betrifft
nur die aktuelle Zelle.
Das Setzen der Text- oder einer beliebigen Zellformatierungseigenschaft betrifft
den gesamten, aktuell ausgewählten Bereich.
Die FillStyle-Eigenschaft legt außerdem fest, ob Änderungen durch Bearbeitung einer Zelle nur auf die
aktuelle Zelle oder die gesamte Auswahl angewendet werden sollen.
FillStyle wird ignoriert, wenn SelectionMode auf flexSelectionListBox steht.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
Selection-Eigenschaft (Seite 166)
FixedCols-Eigenschaft
Ermittelt oder legt die Anzahl der fixierten Spalten (nicht scrollbar) fest.
Syntax
[VB]
Public FixedCols As Integer
[C#]
public int FixedCols {get; set;}
[Delphi]
property FixedCols: Integer;
Bemerkungen
Fixierte Spalten bleiben sichtbar, wenn der Nutzer den Inhalt der Tabelle scrollt. Diese können vom
Nutzer weder ausgewählt noch verändert werden. Allerdings können sie mit Quellcode ausgewählt
werden, so dass es möglich ist, über die EditCell-Methode dem Nutzer das Verändern der Inhalte dieser
Zellen zu erlauben. Sie können FixedCols auf jeden Wert zwischen Null und Anzahl der Spalten setzen.
Die folgende Quellcodezeile platziert drei fixierte Spalten auf der linken Seite der Tabelle.
• Visual Basic
• C#
fg.FixedCols = 3
fg.FixedCols = 3;
• Delphi
fg.FixedCols := 3;
Fixierte Spalten werden in Tabellenkalkulationsprogrammen meist für Zeilennummern oder andere
Zeilenbezeichnungen verwendet.

496 · C1FlexGridClassic-Referenzverzeichnis
Verwenden Sie die BackColorFixed, ForeColorFixed und GridLinesFixed-Eigenschaften, um fixierte
Zellen zu formatieren.
Wenn die AllowUserResizing-Eigenschaft auf einem von Null verschiedenen Wert steht, dann können
die Zeilenhöhen und Spaltenbreiten über die fixierten Zellen durch den Nutzer während der Runtime
verändert werden.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
Fixed-Eigenschaft (ColumnCollection) (Seite 316)
FixedRows-Eigenschaft
Ermittelt oder legt die Anzahl der fixierten Zeilen (nicht scrollbar) fest.
Syntax
[VB]
Public FixedRows As Integer
[C#]
public int FixedRows {get; set;}
[Delphi]
property FixedRows: Integer;
Bemerkungen
Fixierte Zeilen bleiben sichtbar, wenn der Nutzer den Inhalt der Tabelle scrollt. Diese können vom
Nutzer weder ausgewählt noch verändert werden. Allerdings können sie mit Quellcode ausgewählt
werden, so dass es möglich ist, über die EditCell-Methode dem Nutzer das Verändern der Inhalte dieser
Zellen zu erlauben. Sie können FixedRows auf jeden Wert zwischen Null und Anzahl der Zeilen setzen.
Die folgende Quellcodezeile platziert drei fixierte Zeilen an der oberen Seite der Tabelle.
• Visual Basic
• C#
fg.FixedRows = 3
fg.FixedRows = 3;
• Delphi
fg.FixedRows := 3;
Fixierte Zeilen werden in Tabellenkalkulationsprogrammen meist für Spaltenüberschriften und in
Datenbankprogrammen für Feldnamen verwendet.
Verwenden Sie die BackColorFixed, ForeColorFixed und GridLinesFixed-Eigenschaften, um fixierte
Zellen zu formatieren.
Wenn die AllowUserResizing-Eigenschaft auf einem von Null verschiedenen Wert steht, dann können
die Zeilenhöhen und Spaltenbreiten über die fixierten Zellen durch den Nutzer während der Runtime
verändert werden.

FontBold-Eigenschaft · 497
Wenn die ExplorerBar-Eigenschaft auf einem von Null verschiedenen Wert steht, dann kann der Nutzer
Spalten mit den fixierten Zeilen und der Maus sortieren und verschieben.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
Fixed-Eigenschaft (RowCollection) (Seite 306)
FontBold-Eigenschaft
Legt fest, ob Text fett ist.
Syntax
[VB]
Public-Eigenschaft FontBold As Boolean
[C#]
public bool FontBold {get; set;}
[Delphi]
property FontBold: Boolean;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
FontItalic-Eigenschaft
Legt fest, ob Text kursiv ist.
Syntax
[VB]
Public-Eigenschaft FontItalic As Boolean
[C#]
public bool FontItalic {get; set;}
[Delphi]
property FontItalic: Boolean;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
FontName-Eigenschaft
Legt den Namen der für den Text verwendeten Schriftart fest.
Syntax
[VB]
Public-Eigenschaft FontName As String

498 · C1FlexGridClassic-Referenzverzeichnis
[C#]
public string FontName {get; set;}
[Delphi]
property FontName: String;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
FontSize-Eigenschaft
Legt Schriftgröße für die Texte fest, die mit Objekten angezeigt werden.
Syntax
[VB]
Public-Eigenschaft FontSize As Single
[C#]
public Single FontSize {get; set;}
[Delphi]
property FontSize: Single;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
FontStrikeThru-Eigenschaft
Legt fest, ob Text das Strikethru-Format besitzt.
Syntax
[VB]
Public-Eigenschaft FontStrikeThru As Boolean
[C#]
public bool FontStrikeThru {get; set;}
[Delphi]
property FontStrikeThru: Boolean;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
FontUnderline-Eigenschaft
Legt fest, ob Text unterstrichen ist.

Syntax
[VB]
Public-Eigenschaft FontUnderline As Boolean
[C#]
public bool FontUnderline {get; set;}
[Delphi]
property FontUnderline: Boolean;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
ForeColorFixed-Eigenschaft
Ermittelt oder legt die Vordergrundfarbe von fixierten Zeilen und Spalten fest.
Syntax
[VB]
Public ForeColorFixed As Color
[C#]
public Color ForeColorFixed {get; set;}
[Delphi]
property ForeColorFixed: Color;
Bemerkungen
Diese Eigenschaft legt die Schriftfarbe fest.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
Styles-Eigenschaft (Seite 170)
ForeColorSel-Eigenschaft
Ermittelt oder legt die Vordergrundfarbe von ausgewählten Zellen fest.
Syntax
[VB]
Public ForeColorSel As Color
[C#]
public Color ForeColorSel {get; set;}
[Delphi]
property ForeColorSel: Color;
ForeColorFixed-Eigenschaft · 499

500 · C1FlexGridClassic-Referenzverzeichnis
Bemerkungen
Diese Eigenschaft legt die Schriftfarbe fest.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
Styles-Eigenschaft (Seite 170)
FrozenCols-Eigenschaft
Ermittelt oder legt die Anzahl der eingefrorenen Spalten (bearbeitbar, aber nicht scrollbar) fest.
Syntax
[VB]
Public-Eigenschaft FrozenCols As Integer
[C#]
public int FrozenCols {get; set;}
[Delphi]
property FrozenCols: Integer;
Bemerkungen
Zellen in eingefrorenen Spalten können ausgewählt und bearbeitet werden und sie bleiben auf dem
Bildschirm stehen, wenn der Nutzer den Inhalt der Tabelle horizontal scrollt.
Eingefrorene Spalten sind nützlich, wenn die Tabelle als Datenbrowser verwendet wird. Damit kann der
Nutzer den Inhalt scrollen, wobei die linken Spalten aus FrozenCols sichtbar bleiben.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
FrozenRows-Eigenschaft
Ermittelt oder legt die Anzahl der eingefrorenen Zeilen (bearbeitbar, aber nicht scrollbar) fest.
Syntax
[VB]
Public-Eigenschaft FrozenRows As Integer
[C#]
public int FrozenRows {get; set;}
[Delphi]
property FrozenRows: Integer;
Bemerkungen
Zellen in eingefrorenen Zeilen können ausgewählt und bearbeitet werden und sie bleiben auf dem
Bildschirm stehen, wenn der Nutzer den Inhalt der Tabelle vertikal scrollt.

GridColor-Eigenschaft · 501
Eingefrorene Zeilen sind nützlich, wenn die oberen Zeilen Information anzeigen, die auf dem Bildschirm
bleiben sollen, z.B. Zwischensummenzeilen oder eine „query-by-example"-Suchzeile.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
GridColor-Eigenschaft
Ermittelt oder legt die Farbe der Gitterlinien zwischen den nicht fixierten Zellen fest.
Syntax
[VB]
Public GridColor As Color
[C#]
public Color GridColor {get; set;}
[Delphi]
property GridColor: Color;
Bemerkungen
Die GridColor- und GridLines-Eigenschaften legen das Format der Gitterlinien im scrollbaren Bereich
und GridColorFixed und GridLinesFixed im fixierten Bereich der Tabelle fest.
Die GridColor-Eigenschaft wird ignoriert, wenn GridLines auf einem 3D-Format steht. Hervorgehobene
und eingelassene Gitterlinien werden immer mit den vom System festgelegten Farben für Schatten und
Hervorhebungen gezeichnet.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
Styles-Eigenschaft (Seite 170)
GridColorFixed-Eigenschaft
Ermittelt oder legt die Farbe der Gitterlinien zwischen den fixierten Zellen fest.
Syntax
[VB]
Public GridColorFixed As Color
[C#]
public Color GridColorFixed {get; set;}
[Delphi]
property GridColorFixed: Color;
Bemerkungen
Die GridColorFixed- und GridLinesFixed-Eigenschaften legen das Format der Gitterlinien im fixierten
Bereich und GridColor und GridLines im scrollbaren Bereich der Tabelle fest.

502 · C1FlexGridClassic-Referenzverzeichnis
Die GridColorFixed-Eigenschaft wird ignoriert, wenn GridLinesFixed auf einem 3D-Format steht.
Hervorgehobene und eingelassene Gitterlinien werden immer mit den vom System festgelegten Farben
für Schatten und Hervorhebungen gezeichnet.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
Styles-Eigenschaft (Seite 170)
GridLines-Eigenschaft
Ermittelt oder legt den Typ der Gitterlinien zwischen den nicht fixierten Zellen fest.
Syntax
[VB]
Public GridLines As GridStyleSettings
[C#]
public GridStyleSettings GridLines {get; set;}
[Delphi]
property GridLines: GridStyleSettings;
Bemerkungen
Die GridColor- und GridLines-Eigenschaften legen das Format der Gitterlinien im scrollbaren Bereich
und GridColorFixed und GridLinesFixed im fixierten Bereich der Tabelle fest.
Die möglichen Einstellungen der GridLines-Eigenschaft werden nachfolgend beschrieben:
Mitgliedsname Beschreibung
flexGridNone Zeichnet keine Gitternetzlinien zwischen Zellen.
flexGridFlat
Zeichnet flache Linien mit der Farbe und der Breite aus den GridColor- und
GridLineWidth-Eigenschaften.
flexGridInset Zeichnet eingelassene Linien zwischen Zellen.
flexGridRaised Zeichnet herausgehobene Linien zwischen Zellen.
flexGridFlatHorz Zeichnet flache Linien zwischen Zeilen und keine Linien zwischen Spalten.
flexGridInsetHorz Zeichnet eingelassene Linien zwischen Zeilen und keine Linien zwischen Spalten.
flexGridRaisedHorz
Zeichnet herausgehobene Linien zwischen Zeilen und keine Linien zwischen
Spalten.
flexGridSkipHorz Zeichnet eingelassene Linien um jede zweite Zeile.
flexGridFlatVert Zeichnet flache Linien zwischen Spalten und keine Linien zwischen Zeilen.
flexGridInsetVert Zeichnet eingelassene Linien zwischen Spalten und keine Linien zwischen Zeilen.
flexGridRaisedVert
Zeichnet herausgehobene Linien zwischen Spalten und keine Linien zwischen
Zeilen.
flexGridSkipVert Zeichnet eingelassene Linien um jede zweite Spalte.

Mitgliedsname Beschreibung
flexGridExplorer Zeichnet schaltflächenähnliche Rahmen um jede Zelle.
flexGridExcel
GridLinesFixed-Eigenschaft · 503
Zeichnet schaltflächenähnliche Rahmen um jede Zelle und markiert die
Überschriften für die aktuelle Auswahl. Diese Einstellung sollte nur für die
GridLinesFixed-Eigenschaft verwendet werden.
Die GridColor-Eigenschaft wird ignoriert, wenn GridLines auf einem 3D-Format steht. Hervorgehobene
und eingelassene Gitterlinien werden immer mit den vom System festgelegten Farben für Schatten und
Hervorhebungen gezeichnet.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
Styles-Eigenschaft (Seite 170)
GridLinesFixed-Eigenschaft
Ermittelt oder legt den Typ der Gitterlinien zwischen den fixierten Zellen fest.
Syntax
[VB]
Public GridLinesFixed As GridStyleSettings
[C#]
public GridStyleSettings GridLinesFixed {get; set;}
[Delphi]
property GridLinesFixed: GridStyleSettings;
Bemerkungen
Die GridColorFixed- und GridLinesFixed-Eigenschaften legen das Format der Gitterlinien im fixierten
Bereich und GridColor und GridLines im scrollbaren Bereich der Tabelle fest.
Die möglichen Einstellungen der GridLinesFixed-Eigenschaft sind die Gleichen wie die der GridLines-
Eigenschaft. flexGridExcel sollte nur für die GridLinesFixed-Eigenschaft verwendet werden. Durch diese
Einstellung werden die fixierten Zeilen und Spalten entsprechend der aktuellen Auswahl hervorgehoben.
Damit kann der Nutzer besser erkennen, in welcher Zeile und Spalte sich die aktuelle Auswahl befindet.
Die GridColorFixed-Eigenschaft wird ignoriert, wenn GridLinesFixed auf einem 3D-Format steht.
Hervorgehobene und eingelassene Gitterlinien werden immer mit den vom System festgelegten Farben
für Schatten und Hervorhebungen gezeichnet.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
Styles-Eigenschaft (Seite 170)
GridLineWidth-Eigenschaft
Ermittelt oder legt die Breite der Gitterlinien in Pixeln fest.

504 · C1FlexGridClassic-Referenzverzeichnis
Syntax
[VB]
Public GridLineWidth As Integer
[C#]
public int GridLineWidth {get; set;}
[Delphi]
property GridLineWidth: Integer;
Bemerkungen
Die GridLineWidth-Eigenschaft legt die Dicke der Gitternetzlinien in Pixeln fest, wenn die
GridLineWidth- oder GridLinesFixed-Eigenschaft auf einem der flachen Formate (flexGridFlat,
flexGridFlatHorz, flexGridFlatVert) steht. Herausgehobene und eingelassene Gitternetzlinien haben feste
Breiten, die nicht verändert werden können.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
Styles-Eigenschaft (Seite 170)
KeyActionEnter-Eigenschaft (C1FlexGridClassic)
Legt die auszuführende Aktion fest, wenn der Nutzer die Enter-Taste drückt.
Syntax
[VB]
Public KeyActionEnter As KeyActionEnum
[C#]
public KeyActionEnum KeyActionEnter {get; set;}
[Delphi]
property KeyActionEnter: KeyActionEnum;
Eigenschaftswert
Einer der KeyActionEnum-Werte. Der Standardwert ist KeyActionEnum.MoveDown.
Mitgliedsname Beschreibung
None
Keine Handlung (das System verwaltet die Zelle). Zum Beispiel, die Tabulatortaste wird
normalerweise für das Durchblättern der Steuerungen auf einem Formular verwendet.
MoveDown Gehe zur nächsten Zeile, wenn die Taste gedrückt wird.
MoveAcross
MoveAcrossOut
Gehe zur nächsten Spalte, wenn die Taste gedrückt wird. Nach der letzten Spalte,
gehe zur nächsten Zeile und zurück zur ersten Spalte.
Gehe zur nächsten Spalte, wenn die Taste gedrückt wird. Gehe nach der letzten Spalte
zur nächsten Zeile und zurück zur ersten Spalte. Verschiebe nach der letzten Zeile und
Spalte den Fokus zur nächsten Steuerung auf dem Formular,.

Bemerkungen
KeyActionTab-Eigenschaft (C1FlexGridClassic) · 505
Standardmäßig verschiebt die Tabelle die Auswahl auf die nächste sichtbare Zeile, wenn der Nutzer die
Enter-Taste drückt. Wenn die Tabelle bearbeitbar ist, dann wird diese durch die Enter-Taste in den
Bearbeitungsmodus versetzt und, während sie in diesem Modus verweilt, verschiebt die Enter-Taste den
Cursor nach unten.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGridClassic-Klasse (Seite 450)
KeyActionTab-Eigenschaft (C1FlexGridClassic)
Legt die auszuführende Aktion fest, wenn der Nutzer die Tabulator-Taste drückt.
Syntax
[VB]
Public KeyActionTab As KeyActionEnum
[C#]
public KeyActionEnum KeyActionTab {get; set;}
[Delphi]
property KeyActionTab: KeyActionEnum;
Eigenschaftswert
Einer der KeyActionEnum-Werte. Der Standardwert ist KeyActionEnum.None.
Mitgliedsname Beschreibung
None
Keine Handlung (das System verwaltet die Zelle). Zum Beispiel, die Tabulatortaste
wird normalerweise für das Durchblättern der Steuerungen auf einem Formular
verwendet.
MoveDown Gehe zur nächsten Zeile, wenn die Taste gedrückt wird.
MoveAcross
MoveAcrossOut
Bemerkungen
Gehe zur nächsten Spalte, wenn die Taste gedrückt wird. Gehe nach der letzten
Spalte zur nächsten Zeile und zurück zur ersten Spalte.
Gehe zur nächsten Spalte, wenn die Taste gedrückt wird. Gehe nach der letzten
Spalte zur nächsten Zeile und zurück zur ersten Spalte. Verschiebe nach der letzten
Zeile und Spalte den Fokus zur nächsten Steuerung auf dem Formular.
Standardmäßig wird die Tabelle die Tabulator-Taste ignorieren. Sie wird durch das Formular
abgewickelt und verschiebt den Fokus auf die nächste Steuerung. Wenn Sie die KeyActionTab-
Eigenschaft auf einen von KeyActionEnum.None verschiedenen Wert setzen, dann wird die Tabelle die
Tabulator-Taste abfangen und diese für die Navigation durch die Zellen verwenden.
Beispiel
Der nachfolgende Quellcode ändert den Wert der KeyActionTab-Eigenschaft basierend auf der aktuellen
Zelle. Der Nutzer kann die Tabulator-Taste drücken, um durch die Zellen zu navigieren bis er am Ende

506 · C1FlexGridClassic-Referenzverzeichnis
der Tabelle angelangt ist. Wenn er diese erneut drückt, dann wird der Fokus auf die nächste Steuerung
verschoben.
• Visual Basic
• C#
Private Sub flex_Enter(sender As Object, e As System.EventArgs)
flex.Select(flex.Rows.Fixed, flex.Cols.Fixed)
End Sub 'flex_Enter
Private Sub flex_RowColChange(sender As Object, e As System.EventArgs)
Dim lastCell As Boolean
lastCell = flex.Col = flex.Cols.Count - 1 And _
flex.Row = flex.Rows.Count - 1
If lastCell Then
flex.KeyActionTab = KeyActionEnum.None
Else
flex.KeyActionTab = KeyActionEnum.MoveAcross
End If
End Sub 'flex_RowColChange
private void flex_Enter(object sender, System.EventArgs e)
{
flex.Select(flex.Rows.Fixed, flex.Cols.Fixed);
}
private void flex_RowColChange(object sender, System.EventArgs e)
{
bool lastCell = (flex.Col == flex.Cols.Count-1 &&
flex.Row == flex.Rows.Count-1);
flex.KeyActionTab = (lastCell)
? KeyActionEnum.None
: KeyActionEnum.MoveAcross;
}
• Delphi
procedure Class1.flex_Enter(sender: System.Object; e:
System.EventArgs);
begin
flex.Select(flex.Rows.Fixed, flex.Cols.Fixed);
end;
procedure flex_RowColChange(sender: System.Object; e:
System.EventArgs);
var
lastCell: Boolean;
begin
lastCell := (flex.Col = flex.Cols.Count – 1_ And
(flex.Row = flex.Rows.Count – 1);
if lastCell then
flex.KeyActionTab := KeyActionEnum.None
Else
flex.KeyActionTab := KeyActionEnum.MoveAcross;
end; // flex_RowColChange
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGridClassic-Klasse (Seite 450)

MergeCells-Eigenschaft
Ermittelt oder legt fest, ob Zellen mit gleichem Inhalt zu einer Zelle verbunden werden.
Syntax
[VB]
Public MergeCells As MergeSettings
[C#]
public MergeSettings MergeCells {get; set;}
[Delphi]
property MergeCells: MergeSettings;
Bemerkungen
Gültige Einstellungen für die MergeCells-Eigenschaft:
Mitgliedsname Beschreibung
flexMergeNever Zellen nicht verbinden.
flexMergeFree
MergeCells-Eigenschaft · 507
Angrenzende Zellen mit gleichem Inhalt verbinden, wenn diese sich in
Zeilen mit RowMerge=TRUE oder Spalten mit MergeCol=TRUE befinden.
flexMergeRestrictRows Zeilen verbinden, wenn die Zellen darüber auch verbunden sind.
flexMergeRestrictColumns Spalten verbinden, wenn die Zellen links davon auch verbunden sind.
flexMergeRestrictAll
flexMergeFixedOnly
Zellen verbinden, wenn die Zellen darüber und links davon auch
verbunden sind.
Nur fixierte Zellen verbinden. Diese Einstellung ist für komplexe
Überschriften sinnvoll, ohne dabei die Datenzellen selbst zu verbinden.
flexMergeSpill Langen Einträgen erlauben, in leere, angrenzende Zellen überzugehen.
flexMergeOutline
Einträgen in Zwischensummenzeilen erlauben, in leere, angrenzende
Zellen überzugehen. Diese Einstellung ist sinnvoll, wenn Sie nur
Knotennamen in den Gliederungsknoten anzeigen wollen und die Daten
in regulären Zeilen stehen.
Die MergeCells-Eigenschaft wird zusammen mit der set_MergeRow und set_MergeCol-Methode
verwendet und steuert, ob und wie angezeigte Zellen verbunden werden. Verbunde Zellen dienen dazu,
Daten auf eine klare und ansprechende Weise anzuzeigen, indem Gruppen mit gleichen Informationen
hervorgehoben werden. Somit sind Sie felxibel und können ähnliche Tabellen wie die, die Sie in HTML
oder mit Microsoft Word (beide unterstützen verbundene Zellen) verwenden, erstellen.
Um Tabellen mit verbundenen Zellen zu erstellen, müssen Sie die MergeCells-Eigenschaft auf einen von
flexMergeNever verschiedenen Wert, und die set_MergeRow- und set_MergeCol-Methoden für die
jeweiligen Zeilen und Spalten, die Sie verbinden wollen, auf TRUE setzen (außer wenn Sie den
flexMergeSpill-Modus verwenden). Nachdem diese Eigenschaften gesetzt wurden, wird die
Tabellensteuerung automatisch angrenzende Zellen mit gleichen Inhalten verbinden. Immer wenn sich
die Tabelleninhalte verändern, aktualisiert die Tabelle die Verbindungen.

508 · C1FlexGridClassic-Referenzverzeichnis
Die flexMergeSpill-Einstellung unterschiedet sich ein wenig von den anderen, indem Sie für diese die
Methoden set_MergeRow und set_MergeCol nicht setzen müssen und Zellen mit gleichen Einstellungen
nicht verbunden werden. Stattdessen gehen lange Einträge in angrenzende Zellen über, solange diese leer
sind. Dies ist oft für Gliederungen nützlich, bei denen eine schmale Spalte für die Gruppenüberschriften
verwendet werden soll, sodass diese in die rechts angrenzenden Zellen übergeht. Die nachfolgende
Grafik zeigt ein Beispiel, in dem die flexMergeSpill-Einstellung verwendet wurde. Beachten Sie wie einige
lange Texte in angrenzende Zellen übergehen, wenn diese leer sind, und andere abgeschnitten werden,
weil die angrenzende Zelle nicht leer ist:
Die flexMergeOutline-Einstellung ist ähnlich der flexMergeSpill, bis auf die Tatsache, dass Zellen in
Zwischensummenzeilen mit angrenzenden leeren Zellen verbunden werden. Dies ist nützlich, wenn Sie
nur einen Knotennamen in den Zwischensummenzeilen (Knoten) und Daten in regulären Zeilen
anzeigen wollen.
Der Unterschied zwischen den Free und Restricted-Einstellungen besteht darin, dass entweder Zellen mit
gleichem Inhalt immer verbunden werden (Free-Einstellung) oder nur dann, wenn die links oder oben
angrenzenden Zellen auch verbunden sind. Die nachstehenden Beispiele zeigen den Unterschied.
• Visual Basic
• C#
' regular spreadsheet view
fg.MergeCells = MergeSettings.flexMergeNever
fg.set_MergeCol(0, True)
fg.set_MergeCol(1, True)
fg.set_MergeCol(2, True)
fg.set_MergeCol(3, False)
// regular spreadsheet view
fg.MergeCells = MergeSettings.flexMergeNever;
fg.set_MergeCol(0, true);
fg.set_MergeCol(1, true);
fg.set_MergeCol(2, true);
fg.set_MergeCol(3, false);
• Delphi
begin
fg.MergeCells := MergeSettings.flexMergeNever;
fg.set_MergeCol(0, True);
fg.set_MergeCol(1, True);
fg.set_MergeCol(2, True);
fg.set_MergeCol(3, False);
end;

• Visual Basic
• C#
MergeCells-Eigenschaft · 509
' free merging: notice how the first region cell (East) merges
' across employees (Donna and John) to its left.
fg.MergeCells = MergeSettings.flexMergeFree
fg.set_MergeCol(0, True)
fg.set_MergeCol(1, True)
fg.set_MergeCol(2, True)
fg.set_MergeCol(3, False)
// free merging: notice how the first region cell (East) merges
// across employees (Donna and John) to its left.
fg.MergeCells = MergeSettings.flexMergeFree;
fg.set_MergeCol(0, true);
fg.set_MergeCol(1, true);
fg.set_MergeCol(2, true);
fg.set_MergeCol(3, false);
• Delphi
begin
// free merging: notice how the first region cell (East) merges
// across employees (Donna and John) to its left.
fg.MergeCells := MergeSettings.flexMergeFree;
fg.set_MergeCol(0, True);
fg.set_MergeCol(1, True);
fg.set_MergeCol(2, True);
fg.set_MergeCol(3, False);
end;
• Visual Basic
' restricted merging: notice how the first region cell (East)
' no longer merges across employees to its left.

510 · C1FlexGridClassic-Referenzverzeichnis
• C#
fg.MergeCells = MergeSettings.flexMergeRestrictAll
fg.set_MergeCol(0, True)
fg.set_MergeCol(1, True)
fg.set_MergeCol(2, True)
fg.set_MergeCol(3, False)
// restricted merging: notice how the first region cell (East)
// no longer merges across employees to its left.
fg.MergeCells = MergeSettings.flexMergeRestrictAll;
fg.set_MergeCol(0, true);
fg.set_MergeCol(1, true);
fg.set_MergeCol(2, true);
fg.set_MergeCol(3, false);
• Delphi
begin
// restricted merging: notice how the first region cell (East)
// no longer merges across employees to its left.
fg.MergeCells := MergeSettings.flexMergeRestrictAll;
fg.set_MergeCol(0, True);
fg.set_MergeCol(1, True);
fg.set_MergeCol(2, True);
fg.set_MergeCol(3, False);
end;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
NodeClosedPicture-Eigenschaft
Ermittelt oder legt das Bild für einen geschlossenen Gliederungsknoten fest.
Syntax
[VB]
Public-Eigenschaft NodeClosedPicture As System.Drawing.Image
[C#]
public System.Drawing.Image NodeClosedPicture {get; set;}

[Delphi]
property NodeClosedPicture: System.Drawing.Image;
Bemerkungen
NodeOpenPicture-Eigenschaft · 511
Wenn keine benutzerdefinierte Grafik bereitgestellt wird, dann wird ein geschlossener Knoten mit einem
Plus-Zeichen in einem Rechteck angezeigt.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
NodeOpenPicture-Eigenschaft
Ermittelt oder legt das Bild für einen offenen Gliederungsknoten fest.
Syntax
[VB]
Public-Eigenschaft NodeOpenPicture As System.Drawing.Image
[C#]
public System.Drawing.Image NodeOpenPicture {get; set;}
[Delphi]
property NodeOpenPicture: System.Drawing.Image;
Bemerkungen
Wenn keine benutzerdefinierte Grafik bereitgestellt wird, dann wird ein offener Knoten mit einem
Minus-Zeichen in einem Rechteck angezeigt.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
OutlineBar-Eigenschaft
Ermittelt oder legt den Typ der anzuzeigenden Gliederungsleiste fest.
Syntax
[VB]
Public-Eigenschaft OutlineBar As C1.Win.C1FlexGrid.Classic.OutlineBarSettings
[C#]
public OutlineBarSettings OutlineBar {get; set;}
[Delphi]
property OutlineBar: OutlineBarSettings;
Bemerkungen
Gültige Einstellungen für die OutlineBar-Eigenschaft:

512 · C1FlexGridClassic-Referenzverzeichnis
Mitgliedsname Beschreibung
flexOutlineBarComplete
flexOutlineBarCompleteLeaf
Der vollständige Gliederungsbaum und eine Schaltflächenzeile darüber
wird angezeigt. Schaltflächen werden nur angezeigt, wenn die
Gliederungsleiste in einer fixierten Spalte steht.
Ähnlich der flexOutlineBarComplete, aber leere Knoten werden ohne
Symbol angezeigt.
flexOutlineBarNone Die Gliederungsleiste wird nicht angezeigt
flexOutlineBarSimple
flexOutlineBarSimpleLeaf
Der vollständige Gliederungsbaum wird angezeigt, aber keine
Schaltflächenzeile.
Ähnlich der flexOutlineBarSimple, aber leere Knoten werden ohne
Symbol angezeigt.
flexOutlineBarSymbols Gliederungssymbole, aber keine Verknüpfungslinien werden angezeigt.
flexOutlineBarSymbolsLeaf
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
OutlineCol-Eigenschaft
Ähnlich der flexOutlineBarSymbols, aber leere Knoten werden ohne
Symbol angezeigt.
Ermittelt oder legt die für den Gliederungsbaum zu verwendende Spalte fest.
Syntax
[VB]
Public-Eigenschaft OutlineCol As Integer
[C#]
public int OutlineCol {get; set;}
[Delphi]
property OutlineCol: Integer;
Bemerkungen
Die OutlineCol-Eigenschaft steuert zusammen mit der OutlineBar-Eigenschaft das Format und das
Verhalten des Gliederungsbaums.
Standardmäßig steht die OutlineCol-Eigenschaft auf Null, so dass die Gliederungsleiste, wenn
vorhanden, in der ersten Spalte der Steuerung angezeigt wird. Sie können OutlineCol verwenden, um
den Gliederungsbaum in unterschiedlichen Spalten anzuzeigen. Wenn Sie den Gliederungsbaum auf eine
Spalte mit Daten setzen, dann werden die Einträge der Spalte so eingerückt, dass die Zellen den
Gliederungsbaum anzeigen können.
Nachdem Sie diese Eigenschaft eingestellt haben, sollten Sie die AutoSize-Methode anwenden, damit
sichergestellt ist, dass der Baum und die Daten in der OutlineCol-Spalte vollständig sichtbar sind.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)

Picture-Eigenschaft
Gibt ein Abbild der gesamten Steuerung zurück.
Syntax
[VB]
Public ReadOnly-Eigenschaft Picture As System.Drawing.Image
[C#]
public System.Drawing.Image Picture {get;}
[Delphi]
property Picture: System.Drawing.Image;
Bemerkungen
Picture-Eigenschaft · 513
Diese Eigenschaft gibt eine Grafik (Metadatei) zurück, die die gesamte Steuerung, inklusive der Zeilen
und Spalten zeigt, die auf dem Bildschirm nicht sichtbar sind. Wenn Sie zum Beispiel eine Steuerung mit
1000 Zeilen haben, dann beinhaltet die Grafik diese auch.
Diese Eigenschaft ruft zuerst die Basisklasse CreateImage-Methode auf. CreateImage besitzt Parameter,
mit denen Sie den Bereich festlegen können, der für die Grafik verwendet werden soll.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
PicturesOver-Eigenschaft
Syntax
[VB]
Public-Eigenschaft PicturesOver As Boolean
[C#]
public bool PicturesOver {get; set;}
[Delphi]
property PicturesOver: Boolean;
Bemerkungen
Der Standardwert dieser Eigenschaft ist FALSE.
Schauen Sie ferner unter
C1FlexGridClassic-Klassen
Redraw-Eigenschaft (C1FlexGridClassic)
Legt fest, ob die Tabelle ihre Inhalte zeichnen soll.

514 · C1FlexGridClassic-Referenzverzeichnis
Syntax
[VB]
Public-Eigenschaft Redraw As C1.Win.C1FlexGrid.Classic.RedrawSettings
[C#]
public RedrawSettings Redraw {get; set;}
[Delphi]
property Redraw: RedrawSettings;
Bemerkungen
Gültige Einstellungen für die Redraw-Eigenschaft:
Mitgliedsname Beschreibung
flexRDBuffered
flexRDDirect
Die Tabelle zeichnet ihren Inhalt in einem off-screen Puffer, und transferiert das
komplette Abbild auf den Bildschirm. Dieser Modus ist etwas langsamer als
flexRDDirect, aber er verhindert das Flackern des Bildschirms.
Die Tabelle zeichnet ihren Inhalt direkt auf den Bildschirm. Dies ist der schnellste
Modus für das Zeichnen der Tabelleninhalte, dafür kann gelegentlich aber ein
leichtes Flackern auftreten.
flexRDNone Die Tabelle zeichnet sich nicht selbst neu.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGridClassic-Klasse (Seite 450)
RowHeightMax-Eigenschaft
Ermittelt oder legt die maximale Zeilenhöhe in Twips fest.
Syntax
[VB]
Public RowHeightMax As Integer
[C#]
public int RowHeightMax {get; set;}
[Delphi]
property RowHeightMax: Integer;
Bemerkungen
Setzen Sie diese Eigenschaft auf einen von Null verschiedenen Wert, um die maximale Höhe von Zeilen
festzulegen. Dies ist oft nützlich, wenn Sie die AutoSize-Methode verwenden und manche Zeilen
dadurch zu hoch werden würden.
Siehe auch ColWidthMin-, ColWidthMax- und RowHeightMin-Eigenschaften.

Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
MaxSize-Eigenschaft (RowCollection) (Seite 307)
RowHeightMin-Eigenschaft
Ermittelt oder legt die minimale Zeilenhöhe in Twips fest.
Syntax
[VB]
Public RowHeightMin As Integer
[C#]
public int RowHeightMin {get; set;}
[Delphi]
property RowHeightMin: Integer;
Bemerkungen
RowHeightMin-Eigenschaft · 515
Setzen Sie diese Eigenschaft auf einen von Null verschiedenen Wert, um die Mindesthöhe von Zeilen
festzulegen. Dies ist oft nützlich, wenn Sie die AutoSize-Methode verwenden und manche Zeilen
dadurch zu flach werden würden, oder wenn Sie kleine Schriftgrößen verwenden, aber die Zeilen nicht
flacher werden sollen.
Siehe auch ColWidthMin-, ColWidthMax- und RowHeightMax-Eigenschaften.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
MinSize-Eigenschaft (RowCollection) (Seite 308)
Rows-Eigenschaft (C1FlexGridClassic)
Gibt alle Zeilen einer Tabelle zurück.
Syntax
[VB]
Public Rows As RowCollection
[C#]
public RowCollection Rows {get;}
[Delphi]
property Rows: RowCollection;
Bemerkungen
Mit der Rows-Eigenschaft können Sie eine Liste mit allen derzeit vorhandenen Zeilen in einer Tabelle
abfragen. Mit dieser Referenz können Sie Zeilen hinzufügen, entfernen, verschieben und zählen. Für

516 · C1FlexGridClassic-Referenzverzeichnis
weitere Informationen über die Funktionen dieser Sammlung, schauen Sie in den Referenzthemen der
RowCollection-Klasse nach.
Diese Eigenschaft kann nur gelesen werden. Die Tabelle erstellt und verwaltet diese Liste/Sammlung.
Upgradenotiz: In der VSFlexGrid-ActiveX-Steuerung zeigen die Rows- und FixedRows-Eigenschaften
die Anzahl der Zeilen und der fixierten Zeilen in einer Tabelle. Verwenden Sie in C1FlexGrid
Rows.Count und Rows.Fixed hierfür.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGridClassic-Klasse (Seite 450)
SelectedRows-Eigenschaft
Gibt die Anzahl der ausgewählten Zeilen zurück, wenn der SelectionMode auf flexSelectionListBox steht.
Syntax
[VB]
Public SelectedRows As Integer
[C#]
public int SelectedRows {get; set;}
[Delphi]
property SelectedRows: Integer;
Bemerkungen
Diese Eigenschaft ist besonders nützlich, wenn die SelectionMode-Eigenschaft auf flexSelectionListBox (3)
steht, so dass der Nutzer mehrere nichtangrenzende Zeilen auswählen kann.
Der nachfolgende Quellcode gibt die Anzahl der ausgewählten Zeilen im Debugfenster aus, wenn sich
die Auswahl ändert:
• Visual Basic
• C#
Private Sub Form1_Load(ByVal sender As System.Object,
ByVal e As System.EventArgs)
fg.SelectionMode = SelModeSettings.flexSelectionListBox
End Sub
Private Sub fg_SelChange(ByVal sender As Object, ByVal e As
System.EventArgs)
Debug.WriteLine (fg.SelectedRows)
End Sub
private void Form1_Load( System.object sender, System.EventArgs e) {
fg.SelectionMode = SelModeSettings.flexSelectionListBox;
}
private void fg_SelChange( object sender, System.EventArgs e) {
Debug.WriteLine (fg.SelectedRows);
}

• Delphi
SelectionMode-Eigenschaft (C1FlexGridClassic) · 517
procedure Form1_Load(sender: System.Object;
e: System.EventArgs);
begin
fg.SelectionMode := SelModeSettings.flexSelectionListBox;
end;
procedure fg_SelChange(sender: System.Object; e: System.EventArgs);
begin
Debug.WriteLine(fg.SelectedRows);
end;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
Selection-Eigenschaft (Seite 166)
SelectionMode-Eigenschaft (C1FlexGridClassic)
Legt das Auswahlverhalten der Tabelle fest.
Syntax
[VB]
Public SelectionMode As SelModeSettings
[C#]
public SelModeSettings SelectionMode {get; set;}
[Delphi]
property SelectionMode: SelModeSettings;
Bemerkungen
Gültige Einstellungen für die SelectionMode-Eigenschaft:
Mitgliedsname Beschreibung
flexSelectionByColumn
flexSelectionByRow
Zwingt die Auswahl, sich auf die gesamte Spalte auszuweiten. Dies ist für
Diagrammbereiche oder zu sortierende Felder nützlich.
Zwingt die Auswahl, sich auf die gesamte Zeile auszuweiten. Dies ist für die
Implementierung von datensatzbasierender Anzeige nützlich.
flexSelectionFree Auswahlen können wie üblich getroffen werden.
flexSelectionListBox
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGridClassic-Klasse (Seite 450)
Ähnlich wie flexSelectionByRow, aber es können auch unterbrochene
Auswahlen getroffen werden. Strg-Taste halten und mit der Maus klicken
schaltet die Auswahl für eine einzelne Zeile um. Die Maus über eine Gruppe
von Zeilen zu ziehen schaltet deren Auswahlzustand um.

518 · C1FlexGridClassic-Referenzverzeichnis
SheetBorder-Eigenschaft
Ermittelt oder legt die Farbe des Rahmens um das Arbeitsblatt fest.
Syntax
[VB]
Public SheetBorder As Color
[C#]
public Color SheetBorder {get; set;}
[Delphi]
property SheetBorder: Color;
Bemerkungen
Diese Eigenschaft ist nützlich, wenn Sie die Tabelle wie eine Seite ohne Rahmen um die Zellen anzeigen
wollen. Setzen Sie hierfür die SheetBorder-Eigenschaft auf die Tabellenhintergrundfarbe (BackColor-
Eigenschaft).
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
Styles-Eigenschaft (Seite 170)
Sort-Eigenschaft (C1FlexGridClassic)
Legt die Sortierungsrichtung fest.
Syntax
[VB]
Public Sort As SortSettings
[C#]
public SortSettings Sort {get; set;}
[Delphi]
property Sort: SortSettings;
Bemerkungen
Gültige Einstellungen für die Sort-Eigenschaft:
Mitgliedsname Beschreibung
flexSortNone
Ignoriert die Spalte, wenn sortiert wird. Diese Einstellung ist
nützlich, wenn Sie diese der Cols-Eigenschaft einer Spalte
zuordnen und dann Sort auf flexSortUseColSort stellen.
flexSortGenericAscending Sortiert Zeichenketten und Zahlen aufsteigend.
flexSortGenericDescending Sortiert Zeichenketten und Zahlen absteigend.

Mitgliedsname Beschreibung
flexSortNumericAscending Sortiert Zahlen aufsteigend.
flexSortNumericDescending Sortiert Zahlen absteigend.
flexSortStringNoCaseAscending
flexSortStringNoCaseDescending
Styles-Eigenschaft (C1FlexGridClassic) · 519
Sortiert Zeichenketten ohne Rücksicht auf Groß- und
Kleinschreibung aufsteigend.
Sortiert Zeichenketten ohne Rücksicht auf Groß- und
Kleinschreibung absteigend.
flexSortStringAscending Sortiert Zeichenketten aufsteigend.
flexSortStringDescending Sortiert Zeichenketten absteigend.
flexSortCustom
flexSortUseColSort
Startet ein Compare-Ereignis und verwendet den Rückgabewert
um eine Spalte zu sortieren.
Mit dieser Einstellung können Sie verschiedene
Sortierungsrichtungen für einzelne Spalten mit der ColSort-
Eigenschaft einstellen.
Mit der Sort-Eigenschaft können Sie einen Bereich oder Zeilen in auf- oder absteigender Richtung,
basierend auf den Inhalten in einer oder mehrerer Spalten, sortieren. Die Sort-Eigenschaft berücksichtigt
auch Gliederungsstrukturen, so dass sie nur Datenzeilen sortiert und Knoten nicht verändert.
Der zu sortierende Zeilenbereich wird durch die Einstellungen in den Row- und RowSel-Eigenschaften
festgelegt. Wenn Row und RowSel gleich sind, dann sortiert die Steuerung alle nicht fixierten Zeilen.
Der zuverwendende Sortierungsschlüssel wird von den Col- und ColSel-Eigenschaften immer von links
nach rechts festgelegt. Zum Beispiel, wenn Col = 3 und ColSel = 1, dann wird nach den Inhalten in Spalte
eins, dann zwei und dann drei sortiert.
Der von der FlexGrid-Steuerung verwendete Sortieralgorithmus ist „stable“: Das bedeutet, dass das
Sortieren die relative Reihenfolge der Daten beibehält, wenn der Sortierschlüssel der gleiche ist. Zum
Beispiel, wenn Sie zunächst ein Dateienliste nach Namen und anschließend nach Dateienerweiterung
sortieren, dann werden die Dateinamen innerhalb der Dateienerweiterungsgruppe immer noch sortiert
sein.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
Styles-Eigenschaft (C1FlexGridClassic)
Gibt alle Formatvorlagen einer Tabelle zurück.
Syntax
[VB]
Public Styles As CellStyleCollection
[C#]
public CellStyleCollection Styles {get;}

520 · C1FlexGridClassic-Referenzverzeichnis
[Delphi]
property Styles: CellStyleCollection;
Bemerkungen
Mit der Styles-Eigenschaft können Sie einen Verweis auf eine Liste aller derzeit in der Tabelle definierten
Formate abfragen. Mit diesem Verweis können Sie Formatvorlagen hinzufügen, entfernen und zählen.
Für weitere Informationen über die Aufgaben, die mit dieser Liste ausgeführt werden können, schauen
Sie unter CellStyleCollection-Klassenreferenzthemen für Informationen über Zellformatierungen, unter
CellStyle-Referenzthemen nach.
Diese Eigenschaft kann nur gelesen werden. Die Tabelle erstellt und verwaltet die Liste für Sie.
Upgradenotiz: Die VSFlexGrid ActiveX-Steuerung hatte viele Eigenschaften, welche die Anzeige der
Tabelle beeinflusst haben (z.B. BackColor, BackColorAlternate, BackColorBkg, BackColorFixed,
BackColorFrozen, BackColorSel, usw.). Die C1FlexGrid-Steuerung ersetzt all diese Eigenschaften mit
einer CellStyleCollection der CellStyle-Objekte. Damit ist das Objektmodel einfacher, konsistenter und
stärker. Sie können die bestehenden Formatvorlagen verändern oder Ihre eigenen definieren und diese
den Zeilen, Spalten oder willkürlichen Zellbereichen zuordnen.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGridClassic-Klasse (Seite 450)
TabBehavior-Eigenschaft
Ermittelt oder legt fest, ob die Tabulator-Taste den Fokus zwischen den Steuerungen (VB-Standard) oder
zwischen Tabellenzellen verschiebt.
Syntax
[VB]
Public TabBehavior As TabBehaviorSettings
[C#]
public TabBehaviorSettings TabBehavior {get; set;}
[Delphi]
property TabBehavior: TabBehaviorSettings;
Bemerkungen
Die möglichen Einstellungen der TabBehavior-Eigenschaft werden nachfolgend beschrieben:
Mitgliedsname Beschreibung
flexTabControls
flexTabCells
Die Tabulator-Taste wird verwendet, um zur nächsten oder
vorhergehenden Steuerung im Formular zu gehen.
Die Tabulator-Taste wird verwendet, um zur nächsten oder
vorhergehenden Zelle auf der Steuerung zu gehen.
Das nachfolgende Beispiel stellt die Tabulator-Taste so ein, dass zur nächsten Steuerung gegangen wird,
wenn man sich in der letzten Zelle befindet:

• Visual Basic
• C#
Text-Eigenschaft · 521
Private Sub fg_Focus(ByVal sender As Object, ByVal e As System.Event
Args)
fg.Select (fg.FixedRows, fg.FixedCols)
End Sub
Private Sub fg_EnterCell(ByVal sender As Object, ByVal e As
System.EventArgs)
If fg.Col = fg.Cols - 1 And fg.Row = fg.Rows - 1 Then
fg.TabBehavior = TabBehaviorSettings.flexTabControls
Else
fg.TabBehavior = TabBehaviorSettings.flexTabCells
End If
End Sub
private void fg_Focus( object sender, System.event e Args) {
fg.Select (fg.FixedRows, fg.FixedCols);
}
private void fg_EnterCell( object sender, System.EventArgs e) {
if ( fg.Col = fg.Cols - 1 && fg.Row = fg.Rows - 1 ) {
fg.TabBehavior = TabBehaviorSettings.flexTabControls;
} else {
fg.TabBehavior = TabBehaviorSettings.flexTabCells;
}
}
• Delphi
procedure fg_Focus(sender: System.Object; e: System.Event Args);
begin
fg.Select(fg.FixedRows, fg.FixedCols);
end;
procedure fg_EnterCell(sender: System.Object; e: System.EventArgs);
begin
If (fg.Col = fg.Cols.Count – 1) And (fg.Row = fg.Rows.Count – 1) Then
fg.TabBehavior := TabBehaviorSettings.flexTabControls
Else
fg.TabBehavior := TabBehaviorSettings.flexTabCells;
end;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
KeyActionEnter-Eigenschaft (Seite 149)
KeyActionTab-Eigenschaft (Seite 150)
Text-Eigenschaft
Ermittelt oder legt den Inhalt der ausgewählten Zelle oder des Bereichs fest.
Syntax
[VB]
Public Text As String

522 · C1FlexGridClassic-Referenzverzeichnis
[C#]
public string Text {get; set;}
[Delphi]
property Text: string;
Bemerkungen
Die Text-Eigenschaft ruft den Inhalt der aktuellen Zelle ab, die durch die Row- und Col-Eigenschaften
festgelegt ist. Wenn der Text-Eigenschaft eine Zeichenkette zugeordnet wird, dann wird diese entweder
auf die aktuelle Zelle angewendet, oder über die aktuelle Auswahl kopiert, je nach Einstellung der
FillStyle-Eigenschaft.
Der nachfolgende Code setzt den Inhalt der Zelle in der vierten Spalte und vierten Zeile auf „Apple“:
• Visual Basic
• C#
fg.Select 3, 3
fg.Text = "Apple"
fg.Select 3, 3;
fg.Text = "Apple";
• Delphi
fg.Select(3, 3);
fg.Text := 'Apple';
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
GetData-Methode (Seite 190)
SetData-Methode (Seite 207)
TextStyle-Eigenschaft
Ermittelt oder legt den 3D-Effekt für den Text in nicht fixierten Zellen fest.
Syntax
[VB]
Public TextStyle As TextStyleSettings
[C#]
public TextStyleSettings TextStyle {get; set;}
[Delphi]
property TextStyle: TextStyleSettings;
Bemerkungen
Gültige Einstellungen für die TextStyle-Eigenschaft:

Mitgliedsname Beschreibung
flexTextFlat Zeichnet Text normal.
flexTextRaised Zeichnet Text mit einem stark gehobenen 3D-Effekt.
flexTextInset Zeichnet Text mit einem stark eingelassenen 3D-Effekt.
flexTextRaisedLight Zeichnet Text mit einem schwach gehobenen 3D-Effekt.
TextStyleFixed-Eigenschaft · 523
flexTextInsetLight Zeichnet Text mit einem schwach eingelassenen 3D-Effekt.
Die Konstanten flexTextRaised und flexTextInset passen gut zu großen und fetten Schriftarten und
flexTextRaisedLight und flexTextInsetLight eher zu kleineren, normalen Schriftarten.
Das nachfolgende Beispiel zeigt Text mit einem eingelassenen 3D-Effekt in nicht fixierten Zellen an:
• Visual Basic
• C#
fg.TextStyle = TextStyleSettings.flexTextInset
fg.TextStyle = TextStyleSettings.flexTextInset;
• Delphi
fg.TextStyle := TextStyleSettings.flexTextInset;
Schauen Sie in der CellTextStyle-Eigenschaft für eine Aufzählungsliste nach.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
Styles-Eigenschaft (Seite 170)
TextStyleFixed-Eigenschaft
Ermittelt oder legt den 3D-Effekt für den Text in fixierten Zellen fest.
Syntax
[VB]
Public TextStyleFixed As TextStyleSettings
[C#]
public TextStyleSettings TextStyleFixed {get; set;}
[Delphi]
property TextStyleFixed: TextStyleSettings;
Bemerkungen
Gültige Einstellungen für die TextStyleFixed-Eigenschaft:
Mitgliedsname Beschreibung
flexTextFlat Zeichnet Text normal.

524 · C1FlexGridClassic-Referenzverzeichnis
Mitgliedsname Beschreibung
flexTextRaised Zeichnet Text mit einem stark gehobenen 3D-Effekt.
flexTextInset Zeichnet Text mit einem stark eingelassenen 3D-Effekt.
flexTextRaisedLight Zeichnet Text mit einem schwach gehobenen 3D-Effekt.
flexTextInsetLight Zeichnet Text mit einem schwach eingelassenen 3D-Effekt.
Das nachfolgende Beispiel zeigt Text mit einem gehobenen 3D-Effekt in fixierten Zellen an:
• Visual Basic
• C#
fg.TextStyleFixed = TextStyleSettings.flexTextRaised
fg.TextStyleFixed = TextStyleSettings.flexTextRaised;
• Delphi
fg.TextStyleFixed := TextStyleSettings.flexTextRaised;
Schauen Sie in der CellTextStyle-Eigenschaft für eine Aufzählungsliste nach.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
Styles-Eigenschaft (Seite 170)
TreeColor-Eigenschaft
Ermittelt oder legt die Farbe für den Gliederungsbaum fest.
Syntax
[VB]
Public-Eigenschaft TreeColor As System.Drawing.Color
[C#]
public System.Drawing.Color TreeColor {get; set;}
[Delphi]
property TreeColor: System.Drawing.Color;
Bemerkungen
Der Gliederungsbaum wird nur gezeichnet, wenn die OutlineBar-Eigenschaft auf einem von Null
verschiedenen Wert steht und die Steuerung Zwischensummenzeilen enthält. Nutzer können die
Gliederung erweitern und zusammenklappen.
Schauen Sie unter der Outline-Methode für Einzelheiten über Gliederungen und ein Beispiel nach.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)

Value-Eigenschaft
Gibt den numerischen Wert der aktuellen Zelle zurück.
Syntax
[VB]
Public Value As Integer
[C#]
public int Value {get; set;}
[Delphi]
Eigenschaftswert: Integer;
Bemerkungen
Value-Eigenschaft · 525
Diese Eigenschaft ist ähnlich der Visual Basic-Funktion Val, nur dass sie lokal angepasste
Tausendertrennzeichen, Währungszeichen und eingeklammerte negative Werte erkennt. Zum Beispiel,
wenn die aktuelle Zelle die Zeichenkette „$(1,234.56)“ enthält, dann gibt die Value-Eigenschaft den Wert
-1234.56 zurück.
Der nachfolgende Quellcode gibt den Wert der aktuellen Zelle im Debugfenster aus:
• Visual Basic
• C#
Private Sub Button1_Click(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles Button1.Click
Debug. WriteLine (fg.Value)
End Sub
private void Button1_Click( System.object sender, System.EventArgs e)
Button1.Click {
Debug. WriteLine (fg.value);
}
• Delphi
procedure Button1_Click(sender: System.Object;
e: System.EventArgs);
begin
Debug. WriteLine(fg.Value);
end;
Diese Eigenschaft ist kein Ausdrucksbewerter. Wenn zum Beispiel die aktuelle Zelle die Zeichenkette
„2+2“ enthält, dann gibt die Value-Eigenschaft 2 anstatt 4 zurück. Die Visual Basic-Anweisung Val("2+2")
gibt auch 2 zurück.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
GetData-Methode (Seite 190)
SetData-Methode (Seite 207)

526 · C1FlexGridClassic-Referenzverzeichnis
WallPaper-Eigenschaft
Ermittelt oder legt eine Hintergrundgrafik für den scrollbaren Bereich der Tabelle fest.
Syntax
[VB]
Public-Eigenschaft WallPaper As System.Drawing.Image
[C#]
public System.Drawing.Image WallPaper {get; set;}
[Delphi]
property WallPaper: System.Drawing.Image;
Bemerkungen
Diese Eigenschaft ist gleich der BackgroundImage-Eigenschaft, die aus der Control-Basisklasse erbt.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
WordWrap-Eigenschaft (C1FlexGridClassic)
Legt fest, ob lange Zeichenketten in der Zelle umgebrochen werden.
Syntax
[VB]
Public-Eigenschaft WordWrap As Boolean
[C#]
public bool WordWrap {get; set;}
[Delphi]
property WordWrap: Boolean;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
C1FlexGridClassic-Methoden
AutoSize-Methode
Passt die Breite von Spalten und die Höhe von Zeilen an den Zellinhalt an.
Syntax
[VB]
Public Sub AutoSize(col As Integer)
Public Sub AutoSize(col1 As Integer, col2 As Integer)

Public Sub AutoSize(col1 As Integer, col2 As Integer, equal As Boolean, extra As Integer)
[C#]
public void AutoSize ( int col )
public void AutoSize ( int col1 , int col2 )
public void AutoSize ( int col1 , int col2 , Boolean equal , int extra )
[Delphi]
procedure AutoSize(col: Integer);
procedure AutoSize(col1: Integer; col2: Integer);
procedure AutoSize(col1: Integer; col2: Integer; equal: Boolean; extra: Integer);
Parameter Beschreibung
Col1, Col2
equal
ExtraSpace
Bemerkungen
Clear-Methode · 527
Der Index der ersten und letzten Spalte, so dass deren Breiten an den breitesten
Eintrag für jede Spalte angepasst wird. Der gültige Bereich für diese Parameter liegt
zwischen 0 und Cols-1. Col2 ist optional und wenn nicht gesetzt, dann wird nur die
Breite von Col1 angepasst.
Wenn TRUE, dann werden alle Spalten zwischen Col1 und Col2 auf die gleiche Breite
gesetzt. Wenn FALSE, dann wird die Breite jeder Spalte einzeln gesetzt. Dieser
Parameter ist optional und die Standardeinstellung ist FALSE.
Mit diesem Parameter können Sie den zusätzlichen Platz in Twips festlegen, der zu der
minimalen Breite der Spalte hinzugefügt werden soll. Dies ist oft nützlich, wenn Sie
zusätzlichen Platz für Grafiken oder Ränder innerhalb von Zellen lassen wollen. Dieser
Parameter ist optional und die Standardeinstellung ist Null.
Die AutoSize-Methode kann auch für Zeilenhöhen verwendet werden. Dies ist nützlich, wenn Text in
einer Zelle umgebrochen wird (Siehe WordWrap-Eigenschaft) oder wenn Zellen verschiedene
Schriftgrößen haben (Siehe Cell-Eigenschaft).
Die AutoSizeMode-Eigenschaft legt fest, ob AutoSize die Größe von Zeilen oder Spalten anpasst.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
AutoSizeCol-Methode (Seite 176)
AutoSizeRow-Methode (Seite 178)
Clear-Methode
Löscht den Inhalt einer Steuerung. Optionale Parameter legen fest, was wo gelöscht werden soll.

528 · C1FlexGridClassic-Referenzverzeichnis
Syntax
[VB]
Public Sub Clear()
Public Sub Clear(where As ClearWhereSettings)
Public Sub Clear(where As ClearWhereSettings, what As ClearWhatSettings)
[C#]
public void Clear ( )
public void Clear (ClearWhereSettings where )
public void Clear (ClearWhereSettings where , ClearWhatSettings what )
[Delphi]
procedure Clear;
procedure Clear(where: ClearWhereSettings);
procedure Clear(where: ClearWhereSettings; what: ClearWhatSettings);
Parameter Beschreibung
what ClearWhatSettings-Konstante beschreibt, was entfernt wird (siehe unten).
where ClearWhereSettings-Konstante beschreibt, wo etwas entfernt wird (siehe unten).
Bemerkungen
Die möglichen Einstellungen der ClearWhatSettings-Konstanten werden nachfolgend beschrieben:
Mitgliedsname Beschreibung
flexClearEverything Alles wird aus dem Bereich entfernt.
flexCleartext Nur Text wird aus dem Bereich entfernt.
flexClearFormatting Nur Formatierung wird aus dem Bereich entfernt.
flexClearData Nur Daten im Datenbereich werden aus dem Bereich entfernt.
Die möglichen Einstellungen der ClearWhereSettings-Konstanten werden nachfolgend beschrieben:
Mitgliedsname Beschreibung
flexClearEverywhere Entfernt von gesamter Tabelle.
flexClearScrollable Entfernt nur vom scrollbaren Bereich der Tabelle.
flexClearSelection Entfernt vom ausgewählten Bereich.

ComboItem-Methode · 529
Die Clear-Methode verändert nicht die Anzahl der Zeilen und Spalten in einer Tabelle und kann auch
nicht für das Löschen von Daten in, an Datenquellen gebundene, Tabellen verwendet werden.
Sie können mit der Cell-Eigenschaft Text oder benutzerdefinierte Formatierung in einem willkürlichen
Bereich entfernen. Zum Beispiel, der nachfolgende Quellcode entfernt jeden Text und benutzerdefinierte
Formatierung in einem Bereich:
• Visual Basic
• C#
Dim r1&, c1&, r2&, c2&
fg.set_Cell(CellPropertySettings.flexcpText, r1, C1, r2, c2, "")
fg.set_Cell(CellPropertySettings.flexcpCustomFormat, r1, C1, r2, c2,
False)
r1&, c1&, r2&, c2&;
fg.set_Cell(CellPropertySettings.flexcpText, r1, C1, r2, c2, "");
fg.set_Cell(CellPropertySettings.flexcpCustomFormat, r1, C1, r2, c2,
false);
• Delphi
var
r1, c1, r2, c2: Integer;
begin
fg.set_Cell(CellPropertySettings.flexcpText, r1, C1, r2, c2, '');
fg.set_Cell(CellPropertySettings.flexcpCustomFormat, r1, C1, r2, c2,
False);
end;
Dieses Beispiel entfernt Text aus den ausgewählten Zellen, wobei Grafiken und Zelldaten bestehen
bleiben:
• Visual Basic
• C#
fg.Clear(ClearWhereSettings.flexClearSelection,
ClearWhatSettings.flexClearText)
fg.Clear(ClearWhereSettings.flexClearSelection,
ClearWhatSettings.flexClearText);
• Delphi
fg.Clear(ClearWhereSettings.flexClearSelection,
ClearWhatSettings.flexClearText);
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
Clear-Methode (C1FlexGrid) (Seite 179)
ComboItem-Methode
Gibt die mit einem Element verknüpfte Zeichenkette aus der Auswahlliste des Editors zurück.
Syntax
[VB]
Public Function ComboItem(ByVal index As Integer) As String

530 · C1FlexGridClassic-Referenzverzeichnis
[C#]
public String ComboItem (Integer Index)
[Delphi]
function ComboItem(index: Integer): String;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
EditCell-Methode
Aktiviert den Bearbeitungsmodus.
Syntax
[VB]
Public Sub EditCell()
[C#]
public void EditCell ( )
[Delphi]
procedure EditCell;
Bemerkungen
Wenn die Editable-Eigenschaft auf einem von Null verschiedenen Wert steht, dann geht die Steuerung
automatisch in den Bearbeitungsmodus, wenn der Nutzer die F2-, die Leer- oder jede beliebige
Zeichentaste drückt. Sie können die EditCell-Methode verwenden, um die Steuerung in den
Bearbeitungsmodus zu zwingen.
Beachten Sie, dass EditCell die Steuerung in den Bearbeitungsmodus zwingt, auch wenn die Editable-
Eigenschaft auf FALSE steht. Sie können sogar die Bearbeitung von fixierten Zellen erlauben.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
FindRow-Methode (C1FlexGridClassic)
Sucht eine Zeile mit einer bestimmten Zeichenkette oder Objekt.
Syntax
[VB]
Public Function FindRow(objFind As Object, rowStart As Integer, col As Integer, wrap As Boolean) As
Integer
Public Function FindRow(strFind As String, rowStart As Integer, col As Integer, caseSensitive As
Boolean, fullMatch As Boolean, wrap As Boolean) As Integer

[C#]
public Integer FindRow (Object objFind , int rowStart , int col , Boolean wrap )
get_Cell-Methode · 531
public Integer FindRow (String strFind , int rowStart , int col , Boolean caseSensitive , Boolean fullMatch ,
Boolean wrap )
[Delphi]
function FindRow(objFind: Object; rowStart: Integer; col: Integer; wrap: Boolean): Integer;
function FindRow(strFind: string; rowStart: Integer; col: Integer; caseSensitive: Boolean; fullMatch:
Boolean; wrap: Boolean): Integer;
Parameter Beschreibung
strFind Zeichenkette, nach der gesucht wird.
objFind Objekt, nach dem gesucht wird.
rowStart Index der Zeile, in der die Suche beginnen soll.
col Spalte, welche die gesuchten Daten enthält.
caseSensitive Ob die Suche Groß- und Kleinschreibung berücksichtigt.
fullMatch
wrap
Rückgabewert
Ob die Suchwörter genau gefunden werden müssen. Wenn dieser Parameter auf
FALSE steht, dann ergibt z.B. die Suche nach „John“ u.a. auch „Johnson".
Ob die Suche am Ende der Tabelle anhalten, oder in der ersten, scrollbaren Zeile
fortfahren soll.
Den Index der Zeile mit den gesuchten Daten oder –1, wenn die Daten nicht gefunden wurden.
Bemerkungen
Verwenden Sie die AutoSearch-Eigenschaft, um nach Daten zu suchen, während der Nutzer noch tippt.
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGridClassic-Klasse (Seite 450)
get_Cell-Methode
Ermittelt die cell-Eigenschaften für einen willkürlichen Bereich.
Syntax
[VB]
Public Function get_Cell(ByVal setting As C1.Win.C1FlexGrid.Classic.CellPropertySettings, ByVal row
As Integer, ByVal col As Integer) As Object
Public Function get_Cell(ByVal setting As C1.Win.C1FlexGrid.Classic.CellPropertySettings, ByVal row1
As Integer, ByVal col1 As Integer, ByVal row2 As Integer, ByVal col2 As Integer) As Object

532 · C1FlexGridClassic-Referenzverzeichnis
[C#]
public System.Object get_Cell ( C1.Win.C1FlexGrid.Classic.CellPropertySettings setting , System.Int32
row , System.Int32 col )
public System.Object get_Cell ( C1.Win.C1FlexGrid.Classic.CellPropertySettings setting , System.Int32
row1 , System.Int32 col1 , System.Int32 row2 , System.Int32 col2 )
[Delphi]
function get_Cell(setting: C1.Win.C1FlexGrid.Classic.CellPropertySettings; row: Integer; col: Integer):
Object;
function get_Cell(setting: C1.Win.C1FlexGrid.Classic.CellPropertySettings; row1: Integer; col1: Integer;
row2: Integer; col2: Integer): Object;
Bemerkungen
Mit der get_Cell-Methode können Sie die cell-Eigenschaften von einzelnen Zellen oder Zellbereichen
direkt auslesen oder festlegen, ohne diese auszuwählen.
Die Parameter für die get_Cell-Methode werden nachfolgend beschrieben:
Setting As CellPropertySettings
Dieser Parameter legt fest, welche Eigenschaft gelesen oder gesetzt wird. Die verfügbaren Einstellungen
sind nachfolgend aufgelistet.
Row1, Col1, Row2, and Col2 As Integer (optional)
Wenn die cell-Eigenschaften gelesen werden, dann wird nur die Zelle (Row1, Col1) verwendet. Wenn sie
gesetzt werden, dann ist der gesamte Bereich betroffen. Der Standardwert für Row1 und Col1 ist die
aktuelle Zeile und die aktuelle Spalte. Wenn diese nicht zur Verfügung gestellt werden, dann wird die
aktuelle Zelle verwendet. Der Standardwert für Row2 und Col2 ist Row1 und Col1. Wenn diese nicht zur
Verfügung gestellt werden, dann wird eine einzelne Zelle verwendet.
Die Gültigen Einstellungen für den setting-Parameter sind:
Mitgliedsname Beschreibung
flexChecked Die Zelle hat ein Kontrollkästchen mit einem Häkchen drin.
flexNoCheckbox Die Zelle hat kein Kontrollkästchen.
flexTSChecked Die Zelle hat ein drei-Zustands-Kontrollkästchen mit einem Häkchen drin.
flexTSGrayed Die Zelle hat ein drei-Zustands-Kontrollkästchen im grauen Zustand.
flexTSUnchecked Die Zelle hat ein leeres drei-Zustands-Kontrollkästchen.
flexUnchecked Die Zelle hat ein leeres Kontrollkästchen.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
get_ColAlignment-Methode
Ermittelt die Ausrichtung einer gegebenen Spalte.

Syntax
[VB]
Public Function get_ColAlignment(ByVal col As Integer) As
C1.Win.C1FlexGrid.Classic.AlignmentSettings
[C#]
get_ColComboList-Methode · 533
public C1.Win.C1FlexGrid.Classic.AlignmentSettings get_ColAlignment ( System.Int32 col )
[Delphi]
function get_ColAlignment(col: Integer): C1.Win.C1FlexGrid.Classic.AlignmentSettings;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
get_ColComboList-Methode
Ermittelt die für ein Auswahlfeld zu verwendende Liste von einer bestimmten Spalte.
Syntax
[VB]
Public Function get_ColComboList(ByVal col As Integer) As String
[C#]
public System.String get_ColComboList ( System.Int32 col )
[Delphi]
function get_ColComboList(col: Integer): String;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
get_ColData-Methode
Ermittelt ein benutzerdefiniertes, mit einer Spalte verknüpftes Variant.
Syntax
[VB]
Public Function get_ColData(ByVal col As Integer) As Object
[C#]
public System.Object get_ColData ( System.Int32 col )
[Delphi]
function get_ColData(col: Integer): Object;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)

534 · C1FlexGridClassic-Referenzverzeichnis
get_ColDataType-Methode
Ermittelt den Datentyp einer Spalte.
Syntax
[VB]
Public Function get_ColDataType(ByVal col As Integer) As System.Type
[C#]
public System.Type get_ColDataType ( System.Int32 col )
[Delphi]
function get_ColDataType(col: Integer): System.Type
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
get_ColEditMask-Methode
Ermittelt die Eingabemaske, die für die Bearbeitung der Zellen in einer bestimmten Spalte verwendet
wird.
Syntax
[VB]
Public Function get_ColEditMask(ByVal col As Integer) As String
[C#]
public System.String get_ColEditMask ( System.Int32 col )
[Delphi]
function get_ColEditMask(col: Integer): String;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
get_ColFormat-Methode
Ermittelt das für numerische Werte verwendete Format.
Syntax
[VB]
Public Function get_ColFormat(ByVal col As Integer) As String
[C#]
public System.String get_ColFormat ( System.Int32 col )
[Delphi]
function get_ColFormat(col: Integer): String;

Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
get_ColHidden-Methode
Ermittelt, ob eine Spalte ausgeblendet ist.
Syntax
[VB]
Public Function get_ColHidden(ByVal col As Integer) As Boolean
[C#]
public System.Boolean get_ColHidden ( System.Int32 col )
[Delphi]
function get_ColHidden(col: Integer): Boolean;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
get_ColIndent-Methode
Ermittelt den Einzug einer gegebenen Spalte in Twips.
Syntax
[VB]
Public Function get_ColIndent(ByVal col As Integer) As Integer
[C#]
public System.Int32 get_ColIndent ( System.Int32 col )
[Delphi]
function get_ColIndent(col: Integer): Integer;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
get_ColIndex-Methode
Ermittelt den Spaltenindex, der zu einer gegebenen Taste passt.
Syntax
[VB]
Public Function get_ColIndex(ByVal colKey As String) As Integer
[C#]
public System.Int32 get_ColIndex ( System.String colKey )
get_ColHidden-Methode · 535

536 · C1FlexGridClassic-Referenzverzeichnis
[Delphi]
Function get_ColIndex(colKey: String): Integer;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
get_ColIsVisible-Methode
Ermittelt, ob eine gegebene Spalte derzeit auf dem Bildschirm ist.
Syntax
[VB]
Public Function get_ColIsVisible(ByVal col As Integer) As Boolean
[C#]
public System.Boolean get_ColIsVisible ( System.Int32 col )
[Delphi]
function get_ColIsVisible(col: Integer): Boolean;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
get_ColKey-Methode
Ermittelt eine Taste, mit der eine gegebene Spalte identifiziert wird.
Syntax
[VB]
Public Function get_ColKey(ByVal col As Integer) As String
[C#]
public System.String get_ColKey ( System.Int32 col )
[Delphi]
function get_ColKey(col: Integer): String;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
get_ColPos-Methode
Ermittelt die linke (x) Koordinate einer Spalte relativ zur Kante der Steuerung in Twips.
Syntax
[VB]
Public Function get_ColPos(ByVal col As Integer) As Integer

[C#]
public System.Int32 get_ColPos ( System.Int32 col )
[Delphi]
function get_ColPos(col: Integer): Integer;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
get_ColSort-Methode
Ermittelt die Sortierungsrichtung für jede Spalte (zur Verwendung mit der Sort-Eigenschaft).
Syntax
[VB]
get_ColSort-Methode · 537
Public Function get_ColSort(ByVal col As Integer) As C1.Win.C1FlexGrid.Classic.SortSettings
[C#]
public C1.Win.C1FlexGrid.Classic.SortSettings get_ColSort ( System.Int32 col )
[Delphi]
function get_ColSort(col: Integer): C1.Win.C1FlexGrid.Classic.SortSettings;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
get_ColWidth-Methode
Ermittelt die Breite einer bestimmten Spalte in Twips.
Syntax
[VB]
Public Function get_ColWidth(ByVal col As Integer) As Integer
[C#]
public System.Int32 get_ColWidth ( System.Int32 col )
[Delphi]
function get_ColWidth(col: Integer): Integer;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
get_FixedAlignment-Methode
Ermittelt die Ausrichtung für fixierte Zeilen in einer Spalte.

538 · C1FlexGridClassic-Referenzverzeichnis
Syntax
[VB]
Public Function get_FixedAlignment(ByVal col As Integer) As
C1.Win.C1FlexGrid.Classic.AlignmentSettings
[C#]
public C1.Win.C1FlexGrid.Classic.AlignmentSettings get_FixedAlignment ( System.Int32 col )
[Delphi]
function get_FixedAlignment(col: Integer): C1.Win.C1FlexGrid.Classic.AlignmentSettings;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
get_IsCollapsed-Methode
Ermittelt ob eine Zeile eingeklappt ist.
Syntax
[VB]
Public Function get_IsCollapsed(ByVal row As Integer) As Boolean
[C#]
public bool get_IsCollapsed ( System.Int32 row )
[Delphi]
function get_IsCollapsed(row: Integer): Boolean;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
get_IsSelected-Methode
Ermittelt ob eine Zeile ausgewählt ist (für listbox-Auswahltypen).
Syntax
[VB]
Public Function get_IsSelected(ByVal row As Integer) As Boolean
[C#]
public bool get_IsSelected ( System.Int32 row )
[Delphi]
function get_IsSelected(row: Integer): Boolean;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)

get_IsSubtotal-Methode
Ermittelt ob eine Zeile Zwischensummen beinhaltet (anstelle von Daten).
Syntax
[VB]
Public Function get_IsSubtotal(ByVal row As Integer) As Boolean
[C#]
public System.Boolean get_IsSubtotal ( System.Int32 row )
[Delphi]
function get_IsSubtotal(row: Integer): Boolean;
Bemerkungen
get_IsSubtotal-Methode · 539
Mit dieser Eigenschaft können Sie zum Einen feststellen, ob eine gegebene Zeile eine reguläre oder eine
Zwischensummenzeile ist, oder zum Anderen Zwischensummenzeilen manuell, als Gegenstück zur
Subtotal-Methode, erstellen.
Es bestehen zwei Unterschiede zwischen Zwischensummenzeilen und regulären Zeilen:
1. Zwischensummenzeilen können automatisch mit der Subtotal-Methode hinzugefügt oder
entfernt werden.
2. Wenn die Steuerung als Gliederung verwendet wird, dann verhalten sich Zwischensummenzeilen
wie Gliederungsknoten, währenddessen reguläre Zeilen sich wie Zweigstellen verhalten.
Sie können diese Eigenschaft verwenden, um eigene Gliederungen zu erstellen. Dies erfordert drei
Schritte:
1. Setzen Sie die IsSubtotal-Eigenschaft für alle Gliederungsknoten auf TRUE.
2. Setzen Sie die set_RowOutlineLevel-Methode für jeden Gliederungsknoten.
3. Setzen Sie die OutlineBar- und OutlineCol-Eigenschaften, wenn Sie einen Gliederungsbaum
erstellen wollen, in dem der Nutzer die Gliederung zusammenklappen und erweitern kann.
Für weitere Details, schauen Sie bitte unter „Übung zur Gliederung“ nach.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
get_MergeCol-Methode
Ermittelt ob die Zellen einer Spalte verbunden werden (Siehe auch MergeCells-Eigenschaft).
Syntax
[VB]
Public Function get_MergeCol(ByVal col As Integer) As Boolean
[C#]
public System.Boolean get_MergeCol ( System.Int32 col )

540 · C1FlexGridClassic-Referenzverzeichnis
[Delphi]
function get_MergeCol(col: Integer): Boolean;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
MergeCells-Eigenschaft (Seite 507)
GetMergedRange-Methode
Ermittelt ob die Zellen eines Bereichs verbunden werden.
Syntax
[VB]
Public Sub GetMergedRange(row As Integer, col As Integer, r1 As Integer, c1 As Integer, r2 As Integer,
c2 As Integer)
[C#]
public void GetMergedRange ( int row , int col , int r1 , int c1 , int r2 , int c2 )
[Delphi]
procedure GetMergedRange(row: Integer; col: Integer; r1: Integer; r2: integer; c2: Integer);
Parameter Beschreibung
row, col Die Koordinaten der Zelle, die in dem verbundenen Bereich enthalten sein soll.
r1, r2, c1, c2
Bemerkungen
Vier Koordinaten, die den aktuell verbundenen Bereich festlegen. r1 und r2 stehen
für die oberste und unterste Zeile, c1 und c2 stehen hingegen für die linke und
rechte Spalte des Bereichs.
Die C1FlexGridClassic-Steuerung kann Zellen aufgrund deren Inhalts verbinden. Mit dieser Methode
können Sie festlegen, ob eine Zelle mit ihren Nachbarzellen verbunden wird.
Zum Beispiel, der nachfolgende Quellcode ändert den Inhalt einer verbundenen Zelle, erhält dabei aber
den verbundenen Bereich:
• Visual Basic
' create a merged range
fg.MergeCells = MergeSettings.flexMergeFree
fg.set_MergeRow(1, True)
fg.set_Cell(CellPropertySettings.flexcpText,
1, 1, 1, 4, "Merged Range")
' this changes only cell 1, 1
fg.set_Cell(CellPropertySettings.flexcpText,_
1, 1, "Merged Range Has Changed")
' this changes the whole merged range
Dim r1&, c1&, r2&, c2&
fg.GetMergedRange (1, 2, r1, r2, c1, c2)

• C#
• Delphi
fg.set_Cell(CellPropertySettings.flexcpText, _
1, 1, 1, 4, "Merged Range Has Changed")
// create a merged range
fg.MergeCells = MergeSettings.flexMergeFree;
fg.set_MergeRow(1, true);
fg.set_Cell(CellPropertySettings.flexcpText,
1, 1, 1, 4, "Merged Range");
// this changes only cell 1, 1
fg.set_Cell(CellPropertySettings.flexcpText,
1, 1, "Merged Range Has Changed");
// this changes the whole merged range
r1&, c1&, r2&, c2&;
fg.GetMergedRange (1, 2, r1, r2, c1, c2);
fg.set_Cell(CellPropertySettings.flexcpText,
1, 1, 1, 4, "Merged Range Has Changed");
get_MergeRow-Methode · 541
var
r1, r2, c1, c2: Integer;
begin
// create a merged range
fg.MergeCells := MergeSettings.flexMergeFree;
fg.set_MergeRow(1, True);
fg.set_Cell(CellPropertySettings.flexcpText, 1, 1, 1, 4, 'Merged
Range');
// this changes only cell 1, 1
fg.set_Cell(CellPropertySettings.flexcpText, 1, 1, 'Merged Range Has
Changed');
// this changes the whole merged range
fg.GetMergedRange(1, 2, r1, r2, c1, c2);
fg.set_Cell(CellPropertySettings.flexcpText, 1, 1, 1, 4, 'Merged
Range Has Changed');
end;
Schauen Sie unter der MergeCells-Eigenschaft für weitere Einzelheiten über Zellverbindungen nach.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
GetMergedRange-Methode (C1FlexGrid) (Seite 192)
get_MergeRow-Methode
Ermittelt ob die Zellen einer Zeile verbunden werden (Siehe auch MergeCells-Eigenschaft).
Syntax
[VB]
Public Function get_MergeRow(ByVal row As Integer) As Boolean
[C#]
public System.Boolean get_MergeRow ( System.Int32 row )
[Delphi]
function get_MergeRow(row: Integer): Boolean;

542 · C1FlexGridClassic-Referenzverzeichnis
Bemerkungen
Die get_MergeRow-Methode wird zusammen mit der MergeCells-Eigenschaft und get_MergeCol-
Methode verwendet und steuert, ob und wie angezeigte Zellen verbunden werden.
Die MergeCells-Eigenschaft wird verwendet, um Zellverbindungen für die gesamte Tabelle zu
aktivieren. Nachdem diese auf einen angemessenen Wert gesetzt wurde, wird mit den get_MergeRow-
und get_MergeCol-Methoden festgelegt, in welchen Zeilen und Spalten Zellen verbunden werden.
Standardmäßig ist get_MergeRow und get_MergeCol auf FALSE gesetzt, sodass keine Zellen verbunden
werden. Wenn Sie diese für eine bestimmte Zeile oder Spalte auf TRUE setzen, dann werden
angrenzende Zellen im gleichen Inhalt verbunden.
Der Row-Parameter muss auf einen Wert zwischen Null und Rows-1 damit MergeRow für eine einzelne
Zeile oder auf den Wert -1 gesetzt werden,damit MergeRow für alle Zeilen aktiviert wird.
Sie müssen get_MergeRow nicht auf TRUE setzen, wenn MergeCells auf flexMergeSpill (6) steht.
Schauen Sie unter der MergeCells-Eigenschaft für weitere Einzelheiten und Beispiele nach.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
AllowMerging-Eigenschaft (Row) (Seite 326)
MergeCells-Eigenschaft (Seite 507)
GetNode-Methode (C1FlexGridClassic)
Ermittelt ein Gliederungsknotenobjekt für eine gegebene Zwischensummenzeile.
Syntax
[VB]
Public Function GetNode() As C1.Win.C1FlexGrid.Node
Public Function GetNode(ByVal row As Integer) As C1.Win.C1FlexGrid.Node
[C#]
public C1.Win.C1FlexGrid.Node GetNode ( )
public C1.Win.C1FlexGrid.Node GetNode ( System.Int32 row )
[Delphi]
function GetNode: C1.Win.C1FlexGrid.Node;
function GetNode(row: Integer): C1.Win.C1FlexGrid.Node;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
GetNodeRow-Methode
Ermittelt die Anzahl der, einer Zeile übergeordneten und untergeorneten ersten und letzten Zeile in der
Gliederung.

Syntax
[VB]
Public Function GetNodeRow(ByVal row As Integer, ByVal which As
C1.Win.C1FlexGrid.NodeTypeEnum) As Integer
[C#]
get_RowData-Methode · 543
public System.Int32 GetNodeRow ( System.Int32 row , C1.Win.C1FlexGrid.NodeTypeEnum which )
[Delphi]
function GetNodeRow (row: Integer; which: C1.Win.C1FlexGrid.NodeTypeEnum): Integer;
Bemerkungen
Wenn die Tabelle als Gliederung verwendet wird, dann können Sie mit dieser Methode den
übergeordneten, den ersten oder letzten untergeordneten Knoten eines gegebenen Knotens festlegen.
Die Parameter für die GetNodeRow-Eigenschaft werden nachfolgend beschrieben:
Row As Integer
Die Zeilennummer des Knotens, dessen über- oder untergeordneten Knoten Sie bestimmen wollen.
Which As NodeTypeSettings
Welcher Knoten zurückgegeben wird. Gültige Einstellungen für diesen Paramter sind:
Mitgliedsname Beschreibung
Root Des Knotens Quellknoten.
Parent Des Knotens direkter Vorgänger.
FirstChild Des Knotens erster Nachfolger.
LastChild Des Knotens letzter Nachfolger.
FirstSibling Des Knotens erster Sibling (Knoten auf der selben Ebene mit dem selben
übergeordneten Knoten).
LastSibling Des Knotens letzter Sibling.
NextSibling Des Knotens nächster Sibling.
PreviousSibling Des Knotens vorhergehender Sibling.
Wenn der gewünschte Knoten nicht exisitert, dann gibt GetNode Null zurück. Zum Beispiel, der
Quellknoten besitzt keinen vorhergehenden und leere Knoten keine weiteren nachfolgenden Siblings.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
get_RowData-Methode
Ermittelt ein benutzerdefiniertes, mit einer gegebenen Zeile verknüpftes Variant.

544 · C1FlexGridClassic-Referenzverzeichnis
Syntax
[VB]
Public Function get_RowData(ByVal row As Integer) As Object
[C#]
public System.Object get_RowData ( System.Int32 row )
[Delphi]
function get_RowData(row: Integer): Object;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
get_RowHeight-Methode
Ermittelt die Höhe einer bestimmten Zeile in Twips.
Syntax
[VB]
Public Function get_RowHeight(ByVal row As Integer) As Integer
[C#]
public System.Int32 get_RowHeight ( System.Int32 row )
[Delphi]
function get_RowHeight(row: Integer): As Integer;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
get_RowHidden-Methode
Ermittelt, ob eine Zeile versteckt ist.
Syntax
[VB]
Public Function get_RowHidden(ByVal row As Integer) As Boolean
[C#]
public bool get_RowHidden ( System.Int32 row )
[Delphi]
function get_RowHidden(row: Integer): Boolean;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)

get_RowIsVisible-Methode
Ermittelt, ob eine gegebene Zeile derzeit auf dem Bildschirm sichtbar ist.
Syntax
[VB]
Public Function get_RowIsVisible(ByVal row As Integer) As Boolean
[C#]
public System.Boolean get_RowIsVisible ( System.Int32 row )
[Delphi]
function get_RowIsVisible(row: Integer): Boolean;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
get_RowOutlineLevel-Methode
Ermittelt die Gliederungsebene für eine Zwischensummenzeile.
Syntax
[VB]
Public Function get_RowOutlineLevel(ByVal row As Integer) As Integer
[C#]
public System.Int32 get_RowOutlineLevel ( System.Int32 row )
[Delphi]
function get_RowOutlineLevel(row: Integer): Integer;
Bemerkungen
Die get_RowOutlineLevel-Eigenschaft wird für zwei eng verwandte Ziele genutzt.
get_RowIsVisible-Methode · 545
1. Wenn sich die Tabelle im Gliederungsmodus befindet, dann wird get_RowOutlineLevel für das
Festlegen der hierarchischen Ebene eines Knotens verwendet. Knoten mit hohen
Gliederungsebenen sind Zeilen, mit niedrigeren Gliederungsebenen untergeordnete. Der
Quellknoten hat die niedrigste Gliederungsebene. Sie können die Beziehungen zwischen Knoten
verändern, indem Sie den Wert der get_RowOutlineLevel-Methode anpassen. Schauen Sie bitte
für weitere Einzelheiten über das Erstellen und Verwenden von Gliederungen unter „Übung zur
Gliederung“ nach.
2. Wenn die Subtotal-Methode für automatisches Erstellen von Zwischensummenzeilen verwendet
wird, dann speichert get_RowOutlineLevel die Nummer der Zeile, die für das Gruppieren der
Daten genutzt wird. Schauen Sie bitte für weitere Einzelheiten über das Erstellen und Verwenden
von automatischen Zwischensummenzeilen unter der Subtotal-Methode nach.
Die get_RowOutlineLevel wird von der Steuerung nur verwendet, wenn die get_IsSubtotal-Eigenschaft
auf TRUE steht.

546 · C1FlexGridClassic-Referenzverzeichnis
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
get_RowPos-Methode
Ermittelt die obere (y) Koordinate einer Zeile, relativ zur Kante der Steuerung in Twips.
Syntax
[VB]
Public Function get_RowPos(ByVal row As Integer) As Integer
[C#]
public System.Int32 get_RowPos ( System.Int32 row )
[Delphi]
function get_RowPos(row: Integer): Integer;
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
GetSelection-Methode
Ermittelt die sortierte aktuelle Auswahl, sodass Row1

Zum Beispiel, der nachfolgende Quellcode druckt den Inhalt des ausgwählten Bereichs:
• Visual Basic
• C#
• Delphi
Dim r&, c&, r1&, c1, r2&, c2&
fg.GetSelection (r1, c1, r2, c2)
For r = r1 To r2
For c = c1 To c2
Debug.WriteLine (fg.get_TextMatrix (r,c))
Next
Next
r&, c&, r1&, c1, r2&, c2&;
fg.GetSelection (r1, c1, r2, c2);
for ( r = r1; r

548 · C1FlexGridClassic-Referenzverzeichnis
get_ValueMatrix-Methode
Ermittelt einen numerischen Wert einer Zelle zurück, die durch ihre Zeilen- und Spaltenkoordinaten
definiert wird.
Syntax
[VB]
Public Function get_ValueMatrix(r As Integer, c As Integer) As Double
[C#]
public Double get_ValueMatrix ( int r , int c )
[Delphi]
function get_ValueMatrix(r: Integer; c: Integer): Double;
Parameter Beschreibung
Row Zeilenindex der Zelle, dessen Wert abgerufen wird.
Col Spaltenindex der Zelle, dessen Wert abgerufen wird.
Bemerkungen
Diese Eigenschaft ist ähnlich der Value-Eigenschaft. Sie können mit dieser Methode allerdings die Zelle
festlegen, deren Wert abgerufen wird.
Der nachfolgende Quellcode gibt den Wert einer willkürlichen Zelle im Debugfenster aus:
• Visual Basic
• C#
Debug.WriteLine(fg.get_ValueMatrix(1, 1))
Debug.WriteLine(fg.get_ValueMatrix(1, 1));
• Delphi
Console.WriteLine(fg.get_ValueMatrix(1, 1));
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
GetData-Methode (Seite 190)
SetData-Methode (Seite 207)
Outline-Methode
Legt eine Gliederungsebene für die Zwischensummenzeilen fest.
Syntax
[VB]
Public Sub Outline(ByVal level As Integer)

[C#]
public void Outline ( System.Int32 level )
[Delphi]
procedure Outline(level: Integer);
Bemerkungen
PrintGrid-Methode (C1FlexGridClassic) · 549
Die Outline-Methode klappt eine Gliederung bis zu einer gegebenen Ebene aus oder ein. Dabei werden
mehrere Knoten gleichzeitig ein- oder ausgeklappt.
Die Methode zeigt alle Knoten, die ein RowOutlineLevel kleiner oder gleich dem Wert des Level-
Parameters besitzen. Kleinere Level-Werte klappt die Gliederung zusammen, größere Werte erweitert sie.
Wenn die Ebene Null ist, dann werden nur die Quellknoten angezeigt. Wenn das Level auf einen sehr
großen Wert gesetzt wird, z.B. 100, dann wird die Gliederung vollständig erweitert und sichtbar.
Wenn das Level auf -1 steht, dann wird die Gliederung vollständig erweitert.
Wenn Knoten erweitert oder zusammengeklappt werden, dann startet die Steuerung die BeforeCollapse-
und AfterCollapse-Ereignisse. Sie können diese Ereignisse abfangen und die Handlungen abbrechen.
Schauen Sie im BeforeCollapse-Ereignis für ein Beispiel nach.
Schauen Sie in der Subtotal-Methode nach, um eine Gliederungsstruktur mit automatischen
Zwischensummen zu erstellen. Schauen Sie in der set_IsSubtotal-Methode nach, um eine
benutzerdefinierte Gliederungsstruktur zu erstellen. Für weitere Einzelheiten über das Erstellen und
Verwenden von Gliederungen, schauen Sie bitte unter „Übung zur Gliederung“ nach.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
PrintGrid-Methode (C1FlexGridClassic)
Druckt die Tabelle und zweigt optional ein Druckvorschaufenster an.
Syntax
[VB]
Public Function PrintGrid(docName As String) As Boolean
Public Function PrintGrid(docName As String, flags As PrintGridFlags) As Boolean
Public Function PrintGrid(docName As String, flags As PrintGridFlags, header As String, footer As
String) As Boolean
[C#]
public Boolean PrintGrid(string docName)
public Boolean PrintGrid(string docName , PrintGridFlags flags)
public Boolean PrintGrid(string docName , PrintGridFlags flags , string header , string footer)
[Delphi]
function PrintGrid(docName: string): Boolean;
function PrintGrid(docName: string; flags: PrintGridFlags): Boolean;

550 · C1FlexGridClassic-Referenzverzeichnis
function PrintGrid(docName: string; flags: PrintGridFlags; header: string; footer: string); Boolean;
Parameter Beschreibung
docName
flags
Der Dokumentname, der in den Fortschritts- und den Druckauftragsfenstern
angezeigt wird.
Eine Kombination von Werten der PrintGridFlags-Aufzählung, die den Typ der
anzuzeigenden Druck- und Vorschaufenster festlegen und bestimmen, wie die
Tabelle für den Ausdruck skaliert wird.
header, footer Zeichenketten, die oben und unten auf jede Seite gedruckt werden.
Rückgabewert
Ein Boolean-Wert der anzeigt, ob entweder die Tabelle gedruckt wurde, oder der Nutzer eines der
optionalen Einstellungsfenster abgebrochen hat.
Bemerkungen
Die Kopf- und Fußzeilentexte können bis zu drei tabulatorgetrennte Abschnitte besitzen, die
entsprechend links, mittig und rechts auf der Seite ausgerichtet werden. Die Texte können weiterhin
Platzhalter besitzen, die mit der aktuellen Seitenzahl oder der Gesamtseitenzahl (“{0}” und “{1}”) ersetzt
werden.
Mit der PrintParameters-Eigenschaft können Sie noch weitere Aspekte des Druckauftrags, wie z.B.
Seitenausrichtung, Ränder, Kopf- und Fußzeilenschriftarten, steuern.
Beispiel
Der folgende Aufruf skaliert die Tabelle auf eine Seitenbreite, platziert eine zentrierte Fußzeile mit dem
Text „Page n of m” am unteren Ende der Seite und druckt sie auf dem Standarddrucker aus.
• Visual Basic
• C#
flex.PrintGrid("My Grid", PrintGridFlags.FitPageWidth, _
"", vbTab + "Page {0} of {1}")
flex.PrintGrid("My Grid", PrintGridFlags.FitPageWidth,
"", "\tPage {0} of {1}");
• Delphi
flex.PrintGrid('My Grid', PrintGridFlags.FitPageWidth, '', #9'Page
{0} of {1}');
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGridClassic-Klasse (Seite 450)
RemoveItem-Methode (C1FlexGridClassic)
Entfernt eine Zeile aus der Steuerung.

Syntax
[VB]
Object.RemoveItem ()
Object.RemoveItem (int Row)
[C#]
public void RemoveItem ( )
public void RemoveItem ( int Index )
[Delphi]
procedure RemoveItem;
procedure RemoveItem(index: Integer);
Parameter Beschreibung
Row
Bemerkungen
SelectedRow-Methode · 551
Ein optionaler Parameter, mit dem festgelegt wird, welche Zeile aus der Steuerung
entfernt wird.
Der Row-Parameter legt fest, welche Zeile aus der Steuerung entfernt wird. Wenn dieser bereitgestellt
wird, dann muss er zwischen 0 und Rows-1 liegen, da sonst ein Invalid Index-Fehler (ungültiger Index)
auftritt. Wenn dieser Parameter unberücksichtigt bleibt, dann wird die letzte Zeile der Tabelle gelöscht.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
Remove-Methode (RowCollection) (Seite 313)
SelectedRow-Methode
Ermittelt die Position einer ausgewählten Zeile, wenn der SelectionMode auf flexSelectionListBox steht.
Syntax
[VB]
Public Function SelectedRow(ByVal index As Integer) As Integer
[C#]
public int SelectedRow (int index)
[Delphi]
function SelectedRow(index: Integer): Integer;
Bemerkungen
Diese Eigenschaft arbeitet zusammen mit der SelectedRows-Eigenschaft, um alle ausgewählten Zeilen in
der Steuerung aufzulisten. Diese Eigenschaft ist besonders nützlich, wenn die SelectionMode-

552 · C1FlexGridClassic-Referenzverzeichnis
Eigenschaft auf flexSelectionListBox (3) steht, sodass der Nutzer mehrere nichtangrenzende Zeilen
auswählen kann.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
Selection-Eigenschaft (Seite 166)
set_Cell-Methode
Legt die cell-Eigenschaften auf einen willkürlichen Bereich fest.
Syntax
[VB]
Public Sub set_Cell(ByVal setting As C1.Win.C1FlexGrid.Classic.CellPropertySettings, ByVal row1 As
Integer, ByVal col1 As Integer, ByVal row2 As Integer, ByVal col2 As Integer, ByVal newVal As Object)
Public Sub set_Cell(ByVal setting As C1.Win.C1FlexGrid.Classic.CellPropertySettings, ByVal row As
Integer, ByVal col As Integer, ByVal newVal As Object)
[C#]
public void set_Cell ( C1.Win.C1FlexGrid.Classic.CellPropertySettings setting , System.Int32 row ,
System.Int32 col , System.Object newVal )
public void set_Cell ( C1.Win.C1FlexGrid.Classic.CellPropertySettings setting , System.Int32 row1 ,
System.Int32 col1 , System.Int32 row2 , System.Int32 col2 , System.Object newVal )
[Delphi]
procedure set_Cell(setting: C1.Win.C1FlexGrid.Classic.CellPropertySettings; row1: Integer; col1: Integer;
row2: Integer; col2: Integer; newVal: Object);
procedure set_Cell(setting: C1.Win.C1FlexGrid.Classic.CellPropertySettings; row: Integer; col: Integer;
newVal: Object);
Bemerkungen
Mit der set_Cell-Methode können Sie die cell-Eigenschaften von einzelnen Zellen oder Zellbereichen
direkt auslesen oder festlegen, ohne diese auszuwählen.
Die Parameter für die set_Cell-Methode werden nachfolgend beschrieben:
Setting As CellPropertySettings
Dieser Parameter legt fest, welche Eigenschaft gelesen oder gesetzt wird. Die verfügbaren Einstellungen
sind nachfolgend aufgelistet.
Row1, Col1, Row2, and Col2 As Integer (optional)
Wenn die cell-Eigenschaften gelesen werden, dann wird nur die Zelle (Row1, Col1) verwendet. Wenn sie
gesetzt werden, dann ist der gesamte Bereich betroffen. Der Standardwert für Row1 und Col1 ist die
aktuelle Zeile und die aktuelle Spalte. Wenn diese nicht zur Verfügung gestellt werden, dann wird die
aktuelle Zelle verwendet. Der Standardwert für Row2 und Col2 ist Row1 und Col1. Wenn diese nicht zur
Verfügung gestellt werden, dann wird eine einzelne Zelle verwendet.
Die Gültigen Einstellungen für den setting-Parameter sind:

Mitgliedsname Beschreibung
flexChecked Die Zelle hat ein Kontrollkästchen mit einem Häkchen drin.
flexNoCheckbox Die Zelle hat kein Kontrollkästchen.
set_ColAlignment-Methode · 553
flexTSChecked Die Zelle hat ein drei-Zustands-Kontrollkästchen mit einem Häkchen drin.
flexTSGrayed Die Zelle hat ein drei-Zustands-Kontrollkästchen im grauen Zustand.
flexTSUnchecked Die Zelle hat ein leeres drei-Zustands-Kontrollkästchen.
flexUnchecked Die Zelle hat ein leeres Kontrollkästchen.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
set_ColAlignment-Methode
Legt die Ausrichtung einer gegebenen Spalte fest.
Syntax
[VB]
Public Sub set_ColAlignment(ByVal col As Integer, ByVal newVal As
C1.Win.C1FlexGrid.Classic.AlignmentSettings)
[C#]
public void set_ColAlignment ( System.Int32 col , C1.Win.C1FlexGrid.Classic.AlignmentSettings
newVal)
[Delphi]
procedure set_ColAlignment(col: Integer; newVal: C1.Win.C1FlexGrid.Classic.AlignmentSettings);
Bemerkungen
Die flexAlignGeneral-Einstellung richtet Text linksbündig und Zahlen und Daten rechtsbündig aus.
Die set_ColAlignment-Methode betrifft alle Zellen in der festgelegten Spalte, auch die in den fixierten
Zeilen. Sie können diese Einstellung für fixierte Zellen mit der set_FixedAlignment-Methode und für
einzelne Zellen mit der Cell(flexcpAlignment)-Eigenschaft überschreiben.
Dieses Beispiel legt die Ausrichtung der dritten Spalte auf rechts unten fest.
• Visual Basic
• C#
fg.set_ColAlignment(2, AlignmentSettings.flexAlignRightBottom)
fg.set_ColAlignment(2, AlignmentSettings.flexAlignRightBottom);
• Delphi
fg.set_ColAlignment(2, AlignmentSettings.flexAlignRightBottom);
Sie können die Ausrichtung von Grafiken mit der CellPictureAlignment-Eigenschaft festlegen.

554 · C1FlexGridClassic-Referenzverzeichnis
Wenn Sie diese Eigenschaft setzen, dann sollte der Col-Parameter auf einem Wert zwischen 0 und Cols-1
stehen, um eine gegebene Spalte auszurichten oder auf -1, um die Ausrichtung aller Spalten festzulegen.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
StyleFixedDisplay-Eigenschaft (Seite 359)
set_ColComboList-Methode
Legt die für ein Auswahlfeld zu verwendende Liste von einer bestimmten Spalte fest.
Syntax
[VB]
Public Sub set_ColComboList(ByVal col As Integer, ByVal newVal As String)
[C#]
public void set_ColComboList ( System.Int32 col , System.String newVal )
[Delphi]
procedure set_ColComboList(col: Integer; newVal: String);
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
set_ColData-Methode
Legt ein benutzerdefiniertes, mit einer Spalte verknüpftes Variant fest.
Syntax
[VB]
Public Sub set_ColData(ByVal col As Integer, ByVal newVal As Object)
[C#]
public void set_ColData ( System.Int32 col , System.Object newVal )
[Delphi]
procedure set_ColData(col: Integer; newVal: Object);
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
set_ColDataType-Methode
Legt den Datentyp einer Spalte fest.
Syntax
[VB]
Public Sub set_ColDataType(ByVal col As Integer, ByVal newVal As System.Type)

[C#]
public void set_ColDataType ( System.Int32 col , System.Type newVal )
[Delphi]
procedure set_ColDataType(col: Integer; newVal: System.Type);
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
set_ColEditMask-Methode
set_ColEditMask-Methode · 555
Legt die Eingabemaske fest, die für die Bearbeitung der Zellen in einer bestimmten Spalte verwendet
wird.
Syntax
[VB]
Public Sub set_ColEditMask(ByVal col As Integer, ByVal newVal As String)
[C#]
public void set_ColEditMask ( System.Int32 col , System.String newVal )
[Delphi]
procedure set_ColEditMask(col: Integer; newVal: String);
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
set_ColFormat-Methode
Legt das für numerische Werte verwendete Format fest.
Syntax
[VB]
Public Sub set_ColFormat(ByVal col As Integer, ByVal newVal As String)
[C#]
public void set_ColFormat ( System.Int32 col , System.String newVal )
[Delphi]
procedure set_ColFormat(col: Integer; newVal: String);
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
set_ColHidden-Methode
Legt fest, ob eine Spalte ausgeblendet wird.
Syntax

556 · C1FlexGridClassic-Referenzverzeichnis
[VB]
Public Sub set_ColHidden(ByVal col As Integer, ByVal newVal As Boolean)
[C#]
public void set_ColHidden ( System.Int32 col , System.Boolean newVal )
[Delphi]
Sub set_ColHidden(col: Integer; newVal: Boolean);
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
set_ColImageList-Methode
Legt einen zu verwendenden Abwickler auf eine ImageList als Quelle des Bildes für eine gegebene Spalte
fest.
Syntax
[VB]
Public Sub set_ColImageList(ByVal col As Integer, ByVal newVal As System.Windows.Forms.ImageList)
[C#]
public void set_ColImageList ( System.Int32 col , System.Windows.Forms.ImageList newVal )
[Delphi]
procedure set_ColImageList(col: Integer; newVal: System.Windows.Forms.ImageList);
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
set_ColIndent-Methode
Legt den Einzug einer gegebenen Spalte in Twips fest.
Syntax
[VB]
Public Sub set_ColIndent(ByVal col As Integer, ByVal newVal As Integer)
[C#]
public void set_ColIndent ( System.Int32 col , System.Int32 newVal )
[Delphi]
procedure set_ColIndent(col: Integer; newVal: Integer);
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)

set_ColKey-Methode
Legt eine Taste fest, mit der eine gegebene Spalte identifiziert wird.
Syntax
[VB]
Public Sub set_ColKey(ByVal col As Integer, ByVal newVal As String)
[C#]
public void set_ColKey ( System.Int32 col , System.String newVal )
[Delphi]
procedure set_ColKey(col: Integer; newVal: String);
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
set_ColPosition-Methode
Verschiebt eine gegebene Spalte auf eine neue Position.
Syntax
[VB]
Public Sub set_ColPosition(ByVal col As Integer, ByVal newPosition As Integer)
[C#]
public void set_ColPosition ( System.Int32 col , System.Int32 newPosition )
[Delphi]
procedure set_ColPosition(col: Integer; newPosition: Integer);
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
set_ColSort-Methode
Legt die Sortierungsrichtung für jede Spalte fest (zur Verwendung mit der Sort-Eigenschaft).
Syntax
[VB]
set_ColKey-Methode · 557
Public Sub set_ColSort(ByVal col As Integer, ByVal newVal As C1.Win.C1FlexGrid.Classic.SortSettings)
[C#]
public void set_ColSort ( System.Int32 col , C1.Win.C1FlexGrid.Classic.SortSettings newVal )
[Delphi]
procedure set_ColSort(col: Integer; newVal: C1.Win.C1FlexGrid.Classic.SortSettings);

558 · C1FlexGridClassic-Referenzverzeichnis
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
set_ColWidth-Methode
Legt die Breite einer bestimmten Spalte in Twips fest.
Syntax
[VB]
Public Sub set_ColWidth(ByVal col As Integer, ByVal newVal As Integer)
[C#]
public void set_ColWidth ( System.Int32 col , System.Int32 newVal )
[Delphi]
procedure set_ColWidth(col: Integer; newVal: Integer);
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
set_FixedAlignment-Methode
Legt die Ausrichtung für fixierte Zeilen in einer Spalte fest.
Syntax
[VB]
Public Sub set_FixedAlignment(ByVal col As Integer, ByVal newVal As
C1.Win.C1FlexGrid.Classic.AlignmentSettings)
[C#]
public void set_FixedAlignment ( System.Int32 col , C1.Win.C1FlexGrid.Classic.AlignmentSettings
newVal )
[Delphi]
procedure set_FixedAlignment(col: Integer; newVal: C1.Win.C1FlexGrid.Classic.AlignmentSettings);
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
set_IsCollapsed-Methode
Legt fest, ob eine Zeile eingeklappt ist.
Syntax
[VB]
Public Sub set_IsCollapsed(ByVal row As Integer, ByVal newVal As Boolean)

[C#]
public void set_IsCollapsed ( System.Int32 row , System.Boolean newVal )
[Delphi]
procedure set_IsCollapsed(row: Integer; newVal: Boolean);
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
set_IsSelected-Methode
Legt fest, ob eine Zeile ausgewählt ist (für listbox-Auswahltypen).
Syntax
[VB]
Public Sub set_IsSelected(ByVal row As Integer, ByVal newVal As Boolean)
[C#]
public void set_IsSelected ( System.Int32 row , System.Boolean newVal )
[Delphi]
procedure set_IsSelected(row: Integer; newVal: Boolean);
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
set_IsSubtotal-Methode
Legt fest, ob eine Zeile Zwischensummen beinhaltet (anstelle von Daten).
Syntax
[VB]
Public Sub set_IsSubtotal(ByVal row As Integer, ByVal newVal As Boolean)
[C#]
public void set_IsSubtotal ( System.Int32 row , System.Boolean newVal )
[Delphi]
procedure set_IsSubtotal(row: Integer; newVal: Boolean);
Bemerkungen
set_IsSelected-Methode · 559
Mit dieser Eigenschaft können Sie zum Einen feststellen, ob eine gegebene Zeile eine reguläre oder eine
Zwischensummenzeile ist, oder zum Anderen Zwischensummenzeilen manuell, als Gegenstück zur
Subtotal-Methode, erstellen.
Es bestehen zwei Unterschiede zwischen Zwischensummenzeilen und regulären Zeilen:
1. Zwischensummenzeilen können automatisch mit der Subtotal-Methode hinzugefügt oder
entfernt werden.

560 · C1FlexGridClassic-Referenzverzeichnis
2. Wenn die Steuerung als Gliederung verwendet wird, dann verhalten sich Zwischensummenzeilen
wie Gliederungsknoten, währenddessen reguläre Zeilen sich wie Zweigstellen verhalten.
Sie können diese Eigenschaft verwenden, um eigene Gliederungen zu erstellen. Dies benötig drei Schritte:
3. Setzen Sie die IsSubtotal-Eigenschaft für alle Gliederungsknoten auf TRUE.
4. Setzen Sie die set_RowOutlineLevel-Methode für jeden Gliederungsknoten.
5. Setzen Sie die OutlineBar- und OutlineCol-Eigenschaften, wenn Sie einen Gliederungsbaum
erstellen wollen, in dem der Nutzer die Gliederung zusammenklappen und erweitern kann.
Für weitere Details, schauen Sie bitte unter „Übung zur Gliederung“ nach.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
set_MergeCol-Methode
Legt fest, ob die Zellen einer Spalte verbunden werden (Siehe auch MergeCells-Eigenschaft).
Syntax
[VB]
Public Sub set_MergeCol(ByVal col As Integer, ByVal newVal As Boolean)
[C#]
public void set_MergeCol ( System.Int32 col , System.Boolean newVal )
[Delphi]
procedure set_MergeCol(col: Integer; newVal: Boolean);
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
MergeCells-Eigenschaft (Seite 507)
set_MergeRow-Methode
Legt fest, ob die Zellen einer Zeile verbunden werden (Siehe auch MergeCells-Eigenschaft).
Syntax
[VB]
Public Sub set_MergeRow(ByVal row As Integer, ByVal newVal As Boolean)
[C#]
public void set_MergeRow ( System.Int32 row , System.Boolean newVal )
[Delphi]
procedure set_MergeRow(row: Integer; newVal: Boolean);

Bemerkungen
set_RowData-Methode · 561
Die set_MergeRow-Methode wird zusammen mit der MergeCells-Eigenschaft und set_MergeCol-
Methode verwendet und steuert, ob und wie angezeigte Zellen verbunden werden.
Die MergeCells-Eigenschaft wird verwendet, um Zellverbindungen für die gesamte Tabelle zu
aktivieren. Nachdem diese auf einen angemessenen Wert gesetzt wurde, wird mit den set_MergeRow-
und set_MergeCol-Methoden festgelegt, in welchen Zeilen und Spalten Zellen verbunden werden.
Standardmäßig ist set_MergeRow und set_MergeCol auf FALSE gesetzt, so dass keine Zellen verbunden
werden. Wenn Sie diese für eine bestimmte Zeile oder Spalte auf TRUE setzen, dann werden
angrenzende Zellen mit gleichem Inhalt verbunden.
Der Row-Parameter muss auf einem Wert zwischen Null und Rows-1, damit MergeRow für eine einzelne
Zeile, oder auf den Wert -1 gesetzt werden, damit MergeRow für alle Zeilen aktiviert wird.
Sie müssen set_MergeRow nicht auf TRUE setzen, wenn MergeCells auf flexMergeSpill (6) steht.
Schauen Sie unter der MergeCells-Eigenschaft für weitere Einzelheiten und Beispiele nach.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
MergeCells-Eigenschaft (Seite 507)
set_RowData-Methode
Legt ein benutzerdefiniertes, mit einer gegebenen Zeile verknüpftes Variant fest.
Syntax
[VB]
Public Sub set_RowData(ByVal row As Integer, ByVal newVal As Object)
[C#]
public void set_RowData ( System.Int32 row , System.Object newVal )
[Delphi]
procedure set_RowData(row: Integer; newVal: Object);
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
set_RowHeight-Methode
Legt die Höhe einer bestimmten Zeile in Twips fest.
Syntax
[VB]
Public Sub set_RowHeight(ByVal row As Integer, ByVal newVal As Integer)
[C#]
public void set_RowHeight ( System.Int32 row , System.Int32 newVal )

562 · C1FlexGridClassic-Referenzverzeichnis
[Delphi]
procedure set_RowHeight(row: Integer; newVal: Integer);
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
set_RowHidden-Methode
Legt fest, ob eine Zeile versteckt ist.
Syntax
[VB]
Public Sub set_RowHidden(ByVal row As Integer, ByVal newVal As Boolean)
[C#]
public void set_RowHidden ( System.Int32 row , System.Boolean newVal )
[Delphi]
procedure set_RowHidden(row: Integer, newVal: Boolean);
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
set_RowOutlineLevel-Methode
Legt die Gliederungsebene für eine Zwischensummenzeile fest.
Syntax
[VB]
Public Sub set_RowOutlineLevel(ByVal row As Integer, ByVal newVal As Integer)
[C#]
public void set_RowOutlineLevel ( System.Int32 row , System.Int32 newVal )
[Delphi]
procedure set_RowOutlineLevel(row: Integer; newVal: Integer);
Bemerkungen
Die set_RowOutlineLevel-Eigenschaft wird für zwei eng verwandte Ziele genutzt.
1. Wenn sich Tabellen im Gliederungsmodus befinden, dann wird set_RowOutlineLevel für das
Festlegen der hierarchischen Ebene eines Knotens verwendet. Knoten mit hohen
Gliederungsebenen sind Zeilen mit niedrigeren Gliederungsebenen untergeordnet. Der
Quellknoten hat die niedrigste Gliederungsebene. Sie können die Beziehungen zwischen Knoten
verändern, indem Sie den Wert der set_RowOutlineLevel-Methode anpassen. Schauen Sie bitte
für weitere Einzelheiten über das Erstellen und Verwenden von Gliederungen unter „Übung zur
Gliederung“ nach.
2. Wenn die Subtotal-Methode für automatisches Erstellen von Zwischensummenzeilen verwendet
wird, dann speichert get_RowOutlineLevel die Nummer der Zeile, die für das Gruppieren der

set_RowPosition-Methode · 563
Daten genutzt wird. Schauen Sie bitte für weitere Einzelheiten über das Erstellen und Verwenden
von automatischen Zwischensummenzeilen unter der Subtotal-Methode nach.
Die set_RowOutlineLevel wird von der Steuerung nur verwendet, wenn die set_IsSubtotal-Eigenschaft
auf TRUE steht.
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
set_RowPosition-Methode
Verschiebt eine gegebene Zeile auf eine neue Position.
Syntax
[VB]
Public Sub set_RowPosition(ByVal row As Integer, ByVal newPosition As Integer)
[C#]
public void set_RowPosition ( System.Int32 row , System.Int32 newPosition )
[Delphi]
procedure set_RowPosition(row: Integer; newPosition: Integer);
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)
set_TextMatrix-Methode
Legt den Inhalt einer Zelle fest, die durch ihre Zeilen- und Spaltenkoordinaten definiert wird.
Syntax
[VB]
Public Sub set_TextMatrix(ByVal r As Integer, ByVal c As Integer, ByVal s As String)
[C#]
public void set_TextMatrix ( System.Int32 r , System.Int32 c , System.String s )
[Delphi]
procedure set_TextMatrix(r: Integer; c: Integer; s: String);
Schauen Sie ferner unter
C1FlexGridClassic-Klasse (Seite 450)

564 · C1FlexGridClassic-Referenzverzeichnis
Cell-Klassen
Alle Cell-Mitglieder
Cell-Eigenschaften
Item Ermittelt oder legt die Daten in einer Tabellenzelle fest.
Cell-Eigenschaften
Item-Eigenschaft (Cell)
Ermittelt oder legt die Daten in einer Tabellenzelle fest.
Syntax
[VB]
Default Public-Eigenschaft Item(ByVal setting As C1.Win.C1FlexGrid.Classic.CellPropertySettings, ByVal
row As Integer, ByVal col As Integer) As Object
Default Public-Eigenschaft Item(ByVal setting As C1.Win.C1FlexGrid.Classic.CellPropertySettings, ByVal
row1 As Integer, ByVal col1 As Integer, ByVal row2 As Integer, ByVal col2 As Integer) As Object
[C#]
public object this [CellPropertySettings setting, int row, int col]
public object this [CellPropertySettings setting, int row1, int col1, int row2, int col2]
[Delphi]
property Item(setting: CellPropertySettings; row: Integer, col: Integer): Object;
property Item(setting: CellPropertySettings; row1: Integer, col1: Integer, row2: Integer, col2: Integer):
Object;
Schauen Sie ferner unter
C1FlexGrid-Klasse (Seite 109)
C1FlexGridClassic-Klasse (Seite 450)
Column-Klasse (Seite 339)
Row-Klasse (Seite 324)
C1FlexGridClassic-Aufzählungen
AlignmentSettings-Aufzählung
Legt den Typ der Ausrichtung fest.

Syntax
[VB]
Public enum AlignmentSettings
[C#]
public sealed enum AlignmentSettings : System.Enum
[Delphi]
AllowUserResizeSettings-Aufzählung · 565
type AlignmentSettings = (flexAlignLeftTop, flexAlignLeftCenter, flexAlignLeftBottom,
flexAlignCenterTop, flexAlignCenterCenter, flexAlignCenterBottom, flexAlignRightTop,
flexAlignRightCenter, flexAlignRightBottom, flexAlignGeneral);
Bemerkungen
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der CellAlignment, get_ColAlignment
und get_FixedAlignment in der C1FlexGridClassic-Steuerung festzulegen.
Mitgliedsname Beschreibung
flexAlignLeftTop Richtet Text links oben aus.
flexAlignLeftCenter Richtet Text links zentriert aus.
flexAlignLeftBottom Richtet Text links unten aus.
flexAlignCenterTop Richtet Text zentriert oben aus.
flexAlignCenterCenter Richtet Text zentriert aus.
flexAlignCenterBottom Richtet Text zentriert unten aus.
flexAlignRightTop Richtet Text rechts oben aus.
flexAlignRightCenter Richtet Text rechts zentriert aus.
flexAlignRightBottom Richtet Text rechts unten aus.
flexAlignGeneral Richtet Text links und Zahlen und Daten rechts aus.
AllowUserResizeSettings-Aufzählung
Legt fest, in welchen Bereichen der Tabelle die Größe verändert werden darf.
Syntax
[VB]
Public enum AllowUserResizeSettings
[C#]
public sealed enum AllowUserResizeSettings : System.Enum
[Delphi]
type AllowUserResizeSettings = (flexResizeNone, flexResizeColumns, flexResizeRows, flexResizeBoth,
flexResizeBothUniform, flexResizeRowsUniform);

566 · C1FlexGridClassic-Referenzverzeichnis
Bemerkungen
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der AllowUserResizing-Eigenschaft in
der C1FlexGridClassic-Steuerung festzulegen.
Mitgliedsname Beschreibung
flexResizeNone
Der Nutzer kann die Größe von Zeilen und Spalten nicht
verändern.
flexResizeColumns Der Nutzer kann die Spaltenbreite verändern.
flexResizeRows Der Nutzer kann die Zeilenhöhe verändern.
flexResizeBoth Der Nutzer kann die Größe von Zeilen und Spalten verändern.
flexResizeBothUniform Der Nutzer kann die Größe von Zeilen und Spalten verändern.
flexResizeRowsUniform
AutoSizeSettings-Aufzählung
Wenn die Zeilenhöhe geändert wird, dann wird diese Höhe auf
alle Zeilen angewendet.
Legt fest, ob AutoSizeMode Spaltenbreiten und Zeilenhöhen an den Zellinhalten ausrichtet.
Syntax
[VB]
Public enum AutoSizeSettings
[C#]
public sealed enum AutoSizeSettings : System.Enum
[Delphi]
type AutoSizeSettings = (flexAutoSizeColWidth, flexAutoSizeRowHeight);
Bemerkungen
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der AutoSizeMode-Eigenschaft in der
C1FlexGridClassic-Steuerung festzulegen.
Mitgliedsname Beschreibung
flexAutoSizeColWidth Der Nutzer kann die Breite von Spalten verändern.
flexAutoSizeRowHeight Der Nutzer kann die Höhe von Zeilen verändern.
CellCheckedSettings-Aufzählung
Legt den aktuellen Zustand eines Kontrollkästchens in einer Zelle oder in einem Auswahlbereich fest.
Syntax
[VB]
Public enum CellCheckedSettings

[C#]
public sealed enum CellCheckedSettings : System.Enum
[Delphi]
type CellCheckedSettings = (flexNoCheckbox, flexChecked, flexUnchecked);
Bemerkungen
CellPropertySettings-Aufzählung · 567
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der CellChecked-Eigenschaft in der
C1FlexGridClassic-Steuerung festzulegen.
Mitgliedsname Beschreibung
flexNoCheckbox Die Zelle besitzt kein Kontrollkästchen. (Standardeinstellung)
flexChecked Die Zelle besitzt ein Kontrollkästchen mit Häkchen.
flexUnchecked Die Zelle besitzt ein Kontrollkästchen ohne Häkchen.
CellPropertySettings-Aufzählung
Legt fest, wie ein Kontrollkästchen in einer Zelle erscheint.
Syntax
[VB]
Public enum CellPropertySettings
[C#]
public sealed enum CellPropertySettings: System.Enum
[Delphi]
type CellPropertySettings = (flexChecked, flexNoCheckbox, flexTSChecked, flexTSGrayed,
flexTSUnchecked, flexUnchecked);
Bemerkungen
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der get_Cell und set_Cell-Methoden und
der Item-Eigenschaft in der C1FlexGridClassic-Steuerung festzulegen.
Mitgliedsname Beschreibung
flexChecked Die Zelle hat ein Kontrollkästchen mit einem Häkchen drin.
flexNoCheckbox Die Zelle hat kein Kontrollkästchen.
flexTSChecked Die Zelle hat ein drei-Zustands-Kontrollkästchen mit einem Häkchen drin.
flexTSGrayed Die Zelle hat ein drei-Zustands-Kontrollkästchen im grauen Zustand.
flexTSUnchecked Die Zelle hat ein leeres drei-Zustands-Kontrollkästchen.
flexUnchecked Die Zelle hat ein leeres Kontrollkästchen.

568 · C1FlexGridClassic-Referenzverzeichnis
ClearWhatSettings-Aufzählung
Legt fest, was die Clear-Methode entfernen wird.
Syntax
[VB]
Public enum ClearWhatSettings
[C#]
public sealed enum ClearWhatSettings : System.Enum
[Delphi]
type ClearWhatSettings = (flexClearEverything, flexCleartext, flexClearFormatting; flexClearData);
Bemerkungen
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert eines Arguments der Clear-Methode in
der C1FlexGridClassic-Steuerung festzulegen.
Mitgliedsname Beschreibung
flexClearEverything Alles wird aus dem Bereich entfernt.
flexCleartext Nur Text wird aus dem Bereich entfernt.
flexClearFormatting Nur Formatierung wird aus dem Bereich entfernt.
flexClearData Nur Daten im Datenbereich werden aus dem Bereich entfernt.
ClearWhereSettings-Aufzählung
Legt fest, wo die Clear-Methode etwas entfernen wird.
Syntax
[VB]
Public enum ClearWhereSettings
[C#]
public sealed enum ClearWhereSettings : System.Enum
[Delphi]
type ClearWhereSettings = (flexClearEverywhere, flexClearScrollable, flexClearSelection);
Bemerkungen
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert eines Arguments der Clear-Methode in
der C1FlexGridClassic-Steuerung festzulegen.
Mitgliedsname Beschreibung
flexClearEverywhere Entfernt von gesamter Tabelle.
flexClearScrollable Entfernt nur vom scrollbaren Bereich der Tabelle.

flexClearSelection Entfernt vom ausgewählten Bereich.
EditableSettings-Aufzählung
Legt den Bearbeitungszustand in der Tabelle fest.
Syntax
[VB]
Public enum EditableSettings
[C#]
public sealed enum EditableSettings : System.Enum
[Delphi]
type EditableSettings = (flexEDNone, flexEDKbd, flexEDKbdMouse);
Bemerkungen
EditableSettings-Aufzählung · 569
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der Editable-Eigenschaft in der
C1FlexGridClassic-Steuerung festzulegen.
Mitgliedsname Beschreibung
flexEDNone Der Tabelleninhalt kann vom Nutzer nicht bearbeitet werden.
flexEDKbd
flexEDKbdMouse
EllipsisSettings-Aufzählung
Der Nutzer kann den Bearbeitungsmodus initialisieren, wenn er in die
aktuelle Zelle schreibt.
Der Nutzer kann den Bearbeitungsmodus initialisieren, wenn er in die
aktuelle Zelle schreibt oder mit der Maus darauf doppelklickt.
Legt fest, wie lang Zeichenketten in einer Zelle angezeigt werden.
Syntax
[VB]
Public enum EllipsisSettings
[C#]
public sealed enum EllipsisSettings : System.Enum
[Delphi]
type EllipsisSettings = (flexNoEllipsis, flexEllipsisEnd, flexEllipsisPath);
Bemerkungen
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der Ellipsis-Eigenschaft in der
C1FlexGridClassic-Steuerung festzulegen.

570 · C1FlexGridClassic-Referenzverzeichnis
Mitgliedsname Beschreibung
flexNoEllipsis
Lange Zeichenketten werden abgeschnitten und es werden keine
Ellipsis-Zeichen angezeigt.
flexEllipsisEnd Ellipsis-Zeichen werden am Ende von langen Zeichenketten angezeigt.
flexEllipsisPath Ellipsis-Zeichen werden in der Mitte von langen Zeichenketten angezeigt.
ExplorerBarSettings-Aufzählung
Legt die Eigenschaften der Spaltenüberschriften fest.
Syntax
[VB]
Public enum ExplorerBarSettings
[C#]
public sealed enum ExplorerBarSettings : System.Enum
[Delphi]
type ExplorerBarSettings = (flexExNone, flexExSort, flexExMove, flexExSortAndMove, flexExSortShow,
flexExSortShowAndMove, flexExMoveRows);
Bemerkungen
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der ExplorerBar-Eigenschaft in der
C1FlexGridClassic-Steuerung festzulegen.
Mitgliedsname Beschreibung
flexExNone Nutzer können Spalten weder sortieren noch verschieben.
flexExSort Nutzer können Spalten sortieren.
flexExMove Nutzer können Spalten verschieben.
flexExSortAndMove Nutzer können Spalten sortieren und verschieben.
flexExSortShow
flexExSortShowAndMove
flexExMoveRows*
Nutzer können Spalten mit einem Klick auf deren Überschirft sortieren. Die
Steuerung zeigt die aktuelle Sortierungsrichtung mit einem Pfeil in der
Spaltenüberschrift an.
Nutzer können Spalten sortieren und verschieben. Die Steuerung zeigt die
aktuelle Sortierungsrichtung mit einem Pfeil in der Spaltenüberschrift an.
Nutzer können Zeilen verschieben, indem sie die fixierten Zellen der
entsprechenden Zeile auf eine neue Position ziehen.
* Die Einstellung flexExMoveRows ist eigentlich ein Flag und kann mit anderen Einstellungen durch eine
„Or“-Anweisung verknüpft werden.

FillStyleSettings-Aufzählung
FillStyleSettings-Aufzählung · 571
Legt fest, ob die Eigenschaften auf die aktuelle Zelle oder die gesamte Auswahl angewendet wird.
Syntax
[VB]
Public enum FillStyleSettings
[C#]
public sealed enum FillStyleSettings : System.Enum
[Delphi]
type FillStyleSettings = (flexFillSingle, flexFillRepeat);
Bemerkungen
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der FillStyle-Eigenschaft in der
C1FlexGridClassic-Steuerung festzulegen.
Mitgliedsname Beschreibung
flexFillSingle
flexFillRepeat
GridStyleSettings-Aufzählung
Das Setzen der Text- oder einer beliebigen Zellformatierungseigenschaft betrifft nur
die aktuelle Zelle.
Das Setzen der Text- oder einer beliebigen Zellformatierungseigenschaft betrifft den
gesamten, aktuell ausgewählten Bereich.
Legt das Linienformat der Gitternetzlinien fest.
Syntax
[VB]
Public enum GridStyleSettings
[C#]
public sealed enum GridStyleSettings : System.Enum
[Delphi]
type GridStyleSettings = (flexGridNone, flexGridFlat, flexGridInset, flexGridRaised, flexGridFlatHorz,
flexGridInsetHorz, flexGridRaisedHorz, flexGridSkipHorz, flexGridFlatVert, flexGridInsetVert,
flexGridRaisedVert, flexGridSkipVert, flexGridExplorer, flexGridExcel);
Bemerkungen
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der GridLines- und GridLinesFixed-
Eigenschaften in der C1FlexGridClassic-Steuerung festzulegen.

572 · C1FlexGridClassic-Referenzverzeichnis
Mitgliedsname Beschreibung
flexGridNone Zeichnet keine Gitternetzlinien zwischen Zellen.
flexGridFlat
Zeichnet flache Linien mit der Farbe und der Breite aus den GridColor- und
GridLineWidth-Eigenschaften.
flexGridInset Zeichnet eingelassene Linien zwischen Zellen.
flexGridRaised Zeichnet herausgehobene Linien zwischen Zellen.
flexGridFlatHorz Zeichnet flache Linien zwischen Zeilen und keine Linien zwischen Spalten.
flexGridInsetHorz
flexGridRaisedHorz
Zeichnet eingelassene Linien zwischen Zeilen und keine Linien zwischen
Spalten.
Zeichnet herausgehobene Linien zwischen Zeilen und keine Linien zwischen
Spalten
flexGridSkipHorz Zeichnet eingelassene Linien um jede zweite Zeile.
flexGridFlatVert Zeichnet flache Linien zwischen Spalten und keine Linien zwischen Zeilen.
flexGridInsetVert
flexGridRaisedVert
Zeichnet eingelassene Linien zwischen Spalten und keine Linien zwischen
Zeilen.
Zeichnet herausgehobene Linien zwischen Spalten und keine Linien zwischen
Zeilen.
flexGridSkipVert Zeichnet eingelassene Linien um jede zweite Spalte.
flexGridExplorer Zeichnet schaltflächenähnliche Rahmen um jede Zelle.
flexGridExcel
MergeSettings-Aufzählung
Legt fest, wie Zellen verbunden werden.
Syntax
[VB]
Public enum MergeSettings
[C#]
Zeichnet schaltflächenähnliche Rahmen um jede Zelle und markiert die
Überschriften für die aktuelle Auswahl. Diese Einstellung sollte nur für die
GridLinesFixed-Eigenschaft verwendet werden.
public sealed enum MergeSettings : System.Enum
[Delphi]
type MergeSettings = (flexMergeNever, flexMergeFree, flexMergeRestrictRows,
flexMergeRestrictColumns, flexMergeRestrictAll, flexMergeFixedOnly, flexMergeSpill,
flexMergeOutline);
Bemerkungen
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der MergeCells-Eigenschaft in der
C1FlexGridClassic-Steuerung festzulegen.

Mitgliedsname Beschreibung
flexMergeNever Zellen nicht verbinden.
flexMergeFree
OutlineBarSettings-Aufzählung · 573
Angrenzende Zellen mit gleichem Inhalt verbinden, wenn diese sich in
Zeilen mit RowMerge=TRUE oder Spalten mit MergeCol=TRUE befinden.
flexMergeRestrictRows Zeilen verbinden, wenn die Zellen darüber auch verbunden sind.
flexMergeRestrictColumns Spalten verbinden, wenn die Zellen links davon auch verbunden sind.
flexMergeRestrictAll
flexMergeFixedOnly
Zellen verbinden, wenn die Zellen darüber und links davon auch
verbunden sind.
Nur fixierte Zellen verbinden. Diese Einstellung ist für komplexe
Überschriften sinnvoll, ohne dabei die Datenzellen selbst zu verbinden.
flexMergeSpill Langen Einträgen erlauben, in leere, angrenzende Zellen überzugehen.
flexMergeOutline
OutlineBarSettings-Aufzählung
Einträgen in Zwischensummenzeilen erlauben, in leere, angrenzende
Zellen überzugehen. Diese Einstellung ist sinnvoll, wenn Sie nur
Knotennamen in den Gliederungsknoten anzeigen wollen und die Daten in
regulären Zeilen stehen.
Legt das Format der Gliederungsleiste, wie in der OutlineBar-Eigenschaft definiert, fest.
Syntax
[VB]
Public enum OutlineBarSettings
[C#]
public sealed enum OutlineBarSettings: System.Enum
[Delphi]
type OutlineBarSettings = (flexOutlineBarComplete, flexOutlineBarCompleteLeaf, flexOutlineBarNone,
flexOutlineBarSimple, flexOutlineBarSimpleLeaf, flexOutlineBarSymbols, flexOutlineBarSymbolsLeaf);
Bemerkungen
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der OutlineBar-Eigenschaft in der
C1FlexGridClassic-Steuerung festzulegen.
Mitgliedsname Beschreibung
flexOutlineBarComplete
flexOutlineBarCompleteLeaf
Der vollständige Gliederungsbaum und eine Schaltflächenzeile darüber
wird angezeigt. Schaltflächen werden nur angezeigt, wenn die
Gliederungsleiste in einer fixierten Spalte steht.
Ähnlich der flexOutlineBarComplete, aber leere Knoten werden ohne
Symbol angezeigt.
flexOutlineBarNone Die Gliederungsleiste wird nicht angezeigt.

574 · C1FlexGridClassic-Referenzverzeichnis
flexOutlineBarSimple
flexOutlineBarSimpleLeaf
Der vollständige Gliederungsbaum aber keine Schaltflächenzeile wird
angezeigt.
Ähnlich der flexOutlineBarSimple, aber leere Knoten werden ohne
Symbol angezeigt.
flexOutlineBarSymbols Gliederungssymbole, aber keine Verknüpfungslinien werden angezeigt.
flexOutlineBarSymbolsLeaf
PictureAlignmentSettings-Aufzählung
Legt fest, wie Grafiken in Zellen ausgerichtet werden.
Syntax
[VB]
Public enum PictureAlignmentSettings
[C#]
public sealed enum PictureAlignmentSettings : System.Enum
[Delphi]
Ähnlich der flexOutlineBarSymbols, aber leere Knoten werden ohne
Symbol angezeigt.
type PictureAlignmentSettings = (flexPicAlignLeftTop, flexPicAlignLeftCenter, flexPicAlignLeftBottom,
flexPicAlignCenterTop, flexPicAlignCenterCenter, flexPicAlignCenterBottom, flexPicAlignRightTop,
flexPicAlignRightCenter, flexPicAlignRightBottom, flexPicAlignStretch, flexPicAlignTile);
Bemerkungen
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der CellPictureAlignment-Eigenschaft in
der C1FlexGridClassic-Steuerung festzulegen.
Mitgliedsname Beschreibung
flexPicAlignLeftTop Richtet Grafiken links oben aus.
flexPicAlignLeftCenter Richtet Grafiken links zentriert aus.
flexPicAlignLeftBottom Richtet Grafiken links unten aus.
flexPicAlignCenterTop Richtet Grafiken zentriert oben aus.
flexPicAlignCenterCenter Richtet Grafiken zentriert aus.
flexPicAlignCenterBottom Richtet Grafiken zentriert unten aus.
flexPicAlignRightTop Richtet Grafiken rechts oben aus.
flexPicAlignRightCenter Richtet Grafiken rechts zentriert aus.
flexPicAlignRightBottom Richtet Grafiken rechts unten aus.
flexPicAlignStretch Streckt das Bild, damit es die Zelle ausfüllt.
flexPicAlignTile
Ordnet die Grafik nebeneinander an, um die Zelle
auszufüllen.

RedrawSettings-Aufzählung
Legt fest, ob die Tabelle ihre Inhalte zeichnen soll.
Syntax
[VB]
Public enum RedrawSettings
[C#]
public sealed enum RedrawSettings : System.Enum
[Delphi]
type RedrawSettings = (flexRDBuffered, flexRDDirect, flexRDNone);
Bemerkungen
RedrawSettings-Aufzählung · 575
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der Redraw-Eigenschaft in der
C1FlexGridClassic-Steuerung festzulegen.
Mitgliedsname Beschreibung
flexRDBuffered
flexRDDirect
Die Tabelle zeichnet ihren Inhalt in einem off-screen Puffer und transferiert das
komplette Abbild auf den Bildschirm. Dieser Modus ist etwas langsamer als
flexRDDirect, aber er verhindert das Flackern des Bildschirms.
Die Tabelle zeichnet ihren Inhalt direkt auf den Bildschirm. Dies ist der schnellste
Modus für das Zeichnen der Tabelleninhalte, dafür kann gelegentlich aber ein leichtes
Flackern auftreten.
flexRDNone Die Tabelle zeichnet sich nicht selbst neu.
SelModeSettings-Aufzählung
Legt fest, wie Auswahlen getroffen werden können.
Syntax
[VB]
Public enum SelModeSettings
[C#]
public sealed enum SelModeSettings: System.Enum
[Delphi]
type SelModeSettings = (flexSelectionByColumn, flexSelectionByRow, flexSelectionFree,
flexSelectionListBox);
Bemerkungen
Verwenden Sie die Mitglieder dieser Aufzählung um den Wert der SelectionMode-Eigenschaft in der
C1FlexGridClassic-Steuerung festzulegen.

576 · C1FlexGridClassic-Referenzverzeichnis
Mitgliedsname Beschreibung
flexSelectionByColumn
flexSelectionByRow
Zwingt die Auswahl, sich auf die gesamte Spalte auszuweiten. Dies ist für
Diagrammbereiche oder zu sortierende Felder nützlich.
Zwingt die Auswahl, sich auf die gesamte Zeile auszuweiten. Dies ist für die
Implementierung von datensatzbasierender Anzeige nützlich.
flexSelectionFree Auswahlen können wie üblich getroffen werden.
flexSelectionListBox
SortSettings-Aufzählung
Legt fest, wie eine Spalte sortiert wird.
Syntax
[VB]
Public enum SortSettings
[C#]
public sealed enum SortSettings : System.Enum
[Delphi]
Ähnlich wie flexSelectionByRow, aber es können auch unterbrochene
Auswahlen getroffen werden. Strg-Taste halten und mit der Maus klicken
schaltet die Auswahl für eine einzelne Zeile um. Die Maus über eine Gruppe
von Zeilen zu ziehen, schaltet deren Auswahlzustand um.
type SortSettings = (flexSortNone, flexSortGenericAscending, flexSortGenericDescending,
flexSortNumericAscending, flexSortNumericDescending, flexSortStringNoCaseAscending,
flexSortStringNoCaseDescending, flexSortStringAscending, flexSortStringDescending, flexSortCustom,
flexSortUseColSort);
Bemerkungen
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der Sort-Eigenschaft in der
C1FlexGridClassic-Steuerung festzulegen.
Mitgliedsname Beschreibung
flexSortNone
Ignoriert die Spalte, wenn sortiert wird. Diese Einstellung ist
nützlich, wenn Sie diese der Cols-Eigenschaft einer Spalte
zuordnen und dann Sort auf flexSortUseColSort stellen.
flexSortGenericAscending Sortiert Zeichenketten und Zahlen aufsteigend.
flexSortGenericDescending Sortiert Zeichenketten und Zahlen absteigend.
flexSortNumericAscending Sortiert Zahlen aufsteigend.
flexSortNumericDescending Sortiert Zahlen absteigend.
flexSortStringNoCaseAscending
flexSortStringNoCaseDescending
Sortiert Zeichenketten ohne Rücksicht auf Groß- und
Kleinschreibung aufsteigend.
Sortiert Zeichenketten ohne Rücksicht auf Groß- und
Kleinschreibung absteigend.
flexSortStringAscending Sortiert Zeichenketten aufsteigend.

Mitgliedsname Beschreibung
flexSortStringDescending Sortiert Zeichenketten absteigend.
flexSortCustom
flexSortUseColSort
TabBehaviorSettings-Aufzählung
TabBehaviorSettings-Aufzählung · 577
Startet ein Compare-Ereignis und verwendet den Rückgabewert,
um eine Spalte zu sortieren.
Mit dieser Einstellung können Sie verschiedene
Sortierungsrichtungen für einzelne Spalten mit der ColSort-
Eigenschaft einstellen.
Legt die Flussrichtung der Steuerungen fest, wenn die Tabulator-Taste gedrückt wird.
Syntax
[VB]
Public enum TabBehaviorSettings
[C#]
public sealed enum TabBehaviorSettings : System.Enum
[Delphi]
type TabBehaviorSettings = (flexTabControls, flexTabCells);
Bemerkungen
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der TabBehavior-Eigenschaft in der
C1FlexGridClassic-Steuerung festzulegen.
Mitgliedsname Beschreibung
flexTabControls
flexTabCells
TextStyleSettings-Aufzählung
Legt das Textformat fest.
Syntax
[VB]
Public enum TextStyleSettings
[C#]
Die Tabulator-Taste wird verwendet, um zur nächsten oder vorhergehenden
Steuerung im Formular zu gehen.
Die Tabulator-Taste wird verwendet, um zur nächsten oder vorhergehenden Zelle auf
der Steuerung zu gehen.
public sealed enum TextStyleSettings : System.Enum

578 · C1FlexGridClassic-Referenzverzeichnis
[Delphi]
type TextStyleSettings = (flexTextFlat, flexTextRaised, flexTextInset, flexTextRaisedLight,
flexTextInsetLight);
Bemerkungen
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der CellTextStyle, TextStyle und
TextStyleFixed-Eigenschaften in der C1FlexGridClassic-Steuerung festzulegen.
Mitgliedsname Beschreibung
flexTextFlat Zeichnet Text normal.
flexTextRaised Zeichnet Text mit einem stark gehobenen 3D-Effekt.
flexTextInset Zeichnet Text mit einem stark eingelassenen 3D-Effekt.
flexTextRaisedLight Zeichnet Text mit einem schwach gehobenen 3D-Effekt.
flexTextInsetLight Zeichnet Text mit einem schwach eingelassenen 3D-Effekt.

Index
A
AddItem-Methode 174
Add-Method
von ColumnCollection 325
Add-Methode 315, 325, 380
von CellStyleCollection 380
von RowCollection 315
AddNode-Methode 409
AfterAddRow-Ereignis 221
AfterCollapse-Ereignis 221
AfterDataRefresh-Ereignis 222
AfterDeleteRow-Ereignis 223
AfterDragColumn-Ereignis 223
AfterDragRow-Ereignis 224
AfterEdit-Ereignis 225
AfterFreezeColumn-Ereignis 225
AfterFreezeRow-Ereignis 226
AfterResizeColumn-Ereignis 227
AfterResizeRow-Ereignis 227
AfterRowColChange-Ereignis 228
AfterScroll-Ereignis 229
AfterSelChange-Ereignis 231
AfterSort-Ereignis 231
Aggregate-Methode 176
AlignmentSettings-Aufzählung 574
AllowAddNew-Eigenschaft 117
AllowBigSelection-Eigenschaft 464
AllowDelete-Eigenschaft 118
AllowDragging-Eigenschaft 119, 331, 348, 465
von C1FlexGridClassic 465
von Column 348
von Row 331
AllowEditing-Eigenschaft 120, 332, 348, 466
von C1FlexGrid 120
von C1FlexGridClassic 466
von Column 348
von Row 332
AllowFreezing-Eigenschaft 120
AllowMerging-Eigenschaft 121, 332, 349, 467
von C1FlexGridClassic 467
von Column 349
von Row 332
AllowResizing-Eigenschaft 122, 333, 349, 468
von C1FlexGridClassic 468
von Column 349
von Row 333
AllowSelection-Eigenschaft 469
AllowSorting-Eigenschaft 124, 350, 470
von C1FlexGrid 124
von C1FlexGridClassic 470
von Column 350
AllowUserResizeSettings-Aufzählung 575
AllowUserResizing-Eigenschaft 471
Alternate-Eigenschaft 374
AutoClipboard-Eigenschaft 125
AutoResize-Eigenschaft 126
AutoSearchDelay-Eigenschaft 127
AutoSearch-Eigenschaft 126
AutoSizeCol-Methode 178
AutoSizeCols-Methode 179
AutoSize-Methode 535
AutoSizeMode-Eigenschaft 472
AutoSizeRow-Methode 180
AutoSizeRows-Methode 180
AutoSizeSettings-Aufzählung 576
B
BackColorAlternate-Eigenschaft 473
BackColorBkg-Eigenschaft 473
BackColor-Eigenschaft 386
BackColorFixed-Eigenschaft 474
BackColorSel-Eigenschaft 474
BackgroundImage-Eigenschaft 475
BeforeAddRow-Ereignis 232
BeforeAutoSizeColumn-Ereignis 233
BeforeAutoSizeRow-Ereignis 233
BeforeCollapse-Ereignis 234
BeforeDeleteRow-Ereignis 237
BeforeDragColumn-Ereignis 237
BeforeDragRow-Ereignis 238
BeforeEdit-Ereignis 239
BeforeFreezeColumn-Ereignis 241
BeforeFreezeRow-Ereignis 241
BeforeMouseDown-Ereignis 242
BeforeMouseDownEventArgs-Klasse 289
BeforeMouseDownEventHandler-Delegierer 281
BeforePageBreak-Ereignis 243
BeforeResizeColumn-Ereignis 245
BeforeResizeRow-Ereignis 245
BeforeRowColChange-Ereignis 246
BeforeScroll-Ereignis 247
BeforeScrollTip-Ereignis 248
BeforeSelChange-Ereignis 249
Index · 579

580 · Index
BeforeSort-Ereignis 250
BeginPrint-Ereignis 251
Border-Eigenschaft 387
BorderStyle-Eigenschaft 128
Bottom-Eigenschaft 333
BottomRow-Eigenschaft 127, 298
von CellRange 298
BuildString-Methode 381, 397
von CellStyle 397
C
CancelAddRow-Ereignis 251
Caption-Eigenschaft 334, 350
von Row 334
CellAlignment-Eigenschaft 475
CellBackColor-Eigenschaft 477
CellButtonClick-Ereignis 252
CellButtonImage-Eigenschaft 128, 478
von C1FlexGridClassic 478
CellButtonPicture-Eigenschaft 479
CellChanged-Ereignis 252
CellChecked-Eigenschaft 479
CellCheckedSettings-Aufzählung 576
Cell-Eigenschaft 475
CellFontBold-Eigenschaft 482
CellFont-Eigenschaft 481
CellFontItalic-Eigenschaft 482
CellFontName-Eigenschaft 483
CellFontSize-Eigenschaft 483
CellFontStrikeThru-Eigenschaft 484
CellFontUnderline-Eigenschaft 485
CellForeColor-Eigenschaft 485
CellHeight-Eigenschaft 486
CellLeft-Eigenschaft 486
CellPictureAlignment-Eigenschaft 487
CellPicture-Eigenschaft 487
CellPropertySettings-Aufzählung 577
CellTextStyle-Eigenschaft 488
CellTop-Eigenschaft 489
CellWidth-Eigenschaft 490
ChangeEdit-Ereignis 253
CheckBox-Eigenschaft 298
Children-Eigenschaft 404
Clear-Methode 181, 345, 371, 382, 398, 536
von C1FlexGrid 181
von CellStyle 398
von CellStyleCollection 382
von Column 371
von Row 345
ClearUnused-Methode 382
ClearWhatSettings-Aufzählung 578
ClearWhereSettings-Aufzählung 578
Clip-Eigenschaft 129, 299
von CellRange 299
ClipSeparators-Eigenschaft 130
Col-Eigenschaft 131
Collapsed-Eigenschaft 405
Color-Eigenschaft 402
Cols-Eigenschaft 132, 490
von C1FlexGridClassic 490
ColSel-Eigenschaft 132
ColumnCollection-Eigenschaft 491
Column-Eigenschaft 307, 415
von HitTestInfo 307
ColWidthMax-Eigenschaft 491
ColWidthMin-Eigenschaft 492
ComboCloseUp-Ereignis 256
ComboCount-Eigenschaft 493
ComboDropDown-Ereignis 256
ComboIndex-Eigenschaft 493
ComboItem-Methode 538
ComboList-Eigenschaft 133, 351, 387
von CellStyle 387
von Column 351
ContainsCol-Methode 306
Contains-Methode 305, 315, 325, 383
von CellRange 305
von CellStyleCollection 383
von ColumnCollection 325
von RowCollection 315
ContainsRow-Methode 306
Count-Eigenschaft 310, 321, 375
von CellStyleCollection 375
von ColumnCollection 321
von RowCollection 310
CreateImage-Methode 182
CursorCell-Eigenschaft 136
CustomComparer-Eigenschaft 136
D
DataDisplay-Eigenschaft 300
Data-Eigenschaft 299, 405
von CellRange 299
von Node 405
DataIndex-Eigenschaft 334, 351
von Column 351
von Row 334
DataMap-Eigenschaft 352, 388
von CellStyle 388
von Column 352
DataMember-Eigenschaft 137
DataSource-Eigenschaft 137, 335

von C1FlexGrid 137
von Row 335
DataType-Eigenschaft 353
DefaultSize-Eigenschaft 311, 321
von ColumnCollection 321
von RowCollection 311
DefinedElements-Eigenschaft 388
Direction-Eigenschaft 401
Display-Eigenschaft 389
DoubleBuffer-Eigenschaft 140
DragMode-Eigenschaft 141
DragRowColEventArgs-Klasse 289
DragRowColEventHandler-Delegierer 282
DrawCell-Methode 184
DrawMode-Eigenschaft 141
DropMode-Eigenschaft 142
E
Editable-Eigenschaft 493
EditableSettings-Aufzählung 579
EditCell-Methode 538
EditMask-Eigenschaft 143, 355, 390
von C1FlexGrid 143
von Column 355
EditOptions-Eigenschaft 146
Editor-Eigenschaft 144, 335, 356, 375, 389
von C1FlexGrid 144
von CellStyle 389
von CellStyleCollection 375
von Column 356
von Row 335
EditSelLength-Eigenschaft 494
EditSelStart-Eigenschaft 496
EditSelText-Eigenschaft 497
EditText-Eigenschaft 498
EditWindow-Eigenschaft 499
Ellipsis-Eigenschaft 500
EllipsisSettings-Aufzählung 579
EmptyArea-Eigenschaft 376
EndPrint-Ereignis 257
EnsureVisible-Methode 410
EnterCell-Ereignis 258
Expanded-Eigenschaft 406
ExplorerBar-Eigenschaft 501
ExplorerBarSettings-Aufzählung 580
ExtendLastCol-Eigenschaft 146
F
FillStyle-Eigenschaft 503
FillStyleSettings-Aufzählung 581
FindRow-Methode 185, 539
von C1FlexGridClassic 539
FinishEditing-Methode 186
FixedCols-Eigenschaft 503
Fixed-Eigenschaft 311, 322, 376
von CellStyleCollection 376
von ColumnCollection 322
von RowCollection 311
FixedRows-Eigenschaft 504
Focus-Eigenschaft 377
FocusRect-Eigenschaft 147
FontBold-Eigenschaft 505
Font-Eigenschaft 391
von CellStyle 391
FontItalic-Eigenschaft 505
FontName-Eigenschaft 506
FontSize-Eigenschaft 506
FontStrikeThru-Eigenschaft 507
FontUnderline-Eigenschaft 507
Footer-Eigenschaft 422
FooterFont-Eigenschaft 423
ForeColor-Eigenschaft 391
ForeColorFixed-Eigenschaft 507
ForeColorSel-Eigenschaft 508
Format-Eigenschaft 356, 392
von CellStyle 392
FrozenCols-Eigenschaft 508
Frozen-Eigenschaft 312, 322, 376
von ColumnCollection 322
von RowCollection 312
FrozenRows-Eigenschaft 509
G
get_Cell-Methode 540
get_ColAlignment-Methode 541
get_ColComboList-Methode 542
get_ColData-Methode 542
get_ColDataType-Methode 542
get_ColEditMask-Methode 543
get_ColFormat-Methode 543
get_ColHidden-Methode 544
get_ColIndent-Methode 544
get_ColIndex-Methode 544
get_ColIsVisible-Methode 545
get_ColKey-Methode 545
get_ColPos-Methode 546
get_ColSort-Methode 546
get_ColWidth-Methode 546
get_FixedAlignment-Methode 547
get_IsCollapsed-Methode 547
get_IsSelected-Methode 547
Index · 581

582 · Index
get_IsSubtotal-Methode 548
get_MergeCol-Methode 549
get_MergeRow-Methode 551
get_RowData-Methode 553
get_RowHeight-Methode 553
get_RowHidden-Methode 554
get_RowIsVisible-Methode 554
get_RowOutlineLevel-Methode 554
get_RowPos-Methode 555
get_TextMatrix-Methode 557
Get_ValueMatrix-Methode 557
GetCellCheck-Eigenschaft 147
GetCellCheck-Methode 187
GetCellImage-Methode 188
GetCellRange-Methode 189, 410
von Node 410
GetCellRect-Methode 190
GetCellStyleDisplay-Methode 192
GetCellStyle-Methode 191
GetDataDisplay-Methode 193
GetData-Methode 192
GetMergedRange Methode
von C1FlexGrid 194
GetMergedRange-Methode 194, 549
GetNode-Methode 411, 551
vom C1FlexGridClassic 551
GetNodeRow-Methode 552
GetSelection-Methode 555
GetUnboundValue-Ereignis 259
Glyphs-Eigenschaft 148
GridChanged-Ereignis 262
GridChangedEventArgs-Klasse 290
GridChangedEventHandler-Delegierer 282
GridColor-Eigenschaft 509
GridColorFixed-Eigenschaft 510
GridError-Ereignis 263
GridErrorEventArgs-Klasse 290
GridErrorEventHandler-Delegierer 283
GridLines-Eigenschaft 510
GridLinesFixed-Eigenschaft 511
GridLineWidth-Eigenschaft 512
GridStyleSettings-Aufzählung 581
H
Header-Eigenschaft 424
HeaderFont-Eigenschaft 425
HeightDisplay-Eigenschaft 337
Height-Eigenschaft 336
HighLight-Eigenschaft 148, 377
von CellStyleCollection 377
HitTest-Methode 195
I
ImageAlign-Eigenschaft 337, 359, 392
von CellStyle 392
von Column 359
von Row 337
ImageAlignFixed-Eigenschaft 337, 359
von Column 359
von Row 337
ImageAndText-Eigenschaft 360
Image-Eigenschaft 300, 407
von Node 407
ImageMap-Eigenschaft 360, 393
von Column 360
ImageSpacing-Eigenschaft 393
Indent-Eigenschaft 416
Index-Eigenschaft 338, 362
von Column 362
von Row 338
Insert-Methode 316, 326
von ColumnCollection 326
von RowCollection 316
InsertNode-Methode 316
InsertRange-Methode 317, 326
von ColumnCollection 326
von RowCollection 317
Invalidate-Methode 197
IsNew-Eigenschaft 339
IsNode-Eigenschaft 339
IsSingleCell-Eigenschaft 301
IsValid-Eigenschaft 301
Item-Eigenschaft 149, 312, 322, 378, 414, 574
von Cell 574
von CellStyleCollection 378
von ColumnCollection 322
von GridGlyphs 414
von RowCollection 312
K
KeyActionEnter-Eigenschaft 150, 513
von C1FlexGridClassic 513
KeyActionTab-Eigenschaft 151, 513
von C1FlexGridClassic 513
KeyDownEdit-Ereignis 264
KeyEditEventArgs-Klasse 291
KeyEditEventHandler-Delegierer 283
Key-Eigenschaft 408
KeyPressEdit-Ereignis 265
KeyPressEditEventArgs-Klasse 292
KeyPressEditEventHandler-Delegierer 284
KeyUpEdit-Ereignis 266

Klasse
CellBorder-Klasse 401
CellStyleCollection-Klasse 373
CellStyle-Klasse 384
ColumnCollection-Klasse 320
Column-Klasse 346
DragRowColEventArgs-Klasse 289
GridChangedEventArgs-Klasse 290
GridErrorEventArgs-Klasse 290
GridGlyphs-Klasse 414
GridPrinter-Klasse 421
GridTree-Klasse 415
HitTestInfo-Klasse 307
KeyEditEventArgs-Klasse 291
KeyPressEditEventArgs-Klasse 292
OwnerDrawCellEventArgs-Klasse 292
RangeEventArgs-Klasse 293
RowColEventArgs-Klasse 294
RowCollection-Klasse 309
Row-Klasse 330
SortColEventArgs-Klasse 294
ValidateEditEventArgs-Klasse 295
Klassen
C1FlexGrid-Klasse 109
L
LeaveCell-Ereignis 268
LeftCol-Eigenschaft 153, 302
von CellRange 302
Left-Eigenschaft 362
Level-Eigenschaft 408
LineColor-Eigenschaft 416
LineStyle-Eigenschaft 417
LoadExcel-Methode 198
LoadExcelSheetNames-Methode 199
LoadGrid-Methode 199
M
Margins-Eigenschaft 394
MaxSize-Eigenschaft 313, 323
von ColumnCollection 323
von RowCollection 313
MergeCells-Eigenschaft 515
MergeSettings-Aufzählung 582
MergeWith-Methode 398
MinSize-Eigenschaft 313, 324
von ColumnCollection 324
von RowCollection 313
MouseCol-Eigenschaft 154
MouseRow-Eigenschaft 155
Move-Methode 317, 327, 345, 372, 411
von Column 372
von ColumnCollection 327
von Row 345
von RowCollection 317
MoveRange-Methode 318, 327
von ColumnCollection 327
von RowCollection 318
N
Name-Eigenschaft 363, 394
von CellStyle 394
von Column 363
NewRow-Eigenschaft 378
NodeClosedPicture-Eigenschaft 519
Node-Eigenschaft 340
NodeImageCollapsed-Eigenschaft 417
NodeImageExpanded-Eigenschaft 418
NodeOpenPicture-Eigenschaft 519
Normal-Eigenschaft 379
Normalize-Methode 307
O
OutlineBar-Eigenschaft 520
OutlineBarSettings-Aufzählung 583
OutlineCol-Eigenschaft 521
Outline-Methode 558
OwnerDrawCell-Ereignis 269
OwnerDrawCellEventArgs-Klasse 292
OwnerDrawCellEventHandler-Delegierer 284
P
PageCount-Eigenschaft 426
PageNumber-Eigenschaft 425
ParseString-Methode 383, 399
von CellStyle 399
von CellStyleCollection 383
PictureAlignmentSettings-Aufzählung 584
Picture-Eigenschaft 521
PrintDocument-Eigenschaft 426
PrintEventHandler-Delegierer 285
PrintGrid-Methode 200, 559
von C1FlexGridClassic 559
PrintPage-Ereignis 273
PrintPageEventHandler-Delegierer 285
PrintParameters-Eigenschaft 156
PrintPreviewDialog-Eigenschaft 427
Index · 583

584 · Index
R
r1,c1,r2,c2-Eigenschaft 302
RangeEventArgs-Klasse 293
RangeEventHandler-Delegierer 286
Redraw-Eigenschaft 156, 522
von C1FlexGridClassic 522
RedrawSettings-Aufzählung 585
RemoveItem-Methode 202, 560
C1FlexGrid 202
von C1FlexGridClassic 560
Remove-Methode 318, 328, 384
von CellStyleCollection 384
von ColumnCollection 328
von RowCollection 318
RemoveNode-Methode 412
RemoveRange-Methode 319, 328
von ColumnCollection 328
von RowCollection 319
Render-Methode 400
RightCol-Eigenschaft 157, 302
von CellRange 302
Right-Eigenschaft 363
RowColChange-Ereignis 273
RowColEventArgs-Klasse 294
RowColEventHandler-Delegierer 287
Row-Eigenschaft 158, 308, 409
von HitTestInfo 308
von Node 409
RowHeightMax-Eigenschaft 523
RowHeightMin-Eigenschaft 523
Rows-Eigenschaft 159, 524
von C1FlexGridClassic 524
RowSel-Eigenschaft 159
S
SafeIndex-Eigenschaft 340, 364
von Column 364
von Row 340
SaveExcel-Methode 202
SaveGrid-Methode 204
ScrollBars-Eigenschaft 160
ScrollPosition-Eigenschaft 162
ScrollTips-Eigenschaft 164
ScrollTipText-Eigenschaft 167
ScrollTrack-Eigenschaft 164
Search-Eigenschaft 380
SelChange-Ereignis 274
Selected-Eigenschaft 314, 324, 341, 364
von Column 364
von Row 341
von RowCollection 314
SelectedRow-Methode 561
SelectedRows-Eigenschaft 525
Selection-Eigenschaft 167
SelectionMode-Eigenschaft 168, 526
von C1FlexGridClassic 526
Select-Methode 205, 412
von Node 412
SelModeSettings-Aufzählung 585
set_Cell-Methode 561
set_ColAlignment-Methode 562
set_ColComboList-Methode 563
set_ColData-Methode 564
set_ColDataType-Methode 564
set_ColEditMask-Methode 564
set_ColFormat-Methode 565
set_ColHidden-Methode 565
set_ColImageList-Methode 565
set_ColIndent-Methode 566
set_ColKey-Methode 566
set_ColPosition-Methode 567
set_ColSort-Methode 567
set_ColWidth-Methode 567
set_FixedAlignment-Methode 568
set_IsCollapsed-Methode 568
set_IsSelected-Methode 569
set_IsSubtotal-Methode 569
set_MergeCol-Methode 570
set_MergeRow-Methode 570
set_RowData-Methode 571
set_RowHeight-Methode 571
set_RowHidden-Methode 572
set_RowOutlineLevel-Methode 572
set_RowPosition-Methode 573
set_TextMatrix-Methode 573
SetCellCheck-Eigenschaft 169
SetCellCheck-Methode 208
SetCellImage-Methode 206
SetCellStyle-Methode 207
SetDataBinding-Methode 211
SetData-Methode 209
SetUnboundValue-Ereignis 274
SetupEditor-Ereignis 275
SheetBorder-Eigenschaft 526
ShowButtons-Eigenschaft 169
ShowCell-Methode 212
ShowCursor-Eigenschaft 170
ShowErrors-Eigenschaft 171
Show-Methode 419
ShowSortAt-Methode 212
SortColEventArgs-Klasse 294

SortColEventHandler-Delegierer 288
Sort-Eigenschaft 365, 527
von C1FlexGridClassic 527
von Column 365
Sort-Methode 213, 413, 419
von GridTree 419
von Node 413
SortSettings-Aufzählung 586
StartEdit-Ereignis 278
StartEditing-Methode 215
StyleDisplay-Eigenschaft 303, 342, 366
von CellRange 303
von Column 366
von Row 342
Style-Eigenschaft 303, 341, 365, 402, 418
von CellRange 303
von Column 365
von GridTree 418
von Row 341
StyleFixedDisplay-Eigenschaft 367
StyleFixed-Eigenschaft 366
StyleFixedNew-Eigenschaft 367
StyleNew-Eigenschaft 304, 342, 368
von CellRange 304
von Column 368
von Row 342
Styles-Eigenschaft 172, 528
von C1FlexGridClassic 528
Subtotal-Methode 217
SubTotalPosition-Eigenschaft 172
T
TabBehavior-Eigenschaft 529
TabBehaviorSettings-Aufzählung 587
TextAlign-Eigenschaft 368, 394
von CellStyle 394
von Column 368
TextAlignFixed-Eigenschaft 369
TextDirection-Eigenschaft 395
TextEffect-Eigenschaft 395
Text-Eigenschaft 530
TextStyle-Eigenschaft 531
TextStyleFixed-Eigenschaft 532
TextStyleSettings-Aufzählung 588
Top-Eigenschaft 343
TopRow-Eigenschaft 173, 304
von CellRange 304
TreeColor-Eigenschaft 533
Tree-Eigenschaft 173
Trimming-Eigenschaft 396
Type-Eigenschaft 308
U
von HitTestInfo 308
UserData-Eigenschaft 305, 343, 369, 396
von CellRange 305
von CellStyle 396
von Column 369
von Row 343
V
ValidateEdit-Ereignis 279
ValidateEditEventArgs-Klasse 295
ValidateEditEventHandler-Delegierer 288
Value-Eigenschaft 533
Visible-Eigenschaft 344, 370
von Column 370
von Row 344
W
Wallpaper-Eigenschaft 534
WidthDisplay-Eigenschaft 371
Width-Eigenschaft 370, 403
von CellBorder 403
von Column 370
WordWrap-Eigenschaft 397, 535
von C1FlexGridClassic 535
X
X-Eigenschaft 309
von HitTestInfo 309
Y
Y-Eigenschaft 309
von HitTestInfo 309
Index · 585