treeview — u_pbt_treeview #

← Komponentenreferenz · Inhalt des Handbuchs

treeview zeigt Daten als Baum: Knoten, die andere enthalten, über ihren Chevron geöffnet und geschlossen, mit einem Bild, einem Badge, einem Kontrollkästchen mit drei Zuständen und einer Einfach- oder Mehrfachauswahl. Sobald er eine Spalte erhält, wird er zur Baumliste (TreeList): Die erste Spalte trägt den Baum, die anderen zeigen die Felder jedes Knotens, sortierbar per Klick auf ihre Kopfzeile. Ein Zweig kann Kinder versprechen, die er erst beim Öffnen liest; der Benutzer benennt einen Knoten um (F2) und zieht ihn an eine andere Stelle, wobei Ihre Anwendung vorher ablehnen kann; eine Suche behält nur, was passt. Der Baum wird von Hand oder aus einem hierarchischen DataStore gefüllt (eine Zeile nennt ihren Elternknoten) und kann dorthin zurückschreiben, was der Benutzer ändert.

▶ Live ansehen — Demoanwendung, Kachel Tree view: die Vorschau, der zugehörige Code und diese Seite, nebeneinander.

Auf einen Blick #

Schnellstart #

// Two levels : a continent, then its countries (the parent is added first)
uo_tree.of_add_node(/*keys*/ "europe", /*text*/ "Europe")
uo_tree.of_add_node(/*keys*/ "europe/france", /*text*/ "France")
uo_tree.of_add_node(/*keys*/ "europe/italy", /*text*/ "Italy")

// Open the continent : its countries show
uo_tree.of_node(/*keys*/ "europe").ib_expanded = true

// event ue_node_opened of uo_tree : (string as_keys)
// A double click or Enter on a node : your own window shows it
OpenWithParm(w_country, as_keys)

Eine Adresse pro Knoten #

Ein Knoten wird über seine Adresse bezeichnet: die Schlüssel seiner Ebenen, mit / verbunden. "europe" steht oben, "europe/france" in "europe" — der Elternknoten wird zuerst hinzugefügt. Ein Schlüssel ist unter seinem Elternknoten eindeutig: "europe/paris" und "usa/paris" sind zwei Knoten. Eine schon vergebene Adresse, ein unbekannter Elternknoten, eine leere Ebene, ein Schlüssel mit | oder der mit __ beginnt: Das Hinzufügen gibt -5 zurück und of_get_last_error sagt warum. of_insert_node setzt einen Knoten zwischen seine Geschwister (Position ab 1 gezählt), of_move_node verschiebt ihn mit seinem Teilbaum unter einen anderen Elternknoten ("" = ganz oben): Seine Adresse ändert sich, und die an der alten Adresse geholten Handles werden sofort freigegeben (ein danach an der neuen geholter Handle bleibt gültig). Um den Baum zu durchlaufen: of_count() und of_keys_at(n) für die oberste Ebene, of_count(adresse) und of_keys_at(adresse, n) für die Kinder eines Knotens — das die vollständige Adresse liefert, so wiederverwendbar.

// Local variables
long ll_i

// Paris first among the cities of France, then Italy moved under a new region
uo_tree.of_add_node(/*keys*/ "europe/france/lyon", /*text*/ "Lyon")
uo_tree.of_insert_node(/*keys*/ "europe/france/paris", /*text*/ "Paris", /*image*/ "", /*position*/ 1)
uo_tree.of_add_node(/*keys*/ "south", /*text*/ "Southern Europe")
uo_tree.of_move_node(/*keys*/ "europe/italy", /*to_parent_keys*/ "south", /*position*/ 1)

// The children of France, by their whole address
for ll_i = 1 to uo_tree.of_count(/*keys*/ "europe/france")
    lb_cities.AddItem(uo_tree.of_keys_at(/*keys*/ "europe/france", /*index*/ ll_i))
next

Öffnen, auswählen, anhaken #

Ein Knoten öffnet sich über seinen Chevron, einen Doppelklick, die Tastatur oder Ihren Code (ib_expanded seines Handles, of_expand_all, of_collapse_all, of_expand_to_level, of_scroll_to_node, was of_select_node öffnet; of_clear_children schließt): Jedes davon löst ue_node_toggled aus, dann ue_layout_changed. Die Auswahl folgt is_selection_mode: ein Knoten (SELECT_SINGLE, der Standard), mehrere mit Strg und Umschalt wie im Explorer (SELECT_MULTIPLE) oder keiner (SELECT_NONE: Die Tastatur bewegt nur einen Fokus). of_select_node wählt einen Knoten allein aus, öffnet, was ihn enthält, und bringt ihn auf den Bildschirm — ein Baum öffnet, um auszuwählen, wie die TreeView von Windows, aber er prüft zuerst: Ein ausgeblendeter oder in einem ausgeblendeten enthaltener Knoten, einer jenseits der Demogrenze oder einer, den die Suche ausschließt, wird abgelehnt (-5, of_get_last_error sagt warum), und nichts öffnet sich. ue_selection_changed erhält die ausgewählten Adressen als JSON-Array — ob ein Klick, die Tastatur oder Ihr Code sie geändert hat oder ein ausgewählter Knoten den Bildschirm verlassen hat (Zweig geschlossen, Knoten entfernt oder ausgeblendet, Knoten von der Suche verborgen). Das Schließen eines Zweigs bringt den Fokus auf ihn zurück. Mit ib_checkboxes hat jeder Knoten ein Kästchen; mit ib_check_cascade (der Standard) hakt ein Haken des Benutzers an einem Elternknoten dessen Teilbaum an, außer einem ausgegrauten Knoten und seinem Teilbaum, die bleiben, wie sie sind (der Elternknoten ist dann gemischt); ein Haken Ihres Codes hakt alles an. Während einer Suche erfasst die Kaskade den ganzen Teilbaum, verborgene Knoten eingeschlossen. Unter der Kaskade ist ein Elternknoten der Zustand der Kinder, die der Baum zeichnen kann (weder ausgeblendet noch im Demomodus jenseits der Grenze): angehakt, wenn alle es sind, gemischt, wenn ein Teil es ist. Ein vom Benutzer gesetzter Haken löst ue_node_checked aus; ein von Ihrem Code gesetzter Haken (ib_checked, of_check_all) ist ein Wert, stumm wie SetItem. Die unter einem angehakten Blatt empfangenen Kinder übernehmen dessen Haken — alle, die ganze Antwort auf ue_children_needed —, bis ein Haken (Geste oder Code) oder ein hineinverschobener Knoten dem ein Ende setzt. Ein Haken des Benutzers berührt nie einen Knoten jenseits der Demogrenze, mit ib_write_back auch keinen ausgeblendeten. of_select_nodes(as_keys_json) wählt in SELECT_MULTIPLE mehrere Knoten auf einmal aus — das Gegenstück zu of_selected_keys — mit einer einzigen Frage an die Vetos und einem einzigen ue_selection_changed; der Fokus geht auf die zuletzt genannte Adresse.

