Beiträge von habenureinproblem

Ich wollte mich nochmal bedanken für euren Einsatz.

Habe den Thread nun auf gelöst gesetzt, da ja das Problem an sich gefunden wurde.

nur noch zum Schluss:
@Kanashius - Super Idee mit dem neuen GUI hatte aber einige Schwierigkeiten da etwas hinzuzufügen, auch wird das eine GUI mit blauen Balken gezeigt, das andere sieht wie nicht angewählt aus.

Aber wenn dann würde ich dafür einen neuen Thread erstellen.

Bis dann

@Oscar
Ahh vielen Dank.

Gleich getestet und festgestellt, dass das Erstellen vom neuen Listview direkt wieder üüber 3 Sekunden statt 30ms dauert.

Ich glaube wir können somit festlegen:

Tabs dürfen nicht mit Listview benutzt werden für volle Geschwindigkeit.

Benutzt jemand Alternativen? Z.B. für Einstellungen 2. Gui erstellen o.ä.?

Abend,

das ging schneller als erwartet, ich habe den Übeltäter.

Wieso GuiCtrlCreateGroup vorher etwas bewirkt hat ist mir schleierhaft, aber diese Zeile:

$tab1 = GUICtrlCreateTab(0, 0, 550, 600)

war der Auslöser.
Sobald keine Tabs genutzt werden füllt sich das Listview genau so wie wenn es gelöscht wurde.

Ich habe alle Inhalte der anderen Tabs entfernt = keine Verbesserung
andere Tabs entfernt = keine Verbesserung
Tabs ganz weggemacht bzw. nur diese oben genannte Zeile auskommentiert = full speed

MEINE geliebten TABS !!! Ich werde irre, was mache ich denn nun?

Kleine Randbemerkung:
Ich hatte in der Zwischenzeit ein Geschwindigkeitsproblem beim Imagesearch und hatte wegen einem Hinweis Aero ausgeschaltet (von Win7 Aero zu Win7 klassisch).
Prompt waren es keine 6 Sekunden sondern nur noch 2,5 Sekunden, mehr als doppelter Geschwindigkeitsgewinn.

Somit bleiben nur noch 2 Fragen offen.

Welche Alternativen, die genauso schön aussehen, gibt es für Tabs?
Wenn man die Tabs weiter benutzen möchte und full speed braucht, muss man das listview löschen, wie bekomme ich es in Tab3 und nur dort wieder hin?

Vielen Dank für eure Hilfe, wir nähern uns dem Ende

kleines EDIT:

gerade ein
GUICtrlCreateTab und GUICtrlCreateTabItem in mein Testprogramm, in dem nur Listviews drinnen sind eingefügt und sofort 3fache Füllzeit erreicht.

@Andy:
Ja klar ist das schnell, deswegen auch meine favorisierte Lösung. Wie aber sogt man dafür, dass das neu erstellte Listview in Tab3 bleibt?

Aber wozu leert man dann Listview? Kann man doch immer löschen.
Ich antworte mal selber : Weil es nur bei diesem speziellen GUI Geschwindigkeitsverluste gibt. Bei einem z.B. ohne Tabs und ohne anderen Kram bremst ein GuiCtrlCreateGroup um ein Listview gar nichts aus.

Leider ist Zeit bei mir so ein kleines Problem, aber ich denke mal heute Abend werde ich mein GUI entschlacken.

Morgen,

Da BugFix groupex schon einiges geholfen hat, aber noch entfernt von der Erstellgeschwindigkeit ist, wollte ich weiter testen.

Deshalb habe ich gestern mal ein neues GUI erstellt mit 3 Listviews, Zeit gemessen und GuiCtrlCreateGroup rum gemacht. Ergebnis: keine Änderungen.
Da dachte ich mir, dass es also im Zusammenhang mit anderen Elementen oder aber an meine Programmierung liegt.

Nun werde ich nach und nach mein GUI entschlacken und immer mal testen.

Dabei ist mir aber der Gedanke von Andy gekommen. Was wenn es am System selber liegt?

Daher habe ich mein Programm alle relevanten Teile rausgenommen und nur das GUI drin gelassen (aber die Grundstruktur dringelassen). Wer möchte kann es ja mal auf seinem Rechner starten lassen und 4 Varianten testen.

#include <Array.au3>
#include <GUIConstantsEx.au3>
#include <GuiListView.au3>
#include <GuiTab.au3>
#include <ListViewConstants.au3>
#include <Misc.au3>
#include <TreeViewConstants.au3>
#include <WindowsConstants.au3>
#include <groupex.au3>


#Region ;**** Directives created by AutoIt3Wrapper_GUI ****
#AutoIt3Wrapper_UseX64=n
#EndRegion ;**** Directives created by AutoIt3Wrapper_GUI ****


ProgressOn("Test", "wird geladen....Bitte warten!")
ProgressSet(10, "Includes laden")
_Singleton("MBH")


ProgressSet(30, "GUI laden")


$version = "1.3.0"


Dim $textitem_update[100][100] ;leere Felder werden bei Ausgabe gefiltert
$textitem_update[1][0] = " "
$textitem_update[1][1] = " "
$textitem_update[2][0] = " "


#Region Parameter
$zusatz1 = ""
$ende = 0
$doppelt = 0
$B_DESCENDING = False


$speicherort = @ScriptDir
$speicherortini = $speicherort & "settings.ini"
$speicherort5 = ""


