Changeset 9762

Timestamp:

12/17/09 20:11:36 (9 months ago)

Author:

adamk

Message:

Landing new lock subsystem

Location:

trunk/Padre

Files:

• Changes (modified) (1 diff)
• lib/Padre/Document/Perl.pm (modified) (1 diff)
• lib/Padre/Lock.pm (modified) (2 diffs)
• lib/Padre/Locker.pm (modified) (3 diffs)
• lib/Padre/Wx/Directory/SearchCtrl.pm (modified) (1 diff)
• lib/Padre/Wx/Directory/TreeCtrl.pm (modified) (1 diff)
• lib/Padre/Wx/Main.pm (modified) (10 diffs)

trunk/Padre/Changes

@@ -16 +16 @@
     - Fixed missing mime type guessing that caused new Padre documents to
       default always to Scintilla (AZAWAWI)
+    - Landed first phase of new multi-resource locking subsystem (ADAMK)
 
 0.52 2009.12.14

trunk/Padre/lib/Padre/Document/Perl.pm

@@ -1518 +1518 @@
                                 $dialog->Destroy;
                                 return unless defined $replacement;
+                                my $lock = $editor->main->lock('BUSY');
                                 $doc->lexical_variable_replacement($replacement);
                         },

trunk/Padre/lib/Padre/Lock.pm