// Local variables
n_pbt_json lnv_json
string ls_keys[]
long ll_i

// A box before each node : checking a parent checks its subtree
uo_tree.ib_checkboxes = true
uo_tree.of_node(/*keys*/ "europe/france").ib_checked = true

// Every checked node, in the order of the tree
lnv_json.of_load(/*json*/ uo_tree.of_checked_keys())
for ll_i = 1 to lnv_json.of_get_array(/*path*/ "", /*values*/ ls_keys)
    lb_chosen.AddItem(ls_keys[ll_i])
next

Zuerst fragen: Auswahl und Öffnen #

Ein Master-Detail-Bildschirm darf einen nicht gespeicherten Datensatz nicht verlassen. Mit ib_veto_selection erhält ue_selection_changing die aktuelle und die gewünschte Auswahl (JSON-Arrays von Adressen) vor jeder Wahl: ein Klick, Strg- oder Umschalt-Klick, die Tastatur, F3, of_select_node, of_clear_selection, of_search_next oder of_search_prev. Geben Sie FALSE zurück, um abzulehnen: Nichts bewegt sich, nicht einmal der Tastaturfokus, und die Methode gibt -4 zurück; ue_node_clicked wird trotzdem ausgelöst, der Klick hat stattgefunden. Was als Folge die Auswahl verlässt — ein geschlossener Zweig, ein entfernter, ausgeblendeter oder von der Suche verborgener Knoten —, wird nicht gefragt. Ebenso fragt ib_veto_toggle mit ue_node_toggling vor jedem Öffnen oder Schließen, durch eine Geste oder den Code: Ein abgelehntes ib_expanded sendet nichts (of_get_last_error sagt es), of_expand_all, of_collapse_all und of_expand_to_level wenden die übrigen Knoten an und geben -4 zurück, of_select_node und of_scroll_to_node geben -4 zurück, ohne etwas zu öffnen. of_select_node fragt zuerst die Öffnungen (ue_node_toggling), dann die Auswahl: Eine Anwendung handelt nie auf eine angenommene Auswahl, deren Öffnung sie danach ablehnt. Was als Folge die Auswahl verlässt, lässt sich nicht ablehnen: Damit ein geschlossener Zweig keinen nicht gespeicherten Datensatz verlässt, kombinieren Sie ib_veto_selection mit ib_veto_toggle und lehnen das Schließen des Zweigs ab, der ihn enthält. ib_single_expand lässt unter jedem Elternknoten nur einen offenen Zweig: Einen Knoten zu öffnen schließt seine offenen Geschwister, ohne zu fragen; das Setzen schließt im Moment nichts.

// A record shown beside the tree : ask before the selection leaves it, and before
// a branch closes (closing the branch that holds it would leave it)
uo_tree.ib_veto_selection = true
uo_tree.ib_veto_toggle = true

// event ue_selection_changing of uo_tree : (string as_from_keys_json, string as_keys_json)
// Unsaved changes in the detail : the user decides
if dw_detail.ModifiedCount() > 0 then
    if MessageBox("Unsaved changes", "Leave this record without saving?", Question!, YesNo!) = 2 then return false
end if
return true

// event ue_node_toggling of uo_tree : (string as_keys, boolean ab_expanding)
// Closing the branch that holds an unsaved record would leave it : refused
if not ab_expanding and dw_detail.ModifiedCount() > 0 then
    if Pos(uo_tree.of_selected_key() + "/", as_keys + "/") = 1 then return false
end if
return true

Bei Bedarf geladene Zweige #

Ein großer Baum — ein Laufwerk, ein Katalog, eine Tabelle mit Tausenden von Zeilen — muss nicht auf einmal gelesen werden. ib_has_children = true an einem Knoten ist ein Versprechen: Sein Chevron wird angezeigt, obwohl er nichts enthält. Wenn er sich öffnet — ein Klick, die Tastatur, Ihr Code oder of_select_node, das öffnet, was einen Knoten enthält —, wird ue_children_needed ausgelöst: Ihre während des Ereignisses ausgeführten of_add_node sind da, wenn sich der Zweig öffnet, nachdem die Zeile, die ihn geöffnet hat, zurückgekehrt ist (ib_expanded = true wartet nicht auf sie). Das Versprechen gilt bis zu dieser Antwort, auch wenn inzwischen ein Knoten hinzugefügt oder abgelegt wurde; fügen Sie nichts hinzu, wird es zurückgezogen (der Chevron verschwindet). Setzen Sie ib_has_children = true erneut, fragt die nächste Öffnung wieder. Eine während des Ereignisses ausgeführte Öffnung löst nur ein ue_node_toggled aus. of_expand_all öffnet nur die Zweige, die bereits Kinder haben: Ein Zweig, dessen Versprechen nicht beantwortet wurde, bleibt geschlossen, es wird keine Frage in Masse gestellt. Für eine Tabelle muss of_add_node nicht Zeile für Zeile aufgerufen werden: of_from_datastore(ads, as_parent_keys) macht die Zeilen eines DataStores in einer einzigen Nachricht zu Kindern des Knotens — das Muster ItemPopulate → Retrieve der TreeView von PowerBuilder. ROLE_PARENT nennt dort eine Zeile desselben Loses (leer oder unbekannt: direkt unter dem Knoten); derselbe DataStore, erneut unter demselben Knoten übergeben, ersetzt sein Los, ein anderer DataStore fügt seines hinzu. of_row eines Knotens eines Loses liefert seine Zeile in seinem DataStore, und ib_write_back schreibt dorthin. of_clear_children entfernt die Kinder eines Knotens und lässt ihn erneut versprechen: Sein nächstes Öffnen fragt wieder (das „Aktualisieren“ eines Ordners). Geben Sie jedem Los seinen eigenen DataStore (beim Öffnen seines Zweigs erstellt, behalten, solange seine Knoten gezeigt werden): Ein für einen anderen Knoten neu geladener DataStore — Reset, Retrieve, dann of_from_datastore unter einem anderen Knoten — nimmt seine Zeilen zum neuen Los mit, und PowerBuilder vergibt nach einem Reset dieselben RowIDs erneut. Die Knoten des früheren Loses behalten dann, was sie zeigen, haben aber keine Zeile mehr: of_row liefert 0, eine Verschiebung durch den Code liefert -5 („loaded again“), ein umbenannter Text oder ein Haken wird abgelehnt und ue_write_back_failed sagt warum, und das Laden, das es verursacht hat, zählt sie (stale=N) in of_get_last_error. Derselbe DataStore, erneut unter demselben Knoten übergeben, ersetzt sein Los; um ein Los aus einem anderen DataStore-Objekt aufzufrischen, rufen Sie zuerst of_clear_children auf, sonst wird es neben das erste gestellt. Eine Spalte namens has_children (ROLE_HAS_CHILDREN) lässt eine Zeile eigene Kinder versprechen, ohne Schleife. Ein leeres as_parent_keys wird abgelehnt (-5): Die Spitze des Baums ist of_from_datastore(ads).