$username = "TEST"


$error = 0


#EndRegion Parameter


ProgressSet(35, "GUI laden")


#Region GUI
$gui1 = GUICreate("Test - " & $version, 550, 400, -1, -1)
$tab1 = GUICtrlCreateTab(0, 0, 550, 600)


#Region TABITEM1


$tabitem1 = GUICtrlCreateTabItem($username)
$Seitelabel = GUICtrlCreateLabel("Seite", 170, 34, 200)
$starten = GUICtrlCreateButton("aufnehmen", 32, 34, 129, 25, 0)
GUICtrlCreateLabel("Seite 1 bis Seite ", 32, 70)
$seite_eingabe = GUICtrlCreateInput("1", 110, 67, 40, 20)
GUICtrlCreateUpdown(-1)


$checkbox_nureineseite = GUICtrlCreateCheckbox("nur diese Seite?", 152, 67)
GUICtrlCreateGroup("Suche", 10, 90, 530, 65)


$input_suche = GUICtrlCreateInput("", 20, 107, 500, 20)
$label_suche = GUICtrlCreateLabel("ACHTUNG - Die Suche dauert länger -> nicht zuviele Seiten wählen", 20, 135, 500)


GUICtrlCreateLabel("Version : " & $version, 432, 50)
$button_update = GUICtrlCreateButton("Update verfügbar", 423, 70, 100)
GUICtrlSetState($button_update, $GUI_HIDE)


#EndRegion TABITEM1


#Region TABITEM2
$tabitem2 = GUICtrlCreateTabItem("Einstellungen")
#Region Zusatz
$x_zusatz = 10
$y_zusatz = 40
GUICtrlCreateGroup("Zusatz", $x_zusatz, $y_zusatz, 530, 80)


$checkbox_a = GUICtrlCreateCheckbox("a", $x_zusatz + 22, $y_zusatz + 20)
$checkbox_b = GUICtrlCreateCheckbox("b", $x_zusatz + 22, $y_zusatz + 50)
$checkbox_cc = GUICtrlCreateCheckbox("cc", $x_zusatz + 240, $y_zusatz + 20)
$input_datum = GUICtrlCreateInput("", $x_zusatz + 400, $y_zusatz + 20, 62)
GUICtrlSetData($input_datum, IniRead($speicherortini, "Einstellungen", "Datum", "10.04.2000"))
GUICtrlSetLimit($input_datum, 10)
$input_zeit = GUICtrlCreateInput("", $x_zusatz + 400, $y_zusatz + 40, 62)
GUICtrlSetData($input_zeit, IniRead($speicherortini, "Einstellungen", "Zeit", "00:00:00"))
GUICtrlSetLimit($input_zeit, 8)
#EndRegion Zusatz
#Region Filter
$x_filter = 10
$y_filter = 120
GUICtrlCreateGroup("Filter", $x_filter, $y_filter, 530, 140)
$checkbox_1 = GUICtrlCreateCheckbox("1", $x_filter + 20, $y_filter + 20)
GUICtrlSetTip(-1, "1")
$checkbox_2 = GUICtrlCreateCheckbox("2", $x_filter + 20, $y_filter + 50)
GUICtrlSetTip(-1, "2")
$checkbox_3 = GUICtrlCreateCheckbox("3", $x_filter + 20, $y_filter + 80)
GUICtrlSetTip(-1, "3")
$checkbox_4 = GUICtrlCreateCheckbox("4)", $x_filter + 20, $y_filter + 110)
GUICtrlSetTip(-1, "4")
$checkbox_5 = GUICtrlCreateCheckbox("5", $x_filter + 240, $y_filter + 20)
GUICtrlSetTip(-1, "5")
$checkbox_6 = GUICtrlCreateCheckbox("6", $x_filter + 240, $y_filter + 50)
GUICtrlSetTip(-1, "6")
$checkbox_7 = GUICtrlCreateCheckbox("7", $x_filter + 240, $y_filter + 80)
GUICtrlSetTip(-1, "7")
$checkbox_8 = GUICtrlCreateCheckbox("8", $x_filter + 240, $y_filter + 110)
GUICtrlSetTip(-1, "8")
#EndRegion Filter
#Region m
$x_md = 10
$y_md = 260
GUICtrlCreateGroup("M", $x_md, $y_md, 530, 60)
$button_a = GUICtrlCreateButton("ansehen", $x_md + 5, $y_md + 20, 60)
$button_s = GUICtrlCreateButton("speichern unter : ", $x_md + 80, $y_md + 20)
$label_datei = GUICtrlCreateLabel($speicherort5, $x_md + 180, $y_md + 25, 340)
#EndRegion m
#Region settings.ini
$x_settingsini = 10
$y_settingsini = 320
GUICtrlCreateGroup("settings.ini", $x_settingsini, $y_settingsini, 70, 60)
$button_settingsini_ansehen = GUICtrlCreateButton("ansehen", $x_settingsini + 5, $y_settingsini + 20, 60)
#EndRegion settings.ini
#Region temp ordner
$x_tempordner = 85
$y_tempordner = 320
GUICtrlCreateGroup("Temp Ordner", $x_tempordner, $y_tempordner, 90, 60)
$button_tempordner_ansehen = GUICtrlCreateButton("Ordner öffnen", $x_tempordner + 5, $y_tempordner + 20, 80)
#EndRegion temp ordner


#EndRegion TABITEM2


