Getopt::GUI::Long - Getopt::GUI::Long documentation

  use Getopt::GUI::Long;

  # pass useful config options to Configure
  Getopt::GUI::Long::Configure(qw(display_help no_ignore_case capture_output));
  GetOptions(\%opts,
             ["GUI:separator",   "Important Flags:"],
	     ["f|some-flag=s",   "A flag based on a string"],
	     ["o|other-flag",    "A boloean"],
            );

  # or use references instead of a hash (less tested, however):

  GetOptions(["some-flag=s",  "perform some flag based on a value"] => \$flag,
             ["other-flag=s", "perform some flag based on a value"] => \$other);

  # displays auto-help given the input above:

  % opttest -h
  Usage: opttest [OPTIONS] Other Arguments

  OPTIONS:

  Important Flags:
     -f STRING             A flag based on a string
     -o                    A boloean

  Help Options:
     -h                    Display help options -- short flags preferred
    --help                 Display help options -- long flags preferred
    --help-full            Display all help options -- short and long







  # or long help:

  % opttest --help
  Usage: opttest [OPTIONS] Other Arguments

  OPTIONS:

  Important Flags:
    --some-flag=STRING     A flag based on a string
    --other-flag           A boloean

  Help Options:
     -h                    Display help options -- short flags preferred
    --help                 Display help options -- long flags preferred
    --help-full            Display all help options -- short and long

  # or a GUI screen:

  (see http://www.dnssec-tools.org/images/getopt_example.png )

  This module is a wrapper around Getopt::Long that extends the value of
  the original Getopt::Long module to:

  1) add a simple graphical user interface option screen if no
     arguments are passed to the program.  Thus, the arguments to
     actually use are built based on the results of the user
     interface. If arguments were passed to the program, the user
     interface is not shown and the program executes as it normally
     would and acts just as if Getopt::Long::GetOptions had been
     called instead.

  2) provide an auto-help mechanism such that -h and --help are
     handled automatically.  In fact, calling your program with -h
     will default to showing the user a list of short-style arguments
     when one exists for the option.  Similarly --help will show the
     user a list of long-style when possible.  --help-full will list
     all potential arguments for an option (short and long both).

  It's designed to make the creation of graphical shells trivial
  without the programmer having to think about it much as well as
  providing automatic good-looking usage output without the
  programmer needing to write usage() functions.

  This also can turn normal command line programs into web CGI scripts
  as well (automatically).  If the Getopt::GUI::Long program is
  installed as a CGI script then it will automatically prompt the user
  for the same variables.

  $Getopt::GUI::Long::GUI_qw->set_progress(3/5)
    if ($Getopt::GUI::Long::GUI_qw);

  LocalGetOptions(\%opts,
	          ["h|help", "Show help for command line options"],
	          ["some-flag=s", "perform some flag based on a value"]);

  sub LocalGetOptions {
      if (eval {require Getopt::GUI::Long;}) {
  	import Getopt::GUI::Long;
        # optional configure call
	Getopt::GUI::Long::Configure(qw(display_help no_ignore_case capture_output));
  	return GetOptions(@_);
      }
      require Getopt::Long;
      import Getopt::Long;
      # optional configure call
      Getopt::Long::Configure(qw(auto_help no_ignore_case));
      GetOptions(LocalOptionsMap(@_));
  }

  sub LocalOptionsMap {
      my ($st, $cb, @opts) = ((ref($_[0]) eq 'HASH') 
  			    ? (1, 1, $_[0]) : (0, 2));
      for (my $i = $st; $i <= $#_; $i += $cb) {
  	if ($_[$i]) {
	    next if (ref($_[$i]) eq 'ARRAY' && $_[$i][0] =~ /^GUI:/);
  	    push @opts, ((ref($_[$i]) eq 'ARRAY') ? $_[$i][0] : $_[$i]);
  	    push @opts, $_[$i+1] if ($cb == 2);
  	}
      }
      return @opts;
  }

  ['GUI:allowcgiargs',1]

  ["c|config-file","Load a specific configuration file", nocgi => 1]