// A folder that promises children : nothing is read before it opens
uo_tree.of_add_node(/*keys*/ "docs", /*text*/ "Documents", /*image*/ "img\packimages.dll:png/folder")
uo_tree.of_node(/*keys*/ "docs").is_expanded_image = "mono:img\packimages.dll:svg/samples/folder-open"
uo_tree.of_node(/*keys*/ "docs").ib_has_children = true

// event ue_children_needed of uo_tree : (string as_keys)
// Local variables
datastore lds_folders
n_pbt_utils lnv_utils

// The folder opens : ITS sub-folders are retrieved into a DataStore of their own and
// added in ONE call - code is their key and name their text (of_map, once), the
// column has_children says whether each one promises its own
lds_folders = create datastore
lds_folders.DataObject = "d_folders"
lds_folders.SetTransObject(SQLCA)

// as_keys is the whole ADDRESS (docs/reports) : the code of the folder is its LAST key
lds_folders.Retrieve(lnv_utils.of_leaf(/*keys*/ as_keys))
uo_tree.of_from_datastore(/*ads*/ lds_folders, /*parent_keys*/ as_keys)

// One DataStore per lot, kept while its nodes are shown : of_row and ib_write_back
// read it ; the window destroys them when it closes
ids_lots[UpperBound(ids_lots) + 1] = lds_folders

Umbenennen und verschieben #

Mit ib_editable benennt der Benutzer einen Knoten um: F2 oder ein Klick auf den bereits ausgewählten Knoten (nach einer kurzen Verzögerung, wie im Explorer). Eingabe (oder das Verlassen des Feldes) behält den Text, Esc stellt ihn wieder her, ein geleerter Text wird abgelehnt (die Bearbeitung wird abgebrochen); ue_node_edited erhält den getippten Text und den alten — ein getippter Text ist Text, niemals Auszeichnung. Ein Befehl Ihres Codes während der Bearbeitung behält das Feld und das darin Getippte; verlässt die bearbeitete Zeile den Bildschirm ohne Geste des Benutzers (Code, Bildlauf), wird die Bearbeitung abgebrochen. Mit ib_drag_drop zieht er einen Knoten: auf dem oberen Viertel einer Zeile kommt er vor sie, auf dem unteren Viertel hinter sie — als erstes Kind, wenn sie ein offener Zweig ist —, in der Mitte in sie; ein geschlossener Zweig unter dem Zeiger öffnet sich nach einem Moment, der Baum rollt nahe an seinen Rändern, Esc bricht ab, ein Knoten kommt nie in seinen eigenen Teilbaum noch dorthin, wo sein Schlüssel vergeben ist, und auf der Zeile eines ausgegrauten Knotens wird nichts abgelegt. Ein Ziehen, dessen losgelassene Taste der Baum nicht sieht — das Fenster verliert den Fokus (Alt+Tab, ein Meldungsfenster) —, wird abgebrochen: Nichts bewegt sich. Unter einer Sortierung oder mit ib_parents_first geht ein Ablegen nur hinein. ue_node_moved erhält die neue Adresse, die alte und den Platz unter dem neuen Elternknoten; ein an seinem Platz abgelegter Knoten fragt, schreibt und löst nichts aus. Mit ib_veto_changes werden ue_node_editing und ue_node_moving vorher gefragt — ue_node_moving mit dem endgültigen Platz, dem, den ue_node_moved nennen wird: Geben Sie FALSE zurück, um abzulehnen — nichts ändert sich, und of_move_node gibt -4 zurück. Es wird jeweils ein Knoten gezogen, auch bei Mehrfachauswahl.

// Renaming and moving by the user, with a question before each change
uo_tree.ib_editable = true
uo_tree.ib_drag_drop = true
uo_tree.ib_veto_changes = true

// event ue_node_moving of uo_tree : (string as_keys, string as_to_parent_keys, long al_position)
// Nothing goes to the top level : FALSE keeps the node where it is
if as_to_parent_keys = "" then return false
return true

Auch Ihr Code öffnet einen Namen zur Bearbeitung: of_edit_node(as_keys) — das EditLabel eines PowerBuilder-TreeView, für einen „Neuen Ordner“, der sich bereit zur Benennung öffnet. Der Knoten wird zuerst ausgewählt (was ihn enthält, öffnet sich), dann öffnet sich das Feld; das Ende gehört dem Benutzer, wie oben. Eine Sperre hält den Benutzer auf, nie Ihren Code: Es funktioniert mit ib_editable = false, auf einem schreibgeschützten oder ausgegrauten Knoten. of_cancel_edit() schließt das Feld und stellt den Text wieder her, wie Esc.

// A new folder, opened at once in edit mode : the user types its name, then Enter
uo_tree.of_add_node(/*keys*/ "docs/new", /*text*/ "New folder")
uo_tree.of_edit_node(/*keys*/ "docs/new")

Sperren, Entf und Kopieren #

Drei Sperren pro Knoten halten den Benutzer auf, nie Ihren Code: ib_read_only (weder umbenannt noch gezogen, er bleibt ein Ziel), ib_drop_target = false (nichts wird in ihn abgelegt, weder ein Knoten noch eine Datei — davor oder dahinter bleibt erlaubt) und ib_show_checkbox = false (kein Kästchen: Der Knoten zählt nicht für seinen Elternknoten, steht nicht in of_checked_keys, und die Kaskade geht durch ihn hindurch zu seinen Kindern). Entf löst ue_delete_requested mit den ausgewählten Knoten aus (in SELECT_NONE dem mit dem Fokus; ohne Auswahl sonst wird nichts ausgelöst), außer ausgegrauten und schreibgeschützten: Der Baum entfernt nichts, Ihre Anwendung ruft of_remove_node für das auf, was sie löscht. Strg+C (oder Strg+Einfg) löst ue_copy mit den ausgewählten Knoten (in SELECT_NONE dem mit dem Fokus) als tabulatorgetrenntem Text aus, eine Zahl roh (ein Punkt, weder Gruppierung noch Symbol): der Text nach so vielen Tabulatoren wie seine Tiefe, dann die Spalten einer Baumliste ausgerichtet, zuerst eine Kopfzeile; der Baum versucht auch die Zwischenablage des Browsers, die der Seite verweigert werden kann — ClipBoard(as_tsv), um sicher zu sein.

// The system folder : neither renamed nor dragged, nothing dropped into it, no check box
uo_tree.of_node(/*keys*/ "system").ib_read_only = true
uo_tree.of_node(/*keys*/ "system").ib_drop_target = false
uo_tree.of_node(/*keys*/ "system").ib_show_checkbox = false

// event ue_delete_requested of uo_tree : (string as_keys_json)
// Local variables
n_pbt_json lnv_json
string ls_keys[]
long ll_i

// Delete pressed : the tree removes nothing, your application decides
lnv_json.of_load(/*json*/ as_keys_json)
for ll_i = 1 to lnv_json.of_get_array(/*path*/ "", /*values*/ ls_keys)
    uo_tree.of_remove_node(/*keys*/ ls_keys[ll_i])
next

