Padre::Current - A context object, for centralising the concept of what is "current"

    my $config = Padre::Current->config;

    my $document = Padre::Current->document;

    my $editor = Padre::Current->editor;

    my $filename = Padre::Current->filename;

    my $ide = Padre::Current->ide;

    my $main = Padre::Current->main;

    my $main = Padre::Current->notebook;

    my $main = Padre::Current->project;

    my $main = Padre::Current->text;

    my $main = Padre::Current->title;

    my $main = Padre::Current->main;
    # ...

    # Vanilla constructor
    Padre::Current->new;

    # Seed the object with some context
    Padre::Current->new( document => $document );

package Padre::Current;

use 5.008;
use strict;
use warnings;
use Carp         ();
use Exporter     ();
use Params::Util ();

our $VERSION   = '0.86';
our @ISA       = 'Exporter';
our @EXPORT_OK = '_CURRENT';

use Class::XSAccessor {
	constructor => 'new',
};





#####################################################################
# Exportable Functions

# This is an importable convenience function.
# It's current not as efficient as it should be, but once the majority
# of the context-sensitive code has been migrated over, we should be
# able to simplify it quite a bit.
sub _CURRENT {

	# Most likely options
	return Padre::Current->new unless defined $_[0];
	return shift if Params::Util::_INSTANCE( $_[0], 'Padre::Current' );

	# Fallback options
	if ( Params::Util::_INSTANCE( $_[0], 'Padre::Document' ) ) {
		return Padre::Current->new( document => shift );
	}

	return Padre::Current->new;
}





#####################################################################
# Context Methods

# Get the project from the document (and don't cache)
sub project {
	my $self = ref( $_[0] ) ? $_[0] : $_[0]->new;
	my $document = $self->document;
	if ( defined $document ) {
		return $document->project;
	} else {
		return;
	}
}

# Get the text from the editor (and don't cache)
sub text {
	my $self = ref( $_[0] ) ? $_[0] : $_[0]->new;
	my $editor = $self->editor;
	if ( defined $editor ) {
		return $editor->GetSelectedText;
	} else {
		return '';
	}
}

# Get the title of the current editor window (and don't cache)
sub title {
	my $self     = ref( $_[0] ) ? $_[0] : $_[0]->new;
	my $notebook = $self->notebook;
	my $selected = $notebook->GetSelection;
	if ( $selected >= 0 ) {
		return $notebook->GetPageText($selected);
	} else {
		return;
	}
}

# Get the filename from the document
sub filename {
	my $self = ref( $_[0] ) ? $_[0] : $_[0]->new;
	unless ( exists $self->{filename} ) {
		my $document = $self->document;
		if ( defined $document ) {
			$self->{filename} = $document->filename;
		} else {
			$self->{filename} = undef;
		}
	}
	return $self->{filename};
}

# Get the document from the editor
sub document {
	my $self = ref( $_[0] ) ? $_[0] : $_[0]->new;
	unless ( exists $self->{document} ) {
		my $editor = $self->editor;
		if ( defined $editor ) {
			$self->{document} = $editor->{Document};
		} else {
			$self->{document} = undef;
		}
	}
	return $self->{document};
}

# Derive the editor from the document
sub editor {
	my $self = ref( $_[0] ) ? $_[0] : $_[0]->new;
	unless ( exists $self->{editor} ) {
		my $notebook = $self->notebook;
		if ( defined($notebook) ) {
			my $selected = $notebook->GetSelection;
			if ( $selected == -1 ) {
				$self->{editor} = undef;
			} elsif ( $selected >= $notebook->GetPageCount ) {
				$self->{editor} = undef;
			} else {
				$self->{editor} = $notebook->GetPage($selected);
				unless ( $self->{editor} ) {
					Carp::croak("Failed to find page");
				}
			}
		}
	}
	return $self->{editor};
}

# Convenience method
sub notebook {
	my $self = ref( $_[0] ) ? $_[0] : $_[0]->new;
	unless ( defined $self->{notebook} ) {
		return unless defined $self->main;
		$self->{notebook} = $self->main->notebook;
	}
	return $self->{notebook};
}

# Get the current configuration from the main window (and don't cache).
sub config {
	my $self = ref( $_[0] ) ? $_[0] : $_[0]->new;
	if ( defined $self->main ) {
		return $self->main->config;
	} elsif ( $self->ide ) {
		return $self->ide->config;
	} else {
		return;
	}
}

# Convenience method
sub main {
	my $self = ref( $_[0] ) ? $_[0] : $_[0]->new;

	# floating windows (Wx::AuiFloatingFrame) may
	# call us passing $self as an argument, so
	# we short-circuit them if they're docked
	if ( $_[1] ) {
		my $parent = $_[1]->main;
		return $parent if ref $parent eq 'Padre::Wx::Main';
	}
	if ( defined $self->{main} ) {
		return $self->{main};
	}
	if ( defined $self->{ide} ) {
		return unless defined( $self->{ide}->wx );
		return $self->{main} = $self->{ide}->wx->main;
	}
	if ( defined $self->{editor} ) {
		return $self->{main} = $self->{editor}->main;
	}
	if ( defined $self->{document} ) {
		my $editor = $self->{document}->{editor};
		if ($editor) {
			my $main = $editor->main;
			return $self->{main} = $main if $main;
		}
	}

	# Last resort fallback
	require Padre;

	# Whe whole idea of loading Padre at this point does not look good.
	# It should have already be done in the padre script so loading here again seems incorrect
	# anyway. Does this only serve the testsing? ~ szabgab
	$self->{ide} = Padre->ide;
	return unless defined( $self->{ide}->wx );
	return $self->{main} = $self->{ide}->wx->main;
}

# Convenience method
sub ide {
	my $self = ref( $_[0] ) ? $_[0] : $_[0]->new;

	if ( defined $self->{ide} ) {
		return $self->{ide};
	}
	if ( defined $self->{main} ) {
		return $self->{ide} = $self->{main}->ide;
	}
	if (   defined $self->{document}
		or defined $self->{editor} )
	{
		return $self->{ide} = $self->main->ide;
	}

	# Last resort
	require Padre;
	return $self->{ide} = Padre->ide;
}

1;

__END__

# Copyright 2008-2011 The Padre development team as listed in Padre.pm.
# LICENSE
# This program is free software; you can redistribute it and/or
# modify it under the same terms as Perl 5 itself.