package Getopt::GUI::Long;

# Copyright 2005-2006, Sparta, Inc.
# All rights reserved.

use strict;
use Text::Wrap;
use Getopt::Long qw();
use File::Temp qw(tempfile);

our $VERSION="0.92";

require Exporter;

our @ISA = qw(Exporter Getopt::Long);
our @EXPORT = qw(GetOptions);
our $GUI_qw;
our $verbose;
our @ARGVsaved;

#
# Configuration variables
#
my %config = (
	      capture_output => 0,
	      display_help => 0,
	      no_gui => 0,
	      allow_zero => 0,
	     );

my @pass_to_qwizard_qs = qw(helpdesc helptext values labels default
			    check_value doif submit refresh_on_change
			    handle_results text name type indent);

# Primary storage for QWizard
my %primaries = 
  (
   display_results =>
   {
    title => (defined($ARGV) ? $ARGV : "") . " Output",
    questions =>
    [
     { type => 'paragraph',
       values => sub {
	   my $data;
	   # XXX: arg.  optimize with read() and then a file display widget
	   open(I,$config{'output_file'});
	   while (<I>) {
	       $data .= $_;
	   }
	   close(I);
	   return $data;
       }
     },
     { type => 'hidden',
       name => 'QWizard_finish',
       values => '_Exit' }
    ]
   }
  );


#
# changes the default for a given question to a memorized value
#
sub set_default_opt {
    my ($cache, @qs) = @_;
    if ($cache) {
	foreach my $q (@qs) {
	    if (!$q->{'default'}) {
		$q->{'default'} = $cache->get($q->{'name'});
	    }
	}
    }
    return @qs;
}