// event ue_copy of uo_tree : (string as_tsv)
// Ctrl+C : the nodes copied, ready for a spreadsheet
ClipBoard(as_tsv)

Aus dem Explorer abgelegte Dateien #

Mit ib_allow_drop nimmt der Baum Dateien an, die aus dem Windows-Explorer auf einen Knoten gezogen werden: Der Knoten unter dem Cursor leuchtet während des Ziehens auf, ue_drop_files erhält seine Adresse und die vollständigen Pfade. as_keys ist leer bei einem Ablegen neben den Knoten, auf einem ausgegrauten Knoten oder auf einem Knoten, dessen ib_drop_target false ist. ue_drag_enter und ue_drag_leave melden, dass ein Ziehen von Dateien hereingekommen und wieder gegangen ist, ohne abzulegen.

// Files of the Explorer dropped on a folder of the tree
uo_tree.ib_allow_drop = true

// event ue_drop_files of uo_tree : (string as_keys, string as_files[])
// The folder under the cursor : your application copies the files there
if as_keys <> "" then wf_copy_files(as_files, uo_tree.of_get_field(/*keys*/ as_keys, /*field*/ "path"))

Spalten, Sortierung und Layout #

of_add_column macht aus dem Baum eine Baumliste: Die erste Spalte trägt den Baum (ihr Titel ist is_tree_title), jede hinzugefügte Spalte zeigt das Feld mit demselben Schlüssel jedes Knotens — gesetzt über of_set_field oder eine Spalte des DataStores. Der Handle einer Spalte (of_column) legt ihren Titel, ihre Breite (0 = automatisch), ihre Ausrichtung, ihr Format (eine Zahlenmaske wie "#,##0.00" mit den Trennzeichen der Anzeigesprache oder Datums-Token für einen Wert "yyyy-mm-dd", die des datagrid), ihre Sichtbarkeit und ihren Platz fest. Ein Klick auf eine Kopfzeile sortiert die Geschwister jeder Ebene — aufsteigend, absteigend, dann die Reihenfolge des Hinzufügens — und löst ue_sort_changed aus; of_sort tut dasselbe per Code. Die Sortierung ändert nur die angezeigte Reihenfolge: of_keys_at und die Positionen behalten die Reihenfolge des Hinzufügens. Der Benutzer verbreitert eine Spalte über den Rand ihrer Kopfzeile und verschiebt sie durch Ziehen der Kopfzeile. Was er angeordnet hat — Breiten, Reihenfolge, Sichtbarkeit, Sortierung, offene Knoten —, wird über of_get_layout gelesen und über of_set_layout zurückgegeben; ue_layout_changed trägt das ganze Layout nach jeder Geste, die es ändert, und wenn Ihr Code die Breite, den Platz oder die Sichtbarkeit einer Spalte schreibt (ii_width, ii_index, ib_visible) und sich das Layout ändert. Gleiche Werte behalten die Reihenfolge des Modells, und die Sortierung wird neu ausgeführt, wenn sich die Anzeigesprache ändert. Das Entfernen der sortierten Spalte (of_remove_column, of_clear_columns) löst ue_sort_changed mit dem nächsten Schlüssel der Sortierung aus — SORT_NONE, wenn es der einzige war —, dann ue_layout_changed. Die fünf Farben des Handles einer Spalte (il_accent, il_back_color, il_text_color, il_back_color_hover, il_text_color_hover) färben ihre Kopfzeile. Sobald es Spalten gibt, bleibt die Baumspalte beim waagerechten Bildlauf fixiert. Die Sortierung kann mehrere Schlüssel haben: of_sort(as_sort) liest die Syntax des SetSort eines DataWindows („type A, text D“, wobei „text“ der Text der Knoten ist), of_sort(as_column, as_dir) nimmt auch ein Feld an, das keine Spalte zeigt, und ue_sort_changed erhält die ganze Sortierung als drittes Argument. ib_parents_first stellt auf jeder Ebene die Knoten, die Kinder haben (oder versprechen), vor die Blätter — die Ordner vor die Dateien —, welche Sortierung auch immer. Eine Spalte kann den Schlüssel text nicht nehmen, der den Text der Knoten bezeichnet (-5): of_sort("text", as_dir) sortiert danach, und of_sort akzeptiert mehrere Leerzeichen zwischen einer Spalte und ihrer Richtung, wie SetSort.

// A tree list : the population of each country beside the tree
uo_tree.is_tree_title = "Country"
uo_tree.of_add_column(/*key*/ "population", /*title*/ "Population", /*width*/ 120)
uo_tree.of_column(/*key*/ "population").is_format = "#,##0"
uo_tree.of_column(/*key*/ "population").is_align = u_pbt_treeview.ALIGN_END
uo_tree.of_set_field(/*keys*/ "europe/france", /*field*/ "population", /*value*/ "68000000")

// The largest countries first, inside each continent
uo_tree.of_sort(/*column*/ "population", /*dir*/ u_pbt_treeview.SORT_DESC)

// The folders first, then by type and by name
uo_tree.ib_parents_first = true
uo_tree.of_sort(/*sort*/ "type A, text A")

Den Baum mit seiner Hierarchie exportieren: of_export_csv(as_path) schreibt eine CSV-Datei (UTF-8, Semikolon), in der der Text eines Knotens in der Zelle seiner Ebene steht — eine Zelle weiter rechts pro Ebene —, die Spalten einer Baumliste nach der tiefsten Ebene, zuerst eine Kopfzeile; of_export_xlsx(as_path) schreibt eine Excel-Arbeitsmappe, in der der Text um seine Ebene eingerückt und jeder Zweig unter seinem Elternknoten gruppiert ist, in Excel einklappbar, und Zahlen Zahlen bleiben. is_export_scope sagt, welche Knoten: EXPORT_ALL (Standard) alle Knoten, geschlossene Zweige eingeschlossen, EXPORT_SHOWN die Zeilen auf dem Bildschirm. Der Baum erstellt die Datei, die DLL schreibt sie, ue_csv_saved / ue_xlsx_saved bestätigen; im Demomodus abgelehnt.

// The tree written to Excel - every node, the closed branches too ; ue_xlsx_saved confirms
uo_tree.is_export_scope = u_pbt_treeview.EXPORT_ALL
uo_tree.of_export_xlsx(/*path*/ "C:\exports\countries.xlsx")

Gesamtwerte pro Zweig #

Eine Spalte einer Baumliste kann an jedem Zweig den Gesamtwert dessen zeigen, was er enthält: is_summary an ihrem Handle ist SUMMARY_SUM, SUMMARY_AVG, SUMMARY_MIN, SUMMARY_MAX oder SUMMARY_COUNT (die nicht leeren Werte). Die Berechnung geht bis zu den Blättern hinunter — ein Durchschnitt ist der der Blätter, nie ein Durchschnitt von Durchschnitten —, und der Gesamtwert wird fett über is_format geschrieben — eine Anzahl immer als einfache Zahl. Ein Zweig mit eigenem Wert behält ihn und gibt ihn nach oben weiter, außer mit ib_summary_over_value an der Spalte. Es zählen nur die Knoten, die der Baum zeichnen kann (nie ein ausgeblendeter); mit ib_summary_filtered an der Komponente nur, was die Suche zeigt. of_get_field liefert den rohen Gesamtwert (eine Zahl mit Punkt), eine Sortierung nach dieser Spalte verwendet die Gesamtwerte, und die Gesamtwerte folgen jedem Hinzufügen, Entfernen oder Ziehen. SUMMARY_MIN und SUMMARY_MAX vergleichen auch Datumswerte (yyyy-mm-dd, yyyy-mm-dd hh:mm:ss, hh:mm:ss), und eine Summe ganzer Zahlen bleibt über 2^53 hinaus exakt.