#Region TABITEM3
$tabitem3 = GUICtrlCreateTabItem("Datenbank")
$x_datenbank = 10
$y_datenbank = 30


;-----------------------------------------------------------------------------------------------------------------------------
;-----------------------------------------------------------------------------------------------------------------------------
;-----------------------------------------------------------------------------------------------------------------------------
;~ $group3 = _GuiCtrlGroup_Create($gui1, 'Datenbank', $x_datenbank, $y_datenbank, 530, 360)
$group3 = GUICtrlCreateGroup("Datenbank", $x_datenbank, $y_datenbank, 530, 360)
;-----------------------------------------------------------------------------------------------------------------------------
;-----------------------------------------------------------------------------------------------------------------------------
;-----------------------------------------------------------------------------------------------------------------------------


$checkbox_datenbank = GUICtrlCreateCheckbox("Datenbank benutzen?", $x_datenbank + 22, $y_datenbank + 20)
If IniRead($speicherortini, "Einstellungen", "Check_Datenbank", 1) = 1 Then GUICtrlSetState($checkbox_datenbank, $GUI_CHECKED)
$checkbox_ergebnisse_sichtbar = GUICtrlCreateCheckbox("Übereinstimmungen anzeigen?", $x_datenbank + 153, $y_datenbank + 20)
If IniRead($speicherortini, "Einstellungen", "Check_Ergebnisse_sichtbar", 1) = 1 Then GUICtrlSetState($checkbox_ergebnisse_sichtbar, $GUI_CHECKED)
$label_eintraege = GUICtrlCreateLabel("", $x_datenbank + 353, $y_datenbank + 23, 200, 30)
$input_datenbank_suche = GUICtrlCreateInput("", $x_datenbank + 22, $y_datenbank + 50, 490, 20)


Global $sHeader = "Filmname" ; Die Überschriften für das Listview und für das "Neuer Eintrag"-Fenster
Global $iEdit = -1 ; Wert auf -1 setzen, weil _GUICtrlListView_GetSelectionMark() einen Nullbasierten Wert liefert
Global $hListView = GUICtrlCreateListView($sHeader, $x_datenbank + 22, $y_datenbank + 80, 490, 230, $LVS_SHOWSELALWAYS)
Global $hLVHandle = GUICtrlGetHandle($hListView) ; das Handle vom Listview wird für die UDF-Listview-Funktionen benötigt
GUICtrlSetState($hListView, $GUI_HIDE)
_GUICtrlListView_SetColumn($hLVHandle, 0, "Test", 420, 0)
$button_delete = GUICtrlCreateButton("Datenbank löschen", 422, 350)
$button_delete_einzeln = GUICtrlCreateButton("Eintrag löschen", 31, 350)


#EndRegion TABITEM3


#Region TAB4
$tabitem4 = GUICtrlCreateTabItem("Was ist neu?")
$x_update = 10
$y_update = 50
GUICtrlCreateGroup("Updates", $x_update, $y_update, 530, 330)


$treeview = GUICtrlCreateTreeView($x_update + 15, $y_update + 15, 500, 300, BitOR($TVS_HASBUTTONS, $TVS_HASLINES, $TVS_LINESATROOT, $TVS_DISABLEDRAGDROP, $TVS_SHOWSELALWAYS), $WS_EX_CLIENTEDGE)
Dim $treeview_version[UBound($textitem_update, 1) + 1]
For $a = 1 To UBound($textitem_update, 1) - 1
    If $textitem_update[$a][0] <> "" Then $treeview_version[$a] = GUICtrlCreateTreeViewItem($textitem_update[$a][0], $treeview)
    For $i = 1 To UBound($textitem_update, 2) - 1
        If $textitem_update[$a][$i] <> "" Then GUICtrlCreateTreeViewItem($textitem_update[$a][$i], $treeview_version[$a])
    Next
    If $treeview_version[$a] = "" Then
        GUICtrlSetState($treeview_version[$a - 1], $GUI_EXPAND)
        GUICtrlSetState($treeview_version[$a - 2], $GUI_EXPAND)
        GUICtrlSetState($treeview_version[$a - 3], $GUI_EXPAND)
        ExitLoop
    EndIf
Next
#EndRegion TAB4


GUICtrlCreateTabItem("")
_GUICtrlTab_ClickTab($tab1, 0)
$info_tab = 0


#EndRegion GUI


ProgressSet(50, "Update überprüfen")


ProgressSet(70, "Datenbank laden")


#Region Datenbank Liste laden


GUICtrlSetData($Seitelabel, "lade Liste")
$info = $version
;Fake-Datenbank erstellen
$datenbank_inhalt = " "
For $i = 0 To 10000
    $datenbank_inhalt &= "test" & $i & "#*#"
Next
;ENDE Fake-Datenbank erstellen


If $datenbank_inhalt <> "" Then
    $datenbank_inhalt = $datenbank_inhalt
    $liste = StringSplit($datenbank_inhalt, "#*#", 1)


    _ArrayDelete($liste, 0)
    _ArrayDelete($liste, 0)
    _ArraySort($liste)
    $anzahl_eintraege = UBound($liste)
    $timer1 = TimerInit()
    _GUICtrlListView_BeginUpdate($hLVHandle) ; Listview sperren


    For $i = 0 To $anzahl_eintraege - 1


        GUICtrlCreateListViewItem($liste[$i], $hListView)
        If @error Then ExitLoop


    Next
    _GUICtrlListView_EndUpdate($hLVHandle) ; Listview wieder freigeben
    ConsoleWrite('Ersterstellung ' & TimerDiff($timer1) & @CRLF ) ;### Debug Console
    GUICtrlSetData($label_eintraege, $anzahl_eintraege & " Einträgen geladen")
    GUICtrlSetData($Seitelabel, $anzahl_eintraege & " Einträgen geladen")