sub GetOptions(@) {
    my ($st, $cb, @opts) = ((ref($_[0]) eq 'HASH') ?
			    (1, 1, @_) : (0, 2, @_));
    my @savedopts = @_;

    my %GUI_info;
    my $dohelp;

    my $firstarg = "";

    if ($#main::ARGV > -1 &&
	($main::ARGV[0] =~ /--*gui/ || $main::ARGV[0] =~ /--*no-gui/ ||
	 $main::ARGV[0] =~ /--*nogui/)) {
	$firstarg = shift @main::ARGV;
	$firstarg = '-' . $firstarg if ($firstarg =~ /^-[^-]/);
    }

    # If the user didn't specify any arguments, we display a GUI for them.
    if ($firstarg ne '--nogui' &&
	$firstarg ne '--no-gui' &&
	(($#main::ARGV == -1 && !$config{'no_gui'} && !$config{'allow_zero'}) ||
	 $firstarg eq '--gui') &&
	eval "require QWizard") {

	require QWizard;
	import QWizard;
	require QWizard::Storage::File;
	import QWizard::Storage::File;
	require QWizard::Plugins::Bookmarks;
	import QWizard::Plugins::Bookmarks qw(init_bookmarks);

	# load the cache of saved default values
	my $progname = $main::0;
	my $cache;
	my %addpris;

	$progname =~ s/([^a-zA-Z0-9])/'_' . ord($1)/eg;
	my $cachefile = "$ENV{HOME}/.GetoptLongGUI/$progname";
	my $marksfile = "$ENV{HOME}/.GetoptLongGUI/$progname-bookmarks";
	if (-f $cachefile) {
	    $cache = new QWizard::Storage::File (file => $cachefile);
	    $cache->load_data();
	}

	$config{'GUI_on'} = 1;
	
	# create the qwizard instance
	my $qw = new QWizard(no_confirm => 1,
			     title => $main::0);

	# they called us with no options, offer them a GUI screen full
	my @names;
	my %names;
	my @qs;
	my $screencount = 0;
	my @saveqs;
	my $pris;
	
	# Define the first screen
	$pris->{'screen' . $screencount} =
	  { title => "Options for $main::0", };

	for (my $i = $st; $i <= $#opts; $i += $cb) {
	    my ($spec, $desc, %rest);
	    if (ref($opts[$i]) eq 'ARRAY') {
		$spec = $opts[$i][0];
		$desc = $opts[$i][1];
		%rest = @{$opts[$i]}[2..$#{$opts[$i]}];
	    } elsif ($opts[$i] eq '') {
		push @qs,"";
		next;
	    } else {
		$spec = $opts[$i];
	    }

	    next if ($rest{'nocgi'} && ref($qw->{'generator'}) =~ /HTML/);

	    if ($spec =~ /^GUI:(.*)/) {
		my $guiname = $1;
		
		if ($guiname eq "guionly") {
		    #
		    # a specific QWizard question to be added
		    #
		    push @qs,
		      set_default_opt($cache,@{$opts[$i]}[1..$#{$opts[$i]}]);

		} elsif ($guiname eq "separator") {
		    #
		    # add a separator label.
		    #
		    push @qs, "", { type => 'label', text => $opts[$i][1]};

		} elsif ($guiname eq "screen") {
		    #
		    # Start a brand new screen
		    #

		    # If the screen is optional via a previous flag
		    if (exists($rest{'doif'}) &&
			ref($rest{'doif'}) ne 'CODE') {
			$rest{'doifstr'} = $rest{'doif'};
			$rest{'doif'} = 
			  sub { return qwparam($_[2]{'doifstr'})};
		    }

		    # Define the new screen
		    if ($#qs == -1) {
			# screen definition occured before the first
			# question, have this only affect the current
			# screen.
			foreach my $tok (keys(%rest)) {
			    $pris->{'screen' . $screencount}{$tok} = 
			      $rest{$tok};
			}
			# maybe set the title
			$pris->{'screen' . $screencount}{'title'} = $desc
			  if ($desc);
		    } else {
			$pris->{'screen' . $screencount}{'questions'} = [@qs];
			$screencount++;
			$pris->{'screen' . $screencount} =
			  { title => $desc || "Options for $main::0",
			    # allow user to override
			    %rest };
			@qs = ();
		    }
		} else {
		    # generic GUI config token; store the name
		    @{$GUI_info{$guiname}} = @{$opts[$i]}[1..$#{$opts[$i]}];
		}
		next;
	    }

	    # regexp stolen (and modified) from Getopt::Long
	    # XXX: copy copyright
	    $spec =~ m;^
		   		   # $1 = whole name pattern
                                      (
                                          # $2 = Option name
                                          (\w+[-\w]* )
                                          # $3 = first name, or "?"
                                          (?: \| (\? | \w[-\w]* )? )?
                                          # Alias names, or "?"
                                          (?: \| (?: \? | \w[-\w]* )? )*
                                      )?
                                      # $4 = arguments
                                      (
                                          # Either modifiers ...
                                          [!+]
                                          |
                                          # ... or a value/dest specification
                                          [=:] [ionfs] [@%]?
                                          |
                                          # ... or an optional-with-default spec
                                          : (?: -?\d+ | \+ ) [@%]?
                                      )?
		       		       $;x;

	    # map option pieces into variables
	    my ($pat, $optname, $firstname, $args) = ($1, $2, $3, $4);


	    # calculate the option name to use from the list of names.
	    my $name = (length($optname) == 1 ? 
			((length($firstname) > 1) ? $firstname : $optname) :
			$optname);

	    # if no description, we copy the name and use that.
	    $desc = $name if (!$desc);

	    # remember the name of the option we're working on
	    push @names,$name;
	    $names{$name} = $args;

	    # get default value from the user preference if they had
	    # one already.
	    my $defval;
	    $defval = $cache->get($name) if ($cache);

	    # calculate a default value based on the passed in hash
	    # ref or variable reference.
	    if (!$defval) {
		$defval = (($cb == 1) ? 
			   (exists($_[0]{$optname}) ? $_[0]{$optname} : undef) :
			   $opts[$i+1]);
	    }

	    #
	    # Now constructure the needed GUI question
	    #
	    if ($rest{'question'}) {
		# if a QWizard question definition was passed to us, use that.
		if (ref($rest{'question'}) ne 'ARRAY') {
		    $rest{'question'} = [$rest{'question'}];
		}
		map {
		    $_->{'name'} = $name if ($_->{'name'} eq '');
		    $_->{'text'} = $desc if ($_->{'text'} eq '');
		    $_->{'default'} = $defval if (!exists($_->{'default'}));
		} @{$rest{'question'}};
		push @qs, set_default_opt($cache, @{$rest{'question'}});

	    } elsif ($desc =~ /^!GUI/) {
		# if the description was marked as not-for-the-GUI, don't
		# dispaly aynthing and skip it but remember the parameter name.
		push @qs, {type => 'hidden', name => $name, default => $defval};

	    } elsif (!$args || $args =~ /[!+]/) {
		#
		# Boolean => Checkbox
		#
		push @qs,
		  {
		   'text' => $desc,
		   'type' => 'checkbox',
		   values => [1, undef],
		   default => (($defval)?1:undef),
		   'name' => $name,
		  };

	    } elsif ($args =~ /i/) {
		#
		# Integer => textbox with int check
		#
		push @qs,
		  {
		   'text' => $desc,
		   'type' => 'text',
		   default => $defval,
		   'name' => $name,
		   check_value => (($rest{'required'}) ?
				   \&qw_integer : \&qw_optional_integer),
		  };
	    } elsif ($args =~ /[sf]/) {
		#
		# Float/string => textbox
		#
		# XXX: deal with floats seperately
		push @qs,
		  {
		   'text' => $desc,
		   'type' => 'text',
		   default => $defval,
		   'name' => $name,
		  };
	    } else {
		#
		# Unknown => textbox
		#
		push @qs,
		  {
		   'text' => $desc,
		   'type' => 'text',
		   default => $defval,
		   'name' => $name,
		  };
	    }

	    # if the required flag was set, force a requirement check.
	    if ($rest{'required'} && !exists($qs[$#qs]{'check_answer'})) {
		$qs[$#qs]{'check_value'} = \&qw_required_field;
	    }

	    # check the other auto-passing arguments
	    foreach my $k (@pass_to_qwizard_qs) {
		$qs[$#qs]{$k} = $rest{$k} if (exists($rest{$k}));
	    }
	}

	# include other primary information passed to us
	if (exists($GUI_info{'otherprimaries'})) {
	    %addpris = @{$GUI_info{'otherprimaries'}};
	}

	# Prompt for remaining arguments (or don't if requested to
	# skip it or don't for CGIs by default).  Normally this would
	# be stuff handled beyond the realm of the Getopt processing
	# like file-names, etc.
	if ($GUI_info{'nootherargs'}) {
	    push @{$pris->{'screen0'}{'questions'}},
	      { type => 'hidden', name => '__otherargs' };
	} elsif (ref($qw->{'generator'}) !~ /HTML/ ||
		 $GUI_info{'allowcgiargs'}) {
	    my $q = { type => 'text',
		      width => 80,
		      name => '__otherargs',
		      default => 
		      ($cache) ? $cache->get('__otherargs') : '',
		      text =>
		      $GUI_info{'otherargs_text'} || "Other Arguments",
		    };
	    if ($GUI_info{'otherargs_required'}) {
		$q->{'check_value'} = \&qw_required_field;
	    }
	    push @{$pris->{'screen0'}{'questions'}}, "", $q;
	}

	# our last primary setup
	$pris->{'screen' . $screencount}{'questions'} = [@qs];
	push @{$pris->{'screen' . $screencount}{'actions'}},
	  [sub {
	       #
	       # map all the defined option names from
	       # qwparam values pulled from the GUI back
	       # into ARGV options to be passed to
	       # Getopt::Long for processing
	       #
	       my ($qw, $name_array, $name_hash) = @_;
	       for (my $i = 0; $i <= $#{$name_array}; $i++) {
		   if (qwparam($name_array->[$i])) {
		       if (!$name_hash->{$name_array->[$i]} ||
			   $name_hash->{$name_array->[$i]} =~ /[+!]/) {
			   push @main::ARGV,
			     "--" . $name_array->[$i];
		       } else {
			   push @main::ARGV,
			     "--" . $name_array->[$i],
			       qwparam($name_array->[$i]);
		       }
		   }
	       }
	       if (ref($qw->{'generator'}) !~ /HTML/ ||
		   $GUI_info{'allowcgiargs'}) {
		   push @main::ARGV,
		     split(/\s+/,qwparam('__otherargs'));
	       }

	       return 'OK';
	   }, \@names, \%names];

	# add in later screens if needed
	if ($screencount > 0) {
	    push @{$pris->{'screen0'}{'post_answers'}},
	      [sub {
		   my ($wiz, $screencount) = @_;
		   for (my $i = $screencount; $i >= 1; $i--) {
		       $wiz->add_todos('screen' .$i);
		   }
	       }, $screencount];
	}
	
	# add in an post_answers clauses to the master primary
	# XXX: move to each screen def
	if ($GUI_info{'post_answers'}) {
	    push @{$pris->{'screen0'}{'post_answers'}},
	      @{$GUI_info{'post_answers'}};
	}

	push @{$pris->{'screen' . $screencount}{'questions'}},
	  { type => 'hidden', name => 'QWizard_finish', values => '' };
	push @{$pris->{'screen' . $screencount}{'post_answers'}},
	  [sub {
	       my ($wiz, $screencount) = @_;
	       qwparam('QWizard_finish', $GUI_info{'run_button'} || '_Run');
	   }];

	# add in an actions clauses to the master primary
	if ($GUI_info{'actions'}) {
	    unshift @{$pris->{'screen0'}{'actions'}}, @{$GUI_info{'actions'}};
	}

	# Finally, construct the QWizard GUI class...
	$qw->merge_primaries($pris);

	# add the bookmarks menu
	if (ref($qw->{'generator'}) !~ /HTML/ && !$GUI_info{'nosavebutton'}) {
	    my $marks = new QWizard::Storage::File (file => $marksfile);
	    $marks->load_data();
	    init_bookmarks($qw, $marks, title => 'Save Settings');
	}

	# ... remember it ...
	$GUI_qw = $qw;

	# ... load in our other primaries ...
	$qw->merge_primaries(\%primaries);
	$qw->merge_primaries(\%addpris);

	# ... and tell it to go
	$qw->magic('screen0', @{$GUI_info{'submodules'}});
	$qw->finished(); # drop the window for long running apps

	# ... if we aren't finished processing then exit.  This should
	# only happen if we're in a CGI script where we're not done yet.
	exit if (!$qw->is_done());
	
	# if there are any final hook routines to call, do so.
	if ($GUI_info{'hook_finished'}) {
	    foreach my $h (@{$GUI_info{'hook_finished'}}) {
		$h->();
	    }
	}
    } elsif ($#main::ARGV == -1 && !$config{'allow_zero'}) {
	# no qwizard, but no args so force usage
	$dohelp = 1;
	$opts[0]{'h'} = 1;
    }

    # map the options passed to us to ones that are compliant with
    # Getopt::Long
    @opts = MapToGetoptLong(\%GUI_info, @_);

    # save the arguments we contstructed for future use.
    @ARGVsaved = @main::ARGV;

    # display the results to the user if verbose was requested.
    if ($verbose) {
	print STDERR "passing $#main::ARGV args to Getopt::Long: ",
	  join(",",@main::ARGV),"\n";
    }

    # finally, pass on to the original Getopt::Long routine.
    my $ret = 1;
    $ret = Getopt::Long::GetOptions(@opts) if (!$dohelp);

    if ($verbose) {
	print STDERR "ret from long: $ret\n";
    }

    # capture stderr/out if required to display later.
    if ($config{'capture_output'} && $config{'GUI_on'}) {
	($config{'fh'}, $config{'output_file'}) =
	  tempfile("guilongXXXXXX", SUFFIX => 'txt');
	close(STDOUT);
	close(STDERR);
	*STDOUT = $config{'fh'};
	*STDERR = $config{'fh'};
    }

    if (defined($config{'display_help'}) && $config{'display_help'} &&
	(ref($_[0]) eq 'HASH' &&
	 ($_[0]{'help'} || $_[0]{'help-full'} || $_[0]{'h'})) ||
	$dohelp) {
	display_help($st, $cb, \%GUI_info, \@savedopts, @_);
    }

    if (ref($_[0]) eq 'HASH' && exists($_[0]{'getopt-to-pod'})) {
	_getopt_to_pod($st, $cb, \%GUI_info, \@savedopts, @_);
    }

    if (defined($config{'display_help'}) && $config{'display_help'} &&
	defined($GUI_info{'VERSION'}) &&
	ref($_[0]) eq 'HASH' && ($_[0]{'version'})) {
	print STDERR "Version: ",$GUI_info{'VERSION'},"\n";
	exit(0);
    }
    return $ret;
}

#
# prints help information
#
sub display_help {
    my $st = shift;
    my $cb = shift;
    my $GUI_info = shift;
    my $savedopts = shift;
    # Print help message if auto_help is on (XXX)

    my $topod = $GUI_info->{'__pod_to_text'};

    print STDERR "Usage: $0 [OPTIONS] ",
      ($GUI_info->{'otherargs_text'} ||
       ($GUI_info->{'nootherargs'} ? "" : "Other Arguments")),
	 "\n\nOPTIONS:\n"
	   if (!$topod);

    for (my $i = $st; $i <= $#{$savedopts}; $i += $cb) {
	my ($spec, $desc, %rest);
	if (ref($savedopts->[$i]) eq 'ARRAY') {
	    $spec = $savedopts->[$i][0];
	    $desc = $savedopts->[$i][1];
	    %rest = @{$savedopts->[$i]}[2..$#{$savedopts->[$i]}];
	} elsif ($savedopts->[$i] eq '') {
	    print STDERR "\n";
	    next;
	} else {
	    $spec = $savedopts->[$i];
	}

	# print separators
	if ($spec =~ /^GUI:(separator|screen)/) {
	    if ($topod) {
		print STDERR "=head2 $desc\n\n";
	    } else {
		print STDERR "\n$desc\n";
	    }
	    next;
	}

	next if ($spec =~ /^GUI:(.*)/);

	# regexp stolen (and modified) from Getopt::Long
	# XXX: copy copyright
	$spec =~ m;^
		   		   # $1 = whole name pattern
		   		   (
		   		   # $2 = Option name
		   		   (\w+[-\w]* )
		   		   # $3 = first name, or "?"
		   		   (?: \| (\? | \w[-\w]* )? )?
		   		   # Alias names, or "?"
		   		   (?: \| (?: \? | \w[-\w]* )? )*
		  		  )?
		   		   # $4 = arguments
		   		   (
		   		   # Either modifiers ...
		   		   [!+]
		   		   |
		   		   # ... or a value/dest specification
		   		   [=:] [ionfs] [@%]?
		   		   |
		   		   # ... or an optional-with-default spec
		   		   : (?: -?\d+ | \+ ) [@%]?
		  		  )?
		   		   $;x;

	# map option pieces into variables
	my ($pat, $optname, $firstname, $argspec) = ($1, $2, $3, $4);

	# turn argspecs into human consumable versions.
	if ($argspec =~ /i/) {
	    $argspec = "INTEGER";
	} elsif ($argspec =~ /f/) {
	    $argspec = "FLOAT";
	} elsif ($argspec =~ /s/) {
	    $argspec = "STRING";
	} else {
	    $argspec = "";
	}

	my @args=split(/\|/,$pat);
	if ($_[0]{'help-full'} || $topod) {
	    # they want *everything*
	    for (my $argc=0;  $argc <= $#args; $argc++) {
		_display_help_option($args[$argc], $argspec,
				     ($argc == $#args)?$desc:"", $topod);
	    }

	} elsif ($_[0]{'h'}) {
	    # assume short names perferred and always show the shortest
	    _display_help_option($args[0], $argspec, $desc);

	} elsif ($_[0]{'help'}) {
	    # assume long names perferred and use those if possible
	    if ($#args == 0) {
		# only one is avialable
		_display_help_option($args[0], $argspec, $desc);
	    } elsif (length($args[0]) == 1) {
		# first one is short, display the second...
		_display_help_option_long($args[1], $argspec, $desc);
	    } else {
		# first one itself is long, display it.
		_display_help_option_long($args[0], $argspec, $desc);
	    }
	}
    }

    # display the display_help options
    print STDERR "\nHelp Options:\n";
    _display_help_option_short('h','',
			       'Display help options -- short flags preferred');
    _display_help_option_long('help','',
			       'Display help options -- long flags preferred');
    _display_help_option_long('help-full','',
			       'Display all help options -- short and long');
    _display_help_option_long('gui','',
			       'Display a help GUI');
    _display_help_option_long('no-gui','',
			       'Do not display the default help GUI');
    _display_help_option_long('version','',
			      'Display the version number')
      if ($GUI_info->{'VERSION'});

    exit(1);
}

sub _getopt_to_pod {
    my $st = shift;
    my $cb = shift;
    my $GUI_info = shift;
    my $savedopts = shift;
    $GUI_info->{'__pod_to_text'} = 1;
    display_help($st, $cb, $GUI_info, $savedopts, @_);
}

sub _display_help_option {
    my ($arg,$spec,$desc,$topod) = @_;
    if ($topod) {
	_display_help_option_pod(@_);
    } elsif (length($arg) == 1) {
	_display_help_option_short(@_);
    } else {
	_display_help_option_long(@_);
    }
}

sub _display_help_option_short {
    my ($arg,$spec,$desc) = @_;
    printf STDERR ("   -%-20s %-55s\n", $arg . " " . $spec, $desc);
}

sub _display_help_option_long {
    my ($arg,$spec,$desc) = @_;
    printf STDERR ("  --%-20s %-55s\n",
		   $arg . ($spec ? "=" : "") . $spec, $desc);
}

sub _display_help_option_pod {
    my ($arg,$spec,$desc) = @_;
    printf STDERR ("=item  -%s%s\n\n%s\n\n",
		   ((length($arg) == 1) ? $arg : "-" . $arg),
		   ($spec ? ((length($arg) == 1) ? " " : "=") : "") . $spec,
		   $desc);
}


sub MapToGetoptLong {
    my $guiinfo = shift;
    my ($st, $cb, @opts) = ((ref($_[0]) eq 'HASH') 
			    ? (1, 1, $_[0]) : (0, 2));
    for (my $i = $st; $i <= $#_; $i += $cb) {
	if ($_[$i]) {
	    if (ref($_[$i]) eq 'ARRAY' && $_[$i][0] =~ /^GUI:(.*)/) {
		$guiinfo->{$1} = $_[$i][1];
		next;
	    }
	    push @opts, ((ref($_[$i]) eq 'ARRAY') ? $_[$i][0] : $_[$i]);
	    push @opts, $_[$i+1] if ($cb == 2);
	}
    }
    push @opts,GetHelpOptions() if ($config{'display_help'});
    push @opts,GetInternalOptions() unless ($config{'no_internal_options'});
    return @opts;
}

sub GetHelpOptions {
    return ('help','h','help-full','version');
}

sub GetInternalOptions {
    return ('getopt-to-pod', 'gui', 'no-gui|nogui');
}

#
# Configure's the running operation of the module.  Any unknown
# arguments are passed to the parent Configure script.
#
sub Configure (@) {
    my @options = @_;
    my @passopts;
    foreach my $opt (@options) {
	if (exists($config{$opt})) {
	    $config{$opt} = 1;
	} else {
	    push @passopts, $opt;
	}
    }
    Getopt::Long::Configure(@passopts);
}

#
# Calls qwizard at the end if output capture was turned on.
#
sub END {
    if ($config{'capture_output'} && $config{'GUI_on'} && $config{'fh'}) {
	$config{'fh'}->close();
	$GUI_qw->magic('display_results');
	unlink($config{'output_file'});
	$GUI_qw->finished();
    }
}

1;

1;