// Each continent shows the sum of its countries, in bold
uo_tree.of_column(/*key*/ "population").is_summary = u_pbt_treeview.SUMMARY_SUM

// The total of Europe, read like a field
st_total.text = uo_tree.of_get_field(/*keys*/ "europe", /*field*/ "population")

Suchen #

is_filter zeigt nur die Knoten, deren Text die Suche enthält (Groß-/Kleinschreibung ignoriert), mit den Knoten, die sie enthalten, geöffnet, und dem gefundenen Text hervorgehoben. "" zeigt alles. Was einen Treffer enthält, wird geöffnet angezeigt, ohne ib_expanded zu ändern, und die Chevrons sind während der Suche wirkungslos. Mit ib_toolbar trägt eine Leiste über dem Baum ein Suchfeld (das is_filter schreibt: Ein Lesen liefert es sofort) und die Schaltflächen Alle aufklappen und Alle zuklappen. Esc im Feld leert die Suche, Pfeil nach unten wechselt zum Baum, Eingabe und F3 gehen zum nächsten Treffer (Umschalt: zum vorigen), und das Feld behält die Tastatur. Ein ausgewählter Knoten, den die Suche verbirgt, verlässt die Auswahl, und ue_selection_changed meldet es; der Knoten, der ihn enthält, wird nicht an seiner Stelle ausgewählt. of_select_node und of_scroll_to_node lehnen einen Knoten ab, den die Suche ausschließt (-5). Um von Treffer zu Treffer zu gehen, wählen of_search_next und of_search_prev den nächsten oder vorigen nach dem Knoten mit dem Fokus aus, im Kreis (F3 und Umschalt+F3 über die Tastatur), und of_match_count sagt, wie viele die Suche gefunden hat. of_find_node(as_field, as_value, as_after_keys) findet ohne zu filtern: die Adresse des ersten Knotens, dessen Feld ("" = sein Text) genau den Wert enthält, in der Reihenfolge, die der Baum zeigt, geschlossene Zweige eingeschlossen; übergeben Sie die gefundene Adresse erneut für den nächsten. In SELECT_NONE bewegen of_search_next und of_search_prev den Fokus dorthin, wie F3. of_find_node beginnt nach dem Platz von as_after_keys in der angezeigten Reihenfolge — auch bei einem ausgeblendeten Knoten; ein unbekannter liefert "", und of_get_last_error sagt es. of_find_nodes(as_field, as_value) liefert alle Treffer auf einmal, als JSON-Array in der angezeigten Reihenfolge.

Die Suche ignoriert Akzente standardmäßig, wie die Sortierung: „montreal“ findet „Montréal“, und das türkische I mit Punkt zählt als I („izmir“ findet „İzmir“); ib_filter_accents = true lässt sie zählen. Bei Mehrfachauswahl wählt Strg+A alle angezeigten Knoten aus (eine einzige Frage mit ib_veto_selection).

// A search field above the tree, and a first search from the code
uo_tree.ib_toolbar = true
uo_tree.is_filter = "par"

// Local variables
string ls_keys

// The first node whose code is FR, selected if there is one
ls_keys = uo_tree.of_find_node(/*field*/ "code", /*value*/ "FR", /*after_keys*/ "")
if ls_keys <> "" then uo_tree.of_select_node(/*keys*/ ls_keys)

// Every node whose status is late, selected at once (a multiple selection)
uo_tree.is_selection_mode = u_pbt_treeview.SELECT_MULTIPLE
uo_tree.of_select_nodes(/*keys_json*/ uo_tree.of_find_nodes(/*field*/ "status", /*value*/ "late"))

Aus einem DataStore #

