Changeset 12399

Timestamp:

08/30/10 02:39:48 (18 months ago)

Author:

adamk

Message:

Change Padre::Cache to use methods, for cleanliness.
Trying to fix second-order issues in the directory tree.

Location:

trunk/Padre/lib/Padre

Files:

• Cache.pm (modified) (2 diffs)
• Document.pm (modified) (1 diff)
• Project.pm (modified) (2 diffs)
• Wx/Directory.pm (modified) (10 diffs)
• Wx/TreeCtrl.pm (modified) (1 diff)

trunk/Padre/lib/Padre/Cache.pm

@@ -14 +14 @@
 
 sub stash {
+    my $class = shift;
     my $owner = shift;
     my $key   = shift;
@@ -29 +30 @@
 
     $DATA{$key}->{$owner}
-        or $DATA{$key}->{$owner} = {};
+    or $DATA{$key}->{$owner} = {};
 }
 
 sub release {
-    delete $DATA{ $_[0] };
+    delete $DATA{ $_[1] };
 }
 

trunk/Padre/lib/Padre/Document.pm

@@ -343 +343 @@
 sub DESTROY {
     if ( defined $_[0]->{filename} ) {
-        Padre::Cache::release( $_[0]->{filename} );
+        Padre::Cache->release( $_[0]->{filename} );
     }
 }

trunk/Padre/lib/Padre/Project.pm

@@ -6 +6 @@
 use strict;
 use warnings;
-use File::Spec ();
+use File::Spec   ();
+use Padre::Cache ();
 
 our $VERSION = '0.69';
@@ -317 +318 @@
     if ( defined $_[0]->{root} ) {
         require Padre::Cache;
-        Padre::Cache::release( $_[0]->{root} );
+        Padre::Cache->release( $_[0]->{root} );
     }
 }

trunk/Padre/lib/Padre/Wx/Directory.pm

@@ -56 +56 @@
     # Where is the current root directory of the tree
     $self->{root} = '';
-
-    # The list of all files to build into the tree
-    $self->{files} = [];
-
-    # The directories in the tree that should be expanded
-    $self->{expand} = {};
 
     # Create the search control
@@ -194 +188 @@
             # Leaving search mode
             $self->{searching} = 0;
-            $search->ShowCancelButton(0);
             $self->task_reset;
             $self->clear;
+            $self->refill;
             $self->browse;
         } else {
@@ -208 +202 @@
         } else {
             # Entering search mode
-            $self->{expand}    = $self->tree->expanded;
+            $self->{expand}    = $self->tree->GetExpandedPlData;
             $self->{searching} = 1;
             $search->ShowCancelButton(1);
@@ -260 +254 @@
 }
 
+# Refill the tree from storage
+sub refill {
+    my $self   = shift;
+    my $tree   = $self->{tree};
+    my $files  = delete $self->{files};
+    my $expand = delete $self->{expand} or return;
+    my @stack  = $tree->GetRootItem;
+    foreach my $i ( 0 .. $#$files ) {
+        my $path  = $files->[$i];
+        my $image = $path->type ? 'folder' : 'package';
+        unless ( $tree->GetPlData($stack[-1])->GetData->is_parent($path) ) {
+            if ( $files->[$i - 1]->is_parent($path) ) {
+                # Descending
+                push @stack, $tree->GetLastChild($stack[-1]);
+            } else {
+                # Ascending
+                while ( @stack ) {
+                    pop @stack;
+                    if ( $tree->GetPlData($stack[-1])->GetData->is_parent($path) ) {
+                        last;
+                    }
+                }
+            }                   
+        }
+        $tree->AppendItem(
+            $stack[-1],                   # Parent node
+            $path->name,                  # Label
+            $tree->{images}->{$image},    # Icon
+            -1,                           # Wx Identifier
+            Wx::TreeItemData->new($path), # Embedded data
+        );
+    }
+}
+        
 
 
@@ -285 +313 @@
     );
 