Else


    GUICtrlSetState($checkbox_datenbank, $GUI_DISABLE)
    GUICtrlSetState($checkbox_ergebnisse_sichtbar, $GUI_DISABLE)
    GUICtrlSetData($Seitelabel, "Datenbank nicht gefunden")
    GUICtrlSetData($label_eintraege, "Datenbank nicht gefunden")
EndIf
GUICtrlSetState($hListView, $GUI_SHOW)


#EndRegion Datenbank Liste laden


ProgressSet(100)


ProgressOff()


GUISetState()


$zwischen = ""


While 1
    $ende = 0
    $nMsg = GUIGetMsg()
    Switch $nMsg
        Case $GUI_EVENT_CLOSE
            Exit
        Case $hListView ; User hat auf eine Spaltenüberschrift geklickt
            _GUICtrlListView_SortItems($hLVHandle, GUICtrlGetState($hListView)) ; Einträge entsprechend sortieren
        Case $tab1
            If GUICtrlRead($tab1) = 0 Then $info_tab = 0
            If GUICtrlRead($tab1) = 1 Then $info_tab = 1
            If GUICtrlRead($tab1) = 2 Then $info_tab = 2
            If GUICtrlRead($tab1) = 3 Then $info_tab = 3
    EndSwitch
    If $info_tab = 2 Then


        If GUICtrlRead($input_datenbank_suche) <> $zwischen Then
            $zwischen = GUICtrlRead($input_datenbank_suche)
            _update_datenbank()
        EndIf
    EndIf


    Sleep(50)
WEnd


Func _update_datenbank()
    $timer1 = TimerInit()
    GUICtrlSetState($hListView, $GUI_HIDE)
;~     GUISetState(@SW_LOCK, $hListView)


$timer3 = TimerInit()
;-----------------------------------------------------------------------------------------------------------------------------
;-----------------------------------------------------------------------------------------------------------------------------
;-----------------------------------------------------------------------------------------------------------------------------


    _GUICtrlListView_DeleteAllItems($hLVHandle)
;~ GUICtrlDelete($hListView)
;~ Global $hListView = GUICtrlCreateListView($sHeader, $x_datenbank + 22, $y_datenbank + 80, 490, 230, $LVS_SHOWSELALWAYS)
;~ Global $hLVHandle = GUICtrlGetHandle($hListView) ; das Handle vom Listview wird für die UDF-Listview-Funktionen benötigt
;~ _GUICtrlListView_SetColumn($hLVHandle, 0, "Test2", 420, 0) ; 1. Spalte = 120 Px breit, rechts ausgerichtet


;-----------------------------------------------------------------------------------------------------------------------------
;-----------------------------------------------------------------------------------------------------------------------------
;-----------------------------------------------------------------------------------------------------------------------------


    ConsoleWrite('nur löschen:  ' & TimerDiff($timer3) & @CRLF ) ;### Debug Console


    $zaehler = 0
    $insg = 0
    _GUICtrlListView_BeginUpdate($hLVHandle) ; Listview sperren
    For $i = 0 To $anzahl_eintraege - 1
        If $ende = 1 Then ExitLoop


            $gefunden_suche = StringRegExp($liste[$i], "(?i).*?" & GUICtrlRead($input_datenbank_suche), 0)
            If $gefunden_suche = 1 Then
                $zaehler += 1
                $timer4 = TimerInit()
;~                 _GUICtrlListView_AddItem($hLVHandle,$liste[$i])
                GUICtrlCreateListViewItem($liste[$i], $hListView)


                $insg += TimerDiff($timer4)
                If @error Then ExitLoop
            EndIf


    Next
    _GUICtrlListView_EndUpdate($hLVHandle) ; Listview wieder freigeben


    GUICtrlSetData($label_eintraege, $zaehler & " Einträgen geladen")
    ConsoleWrite('(' & @ScriptLineNumber & ') : nur hinzufügen $insg = ' & $insg & @CRLF) ;### Debug Console
    ConsoleWrite('insgesamt:  ' & TimerDiff($timer1) & @CRLF ) ;### Debug Console


    ConsoleWrite('----------------------------------' & @CRLF) ;### Debug Console
    GUICtrlSetState($hListView, $GUI_SHOW)
EndFunc   ;==>_update_datenbank

Immer die gleiche Vorgehensweise
einige Zeilen auskommentieren, dann Programm starten, in Tab3 gehen, ins Inputfeld eine 1 tippen, warten und in die Console schauen.

Um diese Zeilen geht es (einfach per STRG+Q auskommentieren bzw. wieder reinbringen):
Zeile 152: _GuiCtrlGroup_Create
Zeile 153: GuiCtrlCreateGroup
Zeile 308-312: Listview leeren bzw. löschen

Variante1 (normale GuiCtrlCreateGroup,Listview leeren):

Ersterstellung 71.1722469699422
nur löschen: 2034.77237302716
(342) : nur hinzufügen $insg = 6335.95952541161
insgesamt: 8487.79612799918

Variante2 (komplett ohne GuiCtrlCreateGroup,Listview leeren):