of_from_datastore macht aus jeder Zeile einer hierarchischen Tabelle einen Knoten: Die Spalte ROLE_KEY gibt seinen Schlüssel (ohne sie die RowID der Zeile), die Spalte ROLE_PARENT nennt den Schlüssel des Knotens, der ihn enthält (leer, unbekannt oder eine Schleife: ganz oben) — mit einer Spalte ROLE_KEY nennt ein Elternwert einen Schlüssel, niemals eine RowID. Die anderen Rollen: der Text (ROLE_TEXT, als Text angezeigt, nie als Auszeichnung), das Bild, der Haken, das Badge und ob er beim Laden offen ist. Eine Spalte spielt eine Rolle, wenn sie so heißt (key, parent, text…) oder wenn of_map es sagt. Jede Spalte ist ein Feld (of_get_field) — die Spalten der Liste werden nicht für Sie angelegt: of_add_column mit dem Spaltennamen. Datums- und Zahlenwerte werden unabhängig von den Regionaleinstellungen in einer einzigen Form gelesen: ein Datum yyyy-mm-dd, ein Datum mit Uhrzeit yyyy-mm-dd hh:mm:ss, eine Zahl mit Punkt und ohne überflüssige Null (1234,50 wird 1234.5) — eine Dezimalspalte wird als Zahl formatiert und sortiert. Zwei Zeilen mit demselben Schlüssel: Die zweite erhält "Schlüssel~RowID". Was das Laden korrigieren musste (Zeilen, deren Elternknoten fehlt, aufgebrochene Schleifen, doppelte Schlüssel, unmögliche Schlüssel), sagt of_get_last_error, die Rückgabe bleibt 0. of_reload_row liest eine von Ihrem Code geänderte Zeile erneut und aktualisiert ihren Knoten an Ort und Stelle; eine Zeile, deren Schlüssel oder Elternknoten sich geändert hat, verschiebt ihren Knoten. Der Knoten einer Zeile, der durch of_remove_node entfernt wurde, bleibt bis zum nächsten of_from_datastore weg; of_reload_row seiner Zeile bringt ihn zurück. Mit ib_write_back wird ein umbenannter Text in die Spalte ROLE_TEXT geschrieben, und ein Knoten, der den Elternknoten wechselt, schreibt ihn in die Spalte ROLE_PARENT (NULL ganz oben, welcher Typ auch immer; eine Verschiebung unter denselben Geschwistern schreibt nichts), vor dem Ereignis; ein Knoten einer Zeile geht dann weder unter einen von Hand hinzugefügten Knoten noch unter eine Zeile ohne Schlüsselwert — seine Elternspalte könnte es nicht ausdrücken. Ein Wert, den der DataStore ablehnt, oder ein seit dem Laden zerstörter DataStore (no DataStore is bound) setzt den Knoten zurück und löst ue_write_back_failed aus. Ohne ib_write_back verschiebt ein Ziehen nur den Knoten: Seine Zeile behält, was der DataStore sagt, und das nächste Lesen der Zeilen (of_map, is_group_by, of_reload_row, ein neues Laden) setzt den Knoten dorthin zurück, wo seine Zeile es sagt — sein altes Handle wird freigegeben. Das Update bleibt Ihre Sache. Der Handle eines Knotens liest die Nummer seiner Zeile (of_row). of_from_datastore liest auch die Zeilen eines DataWindows oder eines DataWindowChilds — dessen, das der Benutzer daneben sieht: Der Baum schreibt dann in dieses. Mit ib_write_back wird ein Haken des Benutzers auch in die Spalte ROLE_CHECKED jeder Zeile geschrieben, die er geändert hat — die Kaskade eingeschlossen, und die Zweige darüber, deren Zustand zu angehakt oder nicht angehakt wechselt (ein Zweig, der gemischt wird, behält seinen Wert) —, so geschrieben, wie die Spalte es bereits tut (1/0, Y/N, T/F, O/N, -1/0…; eine Spalte, die nur ihr Nein zeigt, schreibt das übliche Ja: Y für N, 1 für 0 — O und -1 nur, wenn die Spalte schon eines enthält); eine Spalte, deren Werte weder ein Ja noch ein Nein sind, wird mit ihrem Grund abgelehnt. Jeder Wert wird zuerst geprüft, und das Schreiben ist alles oder nichts: Eine Ablehnung gibt die Haken der Geste zurück und löst ue_write_back_failed aus. of_row_keys liefert die Adresse des Knotens einer Zeile des Haupt-DataStores: Entfernen Sie den Knoten vor einem DeleteRow. Jedes Zurückschreiben ist alles oder nichts — jeder Wert wird geprüft, bevor einer geschrieben wird; ein Datum mit Uhrzeit behält seine Uhrzeit, eine time-Spalte wird als hh:mm:ss geschrieben, gelesen und gruppiert. Eine von of_move_node geschriebene Verschiebung wird nach ue_node_moving erneut geprüft, und das Geschriebene wird zurückgesetzt, wenn sich der Knoten nicht bewegt. Mit ib_write_back lässt sich ein Knoten einer Zeile, deren DataStore keine ROLE_TEXT-Spalte hat, nicht umbenennen. Ein neues Laden gibt nur die Handles dessen frei, was es ersetzt: das Handle eines von Hand hinzugefügten Knotens, ein inaktives Handle oder eines, das für eine noch nicht erstellte Adresse genommen wurde, bleiben gültig; of_from_datastore aus einer DataWindow prüft, dass ihre Daten geteilt werden können (-5 mit dem Grund). Was ein Lesen der Zeilen korrigieren musste, wird in of_get_last_error gezählt — auch die von Hand hinzugefügten Knoten, die an die Spitze gehoben wurden, weil ihre Gruppe weg ist (lifted=N), und die Lose, die mit ihrem Knoten gegangen sind (lots=N); of_map und is_group_by melden es für alle Quellen.

// The departments : each row names its parent by its id
ids_depts.Retrieve()
uo_tree.of_map(/*role*/ u_pbt_treeview.ROLE_KEY, /*column*/ "dept_id")
uo_tree.of_map(/*role*/ u_pbt_treeview.ROLE_PARENT, /*column*/ "parent_id")
uo_tree.of_map(/*role*/ u_pbt_treeview.ROLE_TEXT, /*column*/ "dept_name")
uo_tree.of_from_datastore(/*ads*/ ids_depts)

// Two columns of the DataStore shown beside the tree
uo_tree.of_add_column(/*key*/ "head_count", /*title*/ "Staff")
uo_tree.of_add_column(/*key*/ "budget", /*title*/ "Budget")
uo_tree.of_column(/*key*/ "budget").is_format = "#,##0"

// A renamed or moved department is written into its row before the event
uo_tree.ib_write_back = true
uo_tree.ib_editable = true
uo_tree.ib_drag_drop = true

// event ue_node_moved of uo_tree : (string as_keys, string as_old_keys, long al_position)
// parent_id is already written in the row : save it
if ids_depts.Update() = 1 then commit using sqlca;

Eine Rolle wird pro DataStore aufgelöst: die Spalte, die of_map(ads, as_role, as_column) diesem DataStore gegeben hat, sonst die von of_map(as_role, as_column), wenn dieser DataStore sie hat, sonst die nach der Rolle benannte Spalte. Ein Los von Mitarbeitern unter einem Baum von Abteilungen braucht also keine der Spalten der Abteilungen. Eine Tabelle, deren Wurzeln 0 in ihrer Elternspalte tragen (eine NOT-NULL-Spalte), sagt es mit is_root_parent_value = "0" ("0|-1" für zwei Werte): Diese Zeilen stehen oben, ohne als verwaist zu zählen, und ein mit ib_write_back nach oben verschobener Knoten schreibt 0 statt NULL. Die Spalten ROLE_STATE_IMAGE und ROLE_OVERLAY_IMAGE geben das Statusbild und das überlagerte Bild eines Knotens, gelesen wie ROLE_IMAGE.

// event ue_children_needed of uo_tree : (string as_keys)
// Local variables
datastore lds_staff
n_pbt_utils lnv_utils

// The employees of the department that opens, in a DataStore of their own
lds_staff = create datastore
lds_staff.DataObject = "d_staff"
lds_staff.SetTransObject(SQLCA)
lds_staff.Retrieve(lnv_utils.of_leaf(/*keys*/ as_keys))

// THEIR key and THEIR text : the departments keep dept_id and dept_name
uo_tree.of_map(/*ads*/ lds_staff, /*role*/ u_pbt_treeview.ROLE_KEY, /*column*/ "emp_id")
uo_tree.of_map(/*ads*/ lds_staff, /*role*/ u_pbt_treeview.ROLE_TEXT, /*column*/ "emp_name")
uo_tree.of_from_datastore(/*ads*/ lds_staff, /*parent_keys*/ as_keys)

// Kept while its nodes are shown ; the window destroys them when it closes
ids_lots[UpperBound(ids_lots) + 1] = lds_staff

// The roots of the table carry 0 in parent_id (a NOT NULL column) : 0 names the top
uo_tree.is_root_parent_value = "0"
uo_tree.of_from_datastore(/*ads*/ ids_depts)

Ein nach Spalten gruppierter Baum #