@@ -9 +9 @@
 sub new {
         my $class = shift;
-        my $self = bless {@_}, $class;
+        my $self  = bless { @_ }, $class;
 
         # Enable the locks
-        if ( $self->{update} ) {
+        if ( $self->{UPDATE} ) {
                 $self->{locker}->update_enable;
         }
-        if ( $self->{busy} ) {
+        if ( $self->{BUSY} ) {
                 $self->{locker}->busy_enable;
         }
@@ -22 +22 @@
 }
 
+# Disable locking on destruction
 sub DESTROY {
-
-        # Disable the locks
-        if ( $_[0]->{update} ) {
+        if ( $_[0]->{UPDATE} ) {
                 $_[0]->{locker}->update_disable;
         }
-        if ( $_[0]->{busy} ) {
+        if ( $_[0]->{BUSY} ) {
                 $_[0]->{locker}->busy_disable;
         }

trunk/Padre/lib/Padre/Locker.pm

@@ -1 +1 @@
 package Padre::Locker;
+
+=pod
+
+=head1 NAME
+
+Padre::Locker - The Padre Multi-Resource Lock Manager
+
+=cut
 
 use 5.008;
@@ -32 +40 @@
 sub lock {
         my $self = shift;
-        return Padre::Lock->new( map { $_ => 1 } @_ );
+        return Padre::Lock->new(
+                locker => $self,
+                map { $_ => 1 } @_
+        );
 }
 
@@ -67 +78 @@
 
                 # Locking for the first time
-                $self->{busy_locker} = Wx::WindowDisabler->new;
+                $self->{busy_locker} = Wx::BusyCursor->new;
         }
         return;

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

@@ -518 +518 @@
         # Lock the gui here to make the updates look slicker
         # The locker holds the gui freeze until the update is done.
-        my $locker = $self->current->main->freezer;
+        my $lock = $self->current->main->lock('UPDATE');
 
         # Cleans the Directory Browser window to show the result

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

@@ -149 +149 @@
         # Lock the gui here to make the updates look slicker
         # The locker holds the gui freeze until the update is done.
-        my $locker = $self->main->freezer;
+        my $lock = $self->main->lock('UPDATE');
 
         # If the project have changed or the project root folder updates or

trunk/Padre/lib/Padre/Wx/Main.pm

@@ -128 +128 @@
         $self->{config} = $config;
 
+        # Create the lock manager before any gui operations,
+        # so that we can do locking operations during startup.
+        $self->{locker} = Padre::Locker->new($self);
+
         # Determine the window title (needs ide & config)
         $self->set_title;
 
+        # Remember where the editor started from,
+        # this could be handy later.
+        $self->{cwd} = Cwd::cwd();
+
+        # There is a directory locking problem on Win32.
+        # If we open Padre from a directory and leave the Cwd cursor
+        # in that directory, then it can NEVER be deleted.
         # Having recorded the "current working directory" move
-        # the OS directory cursor away from this directory, so
-        # that Padre won't hold a lock on the current directory.
-        # If changing the directory fails, ignore errors (for now)
-        $self->{cwd} = Cwd::cwd();
-        if (Padre::Constant::WIN32) {
-
-                # Directory locking problem only exists on Win
+        # the OS directory cursor away from this starting directory,
+        # so that Padre won't hold an implicit OS lock on it.
+        # NOTE: If changing the directory fails, ignore errors for now,
+        #       since that means we have WAY bigger problems.
+        if ( Padre::Constant::WIN32 ) {
                 chdir( File::HomeDir->my_home );
         }
+
+        # Bootstrap locale support before we start fiddling with the GUI.
+        $self->{locale} = Padre::Locale::object();
 
         # A large complex application looks, frankly, utterly stupid
         # if it gets very small, or even mildly small.
         $self->SetMinSize( Wx::Size->new( 500, 400 ) );
-
-        # Set the locale
-        $self->{locale} = Padre::Locale::object();
 
         # Drag and drop support
@@ -330 +339 @@
 
         # GUI Elements
+        ide                 => 'ide',
+        config              => 'config',
         title               => 'title',
-        config              => 'config',
-        ide                 => 'ide',
         aui                 => 'aui',
         menu                => 'menu',
@@ -347 +356 @@
 
         # Operating Data
+        locker     => 'locker',
         cwd        => 'cwd',
         search     => 'search',
@@ -619 +629 @@
 =pod
 
-=head2 C<freezer>
-
-   my $locker = $main->freezer;
-
-Create and return an automatic C<freeze> object that will C<thaw> on destruction.
-
-=cut
-
-sub freezer {
-        Wx::WindowUpdateLocker->new( $_[0] );
+=head2 C<lock>
+
+  my $lock = $main->lock('UPDATE', 'BUSY', 'refresh_menu');
+
+Create and return a guard object that holds resource locks of various types.
+
+The method takes a parameter list of the locks you wish to exist for the
+current scope. Special types of locks are provided in capitals,
+refresh/method locks are provided in lowercase.
+
+The C<UPDATE> lock creates a Wx repaint lock using the built in
+L<Wx::WindowUpdateLocker> class.
+
+You should use an update lock during GUI construction/modification to
+prevent screen flicker. As a side effect of not updating, the GUI changes
+happen B<significantly> faster as well. Update locks should only be held for
+short periods of time, as the operating system will begin to treat your\
+application as "hung" if an update lock persists for more than a few
+seconds. In this situation, you may begin to see GUI corruption.
+
+The C<BUSY> lock creates a Wx "busy" lock using the built in
+L<Wx::WindowDisabler> class.
+
+You should use a busy lock during times when Padre has to do a long and/or
+complex operation in the foreground, or when you wish to disable use of any
+user interface elements until a background thread is finished.
+
+Busy locks can be held for long periods of time, however your users may
+start to suspect trouble if you do not provide any periodic feedback to them.
+
+Lowercase lock names are used to delay the firing of methods that will
+themselves generate GUI events you may want to delay until you are sure
+you want to rebuild the GUI.
+
+For example, opening a file will require a Padre::Wx::Main refresh call,
+which will itself generate more refresh calls on the directory browser, the
+function list, output window, menus, and so on.
+
+But if you open more than one file at a time, you don't want to refresh the
+menu for the first file, only to do it again on the second, third and
+fourth files.
+
+By creating refresh locks in the top level operation, you allow the lower
+level operation to make requests for parts of the GUI to be refreshed, but
+have the actual refresh actions delayed until the lock expires.
+
+This should make operations with a high GUI intensity both simpler and
+faster.
+
+The name of the lowercase MUST be the name of a Padre::Wx::Main method,
+which will be fired (with no params) when the method lock expires.
+
+=cut
+
+sub lock {
+        shift->locker->lock( @_ );
 }
 
@@ -903 +959 @@
 
         # Freeze during the refresh
-        my $guard   = $self->freezer;
+        my $lock    = $self->lock('UPDATE');
         my $current = $self->current;
 
@@ -1208 +1264 @@
 
         # Do everything inside a freeze
-        my $guard = $self->freezer;
+        my $lock = $self->lock('UPDATE');
 
         # The biggest potential change is that the user may have a
@@ -2828 +2884 @@
                 # Lock both Perl and Wx-level updates
                 local $self->{_no_refresh} = 1;
-                my $guard = $self->freezer;
+                my $lock = $self->lock('UPDATE');
 
                 # If and only if there is only one current file,
@@ -3333 +3389 @@
 
 sub reload_all {
-        my $self  = shift;
-        my $skip  = shift;
-        my $guard = $self->freezer;
+        my $self = shift;
+        my $skip = shift;
+        my $lock = $self->lock('UPDATE');
 
         my @pages = $self->pageids;
@@ -3839 +3895 @@
 
 sub close_all {
-        my $self  = shift;
-        my $skip  = shift;
-        my $guard = $self->freezer;
+        my $self = shift;
+        my $skip = shift;
+        my $lock = $self->lock('UPDATE');
 
         my $manager = $self->{ide}->plugin_manager;
@@ -3899 +3955 @@
         my $where    = shift;
         my $notebook = $self->notebook;
-        my $guard    = $self->freezer;
+        my $lock     = $self->lock('UPDATE');
         foreach my $id ( reverse $self->pageids ) {
                 if ( $where->( $notebook->GetPage($id)->{Document} ) ) {