Ersterstellung 77.6267173166847
nur löschen: 2255.17422300204
(342) : nur hinzufügen $insg = 1346.96704625789
insgesamt: 3706.29178839422

Variante 3 (normale GuiCtrlCreateGroup,Listview löschen):
Zeile 153
Zeilen 308 bis 312 strg+q

Ersterstellung 78.545572240156
nur löschen: 524.298210498522
(342) : nur hinzufügen $insg = 29.5134020969787
insgesamt: 675.303176130895

Variante 4 für die, die BugFix groupex benutzen (mit _GuiCtrlGroup_Create,Listview leeren):
Zeilen 308 bis 312 Strg+q
Zeile 152 und 153 Strg+q
Zeile 9 strg+q

Ersterstellung 79.0579778037085
nur löschen: 1973.03465721805
(342) : nur hinzufügen $insg = 1791.06015825291
insgesamt: 3871.39438023286

EDIT: Spoiler hinzugefügt

@BugFix

Test:

mit Standard GuiCtrlCreateGroup: 4400ms
mit deiner _GuiCtrlGroup_Create: 1600ms
ohne alles: 1200ms

Super, wie auch immer das möglich ist.
Ich schaue mir deine groupex mal genauer an.

Ahh, wahrscheinlich wird mit deinem _GuiCtrlGroup_Create UM mein Listview gezeichnet (gelabeled ), während GuiCtrlCreateGroup (weshalb auch immer) auch den Bereich innen ändert.

Guten Morgen,

vielen Dank für euren Beitrag.

Ich war ja nun der Meinung, dass Löschen das Maß aller Dinge ist. Musste aber feststellen, dass es Komplikationen gibt, wenn das neu erstellte Element in einem anderen Tab ist.
Plötzlich hatte das Listview alle anderen Elemente von den anderen Tabs überdeckt.

Ärgerlich, da ich aber einfach zu faul war, jetzt auch noch Lösungen zu finden wie man das Listview wieder nur in Tab 3 bekommt, habe ich das guictrlcreategroup gelöscht und lebe zufrieden.

Für meine Zwecke reicht es ja, ABER es läßt mich nicht los. Irgendwann kann ich vielleicht nicht mehr mit paar Sekunden mehr leben und stehe vor dem selben Problem.

Daher KloMeister:

Ich denke, dieser Ansatz ist super, wenn man sehr viele Elemente im Bild hat.
Und bringt mich auf die Idee: macht es einen Unterschied, ob beim Listview füllen, die sich im Bild befindenen Elemente, kurz vorher oder viel früher erstellt wurden? (Z.B. eine vor, das andere nach GuiSetState)

In meinem speziellen Fall wüßte ich nicht, wie ich mit Screencapture ein GuiCtrlCreateGroup "emuliere". Nebenbei würde es das GuiCtrlCreateGroup ad absurdum führen.
Wenn ich meine zwei Buttons entferne die sich unter dem Listview befinden, ändert sich nichts. Ein ScreenCapture über die Listview, wäre ja wie ein GuiCtrlCreateGroup über dem Listview, also das gleiche Ergebnis?
Probieren werde ich es aber auf jeden Fall.

Andy:
Es gibt ja schon die Variante bei PHP und HTML, dass man mit Seiten arbeitet, um nur einen kleinen Bereich und nicht alles anzuzeigen.
Würde ich das auch machen mit meinem Listview, müsste aber theoretisch immer noch das Problem GuiCtrlCreateGroup bestehen. Zwar zeitmäßig uninteressant, aber vorhanden.
Theoretisches Beispiel:
mit GuiCtrlCreateGroup: 60ms
ohne GuiCtrlCreateGroup: 20ms

Ich werde nochmal testen, alle Elemente die sichtbaren wie unsichtbaren, die sich aber theoretisch hinter oder vor dem Listview befinden zu entfernen. (Beispiel: mein Listview ist in Tab3 in Tab 2 und 4 befinden sich auf Höhe des Listview Buttons oder Text u.ä.)
Mal sehen, ob die nicht auch Geschwindigkeit klauen.

Viele Grüße

Morgen,

habe meine Datenbank einfach auf 13000 Einträge erweitert

mit GUICtrlCreateGroup = 18000ms
ohne GUICtrlCreateGroup = 4000ms
direkt nach GUI-Erstellung = 200ms

Mein Listview fülle ich, in dem ich es erst verstecke (hide) -> _BeginUpdate -> Füllen -> _EndUpdate -> sichtbar machen (show).
Möglichweise bringt das _BeginnUpdate bei 2d-Arrays, mehr Bedingungen oder viel größeren Datenbanken mehr. Bei mir aber war es recht wenig.

Was weit mehr bringt ist das Verstecken des Listview, was sich ja mit der Erkenntnis, dass das GUI schuld hat ja deckt.
Sobald man etwas flackern sieht, ist es langsam.

Im übrigen , wenn ohne hide und _BeginUpdate arbeite sieht man ja das Befüllen des Listviews.
Und ich erinnere mich an ein früheres, sehr spartanischen mit GUI ausgestatteten Projekt, dort konnte ich das Befüllen sehr gut verfolgen (in der rechten Leiste wurde der Schiebebalken immer kleiner). Beim jetzigen Programm sieht man nur Flackern, erst wenn man das Listview löscht und neu befüllt und dabei mal nicht versteckt kann man das Füllen wieder beobachten.