Der TreeView-Stil eines DataWindows, ohne DataWindow: is_group_by = "region|country|city" macht die Zeilen von of_from_datastore zu Blättern von Gruppen, die auf den Werten dieser Spalten aufbauen, eine Ebene pro Spalte (ROLE_PARENT spielt keine Rolle, ROLE_KEY benennt die Blätter). Der Schlüssel einer Gruppe ist ihr Wert (/, | und % als %2F, %7C, %25 geschrieben), ihr Text der Wert im Format der gleichnamigen Spalte, „(leer)“ für einen leeren Wert; der Handle eines Gruppenknotens liest of_group_column() und of_group_value(). Nach einem Laden gesetzt, gruppiert es neu; of_reload_row ordnet eine Zeile, deren Wert sich geändert hat, in ihre neue Gruppe ein. of_set_level_image gibt allen Knoten einer Ebene ein Bild, of_expand_to_level öffnet den Baum bis zu einer Ebene, und is_summary gibt die Gesamtwerte jeder Gruppe. Mit ib_write_back schreibt ein Blatt, das unter einer Gruppe der letzten Ebene abgelegt wird, vor dem Ereignis alle seine Gruppenspalten; anderswo und für einen Gruppenknoten wird das Verschieben abgelehnt. Der Text einer Gruppe folgt einem nach dem Laden gesetzten Format, dem Eintreffen ihrer Spalte und der Anzeigesprache; ein Wert, der mit __ beginnt, wird im Schlüssel %5F_ geschrieben; of_group_value eines Datums mit Uhrzeit ist yyyy-mm-dd hh:mm:ss, einer Uhrzeit hh:mm:ss. Ohne ib_write_back kehrt ein unter eine andere Gruppe gezogenes Blatt beim nächsten Gruppieren in seine eigene zurück, da sich seine Zeile nicht geändert hat; ein von Hand hinzugefügter Knoten unter einer verschwindenden Gruppe steigt an die Spitze.

// The sales, one row per sale, grouped by region, country and city : the customer is
// the text of each sale
uo_tree.is_group_by = "region|country|city"
uo_tree.of_map(/*role*/ u_pbt_treeview.ROLE_TEXT, /*column*/ "customer")
uo_tree.of_from_datastore(/*ads*/ ids_sales)

// The amount of each sale, and the total of each group
uo_tree.of_add_column(/*key*/ "amount", /*title*/ "Amount")
uo_tree.of_column(/*key*/ "amount").is_format = "#,##0.00"
uo_tree.of_column(/*key*/ "amount").is_summary = u_pbt_treeview.SUMMARY_SUM

// A globe before every region ; only the regions show at first
uo_tree.of_set_level_image(/*level*/ 1, /*image*/ "mono:img\packimages.dll:svg/ribbon/globe", /*expanded_image*/ "")
uo_tree.of_expand_to_level(/*level*/ 1)

Eigenschaften #

Eigenschaften eines Knotens — n_pbt_treeview_node #

Sein Handle, über of_node(adresse). Ein Lesen fragt den Baum, was der Knoten jetzt ist. Sein of_count() zählt seine Kinder, sein of_keys_at(n) liefert die Adresse seines n-ten Kindes (ab 1 gezählt), sein of_has(schlüssel) sagt, ob er dieses Kind hat, sein of_key() liefert seinen Schlüssel.

Eigenschaften einer Spalte — n_pbt_treeview_column #

Sein Handle, über of_column(schlüssel). Ein von Ihrem Code geschriebener Wert ist stumm, wie SetItem — außer seinem Layout: Von Ihrem Code geschriebene ii_width, ii_index und ib_visible lösen ue_layout_changed aus, wenn sich das Layout ändert, wie eine Geste. Ein Lesen liefert, was der Benutzer geändert haben mag (Breite, Platz).

Konstanten #

Sie befinden sich auf u_pbt_treeview: u_pbt_treeview.CHECK_MIXED.

Methoden #

Ereignisse #

Tastatur und Maus #

• Klick auf einen Knoten: Er wird ausgewählt (ue_node_clicked); auf seinen Chevron: Er öffnet oder schließt sich; auf sein Kästchen: Er wird angehakt; Doppelklick: ue_node_opened, und ein Zweig öffnet oder schließt sich; Rechtsklick: ue_node_rclicked. In SELECT_MULTIPLE fügt Strg + Klick einen Knoten hinzu oder nimmt ihn weg, Umschalt + Klick nimmt den Bereich ab dem letzten.
• Auf / Ab: der vorige Knoten, der nächste; Pos1 / Ende: der erste, der letzte; Bild auf / Bild ab: um einen Bildschirm. Ausgegraute Knoten werden übersprungen.
• Rechts öffnet den Knoten und geht dann zu seinem ersten Kind hinunter; Links schließt ihn und geht dann zu seinem Elternknoten hinauf — in einer Rechts-nach-links-Anwendung vertauscht. * des Ziffernblocks öffnet den ganzen Teilbaum; + / - des Ziffernblocks öffnen und schließen — die der Haupttastatur werden getippt, um „+1.2“ oder „-Soll“ zu erreichen.
• Leertaste hakt den Knoten an (mit ib_checkboxes), sonst wählt sie ihn aus; Eingabe: ue_node_opened; F2: umbenennen (mit ib_editable); Kontextmenütaste oder Umschalt + F10: ue_node_rclicked.
• In SELECT_MULTIPLE erweitern Umschalt + Pfeile die Auswahl, Strg + Pfeile bewegen nur den Fokus, Strg + Leertaste fügt den Knoten mit dem Fokus hinzu oder nimmt ihn weg, Strg + A wählt alle angezeigten Knoten aus (eine einzige Frage mit ib_veto_selection).
• Die ersten Buchstaben eines Textes wählen den angezeigten Knoten aus, der mit ihnen beginnt, wie eine Pfeiltaste (in SELECT_NONE bringen sie nur den Fokus dorthin).
• Entf: ue_delete_requested (der Baum entfernt nichts); Strg+C oder Strg+Einfg: ue_copy; F3 / Umschalt+F3: der nächste / vorige Treffer der Suche (in SELECT_NONE geht der Fokus dorthin), vom Baum oder vom Suchfeld aus, wo Eingabe dasselbe tut. Entf und Strg+C wirken nur in SELECT_NONE auf den Knoten mit dem Fokus.
• Die Kopfzeile einer Baumliste ist ein Halt der Tabulatortaste: Links / Rechts gehen von Kopfzelle zu Kopfzelle (in einer Rechts-nach-links-Anwendung vertauscht), Pos1 / Ende zur ersten und zur letzten, Eingabe oder Leertaste sortiert, Strg + Links / Rechts verschmälert oder verbreitert die Spalte um 10 Pixel, Strg + Umschalt + Links / Rechts verschiebt sie, Ab wechselt zu den Zeilen.
• Einen Knoten ziehen (mit ib_drag_drop): Ein Schatten folgt dem Zeiger, ein Balken zeigt, wo er davor oder dahinter landet, ein Rahmen, wenn er hineinfällt; Esc bricht ab. Den Rand einer Kopfzeile ziehen verbreitert die Spalte, die Kopfzeile ziehen verschiebt sie — ein Schatten und ein Einfügebalken zeigen wohin, Esc bricht ab —, die Kopfzeile anklicken sortiert. Ein Ziehen, dessen losgelassene Taste der Baum nicht sieht — das Fenster verliert den Fokus (Alt+Tab, ein Meldungsfenster) —, wird abgebrochen: Nichts bewegt sich, eine Breite kehrt zurück.
• Der Baum ist ein Halt der Tabulatortaste (plus die Kopfzeile einer Baumliste, Feld und Schaltflächen der Symbolleiste); ein gepunkteter Ring in der Textfarbe markiert den Knoten mit dem Fokus. Ein ausgegrauter Baum nimmt keinen Fokus an.

