Win32::GUI::GridLayout - Grid layout support for Win32::GUI

    use Win32::GUI::
    use Win32::GUI::GridLayout;

    # 1. make a "static" grid
    $grid = new Win32::GUI::GridLayout(400, 300, 3, 3, 0, 0);

    $win = new Win32::GUI::Window(

    $win->AddLabel(
        -name => "label1",
        -text => "Label 1",
        -width  => $grid->width(35),
        -height => $grid->height(11),
        -left   => $grid->col(1, "left"),
        -top    => $grid->row(1, "top"),
    );

    # 2. make a "dynamic" grid
    $grid = apply Win32::GUI::GridLayout($win, 3, 3, 0, 0);
        or
    $grid = apply Win32::GUI::GridLayout($win,
        [qw(10 * * 10)],
        [qw(10 * 40)],
        0, 0);

    $win->AddLabel(
        -name => "label1",
        -text => "Label 1",
    );
    $grid->add($win->label1, 1, 1, "left top");
       or
    $grid->add($win->label1, [2..3], 1, "justify justify");

    $grid->recalc();

package Win32::GUI::GridLayout;

$Win32::GUI::GridLayout::VERSION = "0.06";
$Win32::GUI::GridLayout::VERSION = eval $Win32::GUI::GridLayout::VERSION;

sub new {
    my($class, $c, $r, $w, $h, $xpad, $ypad) = @_;
    my $r_grid = {
        "cols"   => $c,
        "rows"   => $r,
        "width"  => $w,
        "height" => $h,
        "xPad"   => $xpad,
        "yPad"   => $ypad,
    };
    bless $r_grid, $class;
    return $r_grid;
}

sub apply {
    my($class, $to, $c, $r, $xpad, $ypad) = @_;
    my $w = $to->ScaleWidth();
    my $h = $to->ScaleHeight();
    my $r_grid = {
        "cols"   => $c,
        "rows"   => $r,
        "width"  => $w,
        "height" => $h,
        "xPad"   => $xpad,
        "yPad"   => $ypad,
        "source" => $to,
        "content" => [],
    };
    bless $r_grid, $class;
    return $r_grid;
}

sub add {
    my($grid, $o, $c, $r, $align) = @_;    
    my @content = @{$grid->{'content'}};
    my($halign, $valign) = split(/\s*,\s*|\s+/, $align);
    push(@content, [$o, $c, $r, $halign, $valign] );
    $grid->{'content'} = [@content];
}

sub recalc {
    my($grid) = @_;    
    $grid->{'width'}  = $grid->{'source'}->ScaleWidth();
    $grid->{'height'} = $grid->{'source'}->ScaleHeight();

    if(ref $grid->{'cols'} eq 'ARRAY') {
        my @colw = @{$grid->{'cols'}};
        my @absw = grep(/^\d+$/, @colw);
        my $absw = 0;
        map($absw+=$_, @absw);
        my $relw = int(($grid->{'width'}-$absw)/($#colw-$#absw));
        for my $i (0..$#colw) {
            $grid->{'_cols_w'}[$i] = ($colw[$i] eq '*') ? $relw : $colw[$i];
        }
    }
    else {
        my $relw = int($grid->{'width'}/$grid->{'cols'});
        for my $i (0..($grid->{'cols'}-1)) {
            $grid->{'_cols_w'}[$i] = $relw;
        }
    }

    if(ref $grid->{'rows'} eq 'ARRAY') {
        my @rowh = @{$grid->{'rows'}};
        my @absh = grep(/^\d+$/, @rowh);
        my $absh = 0;
        map($absh+=$_, @absh);
        my $relh = int(($grid->{'height'}-$absh)/($#rowh-$#absh));
        for my $i (0..$#rowh) {
            $grid->{'_rows_h'}[$i] = ($rowh[$i] eq '*') ? $relh : $rowh[$i];
        }
    }
    else {
        my $relh = int($grid->{'height'}/$grid->{'rows'});
        for my $i (0..($grid->{'rows'}-1)) {
            $grid->{'_rows_h'}[$i] = $relh;
        }
    }

    foreach my $inside (@{$grid->{'content'}}) {       
        $grid->{'widgetWidth'} = $inside->[0]->Width();
        $grid->{'widgetHeight'} = $inside->[0]->Height();
        if($inside->[3] =~ /^j/i) {
            $inside->[0]->Resize(
                $grid->col_w($inside->[1]),
                $inside->[0]->Height,
            );
        }
        
        if($inside->[4] =~ /^j/i) {
            $inside->[0]->Resize(
                $inside->[0]->Width,
                $grid->row_h($inside->[2]),
            );
        }
        
        $inside->[0]->Move(
            $grid->col($inside->[1], $inside->[3]),
            $grid->row($inside->[2], $inside->[4]),
        );
    }
}

sub draw {
    my($grid) = @_;
    return undef unless $grid->{'source'};
    my $DC = $grid->{'source'}->GetDC();
    my $colWidth = int($grid->{'width'} / $grid->{'cols'});
    my $rowHeight = int($grid->{'height'} / $grid->{'rows'});
    my($i, $s);
    $s = 0;
    for my $i (@{$grid->{'_cols_w'}}) {
        $s += $i;
        $DC->MoveTo($s, 0);
        $DC->LineTo($s, $grid->{'height'});
    }
    $s = 0;
    for my $i (@{$grid->{'_rows_h'}}) {
        $s += $i;
        $DC->MoveTo(0, $s);
        $DC->LineTo($grid->{'width'}, $s);
    }
}

sub column {
    my($grid_param, $col, $align) = @_;
    $col = [$col] unless(ref $col);
    $col = [map($_-1, @$col)];
    my $x = 0;
    my $colWidth = 0;
    if($grid_param->{'_cols_w'}) {
        my @colw = @{$grid_param->{'_cols_w'}};
        for(@$col) {
            $colWidth += $colw[$_];
        }
        for(my $i=0; $i<=$col->[0]-1; $i++) {
            $x += $colw[$i];
        }
        $x += $grid_param->{'xPad'};
    }
    else {
        $colWidth = int($grid_param->{'width'} / $grid_param->{'cols'}
            *($#$col+1));
        $x = ($col->[0] * $colWidth) + ($grid_param->{'xPad'});
    }
    $x += int(($colWidth - $grid_param->{'widgetWidth'}) / 2)
        if $align =~ /^c/i;
    $x += ($colWidth - $grid_param->{'widgetWidth'}) - 2*$grid_param->{'xPad'}
        if $align =~ /^r/i;
    $grid_param->{'widgetWidth'} = 0; # in case a width declaration is missed or not used
    return $x;
}
sub col { column @_; }

sub row {
    my($grid_param, $row, $align) = @_;
    $row = [$row] unless(ref $row);
    $row = [map($_-1, @$row)];
    my $y = 0;
    my $rowHeight = 0;
    if($grid_param->{'_rows_h'}) {
        my @rowh = @{$grid_param->{'_rows_h'}};
        for(@$row) {
            $rowHeight = $rowh[$_];
        }
        for(my $i=0; $i<=$row->[0]-1; $i++) {
            $y += $rowh[$i];
        }
        $y += $grid_param->{'yPad'};
    }
    else {
        $rowHeight = int($grid_param->{'height'} / $grid_param->{'rows'})
            *($#$row+1);
        $y = ($row->[0] * $rowHeight) + ($grid_param->{'yPad'});
    }

    $y += int(($rowHeight - $grid_param->{'widgetHeight'}) / 2)
        if $align =~ /^c/i;
    $y += ($rowHeight - $grid_param->{'widgetHeight'}) - 2*$grid_param->{'yPad'}
        if $align =~ /^b/i;
    $grid_param->{'widgetHeight'} = 0; # same reason as coment in &column
    return $y;
}

sub width {
    my ($grid_param,$w) = @_;
    $grid_param->{'widgetWidth'} = $w;
    return $grid_param->{'widgetWidth'};
}

sub height {
    my ($grid_param,$h) = @_;
    $grid_param->{'widgetHeight'} = $h;
    return $grid_param->{'widgetHeight'};
}

sub col_w {
    my($grid_param, $col) = @_;
    $col = [$col] unless(ref $col);
    my $w = 0;
    for my $col (@$col) {
        $w += $grid_param->{'_cols_w'}[$col-1];
    }
    
    $w -= 2*$grid_param->{'xPad'};
    return $w;
}

sub row_h {
    my($grid_param, $row) = @_;
    $row = [$row] unless(ref $row);
    my $h = 0;
    for my $row (@$row) {
        $h += $grid_param->{'_rows_h'}[$row-1];
    }
    
    $h -= 2*$grid_param->{'yPad'};
    return $h;
}

1;

__END__