No you're right to break things into different modules. As for whether or not to use OO I would suggest using whatever is comfortable.

And use whatever namespace you want. If you app is called foo.pl I'd create Foo::Widgets or something.

I agree Tk and most GUI widget sets are unwieldy to code with. One think you might think about is using Glade and Gtk2::GladeXML. This lets you "draw" your GUI, which is defined in an XML file, that that CPAN module reads and does all of the "building" for you. You then just write the callbacks and the portion you need to modify.

Hope this helps.

In addition to being easier to read, the good thing about this is that in my app you can add and remove rows dynamically. So when you click a button it just calls "add_row()"; click another and it calls "remove_row()". The "grid" object would handle that, and it can make sure you don't have less than $MIN_ROWS rows or more than $MAX_ROWS rows, and keep track of the current number of rows, etc. etc.

Depends what your requirements are though. Only use OO if it makes sense to use it.

What I have is is a complex app that talks to up to 200+ sensors and displays the data, logs it. It also provides a simple serial terminal and an on-line help system. I am adding the ability to trigger notifications based on filtering the sensor readings. I wrote it like all the examples I saw, and despite my best efforts, it's big, ugly, and unweildy.

For the filter creation I'm going to have to build a rule editor that allows you to specify N clauses ( <FEILD> < IS / IS LESS THAN / IS GREATER THAN > <VALUE> ) and specify whether they are combined as a conjuction (ALL) or disjunction (ANY). I think I will be making a Clause mega-widget. I think I'll use an HList to manage my clause widgets, as it provides the add_row() functionality you describe. HList is pretty cool, if you haven't used it, check it out.


TGI says moo

### A Different file

package PhoneList;

use Tk;

sub placement($$) {
    my ($w, $placement) = @_;
    if ($placement =~ s/^p,(\w+),(\w+),(\w+)//) {
        $w->pack(-side => $1, -fill => $2, -expand => $3);
    } elsif ($placement =~ s/^g,(\d+),(\d+)//) {
        $w->grid(-column => $1, -row => $2);
    } else {
        die "Illegal placement format '$placement'\n";
    }
    return $w;
}

sub myFrame($$$$) {
    my ($w, $ix, $iy, $placement) = @_;
    my $fr = $w->Frame();
    return &placement($fr, $placement);
}

sub myLabel($$$) {
    my ($w, $text, $placement) = @_;
    my $lbl = $w->Label(-text => $text);
    return &placement($lbl, $placement);
}

sub myEntry($$$) {
    my ($w, $tvar, $placement) = @_;
    my $e = $w->Entry(-textvariable => $tvar);
    return &placement($e, $placement);
}

sub myCheckbutton($$$$$) {
    my ($w, $v, $b0, $b1, $placement) = @_;
    my $c = $w->Checkbutton(-textvar => $v, -offvalue => $b0, -onvalue
+ => $b1);
    return &placement($c, $placement);
}

sub setup {
    my $parent = shift;
    my %args = @_;

    my $top  = myFrame $parent, 5, 5, 'p,top,x,1';
    my $list = myFrame $parent, 5, 5, 'p,top,x,1';

    myLabel $top,  'Enter some phone numbers.',       'p,top,none,0';
    myLabel $top,  'Check numbers to activate them.', 'p,top,none,0';
    myLabel $list, 'Enabled',                         'g,0,0';
    myLabel $list, 'Phone number',                    'g,1,0';
    myLabel $list, 'Description',                     'g,2,0';

    for ( 1..5 ) {
        my $textvar = \$args{-numbers}->[$_]{enable};
        myCheckbutton $list, $textvar, '', 'ACTIVE', "g,0,$_";
        myEntry $list, \$args{-numbers}->[$_]{number},      "g,1,$_";
        myEntry $list, \$args{-numbers}->[$_]{description}, "g,2,$_";
    }

    MainLoop
}

1;
[download]

#!/usr/bin/perl -w

use strict;
use warnings;

use lib ".";
use PhoneList;

my $mw = MainWindow->new;
$mw->configure(-title => "A phone List");

my $phoneNumbers = [
    {   number      => '123-4321',
        enable      => 'ACTIvE',
        description => 'Bob',
    },
    {   number      => '321-1234',
        enable      => '',
        description => 'Not Bob',
    },
];

PhoneList::setup($mw, -numbers => $phoneNumbers);
[download]

For my Tk-Apps, I often use package/module names like (if my App is called MyApp):

• MyApp::Widgets: little wrapper around widgets with some defaults (e.g. background, font, ...) to be able to get a flexible layout and shorter widget calls. Some enhanced widgets (e.g. with Tk::Derived) may be specified here as well if the code is short, although then there is more than one package in a module...
• MyApp::Forms: most of the GUI functionality is coded here to separate layout and code as far as possible
• MyApp::Callbacks: callbacks are specified here; if necessary, there even may be more modules grouped by topic)
• MyApp::DB: the interface to Databases, or MyApp::LDAP as interface to Directory Services, ... so I don't need to search through the whole program if the interface changes
• maybe MyApp::Config: this sometimes contains the configuration in global package variables which I treat as readonly, sometimes as configuration objects or an interface to an external configuration
• sometimes MyApp::Global for saving global variables like $Mw, $ToplevelEdit, ...

A while back, I thought everything in Perl should be OO. But I have changed my mind in a way, and my thought now is to go with non-OO if Perl OO seems laborious to you. After all, you want to develop your Perl applications quick, which is one of the key point of using Perl.

I've been bitten by the excessive generality bug a few times as well. It's the easiest way to never finish a project. I've done in a few projects this way myself--on the good side, I learned a lot while doing it.

My app is currently weighing in at around 3000 lines of code (including whitespace and comments, but not counting the libraries I wrote for backend stuff). It's just too damn big to navigate around easily. Amazingly, it is maintainable, I was able to get in and make some changes after 8 months away from working on it without too much pain. Let's hear it for good documentation practices.

Any thoughts on the namespace issue? I'm planning on keeping the libraries in the same directory with the script, so top level names are OK. I'm leaning towards MyApp::PhoneList and MyApp::DisplayData and so forth.


TGI says moo

One can also (is supposed to (?)) create a Tk::composite object.

package myApp::MyWidget;
use strict;
use warnings;
use base qw/Tk::Frame/;
our $VERSION = 0.1;

Construct Tk::Widget 'MyWidget';

=pod

=head1 NAME

myApp::MyWidget - Widget for use in myApp

=head1 SYNOPSIS

 use strict;
 use Tk;
 use myApp::MyWidgeet;

 my $mw = new MainWindow;
 my $widget = $mw->MyWidget( %options );
 $widget->pack;

=cut

sub Populate {
  my($self, $args) = @_;
  $self->SUPER::Populate($args);

  my $top = $self->Frame()->pack(
        -fill   => 'both',
        -expand => 'x',
        -ipadx  => 5,
        -ipady  => 5,
    );

  # ... Other stuff ...

#   $self->ConfigSpecs(
#       ...
#     );
#   $self->Delegates('DEFAULT' => $scale);
}

1;
[download]

The ConfigSpecs and Delegates control which options/methods go to which subwidgets. There is also a Component method that can be called that can give you access to the subcomponents (such as your checkboxes), or you can create custom methods that process the information from the form before returning it (which is probably the better route anyway).