Das mit dem _GuiCtrlListView_DeleteAllItems werde ich mir noch anschauen, obwohl ich ja eh das GUI komplett löschen muss, um volle Geschwindigkeit zu bekommen.
Daher wäre das GuiDelete wichtiger.
Ich muss aber gestehen, dass ich eigentlich es lieber hätte, wenn ich mein erstelltes GUI nicht mehr anfassen müsste.

Aso, gerade noch getestet, wenn ich bei mir nicht nur das Listview verstecke, sondern auch GUICtrlCreateGroup, dann verschwindet auch die Leistungsbremse, als wenn es nicht da wäre.

Aber was heißt dass nun, um max. Geschwindigkeit zu erhalten?
Nach meiner Erkenntnis:

Vor jeder Befüllung GUI-Element löschen, versteckt erstellen und befüllen!
(Habe listbox und Edit Elemente nicht getestet)

Aber was wenn man diese Elemente aber nicht löschen kann, aus welchen Gründen auch immer?

Wie kann man Leistungsbremsen, wie ein GUICtrlCreateGroup (das nichts weiter als ein kleiner Rahmen ist, nichts bedeutendes) ausfindig machen (es ist ja nicht jedes, sondern nur das eine um das zu befüllende Element)?

Will man bei bestimmten Aktionen, wie von Andy vorgeschlagen, alles verstecken? Sieht sicher komisch aus, schon nur ein GUICtrlCreateGroup zu verstecken bei Befüllen von einem Listview wirkt eigenartig (aber um 4 Sekunden zu sparen bzw im oberen Beispiel 14 Sekunden wäre es es sicher wert).
Soll ich alle GUI Elemente durchtesten bis ich den Übeltäter habe oder gibt es vielleicht etwas worauf man achten kann? Z.B. erstelle ein Tab mit einem Listview immer zuerst oder schreibe GUI-Anweisungen immer nur mit der Nasenspitze, statt mit den Fingern.

Ach...für mich alles ein Rätsel.

Hallo liebe Community,

ich habe mich entschlossen, diese Zeilen hier zu schreiben, weil ich Stunden auf der Suche nach einem Fehler verbracht habe und davon gerne erzählen möchte.

Das allseits beliebte GUICtrlCreateListViewItem!

Ich habe einige Zeit in Foren verbracht, in denen verschiedenste Methoden ausdiskutiert wurden, wie man nun "GUICtrlCreateListViewItem" schneller hinbekommt. Oft genug wurde es mir zu kompliziert und womöglich war es auch gar nicht das Problem das ich hatte.

Mein Problem war eine Datenbank mit etwa 4400 Einträgen in einem Listview, erstellt mit GUICtrlCreateListViewItem in einer FOR-Schleife. Sobald in einem Input-Feld ein Buchstabe eingegeben wurde, wurde mit einer gleichen FOR-Schleife das Listview geleert und neu befüllt in dem das Item erstellt wird, wenn die Bedingung erfüllt ist (Update-Funktion).

Das Eingeben eines Buchstaben reduzierte die Datenbankausgabe auf 3200 Einträge und dauerte 6000ms. 6 Sekunden waren mir zu lang. Daraufhin Foren durchgestöbert und einige Varianten getestet: _GUICtrlListView_AddItem und _GUICtrlListView_AddArray, beides mit Geschwindigkeitserfolg, auch $SW_HIDE und _GUICtrlListView_BeginUpdate haben zum Erfolg geführt, aber waren immer noch viel zu langsam.
Denn beim Testen ist dann aufgefallen: beim Starten meines Programms wird das Listview auch schon gefüllt und es dauerte nur 70ms (!) mit mehr Einträgen.
Daraufhin habe ich die Update-Funktion mal an anderen Stellen gepackt und dabei entdeckt: NACH GuiSetState() (also nach dem ganze GUI) 6000ms -> VOR GuiSetState 70ms !!!

Mit anderen Worten der Geschwindigkeitsverlust kommt NUR durch das GUI. Selbst wenn ich die Liste vor dem Updaten nicht gelöscht habe ist es etwas über 6000ms gegangen (knapp doppelte Menge, also knapp 70ms mehr als vorher).

Und jetzt kommt es. Der Hauptübeltäter war ein GUICtrlCreateGroup das den Listview einrahmte.

mit GUICtrlCreateGroup = 6000ms
ohne GUICtrlCreateGroup = 1400ms

Daraufhin jedes GUICtrlCreateGroup rausgenommen: trotzdem nur 1400ms

GUICtrlCreateGroup wieder hinzugenommen:
1. Start 4300ms
2. Start 5000ms
danach wieder 6000ms nach jedem Start.

Und nu würde ich gerne von den Profis wissen, WARUM ist das so?

Ich habe versucht es in einem Testprogramm zu reproduzieren, aber es reicht nicht nur eine Group hinzuzufügen, es müssen wohl weit mehr Elemente sein. Denn auch die 1400ms sind ja nicht das Beste.

Für die, die sich durch die Textwüste gekämpft haben:
um auf die 70ms wiederzukommen muss man das GUI-Listview Element löschen und wieder neu erstellen. Natürlich sind die 70ms nur das Füllen vom Listview....löschen vom GUI-Element oder das Leeren vom Listview kostet natürlich auch Zeit.

Vielen Dank fürs Durchlesen.

au backe, was für ein Unterschied...

