C1FlexGrid - Saturday, April 28, 2012 8:51 AM - ComponentOne
C1FlexGrid - Saturday, April 28, 2012 8:51 AM - ComponentOne
C1FlexGrid - Saturday, April 28, 2012 8:51 AM - ComponentOne
Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.
YUMPU macht aus Druck-PDFs automatisch weboptimierte ePaper, die Google liebt.
User’s Guide
Copyright © 1991-2005 <strong>ComponentOne</strong> LLC. Alle Rechte vorbehalten.<br />
Unternehmenszentrale<br />
<strong>ComponentOne</strong> LLC<br />
4<strong>51</strong>6 Henry Street<br />
Suite 500<br />
Pittsburgh, PA 15213 USA<br />
Internet: info@componentone.com<br />
Webseite: http://www.componentone.com<br />
Vertrieb: sales@componentone.com<br />
+1 (800) 858-2739 oder +1 (412) 681-4343 (Pittsburgh, PA USA Office)<br />
Technischer Support<br />
Informationen zum Technischen Support finden Sie im Kapitel Technischer Support in diesem Handbuch.<br />
Markenzeichen<br />
<strong>ComponentOne</strong> FlexGrid für .NET und das <strong>ComponentOne</strong> FlexGrid für .NET-Logo sind Markenzeichen und<br />
<strong>ComponentOne</strong> ist eine registrierte Handelsmarke von <strong>ComponentOne</strong> LLC. Alle anderen, in diesem Handbuch<br />
verwendeten Markenzeichen sind Eigentum der entsprechenden Besitzer.<br />
GARANTIE<br />
<strong>ComponentOne</strong> garantiert für einen Zeitraum von 90 Tagen nach Kauf des Produktes, dass die originale CD oder<br />
Diskette keine Material- oder Qualitätsschäden bei normalem Gebrauch aufweist. Sie können einen defekten Datenträger<br />
zusammen mit dem datierten Kaufbeleg an <strong>ComponentOne</strong> einsenden, wenn ein Schaden während dieser Zeit auftritt.<br />
Sie erhalten eine neue CD oder Diskette ohne weitere Kosten. Für Ersatzlieferungen nach Ablauf der 90 Tage können Sie<br />
defekte Datenträger zusammen mit einem Scheck über US$25 für Porto und Verpackung an <strong>ComponentOne</strong> schicken.<br />
Mit Ausnahme der oben genannten Garantiebestimmung für die originale CD oder Diskette, gibt <strong>ComponentOne</strong> keine<br />
weiteren Garantien. Es wurde jede Anstrengung unternommen, um sicherzustellen, dass die vorliegenden Informationen<br />
zum Zeitpunkt der Erstellung des Handbuches richtig sind. <strong>ComponentOne</strong> ist nicht für falsche oder fehlende<br />
Informationen verantwortlich. <strong>ComponentOne</strong> haftet für den von ihnen entrichteten Kaufpreis für das Produkt.<br />
<strong>ComponentOne</strong> ist unter keinen Umständen für Folgeschäden, außerordentliche oder andere Schäden haftbar.<br />
Kopieren und vertreiben<br />
Es ist gestattet, Sicherheitskopien der Software für den eigenen Gebrauch und Schutz anzulegen, allerdings dürfen diese<br />
nicht an Dritte weitergegeben oder verwendet werden. <strong>ComponentOne</strong> hat viel Zeit und Aufwand in die Erstellung des<br />
Produktes gesteckt und bedankt sich für Ihr Verständnis, dass nur lizenzierte Benutzer das Produkt verwenden dürfen.<br />
Bitte lesen Sie die Abschnitte Lizenzvertrag und Lizenzierungsabschnitt in diesem Handbuch bevor Sie Kopien der<br />
<strong>ComponentOne</strong> FlexGrid für .NET-Dateien anfertigen und vertreiben
Inhaltsverzeichnis<br />
Inhaltsverzeichnis ...................................................................................................................... iii<br />
Willkommen zu <strong>ComponentOne</strong> FlexGrid für .NET ............................................................ 1<br />
Überblick ................................................................................................................................. 1<br />
Was ist neu in der Version 2.5 .............................................................................................. 2<br />
Installation............................................................................................................................... 3<br />
ENDBENUTZER-LIZENZVERTRAG FÜR COMPONENTONE SOFTWARE............. 4<br />
Häufig gestellte Fragen zur Lizenz (FAQs) ...................................................................... 12<br />
Technische Unterstützung .................................................................................................. 16<br />
Wiedervertreibbare Dateien................................................................................................ 17<br />
Namensbereiche (Namespaces).......................................................................................... 17<br />
Ein .NET-Projekt erstellen................................................................................................... 19<br />
Die <strong>C1FlexGrid</strong> Component der Toolbox hinzufügen.................................................... 20<br />
Die <strong>C1FlexGrid</strong>-Steuerung verwenden.................................................................................. 21<br />
Layout .................................................................................................................................... 22<br />
Auswahl................................................................................................................................. 24<br />
Datenbindungen................................................................................................................... 26<br />
Daten speichern und laden ................................................................................................. 27<br />
Zellbereich............................................................................................................................. <strong>28</strong><br />
Zellbilder ............................................................................................................................... 29<br />
Zellen formatieren................................................................................................................ 29<br />
Zellen bearbeiten .................................................................................................................. 37<br />
Zusammenfassen und Gliedern ......................................................................................... 49<br />
Zellen verbinden................................................................................................................... 56<br />
Speichern, Laden und Drucken.......................................................................................... 62<br />
FlexGrid-Eigenschaftsgruppen........................................................................................... 66<br />
FlexGrid-Beispiele...................................................................................................................... 69<br />
Visual Basic-Beispiele ..........................................................................................................69<br />
C#-Beispiele .......................................................................................................................... 72<br />
<strong>ComponentOne</strong> FlexGrid für mobile Gerätebeispiele..................................................... 77<br />
FlexGrid-Übungen ..................................................................................................................... 78<br />
Übung zur Bearbeitung ....................................................................................................... 78<br />
Übung zur Gliederung ........................................................................................................ 88<br />
Übung zur Datenanalyse..................................................................................................... 99<br />
<strong>C1FlexGrid</strong>-Referenzverzeichnis........................................................................................... 109<br />
<strong>C1FlexGrid</strong>-Klasse.............................................................................................................. 109<br />
CellRange-Struct................................................................................................................. 292<br />
HitTestInfo-Klasse..............................................................................................................302<br />
RowCollection-Klasse ........................................................................................................ 304<br />
ColumnCollection-Klasse.................................................................................................. 314<br />
Row-Klassen........................................................................................................................ 324<br />
Column-Klassen ................................................................................................................. 339<br />
CellStyleCollection-Klasse................................................................................................. 365<br />
CellStyle-Klasse .................................................................................................................. 376<br />
CellBorderKlassen.............................................................................................................. 392<br />
Node-Klasse ........................................................................................................................ 394<br />
· iii
iv ·<br />
GridGlyphs-Klasse ............................................................................................................. 405<br />
GridTree-Klasse .................................................................................................................. 406<br />
GridPrinter-Klasse..............................................................................................................412<br />
<strong>C1FlexGrid</strong>-Aufzählungen................................................................................................ 419<br />
<strong>C1FlexGrid</strong>-Schnittstellen.................................................................................................. 446<br />
<strong>C1FlexGrid</strong>Classic-Steuerung ................................................................................................ 449<br />
<strong>C1FlexGrid</strong>Classic-Referenzverzeichnis.............................................................................. 450<br />
<strong>C1FlexGrid</strong>Classic-Klassen ............................................................................................... 450<br />
Cell-Klassen......................................................................................................................... 564<br />
<strong>C1FlexGrid</strong>Classic-Aufzählungen.................................................................................... 564<br />
Index............................................................................................................................................ 579
Willkommen zu <strong>ComponentOne</strong><br />
FlexGrid für .NET<br />
Überblick · 1<br />
<strong>ComponentOne</strong> FlexGrid für .NET beinhaltet <strong>C1FlexGrid</strong>, eine voll ausgestattete Tabellensteuerung,<br />
mit der Sie schnell und einfach Daten anzeigen, formatieren und bearbeiten können.<br />
FlexGrid für .NET vereint die neuesten Datenbindungstechnologien – ADO.NET und <strong>ComponentOne</strong><br />
DataObjects – nahtlos innerhalb des Microsoft .NET Frameworks.<br />
Die benutzerdefinierten Steuerungen von <strong>ComponentOne</strong> sind innovativ, flexibel und stark. Wenn Sie<br />
FlexGrid mögen, dann sollten Sie sich auch unsere anderen preisgekrönten Produkte anschauen, welche<br />
im Abschnitt „Produkte von <strong>ComponentOne</strong>“ beschrieben werden.<br />
<strong>ComponentOne</strong> hat eine benutzerfreundliche Vertriebspolitik. Jeder Programmierer kann eine Kopie von<br />
FlexGrid für .NET besitzen und diese so lange ausprobieren, wie er möchte. Diejenigen, denen das<br />
Produkt gefällt und dieses nützlich finden, können eine Lizenz für einen günstigen Preis erwerben. Die<br />
einzige Einschränkung einer nicht lizenzierten Kopie von FlexGrid für .NET ist der <strong>ComponentOne</strong>-<br />
Banner, der bei jedem Programmstart angezeigt wird und den Entwickler auf die Lizenzierung des<br />
Produktes hinweist.<br />
Wir sind sicher, dass Sie <strong>ComponentOne</strong> FlexGrid für .NET mögen werden. Wenn Sie Vorschläge oder<br />
Ideen für neue Funktionen oder Steuerungen haben, die in den zukünftigen Versionen integriert werden<br />
sollten, dann rufen Sie uns an oder schreiben Sie uns an:<br />
<strong>ComponentOne</strong> LLC<br />
4<strong>51</strong>6 Henry Street<br />
Suite 500<br />
Pittsburgh, PA 15213 USA<br />
412.681.4343<br />
412.681.4384 (Fax)<br />
http://www.componentone.com<br />
Überblick<br />
Das <strong>ComponentOne</strong> FlexGrid für .NET-Paket besteht aus zwei Steuerungen:<br />
<strong>C1FlexGrid</strong>-Steuerung<br />
<strong>C1FlexGrid</strong> ist ein starkes voll ausgestattetes Tabellenprogramm. Es beinhaltet neue Wege, tabellarische<br />
Daten anzuzeigen, zu bearbeiten, zu formatieren, zu organisieren, zusammenzufassen und zu drucken.<br />
Es kann Tabellen von komprimierten Binärdateien oder Textdateien lesen und diese auch schreiben<br />
(kompatibel mit Microsoft Access und Excel). <strong>C1FlexGrid</strong> beinhaltet alle Basisfunktionen und<br />
fortgeschrittenen Funktionen, wie zum Beispiel Gliederungen, Sortieren, Zellenverbindungen,<br />
Maskenbearbeitung, übersetzte Zusammenstellungen, Listenbilder und automatische<br />
Datenzusammenfassung.
2 · Willkommen zu <strong>ComponentOne</strong> FlexGrid für .NET<br />
<strong>C1FlexGrid</strong> kann im bound-Modus (gebunden), wo Daten von jeder beliebigen .Net-Datenquelle,<br />
inklusive ADO.Net und <strong>ComponentOne</strong> DataObjects, angezeigt werden, oder im unbound-Modus<br />
(ungebunden), wo die Tabellensteuerung selbst die Daten verwaltet, genutzt werden.<br />
<strong>C1FlexGrid</strong>Classic Control<br />
<strong>C1FlexGrid</strong>Classic ist eine von <strong>C1FlexGrid</strong> abgeleitet Steuerung und beinhaltet ein Objektmodel, das<br />
genauso wie die VSFlexGrid ActiveX-Steuerung aussieht. <strong>C1FlexGrid</strong>Classic wurde für die einfache<br />
Migration von existierenden VSFlexGrid-Projekten entwickelt.<br />
Der Quellcode für <strong>C1FlexGrid</strong>Classic wird als Beispiel zur Verfügung gestellt. Sie können diesen als<br />
Referenz verwenden, um zu sehen, wie die <strong>C1FlexGrid</strong>-Steuerung als Basisklasse bei der Entwicklung<br />
einer benutzerdefinierten Tabellensteuerung verwendet wird.<br />
Was ist neu in der Version 2.5<br />
Die Version 2.5 von <strong>C1FlexGrid</strong> beinhaltet zwei neue Hauptfunktionen und einige nützliche<br />
Erweiterungen.<br />
Unterstützung von benutzerdefinierten Editoren<br />
Sie können nun jede beliebige .NET-Steuerung als Tabelleneditor verwenden. Ordnen Sie einfach eine<br />
Instanz der Steuerung der Editor-Eigenschaft einer Spalte zu und die Tabelle wird diese Steuerung dann<br />
für die Bearbeitung der Zellen in dieser Spalte verwenden.<br />
Sie können das Verhalten eines benutzerdefinierten Editors anpassen, indem Sie die<br />
IC1EmbeddedEditor-Schnittstelle implementieren (definiert in C1Common.dll). Dadurch verbessern Sie<br />
auch die Integration zwischen der Tabelle und den externen Editoren. Alle Steuerungen in der C1Input-<br />
Bibliothek implementieren nun den IC1EmbeddedEditor und können somit als Tabelleneditoren<br />
verwendet werden (es wird kein Quellcode benötigt).<br />
Wir stellen Ihnen außerdem Beispiele zur Verfügung, die Ihnen zeigen, wie man UIType-Editorklassen<br />
als Tabelleneditoren verwenden kann. (Schauen Sie unter „CustomEditors“ in unserer online<br />
Beispielbibliothek nach).<br />
Speichern und Öffnen von Microsoft Excel-Dateien<br />
Die Methoden SaveGrid und LoadGrid haben nun überladene Versionen, mit denen Sie Microsoft Excel-<br />
Dateien (*.xls) speichern und öffnen können. Die Tabellensteuerung nutzt reinen .NET-Code und<br />
benötigt somit keine installierte Kopie von Excel auf ihrem Computer.<br />
Es gibt zudem spezielle Methoden SaveExcel und LoadExcel, die zusätzliche Steuerungen für das<br />
Speichern und Laden von Tabellen auf bestimmten Blättern in einer Excel-Arbeitsmappe beinhalten.<br />
Unterstützung der automatischen Zwischenablage<br />
Mit der neuen Eigenschaft AutoClipboard kann die Tabellensteuerung die Standardbefehle der<br />
Zwischenablage - ausschneiden, kopieren, einfügen und löschen von Zellwerten - verwenden.<br />
Benutzerdefiniertes Verhalten für Zellverbindungen und Gruppierungen<br />
Mit der neuen Eigenschaft CustomComparer können Sie eine IComparer-Klasse festlegen, um<br />
angrenzende Zellen entweder zu verbinden, oder zu gruppieren.
Einfacher Zugang zu Datenquellenobjekten<br />
Installation · 3<br />
Mit der neuen Eigenschaft Row.DataSource können Sie leicht auf die Quelldaten einer Zeile zugreifen.<br />
Zum Beispiel, wenn die Tabellensteuerung an einen ADO.NET DataView gebunden ist, können Sie ganz<br />
einfach an das an jede Zeile angehängte DataViewRow-Objekt kommen.<br />
Noch stärkere CellStyle-Klassen<br />
Die CellStyle-Klasse hat eine neue Editor-Eigenschaft, mit der Sie einen benutzerdefinierten Editor<br />
festlegen können, und eine neue Render-Methode, mit der Sie den Stil verwenden können, der<br />
Zeichenketten und Grafiken in jedem beliebige Graphics-Objekt anzeigt.<br />
Neue Ereignisse<br />
Die Tabellensteuerung gibt nun Meldungen, bevor und nachdem der Nutzer eine Zeile hinzufügt oder<br />
löscht, aus, so dass Sie diese Aktionen überwachen oder abbrechen können (BeforeAddRow,<br />
AfterAddRow, CancelAddRow, BeforeDeleteRow und AfterDeleteRow).<br />
Außerdem gibt es neue Ereignisse um ungebundene Datenspalten zu unterstützen (GetUnboundValue<br />
und SetUnboundValue).<br />
Mehr Geschwindigkeit<br />
Die Version 2.5 beinhaltet einige Optimierungen, so dass die Tabellensteuerung erheblich schneller<br />
angezeigt und gescrollt werden kann, als zuvor.<br />
Installation<br />
Um FlexGrid für .NET zu installieren, starten Sie die <strong>C1FlexGrid</strong>.msi-Installationsdatei, die sich auf der<br />
CD befindet (oder als Download aus dem Internet) und folgen Sie den Anweisungen.<br />
Das Installationsprogramm wird ein Verzeichnis mit dem Namen „<strong>ComponentOne</strong> Studio.NET“ unter<br />
„Programme“ erstellen. Dieses Verzeichnis wird die folgenden Unterverzeichnisse enthalten:<br />
bin Enthält Kopien aller Binaries (*.dll, *.exe) aus dem <strong>ComponentOne</strong> Visual<br />
Studio.NET-Paket.<br />
Common Enthält Support- und Datendateien, die von vielen der Demoprogramme<br />
genutzt werden.<br />
Demos Enthält Beispielprojekte für alle Studio-Komponenten.<br />
Help Enthält die online Handbücher aller Studio-Komponenten.<br />
<strong>C1FlexGrid</strong> Enthält Beispiele und Anweisungen für die <strong>C1FlexGrid</strong>-Komponenten.<br />
Other Enthält Beispiele und Anweisungen für andere Studio-Komponenten.<br />
Installation von Demonstrationsversionen<br />
Wenn Sie FlexGrid für .NET ausprobieren wollen, aber keinen Registrierungsschlüssel besitzen, dann<br />
installieren Sie das Produkt ganz normal, geben aber keinen Registrierungsschlüssel ein. Der einzige<br />
Unterschied zwischen einer nicht registrierten (Evaluation) und einer registrierten (gekauften) Version<br />
der Software ist ein Banner, der beim Programmstart angezeigt wird.
4 · Willkommen zu <strong>ComponentOne</strong> FlexGrid für .NET<br />
Deinstallation von FlexGrid für .NET<br />
Um FlexGrid für .NET zu deinstallieren, müssen Sie die Systemsteuerung öffnen, auf Software klicken,<br />
im Register „Programme ändern oder entfernen“ FlexGrid für .NET auswählen und auf „Entfernen“<br />
klicken.<br />
ENDBENUTZER-LIZENZVERTRAG FÜR COMPONENTONE<br />
SOFTWARE<br />
WICHTIG – BITTE SORGFÄLTIG LESEN: Dieser Endbenutzer-Lizenzvertrag (diese „EULA“) legt die<br />
Bestimmungen fest, unter denen Sie berechtigt sind, die SOFTWARE wie nachfolgend definiert zu<br />
nutzen. Diese EULA beinhaltet maßgebliche Grenzen hinsichtlich ihrer Endbenutzerrechte. Sie sollten<br />
daher diese EULA sorgfältig lesen und Sie als wertvolles Eigentum ansehen.<br />
I. DIESE EULA.<br />
1. SOFTWARE definiert durch diese EULA. Diese EULA regelt die Nutzung der <strong>ComponentOne</strong>,<br />
LLC („C1“) und alle anderen mitgelieferten Softwareprodukte (einzeln und gemeinsam, die<br />
„SOFTWARE“). Der Begriff „SOFTWARE“ beinhaltet als Erweiterung zu der Definition von C1:<br />
1) jede Art von dazugehörigen Überarbeitungen, Updates und/oder Verbesserungen; 2) jede Art<br />
von Daten, Abbildungen oder ausführbaren Dateien, Datenbaken, Daten-Engines, Computer<br />
Software oder ähnlichen Elementen, die üblicherweise genutzt oder mit Softwareprodukten<br />
mitgeliefert werden; 3) jegliches, was auf irgendeine Art und Weise dafür vorgesehen ist, direkt<br />
mit oder in Verbindung mit der SOFTWARE genutzt zu werden; und 4) jede Art von<br />
dazugehörigen Medien, physikalischen, elektronischen und online Dokumentationen sowie<br />
gedruckten Materialien (die „Dokumentation“).<br />
2. Diese EULA ist ein rechtskräftiger Vertrag zwischen ihnen und C1. Sollten Sie als<br />
Bevollmächtigter eines Unternehmens oder einer anderen juristischen Person, wie beispielsweise<br />
als Angestellter im Auftrag ihres Arbeitsgebers, handeln, so bezieht sich „sie” und „ihr“ auf ihren<br />
Auftraggeber, auf das Unternehmen oder eine andere juristische Person, in dessen Auftrag Sie<br />
handeln. Dennoch können Sie für den Fall, dass Sie als Bevollmächtigter im Auftrag eines Dritten<br />
handeln, persönlich für Verstöße gegen staatliche Gesetze wie Urheberrechtsverletzungen<br />
haftbar gemacht werden.<br />
Diese EULA ist ein rechtskräftiger Vertrag zwischen ihnen und C1. Sie sind rechtlich an diese<br />
EULA gebunden, als hätten Sie und C1 persönlich diese EULA unterschrieben. Indem Sie die<br />
SOFTWARE installieren, kopieren, oder Sie anderweitig verwenden, erklären Sie sich damit<br />
einverstanden, durch die Bestimmungen dieser EULA gebunden zu sein. Falls Sie sich mit den<br />
Bestimmungen dieser EULA nicht einverstanden erklären, sind Sie nicht berechtigt, die<br />
SOFTWARE zu installieren oder zu verwenden. Falls Sie die Installation dieser SOFTWARE, aus<br />
welchen Gründen auch immer, bereits begonnen oder gar schon abgeschlossen haben, sollten Sie<br />
den Installationsvorgang abbrechen oder die SOFTWARE deinstallieren. (Klicken Sie auf die<br />
Beenden- oder eine äquivalente Schaltfläche, um die Installation sofort zu beenden.) Falls Sie sich<br />
mit den Bestimmungen dieser EULA nicht einverstanden erklären, müssen Sie die SOFTWARE<br />
unverzüglich zu dem Geschäft, bei dem Sie die SOFTWARE erworben haben, gemäß deren<br />
Rückgaberichtlinien zurückgeben. Rückgaberichtlinien können von Händler zu Händler<br />
unterschiedlich sein. Sie müssen ihrer Rückgaberichtlinie, mit der Sie sich zum Kaufzeitpunkt<br />
einverstanden erklärt haben, nachkommen. Falls das Geschäft, bei der Sie die SOFTWARE<br />
erworben haben, der Rückerstattung des vollen Kaufpreises innerhalb eines Zeitraumes von<br />
dreißig (30) Tagen seit dem nachweisbaren Kaufzeitpunkt nicht nachkommt, können Sie die<br />
SOFTWARE direkt an C1 innerhalb einer Periode von dreißig (30) Tagen seit des<br />
Kaufzeitpunktes zurückgeben. Um das Produkt direkt an C1 zurückzugeben, müssen Sie sich
ENDBENUTZER-LIZENZVERTRAG FÜR COMPONENTONE SOFTWARE · 5<br />
eine C1 Rückgabeberechtigungsnummer beschaffen, indem Sie C1 zunächst kontaktieren. Sie<br />
sind verpflichtet, alle erworbenen Teile des Produktes, den Kaufnachweis inbegriffen, direkt an<br />
C1 zu senden. Das Porto dieser Rücksendung muss im Voraus bezahlt werden. Es muss<br />
eindeutig erkennbar sein, dass die Rückgabe innerhalb der Frist von dreißig Tagen, beginnend<br />
mit dem Tag des nachweisbaren Kaufes erfolgt, wobei diese Fristeinhaltung entscheidend für die<br />
Vertragserfüllung ist. Die Möglichkeit der Rücksendung des Produktes an C1 wird nur den<br />
Erstkäufern eines ungeöffneten, original verpackten Produktes gewährt.<br />
II. IHRE LIZENZ ZU ENTWICKLEN UND ZU VERTREIBEN.<br />
Wie im Folgenden noch ausführlicher erläutert wird, gewährt ihnen diese EULA zwei Lizenzen: 1) eine<br />
Lizenz zur Nutzung der SOFTWARE, um andere Software Produkte zu entwickeln (die<br />
„Entwicklungslizenz“); und 2) eine Lizenz, um die entwickelte Software zu nutzen und/oder zu<br />
vertreiben (die „Vertriebslizenz“). Beide Lizenzen (einzeln und gemeinsam, die „Lizenzen“) werden im<br />
Folgenden detaillierter erläutert und definiert.<br />
3. Definitionen. Die folgenden Begriffe haben die entsprechende Bedeutung, wie diese in dieser<br />
EULA festgelegt wird:<br />
„Netzwerk Server” beschreibt einen Computer mit einem oder mehreren Prozessoren (CPU's),<br />
die das Ziel verfolgen, andere Computer, die logisch oder physisch mit dieser CPU verbunden<br />
sind, einschließlich, aber nicht ausschließlich anderer Computer, die über ein internes Netzwerk,<br />
das Intranet oder das Internet mit dieser CPU verbunden sind, mit Daten zu beliefern. „Web<br />
Server“ beschreibt eine Art Netzwerk Server, der andere Computer, die eher über das Intranet<br />
oder das Internet mit diesem Netzwerk Server verbunden sind, mit Daten beliefert.<br />
„Entwickelte Software“ beschreibt diejenigen Softwareprodukte, die unter Verwendung der<br />
SOFTWARE entwickelt wurden. „entwickelte Web Server-Software“ beschreibt diejenigen<br />
entwickelten Softwareprodukte, die logisch oder physisch auf mindestens einem Web Server<br />
abgespeichert werden und vom Prozessor oder den Prozessoren des Web Servers bedient werden<br />
(was bedeutet, dass die Anweisungsbefehle ausgeführt werden). „entwickelte Stammsoftware“<br />
beschreibt diejenigen entwickelten Softwareprodukte, die keine entwickelte Web Server-Software<br />
sind. Dies schließt beispielsweise selbständige Anwendungen sowie Anwendungen, die alleine<br />
durch einen File-Server zugänglich gemacht werden können, ein. „Wiedervertreibbare Dateien“<br />
beschreiben SOFTWARE-Dateien oder andere Bestandteile der SOFTWARE, die von C1 geliefert<br />
werden und die Sie als beim Vertrieb der entwickelten Software in den zugehörigen schriftlichen<br />
Materialien als wiedervertreibbare Dateien kennzeichnen müssen. „Entwickler“ beschreibt einen<br />
Menschen oder jedes automatisierte Instrument, das die SOFTWARE gemäß den Bestimmungen<br />
dieser EULA verwendet.<br />
„Einzelentwicklerlizenz“ bedeutet, dass jeder Entwickler, der die programmatische Schnittstelle<br />
oder die SOFTWARE nutzt oder anderweitigen Zugang zu diesen hat, eine separate<br />
Benutzerlizenz erwerben muss.<br />
„Quellcode” soll als Software-Code oder als Programm in einem visuell lesbaren Format<br />
verstanden werden, wie z.B. eine gedruckte Auflistung eines solchen Programms, welches in<br />
einer höheren Programmiersprache geschriebenen wurde. Der Begriff „Quellcode” umfasst nicht<br />
nur Dokumente und Materialien, wie Flussdiagramme, Pseudo-Code und Programmnotizen, die<br />
zur Unterstützung der SOFTWARE-Entwicklung dienen.<br />
4. Ihre Entwicklungslizenz. Ihnen wird hiermit ein limitiertes, gebührenfreies und nicht-exklusives<br />
Nutzungsrecht an der SOFTWARE gewährt, um mit dieser SOFTWARE entwickelte Software zu
6 · Willkommen zu <strong>ComponentOne</strong> FlexGrid für .NET<br />
entwerfen, zu erstellen und zu testen. Dies gilt allerdings nur unter der Bedingung, dass Sie sich,<br />
und nur dann, mit den Bestimmungen dieser EULA vollständig einverstanden erklären.<br />
Die SOFTWARE ist für Sie auf einer Einzelentwicklerlizenzbasis lizenziert.<br />
Die Einzelentwicklerlizenz berechtig Sie dazu, eine einzige Installation der SOFTWARE<br />
durchzuführen, um diese zur Entwerfung, zur Erstellung und zur Testung von entwickelter<br />
Software von einem einzigen Entwickler, auf einem oder mehreren Computern, mit jeweils<br />
einem einzigen Satz an Eingabegeräten zu nutzen, solange wie der/die Computer nur von einem<br />
Entwickler zu jedem Zeitpunkt und nicht gleichzeitig genutzt wird/werden. Dies bedeutet<br />
gleichzeitig, dass Sie nicht dazu berechtigt sind, die SOFTWARE auf einem Computer, der als<br />
Netzwerk Server oder Computer dient, auf welchem die SOFTWARE von mehr als nur einem<br />
Entwickler genutzt werden kann, zu installieren oder zu nutzen. Sie sind nicht berechtigt, die<br />
SOFTWARE oder eine Komponente der SOFTWARE zu vernetzen, wenn Sie dadurch von mehr<br />
als nur einem Entwickler genutzt werden kann. Dies trifft nicht zu, wenn Sie für jeden weiteren<br />
Nutzer jeweils eine weitere Entwicklungslizenz erworben haben. Zudem müssen Sie eine weitere<br />
separate SOFTWARE Lizenz erwerben, um den zusätzlichen Nutzern Entwicklungsplätze<br />
beifügen zu können. Diese Notwendigkeit ist unabhängig davon, ob die weiteren Nutzer die<br />
SOFTWARE in einem unabhängigen Umfeld oder in einem Computer Netzwerk nutzen.<br />
In keinem Fall ist es ihnen ohne das ausdrückliche, schriftliche Einverständnis von C1 gestattet,<br />
den C1-Namen, das C1-Logo oder die C1-Markenzeichen zu verwenden, um ihre entwickelte<br />
Software zu vertreiben; (b) Sie müssen den folgenden C1-Urheberrechtshinweis („Portions<br />
Copyright © <strong>ComponentOne</strong>, LLC 1991-2002. Alle Rechte vorbehalten.”) in ihre Dokumentation<br />
der entwickelten Software und/oder in die „Über-Text“ der entwickelten Software sowie an jeder<br />
Stelle, an der der Rechtshinweis in der entwickelten Software platziert ist, einfügen; (c) Sie<br />
stimmen hiermit einer Ausschlussklausel für finanzielle Haftung zu; Sie stimmen zu, dass Sie C1-<br />
Schadensersatz leisten und dass Sie C1, seine Zulieferer und Händler vor jeglicher Art der<br />
Anspruchsforderungen oder Gerichtsverfahren, die aus der Verwendung oder dem Vertrieb<br />
ihrer entwickelten Software resultieren können, einschließlich der Anwaltskosten, zu schützen;<br />
(d) Sie dürfen die SOFTWARE lediglich für die Erstellung von entwickelter Software, die<br />
signifikante Unterschiede zur originalen SOFTWARE aufweist, verwenden.<br />
5. Ihre Vertriebslizenz.<br />
Lizenz zum Vertrieb der Entwickelten Stammsoftware. Gemäß den Bestimmungen dieser<br />
EULA wird ihnen die Lizenz zur gebührenfreien Nutzung und zum Vertrieb von entwickelter<br />
Stammsoftware gewährt, sofern die in einem maschinensprachigen Format entwickelte<br />
Stammsoftware (üblicherweise ein „*.exe“- oder „*.dll“-Format), die SOFTWARE als inneren Teil<br />
der entwickelten Software enthält. Es ist ihnen nicht gestattet, die SOFTWARE als entwickelte<br />
Software zu versenden, zu bündeln, zu verpacken oder zu unterteilen, die sich als die<br />
programmatische Schnittstelle der SOFTWARE herausstellt, wenn Sie in einer „designtime“-<br />
Entwicklungsumgebung genutzt wird. Sie dürfen lediglich auf einer gebührenfreien Basis<br />
wiedervertreibbare Dateien der entwickelten Stammsoftware vertreiben.<br />
4. Spezifische Produkteinschränkungen. Falls die gekaufte Lizenz für eines der folgenden<br />
Produkte gedacht ist, gelten die folgenden zusätzlichen Einschränkungen, ungeachtet jeglicher<br />
Bestimmungen in dieser EULA, die diesen Einschränkungen zuwiderlaufen:<br />
a. <strong>ComponentOne</strong> Reports für .NET Designer Edition. <strong>ComponentOne</strong> Reports für .NET<br />
Designer Edition beinhaltet zumindest: 1) eine dynamische Link-Bibliotheksdatei<br />
(c1.win.c1reportdesigner.dll), bekannt als C1ReportDesigner-Komponente, 2) eine<br />
funktionsfähige Datei (ReportDesigner.exe), bekannt als C1ReportDesigner-Anwendung und 3)
ENDBENUTZER-LIZENZVERTRAG FÜR COMPONENTONE SOFTWARE · 7<br />
den Quellcode der C1ReportDesigner-Anwendung. Die C1ReportDesigner-Komponente ist<br />
Gegenstand der generellen, in dieser EULA dargelegten Begrifflichkeiten und Beschränkungen.<br />
Die C1ReportDesigner-Anwendung ist eine funktionsfähige Datei, die verwendet wird, um<br />
Berichte zu entwerfen und anzufertigen; die C1ReportDesigner-Anwendung kann gebührenfrei<br />
nur in Verbindung mit der entwickelten Software vertrieben werden.<br />
Gemäß den Bestimmungen in dieser EULA gewährt C1 ihnen hiermit das Recht, den<br />
Anwendungsquellcode des C1ReportDesigners zu nutzen. Ihnen wird hiermit ebenso das Recht<br />
gewährt, einen solchen Quellcode zu modifizieren und abgeleitete Arbeiten, die auf dem<br />
lizenzierten Quellcode basieren, zu erstellen. Sie dürfen die von ihnen entwickelten und<br />
abgeleiteten Arbeiten nur in einem Objektcodeformat und ausschließlich in Verbindung mit<br />
und/oder als Teil der entwickelten Software vertreiben. Ihnen wird ausdrücklich das Recht<br />
verwährt, den lizenzierten Quellcode, jegliche abgeänderte Versionen, abgeleitete Arbeiten oder<br />
jeder Anteil dieser genannten Arbeiten in einem Quellcodeformat an eine dritte Partei zu<br />
vertreiben, dieser den Quellcode bekannt zu geben, oder der dritten Partei den Quellcode auf<br />
eine andere Weise zugänglich zu machen.<br />
C1 behält alle Rechte, Ansprüche und Anteile an dem lizenzierten Quellcode, sowie an allen<br />
Updates, Änderungen und Weiterentwicklungen, die von C1 stammen. In Bezug auf den<br />
lizenzierten Quellcode gilt nichts als von C1 auf Sie transferierbares Eigentums- oder<br />
Anspruchsrecht.<br />
DER QUELLCODE IST WIE BESCHRIEBEN AUF SIE LIZENZIERT. C1 WIRD UND SOLL<br />
IHENEN KEINEN TECHNISCHEN SUPPORT FÜR IHRE QUELLCODELIZENZ BIETEN.<br />
b. VSView Reporting Edition. Die VS View Reporting Edition beinhaltet zumindest eine<br />
funktionsfähige Datei, die als „VSRpt7.exe” (wobei X die Versionsnummer darstellt, z.B. 7,8,<br />
usw.), gelistet und als „Designer” bekannt ist. Die Datei „VSRpt7.exe” oder jede Verbesserung<br />
oder zukünftige Version des Designers sind Gegenstand der in dieser EULA dargestellten<br />
Beschränkungen und dürfen nicht mit ihrer Entwickelten Software oder auf einem anderen Wege<br />
vertrieben werden.<br />
c. Doc-To-Help und <strong>ComponentOne</strong> Natural Search. Sie dürfen Doc-To-Help dazu nutzen,<br />
Onlinehilfen, Handbücher oder andere Dokumentationen in elektronischem oder gedruckter<br />
Form zu erstellen (die „Output Dokumente“). Sie können diejenigen Dateien, die in der<br />
Dokumentation als wiedervertreibbare Dateien gekennzeichnet sind, in solche Output-<br />
Dokumente fassen und vertreiben. Mit Ausnahme diesen speziellen wiedervertreibbaren<br />
Dateien, DÜRFEN Sie die SOFTWARE NICHT an Dritte vertreiben, egal in welchem Format.<br />
d. Studio Products. Es ist ihnen weder gestattet die Komponenten des Studio Products, für die<br />
Sie eine Lizenz erhalten haben, mit anderen Entwicklern zu teilen, noch dürfen Sie die Nutzung<br />
und/oder Installation dieser Komponenten durch andere Entwicklern erlauben.<br />
e. <strong>ComponentOne</strong> Response und SOAP Channel. <strong>ComponentOne</strong> Response ist dafür<br />
vorgesehen, auf einem Netzwerkserver installiert zu werden. C1 gibt ihnen folgende Rechte für<br />
diese SOFTWARE: a) Installation: Sie dürfen eine Kopie der SOFTWARE auf einem<br />
Netzwerkserver installieren; b) Verwendung: Wenn die SOFTWARE installiert und initialisiert<br />
wurde, dann erstellt diese eine Datenbankdatei, welche eine Lösungs- und Wissensdatenbank<br />
darstellt (Die Datenbank wird im Folgenden „Knowledge Base“ genannt).
8 · Willkommen zu <strong>ComponentOne</strong> FlexGrid für .NET<br />
Sie dürfen die SOFTWARE nur dafür verwenden, um Knowledge Bases auf einem<br />
Netzwerkserver zu erstellen. Um Knowledge Bases auf mehr als nur einem Netzwerkserver zu<br />
erstellen und zu verwenden, müssen Sie zusätzliche SOFTWARE-Lizenzen für jeden zusätzlichen<br />
Netzwerkserver erwerben.<br />
5. Updates/Upgrades; Studio Abonnement. Gemäß den Bestimmungen in dieser EULA sind die<br />
Lizenzen fortwährend. Updates und Verbesserungen der SOFTWARE können von Zeit zu Zeit<br />
durch C1 zur Verfügung gestellt werden und welche in diesem Falle nach den Bestimmungen,<br />
die zu diesem Zeitpunkt Gültigkeit besitzen und die ganz im Ermessen von C1 liegen, angeboten<br />
werden. C1 wird diese Updates und Verbesserungen der SOFTWARE nie oder zu gegebenem<br />
Zeitpunkt entweder kostenlos oder für eine Gebühr anbieten und über ihre gewählten<br />
Vertriebswege vertreiben. Das Verfahren mit diesen Begebenheiten liegt im alleinigen und<br />
vollständigen Ermessen von C1.<br />
C1 lizenziert bestimmte, seiner separat lizenzierten Produkte in einem Produktbündel, welches<br />
als C1 „Studio“-Produktlinie bezeichnet wird (die „Studio Products“). Die wirklich separat<br />
lizenzierten Produkte, die als Studio Products zusammengestellt wurden, können sich von Zeit<br />
zu Zeit ändern, da die Zusammenstellung ganz im Ermessen von C1 liegt. Sollte die SOFTWARE<br />
als C1 „Studio” Produkt gekennzeichnet sein, so ist die SOFTWARE Teil der Studio Products. Die<br />
SOFTWARE und die Studio Products werden von Zeit zu Zeit überarbeitet (was beispielsweise<br />
eine Überarbeitung durch Updates, durch Verbesserungen und im Falle von Studio Products,<br />
durch mögliche Änderungen bezüglich der spezifischen Zusammenstellung des Produktbündels,<br />
bedeuten kann). Damit Sie berechtigt sind, eine solche Überarbeitung der SOFTWARE oder der<br />
Studio Products zu erhalten, müssen Sie über eine gültige SOFTWARE Lizenz oder ein gültiges<br />
Studio Abonnement verfügen. Der ursprüngliche Käufer der SOFTWARE oder eines Studio<br />
Products erhält ein einjähriges Abonnement ab dem Zeitpunkt des Erwerbs der SOFTWARE.<br />
Nach Ablauf des Jahres muss das Studio Abonnement und/oder die SOFTWARE-Lizenz<br />
erneuert werden, um weiterhin berechtigt zu sein, die SOFTWARE und/oder die Revisionen der<br />
Studio Products zu erhalten.<br />
6. Seriennummer. Im Inneren der Verpackung der SOFTWARE ist eine einzigartige<br />
Fabrikatsnummer (die „Seriennummer”) enthalten, welche die Registrierung für die<br />
SOFTWARE ermöglicht. Die Seriennummer unterliegt den Beschränkungen, die in dieser EULA<br />
dargelegt werden. Sie darf weder mit ihrer Entwickelten Software, noch auf anderem Wege<br />
bekannt gegeben oder vertrieben werden. Die Bekanntgabe oder der Vertrieb der Seriennummer<br />
stellt einen Verstoß gegen diese EULA dar und bewirkt automatisch die Beendigung und den<br />
Entzug aller durch diese EULA garantierten Rechte.<br />
7. Evaluations-Version. Sollten Sie eine „Evaluations-Version“ oder eine ähnliche Version<br />
verwenden, die speziell als solche von C1 entweder auf dessen Webseite oder auf anderem Wege<br />
ausgewiesen ist, so sind die Lizenzen auf folgendes beschränkt: a) ihnen wird eine Lizenz für die<br />
Verwendung der SOFTWARE für einen Zeitraum von dreißig (30) Tage, beginnend mit dem Tag<br />
der Installation (die „Evaluations-Periode”) gewährt; b) nach Ablauf der Evaluations-Periode<br />
sollten Sie entweder i) die SOFTWARE von dem Computer, der die Installation enthält, löschen,<br />
oder Sie können ii) C1 oder einen seiner autorisierten Händler kontaktieren, um eine SOFTWARE<br />
Lizenz zu erwerben, welche den Bestimmungen dieser EULA unterliegt; und c) jede mit der<br />
SOFTWARE entwickelte Software darf nicht vertrieben oder für einen kommerziellen Zweck<br />
verwendet werden.<br />
III. GEWERBLICHE SCHUTZRECHTE.<br />
1. Urheberrecht. Alle Eigentumsrechte und gewerblichen Schutzrechte an der SOFTWARE<br />
(einschließlich, aber nicht beschränkt auf Bilder, Fotografien, Animationen, Video, Audio, Musik,
ENDBENUTZER-LIZENZVERTRAG FÜR COMPONENTONE SOFTWARE · 9<br />
Text und „Applets“, die in der SOFTWARE enthalten sind) sowie an jeder Kopie der SOFTWARE<br />
und jede einbegriffenen Eigentumsrechte und anderes geistiges Eigentum oder der Bezug darauf,<br />
liegen ausschließlich bei C1. Eine Ausnahme besteht in begrenzten Umfang, in dem C1 der<br />
rechtmäßige Lizenzinhaber von bestimmten Technologien Dritter ist, die in der SOFTWARE<br />
enthalten sind. Die SOFTWARE ist durch Urheberrechte und internationalen<br />
Vertragsvorschriften geschützt. Die SOFTWARE wird lizenziert, nicht verkauft. C1 behält sich<br />
alle Rechte, die nicht anderweitig ausdrücklich und spezifisch durch diese EULA gewährleistet<br />
werden, vor.<br />
2. Sicherungskopie. Sie sind berechtigt: (a) die SOFTWARE ausschließlich für den Zweck der<br />
Erstellung einer Sicherungskopie oder der Archivierung zu kopieren; oder (b) die SOFTWARE<br />
auf einem einzigen Computer zu installieren, vorausgesetzt, Sie bewahren das Original einzig für<br />
den Zweck der Erstellung einer Sicherungskopie oder der Archivierung auf. Ungeachtet des<br />
Voranstehendem sind Sie nicht berechtigt, die schriftlichen Materialien zu kopieren.<br />
3. Allgemeine Beschränkungen. Es ist ihnen nicht gestattet, die SOFTWARE auseinander<br />
zunehmen (Reverse Engineering), zu dekompilieren oder auseinander zu bauen, mit der<br />
Ausnahme und nur zu dem durch das anwendbaren Rechtes ausdrücklich gestatteten Umfang,<br />
zu dem solche Aktivitäten trotz dieser Beschränkungen zugelassen sind.<br />
4. Software Übertragungen. Sie sind nicht berechtigt, die SOFTWARE zu vermieten oder zu<br />
verleasen. Sie sind berechtigt, die SOFTWARE auf einen anderen Computer zu übertragen,<br />
vorausgesetzt, dass die SOFTWARE vollständig von dem Computer entfernt wurde, von<br />
welchen Sie übertragen wurde. Sie sind berechtigt, ihre gesamten Rechte unter dieser EULA<br />
dauerhaft zu übertragen, vorausgesetzt, dass Sie keine Kopien zurückbehalten, dass Sie die<br />
gesamte SOFTWARE übertragen (einschließlich aller Zubehörteile, dem Speichermedium und<br />
den schriftlichen Materialien, alle Daten, Verbesserungen, diese EULA und, falls möglich, die<br />
Echtheitsbescheinigung) und dass der Empfänger den Bestimmungen dieser EULA zustimmt,<br />
wie von dieser EULA vorgesehen. Falls es sich bei der SOFTWARE um ein Update oder eine<br />
Verbesserung handelt, muss eine Übertragung der SOFTWARE alle früheren Versionen der<br />
SOFTWARE beinhalten.<br />
5. Kündigung. Ohne sonstige Rechte zu beschaden oder zu beschränken ist C1 berechtigt, diese<br />
EULA und die Lizenzen zu kündigen, sofern Sie die Bestimmungen dieser EULA nicht einhalten.<br />
In einem solchen Fall sind Sie verpflichtet, sämtliche Kopien der SOFTWARE und alle ihre<br />
Komponenten zu vernichten.<br />
6. Ausfuhrbeschränkungen. Sie erkennen an, dass die SOFTWARE U.S. amerikanischen Ursprungs<br />
ist. Sie erkennen an, dass die Lizenz und der Vertrieb der SOFTWARE dem Exportkontrollrecht,<br />
den gesetzlichen Regulierungen und den diesbezüglichen Ergänzungen der Vereinigten Staaten<br />
von Amerika unterliegen, welche die Exporte und Reexporte von Software, technischen Daten<br />
und direkten Produkten technischer Daten, einschließlich den Services und entwickelter Software<br />
begrenzen. Sie erklären sich damit einverstanden, dass Sie die SOFTWARE oder irgendeine<br />
entwickelte Software oder irgendwelche Informationen, Dokumente und/oder gedruckte<br />
Materialien, die entweder direkt oder indirekt in Zusammenhang mit der SOFTWARE oder einer<br />
entwickelten Software stehen, nicht zu exportieren oder zu reexportieren, ohne zuvor hierfür<br />
eine Genehmigung vom United States of America Department of Commerce's Bureau of Export<br />
Administration („BXA“) oder von einer anderen zuständigen Regierungsbehörde erhalten zu<br />
haben. Sollte der Export oder Reexport in einen Staat, zu Endbenutzern oder zwecks einer<br />
Endbenutzung stattfinden, gegen welche das U.S. amerikanische Exportrecht, Regulierungen<br />
oder irgendwelche diesbezüglich ergänzende Beschränkungen mit nachfolgenden Inhalt<br />
vorsieht, dann ist folgendes zu beachten:
10 · Willkommen zu <strong>ComponentOne</strong> FlexGrid für .NET<br />
Beschränkung gegen Staaten: Die Liste der beschränkten Staaten beinhaltet derzeit (nicht zwingend<br />
vollständig): Kuba, Iran, Irak, Libyen, Montenegro, Nord Korea, Serbien, Sudan und Syrien.<br />
Beschränkung gegen Endbenutzer: Jeder Endbenutzer, von dem Sie wissen, oder von dem Sie<br />
Grund haben anzunehmen, dass er die SOFTWARE oder die entwickelte Software für den<br />
Entwurf, die Entwicklung oder die Produktion von Flugkörpern und Flugkörpertechniken, von<br />
Nuklearwaffen und Waffentechnologien oder chemischen und biologischen Waffen nutzt. Jeder<br />
Bürger der beschränkten Staaten, wo auch immer er sich befindet, der beabsichtigt, die<br />
SOFTWARE oder die entwickelte Software in eine der beschränkten Staaten zu senden oder zu<br />
transportieren.<br />
Beschränkung gegen Endbenutzungen: Jede Verwendung der SOFTWARE und der entwickelten<br />
Software, die in Zusammenhang mit dem Entwurf, der Entwicklung oder der Produktion von<br />
Flugkörpern und Flugkörpertechniken, von Nuklearwaffen und Waffentechnologien oder<br />
chemischen und biologischen Waffen steht.<br />
Diese Beschränkungen können sich mit der Zeit ändern. Sie müssen dafür Sorge tragen und<br />
garantieren, dass weder das BXA noch irgendeine andere staatliche Behörde der Vereinigten<br />
Staaten von Amerika ihr Exportsonderrecht aufgeschoben, aufgehoben oder verweigert hat. C1<br />
erkennt an, dass es sich angemessen bemühen muss, um ihnen alle notwendig-relevanten<br />
Informationen bezüglich der SOFTWARE und seinem Unternehmen bereitzustellen, um ihnen so<br />
zu ermöglichen, vollständig den Bestimmungen dieses Kapitels nachzukommen. Sollten Sie<br />
weitere Fragen hinsichtlich ihren Verpflichtungen unter den Exportvorschriften der Vereinigten<br />
Staaten von Amerika haben, können Sie sich an das Bureau of Export Administration wenden;<br />
Bureau of Export Administration United States Department of Commerce, Exporter Counseling<br />
Division, Washington DC. U.S.A. (202) 482-4811, http://www.bxa.doc.gov.<br />
7. U.S. Government Restricted Rights. Die SOFTWARE und ihre Dokumente werden mit<br />
beschränkten Rechten geliefert. Für Erlässe, die von den Vereinigten Staaten von Amerika, seinen<br />
Vertretungen und/oder Vermittlungen (die „Regierung“), mit Ausnahme des<br />
Verteidigungsministerium, vor dem 1. Dezember 1995 ausgestellt wurden, unterliegen die<br />
Nutzung, die Vervielfältigung oder die Bekanntmachung der Software und der Dokumente, die<br />
der Regierung unter dieser EULA bereitgestellt wurden, den BESCHRÄNKTEN RECHTEN, wie<br />
in den Unterparagraphen (c)(1) und (2) der Commercial Computer Software - Restricted Rights<br />
clause in 48 CFR ch.1 52.227-19 dargelegt. Für Erlässe, die von dem Verteidigungsministerium<br />
vor dem 29. September 1995 ausgestellt wurden, unterliegen die Nutzung, die Vervielfältigung<br />
oder die Bekanntmachung der Software und der Dokumente, die der Regierung unter dieser<br />
EULA bereitgestellt wurden, den BESCHRÄNKTEN RECHTEN, wie in den Unterparagraphen<br />
(c)(1)(ii) des Rights in Technical Data and Computer Software clause in 48 CFR ch.2 252.227-7013<br />
dargelegt. Sie werden jeder Anforderung der Regierung nachkommen, einschließlich und ohne<br />
Einschränkung der Platzierung von beschränkenden Erklärungen in der SOFTWARE und in dem<br />
Lizenz-Vertrag, welcher in Zusammenhang mit dem Vertrieb der SOFTWARE verwendet wird,<br />
um den Schutz dieser BESCHRÄNKTEN RECHTEN zu erhalten. Der Hersteller ist<br />
<strong>ComponentOne</strong>, LLC, 4<strong>51</strong>6 Henry Street, Suite 501, Pittsburgh, Pennsylvania 15213 USA. Für<br />
Erlässe, die von der Regierung am 1. Dezember 1995 oder später und vom<br />
Verteidigungsministerium am 29. September 1995 oder später ausgestellt wurden, sind die<br />
einzigen Rechte, die an der Software und an den Dokumenten übertragen werden, die in dieser<br />
EULA enthalten sind. Unter keinen Umständen soll C1 dazu verpflichtet werden, einer<br />
Regierungsanforderung hinsichtlich der Vorlage einer oder der Anfrage nach einer Befreiung von<br />
der Einreichung von Kostendaten oder Preisgestaltungsdaten oder betrieblichen<br />
Rechnungswesensanforderungen nachzukommen. Für jeden Vertrieb der SOFTWARE, der von
ENDBENUTZER-LIZENZVERTRAG FÜR COMPONENTONE SOFTWARE · 11<br />
C1 die Einhaltung einer Regierungsanforderung bezüglich Kostendaten oder<br />
Preisgestaltungsdaten oder Anforderungen hinsichtlich dem betrieblichen Rechnungswesen<br />
erfordern würde, müssen Sie eine sachgerechte Befreiung oder Freistellung von solchen<br />
Anforderungen zugunsten von C1 von der zuständigen Regierungsstelle einholen, bevor die<br />
SOFTWARE an die Regierung vertrieben und/oder lizenziert wird.<br />
IV. GARANTIEN UND ANSPRÜCHE.<br />
1. Beschränkte Garantie. C1 garantiert, dass das originale Speichermedium für einen Zeitraum von<br />
neunzig (90) Tagen ab dem Zeitpunkt der Lieferung der SOFTWARE keine Fehler aufweist.<br />
SOFERN NICHT ANDERS IN DEM VORHERGEHENDEN SATZ BESCHRIEBEN UND IM<br />
GRÖßTMÖGLICHEN DURCH DAS ANWENDBARE RECHT GESTATTETEN UMFANG,<br />
SCHLIEßT C1 AUSDRÜCKLICH JEDE GARANTIE FÜR DIE SOFTWARE, FÜR DIE<br />
SCHRIFTLICHEN MATERIALIEN UND ALLES ANDERE, WAS C1 HIERMIT GELIEFERT<br />
HAT, AUS. C1 LIEFERT DIES ALLES MIT DER BESCHAFFENHEIT „OHNE<br />
MÄNGELGEWÄHR“, OHNE JEDE ART VON GEWÄHRLEISTUNGEN, UNABHÄNGIG<br />
DAVON, OB SIE AUSDRÜCKLICH ODER KONKLUDENT GEWÄHRT WORDEN SIND,<br />
EINSCHLIEßLICH UND OHNE AUSNAHME KONKLUDENTER GEWÄHRLEISTUNGEN<br />
IM HINBLICK AUF HANDELSÜBLICHKEIT UND EIGNUNG FÜR EINEN BESTIMMTEN<br />
ZWECK. DAS GES<strong>AM</strong>TE RISIKO, WELCHES SICH AUS DER NUTZUNG ODER<br />
AUSFÜHRUNG DER SOFTWARE UND DER SCHRIFTLICHEN MATERIALIEN ERGIBT,<br />
MÜSSEN SIE TRAGEN. DIESE BESCHRÄNKTE GARANTIE GEWÄHRT IHNEN<br />
BESTIMMTE RECHTE. JE NACH STAAT KÖNNEN SIE MÖGLICHERWEISE ANDERE<br />
RECHTE HABEN.<br />
2. Beschränkter Anspruch. Die gesamte Haftung von C1 und ihr alleiniger Anspruch unter dieser<br />
EULA besteht nach Ermessen von C1 entweder (a) in der Rückerstattung des für die SOFTWARE<br />
bezahlten Preises; (b) in der Reparatur der SOFTWARE durch Updates, die entweder online oder<br />
je nach Wahl von C1 auf anderem Wege vertrieben werden; oder (c) in der Ersetzung der<br />
SOFTWARE mit SOFTWARE, die so funktioniert, wie dies in der SOFTWARE-Dokumentation<br />
beschrieben wird, vorausgesetzt, dass Sie die SOFTWARE in gleicher Weise zurücksenden, wie<br />
unter Kapitel I.2 festgeschrieben ist, welches die Bestimmung für die Zurücksendung der<br />
SOFTWARE, im Falle dass diese EULA nicht akzeptiert wird, enthält. Für jedes Speichermedium<br />
einer reparierten oder ausgetauschten SOFTWARE wird entweder eine Garantie für den Rest der<br />
ursprünglichen Garantiefrist oder für dreißig (30) Tage gewährt, je nach dem, welcher Zeitraum<br />
länger ist. DIESE ANSPRÜCHE GELTEN NICHT AUSSERHALB DEN VEREINIGTEN<br />
STAATEN VON <strong>AM</strong>ERIKA. IM GRÖßTMÖGLICHEN DURCH DAS ANWENDBARE<br />
RECHT GESTATTETEN UMFANG IST C1 IN KEINEM FALL HAFTBAR FÜR<br />
IRGENDWELCHE SCHÄDEN WELCHER ART AUCH IMMER (EINSCHLIEßLICH UND<br />
OHNE AUSNAHME, SCHÄDEN DURCH VERLUST VON GESCHÄFTLICHEM GEWINN,<br />
DURCH GESCHÄFTSUNTERBRECHUNGEN, DURCH VERLUST VON<br />
GESCHÄFTLICHEN INFORMATIONEN ODER FÜR IRGENDWELCHE ANDEREN<br />
VERMÖGENSSCHÄDEN), DIE AUS DER VERWENDUNG DER SOFTWARE ODER DER<br />
TATSACHE, DASS SIE NICHT VERWENDET WERDEN KANN, ENTSTEHEN, SELBST<br />
WENN C1 AUF DIE MÖGLICHKEIT SOLCHER SCHÄDEN HINGEWIESEN WORDEN IST.<br />
DA EINIGE STAATEN/RECHTSORDUNGEN DIE BESCHRÄNKUNG ODER DEN<br />
AUSSCHLUSS DER HAFTUNG FÜR ZUFÄLLIGE ODER FOLGESCHÄDEN NICHT<br />
GESTATTEN, GILT DIE VORSTEHENDE BESCHRÄNKUNG FÜR SIE MÖGLICHERWEISE<br />
NICHT.<br />
V. SONSTIGES.<br />
1. Dieses ist das gesamte Vertragswerk. In Bezug auf die SOFTWARE ist diese EULA<br />
(einschließlich der Ergänzungen oder Neufassungen zu dieser EULA, die dieser SOFTWARE<br />
beigefügt sind) die endgültige, vollständige und ausschließliche Bescheinigung für das gesamte
12 · Willkommen zu <strong>ComponentOne</strong> FlexGrid für .NET<br />
Vertragswerk zwischen ihnen und C1. Diese EULA ersetzt jede früheren sowie gleichzeitigen<br />
Angebote, Kaufbestellungen, Anzeigen und alle anderen mündlichen oder schriftlichen<br />
Mitteilungen, die in Zusammenhang mit dem Gegenstand dieser EULA stehen. Nur die<br />
Bestimmungen, die in dieser EULA enthalten sind, das heißt keine anderen Vereinbarung oder<br />
Vertragswerke, die auf irgendeine Weise diese Bestimmungen verändern, sollen für die<br />
Vertragsparteien verbindlich sein. Dies trifft nicht zu, wenn die Vertragsparteien schriftlich oder<br />
auf eine andere, nicht mündliche Weise in einen Vertragsprozess treten, wobei die<br />
Vertragsparteien sachlich und endgültig in einer verbindlichen Weise handeln (wie<br />
beispielsweise durch eine anhaltende Installation der SOFTWARE, „durchklicken” durch einen<br />
Fragebogen, etc.). Den Mitarbeitern, Bevollmächtigten oder anderen Repräsentanten von C1 ist es<br />
nicht gestattet, diese EULA mündlich zu verändern.<br />
2. Sie leisten C1 Schadensersatz. Sie stimmen hiermit einer Ausschlussklausel für finanzielle<br />
Haftung zu, Sie stimmen zu, dass Sie C1 Schadensersatz leisten, und dass Sie C1, seine Zulieferer<br />
und Händler vor jeglicher Art der Anspruchsforderungen oder Gerichtsverfahren, die aus dem<br />
Bruch von Bestimmungen und Bedingungen dieser EULA resultieren, einschließlich der<br />
Anwaltskosten, zu schützen.<br />
3. Interpretation dieser EULA. Falls aus irgendeinem Grund der Gerichtsstand eine Bestimmung<br />
dieser EULA oder einen Bestandteil der Bestimmung für uneinklagbar befindet, wird diese<br />
Bestimmung dieser EULA bis zu ihrem größtmöglichen gestatteten Umfang durchgesetzt, um die<br />
Absicht der Vertragsparteien zu erwirken. Der Rest dieser EULA wird seine volle Gültigkeit<br />
beibehalten. Misslingt es einer der beiden Vertragsparteien, eine Bestimmung dieser EULA<br />
durchzusetzen, wird dies nicht als Verzicht von künftigen Durchsetzungen dieser oder anderer<br />
Bestimmungen erachtet. Sofern gesetzlich nicht anders vorgeschrieben oder verändert, unterliegt<br />
diese EULA den Gesetzen des Commonwealth von Pennsylvania, ohne den Konflikt der EULA<br />
mit den Gesetzmäßigkeiten zu betrachten. Die Vertragsparteien willigen mit der Zuständigkeit<br />
und dem Verhandlungsort des Commonwealth von Pennsylvania, dem County von Allegheny,<br />
ein und stimmen zu, dass jegliche Gerichtsverfahren, die sich aus dieser EULA ergeben, einzig in<br />
einem solchen Commonwealth ausgeführt werden. Wurde die SOFTWARE außerhalb den<br />
Vereinigten Staaten erworben, so unterliegt sie dem lokalen Recht.<br />
Häufig gestellte Fragen zur Lizenz (FAQs)<br />
Dieser Abschnitt beschreibt die wichtigsten, technischen Aspekte der Lizenz. Diese werden dem<br />
Anwender helfen, eventuelle Lizenzprobleme während der Verwendung von <strong>ComponentOne</strong> .NET und<br />
ASP.NET-Produkten zu verstehen und zu lösen.<br />
Was ist Lizenzierung?<br />
Lizenzierung ist ein Mechanismus um intellektuelles Eigentum zu schützen und um dem Anwender die<br />
Verwendung des Softwareproduktes zu gestatten.<br />
Lizenzierung soll nicht nur den illegalen Vertrieb von Softwareprodukten verhindern. Viele<br />
Softwarehersteller, darunter auch <strong>ComponentOne</strong>, verwenden Lizenzierung um einem potentiellen<br />
Anwender die Möglichkeit zu geben, dass Produkt zu testen, bevor er es möglicherweise erwirbt.<br />
Ohne Lizenzierung wäre diese Art des Vertriebes für den Hersteller unpraktisch und für den Anwender<br />
unbequem. Hersteller müssten entweder Evaluationssoftware mit begrenzter Funktionalität vertreiben,<br />
oder Sie übertragen die Lizenzverantwortung an den Kunden, der aber schnell vergessen kann, dass er<br />
nur eine Evulationsversion besitzt und das Produkt noch nicht erworben hat.
Wie funktioniert Lizenzierung?<br />
Häufig gestellte Fragen zur Lizenz (FAQs) · 13<br />
<strong>ComponentOne</strong> verwendet ein auf eine Standardlizenz von Microsoft basierendes Lizenzmodel, welches<br />
für alle Komponententypen gültig ist.<br />
Wenn ein Anwender ein Produkt erwirbt, erhält er ein Installationsprogramm und eine Serial-Nummer.<br />
Während dem Installationsprozess wird der Anwender nach der Serial-Nummer gefragt, die auf dem<br />
System gespeichert ist. (Der Anwender kann die Serial-Nummer auch eingeben, indem er auf die<br />
„License“-Schaltfläche im „Über“-Fenster eines beliebigen Produktes von <strong>ComponentOne</strong> klickt.)<br />
Wenn eine lizenzierte Komponente zu einem Formular oder einer Webseite hinzugefügt wird, dann<br />
erfragt Visual Studio die neu erstellte Komponente nach Lizenzinformationen. Die Komponente sucht<br />
dann nach den Lizenzinformationen, die im System gespeichert sind, und erstellt einen Schlüssel, der von<br />
Visual Studio in zwei Dateien gespeichert wird:<br />
1. Eine „.licenses“- Ressourcendatei, welche den eigentlichen Schlüssel beinhaltet,<br />
und<br />
2. Eine „licenses.licx“-Datei, die Verweise zu diesen Ressourcen enthält.<br />
Diese Dateien werden automatisch dem Projekt hinzugefügt.<br />
Beachten Sie, dass die „licenses.licx“-Datei normalerweise nicht im Solution Explorer angezeigt wird; sie<br />
erscheint nur, wenn Sie die „Show All Files“-Schaltfläche in der Toolbox des Solution Explorers drücken<br />
oder Project | Show All Files aus dem Hauptmenü des Visual Studios auswählen.<br />
Später, wenn die Komponente während der Runtime erstellt wird, erhält sie den Schlüssel, der in der<br />
Erstellungsphase erstellt wurde und kann entscheiden, ob sie diesen einfach akzeptiert, oder eine Störung<br />
meldet und den Prozess fehlschlagen lässt, oder ob sie eine Nachricht mit erinnernden Informationen<br />
über die unlizenzierte Software ausgibt.<br />
Alle <strong>ComponentOne</strong>-Produkte zeigen Lizenzinformationen an, wenn diese noch nicht lizenziert sind.<br />
Allerdings wird keines dieser Ereignisse Störungen senden oder die Anwendung funktionsunfähig<br />
machen.<br />
Übliche Szenarien<br />
Komponenten in der Erstellungsphase erstellen<br />
Dies ist das weitverbreitetste und einfachste Szenario: Der Anwender fügt dem Formular eine oder<br />
mehrere Steuerungen hinzu, die Lizenzinformationen werden in der „licenses.licx“-Datei gespeichert und<br />
die Komponente funktioniert.<br />
Der Mechanismus ist für „Windows Forms“ und „Web Forms“ (ASP.NET)-Projekte exakt der Gleiche.<br />
Komponenten in der Runtime erstellen<br />
Dies ist ebenfalls ein übliches Szenario. Sie benötigen keine Instanz der Komponente auf dem Formular,<br />
aber erstellen eine oder mehrere Instanzen während der Runtime.<br />
In diesem Fall wird das Projekt keine „licenses.licx“-Datei enthalten, oder die Datei wird keinen<br />
passenden Schlüssel für die Komponente enthalten, und deswegen wird die Lizenzierung fehlschlagen.<br />
Um dieses Problem zu beheben, müssen Sie eine Instanz der Komponente einem Formular in Ihrem<br />
Projekt hinzufügen. Dies wird die „licenses.licx“-Datei erstellen und alles funktioniert wie erwartet. Die<br />
Komponente kann, nachdem die „licenses.licx“-Datei erstellt wurde, wieder entfernt werden.
14 · Willkommen zu <strong>ComponentOne</strong> FlexGrid für .NET<br />
Von lizenzierten Komponenten erben<br />
Wenn eine Komponente, die von einer lizenzierten Komponente erbt, erstellt wird, so werden die<br />
Lizenzinformationen, die im Formular gespeichert werden, immer noch benötigt. Dies kann auf zwei<br />
Wegen getan werden:<br />
1. Fügen Sie ein „LicenseProvider“-Attribut der Komponente hinzu.<br />
Dieses Attribut wird die Komponente als lizenziert markieren. Wenn eine Komponente zu einem<br />
Formular hinzugefügt wird, erstellt und verwaltet Visual Studio die „licenses.licx“-Datei, und<br />
die „base-Klasse“ wird den Lizenzierungsprozess wie üblich handhaben. Es ist kein weiteres<br />
Eingreifen nötig. Zum Beispiel:<br />
[LicenseProvider(typeof(LicenseProvider))]<br />
class MyGrid: C1.Win.<strong>C1FlexGrid</strong>.<strong>C1FlexGrid</strong><br />
{<br />
// ...<br />
}<br />
2. Fügen Sie eine Instanz der Basiskomponente dem Formular hinzu.<br />
Dies wird die Lizenzinformationen, wie in den vorhergehenden Szenarien in die „licenses.licx“-<br />
Datei einbetten. Die Basiskomponente wird die Informationen finden und verwenden. Wie<br />
zuvor, kann auch hier die zusätzliche Instanz, nachdem die „licenses.licx“-Datei erstellt wurde,<br />
wieder gelöscht werden.<br />
Lizenzierte Komponenten in Konsole-Anwendungen verwenden<br />
Wenn eine Konsole-Anwendung erstellt wird, gibt es keine Formulare denen eine Komponente<br />
hinzugefügt werden kann, so dass Visual Studio keine „licenses.licx“-Datei erstellt.<br />
In diesen Fällen müssen Sie eine vorübergehende „Windows Forms“-Anwendung erstellen und alle<br />
gewünschten und lizenzierten Komponenten einem Formular anhängen. Schließen Sie dann die<br />
„Windows Forms“-Anwendung und kopieren Sie die „licenses.licx“-Datei in das Projekt der Konsole-<br />
Anwendung.<br />
Stellen Sie sicher, dass die „licensex.licx“-Datei als eingebettete Ressource konfiguriert ist. Dazu müssen<br />
Sie die „licenses.licx“-Datei im Solution Explorer-Fenster rechtsklicken und Eigenschaften auswählen. Im<br />
Eigenschaftsfenster müssen Sie anschließend die „Build Action“-Eigenschaft auf „Embedded Resource“<br />
stellen.<br />
Lizenzierte Komponenten in Visual C++-Anwendungen verwenden<br />
Es scheint als wäre ein Fehler in VC++ 2003. Die „licenses.licx“-Datei wird während des<br />
Erstellungsprozesses nicht berücksichtigt und daher die Lizenzinformationen in VC++-Anwendungen<br />
nicht verarbeitet.<br />
Um dieses Problem zu beheben, kompilieren Sie die Lizenzressourcen und verknüpfen diese mit dem<br />
Projekt wie folgt:<br />
1. Erstellen Sie das C++-Projekt wie üblich. Dies sollte eine *.exe-Datei und auch die „licenses.licx“-<br />
Datei mit den Lizenzinformationen erzeugen.<br />
2. Kopieren Sie die „licenses.licx“-Datei aus dem „app“-Verzeichnis in das Zielverzeichnis „Debug“<br />
oder „Release“.<br />
3. Kopieren Sie das C1Lc.exe-Werkzeug und die lizenzierten *.dlls in das Zielverzeichnis.<br />
Verwenden Sie nicht die standard lc.exe. Diese hat einen Fehler.)
Häufig gestellte Fragen zur Lizenz (FAQs) · 15<br />
4. Verwenden Sie C1Lc.exe um die „licenses.licx“-Datei zu kompilieren. Die Kommandozeile sollte<br />
wie folgt aussehen:<br />
c1lc /target:MyApp.exe /complist:licenses.licx /i:C1.Win.<strong>C1FlexGrid</strong>.dll<br />
5. Verknüpfen Sie nun die Lizenz in das Projekt, indem Sie zurück zu Visual Studio gehen, das<br />
Projekt rechtsklicken, Eigenschaften auswählen und bis zur Linker/Command Line-Option<br />
gehen. Schreiben Sie nun Folgendes:<br />
/ASSEMBLYRESOURCE:Debug\MyApp.exe.licenses<br />
6. Erstellen Sie erneut die ausführbare Datei um die Lizenzinformationen in die Anwendung<br />
einzuschließen.<br />
Fehlerbehebung<br />
Wir versuchen die Lizenzierungsmechanismen so unauffällig wie möglich zu gestallten, aber Probleme<br />
werden aus verschiedenen Gründen auftreten.<br />
Nachfolgend stehen Beschreibungen häufiger Probleme und deren Lösung.<br />
Ich besitze eine lizenzierte Version eines <strong>ComponentOne</strong>-Produkts, aber ich bekomme immer noch den<br />
Startbanner, wenn ich das Projekt ausführe.<br />
Wenn dies passiert, dann muss es ein Problem mit der „licenses.licx“-Datei in ihrem Projekt geben.<br />
Entweder existiert die Datei nicht, sie enthält die falschen Informationen oder sie ist nicht richtig<br />
konfiguriert.<br />
Versuchen Sie zunächst eine vollständig neue Kompilierung („Rebuild All“ aus dem Visual Studio Build-<br />
Menü). Diese sollte normalerweise die richtigen Lizenzressourcen wiederherstellen.<br />
Wenn dies fehlschlägt, dann folgen Sie diesen Schritten:<br />
1. Öffnen Sie das Projekt und gehen Sie zu dem Solution Explorer-Fenster.<br />
2. Klicken Sie oben im Fenster auf die „Show All Files“-Schaltfläche.<br />
3. Suchen und löschen Sie die „licenses.licx“-Datei.<br />
4. Schließen Sie das Projekt und öffnen Sie es wieder.<br />
5. Öffnen Sie das Hauptformular und fügen Sie eine Instanz von jeder lizenzierten Steuerung hinzu.<br />
6. Überprüfen Sie im Solution Explorer-Fenster, ob die „licenses.licx“-Datei vorhanden ist.<br />
7. Erstellen Sie das Projekt mit der „Rebuild All“-Option erneut; nicht nur „Rebuild“.<br />
Ich besitze eine lizenzierte Version eines <strong>ComponentOne</strong>-Produkts auf meinem Web Server, aber die<br />
Komponenten verhalten sich immer noch wie nicht lizenziert.<br />
Es muss keine Lizenz auf einem Computer, der als Server und nicht als Entwicklungsumgebung<br />
verwendet wird, installiert sein.<br />
Die Komponenten müssen auf dem Entwicklungscomputer lizenziert sein, da die Lizenzinformationen in<br />
der ausführbaren Dateien (*:exe oder *.dll) während der Projektkompilierung gespeichert werden.<br />
Danach kann die Anwendung auf jedem Computer und auch auf Web Servern ausgeführt werden.
16 · Willkommen zu <strong>ComponentOne</strong> FlexGrid für .NET<br />
Ich lade mir eine neue Version einer Komponente, die ich gekauft habe, herunter und nun bekomme ich<br />
das Banner wenn ich meine Projekte kompiliere.<br />
Stellen Sie sicher, dass der Lizenzschlüssel immer noch gültig ist. Wenn Sie die Komponente vor mehr als<br />
einem Jahr lizenziert haben, dann ist Ihr Abonnement eventuell abgelaufen. In diesem Fall haben Sie<br />
zwei Möglichkeiten.<br />
Option 1 – Erneuern Sie ihr Abonnement um einen neuen Lizenzschlüssel zu erhalten.<br />
Wenn Sie diese Option wählen, erhalten Sie einen neuen Schlüssel. Mit diesem können Sie die neuen<br />
Komponenten direkt im Installationsmenü oder im „Über“-Fenster lizenzieren.<br />
Das neue Abonnement berechtigt Sie für ein ganzes Jahr die neusten Versionen und Builds direkt über<br />
unsere Webseite http://prerelease.componentone.com/ zu erhalten.<br />
Option 2 – Die bestehenden Komponenten weiterverwenden.<br />
Abonnements laufen ab, Produkte aber nicht. Sie können weiterhin die Komponenten, die Sie erhalten<br />
oder heruntergeladen haben, auch mit abgelaufenem Abonnement verwenden.<br />
Technische Unterstützung<br />
<strong>ComponentOne</strong> FlexGrid für .NET wurde von <strong>ComponentOne</strong> LLC - einem Zusammenschluss der<br />
Firmen APEX Software Corporation und VideoSoft - entwickelt. Folgende Wege stehen Ihnen für die<br />
technische Unterstützung offen:<br />
<strong>ComponentOne</strong> Webseite<br />
Die <strong>ComponentOne</strong>-Webseite www.componentone.com hält reichhaltige Informationen und<br />
Softwaredownloads für FlexGrid .NET-Anwender bereit. Darunter befindet sich auch:<br />
Per eMail<br />
• Beschreibungen der verschiedenen Supportoptionen.<br />
• Nach Funktionalität sortierte Antworten zu häufig gestellten Fragen „FAQ“ über unsere<br />
Produkte. Bitte schauen Sie zunächst in den FAQ's nach, bevor Sie uns direkt kontaktieren, da<br />
dies Ihnen möglicherweise viel Zeit erspart und Sie außerdem viele neue Informationen über<br />
unsere Produkte erfahren können.<br />
• Kostenlose Produktupdates mit Fehlerbehebungen und neuen Funktionen.<br />
Für technische Unterstützung über das Internet, schreiben Sie eine eMail an:<br />
Support.FlexGrid.NET@componentone.com<br />
Um sicherzustellen, dass Sie die bestmögliche Unterstützung erhalten, schreiben Sie uns bitte folgende<br />
Informationen, wenn Sie <strong>ComponentOne</strong> kontaktieren:<br />
• Ihre <strong>ComponentOne</strong> Produktseriennummer.<br />
• Die Version und den Namen Ihres Betriebssystems.<br />
• Ihre Entwicklungsumgebung und die Version.<br />
Für weitere Informationen zur technischen Unterstützung besuchen Sie bitte unsere Webseite unter:<br />
www.componentone.com/support
Peer-to-Peer Newsgroup<br />
Wiedervertreibbare Dateien · 17<br />
<strong>ComponentOne</strong> unterstützt auch eine Peer-to-Peer Newsgroup für Anwender. <strong>ComponentOne</strong> bietet<br />
allerdings keine formale technische Unterstützung in diesen Newsgroups an, sondern gibt Ihnen die<br />
Möglichkeit, Fragen über unsere Produkte einzustellen und die Fragen anderer Teilnehmer zu<br />
beantworten. Dennoch wird <strong>ComponentOne</strong> die Newsgroup-Einträge verfolgen, um die Richtigkeit der<br />
Informationen sicherzustellen und eventuell Kommentare zu hinterlassen, wenn dies nötig ist. Sie<br />
können die Newsgroup über die Webseite von <strong>ComponentOne</strong> erreichen:<br />
www.componentone.com/newsgroups.<br />
Wiedervertreibbare Dateien<br />
<strong>ComponentOne</strong> FlexGrid für .NET wurde von <strong>ComponentOne</strong> LLC entwickelt und veröffentlicht. Sie<br />
dürfen es verwenden, um Programme in Verbindung mit Microsoft Visual Studio oder jeder anderen<br />
Programmierumgebung, die es dem Anwender ermöglicht, Steuerungen zu integrieren und zu<br />
verwenden, zu erstellen. Sie dürfen weiterhin die folgenden wiedervertreibbaren Dateien gebührenfrei<br />
mit der von Ihnen entwickelten Anwendung vertreiben, sofern diese auf einem separaten Computer mit<br />
einer CPU auf der Client/Workstation-Seite des Netzwerkes läuft:<br />
• C1.Common.dll<br />
• C1.Win.C1Flexgrid.Classic.dll<br />
• C1.Win.C1Flexgrid.dll<br />
Platzlizenzen sind für Gruppen von mehreren Entwicklern verfügbar. Bitte kontaktieren Sie<br />
Sales@<strong>ComponentOne</strong>.com für weitere Einzelheiten.<br />
Namensbereiche (Namespaces)<br />
Namensbereiche organisieren die in einer Assembly definierten Objekte. Assemblies können mehrere<br />
Namensbereiche enthalten, die wiederum andere Namensbereiche enthalten können. Namensbereiche<br />
verhindern Mehrdeutigkeit und vereinfachen die Referenzierung wenn Sie große Objektgruppen, wie<br />
zum Beispiel Klassenbibliotheken, verwenden.<br />
Der allgemeine Namensbereich für Windowsprodukte von <strong>ComponentOne</strong> ist C1.Win. Der<br />
Namensbereich für die FlexGrid-Steuerung ist C1.Win.<strong>C1FlexGrid</strong>. Der folgende Quelltext zeigt, wie<br />
eine <strong>C1FlexGrid</strong>-Steuerung unter Verwendung des vollständig qualifizierten Namens dieser Klasse<br />
deklariert wird:<br />
• Visual Basic<br />
• C#<br />
Dim flex As C1.Win.<strong>C1FlexGrid</strong>.<strong>C1FlexGrid</strong><br />
C1.Win.<strong>C1FlexGrid</strong>.<strong>C1FlexGrid</strong> flex;<br />
• Delphi<br />
uses C1.Win.<strong>C1FlexGrid</strong>;<br />
Namensbereiche adressieren ein Problem, welches unter dem Namen namespace pollution bekannt ist.<br />
Hierbei wird der Entwickler einer Klassenbibliothek durch die Verwendung von ähnlichen Namen in<br />
anderen Bibliotheken behindert. Diese Konflikte mit existierenden Komponenten werden auch name<br />
collisions genannt.
18 · Willkommen zu <strong>ComponentOne</strong> FlexGrid für .NET<br />
Zum Beispiel, wenn Sie eine neue Klasse mit dem Namen Column erzeugen, dann können Sie diese<br />
innerhalb Ihres Projektes ohne Qualifikation verwenden. Die <strong>C1FlexGrid</strong>-Assembly implementiert<br />
allerdings auch eine Klasse namens Column. Wenn Sie also die <strong>C1FlexGrid</strong>-Klasse in demselben Projekt<br />
verwenden wollen, dann müssen Sie eine vollständig qualifizierte Referenz verwenden, damit diese<br />
einzigartig ist. Wenn die Referenz nicht einzigartig ist, dann wird Visual Studio .NET einen Fehler wegen<br />
der Mehrdeutigkeit des Namens erzeugen. Der folgende Quellcode zeigt, wie diese Objekte deklariert<br />
werden müssen:<br />
• Visual Basic<br />
• C#<br />
' Define a new Column object (custom Column class)<br />
Dim MyCol as Column<br />
' Define a new <strong>C1FlexGrid</strong>.Column object.<br />
Dim FlexCol as C1.Win.<strong>C1FlexGrid</strong>.Column<br />
// Define a new Column object (custom Column class)<br />
Column MyCol;<br />
// Define a new <strong>C1FlexGrid</strong>.Column object.<br />
C1.Win.<strong>C1FlexGrid</strong>.Column FlexCol;<br />
• Delphi<br />
var<br />
FlexCol: C1.Win.<strong>C1FlexGrid</strong>.Column;<br />
MyCol: Column;<br />
Vollständig qualifizierte Namen sind Objektreferenzen mit dem Namen des Namensbereiches, wo das<br />
Objekt definiert ist, als Vorsilbe. Sie können Objekte aus anderen Projekten verwenden, wenn Sie eine<br />
Referenz zu der Klasse erstellen, indem Sie „Add Reference“ aus dem Project-Menü auswählen und dann<br />
denn vollständig qualifizierten Namen für das Objekt in Ihren Quellcode einbauen.<br />
Vollständig qualifizierte Namen verhindern Namenskonflikte, weil der Kompiler immer feststellen kann,<br />
welches Objekt verwendet wird. Die Namen selbst können aber schnell lang und lästig werden. Um dies<br />
zu umgehen, können Sie die Import-Anweisung „import in C#“ verwenden, um ein Alias zu definieren<br />
— ein abgekürzter Name, den Sie anstelle des vollständig qualifizierte Namen einsetzen können. Zum<br />
Beispiel, der folgende Quellcodeausschnitt erzeugt Aliasse für zwei vollständig qualifizierte Namen und<br />
verwendet diese dann um zwei Objekte zu definieren:<br />
• Visual Basic<br />
• C#<br />
Imports C1Column = C1.Win.<strong>C1FlexGrid</strong>.Column<br />
Imports MyColumn = MyProject.Column<br />
Dim c1 As C1Column<br />
Dim c2 As MyColumn<br />
using C1Column = C1.Win.<strong>C1FlexGrid</strong>.Column;<br />
using MyColumn = MyProject.Column;<br />
C1Column c1;<br />
MyColumn c2;<br />
• Delphi<br />
uses C1.Win.<strong>C1FlexGrid</strong>.Column,<br />
MyProject.Column;<br />
var
c2: MyColumn;<br />
c1: C1Column;<br />
Ein .NET-Projekt erstellen · 19<br />
Wenn Sie den Import-Befehl ohne einen Alias verwenden, dann können Sie alle Namen in diesem<br />
Namensbereich ohne entsprechende Qualifikation aber trotzdem einzigartig in Ihrem Projekt nutzen.<br />
Ein .NET-Projekt erstellen<br />
Dieses Thema zeigt, wie ein neues .NET-Projekt erstellt wird.<br />
1. Wählen Sie New aus dem File-Menü in Microsoft Visual Studio .NET aus, und klicken Sie auf<br />
Project. Das New Project-Fenster öffnet sich.<br />
2. Wählen Sie entweder Visual Basic-Projekts oder Visual C# Projects in der Project Types-Box aus<br />
und klicken Sie auf Windows Application in der Vorlagenliste auf der rechten Seite.<br />
3. Suchen Sie einen Ort für Ihre Anwendung im Location-Feld oder geben Sie einen Ort ein und<br />
klicken Sie auf OK.<br />
Ein neues Microsoft Visual Studio .NET-Projekt wird am angegebenen Ort erstellt. Außerdem<br />
wird ein neues Form1 (Formular1) in der Designer-Ansicht angezeigt.<br />
4. Doppelklicken Sie die <strong>C1FlexGrid</strong>-Komponente in der Toolbox, um diese dem Form1<br />
hinzuzufügen. Für weitere Informationen über das Hinzufügen von Komponenten zur Toolbox<br />
schauen Sie unter „Die <strong>C1FlexGrid</strong> Component der Toolbox hinzufügen“ (Seite 20) nach.
20 · Willkommen zu <strong>ComponentOne</strong> FlexGrid für .NET<br />
Die <strong>C1FlexGrid</strong> Component der Toolbox hinzufügen<br />
Wenn <strong>C1FlexGrid</strong> installiert wird, dann erscheinen folgende neue Komponenten in der Toolbox des<br />
Anpassungsfensters von Visual Studio:<br />
• <strong>C1FlexGrid</strong><br />
• <strong>C1FlexGrid</strong>Classic<br />
<strong>C1FlexGrid</strong> ist die Komponente, die neue Wege für das Anzeigen, Bearbeiten, Formatieren, Organisieren,<br />
Zusammenfassen und Drucken von tabellarischen Daten bereitstellt.<br />
Mit der <strong>C1FlexGrid</strong>Classic-Komponente können Sie existierende VSFlexGrid-Projekte migrieren.<br />
Um diese Komponenten verwenden zu können, müssen diese der Visual Studio-Toolbox hinzugefügt<br />
werden:<br />
Öffnen Sie die Visual Studio IDE (Microsoft Development Environment). Stellen Sie sicher, dass die<br />
Toolbox angezeigt wird. Wählen Sie Toolbox im View (Ansicht)-Menü aus, wenn nötig. Rechtsklicken Sie<br />
die Toolbox um das Kontextmenü der Toolbox zu öffnen.<br />
Wenn Sie die <strong>C1FlexGrid</strong>- und <strong>C1FlexGrid</strong>Classic-Komponente auf deren eigenen Reiter in der Toolbox<br />
anzeigen lassen wollen, dann wählen Sie Add Tab aus dem Kontextmenü aus und schreiben Sie den<br />
Namen des Reiters hinein: zum Beispiel „<strong>C1FlexGrid</strong>”. Wählen Sie den Reiter aus, in dem die<br />
Komponente erscheinen soll. Rechtsklicken Sie diesen und wählen Sie Customize Toolbox… aus dem<br />
Kontextmenü aus. Das Customize Toolbox-Fenster wird sich öffnen.<br />
Gehen Sie zum .NET Framework Komponenten-Reiter im Customize Toolbox-Fenster. Sortieren Sie die<br />
Liste nach Namensbereichen, klicken Sie auf die Spaltenüberschrift „Namensbereich“ und markieren Sie<br />
das Auswahlfeld für die Komponente, die zu dem Namensbereich C1.Win.<strong>C1FlexGrid</strong> gehört.
Die <strong>C1FlexGrid</strong>-Steuerung verwenden · 21<br />
Die <strong>C1FlexGrid</strong>-Steuerung verwenden<br />
Mit der <strong>C1FlexGrid</strong>-Steuerung können Sie tabellarische Daten anzeigen, bearbeiten, gruppieren und<br />
zusammenfassen. Die Tabellensteuerung kann an eine Datenquelle gebunden sein, oder Sie verwaltet<br />
ihre eigenen Daten.<br />
Die <strong>C1FlexGrid</strong>-Steuerung hat ein reichhaltiges Objektmodel mit den folgenden Elementen:<br />
Der folgende Abschnitt begleitet Sie durch die Hauptfunktionen der <strong>C1FlexGrid</strong>-Steuerung:<br />
Layout Beschreibt wie die Tabellengröße und das Layout festgelegt werden.<br />
Auswahl Beschreibt die Konzepte „current cell“ (aktuelle Zelle) und „selection“<br />
(Auswahl).
22 · Die <strong>C1FlexGrid</strong>-Steuerung verwenden<br />
Zellen bearbeiten Beschreibt die Implementierung von einfacher Textbearbeitung, Drop-down-<br />
Listen und Kombolisten, Zellschaltflächen, Maskenbearbeitung und<br />
Datengültigkeit.<br />
Zellen formatieren Beschreibt wie das Format einer Tabelle bearbeitet wird: Zahlenformate,<br />
Datums und Wahrheitswerte, Schriftart und Schriftfarbe, Textausrichtung<br />
und Grafiken für einzelne Zellen oder eine gesamte Auswahl.<br />
Zellen verbinden Beschreibt wie die Tabellenansicht verändert wird, so dass Zellen mit<br />
ähnlichen Inhalten verschmelzen und somit eine Art „gruppierte“ Ansicht die<br />
verwandten Daten markiert.<br />
Zusammenfassen<br />
und Gliederung<br />
Beschreibt wie Zwischensummen der Tabelle hinzugefügt und<br />
Gliederungsbäume erstellt werden.<br />
Datenbindungen Diskutiert die grundlegenden Aspekte der ADO/OLEDB- und DAO-<br />
Datenbindungen.<br />
Speichern, Laden<br />
und Drucken<br />
Layout<br />
Beschreibt wie Sie den Inhalt oder die Formatierung einer Tabelle speichern<br />
und später wieder laden, oder Tabellendaten mit anderen Anwendungen,<br />
wie zum Beispiel Microsoft Access und Excel, austauschen können. Dieser<br />
Abschnitt zeigt Ihnen auch, wie Sie Tabellen drucken können.<br />
Eigenschaftsgruppen Zeigt eine Übersicht der mit Querverweisen referenzierten<br />
Haupteigenschaften von <strong>C1FlexGrid</strong>.<br />
Eine <strong>C1FlexGrid</strong>-Steuerung besteht aus Zeilen und Spalten. Alle Zeilen und Spalten werden durch die<br />
Eigenschaften Rows und Cols festgelegt.<br />
Wenn die Tabellensteuerung an eine Datenquelle gebunden ist, dann wird die Anzahl der Zeilen und<br />
Spalten durch die vorhandenen Daten bestimmt. Im ungebundenen Modus können Sie diesen<br />
willkürliche Werte mit der Count-Eigenschaft der „Collections“ zuordnen. Zum Beispiel der<br />
nachstehende Quellcode legt die Tabellengröße auf 500 Zeilen und 10 Spalten fest:<br />
• Visual Basic<br />
• C#<br />
fg.Rows.Count = 500<br />
fg.Cols.Count = 10<br />
fg.Rows.Count = 500;<br />
fg.Cols.Count = 10;<br />
• Delphi<br />
fg.Rows.Count := 500;<br />
fg.Cols.Count := 10;<br />
Es gibt zwei grundlegende Typen von Zeilen und Spalten: fixed und scrollable. Feste Zeile verweilen<br />
immer oben in der Tabelle, wenn der Anwender die Tabelle vertikal blättert. Feste Spalten verweilen<br />
immer links, wenn der Anwender horizontal blättert. Feste Zellen sind für die Anzeige von Überschriften<br />
nützlich. Die Anzahl, die von der Count-Eigenschaft zurückgegeben wird, enthält feste und scrollbare<br />
Zellen.<br />
Sie können die Anzahl der festen Zeilen und Spalten mit der Fixed-Eigenschaft in den Rows- und Cols-<br />
Collections festlegen. Zum Beispiel der nachfolgende Quellcode erstellt eine Tabelle mit einer festen<br />
Zeilen und keiner festen Spalte:
• Visual Basic<br />
• C#<br />
fg.Rows.Fixed = 1<br />
fg.Cols.Fixed = 0<br />
fg.Rows.Fixed = 1;<br />
fg.Cols.Fixed = 0;<br />
• Delphi<br />
fg.Rows.Fixed := 1;<br />
fg.Cols.Fixed := 0;<br />
Layout · 23<br />
Die Rows- und Cols-Collections enthalten auch Methoden zum Einfügen, Löschen und Verschieben von<br />
Zeilen und Spalten in der Tabelle. Sie können deren Item-Eigenschaft verwenden (ein Zähler) um<br />
einzelne Elemente (Zeilen und Spalten) in jeder Collection anzusprechen.<br />
Spalten mit dem <strong>C1FlexGrid</strong>-Spalteneditor bearbeiten<br />
Wenn Sie dies bevorzugen, können Sie die Tabellenspalten während der Erstellungsphase einrichten,<br />
anstatt denn Quellcode hierfür zu schreiben. Wählen Sie die Tabelle in .Net aus, gehen Sie zu den<br />
Eigenschaften und klicken Sie auf die Schaltfläche neben der Cols-Eigenschaft, oder rechtsklicken Sie die<br />
Steuerung und wählen Sie das Edit Columns…-Menü aus. Dies wird den nachfolgend gezeigten Column<br />
Editor öffnen:<br />
Im gebundenen Modus kann der Editor verwendet werden, um festzulegen, welche Felder der<br />
DataSource angezeigt werden, in welcher Reihenfolge, mit welchen Spaltenüberschriften, wie Breit und<br />
mit welcher Ausrichtung. Im ungebundenen Modus kann im Editor zusätzlich der Datentyp der Spalte<br />
bestimmt werden.<br />
Mit dem Editor können Sie folgende Tätigkeiten durchführen:<br />
1. Spalten neu anordnen: Sie können Spalten verschieben, indem Sie diese mit der Überschriftszelle<br />
auf eine neue Position ziehen.<br />
2. Spaltenbreiten anpassen: Sie können die Spaltenbreiten verändern, indem Sie die rechte Kante<br />
der Überschriftszelle mit der Maus ziehen. Sie können auch mehrere Spalten auswählen, indem
24 · Die <strong>C1FlexGrid</strong>-Steuerung verwenden<br />
Auswahl<br />
Sie die Shift-Taste während der Klicks auf die Überschriften halten und anschließend alle<br />
Spaltenbreiten auf einmal über das Eigenschaftsfenster festlegen. Wenn Sie die Spaltenbreite auf<br />
–1 stellen, dann wird die Standardbreite verwendet.<br />
3. Spalteneigenschaften festlegen: Immer wenn eine oder mehrere Spalten ausgewählt sind, dann<br />
können Sie deren Eigenschaften im Eigenschaftsfenster auf der linken Seite des Editors einsehen<br />
und verändern.<br />
4. Spalten einfügen oder löschen: Verwenden Sie die Symbolleiste um Spalten vor oder nach einer<br />
Auswahl einzufügen oder zu löschen. Dies ist oft im ungebundenen Modus nützlich.<br />
5. Die Symbolleiste für gängige Aufgaben verwenden: Nachfolgende Tabelle beschreibt die<br />
Funktionen der Schaltflächen in der Symbolleiste:<br />
Diese Schaltflächen sind Umschalter, die das Eigenschaftsfenster steuern. Der<br />
Erste legt fest, ob die Eigenschaften für die ausgewählten Spalten in<br />
alphabetischer oder kategorisierter Reihenfolge angezeigt werden. Der Zweite legt<br />
fest, ob die Eigenschaftstabelle Beschreibungen für die ausgewählten<br />
Eigenschaften anzeigen soll.<br />
Undo (Rückgängig): Setzt alle Änderungen zurück und stellt den<br />
Ausgangszustand der Tabellenspalten wieder her.<br />
Insert Column (Spalten einfügen): Fügt Spalten links oder rechts der Auswahl<br />
ein. Diese Schaltflächen sind nur für ungebundene Tabellen verfügbar.<br />
Remove Column (Spalten löschen): Löscht die ausgewählte Spalte.<br />
Column Width (Spaltenbreite): Legt für alle ausgewählten Spalten dieselbe Breite<br />
fest, macht diese breiter oder schmaler.<br />
Make Visible (Einblenden): Blendet alle Spalten ein. Wenn Sie die Visible-<br />
Eigenschaft einer Spalte auf FALSE stellen, dann wird diese ausgeblendet und<br />
kann dadurch nicht mehr mit der Maus ausgewählt werden. Verwenden Sie diese<br />
Schaltfläche um alle Spalten anzuzeigen, so dass Sie diese auswählen und<br />
bearbeiten können.<br />
Alignment (Ausrichtung): Richten Sie die Spalteninhalte links-, zentriert oder<br />
rechtsbündig aus. Diese Befehle betreffen nur den scrollbaren Bereich der Tabelle.<br />
Um die Ausrichtung der Spaltenüberschrift vorzunehmen, wählen Sie die Spalte<br />
aus und setzen Sie die TextAlignFixed-Eigenschaft entsprechend.<br />
AutoResize (Optimale Breite): Diese Schaltfläche legt fest, ob eine Tabelle mit<br />
gebundener Datenquelle automatisch die optimalen Breiten der Spalten bestimmen<br />
soll, um deren Inhalt anzuzeigen.<br />
Reload from Datasource (Daten erneut laden): Überschreibt alle Spalten mit den<br />
Informationen der aktuellen DataSource (Datenquelle). Diese Schaltfläche ist<br />
nützlich, wenn die Tabellensteuerung an eine Datenquelle gebunden ist und sie mit<br />
der Bearbeitung von vorn beginnen wollen. Diese Schaltfläche ist deaktiviert, wenn<br />
die Tabellensteuerung nicht an eine Datenquelle gebunden ist.<br />
Die Tabellensteuerung besitzt eine Cursorzelle, welche bei aktiver Tabelle von einem fokussierenden<br />
Rechteck umgeben ist. Der Anwender kann den Cursor mit der Tastatur oder der Maus bewegen und<br />
den Inhalt der markierten Zelle bearbeiten, wenn die Tabelle bearbeitbar ist.
Auswahl · 25<br />
Sie können die aktuelle Zelle im Quellcode mit der Row- und Col-Eigenschaft festlegen. Wenn Sie eine<br />
dieser Eigenschaften auf –1 stellen, dann wird der Cursor versteckt.<br />
Die Tabellensteuerung unterstützt extended selections - eine erweiterte rechteckige Auswahl über<br />
mehrere Zellen, die durch zwei sich gegenüberliegende Ecken definiert wird: Die Cursorzelle und die<br />
Auswahlzelle. Sie können die Auswahlzelle mit der RowSel- und ColSel-Eigenschaft im Quellcode<br />
auslesen und festlegen. Sie können die Auswahl im Quellcode auch mit der Select-Methode festlegen.<br />
Achtung: Wenn sich die Cursorzelle ändert, dann wird die Auswahl automatisch zurückgesetzt. Um eine<br />
erweiterte Auswahl im Quellcode zu erstellen, legen Sie entweder Row und Col vor der RowSel und<br />
ColSel fest oder verwenden Sie die Select-Methode.<br />
Die Erscheinung der Auswahl wird von den folgenden Eigenschaften bestimmt:<br />
1. FocusRect legt den Typ des fokussierenden Rechtecks für die Markierung der aktuellen<br />
Cursorzelle fest.<br />
2. HighLight legt fest, wann die Auswahl markiert werden soll, beispielsweise immer dann, wenn<br />
die Steuerung einen Fokus hat, oder niemals.<br />
3. Styles.HighLight und Styles.Focus sind Zellformate, die die Erscheinung der Auswahl in<br />
Schriftart, Schriftfarbe und Zellrahmen festlegen.<br />
Der Typ der verfügbaren Auswahl wird durch die SelectionMode-Eigenschaft bestimmt. Standardmäßig<br />
unterstützt die Tabellensteuerung normale Bereichsauswahl. Sie können dieses Verhalten verändern, um<br />
der erweiterten Auswahl, der Auswahl nach Zeilen oder Spalten oder im Listenfeldmodus vorzubeugen.<br />
Der Listenfeldmodus erlaubt die Auswahl einzelner Zeilen.<br />
Wenn Sie den Listenfeldauswahlmodus wählen, dann können Sie den Auswahlstatus für einzelne Zeilen<br />
festlegen oder auslesen, indem Sie die Rows(index).Selected-Eigenschaft verwenden. Sie können auch<br />
alle ausgewählten Zeilen mit der Rows.Selected-Eigenschaft abrufen. Zum Beispiel der nachfolgende<br />
Quellcode wählt alle Zeilen aus, die eine bestimmte Bedingung erfüllen:<br />
• Visual Basic<br />
• C#<br />
fg.SelectionMode = SelectionModeEnum.ListBox<br />
Dim index As Integer<br />
For index = fg.Rows.Fixed To fg.Rows.Count – 1<br />
If Val(fg(index, "Sales")) > 80000 Then<br />
fg.Rows(index).Selected = True<br />
End If<br />
Next<br />
Console.WriteLine("There are now {0} rows selected", _<br />
fg.Rows.Selected.Count)<br />
fg.SelectionMode = SelectionModeEnum.ListBox;<br />
for (int index = fg.Rows.Fixed ; index < fg.Rows.Count; index++)<br />
{<br />
if ( Val(fg(index, "Sales")) > 80000) {<br />
fg.Rows(index).Selected = true;<br />
}<br />
}<br />
Console.WriteLine("There are now {0} rows selected",<br />
fg.Rows.Selected.Count);
26 · Die <strong>C1FlexGrid</strong>-Steuerung verwenden<br />
• Delphi<br />
var<br />
index: Integer;<br />
begin<br />
fg.SelectionMode := SelectionModeEnum.ListBox;<br />
while (index 80000) then<br />
fg.Rows(index).Selected := True;<br />
Inc(index);<br />
end;<br />
Console.WriteLine('There are now {0} rows selected',<br />
fg.Rows.Selected.Count);<br />
end;<br />
Datenbindungen<br />
Datenbindung ist ein Prozess, der es mehreren Datennutzern ermöglicht, auf synchronisierte Weise an<br />
eine Datenquelle gebunden zu sein. Wenn Sie den Cursor in einer datengebundenen Tabellensteuerung<br />
bewegen, dann wird diese Bewegung in allen anderen, mit der Tabelle verbundenen Steuerungen<br />
ebenfalls durchgeführt. Wenn Sie einen Zellwert in einer datengebundenen Tabellensteuerung<br />
verändern, dann wird diese Veränderung auch in allen anderen, mit der Tabelle verbundenen<br />
Steuerungen durchgeführt und der neue Wert angezeigt.<br />
<strong>C1FlexGrid</strong> unterstützt Datenbindungen zu ADO.NET-Datenquellobjekten, wie zum Beispiel DataTable,<br />
DataView, DataSet und DataViewManager.<br />
<strong>C1FlexGrid</strong> unterstützt auch Datenbindungen zu <strong>ComponentOne</strong>-Datenobjektkomponenten, wie zum<br />
Beispiel C1ExpressTable, C1ExpressVew, C1ExpressConnection, C1DataView, C1DataTableSource<br />
und C1DataSet.<br />
Um eine Tabellensteuerung an eine Datenquelle zu binden, müssen Sie das Datenquellobjekt in die<br />
DataSource-Eigenschaft der Tabellensteuerung eintragen. Wenn das Datenquellobjekt mehr als eine<br />
Tabelle beinhaltet, dann müssen Sie in der DataMember-Eigenschaft festlegen, welche Tabelle genutzt<br />
werden soll.<br />
Alternativ können Sie beide Eigenschaften gleichzeitig setzten, indem Sie die SetDataBinding-Methode<br />
einmal aufrufen.<br />
Wenn Sie eine neue Datenquelle einer Steuerung hinzufügen, dann wird diese automatisch ihre Spalten<br />
aktualisieren, um sie dann an die Spalten der Datenquelle zu binden. Sie können die Spalten anpassen<br />
indem Sie diese verschieben, verstecken oder löschen. Sie können auch die Spalteneigenschaften, wie<br />
zum Beispiel Width, EditMask und Format, verändern.<br />
Für ein Beispiel zur Neuordnung der Tabellenspalten nachdem eine Datenquelle verbunden wurde,<br />
schauen Sie sich bitte das Beispiel „ColumnOrder“ in unserer online Beispielbibliothek an.<br />
Für Details über das Erstellen von ADO.NET-Datenquellobjekten, schauen Sie bitte in der .NET<br />
Framework-Dokumentation nach.<br />
Für Details über <strong>ComponentOne</strong>-Datenobjekte, schauen Sie bitte in der C1DataObjects-Dokumentation<br />
nach. Diese ist zu finden in der <strong>ComponentOne</strong> Studio für .NET-Dokumentation.
Daten speichern und laden<br />
Daten speichern und laden · 27<br />
Das <strong>C1FlexGrid</strong> kann im gebundenen und ungebundenen Modus verwendet werden. Im gebundenen<br />
Modus ist die Tabellensteuerung mit einer Datenquelle verknüpft und alle in der Steuerung angezeigten<br />
Daten stammen aus dieser Datenquelle. In diesem Modus werden die Daten, die mit der Steuerung<br />
geändert werden, direkt in der zugrunde liegenden Datenquelle geändert. Im ungebundenen Modus<br />
verwaltet die Tabellensteuerung ihre eigene Datenquelle.<br />
Sowohl im gebundenen als auch im ungebundenen Modus sind die Row and Column-Zähler der<br />
einfachste Weg, die Daten mit <strong>C1FlexGrid</strong> anzusprechen. Mit den Zählern können Sie eine Zelle in einer<br />
Zeile oder einer Spalte auswählen und die Daten in dieser abrufen oder verändern. Zum Beispiel der<br />
folgende Quellcode wählt die zweite Zelle in einer Zeile aus:<br />
• Visual Basic<br />
• C#<br />
Row(2).Selected = True<br />
Row[2].Selected = true;<br />
• Delphi<br />
Row[2].Selected := true;<br />
Mit der Item-Eigenschaft können Sie ebenfalls die Daten in <strong>C1FlexGrid</strong> auswählen. Die Item-Eigenschaft<br />
ist ein weiterer Zähler der Zeilen und Spalten indiziert und Zellwerte ausliest oder festlegt. Sie können<br />
auch die Spaltennamen als Indizes verwenden. Zum Beispiel der folgende Quellcode speichert die<br />
Zeilennummern in der ersten Tabellenspalte:<br />
• Visual Basic<br />
• C#<br />
Dim r As Integer<br />
For r = fg.Rows.Fixed To fg.Rows.Count – 1<br />
fg(r, 0) = r<br />
Next<br />
int r;<br />
for ( r = fg.Rows.Fixed ; r
<strong>28</strong> · Die <strong>C1FlexGrid</strong>-Steuerung verwenden<br />
Wenn Sie Daten mit den Zählern abrufen, dann wird die Tabellensteuerung den eigentlichen Wert der<br />
Zelle wiedergeben. Um die formatierte Version der Daten, also das, was die Tabellensteuerung dem<br />
Anwender anzeigt, zu erhalten, müssen Sie die GetDataDisplay-Methode verwenden.<br />
Mit der Clip-Eigenschaft können Sie auch den Inhalt einer gesamten Auswahl abrufen. Diese Eigenschaft<br />
ist besonders nützlich, wenn Sie die Zwischenablage oder Drag-und-drop-Operationen steuern wollen.<br />
Standardmäßig gibt die Clip-Eigenschaft eine Zeichenkette, mit Tabulatorenzeichen (Chr(9)) zwischen<br />
Zellen und Zeilenumbruchszeichen (Chr(13)) zwischen Zeilen, zurück. Um andere Trennzeichen zu<br />
verwenden, müssen Sie die ClipSeparators-Eigenschaft anpassen.<br />
Letztendlich können Sie die Inhalte eines willkürlichen Zellbereiches auch mit CellRange-Objekten<br />
speichern und abrufen.<br />
Zellbereich<br />
Mit CellRange-Objekten können Sie an willkürlich ausgewählten Zellgruppen wie an einer einzelnen<br />
Einheit arbeiten. Zum Beispiel der nachfolgende Quellcode erstellt ein CellRange-Objekt, löscht die<br />
Daten in der Auswahl und legt ein benutzerdefiniertes Format fest:<br />
• Visual Basic<br />
• C#<br />
Dim rg As CellRange = fg.GetCellRange(3, 3, 10, 10)<br />
rg.Data = Nothing<br />
rg.Style = fg.Styles("MyRangeStyle")<br />
CellRange rg = fg.GetCellRange(3, 3, 10, 10);<br />
rg.Data = null;<br />
rg.Style = fg.Styles["MyRangeStyle"];<br />
• Delphi<br />
var<br />
rg: CellRange;<br />
begin<br />
rg := fg.GetCellRange(3, 3, 10, 10);<br />
rg.Data := nil;<br />
rg.Style := fg.Styles['MyRangeStyle'];<br />
end;<br />
Die CellRange-Objekte haben eine StyleNew-Eigenschaft, die das Auswahlformat, wenn es existiert,<br />
abfragt oder ein neues erstellt und dieses der Auswahl zuordnet und dann zurückgibt. Diese Eigenschaft<br />
ist in Situationen hilfreich, in denen Sie keine richtige Kontrolle über die Formatierung benötigen. Zum<br />
Beispiel dann, wenn Sie einem Zellbereich einen roten Hintergrund verpassen wollen:<br />
• Visual Basic<br />
• C#<br />
Dim rg As CellRange = fg.GetCellRange(3, 3, 10, 10)<br />
rg.StyleNew.BackColor = Color.Red<br />
CellRange rg = fg.GetCellRange(3, 3, 10, 10);<br />
rg.StyleNew.BackColor = Color.Red;<br />
• Delphi<br />
var<br />
rg: CellRange;<br />
begin<br />
rg := fg.GetCellRange(3, 3, 10, 10);<br />
rg.StyleNew.BackColor := Color.Red;
Zellbilder<br />
end;<br />
Zellbilder · 29<br />
Jede Tabellenzelle kann neben ihren Daten auch ein Bild anzeigen. Dies kann auf zwei Wegen getan<br />
werden:<br />
1. Sie können einer Zelle ein Image-Objekt mit der SetCellImage-Methode zuordnen. Mit dieser<br />
Methode können Sie willkürliche Bilder einer jeden Zelle anhängen, und sie ist nützlich, wenn<br />
das Bild nicht mit den Daten in der Zelle in Verbindung steht. Zum Beispiel könnten Sie ein Bild<br />
als Zellhintergrund verwenden, um zu signalisieren, dass die Daten in dieser Zelle ungültig sind.<br />
2. Sie können ein ImageMap einer Spalte zuordnen und die Tabellensteuerung wird automatisch<br />
die Zelldaten zu dem dazugehörigen Bild verknüpfen. Diese Methode ist in Situationen nützlich,<br />
in denen das Bild die Zelldaten widerspiegelt. Zum Beispiel könnten die Bilder Symbole sein, die<br />
Produkttypen darstellen.<br />
Zellen formatieren<br />
Eine der Stärken der <strong>C1FlexGrid</strong>-Steuerung ist die Möglichkeit, das Format der Tabelle und der<br />
einzelnen Zellen bis ins kleinste Detail anzupassen.<br />
Zellinhalt<br />
Um das Format der Zellinhalte zu steuern, setzen Sie die Cols(index).Format-Eigenschaft auf eine<br />
ähnliche Formatzeichenkette, wie Sie diese bei der String.Format-Method im .NET Framework<br />
verwendet haben. Zum Beispiel der nachfolgende Quellcode zeigt ein kurzes Datum in der Spalte eins<br />
und Währungen in der Spalte zwei:<br />
• Visual Basic<br />
• C#<br />
fg.Cols(1).Format = "d" '
30 · Die <strong>C1FlexGrid</strong>-Steuerung verwenden<br />
Zellformat<br />
• C#<br />
fg.Cols[1].Format = "d"; //
Zellen formatieren · 31<br />
Sie können auch ihre eigenen Formatvorlagen erstellen und auf Zellen, Zeilen und Spalten anwenden.<br />
Zum Beispiel der nachfolgende Quellcode erstellt eine benutzerdefinierte Zellformatvorlage und wendet<br />
diese auf jede fünfte Zeile an:<br />
• Visual Basic<br />
• C#<br />
Dim cs As CellStyle = fg.Styles.Add("Fifth")<br />
cs.BackColor = Color.Gray<br />
Dim idex%<br />
For idex = fg.Rows.Fixed To fg.Rows.Count - 1 Schritt 5<br />
fg.Rows(idex).Style = cs<br />
Next<br />
CellStyle cs = fg.Styles.Add("Fifth");<br />
cs.BackColor = Color.Gray;<br />
for (int index = fg.Rows.Fixed ; index
32 · Die <strong>C1FlexGrid</strong>-Steuerung verwenden<br />
// assign new style to a row<br />
_flex.Rows[3].Style = _flex.Styles["MyStyle"];<br />
// assign new style to a cell range<br />
CellRange rg = _flex.GetCellRange(4,4,6,6);<br />
rg.Style = _flex.Styles["MyStyle"];<br />
• Delphi<br />
var<br />
rg: CellRange;<br />
s: CellStyle;<br />
begin<br />
s := _flex.Styles.Add('MyStyle');<br />
s.BackColor := Color.Red;<br />
s.ForeColor := Color.White;<br />
_flex.Cols[3].Style := _flex.Styles['MyStyle'];<br />
_flex.Rows[3].Style := _flex.Styles['MyStyle'];<br />
rg := _flex.GetCellRange(4, 4, 6, 6);<br />
rg.Style := _flex.Styles['MyStyle'];<br />
end;<br />
Sie können ihre Formatvorlagen auch während der Erstellungsphase erstellen, anstatt den Quellcode<br />
hierfür zu schreiben. Wählen Sie einfach die Tabelle aus, gehen Sie in das Eigenschaftsfenster und klicken<br />
Sie auf die Schaltfläche neben der Styles-Eigenschaft.<br />
Die Tabellensteuerung wird das folgende style editor-Fenster anzeigen:<br />
Mit dem Style-Editor können Sie bestehende Formatvorlagen verändern und eigene neue<br />
Formatvorlagen, die später auf Zellen, Zeilen und Spalten angewendet werden können, erstellen.
Zellen formatieren · 33<br />
Verwenden Sie die Add-Schaltfläche um eine benutzerdefinierte Formatvorlage hinzuzufügen.<br />
Nachfolgend wird gezeigt, wie Ihre neue Vorlage im Vorschaufenster über den Formatierungsoptionen<br />
erscheint.<br />
Die Remove-Schaltfläche entfernt die ausgewählte Formatvorlage. Sie können die Vorlagen umbenennen,<br />
indem Sie diese in der Liste auswählen und den neuen Namen eingeben. Die Clear-Schaltfläche entfernt<br />
alle benutzerdefinierten Formatvorlagen und stellt die Einstellungen der vordefinierten Vorlagen wieder<br />
her.<br />
Die AutoFormat-Schaltfläche öffnet ein zweites Fenster, mit dem Sie einen neuen Satz vordefinierter<br />
Formatvorlagen auswählen können. So sieht das AutoFormat-Fenster aus:
34 · Die <strong>C1FlexGrid</strong>-Steuerung verwenden<br />
Bedingte Formatierung<br />
Um Zellen nach ihrem Inhalt zu formatieren, können Sie das CellChanged-Ereignis verwenden. Zum<br />
Beispiel der nachfolgende Quellcode erstellt eine neue Formatierung für große Währungswerte und<br />
wendet diese auf Zellen mit bestimmten Inhalten an:<br />
• Visual Basic<br />
• C#<br />
' create a custom style for large values<br />
cs = fg.Styles.Add("LargeValue")<br />
cs.Font = New Font(Font, FontStyle.Italic)<br />
cs.BackColor = Color.Gold<br />
' format cells based on their content<br />
Private Sub fg_CellChanged(ByVal sender As Object,<br />
ByVal e As RowColEventArgs) Handles fg.CellChanged<br />
' mark currency values > 50,000 as LargeValues<br />
' (reset others by setting their Style to Nothing)<br />
Dim cs As CellStyle<br />
If Val(fg(e.Row, e.Col)) >= 50000 Then<br />
cs = fg.Styles("LargeValue")<br />
End If<br />
fg.SetCellStyle(e.Row, e.Col, cs)<br />
End Sub<br />
// create a custom style for large values<br />
cs = fg.Styles.Add("LargeValue");<br />
cs.Font = new Font(Font, FontStyle.Italic);<br />
cs.BackColor = Color.Gold;<br />
// format cells based on their content<br />
private void fg_CellChanged( object sender, RowColEventArgs e) {<br />
// mark currency values > 50,000 as LargeValues<br />
// (reset others by setting their Style to null)<br />
CellStyle cs;<br />
if ( Val(fg(e.Row, e.Col)) >= 50000) {<br />
cs = fg.Styles["LargeValue"];<br />
}<br />
fg.SetCellStyle(e.Row, e.Col, cs);<br />
}<br />
• Delphi<br />
cs := fg.Styles.Add('LargeValue');<br />
cs.Font := Font.Create(Font, FontStyle.Italic);<br />
cs.BackColor := Color.Gold;<br />
procedure fg_CellChanged(sender: System.Object; e: RowColEventArgs)<br />
begin<br />
// mark currency values > 50,000 as LargeValues<br />
// (reset others by setting their Style to null)<br />
if val(fg[e.Row, e.Col] >= 50000 then<br />
cs := fg.Styles['LargeValue'];<br />
fg.SetCellStyle(e.Row, e.Col, cs);<br />
end;<br />
Handgezeichnete Zellen<br />
Obwohl die CellStyle-Objekte viele Formatierungsoptionen für Zellen abdecken, wie Hinter- und<br />
Fordergrundfarben, Ausrichtung, Schriftart, Ränder, Rahmen usw., ist dies nicht genug. Vielleicht wollen<br />
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<br />
vollständige Kontrolle über den Aufbau der Zellen zu haben.<br />
Zellen formatieren · 35<br />
Die DrawMode-Eigenschaft legt fest, ob das OwnerDrawCell-Ereignis ausgeführt wird, oder nicht. Mit<br />
diesem Ereignis können Sie jede Option der Zellformatierung überschreiben. Mit den Parametern des<br />
OwnerDrawCell-Ereignisses können Sie nicht nur die angezeigten Daten und deren Formatierung<br />
ändern, sondern Sie können auch die Zellen komplett neu zeichnen.<br />
Die Parameter e.Text und e.Image im Ereignisablauf ändern den Text oder die Grafik, der/die in der<br />
Zelle angezeigt wird. Mit der e.Style-Eigenschaft können Sie auch die verwendete Formatvorlage der<br />
Zelle überschreiben.<br />
Sie sollten allerdings nicht die Eigenschaften des Style-Parameters verändern, weil dies eventuell auch<br />
andere Zellen betrifft. Ordnen Sie stattdessen ein neues CellStyle-Objekt dem Style-Parameter zu. Zum<br />
Beispiel anstatt e.Style.ForeColor = Color.Red festzulegen, ordnen Sie dem Parameter ein neues Format<br />
zu: e.Style = _flex.Styles["RedStyle"].<br />
Sie können nicht nur Ihren eigenen Zeichencode verwenden, um die Zellen einzufärben, sondern auch<br />
Ihren eigenen Code mit der e.DrawCell-Methode verbinden. Zum Beispiel können Sie Ihren<br />
Zellhintergrund mit einem GDI-Aufruf erstellen und dann e.DrawCell aufrufen, um den Zellinhalt und<br />
die Zellrahmen anzuzeigen.<br />
Für ein Beispiel über fortgeschrittenen OwnerDraw-Quellcode, schauen Sie bitte im „RtfGrid“-Beispiel in<br />
unserer online Beispielbibliothek nach.<br />
Der nachfolgende Quellcode zeigt ein solches Beispiel. Es wird ein Farbverlauf für den Hintergrund der<br />
ausgewählten Zelle angewendet. Zunächst wird die DrawMode-Eigenschaft gesetzt, das<br />
LinearGradientBrush-Objekt deklariert und der Hintergrund immer dann angepasst, wenn die Größe<br />
der Zelle verändert wird:<br />
• Visual Basic<br />
• C#<br />
' use owner-draw to add gradients<br />
fg.DrawMode = DrawModeEnum.OwnerDraw<br />
' brush to use with owner-draw cells<br />
Dim m_GradientBrush As LinearGradientBrush<br />
Private Sub fg_Resize(ByVal sender As Object, ByVal e As<br />
System.EventArgs) _<br />
Handles fg.Resize<br />
' update gradient brush when the control is resized<br />
m_GradientBrush = New LinearGradientBrush(ClientRectangle, _<br />
Color.SteelBlue, Color.White, 45)<br />
End Sub<br />
// use owner-draw to add gradients<br />
fg.DrawMode = DrawModeEnum.OwnerDraw;<br />
// brush to use with owner-draw cells<br />
LinearGradientBrush m_GradientBrush;<br />
private void fg_Resize( object sender, System.EventArgs e) fg.Resize<br />
{<br />
// update gradient brush when the control is resized<br />
m_GradientBrush = new LinearGradientBrush(ClientRectangle,,<br />
Color.SteelBlue, Color.White, 45);
36 · Die <strong>C1FlexGrid</strong>-Steuerung verwenden<br />
}<br />
• Delphi<br />
// brush to use with owner-draw cells<br />
m_GradientBrush: LinearGradientBrush;<br />
// use owner-draw to add gradients<br />
fg.DrawMode := DrawModeEnum.OwnerDraw;<br />
procedure fg_Resize(sender: System.Object; e: System.EventArgs);<br />
begin<br />
m_GradientBrush := new LinearGradientBrush(ClientRectangle,<br />
Color.SteelBlue, Color.White, 45);<br />
end;<br />
Im zweiten Schritt wird das OwnerDrawCell-Ereignis behandelt und der benutzerdefinierte Pinsel<br />
verwendet, um den Zellhintergrund zu gestallten. In diesem Beispiel wird der Vordergrund von der<br />
Tabellensteuerung mit der DrawCell-Methode im event-Argument festgelegt:<br />
• Visual Basic<br />
• C#<br />
Private Sub fg_OwnerDrawCell(ByVal sender As Object, _<br />
ByVal e As OwnerDrawCellEventArgs) Handles fg.OwnerDrawCell<br />
' draw selected cell background using gradient brush<br />
If fg.Selection.Contains(e.Row, e.Col) Then<br />
e.Graphics.FillRectangle(m_GradientBrush, e.Bounds) ' draw<br />
background<br />
e.DrawCell(DrawCellFlags.Content) ' let the grid draw the<br />
content<br />
e.Handled = True ' we're done drawing this cell<br />
End If<br />
End Sub<br />
private void fg_OwnerDrawCell( object sender, OwnerDrawCellEventArgs<br />
e) fg.OwnerDrawCell {<br />
// draw selected cell background using gradient brush<br />
if (fg.Selection.Contains(e.Row, e.Col))<br />
{<br />
e.Graphics.FillRectangle(m_GradientBrush, e.Bounds); // draw<br />
background<br />
e.DrawCell(DrawCellFlags.Content); // let the grid draw the<br />
content<br />
e.Handled = true; // we're done drawing this cell<br />
}<br />
}<br />
• Delphi<br />
procedure fg_OwnerDrawCell(sender: System.Object; _<br />
e: OwnerDrawCellEventArgs);<br />
begin<br />
// draw selected cell background using gradient brush<br />
If fg.Selection.Contains(e.Row, e.Col) Then<br />
begin<br />
e.Graphics.FillRectangle(m_GradientBrush, e.Bounds); // draw<br />
background<br />
e.DrawCell(DrawCellFlags.Content); // let the grid draw the content<br />
e.Handled := True // we're done drawing this cell<br />
end;<br />
end;
Zellen bearbeiten<br />
Zellen bearbeiten · 37<br />
Standardmäßig erlaubt die <strong>C1FlexGrid</strong>-Steuerung immer, dass Sie als Nutzer die Zellen verändern<br />
können, indem Sie in diese hineinschreiben. Dies kann verhindert werden, indem Sie die AllowEditing-<br />
Eigenschaft auf FALSE stellen. Es können auch nur bestimmte Spalten, die der Nutzer nicht verändern<br />
soll, gesperrt werden, indem Sie die Cols(index).AllowEditing-Eigenschaft auf FALSE stellen. Wenn die<br />
Tabellensteuerung an eine Datenquelle gebunden ist, dann wird automatisch bestimmt, welche Spalten<br />
veränderbar sind und danach die AllowEditing-Eigenschaft eingestellt.<br />
Um anzufangen, eine Zelle zu bearbeiten, kann der Nutzer:<br />
1. Anfangen in die Zelle zu schreiben. Dies ersetzt den bisherigen Zellinhalt.<br />
2. F2 oder Enter drücken. Dies versetzt die Tabellensteuerung in den Bearbeitungsmodus und<br />
übergibt den bisherigen Zellinhalt dem Editor.<br />
3. Doppelklick auf die Zelle. Dies hat dieselbe Wirkung wie F2 zu drücken, stellt aber den Cursor<br />
neben das Zeichen, auf das geklickt wurde.<br />
Im einfachen Bearbeitungsmodus kann der Nutzer Inhalte in die Zellen schreiben. Wenn die bearbeitete<br />
Spalte einen bestimmten Datentyp besitzt, dann wir der vom Nutzer eingegebene Wert automatisch in<br />
den entsprechenden Datentyp konvertiert. Wenn der vom Nutzer eingegebene Wert nicht konvertiert<br />
werden kann, dann gibt die Tabellensteuerung den „GridError“ aus und übergeht den neuen Eintrag.<br />
Der einfache Bearbeitungsmodus ist für die meisten Anwendungen ausreichend. Dennoch besitzt das<br />
<strong>C1FlexGrid</strong> noch weitere Eigenschaften und Ereignisse, mit denen Sie den Bearbeitungsprozess steuern<br />
können, und es stellt außerdem Auswahllisten, Befehlsschaltflächen und eine erweiterte<br />
Gültigkeitskontrolle zur Verfügung.<br />
Ab der Version 2.5 unterstützt <strong>C1FlexGrid</strong> auch externe Bearbeitungsprogramme. Somit können Sie jede<br />
beliebige Tabellensteuerung für die Tabellenbearbeitung verwenden. Zum Beispiel können Sie nun die<br />
C1Input-Steuerung als Tabelleneditor verwenden.<br />
Diese Funktionen werden nachfolgend beschrieben.<br />
Mit Listen- und Kombinationsfeldern arbeiten<br />
Oft haben manche Zellen eine festgelegte Auswahl möglicher Werten. In diesen Fällen können Sie den<br />
Nutzer einen Wert aus einem Auswahllistenfeld (drop-down list) wählen lassen. Dafür muss eine<br />
Zeichenkette mit allen möglichen Werten, getrennt durch das Senkrechtstrichzeichen, z.B.<br />
"Wahr|Falsch|Weis nicht", erstellen und diese der Cols(index).ComboList-Eigenschaft zugeordnet<br />
werden. Jeder Spalte kann eine andere Liste zugeordnet werden. Wenn Sie die ComboList-Eigenschaft<br />
festlegen, erstellt die Tabellensteuerung automatisch ein Auswahlfeld neben der Zelle. Der Nutzer kann<br />
dieses Feld anklicken oder F2 drücken, um die Liste der möglichen Werte für die entsprechende Zelle<br />
einzusehen.<br />
In einer anderen, häufigen auftretenden Situation soll eine Zelle zwar eine Auswahl an verschiedenen<br />
Werten besitzen, dennoch soll aber die Möglichkeit bestehen, einen nicht aufgeführten Wert<br />
hinzuzufügen. Dies kann mit Auswahlkombinationsfeldern (drop-down combos), einer Kombination<br />
aus Textfeld und Auswahlliste, erreicht werden. Um ein solches Kombinationsfeld zu erstellen, beginnen<br />
Sie die Zeichenkette der Auswahlmöglichkeiten mit dem Senkrechtstrichzeichen, z.B.<br />
"|Wahr|Falsch|Weis nicht", und ordnen Sie diese, wie zuvor der Cols(index).ComboList-Eigenschaft zu.<br />
Zum Beispiel der nachfolgende Quellcode würde die Tabellensteuerung veranlassen, ein<br />
Auswahllistenfeld mit verschiedenen Farben in Spalte eins und ein Auswahlkombinationsfeld in Spalte<br />
zwei zu erstellen. Wenn eine Zelle aus Spalte eins bearbeitet werden soll, so muss der Nutzer einen Wert
38 · Die <strong>C1FlexGrid</strong>-Steuerung verwenden<br />
aus der Liste wählen. Bearbeitet er hingegen Spalte zwei, so kann er neben der Auswahl auch einen<br />
eigenen Wert in die Zelle schreiben:<br />
• Visual Basic<br />
• C#<br />
fg.Cols(1).ComboList = "Red|Green|Blue|Red|White" ' drop-down list<br />
fg.Cols(2).ComboList = "|Red|Green|Blue|Red|White" ' drop-down combo<br />
fg.Cols[1].ComboList = "Red|Green|Blue|Red|White"; // drop-down list<br />
fg.Cols[2].ComboList = "|Red|Green|Blue|Red|White"; // drop-down combo<br />
• Delphi<br />
fg.Cols[1].ComboList := 'Red|Green|Blue|Red|White';<br />
fg.Cols[2].ComboList := '|Red|Green|Blue|Red|White';<br />
Es ist auch möglich, dass verschiedene Zellen in einer Spalte verschiedene Listen benötigen. Zum Beispiel<br />
stehe in einer Eigenschaftsliste in der ersten Spalte die Eigenschaft und in der zweiten Spalte die<br />
dazugehörigen Werte. Wenn die Werte eigenschaftsspezifisch sind, so muss sich die Auswahlliste der<br />
Werte an die entsprechende Eigenschaft in jeder Zeile anpassen. In diesem Fall sollten Sie das<br />
BeforeEdit-Ereignis verwenden und die ComboList-Eigenschaft auf die entsprechende Liste für die<br />
aktuelle Zelle setzen. Die ComboList-Eigenschaft wird auf die gesamte Tabelle angewendet.<br />
Das integrierte Kombinationsfeld enthält standardmäßig eine automatische Suchfunktion. Wenn der<br />
Nutzer anfängt, einen Wert zu schreiben, dann wird die Auswahl zu dem nächstpassenden Wert<br />
springen. Diese Funktion können Sie mit der EditOptions-Eigenschaft deaktivieren und die Zeit, bis die<br />
Tabelle den automatischen Suchpuffer löscht, mit der AutoSearchDelay-Eigenschaft steuern.<br />
Das Kombinationsfeld enthält außerdem eine automatische Fortlauffunktion, wie die Editoren im Visual<br />
Studio-Eigenschaftsfenster. Wenn man auf eine Zelle mit einer dazugehörigen Liste doppelt klickt, dann<br />
wird die Tabellensteuerung automatisch den nächsten Wert auswählen. Diese Funktion können Sie<br />
ebenfalls mit der EditOptions-Eigenschaft deaktivieren.<br />
Kontrollkästchen<br />
Standardmäßig zeigt die Tabellensteuerung Werte in Boolean-Spalten als Kontrollkästchen an. Der<br />
Spaltentyp wird von der DataType-Eigenschaft des Column-Objekts festgelegt. Wenn Sie Boolean-Werte<br />
nicht als Kontrollkästchen anzeigen lassen wollen, dann müssen Sie in die Format-Eigenschaft der Spalte<br />
eine Zeichenkette mit den entsprechenden Wahr- und Falsch-Werten eintragen. Zum Beispiel:<br />
• Visual Basic<br />
• C#<br />
fg.Cols("bools").Format = "Yes;No"<br />
fg.Cols["bools"].Format = "Yes;No";<br />
• Delphi<br />
fg.Cols['bools'].Format := 'Yes;No';<br />
Im ungebundenen Zustand können Sie die GetCellCheck- und SetCellCheck-Eigenschaften verwenden,<br />
um Kontrollkästchen in Zellen einzufügen. Das Kontrollkästchen wird zusammen mit jedem beliebigen<br />
Text in der Zelle angezeigt und Sie können deren Position mit der ImageAlign-Spalteneigenschaft<br />
festlegen.<br />
Es gibt zwei Kontrollkästchentypen: Boolean und Tri-State. Boolean-Kontrollkästchen schalten zwischen<br />
den beiden Zuständen CheckEnum.Checked und CheckEnum.Unchecked um. Drei-Zustands-
Zellen bearbeiten · 39<br />
Kontrollkästchen laufen durch die drei Zustände CheckEnum.TSChecked, CheckEnum.TSUnchecked<br />
und CheckEnum.TSGrayed.<br />
Wenn eine Zelle ein Kontrollkästchen besitzt und die AllowEditing-Eigenschaft auf TRUE steht, dann<br />
kann der Nutzer dessen Zustand mit einem Mausklick oder mit der Leer- oder Entertaste ändern.<br />
Standardmäßig werden alle in einer Auswahl befindlichen Kontrollkästchen umgeschaltet, wenn eins<br />
dieser per Maus oder Tastatur umgeschaltet wird. Diese Funktion kann mit der EditOptions-Eigenschaft<br />
deaktiviert werden.<br />
Werteverknüpfte Listen<br />
Die oben beschriebene ComboList-Eigenschaft stellt sicher, dass Zellwerte aus einer Liste ausgewählt<br />
werden. Der vom Nutzer ausgewählte Wert wird in den entsprechenden Typ der Spalte konvertiert und<br />
in der Tabelle so abgespeichert, wie als wenn der Nutzer diesen Wert eigenhändig eingegeben hätte.<br />
In vielen Fällen könnten Zellen ihre Werte aus einer gut definierten Liste auswählen, Sie möchten<br />
dennoch aber ein benutzerfreundliches Format der eigentlichen Werte anzeigen. Zum Beispiel, wenn eine<br />
Spalte Produktnummern enthält, so sollen diese auch gespeichert, stattdessen aber der dazugehörige<br />
Produktname angezeigt werden.<br />
Dies wird mit der Cols(index).DataMap-Eigenschaft erreicht. Diese Eigenschaft enthält einen Verweis zu<br />
einem IDictionary-Objekt, welches die Zuordnung zwischen dem, was gespeichert wird, und dem, was<br />
dem Nutzer angezeigt wird, erstellt. Die IDictionary-Schnittstelle wird im System.Collections-<br />
Namensbereich festgelegt und wird unter anderem durch Hashtable-Klassen implementiert.<br />
Zum Beispiel der nachfolgende Quellcode erstellt eine Datenzuordnung zwischen Farbwerten und deren<br />
Namen. Die Farben werden in der Tabelle gespeichert und deren Namen dem Nutzer angezeigt:<br />
• Visual Basic<br />
• C#<br />
Dim dtMap As Hashtable = New Hashtable()<br />
dtMap.Add(Color.Red, "Apple")<br />
dtMap.Add(Color.Green, "Forest")<br />
dtMap.Add(Color.Blue, "Sky")<br />
dtMap.Add(Color.Black, "Coal")<br />
dtMap.Add(Color.White, "Snow")<br />
fg.Cols(1).DataType = GetType(Color)<br />
fg.Cols(1).DataMap = dtMap<br />
Hashtable Hashtable dtMap = new Hashtable();<br />
dtMap.Add(Color.Red, "Apple");<br />
dtMap.Add(Color.Green, "Forest");<br />
dtMap.Add(Color.Blue, "Sky");<br />
dtMap.Add(Color.Black, "Coal");<br />
dtMap.Add(Color.White, "Snow");<br />
fg.Cols[1].DataType = typeof(Color);<br />
fg.Cols[1].DataMap = dtMap;<br />
• Delphi<br />
var<br />
Hashtable: Hashtable;<br />
begin<br />
dtMap := Hashtable.Create;<br />
dtMap.Add(Color.Red, 'Apple');<br />
dtMap.Add(Color.Green, 'Forest');<br />
dtMap.Add(Color.Blue, 'Sky');<br />
dtMap.Add(Color.Black, 'Coal');
40 · Die <strong>C1FlexGrid</strong>-Steuerung verwenden<br />
dtMap.Add(Color.White, 'Snow');<br />
fg.Cols[1].DataType := TypeOf(Color);<br />
fg.Cols[1].DataMap := dtMap;<br />
end;<br />
Jede Klasse, die das IDictionary implementiert, kann als DataMap verwendet werden. Zum Beispiel,<br />
Hashtable, ListDictionary und SortedList. Alle diese Klassen stellen gültige Datenzuordnungen zur<br />
Verfügung. Der Unterschied liegt allein in der klassenabhängigen Reihenfolge, in der die Werte in der<br />
Auswahlliste angezeigt werden, wenn diese in bearbeitbaren Spalten angewendet werden.<br />
Die SortedList-Klasse sortiert die Werte nach einem Schlüssel, Hashtable verwendet eine willkürliche<br />
Reihenfolge und ListDictionary erhält die Reihenfolge, in der die Werte der Liste hinzugefügt wurden.<br />
Daher ist ListDictionary meist die passendste Alternative für DataMaps.<br />
Beachten Sie, dass die Schlüssel einer Datenzuordnung denselben Typ wie die zu bearbeitenden Zellen<br />
besitzen müssen. Zum Beispiel wenn eine Spalte kurze Integer (Int16) enthält, dann müssen alle mit<br />
dieser Spalte verknüpften Zuordnungen ebenfalls kurze Integer-Schlüssel besitzen. Übliche Integer<br />
(Int32) würden als Schlüssel in diesem Fall nicht funktionieren.<br />
Das folgende Beispiel zeigt diesen Unterschied:<br />
• Visual Basic<br />
private void Form1_Load(object sender, System.EventArgs e)<br />
{<br />
SortedList sl = new SortedList(); //
}<br />
• Delphi<br />
ld.Add(2, "Two");<br />
ld.Add(3, "Three");<br />
Hashtable ht = new Hashtable(); //
42 · Die <strong>C1FlexGrid</strong>-Steuerung verwenden<br />
• C#<br />
private enum Countries<br />
{<br />
NewYork;<br />
Chicago;<br />
NewOrleans;<br />
London;<br />
Paris;<br />
};<br />
fg.Cols(1).DataType = typeof(Countries);<br />
• Delphi<br />
Zellschaltflächen<br />
type<br />
Countries = (NewYork, Chicago, NewOrleans, London, Paris);<br />
fg.Cols[1].DataType := TypeOf(Countries);<br />
Manche Zellen benötigen eventuell kompliziertere Editoren im Vergleich zu einem Textfeld oder einer<br />
Auswahlliste. Zum Beispiel wenn eine Spalte Dateinamen oder Farben beinhaltet, dann wird meist ein<br />
Dialogfenster benötigt.<br />
In diesen Fällen muss die ComboList-Eigenschaft auf Ellipsis („…“) gestellt werden. Die Steuerung wird<br />
dann eine Schaltfläche neben der Zelle anzeigen und das CellButtonClick-Ereignis ausführen, wenn der<br />
Nutzer auf diese klickt. Sie können das Ereignis abfangen, ein Dialogfenster anzeigen und den Zellinhalt<br />
mit des Nutzers Auswahl abspeichern.<br />
Wenn Sie das Senkrechtzeichen vor die Ellipsis stellen, dann kann der Nutzer den Zellinhalt durch<br />
einfaches hineinschreiben verändern.<br />
Standardmäßig wird die Zellschaltfläche mit der Ellipsis („…“) beschriftet. Mit der CellButtonImage-<br />
Eigenschaft können Sie der Zellschaltfläche ein Bild zuordnen.<br />
Das folgende Beispiel zeigt, wie Sie einen Kalender aufrufen, um ein Datum in einer Spalte<br />
abzuspeichern. Das Beispiel geht davon aus, dass eine MonthCalendar-Steuerung mit dem Namen „cal“<br />
auf Ihrem Formular vorhanden ist:<br />
• Visual Basic<br />
• C#<br />
' set up date column<br />
Dim c As Col = fg.Cols(1)<br />
c.DataType = GetType(Color)<br />
c.ComboList = "..." '
Zellen bearbeiten · 43<br />
Dieser Quellcode erstellt eine Spalte, in welcher der Nutzer auf eine Schaltfläche klicken oder ein Datum<br />
per Hand einfügen kann. Im nächsten Schritt wird ein Klick auf die besagte Schaltfläche abgewickelt:<br />
• Visual Basic<br />
• C#<br />
Private Sub fg_CellButtonClick(ByVal sender As Object, _<br />
ByVal e As RowColEventArgs) Handles fg.CellButtonClick<br />
' create color picker dialog<br />
Dim clrDlg As New ColorDialog()<br />
' initialize the dialog<br />
If fg(e.Row, e.Col) Is GetType(Color) Then<br />
clrDlg.Color = fg(e.Row, e.Col)<br />
End If<br />
' get new color from dialog and assign it to the cell<br />
If clrDlg.ShowDialog() = DialogResult.OK Then<br />
fg(e.Row, e.Col) = clrDlg.Color<br />
End If<br />
End Sub<br />
private void fg_CellButtonClick( object sender, RowColEventArgs e)<br />
fg.CellButtonClick {<br />
}<br />
• Delphi<br />
// create color picker dialog<br />
ColorDialog clrDlg = new ColorDialog();<br />
// initialize the dialog<br />
if ( fg(e.Row, e.Col) Is typeof(Color))<br />
{<br />
clrDlg.Color = fg(e.Row, e.Col);<br />
}<br />
// get new color from dialog and assign it to the cell<br />
if ( clrDlg.ShowDialog() = DialogResult.OK)<br />
{<br />
fg(e.Row, e.Col) = clrDlg.Color;<br />
}<br />
procedure fg_CellButtonClick(sender: System.Object; _<br />
e: RowColEventArgs);<br />
var<br />
clrDlg: ColorDialog;<br />
begin<br />
// create color picker dialog<br />
clrDlg := ColorDialog.Create;<br />
// initialize the dialog<br />
If fg[e.Row, e.Col] Is Color Then<br />
clrDlg.Color := fg[e.Row, e.Col];<br />
// get new color from dialog and assign it to the cell<br />
If clrDlg.ShowDialog = System.Windows.Forms.DialogResult.OK Then<br />
fg[e.Row, e.Col] := clrDlg.Color<br />
end;
44 · Die <strong>C1FlexGrid</strong>-Steuerung verwenden<br />
Masken<br />
Die <strong>C1FlexGrid</strong>-Steuerung unterstützt auch Maskeneingaben. Diese Form der Bearbeitung verwendet<br />
Eingabemasken um gewisse Vorlagen bereitzustellen und die Eingaben des Nutzers direkt automatisch<br />
auf Gültigkeit zu prüfen. Die Maske wird durch die Col(index).EditMask-Eigenschaft festgelegt und kann<br />
mit normalen Textfeldern und Auswahlkombinationsfeldern verwendet werden.<br />
Die Zeichenketten von Eingabemasken besitzen zwei Zeichentypen: Wortzeichen, die ein Teil der<br />
eigentlichen Eingabe darstellen, und Vorlagenzeichen, welche als Platzhalter für Zeichen, die zu einer<br />
speziellen Kategorie gehören, dienen, z.B. Zahlen oder Buchstaben. Zum Beispiel der nachfolgende<br />
Quellcode ordnet eine „(999) 999-9999“ Eingabemaske der Spalte eins zu, welche Telefonnummern<br />
abspeichert. Die zahl „9“ ist ein Platzhalter, der für jede andere Zahl steht:<br />
• Visual Basic<br />
• C#<br />
' set up phone number edit mask<br />
fg.Cols(1).EditMask = "(999) 999-9999<br />
// set up phone number edit mask<br />
fg.Cols[1].EditMask = "(999) 999-9999;<br />
• Delphi<br />
fg.Cols(1).EditMask := '(999) 999-9999;';<br />
Wenn Sie eine Zeichenkette in der EditMask-Eigenschaft eintragen, so wird automatisch der integrierte<br />
Maskeneditor verwendet, auch wenn die Spalte Datums- oder Zeitwerte enthält. Gewöhnlich wird eine<br />
DateTimePicker-Steuerung für solche Spalten verwendet. Dies ist besonders günstig, wenn es um<br />
DateTime-Spalten geht, die nur Uhrzeiten enthalten, aber kein Datum. In diesen Fällen können Sie die<br />
folgenden Eigenschaften setzen, um einen Maskeneditor anstatt der DateTimePicker-Steuerung zu<br />
verwenden:<br />
• Visual Basic<br />
• C#<br />
fg.Cols(1).DataType = GetType(DateTime) '<br />
fg.Cols(1).Format = "hh:mm tt" '<br />
fg.Cols(1).EditMask = "99:99 LL" '<br />
fg.Cols[1].DataType=typeof(DateTime);<br />
fg.Cols[1].Format="hh:mm tt";<br />
fg.Cols[1].EditMask="99:99 LL";<br />
• Delphi<br />
fg.Cols[1].DataType := TypeOf(DateTime);<br />
fg.Cols[1].Format := 'hh:mm tt';<br />
fg.Cols[1].EditMask := '99:99 LL';<br />
Für weitere Details zum Aufbau der Zeichenketten für Masken, schauen Sie bitte unter der EditMask-<br />
Eigenschaft im Abschnitt „Steuerungsverweise“ nach.<br />
Wenn verschiedene Zellen in derselben Spalte verschiedene Masken benötigen, müssen Sie das<br />
BeforeEdit-Ereignis verwenden um die EditMask-Eigenschaft auf den entsprechenden Wert für die<br />
aktuelle Zelle zu setzen.
Gültigkeit<br />
Zellen bearbeiten · 45<br />
In vielen Fällen sind Eingabemasken allein nicht genug um sicherzustellen, dass die vom Nutzer<br />
eingegebenen Daten gültig sind. Zum Beispiel können Sie mit einer Maske nicht eine Spanne möglicher<br />
Werte angeben oder die Daten der aktuellen Zelle aufgrund von Daten einer anderen Zelle bestätigen.<br />
In diesen Fällen muss das ValidateEdit-Ereignis verwendet werden, um den Wert der Editor.Text-<br />
Eigenschaft auf Gültigkeit für die aktuelle Zelle zu prüfen. An diesem Punkt besitzt die Zelle immer noch<br />
ihren anfänglichen Wert. Wenn die Eingabe ungültig ist, muss der Cancel-Parameter auf TRUE gestellt<br />
werden und die Steuerung verbleibt im Eingabemodus bis der Nutzer eine gültige Eingabe vornimmt.<br />
Zum Beispiel der nachfolgende Quellcode prüft die Eingabe in einer Währungsspalte um sicherzustellen,<br />
dass die eingegebenen Werte zwischen 1.000 und 10.000 liegen:<br />
• Visual Basic<br />
• C#<br />
Private Sub fg_ValidateEdit(ByVal sender As Object, _<br />
ByVal e As ValidateEditEventArgs) Handles fg.ValidateEdit<br />
' validate amounts<br />
If fg.Cols(e.Col).DataType Is GetType(Decimal) Then<br />
10,000")<br />
Try<br />
End If<br />
End Sub<br />
Dim dec As Decimal = Decimal.Parse(fg.Editor.Text())<br />
If dec < 1000 Or dec > 10000 Then<br />
MessageBox.Show("Value must be between 1,000 and<br />
e.Cancel = True<br />
End If<br />
Catch<br />
MessageBox.Show("Value not recognized as a Currency")<br />
e.Cancel = True<br />
End Try<br />
private void fg_ValidateEdit( object sender, ValidateEditEventArgs e)<br />
{<br />
{<br />
// validate amounts<br />
if (fg.Cols[e.Col].DataType is (Decimal))<br />
try {<br />
Decimal dec = Decimal.Parse(fg.Editor.Text);<br />
if ( dec < 1000 || dec > 10000) {<br />
MessageBox.Show("value must be between 1,000 and<br />
10,000");<br />
e.Cancel = true;<br />
}<br />
} catch{<br />
MessageBox.Show("value not recognized as a Currency");<br />
e.Cancel = true;<br />
}<br />
}<br />
}
46 · Die <strong>C1FlexGrid</strong>-Steuerung verwenden<br />
• Delphi<br />
Private Sub fg_ValidateEdit(sender: System.Object; _<br />
e: ValidateEditEventArgs);<br />
var<br />
dec: Decimal;<br />
begin<br />
// validate amounts<br />
If fg.Cols(e.Col).DataType Is Decimal Then<br />
Try<br />
dec := Decimal.Parse(fg.Editor.Text())<br />
If (dec < 1000) Or (dec > 10000) Then<br />
begin<br />
MessageBox.Show('Value must be between 1,000 and 10,000');<br />
e.Cancel := True;<br />
end;<br />
except<br />
MessageBox.Show('Value not recognized as a Currency');<br />
e.Cancel := True<br />
end;<br />
end;<br />
Benutzerdefinierte Editoren verwenden<br />
Obwohl die integrierten Editoren sehr flexible und stark sind, möchten Sie vielleicht dennoch in einigen<br />
Fällen externe Steuerungen als spezialisierte Editoren verwenden. Zum Beispiel können Sie die<br />
C1NumericInput-Steuerung, die einen Drop-Down-Rechner für die Nummerneingabe bereit hält, einen<br />
Editor für das Auswählen von Listen über mehrere Spalten hinweg, oder eine spezialisierte Steuerung,<br />
die Sie für Ihre Bedürfnisse erstellt haben, verwenden.<br />
Jede Steuerung, die von der Control-Basisklasse abgeleitet wird, kann als grundlegender Tabelleneditor<br />
verwendet werden. Steuerungen, die die IC1EmbeddedEditor-Schnittstelle implementieren (in<br />
C1Common.dll definiert), können zudem eine bessere Integration mit der Tabellensteuerung und<br />
zusätzliche erweiterte Funktionen bieten. Für weitere Details über IC1EmbeddedEditor-Schnittstellen,<br />
schauen Sie unter der Editor-Eigenschaft nach.<br />
Um eine Steuerung als benutzerdefinierten Editor zu verwenden, müssen Sie eine Instanz der Steuerung<br />
mit der Tabellenspalte oder einer Formatvorlage über deren Editor-Eigenschaft verknüpfen. Sie können<br />
dies in der Erstellungsphase mit dem Spalteneditor oder während der Runtime tun. Danach wird die<br />
entsprechende Steuerung automatisch von der Tabelle genutzt.<br />
Um benutzerdefinierte Editoren während der Erstellungsphase festzulegen, müssen Sie eine Instanz der<br />
Editorsteuerung dem Formular hinzufügen, dann die Tabelle rechtsklicken und „Edit Columns…“<br />
auswählen. Wählen Sie die Spalten aus, die den benutzerdefinierten Editor verwenden sollen, und tragen<br />
Sie den Namen der neuen Editorsteuerung in die Editor-Eigenschaften ein.<br />
Folgen Sie den nachstehenden Schritten, um zum Beispiel die NumericUpDown-Steuerung als<br />
Tabelleneditor zu verwenden:<br />
1. Fügen Sie die <strong>C1FlexGrid</strong>-Steuerung dem Formular hinzu.<br />
2. Fügen Sie eine NumericUpDown-Steuerung dem Formular hinzu und stellen Sie deren<br />
BorderStyle-Eigenschaft auf „None“.<br />
3. Rechtsklicken Sie die Tabellensteuerung und wählen Sie die Option „Edit Columns…“ aus.<br />
4. Wählen Sie die erste, scrollbare Tabellenspalte im Spalteneditor aus, und stellen Sie die Editor-<br />
Eigenschaft auf „numericUpDown1“.
Zellen bearbeiten · 47<br />
Starten Sie das Projekt und schreiben Sie einige Werte in die erste Spalte. Beachten Sie, wie sich die<br />
Tabelle positioniert und die NumericUpDown-Steuerung für die Zellbearbeitung initialisiert wird. Wenn<br />
Sie mit der Bearbeitung einer Zelle fertig sind, dann klicken Sie auf eine andere Zelle oder drücken Sie die<br />
Tabulatortaste um zur nächsten Zelle zu gelangen. Der neue Wert wird in der Zelle abgespeichert.<br />
Sie können benutzerdefinierte Editoren auch während der Runtime mit Quellcode hinzufügen:<br />
• Visual Basic<br />
• C#<br />
Private Sub Form_Load(EventArgs e)<br />
End Sub<br />
' create custom editor<br />
Dim editor as New NuumericUpDown()<br />
editor.BorderStyle = BorderStyle.None<br />
' assign custom editor to the grid<br />
fg.Cols(1).Editor = editor<br />
private void Form_Load(EventArgs e)<br />
{<br />
// create custom editor<br />
NumericUpDown editor = new NumericUpDown();<br />
editor.BorderStyle = BorderStyle.None;<br />
}<br />
• Delphi<br />
// assign custom editor to the grid<br />
fg.Cols[1].Editor = editor;<br />
procedure TWinForm.Form_Load(object sender; e: System.EventArgs);<br />
var editor: NumericUpDown;<br />
begin<br />
// create custom editor<br />
editor := NumericUpDown.Create;<br />
editor.BorderStyle := BorderStyle.None;<br />
// assign custom editor to the grid<br />
fg.Cols[1].Editor := editor;<br />
end;<br />
Benutzerdefinierte Editoren erstellen<br />
Jede Steuerung, die von der Control-Basisklasse abgeleitet wird, kann als Tabelleneditor verwendet<br />
werden. Dies ist möglich, weil die Tabellensteuerung ausreichend Informationen über die Basisklasse<br />
besitzt und daher auf Eigenschaften wie Text und Bounds und Ereignisse wie Leave und TextChanged<br />
zugreifen kann. In vielen Fällen ist dieses Unterstützungsniveau ausreichend.<br />
Manchmal ist es vielleicht nötig, dass Sie Steuerungen verwenden, die nicht vollständig auf der<br />
Basisklasse beruhen. Zum Beispiel eine DateTimePicker-Steuerung besitzt eine Value-Eigenschaft, die<br />
anstelle von Text für das Zurückholen von geänderten Werten verwendet werden sollte. In solchen<br />
Fällen können Sie eine oder mehrere Methoden in die IC1EmbeddedEditor-Schnittstelle implementieren,<br />
um das Standardverhalten zu überschreiben. Alle Steuerungen der C1Input-Bibliothek unterstützen<br />
allerdings den IC1EmbeddedEditor und integrieren sich daher gut in die <strong>C1FlexGrid</strong> und<br />
C1TrueDBGrid.
48 · Die <strong>C1FlexGrid</strong>-Steuerung verwenden<br />
Die IC1EmbeddedEditor-Schnittstelle ist recht einfach gestrickt und weil die Tabellensteuerung an diese<br />
über „late binding“ gebunden ist, müssen deren Mitglieder nicht einmal implementiert werden.<br />
Implementieren Sie nur diejenigen, die für Ihre Editorsteuerung Sinn ergeben.<br />
Die Schnittstelle ist derart flexibel, dass Sie so gut wie jede Steuerung als Tabelleneditor verwenden<br />
können. Sie können sogar die UITypeEditor-Klassen als Tabelleneditor verwenden. Um dies zu tun,<br />
benötigen Sie eine Wrapper-Klasse die von der Control abgeleitet wird (UITypeEditor tut dies nicht), die<br />
die IC1EmbeddedEditor-Schnittstelle implementiert und den passenden UITypeEditor verkapselt. Wir<br />
stellen den Quellcode für diese Wrapper-Klasse im „CustomEditors“-Beispiel zur Verfügung.<br />
Wenn Sie die UITypeEditor-Wrapper-Klasse verwenden, können Sie jeden beliebigen UITypeEditor mit<br />
<strong>C1FlexGrid</strong> einsetzen. .NET stellt einige UITypeEditoren für u.a. Farbanpassungen, Schriftarten und<br />
Dateinamen zur Verfügung. Sie können auch Ihren eigenen UITypeEditor schreiben. Dies ist manchmal<br />
einfacher als eine Steuerung zu erstellen.<br />
Für Beispiele zur Verwendung von integrierten, benutzerdefinierten und UITypeEditor-Editoren mit<br />
<strong>C1FlexGrid</strong>, schauen Sie bitte im „CustomEditors“-Beispiel in unserer online Beispielbibliothek nach.<br />
Den Bearbeitungsmodus steuern<br />
Um festzustellen, ob sich die Tabelle im Bearbeitungsmodus befindet, müssen Sie die Werte der Editor-<br />
Eigenschaft auslesen. Wenn diese Eigenschaft „null“ zurückgibt, dann befindet sich die Tabelle nicht im<br />
Bearbeitungsmodus. Andernfalls gibt die Eigenschaft einen Verweis auf die entsprechende Steuerung<br />
zurück, die gerade verwendet wird, um die aktuelle Zelle zu bearbeiten. Diese Steuerung kann ein<br />
Textfeld, ein Kombinationsfeld oder ein anderer Steuerungstyp sein.<br />
Sie können die Tabelle programmatisch mit der StartEditing-Methode in den Bearbeitungsmodus<br />
versetzen und diesen mit der FinishEditing-Methode wieder beenden.<br />
Indem Sie die Bearbeitungsereignisse, die von der Tabelle gestartet werden, abfangen und verarbeiten,<br />
können Sie den gesamten Bearbeitungsprozess noch stärker steuern. Während des Bearbeitungsprozesses<br />
einer Zelle startet die Tabelle die folgende Abfolge an Ereignissen:<br />
BeforeEdit-Ereignis (Seite 236)<br />
Dieses Ereignis wird immer dann gestartet, wenn eine bearbeitbare Zelle ausgewählt wird. Sie können an<br />
dieser Stelle die Bearbeitung dieser Zelle verhindern, indem Sie den Ereignisparameter Cancel auf TRUE<br />
stellen. Sie können auch die ComboList-Eigenschaft verändern, so dass die passende<br />
Auswahllistenschaltfläche in dieser Zelle angezeigt wird.<br />
Beachten Sie aber, dass der Nutzer nicht zwingend diese Zelle auch bearbeiten will. Es kann sein, dass er<br />
die Auswahl einfach auf einen andere Zelle oder Steuerung verschiebt.<br />
StartEdit-Ereignis (Seite 274)<br />
Dieses Ereignis ist ähnlich wie BeforeEdit, nur dass der Nutzer in diesem Fall bereits eine Taste gedrückt<br />
oder auf die Auswahlschaltfläche der Zelle geklickt hat und wirklich die Zelle verändern will. Sie können<br />
die Bearbeitung immer noch stoppen.<br />
Die Editor-Eigenschaft ist an dieser Stelle immer noch „null“, weil die Steuerung noch nicht festgelegt<br />
hat, welcher Editortyp verwendet werden sollte. Sie können daher auch noch einen benutzerdefinierten<br />
Editor der Editor-Eigenschaft zuordnen.<br />
SetupEditor-Ereignis (Seite 271)<br />
Dieses Ereignis wird gestartet, wenn die Editorsteuerung erstellt und konfiguriert wurde, um die Zelle zu<br />
bearbeiten, aber noch bevor dies sichtbar ist. An dieser Stelle können Sie die Editoreneinstellungen
Zusammenfassen und Gliedern · 49<br />
verändern. Zum Beispiel die maximale Länge oder die zu verwendenden Passwortzeichen in einem<br />
TextBox-Editor. Sie können auch Ihre eigene Ereignisverarbeitung dem Editor anhängen.<br />
ValidateEdit-Ereignis (Seite 275)<br />
Dieses Ereignis wird gestartet, wenn der Nutzer mit der Bearbeitung fertig ist und bevor der Editorwert<br />
zurück in die Tabellenzelle kopiert wird. Sie können den ursprünglichen Wert prüfen, indem Sie diesen<br />
aus der Tabelle auslesen. Das Ereignis stellt die Koordinaten der Zelle zur Verfügung. Den neuen Wert,<br />
der der Tabelle hinzugefügt werden soll, können Sie mit den Editor-Eigenschaften, z.B. Editor.Text,<br />
prüfen. Wenn der neue Wert für die entsprechende Zelle ungültig ist, dann muss nur der Cancel-<br />
Parameter auf TRUE gestellt werden, und die Tabelle bleibt im Bearbeitungsmodus.<br />
Wenn Sie stattdessen den Bearbeitungsmodus beenden und den ursprünglichen Wert wiederherstellen<br />
wollen, so müssen Sie Cancel auf TRUE stellen und dann die FinishEditing-Methode aufrufen.<br />
AfterEdit-Ereignis (Seite 222)<br />
Dieses Ereignis wird gestartet, nachdem der neue Wert der Zelle zugewiesen und der Editor deaktiviert<br />
wurde. Sie können dieses Ereignis verwenden, um alles, was auf den Wert dieser Zelle beruht, zu<br />
aktualisieren (z.B. Zwischensummen oder Sortierung).<br />
Zusammenfassen und Gliedern<br />
Die FlexGrid-Steuerung besitzt Methoden und Eigenschaften, mit denen Sie Daten zusammenfassen oder<br />
in hierarchischer Form anzeigen können. Um Daten zusammenzufassen und Zwischensummen<br />
hinzuzufügen, müssen Sie die Subtotal-Methode verwenden. Für hierarchische Datenansichten ist die<br />
Tree-Eigenschaft zuständig.<br />
Zwischensummen erstellen<br />
Die Subtotal-Methode fügt eine Zwischensummenzeile mit aggregierten Werten der normalen Zeilen,<br />
aber keine Summen ein.<br />
Subtotal unterstützt hierarchische Summen. Zum Beispiel wenn Ihre Tabelle Umsatzzahlen beinhaltet,<br />
dann können Sie Subtotal dazu verwenden, um zusammengefasste Summen nach Produkten, Regionen<br />
und Verkäufern zu erstellen. Der nachfolgende Quellcode illustriert dies:<br />
• Visual Basic<br />
Private Sub ShowTotals()<br />
' show OutlineBar on column 0<br />
fg.Tree.Column = 0<br />
fg.Tree.Style = TreeStyleFlags.Simple<br />
' clear existing subtotals<br />
fg.Subtotal(AggregateEnum.Clear)<br />
' get a Grand total (use -1 instead of column index)<br />
fg.Subtotal(AggregateEnum.Sum, -1, -1, 3, "Grand Total")<br />
' total per Product (column 0)<br />
fg.Subtotal(AggregateEnum.Sum, 0, 0, 3, "Total {0}")<br />
' total per Region (column 1)<br />
fg.Subtotal(AggregateEnum.Sum, 1, 1, 3, "Total {0}")<br />
' size column widths based on content<br />
fg.AutoSizeCols()
50 · Die <strong>C1FlexGrid</strong>-Steuerung verwenden<br />
• C#<br />
End Sub<br />
private void ShowTotals() {<br />
}<br />
• Delphi<br />
// show OutlineBar on column 0<br />
fg.Tree.Column = 0;<br />
fg.Tree.Style = TreeStyleFlags.Simple;<br />
// clear existing subtotals<br />
fg.Subtotal(AggregateEnum.Clear);<br />
// get a Grand total (use -1 instead of column index)<br />
fg.Subtotal(AggregateEnum.Sum, -1, -1, 3, "Grand Total");<br />
// total per Product (column 0)<br />
fg.Subtotal(AggregateEnum.Sum, 0, 0, 3, "Total {0}");<br />
// total per Region (column 1)<br />
fg.Subtotal(AggregateEnum.Sum, 1, 1, 3, "Total {0}");<br />
// size column widths based on content<br />
fg.AutoSizeCols();<br />
procedure ShowTotals()<br />
begin<br />
// show OutlineBar on column 0<br />
fg.Tree.Column := 0;<br />
fg.Tree.Style := TreeStyleFlags.Simple;<br />
// clear existing subtotals<br />
fg.Subtotal(AggregateEnum.Clear);<br />
// get a Grand total (use -1 instead of column index)<br />
fg.Subtotal(AggregateEnum.Sum, -1, -1, 3, 'Grand Total');<br />
// total per Product (column 0)<br />
fg.Subtotal(AggregateEnum.Sum, 0, 0, 3, 'Total {0}');<br />
// total per Region (column 1)<br />
fg.Subtotal(AggregateEnum.Sum, 1, 1, 3, 'Total {0}');<br />
// size column widths based on content<br />
fg.AutoSizeCols;<br />
end;<br />
Wenn die Subtotal-Methode Zeilen mit zusammengefassten Informationen hinzufügt, dann wird<br />
automatisch das subtotal-Format auf diese neuen Zeilen angewendet. Es gibt fünf Standardformate für<br />
fünf verschiedene Zwischensummenniveaus. Sie können die Formate der Zwischensummenzeilen<br />
verändern, indem Sie die Eigenschaften der Gliederungsformate während der Designtime mit dem Style-<br />
Editor oder während der Runtime mit Quellcode bearbeiten. Zum Beispiel:<br />
• Visual Basic<br />
' set styles for subtotals<br />
Dim cs As CellStyle<br />
cs = fg.Styles(CellStyleEnum.GrandTotal)<br />
cs.BackColor = Color.Black<br />
cs.ForeColor = Color.White<br />
cs.Font = New Font(Font, FontStyle.Bold)<br />
cs = fg.Styles(CellStyleEnum.Subtotal0)<br />
cs.BackColor = Color.DarkRed<br />
cs.ForeColor = Color.White
• C#<br />
cs.Font = New Font(Font, FontStyle.Bold)<br />
cs = fg.Styles(CellStyleEnum.Subtotal1)<br />
cs.BackColor = Color.DarkBlue<br />
cs.ForeColor = Color.White<br />
// set styles for subtotals<br />
CellStyle cs;<br />
cs = fg.Styles[CellStyleEnum.GrandTotal];<br />
cs.BackColor = Color.Black;<br />
cs.ForeColor = Color.White;<br />
cs.Font = new Font(Font, FontStyle.Bold);<br />
cs = fg.Styles[CellStyleEnum.Subtotal0];<br />
cs.BackColor = Color.DarkRed;<br />
cs.ForeColor = Color.White;<br />
cs.Font = new Font(Font, FontStyle.Bold);<br />
cs = fg.Styles[CellStyleEnum.Subtotal1];<br />
cs.BackColor = Color.DarkBlue;<br />
cs.ForeColor = Color.White;<br />
• Delphi<br />
cs := fg.Styles[CellStyleEnum.GrandTotal);<br />
cs.BackColor := Color.Black;<br />
cs.ForeColor := Color.White;<br />
cs.Font := Font.Create(Font, FontStyle.Bold);<br />
cs := fg.Styles[CellStyleEnum.Subtotal0];<br />
cs.BackColor := Color.DarkRed;<br />
cs.ForeColor := Color.White;<br />
cs.Font := Font.Create(Font, FontStyle.Bold);<br />
cs := fg.Styles[CellStyleEnum.Subtotal1];<br />
cs.BackColor := Color.DarkBlue;<br />
cs.ForeColor := Color.White;<br />
Nachdem dieser Quellcode ausgeführt wurde, sollte die Tabelle wie folgt aussehen:<br />
Zusammenfassen und Gliedern · <strong>51</strong>
52 · Die <strong>C1FlexGrid</strong>-Steuerung verwenden<br />
Die Gesamtsummenzeile enthält den gesamten Umsatz für alle Produkte, Regionen und Verkäufer. Sie<br />
wurde mit einer „–1“ für den groupOn-Parameter im Aufruf der Subtotal-Methode erstellt. Die anderen<br />
Zwischensummen zeigen die Umsätze nach Produkten und Regionen. Diese wurden mit den Werten 0<br />
und 1 für den groupOn-Parameter erstellt.<br />
Sie können neben Summen auch noch weitere Aggregationen vornehmen, z.B. Durchschnitte oder<br />
Prozente, und somit verschiedene Zusammenfassungen für jede Zeile vornehmen, z.B. Brutto- und<br />
Nettoumsatz.<br />
Zwischensummenzeilen, die von der Subtotal-Methode erstellt wurden, unterscheiden sich von<br />
normalen Zeilen in drei Aspekten:<br />
1) Zwischensummenzeilen können automatisch mit einem Aufruf der Subtotal-Methode mit dem<br />
flexSTClear-Parameter entfernt werden. Damit wird eine dynamische Ansicht der Daten erstellt,<br />
so dass der Nutzer Spalten verschieben oder Daten neu sortieren kann, und anschließend die<br />
Summen neu berechnet werden.<br />
2) Zwischensummenzeilen dienen als Knotenpunkt in einer Gliederung und können Zeilengruppen<br />
ein- und ausblenden, um eine Übersichtsansicht zu erstellen oder Details zu zeigen. Um die<br />
Gliederung zu sehen, müssen Sie die Tree.Column- und die Tree.Style-Eigenschaften setzen, um<br />
die Position und das Format der Gliederung festzulegen.<br />
3) Zwischensummenzeilen können als Knoten in Bäumen verwendet werden. Sie können das<br />
Node-Objekt für jede Zwischensummenzeilen mit der Rows(index).Node-Eigenschaft abrufen.<br />
4) Wenn die Tabelle an eine Datenquelle gebunden ist, dann entsprechen Zwischensummenzeilen<br />
nicht den eigentlichen Daten. Wenn Sie den Cursor in der Datenquelle bewegen, dann werden<br />
die Zwischensummenzeilen in der Tabelle ausgelassen.<br />
Mit der Gliederung kann der Nutzer Teile der Tabelle ein- und ausblenden, indem er auf die<br />
Knotenpunkte klickt. Sie können diese Gliederungen auch dafür verwenden, verschiedene
Zusammenfassen und Gliedern · 53<br />
Informationstypen und nicht nur Zusammenfassungen anzuzeigen. Das nächste Beispiel zeigt, wie Sie<br />
eine benutzerdefinierte Gliederung für die Anzeige von Verzeichnisinformationen erstellen können.<br />
Benutzerdefinierte Gliederungsbäume erstellen<br />
Um Gliederungen ohne die Subtotal-Methode zu erstellen, müssen Sie den folgenden 3 Schritten folgen:<br />
1) Fügen Sie Zeilen in die Tabelle ein.<br />
2) Ändern Sie einige Zeilen zu Gliederungsknoten, indem Sie deren Row(index).IsNode-Eigenschaft<br />
auf TRUE stellen.<br />
3) Rufen Sie das Node-Objekt für jede Knotenzeile ab und setzen Sie dessen Level-Eigenschaft, um<br />
das Niveau und die Position in der Baumhierarchie festzulegen. Höhere Werte bedeuten, dass<br />
der Knoten sich auf tieferen Ebenen in der Gliederung befinden wird.<br />
Zum Beispiel, der nachfolgende Quellcode erstellt einen Verzeichnisbaum:<br />
• Visual Basic<br />
• C#<br />
Private Sub Form1_Load(ByVal sender As System.Object, _<br />
ByVal e As System.EventArgs) Handles MyBase.Load<br />
' initialize grid layout<br />
fg.Cols.Fixed = 0<br />
fg.Cols.Count = 1<br />
fg.Rows.Count = 1<br />
fg.ExtendLastCol = True<br />
fg.Styles.Normal.TextAlign = TextAlignEnum.LeftCenter<br />
fg.Styles.Normal.Border.Style = BorderStyleEnum.None<br />
' initialize outline tree<br />
fg.Tree.Column = 0<br />
fg.Tree.Style = TreeStyleFlags.SimpleLeaf<br />
' populate the grid<br />
AddDirectory("c:\", 0)<br />
End Sub<br />
private void Form1_Load( System.object sender, System.EventArgs e)<br />
base.Load {<br />
// initialize grid layout<br />
fg.Cols.Fixed = 0;<br />
fg.Cols.Count = 1;<br />
fg.Rows.Count = 1;<br />
fg.ExtendLastCol = true;<br />
fg.Styles.Normal.TextAlign = TextAlignEnum.LeftCenter;<br />
fg.Styles.Normal.Border.Style = BorderStyleEnum.None;<br />
// initialize outline tree<br />
fg.Tree.Column = 0;<br />
fg.Tree.Style = TreeStyleFlags.SimpleLeaf;<br />
// populate the grid<br />
AddDirectory("c:\", 0);<br />
}
54 · Die <strong>C1FlexGrid</strong>-Steuerung verwenden<br />
• Delphi<br />
procedure Form1_Load(sender: System.Object; _<br />
e: System.EventArgs);<br />
begin<br />
// initialize grid layout<br />
fg.Cols.Fixed := 0;<br />
fg.Cols.Count := 1;<br />
fg.Rows.Count := 1;<br />
fg.ExtendLastCol := True;<br />
fg.Styles.Normal.TextAlign := TextAlignEnum.LeftCenter;<br />
fg.Styles.Normal.Border.Style := BorderStyleEnum.None;<br />
// initialize outline tree<br />
fg.Tree.Column := 0;<br />
fg.Tree.Style := TreeStyleFlags.SimpleLeaf;<br />
// populate the grid<br />
AddDirectory("c:\", 0)<br />
end;<br />
Der obenstehende Quelltext initialisiert das Tabellenformat und ruft die AddDirectory-Routine auf, die<br />
die Tabelle erstellt und die Gliederungsstruktur einrichtet:<br />
• Visual Basic<br />
Private Sub AddDirectory(ByVal dir As String, ByVal level As Integer)<br />
' add this directory<br />
Dim thisDir As String<br />
thisDir = Path.GetFileName(dir)<br />
If thisDir.Length = 0 Then thisDir = dir<br />
fg.AddItem(thisDir.ToUpper())<br />
End Sub<br />
' make this new row a node<br />
Dim row As Row = fg.Rows(fg.Rows.Count - 1)<br />
row.IsNode = True<br />
' set node level<br />
Dim nd As Node = row.Node<br />
nd.Level = level<br />
' add files in this directory<br />
Dim file As String, cnt As Integer<br />
cnt = 0<br />
For Each file In Directory.GetFiles(dir)<br />
fg.AddItem(Path.GetFileName(file).ToLower())<br />
cnt = cnt + 1<br />
If cnt > 10 Then Exit For<br />
Next<br />
' add subdirectories (up to level 4)<br />
If level 10 Then Exit For<br />
Next<br />
End If
• C#<br />
private void AddDirectory( string dir, int level) {<br />
// add this directory<br />
string thisDir = Path.GetFileName(dir);<br />
if ( thisDir.Length == 0) thisDir = dir;<br />
fg.AddItem(thisDir.ToUpper());<br />
• Delphi<br />
// make this new row a node<br />
Row row = fg.Rows[fg.Rows.Count – 1];<br />
row.IsNode = true;<br />
// set node level<br />
Node nd = row.Node;<br />
nd.Level = level;<br />
// add files in this directory<br />
int cnt = 0;<br />
foreach (string file In Directory.GetFiles(dir)<br />
{<br />
fg.AddItem(Path.GetFileName(file).ToLower());<br />
cnt = cnt + 1;<br />
if ( cnt > 10) break; }<br />
procedure AddDirectory(dir: String; level: Integer);<br />
var<br />
thisDir: string;<br />
r: Row;<br />
nd: Node;<br />
file: string;<br />
cnt: Integer;<br />
files: array of string;<br />
subdir: string;<br />
begin<br />
// add this directory<br />
thisDir := Path.GetFileName(dir);<br />
If thisDir.Length = 0 Then thisDir := dir;<br />
fg.AddItem(thisDir.ToUpper());<br />
// make this new row a node<br />
r := fg.Rows(fg.Rows.Count - 1);<br />
r.IsNode := True;<br />
// set node level<br />
nd := r.Node;<br />
nd.Level := level;<br />
// add files in this directory<br />
cnt := 0;<br />
files := Directory.GetFiles(dir);<br />
for I := 0 to High(Files) do<br />
begin<br />
fg.AddItem(Path.GetFileName(files[I].ToLower());<br />
cnt := cnt + 1;<br />
if cnt > 10 then<br />
break;<br />
end;<br />
// add subdirectories (up to level 4)<br />
If level
56 · Die <strong>C1FlexGrid</strong>-Steuerung verwenden<br />
for I := 0 to High(files) do<br />
begin<br />
AddDirectory(subdir, level + 1);<br />
cnt := cnt + 1;<br />
if cnt > 10 then<br />
break;<br />
end;<br />
end;<br />
end;<br />
AddDirectory ist eine rekursive Routine, die das aktuelle Verzeichnis und dessen Unterverzeichnisse<br />
durchquert. In diesem Beispiel ist die Gliederungstiefe auf vier Ebenen beschränkt, um Zeit zu sparen. In<br />
einer richtigen Anwendung sollte die Routine so geändert werden, dass Sie diese Gliederungsebenen nur<br />
dann erstellt, wenn Sie aufgerufen, bzw. die Gliederung erweitert wird. Schauen Sie in den FlexGrid-<br />
Anweisungen nach (Seite 78).<br />
Der Quelltext erstellt eine Tabelle, die wie folgt aussieht:<br />
Zellen verbinden<br />
Mit der <strong>C1FlexGrid</strong>-Steuerung können Sie Zellen verbinden, so dass sich diese über mehrere Spalten<br />
oder Zeile erstrecken. Diese Funktion kann dafür verwendet werden, die Daten der Tabelle deutlicher<br />
und klarer anzuzeigen. Der Effekt dieser Funktion ähnelt dem des HTML „“- und<br />
„“-Befehles.<br />
Um Zellverbindungen zu aktivieren, müssen Sie zwei Dinge tun:<br />
1. Setzen Sie die AllowMerging-Eigenschaft der Tabelle auf einen von Null verschiedenen Wert.<br />
Das Ergebnis der verschiedenen Einstellungen wird im Referenzabschnitt erläutert.<br />
2. Wenn Sie Spalten verbinden wollen, müssen Sie die Cols(index).AllowMerging-Eigenschaft von<br />
jeder betroffenen Spalte auf TRUE stellen. Wollen Sie hingegen Zeilen verbinden, so müssen Sie<br />
die Rows(index).AllowMerging-Eigenschaft von jeder betroffenen Zeile auf TRUE stellen.
Zellen verbinden · 57<br />
Die Zellen werden verbunden, wenn die jeweils angrenzenden Zellen die gleiche nicht-leere Zeichenkette<br />
besitzt. Es gibt keine Methode mit der Sie Zellenverbindungen erzwingen können. Die Verbindungen<br />
werden automatisch aufgrund der Zellinhalte erstellt. Damit ist es leichter, aggregierte Ansichten für<br />
sortierte Daten mit wiederholten Daten in aufeinanderfolgenden Zeilen bereitzustellen.<br />
Zellverbindungen besitzen viele mögliche Anwendungen. Zum Beispiel können Sie für<br />
Tabellenüberschriften über mehrere Spalten hinweg, verbundene Datenansichten oder Tabellen, in denen<br />
der Text in angrenzende Spalten übergeht, verwendet werden.<br />
Verbundene Tabellenüberschriften<br />
Um verbundene Tabellenüberschriften zu erstellen, müssen Sie zunächst die Tabelleneigenschaft<br />
AllowMerging auf FixedOnly setzen. Danach legen Sie die Zeilen und Spalten fest, die verbunden<br />
werden sollen, indem Sie die Zeilen- und Spalteneigenschaft AllowMerging setzen. Schlussendlich<br />
müssen Sie den Überschriftstext in jede Zelle der Tabellenüberschrift eintragen, so dass die Zellen, die Sie<br />
verbinden wollen, denselben Inhalt haben.<br />
Der nachfolgende Quelltext zeigt ein Beispiel hierfür:<br />
• Visual Basic<br />
Private Sub Form1_Load(ByVal sender As System.Object, _<br />
ByVal e As System.EventArgs) Handles MyBase.Load<br />
Dim i%<br />
' initialize control<br />
fg.Styles.Normal.WordWrap = True<br />
fg.Cols.Count = 9<br />
fg.Rows.Fixed = 2<br />
fg.AllowMerging = AllowMergingEnum.FixedOnly<br />
' create row headers<br />
fg.Rows(0).AllowMerging = True<br />
' four cells with same contents, will merge<br />
Dim rng As CellRange = fg.GetCellRange(0, 1, 0, 4)<br />
rng.Data = "North"<br />
' four cells with same contents, will merge<br />
rng = fg.GetCellRange(0, 5, 0, 8)<br />
rng.Data = "South"<br />
For i = 1 To 4<br />
fg(1, i) = "Qtr " & i<br />
fg(1, i + 4) = "Qtr " & i<br />
Next<br />
' create column header<br />
fg.Cols(0).AllowMerging = True<br />
' two cells with same contents, will merge<br />
rng = fg.GetCellRange(0, 0, 1, 0)<br />
rng.Data = "Sales by Product"<br />
' align and autosize the cells<br />
fg.Styles.Fixed.TextAlign = TextAlignEnum.CenterCenter<br />
fg.AutoSizeCols(1, fg.Cols.Count - 1, 10)<br />
End Sub
58 · Die <strong>C1FlexGrid</strong>-Steuerung verwenden<br />
• C#<br />
private void Form1_Load( System.object sender, System.EventArgs e)<br />
base.Load {<br />
i%;<br />
}<br />
• Delphi<br />
// initialize control<br />
fg.Styles.Normal.WordWrap = true;<br />
fg.Cols.Count = 9;<br />
fg.Rows.Fixed = 2;<br />
fg.AllowMerging = AllowMergingEnum.FixedOnly;<br />
// create row headers<br />
fg.Rows[0].AllowMerging = true;<br />
// four cells with same contents, will merge<br />
CellRange rng = fg.GetCellRange(0, 1, 0, 4);<br />
rng.Data = "North";<br />
// four cells with same contents, will merge<br />
rng = fg.GetCellRange(0, 5, 0, 8);<br />
rng.Data = "South";<br />
for ( i = 1 ; i
fg[1, i] := 'Qtr ' + I;<br />
fg[1, i + 4] = 'Qtr ' + I;<br />
end;<br />
// create column header<br />
fg.Cols[0].AllowMerging := True;<br />
// two cells with same contents, will merge<br />
rng := fg.GetCellRange(0, 0, 1, 0);<br />
rng.Data := 'Sales by Product';<br />
// align and autosize the cells<br />
fg.Styles.Fixed.TextAlign := TextAlignEnum.CenterCenter;<br />
fg.AutoSizeCols(1, fg.Cols.Count - 1, 10);<br />
end;<br />
So sieht das Ergebnis aus:<br />
Verbundene Datenansichten<br />
Zellen verbinden · 59<br />
Zellverbindungen funktionieren ebenso, wenn die Tabelle an eine Datenquelle gebunden ist. Der<br />
nachfolgende Quelltext zeigt ein Beispiel hierfür. Der Quellcode verwendet ein DataAdapter-Objekt,<br />
welches während der Designtime erstellt wurde:<br />
• Visual Basic<br />
• C#<br />
Private Sub Form1_Load(ByVal sender As System.Object, _<br />
ByVal e As System.EventArgs) Handles MyBase.Load<br />
Dim i%<br />
' bind the grid to a data source<br />
Dim ds As New DataSet()<br />
SqlDataAdapter1.Fill(ds)<br />
fg.DataSource = ds.Tables(0)<br />
' set up cell merging<br />
fg.AllowMerging = AllowMergingEnum.RestrictCols<br />
For i = fg.Cols.Fixed To fg.Cols.Count – 1<br />
fg.Cols(i).AllowMerging = True<br />
Next<br />
End Sub<br />
private void Form1_Load( System.object sender, System.EventArgs e)<br />
{<br />
// bind the grid to a data source<br />
DataSet ds = new DataSet();<br />
SqlDataAdapter1.Fill(ds);
60 · Die <strong>C1FlexGrid</strong>-Steuerung verwenden<br />
}<br />
• Delphi<br />
fg.DataSource = ds.Tables[0];<br />
// set up cell merging<br />
fg.AllowMerging = AllowMergingEnum.RestrictCols;<br />
for (int i = fg.Cols.Fixed; i
Zellen verbinden · 61<br />
1. Die Spill-Einstellung ermöglicht dem Text, der zu lang für eine Zelle ist, in angrenzende leere<br />
Zellen überzugehen. Das Ergebnis ist dem von Microsoft Excel ähnlich. Wenn ein Eintrag in einer<br />
Zelle zu lang ist, dann wird dieser über den angrenzenden leeren Zellen angezeigt.<br />
Zum Beispiel die nachfolgende Grafik zeigt wie die Tabelle aussehen könnte, wenn die<br />
AllowMerging-Eigenschaft auf Spill gesetzt wurde und ein Nutzer unterschiedlich lange<br />
Einträge vornimmt:<br />
2. Die Nodes-Einstellung ist der Spill-Einstellung ähnlich, wird aber nur auf Gliederungsknoten<br />
angewendet. Diese Eigenschaft ist für gruppierte Daten nützlich, bei denen die Knotenzeilen<br />
Informationen enthalten, die ein anderes Format als die Datenzeilen besitzen.<br />
Zum Beispiel die nachfolgende Grafik zeigt, wie die Tabelle aussehen könnte, wenn die Daten<br />
mit der Subtotal-Methode gruppiert und zusammengefasst sind, und die AllowMerging auf<br />
Nodes gesetzt wurde:<br />
Diese Grafik ist der im vorhergehenden Abschnitt über Zwischensummen ähnlich. Der<br />
Unterschied liegt in den Zwischensummenzeilen (Knoten), deren Inhalte in die nun links<br />
angrenzenden leeren Zellen übergehen und damit die Ansicht verbessert.<br />
Benutzerdefinierte Verbindungen<br />
Sie können das Standardverhalten der Verbindungen auf zwei Wegen anpassen:
62 · Die <strong>C1FlexGrid</strong>-Steuerung verwenden<br />
1. Ordnen Sie eine benutzerdefinierte IComparer-Klasse der CustomComparer-Eigenschaft zu.<br />
Standardmäßig verbindet die Tabellensteuerung Zellen mit demselben, aber von Null verschiedenen<br />
Inhalt. Zeichenkettenvergleiche berücksichtigen Groß- und Kleinschreibung und Leerzeichen.<br />
Wenn Sie möchten, dass die Tabellensteuerung Zellen verbindet, wobei beim Inhaltsvergleich sowohl<br />
Groß- und Kleinschreibung als auch Leerzeichen unberücksichtig bleiben, dann müssen Sie eine eigene<br />
Klasse schreiben, den IComparer implementieren und diese der CustomComparer-Eigenschaft<br />
zuordnen.<br />
2. Schreiben Sie eine neue Klasse, die von der <strong>C1FlexGrid</strong> abgleitet wird, und überschreiben Sie die<br />
GetMergedRange-Virtualmethode mit Ihrer eigenen Verbindungslogik.<br />
Für Beispiele, die zeigen, wie man benutzerdefinierte Verbindungslogiken implementiert, schauen Sie<br />
bitte in den „CustomMerge“-Beispielen in unserer online Beispielbibliothek nach.<br />
Speichern, Laden und Drucken<br />
Die <strong>C1FlexGrid</strong>-Steuerung besitzt Methoden, mit denen Sie Tabellen speichern, laden und drucken<br />
können.<br />
Tabellen in Textdateien speichern und öffnen<br />
Die SaveGrid-Methode speichert die Tabelle in einer Textdatei ab. Diese Methode besitzt verschiedene<br />
Parameter, die u.a. das Trennzeichen festlegen (z.B. Kommas, Tabulatoren oder benutzerdefinierte<br />
Trennzeichen), festlegen, ob die festen Zellen, oder nur die scrollbaren Zellen gespeichert werden und<br />
den Encodertyp bestimmen (z.B. ASCII oder Unicode). Die erstellten Textdateien können später mit der<br />
Tabellensteuerung oder mit jedem anderen Programm geladen werden, welches komma- oder<br />
tabulatorengetrennte Textdateien, z.B. Microsoft Excel, unterstützt.<br />
Die LoadGrid-Methode liest die Daten aus den Textdateien aus. Sie können alle Textdateien öffnen, die<br />
entweder mit der SaveGrid-Methode oder einem anderen beliebigen Programm erstellt wurden.<br />
Das Format der Textdateien ist recht einfach. Die Zellinhalte werden als formatierte Zeichenketten<br />
gespeichert, genauso wie diese auf dem Bildschirm angezeigt werden. Wenn der Text der Zelle<br />
Anführungszeichen oder Zelltrennzeichen enthält, dann wird die Zelle in Anführungszeichen<br />
eingeschlossen, so dass alle Anführungszeichen im Zelltext verdoppelt werden. Diese Konvention wird<br />
ebenfalls in Microsoft Excel-Textdateien verwendet.<br />
Textdateien enthalten keine Bilder und keine Formatierungsinformationen.<br />
Die SaveGrid-Methode besitzt den flags-Parameter, mit dem Sie festlegen können, ob die gesamte<br />
Tabelle oder nur ein Teil (scrollbarer, sichtbarer oder ausgewählter Bereich) gespeichert werden soll.<br />
Microsoft Excel-Dateien speichern und öffnen<br />
Ab Version 2.5 können Sie die Methoden SaveGrid und LoadGrid verwenden, um sowohl Microsoft<br />
Excel-Dateien (*.xls) als auch Textdateien abzuspeichern. Somit können neben den Daten auch die<br />
Formatierungsinformationen abgespeichert werden.<br />
Um Excel-Dateien mit den SaveGrid- und LoadGrid-Methoden zu speichern oder zu öffnen, müssen Sie<br />
nur den format-Parameter auf FileFormatEnum.Excel stellen und die besagten Methoden wie üblich<br />
aufrufen. Microsoft Excel muss hierfür nicht auf Ihrem Computer installiert sein.<br />
Excel-Dateien enthalten „Arbeitsmappen“, die aus „Blättern“ bestehen. Die SaveGrid und LoadGrid-<br />
Methoden speichern Tabellen auf nur einem Arbeitsblatt ab und öffnen immer nur das erste Blatt einer<br />
Mappe. Wenn Sie die zu speichernden oder zu öffnenden Blätter festlegen wollen, so müssen Sie die
Speichern, Laden und Drucken · 63<br />
SaveExcel-, LoadExcel- und LoadExcelSheetNames-Methoden verwenden. Der Speicher- und<br />
Ladeprozess von Excel-Dateien wandelt die meisten Datentypen und Formatierungsinformationen um,<br />
u.a. Zeilenhöhe und Spaltenbreite, Schriftarten, Farben, Formate und Zellausrichtungen. Dennoch<br />
können nicht alle Formatierungselemente umgewandelt werden. Zum Beispiel wir die Tabellensteuerung<br />
zwar die Werte in die Excel-Zellen laden, die darunter liegenden Formeln gehen dabei aber verloren.<br />
Andere Funktionen, wie zum Beispiel eingefrorene und verbundene Zellen, Bilder, Datengliederungen<br />
und Zellrahmen werden auch nicht übernommen.<br />
Tabellen aus Datenbanken laden<br />
Sie können Tabellendaten auch aus Datenbanken laden. Dies unterscheidet sich von Datenbindungen, bei<br />
denen die Verbindung zwischen den Steuerungen und der zugrundeliegenden Datenquelle erhalten<br />
bleiben. Um Daten aus Datenbanken zu laden, können Sie das DataReader-Objekt wie folgt verwenden:<br />
• Visual Basic<br />
• C#<br />
Private Sub _btnData_Click(sender As Object, e As System.EventArgs)<br />
' prepare DataReader<br />
Dim strConn As String = "data source=MYMACHINE;initial<br />
catalog=Northwind;"<br />
Dim myConn As New SqlConnection(strConn)<br />
Dim myCMD As New SqlCommand("SELECT * FROM Employees", myConn)<br />
myConn.Open()<br />
Dim myReader As SqlDataReader = myCMD.ExecuteReader()<br />
' build grid structure from DB schema<br />
Dim dt As DataTable = myReader.GetSchemaTable()<br />
_flex.Cols.Count = 1<br />
Dim dr As DataRow<br />
For Each dr In dt.Rows<br />
Dim c As Column = _flex.Cols.Add()<br />
c.Caption =(c.Name
64 · Die <strong>C1FlexGrid</strong>-Steuerung verwenden<br />
}<br />
• Delphi<br />
// build grid structure from DB schema<br />
DataTable dt = myReader.GetSchemaTable();<br />
_flex.Cols.Count = 1;<br />
foreach (DataRow dr in dt.Rows)<br />
{<br />
Column c = _flex.Cols.Add();<br />
c.Caption = c.Name = (string)dr["ColumnName"];<br />
c.DataType = (Type)dr["DataType"];<br />
}<br />
// populate grid<br />
_flex.Rows.Count = 1;<br />
int row = 1;<br />
int cols = dt.Columns.Count;<br />
object[] v = (object[])Array.CreateInstance(typeof(object), cols);<br />
while (myReader.Read())<br />
{<br />
myReader.GetValues(v);<br />
_flex.AddItem(v, row++, 1);<br />
}<br />
// cleanup<br />
_flex.AutoSizeCols();<br />
myReader.Close();<br />
myConn.Close();<br />
var<br />
v: System.Array;<br />
cols: Integer;<br />
row: Integer;<br />
dt: DataTable;<br />
dr: DataRow;<br />
myReader: SqlDataReader;<br />
myCMD: SqlCommand;<br />
myConn: SqlConnection;<br />
strConn: string;<br />
c: Column;<br />
begin<br />
// prepare DataReader<br />
strConn := 'data source=MYMACHINE;initial catalog=Northwind;';<br />
myConn := SqlConnection.Create(strConn);<br />
myCMD := SqlCommand.Create('SELECT * FROM Employees', myConn);<br />
myConn.Open;<br />
myReader := myCMD.ExecuteReader;<br />
// build grid structure from DB schema<br />
dt := myReader.GetSchemaTable;<br />
_flex.Cols.Count = 1<br />
for I := 0 to dt.Rows.Count – 1 do<br />
begin<br />
dr := dt.Rows[I];<br />
c := flex.Cols.Add;<br />
c.Caption := string(dr['ColumnName']);<br />
c.Name := string(dr['ColumnName']);<br />
c.DataType := System.Type(dr['DataType']);<br />
end;<br />
// populate grid<br />
flex.Rows.Count := 1;<br />
row := 1;<br />
cols := dt.Columns.Count;
Tabellen drucken<br />
Speichern, Laden und Drucken · 65<br />
v := _ System.Array.CreateInstance(typeof(System.Object), cols),<br />
cols);<br />
While myReader.Read() do<br />
begin<br />
myReader.GetValues(v);<br />
_flex.AddItem(v, row, 1);<br />
row := row + 1;<br />
end;<br />
// cleanup<br />
_flex.AutoSizeCols;<br />
myReader.Close;<br />
myConn.Close;<br />
end; //_btnData_Click<br />
Verwenden Sie die PrintGrid-Methode um die Inhalte einer Tabelle zu drucken. Diese Methode besitzt<br />
Parameter, mit denen Sie u.a. den Skalierungsmodus auswählen können, das Druckvorschaufenster<br />
anzeigen und Kopf- und Fußzeilen festlegen können.<br />
Die PrintParameters-Eigenschaft beinhaltet weitere Druckeinstellungen, wie zum Beispiel die Schriftart<br />
der Kopf- und Fußzeilen und ein PrintDocument-Objekt des .NET-Frameworks, mit dem u.a. der<br />
Drucker, die Papiergröße und Ausrichtung sowie die Ränder ausgewählt werden können.<br />
Der Nachfolgende Quelltext verwendet die PrintParameters-Eigenschaft, um die Seitenausrichtung, die<br />
Ränder und die Kopf- und Fußzeilenschriftart festzulegen. Dann wird die PrintGrid-Methode<br />
aufgerufen, um eine Druckvorschau anzuzeigen:<br />
• Visual Basic<br />
• C#<br />
' get grid's PrintDocument object<br />
Dim pd As PrintDocument<br />
pd = fg.PrintParameters.PrintDocument()<br />
' set up the page (landscape, 1.5" left margin)<br />
With pd.DefaultPageSettings<br />
.Landscape = True<br />
.Margins.Left = 150<br />
End With<br />
' set up header and footer fonts<br />
fg.PrintParameters.HeaderFont = New Font("Arial Black", 14,<br />
FontStyle.Bold)<br />
fg.PrintParameters.FooterFont = New Font("Arial Narrow", 8,<br />
FontStyle.Italic)<br />
' preview the grid<br />
fg.PrintGrid("VB Tutorial", _<br />
PrintGridFlags.FitToPageWidth + PrintGridFlags.ShowPreviewDialog, _<br />
"VB Tutorial" + Chr(9) + Chr(9) + Format(DateTime.Now, "d"), _<br />
Chr(9) + Chr(9) + "Page {0} of {1}")<br />
// get grid's PrintDocument object<br />
PrintDocument pd = fg.PrintParameters.PrintDocument();<br />
// set up the page (landscape, 1.5" left margin)<br />
pd.DefaultPageSettings;<br />
.Landscape = true;<br />
.Margins.Left = 150;<br />
} With
66 · Die <strong>C1FlexGrid</strong>-Steuerung verwenden<br />
// set up header and footer fonts<br />
fg.PrintParameters.HeaderFont = new Font("Arial Black", 14,<br />
FontStyle.Bold);<br />
fg.PrintParameters.FooterFont = new Font("Arial Narrow", 8,<br />
FontStyle.Italic);<br />
// preview the grid<br />
fg.PrintGrid("VB Tutorial",<br />
PrintGridFlags.FitToPageWidth | PrintGridFlags.ShowPreviewDialog,<br />
"VB Tutorial\t\t" + Format(DateTime.Now, "d"),<br />
"\t\tPage {0} of {1}");<br />
• Delphi<br />
var<br />
pd: PrintDocument;<br />
begin<br />
// get grid's PrintDocument object<br />
pd := flex.PrintParameters.PrintDocument;<br />
// set up the page (landscape, 1.5" left margin)<br />
With pd.DefaultPageSettings do<br />
begin<br />
Landscape := True;<br />
Margins.Left := 150;<br />
End;<br />
// set up header and footer fonts<br />
flex.PrintParameters.HeaderFont := System.Drawing.Font.Create('Arial<br />
Black', 14, FontStyle.Bold);<br />
flex.PrintParameters.FooterFont := System.Drawing.Font.Create('Arial<br />
Narrow', 8, FontStyle.Italic);<br />
// preview the grid<br />
flex.PrintGrid('VB Tutorial',<br />
PrintGridFlags.FitToPageWidth or PrintGridFlags.ShowPreviewDialog,<br />
'VB Tutorial'#9#9 + Format(DateTime.Now, 'd'),<br />
#9#9 + 'Page {0} of {1}');<br />
end;<br />
FlexGrid-Eigenschaftsgruppen<br />
Die <strong>C1FlexGrid</strong>-Steuerung besitzt sehr viele Eigenschaften, Methoden und Ereignisse, die Sie natürlich<br />
nicht alle kennen müssen, um die Steuerung effektiv nutzen zu können.<br />
Die nachfolgende Auflistung zeigt die wichtigsten Eigenschaften, Methoden und Ereignisse, gruppiert<br />
nach Anwendungstyp. Einige Elemente tauchen in mehr als nur einer Gruppe auf. Für weitere Details<br />
über bestimmte Elemente schauen Sie bitte im Referenzverzeichnis dieser Dokumentation nach.<br />
1) Tabellenformatierung<br />
Rows, Cols, AutoSizeCols, ScrollBars, ScrollTrack<br />
2) Cursor und Auswahlen<br />
SelectionMode, Select, ShowCell, Row, Col, RowSel, ColSel, SelectionBeforeMouseDown,<br />
MouseRow, MouseCol,<br />
BeforeRowColChange, AfterRowColChange, BeforeSelChange, AfterSelChange,<br />
KeyActionTab, KeyActionEnter
3) Bearbeiten<br />
AllowEditing, ComboList, EditMask,<br />
BeforeEdit, StartEdit, ValidateEdit, AfterEdit,<br />
StartEditing, FinishEditing, Editor, CellButtonClick,<br />
KeyDownEdit, KeyPressEdit, KeyUpEdit, ChangeEdit<br />
4) Werte abrufen und abspeichern<br />
Item (indexer), GetData, GetDataDisplay, SetData, GetCellRange,<br />
GetCellImage, SetCellImage, Clip, FindRow, Aggregate, CellChanged<br />
5) Benutzerschnittstellen<br />
AllowEditing, AllowMerging, AllowResizing, AllowDragging,<br />
AllowSorting, BeforeSort, AfterSort, AutoSearch, AutoSearchDelay<br />
BeforeDragColumn, AfterDragColumn, BeforeDragRow, AfterDragRow,<br />
BeforeResizeColumn, AfterResizeColumn, BeforeResizeRow, AfterResizeRow,<br />
ScrollTips, ScrollTipText, BeforeScrollTip<br />
6) Gliederungen und Zusammenfassungen<br />
Subtotal, Tree, Rows(index).IsNode, Node.Level,<br />
Node.Collapsed, BeforeCollapse, AfterCollapse<br />
7) Zellen verbinden<br />
AllowMerging, GetMergedRange<br />
8) Datenbindungen<br />
DataSource, DataMember, AfterDataRefresh, AutoResize, GridError<br />
9) Tabellen speichern, öffnen und drucken<br />
LoadGrid, SaveGrid, LoadExcel, SaveExcel, ClipSeparators, PrintGrid<br />
10) OLE-Drag-Drop<br />
DragMode, DropMode, BeforeMouseDown<br />
FlexGrid-Eigenschaftsgruppen · 67
FlexGrid-Beispiele<br />
Visual Basic-Beispiele · 69<br />
Die folgenden Beispiele sind in diesem Produkt enthalten. Verschiedene Produkte und Beispiele können<br />
auch noch weitere <strong>ComponentOne</strong>-Steuerungen beinhalten. An dieser Stelle sind einige Beispiele<br />
aufgeführt. Sie demonstrieren diverse Programmfunktionen und wie die entsprechende Steuerung in den<br />
Rest der <strong>ComponentOne</strong>-Produktlinie integriert wird. Diese entsprechenden Steuerungen müssen aber<br />
nicht zwingend in dem von Ihnen möglicherweise einzeln erworbenen Produkt enthalten sein.<br />
Die <strong>ComponentOne</strong>-Beispiele sind auch unter http://www.componentone.com/samples verfügbar.<br />
Visual Basic-Beispiele<br />
AutoSizeEdit<br />
BarChart<br />
Benchmark<br />
Blinker<br />
BoundDelete<br />
BoundFinishEdit<br />
BoundImage<br />
CellBorders<br />
CellDataType<br />
CellMerging<br />
Clipboard<br />
ColumnEditor<br />
CustomDataMap<br />
Ändert die Größe des Editors, während der Nutzer schreibt. Dieses<br />
Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Erstellt Balkendiagramme mit Tabellenzellen. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Vergleicht die Stärke der Datenbindungen für FlexGrid und<br />
MSDataGrid. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>- und die<br />
C1TrueDBGrid-Steuerung.<br />
Verwendet CellStyles um Zellen blinken zu lassen. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Löscht Zeilen aus einem gebundenen FlexGrid. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Übergibt Änderungen nach Bearbeitung an DataRow. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Knüpft die Tabelle an Grafikfelder, die als OLE-Objekte abgespeichert<br />
sind. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Verwendet OwnerDraw um benutzerdefinierte Zellrahmen<br />
bereitzustellen. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Ordnet Zelltypen (und Editoren) auf einer „pro Zelle“-Basis zu. Dieses<br />
Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Zeigt verschiedene Typen von Zellverbindungen in einer FlexGrid-<br />
Steuerung. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Fügt die Unterstützung für Zwischenablagen der FlexGrid-Steuerung<br />
hinzu. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Zeigt den FlexGrid-Spalteneditor der Designtime in Ihrer Steuerung an.<br />
Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Legt die Auswahloptionen in Auswahlfeldern unter Verwendung von<br />
DataMaps fest. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.
70 · FlexGrid-Beispiele<br />
CustomEditor<br />
CustomMerge<br />
CustomMerge2<br />
CustomMerge3<br />
CustomMerge4<br />
CustomPrint<br />
CustomTree<br />
DataIndex<br />
DataMap<br />
DataReader<br />
DataTable<br />
DataTableDictionary<br />
DBDynamicStyles<br />
DBImageField<br />
DBSchemaChange<br />
DBTree<br />
Implementiert Ihren eigenen Zelleditor. Dieses Beispiel verwendet die<br />
<strong>C1FlexGrid</strong>-Steuerung.<br />
Implementiert Ihre eigene Verbindungslogik um einen Bildschirm für<br />
einen TV-Führer zu erstellen. Dieses Beispiel ruft den<br />
C1.Win.<strong>C1FlexGrid</strong>-Namensbereich auf.<br />
Implementiert Ihre eigene Verbindungslogik um verschiedene<br />
Verbindungsarten zu vermischen. Dieses Beispiel ruft den<br />
C1.Win.<strong>C1FlexGrid</strong>-Namensbereich auf.<br />
Zeigt, wie Gruppierung angepasst wird, indem man sich über die<br />
GetData-Methode hinwegsetzt. Dieses Beispiel ruft den<br />
C1.Win.<strong>C1FlexGrid</strong>-Namensbereich auf.<br />
Zeigt, wie Gruppierung angepasst wird, indem man sich über die<br />
GetData-Methode hinwegsetzt. Dieses Beispiel ruft den<br />
C1.Win.<strong>C1FlexGrid</strong>-Namensbereich auf.<br />
Verwendet die CreateImage-Methode, um Tabellen mit willkürlichen<br />
Zeilen- und Spaltenumbrüchen zu drucken. Dieses Beispiel verwendet<br />
die <strong>C1FlexGrid</strong>-Steuerung.<br />
Verwendet die <strong>C1FlexGrid</strong>-Steuerung, um einen Gliederungsbaum zu<br />
erstellen. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Verwendet die Row.DataIndex-Eigenschaft, um die zugrunde liegende<br />
Datenzeile zu ermitteln. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-<br />
Steuerung.<br />
Verwendet auf Daten zugeordnete Spalten, wenn diese an eine<br />
Datenquelle gebunden sind. Dieses Beispiel verwendet die<br />
<strong>C1FlexGrid</strong>-Steuerung.<br />
Füllt eine Tabelle aus einem DataReader aus. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Verknüpft zu DataTable, fügt Zeilen hinzu und löscht Zeilen. Dieses<br />
Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Zeigt, wie DataMaps aus DataTable-Objekten erstellt werden. Dieses<br />
Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Wendet Formatvorlagen auf Zellen, basierend auf deren Inhalten, an.<br />
Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Zeigt in einer DataTable abgespeicherte Bilder. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Prüft die Tabellenreaktion auf Änderungen im Datenquellobjekt. Dieses<br />
Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Zeigt gebundene Daten in einer hierarchischen Gliederungsansicht an.<br />
Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.
DragDrop<br />
DragRow<br />
DynamicStyles<br />
Editing<br />
FlexByRow<br />
FlexGroup<br />
FreezeBottom<br />
GridChart<br />
HierData<br />
Hyperlink<br />
MapAndGroup<br />
MergeStyles<br />
MultiColumnDropDown<br />
Outline<br />
PrintPreview<br />
ProductTree<br />
RTFGrid<br />
Visual Basic-Beispiele · 71<br />
Passt automatisches Drag & Drop an. Dieses Beispiel verwendet die<br />
<strong>C1FlexGrid</strong>-Steuerung.<br />
Zieht Zeilen zwischen Tabellen. Dieses Beispiel verwendet die<br />
<strong>C1FlexGrid</strong>-Steuerung.<br />
Wendet Formatvorlagen auf Zellen, basierend auf Inhalten von<br />
anderen Zellen an. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-<br />
Steuerung.<br />
Bearbeitet Zellen mit Textfeldern, Listen, Masken und Kontrollfeldern.<br />
Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Erstellt eine Tabelle im transponierten Format. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Implementiert Outlook-ähnliche Gruppierungs- und Filterfunktionen<br />
unter Verwendung von FlexGrid. Dieses Beispiel verwendet die<br />
<strong>C1FlexGrid</strong>-Steuerung.<br />
Zeigt feste Zeilen am Ende der Tabelle. Dieses Beispiel verwendet die<br />
<strong>C1FlexGrid</strong>-Steuerung.<br />
Hängt ein FlexGrid an eine C1Chart-Steuerung an. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>- und die C1Chart-Steuerung.<br />
Bindet hierarchische Datenquellen an (master-detail-Style). Dieses<br />
Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Fügt Hyperlinks in Zellen der FlexGrid ein. Dieses Beispiel verwendet<br />
die <strong>C1FlexGrid</strong>-Steuerung.<br />
Zeigt Gruppierungs- und Sortierungsverhalten, wenn mit Daten<br />
verknüpfte Spalten verwendet werden. Dieses Beispiel verwendet die<br />
<strong>C1FlexGrid</strong>-Steuerung.<br />
Verbindet auf Zeilen, Spalten und Zellen angewendete CellStyles.<br />
Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Mehrspaltenauswahleditor für die Verwendung mit dem <strong>C1FlexGrid</strong>.<br />
Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Blendet wiederholte Daten in einer Gliederung aus. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Stellt Druckvorschau mit der C1PrintPreview-Steuerung auf drei<br />
Wegen zur Verfügung. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-,<br />
C1PrintDocument-, C1PrintPreview- und PreviewToolBarButton-<br />
Steuerung.<br />
Erstellt eine benutzerdefinierte Gliederung mit Produktinformationen.<br />
Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Zeigt *.RTF-Texte in Tabellenzellen an. Dieses Beispiel verwendet die<br />
<strong>C1FlexGrid</strong>-Steuerung.
72 · FlexGrid-Beispiele<br />
ScrollPosition<br />
SelectionMode<br />
Sorting<br />
Splits<br />
StartEditing<br />
Styles<br />
Subtotals<br />
Transpose<br />
TreeCheck<br />
TreeNode<br />
Tut_Analyze<br />
Tut_Edit<br />
Tut_XMLTree<br />
Validate<br />
C#-Beispiele<br />
Analyze<br />
AutoSizeEdit<br />
Zeigt wie die ScrollPosition-Eigenschaft funktioniert. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Zeigt die Auswirkungen der SelectionMode-Eigenschaft. Dieses<br />
Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Zeigt einige Sortierungstechniken. Dieses Beispiel verwendet die<br />
<strong>C1FlexGrid</strong>-Steuerung.<br />
Spaltet ein <strong>C1FlexGrid</strong> in mehrere Ansichten auf. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Implementiert eine Tabelle, die im Zellbearbeitungsmodus verweilt.<br />
Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Zeigt wie man Formatvorlagen verwendet, um das Aussehen der<br />
<strong>C1FlexGrid</strong> anzupassen. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-<br />
Steuerung.<br />
Erstellt Zwischensummen in mehreren Spalten. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Transponiert Daten in einer Tabelle. Dieses Beispiel verwendet die<br />
<strong>C1FlexGrid</strong>-Steuerung.<br />
Fügt Kontrollkästchen einem Gliederungsbaum hinzu. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Verwaltet einen Gliederungsbaum unter Verwendung von FlexGrid-<br />
Knotenobjekten. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Stellt dynamisches Sortieren und Gruppieren zur Verfügung. Dieses<br />
Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Bearbeitet Zellen mit Textfeldern, Listen, Masken und Kontrollfeldern.<br />
Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Füllt die Tabelle mit Daten aus einem XML-Dokument. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Verwendet die ErrorProvider-Steuerung zusammen mit FlexGrid.<br />
Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Stellt dynamisches Sortieren und Gruppieren zur Verfügung. Dieses<br />
Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Ändert die Größe des Editors, während der Nutzer schreibt. Dieses<br />
Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.
BarChart<br />
Benchmark<br />
BoundDelete<br />
BoundFinishEdit<br />
BoundImage<br />
BoundImageMap<br />
CellBorders<br />
CellDataType<br />
CellLabels<br />
Clipboard<br />
ColumnEditor<br />
ColumnOrder<br />
CustomData<br />
CustomDataMap<br />
CustomDataSource<br />
CustomEditor<br />
CustomMerge<br />
Erstellt Balkendiagramme mit Tabellenzellen. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Vergleicht die Stärke der Datenbindungen für FlexGrid und<br />
MSDataGrid. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>- und die<br />
C1TrueDBGrid-Steuerung.<br />
Löscht Zeilen aus einem gebundenen FlexGrid. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
C#-Beispiele · 73<br />
Übergibt Änderungen nach Bearbeitung an DataRow. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Knüpft die Tabelle an Grafikfelder, die als OLE-Objekte abgespeichert<br />
sind. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Verwendet die ImageMap-Eigenschaft mit einer datengebundenen<br />
Tabelle. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Verwendet OwnerDraw um benutzerdefinierte Zellrahmen<br />
bereitzustellen. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Ordnet Zelltypen (und Editoren) auf einer „pro Zelle“-Basis zu. Dieses<br />
Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Zeigt Quickinfos für Texte, die zu lang für ihre Zelle sind, an. Dieses<br />
Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Fügt die Unterstützung für Zwischenablagen der FlexGrid-Steuerung<br />
hinzu. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Zeigt den FlexGrid-Spalteneditor der Designtime in Ihrer Steuerung an.<br />
Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Positioniert Spalten dynamisch. Dieses Beispiel verwendet die<br />
<strong>C1FlexGrid</strong>-Steuerung.<br />
Implementiert ein benutzerdefiniertes Datenquellobjekt. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Legt die Auswahloptionen in Auswahlfeldern unter Verwendung von<br />
DataMaps fest. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Implementiert ein benutzerdefiniertes Datenquellobjekt und verknüpft<br />
diese mit der Tabelle. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-<br />
Steuerung.<br />
Implementiert Ihren eigenen Zelleditor. Dieses Beispiel verwendet die<br />
<strong>C1FlexGrid</strong>-Steuerung.<br />
Implementiert Ihre eigene Verbindungslogik um einen Bildschirm für<br />
einen TV-Führer zu erstellen. Dieses Beispiel ruft den<br />
C1.Win.<strong>C1FlexGrid</strong>-Namensbereich auf.
74 · FlexGrid-Beispiele<br />
CustomMerge2<br />
CustomMerge3<br />
CustomMerge4<br />
CustomPrint<br />
CustomSelection<br />
CustomSort<br />
DataIndex<br />
DataMap<br />
DataReader<br />
DataTable<br />
DataTableDictionary<br />
DataTree<br />
DBDynamicStyles<br />
DBImageField<br />
DBImages<br />
Implementiert Ihre eigene Verbindungslogik um verschiedene<br />
Verbindungsarten zu vermischen. Dieses Beispiel ruft den<br />
C1.Win.<strong>C1FlexGrid</strong>-Namensbereich auf.<br />
Zeigt, wie Gruppierung angepasst wird, indem man sich über die<br />
GetData-Methode hinwegsetzt. Dieses Beispiel ruft den<br />
C1.Win.<strong>C1FlexGrid</strong>-Namensbereich auf.<br />
Zeigt, wie Gruppierung angepasst wird, indem man sich über die<br />
GetData-Methode hinwegsetzt. Dieses Beispiel ruft den<br />
C1.Win.<strong>C1FlexGrid</strong>-Namensbereich auf.<br />
Verwendet die CreateImage-Methode um Tabellen mit willkürlichen<br />
Zeilen- und Spaltenumbrüchen zu drucken. Dieses Beispiel verwendet<br />
die <strong>C1FlexGrid</strong>-Steuerung.<br />
Verwendet OwnerDraw um benutzerdefinierte (nicht rechteckige)<br />
Auswahl zu implementieren. Dieses Beispiel ruft den<br />
C1.Win.<strong>C1FlexGrid</strong>-Namensbereich auf.<br />
Implementiert Ihre eigene Sortierungslogik mit einem<br />
benutzerdefinierten IComparer-Objekt. Dieses Beispiel verwendet die<br />
<strong>C1FlexGrid</strong>-Steuerung.<br />
Verwendet die Row.DataIndex-Eigenschaft um die zugrunde liegende<br />
Datenzeile zu ermitteln. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-<br />
Steuerung.<br />
Verwendet auf Daten zugeordnete Spalten, wenn diese an eine<br />
Datenquelle gebunden sind. Dieses Beispiel verwendet die<br />
<strong>C1FlexGrid</strong>-Steuerung.<br />
Füllt eine Tabelle aus einem DataReader aus. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Verknüpft zu DataTable, fügt Zeilen hinzu und löscht Zeilen. Dieses<br />
Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Zeigt, wie DataMaps aus DataTable-Objekten erstellt werden. Dieses<br />
Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Knüpft die Tabelle an eine hierarchische Datenquelle und zeigt Details<br />
in Untertabellen. Dieses Beispiel ruft den C1.Win.<strong>C1FlexGrid</strong>-<br />
Namensbereich auf.<br />
Wendet Formatvorlagen auf Zellen, basierend auf deren Inhalte an.<br />
Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Zeigt in einer DataTable abgespeicherte Bilder. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Knüpft die Tabelle an eine Datenbasis, in der Bilddateien als OLE-<br />
Objekte gespeichert sind. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-<br />
Steuerung.
DBSchemaChange<br />
DBTree<br />
DBUpdate<br />
DragDrop<br />
DragMerged<br />
DragRow<br />
DynamicStyles<br />
FilterRow<br />
FindRow<br />
FlexByRow<br />
FlexGroup<br />
FlexHierarchical<br />
FlexHierC1Data<br />
FreezeBottom<br />
GridChart<br />
HierData<br />
HostControls<br />
C#-Beispiele · 75<br />
Prüft die Tabellenreaktion auf Änderungen im Datenquellobjekt. Dieses<br />
Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Zeigt gebundene Daten in einer hierarchischen Gliederungsansicht an.<br />
Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Speichert Änderungen in einer zugrundeliegenden Datenbank. Dieses<br />
Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Passt automatisches Drag & Drop an. Dieses Beispiel verwendet die<br />
<strong>C1FlexGrid</strong>-Steuerung.<br />
Zieht gruppierte und verbundene Spalten. Dieses Beispiel verwendet<br />
die <strong>C1FlexGrid</strong>-Steuerung.<br />
Zieht Zeilen zwischen Tabellen. Dieses Beispiel verwendet die<br />
<strong>C1FlexGrid</strong>-Steuerung.<br />
Wendet Formatvorlagen auf Zellen, basierend auf Inhalten von<br />
anderen Zellen an. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-<br />
Steuerung.<br />
Implementiert eine FilterRow in einer FlexGrid-Steuerung. Dieses<br />
Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Findet Zeilen in einer zugrundeliegenden Datenquelle. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Erstellt eine Tabelle im transponierten Format. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Implementiert Outlook-ähnliche Gruppierungsfunktionen unter<br />
Verwendung von FlexGrid. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-<br />
Steuerung.<br />
Implementiert hierarchische Datenbindungen unter Verwendung von<br />
FlexGrid. Dieses Beispiel ruft den C1.Win.<strong>C1FlexGrid</strong>-Namensbereich<br />
auf.<br />
Implementiert hierarchische Datenbindungen unter Verwendung von<br />
FlexGrid und C1Data. Dieses Beispiel verwendet die C1DataSet- und<br />
C1SchemaDef-Steuerungen und ruft den C1.Win.<strong>C1FlexGrid</strong>-<br />
Namensbereich auf.<br />
Zeigt feste Zeilen am Ende der Tabelle. Dieses Beispiel verwendet die<br />
<strong>C1FlexGrid</strong>-Steuerung.<br />
Hängt ein FlexGrid an eine C1Chart-Steuerung an. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>- und die C1Chart-Steuerung.<br />
Bindet hierarchische Datenquellen an (master-detail-Style). Dieses<br />
Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Host-Steuerungen in Tabellenzellen. Dieses Beispiel verwendet die<br />
<strong>C1FlexGrid</strong>-Steuerung.
76 · FlexGrid-Beispiele<br />
Hyperlink<br />
MasterDetail<br />
MergeStyles<br />
MultiColumnDropDown<br />
NumericInput<br />
Outline<br />
PasswordChar<br />
PrintPreview<br />
RowStateDisplay<br />
RTFGrid<br />
ScrollPosition<br />
SelectionMode<br />
SetupEditor<br />
Sorting<br />
Splits<br />
StartEditing<br />
Subtotals<br />
Fügt Hyperlinks in Zellen der FlexGrid ein. Dieses Beispiel verwendet<br />
die <strong>C1FlexGrid</strong>-Steuerung.<br />
Zeigt wie master-detail DataSets im Quellcode erstellt und gebunden<br />
werden. Dieses Beispiel ruft den C1.Win.<strong>C1FlexGrid</strong>-Namensbereich<br />
auf.<br />
Verbindet auf Zeilen, Spalten und Zellen angewendete CellStyles.<br />
Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Mehrspaltenauswahleditor für die Verwendung mit dem <strong>C1FlexGrid</strong>.<br />
Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Implementiert Ihren eigenen Zelleditor für numerische Eingaben.<br />
Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Blendet wiederholte Daten in einer Gliederung aus. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Verwendet die <strong>C1FlexGrid</strong>, um Passwörter einzugeben und zu<br />
bearbeiten. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Stellt Druckvorschau mit der C1PrintPreview-Steuerung auf drei<br />
Wegen zur Verfügung. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-,<br />
C1PrintDocument-, C1PrintPreview- und PreviewToolBarButton-<br />
Steuerung.<br />
Verwendet verschiedene Formatvorlagen, um DataRows in<br />
verschiedenen Zuständen anzuzeigen. Dieses Beispiel verwendet die<br />
<strong>C1FlexGrid</strong>-Steuerung.<br />
Zeigt *.RTF-Texte in Tabellenzellen an. Dieses Beispiel verwendet die<br />
<strong>C1FlexGrid</strong>-Steuerung.<br />
Zeigt wie die ScrollPosition-Eigenschaft funktioniert. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Zeigt die Auswirkungen der SelectionMode-Eigenschaft. Dieses<br />
Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Verwendet das SetupEditor-Ereignis, um die Tabelleneditoren<br />
anzupassen. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Zeigt einige Sortierungstechniken. Dieses Beispiel verwendet die<br />
<strong>C1FlexGrid</strong>-Steuerung.<br />
Spaltet ein <strong>C1FlexGrid</strong> in mehrere Ansichten auf. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Implementiert eine Tabelle, die im Zellbearbeitungsmodus verweilt.<br />
Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Erstellt Zwischensummen in mehreren Spalten. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.
Transpose<br />
TreeCheck<br />
TreeNode<br />
TriStateBound<br />
<strong>ComponentOne</strong> FlexGrid für mobile Gerätebeispiele · 77<br />
Transponiert Daten in einer Tabelle. Dieses Beispiel verwendet die<br />
<strong>C1FlexGrid</strong>-Steuerung.<br />
Fügt Kontrollkästchen einem Gliederungsbaum hinzu. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Verwaltet einen Gliederungsbaum unter Verwendung von FlexGrid-<br />
Knotenobjekten. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Stellt 3-Zustands-Werte (graubar) in Boolean-Spalten zur Verfügung.<br />
Dieses Beispiel ruft den C1.Win.<strong>C1FlexGrid</strong>-Namensbereich auf.<br />
<strong>ComponentOne</strong> FlexGrid für mobile Gerätebeispiele<br />
Analyze<br />
BarChart<br />
EditData<br />
Stellt dynamisches Sortieren und Gruppieren zur Verfügung. Dieses Beispiel<br />
verwendet die <strong>C1FlexGrid</strong>-Steuerung.<br />
Erstellt Balkendiagramme mit Tabellenzellen. Dieses Beispiel verwendet die<br />
<strong>C1FlexGrid</strong>-Steuerung.<br />
Zeigt verschiedene Typen der integrierten Editoren und der dynamischen<br />
Formatierung. Dieses Beispiel verwendet die <strong>C1FlexGrid</strong>-Steuerung.
78 · FlexGrid-Übungen<br />
FlexGrid-Übungen<br />
Der folgende Abschnitt beinhaltet verschiedene Übungen zu einigen der wichtigsten Funktionen in der<br />
<strong>C1FlexGrid</strong>-Steuerung. Die Anweisungen werden Sie durch die Erstellung einfacher Projekte mit Schrittfür-Schritt-Beschreibungen<br />
begleiten. Die Software-CD enthält weitere, komplexere Beispiele, die Sie als<br />
Referenz verwenden können.<br />
Die folgenden Übungen sind in diesem Dokument enthalten:<br />
Bearbeiten Diese Übung beginnt mit der einfachen Dateneingabe und zeigt, wie<br />
Datenformatierungen, Kontrollkästchen, Auswahllistenfelder, Eingabemasken<br />
Datengültigkeit und die Zwischenablage angewendet werden.<br />
Gliederungen Hier wird gezeigt, wie man <strong>C1FlexGrid</strong> verwenden kann, um Gliederungen für<br />
strukturierte oder hierarchische Daten anzuzeigen.<br />
Daten<br />
analysieren<br />
Übung zur Bearbeitung<br />
Ausgehend von einer Tabelle mit Umsatzzahlen für verschiedene Produkte,<br />
Regionen und Vertriebsmitarbeitern, zeigt diese Anleitung, wie dynamische<br />
Ansichten (Spaltenreihenfolge), automatische Sortierung, Zellverbindungen,<br />
automatische Zwischensummen und Gliederungen implementiert werden können.<br />
Diese Übung beginnt mit einer einfachen Dateneingabe und fügt dann folgende Funktionen hinzu:<br />
1. Formatierung<br />
2. Kontrollkästchen<br />
3. Auswahllistenfelder<br />
4. Komplexe Datengültigkeit<br />
5. Zwischenablagenunterstützung<br />
6. Benutzerdefinierte Editoren<br />
So wird die endgültige Tabelle nach den Übungen aussehen:<br />
Schritt 1: Erstelle die <strong>C1FlexGrid</strong>-Steuerung
Übung zur Bearbeitung · 79<br />
Erstellen Sie ein neues Visual Basic-Projekt und fügen Sie eine <strong>C1FlexGrid</strong>-Steuerung dem Formular<br />
hinzu, indem Sie auf das <strong>C1FlexGrid</strong>-Symbol in der Symbolleiste klicken. Klicken Sie dann auf das<br />
Formular und ziehen Sie das Objekt in die richtige Größe.<br />
Wenn Sie die <strong>C1FlexGrid</strong>-Steuerung in der Symbolleiste nicht finden können, dann rechtsklicken Sie auf<br />
die Symbolleiste und wählen die Option Customize Toolbox (Anpassen…) aus. Suchen Sie die<br />
<strong>C1FlexGrid</strong>-Steuerung in der Liste der .NET-Komponenten und stellen Sie sicher, dass diese aktiviert ist.<br />
Wenn Sie die <strong>C1FlexGrid</strong> in der Komponentenliste nicht finden können, dann müssen Sie das Programm<br />
eventuell erneut installieren.<br />
Als nächstes legen Sie im .NET-Eigenschaftsfenster die folgenden Steuerungseigenschaften fest:<br />
(Name) = fg<br />
Dock = Fill<br />
Cols.Count = 5<br />
Cols.Fixed = 0<br />
Klicken Sie nun doppelt auf den Titelbereich des Formulars, um das Quellcodefenster zu öffnen. Fügen<br />
Sie folgende Anweisungen am oberen Ende der Datei ein:<br />
• Visual Basic<br />
• C#<br />
Imports C1.Win.<strong>C1FlexGrid</strong><br />
using C1.Win.<strong>C1FlexGrid</strong>;<br />
• Delphi<br />
uses C1.Win.<strong>C1FlexGrid</strong>;<br />
Damit werden die Objekte, die in der <strong>C1FlexGrid</strong>-Assembly definiert sind, im Projekt sichtbar und<br />
erspart somit viel Schreibarbeit.<br />
Folgender Quellcode erstellt die Tabelle, wenn das Formular geladen wird. Geben Sie diesen ein oder<br />
kopieren Sie ihn:<br />
• Visual Basic<br />
• C#<br />
Private Sub Form1_Load(ByVal sender As System.Object, _<br />
ByVal e As System.EventArgs) Handles MyBase.Load<br />
' set up columns<br />
Dim cols As String = "Product|Region|Salesperson|Sales|Bonus"<br />
Dim colNames As String() = cols.Split("|")<br />
Dim i%<br />
For i = 0 To fg.Cols.Count – 1<br />
fg(0, i) = colNames(i)<br />
fg.Cols(i).Name = colNames(i)<br />
Next<br />
End Sub<br />
private void Form1_Load( System.object sender, System.EventArgs e)<br />
{<br />
// set up columns<br />
string cols = "Product|Region|Salesperson|Sales|Bonus";<br />
string[]colNames = cols.Split("|");<br />
for (int i = 0; i < fg.Cols.Count; i++)<br />
{<br />
fg[0, i] = colNames[i];<br />
fg.Cols[i].Name = colNames[i];<br />
}
80 · FlexGrid-Übungen<br />
}<br />
• Delphi<br />
procedure Form1_Load(sender: System.Object;_<br />
e: System.EventArgs);<br />
var<br />
cols: string;<br />
colNames: array of string;<br />
I: Integer;<br />
begin<br />
// set up columns<br />
cols := 'Product|Region|Salesperson|Sales|Bonus';<br />
colNames := cols.Split('|');<br />
For i := 0 To fg.Cols.Count – 1 do<br />
begin<br />
fg[0, i] := colNames[i];<br />
fg.Cols[i].Name := colNames[i];<br />
end;<br />
end;<br />
Das ist alles. Drücken Sie nun F5 um das Projekt auszuführen und Daten in Ihre neue Steuerung<br />
einzutragen. Drücken Sie F2 oder die Leertaste um existierende Einträge zu bearbeiten oder<br />
überschreiben Sie diese einfach, indem Sie neue Einträge vornehmen.<br />
Schritt 2: Spaltentypen und Formate festlegen<br />
Wenn numerische oder andere Datenwerte angezeigt werden sollen, dann wollen Sie sicherlich ein<br />
konsistentes Format für die entsprechenden Werte anwenden. Mit der <strong>C1FlexGrid</strong>-Steuerung können Sie<br />
den DataType und das Format für jede Spalte festlegen.<br />
Um den DataType und das Format für eine Spalte festzulegen, fügen Sie den folgenden Quelltext in das<br />
Form_Load-Ereignis ein:<br />
• Visual Basic<br />
• C#<br />
Private Sub Form1_Load(ByVal sender As System.Object, _<br />
ByVal e As System.EventArgs) Handles MyBase.Load<br />
' set up columns<br />
Dim cols As String = "Product|Region|Salesperson|Sales|Bonus"<br />
Dim colNames As String() = cols.Split("|")<br />
Dim i%<br />
For i = 0 To fg.Cols.Count – 1<br />
fg(0, i) = colNames(i)<br />
fg.Cols(i).Name = colNames(i)<br />
Next<br />
' set column DataType and Format<br />
Dim c As Column = fg.Cols("Sales")<br />
c.DataType = GetType(Decimal)<br />
c.Format = "c" '
}<br />
• Delphi<br />
for (int i = 0; i
82 · FlexGrid-Übungen<br />
Wir nehmen einmal an, dass unser Beispielprojekt den Verkauf von drei Produkten (Applets, Widgets<br />
und Gadgets) in vier Regionen (North, South, East und West) mit drei Vollzeitvertriebsmitarbeitern<br />
(Mary, Sarah und Paula) umfasst.<br />
Um diese Listen als Auswahl in der <strong>C1FlexGrid</strong>-Steuerung zu verwenden, erstellen Sie eine Zeichenkette<br />
mit den jeweiligen Elementen der Liste (getrennt durch Senkrechtstriche) und ordnen diese der<br />
ComboList-Eigenschaft von der entsprechenden Spalte zu.<br />
Schreiben Sie den folgenden Quelltext in das Form_Load-Ereignis, um die Kombinationsliste<br />
hinzuzufügen:<br />
• Visual Basic<br />
• C#<br />
Private Sub Form1_Load(ByVal sender As System.Object, _<br />
ByVal e As System.EventArgs) Handles MyBase.Load<br />
' set up columns<br />
Dim cols As String = "Product|Region|Salesperson|Sales|Bonus"<br />
Dim colNames As String() = cols.Split("|")<br />
Dim i%<br />
For i = 0 To fg.Cols.Count – 1<br />
fg(0, i) = colNames(i)<br />
fg.Cols(i).Name = colNames(i)<br />
Next<br />
' set column DataType and Format<br />
Dim c As Column = fg.Cols("Sales")<br />
c.DataType = GetType(Decimal)<br />
c.Format = "c" '
}<br />
• Delphi<br />
procedure Form1_Load(sender: System.Object;<br />
e: System.EventArgs);<br />
var<br />
cols: string;<br />
colNames: array of string;<br />
I: Integer;<br />
begin<br />
// set up columns<br />
cols := 'Product|Region|Salesperson|Sales|Bonus';<br />
colNames := cols.Split('|');<br />
for i := 0 to fg.Cols.Count – 1 do<br />
begin<br />
fg[0, i] := colNames[i];<br />
fg.Cols[i].Name := colNames[I];<br />
Next<br />
// set column DataType and Format<br />
c := fg.Cols['Sales'];<br />
c.DataType := typeof(Decimal);<br />
c.Format := 'c' //
84 · FlexGrid-Übungen<br />
• C#<br />
' collect the data we need<br />
Select Case e.Col<br />
Case 0<br />
prd = fg.Editor.Text<br />
rgn = fg(e.Row, "Region")<br />
Case 1<br />
prd = fg(e.Row, "Product")<br />
rgn = fg.Editor.Text<br />
End Select<br />
' we can't sell Applets in the North Region...<br />
If prd = "Applets" And rgn = "North" Then<br />
MsgBox("Warning: Regulation #12333AS/SDA-23 forbids " & _<br />
"the sale of " & prd & " in region " & rgn & ". " & _<br />
"Please verify input.")<br />
e.Cancel = True<br />
End If<br />
End Sub<br />
private void fg_ValidateEdit( object sender, ValidateEditEventArgs e)<br />
{<br />
string rgn = string.Empty;<br />
string prd = string.Empty;<br />
+<br />
}<br />
// collect the data we need<br />
switch (e.Col)<br />
{<br />
case 0:<br />
prd = fg.Editor.Text;<br />
rgn = (string)fg[e.Row, "Region"];<br />
break;<br />
case 1:<br />
prd = (string)fg[e.Row, "Product"];<br />
rgn = fg.Editor.Text;<br />
break;<br />
}<br />
// we can't sell Applets in the North Region...<br />
if ( prd == "Applets" && rgn == "North") {<br />
MessageBox.Show("Warning: Regulation #12333AS/SDA-23 forbids "<br />
}<br />
• Delphi<br />
"the sale of " + prd + " in region " + rgn + ". " +<br />
"Please verify input.");<br />
e.Cancel = true;<br />
procedure fg_ValidateEdit(sender: System.Object;<br />
e: ValidateEditEventArgs);<br />
var<br />
rgn: string;<br />
prd: string;<br />
begin<br />
// collect the data we need<br />
case e.Col of<br />
0:<br />
begin<br />
prd := fg.Editor.Text;<br />
rgn := fg[e.Row, 'Region'];<br />
end;
1:<br />
begin<br />
prd := fg[e.Row, 'Product'];<br />
rgn := fg.Editor.Text;<br />
end;<br />
end;<br />
Übung zur Bearbeitung · 85<br />
// we can't sell Applets in the North Region...<br />
If (prd = 'Applets') And (rgn = 'North') Then<br />
begin<br />
MsgBox('Warning: Regulation #12333AS/SDA-23 forbids ' + _<br />
'the sale of ' + prd + ' in region ' + rgn + ". " + _<br />
'Please verify input.');<br />
e.Cancel := True;<br />
end;<br />
end;<br />
Die Funktion beginnt mit dem Auslesen der Daten, die sie für die Gültigkeitsprüfung benötigt. Die zu<br />
prüfenden Werte werden mit Hilfe der Editor.Text-Eigenschaft ausgelesen, da die eingegebenen Werte<br />
noch nicht in der Tabelle abgespeichert wurden. Wenn der Test nicht bestanden wird, dann zeigt die<br />
Funktion eine Warnung an und stellt den Cancel-Parameter auf TRUE, so dass die Bearbeitung<br />
abgebrochen und die Zelle zurück in den edit-Modus versetzt wird. Der Nutzer kann nun die Eingabe<br />
erneut versuchen.<br />
Drücken Sie F5 um das Projekt zu starten und versuchen Sie, fehlerhafte Werte einzugeben. Sie werden<br />
sehen, dass die Tabellensteuerung dies nicht akzeptiert.<br />
Schritt 5: Unterstützung der Zwischenablage<br />
Die Zwischenablage von Windows ist eine sehr nützliche Funktion, um Informationen zwischen<br />
Anwendungen auszutauschen.<br />
Es ist recht einfach, die Zwischenablagenunterstützung in FlexGrid-Projekten zu integrieren. Stellen Sie<br />
nur die AutoClipboard-Eigenschaft auf TRUE und die Tabellensteuerung wird automatisch die<br />
Standardbefehle und Tastenkombinationen der Zwischenablage hinzufügen: ctrl-X oder shift-Entfernen<br />
um auszuschneiden, ctrl-C oder ctrl-Einfügen um zukopieren und ctrl-V oder shift-Einfügen um<br />
einzufügen.<br />
Eine weitere großartige Windowsfunktion, die mit der Zwischenablage eng zusammenarbeitet, ist das<br />
OLE-Drag & Drop (Ziehen-und-fallen-lassen). <strong>C1FlexGrid</strong> besitzt zwei Eigenschaften, DragMode und<br />
DropMode, die diese Funktion implementieren. Wenn Sie beide Eigenschaften auf Ihre automatische<br />
Einstellung setzen, dann können Sie eine Auswahl mit deren Ecken ziehen und diese in anderen<br />
Anwendungen, wie z.B. Microsoft Excel, fallen lassen. Sie können natürlich auch eine Auswahl von<br />
Excel-Tabellen in die <strong>C1FlexGrid</strong>-Steuerung ziehen.<br />
Drücken Sie F5 um das Projekt zu starten und versuchen Sie Zellen zu kopieren und wieder einzufügen.<br />
Beachten Sie, dass Sie auch ungültige Daten einfügen können, da der Quelltext des Befehls Einfügen<br />
keine Gültigkeitsprüfung vornimmt. Dies bleibt als Übung dem Leser erhalten.<br />
Schritt 6: Benutzerdefinierte Editoren<br />
Das <strong>C1FlexGrid</strong> besitzt sehr starke, integrierte Editors für die reine Texteingabe, Texteingabe mit<br />
Masken, Auswahl durch Listen, Kontrollkästchen und weitere. Eventuell wollen Sie aber statt der<br />
integrierten Editoren Ihre eigenen verwenden - vielleicht eine Eingabesteuerung aus der C1Input-<br />
Bibliothek oder eine Steuerung, die Sie selbst geschrieben haben. Ab Version 2.5 können Sie mit FlexGrid<br />
ganz einfach eigene Editoren verwenden. Um einen benutzerdefinierten Editor der „Sales“-Spalte in<br />
unserem Beispiel zuzuordnen, müssen Sie zunächst eine NumericUpDown-Steuerung dem Formular<br />
hinzufügen. Verwenden Sie nun das .NET-Eigenschaftsfenster um die neue Steuerung mit den folgenden<br />
Einstellungen zu konfigurieren:
86 · FlexGrid-Übungen<br />
BorderStyle = None<br />
Visible = False<br />
DecimalPlaces = 2<br />
ThousandsSeparator = True<br />
Maximum = 5000000<br />
Rechtsklicken Sie anschließend die Tabelle und wählen Sie „Edit Columns…“ aus, um den Spalteneditor<br />
der Tabelle aufzurufen.<br />
Wählen Sie die dritte Spalte aus (in der Umsatzzahlen stehen werden) und stellen Sie die Editor-<br />
Eigenschaft auf numericUpDown1, wie nachfolgend in der Grafik gezeigt:<br />
Starten Sie nun das Projekt und versuchen Sie, einige Werte in der „Sales“-Spalte zu ändern. Die Tabelle<br />
verwendet nun die NumericUpDown-Steuerung anstatt der integrierten Editoren. Die Steuerung ist<br />
richtig positioniert, initialisiert und verwaltet. Wenn Sie den Cursor auf eine andere Zelle bewegen, dann<br />
wird der entsprechende Wert in der Tabelle gespeichert.<br />
Dennoch verhält sich der benutzerdefinierte Editor nicht exakt genauso wie die integrierten. Z.B.:<br />
1. Wenn Sie die Bearbeitung mit dem eintippen einer Zahl beginnen, wird der ursprüngliche Wert<br />
der Zelle nicht sofort gelöscht.<br />
2. Die Größe des Editors ist nicht richtig. Er ist ein wenig zu klein.<br />
3. Es ertönt ein störender Beep, wenn Sie Enter drücken, um die Eingabe zu bestätigen.<br />
Sie können diese Probleme auf mehreren Wegen umgehen. Zum Beispiel könnten Sie die Ereignisse des<br />
Editors verwenden, wobei es dann aber schwierig wird, diese Steuerung in anderen Projekten wieder zu<br />
verwenden. Oder Sie könnten eine abgeleitete Klasse erstellen und einige Methoden in der<br />
IC1EmbeddedEditor-Schnittstelle implementieren.<br />
Zum Beispiel, der nachfolgende Quellcode implementiert drei Methoden:
Übung zur Bearbeitung · 87<br />
C1EditorInitialize wird aufgerufen um den Editor zu initialisieren. Es setzt den ursprünglichen Wert<br />
und wählt dann den gesamten Eintrag aus. Dies löst das erste Problem. Weil der gesamte Eintrag<br />
ausgewählt ist, wird das Eintippen des ersten Zeichens den ursprünglichen Inhalt der Zelle ersetzen.<br />
C1EditorUpdateBounds wird aufgerufen, um den Editor genau über der zu bearbeitenden Zelle zu<br />
platzieren. Die Höhe der NumericUpDown-Steuerung wird automatisch an die Schriftgroße angepasst,<br />
so dass diese für die Zelle zu kurz erscheint. Daher stellt der Quellcode die FontHeight-Eigenschaft des<br />
Editors so ein, dass dieser exakt über der Zelle platziert wird.<br />
Schlussendlich überschreibt der Quellcode die ProcessDialogKey-Methode um die störenden Beeps zu<br />
unterdrücken, wenn der Nutzer die Enter-Taste drückt.<br />
• Visual Basic<br />
• C#<br />
Public Class MyUpDown<br />
Inherits NumericUpDown<br />
' set initial value<br />
Public Sub C1EditorInitialize(ByVal value As Object, _<br />
ByVal editorAttributes As IDictionary)<br />
value = Convert.ChangeType(value, GetType(Decimal))<br />
MyBase.Select(0, Int32.MaxValue)<br />
End Sub<br />
' set FontHeight so the control honors the rectangle height<br />
Public Sub C1EditorUpdateBounds(ByVal rc As Rectangle)<br />
MyBase.FontHeight = rc.Height<br />
Bounds = rc<br />
End Sub<br />
' suppress annoying beeps when user hits enter<br />
Protected Overrides Function ProcessDialogKey(ByVal keyData As<br />
Keys) As Boolean<br />
If (keyData = Keys.Enter) Then<br />
Parent.Focus()<br />
If (Parent.Focused) Then SendKeys.Send("{Down}")<br />
Return True<br />
End If<br />
Return MyBase.ProcessDialogKey(keyData)<br />
End Function<br />
End Class<br />
internal class MyUpDown : NumericUpDown<br />
{<br />
// set initial value<br />
public void C1EditorInitialize(object value, IDictionary<br />
editorAttributes)<br />
{<br />
// apply initial value<br />
Value = (decimal)Convert.ChangeType(value, typeof(decimal));<br />
}<br />
// select the whole entry<br />
Select(0, int.MaxValue);<br />
// set FontHeight so the control honors the rectangle height<br />
public void C1EditorUpdateBounds(Rectangle rc)<br />
{<br />
base.FontHeight = rc.Height;<br />
Bounds = rc;<br />
}
88 · FlexGrid-Übungen<br />
}<br />
• Delphi<br />
// suppress annoying beeps when user hits enter<br />
override protected bool ProcessDialogKey(Keys keyData)<br />
{<br />
if (keyData == Keys.Enter)<br />
{<br />
Parent.Focus();<br />
if (Parent.Focused) SendKeys.Send("{Down}");<br />
return true;<br />
}<br />
return base.ProcessDialogKey(keyData);<br />
}<br />
type TMyUpDown = class(NumericUpDown)<br />
public<br />
procedure C1EditorInitialize(value: System.Object; editorAttributes:<br />
IDictionary);<br />
procedure C1EditorUpdateBounds(rc: Rectangle);<br />
function ProcessDialogKey(keyData: Keys): boolean;<br />
end;<br />
procedure TMyUpDown.C1EditorInitialize(value: System.Object;<br />
editorAttributes: IDictionary);<br />
begin<br />
// apply initial value<br />
value := Currency(Convert.ChangeType(value, TypeOf(Currency)));<br />
// select the whole entry<br />
Select(0, System.Int32.MaxValue);<br />
end;<br />
procedure TMyUpDown.C1EditorUpdateBounds(rc: Rectangle);<br />
begin<br />
inherited FontHeight := rc.Height;<br />
Bounds := rc;<br />
end;<br />
function TMyUpDown.ProcessDialogKey(keyData: Keys): boolean;<br />
begin<br />
if (keyData = Keys.Enter) then<br />
begin<br />
Parent.Focus;<br />
if (Parent.Focused) then<br />
SendKeys.Send(‘{Down}’);<br />
Result := true;<br />
Exit;<br />
end;<br />
Result := inherited ProcessDialogKey(keyData);<br />
end;<br />
Übung zur Gliederung<br />
Dieses Beispiel zeigt, wie Sie <strong>C1FlexGrid</strong> als Gliederung für die Anzeige von strukturierten oder<br />
hierarchischen Daten verwenden können. Die <strong>C1FlexGrid</strong>-Steuerung verhält sich wie eine<br />
Baumsteuerung, wenn Sie als Gliederer verwendet wird, und zeigt Knoten, die erweitert oder gruppiert<br />
werden können, um Teile mit untergeordneten Daten ein- oder auszublenden.<br />
Mit dem folgendem Beispiel können Sie ein XML-Dokument in die Tabelle laden, wo diese als<br />
Gliederungsbaum angezeigt wird. So wird die fertige Anwendung aussehen:
Schritt 1: Die Steuerung erstellen<br />
Starten Sie ein neues Visual Basic-Projekt und fügen Sie zwei Steuerungen hinzu:<br />
1. Eine Befehlsschaltfläche im oberen Teil des Formulars, und<br />
2. Eine <strong>C1FlexGrid</strong>-Steuerung unterhalb der Schaltfläche.<br />
Übung zur Gliederung · 89<br />
Wenn Sie die <strong>C1FlexGrid</strong>-Steuerung in der Symbolleiste nicht finden können, dann rechtsklicken Sie auf<br />
die Symbolleiste und wählen die Option Customize Toolbox (Anpassen…) aus. Suchen Sie die<br />
<strong>C1FlexGrid</strong>-Steuerung in der Liste der .NET-Komponenten und stellen Sie sicher, dass diese aktiviert ist.<br />
Wenn Sie die <strong>C1FlexGrid</strong> in der Komponentenliste nicht finden können, dann müssen Sie das Programm<br />
eventuell erneut installieren.<br />
Verwenden Sie nun das .NET-Eigenschaftsfenster um die folgenden Einstellungen vorzunehmen:<br />
1. Command button<br />
Text = "Open XML File…"<br />
Dock = Top<br />
2. <strong>C1FlexGrid</strong><br />
(Name) = fg<br />
Dock = Fill<br />
Doppelklicken Sie nun auf den Titelbereich des Formulars, um das Quellcodefenster zu öffnen. Fügen Sie<br />
folgende Anweisungen am oberen Ende der Datei ein:<br />
• Visual Basic<br />
• C#<br />
Imports C1.Win.<strong>C1FlexGrid</strong><br />
using C1.Win.<strong>C1FlexGrid</strong>;<br />
• Delphi<br />
uses C1.Win.<strong>C1FlexGrid</strong>;
90 · FlexGrid-Übungen<br />
Damit werden die Objekte, die in der <strong>C1FlexGrid</strong>-Assembly definiert sind, im Projekt sichtbar und<br />
ersparen somit viel Schreibarbeit.<br />
Als nächsten geben Sie den folgenden Quellcode, der die Tabelle erstellt, wenn das Formular geladen<br />
wird, ein oder kopieren Sie ihn:<br />
• Visual Basic<br />
• C#<br />
Private Sub Form1_Load(ByVal sender As System.Object, _<br />
ByVal e As System.EventArgs) Handles MyBase.Load<br />
End Sub<br />
' initialize grid<br />
fg.Rows.Count = 1<br />
fg.Cols.Count = 2<br />
fg.Cols.Fixed = 0<br />
fg.ExtendLastCol = True<br />
fg(0, 0) = "Element"<br />
fg(0, 1) = "Text"<br />
' initialize outline tree<br />
fg.Tree.Column = 0<br />
fg.Tree.Style = TreeStyleFlags.SimpleLeaf<br />
fg.Cols(0).AllowEditing = False<br />
' initialize styles<br />
fg.Styles.Normal.Border.Style = BorderStyleEnum.None<br />
fg.Styles.Normal.TextAlign = TextAlignEnum.LeftCenter<br />
fg.Styles.Normal.WordWrap = False<br />
Dim cs As CellStyle = fg.Styles.Add("Data")<br />
cs.BackColor = SystemColors.Control<br />
private void Form1_Load( System.object sender, System.EventArgs e)<br />
{<br />
// initialize grid<br />
fg.Rows.Count = 1;<br />
fg.Cols.Count = 2;<br />
fg.Cols.Fixed = 0;<br />
fg.ExtendLastCol = true;<br />
fg[0, 0] = "Element";<br />
fg[0, 1] = "Text";<br />
}<br />
• Delphi<br />
// initialize outline tree<br />
fg.Tree.Column = 0;<br />
fg.Tree.Style = TreeStyleFlags.SimpleLeaf;<br />
fg.Cols[0].AllowEditing = false;<br />
// initialize styles<br />
fg.Styles.Normal.Border.Style = BorderStyleEnum.None;<br />
fg.Styles.Normal.TextAlign = TextAlignEnum.LeftCenter;<br />
fg.Styles.Normal.WordWrap = false;<br />
CellStyle cs = fg.Styles.Add("Data");<br />
cs.BackColor = SystemColors.Control;<br />
procedure Form1_Load(sender: System.Object;<br />
e: System.EventArgs);<br />
var<br />
cs: CellStyle;
egin<br />
// initialize grid<br />
fg.Rows.Count := 1;<br />
fg.Cols.Count := 2;<br />
fg.Cols.Fixed := 0;<br />
fg.ExtendLastCol := True;<br />
fg[0, 0] := 'Element';<br />
fg[0, 1] := 'Text';<br />
// initialize outline tree<br />
fg.Tree.Column := 0;<br />
fg.Tree.Style := TreeStyleFlags.SimpleLeaf;<br />
fg.Cols[0].AllowEditing := False;<br />
// initialize styles<br />
fg.Styles.Normal.Border.Style := BorderStyleEnum.None;<br />
fg.Styles.Normal.TextAlign := TextAlignEnum.LeftCenter;<br />
fg.Styles.Normal.WordWrap := False;<br />
cs := fg.Styles.Add('Data');<br />
cs.BackColor := SystemColors.Control;<br />
End;<br />
Der Quellcode erstellt zunächst die Tabelle und fügt die Spaltenüberschriften ein.<br />
Übung zur Gliederung · 91<br />
Danach wird der Gliederungsbaum mit der Tree-Eigenschaft initialisiert und es wird die Bearbeitung der<br />
XML-Knoten verhindert, indem die AllowEditing-Eigenschaft der ersten Spalte auf FALSE gestellt wird.<br />
Beachten Sie, dass der Nutzer immer noch die zweite Spalte mit den Daten eines jeden XML-Knotens<br />
bearbeiten kann.<br />
Nun ist die Steuerung fertig und wir können etwas Quellcode hinzufügen.<br />
Schritt 2: Die Daten lesen und die Gliederung erstellen<br />
Klicken Sie doppelt auf die Befehlsschaltfläche und fügen Sie folgenden Quellcode in das Button1_Click-<br />
Ereignis ein:<br />
• Visual Basic<br />
Private Sub Button1_Click(ByVal sender As System.Object, _<br />
ByVal e As System.EventArgs) Handles Button1.Click<br />
' get file name<br />
Dim fo As OpenFileDialog = New OpenFileDialog()<br />
fo.DefaultExt = "xml"<br />
fo.Filter = "XML Files (*.xml)|*.xml"<br />
If fo.ShowDialog() DialogResult.OK Then Exit Sub<br />
' load XML file<br />
Dim xdoc As Xml.XmlDocument = New Xml.XmlDocument()<br />
xdoc.Load(fo.FileName)<br />
' stop redrawing to improve speed<br />
fg.Redraw = False<br />
' populate grid<br />
fg.Rows.Count = 1<br />
GetXMLData(xdoc.ChildNodes(1), 0)<br />
' autosize tree column<br />
fg.AutoSizeCol(0)<br />
' show levels 0,1,2<br />
fg.Tree.Show(2)
92 · FlexGrid-Übungen<br />
• C#<br />
' ready to redraw<br />
fg.Redraw = True<br />
End Sub<br />
private void Button1_Click( System.object sender, System.EventArgs e)<br />
{<br />
// get file name<br />
OpenFileDialog fo = new OpenFileDialog();<br />
fo.DefaultExt = "xml";<br />
fo.Filter = "XML Files (*.xml)|*.xml";<br />
if ( fo.ShowDialog() != DialogResult.OK) return<br />
}<br />
• Delphi<br />
// load XML file<br />
Xml.XmlDocument xdoc = new Xml.XmlDocument();<br />
xdoc.Load(fo.FileName);<br />
// stop redrawing to improve speed<br />
fg.Redraw = false;<br />
// populate grid<br />
fg.Rows.Count = 1;<br />
GetXMLData(xdoc.ChildNodes[1], 0)<br />
// autosize tree column<br />
fg.AutoSizeCol(0);<br />
// show levels 0,1,2<br />
fg.Tree.Show(2);<br />
// ready to redraw<br />
fg.Redraw = true;<br />
procedure Button1_Click(sender: System.Object;<br />
e: System.EventArgs);<br />
var<br />
fo: OpenFileDialog;<br />
xdoc: Xml.XmlDocument;<br />
begin<br />
// get file name<br />
fo := OpenFileDialog.Create;<br />
fo.DefaultExt := 'xml';<br />
fo.Filter := 'XML Files (*.xml)|*.xml';<br />
If fo.ShowDialog System.Windows.Forms.DialogResult.OK Then<br />
exit;<br />
// load XML file<br />
xdoc := Xml.XmlDocument.Create;<br />
xdoc.Load(fo.FileName);<br />
// stop redrawing to improve speed<br />
fg.Redraw := False;<br />
// populate grid<br />
fg.Rows.Count := 1;<br />
GetXMLData(xdoc.ChildNodes[1], 0);<br />
// autosize tree column<br />
fg.AutoSizeCol(0);
show levels 0,1,2<br />
fg.Tree.Show(2);<br />
// ready to redraw<br />
fg.Redraw := True;<br />
end;<br />
Übung zur Gliederung · 93<br />
Die Routine zeigt zunächst ein OpenFileDialog („Datei öffnen“-Fenster) mit dem der Nutzer eine XML-<br />
Datei in die Tabelle laden kann. Wenn die Datei ausgewählt ist, dann lädt die Routine diese in ein<br />
XmlDocument-Objekt, welches den Inhalt der Datei an den Speicher übergibt.<br />
Die Routine stellt dann die Tabelleneigenschaft Redraw auf FALSE, um die aktualisierende Anzeige<br />
auszuschalten, während die Tabelle gefüllt wird. Diese Technik verbessert erheblich die Geschwindigkeit<br />
und Sie sollten diese immer verwenden, wenn Sie erhebliche Datenmengen dem <strong>C1FlexGrid</strong> hinzufügen.<br />
Als nächstes löscht die Routine alle Daten, indem sie die Einstellung Rows.Count = 1 vornimmt, und ruft<br />
anschließend die GetXMLData-Routine auf, um die Steuerung mit den Inhalten des Xml-Dokuments zu<br />
füllen. Die GetXMLData-Routine ist die wichtigste in diesem Beispiel und wird nachfolgend aufgeführt.<br />
Nachdem die Tabelle gefüllt wurde, verwendet die Routine die AutoSize-Methode, um die Breite der<br />
ersten Spalte aufgrund ihres Inhaltes festzulegen, und die Tree.Show-Methode, um die Gliederung<br />
aufzublättern und die Ebenen 0, 1 und 2 anzuzeigen. Dann wird die Redraw-Eigenschaft wieder auf<br />
TRUE gestellt, so dass die Tabelle wieder normal und aktualisiert angezeigt wird.<br />
Die GetXMLData-Routine ist die interessanteste in diesem Beispiel. Sie übersetzt das XMLDocument-<br />
Objekt und erstellt den Gliederungsbaum. Dies ist der entsprechende Quellcode:<br />
• Visual Basic<br />
Private Sub GetXMLData(ByVal node As Xml.XmlNode, ByVal level As<br />
Integer)<br />
' skip comment nodes<br />
If node.NodeType = Xml.XmlNodeType.Comment Then<br />
Exit Sub<br />
End If<br />
' add new row for this node<br />
Dim row As Integer = fg.Rows.Count<br />
fg.Rows.Add()<br />
' add data to new row<br />
fg(row, 0) = node.Name<br />
If node.ChildNodes.Count = 1 Then<br />
fg(row, 1) = node.InnerText<br />
fg.SetCellStyle(row, 1, fg.Styles("Data"))<br />
End If<br />
' if the node has a "Name" subnode, save it to use as a tooltip<br />
If node.ChildNodes.Count > 0 Then<br />
Dim ndName As Xml.XmlNode = node.SelectSingleNode("Name")<br />
If Not (ndName Is Nothing) Then<br />
fg.Rows(row).UserData = ndName.InnerText<br />
End If<br />
End If<br />
' if this node has children, get them as well<br />
If node.ChildNodes.Count > 1 Then<br />
' make this row a node<br />
fg.Rows(row).IsNode = True<br />
fg.Rows(row).Node.Level = level<br />
' recurse to get children
94 · FlexGrid-Übungen<br />
• C#<br />
Dim child As Xml.XmlNode<br />
For Each child In node.ChildNodes<br />
GetXMLData(child, level + 1)<br />
Next<br />
End If<br />
End Sub<br />
private void GetXMLData( Xml.XmlNode node, int level)<br />
{<br />
// skip comment nodes<br />
if ( node.NodeType == Xml.XmlNodeType.Comment)<br />
return;<br />
}<br />
}<br />
// add new row for this node<br />
int row = fg.Rows.Count;<br />
fg.Rows.Add();<br />
// add data to new row<br />
fg(row, 0) = node.Name;<br />
if ( node.ChildNodes.Count = 1) {<br />
fg(row, 1) = node.InnerText;<br />
fg.SetCellStyle(row, 1, fg.Styles["Data"]);<br />
}<br />
// if the node has a "Name" subnode, save it to use as a tooltip<br />
if (node.ChildNodes.Count > 0) {<br />
Xml.XmlNode ndName = node.SelectSingleNode("Name");<br />
if (ndName != null) {<br />
fg.Rows[row].UserData = ndName.InnerText;<br />
}<br />
}<br />
// if this node has children, get them as well<br />
if ( node.ChildNodes.Count > 1) {<br />
}<br />
• Delphi<br />
// make this row a node<br />
fg.Rows[row].IsNode = true;<br />
fg.Rows[row].Node.Level = level;<br />
// recurse to get children<br />
Xml.XmlNode child;<br />
foreach ( child In node.ChildNodes)<br />
GetXMLData(child, level + 1)<br />
procedure GetXMLData(node: Xml.XmlNode; level: Integer);<br />
var<br />
r: Integer;<br />
ndName: Xml.XmlNode;<br />
child: Xml.XmlNode;<br />
begin<br />
// skip comment nodes<br />
if node.NodeType = Xml.XmlNodeType.Comment then<br />
exit;<br />
// add new row for this node<br />
r := fg.Rows.Count;<br />
fg.Rows.Add;
add data to new row<br />
fg[row, 0] := node.Name;<br />
if node.ChildNodes.Count = 1 then<br />
begin<br />
fg[row, 1] := node.InnerText;<br />
fg.SetCellStyle(row, 1, fg.Styles['Data']);<br />
end;<br />
Übung zur Gliederung · 95<br />
// if the node has a "Name" subnode, save it to use as a tooltip<br />
if node.ChildNodes.Count > 0 then<br />
begin<br />
ndName := node.SelectSingleNode('Name');<br />
if ndName nil then<br />
begin<br />
fg.Rows[row].UserData := ndName.InnerText;<br />
end;<br />
end;<br />
// if this node has children, get them as well<br />
if node.ChildNodes.Count > 1 then<br />
begin<br />
// make this row a node<br />
fg.Rows[row].IsNode := True;<br />
fg.Rows[row].Node.Level := level;<br />
// recurse to get children<br />
for I := 0 to node.ChildNodes.Count – 1 do<br />
GetXMLData(node.ChildNodes[I], level + 1);<br />
end;<br />
end;<br />
Die Routine beginnt damit, die XML-Kommentarknoten auszulassen und verwendet anschließend die<br />
Rows.Add-Methode um eine neue Zeile der Tabelle hinzuzufügen.<br />
Danach wird der Name des Knotens festgelegt und überprüft, ob dieser genau einen Unterknoten besitzt.<br />
In diesem Falle wird der Knoten als ein Datenknoten interpretiert und die Knoteneigenschaft InnerText<br />
wird in die zweite Spalte der neuen Zeile kopiert. Der Quelltext legt außerdem das Format der Zellen, die<br />
Daten besitzen, auf den „Data“-Style fest, der beim Laden des Formulars erstellt wurde.<br />
Der nächste Quellcodeabschnitt überprüft, ob dieser Knoten einen Unterknoten mit dem Namen „Name“<br />
besitzt. Wenn dies der Fall ist, dann wird der Inhalt des „Name“-Knotens der UserData-Eigenschaft der<br />
neuen Zeile zugeordnet. Dieser Wert wird später für die Implementierung von Quickinfos verwendet, so<br />
dass die Nutzer den Knotennamen, obwohl dieser zusammengeklappt ist, sehen können.<br />
Zuletzt ruft sich die GetXMLData-Routine selbst auf, um auch die Unterknoten der Tabelle<br />
hinzuzufügen, wenn der Knoten weitere Unterknoten besitzt.<br />
Wenn Sie das Projekt nun starten, werden Sie sehen, dass dieses bereits XML-Dateien laden und anzeigen<br />
und der Nutzer die Knoten auf und zuklappen kann, indem er auf diese klickt. Der nächste Schritt fügt<br />
ein paar Verbesserungen hinzu, damit die Anwendung einfacher wird.<br />
Schritt 3: benutzerdefinierte Maus- und Tastatursteuerung<br />
Das <strong>C1FlexGrid</strong> stellt zwar das Erweitern und Zusammenklappen der Knoten zur Verfügung, Sie<br />
können aber dennoch dessen Verhalten erweitern und anpassen. Jedes Mal wenn ein Teil der Gliederung<br />
aus- oder eingeklappt wird, startet die Steuerung die Ereignisse BeforeCollapse und AfterCollapse, die<br />
Sie für diverse Aktionen verwenden können. Des Weiteren können Sie die Node.Collapsed-Eigenschaft<br />
verwenden, um den Zustand eines Gliederungsteils im Quellcode abzufragen oder festzulegen.
96 · FlexGrid-Übungen<br />
In diesem Beispiel fangen wir die DoubleClick- und KeyPress-Ereignisse ab, um die Knoten aus- und<br />
einzuklappen, wenn der Nutzer doppelklickt, oder die Enter-Taste drückt. Dies ist der Quellcode:<br />
• Visual Basic<br />
• C#<br />
Private Sub fg_DoubleClick(ByVal sender As Object, _<br />
ByVal e As EventArgs) Handles fg.DoubleClick<br />
If fg.MouseCol = 0 Then<br />
ToggleNodeState()<br />
End If<br />
End Sub<br />
Private Sub fg_KeyPress(ByVal sender As Object, _<br />
ByVal e As KeyPressEventArgs) Handles fg.KeyPress<br />
If e.KeyChar = vbCr Then<br />
ToggleNodeState()<br />
End If<br />
End Sub<br />
Private Sub ToggleNodeState()<br />
' if the current row is not a node, no work<br />
Dim r As Row = fg.Rows(fg.Row)<br />
If Not r.IsNode Then Exit Sub<br />
' toggle collapsed state<br />
r.Node.Collapsed = Not r.Node.Collapsed<br />
End Sub<br />
private void fg_DoubleClick( object sender, EventArgs e)<br />
fg.DoubleClick {<br />
if ( fg.MouseCol == 0) {<br />
ToggleNodeState();<br />
}<br />
}<br />
private void fg_KeyPress( object sender, KeyPressEventArgs e)<br />
fg.KeyPress {<br />
if ( e.KeyChar == 13) {<br />
ToggleNodeState();<br />
}<br />
}<br />
private void ToggleNodeState() {<br />
}<br />
• Delphi<br />
// if the current row is not a node, no work<br />
Row r = fg.Rows[fg.Row];<br />
if (! r.IsNode) return;<br />
// toggle collapsed state<br />
r.Node.Collapsed = !r.Node.Collapsed;<br />
procedure fg_DoubleClick(sender: System.Object;<br />
e: System.EventArgs);<br />
begin<br />
If fg.MouseCol = 0 Then<br />
ToggleNodeState;<br />
end;<br />
procedure fg_KeyPress(sender: System.Object;
e: KeyPressEventArgs);<br />
begin<br />
If e.KeyChar = #13 Then<br />
ToggleNodeState;<br />
end;<br />
procedure ToggleNodeState;<br />
var<br />
r: Row;<br />
begin<br />
// if the current row is not a node, no work<br />
r := fg.Rows[fg.Row];<br />
If Not r.IsNode Then<br />
exit;<br />
// toggle collapsed state<br />
r.Node.Collapsed := Not r.Node.Collapsed;<br />
end;<br />
Übung zur Gliederung · 97<br />
Der Ereignisabwickler prüft, ob der Nutzer auf die erste Spalte doppelgeklickt oder die Enter-Taste<br />
gedrückt hat, und ruft dann die ToggleNodeState-Routine auf. ToggleNodeState prüft, ob die aktuelle<br />
Zeile einen Knoten besitzt und schaltet den Wert der Node.Collapsed-Eigenschaft um, wenn es eine ist.<br />
Schritt 4: Bearbeitung erlauben/verbieten<br />
Erinnern Sie sich, dass wir die AllowEditing-Eigenschaft der ersten Spalte im Form_Load-Ereignis auf<br />
FALSE gesetzt haben. Daher konnte der Nutzer die Zellen der ersten Spalte nicht mehr verändern. Wir<br />
wollen nun den Nutzer auch davon abhalten, Werte in die zweite Spalte der Knotenzeilen einzutragen.<br />
Um dies zu tun, geben Sie folgenden Quellcode in das BeforeEdit-Ereignis ein:<br />
• Visual Basic<br />
• C#<br />
Private Sub fg_BeforeEdit(ByVal sender As Object, _<br />
ByVal e As RowColEventArgs) Handles fg.BeforeEdit<br />
' if the current row is a node, don't edit it<br />
Dim r As Row = fg.Rows(fg.Row)<br />
If r.IsNode Then e.Cancel = True<br />
End Sub<br />
private void fg_BeforeEdit( object sender, RowColEventArgs e)<br />
fg.BeforeEdit {<br />
}<br />
• Delphi<br />
// if the current row is a node, don't edit it<br />
Row r = fg.Rows[fg.Row];<br />
if (r.IsNode) e.Cancel = true;<br />
procedure fg_BeforeEdit(sender: System.Object;<br />
e: RowColEventArgs);<br />
var<br />
r: Row;<br />
begin<br />
// if the current row is a node, don't edit it<br />
r := fg.Rows[fg.Row];<br />
If r.IsNode Then<br />
e.Cancel := True;<br />
end;
98 · FlexGrid-Übungen<br />
Schritt 5: Quickinfo implementieren<br />
Um diese Übung zu beenden werden wir nun Quickinfos im Gliederungsbaum integrieren. Die<br />
Quickinfo wird den Text, der von der oben beschriebenen GetXMLData-Routine in der UserData-<br />
Eigenschaft abgespeichert wurde, von jeder Zeile anzeigen. Sie wird also den Inhalt des „Name“-Knotens<br />
einblenden, wenn der Nutzer mit der Maus über dessen übergeordneten Knoten fährt. Dies ist nützlich,<br />
wenn der übergeordnete Knoten zusammengeklappt und damit der „Name“-Knoten nicht sichtbar ist.<br />
Um Quickinfo zu implementieren, müssen Sie zunächst eine ToolTip-Steuerung dem Formular<br />
hinzufügen. Danach fügen Sie den folgenden Quellcode ein, um das Tabellenereignis MouseMove<br />
abzufangen:<br />
• Visual Basic<br />
• C#<br />
Private Sub fg_MouseMove(ByVal sender As Object, _<br />
ByVal e As MouseEventArgs) Handles fg.MouseMove<br />
' check tooltip for this cell<br />
Dim tip As String<br />
If fg.MouseCol = 0 And fg.MouseRow > 0 Then<br />
tip = fg.Rows(fg.MouseRow).UserData<br />
End If<br />
' set it if different from current<br />
If tip ToolTip1.GetToolTip(fg) Then<br />
ToolTip1.SetToolTip(fg, tip)<br />
End If<br />
End Sub<br />
private void fg_MouseMove( object sender, MouseEventArgs e)<br />
fg.MouseMove {<br />
}<br />
• Delphi<br />
// check tooltip for this cell<br />
string tip;<br />
if ( fg.MouseCol == 0 && fg.MouseRow > 0) {<br />
tip = fg.Rows[fg.MouseRow].UserData;<br />
}<br />
// set it if different from current<br />
if ( tip != ToolTip1.GetToolTip(fg)) {<br />
ToolTip1.SetToolTip(fg, tip);<br />
}<br />
procedure fg_MouseMove(sender: System.Object;<br />
e: System.MouseEventArgs);<br />
var<br />
tip: string;<br />
begin<br />
// check tooltip for this cell<br />
If (fg.MouseCol = 0) And (fg.MouseRow > 0) Then<br />
tip := fg.Rows[fg.MouseRow].UserData;<br />
// set it if different from current<br />
If tip ToolTip1.GetToolTip(fg) Then<br />
ToolTip1.SetToolTip(fg, tip);<br />
end;<br />
Der Quellcode beginnt mit der Überprüfung der Zelle unter dem Mauszeiger mit der MouseRow- und<br />
MouseCol-Eigenschaft. Wenn der Mauszeiger sich in der ersten Spalte und in einer Zeile, die eine
Übung zur Datenanalyse · 99<br />
Quickinfo enthält, befindet, dann wird der entsprechende Text abgerufen. Sonst wird die Quickinfo auf<br />
Nothing gestellt.<br />
Danach vergleicht die Routine den aktuellen und den neuen Quickinfotext und aktualisiert diesen wenn<br />
nötig, indem die SetToolTip-Methode auf die tooltip-Steuerung anwendet.<br />
Damit ist diese Übung beendet. Sie können dieses Projekt noch auf vielen Wegen erweitern, z.B. so, dass<br />
Änderungen wieder im XML-Dokument gespeichert werden, Knoten hinzugefügt, gelöscht oder<br />
verschoben werden können, oder dass verschiedene Formate für verschiedene Datentypen angewendet<br />
werden.<br />
Übung zur Datenanalyse<br />
Diese Übung deckt einige der nützlichsten Funktionen der <strong>C1FlexGrid</strong>-Steuerung ab, um dynamische<br />
Ansichten von Datentabellen zur Verfügung zu stellen. Die Anwendung beginnt mit einer einfachen,<br />
datengebundenen Tabelle mit Umsatzzahlen (aus der NorthWind-Datenbank) und fügt dann die<br />
folgenden Funktionen hinzu:<br />
• Dynamisches Gestaltung (Spaltenreihenfolge)<br />
• Automatische Sortierung<br />
• Zellverbindungen<br />
• Automatische Zwischensummen<br />
• Gliederungsbaum<br />
Die nachfolgende Grafik zeigt, wie die endgültige Anwendung aussehen wird. Der Nutzer kann die<br />
ersten drei Spalten ziehen, um die Daten nach Vertriebsmitarbeitern, Ländern und Produktnamen zu<br />
gruppieren. Wenn ein Spalte gezogen wird, dann werden die Summen automatisch neu berechnet und<br />
die Gliederung neu aufgebaut.
100 · FlexGrid-Übungen<br />
Schritt 1: Die <strong>C1FlexGrid</strong>-Steuerung<br />
Erstellen Sie ein neues Visual Basic-Projekt und fügen Sie eine <strong>C1FlexGrid</strong>-Steuerung dem Formular<br />
hinzu, indem Sie auf das <strong>C1FlexGrid</strong>-Symbol in der Symbolleiste klicken. Klicken Sie dann auf das<br />
Formular und ziehen Sie das Objekt in die richtige Größe.<br />
Wenn Sie die <strong>C1FlexGrid</strong>-Steuerung in der Symbolleiste nicht finden können, dann rechtsklicken Sie auf<br />
die Symbolleiste und wählen die Option Customize Toolbox (Anpassen…) aus. Suchen Sie die<br />
<strong>C1FlexGrid</strong>-Steuerung in der Liste der .NET-Komponenten und stellen Sie sicher, dass diese aktiviert ist.<br />
Wenn Sie die <strong>C1FlexGrid</strong> in der Komponentenliste nicht finden können, dann müssen Sie das Programm<br />
eventuell erneut installieren.<br />
Als nächstes müssen Sie im .NET-Eigenschaftsfenster die folgenden Steuerungseigenschaften festlegen:<br />
(Name) = fg<br />
Dock = Fill<br />
Doppelklicken Sie nun auf den Titelbereich des Formulars um das Quellcodefenster zu öffnen. Fügen Sie<br />
folgende Anweisungen am oberen Ende der Datei ein:<br />
• Visual Basic<br />
• C#<br />
Imports System.Data.OleDb<br />
Imports C1.Win.<strong>C1FlexGrid</strong><br />
using System.Data.OleDb;<br />
using C1.Win.<strong>C1FlexGrid</strong>;<br />
• Delphi<br />
uses System.Data.OleDb,<br />
C1.Win.<strong>C1FlexGrid</strong>;<br />
Damit werden die Objekte, die in der <strong>C1FlexGrid</strong>- und der OleDb-Assembly definiert sind, im Projekt<br />
sichtbar und ersparen somit viel Schreibarbeit.<br />
Schritt 2: Die Tabelle initialisieren und mit Daten füllen<br />
Fügen Sie den folgenden Quellcode in das Form_Load-Ereignis ein, um die Tabelle zu erstellen und mit<br />
den zu analysierenden Umsatzdaten zu füllen:<br />
• Visual Basic<br />
Private Sub Form1_Load(ByVal sender As System.Object, _<br />
ByVal e As EventArgs) Handles MyBase.Load<br />
' set up grid layout/behavior<br />
fg.AllowEditing = False<br />
fg.AllowSorting = AllowSortingEnum.None<br />
fg.AllowMerging = AllowMergingEnum.Nodes<br />
fg.SelectionMode = SelectionModeEnum.Cell<br />
fg.ExtendLastCol = True<br />
fg.Cols(0).Width = fg.Cols.DefaultSize / 4<br />
fg.Tree.Style = TreeStyleFlags.Simple<br />
fg.Tree.Column = 1<br />
' set up grid styles<br />
fg.Styles.Normal.Border.Style = BorderStyleEnum.None<br />
fg.Styles.Normal.Trimming = StringTrimming.EllipsisCharacter<br />
Dim s As CellStyle = fg.Styles(CellStyleEnum.GrandTotal)<br />
s.BackColor = Color.Black
• C#<br />
s.ForeColor = Color.White<br />
s = fg.Styles(CellStyleEnum.Subtotal0)<br />
s.BackColor = Color.Gold<br />
s.ForeColor = Color.Black<br />
s = fg.Styles(CellStyleEnum.Subtotal1)<br />
s.BackColor = Color.Khaki<br />
s.ForeColor = Color.Black<br />
s = fg.Styles(CellStyleEnum.Subtotal2)<br />
s.BackColor = Color.LightGoldenrodYellow<br />
s.ForeColor = Color.Black<br />
' bind flex to data source<br />
fg.DataSource = GetDataSource()<br />
' prevent user from dragging last three columns<br />
fg.Cols(4).AllowDragging = False<br />
fg.Cols(5).AllowDragging = False<br />
fg.Cols(6).AllowDragging = False<br />
End Sub<br />
Übung zur Datenanalyse · 101<br />
private void Form1_Load( System.object sender, EventArgs e) base.Load<br />
{<br />
}<br />
• Delphi<br />
// set up grid layout/behavior<br />
fg.AllowEditing = False<br />
fg.AllowSorting = AllowSortingEnum.None;<br />
fg.AllowMerging = AllowMergingEnum.Nodes;<br />
fg.SelectionMode = SelectionModeEnum.Cell;<br />
fg.ExtendLastCol = true;<br />
fg.Cols[0].Width = fg.Cols.DefaultSize / 4;<br />
fg.Tree.Style = TreeStyleFlags.Simple;<br />
fg.Tree.Column = 1;<br />
// set up grid styles<br />
fg.Styles.Normal.Border.Style = BorderStyleEnum.None;<br />
fg.Styles.Normal.Trimming = StringTrimming.EllipsisCharacter;<br />
CellStyle s = fg.Styles[CellStyleEnum.GrandTotal];<br />
s.BackColor = Color.Black;<br />
s.ForeColor = Color.White;<br />
s = fg.Styles[CellStyleEnum.Subtotal0];<br />
s.BackColor = Color.Gold;<br />
s.ForeColor = Color.Black;<br />
s = fg.Styles[CellStyleEnum.Subtotal1];<br />
s.BackColor = Color.Khaki;<br />
s.ForeColor = Color.Black;<br />
s = fg.Styles[CellStyleEnum.Subtotal2];<br />
s.BackColor = Color.LightGoldenrodYellow;<br />
s.ForeColor = Color.Black;<br />
// bind flex to data source<br />
fg.DataSource = GetDataSource();<br />
// prevent user from dragging last three columns<br />
fg.Cols[4].AllowDragging = false;<br />
fg.Cols[5].AllowDragging = false;<br />
fg.Cols[6].AllowDragging = false;<br />
procedure Form1_Load(sender: System.Object;<br />
e: System.EventArgs);
102 · FlexGrid-Übungen<br />
var<br />
s: CellStyle;<br />
begin<br />
// set up grid layout/behavior<br />
fg.AllowEditing = False<br />
fg.AllowSorting := AllowSortingEnum.None;<br />
fg.AllowMerging := AllowMergingEnum.Nodes;<br />
fg.SelectionMode := SelectionModeEnum.Cell;<br />
fg.ExtendLastCol := True;<br />
fg.Cols[0].Width := fg.Cols.DefaultSize / 4;<br />
fg.Tree.Style := TreeStyleFlags.Simple;<br />
fg.Tree.Column := 1;<br />
// set up grid styles<br />
fg.Styles.Normal.Border.Style := BorderStyleEnum.None;<br />
fg.Styles.Normal.Trimming := StringTrimming.EllipsisCharacter;<br />
s := fg.Styles[CellStyleEnum.GrandTotal];<br />
s.BackColor := Color.Black;<br />
s.ForeColor := Color.White;<br />
s = fg.Styles[CellStyleEnum.Subtotal0];<br />
s.BackColor := Color.Gold;<br />
s.ForeColor := Color.Black;<br />
s := fg.Styles[CellStyleEnum.Subtotal1];<br />
s.BackColor := Color.Khaki;<br />
s.ForeColor := Color.Black;<br />
s := fg.Styles[CellStyleEnum.Subtotal2];<br />
s.BackColor := Color.LightGoldenrodYellow;<br />
s.ForeColor := Color.Black;<br />
// bind flex to data source<br />
fg.DataSource := GetDataSource;<br />
// prevent user from dragging last three columns<br />
fg.Cols[4].AllowDragging := False;<br />
fg.Cols[5].AllowDragging := False;<br />
fg.Cols[6].AllowDragging := False;<br />
end;<br />
Die Routine beginnt die Tabelle und einige Formate zu erstellen. Diese Eigenschaften können Sie, wenn<br />
gewünscht, auch während der Designtime mit den integrierten Tabelleneditoren festlegen.<br />
Nachdem die Tabelle erzeugt wurde, bindet die Routine diese an die, von der nachfolgend aufgelisteten<br />
GetDataSource-Methode erstellten Datenquelle. Zuletzt werden noch die drei hinteren Spalten auf ihre<br />
Position fixiert, indem ihre AllowDragging-Eigenschaft auf FALSE gestellt wird, so dass der Nutzer<br />
nicht nach den Daten in diesen Spalten gruppieren kann. Die Werte in diesen Spalten sind in jeder Zeile<br />
verschieden.<br />
Die GetDataSource-Methode erstellt die Datentabelle, die von der Steuerung angezeigt wird. Diese<br />
Routine ist, außer der SQL-Anweisung, die die Daten abruft, recht einfach. Die meisten Anwender<br />
schreiben diesen SQL-Befehl nicht selbst, sondern verwenden einen Visual Designer, wie zum Beispiel<br />
den in Visual Studio oder Microsoft Access.<br />
Beachten Sie, dass Sie eventuell die Verbindungsanweisung etwas abändern müssen, weil diese einen<br />
Verweis auf die NorthWind-Datenbank beinhaltet und die Dateien auf Ihrem System vielleicht in einem<br />
anderen Verzeichnis liegen:<br />
• Visual Basic<br />
Private Function GetDataSource() As DataTable<br />
' set up connection string<br />
Dim conn As String = "Provider=Microsoft.Jet.OLEDB.4.0;" & _
"Data Source=C:\Program Files\Microsoft Visual<br />
Studio\VB98\NWIND.MDB;"<br />
& _<br />
• C#<br />
Übung zur Datenanalyse · 103<br />
' set up SQL statement<br />
Dim rs As String = _<br />
"SELECT Employees.LastName,Orders.ShipCountry," & _<br />
"Categories.CategoryName,Products.ProductName,Orders.OrderDate,"<br />
"[Quantity]*[Products].[UnitPrice] AS [Sale Amount] " & _<br />
"FROM (Categories INNER JOIN Products " & _<br />
"ON Categories.CategoryID = Products.CategoryID) " & _<br />
"INNER JOIN ((Employees INNER JOIN Orders " & _<br />
"ON Employees.EmployeeID = Orders.EmployeeID) " & _<br />
"INNER JOIN [Order Details] " & _<br />
"ON Orders.OrderID = [Order Details].OrderID) " & _<br />
"ON Products.ProductID = [Order Details].ProductID "<br />
"ORDER BY Employees.LastName,Orders.ShipCountry," & _<br />
"Categories.CategoryName;"<br />
' retrieve data into DataSet<br />
Dim da As OleDbDataAdapter = New OleDbDataAdapter(rs, conn)<br />
Dim ds As DataSet = New DataSet()<br />
da.Fill(ds)<br />
' return data table<br />
GetDataSource = ds.Tables(0)<br />
End Function<br />
private DataTable GetDataSource() {<br />
// set up connection string<br />
string conn = "Provider=Microsoft.Jet.OLEDB.4.0;" + "Data<br />
Source=C:\Program Files\Microsoft Visual Studio\VB98\NWIND.MDB;";<br />
+<br />
// set up SQL statement<br />
string rs =<br />
"SELECT Employees.LastName,Orders.ShipCountry," +<br />
"Categories.CategoryName,Products.ProductName,Orders.OrderDate,"<br />
"[Quantity]*[Products].[UnitPrice] AS [Sale Amount] " +<br />
"FROM (Categories INNER JOIN Products " +<br />
"ON Categories.CategoryID = Products.CategoryID) " +<br />
"INNER JOIN ((Employees INNER JOIN Orders " +<br />
"ON Employees.EmployeeID = Orders.EmployeeID) " +<br />
"INNER JOIN [Order Details] " +<br />
"ON Orders.OrderID = [Order Details].OrderID) " +<br />
"ON Products.ProductID = [Order Details].ProductID " +<br />
"ORDER BY Employees.LastName,Orders.ShipCountry," +<br />
"Categories.CategoryName;";<br />
// retrieve data into DataSet<br />
OleDbDataAdapter OleDbDataAdapter da = new OleDbDataAdapter(rs,<br />
conn);<br />
DataSet DataSet ds = new DataSet();<br />
da.Fill(ds);<br />
}<br />
// return data table<br />
GetDataSource = ds.Tables[0]
104 · FlexGrid-Übungen<br />
• Delphi<br />
function Class1.GetDataSource: DataTable;<br />
var<br />
DataSet: DataSet;<br />
OleDbDataAdapter: OleDbDataAdapter;<br />
rs: string;<br />
conn: string;<br />
begin<br />
conn := ('Provider=Microsoft.Jet.OLEDB.4.0;' + 'Data<br />
Source=C:\Program Files Microsoft Visual Studio B98 WIND.MDB;');<br />
+<br />
// set up SQL statement<br />
rs :=<br />
'SELECT Employees.LastName,Orders.ShipCountry,' +<br />
'Categories.CategoryName,Products.ProductName,Orders.OrderDate,'<br />
'[Quantity]*[Products].[UnitPrice] AS [Sale Amount] ' +<br />
'FROM (Categories INNER JOIN Products ' +<br />
'ON Categories.CategoryID = Products.CategoryID) ' +<br />
'INNER JOIN ((Employees INNER JOIN Orders ' +<br />
'ON Employees.EmployeeID = Orders.EmployeeID) ' +<br />
'INNER JOIN [Order Details] ' +<br />
'ON Orders.OrderID = [Order Details].OrderID) ' +<br />
'ON Products.ProductID = [Order Details].ProductID ' +<br />
'ORDER BY Employees.LastName,Orders.ShipCountry,' +<br />
'Categories.CategoryName;';<br />
da := OleDbDataAdapter.Create(rs, conn);<br />
ds := DataSet.Create;<br />
da.Fill(ds);<br />
Self.GetDataSource := ds.Tables[0];<br />
end;<br />
Wenn Sie das Projekt nun starten, dann sehen Sie eine rohe Tabelle, in der Sie die Spalten verschieben<br />
und sich durch die Daten klicken können. Da die Daten immer noch unstrukturiert sind und die Tabelle<br />
mehrere tausend Einträge enthält, ist es schwer, einen Überblick über diese zu erhalten.<br />
Schritt 3: Automatische Sortierung<br />
Der erste Schritt in Richtung organisierte Daten ist die Sortierung. Zusätzlich würden wir gern die Daten<br />
immer dann automatisch sortieren, wenn der Nutzer die Spaltenreihenfolge verändert.<br />
Wenn der Nutzer die Spalten neu anordnet, dann startet die <strong>C1FlexGrid</strong>-Steuerung das<br />
AfterDragColumn-Ereignis. Wir werden nun in dieses Ereignis einen Ereignisabwickler einzufügen, der<br />
die Daten in der zugrunde liegenden Datentabelle sortiert. Wenn sich die Tabelle im ungebundenen<br />
Modus befinden würde, dann hätten wir an dieser Stelle die Sort-Methode verwendet.<br />
Der Quellcode ist recht einfach:<br />
• Visual Basic<br />
Private Sub fg_AfterDragColumn(ByVal sender As Object, _<br />
ByVal e As DragRowColEventArgs) Handles fg.AfterDragColumn<br />
' sort the recordset when the user drags columns<br />
' this will cause a data refresh, removing all subtotals and<br />
' firing the AfterDataRefresh event, which rebuilds the subtotals.<br />
Dim sort As String = fg.Cols(1).Name & ", " & _<br />
fg.Cols(2).Name & ", " & _<br />
fg.Cols(3).Name<br />
Dim dt As DataTable = fg.DataSource
• C#<br />
dt.DefaultView.Sort = sort<br />
End Sub<br />
Übung zur Datenanalyse · 105<br />
private void fg_AfterDragColumn( object sender, DragRowColEventArgs e)<br />
fg.AfterDragColumn {<br />
}<br />
• Delphi<br />
// sort the recordset when the user drags columns<br />
// this will cause a data refresh, removing all subtotals and<br />
// firing the AfterDataRefresh event, which rebuilds the subtotals.<br />
string sort = fg.Cols[1].Name + ", " +<br />
fg.Cols[2].Name + ", " +<br />
fg.Cols(3).Name;<br />
DataTable dt = fg.DataSource;<br />
dt.DefaultView.Sort = sort;<br />
procedure fg_AfterDragColumn(sender: Object;<br />
e: DragRowColEventArgs);<br />
var<br />
sort: string;<br />
dt: DataTable;<br />
begin<br />
// sort the recordset when the user drags columns<br />
// this will cause a data refresh, removing all subtotals and<br />
// firing the AfterDataRefresh event, which rebuilds the subtotals.<br />
sort := fg.Cols[1].Name + ', ' +<br />
fg.Cols[2].Name + ', ' +<br />
fg.Cols[3].Name;<br />
dt := fg.DataSource;<br />
dt.DefaultView.Sort := sort;<br />
end;<br />
Starten Sie das Projekt und versuchen Sie die ersten drei Spalten neu anzuordnen, indem Sie deren<br />
Überschriften an andere Stellen ziehen. Immer wenn Sie eine Spalte verschieben, werden die Daten nun<br />
automatisch neu sortiert und können daher leichter interpretiert werden.<br />
Im nächsten Schritt werden wir Zwischensummen und einen Gliederungsbaum hinzufügen.<br />
Schritt 4: Zwischensumme und Gliederungsbaum<br />
Wenn sich die Tabelle im gebunden Modus befindet, dann wird nach jeder Änderung der Datenquelle<br />
das AfterDataRefresh-Ereignis gestartet. Dieses Ereignis eignet sich sehr gut, um den Quellcode für das<br />
Einfügen von Zwischensummen und den Aufbau eines Gliederungsbaumes einzubringen.<br />
Dies ist der AfterDataRefresh-Ereignisabwickler:<br />
• Visual Basic<br />
Private Sub fg_AfterDataRefresh(ByVal sender As Object, _<br />
ByVal e As ListChangedEventArgs) Handles fg.AfterDataRefresh<br />
' total on Sale Amount<br />
Dim totalOn As Integer = fg.Cols("Sale Amount").SafeIndex<br />
Dim caption As String = "Total for {0}"<br />
' calculate three levels of totals<br />
fg.Subtotal(AggregateEnum.Sum, 0, 1, totalOn, caption)<br />
fg.Subtotal(AggregateEnum.Sum, 1, 2, totalOn, caption)<br />
fg.Subtotal(AggregateEnum.Sum, 2, 3, totalOn, caption)<br />
' collapse outline to level 2
106 · FlexGrid-Übungen<br />
• C#<br />
fg.Tree.Show(2)<br />
' autosize the grid to accommodate tree<br />
fg.AutoSizeCols(1, 1, 1000, 3, 30, AutoSizeFlags.IgnoreHidden)<br />
End Sub<br />
private void fg_AfterDataRefresh( object sender, ListChangedEventArgs<br />
e) fg.AfterDataRefresh {<br />
}<br />
• Delphi<br />
// total on Sale Amount<br />
int totalOn = fg.Cols["Sale Amount"].SafeIndex;<br />
string caption = "Total for {0}";<br />
// calculate three levels of totals<br />
fg.Subtotal(AggregateEnum.Sum, 0, 1, totalOn, caption);<br />
fg.Subtotal(AggregateEnum.Sum, 1, 2, totalOn, caption);<br />
fg.Subtotal(AggregateEnum.Sum, 2, 3, totalOn, caption);<br />
// collapse outline to level 2<br />
fg.Tree.Show(2);<br />
// autosize the grid to accommodate tree<br />
fg.AutoSizeCols(1, 1, 1000, 3, 30, AutoSizeFlags.IgnoreHidden);<br />
procedure fg_AfterDataRefresh(sender: System.Object;<br />
e: ListChangedEventArgs);<br />
var<br />
totalOn: Integer;<br />
caption: string;<br />
begin<br />
// total on Sale Amount<br />
totalOn := fg.Cols['Sale Amount'].SafeIndex;<br />
caption := 'Total for {0}';<br />
// calculate three levels of totals<br />
fg.Subtotal(AggregateEnum.Sum, 0, 1, totalOn, caption);<br />
fg.Subtotal(AggregateEnum.Sum, 1, 2, totalOn, caption);<br />
fg.Subtotal(AggregateEnum.Sum, 2, 3, totalOn, caption);<br />
// collapse outline to level 2<br />
fg.Tree.Show(2);<br />
// autosize the grid to accommodate tree<br />
fg.AutoSizeCols(1, 1, 1000, 3, 30, AutoSizeFlags.IgnoreHidden);<br />
end;<br />
Dieser recht einfache Quelltext beginnt mit der Ermittlung des Index der „Sale Amount“-Spalte. In<br />
diesem Beispiel ist dieser Index immer der gleiche (Spalte 6). Den Index zu ermitteln ist üblicherweise<br />
besser als diesen fix im Quellcode zu hinterlegen, da er sich ändert, wenn einige Felder in der SQL-<br />
Anweisung hinzugefügt werden.<br />
Der Quellcode ruft anschließend die Subtotal-Methode auf, um die Daten zu gruppieren und neue Zeilen<br />
mit den entsprechenden Zwischensummen einzufügen. Die neuen Zeilen werden automatisch als<br />
Gliederungsknoten formatiert und deren IsNode-Eigenschaft steht auf TRUE, so dass die<br />
Zwischensummen eingeklappt werden können.
Übung zur Datenanalyse · 107<br />
Starten Sie nun das Projekt erneut und verschieben Sie einige Spalten. Sie können nun die Summen für<br />
Länder, Produktkategorie und Vertriebsmitarbeiter sehen. Sie können außerdem die Gliederung<br />
erweitern, um detailliertere Daten in unteren Ebenen einzusehen.<br />
Beachten Sie auch, dass die Tabelle noch bearbeitbar ist. Wenn Sie einen Wert in der „Sale Amount“-<br />
Spalte ändern, dann wird automatisch das AfterDataRefresh-Ereignis gestartet und die Summen werden<br />
entsprechend aktualisiert.<br />
Damit ist diese Übung beendet.
<strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
<strong>C1FlexGrid</strong>-Klasse · 109<br />
Die <strong>C1FlexGrid</strong>-Komponente stellt die folgenden Eigenschaften, Ereignisse und Methoden zur<br />
Verfügung:<br />
<strong>C1FlexGrid</strong>-Klasse<br />
Mit der <strong>C1FlexGrid</strong>-Steuerung können Sie tabellarische Daten anzeigen, bearbeiten, gruppieren und<br />
zusammenfassen. Die Tabellensteuerung kann an eine Datenquelle gebunden sein, oder Sie verwaltet<br />
ihre eigenen Daten.<br />
Alle <strong>C1FlexGrid</strong>-Mitglieder<br />
<strong>C1FlexGrid</strong>-Eigenschaften (public)<br />
AllowAddNew Gibt zurück oder legt fest, ob die Tabelle eine Vorlage<br />
für eine neue Zeile nach der letzten Zeile anzeigt.<br />
AllowDelete Gibt zurück oder legt fest, ob die Tabelle die Tastatur<br />
überwacht und die Entfernen-Taste kontrollieren soll.<br />
AllowDragging<br />
Unterstützt vom .NET-Compact-Framework.<br />
AllowEditing<br />
Unterstützt vom .NET-Compact-Framework.<br />
Legt fest, ob der Nutzer Spalten/Zeilen mit der Maus<br />
ziehen darf.<br />
Legt fest, ob der Nutzer Zellen bearbeiten darf.<br />
AllowFreezing Legt fest, ob der Nutzer Spalten und Zeilen mit der Maus<br />
fixieren darf.<br />
AllowMerging<br />
Unterstützt vom .NET-Compact-Framework.<br />
AllowResizing<br />
Unterstützt vom .NET-Compact-Framework.<br />
AllowSorting<br />
Unterstützt vom .NET-Compact-Framework.<br />
Legt fest, ob Zellen mit ähnlichem Inhalt verbunden<br />
werden.<br />
Legt fest, ob der Nutzer die Größe von Spalten und<br />
Zeilen mit der Maus verändern darf.<br />
Legt fest, ob der Nutzer Spalten mit der Maus sortieren<br />
darf.<br />
AutoClipboard Gibt zurück oder legt fest, ob die Tabelle die<br />
Zwischenablagefunktionen steuern soll und automatisch<br />
die Operationen Ausschneiden, Kopieren, Einfügen und<br />
Löschen durchführen soll.<br />
AutoGenerateColumns Legt fest, ob die Tabelle ihre Spalten aktualisiert, wenn<br />
sie einer neuen Datenquelle zugeordnet wurde.<br />
AutoResize Gibt zurück oder legt fest, ob die Spaltenbreiten<br />
automatisch angepasst werden, wenn Daten geladen<br />
werden.<br />
AutoSearch<br />
Unterstützt vom .NET-Compact-Framework.<br />
AutoSearchDelay<br />
Unterstützt vom .NET-Compact-Framework.<br />
Legt fest, ob die Tabelle den Cursor bewegen soll, wenn<br />
diese nach Einträgen sucht, während der Nutzer tippt.<br />
Legt die zu verstreichende Zeit fest (in Sekunden), bevor<br />
der AutoSearch-Puffer zurückgesetzt wird.
110 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
BottomRow<br />
Unterstützt vom .NET-Compact-Framework.<br />
Gibt die letzte, sichtbare Zeile einer Tabelle zurück.<br />
BorderStyle Gibt/legt den Rahmen-Stil der Steuerung zurück/fest.<br />
CellButtonImage<br />
Unterstützt vom .NET-Compact-Framework.<br />
Clip<br />
Unterstützt vom .NET-Compact-Framework.<br />
ClipSeparators<br />
Unterstützt vom .NET-Compact-Framework.<br />
Col<br />
Unterstützt vom .NET-Compact-Framework.<br />
Cols<br />
Unterstützt vom .NET-Compact-Framework.<br />
ColSel<br />
Unterstützt vom .NET-Compact-Framework.<br />
ComboList<br />
Unterstützt vom .NET-Compact-Framework.<br />
CursorCell<br />
Unterstützt vom .NET-Compact-Framework.<br />
Legt die Grafik auf einer Zellschaltfläche fest.<br />
Gibt/legt den Inhalt eines Zellbereichs zurück/fest.<br />
Gibt/legt die Trennzeichen für Zeilen und Spalten im<br />
Clip-Eintrag zurück/fest.<br />
Gibt/legt den Index einer ausgewählten Spalte<br />
zurück/fest.<br />
Gibt alle Spalten einer Tabelle zurück.<br />
Gibt/legt den Index der letzten Spalte in der aktuellen<br />
Auswahl zurück/fest.<br />
Gibt/legt die Liste der Elemente, die von einem Dropdown-Editor<br />
verwendet werden zurück/fest.<br />
Gibt ein CellRange-Objekt zurück, dass die Ankerzelle<br />
in der aktuellen Auswahl enthält.<br />
CustomComparer Gibt/legt ein benutzerdefiniertes IComparer-Objekt,<br />
dass von der Tabelle für Gruppierung, Zellverbindung<br />
und Suchoperationen verwendet wird, zurück/fest.<br />
DataMember Gibt/legt eine bestimmte Liste eines DataSource-<br />
Objekts, das die Tabelle anzeigen soll, zurück/fest.<br />
DataSource<br />
Unterstützt vom .NET-Compact-Framework.<br />
Gibt/legt die Datenquelle der Steuerung zurück/fest.<br />
DoubleBuffer Wenn diese Eigenschaft auf TRUE steht, dann wird die<br />
Tabelle in einem Puffer gezeichnet und danach das<br />
Ergebnis auf dem Bildschirm ausgegeben. Damit wird<br />
mögliches Flackern verhindert, wenn die Tabelle von der<br />
Steuerung erneut gezeichnet wird.<br />
DragMode<br />
Unterstützt vom .NET-Compact-Framework.<br />
DrawMode<br />
Unterstützt vom .NET-Compact-Framework.<br />
DropMode<br />
Unterstützt vom .NET-Compact-Framework.<br />
EditMask<br />
Unterstützt vom .NET-Compact-Framework.<br />
Editor<br />
Unterstützt vom .NET-Compact-Framework.<br />
Gibt/legt einen Wert, der festlegt, ob der Nutzer Daten<br />
aus der Steuerung ziehen kann, zurück/fest.<br />
Legt fest, ob benutzerdefinierte Zeichen für<br />
Tabellenzellen bereitgestellt werden.<br />
Gibt/legt einen Wert zurück/fest, der festlegt, ob die<br />
Steuerung Daten akzeptiert, die der Nutzer auf die<br />
Tabelle zieht.<br />
Gibt/legt die Eingabemaske zurück/fest, wenn Zellen<br />
bearbeitet werden.<br />
Gibt den aktuellen Zelleditor zurück, oder legt eine<br />
Steuerung, die als Editor verwendet werden soll, fest<br />
(kann nur während des StartEdit-Ereignisses gesetzt<br />
werden).
<strong>C1FlexGrid</strong>-Klasse · 111<br />
EditOptions Beinhaltet Flags, die das Verhalten der integrierten<br />
Editoren anpassen können.<br />
ExtendLastCol<br />
Unterstützt vom .NET-Compact-Framework.<br />
FocusRect<br />
Unterstützt vom .NET-Compact-Framework.<br />
Legt fest, ob die Breite der letzten Spalte an den zur<br />
Verfügung stehenden Platz in der Steuerung angepasst<br />
werden soll.<br />
Legt den rechteckigen Fokustyp fest, der um die aktuelle<br />
Zelle gelegt wird.<br />
GetCellCheck Gibt einen Wert zurück, der anzeigt, ob die Zelle ein<br />
Kontrollkästchen beinhaltet.<br />
HighLight<br />
Unterstützt vom .NET-Compact-Framework.<br />
Item<br />
Unterstützt vom .NET-Compact-Framework.<br />
KeyActionEnter<br />
Unterstützt vom .NET-Compact-Framework.<br />
KeyActionTab<br />
Unterstützt vom .NET-Compact-Framework.<br />
LeftCol<br />
Unterstützt vom .NET-Compact-Framework.<br />
MouseCol<br />
Unterstützt vom .NET-Compact-Framework.<br />
MouseRow<br />
Unterstützt vom .NET-Compact-Framework.<br />
Legt fest, wann die ausgewählte Zelle markiert wird.<br />
Gibt/legt die Daten in einer Tabellenzelle zurück/fest.<br />
Legt die auszuführende Aktion fest, wenn der Nutzer die<br />
Enter-Taste drückt.<br />
Legt die auszuführende Aktion fest, wenn der Nutzer die<br />
Tabulator-Taste drückt.<br />
Gibt/legt den Index der am weitesten links liegenden,<br />
nicht fixierten Spalte zurück/fest.<br />
Gibt/legt den Index der Spalte unter dem Mauszeiger<br />
zurück/fest.<br />
Gibt/legt den Index der Zeile unter dem Mauszeiger<br />
zurück/fest.<br />
PrintParameters Gibt ein GridPrinter-Objekt zurück, das die<br />
Druckparameter der Tabelle festlegt.<br />
Redraw<br />
Unterstützt vom .NET-Compact-Framework.<br />
RightCol<br />
Unterstützt vom .NET-Compact-Framework.<br />
Row<br />
Unterstützt vom .NET-Compact-Framework.<br />
Rows<br />
Unterstützt vom .NET-Compact-Framework.<br />
RowSel<br />
Unterstützt vom .NET-Compact-Framework.<br />
Legt fest, ob die Tabelle ihren Inhalt zeichnen soll.<br />
Gibt den Index der am weitesten rechtsstehenden Spalte<br />
zurück.<br />
Gibt/legt den Index der ausgewählten Zeile zurück/fest.<br />
Gibt alle Zeilen der Tabelle zurück.<br />
Gibt/legt den Index der letzten Zeile der aktuellen<br />
Auswahl zurück/fest.<br />
ScrollBars Gibt zurück/legt fest welche Bildlaufleisten in der Tabelle<br />
angezeigt werden.<br />
ScrollPosition Gibt/legt die Bildlaufleistenposition zurück/fest.<br />
ScrollTrack Legt das Tabellenverhalten fest, während der Nutzer die<br />
Bildlaufleisten zieht.<br />
ScrollTips Gibt zurück/legt fest, ob Quickinfos angezeigt werden,<br />
wenn der Nutzer die vertikale Bildlaufleiste zieht.
112 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
ScrollTipText Gibt/legt die Quickinfo zurück/fest, die angezeigt wird,<br />
wenn der Nutzer die vertikale Bildlaufleiste zieht.<br />
Selection<br />
Unterstützt vom .NET-Compact-Framework.<br />
SelectionMode<br />
Unterstützt vom .NET-Compact-Framework.<br />
Gibt ein CellRange-Objekt mit der aktuellen Auswahl<br />
zurück.<br />
Legt das Auswahlverhalten der Tabelle fest.<br />
SetCellCheck Legt den Zustand eines Kontrollkästchens in einer Zelle<br />
fest.<br />
ShowButtons Legt fest, wann die Tabelle Auswahl- und Popup-<br />
Schaltflächen in bearbeitbaren Zellen anzeigen soll.<br />
ShowCellLabels Zeigt eine Art Quickinfo an, wenn der Mauszeiger über<br />
einer Zelle steht, die zu klein für ihren Inhalt ist.<br />
ShowCursor Legt fest, ob die Tabelle eine<br />
Datensatzmarkierungsgrafik anzeigen soll.<br />
Styles<br />
Unterstützt vom .NET-Compact-Framework.<br />
Gibt alle Zellformate in einer Tabelle zurück.<br />
SubTotalPosition Legt fest, ob die Subtotal-Methode die Knotenzeilen<br />
unter oder über den Daten, die zusammengefasst<br />
werden, einfügt.<br />
TopRow<br />
Unterstützt vom .NET-Compact-Framework.<br />
Tree<br />
Unterstützt vom .NET-Compact-Framework.<br />
<strong>C1FlexGrid</strong>-Methoden (public)<br />
AddItem<br />
Unterstützt vom .NET-Compact-Framework.<br />
Aggregate<br />
Unterstützt vom .NET-Compact-Framework.<br />
AutoSizeCol<br />
Unterstützt vom .NET-Compact-Framework.<br />
AutoSizeCols<br />
Unterstützt vom .NET-Compact-Framework.<br />
AutoSizeRow<br />
Unterstützt vom .NET-Compact-Framework.<br />
AutoSizeRows<br />
Unterstützt vom .NET-Compact-Framework.<br />
Clear<br />
Unterstützt vom .NET-Compact-Framework.<br />
CreateImage<br />
Unterstützt vom .NET-Compact-Framework.<br />
Gibt/legt den Index der obersten sichtbaren und nicht<br />
fixierten Zeilen zurück/fest.<br />
Gibt das GridTree-Objekt zurück, das die Ansicht des<br />
Gliederungsbaums in einer Tabelle steuert.<br />
Fügt eine neue Zeile der Tabelle hinzu und füllt<br />
diese mit den gegebenen Daten.<br />
Berechnet aggregierte Statistiken für einen<br />
Zellbereich.<br />
Passt die Breite der aktuellen Spalte an ihre Daten<br />
an.<br />
Passt die Breite aller Spalten an ihre Daten an.<br />
Passt die Höhe einer einzelnen Zeile an ihre Daten<br />
an.<br />
Passt die Höhe einer Auswahl von Zeilen an ihre<br />
Daten an.<br />
Löscht die Inhalte einer Tabelle.<br />
Erstellt eine Grafik von der gesamten Tabelle oder<br />
einer Auswahl.
FindRow<br />
Unterstützt vom .NET-Compact-Framework.<br />
FinishEditing<br />
Unterstützt vom .NET-Compact-Framework.<br />
GetCellCheck<br />
Unterstützt vom .NET-Compact-Framework.<br />
GetCellImage<br />
Unterstützt vom .NET-Compact-Framework.<br />
GetCellRange<br />
Unterstützt vom .NET-Compact-Framework.<br />
GetCellRect<br />
Unterstützt vom .NET-Compact-Framework.<br />
GetCellStyle<br />
Unterstützt vom .NET-Compact-Framework.<br />
GetCellStyleDisplay<br />
Unterstützt vom .NET-Compact-Framework.<br />
GetData<br />
Unterstützt vom .NET-Compact-Framework.<br />
GetDataDisplay<br />
Unterstützt vom .NET-Compact-Framework.<br />
GetMergedRange<br />
Unterstützt vom .NET-Compact-Framework.<br />
<strong>C1FlexGrid</strong>-Klasse · 113<br />
Sucht eine Zeile, die eine gegebene Zeichenkette<br />
oder ein gegebenes Objekt enthält.<br />
Beendet die Bearbeitung der aktuellen Zelle und<br />
den Bearbeitungsmodus der Tabelle.<br />
Gibt den Zustand eines Kontrollkästchens in einer<br />
Tabellenzelle zurück.<br />
Gibt die einer Zelle zugeordnete Grafik zurück.<br />
Gibt ein CellRange-Objekt zurück, mit dem eine<br />
Auswahl formatiert und verändert werden kann.<br />
Gibt ein Rectangle-Objekt mit den Koordinaten der<br />
Zellen auf dem Bildschirm zurück.<br />
Gibt ein benutzerdefiniertes, einer bestimmten Zelle<br />
zugeordnetes Format zurück, oder „null“, wenn<br />
diese kein eigenes Format besitzt.<br />
Gibt das Format zurück, das für das Rendern der<br />
Zelle verwendet wird.<br />
Gibt die Daten einer Tabellenzelle zurück.<br />
Gibt die Daten einer Tabellenzelle als Zeichenkette<br />
zurück.<br />
Gibt die Auswahl der mit einer gegeben Zelle<br />
verbundenen Zellen zurück.<br />
HitTest Gibt Informationen über die Steuerung an einem<br />
gegebenen Punkt auf der Steuerungsoberfläche<br />
zurück.<br />
Invalidate<br />
Unterstützt vom .NET-Compact-Framework.<br />
Erklärt einen bestimmten Teil der Tabelle als<br />
ungültig und gibt eine Farbnachricht an die<br />
Steuerung aus.<br />
LoadExcel Lädt ein Arbeitsblatt aus einer Microsoft Excel-Datei<br />
(*.xls).<br />
LoadExcelSheetNames Gibt eine Liste aller Arbeitsblätter einer Microsoft<br />
Excel-Datei zurück (*.xls).<br />
LoadGrid Lädt eine Tabelle aus einer Datei.<br />
PrintGrid<br />
Unterstützt vom .NET-Compact-Framework.<br />
Druckt die Tabelle und zeigt optional ein<br />
Druckvorschaufenster an.<br />
RemoveItem Löscht eine Zeile in der Steuerung.<br />
SaveExcel Speichert die Tabelle in einer Microsoft Excel-Datei<br />
(*.xls).<br />
SaveGrid Speichert die Tabelle in eine Datei.<br />
Select<br />
Unterstützt vom .NET-Compact-Framework.<br />
Wählt eine oder mehrere Zellen aus.
114 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
SetCellImage<br />
Unterstützt vom .NET-Compact-Framework.<br />
SetCellStyle<br />
Unterstützt vom .NET-Compact-Framework.<br />
SetCellCheck<br />
Unterstützt vom .NET-Compact-Framework.<br />
SetData<br />
Unterstützt vom .NET-Compact-Framework.<br />
Ordnet eine Grafik einer Zelle zu.<br />
Ordnet einen eigenen CellStyle der Zelle zu.<br />
Legt den Zustand eines Kontrollkästchens, dass in<br />
einer Zelle angezeigt wird, fest.<br />
Ordnet Daten einer Tabellenzelle zu.<br />
SetDataBinding Stellt die DataSource- und DataMember-<br />
Eigenschaften ein.<br />
ShowCell<br />
Unterstützt vom .NET-Compact-Framework.<br />
Scrollt die Tabelle, so dass eine bestimmt Zelle auf<br />
dem Bildschirm angezeigt wird.<br />
ShowSortAt Zeigt ein Sortierungszeichen in einer bestimmten<br />
Spalte.<br />
Sort<br />
Unterstützt vom .NET-Compact-Framework.<br />
StartEditing<br />
Unterstützt vom .NET-Compact-Framework.<br />
Sortiert die gesamte Tabelle oder eine Auswahl an<br />
Zeilen, basierend auf dem Inhalt einer oder<br />
mehrerer Spalten.<br />
Versetzt die Tabelle in den Bearbeitungsmodus und<br />
beginnt die Zelle zu bearbeiten.<br />
Subtotal Gruppiert und summiert Zeilen nach ihrem Inhalt.<br />
<strong>C1FlexGrid</strong>-Ereignisse (public)<br />
AfterAddRow Wird gestartet, wenn die AllowAddNew-<br />
Eigenschaft auf TRUE steht, und nachdem der<br />
Nutzer eine neue Zeile in die Tabelle einfügt.<br />
AfterDataRefresh<br />
Unterstützt vom .NET-Compact-Framework.<br />
Wird im gebundenen Modus gestartet, nachdem<br />
sich die Tabelle durch die Änderung der<br />
Datenquelle verändert.<br />
AfterDeleteRow Wird gestartet, wenn die AllowDelete-Eigenschaft<br />
auf TRUE steht, und nachdem der Nutzer eine Zeile<br />
in der Tabelle gelöscht hat.<br />
AfterDragColumn<br />
Unterstützt vom .NET-Compact-Framework.<br />
AfterDragRow<br />
Unterstützt vom .NET-Compact-Framework.<br />
AfterEdit<br />
Unterstützt vom .NET-Compact-Framework.<br />
Wird gestartet, nachdem der Nutzer eine Spalte mit<br />
der Maus verschoben hat.<br />
Wird gestartet, nachdem der Nutzer eine Zeile mit<br />
der Maus verschoben hat.<br />
Wird gestartet, nachdem der Nutzer die Zelle fertig<br />
bearbeitet hat.<br />
AfterFreezeColumn Wird gestartet, nachdem der Nutzer Spalten mit der<br />
Maus fixiert hat.<br />
AfterFreezeRow Wird gestartet, nachdem der Nutzer Zeilen mit der<br />
Maus fixiert hat.
AfterResizeColumn<br />
Unterstützt vom .NET-Compact-Framework.<br />
AfterResizeRow<br />
Unterstützt vom .NET-Compact-Framework.<br />
AfterRowColChange<br />
Unterstützt vom .NET-Compact-Framework.<br />
AfterScroll<br />
Unterstützt vom .NET-Compact-Framework.<br />
AfterSelChange<br />
Unterstützt vom .NET-Compact-Framework.<br />
AfterSort<br />
Unterstützt vom .NET-Compact-Framework.<br />
<strong>C1FlexGrid</strong>-Klasse · 115<br />
Wird gestartet, nachdem der Nutzer die Breite von<br />
Spalten verändert hat.<br />
Wird gestartet, nachdem der Nutzer die Höhe von<br />
Zeilen verändert hat.<br />
Wird gestartet, nachdem der Auswahlanker auf eine<br />
andere Zelle festgelegt wurde.<br />
Wird gestartet, nachdem die Tabelle gescrollt<br />
wurde.<br />
Wird gestartet, nachdem sich die Auswahl geändert<br />
hat.<br />
Wird gestartet, nachdem die Spalte durch einen<br />
Klick des Nutzers auf die Überschrift sortiert wurde.<br />
BeforeAddRow Wird gestartet, wenn die AllowAddNew-<br />
Eigenschaft auf TRUE steht, bevor der Nutzer eine<br />
neue Zeile in die Tabelle einfügt.<br />
BeforeAutoSizeColumn Wird gestartet, bevor eine Spalte ihre Breite<br />
aufgrund eines Doppelklicks automatisch anpasst.<br />
BeforeAutoSizeRow Wird gestartet, bevor eine Zeile ihre Höhe aufgrund<br />
eines Doppelklicks automatisch anpasst.<br />
BeforeDeleteRow Wird gestartet, wenn die AllowDelete-Eigenschaft<br />
auf TRUE steht, bevor der Nutzer eine Zeile in der<br />
Tabelle löscht.<br />
BeforeDragColumn<br />
Unterstützt vom .NET-Compact-Framework.<br />
BeforeDragRow<br />
Unterstützt vom .NET-Compact-Framework.<br />
BeforeEdit<br />
Unterstützt vom .NET-Compact-Framework.<br />
Wird gestartet, bevor der Nutzer eine Spalte mit der<br />
Maus verschiebt und sich die Spalte an ihrer neuen<br />
Position befindet.<br />
Wird gestartet, bevor der Nutzer eine Zeile mit der<br />
Maus verschieben will und sich die Zeile an ihrer<br />
neuen Position befindet.<br />
Wird gestartet, bevor die Steuerung in den<br />
Bearbeitungsmodus geht.<br />
BeforeFreezeColumn Wird gestartet, bevor der Nutzer Spalten mit der<br />
Maus fixiert.<br />
BeforeFreezeRow Wird gestartet, bevor der Nutzer Zeilen mit der<br />
Maus fixiert.<br />
BeforeMouseDown<br />
Unterstützt vom .NET-Compact-Framework.<br />
BeforePageBreak<br />
Unterstützt vom .NET-Compact-Framework.<br />
BeforeResizeColumn<br />
Unterstützt vom .NET-Compact-Framework.<br />
BeforeResizeRow<br />
Unterstützt vom .NET-Compact-Framework.<br />
BeforeRowColChange<br />
Unterstützt vom .NET-Compact-Framework.<br />
Wird gestartet, bevor die Steuerung das<br />
MouseDown-Ereignis verarbeitet.<br />
Wird gestartet, während die Tabelle gedruckt wird,<br />
um die Seitenumbrüche zu steuern.<br />
Wird gestartet, bevor die Breite von Spalten<br />
verändert wird.<br />
Wird gestartet, bevor die Höhe von Zeilen verändert<br />
wird.<br />
Wird gestartet, bevor eine andere Zelle zur<br />
aktuellen Zelle (Row, Col) wird.
116 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
BeforeScroll<br />
Unterstützt vom .NET-Compact-Framework.<br />
BeforeScrollTip<br />
Unterstützt vom .NET-Compact-Framework.<br />
BeforeSelChange<br />
Unterstützt vom .NET-Compact-Framework.<br />
BeforeSort<br />
Unterstützt vom .NET-Compact-Framework.<br />
BeginPrint<br />
Unterstützt vom .NET-Compact-Framework.<br />
Wird gestartet, bevor die Steuerung scrollt.<br />
Wird gestartet, bevor ein Scroll-Tip angezeigt wird,<br />
so dass Sie die ScrollTipText-Eigenschaft setzen<br />
können.<br />
Wird gestartet, bevor sich eine Auswahl (RowSel,<br />
ColSel) ändert.<br />
Wird gestartet, bevor die Spalte durch einen Klick<br />
des Nutzers auf die Überschrift sortiert wird.<br />
Wird gestartet, wenn die Tabelle zu drucken<br />
beginnt.<br />
CancelAddRow Wird gestartet, wenn die AllowAddNew-<br />
Eigenschaft TRUE ist, und nachdem der Nutzer<br />
eine Zeile hinzugefügt hat, diese aber wieder<br />
entfernt, indem er sie ohne Änderungen verlässt.<br />
CellButtonClick<br />
Unterstützt vom .NET-Compact-Framework.<br />
Wird gestartet, wenn der Nutzer auf die<br />
Zellschaltfläche klickt.<br />
CellChanged Wird gestartet, nachdem der Inhalt einer Zelle sich<br />
verändert hat.<br />
ChangeEdit<br />
Unterstützt vom .NET-Compact-Framework.<br />
ComboCloseUp<br />
Unterstützt vom .NET-Compact-Framework.<br />
ComboDropDown<br />
Unterstützt vom .NET-Compact-Framework.<br />
EndPrint<br />
Unterstützt vom .NET-Compact-Framework.<br />
EnterCell<br />
Unterstützt vom .NET-Compact-Framework.<br />
Wird gestartet, nachdem der Text im Editor sich<br />
verändert hat.<br />
Wird gestartet, wenn sich die Tabelle im<br />
Bearbeitungsmodus befindet, und bevor der Nutzer<br />
eine Auswahlkombinationsliste zuklappt.<br />
Wird gestartet, wenn sich die Tabelle im<br />
Bearbeitungsmodus befindet, und bevor der Nutzer<br />
eine Auswahlkombinationsliste aufklappt.<br />
Wird gestartet, wenn die Tabelle den Druckvorgang<br />
beendet hat.<br />
Wird gestartet, wenn eine Zelle aktiv wird.<br />
GetCellErrorInfo Wird gestartet, wenn ShowErrors TRUE ist und die<br />
Tabelle Fehlerinformationen für eine Zelle benötigt.<br />
GetRowErrorInfo Wird gestartet, wenn ShowErrors TRUE ist und die<br />
Tabelle Fehlerinformationen für eine Zeile benötigt.<br />
GetUnboundValue Wird gestartet, wenn die Tabelle gebunden ist und<br />
Werte von einer ungebundenen Tabelle abrufen<br />
muss.<br />
GridChanged Wird gestartet, wenn sich die Tabelle auf irgendeine<br />
Weise verändert.<br />
GridError<br />
Unterstützt vom .NET-Compact-Framework.<br />
KeyDownEdit<br />
Unterstützt vom .NET-Compact-Framework.<br />
Wird gestartet, wenn die Tabelle eine<br />
Fehlerbedingung aufspürt.<br />
Wird gestartet, wenn der Nutzer eine Taste im<br />
Zellbearbeitungsmodus drückt.
KeyPressEdit<br />
Unterstützt vom .NET-Compact-Framework.<br />
KeyUpEdit<br />
Unterstützt vom .NET-Compact-Framework.<br />
LeaveCell<br />
Unterstützt vom .NET-Compact-Framework.<br />
<strong>C1FlexGrid</strong>-Klasse · 117<br />
Wird gestartet, wenn der Nutzer eine Taste im<br />
Zellbearbeitungsmodus drückt.<br />
Wird gestartet, wenn der Nutzer eine Taste im<br />
Zellbearbeitungsmodus drückt.<br />
Wird gestartet, bevor die aktuelle Zelle eine andere<br />
wird.<br />
MouseHoverCell Wird gestartet, wenn der Mauszeiger über eine<br />
Zelle fährt.<br />
OwnerDrawCell<br />
Unterstützt vom .NET-Compact-Framework.<br />
PrintPage<br />
Unterstützt vom .NET-Compact-Framework.<br />
RowColChange<br />
Unterstützt vom .NET-Compact-Framework.<br />
SelChange<br />
Unterstützt vom .NET-Compact-Framework.<br />
Wird gestartet, bevor die Tabelle eine Zelle zeichnet<br />
und die DrawMode-Eigenschaft auf OwnerDraw<br />
steht.<br />
Wird gestartet, wenn die Tabelle den Druckvorgang<br />
für eine Seite beendet hat.<br />
Wird gestartet, bevor die aktuelle Zelle (Row, Col)<br />
eine andere wird.<br />
Wird gestartet, nachdem sich die Auswahl (RowSel,<br />
ColSel) geändert hat.<br />
SetUnboundValue Wird gestartet, wenn die Tabelle gebunden ist und<br />
einen Wert in einer ungebundenen Spalte setzt.<br />
SetupEditor<br />
Unterstützt vom .NET-Compact-Framework.<br />
StartEdit<br />
Unterstützt vom .NET-Compact-Framework.<br />
ValidateEdit<br />
Unterstützt vom .NET-Compact-Framework.<br />
<strong>C1FlexGrid</strong>-Eigenschaften<br />
AllowAddNew-Eigenschaft<br />
Wird gestartet, nachdem der integrierte Editor<br />
initialisiert wurde, aber bevor dieser angezeigt wird.<br />
Wird gestartet, wenn die Steuerung in den<br />
Zellbearbeitungsmodus übergeht (nach BeforeEdit).<br />
Wird gestartet, wenn die Steuerung den<br />
Zellbearbeitungsmodus verlässt.<br />
Ermittelt oder legt fest, ob die Tabelle eine Vorlage für eine neue Zeile nach der letzten Zeile anzeigt.<br />
Wenn der Nutzer in diese Vorlage Daten eingibt, dann wird der Tabelle eine neue Zeile angehängt.<br />
Syntax<br />
[VB]<br />
Public AllowAddNew As Boolean<br />
[C#]<br />
public bool AllowAddNew { get; set;}<br />
[Delphi]<br />
property AllowAddNew: Boolean;
118 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Bemerkungen<br />
Diese Eigenschaft funktioniert im gebundenen (wenn die Datenquelle das Hinzufügen von neuen Zeilen<br />
unterstützt) und im ungebundenen Modus.<br />
Beachten Sie, dass wenn diese Eigenschaft auf TRUE steht, die Rows.Count-Eigenschaft einen Wert<br />
zurückgibt, der die Vorlage für die neue Zeile mitzählt. Wenn Sie hingegen die Rows.Count-Eigenschaft<br />
setzen, dann wird die Tabelle dementsprechend viele Datenzeilen anlegen und automatisch die Vorlage<br />
für die neue Zeile hinzufügen. Zum Beispiel:<br />
• Visual Basic<br />
• C#<br />
flex.AllowAddNew = True<br />
flex.Rows.Count = 10<br />
Console.WriteLine(_flex.Rows.Count)<br />
flex.AllowAddNew = true;<br />
flex.Rows.Count = 10;<br />
Console.WriteLine(_flex.Rows.Count);<br />
• Delphi<br />
begin<br />
flex.AllowAddNew := True;<br />
flex.Rows.Count := 10;<br />
Console.WriteLine(_flex.Rows.Count);<br />
end;<br />
Dies wird „11“ Zeilen anlegen (10 Datenzeilen und eine Vorlage für eine neue Zeile).<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
AllowDelete-Eigenschaft<br />
Ermittelt oder legt fest, ob die Tabelle die Tastatur überwacht und die Entfernen-Taste kontrollieren soll.<br />
Wenn diese Eigenschaft auf TRUE steht, dann kann der Nutzer Zeilen löschen, indem er diese auswählt<br />
und die Entfernen-Taste drückt.<br />
Syntax<br />
[VB]<br />
Public AllowDelete As Boolean<br />
[C#]<br />
public bool AllowDelete { get; set;}<br />
[Delphi]<br />
property AllowDelete: Boolean;<br />
Bemerkungen<br />
Diese Eigenschaft funktioniert im gebundenen (wenn die Datenquelle das Löschen von Zeilen<br />
unterstützt) und im ungebundenen Modus.
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
AllowDragging-Eigenschaft<br />
Legt fest, ob der Nutzer Spalten/Zeilen mit der Maus ziehen darf.<br />
Syntax<br />
[VB]<br />
Public AllowDragging As AllowDraggingEnum<br />
[C#]<br />
public AllowDraggingEnum AllowDragging {get; set;}<br />
[Delphi]<br />
property AllowDragging: AllowDraggingEnum;<br />
Eigenschaftswerte<br />
AllowDragging-Eigenschaft · 119<br />
Einer der AllowDraggingEnum-Werte. Der Standardwert ist AllowDraggingEnum.Columns.<br />
Wert Beschreibung<br />
None Der Nutzer kann mit der Maus Zeilen und Spalten nicht ziehen.<br />
Columns Der Nutzer kann mit der Maus Spalten auf neue Positionen ziehen.<br />
Rows Der Nutzer kann mit der Maus Zeilen auf neue Positionen ziehen.<br />
Both Der Nutzer kann mit der Maus Zeilen und Spalten auf neue Positionen ziehen.<br />
Bemerkungen<br />
Sie können das Ziehen von bestimmten Zeilen und Spalten verhindern, indem Sie deren AllowDragging-<br />
Eigenschaft auf FALSE setzen. Zum Beispiel:<br />
• Visual Basic<br />
• C#<br />
flex.AllowDragging = AllowDraggingEnum.Columns<br />
flex.Cols(2).AllowDragging = False<br />
flex.AllowDragging = AllowDraggingEnum.Columns;<br />
flex.Cols[2].AllowDragging = false;<br />
• Delphi<br />
flex.AllowDragging := AllowDraggingEnum.Columns;<br />
flex.Cols[2].AllowDragging := false;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)
120 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
AllowEditing-Eigenschaft (<strong>C1FlexGrid</strong>)<br />
Legt fest, ob der Nutzer Zellen bearbeiten darf.<br />
Syntax<br />
[VB]<br />
Public AllowEditing As Boolean<br />
[C#]<br />
public bool AllowEditing { get; set;}<br />
[Delphi]<br />
property AllowEditing: Boolean;<br />
Eigenschaftswerte<br />
Der Standardwert ist TRUE.<br />
Bemerkungen<br />
Sie können das Bearbeiten von bestimmten Zeilen und Spalten verhindern, indem Sie deren<br />
AllowEditing-Eigenschaft auf FALSE setzen. Zum Beispiel<br />
• Visual Basic<br />
• C#<br />
flex.AllowEditing = True<br />
flex.Cols(2).AllowEditing = False ' prevent editing column 2<br />
flex.AllowEditing = true;<br />
flex.Cols[2].AllowEditing = false; // prevent editing column 2<br />
• Delphi<br />
flex.AllowEditing := true;<br />
flex.Cols[2].AllowEditing := false; // prevent editing column 2<br />
Für mehr Details und Beispiele über Zellbearbeitung, schauen Sie bitte unter „Zellen bearbeiten“ (Seite<br />
37) nach.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
AllowFreezing-Eigenschaft<br />
Legt fest, ob der Nutzer Spalten und Zeilen mit der Maus fixieren darf.<br />
Syntax<br />
[VB]<br />
Public AllowFreezing As AllowFreezingEnum<br />
[C#]<br />
public AllowFreezingEnum AllowFreezing { get; set;}
[Delphi]<br />
property AllowFreezing: AllowFreezingEnum;<br />
Eigenschaftswerte<br />
Einer der AllowFreezingEnum-Werte. Der Standardwert ist AllowFreezingEnum.None.<br />
Bemerkungen<br />
AllowMerging-Eigenschaft · 121<br />
Eingefrorene Zellen bleiben an ihrer Stelle, wenn der Nutzer die Tabelle scrollt (wie fixierte Zellen),<br />
können aber weiterhin wie normale Zellen ausgewählt und bearbeitet werden (wie scrollbare Zellen).<br />
Diese Zellen werden mit dem Styles.Frozen-Style formatiert.<br />
Um Zeilen oder Spalten einzufrieren, muss der Mauszeiger an der Kante des einzufrierenden Bereichs<br />
stehen. Dieser wird sich dann in einen 'freeze'-Zeiger verwandeln (Sieht aus wie ein Vorhängeschloss), so<br />
dass der Nutzer die Grenze der eingefrorenen Zellen auf eine neue Zeile oder Spalte ziehen kann.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
AllowMerging-Eigenschaft<br />
Legt fest, ob Zellen mit ähnlichem Inhalt verbunden werden.<br />
Syntax<br />
[VB]<br />
Public AllowMerging As AllowMergingEnum<br />
[C#]<br />
public AllowMergingEnum AllowMerging {get; set;}<br />
[Delphi]<br />
property AllowMerging: AllowMergingEnum;<br />
Eigenschaftswerte<br />
Einer der AllowMergingEnum-Werte. Der Standardwert ist AllowMergingEnum.None.<br />
Wert Beschreibung<br />
None Zellen nicht verbinden.<br />
Free Angrenzende Zellen mit gleichem Inhalt verbinden.<br />
RestrictRows Zeilen verbinden, wenn die Zellen darüber auch verbunden sind.<br />
RestrictCols Spalten verbinden, wenn die Zellen links davon auch verbunden sind.<br />
RestrictAll Zellen verbinden, wenn die Zellen darüber und links davon auch verbunden sind.<br />
FixedOnly<br />
Nur fixierte Zellen verbinden. Diese Einstellung ist für komplexe Überschriften<br />
sinnvoll, ohne dabei die Datenzellen selbst zu verbinden.<br />
Spill Langen Einträgen erlauben, in leere, angrenzende Zellen überzugehen.<br />
Nodes<br />
Langen Einträgen in Knotenzeilen erlauben, in leere, angrenzende Zellen<br />
überzugehen.
122 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Bemerkungen<br />
Verbunde Zellen dienen dazu, Daten auf eine klare und ansprechende Weise anzuzeigen, indem<br />
Gruppen mit gleichen Informationen hervorgehoben werden. Somit sind Sie flexibel und können<br />
ähnliche Tabellen wie die, die Sie in HTML oder mit Microsoft Word (beide unterstützen verbundene<br />
Zellen) verwenden, erstellen.<br />
Um Tabellen mit verbundenen Zellen zu erstellen, müssen Sie die AllowMerging-Eigenschaft auf einen<br />
von AllowMergingEnum.None verschiedenen Wert, und die AllowMerging-Eigenschaft von den<br />
jeweiligen Zeilen und Spalten, die Sie verbinden wollen, auf TRUE setzen. Nachdem diese Eigenschaften<br />
gesetzt wurden, wird die Tabellensteuerung automatisch angrenzende Zellen mit gleichen Inhalten<br />
verbinden. Immer wenn sich die Tabelleninhalte verändern, aktualisiert die Tabelle die Verbindungen.<br />
Beispiel<br />
Durch den nachfolgenden Quellcode verbindet die Tabellensteuerung angrenzende Zellen mit gleichen<br />
Daten in Spalte 1:<br />
• Visual Basic<br />
• C#<br />
flex.AllowMerging = AllowMergingEnum.Free<br />
flex.Cols(1).AllowMerging = True ' merge values in column 1<br />
flex.AllowMerging = AllowMergingEnum.Free;<br />
flex.Cols[1].AllowMerging = true; // merge values in column 1<br />
• Delphi<br />
flex.AllowMerging := AllowMergingEnum.Free;<br />
flex.Cols[1].AllowMerging := true; // merge values in column 1<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
AllowResizing-Eigenschaft<br />
Legt fest, ob der Nutzer die Größe von Spalten und Zeilen mit der Maus verändern darf.<br />
Syntax<br />
[VB]<br />
Public AllowResizing As AllowResizingEnum<br />
[C#]<br />
public AllowResizingEnum AllowResizing {get; set;}<br />
[Delphi]<br />
property AllowResizing: AllowResizingEnum;<br />
Eigenschaftswerte<br />
Einer der AllowResizingEnum-Werte. Der Standardwert ist AllowResizingEnum.Columns.
Wert Beschreibung<br />
None Der Nutzer kann die Größe von Zeilen und Spalten nicht verändern.<br />
Columns<br />
ColumnsUniform<br />
Rows<br />
Both<br />
RowsUniform<br />
BothUniform<br />
Bemerkungen<br />
AllowResizing-Eigenschaft · 123<br />
Der Nutzer kann die Breite von Spalten verändern, indem er die Kanten der<br />
fixierten Spalten oben in der Tabelle entsprechend zieht. Ein Doppelklick auf die<br />
Kante der fixierten Zellen passt die Breite an deren breitesten Eintrag an.<br />
Der Nutzer kann die Breite einer Spalte mit der Maus verändern. Wenn die<br />
Größe einer Spalte verändert wurde, dann wird die neue Spaltenbreite auf alle<br />
Spalten angewendet.<br />
Der Nutzer kann die Höhe einer Zeile verändern, indem er die Kanten der<br />
fixierten Zeilen links in der Tabelle entsprechend zieht. Ein Doppelklick auf die<br />
Kante der fixierten Zellen passt die Höhe an deren höchsten Eintrag an.<br />
Der Nutzer kann die Höhe von Zeilen und die Breite von Spalten mit der Maus<br />
verändern.<br />
Der Nutzer kann die Höhe einer Zeile mit der Maus verändern. Wenn die Größe<br />
einer Zeile verändert wurde, dann wird die neue Zeilenhöhe auf alle Zeilen<br />
angewendet.<br />
Der Nutzer kann die Höhe von Zeilen und die Breite von Spalten mit der Maus<br />
verändern. Wenn die Größe einer Zeile oder Spalte verändert wurde, dann wird<br />
die neue Höhe oder Breite auf alle Zeilen oder Spalten angewendet.<br />
Um Zeilen oder Spalten in ihrer Größe zu verändern, muss der Mauszeiger über den fixierten Zellen der<br />
Tabelle und nahe einer Grenze zwischen Zeilen und Spalten stehen. Der Mauszeiger ändert sich dann zu<br />
einem Größenzeiger und der Nutzer kann die Zeilen und Spalten ziehen, um deren Höhe oder Breite zu<br />
verändern.<br />
Wenn eine Spaltengruppe ausgewählt wurde (von der ersten bis zur letzten Zeile) und der Nutzer die<br />
Größe einer Spalte davon verändert, dann werden alle ausgewählten Spalten ebenfalls angepasst. Das<br />
Gleiche gilt für Zeilen.<br />
Wenn die Anpassung der Größe für Spalten erlaubt ist, dann kann mit einem Doppelklick deren Breite<br />
automatisch an den längsten Eintrag der entsprechenden Spalte angepasst werden.<br />
Zeilen mit einer Höhe von Null und Spalten mit einer Breite von Null können vom Nutzer nicht mehr<br />
verändert werden. Wenn diese Zeilen und Spalten zwar sehr klein, aber immer noch veränderbar sein<br />
sollen, dann sollten Sie deren Höhe oder Breite auf einen Pixel stellen, und nicht Null.<br />
Die BeforeResizeRow- und BeforeResizeColumn-Ereignisse werden vor der Veränderung gestartet und<br />
können dazu verwendet werden, die Veränderung der Größe von bestimmten Zeilen und Spalten zu<br />
verhindern. Die AfterResizeRow- und AfterResizeColumn-Ereignisse werden nach der<br />
Größenanpassung gestartet und können für die Prüfung der Änderung oder das Aktualisieren der<br />
Anzeige verwendet werden.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)
124 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
AllowSorting-Eigenschaft (<strong>C1FlexGrid</strong>)<br />
Legt fest, ob der Nutzer Spalten mit der Maus sortieren darf.<br />
Syntax<br />
[VB]<br />
Public AllowSorting As AllowSortingEnum<br />
[C#]<br />
public AllowSortingEnum AllowSorting {get; set;}<br />
[Delphi]<br />
property AllowSorting: AllowSortingEnum;<br />
Eigenschaftswerte<br />
Einer der AllowSortingEnum-Werte. Der Standardwert ist AllowSortingEnum.SingleColumn.<br />
Wert Beschreibung<br />
None Der Nutzer kann Spalten nicht mit der Maus sortieren.<br />
SingleColumn<br />
MultiColumn<br />
Bemerkungen<br />
Der Nutzer kann Spalten mit der Maus sortieren. Klickt man auf die<br />
Spaltenüberschrift, so werden diese jeweils auf- oder absteigend sortiert.<br />
Diese Funktion ist gleich denen, die in den meisten Standardanwendungen, wie<br />
zum Beispiel Windows Explorer, zu finden sind.<br />
Der Nutzer kann Spalten mit der Maus sortieren. Klickt man auf die<br />
Spaltenüberschrift, so werden alle Spalten von der Ersten bis zur zuvor<br />
angeklickten auf- oder absteigend sortiert.<br />
Diese Einstellung ist sinnvoll, wenn die Daten nach Kategorien von links nach<br />
rechts gruppiert sind und Sie diese Gruppen trotz Sortierung erhalten wollen.<br />
Wenn sich die Tabelle im gebundenen Modus befindet, so wird die Sortierung in der darunterliegenden<br />
Datentabelle vorgenommen.<br />
Wenn die Tabelle ungebunden ist, können Sie die Daten auch mit der Sort-Methode sortieren.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109 )<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
AutoClipboard-Eigenschaft<br />
Gibt zurück oder legt fest, ob die Tabelle die Zwischenablagefunktionen steuern soll und automatisch die<br />
Operationen Ausschneiden, Kopieren, Einfügen und Löschen durchführen soll.<br />
Syntax<br />
[VB]
Public AutoClipboard As Boolean<br />
[C#]<br />
public bool AutoClipboard {get; set;}<br />
[Delphi]<br />
property AutoClipboard: Boolean;<br />
Bemerkungen<br />
AutoGenerateColumns-Eigenschaft · 125<br />
Wenn Sie diese Eigenschaft auf TRUE setzen, dann überwacht die Tabellensteuerung die Tastatur für die<br />
folgenden Tastenkombinationen:<br />
Zwischenablagenoperation Tastenkombination<br />
Kopieren Strg-Einfügen (Einfg), Strg-C<br />
Ausschneiden Strg-X, Shift-Entfernen (Entf)<br />
Einfügen Strg-V, Shift- Einfügen (Einfg)<br />
Löschen Entfernen (Entf)<br />
Die Operationen Einfügen, Ausschneiden und Löschen werden nur ausgeführt, wenn die AllowEditing-<br />
Eigenschaft auf TRUE gesetzt ist.<br />
Wenn Sie nur einen Teil der unterstützten Tastenkombinationen zur Verfügung stellen wollen, dann<br />
können Sie einen entsprechenden Ereignisabwickler dem KeyDown-Ereignis hinzufügen und die<br />
Handled-Parameter auf TRUE setzen um einige der Tastenkombinationen zu deaktivieren.<br />
Die automatischen Zwischenablageoperationen betreffen nur die Tabellendaten. Formate und Bilder<br />
werden weder mit kopiert, noch eingefügt oder gelöscht.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
AutoGenerateColumns-Eigenschaft<br />
Legt fest, ob die Tabelle ihre Spalten aktualisiert, wenn sie einer neuen Datenquelle zugeordnet wurde.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft AutoGenerateColumns As Boolean<br />
[C#]<br />
public bool AutoGenerateColumns {get; set;}<br />
[Delphi]<br />
property AutoGenerateColumns: Boolean;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)
126 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
AutoResize-Eigenschaft<br />
Gibt zurück oder legt fest, ob die Spaltenbreiten automatisch angepasst werden, wenn Daten geladen<br />
werden.<br />
Syntax<br />
[VB]<br />
Public AutoResize As Boolean<br />
[C#]<br />
public bool AutoResize {get; set;}<br />
[Delphi]<br />
property AutoResize: Boolean;<br />
Bemerkungen<br />
Diese Eigenschaft funktioniert nur, wenn die Tabelle an eine Datenquelle gebunden ist. Wenn AutoResize<br />
auf TRUE steht, dann passt die Tabellensteuerung beim Laden neuer Daten die Spaltenbreiten<br />
automatisch an den breitesten Eintrag an.<br />
Sie können weiterhin die Spaltenbreiten im Quelltext mit der AutoSizeCols-Methode anpassen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
AutoSearch-Eigenschaft<br />
Legt fest, ob die Tabelle den Cursor bewegen soll, wenn diese nach Einträgen sucht, während der Nutzer<br />
tippt.<br />
Syntax<br />
[VB]<br />
Public AutoSearch As AutoSearchEnum<br />
[C#]<br />
public AutoSearchEnum AutoSearch {get; set;}<br />
[Delphi]<br />
property AutoSearch: AutoSearchEnum;<br />
Eigenschaftswerte<br />
Einer der AutoSearchEnum-Werte. Der Standardwert ist AutoSearchEnum.None.<br />
Bemerkungen<br />
Wenn AutoSearch eingeschaltet ist, dann durchsucht die Tabelle automatisch die aktuelle Spalte nach<br />
dem Wert, den der Nutzer gerade eingibt, indem diese den Cursor bewegt und die Übereinstimmungen<br />
mit dem Styles.Search-Zellformat markiert. Die Suche berücksichtigt Groß- und Kleinschreibung und<br />
wird abgebrochen, wenn der Nutzer die Escape-Taste drückt oder die Auswahl mit der Maus oder den<br />
Pfeiltasten bewegt.
AutoSearchDelay-Eigenschaft · 127<br />
Hört der Nutzer kurz auf zu schreiben, so wird der Suchpuffer zurückgesetzt. Die Zeitspanne bis zum<br />
Zurücksetzen des Puffers kann durch die AutoSearchDelay-Eigenschaft festgelegt werden.<br />
Wenn AutoSearch eingeschaltet ist und die AllowEditing-Eigenschaft auf TRUE steht, so muss der<br />
Nutzer die Enter-, Leer- oder F2-Taste drücken um die Zelle zu bearbeiten. Andere Tasten werden für die<br />
Suche verwendet.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
AutoSearchDelay-Eigenschaft<br />
Legt die zu verstreichende Zeit fest (in Sekunden), bevor der AutoSearch-Puffer zurückgesetzt wird.<br />
Syntax<br />
[VB]<br />
Public AutoSearchDelay As double<br />
[C#]<br />
public double AutoSearchDelay {get; set;}<br />
[Delphi]<br />
property AutoSearchDelay: Double;<br />
Bemerkungen<br />
Schauen Sie unter der AutoSearch-Eigenschaft nach.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
BottomRow-Eigenschaft<br />
Gibt die letzte, sichtbare Zeile einer Tabelle zurück.<br />
Syntax<br />
[VB]<br />
Public BottomRow As Integer<br />
[C#]<br />
public int BottomRow {get;}<br />
[Delphi]<br />
property BottomRow: Integer;<br />
Bemerkungen<br />
Die zurückgegebene unterste Zeile ist vielleicht nur teilweise auf dem Bildschirm sichtbar.<br />
Sie können diese Eigenschaft nicht festlegen. Um die Inhalte der Tabelle mit Quelltext zu scrollen,<br />
verwenden Sie die TopRow- und LeftCol-Eigenschaften. Verwenden Sie die ShowCell-Methode, um<br />
sicherzustellen, dass eine gegebene Zelle auf dem Bildschirm angezeigt wird.
1<strong>28</strong> · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
BorderStyle-Eigenschaft<br />
Gibt/legt den Rahmen-Stil der Steuerung zurück/fest.<br />
Syntax<br />
[VB]<br />
Public BorderStyle As BorderStyleEnum<br />
[C#]<br />
public BorderStyleEnum BorderStyle {get; set;}<br />
[Delphi]<br />
property BorderStyle: BorderStyleEnum;<br />
Eigenschaftswerte<br />
Einer der BorderStyleEnum-Werte. Der Standardwert ist BorderStyleEnum.Fixed3D.<br />
Bemerkungen<br />
Zusätzlich zu den Standardeinstellungen FixedSingle und Fixed3D, können Sie den Light3D-Rahmen<br />
verwenden, der ein Pixel breit ist.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
CellButtonImage-Eigenschaft<br />
Legt die Grafik auf einer Zellschaltfläche fest.<br />
Syntax<br />
[VB]<br />
Public CellButtonImage As Image<br />
[C#]<br />
public Image CellButtonImage {get; set;}<br />
[Delphi]<br />
property CellButtonImage: Image;<br />
Bemerkungen<br />
Mit dieser Eigenschaft können Sie das Aussehen der Zellschaltflächen anpassen. Für Details über die<br />
Handhabung von Zellschaltflächen, schauen Sie bitte unter CellButtonClick-Ereignis nach.<br />
Wenn Sie nur eine Grafik für alle Zellschaltflächen in der Tabelle verwenden wollen, dann ordnen Sie<br />
diese der CellButtonImage-Eigenschaft während der Designtime zu. Um die Grafiken je nach Spalte,<br />
Zeile oder zu bearbeitender Zelle zu verändern, fangen Sie das BeforeEdit-Ereignis ab und legen Sie das<br />
entsprechende Bild fest.
Clip-Eigenschaft · 129<br />
Die für die Zellschaltflächen verwendete Grafik sollte auf die Schaltfläche passen (größere Grafiken<br />
werden beschnitten). Diese sollten auch transparent sein, so dass die Schaltflächenoberfläche durch die<br />
leeren Stellen der Grafik zu sehen ist. Für das beste Ergebnis, verwenden Sie kleine Symbole (16x16 Pixel)<br />
und zeichnen Sie das Bild in das obere linke 12x12-Rechteck innerhalb des Symbols.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109 )<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Clip-Eigenschaft<br />
Gibt/legt den Inhalt eines Zellbereichs zurück/fest.<br />
Syntax<br />
[VB]<br />
Public Clip As String<br />
[C#]<br />
public string Clip {get; set;}<br />
[Delphi]<br />
property Clip: string;<br />
Bemerkungen<br />
Der Eintrag, welcher der Clip-Eigenschaft zugeordnet oder von dieser zurückgegeben wird, kann<br />
mehrere Zellen umfassen. Standardmäßig stehen Tabulatorzeichen (\t) für eine neue Spalte und<br />
Zeilenumschalterzeichen (\n) für Zeilenumbrüche.<br />
Die Standard-Zeilen- und -Spaltenabgrenzer können in der ClipSeparators-Eigenschaft geändert werden.<br />
Wenn eine Zeichenkette der Clip-Eigenschaft zugeordnet ist, dann sind nur die ausgewählten Zellen<br />
betroffen. Wenn sich noch weitere Zellen neben denen, die im Clip-Eintrag gespeichert sind, in der<br />
Auswahl befinden, dann werden diese ignoriert. Wenn im Clip-Eintrag mehr Zellen beschrieben werden,<br />
als in der Auswahlregion vorhanden sind, dann wird der überschüssige Teil des Clip-Eintrags ebenfalls<br />
ignoriert. Leere Clip-Einträge löschen die aktuellen Inhalte der Zellen.<br />
Das nachfolgende Beispiel schreibt Text in einen ausgewählten Bereich, zwei Zeilen hoch und zwei<br />
Spalten breit:<br />
• Visual Basic<br />
• C#<br />
' build clip string<br />
Dim s As String = "1st" + vbTab + "a" +vbLf + "2nd" +vbTab + "b"<br />
' paste it over current selection<br />
flex.Clip = s<br />
// build clip string<br />
string s = "1st" + "\t" + "a" + "\n" + "2nd" + "\t" + "b";<br />
// paste it over current selection<br />
flex.Clip = s;
130 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
• Delphi<br />
var<br />
s: string;<br />
begin<br />
s := '1st' + #9 + 'a' + #10 + '2nd' + #9 + 'b';<br />
flex.Clip := s;<br />
end;<br />
Sie können den Clip-Eintrag auch für jede willkürliche Auswahl (nicht zwingend ausgewählt) mit einem<br />
CellRange-Objekt abrufen oder festlegen. Zum Beispiel:<br />
• Visual Basic<br />
• C#<br />
' build clip string<br />
Dim rg As CellRange = flex.GetCellRange(1, 1, 10, 10)<br />
MessageBox.Show(rg.Text)<br />
// build clip string<br />
CellRange rg = flex.GetCellRange(1,1,10,10);<br />
MessageBox.Show(rg.Text);<br />
• Delphi<br />
var<br />
rg: CellRange;<br />
begin<br />
rg := flex.GetCellRange(1, 1, 10, 10);<br />
MessageBox.Show(rg.Text);<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
ClipSeparators-Eigenschaft<br />
Gibt/legt die Trennzeichen für Zeilen und Spalten im Clip-Eintrag zurück/fest.<br />
Syntax<br />
[VB]<br />
Public ClipSeparators As String<br />
[C#]<br />
public string ClipSeparators {get; set;}<br />
[Delphi]<br />
property ClipSeparators: string;<br />
Bemerkungen<br />
Schauen Sie auch unter Clip-Eigenschaft nach.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)
Col-Eigenschaft<br />
Gibt/legt den Index einer ausgewählten Spalte zurück/fest.<br />
Syntax<br />
[VB]<br />
Public Col As Integer<br />
[C#]<br />
public int Col {get; set;}<br />
[Delphi]<br />
property Col: Integer;<br />
Bemerkungen<br />
Col-Eigenschaft · 131<br />
Verwenden Sie die Row- und Col-Eigenschaften um eine Zelle aktuell zu machen, oder herauszufinden,<br />
in welcher Zeile oder Spalte sich die aktuelle Zelle befindet. Spalten und Zeilen werden von Null an,<br />
beginnend von der obersten Zeile und der linken Spalte nummeriert.<br />
Die Col-Eigenschaft kann auf -1, um die Auswahl auszublenden, oder auf einen Wert zwischen Null und<br />
Cols.Fixed-1 gesetzt werden, um eine Zelle in einer fixierten Spalte auszuwählen. Sie kann auch auf einen<br />
Wert zwischen Cols.Fixed und Cols.Count-1 gesetzt werden, um eine scrollbare Spalte auszuwählen.<br />
Indem man die Row- und Col-Eigenschaften setzt, wird die Auswahl automatisch auf eine einzelne Zelle<br />
beschränkt und damit die Eigenschaften RowSel und ColSel zurückgesetzt. Um eine Blockauswahl<br />
vorzunehmen, müssen Sie zuerst Row und Col und dann RowSel und ColSel festlegen. Oder Sie<br />
verwenden die Select-Methode, um eine willkürliche Auswahl mit einem einzigen Befehl vorzunehmen.<br />
Indem die Row- und Col-Eigenschaften gesetzt werden, kann nicht sichergestellt werden, dass die Zelle<br />
auf dem Bildschirm sichtbar ist. Um dies zu tun, müssen Sie die ShowCell-Methode anwenden.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
Cols-Eigenschaft<br />
Gibt alle Spalten einer Tabelle zurück.<br />
Syntax<br />
[VB]<br />
Public Cols As ColumnCollection<br />
[C#]<br />
public ColumnCollection Cols {get;}<br />
[Delphi]<br />
property Cols: ColumnCollection;<br />
Bemerkungen<br />
Mit der Cols-Eigenschaft können Sie eine Liste mit allen derzeit vorhandenen Spalten in einer Tabelle<br />
abfragen. Mit dieser Referenz können Sie Spalten hinzufügen, entfernen, verschieben und zählen. Für
132 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
weitere Informationen über die Funktionen dieser Sammlung, schauen Sie in den Referenzthemen der<br />
ColumnCollection-Klasse nach.<br />
Diese Eigenschaft kann nur gelesen werden. Die Tabelle erstellt und verwaltet diese Liste/Sammlung.<br />
Upgradenotiz: In der VSFlexGrid-ActiveX-Steuerung zeigen die Cols- und FixedCols-Eigenschaften die<br />
Anzahl der Spalten und der fixierten Spalten in einer Tabelle. Verwenden Sie in <strong>C1FlexGrid</strong> Cols.Count<br />
und Cols.Fixed hierfür.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
ColSel-Eigenschaft<br />
Gibt/legt den Index der letzten Spalte in der aktuellen Auswahl zurück/fest.<br />
Syntax<br />
[VB]<br />
Public ColSel As Integer<br />
[C#]<br />
public int ColSel {get; set;}<br />
[Delphi]<br />
property ColSel: Integer;<br />
Bemerkungen<br />
Verwenden Sie die RowSel- und ColSel-Eigenschaften um eine Auswahl zu verändern oder um zu<br />
bestimmen, welche Zellen gerade ausgewählt sind. Spalten und Zeilen werden von Null an, beginnend<br />
von der obersten Zeile und der linken Spalte numeriert.<br />
Indem man die Row- und Col-Eigenschaften setzt, wird die Auswahl automatisch auf eine einzelne Zelle<br />
beschränkt und damit die Eigenschaften RowSel und ColSel zurückgesetzt. Um eine Blockauswahl<br />
vorzunehmen, müssen Sie zuerst Row und Col und dann RowSel und ColSel festlegen. Oder Sie<br />
verwenden die Select-Methode, um eine willkürliche Auswahl mit einem einzigen Befehl vorzunehmen.<br />
Wenn ein Bereich ausgewählt ist, dann kann der Wert von Row oder Col größer oder kleiner als der von<br />
RowSel oder ColSel sein. Dies ist recht lästig, wenn Sie Grenzen für Schleifen setzen wollen. In diesen<br />
Fällen können Sie die Selection-Eigenschaft verwenden, um ein normalisiertes CellRange-Objekt<br />
abzufragen, indem r1
• C#<br />
Next c<br />
Next r<br />
ComboList-Eigenschaft · 133<br />
CellRange rg = flex.Selection;<br />
for (int r = rg.r1; r
134 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
• C#<br />
flex.ComboList = "ListItem 1|ListItem 2"<br />
flex.ComboList = "ListItem 1|ListItem 2";<br />
• Delphi<br />
flex.ComboList := 'ListItem 1|ListItem 2';<br />
3. Setzen Sie die ComboList-Eigenschaft auf eine Zeichenkette mit den zur Verfügung stehenden<br />
Optionen, getrennt und beginnend mit einem Senkrechtstrich ("|"), um die Zelle mit einer<br />
Auswahlkombinationsliste zu bearbeiten. Zum Beispiel:<br />
• Visual Basic<br />
• C#<br />
flex.ComboList = "|ComboItem 1|ComboItem 2"<br />
flex.ComboList = "|ComboItem 1|ComboItem 2";<br />
• Delphi<br />
flex.ComboList := '|ComboItem 1|ComboItem 2';<br />
4. Um eine Bearbeitungsschaltfläche anzuzeigen, müssen Sie die ComboList-Eigenschaft auf eine<br />
Zechenkette mit einer Ellipsis („...“) setzen. Bearbeitungsschaltflächen sehen wie ganz normale<br />
Schaltflächen aus, die rechts in der Zelle stehen, und besitzen drei Punkte (Ellipsis) als Aufdruck.<br />
Wenn der Nutzer auf diese klickt, startet die Tabelle das CellButtonClick-Ereignis. In diesem<br />
Fall kann der Nutzer den Zellinhalt nicht direkt bearbeiten. Zum Beispiel:<br />
• Visual Basic<br />
• C#<br />
flexComboList = "..."<br />
flexComboList = "...";<br />
• Delphi<br />
flexComboList := '...';<br />
5. Um eine Bearbeitungsschaltfläche neben einer bearbeitbaren Zelle anzuzeigen, müssen Sie die<br />
ComboList-Eigenschaft auf eine Zeichenkette mit einem Senkrechtstrich und der Ellipsis ("|...")<br />
setzen. In diesem Fall erhalten Sie eine gewöhnliche Bearbeitungsschaltfläche, aber der Nutzer<br />
kann außerdem den Zellinhalt direkt bearbeiten. Zum Beispiel:<br />
• Visual Basic<br />
• C#<br />
flexComboList = "|..."<br />
flexComboList = "|...";<br />
• Delphi<br />
flexComboList := '|...';<br />
Die ComboList-Eigenschaft ist in solchen Fällen besonders sinnvoll, in denen Zeilen in der selben Spalte<br />
verschiedene Datentypen enthalten (zum Beispiel eine Steuerung wie die Microsoft-PropertyGrid). In<br />
diesem Fall können Sie den für die aktuelle Zeile entsprechenden Bearbeitungstyp in der ComboList-<br />
Eigenschaft anpassen.
CursorCell-Eigenschaft · 135<br />
Verwenden Sie die ComboList-Eigenschaft der Spalte, wenn alle Zeilen in einer Spalte den gleichen<br />
Datentyp verwenden. Auf diesem Wege wählt die Tabellensteuerung automatisch die entsprechende<br />
ComboList für die Spalte aus und Sie müssen keinerlei Ereignisse bearbeiten.<br />
Beispiel<br />
Der nachfolgende Quellcode fängt das BeforeEdit-Ereignis ab und ordnet der ComboList-Eigenschaft<br />
einen Wert zu, so dass die Tabellensteuerung verschiedene Schaltflächen in jeder Zeile anzeigt.<br />
• Visual Basic<br />
• C#<br />
Private Sub _flex_BeforeEdit(sender As Object, e As RowColEventArgs)<br />
_flex.ComboList = ""<br />
If e.Row Mod 2 = 0 Then<br />
flex.ComboList = "..."<br />
Else<br />
flex.ComboList = ""<br />
End If<br />
End Sub '_flex_BeforeEdit<br />
private void _flex_BeforeEdit(object sender, RowColEventArgs e)<br />
{<br />
_flex.ComboList = (e.Row % 2 == 0)? "..." : "";<br />
}<br />
• Delphi<br />
procedure _flex_BeforeEdit(sender: System.Object; e: RowColEventArgs);<br />
begin<br />
_flex.ComboList := '';<br />
If (e.Row Mod 2) = 0 Then<br />
flex.ComboList = '...'<br />
Else<br />
flex.ComboList = '';<br />
end; //_flex_BeforeEdit<br />
Für mehr Details und Beispiele über Zellbearbeitung, schauen Sie bitte unter „Zellen bearbeiten“ (Seite<br />
37) nach.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
CursorCell-Eigenschaft<br />
Gibt ein CellRange-Objekt zurück, dass die Ankerzelle in der aktuellen Auswahl mit den Koordinaten<br />
Row, Col enthält.<br />
Syntax<br />
[VB]<br />
Public CursorCell As CellRange<br />
[C#]<br />
public CellRange CursorCell {get;}<br />
[Delphi]<br />
property CursorCell: CellRange;
136 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Eigenschaftswerte<br />
Ein CellRange-Objekt, das für die Veränderung eines Zellbereiches verwendet werden kann.<br />
Bemerkungen<br />
Verwenden Sie die Selection-Eigenschaft, um ein CellRange-Objekt über die gesamte Auswahl zu<br />
erhalten (definiert durch die Row, Col, RowSel und ColSel-Eigenschaften).<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
CustomComparer-Eigenschaft<br />
Gibt/legt ein benutzerdefiniertes IComparer-Objekt, dass von der Tabelle für Gruppierung,<br />
Zellverbindung und Suchoperationen verwendet wird, zurück/fest<br />
Syntax<br />
[VB]<br />
Public CustomComparer As IComparer<br />
[C#]<br />
public IComparer CustomComparer {get;set;}<br />
[Delphi]<br />
property CustomComparer: IComparer;<br />
Bemerkungen<br />
Die Tabelle besitzt eine IComparer-Standardimplementation, die für Vergleiche zwischen Zellen<br />
verwendet wird, um zu bestimmen, ob diese den gleichen Inhalt besitzen. Diese Implementation wird für<br />
Zellverbindungen, Zellgruppierungen und für die Suche nach Werten verwendet (Schauen Sie ebenfalls<br />
unter der AllowMerging-Eigenschaft und den Subtotal- und FindRow-Methoden nach).<br />
Die Standardimplementation berücksichtigt sowohl Groß- und Kleinschreibung als auch voran- oder<br />
nachstehende Leerzeichen.<br />
Wenn Sie in den Vergleichen für Zellverbindungen Groß- und Kleinschreibung berücksichtigt wollen,<br />
Leerzeichen aber nicht, dann müssen Sie eine eigene Klasse schreiben, die den IComparer implementiert,<br />
und diese der CustomComparer-Eigenschaft zuordnen.<br />
Setzen Sie diese Eigenschaft auf Null (Nothing in Visual Basic), um das Standardverhalten<br />
wiederherzustellen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
DataMember-Eigenschaft<br />
Gibt/legt eine bestimmte Liste eines DataSource-Objekts, das die Tabelle anzeigen soll, zurück/fest.<br />
Syntax<br />
[VB]
Public DataMember As String<br />
[C#]<br />
public string DataMember {get;set;}<br />
[Delphi]<br />
property DataMember: string;<br />
Bemerkungen<br />
DataSource-Eigenschaft (<strong>C1FlexGrid</strong>) · 137<br />
Wenn eine DataSource mehrere Datenquellen (Tabellen) enthält, dann sollten Sie die DataMember-<br />
Eigenschaft auf eine bestimmte Quelle festsetzen. Zum Beispiel, wenn die DataSource ein DataSet oder<br />
DataViewManager ist, der drei Tabellen mit den Namen Customers, Orders und OrderDetails enthält,<br />
dann müssen Sie eine Tabelle festlegen, an die Sie Ihre Tabelle binden möchten. Wenn die DataSet oder<br />
DataViewManager nur eine DataTable beinhaltet, dann können Sie die DataMember-Eigenschaft leer<br />
lassen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
DataSource-Eigenschaft (<strong>C1FlexGrid</strong>)<br />
Gibt/legt die Datenquelle der Steuerung zurück/fest.<br />
Syntax<br />
[VB]<br />
Public DataSource As object<br />
[C#]<br />
public object DataSource {get; set;}<br />
[Delphi]<br />
property DataSource: object;<br />
Bemerkungen<br />
Die folgenden ADO.NET-Datenquellen sind gültig: DataTable, DataView, DataSet, DataViewManager.<br />
Die folgenden <strong>ComponentOne</strong> DataObjects-Komponenten sind ebenfalls gültige Datenquellen:<br />
C1ExpressTable, C1ExpressVew, C1ExpressConnection, C1DataView, C1DataTableSource und<br />
C1DataSet.<br />
Wenn die DataSource-Referenz mehr als nur eine Tabelle enthält, dann müssen Sie in der DataMember-<br />
Eigenschaft die entsprechende Tabelle festlegen, zu der Sie verbinden möchten. Zum Beispiel, wenn die<br />
DataSource ein DataSet oder DataViewManager ist, der drei Tabellen mit den Namen Customers, Orders<br />
und OrderDetails enthält, dann müssen Sie eine Tabelle festlegen, an die Sie Ihre Tabelle binden möchten.<br />
Sie können auch ein weiteres <strong>C1FlexGrid</strong>-Objekt der DataSource-Eigenschaft zuordnen. In diesem Fall<br />
werden die Steuerungen sich das gleiche Tabellenmodel, inklusive der Daten, Anzeigeformate,<br />
Auswahlen, usw., teilen. Dies kann dazu verwendet werden, um geteilte Ansichten zu implementieren,<br />
wobei verschiedene Steuerungen verschiedene Teile der Daten anzeigen.<br />
Beispiel
138 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Dieser Quelltext bindet die Tabelle an eine ADO.NET-Datenquelle:<br />
• Visual Basic<br />
• C#<br />
' replace with actual connection string<br />
Dim conn As String = "<br />
Provider=Microsoft.Jet.OLEDB.4.0;UserID=Admin;... "<br />
'<br />
Dim rs As String = "select * from customers"<br />
Dim da As New OleDbDataAdapter(rs, conn)<br />
Dim ds As New DataSet()<br />
da.Fill(ds)<br />
flex.DataSource = ds.Tables(0)<br />
// replace with actual connection string<br />
string conn = @"Provider=Microsoft.Jet.OLEDB.4.0; User ID=Admin; ...";<br />
string rs = "select * from customers";<br />
OleDbDataAdapter da = new OleDbDataAdapter(rs, conn);<br />
DataSet ds = new DataSet();<br />
da.Fill(ds);<br />
flex.DataSource = ds.Tables[0];<br />
• Delphi<br />
var<br />
ds: DataSet;<br />
da: OleDbDataAdapter;<br />
rs: string;<br />
conn: string;<br />
begin<br />
conn := 'Provider=Microsoft.Jet.OLEDB.4.0;Password="";User ID=Admin;<br />
...';<br />
rs := 'select * from customers';<br />
da := OleDbDataAdapter.Create(rs, conn);<br />
ds := DataSet.Create;<br />
da.Fill(ds);<br />
flex.DataSource := ds.Tables[0];<br />
end;<br />
Dieser Quelltext bindet zwei Tabellen (fgLeft und fgRight) zusammen und synchronisiert deren<br />
vertikalen Bildlauf (Die Nutzer können nur noch horizontal unabhängig scrollen).<br />
• Visual Basic<br />
• C#<br />
' bind grids together<br />
fgRight.DataSource = fgLeft<br />
fgLeft.ScrollBars = ScrollBars.Horizontal<br />
' synchronize vertical scrolling<br />
Private Sub flex_AfterScroll(sender As Object,<br />
e As C1.Win.<strong>C1FlexGrid</strong>.RangeEventArgs)<br />
Dim fg As <strong>C1FlexGrid</strong> = CType(sender, <strong>C1FlexGrid</strong>)<br />
fg.Update()<br />
Dim y As Integer = fg.ScrollPosition.Y<br />
If fg = fgLeft Then<br />
fgRight.ScrollPosition = New Point(fgRight.ScrollPosition.X, y)<br />
Else<br />
fgLeft.ScrollPosition = New Point(fgLeft.ScrollPosition.X, y)<br />
End If<br />
End Sub<br />
// bind grids together
fgRight.DataSource = fgLeft;<br />
fgLeft.ScrollBars = ScrollBars.Horizontal;<br />
DoubleBuffer-Eigenschaft · 139<br />
// synchronize vertical scrolling<br />
private void flex_AfterScroll(object sender,<br />
C1.Win.<strong>C1FlexGrid</strong>.RangeEventArgs e)<br />
{<br />
<strong>C1FlexGrid</strong> fg = (<strong>C1FlexGrid</strong>)sender;<br />
fg.Update();<br />
int y = fg.ScrollPosition.Y;<br />
if (fg == fgLeft)<br />
fgRight.ScrollPosition = new Point(fgRight.ScrollPosition.X,<br />
y);<br />
else<br />
fgLeft.ScrollPosition = new Point(fgLeft.ScrollPosition.X, y);<br />
}<br />
}<br />
• Delphi<br />
// bind grids together<br />
fgRight.DataSource := fgLeft;<br />
fgLeft.ScrollBars := ScrollBars.Horizontal;<br />
procedure Class1.flex_AfterScroll(sender: System.Object; e:<br />
C1.Win.<strong>C1FlexGrid</strong>.RangeEventArgs);<br />
var<br />
y: Integer;<br />
fg: <strong>C1FlexGrid</strong>;<br />
begin<br />
fg := <strong>C1FlexGrid</strong>(sender);<br />
fg.Update;<br />
y := fg.ScrollPosition.Y;<br />
if (fg = fgLeft) then<br />
fgRight.ScrollPosition := Point.Create(fgRight.ScrollPosition.X, y)<br />
else<br />
fgLeft.ScrollPosition := Point.Create(fgLeft.ScrollPosition.X, y);<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
DoubleBuffer-Eigenschaft<br />
Wenn diese Eigenschaft auf TRUE steht, dann wird die Tabelle in einem Puffer gezeichnet und danach<br />
das Ergebnis auf dem Bildschirm ausgegeben. Damit wird mögliches Flackern verhindert, wenn die<br />
Tabelle von der Steuerung erneut gezeichnet wird.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft DoubleBuffer As Boolean<br />
[C#]<br />
public Bool DoubleBuffer {get; set;}<br />
[Delphi]<br />
property DoubleBuffer: Boolean;
140 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Eigenschaftswerte<br />
Mitglied der C1.Win.<strong>C1FlexGrid</strong>.<strong>C1FlexGrid</strong>Base<br />
Bemerkungen<br />
Setzen Sie DoubleBuffer nicht auf FALSE, wenn die Tabelle folgendes besitzt:<br />
• Verbundene Zellen, oder<br />
• Transparente Bereiche, oder<br />
• Ein Hintergrundbild.<br />
Unter Einsatz von Anwendungen, die auf Terminalserven laufen, können Sie DoubleBuffer für eine<br />
Leistungssteigerung auf FALSE setzen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>Base<br />
DragMode-Eigenschaft<br />
Gibt/legt einen Wert, der festlegt, ob der Nutzer Daten aus der Steuerung ziehen kann, zurück/fest.<br />
Syntax<br />
[VB]<br />
Public DragMode As DragModeEnum<br />
[C#]<br />
public DragModeEnum DragMode {get; set;}<br />
[Delphi]<br />
property DragMode: DragModeEnum;<br />
Eigenschaftswerte<br />
Einer der DragModeEnum-Werte.<br />
Bemerkungen<br />
Mit dieser Eigenschaft können Sie die Steuerung als Quelle für OLE-Drag-Drop-Operationen verwenden.<br />
Wenn diese auf einen der automatischen Werte gesetzt ist, dann stellt die Steuerung folgende Funktionen<br />
zur Verfügung:<br />
1. Bemerken, wenn die Maus nah der Kante einer ausgewählten Zelle oder einer Auswahl steht und<br />
den OLE-Ziehcursor anzeigen.<br />
2. Wenn der Nutzer mit der Maus klickt, während der OLE-Ziehcursor angezeigt wird, dann wird<br />
die Ziehoperation mit einem Objekt der aktuellen Auswahl initialisiert.<br />
Im manuellen Modus ist der Programmierer für die Initialisierung der Drag-Drop-Operationen mit der<br />
System.Windows.Forms.Control.DoDragDrop-Methode verantwortlich.<br />
Schauen Sie ferner unter<br />
DropMode-Eigenschaft (Seite 141)
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
DrawMode-Eigenschaft<br />
Legt fest, ob Sie benutzerdefiniertes Zeichnen für Tabellenzellen bereitstellen wollen.<br />
Syntax<br />
[VB]<br />
Public DrawMode As DrawModeEnum<br />
[C#]<br />
public DrawModeEnum DrawMode {get; set;}<br />
[Delphi]<br />
property DrawMode: DrawModeEnum;<br />
Eigenschaftswerte<br />
Einer der DrawModeEnum-Werte. Der Standardwert ist DrawModeEnum.Default.<br />
Bemerkungen<br />
DrawMode-Eigenschaft · 141<br />
Wenn Sie diese Eigenschaft auf DrawModeEnum OwnerDraw setzen, dann wird die Tabelle das<br />
OwnerDrawCell-Ereignis starten. Sie können dieses Ereignis abfangen und die Art und Weise anpassen,<br />
wie die Zelle gezeichnet wird, indem Sie deren Inhalt oder Format direkt, oder indem Sie das Zeichnen<br />
selbst in die Hand nehmen, verändern.<br />
Für mehr Details und Beispiele, schauen Sie unter OwnerDrawCell-Ereignis nach.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
DropMode-Eigenschaft<br />
Gibt/legt einen Wert zurück/fest, der festlegt, ob die Steuerung Daten akzeptiert, die der Nutzer auf die<br />
Tabelle zieht.<br />
Syntax<br />
[VB]<br />
Public DropMode As DropModeEnum<br />
[C#]<br />
public DropModeEnum DropMode {get; set;}<br />
[Delphi]<br />
property DropMode: DropModeEnum;<br />
Eigenschaftswerte<br />
Einer der DropModeEnum-Werte.<br />
Bemerkungen<br />
Mit dieser Eigenschaft können Sie die Steuerung als Ziel der OLE-Drag-Drop-Operationen nutzen.
142 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Wenn sie auf None gesetzt ist (Standardwert), dann agiert die Steuerung nicht als Drop-Ziel.<br />
Wenn sie auf Manual gesetzt ist, dann startet die Steuerung die Standardereignisse Drag-Drop und der<br />
Programmierer muss diese abfangen. Die betreffenden Hauptereignisse sind DragOver und DragDrop.<br />
Diese Ereignisse werden vom Standardobjekt System.Windows.Forms.Control bereitgestellt.<br />
Wenn sie auf Automatic gesetzt ist, dann behandelt die Steuerung die Ereignisse DragOver und<br />
DragDrop automatisch, indem die folgenden Maßnahmen ausgeführt werden:<br />
1. Fragt das data-Objekt nach Daten im Text- oder Dateinamenformat.<br />
2. Scrollt, wenn der Nutzer ein Objekt nah der Kante der Steuerung zieht.<br />
3. Fügt den Inhalt des data-Objekts ein, wenn der Nutzer gültige Daten in der Tabelle fallen lässt.<br />
NOTE: Diese Eigenschaft erweitert und ersetzt die AllowDrop-Eigenschaft, die vom Basisobjekt<br />
Windows.Forms.Control bereitgestellt wird.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
EditMask-Eigenschaft (<strong>C1FlexGrid</strong>)<br />
Gibt/legt die Eingabemaske zurück/fest, wenn Zellen bearbeitet werden.<br />
Syntax<br />
[VB]<br />
Public EditMask As String<br />
[C#]<br />
public string EditMask {get; set;}<br />
[Delphi]<br />
property EditMask: string;<br />
Bemerkungen<br />
Mit der EditMask-Eigenschaft können Sie eine Eingabemaske festlegen, welche die Eingabe automatisch<br />
formatiert und auf Gültigkeit prüft. Die Maskensyntax ist ähnlich der von der Microsoft MaskedEdit<br />
ActiveX-Steuerung und von Microsoft Access verwendeten und wird nachfolgend beschrieben.<br />
Setzen Sie die EditMask-Eigenschaft als Antwort auf das BeforeEdit-Ereignis, genauso wie Sie die<br />
ComboList-Eigenschaft setzen würden.<br />
Wenn dieselbe Maske für alle Werte in einer Spalte verwendet wird, dann verwenden Sie die EditMask-<br />
Eigenschaft der entsprechenden Spalte. Dies vereinfacht den Quellcode, da Sie das BeforeEdit-Ereignis<br />
nicht abfangen müssen.<br />
Beendet der Nutzer die Bearbeitung einer Zelle in der Maske, so wird das ValidateEdit-Ereignis<br />
gestartet. Die Cancel-Eigenschaft im Ereignis wird auf TRUE gesetzt, wenn die Maske nicht richtig<br />
ausgefüllt wurde, so dass Sie nicht einmal den Abwickler implementieren müssen. Das<br />
Standardverhalten stellt sicher, dass nur gültige Daten eingetragen werden.<br />
Die EditMask muss eine Zeichenkette, bestehend aus folgenden Symbolen, sein:
1) Platzhalter<br />
0 Ziffer<br />
9 Ziffer oder Leerzeichen<br />
# Ziffer oder Satzzeichen<br />
L Buchstabe<br />
? Buchstabe oder Leerzeichen<br />
A Buchstabe oder Ziffer<br />
a Buchstabe, Ziffer oder Leerzeichen<br />
& beliebiges Zeichen<br />
2) Ortsgebundene Zeichen<br />
. ortsgebundenes Dezimaltrennzeichen<br />
, ortsgebundenes Tausendertrennzeichen<br />
: ortsgebundenes Zeittrennzeichen<br />
/ ortsgebundenes Datumstrennzeichen<br />
3) Befehlszeichen<br />
\ nächstes Zeichen ist wird wörtlich genommen<br />
> Buchstaben zu Großbuchstaben umformen<br />
< Buchstaben zu Kleinbuchstaben umformen<br />
4) Platzhaltereinstellungen<br />
; Nächstes Zeichen wird als Platzhalter verwendet (Standard ist ein Unterstrich)<br />
Zum Beispiel:<br />
• Visual Basic<br />
• C#<br />
Editor-Eigenschaft (<strong>C1FlexGrid</strong>) · 143<br />
' set the mask so the user can enter a phone number,<br />
' with optional area code, and a state in uppercase letters.<br />
' use an asterisk as a placeholder<br />
flex.EditMask = "(###) 000-0000 St" + "ate" > LL '<br />
// set the mask so the user can enter a phone number,<br />
// with optional area code, and a state in uppercase letters.<br />
// use an asterisk as a placeholder<br />
flex.EditMask = "(###) 000-0000 St\ate\: >LL;*";<br />
• Delphi<br />
// set the mask so the user can enter a phone number,<br />
// with optional area code, and a state in uppercase letters.<br />
// use an asterisk as a placeholder<br />
flex.EditMask := '(###) 000-0000 St'#7'te >LL;*';<br />
Für mehr Details und Beispiele über Zellbearbeitung, schauen Sie bitte unter „Zellen bearbeiten“ (Seite<br />
37.)<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
Editor-Eigenschaft (<strong>C1FlexGrid</strong>)<br />
Gibt den aktuellen Zelleditor zurück, oder legt eine Steuerung, die als Editor verwendet werden soll, fest<br />
(kann nur während des StartEdit-Ereignisses gesetzt werden).<br />
Syntax
144 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
[VB]<br />
Public Editor As Control<br />
[C#]<br />
public Control Editor {get;set;}<br />
[Delphi]<br />
property Editor: Control;<br />
Bemerkungen<br />
Die Editor-Eigenschaft gibt einen Verweis auf einen Zelleditor zurück, der gerade aktiv ist. Dies kann<br />
einer der integrierten Editoren (eine TextBox-, eine ComboBox- oder eine DateTimePicker-Steuerung),<br />
ein externer Editor oder Null (wenn die Tabelle sich nicht im Bearbeitungsmodus befindet) sein.<br />
Sie können diese Eigenschaft verwenden, um programmatisch Zugang zu den Editoren zu verschaffen<br />
oder um herauszufinden, ob sich die Tabelle im Bearbeitungsmodus befindet.<br />
Wenn Sie die integrierten Editoren nicht verwenden wollen, so können Sie stattdessen auch jede andere<br />
Steuerung verwenden. Um dies zu tun, müssen Sie den externen Editor über die Editor-Eigenschaften<br />
mit einer der Tabellen-Row, -Column oder einem CellStyle verknüpfen. Dies Informationen können Sie<br />
jederzeit festlegen oder auch abrufen.<br />
Alternativ können Sie auch das StartEdit-Ereignis abfangen und eine beliebige Steuerung direkt der<br />
Editor-Tablleneigenschaft zuordnen. (Beachten Sie, dass die Editor-Eigenschaft der Tabelle nur während<br />
des StartEdit-Ereignisses gesetzt werden kann und diese automatisch auf Null gesetzt wird, wenn die<br />
Tabelle den Bearbeitungsmodus verlässt.)<br />
Obwohl jede beliebige Steuerung als externen Editor verwendet werden kann, sollten diese dennoch die<br />
IC1EmbeddedEditor-Schnittstelle implementieren, um die vollständige Integration mit der Tabelle<br />
sicherzustellen. Einige Steuerungen implementieren diese Schnittstelle standardmäßig und benötigen<br />
daher keinen weiteren Quellcode, um diese als Tabelleneditoren zu verwenden (wie z.B. die in der<br />
C1Input-Bibliothek). Für die meisten jedoch müssen Sie einige der Methoden des IC1EmbeddedEditors<br />
implementieren.<br />
Zum Beispiel über eigene Editoren, schauen Sie bitte unter „Benutzerdefinierte Editoren verwenden“<br />
(Seite 46 ) und „Benutzerdefinierte Editoren erstellen“ (Seite 47 )in dieser Dokumentation nach, oder<br />
besuchen Sie unsere online Beispielbibliothek und laden Sie das „CustomEditors“-Beispiel herunter.<br />
Beispiel<br />
Dieser Quellcode verwendet die Editor-Eigenschaft um zu prüfen, ob sich die Tabelle im<br />
Bearbeitungsmodus befindet und hindert den Benutzer zu scrollen, während eine Zelle bearbeitet wird:<br />
• Visual Basic<br />
• C#<br />
Private flex_ As Sub New(sender As Object, e As RangeEventArgs)<br />
If Not (flex.Editor Is Nothing) Then<br />
e.Cancel = True<br />
End If<br />
End Sub 'New<br />
private void flex_ BeforeScroll(object sender, RangeEventArgs e)<br />
{<br />
if (flex.Editor != null)<br />
e.Cancel = true;
}<br />
• Delphi<br />
EditOptions-Eigenschaft · 145<br />
procedure flex_BeforeScroll(sender: System.Object; e: RangeEventArgs);<br />
begin<br />
If flex.Editor nil Then<br />
e.Cancel := True<br />
end; // New<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
EditOptions-Eigenschaft<br />
Beinhaltet Flags, die das Verhalten der integrierten Editoren anpassen können.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft EditOptions As EditFlags<br />
[C#]<br />
public EditFlags EditOptions {get; set;}<br />
[Delphi]<br />
property EditOptions: EditFlags;<br />
Eigenschaftswerte<br />
Einer der EditFlags-Werte. Der Standardwert ist EditFlags.All, welcher das automatische Suchen und<br />
das automatische Durchblättern in Kombinationsfeldern aktiviert, und Kontrollkästchen für einen<br />
gesamten Auswahlbereich umschaltet.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
ExtendLastCol-Eigenschaft<br />
Legt fest, ob die Breite der letzten Spalte an den zur Verfügung stehenden Platz in der Steuerung<br />
angepasst werden soll.<br />
Syntax<br />
[VB]<br />
Public ExtendLastCol As Boolean<br />
[C#]<br />
public bool ExtendLastCol {get; set;}<br />
[Delphi]<br />
property ExtendLastCol: Boolean;
146 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Bemerkungen<br />
Diese Eigenschaft betrifft nur das Zeichnen/die Anzeige der Spalten. Sie verändert nicht die<br />
Width.Column-Klasseneigenschaft der letzten Spalte.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
FocusRect-Eigenschaft<br />
Legt den rechteckigen Fokustyp fest, der um die aktuelle Zelle gelegt wird.<br />
Syntax<br />
[VB]<br />
Public FocusRect As FocusRectEnum<br />
[C#]<br />
public FocusRectEnum FocusRect {get; set;}<br />
[Delphi]<br />
property FocusRect: FocusRectEnum;<br />
Eigenschaftswerte<br />
Einer der FocusRectEnum-Werte. Der Standardwert ist FocusRectEnum.Light.<br />
Bemerkungen<br />
Wenn das Fokusrechteck um die aktuelle Zelle gezeichnet wird, dann erscheint diese im Focus-Format,<br />
welches standardmäßig wie eine normale scrollbare Zelle aussieht (wie in den meisten Tabellen).<br />
Wenn das Fokusrechteck versteckt ist (mit der FocusRectEnum.None-Einstellung), dann wird die<br />
aktuelle Zelle mit dem Highlight-Format gezeichnet.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
GetCellCheck-Eigenschaft<br />
Gibt einen Wert zurück, der anzeigt, ob die Zelle ein Kontrollkästchen beinhaltet.<br />
Syntax<br />
[VB]<br />
Public GetCellCheck As CheckEnum<br />
[C#]<br />
public CheckEnum GetCellCheck(int row, int col)<br />
[Delphi]<br />
property GetCellCheck: CheckEnum
Bemerkungen<br />
Diese Methode ruft Kontrollkästchenwerte einer Zell mit der SetCellCheck-Eigenschaft ab.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
Glyphs-Eigenschaft<br />
Hiermit können Sie alle von der Tabelle angezeigten, integrierten Bilder anpassen.<br />
Syntax<br />
[VB]<br />
Public Glyphs As GridGlyphs<br />
[C#]<br />
public GridGlyphs Glyphs {get;}<br />
[Delphi]<br />
property Glyphs: GridGlyphs;<br />
Bemerkungen<br />
Glyphs-Eigenschaft · 147<br />
Die Glyphs-Eigenschaft gibt ein GridGlyphs-Objekt mit einem Index vom Typ GlyphEnum zurück, das<br />
die Grafik festlegt oder abruft, die Spaltensortierung, erweiterte oder zusammengeklappte<br />
Gliederungsgruppen, Kontrollkästchen, Cursor, Fehlerinformationen, usw., anzeigt.<br />
Zum Beispiel, der nachfolgende Quellcode veranlasst die Tabelle, eine benutzerdefinerte Grafik für<br />
Anzeige der Spaltensortierungsrichtung zu verwenden. (anstatt der üblichen, ausgehöhlten Dreiecke):<br />
• Visual Basic<br />
• C#<br />
_flex.Glyphs(GlyphEnum.Ascending) = imgAscending '<br />
_flex.Glyphs(GlyphEnum.Descending) = imgDescending '<br />
_flex.Glyphs[GlyphEnum.Ascending] = imgAscending;<br />
_flex.Glyphs[GlyphEnum.Descending] = imgDescending;<br />
• Delphi<br />
_flex.Glyphs[GlyphEnum.Ascending] := imgAscending;<br />
_flex.Glyphs[GlyphEnum.Descending] := imgDescending;<br />
Anmerkung: Die Standardgrafik wird wiederhergestellt, indem Sie den Glyph auf Null setzen. Wenn Sie<br />
einen Glyph unsichtbar machen wollen, dann setzten Sie diesen auf eine kleine leere Grafik.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
HighLight-Eigenschaft<br />
Legt fest, wann die ausgewählte Zelle markiert wird.
148 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Syntax<br />
[VB]<br />
Public HighLight As HighLightEnum<br />
[C#]<br />
public HighLightEnum HighLight {get; set;}<br />
[Delphi]<br />
property HighLight: HighLightEnum;<br />
Eigenschaftswerte<br />
Einer der HighLightEnum-Werte. Der Standardwert ist HighLightEnum.Always.<br />
Bemerkungen<br />
Hervorgehobene Zellen werden im Highlight-Format gezeichnet.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
Item-Eigenschaft<br />
Gibt/legt die Daten in einer Tabellenzelle zurück/fest.<br />
Syntax<br />
[VB]<br />
Public Item(Row As Integer, Col As Integer) As object<br />
Public Item(Row As Integer, Col As String) As object<br />
[C#]<br />
public object this [ int row, int col ] {get; set;}<br />
public object this [ int row, string col ] {get; set;}<br />
[Delphi]<br />
property Item(Row: Integer; Col: Integer): Object;<br />
property Item(Row: Integer; Col: string): Object;<br />
Bemerkungen<br />
Diese Eigenschaft ist der Indizierer für die <strong>C1FlexGrid</strong>-Steuerung.<br />
Sie können Zellen mit den row- und column-Indizes oder der Zeilennummer und dem Spaltenname<br />
indizieren, wie im nachfolgendem Beispiel. Einerseits ist es effizienter, numerische Indizes zu<br />
verwenden, da die Tabelle so die Namen der Spalten nicht nachschauen muss. Andererseits ist die<br />
Verwendung von Namen flexibler, da Verweise gültig bleiben, selbst wenn der Nutzer eine Spalte auf<br />
eine neue Position verschiebt.<br />
Wenn ein Wert einer Zelle zugeordnet wird, dann versucht die Tabelle diesen in den entsprechenden Typ<br />
für diese Spalte umzuwandeln. Schauen Sie unter der DataType-Eigenschaft für Spalten nach. Wenn die
KeyActionEnter-Eigenschaft · 149<br />
Tabelle den Wert nicht umwandeln kann, dann startet diese das GridError-Ereignis und die Zuordnung<br />
schlägt fehl.<br />
Schauen Sie unter den GetData- und SetData-Methoden nach.<br />
Upgradenotiz: In der VSFlexGrid ActiveX-Steuerung haben Sie die TextMatrix-Eigenschaft verwendet,<br />
um auf Zellinhalte zuzugreifen und die ColIndex-Eigenschaft um Spalten mit Namen zu indizieren.<br />
Verwenden Sie in <strong>C1FlexGrid</strong> nun stattdessen die Indizierer.<br />
• Visual Basic<br />
• C#<br />
' create a column, assign it a name and get the new index<br />
Dim myCol As Column = flex.Cols.Add()<br />
myCol.Name = "address"<br />
myCol.DataType = GetType(String)<br />
Dim colIndex As Integer = myCol.Index<br />
' assign a value to a cell using cell coordinates:<br />
flex(1, colIndex) = "555, Broadway" '<br />
' get the value using the column name<br />
MessageBox.Show(("The address is " + flex(1, "address").ToString()))<br />
// create a column, assign it a name and get the new index<br />
Column myCol = flex.Cols.Add();<br />
myCol.Name = "address";<br />
myCol.DataType = typeof(string);<br />
int colIndex = myCol.Index;<br />
// assign a value to a cell using cell coordinates:<br />
flex[1, colIndex] = "555, Broadway";<br />
// get the value using the column name<br />
MessageBox.Show("The address is " + flex[1, "address"].ToString());<br />
• Delphi<br />
var<br />
colIndex: Integer;<br />
myCol: Column;<br />
begin<br />
myCol := flex.Cols.Add;<br />
myCol.Name := 'address';<br />
myCol.DataType := TypeOf(string);<br />
colIndex := myCol.Index;<br />
flex[1] := '555, Broadway';<br />
MessageBox.Show(('The address is ' + flex[1].ToString);<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
Column-Klasse (Seite 339)<br />
Row-Klasse (Seite 324)<br />
KeyActionEnter-Eigenschaft<br />
Legt die auszuführende Aktion fest, wenn der Nutzer die Enter-Taste drückt.
150 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Syntax<br />
[VB]<br />
Public KeyActionEnter As KeyActionEnum<br />
[C#]<br />
public KeyActionEnum KeyActionEnter {get; set;}<br />
[Delphi]<br />
property KeyActionEnter: KeyActionEnum;<br />
Eigenschaftswerte<br />
Einer der KeyActionEnum-Werte. Der Standardwert ist KeyActionEnum.MoveDown.<br />
Wert Beschreibung<br />
None<br />
Keine Handlung (das System verwaltet die Zelle). Zum Beispiel, die Tabulatortaste<br />
wird normalerweise für das Durchblättern der Steuerungen auf einem Formular<br />
verwendet.<br />
MoveDown Gehe zur nächsten Zeile, wenn die Taste gedrückt wird.<br />
MoveAcross<br />
MoveAcrossOut<br />
Bemerkungen<br />
Gehe zur nächsten Spalte, wenn die Taste gedrückt wird. Nach der letzten Spalte,<br />
gehe zur nächsten Zeile und zurück zur ersten Spalte.<br />
Gehe zur nächsten Spalte, wenn die Taste gedrückt wird. Nach der letzten Spalte,<br />
gehe zur nächsten Zeile und zurück zur ersten Spalte. Nach der letzten Zeile und<br />
Spalte verschiebe den Fokus zur nächsten Steuerung auf dem Formular.<br />
Standardmäßig verschiebt die Tabelle den Fokus auf die nächste sichtbare Zeile, wenn der Nutzer die<br />
Enter-Taste drückt. Wenn die Tabelle bearbeitbar ist, dann wird diese durch die Enter-Taste in den<br />
Bearbeitungsmodus versetzt und, während sie in diesem Modus verweilt, verschiebt die Enter-Taste den<br />
Cursor nach unten.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109 )<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
KeyActionTab-Eigenschaft<br />
Legt die auszuführende Aktion fest, wenn der Nutzer die Tabulator-Taste drückt.<br />
Syntax<br />
[VB]<br />
Public KeyActionTab As KeyActionEnum<br />
[C#]<br />
public KeyActionEnum KeyActionTab {get; set;}
[Delphi]<br />
property KeyActionTab: KeyActionEnum;<br />
Eigenschaftswerte<br />
Einer der KeyActionEnum-Werte. Der Standardwert ist KeyActionEnum.None.<br />
Wert Beschreibung<br />
None<br />
KeyActionTab-Eigenschaft · 1<strong>51</strong><br />
Keine Handlung (das System verwaltet die Zelle). Zum Beispiel, die Tabulatortaste<br />
wird normalerweise für das Durchblättern der Steuerungen auf einem Formular<br />
verwendet.<br />
MoveDown Gehe zur nächsten Zeile, wenn die Taste gedrückt wird.<br />
MoveAcross<br />
MoveAcrossOut<br />
Bemerkungen<br />
Gehe zur nächsten Spalte, wenn die Taste gedrückt wird. Nach der letzten Spalte,<br />
gehe zur nächsten Zeile und zurück zur ersten Spalte.<br />
Gehe zur nächsten Spalte, wenn die Taste gedrückt wird. Nach der letzten Spalte,<br />
gehe zur nächsten Zeile und zurück zur ersten Spalte. Nach der letzten Zeile und<br />
Spalte verschiebe den Fokus zur nächsten Steuerung auf dem Formular.<br />
Standardmäßig wird die Tabelle die Tabulator-Taste ignorieren. Sie wird durch das Formular<br />
abgewickelt und verschiebt den Fokus auf die nächste Steuerung. Wenn Sie die KeyActionTab-<br />
Eigenschaft auf einen von KeyActionEnum.None verschiedenen Wert setzen, dann wird die Tabelle die<br />
Tabulator-Taste abfangen und diese für die Navigation durch die Zellen verwenden.<br />
Beispiel<br />
Der nachfolgende Quellcode ändert den Wert der KeyActionTab-Eigenschaft basierend auf der aktuellen<br />
Zelle. Der Nutzer kann die Tabulator-Taste drücken, um durch die Zellen zu navigieren bis er am Ende<br />
der Tabelle angelangt ist. Wenn er diese erneut drückt, dann wird der Fokus auf die nächste Steuerung<br />
verschoben.<br />
• Visual Basic<br />
• C#<br />
Private Sub flex_Enter(sender As Object, e As System.EventArgs)<br />
flex.Select(flex.Rows.Fixed, flex.Cols.Fixed)<br />
End Sub 'flex_Enter<br />
Private Sub flex_RowColChange(sender As Object, e As System.EventArgs)<br />
Dim lastCell As Boolean<br />
lastCell = flex.Col = flex.Cols.Count - 1 And _<br />
flex.Row = flex.Rows.Count - 1<br />
If lastCell Then<br />
flex.KeyActionTab = KeyActionEnum.None<br />
Else<br />
flex.KeyActionTab = KeyActionEnum.MoveAcross<br />
End If<br />
End Sub 'flex_RowColChange<br />
private void flex_Enter(object sender, System.EventArgs e)<br />
{<br />
flex.Select(flex.Rows.Fixed, flex.Cols.Fixed);<br />
}<br />
private void flex_RowColChange(object sender, System.EventArgs e)
152 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
{<br />
}<br />
• Delphi<br />
bool lastCell = (flex.Col == flex.Cols.Count-1 &&<br />
flex.Row == flex.Rows.Count-1);<br />
flex.KeyActionTab = (lastCell)<br />
? KeyActionEnum.None<br />
: KeyActionEnum.MoveAcross;<br />
procedure Class1.flex_Enter(sender: System.Object; e:<br />
System.EventArgs);<br />
begin<br />
flex.Select(flex.Rows.Fixed, flex.Cols.Fixed);<br />
end;<br />
procedure flex_RowColChange(sender: System.Object; e:<br />
System.EventArgs);<br />
var<br />
lastCell: Boolean;<br />
begin<br />
lastCell := (flex.Col = flex.Cols.Count – 1_ And<br />
(flex.Row = flex.Rows.Count – 1);<br />
If lastCell Then<br />
flex.KeyActionTab := KeyActionEnum.None<br />
Else<br />
flex.KeyActionTab := KeyActionEnum.MoveAcross;<br />
end; // flex_RowColChange<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109 )<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
LeftCol-Eigenschaft<br />
Gibt/legt den Index der am weitesten links liegenden, nicht fixierten Spalte zurück/fest.<br />
Syntax<br />
[VB]<br />
Public LeftCol As Integer<br />
[C#]<br />
public int LeftCol {get; set;}<br />
[Delphi]<br />
property LeftCol: Integer;<br />
Bemerkungen<br />
Wenn die LeftCol-Eigenschaft gesetzt wird, dann scrollt die Tabelle horizontal, so dass die gegebenen<br />
Spalten, die am äußersten linken Rand noch sichtbaren sind. Dies ist nützlich, wenn Sie zwei oder mehr<br />
Tabellen synchronisieren wollen und somit, wenn die eine gescrollt wird, die andere sich mitbewegt.<br />
Verwenden Sie die TopRow-Eigenschaft, um vertikal zu scrollen.<br />
Der größte Wert dieser Eigenschaft ist die Summe aller Spalten, minus derer, die auf dem Bildschirm<br />
gleichzeitig angezeigt werden können. Wenn Sie LeftCol auf einen größeren Wert stellen, dann wird die<br />
Steuerung den größtmöglichen Wert für diese Tabelle ohne Fehlermeldung annehmen.
MouseCol-Eigenschaft · 153<br />
Die Werte, die von den LeftCol- und TopRow-Eigenschaften zurückgegeben werden, entsprechen den<br />
auf dem Bildschirm teilweise oder vollständig sichtbaren Zeilen und Spalten.<br />
Verwenden Sie die LeftCol- und TopRow-Eigenschaften um mit Zellen als Einheiten, und die<br />
ScrollPosition-Eigenschaft um mit Pixel als Einheiten zu scrollen.<br />
Verwenden Sie die ShowCell-Methode um sicherzustellen, dass eine Zelle angezeigt wird.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
MouseCol-Eigenschaft<br />
Gibt/legt den Index der Spalte unter dem Mauszeiger zurück/fest.<br />
Syntax<br />
[VB]<br />
Public MouseCol As Integer<br />
[C#]<br />
public int MouseCol {get;}<br />
[Delphi]<br />
property MouseCol: Integer;<br />
Bemerkungen<br />
Die MouseRow- und MouseCol-Eigenschaften sind oft nützlich, wenn das BeforeMouseDown-Ereignis<br />
abgefangen wird, um das Verhalten der Maus anzupassen. Sie sind für die Abwicklung von<br />
Mausereignissen, welche die Auswahl nicht verändern, und für das Aufzuspüren von Klicks auf den<br />
fixierten Bereich einer Tabelle nützlich.<br />
Eine typische Verwendung für diese Eigenschaften beinhalten die Anzeige von Hilfeinformationen oder<br />
Quickinfos, wenn der Nutzer den Mauszeiger über eine Auswahl schiebt, und die Implementation von<br />
manuellen Drag-And-Drop Anpassungen von OLE-Objekten.<br />
Die MouseRow- und MouseCol-Eigenschaften geben –1 zurück, wenn sich der Mauszeiger über keiner<br />
Zelle befindet.<br />
Beispiel<br />
Dieser Quellcode wird eine Quickinfo mit den Koordinaten der Zelle unter dem Cursor anzeigen:<br />
• Visual Basic<br />
• C#<br />
Private Sub flex_MouseMove(sender As Objec<br />
t, e As System.Windows.Forms.MouseEventArgs)<br />
' build tooltip text<br />
Dim str As String = String.Format("This is cell {0}, {1}",<br />
flex.MouseRow, flex.MouseCol)<br />
' ttip is a Windows.Forms.ToolTip component<br />
If str ttip.GetToolTip(flex) Then<br />
ttip.SetToolTip(flex, str)<br />
End If<br />
End Sub 'flex_MouseMove
154 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
private void flex_MouseMove(object sender,<br />
System.Windows.Forms.MouseEventArgs e)<br />
{<br />
// build tooltip text<br />
string str = string.Format("This is cell {0}, {1}",<br />
flex.MouseRow, flex.MouseCol);<br />
}<br />
• Delphi<br />
// ttip is a Windows.Forms.ToolTip component<br />
if (str != ttip.GetToolTip(flex))<br />
ttip.SetToolTip(flex, str);<br />
procedure flex_MouseMove(sender: System.Object; e:<br />
System.Windows.Forms.MouseEventArgs);<br />
var<br />
str: string;<br />
begin<br />
// build tooltip text<br />
str := String.Format('This is cell {0}, {1}', flex.MouseRow,<br />
flex.MouseCol);<br />
// ttip is a Windows.Forms.ToolTip component<br />
If str ttip.GetToolTip(flex) Then<br />
ttip.SetToolTip(flex, str);<br />
end; // flex_MouseMove<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
MouseRow-Eigenschaft<br />
Gibt/legt den Index der Zeile unter dem Mauszeiger zurück/fest.<br />
Syntax<br />
[VB]<br />
Public MouseRow As Integer<br />
[C#]<br />
public int MouseRow {get;}<br />
[Delphi]<br />
property MouseRow: Integer;<br />
Bemerkungen<br />
Die MouseRow- und MouseCol-Eigenschaften geben –1 zurück, wenn sich der Mauszeiger über keiner<br />
Zelle befindet.<br />
Für Details und ein Beispiel, schauen Sie bitte unter der MouseCol-Eigenschaft nach.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)
PrintParameters-Eigenschaft<br />
Gibt ein GridPrinter-Objekt zurück, das die Druckparameter der Tabelle festlegt.<br />
Syntax<br />
[VB]<br />
Public PrintParameters As GridPrinter<br />
[C#]<br />
public GridPrinter PrintParameters {get;}<br />
[Delphi]<br />
property PrintParameters: GridPrinter;<br />
Bemerkungen<br />
PrintParameters-Eigenschaft · 155<br />
Verwenden Sie die PrintGrid-Methode, um die Tabelle zu drucken und um den Dokumentnamen,<br />
allgemeine Druckoptionen, Kopf- und Fußzeilen festzulegen. Verwenden Sie hingegen die<br />
PrintParameters-Eigenschaft, um weniger allgemeine Druckoptionen, wie z.B. Kopf- und<br />
Fußzeilenschriftart, Seitenränder und Ausrichtung, festzulegen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
Redraw-Eigenschaft<br />
Legt fest, ob die Tabelle ihren Inhalt zeichnen soll.<br />
Syntax<br />
[VB]<br />
Public Redraw As Boolean<br />
[C#]<br />
public bool Redraw {get; set;}<br />
[Delphi]<br />
property Redraw: Boolean;<br />
Bemerkungen<br />
Die Redraw-Eigenschaft wird für die Leistungsoptimierung der Tabelle genutzt. Bevor Sie tiefgreifende<br />
Änderungen in der Tabelle vornehmen, setzen Sie Redraw auf FALSE, um das Zeichnen der Zellen zu<br />
verhindern. Wenn die Änderungen erledigt sind, dann setzen Sie Redraw wieder auf TRUE. Dies wird<br />
das Flackern verhindern und die Leistung steigern. Diese Optimierung ist besonders effektiv, wenn viele<br />
neue Zeilen der Tabelle angefügt werden, weil diese mit jeder neu hinzugefügten Zeile Bereiche neu<br />
berechnen und die Bildlaufleisten aktualisieren muss.<br />
Beispiel<br />
Dieser nachfolgende Quellcode stellt die permanente Neuzeichnung aus, ändert den Inhalt der Tabelle<br />
und stellt anschließend die Neuzeichnung wieder an, um das Ergebnis zu zeigen.<br />
• Visual Basic
156 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
• C#<br />
Private Function UpdateGrid(flex As c1FlexGrid) As function<br />
flex.Redraw = False ' suspend painting to avoid flicker<br />
flex.Rows.Count = 1<br />
Dim i As Integer<br />
For i = 1 To 9999<br />
flex.AddItem(("Row " + i.ToString()))<br />
Next i<br />
flex.Redraw = True ' resume painting<br />
End Function 'UpdateGrid<br />
private function UpdateGrid(c1FlexGrid flex)<br />
{<br />
flex.Redraw = false; // suspend painting to avoid flicker<br />
flex.Rows.Count = 1;<br />
for (int i = 1; i < 10000; i++)<br />
flex.AddItem("Row " + i.ToString());<br />
flex.Redraw = true; // resume painting<br />
}<br />
• Delphi<br />
function Class1.UpdateGrid(flex: c1FlexGrid): &function;<br />
var<br />
i: Integer;<br />
begin<br />
flex.Redraw := False;<br />
flex.Rows.Count := 1;<br />
for I := 1 to 9999 do<br />
flex.AddItem('Row ' + System.Object(i).ToString);<br />
flex.Redraw := True;<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109 )<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
RightCol-Eigenschaft<br />
Gibt den Index der am weitesten rechtsstehenden Spalte zurück.<br />
Syntax<br />
[VB]<br />
Public RightCol As Integer<br />
[C#]<br />
public int RightCol {get;}<br />
[Delphi]<br />
property RightCol: Integer;<br />
Bemerkungen<br />
Die rechte, zurückgegebene Spalte ist möglicherweise nur teilweise sichtbar.
Row-Eigenschaft · 157<br />
Sie können diese Eigenschaft nicht setzen. Verwenden Sie die TopRow und LeftCol-Eigenschaften, um<br />
den Inhalt der Tabelle zu scrollen.<br />
Verwenden Sie die ShowCell-Methode um sicherzustellen, dass eine Zelle angezeigt wird.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
Row-Eigenschaft<br />
Gibt/legt den Index der ausgewählten Zeile zurück/fest.<br />
Syntax<br />
[VB]<br />
Public Row As Integer<br />
[C#]<br />
public int Row {get; set;}<br />
[Delphi]<br />
property Row: Integer;<br />
Bemerkungen<br />
Verwenden Sie die Row- und Col-Eigenschaften um eine Zelle aktuell zu machen, oder herauszufinden,<br />
in welcher Zeile oder Spalte sich die aktuelle Zelle befindet. Spalten und Zeilen werden von Null an,<br />
beginnend von der obersten Zeile und der linken Spalte nummeriert.<br />
Die Row-Eigenschaft kann auf -1, um die Auswahl auszublenden, auf einen Wert zwischen Null und<br />
Rows.Fixed-1, um eine Zelle in einer fixierten Zeile, oder auf einen Wert zwischen Rows.Fixed und<br />
Rows.Count-1, um eine scrollbare Zeile auszuwählen, gesetzt werden.<br />
Indem man die Row- und Col-Eigenschaften setzt, wird die Auswahl automatisch auf eine einzelne Zelle<br />
beschränkt und damit die Eigenschaften RowSel und ColSel zurückgesetzt. Um eine Blockauswahl<br />
vorzunehmen, müssen Sie zuerst Row und Col und dann RowSel und ColSel festlegen. Oder Sie<br />
verwenden die Select-Methode, um eine willkürliche Auswahl mit einem einzigen Befehl vorzunehmen.<br />
Indem die Row- und Col-Eigenschaften gesetzt werden, kann nicht sichergestellt werden, dass die Zelle<br />
auf dem Bildschirm sichtbar ist. Um dies zu tun, müssen Sie die ShowCell-Methode anwenden.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
Rows-Eigenschaft<br />
Gibt die alle Zeilen der Tabelle zurück.<br />
Syntax<br />
[VB]<br />
Public Rows As RowCollection<br />
[C#]
158 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
public RowCollection Rows {get;}<br />
[Delphi]<br />
property Rows: RowCollection;<br />
Bemerkungen<br />
Mit der Rows-Eigenschaft können Sie eine Liste mit allen derzeit vorhandenen Zeilen in einer Tabelle<br />
abfragen. Mit dieser Referenz können Sie Zeilen hinzufügen, entfernen, verschieben und zählen. Für<br />
weitere Informationen über die Funktionen dieser Sammlung, schauen Sie in den Referenzthemen der<br />
RowCollection-Klasse nach.<br />
Diese Eigenschaft kann nur gelesen werden. Die Tabelle erstellt und verwaltet diese Liste/Sammlung.<br />
Upgradenotiz: In der VSFlexGrid-ActiveX-Steuerung zeigen die Rows- und FixedRows-Eigenschaften<br />
die Anzahl der Zeilen und der fixierten Zeilen in einer Tabelle. Verwenden Sie in <strong>C1FlexGrid</strong><br />
Rows.Count und Rows.Fixed hierfür.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109 )<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
RowSel-Eigenschaft<br />
Gibt/legt den Index der letzt Zeile der aktuellen Auswahl zurück/fest.<br />
Syntax<br />
[VB]<br />
Public RowSel As Integer<br />
[C#]<br />
public int RowSel {get; set;}<br />
[Delphi]<br />
property RowSel: Integer;<br />
Bemerkungen<br />
Verwenden Sie die RowSel- und ColSel-Eigenschaften, um eine Auswahl zu verändern oder um zu<br />
bestimmen, welche Zellen gerade ausgewählt sind. Spalten und Zeilen werden von Null an, beginnend<br />
von der obersten Zeile und der linken Spalte nummeriert.<br />
Indem man die Row- und Col-Eigenschaften setzt, wird die Auswahl automatisch auf eine einzelne Zelle<br />
beschränkt und damit die Eigenschaften RowSel und ColSel zurückgesetzt. Um eine Blockauswahl<br />
vorzunehmen, müssen Sie zuerst Row und Col und dann RowSel und ColSel festlegen. Oder Sie<br />
verwenden die Select-Methode, um eine willkürliche Auswahl mit einem einzigen Befehl vorzunehmen.<br />
Wenn die SelectionMode-Eigenschaft auf Listbox gesetzt ist, dann sollten Sie die Selected-Eigenschaft<br />
für die Auswahl einzelner Zeilenobjekte verwenden.<br />
Wenn ein Bereich ausgewählt ist, dann kann der Wert von Row oder Col größer oder kleiner als der von<br />
RowSel oder ColSel sein. Dies ist recht lästig, wenn Sie Grenzen für Schleifen setzen wollen. In diesen<br />
Fällen können Sie die Selection-Eigenschaft verwenden, um ein normalisiertes CellRange-Objekt<br />
abzufragen, indem r1
Schauen Sie unter der ColSel-Eigenschaft für ein Beispiel nach.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
ScrollBars-Eigenschaft<br />
Gibt zurück/legt fest welche Bildlaufleisten in der Tabelle angezeigt werden.<br />
Syntax<br />
[VB]<br />
Public ScrollBars As ScrollBars<br />
[C#]<br />
public ScrollBars ScrollBars {get; set;}<br />
[Delphi]<br />
property ScrollBars: ScrollBars;<br />
Eigenschaftswerte<br />
ScrollBars-Eigenschaft · 159<br />
Einer der Aufzählungswerte von ScrollBars, die zeigen, ob die Tabelle keine Bildlaufleisten, eine<br />
horizontale Bildlaufleiste, eine vertikale Bildlaufleiste oder beide haben soll. Der Standardwert ist<br />
ScrollBars.Both.<br />
Bemerkungen<br />
Bildlaufleisten werden nur dann angezeigt, wenn die Inhalte der Steuerung die Grenzen überschreiten.<br />
Zum Beispiel, wenn ScrollBars auf ScrollBars.Horizontal steht, dann wird die horizontale Bildlaufleiste<br />
auch nur dann angezeigt, wenn die Steuerung nicht breit genug ist, um alle Spalten auf einmal auf dem<br />
Bildschirm anzuzeigen.<br />
Auch wenn die Tabelle keine Bildlaufleisten besitzt, wird die Steuerung immer noch scrollen, um eine<br />
Auswahl vollständig anzuzeigen. Wenn Sie scrollen verhindern wollen, dann müssen Sie das<br />
BeforeScroll-Ereignis abfangen und dessen Cancel-Parameter auf TRUE setzen.<br />
Beachten Sie, dass wenn die ScrollBars-Eigenschaft auf ScrollBars.Both steht, nicht zwingend beide<br />
Bildlaufleisten angezeigt werden. Diese werden nur erscheinen, wenn die Steuerung mehr Zeilen oder<br />
Spalten besitzt, als auf einmal auf dem Bildschirm angezeigt werden können. Um festzustellen, ob die<br />
Bildlaufleisten derzeit sichtbar sind, können Sie einen Quellcode wie den folgenden verwenden:<br />
• Visual Basic<br />
Function CheckScrollBars(fg As C1.Win.<strong>C1FlexGrid</strong>.<strong>C1FlexGrid</strong>) As<br />
ScrollBars<br />
Dim SBWID As Integer = SystemInformation.VerticalScrollBarWidth<br />
Dim SBHEI As Integer = SystemInformation.HorizontalScrollBarHeight<br />
Dim rcCtl As Rectangle = fg.Bounds<br />
Dim rcClient As Rectangle = fg.ClientRectangle<br />
Dim vbar As Boolean = rcCtl.Width - rcClient.Width >= SBWID<br />
Dim hbar As Boolean = rcCtl.Height - rcClient.Height >= SBHEI<br />
If vbar And hbar Then<br />
Return ScrollBars.Both<br />
End If
160 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
• C#<br />
If vbar Then<br />
Return ScrollBars.Vertical<br />
End If<br />
If hbar Then<br />
Return ScrollBars.Horizontal<br />
End If<br />
Return ScrollBars.None<br />
End Function 'CheckScrollBars<br />
ScrollBars CheckScrollBars(C1.Win.<strong>C1FlexGrid</strong>.<strong>C1FlexGrid</strong> fg)<br />
{<br />
int SBWID = SystemInformation.VerticalScrollBarWidth;<br />
int SBHEI = SystemInformation.HorizontalScrollBarHeight;<br />
}<br />
• Delphi<br />
Rectangle rcCtl = fg.Bounds;<br />
Rectangle rcClient = fg.ClientRectangle;<br />
bool vbar = (rcCtl.Width - rcClient.Width >=SBWID);<br />
bool hbar = (rcCtl.Height - rcClient.Height >= SBHEI);<br />
if (vbar && hbar) return ScrollBars.Both;<br />
if (vbar) return ScrollBars.Vertical;<br />
if (hbar) return ScrollBars.Horizontal;<br />
return ScrollBars.None;<br />
function CheckScrollBars(fg: C1.Win.<strong>C1FlexGrid</strong>.<strong>C1FlexGrid</strong>): ScrollBars;<br />
var<br />
hbar: Boolean;<br />
vbar: Boolean;<br />
rcClient: Rectangle;<br />
rcCtl: Rectangle;<br />
SBHEI: Integer;<br />
SBWID: Integer;<br />
CheckScrollBars: ScrollBars;<br />
begin<br />
SBWID := SystemInformation.VerticalScrollBarWidth;<br />
SBHEI := SystemInformation.HorizontalScrollBarHeight;<br />
rcCtl := fg.Bounds;<br />
rcClient := fg.ClientRectangle;<br />
vbar := rcCtl.Width - rcClient.Width >= SBWID;<br />
hbar := rcCtl.Height - rcClient.Height >= SBHEI;<br />
if vbar And hbar then<br />
begin<br />
Result := ScrollBars.Both;<br />
exit;<br />
end;<br />
if vbar then<br />
begin<br />
Result := ScrollBars.Vertical;<br />
exit;<br />
end;<br />
if hbar then<br />
begin<br />
Result := ScrollBars.Horizontal;<br />
exit;
end;<br />
Result := ScrollBars.None;<br />
end; // CheckScrollBars<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
ScrollPosition-Eigenschaft<br />
Gibt/legt die Bildlaufleistenposition zurück/fest.<br />
Syntax<br />
[VB]<br />
Public ScrollPosition As Point<br />
[C#]<br />
public Point ScrollPosition {get; set;}<br />
[Delphi]<br />
property ScrollPosition: Point;<br />
Eigenschaftswerte<br />
Ein Point-Objekt, das die Bildlaufleistenposition in Pixeln enthält.<br />
Bemerkungen<br />
ScrollPosition-Eigenschaft · 161<br />
Verwenden Sie die ScrollPosition-Eigenschaft um mit Pixel als Einheiten, und die LeftCol- und<br />
TopRow-Eigenschaften, um mit Zellen als Einheiten zu scrollen.<br />
Beispiel<br />
Dieser Quelltext bindet zwei Tabellen (fgLeft und fgRight) zusammen und synchronisiert deren<br />
vertikalen Bildlauf. Die Nutzer können nur noch horizontal unabhängig scrollen.<br />
• Visual Basic<br />
' bind grids together<br />
fgRight.DataSource = fgLeft<br />
fgLeft.ScrollBars = ScrollBars.Horizontal<br />
' synchronize vertical scrolling<br />
Private Sub flex_AfterScroll(sender As Object, _<br />
e As C1.Win.<strong>C1FlexGrid</strong>.RangeEventArgs)<br />
' update sender grid (could be fgLeft or fgRight)<br />
Dim fg As <strong>C1FlexGrid</strong>.<strong>C1FlexGrid</strong> = CType(sender, <strong>C1FlexGrid</strong>) '<br />
fg.Update()<br />
' get new vertical position from sender grid<br />
Dim y As Integer = fg.ScrollPosition.Y<br />
' apply new vertical position to the other grid<br />
If fg = fgLeft Then<br />
fgRight.ScrollPosition = New Point(fgRight.ScrollPosition.X, y)<br />
Else<br />
fgLeft.ScrollPosition = New Point(fgLeft.ScrollPosition.X, y)
162 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
• C#<br />
End If<br />
End Sub 'flex_AfterScroll<br />
// bind grids together<br />
fgRight.DataSource = fgLeft;<br />
fgLeft.ScrollBars = ScrollBars.Horizontal;<br />
// synchronize vertical scrolling<br />
private void flex_AfterScroll(object sender,<br />
C1.Win.<strong>C1FlexGrid</strong>.RangeEventArgs e)<br />
{<br />
// update sender grid (could be fgLeft or fgRight)<br />
<strong>C1FlexGrid</strong>.<strong>C1FlexGrid</strong> fg = ((<strong>C1FlexGrid</strong>)sender);<br />
fg.Update();<br />
}<br />
• Delphi<br />
// get new vertical position from sender grid<br />
int y = fg.ScrollPosition.Y;<br />
// apply new vertical position to the other grid<br />
if (fg == fgLeft)<br />
fgRight.ScrollPosition = new Point(fgRight.ScrollPosition.X, y);<br />
else<br />
fgLeft.ScrollPosition = new Point(fgLeft.ScrollPosition.X, y);<br />
// bind grids together<br />
fgRight.DataSource := fgLeft;<br />
fgLeft.ScrollBars := ScrollBars.Horizontal;<br />
// synchronize vertical scrolling<br />
procedure flex_AfterScroll(sender: System.Object;<br />
e: C1.Win.<strong>C1FlexGrid</strong>.RangeEventArgs);<br />
var<br />
fg: <strong>C1FlexGrid</strong>;<br />
begin<br />
// update sender grid (could be fgLeft or fgRight)<br />
fg := <strong>C1FlexGrid</strong> (sender);<br />
fg.Update;<br />
// get new vertical position from sender grid<br />
y := fg.ScrollPosition.Y;<br />
// apply new vertical position to the other grid<br />
if fg = fgLeft then<br />
fgRight.ScrollPosition := Point.Create(fgRight.ScrollPosition.X, y)<br />
else<br />
fgLeft.ScrollPosition := Point.Create(fgLeft.ScrollPosition.X, y);<br />
end; // flex_AfterScroll<br />
Upgradenotiz: Die VSFlexGrid-Steuerung hat immer genau eine Zelle gescrollt und hat nichts<br />
Vergleichbares zur ScrollPosition-Eigenschaft besessen. Das <strong>C1FlexGrid</strong> kann in Pixeln scrollen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
ScrollTrack-Eigenschaft<br />
Legt das Tabellenverhalten fest, während der Nutzer die Bildlaufleisten zieht.
Syntax<br />
[VB]<br />
Public ScrollTrack As Boolean<br />
[C#]<br />
public bool ScrollTrack {get; set;}<br />
[Delphi]<br />
property ScrollTrack: Boolean;<br />
Bemerkungen<br />
ScrollTips-Eigenschaft · 163<br />
Wenn ScrollTrack auf TRUE steht (Standardwert), dann scrollt die Tabelle, während der Nutzer die<br />
Bildlaufleisten zieht.<br />
Wenn ScrollTrack auf FALSE steht, dann aktualisiert die Tabelle die Ansicht nicht, bis der Nutzer die<br />
Bildlaufleisten los lässt.<br />
Wenn die Tabelle sehr groß ist und viele Daten enthält, dann können Sie Scrollen beschleunigen, indem<br />
Sie ScrollTrack auf FALSE setzen. In diesem Fall sollte die Verwendung der ScrollTips-Eigenschaft in<br />
Betracht gezogen werden, um dem Nutzer eine Orientierung im Dokument zu geben, während er scrollt.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
ScrollTips-Eigenschaft<br />
Gibt zurück/legt fest, ob Quickinfos angezeigt werden, wenn der Nutzer die vertikale Bildlaufleiste<br />
zieht.<br />
Syntax<br />
[VB]<br />
Public ScrollTips As Boolean<br />
[C#]<br />
public bool ScrollTips<br />
[Delphi]<br />
property ScrollTips: Boolean;<br />
Bemerkungen<br />
Verwenden Sie die ScrollTips-Eigenschaft, um eine Quickinfo über der vertikalen Bildlaufleiste<br />
anzuzeigen, während der Nutzer den Bildlaufleistenbalken zieht. Diese zeigt ihm, welche Zeile sichtbar<br />
wird, wenn er den Bildlaufbalken loslässt. Diese Funktion erleichtert die Suche nach bestimmten Zeilen<br />
in großen Datentabellen und ist besonders sinnvoll, wenn die ScrollTrack-Eigenschaft auf FALSE steht,<br />
weil dann die Tabelle solange nicht scrollt, bis der Nutzer den Balken loslässt.<br />
Sie müssen folgende Schritte ausführen, um diese Funktion in Ihrem Programm zu implementieren:<br />
1. Setzen Sie die ScrollTips-Eigenschaft auf TRUE.
164 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Beispiel<br />
2. Fangen Sie das BeforeScrollTip-Ereignis ab, indem Sie die ScrollTipText-Eigenschaft auf einen<br />
Text setzen, der die aktuelle Zeile nennt.<br />
Dieser Quellcode zeigt eine Scrollinfo mit dem Index und den Daten der obersten sichtbar werdenden<br />
Zeile, wenn der Nutzer den Balken freigeben würde, an.<br />
• Visual Basic<br />
• C#<br />
flex.ScrollTips = True<br />
flex.ScrollTrack = False<br />
Private Sub flex_BeforeScrollTip(sender As Object, e As<br />
RowColEventArgs)<br />
Dim tip As String = String.Format("Row {0}" + ControlChars.Lf +<br />
"{1}", e.Row, flex(e.Row, 1))<br />
flex.ScrollTipText = tip<br />
End Sub 'flex_BeforeScrollTip<br />
flex.ScrollTips = True<br />
flex.ScrollTrack = False<br />
Private Sub flex_BeforeScrollTip(sender As Object, e As<br />
RowColEventArgs)<br />
Dim tip As String<br />
tip = String.Format("Row {0}" + ControlChars.Lf + "{1}", _<br />
e.Row, flex(e.Row, 1))<br />
flex.ScrollTipText = tip<br />
End Sub 'flex_BeforeScrollTip<br />
• Delphi<br />
flex.ScrollTips := True;<br />
flex.ScrollTrack := False;<br />
procedure Class1.flex_BeforeScrollTip(sender: System.Object; e:<br />
RowColEventArgs);<br />
var<br />
tip: string;<br />
begin<br />
tip := Format('Row {0}'#10'{1}', e.Row, flex[e.Row]);<br />
flex.ScrollTipText := tip;<br />
end;<br />
Scrollinfo ist ein besonderer Typ der Quickinfo, die an die vertikale Bildlaufleiste gebunden ist.<br />
Verwenden Sie die ToolTip-Steuerung, um allgemeine Quickinfos anzuzeigen (z.B. über Zellen):<br />
• Visual Basic<br />
Private ttip As New ToolTip(Me.components)<br />
Private Sub flex_MouseMove(sender As Object, e As<br />
System.Windows.Forms.MouseEventArgs)<br />
Dim str As String<br />
str = String.Format("This is cell {0}, {1}", _<br />
flex.MouseRow, flex.MouseCol)<br />
If str ttip.GetToolTip(flex) Then<br />
ttip.SetToolTip(flex, str)<br />
End If<br />
End Sub 'flex_MouseMove
• C#<br />
private ToolTip ttip = new ToolTip(this.components);<br />
private void flex_MouseMove(object sender,<br />
System.Windows.Forms.MouseEventArgs e)<br />
{<br />
string str = string.Format("This is cell {0}, {1}",<br />
flex.MouseRow, flex.MouseCol);<br />
if (str != ttip.GetToolTip(flex))<br />
ttip.SetToolTip(flex, str);<br />
}<br />
• Delphi<br />
private<br />
ttip: ToolTip;<br />
procedure flex_MouseMove(sender: System.Object; e:<br />
System.Windows.Forms.MouseEventArgs);<br />
var<br />
str: string;<br />
begin<br />
str := System.String.Format('This is cell {0}, {1}', _<br />
flex.MouseRow, flex.MouseCol);<br />
if str ttip.GetToolTip(flex) then<br />
ttip.SetToolTip(flex, str);<br />
end; // flex_MouseMove<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
ScrollTipText-Eigenschaft<br />
ScrollTipText-Eigenschaft · 165<br />
Gibt/legt die Quickinfo zurück/fest, die angezeigt wird, wenn der Nutzer die vertikale Bildlaufleiste<br />
zieht.<br />
Syntax<br />
[VB]<br />
Public ScrollTipText As String<br />
[C#]<br />
public string ScrollTipText {get; set;}<br />
[Delphi]<br />
property ScrollTipText: string;<br />
Bemerkungen<br />
Setzen Sie diese Eigenschaft als Antwort auf das BeforeScrollTip-Ereignis, um Information über eine<br />
gegebene Zeile, während der Nutzer den Inhalt der Tabelle scrollt, anzuzeigen.<br />
Für mehr Details und Beispiele schauen Sie bitte unter der ScrollTips-Eigenschaft nach.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)
166 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Selection-Eigenschaft<br />
Gibt ein CellRange-Objekt mit der aktuellen Auswahl zurück.<br />
Syntax<br />
[VB]<br />
Public Selection As CellRange<br />
[C#]<br />
public CellRange Selection {get;}<br />
[Delphi]<br />
property Selection: CellRange;<br />
Eigenschaftswerte<br />
Ein CellRange-Objekt, das für die Veränderung von Zellen in einer Auswahl verwendet werden kann.<br />
Bemerkungen<br />
Der Bereich entspricht der aktuellen Auswahl, die durch die Row-, Col-, RowSel- und ColSel-<br />
Eigenschaften definiert ist. Dieser Bereich ist normalisiert, so dass r1
Die Ausführung des Quellcodes erzuegt folgendes Ergebnis:<br />
SelectionMode-Eigenschaft · 167<br />
Cursor CellRange: (1,1)-(1,1), Selection CellRange: (1,1)-(5,5)<br />
Cursor CellRange: (5,5)-(5,5), Selection CellRange: (1,1)-(5,5)<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
SelectionMode-Eigenschaft<br />
Legt das Auswahlverhalten der Tabelle fest.<br />
Syntax<br />
[VB]<br />
Public SelectionMode As SelectionModeEnum<br />
[C#]<br />
public SelectionModeEnum SelectionMode {get; set;}<br />
[Delphi]<br />
property SelectionMode: SelectionModeEnum;<br />
Eigenschaftswerte<br />
Einer der SelectionModeEnum-Werte. Der Standardwert ist SelectionModeEnum.Default.<br />
Bemerkungen<br />
In den meisten Auswahlmodi können Sie die aktuelle Auswahl mit der Selection-Eigenschaft abfragen.<br />
Wenn allerdings der SelectionMode auf SelectionModeEnum.ListBox gesetzt ist, dann muss die<br />
Auswahl nicht zwingend aus einem ununterbrochenen Zeilenbereich bestehen. In diesem Fall können Sie<br />
den Auswahlstatus von einzelnen oder allen ausgewählten Zeilen mit der Selected-Eigenschaft für Zeilen<br />
abfragen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
SetCellCheck-Eigenschaft<br />
Legt den Zustand eines Kontrollkästchens in einer Zelle fest.<br />
Syntax<br />
[VB]<br />
Public SetCellCheck As Integer<br />
[C#]<br />
public Integer SetCellCheck {get; set;}<br />
[Delphi]<br />
property SetCellCheck: Integer;
168 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Bemerkungen<br />
Neben den gewöhnlichen Zellinhalten können Sie auch Kontrollkästchen anzeigen lassen. Hiefür stehen<br />
Ihnen zwei Möglichkeiten zur Verfügung:<br />
1. Um Kontrollkästchen direkt den Zellen zuzuordnen, können Sie die SetCellCheck- und<br />
GetCellCheck-Eigenschaften verwenden. In diesem Fall sind der Zellinhalt und das<br />
Kontrollkästchen unabhängig und Sie können Kästchen mit zwei oder drei Zuständen<br />
verwenden.<br />
2. Sie können aber auch die DataType-Eigenschaft des Spaltenobjekts auf Boolean setzen, so dass<br />
alle Werte dieser Spalte als Kontrollkästchen mit zwei Zuständen angezeigt werden.<br />
In beiden Modi kann der Nutzer die Kontrollkästchen mit der Maus und der Tastatur umschalten, wenn<br />
die AllowEditing-Eigenschaft auf TRUE steht.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
ShowButtons-Eigenschaft<br />
Legt fest, wann die Tabelle Auswahl- und Popup-Schaltflächen in bearbeitbaren Zellen anzeigen soll.<br />
Syntax<br />
[VB]<br />
Public ShowButtons As ShowButtonsEnum<br />
[C#]<br />
public ShowButtonsEnum ShowButtons {get;}<br />
[Delphi]<br />
property ShowButtons: ShowButtonsEnum;<br />
Eigenschaftswerte<br />
Einer der ShowButtonsEnum-Werte. Der Standardwert ist ShowButtonsEnum.WithFocus.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
ShowCellLabels-Eigenschaft<br />
Zeigt eine Art Quickinfo an, wenn der Mauszeiger über einer Zelle steht, die zu klein für ihren Inhalt ist.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft ShowCellLabels As Boolean<br />
[C#]<br />
public bool ShowCellLabels {get; set;}<br />
[Delphi]
property ShowCellLabels: Boolean;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
ShowCursor-Eigenschaft<br />
Legt fest, ob die Tabelle eine Datensatzmarkierungsgrafik anzeigen soll.<br />
Syntax<br />
[VB]<br />
Public ShowCursor As Boolean<br />
[C#]<br />
public bool ShowCursor {get; set;}<br />
[Delphi]<br />
property ShowCursor: Boolean;<br />
Bemerkungen<br />
ShowCursor-Eigenschaft · 169<br />
Legt fest, ob die Tabelle eine Datensatzmarkierungsgrafik auf der ersten fixierten Spalte der aktuellen<br />
Zeile anzeigen soll. Der Datensatzmarkierer ist ein kleines Dreieck, vergleichbar mit denen, die in Access<br />
und den meisten anderen datenbankbasierten Tabellen verwendet wird.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
ShowErrors-Eigenschaft<br />
Ermittelt oder legt fest, ob die Tabelle Fehler in der Datenquelle überwacht und anzeigt. Die Fehler<br />
werden vom Datenquellenobjekt über die IDataErrorInfo-Schnittstelle zur Verfügung gestellt. ADO.NET<br />
und C1Data unterstützen dies.<br />
Syntax<br />
[VB]<br />
Public ShowErrors As Boolean<br />
[C#]<br />
public bool ShowErrors {get; set;}<br />
[Delphi]<br />
property ShowErrors: Boolean;<br />
Bemerkungen<br />
Wenn diese Eigenschaft aktiviert ist, dann werden Zellen mit Fehlern ein Fehlersymbol anzeigen,<br />
anpassbar mit der SetGlyph-Methode. Wenn der Nutzer den Mauszeiger über das Fehlersymbol zieht,<br />
dann wird die Tabelle eine Quickinfo mit einer Fehlerbeschreibung anzeigen. Zum Beispiel:<br />
• Visual Basic<br />
Me._flex.ShowErrors = True
170 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
• C#<br />
dt.Rows(3).SetColumnError(_dt.Columns(0), "row 3, col 0 is bad") '<br />
dt.Rows(4).SetColumnError(_dt.Columns(1), "this cell is bad too") '<br />
dt.Rows(5).RowError = "This whole row is bad" '<br />
this._flex.ShowErrors = true;<br />
dt.Rows[3].SetColumnError(_dt.Columns[0], "row 3, col 0 is bad");<br />
dt.Rows[4].SetColumnError(_dt.Columns[1], "this cell is bad too");<br />
dt.Rows[5].RowError = "This whole row is bad";<br />
• Delphi<br />
Self._flex.ShowErrors := True;<br />
dt.Rows[3].SetColumnError(_dt.Columns[0], 'row 3, col 0 is bad');<br />
dt.Rows[4].SetColumnError(_dt.Columns[1], 'this cell is bad too');<br />
dt.Rows[5].RowError := 'This whole row is bad';<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
Styles-Eigenschaft<br />
Gibt alle Zellformate in einer Tabelle zurück.<br />
Syntax<br />
[VB]<br />
Public Styles As CellStyleCollection<br />
[C#]<br />
public CellStyleCollection Styles {get;}<br />
[Delphi]<br />
property Styles: CellStyleCollection;<br />
Bemerkungen<br />
Mit der Styles-Eigenschaft können Sie einen Verweis auf eine Liste aller derzeit in der Tabelle definierten<br />
Formate abfragen. Mit diesem Verweis können Sie Formatvorlagen hinzufügen, entfernen und zählen.<br />
Für weitere Informationen über die Aufgaben, die mit dieser Liste ausgeführt werden können, schauen<br />
Sie unter CellStyleCollection-Klassenreferenzthemen für Informationen über Zellformatierungen unter<br />
CellStyle-Referenzthemen nach.<br />
Diese Eigenschaft kann nur gelesen werden. Die Tabelle erstellt und verwaltet die Liste für Sie.<br />
Upgradenotiz: Die VSFlexGrid ActiveX-Steuerung hatte viele Eigenschaften, welche die Anzeige der<br />
Tabelle beeinflusst haben (z.B. BackColor, BackColorAlternate, BackColorBkg, BackColorFixed,<br />
BackColorFrozen, BackColorSel, usw.). Die <strong>C1FlexGrid</strong>-Steuerung ersetzt all diese Eigenschaften mit<br />
einer CellStyleCollection der CellStyle-Objekte. Damit ist das Objektmodel einfacher, konsistenter und<br />
stärker. Sie können die bestehenden Formatvorlagen verändern oder Ihre eigenen definieren und diese<br />
Zeilen, Spalten oder willkürlichen Zellebereichen zuordnen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)
SubTotalPosition-Eigenschaft<br />
SubTotalPosition-Eigenschaft · 171<br />
Legt fest, ob die Subtotal-Methode die Knotenzeilen unter oder über den Daten, die zusammengefasst<br />
werden, einfügt.<br />
Syntax<br />
[VB]<br />
Public SubTotalPosition As SubTotalPositionEnum<br />
[C#]<br />
public SubTotalPositionEnum SubTotalPosition {get; set;}<br />
[Delphi]<br />
property SubTotalPosition: SubTotalPositionEnum;<br />
Eigenschaftswerte<br />
Einer der SubTotalPositionEnum-Werte. Der Standardwert ist SubTotalPositionEnum.AboveData.<br />
Bemerkungen<br />
Diese Eigenschaft legt auch fest, wie der Gliederungsbaum gezeichnet wird. Eine Änderung dieser<br />
Eigenschaft entfernt alle in der Tabelle enthaltenen Knotenzeilen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
TopRow-Eigenschaft<br />
Gibt/legt den Index der obersten sichtbaren und nicht fixierten Zeilen zurück/fest.<br />
Syntax<br />
[VB]<br />
Public TopRow As Integer<br />
[C#]<br />
public int TopRow {get; set;}<br />
[Delphi]<br />
property TopRow: Integer;<br />
Bemerkungen<br />
Wenn Sie einen Wert für die TopRow-Eigenschaft festlegen, dann wird die Tabelle vertikal gescrollt, bis<br />
die eingegebene Zeile am obersten Rand der Anzeige sichtbar wird. Dies ist nützlich, wenn Sie zwei oder<br />
mehr Tabellen synchronisieren wollen und somit, wenn die eine gescrollt wird, die andere sich<br />
mitbewegt. Verwenden Sie die LeftCol-Eigenschaft, um horizontal zu scrollen.<br />
Der größte Wert dieser Eigenschaft ist die Summe aller Zeilen, minus derer, die auf dem Bildschirm<br />
gleichzeitig angezeigt werden können. Wenn Sie TopRow auf einen größeren Wert stellen, dann wird die<br />
Steuerung den größtmöglichen Wert für diese Tabelle ohne Fehlermeldung annehmen.
172 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Die Werte, die von den LeftCol- und TopRow-Eigenschaften zurückgegeben werden, entsprechen den<br />
auf dem Bildschirm teilweise oder vollständig sichtbaren Zeilen und Spalten.<br />
Verwenden Sie die LeftCol- und TopRow-Eigenschaften um mit Zellen als Einheiten, und die<br />
ScrollPosition-Eigenschaft um mit Pixel als Einheiten zu scrollen.<br />
Verwenden Sie die ShowCell-Methode, um sicherzustellen, dass eine Zelle angezeigt wird.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
Tree-Eigenschaft<br />
Gibt das GridTree-Objekt zurück, das die Ansicht des Gliederungsbaums in einer Tabelle steuert.<br />
Syntax<br />
[VB]<br />
Public Tree As GridTree<br />
[C#]<br />
public GridTree Tree {get;}<br />
[Delphi]<br />
property Tree: GridTree;<br />
Bemerkungen<br />
Die <strong>C1FlexGrid</strong>-Steuerung kann Daten hierarchisch gruppieren und diese mit einem erweiterbaren<br />
Gliederungsbaum, ähnlich dem in der Microsoft TreeView-Steuerung, anzeigen. Das GridTree-Objekt<br />
wird für die Festlegung der Position und des Formats von Gliederungsbäumen verwendet.<br />
Diese Eigenschaft kann nur gelesen werden.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>-Methoden<br />
AddItem-Methode<br />
Fügt eine neue Zeile der Tabelle hinzu und füllt diese mit den gegebenen Daten.<br />
Syntax<br />
[VB]<br />
Public Function AddItem(item As String) As Row<br />
Public Function AddItem(item As String, index As Integer) As Row<br />
Public Function AddItem(items As Object( )) As Row<br />
Public Function AddItem(items As Object( ), rowIndex As Integer, colIndex As Integer) As Row
[C#]<br />
public Row AddItem (String item )<br />
public Row AddItem (String item , Int index )<br />
public Row AddItem ( object[] items )<br />
public Row AddItem ( object[] items , Int rowIndex , Int colIndex )<br />
[Delphi]<br />
function AddItem(item: string): Row;<br />
function AddItem(item: string; index: Integer): Row;<br />
function AddItem(items: Object): Row;<br />
function AddItems(items: Object; rowIndex: Integer; colIndex: Integer): Row;<br />
Parameter Beschreibung<br />
Item<br />
index<br />
Zeichenkette mit Daten für jede Zelle auf der neuen Zeile. Die Daten werden<br />
standardmäßig von einem Tabulatorzeichen getrennt. Sie können das<br />
Trennzeichen in der ClipSeparators-Eigenschaft ändern.<br />
Position, an der die Zeile eingefügt wird. Wenn dieser Parameter weggelassen<br />
wird, dann fügt die Steuerung die Zeile am Ende der Tabelle an.<br />
items Array mit Objekten, die in die neue Zeile eingefügt werden.<br />
colIndex<br />
Bemerkungen<br />
Erste Spalte, die mit den Daten des items-Array gefüllt wird. Dieser Parameter<br />
ist normalerweise Null oder die erste scrollbare Spalte.<br />
AddItem-Methode · 173<br />
Sie können Zeilen auch mit der Rows-Collection hinzufügen oder entfernen. Die AddItem-Methode stellt<br />
aber einen kurzen Syntax für das Einfügen einer Zeile, mit der Insert-Zeilenmethode, und das Ausfüllen<br />
einer jeden Zelle, zur Verfügung.<br />
Beispiel<br />
Der nachfolgende Quellcode fügt der Tabelle drei Zeilen hinzu:<br />
• Visual Basic<br />
• C#<br />
' add row at the bottom, using tabs as separators<br />
flex.ClipSeparators = vbTab + vbLf '
174 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
flex.AddItem("col 0\tcol1\tcol2");<br />
// add row at the top, using pipes as separators<br />
flex.ClipSeparators = "|;";<br />
flex.AddItem("col 0|col1|col2", 0);<br />
// add row at the bottom, using an object array<br />
object[] items = { "col0", "col1", 12 };<br />
flex.AddItem(items, flex.Rows.Count, 0);<br />
• Delphi<br />
var<br />
items: array of System.Object;<br />
begin<br />
flex.ClipSeparators := #9#10;<br />
flex.AddItem('col 0'#9'col1'#9'col2');<br />
flex.ClipSeparators := '|;';<br />
flex.AddItem('col 0|col1|col2', 0);<br />
SetLength(items, 3);<br />
items[0] := 'col0';<br />
items[1] := 'col1';<br />
items[2] := System.Object(12);<br />
flex.AddItem(items, flex.Rows.Count, 0);<br />
end;<br />
Für weitere Beispiele, schauen Sie unter der Redraw-Eigenschaft und unter dem Thema „Tabellen in<br />
Textdateien speichern und öffnen“ (Seite 62) nach.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
Aggregate-Methode<br />
Berechnet aggregierte Statistiken für einen Zellbereich.<br />
Syntax<br />
[VB]<br />
Public Function Aggregate(aggType As AggregateEnum) As Double<br />
Public Function Aggregate(aggType As AggregateEnum, flags As AggregateFlags) As Double<br />
Public Function Aggregate(aggType As.AggregateEnum, rg As CellRange) As Double<br />
Public Function Aggregate(aggType As AggregateEnum, rg As CellRange, flags As AggregateFlags) As<br />
Double<br />
Public Function Aggregate(aggType As AggregateEnum, r1 As Integer, c1 As Integer, r2 As Integer, c2<br />
As Integer) As Double<br />
Public Function Aggregate(aggType As AggregateEnum, r1 As Integer, c1 As Integer, r2 As Integer, c2<br />
As Integer, flags As AggregateFlags) As Double<br />
[C#]<br />
public Double Aggregate (AggregateEnum aggType, int r1, int c1, int r2, int c2)<br />
public Double Aggregate (AggregateEnum aggType )<br />
public Double Aggregate (AggregateEnum aggType, CellRange rg )
Aggregate-Methode · 175<br />
public Double Aggregate (AggregateEnum aggType, int r1, int c1, int r2, int c2, AggregateFlags flags)<br />
public Double Aggregate (AggregateEnum aggType, AggregateFlags flags)<br />
public Double Aggregate (AggregateEnum aggType, CellRange rg, AggregateFlags flags)<br />
[Delphi]<br />
function Aggregate(aggType: AggregateEnum): Double;<br />
function Aggregate(aggType: AggregateEnum; flags: AggregateFlags): Double;<br />
function Aggregate(aggType: AggregateEnum; rg: CellRange): Double;<br />
function Aggregate(aggType: AggregateEnum; rg: CellRange; flags: AggregateFlags): Double;<br />
function Aggregate(aggType: AggregateEnum; r1: Integer; c1:Integer; r2: Integer; c2: Integer): Double;<br />
function Aggregate(aggType: AggregateEnum; r1: Integer; c1:Integer; r2: Integer; c2: Integer; flags:<br />
AggregateFlags): Double;<br />
Parameter Beschreibung<br />
Function<br />
Einer der AggregateEnum-Werte. Dieser Parameter legt den zu<br />
berechnenden Typ der Aggregierung fest.<br />
row1, col1, row2, col2 Vier Integer-Werte, die den zu aggregierenden Zellbereich festlegen.<br />
Rg Ein CellRange-Objekt, das den zu aggregierenden Zellbereich festlegt.<br />
flags<br />
Rückgabewert<br />
Eine Kombination von Werten aus der AggregateFlags-Aufzählung. Der<br />
Standardwert ist AggregateFlags.None.<br />
Ein Double-Wert für die berechnete Gesamtmenge.<br />
Beispiel<br />
Dieser Quellcode verwendet die Aggregate-Methode um aggregierte Statistiken für willkürliche Bereiche<br />
zu berechen. Immer wenn sich die Auswahl in der Tabelle verändert, dann werden die Gesamtmengen<br />
neu berechnet und in die Konsole geschrieben.<br />
• Visual Basic<br />
• C#<br />
Private Sub flex_SelChange(sender As Object, e As System.EventArgs)<br />
Dim fmt As String = "Count {0:0}, Sum {1:#,##0.00}, " & _<br />
"Avg {2:#,##0.00}, Stdev {3:#,##0.00}"<br />
Dim agg As String = String.Format(fmt, _<br />
flex.Aggregate(AggregateEnum.Count), _<br />
flex.Aggregate(AggregateEnum.Sum), _<br />
flex.Aggregate(AggregateEnum.Average), _<br />
flex.Aggregate(AggregateEnum.Std))<br />
Console.WriteLine(agg)<br />
End Sub 'flex_SelChange<br />
private void flex_SelChange(object sender, System.EventArgs e)<br />
{
176 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
}<br />
• Delphi<br />
string fmt = "Count {0:0}, Sum {1:#,##0.00}, " +<br />
"Avg {2:#,##0.00}, Stdev {3:#,##0.00}";<br />
string agg = string.Format(fmt,<br />
flex.Aggregate(AggregateEnum.Count),<br />
flex.Aggregate(AggregateEnum.Sum),<br />
flex.Aggregate(AggregateEnum.Average),<br />
flex.Aggregate(AggregateEnum.Std));<br />
Console.WriteLine(agg);<br />
procedure Class1.flex_SelChange(sender: System.Object; e:<br />
System.EventArgs);<br />
var<br />
agg: string;<br />
fmt: string;<br />
begin<br />
fmt := ('Count {0:0}, Sum {1:#,##0.00}, ' + 'Avg {2:#,##0.00}, Stdev<br />
{3:#,##0.00}');<br />
agg := System.String.Format(fmt, flex.Aggregate(AggregateEnum.Count),<br />
flex.Aggregate(AggregateEnum.Sum),<br />
flex.Aggregate(AggregateEnum.Average),<br />
flex.Aggregate(AggregateEnum.Std));<br />
Console.WriteLine(agg);<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
AutoSizeCol-Methode<br />
Passt die Breite der aktuellen Spalte an ihre Daten an.<br />
Syntax<br />
[VB]<br />
Public Sub AutoSizeCol(col As Integer)<br />
Public Sub AutoSizeCol(col As Integer, extraSpace As Integer)<br />
[C#]<br />
public virtual void AutoSizeCol ( int col )<br />
public virtual void AutoSizeCol ( int col , int extraSpace )<br />
[Delphi]<br />
procedure AutoSizeCol(col: Integer);<br />
procedure AutoSizeCol(col: Integer, extraSpace: Integer);<br />
Parameter Beschreibung<br />
col Der Index der anzupassenden Spalte.<br />
extraSpace Die Anzahl der Pixel, die zusätzlich zur Breite hinzugefügt werden.
Bemerkungen<br />
AutoSizeCols-Methode · 177<br />
Diese Methode misst den Inhalt einer jeden Zelle in der Spalte aus, mit Rücksicht auf ihre Formatierung.<br />
Wenn die Tabelle viele Zeilen besitzt, dann sollten Sie die AutoSizeCols-Methode in Betracht ziehen, mit<br />
der Sie die einzelnen Spalten und Zeilen, die ausgemessen werden sollen, festlegen können.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
AutoSizeCols-Methode<br />
Passt die Breite aller Spalte an ihre Daten an.<br />
Syntax<br />
[VB]<br />
Public Sub AutoSizeCols()<br />
Public Sub AutoSizeCols(extraSpace As Integer)<br />
Public Sub AutoSizeCols(col1 As Integer, col2 As Integer, extraSpace As Integer)<br />
Public Sub AutoSizeCols(row1 As Integer, col1 As Integer, row2 As Integer, col2 As Integer, extraSpace<br />
As Integer, flags As AutoSizeFlags)<br />
Protected Sub AutoSizeCols(g As Graphics, row1 As Integer, col1 As Integer, row2 As Integer, col2 As<br />
Integer, extra As Integer, flags As AutoSizeFlags)<br />
[C#]<br />
public virtual void AutoSizeCols ( )<br />
public virtual void AutoSizeCols ( int extraSpace )<br />
public virtual void AutoSizeCols ( int col1 , int col2 , int extraSpace )<br />
public virtual void AutoSizeCols ( int row1 , int col1 , int row2 , int col2 , int extraSpace , AutoSizeFlags<br />
flags )<br />
public protected internal virtual void AutoSizeCols (Graphics g , int row1 , int col1 , int row2 , int col2 ,<br />
int extra ,AutoSizeFlags flags )<br />
[Delphi]<br />
procedure AutoSizeCols;<br />
procedure AutoSizeCols(extraSpace: Integer);<br />
procedure AutoSizeCols(col1: Integer; col2: Integer; extraSpace: Integer);<br />
procedure AutoSizeCols(row1: Integer; col1: Integer; row2: Integer; col2: Integer; extraSpace: Integer;<br />
flags: AutoSizeFlags);<br />
procedure AutoSizeCols(g: Graphics; row1: Integer; col1: Integer; row2: Integer; col2: Integer; extra:<br />
Integer; flags: AutoSizeFlags);<br />
Parameter Beschreibung<br />
col1, col2 Der Index der ersten und letzten anzupassenden Spalte.
178 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
row1, row2<br />
Die zu vermessenden Zeilen. Wenn nicht festgelegt, dann werden alle Zeilen<br />
verwendet.<br />
extraSpace Die Anzahl der Pixel, die zusätzlich zur Breite hinzugefügt werden.<br />
flags<br />
Bemerkungen<br />
Eine Kombination von Werten der AutoSizeFlags-Aufzählung. Die Flags legen<br />
Optionen, wie z.B. versteckte oder verbundene Spalten ignorieren oder allen<br />
Spalten die gleiche Breite zuordnen, fest.<br />
Standardmäßig misst diese Methode den Inhalt einer jeden Zelle in den Spalten aus, mit Rücksicht auf<br />
deren Formatierung. Wenn die Tabelle viele Zeilen besitzt, dann sollten Sie die Version wählen, mit der<br />
Sie einen Zeilenbereich festlegen können. Sie können allerdings nur ein paar hundert Zeilen und etwas<br />
zusätzlichen Platz in den Prozess einbeziehen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
AutoSizeRow-Methode<br />
Passt die Höhe einer einzelnen Zeile an ihre Daten an.<br />
Syntax<br />
[VB]<br />
Public Sub AutoSizeRow(row As Integer)<br />
[C#]<br />
public virtual void AutoSizeRow ( int row )<br />
[Delphi]<br />
procedure AutoSizeRow(row: Integer);<br />
Parameter Beschreibung<br />
row Der Index der anzupassenden Zeile.<br />
Bemerkungen<br />
Diese Methode misst den Inhalt einer jeden Zelle in der Spalte aus, mit Rücksicht auf ihre Formatierung.<br />
Wenn Sie viele Zeilen gleichzeitig anpassen wollen, dann sollten Sie die AutoSizeRows-Methode in<br />
Betracht ziehen.<br />
Beispiel<br />
Schauen Sie im ChangeEdit-Ereignis nach.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)
AutoSizeRows-Methode<br />
Passt die Höhe einer Auswahl von Zeilen an ihre Daten an.<br />
Syntax<br />
[VB]<br />
Public Sub AutoSizeRows()<br />
AutoSizeRows-Methode · 179<br />
Public Sub AutoSizeRows(row1 As Integer, col1 As Integer, row2 As Integer, col2 As Integer, extra As<br />
Integer, flags As AutoSizeFlags)<br />
[C#]<br />
public virtual void AutoSizeRows ( )<br />
public protected internal virtual void AutoSizeRows (Graphics g , int row1 , int col1 , int row2 , int col2 ,<br />
int extra , AutoSizeFlags flags )<br />
[Delphi]<br />
procedure AutoSizeRows;<br />
procedure AutoSizeRows(g: Graphics; row1: Integer; col1: Integer; row2: Integer; col2: Integer; extra:<br />
Integer; flags: AutoSizeFlags);<br />
Parameter Beschreibung<br />
col1, col2<br />
Der Index der ersten und letzten zu vermessenden Spalte. Wenn nicht festgelegt,<br />
dann werden alle Spalten verwendet.<br />
row1, row2 Der Index der ersten und letzten anzupassenden Zeile.<br />
extraSpace Die Anzahl der Pixel, die zusätzlich zur Höhe hinzugefügt werden.<br />
flags<br />
Bemerkungen<br />
Eine Kombination von Werten der AutoSizeFlags-Aufzählung. Die Flags legen<br />
Optionen fest, wie z.B. versteckte oder verbundene Zeilen ignorieren oder allen<br />
Zeilen die gleiche Höhe zuordnen.<br />
Diese Methode misst den Inhalt einer jeden Zelle in der Spalte aus, mit Rücksicht auf ihre Formatierung.<br />
Um eine einzelne Zeile anzupassen, verwenden Sie die AutoSizeRow-Methode.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
Clear-Methode (<strong>C1FlexGrid</strong>)<br />
Löscht die Inhalte einer Tabelle.<br />
Syntax<br />
[VB]<br />
Public Sub Clear()
180 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Public Sub Clear(clearFlags As ClearFlags)<br />
Public Sub Clear(clearFlags As ClearFlags, rg As CellRange)<br />
Public Sub Clear(clearFlags As ClearFlags, row As Integer, col As Integer)<br />
Public Sub Clear(clearFlags As ClearFlags, row1 As Integer, col1 As Integer, row2 As Integer, col2 As<br />
Integer)<br />
[C#]<br />
public void Clear ()<br />
public void Clear (ClearFlags clearFlags )<br />
public void Clear (ClearFlags clearFlags , int row , int col )<br />
public void Clear (ClearFlags clearFlags , int row1 , int col1 , int row2 , int col2 )<br />
public void Clear (ClearFlags clearFlags , CellRange rg )<br />
[Delphi]<br />
procedure Clear;<br />
procedure Clear(clearFlags: ClearFlags);<br />
procedure Clear(clearFlags: ClearFlags; row: Integer; col: Integer);<br />
procedure Clear(clearFlags: ClearFlags; row1: Integer; col1: Integer; row2: Integer; col2: Integer);<br />
procedure Clear(clearFlags: ClearFlags; rg: CellRange);<br />
Parameter Beschreibung<br />
flags<br />
rg<br />
row1, col1, row2, col2<br />
Bemerkungen<br />
Eine Kombination von Werten der ClearFlags-Aufzählung. Die Flags legen<br />
fest, was gelöscht werden soll. (Daten, Formatierung, usw.). Der Standard ist<br />
ClearFlags.All, welcher alle Daten, Formate und Nutzerdaten aus den Zellen,<br />
Zeilen und Spalten löscht.<br />
Ein CellRange-Objekt, dass den zu löschenden Bereich festlegt.<br />
Standardmäßig wird die gesamte Tabelle gelöscht.<br />
Vier Indizes, die den zu löschenden Bereich festlegen. Standardmäßig wird die<br />
gesamte Tabelle gelöscht.<br />
Die Clear-Methode verändert nicht die Anzahl der Zeilen und Spalten in einer Tabelle und kann auch<br />
nicht für das Löschen von Daten in an Datenquellen gebundene Tabellen verwendet werden.<br />
Schauen Sie unter ClearFlags für detailliertere Information über die Elemente, die entfernent werden,<br />
wenn diese Methode verwendet wird, nach.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)
CreateImage-Methode<br />
Erstellt eine Grafik von der gesamten Tabelle oder einer Auswahl.<br />
Syntax<br />
[VB]<br />
Public Function CreateImage() As Image<br />
Public Function CreateImage(rg As CellRange) As Image<br />
Public Function CreateImage(rg As CellRange, emfType As EmfType) As Image<br />
CreateImage-Methode · 181<br />
Public Function CreateImage(row1 As Integer, col1 As Integer, row2 As Integer, col2 As Integer) As<br />
Image<br />
Public Function CreateImage(row1 As Integer, col1 As Integer, row2 As Integer, col2 As Integer,<br />
emfType As EmfType) As Image<br />
[C#]<br />
public Image CreateImage ( )<br />
public Image CreateImage (CellRange rg )<br />
public Image CreateImage (CellRange rg , EmfType emfType )<br />
public Image CreateImage ( int row1 , System.Int32 col1 , int row2 , int col2 )<br />
public Image CreateImage ( int row1 , int col1 , int row2 , int col2 , EmfType emfType )<br />
[Delphi]<br />
function CreateImage: Image;<br />
function CreateImage(rg: CellRange): Image;<br />
function CreateImage(rg: CellRange; emfType: EmfType): Integer;<br />
function CreateImage(row1: Integer; col1: Integer; row2: Integer; col2: Integer): Image;<br />
function CreateImage(row1: Integer; col1: Integer; row2: Integer; col2: Integer; emfType: EmfType):<br />
Image;<br />
Parameter Beschreibung<br />
Range<br />
row1, col1, row2, col2<br />
emfType<br />
Ein CellRange-Objekt, das den Zellbereich beinhaltet, der in die Grafik<br />
eingeschlossen werden soll. Standardmäßig gibt diese Methode eine Grafik<br />
über die gesamte Tabelle zurück.<br />
Vier Indizes, die den Zellbereich beinhaltet, der in die Grafik eingeschlossen<br />
werden soll. Standardmäßig gibt diese Methode eine Grafik über die gesamte<br />
Tabelle zurück.<br />
Ein Wert der EmfType-Aufzählung, der den Typ der zu erstellenden Metadatei<br />
(GDI, GDI+ oder dual) festlegt. Der Standardwert für diesen Parameter ist<br />
EmfType.EmfOnly.
182 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Rückgabewert<br />
Ein Image-Objekt, das eine Metadateigrafik der Tabelle enthält.<br />
Bemerkungen<br />
Verwenden Sie diese Methode, um Tabellenbilder in die Zwischenablage zu kopieren und diese in<br />
andere Anwendungen einzufügen.<br />
Zum Beispiel, der nachfolgende Quellcode erstellt ein Bild eines Tabellenbereiches und speichert dieses<br />
in eine *.png-Datei, so dass diese in andere Dokumente, z.B. Webseiten, eingefügt werden kann:<br />
• Visual Basic<br />
• C#<br />
Private Sub button1_Click(sender As Object, e As System.EventArgs)<br />
Dim img As Image = _flex.CreateImage(0, 0, 10, 5)<br />
img.Save("c:\temp\flex.png") '<br />
End Sub 'button1_Click<br />
private void button1_Click(object sender, System.EventArgs e)<br />
{<br />
Image img = _flex.CreateImage(0,0,10,5);<br />
img.Save(@"c:\temp\flex.png",<br />
System.Drawing.Imaging.ImageFormat.Png);<br />
}<br />
• Delphi<br />
procedure Class1.button1_Click(sender: System.Object; e:<br />
System.EventArgs);<br />
var<br />
img: Image;<br />
begin<br />
img := _flex.CreateImage(0, 0, 10, 5);<br />
img.Save('c:\temp\flex.png', System.Drawing.Imaging.ImageFormat.Png);<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
DrawCell-Methode<br />
Zeichnet eine ganze oder Teile einer Zelle.<br />
Syntax<br />
[VB]<br />
Public Sub DrawCell()<br />
Public Sub DrawCell(flags As DrawCellFlags)<br />
[C#]<br />
public void DrawCell ( )<br />
public void DrawCell (DrawCellFlags flags )<br />
[Delphi]<br />
procedure DrawCell;
procedure DrawCell(flags: DrawCellFlags);<br />
Bemerkungen<br />
FindRow-Methode · 183<br />
Diese Methode wird in Routinen verwendet, die das OwnerDrawCell-Ereignis abfangen, welches<br />
gestartet wird, wenn die DrawMode-Eigenschaft auf OwnerDraw steht. Die DrawCell-Methode ist<br />
nützlich, wenn Sie Teile der Zelle neben der standardmäßigen Zeichenroutine der Tabelle selbst zeichnen<br />
wollen.<br />
Die Flags-Parameter legen fest, welcher Zellteil gezeichnet werden soll. Die Optionen sind:<br />
Parameter Beschreibung<br />
Background Die Steuerung zeichnet den Hintergrund.<br />
Border Die Steuerung zeichnet die Rahmen.<br />
Content Die Steuerung zeichnet den Zellinhalt (Text und Grafiken).<br />
All Die Steuerung zeichnet die gesamte Zelle.<br />
Normalerweise wird der Quellcode (1) den Zellhintergrund zeichnen und die DrawCell aufrufen, um<br />
Zellrahmen und –inhalt anzuzeigen, oder (2) die DrawCell aufrufen, um den Hintergrund und die<br />
Rahmen zu zeichen, und anschließend benutzerdefinierten Code verwenden, um die Inhalte zu zeichnen.<br />
Schauen Sie ferner unter<br />
OwnerDrawCellEventArgs-Klasse (Seite <strong>28</strong>8)<br />
FindRow-Methode<br />
Sucht eine Zeile, die eine gegebene Zeichenkette oder ein gegebenes Objekt enthält.<br />
Syntax<br />
[VB]<br />
Public Function FindRow(objFind As Object, rowStart As Integer, col As Integer, wrap As Boolean) As<br />
Integer<br />
Public Function FindRow(strFind As String, rowStart As Integer, col As Integer, caseSensitive As<br />
Boolean, fullMatch As Boolean, wrap As Boolean) As Integer<br />
[C#]<br />
public Integer FindRow (Object objFind , int rowStart , int col , Boolean wrap )<br />
public Integer FindRow (String strFind , int rowStart , int col , Boolean caseSensitive , Boolean fullMatch ,<br />
Boolean wrap )<br />
[Delphi]<br />
function FindRow(objFind: Object; rowStart: Integer; col: Integer; wrap: Boolean): Integer;<br />
function FindRow(strFind: string; rowStart: Integer; col: Integer; caseSensitive: Boolean; fullMatch:<br />
Boolean; wrap: Boolean): Integer;
184 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Parameter Beschreibung<br />
strFind Zeichenkette, nach der gesucht wird.<br />
objFind Objekt, nach dem gesucht wird.<br />
rowStart Index der Zeile, in der die Suche beginnen soll.<br />
col Spalte, welche die gesuchten Daten enthält.<br />
caseSensitive Ob die Suche Groß- und Kleinschreibung berücksichtigt.<br />
fullMatch<br />
wrap<br />
Rückgabewert<br />
Ob die Suchwörter genau gefunden werden müssen. Wenn dieser Parameter auf<br />
FALSE steht, dann ergibt z.B. die Suche nach „John“ u.a. auch „Johnson".<br />
Ob die Suche am Ende der Tabelle anhalten, oder in der ersten, scrollbaren Zeile<br />
fortfahren soll.<br />
Der Index der Zeile mit den gesuchten Daten oder –1, wenn die Daten nicht gefunden wurden.<br />
Bemerkungen<br />
Verwenden Sie die AutoSearch-Eigenschaft, um nach Daten zu suchen, während der Nutzer noch tippt.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
FinishEditing-Methode<br />
Beendet die Bearbeitung der aktuellen Zelle und den Bearbeitungsmodus der Tabelle.<br />
Syntax<br />
[VB]<br />
Public Function FinishEditing() As Boolean<br />
Public Function FinishEditing(cancel As Boolean) As Boolean<br />
[C#]<br />
public Boolean FinishEditing ( )<br />
public Boolean FinishEditing (Boolean cancel )<br />
[Delphi]<br />
function FinishEditing: Boolean;<br />
function FinishEditing(cancel: Boolean): Boolean;<br />
Parameter Beschreibung<br />
cancel<br />
Gibt an, ob die aktuellen Veränderungen abgebrochen und der ursprüngliche Wert<br />
wiederhergestellt werden soll.
Rückgabewert<br />
GetCellCheck-Methode · 185<br />
TRUE, wenn die Tabelle sich nicht mehr im Bearbeitungsmodus befindet; FALSE, wenn die<br />
Gültigkeitsprüfung fehl schlägt und die Tabelle zurück in den Bearbeitungsmodus versetzt wird.<br />
Bemerkungen<br />
Überprüfen Sie ob die Editor-Eigenschaft Null ist, um festzustellen, ob die Tabelle sich im<br />
Bearbeitungsmodus befindet.<br />
Wenn der cancel-Parameter auf FALSE steht, dann wird die Tabelle die Ereignisse ValidateEdit und<br />
AfterEdit wie üblich starten. Je nach dem, wie diese Ereignisse abgefangen werden, kehrt die Tabelle<br />
eventuell in den Bearbeitungsmodus zurück. Wenn der cancel-Pparameter auf TRUE steht, dann verlässt<br />
die Tabelle den Bearbeitungsmodus.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
GetCellCheck-Methode<br />
Gibt den Zustand eines Kontrollkästchens in einer Tabellenzelle zurück.<br />
Syntax<br />
[VB]<br />
Public Function GetCellCheck(row As Integer, col As Integer) As CheckEnum<br />
[C#]<br />
public virtual CheckEnum GetCellCheck ( int row , int col )<br />
[Delphi]<br />
function GetCellCheck(row: Integer; col: Integer): CheckEnum;<br />
Parameter Beschreibung<br />
row, col Die Koordinaten der Zelle.<br />
Rückgabewert<br />
Einer der Werte der CheckEnum-Aufzählung.<br />
Bemerkungen<br />
Standardmäßig zeigt die Tabellensteuerung Werte in Boolean-Spalten als Kontrollkästchen an. Der<br />
Spaltentyp wird von der DataType-Eigenschaft des Column-Objekts festgelegt. Wenn Sie Boolean-Werte<br />
nicht als Kontrollkästchen anzeigen lassen wollen, dann müssen Sie in die Format-Eigenschaft der Spalte<br />
eine Zeichenkette mit den entsprechenden Wahr- und Falsch-Werten eintragen. Zum Beispiel:<br />
• Visual Basic<br />
fg.Cols("bools").Format = "Yes;No"
186 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
• C#<br />
fg.Cols("bools").Format = "Yes;No";<br />
• Delphi<br />
fg.Cols['bools'].Format := 'Yes;No';<br />
Im ungebundenen Zustand können Sie die GetCellCheck- und SetCellCheck-Eigenschaften verwenden,<br />
um Kontrollkästchen in Zellen einzufügen. Das Kontrollkästchen wird zusammen mit jedem beliebigen<br />
Text in der Zelle angezeigt und Sie können deren Position mit der ImageAlign-Spalteneigenschaft<br />
festlegen.<br />
Es gibt zwei Kontrollkästchentypen: Boolean und Tri-State. Boolean-Kontrollkästchen schalten zwischen<br />
den beiden Zuständen CheckEnum.Checked und CheckEnum.Unchecked um. Drei-Zustands-<br />
Kontrollkästchen laufen durch die drei Zustände CheckEnum.TSChecked, CheckEnum.TSUnchecked<br />
und CheckEnum.TSGrayed.<br />
Zum Beispiel, der nachfolgende Quellcode erstellt ein Boolean-Kontrollkästchen in der Zelle (3,3) und ein<br />
Drei-Zustands-Kontrollkästchen in der Zelle (4,3):<br />
• Visual Basic<br />
• C#<br />
fg.SetCellCheck(3, 3, CheckEnum.Unchecked) ' boolean<br />
fg.SetCellCheck(4, 3, CheckEnum.TSUnchecked) ' tri-state<br />
fg.SetCellCheck(3, 3, CheckEnum.Unchecked) // boolean;<br />
fg.SetCellCheck(4, 3, CheckEnum.TSUnchecked) // tri-state;<br />
• Delphi<br />
fg.SetCellCheck(3, 3, CheckEnum.Unchecked);<br />
fg.SetCellCheck(4, 3, CheckEnum.TSUnchecked);<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
GetCellImage-Methode<br />
Gibt die einer Zelle zugeordnete Grafik zurück.<br />
Syntax<br />
[VB]<br />
Public Function GetCellImage(row As Integer, col As Integer) As Image<br />
[C#]<br />
public Image GetCellImage ( int row , int col )<br />
[Delphi]<br />
function GetCellImage(row: Integer; col: Integer): Image;<br />
Parameter Beschreibung<br />
row Zeile, welche die Grafik enthält.<br />
col Spalte, welche die Grafik enthält.
Bemerkungen<br />
GetCellRange-Methode · 187<br />
Diese Methode ruft Grafiken ab, die einer Zelle mit der SetCellImage-Methode zugeordnet wurden.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
GetCellRange-Methode<br />
Gibt ein CellRange-Objekt zurück, mit dem eine Auswahl formatiert und verändert werden kann.<br />
Syntax<br />
[VB]<br />
Public Function GetCellRange(row As Integer, col As Integer) As CellRange<br />
Public Function GetCellRange(row1 As Integer, col1 As Integer, row2 As Integer, col2 As Integer) As<br />
CellRange<br />
[C#]<br />
public CellRange GetCellRange ( int row1 , int col1 , int row2 , int col2 )<br />
public CellRange GetCellRange ( int row , int col )<br />
[Delphi]<br />
function GetCellRange(row: integer; col: Integer): CellRange;<br />
function GetCellRange(row1: Integer; col1: Integer; row2: Integer; col2: Integer): CellRange;<br />
Parameter Beschreibung<br />
row, col Die Koordinaten einer einzigen Zelle, die den Bereich darstellt.<br />
row1, col1, row2, col2 Vier Indizes, die einen Bereich festlegen.<br />
Rückgabewert<br />
Ein CellRange-Objekt, mit dem ein bestimmter Bereich formatiert und verändert werden kann.<br />
Bemerkungen<br />
Das CellRange-Objekt stellt den Zugang zu den Eigenschaften der Zellen in einem Bereich zur<br />
Verfügung. Zum Beispiel, der nachfolgende Quellcode legt das Format (Style) eines Bereichs fest:<br />
• Visual Basic<br />
• C#<br />
Dim rg As CellRange = flex.GetCellRange(5, 5, 20, 8)<br />
rg.Style = flex.Styles("MyStyle")<br />
CellRange rg = flex.GetCellRange(5, 5, 20, 8);<br />
rg.Style = flex.Styles["MyStyle"];<br />
• Delphi
188 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
var<br />
rg: CellRange;<br />
begin<br />
rg := flex.GetCellRange(5, 5, 20, 8);<br />
rg.Style := flex.Styles['MyStyle'];<br />
end;<br />
Anmerkung: CellRange ist eine Klasse, keine Struktur. Deswegen müssen Sie den Wert einer Variable<br />
zuordnen und dann diese Variable verwenden. Der folgende Quellcode, zum Beispiel, würde nicht<br />
kompilieren:<br />
• Visual Basic<br />
• C#<br />
' this does not compile!!!<br />
flex.GetCellRange(5, 5, 20, 8).Style = flex.Styles("MyStyle")<br />
// this does not compile!!!<br />
flex.GetCellRange(5, 5, 20, 8).Style = flex.Styles["MyStyle"];<br />
• Delphi<br />
flex.GetCellRange(5, 5, 20, 8).Style := flex.Styles['MyStyle'];<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
GetCellRect-Methode<br />
Gibt ein Rectangle-Objekt mit den Koordinaten der Zellen auf dem Bildschirm zurück.<br />
Syntax<br />
[VB]<br />
Public Function GetCellRect(row As Integer, col As Integer) As Rectangle<br />
Public Function GetCellRect(row As Integer, col As Integer, show As Boolean) As Rectangle<br />
[C#]<br />
public Rectangle GetCellRect ( int row , int col )<br />
public Rectangle GetCellRect ( int row , int col , Boolean show )<br />
[Delphi]<br />
function GetCellRect(row: Integer; col: Integer): Rectangle;<br />
function GetCellRect(row: Integer; col: Integer; show: Boolean): Rectangle;<br />
Parameter Beschreibung<br />
row, col Die Koordinaten der Zelle.<br />
show<br />
Ob die Zelle auf den Bildschirm gescrollt werden soll, bevor das Rechteck<br />
berechnet wird.
Rückgabewert<br />
GetCellStyle-Methode · 189<br />
Ein Rectangle-Objekt, welches die Koordinaten des Zellrechtecks in Pixeln und relativ zum aktuellen<br />
Tabellenbereich, enthält.<br />
Bemerkungen<br />
Diese Eigenschaft ist nützlich, wenn Sie benutzerdefinierte Editoren oder andere Elemente, die genau<br />
über einer Zelle positioniert werden, implementieren müssen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
GetCellStyle-Methode<br />
Gibt ein benutzerdefiniertes, einer bestimmten Zelle zugeordnetes Format zurück, oder „Null“, wenn<br />
diese kein eigenes Format besitzt.<br />
Syntax<br />
[VB]<br />
Public Function GetCellStyle(row As Integer, col As Integer) As CellStyle<br />
[C#]<br />
public CellStyle GetCellStyle ( int row , int col )<br />
[Delphi]<br />
function GetCellStyle(row: Integer; col: Integer): CellStyle;<br />
Parameter Beschreibung<br />
row, col Die Koordinaten der Zelle, die den Style enthalten soll.<br />
Rückgabewert<br />
Ein CellStyle-Objekt mit dem Format, das einer Zelle zugeordnet ist, oder „Null“, wenn diese kein<br />
benutzerdefiniertes Format besitzt.<br />
Bemerkungen<br />
Wenn die Zelle kein benutzerdefiniertes Format besitzt, dann verwendet die Tabellensteuerung eine der<br />
Standardformatvolagen. Die Standardformatvolagen werden je nach Zellposition und Zustand<br />
ausgewählt (fixiert, scrollbar, markiert, usw.). Verwenden Sie die GetCellStyleDisplay-Methode, um das<br />
Format, mit dem eine Zelle gezeichnet wird (benutzerdefiniert oder integriert) abzurufen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
GetCellStyleDisplay-Methode<br />
Gibt das Format zurück, das für das Rendern der Zelle verwendet wird.<br />
Syntax
190 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
[VB]<br />
Public Function GetCellStyleDisplay(row As Integer, col As Integer) As CellStyle<br />
[C#]<br />
public CellStyle GetCellStyleDisplay ( int row , int col )<br />
[Delphi]<br />
function GetcellStyleDisplay(row: Integer; col: Integer): CellStyle;<br />
Parameter Beschreibung<br />
row, col Die Koordinaten der Zelle, die den Style enthalten soll.<br />
Rückgabewert<br />
Ein CellStyle-Objekt mit einem Format, das für das Rendern der Zelle verwendet wird. Wenn die Zelle<br />
einen benutzerdefiniertes Format besitzt, dann gibt GetCellStyleDisplay dieses zurück; andernfalls wird<br />
das Standardformat (z.B. Normal, Fixed, usw.) ausgegeben.<br />
Bemerkungen<br />
Das zurückgegebene Format kann ein, einer Zelle zugeordnetes, benutzerdefiniertes oder, wenn die Zelle<br />
kein eigenes besitzt, ein Standardformat sein. Diese Methode gibt niemals Null zurück. Verwenden Sie<br />
die GetCellStyle-Methode um festzustellen, ob die Zelle einen benutzerdefiniertes Format besitzt, und<br />
um dieses abzurufen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
GetData-Methode<br />
Gibt die Daten einer Tabellenzelle zurück.<br />
Syntax<br />
[VB]<br />
Public Function GetData(row As Integer, col As Integer) As Object<br />
Public Function GetData(row As Integer, colName As String) As Object<br />
[C#]<br />
public Object GetData ( int row , int col )<br />
public Object GetData ( int row , String colName )<br />
[Delphi]<br />
function GetData(row: Integer; col: Integer): Object;<br />
function GetData(row: Integer; colName: string): Object;
Parameter Beschreibung<br />
row, col Die Koordinaten der Zelle.<br />
Rückgabewert<br />
Die Daten einer gegebenen Zelle.<br />
Bemerkungen<br />
GetDataDisplay-Methode · 191<br />
Die GetData-Methode gibt die rohen, in einer bestimmten Zelle gespeicherten Daten zurück. Dies<br />
entspricht der Verwendung der Tabellenindizierer. Zum Beispiel:<br />
• Visual Basic<br />
• C#<br />
Dim foo As Object<br />
foo = fg.GetData(row, col) ' is equivalent to<br />
foo = fg(row, col)<br />
object foo;<br />
foo = fg.GetData(row, col); // is equivalent to<br />
foo = fg[row, col];<br />
• Delphi<br />
var<br />
foo: System.Object;<br />
begin<br />
foo := fg.GetData(row, col);<br />
foo := fg[row, col];<br />
end;<br />
Die von der Tabelle angezeigten Daten können von den rohen Daten, abhängig von den Format- und<br />
DataMap-Eigenschaften des Column-Objekts, abweichen. Verwenden Sie stattdessen die<br />
GetDataDisplay-Methode, um den angezeigten Wert als Zeichenkette abzurufen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
GetDataDisplay-Methode<br />
Gibt die Daten einer Tabellenzelle als Zeichenkette zurück.<br />
Syntax<br />
[VB]<br />
Public Function GetDataDisplay(row As Integer, col As Integer) As String<br />
Public Function GetDataDisplay(row As Integer, colName As String) As String<br />
[C#]<br />
public String GetDataDisplay ( int row , int col )<br />
public String GetDataDisplay ( int row , String colName )<br />
[Delphi]
192 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
function GetDataDisplay(row: Integer, col: Integer): string;<br />
function GetDataDisplay(row: Integer, colName: string): string;<br />
Parameter Beschreibung<br />
row, col Die Koordinaten der Zelle.<br />
Rückgabewert<br />
Eine Zeichenkette der Daten, die in einer gegebenen Zelle angezeigt werden.<br />
Bemerkungen<br />
Verwenden Sie die GetData-Methode oder die Tabellenindizierer, um die rohen Daten vor jeglichen<br />
Zuordnungen und Formatierungen abzurufen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
GetMergedRange-Methode (<strong>C1FlexGrid</strong>)<br />
Gibt die Auswahl der mit einer gegeben Zelle verbundenen Zellen zurück.<br />
Syntax<br />
[VB]<br />
Public Function GetMergedRange(row As Integer, col As Integer) As CellRange<br />
Public Function GetMergedRange(row As Integer, col As Integer, clip As Boolean) As CellRange<br />
[C#]<br />
public CellRange GetMergedRange(int row , int col)<br />
public CellRange GetMergedRange(int row , int col , Boolean clip)<br />
[Delphi]<br />
function GetMergedRange(row: Integer; col: Integer): CellRange;<br />
function GetMergedRange(row: Integer; col: Integer; clip: Boolean); CellRange;<br />
Parameter Beschreibung<br />
row, col Die Koordinaten der Zelle.<br />
Clip<br />
Rückgabewert<br />
Ob der zurückgegebene Wert alle verbundenen Zellen im Bereich (clip = FALSE)<br />
oder nur die sichtbaren (clip = TRUE) enthalten soll.<br />
Ein CellRange-Objekt mit allen Zellen des verbundenen Bereichs um die Zelle auf Position row, col.<br />
Bemerkungen
HitTest-Methode · 193<br />
Zellverbindungen werden von der AllowMerging-Eigenschaft gesteuert. Mit der GetMergedRange<br />
können Sie nur feststellen, ob eine bestimmte Zelle mit ihren Nachbarzellen verbunden ist.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
HitTest-Methode<br />
Gibt Informationen über die Steuerung an einem gegebenen Punkt auf der Steuerungsoberfläche zurück.<br />
Syntax<br />
[VB]<br />
Public Function HitTest(x As Integer, y As Integer) As HitTestInfo<br />
[C#]<br />
public HitTestInfo HitTest(int x , int y)<br />
[Delphi]<br />
function HitTest(x: Integer; y: Integer): HitTestInfo;<br />
Parameter Beschreibung<br />
x, y Die Koordinaten eines Punktes auf der Steuerungsoberfläche in Pixeln.<br />
row1, col1, row2, col2 Die Koordinaten des Bereichs, der geprüft werden soll.<br />
range CellRange-Objekt, das den Bereich festlegt, der geprüft werden soll.<br />
Rückgabewert<br />
Eine HitTestInfo-Struct mit den Daten über den Punkt (Koordinaten, Zeile, Spalte, usw.).<br />
Bemerkungen<br />
Diese Methode ist besonders nützlich, wenn dass BeforeMouseDown-Ereignis abgefangen wird und<br />
bestimmt werden soll, ob der Mauszeiger z.B. über einer bestimmten Zelle, Schaltfläche oder einem<br />
Größenänderungselement steht.<br />
Zum Beispiel, der nachfolgende Quellcode zeigt die HitTest-Information immer dann an, wenn der<br />
Nutzer mit der Maus klickt:<br />
• Visual Basic<br />
• C#<br />
Private Sub _flex_BeforeMouseDown(sender As Object, e As<br />
BeforeMouseDownEventArgs)<br />
Dim hti As HitTestInfo = _flex.HitTest(e.X, e.Y)<br />
Console.WriteLine("at {0},{1}: row {2} col {3} type {4}", _<br />
hti.X, hti.Y, hti.Row, hti.Column, hti.Type)<br />
End Sub '_flex_BeforeMouseDown<br />
private void _flex_BeforeMouseDown(object sender,<br />
BeforeMouseDownEventArgs e)<br />
{<br />
HitTestInfo hti = _flex.HitTest(e.X, e.Y);
194 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
}<br />
• Delphi<br />
Console.WriteLine("at {0},{1}: row {2} col {3} type {4}",<br />
hti.X, hti.Y, hti.Row, hti.Column, hti.Type);<br />
var<br />
hti: HitTestInfo;<br />
items: array of object;<br />
begin<br />
hti := _flex.HitTest(e.X, e.Y);<br />
SetLength(items, 5);<br />
items[0] := System.Object(hti.X);<br />
items[1] := System.Object(hti.Y);<br />
items[2] := System.Object(hti.Row);<br />
items[3] := System.Object(hti.Column);<br />
items[4] := System.Object(hti.Type);<br />
Console.WriteLine('at {0},{1}: row {2} col {3} type {4}',<br />
items);<br />
end;<br />
Bei Verwendung dieser Methode in einem Ereignis, dass die Mauszeigerkoordinaten nicht bereitstellt,<br />
müssen Sie die Control.MousePosition-Eigenschaft nutzen und den Punkt von den Fenster- zu<br />
Steuerungskordinaten umwandeln. Zum Beispiel:<br />
• Visual Basic<br />
• C#<br />
Private Sub _flex_DoubleClick(sender As Object, e As System.EventArgs)<br />
Dim pt As Point = Control.MousePosition<br />
pt = _flex.PointToClient(pt)<br />
Dim hti As HitTestInfo = _flex.HitTest(pt.X, pt.Y)<br />
Console.WriteLine("at {0},{1}: row {2} col {3} type {4}", _<br />
hti.X, hti.Y, hti.Row, hti.Column, hti.Type)<br />
End Sub '_flex_DoubleClick<br />
private void _flex_DoubleClick(object sender, System.EventArgs e)<br />
{<br />
Point pt = Control.MousePosition;<br />
pt = _flex.PointToClient(pt);<br />
HitTestInfo hti = _flex.HitTest(pt.X, pt.Y);<br />
Console.WriteLine("at {0},{1}: row {2} col {3} type {4}",<br />
hti.X, hti.Y, hti.Row, hti.Column, hti.Type);<br />
}<br />
• Delphi<br />
var<br />
hti: HitTestInfo;<br />
pt: Point;<br />
items: array of object;<br />
begin<br />
pt := Control.MousePosition;<br />
pt := _flex.PointToClient(pt);<br />
hti := _flex.HitTest(pt.X, pt.Y);<br />
SetLength(items, 5);<br />
items[0] := System.Object(hti.X);<br />
items[1] := System.Object(hti.Y);<br />
items[2] := System.Object(hti.Row);<br />
items[3] := System.Object(hti.Column);<br />
items[4] := System.Object(hti.Type);<br />
Console.WriteLine('at {0},{1}: row {2} col {3} type {4}',<br />
items);<br />
end;
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
Invalidate-Methode<br />
Invalidate-Methode · 195<br />
Erklärt einen bestimmten Teil der Tabelle als ungültig und gibt eine Farbnachricht an die Steuerung aus.<br />
Syntax<br />
[VB]<br />
Public Sub Invalidate(row As Integer, col As Integer)<br />
Public Sub Invalidate(rg As CellRange)<br />
Public Sub Invalidate(row1 As Integer, col1 As Integer, row2 As Integer, col2 As Integer)<br />
[C#]<br />
public void Invalidate(int row , int col)<br />
public void Invalidate(int row1 , int col1 , int row2 , int col2)<br />
public virtual void Invalidate(CellRange rg)<br />
[Delphi]<br />
procedure Invalidate(row: integer; col: Integer);<br />
procedure Invalidate(rg: CellRange);<br />
procedure Invalidate(row1: Integer; col1: Integer; row2: Integer; col2: Integer);<br />
Parameter Beschreibung<br />
row, col Die Koordinaten der für ungültig zu erklärenden Zelle.<br />
row1, col1, row2, col2 Die Koordinaten des für ungültig zu erklärenden Bereichs.<br />
range Ein CellRange-Objekt mit dem für ungültig zu erklärenden Bereich.<br />
Bemerkungen<br />
Diese Methode wird kaum von Programmierern verwendet, da die Tabelle betreffende Zellen<br />
automatisch für ungültig erklärt.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109 )<br />
Column-Klasse (Seite 339)<br />
Row-Klasse (Seite 324)<br />
LoadExcel-Methode<br />
Lädt ein Arbeitsblatt aus einer Microsoft Excel-Datei (*.xls).<br />
Syntax
196 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
[VB]<br />
Public Sub LoadExcel(fileName As String)<br />
Public Sub LoadExcel(fileName As String, sheetName As String)<br />
Public Sub LoadExcel(fileName As String, sheetName As String, flags As FileFlags)<br />
[C#]<br />
public void LoadExcel(string fileName)<br />
public void LoadExcel(string fileName, string sheetName)<br />
public void LoadExcel(string fileName, string sheetName, FileFlags flags)<br />
[Delphi]<br />
procedure LoadExcel(fileName: string);<br />
procedure LoadExcel(fileName: string; sheetName: string);<br />
procedure LoadExcel(fileName: string; sheetName: string; flags: FileFlags);<br />
Parameter Beschreibung<br />
fileName Der Name der zu ladenden Datei und ihr Pfad.<br />
sheetName<br />
flags<br />
Bemerkungen<br />
Der Name der zu ladenden Tabelle in der Excel-Datei. Wenn dieser nicht<br />
angegeben ist, wird die erste Tabelle geladen. Verwenden Sie die<br />
LoadExcelSheetNames-Methode, um eine Liste aller Tabellen der Datei<br />
abzufragen.<br />
Einer der Werte aus der FileFlags-Aufzählung, die Ladeoptionen für die Datei<br />
festlegen (z.B. ob feste Zellen geladen werden).<br />
Auch die LoadGrid-Methode kann Excel-Dateien laden. Sie können da allerdings nicht das zu ladende<br />
Arbeitsblatt angeben, so dass immer das erste in der Arbeitsmappe geladen wird.<br />
Verwenden Sie die LoadExcelSheetNames-Methode, um eine Liste aller Tabellen der Datei abzufragen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
LoadExcelSheetNames-Methode<br />
Gibt eine Liste aller Arbeitsblätter einer Microsoft Excel-Datei zurück (*.xls).<br />
Syntax<br />
[VB]<br />
Public Function LoadExcelSheetNames(fileName As String) As String()<br />
[C#]<br />
public string() LoadExcelSheetNames(string fileName)
[Delphi]<br />
function LoadExcelSheetNames(fileName: string): string[];<br />
Parameter Beschreibung<br />
fileName Der Name der zu ladenden Datei und ihr Pfad.<br />
Bemerkungen<br />
LoadGrid-Methode · 197<br />
Diese Methode ist nützlich, wenn Sie eine bestimmt Tabelle aus einer Excel-Arbeitsmappe laden wollen.<br />
Verwenden Sie hierfür zunächst die LoadExcelSheetNames, um eine Liste der vorhandenen Tabellen<br />
abzurufen, wählen Sie die zu ladende Tabelle aus und rufen Sie diese anschließend mit der LoadExcel-<br />
Methode ab.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
LoadGrid-Methode<br />
Lädt eine Tabelle aus einer Datei.<br />
Syntax<br />
[VB]<br />
Public Sub LoadGrid(fileName As String, format As FileFormatEnum)<br />
Public Sub LoadGrid(fileName As String, format As FileFormatEnum, flags As FileFlags)<br />
Public Sub LoadGrid(fileName As String, format As FileFormatEnum, flags As FileFlags, encoding As<br />
Encoding)<br />
[C#]<br />
public void LoadGrid(string fileName , FileFormatEnum format)<br />
public void LoadGrid(string fileName , FileFormatEnum format , FileFlags flags)<br />
public void LoadGrid(string fileName , FileFormatEnum format , FileFlags flags, Encoding encoding)<br />
[Delphi]<br />
procedure LoadGrid(fileName: string; format: FileFormatEnum);<br />
procedure LoadGrid(fileName: string; format: FileFormatEnum; flags: FileFlags);<br />
procedure LoadGrid(fileName: string; format: FileFormatEnum; flags: FileFlags; encoding: Encoding);<br />
Parameter Beschreibung<br />
fileName Der Name der zu ladenden Datei und ihr Pfad.<br />
format<br />
Einer der Werte aus der FileFormatEnum-Aufzählung, die das Format der<br />
Datei festlegen (z.B. komma- oder tabulatorengetrennte Textdateien, Excel).
198 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
flags<br />
encoding<br />
Bemerkungen<br />
Einer der Werte aus der FileFlags-Aufzählung, die Ladeoptionen für die Datei<br />
festlegen (z.B. ob feste Zellen geladen werden).<br />
Ein System.Text.Encoding-Objekt, welches festlegt, wie der Text in die Datei<br />
codiert wird. (z.B. ASCII, Unicode, UTF-7, UTF-8). Dieser Parameter ist nicht<br />
nötig, wenn Excel-Dateien geladen werden.<br />
Diese Methode lädt eine Tabelle aus einer zuvor mit der SaveGrid-Methode gespeicherten,<br />
kommagetrennten Textdatei (*.csv), wie z.B. eine Microsoft Excel-Datei, oder eine tabulatorgetrennte<br />
Textdatei. Sie kann auch für das Laden von Microsoft Excel-Dateien (*.xls) verwendet werden.<br />
Wenn eine Textdatei geladen wird, dann werden Zeilen und Spalten so hinzugefügt, dass der Inhalt der<br />
Textdatei darin Platz findet.<br />
Wenn Excel-Dateien geladen werden, dann ruft die Tabellensteuerung das erste Arbeitsblatt mit der<br />
ersten Tabelle der *.xls-Datei ab. Mit der LoadExcel-Methode hingegen können Sie das gewünschte<br />
Arbeitsblatt festlegen. Verwenden Sie zusätzlich die LoadExcelSheetNames-Methode, um eine Liste aller<br />
Tabellen der *.xls-Datei abzufragen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
PrintGrid-Methode<br />
Druckt die Tabelle und zeigt optional ein Druckvorschaufenster an.<br />
Syntax<br />
[VB]<br />
Public Function PrintGrid(docName As String) As Boolean<br />
Public Function PrintGrid(docName As String, flags As PrintGridFlags) As Boolean<br />
Public Function PrintGrid(docName As String, flags As PrintGridFlags, header As String, footer As<br />
String) As Boolean<br />
[C#]<br />
public Boolean PrintGrid(string docName)<br />
public Boolean PrintGrid(string docName , PrintGridFlags flags)<br />
public Boolean PrintGrid(string docName , PrintGridFlags flags , string header , string footer)<br />
[Delphi]<br />
function PrintGrid(docName: string): Boolean;<br />
function PrintGrid(docName: string; flags: PrintGridFlags): Boolean;<br />
function PrintGrid(docName: string; flags: PrintGridFlags; header: string; footer: string): Boolean;
Parameter Beschreibung<br />
docName<br />
flags<br />
RemoveItem-Methode (<strong>C1FlexGrid</strong>) · 199<br />
Der Dokumentname, der in den Fortschritts- und den Druckauftragsfenstern<br />
angezeigt wird.<br />
Eine Kombination von Werten der PrintGridFlags-Aufzählung, die den Typ der<br />
anzuzeigenden Druck- und Vorschaufenster festlegen und bestimmen, wie die<br />
Tabelle für den Ausdruck skaliert wird.<br />
header, footer Zeichenketten, die oben und unten auf jede Seite gedruckt werden.<br />
Rückgabewert<br />
Ein Boolean-Wert der anzeigt, ob entweder die Tabelle gedruckt wurde, oder der Nutzer eines der<br />
optionalen Einstellungsfenster abgbrochen hat.<br />
Bemerkungen<br />
Die Kopf- und Fußzeilentexte können bis zu drei tabulatorgetrennte Abschnitte besitzen, die<br />
entsprechend linksbündig, mittig und rechtsbündig auf der Seite ausgerichtet werden. Die Texte können<br />
weiterhin Platzhalter besitzen, die mit der aktuellen Seitenzahl oder der Gesamtseitenzahl (“{0}” und<br />
“{1}”) ersetzt werden.<br />
Mit der PrintParameters-Eigenschaft können Sie noch weitere Aspekte des Druckauftrags, wie z.B.<br />
Seitenausrichtung, Ränder, Kopf- und Fußzeilenschriftarten, steuern.<br />
Beispiel<br />
Der folgende Aufruf skaliert die Tabelle auf eine Seitenbreite, platziert eine zentrierte Fußzeile mit dem<br />
Text „Page n of m” am unteren Ende der Seite und druckt sie auf dem Standarddrucker aus.<br />
• Visual Basic<br />
• C#<br />
flex.PrintGrid("My Grid", PrintGridFlags.FitPageWidth, _<br />
"", vbTab + "Page {0} of {1}")<br />
flex.PrintGrid("My Grid", PrintGridFlags.FitPageWidth,<br />
"", "\tPage {0} of {1}");<br />
• Delphi<br />
flex.PrintGrid('My Grid', PrintGridFlags.FitPageWidth, '', #9'Page<br />
{0} of {1}');<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109 )<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
RemoveItem-Methode (<strong>C1FlexGrid</strong>)<br />
Löscht eine Zeile in der Steuerung.<br />
Syntax<br />
[VB]<br />
Public Sub RemoveItem()
200 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Public Sub RemoveItem(index As Integer)<br />
[C#]<br />
public void RemoveItem ( )<br />
public void RemoveItem ( int index )<br />
[Delphi]<br />
procedure RemoveItem;<br />
procedure RemoveItem(index: Integer);<br />
Parameter Beschreibung<br />
index<br />
Bemerkungen<br />
Der Index der zu löschenden Zeile. Wenn dieser Parameter unberücksichtigt bleibt,<br />
dann wird die letzte Zeile der Tabelle gelöscht.<br />
Sie können Zeilen auch mit der Rows-Collection löschen und hinzufügen. Die RemoveItem-Methode<br />
wird hauptsächlich aus Konsistenzgründen zur Verfügung gestellt.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
SaveExcel-Methode<br />
Speichert die Tabelle in einer Microsoft Excel-Datei (*.xls).<br />
Syntax<br />
[VB]<br />
Public Sub SaveExcel(fileName As String)<br />
Public Sub SaveExcel(fileName As String, sheetName As String)<br />
Public Sub SaveExcel(fileName As String, sheetName As String, flags As FileFlags)<br />
[C#]<br />
public void SaveExcel(string fileName)<br />
public void SaveExcel(string fileName, string sheetName)<br />
public void SaveExcel(string fileName, string sheetName, FileFlags flags)<br />
[Delphi]<br />
procedure SaveExcel(fileName: string);<br />
procedure SaveExcel(fileName: string; sheetName: string);<br />
procedure SaveExcel(fileName: string; sheetName: string; flags: FileFlags);
Parameter Beschreibung<br />
fileName Der Name der zu speichernden Datei und ihr Pfad.<br />
sheetName<br />
flags<br />
Bemerkungen<br />
SaveGrid-Methode · 201<br />
Der Name der zu speichernden Tabelle in der Excel-Datei. Wenn dieser nicht<br />
angegeben ist, dann wird eine Datei mit nur einem Arbeitsblatt erstellt,<br />
andernfalls wird ein Arbeitsblatt mit dem angegebenen Namen der Datei<br />
hinzugefügt.<br />
Einer der Werte aus der FileFlags-Aufzählung, die Speicheroptionen für die<br />
Datei festlegen (z.B. ob feste Zellen gespeichert werden).<br />
Auch die SaveGrid-Methode kann Excel-Dateien speichern. Sie können da allerdings nicht das zu<br />
speichernde Arbeitsblatt angeben, so dass immer Arbeitsmappen mit nur einem Arbeitsblatt erstellt<br />
werden.<br />
Mit der SaveExcel-Methode können Sie hingegen mehrere Tabellen auf verschiedenen Arbeitsbättern in<br />
einer Datei speichern. Zum Beispiel, der nachfolgende Quellcode speichert alle Tabellen in einem<br />
Datensatz in einer einzigen *.xls-Datei:<br />
• Visual Basic<br />
• C#<br />
Dim ds As DataSet = GetDataSet()<br />
Dim dt As DataTable<br />
For Each dt In ds.Tables<br />
_flex.DataSource = dt<br />
_flex.SaveExcel(xlsFileName, dt.TableName)<br />
Next<br />
DataSet ds = GetDataSet();<br />
foreach (DataTable dt in ds.Tables)<br />
{<br />
_flex.DataSource = dt;<br />
_flex.SaveExcel(xlsFileName, dt.TableName);<br />
}<br />
• Delphi<br />
var ds: DataSet;<br />
dt: DataTable;<br />
i: Integer;<br />
ds := GetDataSet;<br />
for i := 0 to ds.Tables.Count-1 do<br />
begin<br />
dt := ds.Tables[i];<br />
_flex.DataSource := dt;<br />
_flex.SaveExcel(xlsFileName, dt.TableName);<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
SaveGrid-Methode<br />
Speichert die Tabelle in eine Datei.
202 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Syntax<br />
[VB]<br />
Public Sub SaveGrid(fileName As String, format As FileFormatEnum)<br />
Public Sub SaveGrid(fileName As String, format As FileFormatEnum, flags As FileFlags)<br />
Public Sub SaveGrid(fileName As String, format As FileFormatEnum, flags As FileFlags, encoding As<br />
Encoding)<br />
[C#]<br />
public void SaveGrid (String fileName , FileFormatEnum format )<br />
public void SaveGrid (String fileName , FileFormatEnum format , FileFlags flags)<br />
public void SaveGrid (String fileName , FileFormatEnum format ,FileFlags flags, Encoding encoding)<br />
[Delphi]<br />
procedure SaveGrid(fileName: string; format: FileFormatEnum);<br />
procedure SaveGrid(fileName: string; format: FileFormatEnum; flags: FileFlags);<br />
procedure SaveGrid(fileName: string; format: FileFormatEnum; flags: FileFlags; encoding: Encoding);<br />
Parameter Beschreibung<br />
fileName Der Name der zu speichernden Datei und ihr Pfad.<br />
format<br />
flags<br />
encoding<br />
Bemerkungen<br />
Einer der Werte aus der FileFormatEnum-Aufzählung, die das Format der<br />
Datei festlegen (z.B. komma- oder tabulatorengetrennte Textdateien, Excel).<br />
Einer der Werte aus der FileFlags-Aufzählung, die Speicheroptionen für die<br />
Datei festlegen (z.B. ob feste Zellen gespeichert werden).<br />
Ein System.Text.Encoding-Objekt, welches festlegt, wie der Text in die Datei<br />
codiert wird. (z.B. ASCII, Unicode, UTF-7, UTF-8). Der Standardwert ist<br />
Encoding.ASCII. Dieser Parameter ist nicht nötig, wenn Excel-Dateien<br />
gespeichert werden.<br />
Wenn die Tabellensteuerung eine Textdatei speichert, dann werden alle Zellen, die Anführungszeichen<br />
oder Zeilen- und Spaltentrennzeichen enthalten, in Anführungszeichen eingeschlossen.<br />
Anführungszeichen im Zelltext werden durch doppelte Anführungszeichen ersetzt. Dies stellt die<br />
Standardcodierung dar, wenn *.csv-Dateien geladen oder gespeichert werden. Wenn Excel-Dateien<br />
gespeichert werden, dann erstellt die Tabellensteuerung eine neue *.xls-Datei mit einem Arbeitsblatt, auf<br />
dem die Tabellendaten gespeichert werden.<br />
Mit der SaveExcel-Methode können Sie hingegen mehrere Tabellen auf verschiedenen Arbeitsbättern in<br />
einer *.xls-Datei speichern.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)
Select-Methode<br />
Wählt eine oder mehrere Zellen aus.<br />
Syntax<br />
[VB]<br />
Public Select(row As Integer, col As Integer)<br />
Public Select(row As Integer, col As Integer, rowSel As Integer, colSel As Integer)<br />
Public Select(rg As CellRange)<br />
Public Select(row As Integer, col As Integer, show As Boolean)<br />
Select-Methode · 203<br />
Public Select(row As Integer, col As Integer, rowSel As Integer, colSel As Integer, show As Boolean)<br />
Public Select(rg As CellRange, show As Boolean)<br />
[C#]<br />
public void Select ( int row , int col )<br />
public void Select ( int row , int col , int rowSel , int colSel )<br />
public void Select ( int row , int col , Boolean show )<br />
public void Select (CellRange rg )<br />
public void Select ( int row , int col , int rowSel , int colSel , Boolean show )<br />
public void Select (CellRange rg , Boolean show )<br />
[Delphi]<br />
procedure Select(row: Integer; col: Integer);<br />
procedure Select(row: Integer; col: Integer; rowSel: Integer; colSel: Integer);<br />
procedure Select(row: Integer; col: Integer; show: Boolean);<br />
procedure Select(rg: CellRange);<br />
procedure Select(row: Integer; col: Integer; rowSel: Integer; colSel: Integer; show: Boolean);<br />
procedure Select(rg: CellRange; show: Boolean);<br />
Parameter Beschreibung<br />
row, col Die Koordinaten der auszuwählenden Zelle.<br />
row1, col1, row2, col2 Die Koordinaten des auszuwählenden Bereichs.<br />
range Der für ungültig zu erklärende Bereich.<br />
show<br />
Ob die Auswahl auf den Bildschirm gescrollt werden soll. Der Standardwert für<br />
diesen Parameter ist TRUE.
204 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Bemerkungen<br />
Die Verwendung der Select-Methode ist gleich dem Setzen der Row, Col, RowSel und ColSel-<br />
Eigenschaften.<br />
Wenn Sie die SelectionMode-Eigenschaft auf ListBox setzen, dann verhält sich die Tabelle wie ein<br />
Mehrfachauswahllistenfeld. In diesem Modus können Sie die Selected-Eigenschaft des Row-Objekts<br />
verwenden, um den Auswahlzustand einer Zeile abzurufen oder zu setzen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
SetCellImage-Methode<br />
Ordnet eine Grafik einer Zelle zu.<br />
Syntax<br />
[VB]<br />
Public Sub SetCellImage(row As Integer, col As Integer, newImage As Image)<br />
[C#]<br />
public void SetCellImage ( int row , int col , Image newImage )<br />
[Delphi]<br />
procedure SetCellImage(row: Integer; col: Integer; newImage: Image);<br />
Bemerkungen<br />
Parameter Beschreibung<br />
row Zeile, welche die Grafik beinhalten wird.<br />
col Spalte, welche die Grafik beinhalten wird.<br />
newImage Die der Zelle hinzuzufügende Grafik.<br />
Bemerkungen<br />
Jede Zelle der Tabelle kann neben ihren Daten auch ein Bild anzeigen. Dies kann auf zwei Wegen getan<br />
werden:<br />
1. Sie können die SetCellImage- und GetCellImage-Methoden verwenden, um Grafiken direkt der<br />
Zelle zuzuordnen. In diesem Fall sind der Zellinhalt und die Grafik unabhängig. Um die Grafik<br />
zu aktualisieren, müssen Sie die SetCellImage erneut aufrufen.<br />
2. Sie können die ImageMap-Eigenschaft eines Column-Objekts verwenden, um Grafiken auf<br />
bestimmte Zellwerte zuzuordnen. In diesem Fall wird die Grafik automatisch aktualisiert, wenn<br />
sich der Zellinhalt ändert. Das column-Objekt besitzt außerdem eine ImageAndText-Eigenschaft,<br />
mit der Sie festlegen können, ob die Steuerung die Grafik zusätzlich oder anstatt des Zelltextes<br />
anzeigen soll.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)
SetCellStyle-Methode<br />
Ordnet einen eigenen CellStyle der Zelle zu.<br />
Syntax<br />
[VB]<br />
Public Sub SetCellStyle(row As Integer, col As Integer, newStyle As CellStyle)<br />
[C#]<br />
public void SetCellStyle ( int row , int col , CellStyle newStyle )<br />
[Delphi]<br />
procedure SetCellStyle(row: Integer; col: Integer; newStyle: CellStyle);<br />
Parameter Beschreibung<br />
row, col Die Koordinaten der Zelle, die das neue Format zugeordnet bekommt.<br />
SetCellStyle-Methode · 205<br />
newStyle Das neue Format für die Zelle, oder Null, um das Zellfomat zurückzusetzen.<br />
Bemerkungen<br />
Die SetCellStyle-Methode ist nützlich, wenn Sie einen neues Format einer Zelle zuordnen wollen. Sie<br />
können das Zellformat auch zurücksetzen, indem Sie es auf Null setzen („Nothing“ in VB).<br />
Um eine benutzerdefinierte Formatvorlage auf eine gesamte Zeile oder Spalte anzuwenden, müssen Sie<br />
die Style-Eigenschaft der Row- oder Column-Objekte setzen.<br />
Verwenden Sie das CellRange-Objekt, um eine benutzerdefinierte Formatvorlage auf einen Zellbereich<br />
anzuwenden. Zum Beispiel:<br />
• Visual Basic<br />
• C#<br />
Dim rg As CellRange = fg.GetCellRange(3, 3, 10, 10)<br />
rg.Data = Nothing<br />
rg.Style = fg.Styles("MyRangeStyle")<br />
CellRange rg = fg.GetCellRange(3, 3, 10, 10);<br />
rg.Data = null;<br />
rg.Style = fg.Styles["MyRangeStyle"];<br />
• Delphi<br />
var<br />
rg: CellRange;<br />
begin<br />
rg := fg.GetCellRange(3, 3, 10, 10);<br />
rg.Data := nil;<br />
rg.Style := fg.Styles['MyRangeStyle'];<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)
206 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
SetCellCheck-Methode<br />
Legt den Zustand eines Kontrollkästchens, dass in einer Zelle angezeigt wird, fest.<br />
Syntax<br />
[VB]<br />
Public Sub SetCellCheck(row As Integer, col As Integer, check As CheckEnum)<br />
[C#]<br />
public void SetCellCheck ( int row , int col , CheckEnum check )<br />
[Delphi]<br />
procedure SetCellCheck(row: Integer; col: Integer; check: CheckEnum);<br />
Parameter Beschreibung<br />
row, col Die Koordinaten der Zelle, deren Kontrollkästchenzustand verändert werden soll.<br />
checkValue<br />
Bemerkungen<br />
Einer der Werte aus der CheckEnum-Aufzählung, die festlegen, ob ein<br />
Kontrollkästchen in der Zelle angezeigt wird und welchen Zustand es haben soll.<br />
Standardmäßig zeigt die Tabellensteuerung Werte in Boolean-Spalten als Kontrollkästchen an. Der<br />
Spaltentyp wird von der DataType-Eigenschaft des Column-Objekts festgelegt. Wenn Sie Boolean-Werte<br />
nicht als Kontrollkästchen anzeigen lassen wollen, dann müssen Sie in die Format-Eigenschaft der Spalte<br />
eine Zeichenkette mit den entsprechenden Wahr- und Falsch-Werten eintragen. Zum Beispiel:<br />
• Visual Basic<br />
• C#<br />
fg.Cols("bools").Format = "Yes;No"<br />
fg.Cols["bools"].Format = "Yes;No";<br />
• Delphi<br />
fg.Cols['bools'].Format := 'Yes;No';<br />
Im ungebundenen Zustand können Sie die GetCellCheck- und SetCellCheck-Eigenschaften verwenden,<br />
um Kontrollkästchen in Zellen einzufügen. Das Kontrollkästchen wird zusammen mit jedem beliebigen<br />
Text in der Zelle angezeigt und Sie können deren Position mit der ImageAlign-Spalteneigenschaft<br />
festlegen.<br />
Es gibt zwei Kontrollkästchentypen: Boolean und Tri-State. Boolean-Kontrollkästchen schalten zwischen<br />
den beiden Zuständen CheckEnum.Checked und CheckEnum.Unchecked um. Drei-Zustands-<br />
Kontrollkästchen laufen durch die drei Zustände CheckEnum.TSChecked, CheckEnum.TSUnchecked<br />
und CheckEnum.TSGrayed.<br />
Zum Beispiel, der nachfolgende Quellcode erstellt ein Boolean-Kontrollkästchen in der Zelle (3,3) und ein<br />
Drei-Zustands-Kontrollkästchen in der Zelle (4,3):<br />
• Visual Basic<br />
fg.SetCellCheck(3, 3, CheckEnum.Unchecked) ' boolean
• C#<br />
fg.SetCellCheck(4, 3, CheckEnum.TSUnchecked) ' tri-state<br />
fg.SetCellCheck(3, 3, CheckEnum.Unchecked); // boolean<br />
fg.SetCellCheck(4, 3, CheckEnum.TSUnchecked); // tri-state<br />
• Delphi<br />
fg.SetCellCheck(3, 3, CheckEnum.Unchecked); // boolean<br />
fg.SetCellCheck(4, 3, CheckEnum.TSUnchecked); // tri-state<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
SetData-Methode<br />
Ordnet Daten einer Tabellenzelle zu.<br />
Syntax<br />
[VB]<br />
Public Function SetData(row As Integer, colName As String, data As Object) As Boolean<br />
SetData-Methode · 207<br />
Public Function SetData(row As Integer, colName As String, data As Object, coerce As Boolean) As<br />
Boolean<br />
Public Function SetData(rg As CellRange, data As Object) As Boolean<br />
Public Function SetData(rg As CellRange, data As Object, coerce As Boolean) As Boolean<br />
Public Function SetData(row As Integer, col As Integer, data As Object) As Boolean<br />
Public Function SetData(row As Integer, col As Integer, data As Object, coerce As Boolean) As Boolean<br />
[C#]<br />
public Boolean SetData ( int row , String colName , Object data )<br />
public Boolean SetData ( int row , String colName , Object data , Boolean coerce )<br />
public Boolean SetData (CellRange rg , Object data )<br />
public Boolean SetData ( int row , int col , Object data )<br />
public Boolean SetData (CellRange rg , Object data , Boolean coerce )<br />
public Boolean SetData (int row , int col , Object data , Boolean coerce )<br />
[Delphi]<br />
function SetData(row: Integer; colName: string; data: Object): Boolean;<br />
function SetData(row: Integer; colName: string; data: Object; coerce: Boolean): Boolean;<br />
function SetData(rg: CellRange; data: Object): Boolean;<br />
function SetData(row: Integer; col: Integer; data: Object): Boolean;<br />
function SetData(rg: CellRange; data: Object; coerce, Boolean): Boolean;<br />
function SetData(row: Integer; col: Integer; data: Object; coerce: Boolean): Boolean;
208 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Parameter Beschreibung<br />
row, col Die Koordinaten der Zelle, der die neuen Daten zugeordnet werden.<br />
data Die der Zelle zuzuordnenden Daten.<br />
coerce<br />
Rückgabewert<br />
Legt fest, ob das Objekt in den Datentyp der Spalte umgewandelt wird. Wenn<br />
coerce auf TRUE steht, der Wert aber nicht in den richtigen Datentyp umgewandelt<br />
werden kann, dann wird die Tabellensteuerung das GridError-Ereignis starten und<br />
die Zelle ihren ursprünglichen Wert beibehalten. Der Standardwert für diesen<br />
Parameter ist TRUE.<br />
Ein Boolean-Wert der anzeigt, ob die Daten der Tabelle zugeordnet wurden. (siehe nachfolgende<br />
Bemerkungen).<br />
Bemerkungen<br />
Die SetData-Methode ordnet Daten einer Tabellenzelle zu und entspricht der Verwendung der<br />
Tabellenindizierer. Zum Beispiel:<br />
• Visual Basic<br />
• C#<br />
fg.SetData(row, col, 12) ' is equivalent to<br />
fg(row, col) = 12<br />
fg.SetData(row, col, 12); // is equivalent to<br />
fg[row, col] = 12;<br />
• Delphi<br />
fg.SetData(row, col, 12);<br />
fg[row, col] := 12;<br />
Wenn Sie einer Zelle einen Datenwert zuordnen, dann prüft die Tabelle den Datentyp der Spalten und<br />
zwingt den Datenwert automatisch in den entsprechenden Typ. Zum Beispiel, wenn die DataType-<br />
Eigenschaft einer Spalte auf Integer steht und Sie einer Zelle dieser Spalte einen String- oder Double-Wert<br />
zuordnen, dann wird die Tabellensteuerung versuchen, diesen Wert in einen Integer umzuwandeln,<br />
bevor er in der Tabelle abgespeichert wird. Wenn die Umwandlung fehl schlägt, gibt SetData FALSE<br />
zurück.<br />
Wenn Sie den optionalen Parameter coerce auf FALSE setzen, dann speichert die Steuerung die Daten<br />
ohne Umwandlung in der Tabelle ab. Somit können Sie willkürliche Daten, ohne Rücksicht auf den<br />
Datentyp der Spalte, in den Zellen abspeichern.<br />
Sie können auch Ihre eigenen, willkürlichen Daten mit einem CellRange-Objekt und dessen UserData-<br />
Eigenschaft den Zellen in einer Tabelle zuordnen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
SetDataBinding-Methode<br />
Stellt die DataSource- und DataMember-Eigenschaften ein.
Syntax<br />
[VB]<br />
Public Sub SetDataBinding(ByVal dataSource As Object, ByVal dataMember As String)<br />
[C#]<br />
public void SetDataBinding (object dataSource, string dataMember)<br />
[Delphi]<br />
procedure SetDataBinding(dataSource: Object; dataMember: String);<br />
Parameter Beschreibung<br />
dataSource Die Datenquelle der Tabelle.<br />
dataMember<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
ShowCell-Methode<br />
ShowCell-Methode · 209<br />
Eine bestimmte Liste in einem DataSource-Objekt, welche die Tabelle anzeigen<br />
soll.<br />
Scrollt die Tabelle, so dass eine bestimmte Zelle auf dem Bildschirm angezeigt wird.<br />
Syntax<br />
[VB]<br />
Public Sub ShowCell(row As Integer, col As Integer)<br />
[C#]<br />
public void ShowCell ( int row , int col )<br />
[Delphi]<br />
procedure ShowCell(row: integer; col: Integer);<br />
Parameter Beschreibung<br />
row, col Die Koordinaten der Zelle, die auf den Bildschirm gescrollt wird.<br />
Bemerkungen<br />
Diese Methode betrifft nicht die aktuelle Auswahl. Verwenden Sie die Select-Methode, um einen Cursor<br />
auf eine bestimmte Zelle zu setzen und diese optional auf den Bildschirm zu bringen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)
210 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
ShowSortAt-Methode<br />
Zeigt ein Sortierungszeichen in einer bestimmten Spalte.<br />
Syntax<br />
[VB]<br />
Public Sub ShowSortAt(order As SortFlags, col As Integer)<br />
[C#]<br />
public void ShowSortAt (SortFlags order , int col )<br />
[Delphi]<br />
procedure ShowSortAt(order: SortFlags; col: Integer);<br />
Parameter Beschreibung<br />
glyph<br />
Der Typ des anzuzeigenden Sortierungszeichens (z.B. SortFlags.Ascending oder<br />
SortFlags.Descending).<br />
col Die Spalte, in der das Zeichen angezeigt werden soll.<br />
Bemerkungen<br />
Diese Methode ist nützlich, wenn Sie eine benutzerdefinierte Sortierung vornehmen wollen und<br />
Kontrolle über das Aussehen und die Position des Sortierungszeichens benötigen. Das kleine Dreieck<br />
erscheint in der Kopfzeile der sortierten Spalten.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
Sort-Methode<br />
Sortiert die gesamte Tabelle oder eine Auswahl an Zeilen, basierend auf dem Inhalt einer oder mehrerer<br />
Spalten.<br />
Syntax<br />
[VB]<br />
Public Overridable Sort(order As SortFlags, col As Integer)<br />
Public Overridable Sort(order As SortFlags, col1 As Integer, col2 As Integer)<br />
Public Overridable Sort(order As SortFlags, rg As CellRange)<br />
Public Overridable Sort(index As Integer, count As Integer, comparer As IComparer)<br />
Public Overridable Sort(comparer As IComparer)<br />
[C#]<br />
public void Sort (SortFlags order , int col )<br />
public void Sort (SortFlags order , int col1 , int col2 )
public void Sort (SortFlags order , CellRange rg )<br />
public void Sort ( int index , int count , IComparer comparer )<br />
public void Sort (IComparer comparer )<br />
[Delphi]<br />
procedure Sort(order: SortFlags; col: Integer);<br />
procedure Sort(order: SortFlags; col1: Integer; col2: Integer);<br />
procedure Sort(order: SortFlags; rg: CellRange);<br />
procedure Sort(index: Integer; count: Integer; comparer: Icomparer);<br />
procedure Sort(comparer: Icomparer);<br />
Parameter Beschreibung<br />
SortFlags flags<br />
Einer oder mehrere Werte aus der SortFlags-Aufzählung, die den<br />
Sortierungstyp festlegen (z.B. aufsteigend, absteigend oder Groß- und<br />
Kleinschreibung berücksichtigend).<br />
int col Die Spalte, nach deren Daten sortiert werden soll.<br />
int col1, col2 Ein Spaltenbereich, nach dem sortiert werden soll.<br />
CellRange range<br />
IComparer compare<br />
Bemerkungen<br />
Sort-Methode · 211<br />
Ein Zellbereich, nach dem sortiert werden soll. Wenn ein Bereich festgelegt ist,<br />
dann sortiert die Tabelle nur die Zeilen innerhalb des Bereichs.<br />
Ein Objekt, dass die IComparer-Schnittstelle implementiert, um Row-Objekte<br />
zu vergleichen. Dies kann für benutzerdefinierte Sortierung verwendet werden.<br />
Mit der Sort-Methode können Sie Spalten oder Zellbereiche auf- oder absteigend sortieren. Die flags-<br />
Parameter legen neben anderen Optionen auch die Sortierungsrichtung, wie nachfolgend beschrieben,<br />
fest:<br />
Flag Wirkung<br />
Ascending Sortiert die Zeilen aufsteigend.<br />
Descending Sortiert die Zeilen absteigend.<br />
AsDisplayed Sortiert nach den angezeigten Werten. Wenn dieser Flag gesetzt ist, dann basiert<br />
die Sortierung der Daten auf den, dem Nutzer angezeigten und formatierten<br />
Zellinhalten. Wenn er nicht gesetzt wird, dann basiert die Sortierung auf den<br />
zugrundeliegenden Datenwerten.<br />
IgnoreCase Berücksichtigt keine Groß- und Kleinschreibung beim Vergleich der Zellinhalte.<br />
UseColSort Verwendet den Wert der Sort-Eigenschaft von jeder Spalte in dem entsprechenden<br />
Sortierungsbereich. Somit können Sie manche Spalten in auf- und andere in<br />
absteigender Richtung sortieren.
212 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Wenn Sie mehrere Spalten sortieren, dann werden auf alle Spalten, beginnend von der linken Spalte des<br />
Sortierungsbereichs und nach rechts fortfahrend, die gleichen Sortieroptionen angewendet.<br />
Die Tabelle verwendet einen konstanten Sortieralgorythmus. Das bedeutet, dass die Sortierung die<br />
relative Reiheinfolge der Daten beibehält, wenn der Sortierungsschlüssel der gleiche ist. Zum Beispiel,<br />
wenn Sie zunächst eine Dateienliste nach Namen und anschließend nach Dateienerweiterungen sortieren,<br />
dann werden die Dateinamen innerhalb der Dateienerweiterungsgruppe immer noch sortiert sein.<br />
Um mehrere Spalten in unterschiedliche Richtungen zu sortieren, können Sie entweder die Sort-Methode<br />
mehrfach hintereinander aufrufen, oder die Sort-Eigenschaft einer jeden Spalte festlegen und dann die<br />
Sort-Methode mit dem UseColSort-Flag im flags-Pparameter aufrufen.<br />
Um benutzerdefinierte Sortierungen zu integrieren, sollten Sie ein Objekt zur Verfügung stellen, dass die<br />
IComparer-Schnittstelle implementiert. Diese einfache Schnittstelle besitzt nur eine Methode mit dem<br />
Namen Compare. Diese nimmt zwei Objekte als Argumente an (In diesem Fall werden es Row-Objekte<br />
sein) und gibt -1, 0 oder +1 zurück. Für weitere Details, schauen Sie bitte in der Dokumentation der<br />
System.Collections.IComparer-Schnittstelle nach.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
StartEditing-Methode<br />
Versetzt die Tabelle in den Bearbeitungsmodus und beginnt die Zelle zu bearbeiten.<br />
Syntax<br />
[VB]<br />
Public Function StartEditing() As Boolean<br />
Public Function StartEditing(row As Integer, col As Integer) As Boolean<br />
Public Function StartEditing(row As Integer, col As Integer, key As Char) As Boolean<br />
[C#]<br />
public Boolean StartEditing ( )<br />
public Boolean StartEditing ( int row , int col )<br />
public Boolean StartEditing ( int row , int col , Char key )<br />
[Delphi]<br />
function StartEditing: Boolean;<br />
function StartEditing(row: Integer; col: Integer): Boolean;<br />
function StartEditing(row: Integer; col: Integer; key: Char): Boolean;<br />
Parameter Beschreibung<br />
row, col<br />
charTyped<br />
Die zu bearbeitende Zelle. Der Standardwert ist die aktuelle Auswahl, welche durch<br />
die Eigenschaften Row und Col festgelegt ist.<br />
Das zunächst im Editor angezeigte Zeichen. Wenn dieser Parameter nicht gesetzt<br />
wird, dann beginnt der Editor mit dem aktuellen Wert der Zelle. Wenn ein Wert zur<br />
Verfügung gestellt wird, dann sendet die Tabelle diesen an den Editor und ersetzt
Bemerkungen<br />
StartEditing-Methode · 213<br />
somit die aktuelle Auswahl in Textfeldeditoren oder wählt ein Element mit dem<br />
entsprechendem Zeichen in Listeneditoren aus.<br />
Wenn die AllowEditing-Eigenschaft auf einem von Null verschiedenen Wert steht, dann geht die<br />
Steuerung automatisch in den Bearbeitungsmodus, wenn der Nutzer die Bearbeitungstaste (F2), die<br />
Leertaste oder jede beliebige Taste druckbarer Zeichen drückt. Sie können außerdem die StartEditing-<br />
Methode verwenden, um die Steuerung in den Bearbeitungsmodus zu zwingen.<br />
Die StartEditing-Methode zwingt die Steuerung sogar in den Bearbeitungsmodus, wenn die<br />
AllowEditing-Eigenschaft auf FALSE steht oder die Zellen fixiert sind.<br />
Beispiel<br />
Der nachfolgende Quellcode verwendet die StartEditing-Methode, um die Tabelle im<br />
Bearbeitungsmodus zu halten, selbst wenn der Nutzer die Auswahl verändert (wie die .NET-DataGrid-<br />
Steuerung):<br />
• Visual Basic<br />
• C#<br />
Private Sub _flex_KeyDown(sender As Object, e As KeyEventArgs)<br />
If e.KeyCode = Keys.Return Then<br />
e.Handled = True ' ignore the event, we'll handle it ourselves<br />
_flex.StartEditing() ' put the grid in edit mode<br />
Dim tb As TextBox = _flex.Editor '<br />
' if we got a textbox, then<br />
If Not (tb Is Nothing) Then<br />
tb.Select(tb.Text.Length, 0) ' move cursor to end<br />
End If<br />
End If<br />
End Sub '_flex_KeyDown<br />
Private Sub _flex_KeyPress(sender As Object, e As KeyPressEventArgs)<br />
If e.KeyChar = CChar(13) Then ' ignore enter key<br />
e.Handled = True ' (don't move the cursor)<br />
End If<br />
End Sub '_flex_KeyPress<br />
private void _flex_KeyDown(object sender, KeyEventArgs e)<br />
{<br />
if (e.KeyCode == Keys.Return)<br />
{<br />
e.Handled = true; // ignore the event, we'll handle it ourselves<br />
_flex.StartEditing(); // put the grid in edit mode<br />
TextBox tb = _flex.Editor as TextBox; // if we got a textbox, then<br />
if (tb != null) tb.Select(tb.Text.Length, 0); // move cursor to end<br />
}<br />
}<br />
private void _flex_KeyPress(object sender, KeyPressEventArgs e)<br />
{<br />
if (e.KeyChar == (char)13) // ignore enter key<br />
e.Handled = true; // (don't move the cursor)<br />
}<br />
• Delphi<br />
procedure Class1._flex_KeyDown(sender: System.Object; e: KeyEventArgs);<br />
var<br />
tb: TextBox;
214 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
begin<br />
if (e.KeyCode = Keys.Return) then<br />
begin<br />
e.Handled := True;<br />
_flex.StartEditing;<br />
if (flex.Editor is TextBox) then<br />
TextBox(tb).Select(tb.Text.Length, 0);<br />
end;<br />
end;<br />
procedure Class1._flex_KeyPress(sender: System.Object; e:<br />
KeyPressEventArgs);<br />
begin<br />
if (e.KeyChar = (WideChar(13))) then<br />
e.Handled := True;<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
Subtotal-Methode<br />
Gruppiert und summiert Zeilen nach ihrem Inhalt.<br />
Syntax<br />
[VB]<br />
Public Sub Subtotal(aggType As AggregateEnum)<br />
Public Sub Subtotal(aggType As AggregateEnum, level As Integer, groupOn As Integer, totalOn As<br />
Integer)<br />
Public Sub Subtotal(aggType As AggregateEnum, level As Integer, groupFrom As Integer, groupTo As<br />
Integer, totalOn As Integer, caption As String)<br />
Public Sub Subtotal(aggType AggregateEnum, level As Integer, groupOn As Integer, totalOn As Integer,<br />
caption As String)<br />
[C#]<br />
public void Subtotal (AggregateEnum aggType )<br />
public void Subtotal (AggregateEnum aggType , int level , int groupOn , int totalOn )<br />
public void Subtotal (AggregateEnum aggType , int level , int groupOn , int totalOn , String caption )<br />
public void Subtotal (AggregateEnum aggType , int level , int groupFrom , int groupTo , int totalOn ,<br />
String caption )<br />
[Delphi]<br />
procedure Subtotal(aggType: AggregateEnum);<br />
procedure Subtotal(aggType: AggregateEnum; level: Integer; groupOn: Integer; totalOn: Integer);<br />
procedure Subtotal(aggType: AggregateEnum; level: Integer; groupOn: Integer; totalOn: Integer;<br />
caption: string);<br />
procedure Subtotal(aggType: AggregateEnum; level: Integer; groupFrom: Integer; groupOn: Integer;<br />
totalOn: Integer; caption: string);
Parameter Beschreibung<br />
function<br />
level<br />
groupOn<br />
groupFrom,<br />
groupTo<br />
totalOn<br />
caption<br />
Bemerkungen<br />
Subtotal-Methode · 215<br />
Einer der AggregateEnum-Werte. Dieser Parameter legt den zu berechnenden<br />
Aggregierungstyp fest (z.B. Summe, Durchschnitt, Minimum, Maximum).<br />
Die der neuen Zwischensummenzeile zuzuordnende Gliederungsebene. Mit<br />
diesem Parameter können Sie Zwischensummen auf mehreren Ebenen erstellen<br />
und damit die Ansicht des Gliederungsbaums verändern. Für weitere Details<br />
über Gliederungen, schauen Sie bitte unter der Tree-Eigenschaft nach. Wenn<br />
dieser Parameter auf einem negativen Werte steht, dann werden die<br />
Zwischensummen nicht als Knoten im Gliederungsbaum angezeigt.<br />
Der zu verwendende Spaltenindex, um Gruppen abzugrenzen. Wenn die<br />
Zwischensummen eingefügt werden, dann durchsucht die Tabelle alle Zeilen und<br />
fügt Zwischensummenzeilen ein, wenn sich der Wert dieser oder der links von<br />
dieser stehenden Spalte ändert. Wenn dieser Parameter auf einem negativen<br />
Wert steht, dann berechnet die Steuerung die Gesamtsumme für die Tabelle.<br />
Der zu verwendende Spaltenbereich, um Gruppen abzugrenzen. Wenn die<br />
Zwischensummen eingefügt werden, dann durchsucht die Tabelle alle Zeilen und<br />
fügt Zwischensummenzeilen ein, wenn sich ein Wert in diesem Bereich ändert.<br />
Die für die Aggregierung zu verwendende Spalte. Für die meisten<br />
Aggregationstypen muss diese Spalte numerische Werte enthalten. Sie können<br />
auch Zählungen für jeden Typ und Bereich der Datenspalten vornehmen.<br />
Der in der Zwischensummenzeile einzufügende Text. Standardmäßig wird die<br />
Tabelle die nach den zu gruppierenden Werte verwenden, festgelegt durch die<br />
groupOn-, groupFrom oder groupTo-Parameter. Wenn Sie eine Bezeichnung<br />
hierfür festlegen, dann wird diese in der Zwischensummenzeile derjenigen Spalte<br />
zugewiesen, die in der Column-Eigenschaft der Gliederung steht. Die<br />
Bezeichnung kann einen Platzhalter „{0}“ enthalten, der mit dem zu<br />
gruppierenden Wert ersetzt wird.<br />
Die Subtotal-Methode fügt Zeilen mit aggregierten Werten ein. Diese neuen Zeilen verhalten sich wie<br />
Gliederungsknoten, so dass diese erweitert und zusammengeklappt werden können und eine<br />
dynamische Gliederungshierarchie unterstützen.<br />
Sie können die Ansicht und das Verhalten der Gliederungsbäume mit der Tree-Eigenschaft steuern.<br />
Die Style-Eigenschaft der Knotenzeilen, die von der Subtotal-Methode hinzugefügt werden, steht<br />
automatisch auf einem der Styles.Subtotal-Formate. Verwenden Sie diese Styles-Eigenschaft, um das<br />
Format aller Zwischensummenzeilen in der Tabelle anzupassen.<br />
Um einen Gliederungsbaum manuell zu erstellen, müssen Sie die IsNode-Eigenschaft der Zeile, die einen<br />
Gliederungsknoten enthalten soll, auf TRUE setzen. Anschließend können Sie mit der Level-Eigenschaft<br />
von Row.Node die Gliederungsebene des neuen Knotens festlegen.<br />
Beispiel<br />
Der nachfolgende Quellcode ist eine typische, gliederungsaktualisierende Routine, die aufgerufen wird,<br />
wenn sich Daten geändert haben, oder der Nutzer Spalten verschoben hat, um die Ansicht der Daten<br />
anzupassen.
216 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Die Routine beginnt damit, die alten Summen zu löschen und sortiert anschließend die Tabelle, um die<br />
Daten in Gruppen zu organisieren. Schlussendlich werden drei Zwischensummenebenen für die „Sales“-<br />
und „Credits“-Spalte erstellt.<br />
• Visual Basic<br />
• C#<br />
Private Sub flex_AfterDragColumn(sender As Object, e As<br />
DragRowColEventArgs)<br />
updateTreeReport(True)<br />
End Sub 'flex_AfterDragColumn<br />
Sub updateTreeReport(setCaption As Boolean)<br />
' avoid flicker<br />
flex.Redraw = False<br />
' clear old totals<br />
flex.Subtotal(AggregateEnum.Clear)<br />
' sort grid to organize into groups<br />
flex.Sort(SortFlags.Ascending, flex.Cols.Fixed, flex.Cols.Count - 1)<br />
' update subtotals<br />
flex.Tree.Column = 1<br />
Dim caption As String<br />
If setCaption Then caption = "Total {0}"<br />
' total on Sales, group on first three columns<br />
Dim totalOn As Integer = flex.Cols("Sales").SafeIndex<br />
flex.Subtotal(AggregateEnum.Sum, 0, 1, totalOn, caption)<br />
flex.Subtotal(AggregateEnum.Sum, 1, 2, totalOn, caption)<br />
flex.Subtotal(AggregateEnum.Sum, 2, 3, totalOn, caption)<br />
' total on Credits, group on first three columns<br />
totalOn = flex.Cols("Credits").SafeIndex<br />
flex.Subtotal(AggregateEnum.Sum, 0, 1, totalOn, caption)<br />
flex.Subtotal(AggregateEnum.Sum, 1, 2, totalOn, caption)<br />
flex.Subtotal(AggregateEnum.Sum, 2, 3, totalOn, caption)<br />
' ready to show the grid again<br />
flex.Redraw = True<br />
End Sub 'updateTreeReport<br />
private void flex_AfterDragColumn(object sender, DragRowColEventArgs e)<br />
{<br />
updateTreeReport(true);<br />
}<br />
void updateTreeReport(bool setCaption)<br />
{<br />
// avoid flicker<br />
flex.Redraw = false;<br />
// clear old totals<br />
flex.Subtotal(AggregateEnum.Clear);<br />
// sort grid to organize into groups<br />
flex.Sort(SortFlags.Ascending, flex.Cols.Fixed, flex.Cols.Count-1);<br />
// update subtotals<br />
flex.Tree.Column = 1;<br />
string caption = (setCaption)? "Total {0}": "";<br />
// total on Sales, group on first three columns
}<br />
• Delphi<br />
int totalOn = flex.Cols["Sales"].SafeIndex;<br />
flex.Subtotal(AggregateEnum.Sum, 0, 1, totalOn, caption);<br />
flex.Subtotal(AggregateEnum.Sum, 1, 2, totalOn, caption);<br />
flex.Subtotal(AggregateEnum.Sum, 2, 3, totalOn, caption);<br />
// total on Credits, group on first three columns<br />
totalOn = flex.Cols["Credits"].SafeIndex;<br />
flex.Subtotal(AggregateEnum.Sum, 0, 1, totalOn, caption);<br />
flex.Subtotal(AggregateEnum.Sum, 1, 2, totalOn, caption);<br />
flex.Subtotal(AggregateEnum.Sum, 2, 3, totalOn, caption);<br />
// ready to show the grid again<br />
flex.Redraw = true;<br />
procedure flex_AfterDragColumn(sender: System.Object; e:<br />
DragRowColEventArgs);<br />
updateTreeReport(True);<br />
end; // flex_AfterDragColumn<br />
procedure updateTreeReport(setCaption: Boolean);<br />
var<br />
caption: string;<br />
totalOn: Integer;<br />
begin<br />
// avoid flicker<br />
flex.Redraw := False;<br />
// clear old totals<br />
flex.Subtotal(AggregateEnum.Clear);<br />
Subtotal-Methode · 217<br />
// sort grid to organize into groups<br />
flex.Sort(SortFlags.Ascending, flex.Cols.Fixed, flex.Cols.Count - 1);<br />
// update subtotals<br />
flex.Tree.Column := 1;<br />
If setCaption Then<br />
caption := 'Total {0}';<br />
// total on Sales, group on first three columns<br />
totalOn := flex.Cols['Sales'].SafeIndex;<br />
flex.Subtotal(AggregateEnum.Sum, 0, 1, totalOn, caption);<br />
flex.Subtotal(AggregateEnum.Sum, 1, 2, totalOn, caption);<br />
flex.Subtotal(AggregateEnum.Sum, 2, 3, totalOn, caption);<br />
// total on Credits, group on first three columns<br />
totalOn := flex.Cols['Credits'].SafeIndex;<br />
flex.Subtotal(AggregateEnum.Sum, 0, 1, totalOn, caption);<br />
flex.Subtotal(AggregateEnum.Sum, 1, 2, totalOn, caption);<br />
flex.Subtotal(AggregateEnum.Sum, 2, 3, totalOn, caption);<br />
// ready to show the grid again<br />
flex.Redraw := True;<br />
end; // updateTreeReport<br />
Beachten Sie, dass mehrere Aggregierungen in einer Zwischensummenzeile angezeigt werden können.<br />
(eine pro Spalte). Die Subtotal-Methode prüft auf leere Zellen in den vorhandenen<br />
Zwischensummenzeilen und wird diese, wenn möglich verwenden. Das nachfolgende Beispiel zeigt<br />
Summen für mehrere Spalten in jeder Zwischensummenzeile:
218 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
• Visual Basic<br />
• C#<br />
flex.Subtotal(AggregateEnum.Clear)<br />
flex.Subtotal(AggregateEnum.Count, 0, 1, 1, 1, "Count is {0}")<br />
Dim c As Integer<br />
For c = 2 To flex.Cols.Count - 1<br />
flex.Subtotal(AggregateEnum.Sum, 0, 1, 1, c, "Sum is {0}")<br />
Next c<br />
flex.Subtotal(AggregateEnum.Clear);<br />
flex.Subtotal(AggregateEnum.Count, 0, 1, 1, 1, "Count is {0}");<br />
for (int c = 2; c < flex.Cols.Count; c++)<br />
flex.Subtotal(AggregateEnum.Sum, 0, 1, 1, c, "Sum is {0}");<br />
• Delphi<br />
var<br />
c: Integer;<br />
begin<br />
flex.Subtotal(AggregateEnum.Clear);<br />
flex.Subtotal(AggregateEnum.Count, 0, 1, 1, 1, 'Count is {0}');<br />
c := 2;<br />
while (c < flex.Cols.Count) do<br />
begin<br />
flex.Subtotal(AggregateEnum.Sum, 0, 1, 1, c, 'Sum is {0}');<br />
c := c + 1;<br />
end;<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>-Ereignisse<br />
AfterAddRow-Ereignis<br />
Wird gestartet, wenn die AllowAddNew-Eigenschaft auf TRUE steht, und nachdem der Nutzer eine<br />
neue Zeile in die Tabelle eingefügt hat.<br />
Syntax<br />
[VB]<br />
Public Event AfterAddRow(sender As Object, e As RowColEventArgs) As RowColEventHandler<br />
[C#]<br />
public event RowColEventHandler AfterAddRow<br />
[Delphi]<br />
property AfterAddRow: RowColEventHandler;<br />
Bemerkungen<br />
Dieses Ereignis wird nicht gestartet, wenn der Tabelle eine neue Zeile programmatisch oder durch die<br />
Datenquelle der Tabelle hinzugefügt wurde. Um es zu starten, muss AllowAddNew auf TRUE stehen<br />
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.<br />
AfterCollapse-Ereignis · 219<br />
Wenn eine neue Zeile auf diesem Wege erstellt wurde, dann ist diese zunächst leer und der Nutzer kann<br />
den Vorgang abbrechen, indem er den Cursor aus der unveränderten Zeile herausnimmt. In diesem Fall<br />
startet die Tabelle das CancelAddRow-Ereignis und die neue, leere Zeile wird wieder entfernt.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
AfterCollapse-Ereignis<br />
Wird gestartet, nachdem eine Knotenzeile auf- oder zusammengklappt wurde.<br />
Syntax<br />
[VB]<br />
Public Event AfterCollapse(sender As Object, e As RowColEventArgs) As RowColEventHandler<br />
[C#]<br />
public event RowColEventHandler AfterCollapse<br />
[Delphi]<br />
property AfterCollapse: RowColEventHandler;<br />
Bemerkungen<br />
Schauen Sie für Details und Beispiele unter dem BeforeCollapse-Ereignis nach.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
AfterDataRefresh-Ereignis<br />
Wird im gebundenen Modus gestartet, nachdem sich die Tabelle durch die Änderung der Datenquelle<br />
verändert.<br />
Syntax<br />
[VB]<br />
Public Event AfterDataRefresh(sender As Object, e As ListChangedEventArgs) As<br />
ListChangedEventHandler<br />
[C#]<br />
public ListChangedEventHandler AfterDataRefresh<br />
[Delphi]<br />
property AfterDataRefresh: ListChangedEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ ListChangedEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält.<br />
Bemerkungen
220 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Wenn die Tabelle im gebundenen Modus verwendet wird, dann startet die Tabelle nach jeder Änderung<br />
der Datenquelle das AfterDataRefresh-Ereignis. Dieses Ereignis eignet sich für Quellcode, der die Tabelle<br />
mit datengebundenen Elementen, wie z.B. Zwischensummen oder Gliederungsbäumen, aktualisiert.<br />
Schauen Sie in der Datenanalyseübung für ein Beispiel nach.<br />
Anmerkung: Der ListChangedEventHandler-Delegierer wird in System.ComponentModel definiert.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
AfterDeleteRow-Ereignis<br />
Wird gestartet, wenn die AllowDelete-Eigenschaft auf TRUE steht, und nachdem der Nutzer eine Zeile<br />
in der Tabelle mit der Entfernen-Taste gelöscht hat.<br />
Syntax<br />
[VB]<br />
Public Event AfterDeleteRow(sender As Object, e As RowColEventArgs) As RowColEventHandler<br />
[C#]<br />
public event RowColEventHandler AfterDeleteRow<br />
[Delphi]<br />
property AfterDeleteRow: RowColEventHandler;<br />
Bemerkungen<br />
Dieses Ereignis wird nicht gestartet, wenn aus der Tabelle eine Zeile programmatisch oder durch die<br />
Datenquelle der Tabelle gelöscht wurde. Um es zu startet, muss die AllowDelete auf TRUE stehen, so<br />
dass der Nutzer die Zeile mit der Entfernen-Tatse löschen kann.<br />
Wenn dieses Ereignis gestartet wird, dann sind die Zeilen bereits aus der Tabelle entfernt, so dass der<br />
Row-Parameter imm auf –1 steht.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
AfterDragColumn-Ereignis<br />
Wird gestartet, nachdem der Nutzer eine Spalte mit der Maus verschoben hat.<br />
Syntax<br />
[VB]<br />
Public Event AfterDragColumn(sender As Object, e As DragRowColEventArgs) As<br />
DragRowColEventHandler<br />
[C#]<br />
public event DragRowColEventHandler AfterDragColumn<br />
[Delphi]<br />
property AfterDragColumn: DragRowColEventHandler;
Ereignisdaten<br />
AfterDragRow-Ereignis · 221<br />
Der Ereignisabwickler erhält ein Argument vom Typ DragRowColEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int Col Der ursprüngliche Index der Spalte, die vom Nutzer gezogen wurde.<br />
int Position Der aktuelle Index der Spalte, die vom Nutzer gezogen wurde.<br />
Bemerkungen<br />
Dieses Ereignis wird nur gestartet, wenn eine Spalte vom Nutzer verschoben wird, indem er diese mit<br />
der Maus zieht (Siehe AllowDragging-Eigenschaft). Es wird nicht gestartet, wenn eine Spalte mit der<br />
Cols.Move-Methode verschoben wird.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
AfterDragRow-Ereignis<br />
Wird gestartet, nachdem der Nutzer eine Zeile mit der Maus verschoben hat.<br />
Syntax<br />
[VB]<br />
Public Event AfterDragRow(sender As Object, e As DragRowColEventArgs) As<br />
DragRowColEventHandler<br />
[C#]<br />
public event DragRowColEventHandler AfterDragRow<br />
[Delphi]<br />
property AfterDragRow: DragRowColEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ DragRowColEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int Row Der ursprüngliche Index der Zeile, die vom Nutzer gezogen wurde.<br />
int Position Der aktuelle Index der Zeile, die vom Nutzer gezogen wurde.<br />
Bemerkungen
222 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Dieses Ereignis wird nur gestartet, wenn eine Zeile vom Nutzer verschoben wird, indem er diese mit der<br />
Maus zieht (Siehe AllowDragging-Eigenschaft). Es wird nicht gestartet, wenn eine Zeile mit der<br />
Rows.Move-Methode verschoben wird.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
AfterEdit-Ereignis<br />
Wird gestartet, nachdem der Nutzer die Zelle fertig bearbeitet hat.<br />
Syntax<br />
[VB]<br />
Public Event AfterEdit(sender As Object, e As RowColEventArgs) As RowColEventHandler<br />
[C#]<br />
public event RowColEventHandler AfterEdit<br />
[Delphi]<br />
property AfterEdit: RowColEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int Row, Col Die Koordinaten der Zelle, die bearbeitet wurde.<br />
Bemerkungen<br />
Dieses Ereignis wird gestartet, nachdem die Inhalte einer Zelle vom Nutzer verändert wurden. Es ist für<br />
Eingriffe nützlich, wie z.B. neue Datensortierung oder Berechnung der Zwischensummen.<br />
Das AfterEdit-Ereignis eignet sich nicht für Gültigkeitsprüfungen der Daten, da es erst gestartet wird,<br />
nachdem die Änderungen in die Tabelle eingefügt wurden. Verwenden Sie stattdessen das ValidateEdit-<br />
Ereignis, um vom Nutzer eingegebene Daten auf Gültigkeit zu prüfen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
AfterFreezeColumn-Ereignis<br />
Wird gestartet, nachdem der Nutzer Spalten mit der Maus fixiert hat.<br />
Syntax<br />
[VB]<br />
Public Event AfterFreezeColumn(sender As Object, e As RowColEventArgs) As RowColEventHandler
[C#]<br />
public event RowColEventHandler AfterFreezeColumn<br />
[Delphi]<br />
property AfterFreezeColumn: RowColEventHandler;<br />
Ereignisdaten<br />
AfterFreezeRow-Ereignis · 223<br />
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int Row, Col Die Koordinaten der Zelle, die bearbeitet wurde.<br />
Bemerkungen<br />
Schauen Sie auch unter der AllowFreezing-Eigenschaft (Seite 120) nach.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
AfterFreezeRow-Ereignis<br />
Wird gestartet, nachdem der Nutzer Zeilen mit der Maus fixiert hat.<br />
Syntax<br />
[VB]<br />
Public Event AfterFreezeRow(sender As Object, e As RowColEventArgs) As RowColEventHandler<br />
[C#]<br />
public event RowColEventHandler AfterFreezeRow<br />
[Delphi]<br />
property AfterFreezeRow: RowColEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int Row, Col Die Koordinaten der Zelle, die bearbeitet wurde.<br />
Bemerkungen<br />
Schauen Sie auch unter der AllowFreezing-Eigenschaft (Seite 120) nach.
224 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
AfterResizeColumn-Ereignis<br />
Wird gestartet, nachdem der Nutzer die Breite von Spalten verändert hat.<br />
Syntax<br />
[VB]<br />
Public Event AfterResizeColumn(sender As Object, e As RowColEventArgs) As RowColEventHandler<br />
[C#]<br />
public event RowColEventHandler AfterResizeColumn<br />
[Delphi]<br />
property AfterResizeColumn: RowColEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int Col Der Index der Spalte, deren Höhe der Nutzer angepasst hat.<br />
Bemerkungen<br />
Dieses Ereignis wird nur gestartet, wenn der Nutzer die Größe der Spalte ändert, indem er die<br />
Überschriftszelle an ihren Rändern mit der Maus zieht (Siehe AllowResizing-Eigenschaft). Es wird nicht<br />
gestartet, wenn die Breite einer Spalte durch das Setzen eines neuen Wertes in der Col.Width-Eigenschaft<br />
verändert wird.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
AfterResizeRow-Ereignis<br />
Wird gestartet, nachdem der Nutzer die Höhe von Zeilen verändert hat.<br />
Syntax<br />
[VB]<br />
Public Event AfterResizeRow(sender As Object, e As RowColEventArgs) As RowColEventHandler<br />
[C#]<br />
public event RowColEventHandler AfterResizeRow
[Delphi]<br />
property AfterResizeRow: RowColEventHandler;<br />
Ereignisdaten<br />
AfterRowColChange-Ereignis · 225<br />
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int Row Der Index der Zeile, deren Höhe der Nutzer angepasst hat.<br />
Bemerkungen<br />
Dieses Ereignis wird nur gestartet, wenn der Nutzer die Höhe der Zeile ändert, indem er die<br />
Überschriftszelle an ihren Rändern mit der Maus zieht (Siehe AllowResizing-Eigenschaft). Es wird nicht<br />
gestartet, wenn die Höhe einer Zeile durch das Setzen eines neuen Wertes in der Row.Height-<br />
Eigenschaft verändert wird.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
AfterRowColChange-Ereignis<br />
Wird gestartet, nachdem der Auswahlanker auf eine andere Zelle festgelegt wird.<br />
Syntax<br />
[VB]<br />
Public Event AfterRowColChange(sender As Object, e As RangeEventArgs) As RangeEventHandler<br />
[C#]<br />
public event RangeEventHandler AfterRowColChange<br />
[Delphi]<br />
property AfterRowColChange: RangeEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ RangeEventArgs, welches die mit diesem Ereignis<br />
zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle Informationen für<br />
dieses Ereignis zur Verfügung.<br />
Property Beschreibung<br />
CellRange OldRange Die Auswahl vor dem Ereignis.<br />
CellRange NewRange Die aktuelle Auswahl.
226 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Bemerkungen<br />
Dieses Ereignis wird gestartet, nachdem sich die Row- oder Col-Eigenschaften durch entweder den<br />
Nutzer mit einer Tastatur- oder Mauseingabe oder durch Quellcode geändert hat.<br />
Dieses Ereignis ist nützlich, wenn Sie zusätzliche Informationen über die aktuell ausgewählte Zeile,<br />
Spalte oder Zelle anzeigen wollen. Verwenden Sie hingegen die Ereignisse BeforeRowColChange und<br />
BeforeSelChange, um eine Gültigkeitsprüfung vorzunehmen oder die Bearbeitung einer Zelle zu<br />
verhindern.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
AfterScroll-Ereignis<br />
Wird gestartet, nachdem die Tabelle gescrollt wurde.<br />
Syntax<br />
[VB]<br />
Public Event AfterScroll(sender As Object, e As RangeEventArgs) As RangeEventHandler<br />
[C#]<br />
public event RangeEventHandler AfterScroll<br />
[Delphi]<br />
property AfterScroll: RangeEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ RangeEventArgs, welches die mit diesem Ereignis<br />
zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle Informationen für<br />
dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
CellRange OldRange<br />
Der sichtbare Bereich (TopRow, LeftCol, BottomRow, RightCol) vor<br />
dem Ereignis.<br />
CellRange NewRange Der aktuell sichtbare Bereich.<br />
Bemerkungen<br />
Dieses Ereignis ist nützlich, wenn Sie synchronisierte Ansichten von zwei oder mehr Tabellen benötigen.<br />
Beispiel<br />
Dieser Quellcode verbindet zwei Tabellen (fgLeft und fgRight) und synchronisiert deren vertikalen<br />
Bildlauf. Der Nutzer kann aber weiterhin unabhängig horizontal scrollen.<br />
• Visual Basic<br />
' bind grids together<br />
fgRight.DataSource = fgLeft<br />
fgLeft.ScrollBars = ScrollBars.Horizontal
• C#<br />
AfterSelChange-Ereignis · 227<br />
' synchronize vertical scrolling<br />
Private Sub flex_AfterScroll(sender As Object, _<br />
e As C1.Win.<strong>C1FlexGrid</strong>.RangeEventArgs)<br />
Dim fg As <strong>C1FlexGrid</strong>.<strong>C1FlexGrid</strong> = CType(sender, <strong>C1FlexGrid</strong>)<br />
fg.Update()<br />
Dim y As Integer = fg.ScrollPosition.Y<br />
If fg = fgLeft Then<br />
fgRight.ScrollPosition = New Point(fgRight.ScrollPosition.X, y)<br />
Else<br />
fgLeft.ScrollPosition = New Point(fgLeft.ScrollPosition.X, y)<br />
End If<br />
End Sub 'flex_AfterScroll<br />
// bind grids together<br />
fgRight.DataSource = fgLeft;<br />
fgLeft.ScrollBars = ScrollBars.Horizontal;<br />
// synchronize vertical scrolling<br />
private void flex_AfterScroll(object sender,<br />
C1.Win.<strong>C1FlexGrid</strong>.RangeEventArgs e)<br />
{<br />
<strong>C1FlexGrid</strong>.<strong>C1FlexGrid</strong> fg = ((<strong>C1FlexGrid</strong>)sender);<br />
fg.Update();<br />
int y = fg.ScrollPosition.Y;<br />
if (fg == fgLeft)<br />
fgRight.ScrollPosition = new Point(fgRight.ScrollPosition.X, y);<br />
else<br />
fgLeft.ScrollPosition = new Point(fgLeft.ScrollPosition.X, y);<br />
}<br />
}<br />
• Delphi<br />
fgRight.DataSource := fgLeft;<br />
fgLeft.ScrollBars := ScrollBars.Horizontal;<br />
procedure Class1.flex_AfterScroll(sender: System.Object; e:<br />
C1.Win.<strong>C1FlexGrid</strong>.RangeEventArgs);<br />
var<br />
y: Integer;<br />
fg: <strong>C1FlexGrid</strong>.<strong>C1FlexGrid</strong>;<br />
begin<br />
fg := <strong>C1FlexGrid</strong>(sender);<br />
fg.Update;<br />
y := fg.ScrollPosition.Y;<br />
if fg = fgLeft then<br />
fgRight.ScrollPosition := Point.Create(fgRight.ScrollPosition.X, y)<br />
else<br />
fgLeft.ScrollPosition := Point.Create(fgLeft.ScrollPosition.X, y);<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
AfterSelChange-Ereignis<br />
Wird gestartet, nachdem sich die Auswahl geändert hat.
2<strong>28</strong> · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Syntax<br />
[VB]<br />
Public Event AfterSelChange(sender As Object, e As RangeEventArgs) As RangeEventHandler<br />
[C#]<br />
public event RangeEventHandler AfterSelChange<br />
[Delphi]<br />
property AfterSelChange: RangeEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ RangeEventArgs, welches die mit diesem Ereignis<br />
zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle Informationen für<br />
dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
CellRange OldRange Die Auswahl vor dem Ereignis.<br />
CellRange NewRange Die aktuelle Auswahl.<br />
Bemerkungen<br />
Dieses Ereignis wird gestartet, nachdem sich die RowSel oder ColSel-Eigenschaften durch entweder den<br />
Nutzer mit einer Tastatur- oder Mauseingabe oder durch Quellcode geändert hat.<br />
Dieses Ereignis ist nützlich, wenn Sie zusätzliche Informationen über die aktuell ausgewählte Zeile,<br />
Spalte oder Zelle anzeigen wollen. Verwenden Sie hingegen die Ereignisse BeforeRowColChange und<br />
BeforeSelChange, um eine Gültigkeitsprüfung vorzunehmen oder die Bearbeitung einer Zelle zu<br />
verhindern.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
AfterSort-Ereignis<br />
Wird gestartet, nachdem die Spalte durch einen Klick des Nutzers auf die Überschrift sortiert wurde.<br />
Syntax<br />
[VB]<br />
Public Event AfterSort(sender As Object, e As SortColEventArgs) As SortColEventHandler<br />
[C#]<br />
public event SortColEventHandler AfterSort<br />
[Delphi]<br />
property AfterSort: SortColEventHandler;
Ereignisdaten<br />
BeforeAddRow-Ereignis · 229<br />
Der Ereignisabwickler erhält ein Argument vom Typ SortColEventArgs, welches die mit diesem Ereignis<br />
zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle Informationen für<br />
dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int Col Die Spalte, die sortiert wurde.<br />
SortFlags Order Die neue Sortierungsrichtung der Spalte.<br />
Bemerkungen<br />
Dieses Ereignis wird nur gestartet, wenn die Spalte durch einen Klick des Nutzers auf die Überschrift<br />
sortiert wurde (Siehe AllowSorting-Eigenschaft). Es wird nicht nach der Sortierung mit der Sort-<br />
Methode gestartet.<br />
Dieses Ereignis ist nützlich, wenn Sie Benutzerschnittstellenelemente aktualisieren wollen, um die neue<br />
Sortierung anzuzeigen.<br />
Verwenden Sie hingegen Col.AllowSorting oder wickeln Sie das BeforeSort-Ereignis ab, um die<br />
Sortierung von bestimmten Spalten zu unterdrücken oder deren Standardsortierungsrichtung zu ändern.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
BeforeAddRow-Ereignis<br />
Wird gestartet, wenn die AllowAddNew-Eigenschaft auf TRUE steht, und bevor der Nutzer eine neue<br />
Zeile in die Tabelle einfügt.<br />
Syntax<br />
[VB]<br />
Public Event BeforeAddRow(sender As Object, e As RowColEventArgs) As RowColEventHandler<br />
[C#]<br />
public event RowColEventHandler BeforeAddRow<br />
[Delphi]<br />
property BeforeAddRow: RowColEventHandler;<br />
Bemerkungen<br />
Dieses Ereignis wird nicht gestartet, wenn der Steuerung eine neue Zeile programmatisch oder durch die<br />
Datenquelle der Tabelle hinzugefügt wurde. Um es zu startet, muss die AllowAddNew auf TRUE stehen<br />
und der Nutzer eine neue, leere Zeile erstellen, indem er den Cursor in die letzte Zeile der Tabelle stellt.<br />
Sie können dieses Ereignis verwenden, um die Erstellung der neuen Zeile zu verhindern, indem Sie den<br />
Cancel-Parameter auf TRUE stellen. In diesem Fall lässt sich der Cursor nicht in die neue Zeile stellen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)
230 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
BeforeAutoSizeColumn-Ereignis<br />
Wird gestartet, bevor eine Spalte ihre Breite aufgrund eines Doppelklicks automatisch anpasst.<br />
Syntax<br />
[VB]<br />
Public Event BeforeAutosizeColumn(sender As Object, e As RowColEventArgs) As<br />
RowColEventHandler<br />
[C#]<br />
public event RowColEventHandler BeforeAutosizeColumn<br />
[Delphi]<br />
property BeforeAutosizeColumn: RowColEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int Row, Col Die Zelle, die gleich bearbeitet oder gezeichnet wird.<br />
bool Cancel<br />
Bemerkungen<br />
Setzen Sie diesen Parameter auf TRUE, um die Bearbeitung der Zelle<br />
nicht zuzulassen.<br />
Standardmäßig ändert die Steuerung automatisch die Größe der Zeilen und Spalten hinsichtlich deren<br />
Inhalts für die gesamte Tabelle. Wenn eine Tabelle mehrere Tausend Zeilen beinhaltet, dann können Sie<br />
etwas Zeit sparen, indem Sie dieses Ereignis abfangen, die Größe der Spalten mit der AutoSizeCols-<br />
Methode verändern und den Cancel-Parameter auf TRUE setzen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
BeforeAutoSizeRow-Ereignis<br />
Wird gestartet, bevor eine Zeile ihre Höhe aufgrund eines Doppelklicks automatisch anpasst.<br />
Syntax<br />
[VB]<br />
Public Event BeforeAutosizeRow(sender As Object, e As RowColEventArgs) As RowColEventHandler<br />
[C#]<br />
public event RowColEventHandler BeforeAutosizeRow
[Delphi]<br />
property BeforeAutosizeRow: RowColEventHandler;<br />
Ereignisdaten<br />
BeforeCollapse-Ereignis · 231<br />
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Property Beschreibung<br />
int Row, Col Die Zelle, die gleich bearbeitet oder gezeichnet wird.<br />
bool Cancel<br />
Bemerkungen<br />
Setzen Sie diesen Parameter auf TRUE, um die Bearbeitung der Zelle<br />
nicht zuzulassen.<br />
Standardmäßig ändert die Steuerung automatisch die Größe der Zeilen und Spalten hinsichtlich deren<br />
Inhalts für die gesamte Tabelle. Wenn eine Tabelle mehrere Tausend Zeilen beinhaltet, dann können Sie<br />
etwas Zeit sparen, indem Sie dieses Ereignis abfangen, die Größe der Spalten mit der AutoSizeCols-<br />
Methode verändern und den Cancel-Parameter auf TRUE setzen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
BeforeCollapse-Ereignis<br />
Wird gestartet, bevor eine Knotenzeile auf- oder zusammengeklappt wird.<br />
Syntax<br />
[VB]<br />
Public Event BeforeCollapse(sender As Object, e As RowColEventArgs) As RowColEventHandler<br />
[C#]<br />
public event RowColEventHandler BeforeCollapse<br />
[Delphi]<br />
property BeforeCollapse: RowColEventHandler;<br />
Bemerkungen<br />
Die Ereignisse BeforeCollapse und AfterCollapse werden gestartet, bevor und nachdem ein Knoten<br />
erweitert oder zusammengeklappt wird. Sie können ermitteln, ob der Knoten aus- oder eingeklappt ist,<br />
indem Sie die Expanded-Eigenschaft überprüfen.<br />
Mit diesen Ereignissen können Sie die Gliederung je nach Nachfrage aufbauen, so dass Sie nur die Zeilen<br />
erstellen, die auch wirklich dem Nutzer angezeigt werden. Zum Beispiel, wenn Sie die Tabelle für einen<br />
Verzeichnisbaum nutzen, dann würde es sehr lang dauern, bis jedes Verzeichnis aus dem Speicher<br />
abgerufen wurde, um den Baum zu füllen. Der Nutzer wird dann anschließend wahrscheinlich nur auf<br />
ein paar wenige Knoten schauen.
232 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Der nachfolgende Quellcode zeigt, wie Sie das BeforeCollapse-Ereignis abwickeln können, um einen<br />
Baum auf Nachfrage hin zu füllen. Der Code geht davon aus, dass die Tabelle einen Quellknoten mit<br />
einem Unterknoten besitzt. Der Unterknoten wird mit den eigentlichen Daten ersetzt, wenn der Nutzer<br />
den Quellknoten erweitert.<br />
• Visual Basic<br />
• C#<br />
Private m_ExpandingNode As Boolean = False<br />
Private Sub flex_BeforeCollapse(sender As Object, e As RowColEventArgs)<br />
' if we're working, ignore this<br />
If m_ExpandingNode Then<br />
Return<br />
End If<br />
' don't allow collapsing/expanding groups of rows (with shift-click)<br />
If e.Row < 0 Then<br />
e.Cancel = True<br />
Return<br />
End If<br />
' if we're already collapsed, populate node<br />
' before expanding<br />
If flex.Rows(e.Row).Node.Collapsed Then<br />
m_ExpandingNode = True<br />
ExpandRow(e.Row)<br />
m_ExpandingNode = False<br />
End If<br />
End Sub 'flex_BeforeCollapse<br />
private bool m_ExpandingNode = false;<br />
private void flex_BeforeCollapse(object sender, RowColEventArgs e)<br />
{<br />
// if we're working, ignore this<br />
if (m_ExpandingNode)<br />
return;<br />
}<br />
• Delphi<br />
// don't allow collapsing/expanding groups of rows (with shift-click)<br />
if (e.Row < 0)<br />
{<br />
e.Cancel = true;<br />
return;<br />
}<br />
// if we're already collapsed, populate node<br />
// before expanding<br />
if (flex.Rows[e.Row].Node.Collapsed)<br />
{<br />
m_ExpandingNode = true;<br />
ExpandRow(e.Row);<br />
m_ExpandingNode = false;<br />
}<br />
procedure Class1.flex_BeforeCollapse(sender: System.Object; e:<br />
RowColEventArgs);<br />
begin<br />
// if we're working, ignore this<br />
if Self.m_ExpandingNode then<br />
Exit;<br />
// don't allow collapsing/expanding groups of rows (with shift-click)<br />
if (e.Row < 0) then
egin<br />
e.Cancel := True;<br />
Exit;<br />
end;<br />
// if we're already collapsed, populate node<br />
// before expanding<br />
if flex.Rows[e.Row].Node.Collapsed then<br />
begin<br />
Self.m_ExpandingNode := True;<br />
ExpandRow(e.Row);<br />
Self.m_ExpandingNode := False;<br />
end;<br />
end;<br />
BeforeCollapse-Ereignis · 233<br />
Der Quellcode beginnt damit, ein m_ExpandingNode-Flag zu deklarieren, um rekursive Aufrufe zu<br />
verhindern. Dies ist nötig, weil die im Code später aufgerufene ExpandRow-Routine ebenfalls Knoten<br />
erweitert, und somit dieses Ereignis erneut anschiebt.<br />
Danach wird der Wert des e.Row-Parameters geprüft. Dieser Parameter kann negativ sein, wenn viele<br />
Zeilen gleichzeitig erweitert oder zusammengeklappt werden. Dies geschieht, wenn Sie die Tree.Show<br />
Methode aufrufen.<br />
Schlussendlich prüft der Code, ob die aktuelle Zeile zusammengeklappt ist. Wenn dies der Fall ist, dann<br />
wird die Hilfsroutine ExpandRow aufgerufen, um den Knoten zu füllen, bevor dieser erweitert wird.<br />
BeforeCollapse und AfterCollapse werden nun mit Row = -1 gestartet, um anzuzeigen, dass viele Zeilen<br />
gleichzeitig erweitert oder zusammengeklappt werden.<br />
Wenn der Nutzer auf eine Gliederungsschaltfläche klickt, dann werden möglicherweise mehrere Knoten<br />
erweitert oder zusammengeklappt, um eine Zielebene anzuzeigen. In desem Fall startet die Steuerung<br />
zunächst das BeforeCollapse-Ereignis mit dessen Row-Parameter auf -1 stehend, um anzuzeigen, dass<br />
eine Abfolgeoperation mit mehrmaligem Auf-/Zuklappen gestartet wird. Abschließend wird das<br />
AfterCollapse-Ereignis ebenfalls mit dessen Row-Parameter auf -1 stehend gestartet, um anzuzeigen,<br />
dass die Abfolgeoperationen beendet sind. Zum Beispiel, wenn der Nutzer die Gliederung bis zu einer<br />
betimmten Ebene erweitert, dann wird die Steuerung die folgende Ereignisabfolge starten:<br />
• Visual Basic<br />
• C#<br />
BeforeCollapse(e.Row = - 1) ' ** batch started<br />
BeforeCollapse(e.Row = 1) ' individual rows being collapsed/expanded<br />
AfterCollapse(e.Row = 1)<br />
BeforeCollapse(e.Row = 5)<br />
AfterCollapse(e.Row = 5)<br />
BeforeCollapse(e.Row = 15)<br />
AfterCollapse(e.Row = 15)<br />
AfterCollapse(e.Row = - 1) ' ** batch ended<br />
BeforeCollapse (e.Row = -1) // ** batch started<br />
BeforeCollapse (e.Row = 1) // individual rows being collapsed/expanded<br />
AfterCollapse (e.Row = 1)<br />
BeforeCollapse (e.Row = 5)<br />
AfterCollapse (e.Row = 5)<br />
BeforeCollapse (e.Row = 15)<br />
AfterCollapse (e.Row = 15)<br />
AfterCollapse (e.Row = -1) // ** batch ended<br />
• Delphi<br />
BeforeCollapse(e.Row = -1); // ** batch started
234 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
BeforeCollapse(e.Row = 1); // individual rows being<br />
collapsed/expanded<br />
AfterCollapse(e.Row = 1);<br />
BeforeCollapse(e.Row = 5);<br />
AfterCollapse(e.Row = 5);<br />
BeforeCollapse(e.Row = 15);<br />
AfterCollapse(e.Row = 15);<br />
AfterCollapse(e.Row = -1); // ** batch ended<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
BeforeDeleteRow-Ereignis<br />
Wird gestartet, wenn die AllowDelete-Eigenschaft auf TRUE steht, und bevor der Nutzer eine Zeile in<br />
der Tabelle mit der Entfernen-Taste löscht.<br />
Syntax<br />
[VB]<br />
Public Event BeforeDeleteRow(sender As Object, e As RowColEventArgs) As RowColEventHandler<br />
[C#]<br />
public event RowColEventHandler BeforeDeleteRow<br />
[Delphi]<br />
property BeforeDeleteRow: RowColEventHandler;<br />
Bemerkungen<br />
Dieses Ereignis wird nicht gestartet, wenn die Steuerung eine Zeile programmatisch oder durch die<br />
Datenquelle aus der Tabelle entfernt. Um es zu startet, muss die AllowAddNew auf TRUE stehen und<br />
der Nutzer eine oder mehrere Zeilen mit der Entfernen-Taste löschen.<br />
Verwenden Sie dieses Ereignis, um das Löschen von Zeilen zu verhindern, indem Sie den Cancel-<br />
Parameter auf TRUE stellen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
BeforeDragColumn-Ereignis<br />
Wird gestartet, bevor der Nutzer eine Spalte mit der Maus verschiebt und sich die Spalte an ihrer neuen<br />
Position befindet.<br />
Syntax<br />
[VB]<br />
Public Event BeforeDragColumn(sender As Object, e As DragRowColEventArgs) As<br />
DragRowColEventHandler<br />
[C#]<br />
public event DragRowColEventHandler BeforeDragColumn
[Delphi]<br />
property BeforeDragColumn: DragRowColEventHandler;<br />
Ereignisdaten<br />
BeforeDragRow-Ereignis · 235<br />
Der Ereignisabwickler erhält ein Argument vom Typ DragRowColEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int Col Der aktuelle Index der Spalte, die vom Nutzer gezogen wurde.<br />
int Position<br />
Bemerkungen<br />
Der neue Index der Spalte, die vom Nutzer gezogen wurde. Sie können diesen<br />
Wert verändern, um die Spalte auf eine neue Position zu verschieben.<br />
Dieses Ereignis wird nur gestartet, wenn eine Spalte vom Nutzer verschoben wird, indem er diese mit<br />
der Maus zieht (Siehe AllowDragging-Eigenschaft). Es wird nicht gestartet, wenn eine Spalte mit der<br />
Cols.Move-Methode verschoben wird.<br />
Sie können das Ziehen von bestimmten Zeilen und Spalten verhindern, indem Sie deren AllowDragging-<br />
Eigenschaft auf FALSE setzen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
BeforeDragRow-Ereignis<br />
Wird gestartet, bevor der Nutzer eine Zeile mit der Maus verschieben will und sich die Zeile an ihrer<br />
neuen Position befindet.<br />
Syntax<br />
[VB]<br />
Public Event BeforeDragRow(sender As Object, e As DragRowColEventArgs) As<br />
DragRowColEventHandlers<br />
[C#]<br />
public event DragRowColEventHandler BeforeDragRow<br />
[Delphi]<br />
property BeforeDragRow: DragRowColEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ DragRowColEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.
236 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Eigenschaft Beschreibung<br />
int Row Der aktuelle Index der Zeile, die vom Nutzer gezogen wurde.<br />
int Position<br />
Bemerkungen<br />
Der neue Index der Zeile, die vom Nutzer gezogen wurde. Sie können diesen Wert<br />
verändern, um die Zeile auf eine neue Position zu verschieben.<br />
Dieses Ereignis wird nur gestartet, wenn eine Zeile vom Nutzer verschoben wird, indem er diese mit der<br />
Maus zieht (Siehe AllowDragging-Eigenschaft). Es wird nicht gestartet, wenn eine Zeile mit der<br />
Rows.Move-Methode verschoben wird.<br />
Sie können das Ziehen von bestimmten Zeilen und Spalten verhindern, indem Sie deren AllowDragging-<br />
Eigenschaft auf FALSE setzen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
BeforeEdit-Ereignis<br />
Wird gestartet, bevor die Steuerung in den Bearbeitungsmodus geht.<br />
Syntax<br />
[VB]<br />
Public Event BeforeEdit(sender As Object, e As RowColEventArgs) As RowColEventHandler<br />
[C#]<br />
public event RowColEventHandler BeforeEdit<br />
[Delphi]<br />
property BeforeEdit: RowColEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int Row, Col Die Zelle, die gleich bearbeitet oder gezeichnet wird.<br />
bool Cancel<br />
Bemerkungen<br />
Setzen Sie diesen Parameter auf TRUE, um die Bearbeitung der Zelle nicht<br />
zuzulassen.<br />
Dieses Ereignis wird gestartet, bevor die Steuerung in den Bearbeitungsmodus versetzt wird und bevor<br />
eine veränderbare Zelle neu gezeichnet wird, wenn diese den Fokus erhält, um festzustellen, ob diese mit<br />
einem Auswahlfeldpfeil versehen wird. Außerdem können Sie die Bearbeitung verhindern, indem Sie
BeforeFreezeColumn-Ereignis · 237<br />
den Cancel-Parameter auf TRUE setzen, oder mit der ComboList-Eigenschaft eine Auswahlliste an<br />
möglichen Elementen oder mit der EditMask-Eigenschaft eine Eingabemaske zur Verfügung stellen.<br />
Wenn die Auswahl oder die Eingabemaske für die gesamte Spalte gleich ist, dann können Sie auch die<br />
entsprechenden Eigenschaften (AllowEdit, ComboList und EditMask) des Column-Objekts setzen.<br />
Weil das BeforeEdit-Ereignis vor jeder Neuzeichnung gestartet wird, kann dieses nicht garantieren, dass<br />
die Tabelle in den Bearbeitungsmodus geht. Verwenden Sie hierfür stattdessen das StartEdit-Ereignis.<br />
Beispiel<br />
Der Nachfolgende Quellcode zeigt, wie Sie die Bearbeitung von bestimmten Zellen aufgrund deren<br />
Inhalts verhindern können. Für eine ganze Spalte können Sie die Bearbeitung mit deren AllowEditing-<br />
Eigenschaft verhindern, indem Sie diese auf FALSE setzen.<br />
• Visual Basic<br />
• C#<br />
Private Sub c1FlexGrid1_BeforeEdit(sender As Object, e As<br />
RowColEventArgs)<br />
Dim value As Object = _flex(e.Row, e.Col)<br />
If TypeOf value Is Integer And CInt(value) < 0 Then<br />
e.Cancel = True<br />
End If<br />
End Sub 'c1FlexGrid1_BeforeEdit<br />
private void c1FlexGrid1_BeforeEdit(object sender, RowColEventArgs e)<br />
{<br />
object value = _flex[e.Row, e.Col];<br />
if (value is int && (int)value < 0)<br />
e.Cancel = true;<br />
}<br />
• Delphi<br />
var<br />
value: System.Object;<br />
begin<br />
value := _flex[e.Row];<br />
if ((value is System.Int32) and (Integer(value) < 0)) then<br />
e.Cancel := True;<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
BeforeFreezeColumn-Ereignis<br />
Wird gestartet, bevor der Nutzer Spalten mit der Maus fixiert.<br />
Syntax<br />
[VB]<br />
Public Event BeforeFreezeColumn(sender As Object, e As RowColEventArgs) As RowColEventHandler<br />
[C#]<br />
public event RowColEventHandler BeforeFreezeColumn
238 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
[Delphi]<br />
property BeforeFreezeColumn: RowColEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Property Beschreibung<br />
int Row, Col Die Zelle, die gleich bearbeitet oder gezeichnet wird.<br />
bool Cancel<br />
Bemerkungen<br />
Setzen Sie diesen Parameter auf TRUE, um die Bearbeitung der Zelle nicht<br />
zuzulassen.<br />
Siehe auch AllowFreezing-Eigenschaft (Seite 120).<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
BeforeFreezeRow-Ereignis<br />
Wird gestartet, bevor der Nutzer Zeilen mit der Maus fixiert.<br />
Syntax<br />
[VB]<br />
Public Event BeforeFreezeRow(sender As Object, e As RowColEventArgs) As RowColEventHandler<br />
[C#]<br />
public event RowColEventHandler BeforeFreezeRow<br />
[Delphi]<br />
property BeforeFreezeRow: RowColEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Property Beschreibung<br />
int Row, Col Die Zelle, die gleich bearbeitet oder gezeichnet wird.<br />
bool Cancel<br />
Setzen Sie diesen Parameter auf TRUE, um die Bearbeitung der Zelle nicht<br />
zuzulassen.
Bemerkungen<br />
Schauen Sie auch unter der AllowFreezing-Eigenschaft (Seite 120) nach.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
BeforeMouseDown-Ereignis<br />
Wird gestartet, bevor die Steuerung das MouseDown-Ereignis verarbeitet.<br />
Syntax<br />
[VB]<br />
BeforeMouseDown-Ereignis · 239<br />
Public Event BeforeMouseDown(sender As Object, e As BeforeMouseDownEventArgs) As<br />
BeforeMouseDownEventHandler<br />
[C#]<br />
public BeforeMouseDownEventHandler BeforeMouseDown<br />
[Delphi]<br />
property BeforeMouseDown: BeforeMouseDownEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ BeforeMouseDownEventArgs, welches die mit<br />
diesem Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
MouseButtons Button Ermittelt, welche Maustaste gedrückt wurde.<br />
int Clicks, X, Y, Delta<br />
bool Cancel<br />
Bemerkungen<br />
Weitere Informationen über die Mausoperationen (die gleichen Parameter<br />
wie im MouseDown-Ereignis).<br />
Setzen Sie diesen Parameter auf TRUE, um die Steuerung davon<br />
abzuhalten, die Mausoperationen zu verarbeiten.<br />
Die Parameter für dieses Ereignis sind gleich denen im MouseDown-Ereignis zuzüglich einem Cancel-<br />
Parameter. Mit diesem können Sie das Standardvorgehen der Steuerung abbrechen und das Ereignis<br />
selbst abwickeln.<br />
Beispiel<br />
Die folgende Routine deaktiviert die Auswahl per Maus, während die Tabelle im Bearbeitungsmodus ist:<br />
• Visual Basic<br />
Private Sub flex_BeforeMouseDown(sender As Object, e As<br />
BeforeMouseDownEventArgs)<br />
If Not (flex.Editor Is Nothing) Then<br />
e.Cancel = True<br />
End If
240 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
• C#<br />
End Sub 'flex_BeforeMouseDown<br />
private void flex_BeforeMouseDown(object sender,<br />
BeforeMouseDownEventArgs e)<br />
{<br />
if (flex.Editor != null)<br />
e.Cancel = true;<br />
}<br />
• Delphi<br />
procedure Class1.flex_BeforeMouseDown(sender: System.Object; e:<br />
BeforeMouseDownEventArgs);<br />
begin<br />
if (flex.Editor nil) then<br />
e.Cancel := True;<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
BeforePageBreak-Ereignis<br />
Wird gestartet, während die Tabelle gedruckt wird, um die Seitenumbrüche zu steuern.<br />
Syntax<br />
[VB]<br />
Public Event BeforePageBreak(sender As Object, e As RowColEventArgs) As RowColEventHandler<br />
[C#]<br />
public event RowColEventHandler BeforePageBreak<br />
[Delphi]<br />
property BeforePageBreak: RowColEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int Row Die Zeile, die den Zeilenumbruch herbeiführt und die erste auf der neuen Seite ist.<br />
bool Cancel<br />
Bemerkungen<br />
Setzen Sie diesen Parameter auf TRUE, um zu verhindern, dass die Zeile in Row<br />
die erste auf einer neuen Seite ist.<br />
Dieses Ereignis wird ausgeführt, während die Tabellensteuerung mit der PrintGrid-Methode druckt und<br />
sie stellt die Kontrolle über Seitenumbrüche zur Verfügung.
BeforeResizeColumn-Ereignis · 241<br />
Setzen Sie den Cancel-Parameter auf TRUE, um zu verhindern, dass die Zeile in Row die erste auf einer<br />
neuen Seite ist. In diesem Fall wird die Steuerung den Umbruch nach oben verschieben und das Ereignis<br />
erneut aufrufen, bis sie eine gültige Zeile für einen Umbruch gefunden hat.<br />
Beispiel<br />
Der folgende Code zeigt, wie das BeforePageBreak-Ereignis verwendet wird, um gewisse Zeilengruppen<br />
auf einer Seite auszugeben.<br />
• Visual Basic<br />
• C#<br />
Private Sub flex_BeforePageBreak(sender As Object, e As<br />
RowColEventArgs)<br />
' get content before and after the proposed page break<br />
Dim s1 As String = CStr(flex(e.Row, 1))<br />
Dim s2 As String = CStr(flex(e.Row - 1, 1))<br />
' if contents are the same, set Cancel to true to<br />
' keep rows together on a page<br />
If s1 = s2 Then<br />
e.Cancel = True<br />
End If<br />
End Sub 'flex_BeforePageBreak<br />
private void flex_BeforePageBreak(object sender, RowColEventArgs e)<br />
{<br />
// get content before and after the proposed page break<br />
string s1 = (string) flex[e.Row,1];<br />
string s2 = (string) flex[e.Row-1,1];<br />
}<br />
• Delphi<br />
// if contents are the same, set Cancel to true to<br />
// keep rows together on a page<br />
if (s1 == s2)<br />
e.Cancel = true;<br />
procedure Class1.flex_BeforePageBreak(sender: System.Object; e:<br />
RowColEventArgs);<br />
var<br />
s2: string;<br />
s1: string;<br />
begin<br />
s1 := string(flex[e.Row]);<br />
s2 := string(flex[(e.Row - 1)]);<br />
if (s1 = s2) then<br />
e.Cancel := True;<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
BeforeResizeColumn-Ereignis<br />
Wird gestartet, bevor die Breite von Spalten verändert wird.
242 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Syntax<br />
[VB]<br />
Public Event BeforeResizeColumn(sender As Object, e As RowColEventArgs) As RowColEventHandler<br />
[C#]<br />
public event RowColEventHandler BeforeResizeColumn<br />
[Delphi]<br />
property BeforeResizeColumn: RowColEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Property Beschreibung<br />
int Col Die Spalte, deren Breite verändert wird.<br />
bool Cancel<br />
Bemerkungen<br />
Setzen Sie diesen Parameter auf TRUE, um die Größenänderung der Spalte in Col<br />
zu verhindern.<br />
Verwenden Sie die AllowResizing-Eigenschaft der Tabelle um festzustellen, ob Nutzer die Größe von<br />
Zeilen, Spalten oder beides verändern dürfen. Row- und Column-Objekte besitzen ebenfalls eine<br />
AllowResizing-Eigenschaft, mit der Sie die Änderung der Größe von Spalten verhindern können.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
BeforeResizeRow-Ereignis<br />
Wird gestartet, bevor die Höhe von Zeilen verändert wird.<br />
Syntax<br />
[VB]<br />
Public Event BeforeResizeRow(sender As Object, e As RowColEventArgs) As RowColEventHandler<br />
[C#]<br />
public event RowColEventHandler BeforeResizeRow<br />
[Delphi]<br />
property BeforeResizeRow: RowColEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung<br />
int Row Die Zeile, deren Höhe verändert wird.<br />
bool Cancel<br />
Bemerkungen<br />
BeforeRowColChange-Ereignis · 243<br />
Setzen Sie diesen Parameter auf TRUE, um die Größenänderung der Zeile in Row<br />
zu verhindern.<br />
Verwenden Sie die AllowResizing-Eigenschaft der Tabelle um festzustellen, ob Nutzer die Größe von<br />
Zeilen, Spalten oder beiden verändern dürfen. Row- und Column-Objekte besitzen ebenfalls eine<br />
AllowResizing-Eigenschaft, mit der Sie die Änderung der Größe von Spalten verhindern können.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
BeforeRowColChange-Ereignis<br />
Wird gestartet, bevor eine andere Zelle zur aktuellen Zelle (Row, Col) wird.<br />
Syntax<br />
[VB]<br />
Public Event BeforeRowColChange(sender As Object, e As RangeEventArgs) As RangeEventHandler<br />
[C#]<br />
public event RangeEventHandler BeforeRowColChange<br />
[Delphi]<br />
property BeforeRowColChange: RangeEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ RangeEventArgs, welches die mit diesem Ereignis<br />
zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle Informationen für<br />
dieses Ereignis zur Verfügung.<br />
Property Beschreibung<br />
CellRange OldRange Die Auswahl vor dem Ereignis.<br />
CellRange NewRange Die aktuelle Auswahl.<br />
Bemerkungen<br />
Dieses Ereignis wird gestartet, bevor sich die Row- oder Col-Eigenschaften durch entweder den Nutzer<br />
oder durch Quellcode ändern. Außerdem können Sie die Auswahl von bestimmten Zellen verhindern<br />
und einen geschützten Bereich auf der Tabelle erstellen.<br />
BeforeRowColChange wird nur gestartet, wenn sich Row- und Col-Eigenschaften gerade ändern. Um<br />
eine erweiterte Auswahl eines Bereichs zu verhindern, müssen Sie das BeforeSelChange-Ereignis<br />
abfangen.
244 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
BeforeScroll-Ereignis<br />
Wird gestartet, bevor die Steuerung scrollt.<br />
Syntax<br />
[VB]<br />
Public Event BeforeScroll(sender As Object, e As RangeEventArgs) As RangeEventHandler<br />
[C#]<br />
public event RangeEventHandler BeforeScroll<br />
[Delphi]<br />
property BeforeScroll: RangeEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ RangeEventHandler, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Bemerkungen<br />
Mit diesem Ereignis können Sie den Nutzer daran hindern, die Tabelle zu scrollen, während eine<br />
Operation in der aktuellen Auswahl ausgeführt wird.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
BeforeScrollTip-Ereignis<br />
Wird gestartet, bevor ein Scroll-Tip angezeigt wird, so dass Sie die ScrollTipText-Eigenschaft setzen<br />
können.<br />
Syntax<br />
[VB]<br />
Public Event BeforeScrollTip(sender As Object, e As RowColEventArgs) As RowColEventHandler<br />
[C#]<br />
public event RowColEventHandler BeforeScrollTip<br />
[Delphi]<br />
property BeforeScrollTip: RangeEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.
Eigenschaft Beschreibung<br />
int Row Die Zeile, in der die aktuelle Zelle platziert ist.<br />
Bemerkungen<br />
BeforeSelChange-Ereignis · 245<br />
Dieses Ereignis wird nur ausgeführt, wenn die ScrollTips-Eigenschaft auf TRUE steht. Somit können Sie<br />
die ScrollTipText-Eigenschaft auf einen, für eine gegebene Zeile beschreibenden, Text setzen. Zum<br />
Beispiel:<br />
• Visual Basic<br />
• C#<br />
flex.ScrollTips = True<br />
flex.ScrollTrack = False<br />
Private Sub flex_BeforeScrollTip(sender As Object, e As<br />
RowColEventArgs)<br />
Dim tip As String<br />
tip = String.Format("Row {0}" + ControlChars.Lf + "{1}", _<br />
e.Row, flex(e.Row, 1))<br />
flex.ScrollTipText = tip<br />
End Sub 'flex_BeforeScrollTip<br />
flex.ScrollTips = true;<br />
flex.ScrollTrack = false;<br />
private void flex_BeforeScrollTip(object sender, RowColEventArgs e)<br />
{<br />
string tip = string.Format("Row {0}\n{1}", e.Row, flex[e.Row,1]);<br />
flex.ScrollTipText = tip;<br />
}<br />
• Delphi<br />
flex.ScrollTips := True;<br />
flex.ScrollTrack := False;<br />
procedure Class1.flex_BeforeScrollTip(sender: System.Object; e:<br />
RowColEventArgs);<br />
var<br />
tip: string;<br />
begin<br />
tip := System.String.Format('Row {0}'#10'{1}', e.Row, flex[e.Row]);<br />
flex.ScrollTipText := tip;<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
BeforeSelChange-Ereignis<br />
Wird gestartet, bevor sich eine Auswahl (RowSel, ColSel) ändert.
246 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Syntax<br />
[VB]<br />
Public Event BeforeSelChange(sender As Object, e As RangeEventArgs) As RangeEventHandler<br />
[C#]<br />
public event RangeEventHandler BeforeSelChange<br />
[Delphi]<br />
property BeforeSelChange: RangeEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ RangeEventArgs, welches die mit diesem Ereignis<br />
zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle Informationen für<br />
dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
CellRange OldRange Die Auswahl vor dem Ereignis.<br />
CellRange NewRange Die aktuelle Auswahl.<br />
Bemerkungen<br />
Dieses Ereignis wird, bevor sich die Row- oder Col-Eigenschaften durch entweder den Nutzer oder<br />
durch Quellcode ändert, gestartet. Außerdem können Sie die Auswahl von bestimmten Zellen<br />
verhindern und einen geschützten Bereich auf der Tabelle erstellen.<br />
Um eine Berichsauswahl zu verhindern, müssen Sie außerdem das BeforeRowColChange-Ereignis,<br />
welches vor den Änderungen der Row- und Col-Eigenschaften gestartet wird, abfangen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
BeforeSort-Ereignis<br />
Wird gestartet, bevor die Spalte durch einen Klick des Nutzers auf die Überschrift sortiert wird.<br />
Syntax<br />
[VB]<br />
Public Event BeforeSort(sender As Object, e As SortColEventArgs) As SortColEventHandler<br />
[C#]<br />
public event SortColEventHandler BeforeSort<br />
[Delphi]<br />
property BeforeSort: SortColEventHandler;<br />
Ereignisdaten
BeginPrint-Ereignis · 247<br />
Der Ereignisabwickler erhält ein Argument vom Typ SortColEventArgs, welches die mit diesem Ereignis<br />
zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle Informationen für<br />
dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int Col Die zu sortierende Spalte.<br />
SortFlags Order Die Sortierungsrichtung.<br />
bool Cancel<br />
bool Handled<br />
Bemerkungen<br />
Bricht das Sortieren ab. Wenn dieser Parameter auf TRUE gestellt wird, dann<br />
bricht die Sortieroperation ab und das Sortierungszeichen bleibt unverändert.<br />
Das Sortieren wurde vom Ereignisabwickler durchgeführt. Wenn dieser<br />
Parameter auf TRUE gestellt wird, dann bricht das integrierte Sortieren ab,<br />
Das Sortierungszeichen wird aber dennoch aktualisiert, so als ob das Sortieren<br />
stattgefunden hätte. Dies ist nützlich, wenn Sie benutzerdefiniertes Sortieren<br />
verwenden.<br />
Dieses Ereignis wird nur gestartet, wenn das Sortieren durch einen Klick auf die Spaltenüberschrift<br />
ausgelöst wurde. Es wird nicht gestartet, wenn das Sortieren mit der Sort-Eigenschaft stattgefunden hat.<br />
Dieses Ereignis ist nützlich, wenn Sie das Sortieren von bestimmten Spalten durch den Nutzer<br />
verhindern oder wenn Sie benutzerdefinierte Sortierungsrichtungen für bestimmte Spalten anwenden<br />
wollen. Dies kann über den Wert des Order-Parameters gesteuert werden.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
BeginPrint-Ereignis<br />
Wird gestartet, wenn die Tabelle beginnt zu drucken.<br />
Syntax<br />
[VB]<br />
Public Event BeginPrint(sender As Object, e As PrintEventArgs) As PrintEventHandler<br />
[C#]<br />
public event PrintEventHandler BeginPrint<br />
[Delphi]<br />
property BeginPrint: PrintEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ PrintEventHandler, der im<br />
System.Drawing.Printing-Namensbereich definiert ist.<br />
Bemerkungen<br />
Verwenden Sie die PrintGrid-Methode um die Tabelle zu drucken und um den Dokumentennamen,<br />
allgemeine Druckoptionen, Kopf- und Fußzeilen festzulegen. Verwenden Sie hingegen die
248 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
PrintParameters-Eigenschaft um weniger allgemeine Druckoptionen, wie z.B. Kopf- und<br />
Fußzeilenschriftart, Seitenränder und Ausrichtung, festzulegen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
CancelAddRow-Ereignis<br />
Wird gestartet, wenn die AllowAddNew-Eigenschaft TRUE ist, und nachdem der Nutzer eine Zeile<br />
hinzugefügt hat, diese aber wieder entfernt, indem er sie ohne Änderungen verlässt.<br />
Syntax<br />
[VB]<br />
Public Event CancelAddRow(sender As Object, e As RowColEventArgs) As RowColEventHandler<br />
[C#]<br />
public event RowColEventHandler CancelAddRow<br />
[Delphi]<br />
property CancelAddRow: RowColEventHandler;<br />
Bemerkungen<br />
Schauen Sie im AfterAddRow-Ereignis für Einzelheiten nach.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
CellButtonClick-Ereignis<br />
Wird gestartet, wenn der Nutzer auf die Zellschaltfläche klickt.<br />
Syntax<br />
[VB]<br />
Public Event CellButtonClick(sender As Object, e As RowColEventArgs) As RowColEventHandler<br />
[C#]<br />
public event RowColEventHandler CellButtonClick<br />
[Delphi]<br />
property CellButtonClick: RowColEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Property Beschreibung<br />
int Row Die Zeile, in der die aktuelle Zelle platziert ist.
int Col Die Spalte, in der die aktuelle Zelle platziert ist.<br />
Bemerkungen<br />
CellChanged-Ereignis · 249<br />
Dieses Ereignis wird gestartet, wenn der Nutzer eine Bearbeitungsschaltfläche in einer Zelle anklickt.<br />
Typischerweise wird diese dazu verwendet, um einen benutzerdefinierten Editor vor der Zelle zu<br />
platzieren (z.B. Fenster für Farbauswahl, Datum, Dateien, Bilder, usw.).<br />
Standardmäßig werden Zellbearbeitungsschaltflächen rechts in der Zelle mit der Beschriftung<br />
„...“angezeigt. Diese sind den Schaltflächen im Visual Basic-Eigenschaftsfenster neben den Picture-<br />
Eigenschaften ähnlich. Sie können deren Aussehen anpassen, indem Sie eine Grafik in der<br />
CellButtonImage-Eigenschaft festlegen.<br />
Um eine Bearbeitungsschaltfläche in einer Zelle zu erstellen, müssen Sie die AllowEditing-Eigenschaft<br />
auf TRUE stellen und die ComboList-Eigenschaft der Tabelle oder einer bestimmten Spalte auf eine<br />
Ellipsis („…“) setzen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
CellChanged-Ereignis<br />
Wird gestartet, nachdem der Inhalt einer Zelle sich verändert hat.<br />
Syntax<br />
[VB]<br />
Public Event CellChanged(sender As Object, e As RowColEventArgs) As RowColEventHandler<br />
[C#]<br />
public event RowColEventHandler CellChanged<br />
[Delphi]<br />
property CellChanged: RowColEventHandler;<br />
Bemerkungen<br />
Mit diesem Ereignis können Sie Prozesse ausführen, wenn sich Zellinhalte ändern, egal auf welchem<br />
Wege (z.B. ein Nutzer gibt Daten in eine Zelle ein, Daten werden aus Datenbanken geladen oder Daten<br />
werden durch Quellcode eingefügt).<br />
Dieses Ereignis kann dafür verwendet werden, um bedingte Formatierungen und dynamische<br />
Datenzusammenfassungen zu implementieren, so dass diese automatisch aktualisiert werden, wenn<br />
immer sich Daten ändern. Für ein Beispiel schauen Sie bitte unter „Zellen formatieren“ (Seite 29) nach.<br />
Wichtige Anmerkung: In manchen Fällen wird CellChanged mit e.Col = -1 gestartet.<br />
Wenn Sie eine Zelle in der Tabelle bearbeiten, dann wird das CellChanged-Ereignis gestartet und zeigt<br />
Ihnen, welche Zeilen und Spalten verändert wurden. Dies funktioniert im gebundenen und<br />
ungebundenen Modus.<br />
Wenn die Tabelle an eine Datenquelle gebunden ist und sich Daten in dieser Datenquelle ändern, dann<br />
informiert die Quelle die Tabelle, dass sich etwas in einer bestimmten Zeile geändert hat. Es wird<br />
allerdings nicht die entsprechende Spalte übermittelt und es könnten eventuell auch mehrere Spalten
250 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
betroffen sein. Dies wird durch die Definition der IBindingList-Schnittstelle in .NET determiniert.<br />
Änderungshinweise werden auf Zeilenebene (Datensätze) und nicht auf Spaltenebene (Felder) gegeben.<br />
Wenn die Tabelle gebunden ist und der Nutzer etwas in eine Zelle schreibt, dann werden zwei<br />
Mittteilungen ausgegeben. Eine Mittteilung von der Tabelle mit der Zeile und Spalte der aktuellen Zelle<br />
und eine weitere Mittteilung von der Datenquelle mit der aktuellen Zeile und -1 für die Spalte. Wenn das<br />
einzige UI-Element, dass die Daten in Ihrer Anwendung ändern kann, die Tabelle ist, dann können Sie<br />
die zweite Mittteilung ignorieren.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
ChangeEdit-Ereignis<br />
Wird gestartet, nachdem der Text im Editor sich verändert hat.<br />
Syntax<br />
[VB]<br />
Public Event ChangeEdit(sender As Object, e As EventArgs) As EventHandler<br />
[C#]<br />
public EventHandler ChangeEdit<br />
[Delphi]<br />
property ChangeEdit: EventHandler;<br />
Ereignisdaten<br />
Keine Parameter.<br />
Bemerkungen<br />
Dieses Ereignis wird gestartet, während sich die Tabelle im Bearbeitungsmodus befindet und sich die<br />
Inhalte des Editors ändern, oder eine neue Auswahl aus einem Auswahlfeld getätigt wird.<br />
Beispiel<br />
Der nachfolgende Quellcode zeigt, wie Sie das ChangeEdit-Ereignis verwenden können, um die Größe<br />
einer Zeile an den Inhalt ihrer Zellen anzupassen und die Zeilenhöhe automatisch anzupassen, während<br />
der Nutzer Daten in die entsprechenden Zeilen eingibt:<br />
• Visual Basic<br />
' set up grid styles to allow wordwrapping:<br />
Private Sub Form1_Load(sender As Object, e As System.EventArgs)<br />
flex.Styles.Normal.WordWrap = True<br />
End Sub 'Form1_Load<br />
' after editing a row, do an AutoSizeRow<br />
Private Sub flex_AfterEdit(sender As Object, e As RowColEventArgs)<br />
flex.AutoSizeRow(e.Row)<br />
End Sub 'flex_AfterEdit<br />
' while editing, adjust the row height to fit the contents of the<br />
editor<br />
Private Sub flex_ChangeEdit(sender As Object, e As System.EventArgs)<br />
Dim g As Graphics = flex.CreateGraphics()<br />
Try
• C#<br />
ChangeEdit-Ereignis · 2<strong>51</strong><br />
' measure text height<br />
Dim sf As New StringFormat()<br />
Dim wid As Integer = flex.Cols(flex.Col).WidthDisplay - 2<br />
Dim [text] As String = flex.Editor.Text<br />
Dim sz As SizeF = g.MeasureString([text], flex.Font, wid, sf)<br />
' adjust row height if necessary<br />
Dim row As Row = flex.Rows(flex.Row)<br />
If sz.Height + 4 > row.HeightDisplay Then<br />
row.HeightDisplay = CInt(sz.Height) + 4<br />
End If<br />
Finally<br />
g.Dispose()<br />
End Try<br />
End Sub 'flex_ChangeEdit<br />
// set up grid styles to allow wordwrapping:<br />
private void Form1_Load(object sender, System.EventArgs e)<br />
{<br />
flex.Styles.Normal.WordWrap = true;<br />
}<br />
// after editing a row, do an AutoSizeRow<br />
private void flex_AfterEdit(object sender, RowColEventArgs e)<br />
{<br />
flex.AutoSizeRow(e.Row);<br />
}<br />
// while editing, adjust the row height to fit the contents of the<br />
editor<br />
private void flex_ChangeEdit(object sender, System.EventArgs e)<br />
{<br />
using (Graphics g = flex.CreateGraphics())<br />
{<br />
// measure text height<br />
StringFormat sf = new StringFormat();<br />
int wid = flex.Cols[flex.Col].WidthDisplay - 2;<br />
string text = flex.Editor.Text;<br />
SizeF sz = g.MeasureString(text, flex.Font, wid, sf);<br />
}<br />
}<br />
• Delphi<br />
// adjust row height if necessary<br />
Row row = flex.Rows[flex.Row];<br />
if (sz.Height + 4 > row.HeightDisplay)<br />
row.HeightDisplay = (int)sz.Height + 4;<br />
// set up grid styles to allow wordwrapping:<br />
procedure Form1_Load(sender: System.Object; e: System.EventArgs);<br />
begin<br />
flex.Styles.Normal.WordWrap := True;<br />
end; // Form1_Load<br />
// after editing a row, do an AutoSizeRow<br />
procedure flex_AfterEdit(sender: System.Object; e: RowColEventArgs);<br />
begin<br />
flex.AutoSizeRow(e.Row);<br />
end; // flex_AfterEdit<br />
// while editing, adjust the row height to fit the contents of the<br />
editor<br />
procedure flex_ChangeEdit(sender: System.Object; e: System.EventArgs);<br />
var
252 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
g: Graphics;<br />
sf: StringFormat;<br />
wid: Integer;<br />
txt: string;<br />
sz: SizeF;<br />
r: Row;<br />
begin<br />
g := flex.CreateGraphics;<br />
Try<br />
// measure text height<br />
sf := StringFormat.Create;<br />
wid := flex.Cols[flex.Col].WidthDisplay – 2;<br />
txt := flex.Editor.Text;<br />
sz := g.MeasureString(txt, flex.Font, wid, sf);<br />
// adjust row height if necessary<br />
r := flex.Rows[flex.Row];<br />
if sz.Height + 4 > row.HeightDisplay then<br />
row.HeightDisplay := Integer(sz.Height) + 4;<br />
Finally<br />
g.Dispose;<br />
end;<br />
end; // flex_ChangeEdit<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
ComboCloseUp-Ereignis<br />
Wird gestartet, wenn sich die Tabelle im Bearbeitungsmodus befindet, und bevor der Nutzer eine<br />
Auswahlkombinationsliste zuklappt.<br />
Syntax<br />
[VB]<br />
Public Event ComboCloseUp(sender As Object, e As RowColEventArgs) As RowColEventHandler<br />
[C#]<br />
public event RowColEventHandler ComboCloseUp<br />
[Delphi]<br />
property ComboCloseUp: RowColEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int Row Die Zeile, in der die aktuelle Zelle platziert ist.<br />
int Col Die Spalte, in der die aktuelle Zelle platziert ist.
Bemerkungen<br />
ComboDropDown-Ereignis · 253<br />
Dieses Ereignis wird gestartet, während sich die Tabelle im Bearbeitungsmodus befindet und die Zelle<br />
mit dem integrierten Auswahllisteneditor bearbeitet wird.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
ComboDropDown-Ereignis<br />
Wird gestartet, wenn sich die Tabelle im Bearbeitungsmodus befindet, und bevor der Nutzer eine<br />
Auswahlkombinationsliste aufklappt.<br />
Syntax<br />
[VB]<br />
Public Event ComboDropDown(sender As Object, e As RowColEventArgs) As RowColEventHandler<br />
[C#]<br />
public event RowColEventHandler ComboDropDown<br />
[Delphi]<br />
property ComboDropDown: RowColEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int Row Die Zeile, in der die aktuelle Zelle platziert ist.<br />
int Col Die Spalte, in der die aktuelle Zelle platziert ist.<br />
Bemerkungen<br />
Dieses Ereignis wird gestartet, während sich die Tabelle im Bearbeitungsmodus befindet und die Zelle<br />
mit dem integrierten Auswahllisteneditor bearbeitet wird.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
EndPrint-Ereignis<br />
Wird gestartet, wenn die Tabelle den Druckvorgang beendet hat.<br />
Syntax<br />
[VB]<br />
Public Event EndPrint(sender As Object, e As PrintEventArgs) As PrintEventHandler
254 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
[C#]<br />
public event PrintEventHandler EndPrint<br />
[Delphi]<br />
property EndPrint: PrintEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ PrintEventHandler, welches im<br />
System.Drawing.Printing-Namensbereich definiert ist.<br />
Bemerkungen<br />
Verwenden Sie die PrintGrid-Methode, um die Tabelle zu drucken und um den Dokumentennamen,<br />
allgemeine Druckoptionen, Kopf- und Fußzeilen festzulegen. Verwenden Sie hingegen die<br />
PrintParameters-Eigenschaft um weniger allgemeine Druckoptionen, wie z.B. Kopf- und<br />
Fußzeilenschriftart, Seitenränder und Ausrichtung, festzulegen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
EnterCell-Ereignis<br />
Wird gestartet, wenn eine Zelle aktiv wird.<br />
Syntax<br />
[VB]<br />
Public Event EnterCell(sender As Object, e As EventArgs) As EventHandler<br />
[C#]<br />
public event EventHandler EnterCell<br />
[Delphi]<br />
property EnterCell: EventHandler;<br />
Ereignisdaten<br />
Keine Parameter.<br />
Bemerkungen<br />
Dieses Ereignis wird gestartet, nachdem eine Zelle aktuell geworden ist, entweder durch die<br />
Maus/Tastatur, oder wenn die aktuelle Auswahl durch Programmcode verändert wurde.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
GetCellErrorInfo-Ereignis<br />
Wird gestartet, wenn ShowErrors TRUE ist und die Tabelle Fehlerinformationen für eine Zelle benötigt.
Syntax<br />
[VB]<br />
GetRowErrorInfo-Ereignis · 255<br />
Public Event GetCellErrorInfo(ByVal sender As Object, ByVal e As<br />
C1.Win.<strong>C1FlexGrid</strong>.GetErrorInfoEventArgs) As C1.Win.<strong>C1FlexGrid</strong>.GetErrorInfoEventHandler<br />
[C#]<br />
public event GetErrorInfoEventHandler GetCellErrorInfo<br />
[Delphi]<br />
property GetCellErrorInfo: GetErrorInfoEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ GetErrorInfoEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int Row, Col Die Zeile oder Spalte, für die Fehlerinformationen benötigt werden.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
GetRowErrorInfo-Ereignis<br />
Wird gestartet, wenn ShowErrors TRUE ist und die Tabelle Fehlerinformationen für eine Zeile benötigt.<br />
Syntax<br />
[VB]<br />
Public Event GetRowErrorInfo(ByVal sender As Object, ByVal e As<br />
C1.Win.<strong>C1FlexGrid</strong>.GetErrorInfoEventArgs) As C1.Win.<strong>C1FlexGrid</strong>.GetErrorInfoEventHandler<br />
[C#]<br />
public event GetErrorInfoEventHandler GetRowErrorInfo<br />
[Delphi]<br />
property GetRowErrorInfo: GetErrorInfoEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ GetErrorInfoEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int Row, Col Die Zeile oder Spalte, für die Fehlerinformationen benötigt werden.
256 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
GetUnboundValue-Ereignis<br />
Wird gestartet, wenn die Tabelle gebunden ist und Werte von einer ungebundenen Tabelle abrufen muss.<br />
Syntax<br />
[VB]<br />
Public Event GetUnboundValue(sender As Object, e As EventArgs) As UnboundValueEventHandler<br />
[C#]<br />
public event UnboundValueEventHandler GetUnboundValue<br />
[Delphi]<br />
property GetUnboundValue: UnboundValueEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ UnboundValueEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int Row, Col Die ungebundene Zelle, die den Wert enthält.<br />
object Value<br />
Bemerkungen<br />
Der Wert der ungebundenen Zelle. Der Ereignisabwickler sollte den<br />
ungebundenen Wert abrufen oder berechnen und diesem Parameter<br />
zuordnen.<br />
Dieses Ereignis wird nur im gebundenen Modus gestartet, wenn die Tabelle ungebundene Spalten<br />
enthält. Ungebundene Spalten verknüpfen ihre Werte nicht mit der Datenquelle. Sie können auf<br />
gebundene Spalten basierende Informationen berechnen oder andere Information, die in der Tabelle<br />
durch die Anwendung zur Verfügung gestellt werden, enthalten.<br />
Die ADO.NET DataTable-Klasse unterstützt berechnete Spalten, die in vielen Situationen anstelle der<br />
ungebundenen verwendet werden können. Dennoch sind berechnete Spalten etwas beschränkt. Die<br />
Werte müssen einfache Funktionen von anderen Werten der gleichen Zeile sein. In diesen Fällen können<br />
Sie eine ungebundene Spalte verwenden und den entsprechenden Wert mit diesem Ereignis bereitstellen.<br />
Zum Beispiel, der nachfolgende Quellcode bindet die Tabelle an eine Datenquelle und fügt anschließend<br />
eine ungebundene Spalte mit zusätzlichen Daten, die nicht in der Datenbank gespeichert sind, hinzu:<br />
• Visual Basic<br />
Private Sub Form1_Load(ByVal sender As System.Object,<br />
ByVal e As System.EventArgs) Handles MyBase.Load<br />
' load table from db<br />
Dim dt As DataTable = GetProductDataTable()
• C#<br />
End Sub<br />
' bind to grid<br />
_flex.Cols(0).Width = 20<br />
_flex.ShowCursor = True<br />
_flex.DataSource = dt<br />
' add unbound column<br />
Dim col As Column = _flex.Cols.Add()<br />
col.Name = col.Caption = "Unbound"<br />
' keep unbound values in a hashtable<br />
Dim _hash As New Hashtable()<br />
Private Sub _flex_GetUnboundValue(ByVal sender As Object, _<br />
ByVal e As C1.Win.<strong>C1FlexGrid</strong>.UnboundValueEventArgs) _<br />
Handles _flex.GetUnboundValue<br />
Dim drv As DataRowView = _flex.Rows(e.Row).DataSource<br />
e.Value = _hash(drv("ProductID"))<br />
End Sub<br />
GetUnboundValue-Ereignis · 257<br />
Private Sub _flex_SetUnboundValue(ByVal sender As Object, _<br />
ByVal e As C1.Win.<strong>C1FlexGrid</strong>.UnboundValueEventArgs) _<br />
Handles _flex.SetUnboundValue<br />
Dim drv As DataRowView = _flex.Rows(e.Row).DataSource<br />
_hash(drv("ProductID")) = e.Value<br />
End Sub<br />
End Sub<br />
private void Form1_Load(object sender, System.EventArgs e)<br />
{<br />
// load table from db<br />
DataTable dt = GetProductDataTable();<br />
}<br />
// bind to grid<br />
_flex.Cols[0].Width = 20;<br />
_flex.ShowCursor = true;<br />
_flex.DataSource = dt;<br />
// add unbound column<br />
Column col = _flex.Cols.Add();<br />
col.Name = col.Caption = "Unbound";<br />
// keep unbound values in a hashtable<br />
Hashtable _hash = new Hashtable();<br />
// get value from hashtable using ProductID as key<br />
private void _flex_GetUnboundValue(object sender,<br />
C1.Win.<strong>C1FlexGrid</strong>.UnboundValueEventArgs e)<br />
{<br />
DataRowView drv = (DataRowView)_flex.Rows[e.Row].DataSource;<br />
e.Value = _hash[drv["ProductID"]];<br />
}<br />
// store value in hashtable using ProductID as key<br />
private void _flex_SetUnboundValue(object sender,<br />
C1.Win.<strong>C1FlexGrid</strong>.UnboundValueEventArgs e)<br />
{<br />
DataRowView drv = (DataRowView)_flex.Rows[e.Row].DataSource;<br />
_hash[drv["ProductID"]] = e.Value;<br />
}
258 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
• Delphi<br />
TWinForm1 = class(TWinForm)<br />
private<br />
// keep unbound values in a hashtable<br />
Fhash: Hashtable;<br />
end;<br />
constructor TWinForm.Create;<br />
begin<br />
inherited Create;<br />
//<br />
// Required for Windows Form Designer support<br />
//<br />
InitializeComponent;<br />
//<br />
Fhash := Hashtable.Create;<br />
end;<br />
procedure TWinForm1.TWinForm_Load(sender: System.Object; e:<br />
System.EventArgs);<br />
var dt: DataTable;<br />
col: Column;<br />
begin<br />
// load table from db<br />
dt := GetProductDataTable;<br />
// bind to grid<br />
_flex.Cols[0].Width := 20;<br />
_flex.ShowCursor := true;<br />
_flex.DataSource := dt;<br />
// add unbound column<br />
col := _flex.Cols.Add;<br />
col.Name := ‘Unbound’;<br />
col.Caption := col.Name;<br />
end;<br />
// get value from hashtable using ProductID as key<br />
procedure TWinForm1._flex_GetUnboundValue(sender: System.Object; e:<br />
C1.Win.<strong>C1FlexGrid</strong>.UnboundValueEventArgs);<br />
var drv: DataRowView;<br />
begin<br />
drv := DataRowView(_flex.Rows[e.Row].DataSource);<br />
e.Value := Fhash[drv[‘ProductID’]];<br />
end;<br />
// store value in hashtable using ProductID as key<br />
procedure TWinForm1._flex_SetUnboundValue(sender: System.Object; e:<br />
C1.Win.<strong>C1FlexGrid</strong>.UnboundValueEventArgs);<br />
var drv: DataRowView;<br />
begin<br />
drv := DataRowView(_flex.Rows[e.Row].DataSource);<br />
Fhash[drv[‘ProductID’]] := e.Value;<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)
GridChanged-Ereignis<br />
Wird gestartet, wenn sich die Tabelle auf irgendeine Weise verändert.<br />
Syntax<br />
[VB]<br />
Public Event GridChanged(sender As Object, e As GridChangedEventArgs) As<br />
GridChangedEventHandler<br />
[C#]<br />
public event GridChangedEventHandler GridChanged<br />
[Delphi]<br />
property GridChanged: GridChangedEventHandler;<br />
Ereignisdaten<br />
GridChanged-Ereignis · 259<br />
Der Ereignisabwickler erhält ein Argument vom Typ GridChangedEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int r1, c1, r2, c2 Der Zellbereich, der von dem Ereignis betroffen ist. Der Wert beträgt -1 für<br />
Ereignisse, die die gesamte Tabelle betreffen.<br />
GridChangedTypeEnum<br />
GridChangedType<br />
Bemerkungen<br />
Der Typ der Änderung, der dieses Ereignis ausgelöst hat.<br />
Dieses Ereignis wird zusätzlich zu spezifischeren Ereignissen gestartet. Zum Beispiel, wenn ein Nutzer<br />
eine Spalte mit der Maus verschiebt, dann startet die Steuerung die Ereignisse BeforeDragColumn,<br />
GridChanged und AfterDragColumn.<br />
Das GridChanged-Ereignis stellt einen generischen, zentralisierten Abwickler für alle Typen der<br />
Tabellenereignisse zur Verfügung. Es enthält für die Ereignisse allerdings keine detaillierteren<br />
Argumente oder Optionen zum Abbruch von irgendwelchen Maßnahmen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
GridError-Ereignis<br />
Wird gestartet, wenn die Tabelle eine Fehlerbedingung aufspürt.<br />
Syntax<br />
[VB]<br />
Public Event GridError(sender As Object, e As GridErrorEventArgs) As GridErrorEventHandler
260 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
[C#]<br />
public event GridErrorEventHandler GridError<br />
[Delphi]<br />
property GridError: GridErrorEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ GridErrorEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int row, col Die Zelle, in der die Fehlerbedingung gefunden wurde.<br />
Exception exception Die Beschreibung des gefundenen Fehlers.<br />
bool handled Ob der Fehler behandelt wurde und die Tabelle ihn ignorieren kann. Wenn<br />
dieser Parameter auf FALSE steht, dann stellt die Tabelle den Einwand in<br />
den exception-Parameter.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
KeyDownEdit-Ereignis<br />
Wird gestartet, wenn der Nutzer eine Taste im Zellbearbeitungsmodus drückt.<br />
Syntax<br />
[VB]<br />
Public Event KeyDownEdit(sender As Object, e As KeyEditEventArgs) As KeyEditEventHandler<br />
[C#]<br />
public event KeyEditEventHandler KeyDownEdit<br />
[Delphi]<br />
property KeyDownEdit: KeyEditEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ KeyEditEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int Row Die Zeile, in der die aktuelle Zelle platziert ist.<br />
int Col Die Spalte, in der die aktuelle Zelle platziert ist.<br />
Keys KeyCode ASCII-Code für die gedrückte Taste.<br />
bool Shift Bestimmt, ob die Strg-Taste gedrückt war.
Bemerkungen<br />
KeyPressEdit-Ereignis · 261<br />
Dieses Ereignis ist dem standard KeyDown-Ereignis ähnlich, wird aber nur gestartet, wenn sich die<br />
Tabelle im Bearbeitungsmodus befindet.<br />
Der Editor besitzt drei Modi: Text, Auswahlkombinationsliste oder Auswahlliste. Der verwendete Modus<br />
wird durch die ComboList-Eigenschaften der Tabellen- und Spaltenobjekte festgelegt.<br />
Während der Bearbeitung mit dem Texteditor oder dem Auswahlkombinationsfeld, können Sie die<br />
Inhalte des Editors mit der Editor-Eigenschaft in der Editorsteuerung setzen und abfragen und diese in<br />
den richtigen Typ umwandeln. Zum Beispiel, der nachfolgende Quellcode ruft die Inhalte der Auswahl<br />
in der Editorsteuerung ab:<br />
• Visual Basic<br />
• C#<br />
Dim selText As String = ""<br />
Dim ctl As Control = flex.Editor<br />
If TypeOf ctl Is TextBox Then<br />
selText = CType(ctl, TextBox).SelectedText<br />
End If<br />
If TypeOf ctl Is ComboBox Then<br />
selText = CType(ctl, ComboBox).SelectedText<br />
End If<br />
string selText = "";<br />
Control ctl = flex.Editor<br />
if (ctl is TextBox) selText = ((TextBox)ctl).SelectedText;<br />
if (ctl is ComboBox) selText = ((ComboBox)ctl).SelectedText;<br />
• Delphi<br />
var<br />
ctl: Control;<br />
selText: string;<br />
begin<br />
selText := '';<br />
ctl := flex.Editor;<br />
if (ctl is TextBox) then selText := TextBox(ctl).SelectedText;<br />
if (ctl is ComboBox) then selText := ComboBox(ctl).SelectedText;<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
KeyPressEdit-Ereignis<br />
Wird gestartet, wenn der Nutzer eine Taste im Zellbearbeitungsmodus drückt.<br />
Syntax<br />
[VB]<br />
Public Event KeyPressEdit(sender As Object, e As KeyPressEditEventArgs) As<br />
KeyPressEditEventHandler
262 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
[C#]<br />
public event KeyPressEditEventHandler KeyPressEdit<br />
[Delphi]<br />
property KeyPressEdit: KeyPressEditEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ KeyPressEditEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int Row Die Zeile, in der die aktuelle Zelle platziert ist.<br />
int Col Die Spalte, in der die aktuelle Zelle platziert ist.<br />
char KeyChar Die Taste, die der Nutzer gedrückt hat.<br />
bool Handled Bestimmt, ob der Tastendruck verarbeitet wurde.<br />
Bemerkungen<br />
Dieses Ereignis ist dem standard KeyDown-Ereignis ähnlich, wird aber nur gestartet, wenn sich die<br />
Tabelle im Bearbeitungsmodus befindet.<br />
Der Editor besitzt drei Modi: Text, Auswahlkombinationsliste oder Auswahlliste. Der verwendete Modus<br />
wird durch die ComboList-Eigenschaften der Tabellen- und Spaltenobjekte festgelegt.<br />
Während der Bearbeitung mit dem Texteditor oder dem Auswahlkombinationsfeld, können Sie die<br />
Inhalte des Editors mit der Editor-Eigenschaft in der Editorsteuerung setzen und abfragen und diese in<br />
den richtigen Typ umwandeln. Zum Beispiel, der nachfolgende Quellcode ruft die Inhalte der Auswahl<br />
in der Editorsteuerung ab:<br />
• Visual Basic<br />
• C#<br />
Dim selText As String = ""<br />
Dim ctl As Control = flex.Editor<br />
If TypeOf ctl Is TextBox Then<br />
selText = CType(ctl, TextBox).SelectedText<br />
End If<br />
If TypeOf ctl Is ComboBox Then<br />
selText = CType(ctl, ComboBox).SelectedText<br />
End If<br />
string selText = "";<br />
Control ctl = flex.Editor<br />
if (ctl is TextBox) selText = ((TextBox)ctl).SelectedText;<br />
if (ctl is ComboBox) selText = ((ComboBox)ctl).SelectedText;<br />
• Delphi<br />
var<br />
ctl: Control;<br />
selText: string;<br />
begin
KeyUpEdit-Ereignis · 263<br />
selText := '';<br />
ctl := flex.Editor;<br />
if (ctl is TextBox) then selText := TextBox(ctl).SelectedText;<br />
if (ctl is ComboBox) then selText := ComboBox(ctl).SelectedText;<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
KeyUpEdit-Ereignis<br />
Wird gestartet, wenn der Nutzer eine Taste im Zellbearbeitungsmodus drückt.<br />
Syntax<br />
[VB]<br />
Public Event KeyUpEdit(sender As Object, e As KeyEditEventArgs) As KeyEditEventHandler<br />
[C#]<br />
public event KeyEditEventHandler KeyUpEdit<br />
[Delphi]<br />
property KeyUpEdit: KeyEditEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ KeyEditEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int Row Die Zeile, in der die aktuelle Zelle platziert ist.<br />
int Col Die Spalte, in der die aktuelle Zelle platziert ist.<br />
Keys KeyCode ASCII-Code für die gedrückte Taste.<br />
bool Shift Bestimmt, ob die Strg-Taste gedrückt war.<br />
Bemerkungen<br />
Dieses Ereignis ist dem Standard KeyDown-Ereignis ähnlich, wird aber nur gestartet, wenn sich die<br />
Tabelle im Bearbeitungsmodus befindet.<br />
Der Editor besitzt drei Modi: Text, Auswahlkombinationsliste oder Auswahlliste. Der verwendete Modus<br />
wird durch die ComboList-Eigenschaften der Tabellen- und Spaltenobjekte festgelegt.<br />
Während der Bearbeitung mit dem Texteditor oder dem Auswahlkombinationsfeld, können Sie die<br />
Inhalte des Editors mit der Editor-Eigenschaft in der Editorsteuerung setzen und abfragen, und diese in<br />
den richtigen Typ umwandeln. Zum Beispiel, der nachfolgende Quellcode ruft die Inhalte der Auswahl<br />
in der Editorsteuerung ab:<br />
• Visual Basic<br />
Dim selText As String = ""<br />
Dim ctl As Control = flex.Editor<br />
If TypeOf ctl Is TextBox Then
264 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
• C#<br />
selText = CType(ctl, TextBox).SelectedText<br />
End If<br />
If TypeOf ctl Is ComboBox Then<br />
selText = CType(ctl, ComboBox).SelectedText<br />
End If<br />
string selText = "";<br />
Control ctl = flex.Editor<br />
if (ctl is TextBox) selText = ((TextBox)ctl).SelectedText;<br />
if (ctl is ComboBox) selText = ((ComboBox)ctl).SelectedText;<br />
• Delphi<br />
var<br />
ctl: Control;<br />
selText: string;<br />
begin<br />
selText := '';<br />
ctl := flex.Editor;<br />
if ctl is TextBox then<br />
selText := TextBox(ctl).SelectedText;<br />
if ctl is ComboBox then<br />
selText := ComboBox(ctl).SelectedText;<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
LeaveCell-Ereignis<br />
Wird gestartet, bevor die aktuelle Zelle eine andere wird.<br />
Syntax<br />
[VB]<br />
Public Event LeaveCell(sender As Object, e As EventArgs) As EventHandler<br />
[C#]<br />
public event EventHandler LeaveCell<br />
[Delphi]<br />
property LeaveCell: EventHandler;<br />
Ereignisdaten<br />
Keine Parameter.<br />
Bemerkungen<br />
Dieses Ereignis wird gestartet, bevor der Cursor die aktuelle Zelle verlässt, entweder durch die<br />
Maus/Tastatur, oder wenn die aktuelle Auswahl durch Programmcode verändert wurde.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)
MouseHoverCell-Ereignis<br />
Wird gestartet, wenn der Mauszeiger über eine Zelle fährt.<br />
Syntax<br />
[VB]<br />
Public Event MouseHoverCell(ByVal sender As Object, ByVal e As System.EventArgs) As<br />
System.EventHandler<br />
[C#]<br />
public event EventHandler MouseHoverCell<br />
[Delphi]<br />
property MouseHoverCell: EventHandler;<br />
Ereignisdaten<br />
Keine Parameter.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse<br />
OwnerDrawCell-Ereignis<br />
MouseHoverCell-Ereignis · 265<br />
Wird gestartet, bevor die Tabelle eine Zelle zeichnet und die DrawMode-Eigenschaft auf OwnerDraw<br />
steht.<br />
Syntax<br />
[VB]<br />
Public Event OwnerDrawCell(sender As Object, e As OwnerDrawCellEventArgs) As<br />
OwnerDrawCellEventHandler<br />
[C#]<br />
public event OwnerDrawCellEventHandler OwnerDrawCell<br />
[Delphi]<br />
property OwnerDrawCell: OwnerDrawCellEventHandler;<br />
Event Data<br />
Der Ereignisabwickler erhält ein Argument vom Typ OwnerDrawCellEventArgs, welches die mit<br />
diesem Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int Row, Col Ermittelt die Koordinaten der zu zeichnenden Zelle.<br />
Graphics Graphics Ermittelt die zu verwendende grafische Oberfläche, um die Zelle zu<br />
zeichnen.<br />
Rectangle Bounds Ermittelt das Rechteck, wo die Zelle gezeichnet wird.
266 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Eigenschaft Beschreibung<br />
string Text Ermittelt oder legt den Text fest, der in der Zelle angezeigt wird.<br />
Image Image Ermittelt oder legt die Grafik fest, die in der Zelle angezeigt wird.<br />
CellStyle Style Legt das zu verwendende CellStyle-Objekt fest, mit dem die Zelle<br />
gezeichnet wird.<br />
void DrawCell(DrawCellFlags flags) Veranlasst die Tabelle, Teile der Zelle zu zeichnen (Hintergrund,<br />
Vordergrund, Rahmen, usw.).<br />
void DrawCell() Veranlasst die Tabelle, die gesamte Zelle zu zeichnen.<br />
bool Handled Ermittelt oder legt fest, ob das Ereignis das Zeichnen der Zelle<br />
abgeschlossen hat.<br />
bool Measuring Ermittelt einen Wert, der festlegt, ob das Ereignis nur aufgerufen wurde,<br />
um eine Zelle auszumessen. Dies geschieht während die Größe von<br />
Zeilen und Spalten automatisch angepasst wird.<br />
Bemerkungen<br />
Das OwnerDrawCell-Ereignis wird nur gestartet, wenn die DrawMode-Eigenschaft auf OwnerDraw<br />
steht.<br />
Sie können dieses Ereignis verwenden, um das Format einer jeden Zelle in der Tabelle anzupassen. Das<br />
Ereignis stellt drei Haupttypen der Anpassung zur Verfügung:<br />
1. Ändert die Text und Image-Parameter, um die Werte zu verändern, die von der Tabelle angezeigt<br />
werden. Sie können diesen Typ der Anpassung verwenden, um zum Beispiel Passwörter durch<br />
Sternzeichen („*“) zu ersetzen.<br />
2. Ändert die Style-Eigenschaft, um die Zelle in einem anderen, als dem von der Tabelle festgelgtem<br />
Standardformat, anzuzeigen. Sie können diesen Typ der Anpassung verwenden, um zum<br />
Beispiel bedingte Formatierung zur Verfügung zu stellen.<br />
3. Verwenden Sie die Graphics und Bounds-Parameter und zeichnen Sie die Zelle selbst. Wenn<br />
Zellen auf diesem Weg gezeichnet werden, dann können Sie die DrawCell-Member aufrufen, um<br />
die Tabelle zu zwingen, einige Teile der Zelle zu zeichnen, während ihr Quellcode andere Teile<br />
zeichnet. Zum Beispiel, der nachfolgende Quellcode zeichnet eine Zelle mit einem Farbübergang<br />
als Hintergrund:<br />
• Visual Basic<br />
' use owner-draw to add gradients<br />
fg.DrawMode = DrawModeEnum.OwnerDraw<br />
Private Sub fg_OwnerDrawCell(ByVal sender As Object, _<br />
ByVal e As OwnerDrawCellEventArgs) Handles fg.OwnerDrawCell<br />
' draw selected cell background using gradient brush<br />
If fg.Selection.Contains(e.Row, e.Col) Then<br />
e.Graphics.FillRectangle(m_GradientBrush, e.Bounds) ' draw<br />
background<br />
e.DrawCell(DrawCellFlags.Content) ' let the grid draw the<br />
content<br />
e.Handled = True ' we're done drawing this cell<br />
End If
• C#<br />
End Sub<br />
// use owner-draw to add gradients<br />
fg.DrawMode = DrawModeEnum.OwnerDraw;<br />
private void fg_OwnerDrawCell( object sender,<br />
OwnerDrawCellEventArgs e) fg.OwnerDrawCell {<br />
OwnerDrawCell-Ereignis · 267<br />
// draw selected cell background using gradient brush<br />
if ( fg.Selection.Contains(e.Row, e.Col) ) {<br />
e.Graphics.FillRectangle(m_GradientBrush, e.Bounds); // draw<br />
background<br />
e.DrawCell(DrawCellFlags.Content); // let the grid draw the<br />
content<br />
e.Handled = true; // we're done drawing this cell<br />
}<br />
}<br />
• Delphi<br />
' use owner-draw to add gradients<br />
fg.DrawMode := DrawModeEnum.OwnerDraw;<br />
procedure fg_OwnerDrawCell(sender: System.Object;<br />
e: OwnerDrawCellEventArgs);<br />
begin<br />
// draw selected cell background using gradient brush<br />
If fg.Selection.Contains(e.Row, e.Col) Then<br />
begin<br />
e.Graphics.FillRectangle(m_GradientBrush, e.Bounds); // draw<br />
background<br />
e.DrawCell(DrawCellFlags.Content); // let the grid draw the<br />
content<br />
e.Handled := True; // we're done drawing this cell<br />
end;<br />
end;<br />
Das OwnerDrawCell-Ereignis wird auch gestartet, wenn die Tabelle die Größen der Zeilen und Spalten<br />
automatisch anpasst (Siehe AutoSizeRows- und AutoSizeCols-Methoden). Dies wird getan, weil die<br />
Tabelle die Zellen mit den selben text-, image- und style-Parametern ausmessen muss, die auch dazu<br />
verwendet werden, die Zelle zu rendern. In diesen Fällen ist der Measuring-Parameter auf TRUE gesetzt<br />
und das Bounds-Rechteck ist leer.<br />
Beispiel<br />
Dieses Beispiel zeichnet die Zellen wie üblich, und markiert die ersten zwei Zeichen in einer Zelle. Der<br />
Quellcode beginnt damit, die Zeichenkette auszumessen und berücksichtigt dabei den Zellrahmen. Dann<br />
wird die DrawCell-Methode verwendet, um den Hintergrund der Zelle, ein markiertes Rechteck und<br />
schlussendlich den Zellinhalt und den Rahmen zu zeichnen:<br />
• Visual Basic<br />
Private Sub _flex_OwnerDrawCell(sender As Object, e As<br />
OwnerDrawCellEventArgs)<br />
' highlight all but the first two characters<br />
Dim txt As String = _flex.GetDataDisplay(e.Row, e.Col)<br />
If txt.Length < 2 Then<br />
Return<br />
End If<br />
txt = txt.Substring(2)
268 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
• C#<br />
' measure the width of the highlight<br />
Dim g As Graphics = e.Graphics<br />
Dim wid As Integer = CInt(g.MeasureString(txt, e.Style.Font).Width)<br />
wid += e.Style.Margins.Right<br />
wid += e.Style.Border.Width - 1<br />
' build the highlight rect<br />
Dim rc As Rectangle = e.Bounds<br />
rc.X = rc.Right - wid<br />
rc.Width = wid<br />
' draw background, highlight, draw content<br />
e.DrawCell(DrawCellFlags.Background)<br />
g.FillRectangle(Brushes.LightYellow, rc)<br />
e.DrawCell((DrawCellFlags.Border Or DrawCellFlags.Content))<br />
End Sub '_flex_OwnerDrawCell<br />
private void _flex_OwnerDrawCell(object sender, OwnerDrawCellEventArgs<br />
e)<br />
{<br />
// highlight all but the first two characters<br />
string txt = _flex.GetDataDisplay(e.Row, e.Col);<br />
if (txt.Length < 2) return;<br />
txt = txt.Substring(2);<br />
}<br />
• Delphi<br />
// measure the width of the highlight<br />
Graphics g = e.Graphics;<br />
int wid = (int)g.MeasureString(txt, e.Style.Font).Width;<br />
wid += e.Style.Margins.Right;<br />
wid += e.Style.Border.Width - 1;<br />
// build the highlight rect<br />
Rectangle rc = e.Bounds;<br />
rc.X = rc.Right - wid;<br />
rc.Width = wid;<br />
// draw background, highlight, draw content<br />
e.DrawCell(DrawCellFlags.Background);<br />
g.FillRectangle(Brushes.LightYellow, rc);<br />
e.DrawCell(DrawCellFlags.Border | DrawCellFlags.Content);<br />
procedure_flex_OwnerDrawCell(sender: System.Object; e:<br />
OwnerDrawCellEventArgs)<br />
var<br />
txt: string;<br />
g: Graphics;<br />
wid: Integer;<br />
rc: Rectangle;<br />
begin<br />
// highlight all but the first two characters<br />
txt := _flex.GetDataDisplay(e.Row, e.Col);<br />
If txt.Length < 2 Then<br />
exit;<br />
txt := txt.Substring(2);<br />
// measure the width of the highlight<br />
g := e.Graphics;<br />
wid := Round(g.MeasureString(txt, e.Style.Font).Width);<br />
wid := wid + e.Style.Margins.Right;
wid := wid + e.Style.Border.Width – 1;<br />
// build the highlight rect<br />
rc := e.Bounds;<br />
rc.X := rc.Right – wid;<br />
rc.Width := wid;<br />
// draw background, highlight, draw content<br />
e.DrawCell(DrawCellFlags.Background);<br />
g.FillRectangle(Brushes.LightYellow, rc);<br />
e.DrawCell(DrawCellFlags.Border Or DrawCellFlags.Content);<br />
end; //_flex_OwnerDrawCell<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
PrintPage-Ereignis<br />
Wird gestartet, wenn die Tabelle den Druckvorgang für eine Seite beendet hat.<br />
Syntax<br />
[VB]<br />
PrintPage-Ereignis · 269<br />
Public Event PrintPage(sender As Object, e As PrintPageEventArgs) As PrintPageEventHandler<br />
[C#]<br />
public event PrintPageEventHandler PrintPage<br />
[Delphi]<br />
property PrintPage: PrintPageEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ PrintEventHandler, welcher im<br />
System.Drawing.Printing-Namensbereich definiert ist.<br />
Bemerkungen<br />
Verwenden Sie die PrintGrid-Methode, um die Tabelle zu drucken und um den Dokumentennamen,<br />
allgemeine Druckoptionen, Kopf- und Fußzeilen festzulegen. Verwenden Sie hingegen die<br />
PrintParameters-Eigenschaft um weniger allgemeine Druckoptionen, wie z.B. Kopf- und<br />
Fußzeilenschriftart, Seitenränder und Ausrichtung, festzulegen.<br />
Mit diesem Ereignis können Sie benutzerdefinierte Grafiken zu einer gedruckten Seite hinzufügen oder<br />
den Druckprozess abbrechen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
RowColChange-Ereignis<br />
Wird gestartet, bevor die aktuelle Zelle (Row, Col) eine andere wird.
270 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Syntax<br />
[VB]<br />
Public Event RowColChange(sender As Object, e As EventArgs) As EventHandler<br />
[C#]<br />
public event EventHandler RowColChange<br />
[Delphi]<br />
property RowColChange: EventHandler;<br />
Ereignisdaten<br />
Keine Parameter<br />
Bemerkungen<br />
RowColChange wird nur gestartet, wenn sich die Row- und Col-Eigenschaften, entweder durch den<br />
Nutzer mit Maus/Tastatur, oder durch Programmcode, ändern. Es wird nicht gestartet, wenn sich zwar<br />
die Auswahl (RowSel- oder ColSel-Eigenschaften) ändert, die aktive Zelle (Row, Col) aber gleich bleibt.<br />
In diesem Fall wird stattdessen das SelChange-Ereignis gestartet.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
SelChange-Ereignis<br />
Wird gestartet, nachdem sich die Auswahl (RowSel, ColSel) geändert hat.<br />
Syntax<br />
[VB]<br />
Public Event SelChange(sender As Object, e As EventArgs) As EventHandler<br />
[C#]<br />
public event EventHandler SelChange<br />
[Delphi]<br />
property SelChange: EventHandler;<br />
Ereignisdaten<br />
Keine Parameter<br />
Bemerkungen<br />
SelChange wird nur gestartet, wenn sich die Row-, Col-, RowSel- oder ColSel-Eigenschaften, entweder<br />
durch den Nutzer mit Maus/Tastatur, oder durch Programmcode, ändern. Es wird auch gestartet, wenn<br />
der Nutzer die Auswahl mit der Maus erweitert.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)
SetUnboundValue-Ereignis<br />
SetUnboundValue-Ereignis · 271<br />
Wird gestartet, wenn die Tabelle gebunden ist und einen Wert in einer ungebundenen Spalte setzt.<br />
Syntax<br />
[VB]<br />
Public Event SetUnboundValue(sender As Object, e As EventArgs) As UnboundValueEventHandler<br />
[C#]<br />
public event UnboundValueEventHandler SetUnboundValue<br />
[Delphi]<br />
property SetUnboundValue: UnboundValueEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ UnboundValueEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int Row, Col Die ungebundene Zelle, die den Wert enthält.<br />
object Value<br />
Bemerkungen<br />
Der Wert der ungebundenen Zelle. Der Ereignisabwickler sollte diesen<br />
Wert der Zelle zuordnen.<br />
Dieses Ereignis wird nur im gebundenen Modus gestartet, wenn die Tabelle ungebundene Spalten<br />
enthält. Ungebundene Spalten verknüpfen ihre Werte nicht mit der Datenquelle. Sie können, auf<br />
gebundene Spalten basierende Informationen berechnen oder andere Information enthalten, die in der<br />
Tabelle durch die Anwendung zur Verfügung gestellt werden.<br />
In den meisten Fällen können ungebundene Spalten nur gelesen werden, so dass Sie dieses Ereignis nicht<br />
abfangen müssen. Wenn dennoch ein Wert entweder durch Bearbeitung oder durch Quellcode in einer<br />
ungebundenen Zelle steht, dann startet die Tabelle dieses Ereignis, damit die Anwendung den Wert mit<br />
dem entsprechendem Mechanismus speichern kann.<br />
Schauen Sie im GetUnboundValue-Ereignis für ein Beispiel nach.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
SetupEditor-Ereignis<br />
Wird gestartet, nachdem der integrierte Editor initialisiert wurde, aber bevor dieser angezeigt wird.<br />
Syntax<br />
[VB]<br />
Public Event SetupEditor(sender As Object, e As RowColEventArgs) As RowColEventHandler
272 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
[C#]<br />
public event RowColEventHandler SetupEditor<br />
[Delphi]<br />
property SetupEditor: RowColEventHandler;<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int row, col Die Koordinaten der Zelle, die gleich bearbeitet wird.<br />
Bemerkungen<br />
Die Tabelle initialisiert den Editor je nach Format der Zelle, die bearbeitet werden soll. Standardmäßig<br />
hat der Editor die gleiche Schriftart, Hintergrundfarbe, Ausrichtung, usw. wie die entsprechende Zelle.<br />
Sie können das SetupEditor-Ereignis verwenden, um dieses Verhalten zu ändern und das Aussehen des<br />
Editors anzupassen.<br />
Beispiel<br />
Der nachfolgende Quellcode formatiert die Schrift des Editors fett, fügt einen gelben Hintergrund ein<br />
und legt die maximale Länge der Eingabe auf vier Zeichen fest:<br />
• Visual Basic<br />
• C#<br />
Private Sub flex_SetupEditor(sender As Object, e As RowColEventArgs)<br />
Dim ctl As Control = flex.Editor<br />
ctl.Font = New Font(ctl.Font, FontStyle.Bold)<br />
ctl.BackColor = Color.Yellow<br />
If TypeOf ctl Is TextBox Then<br />
CType(ctl, TextBox).MaxLength = 4<br />
End If<br />
End Sub 'flex_SetupEditor<br />
private void flex_SetupEditor(object sender, RowColEventArgs e)<br />
{<br />
Control ctl = flex.Editor;<br />
ctl.Font = new Font(ctl.Font, FontStyle.Bold);<br />
ctl.BackColor = Color.Yellow;<br />
if (ctl is TextBox) ((TextBox)ctl).MaxLength = 4;<br />
}<br />
• Delphi<br />
procedure Class1.flex_SetupEditor(sender: System.Object; e:<br />
RowColEventArgs);<br />
var<br />
ctl: Control;<br />
begin<br />
ctl := flex.Editor;<br />
ctl.Font := Font.Create(ctl.Font, FontStyle.Bold);<br />
ctl.BackColor := Color.Yellow;
if (ctl is TextBox) then TextBox(tl).MaxLength := 4;<br />
end;<br />
Dies ist ein etwas komplizierteres Beispiel, welches das SetupEditor-Ereignis verwendet, um<br />
Ereignisabwickler für den Editor zu installieren:<br />
• Visual Basic<br />
• C#<br />
SetupEditor-Ereignis · 273<br />
' ** initialize and hook up event handlers for the grid editors<br />
Private Sub flex_SetupEditor(sender As Object, e As RowColEventArgs)<br />
' set up the grid's combo box<br />
Dim cb As ComboBox = flex.Editor '<br />
If Not (cb Is Nothing) Then<br />
' make this a real combo, even if we're using a DataMap<br />
cb.DropDownStyle = ComboBoxStyle.DropDown<br />
' hook up combo event<br />
cb.SelectedIndexChanged -= New<br />
System.EventHandler(fe_SelectedValueChanged)<br />
AddHandler cb.SelectedIndexChanged, AddressOf<br />
fe_SelectedValueChanged<br />
' hook up textbox event<br />
cb.TextChanged -= New<br />
System.EventHandler(fe_SelectedValueChanged)<br />
AddHandler cb.TextChanged, AddressOf fe_SelectedValueChanged<br />
End If<br />
' set up the grid's text box<br />
Dim tb As TextBox = flex.Editor '<br />
If Not (tb Is Nothing) Then<br />
tb.TextChanged -= New<br />
System.EventHandler(fe_SelectedValueChanged)<br />
AddHandler tb.TextChanged, AddressOf fe_SelectedValueChanged<br />
End If<br />
End Sub 'flex_SetupEditor<br />
' ** event handlers for the grid editors<br />
Private Sub fe_SelectedValueChanged(sender As Object, e As<br />
System.EventArgs)<br />
Console.WriteLine(("editor value changed to " + _flex.Editor.Text))<br />
End Sub 'fe_SelectedValueChanged<br />
// ** initialize and hook up event handlers for the grid editors<br />
private void flex_SetupEditor(object sender, RowColEventArgs e)<br />
{<br />
// set up the grid's combo box<br />
ComboBox cb = flex.Editor as ComboBox;<br />
if (cb != null)<br />
{<br />
// make this a real combo, even if we're using a DataMap<br />
cb.DropDownStyle = ComboBoxStyle.DropDown;<br />
// hook up combo event<br />
cb.SelectedIndexChanged -= new<br />
System.EventHandler(fe_SelectedValueChanged);<br />
cb.SelectedIndexChanged += new<br />
System.EventHandler(fe_SelectedValueChanged);<br />
// hook up textbox event<br />
cb.TextChanged -= new System.EventHandler(fe_SelectedValueChanged);<br />
cb.TextChanged += new System.EventHandler(fe_SelectedValueChanged);
274 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
}<br />
// set up the grid's text box<br />
TextBox tb = flex.Editor as TextBox;<br />
if (tb != null)<br />
{<br />
tb.TextChanged -= new System.EventHandler(fe_SelectedValueChanged);<br />
tb.TextChanged += new System.EventHandler(fe_SelectedValueChanged);<br />
}<br />
}<br />
// ** event handlers for the grid editors<br />
private void fe_SelectedValueChanged(object sender, System.EventArgs e)<br />
{<br />
Console.WriteLine("editor value changed to " + _flex.Editor.Text);<br />
}<br />
• Delphi<br />
// ** initialize and hook up event handlers for the grid editors<br />
procedure flex_SetupEditor(sender: System.Object; e: RowColEventArgs);<br />
var<br />
cb: ComboBox;<br />
tb: TextBox;<br />
begin<br />
// set up the grid's combo box<br />
if cb Is ComboBox then<br />
begin<br />
cb := ComboBox(flex.Editor);<br />
// make this a real combo, even if we're using a DataMap<br />
cb.DropDownStyle := ComboBoxStyle.DropDown;<br />
// hook up combo event<br />
Exclude(cb.SelectedIndexChanged, fe_SelectedValueChanged);<br />
Include(cb.SelectedIndexChanged, fe_SelectedValueChanged);<br />
// hook up textbox event<br />
Exclude(cb.TextChanged, fe_SelectedValueChanged);<br />
Include(cb.TextChanged, fe_SelectedValueChanged);<br />
End;<br />
// set up the grid's text box<br />
if tb Is TextBox then<br />
begin<br />
tb := TextBox(flex.Editor);<br />
Exclude(tb.TextChanged, fe_SelectedValueChanged);<br />
Include(tb.TextChanged, fe_SelectedValueChanged);<br />
end;<br />
end; // flex_SetupEditor<br />
// ** event handlers for the grid editors<br />
procedure fe_SelectedValueChanged(sender: System.Object; e:<br />
System.EventArgs);<br />
Console.WriteLine('editor value changed to ' + _flex.Editor.Text);<br />
end; // fe_SelectedValueChanged<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
StartEdit-Ereignis<br />
Wird gestartet, wenn die Steuerung in den Zellbearbeitungsmodus übergeht (nach BeforeEdit).
Syntax<br />
[VB]<br />
Public Event StartEdit(sender As Object, e As RowColEventArgs) As RowColEventHandler<br />
[C#]<br />
public event RowColEventHandler StartEdit<br />
[Delphi]<br />
property StartEdit: RowColEventHandler;<br />
Ereignisdaten<br />
ValidateEdit-Ereignis · 275<br />
Der Ereignisabwickler erhält ein Argument vom Typ RowColEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int row, col Die Koordinaten der Zelle, die gleich bearbeitet wird.<br />
bool Cancel Legt fest, ob die Bearbeitung abgebrochen wird.<br />
Bemerkungen<br />
Dieses Ereignis wird gestartet, bevor die Steuerung in den Bearbeitungsmodus versetzt wird. Sie können<br />
die Bearbeitung verhindern, indem Sie den Cancel-Parameter auf TRUE setzen, oder mit der ComboList-<br />
Eigenschaft eine Auswahlliste an möglichen Elementen oder mit der EditMask-Eigenschaft eine<br />
Eingabemaske zur Verfügung stellen.<br />
Wenn die Auswahl oder die Eingabemaske für die gesamte Spalte gleich ist, dann können Sie auch die<br />
entsprechenden Eigenschaften (AllowEdit, ComboList und EditMask) des Column-Objekts setzen, so<br />
dass Sie das StartEdit-Ereignis nicht abfangen müssen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
ValidateEdit-Ereignis<br />
Wird gestartet, wenn die Steuerung den Zellbearbeitungsmodus verlässt.<br />
Syntax<br />
[VB]<br />
Public Event ValidateEdit(sender As Object, e As ValidateEditEventArgs) As ValidateEditEventHandler<br />
[C#]<br />
public event ValidateEditEventHandler ValidateEdit<br />
[Delphi]<br />
property ValidateEdit: ValidateEditEventHandler;
276 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Ereignisdaten<br />
Der Ereignisabwickler erhält ein Argument vom Typ ValidateEditEventArgs, welches die mit diesem<br />
Ereignis zusammenhängenden Daten enthält. Die folgenden Eigenschaften stellen spezielle<br />
Informationen für dieses Ereignis zur Verfügung.<br />
Eigenschaft Beschreibung<br />
int row, col Die Koordinaten der Zelle, die bearbeitet wird.<br />
CheckEnum<br />
Checkbox<br />
bool Cancel<br />
Bemerkungen<br />
Wenn die Zelle ein Kontrollkästchen beinhaltet, dann enthält dieser Parameter<br />
dessen Zustand, welcher der Zelle zugeordnet wird. Wenn die Zelle kein<br />
Kontrollkästchen enthält, dann steht dieser Parameter auf CheckEnum.None.<br />
Setzen Sie diesen Parameter auf TRUE, um die Bearbeitungen abzubrechen,<br />
wenn der Wert im Editor für die Zelle ungültig ist.<br />
Das ValidateEdit-Ereignis wird gestartet, bevor die Änderungen in der Zelle gespeichert werden. Der<br />
Ereigniscode sollte den Wert der Editor.Text-Eigenschaft überprüfen. Wenn dieser Wert ungültig ist,<br />
dann muss die Cancel-Parameter auf TRUE gesetzt werden, so dass die Tabelle im Bearbeitungsmodus<br />
verweilt, bis der Nutzer einen gültigen Wert eingegeben hat.<br />
Zum Beispiel der nachfolgende Quellcode prüft die Eingabe in einer Währungsspalte um sicherzustellen,<br />
dass die eingegebenen Werte zwischen 1.000 und 10.000 liegen:<br />
• Visual Basic<br />
• C#<br />
Private Sub fg_ValidateEdit(ByVal sender As Object, _<br />
ByVal e As ValidateEditEventArgs) Handles fg.ValidateEdit<br />
' validate amounts<br />
If fg.Cols(e.Col).DataType Is GetType(Decimal) Then<br />
10,000")<br />
Try<br />
End If<br />
End Sub<br />
Dim dec As Decimal = Decimal.Parse(fg.Editor.Text())<br />
If dec < 1000 Or dec > 10000 Then<br />
MessageBox.Show("Value must be between 1,000 and<br />
e.Cancel = True<br />
End If<br />
Catch<br />
MessageBox.Show("Value not recognized as a Currency")<br />
e.Cancel = True<br />
End Try<br />
private void fg_ValidateEdit( object sender, ValidateEditEventArgs e)<br />
{<br />
// validate amounts<br />
if ( fg.Cols[e.Col].DataType == typeof(Decimal) ) {<br />
try {<br />
Decimal dec = Decimal.Parse(fg.Editor.Text());<br />
if ( dec < 1000 || dec > 10000 ) {
BeforeMouseDownEventHandler-Delegierer · 277<br />
MessageBox.Show("value must be between 1,000 and<br />
10,000");<br />
e.Cancel = true;<br />
}<br />
} catch {<br />
MessageBox.Show("value not recognized as a Currency");<br />
e.Cancel = true;<br />
}<br />
}<br />
}<br />
• Delphi<br />
procedure fg_ValidateEdit(sender: System.Object;<br />
e: ValidateEditEventArgs);<br />
var<br />
dec: Decimal;<br />
begin<br />
// validate amounts<br />
if fg.Cols(e.Col).DataType Is Decimal then<br />
Try<br />
dec := System.Decimal.Parse(fg.Editor.Text());<br />
If (dec < 1000) Or (dec > 10000) Then<br />
begin<br />
MessageBox.Show('Value must be between 1,000 and 10,000');<br />
e.Cancel := True;<br />
end;<br />
except<br />
MessageBox.Show('Value not recognized as a Currency');<br />
e.Cancel = True;<br />
end;<br />
end;<br />
Wenn Sie Zeichen überprüfen wollen, während diese im Editor eingegeben werden, dann müssen Sie die<br />
KeyPressEdit- oder die ChangeEdit-Ereignisse verwenden. Für weitere Einzelheiten über<br />
Zellbearbeitung, schauen Sie unter „Zellen bearbeiten“ (Seite 37 ) nach.<br />
<strong>C1FlexGrid</strong>-Ereignisabwickler<br />
BeforeMouseDownEventHandler-Delegierer<br />
Syntax<br />
[VB]<br />
Public Delegate Sub BeforeMouseDownEventHandler (object sender, BeforeMouseDownEventArgs e)<br />
[C#]<br />
public delegate BeforeMouseDownEventHandler : MulticastDelegate<br />
[Delphi]<br />
type BeforeMouseDownEventHandler = procedure(sender: System.Object, e:<br />
BeforeMouseDownEventArgs) of object;
278 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Argumente<br />
Argument Beschreibung<br />
sender Der Auslöser des Ereignisses.<br />
e Ein BeforeMouseDownEventArgs-Objekt, das die Ereignisdaten beinhaltet.<br />
Schauen Sie ferner unter<br />
BeforeMouseDown-Ereignis (Seite 239)<br />
DragRowColEventHandler-Delegierer<br />
Syntax<br />
[VB]<br />
Public Delegate Sub DragRowColEventHandler (object sender, DragRowColEventArgs e)<br />
[C#]<br />
public sealed delegate DragRowColEventHandler : System.MulticastDelegate<br />
[Delphi]<br />
type DragRowColEventHandler = procedure(sender: System.Object, e: DragRowColEventArgs) of<br />
object;<br />
Argumente<br />
Argument Beschreibung<br />
sender Der Auslöser des Ereignisses.<br />
e Ein DragRowColEventArgs-Objekt, das die Ereignisdaten beinhaltet.<br />
Schauen Sie ferner unter<br />
AfterDragColumn-Ereignis (Seite 220)<br />
AfterDragRow-Ereignis (Seite 221)<br />
BeforeDragColumn-Ereignis (Seite 234)<br />
BeforeDragRow-Ereignis (Seite 235)<br />
GridChangedEventHandler-Delegierer<br />
Syntax<br />
[VB]<br />
Public Delegate Sub GridChangedEventHander (object sender, GridChangedEventArgs e)
[C#]<br />
public sealed delegate GridChangedEventHandler : System.MulticastDelegate<br />
[Delphi]<br />
GridErrorEventHandler-Delegierer · 279<br />
type GridChangedEventHander = procedure(sender: System.Object, e: GridChangedEventArgs) of<br />
object;<br />
Argumente<br />
Argument Beschreibung<br />
sender Der Auslöser des Ereignisses.<br />
e Ein GridChangedEventArgs-Objekt, das die Ereignisdaten beinhaltet.<br />
Schauen Sie ferner unter<br />
GridChanged-Ereignis (Seite 259)<br />
GridErrorEventHandler-Delegierer<br />
Syntax<br />
[VB]<br />
Public Delegate Sub GridErrorEventHander (object sender, GridErrorEventArgs e)<br />
[C#]<br />
public sealed delegate GridErrorEventHandler : System.MulticastDelegate<br />
[Delphi]<br />
type GridErrorEventHandler = procedure(sender: System.Object, e: GridErrorEventArgs) of object;<br />
Argumente<br />
Argument Beschreibung<br />
sender Der Auslöser des Ereignisses.<br />
e Ein GridErrorEventArgs-Objekt, das die Ereignisdaten beinhaltet.<br />
Schauen Sie ferner unter<br />
GridError-Ereignis (Seite 259)<br />
KeyEditEventHandler-Delegierer<br />
Syntax<br />
[VB]<br />
Public Delegate Sub KeyEditEventHandler (object sender, KeyEditEventHandler e)
<strong>28</strong>0 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
[C#]<br />
public sealed delegate KeyEditEventHandler : System.MulticastDelegate<br />
[Delphi]<br />
type KeyEditEventHandler = procedure(sender: System.Object, e: KeyEditEventHandler) of object;<br />
Argumente<br />
Argument Beschreibung<br />
sender Der Auslöser des Ereignisses.<br />
e Ein KeyEditEventArgs-Objekt, das die Ereignisdaten beinhaltet.<br />
Schauen Sie ferner unter<br />
KeyDownEdit-Ereignis (Seite 260)<br />
KeyUpEdit-Ereignis (Seite 263)<br />
KeyPressEditEventHandler-Delegierer<br />
Syntax<br />
[VB]<br />
Public Delegate Sub KeyPressEditEventHandler (object sender, KeyPressEditEventArgs e)<br />
[C#]<br />
public sealed delegate KeyPressEditEventHandler : System.MulticastDelegate<br />
[Delphi]<br />
type KeyPressEditEventHandler = procedure(sender: System.Object, e: KeyPressEditEventArgs) of<br />
object;<br />
Argumente<br />
Argument Beschreibung<br />
sender Der Auslöser des Ereignisses.<br />
e Ein KeyPressEditEventArgs-Objekt, das die Ereignisdaten beinhaltet.<br />
Schauen Sie ferner unter<br />
KeyPressEdit-Ereignis (Seite 261)
OwnerDrawCellEventHandler-Delegierer<br />
Syntax<br />
[VB]<br />
OwnerDrawCellEventHandler-Delegierer · <strong>28</strong>1<br />
Public Delegate Sub OwnerDrawCellEventHandler (object sender, OwnerDrawCellEventArgs e)<br />
[C#]<br />
public sealed delegate OwnerDrawCellEventHandler : System.MulticastDelegate<br />
[Delphi]<br />
type OwnerDrawCellEventHandler = procedure(sender: System.Object, e: OwnerDrawCellEventArgs)<br />
of object;<br />
Argumente<br />
Argument Beschreibung<br />
sender Der Auslöser des Ereignisses.<br />
e Ein OwnerDrawCellEventArgs-Objekt, das die Ereignisdaten beinhaltet.<br />
Schauen Sie ferner unter<br />
OwnerDrawCell-Ereignis (Seite 265)<br />
PrintEventHandler-Delegierer<br />
Syntax<br />
[VB]<br />
Public Delegate Sub PrintEventHandler (object sender, PrintEventArgs e)<br />
[C#]<br />
public sealed delegate PrintEventHandler : System.MulticastDelegate<br />
[Delphi]<br />
type PrintEventHandler = procedure(sender: System.Object, e: PrintEventArgs) of object;<br />
Argumente<br />
Argument Beschreibung<br />
sender Der Auslöser des Ereignisses.<br />
e Ein PrintEventArgs-Objekt, das die Ereignisdaten beinhaltet.<br />
Schauen Sie ferner unter<br />
BeginPrint-Ereignis (Seite 247)
<strong>28</strong>2 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
EndPrint-Ereignis (Seite 253)<br />
PrintPageEventHandler-Delegierer<br />
Syntax<br />
[VB]<br />
Public Delegate Sub PrintPageEventHandler (object sender, PrintPageEventArgs e)<br />
[C#]<br />
public sealed delegate PrintPageEventHandler : System.MulticastDelegate<br />
[Delphi]<br />
type PrintPageEventHandler = procedure(sender: System.Object, e: PrintPageEventArgs) of object;<br />
Argumente<br />
Argument Beschreibung<br />
sender Der Auslöser des Ereignisses.<br />
e Ein PrintPageEventArgs-Objekt, das die Ereignisdaten beinhaltet.<br />
Schauen Sie ferner unter<br />
PrintPage-Ereignis (Seite 269)<br />
RangeEventHandler-Delegierer<br />
Syntax<br />
[VB]<br />
Public Delegate Sub RangeEventHandler (object sender, RangeEventArgs e)<br />
[C#]<br />
public sealed delegate RangeEventHandler : System.MulticastDelegate<br />
[Delphi]<br />
type RangeEventHandler = procedure(sender: System.Object, e: RangeEventArgs) of object;<br />
Argumente<br />
Argument Beschreibung<br />
sender Der Auslöser des Ereignisses.<br />
e Ein RangeEventArgs-Objekt, das die Ereignisdaten beinhaltet.<br />
Schauen Sie ferner unter<br />
AfterRowColChange-Ereignis (Seite 225)
AfterScroll-Ereignis (Seite 226)<br />
AfterSelChange-Ereignis (Seite 227)<br />
BeforeRowColChange-Ereignis (Seite 243)<br />
BeforeScroll-Ereignis (Seite 244)<br />
BeforeSelChange-Ereignis (Seite 245)<br />
RowColEventHandler-Delegierer<br />
Syntax<br />
[VB]<br />
Public Delegate Sub RowColEventHandler (object sender, RowColEventArgs e)<br />
[C#]<br />
public sealed delegate RowColEventHandler : System.MulticastDelegate<br />
[Delphi]<br />
RowColEventHandler-Delegierer · <strong>28</strong>3<br />
type RowColEventHandler = procedure(sender: System.Object, e: RowColEventArgs) of object;<br />
Argumente<br />
Argument Beschreibung<br />
sender Der Auslöser des Ereignisses.<br />
e Ein RowColEventArgs-Objekt, das die Ereignisdaten beinhaltet.<br />
Schauen Sie ferner unter<br />
AfterEdit-Ereignis (Seite 222)<br />
AfterResizeColumn-Ereignis (Seite 224)<br />
AfterResizeRow-Ereignis (Seite 224)<br />
BeforeEdit-Ereignis (Seite 236)<br />
BeforePageBreak-Ereignis (Seite 240)<br />
BeforeResizeColumn-Ereignis (Seite 241)<br />
BeforeResizeRow-Ereignis (Seite 242)<br />
BeforeScrollTip-Ereignis (Seite 244)<br />
CellButtonClick-Ereignis (Seite 248)<br />
ComboCloseUp-Ereignis (Seite 252)<br />
ComboDropDown-Ereignis (Seite 253)<br />
SetupEditor-Ereignis (Seite 271)<br />
StartEdit-Ereignis (Seite 274)
<strong>28</strong>4 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
SortColEventHandler-Delegierer<br />
Syntax<br />
[VB]<br />
Public Delegate Sub SortColEventHandler (object sender, SortColEventArgs e)<br />
[C#]<br />
public sealed delegate SortColEventHandler : System.MulticastDelegate<br />
[Delphi]<br />
type SortColEventHandler = procedure(sender: System.Object, e: SortColEventArgs) of object;<br />
Argumente<br />
Argument Beschreibung<br />
sender Der Auslöser des Ereignisses.<br />
e Ein SortColEventArgs-Objekt, das die Ereignisdaten beinhaltet.<br />
Schauen Sie ferner unter<br />
AfterSort-Ereignis (Seite 2<strong>28</strong>)<br />
BeforeSort-Ereignis (Seite 246)<br />
ValidateEditEventHandler-Delegierer<br />
Syntax<br />
[VB]<br />
Public Delegate Sub ValidateEditEventHandler (object sender, ValidateEditEventArgs e)<br />
[C#]<br />
public sealed delegate ValidateEditEventHandler : System.MulticastDelegate<br />
[Delphi]<br />
type ValidateEditEventHandler = procedure(sender: System.Object, e: ValidateEditEventArgs) of object;<br />
Argumente<br />
Argument Beschreibung<br />
sender Der Auslöser des Ereignisses.<br />
e Ein ValidateEditEventArgs-Objekt, das die Ereignisdaten beinhaltet.
Schauen Sie ferner unter<br />
ValidateEdit-Ereignis (Seite 275)<br />
<strong>C1FlexGrid</strong>-Ereignisargumente<br />
BeforeMouseDownEventArgs-Klasse<br />
Syntax<br />
[VB]<br />
Public Class BeforeMouseDownEventArgs<br />
[C#]<br />
public class BeforeMouseDownEventArgs : EventArgs<br />
[Delphi]<br />
type BeforeMouseDownEventArgs: class(EventArgs);<br />
Mitglieder<br />
Mitglied Beschreibung<br />
MouseButtons Button Ermittelt, welche Maustaste gedrückt wurde.<br />
int Clicks, X, Y, Delta<br />
bool Cancel<br />
Schauen Sie ferner unter<br />
BeforeMouseDownEventArgs-Klasse · <strong>28</strong>5<br />
Weitere Informationen über Mausaktivitäten (gleich den Parametern im<br />
MouseDown-Ereignis).<br />
Setzen Sie diesen Parameter auf TRUE, damit die Steuerung die<br />
Mausaktivitäten ignoriert.<br />
BeforeMouseDownEventHandler-Delegierer (Seite 277)<br />
DragRowColEventArgs-Klasse<br />
Syntax<br />
[VB]<br />
Public Class DragRowColEventArgs<br />
[C#]<br />
public class DragRowColEventArgs : EventArgs<br />
[Delphi]<br />
type DragRowColEventArgs: class(EventArgs);
<strong>28</strong>6 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Mitglieder<br />
Mitglied Beschreibung<br />
int Col Der ursprüngliche Index der Spalte, die vom Nutzer gezogen wurde.<br />
int Row Der ursprüngliche Index der Zeile, die vom Nutzer gezogen wurde.<br />
int Position Der aktuelle Index der Spalte, die vom Nutzer gezogen wurde.<br />
bool Cancel Bricht die aktuellen Operationen ab.<br />
Schauen Sie ferner unter<br />
DragRowColEventHandler-Delegierer (Seite 278)<br />
GridChangedEventArgs-Klasse<br />
Syntax<br />
[VB]<br />
Public Class GridChangedEventArgs<br />
[C#]<br />
public class GridChangedEventArgs : EventArgs<br />
[Delphi]<br />
type GridChangedEventArgs: class(EventArgs);<br />
Mitglieder<br />
Mitglied Beschreibung<br />
int r1, c1, r2, c2 Der Bereich, der von der Änderung betroffen war.<br />
GridChangedTypeEnum<br />
GridChangedType<br />
Schauen Sie ferner unter<br />
GridChangedEventHandler-Delegierer (Seite 278)<br />
GridErrorEventArgs-Klasse<br />
Syntax<br />
[VB]<br />
Public Class GridErrorEventArgs<br />
[C#]<br />
public class GridErrorEventArgs : EventArgs<br />
Der Typ der Änderung, die das Ereignis gestartet hat.
[Delphi]<br />
type GridErrorEventArgs: class(EventArgs);<br />
Mitglieder<br />
KeyEditEventArgs-Klasse · <strong>28</strong>7<br />
Mitglied Beschreibung<br />
int Row, Col Die Koordinaten der Zelle, in welcher der Fehler gefunden wurde.<br />
Exception Exception Eine Fehlerbeschreibung.<br />
bool Handled Ob der Fehler vom Quellcode behandelt oder eine Exception ausgegeben wurde.<br />
Schauen Sie ferner unter<br />
GridErrorEventHandler-Delegierer (Seite 279)<br />
KeyEditEventArgs-Klasse<br />
Syntax<br />
[VB]<br />
Public Class KeyEditEventArgs<br />
[C#]<br />
public class KeyEditEventArgs : EventArgs<br />
[Delphi]<br />
type KeyEditEventArgs: class(EventArgs);<br />
Mitglieder<br />
Mitglied Beschreibung<br />
int Row, Col Die Koordinaten der zu bearbeitenden Zelle, wenn die Taste gedrückt wurde.<br />
int Col Die Spalte, in der die aktuelle Zelle platziert ist.<br />
int KeyValue Der Zahlwert, der die KeyData-Eigenschaft darstellt.<br />
Keys KeyCode Der Tastencode für das Ereignis, welcher einer der Keys-Werte sein wird.<br />
Keys KeyData<br />
Der key-Code für die gedrückte Taste, zusammen mit Veränderungs-Flags, die<br />
anzeigen, welche Kombination von CTRL-, Strg- und ALT-Tasten gleichzeitig<br />
gedrückt wurde.<br />
Keys Modifiers Einer oder mehrere Veränderungs-Flags, wie in Keys definiert.<br />
bool Shift Ermittelt, ob die Strg-Taste gedrückt war.<br />
bool Alt Ermittelt, ob die Alt-Taste gedrückt war.<br />
bool Control Ermittelt, ob die Ctrl-Taste gedrückt war.<br />
Handled Ermittelt, ob der Tastendruck abgewickelt wurde.
<strong>28</strong>8 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Schauen Sie ferner unter<br />
KeyEditEventHandler-Delegierer (Seite 279)<br />
KeyPressEditEventArgs-Klasse<br />
Syntax<br />
[VB]<br />
Public Class KeyPressEditEventArgs<br />
[C#]<br />
public class KeyPressEditEventArgs : EventArgs<br />
[Delphi]<br />
type KeyPressEditEventArgs: class(EventArgs);<br />
Mitglieder<br />
Mitglied Beschreibung<br />
int Row, Col Die Koordinaten der zu bearbeitenden Zelle.<br />
char KeyChar Das Zeichen, das zu der gedrückten Taste gehört.<br />
bool Handled Ermittelt, ob der Tastendruck abgewickelt wurde.<br />
Schauen Sie ferner unter<br />
KeyPressEditEventHandler-Delegierer (Seite <strong>28</strong>0)<br />
OwnerDrawCellEventArgs-Klasse<br />
Syntax<br />
[VB]<br />
Public Class OwnerDrawCellEventArgs<br />
[C#]<br />
public class OwnerDrawCellEventArgs : EventArgs<br />
[Delphi]<br />
type OwnerDrawCellEventArgs: class(EventArgs);<br />
Mitglieder<br />
Mitglied Beschreibung<br />
int Row, Col Ermittelt die Koordinaten der zu zeichnenden Zelle.<br />
Graphics Graphics Ermittelt die zu verwendende grafische Oberfläche, um die Zelle zu<br />
zeichnen.
Rectangle Bounds Ermittelt das Rechteck, wo die Zelle gezeichnet wird.<br />
RangeEventArgs-Klasse · <strong>28</strong>9<br />
string Text Ermittelt oder legt den Text fest, der in der Zelle angezeigt wird.<br />
Image Image Ermittelt oder legt die Grafik fest, die in der Zelle angezeigt wird.<br />
CellStyle Style Legt das zu verwendende CellStyle-Objekt fest, mit dem die Zelle<br />
gezeichnet wird.<br />
void DrawCell(DrawCellFlags<br />
flags)<br />
Veranlasst die Tabelle, Teile der Zelle zu zeichnen (Hintergrund,<br />
Vordergrund, Rahmen, usw.).<br />
void DrawCell() Veranlasst die Tabelle, die gesamte Zelle zu zeichnen.<br />
bool Handled Ermittelt oder legt fest, ob das Ereignis das Zeichnen der Zelle<br />
abgeschlossen hat.<br />
bool Measuring Ermittelt einen Wert, der festlegt, ob das Ereignis nur aufgerufen wurde,<br />
um eine Zelle auszumessen. Dies geschieht, während die Größe von<br />
Zeilen und Spalten automatisch angepasst wird.<br />
Bemerkungen<br />
Der Nutzer kann den anzuzeigenden Inhalt, das zu verwendende Format oder das zur Verfügung<br />
gestellte Graphics-Objekt verändern, um benutzerdefinierte Inhalte in die Zelle zu zeichnen.<br />
Schauen Sie ferner unter<br />
OwnerDrawCellEventHandler-Delegierer (Seite <strong>28</strong>1)<br />
RangeEventArgs-Klasse<br />
Syntax<br />
[VB]<br />
Public Class RangeEventArgs<br />
[C#]<br />
public class RangeEventArgs : EventArgs<br />
[Delphi]<br />
type RangeEventArgs: class(EventArgs);<br />
Mitglieder<br />
Mitglied Beschreibung<br />
CellRange OldRange Die Auswahl vor dem Ereignis.<br />
CellRange NewRange Die aktuelle Auswahl.<br />
bool Cancel<br />
Ein Wahrheitswert, der, wenn er auf WAHR steht, die anstehenden<br />
Operationen abbricht.
290 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Schauen Sie ferner unter<br />
RangeEventHandler-Delegierer (Seite <strong>28</strong>2)<br />
RowColEventArgs-Klasse<br />
Syntax<br />
[VB]<br />
Public Class RowColEventArgs<br />
[C#]<br />
public class RowColEventArgs : EventArgs<br />
[Delphi]<br />
type RowColEventArgs: class(EventArgs);<br />
Mitglieder<br />
Mitglied Beschreibung<br />
int Row, Col Die Koordinaten der Zelle, auf die eine Operation angewendet wurde.<br />
bool Cancel<br />
Schauen Sie ferner unter<br />
Ein Wahrheitswert, der, wenn er auf WAHR steht, die anstehenden Operationen<br />
abbricht.<br />
RowColEventHandler-Delegierer (Seite <strong>28</strong>3)<br />
SortColEventArgs-Klasse<br />
Syntax<br />
[VB]<br />
Public Class SortColEventArgs<br />
[C#]<br />
public class SortColEventArgs : EventArgs<br />
[Delphi]<br />
type SortColEventArgs: class(EventArgs);<br />
Mitglieder<br />
Mitglied Beschreibung<br />
int Col Die zu sortierende Spalte.<br />
SortFlags Order Die Sortierungsrichtung.<br />
bool Cancel Bricht das Sortieren ab. Wenn dieser Parameter im BeforeSort-Ereignis
ool Handled<br />
Schauen Sie ferner unter<br />
SortColEventHandler-Delegierer (Seite <strong>28</strong>4)<br />
ValidateEditEventArgs-Klasse<br />
Syntax<br />
[VB]<br />
Public Class ValidateEditEventArgs<br />
[C#]<br />
public class ValidateEditEventArgs : EventArgs<br />
[Delphi]<br />
type ValidateEditEventArgs: class(EventArgs);<br />
Mitglieder<br />
Public Readonly Integer Row, Col<br />
Public Readonly CheckEnum Checkbox<br />
Public Boolean Cancel<br />
Eigenschaft Beschreibung<br />
ValidateEditEventArgs-Klasse · 291<br />
auf TRUE gestellt wird, dann bricht die Sortieroperation ab und das<br />
Sortierungszeichen bleibt unverändert<br />
Die Sortierung wurde vom Ereignisabwickler durchgeführt. Wenn dieser<br />
Parameter im BeforeSort-Ereignis auf TRUE gestellt wird, dann bricht die<br />
integrierte Sortierung ab. Das Sortierungszeichen wird aber dennoch<br />
aktualisiert, so als ob das Sortieren stattgefunden hätte. Dies ist nützlich,<br />
wenn Sie benutzerdefiniertes Sortieren verwenden.<br />
int Row Die Zeile, in der die aktuelle Zelle platziert ist.<br />
int Col Die Spalte, in der die aktuelle Zelle platziert ist.<br />
CheckEnum Checkbox<br />
Wenn die Zelle ein Kontrollkästchen beinhaltet, dann enthält dieser Parameter<br />
dessen Zustand, welcher der Zelle zugeordnet wird.<br />
bool Cancel Legt fest, ob der Start des Ereignisses abgebrochen werden soll.<br />
Schauen Sie ferner unter<br />
ValidateEditEventHandler-Delegierer (Seite <strong>28</strong>4)
292 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
CellRange-Struct<br />
Das CellRange-Objekt stellt den Zugang zu den Eigenschaften von Zellbereichen zur Verfügung.<br />
Verwenden Sie die GetCellRange-Methode von <strong>C1FlexGrid</strong>, um ein CellRange-Objekt zu erhalten.<br />
Zum Beispiel, der nachfolgende Quellcode legt das Format einer Zellgruppe fest.<br />
• Visual Basic<br />
• C#<br />
' create new custom cell style<br />
Dim st As CellStyle = flex.Styles.Add("MyStyle")<br />
st.Font = New Font("Tahoma", 14)<br />
' assign new style to a group of cells<br />
Dim rg As CellRange = flex.GetCellRange(1, 1, 10, 10)<br />
rg.Style = st<br />
// create new custom cell style<br />
CellStyle st = flex.Styles.Add("MyStyle");<br />
st.Font = new Font("Tahoma", 14);<br />
// assign new style to a group of cells<br />
CellRange rg = flex.GetCellRange(1,1,10,10);<br />
rg.Style = st;<br />
• Delphi<br />
var<br />
rg: CellRange;<br />
st: CellStyle;<br />
begin<br />
st := flex.Styles.Add('MyStyle');<br />
st.Font := Font.Create('Tahoma', 14);<br />
// assign new style to a group of cells<br />
rg := flex.GetCellRange(1, 1, 10, 10);<br />
rg.Style := st;<br />
end;<br />
Beachten Sie, dass das CellRange-Objekt eine struct und keine class ist. Das bedeutet, dass das Objekt als<br />
Wert und nicht als Referenz verwendet wird. Wenn Sie ein CellRange-Objekt an eine Methode<br />
übergeben und das Objekt in der Methode verändern, dann wird der ursprüngliche Wert nicht geändert.<br />
Alle CellRange-Mitglieder<br />
CellRange-Struct-Eigenschaften (public)<br />
BottomRow<br />
Unterstützt vom .NET-Compact-Framework.<br />
CheckBox<br />
Unterstützt vom .NET-Compact-Framework.<br />
Clip<br />
Unterstützt vom .NET-Compact-Framework.<br />
Data<br />
Unterstützt vom .NET-Compact-Framework.<br />
Gibt den Index der letzten Zeile des Bereichs zurück.<br />
(der größere Wert von r1 und r2).<br />
Gibt/legt den Zustand des Kontrollkästchens im<br />
Bereich zurück/fest.<br />
Gibt/legt den Inhalt eines Zellbereichs als<br />
Zeichenkette zurück/fest.<br />
Gibt/legt den rohen Inhalt des Bereichs zurück/fest.
DataDisplay<br />
Unterstützt vom .NET-Compact-Framework.<br />
Image<br />
Unterstützt vom .NET-Compact-Framework.<br />
BottomRow-Eigenschaft (CellRange) · 293<br />
Gibt den Inhalt der Zelle in (r1,c1) zurück.<br />
Gibt/legt die in dem Bereich angezeigte Grafik<br />
zurück/fest.<br />
IsSingleCell Ermittelt, ob der ausgewählte Bereich nur aus einer<br />
Zelle besteht (r1 == r2 und c1 == c2).<br />
IsValid Ermittelt ob das CellRange-Objekt eine gültige<br />
Auswahl enthält.<br />
LeftCol<br />
Unterstützt vom .NET-Compact-Framework.<br />
r1c1r2c2<br />
Unterstützt vom .NET-Compact-Framework.<br />
RightCol<br />
Unterstützt vom .NET-Compact-Framework.<br />
Style<br />
Unterstützt vom .NET-Compact-Framework.<br />
StyleDisplay<br />
Unterstützt vom .NET-Compact-Framework.<br />
StyleNew<br />
Unterstützt vom .NET-Compact-Framework.<br />
TopRow<br />
Unterstützt vom .NET-Compact-Framework.<br />
UserData<br />
Unterstützt vom .NET-Compact-Framework.<br />
CellRange-Struct-Methoden (public)<br />
Contains<br />
Unterstützt vom .NET-Compact-Framework.<br />
ContainsCol<br />
Unterstützt vom .NET-Compact-Framework.<br />
ContainsRow<br />
Unterstützt vom .NET-Compact-Framework.<br />
Normalize<br />
Unterstützt vom .NET-Compact-Framework.<br />
CellRange-Eigenschaften<br />
BottomRow-Eigenschaft (CellRange)<br />
Gibt den Index der linken Spalte des Bereichs zurück<br />
(der kleinere Wert von c1 und c2).<br />
Index der Zellen, die den Bereich festlegen (nicht<br />
zwingend in Reihenfolge, siehe Normalize-Methode).<br />
Gibt den Index der rechten Spalte des Bereichs<br />
zurück (der größere Wert von c1 und c2).<br />
Gibt/legt ein benutzerdefiniertes Zellformat für den<br />
Bereich zurück/fest.<br />
Gibt das Zellformat zurück, das für die Anzeige des<br />
Bereichs verwendet wird.<br />
Gibt das benutzerdefinierte Zellformat, das für die<br />
Anzeige des Bereichs verwendet wird, zurück und<br />
erstellt eine neue Formatvorlage, wenn nötig.<br />
Gibt den Index der ersten Zeile des Bereichs zurück.<br />
(der kleinere Wert von r1 und r2).<br />
Gibt/legt willkürliche Daten für die Zellen des Bereichs<br />
zurück/fest.<br />
Ermittelt, ob eine bestimmte Zelle in diesem Bereich<br />
enthalten ist CellRange.<br />
Ermittelt, ob eine bestimmte Spalte in diesem Bereich<br />
enthalten ist CellRange.<br />
Ermittelt, ob eine bestimmte Zeile in diesem Bereich<br />
enthalten ist CellRange.<br />
Stellt sicher, dass r1 = TopRow, r2 = BottomRow, c1<br />
= LeftCol, c2 = RightCol ist.<br />
Gibt den Index der letzten Zeile des Bereichs zurück. (der größere Wert von r1 und r2).
294 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Syntax<br />
[VB]<br />
Public BottomRow As Integer<br />
[C#]<br />
public int BottomRow {get;}<br />
[Delphi]<br />
property BottomRow: Integer;<br />
Schauen Sie ferner unter<br />
CellRange-Struct (Seite 292)<br />
CheckBox-Eigenschaft<br />
Gibt/legt den Zustand des Kontrollkästchens im Bereich zurück/fest.<br />
Syntax<br />
[VB]<br />
Public Checkbox As CheckEnum<br />
[C#]<br />
public CheckEnum Checkbox {get; set;}<br />
[Delphi]<br />
property CheckBox: CheckEnum;<br />
Bemerkungen<br />
Diese Eigenschaft gibt den Zustand des Kontrollkästchens der ersten Zelle (r1, c1) des Bereichs zurück<br />
und legt diesen für alle Kontrollkästchen im gesamten Bereich fest.<br />
Schauen Sie ferner unter<br />
CellRange-Struct (Seite 292)<br />
Clip-Eigenschaft (CellRange)<br />
Gibt/legt den Inhalt eines Zellbereichs als Zeichenkette zurück/fest.<br />
Syntax<br />
[VB]<br />
Public Clip As String<br />
[C#]<br />
public string Clip {get; set;}<br />
[Delphi]<br />
property Clip: string;
Bemerkungen<br />
Data-Eigenschaft (CellRange) · 295<br />
Der Eintrag, welcher der Clip-Eigenschaft zugeordnet oder von dieser zurückgegeben wird, kann<br />
mehrere Zellen umfassen. Standardmäßig stehen Tabulatorenzeichen (\t) für eine neue Spalte und<br />
Zeilenumschalterzeichen (\n) für Zeilenumbrüche.<br />
Die Standard Zeilen- und Spaltenabgrenzer können in der ClipSeparators-Eigenschaft geändert werden.<br />
Schauen Sie ferner unter<br />
CellRange-Struct (Seite 292)<br />
Data-Eigenschaft (CellRange)<br />
Gibt/legt den rohen Inhalt des Bereichs zurück/fest.<br />
Syntax<br />
[VB]<br />
Public Data As Object<br />
[C#]<br />
public object Data {get; set;}<br />
[Delphi]<br />
property Data: Object;<br />
Bemerkungen<br />
Diese Eigenschaft gibt den Inhalt der ersten Zelle des Bereichs (r1, c1) zurück und legt diesen für den<br />
gesamten Bereich fest.<br />
Schauen Sie ferner unter<br />
CellRange-Struct (Seite 292)<br />
DataDisplay Property<br />
Gibt den Inhalt der ersten Zelle (r1,c1) zurück und formatiert diesen als Zeichenkette.<br />
Syntax<br />
[VB]<br />
Public DataDisplay As String<br />
[C#]<br />
public string DataDisplay {get;}<br />
[Delphi]<br />
property DataDisplay: string;<br />
Bemerkungen<br />
Diese Eigenschaft ist der Clip-Eigenschaft ähnlich, nur dass Clip eine geteilte Zeichenkette mit allen<br />
Daten des gesamten Bereichs enthält und DataDisplay nur den Inhalt der ersten Zelle (r1, c1) zurückgibt.
296 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Schauen Sie ferner unter<br />
CellRange-Struct (Seite 292)<br />
Image Property<br />
Gibt/legt die in dem Bereich angezeigte Grafik zurück/fest.<br />
Syntax<br />
[VB]<br />
Public Image As Image<br />
[C#]<br />
public Image Image {get; set;}<br />
[Delphi]<br />
property Image: Image;<br />
Bemerkungen<br />
Diese Eigenschaft gibt die Grafik der ersten Zelle des Bereichs (r1, c1) zurück und legt diese für alle<br />
Zellen des gesamten Bereichs fest.<br />
Schauen Sie ferner unter<br />
CellRange-Struct (Seite 292)<br />
IsSingleCell Property<br />
Ermittelt, ob der ausgewählte Bereich nur aus einer Zelle besteht (r1 == r2 und c1 == c2).<br />
Syntax<br />
[VB]<br />
Public IsSingleCell As Boolean<br />
[C#]<br />
public bool IsSingleCell {get; }<br />
[Delphi]<br />
property IsSingleCell: Boolean;<br />
Schauen Sie ferner unter<br />
CellRange-Struct (Seite 292)<br />
IsValid Property<br />
Ermittelt ob das CellRange-Objekt eine gültige Auswahl enthält.<br />
Syntax<br />
[VB]<br />
Public IsValid As Boolean
[C#]<br />
public bool IsValid {get; }<br />
[Delphi]<br />
property IsValid: Boolean;<br />
Bemerkungen<br />
LeftCol-Eigenschaft (CellRange) · 297<br />
Diese Eigenschaft gibt TRUE zurück, wenn die Koordinaten des Bereichs gültig sind (r1 und r2 zwischen<br />
0 und Count -1; c1 und c2 zwischen 0 und Count – 1).<br />
Schauen Sie ferner unter<br />
CellRange-Struct (Seite 292)<br />
LeftCol-Eigenschaft (CellRange)<br />
Gibt den Index der linken Spalte des Bereichs zurück (der kleinere Wert von c1 und c2).<br />
Syntax<br />
[VB]<br />
Public LeftCol As Integer<br />
[C#]<br />
public int LeftCol {get;}<br />
[Delphi]<br />
property LeftCol: Integer;<br />
Schauen Sie ferner unter<br />
CellRange-Struct (Seite 292)<br />
r1,c1,r2,c2-Eigenschaft<br />
Index der Zellen, die den Bereich festlegen (nicht zwingend in Reihenfolge, siehe Normalize-Methode).<br />
Syntax<br />
[VB]<br />
Public r1, c1, r2, c2 As Integer<br />
[C#]<br />
Public int r1, c1, r2, c2; { get; set; }<br />
[Delphi]<br />
property r1, c1, r2, c2: Integer;<br />
Schauen Sie ferner unter<br />
CellRange-Struct (Seite 292)
298 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
RightCol-Eigenschaft (CellRange)<br />
Gibt den Index der rechten Spalte des Bereichs zurück (der größere Wert von c1 und c2).<br />
Syntax<br />
[VB]<br />
Public RightCol As Integer<br />
[C#]<br />
public int RightCol {get;}<br />
[Delphi]<br />
property RightCol: Integer;<br />
Schauen Sie ferner unter<br />
CellRange-Struct (Seite 292)<br />
Style-Eigenschaft (CellRange)<br />
Gibt/legt ein benutzerdefiniertes Zellformat für den Bereich zurück/fest.<br />
Syntax<br />
[VB]<br />
Public Style As CellStyle<br />
[C#]<br />
public CellStyle Style {get; set;}<br />
[Delphi]<br />
property Style: CellStyle;<br />
Bemerkungen<br />
Wenn abgefragt, dann gibt diese Eigenschaft das benutzerdefinierte Format der Zelle (r1, c1) zurück.<br />
Wenn die Zelle kein eigenes Format besitzt, dann wird Null zurückgegeben. Wenn festgelegt, dann<br />
ordnet diese Eigenschaft den neuen Wert für das Format allen Zellen im ausgewählten Bereich zu.<br />
Schauen Sie ferner unter<br />
CellRange-Struct (Seite 292)<br />
StyleDisplay-Eigenschaft (CellRange)<br />
Gibt das Zellformat zurück, dass für die Anzeige des Bereichs verwendet wird.<br />
Syntax<br />
[VB]<br />
Public StyleDisplay As CellStyle
[C#]<br />
public CellStyle StyleDisplay {get;}<br />
[Delphi]<br />
property StyleDisplay: CellStyle;<br />
Bemerkungen<br />
StyleNew-Eigenschaft (CellRange) · 299<br />
Wenn abgefragt, dann gibt diese Eigenschaft ein CellStyle-Objekt mit einem Format zurück, das für das<br />
Rendern der Zelle verwendet wird. Wenn die Zelle ein benutzerdefiniertes Format besitzt, dann gibt<br />
StyleDisplay dieses zurück; andernfalls wird das Standardformat (z.B. Normal, Fixed, usw.)<br />
zurückgegeben.<br />
Schauen Sie ferner unter<br />
CellRange-Struct (Seite 292)<br />
StyleNew-Eigenschaft (CellRange)<br />
Gibt das benutzerdefinierte Zellformat, dass für die Anzeige des Bereichs verwendet wird, zuück und<br />
erstellt eine neue Formatvorlage, wenn nötig.<br />
Syntax<br />
[VB]<br />
Public StyleNew As CellStyle<br />
[C#]<br />
public CellStyle StyleNew {get;}<br />
[Delphi]<br />
property StyleNew: CellStyle;<br />
Bemerkungen<br />
Wenn die Zelle (r1,c1) ein eigenes Format besitzt, dann wird es von dieser Eigenschaft zurückgegeben.<br />
Wenn die Zelle kein eigenes Format besitzt, dann wird von StyleNew ein neues erstellt und dieses dem<br />
gesamten Bereich zugeordnet.<br />
Schauen Sie ferner unter<br />
CellRange-Struct (Seite 292)<br />
TopRow-Eigenschaft (CellRange)<br />
Gibt den Index der ersten Zeile des Bereichs zurück. (der kleinere Wert von r1 und r2).<br />
Syntax<br />
[VB]<br />
Public TopRow As Integer<br />
[C#]<br />
public int TopRow {get;}
300 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
[Delphi]<br />
property TopRow: Integer;<br />
Schauen Sie ferner unter<br />
CellRange-Struct (Seite 292)<br />
UserData-Eigenschaft (CellRange)<br />
Gibt/legt willkürliche Daten für die Zellen des Bereichs zurück/fest.<br />
Syntax<br />
[VB]<br />
Public UserData As Object<br />
[C#]<br />
public object UserData {get; set;}<br />
[Delphi]<br />
property UserData: Object;<br />
Bemerkungen<br />
Wenn abgefragt, dann gibt diese Eigenschaft den Datenwert der ersten Zelle im Bereich (r1,c1) zurück<br />
und wenn festgelegt, dann ordnet diese den neuen Wert allen Zellen im ausgewählten Bereich zu.<br />
Schauen Sie ferner unter<br />
CellRange-Struct (Seite 292)<br />
CellRange-Methoden<br />
Contains-Methode (CellRange)<br />
Ermittelt, ob eine bestimmte Zelle in diesem Bereich enthalten ist CellRange.<br />
Syntax<br />
[VB]<br />
Public Function Contains(row As Integer, col As Integer) As Boolean<br />
[C#]<br />
public Boolean Contains ( int row , int col )<br />
[Delphi]<br />
function Contains(row: Integer; col: Integer): Boolean;<br />
Parameter Beschreibung<br />
row, col Die Koordinaten der zu überprüfenden Zelle.
Rückgabewert<br />
ContainsCol-Methode · 301<br />
Boolean. Gibt TRUE zurück, wenn die Zell auf (row, col) im Bereich CellRange liegt. (sonst FALSE)<br />
Schauen Sie ferner unter<br />
CellRange-Struct (Seite 292)<br />
ContainsCol-Methode<br />
Ermittelt, ob eine bestimmte Spalte in diesem Bereich enthalten ist CellRange.<br />
Syntax<br />
[VB]<br />
Public Function ContainsCol(col As Integer) As Boolean<br />
[C#]<br />
public Boolean ContainsCol ( int col )<br />
[Delphi]<br />
function ContainsCol(col: Integer): Boolean;<br />
Parameter Beschreibung<br />
col Der Index der zu überprüfenden Spalte.<br />
Rückgabewert<br />
Boolean. Gibt TRUE zurück, wenn die Spalte im Bereich CellRange liegt. (sonst FALSE)<br />
Schauen Sie ferner unter<br />
CellRange-Struct (Seite 292)<br />
ContainsRow-Methode<br />
Ermittelt, ob eine bestimmte Zeile in diesem Bereich enthalten ist CellRange.<br />
Syntax<br />
[VB]<br />
Public Function ContainsRow(row As Integer) As Boolean<br />
[C#]<br />
public Boolean ContainsRow ( int row )<br />
[Delphi]<br />
function ContainsRow(row: Integer): Boolean;
302 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Parameter Beschreibung<br />
row Der Index der zu überprüfenden Zeile.<br />
Rückgabewert<br />
Boolean. Gibt TRUE zurück, wenn die Zeile im Bereich CellRange liegt. (sonst FALSE)<br />
Schauen Sie ferner unter<br />
CellRange-Struct (Seite 292)<br />
Normalize-Methode<br />
Normalisiert den Bereich um sicherzustellen, dass r1
Syntax<br />
[VB]<br />
Public Column As Integer<br />
[C#]<br />
public int Column {get;}<br />
[Delphi]<br />
property Column: Integer;<br />
Schauen Sie ferner unter<br />
HitTestInfo-Klasse (Seite 302)<br />
Row-Eigenschaft (HitTestInfo)<br />
Row-Eigenschaft (HitTestInfo) · 303<br />
Ermittelt die Zeile, in welcher der Punkt geprüft wird, oder gibt -1 zurück, wenn der Punkt in einem<br />
leeren Bereich der Tabellensteuerung liegt.<br />
Syntax<br />
[VB]<br />
Public Row As Integer<br />
[C#]<br />
public int Row {get;}<br />
[Delphi]<br />
property Row: Integer;<br />
Schauen Sie ferner unter<br />
HitTestInfo-Klasse (Seite 302)<br />
Type-Eigenschaft (HitTestInfo)<br />
Ermittelt den Typ des Elements am zu prüfendem Punkt.<br />
Syntax<br />
[VB]<br />
Public Type As HitTestTypeEnum<br />
[C#]<br />
public HitTestTypeEnum Type {get;}<br />
[Delphi]<br />
property Type: HitTestTypeEnum;<br />
Bemerkungen<br />
Mit dieser Eigenschaft können Sie erfahren, ob der Punkt auf einer Zelle oder einem besonderem Element<br />
liegt, wie z.B. dem Größenveränderungsbereichen von Spalten und Zeilen.
304 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Schauen Sie ferner unter<br />
HitTestInfo-Klasse (Seite 302)<br />
X-Eigenschaft (HitTestInfo)<br />
Ermittelt die X-Koordinate des zu prüfenden Punktes.<br />
Syntax<br />
[VB]<br />
Public X As Integer<br />
[C#]<br />
public int X {get;}<br />
[Delphi]<br />
property X: Integer;<br />
Schauen Sie ferner unter<br />
HitTestInfo-Klasse (Seite 302)<br />
Y-Eigenschaft (HitTestInfo)<br />
Ermittelt die Y-Koordinate des zu prüfenden Punktes.<br />
Syntax<br />
[VB]<br />
Public Y As Integer<br />
[C#]<br />
public int Y {get;}<br />
[Delphi]<br />
property Y: Integer;<br />
Schauen Sie ferner unter<br />
HitTestInfo-Klasse (Seite 302)<br />
RowCollection-Klasse<br />
Alle RowCollection-Mitglieder<br />
RowCollection-Klasseneigenschaften (public)<br />
Count Ermittelt oder legt die Anzahl der Zeilen in der<br />
Collection fest.<br />
DefaultSize Ermittelt oder legt die Standardhöhe für alle Zeilen<br />
der Collection fest.
Count-Eigenschaft (RowCollection) · 305<br />
Fixed Ermittelt oder legt die Anzahl der fixierten Zeilen in<br />
der Collection fest.<br />
Frozen Ermittelt oder legt die Anzahl der eingefrorenen<br />
Zeilen in der Collection fest.<br />
Item Ermittelt das Zeilenobjekt an einem bestimmten<br />
Index.<br />
MaxSize Ermittelt oder legt die maximale Höhe einer Zeile<br />
fest.<br />
MinSize Ermittelt oder legt die minimale Höhe einer Zeile fest.<br />
Selected<br />
Unterstützt vom .NET-Compact-Framework.<br />
RowCollection-Klassenmethoden (public)<br />
Add<br />
Unterstützt vom .NET-Compact-Framework.<br />
Ermittelt eine Collection von Zeilen, die gerade<br />
ausgewählt sind.<br />
Fügt der Collection eine neue Zeile hinzu.<br />
Contains Ermittelt, ob die Collection eine gegebene Zeile<br />
enthält.<br />
Insert<br />
Unterstützt vom .NET-Compact-Framework.<br />
Fügt einer Collection eine neue Zeile an einer<br />
bestimmten Position hinzu.<br />
InsertNode Fügt einer Collection eine neue Knotenzeile ein.<br />
InsertRange<br />
Unterstützt vom .NET-Compact-Framework.<br />
Fügt einer Collection eine Zeilenauswahl an einer<br />
bestimmten Position hinzu.<br />
Move Verschiebt eine Zeile auf eine neue Position in der<br />
Collection.<br />
MoveRange Verschiebt eine Zeilenauswahl auf eine neue<br />
Position in der Collection.<br />
Remove<br />
Unterstützt vom .NET-Compact-Framework.<br />
RemoveRange<br />
Unterstützt vom .NET-Compact-Framework.<br />
RowCollection-Eigenschaften<br />
Count-Eigenschaft (RowCollection)<br />
Ermittelt oder legt die Anzahl der Zeilen in der Collection fest.<br />
Syntax<br />
[VB]<br />
Public Count As Integer<br />
Entfernt eine Zeile aus der Collection.<br />
Entfernt eine Zeilenauswahl aus der Collection.
306 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
[C#]<br />
public int Count {get; set;}<br />
[Delphi]<br />
property Count: Integer;<br />
Bemerkungen<br />
Sie können Zeilen entfernen oder hinzufügen, indem Sie dieser Eigenschaft einen neuen Wert zurordnen,<br />
oder die Add-, Insert-, InsertRange- und Remove-Methoden verwenden.<br />
Schauen Sie ferner unter<br />
RowCollection-Klasse (Seite 304)<br />
DefaultSize-Eigenschaft (RowCollection)<br />
Ermittelt oder legt die Standardhöhe für alle Zeilen der Collection fest.<br />
Syntax<br />
[VB]<br />
Public DefaultSize As Integer<br />
[C#]<br />
public int DefaultSize {get; set;}<br />
[Delphi]<br />
property DefaultSize: Integer;<br />
Bemerkungen<br />
Die Standardhöhe wird verwendet, wenn die Row.Height-Eigenschaft den Wert -1 besitzt.<br />
Wenn Sie einen neuen Wert der Font-Eigenschaft der Tabelle zuordnen, dann wird die DefaultSize-<br />
Eigenschaft automatisch angepasst, so dass die neue Schriftgröße in die Zeile passt.<br />
Schauen Sie ferner unter<br />
RowCollection-Klasse (Seite 304)<br />
Fixed-Eigenschaft (RowCollection)<br />
Ermittelt oder legt die Anzahl der fixierten Zeilen in der Collection fest.<br />
Syntax<br />
[VB]<br />
Public Fixed As Integer<br />
[C#]<br />
public int Fixed {get; set;}<br />
[Delphi]<br />
property Fixed: Integer;
Schauen Sie ferner unter<br />
RowCollection-Klasse (Seite 304)<br />
Frozen-Eigenschaft (RowCollection)<br />
Ermittelt oder legt die Anzahl der eingefrorenen Zeilen in der Collection fest.<br />
Syntax<br />
[VB]<br />
Public Frozen As Integer<br />
[C#]<br />
public int Frozen {get; set;}<br />
[Delphi]<br />
property Frozen: Integer;<br />
Bemerkungen<br />
Frozen-Eigenschaft (RowCollection) · 307<br />
Verwenden Sie die AllowFreezing-Eigenschaft um festzulegen, ob Nutzer Zeilen mit der Maus einfrieren<br />
können.<br />
Schauen Sie ferner unter<br />
RowCollection-Klasse (Seite 304)<br />
Item-Eigenschaft (RowCollection)<br />
Ermittelt das Zeilenobjekt an einem bestimmten Index.<br />
Syntax<br />
[VB]<br />
Public Item As Row<br />
[C#]<br />
public Row this[int index] {get;}<br />
[Delphi]<br />
property Item: Row;<br />
Bemerkungen<br />
Sie können das von dieser Methode zurückgegebene Row-Objekt verwenden, um Attribute, wie z.B.<br />
Zeilenhöhe, Sichtbarkeit, Format, Auswahlzustand, usw. zu setzen.<br />
Schauen Sie ferner unter<br />
RowCollection-Klasse (Seite 304)<br />
MaxSize-Eigenschaft (RowCollection)<br />
Ermittelt oder legt die maximale Höhe einer Zeile fest.
308 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Syntax<br />
[VB]<br />
Public MaxSize As Integer<br />
[C#]<br />
public int MaxSize {get; set;}<br />
[Delphi]<br />
property MaxSize: Integer;<br />
Bemerkungen<br />
Die MaxSize-Eigenschaft beschränkt die maximale Größe der Zeilen, wenn diese durch den Nutzer oder<br />
durch die AutoSizeRows-Methode, welche die Größe der Zeilen an den Zellinhalt anpasst, verändert<br />
wird.<br />
Diese Eigenschaft ist deaktiviert, wenn sie auf Null gestellt ist.<br />
Schauen Sie ferner unter<br />
RowCollection-Klasse (Seite 304)<br />
MinSize-Eigenschaft (RowCollection)<br />
Ermittelt oder legt die minimale Höhe einer Zeile fest.<br />
Syntax<br />
[VB]<br />
Public MinSize As Integer<br />
[C#]<br />
public int MinSize {get; set;}<br />
[Delphi]<br />
property MinSize: Integer;<br />
Bemerkungen<br />
Die MinSize-Eigenschaft beschränkt die Mindestgröße der Zeilen, wenn diese durch den Nutzer oder<br />
durch die AutoSizeRows-Methode, welche die Größe der Zeilen an den Zellinhalt anpasst, verändert<br />
wird.<br />
Schauen Sie ferner unter<br />
RowCollection-Klasse (Seite 304)<br />
Selected-Eigenschaft (RowCollection)<br />
Ermittelt eine Collection von Zeilen, die gerade ausgewählt sind.<br />
Syntax<br />
[VB]<br />
Public Selected As RowCollection
[C#]<br />
public RowCollection Selected<br />
[Delphi]<br />
property Selected: RowCollection;<br />
Bemerkungen<br />
Add-Methode (RowCollection) · 309<br />
Diese Eigenschaft ist nützlich, wenn die Tabelle im Listenfeldmodus verwendet wird. Zum Beispiel, der<br />
nachfolgende Quellcode gibt Informationen über die aktuell ausgewählten Zeilen zurück:<br />
• Visual Basic<br />
• C#<br />
fg.SelectionMode = SelectionModeEnum.ListBox<br />
Dim r As Row<br />
For Each r In fg.Rows.Selected<br />
Console.WriteLine(r.Index)<br />
Next<br />
fg.SelectionMode = SelectionModeEnum.ListBox;<br />
foreach (Row row in fg.Rows.Selection)<br />
Console.WriteLine(row.Index);<br />
• Delphi<br />
var<br />
r: Row;<br />
i: Integer;<br />
begin<br />
fg.SelectionMode := SelectionModeEnum.ListBox;<br />
for I := 0 to fg.Rows.Count do<br />
begin<br />
r := fg.Rows[i];<br />
Console.WriteLine(r.Index);<br />
end;<br />
end;<br />
Schauen Sie ferner unter<br />
RowCollection-Klasse (Seite 304)<br />
RowCollection-Methoden<br />
Add-Methode (RowCollection)<br />
Fügt der Collection eine neue Zeile hinzu.<br />
Syntax<br />
[VB]<br />
Public Function Add() As Row<br />
[C#]<br />
public Row Add ( )
310 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
[Delphi]<br />
property Add: Row;<br />
Rückgabewert<br />
Ein Verweis auf die Zeile, die der Collection hinzugefügt wurde.<br />
Bemerkungen<br />
Die Add-Methode hängt der Collection eine neue Zeile an. Verwenden Sie die Insert-Methode, um eine<br />
Zeile an einer bestimmten Stelle einzufügen.<br />
Schauen Sie ferner unter<br />
RowCollection-Klasse (Seite 304)<br />
Contains-Methode (RowCollection)<br />
Ermittelt, ob die Collection eine gegebene Zeile enthält.<br />
Syntax<br />
[VB]<br />
Public Function Contains(item As RowCol) As Boolean<br />
[C#]<br />
public Boolean Contains (RowCol item )<br />
[Delphi]<br />
function Contains(item: RowCol): Boolean;<br />
Parameter Beschreibung<br />
row Das zu prüfende Row-Objekt.<br />
Rückgabewert<br />
Boolean. Gibt TRUE zurück, wenn die Zeile ein Mitglied der Collection ist. (Sonst FALSE)<br />
Schauen Sie ferner unter<br />
RowCollection-Klasse (Seite 304)<br />
Insert-Methode (RowCollection)<br />
Fügt einer Collection eine neue Zeile an einer bestimmten Position hinzu.<br />
Syntax<br />
[VB]<br />
Public Function Insert(index As Integer) As Row<br />
[C#]<br />
public Row Insert ( int index )
[Delphi]<br />
function Insert (index: Integer): Row;<br />
Parameter Beschreibung<br />
index Die Position, auf der die neue Zeile eingefügt werden soll.<br />
Rückgabewert<br />
Ein Verweis auf die Zeile, die der Collection hinzugefügt wurde.<br />
Schauen Sie ferner unter<br />
RowCollection-Klasse (Seite 304)<br />
InsertNode-Methode<br />
Fügt in eine Collection eine neue Knotenzeile ein.<br />
Syntax<br />
[VB]<br />
Public Function InsertNode(index As Integer, level As Integer) As Node<br />
[C#]<br />
public Node InsertNode ( int index , int level )<br />
[Delphi]<br />
function InsertNode (index: Integer; level: Integer): Node;<br />
Rückgabewert<br />
Ein Verweis auf den Knoten, welcher der Collection hinzugefügt wurde.<br />
Bemerkungen<br />
InsertNode-Methode · 311<br />
Diese Methode ist besonders nützlich, wenn die Tabelle an eine Datenquelle gebunden ist, weil Sie in<br />
diesem Fall nicht den Wert der Row.IsNode-Eigenschaft verändern können. Wenn die Tabelle<br />
ungebundenen ist, können Sie Zeilen hinzufügen und diese später mit der Row.IsNode-Eigenschaft in<br />
Knotenzeilen umwandeln.<br />
Schauen Sie ferner unter<br />
RowCollection-Klasse (Seite 304)<br />
InsertRange-Methode (RowCollection)<br />
Fügt einer Collection eine Zeilenauswahl an einer bestimmten Position hinzu.<br />
Syntax<br />
[VB]<br />
Public Sub InsertRange(index As Integer, count As Integer)
312 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
[C#]<br />
public void InsertRange ( int index , int count )<br />
[Delphi]<br />
procedure InsertRange (index: Integer; count: Integer);<br />
Parameter Beschreibung<br />
index Die Position, an welcher der neue Bereich eingefügt wird.<br />
count Die Anzahl der einzufügenden Zeilen.<br />
Schauen Sie ferner unter<br />
RowCollection-Klasse (Seite 304)<br />
Move-Methode (RowCollection)<br />
Verschiebt eine Zeile auf eine neue Position in der Collection.<br />
Syntax<br />
[VB]<br />
Public Sub Move(indexOld As Integer, indexNew As Integer)<br />
[C#]<br />
public void Move ( int indexOld , int indexNew )<br />
[Delphi]<br />
procedure Move (indexOld: Integer; indexNew: Integer);<br />
Parameter Beschreibung<br />
oldindex Der aktuelle Index der zu verschiebenden Zeile.<br />
newindex Der neue Zeilenindex.<br />
Schauen Sie ferner unter<br />
RowCollection-Klasse (Seite 304)<br />
MoveRange-Methode (RowCollection)<br />
Verschiebt eine Zeilenauswahl auf eine neue Position in der Collection.<br />
Syntax<br />
[VB]<br />
Public Sub MoveRange(index As Integer, count As Integer, indexNew As Integer)
[C#]<br />
public void MoveRange ( int index , int count , int indexNew )<br />
[Delphi]<br />
procedure MoveRange (index: Integer, count: Integer, indexNew: Integer);<br />
Parameter Beschreibung<br />
oldindex Der aktuelle Index der ersten Zeile des zu verschiebenden Bereichs.<br />
count Die Anzahl der Zeilen, die verschoben werden.<br />
newindex Der neue Index der ersten Zeile des Bereichs.<br />
Schauen Sie ferner unter<br />
RowCollection-Klasse (Seite 304)<br />
Remove-Methode (RowCollection)<br />
Entfernt eine Zeile aus der Collection.<br />
Syntax<br />
[VB]<br />
Public Function Remove(index As Integer) As Row<br />
[C#]<br />
public Row Remove ( int index )<br />
[Delphi]<br />
function Remove(index: Integer): Row;<br />
Parameter Beschreibung<br />
index Der Index, der aus der Collection zu entfernenden Zeile.<br />
Rückgabewert<br />
Ein Verweis auf die Zeile, die aus der Collection entfernt wurde.<br />
Schauen Sie ferner unter<br />
RowCollection-Klasse (Seite 304)<br />
RemoveRange-Methode (RowCollection)<br />
Entfernt eine Zeilenauswahl aus der Collection.<br />
Remove-Methode (RowCollection) · 313
314 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Syntax<br />
[VB]<br />
Public Sub RemoveRange(index As Integer, count As Integer)<br />
[C#]<br />
public void RemoveRange ( int index , int count )<br />
[Delphi]<br />
procedure RemoveRange(index: Integer; count: Integer);<br />
Parameter Beschreibung<br />
index Der aktuelle Index der ersten Zeile des zu entfernenden Bereichs.<br />
count Die Anzahl der Zeilen, die aus der Collection entfernt werden.<br />
Schauen Sie ferner unter<br />
RowCollection-Klasse (Seite 304)<br />
ColumnCollection-Klasse<br />
Alle ColumnCollection-Mitglieder<br />
ColumnCollection-Klassen-Eigenschaften (public)<br />
Count Ermittelt oder legt die Anzahl der Spalten in der<br />
Collection fest.<br />
DefaultSize Ermittelt oder legt die Standardbreite für alle Spalten<br />
der Collection fest.<br />
Fixed Ermittelt oder legt die Anzahl der fixierten Spalten in<br />
der Collection fest.<br />
Frozen Ermittelt oder legt die Anzahl der eingefrorenen<br />
Spalten in der Collection fest.<br />
Item Ermittelt das Spaltenobjekt an einem bestimmten<br />
Index.<br />
MaxSize Ermittelt oder legt die maximale Breite einer Spalte<br />
fest.<br />
MinSize Ermittelt oder legt die minimale Breite einer Zeile fest.<br />
Selected<br />
Unterstützt vom .NET-Compact-Framework.<br />
Ermittelt eine Collection von Spalten, die gerade<br />
ausgewählt sind.
ColumnCollection-Klassenmethoden (public)<br />
Add<br />
Unterstützt vom .NET-Compact-Framework.<br />
Count-Eigenschaft (ColumnCollection) · 315<br />
Fügt der Collection eine neue Spalte hinzu.<br />
ContainsCol Ermittelt, ob die Collection eine gegebene Spalte<br />
enthält.<br />
Insert<br />
Unterstützt vom .NET-Compact-Framework.<br />
InsertRange<br />
Unterstützt vom .NET-Compact-Framework.<br />
Fügt einer Collection eine neue Spalte an einer<br />
bestimmten Position hinzu.<br />
Fügt einer Collection eine Spaltenauswahl an einer<br />
bestimmten Position hinzu.<br />
Move Verschiebt eine Spalte auf eine neue Position in der<br />
Collection.<br />
MoveRange Verschiebt eine Spaltenauswahl auf eine neue Position<br />
in der Collection.<br />
Remove<br />
Unterstützt vom .NET-Compact-Framework.<br />
RemoveRange<br />
Unterstützt vom .NET-Compact-Framework.<br />
ColumnCollection-Eigenschaften<br />
Count-Eigenschaft (ColumnCollection)<br />
Ermittelt oder legt die Anzahl der Spalten in der Collection fest.<br />
Syntax<br />
[VB]<br />
Public Count As Integer<br />
[C#]<br />
public int Count {get; set;}<br />
[Delphi]<br />
property Count: Integer;<br />
Bemerkungen<br />
Entfernt eine Spalte aus der Collection.<br />
Entfernt eine Spaltenauswahl aus der Collection.<br />
Sie können Spalten entfernen oder hinzufügen, indem Sie dieser Eigenschaft einen neuen Wert<br />
zurordnen, oder die Add-, Insert-, InsertRange- und Remove-Methoden verwenden.<br />
Schauen Sie ferner unter<br />
ColumnCollection-Klasse (Seite 314)<br />
DefaultSize-Eigenschaft (ColumnCollection)<br />
Ermittelt oder legt die Standardbreite für alle Spalten der Collection fest.
316 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Syntax<br />
[VB]<br />
Public DefaultSize As Integer<br />
[C#]<br />
public int DefaultSize {get; set;}<br />
[Delphi]<br />
property DefaultSize: Integer;<br />
Bemerkungen<br />
Die Standardbreite wird verwendet, wenn die Column.Width-Eigenschaft den Wert -1 besitzt.<br />
Wenn Sie einen neuen Wert der Font-Eigenschaft der Tabelle zuordnen, dann wird die DefaultSize-<br />
Eigenschaft automatisch angepasst, so dass die neue Schriftgröße in die Spalte passt.<br />
Schauen Sie ferner unter<br />
ColumnCollection-Klasse (Seite 314)<br />
Fixed-Eigenschaft (ColumnCollection)<br />
Ermittelt oder legt die Anzahl der fixierten Spalten in der Collection fest.<br />
Syntax<br />
[VB]<br />
Public Fixed As Integer<br />
[C#]<br />
public int Fixed {get; set;}<br />
[Delphi]<br />
property Fixed: Integer;<br />
Schauen Sie ferner unter<br />
ColumnCollection-Klasse (Seite 314)<br />
Frozen-Eigenschaft (ColumnCollection)<br />
Ermittelt oder legt die Anzahl der eingefrorenen Spalten in der Collection fest.<br />
Syntax<br />
[VB]<br />
Public Frozen As Integer<br />
[C#]<br />
public int Frozen {get; set;}<br />
[Delphi]<br />
property Frozen: Integer;
Bemerkungen<br />
Item-Eigenschaft (ColumnCollection) · 317<br />
Verwenden Sie die AllowFreezing-Eigenschaft um festzulegen, ob Nutzer Spalten mit der Maus<br />
einfrieren können.<br />
Schauen Sie ferner unter<br />
ColumnCollection-Klasse (Seite 314)<br />
Item-Eigenschaft (ColumnCollection)<br />
Ermittelt das Spaltenobjekt an einem bestimmten Index.<br />
Syntax<br />
[VB]<br />
Public Item[int index] As Column<br />
[C#]<br />
public Column this[int index] {get; }<br />
public Column this[string name] {get; }<br />
[Delphi]<br />
property Item: Column;<br />
Bemerkungen<br />
Sie können das von dieser Methode zurückgegebene Column-Objekt verwenden, um Attribute, wie z.B.<br />
Spaltenbreite, Sichbarkeit, Format, Auswahlzustand, usw. zu setzen.<br />
Der Zeichenkettenindizierer sucht nach einer Spalte mit einem festgelegten Name. Der Spaltenname wird<br />
entweder automatisch gesetzt, wenn die Tabelle an eine Datenbank gebunden ist, oder er wird mit<br />
Quellcode festgelegt. Zum Beispiel:<br />
• Visual Basic<br />
• C#<br />
' set the column name<br />
flex.Cols(2).Name = "bools" '<br />
flex.Cols(2).DataType = GetType(Boolean) '<br />
' show boolean column as text<br />
flex.Cols("bools").Format = "Yes;No" '<br />
// set the column name<br />
flex.Cols[2].Name = "bools";<br />
flex.Cols[2].DataType = typeof(bool);<br />
// show boolean column as text<br />
flex.Cols["bools"].Format = "Yes;No";<br />
• Delphi<br />
// set the column name<br />
flex.Cols[2].Name := 'bools';<br />
flex.Cols[2].DataType := TypeOf(Boolean);<br />
// show boolean column as text
318 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
flex.Cols['bools'].Format := 'Yes;No';<br />
Schauen Sie ferner unter<br />
ColumnCollection-Klasse (Seite 314)<br />
MaxSize-Eigenschaft (ColumnCollection)<br />
Ermittelt oder legt die maximale Breite einer Spalte fest.<br />
Syntax<br />
[VB]<br />
Public MaxSize As Integer<br />
[C#]<br />
public int MaxSize {get; set;}<br />
[Delphi]<br />
property MaxSize: Integer;<br />
Bemerkungen<br />
Die MaxSize-Eigenschaft beschränkt die maximale Größe der Spalte, wenn diese durch den Nutzer oder<br />
durch die AutoSizeCols-Methode, welche die Größe der Spalten an den Zellinhalt anpasst, verändert<br />
wird.<br />
Diese Eigenschaft ist deaktiviert, wenn sie auf Null gestellt wird.<br />
Schauen Sie ferner unter<br />
ColumnCollection-Klasse (Seite 314)<br />
MinSize-Eigenschaft (ColumnCollection)<br />
Ermittelt oder legt die minimale Breite einer Zeile fest.<br />
Syntax<br />
[VB]<br />
Public MinSize As Integer<br />
[C#]<br />
public int MinSize {get; set;}<br />
[Delphi]<br />
property MinSize: Integer;<br />
Bemerkungen<br />
Die MinSize-Eigenschaft beschränkt die Mindestgröße der Spalte, wenn diese durch den Nutzer oder<br />
durch die AutoSizeCols-Methode, welche die Größe der Spalten an den Zellinhalt anpasst, verändert<br />
wird.<br />
Schauen Sie ferner unter<br />
ColumnCollection-Klasse (Seite 314)
Selected-Eigenschaft<br />
Ermittelt eine Collection von Spalten, die gerade ausgewählt sind.<br />
Syntax<br />
[VB]<br />
Public Selected As ColumnCollection<br />
[C#]<br />
public ColumnCollection Selected {get;}<br />
[Delphi]<br />
property Selected: ColumnCollection;<br />
Schauen Sie ferner unter<br />
ColumnCollection-Klasse (Seite 314)<br />
ColumnCollection-Methoden<br />
Add-Methode (ColumnCollection)<br />
Fügt der Collection eine neue Spalte hinzu.<br />
Syntax<br />
[VB]<br />
Public Function Add() As Column<br />
[C#]<br />
public Column Add ( )<br />
[Delphi]<br />
function Add: Column;<br />
Rückgabewert<br />
Ein Verweis auf die Spalte, die der Collection hinzugefügt wurde.<br />
Bemerkungen<br />
Selected-Eigenschaft · 319<br />
Die Add-Methode hängt der Collection eine neue Spalte an. Verwenden Sie die Insert-Methode, um eine<br />
Spalte an einer bestimmten Stelle einzufügen.<br />
Schauen Sie ferner unter<br />
ColumnCollection-Klasse (Seite 314)<br />
Contains-Methode (ColumnCollection)<br />
Ermittelt, ob die Collection eine gegebene Spalte enthält.
320 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Syntax<br />
[VB]<br />
Public Function Contains(columnName As String) As Boolean<br />
[C#]<br />
public Boolean Contains (String columnName )<br />
[Delphi]<br />
function Contains(columnName: string): Boolean;<br />
Parameter Beschreibung<br />
col Das zu prüfende Column-Objekt.<br />
Rückgabewert<br />
Boolean. Gibt TRUE zurück, wenn die Spalte ein Mitglied der Collection ist. (Sonst FALSE)<br />
Schauen Sie ferner unter<br />
ColumnCollection-Klasse (Seite 314)<br />
Insert-Methode (ColumnCollection)<br />
Fügt einer Collection eine neue Spalte an einer bestimmten Position hinzu.<br />
Syntax<br />
[VB]<br />
Public Function Insert(index As Integer) As Column<br />
[C#]<br />
public Column Insert ( int index )<br />
[Delphi]<br />
function Insert(index: Integer): Column;<br />
Parameter Beschreibung<br />
index Die Position, auf der die neue Spalte eingefügt werden soll.<br />
Rückgabewert<br />
Ein Verweis auf die Spalte, die der Collection hinzugefügt wurde.<br />
Schauen Sie ferner unter<br />
ColumnCollection-Klasse (Seite 314)<br />
InsertRange-Methode (ColumnCollection)<br />
Fügt einer Collection eine Spaltenauswahl an einer bestimmten Position hinzu.
Syntax<br />
[VB]<br />
Public Sub InsertRange(index As Integer, count As Integer)<br />
[C#]<br />
public void InsertRange ( int index , int count )<br />
[Delphi]<br />
procedure InsertRange (index: Integer; count: Integer);<br />
Parameter Beschreibung<br />
index Die Position, an welcher der neue Bereich eingefügt wird.<br />
count Die Anzahl der einzufügenden Spalten.<br />
Schauen Sie ferner unter<br />
ColumnCollection-Klasse (Seite 314)<br />
Move-Methode (ColumnCollection)<br />
Verschiebt eine Spalte auf eine neue Position in der Collection.<br />
Syntax<br />
[VB]<br />
Public Sub Move(indexOld As Integer, indexNew As Integer)<br />
[C#]<br />
public void Move ( int indexOld , int indexNew )<br />
[Delphi]<br />
procedure Move (indexOld: Integer; IndexNew: Integer);<br />
Parameter Beschreibung<br />
oldindex Der aktuelle Index der zu verschiebenden Spalte.<br />
newIndex Der neue Spaltenindex.<br />
Schauen Sie ferner unter<br />
ColumnCollection-Klasse (Seite 314)<br />
MoveRange-Methode (ColumnCollection)<br />
Verschiebt eine Spaltenauswahl auf eine neue Position in der Collection.<br />
Move-Methode (ColumnCollection) · 321
322 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Syntax<br />
[VB]<br />
Public Sub MoveRange(index As Integer, count As Integer, indexNew As Integer)<br />
[C#]<br />
public void MoveRange ( int index , int count , int indexNew )<br />
[Delphi]<br />
procedure MoveRange(index: Integer; count: Integer, indexNew: Integer);<br />
Parameter Beschreibung<br />
oldindex Der aktuelle Index der ersten Spalte des zu verschiebenden Bereichs.<br />
count Die Anzahl der Zeilen, die verschoben werden.<br />
newIndex Der neue Index der ersten Spalte des Bereichs.<br />
Schauen Sie ferner unter<br />
ColumnCollection-Klasse (Seite 314)<br />
Remove-Methode (ColumnCollection)<br />
Entfernt eine Spalte aus der Collection.<br />
Syntax<br />
[VB]<br />
Public Function Remove(index As Integer) As Column<br />
[C#]<br />
public Column Remove ( int index )<br />
[Delphi]<br />
function Remove(index: Integer): Column;<br />
Parameter Beschreibung<br />
index Der Index, der aus der Collection zu entfernenden Spalte.<br />
Rückgabewert<br />
Ein Verweis auf die Spalte, die aus der Collection entfernt wurde.<br />
Schauen Sie ferner unter<br />
ColumnCollection-Klasse (Seite 314)
RemoveRange-Methode (ColumnCollection)<br />
Entfernt eine Spaltenauswahl aus der Collection.<br />
Syntax<br />
[VB]<br />
Public Sub RemoveRange(index As Integer, count As Integer)<br />
[C#]<br />
public void RemoveRange ( int index , int count )<br />
[Delphi]<br />
procedure RemoveRange(index: Integer; count: Integer);<br />
RemoveRange-Methode (ColumnCollection) · 323<br />
Parameter Beschreibung<br />
index Der aktuelle Index der ersten Spalte des zu entfernenden Bereichs.<br />
count Die Anzahl der Spalten, die aus der Collection entfernt werden.<br />
Schauen Sie ferner unter<br />
ColumnCollection-Klasse (Seite 314)
324 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Row-Klassen<br />
Alle Row-Mitglieder<br />
Row-Klasseneigenschaften (public)<br />
AllowDragging Ermittelt oder legt fest, ob der Nutzer diese Zeile mit<br />
der Maus ziehen darf.<br />
AllowEditing Ermittelt oder legt fest, ob der Nutzer die Zellen<br />
dieser Zeilen bearbeiten darf.<br />
AllowMerging Ermittelt oder legt fest, ob die Zellen mit den<br />
benachbarten Zellen dieser Zeile verbunden werden.<br />
AllowResizing Ermittelt oder legt fest, ob der Nutzer die Größe<br />
dieser Zeile mit der Maus verändern darf.<br />
Bottom<br />
Unterstützt vom .NET-Compact-Framework.<br />
Gibt die Position der unteren Grenze dieser Zeile in<br />
Pixeln, relativ zur Tabelle zurück. (berücksichtigt<br />
nicht den Bildlauf)<br />
Caption Ermittelt oder legt den Text der ersten fixierten Zelle<br />
in dieser Zeile fest.<br />
DataIndex Gibt die Position dieser Zeile im Datenquellobjekt<br />
zurück.<br />
DataSource Gibt das Objekt zurück, welches die Daten für diese<br />
Zeile zur Verfügung stellt.<br />
Editor Ermittelt oder legt den benutzerdefinierten Editor<br />
fest, der für die Bearbeitung der Zellen in dieser Zeile<br />
verwendet werden soll.<br />
Height<br />
Unterstützt vom .NET-Compact-Framework.<br />
HeightDisplay<br />
Unterstützt vom .NET-Compact-Framework.<br />
Ermittelt oder legt die Höhe dieser Zeile in Pixel fest.<br />
Gibt -1 zurück, wenn die Zeile die Standardhöhe hat.<br />
Ermittelt oder legt die angezeigte Höhe dieser Zeile<br />
in Pixeln fest.<br />
ImageAlign Ermittelt oder legt fest, wie Grafiken in scrollbaren<br />
Zellen dieser Zeile ausgerichtet werden.<br />
ImageAlignFixed Ermittelt oder legt fest, wie Grafiken in fixierten<br />
Zellen dieser Zeile ausgerichtet werden.<br />
Index Gibt den Index dieser Zeile in der Rows-Collection<br />
zurück.<br />
IsNew Zeigt an, dass die Zeile ein Platzhalter für das<br />
Hinzufügen von neuen Zeilen zur Tabelle darstellt.<br />
IsNode<br />
Unterstützt vom .NET-Compact-Framework.<br />
Node<br />
Unterstützt vom .NET-Compact-Framework.<br />
Ermittelt oder legt fest, ob diese Zeile eine<br />
Knotenzeile in einer Gliederung ist.<br />
Gibt ein Node-Objekt zurück.
AllowDragging-Eigenschaft (Row) · 325<br />
SafeIndex Gibt den Index dieser Zeile in der Rows-Collection<br />
zurück.<br />
Selected Ermittelt oder legt fest, ob diese Zeile ausgewählt ist.<br />
Style Ermittelt oder legt fest, welches Format verwendet<br />
wird, um die Zeile anzuzeigen.<br />
StyleDisplay Ermittelt das für die Anzeige der Zelle verwendete<br />
Format.<br />
StyleNew Ermittelt das benutzerdefinierte Format, das mit<br />
dieser Zeile verknüpft ist, und erstellt, wenn nötig,<br />
eine neue Formatvorlage.<br />
Top<br />
Unterstützt vom .NET-Compact-Framework.<br />
Gibt die Position der oberen Grenze dieser Zeile in<br />
Pixeln, relativ zur Tabelle zurück. (berücksichtigt<br />
nicht den Bildlauf)<br />
UserData Ermittelt oder legt die mit dieser Zeile verknüpften<br />
Benutzerdaten fest.<br />
Visible Ermittelt oder legt die Sichtbarkeit dieser Zeile fest.<br />
Row-Klassenmethoden (public)<br />
Clear<br />
Unterstützt vom .NET-Compact-Framework.<br />
Löscht die Inhalte dieser Zeile.<br />
Move Verschiebt diese Zeile in der Collection auf eine<br />
neue Position.<br />
Row-Eigenschaften<br />
AllowDragging-Eigenschaft (Row)<br />
Ermittelt oder legt fest, ob der Nutzer diese Zeile mit der Maus ziehen darf.<br />
Syntax<br />
[VB]<br />
Public AllowDragging As Boolean<br />
[C#]<br />
public bool AllowDragging {get; set;}<br />
[Delphi]<br />
property AllowDragging: Boolean;<br />
Bemerkungen<br />
Die Tabelle besitzt eine AllowDragging-Eigenschaft, die festlegt, ob Zeilen und Spalten gezogen werden<br />
können. Die AllowDragging-Eigenschaft von Row- und Column-Objekten wird verwendet, um den<br />
Nutzer daran zu hindern, bestimmte Zeilen und Spalten von ihrer eigentlichen Position zu ziehen.
326 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Schauen Sie ferner unter<br />
Row-Klasse (Seite 324)<br />
AllowEditing-Eigenschaft (Row)<br />
Ermittelt oder legt fest, ob der Nutzer die Zellen dieser Zeilen bearbeiten darf.<br />
Syntax<br />
[VB]<br />
Public AllowEditing As Boolean<br />
[C#]<br />
public bool AllowEditing {get; set;}<br />
[Delphi]<br />
property AllowEditing: Boolean;<br />
Bemerkungen<br />
Die Tabelle besitzt eine AllowEditing-Eigenschaft, die festlegt, ob Zellen bearbeitet werden können. Die<br />
AllowEditing-Eigenschaft von Row- und Column-Objekten wird verwendet, um den Nutzer daran zu<br />
hindern, Zellen in bestimmten Zeilen und Spalten zu bearbeiten.<br />
Schauen Sie ferner unter<br />
Row-Klasse (Seite 324)<br />
AllowMerging-Eigenschaft (Row)<br />
Ermittelt oder legt fest, ob die Zellen mit den benachbarten Zellen dieser Zeile verbunden werden.<br />
Syntax<br />
[VB]<br />
Public AllowMerging As Boolean<br />
[C#]<br />
public bool AllowMerging {get; set;}<br />
[Delphi]<br />
property AllowMerging: Boolean;<br />
Bemerkungen<br />
Die Tabelle besitzt eine AllowMerging-Eigenschaft, die festlegt, ob Zellen verbunden werden können.<br />
Die AllowMerging-Eigenschaft von Row- und Column-Objekten wird verwendet, um Zellen mit<br />
angrenzenden Zellen in bestimmten Zeilen und Spalten zu verbinden.<br />
Schauen Sie ferner unter<br />
Row-Klasse (Seite 324)
AllowResizing-Eigenschaft (Row)<br />
AllowResizing-Eigenschaft (Row) · 327<br />
Ermittelt oder legt fest, ob der Nutzer die Größe dieser Zeile mit der Maus verändern darf.<br />
Syntax<br />
[VB]<br />
Public AllowResizing As Boolean<br />
[C#]<br />
public bool AllowResizing {get; set;}<br />
[Delphi]<br />
property AllowResizing: Boolean;<br />
Bemerkungen<br />
Die Tabelle besitzt eine AllowResizing-Eigenschaft, die festlegt, ob die Größe von Zeilen und Spalten mit<br />
Ziehen der Kanten der Überschriftszelle verändert werden kann. Die AllowResizing-Eigenschaft von<br />
Row- und Column-Objekten wird verwendet, um den Nutzer daran zu hindern, die Größe von<br />
bestimmten Zeilen und Spalten zu ändern.<br />
Schauen Sie ferner unter<br />
Row-Klasse (Seite 324)<br />
Bottom-Eigenschaft<br />
Gibt die Position der unteren Grenze dieser Zeile in Pixeln, relativ zur Tabelle zurück. (berücksichtigt<br />
nicht den Bildlauf)<br />
Syntax<br />
[VB]<br />
Public Bottom As Integer<br />
[C#]<br />
public int Bottom {get;}<br />
[Delphi]<br />
property Bottom: Integer;<br />
Bemerkungen<br />
Der zurückgegebene Wert ist die Summe der Zeilenhöhen vom oberen Ende der Tabelle. Um vertikalen<br />
Bildlauf in Betracht zu ziehen, müssen Sie den Wert mit Hilfe der ScrollPosition-Tabelleneigenschaft<br />
anpassen.<br />
Verwenden Sie die GetCellRect-Methode, um die Größe und Position einer Zelle abzufragen.<br />
Schauen Sie ferner unter<br />
Row-Klasse (Seite 324)
3<strong>28</strong> · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Caption-Eigenschaft (Row)<br />
Ermittelt oder legt den Text der ersten fixierten Zelle in dieser Zeile fest.<br />
Syntax<br />
[VB]<br />
Public Caption As String<br />
[C#]<br />
public string Caption {get; set;}<br />
[Delphi]<br />
property Caption: string;<br />
Schauen Sie ferner unter<br />
Row-Klasse (Seite 324)<br />
DataIndex-Eigenschaft (Row)<br />
Gibt die Position dieser Zeile, ausschließlich der fixierten und Knotenzeilen, in der Rows-Collection<br />
zurück.<br />
Syntax<br />
[VB]<br />
Public DataIndex As Integer<br />
[C#]<br />
public int DataIndex {get;}<br />
[Delphi]<br />
property DataIndex: Integer;<br />
Bemerkungen<br />
Diese Eigenschaft gibt –1 zurück, wenn die Zeile fixiert oder eine Knotenzeile ist.<br />
Wenn die Tabelle an eine Datenquelle gebunden ist, dann kann der Rückgabewert als ein Indizierer in<br />
dieser Quelle verwendet werden, um einen Verweis auf das an diese Zeile gebundene Element zu<br />
erhalten.<br />
Sie können das zugrunde liegende Datenobjekt auch direkt mit der DataSource-Eigenschaft der Zeile<br />
abfragen.<br />
Schauen Sie ferner unter<br />
Row-Klasse (Seite 324)<br />
Index-Eigenschaft (Row) (Seite 331)<br />
DataSource-Eigenschaft (Row) (Seite 329)<br />
SafeIndex-Eigenschaft (Row) (Seite 334)
DataSource-Eigenschaft (Row)<br />
Gibt das Objekt zurück, welches die Daten für diese Zeile zur Verfügung stellt.<br />
Syntax<br />
[VB]<br />
Public DataSource As Object<br />
[C#]<br />
public object DataSource {get;}<br />
[Delphi]<br />
property DataSource: Object;<br />
Bemerkungen<br />
DataSource-Eigenschaft (Row) · 329<br />
Der Type des zurückgegebenen Objekts hängt vom Typ der, der Tabelle zugeordneten, DataSource ab.<br />
Zum Beispiel, wenn die Tabelle an ein DataView-Objekt gebunden ist, dann wird diese Eigenschaft das<br />
entsprechende DataRowView-Objekt zurückgeben, welches an diese Zeile gebunden ist.<br />
Diese Eigenschaft gibt Null zurück („Nothing“ in VB), wenn die Tabelle ungebunden ist oder die Zeile<br />
fixiert oder eine Knotenzeile ist, die zu keinem Objekt in der Datenquelle der Tabelle verknüpft ist.<br />
Schauen Sie im GetUnboundValue-Ereignis für ein Beispiel nach.<br />
Schauen Sie ferner unter<br />
Row-Klasse (Seite 324)<br />
Index-Eigenschaft (Row) (Seite 331)<br />
DataIndex-Eigenschaft (Row) (Seite 3<strong>28</strong>)<br />
SafeIndex-Eigenschaft (Row) (Seite 334)<br />
Editor-Eigenschaft (Row)<br />
Ermittelt oder legt den benutzerdefinierten Editor fest, der für die Bearbeitung der Zellen in dieser Zeile<br />
verwendet werden soll.<br />
Syntax<br />
[VB]<br />
Public Editor As Control<br />
[C#]<br />
public Control Editor {get;set;}<br />
[Delphi]<br />
property Editor: Control;<br />
Bemerkungen<br />
Die Tabelle stellt einige integrierte Editoren zur Verfügung, aus denen automatisch einer aufgrund der<br />
Eigenschaften der zu bearbeitenden Zelle ausgewählt wird.
330 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Mit dieser Eigenschaft können Sie für die Bearbeitung der Zellen einer gegebenen Zeile externe Editoren<br />
verwenden. Es kann zwar jede beliebige Steuerung als externer Editor verwendet werden, um aber eine<br />
vollständige Integration mit der Tabelle sicher zustellen, sollte der externe Editor die<br />
IC1EmbeddedEditor-Schnittstelle implementieren.<br />
Für weitere Einzelheiten, schauen Sie bitte unter Editor-Eigenschaft nach.<br />
Schauen Sie ferner unter<br />
Editor-Eigenschaft (Column) (Seite 349)<br />
IC1EmbeddedEditor-Schnittstelle (Seite 446)<br />
Height-Eigenschaft<br />
Ermittelt oder legt die Höhe dieser Zeile in Pixeln fest. Gibt -1 zurück, wenn die Zeile die Standardhöhe<br />
hat.<br />
Syntax<br />
[VB]<br />
Public Height As Integer<br />
[C#]<br />
public int Height {get; set;}<br />
[Delphi]<br />
property Height: Integer;<br />
Bemerkungen<br />
Wenn Height auf -1 gesetzt wird, dann verwendet die Tabelle die Standardhöhe aus Rows.DefaultSize<br />
für diese Zeile.<br />
Height gibt die der Zeile zugeordnete Höhe zurück, auch wenn diese ausgeblendet ist und -1, wenn die<br />
entsprechende Zeile die Standardhöhe besitzt. Verwenden Sie die HeightDisplay-Eigenschaft, um die<br />
wirklich angezeigte und damit sichtbare Höhe einer Zeile abzufragen.<br />
Schauen Sie ferner unter<br />
Row-Klasse (Seite 324)<br />
HeightDisplay-Eigenschaft<br />
Ermittelt oder legt die angezeigte Höhe dieser Zeile in Pixel fest.<br />
Syntax<br />
[VB]<br />
Public HeightDisplay As Integer<br />
[C#]<br />
public int HeightDisplay {get; set;}<br />
[Delphi]<br />
property HeightDisplay: Integer;
Bemerkungen<br />
ImageAlign-Eigenschaft (Row) · 331<br />
HeightDisplay gibt die dem Nutzer wirklich angezeigte Zeilenhöhe unter Berücksichtigung der<br />
Standardhöhe und der Zeilensichtbarkeit zurück. Siehe auch Height-Eigenschaft.<br />
Schauen Sie ferner unter<br />
Row-Klasse (Seite 324)<br />
ImageAlign-Eigenschaft (Row)<br />
Ermittelt oder legt fest, wie Grafiken in scrollbaren Zellen dieser Zeile ausgerichtet werden.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft ImageAlign As C1.Win.<strong>C1FlexGrid</strong>.ImageAlignEnum<br />
[C#]<br />
public ImageAlignEnum ImageAlign {get; set;}<br />
[Delphi]<br />
property ImageAlign: ImageAlignEnum;<br />
Schauen Sie ferner unter<br />
Row-Klasse (Seite 324)<br />
ImageAlign-Eigenschaft (Column) (Seite 352)<br />
ImageAlignFixed-Eigenschaft (Row)<br />
Ermittelt oder legt fest, wie Grafiken in fixierten Zellen dieser Zeile ausgerichtet werden.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft ImageAlignFixed As C1.Win.<strong>C1FlexGrid</strong>.ImageAlignEnum<br />
[C#]<br />
public ImageAlignEnum ImageAlignFixed {get; set;}<br />
[Delphi]<br />
property ImageAlignFixed: ImageAlignEnum;<br />
Schauen Sie ferner unter<br />
Row-Klasse (Seite 324)<br />
ImageAlignFixed-Eigenschaft (Column) (Seite 352)<br />
Index-Eigenschaft (Row)<br />
Gibt den Index dieser Zeile in der Rows-Collection zurück.<br />
Syntax
332 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
[VB]<br />
Public Index As Integer<br />
[C#]<br />
public int Index {get;}<br />
[Delphi]<br />
property Index: Integer;<br />
Bemerkungen<br />
Gibt –1 zurück, wenn die Zeile nicht Mitglied der Collection ist.<br />
Siehe auch SafeIndex- und DataIndex-Eigenschaften.<br />
• Visual Basic<br />
• C#<br />
Dim row As Row = _flex.Rows(12)<br />
Console.WriteLine("*** Row index is {0}", row.Index)<br />
Row row = _flex.Rows[12];<br />
Console.WriteLine("*** Row index is {0}", row.Index);<br />
*** Row index is 12<br />
• Delphi<br />
var<br />
r: Row;<br />
begin<br />
r := _flex.Rows[12];<br />
Console.WriteLine('*** Row index is {0}', r.Index);<br />
end;<br />
Schauen Sie ferner unter<br />
Row-Klasse (Seite 324)<br />
IsNew-Eigenschaft<br />
Zeigt an, dass die Zeile ein Platzhalter für das Hinzufügen von neuen Zeilen zur Tabelle darstellt.<br />
Syntax<br />
[VB]<br />
Public IsNew As Boolean<br />
[C#]<br />
public Bool IsNew {get; set;}<br />
[Delphi]<br />
property IsNew: Boolean;<br />
Bemerkungen<br />
Dies gilt nur für die letzte Zeile in der Tabelle und wenn die AllowAddNew-Eigenschaft auf TRUE steht.<br />
In der ersten fixierten Spalte dieser Zeile steht ein Sternchen („*“).
Schauen Sie ferner unter<br />
Row-Klasse (Seite 324)<br />
IsNode-Eigenschaft<br />
Ermittelt oder legt fest, ob diese Zeile eine Knotenzeile in einer Gliederung ist.<br />
Syntax<br />
[VB]<br />
Public IsNode As Boolean<br />
[C#]<br />
public bool IsNode {get; set;}<br />
[Delphi]<br />
property IsNode: Boolean;<br />
Bemerkungen<br />
IsNode-Eigenschaft · 333<br />
Die IsNode-Eigenschaft legt fest, ob die Zeile einen Knoten in einem Gliederungsbaum darstellt. Sie<br />
können diese Eigenschaft verwenden, um benutzerdefinierte Gliederungen zu erstellen, oder mit der<br />
Subtotal-Methode der Tabelle die Gliederungen automatisch erstellen.<br />
Schauen Sie ferner unter<br />
Row-Klasse (Seite 324)<br />
Node-Eigenschaft<br />
Gibt ein Node-Objekt zurück.<br />
Syntax<br />
[VB]<br />
Public Node As Node<br />
[C#]<br />
public Node Node {get;}<br />
[Delphi]<br />
property Node: Node;<br />
Bemerkungen<br />
Wenn die Zeile ein Knoten ist (IsNode = TRUE), dann gibt diese Eigenschaft ein Node-Objekt zurück,<br />
dass unter anderem dazu verwendet werden kann, diesen Knoten ein- oder auszuklappen oder dessen<br />
Ebene in der Gliederung festzulegen. Wenn die Zeile kein Knoten ist (IsNode = FALSE), dann wird der<br />
Überknoten dieser Zeile zurückgegeben.<br />
Schauen Sie ferner unter<br />
Row-Klasse (Seite 324)
334 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
SafeIndex-Eigenschaft (Row)<br />
Gibt den Index dieser Zeile in der Rows-Collection zurück.<br />
Syntax<br />
[VB]<br />
Public SafeIndex As Integer<br />
[C#]<br />
public int SafeIndex {get;}<br />
[Delphi]<br />
property SafeIndex: Integer;<br />
Bemerkungen<br />
Diese Eigenschaft ist ähnlich der Index-Eigenschaft, nur dass diese eine Exception ausgibt, wenn die<br />
Zeile kein Mitglied der Collection ist.<br />
Schauen Sie ferner unter<br />
Row-Klasse (Seite 324)<br />
Selected-Eigenschaft (Row)<br />
Ermittelt oder legt fest, ob diese Zeile ausgewählt ist.<br />
Syntax<br />
[VB]<br />
Public Selected As Boolean<br />
[C#]<br />
public bool Selected {get; set;}<br />
[Delphi]<br />
property Selected: Boolean;<br />
Bemerkungen<br />
Verwenden Sie diese Eigenschaft um den Auswahlstatus für eine einzelne Zeile abzufragen oder<br />
festzulegen, wenn die SelectionMode-Eigenschaft der Tabelle auf SelectionModeEnum.ListBox steht.<br />
Schauen Sie ferner unter<br />
Row-Klasse (Seite 324)<br />
Style-Eigenschaft (Row)<br />
Ermittelt oder legt fest, welches Format verwendet wird, um die Zeile anzuzeigen.<br />
Syntax<br />
[VB]<br />
Public Style As CellStyle
[C#]<br />
public CellStyle Style {get; set;}<br />
[Delphi]<br />
property Style: CellStyle;<br />
Bemerkungen<br />
StyleDisplay-Eigenschaft (Row) · 335<br />
Wenn die Zeile ein eigenes Format besitzt, dann wird dieses von dieser Eigenschaft zurückgegeben.<br />
Andernfalls wird Null zurückgegeben.<br />
Siehe auch StyleDisplay und StyleNew-Eigenschaften.<br />
Schauen Sie ferner unter<br />
Row-Klasse (Seite 324)<br />
StyleDisplay-Eigenschaft (Row)<br />
Ermittelt das für die Anzeige der Zelle verwendete Format.<br />
Syntax<br />
[VB]<br />
Public StyleDisplay As CellStyle<br />
[C#]<br />
public CellStyle StyleDisplay {get;}<br />
[Delphi]<br />
property StyleDisplay: CellStyle;<br />
Bemerkungen<br />
Wenn die Zeile ein eigenes Format besitzt, dann wird dieses von dieser Eigenschaft zurückgegeben.<br />
Andernfalls wird das für diese Zeile verwendete Standardformat (z.B. Normal, Alternate, Fixed)<br />
wiedergegeben.<br />
Schauen Sie ferner unter<br />
Row-Klasse (Seite 324)<br />
StyleNew-Eigenschaft (Row)<br />
Ermittelt das benutzerdefinierte Format, dass mit dieser Zeile verknüpft ist, und erstellt, wenn nötig, eine<br />
neue Formatvorlage.<br />
Syntax<br />
[VB]<br />
Public StyleNew As CellStyle<br />
[C#]<br />
public CellStyle StyleNew {get;}
336 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
[Delphi]<br />
property StyleNew: CellStyle;<br />
Bemerkungen<br />
Wenn die Zeile ein eigenes Format besitzt, dann wird dieses von dieser Eigenschaft zurückgegeben.<br />
Andernfalls wird ein neues benutzerdefiniertes Format erstellt und ein Verweis auf dieses<br />
wiedergegeben.<br />
Schauen Sie ferner unter<br />
Row-Klasse (Seite 324)<br />
Top-Eigenschaft<br />
Gibt die Position der oberen Grenze dieser Zeile in Pixeln, relativ zur Tabelle zurück. (berücksichtigt<br />
nicht den Bildlauf)<br />
Syntax<br />
[VB]<br />
Public Top As Integer<br />
[C#]<br />
public int Top {get;}<br />
[Delphi]<br />
property Top: Integer;<br />
Bemerkungen<br />
Der zurückgegebene Wert ist die Summe der Zeilenhöhen vom oberen Ende der Tabelle. Um vertikalen<br />
Bildlauf in Betracht zu ziehen, müssen Sie den Wert mit Hilfe der ScrollPosition-Tabelleneigenschaft<br />
anpassen.<br />
Verwenden Sie die GetCellRect-Methode, um die Größe und Position einer Zelle abzufragen.<br />
Schauen Sie ferner unter<br />
Row-Klasse (Seite 324)<br />
UserData-Eigenschaft (Row)<br />
Ermittelt oder legt die mit dieser Zeile verknüpften Benutzerdaten fest.<br />
Syntax<br />
[VB]<br />
Public UserData As Object<br />
[C#]<br />
public object UserData {get; set;}<br />
[Delphi]<br />
property UserData: Object;
Beispiel<br />
Visible-Eigenschaft (Row) · 337<br />
Der nachfolgende Quellcode sucht nach dem einer Zeile zugeordneten UserData und gibt den<br />
entsprechenden Zeilenindex der Fundstelle zurück:<br />
• Visual Basic<br />
• C#<br />
Private Function FindRow(fg As <strong>C1FlexGrid</strong>, data As Object) As Integer<br />
' look for data in Row.UserData<br />
Dim row As Row<br />
For Each row In fg.Rows<br />
If data.Equals(row.UserData) Then<br />
Return row.Index<br />
End If<br />
Next row ' not found<br />
Return - 1<br />
End Function 'FindRow<br />
private int FindRow(<strong>C1FlexGrid</strong> fg, object data)<br />
{<br />
// look for data in Row.UserData<br />
foreach (Row row in fg.Rows)<br />
if (data.Equals(row.UserData))<br />
return row.Index;<br />
}<br />
• Delphi<br />
// not found<br />
return -1;<br />
function Class1.FindRow(fg: <strong>C1FlexGrid</strong>; data: System.Object): Integer;<br />
var<br />
I: Integer;<br />
r: Row;<br />
begin<br />
// look for data in Row.UserData<br />
for I := 0 to fg.Rows.Count – 1 do<br />
if (data.Equals(fg.Rows[I].UserData))<br />
begin<br />
Result := fg.Rows[I].Index;<br />
exit;<br />
end;<br />
// not found<br />
Result := -1;<br />
end;<br />
Bemerkungen<br />
Der UserData-Wert wird von der Tabelle intern nicht verwendet. Dieser ist für zusätzliche Daten<br />
reserviert, die Sie mit der Zeile verknüpfen wollen.<br />
Schauen Sie ferner unter<br />
Row-Klasse (Seite 324)<br />
Visible-Eigenschaft (Row)<br />
Ermittelt oder legt die Sichtbarkeit dieser Zeile fest.
338 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Syntax<br />
[VB]<br />
Public Visible As Boolean<br />
[C#]<br />
public bool Visible {get; set;}<br />
[Delphi]<br />
property Visible: Boolean;<br />
Bemerkungen<br />
Diese Eigenschaft gibt TRUE zurück, wenn die Zeile eine von Null verschiedene Höhe besitzt und auch<br />
wenn diese aus dem sichtbaren Bereich gescrollt wurde. Verwenden Sie hingegen die TopRow- und<br />
BottomRow-Eigenschaften, um festzustellen, ob eine Zeile derzeit auf dem Bildschirm angezeigt wird.<br />
Schauen Sie ferner unter<br />
Row-Klasse (Seite 324)<br />
Row-Methoden<br />
Clear-Methode (Row)<br />
Löscht die Inhalte dieser Zeile.<br />
Syntax<br />
[VB]<br />
Public Sub Clear(clearFlags As ClearFlags)<br />
[C#]<br />
public void Clear (ClearFlags clearFlags )<br />
[Delphi]<br />
procedure Clear(clearFlags: ClearFlags);<br />
Parameter Beschreibung<br />
flags<br />
Bemerkungen<br />
Ein oder mehrere Werte aus der ClearFlags-Aufzählung, die festlegen, was<br />
gelöscht werden soll.<br />
Verwenden Sie diese Methode um die Zeileneigenschaften (Höhe, Sichtbarkeit, Format, Nutzerdaten,<br />
usw.) auf deren Standardwert zurückzusetzen. Diese Methode betrifft nicht die Inhalte der Zellen in der<br />
Zeile.<br />
Schauen Sie ferner unter<br />
Row-Klasse (Seite 324)
Move-Methode (Row)<br />
Verschiebt diese Zeile in der Collection auf eine neue Position.<br />
Syntax<br />
[VB]<br />
Public Sub Move(indexNew As Integer)<br />
[C#]<br />
public void Move ( int indexNew )<br />
[Delphi]<br />
procedure Move(indexNew: Integer);<br />
Parameter Beschreibung<br />
indexNew Eine Integerzahl, welche die neue Position der Zeile festlegt.<br />
Schauen Sie ferner unter<br />
Row-Klasse (Seite 324)<br />
Column-Klassen<br />
Alle Column-Mitglieder<br />
Column-Klasseneigenschaften (public)<br />
Move-Methode (Row) · 339<br />
AllowDragging Ermittelt oder legt fest, ob der Nutzer diese Spalte mit<br />
der Maus ziehen darf.<br />
AllowEditing Ermittelt oder legt fest, ob der Nutzer die Zellen dieser<br />
Spalten bearbeiten darf.<br />
AllowMerging Ermittelt oder legt fest, ob die Zellen mit den<br />
benachbarten Zellen dieser Spalte verbunden werden.<br />
AllowResizing Ermittelt oder legt fest, ob der Nutzer die Größe dieser<br />
Spalte mit der Maus verändern darf.<br />
AllowSorting<br />
Unterstützt vom .NET-Compact-Framework.<br />
Ermittelt oder legt fest, ob diese Spalte mit der Maus<br />
sortiert werden darf.<br />
Caption Ermittelt oder legt den Text der ersten fixierten Zelle in<br />
dieser Spalte fest.<br />
ComboList<br />
Unterstützt vom .NET-Compact-Framework.<br />
Ermittelt oder legt die Liste der Elemente fest, die vom<br />
Auswahllisteneditor für diese Spalte verwendet wird.<br />
DataIndex Gibt die Position dieser Spalte im Datenquellobjekt<br />
zurück.
340 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
DataMap<br />
Unterstützt vom .NET-Compact-Framework.<br />
DataType<br />
Unterstützt vom .NET-Compact-Framework.<br />
EditMask<br />
Unterstützt vom .NET-Compact-Framework.<br />
Ermittelt oder legt die Datenzuordnung fest, um die<br />
Datenwerte in die anzuzeigenden Werte dieser Spalte<br />
umzuwandeln.<br />
Ermittelt oder legt den Datentyp dieser Spalte fest.<br />
Ermittelt oder legt die zu verwendende Eingabemaske<br />
für die Bearbeitung der Zellen in dieser Spalte fest.<br />
Editor Ermittelt oder legt den benutzerdefinierten Editor fest,<br />
der für die Bearbeitung der Zellen in dieser Spalte<br />
verwendet werden soll.<br />
Format<br />
Unterstützt vom .NET-Compact-Framework.<br />
ImageAlign<br />
Unterstützt vom .NET-Compact-Framework.<br />
Ermittelt oder legt eine Zeichenkette fest, die die<br />
Formatierung der Daten in dieser Spalte bestimmt.<br />
Ermittelt oder legt fest, wie Grafiken in scrollbaren<br />
Zellen dieser Spalte ausgerichtet werden.<br />
ImageAlignFixed Ermittelt oder legt fest, wie Grafiken in fixierten Zellen<br />
dieser Spalte ausgerichtet werden.<br />
ImageAndText<br />
Unterstützt vom .NET-Compact-Framework.<br />
ImageMap<br />
Unterstützt vom .NET-Compact-Framework.<br />
Legt fest, ob die Grafiken, die in der ImageMap der<br />
Spalte gefunden werden, anstelle des oder zusätzlich<br />
zum Zelltext angezeigt werden sollen.<br />
Ermittelt oder legt die Datenzuordnung fest, um die<br />
Datenwerte in die anzuzeigenden Grafiken dieser<br />
Spalte umzuwandeln.<br />
Index Gibt den Index dieser Spalte in der Cols-Collection<br />
zurück.<br />
Left<br />
Unterstützt vom .NET-Compact-Framework.<br />
Name<br />
Unterstützt vom .NET-Compact-Framework.<br />
Right<br />
Unterstützt vom .NET-Compact-Framework.<br />
Gibt die Position der linken Seite dieser Spalte in Pixels,<br />
relativ zur Tabelle zurück.<br />
Gibt oder legt den Namen dieser Spalte fest. Der Name<br />
kann als Index im Cols-Eigenschaftsindizierer<br />
verwendet werden.<br />
Gibt die Position der rechten Seite dieser Spalte in<br />
Pixeln, relativ zur Tabelle zurück.<br />
SafeIndex Gibt den Index dieser Spalte in der Column-Collection<br />
zurück.<br />
Selected Ermittelt oder legt fest, ob diese Spalte ausgewählt ist.<br />
Sort<br />
Unterstützt vom .NET-Compact-Framework.<br />
Legt fest, wie diese Spalte sortiert werden soll.<br />
Style Ermittelt oder legt fest, welches Format verwendet wird,<br />
um die Spalte anzuzeigen.<br />
StyleFixed<br />
Unterstützt vom .NET-Compact-Framework.<br />
StyleFixedDisplay<br />
Unterstützt vom .NET-Compact-Framework.<br />
StyleFixedNew<br />
Unterstützt vom .NET-Compact-Framework.<br />
Gibt den Standard CellStyle zurück, mit dem fixierte<br />
Zellen gezeichnet werden.<br />
Gibt das Format zurück, mit dem fixierte Zellen in dieser<br />
Spalte angezeigt werden.<br />
Gibt das benutzerdefinierte Format zurück, das den<br />
fixierten Zellen in dieser Spalte zugeordnet ist.
AllowDragging-Eigenschaft (Column) · 341<br />
StyleNew Gibt das benutzerdefinierte Format zurück, das dieser<br />
Spalte zugeordnet ist.<br />
TextAlign<br />
Unterstützt vom .NET-Compact-Framework.<br />
TextAlignFixed<br />
Unterstützt vom .NET-Compact-Framework.<br />
Ermittelt oder legt fest, wie der Text in den Zellen dieser<br />
Spalte ausgerichtet wird.<br />
Ermittelt oder legt fest, wie der Text in den fixierten<br />
Zellen dieser Spalte ausgerichtet wird.<br />
UserData Ermittelt oder legt die mit dieser Spalte verknüpften<br />
Benutzerdaten fest.<br />
Visible Ermittelt oder legt die Sichtbarkeit dieser Spalte fest.<br />
Width<br />
Unterstützt vom .NET-Compact-Framework.<br />
WidthDisplay<br />
Unterstützt vom .NET-Compact-Framework.<br />
Column-Klassenmethoden (public)<br />
Clear<br />
Unterstützt vom .NET-Compact-Framework.<br />
Ermittelt oder legt die Breite dieser Spalte in Pixeln fest.<br />
Ermittelt oder legt die angezeigte Breite dieser Spalte in<br />
Pixeln fest.<br />
Löscht die Inhalte dieser Spalte.<br />
Move Verschiebt diese Spalte in der Collection auf eine neue<br />
Position.<br />
Column-Eigenschaften<br />
AllowDragging-Eigenschaft (Column)<br />
Ermittelt oder legt fest, ob der Nutzer diese Spalte mit der Maus ziehen darf.<br />
Syntax<br />
[VB]<br />
Public AllowDragging As Boolean<br />
[C#]<br />
public bool AllowDragging {get; set;}<br />
[Delphi]<br />
property AllowDragging: Boolean;<br />
Bemerkungen<br />
Die Tabelle besitzt eine AllowDragging-Eigenschaft, die festlegt, ob Zeilen und Spalten gezogen werden<br />
können. Die AllowDragging-Eigenschaft von Row- und Column-Objekten wird verwendet, um den<br />
Nutzer daran zu hindern, bestimmte Zeilen und Spalten von ihrer eigentlichen Position zu ziehen.<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)
342 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
AllowEditing-Eigenschaft (Column)<br />
Ermittelt oder legt fest, ob der Nutzer die Zellen dieser Spalten bearbeiten darf.<br />
Syntax<br />
[VB]<br />
Public AllowEditing As Boolean<br />
[C#]<br />
public bool AllowEditing {get; set;}<br />
[Delphi]<br />
property AllowEditing: Boolean;<br />
Bemerkungen<br />
Die Tabelle besitzt eine AllowEditing-Eigenschaft, die festlegt, ob Zellen bearbeitet werden können. Die<br />
AllowEditing-Eigenschaft von Row- und Column-Objekten wird verwendet, um den Nutzer daran zu<br />
hindern, Zellen in bestimmten Zeilen und Spalten zu bearbeiten.<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
AllowMerging-Eigenschaft (Column)<br />
Ermittelt oder legt fest, ob die Zellen mit den benachbarten Zellen dieser Spalte verbunden werden.<br />
Syntax<br />
[VB]<br />
Public AllowMerging As Boolean<br />
[C#]<br />
public bool AllowMerging {get; set;}<br />
[Delphi]<br />
property AllowMerging: Boolean;<br />
Bemerkungen<br />
Die Tabelle besitzt eine AllowMerging-Eigenschaft, die festlegt, ob Zellen verbunden werden können.<br />
Die AllowMerging-Eigenschaft von Row- und Column-Objekten wird verwendet, um Zellen mit<br />
angrenzenden Zellen in bestimmten Zeilen und Spalten zu verbinden.<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
AllowResizing-Eigenschaft (Column)<br />
Ermittelt oder legt fest, ob der Nutzer die Größe dieser Spalte mit der Maus verändern darf.
Syntax<br />
[VB]<br />
Public AllowResizing As Boolean<br />
[C#]<br />
public bool AllowResizing {get; set;}<br />
[Delphi]<br />
property AllowResizing: Boolean;<br />
Bemerkungen<br />
AllowSorting-Eigenschaft (Column) · 343<br />
Die Tabelle besitzt eine AllowResizing-Eigenschaft, die festlegt, ob die Größe von Zeilen und Spalten mit<br />
Ziehen der Kanten der Überschriftszelle verändert werden kann. Die AllowResizing-Eigenschaft von<br />
Row- und Column-Objekten wird verwendet, um den Nutzer daran zu hindern, die Größe von<br />
bestimmten Zeilen und Spalten zu ändern.<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
AllowSorting-Eigenschaft (Column)<br />
Ermittelt oder legt fest, ob diese Spalte mit der Maus sortiert werden darf.<br />
Syntax<br />
[VB]<br />
Public AllowSorting As Boolean<br />
[C#]<br />
public bool AllowSorting {get; set;}<br />
[Delphi]<br />
property AllowSorting: Boolean;<br />
Bemerkungen<br />
Die Tabelle besitzt eine AllowSorting-Eigenschaft, die festlegt, ob die Spalten mit einem Klick auf die<br />
Überschriftszellen sortiert werden können. Die AllowSorting-Eigenschaft von Row- und Column-<br />
Objekten wird verwendet, um den Nutzer daran zu hindern, bestimmte Spalten zu sortieren.<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
Caption-Eigenschaft<br />
Ermittelt oder legt den Text der ersten fixierten Zelle in dieser Spalte fest.<br />
Syntax<br />
[VB]<br />
Public Caption As String
344 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
[C#]<br />
public string Caption {get; set;}<br />
[Delphi]<br />
property Caption: string;<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
ComboList-Eigenschaft (Column)<br />
Ermittelt oder legt die Liste der Elemente fest, die vom Auswahllisteneditor für diese Spalte verwendet<br />
wird.<br />
Syntax<br />
[VB]<br />
Public ComboList As String<br />
[C#]<br />
public string ComboList {get; set;}<br />
[Delphi]<br />
property ComboList: string;<br />
Bemerkungen<br />
Für Einzelheiten und Beispiele, schauen Sie bitte unter „Zellen bearbeiten“ (Seite 37)nach.<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
DataIndex-Eigenschaft (Column)<br />
Gibt die Position dieser Spalte im Datenquellobjekt zurück.<br />
Syntax<br />
[VB]<br />
Public DataIndex As Integer<br />
[C#]<br />
public int DataIndex {get;}<br />
[Delphi]<br />
property DataIndex: Integer;<br />
Bemerkungen<br />
In datengebundenen Tabellen besitzt jede Spalte einen Index zur Spalten-Collection (Cols) der Tabelle<br />
und einen Index in die zugrundeliegende Datenquelle. Zum Beispiel, wenn eine Datenquelle drei Spalten
DataMap-Eigenschaft (Column) · 345<br />
umfasst [Erste, Letzte, Mittlere] und Sie binden diese an eine Tabelle mit einer fixierten Spalte, dann<br />
würde die DataIndex-Eigenschaft für jede Spalte wie folgt sein:<br />
Tabellenindex Datenfeld DataIndex<br />
0 (fixiert) -1<br />
1 Erste 0<br />
2 Letzte 1<br />
3 Mittlere 2<br />
Wenn der Nutzer anschließend die letzte Spalte (Mittlere) auf die erste Position zieht, dann würde die<br />
DataIndex-Eigenschaft für jede Spalte wie folgt sein:<br />
Tabellenindex Datenfeld DataIndex<br />
0 (fixiert) -1<br />
1 Mittlere 2<br />
2 Erste 0<br />
3<br />
Anmerkung:<br />
Letzte 1<br />
Diese Eigenschaft gibt –1 zurück, wenn die Zeile fixiert ist.<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
DataMap-Eigenschaft (Column)<br />
Ermittelt oder legt die Datenzuordnung (DataMap) fest, um die Datenwerte in die anzuzeigenden Werte<br />
dieser Spalte umzuwandeln.<br />
Syntax<br />
[VB]<br />
Public DataMap As IDictionary<br />
[C#]<br />
public IDictionary DataMap {get; set;}<br />
[Delphi]<br />
property DataMap: IDictionary;<br />
Bemerkungen<br />
Mit der DataMap-Eigenschaft können Sie „übersetzte” Spalten implementieren. In übersetzten Spalten<br />
zeigt die Tabelle nicht die in der Zelle gespeicherten Werte an, sondern schlägt diese in der DataMap der<br />
Spalte nach und zeigt die verknüpften Werte an.<br />
Zum Beispiel können Sie die DataMap-Eigenschaft verwenden, um Produktschlüssel zu speichern, aber<br />
stattdessen Produktnamen anzuzeigen:
346 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
• Visual Basic<br />
• C#<br />
Dim employeeMap As New Hashtable()<br />
Dim e As Employee<br />
For Each e In EmployeeCollection<br />
employeeMap.Add(e.ID, e.LastName)<br />
Next e<br />
flex.Cols(1).DataType = GetType(Employee)<br />
flex.Cols(1).DataMap = employeeMap '<br />
Hashtable employeeMap = new Hashtable();<br />
foreach (Employee e in EmployeeCollection)<br />
employeeMap.Add(e.ID, e.LastName);<br />
flex.Cols[1].DataType = typeof(Employee);<br />
flex.Cols[1].DataMap = employeeMap;<br />
• Delphi<br />
var<br />
employeeMap: Hashtable;<br />
I: Integer;<br />
e: Employee;<br />
begin<br />
employeeMap := Hashtable.Create;<br />
for I := 0 to EmployeeCollection.Count – 1 do<br />
begin<br />
e := Employee(EmployeeCollection[I]);<br />
employeeMap.Add(System.Object(e.ID), System.Object(e.LastName));<br />
end;<br />
flex.Cols[1].DataType := TypeOf(Employee);<br />
flex.Cols[1].DataMap := employeeMap;<br />
end;<br />
Die Tabelle verwendet die DataMap-Eigenschaft auch um die Auswahllisten zu füllen, wenn die Spalte<br />
bearbeitbar ist.<br />
Anmerkung: Die IDictionary-Schnittstelle ist im System.Collections-Namensbereich definiert und wird<br />
unter anderem von der Hashtable-Klasse implementiert.<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
DataType-Eigenschaft<br />
Ermittelt oder legt den Datentyp dieser Spalte fest.<br />
Syntax<br />
[VB]<br />
Public DataType As Type<br />
[C#]<br />
public Type DataType {get; set;}<br />
[Delphi]<br />
property DataType: Type;
Bemerkungen<br />
DataType-Eigenschaft · 347<br />
Standardmäßig ist die DataType-Eigenschaft der Spalte auf object gesetzt, so dass Sie jeden beliebigen<br />
Datenwert in der Spalte speichern können.<br />
Wenn Sie DataType der Spalte auf einen bestimmten Typ setzen, dann wird die Tabelle versuchen, jeden<br />
der Zellen dieser Spalte zugeordneten Werte in den entsprechenden Datentyp umzuwandeln. Wenn die<br />
Umwandlung fehlschlägt, dann startet die Tabelle das GridError-Ereignis und der entsprechende<br />
Zellwert bleibt unverändert.<br />
Die DataType-Eigenschaft steuert, wie Werte intern in die Tabelle gespeichert werden, wie diese<br />
gespeichert werden und betrifft den Steuerungstyp, der verwendet wird, um die Werte dieser Spalte zu<br />
bearbeiten. Zum Beispiel, eine DateTimePicker-Steuerung wird verwendet um Werte in DateTime-<br />
Spalten zu bearbeiten und Kontrollkästchen sind dafür da, um Wahrheitswerte in bearbeitbaren Boolean-<br />
Spalten anzuzeigen.<br />
Wenn Sie eine Zeit anstatt einem Datum in den Zellen einer Spalte speichern wollen, dann können Sie<br />
immer noch den DateTime-Type verwenden. Sie sollten aber ein Format aussuchen, dass nur die Zeiten<br />
und nicht das Datum anzeigt. Sie sollten außerdem verhindern, dass die Steuerung den DateTimePicker-<br />
Editor verwendet, wenn die Spalte bearbeitbar ist. Dies kann erreicht werden, indem eine EditMask<br />
verwendet wird oder der Editor im SetupEditor-Ereignis angepasst wird. Zum Beispiel:<br />
• Visual Basic<br />
• C#<br />
' store times in column 1, use masked editor<br />
fg.Cols(1).DataType = GetType(DateTime) '<br />
fg.Cols(1).Format = "hh:mm tt"<br />
fg.Cols(1).EditMask = "99:99 LL"<br />
' store times in column 2, use DateTimePicker but prevent drop-down<br />
fg.Cols(2).DataType = GetType(DateTime) '<br />
fg.Cols(2).Format = "hh:mm tt"<br />
Private Sub fg_SetupEditor(sender As Object, e As RowColEventArgs)<br />
If e.Col = 2 Then<br />
Dim ctl As DateTimePicker = flex.Editor '<br />
If Not (ctl Is Nothing) Then<br />
ctl.ShowUpDown = True<br />
End If<br />
End If<br />
End Sub 'fg_SetupEditor<br />
' store times in column 1, use masked editor<br />
fg.Cols[1].DataType=typeof(DateTime);<br />
fg.Cols[1].Format="hh:mm tt";<br />
fg.Cols[1].EditMask="99:99 LL";<br />
' store times in column 2, use DateTimePicker but prevent drop-down<br />
fg.Cols[2].DataType=typeof(DateTime);<br />
fg.Cols[2].Format="hh:mm tt";<br />
private void fg_SetupEditor(object sender, RowColEventArgs e)<br />
{<br />
if (e.Col == 2)<br />
{<br />
DateTimePicker ctl = flex.Editor as DateTimePicker;<br />
if (ctl != null)<br />
ctl.ShowUpDown = true;<br />
}<br />
}
348 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
• Delphi<br />
// store times in column 1, use masked editor<br />
fg.Cols[1].DataType := typeof(DateTime);<br />
fg.Cols[1].Format := 'hh:mm tt';<br />
fg.Cols[1].EditMask := '99:99 LL';<br />
// store times in column 2, use DateTimePicker but prevent drop-down<br />
fg.Cols[2].DataType := typeof(DateTime);<br />
fg.Cols[2].Format := 'hh:mm tt';<br />
procedure fg_SetupEditor(sender: System.Object; e: RowColEventArgs);<br />
var<br />
ctl: DateTimePicker;<br />
begin<br />
if e.Col = 2 then<br />
begin<br />
if ctl is DateTimePicker then<br />
begin<br />
ctl := DateTimePicker(flex.Editor);<br />
ctl.ShowUpDown := True;<br />
end;<br />
end;<br />
end; // fg_SetupEditor<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
EditMask-Eigenschaft (Column)<br />
Ermittelt oder legt die zu verwendende Eingabemaske für die Bearbeitung der Zellen in dieser Spalte<br />
fest.<br />
Syntax<br />
[VB]<br />
Public EditMask As String<br />
[C#]<br />
public string EditMask {get; set;}<br />
[Delphi]<br />
property EditMask: string;<br />
Bemerkungen<br />
Die Tabelle besitzt auch eine EditMask-Eigenschaft, die auf die gesamte Tabelle angewandt wird.<br />
Schauen Sie unter der EditMask-Eigenschaft der Tabelle und „Zellen bearbeiten“ (Seite 37) für<br />
Einzelheiten über das Festlegen und die Verwendung von Eingabemasken nach.<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)
Editor-Eigenschaft (Column)<br />
Editor-Eigenschaft (Column) · 349<br />
Ermittelt oder legt den benutzerdefinierten Editor fest, der für die Bearbeitung der Zellen in dieser Spalte<br />
verwendet werden soll.<br />
Syntax<br />
[VB]<br />
Public Editor As Control<br />
[C#]<br />
public Control Editor {get;set;}<br />
[Delphi]<br />
property Editor: Control;<br />
Bemerkungen<br />
Die Tabelle stellt einige integrierte Editoren zur Verfügung, aus denen automatisch einer aufgrund der<br />
Eigenschaften der zu bearbeitenden Zelle ausgewählt wird.<br />
Mit dieser Eigenschaft können Sie für die Bearbeitung der Zellen einer gegebenen Spalte externe Editoren<br />
verwenden. Es kann zwar jede beliebige Steuerung als externer Editor verwendet werden, um aber eine<br />
vollständige Integration mit der Tabelle sicherzustellen, sollte der externe Editor die<br />
IC1EmbeddedEditor-Schnittstelle implementieren.<br />
Sie können externe Editoren mit Spalten während der Designtime im Column Editor oder während der<br />
Runtime verknüpfen.<br />
Für weitere Einzelheiten, schauen Sie bitte unter Editor-Eigenschaft nach.<br />
Schauen Sie ferner unter<br />
Editor-Eigenschaft (Row) (Seite 329)<br />
IC1EmbeddedEditor-Schnittstelle (Seite 446)<br />
Format-Eigenschaft<br />
Ermittelt oder legt eine Zeichenkette fest, welche die Formatierung der Daten in dieser Spalte bestimmt.<br />
Syntax<br />
[VB]<br />
Public Format As String<br />
[C#]<br />
public string Format {get; set;}<br />
[Delphi]<br />
property Format: string;
350 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Bemerkungen<br />
Die Format-Eigenschaft legt zwar fest, wie Werte für die Anzeige formatiert werden, betrifft aber nicht<br />
die intern gespeicherten Werte. Verwenden Sie die GetDataDisplay-Eigenschaft, um die formatierten<br />
Werte von Zellen abzurufen.<br />
Die Format-Zeichenkette besitzt die gleiche Semantik wie die Formatierungsargumente in der .NET<br />
String.Format-Methode. Für Einzelheiten und ein vollständiges Beispiel schauen Sie bitte in der .NET<br />
Dokumentation nach. Eine kurze Übersicht über die am häufigsten verwendeten Optionen wird<br />
nachfolgend gegeben.<br />
Formatierung von numerischen Werten<br />
Die folgenden Zeichenketten können verwendet werden, um Zahlen zu formatieren:<br />
Zeichenkette Name Beschreibung<br />
C oder c Währung Die Zahl wird in eine Zeichenkette umgewandelt, die einen<br />
angepassten Währungsbetrag anzeigt.<br />
E oder e Exponentialzahl Die Zahl wird in eine Zeichenkette der Form "-d.ddd…E+ddd" oder<br />
"-d.ddd…e+ddd" umgewandelt, wobei jedes 'd' für eine Zahl<br />
zwischen 0 und 9 steht.<br />
F oder f Gleitkommazahl Die Zahl wird in eine Zeichenkette umgewandelt, die eine<br />
Gleitkommazahl mit einer festgelegten Anzahl an Dezimalstellen<br />
anzeigt.<br />
N oder n Nummer Die Zahl wird in eine Zeichenkette umgewandelt, die eine<br />
Kommazahl mit einer festgelegten Anzahl an Dezimalstellen und<br />
1000er-Trennzeichen anzeigt.<br />
P oder p Prozentzahl Die Zahl wird in eine Zeichenkette umgewandelt, die eine<br />
Prozentzahl anzeigt.<br />
Mit den folgenden Zeichen können Sie auch eigene Formate erstellen:<br />
Zeichen Name Beschreibung<br />
0 Nullplatzhalter Wenn ein formatierter Wert eine Ziffer an der Stelle besitzt, wo die<br />
Formatierungszeichenkette eine Null aufweist, dann wird diese Ziffer<br />
in die endgültige Zeichenkette kopiert. Die Position der am weitesten<br />
links stehenden '0' vor dem Dezimalpunkt und die am weitesten<br />
rechts stehende '0' nach dem Dezimalpunkt legt den Ziffernbereich<br />
(Stellenanzahl) der endgültigen Zeichenkette fest.<br />
# Ziffernplatzhalter Wenn ein formatierter Wert eine Ziffer an der Stelle besitzt, wo die<br />
Formatierungszeichenkette ein ’#’ aufweist, dann wird diese Ziffer in<br />
die endgültige Zeichkette kopiert. Andernfalls wird keine Ziffer an<br />
dieser Stelle der endgültigen Zeichenkette gespeichert.<br />
. Dezimalpunkt Das erste '.'-Zeichen in der Formatierungszeichenkette legt die<br />
Position des lokal angepassten Dezimaltrennzeichens im formatierten<br />
Wert fest. Jedes weitere '.'-Zeichen wird ignoriert.<br />
, 1000er-<br />
Trennzeichen<br />
1000er-Trennzeichen werden zwischen jeder Dreiergruppe an Ziffern,<br />
beginnend links neben dem Dezimaltrennzeichen, eingefügt. Wenn<br />
die formatierte Zeichenkette ein oder mehrere ','-Zeichen direkt links
Format-Eigenschaft · 3<strong>51</strong><br />
neben dem Dezimalpunkt besitzt, dann wird die Zahl durch die<br />
Anzahl der ','-Zeichen, multipliziert mit 1000, geiteilt, bevor diese<br />
formatiert wird.<br />
% Prozentplatzhalter Wenn die Formatierungszeichenkette ein '%'-Zeichen enthält, dann<br />
wir die Zahl mit 100 multipliziert, bevor sie formatiert wird.<br />
; Abschnittstrennzeichen<br />
Formatierung von Datumswerten<br />
Das ';'-Zeichen wird verwendet, um Abschnitte für positive, negative<br />
und Nullwerte in der Formatierungszeichenkette abzugrenzen.<br />
Die folgenden Zeichenketten können verwendet werden, um Zeit und Datum zu formatieren:<br />
String Name<br />
d Kurzes Datum<br />
D Langes Datum<br />
t Kurze Zeit<br />
T Lange Zeit<br />
Mit den folgenden Zeichen können Sie auch eigene Formate erstellen:<br />
Zeichen Beschreibung<br />
d Zeigt den aktuellen Tag des Monats an, als eine Zahl zwischen 1 und 31. Wenn der Tag<br />
nur eine Ziffer (1-9) hat, dann wird auch nur eine angezeigt.<br />
dd Zeigt den aktuellen Tag des Monats an, als eine Zahl zwischen 1 und 31. Wenn der Tag<br />
nur eine Ziffer hat, dann wird diese mit einer voranstehenden 0 (01-09) angezeigt.<br />
ddd Zeigt den abgekürzten Namen des Tages an.<br />
dddd Zeigt den vollständigen Namen des Tages an.<br />
M Zeigt den aktuellen Monat an, als eine Zahl zwischen 1 und 12. Wenn der Monat nur eine<br />
Ziffer (1-9) hat, dann wird auch nur eine angezeigt.<br />
MM Zeigt den aktuellen Monat an, als eine Zahl zwischen 1 und 12. Wenn der Monat nur eine<br />
Ziffer hat, dann wird dieser mit einer voranstehenden 0 (01-09) angezeigt.<br />
MMM Zeigt den abgekürzten Namen des Monats an.<br />
MMMM Zeigt den vollständigen Namen des Monats an.<br />
y Zeigt das Jahr in maximal zwei Ziffern an. Die ersten zwei Ziffern werden unterdrückt.<br />
Wenn das Jahr nur eine Ziffer (1-9) hat, dann wird auch nur eine angezeigt.<br />
yy Zeigt das Jahr in zwei Zifern an. Die ersten zwei Ziffern werden unterdrückt. Wenn das<br />
Jahr nur eine Ziffer hat, dann wird dieses mit einer voranstehenden 0 (01-09) angezeigt.<br />
yyyy Zeigt die vollständige Jahreszahl mit vier Ziffern an.<br />
/ Ortsgebundenes Datumstrennzeichen.
352 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
ImageAlign-Eigenschaft (Column)<br />
Ermittelt oder legt fest, wie Grafiken in scrollbaren Zellen dieser Spalte ausgerichtet werden.<br />
Syntax<br />
[VB]<br />
Public ImageAlign As ImageAlignEnum<br />
[C#]<br />
public ImageAlignEnum ImageAlign {get; set;}<br />
[Delphi]<br />
property ImageAlign: ImageAlignEnum;<br />
Bemerkungen<br />
Diese Eigenschaft verknüpft zu dem, dieser Spalte zugeordneten CellStyle. Zum Beispiel:<br />
• Visual Basic<br />
• C#<br />
flex.Cols(1).ImageAlign = ImageAlignEnum.RightTop '<br />
Console.WriteLine(flex.Cols(1).Style.ImageAlign)<br />
ImageAlignEnum.RightTop<br />
flex.Cols[1].ImageAlign = ImageAlignEnum.RightTop;<br />
Console.WriteLine(flex.Cols[1].Style.ImageAlign);<br />
ImageAlignEnum.RightTop<br />
• Delphi<br />
flex.Cols[1].ImageAlign := ImageAlignEnum.RightTop;<br />
Console.WriteLine(flex.Cols[1].Style.ImageAlign);<br />
ImageAlignEnum.RightTop;<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
ImageAlign-Eigenschaft (Row) (Seite 331)<br />
ImageAlignFixed-Eigenschaft (Column)<br />
Ermittelt oder legt fest, wie Grafiken in fixierten Zellen dieser Spalte ausgerichtet werden.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft ImageAlignFixed As C1.Win.<strong>C1FlexGrid</strong>.ImageAlignEnum<br />
[C#]<br />
public ImageAlignEnum ImageAlignFixed {get; set;}
[Delphi]<br />
property ImageAlignFixed: ImageAlignEnum;<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
ImageAlignFixed-Eigenschaft (Row) (Seite 331)<br />
ImageAndText-Eigenschaft<br />
ImageAndText-Eigenschaft · 353<br />
Legt fest, ob die Grafiken, die in der ImageMap der Spalte gefunden werden, anstelle oder zusätzlich<br />
zum Zelltext angezeigt werden sollen.<br />
Syntax<br />
[VB]<br />
Public ImageAndText As Boolean<br />
[C#]<br />
public bool ImageAndText {get; set;}<br />
[Delphi]<br />
property ImageAndText: Boolean;<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
ImageMap-Eigenschaft (Column) (Seite 353)<br />
ImageMap-Eigenschaft (Column)<br />
Ermittelt oder legt die Datenzuordnung fest, um die Datenwerte in die anzuzeigenden Grafiken dieser<br />
Spalte umzuwandeln.<br />
Syntax<br />
[VB]<br />
Public ImageMap As IDictionary<br />
[C#]<br />
public IDictionary ImageMap {get; set;}<br />
[Delphi]<br />
property ImageMap: IDictionary;<br />
Bemerkungen<br />
Verwenden Sie diese Eigenschaft um Datenwerte in einer Spalte mit Grafiken zu verknüpfen. Zum<br />
Beispiel, wenn eine Spalte Ländernamen beinhaltet, dann können Sie diese Eigenschaft verwenden, um<br />
die entsprechend dazugehörige Länderfahne anzuzeigen.<br />
Verwenden Sie die ImageAndText-Eigenschaft um festzulegen, ob die Steuerung die Grafik zusätzlich<br />
oder anstelle des Zelltextes anzeigen soll.
354 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Der nachfolgende Quellcode zeigt, wie Sie ein ImageMap für eine Spalte einrichten können. Das Beispiel<br />
geht davon aus, dass Sie eine ImageList-Steuerung erstellt und diese mit den Grafiken der Länderfahnen<br />
gefüllt haben:<br />
• Visual Basic<br />
• C#<br />
Private Enum Countries<br />
Australia<br />
Brazil<br />
Canada<br />
Denmark<br />
France<br />
Germany<br />
Italy<br />
Japan<br />
Korea<br />
Mexico<br />
Netherlands<br />
Portugal<br />
Russia<br />
Spain<br />
Turkey<br />
USA<br />
End Enum 'Countries<br />
' set up image map<br />
Dim imgMap As New Hashtable()<br />
For i = 0 To imgListFlags.Images.Count - 1<br />
imgMap.Add(CType(i, Countries), imgListFlags.Images(i))<br />
Next i<br />
Dim col As Column = flex.Cols("countries")<br />
col.ImageMap = imgMap<br />
col.ImageAndText = False<br />
col.ImageAlign = ImageAlignEnum.CenterCenter<br />
private enum Countries<br />
{<br />
Australia, Brazil, Canada, Denmark, France,<br />
Germany, Italy, Japan, Korea, Mexico,<br />
Netherlands, Portugal, Russia, Spain, Turkey, USA<br />
};<br />
// set up image map<br />
Hashtable imgMap = new Hashtable();<br />
for (i = 0; i < imgListFlags.Images.Count; i++)<br />
imgMap.Add((Countries)i, imgListFlags.Images[i]);<br />
Column col = flex.Cols["countries"];<br />
col.ImageMap = imgMap;<br />
col.ImageAndText = false;<br />
col.ImageAlign = ImageAlignEnum.CenterCenter;<br />
• Delphi<br />
type<br />
Countries = (Australia, Brazil, Canada, Denmark, France, Germany,<br />
Italy, Japan, Korea, Mexico, Netherlands, Portugal, Russia, Spain,<br />
Turkey, USA);<br />
var<br />
col: Column;<br />
imgMap: Hashtable;<br />
begin<br />
imgMap := Hashtable.Create;
for i := 0 to imgListFlags.Images.Count – 1 do<br />
imgMap.Add(System.Object(i), imgListFlags.Images[i]);<br />
col := flex.Cols['countries'];<br />
col.ImageMap := imgMap;<br />
col.ImageAndText := False;<br />
col.ImageAlign := ImageAlignEnum.CenterCenter;<br />
end;<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
Index-Eigenschaft (Column)<br />
Gibt den Index dieser Spalte in der Cols-Collection zurück.<br />
Syntax<br />
[VB]<br />
Public Index As Integer<br />
[C#]<br />
public int Index {get;}<br />
[Delphi]<br />
property Index: Integer;<br />
Bemerkungen<br />
Gibt –1 zurück, wenn die Spalte nicht Mitglied der Collection ist.<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
SafeIndex-Eigenschaft (Column) (Seite 357)<br />
Left-Eigenschaft<br />
Index-Eigenschaft (Column) · 355<br />
Gibt die Position der linken Seite dieser Spalte in Pixeln, relativ zur Tabelle zurück. (berücksichtigt nicht<br />
den Bildlauf)<br />
Syntax<br />
[VB]<br />
Public Left As Integer<br />
[C#]<br />
public int Left {get;}<br />
[Delphi]<br />
property Left: Integer;<br />
Bemerkungen
356 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Der zurückgegebene Wert ist die Summe der Spaltenbreiten von der linken Seite der Tabelle. Um<br />
horizontalen Bildlauf in Betracht zu ziehen, müssen Sie den Wert mit Hilfe der ScrollPosition-<br />
Tabelleneigenschaft anpassen.<br />
Verwenden Sie die GetCellRect-Methode, um die Größe und Position einer Zelle abzufragen.<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
Name-Eigenschaft (Column)<br />
Gibt oder legt den Namen dieser Spalte zurück/fest. Der Name kann als Index im Cols-<br />
Eigenschaftsindizierer verwendet werden.<br />
Syntax<br />
[VB]<br />
Public Name As String<br />
[C#]<br />
public string Name {get; set;}<br />
[Delphi]<br />
property Name: string;<br />
Bemerkungen<br />
Wenn die Tabelle an eine DataSource gebunden ist, dann werden die Spaltennamen automatisch gesetzt.<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
Right-Eigenschaft<br />
Gibt die Position der rechten Seite dieser Spalte in Pixeln, relativ zur Tabelle zurück. (berücksichtigt nicht<br />
den Bildlauf)<br />
Syntax<br />
[VB]<br />
Public Right As Integer<br />
[C#]<br />
public int Right {get;}<br />
[Delphi]<br />
property Right: Integer;<br />
Bemerkungen<br />
Der zurückgegebene Wert ist die Summe der Spaltenbreiten von der linken Seite der Tabelle. Um<br />
horizontalen Bildlauf in Betracht zu ziehen, müssen Sie den Wert mit Hilfe der ScrollPosition-<br />
Tabelleneigenschaft anpassen.
SafeIndex-Eigenschaft (Column) · 357<br />
Verwenden Sie die GetCellRect-Methode, um die Größe und Position einer Zelle abzufragen.<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
SafeIndex-Eigenschaft (Column)<br />
Gibt den Index dieser Spalte in der Column-Collection zurück.<br />
Syntax<br />
[VB]<br />
Public SafeIndex As Integer<br />
[C#]<br />
public int SafeIndex {get;}<br />
[Delphi]<br />
property SafeIndex: Integer;<br />
Bemerkungen<br />
Diese Eigenschaft ist ähnlich der Index-Eigenschaft, nur dass diese eine Exception ausgibt, wenn die<br />
Spalte kein Mitglied der Collection ist.<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
Selected-Eigenschaft (Column)<br />
Ermittelt oder legt fest, ob diese Spalte ausgewählt ist.<br />
Syntax<br />
[VB]<br />
Public Selected As Boolean<br />
[C#]<br />
public bool Selected {get; set;}<br />
[Delphi]<br />
property Selected: Boolean;<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
Sort-Eigenschaft (Column)<br />
Legt fest, wie diese Spalte sortiert werden soll.
358 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Syntax<br />
[VB]<br />
Public Sort As SortFlags<br />
[C#]<br />
public SortFlags Sort {get; set;}<br />
[Delphi]<br />
property Sort: SortFlags;<br />
Bemerkungen<br />
Diese Eigenschaft wird verwendet, wenn Sie die Sort-Methode aufrufen und die SortFlags.UseColSort-<br />
Flag nutzen.<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
Sort-Eigenschaft (<strong>C1FlexGrid</strong>Classic) (Seite <strong>51</strong>8)<br />
Style-Eigenschaft (Column)<br />
Ermittelt oder legt fest, welches Format verwendet wird, um die Spalte anzuzeigen.<br />
Syntax<br />
[VB]<br />
Public Style As CellStyle<br />
[C#]<br />
public CellStyle Style {get; set;}<br />
[Delphi]<br />
property Style: CellStyle;<br />
Bemerkungen<br />
Wenn die Spalte ein eigenes Format besitzt, dann wird es von dieser Eigenschaft zurückgegeben.<br />
Andernfalls wird Null wiedergegeben.<br />
Siehe auch StyleDisplay und StyleNew-Eigenschaften.<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
StyleDisplay-Eigenschaft (Column)<br />
Ermittelt das Format, welches verwendet wird, um die scrollbaren Zellen in dieser Spalte anzuzeigen<br />
Syntax<br />
[VB]<br />
Public StyleDisplay As CellStyle
[C#]<br />
public CellStyle StyleDisplay {get;}<br />
[Delphi]<br />
property StyleDisplay: CellStyle;<br />
Bemerkungen<br />
StyleFixed-Eigenschaft · 359<br />
Wenn die Spalte ein eigenes Format besitzt, dann wird es von dieser Eigenschaft zurückgegeben.<br />
Andernfalls wird das für diese Spalte verwendete Standardformat (z.B. Normal, Alternate, Fixed)<br />
wiedergegeben.<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
StyleFixed-Eigenschaft<br />
Gibt den Standard CellStyle zurück, mit dem fixierte Zellen gezeichnet werden.<br />
Syntax<br />
[VB]<br />
Public StyleFixed As CellStyle<br />
[C#]<br />
public CellStyle StyleFixed {get;}<br />
[Delphi]<br />
property StyleFixed: CellStyle;<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
Styles-Eigenschaft (Seite 170)<br />
StyleFixedDisplay-Eigenschaft<br />
Gibt das Format zurück, mit dem fixierte Zellen in dieser Spalte angezeigt werden.<br />
Syntax<br />
[VB]<br />
Public StyleFixedDisplay As CellStyle<br />
[C#]<br />
public CellStyle StyleFixedDisplay {get;}<br />
[Delphi]<br />
property StyleFixedDisplay: CellStyle;
360 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Bemerkungen<br />
Wenn die Spalte ein eigenes Format für ihre fixierte Zellen besitzt, dann wird es von dieser Eigenschaft<br />
zurückgegeben. Andernfalls wird das für diese Spalte verwendete Standardformat (z.B. Normal,<br />
Alternate, Fixed) wiedergegeben.<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
StyleFixedNew-Eigenschaft<br />
Gibt das benutzerdefinierte Format zurück, das den fixierten Zellen in dieser Spalte zugeordnet ist.<br />
Syntax<br />
[VB]<br />
Public StyleFixedNew As CellStyle<br />
[C#]<br />
public CellStyle StyleFixedNew {get;}<br />
[Delphi]<br />
property StyleFixedNew: CellStyle;<br />
Bemerkungen<br />
Wenn die Spalte ein eigenes Format für ihre fixierten Zellen besitzt, dann wird es von dieser Eigenschaft<br />
zurückgegeben. Andernfalls wird ein neues benutzerdefiniertes Format erstellt und ein Verweis auf<br />
dieses wiedergegeben.<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
StyleNew-Eigenschaft (Column)<br />
Ermittelt das benutzerdefinierte Format, das mit dieser Spalte verknüpft ist, und erstellt, wenn nötig, eine<br />
neue Formatvorlage.<br />
Syntax<br />
[VB]<br />
Public StyleNew As CellStyle<br />
[C#]<br />
public CellStyle StyleNew {get;}<br />
[Delphi]<br />
property StyleNew: CellStyle;<br />
Bemerkungen<br />
Wenn die Spalte ein eigenes Format besitzt, dann wird es von dieser Eigenschaft zurückgegeben.<br />
Andernfalls wird ein neues benutzerdefiniertes Format erstellt und ein Verweis auf dieses<br />
wiedergegeben.
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
TextAlign-Eigenschaft (Column)<br />
Ermittelt oder legt fest, wie der Text in den Zellen dieser Spalte ausgerichtet wird.<br />
Syntax<br />
[VB]<br />
Public TextAlign As TextAlignEnum<br />
[C#]<br />
public TextAlignEnum TextAlign {get; set;}<br />
[Delphi]<br />
property TextAlign: TextAlignEnum;<br />
Bemerkungen<br />
TextAlign-Eigenschaft (Column) · 361<br />
Diese Eigenschaft verknüpft mit dieser Spalte den zugeordneten CellStyle. Zum Beispiel:<br />
• Visual Basic<br />
• C#<br />
flex.Cols(1).TextAlign = TextAlignEnum.RightTop '<br />
Console.WriteLine(flex.Cols(1).Style.TextAlign)<br />
flex.Cols[1].TextAlign = TextAlignEnum.RightTop;<br />
Console.WriteLine(flex.Cols[1].Style.TextAlign);<br />
TextAlignEnum.RightTop<br />
• Delphi<br />
flex.Cols[1].TextAlign := TextAlignEnum.RightTop;<br />
Console.WriteLine(flex.Cols[1].Style.TextAlign);<br />
TextAlignEnum.RightTop;<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
TextAlignFixed-Eigenschaft<br />
Ermittelt oder legt fest, wie der Text in den fixierten Zellen dieser Spalte ausgerichtet wird.<br />
Syntax<br />
[VB]<br />
Public TextAlignFixed As TextAlignEnum<br />
[C#]<br />
public TextAlignEnum TextAlignFixed {get; set;}<br />
[Delphi]<br />
property TextAlignFixed: TextAlignEnum;
362 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Bemerkungen<br />
Diese Eigenschaft verknüpft mit dieser Spalte den zugeordneten CellStyle. Zum Beispiel:<br />
• Visual Basic<br />
• C#<br />
flex.Cols(1).TextAlign = TextAlignEnum.RightTop '<br />
Console.WriteLine(flex.Cols(1).StyleFixed.TextAlign)<br />
flex.Cols[1].TextAlign = TextAlignEnum.RightTop;<br />
Console.WriteLine(flex.Cols[1].StyleFixed.TextAlign);<br />
TextAlignEnum.RightTop<br />
• Delphi<br />
flex.Cols[1].TextAlign := TextAlignEnum.RightTop;<br />
Console.WriteLine(flex.Cols[1].StyleFixed.TextAlign);<br />
TextAlignEnum.RightTop;<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
UserData-Eigenschaft (Column)<br />
Ermittelt oder legt die mit dieser Spalte verknüpften Benutzerdaten fest.<br />
Syntax<br />
[VB]<br />
Public UserData As Object<br />
[C#]<br />
public object UserData {get; set;}<br />
[Delphi]<br />
property UserData: Object;<br />
Bemerkungen<br />
Der UserData-Wert wird von der Tabelle intern nicht verwendet. Dieser ist für zusätzliche Daten<br />
reserviert, die Sie mit der Spalte verknüpfen wollen.<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
Visible-Eigenschaft (Column)<br />
Ermittelt oder legt die Sichtbarkeit dieser Spalte fest.<br />
Syntax<br />
[VB]<br />
Public Visible As Boolean<br />
[C#]
public bool Visible {get; set;}<br />
[Delphi]<br />
property Visible: Boolean;<br />
Bemerkungen<br />
Width-Eigenschaft (Column) · 363<br />
Diese Eigenschaft gibt TRUE zurück, wenn die Spalte eine von Null verschiedene Breite besitzt und auch<br />
wenn diese aus dem sichtbaren Bereich gescrollt wurde. Verwenden Sie hingegen die LeftCol- und<br />
RightCol-Eigenschaften, um festzustellen, ob eine Zeile derzeit auf dem Bildschirm angezeigt wird.<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
Width-Eigenschaft (Column)<br />
Ermittelt oder legt die Breite dieser Spalte in Pixeln fest. Gibt–1 zurück, wenn die Spalte die<br />
Standardbreite besitzt.<br />
Syntax<br />
[VB]<br />
Public Width As Integer<br />
[C#]<br />
public int Width {get; set;}<br />
[Delphi]<br />
property Width: Integer;<br />
Bemerkungen<br />
Wenn Width auf -1 gesetzt wird, dann verwendet die Tabelle die Standardbreite aus Cols.DefaultSize<br />
für diese Spalte.<br />
Width gibt die der Spalte zugeordnete Breite zurück, auch wenn diese ausgeblendet ist und -1, wenn die<br />
entsprechende Spalte die Standardbreite besitzt. Verwenden Sie die WidthDisplay-Eigenschaft, um die<br />
wirklich angezeigte und damit sichtbare Breite einer Spalte abzufragen.<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
WidthDisplay-Eigenschaft<br />
Ermittelt oder legt die angezeigte Breite dieser Spalte in Pixeln fest.<br />
Syntax<br />
[VB]<br />
Public WidthDisplay As Integer<br />
[C#]<br />
public int WidthDisplay {get; set;}
364 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
[Delphi]<br />
property WidthDisplay: Integer;<br />
Bemerkungen<br />
WidthDisplay gibt die dem Nutzer wirklich angezeigte Spaltenbreite unter Berücksichtigung der<br />
Standardbreite und der Spaltensichtbarkeit zurück. Siehe auch Width-Eigenschaft.<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
Column-Methoden<br />
Clear-Methode (Column)<br />
Löscht die Inhalte dieser Spalte.<br />
Syntax<br />
[VB]<br />
Public Sub Clear(clearFlags As ClearFlags)<br />
[C#]<br />
public void Clear (ClearFlags clearFlags )<br />
[Delphi]<br />
procedure Clear(clearFlags: ClearFlags);<br />
Parameter Beschreibung<br />
flags<br />
Bemerkungen<br />
Ein oder mehrere Werte aus der ClearFlags-Aufzählung, die festlegen, was<br />
gelöscht werden soll.<br />
Verwenden Sie diese Methode um die Spalteneigenschaften (Breite, Sichtbarkeit, Format, Nutzerdaten,<br />
usw.) auf deren Standardwert zurückzusetzen. Diese Methode betrifft nicht den Inhalt der Zellen in der<br />
Spalte.<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
Move-Methode (Column)<br />
Verschiebt diese Spalte in der Collection auf eine neue Position.<br />
Syntax<br />
[VB]<br />
Public Sub Move(indexNew As Integer)
[C#]<br />
public void Move ( int indexNew )<br />
[Delphi]<br />
procedure Move(indexNew: Integer);<br />
Parameter Beschreibung<br />
indexNew Eine Integerzahl, welche die neue Position der Spalte festlegt.<br />
Schauen Sie ferner unter<br />
Column-Klasse (Seite 339)<br />
CellStyleCollection-Klasse<br />
Move-Methode (Column) · 365<br />
Diese Klasse verwaltet die für das Rendern der Tabelle verwendete Collection der CellStyle-Objekte. Es<br />
gibt zwei Zellformattypen: Standard (Stock) und benutzerdefinierte (Custom).<br />
Standardformat<br />
Standardformatvorlagen werden von der Tabelle erstellt. Sie können zwar deren Eigenschaften<br />
verändern, aber diese weder löschen noch erstellen. Zellformate sind hierarchisch (ähnlich den<br />
„cascadierenden Stylesheets“). Alle Formatvorlagen basieren auf dem Standardformat Normal. Jegliche<br />
Änderungen, die Sie in der Normal-Formatvorlage vornehmen, werden von allen anderen<br />
Formatvorlagen geerbt, außer wenn die spezielle Eigenschaft explizit im abgeleiteten Format<br />
überschrieben wird. Zum Beispiel, wenn Sie die Font-Eigenschaft des Formats Normal ändern, dann<br />
werden alle fixierten und markierten Zellen die neue Schriftart verwenden, da die Fixed- und Highlight-<br />
Formatevolagen standardmäßig keinen eigenen Wert für ihre Font-Eigenschaft besitzen.<br />
Das Erbverhalten von Formatvorlagen wird von der Tabelle auch für das dynamische Kombinieren von<br />
Formaten verwendet. Zum Beispiel, eine könnte eine ausgewählte Zelle in einer geraden, scrollbaren<br />
Zeile mit dem Selected-Format formatiert werden und damit vom Alternate- und Normal-Fomat erben.<br />
Die von der Tabelle definierten Standardformate lauten: Normal, Fixed, Alternate, Highlight,<br />
EmptyArea, Focus, Search, GrandTotal und Subtotal0 bis Subtotal5.<br />
Sie können die Standardformate mit den Eigenschaften aus der Styles-Collection oder mit einem der<br />
Indizierer (z.B. Styles.Normal, Styles[0], Styles[CellStyleEnum.Normal], Styles["Normal"]) ansprechen.<br />
Benutzerdefinierte Format<br />
Benutzerdefinierte Formate werden mit der Add-Methode aus der Styles-Collection erstellt und können<br />
über die diese Styles-Collection per Name oder Index angesprochen werden. Sie können auf Row-,<br />
Column- und CellRange-Objekte angewandt werden. Außerdem gilt für benutzerdefinierte Formate das<br />
gleiche Erbverhalten wie für Standardformate. Zum Beispiel, wenn Sie ein benutzerdefiniertes Format<br />
mit dem Namen „Small Number“ erstellen, dessen BackColor-Eigenschaft auf rot setzen und alle<br />
anderen Eigenschaften unveränder lassen, dann wird diese Zelle mit diesem Format die Font- und<br />
ForeGround-Eigenschaften aus dem entsprechenden, dem Row- oder Column-Objekten zugeordnen<br />
Format erben. (entweder von Normal, Alternate, Focus, Highlight oder ein anderes benutzerdefiniertes<br />
Format)
366 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Alle CellStyleCollection-Mitglieder<br />
CellStyleCollection-Klasseneigenschaften (public)<br />
Alternate<br />
Unterstützt vom .NET-Compact-Framework.<br />
Count<br />
Unterstützt vom .NET-Compact-Framework.<br />
Gibt den für das Zeichnen alternierender Zeilen<br />
verwendeten CellStyle zurück.<br />
Gibt die Anzahl der Formate in der Collection zurück.<br />
Editor Gibt den für das Zeichnen von Zellen während deren<br />
Bearbeitung verwendeten CellStyle zurück.<br />
EmptyArea<br />
Unterstützt vom .NET-Compact-Framework.<br />
Fixed<br />
Unterstützt vom .NET-Compact-Framework.<br />
Focus<br />
Unterstützt vom .NET-Compact-Framework.<br />
Gibt den für das Zeichnen leerer Tabellenbereiche<br />
verwendeten CellStyle zurück.<br />
Gibt den für das Zeichnen fixierter Zellen (nicht<br />
scrollbar) verwendeten CellStyle zurück.<br />
Gibt den für das Zeichnen aktiver Zellen verwendeten<br />
CellStyle zurück, wenn die Tabelle den Fokus hat.<br />
Frozen Gibt den für das Zeichnen eingefrorener Zellen<br />
verwendeten Standard CellStyle zurück.<br />
Highlight<br />
Unterstützt vom .NET-Compact-Framework.<br />
Item<br />
Unterstützt vom .NET-Compact-Framework.<br />
Gibt den, für das Markieren von ausgewählten Zellen<br />
verwendeten Standard CellStyle zurück.<br />
Gibt einen Verweis auf ein Format in der Collection<br />
zurück.<br />
NewRow Integriertes Format der Vorlage für eine neue Zeile<br />
(nur verfügbar, wenn AllowAddNew auf TRUE steht).<br />
Normal<br />
Unterstützt vom .NET-Compact-Framework.<br />
Search<br />
Unterstützt vom .NET-Compact-Framework.<br />
CellStyleCollection-Klassenmethoden (public)<br />
Add<br />
Unterstützt vom .NET-Compact-Framework.<br />
BuildString<br />
Unterstützt vom .NET-Compact-Framework.<br />
Clear<br />
Unterstützt vom .NET-Compact-Framework.<br />
Gibt den für gewöhnliche, scrollbare Zellen<br />
verwendeten CellStyle zurück.<br />
Gibt den für die aktuelle Zelle während laufendem<br />
AutoSearch verwendeten CellStyle zurück.<br />
Fügt der Collection ein benutzerdefiniertes Format<br />
hinzu.<br />
Gibt eine kompakte Zeichenkette mit allen in der<br />
Collection enthaltenen Formaten zurück.<br />
Entfernt alle benutzerdefinierten Formatvorlagen aus<br />
der Collection und setzt die Standardformate auf deren<br />
Standardwerte zurück.<br />
ClearUnused Dies löscht unbenannte und ungenutze Formate.<br />
Contains<br />
Unterstützt vom .NET-Compact-Framework.<br />
ParseString<br />
Unterstützt vom .NET-Compact-Framework.<br />
Remove<br />
Unterstützt vom .NET-Compact-Framework.<br />
Prüft die Collection, ob diese ein bestimmtes Format<br />
mit einem gegebenen Namen enthält.<br />
Erstellt die Style-Collection neu, basierend auf der in<br />
einer Zeichenkette enthaltenen Beschreibung.<br />
Löscht ein benutzerdefiniertes Format aus der<br />
Collection.
CellStyleCollection-Eigenschaften<br />
Alternate-Eigenschaft<br />
Gibt den für das Zeichnen alternierender Zeilen verwendeten CellStyle zurück.<br />
Syntax<br />
[VB]<br />
Public Alternate As CellStyle<br />
[C#]<br />
public CellStyle Alternate {get;}<br />
[Delphi]<br />
property Alternate: CellStyle;<br />
Schauen Sie ferner unter<br />
CellStyleCollection-Klasse (Seite 365)<br />
Count-Eigenschaft (CellStyleCollection)<br />
Gibt die Anzahl der Formate in der Collection zurück.<br />
Syntax<br />
[VB]<br />
Public Count As Integer<br />
[C#]<br />
public int Count {get;}<br />
[Delphi]<br />
property Count: Integer;<br />
Schauen Sie ferner unter<br />
CellStyleCollection-Klasse (Seite 365)<br />
Editor-Eigenschaft (CellStyleCollection)<br />
Alternate-Eigenschaft · 367<br />
Gibt den für das Zeichnen von Zellen während deren Bearbeitung verwendeten CellStyle zurück.<br />
Syntax<br />
[VB]<br />
Public Editor As CellStyle<br />
[C#]<br />
public CellStyle Editor {get;}
368 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
[Delphi]<br />
property Editor: CellStyle;<br />
Bemerkungen<br />
Elemente in diesem Format werden auf aktive Zellen in der Editorsteuerung angewendet. Nicht alle<br />
Editoren unterstützen alle Formatelemente. Die meisten Editoren unterstützen aber zumindest die<br />
BackColor-, ForeColor- und Font-Eigenschaften.<br />
Schauen Sie ferner unter<br />
CellStyleCollection-Klasse (Seite 365)<br />
EmptyArea-Eigenschaft<br />
Gibt den für das Zeichnen leerer Tabellenbereiche verwendeten CellStyle zurück.<br />
Syntax<br />
[VB]<br />
Public EmptyArea As CellStyle<br />
[C#]<br />
public CellStyle EmptyArea {get;}<br />
[Delphi]<br />
property EmptyArea: CellStyle;<br />
Bemerkungen<br />
Es werden nur die BackColor- und Border-Elemente von dieser Formatvorlage verwendet. Diese legt das<br />
Format für den Bereich zwischen der letzten Zelle und dem Rahmen der Steuerung fest.<br />
Das Border.Color-Element legt die Farbe der Rahmenlinien um die Kanten des Arbeitsblatts und<br />
zwischen eingefrorenen und scrollbaren Zellen fest.<br />
Schauen Sie ferner unter<br />
CellStyleCollection-Klasse (Seite 365)<br />
Frozen-Eigenschaft<br />
Gibt den für das Zeichnen eingefrorener Zellen verwendeten Standard CellStyle zurück.<br />
Syntax<br />
[VB]<br />
Public Frozen As CellStyle<br />
[C#]<br />
public CellStyle Frozen {get;}<br />
[Delphi]<br />
property Frozen: CellStyle;
Schauen Sie ferner unter<br />
CellStyleCollection-Klasse (Seite 365)<br />
AllowFreezing-Eigenschaft (Seite 120)<br />
Fixed-Eigenschaft (CellStyleCollection)<br />
Fixed-Eigenschaft (CellStyleCollection) · 369<br />
Gibt den für das Zeichnen fixierter Zellen (nicht scrollbar) verwendeten CellStyle zurück.<br />
Syntax<br />
[VB]<br />
Public Fixed As CellStyle<br />
[C#]<br />
public CellStyle Fixed {get;}<br />
[Delphi]<br />
property Fixed: CellStyle;<br />
Schauen Sie ferner unter<br />
CellStyleCollection-Klasse (Seite 365)<br />
Focus-Eigenschaft<br />
Gibt den für das Zeichnen aktiver Zellen verwendeten CellStyle zurück, wenn die Tabelle den Fokus hat.<br />
Syntax<br />
[VB]<br />
Public Focus As CellStyle<br />
[C#]<br />
public CellStyle Focus {get;}<br />
[Delphi]<br />
property Focus: CellStyle;<br />
Schauen Sie ferner unter<br />
CellStyleCollection-Klasse (Seite 365)<br />
Highlight-Eigenschaft (CellStyleCollection)<br />
Gibt den für das Markieren von ausgewählten Zellen verwendeten Standard CellStyle zurück.<br />
Syntax<br />
[VB]<br />
Public Highlight As CellStyle
370 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
[C#]<br />
public CellStyle Highlight {get;}<br />
[Delphi]<br />
property Highlight: CellStyle;<br />
Schauen Sie ferner unter<br />
CellStyleCollection-Klasse (Seite 365)<br />
Item-Eigenschaft (CellStyleCollection)<br />
Gibt einen Verweis auf ein Format in der Collection zurück. Gibt Null zurück, wenn das Format nicht<br />
gefunden werden kann.<br />
Syntax<br />
[VB]<br />
Public Item (index As Integer) As CellStyle<br />
Public Item(index As CellStyleEnum) As CellStyle<br />
Public Item(name As String) As CellStyle<br />
[C#]<br />
public CellStyle this[int styleIndex]<br />
public CellStyle this[CellStyleEnum styleType]<br />
public CellStyle this[string styleName]<br />
[Delphi]<br />
property Item(index: Integer): CellStyle;<br />
property Item(index: CellStyleEnum): CellStyle;<br />
property Item(name: string): CellStyle;<br />
Schauen Sie ferner unter<br />
CellStyleCollection-Klasse (Seite 365)<br />
NewRow-Eigenschaft<br />
Integriertes Format der Vorlage für eine neue Zeile (nur verfügbar, wenn AllowAddNew auf TRUE<br />
steht).<br />
Syntax<br />
[VB]<br />
Public NewRow As CellStyle<br />
[C#]<br />
public CellStyle NewRow {get; }
[Delphi]<br />
property NewRow: CellStyle;<br />
Bemerkungen<br />
Normal-Eigenschaft · 371<br />
Zum Beispiel, der nachfolgende Quellcode lässt eine Vorlage für eine neue Zeile mit einem gelben<br />
Hintergrund anzeigen:<br />
• Visual Basic<br />
• C#<br />
_flex.Styles.NewRow.BackColor = Color.Yellow<br />
_flex.Styles.NewRow.BackColor = Color.Yellow;<br />
• Delphi<br />
_flex.Styles.NewRow.BackColor := Color.Yellow;<br />
Schauen Sie ferner unter<br />
CellStyleCollection-Klasse (Seite 365)<br />
Normal-Eigenschaft<br />
Gibt den für gewöhnliche, scrollbare Zellen verwendeten CellStyle zurück.<br />
Syntax<br />
[VB]<br />
Public Normal As CellStyle<br />
[C#]<br />
public CellStyle Normal {get;}<br />
[Delphi]<br />
property Normal: CellStyle;<br />
Bemerkungen<br />
Dies ist das Mutterformat für die meisten Zellen. Wenn die BackColor-, ForeColor- oder Font-<br />
Eigenschaften der Steuerung auf automatisch stehen, dann wird immer die entsprechende Eigenschaft<br />
aus dem Normal-Format verwendet.<br />
Wenn Sie eine beliebige Eigenschaft im Normal-Format ändern, dann wird diese Änderung in allen<br />
weiteren Formatvorlagen, die diese Eigenschaft nicht explizit überschreiben, sichtbar sein. Zum Beispiel,<br />
der nachfolgende Quellcode legt eine gewöhnliche „Arial“-Schriftart für alle Zellen der Tabelle,<br />
Fettschrift für fixierte und Unterstreichung für fokussierte Zellen fest:<br />
• Visual Basic<br />
• C#<br />
flex.Styles.Normal.Font = New Font("Arial", 9)<br />
flex.Styles.Fixed.Font = New Font("Arial", 9, FontStyle.Bold)<br />
flex.Styles.Focus.Font = New Font("Arial", 9, FontStyle.Underline)<br />
flex.Styles.Normal.Font = new Font("Arial", 9);<br />
flex.Styles.Fixed.Font = new Font("Arial", 9, FontStyle.Bold);<br />
flex.Styles.Focus.Font = new Font("Arial", 9, FontStyle.Underline);
372 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
• Delphi<br />
flex.Styles.Normal.Font := Font.Create('Arial', 9);<br />
flex.Styles.Fixed.Font := Font.Create('Arial', 9, FontStyle.Bold);<br />
flex.Styles.Focus.Font := Font.Create('Arial', 9, FontStyle.Underline);<br />
Schauen Sie ferner unter<br />
CellStyleCollection-Klasse (Seite 365)<br />
Search-Eigenschaft<br />
Gibt den für die aktuelle Zelle bei laufendem AutoSearch verwendeten CellStyle zurück.<br />
Syntax<br />
[VB]<br />
Public Search As CellStyle<br />
[C#]<br />
public CellStyle Search {get;}<br />
[Delphi]<br />
property Search: CellStyle;<br />
Bemerkungen<br />
Siehe auch AutoSearch-Eigenschaft.<br />
Schauen Sie ferner unter<br />
CellStyleCollection-Klasse (Seite 365)<br />
CellStyleCollection-Methoden<br />
Add-Methode (CellStyleCollection)<br />
Fügt der Collection ein benutzerdefiniertes Format hinzu.<br />
Syntax<br />
[VB]<br />
Public Function Add(name As String) As CellStyle<br />
Public Function Add(name As String, basedOn As CellStyle) As CellStyle<br />
[C#]<br />
public CellStyle Add (String name )<br />
public CellStyle Add (String name , CellStyle basedOn )<br />
[Delphi]<br />
function Add(name: string): CellStyle;<br />
function Add(name: string; basedOn: CellStyle): CellStyle;
Parameter Beschreibung<br />
styleName<br />
basedOn<br />
Bemerkungen<br />
BuildString-Methode · 373<br />
Der Name des neuen Formats. Der Name muss in der Collection einzigartig sein<br />
und darf nur alphanumerische Zeichen oder Leerzeichen enthalten.<br />
Eine existierende Formatvorlage, von welcher das hinzugefügte Format erbt. Wenn<br />
dieser Paramter nicht gesetzt wird, dann basiert das neue Format auf dem<br />
Standardformat Normal.<br />
Wenn der styleName-Parameter zur Verfügung gestellt wird, dann muss dieser einzigartig sein und darf<br />
keine geschweiften Klammern ("{" oder "}") enthalten.<br />
Wenn der styleName-Parameter auf Null steht, dann wird ein einzigartiges „anonymous“-Format<br />
erstellt. Dieser Formattyp wird nicht der Style-Collection hinzugefügt und kann daher nicht per Name<br />
oder Index angesprochen werden. Dies ist in Anwendungen nützlich, die ihre eigenen Style-Collections<br />
erstellen und verwalten.<br />
Schauen Sie ferner unter<br />
CellStyleCollection-Klasse (Seite 365)<br />
BuildString-Methode<br />
Gibt eine kompakte Zeichenkette mit allen in der Collection enthaltenen Formaten zurück.<br />
Syntax<br />
[VB]<br />
Public Function BuildString(includeEmpty As Boolean) As String<br />
[C#]<br />
public String BuildString (Boolean includeEmpty )<br />
[Delphi]<br />
function BuildString(includeEmpty: Boolean): string;<br />
Parameter Beschreibung<br />
includeEmpties<br />
Bemerkungen<br />
Ein Wahrheitswert, der festlegt, ob leere Formate bei der Zeichenkettendefinition<br />
berücksichtigt werden sollen. Leere Formate haben zwar Namen, definieren aber<br />
keinerlei Eigenschaften. Diese können als Platzhalter verwendet werden.<br />
Zeichenketten, die mit der BuildString-Methode erstellt werden, können später mit der ParseString-<br />
Methode verwendet werden. Somit können Style-Collections als Vorlagen schnell und einfach<br />
gespeichert und angewendet werden (auch als „Skins“ bekannt).
374 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Schauen Sie ferner unter<br />
CellStyleCollection-Klasse (Seite 365)<br />
Clear-Methode (CellStyleCollection)<br />
Entfernt alle benutzerdefinierten Formatvorlagen aus der Collection und setzt die Standardformate auf<br />
deren Standardwerte zurück.<br />
Syntax<br />
[VB]<br />
Public Sub Clear()<br />
[C#]<br />
public void Clear ( )<br />
[Delphi]<br />
procedure Clear;<br />
Bemerkungen<br />
Die Clear-Methode entfernt auch alle benutzerdefinierten Formatvorlagen, die derzeit für Zeilen, Spalten<br />
und Zellen verwendet werden.<br />
Schauen Sie ferner unter<br />
CellStyleCollection-Klasse (Seite 365)<br />
ClearUnused-Methode<br />
Dies löscht unbenannte und ungenutze Formate.<br />
Syntax<br />
[VB]<br />
Public Sub ClearUnused()<br />
[C#]<br />
public void ClearUnused ( )<br />
[Delphi]<br />
procedure ClearUnused;<br />
Bemerkungen<br />
Diese Methode wird genutzt, wenn ein Format mit StyleNew erstellt wurde, dann aber auf keine Zeile,<br />
Spalte oder einen Zellbereich angewendet wurde.<br />
Schauen Sie ferner unter<br />
CellStyleCollection-Klasse (Seite 365)<br />
Contains-Methode (CellStyleCollection)<br />
Prüft die Collection, ob diese ein bestimmtes Format mit einem gegebenen Namen enthält.
Syntax<br />
[VB]<br />
Public Function Contains(name As String) As Boolean<br />
[C#]<br />
public Boolean Contains (String name )<br />
[Delphi]<br />
function Contains(name: string): Boolean;<br />
Schauen Sie ferner unter<br />
CellStyleCollection-Klasse (Seite 365)<br />
ParseString-Methode (CellStyleCollection)<br />
ParseString-Methode (CellStyleCollection) · 375<br />
Erstellt die Style-Collection neu, basierend auf der in einer Zeichenkette enthaltenen Beschreibung.<br />
Syntax<br />
[VB]<br />
Public Function ParseString(str As String) As Boolean<br />
[C#]<br />
public Boolean ParseString (String str )<br />
[Delphi]<br />
function ParseString(str: string): Boolean;<br />
Parameter Beschreibung<br />
styleDefinition<br />
Bemerkungen<br />
Eine von einer Zelle an die BuildString-Methode zurückgegebene Zeichenkette,<br />
die eine Beschreibung von einer Style-Collection enthält.<br />
Die ParseString-Methode entfernt keine existierenden Formatvorlagen, wenn sie nicht in der<br />
Zeichenkette mit den Formatdefinitionen enthalten ist. Verwenden Sie die Clear-Methode bevor Sie<br />
ParseString aufrufen, um die aktuelle Style-Collection zurückzusetzen.<br />
Schauen Sie ferner unter<br />
CellStyleCollection-Klasse (Seite 365)<br />
Remove-Methode (CellStyleCollection)<br />
Löscht ein benutzerdefiniertes Format aus der Collection.<br />
Syntax<br />
[VB]<br />
Public Sub Remove(index As Integer)
376 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Public Sub Remove(style As CellStyle)<br />
[C#]<br />
public void Remove ( int index )<br />
public void Remove (CellStyle style )<br />
[Delphi]<br />
procedure Remove(index: Integer);<br />
procedure Remove(style: CellStyle);<br />
Parameter Beschreibung<br />
index<br />
Der Index des zu entfernenden Formats. Da die Formatvorlage ein<br />
benutzerdefiniertes Format sein muss, ist der Index dieser größer oder gleich<br />
(int)CellStyleEnum FirstCustomStyle.<br />
name Der Name des zu entfernenden Formats.<br />
Bemerkungen<br />
Nur benutzerdefinierte Formate können aus der Collection entfernt werden. Die Remove-Methode<br />
entfernt benutzerdefinierte Formate aus der Collection und von jeder Zeile, Spalte oder Zelle, die dieses<br />
zu löschende Format verwendet.<br />
Schauen Sie ferner unter<br />
CellStyleCollection-Klasse (Seite 365)<br />
CellStyle-Klasse<br />
CellStyle-Objekte beinhalten Formatierungsinformationen für das Rendern der Tabellenzellen. Diese<br />
Informationen betreffen unter anderem die Hintergrund- und Vordergrundfarben, die Schriftart und die<br />
Text- und Grafikausrichtung. Die Styles-Eigenschaft verwaltet die Collection aller Formatvorlagen der<br />
Tabelle und besitzt Methoden, mit denen Sie Formatvorlagen der Tabelle erstellen und entfernen können.<br />
Einzelne Formate können auf CellRange-, Row- und Column-Objekte angewendet werden.<br />
Formate folgen, ähnlich wie bei Formatvorlagen in Microsoft Word oder in „cascadierenden Stylesheets“,<br />
einem hierarchischen Model. Die Eigenschaft in einem CellStyle-Objekt müssen nicht zwingend<br />
festgelegt werden, so dass deren Werte aus den Mutterformaten geerbt werden. Das Mutterformat ist für<br />
gewöhnlich das Standardformat Normal. Verwenden Sie die DefinedElements-Eigenschaft, um<br />
festzulegen, welche Elemente in einer bestimmten Formatvorlage definiert werden.<br />
Wenn Sie eine Eigenschaft eines CellStyle-Objekts verändern, dann werden alle Zellen, die dieses Format<br />
verwenden, neu gezeichnet, um die Änderungen zu übernehmen.<br />
Alle CellStyle-Mitglieder<br />
CellStyle-Klasseneigenschaften (public)<br />
BackColor<br />
Unterstützt vom .NET-Compact-Framework.<br />
Ermittelt oder legt die Hintergrundfarbe der Zelle fest.
Border<br />
Unterstützt vom .NET-Compact-Framework.<br />
Remove-Methode (CellStyleCollection) · 377<br />
Gibt das für den Zellrahmen verwendete CellBorder-<br />
Objekt zurück.<br />
ComboList Ermittelt oder legt die ComboList fest, die für die<br />
Bearbeitung der Zelle verwendet werden soll.<br />
DataMap Ermittelt oder legt die Datenzuordnung fest, um die<br />
anzuzeigenden Zeichenketten mit den Datenwerten<br />
dieser Zelle zu verknüpfen.<br />
DefinedElements<br />
Unterstützt vom .NET-Compact-Framework.<br />
Ermittelt oder legt die in diesem CellStyle definierten<br />
Elemente fest.<br />
Display Ermittelt oder legt fest, ob in der Zelle Text und/oder<br />
Grafiken angezeigt werden und wie diese angeordnet<br />
werden sollen.<br />
EditMask Ermittelt oder legt die zu verwendende Eingabemaske<br />
für die Bearbeitung der Zelle fest.<br />
Editor Ermittelt oder legt den benutzerdefinierten Editor fest,<br />
der für die Bearbeitung der Zelle verwendet werden<br />
soll.<br />
Font<br />
Unterstützt vom .NET-Compact-Framework.<br />
ForeColor<br />
Unterstützt vom .NET-Compact-Framework.<br />
Ermittelt oder legt die Schriftart des Textes in der Zelle<br />
fest.<br />
Ermittelt oder legt die Schriftfarbe des Textes in der<br />
Zelle fest.<br />
Format Ermittelt oder legt das Format fest, um Zellwerte in<br />
anzuzeigende Zeichenketten umzuwandeln.<br />
ImageAlign<br />
Unterstützt vom .NET-Compact-Framework.<br />
Ermittelt oder legt die Ausrichtung von Grafiken in einer<br />
Zelle fest.<br />
ImageMap Ermittelt oder erstellt das ImageMap, um Zellwerte mit<br />
in dieser Zelle anzuzeigenden Grafiken zu verknüpfen.<br />
ImageSpacing<br />
Unterstützt vom .NET-Compact-Framework.<br />
Margins<br />
Unterstützt vom .NET-Compact-Framework.<br />
Name<br />
Unterstützt vom .NET-Compact-Framework.<br />
TextAlign<br />
Unterstützt vom .NET-Compact-Framework.<br />
Ermittelt oder legt den Abstand in Pixeln zwischen der<br />
Grafik und dem Text in der Zelle fest.<br />
Ermittelt oder legt den Abstand in Pixeln zwischen den<br />
Zellkanten und dem Zellinhalt fest.<br />
Ermittelt oder legt den Name für diesen CellStyle fest.<br />
Ermittelt oder legt die Ausrichtung des Textes in einer<br />
Zelle fest.<br />
TextDirection Hiermit kann Text in vertikaler Richtung angezeigt<br />
werden (auf- oder abwärts orientiert).<br />
TextEffect<br />
Unterstützt vom .NET-Compact-Framework.<br />
Trimming<br />
Unterstützt vom .NET-Compact-Framework.<br />
Ermittelt oder legt den 3D-Effekt für den Text in der<br />
Zelle fest.<br />
Legt fest, wie Texte beschnitten werden, wenn diese zu<br />
lang für die Zelle sind.<br />
UserData Ermittelt oder legt willkürliche Daten für diesen<br />
CellStyle fest.
378 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
WordWrap<br />
Unterstützt vom .NET-Compact-Framework.<br />
CellStyle-Klassenmethoden (public)<br />
BuildString<br />
Unterstützt vom .NET-Compact-Framework.<br />
Clear<br />
Unterstützt vom .NET-Compact-Framework.<br />
Legt fest, ob lange Zeichenketten in der Zelle<br />
umgebrochen werden.<br />
Gibt eine kompakte Zeichenkette zurück, die diesen<br />
CellStyle darstellt.<br />
Entfernt ausgewählte Elemente aus diesem CellStyle.<br />
MergeWith Kopiert alle in einem Quell-CellStyle definierten<br />
Elemente in diese Formatvorlage. Formatelemente, die<br />
nicht in diesem CellStyle enthalten sind, werden<br />
bewahrt.<br />
ParseString<br />
Unterstützt vom .NET-Compact-Framework.<br />
Erstellt diesen CellStyle neu, basierend auf der in einer<br />
Zeichenkette enthaltenen Beschreibung.<br />
Render Rendert Zeichenketten und Grafiken mit den in diesem<br />
CellStyle definierten Attributen in ein Graphics-Objekt.<br />
CellStyle-Eigenschaften<br />
BackColor-Eigenschaft<br />
Ermittelt oder legt die Hintergrundfarbe der Zelle fest.<br />
Syntax<br />
[VB]<br />
Public BackColor As Color<br />
[C#]<br />
public Color BackColor {get; set;}<br />
[Delphi]<br />
property BackColor: Color;<br />
Schauen Sie ferner unter<br />
CellStyle-Klasse (Seite 376)<br />
Border-Eigenschaft<br />
Gibt das für den Zellrahmen verwendete CellBorder-Objekt zurück.<br />
Syntax<br />
[VB]<br />
Public Border As CellBorder
[C#]<br />
public CellBorder Border {get;}<br />
[Delphi]<br />
property Border: CellBorder;<br />
Bemerkungen<br />
ComboList-Eigenschaft (CellStyle) · 379<br />
Mit dem CellBorder-Objekt können Sie den Rahmentyp, dessen Farbe und die Dicke einstellen.<br />
Schauen Sie ferner unter<br />
CellStyle-Klasse (Seite 376)<br />
ComboList-Eigenschaft (CellStyle)<br />
Ermittelt oder legt die ComboList fest, die für die Bearbeitung der Zelle verwendet werden soll.<br />
Syntax<br />
[VB]<br />
Public ComboList As String<br />
[C#]<br />
public string ComboList {get; set}<br />
[Delphi]<br />
property ComboList: string;<br />
Bemerkungen<br />
• Visual Basic<br />
• C#<br />
Dim s As CellStyle = _flex.Styles.Add("TheList")<br />
s.ComboList = "Fiat|Mercedes|Porsche|Pontiac"<br />
Dim r As CellRange = _flex.GetCellRange(10, 10)<br />
rg.Style = s<br />
CellStyle s = _flex.Styles.Add("TheList");<br />
s.ComboList = "Fiat|Mercedes|Porsche|Pontiac";<br />
CellRange r = _flex.GetCellRange(10,10);<br />
rg.Style = s;<br />
• Delphi<br />
var<br />
r: CellRange;<br />
s: CellStyle;<br />
begin<br />
s := _flex.Styles.Add('TheList');<br />
s.ComboList := 'Fiat|Mercedes|Porsche|Pontiac';<br />
r := _flex.GetCellRange(10, 10);<br />
rg.Style := s;<br />
end;<br />
Schauen Sie ferner unter<br />
CellStyle-Klasse (Seite 376)
380 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
DataMap-Eigenschaft (CellStyle)<br />
Ermittelt oder legt die Datenzuordnung fest, um die anzuzeigenden Zeichenketten mit den Datenwerten<br />
einzelner Zellen und Zellbereiche zu verknüpfen (als Alternative zur Anwendung auf die gesamte<br />
Tabelle, oder auf Zeilen oder Spalten, was immer noch verfügbar ist).<br />
Syntax<br />
[VB]<br />
Public DataMap As IDictionary<br />
[C#]<br />
public IDictionary DataMap {get; set;}<br />
[Delphi]<br />
property DataMap: IDictionary;<br />
Bemerkungen<br />
Für Einzelheiten und Beispiele schauen Sie bitte unter der Column.DataMap-Eigenschaft nach.<br />
Schauen Sie ferner unter<br />
CellStyle-Klasse (Seite 376)<br />
DefinedElements-Eigenschaft<br />
Ermittelt oder legt die, in diesem CellStyle definierten Elemente fest (alle andern Elemente werden vom<br />
Mutterformat geerbt).<br />
Syntax<br />
[VB]<br />
Public DefinedElements As StyleElementFlags<br />
[C#]<br />
public StyleElementFlags DefinedElements {get; set;}<br />
[Delphi]<br />
property DefinedElements: StyleElementFlags;<br />
Bemerkungen<br />
Elemente, die in einer Formatvorlage nicht definiert sind, werden automatisch vom Mutterformat geerbt<br />
(für gewöhnlich das Format Normal). Zum Beispiel, wenn Sie ein benutzerdefiniertes Format erstellen<br />
und die Font-Eigenschaft festlegen, dann werden alle weiteren Elemente, wie Hintergrundfarbe und<br />
Ausrichtung, aus der Formatvorlage Normal geerbt.<br />
Schauen Sie ferner unter<br />
CellStyle-Klasse (Seite 376)
Display-Eigenschaft<br />
Display-Eigenschaft · 381<br />
Ermittelt oder legt fest, ob in der Zelle Text und/oder Grafiken angezeigt und wie diese angeordnet<br />
werden sollen.<br />
Syntax<br />
[VB]<br />
Public Display As DisplayEnum<br />
[C#]<br />
public DisplayEnum Display {get; set;}<br />
[Delphi]<br />
property Display: DisplayEnum;<br />
Schauen Sie ferner unter<br />
CellStyle-Klasse (Seite 376)<br />
Editor-Eigenschaft (CellStyle)<br />
Ermittelt oder legt den benutzerdefinierten Editor fest, der für die Bearbeitung der Zelle verwendet<br />
werden soll.<br />
Syntax<br />
[VB]<br />
Public Editor As Control<br />
[C#]<br />
public Control Editor {get;set;}<br />
[Delphi]<br />
property Editor: Control;<br />
Bemerkungen<br />
Die Tabelle stellt einige integrierte Editoren zur Verfügung. Aus diesen wird automatisch einer aufgrund<br />
der Eigenschaften der zu bearbeitenden Zelle ausgewählt.<br />
Mit dieser Eigenschaft können Sie für die Bearbeitung der Zellen eines gegebenen CellStyles externe<br />
Editoren verwenden. Es kann zwar jede beliebige Steuerung als externer Editor verwendet werden, um<br />
aber eine vollständige Integration mit der Tabelle sicher zustellen, sollte der externe Editor die<br />
IC1EmbeddedEditor-Schnittstelle implementieren.<br />
Für weitere Einzelheiten schauen Sie bitte unter Editor-Eigenschaft nach.<br />
Schauen Sie ferner unter<br />
IC1EmbeddedEditor-Schnittstelle (Seite 446)<br />
EditMask-Eigenschaft<br />
Ermittelt oder legt die zu verwendende Eingabemaske für die Bearbeitung der Zelle fest.
382 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Syntax<br />
[VB]<br />
Public EditMask As String<br />
[C#]<br />
public string EditMask {get; set}<br />
[Delphi]<br />
property EditMask: string;<br />
Bemerkungen<br />
• Visual Basic<br />
• C#<br />
Dim s As CellStyle = _flex.Styles.Add("TheMask")<br />
s.EditMask = "##-##-####"<br />
Dim r As CellRange = _flex.GetCellRange(10, 10)<br />
rg.Style = s<br />
CellStyle s = _flex.Styles.Add("TheMask");<br />
s.EditMask = "##-##-####";<br />
CellRange r = _flex.GetCellRange(10,10);<br />
rg.Style = s;<br />
• Delphi<br />
var<br />
r: CellRange;<br />
s: CellStyle;<br />
begin<br />
s := _flex.Styles.Add('TheMask');<br />
s.EditMask := '##-##-####';<br />
r := _flex.GetCellRange(10, 10);<br />
rg.Style := s;<br />
end;<br />
Schauen Sie ferner unter<br />
CellStyle-Klasse (Seite 376)<br />
Font-Eigenschaft (CellStyle)<br />
Ermittelt oder legt die Schriftart des Textes in der Zelle fest.<br />
Syntax<br />
[VB]<br />
Public Font As Font<br />
[C#]<br />
public Font Font {get; set;}<br />
[Delphi]<br />
property Font: Font;
Bemerkungen<br />
ForeColor-Eigenschaft · 383<br />
Indem die Font-Eigenschaft der Tabelle festgelegt wird, ändert sich automatisch die Font-Eigenschaft der<br />
Formatvorlage Normal.<br />
Schauen Sie ferner unter<br />
CellStyle-Klasse (Seite 376)<br />
ForeColor-Eigenschaft<br />
Ermittelt oder legt die Schriftfarbe des Textes in der Zelle fest.<br />
Syntax<br />
[VB]<br />
Public ForeColor As Color<br />
[C#]<br />
public Color ForeColor {get; set;}<br />
[Delphi]<br />
property ForeColor: Color;<br />
Bemerkungen<br />
Indem die ForeColor-Eigenschaft der Tabelle festgelegt wird, ändert sich automatisch die ForeColor-<br />
Eigenschaft der Formatvorlage Normal.<br />
Schauen Sie ferner unter<br />
CellStyle-Klasse (Seite 376)<br />
Format-Eigenschaft (CellStyle)<br />
Ermittelt oder legt das Format fest, um Zellwerte in anzuzeigende Zeichenketten umzuwandeln.<br />
Syntax<br />
[VB]<br />
Public Format As String<br />
[C#]<br />
public string Format {get; set}<br />
[Delphi]<br />
property Format: string;<br />
Bemerkungen<br />
• Visual Basic<br />
Dim s As CellStyle = _flex.Styles.Add("BigNumber")<br />
s.Format = "#,##0.##"<br />
Dim r As CellRange = _flex.GetCellRange(10, 10)<br />
rg.Style = s
384 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
• C#<br />
CellStyle s = _flex.Styles.Add("BigNumber");<br />
s.Format = "#,##0.##";<br />
CellRange r = _flex.GetCellRange(10,10);<br />
rg.Style = s;<br />
• Delphi<br />
var<br />
r: CellRange;<br />
s: CellStyle;<br />
begin<br />
s := _flex.Styles.Add('BigNumber');<br />
s.Format := '#,##0.##';<br />
r := _flex.GetCellRange(10, 10);<br />
rg.Style := s;<br />
end;<br />
Schauen Sie ferner unter<br />
CellStyle-Klasse (Seite 376)<br />
ImageAlign-Eigenschaft (CellStyle)<br />
Ermittelt oder legt die Ausrichtung von Grafiken in einer Zelle fest.<br />
Syntax<br />
[VB]<br />
Public ImageAlign As ImageAlignEnum<br />
[C#]<br />
public ImageAlignEnum ImageAlign {get; set;}<br />
[Delphi]<br />
property ImageAlign: ImageAlignEnum;<br />
Eigenschaftswert<br />
Einer der ImageAlignEnum-Werte. Der Standardwert ist ImageAlignEnum.LeftCenter.<br />
Schauen Sie ferner unter<br />
CellStyle-Klasse (Seite 376)<br />
ImageMap-Eigenschaft<br />
Ermittelt oder erstellt das ImageMap, um Zellwerte mit in dieser Zelle anzuzeigenden Grafiken zu<br />
verknüpfen.<br />
Syntax<br />
[VB]<br />
Public ImageMap As Idictionary<br />
[C#]<br />
public.Idictionary ImageMap {get; set;}
[Delphi]<br />
property ImageMap: Idictionary;<br />
Schauen Sie ferner unter<br />
CellStyle-Klasse (Seite 376)<br />
ImageMap-Eigenschaft (Column) (Seite 353)<br />
ImageSpacing-Eigenschaft<br />
ImageSpacing-Eigenschaft · 385<br />
Ermittelt oder legt den Abstand in Pixeln zwischen der Grafik und dem Text in der Zelle fest.<br />
Syntax<br />
[VB]<br />
Public ImageSpacing As Integer<br />
[C#]<br />
public int ImageSpacing {get; set;}<br />
[Delphi]<br />
property ImageSpacing: Integer;<br />
Schauen Sie ferner unter<br />
CellStyle-Klasse (Seite 376)<br />
Margins-Eigenschaft<br />
Ermittelt oder legt den Abstand in Pixeln zwischen den Zellkanten und dem Zellinhalt fest.<br />
Syntax<br />
[VB]<br />
Public Margins As Margins<br />
[C#]<br />
public Margins Margins {get; set;}<br />
[Delphi]<br />
property Margins: Margins;<br />
Schauen Sie ferner unter<br />
CellStyle-Klasse (Seite 376)<br />
Name-Eigenschaft (CellStyle)<br />
Ermittelt oder legt den Namen für diesen CellStyle fest.
386 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Syntax<br />
[VB]<br />
Public Name As String<br />
[C#]<br />
public string Name {get; set}<br />
[Delphi]<br />
property Name: string;<br />
Bemerkungen<br />
Der styleName-Parameter muss einzigartig sein und darf keine geschweiften Klammern enthalten.<br />
Schauen Sie ferner unter<br />
CellStyle-Klasse (Seite 376)<br />
TextAlign-Eigenschaft (CellStyle)<br />
Ermittelt oder legt die Ausrichtung des Textes in einer Zelle fest.<br />
Syntax<br />
[VB]<br />
Public TextAlign As TextAlignEnum<br />
[C#]<br />
public TextAlignEnum TextAlign {get; set;}<br />
[Delphi]<br />
property TextAlign: TextAlignEnum;<br />
Eigenschaftswert<br />
Einer der TextAlignEnum-Werte. Der Standardwert ist TextAlignEnum.GeneralCenter.<br />
Schauen Sie ferner unter<br />
CellStyle-Klasse (Seite 376)<br />
TextDirection-Eigenschaft<br />
Hiermit kann Text in vertikaler Richtung angezeigt werden (auf- oder abwärts orientiert).<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft TextDirection As TextDirectionEnum<br />
[C#]<br />
public TextDirectionEnum TextDirection {get; set;}
[Delphi]<br />
property TextDirection: TextDirectionEnum;<br />
Bemerkungen<br />
TextEffect-Eigenschaft · 387<br />
Zellen mit vertikalem Text können wie gewöhnlich Zeilen umbrechen und die Zellgröße automatisch<br />
anpassen.<br />
Schauen Sie ferner unter<br />
CellStyle-Klasse (Seite 376)<br />
TextEffect-Eigenschaft<br />
Ermittelt oder legt den 3D-Effekt für den Text in der Zelle fest.<br />
Syntax<br />
[VB]<br />
Public TextEffect As TextEffectEnum<br />
[C#]<br />
public TextEffectEnum TextEffect {get; set;}<br />
[Delphi]<br />
property TextEffect: TextEffectEnum;<br />
Eigenschaftswert<br />
Einer der TextEffectEnum-Werte. Der Standardwert ist TextEffectEnum.Flat.<br />
Schauen Sie ferner unter<br />
CellStyle-Klasse (Seite 376)<br />
Trimming-Eigenschaft<br />
Legt fest, wie Texte beschnitten werden, wenn diese zu lang für die Zelle sind.<br />
Syntax<br />
[VB]<br />
Public Trimming As StringTrimming<br />
[C#]<br />
public StringTrimming Trimming {get; set;}<br />
[Delphi]<br />
property Trimming: StringTrimming;<br />
Eigenschaftswert<br />
Einer der StringTrimming-Werte. Der Standardwert ist StringTrimming.None.<br />
Bemerkungen<br />
Die StringTrimming-Aufzählung wird im System.Drawing-Namensbereich definiert.
388 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Schauen Sie ferner unter<br />
CellStyle-Klasse (Seite 376)<br />
UserData-Eigenschaft (CellStyle)<br />
Ermittelt oder legt willkürliche Daten für diesen CellStyle fest.<br />
Syntax<br />
[VB]<br />
Public UserData As Object<br />
[C#]<br />
public object UserData {get; set;}<br />
[Delphi]<br />
property UserData: Object;<br />
Bemerkungen<br />
Der UserData-Wert wird von der Tabelle intern nicht verwendet. Dieser ist für zusätzliche Daten<br />
reserviert, die Sie mit dem CellStyle verknüpfen wollen.<br />
Schauen Sie ferner unter<br />
CellStyle-Klasse (Seite 376)<br />
WordWrap-Eigenschaft<br />
Legt fest, ob lange Zeichenketten in der Zelle umgebrochen werden.<br />
Syntax<br />
[VB]<br />
Public WordWrap As Boolean<br />
[C#]<br />
public bool WordWrap {get; set;}<br />
[Delphi]<br />
property WordWrap: Boolean;<br />
Bemerkungen<br />
Die WordWrap-Eigenschaft steuert weiche Zeilenumbrüche. Zeichenketten, die Zeilenumbruchszeichen<br />
enthalten, werden immer umgebrochen.<br />
Schauen Sie ferner unter<br />
CellStyle-Klasse (Seite 376)
CellStyle-Methoden<br />
BuildString-Methode (CellStyle)<br />
Gibt eine kompakte Zeichenkette zurück, die diesen CellStyle darstellt.<br />
Syntax<br />
[VB]<br />
Public Function BuildString() As String<br />
[C#]<br />
public String BuildString ( )<br />
[Delphi]<br />
function BuildString: string;<br />
Bemerkungen<br />
BuildString-Methode (CellStyle) · 389<br />
Die Zeichenkette stellt nur die in diesem Format definierten Elemente dar. Verwenden Sie die<br />
ParseString-Methode, um diese Zeichenkette auf einen vorhandenen CellStyle anzuwenden.<br />
Schauen Sie ferner unter<br />
CellStyle-Klasse (Seite 376)<br />
Clear-Methode (CellStyle)<br />
Entfernt ausgewählte Elemente aus diesem CellStyle.<br />
Syntax<br />
[VB]<br />
Public Sub Clear(flags StyleElementFlags)<br />
[C#]<br />
public void Clear (StyleElementFlags flags )<br />
[Delphi]<br />
procedure Clear(flags: StyleElementFlags);<br />
Parameter Beschreibung<br />
flags<br />
Schauen Sie ferner unter<br />
CellStyle-Klasse (Seite 376)<br />
Beinhaltet eine Kombination von Flags, die festlegen, welche Formatelemente aus<br />
der Formatvorlage entfernt werden. Wenn diese Parameter nicht gesetzt sind,<br />
dann werden alle Elemente entfernt.
390 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
MergeWith-Methode<br />
Kopiert alle in einem Quell-CellStyle definierten Elemente in diese Formatvorlage. Formatelemente, die<br />
nicht in diesem CellStyle enthalten sind, werden bewahrt.<br />
Syntax<br />
[VB]<br />
Public Sub MergeWith(sourceStyle As CellStyle)<br />
[C#]<br />
public void MergeWith (CellStyle sourceStyle )<br />
[Delphi]<br />
procedure MergeWith(sourceStyle: CellStyle);<br />
Bemerkungen<br />
Mit dieser Methode können Sie visuelle Formate auf Zeilen und Spalten anwenden, ohne bereits<br />
vorhandene Formatattribute, wie z.b. ComboList und Format, zu zerstören.<br />
• Visual Basic<br />
• C#<br />
' add a combo box to a column (saved with the column style)<br />
_flex.Cols(2).ComboList = "A|B|C|D|E|F"<br />
' apply a new style to the column without disturbing the combo<br />
_flex.Cols(2).Style.MergeWith(flex.Styles.Frozen)<br />
' ** this wouldn't work, it would remove the ComboList saved with the<br />
column style<br />
'_ flex.Cols(2).Style = flex.Styles.Frozen<br />
' add a combo box to a column (saved with the column style)<br />
_flex.Cols[2].ComboList = "A|B|C|D|E|F";<br />
' apply a new style to the column without disturbing the combo<br />
_flex.Cols[2].Style.MergeWith(flex.Styles.Frozen);<br />
' ** this wouldn't work, it would remove the ComboList saved with the<br />
column style<br />
'_flex.Cols[2].Style = flex.Styles.Frozen;<br />
• Delphi<br />
// add a combo box to a column (saved with the column style)<br />
_flex.Cols[2].ComboList := 'A|B|C|D|E|F';<br />
// apply a new style to the column without disturbing the combo<br />
_flex.Cols[2].Style.MergeWith(flex.Styles.Frozen);<br />
// ** this wouldn't work, it would remove the ComboList saved with the<br />
column style<br />
//_ flex.Cols(2).Style = flex.Styles.Frozen<br />
Schauen Sie ferner unter<br />
CellStyle-Klasse (Seite 376)
ParseString-Methode (CellStyle)<br />
ParseString-Methode (CellStyle) · 391<br />
Erstellt diesen CellStyle neu, basierend auf der in einer Zeichenkette enthaltenen Beschreibung.<br />
Syntax<br />
[VB]<br />
Public Function ParseString(str As String) As Boolean<br />
[C#]<br />
public Boolean ParseString(string str)<br />
[Delphi]<br />
function ParseString(str: string): Boolean;<br />
Parameter Beschreibung<br />
styleDefinition<br />
Bemerkungen<br />
Eine von einer Zelle an die BuildString-Methode zurückgegebene Zeichenkette,<br />
die eine Beschreibung von einer Formatvorlage enthält.<br />
Die ParseString-Methode entfernt keine existierenden Elemente, wenn diese nicht in der Zeichenkette<br />
mit den Formatdefinitionen enthalten sind. Verwenden Sie die Clear-Methode bevor Sie ParseString<br />
aufrufen, um das aktuelle Format zurückzusetzen.<br />
Schauen Sie ferner unter<br />
CellStyle-Klasse (Seite 376)<br />
Render-Methode<br />
Rendert Zeichenketten und Grafiken mit den in diesem CellStyle definierten Attributen in ein Graphics-<br />
Objekt.<br />
Syntax<br />
[VB]<br />
Public Sub Render(g As Graphics, rc As Rectangle, s as String, img As Image, DrawCellFlags flags)<br />
Public Sub Render(g As Graphics, rc As Rectangle, s as String, img As Image)<br />
Public Sub Render(g As Graphics, rc As Rectangle, s as String)<br />
Public Sub Render(g As Graphics, rc As Rectangle, img As Image)<br />
[C#]<br />
public void Render(Graphics g, Rectangle rc, string s, Image img, DrawCellFlags flags);<br />
public void Render(Graphics g, Rectangle rc, string s, Image img);<br />
public void Render(Graphics g, Rectangle rc, string s);<br />
public void Render(Graphics g, Rectangle rc, Image img);
392 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
[Delphi]<br />
procedure Render(g: Graphics, rc: Rectangle, s: String, img: Image, DrawCellFlags flags);<br />
procedure Render(g: Graphics, rc: Rectangle, s: String, img: Image);<br />
procedure Render(g: Graphics, rc: Rectangle, s: String);<br />
procedure Render(g: Graphics, rc: Rectangle, img: Image);<br />
Parameter Beschreibung<br />
g Das Graphics-Objekt, in dem der Text und die Grafik gerendert werden soll.<br />
rc Das Rectangle, in welchem der Text und die Grafik gerendert werden soll.<br />
s Der Text, der gerendert werden soll.<br />
img Die Garfik, die gerendert werden soll.<br />
flags<br />
Bemerkungen<br />
EineKombination von einem oder mehreren Formatelementen die gerendert<br />
werden sollen (Hintergrund, Rahmen, Inhalt). Wenn diese Parameter nicht gesetzt<br />
sind, dann werden alle Elemente gerendert.<br />
Diese Methode wird intern von der Tabelle verwendet, um alle Zellen zu rendern. Sie stellt einen<br />
bequemen Mechanismus für das erneute Verwenden von CellStyle-Objekten zur Verfügung, um Text<br />
und Grafiken in andere Steuerungen zu rendern.<br />
Schauen Sie ferner unter<br />
CellStyle-Klasse (Seite 376)<br />
CellBorder-Klassen<br />
Die CellBorder-Klasse legt das Aussehen des Rahmens in einem CellStyle-Objekt fest. CellBorder<br />
definiert den Typ der Tabellenlinien in der Steuerung und kann über die Border-Eigenschaft von<br />
CellStyle abgefragt werden.<br />
Alle CellBorder-Mitglieder<br />
CellBorder-Klasseneigenschaften (public)<br />
Direction<br />
Unterstützt vom .NET-Compact-Framework.<br />
Color<br />
Unterstützt vom .NET-Compact-Framework.<br />
Legt die Ausrichtung des Rahmens fest.<br />
Legt die Farbe des Rahmens fest.<br />
Style Legt den Typ des Rahmens fest, der um die Zelle<br />
gezeichnet wird.<br />
Width<br />
Unterstützt vom .NET-Compact-Framework.<br />
Legt die Breite des Rahmens in Pixeln fest.
CellBorder-Eigenschaften<br />
Direction-Eigenschaft<br />
Legt die Ausrichtung des Rahmens fest.<br />
Syntax<br />
[VB]<br />
Public Direction As BorderDirEnum<br />
[C#]<br />
public BorderDirEnum Direction {get; set;}<br />
[Delphi]<br />
property Direction: BorderDirEnum;<br />
Eigenschaftswert<br />
Einer der BorderStyleEnum-Werte. Der Standardwert ist BorderStyleEnum.Both.<br />
Schauen Sie ferner unter<br />
CellBorder-Klasse (Seite 392)<br />
Color-Eigenschaft<br />
Legt die Farbe des Rahmens fest.<br />
Syntax<br />
[VB]<br />
Public Color As Color<br />
[C#]<br />
public Color Color {get; set;}<br />
[Delphi]<br />
property Color: Color;<br />
Bemerkungen<br />
Direction-Eigenschaft · 393<br />
Die Color-Eigenschaft betrifft nicht die 3D-Rahmen, die mit Systemfarben gezeichnet werden.<br />
Schauen Sie ferner unter<br />
CellBorder-Klasse (Seite 392)<br />
Style-Eigenschaft<br />
Legt den Typ des Rahmens fest, der um die Zelle gezeichnet wird.
394 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Syntax<br />
[VB]<br />
Public Style As BorderStyleEnum<br />
[C#]<br />
public BorderStyleEnum Style {get; set;}<br />
[Delphi]<br />
property Style: BorderStyleEnum;<br />
Eigenschaftswert<br />
Einer der BorderStyleEnum-Werte. Der Standardwert ist BorderStyleEnum.Flat.<br />
Schauen Sie ferner unter<br />
CellBorder-Klasse (Seite 392)<br />
Width-Eigenschaft (CellBorder)<br />
Legt die Breite des Rahmens in Pixeln fest.<br />
Syntax<br />
[VB]<br />
Public Width As Integer<br />
[C#]<br />
public int Width {get; set;}<br />
[Delphi]<br />
property Width: Integer;<br />
Bemerkungen<br />
Die Width-Eigenschaft betrifft nicht die 3D-Rahmen, die mit den vordefinierten Breiten (je nach<br />
Rahmentyp: 1 oder 2 Pixel) gezeichnet werden.<br />
Schauen Sie ferner unter<br />
CellBorder-Klasse (Seite 392)<br />
Node-Klasse<br />
Wenn Sie die <strong>C1FlexGrid</strong>-Steuerung für eine Gliederung verwenden, dann können Zeilen als<br />
Gliederungsknoten verwendet werden. Die Node-Klasse beinhaltet Eigenschaften, mit denen Sie diese<br />
Zeilen verändern können (ein- und ausklappen, verschieben oder sortieren). Sie können Knotenzeilen mit<br />
der Subtotal-Methode oder, indem Sie die IsNode-Eigenschaft der Zeile auf TRUE setzen, erstellen.
Alle Node-Mitglieder<br />
Node-Klasseneigenschaften (public)<br />
Children<br />
Unterstützt vom .NET-Compact-Framework.<br />
Collapsed<br />
Unterstützt vom .NET-Compact-Framework.<br />
Data<br />
Unterstützt vom .NET-Compact-Framework.<br />
Expanded<br />
Unterstützt vom .NET-Compact-Framework.<br />
Image<br />
Unterstützt vom .NET-Compact-Framework.<br />
Key<br />
Unterstützt vom .NET-Compact-Framework.<br />
Level<br />
Unterstützt vom .NET-Compact-Framework.<br />
Row<br />
Unterstützt vom .NET-Compact-Framework.<br />
Node-Klassenmethoden (public)<br />
AddNode<br />
Unterstützt vom .NET-Compact-Framework.<br />
EnsureVisible<br />
Unterstützt vom .NET-Compact-Framework.<br />
GetCellRange<br />
Unterstützt vom .NET-Compact-Framework.<br />
GetNode<br />
Unterstützt vom .NET-Compact-Framework.<br />
Move<br />
Unterstützt vom .NET-Compact-Framework.<br />
RemoveNode<br />
Unterstützt vom .NET-Compact-Framework.<br />
Select<br />
Unterstützt vom .NET-Compact-Framework.<br />
Sort<br />
Unterstützt vom .NET-Compact-Framework.<br />
Width-Eigenschaft (CellBorder) · 395<br />
Ermittelt die Anzahl der diesem Knoten<br />
untergeordneten Knoten.<br />
Ermittelt oder legt fest, ob dieser Knoten<br />
zusammengeklappt ist.<br />
Ermittelt oder legt die Daten in dieser Knotenzeile in<br />
der Spalte fest, die den Gliederungsbaum enthält.<br />
Ermittelt oder legt fest, ob dieser Knoten aufgeklappt<br />
ist.<br />
Ermittelt oder legt die Grafik in dieser Knotenzeile in<br />
der Spalte fest, die den Gliederungsbaum enthält.<br />
Ermittelt oder legt UserData von dieser Knotenzeile<br />
fest.<br />
Ermittelt oder legt die Gliederungsebene für diesen<br />
Knoten fest.<br />
Gibt einen Verweis auf das zu diesem Knoten<br />
gehörende Zeilenobjekt zurück.<br />
Erstellt eine Knotenzeile relative zu diesem Knoten<br />
an einer bestimmten Position.<br />
Stellt sicher, dass dieser Knoten sichtbar ist, so dass<br />
dessen Mutterknoten aufgeklappt werden und die<br />
Zeile auf den Bildschirm gescrollt wird.<br />
Gibt ein CellRange-Objekt mit dieser Zeile und allen<br />
untergeordneten Zeilen zurück.<br />
Gibt einen Verweis auf eine Knotenzeile relativ zu<br />
diesem Knoten an einer bestimmten Position zurück.<br />
Verschiebt einen Knoten auf eine neue Position.<br />
Entfernt diese und alle ihre untergeordneten<br />
Knotenzeilen aus der Tabelle (Knoten und Daten).<br />
Wählt den aktuellen Knoten aus.<br />
Sortiert die aktuellen Knoten in bestimmter<br />
Reihenfolge.
396 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Node-Eigenschaften<br />
Children-Eigenschaft<br />
Ermittelt die Anzahl der diesem Knoten untergeordneten Knoten. Die den untergeordneten Knoten<br />
untergeordneten Knoten werden nicht mit gezählt.<br />
Syntax<br />
[VB]<br />
Public Children As Integer<br />
[C#]<br />
public int Children {get;}<br />
[Delphi]<br />
property Children: Integer;<br />
Bemerkungen<br />
Schauen Sie unter „Benutzerdefinierte Gliederungsbäume erstellen“ (Seite 53) und „Übung zur<br />
Gliederung“ (Seite 88) für Verwendungsbeispiele über Node-Objekte nach.<br />
Schauen Sie ferner unter<br />
Node-Klasse (Seite 394)<br />
Collapsed-Eigenschaft<br />
Ermittelt oder legt fest, ob dieser Knoten zusammengeklappt ist.<br />
Syntax<br />
[VB]<br />
Public Collapsed As Boolean<br />
[C#]<br />
public bool Collapsed {get; set;}<br />
[Delphi]<br />
property Collapsed: Boolean;<br />
Bemerkungen<br />
Schauen Sie unter „Benutzerdefinierte Gliederungsbäume erstellen“ (Seite 53) und „Übung zur<br />
Gliederung“ (Seite 88) für Verwendungsbeispiele über Node-Objekte nach.<br />
Schauen Sie ferner unter<br />
Node-Klasse (Seite 394)<br />
Data-Eigenschaft (Node)<br />
Ermittelt oder legt die Daten in dieser Knotenzeile in der Spalte fest, die den Gliederungsbaum enthält.
Syntax<br />
[VB]<br />
Public Data As Object<br />
[C#]<br />
public object Data {get; set;}<br />
[Delphi]<br />
property Data: Object;<br />
Bemerkungen<br />
Expanded-Eigenschaft · 397<br />
Der nachfolgende Code zeigt die Beziehung zwischen der Node.Data-Eigenschaft und den GetData- und<br />
SetData-Methoden der Tabelle:<br />
• Visual Basic<br />
• C#<br />
Dim o1 As Object = node.Data<br />
Dim row As Integer = nd.Row.SafeIndex<br />
Dim col As Integer = flex.Tree.Column<br />
Dim o2 As Object = flex(row, col)<br />
Debug.Assert(o1.Equals(o2), "o1 and o2 refer to the same object")<br />
object o1 = node.Data;<br />
int row = nd.Row.SafeIndex;<br />
int col = flex.Tree.Column;<br />
object o2 = flex[row, col];<br />
Debug.Assert(o1.Equals(o2), "o1 and o2 refer to the same object");<br />
• Delphi<br />
var<br />
o2: System.Object;<br />
col: Integer;<br />
row: Integer;<br />
o1: System.Object;<br />
begin<br />
o1 := node.Data;<br />
row := nd.Row.SafeIndex;<br />
col := flex.Tree.Column;<br />
o2 := flex[row];<br />
Debug.Assert(o1.Equals(o2), 'o1 and o2 refer to the same object');<br />
end;<br />
Schauen Sie ferner unter<br />
Node-Klasse (Seite 394)<br />
Expanded-Eigenschaft<br />
Ermittelt oder legt fest, ob dieser Knoten aufgeklappt ist.<br />
Syntax<br />
[VB]<br />
Public Expanded As Boolean
398 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
[C#]<br />
public bool Expanded {get; set;}<br />
[Delphi]<br />
property Expanded: Boolean;<br />
Bemerkungen<br />
Schauen Sie unter „Benutzerdefinierte Gliederungsbäume erstellen“ (Seite 53) und „Übung zur<br />
Gliederung“ (Seite 88) für Verwendungsbeispiele über Node-Objekte nach.<br />
Schauen Sie ferner unter<br />
Node-Klasse (Seite 394)<br />
Image-Eigenschaft (Node)<br />
Ermittelt oder legt die Grafik in dieser Knotenzeile in der Spalte fest, die den Gliederungsbaum enthält.<br />
Syntax<br />
[VB]<br />
Public Image As Image<br />
[C#]<br />
public Image Image {get; set;}<br />
[Delphi]<br />
property Image: Image;<br />
Bemerkungen<br />
Der nachfolgende Code zeigt die Beziehung zwischen der Node. Image-Eigenschaft und den<br />
GetCellImage- und SetCellImage-Methoden der Tabelle:<br />
• Visual Basic<br />
• C#<br />
Dim img1 As Image = node.Image<br />
Dim row As Integer = nd.Row.SafeIndex<br />
Dim col As Integer = flex.Tree.Column<br />
Dim img2 As Image = flex.GetCellImage(row, col)<br />
Debug.Assert(img1.Equals(img2), "img1 and img2 are the same image")<br />
Image img1 = node.Image;<br />
int row = nd.Row.SafeIndex;<br />
int col = flex.Tree.Column;<br />
Image img2 = flex.GetCellImage(row, col);<br />
Debug.Assert(img1.Equals(img2), "img1 and img2 are the same image");<br />
• Delphi<br />
var<br />
img2: Image;<br />
col: Integer;<br />
row: Integer;<br />
img1: Image;
Key-Eigenschaft · 399<br />
begin<br />
img1 := node.Image;<br />
row := nd.Row.SafeIndex;<br />
col := flex.Tree.Column;<br />
img2 := flex.GetCellImage(row, col);<br />
Debug.Assert(img1.Equals(img2), 'img1 and img2 are the same image');<br />
end;<br />
Schauen Sie ferner unter<br />
Node-Klasse (Seite 394)<br />
Key-Eigenschaft<br />
Ermittelt oder legt UserData von dieser Knotenzeile fest.<br />
Syntax<br />
[VB]<br />
Public Key As Object<br />
[C#]<br />
public object Key {get; set;}<br />
[Delphi]<br />
property Key: Object;<br />
Bemerkungen<br />
Der nachfolgende Code zeigt die Beziehung zwischen der Node. Key-Eigenschaft und der<br />
Row.UserData-Eigenschaft:<br />
• Visual Basic<br />
• C#<br />
Dim o1 As Object = node.Key<br />
Dim o2 As Object = nd.Row.UserData<br />
Debug.Assert(o1.Equals(o2), "o1 and o2 refer to the same object")<br />
object o1 = node.Key;<br />
object o2 = nd.Row.UserData;<br />
Debug.Assert(o1.Equals(o2), "o1 and o2 refer to the same object");<br />
• Delphi<br />
var<br />
o2: System.Object;<br />
o1: System.Object;<br />
begin<br />
o1 := node.Key;<br />
o2 := nd.Row.UserData;<br />
Debug.Assert(o1.Equals(o2), 'o1 and o2 refer to the same object');<br />
end;<br />
Schauen Sie ferner unter<br />
Node-Klasse (Seite 394)
400 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Level-Eigenschaft<br />
Ermittelt oder legt die Gliederungsebene für diesen Knoten fest.<br />
Syntax<br />
[VB]<br />
Public Level As Integer<br />
[C#]<br />
public int Level {get; set;}<br />
[Delphi]<br />
property Level: Integer;<br />
Bemerkungen<br />
Höhere Ebenen stehen für tiefere Verschachtelungen. Setzen Sie die Ebene auf 0, um einen Quellknoten,<br />
oder auf einen negativen Wert, um einen im Gliederungsbaum nicht sichtbaren Knoten zu erstellen.<br />
Schauen Sie unter „Benutzerdefinierte Gliederungsbäume erstellen“ (Seite 53) und „Übung zur<br />
Gliederung“ (Seite 88) für Verwendungsbeispiele über Node-Objekte nach.<br />
Schauen Sie ferner unter<br />
Node-Klasse (Seite 394)<br />
Row-Eigenschaft (Node)<br />
Gibt einen Verweis auf das zu diesem Knoten gehörende Zeilenobjekt zurück.<br />
Syntax<br />
[VB]<br />
Public Row As Row<br />
[C#]<br />
public Row Row {get;}<br />
[Delphi]<br />
property Row: Row;<br />
Schauen Sie ferner unter<br />
Node-Klasse (Seite 394)<br />
Node-Methoden<br />
AddNode-Methode<br />
Erstellt eine Knotenzeile relativ zu diesem Knoten an einer bestimmten Position.
Syntax<br />
[VB]<br />
Public Function AddNode(position As NodeTypeEnum, data As Object) As Node<br />
EnsureVisible-Methode · 401<br />
Public Function AddNode(position As NodeTypeEnum, data As Object, key As Object, img As Image)<br />
As Node<br />
[C#]<br />
public Node AddNode (NodeTypeEnum position , Object data , Object key , Image img )<br />
public Node AddNode (NodeTypeEnum position , Object data )<br />
[Delphi]<br />
function AddNode(position: NodeTypeEnum; data: Object): Node;<br />
function AddNode(position: NodeTypeEnum; data: Object; key: Object; img: Image): Node;<br />
Parameter Beschreibung<br />
position<br />
Ein Wert der NodeTypeEnum-Aufzählung, der festlegt, wo der neue Knoten in<br />
Bezug auf diesen Knoten hinzugefügt werden soll (z.B. Kind oder Sibling).<br />
data Wert der Data-Eigenschaft für den neuen Knoten.<br />
key Wert der Key-Eigenschaft für den neuen Knoten.<br />
image Wert der Image-Eigenschaft für den neuen Knoten.<br />
Rückgabewert<br />
Ein Verweis auf den neu der Tabelle hinzugefügten Node.<br />
Schauen Sie ferner unter<br />
Node-Klasse (Seite 394)<br />
EnsureVisible-Methode<br />
Stellt sicher, dass dieser Knoten sichtbar ist, so dass dessen Mutterknoten aufgeklappt werden und die<br />
Zeile auf den Bildschirm gescrollt wird, wenn nötig.<br />
Syntax<br />
[VB]<br />
Public Sub EnsureVisible()<br />
[C#]<br />
public void EnsureVisible ( )<br />
[Delphi]<br />
procedure EnsureVisible;
402 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Schauen Sie ferner unter<br />
Node-Klasse (Seite 394)<br />
GetCellRange-Methode (Node)<br />
Gibt ein CellRange-Objekt mit dieser Zeile und allen untergeordneten Zeilen zurück (Knoten- und<br />
Datenzeilen).<br />
Syntax<br />
[VB]<br />
Public Function GetCellRange() As CellRange<br />
[C#]<br />
public CellRange GetCellRange ( )<br />
[Delphi]<br />
function GetCellRange: CellRange;<br />
Bemerkungen<br />
Das zurückgegebene CellRange-Objekt beinhaltet alle Spalten.<br />
Schauen Sie ferner unter<br />
Node-Klasse (Seite 394)<br />
GetNode-Methode<br />
Gibt einen Verweis auf eine Knotenzeile relativ zu diesem Knoten an einer bestimmten Position zurück<br />
(z.B. erstes Kind, letzer Sibling).<br />
Syntax<br />
[VB]<br />
Public Function GetNode(position As NodeTypeEnum) As Node<br />
[C#]<br />
public Node GetNode (NodeTypeEnum position )<br />
[Delphi]<br />
function GetNode(position: NodeTypeEnum): Node;<br />
Bemerkungen<br />
Wenn der gewünschte Knoten nicht exisitert, dann gibt GetNode Null zurück (z.B. der Quellknoten<br />
besitzt keinen vorhergehenden Sibling).<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Node-Klasse (Seite 394)
Move-Methode<br />
Verschiebt einen Knoten auf eine neue Position.<br />
Syntax<br />
[VB]<br />
Public Function Move(moveTo As NodeMoveEnum, targetNode As Node) As Boolean<br />
Public Function Move(moveTo As NodeMoveEnum) As Boolean<br />
[C#]<br />
public Boolean Move (NodeMoveEnum moveTo , Node targetNode )<br />
public Boolean Move (NodeMoveEnum moveTo )<br />
[Delphi]<br />
function Move(moveTo: NodeMoveEnum; tragetNode: Node): Boolean;<br />
function Move(moveTo: NodeMoveEnum): Boolean;<br />
Parameter Beschreibung<br />
moveTo<br />
targetNode<br />
Rückgabewert<br />
Ein Wert der NodeMoveEnum-Aufzählung, der festlegt, wohin der Knoten in<br />
Bezug auf seine derzeitige Position verschoben wird.<br />
Zu verwendendes Node-Zielobjekt, wenn der moveTo-Parameter auf<br />
NodeMoveEnum.ChildOf steht.<br />
Gibt TRUE zurück, wenn die Methode erfolgreich war, anderfalls wird FALSE ausgegeben.<br />
Schauen Sie ferner unter<br />
Node-Klasse (Seite 394)<br />
RemoveNode-Methode<br />
Entfernt diese und alle ihre untergeordneten Knotenzeilen aus der Tabelle (Knoten und Daten).<br />
Syntax<br />
[VB]<br />
Public Sub RemoveNode()<br />
[C#]<br />
public void RemoveNode ( )<br />
[Delphi]<br />
procedure RemoveNode;<br />
Move-Methode · 403
404 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Schauen Sie ferner unter<br />
Node-Klasse (Seite 394)<br />
Select-Methode (Node)<br />
Wählt den aktuellen Knoten aus.<br />
Syntax<br />
[VB]<br />
Public Sub Select()<br />
[C#]<br />
public void Select ( )<br />
[Delphi]<br />
procedure Select;<br />
Schauen Sie ferner unter<br />
Node-Klasse (Seite 394)<br />
Sort-Methode (Node)<br />
Sortiert die aktuellen Unterknoten in bestimmter Reihenfolge.<br />
Syntax<br />
[VB]<br />
Public Sub Sort(order As SortFlags)<br />
Public Sub Sort(order As SortFlags, col1 As Integer, col2 As Integer)<br />
[C#]<br />
public void Sort (SortFlags order )<br />
public void Sort (SortFlags order , int col1 , int col2 )<br />
[Delphi]<br />
procedure Sort(order: SortFlags);<br />
procedure Sort(order: SortFlags; col1: Integer; col2: Integer);<br />
Parameter Beschreibung<br />
order<br />
col<br />
Bemerkungen<br />
Ein oder mehrere Flags aus der SortFlags-Aufzählung, die festlegen, wie die Knoten<br />
sortiert werden.<br />
Index der Spalte, nach deren Inhalten sortiert werden soll. Wenn dieser Parameter<br />
nicht festgelegt ist, dann wird standardmäßig nach der Spalte sortiert, die den Baum<br />
anzeigt. Diese Spalte wird von der Column-Eigenschaft des Trees bestimmt.<br />
Diese Methode betrifft nicht die Reihenfolge der Zeilen, die keine Knoten sind.
Schauen Sie ferner unter<br />
Node-Klasse (Seite 394)<br />
GridGlyphs-Klasse<br />
Item-Eigenschaft (GridGlyphs) · 405<br />
Die GridGlyphs-Klasse stellt ein Array mit Glyphen (Grafiken) dar, die nach dem Glyphentyp indiziert<br />
sind (GlyphEnum-Typ).<br />
Dieses Feld enthält von der Tabelle verwendete Grafiken, um z.B. Spaltensortierung, ein- und<br />
ausgeklappte Gliederungsgruppen, Kontrollkästchen, Cursor und Fehlerinformation anzuzeigen.<br />
Verwenden Sie die Glyphs-Eigenschaft um ein GridGlyphs-Objekt zu holen und verwenden Sie den<br />
Indizierer um eine Grafik abzurufen oder festzulegen.<br />
Alle GridGlyphs-Mitglieder<br />
GridGlyphs-Klasseneigenschaften (public)<br />
Item Ermittelt oder legt den Glyph für ein bestimmtes GlyphEnum fest.<br />
GridGlyphs-Eigenschaften<br />
Item-Eigenschaft (GridGlyphs)<br />
Eine, von der Tabelle verwendete Grafik, um Information über eine Zeile, Spalte oder Zelle zu verbreiten.<br />
Syntax<br />
[VB]<br />
Public Item(type As GlyphEnum) As Image<br />
[C#]<br />
public Image this[GlyphEnum type] {get;set;}<br />
[Delphi]<br />
property Item(type: GlyphEnum): Image;<br />
Bemerkungen<br />
Verwenden Sie diese Eigenschaft um die von der Tabelle verwendete Grafik zu verändern, die<br />
Information über eine Zeile, Spalte oder Zelle verbreiten. Zum Beispiel, der nachfolgende Quellcode<br />
ändert die Grafik, welche die Richtung der Sortierung einer Spalte anzeigt:<br />
• Visual Basic<br />
• C#<br />
_flex.Glyphs(GlyphEnum.Ascending) = imgAscending<br />
_flex.Glyphs(GlyphEnum.Descending) = imgDescending<br />
_flex.Glyphs[GlyphEnum.Ascending] = imgAscending;<br />
_flex.Glyphs[GlyphEnum.Descending] = imgDescending;<br />
• Delphi<br />
_flex.Glyphs[GlyphEnum.Ascending] := imgAscending;
406 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
_flex.Glyphs[GlyphEnum.Descending] := imgDescending;<br />
Schauen Sie ferner unter<br />
GridGlyphs-Klasse (Seite 405)<br />
GridTree-Klasse<br />
Wenn Sie die <strong>C1FlexGrid</strong>-Steuerung für eine Gliederung verwenden, dann können Zeilen als<br />
Gliederungsknoten verwendet werden. Die GridTree-Klasse beinhaltet Eigenschaften, mit denen Sie das<br />
Aussehen, die Position und das Verhalten des Gliederungbaums festlegen können. Jede Tabelle besitzt<br />
ein einziges GridTree-Objekt, welches mit der Tree-Eigenschaft abgerufen werden kann.<br />
Alle GridTree-Mitglieder<br />
GridTree-Klasseneigenschaften (public)<br />
Column<br />
Indent<br />
LineColor<br />
LineStyle<br />
NodeImageCollapsed<br />
NodeImageExpanded<br />
Ermittelt oder legt den Index der Spalte fest, in welcher der<br />
Gliederungsbaum angezeigt werden soll.<br />
Ermittelt oder legt den Einzug einer jeden Gliederungsebene<br />
in Pixeln fest.<br />
Ermittelt oder legt die Farbe der Linien im Gliederungsbaum<br />
fest.<br />
Ermittelt oder legt den Typ der Linien im Gliederungsbaum<br />
fest.<br />
Ermittelt oder legt die Grafik fest, die neben einem<br />
eingeklappten Knoten angezeigt wird.<br />
Ermittelt oder legt die Grafik fest, die neben einem<br />
ausgeklappten Knoten angezeigt wird.<br />
Style Ermittelt oder legt das Format des Gliederungsbaumes fest.<br />
GridTree-Klassenmethoden (public)<br />
Show<br />
Klappt alle Knoten bis zu einer betimmten Ebene auf und alle<br />
anderen zu.<br />
Sort Sortiert alle Knoten auf einer gegebenen Ebene.<br />
GridTree-Eigenschaften<br />
Column-Eigenschaft<br />
Ermittelt oder legt den Index der Spalte fest, in welcher der Gliederungsbaum angezeigt werden soll.
Syntax<br />
[VB]<br />
Public Column As Integer<br />
[C#]<br />
public int Column {get; set;}<br />
[Delphi]<br />
propery Column: Integer;<br />
Bemerkungen<br />
Indent-Eigenschaft · 407<br />
Standardmäßig ist diese Eigenschaft auf -1 gesetzt, so dass der Gliederungsbaum ausgeblendet ist.<br />
Schauen Sie ferner unter<br />
GridTree-Klasse (Seite 406)<br />
Indent-Eigenschaft<br />
Ermittelt oder legt den Einzug einer jeden Gliederungsebene in Pixeln fest.<br />
Syntax<br />
[VB]<br />
Public Indent As Integer<br />
[C#]<br />
public int Indent {get; set;}<br />
[Delphi]<br />
property Indent: Integer;<br />
Bemerkungen<br />
Wenn Sie die Indent-Eigenschaft auf einen Wert stellen, der zu klein ist, um die NodeImageCollapsed-<br />
und NodeImageExpanded-Grafiken anzuzeigen, dann passt die Tabelle automatisch diesen an, so dass<br />
die Grafiken in den Einzug passen.<br />
Schauen Sie ferner unter<br />
GridTree-Klasse (Seite 406)<br />
LineColor-Eigenschaft<br />
Ermittelt oder legt die Farbe der Linien im Gliederungsbaum fest.<br />
Syntax<br />
[VB]<br />
Public LineColor As Color<br />
[C#]<br />
public Color LineColor {get; set;}
408 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
[Delphi]<br />
property LineColor: Color;<br />
Bemerkungen<br />
Siehe auch Style-Eigenschaft.<br />
Schauen Sie ferner unter<br />
GridTree-Klasse (Seite 406)<br />
LineStyle-Eigenschaft<br />
Ermittelt oder legt den Typ der Linien im Gliederungsbaum fest.<br />
Syntax<br />
[VB]<br />
Public LineStyle As DashStyle<br />
[C#]<br />
public DashStyle LineStyle {get; set;}<br />
[Delphi]<br />
property LineStyle: DashStyle;<br />
Bemerkungen<br />
Legt das Format fest, mit dem der Gliederungsbaum gezeichnet wird. Standardmäßig ist diese<br />
Eigenschaft auf DashStyle.Dot gesetzt, so dass der Baum mit einer gepunkteten Linie gezeichnet wird.<br />
Schauen Sie ferner unter<br />
GridTree-Klasse (Seite 406)<br />
NodeImageCollapsed-Eigenschaft<br />
Ermittelt oder legt die Grafik fest, die neben einem eingeklappten Knoten angezeigt wird.<br />
Syntax<br />
[VB]<br />
Public NodeImageCollapsed As Image<br />
[C#]<br />
public Image NodeImageCollapsed {get; set;}<br />
[Delphi]<br />
property NodeImageCollapsed: Image;<br />
Bemerkungen<br />
Wenn Sie diese Eigenschaft auf Null stellen, dann wird sie zurückgesetzt und es werden die<br />
Standardgrafiken der Tabelle verwendet (ein Pluszeichen). Verwenden Sie die Tree.Style-Eigenschaft,<br />
um die Grafiken auszublenden.
Schauen Sie ferner unter<br />
GridTree-Klasse (Seite 406)<br />
NodeImageExpanded-Eigenschaft<br />
NodeImageExpanded-Eigenschaft · 409<br />
Ermittelt oder legt die Grafik fest, die neben einem ausgeklappten Knoten angezeigt wird.<br />
Syntax<br />
[VB]<br />
Public NodeImageExpanded As Image<br />
[C#]<br />
public Image NodeImageExpanded {get; set;}<br />
[Delphi]<br />
property NodeImageExpanded: Image;<br />
Bemerkungen<br />
Wenn Sie diese Eigenschaft auf Null stellen, dann wird sie zurückgesetzt und es werden die<br />
Standardgrafiken der Tabelle verwendet (ein Pluszeichen). Verwenden Sie die Tree.Style-Eigenschaft,<br />
um die Grafiken auszublenden.<br />
Schauen Sie ferner unter<br />
GridTree-Klasse (Seite 406)<br />
Style-Eigenschaft (GridTree)<br />
Ermittelt oder legt das Format des Gliederungsbaumes fest.<br />
Syntax<br />
[VB]<br />
Public Style As TreeStyleFlags<br />
[C#]<br />
public TreeStyleFlags Style {get; set;}<br />
[Delphi]<br />
property Style: TreeStyleFlags;<br />
Bemerkungen<br />
Verwenden Sie die Style-Eigenschaft um festzulegen, ob der Gliederungsbaum mit Linien die Knoten<br />
und die Ein- und Ausklappschaltflächen verbinden soll, und die Column-Eigenschaft, um festzulegen, ob<br />
die Tabelle den Gliederungsbaum anzeigen soll.<br />
Schauen Sie ferner unter<br />
GridTree-Klasse (Seite 406)
410 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
GridTree-Methoden<br />
Show-Methode<br />
Klappt alle Knoten bis zu einer betimmten Ebene auf und alle anderen zu.<br />
Syntax<br />
[VB]<br />
Public Sub Show(level As Integer)<br />
[C#]<br />
public void Show ( int level )<br />
[Delphi]<br />
procedure Show(level: Integer);<br />
Parameter Beschreibung<br />
level<br />
Schauen Sie ferner unter<br />
GridTree-Klasse (Seite 406)<br />
Sort-Methode (GridTree)<br />
Die anzuzeigende Ebene. Jeder Knoten mit einem tieferen Level als dieses wird<br />
zusammengeklappt und alle anderen aufgeklappt.<br />
Sortiert alle Knoten auf einer gegebenen Ebene.<br />
Syntax<br />
[VB]<br />
Public Sub Sort(level As Integer, order As SortFlags, col1 As Integer, col2 As Integer)<br />
[C#]<br />
public void Sort ( int level , SortFlags order , int col1 , int col2 )<br />
[Delphi]<br />
procedure Sort(level: Integer; order: SortFlags; col12: Integer; col2: Integer);<br />
Parameter Beschreibung<br />
level Die zu sortierende Ebene. Alle Knoten auf dieser Ebene werden sortiert.<br />
order<br />
Ein oder mehrere Werte der SortFlags-Aufzählung, die festlegen, wie das<br />
Sortieren erfolgt.<br />
col1, col2 Ein Spaltenbereich, der die Werte enthält, nach denen sortiert werden soll.
Bemerkungen<br />
Sort-Methode (GridTree) · 411<br />
Die Tabellenmethode Sort sortiert Datenzeilen innerhalb eines Knotens. Sie verschiebt nicht die<br />
Knotenzeilen.<br />
Die Tree.Sort-Methode sortiert die Knotenzeilen und verschiebt alle Datenzeilen des Knotens mit. Zum<br />
Beispiel, der nachfolgende Quellcode sortiert eine Datengliederung nach den Werten in der „Sales“-<br />
Spalte in aufsteigender Richtung:<br />
• Visual Basic<br />
• C#<br />
Private Sub SortTree(sf As SortFlags)<br />
Dim col As Integer = flex.Cols("Sales").SafeIndex<br />
flex.Tree.Sort(0, sf, col, col) '
412 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Gliederungsbaum absteigend nach „Sales“ sortiert.<br />
Schauen Sie ferner unter<br />
GridTree-Klasse (Seite 406)<br />
GridPrinter-Klasse<br />
Die PrintParameters-Eigenschaft gibt einen Verweis auf das GridPrinter-Objekt zurück, das den<br />
Ausdruck der Tabelle verwaltet. Das GridPrinter-Objekt beinhaltet Eigenschaften, mit denen Sie<br />
geringwertige Parameter des Druckvorgangs, z.B. Seiten- und Druckereinrichtungen, steuern können.<br />
Alle GridPrinter-Mitglieder<br />
GridPrinter-Klasseneigenschaften (public)<br />
Footer Hiermit können Sie die Fußzeile vom PrintDocument-Objekt der Tabelle<br />
anpassen.<br />
FooterFont Legt die Schriftart für die Fußzeile fest, wenn die Tabelle mit der PrintGrid-<br />
Methode gedruckt wird.<br />
Header Hiermit können Sie die Kopfzeile vom PrintDocument-Objekt der Tabelle<br />
anpassen.<br />
HeaderFont Legt die Schriftart für die Kopfzeile fest, wenn die Tabelle mit der PrintGrid-<br />
Methode gedruckt wird.<br />
PageNumber Gibt die Seitenzahl der zu druckenden Seite zurück.<br />
PageCount Gibt die Gesamtzahl der Seiten im zu druckenden Dokument zurück.<br />
PrintDocument Gibt das PrintDocument-Objekt zurück, das die Seite und die<br />
Druckereinstellungen festlegt.<br />
PrintPreviewDialog Hiermit können Sie Eigenschaften für das integrierte Druckvorschaufenster<br />
festlegen.
GridPrinter-Eigenschaften<br />
Footer-Eigenschaft<br />
Footer-Eigenschaft · 413<br />
Hiermit können Sie die Fußzeile vom PrintDocument-Objekt der Tabelle anpassen, für den Fall, dass Sie<br />
die Tabellenvorschau in ihrem eigenen Fenster anzeigen wollen.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft Footer As String<br />
[C#]<br />
public string Footer {get; set;}<br />
[Delphi]<br />
property Footer: string;<br />
Beispiel<br />
Der folgende Quellcode passt die Fußzeile des PrintDocument-Objeks der Tabelle an:<br />
• Visual Basic<br />
• C#<br />
Dim gp As GridPrinter = _flex.PrintParameters<br />
gp.Footer = "Hello" + ControlChars.Tab + "World" + ControlChars.Tab +<br />
"Footer"<br />
gp.PrintGridFlags = C1.Win.<strong>C1FlexGrid</strong>.PrintGridFlags.FitToPageWidth<br />
Dim dlg As New PrintPreviewDialog()<br />
dlg.Document = gp.PrintDocument<br />
dlg.ShowDialog()<br />
GridPrinter gp = _flex.PrintParameters;<br />
gp.Footer = "Hello\tWorld\tFooter";<br />
gp.PrintGridFlags =<br />
C1.Win.<strong>C1FlexGrid</strong>.PrintGridFlags.FitToPageWidth;<br />
PrintPreviewDialog dlg = new PrintPreviewDialog();<br />
dlg.Document = gp.PrintDocument;<br />
dlg.ShowDialog();<br />
• Delphi<br />
var<br />
dlg: PrintPreviewDialog;<br />
gp: GridPrinter;<br />
begin<br />
gp := _flex.PrintParameters;<br />
gp.Footer := 'Hello'#9'World'#9'Footer';<br />
gp.PrintGridFlags := C1.Win.<strong>C1FlexGrid</strong>.PrintGridFlags.FitToPageWidth;<br />
dlg := PrintPreviewDialog.Create;<br />
dlg.Document := gp.PrintDocument;<br />
dlg.ShowDialog;<br />
end;<br />
Schauen Sie ferner unter<br />
GridPrinter-Klasse (Seite 412)
414 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
FooterFont-Eigenschaft<br />
Legt die Schriftart für die Fußzeile fest, wenn die Tabelle mit der PrintGrid-Methode gedruckt wird.<br />
Syntax<br />
[VB]<br />
Public FooterFont As Font<br />
[C#]<br />
public Font FooterFont {get; set;}<br />
[Delphi]<br />
property FooterFont: Font;<br />
Beispiel<br />
Der folgende Quellcode druckt die Tabelle mit einer großen und fetten Fußzeile aus:<br />
• Visual Basic<br />
• C#<br />
Dim gp As GridPrinter = flex.PrinterSettings<br />
gp.FooterFont = New Font("Arial", 16, FontStyle.Bold)<br />
flex.PrintGrid("my grid", PrintGridFlags.ActualSize, _<br />
"Header" + vbTab + vbTab + "{0}", "Footer")<br />
GridPrinter gp = flex.PrinterSettings;<br />
gp.FooterFont = new Font("Arial", 16, FontStyle.Bold);<br />
flex.PrintGrid("my grid",<br />
PrintGridFlags.ActualSize, "Header\t\t{0}", "Footer");<br />
• Delphi<br />
var<br />
gp: GridPrinter;<br />
begin<br />
gp := flex.PrinterSettings;<br />
gp.FooterFont := Font.Create('Arial', 16, FontStyle.Bold);<br />
flex.PrintGrid('my grid', PrintGridFlags.ActualSize,<br />
'Header'#9#9'{0}', 'Footer');<br />
end;<br />
Schauen Sie ferner unter<br />
GridPrinter-Klasse (Seite 412)<br />
Header-Eigenschaft<br />
Hiermit können Sie die Kopfzeile vom PrintDocument-Objekt der Tabelle, für den Fall, dass Sie die<br />
Tabellenvorschau in ihrem eigenen Fenster anzeigen wollen, anpassen.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft Header As String
[C#]<br />
public string Header {get; set;}<br />
[Delphi]<br />
property Header: string;<br />
Beispiel<br />
Der folgende Quellcode passt die Kopfzeile des PrintDocument-Objeks der Tabelle an:<br />
• Visual Basic<br />
• C#<br />
HeaderFont-Eigenschaft · 415<br />
Dim gp As GridPrinter = _flex.PrintParameters<br />
gp.Header = "Hello" & vbTab & "World" &_<br />
vbTab + "Header"<br />
gp.PrintGridFlags = C1.Win.<strong>C1FlexGrid</strong>.PrintGridFlags.FitToPageWidth<br />
Dim dlg As New PrintPreviewDialog()<br />
dlg.Document = gp.PrintDocument<br />
dlg.ShowDialog()<br />
GridPrinter gp = _flex.PrintParameters;<br />
gp.Header = "Hello\tWorld\tHeader";<br />
gp.PrintGridFlags =<br />
C1.Win.<strong>C1FlexGrid</strong>.PrintGridFlags.FitToPageWidth;<br />
PrintPreviewDialog dlg = new PrintPreviewDialog();<br />
dlg.Document = gp.PrintDocument;<br />
dlg.ShowDialog();<br />
• Delphi<br />
var<br />
dlg: PrintPreviewDialog;<br />
gp: GridPrinter;<br />
begin<br />
gp := _flex.PrintParameters;<br />
gp.Header := 'Hello'#9'World'#9'Header';<br />
gp.PrintGridFlags := C1.Win.<strong>C1FlexGrid</strong>.PrintGridFlags.FitToPageWidth;<br />
dlg := PrintPreviewDialog.Create;<br />
dlg.Document := gp.PrintDocument;<br />
dlg.ShowDialog;<br />
end;<br />
Schauen Sie ferner unter<br />
GridPrinter-Klasse (Seite 412)<br />
HeaderFont-Eigenschaft<br />
Legt die Schriftart für die Kopfzeile fest, wenn die Tabelle mit der PrintGrid-Methode gedruckt wird.<br />
Syntax<br />
[VB]<br />
Public HeaderFont As Font<br />
[C#]<br />
public Font HeaderFont {get; set;}
416 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
[Delphi]<br />
property HeaderFont: Font;<br />
Beispiel<br />
Der folgende Quellcode druckt die Tabelle mit einer großen und fetten Kopfzeile aus:<br />
• Visual Basic<br />
• C#<br />
Dim gp As GridPrinter = flex.PrinterSettings<br />
gp.HeaderFont = New Font("Arial", 16, FontStyle.Bold)<br />
flex.PrintGrid("my grid", PrintGridFlags.ActualSize, _<br />
"Header" + vbTab + vbTab + "{0}", "Footer")<br />
GridPrinter gp = flex.PrinterSettings;<br />
gp.HeaderFont = new Font("Arial", 16, FontStyle.Bold);<br />
flex.PrintGrid("my grid", PrintGridFlags.ActualSize,<br />
"Header\t\t{0}", "Footer");<br />
• Delphi<br />
var<br />
gp: GridPrinter;<br />
begin<br />
gp := flex.PrinterSettings;<br />
gp.HeaderFont := Font.Create('Arial', 16, FontStyle.Bold);<br />
flex.PrintGrid('my grid', PrintGridFlags.ActualSize,<br />
'Header'#9#9'{0}', 'Footer');<br />
end;<br />
Schauen Sie ferner unter<br />
GridPrinter-Klasse (Seite 412)<br />
PageNumber-Eigenschaft<br />
Gibt die Seitenzahl der zu druckenden Seite zurück.<br />
Syntax<br />
[VB]<br />
Public PageNumber As Integer<br />
[C#]<br />
public int PageNumber {get;}<br />
[Delphi]<br />
property PageNumber: Integer;<br />
Bemerkungen<br />
Diese Eigenschaft kann auch dafür verwendet werden, dem Nutzer den Druckfortschritt während des<br />
Druckvorgangs anzuzeigen.<br />
Schauen Sie ferner unter<br />
GridPrinter-Klasse (Seite 412)
PageCount-Eigenschaft<br />
Gibt die Gesamtzahl der Seiten im zu druckenden Dokument zurück.<br />
Syntax<br />
[VB]<br />
Public PageCount As Integer<br />
[C#]<br />
public int PageCount {get;}<br />
[Delphi]<br />
property PageCount: Integer;<br />
Bemerkungen<br />
PageCount-Eigenschaft · 417<br />
Diese Eigenschaft kann auch dafür verwendet werden, dem Nutzer den Druckfortschritt während des<br />
Druckvorgangs anzuzeigen.<br />
Schauen Sie ferner unter<br />
GridPrinter-Klasse (Seite 412)<br />
PrintDocument-Eigenschaft<br />
Gibt das PrintDocument-Objekt zurück, das die Seite und die Druckereinstellungen festlegt.<br />
Syntax<br />
[VB]<br />
Public PrintDocument As PrintDocument<br />
[C#]<br />
public PrintDocument PrintDocument {get;}<br />
[Delphi]<br />
property PrintDocument: PrintDocument;<br />
Bemerkungen<br />
Die PrintDocument-Klasse ist Teil des .NET-Frameworks und wird im System.Drawing.Printing-<br />
Namensbereich definiert. Es enthält Eigenschaften, mit denen die Seiten- und Druckereinrichtung eines<br />
Dokuments gesteuert werden kann.<br />
Beispiel<br />
Der folgende Quellcode druckt die Tabelle im Querformat aus:<br />
• Visual Basic<br />
• C#<br />
Dim gp As GridPrinter = flex.PrinterSettings<br />
gp.DefaultPageSettings.Landscape = True<br />
flex.PrintGrid("my grid")<br />
GridPrinter gp = flex.PrinterSettings;
418 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
gp.DefaultPageSettings.Landscape = true;<br />
flex.PrintGrid("my grid");<br />
• Delphi<br />
var<br />
gp: GridPrinter;<br />
begin<br />
gp := flex.PrinterSettings;<br />
gp.DefaultPageSettings.Landscape := True;<br />
flex.PrintGrid('my grid');<br />
end;<br />
Schauen Sie ferner unter<br />
GridPrinter-Klasse (Seite 412)<br />
PrintPreviewDialog-Eigenschaft<br />
Hiermit können Sie Eigenschaften für das integrierte Druckvorschaufenster festlegen.<br />
Syntax<br />
[VB]<br />
Public PrintPreviewDialog As PrintDocument<br />
[C#]<br />
public PrintDocument PrintPreviewDialog {get;}<br />
[Delphi]<br />
property PrintPreviewDialog: PrintDocument;<br />
Bemerkungen<br />
Zum Beispiel, der nachfolgende Quellcode legt die Überschrift und die Größe des integrierten<br />
Druckvorschaufensters (PrintPreview dialog) fest:<br />
• Visual Basic<br />
• C#<br />
Dim dlg As PrintPreviewDialog =<br />
_flex.PrintParameters.PrintPreviewDialog<br />
dlg.Text = "Custom Caption in Preview Dialog"<br />
dlg.ClientSize = New Size(500, 500)<br />
PrintPreviewDialog dlg = _flex.PrintParameters.PrintPreviewDialog;<br />
dlg.Text = "Custom Caption in Preview Dialog";<br />
dlg.ClientSize = new Size(500,500);<br />
• Delphi<br />
var<br />
dlg: PrintPreviewDialog;<br />
begin<br />
dlg := _flex.PrintParameters.PrintPreviewDialog;<br />
dlg.Text := 'Custom Caption in Preview Dialog';<br />
dlg.ClientSize := Size.Create(500, 500);<br />
end;<br />
Schauen Sie ferner unter<br />
GridPrinter-Klasse (Seite 412)
<strong>C1FlexGrid</strong>-Aufzählungen<br />
AggregateEnum-Aufzählung<br />
AggregateEnum-Aufzählung · 419<br />
Legt den Typ der Aggregierungsfunktion für die Berechnungen in den Aggregate- und Subtotal-<br />
Methoden fest.<br />
Syntax<br />
[VB]<br />
Public Enum AggregateEnum<br />
[C#]<br />
public sealed enum AggregateEnum : System.Enum<br />
[Delphi]<br />
type AggregateEnum = (Average, Clear, Count, Max, Min, None, Percent, Std, StdPop, Sum, Var,<br />
VarPop);<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
None<br />
Clear<br />
Keine Aggregierung. Diese Einstellung wird von der Subtotal-Methode verwendet,<br />
um einen Gliederungsbaum ohne numerische Gesamtbeträge zu erstellen.<br />
Löscht vorhandene Aggregierungen. Diese Einstellung wird von der Subtotal-<br />
Methode verwendet, um vorhandene Zwischensummen, meistens vor einer<br />
Neuberechnung, zu löschen.<br />
Sum Gibt die Summe aller Werte in einem Bereich zurück.<br />
Percent<br />
Anteil an einer Gesamtsumme. Diese Einstellung wird von der Subtotal-Methode<br />
verwendet, um den Anteil in Prozent einer Untergruppe an der Gesamtsumme zu<br />
berechnen. Diese Einstellung kann nicht in der Aggregate-Methode verwendet<br />
werden.<br />
Count Gibt die Anzahl der von Null verschiedenen Zellen in einem Bereich zurück.<br />
Average Gibt den Durchschnitt der von Null verschiedenen Zellen in einem Bereich zurück.<br />
Max Gibt den größten Wert in einem Bereich zurück.<br />
Min Gibt den kleinsten Wert in einem Bereich zurück.<br />
Std<br />
Var<br />
StdPop<br />
VarPop<br />
Gibt die Standardabweichung der Werte einer Stichprobe in einem Bereich zurück<br />
(Verwendet die auf (n-1) basierende Formel).<br />
Gibt die Varianz der Werte einer Stichproben in einem Bereich zurück (Verwendet<br />
die auf (n-1) basierende Formel).<br />
Gibt die Standardabweichung der Werte einer Grundgesamtheit in einem Bereich<br />
zurück (Verwendet die auf (n) basierende Formel).<br />
Gibt die Varianz der Werte einer Grundgesamtheit in einem Bereich zurück<br />
(Verwendet die auf (n) basierende Formel).
420 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
AggregateFlags-Aufzählung<br />
Legt die Optionen für die Berechnung der Gesamtbeträge mit der Aggregate-Methode fest.<br />
Syntax<br />
[VB]<br />
Public Enum AggregateFlags<br />
[C#]<br />
public sealed enum AggregateFlags : System.Enum<br />
[Delphi]<br />
type AggregateFlags = (AggregateDates, ExcludeNodes, None);<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
None Verwendet alle Zeilen, aber nur numerische Werte.<br />
ExcludeNodes<br />
AggregateDates<br />
Mitgliedsname Beschreibung<br />
AggregateBooleans<br />
AllowFreezingEnum-Aufzählung<br />
Schließt die Knotenzeilen von der Berechnug aus. Diese Option ist nützlich,<br />
wenn die Tabelle Zwischensummen in den Knotenzeilen enthält und diese daher<br />
in die Berechnung des Gesamtbetrages nicht mit einfließen dürfen.<br />
Berechnet Gesamtbeträge für Daten anstatt für numerische Wert. Nur wenige<br />
Berechnugsfunktionen sind für Daten sinnvoll: count, maximum und minimum.<br />
Zwingt die Steuerung dazu, Wahrheitswertzellen in Aggregierungen zu beachten:<br />
TRUE-Werte zählen als 1, FALSE als 0. Zum Beispiel können Sie die Anzahl von<br />
wahren Zellen in einem Bereich wie folgt abfragen:<br />
// Summenwerte in einem Bereich, zähle TRUE-Werte als 1<br />
double sum = _flex.Aggregate(AggregateEnum.Sum, 1, 1, 49, 1,<br />
AggregateFlags.AggregateBooleans);<br />
Legt fest, ob Zellen in der Tabelle eingefroren werden können.<br />
Syntax<br />
[VB]<br />
Public Enum AllowFreezingEnum<br />
[C#]<br />
public sealed enum AllowFreezingEnum : System.Enum<br />
[Delphi]<br />
type AllowFreezingEnum = (Both, Columns, None, Rows);
Mitglieder<br />
AllowMergingEnum-Aufzählung · 421<br />
Mitgliedsname Beschreibung<br />
None Der Nutzer kann Zeilen und Spalten mit der Maus nicht einfrieren (Standard).<br />
Columns Der Nutzer kann Spalten mit der Maus einfrieren.<br />
Rows Der Nutzer kann Zeilen mit der Maus einfrieren.<br />
Both Der Nutzer kann Zeilen und Spalten mit der Maus einfrieren.<br />
AllowMergingEnum-Aufzählung<br />
Legt fest, welche Zellen sich verbinden dürfen.<br />
Syntax<br />
[VB]<br />
Public Enum AllowMergingEnum<br />
[C#]<br />
public sealed enum AllowMergingEnum : System.Enum<br />
[Delphi]<br />
type AllowMergingEnum = (FixedOnly, Free, Nodes, None, RestrictAll, RestrictCols, RestrictRows,<br />
Spill);<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
None Zellen nicht verbinden.<br />
Free Angrenzende Zellen mit gleichem Inhalt verbinden.<br />
RestrictRows Zeilen verbinden, wenn die Zellen darüber auch verbunden sind.<br />
RestrictCols Spalten verbinden, wenn die Zellen links davon auch verbunden sind.<br />
RestrictAll Zellen verbinden, wenn die Zellen darüber und links davon auch verbunden sind.<br />
FixedOnly<br />
Nur fixierte Zellen verbinden. Diese Einstellung ist für komplexe Überschriften<br />
sinnvoll, ohne dabei die Datenzellen selbst zu verbinden.<br />
Spill Langen Einträgen erlauben, in leere, angrenzende Zellen überzugehen.<br />
Nodes<br />
AllowResizingEnum-Aufzählung<br />
Langen Einträgen in Knotenzeilen erlauben, in leere, angrenzende Zellen<br />
überzugehen.<br />
Legt fest, welche Tabellenelemente (Zeilen und/oder Spalten) mit der Maus in deren Größe verändert<br />
werden dürfen.
422 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Syntax<br />
[VB]<br />
Public Enum AllowResizingEnum<br />
[C#]<br />
public sealed enum AllowResizingEnum : System.Enum<br />
[Delphi]<br />
type AllowResizingEnum = (Both, BothUniform, Columns, ColumnsUniform, None, Rows,<br />
RowsUniform);<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
None Der Nutzer kann die Größe von Zeilen und Spalten nicht verändern.<br />
Columns<br />
ColumnsUniform<br />
Rows<br />
Both<br />
RowsUniform<br />
BothUniform<br />
AllowDraggingEnum-Aufzählung<br />
Der Nutzer kann die Breite von Spalten verändern, indem er die Kanten der<br />
fixierten Spalten oben in der Tabelle entsprechend zieht. Ein Doppelklick auf die<br />
Kante der fixierten Zellen passt die Breite an deren breitesten Eintrag an.<br />
Der Nutzer kann die Breite einer Spalte mit der Maus verändern. Wenn die<br />
Größe einer Spalte verändert wurde, dann wird die neue Spaltenbreite auf alle<br />
Spalten angewendet.<br />
Der Nutzer kann die Höhe von Zeile verändern, indem er die Kanten der fixierten<br />
Zeilen links in der Tabelle entsprechend zieht. Ein Doppelklick auf die Kante der<br />
fixierten Zellen passt die Höhe an deren höchsten Eintrag an.<br />
Der Nutzer kann die Höhe von Zeilen und die Breite von Spalten mit der Maus<br />
verändern.<br />
Der Nutzer kann die Höhe einer Zeile mit der Maus verändern. Wenn die Größe<br />
einer Zeile verändert wurde, dann wird die neue Zeilenhöhe auf alle Zeilen<br />
angewendet.<br />
Der Nutzer kann die Höhe von Zeilen und die Breite von Spalten mit der Maus<br />
verändern. Wenn die Größe einer Zeile oder Spalte verändert wurde, dann wird<br />
die neue Höhe oder Breite auf alle Zeilen oder Spalten angewendet.<br />
Legt fest, welche Tabellenelemente (Zeilen und/oder Spalten) mit der Maus gezogen werden dürfen.<br />
Syntax<br />
[VB]<br />
Public Enum AllowDraggingEnum<br />
[C#]<br />
public sealed enum AllowDraggingEnum : System.Enum<br />
[Delphi]<br />
type AllowDraggingEnum = (Both, Columns, None, Rows);
Mitglieder<br />
Mitgliedsname Beschreibung<br />
None Der Nutzer kann mit der Maus Zeilen und Spalten nicht ziehen.<br />
Columns Der Nutzer kann mit der Maus Spalten auf neue Poitionen ziehen.<br />
Rows Der Nutzer kann mit der Maus Zeilen auf neue Poitionen ziehen.<br />
AllowSortingEnum-Aufzählung · 423<br />
Both Der Nutzer kann mit der Maus Zeilen und Spalten auf neue Poitionen ziehen.<br />
AllowSortingEnum-Aufzählung<br />
Legt fest, ob der Nutzer Spalten mit der Maus sortieren darf.<br />
Syntax<br />
[VB]<br />
Public Enum AllowSortingEnum<br />
[C#]<br />
public sealed enum AllowSortingEnum : System.Enum<br />
[Delphi]<br />
type AllowSortingEnum = (MultiColumn, SingleColumn, None);<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
None Der Nutzer kann Spalten nicht mit der Maus sortieren.<br />
SingleColumn<br />
MultiColumn<br />
AutoSearchEnum-Aufzählung<br />
Der Nutzer kann Spalten mit der Maus sortieren. Klickt man auf die<br />
Spaltenüberschrift, so werden diese jeweils auf- oder absteigend sortiert.<br />
Diese Funktion ist gleich denen, die in den meisten Standardanwendungen, wie<br />
zum Beispiel Windows Explorer, zu finden sind.<br />
Der Nutzer kann Spalten mit der Maus sortieren. Klickt man auf die<br />
Spaltenüberschrift, so werden alle Spalten von der Ersten bis zu der, auf die man<br />
klickte, auf- oder absteigend sortiert.<br />
Diese Einstellung ist sinnvoll, wenn die Daten in Kategorien von links nach rechts<br />
gruppiert sind und Sie diese Gruppen trotz Sortieren erhalten wollen.<br />
Legt fest, wo die Tabelle anfangen soll, nach Zellen zu suchen, wenn die AutoSearch-Eigenschaft<br />
verwendet wird.<br />
Syntax<br />
[VB]<br />
Public Enum AutoSearchEnum
424 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
[C#]<br />
public sealed enum AutoSearchEnum : System.Enum<br />
[Delphi]<br />
type AutoSearchEnum = (FromCursor, FromTop, None);<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
None Automatisches Suchen deaktivieren.<br />
FromTop<br />
FromCursor<br />
AutoSizeFlags-Aufzählung<br />
Wenn der Nutzer anfängt zu schreiben, soll nach Übereinstimmungen von oben<br />
nach unten in der Tabelle gesucht werden.<br />
Wenn der Nutzer anfängt zu schreiben, soll nach Übereinstimmungen ab der<br />
aktuellen Zeile gesucht werden.<br />
Legt die Optionen fest, wenn die Größe von Zeilen und/oder Spalten automatisch angepasst wird.<br />
Syntax<br />
[VB]<br />
Public Enum AutoSizeFlags<br />
[C#]<br />
public sealed enum AutoSizeFlags : System.Enum<br />
[Delphi]<br />
type AutoSizeFlags = (IgnoreHidden, IgnoreMerged, None, SameSize);<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
None Standardverhalten bei automatischer Größenanpassung.<br />
SameSize<br />
Wendet die gleiche Größe auf alle Zeilen oder Spalten an, deren Größe verändert<br />
wird.<br />
IgnoreHidden Übergeht versteckte Zeilen und Spalten, wenn Zellgrößen berechnet werden.<br />
IgnoreMerged Übergeht verbundene Zeilen und Spalten, wenn Zellgrößen berechnet werden.<br />
BorderDirEnum-Aufzählung<br />
Legt die Ausrichtung der Zellrahmen fest.<br />
Syntax<br />
[VB]<br />
Public Enum BorderDirEnum
[C#]<br />
public sealed enum BorderDirEnum : System.Enum<br />
[Delphi]<br />
type BorderDirEnum = (Both, Horizontal, Vertical);<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
Both Zeichnet Zellrahmen in beide Richtungen.<br />
Horizontal Zeichnet Zellrahmen nur in horizontaler Richtungen.<br />
Vertical Zeichnet Zellrahmen nur in vertikaler Richtungen.<br />
BorderStyleEnum-Aufzählung<br />
Legt den Typ des Rahmens fest, der um die Zelle gezeichnet wird.<br />
Syntax<br />
[VB]<br />
Public Enum BorderStyleEnum<br />
[C#]<br />
public sealed enum BorderStyleEnum : System.Enum<br />
[Delphi]<br />
type BorderStyleEnum = (Fixed, FixedSingle, Light3D, None, XpThemes);<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
Fixed3D Der Rahmen ist eine Linie mit 3D-Effekt.<br />
FixedSingle Der Rahmen ist eine einfache Linie.<br />
Light3D Der Rahmen ist eine schwache, ein Pixel breite 3D-Linie.<br />
None Kein Rahmen.<br />
XpThemes<br />
CellStyleEnum-Aufzählung<br />
BorderStyleEnum-Aufzählung · 425<br />
Zwingt die Steuerung, XP-Motive für fixierte Zellen zu verwenden, Hot-Tracking<br />
eingeschlossen.<br />
Legt die Standardformate fest und kann als Index in der Styles-Eigenschaft verwendet werden.<br />
Syntax<br />
[VB]<br />
Public Enum CellStyleEnum
426 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
[C#]<br />
public sealed enum CellStyleEnum : System.Enum<br />
[Delphi]<br />
type CellStyleEnum = (Alternate, EmptyArea, FirstCustomStyle, Fixed, Focus, Frozen, GrandTotal,<br />
Highlight, NewRow, Normal, Search, Subtotal0,, Subtotal1, Subtotal2, Subtotal3, Subtotal4, Subtotal5);<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
Normal Formatvorlage, mit der scrollbare, normale Zellen gerendert werden.<br />
Alternate<br />
Fixed<br />
Highlight<br />
Focus<br />
Editor<br />
Search<br />
Frozen<br />
NewRow<br />
EmptyArea<br />
GrandTotal<br />
Subtotal(0-5)<br />
CheckEnum-Aufzählung<br />
Formatvorlage, mit der scrollbare Zellen in gerade nummerierten Zeilen gerendert<br />
werden. Standardmäßig ist diese Vorlage leer, so dass alle scrollbaren Zellen mit<br />
der Formatvorlage Normal gerendert werden.<br />
Formatvorlage, mit der fixierte Zellen gerendert werden. Standardmäßig besitzt<br />
diese Vorlage eine eigene Hintergrundfarbe.<br />
Formatvorlage, mit der ausgewählte und markierte Zellen gerendert werden.<br />
Standardmäßig besitzt diese Vorlage eine eigene Hinter- und Vordergrundfarbe.<br />
Formatvorlage, mit der Fokuszellen gerendert werden. Standardmäßig ist diese<br />
Vorlage leer, so dass alle fokussierten Zellen mit der Formatvorlage Normal<br />
gerendert werden.<br />
Formatvorlage, mit der Zellen während ihrer Bearbeitung gerendert werden.<br />
Standardmäßig ist diese Vorlage leer, so dass alle Zellen während ihrer<br />
Bearbeitung mit der Formatvorlage Normal gerendert werden.<br />
Formatvorlage, mit der Zellen gerendert werden, die ausgewählt sind, während der<br />
Nutzer im AutoSerach-Modus eine Eingabe vornimmt. Standardmäßig besitzt diese<br />
Vorlage eine eigene Hintergrundfarbe.<br />
Formatvorlage, mit der eingefrorene Zellen (bearbeitbar, aber nicht scrollbar)<br />
gerendert werden. Standardmäßig besitzt diese Vorlage eine eigene<br />
Hintergrundfarbe.<br />
Formatvorlage, mit der die letzte Zeile in der Tabelle gerendert wird, wenn die<br />
AllowAddNew-Eigenschaft auf TRUE steht. Diese Zeile wird dafür verwendet, neue<br />
Elemente der Tabelle hinzuzufügen.<br />
Formatvorlage, mit der der Bereich in der Tabelle gerenderet wird, wo keine Zellen<br />
mehr sind. Der für diese Vorlage verwendete Rahmentyp legt die Umrandung, die<br />
um alle Zellen in der Tabelle gezeichnet wird, fest.<br />
Formatvorlage, die automatisch auf die von der Subtotal-Methode erstellten<br />
Gesamtsummenzeile angewendet wird. Standardmäßig besitzt diese Vorlage eine<br />
eigene Hinter- und Vordergrundfarbe.<br />
Formatvorlage, die automatisch auf die von der Subtotal-Methode erstellten<br />
Zwischensummenzeilen angewendet wird. Standardmäßig besitzt diese Vorlage<br />
eine eigene Hinter- und Vordergrundfarbe.<br />
Legt den Typ des Kontrollkästchens einer Zelle fest.
Syntax<br />
[VB]<br />
Public Enum CheckEnum<br />
[C#]<br />
public sealed enum CheckEnum : System.Enum<br />
[Delphi]<br />
type CheckEnum = (Checked, None, TSChecked, TSGrayed, TSUnchecked, Unchecked);<br />
Bemerkungen<br />
Es gibt zwei Kontrollkästchentypen: Boolean und Tri-State.<br />
ClearFlags-Aufzählung · 427<br />
Normale Kontrollkästchen werden verwendet, um normale Wahrheitswerte anzuzeigen. Sie schalten<br />
zwischen den beiden Zuständen Aktiviert und Deaktiviert um, wenn sie mit der Maus angeklickt werden.<br />
Drei-Zustands-Kontrollkästchen werden verwendet, um Werte, die wahr, falsch oder unbestimmt (grau)<br />
sein können, anzuzeigen. Sie schalten zwischen den beiden Zuständen TSChecked, TSGrayed und<br />
TSUnchecked um, wenn sie mit der Maus angeklickt werden.<br />
Die Zustände Checked und Unchecked sehen äußerlich genauso wie TSChecked und TSUnchecked aus.<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
None Kein Kontrollkästchen.<br />
Checked Kontrollkästchen mit einem Häkchen drin.<br />
Unchecked Leeres Kontrollkästchen.<br />
TSChecked Drei-Zustands-Kontrollkästchen mit einem Häkchen drin.<br />
TSUnchecked Leeres drei-Zustands-Kontrollkästchen.<br />
TSGrayed Drei-Zustands-Kontrollkästchen im grauen Zustand.<br />
ClearFlags-Aufzählung<br />
Legt fest, welche Elemente mit der Clear-Methode gelöscht werden.<br />
Syntax<br />
[VB]<br />
Public Enum ClearFlags<br />
[C#]<br />
public sealed enum ClearFlags : System.Enum<br />
[Delphi]<br />
type ClearFlags = (All, Content, Style, UserData);
4<strong>28</strong> · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
Content Löscht Zelldaten, inklusive Grafiken uns Kontrollkästchen, wenn vorhanden.<br />
Style Löscht die einer Zelle zugeordnete benutzerdefinierte Formatvorlage.<br />
UserData Löscht die einer Zelle zugeordneten Benutzerdaten.<br />
All Alle der oben genannten.<br />
DisplayEnum-Aufzählung<br />
Ein Typ der CellStyle.Display-Eigenschaft. Jede Tabellenzelle kann einen als Text angezeigten Wert und<br />
eine Grafik beinhalten. Die Display-Eigenschaft legt fest, was angezeigt und wie es in der Zelle<br />
angeordnet wird.<br />
Syntax<br />
[VB]<br />
Public enum DisplayEnum<br />
[C#]<br />
public sealed enum DisplayEnum : System.Enum<br />
[Delphi]<br />
type DisplayEnum = (ImageOnly, None, OverLay, Stack, TextOnly);<br />
Bemerkungen<br />
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert eines Arguments der Display-<br />
Eigenschaft in der <strong>C1FlexGrid</strong>-Steuerung zu setzen.<br />
Mitgliedsname Beschreibung<br />
ImageOnly Zeigt nur die Grafik an (kein Wert).<br />
None Nichts (Zelle bleibt leer).<br />
OverLay Grafik und Wert (übereinander).<br />
Stack Grafik und Wert (nebeneinander).<br />
TextOnly Zeigt nur den Wert an (keine Grafik).<br />
DragModeEnum-Aufzählung<br />
Legt fest, wie OLE-Drag-und-Drop-Operationen gehandhabt werden.<br />
Syntax<br />
[VB]<br />
Public Enum DragModeEnum
[C#]<br />
public sealed enum DragModeEnum : System.Enum<br />
[Delphi]<br />
type DragModeEnum = (Automatic, AutomaticCopy, AutomaticMove, Manual);<br />
Mitglieder<br />
DrawCellFlags-Aufzählung · 429<br />
Mitgliedsname Beschreibung<br />
Manual Die Steuerung stellt keine Unterstützung für Ziehen von Objekten zur Verfügung.<br />
Automatic<br />
Die Steuerung stellt Ziehen automatisch als Verschieben und als Kopieren zur<br />
Verfügung.<br />
AutomaticCopy Die Steuerung stellt Ziehen automatisch als Kopieren zur Verfügung.<br />
AutomaticMove Die Steuerung stellt Ziehen automatisch als Verschieben zur Verfügung.<br />
DrawCellFlags-Aufzählung<br />
Legt fest, welches Tabellenelement gezeichnet wird.<br />
Syntax<br />
[VB]<br />
Public Enum DrawCellFlags<br />
[C#]<br />
public sealed enum DrawCellFlags : System.Enum<br />
[Delphi]<br />
type DrawCellFlags = (All, Background, Border, Content);<br />
Bemerkungen<br />
Diese Aufzählung wird verwendet, wenn vom Nutzer gezeichnete Zellen gerendert werden.<br />
Wenn Sie die DrawMode-Eigenschaft auf DrawModeEnum.OwnerDraw setzen, dann wird die Tabelle<br />
das OwnerDrawCell-Ereignis starten, um benutzerdefiniertes Zeichnen der Zellen zu erlauben. Die<br />
OwnerDrawCellEventArgs-Parameter besitzen eine DrawCell-Methode, mit der Sie die<br />
Standardroutinen für das Zeichnen auch für das Rendern des Zellhintergrunds, der Rahmen und/oder<br />
der Zellinhalte verwenden können. Zum Beispiel können Sie einen eigenen Hintergrund zeichnen und<br />
dennoch die Standardroutinen für das Zeichnen des Zellrahmens und des Inhalts verwenden.<br />
Schauen Sie im OwnerDrawCell-Ereignis für ein Beispiel nach.<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
Background Zeichnet den Zellhintergrund.<br />
Border Zeichnet den Zellrahmen.<br />
Content Zeichnet den Zellinhalt (Text, Grafik und Kontrollkästchen).
430 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
All Alle der oben genannten.<br />
DrawModeEnum-Aufzählung<br />
Legt fest, wie Tabellenzellen gezeichnet werden.<br />
Syntax<br />
[VB]<br />
Public Enum DrawModeEnum<br />
[C#]<br />
public sealed enum DrawModeEnum : System.Enum<br />
[Delphi]<br />
type DrawModeEnum = (Normal, OwnerDraw);<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
Normal Tabellenzellen werden von der Steuerung gezeichnet.<br />
OwnerDraw<br />
DropModeEnum-Aufzählung<br />
Die Tabelle startet das OwnerDrawCell-Ereignis, um benutzerdefiniertes Zeichnen<br />
von Zellen zu erlauben.<br />
Legt fest, wie OLE-Drag-und-Drop-Operationen gehandhabt werden.<br />
Syntax<br />
[VB]<br />
Public Enum DropModeEnum<br />
[C#]<br />
public sealed enum DropModeEnum : System.Enum<br />
[Delphi]<br />
type DropModeEnum = (Automatic, Manual, None);<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
None Die Steuerung ist kein Ziel zum Ablegen von Objekten.<br />
Manual Die Steuerung startet Ereignisse.<br />
Automatic Die Steuerung wickelt automatisch das Ablegen von Text und Dateinamen ab.
EditFlags-Aufzählung<br />
Legt Optionen für die Verwendung der EditOptions-Eigenschaft fest.<br />
Syntax<br />
[VB]<br />
Public Enum EditFlags<br />
[C#]<br />
public sealed enum EditFlags : System.Enum<br />
[Delphi]<br />
type EditFlags = (Automatic, Manual, None);<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
None Keine Flags, deaktiviert alle Optionen.<br />
AutoSearch<br />
CycleOnDoubleClick<br />
MultiCheck<br />
All<br />
FileFlags-Aufzählung<br />
EditFlags-Aufzählung · 431<br />
Stellt die automatische Suchefunktion zur Verfügung, wenn mit den integrierten<br />
ComboBox-Feldern bearbeitet wird. Diese Option zwingt die Tabelle dazu,<br />
Einträge zu suchen und auszuwählen, während Sie diese eingeben. Das<br />
Intervall, bevor der Suchpuffer geleert wird, kann mit der AutoSearchDelay-<br />
Eigenschaft festgelegt werden.<br />
Wählt automatisch den nächsten Wert aus, wenn der Nutzer auf eine Zelle<br />
doppelklickt, der eine ComboList oder DataMap zugeordnet ist.<br />
Schaltet alle ausgewählten Kontrollkästchen um, wenn ein beliebiges<br />
Kontrollkästchen umgeschaltet wird.<br />
Aktiviert alle Optionen. Dies ist die Standardeinstellung für die EditOptions-<br />
Eigenschaft.<br />
Legt Optionen für die Verwendung der SaveGrid- und LoadGrid-Methoden fest.<br />
Syntax<br />
[VB]<br />
Public Enum FileFlags<br />
[C#]<br />
public sealed enum FileFlags : System.Enum<br />
[Delphi]<br />
type FileFlags = (None, IncludeFixedCells, VisibleOnly, SelectedRowsOnly);
432 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
None Keine Flags, verwendet Standardeinstellungen.<br />
IncludeFixedCells Schließt fixierte Zellen ein, wenn eine Tabelle geladen oder gespeichert wird.<br />
VisibleOnly Speichert nur sichtbare Zeilen und Spalten. Gilt nicht für Excel-Dateien.<br />
SelectedRowsOnly Speichert nur ausgewählte Zeilen. Gilt nicht für Excel-Dateien.<br />
FileFormatEnum-Aufzählung<br />
Legt den mit den SaveGrid- und LoadGrid-Methoden zu speichernden oder zu öffnenden Dateityp fest.<br />
Syntax<br />
[VB]<br />
Public Enum FileFormatEnum<br />
[C#]<br />
public sealed enum FileFormatEnum : System.Enum<br />
[Delphi]<br />
type FileFormatEnum = (TextComma, TextCustom, TextTab);<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
TextComma Zellen werden mit Kommata abgegrenzt.<br />
TextTab Zellen werden mit Tabulatoren abgegrenzt.<br />
TextCustom Zellen werden mit dem Zeichen aus der ClipSeparators-Eigenschaft abgegrenzt.<br />
Excel Speichert und lädt Microsoft Excel-Dateien (*:xls).<br />
FocusRectEnum-Aufzählung<br />
Legt das Aussehen des Fokusrechtecks auf der Tabelle fest.<br />
Syntax<br />
[VB]<br />
Public Enum FocusRectEnum<br />
[C#]<br />
public sealed enum FocusRectEnum : System.Enum<br />
[Delphi]<br />
type FocusRectEnum = (Heavy, Inset, Light, None, Raised, Solid);
Mitglieder<br />
Mitgliedsname Beschreibung<br />
None Kein Fokusrechteck.<br />
Light Ein ein Pixel breites, gestricheltes Rechteck.<br />
Heavy Ein zwei Pixel breites, gestricheltes Rechteck.<br />
Solid<br />
GlyphEnum-Aufzählung · 433<br />
Ein ein Pixel breites, durchgängiges Rechteck. Die Farbe ist die gleiche, wie die des<br />
Hintergrunds einer Auswahl (Styles.Highlight.BackColor).<br />
Raised Ein ein Pixel breites, erhobenes Rechteck, das mit Systemfarben gezeichnet wird.<br />
Inset<br />
GlyphEnum-Aufzählung<br />
Ein ein Pixel breites, eingelassenes Rechteck, das mit Systemfarben gezeichnet<br />
wird.<br />
Legt den von der Tabelle verwendeten Typ eines Glyphs (Grafik) fest, um Information über eine Zeile,<br />
Spalte oder Zelle zu verbreiten.<br />
Syntax<br />
[VB]<br />
Public Enum GlyphEnum<br />
[C#]<br />
public sealed enum GlyphEnum : System.Enum<br />
[Delphi]<br />
type GlyphEnum = (Ascending, Checked, Collapsed, DBAdd, DBCursor, Descending, ErrorInfo,<br />
Expanded, Grayed, Unchecked);<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
Ascending<br />
Descending<br />
Zeigt aufsteigende Spaltensortierung an (Standard ist eine hohles, nach oben<br />
gerichtetes Dreieck).<br />
Zeigt absteigende Spaltensortierung an (Standard ist eine hohles, nach unten<br />
gerichtetes Dreieck).<br />
Checked Kontrollkästchen mit Haken (aktivierter Zustand).<br />
Unchecked Kontrollkästchen ohne Haken (deaktivierter Zustand).<br />
Grayed Kontrollkästchen mit grauem Feld (undefinierter Zustand).<br />
Collapsed Eingeklappter Baumknoten (Standard ist ein Pluszeichen).<br />
Expanded Ausgeklappter Baumknoten (Standard ist ein Minuszeichen).<br />
DBCursor<br />
Zeigt aktuellen Datensatz an (Standard ist ein schwarzes, nach rechts zeigendes<br />
Dreieck).
434 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Mitgliedsname Beschreibung<br />
DBAdd<br />
Zeigt den der Datenquelle hinzuzufügenden Datensatz an (Standard ist ein Asteriks<br />
(*)).<br />
ErrorInfo Zeigt Zeilen- oder Zellfehler an (Standard ist ein rotes Ausrufezeichen).<br />
GridChangedTypeEnum-Aufzählung<br />
Legt den Typ der Änderung fest, der das GridChanged-Ereignis startet.<br />
Syntax<br />
[VB]<br />
Public Enum GridChangedTypeEnum<br />
[C#]<br />
public sealed enum GridChangedTypeEnum : System.Enum<br />
[Delphi]<br />
type GridChangedTypeEnum = (AfterCollapse, AfterSelChange, BeforeCollapse, BeforeSetChange,<br />
ColAdded, ColMoved, ColRemoved, ColSelected, EnsureVisible, GridChanged, LayoutChanged, None,<br />
RepaintCell, RepaintGrid, RepaintRange, RowAdded, RowMoved, RowRemoved, RowSelected, Select,<br />
StyleChanged, update);<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
None Keine Maßnahme.<br />
GridChanged Die Anzahl der geänderten Zeilen oder Spalten.<br />
LayoutChanged Die Anzahl der geänderten fixen Zeilen oder Spalten.<br />
StyleChanged Ein oder mehrere Formatvorlagen haben sich geändert.<br />
StyleApplied Eine neue Formatvorlage wurde auf den Bereich angewendet.<br />
RepaintGrid Die Tabelle wird gleich neu gezeichnet.<br />
RepaintCell Eine Zelle wird gleich neu gezeichnet.<br />
RepaintRange Ein Zellbereich wird gleich neu gezeichnet .<br />
Update Das Tabellenfenster wird aktualisiert.<br />
BeforeCollapse Eine Knotenzeile wird gleich aus- oder eingeklappt.<br />
AfterCollapse Eine Knotenzeile wurde eben aus- oder eingeklappt.<br />
EnsureVisible Eine Knotenzeile wird auf den Bildschirm gebracht.<br />
Select Eine Knotenzeile wird gleich ausgewählt.<br />
RowMoved Eine Zeile wurde verschoben.<br />
RowAdded Eine Zeile wurde hinzugefügt.<br />
RowRemoved Eine Zeile wurde gelöscht.
Mitgliedsname Beschreibung<br />
RowSelected Eine Zeile wurde ausgewählt.<br />
ColMoved Eine Spalte wurde verschoben.<br />
ColAdded Eine Spalte wurde hinzugefügt.<br />
ColRemoved Eine Spalte wurde gelöscht.<br />
ColSelected Eine Spalte wurde ausgewählt.<br />
BeforeSelChange Die Auswahl ändert sich gleich.<br />
AfterSelChange Die Auswahl hat sich geändert.<br />
HighLightEnum-Aufzählung<br />
Legt fest, wann die aktuelle Auswahl markiert wird.<br />
Syntax<br />
[VB]<br />
Public Enum HighLightEnum<br />
[C#]<br />
public sealed enum HighLightEnum : System.Enum<br />
[Delphi]<br />
type HighLightEnum = (Always, Never, WithFocus);<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
Never Markiert nie eine Auswahl.<br />
Always Markiert immer eine Auswahl.<br />
WithFocus Markiert eine Auswahl, wenn die Steuerung den Fokus hat.<br />
HitTestTypeEnum-Aufzählung<br />
Typ eines Tabellenelements, das einen Punkt in der Steuerung festlegt.<br />
Syntax<br />
[VB]<br />
Public Enum HitTestTypeEnum<br />
[C#]<br />
public sealed enum HitTestTypeEnum : System.Enum<br />
[Delphi]<br />
HighLightEnum-Aufzählung · 435<br />
type HitTestTypeEnum = (Cell, Checkbox, ColumnFreeze, ColumnHeader, ColumnResize, EditButton,<br />
None, OutlineBar, OutlineTree, RowFreeze, RowHeader, RowResize);
436 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
None Der Punkt liegt im leeren Bereich der Tabelle.<br />
Cell<br />
Der Punkt liegt auf einer Tabellenzelle. Die Zellkoordinaten werden in den Row-,<br />
Column-Eigenschaften des HitTestInfo-Objekts gespeichert.<br />
ColumnHeader Der Punkt liegt auf einer fixierten Zeile über einer Spalte.<br />
ColumnResize<br />
ColumnFreeze<br />
Der Punkt liegt nah der rechten Kante einer fixierten Zelle im<br />
Größenänderungsbereich der Spalte.<br />
Der Punkt liegt nah der rechten Kante der letzten eingefrorenen Spalte im<br />
Spalteneinfrierbereich.<br />
RowHeader Der Punkt liegt auf einer fixierten Spalte neben einer Zeile.<br />
RowResize<br />
RowFreeze<br />
Der Punkt liegt nah der unteren Kante einer fixierten Zelle im<br />
Größenänderungsbereich der Zeile.<br />
Der Punkt liegt nah der unteren Kante der letzten eingefrorenen Zeile im<br />
Zeileneinfrierbereich.<br />
CheckBox Der Punkt liegt auf einem Kontrollkästchen.<br />
EditButton Der Punkt liegt auf einer Bearbeitungsschaltfläche (Auswahl- oder Popup-Editoren).<br />
OutlineBar<br />
OutlineTree<br />
ImageAlignEnum-Aufzählung<br />
Der Punkt liegt auf der Gliederungsleiste (Sichtbar wenn die Tree.Style-Eigenschaft<br />
der Tabelle den ButtonBar-Flag enthält).<br />
Der Punkt liegt auf der Ein-/Ausklappschaltfläche eines Gleiderungbaums (Sichtbar<br />
wenn die Tree.Style-Eigenschaft der Tabelle den Symbols-Flag enthält).<br />
Legt fest, wie Grafiken in Zellen ausgerichtet werden.<br />
Syntax<br />
[VB]<br />
Public Enum ImageAlignEnum<br />
[C#]<br />
public sealed enum ImageAlignEnum : System.Enum<br />
[Delphi]<br />
type ImageAlignEnum = (CenterBottom, CenterCenter, CenterTop, Hide, LeftBottom, LeftCenter,<br />
LeftTop, RightBottom, RightCenter, RightTop, Scale, Stretch, Tile);<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
LeftTop Die Grafik wird horizontal links und vertikal oben in der Zelle ausgerichtet.<br />
LeftCenter Die Grafik wird horizontal links und vertikal zentriert in der Zelle ausgerichtet.
Mitgliedsname Beschreibung<br />
KeyActionEnum-Aufzählung · 437<br />
LeftBottom Die Grafik wird horizontal links und vertikal unten in der Zelle ausgerichtet.<br />
CenterTop Die Grafik wird horizontal zentriert und vertikal oben in der Zelle ausgerichtet..<br />
CenterCenter Die Grafik wird horizontal zentriert und vertikal zentriert in der Zelle ausgerichtet.<br />
CenterBottom Die Grafik wird horizontal zentriert und vertikal unten in der Zelle ausgerichtet.<br />
RightTop Die Grafik wird horizontal rechts und vertikal oben in der Zelle ausgerichtet.<br />
RightCenter Die Grafik wird horizontal rechts und vertikal zentriert in der Zelle ausgerichtet.<br />
RightBottom Die Grafik wird horizontal rechts und vertikal unten in der Zelle ausgerichtet.<br />
Scale Die Garfik wird skaliert, damit sie den maxiamlen Bereich der Zelle ausfüllt, wobei das<br />
Seitenverhältnis des Originalbildes beibehalten wird.<br />
Stretch Die Garfik wird skaliert, damit sie den gesamten Bereich der Zelle ausfüllt.<br />
Tile Die Garfik wird nebeneinander angeordnet damit sie die gesamte Zelle ausfüllt.<br />
Hide Die Garfik wird nicht angezeigt.<br />
KeyActionEnum-Aufzählung<br />
Legt die auszuführenden Maßnahmen fest, wenn eine besimmte Taste gedrückt wird.<br />
Syntax<br />
[VB]<br />
Public Enum KeyActionEnum<br />
[C#]<br />
public sealed enum KeyActionEnum : System.Enum<br />
[Delphi]<br />
type KeyActionEnum = (None, MoveAcross, MoveDown);<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
None<br />
Keine Handlung (das System verwaltet die Zelle). Zum Beispiel, die Tabulatortaste<br />
wird normalerweise für das Durchblättern der Steuerungen auf einem Formular<br />
verwendet.<br />
MoveDown Gehe zur nächsten Zeile, wenn die Taste gedrückt wird.<br />
MoveAcross<br />
MoveAcrossOut<br />
Gehe zur nächsten Spalte, wenn die Taste gedrückt wird. Gehe nach der letzten<br />
Spalte zur nächsten Zeile und zurück zur ersten Spalte.<br />
Gehe zur nächsten Spalte, wenn die Taste gedrückt wird. Gehe nach der letzten<br />
Spalte zur nächsten Zeile und zurück zur ersten Spalte. Verschiebe nach der letzten<br />
Zeile und Spalte den Fokus zur nächsten Steuerung auf dem Formular.
438 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
NodeMoveEnum-Aufzählung<br />
Legt das Ziel eines Knotens fest, wenn dieser mit der Node.Move-Methode verschoben wird.<br />
Syntax<br />
[VB]<br />
Public Enum NodeMoveEnum<br />
[C#]<br />
public sealed enum NodeMoveEnum : System.Enum<br />
[Delphi]<br />
type NodeMoveEnum = (ChildOf, Down, First, In, Last, Out, up);<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
In Verschiebt den Knoten in der Gliederung eine Ebene tiefer.<br />
Out Verschiebt den Knoten in der Gliederung eine Ebene höher in Richtung Quellknoten.<br />
Up Verschiebt den Knoten auf eine Position vor seinem vorhergehenden Sibling.<br />
Down Verschiebt den Knoten auf eine Position nach seinem nächsten Sibling.<br />
First Verschiebt den Knoten auf eine Position vor seinem ersten Sibling.<br />
Last Verschiebt den Knoten auf eine Position vor seinem letzten Sibling.<br />
ChildOf Verwandelt den Knoten zu einem Unterknoten eines bestimmten Knotens.<br />
NodeTypeEnum-Aufzählung<br />
Legt den Knoten fest, der mit der Node.GetNode-Methode abgefragt wird.<br />
Syntax<br />
[VB]<br />
Public Enum NodeTypeEnum<br />
[C#]<br />
public sealed enum NodeTypeEnum : System.Enum<br />
[Delphi]<br />
type NodeTypeEnum = (FirstChild, FirstSibling, LastChild, LastSibling, NextSibling, Parent,<br />
PreviousSibling, Root);<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
Root Des Knotens Quellknoten.
Mitgliedsname Beschreibung<br />
Parent Des Knotens direkter Vorgänger.<br />
FirstChild Des Knotens erster Nachfolger.<br />
LastChild Des Knotens letzter Nachfolger.<br />
PrintGridFlags-Aufzählung · 439<br />
FirstSibling Des Knotens erster Sibling (Knoten auf der selben Ebene mit dem selben<br />
übergeordneten Knoten).<br />
LastSibling Des Knotens letzter Sibling.<br />
NextSibling Des Knotens nächster Sibling.<br />
PreviousSibling Des Knotens vorhergehender Sibling.<br />
PrintGridFlags-Aufzählung<br />
Beinhaltet Flags, welche die mit der PrintGrid-Methode zu verwendenden Druckoptionen festlegen.<br />
Syntax<br />
[VB]<br />
Public Enum PrintGridFlags<br />
[C#]<br />
public sealed enum PrintGridFlags : System.Enum<br />
[Delphi]<br />
type PrintGridFlags = (ActualSize, FitToPage, FitToPageWidth, ShowPageSetupDialog,<br />
ShowPrintDialog, ShowPreviewDialog);<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
ActualSize<br />
FitToPageWidth<br />
Druckt die Tabelle in Bildschirmgröße aus. Wenn die Tabelle zu breit und/oder<br />
zu lang für eine Seite ist, dann werden die weiteren Spalten und/oder Zeilen auf<br />
neue Seiten gedruckt.<br />
Skaliert die Tabelle damit sie in der Breite auf eine Seite passt. Wenn die<br />
Tabelle zu lang für eine Seite ist, dann werden die weiteren Zeilen auf neue<br />
Seiten gedruckt.<br />
FitToPage Skaliert die Tabelle damit sie in der Breite und höhe auf eine Seite passt.<br />
ShowHighlight<br />
ShowPageSetupDialog<br />
ShowPrintDialog<br />
ShowPreviewDialog<br />
Zeigt die Auswahl während des Druckvorganges an. Standardmäßig zeigt die<br />
Tabelle die Auswahl nicht an.<br />
Zeigt das Seiteneinrichtungsfenster an, bevor die Tabelle gedruckt wird, sodass<br />
der Nutzer das Papierformat, die Ausrichtung und die Ränder einstellen kann.<br />
Zeigt das Druckereinrichtungsfenster an, bevor die Tabelle gedruckt wird ,<br />
sodass der Nutzer den zu verwendenden Drucker einstellen kann.<br />
Zeigt das Druckvorschaufenster an, bevor die Tabelle gedruckt wird, sodass der<br />
Nutzer das Dokument prüfen kann.
440 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
SelectionModeEnum-Aufzählung<br />
Legt die zu verwendende Tabellenauswahl fest.<br />
Syntax<br />
[VB]<br />
Public Enum SelectionModeEnum<br />
[C#]<br />
public sealed enum SelectionModeEnum : System.Enum<br />
[Delphi]<br />
type SelectionModeEnum = (Cell, CellRange, Column, ColumnRange, Default, ListBox, Row,<br />
RowRange);<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
Default<br />
Der Nutzer kann ununterbrochene Blöcke von Zellen mit der Tastatur und der Maus<br />
auswählen. Wenn Sie die Überschriftszellen anklicken, dann wird die gesamte Zeile<br />
oder Spalte ausgewählt.<br />
Cell Der Nutzer kann immer nur eine Zelle auswählen.<br />
CellRange<br />
Der Nutzer kann ununterbrochene Blöcke von Zellen mit der Tastatur und der Maus<br />
auswählen. Wenn auf die Überschriftszellen geklickt wird, bleibt die Auswahl<br />
unverändert.<br />
Row Der Nutzer kann immer nur eine Zeile auswählen.<br />
RowRange Der Nutzer kann immer nur einen fortlaufenden Zeilenbereich auswählen.<br />
Column Der Nutzer kann immer nur eine Spalte auswählen.<br />
ColumnRange Der Nutzer kann immer nur einen fortlaufenden Spaltenbereich auswählen.<br />
ListBox<br />
Der Nutzer kann auch nicht fortlaufende Zeilenbereiche auswählen, indem er die<br />
Ctrl-Taste hält, während er auf die Zeilen klickt.<br />
ShowButtonsEnum-Aufzählung<br />
Legt fest, wann die Tabelle Auswahllisten- und Popup-Schaltflächen in bearbeitbaren Zellen anzeigen<br />
soll.<br />
Syntax<br />
[VB]<br />
Public Enum ShowButtonsEnum<br />
[C#]<br />
public sealed enum ShowButtonsEnum : System.Enum
[Delphi]<br />
type ShowButtonsEnum = (Always, WhenEditing, WithFocus);<br />
Mitglieder<br />
SortFlags-Aufzählung · 441<br />
Mitgliedsname Beschreibung<br />
WhenEditing Schaltflächen werden nur angezeigt, während der Nutzer die Zelle bearbeitet.<br />
WithFocus Schaltflächen werden nur angezeigt, wenn der Fokus auf der Zelle liegt (Standard).<br />
Always Schaltflächen werden immer angezeigt, wenn die Zelle sichtbar ist.<br />
SortFlags-Aufzählung<br />
Beinhaltet Flags, die Sortierungsoptionen bei der Verwendung der Sort-Methode festlegen.<br />
Syntax<br />
[VB]<br />
Public Enum SortFlags<br />
[C#]<br />
public sealed enum SortFlags : System.Enum<br />
[Delphi]<br />
type SortFlags = (Ascending, AsDisplayed, Descending, IgnoreCase, None, UseColSort);<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
None<br />
Sortiert nicht. Diese Einstellung ist sinnvoll, um Spalten auszulassen, wenn ein<br />
Spaltenbereich sortiert wird.<br />
Ascending Sortiert aufsteigend.<br />
Descending Sortiert absteigend.<br />
AsDisplayed Sortiert nach den Zeichenketten der Daten. In diesem Fall steht die „100“ vor der " „2“.<br />
IgnoreCase Berücksichtigt keine Groß- und Kleinschreibung, wenn Zeichenketten sortiert werden.<br />
UseColSort Verwendet die sort-Flags der Sort-Eigenschaft eines jeden Spaltenobjekts.<br />
StyleElementFlags-Aufzählung<br />
Beinhaltet Flags, die festlegen, welche Formatelemente in einem CellStyle-Objekt verwendet werden.<br />
Syntax<br />
[VB]<br />
Public Enum StyleElementFlags
442 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
[C#]<br />
public sealed enum StyleElementFlags : System.Enum<br />
[Delphi]<br />
type StyleElementFlags = (All, BackColor, Border, ComboList, DataMap, DataType, Display, EditMask,<br />
Font, ForeColor, Format, ImageAlign, ImageMap, ImageSpacing, Margins, None, TextAlign,<br />
TextEffect,Trimming, WordWrap);<br />
Bemerkungen<br />
CellStyle-Objekte legen die für das Rendern der Tabellenzellen zu verwendenden Elemente fest.<br />
Elemente, die nicht in einer Formatvorlage festgelegt sind, werden vom Mutterformat geerbt.<br />
Verwenden Sie die DefinedElements-Eigenschaft, um festzulegen, welche Elemente in einer bestimmten<br />
Formatvorlage definiert werden.<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
None Keine Elemente sind festgelegt.<br />
Font Die Formatvorlage legt eine Schriftart fest.<br />
BackColor Die Formatvorlage legt eine Hintergrundfarbe fest.<br />
ForeColor Die Formatvorlage legt eine Vordergrundfarbe fest.<br />
Margins Die Formatvorlage legt Ränder fest.<br />
Border Die Formatvorlage legt Rahmen fest.<br />
TextAlign Die Formatvorlage legt die Textausrichtung fest.<br />
TextEffect Die Formatvorlage legt einen 3D-Effekt für den Text fest.<br />
ImageAlign Die Formatvorlage legt die Grafikausrichtung fest.<br />
ImageSpacing Die Formatvorlage legt den Abstand zwischen Grafik und Text in der Zelle fest.<br />
Trimming Die Formatvorlage legt fest, wie Texte beschnitten werden, wenn sie zu lang für die<br />
Zelle sind.<br />
WordWrap Die Formatvorlage legt fest, ob lange Zeichenketten in der Zelle umgebrochen<br />
werden.<br />
Display Die Formatvorlage legt fest, ob in der Zelle Text und/oder Grafiken angezeigt<br />
werden.<br />
Format Die Formatvorlage legt eine Formatzeichenkette fest, um Daten in Zeichenketten<br />
umzuwandeln.<br />
EditMask Die Formatvorlage legt eine Eingabemaske für die Bearbeitung der Zelle fest.<br />
ComboList Die Formatvorlage legt eine Liste mit Auswahlmöglichkeiten für den<br />
Auswahllisteneditor fest.<br />
ImageMap Die Formatvorlage legt ein zu verwendendes IDictionary fest, um Zellwerte mit<br />
Grafiken zu verknüpfen.<br />
DataMap Die Formatvorlage legt ein zu verwendendes IDictionary fest, um Zellwerte mit<br />
anzuzeigenden Werten zu verknüpfen.
DataType Die Formatvorlage legt den Typ der Werte in der Zelle fest.<br />
SubTotalPositionEnum-Aufzählung · 443<br />
TextDirection Die Formatvorlage legt fest, ob Text horizontal oder vertikal gerendert wird.<br />
Editor Die Formatvorlage legt eine externe Steuerung fest, die als Editor für die Zelle<br />
verwendet werden soll.<br />
UserData Die Formatvorlage enthält willkürliche Benutzerdaten, die nicht von der Steuerung<br />
verwendet werden.<br />
All Die Formatvorlage legt alle Elemente fest.<br />
SubTotalPositionEnum-Aufzählung<br />
Legt fest, ob die Subtotal-Methode Knotenzeilen über oder unter den zusammengefassten Zeilen<br />
hinzufügen soll.<br />
Syntax<br />
[VB]<br />
Public Enum SubTotalPositionEnum<br />
[C#]<br />
public sealed enum SubtotalPositionEnum : System.Enum<br />
[Delphi]<br />
type SubtotalPositionEnum = (AboveData, BelowData);<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
AboveData Knotenzeilen erscheinen über den Datenzeilen (Standard).<br />
BelowData Knotenzeilen erscheinen unter den Datenzeilen.<br />
TextAlignEnum-Aufzählung<br />
Legt fest, wie Texte in Zellen ausgerichtet werden.<br />
Syntax<br />
[VB]<br />
Public Enum TextAlignEnum<br />
[C#]<br />
public sealed enum TextAlignEnum : System.Enum<br />
[Delphi]<br />
type TextAlignEnum = (CenterBottom, CenterCenter, CenterTop, GeneralBottom, GeneralCenter,<br />
GeneralTop, LeftBottom, LeftCenter, LeftTop, RightBottom, Rightcenter, RightTop);
444 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
LeftTop Der Text wird horizontal links und vertikal oben in der Zelle ausgerichtet.<br />
LeftCenter Der Text wird horizontal links und vertikal zentriert in der Zelle ausgerichtet.<br />
LeftBottom Der Text wird horizontal links und vertikal unten in der Zelle ausgerichtet.<br />
CenterTop Der Text wird horizontal zentriert und vertikal oben in der Zelle ausgerichtet..<br />
CenterCenter Der Text wird horizontal zentriert und vertikal zentriert in der Zelle ausgerichtet.<br />
CenterBottom Der Text wird horizontal zentriert und vertikal unten in der Zelle ausgerichtet.<br />
RightTop Der Text wird horizontal rechts und vertikal oben in der Zelle ausgerichtet.<br />
RightCenter Der Text wird horizontal rechts und vertikal zentriert in der Zelle ausgerichtet.<br />
RightBottom Der Text wird horizontal rechts und vertikal unten in der Zelle ausgerichtet.<br />
GeneralTop Zahlen werden rechts oben und alle anderen Werte links oben ausgerichtet.<br />
GeneralCenter Zahlen werden rechts zentriert und alle anderen Werte links zentriert ausgerichtet.<br />
GeneralBottom Zahlen werden rechts unten und alle anderen Werte links unten ausgerichtet.<br />
TextDirectionEnum-Aufzählung<br />
Legt die zu verwendende Richtung fest, wenn Text in einer Tabellenzelle gerendert wird.<br />
Syntax<br />
[VB]<br />
Public Enum TextDirectionEnum<br />
[C#]<br />
public sealed enum TextDirectionEnum : System.Enum<br />
[Delphi]<br />
type TextDirectionEnum = (Normal, Up, Down);<br />
Bemerkungen<br />
Die Textrichtung beeinflusst auch die automatische Größenanpassung von Zeilen und Spalten.<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
Normal Text wird in horizontaler Richtung gerendert.<br />
Up Text wird in vertikaler Richtung von unten nach oben in der Zelle gerendert.<br />
Down Text wird in vertikaler Richtung von oben nach unten in der Zelle gerendert.<br />
TextEffectEnum-Aufzählung<br />
Legt den zu verwendenden 3D-Effekt fest, wenn der Text der Zelle gerendert wird.
Syntax<br />
[VB]<br />
Public Enum TextEffectEnum<br />
[C#]<br />
public sealed enum TextEffectEnum : System.Enum<br />
[Delphi]<br />
type TextEffectEnum = (Flag, Inset, Raised);<br />
Bemerkungen<br />
TreeStyleFlags-Aufzählung · 445<br />
Um einen 3D-Effekt für Texte zu erstellen, legt die Tabelle einen Streifen mit einem Farbübergang von<br />
der Vordergrundfarbe zur Hintergrundfarbe an und erstellt damit einen Schatten. Die Qualität des<br />
Effekts hängt von den verwendeten Farben und Schriftarten ab.<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
Flat Kein 3D-Effekt.<br />
Raised Der Text wird mit einem, um einen Pixel nach rechts unten versetzten Schatten unterlegt.<br />
Inset Der Text wird mit einem, um einen Pixel nach links oben versetzten Schatten unterlegt.<br />
TreeStyleFlags-Aufzählung<br />
Legt das Aussehen des Gliederungsbaums mit der Tree-Eigenschaft fest.<br />
Syntax<br />
[VB]<br />
Public Enum TreeStyleFlags<br />
[C#]<br />
public sealed enum TreeStyleFlags : System.Enum<br />
[Delphi]<br />
type TreeStyleFlags = (ButtonBar, Complete, CompleteLeaf, Leaf, Lines, None, Simple, SimpleLeaf,<br />
Symbols);<br />
Mitglieder<br />
Mitgliedsname Beschreibung<br />
None Zeigt den Gliederungsbaum nicht an.<br />
Lines Zeigt Baumlinien neben den Knotenzeilen an.<br />
Symbols Zeigt Ein-/Ausklappsymbole an.<br />
ButtonBar Zeigt Gliederungsschaltflächen in der obersten fixierten Zeile an.<br />
Leaf Zeigt Baumlinien neben allen Zeilen an (Knoten- und Datenzeilen).
446 · <strong>C1FlexGrid</strong>-Referenzverzeichnis<br />
Complete Kombination von Lines, Symbols und ButtonBar.<br />
Simple Kombination von Lines und Symbols.<br />
CompleteLeaf Kombination von Lines, Symbols, ButtonBar und Leaf.<br />
SimpleLeaf Kombination von Lines, Symbols und Leaf.<br />
<strong>C1FlexGrid</strong>-Schnittstellen<br />
IC1EmbeddedEditor-Schnittstelle<br />
IC1EmbeddedEditor ist eine öffentliche Schnittstelle, die in der C1Common.dll deklariert wird.<br />
Steuerungen, die diese Schnittstelle implementieren, besitzen eine bessere Integration in der Tabelle. Zum<br />
Beispiel können diese visuelle Formate der Host-Steuerung annehmen und benutzerdefinierte Verhalten<br />
für Tastatureingaben, Gültigkeitsprüfungen und Positionierung bereitstellen.<br />
Die IC1EmbeddedEditor-Schnittstelle enthält die folgenden Mitglieder:<br />
• void C1EditorInitialize(object value, IDictionary editorAttributes)<br />
Diese Methode wird aufgerufen, um den Editorinhalt und das Format zu initialisieren.<br />
Der Parameter ‚value’ enthält die Tabellendaten, die vom Editor angezeigt werden sollen.<br />
Der Parameter ‚editorAttributes’ beinhaltet ein IDictionary-Objekt mit Schlüsseln für die<br />
Formatelementenamen und die Werte für die zu bearbeitende Zelle (z.B. Schriftart,<br />
Hintergrundfarbe). Der Editor kann diese Formatvorlagen verwenden, um die Ansicht und das<br />
Verhalten der Host-Steuerung der Tabelle nachzustellen. Der Editor kann jedes beliebige, aber<br />
sinnvolle Attribut verwenden und andere ignorieren.<br />
Das ‚editorAttributes’-Wörterbuch beinhaltet die folgenden Elemente:<br />
Schlüssel Typ Beschreibung<br />
BackColor Color Zellhintergrund<br />
ContentAlignment ContentAlignment Textausrichtung in der Zelle<br />
DataType Type zu bearbeitender Datentyp<br />
EditMask String Zellbearbeitungsmaske (z.B. „(999) 999-9999“)<br />
Font Font Zellschriftart<br />
ForeColor Color Zellvordergrund<br />
Format String Zellformatierungszeichenkette (z.B. „#,##0.##“)<br />
Margins Margins zusätzlicher Rand um den Zellinhalt in Pixeln<br />
WordWrap Boolean Der Editor soll Zeilenumbüche einfügen.<br />
Der Standardabwickler setzt die Text-Eigenschaft des Editors und ignoriert alle Formatvorlagen.
• object C1EditorGetValue()<br />
IC1EmbeddedEditor-Schnittstelle · 447<br />
Gibt den aktuellen Wert des Editors zurück. Dieser kann von jedem beliebigen Datentyp sein.<br />
Der Standardabwickler gibt die Text-Eigenschaft des Editors zurück.<br />
• object C1EditorSetValue()<br />
Setzt den aktuellen Wert des Editors. Dieser kann von jedem beliebigen Datentyp sein.<br />
Der Standardabwickler setzt die Text-Eigenschaft des Editors.<br />
• bool C1EditorValueIsValid()<br />
Gibt TRUE zurück, wenn der Editor gerade gültigen Inhalt besitzt (z.B. beinhaltet dieser eine<br />
EditMask und alle benötigten Positionen sind ausgefüllt).<br />
Der Standardabwickler gibt immer TRUE zurück.<br />
• UITypeEditorEditStyle C1EditorGetStyle()<br />
Gibt das Editorformat zurück, welches den Schaltflächentyp festlegt, der in der Zelle vor und<br />
während der Bearbeitung angezeigt wird (DropDown, Modal, None).<br />
Der Standardabwickler gibt DropDown für ComboBoxes, DateTimePickers und UpDown-<br />
Steuerungen zurück. Er gibt NONE für alle anderen Steuerungstypen zurück.<br />
Anmerkung: Die UITypeEditorEditStyle-Aufzählung wird im System.Drawing.Design-<br />
Namensbereich definiert. Die möglichen Einstellungen sind DropDown, Modal und None.<br />
• void C1EditorUpdateBounds(Rectangle rc)<br />
Verschiebt den Editor auf ein gegebenes Rechteck, sodass dieser nach der Initialisierung und<br />
immer dann, wenn die Tabelle scrollt, genau über der Zelle steht.<br />
Der Standardabwickler legt die Bounds-Eigenschaft der Steuerung fest.<br />
• bool C1EditorKeyDownFinishEdit(KeyEventArgs e)<br />
Gitb TRUE zurück, wenn eine gegebene Taste die Bearbeitung abschließen und dies von der<br />
Tabelle abgewickelt werden soll.<br />
Der Standardabwickler gibt TRUE für die Tabulator-, Enter- und Escape-Taste zurück. Er wickelt<br />
auch die Pfeiltasten für Editoren ab, basierend auf TextBox-, ComboBox- und DateTimePicker-<br />
Steuerungen.<br />
• string C1EditorFormat(object value, string mask)<br />
Formatiert einen gegebenen Wert mit der Angabenmaske.<br />
Der Standardabwickler gibt eine Zeichenkette der Werte zurück (C1EditorGetValue().ToString()).
<strong>C1FlexGrid</strong>Classic-Steuerung<br />
<strong>C1FlexGrid</strong>Classic-Steuerung · 449<br />
<strong>C1FlexGrid</strong>Classic ist eine von <strong>C1FlexGrid</strong> abgeleitete Steuerung und beinhaltet ein Objektmodel, das<br />
genauso wie die VSFlexGrid ActiveX-Steuerung aussieht. <strong>C1FlexGrid</strong>Classic wurde für die einfache<br />
Migration von existierenden VSFlexGrid-Projekten entwickelt.<br />
Der Quellcode für <strong>C1FlexGrid</strong>Classic wird als Beispiel zur Verfügung gestellt. Sie können diesen als<br />
Referenz verwenden, um zu sehen, wie die <strong>C1FlexGrid</strong>-Steuerung als Basisklasse bei der Entwicklung<br />
einer benutzerdefinierten Tabellensteuerung verwendet wird.
450 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
<strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
<strong>C1FlexGrid</strong>Classic-Klassen<br />
Alle <strong>C1FlexGrid</strong>Classic-Mitglieder<br />
<strong>C1FlexGrid</strong>Classic-Eigenschaften<br />
AllowBigSelection Ermittelt oder legt fest, ob ein Klick auf einen fixierten<br />
Bereich die gesamte Zeile oder Spalte auswählt.<br />
AllowDragging<br />
Unterstützt vom .NET-Compact-Framework.<br />
AllowEditing<br />
Unterstützt vom .NET-Compact-Framework.<br />
AllowMerging<br />
Unterstützt vom .NET-Compact-Framework.<br />
AllowResizing<br />
Unterstützt vom .NET-Compact-Framework.<br />
Legt fest, ob der Nutzer Spalten/Zeilen mit der Maus<br />
ziehen darf.<br />
Legt fest, ob der Nutzer Zellen bearbeiten darf.<br />
Legt fest, ob Zellen mit ähnlichem Inhalt verbunden<br />
werden.<br />
Legt fest, ob der Nutzer die Größe von Spalten und<br />
Zeilen mit der Maus verändern darf.<br />
AllowSelection Ermittelt oder legt fest, ob der Nutzer Zellbereiche mit<br />
der Maus oder der Tastatur auswählen darf.<br />
AllowSorting<br />
Unterstützt vom .NET-Compact-Framework.<br />
Legt fest, ob der Nutzer Spalten mit der Maus sortieren<br />
darf.<br />
AllowUserResizing Legt fest, ob der Nutzer die Größe von Spalten und<br />
Zeilen mit der Maus verändern darf.<br />
AutoSizeMode Ermittelt oder legt fest, ob Spaltenbreiten und<br />
Zeilenhöhen automatisch von AutoSize an die<br />
Zellinhalte angepasst werden.<br />
BackColorAlternate Gibt oder legt die Hintergrundfarbe für alternierende<br />
Zeilen zurück/fest (0 für deaktivieren).<br />
BackColorBkg Gibt oder legt die Hintergrundfarbe für den Bereich, der<br />
nicht mit Zellen bedeckt ist, zurück/fest.<br />
BackColorFixed Gibt oder legt die Hintergrundfarbe für fixierte Zeilen<br />
und Spalten zurück/fest.<br />
BackColorSel Gibt oder legt die Hintergrundfarbe für ausgewählte<br />
Zellen zurück/fest.<br />
BackgroundImage Gibt oder legt ein Hintergrundbild für die ausgewählte<br />
Zelle zurück/fest.<br />
Cell Gibt ein Cell-Objekt zurück.<br />
CellAlignment Ermittelt oder legt die Ausrichtung von Texten in der<br />
ausgewählten Zelle oder dem Bereich fest.
IC1EmbeddedEditor-Schnittstelle · 4<strong>51</strong><br />
CellBackColor Gibt zurück oder setzt die Hintergrundfarbe für die<br />
ausgewählte Zelle oder den Bereich.<br />
CellButtonImage Legt die Grafik auf einer Zellschaltfläche fest.<br />
CellButtonPicture Legt das Bild auf einer Zellschaltflächen fest.<br />
CellChecked Ermittelt oder legt fest, ob eine Tabellenzelle ein<br />
Häkchen hat.<br />
CellFont Ermittelt oder legt das Schriftartattribut der<br />
ausgewählten Zelle oder des Bereichs fest.<br />
CellFontBold Ermittelt oder legt das Fettschriftattribut der Schriftart<br />
in der ausgewählten Zelle oder dem Bereich fest.<br />
CellFontItalic Ermittelt oder legt das Kursivarttribut der Schriftart in<br />
der ausgewählten Zelle oder dem Bereich fest.<br />
CellFontName Ermittelt oder legt den Namen der Schriftart in der<br />
ausgewählten Zelle oder des Bereichs fest.<br />
CellFontSize Ermittelt oder legt die Größe der Schriftart in der<br />
ausgewählten Zelle oder des Bereichs fest.<br />
CellFontStrikeThru Ermittelt oder legt das Strikethruarttribut der Schriftart<br />
in der ausgewählten Zelle oder dem Bereich fest.<br />
CellFontUnderline Ermittelt oder legt das Unterstreichungsarttribut der<br />
Schriftart in der ausgewählten Zelle oder dem Bereich<br />
fest.<br />
CellForeColor Ermittelt oder legt die Vordergrundfarbe der<br />
ausgewählten Zelle oder des Bereichs fest.<br />
CellHeight Gibt die Höhe der ausgewählten Zelle in Twips zurück.<br />
Bringt die Zelle, wenn nötig mit Bildlauf, auf den<br />
Bildschirm.<br />
CellLeft Der linke Teil der Zelle.<br />
CellPicture Ermittelt oder legt das in einer ausgewählten Zelle oder<br />
einem Bereich anzuzeigende Bild fest.<br />
CellPictureAlignment Ermittelt oder legt die Ausrichtung von Grafiken in der<br />
ausgewählten Zelle oder dem Bereich fest.<br />
CellTextStyle Ermittelt oder legt den 3D-Effekt für den Text in einer<br />
ausgewählten Zelle oder einem Bereich fest.<br />
CellTop Der obere Teil der Zelle.<br />
CellWidth Gibt die Breite der ausgewählten Zelle in Twips zurück.<br />
Bringt die Zelle, wenn nötig mit Bildlauf, auf den<br />
Bildschirm.<br />
Cols<br />
Unterstützt vom .NET-Compact-Framework.<br />
Gibt alle Spalten einer Tabelle zurück.<br />
ColumnCollection Ermittelt oder legt die ColumnCollection fest.<br />
ColWidthMax Ermittelt oder legt die maximale Spaltenbreite in Twips<br />
fest.
452 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
ColWidthMin Ermittelt oder legt die minimale Spaltenbreite in Twips<br />
fest.<br />
ComboCount Gibt die Anzahl der Einträge in der Auswahlliste des<br />
Auswahllisteneditors zurück.<br />
ComboIndex Ermittelt oder legt den bei Null beginnenden Index der<br />
aktuellen Auswahl in der Auswahlliste des Editors fest.<br />
Editable Ermittelt oder legt fest, ob die Steuerung<br />
Zellbearbeitung zulässt.<br />
EditSelLength Ermittelt oder legt die Anzahl der im Editor<br />
ausgewählten Zeichen fest.<br />
EditSelStart Ermittelt oder legt das erste Zeichen der Auswahl im<br />
Editor fest.<br />
EditSelText Ermittelt oder legt die Zeichenkette der aktuellen<br />
Auswahl im Editor fest.<br />
EditText Ermittelt oder legt den Text im Editor fest.<br />
EditWindow Gibt einen Abwickler an das Bearbeitungsfenster der<br />
Tabelle zurück, oder 0 wenn die Tabelle sich nicht im<br />
Bearbeitungsmodus befindet.<br />
Ellipsis Ermittelt oder legt fest, ob die Steuerung Ellipsis („...“)<br />
nach langen Zeichenketten anzeigen soll.<br />
ExplorerBar Ermittelt oder legt fest, ob Spaltenüberschriften für<br />
Sortieren und/oder Verschieben verwendet werden.<br />
FillStyle Ermittelt oder legt fest, ob Änderungen in den Text-<br />
oder Format-Eigenschaften auf die aktuelle Zelle oder<br />
die gesamte Auswahl angewendet werden sollen.<br />
FixedCols Ermittelt oder legt die Anzahl der fixierten Spalten<br />
(nicht scrollbar) fest.<br />
FixedRows Ermittelt oder legt die Anzahl der fixierten Zeilen (nicht<br />
scrollbar) fest.<br />
FontBold Legt fest, ob Text fett ist.<br />
FontItalic Legt fest, ob Text kursiv ist.<br />
FontName Legt den Namen der für den Text verwendeten<br />
Schriftart fest.<br />
FontSize Legt die Schriftgröße für den Text fest, der mit<br />
Objekten angezeigt wird.<br />
FontStrikeThru Legt fest, ob Text das Strikethru-Format besitzt.<br />
FontUnderline Legt fest, ob Text unterstrichen ist.<br />
ForeColorFixed Ermittelt oder legt die Vordergrundfarbe von fixierten<br />
Zeilen und Spalten fest.<br />
ForeColorSel Ermittelt oder legt die Vordergrundfarbe von<br />
ausgewählten Zellen fest.<br />
FrozenCols Ermittelt oder legt die Anzahl der eingefrorenen<br />
Spalten (bearbeitbar, aber nicht scrollbar) fest.
IC1EmbeddedEditor-Schnittstelle · 453<br />
FrozenRows Ermittelt oder legt die Anzahl der eingefrorenen Zeilen<br />
(bearbeitbar, aber nicht scrollbar) fest.<br />
GridColor Ermittelt oder legt die Farbe der Gitterlinien zwischen<br />
den nicht fixierten Zellen fest.<br />
GridColorFixed Ermittelt oder legt die Farbe der Gitterlinien zwischen<br />
den fixierten Zellen fest.<br />
GridLines Ermittelt oder legt den Typ der Gitterlinien zwischen<br />
den nicht fixierten Zellen fest.<br />
GridLinesFixed Ermittelt oder legt den Typ der Gitterlinien zwischen<br />
den fixierten Zellen fest.<br />
GridLineWidth Ermittelt oder legt die Breite der Gitterlinien in Pixeln<br />
fest.<br />
KeyActionEnter<br />
Unterstützt vom .NET-Compact-Framework.<br />
KeyActionTab<br />
Unterstützt vom .NET-Compact-Framework.<br />
Legt die auszuführende Aktion fest, wenn der Nutzer<br />
die Enter-Taste drückt.<br />
Legt die auszuführende Aktion fest, wenn der Nutzer<br />
die Tabulator-Taste drückt.<br />
MergeCells Ermittelt oder legt fest, ob Zellen mit gleichem Inhalt zu<br />
einer Zelle verbunden werden.<br />
NodeClosedPicture Ermittelt oder legt das Bild für einen geschlossenen<br />
Gliederungsknoten fest.<br />
NodeOpenPicture Ermittelt oder legt das Bild für einen offenen<br />
Gliederungsknoten fest.<br />
OutlineBar Ermittelt oder legt den Typ der anzuzeigenden<br />
Gliederungsleiste fest.<br />
OutlineCol Ermittelt oder legt die für den Gliederungsbaum zu<br />
verwendende Spalte fest.<br />
Picture Gibt ein Abbild der gesamten Steuerung zurück.<br />
Redraw Legt fest, ob die Tabelle ihre Inhalte zeichnen soll.<br />
PicturesOver Der Standardwert dieser Eigenschaft ist FALSE.<br />
RowHeightMax Ermittelt oder legt die maximale Zeilenhöhe in Twips<br />
fest.<br />
RowHeightMin Ermittelt oder legt die minimale Zeilenhöhe in Twips<br />
fest.<br />
Rows Gibt alle Zeilen einer Tabelle zurück.<br />
SelectedRows Gibt die Anzahl der ausgewählten Zeilen zurück, wenn<br />
der SelectionMode auf flexSelectionListBox steht.<br />
SelectionMode Legt das Auswahlverhalten der Tabelle fest.<br />
SheetBorder Ermittelt oder legt die Farbe des Rahmens um das<br />
Arbeitsblatt fest.<br />
Sort Legt die Sortierungsrichtung fest.<br />
Styles Gibt alle Formatvorlagen einer Tabelle zurück.
454 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
TabBehavior Ermittelt oder legt fest, ob die Tabulator-Taste den<br />
Fokus zwischen den Steuerungen (VB-Standard) oder<br />
zwischen Tabellenzellen verschiebt.<br />
Text Ermittelt oder legt den Inhalt der ausgewählten Zelle<br />
oder des Bereichs fest.<br />
TextStyle Ermittelt oder legt den 3D-Effekt für den Text in nicht<br />
fixierten Zellen fest.<br />
TextStyleFixed Ermittelt oder legt den 3D-Effekt für den Text in<br />
fixierten Zellen fest.<br />
TreeColor Ermittelt oder legt die Farbe für den Gliederungsbaum<br />
fest.<br />
Value Gibt den numerischen Wert der aktuellen Zelle zurück.<br />
WallPaper Ermittelt oder legt eine Hintergrundgrafik für den<br />
scrollbaren Bereich der Tabelle fest.<br />
WordWrap Legt fest, ob lange Zeichenketten in der Zelle<br />
umgebrochen werden.<br />
<strong>C1FlexGrid</strong>Classic-Methoden<br />
AutoSize Passt die Breite von Spalten und die Höhe von Zeilen an den<br />
Zellinhalt an.<br />
Clear Löscht den Inhalt einer Steuerung. Optionale Parameter legen fest,<br />
was wo gelöscht werden soll.<br />
ComboItem Gibt die mit einem Element verknüpfte Zeichenkette aus der<br />
Auswahlliste des Editors zurück.<br />
EditCell Aktiviert den Bearbeitungsmodus.<br />
FindRow Sucht eine Zeile mit einer bestimmten Zeichenkette oder einem<br />
bestimmten Objekt.<br />
get_Cell Ermittelt die cell-Eigenschaften für einen willkürlichen Bereich.<br />
get_ColAlignment Ermittelt die Ausrichtung einer gegebenen Spalte.<br />
get_ColComboList Ermittelt die für ein Auswahlfeld zu verwendende Liste von einer<br />
bestimmten Spalte.<br />
get_ColData Ermittelt ein benutzerdefiniertes, mit einer Spalte verknüpftes Variant.<br />
get_ColDataType Ermittelt den Datentyp einer Spalte.<br />
get_ColEditMask Ermittelt die Eingabemaske, die für die Bearbeitung der Zellen in einer<br />
bestimmten Spalte verwendet wird.<br />
get_ColFormat Ermittelt das für numerische Werte verwendete Format.<br />
get_ColHidden Ermittelt ob eine Spalte ausgeblendet ist.<br />
get_ColIndent Ermittelt den Einzug einer gegebenen Spalte in Twips.<br />
get_ColIndex Ermittelt den Spaltenindex der zu einer gegebenen Taste passt.<br />
get_ColIsVisible Ermittelt ob eine gegebene Spalte derzeit auf dem Bildschirm ist.
IC1EmbeddedEditor-Schnittstelle · 455<br />
get_ColKey Ermittelt einen Taste, mit der eine gegebene Spalte identifiziert wird.<br />
get_ColPos Ermittelt die linke (x) Koordinate einer Spalte, relativ zur Kante der<br />
Steuerung in Twips.<br />
get_ColSort Ermittelt die Sortierungsrichtung für jede Spalte (zur Verwendung mit<br />
der Sort-Eigenschaft).<br />
get_ColWidth Ermittelt die Breite einer bestimmten Spalte in Twips.<br />
get_FixedAlignment Ermittelt die Ausrichtung für fixierte Zeilen in einer Spalte.<br />
get_IsCollapsed Ermittelt ob eine Zeile eingeklappt ist.<br />
get_IsSelected Ermittelt ob eine Zeile ausgewählt ist (für listbox-Auswahltypen).<br />
get_IsSubtotal Ermittelt ob eine Zeile Zwischensummen beinhaltet (anstelle von<br />
Daten).<br />
get_MergeCol Ermittelt ob die Zellen einer Spalte verbunden werden (Siehe auch<br />
MergeCells-Eigenschaft).<br />
GetMergedRange Ermittelt ob die Zellen eines Bereichs verbunden werden.<br />
get_MergeRow Ermittelt ob die Zellen einer Zeile verbunden werden (Siehe auch<br />
MergeCells-Eigenschaft).<br />
GetNode Ermittelt ein Gliederungsknotenobjekt für eine gegebene<br />
Zwischensummenzeile.<br />
GetNodeRow Ermittelt die Anzahl der einer Zeile übergeordneten und<br />
untergeordneten ersten und letzten Zeilen in der Gliederung.<br />
get_RowData Ermittelt ein benutzerdefiniertes, mit einer gegebenen Zeile<br />
verknüpftes Variant.<br />
get_RowHeight Ermittelt die Höhe einer bestimmten Zeile in Twips.<br />
get_RowHidden Ermittelt ob eine Zeile versteckt ist.<br />
get_RowIsVisible Ermittelt ob eine gegebene Zeile derzeit auf dem Bildschirm ist.<br />
get_RowOutlineLevel Ermittelt die Gliederungsebene für eine Zwischensummenzeile.<br />
get_RowPos Ermittelt die obere (y) Koordinate einer Zeile, relativ zur Kante der<br />
Steuerung in Twips.<br />
GetSelection Ermittelt die sortierte aktuelle Auswahl, so dass Row1
456 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
set_ColAlignment Legt die Ausrichtung einer gegebenen Spalte fest.<br />
set_ColComboList Legt die für ein Auswahlfeld zu verwendende Liste von einer<br />
bestimmten Spalte fest.<br />
set_ColData Legt ein benutzerdefiniertes, mit einer Spalte verknüpftes Variant fest.<br />
set_ColDataType Legt den Datentyp einer Spalte fest.<br />
set_ColEditMask Legt die Eingabemaske fest, die für die Bearbeitung der Zellen in einer<br />
bestimmten Spalte verwendet wird.<br />
set_ColFormat Legt das für numerische Werte verwendete Format fest.<br />
set_ColHidden Legt fest, ob eine Spalte ausgeblendet ist.<br />
set_ColImageList Legt einen zu verwendenden Abwickler auf eine ImageList als Quelle<br />
des Bildes für eine gegebene Spalte fest.<br />
set_ColIndent Legt den Einzug einer gegebenen Spalte in Twips fest.<br />
set_ColKey Legt eine Taste fest, mit der eine gegebene Spalte identifiziert wird.<br />
set_ColPosition Verschiebt eine gegebene Spalte auf eine neue Position.<br />
set_ColSort Legt die Sortierungsrichtung für jede Spalte fest (zur Verwendung mit<br />
der Sort-Eigenschaft).<br />
set_ColWidth Legt die Breite einer bestimmten Spalte in Twips fest.<br />
set_FixedAlignment Legt die Ausrichtung für fixierte Zeilen in einer Spalte fest.<br />
set_IsCollapsed Legt fest, ob eine Zeile eingeklappt ist.<br />
set_IsSelected Legt fest,ob eine Zeile ausgewählt ist (für listbox-Auswahltypen).<br />
set_IsSubtotal Legt fest, ob eine Zeile Zwischensummen beinhaltet (anstatt Daten).<br />
set_MergeCol Legt fest, ob die Zellen einer Spalte verbunden werden (Siehe auch<br />
MergeCells-Eigenschaft).<br />
set_MergeRow Legt fest, ob die Zellen einer Zeile verbunden werden (Siehe auch<br />
MergeCells-Eigenschaft).<br />
set_RowData Legt ein benutzerdefiniertes, mit einer gegebenen Zeile verknüpftes<br />
Variant fest.<br />
set_RowHeight Legt die Höhe einer bestimmten Zeile in Twips fest.<br />
set_RowHidden Legt fest, ob eine Zeile versteckt ist.<br />
set_RowOutlineLevel Legt die Gliederungsebene für eine Zwischensummenzeile fest.<br />
set_RowPosition Verschiebt eine gegebene Zeile auf eine neue Position.<br />
set_TextMatrix Legt den Inhalt einer Zelle fest, die durch ihre Zeilen- und<br />
Spaltenkoordinaten definiert wird.<br />
<strong>C1FlexGrid</strong>Classic-Eigenschaften<br />
AllowBigSelection-Eigenschaft<br />
Ermittelt oder legt fest, ob ein Klick auf den fixierten Bereich die gesamte Zeile oder Spalte auswählt.
Syntax<br />
[VB]<br />
Public-Eigenschaft AllowBigSelection As Boolean<br />
[C#]<br />
public bool AllowBigSelection {get; set;}<br />
[Delphi]<br />
property AllowBigSelection: Boolean;<br />
Bemerkungen<br />
AllowDragging-Eigenschaft (<strong>C1FlexGrid</strong>Classic) · 457<br />
Wenn AllowBigSelection auf TRUE steht, dann wählt ein Klick auf die linke, obere, fixierte Zelle die<br />
gesamte Tabelle aus.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
SelectionMode-Eigenschaft (Seite 167)<br />
AllowDragging-Eigenschaft (<strong>C1FlexGrid</strong>Classic)<br />
Legt fest, ob der Nutzer Spalten/Zeilen mit der Maus ziehen darf.<br />
Syntax<br />
[VB]<br />
Public AllowDragging As AllowDraggingEnum<br />
[C#]<br />
public AllowDraggingEnum AllowDragging {get; set;}<br />
[Delphi]<br />
property AllowDragging: AllowDraggingEnum;<br />
Eigenschaftswert<br />
Einer der AllowDraggingEnum-Werte. Der Standardwert ist AllowDraggingEnum.Columns.<br />
Wert Beschreibung<br />
None Der Nutzer kann mit der Maus Zeilen und Spalten nicht ziehen.<br />
Columns Der Nutzer kann mit der Maus Spalten auf neue Positionen ziehen.<br />
Rows Der Nutzer kann mit der Maus Zeilen auf neue Positionen ziehen.<br />
Both Der Nutzer kann mit der Maus Zeilen und Spalten auf neue Positionen ziehen.<br />
Bemerkungen<br />
Sie können das Ziehen von bestimmten Zeilen und Spalten verhindern, indem Sie deren AllowDragging-<br />
Eigenschaft auf FALSE setzen. Zum Beispiel:
458 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
• Visual Basic<br />
• C#<br />
flex.AllowDragging = AllowDraggingEnum.Columns<br />
flex.Cols(2).AllowDragging = False<br />
flex.AllowDragging = AllowDraggingEnum.Columns;<br />
flex.Cols[2].AllowDragging = false;<br />
• Delphi<br />
flex.AllowDragging := AllowDraggingEnum.Columns;<br />
flex.Cols[2].AllowDragging := false;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
AllowEditing-Eigenschaft (<strong>C1FlexGrid</strong>Classic)<br />
Legt fest, ob der Nutzer Zellen bearbeiten darf.<br />
Syntax<br />
[VB]<br />
Public AllowEditing As Boolean<br />
[C#]<br />
public bool AllowEditing { get; set;}<br />
[Delphi]<br />
property AllowEditing: Boolean;<br />
Eigenschaftswert<br />
Der Standardwert ist TRUE.<br />
Bemerkungen<br />
Sie können das Bearbeiten von bestimmten Zeilen und Spalten verhindern, indem Sie deren<br />
AllowEditing-Eigenschaft auf FALSE setzen. Zum Beispiel<br />
• Visual Basic<br />
• C#<br />
flex.AllowEditing = True<br />
flex.Cols(2).AllowEditing = False ' prevent editing column 2<br />
flex.AllowEditing = true;<br />
flex.Cols[2].AllowEditing = false; // prevent editing column 2<br />
• Delphi<br />
flex.AllowEditing := true;<br />
flex.Cols[2].AllowEditing := false; // prevent editing column 2<br />
Für mehr Details und Beispiele über Zellbearbeitung, schauen Sie bitte unter „Zellen bearbeiten“ (Seite<br />
37) nach.
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
AllowMerging-Eigenschaft (<strong>C1FlexGrid</strong>Classic)<br />
Legt fest, ob Zellen mit ähnlichem Inhalt verbunden werden.<br />
Syntax<br />
[VB]<br />
Public AllowMerging As AllowMergingEnum<br />
[C#]<br />
public AllowMergingEnum AllowMerging {get; set;}<br />
[Delphi]<br />
property AllowMerging: AllowMergingEnum;<br />
Eigenschaftswerte<br />
AllowMerging-Eigenschaft (<strong>C1FlexGrid</strong>Classic) · 459<br />
Einer der AllowMergingEnum-Werte. Der Standardwert ist AllowMergingEnum.None.<br />
Wert Beschreibung<br />
None Zellen nicht verbinden.<br />
Free Angrenzende Zellen mit gleichem Inhalt verbinden.<br />
RestrictRows Zeilen verbinden, wenn die Zellen darüber auch verbunden sind.<br />
RestrictCols Spalten verbinden, wenn die Zellen links davon auch verbunden sind.<br />
RestrictAll Zellen verbinden, wenn die Zellen darüber und links davon auch verbunden sind.<br />
FixedOnly<br />
Nur fixierte Zellen verbinden. Diese Einstellung ist für komplexe Überschriften<br />
sinnvoll, ohne dabei die Datenzellen selbst zu verbinden.<br />
Spill Langen Einträgen erlauben, in leere, angrenzende Zellen überzugehen.<br />
Nodes<br />
Bemerkungen<br />
Langen Einträgen in Knotenzeilen erlauben, in leere, angrenzende Zellen<br />
überzugehen.<br />
Verbunde Zellen dienen dazu, Daten auf eine klare und ansprechende Weise anzuzeigen, indem<br />
Gruppen mit gleichen Informationen hervorgehoben werden. Somit sind Sie felxibel und können<br />
ähnliche Tabellen wie die, die Sie in HTML oder mit Microsoft Word (beide unterstützen verbundene<br />
Zellen) verwenden, erstellen.<br />
Um Tabellen mit verbundenen Zellen zu erstellen, müssen Sie die AllowMerging-Eigenschaft auf einen<br />
von AllowMergingEnum.None verschiedenen Wert, und die AllowMerging-Eigenschaft von den<br />
jeweiligen Zeilen und Spalten, die Sie verbinden wollen, auf TRUE setzen. Nachdem diese Eigenschaften<br />
gesetzt wurden, wird die Tabellensteuerung automatisch angrenzende Zellen mit gleichen Inhalten<br />
verbinden. Immer wenn sich die Tabelleninhalte verändern, aktualisiert die Tabelle die Verbindungen.
460 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Beispiel<br />
Durch den nachfolgenden Quellcode verbindet die Tabellensteuerung angrenzende Zellen mit gleichen<br />
Daten in Spalte 1:<br />
• Visual Basic<br />
• C#<br />
flex.AllowMerging = AllowMergingEnum.Free<br />
flex.Cols(1).AllowMerging = True ' merge values in column 1<br />
flex.AllowMerging = AllowMergingEnum.Free;<br />
flex.Cols[1].AllowMerging = true; // merge values in column 1<br />
• Delphi<br />
flex.AllowMerging := AllowMergingEnum.Free;<br />
flex.Cols[1].AllowMerging := true; // merge values in column 1<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
AllowResizing-Eigenschaft (<strong>C1FlexGrid</strong>Classic)<br />
Legt fest, ob der Nutzer die Größe von Spalten und Zeilen mit der Maus verändern darf.<br />
Syntax<br />
[VB]<br />
Public AllowResizing As AllowResizingEnum<br />
[C#]<br />
public AllowResizingEnum AllowResizing {get; set;}<br />
[Delphi]<br />
property AllowResizing: AllowResizingEnum;<br />
Eigenschaftswerte<br />
Einer der AllowResizingEnum-Werte. Der Standardwert ist AllowResizingEnum.Columns.<br />
Wert Beschreibung<br />
None Der Nutzer kann die Größe von Zeilen und Spalten nicht verändern.<br />
Columns<br />
ColumnsUniform<br />
Rows<br />
Der Nutzer kann die Breite von Spalten verändern, indem er die Kanten der<br />
fixierten Spalten oben in der Tabelle entsprechend zieht. Ein Doppelklick auf die<br />
Kante der fixierten Zellen passt die Breite an den breitesten Eintrag dieser an.<br />
Der Nutzer kann die Breite einer Spalte mit der Maus verändern. Wenn die<br />
Größe einer Spalte verändert wurde, dann wird die neue Spaltenbreite auf alle<br />
Spalten angewendet.<br />
Der Nutzer kann die Höhe von Zeile verändern, indem er die Kanten der fixierten<br />
Zeilen links in der Tabelle entsprechend zieht. Ein Doppelklick auf die Kante der<br />
fixierten Zellen passt die Höhe an deren höchsten Eintrag an.
Wert Beschreibung<br />
Both<br />
RowsUniform<br />
BothUniform<br />
Bemerkungen<br />
AllowSelection-Eigenschaft · 461<br />
Der Nutzer kann die Höhe von Zeilen und die Breite von Spalten mit der Maus<br />
verändern.<br />
Der Nutzer kann die Höhe einer Zeile mit der Maus verändern. Wenn die Größe<br />
einer Zeile verändert wurde, dann wird die neue Zeilenhöhe auf alle Zeilen<br />
angewendet.<br />
Der Nutzer kann die Höhe von Zeilen und die Breite von Spalten mit der Maus<br />
verändern. Wenn die Größe einer Zeile oder Spalte verändert wurde, dann wird<br />
die neue Höhe oder Breite auf alle Zeilen oder Spalten angewendet.<br />
Um Zeilen oder Spalten in ihrer Größe zu verändern, muss der Mauszeiger über den fixierten Zellen der<br />
Tabelle und nahe einer Grenze zwischen Zeilen und Spalten stehen. Der Mauszeiger ändert sich dann zu<br />
einem Größenzeiger und der Nutzer kann die Zeilen und Spalten ziehen, um deren Höhe oder Breite zu<br />
verändern.<br />
Wenn eine Spaltengruppe ausgewählt wurde (von der ersten bis zur letzten Zeile) und der Nutzer die<br />
Größe einer davon verändert, dann werden alle ausgewählten Spalten ebenfalls angepasst. Das selbe gilt<br />
für Zeilen.<br />
Wenn die Anpassung der Größe für Spalten erlaubt ist, dann kann mit einem Doppelklick deren Breite<br />
automatisch an den längsten Eintrag der entsprechenden Spalte angepasst werden.<br />
Zeilen mit einer Höhe von Null und Spalten mit einer Breite von Null können vom Nutzer nicht mehr<br />
verändert werden. Wenn Sie diese Zeilen und Spalten zwar sehr klein, aber immer noch veränderbar<br />
haben wollen, dann sollten Sie deren Höhe oder Breite auf einen Pixel stellen, und nicht Null.<br />
Die BeforeResizeRow- und BeforeResizeColumn-Ereignisse werden vor der Veränderung gestartet und<br />
können dazu verwendet werden, die Veränderung der Größe von bestimmten Zeilen und Spalten zu<br />
verhindern. Die AfterResizeRow- und AfterResizeColumn-Ereignisse werden nach der<br />
Größenanpassung gestartet und können für die Prüfung der Änderung oder das Aktualisieren der<br />
Anzeige verwendet werden.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
AllowSelection-Eigenschaft<br />
Ermittelt oder legt fest, ob der Nutzer Zellbereiche mit der Maus oder der Tastatur auswählen darf.<br />
Syntax<br />
[VB]<br />
Public AllowSelection As Boolean<br />
[C#]<br />
public bool AllowSelection {get; set;}
462 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
[Delphi]<br />
property AllowSelection: Boolean;<br />
Bemerkungen<br />
Setzen Sie diese Eigenschaft auf FALSE um den Nutzer daran zu hindern, eine Auswahl per Klick und<br />
Ziehen oder mit den Shift- und Plus-Cursortasten zu erweitern. In diesem Fall wird Klicken und Ziehen<br />
mit der Maus die aktuelle Zelle verschieben, aber nicht die Auswahl erweitern.<br />
Diese Funktion ist nützlich, wenn Sie die <strong>C1FlexGrid</strong>Classic-Steuerung verwenden, um bestimmte<br />
Benutzerschnittstellen, wie z.B. Menüs, Eigenschaftsblätter oder explorerähnliche Bäume, zu<br />
implementieren.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
SelectionMode-Eigenschaft (Seite 167)<br />
AllowSorting-Eigenschaft (<strong>C1FlexGrid</strong>Classic)<br />
Legt fest, ob der Nutzer Spalten mit der Maus sortieren darf.<br />
Syntax<br />
[VB]<br />
Public AllowSorting As AllowSortingEnum<br />
[C#]<br />
public AllowSortingEnum AllowSorting {get; set;}<br />
[Delphi]<br />
property AllowSorting: AllowSortingEnum;<br />
Eigenschaftswerte<br />
Einer der AllowSortingEnum-Werte. Der Standardwert ist AllowSortingEnum.SingleColumn.<br />
Wert Beschreibung<br />
None Der Nutzer kann Spalten nicht mit der Maus sortieren.<br />
SingleColumn<br />
MultiColumn<br />
Der Nutzer kann Spalten mit der Maus sortieren. Klickt man auf die<br />
Spaltenüberschrift, so werden diese jeweils auf- oder absteigend sortiert.<br />
Diese Funktion ist gleich denen, die in den meisten Standardanwendungen, wie<br />
zum Beispiel Windows Explorer, zu finden sind.<br />
Der Nutzer kann Spalten mit der Maus sortieren. Klickt man auf die<br />
Spaltenüberschrift, so werden alle Spalten von der Ersten bis zu der, auf die man<br />
geklickt hat auf- oder absteigend sortiert.<br />
Diese Einstellung ist sinnvoll, wenn die Daten nach Kategorien von links nach<br />
rechts gruppiert sind und Sie diese Gruppen trotz Sortieren erhalten wollen.
Bemerkungen<br />
AllowUserResizing-Eigenschaft · 463<br />
Wenn sich die Tabelle im gebundenen Modus befindet, so wird das Sortieren in der darunterliegenden<br />
Datentabelle vorgenommen.<br />
Wenn die Tabelle ungebundenen ist, können Sie die Daten auch mit der Sort-Methode sortieren.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
AllowUserResizing-Eigenschaft<br />
Legt fest, ob der Nutzer die Größe von Spalten und Zeilen mit der Maus verändern darf.<br />
Syntax<br />
[VB]<br />
Public AllowUserResizing As AllowUserResizeSettings<br />
[C#]<br />
public AllowUserResizeSettings AllowUserResizing {get; set;}<br />
[Delphi]<br />
property AllowUserResizing: AllowUserResizeSettings;<br />
Bemerkungen<br />
Gültige Einstellungen für die AllowUserResizing-Eigenschaft:<br />
Mitgliedsname Beschreibung<br />
flexResizeNone (0)<br />
Der Nutzer kann die Größe von Zeilen und Spalten<br />
nicht verändern.<br />
flexResizeColumns (1) Der Nutzer kann die Spaltenbreite verändern.<br />
flexResizeRows (2) Der Nutzer kann die Zeilenhöhe verändern.<br />
flexResizeBoth (3)<br />
flexResizeBothUniform (4)<br />
flexResizeRowsUniform (5)<br />
Der Nutzer kann die Größe von Zeilen und Spalten<br />
verändern.<br />
Der Nutzer kann die Größe von Zeilen und Spalten<br />
verändern.<br />
Wenn die Zeilenhöhe geändert wird, dann wird diese<br />
Höhe auf alle Zeilen angewendet.<br />
Um Zeilen oder Spalten in ihrer Größe zu verändern, muss der Mauszeiger über den fixierten Zellen der<br />
Tabelle und nahe einer Grenze zwischen Zeilen und Spalten stehen. Der Mauszeiger ändert sich dann zu<br />
einem Größenzeiger und der Nutzer kann die Zeilen und Spalten ziehen, um deren Höhe oder Breite zu<br />
verändern.<br />
Wenn ein Bereich an Spalten ausgewählt ist (von der ersten bis zur letzten Zeile) und der Nutzer deren<br />
Größe ändert, dann wird die neue Größe auf alle ausgwählten Spalten angewendet. Das gleiche gilt für
464 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Zeilen. Setzen Sie die AllowBigSelection-Eigenschaft auf TRUE, um Nutzern zu erlauben, ganze Zeilen<br />
und Spalten auszuwählen.<br />
Wenn die Größe von Spalten verändert werden darf und die AutoSizeMouse-Eigenschaft auf TRUE<br />
steht, dann kann der Nutzer auf den Größenveränderungsbereich einer Spalte doppelklicken, um die<br />
Breite der Spalte an ihren breitesten Eintrag anzupassen.<br />
Die Größe von Zeilen, mit einer Höhe von Null, und Spalten, mit einer Breite von Null, können vom<br />
Nutzer nicht mehr geändert werden. Wenn Sie Zeilen und Spalten sehr klein machen, die Änderung der<br />
Größe durch den Nutzer aber immer noch erlauben wollen, dann stellen Sie deren Höhe und Breite auf<br />
einen Pixel, und nicht auf Null. Zum Beispiel:<br />
• Visual Basic<br />
• C#<br />
fg.set_ColWidth(5,1)<br />
fg.set_ColWidth(5,1);<br />
• Delphi<br />
fg.set_ColWidth(5, 1);<br />
Das BeforeUserResize-Ereignis wird gestartet, bevor die Größenänderung stattfindet und kann dafür<br />
verwendet werden, diesen Vorgang für bestimmte Zeilen und Spalten zu verhindern. Das<br />
AfterUserResize-Ereignis wird gestartet, nachdem die Größenänderung stattgefunden hat und kann für<br />
die Gültigkeitsprüfung der Eingaben des Nutzers verwendet werden.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
AllowResizing-Eigenschaft (Seite 122)<br />
AutoSizeMode-Eigenschaft<br />
Ermittelt oder legt fest, ob Spaltenbreiten und Zeilenhöhen automatisch von AutoSize an die Zellinhalte<br />
angepasst werden.<br />
Syntax<br />
[VB]<br />
Public AutoSizeMode As AutoSizeSettings<br />
[C#]<br />
public AutoSizeSettings AutoSizeMode {get; set;}<br />
[Delphi]<br />
property AutoSizeMode: AutoSizeSettings;<br />
Bemerkungen<br />
Gültige Einstellungen für die AutoSizeMode-Eigenschaft:<br />
Mitgliedsname Beschreibung<br />
flexAutoSizeColWidth Der Nutzer kann die Breite von Spalten verändern.
flexAutoSizeRowHeight Der Nutzer kann die Höhe von Zeilen verändern.<br />
BackColorAlternate-Eigenschaft · 465<br />
Die flexAutoSizeRowHeight-Einstellung ist nützlich, wenn Text in einer Zelle umgebrochen wird (Siehe<br />
WordWrap-Eigenschaft) oder wenn Zellen verschiedene Schriftgrößen haben (Siehe Cell-Eigenschaft).<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
AutoSizeCol-Methode (Seite 176)<br />
BackColorAlternate-Eigenschaft<br />
Gibt oder legt die Hintergrundfarbe für alternierende Zeilen zurück/fest (0 für deaktivieren).<br />
Syntax<br />
[VB]<br />
Public BackColorAlternate As Color<br />
[C#]<br />
public Color BackColorAlternate {get; set;}<br />
[Delphi]<br />
property BackColorAlternate: Color;<br />
Bemerkungen<br />
Wenn Sie die BackColorAlternate-Eigenschaft auf einen von Null verschiedenen Wert setzen, dann wird<br />
die festgelegte Farbe für den Hintergrund jeder zweiten Zeile der Steuerung verwendet.<br />
Diese Eigenschaft zu verwenden ist schneller und effizienter, als die CellBackColor-Eigenschaft einer<br />
jeden zweiten Zeile festzulegen. Außerdem bleiben die alternierenden Farben erhalten, wenn Sie die<br />
Tabelle sortieren, oder Zeilen entfernen oder hinzufügen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
CellStyle-Klasse (Seite 376)<br />
BackColorBkg-Eigenschaft<br />
Gibt oder legt die Hintergrundfarbe für den Bereich, der nicht mit Zellen bedeckt ist, zurück/fest.<br />
Syntax<br />
[VB]<br />
Public BackColorBkg As Color<br />
[C#]<br />
public Color BackColorBkg {get; set}<br />
[Delphi]<br />
property BackColorBkg: Color;
466 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Bemerkungen<br />
Schauen Sie unter der BackColor-Eigenschaft nach, um eine Übersicht über die Farben zu erhalten, und<br />
für welche Bereiche der Tabelle diese verwendet werden.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
CellStyle-Klasse (Seite 376)<br />
BackColorFixed-Eigenschaft<br />
Gibt oder legt die Hintergrundfarbe für fixierte Zeilen und Spalten zurück/fest.<br />
Syntax<br />
[VB]<br />
Public BackColorFixed As Color<br />
[C#]<br />
public Color BackColorFixed {get; set}<br />
[Delphi]<br />
property BackColorFixed: Color;<br />
Bemerkungen<br />
Schauen Sie unter der BackColor-Eigenschaft nach, um eine Übersicht über die Farben zu erhalten, und<br />
für welche Bereiche der Tabelle diese verwendet werden.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
CellStyle-Klasse (Seite 376)<br />
BackColorSel-Eigenschaft<br />
Gibt oder legt die Hintergrundfarbe für ausgewählte Zellen zurück/fest.<br />
Syntax<br />
[VB]<br />
Public BackColorSel As Color<br />
[C#]<br />
public Color BackColorSel {get; set}<br />
[Delphi]<br />
property BackColorSel: Color;<br />
Bemerkungen<br />
Schauen Sie unter der BackColor-Eigenschaft nach, um eine Übersicht über die Farben zu erhalten, und<br />
für welche Bereiche der Tabelle diese verwendet werden.
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
CellStyle-Klasse (Seite 376)<br />
BackgroundImage-Eigenschaft<br />
Gibt oder legt ein Hintergrundbild für die ausgewählte Zelle zurück/fest.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft BackgroundImage As Image<br />
[C#]<br />
public Image BackgroundImage {get; set;}<br />
[Delphi]<br />
property BackgroundImage: Image;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Cell-Eigenschaft<br />
Gibt ein Cell-Objekt zurück.<br />
Syntax<br />
[VB]<br />
Public ReadOnly-Eigenschaft Cell As C1.Win.<strong>C1FlexGrid</strong>.Classic.Cell<br />
[C#]<br />
public C1.Win.<strong>C1FlexGrid</strong>.Classic.Cell Cell {get;}<br />
[Delphi]<br />
property Cell: C1.Win.<strong>C1FlexGrid</strong>.Classic.Cell;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
CellAlignment-Eigenschaft<br />
BackgroundImage-Eigenschaft · 467<br />
Ermittelt oder legt die Ausrichtung von Texten in der ausgewählten Zelle oder dem Bereich fest.<br />
Syntax<br />
[VB]<br />
Public CellAlignment As AlignmentSettings
468 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
[C#]<br />
public AlignmentSettings CellAlignment {get; set;}<br />
[Delphi]<br />
property CellAlignment: AlignmentSettings;<br />
Bemerkungen<br />
Gültige Einstellungen für die CellAlignment-Eigenschaft:<br />
Mitgliedsname Beschreibung<br />
flexAlignLeftTop Richtet Text links oben aus.<br />
flexAlignLeftCenter Richtet Text links zentriert aus.<br />
flexAlignLeftBottom Richtet Text links unten aus.<br />
flexAlignCenterTop Richtet Text zentriert oben aus.<br />
flexAlignCenterCenter Richtet Text zentriert aus.<br />
flexAlignCenterBottom Richtet Text zentriert unten aus.<br />
flexAlignRightTop Richtet Text rechts oben aus.<br />
flexAlignRightCenter Richtet Text rechts zentriert aus.<br />
flexAlignRightBottom Richtet Text rechts unten aus.<br />
flexAlignGeneral Richtet Text links und Zahlen und Daten rechts aus.<br />
Wenn diese Eigenschaft geändert wird, dann betrifft dies die aktuelle Zelle oder Auswahl, je nach<br />
Einstellung der FillStyle-Eigenschaft. Verwenden Sie stattdessen die Cell-Eigenschaft, um die<br />
Ausrichtung für einen willkürlichen Zellbereich festzulegen (nicht zwingend die aktuelle Auswahl).<br />
Dieses Beispiel wählt die ersten sieben Zellen in der 3. Spalte aus und zentriert den Textinhalt.<br />
• Visual Basic<br />
• C#<br />
With fg<br />
'select rows 1 through 7 in Column 3<br />
.Select 1, 3, 7, 3<br />
.FillStyle = FillStyleSettings.flexFillRepeat<br />
.CellAlignment = AlignmentSettings.flexAlignCenterCenter<br />
'return .FillStyle to its default (if needed)<br />
.FillStyle = FillStyleSettings.flexFillSingle<br />
End With<br />
//select rows 1 through 7 in Column 3<br />
fg.Select 1, 3, 7, 3;<br />
fg.FillStyle = FillStyleSettings.flexFillRepeat;<br />
df.CellAlignment = AlignmentSettings.flexAlignCenterCenter;<br />
//return .FillStyle to its default (if needed)<br />
fg.FillStyle = FillStyleSettings.flexFillSingle;<br />
} With<br />
• Delphi<br />
With fg do
CellBackColor-Eigenschaft · 469<br />
begin<br />
// select rows 1 through 7 in Column 3<br />
Select(1, 3, 7, 3);<br />
FillStyle := FillStyleSettings.flexFillRepeat;<br />
CellAlignment := AlignmentSettings.flexAlignCenterCenter;<br />
// return .FillStyle to its default (if needed)<br />
FillStyle := FillStyleSettings.flexFillSingle;<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
CellStyle-Klasse (Seite 376)<br />
CellBackColor-Eigenschaft<br />
Gibt zurück oder setzt die Hintergrundfarbe für die ausgewählte Zelle oder den Bereich.<br />
Syntax<br />
[VB]<br />
Public CellBackColor As Color<br />
[C#]<br />
public Color CellBackColor {get; set;}<br />
[Delphi]<br />
property CellBackColor: Color;<br />
Bemerkungen<br />
Wenn diese Eigenschaft auf Null (schwarz) gestellt wird, dann verwendet die Steuerung die<br />
Standardfarben, die durch die BackColor- und BackColorAlternate-Eigenschaften festgelegt sind.<br />
Verwenden Sie daher RGB(1,1,1) anstatt RGB(0,0,0), um diese Eigenschaft auf schwarz zu stellen.<br />
Der folgende Quellcode ändert die Hintergrundfarbe der aktuellen Zelle:<br />
• Visual Basic<br />
• C#<br />
fg.CellBackColor = System.Drawing.Color.Red<br />
fg.CellBackColor = System.Drawing.Color.Red;<br />
• Delphi<br />
fg.CellBackColor := System.Drawing.Color.Red;<br />
Wenn diese Eigenschaft geändert wird, dann betrifft dies die aktuelle Zelle oder Auswahl, je nach<br />
Einstellung der FillStyle-Eigenschaft. Verwenden Sie stattdessen die Cell-Eigenschaft, um die<br />
Hintergrundfarbe für einen willkürlichen Zellbereich festzulegen (nicht zwingend die aktuelle Auswahl).<br />
Dieses Beispiel wählt die ersten sieben Zellen in der 3. Spalte aus und legt deren Hintergrundfarbe fest.
470 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
• Visual Basic<br />
• C#<br />
With fg<br />
.Select (1, 3, 7, 3)<br />
.FillStyle = FillStyleSettings.flexFillRepeat<br />
.CellBackColor = System.Drawing.Color.Red<br />
'return .FillStyle to its default (if needed)<br />
.FillStyle = FillStyleSettings.flexFillSingle<br />
'Make cell 1, 1 the current cell so we can view the change<br />
.Select (1, 1)<br />
End With<br />
fg.Select (1, 3, 7, 3);<br />
fg.FillStyle = FillStyleSettings.flexFillRepeat;<br />
fg.CellBackColor = System.Drawing.Color.Red;<br />
//return .FillStyle to its default (if needed)<br />
fg.FillStyle = FillStyleSettings.flexFillSingle;<br />
//Make cell 1, 1 the current cell so we can view the change<br />
fg.Select (1, 1);<br />
• Delphi<br />
With fg do<br />
begin<br />
Select (1, 3, 7, 3);<br />
FillStyle := FillStyleSettings.flexFillRepeat;<br />
CellBackColor := System.Drawing.Color.Red;<br />
// return .FillStyle to its default (if needed)<br />
FillStyle := FillStyleSettings.flexFillSingle;<br />
// Make cell 1, 1 the current cell so we can view the change<br />
Select (1, 1);<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
CellStyle-Klasse (Seite 376)<br />
CellButtonImage-Eigenschaft (<strong>C1FlexGrid</strong>Classic)<br />
Legt die Grafik auf einer Zellschaltfläche fest.<br />
Syntax<br />
[VB]<br />
Public CellButtonImage As Image<br />
[C#]<br />
public Image CellButtonImage {get; set;}<br />
[Delphi]<br />
property CellButtonImage: Image;<br />
Bemerkungen<br />
Mit dieser Eigenschaft können Sie das Aussehen der Zellschaltflächen anpassen. Für Details über die<br />
Handhabung von Zellschaltflächen schauen Sie bitte unter CellButtonClick-Ereignis nach.
CellButtonPicture-Eigenschaft · 471<br />
Wenn Sie nur eine Grafik für alle Zellschaltflächen in der Tabelle verwenden wollen, dann ordnen Sie<br />
diese der CellButtonImage-Eigenschaft während der Designtime zu. Um die Grafiken je nach Spalte,<br />
Zeile oder zu bearbeitender Zelle zu verändern, fangen Sie das BeforeEdit-Ereignis ab und legen Sie das<br />
entsprechende Bild fest.<br />
Die für die Zellschaltflächen verwendete Grafik sollte auf die Schaltfläche passen (größere Grafiken<br />
werden beschnitten). Diese sollten auch transparent sein, so dass die Schaltflächenoberfläche durch die<br />
leeren Stellen der Grafik zu sehen ist. Für das beste Ergebnis, verwenden Sie kleine Symbole (16x16 Pixel)<br />
und zeichnen Sie das Bild in das obere linke12x12-Rechteck innerhalb des Symbols.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
CellButtonPicture-Eigenschaft<br />
Legt das Bild auf einer Zellschaltfläche fest.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft CellButtonPicture As System.Drawing.Image<br />
[C#]<br />
public Image CellButtonPicture {get; set;}<br />
[Delphi]<br />
property CellButtonPicture: Image;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
CellChecked-Eigenschaft<br />
Ermittelt oder legt fest, ob eine Tabellenzelle ein Häkchen hat.<br />
Syntax<br />
[VB]<br />
Public CellChecked As CellCheckedSettings<br />
[C#]<br />
public CellCheckedSettings CellChecked {get; set;}<br />
[Delphi]<br />
property CellChecked: CellCheckedSettings;<br />
Bemerkungen<br />
Gültige Einstellungen für die CellChecked-Eigenschaft:
472 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Mitgliedsname Beschreibung<br />
flexNoCheckbox Die Zelle besitzt kein Kontrollkästchen. (Standardeinstellung)<br />
flexChecked Die Zelle besitzt ein Kontrollkästchen mit Häkchen.<br />
flexUnchecked Die Zelle besitzt ein Kontrollkästchen ohne Häkchen.<br />
Wenn eine Zelle ein Kontrollkästchen besitzt und die AllowEditing-Eigenschaft auf TRUE steht, dann<br />
kann der Nutzer dessen Zustand mit einem Mausklick oder mit der Leer- oder Entertaste ändern. Egal<br />
auf welchem Wege das Kästchen umgeschaltet wird, das AfterEdit-Ereignis wird gestartet und Sie<br />
können entsprechende Maßnahmen vornehmen.<br />
Das Kontrollkästchen kann sich links, rechts oder zentriert, je nach Einstellung der<br />
CellPictureAlignment-Eigenschaft, befinden.<br />
Wenn diese Eigenschaft geändert wird, dann betrifft dies die aktuelle Zelle oder Auswahl, je nach<br />
Einstellung der FillStyle-Eigenschaft. Verwenden Sie stattdessen die Cell-Eigenschaft, um die<br />
Kontrollkästchenzustände für einen willkürlichen Zellbereich festzulegen (nicht zwingend die aktuelle<br />
Auswahl).<br />
Zum Beispiel, der nachfolgende Quellcode erstellt Spalte eins:<br />
• Visual Basic<br />
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As<br />
System.EventArgs)<br />
Dim r&<br />
For r = fg.FixedRows To fg.Rows - 1<br />
fg.set_Cell(CellPropertySettings.flexcpChecked, _<br />
r, 1, CellPropertySettings.flexcpChecked)<br />
fg.set_Cell(CellPropertySettings.flexcpText, r, 1, "Row " &<br />
r)<br />
Next<br />
fg.Editable = EditableSettings.flexEDKbdMouse<br />
End Sub<br />
_<br />
• C#<br />
Private Sub Button1_Click(ByVal sender As System.Object, _<br />
ByVal e As System.EventArgs) Handles Button1.Click<br />
Dim r&<br />
For r = fg.FixedRows To fg.Rows - 1<br />
If fg.get_Cell(CellPropertySettings.flexcpChecked, r, 1) =<br />
checked")<br />
End If<br />
Next<br />
End Sub<br />
CellPropertySettings.flexcpChecked Then<br />
Debug.WriteLine(fg.get_TextMatrix(1, 1) & " is<br />
private void Form1_Load( System.object sender, System.EventArgs e) {<br />
r&;<br />
for ( r = fg.FixedRows; r
CellFont-Eigenschaft · 473<br />
}<br />
private void Button1_Click( System.object sender, System.EventArgs e)<br />
{<br />
for (int r = fg.FixedRows; r
474 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
[Delphi]<br />
property CellFont: Boolean;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
CellStyle-Klasse (Seite 376)<br />
CellFontBold-Eigenschaft<br />
Ermittelt oder legt das Fettschriftattribut der Schriftart in der ausgewählten Zelle oder dem Bereich fest.<br />
Syntax<br />
[VB]<br />
Public CellFontBold As Boolean<br />
[C#]<br />
public bool CellFontBold {get; set;}<br />
[Delphi]<br />
property CellFontBold: Boolean;<br />
Bemerkungen<br />
Wenn diese Eigenschaft geändert wird, dann betrifft dies die aktuelle Zelle oder Auswahl, je nach<br />
Einstellung der FillStyle-Eigenschaft. Verwenden Sie stattdessen die Cell-Eigenschaft, um Fettschrift für<br />
einen willkürlichen Zellbereich festzulegen (nicht zwingend die aktuelle Auswahl)<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
CellStyle-Klasse (Seite 376)<br />
CellFontItalic-Eigenschaft<br />
Ermittelt oder legt das Kursivarttribut der Schriftart in der ausgewählten Zelle oder dem Bereich fest.<br />
Syntax<br />
[VB]<br />
Public CellFontItalic As Boolean<br />
[C#]<br />
public bool CellFontItalic {get; set;}<br />
[Delphi]<br />
property CellFontItalic: Boolean;<br />
Bemerkungen<br />
Wenn diese Eigenschaft geändert wird, dann betrifft dies die aktuelle Zelle oder Auswahl, je nach<br />
Einstellung der FillStyle-Eigenschaft. Verwenden Sie stattdessen die Cell-Eigenschaft, um die<br />
Kursivschrift für einen willkürlichen Zellbereich festzulegen (nicht zwingend die aktuelle Auswahl).
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
CellStyle-Klasse (Seite 376)<br />
CellFontName-Eigenschaft<br />
CellFontName-Eigenschaft · 475<br />
Ermittelt oder legt den Namen der Schriftart in der ausgewählten Zelle oder des Bereichs fest.<br />
Syntax<br />
[VB]<br />
Public CellFontName As String<br />
[C#]<br />
public string CellFontName {get; set;}<br />
[Delphi]<br />
property CellFontName: string;<br />
Bemerkungen<br />
Wenn diese Eigenschaft geändert wird, dann betrifft dies die aktuelle Zelle oder Auswahl, je nach<br />
Einstellung der FillStyle-Eigenschaft. Verwenden Sie stattdessen die Cell-Eigenschaft, um den<br />
Schriftartnamen für einen willkürlichen Zellbereich festzulegen (nicht zwingend die aktuelle Auswahl).<br />
Wenn diese Eigenschaft auf eine leere Zeichenkette gesetzt wird, dann wird die Zellformatierung<br />
zurückgesetzt und die Standardschriftart verwendet.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
CellStyle-Klasse (Seite 376)<br />
CellFontSize-Eigenschaft<br />
Ermittelt oder legt die Größe der Schriftart in der ausgewählten Zelle oder des Bereichs fest.<br />
Syntax<br />
[VB]<br />
Public CellFontSize As Integer<br />
[C#]<br />
public int CellFontSize {get; set;}<br />
[Delphi]<br />
property CellFontSize: Integer;<br />
Bemerkungen<br />
Wenn diese Eigenschaft geändert wird, dann betrifft dies die aktuelle Zelle oder Auswahl, je nach<br />
Einstellung der FillStyle-Eigenschaft. Verwenden Sie stattdessen die Cell-Eigenschaft, um die<br />
Schriftgröße für einen willkürlichen Zellbereich festzulegen (nicht zwingend die aktuelle Auswahl).
476 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Wenn diese Eigenschaft auf Null gesetzt wird, dann wird die Zellformatierung zurückgesetzt und die<br />
Standardschriftgröße verwendet.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
CellStyle-Klasse (Seite 376)<br />
CellFontStrikeThru-Eigenschaft<br />
Ermittelt oder legt das Strikethruarttribut der Schriftart in der ausgewählten Zelle oder dem Bereich fest.<br />
Syntax<br />
[VB]<br />
Public CellFontStrikeThru As Boolean<br />
[C#]<br />
public bool CellFontStrikeThru {get; set;}<br />
[Delphi]<br />
property CellFontStrikeThru: Boolean;<br />
Bemerkungen<br />
Wenn diese Eigenschaft geändert wird, dann betrifft dies die aktuelle Zelle oder Auswahl, je nach<br />
Einstellung der FillStyle-Eigenschaft. Verwenden Sie stattdessen die Cell-Eigenschaft, um die Schriftart<br />
für einen willkürlichen Zellbereich festzulegen (nicht zwingend die aktuelle Auswahl).<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
CellStyle-Klasse (Seite 376)<br />
CellFontUnderline-Eigenschaft<br />
Ermittelt oder legt das Unterstreichungsarttribut der Schriftart in der ausgewählten Zelle oder dem<br />
Bereich fest.<br />
Syntax<br />
[VB]<br />
Public CellFontUnderline As Boolean<br />
[C#]<br />
public bool CellFontUnderline {get; set;}<br />
[Delphi]<br />
property CellFontUnderline: Boolean;
Bemerkungen<br />
CellForeColor-Eigenschaft · 477<br />
Wenn diese Eigenschaft geändert wird, dann betrifft dies die aktuelle Zelle oder Auswahl, je nach<br />
Einstellung der FillStyle-Eigenschaft. Verwenden Sie stattdessen die Cell-Eigenschaft, um Unterstreichen<br />
für einen willkürlichen Zellbereich festzulegen (nicht zwingend die aktuelle Auswahl).<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
CellStyle-Klasse (Seite 376)<br />
CellForeColor-Eigenschaft<br />
Ermittelt oder legt die Vordergrundfarbe der ausgewählten Zelle oder des Bereichs fest.<br />
Syntax<br />
[VB]<br />
Public CellForeColor As Color<br />
[C#]<br />
public Color CellForeColor {get; set;}<br />
[Delphi]<br />
property CellForeColor: Color;<br />
Bemerkungen<br />
Wenn diese Eigenschaft geändert wird, dann betrifft dies die aktuelle Zelle oder Auswahl, je nach<br />
Einstellung der FillStyle-Eigenschaft. Verwenden Sie stattdessen die Cell-Eigenschaft, um die<br />
Vordergrundfarbe für einen willkürlichen Zellbereich festzulegen (nicht zwingend die aktuelle<br />
Auswahl).<br />
Wenn diese Eigenschaft auf Null (schwarz) gestellt wird, dann verwendet die Steuerung die<br />
Standardfarbe, die durch die ForeColor-Eigenschaften festgelegt ist. Verwenden Sie RGB(1,1,1) anstatt<br />
RGB(0,0,0) oder vbBlack, um diese Eigenschaft auf schwarz zu stellen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
CellStyle-Klasse (Seite 376)<br />
CellHeight-Eigenschaft<br />
Gibt die Höhe der ausgewählten Zelle in Twips zurück. Bringt die Zelle, wenn nötig mit Bildlauf, auf den<br />
Bildschirm.<br />
Syntax<br />
[VB]<br />
Public CellHeight As Integer<br />
[C#]<br />
public int CellHeight {get; set;}
478 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
[Delphi]<br />
property CellHeight: Integer;<br />
Bemerkungen<br />
Die CellHeight-, CellWidth-, CellTop- und CellLeft-Eigenschaften sind nützlich, um andere<br />
Steuerungen über oder nah einer Zelle zu platzieren. Immer wenn Sie eine dieser Eigenschaften auslesen,<br />
geht die Steuerung davon aus, dass Sie an der aktuellen Zelle arbeiten wollen und zeigt diese somit,<br />
wenn nötig mit Bildlauf, auf dem Bildschirm an.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
GetCellRect-Methode (Seite 188)<br />
CellLeft-Eigenschaft<br />
Der linke Teil der Zelle.<br />
Syntax<br />
[VB]<br />
Public CellLeft As Integer<br />
[C#]<br />
public int CellLeft {get; set;}<br />
[Delphi]<br />
property CellLeft: Integer;<br />
Bemerkungen<br />
Die CellHeight-, CellWidth-, CellTop- und CellLeft-Eigenschaften sind nützlich, um andere<br />
Steuerungen über oder nah einer Zelle zu platzieren. Immer wenn Sie eine dieser Eigenschaften auslesen,<br />
geht die Steuerung davon aus, dass Sie an der aktuellen Zelle arbeiten wollen und zeigt diese somit,<br />
wenn nötig mit Bildlauf, auf dem Bildschirm an.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
GetCellRect-Methode (Seite 188)<br />
CellPicture-Eigenschaft<br />
Ermittelt oder legt das in einer ausgewählten Zelle oder einem Bereich anzuzeigende Bild fest.<br />
Syntax<br />
[VB]<br />
Public CellPicture As Image<br />
[C#]<br />
public Image CellPicture {get; set;}
[Delphi]<br />
property CellPicture: Image;<br />
Bemerkungen<br />
CellPictureAlignment-Eigenschaft · 479<br />
Das Grafikobjekt, dass dieser Eigenschaft zugeordnet ist, kann von anderen Steuerungen abgerufen (z.B.<br />
durch die Picture-Eigenschaft der Image-Steuerung) oder aus einer Datei von der Festplatte mit der<br />
LoadPicture-Funktion von Visual Basic geladen werden.<br />
Jede Zelle kann Text und eine Grafik enthalten. Die relative Position des Textes und der Grafik wird<br />
durch die CellAlignment-Eigenschaft und CellPictureAlignment-Eigenschaft festgelegt. Wenn Sie den<br />
Text über der Grafik anzeigen wollen, müssen Sie die PicturesOver-Eigenschaft auf TRUE setzen.<br />
Wenn diese Eigenschaft geändert wird, dann betrifft dies die aktuelle Zelle oder Auswahl, je nach<br />
Einstellung der FillStyle-Eigenschaft. Verwenden Sie stattdessen die Cell-Eigenschaft, um Bilder für<br />
einen willkürlichen Zellbereich festzulegen (nicht zwingend die aktuelle Auswahl).<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
CellStyle-Klasse (Seite 376)<br />
CellPictureAlignment-Eigenschaft<br />
Ermittelt oder legt die Ausrichtung von Grafiken in der ausgewählten Zelle oder dem Bereich fest.<br />
Syntax<br />
[VB]<br />
Public CellPictureAlignment As PictureAlignmentSettings<br />
[C#]<br />
public PictureAlignmentSettings CellPictureAlignment {get; set;}<br />
[Delphi]<br />
property CellPictureAlignment: PictureAlignmentSettings;<br />
Bemerkungen<br />
Gültige Einstellungen für die CellPictureAlignment-Eigenschaft:<br />
Mitgliedsname Beschreibung<br />
flexPicAlignLeftTop Richtet Grafiken links oben aus.<br />
flexPicAlignLeftCenter Richtet Grafiken links zentriert aus.<br />
flexPicAlignLeftBottom Richtet Grafiken links unten aus.<br />
flexPicAlignCenterTop Richtet Grafiken zentriert oben aus.<br />
flexPicAlignCenterCenter Richtet Grafiken zentriert aus.<br />
flexPicAlignCenterBottom Richtet Grafiken zentriert unten aus.<br />
flexPicAlignRightTop Richtet Grafiken rechts oben aus.<br />
flexPicAlignRightCenter Richtet Grafiken rechts zentriert aus.
480 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
flexPicAlignRightBottom Richtet Grafiken rechts unten aus.<br />
flexPicAlignStretch Streckt das Bild, damit es die Zelle ausfüllt.<br />
flexPicAlignTile Ordnet die Grafik nebeneinander an, um die Zelle auszufüllen.<br />
Diese Eigenschaft legt auch die Ausrichtung von Kontrollkästchen in Zellen fest (Siehe CellChecked-<br />
Eigenschaft).<br />
Wenn diese Eigenschaft geändert wird, dann betrifft dies die aktuelle Zelle oder Auswahl, je nach<br />
Einstellung der FillStyle-Eigenschaft. Verwenden Sie stattdessen die Cell-Eigenschaft, um die<br />
Bilderausrichtung für einen willkürlichen Zellbereich festzulegen (nicht zwingend die aktuelle Auswahl).<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
CellStyle-Klasse (Seite 376)<br />
CellTextStyle-Eigenschaft<br />
Ermittelt oder legt den 3D-Effekt für den Text in einer ausgewählten Zelle oder einem Bereich fest.<br />
Syntax<br />
[VB]<br />
Public CellTextStyle As TextStyleSettings<br />
[C#]<br />
public TextStyleSettings CellTextStyle {get; set;}<br />
[Delphi]<br />
property CellTextStyle: TextStyleSettings;<br />
Bemerkungen<br />
Die Effekte der CellTextStyle-Eigenschaftseinstellungen werden nachfolgend beschrieben:<br />
Mitgliedsname Beschreibung<br />
flexTextFlat Zeichnet Text normal.<br />
flexTextRaised Zeichnet Text mit einem stark gehobenen 3D-Effekt.<br />
flexTextInset Zeichnet Text mit einem stark eingelassenen 3D-Effekt.<br />
flexTextRaisedLight Zeichnet Text mit einem schwach gehobenen 3D-Effekt.<br />
flexTextInsetLight Zeichnet Text mit einem schwach eingelassenen 3D-Effekt.<br />
Die Konstanten flexTextRaised und flexTextInset passen gut zu großen und fetten Schriftarten und<br />
flexTextRaisedLight und flexTextInsetLight eher zu kleineren, normalen Schriftarten.
CellTop-Eigenschaft · 481<br />
Wenn diese Eigenschaft geändert wird, dann betrifft dies die aktuelle Zelle oder Auswahl, je nach<br />
Einstellung der FillStyle-Eigenschaft. Verwenden Sie stattdessen die Cell-Eigenschaft, um die<br />
Textausrichtung für einen willkürlichen Zellbereich festzulegen (nicht zwingend die aktuelle Auswahl).<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
CellStyle-Klasse (Seite 376)<br />
CellTop-Eigenschaft<br />
Der obere Teil der Zelle.<br />
Syntax<br />
[VB]<br />
Public CellTop As Integer<br />
[C#]<br />
public int CellTop {get; set;}<br />
[Delphi]<br />
property CellTop: Integer;<br />
Bemerkungen<br />
Die CellHeight-, CellWidth-, CellTop- und CellLeft-Eigenschaften sind nützlich, um andere<br />
Steuerungen über oder nah einer Zelle zu platzieren. Immer wenn Sie eine dieser Eigenschaften auslesen,<br />
geht die Steuerung davon aus, dass Sie an der aktuellen Zelle arbeiten wollen und zeigt diese somit,<br />
wenn nötig mit Bildlauf, auf dem Bildschirm an.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
GetCellRect-Methode (Seite 188)<br />
CellWidth-Eigenschaft<br />
Gibt die Breite der ausgewählten Zelle in Twips zurück. Bringt die Zelle, wenn nötig mit Bildlauf, auf den<br />
Bildschirm.<br />
Syntax<br />
[VB]<br />
Public CellWidth As Integer<br />
[C#]<br />
public int CellWidth {get; set;}<br />
[Delphi]<br />
property CellWidth: Integer;
482 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Bemerkungen<br />
Die CellHeight-, CellWidth-, CellTop- und CellLeft-Eigenschaften sind nützlich, um andere<br />
Steuerungen über oder nah einer Zelle zu platzieren. Immer wenn Sie eine dieser Eigenschaften auslesen,<br />
geht die Steuerung davon aus, dass Sie an der aktuellen Zelle arbeiten wollen und zeigt diese somit,<br />
wenn nötig mit Bildlauf, auf dem Bildschirm an.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
GetCellRect-Methode (Seite 188)<br />
Cols-Eigenschaft (<strong>C1FlexGrid</strong>Classic)<br />
Gibt alle Spalten einer Tabelle zurück.<br />
Syntax<br />
[VB]<br />
Public Cols As ColumnCollection<br />
[C#]<br />
public ColumnCollection Cols {get;}<br />
[Delphi]<br />
property Cols: ColumnCollection;<br />
Bemerkungen<br />
Mit der Cols-Eigenschaft können Sie eine Liste mit allen derzeit vorhandenen Spalten in einer Tabelle<br />
abfragen. Mit dieser Referenz können Sie Spalten hinzufügen, entfernen, verschieben und zählen. Für<br />
weitere Informationen über die Funktionen dieser Sammlung schauen Sie in den Referenzthemen der<br />
ColumnCollection-Klasse nach.<br />
Diese Eigenschaft kann nur gelesen werden. Die Tabelle erstellt und verwaltet diese Liste/Sammlung.<br />
Upgradenotiz: In der VSFlexGrid-ActiveX-Steuerung zeigen die Cols- und FixedCols-Eigenschaften die<br />
Anzahl der Spalten und der fixierten Spalten in einer Tabelle. Verwenden Sie in <strong>C1FlexGrid</strong> hierfür<br />
Cols.Count und Cols.Fixed.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
ColumnCollection-Eigenschaft<br />
Ermittelt oder legt die ColumnCollection fest.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft ColumnCollection As C1.Win.<strong>C1FlexGrid</strong>.ColumnCollection
[C#]<br />
public C1.Win.<strong>C1FlexGrid</strong>.ColumnCollection ColumnCollection {get; set;}<br />
[Delphi]<br />
property ColumnCollection: C1.Win.<strong>C1FlexGrid</strong>.ColumnCollection;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
ColWidthMax-Eigenschaft<br />
Ermittelt oder legt die maximale Spaltenbreite in Twips fest.<br />
Syntax<br />
[VB]<br />
Public ColWidthMax As Integer<br />
[C#]<br />
public int ColWidthMax {get; set;}<br />
[Delphi]<br />
property ColWidthMax: Integer;<br />
Bemerkungen<br />
ColWidthMax-Eigenschaft · 483<br />
Setzen Sie diese Eigenschaft auf einen von Null verschiedenen Wert, um die maximale Breite von Spalten,<br />
und auf Null, um keinen Grenzwert festzulegen. Verwenden Sie die ColWidthMin-Eigenschaft um die<br />
Mindestgröße der Spalten festzusetzen.<br />
Das Aufstellen von Grenzwerten für Spaltenbreiten kann in Verbindung mit der AutoSize-Methode<br />
sinnvoll sein, um zu breite Spalten durch extrem lange Einträge, und zu schmale Spalten durch leere<br />
Zellen zu verhindern.<br />
Dieses Beispiel setzt die maximale Spaltenbreite auf zwei Inch (<strong>28</strong>80 Twips) fest:<br />
• Visual Basic<br />
• C#<br />
fg.ColWidthMax = <strong>28</strong>80<br />
fg.ColWidthMax = <strong>28</strong>80;<br />
• Delphi<br />
fg.ColWidthMax := <strong>28</strong>80;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
MaxSize-Eigenschaft (ColumnCollection) (Seite 318)<br />
ColWidthMin-Eigenschaft<br />
Ermittelt oder legt die minimale Spaltenbreite in Twips fest.
484 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Syntax<br />
[VB]<br />
Public ColWidthMin As Integer<br />
[C#]<br />
public int ColWidthMin {get; set;}<br />
[Delphi]<br />
property ColWidthMin: Integer;<br />
Bemerkungen<br />
Setzen Sie diese Eigenschaft auf einen von Null verschiedenen Wert, um die Mindestbreite von Spalten,<br />
und auf Null, um keinen Grenzwert festzulegen. Verwenden Sie die ColWidthMax-Eigenschaft, um die<br />
maximale Breite der Spalten festzusetzen.<br />
Das Aufstellen von Grenzwerten für Spaltenbreiten kann in Verbindung mit der AutoSize-Methode<br />
sinnvoll sein, um zu breite Spalten duch extrem lange Einträge und zu schmale Spalten durch leere<br />
Zellen zu verhindern.<br />
Dieses Beispiel setzt die maximale Spaltenbreite auf ein halbes Inch (720 Twips) fest:<br />
• Visual Basic<br />
• C#<br />
fg.ColWidthMin = 720<br />
fg.ColWidthMin = 720;<br />
• Delphi<br />
fg.ColWidthMin := 720;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
MinSize-Eigenschaft (ColumnCollection) (Seite 318)<br />
ComboCount-Eigenschaft<br />
Gibt die Anzahl der Einträge in der Auswahlliste des Auswahllisteneditors zurück.<br />
Syntax<br />
[VB]<br />
Public ReadOnly-Eigenschaft ComboCount As Integer<br />
[C#]<br />
public int ComboCount {get;}<br />
[Delphi]<br />
property ComboCount: Integer;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)
ComboIndex-Eigenschaft<br />
ComboIndex-Eigenschaft · 485<br />
Ermittelt oder legt den bei Null beginnenden Index der aktuellen Auswahl in der Auswahlliste des<br />
Editors fest.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft ComboIndex As Integer<br />
[C#]<br />
public int ComboIndex {get; set;}<br />
[Delphi]<br />
property ComboIndex: Integer;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Editable-Eigenschaft<br />
Ermittelt oder legt fest, ob die Steuerung Zellbearbeitung zulässt.<br />
Syntax<br />
[VB]<br />
Public Editable As EditableSettings<br />
[C#]<br />
public EditableSettings Editable {get; set;}<br />
[Delphi]<br />
property Editable: EditableSettings;<br />
Bemerkungen<br />
Wenn die Editable-Eigenschaft auf einem von Null verschiedenen Wert steht, dann kann der Nutzer die<br />
Zellinhalte bearbeiten, indem er in die Tabelle schreibt.<br />
Die möglichen Einstellungen der Editable-Eigenschaft werden nachfolgend beschrieben:<br />
Mitgliedsname Beschreibung<br />
flexEDNone Der Tabelleninhalt kann vom Nutzer nicht bearbeitet werden.<br />
flexEDKbd<br />
flexEDKbdMouse<br />
Der Nutzer kann den Bearbeitungsmodus initialisieren, wenn er in die<br />
aktuelle Zelle schreibt.<br />
Der Nutzer kann den Bearbeitungsmodus initialisieren, wenn er in die<br />
aktuelle Zelle schreibt oder mit der Maus darauf doppelklickt.
486 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Standardmäßig geht die Steuerung in den Bearbeitungsmodus wenn der Nutzer die F2-, die Leer- oder<br />
jede beliebige Zeichentaste drückt. Wenn die Editable-Eigenschaft auf flexEDKbdMouse (2) steht, dann<br />
geht die Steuerung auch in den Bearbeitungsmodus, wenn der Nutzer auf eine Zelle doppelklickt.<br />
Sie können die Steuerung mit der StartEditing-Methode in den Bearbeitungsmodus zwingen oder diesen<br />
Modus verhindern, indem Sie das BeforeEdit-Ereignis abfangen und den Cancel-Parameter auf TRUE<br />
setzen. Sie können den Bearbeitungsmodus abbrechen, indem Sie mit der Select-Anweisung eine andere<br />
Zelle auswählen (inklusive der, die gerade bearbeitet wird).<br />
Je nach Einstellung der get_ColComboList-Methode, können Sie ein gewöhnliches Textfenster, eine<br />
Auswahlliste oder eine Kombinationsliste verwenden. Die Bearbeitungsmaske kann auch in der<br />
EditMask-Eigenschaft als Antwort auf das BeforeEdit-Ereignis festgelegt werden.<br />
Mit dem ValidateEdit-Ereignis können Daten auf Gültigkeit geprüft werden und mit dem AfterEdit-<br />
Ereignis Anpassungen nach der Bearbeitung, wie z.B. Neusortierung, vorgenommen werden.<br />
Verwenden Sie die EditWindow-Eigenschaft, um zu ermitteln, ob die Steuerung sich im<br />
Bearbeitungsmodus befindet. In diesem Fall hat die Eigenschaft einen von Null verschiedenen Wert.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
AllowEditing-Eigenschaft (<strong>C1FlexGrid</strong>) (Seite 120)<br />
EditSelLength-Eigenschaft<br />
Ermittelt oder legt die Anzahl der im Editor ausgewählten Zeichen fest.<br />
Syntax<br />
[VB]<br />
Public EditSelLength As Integer<br />
[C#]<br />
public int EditSelLength {get; set;}<br />
[Delphi]<br />
property EditSelLength: Integer;<br />
Bemerkungen<br />
Diese Eigenschaft arbeitet zusammen mit den EditSelStart- und EditSelText-Eigenschaften, während die<br />
Steuerung sich im Zellbearbeitungsmodus befindet.<br />
Verwenden Sie diese Eigenschaften für Aufgaben, wie das Festlegen einer Einfügestelle, Erstellen eines<br />
Einfügebereichs, Auswahl von Zeichenkettenteilen in Editoren oder Entfernen von Text. Zusammen mit<br />
dem Visual Basic-Clipboard-Objekt können diese für Kopieren, Ausschneiden und Einfügen nützlich<br />
sein.<br />
Anmerkungen:<br />
1. Die SelLength auf einen Wert kleiner als 0 zu setzen, verursacht einen Runtimefehler.<br />
2. Wenn die SelLength auf einen Wert größer als die Textlänge gesetzt wird, dann passt die<br />
Steuerung diesen an die maximale Textlänge an.<br />
3. Eine Änderung in SelStart ändert die Auswahl einer Einfügestelle und setzt SelLength auf 0.
EditSelStart-Eigenschaft · 487<br />
4. Wenn SelText auf einen neuen Wert gesetzt wird, dann wird der aktuelle Text mit dem neuen<br />
Wert ersetzt und SelLength auf 0 gestellt.<br />
Der folgende Quellcode markiert immer dann Zeichen 6 bis 8, wenn die Zelle angeklickt wird.<br />
• Visual Basic<br />
Private Sub fg_Click(ByVal sender As System.Object, _<br />
ByVal e As System.EventArgs) Handles fg.Click<br />
fg.EditCell<br />
fg.EditSelStart = 5<br />
fg.EditSelLength = 3<br />
End Sub<br />
• C#<br />
private void fg_Click( System.object sender, System.EventArgs e)<br />
fg.Click {<br />
fg.EditCell;<br />
fg.EditSelStart = 5;<br />
fg.EditSelLength = 3;<br />
}<br />
• Delphi<br />
procedure fg_Click(sender: System.Object;<br />
e: System.EventArgs);<br />
begin<br />
fg.EditCell;<br />
fg.EditSelStart := 5;<br />
fg.EditSelLength := 3;<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Editor-Eigenschaft (<strong>C1FlexGrid</strong>) (Seite 143)<br />
EditSelStart-Eigenschaft<br />
Ermittelt oder legt das erste Zeichen der Auswahl im Editor fest.<br />
Syntax<br />
[VB]<br />
Public EditSelStart As Integer<br />
[C#]<br />
public int EditSelStart {get; set;}<br />
[Delphi]<br />
property EditSelStart: Integer;<br />
Bemerkungen<br />
Diese Eigenschaft arbeitet zusammen mit den EditSelLength- und EditSelText-Eigenschaften, während<br />
die Steuerung sich im Zellbearbeitungsmodus befindet.<br />
Verwenden Sie diese Eigenschaften für Aufgaben, wie das Festlegen einer Einfügestelle, Erstellen eines<br />
Einfügebereichs, Auswahl von Zeichenkettenteilen in Editoren oder Entfernen von Text. Zusammen mit
488 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
dem Visual Basic-Clipboard-Objekt können diese für Kopieren, Ausschneiden und Einfügen nützlich<br />
sein.<br />
Anmerkungen:<br />
1. Die SelLength auf einen Wert kleiner als 0 zu setzen, verursacht einen Runtimefehler.<br />
2. Wenn die SelLength auf einen Wert größer als die Textlänge gesetzt wird, dann passt die<br />
Steuerung diesen an die maximale Textlänge an.<br />
3. Eine Änderung in SelStart ändert die Auswahl einer Einfügestelle und setzt SelLength auf 0.<br />
4. Wenn SelText auf einen neuen Wert gesetzt wird, dann wird der aktuelle Text mit dem neuen<br />
Wert ersetzt und SelLength auf 0 gestellt.<br />
Der folgende Quellcode markiert immer dann Zeichen 6 bis 8, wenn die Zelle angeklickt wird.<br />
• Visual Basic<br />
Private Sub fg_Click(ByVal sender As System.Object, _<br />
ByVal e As System.EventArgs) Handles fg.Click<br />
fg.EditCell<br />
fg.EditSelStart = 5<br />
fg.EditSelLength = 3<br />
End Sub<br />
• C#<br />
private void fg_Click( System.object sender, System.EventArgs e)<br />
fg.Click {<br />
fg.EditCell;<br />
fg.EditSelStart = 5;<br />
fg.EditSelLength = 3;<br />
}<br />
• Delphi<br />
procedure fg_Click(sender: System.Object;<br />
e: System.EventArgs);<br />
begin<br />
fg.EditCell;<br />
fg.EditSelStart := 5;<br />
fg.EditSelLength := 3;<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Editor-Eigenschaft (<strong>C1FlexGrid</strong>) (Seite 143)<br />
EditSelText-Eigenschaft<br />
Ermittelt oder legt die Zeichenkette der aktuellen Auswahl im Editor fest.<br />
Syntax<br />
[VB]<br />
Public EditSelText As String<br />
[C#]<br />
public string EditSelText {get; set;}
[Delphi]<br />
property EditSelText: string;<br />
Bemerkungen<br />
EditSelText-Eigenschaft · 489<br />
Diese Eigenschaft arbeitet zusammen mit den EditSelStart- und EditSelLength-Eigenschaften, während<br />
die Steuerung sich im Zellbearbeitungsmodus befindet.<br />
Verwenden Sie diese Eigenschaften für Aufgaben, wie das Festlegen einer Einfügestelle, Erstellen eines<br />
Einfügebereichs, Auswahl von Zeichenkettenteilen in Editoren oder Entfernen von Text. Zusammen mit<br />
dem Visual Basic-Clipboard-Objekt können diese für Kopieren, Ausschneiden und Einfügen nützlich<br />
sein.<br />
Anmerkungen:<br />
1. Die SelLength auf einen Wert kleiner als 0 zu setzen, verursacht einen Runtimefehler.<br />
2. Wenn die SelLength auf einen Wert größer als die Textlänge gesetzt wird, dann passt die<br />
Steuerung diesen an die maximale Textlänge an.<br />
3. Eine Änderung in SelStart ändert die Auswahl einer Einfügestelle und setzt SelLength auf 0.<br />
4. Wenn SelText auf einen neuen Wert gesetzt wird, dann wird der aktuelle Text mit dem neuen<br />
Wert ersetzt und SelLength auf 0 gestellt.<br />
Der folgende Quellcode ersetzt immer dann Zeichen 6 bis 8 mit dem Wort „COW“, wenn die<br />
Zelle angeklickt wird.<br />
• Visual Basic<br />
Private Sub fg_Click(ByVal sender As System.Object,<br />
ByVal e As System.EventArgs) Handles fg.Click<br />
fg.EditCell<br />
fg.EditSelStart = 5<br />
fg.EditSelLength = 3<br />
fg.EditSelText = "COW"<br />
End Sub<br />
• C#<br />
private void fg_Click( System.object sender,<br />
System.EventArgs e)<br />
{<br />
fg.EditCell;<br />
fg.EditSelStart = 5;<br />
fg.EditSelLength = 3;<br />
fg.EditSelText = "COW";<br />
}<br />
• Delphi<br />
procedure fg_Click(sender: System.Object;<br />
e: System.EventArgs);<br />
begin<br />
fg.EditCell;<br />
fg.EditSelStart := 5;<br />
fg.EditSelLength := 3;<br />
fg.EditSelText := 'COW';<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)
490 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Editor-Eigenschaft (<strong>C1FlexGrid</strong>) (Seite 143)<br />
EditText-Eigenschaft<br />
Ermittelt oder legt den Text im Editor fest.<br />
Syntax<br />
[VB]<br />
Public EditText As String<br />
[C#]<br />
public string EditText {get; set;}<br />
[Delphi]<br />
property EditText: string;<br />
Bemerkungen<br />
Mit der EditText-Eigenschaft können Sie den Inhalt des Zelleditors auslesen und verändern, während<br />
dieser aktiv ist.<br />
Diese Eigenschaft ist für die Verarbeitung des ValidateEdit-Ereignisses nützlich. Wenn das ValidateEdit-<br />
Ereignis gestartet wird, dann enthält die Zelle immer noch ihren anfänglichen Wert. Der neue, bearbeitete<br />
Wert steht nur über die EditText-Eigenschaft zur Verfügung.<br />
Zum Beispiel, der nachfolgende Quellcode zeigt einen gängigen Abwickler für das ValidateEdit-Ereignis.<br />
In diesem Fall nimmt Spalte eins nur Zeichenketten und Spalte zwei nur Zahlen größer als Null an:<br />
• Visual Basic<br />
• C#<br />
Private Sub fg_ValidateEdit(ByVal sender As Object, _<br />
ByVal e As C1.Win.<strong>C1FlexGrid</strong>.ValidateEditEventArgs) _<br />
Handles fg.ValidateEdit<br />
Dim c$<br />
Select Case e.Col ' different validation rules for each column<br />
Case 1 ' column 1 only accepts strings<br />
c = Left$(fg.EditText, 1)<br />
If UCaseS(c) < "A" Or UCase$(c) > "Z" Then Beep: e.Cancel = True<br />
Case 2 ' column 2 only accepts numbers > 0<br />
If Val(fg.EditText) "Z" ) e.Cancel = true;<br />
case 2: // column 2 only accepts numbers > 0<br />
try<br />
{<br />
int i = int.Parse(fg.EditText);<br />
} catch {<br />
e.Cancel = true;<br />
}
}<br />
}<br />
• Delphi<br />
procedure fg_ValidateEdit(sender: System.Object; _<br />
e: C1.Win.<strong>C1FlexGrid</strong>.ValidateEditEventArgs);<br />
var<br />
c: char;<br />
begin<br />
case e.Col of // column 1 only accepts strings<br />
1:<br />
begin<br />
c := fg.EditText.SubString(0, 1).ToUpper();<br />
If (c < 'A') Or (c > 'Z') Then<br />
e.Cancel := True;<br />
end;<br />
2:<br />
begin<br />
If Val(fg.EditText)
492 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
• C#<br />
ByVal e As C1.Win.<strong>C1FlexGrid</strong>.RangeEventArgs) Handles<br />
fg.BeforeScroll<br />
If Not fg.EditWindow.Equals(0) AndAlso e.OldRange.TopRow <br />
e.NewRange.TopRow Then<br />
e.Cancel = True<br />
End Sub<br />
private void fg_BeforeScroll( object sender,<br />
C1.Win.<strong>C1FlexGrid</strong>.RangeEventArgs e) fg.BeforeScroll {<br />
if (!fg.EditWindow.Equals(0) && e.OldRange.TopRow !=<br />
e.NewRange.TopRow ) {<br />
e.Cancel = true;<br />
}<br />
• Delphi<br />
procedure fg_BeforeScroll(sender: System.Object;<br />
e: C1.Win.<strong>C1FlexGrid</strong>.RangeEventArgs);<br />
begin<br />
If Not fg.EditWindow.Equals(0) and (e.OldRange.TopRow <br />
e.NewRange.TopRow) Then<br />
e.Cancel := True;<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Editor-Eigenschaft (<strong>C1FlexGrid</strong>) (Seite 143)<br />
Ellipsis-Eigenschaft<br />
Ermittelt oder legt fest, ob die Steuerung Ellipsis („...“) nach langen Zeichenketten anzeigen soll.<br />
Syntax<br />
[VB]<br />
Public Ellipsis As EllipsisSettings<br />
[C#]<br />
public EllipsisSettings Ellipsis {get; set;}<br />
[Delphi]<br />
property Ellipsis: EllipsisSettings;<br />
Bemerkungen<br />
Die Ellipsis-Eigenschaft legt fest, wie die Steuerung Zeichenketten anzeigt, die zu lang für den Platz in<br />
einer Zelle sind. Indem Sie diese Eigenschaft auf einen von Null verschiedenen Wert setzen, zwingen Sie<br />
die Tabelle mit einem Ellipsis-Symbol („...“) anzuzeigen, dass ein Teil des Textes abgeschnitten wurde.<br />
Die möglichen Einstellungen der Ellipsis-Eigenschaft werden nachfolgend beschrieben:<br />
Mitgliedsname Beschreibung<br />
flexNoEllipsis<br />
Lange Zeichenketten werden abgeschnitten und es werden keine Ellipsis-<br />
Zeichen angezeigt.
ExplorerBar-Eigenschaft · 493<br />
flexEllipsisEnd Ellipsis-Zeichen werden am Ende von langen Zeichenketten angezeigt.<br />
flexEllipsisPath Ellipsis-Zeichen werden in der Mitte von langen Zeichenketten angezeigt.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Trimming-Eigenschaft (Seite 387)<br />
ExplorerBar-Eigenschaft<br />
Ermittelt oder legt fest, ob Spaltenüberschriften für Sortieren und/oder Verschieben verwendet werden.<br />
Syntax<br />
[VB]<br />
Public ExplorerBar As ExplorerBarSettings<br />
[C#]<br />
public ExplorerBarSettings ExplorerBar {get; set;}<br />
[Delphi]<br />
property ExplorerBar: ExplorerBarSettings;<br />
Bemerkungen<br />
Mit der ExplorerBar-Eigenschaft können Nutzer über Spaltenüberschriften die entsprechenden Spalten<br />
ohne Quellcode sortieren und verschieben. Gültige Einstellungen werden nachfolgend beschrieben:<br />
Mitgliedsname Beschreibung<br />
flexExNone Nutzer können Spalten weder sortieren noch verschieben.<br />
flexExSort Nutzer können Spalten sortieren.<br />
flexExMove Nutzer können Spalten verschieben.<br />
flexExSortAndMove Nutzer können Spalten sortieren und verschieben.<br />
flexExSortShow<br />
flexExSortShowAndMove<br />
flexExMoveRows *<br />
Nutzer können Spalten mit einem Klick auf deren Überschirft sortieren.<br />
Die Steuerung zeigt die aktuelle Sortierungsrichtung mit einem Pfeil in<br />
der Spaltenüberschrift an.<br />
Nutzer können Spalten sortieren und verschieben. Die Steuerung zeigt<br />
die aktuelle Sortierungsrichtung mit einem Pfeil in der<br />
Spaltenüberschrift an.<br />
Nutzer können Zeilen verschieben, indem sie die fixierten Zellen der<br />
entsprechenden Zeile auf eine neue Position ziehen.<br />
* Die Einstellung flexExMoveRows ist eigentlich ein Flag und kann mit anderen Einstellungen durch eine<br />
„Or“-Anweisung verknüpft werden. Zum Beispiel:
494 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
• Visual Basic<br />
• C#<br />
'allow sorting, moving rows, and moving columns<br />
fg.ExplorerBar = ExplorerBarSettings.flexExMoveRows Or<br />
ExplorerBarSettings.flexExSortShowAndMove<br />
//allow sorting, moving rows, and moving columns<br />
fg.ExplorerBar = ExplorerBarSettings.flexExMoveRows ||<br />
ExplorerBarSettings.flexExSortShowAndMove;<br />
• Delphi<br />
//allow sorting, moving rows, and moving columns<br />
fg.ExplorerBar := (ExplorerBarSettings.flexExMoveRows or<br />
ExplorerBarSettings.flexExSortShowAndMove);<br />
Beachten Sie, dass diese Werte eine Kombination von binären Flags und nicht sequentiell sind.<br />
Standardmäßig funktioniert die ExplorerBar wie die im Dateiexplorer von Microsoft Windows. Ein Klick<br />
sortiert die Spalte in aufsteigender Richtung, der nächste in absteigender Richtung. Jede nicht fixierte<br />
Spalte kann auf eine andere nicht fixierte Position gezogen werden. Die Steuerung startet verschiedene<br />
Ereignisse, mit denen Sie dieses Verhalten anpassen können. Diese Ereignisse sind BeforeSort, AfterSort,<br />
BeforeDragColumn und AfterDragColumn.<br />
Die neue ExplorerBar ist leichter zu bedienen. Zum Beispiel, wenn eine Spalte sortiert ist, dann wird ein<br />
Dreiecksglyph in Richtung der Sortierung angezeigt. Außerdem wird nun deutlich die neue<br />
Spaltenposition angezeigt und die Tabelle, wenn nötig, auch gescrollt, um Spalten auf jede beliebige<br />
Position ziehen zu können, wenn eine Spalte verschoben werden soll.<br />
Sie müssen mindestens eine fixierte Zeile haben, damit Sie ExplorerBar verwenden können.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
AllowResizing-Eigenschaft (Seite 122)<br />
AllowSorting-Eigenschaft (<strong>C1FlexGrid</strong>) (Seite 124)<br />
FillStyle-Eigenschaft<br />
Ermittelt oder legt fest, ob Änderungen in den Text- oder Format-Eigenschaften auf die aktuelle Zelle<br />
oder die gesamte Auswahl angewendet werden sollen.<br />
Syntax<br />
[VB]<br />
Public FillStyle As FillStyleSettings<br />
[C#]<br />
public FillStyleSettings FillStyle {get; set;}<br />
[Delphi]<br />
property FillStyle: FillStyleSettings;<br />
Bemerkungen<br />
Die möglichen Einstellungen der FillStyle-Eigenschaft werden nachfolgend beschrieben:
Mitgliedsname Beschreibung<br />
flexFillSingle<br />
flexFillRepeat<br />
FixedCols-Eigenschaft · 495<br />
Das Setzen der Text- oder einer beliebigen Zellformatierungseigenschaft betrifft<br />
nur die aktuelle Zelle.<br />
Das Setzen der Text- oder einer beliebigen Zellformatierungseigenschaft betrifft<br />
den gesamten, aktuell ausgewählten Bereich.<br />
Die FillStyle-Eigenschaft legt außerdem fest, ob Änderungen durch Bearbeitung einer Zelle nur auf die<br />
aktuelle Zelle oder die gesamte Auswahl angewendet werden sollen.<br />
FillStyle wird ignoriert, wenn SelectionMode auf flexSelectionListBox steht.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Selection-Eigenschaft (Seite 166)<br />
FixedCols-Eigenschaft<br />
Ermittelt oder legt die Anzahl der fixierten Spalten (nicht scrollbar) fest.<br />
Syntax<br />
[VB]<br />
Public FixedCols As Integer<br />
[C#]<br />
public int FixedCols {get; set;}<br />
[Delphi]<br />
property FixedCols: Integer;<br />
Bemerkungen<br />
Fixierte Spalten bleiben sichtbar, wenn der Nutzer den Inhalt der Tabelle scrollt. Diese können vom<br />
Nutzer weder ausgewählt noch verändert werden. Allerdings können sie mit Quellcode ausgewählt<br />
werden, so dass es möglich ist, über die EditCell-Methode dem Nutzer das Verändern der Inhalte dieser<br />
Zellen zu erlauben. Sie können FixedCols auf jeden Wert zwischen Null und Anzahl der Spalten setzen.<br />
Die folgende Quellcodezeile platziert drei fixierte Spalten auf der linken Seite der Tabelle.<br />
• Visual Basic<br />
• C#<br />
fg.FixedCols = 3<br />
fg.FixedCols = 3;<br />
• Delphi<br />
fg.FixedCols := 3;<br />
Fixierte Spalten werden in Tabellenkalkulationsprogrammen meist für Zeilennummern oder andere<br />
Zeilenbezeichnungen verwendet.
496 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Verwenden Sie die BackColorFixed, ForeColorFixed und GridLinesFixed-Eigenschaften, um fixierte<br />
Zellen zu formatieren.<br />
Wenn die AllowUserResizing-Eigenschaft auf einem von Null verschiedenen Wert steht, dann können<br />
die Zeilenhöhen und Spaltenbreiten über die fixierten Zellen durch den Nutzer während der Runtime<br />
verändert werden.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Fixed-Eigenschaft (ColumnCollection) (Seite 316)<br />
FixedRows-Eigenschaft<br />
Ermittelt oder legt die Anzahl der fixierten Zeilen (nicht scrollbar) fest.<br />
Syntax<br />
[VB]<br />
Public FixedRows As Integer<br />
[C#]<br />
public int FixedRows {get; set;}<br />
[Delphi]<br />
property FixedRows: Integer;<br />
Bemerkungen<br />
Fixierte Zeilen bleiben sichtbar, wenn der Nutzer den Inhalt der Tabelle scrollt. Diese können vom<br />
Nutzer weder ausgewählt noch verändert werden. Allerdings können sie mit Quellcode ausgewählt<br />
werden, so dass es möglich ist, über die EditCell-Methode dem Nutzer das Verändern der Inhalte dieser<br />
Zellen zu erlauben. Sie können FixedRows auf jeden Wert zwischen Null und Anzahl der Zeilen setzen.<br />
Die folgende Quellcodezeile platziert drei fixierte Zeilen an der oberen Seite der Tabelle.<br />
• Visual Basic<br />
• C#<br />
fg.FixedRows = 3<br />
fg.FixedRows = 3;<br />
• Delphi<br />
fg.FixedRows := 3;<br />
Fixierte Zeilen werden in Tabellenkalkulationsprogrammen meist für Spaltenüberschriften und in<br />
Datenbankprogrammen für Feldnamen verwendet.<br />
Verwenden Sie die BackColorFixed, ForeColorFixed und GridLinesFixed-Eigenschaften, um fixierte<br />
Zellen zu formatieren.<br />
Wenn die AllowUserResizing-Eigenschaft auf einem von Null verschiedenen Wert steht, dann können<br />
die Zeilenhöhen und Spaltenbreiten über die fixierten Zellen durch den Nutzer während der Runtime<br />
verändert werden.
FontBold-Eigenschaft · 497<br />
Wenn die ExplorerBar-Eigenschaft auf einem von Null verschiedenen Wert steht, dann kann der Nutzer<br />
Spalten mit den fixierten Zeilen und der Maus sortieren und verschieben.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Fixed-Eigenschaft (RowCollection) (Seite 306)<br />
FontBold-Eigenschaft<br />
Legt fest, ob Text fett ist.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft FontBold As Boolean<br />
[C#]<br />
public bool FontBold {get; set;}<br />
[Delphi]<br />
property FontBold: Boolean;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
FontItalic-Eigenschaft<br />
Legt fest, ob Text kursiv ist.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft FontItalic As Boolean<br />
[C#]<br />
public bool FontItalic {get; set;}<br />
[Delphi]<br />
property FontItalic: Boolean;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
FontName-Eigenschaft<br />
Legt den Namen der für den Text verwendeten Schriftart fest.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft FontName As String
498 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
[C#]<br />
public string FontName {get; set;}<br />
[Delphi]<br />
property FontName: String;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
FontSize-Eigenschaft<br />
Legt Schriftgröße für die Texte fest, die mit Objekten angezeigt werden.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft FontSize As Single<br />
[C#]<br />
public Single FontSize {get; set;}<br />
[Delphi]<br />
property FontSize: Single;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
FontStrikeThru-Eigenschaft<br />
Legt fest, ob Text das Strikethru-Format besitzt.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft FontStrikeThru As Boolean<br />
[C#]<br />
public bool FontStrikeThru {get; set;}<br />
[Delphi]<br />
property FontStrikeThru: Boolean;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
FontUnderline-Eigenschaft<br />
Legt fest, ob Text unterstrichen ist.
Syntax<br />
[VB]<br />
Public-Eigenschaft FontUnderline As Boolean<br />
[C#]<br />
public bool FontUnderline {get; set;}<br />
[Delphi]<br />
property FontUnderline: Boolean;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
ForeColorFixed-Eigenschaft<br />
Ermittelt oder legt die Vordergrundfarbe von fixierten Zeilen und Spalten fest.<br />
Syntax<br />
[VB]<br />
Public ForeColorFixed As Color<br />
[C#]<br />
public Color ForeColorFixed {get; set;}<br />
[Delphi]<br />
property ForeColorFixed: Color;<br />
Bemerkungen<br />
Diese Eigenschaft legt die Schriftfarbe fest.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Styles-Eigenschaft (Seite 170)<br />
ForeColorSel-Eigenschaft<br />
Ermittelt oder legt die Vordergrundfarbe von ausgewählten Zellen fest.<br />
Syntax<br />
[VB]<br />
Public ForeColorSel As Color<br />
[C#]<br />
public Color ForeColorSel {get; set;}<br />
[Delphi]<br />
property ForeColorSel: Color;<br />
ForeColorFixed-Eigenschaft · 499
500 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Bemerkungen<br />
Diese Eigenschaft legt die Schriftfarbe fest.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Styles-Eigenschaft (Seite 170)<br />
FrozenCols-Eigenschaft<br />
Ermittelt oder legt die Anzahl der eingefrorenen Spalten (bearbeitbar, aber nicht scrollbar) fest.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft FrozenCols As Integer<br />
[C#]<br />
public int FrozenCols {get; set;}<br />
[Delphi]<br />
property FrozenCols: Integer;<br />
Bemerkungen<br />
Zellen in eingefrorenen Spalten können ausgewählt und bearbeitet werden und sie bleiben auf dem<br />
Bildschirm stehen, wenn der Nutzer den Inhalt der Tabelle horizontal scrollt.<br />
Eingefrorene Spalten sind nützlich, wenn die Tabelle als Datenbrowser verwendet wird. Damit kann der<br />
Nutzer den Inhalt scrollen, wobei die linken Spalten aus FrozenCols sichtbar bleiben.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
FrozenRows-Eigenschaft<br />
Ermittelt oder legt die Anzahl der eingefrorenen Zeilen (bearbeitbar, aber nicht scrollbar) fest.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft FrozenRows As Integer<br />
[C#]<br />
public int FrozenRows {get; set;}<br />
[Delphi]<br />
property FrozenRows: Integer;<br />
Bemerkungen<br />
Zellen in eingefrorenen Zeilen können ausgewählt und bearbeitet werden und sie bleiben auf dem<br />
Bildschirm stehen, wenn der Nutzer den Inhalt der Tabelle vertikal scrollt.
GridColor-Eigenschaft · 501<br />
Eingefrorene Zeilen sind nützlich, wenn die oberen Zeilen Information anzeigen, die auf dem Bildschirm<br />
bleiben sollen, z.B. Zwischensummenzeilen oder eine „query-by-example"-Suchzeile.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
GridColor-Eigenschaft<br />
Ermittelt oder legt die Farbe der Gitterlinien zwischen den nicht fixierten Zellen fest.<br />
Syntax<br />
[VB]<br />
Public GridColor As Color<br />
[C#]<br />
public Color GridColor {get; set;}<br />
[Delphi]<br />
property GridColor: Color;<br />
Bemerkungen<br />
Die GridColor- und GridLines-Eigenschaften legen das Format der Gitterlinien im scrollbaren Bereich<br />
und GridColorFixed und GridLinesFixed im fixierten Bereich der Tabelle fest.<br />
Die GridColor-Eigenschaft wird ignoriert, wenn GridLines auf einem 3D-Format steht. Hervorgehobene<br />
und eingelassene Gitterlinien werden immer mit den vom System festgelegten Farben für Schatten und<br />
Hervorhebungen gezeichnet.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Styles-Eigenschaft (Seite 170)<br />
GridColorFixed-Eigenschaft<br />
Ermittelt oder legt die Farbe der Gitterlinien zwischen den fixierten Zellen fest.<br />
Syntax<br />
[VB]<br />
Public GridColorFixed As Color<br />
[C#]<br />
public Color GridColorFixed {get; set;}<br />
[Delphi]<br />
property GridColorFixed: Color;<br />
Bemerkungen<br />
Die GridColorFixed- und GridLinesFixed-Eigenschaften legen das Format der Gitterlinien im fixierten<br />
Bereich und GridColor und GridLines im scrollbaren Bereich der Tabelle fest.
502 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Die GridColorFixed-Eigenschaft wird ignoriert, wenn GridLinesFixed auf einem 3D-Format steht.<br />
Hervorgehobene und eingelassene Gitterlinien werden immer mit den vom System festgelegten Farben<br />
für Schatten und Hervorhebungen gezeichnet.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Styles-Eigenschaft (Seite 170)<br />
GridLines-Eigenschaft<br />
Ermittelt oder legt den Typ der Gitterlinien zwischen den nicht fixierten Zellen fest.<br />
Syntax<br />
[VB]<br />
Public GridLines As GridStyleSettings<br />
[C#]<br />
public GridStyleSettings GridLines {get; set;}<br />
[Delphi]<br />
property GridLines: GridStyleSettings;<br />
Bemerkungen<br />
Die GridColor- und GridLines-Eigenschaften legen das Format der Gitterlinien im scrollbaren Bereich<br />
und GridColorFixed und GridLinesFixed im fixierten Bereich der Tabelle fest.<br />
Die möglichen Einstellungen der GridLines-Eigenschaft werden nachfolgend beschrieben:<br />
Mitgliedsname Beschreibung<br />
flexGridNone Zeichnet keine Gitternetzlinien zwischen Zellen.<br />
flexGridFlat<br />
Zeichnet flache Linien mit der Farbe und der Breite aus den GridColor- und<br />
GridLineWidth-Eigenschaften.<br />
flexGridInset Zeichnet eingelassene Linien zwischen Zellen.<br />
flexGridRaised Zeichnet herausgehobene Linien zwischen Zellen.<br />
flexGridFlatHorz Zeichnet flache Linien zwischen Zeilen und keine Linien zwischen Spalten.<br />
flexGridInsetHorz Zeichnet eingelassene Linien zwischen Zeilen und keine Linien zwischen Spalten.<br />
flexGridRaisedHorz<br />
Zeichnet herausgehobene Linien zwischen Zeilen und keine Linien zwischen<br />
Spalten.<br />
flexGridSkipHorz Zeichnet eingelassene Linien um jede zweite Zeile.<br />
flexGridFlatVert Zeichnet flache Linien zwischen Spalten und keine Linien zwischen Zeilen.<br />
flexGridInsetVert Zeichnet eingelassene Linien zwischen Spalten und keine Linien zwischen Zeilen.<br />
flexGridRaisedVert<br />
Zeichnet herausgehobene Linien zwischen Spalten und keine Linien zwischen<br />
Zeilen.<br />
flexGridSkipVert Zeichnet eingelassene Linien um jede zweite Spalte.
Mitgliedsname Beschreibung<br />
flexGridExplorer Zeichnet schaltflächenähnliche Rahmen um jede Zelle.<br />
flexGridExcel<br />
GridLinesFixed-Eigenschaft · 503<br />
Zeichnet schaltflächenähnliche Rahmen um jede Zelle und markiert die<br />
Überschriften für die aktuelle Auswahl. Diese Einstellung sollte nur für die<br />
GridLinesFixed-Eigenschaft verwendet werden.<br />
Die GridColor-Eigenschaft wird ignoriert, wenn GridLines auf einem 3D-Format steht. Hervorgehobene<br />
und eingelassene Gitterlinien werden immer mit den vom System festgelegten Farben für Schatten und<br />
Hervorhebungen gezeichnet.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Styles-Eigenschaft (Seite 170)<br />
GridLinesFixed-Eigenschaft<br />
Ermittelt oder legt den Typ der Gitterlinien zwischen den fixierten Zellen fest.<br />
Syntax<br />
[VB]<br />
Public GridLinesFixed As GridStyleSettings<br />
[C#]<br />
public GridStyleSettings GridLinesFixed {get; set;}<br />
[Delphi]<br />
property GridLinesFixed: GridStyleSettings;<br />
Bemerkungen<br />
Die GridColorFixed- und GridLinesFixed-Eigenschaften legen das Format der Gitterlinien im fixierten<br />
Bereich und GridColor und GridLines im scrollbaren Bereich der Tabelle fest.<br />
Die möglichen Einstellungen der GridLinesFixed-Eigenschaft sind die Gleichen wie die der GridLines-<br />
Eigenschaft. flexGridExcel sollte nur für die GridLinesFixed-Eigenschaft verwendet werden. Durch diese<br />
Einstellung werden die fixierten Zeilen und Spalten entsprechend der aktuellen Auswahl hervorgehoben.<br />
Damit kann der Nutzer besser erkennen, in welcher Zeile und Spalte sich die aktuelle Auswahl befindet.<br />
Die GridColorFixed-Eigenschaft wird ignoriert, wenn GridLinesFixed auf einem 3D-Format steht.<br />
Hervorgehobene und eingelassene Gitterlinien werden immer mit den vom System festgelegten Farben<br />
für Schatten und Hervorhebungen gezeichnet.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Styles-Eigenschaft (Seite 170)<br />
GridLineWidth-Eigenschaft<br />
Ermittelt oder legt die Breite der Gitterlinien in Pixeln fest.
504 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Syntax<br />
[VB]<br />
Public GridLineWidth As Integer<br />
[C#]<br />
public int GridLineWidth {get; set;}<br />
[Delphi]<br />
property GridLineWidth: Integer;<br />
Bemerkungen<br />
Die GridLineWidth-Eigenschaft legt die Dicke der Gitternetzlinien in Pixeln fest, wenn die<br />
GridLineWidth- oder GridLinesFixed-Eigenschaft auf einem der flachen Formate (flexGridFlat,<br />
flexGridFlatHorz, flexGridFlatVert) steht. Herausgehobene und eingelassene Gitternetzlinien haben feste<br />
Breiten, die nicht verändert werden können.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Styles-Eigenschaft (Seite 170)<br />
KeyActionEnter-Eigenschaft (<strong>C1FlexGrid</strong>Classic)<br />
Legt die auszuführende Aktion fest, wenn der Nutzer die Enter-Taste drückt.<br />
Syntax<br />
[VB]<br />
Public KeyActionEnter As KeyActionEnum<br />
[C#]<br />
public KeyActionEnum KeyActionEnter {get; set;}<br />
[Delphi]<br />
property KeyActionEnter: KeyActionEnum;<br />
Eigenschaftswert<br />
Einer der KeyActionEnum-Werte. Der Standardwert ist KeyActionEnum.MoveDown.<br />
Mitgliedsname Beschreibung<br />
None<br />
Keine Handlung (das System verwaltet die Zelle). Zum Beispiel, die Tabulatortaste wird<br />
normalerweise für das Durchblättern der Steuerungen auf einem Formular verwendet.<br />
MoveDown Gehe zur nächsten Zeile, wenn die Taste gedrückt wird.<br />
MoveAcross<br />
MoveAcrossOut<br />
Gehe zur nächsten Spalte, wenn die Taste gedrückt wird. Nach der letzten Spalte,<br />
gehe zur nächsten Zeile und zurück zur ersten Spalte.<br />
Gehe zur nächsten Spalte, wenn die Taste gedrückt wird. Gehe nach der letzten Spalte<br />
zur nächsten Zeile und zurück zur ersten Spalte. Verschiebe nach der letzten Zeile und<br />
Spalte den Fokus zur nächsten Steuerung auf dem Formular,.
Bemerkungen<br />
KeyActionTab-Eigenschaft (<strong>C1FlexGrid</strong>Classic) · 505<br />
Standardmäßig verschiebt die Tabelle die Auswahl auf die nächste sichtbare Zeile, wenn der Nutzer die<br />
Enter-Taste drückt. Wenn die Tabelle bearbeitbar ist, dann wird diese durch die Enter-Taste in den<br />
Bearbeitungsmodus versetzt und, während sie in diesem Modus verweilt, verschiebt die Enter-Taste den<br />
Cursor nach unten.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
KeyActionTab-Eigenschaft (<strong>C1FlexGrid</strong>Classic)<br />
Legt die auszuführende Aktion fest, wenn der Nutzer die Tabulator-Taste drückt.<br />
Syntax<br />
[VB]<br />
Public KeyActionTab As KeyActionEnum<br />
[C#]<br />
public KeyActionEnum KeyActionTab {get; set;}<br />
[Delphi]<br />
property KeyActionTab: KeyActionEnum;<br />
Eigenschaftswert<br />
Einer der KeyActionEnum-Werte. Der Standardwert ist KeyActionEnum.None.<br />
Mitgliedsname Beschreibung<br />
None<br />
Keine Handlung (das System verwaltet die Zelle). Zum Beispiel, die Tabulatortaste<br />
wird normalerweise für das Durchblättern der Steuerungen auf einem Formular<br />
verwendet.<br />
MoveDown Gehe zur nächsten Zeile, wenn die Taste gedrückt wird.<br />
MoveAcross<br />
MoveAcrossOut<br />
Bemerkungen<br />
Gehe zur nächsten Spalte, wenn die Taste gedrückt wird. Gehe nach der letzten<br />
Spalte zur nächsten Zeile und zurück zur ersten Spalte.<br />
Gehe zur nächsten Spalte, wenn die Taste gedrückt wird. Gehe nach der letzten<br />
Spalte zur nächsten Zeile und zurück zur ersten Spalte. Verschiebe nach der letzten<br />
Zeile und Spalte den Fokus zur nächsten Steuerung auf dem Formular.<br />
Standardmäßig wird die Tabelle die Tabulator-Taste ignorieren. Sie wird durch das Formular<br />
abgewickelt und verschiebt den Fokus auf die nächste Steuerung. Wenn Sie die KeyActionTab-<br />
Eigenschaft auf einen von KeyActionEnum.None verschiedenen Wert setzen, dann wird die Tabelle die<br />
Tabulator-Taste abfangen und diese für die Navigation durch die Zellen verwenden.<br />
Beispiel<br />
Der nachfolgende Quellcode ändert den Wert der KeyActionTab-Eigenschaft basierend auf der aktuellen<br />
Zelle. Der Nutzer kann die Tabulator-Taste drücken, um durch die Zellen zu navigieren bis er am Ende
506 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
der Tabelle angelangt ist. Wenn er diese erneut drückt, dann wird der Fokus auf die nächste Steuerung<br />
verschoben.<br />
• Visual Basic<br />
• C#<br />
Private Sub flex_Enter(sender As Object, e As System.EventArgs)<br />
flex.Select(flex.Rows.Fixed, flex.Cols.Fixed)<br />
End Sub 'flex_Enter<br />
Private Sub flex_RowColChange(sender As Object, e As System.EventArgs)<br />
Dim lastCell As Boolean<br />
lastCell = flex.Col = flex.Cols.Count - 1 And _<br />
flex.Row = flex.Rows.Count - 1<br />
If lastCell Then<br />
flex.KeyActionTab = KeyActionEnum.None<br />
Else<br />
flex.KeyActionTab = KeyActionEnum.MoveAcross<br />
End If<br />
End Sub 'flex_RowColChange<br />
private void flex_Enter(object sender, System.EventArgs e)<br />
{<br />
flex.Select(flex.Rows.Fixed, flex.Cols.Fixed);<br />
}<br />
private void flex_RowColChange(object sender, System.EventArgs e)<br />
{<br />
bool lastCell = (flex.Col == flex.Cols.Count-1 &&<br />
flex.Row == flex.Rows.Count-1);<br />
flex.KeyActionTab = (lastCell)<br />
? KeyActionEnum.None<br />
: KeyActionEnum.MoveAcross;<br />
}<br />
• Delphi<br />
procedure Class1.flex_Enter(sender: System.Object; e:<br />
System.EventArgs);<br />
begin<br />
flex.Select(flex.Rows.Fixed, flex.Cols.Fixed);<br />
end;<br />
procedure flex_RowColChange(sender: System.Object; e:<br />
System.EventArgs);<br />
var<br />
lastCell: Boolean;<br />
begin<br />
lastCell := (flex.Col = flex.Cols.Count – 1_ And<br />
(flex.Row = flex.Rows.Count – 1);<br />
if lastCell then<br />
flex.KeyActionTab := KeyActionEnum.None<br />
Else<br />
flex.KeyActionTab := KeyActionEnum.MoveAcross;<br />
end; // flex_RowColChange<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)
MergeCells-Eigenschaft<br />
Ermittelt oder legt fest, ob Zellen mit gleichem Inhalt zu einer Zelle verbunden werden.<br />
Syntax<br />
[VB]<br />
Public MergeCells As MergeSettings<br />
[C#]<br />
public MergeSettings MergeCells {get; set;}<br />
[Delphi]<br />
property MergeCells: MergeSettings;<br />
Bemerkungen<br />
Gültige Einstellungen für die MergeCells-Eigenschaft:<br />
Mitgliedsname Beschreibung<br />
flexMergeNever Zellen nicht verbinden.<br />
flexMergeFree<br />
MergeCells-Eigenschaft · 507<br />
Angrenzende Zellen mit gleichem Inhalt verbinden, wenn diese sich in<br />
Zeilen mit RowMerge=TRUE oder Spalten mit MergeCol=TRUE befinden.<br />
flexMergeRestrictRows Zeilen verbinden, wenn die Zellen darüber auch verbunden sind.<br />
flexMergeRestrictColumns Spalten verbinden, wenn die Zellen links davon auch verbunden sind.<br />
flexMergeRestrictAll<br />
flexMergeFixedOnly<br />
Zellen verbinden, wenn die Zellen darüber und links davon auch<br />
verbunden sind.<br />
Nur fixierte Zellen verbinden. Diese Einstellung ist für komplexe<br />
Überschriften sinnvoll, ohne dabei die Datenzellen selbst zu verbinden.<br />
flexMergeSpill Langen Einträgen erlauben, in leere, angrenzende Zellen überzugehen.<br />
flexMergeOutline<br />
Einträgen in Zwischensummenzeilen erlauben, in leere, angrenzende<br />
Zellen überzugehen. Diese Einstellung ist sinnvoll, wenn Sie nur<br />
Knotennamen in den Gliederungsknoten anzeigen wollen und die Daten<br />
in regulären Zeilen stehen.<br />
Die MergeCells-Eigenschaft wird zusammen mit der set_MergeRow und set_MergeCol-Methode<br />
verwendet und steuert, ob und wie angezeigte Zellen verbunden werden. Verbunde Zellen dienen dazu,<br />
Daten auf eine klare und ansprechende Weise anzuzeigen, indem Gruppen mit gleichen Informationen<br />
hervorgehoben werden. Somit sind Sie felxibel und können ähnliche Tabellen wie die, die Sie in HTML<br />
oder mit Microsoft Word (beide unterstützen verbundene Zellen) verwenden, erstellen.<br />
Um Tabellen mit verbundenen Zellen zu erstellen, müssen Sie die MergeCells-Eigenschaft auf einen von<br />
flexMergeNever verschiedenen Wert, und die set_MergeRow- und set_MergeCol-Methoden für die<br />
jeweiligen Zeilen und Spalten, die Sie verbinden wollen, auf TRUE setzen (außer wenn Sie den<br />
flexMergeSpill-Modus verwenden). Nachdem diese Eigenschaften gesetzt wurden, wird die<br />
Tabellensteuerung automatisch angrenzende Zellen mit gleichen Inhalten verbinden. Immer wenn sich<br />
die Tabelleninhalte verändern, aktualisiert die Tabelle die Verbindungen.
508 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Die flexMergeSpill-Einstellung unterschiedet sich ein wenig von den anderen, indem Sie für diese die<br />
Methoden set_MergeRow und set_MergeCol nicht setzen müssen und Zellen mit gleichen Einstellungen<br />
nicht verbunden werden. Stattdessen gehen lange Einträge in angrenzende Zellen über, solange diese leer<br />
sind. Dies ist oft für Gliederungen nützlich, bei denen eine schmale Spalte für die Gruppenüberschriften<br />
verwendet werden soll, sodass diese in die rechts angrenzenden Zellen übergeht. Die nachfolgende<br />
Grafik zeigt ein Beispiel, in dem die flexMergeSpill-Einstellung verwendet wurde. Beachten Sie wie einige<br />
lange Texte in angrenzende Zellen übergehen, wenn diese leer sind, und andere abgeschnitten werden,<br />
weil die angrenzende Zelle nicht leer ist:<br />
Die flexMergeOutline-Einstellung ist ähnlich der flexMergeSpill, bis auf die Tatsache, dass Zellen in<br />
Zwischensummenzeilen mit angrenzenden leeren Zellen verbunden werden. Dies ist nützlich, wenn Sie<br />
nur einen Knotennamen in den Zwischensummenzeilen (Knoten) und Daten in regulären Zeilen<br />
anzeigen wollen.<br />
Der Unterschied zwischen den Free und Restricted-Einstellungen besteht darin, dass entweder Zellen mit<br />
gleichem Inhalt immer verbunden werden (Free-Einstellung) oder nur dann, wenn die links oder oben<br />
angrenzenden Zellen auch verbunden sind. Die nachstehenden Beispiele zeigen den Unterschied.<br />
• Visual Basic<br />
• C#<br />
' regular spreadsheet view<br />
fg.MergeCells = MergeSettings.flexMergeNever<br />
fg.set_MergeCol(0, True)<br />
fg.set_MergeCol(1, True)<br />
fg.set_MergeCol(2, True)<br />
fg.set_MergeCol(3, False)<br />
// regular spreadsheet view<br />
fg.MergeCells = MergeSettings.flexMergeNever;<br />
fg.set_MergeCol(0, true);<br />
fg.set_MergeCol(1, true);<br />
fg.set_MergeCol(2, true);<br />
fg.set_MergeCol(3, false);<br />
• Delphi<br />
begin<br />
fg.MergeCells := MergeSettings.flexMergeNever;<br />
fg.set_MergeCol(0, True);<br />
fg.set_MergeCol(1, True);<br />
fg.set_MergeCol(2, True);<br />
fg.set_MergeCol(3, False);<br />
end;
• Visual Basic<br />
• C#<br />
MergeCells-Eigenschaft · 509<br />
' free merging: notice how the first region cell (East) merges<br />
' across employees (Donna and John) to its left.<br />
fg.MergeCells = MergeSettings.flexMergeFree<br />
fg.set_MergeCol(0, True)<br />
fg.set_MergeCol(1, True)<br />
fg.set_MergeCol(2, True)<br />
fg.set_MergeCol(3, False)<br />
// free merging: notice how the first region cell (East) merges<br />
// across employees (Donna and John) to its left.<br />
fg.MergeCells = MergeSettings.flexMergeFree;<br />
fg.set_MergeCol(0, true);<br />
fg.set_MergeCol(1, true);<br />
fg.set_MergeCol(2, true);<br />
fg.set_MergeCol(3, false);<br />
• Delphi<br />
begin<br />
// free merging: notice how the first region cell (East) merges<br />
// across employees (Donna and John) to its left.<br />
fg.MergeCells := MergeSettings.flexMergeFree;<br />
fg.set_MergeCol(0, True);<br />
fg.set_MergeCol(1, True);<br />
fg.set_MergeCol(2, True);<br />
fg.set_MergeCol(3, False);<br />
end;<br />
• Visual Basic<br />
' restricted merging: notice how the first region cell (East)<br />
' no longer merges across employees to its left.
<strong>51</strong>0 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
• C#<br />
fg.MergeCells = MergeSettings.flexMergeRestrictAll<br />
fg.set_MergeCol(0, True)<br />
fg.set_MergeCol(1, True)<br />
fg.set_MergeCol(2, True)<br />
fg.set_MergeCol(3, False)<br />
// restricted merging: notice how the first region cell (East)<br />
// no longer merges across employees to its left.<br />
fg.MergeCells = MergeSettings.flexMergeRestrictAll;<br />
fg.set_MergeCol(0, true);<br />
fg.set_MergeCol(1, true);<br />
fg.set_MergeCol(2, true);<br />
fg.set_MergeCol(3, false);<br />
• Delphi<br />
begin<br />
// restricted merging: notice how the first region cell (East)<br />
// no longer merges across employees to its left.<br />
fg.MergeCells := MergeSettings.flexMergeRestrictAll;<br />
fg.set_MergeCol(0, True);<br />
fg.set_MergeCol(1, True);<br />
fg.set_MergeCol(2, True);<br />
fg.set_MergeCol(3, False);<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
NodeClosedPicture-Eigenschaft<br />
Ermittelt oder legt das Bild für einen geschlossenen Gliederungsknoten fest.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft NodeClosedPicture As System.Drawing.Image<br />
[C#]<br />
public System.Drawing.Image NodeClosedPicture {get; set;}
[Delphi]<br />
property NodeClosedPicture: System.Drawing.Image;<br />
Bemerkungen<br />
NodeOpenPicture-Eigenschaft · <strong>51</strong>1<br />
Wenn keine benutzerdefinierte Grafik bereitgestellt wird, dann wird ein geschlossener Knoten mit einem<br />
Plus-Zeichen in einem Rechteck angezeigt.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
NodeOpenPicture-Eigenschaft<br />
Ermittelt oder legt das Bild für einen offenen Gliederungsknoten fest.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft NodeOpenPicture As System.Drawing.Image<br />
[C#]<br />
public System.Drawing.Image NodeOpenPicture {get; set;}<br />
[Delphi]<br />
property NodeOpenPicture: System.Drawing.Image;<br />
Bemerkungen<br />
Wenn keine benutzerdefinierte Grafik bereitgestellt wird, dann wird ein offener Knoten mit einem<br />
Minus-Zeichen in einem Rechteck angezeigt.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
OutlineBar-Eigenschaft<br />
Ermittelt oder legt den Typ der anzuzeigenden Gliederungsleiste fest.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft OutlineBar As C1.Win.<strong>C1FlexGrid</strong>.Classic.OutlineBarSettings<br />
[C#]<br />
public OutlineBarSettings OutlineBar {get; set;}<br />
[Delphi]<br />
property OutlineBar: OutlineBarSettings;<br />
Bemerkungen<br />
Gültige Einstellungen für die OutlineBar-Eigenschaft:
<strong>51</strong>2 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Mitgliedsname Beschreibung<br />
flexOutlineBarComplete<br />
flexOutlineBarCompleteLeaf<br />
Der vollständige Gliederungsbaum und eine Schaltflächenzeile darüber<br />
wird angezeigt. Schaltflächen werden nur angezeigt, wenn die<br />
Gliederungsleiste in einer fixierten Spalte steht.<br />
Ähnlich der flexOutlineBarComplete, aber leere Knoten werden ohne<br />
Symbol angezeigt.<br />
flexOutlineBarNone Die Gliederungsleiste wird nicht angezeigt<br />
flexOutlineBarSimple<br />
flexOutlineBarSimpleLeaf<br />
Der vollständige Gliederungsbaum wird angezeigt, aber keine<br />
Schaltflächenzeile.<br />
Ähnlich der flexOutlineBarSimple, aber leere Knoten werden ohne<br />
Symbol angezeigt.<br />
flexOutlineBarSymbols Gliederungssymbole, aber keine Verknüpfungslinien werden angezeigt.<br />
flexOutlineBarSymbolsLeaf<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
OutlineCol-Eigenschaft<br />
Ähnlich der flexOutlineBarSymbols, aber leere Knoten werden ohne<br />
Symbol angezeigt.<br />
Ermittelt oder legt die für den Gliederungsbaum zu verwendende Spalte fest.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft OutlineCol As Integer<br />
[C#]<br />
public int OutlineCol {get; set;}<br />
[Delphi]<br />
property OutlineCol: Integer;<br />
Bemerkungen<br />
Die OutlineCol-Eigenschaft steuert zusammen mit der OutlineBar-Eigenschaft das Format und das<br />
Verhalten des Gliederungsbaums.<br />
Standardmäßig steht die OutlineCol-Eigenschaft auf Null, so dass die Gliederungsleiste, wenn<br />
vorhanden, in der ersten Spalte der Steuerung angezeigt wird. Sie können OutlineCol verwenden, um<br />
den Gliederungsbaum in unterschiedlichen Spalten anzuzeigen. Wenn Sie den Gliederungsbaum auf eine<br />
Spalte mit Daten setzen, dann werden die Einträge der Spalte so eingerückt, dass die Zellen den<br />
Gliederungsbaum anzeigen können.<br />
Nachdem Sie diese Eigenschaft eingestellt haben, sollten Sie die AutoSize-Methode anwenden, damit<br />
sichergestellt ist, dass der Baum und die Daten in der OutlineCol-Spalte vollständig sichtbar sind.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)
Picture-Eigenschaft<br />
Gibt ein Abbild der gesamten Steuerung zurück.<br />
Syntax<br />
[VB]<br />
Public ReadOnly-Eigenschaft Picture As System.Drawing.Image<br />
[C#]<br />
public System.Drawing.Image Picture {get;}<br />
[Delphi]<br />
property Picture: System.Drawing.Image;<br />
Bemerkungen<br />
Picture-Eigenschaft · <strong>51</strong>3<br />
Diese Eigenschaft gibt eine Grafik (Metadatei) zurück, die die gesamte Steuerung, inklusive der Zeilen<br />
und Spalten zeigt, die auf dem Bildschirm nicht sichtbar sind. Wenn Sie zum Beispiel eine Steuerung mit<br />
1000 Zeilen haben, dann beinhaltet die Grafik diese auch.<br />
Diese Eigenschaft ruft zuerst die Basisklasse CreateImage-Methode auf. CreateImage besitzt Parameter,<br />
mit denen Sie den Bereich festlegen können, der für die Grafik verwendet werden soll.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
PicturesOver-Eigenschaft<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft PicturesOver As Boolean<br />
[C#]<br />
public bool PicturesOver {get; set;}<br />
[Delphi]<br />
property PicturesOver: Boolean;<br />
Bemerkungen<br />
Der Standardwert dieser Eigenschaft ist FALSE.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klassen<br />
Redraw-Eigenschaft (<strong>C1FlexGrid</strong>Classic)<br />
Legt fest, ob die Tabelle ihre Inhalte zeichnen soll.
<strong>51</strong>4 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft Redraw As C1.Win.<strong>C1FlexGrid</strong>.Classic.RedrawSettings<br />
[C#]<br />
public RedrawSettings Redraw {get; set;}<br />
[Delphi]<br />
property Redraw: RedrawSettings;<br />
Bemerkungen<br />
Gültige Einstellungen für die Redraw-Eigenschaft:<br />
Mitgliedsname Beschreibung<br />
flexRDBuffered<br />
flexRDDirect<br />
Die Tabelle zeichnet ihren Inhalt in einem off-screen Puffer, und transferiert das<br />
komplette Abbild auf den Bildschirm. Dieser Modus ist etwas langsamer als<br />
flexRDDirect, aber er verhindert das Flackern des Bildschirms.<br />
Die Tabelle zeichnet ihren Inhalt direkt auf den Bildschirm. Dies ist der schnellste<br />
Modus für das Zeichnen der Tabelleninhalte, dafür kann gelegentlich aber ein<br />
leichtes Flackern auftreten.<br />
flexRDNone Die Tabelle zeichnet sich nicht selbst neu.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
RowHeightMax-Eigenschaft<br />
Ermittelt oder legt die maximale Zeilenhöhe in Twips fest.<br />
Syntax<br />
[VB]<br />
Public RowHeightMax As Integer<br />
[C#]<br />
public int RowHeightMax {get; set;}<br />
[Delphi]<br />
property RowHeightMax: Integer;<br />
Bemerkungen<br />
Setzen Sie diese Eigenschaft auf einen von Null verschiedenen Wert, um die maximale Höhe von Zeilen<br />
festzulegen. Dies ist oft nützlich, wenn Sie die AutoSize-Methode verwenden und manche Zeilen<br />
dadurch zu hoch werden würden.<br />
Siehe auch ColWidthMin-, ColWidthMax- und RowHeightMin-Eigenschaften.
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
MaxSize-Eigenschaft (RowCollection) (Seite 307)<br />
RowHeightMin-Eigenschaft<br />
Ermittelt oder legt die minimale Zeilenhöhe in Twips fest.<br />
Syntax<br />
[VB]<br />
Public RowHeightMin As Integer<br />
[C#]<br />
public int RowHeightMin {get; set;}<br />
[Delphi]<br />
property RowHeightMin: Integer;<br />
Bemerkungen<br />
RowHeightMin-Eigenschaft · <strong>51</strong>5<br />
Setzen Sie diese Eigenschaft auf einen von Null verschiedenen Wert, um die Mindesthöhe von Zeilen<br />
festzulegen. Dies ist oft nützlich, wenn Sie die AutoSize-Methode verwenden und manche Zeilen<br />
dadurch zu flach werden würden, oder wenn Sie kleine Schriftgrößen verwenden, aber die Zeilen nicht<br />
flacher werden sollen.<br />
Siehe auch ColWidthMin-, ColWidthMax- und RowHeightMax-Eigenschaften.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
MinSize-Eigenschaft (RowCollection) (Seite 308)<br />
Rows-Eigenschaft (<strong>C1FlexGrid</strong>Classic)<br />
Gibt alle Zeilen einer Tabelle zurück.<br />
Syntax<br />
[VB]<br />
Public Rows As RowCollection<br />
[C#]<br />
public RowCollection Rows {get;}<br />
[Delphi]<br />
property Rows: RowCollection;<br />
Bemerkungen<br />
Mit der Rows-Eigenschaft können Sie eine Liste mit allen derzeit vorhandenen Zeilen in einer Tabelle<br />
abfragen. Mit dieser Referenz können Sie Zeilen hinzufügen, entfernen, verschieben und zählen. Für
<strong>51</strong>6 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
weitere Informationen über die Funktionen dieser Sammlung, schauen Sie in den Referenzthemen der<br />
RowCollection-Klasse nach.<br />
Diese Eigenschaft kann nur gelesen werden. Die Tabelle erstellt und verwaltet diese Liste/Sammlung.<br />
Upgradenotiz: In der VSFlexGrid-ActiveX-Steuerung zeigen die Rows- und FixedRows-Eigenschaften<br />
die Anzahl der Zeilen und der fixierten Zeilen in einer Tabelle. Verwenden Sie in <strong>C1FlexGrid</strong><br />
Rows.Count und Rows.Fixed hierfür.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
SelectedRows-Eigenschaft<br />
Gibt die Anzahl der ausgewählten Zeilen zurück, wenn der SelectionMode auf flexSelectionListBox steht.<br />
Syntax<br />
[VB]<br />
Public SelectedRows As Integer<br />
[C#]<br />
public int SelectedRows {get; set;}<br />
[Delphi]<br />
property SelectedRows: Integer;<br />
Bemerkungen<br />
Diese Eigenschaft ist besonders nützlich, wenn die SelectionMode-Eigenschaft auf flexSelectionListBox (3)<br />
steht, so dass der Nutzer mehrere nichtangrenzende Zeilen auswählen kann.<br />
Der nachfolgende Quellcode gibt die Anzahl der ausgewählten Zeilen im Debugfenster aus, wenn sich<br />
die Auswahl ändert:<br />
• Visual Basic<br />
• C#<br />
Private Sub Form1_Load(ByVal sender As System.Object,<br />
ByVal e As System.EventArgs)<br />
fg.SelectionMode = SelModeSettings.flexSelectionListBox<br />
End Sub<br />
Private Sub fg_SelChange(ByVal sender As Object, ByVal e As<br />
System.EventArgs)<br />
Debug.WriteLine (fg.SelectedRows)<br />
End Sub<br />
private void Form1_Load( System.object sender, System.EventArgs e) {<br />
fg.SelectionMode = SelModeSettings.flexSelectionListBox;<br />
}<br />
private void fg_SelChange( object sender, System.EventArgs e) {<br />
Debug.WriteLine (fg.SelectedRows);<br />
}
• Delphi<br />
SelectionMode-Eigenschaft (<strong>C1FlexGrid</strong>Classic) · <strong>51</strong>7<br />
procedure Form1_Load(sender: System.Object;<br />
e: System.EventArgs);<br />
begin<br />
fg.SelectionMode := SelModeSettings.flexSelectionListBox;<br />
end;<br />
procedure fg_SelChange(sender: System.Object; e: System.EventArgs);<br />
begin<br />
Debug.WriteLine(fg.SelectedRows);<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Selection-Eigenschaft (Seite 166)<br />
SelectionMode-Eigenschaft (<strong>C1FlexGrid</strong>Classic)<br />
Legt das Auswahlverhalten der Tabelle fest.<br />
Syntax<br />
[VB]<br />
Public SelectionMode As SelModeSettings<br />
[C#]<br />
public SelModeSettings SelectionMode {get; set;}<br />
[Delphi]<br />
property SelectionMode: SelModeSettings;<br />
Bemerkungen<br />
Gültige Einstellungen für die SelectionMode-Eigenschaft:<br />
Mitgliedsname Beschreibung<br />
flexSelectionByColumn<br />
flexSelectionByRow<br />
Zwingt die Auswahl, sich auf die gesamte Spalte auszuweiten. Dies ist für<br />
Diagrammbereiche oder zu sortierende Felder nützlich.<br />
Zwingt die Auswahl, sich auf die gesamte Zeile auszuweiten. Dies ist für die<br />
Implementierung von datensatzbasierender Anzeige nützlich.<br />
flexSelectionFree Auswahlen können wie üblich getroffen werden.<br />
flexSelectionListBox<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Ähnlich wie flexSelectionByRow, aber es können auch unterbrochene<br />
Auswahlen getroffen werden. Strg-Taste halten und mit der Maus klicken<br />
schaltet die Auswahl für eine einzelne Zeile um. Die Maus über eine Gruppe<br />
von Zeilen zu ziehen schaltet deren Auswahlzustand um.
<strong>51</strong>8 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
SheetBorder-Eigenschaft<br />
Ermittelt oder legt die Farbe des Rahmens um das Arbeitsblatt fest.<br />
Syntax<br />
[VB]<br />
Public SheetBorder As Color<br />
[C#]<br />
public Color SheetBorder {get; set;}<br />
[Delphi]<br />
property SheetBorder: Color;<br />
Bemerkungen<br />
Diese Eigenschaft ist nützlich, wenn Sie die Tabelle wie eine Seite ohne Rahmen um die Zellen anzeigen<br />
wollen. Setzen Sie hierfür die SheetBorder-Eigenschaft auf die Tabellenhintergrundfarbe (BackColor-<br />
Eigenschaft).<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Styles-Eigenschaft (Seite 170)<br />
Sort-Eigenschaft (<strong>C1FlexGrid</strong>Classic)<br />
Legt die Sortierungsrichtung fest.<br />
Syntax<br />
[VB]<br />
Public Sort As SortSettings<br />
[C#]<br />
public SortSettings Sort {get; set;}<br />
[Delphi]<br />
property Sort: SortSettings;<br />
Bemerkungen<br />
Gültige Einstellungen für die Sort-Eigenschaft:<br />
Mitgliedsname Beschreibung<br />
flexSortNone<br />
Ignoriert die Spalte, wenn sortiert wird. Diese Einstellung ist<br />
nützlich, wenn Sie diese der Cols-Eigenschaft einer Spalte<br />
zuordnen und dann Sort auf flexSortUseColSort stellen.<br />
flexSortGenericAscending Sortiert Zeichenketten und Zahlen aufsteigend.<br />
flexSortGenericDescending Sortiert Zeichenketten und Zahlen absteigend.
Mitgliedsname Beschreibung<br />
flexSortNumericAscending Sortiert Zahlen aufsteigend.<br />
flexSortNumericDescending Sortiert Zahlen absteigend.<br />
flexSortStringNoCaseAscending<br />
flexSortStringNoCaseDescending<br />
Styles-Eigenschaft (<strong>C1FlexGrid</strong>Classic) · <strong>51</strong>9<br />
Sortiert Zeichenketten ohne Rücksicht auf Groß- und<br />
Kleinschreibung aufsteigend.<br />
Sortiert Zeichenketten ohne Rücksicht auf Groß- und<br />
Kleinschreibung absteigend.<br />
flexSortStringAscending Sortiert Zeichenketten aufsteigend.<br />
flexSortStringDescending Sortiert Zeichenketten absteigend.<br />
flexSortCustom<br />
flexSortUseColSort<br />
Startet ein Compare-Ereignis und verwendet den Rückgabewert<br />
um eine Spalte zu sortieren.<br />
Mit dieser Einstellung können Sie verschiedene<br />
Sortierungsrichtungen für einzelne Spalten mit der ColSort-<br />
Eigenschaft einstellen.<br />
Mit der Sort-Eigenschaft können Sie einen Bereich oder Zeilen in auf- oder absteigender Richtung,<br />
basierend auf den Inhalten in einer oder mehrerer Spalten, sortieren. Die Sort-Eigenschaft berücksichtigt<br />
auch Gliederungsstrukturen, so dass sie nur Datenzeilen sortiert und Knoten nicht verändert.<br />
Der zu sortierende Zeilenbereich wird durch die Einstellungen in den Row- und RowSel-Eigenschaften<br />
festgelegt. Wenn Row und RowSel gleich sind, dann sortiert die Steuerung alle nicht fixierten Zeilen.<br />
Der zuverwendende Sortierungsschlüssel wird von den Col- und ColSel-Eigenschaften immer von links<br />
nach rechts festgelegt. Zum Beispiel, wenn Col = 3 und ColSel = 1, dann wird nach den Inhalten in Spalte<br />
eins, dann zwei und dann drei sortiert.<br />
Der von der FlexGrid-Steuerung verwendete Sortieralgorithmus ist „stable“: Das bedeutet, dass das<br />
Sortieren die relative Reihenfolge der Daten beibehält, wenn der Sortierschlüssel der gleiche ist. Zum<br />
Beispiel, wenn Sie zunächst ein Dateienliste nach Namen und anschließend nach Dateienerweiterung<br />
sortieren, dann werden die Dateinamen innerhalb der Dateienerweiterungsgruppe immer noch sortiert<br />
sein.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Styles-Eigenschaft (<strong>C1FlexGrid</strong>Classic)<br />
Gibt alle Formatvorlagen einer Tabelle zurück.<br />
Syntax<br />
[VB]<br />
Public Styles As CellStyleCollection<br />
[C#]<br />
public CellStyleCollection Styles {get;}
520 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
[Delphi]<br />
property Styles: CellStyleCollection;<br />
Bemerkungen<br />
Mit der Styles-Eigenschaft können Sie einen Verweis auf eine Liste aller derzeit in der Tabelle definierten<br />
Formate abfragen. Mit diesem Verweis können Sie Formatvorlagen hinzufügen, entfernen und zählen.<br />
Für weitere Informationen über die Aufgaben, die mit dieser Liste ausgeführt werden können, schauen<br />
Sie unter CellStyleCollection-Klassenreferenzthemen für Informationen über Zellformatierungen, unter<br />
CellStyle-Referenzthemen nach.<br />
Diese Eigenschaft kann nur gelesen werden. Die Tabelle erstellt und verwaltet die Liste für Sie.<br />
Upgradenotiz: Die VSFlexGrid ActiveX-Steuerung hatte viele Eigenschaften, welche die Anzeige der<br />
Tabelle beeinflusst haben (z.B. BackColor, BackColorAlternate, BackColorBkg, BackColorFixed,<br />
BackColorFrozen, BackColorSel, usw.). Die <strong>C1FlexGrid</strong>-Steuerung ersetzt all diese Eigenschaften mit<br />
einer CellStyleCollection der CellStyle-Objekte. Damit ist das Objektmodel einfacher, konsistenter und<br />
stärker. Sie können die bestehenden Formatvorlagen verändern oder Ihre eigenen definieren und diese<br />
den Zeilen, Spalten oder willkürlichen Zellbereichen zuordnen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
TabBehavior-Eigenschaft<br />
Ermittelt oder legt fest, ob die Tabulator-Taste den Fokus zwischen den Steuerungen (VB-Standard) oder<br />
zwischen Tabellenzellen verschiebt.<br />
Syntax<br />
[VB]<br />
Public TabBehavior As TabBehaviorSettings<br />
[C#]<br />
public TabBehaviorSettings TabBehavior {get; set;}<br />
[Delphi]<br />
property TabBehavior: TabBehaviorSettings;<br />
Bemerkungen<br />
Die möglichen Einstellungen der TabBehavior-Eigenschaft werden nachfolgend beschrieben:<br />
Mitgliedsname Beschreibung<br />
flexTabControls<br />
flexTabCells<br />
Die Tabulator-Taste wird verwendet, um zur nächsten oder<br />
vorhergehenden Steuerung im Formular zu gehen.<br />
Die Tabulator-Taste wird verwendet, um zur nächsten oder<br />
vorhergehenden Zelle auf der Steuerung zu gehen.<br />
Das nachfolgende Beispiel stellt die Tabulator-Taste so ein, dass zur nächsten Steuerung gegangen wird,<br />
wenn man sich in der letzten Zelle befindet:
• Visual Basic<br />
• C#<br />
Text-Eigenschaft · 521<br />
Private Sub fg_Focus(ByVal sender As Object, ByVal e As System.Event<br />
Args)<br />
fg.Select (fg.FixedRows, fg.FixedCols)<br />
End Sub<br />
Private Sub fg_EnterCell(ByVal sender As Object, ByVal e As<br />
System.EventArgs)<br />
If fg.Col = fg.Cols - 1 And fg.Row = fg.Rows - 1 Then<br />
fg.TabBehavior = TabBehaviorSettings.flexTabControls<br />
Else<br />
fg.TabBehavior = TabBehaviorSettings.flexTabCells<br />
End If<br />
End Sub<br />
private void fg_Focus( object sender, System.event e Args) {<br />
fg.Select (fg.FixedRows, fg.FixedCols);<br />
}<br />
private void fg_EnterCell( object sender, System.EventArgs e) {<br />
if ( fg.Col = fg.Cols - 1 && fg.Row = fg.Rows - 1 ) {<br />
fg.TabBehavior = TabBehaviorSettings.flexTabControls;<br />
} else {<br />
fg.TabBehavior = TabBehaviorSettings.flexTabCells;<br />
}<br />
}<br />
• Delphi<br />
procedure fg_Focus(sender: System.Object; e: System.Event Args);<br />
begin<br />
fg.Select(fg.FixedRows, fg.FixedCols);<br />
end;<br />
procedure fg_EnterCell(sender: System.Object; e: System.EventArgs);<br />
begin<br />
If (fg.Col = fg.Cols.Count – 1) And (fg.Row = fg.Rows.Count – 1) Then<br />
fg.TabBehavior := TabBehaviorSettings.flexTabControls<br />
Else<br />
fg.TabBehavior := TabBehaviorSettings.flexTabCells;<br />
end;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
KeyActionEnter-Eigenschaft (Seite 149)<br />
KeyActionTab-Eigenschaft (Seite 150)<br />
Text-Eigenschaft<br />
Ermittelt oder legt den Inhalt der ausgewählten Zelle oder des Bereichs fest.<br />
Syntax<br />
[VB]<br />
Public Text As String
522 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
[C#]<br />
public string Text {get; set;}<br />
[Delphi]<br />
property Text: string;<br />
Bemerkungen<br />
Die Text-Eigenschaft ruft den Inhalt der aktuellen Zelle ab, die durch die Row- und Col-Eigenschaften<br />
festgelegt ist. Wenn der Text-Eigenschaft eine Zeichenkette zugeordnet wird, dann wird diese entweder<br />
auf die aktuelle Zelle angewendet, oder über die aktuelle Auswahl kopiert, je nach Einstellung der<br />
FillStyle-Eigenschaft.<br />
Der nachfolgende Code setzt den Inhalt der Zelle in der vierten Spalte und vierten Zeile auf „Apple“:<br />
• Visual Basic<br />
• C#<br />
fg.Select 3, 3<br />
fg.Text = "Apple"<br />
fg.Select 3, 3;<br />
fg.Text = "Apple";<br />
• Delphi<br />
fg.Select(3, 3);<br />
fg.Text := 'Apple';<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
GetData-Methode (Seite 190)<br />
SetData-Methode (Seite 207)<br />
TextStyle-Eigenschaft<br />
Ermittelt oder legt den 3D-Effekt für den Text in nicht fixierten Zellen fest.<br />
Syntax<br />
[VB]<br />
Public TextStyle As TextStyleSettings<br />
[C#]<br />
public TextStyleSettings TextStyle {get; set;}<br />
[Delphi]<br />
property TextStyle: TextStyleSettings;<br />
Bemerkungen<br />
Gültige Einstellungen für die TextStyle-Eigenschaft:
Mitgliedsname Beschreibung<br />
flexTextFlat Zeichnet Text normal.<br />
flexTextRaised Zeichnet Text mit einem stark gehobenen 3D-Effekt.<br />
flexTextInset Zeichnet Text mit einem stark eingelassenen 3D-Effekt.<br />
flexTextRaisedLight Zeichnet Text mit einem schwach gehobenen 3D-Effekt.<br />
TextStyleFixed-Eigenschaft · 523<br />
flexTextInsetLight Zeichnet Text mit einem schwach eingelassenen 3D-Effekt.<br />
Die Konstanten flexTextRaised und flexTextInset passen gut zu großen und fetten Schriftarten und<br />
flexTextRaisedLight und flexTextInsetLight eher zu kleineren, normalen Schriftarten.<br />
Das nachfolgende Beispiel zeigt Text mit einem eingelassenen 3D-Effekt in nicht fixierten Zellen an:<br />
• Visual Basic<br />
• C#<br />
fg.TextStyle = TextStyleSettings.flexTextInset<br />
fg.TextStyle = TextStyleSettings.flexTextInset;<br />
• Delphi<br />
fg.TextStyle := TextStyleSettings.flexTextInset;<br />
Schauen Sie in der CellTextStyle-Eigenschaft für eine Aufzählungsliste nach.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Styles-Eigenschaft (Seite 170)<br />
TextStyleFixed-Eigenschaft<br />
Ermittelt oder legt den 3D-Effekt für den Text in fixierten Zellen fest.<br />
Syntax<br />
[VB]<br />
Public TextStyleFixed As TextStyleSettings<br />
[C#]<br />
public TextStyleSettings TextStyleFixed {get; set;}<br />
[Delphi]<br />
property TextStyleFixed: TextStyleSettings;<br />
Bemerkungen<br />
Gültige Einstellungen für die TextStyleFixed-Eigenschaft:<br />
Mitgliedsname Beschreibung<br />
flexTextFlat Zeichnet Text normal.
524 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Mitgliedsname Beschreibung<br />
flexTextRaised Zeichnet Text mit einem stark gehobenen 3D-Effekt.<br />
flexTextInset Zeichnet Text mit einem stark eingelassenen 3D-Effekt.<br />
flexTextRaisedLight Zeichnet Text mit einem schwach gehobenen 3D-Effekt.<br />
flexTextInsetLight Zeichnet Text mit einem schwach eingelassenen 3D-Effekt.<br />
Das nachfolgende Beispiel zeigt Text mit einem gehobenen 3D-Effekt in fixierten Zellen an:<br />
• Visual Basic<br />
• C#<br />
fg.TextStyleFixed = TextStyleSettings.flexTextRaised<br />
fg.TextStyleFixed = TextStyleSettings.flexTextRaised;<br />
• Delphi<br />
fg.TextStyleFixed := TextStyleSettings.flexTextRaised;<br />
Schauen Sie in der CellTextStyle-Eigenschaft für eine Aufzählungsliste nach.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Styles-Eigenschaft (Seite 170)<br />
TreeColor-Eigenschaft<br />
Ermittelt oder legt die Farbe für den Gliederungsbaum fest.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft TreeColor As System.Drawing.Color<br />
[C#]<br />
public System.Drawing.Color TreeColor {get; set;}<br />
[Delphi]<br />
property TreeColor: System.Drawing.Color;<br />
Bemerkungen<br />
Der Gliederungsbaum wird nur gezeichnet, wenn die OutlineBar-Eigenschaft auf einem von Null<br />
verschiedenen Wert steht und die Steuerung Zwischensummenzeilen enthält. Nutzer können die<br />
Gliederung erweitern und zusammenklappen.<br />
Schauen Sie unter der Outline-Methode für Einzelheiten über Gliederungen und ein Beispiel nach.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)
Value-Eigenschaft<br />
Gibt den numerischen Wert der aktuellen Zelle zurück.<br />
Syntax<br />
[VB]<br />
Public Value As Integer<br />
[C#]<br />
public int Value {get; set;}<br />
[Delphi]<br />
Eigenschaftswert: Integer;<br />
Bemerkungen<br />
Value-Eigenschaft · 525<br />
Diese Eigenschaft ist ähnlich der Visual Basic-Funktion Val, nur dass sie lokal angepasste<br />
Tausendertrennzeichen, Währungszeichen und eingeklammerte negative Werte erkennt. Zum Beispiel,<br />
wenn die aktuelle Zelle die Zeichenkette „$(1,234.56)“ enthält, dann gibt die Value-Eigenschaft den Wert<br />
-1234.56 zurück.<br />
Der nachfolgende Quellcode gibt den Wert der aktuellen Zelle im Debugfenster aus:<br />
• Visual Basic<br />
• C#<br />
Private Sub Button1_Click(ByVal sender As System.Object, _<br />
ByVal e As System.EventArgs) Handles Button1.Click<br />
Debug. WriteLine (fg.Value)<br />
End Sub<br />
private void Button1_Click( System.object sender, System.EventArgs e)<br />
Button1.Click {<br />
Debug. WriteLine (fg.value);<br />
}<br />
• Delphi<br />
procedure Button1_Click(sender: System.Object;<br />
e: System.EventArgs);<br />
begin<br />
Debug. WriteLine(fg.Value);<br />
end;<br />
Diese Eigenschaft ist kein Ausdrucksbewerter. Wenn zum Beispiel die aktuelle Zelle die Zeichenkette<br />
„2+2“ enthält, dann gibt die Value-Eigenschaft 2 anstatt 4 zurück. Die Visual Basic-Anweisung Val("2+2")<br />
gibt auch 2 zurück.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
GetData-Methode (Seite 190)<br />
SetData-Methode (Seite 207)
526 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
WallPaper-Eigenschaft<br />
Ermittelt oder legt eine Hintergrundgrafik für den scrollbaren Bereich der Tabelle fest.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft WallPaper As System.Drawing.Image<br />
[C#]<br />
public System.Drawing.Image WallPaper {get; set;}<br />
[Delphi]<br />
property WallPaper: System.Drawing.Image;<br />
Bemerkungen<br />
Diese Eigenschaft ist gleich der BackgroundImage-Eigenschaft, die aus der Control-Basisklasse erbt.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
WordWrap-Eigenschaft (<strong>C1FlexGrid</strong>Classic)<br />
Legt fest, ob lange Zeichenketten in der Zelle umgebrochen werden.<br />
Syntax<br />
[VB]<br />
Public-Eigenschaft WordWrap As Boolean<br />
[C#]<br />
public bool WordWrap {get; set;}<br />
[Delphi]<br />
property WordWrap: Boolean;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
<strong>C1FlexGrid</strong>Classic-Methoden<br />
AutoSize-Methode<br />
Passt die Breite von Spalten und die Höhe von Zeilen an den Zellinhalt an.<br />
Syntax<br />
[VB]<br />
Public Sub AutoSize(col As Integer)<br />
Public Sub AutoSize(col1 As Integer, col2 As Integer)
Public Sub AutoSize(col1 As Integer, col2 As Integer, equal As Boolean, extra As Integer)<br />
[C#]<br />
public void AutoSize ( int col )<br />
public void AutoSize ( int col1 , int col2 )<br />
public void AutoSize ( int col1 , int col2 , Boolean equal , int extra )<br />
[Delphi]<br />
procedure AutoSize(col: Integer);<br />
procedure AutoSize(col1: Integer; col2: Integer);<br />
procedure AutoSize(col1: Integer; col2: Integer; equal: Boolean; extra: Integer);<br />
Parameter Beschreibung<br />
Col1, Col2<br />
equal<br />
ExtraSpace<br />
Bemerkungen<br />
Clear-Methode · 527<br />
Der Index der ersten und letzten Spalte, so dass deren Breiten an den breitesten<br />
Eintrag für jede Spalte angepasst wird. Der gültige Bereich für diese Parameter liegt<br />
zwischen 0 und Cols-1. Col2 ist optional und wenn nicht gesetzt, dann wird nur die<br />
Breite von Col1 angepasst.<br />
Wenn TRUE, dann werden alle Spalten zwischen Col1 und Col2 auf die gleiche Breite<br />
gesetzt. Wenn FALSE, dann wird die Breite jeder Spalte einzeln gesetzt. Dieser<br />
Parameter ist optional und die Standardeinstellung ist FALSE.<br />
Mit diesem Parameter können Sie den zusätzlichen Platz in Twips festlegen, der zu der<br />
minimalen Breite der Spalte hinzugefügt werden soll. Dies ist oft nützlich, wenn Sie<br />
zusätzlichen Platz für Grafiken oder Ränder innerhalb von Zellen lassen wollen. Dieser<br />
Parameter ist optional und die Standardeinstellung ist Null.<br />
Die AutoSize-Methode kann auch für Zeilenhöhen verwendet werden. Dies ist nützlich, wenn Text in<br />
einer Zelle umgebrochen wird (Siehe WordWrap-Eigenschaft) oder wenn Zellen verschiedene<br />
Schriftgrößen haben (Siehe Cell-Eigenschaft).<br />
Die AutoSizeMode-Eigenschaft legt fest, ob AutoSize die Größe von Zeilen oder Spalten anpasst.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
AutoSizeCol-Methode (Seite 176)<br />
AutoSizeRow-Methode (Seite 178)<br />
Clear-Methode<br />
Löscht den Inhalt einer Steuerung. Optionale Parameter legen fest, was wo gelöscht werden soll.
5<strong>28</strong> · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Syntax<br />
[VB]<br />
Public Sub Clear()<br />
Public Sub Clear(where As ClearWhereSettings)<br />
Public Sub Clear(where As ClearWhereSettings, what As ClearWhatSettings)<br />
[C#]<br />
public void Clear ( )<br />
public void Clear (ClearWhereSettings where )<br />
public void Clear (ClearWhereSettings where , ClearWhatSettings what )<br />
[Delphi]<br />
procedure Clear;<br />
procedure Clear(where: ClearWhereSettings);<br />
procedure Clear(where: ClearWhereSettings; what: ClearWhatSettings);<br />
Parameter Beschreibung<br />
what ClearWhatSettings-Konstante beschreibt, was entfernt wird (siehe unten).<br />
where ClearWhereSettings-Konstante beschreibt, wo etwas entfernt wird (siehe unten).<br />
Bemerkungen<br />
Die möglichen Einstellungen der ClearWhatSettings-Konstanten werden nachfolgend beschrieben:<br />
Mitgliedsname Beschreibung<br />
flexClearEverything Alles wird aus dem Bereich entfernt.<br />
flexCleartext Nur Text wird aus dem Bereich entfernt.<br />
flexClearFormatting Nur Formatierung wird aus dem Bereich entfernt.<br />
flexClearData Nur Daten im Datenbereich werden aus dem Bereich entfernt.<br />
Die möglichen Einstellungen der ClearWhereSettings-Konstanten werden nachfolgend beschrieben:<br />
Mitgliedsname Beschreibung<br />
flexClearEverywhere Entfernt von gesamter Tabelle.<br />
flexClearScrollable Entfernt nur vom scrollbaren Bereich der Tabelle.<br />
flexClearSelection Entfernt vom ausgewählten Bereich.
ComboItem-Methode · 529<br />
Die Clear-Methode verändert nicht die Anzahl der Zeilen und Spalten in einer Tabelle und kann auch<br />
nicht für das Löschen von Daten in, an Datenquellen gebundene, Tabellen verwendet werden.<br />
Sie können mit der Cell-Eigenschaft Text oder benutzerdefinierte Formatierung in einem willkürlichen<br />
Bereich entfernen. Zum Beispiel, der nachfolgende Quellcode entfernt jeden Text und benutzerdefinierte<br />
Formatierung in einem Bereich:<br />
• Visual Basic<br />
• C#<br />
Dim r1&, c1&, r2&, c2&<br />
fg.set_Cell(CellPropertySettings.flexcpText, r1, C1, r2, c2, "")<br />
fg.set_Cell(CellPropertySettings.flexcpCustomFormat, r1, C1, r2, c2,<br />
False)<br />
r1&, c1&, r2&, c2&;<br />
fg.set_Cell(CellPropertySettings.flexcpText, r1, C1, r2, c2, "");<br />
fg.set_Cell(CellPropertySettings.flexcpCustomFormat, r1, C1, r2, c2,<br />
false);<br />
• Delphi<br />
var<br />
r1, c1, r2, c2: Integer;<br />
begin<br />
fg.set_Cell(CellPropertySettings.flexcpText, r1, C1, r2, c2, '');<br />
fg.set_Cell(CellPropertySettings.flexcpCustomFormat, r1, C1, r2, c2,<br />
False);<br />
end;<br />
Dieses Beispiel entfernt Text aus den ausgewählten Zellen, wobei Grafiken und Zelldaten bestehen<br />
bleiben:<br />
• Visual Basic<br />
• C#<br />
fg.Clear(ClearWhereSettings.flexClearSelection,<br />
ClearWhatSettings.flexClearText)<br />
fg.Clear(ClearWhereSettings.flexClearSelection,<br />
ClearWhatSettings.flexClearText);<br />
• Delphi<br />
fg.Clear(ClearWhereSettings.flexClearSelection,<br />
ClearWhatSettings.flexClearText);<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Clear-Methode (<strong>C1FlexGrid</strong>) (Seite 179)<br />
ComboItem-Methode<br />
Gibt die mit einem Element verknüpfte Zeichenkette aus der Auswahlliste des Editors zurück.<br />
Syntax<br />
[VB]<br />
Public Function ComboItem(ByVal index As Integer) As String
530 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
[C#]<br />
public String ComboItem (Integer Index)<br />
[Delphi]<br />
function ComboItem(index: Integer): String;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
EditCell-Methode<br />
Aktiviert den Bearbeitungsmodus.<br />
Syntax<br />
[VB]<br />
Public Sub EditCell()<br />
[C#]<br />
public void EditCell ( )<br />
[Delphi]<br />
procedure EditCell;<br />
Bemerkungen<br />
Wenn die Editable-Eigenschaft auf einem von Null verschiedenen Wert steht, dann geht die Steuerung<br />
automatisch in den Bearbeitungsmodus, wenn der Nutzer die F2-, die Leer- oder jede beliebige<br />
Zeichentaste drückt. Sie können die EditCell-Methode verwenden, um die Steuerung in den<br />
Bearbeitungsmodus zu zwingen.<br />
Beachten Sie, dass EditCell die Steuerung in den Bearbeitungsmodus zwingt, auch wenn die Editable-<br />
Eigenschaft auf FALSE steht. Sie können sogar die Bearbeitung von fixierten Zellen erlauben.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
FindRow-Methode (<strong>C1FlexGrid</strong>Classic)<br />
Sucht eine Zeile mit einer bestimmten Zeichenkette oder Objekt.<br />
Syntax<br />
[VB]<br />
Public Function FindRow(objFind As Object, rowStart As Integer, col As Integer, wrap As Boolean) As<br />
Integer<br />
Public Function FindRow(strFind As String, rowStart As Integer, col As Integer, caseSensitive As<br />
Boolean, fullMatch As Boolean, wrap As Boolean) As Integer
[C#]<br />
public Integer FindRow (Object objFind , int rowStart , int col , Boolean wrap )<br />
get_Cell-Methode · 531<br />
public Integer FindRow (String strFind , int rowStart , int col , Boolean caseSensitive , Boolean fullMatch ,<br />
Boolean wrap )<br />
[Delphi]<br />
function FindRow(objFind: Object; rowStart: Integer; col: Integer; wrap: Boolean): Integer;<br />
function FindRow(strFind: string; rowStart: Integer; col: Integer; caseSensitive: Boolean; fullMatch:<br />
Boolean; wrap: Boolean): Integer;<br />
Parameter Beschreibung<br />
strFind Zeichenkette, nach der gesucht wird.<br />
objFind Objekt, nach dem gesucht wird.<br />
rowStart Index der Zeile, in der die Suche beginnen soll.<br />
col Spalte, welche die gesuchten Daten enthält.<br />
caseSensitive Ob die Suche Groß- und Kleinschreibung berücksichtigt.<br />
fullMatch<br />
wrap<br />
Rückgabewert<br />
Ob die Suchwörter genau gefunden werden müssen. Wenn dieser Parameter auf<br />
FALSE steht, dann ergibt z.B. die Suche nach „John“ u.a. auch „Johnson".<br />
Ob die Suche am Ende der Tabelle anhalten, oder in der ersten, scrollbaren Zeile<br />
fortfahren soll.<br />
Den Index der Zeile mit den gesuchten Daten oder –1, wenn die Daten nicht gefunden wurden.<br />
Bemerkungen<br />
Verwenden Sie die AutoSearch-Eigenschaft, um nach Daten zu suchen, während der Nutzer noch tippt.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
get_Cell-Methode<br />
Ermittelt die cell-Eigenschaften für einen willkürlichen Bereich.<br />
Syntax<br />
[VB]<br />
Public Function get_Cell(ByVal setting As C1.Win.<strong>C1FlexGrid</strong>.Classic.CellPropertySettings, ByVal row<br />
As Integer, ByVal col As Integer) As Object<br />
Public Function get_Cell(ByVal setting As C1.Win.<strong>C1FlexGrid</strong>.Classic.CellPropertySettings, ByVal row1<br />
As Integer, ByVal col1 As Integer, ByVal row2 As Integer, ByVal col2 As Integer) As Object
532 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
[C#]<br />
public System.Object get_Cell ( C1.Win.<strong>C1FlexGrid</strong>.Classic.CellPropertySettings setting , System.Int32<br />
row , System.Int32 col )<br />
public System.Object get_Cell ( C1.Win.<strong>C1FlexGrid</strong>.Classic.CellPropertySettings setting , System.Int32<br />
row1 , System.Int32 col1 , System.Int32 row2 , System.Int32 col2 )<br />
[Delphi]<br />
function get_Cell(setting: C1.Win.<strong>C1FlexGrid</strong>.Classic.CellPropertySettings; row: Integer; col: Integer):<br />
Object;<br />
function get_Cell(setting: C1.Win.<strong>C1FlexGrid</strong>.Classic.CellPropertySettings; row1: Integer; col1: Integer;<br />
row2: Integer; col2: Integer): Object;<br />
Bemerkungen<br />
Mit der get_Cell-Methode können Sie die cell-Eigenschaften von einzelnen Zellen oder Zellbereichen<br />
direkt auslesen oder festlegen, ohne diese auszuwählen.<br />
Die Parameter für die get_Cell-Methode werden nachfolgend beschrieben:<br />
Setting As CellPropertySettings<br />
Dieser Parameter legt fest, welche Eigenschaft gelesen oder gesetzt wird. Die verfügbaren Einstellungen<br />
sind nachfolgend aufgelistet.<br />
Row1, Col1, Row2, and Col2 As Integer (optional)<br />
Wenn die cell-Eigenschaften gelesen werden, dann wird nur die Zelle (Row1, Col1) verwendet. Wenn sie<br />
gesetzt werden, dann ist der gesamte Bereich betroffen. Der Standardwert für Row1 und Col1 ist die<br />
aktuelle Zeile und die aktuelle Spalte. Wenn diese nicht zur Verfügung gestellt werden, dann wird die<br />
aktuelle Zelle verwendet. Der Standardwert für Row2 und Col2 ist Row1 und Col1. Wenn diese nicht zur<br />
Verfügung gestellt werden, dann wird eine einzelne Zelle verwendet.<br />
Die Gültigen Einstellungen für den setting-Parameter sind:<br />
Mitgliedsname Beschreibung<br />
flexChecked Die Zelle hat ein Kontrollkästchen mit einem Häkchen drin.<br />
flexNoCheckbox Die Zelle hat kein Kontrollkästchen.<br />
flexTSChecked Die Zelle hat ein drei-Zustands-Kontrollkästchen mit einem Häkchen drin.<br />
flexTSGrayed Die Zelle hat ein drei-Zustands-Kontrollkästchen im grauen Zustand.<br />
flexTSUnchecked Die Zelle hat ein leeres drei-Zustands-Kontrollkästchen.<br />
flexUnchecked Die Zelle hat ein leeres Kontrollkästchen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
get_ColAlignment-Methode<br />
Ermittelt die Ausrichtung einer gegebenen Spalte.
Syntax<br />
[VB]<br />
Public Function get_ColAlignment(ByVal col As Integer) As<br />
C1.Win.<strong>C1FlexGrid</strong>.Classic.AlignmentSettings<br />
[C#]<br />
get_ColComboList-Methode · 533<br />
public C1.Win.<strong>C1FlexGrid</strong>.Classic.AlignmentSettings get_ColAlignment ( System.Int32 col )<br />
[Delphi]<br />
function get_ColAlignment(col: Integer): C1.Win.<strong>C1FlexGrid</strong>.Classic.AlignmentSettings;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
get_ColComboList-Methode<br />
Ermittelt die für ein Auswahlfeld zu verwendende Liste von einer bestimmten Spalte.<br />
Syntax<br />
[VB]<br />
Public Function get_ColComboList(ByVal col As Integer) As String<br />
[C#]<br />
public System.String get_ColComboList ( System.Int32 col )<br />
[Delphi]<br />
function get_ColComboList(col: Integer): String;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
get_ColData-Methode<br />
Ermittelt ein benutzerdefiniertes, mit einer Spalte verknüpftes Variant.<br />
Syntax<br />
[VB]<br />
Public Function get_ColData(ByVal col As Integer) As Object<br />
[C#]<br />
public System.Object get_ColData ( System.Int32 col )<br />
[Delphi]<br />
function get_ColData(col: Integer): Object;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)
534 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
get_ColDataType-Methode<br />
Ermittelt den Datentyp einer Spalte.<br />
Syntax<br />
[VB]<br />
Public Function get_ColDataType(ByVal col As Integer) As System.Type<br />
[C#]<br />
public System.Type get_ColDataType ( System.Int32 col )<br />
[Delphi]<br />
function get_ColDataType(col: Integer): System.Type<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
get_ColEditMask-Methode<br />
Ermittelt die Eingabemaske, die für die Bearbeitung der Zellen in einer bestimmten Spalte verwendet<br />
wird.<br />
Syntax<br />
[VB]<br />
Public Function get_ColEditMask(ByVal col As Integer) As String<br />
[C#]<br />
public System.String get_ColEditMask ( System.Int32 col )<br />
[Delphi]<br />
function get_ColEditMask(col: Integer): String;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
get_ColFormat-Methode<br />
Ermittelt das für numerische Werte verwendete Format.<br />
Syntax<br />
[VB]<br />
Public Function get_ColFormat(ByVal col As Integer) As String<br />
[C#]<br />
public System.String get_ColFormat ( System.Int32 col )<br />
[Delphi]<br />
function get_ColFormat(col: Integer): String;
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
get_ColHidden-Methode<br />
Ermittelt, ob eine Spalte ausgeblendet ist.<br />
Syntax<br />
[VB]<br />
Public Function get_ColHidden(ByVal col As Integer) As Boolean<br />
[C#]<br />
public System.Boolean get_ColHidden ( System.Int32 col )<br />
[Delphi]<br />
function get_ColHidden(col: Integer): Boolean;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
get_ColIndent-Methode<br />
Ermittelt den Einzug einer gegebenen Spalte in Twips.<br />
Syntax<br />
[VB]<br />
Public Function get_ColIndent(ByVal col As Integer) As Integer<br />
[C#]<br />
public System.Int32 get_ColIndent ( System.Int32 col )<br />
[Delphi]<br />
function get_ColIndent(col: Integer): Integer;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
get_ColIndex-Methode<br />
Ermittelt den Spaltenindex, der zu einer gegebenen Taste passt.<br />
Syntax<br />
[VB]<br />
Public Function get_ColIndex(ByVal colKey As String) As Integer<br />
[C#]<br />
public System.Int32 get_ColIndex ( System.String colKey )<br />
get_ColHidden-Methode · 535
536 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
[Delphi]<br />
Function get_ColIndex(colKey: String): Integer;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
get_ColIsVisible-Methode<br />
Ermittelt, ob eine gegebene Spalte derzeit auf dem Bildschirm ist.<br />
Syntax<br />
[VB]<br />
Public Function get_ColIsVisible(ByVal col As Integer) As Boolean<br />
[C#]<br />
public System.Boolean get_ColIsVisible ( System.Int32 col )<br />
[Delphi]<br />
function get_ColIsVisible(col: Integer): Boolean;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
get_ColKey-Methode<br />
Ermittelt eine Taste, mit der eine gegebene Spalte identifiziert wird.<br />
Syntax<br />
[VB]<br />
Public Function get_ColKey(ByVal col As Integer) As String<br />
[C#]<br />
public System.String get_ColKey ( System.Int32 col )<br />
[Delphi]<br />
function get_ColKey(col: Integer): String;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
get_ColPos-Methode<br />
Ermittelt die linke (x) Koordinate einer Spalte relativ zur Kante der Steuerung in Twips.<br />
Syntax<br />
[VB]<br />
Public Function get_ColPos(ByVal col As Integer) As Integer
[C#]<br />
public System.Int32 get_ColPos ( System.Int32 col )<br />
[Delphi]<br />
function get_ColPos(col: Integer): Integer;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
get_ColSort-Methode<br />
Ermittelt die Sortierungsrichtung für jede Spalte (zur Verwendung mit der Sort-Eigenschaft).<br />
Syntax<br />
[VB]<br />
get_ColSort-Methode · 537<br />
Public Function get_ColSort(ByVal col As Integer) As C1.Win.<strong>C1FlexGrid</strong>.Classic.SortSettings<br />
[C#]<br />
public C1.Win.<strong>C1FlexGrid</strong>.Classic.SortSettings get_ColSort ( System.Int32 col )<br />
[Delphi]<br />
function get_ColSort(col: Integer): C1.Win.<strong>C1FlexGrid</strong>.Classic.SortSettings;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
get_ColWidth-Methode<br />
Ermittelt die Breite einer bestimmten Spalte in Twips.<br />
Syntax<br />
[VB]<br />
Public Function get_ColWidth(ByVal col As Integer) As Integer<br />
[C#]<br />
public System.Int32 get_ColWidth ( System.Int32 col )<br />
[Delphi]<br />
function get_ColWidth(col: Integer): Integer;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
get_FixedAlignment-Methode<br />
Ermittelt die Ausrichtung für fixierte Zeilen in einer Spalte.
538 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Syntax<br />
[VB]<br />
Public Function get_FixedAlignment(ByVal col As Integer) As<br />
C1.Win.<strong>C1FlexGrid</strong>.Classic.AlignmentSettings<br />
[C#]<br />
public C1.Win.<strong>C1FlexGrid</strong>.Classic.AlignmentSettings get_FixedAlignment ( System.Int32 col )<br />
[Delphi]<br />
function get_FixedAlignment(col: Integer): C1.Win.<strong>C1FlexGrid</strong>.Classic.AlignmentSettings;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
get_IsCollapsed-Methode<br />
Ermittelt ob eine Zeile eingeklappt ist.<br />
Syntax<br />
[VB]<br />
Public Function get_IsCollapsed(ByVal row As Integer) As Boolean<br />
[C#]<br />
public bool get_IsCollapsed ( System.Int32 row )<br />
[Delphi]<br />
function get_IsCollapsed(row: Integer): Boolean;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
get_IsSelected-Methode<br />
Ermittelt ob eine Zeile ausgewählt ist (für listbox-Auswahltypen).<br />
Syntax<br />
[VB]<br />
Public Function get_IsSelected(ByVal row As Integer) As Boolean<br />
[C#]<br />
public bool get_IsSelected ( System.Int32 row )<br />
[Delphi]<br />
function get_IsSelected(row: Integer): Boolean;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)
get_IsSubtotal-Methode<br />
Ermittelt ob eine Zeile Zwischensummen beinhaltet (anstelle von Daten).<br />
Syntax<br />
[VB]<br />
Public Function get_IsSubtotal(ByVal row As Integer) As Boolean<br />
[C#]<br />
public System.Boolean get_IsSubtotal ( System.Int32 row )<br />
[Delphi]<br />
function get_IsSubtotal(row: Integer): Boolean;<br />
Bemerkungen<br />
get_IsSubtotal-Methode · 539<br />
Mit dieser Eigenschaft können Sie zum Einen feststellen, ob eine gegebene Zeile eine reguläre oder eine<br />
Zwischensummenzeile ist, oder zum Anderen Zwischensummenzeilen manuell, als Gegenstück zur<br />
Subtotal-Methode, erstellen.<br />
Es bestehen zwei Unterschiede zwischen Zwischensummenzeilen und regulären Zeilen:<br />
1. Zwischensummenzeilen können automatisch mit der Subtotal-Methode hinzugefügt oder<br />
entfernt werden.<br />
2. Wenn die Steuerung als Gliederung verwendet wird, dann verhalten sich Zwischensummenzeilen<br />
wie Gliederungsknoten, währenddessen reguläre Zeilen sich wie Zweigstellen verhalten.<br />
Sie können diese Eigenschaft verwenden, um eigene Gliederungen zu erstellen. Dies erfordert drei<br />
Schritte:<br />
1. Setzen Sie die IsSubtotal-Eigenschaft für alle Gliederungsknoten auf TRUE.<br />
2. Setzen Sie die set_RowOutlineLevel-Methode für jeden Gliederungsknoten.<br />
3. Setzen Sie die OutlineBar- und OutlineCol-Eigenschaften, wenn Sie einen Gliederungsbaum<br />
erstellen wollen, in dem der Nutzer die Gliederung zusammenklappen und erweitern kann.<br />
Für weitere Details, schauen Sie bitte unter „Übung zur Gliederung“ nach.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
get_MergeCol-Methode<br />
Ermittelt ob die Zellen einer Spalte verbunden werden (Siehe auch MergeCells-Eigenschaft).<br />
Syntax<br />
[VB]<br />
Public Function get_MergeCol(ByVal col As Integer) As Boolean<br />
[C#]<br />
public System.Boolean get_MergeCol ( System.Int32 col )
540 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
[Delphi]<br />
function get_MergeCol(col: Integer): Boolean;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
MergeCells-Eigenschaft (Seite 507)<br />
GetMergedRange-Methode<br />
Ermittelt ob die Zellen eines Bereichs verbunden werden.<br />
Syntax<br />
[VB]<br />
Public Sub GetMergedRange(row As Integer, col As Integer, r1 As Integer, c1 As Integer, r2 As Integer,<br />
c2 As Integer)<br />
[C#]<br />
public void GetMergedRange ( int row , int col , int r1 , int c1 , int r2 , int c2 )<br />
[Delphi]<br />
procedure GetMergedRange(row: Integer; col: Integer; r1: Integer; r2: integer; c2: Integer);<br />
Parameter Beschreibung<br />
row, col Die Koordinaten der Zelle, die in dem verbundenen Bereich enthalten sein soll.<br />
r1, r2, c1, c2<br />
Bemerkungen<br />
Vier Koordinaten, die den aktuell verbundenen Bereich festlegen. r1 und r2 stehen<br />
für die oberste und unterste Zeile, c1 und c2 stehen hingegen für die linke und<br />
rechte Spalte des Bereichs.<br />
Die <strong>C1FlexGrid</strong>Classic-Steuerung kann Zellen aufgrund deren Inhalts verbinden. Mit dieser Methode<br />
können Sie festlegen, ob eine Zelle mit ihren Nachbarzellen verbunden wird.<br />
Zum Beispiel, der nachfolgende Quellcode ändert den Inhalt einer verbundenen Zelle, erhält dabei aber<br />
den verbundenen Bereich:<br />
• Visual Basic<br />
' create a merged range<br />
fg.MergeCells = MergeSettings.flexMergeFree<br />
fg.set_MergeRow(1, True)<br />
fg.set_Cell(CellPropertySettings.flexcpText,<br />
1, 1, 1, 4, "Merged Range")<br />
' this changes only cell 1, 1<br />
fg.set_Cell(CellPropertySettings.flexcpText,_<br />
1, 1, "Merged Range Has Changed")<br />
' this changes the whole merged range<br />
Dim r1&, c1&, r2&, c2&<br />
fg.GetMergedRange (1, 2, r1, r2, c1, c2)
• C#<br />
• Delphi<br />
fg.set_Cell(CellPropertySettings.flexcpText, _<br />
1, 1, 1, 4, "Merged Range Has Changed")<br />
// create a merged range<br />
fg.MergeCells = MergeSettings.flexMergeFree;<br />
fg.set_MergeRow(1, true);<br />
fg.set_Cell(CellPropertySettings.flexcpText,<br />
1, 1, 1, 4, "Merged Range");<br />
// this changes only cell 1, 1<br />
fg.set_Cell(CellPropertySettings.flexcpText,<br />
1, 1, "Merged Range Has Changed");<br />
// this changes the whole merged range<br />
r1&, c1&, r2&, c2&;<br />
fg.GetMergedRange (1, 2, r1, r2, c1, c2);<br />
fg.set_Cell(CellPropertySettings.flexcpText,<br />
1, 1, 1, 4, "Merged Range Has Changed");<br />
get_MergeRow-Methode · 541<br />
var<br />
r1, r2, c1, c2: Integer;<br />
begin<br />
// create a merged range<br />
fg.MergeCells := MergeSettings.flexMergeFree;<br />
fg.set_MergeRow(1, True);<br />
fg.set_Cell(CellPropertySettings.flexcpText, 1, 1, 1, 4, 'Merged<br />
Range');<br />
// this changes only cell 1, 1<br />
fg.set_Cell(CellPropertySettings.flexcpText, 1, 1, 'Merged Range Has<br />
Changed');<br />
// this changes the whole merged range<br />
fg.GetMergedRange(1, 2, r1, r2, c1, c2);<br />
fg.set_Cell(CellPropertySettings.flexcpText, 1, 1, 1, 4, 'Merged<br />
Range Has Changed');<br />
end;<br />
Schauen Sie unter der MergeCells-Eigenschaft für weitere Einzelheiten über Zellverbindungen nach.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
GetMergedRange-Methode (<strong>C1FlexGrid</strong>) (Seite 192)<br />
get_MergeRow-Methode<br />
Ermittelt ob die Zellen einer Zeile verbunden werden (Siehe auch MergeCells-Eigenschaft).<br />
Syntax<br />
[VB]<br />
Public Function get_MergeRow(ByVal row As Integer) As Boolean<br />
[C#]<br />
public System.Boolean get_MergeRow ( System.Int32 row )<br />
[Delphi]<br />
function get_MergeRow(row: Integer): Boolean;
542 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Bemerkungen<br />
Die get_MergeRow-Methode wird zusammen mit der MergeCells-Eigenschaft und get_MergeCol-<br />
Methode verwendet und steuert, ob und wie angezeigte Zellen verbunden werden.<br />
Die MergeCells-Eigenschaft wird verwendet, um Zellverbindungen für die gesamte Tabelle zu<br />
aktivieren. Nachdem diese auf einen angemessenen Wert gesetzt wurde, wird mit den get_MergeRow-<br />
und get_MergeCol-Methoden festgelegt, in welchen Zeilen und Spalten Zellen verbunden werden.<br />
Standardmäßig ist get_MergeRow und get_MergeCol auf FALSE gesetzt, sodass keine Zellen verbunden<br />
werden. Wenn Sie diese für eine bestimmte Zeile oder Spalte auf TRUE setzen, dann werden<br />
angrenzende Zellen im gleichen Inhalt verbunden.<br />
Der Row-Parameter muss auf einen Wert zwischen Null und Rows-1 damit MergeRow für eine einzelne<br />
Zeile oder auf den Wert -1 gesetzt werden,damit MergeRow für alle Zeilen aktiviert wird.<br />
Sie müssen get_MergeRow nicht auf TRUE setzen, wenn MergeCells auf flexMergeSpill (6) steht.<br />
Schauen Sie unter der MergeCells-Eigenschaft für weitere Einzelheiten und Beispiele nach.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
AllowMerging-Eigenschaft (Row) (Seite 326)<br />
MergeCells-Eigenschaft (Seite 507)<br />
GetNode-Methode (<strong>C1FlexGrid</strong>Classic)<br />
Ermittelt ein Gliederungsknotenobjekt für eine gegebene Zwischensummenzeile.<br />
Syntax<br />
[VB]<br />
Public Function GetNode() As C1.Win.<strong>C1FlexGrid</strong>.Node<br />
Public Function GetNode(ByVal row As Integer) As C1.Win.<strong>C1FlexGrid</strong>.Node<br />
[C#]<br />
public C1.Win.<strong>C1FlexGrid</strong>.Node GetNode ( )<br />
public C1.Win.<strong>C1FlexGrid</strong>.Node GetNode ( System.Int32 row )<br />
[Delphi]<br />
function GetNode: C1.Win.<strong>C1FlexGrid</strong>.Node;<br />
function GetNode(row: Integer): C1.Win.<strong>C1FlexGrid</strong>.Node;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
GetNodeRow-Methode<br />
Ermittelt die Anzahl der, einer Zeile übergeordneten und untergeorneten ersten und letzten Zeile in der<br />
Gliederung.
Syntax<br />
[VB]<br />
Public Function GetNodeRow(ByVal row As Integer, ByVal which As<br />
C1.Win.<strong>C1FlexGrid</strong>.NodeTypeEnum) As Integer<br />
[C#]<br />
get_RowData-Methode · 543<br />
public System.Int32 GetNodeRow ( System.Int32 row , C1.Win.<strong>C1FlexGrid</strong>.NodeTypeEnum which )<br />
[Delphi]<br />
function GetNodeRow (row: Integer; which: C1.Win.<strong>C1FlexGrid</strong>.NodeTypeEnum): Integer;<br />
Bemerkungen<br />
Wenn die Tabelle als Gliederung verwendet wird, dann können Sie mit dieser Methode den<br />
übergeordneten, den ersten oder letzten untergeordneten Knoten eines gegebenen Knotens festlegen.<br />
Die Parameter für die GetNodeRow-Eigenschaft werden nachfolgend beschrieben:<br />
Row As Integer<br />
Die Zeilennummer des Knotens, dessen über- oder untergeordneten Knoten Sie bestimmen wollen.<br />
Which As NodeTypeSettings<br />
Welcher Knoten zurückgegeben wird. Gültige Einstellungen für diesen Paramter sind:<br />
Mitgliedsname Beschreibung<br />
Root Des Knotens Quellknoten.<br />
Parent Des Knotens direkter Vorgänger.<br />
FirstChild Des Knotens erster Nachfolger.<br />
LastChild Des Knotens letzter Nachfolger.<br />
FirstSibling Des Knotens erster Sibling (Knoten auf der selben Ebene mit dem selben<br />
übergeordneten Knoten).<br />
LastSibling Des Knotens letzter Sibling.<br />
NextSibling Des Knotens nächster Sibling.<br />
PreviousSibling Des Knotens vorhergehender Sibling.<br />
Wenn der gewünschte Knoten nicht exisitert, dann gibt GetNode Null zurück. Zum Beispiel, der<br />
Quellknoten besitzt keinen vorhergehenden und leere Knoten keine weiteren nachfolgenden Siblings.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
get_RowData-Methode<br />
Ermittelt ein benutzerdefiniertes, mit einer gegebenen Zeile verknüpftes Variant.
544 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Syntax<br />
[VB]<br />
Public Function get_RowData(ByVal row As Integer) As Object<br />
[C#]<br />
public System.Object get_RowData ( System.Int32 row )<br />
[Delphi]<br />
function get_RowData(row: Integer): Object;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
get_RowHeight-Methode<br />
Ermittelt die Höhe einer bestimmten Zeile in Twips.<br />
Syntax<br />
[VB]<br />
Public Function get_RowHeight(ByVal row As Integer) As Integer<br />
[C#]<br />
public System.Int32 get_RowHeight ( System.Int32 row )<br />
[Delphi]<br />
function get_RowHeight(row: Integer): As Integer;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
get_RowHidden-Methode<br />
Ermittelt, ob eine Zeile versteckt ist.<br />
Syntax<br />
[VB]<br />
Public Function get_RowHidden(ByVal row As Integer) As Boolean<br />
[C#]<br />
public bool get_RowHidden ( System.Int32 row )<br />
[Delphi]<br />
function get_RowHidden(row: Integer): Boolean;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)
get_RowIsVisible-Methode<br />
Ermittelt, ob eine gegebene Zeile derzeit auf dem Bildschirm sichtbar ist.<br />
Syntax<br />
[VB]<br />
Public Function get_RowIsVisible(ByVal row As Integer) As Boolean<br />
[C#]<br />
public System.Boolean get_RowIsVisible ( System.Int32 row )<br />
[Delphi]<br />
function get_RowIsVisible(row: Integer): Boolean;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
get_RowOutlineLevel-Methode<br />
Ermittelt die Gliederungsebene für eine Zwischensummenzeile.<br />
Syntax<br />
[VB]<br />
Public Function get_RowOutlineLevel(ByVal row As Integer) As Integer<br />
[C#]<br />
public System.Int32 get_RowOutlineLevel ( System.Int32 row )<br />
[Delphi]<br />
function get_RowOutlineLevel(row: Integer): Integer;<br />
Bemerkungen<br />
Die get_RowOutlineLevel-Eigenschaft wird für zwei eng verwandte Ziele genutzt.<br />
get_RowIsVisible-Methode · 545<br />
1. Wenn sich die Tabelle im Gliederungsmodus befindet, dann wird get_RowOutlineLevel für das<br />
Festlegen der hierarchischen Ebene eines Knotens verwendet. Knoten mit hohen<br />
Gliederungsebenen sind Zeilen, mit niedrigeren Gliederungsebenen untergeordnete. Der<br />
Quellknoten hat die niedrigste Gliederungsebene. Sie können die Beziehungen zwischen Knoten<br />
verändern, indem Sie den Wert der get_RowOutlineLevel-Methode anpassen. Schauen Sie bitte<br />
für weitere Einzelheiten über das Erstellen und Verwenden von Gliederungen unter „Übung zur<br />
Gliederung“ nach.<br />
2. Wenn die Subtotal-Methode für automatisches Erstellen von Zwischensummenzeilen verwendet<br />
wird, dann speichert get_RowOutlineLevel die Nummer der Zeile, die für das Gruppieren der<br />
Daten genutzt wird. Schauen Sie bitte für weitere Einzelheiten über das Erstellen und Verwenden<br />
von automatischen Zwischensummenzeilen unter der Subtotal-Methode nach.<br />
Die get_RowOutlineLevel wird von der Steuerung nur verwendet, wenn die get_IsSubtotal-Eigenschaft<br />
auf TRUE steht.
546 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
get_RowPos-Methode<br />
Ermittelt die obere (y) Koordinate einer Zeile, relativ zur Kante der Steuerung in Twips.<br />
Syntax<br />
[VB]<br />
Public Function get_RowPos(ByVal row As Integer) As Integer<br />
[C#]<br />
public System.Int32 get_RowPos ( System.Int32 row )<br />
[Delphi]<br />
function get_RowPos(row: Integer): Integer;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
GetSelection-Methode<br />
Ermittelt die sortierte aktuelle Auswahl, sodass Row1
Zum Beispiel, der nachfolgende Quellcode druckt den Inhalt des ausgwählten Bereichs:<br />
• Visual Basic<br />
• C#<br />
• Delphi<br />
Dim r&, c&, r1&, c1, r2&, c2&<br />
fg.GetSelection (r1, c1, r2, c2)<br />
For r = r1 To r2<br />
For c = c1 To c2<br />
Debug.WriteLine (fg.get_TextMatrix (r,c))<br />
Next<br />
Next<br />
r&, c&, r1&, c1, r2&, c2&;<br />
fg.GetSelection (r1, c1, r2, c2);<br />
for ( r = r1; r
548 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
get_ValueMatrix-Methode<br />
Ermittelt einen numerischen Wert einer Zelle zurück, die durch ihre Zeilen- und Spaltenkoordinaten<br />
definiert wird.<br />
Syntax<br />
[VB]<br />
Public Function get_ValueMatrix(r As Integer, c As Integer) As Double<br />
[C#]<br />
public Double get_ValueMatrix ( int r , int c )<br />
[Delphi]<br />
function get_ValueMatrix(r: Integer; c: Integer): Double;<br />
Parameter Beschreibung<br />
Row Zeilenindex der Zelle, dessen Wert abgerufen wird.<br />
Col Spaltenindex der Zelle, dessen Wert abgerufen wird.<br />
Bemerkungen<br />
Diese Eigenschaft ist ähnlich der Value-Eigenschaft. Sie können mit dieser Methode allerdings die Zelle<br />
festlegen, deren Wert abgerufen wird.<br />
Der nachfolgende Quellcode gibt den Wert einer willkürlichen Zelle im Debugfenster aus:<br />
• Visual Basic<br />
• C#<br />
Debug.WriteLine(fg.get_ValueMatrix(1, 1))<br />
Debug.WriteLine(fg.get_ValueMatrix(1, 1));<br />
• Delphi<br />
Console.WriteLine(fg.get_ValueMatrix(1, 1));<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
GetData-Methode (Seite 190)<br />
SetData-Methode (Seite 207)<br />
Outline-Methode<br />
Legt eine Gliederungsebene für die Zwischensummenzeilen fest.<br />
Syntax<br />
[VB]<br />
Public Sub Outline(ByVal level As Integer)
[C#]<br />
public void Outline ( System.Int32 level )<br />
[Delphi]<br />
procedure Outline(level: Integer);<br />
Bemerkungen<br />
PrintGrid-Methode (<strong>C1FlexGrid</strong>Classic) · 549<br />
Die Outline-Methode klappt eine Gliederung bis zu einer gegebenen Ebene aus oder ein. Dabei werden<br />
mehrere Knoten gleichzeitig ein- oder ausgeklappt.<br />
Die Methode zeigt alle Knoten, die ein RowOutlineLevel kleiner oder gleich dem Wert des Level-<br />
Parameters besitzen. Kleinere Level-Werte klappt die Gliederung zusammen, größere Werte erweitert sie.<br />
Wenn die Ebene Null ist, dann werden nur die Quellknoten angezeigt. Wenn das Level auf einen sehr<br />
großen Wert gesetzt wird, z.B. 100, dann wird die Gliederung vollständig erweitert und sichtbar.<br />
Wenn das Level auf -1 steht, dann wird die Gliederung vollständig erweitert.<br />
Wenn Knoten erweitert oder zusammengeklappt werden, dann startet die Steuerung die BeforeCollapse-<br />
und AfterCollapse-Ereignisse. Sie können diese Ereignisse abfangen und die Handlungen abbrechen.<br />
Schauen Sie im BeforeCollapse-Ereignis für ein Beispiel nach.<br />
Schauen Sie in der Subtotal-Methode nach, um eine Gliederungsstruktur mit automatischen<br />
Zwischensummen zu erstellen. Schauen Sie in der set_IsSubtotal-Methode nach, um eine<br />
benutzerdefinierte Gliederungsstruktur zu erstellen. Für weitere Einzelheiten über das Erstellen und<br />
Verwenden von Gliederungen, schauen Sie bitte unter „Übung zur Gliederung“ nach.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
PrintGrid-Methode (<strong>C1FlexGrid</strong>Classic)<br />
Druckt die Tabelle und zweigt optional ein Druckvorschaufenster an.<br />
Syntax<br />
[VB]<br />
Public Function PrintGrid(docName As String) As Boolean<br />
Public Function PrintGrid(docName As String, flags As PrintGridFlags) As Boolean<br />
Public Function PrintGrid(docName As String, flags As PrintGridFlags, header As String, footer As<br />
String) As Boolean<br />
[C#]<br />
public Boolean PrintGrid(string docName)<br />
public Boolean PrintGrid(string docName , PrintGridFlags flags)<br />
public Boolean PrintGrid(string docName , PrintGridFlags flags , string header , string footer)<br />
[Delphi]<br />
function PrintGrid(docName: string): Boolean;<br />
function PrintGrid(docName: string; flags: PrintGridFlags): Boolean;
550 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
function PrintGrid(docName: string; flags: PrintGridFlags; header: string; footer: string); Boolean;<br />
Parameter Beschreibung<br />
docName<br />
flags<br />
Der Dokumentname, der in den Fortschritts- und den Druckauftragsfenstern<br />
angezeigt wird.<br />
Eine Kombination von Werten der PrintGridFlags-Aufzählung, die den Typ der<br />
anzuzeigenden Druck- und Vorschaufenster festlegen und bestimmen, wie die<br />
Tabelle für den Ausdruck skaliert wird.<br />
header, footer Zeichenketten, die oben und unten auf jede Seite gedruckt werden.<br />
Rückgabewert<br />
Ein Boolean-Wert der anzeigt, ob entweder die Tabelle gedruckt wurde, oder der Nutzer eines der<br />
optionalen Einstellungsfenster abgebrochen hat.<br />
Bemerkungen<br />
Die Kopf- und Fußzeilentexte können bis zu drei tabulatorgetrennte Abschnitte besitzen, die<br />
entsprechend links, mittig und rechts auf der Seite ausgerichtet werden. Die Texte können weiterhin<br />
Platzhalter besitzen, die mit der aktuellen Seitenzahl oder der Gesamtseitenzahl (“{0}” und “{1}”) ersetzt<br />
werden.<br />
Mit der PrintParameters-Eigenschaft können Sie noch weitere Aspekte des Druckauftrags, wie z.B.<br />
Seitenausrichtung, Ränder, Kopf- und Fußzeilenschriftarten, steuern.<br />
Beispiel<br />
Der folgende Aufruf skaliert die Tabelle auf eine Seitenbreite, platziert eine zentrierte Fußzeile mit dem<br />
Text „Page n of m” am unteren Ende der Seite und druckt sie auf dem Standarddrucker aus.<br />
• Visual Basic<br />
• C#<br />
flex.PrintGrid("My Grid", PrintGridFlags.FitPageWidth, _<br />
"", vbTab + "Page {0} of {1}")<br />
flex.PrintGrid("My Grid", PrintGridFlags.FitPageWidth,<br />
"", "\tPage {0} of {1}");<br />
• Delphi<br />
flex.PrintGrid('My Grid', PrintGridFlags.FitPageWidth, '', #9'Page<br />
{0} of {1}');<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
RemoveItem-Methode (<strong>C1FlexGrid</strong>Classic)<br />
Entfernt eine Zeile aus der Steuerung.
Syntax<br />
[VB]<br />
Object.RemoveItem ()<br />
Object.RemoveItem (int Row)<br />
[C#]<br />
public void RemoveItem ( )<br />
public void RemoveItem ( int Index )<br />
[Delphi]<br />
procedure RemoveItem;<br />
procedure RemoveItem(index: Integer);<br />
Parameter Beschreibung<br />
Row<br />
Bemerkungen<br />
SelectedRow-Methode · 5<strong>51</strong><br />
Ein optionaler Parameter, mit dem festgelegt wird, welche Zeile aus der Steuerung<br />
entfernt wird.<br />
Der Row-Parameter legt fest, welche Zeile aus der Steuerung entfernt wird. Wenn dieser bereitgestellt<br />
wird, dann muss er zwischen 0 und Rows-1 liegen, da sonst ein Invalid Index-Fehler (ungültiger Index)<br />
auftritt. Wenn dieser Parameter unberücksichtigt bleibt, dann wird die letzte Zeile der Tabelle gelöscht.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Remove-Methode (RowCollection) (Seite 313)<br />
SelectedRow-Methode<br />
Ermittelt die Position einer ausgewählten Zeile, wenn der SelectionMode auf flexSelectionListBox steht.<br />
Syntax<br />
[VB]<br />
Public Function SelectedRow(ByVal index As Integer) As Integer<br />
[C#]<br />
public int SelectedRow (int index)<br />
[Delphi]<br />
function SelectedRow(index: Integer): Integer;<br />
Bemerkungen<br />
Diese Eigenschaft arbeitet zusammen mit der SelectedRows-Eigenschaft, um alle ausgewählten Zeilen in<br />
der Steuerung aufzulisten. Diese Eigenschaft ist besonders nützlich, wenn die SelectionMode-
552 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Eigenschaft auf flexSelectionListBox (3) steht, sodass der Nutzer mehrere nichtangrenzende Zeilen<br />
auswählen kann.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Selection-Eigenschaft (Seite 166)<br />
set_Cell-Methode<br />
Legt die cell-Eigenschaften auf einen willkürlichen Bereich fest.<br />
Syntax<br />
[VB]<br />
Public Sub set_Cell(ByVal setting As C1.Win.<strong>C1FlexGrid</strong>.Classic.CellPropertySettings, ByVal row1 As<br />
Integer, ByVal col1 As Integer, ByVal row2 As Integer, ByVal col2 As Integer, ByVal newVal As Object)<br />
Public Sub set_Cell(ByVal setting As C1.Win.<strong>C1FlexGrid</strong>.Classic.CellPropertySettings, ByVal row As<br />
Integer, ByVal col As Integer, ByVal newVal As Object)<br />
[C#]<br />
public void set_Cell ( C1.Win.<strong>C1FlexGrid</strong>.Classic.CellPropertySettings setting , System.Int32 row ,<br />
System.Int32 col , System.Object newVal )<br />
public void set_Cell ( C1.Win.<strong>C1FlexGrid</strong>.Classic.CellPropertySettings setting , System.Int32 row1 ,<br />
System.Int32 col1 , System.Int32 row2 , System.Int32 col2 , System.Object newVal )<br />
[Delphi]<br />
procedure set_Cell(setting: C1.Win.<strong>C1FlexGrid</strong>.Classic.CellPropertySettings; row1: Integer; col1: Integer;<br />
row2: Integer; col2: Integer; newVal: Object);<br />
procedure set_Cell(setting: C1.Win.<strong>C1FlexGrid</strong>.Classic.CellPropertySettings; row: Integer; col: Integer;<br />
newVal: Object);<br />
Bemerkungen<br />
Mit der set_Cell-Methode können Sie die cell-Eigenschaften von einzelnen Zellen oder Zellbereichen<br />
direkt auslesen oder festlegen, ohne diese auszuwählen.<br />
Die Parameter für die set_Cell-Methode werden nachfolgend beschrieben:<br />
Setting As CellPropertySettings<br />
Dieser Parameter legt fest, welche Eigenschaft gelesen oder gesetzt wird. Die verfügbaren Einstellungen<br />
sind nachfolgend aufgelistet.<br />
Row1, Col1, Row2, and Col2 As Integer (optional)<br />
Wenn die cell-Eigenschaften gelesen werden, dann wird nur die Zelle (Row1, Col1) verwendet. Wenn sie<br />
gesetzt werden, dann ist der gesamte Bereich betroffen. Der Standardwert für Row1 und Col1 ist die<br />
aktuelle Zeile und die aktuelle Spalte. Wenn diese nicht zur Verfügung gestellt werden, dann wird die<br />
aktuelle Zelle verwendet. Der Standardwert für Row2 und Col2 ist Row1 und Col1. Wenn diese nicht zur<br />
Verfügung gestellt werden, dann wird eine einzelne Zelle verwendet.<br />
Die Gültigen Einstellungen für den setting-Parameter sind:
Mitgliedsname Beschreibung<br />
flexChecked Die Zelle hat ein Kontrollkästchen mit einem Häkchen drin.<br />
flexNoCheckbox Die Zelle hat kein Kontrollkästchen.<br />
set_ColAlignment-Methode · 553<br />
flexTSChecked Die Zelle hat ein drei-Zustands-Kontrollkästchen mit einem Häkchen drin.<br />
flexTSGrayed Die Zelle hat ein drei-Zustands-Kontrollkästchen im grauen Zustand.<br />
flexTSUnchecked Die Zelle hat ein leeres drei-Zustands-Kontrollkästchen.<br />
flexUnchecked Die Zelle hat ein leeres Kontrollkästchen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
set_ColAlignment-Methode<br />
Legt die Ausrichtung einer gegebenen Spalte fest.<br />
Syntax<br />
[VB]<br />
Public Sub set_ColAlignment(ByVal col As Integer, ByVal newVal As<br />
C1.Win.<strong>C1FlexGrid</strong>.Classic.AlignmentSettings)<br />
[C#]<br />
public void set_ColAlignment ( System.Int32 col , C1.Win.<strong>C1FlexGrid</strong>.Classic.AlignmentSettings<br />
newVal)<br />
[Delphi]<br />
procedure set_ColAlignment(col: Integer; newVal: C1.Win.<strong>C1FlexGrid</strong>.Classic.AlignmentSettings);<br />
Bemerkungen<br />
Die flexAlignGeneral-Einstellung richtet Text linksbündig und Zahlen und Daten rechtsbündig aus.<br />
Die set_ColAlignment-Methode betrifft alle Zellen in der festgelegten Spalte, auch die in den fixierten<br />
Zeilen. Sie können diese Einstellung für fixierte Zellen mit der set_FixedAlignment-Methode und für<br />
einzelne Zellen mit der Cell(flexcpAlignment)-Eigenschaft überschreiben.<br />
Dieses Beispiel legt die Ausrichtung der dritten Spalte auf rechts unten fest.<br />
• Visual Basic<br />
• C#<br />
fg.set_ColAlignment(2, AlignmentSettings.flexAlignRightBottom)<br />
fg.set_ColAlignment(2, AlignmentSettings.flexAlignRightBottom);<br />
• Delphi<br />
fg.set_ColAlignment(2, AlignmentSettings.flexAlignRightBottom);<br />
Sie können die Ausrichtung von Grafiken mit der CellPictureAlignment-Eigenschaft festlegen.
554 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Wenn Sie diese Eigenschaft setzen, dann sollte der Col-Parameter auf einem Wert zwischen 0 und Cols-1<br />
stehen, um eine gegebene Spalte auszurichten oder auf -1, um die Ausrichtung aller Spalten festzulegen.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
StyleFixedDisplay-Eigenschaft (Seite 359)<br />
set_ColComboList-Methode<br />
Legt die für ein Auswahlfeld zu verwendende Liste von einer bestimmten Spalte fest.<br />
Syntax<br />
[VB]<br />
Public Sub set_ColComboList(ByVal col As Integer, ByVal newVal As String)<br />
[C#]<br />
public void set_ColComboList ( System.Int32 col , System.String newVal )<br />
[Delphi]<br />
procedure set_ColComboList(col: Integer; newVal: String);<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
set_ColData-Methode<br />
Legt ein benutzerdefiniertes, mit einer Spalte verknüpftes Variant fest.<br />
Syntax<br />
[VB]<br />
Public Sub set_ColData(ByVal col As Integer, ByVal newVal As Object)<br />
[C#]<br />
public void set_ColData ( System.Int32 col , System.Object newVal )<br />
[Delphi]<br />
procedure set_ColData(col: Integer; newVal: Object);<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
set_ColDataType-Methode<br />
Legt den Datentyp einer Spalte fest.<br />
Syntax<br />
[VB]<br />
Public Sub set_ColDataType(ByVal col As Integer, ByVal newVal As System.Type)
[C#]<br />
public void set_ColDataType ( System.Int32 col , System.Type newVal )<br />
[Delphi]<br />
procedure set_ColDataType(col: Integer; newVal: System.Type);<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
set_ColEditMask-Methode<br />
set_ColEditMask-Methode · 555<br />
Legt die Eingabemaske fest, die für die Bearbeitung der Zellen in einer bestimmten Spalte verwendet<br />
wird.<br />
Syntax<br />
[VB]<br />
Public Sub set_ColEditMask(ByVal col As Integer, ByVal newVal As String)<br />
[C#]<br />
public void set_ColEditMask ( System.Int32 col , System.String newVal )<br />
[Delphi]<br />
procedure set_ColEditMask(col: Integer; newVal: String);<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
set_ColFormat-Methode<br />
Legt das für numerische Werte verwendete Format fest.<br />
Syntax<br />
[VB]<br />
Public Sub set_ColFormat(ByVal col As Integer, ByVal newVal As String)<br />
[C#]<br />
public void set_ColFormat ( System.Int32 col , System.String newVal )<br />
[Delphi]<br />
procedure set_ColFormat(col: Integer; newVal: String);<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
set_ColHidden-Methode<br />
Legt fest, ob eine Spalte ausgeblendet wird.<br />
Syntax
556 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
[VB]<br />
Public Sub set_ColHidden(ByVal col As Integer, ByVal newVal As Boolean)<br />
[C#]<br />
public void set_ColHidden ( System.Int32 col , System.Boolean newVal )<br />
[Delphi]<br />
Sub set_ColHidden(col: Integer; newVal: Boolean);<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
set_ColImageList-Methode<br />
Legt einen zu verwendenden Abwickler auf eine ImageList als Quelle des Bildes für eine gegebene Spalte<br />
fest.<br />
Syntax<br />
[VB]<br />
Public Sub set_ColImageList(ByVal col As Integer, ByVal newVal As System.Windows.Forms.ImageList)<br />
[C#]<br />
public void set_ColImageList ( System.Int32 col , System.Windows.Forms.ImageList newVal )<br />
[Delphi]<br />
procedure set_ColImageList(col: Integer; newVal: System.Windows.Forms.ImageList);<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
set_ColIndent-Methode<br />
Legt den Einzug einer gegebenen Spalte in Twips fest.<br />
Syntax<br />
[VB]<br />
Public Sub set_ColIndent(ByVal col As Integer, ByVal newVal As Integer)<br />
[C#]<br />
public void set_ColIndent ( System.Int32 col , System.Int32 newVal )<br />
[Delphi]<br />
procedure set_ColIndent(col: Integer; newVal: Integer);<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)
set_ColKey-Methode<br />
Legt eine Taste fest, mit der eine gegebene Spalte identifiziert wird.<br />
Syntax<br />
[VB]<br />
Public Sub set_ColKey(ByVal col As Integer, ByVal newVal As String)<br />
[C#]<br />
public void set_ColKey ( System.Int32 col , System.String newVal )<br />
[Delphi]<br />
procedure set_ColKey(col: Integer; newVal: String);<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
set_ColPosition-Methode<br />
Verschiebt eine gegebene Spalte auf eine neue Position.<br />
Syntax<br />
[VB]<br />
Public Sub set_ColPosition(ByVal col As Integer, ByVal newPosition As Integer)<br />
[C#]<br />
public void set_ColPosition ( System.Int32 col , System.Int32 newPosition )<br />
[Delphi]<br />
procedure set_ColPosition(col: Integer; newPosition: Integer);<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
set_ColSort-Methode<br />
Legt die Sortierungsrichtung für jede Spalte fest (zur Verwendung mit der Sort-Eigenschaft).<br />
Syntax<br />
[VB]<br />
set_ColKey-Methode · 557<br />
Public Sub set_ColSort(ByVal col As Integer, ByVal newVal As C1.Win.<strong>C1FlexGrid</strong>.Classic.SortSettings)<br />
[C#]<br />
public void set_ColSort ( System.Int32 col , C1.Win.<strong>C1FlexGrid</strong>.Classic.SortSettings newVal )<br />
[Delphi]<br />
procedure set_ColSort(col: Integer; newVal: C1.Win.<strong>C1FlexGrid</strong>.Classic.SortSettings);
558 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
set_ColWidth-Methode<br />
Legt die Breite einer bestimmten Spalte in Twips fest.<br />
Syntax<br />
[VB]<br />
Public Sub set_ColWidth(ByVal col As Integer, ByVal newVal As Integer)<br />
[C#]<br />
public void set_ColWidth ( System.Int32 col , System.Int32 newVal )<br />
[Delphi]<br />
procedure set_ColWidth(col: Integer; newVal: Integer);<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
set_FixedAlignment-Methode<br />
Legt die Ausrichtung für fixierte Zeilen in einer Spalte fest.<br />
Syntax<br />
[VB]<br />
Public Sub set_FixedAlignment(ByVal col As Integer, ByVal newVal As<br />
C1.Win.<strong>C1FlexGrid</strong>.Classic.AlignmentSettings)<br />
[C#]<br />
public void set_FixedAlignment ( System.Int32 col , C1.Win.<strong>C1FlexGrid</strong>.Classic.AlignmentSettings<br />
newVal )<br />
[Delphi]<br />
procedure set_FixedAlignment(col: Integer; newVal: C1.Win.<strong>C1FlexGrid</strong>.Classic.AlignmentSettings);<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
set_IsCollapsed-Methode<br />
Legt fest, ob eine Zeile eingeklappt ist.<br />
Syntax<br />
[VB]<br />
Public Sub set_IsCollapsed(ByVal row As Integer, ByVal newVal As Boolean)
[C#]<br />
public void set_IsCollapsed ( System.Int32 row , System.Boolean newVal )<br />
[Delphi]<br />
procedure set_IsCollapsed(row: Integer; newVal: Boolean);<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
set_IsSelected-Methode<br />
Legt fest, ob eine Zeile ausgewählt ist (für listbox-Auswahltypen).<br />
Syntax<br />
[VB]<br />
Public Sub set_IsSelected(ByVal row As Integer, ByVal newVal As Boolean)<br />
[C#]<br />
public void set_IsSelected ( System.Int32 row , System.Boolean newVal )<br />
[Delphi]<br />
procedure set_IsSelected(row: Integer; newVal: Boolean);<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
set_IsSubtotal-Methode<br />
Legt fest, ob eine Zeile Zwischensummen beinhaltet (anstelle von Daten).<br />
Syntax<br />
[VB]<br />
Public Sub set_IsSubtotal(ByVal row As Integer, ByVal newVal As Boolean)<br />
[C#]<br />
public void set_IsSubtotal ( System.Int32 row , System.Boolean newVal )<br />
[Delphi]<br />
procedure set_IsSubtotal(row: Integer; newVal: Boolean);<br />
Bemerkungen<br />
set_IsSelected-Methode · 559<br />
Mit dieser Eigenschaft können Sie zum Einen feststellen, ob eine gegebene Zeile eine reguläre oder eine<br />
Zwischensummenzeile ist, oder zum Anderen Zwischensummenzeilen manuell, als Gegenstück zur<br />
Subtotal-Methode, erstellen.<br />
Es bestehen zwei Unterschiede zwischen Zwischensummenzeilen und regulären Zeilen:<br />
1. Zwischensummenzeilen können automatisch mit der Subtotal-Methode hinzugefügt oder<br />
entfernt werden.
560 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
2. Wenn die Steuerung als Gliederung verwendet wird, dann verhalten sich Zwischensummenzeilen<br />
wie Gliederungsknoten, währenddessen reguläre Zeilen sich wie Zweigstellen verhalten.<br />
Sie können diese Eigenschaft verwenden, um eigene Gliederungen zu erstellen. Dies benötig drei Schritte:<br />
3. Setzen Sie die IsSubtotal-Eigenschaft für alle Gliederungsknoten auf TRUE.<br />
4. Setzen Sie die set_RowOutlineLevel-Methode für jeden Gliederungsknoten.<br />
5. Setzen Sie die OutlineBar- und OutlineCol-Eigenschaften, wenn Sie einen Gliederungsbaum<br />
erstellen wollen, in dem der Nutzer die Gliederung zusammenklappen und erweitern kann.<br />
Für weitere Details, schauen Sie bitte unter „Übung zur Gliederung“ nach.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
set_MergeCol-Methode<br />
Legt fest, ob die Zellen einer Spalte verbunden werden (Siehe auch MergeCells-Eigenschaft).<br />
Syntax<br />
[VB]<br />
Public Sub set_MergeCol(ByVal col As Integer, ByVal newVal As Boolean)<br />
[C#]<br />
public void set_MergeCol ( System.Int32 col , System.Boolean newVal )<br />
[Delphi]<br />
procedure set_MergeCol(col: Integer; newVal: Boolean);<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
MergeCells-Eigenschaft (Seite 507)<br />
set_MergeRow-Methode<br />
Legt fest, ob die Zellen einer Zeile verbunden werden (Siehe auch MergeCells-Eigenschaft).<br />
Syntax<br />
[VB]<br />
Public Sub set_MergeRow(ByVal row As Integer, ByVal newVal As Boolean)<br />
[C#]<br />
public void set_MergeRow ( System.Int32 row , System.Boolean newVal )<br />
[Delphi]<br />
procedure set_MergeRow(row: Integer; newVal: Boolean);
Bemerkungen<br />
set_RowData-Methode · 561<br />
Die set_MergeRow-Methode wird zusammen mit der MergeCells-Eigenschaft und set_MergeCol-<br />
Methode verwendet und steuert, ob und wie angezeigte Zellen verbunden werden.<br />
Die MergeCells-Eigenschaft wird verwendet, um Zellverbindungen für die gesamte Tabelle zu<br />
aktivieren. Nachdem diese auf einen angemessenen Wert gesetzt wurde, wird mit den set_MergeRow-<br />
und set_MergeCol-Methoden festgelegt, in welchen Zeilen und Spalten Zellen verbunden werden.<br />
Standardmäßig ist set_MergeRow und set_MergeCol auf FALSE gesetzt, so dass keine Zellen verbunden<br />
werden. Wenn Sie diese für eine bestimmte Zeile oder Spalte auf TRUE setzen, dann werden<br />
angrenzende Zellen mit gleichem Inhalt verbunden.<br />
Der Row-Parameter muss auf einem Wert zwischen Null und Rows-1, damit MergeRow für eine einzelne<br />
Zeile, oder auf den Wert -1 gesetzt werden, damit MergeRow für alle Zeilen aktiviert wird.<br />
Sie müssen set_MergeRow nicht auf TRUE setzen, wenn MergeCells auf flexMergeSpill (6) steht.<br />
Schauen Sie unter der MergeCells-Eigenschaft für weitere Einzelheiten und Beispiele nach.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
MergeCells-Eigenschaft (Seite 507)<br />
set_RowData-Methode<br />
Legt ein benutzerdefiniertes, mit einer gegebenen Zeile verknüpftes Variant fest.<br />
Syntax<br />
[VB]<br />
Public Sub set_RowData(ByVal row As Integer, ByVal newVal As Object)<br />
[C#]<br />
public void set_RowData ( System.Int32 row , System.Object newVal )<br />
[Delphi]<br />
procedure set_RowData(row: Integer; newVal: Object);<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
set_RowHeight-Methode<br />
Legt die Höhe einer bestimmten Zeile in Twips fest.<br />
Syntax<br />
[VB]<br />
Public Sub set_RowHeight(ByVal row As Integer, ByVal newVal As Integer)<br />
[C#]<br />
public void set_RowHeight ( System.Int32 row , System.Int32 newVal )
562 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
[Delphi]<br />
procedure set_RowHeight(row: Integer; newVal: Integer);<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
set_RowHidden-Methode<br />
Legt fest, ob eine Zeile versteckt ist.<br />
Syntax<br />
[VB]<br />
Public Sub set_RowHidden(ByVal row As Integer, ByVal newVal As Boolean)<br />
[C#]<br />
public void set_RowHidden ( System.Int32 row , System.Boolean newVal )<br />
[Delphi]<br />
procedure set_RowHidden(row: Integer, newVal: Boolean);<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
set_RowOutlineLevel-Methode<br />
Legt die Gliederungsebene für eine Zwischensummenzeile fest.<br />
Syntax<br />
[VB]<br />
Public Sub set_RowOutlineLevel(ByVal row As Integer, ByVal newVal As Integer)<br />
[C#]<br />
public void set_RowOutlineLevel ( System.Int32 row , System.Int32 newVal )<br />
[Delphi]<br />
procedure set_RowOutlineLevel(row: Integer; newVal: Integer);<br />
Bemerkungen<br />
Die set_RowOutlineLevel-Eigenschaft wird für zwei eng verwandte Ziele genutzt.<br />
1. Wenn sich Tabellen im Gliederungsmodus befinden, dann wird set_RowOutlineLevel für das<br />
Festlegen der hierarchischen Ebene eines Knotens verwendet. Knoten mit hohen<br />
Gliederungsebenen sind Zeilen mit niedrigeren Gliederungsebenen untergeordnet. Der<br />
Quellknoten hat die niedrigste Gliederungsebene. Sie können die Beziehungen zwischen Knoten<br />
verändern, indem Sie den Wert der set_RowOutlineLevel-Methode anpassen. Schauen Sie bitte<br />
für weitere Einzelheiten über das Erstellen und Verwenden von Gliederungen unter „Übung zur<br />
Gliederung“ nach.<br />
2. Wenn die Subtotal-Methode für automatisches Erstellen von Zwischensummenzeilen verwendet<br />
wird, dann speichert get_RowOutlineLevel die Nummer der Zeile, die für das Gruppieren der
set_RowPosition-Methode · 563<br />
Daten genutzt wird. Schauen Sie bitte für weitere Einzelheiten über das Erstellen und Verwenden<br />
von automatischen Zwischensummenzeilen unter der Subtotal-Methode nach.<br />
Die set_RowOutlineLevel wird von der Steuerung nur verwendet, wenn die set_IsSubtotal-Eigenschaft<br />
auf TRUE steht.<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
set_RowPosition-Methode<br />
Verschiebt eine gegebene Zeile auf eine neue Position.<br />
Syntax<br />
[VB]<br />
Public Sub set_RowPosition(ByVal row As Integer, ByVal newPosition As Integer)<br />
[C#]<br />
public void set_RowPosition ( System.Int32 row , System.Int32 newPosition )<br />
[Delphi]<br />
procedure set_RowPosition(row: Integer; newPosition: Integer);<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
set_TextMatrix-Methode<br />
Legt den Inhalt einer Zelle fest, die durch ihre Zeilen- und Spaltenkoordinaten definiert wird.<br />
Syntax<br />
[VB]<br />
Public Sub set_TextMatrix(ByVal r As Integer, ByVal c As Integer, ByVal s As String)<br />
[C#]<br />
public void set_TextMatrix ( System.Int32 r , System.Int32 c , System.String s )<br />
[Delphi]<br />
procedure set_TextMatrix(r: Integer; c: Integer; s: String);<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)
564 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Cell-Klassen<br />
Alle Cell-Mitglieder<br />
Cell-Eigenschaften<br />
Item Ermittelt oder legt die Daten in einer Tabellenzelle fest.<br />
Cell-Eigenschaften<br />
Item-Eigenschaft (Cell)<br />
Ermittelt oder legt die Daten in einer Tabellenzelle fest.<br />
Syntax<br />
[VB]<br />
Default Public-Eigenschaft Item(ByVal setting As C1.Win.<strong>C1FlexGrid</strong>.Classic.CellPropertySettings, ByVal<br />
row As Integer, ByVal col As Integer) As Object<br />
Default Public-Eigenschaft Item(ByVal setting As C1.Win.<strong>C1FlexGrid</strong>.Classic.CellPropertySettings, ByVal<br />
row1 As Integer, ByVal col1 As Integer, ByVal row2 As Integer, ByVal col2 As Integer) As Object<br />
[C#]<br />
public object this [CellPropertySettings setting, int row, int col]<br />
public object this [CellPropertySettings setting, int row1, int col1, int row2, int col2]<br />
[Delphi]<br />
property Item(setting: CellPropertySettings; row: Integer, col: Integer): Object;<br />
property Item(setting: CellPropertySettings; row1: Integer, col1: Integer, row2: Integer, col2: Integer):<br />
Object;<br />
Schauen Sie ferner unter<br />
<strong>C1FlexGrid</strong>-Klasse (Seite 109)<br />
<strong>C1FlexGrid</strong>Classic-Klasse (Seite 450)<br />
Column-Klasse (Seite 339)<br />
Row-Klasse (Seite 324)<br />
<strong>C1FlexGrid</strong>Classic-Aufzählungen<br />
AlignmentSettings-Aufzählung<br />
Legt den Typ der Ausrichtung fest.
Syntax<br />
[VB]<br />
Public enum AlignmentSettings<br />
[C#]<br />
public sealed enum AlignmentSettings : System.Enum<br />
[Delphi]<br />
AllowUserResizeSettings-Aufzählung · 565<br />
type AlignmentSettings = (flexAlignLeftTop, flexAlignLeftCenter, flexAlignLeftBottom,<br />
flexAlignCenterTop, flexAlignCenterCenter, flexAlignCenterBottom, flexAlignRightTop,<br />
flexAlignRightCenter, flexAlignRightBottom, flexAlignGeneral);<br />
Bemerkungen<br />
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der CellAlignment, get_ColAlignment<br />
und get_FixedAlignment in der <strong>C1FlexGrid</strong>Classic-Steuerung festzulegen.<br />
Mitgliedsname Beschreibung<br />
flexAlignLeftTop Richtet Text links oben aus.<br />
flexAlignLeftCenter Richtet Text links zentriert aus.<br />
flexAlignLeftBottom Richtet Text links unten aus.<br />
flexAlignCenterTop Richtet Text zentriert oben aus.<br />
flexAlignCenterCenter Richtet Text zentriert aus.<br />
flexAlignCenterBottom Richtet Text zentriert unten aus.<br />
flexAlignRightTop Richtet Text rechts oben aus.<br />
flexAlignRightCenter Richtet Text rechts zentriert aus.<br />
flexAlignRightBottom Richtet Text rechts unten aus.<br />
flexAlignGeneral Richtet Text links und Zahlen und Daten rechts aus.<br />
AllowUserResizeSettings-Aufzählung<br />
Legt fest, in welchen Bereichen der Tabelle die Größe verändert werden darf.<br />
Syntax<br />
[VB]<br />
Public enum AllowUserResizeSettings<br />
[C#]<br />
public sealed enum AllowUserResizeSettings : System.Enum<br />
[Delphi]<br />
type AllowUserResizeSettings = (flexResizeNone, flexResizeColumns, flexResizeRows, flexResizeBoth,<br />
flexResizeBothUniform, flexResizeRowsUniform);
566 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Bemerkungen<br />
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der AllowUserResizing-Eigenschaft in<br />
der <strong>C1FlexGrid</strong>Classic-Steuerung festzulegen.<br />
Mitgliedsname Beschreibung<br />
flexResizeNone<br />
Der Nutzer kann die Größe von Zeilen und Spalten nicht<br />
verändern.<br />
flexResizeColumns Der Nutzer kann die Spaltenbreite verändern.<br />
flexResizeRows Der Nutzer kann die Zeilenhöhe verändern.<br />
flexResizeBoth Der Nutzer kann die Größe von Zeilen und Spalten verändern.<br />
flexResizeBothUniform Der Nutzer kann die Größe von Zeilen und Spalten verändern.<br />
flexResizeRowsUniform<br />
AutoSizeSettings-Aufzählung<br />
Wenn die Zeilenhöhe geändert wird, dann wird diese Höhe auf<br />
alle Zeilen angewendet.<br />
Legt fest, ob AutoSizeMode Spaltenbreiten und Zeilenhöhen an den Zellinhalten ausrichtet.<br />
Syntax<br />
[VB]<br />
Public enum AutoSizeSettings<br />
[C#]<br />
public sealed enum AutoSizeSettings : System.Enum<br />
[Delphi]<br />
type AutoSizeSettings = (flexAutoSizeColWidth, flexAutoSizeRowHeight);<br />
Bemerkungen<br />
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der AutoSizeMode-Eigenschaft in der<br />
<strong>C1FlexGrid</strong>Classic-Steuerung festzulegen.<br />
Mitgliedsname Beschreibung<br />
flexAutoSizeColWidth Der Nutzer kann die Breite von Spalten verändern.<br />
flexAutoSizeRowHeight Der Nutzer kann die Höhe von Zeilen verändern.<br />
CellCheckedSettings-Aufzählung<br />
Legt den aktuellen Zustand eines Kontrollkästchens in einer Zelle oder in einem Auswahlbereich fest.<br />
Syntax<br />
[VB]<br />
Public enum CellCheckedSettings
[C#]<br />
public sealed enum CellCheckedSettings : System.Enum<br />
[Delphi]<br />
type CellCheckedSettings = (flexNoCheckbox, flexChecked, flexUnchecked);<br />
Bemerkungen<br />
CellPropertySettings-Aufzählung · 567<br />
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der CellChecked-Eigenschaft in der<br />
<strong>C1FlexGrid</strong>Classic-Steuerung festzulegen.<br />
Mitgliedsname Beschreibung<br />
flexNoCheckbox Die Zelle besitzt kein Kontrollkästchen. (Standardeinstellung)<br />
flexChecked Die Zelle besitzt ein Kontrollkästchen mit Häkchen.<br />
flexUnchecked Die Zelle besitzt ein Kontrollkästchen ohne Häkchen.<br />
CellPropertySettings-Aufzählung<br />
Legt fest, wie ein Kontrollkästchen in einer Zelle erscheint.<br />
Syntax<br />
[VB]<br />
Public enum CellPropertySettings<br />
[C#]<br />
public sealed enum CellPropertySettings: System.Enum<br />
[Delphi]<br />
type CellPropertySettings = (flexChecked, flexNoCheckbox, flexTSChecked, flexTSGrayed,<br />
flexTSUnchecked, flexUnchecked);<br />
Bemerkungen<br />
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der get_Cell und set_Cell-Methoden und<br />
der Item-Eigenschaft in der <strong>C1FlexGrid</strong>Classic-Steuerung festzulegen.<br />
Mitgliedsname Beschreibung<br />
flexChecked Die Zelle hat ein Kontrollkästchen mit einem Häkchen drin.<br />
flexNoCheckbox Die Zelle hat kein Kontrollkästchen.<br />
flexTSChecked Die Zelle hat ein drei-Zustands-Kontrollkästchen mit einem Häkchen drin.<br />
flexTSGrayed Die Zelle hat ein drei-Zustands-Kontrollkästchen im grauen Zustand.<br />
flexTSUnchecked Die Zelle hat ein leeres drei-Zustands-Kontrollkästchen.<br />
flexUnchecked Die Zelle hat ein leeres Kontrollkästchen.
568 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
ClearWhatSettings-Aufzählung<br />
Legt fest, was die Clear-Methode entfernen wird.<br />
Syntax<br />
[VB]<br />
Public enum ClearWhatSettings<br />
[C#]<br />
public sealed enum ClearWhatSettings : System.Enum<br />
[Delphi]<br />
type ClearWhatSettings = (flexClearEverything, flexCleartext, flexClearFormatting; flexClearData);<br />
Bemerkungen<br />
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert eines Arguments der Clear-Methode in<br />
der <strong>C1FlexGrid</strong>Classic-Steuerung festzulegen.<br />
Mitgliedsname Beschreibung<br />
flexClearEverything Alles wird aus dem Bereich entfernt.<br />
flexCleartext Nur Text wird aus dem Bereich entfernt.<br />
flexClearFormatting Nur Formatierung wird aus dem Bereich entfernt.<br />
flexClearData Nur Daten im Datenbereich werden aus dem Bereich entfernt.<br />
ClearWhereSettings-Aufzählung<br />
Legt fest, wo die Clear-Methode etwas entfernen wird.<br />
Syntax<br />
[VB]<br />
Public enum ClearWhereSettings<br />
[C#]<br />
public sealed enum ClearWhereSettings : System.Enum<br />
[Delphi]<br />
type ClearWhereSettings = (flexClearEverywhere, flexClearScrollable, flexClearSelection);<br />
Bemerkungen<br />
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert eines Arguments der Clear-Methode in<br />
der <strong>C1FlexGrid</strong>Classic-Steuerung festzulegen.<br />
Mitgliedsname Beschreibung<br />
flexClearEverywhere Entfernt von gesamter Tabelle.<br />
flexClearScrollable Entfernt nur vom scrollbaren Bereich der Tabelle.
flexClearSelection Entfernt vom ausgewählten Bereich.<br />
EditableSettings-Aufzählung<br />
Legt den Bearbeitungszustand in der Tabelle fest.<br />
Syntax<br />
[VB]<br />
Public enum EditableSettings<br />
[C#]<br />
public sealed enum EditableSettings : System.Enum<br />
[Delphi]<br />
type EditableSettings = (flexEDNone, flexEDKbd, flexEDKbdMouse);<br />
Bemerkungen<br />
EditableSettings-Aufzählung · 569<br />
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der Editable-Eigenschaft in der<br />
<strong>C1FlexGrid</strong>Classic-Steuerung festzulegen.<br />
Mitgliedsname Beschreibung<br />
flexEDNone Der Tabelleninhalt kann vom Nutzer nicht bearbeitet werden.<br />
flexEDKbd<br />
flexEDKbdMouse<br />
EllipsisSettings-Aufzählung<br />
Der Nutzer kann den Bearbeitungsmodus initialisieren, wenn er in die<br />
aktuelle Zelle schreibt.<br />
Der Nutzer kann den Bearbeitungsmodus initialisieren, wenn er in die<br />
aktuelle Zelle schreibt oder mit der Maus darauf doppelklickt.<br />
Legt fest, wie lang Zeichenketten in einer Zelle angezeigt werden.<br />
Syntax<br />
[VB]<br />
Public enum EllipsisSettings<br />
[C#]<br />
public sealed enum EllipsisSettings : System.Enum<br />
[Delphi]<br />
type EllipsisSettings = (flexNoEllipsis, flexEllipsisEnd, flexEllipsisPath);<br />
Bemerkungen<br />
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der Ellipsis-Eigenschaft in der<br />
<strong>C1FlexGrid</strong>Classic-Steuerung festzulegen.
570 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Mitgliedsname Beschreibung<br />
flexNoEllipsis<br />
Lange Zeichenketten werden abgeschnitten und es werden keine<br />
Ellipsis-Zeichen angezeigt.<br />
flexEllipsisEnd Ellipsis-Zeichen werden am Ende von langen Zeichenketten angezeigt.<br />
flexEllipsisPath Ellipsis-Zeichen werden in der Mitte von langen Zeichenketten angezeigt.<br />
ExplorerBarSettings-Aufzählung<br />
Legt die Eigenschaften der Spaltenüberschriften fest.<br />
Syntax<br />
[VB]<br />
Public enum ExplorerBarSettings<br />
[C#]<br />
public sealed enum ExplorerBarSettings : System.Enum<br />
[Delphi]<br />
type ExplorerBarSettings = (flexExNone, flexExSort, flexExMove, flexExSortAndMove, flexExSortShow,<br />
flexExSortShowAndMove, flexExMoveRows);<br />
Bemerkungen<br />
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der ExplorerBar-Eigenschaft in der<br />
<strong>C1FlexGrid</strong>Classic-Steuerung festzulegen.<br />
Mitgliedsname Beschreibung<br />
flexExNone Nutzer können Spalten weder sortieren noch verschieben.<br />
flexExSort Nutzer können Spalten sortieren.<br />
flexExMove Nutzer können Spalten verschieben.<br />
flexExSortAndMove Nutzer können Spalten sortieren und verschieben.<br />
flexExSortShow<br />
flexExSortShowAndMove<br />
flexExMoveRows*<br />
Nutzer können Spalten mit einem Klick auf deren Überschirft sortieren. Die<br />
Steuerung zeigt die aktuelle Sortierungsrichtung mit einem Pfeil in der<br />
Spaltenüberschrift an.<br />
Nutzer können Spalten sortieren und verschieben. Die Steuerung zeigt die<br />
aktuelle Sortierungsrichtung mit einem Pfeil in der Spaltenüberschrift an.<br />
Nutzer können Zeilen verschieben, indem sie die fixierten Zellen der<br />
entsprechenden Zeile auf eine neue Position ziehen.<br />
* Die Einstellung flexExMoveRows ist eigentlich ein Flag und kann mit anderen Einstellungen durch eine<br />
„Or“-Anweisung verknüpft werden.
FillStyleSettings-Aufzählung<br />
FillStyleSettings-Aufzählung · 571<br />
Legt fest, ob die Eigenschaften auf die aktuelle Zelle oder die gesamte Auswahl angewendet wird.<br />
Syntax<br />
[VB]<br />
Public enum FillStyleSettings<br />
[C#]<br />
public sealed enum FillStyleSettings : System.Enum<br />
[Delphi]<br />
type FillStyleSettings = (flexFillSingle, flexFillRepeat);<br />
Bemerkungen<br />
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der FillStyle-Eigenschaft in der<br />
<strong>C1FlexGrid</strong>Classic-Steuerung festzulegen.<br />
Mitgliedsname Beschreibung<br />
flexFillSingle<br />
flexFillRepeat<br />
GridStyleSettings-Aufzählung<br />
Das Setzen der Text- oder einer beliebigen Zellformatierungseigenschaft betrifft nur<br />
die aktuelle Zelle.<br />
Das Setzen der Text- oder einer beliebigen Zellformatierungseigenschaft betrifft den<br />
gesamten, aktuell ausgewählten Bereich.<br />
Legt das Linienformat der Gitternetzlinien fest.<br />
Syntax<br />
[VB]<br />
Public enum GridStyleSettings<br />
[C#]<br />
public sealed enum GridStyleSettings : System.Enum<br />
[Delphi]<br />
type GridStyleSettings = (flexGridNone, flexGridFlat, flexGridInset, flexGridRaised, flexGridFlatHorz,<br />
flexGridInsetHorz, flexGridRaisedHorz, flexGridSkipHorz, flexGridFlatVert, flexGridInsetVert,<br />
flexGridRaisedVert, flexGridSkipVert, flexGridExplorer, flexGridExcel);<br />
Bemerkungen<br />
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der GridLines- und GridLinesFixed-<br />
Eigenschaften in der <strong>C1FlexGrid</strong>Classic-Steuerung festzulegen.
572 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Mitgliedsname Beschreibung<br />
flexGridNone Zeichnet keine Gitternetzlinien zwischen Zellen.<br />
flexGridFlat<br />
Zeichnet flache Linien mit der Farbe und der Breite aus den GridColor- und<br />
GridLineWidth-Eigenschaften.<br />
flexGridInset Zeichnet eingelassene Linien zwischen Zellen.<br />
flexGridRaised Zeichnet herausgehobene Linien zwischen Zellen.<br />
flexGridFlatHorz Zeichnet flache Linien zwischen Zeilen und keine Linien zwischen Spalten.<br />
flexGridInsetHorz<br />
flexGridRaisedHorz<br />
Zeichnet eingelassene Linien zwischen Zeilen und keine Linien zwischen<br />
Spalten.<br />
Zeichnet herausgehobene Linien zwischen Zeilen und keine Linien zwischen<br />
Spalten<br />
flexGridSkipHorz Zeichnet eingelassene Linien um jede zweite Zeile.<br />
flexGridFlatVert Zeichnet flache Linien zwischen Spalten und keine Linien zwischen Zeilen.<br />
flexGridInsetVert<br />
flexGridRaisedVert<br />
Zeichnet eingelassene Linien zwischen Spalten und keine Linien zwischen<br />
Zeilen.<br />
Zeichnet herausgehobene Linien zwischen Spalten und keine Linien zwischen<br />
Zeilen.<br />
flexGridSkipVert Zeichnet eingelassene Linien um jede zweite Spalte.<br />
flexGridExplorer Zeichnet schaltflächenähnliche Rahmen um jede Zelle.<br />
flexGridExcel<br />
MergeSettings-Aufzählung<br />
Legt fest, wie Zellen verbunden werden.<br />
Syntax<br />
[VB]<br />
Public enum MergeSettings<br />
[C#]<br />
Zeichnet schaltflächenähnliche Rahmen um jede Zelle und markiert die<br />
Überschriften für die aktuelle Auswahl. Diese Einstellung sollte nur für die<br />
GridLinesFixed-Eigenschaft verwendet werden.<br />
public sealed enum MergeSettings : System.Enum<br />
[Delphi]<br />
type MergeSettings = (flexMergeNever, flexMergeFree, flexMergeRestrictRows,<br />
flexMergeRestrictColumns, flexMergeRestrictAll, flexMergeFixedOnly, flexMergeSpill,<br />
flexMergeOutline);<br />
Bemerkungen<br />
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der MergeCells-Eigenschaft in der<br />
<strong>C1FlexGrid</strong>Classic-Steuerung festzulegen.
Mitgliedsname Beschreibung<br />
flexMergeNever Zellen nicht verbinden.<br />
flexMergeFree<br />
OutlineBarSettings-Aufzählung · 573<br />
Angrenzende Zellen mit gleichem Inhalt verbinden, wenn diese sich in<br />
Zeilen mit RowMerge=TRUE oder Spalten mit MergeCol=TRUE befinden.<br />
flexMergeRestrictRows Zeilen verbinden, wenn die Zellen darüber auch verbunden sind.<br />
flexMergeRestrictColumns Spalten verbinden, wenn die Zellen links davon auch verbunden sind.<br />
flexMergeRestrictAll<br />
flexMergeFixedOnly<br />
Zellen verbinden, wenn die Zellen darüber und links davon auch<br />
verbunden sind.<br />
Nur fixierte Zellen verbinden. Diese Einstellung ist für komplexe<br />
Überschriften sinnvoll, ohne dabei die Datenzellen selbst zu verbinden.<br />
flexMergeSpill Langen Einträgen erlauben, in leere, angrenzende Zellen überzugehen.<br />
flexMergeOutline<br />
OutlineBarSettings-Aufzählung<br />
Einträgen in Zwischensummenzeilen erlauben, in leere, angrenzende<br />
Zellen überzugehen. Diese Einstellung ist sinnvoll, wenn Sie nur<br />
Knotennamen in den Gliederungsknoten anzeigen wollen und die Daten in<br />
regulären Zeilen stehen.<br />
Legt das Format der Gliederungsleiste, wie in der OutlineBar-Eigenschaft definiert, fest.<br />
Syntax<br />
[VB]<br />
Public enum OutlineBarSettings<br />
[C#]<br />
public sealed enum OutlineBarSettings: System.Enum<br />
[Delphi]<br />
type OutlineBarSettings = (flexOutlineBarComplete, flexOutlineBarCompleteLeaf, flexOutlineBarNone,<br />
flexOutlineBarSimple, flexOutlineBarSimpleLeaf, flexOutlineBarSymbols, flexOutlineBarSymbolsLeaf);<br />
Bemerkungen<br />
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der OutlineBar-Eigenschaft in der<br />
<strong>C1FlexGrid</strong>Classic-Steuerung festzulegen.<br />
Mitgliedsname Beschreibung<br />
flexOutlineBarComplete<br />
flexOutlineBarCompleteLeaf<br />
Der vollständige Gliederungsbaum und eine Schaltflächenzeile darüber<br />
wird angezeigt. Schaltflächen werden nur angezeigt, wenn die<br />
Gliederungsleiste in einer fixierten Spalte steht.<br />
Ähnlich der flexOutlineBarComplete, aber leere Knoten werden ohne<br />
Symbol angezeigt.<br />
flexOutlineBarNone Die Gliederungsleiste wird nicht angezeigt.
574 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
flexOutlineBarSimple<br />
flexOutlineBarSimpleLeaf<br />
Der vollständige Gliederungsbaum aber keine Schaltflächenzeile wird<br />
angezeigt.<br />
Ähnlich der flexOutlineBarSimple, aber leere Knoten werden ohne<br />
Symbol angezeigt.<br />
flexOutlineBarSymbols Gliederungssymbole, aber keine Verknüpfungslinien werden angezeigt.<br />
flexOutlineBarSymbolsLeaf<br />
PictureAlignmentSettings-Aufzählung<br />
Legt fest, wie Grafiken in Zellen ausgerichtet werden.<br />
Syntax<br />
[VB]<br />
Public enum PictureAlignmentSettings<br />
[C#]<br />
public sealed enum PictureAlignmentSettings : System.Enum<br />
[Delphi]<br />
Ähnlich der flexOutlineBarSymbols, aber leere Knoten werden ohne<br />
Symbol angezeigt.<br />
type PictureAlignmentSettings = (flexPicAlignLeftTop, flexPicAlignLeftCenter, flexPicAlignLeftBottom,<br />
flexPicAlignCenterTop, flexPicAlignCenterCenter, flexPicAlignCenterBottom, flexPicAlignRightTop,<br />
flexPicAlignRightCenter, flexPicAlignRightBottom, flexPicAlignStretch, flexPicAlignTile);<br />
Bemerkungen<br />
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der CellPictureAlignment-Eigenschaft in<br />
der <strong>C1FlexGrid</strong>Classic-Steuerung festzulegen.<br />
Mitgliedsname Beschreibung<br />
flexPicAlignLeftTop Richtet Grafiken links oben aus.<br />
flexPicAlignLeftCenter Richtet Grafiken links zentriert aus.<br />
flexPicAlignLeftBottom Richtet Grafiken links unten aus.<br />
flexPicAlignCenterTop Richtet Grafiken zentriert oben aus.<br />
flexPicAlignCenterCenter Richtet Grafiken zentriert aus.<br />
flexPicAlignCenterBottom Richtet Grafiken zentriert unten aus.<br />
flexPicAlignRightTop Richtet Grafiken rechts oben aus.<br />
flexPicAlignRightCenter Richtet Grafiken rechts zentriert aus.<br />
flexPicAlignRightBottom Richtet Grafiken rechts unten aus.<br />
flexPicAlignStretch Streckt das Bild, damit es die Zelle ausfüllt.<br />
flexPicAlignTile<br />
Ordnet die Grafik nebeneinander an, um die Zelle<br />
auszufüllen.
RedrawSettings-Aufzählung<br />
Legt fest, ob die Tabelle ihre Inhalte zeichnen soll.<br />
Syntax<br />
[VB]<br />
Public enum RedrawSettings<br />
[C#]<br />
public sealed enum RedrawSettings : System.Enum<br />
[Delphi]<br />
type RedrawSettings = (flexRDBuffered, flexRDDirect, flexRDNone);<br />
Bemerkungen<br />
RedrawSettings-Aufzählung · 575<br />
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der Redraw-Eigenschaft in der<br />
<strong>C1FlexGrid</strong>Classic-Steuerung festzulegen.<br />
Mitgliedsname Beschreibung<br />
flexRDBuffered<br />
flexRDDirect<br />
Die Tabelle zeichnet ihren Inhalt in einem off-screen Puffer und transferiert das<br />
komplette Abbild auf den Bildschirm. Dieser Modus ist etwas langsamer als<br />
flexRDDirect, aber er verhindert das Flackern des Bildschirms.<br />
Die Tabelle zeichnet ihren Inhalt direkt auf den Bildschirm. Dies ist der schnellste<br />
Modus für das Zeichnen der Tabelleninhalte, dafür kann gelegentlich aber ein leichtes<br />
Flackern auftreten.<br />
flexRDNone Die Tabelle zeichnet sich nicht selbst neu.<br />
SelModeSettings-Aufzählung<br />
Legt fest, wie Auswahlen getroffen werden können.<br />
Syntax<br />
[VB]<br />
Public enum SelModeSettings<br />
[C#]<br />
public sealed enum SelModeSettings: System.Enum<br />
[Delphi]<br />
type SelModeSettings = (flexSelectionByColumn, flexSelectionByRow, flexSelectionFree,<br />
flexSelectionListBox);<br />
Bemerkungen<br />
Verwenden Sie die Mitglieder dieser Aufzählung um den Wert der SelectionMode-Eigenschaft in der<br />
<strong>C1FlexGrid</strong>Classic-Steuerung festzulegen.
576 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
Mitgliedsname Beschreibung<br />
flexSelectionByColumn<br />
flexSelectionByRow<br />
Zwingt die Auswahl, sich auf die gesamte Spalte auszuweiten. Dies ist für<br />
Diagrammbereiche oder zu sortierende Felder nützlich.<br />
Zwingt die Auswahl, sich auf die gesamte Zeile auszuweiten. Dies ist für die<br />
Implementierung von datensatzbasierender Anzeige nützlich.<br />
flexSelectionFree Auswahlen können wie üblich getroffen werden.<br />
flexSelectionListBox<br />
SortSettings-Aufzählung<br />
Legt fest, wie eine Spalte sortiert wird.<br />
Syntax<br />
[VB]<br />
Public enum SortSettings<br />
[C#]<br />
public sealed enum SortSettings : System.Enum<br />
[Delphi]<br />
Ähnlich wie flexSelectionByRow, aber es können auch unterbrochene<br />
Auswahlen getroffen werden. Strg-Taste halten und mit der Maus klicken<br />
schaltet die Auswahl für eine einzelne Zeile um. Die Maus über eine Gruppe<br />
von Zeilen zu ziehen, schaltet deren Auswahlzustand um.<br />
type SortSettings = (flexSortNone, flexSortGenericAscending, flexSortGenericDescending,<br />
flexSortNumericAscending, flexSortNumericDescending, flexSortStringNoCaseAscending,<br />
flexSortStringNoCaseDescending, flexSortStringAscending, flexSortStringDescending, flexSortCustom,<br />
flexSortUseColSort);<br />
Bemerkungen<br />
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der Sort-Eigenschaft in der<br />
<strong>C1FlexGrid</strong>Classic-Steuerung festzulegen.<br />
Mitgliedsname Beschreibung<br />
flexSortNone<br />
Ignoriert die Spalte, wenn sortiert wird. Diese Einstellung ist<br />
nützlich, wenn Sie diese der Cols-Eigenschaft einer Spalte<br />
zuordnen und dann Sort auf flexSortUseColSort stellen.<br />
flexSortGenericAscending Sortiert Zeichenketten und Zahlen aufsteigend.<br />
flexSortGenericDescending Sortiert Zeichenketten und Zahlen absteigend.<br />
flexSortNumericAscending Sortiert Zahlen aufsteigend.<br />
flexSortNumericDescending Sortiert Zahlen absteigend.<br />
flexSortStringNoCaseAscending<br />
flexSortStringNoCaseDescending<br />
Sortiert Zeichenketten ohne Rücksicht auf Groß- und<br />
Kleinschreibung aufsteigend.<br />
Sortiert Zeichenketten ohne Rücksicht auf Groß- und<br />
Kleinschreibung absteigend.<br />
flexSortStringAscending Sortiert Zeichenketten aufsteigend.
Mitgliedsname Beschreibung<br />
flexSortStringDescending Sortiert Zeichenketten absteigend.<br />
flexSortCustom<br />
flexSortUseColSort<br />
TabBehaviorSettings-Aufzählung<br />
TabBehaviorSettings-Aufzählung · 577<br />
Startet ein Compare-Ereignis und verwendet den Rückgabewert,<br />
um eine Spalte zu sortieren.<br />
Mit dieser Einstellung können Sie verschiedene<br />
Sortierungsrichtungen für einzelne Spalten mit der ColSort-<br />
Eigenschaft einstellen.<br />
Legt die Flussrichtung der Steuerungen fest, wenn die Tabulator-Taste gedrückt wird.<br />
Syntax<br />
[VB]<br />
Public enum TabBehaviorSettings<br />
[C#]<br />
public sealed enum TabBehaviorSettings : System.Enum<br />
[Delphi]<br />
type TabBehaviorSettings = (flexTabControls, flexTabCells);<br />
Bemerkungen<br />
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der TabBehavior-Eigenschaft in der<br />
<strong>C1FlexGrid</strong>Classic-Steuerung festzulegen.<br />
Mitgliedsname Beschreibung<br />
flexTabControls<br />
flexTabCells<br />
TextStyleSettings-Aufzählung<br />
Legt das Textformat fest.<br />
Syntax<br />
[VB]<br />
Public enum TextStyleSettings<br />
[C#]<br />
Die Tabulator-Taste wird verwendet, um zur nächsten oder vorhergehenden<br />
Steuerung im Formular zu gehen.<br />
Die Tabulator-Taste wird verwendet, um zur nächsten oder vorhergehenden Zelle auf<br />
der Steuerung zu gehen.<br />
public sealed enum TextStyleSettings : System.Enum
578 · <strong>C1FlexGrid</strong>Classic-Referenzverzeichnis<br />
[Delphi]<br />
type TextStyleSettings = (flexTextFlat, flexTextRaised, flexTextInset, flexTextRaisedLight,<br />
flexTextInsetLight);<br />
Bemerkungen<br />
Verwenden Sie die Mitglieder dieser Aufzählung, um den Wert der CellTextStyle, TextStyle und<br />
TextStyleFixed-Eigenschaften in der <strong>C1FlexGrid</strong>Classic-Steuerung festzulegen.<br />
Mitgliedsname Beschreibung<br />
flexTextFlat Zeichnet Text normal.<br />
flexTextRaised Zeichnet Text mit einem stark gehobenen 3D-Effekt.<br />
flexTextInset Zeichnet Text mit einem stark eingelassenen 3D-Effekt.<br />
flexTextRaisedLight Zeichnet Text mit einem schwach gehobenen 3D-Effekt.<br />
flexTextInsetLight Zeichnet Text mit einem schwach eingelassenen 3D-Effekt.
Index<br />
A<br />
AddItem-Methode 174<br />
Add-Method<br />
von ColumnCollection 325<br />
Add-Methode 315, 325, 380<br />
von CellStyleCollection 380<br />
von RowCollection 315<br />
AddNode-Methode 409<br />
AfterAddRow-Ereignis 221<br />
AfterCollapse-Ereignis 221<br />
AfterDataRefresh-Ereignis 222<br />
AfterDeleteRow-Ereignis 223<br />
AfterDragColumn-Ereignis 223<br />
AfterDragRow-Ereignis 224<br />
AfterEdit-Ereignis 225<br />
AfterFreezeColumn-Ereignis 225<br />
AfterFreezeRow-Ereignis 226<br />
AfterResizeColumn-Ereignis 227<br />
AfterResizeRow-Ereignis 227<br />
AfterRowColChange-Ereignis 2<strong>28</strong><br />
AfterScroll-Ereignis 229<br />
AfterSelChange-Ereignis 231<br />
AfterSort-Ereignis 231<br />
Aggregate-Methode 176<br />
AlignmentSettings-Aufzählung 574<br />
AllowAddNew-Eigenschaft 117<br />
AllowBigSelection-Eigenschaft 464<br />
AllowDelete-Eigenschaft 118<br />
AllowDragging-Eigenschaft 119, 331, 348, 465<br />
von <strong>C1FlexGrid</strong>Classic 465<br />
von Column 348<br />
von Row 331<br />
AllowEditing-Eigenschaft 120, 332, 348, 466<br />
von <strong>C1FlexGrid</strong> 120<br />
von <strong>C1FlexGrid</strong>Classic 466<br />
von Column 348<br />
von Row 332<br />
AllowFreezing-Eigenschaft 120<br />
AllowMerging-Eigenschaft 121, 332, 349, 467<br />
von <strong>C1FlexGrid</strong>Classic 467<br />
von Column 349<br />
von Row 332<br />
AllowResizing-Eigenschaft 122, 333, 349, 468<br />
von <strong>C1FlexGrid</strong>Classic 468<br />
von Column 349<br />
von Row 333<br />
AllowSelection-Eigenschaft 469<br />
AllowSorting-Eigenschaft 124, 350, 470<br />
von <strong>C1FlexGrid</strong> 124<br />
von <strong>C1FlexGrid</strong>Classic 470<br />
von Column 350<br />
AllowUserResizeSettings-Aufzählung 575<br />
AllowUserResizing-Eigenschaft 471<br />
Alternate-Eigenschaft 374<br />
AutoClipboard-Eigenschaft 125<br />
AutoResize-Eigenschaft 126<br />
AutoSearchDelay-Eigenschaft 127<br />
AutoSearch-Eigenschaft 126<br />
AutoSizeCol-Methode 178<br />
AutoSizeCols-Methode 179<br />
AutoSize-Methode 535<br />
AutoSizeMode-Eigenschaft 472<br />
AutoSizeRow-Methode 180<br />
AutoSizeRows-Methode 180<br />
AutoSizeSettings-Aufzählung 576<br />
B<br />
BackColorAlternate-Eigenschaft 473<br />
BackColorBkg-Eigenschaft 473<br />
BackColor-Eigenschaft 386<br />
BackColorFixed-Eigenschaft 474<br />
BackColorSel-Eigenschaft 474<br />
BackgroundImage-Eigenschaft 475<br />
BeforeAddRow-Ereignis 232<br />
BeforeAutoSizeColumn-Ereignis 233<br />
BeforeAutoSizeRow-Ereignis 233<br />
BeforeCollapse-Ereignis 234<br />
BeforeDeleteRow-Ereignis 237<br />
BeforeDragColumn-Ereignis 237<br />
BeforeDragRow-Ereignis 238<br />
BeforeEdit-Ereignis 239<br />
BeforeFreezeColumn-Ereignis 241<br />
BeforeFreezeRow-Ereignis 241<br />
BeforeMouseDown-Ereignis 242<br />
BeforeMouseDownEventArgs-Klasse <strong>28</strong>9<br />
BeforeMouseDownEventHandler-Delegierer <strong>28</strong>1<br />
BeforePageBreak-Ereignis 243<br />
BeforeResizeColumn-Ereignis 245<br />
BeforeResizeRow-Ereignis 245<br />
BeforeRowColChange-Ereignis 246<br />
BeforeScroll-Ereignis 247<br />
BeforeScrollTip-Ereignis 248<br />
BeforeSelChange-Ereignis 249<br />
Index · 579
580 · Index<br />
BeforeSort-Ereignis 250<br />
BeginPrint-Ereignis 2<strong>51</strong><br />
Border-Eigenschaft 387<br />
BorderStyle-Eigenschaft 1<strong>28</strong><br />
Bottom-Eigenschaft 333<br />
BottomRow-Eigenschaft 127, 298<br />
von CellRange 298<br />
BuildString-Methode 381, 397<br />
von CellStyle 397<br />
C<br />
CancelAddRow-Ereignis 2<strong>51</strong><br />
Caption-Eigenschaft 334, 350<br />
von Row 334<br />
CellAlignment-Eigenschaft 475<br />
CellBackColor-Eigenschaft 477<br />
CellButtonClick-Ereignis 252<br />
CellButtonImage-Eigenschaft 1<strong>28</strong>, 478<br />
von <strong>C1FlexGrid</strong>Classic 478<br />
CellButtonPicture-Eigenschaft 479<br />
CellChanged-Ereignis 252<br />
CellChecked-Eigenschaft 479<br />
CellCheckedSettings-Aufzählung 576<br />
Cell-Eigenschaft 475<br />
CellFontBold-Eigenschaft 482<br />
CellFont-Eigenschaft 481<br />
CellFontItalic-Eigenschaft 482<br />
CellFontName-Eigenschaft 483<br />
CellFontSize-Eigenschaft 483<br />
CellFontStrikeThru-Eigenschaft 484<br />
CellFontUnderline-Eigenschaft 485<br />
CellForeColor-Eigenschaft 485<br />
CellHeight-Eigenschaft 486<br />
CellLeft-Eigenschaft 486<br />
CellPictureAlignment-Eigenschaft 487<br />
CellPicture-Eigenschaft 487<br />
CellPropertySettings-Aufzählung 577<br />
CellTextStyle-Eigenschaft 488<br />
CellTop-Eigenschaft 489<br />
CellWidth-Eigenschaft 490<br />
ChangeEdit-Ereignis 253<br />
CheckBox-Eigenschaft 298<br />
Children-Eigenschaft 404<br />
Clear-Methode 181, 345, 371, 382, 398, 536<br />
von <strong>C1FlexGrid</strong> 181<br />
von CellStyle 398<br />
von CellStyleCollection 382<br />
von Column 371<br />
von Row 345<br />
ClearUnused-Methode 382<br />
ClearWhatSettings-Aufzählung 578<br />
ClearWhereSettings-Aufzählung 578<br />
Clip-Eigenschaft 129, 299<br />
von CellRange 299<br />
ClipSeparators-Eigenschaft 130<br />
Col-Eigenschaft 131<br />
Collapsed-Eigenschaft 405<br />
Color-Eigenschaft 402<br />
Cols-Eigenschaft 132, 490<br />
von <strong>C1FlexGrid</strong>Classic 490<br />
ColSel-Eigenschaft 132<br />
ColumnCollection-Eigenschaft 491<br />
Column-Eigenschaft 307, 415<br />
von HitTestInfo 307<br />
ColWidthMax-Eigenschaft 491<br />
ColWidthMin-Eigenschaft 492<br />
ComboCloseUp-Ereignis 256<br />
ComboCount-Eigenschaft 493<br />
ComboDropDown-Ereignis 256<br />
ComboIndex-Eigenschaft 493<br />
ComboItem-Methode 538<br />
ComboList-Eigenschaft 133, 3<strong>51</strong>, 387<br />
von CellStyle 387<br />
von Column 3<strong>51</strong><br />
ContainsCol-Methode 306<br />
Contains-Methode 305, 315, 325, 383<br />
von CellRange 305<br />
von CellStyleCollection 383<br />
von ColumnCollection 325<br />
von RowCollection 315<br />
ContainsRow-Methode 306<br />
Count-Eigenschaft 310, 321, 375<br />
von CellStyleCollection 375<br />
von ColumnCollection 321<br />
von RowCollection 310<br />
CreateImage-Methode 182<br />
CursorCell-Eigenschaft 136<br />
CustomComparer-Eigenschaft 136<br />
D<br />
DataDisplay-Eigenschaft 300<br />
Data-Eigenschaft 299, 405<br />
von CellRange 299<br />
von Node 405<br />
DataIndex-Eigenschaft 334, 3<strong>51</strong><br />
von Column 3<strong>51</strong><br />
von Row 334<br />
DataMap-Eigenschaft 352, 388<br />
von CellStyle 388<br />
von Column 352<br />
DataMember-Eigenschaft 137<br />
DataSource-Eigenschaft 137, 335
von <strong>C1FlexGrid</strong> 137<br />
von Row 335<br />
DataType-Eigenschaft 353<br />
DefaultSize-Eigenschaft 311, 321<br />
von ColumnCollection 321<br />
von RowCollection 311<br />
DefinedElements-Eigenschaft 388<br />
Direction-Eigenschaft 401<br />
Display-Eigenschaft 389<br />
DoubleBuffer-Eigenschaft 140<br />
DragMode-Eigenschaft 141<br />
DragRowColEventArgs-Klasse <strong>28</strong>9<br />
DragRowColEventHandler-Delegierer <strong>28</strong>2<br />
DrawCell-Methode 184<br />
DrawMode-Eigenschaft 141<br />
DropMode-Eigenschaft 142<br />
E<br />
Editable-Eigenschaft 493<br />
EditableSettings-Aufzählung 579<br />
EditCell-Methode 538<br />
EditMask-Eigenschaft 143, 355, 390<br />
von <strong>C1FlexGrid</strong> 143<br />
von Column 355<br />
EditOptions-Eigenschaft 146<br />
Editor-Eigenschaft 144, 335, 356, 375, 389<br />
von <strong>C1FlexGrid</strong> 144<br />
von CellStyle 389<br />
von CellStyleCollection 375<br />
von Column 356<br />
von Row 335<br />
EditSelLength-Eigenschaft 494<br />
EditSelStart-Eigenschaft 496<br />
EditSelText-Eigenschaft 497<br />
EditText-Eigenschaft 498<br />
EditWindow-Eigenschaft 499<br />
Ellipsis-Eigenschaft 500<br />
EllipsisSettings-Aufzählung 579<br />
EmptyArea-Eigenschaft 376<br />
EndPrint-Ereignis 257<br />
EnsureVisible-Methode 410<br />
EnterCell-Ereignis 258<br />
Expanded-Eigenschaft 406<br />
ExplorerBar-Eigenschaft 501<br />
ExplorerBarSettings-Aufzählung 580<br />
ExtendLastCol-Eigenschaft 146<br />
F<br />
FillStyle-Eigenschaft 503<br />
FillStyleSettings-Aufzählung 581<br />
FindRow-Methode 185, 539<br />
von <strong>C1FlexGrid</strong>Classic 539<br />
FinishEditing-Methode 186<br />
FixedCols-Eigenschaft 503<br />
Fixed-Eigenschaft 311, 322, 376<br />
von CellStyleCollection 376<br />
von ColumnCollection 322<br />
von RowCollection 311<br />
FixedRows-Eigenschaft 504<br />
Focus-Eigenschaft 377<br />
FocusRect-Eigenschaft 147<br />
FontBold-Eigenschaft 505<br />
Font-Eigenschaft 391<br />
von CellStyle 391<br />
FontItalic-Eigenschaft 505<br />
FontName-Eigenschaft 506<br />
FontSize-Eigenschaft 506<br />
FontStrikeThru-Eigenschaft 507<br />
FontUnderline-Eigenschaft 507<br />
Footer-Eigenschaft 422<br />
FooterFont-Eigenschaft 423<br />
ForeColor-Eigenschaft 391<br />
ForeColorFixed-Eigenschaft 507<br />
ForeColorSel-Eigenschaft 508<br />
Format-Eigenschaft 356, 392<br />
von CellStyle 392<br />
FrozenCols-Eigenschaft 508<br />
Frozen-Eigenschaft 312, 322, 376<br />
von ColumnCollection 322<br />
von RowCollection 312<br />
FrozenRows-Eigenschaft 509<br />
G<br />
get_Cell-Methode 540<br />
get_ColAlignment-Methode 541<br />
get_ColComboList-Methode 542<br />
get_ColData-Methode 542<br />
get_ColDataType-Methode 542<br />
get_ColEditMask-Methode 543<br />
get_ColFormat-Methode 543<br />
get_ColHidden-Methode 544<br />
get_ColIndent-Methode 544<br />
get_ColIndex-Methode 544<br />
get_ColIsVisible-Methode 545<br />
get_ColKey-Methode 545<br />
get_ColPos-Methode 546<br />
get_ColSort-Methode 546<br />
get_ColWidth-Methode 546<br />
get_FixedAlignment-Methode 547<br />
get_IsCollapsed-Methode 547<br />
get_IsSelected-Methode 547<br />
Index · 581
582 · Index<br />
get_IsSubtotal-Methode 548<br />
get_MergeCol-Methode 549<br />
get_MergeRow-Methode 5<strong>51</strong><br />
get_RowData-Methode 553<br />
get_RowHeight-Methode 553<br />
get_RowHidden-Methode 554<br />
get_RowIsVisible-Methode 554<br />
get_RowOutlineLevel-Methode 554<br />
get_RowPos-Methode 555<br />
get_TextMatrix-Methode 557<br />
Get_ValueMatrix-Methode 557<br />
GetCellCheck-Eigenschaft 147<br />
GetCellCheck-Methode 187<br />
GetCellImage-Methode 188<br />
GetCellRange-Methode 189, 410<br />
von Node 410<br />
GetCellRect-Methode 190<br />
GetCellStyleDisplay-Methode 192<br />
GetCellStyle-Methode 191<br />
GetDataDisplay-Methode 193<br />
GetData-Methode 192<br />
GetMergedRange Methode<br />
von <strong>C1FlexGrid</strong> 194<br />
GetMergedRange-Methode 194, 549<br />
GetNode-Methode 411, 5<strong>51</strong><br />
vom <strong>C1FlexGrid</strong>Classic 5<strong>51</strong><br />
GetNodeRow-Methode 552<br />
GetSelection-Methode 555<br />
GetUnboundValue-Ereignis 259<br />
Glyphs-Eigenschaft 148<br />
GridChanged-Ereignis 262<br />
GridChangedEventArgs-Klasse 290<br />
GridChangedEventHandler-Delegierer <strong>28</strong>2<br />
GridColor-Eigenschaft 509<br />
GridColorFixed-Eigenschaft <strong>51</strong>0<br />
GridError-Ereignis 263<br />
GridErrorEventArgs-Klasse 290<br />
GridErrorEventHandler-Delegierer <strong>28</strong>3<br />
GridLines-Eigenschaft <strong>51</strong>0<br />
GridLinesFixed-Eigenschaft <strong>51</strong>1<br />
GridLineWidth-Eigenschaft <strong>51</strong>2<br />
GridStyleSettings-Aufzählung 581<br />
H<br />
Header-Eigenschaft 424<br />
HeaderFont-Eigenschaft 425<br />
HeightDisplay-Eigenschaft 337<br />
Height-Eigenschaft 336<br />
HighLight-Eigenschaft 148, 377<br />
von CellStyleCollection 377<br />
HitTest-Methode 195<br />
I<br />
ImageAlign-Eigenschaft 337, 359, 392<br />
von CellStyle 392<br />
von Column 359<br />
von Row 337<br />
ImageAlignFixed-Eigenschaft 337, 359<br />
von Column 359<br />
von Row 337<br />
ImageAndText-Eigenschaft 360<br />
Image-Eigenschaft 300, 407<br />
von Node 407<br />
ImageMap-Eigenschaft 360, 393<br />
von Column 360<br />
ImageSpacing-Eigenschaft 393<br />
Indent-Eigenschaft 416<br />
Index-Eigenschaft 338, 362<br />
von Column 362<br />
von Row 338<br />
Insert-Methode 316, 326<br />
von ColumnCollection 326<br />
von RowCollection 316<br />
InsertNode-Methode 316<br />
InsertRange-Methode 317, 326<br />
von ColumnCollection 326<br />
von RowCollection 317<br />
Invalidate-Methode 197<br />
IsNew-Eigenschaft 339<br />
IsNode-Eigenschaft 339<br />
IsSingleCell-Eigenschaft 301<br />
IsValid-Eigenschaft 301<br />
Item-Eigenschaft 149, 312, 322, 378, 414, 574<br />
von Cell 574<br />
von CellStyleCollection 378<br />
von ColumnCollection 322<br />
von GridGlyphs 414<br />
von RowCollection 312<br />
K<br />
KeyActionEnter-Eigenschaft 150, <strong>51</strong>3<br />
von <strong>C1FlexGrid</strong>Classic <strong>51</strong>3<br />
KeyActionTab-Eigenschaft 1<strong>51</strong>, <strong>51</strong>3<br />
von <strong>C1FlexGrid</strong>Classic <strong>51</strong>3<br />
KeyDownEdit-Ereignis 264<br />
KeyEditEventArgs-Klasse 291<br />
KeyEditEventHandler-Delegierer <strong>28</strong>3<br />
Key-Eigenschaft 408<br />
KeyPressEdit-Ereignis 265<br />
KeyPressEditEventArgs-Klasse 292<br />
KeyPressEditEventHandler-Delegierer <strong>28</strong>4<br />
KeyUpEdit-Ereignis 266
Klasse<br />
CellBorder-Klasse 401<br />
CellStyleCollection-Klasse 373<br />
CellStyle-Klasse 384<br />
ColumnCollection-Klasse 320<br />
Column-Klasse 346<br />
DragRowColEventArgs-Klasse <strong>28</strong>9<br />
GridChangedEventArgs-Klasse 290<br />
GridErrorEventArgs-Klasse 290<br />
GridGlyphs-Klasse 414<br />
GridPrinter-Klasse 421<br />
GridTree-Klasse 415<br />
HitTestInfo-Klasse 307<br />
KeyEditEventArgs-Klasse 291<br />
KeyPressEditEventArgs-Klasse 292<br />
OwnerDrawCellEventArgs-Klasse 292<br />
RangeEventArgs-Klasse 293<br />
RowColEventArgs-Klasse 294<br />
RowCollection-Klasse 309<br />
Row-Klasse 330<br />
SortColEventArgs-Klasse 294<br />
ValidateEditEventArgs-Klasse 295<br />
Klassen<br />
<strong>C1FlexGrid</strong>-Klasse 109<br />
L<br />
LeaveCell-Ereignis 268<br />
LeftCol-Eigenschaft 153, 302<br />
von CellRange 302<br />
Left-Eigenschaft 362<br />
Level-Eigenschaft 408<br />
LineColor-Eigenschaft 416<br />
LineStyle-Eigenschaft 417<br />
LoadExcel-Methode 198<br />
LoadExcelSheetNames-Methode 199<br />
LoadGrid-Methode 199<br />
M<br />
Margins-Eigenschaft 394<br />
MaxSize-Eigenschaft 313, 323<br />
von ColumnCollection 323<br />
von RowCollection 313<br />
MergeCells-Eigenschaft <strong>51</strong>5<br />
MergeSettings-Aufzählung 582<br />
MergeWith-Methode 398<br />
MinSize-Eigenschaft 313, 324<br />
von ColumnCollection 324<br />
von RowCollection 313<br />
MouseCol-Eigenschaft 154<br />
MouseRow-Eigenschaft 155<br />
Move-Methode 317, 327, 345, 372, 411<br />
von Column 372<br />
von ColumnCollection 327<br />
von Row 345<br />
von RowCollection 317<br />
MoveRange-Methode 318, 327<br />
von ColumnCollection 327<br />
von RowCollection 318<br />
N<br />
Name-Eigenschaft 363, 394<br />
von CellStyle 394<br />
von Column 363<br />
NewRow-Eigenschaft 378<br />
NodeClosedPicture-Eigenschaft <strong>51</strong>9<br />
Node-Eigenschaft 340<br />
NodeImageCollapsed-Eigenschaft 417<br />
NodeImageExpanded-Eigenschaft 418<br />
NodeOpenPicture-Eigenschaft <strong>51</strong>9<br />
Normal-Eigenschaft 379<br />
Normalize-Methode 307<br />
O<br />
OutlineBar-Eigenschaft 520<br />
OutlineBarSettings-Aufzählung 583<br />
OutlineCol-Eigenschaft 521<br />
Outline-Methode 558<br />
OwnerDrawCell-Ereignis 269<br />
OwnerDrawCellEventArgs-Klasse 292<br />
OwnerDrawCellEventHandler-Delegierer <strong>28</strong>4<br />
P<br />
PageCount-Eigenschaft 426<br />
PageNumber-Eigenschaft 425<br />
ParseString-Methode 383, 399<br />
von CellStyle 399<br />
von CellStyleCollection 383<br />
PictureAlignmentSettings-Aufzählung 584<br />
Picture-Eigenschaft 521<br />
PrintDocument-Eigenschaft 426<br />
PrintEventHandler-Delegierer <strong>28</strong>5<br />
PrintGrid-Methode 200, 559<br />
von <strong>C1FlexGrid</strong>Classic 559<br />
PrintPage-Ereignis 273<br />
PrintPageEventHandler-Delegierer <strong>28</strong>5<br />
PrintParameters-Eigenschaft 156<br />
PrintPreviewDialog-Eigenschaft 427<br />
Index · 583
584 · Index<br />
R<br />
r1,c1,r2,c2-Eigenschaft 302<br />
RangeEventArgs-Klasse 293<br />
RangeEventHandler-Delegierer <strong>28</strong>6<br />
Redraw-Eigenschaft 156, 522<br />
von <strong>C1FlexGrid</strong>Classic 522<br />
RedrawSettings-Aufzählung 585<br />
RemoveItem-Methode 202, 560<br />
<strong>C1FlexGrid</strong> 202<br />
von <strong>C1FlexGrid</strong>Classic 560<br />
Remove-Methode 318, 3<strong>28</strong>, 384<br />
von CellStyleCollection 384<br />
von ColumnCollection 3<strong>28</strong><br />
von RowCollection 318<br />
RemoveNode-Methode 412<br />
RemoveRange-Methode 319, 3<strong>28</strong><br />
von ColumnCollection 3<strong>28</strong><br />
von RowCollection 319<br />
Render-Methode 400<br />
RightCol-Eigenschaft 157, 302<br />
von CellRange 302<br />
Right-Eigenschaft 363<br />
RowColChange-Ereignis 273<br />
RowColEventArgs-Klasse 294<br />
RowColEventHandler-Delegierer <strong>28</strong>7<br />
Row-Eigenschaft 158, 308, 409<br />
von HitTestInfo 308<br />
von Node 409<br />
RowHeightMax-Eigenschaft 523<br />
RowHeightMin-Eigenschaft 523<br />
Rows-Eigenschaft 159, 524<br />
von <strong>C1FlexGrid</strong>Classic 524<br />
RowSel-Eigenschaft 159<br />
S<br />
SafeIndex-Eigenschaft 340, 364<br />
von Column 364<br />
von Row 340<br />
SaveExcel-Methode 202<br />
SaveGrid-Methode 204<br />
ScrollBars-Eigenschaft 160<br />
ScrollPosition-Eigenschaft 162<br />
ScrollTips-Eigenschaft 164<br />
ScrollTipText-Eigenschaft 167<br />
ScrollTrack-Eigenschaft 164<br />
Search-Eigenschaft 380<br />
SelChange-Ereignis 274<br />
Selected-Eigenschaft 314, 324, 341, 364<br />
von Column 364<br />
von Row 341<br />
von RowCollection 314<br />
SelectedRow-Methode 561<br />
SelectedRows-Eigenschaft 525<br />
Selection-Eigenschaft 167<br />
SelectionMode-Eigenschaft 168, 526<br />
von <strong>C1FlexGrid</strong>Classic 526<br />
Select-Methode 205, 412<br />
von Node 412<br />
SelModeSettings-Aufzählung 585<br />
set_Cell-Methode 561<br />
set_ColAlignment-Methode 562<br />
set_ColComboList-Methode 563<br />
set_ColData-Methode 564<br />
set_ColDataType-Methode 564<br />
set_ColEditMask-Methode 564<br />
set_ColFormat-Methode 565<br />
set_ColHidden-Methode 565<br />
set_ColImageList-Methode 565<br />
set_ColIndent-Methode 566<br />
set_ColKey-Methode 566<br />
set_ColPosition-Methode 567<br />
set_ColSort-Methode 567<br />
set_ColWidth-Methode 567<br />
set_FixedAlignment-Methode 568<br />
set_IsCollapsed-Methode 568<br />
set_IsSelected-Methode 569<br />
set_IsSubtotal-Methode 569<br />
set_MergeCol-Methode 570<br />
set_MergeRow-Methode 570<br />
set_RowData-Methode 571<br />
set_RowHeight-Methode 571<br />
set_RowHidden-Methode 572<br />
set_RowOutlineLevel-Methode 572<br />
set_RowPosition-Methode 573<br />
set_TextMatrix-Methode 573<br />
SetCellCheck-Eigenschaft 169<br />
SetCellCheck-Methode 208<br />
SetCellImage-Methode 206<br />
SetCellStyle-Methode 207<br />
SetDataBinding-Methode 211<br />
SetData-Methode 209<br />
SetUnboundValue-Ereignis 274<br />
SetupEditor-Ereignis 275<br />
SheetBorder-Eigenschaft 526<br />
ShowButtons-Eigenschaft 169<br />
ShowCell-Methode 212<br />
ShowCursor-Eigenschaft 170<br />
ShowErrors-Eigenschaft 171<br />
Show-Methode 419<br />
ShowSortAt-Methode 212<br />
SortColEventArgs-Klasse 294
SortColEventHandler-Delegierer <strong>28</strong>8<br />
Sort-Eigenschaft 365, 527<br />
von <strong>C1FlexGrid</strong>Classic 527<br />
von Column 365<br />
Sort-Methode 213, 413, 419<br />
von GridTree 419<br />
von Node 413<br />
SortSettings-Aufzählung 586<br />
StartEdit-Ereignis 278<br />
StartEditing-Methode 215<br />
StyleDisplay-Eigenschaft 303, 342, 366<br />
von CellRange 303<br />
von Column 366<br />
von Row 342<br />
Style-Eigenschaft 303, 341, 365, 402, 418<br />
von CellRange 303<br />
von Column 365<br />
von GridTree 418<br />
von Row 341<br />
StyleFixedDisplay-Eigenschaft 367<br />
StyleFixed-Eigenschaft 366<br />
StyleFixedNew-Eigenschaft 367<br />
StyleNew-Eigenschaft 304, 342, 368<br />
von CellRange 304<br />
von Column 368<br />
von Row 342<br />
Styles-Eigenschaft 172, 5<strong>28</strong><br />
von <strong>C1FlexGrid</strong>Classic 5<strong>28</strong><br />
Subtotal-Methode 217<br />
SubTotalPosition-Eigenschaft 172<br />
T<br />
TabBehavior-Eigenschaft 529<br />
TabBehaviorSettings-Aufzählung 587<br />
TextAlign-Eigenschaft 368, 394<br />
von CellStyle 394<br />
von Column 368<br />
TextAlignFixed-Eigenschaft 369<br />
TextDirection-Eigenschaft 395<br />
TextEffect-Eigenschaft 395<br />
Text-Eigenschaft 530<br />
TextStyle-Eigenschaft 531<br />
TextStyleFixed-Eigenschaft 532<br />
TextStyleSettings-Aufzählung 588<br />
Top-Eigenschaft 343<br />
TopRow-Eigenschaft 173, 304<br />
von CellRange 304<br />
TreeColor-Eigenschaft 533<br />
Tree-Eigenschaft 173<br />
Trimming-Eigenschaft 396<br />
Type-Eigenschaft 308<br />
U<br />
von HitTestInfo 308<br />
UserData-Eigenschaft 305, 343, 369, 396<br />
von CellRange 305<br />
von CellStyle 396<br />
von Column 369<br />
von Row 343<br />
V<br />
ValidateEdit-Ereignis 279<br />
ValidateEditEventArgs-Klasse 295<br />
ValidateEditEventHandler-Delegierer <strong>28</strong>8<br />
Value-Eigenschaft 533<br />
Visible-Eigenschaft 344, 370<br />
von Column 370<br />
von Row 344<br />
W<br />
Wallpaper-Eigenschaft 534<br />
WidthDisplay-Eigenschaft 371<br />
Width-Eigenschaft 370, 403<br />
von CellBorder 403<br />
von Column 370<br />
WordWrap-Eigenschaft 397, 535<br />
von <strong>C1FlexGrid</strong>Classic 535<br />
X<br />
X-Eigenschaft 309<br />
von HitTestInfo 309<br />
Y<br />
Y-Eigenschaft 309<br />
von HitTestInfo 309<br />
Index · 585