SL/Template/Plugin/L.pm

   1 package SL::Template::Plugin::L;
   2
   3 use base qw( Template::Plugin );
   4 use Template::Plugin;
   5 use Data::Dumper;
   6 use List::MoreUtils qw(apply);
   7 use List::Util qw(max);
   8 use Scalar::Util qw(blessed);
   9
  10 use SL::Presenter;
  11 use SL::Util qw(_hashify);
  12
  13 use strict;
  14
  15 { # This will give you an id for identifying html tags and such.
  16   # It's guaranteed to be unique unless you exceed 10 mio calls per request.
  17   # Do not use these id's to store information across requests.
  18 my $_id_sequence = int rand 1e7;
  19 sub _tag_id {
  20   return "id_" . ( $_id_sequence = ($_id_sequence + 1) % 1e7 );
  21 }
  22 }
  23
  24 sub _H {
  25   my $string = shift;
  26   return $::locale->quote_special_chars('HTML', $string);
  27 }
  28
  29 sub _J {
  30   my $string = shift;
  31   $string    =~ s/(\"|\'|\\)/\\$1/g;
  32   return $string;
  33 }
  34
  35 sub new {
  36   my ($class, $context, @args) = @_;
  37
  38   return bless {
  39     CONTEXT => $context,
  40   }, $class;
  41 }
  42
  43 sub _context {
  44   die 'not an accessor' if @_ > 1;
  45   return $_[0]->{CONTEXT};
  46 }
  47
  48 sub _call_presenter {
  49   my ($method, $self, @args) = @_;
  50
  51   my $presenter              = $::request->presenter;
  52
  53   if (!$presenter->can($method)) {
  54     $::lxdebug->message(LXDebug::WARN(), "SL::Presenter has no method named '$method'!");
  55     return '';
  56   }
  57
  58   splice @args, -1, 1, %{ $args[-1] } if @args && (ref($args[-1]) eq 'HASH');
  59
  60   $presenter->$method(@args);
  61 }
  62
  63 sub name_to_id    { return _call_presenter('name_to_id',    @_); }
  64 sub html_tag      { return _call_presenter('html_tag',      @_); }
  65 sub hidden_tag    { return _call_presenter('hidden_tag',    @_); }
  66 sub select_tag    { return _call_presenter('select_tag',    @_); }
  67 sub checkbox_tag  { return _call_presenter('checkbox_tag',  @_); }
  68 sub input_tag     { return _call_presenter('input_tag',     @_); }
  69 sub javascript    { return _call_presenter('javascript',    @_); }
  70 sub truncate      { return _call_presenter('truncate',      @_); }
  71 sub simple_format { return _call_presenter('simple_format', @_); }
  72 sub part_picker   { return _call_presenter('part_picker',   @_); }
  73 sub chart_picker  { return _call_presenter('chart_picker',  @_); }
  74 sub customer_vendor_picker   { return _call_presenter('customer_vendor_picker',   @_); }
  75 sub project_picker           { return _call_presenter('project_picker',           @_); }
  76 sub button_tag               { return _call_presenter('button_tag',               @_); }
  77 sub submit_tag               { return _call_presenter('submit_tag',               @_); }
  78 sub ajax_submit_tag          { return _call_presenter('ajax_submit_tag',          @_); }
  79 sub link                     { return _call_presenter('link',                     @_); }
  80
  81 sub _set_id_attribute {
  82   my ($attributes, $name, $unique) = @_;
  83   SL::Presenter::Tag::_set_id_attribute($attributes, $name, $unique);
  84 }
  85
  86 sub img_tag {
  87   my ($self, %options) = _hashify(1, @_);
  88
  89   $options{alt} ||= '';
  90
  91   return $self->html_tag('img', undef, %options);
  92 }
  93
  94 sub textarea_tag {
  95   my ($self, $name, $content, %attributes) = _hashify(3, @_);
  96
  97   _set_id_attribute(\%attributes, $name);
  98   $attributes{rows}  *= 1; # required by standard
  99   $attributes{cols}  *= 1; # required by standard
 100   $content            = $content ? _H($content) : '';
 101
 102   return $self->html_tag('textarea', $content, %attributes, name => $name);
 103 }
 104
 105 sub radio_button_tag {
 106   my ($self, $name, %attributes) = _hashify(2, @_);
 107
 108   $attributes{value}   = 1 unless exists $attributes{value};
 109
 110   _set_id_attribute(\%attributes, $name, 1);
 111   my $label            = delete $attributes{label};
 112
 113   _set_id_attribute(\%attributes, $name . '_' . $attributes{value});
 114
 115   if ($attributes{checked}) {
 116     $attributes{checked} = 'checked';
 117   } else {
 118     delete $attributes{checked};
 119   }
 120
 121   my $code  = $self->html_tag('input', undef,  %attributes, name => $name, type => 'radio');
 122   $code    .= $self->html_tag('label', $label, for => $attributes{id}) if $label;
 123
 124   return $code;
 125 }
 126
 127 sub div_tag {
 128   my ($self, $content, @slurp) = @_;
 129   return $self->html_tag('div', $content, @slurp);
 130 }
 131
 132 sub ul_tag {
 133   my ($self, $content, @slurp) = @_;
 134   return $self->html_tag('ul', $content, @slurp);
 135 }
 136
 137 sub li_tag {
 138   my ($self, $content, @slurp) = @_;
 139   return $self->html_tag('li', $content, @slurp);
 140 }
 141
 142 sub yes_no_tag {
 143   my ($self, $name, $value, %attributes) = _hashify(3, @_);
 144
 145   return $self->select_tag($name, [ [ 1 => $::locale->text('Yes') ], [ 0 => $::locale->text('No') ] ], default => $value ? 1 : 0, %attributes);
 146 }
 147
 148 sub stylesheet_tag {
 149   my $self = shift;
 150   my $code = '';
 151
 152   foreach my $file (@_) {
 153     $file .= '.css'        unless $file =~ m/\.css$/;
 154     $file  = "css/${file}" unless $file =~ m|/|;
 155
 156     $code .= qq|<link rel="stylesheet" href="${file}" type="text/css" media="screen" />|;
 157   }
 158
 159   return $code;
 160 }
 161
 162 my $date_tag_id_idx = 0;
 163 sub date_tag {
 164   my ($self, $name, $value, %params) = _hashify(3, @_);
 165
 166   _set_id_attribute(\%params, $name);
 167   my @onchange = $params{onchange} ? (onChange => delete $params{onchange}) : ();
 168   my @classes  = $params{no_cal} || $params{readonly} ? () : ('datepicker');
 169   push @classes, delete($params{class}) if $params{class};
 170   my %class    = @classes ? (class => join(' ', @classes)) : ();
 171
 172   $::request->presenter->need_reinit_widgets($params{id});
 173
 174   return $self->input_tag(
 175     $name, blessed($value) ? $value->to_lxoffice : $value,
 176     size   => 11,
 177     onchange => "check_right_date_format(this);",
 178     %params,
 179     %class, @onchange,
 180   );
 181 }
 182
 183 # simple version with select_tag
 184 sub vendor_selector {
 185   my ($self, $name, $value, %params) = _hashify(3, @_);
 186
 187   my $actual_vendor_id = (defined $::form->{"$name"})? ((ref $::form->{"$name"}) ? $::form->{"$name"}->id : $::form->{"$name"}) :
 188                          (ref $value && $value->can('id')) ? $value->id : '';
 189
 190   return $self->select_tag($name, SL::DB::Manager::Vendor->get_all(),
 191                                   default      => $actual_vendor_id,
 192                                   title_sub    => sub { $_[0]->vendornumber . " : " . $_[0]->name },
 193                                   'with_empty' => 1,
 194                                   %params);
 195 }
 196
 197
 198 # simple version with select_tag
 199 sub part_selector {
 200   my ($self, $name, $value, %params) = _hashify(3, @_);
 201
 202   my $actual_part_id = (defined $::form->{"$name"})? ((ref $::form->{"$name"})? $::form->{"$name"}->id : $::form->{"$name"}) :
 203                        (ref $value && $value->can('id')) ? $value->id : '';
 204
 205   return $self->select_tag($name, SL::DB::Manager::Part->get_all(),
 206                            default      => $actual_part_id,
 207                            title_sub    => sub { $_[0]->partnumber . " : " . $_[0]->description },
 208                            with_empty   => 1,
 209                            %params);
 210 }
 211
 212
 213 sub javascript_tag {
 214   my $self = shift;
 215   my $code = '';
 216
 217   foreach my $file (@_) {
 218     $file .= '.js'        unless $file =~ m/\.js$/;
 219     $file  = "js/${file}" unless $file =~ m|/|;
 220
 221     $code .= qq|<script type="text/javascript" src="${file}"></script>|;
 222   }
 223
 224   return $code;
 225 }
 226
 227 sub tabbed {
 228   my ($self, $tabs, %params) = _hashify(2, @_);
 229   my $id       = $params{id} || 'tab_' . _tag_id();
 230
 231   $params{selected} *= 1;
 232
 233   die 'L.tabbed needs an arrayred of tabs for first argument'
 234     unless ref $tabs eq 'ARRAY';
 235
 236   my (@header, @blocks);
 237   for my $i (0..$#$tabs) {
 238     my $tab = $tabs->[$i];
 239
 240     next if $tab eq '';
 241
 242     my $tab_id = "__tab_id_$i";
 243     push @header, $self->li_tag($self->link('#' . $tab_id, $tab->{name}));
 244     push @blocks, $self->div_tag($tab->{data}, id => $tab_id);
 245   }
 246
 247   return '' unless @header;
 248
 249   my $ul = $self->ul_tag(join('', @header), id => $id);
 250   return $self->div_tag(join('', $ul, @blocks), class => 'tabwidget');
 251 }
 252
 253 sub tab {
 254   my ($self, $name, $src, %params) = _hashify(3, @_);
 255
 256   $params{method} ||= 'process';
 257
 258   return () if defined $params{if} && !$params{if};
 259
 260   my $data;
 261   if ($params{method} eq 'raw') {
 262     $data = $src;
 263   } elsif ($params{method} eq 'process') {
 264     $data = $self->_context->process($src, %{ $params{args} || {} });
 265   } else {
 266     die "unknown tag method '$params{method}'";
 267   }
 268
 269   return () unless $data;
 270
 271   return +{ name => $name, data => $data };
 272 }
 273
 274 sub areainput_tag {
 275   my ($self, $name, $value, %attributes) = _hashify(3, @_);
 276
 277   my $cols    = delete $attributes{cols} || delete $attributes{size};
 278   my $minrows = delete $attributes{min_rows} || 1;
 279   my $maxrows = delete $attributes{max_rows};
 280   my $rows    = $::form->numtextrows($value, $cols, $maxrows, $minrows);
 281
 282   return $rows > 1
 283     ? $self->textarea_tag($name, $value, %attributes, rows => $rows, cols => $cols)
 284     : $self->input_tag($name, $value, %attributes, size => $cols);
 285 }
 286
 287 sub multiselect2side {
 288   my ($self, $id, %params) = _hashify(2, @_);
 289
 290   $params{labelsx}        = "\"" . _J($params{labelsx} || $::locale->text('Available')) . "\"";
 291   $params{labeldx}        = "\"" . _J($params{labeldx} || $::locale->text('Selected'))  . "\"";
 292   $params{moveOptions}    = 'false';
 293
 294   my $vars                = join(', ', map { "${_}: " . $params{$_} } keys %params);
 295   my $code                = <<EOCODE;
 296 <script type="text/javascript">
 297   \$().ready(function() {
 298     \$('#${id}').multiselect2side({ ${vars} });
 299   });
 300 </script>
 301 EOCODE
 302
 303   return $code;
 304 }
 305
 306 sub sortable_element {
 307   my ($self, $selector, %params) = _hashify(2, @_);
 308
 309   my %attributes = ( distance => 5,
 310                      helper   => <<'JAVASCRIPT' );
 311     function(event, ui) {
 312       ui.children().each(function() {
 313         $(this).width($(this).width());
 314       });
 315       return ui;
 316     }
 317 JAVASCRIPT
 318
 319   my $stop_event = '';
 320
 321   if ($params{url} && $params{with}) {
 322     my $as      = $params{as} || $params{with};
 323     my $filter  = ".filter(function(idx) { return this.substr(0, " . length($params{with}) . ") == '$params{with}'; })";
 324     $filter    .= ".map(function(idx, str) { return str.replace('$params{with}_', ''); })";
 325
 326     my $params_js = $params{params} ? qq| + ($params{params})| : '';
 327
 328     $stop_event = <<JAVASCRIPT;
 329         \$.post('$params{url}'${params_js}, { '${as}[]': \$(\$('${selector}').sortable('toArray'))${filter}.toArray() });
 330 JAVASCRIPT
 331   }
 332
 333   if (!$params{dont_recolor}) {
 334     $stop_event .= <<JAVASCRIPT;
 335         \$('${selector}>*:odd').removeClass('listrow1').removeClass('listrow0').addClass('listrow0');
 336         \$('${selector}>*:even').removeClass('listrow1').removeClass('listrow0').addClass('listrow1');
 337 JAVASCRIPT
 338   }
 339
 340   if ($stop_event) {
 341     $attributes{stop} = <<JAVASCRIPT;
 342       function(event, ui) {
 343         ${stop_event}
 344         return ui;
 345       }
 346 JAVASCRIPT
 347   }
 348
 349   $params{handle}     = '.dragdrop' unless exists $params{handle};
 350   $attributes{handle} = "'$params{handle}'" if $params{handle};
 351
 352   my $attr_str = join(', ', map { "${_}: $attributes{$_}" } keys %attributes);
 353
 354   my $code = <<JAVASCRIPT;
 355 <script type="text/javascript">
 356   \$(function() {
 357     \$( "${selector}" ).sortable({ ${attr_str} })
 358   });
 359 </script>
 360 JAVASCRIPT
 361
 362   return $code;
 363 }
 364
 365 sub dump {
 366   my $self = shift;
 367   return '<pre>' . Data::Dumper::Dumper(@_) . '</pre>';
 368 }
 369
 370 sub sortable_table_header {
 371   my ($self, $by, %params) = _hashify(2, @_);
 372
 373   my $controller          = $self->{CONTEXT}->stash->get('SELF');
 374   my $models              = $params{models} || $self->{CONTEXT}->stash->get('MODELS');
 375   my $sort_spec           = $models->get_sort_spec;
 376   my $by_spec             = $sort_spec->{$by};
 377   my %current_sort_params = $models->get_current_sort_params;
 378   my ($image, $new_dir)   = ('', $current_sort_params{dir});
 379   my $title               = delete($params{title}) || $::locale->text($by_spec->{title});
 380
 381   if ($current_sort_params{sort_by} eq $by) {
 382     my $current_dir = $current_sort_params{sort_dir} ? 'up' : 'down';
 383     $image          = '<img border="0" src="image/' . $current_dir . '.png">';
 384     $new_dir        = 1 - ($current_sort_params{sort_dir} || 0);
 385   }
 386
 387   $params{ $models->sorted->form_params->[0] } = $by;
 388   $params{ $models->sorted->form_params->[1] } = ($new_dir ? '1' : '0');
 389
 390   return '<a href="' . $models->get_callback(%params) . '">' . _H($title) . $image . '</a>';
 391 }
 392
 393 sub paginate_controls {
 394   my ($self, %params) = _hashify(1, @_);
 395
 396   my $controller      = $self->{CONTEXT}->stash->get('SELF');
 397   my $models          = $params{models} || $self->{CONTEXT}->stash->get('MODELS');
 398   my $pager           = $models->paginated;
 399 #  my $paginate_spec   = $controller->get_paginate_spec;
 400
 401   my %paginate_params = $models->get_paginate_args;
 402
 403   my %template_params = (
 404     pages             => \%paginate_params,
 405     url_maker         => sub {
 406       my %url_params                                    = _hashify(0, @_);
 407       $url_params{ $pager->form_params->[0] } = delete $url_params{page};
 408       $url_params{ $pager->form_params->[1] } = delete $url_params{per_page} if exists $url_params{per_page};
 409
 410       return $models->get_callback(%url_params);
 411     },
 412     %params,
 413   );
 414
 415   return SL::Presenter->get->render('common/paginate', %template_params);
 416 }
 417
 418 1;
 419
 420 __END__
 421
 422 =head1 NAME
 423
 424 SL::Templates::Plugin::L -- Layouting / tag generation
 425
 426 =head1 SYNOPSIS
 427
 428 Usage from a template:
 429
 430   [% USE L %]
 431
 432   [% L.select_tag('direction', [ [ 'left', 'To the left' ], [ 'right', 'To the right', 1 ] ]) %]
 433
 434   [% L.select_tag('direction', [ { direction => 'left',  display => 'To the left'  },
 435                                  { direction => 'right', display => 'To the right' } ],
 436                                value_key => 'direction', title_key => 'display', default => 'right')) %]
 437
 438   [% L.select_tag('direction', [ { direction => 'left',  display => 'To the left'  },
 439                                  { direction => 'right', display => 'To the right', selected => 1 } ],
 440                                value_key => 'direction', title_key => 'display')) %]
 441
 442 =head1 DESCRIPTION
 443
 444 A module modeled a bit after Rails' ActionView helpers. Several small
 445 functions that create HTML tags from various kinds of data sources.
 446
 447 The C<id> attribute is usually calculated automatically. This can be
 448 overridden by either specifying an C<id> attribute or by setting
 449 C<no_id> to trueish.
 450
 451 =head1 FUNCTIONS
 452
 453 =head2 LOW-LEVEL FUNCTIONS
 454
 455 The following items are just forwarded to L<SL::Presenter::Tag>:
 456
 457 =over 2
 458
 459 =item * C<name_to_id $name>
 460
 461 =item * C<stringify_attributes %items>
 462
 463 =item * C<html_tag $tag_name, $content_string, %attributes>
 464
 465 =back
 466
 467 =head2 HIGH-LEVEL FUNCTIONS
 468
 469 The following functions are just forwarded to L<SL::Presenter::Tag>:
 470
 471 =over 2
 472
 473 =item * C<input_tag $name, $value, %attributes>
 474
 475 =item * C<hidden_tag $name, $value, %attributes>
 476
 477 =item * C<checkbox_tag $name, %attributes>
 478
 479 =item * C<select_tag $name, \@collection, %attributes>
 480
 481 =item * C<link $href, $content, %attributes>
 482
 483 =back
 484
 485 Available high-level functions implemented in this module:
 486
 487 =over 4
 488
 489 =item C<yes_no_tag $name, $value, %attributes>
 490
 491 Creates a HTML 'select' tag with the two entries C<yes> and C<no> by
 492 calling L<select_tag>. C<$value> determines
 493 which entry is selected. The C<%attributes> are passed through to
 494 L<select_tag>.
 495
 496 =item C<textarea_tag $name, $value, %attributes>
 497
 498 Creates a HTML 'textarea' tag named C<$name> with the content
 499 C<$value> and with arbitrary HTML attributes from C<%attributes>. The
 500 tag's C<id> defaults to C<name_to_id($name)>.
 501
 502 =item C<date_tag $name, $value, %attributes>
 503
 504 Creates a date input field, with an attached javascript that will open a
 505 calendar on click.
 506
 507 =item C<radio_button_tag $name, %attributes>
 508
 509 Creates a HTML 'input type=radio' tag named C<$name> with arbitrary
 510 HTML attributes from C<%attributes>. The tag's C<value> defaults to
 511 C<1>. The tag's C<id> defaults to C<name_to_id($name . "_" . $value)>.
 512
 513 If C<%attributes> contains a key C<label> then a HTML 'label' tag is
 514 created with said C<label>. No attribute named C<label> is created in
 515 that case.
 516
 517 =item C<javascript_tag $file1, $file2, $file3...>
 518
 519 Creates a HTML 'E<lt>script type="text/javascript" src="..."E<gt>'
 520 tag for each file name parameter passed. Each file name will be
 521 postfixed with '.js' if it isn't already and prefixed with 'js/' if it
 522 doesn't contain a slash.
 523
 524 =item C<stylesheet_tag $file1, $file2, $file3...>
 525
 526 Creates a HTML 'E<lt>link rel="text/stylesheet" href="..."E<gt>' tag
 527 for each file name parameter passed. Each file name will be postfixed
 528 with '.css' if it isn't already and prefixed with 'css/' if it doesn't
 529 contain a slash.
 530
 531 =item C<tabbed \@tab, %attributes>
 532
 533 Will create a tabbed area. The tabs should be created with the helper function
 534 C<tab>. Example:
 535
 536   [% L.tabbed([
 537     L.tab(LxERP.t8('Basic Data'),       'part/_main_tab.html'),
 538     L.tab(LxERP.t8('Custom Variables'), 'part/_cvar_tab.html', if => SELF.display_cvar_tab),
 539   ]) %]
 540
 541 =item C<areainput_tag $name, $content, %PARAMS>
 542
 543 Creates a generic input tag or textarea tag, depending on content size. The
 544 amount of desired rows must be either given with the C<rows> parameter or can
 545 be computed from the value and the C<cols> paramter, Accepted parameters
 546 include C<min_rows> for rendering a minimum of rows if a textarea is displayed.
 547
 548 You can force input by setting rows to 1, and you can force textarea by setting
 549 rows to anything >1.
 550
 551 =item C<multiselect2side $id, %params>
 552
 553 Creates a JavaScript snippet calling the jQuery function
 554 C<multiselect2side> on the select control with the ID C<$id>. The
 555 select itself is not created. C<%params> can contain the following
 556 entries:
 557
 558 =over 2
 559
 560 =item C<labelsx>
 561
 562 The label of the list of available options. Defaults to the
 563 translation of 'Available'.
 564
 565 =item C<labeldx>
 566
 567 The label of the list of selected options. Defaults to the
 568 translation of 'Selected'.
 569
 570 =back
 571
 572 =item C<sortable_element $selector, %params>
 573
 574 Makes the children of the DOM element C<$selector> (a jQuery selector)
 575 sortable with the I<jQuery UI Selectable> library. The children can be
 576 dragged & dropped around. After dropping an element an URL can be
 577 postet to with the element IDs of the sorted children.
 578
 579 If this is used then the JavaScript file C<js/jquery-ui.js> must be
 580 included manually as well as it isn't loaded via C<$::form-gt;header>.
 581
 582 C<%params> can contain the following entries:
 583
 584 =over 2
 585
 586 =item C<url>
 587
 588 The URL to POST an AJAX request to after a dragged element has been
 589 dropped. The AJAX request's return value is ignored. If given then
 590 C<$params{with}> must be given as well.
 591
 592 =item C<with>
 593
 594 A string that is interpreted as the prefix of the children's ID. Upon
 595 POSTing the result each child whose ID starts with C<$params{with}> is
 596 considered. The prefix and the following "_" is removed from the
 597 ID. The remaining parts of the IDs of those children are posted as a
 598 single array parameter. The array parameter's name is either
 599 C<$params{as}> or, missing that, C<$params{with}>.
 600
 601 =item C<as>
 602
 603 Sets the POST parameter name for AJAX request after dropping an
 604 element (see C<$params{with}>).
 605
 606 =item C<handle>
 607
 608 An optional jQuery selector specifying which part of the child element
 609 is dragable. If the parameter is not given then it defaults to
 610 C<.dragdrop> matching DOM elements with the class C<dragdrop>.  If the
 611 parameter is set and empty then the whole child element is dragable,
 612 and clicks through to underlying elements like inputs or links might
 613 not work.
 614
 615 =item C<dont_recolor>
 616
 617 If trueish then the children will not be recolored. The default is to
 618 recolor the children by setting the class C<listrow0> on odd and
 619 C<listrow1> on even entries.
 620
 621 =item C<params>
 622
 623 An optional JavaScript string that is evaluated before sending the
 624 POST request. The result must be a string that is appended to the URL.
 625
 626 =back
 627
 628 Example:
 629
 630   <script type="text/javascript" src="js/jquery-ui.js"></script>
 631
 632   <table id="thing_list">
 633     <thead>
 634       <tr><td>This</td><td>That</td></tr>
 635     </thead>
 636     <tbody>
 637       <tr id="thingy_2"><td>stuff</td><td>more stuff</td></tr>
 638       <tr id="thingy_15"><td>stuff</td><td>more stuff</td></tr>
 639       <tr id="thingy_6"><td>stuff</td><td>more stuff</td></tr>
 640     </tbody>
 641   <table>
 642
 643   [% L.sortable_element('#thing_list tbody',
 644                         url          => 'controller.pl?action=SystemThings/reorder',
 645                         with         => 'thingy',
 646                         as           => 'thing_ids',
 647                         recolor_rows => 1) %]
 648
 649 After dropping e.g. the third element at the top of the list a POST
 650 request would be made to the C<reorder> action of the C<SystemThings>
 651 controller with a single parameter called C<thing_ids> -- an array
 652 containing the values C<[ 6, 2, 15 ]>.
 653
 654 =item C<dump REF>
 655
 656 Dumps the Argument using L<Data::Dumper> into a E<lt>preE<gt> block.
 657
 658 =item C<sortable_table_header $by, %params>
 659
 660 Create a link and image suitable for placement in a table
 661 header. C<$by> must be an index set up by the controller with
 662 L<SL::Controller::Helper::make_sorted>.
 663
 664 The optional parameter C<$params{title}> can override the column title
 665 displayed to the user. Otherwise the column title from the
 666 controller's sort spec is used.
 667
 668 The other parameters in C<%params> are passed unmodified to the
 669 underlying call to L<SL::Controller::Base::url_for>.
 670
 671 See the documentation of L<SL::Controller::Helper::Sorted> for an
 672 overview and further usage instructions.
 673
 674 =item C<paginate_controls>
 675
 676 Create a set of links used to paginate a list view.
 677
 678 See the documentation of L<SL::Controller::Helper::Paginated> for an
 679 overview and further usage instructions.
 680
 681 =back
 682
 683 =head2 CONVERSION FUNCTIONS
 684
 685 =over 4
 686
 687 =item C<tab, description, target, %PARAMS>
 688
 689 Creates a tab for C<tabbed>. The description will be used as displayed name.
 690 The target should be a block or template that can be processed. C<tab> supports
 691 a C<method> parameter, which can override the process method to apply target.
 692 C<method => 'raw'> will just include the given text as is. I was too lazy to
 693 implement C<include> properly.
 694
 695 Also an C<if> attribute is supported, so that tabs can be suppressed based on
 696 some occasion. In this case the supplied block won't even get processed, and
 697 the resulting tab will get ignored by C<tabbed>:
 698
 699   L.tab('Awesome tab wih much info', '_much_info.html', if => SELF.wants_all)
 700
 701 =item C<truncate $text, [%params]>
 702
 703 See L<SL::Presenter::Text/truncate>.
 704
 705 =item C<simple_format $text>
 706
 707 See L<SL::Presenter::Text/simple_format>.
 708
 709 =back
 710
 711 =head1 MODULE AUTHORS
 712
 713 Moritz Bunkus E<lt>m.bunkus@linet-services.deE<gt>
 714
 715 L<http://linet-services.de>