......habe gerade mal einen Test gemacht und meine Daten mit inireadsection anstatt iniread einzulesen.... Mußte aber auch extra Kontrollen einbauen......da ab und zu einige keys in manchen sectionen nicht vorhanden sind. Inireadsection würde also als $var[4][0] z.B. GR liefern während in einer anderen Section GR erst an 5ter Stelle kommt also $var[5][0]....die Rechnung würde fehlerbehaftet sein.
Trotzdem brachte es einfach mal über 1 Sek Ersparnis statt 3,7 war ich bei 2,4. (Meine Abfrage war ganz simpel per if $var[4][0] = "GR")

Aber einen so starken Vorteil durch Stringexp war ich mir nicht bewußt.

Muß mir das jetzt erstmal ganz genau anschauen.

So habe mal kurz was zum Testen erstellt...

Mit erstellen, wird die Inidatei erstellt. (damit gleiche Verhältnisse sind).
Mit berechnen werden die Daten die relevant sind gelesen, berechnet und ausgegeben.
Also zum Testen brauchen wir nur den berechnen-Button.

...in etwa so funktioniert mein Programm(nur das halt nicht immer die ganze Ini erstellt wird, sondern nur um geänderte Werte aktualisiert wird).

Das berechnen habe ich immo genau so bei mir drin....aus ini einlesen (was hier iniread mit ner for schleife und $k steht, habe ich bei mir einzelene inireads, da ich keine Zahlen sondern Namen als keys habe), dann alles berechnen, Bedingungen abfragen usw. und als Listviewitem ausgeben.

#include <GUIConstantsEx.au3>
#include <ListViewConstants.au3>
#include <WindowsConstants.au3>

$Form1 = GUICreate("Form1", 625, 443, 192, 124)
$button_erstellen = GUICtrlCreateButton("erstellen", 64, 40, 89, 25, $WS_GROUP)
$button_berechnen = GUICtrlCreateButton("berechnen", 328, 40, 105, 25, $WS_GROUP)
$listview_anzeige = GUICtrlCreateListView("1|2|3|4|5|6|7|8|9|10|11|12|13|14|15", 88, 88, 345, 225)
$label_zeit = GUICtrlCreateLabel("Zeit", 100, 350)
GUISetState(@SW_SHOW)

While 1
$nMsg = GUIGetMsg()
Switch $nMsg
Case $GUI_EVENT_CLOSE
Exit
Case $button_erstellen
_erstellen()
Case $button_berechnen
_berechnen()
EndSwitch
WEnd

Func _erstellen()
For $j = 1 To 200
For $k = 1 To 30
IniWrite("geschwindigkeitstest.ini", $j, $k, Random(1, 20000, 1))
Next
Next
EndFunc ;==>_erstellen

Func _berechnen()
$timer1 = TimerInit()
Dim $vars[31]
$maximal = IniReadSectionNames("geschwindigkeitstest.ini")
For $j = 0 To $maximal[0]
For $k = 0 To 30
$vars[$k] = IniRead("geschwindigkeitstest.ini", $j, $k, 0)
Next
$test1 = $vars[1] * $vars[4]
$test2 = $vars[2] * $vars[5]
$test3 = $vars[3] * $vars[6]
$test4 = $vars[4] * $vars[7]
$test5 = $vars[5] * $vars[4] / $vars[1] * $vars[9]

$item = GUICtrlCreateListViewItem($test1 & "|" & $test2 & "|" & $test3 & "|" & $test4 & "|" & $test5 & "|", $listview_anzeige)
Next
GUICtrlSetData($label_zeit, TimerDiff($timer1))
EndFunc ;==>_berechnen

Guten Morgen, habe heute mal nachgeschaut, es sind genau 240 sections mit je 21 (aber noch steigend) values

habe eben die komplette Func per Timer gemessen.

Der komplette Datensatz einlesen, berechnen und in einem Listview ausgeben (wobei dort nicht alle 21 values gelistet werden) hat etwa um die 3,3 sek gedauert, danach habe ich das erstellen der listviewitems rausgenommen und bin auf eine Zeit um die 1,5 sek gekommen.

Bei 100 Datensätzen dauerte es mit listview 1,2 seks ohne etwa 0,4 seks.

nochmal zusammengefasst:

240 datensätze = 3,3 (mit listview) 1,5 (ohne listview)
100 datensätze = 1,2 (mit listview) 0,4 (ohne listview)

hmm vielleicht bin ich da zu oberflächlich rangegangen und habe die ini beschuldigt, obwohl ich mir listview genauer ansehen müßte.

Ich werde erstmal paar Test durchführen, mit dem einmal einlesen bis zum Beenden vom Programm. Da würde ich die oben genannten 3,3 Sekunden nur einmal am Start haben, was verschmerzbar ist, denke ich mal.
Oder ich schaue mir auch mal das von euch genannte SQLite an.

Ich hatte am Anfang die Daten in 2 txt-Dateien aufgeteilt, sozusagen die sections in der einen, die values in der anderen. Vielleicht sollte ich das auch mal testen, ob es dort einen Geschwindigkeitszuwachs gibt.

Und ich werde die Ausgabe vom Listview noch weiter begrenzen, also alle nicht relevanten nicht als item erzeugen lassen.

Gut habe ich erstmal was zu tun.....ich danke euch für eure Unterstützung.

Wem noch etwas einfällt, immer her damit

Erstmal danke schön für eure Antworten

