refix methods 'GetLastVisibleNoInit' (and 'GetLastVisible') to return correct results even if some ancestor of the last visible node is effectively not visible itself

Changes from commit 8df8d6 for issue #725 performance reintroduced a regression, that prevents method 'TBaseVirtualTree.GetLastVisibleNoInit' from returning a visible node if some of its ancestors are hidden. That is because methods 'TBaseVirtualTree.GetLastVisibleChildNoInit' and 'GetPreviousVisibleSiblingNoInit' both only consider direct children of given 'Node' but ignore other descendant nodes' visibility.

- completely revised method 'TBaseVirtualTree.GetLastVisibleNoInit'
- kept the top-down-traversal algorithm of commit 8df8d6 in particular for optimal performance
- iteratively checked expansion state (but not visibility) of every ancestor of given 'Node' in the first place to prevent a false-positive result in an effectively collapsed subtree
- added conditional recursion for expanded nodes having some visible children (i.e. using fast 'vsAllChildrenHidden' state) as a local function 'IterateChildren'
- apply 'ChildrenAbove' option on the conditions' precedence:
  - for top-down trees prefer visible children over their visible parent
  - for bottom-up trees prefer a visible node over its visible children
  - therefore extracted main condition as a local function 'GetNodeIsVisible' and recursion condition as a local function 'GetNodeHasVisibleChildren'
! thus a visible subnode under some effectively invisible but expanded ancestor will be found again

Author: René Hoffmann

Source/VirtualTrees.pas

@@ -28067,25 +28067,73 @@ function TBaseVirtualTree.GetLastVisibleNoInit(Node: PVirtualNode = nil;
   ConsiderChildrenAbove: Boolean = True; IncludeFiltered: Boolean = False): PVirtualNode;
 
 // Returns the very last visible node in the tree while optionally considering toChildrenAbove.
+// Note that the visibility of all ancestor nodes of the resulting node must not be considered.
 // No initialization is performed.
-var
-  Next: PVirtualNode;
 
-begin
-  Result := GetLastVisibleChildNoInit(Node, IncludeFiltered);
-  if not ConsiderChildrenAbove or not (toChildrenAbove in FOptions.PaintOptions) then
-    while Assigned(Result) and (vsExpanded in Result.States) do
+  //--------------- local functions -------------------------------------------
+
+  function GetNodeIsVisible(ChildNode: PVirtualNode): Boolean;
+  begin
+    Result := (vsVisible in ChildNode.States) and
+              (IncludeFiltered or not IsEffectivelyFiltered[ChildNode]);
+  end;
+
+  function GetNodeHasVisibleChildren(ChildNode: PVirtualNode): Boolean;
+  begin
+    Result := (vsHasChildren in ChildNode.States) and
+              (vsExpanded in ChildNode.States) and
+              not (vsAllChildrenHidden in ChildNode.States);
+  end;
+
+  function IterateChildren(ParentNode: PVirtualNode): PVirtualNode;
+  var
+    Run: PVirtualNode;
+  begin
+    Result := nil;
+
+    Run := GetLastChildNoInit(ParentNode); // Do not use 'GetLastVisibleChildNoInit' here (see above).
+    while Assigned(Run) do
     begin
-      // Test if there is a next last child. If not keep the node from the last run.
-      // Otherwise use the next last child.
-      Next := GetLastChildNoInit(Result);
-      if Assigned(Next) and (not (vsVisible in Next.States) or
-         (not IncludeFiltered and IsEffectivelyFiltered[Next])) then
-        Next := GetPreviousVisibleSiblingNoInit(Next, IncludeFiltered);
-      if Next = nil then
-        Break;
-      Result := Next;
+      if ConsiderChildrenAbove and (toChildrenAbove in FOptions.PaintOptions) then
+      begin
+        if GetNodeIsVisible(Run) then
+          Result := Run
+        else if GetNodeHasVisibleChildren(Run) then
+          Result := IterateChildren(Run);
+      end else
+      begin
+        if GetNodeHasVisibleChildren(Run) then
+          Result := IterateChildren(Run)
+        else if GetNodeIsVisible(Run) then
+          Result := Run;
+      end;
+
+      if Assigned(Result) then
+        break;
+
+      Run := GetPreviousSiblingNoInit(Run);
     end;
+  end;
+
+  //--------------- end local functions ---------------------------------------
+
+var
+  Run: PVirtualNode;
+
+begin
+  Result := nil;
+
+  // First, check wether the given node and all its parents are expanded.
+  // If not, there can not be any visible child node.
+  Run := Node;
+  while Assigned(Run) and (Run <> RootNode) do
+  begin
+    if not (vsExpanded in Run.States) then
+      exit;
+    Run := Run.Parent;
+  end;
+
+  Result := IterateChildren(Node);
 end;
 
 //----------------------------------------------------------------------------------------------------------------------