-    # Before we change anything, store the expansion state
-    unless ( $self->searching ) {
-        $self->{expand} = $self->tree->expanded;
-    }
-
     # Switch project states if needed
     unless ( $self->{root} eq $root ) {
@@ -297 +320 @@
         # if we potentially need it again later.
         if ( $ide->project_exists( $self->{root} ) ) {
-            my $stash = Padre::Cache::stash(
+            my $stash = Padre::Cache->stash(
                 __PACKAGE__ => $ide->project( $self->{root} ),
             );
-            %$stash = (
-                root   => $self->{root},
-                files  => $self->{files},
-                expand => $self->{expand},
-            );
-        }
-
-        # Flush the now-unusable state
+            if ( $self->{searching} ) {
+                # Save the stored browse state
+                %$stash = (
+                    root   => $self->{root},
+                    files  => $self->{files},
+                    expand => $self->{expand},
+                );
+            } else {
+                # Capture the browse state fresh.
+                %$stash = (
+                    root   => $self->{root},
+                    files  => $self->tree->GetChildrenPlData,
+                    expand => $self->tree->GetExpandedPlData,
+                );
+            }
+        }
+
+        # Flush the now-unusable local state
+        $self->clear;
         $self->{root}   = $root;
-        $self->{files}  = [];
-        $self->{expand} = {};
+        $self->{files}  = undef;
+        $self->{expand} = undef;
 
         # Do we have an (out of date) cached state we can use?
-        # If so, display it immediately and update it later.
-        if ($project) {
-            my $stash = Padre::Cache::stash(
+        # If so, display it immediately and update it later on.
+        if ( $project ) {
+            my $stash = Padre::Cache->stash(
                 __PACKAGE__ => $project,
             );
             if ( $stash->{root} ) {
-
                 # We have a cached state
-                $self->{files}  = $stash->{files};
                 $self->{expand} = $stash->{expand};
             }
@@ -327 +359 @@
 
         # Flush the search box and start the rerender
-        $self->clear;
-        $self->browse;
+        if ( $self->{expand} ) {
+            $self->browse( @{$self->{expand}} );
+        } else {
+            $self->browse;
+        }
     }
 
@@ -334 +369 @@
 }
 
-sub refresh_finish {
+
+
+
+
+######################################################################
+# Browse Methods
+
+sub browse {
     TRACE( $_[0] ) if DEBUG;
     my $self = shift;
-    my $task = shift;
-    $self->{files} = $task->{model};
-    $self->refresh_render;
-}
-
-# This is a primitive first attempt to get familiar with the tree API
-sub refresh_render {
-    TRACE( $_[0] ) if DEBUG;
-    my $self   = shift;
-    my $tree   = $self->tree;
-    my $root   = $tree->GetRootItem;
-    my $expand = $self->{expand};
-
-    # Flush the old tree contents
-    # TO DO: This is inefficient, upgrade to something that does the
-    # equivalent of a treewise diff application, modifying the tree
-    # to get the result we want instead of rebuilding it entirely.
-    my $lock = $self->main->lock('UPDATE');
-    $tree->DeleteChildren($root);
-
-    # Fill the new tree
-    my @stack = ();
-    my @files = @{$self->{files}};
-    while (@files) {
-        my $path  = shift @files;
-        my $image = $path->type ? 'folder' : 'package';
-        while (@stack) {
-
-            # If we are not the child of the deepest element in
-            # the stack, move up a level and try again
-            last if $tree->GetPlData( $stack[-1] )->is_parent($path);
-
-            # We have finished filling the directory.
-            # Now it (maybe) has children, we can expand it.
-            my $complete = pop @stack;
-            if ( $expand->{ $tree->GetPlData($complete)->unix } ) {
-                $tree->Expand($complete);
-            }
-        }
-
-        # If there is anything left on the stack it is our parent
-        my $parent = $stack[-1] || $root;
-
-        # Add the next item to that parent
-        my $item = $tree->AppendItem(
-            $parent,                      # Parent node
-            $path->name,                  # Label
-            $tree->{images}->{$image},    # Icon
-            -1,                           # Wx Identifier
-            Wx::TreeItemData->new($path), # Embedded data
-        );
-
-        # If it is a folder, it goes onto the stack
-        if ( $path->type == 1 ) {
-            push @stack, $item;
-        }
-    }
-
-    # Apply the same Expand logic above to any remaining stack elements
-    while (@stack) {
-        my $complete = pop @stack;
-        if ( $expand->{ $tree->GetPlData($complete)->unix || 0 } ) {
-            $tree->Expand($complete);
-        }
-    }
-
-    return 1;
-}
-
-
-
-
-
-######################################################################
-# Browse Methods
-
-sub browse {
-    TRACE( $_[0] ) if DEBUG;
-    my $self = shift;
-    my $path = shift || Padre::Wx::Directory::Path->directory;
     return if $self->searching;
 
@@ -425 +387 @@
         on_message => 'browse_message',
         on_finish  => 'browse_finish',
-        list       => [ $path ],
+        list       => [ @_ ? @_ : Padre::Wx::Directory::Path->directory ],
     );
 
@@ -475 +437 @@
     my $task = shift;
 }
+
 
 

trunk/Padre/lib/Padre/Wx/TreeCtrl.pm

@@ -35 +35 @@
 }
 
+# Fetch a list of all Perl data elements for all nodes
+# in depth-first top-to-bottom order.
+sub GetChildrenPlData {
+    my $self  = shift;
+    my @queue = $self->GetRootItem;
+    my @data  = ();
+    while ( @queue ) {
+        my $item = shift @queue;
+        push @data, $self->GetPlData($item)->GetData;
+
+        # Continue if we have no child nodes
+        next unless $self->GetChildrenCount( $item, 0 );
+
+        # Processing children last to first and unshifting onto the
+        # queue, lets us achieve depth-first top-down within the need
+        # for intermediate storage or grepping.
+        my ( $child, $cookie ) = $self->GetLastChild($item);
+        while ( $cookie ) {
+            unshift @queue, $child;
+            ( $child, $cookie ) = $self->GetPreviousChild( $item, $cookie );
+        }
+    }
+
+    return \@data;
+}
+
+# Fetch a list of the Perl data elements for expanded nodes
+# in depth-first top to bottom order.
+sub GetExpandedPlData {
+    my $self  = shift;
+    my @queue = $self->GetRootItem;
+    my @data  = ();
+    while ( @queue ) {
+        my $item = shift @queue;
+        push @data, $self->GetPlData($item)->GetData;
+
+        # Processing children last to first and unshifting onto the
+        # queue, lets us achieve depth-first top-down within the need
+        # for intermediate storage or grepping.
+        my ( $child, $cookie ) = $self->GetLastChild($item);
+        while ( $cookie ) {
+            if ( $self->IsExpanded ) {
+                unshift @queue, $child;
+            }
+            ( $child, $cookie ) = $self->GetPreviousChild( $item, $cookie );
+        }
+    }
+
+    return \@data;
+}
+
 1;