Ja also ich muß zugeben ich missbrauche die ini als datenbank, einfach weil bestimmte funktionen halt schon gegenben sind, wie z.B. wenn die section schon enthalten ist, wird nur der value wert aktualisiert oder hinzugefügt und das nur durch den einen Befehl iniwrite; für mich kompfortabler.

Wegen dem Ablauf....1. Lade Seite 2. Daten parsen 3. in ini speichern 4.1-3 mehrmals wiederholen 5. zusammenfassung (ini wird geladen und in listview ausgegeben)

mehr ist es nicht.....und das speichern geht sehr schnell nur halt das ausgeben der ini in dem listview dauert immer länger und länger, da die daten nun mal immer mehr werden. Dabei muß ich per inireadsection alles auslesen, da die Daten etwa diese Form haben:

[D234 2424234 867654]
Ko=2424234
Ki=867654
Gr=55555
GF=2323

möglicherweise liegt es aber am listview?....je mehr daten drin sind desto langsamer wird es?

Nagut...ich schaue mir mal externe Datenbanken an die ich mit autoit ansprechen kann.......muß jetzt aber erstmal zur arbeit....ich schaue morgen nochmal rein

Hallo ihr,

gibt es eine schnellere Alternative als die ini-Datei?

Die Inistruktur entspricht genau dem was ich brauche, nur leider sind die Datensätze mitlerweile so groß geworden das das Einlesen merklich länger dauert.

Oder gibt es eine andere Art des Einlesens?

Bsp.: Ich habe 100 Sections mit je 20 Values, um nach einer Spalte sortieren zu können muß ich nun 2000 Values einlesen (theoretisch nur 100x20, da ich aber nach der Sortierung die anderen Values mit anzeige, lese ich alle restlichen values je section mit ein)

Oder statt sortieren, wenn ich nur die Datensätze anzeigen will deren Value mit einer Bedingung übereinstimmt und es wird z.B. nur von einem section erfüllt....muß ich um dies herauszufinden trotzdem alle einlesen, gibt es da Möglichkeiten?

Vielen Dank für eure Hilfe

Scheint wirklich niemanden zu geben der das Problem lösen kann.

Ich hätte dann nur noch eine Frage an die die sich hier her verirren:

Was macht ihr wenn der Platz für die Steuerelemente nicht ausreicht???

Nagut....ich denke mal ich muß von dem Ansatz 2 Guis (1. Hauptfenster 2. Bedienfenster scrollbar) wegkommen.

Hat denn womöglich einer eine Idee was ich anstelle dieser Methode machen könnte?

Wie gesagt einfach alles in einem Fenster funktioniert gut....aber dieses Scrollen das mir den ie embedded mit wegscrollt ist nervig.

Ich bedanke mich aber trotzdem nochmal an die 3 die versucht haben mir zu helfen.

Hallo Sprenger120

Habe gleich mal ein

GUISwitch($gui2,$input)

bzw ein

GUISwitch($gui2)

in meine while 1 reingehauen.

Trotz allem liegt der fokus auf dem google eingabefeld....auch mehrmals hin und her klicken hat den selben Effekt.

guiswitch zeigt keine Wirkung.

Trotzdem Danke für die Idee....bin ganz freudig ins scite gesprungen und hatte schon gedacht...mensch...na klar....so was einfaches.

Guten Morgen (Auto)Bert,

habe mir dein Beispiel man näher angeschaut.
Wenn du mich auf etwas spezielles hinweisen wolltest, dann habe ich es warscheinlich großzügig übersehen....entschuldige bitte.

Aber du hast im Grunde auch nur ein GUI-Fenster auf dem die Steuerelemente sowie das ie-Fenster sitzen.

Wenn ich mein Programm auch nur mit einem GUI-Fenster mache, gibt es bei mir auch keine Probleme.
Es scheint nur der Wechsel vom ie Fenster ins zweite GUI-Fenster problematisch zu sein.

Ich bin noch etwas am herumexperimentieren mit dieser Zeile:

ObjEvent($oIE, "IEEvent_", "DWebBrowserEvents2")

und

$SinkObject = 0 ; IE Eventzuweisung aufheben

da dieses Eventaufheben interessant klingt. Aber im Grunde ist es ja kein richtiges Event im ie das gestartet wurde.

Habe in deinen Code einmal das GUI2 von mir eingebaut und die Seite Google.de genommen (weil dort gleich ein Eingabefenster ist). Die Elemente sind alle im zweiten Fenster.....habe aber den gleichen Fehler....sobald ich in der Google-Eingabe-Zeile war funktionieren die Cursortasten nur noch im ie-Fenster.

Hallo Bitboy, danke für deinen Vorschlag.

Das Problem ist dann aber das die 2te GUI nicht mehr an die erste gebunden ist und auch von der ersten überlagert wird.

Ziel ist ein eigentlich ein Hauptfenster mit embedded object und ein 2tes GUI das größer (mit Hilfe von Scrollbars) per WS_POPUP ans GUI 1 gebunden ist.

Alle Elemente befinden sich auf dem zweiten GUI.

Im Grunde könnte ich auch 2te GUI weglassen....dann aber wäre der Scrollbalken ganz rechts am ersten GUI und ich würde das embedded object mit scrollen. Dieses soll aber stehen bleiben und nur die "Menüführung" also GUI 2 soll sich bewegen.

habe oben den Quelltext nochmal minimal abgeändert.

So soll es eigentlich aussehen: UDF scrollbar is im anhang