Beispiele #

Anzuhakende Rechte #

// The rights of a role : a module, then what it allows
uo_rights.ib_checkboxes = true
uo_rights.of_add_node(/*keys*/ "sales", /*text*/ "Sales")
uo_rights.of_add_node(/*keys*/ "sales/read", /*text*/ "Read orders")
uo_rights.of_add_node(/*keys*/ "sales/write", /*text*/ "Create and change orders")
uo_rights.of_add_node(/*keys*/ "sales/delete", /*text*/ "Delete orders")

// What the role already has ; Sales shows mixed
uo_rights.of_node(/*keys*/ "sales/read").ib_checked = true
uo_rights.of_node(/*keys*/ "sales").ib_expanded = true

// event ue_node_checked of uo_rights : (string as_keys, boolean ab_checked)
// Delete never without write : checking it checks write too
if as_keys = "sales/delete" and ab_checked then this.of_node(/*keys*/ "sales/write").ib_checked = true

Das Layout beim nächsten Start wiederfinden #

// event ue_layout_changed of uo_tree : (string as_layout_json)
// Widths, order, sort and open nodes, kept for the next start
// (the nodes need STABLE keys : a ROLE_KEY column, never the RowIDs a new Retrieve gives)
SetProfileString("app.ini", "tree", "layout", as_layout_json)

// Local variables
string ls_layout

// After the tree is filled : the layout of the last time, if there is one
ls_layout = ProfileString("app.ini", "tree", "layout", "")
if ls_layout <> "" then uo_tree.of_set_layout(/*layout_json*/ ls_layout)

Ein Menü auf einem Knoten #

// The entries of the menu, once : uo_menu is a contextmenu of the window, and
// is_menu_keys a string instance variable that keeps the node right-clicked
uo_menu.of_add_item(/*keys*/ "expand", /*text*/ "Expand")
uo_menu.of_add_item(/*keys*/ "delete", /*text*/ "Delete")

// event ue_node_rclicked of uo_tree : (string as_keys, long al_x, long al_y)
// The node clicked is kept : the selection may have stayed elsewhere (a veto that
// refused it, SELECT_NONE). The menu opens where the user clicked
is_menu_keys = as_keys
uo_menu.of_show(/*x*/ al_x, /*y*/ al_y)

// event ue_item_selected of uo_menu : (string as_keys)
// The entry chosen acts on the node right-clicked
choose case as_keys
    case "expand"
        uo_tree.of_node(/*keys*/ is_menu_keys).ib_expanded = true
    case "delete"
        uo_tree.of_remove_node(/*keys*/ is_menu_keys)
end choose

Bewährte Praxis #

• Stabile Schlüssel: eine ID, keine Beschriftung — der Text wird umbenannt, der Schlüssel bleibt. of_keys_at liefert vollständige Adressen, so an of_node zu übergeben. Ein von einem Start zum nächsten aufbewahrtes Layout (of_get_layout) braucht eine Spalte ROLE_KEY: Ohne sie sind die Schlüssel der Zeilen ihre RowIDs, die ein neues Retrieve anderen Zeilen gibt.
• Zweige bei Bedarf, sobald der Baum groß oder teuer zu lesen ist: ib_has_children und ue_children_needed lesen nur, was der Benutzer öffnet.
• Ein DataStore pro Los: Für einen anderen Knoten neu geladen, nimmt ein DataStore seine Zeilen — und PowerBuilder seine RowIDs — vom früheren Los weg, dessen Knoten dann keine Zeile mehr haben.
• Viele Knoten: Nur die sichtbaren Zeilen werden gezeichnet — zehntausend Knoten rollen wie zwanzig. Sie hinzuzufügen ist etwas anderes: Jedes of_add_node ist eine Nachricht an den Baum, etwa 0,7 ms (2.000 Knoten ≈ 1,3 s gemessen, 10.000 ≈ 7 s erwartet); ein großer Baum wird über of_from_datastore in einer einzigen Nachricht geladen oder bei Bedarf gelesen, ein Los pro Zweig (of_from_datastore(ads, as_parent_keys)).
• Die Spalten eines DataStores sind IDs ebenso wie Werte: Wählen Sie die angezeigten mit of_add_column, nichts wird für Sie angelegt.
• Ein Haken ist ein Wert: Von Ihrem Code gesetzt, löst er nichts aus; lesen Sie of_checked_keys, wenn der Benutzer bestätigt.
• of_get_last_error sagt, warum der letzte Aufruf abgelehnt wurde; es wird von jeder handelnden Methode und jeder geschriebenen Eigenschaft geleert, und von of_find_node / of_find_nodes, die darüber sagen, warum sie nichts gefunden haben.
• Ein während einer Wartezeit erteilter Befehl (PowerBuilder-Code, der läuft, während der Baum auf seine Seite wartet, etwa ein Timer) wird nicht vorab geprüft: Die Seite entscheidet allein, und ein Hinzufügen oder Verschieben, das sie ablehnt, gibt trotzdem 0 zurück.
• Während einer Wartezeit (ein Ereignis der Komponente wird gerade beantwortet) wird ein Befehl Ihres Codes nicht vorab beurteilt: ib_expanded und of_move_node passieren das Veto, ohne die Frage zu stellen, und of_get_last_error sagt es. Geben Sie Ihre Befehle außerhalb des Ereignisses, wenn das Veto zählt.
• of_set_layout stellt einen Zustand wieder her — typischerweise beim Start —, ohne die Fragen von ib_veto_selection und ib_veto_toggle zu stellen: Das ist die Ausnahme von der Regel, dass ein Befehl des Codes die Frage stellt.
• Demomodus: Ohne Schlüssel zeichnet der Baum die ersten 8 Knoten jeder Ebene und 200 Knoten im ganzen Baum (die zuerst hinzugefügten), in der Reihenfolge des Modells — vor Sortierung, Suche und Ausblenden: Ein ausgeblendeter Knoten zählt, eine Suche oder Sortierung zeigt nie den neunten, Lose und Gruppen eingeschlossen, und ein Gesamtwert zählt nie, was die Grenze verbirgt; die übrigen bleiben im Speicher, weder angezeigt noch auswählbar (siehe Der Demomodus).

Vom gemeinsamen Sockel geerbt #

Diese Mitglieder gibt es bei jeder visuellen Komponente — sie sind nicht dieser eigen. Sie werden einmal in den übergreifenden Kapiteln beschrieben; diese Tabelle sagt nur, wo man sie liest.

Zwei Helfer werden nicht geerbt: of_icon und of_escape_markup liegen auf n_pbt_utils. Deklarieren Sie eines — n_pbt_utils lnv_utils, nichts zu erzeugen — und rufen Sie sie darauf auf.

← Komponentenreferenz · Inhalt des Handbuchs