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::Presenter::ALL;
  12 use SL::Presenter::Simple;
  13 use SL::Util qw(_hashify);
  14
  15 use strict;
  16
  17 { # This will give you an id for identifying html tags and such.
  18   # It's guaranteed to be unique unless you exceed 10 mio calls per request.
  19   # Do not use these id's to store information across requests.
  20 my $_id_sequence = int rand 1e7;
  21 sub _tag_id {
  22   return "id_" . ( $_id_sequence = ($_id_sequence + 1) % 1e7 );
  23 }
  24 }
  25
  26 sub _H {
  27   my $string = shift;
  28   return $::locale->quote_special_chars('HTML', $string);
  29 }
  30
  31 sub _J {
  32   my $string = shift;
  33   $string    =~ s/(\"|\'|\\)/\\$1/g;
  34   return $string;
  35 }
  36
  37 sub new {
  38   my ($class, $context, @args) = @_;
  39
  40   return bless {
  41     CONTEXT => $context,
  42   }, $class;
  43 }
  44
  45 sub _context {
  46   die 'not an accessor' if @_ > 1;
  47   return $_[0]->{CONTEXT};
  48 }
  49
  50 sub _call_presenter {
  51   my ($method, $self, @args) = @_;
  52
  53   my $presenter              = $::request->presenter;
  54
  55   splice @args, -1, 1, %{ $args[-1] } if @args && (ref($args[-1]) eq 'HASH');
  56
  57   if (my $sub = SL::Presenter::Simple->can($method)) {
  58     return $sub->(@args);
  59   }
  60
  61   if ($presenter->can($method)) {
  62     return $presenter->$method(@args);
  63   }
  64
  65   $::lxdebug->message(LXDebug::WARN(), "SL::Presenter has no method named '$method'!");
  66   return;
  67 }
  68
  69 sub name_to_id    { return _call_presenter('name_to_id',    @_); }
  70 sub html_tag      { return _call_presenter('html_tag',      @_); }
  71 sub hidden_tag    { return _call_presenter('hidden_tag',    @_); }
  72 sub select_tag    { return _call_presenter('select_tag',    @_); }
  73 sub checkbox_tag  { return _call_presenter('checkbox_tag',  @_); }
  74 sub input_tag     { return _call_presenter('input_tag',     @_); }
  75 sub javascript    { return _call_presenter('javascript',    @_); }
  76 sub truncate      { return _call_presenter('truncate',      @_); }
  77 sub simple_format { return _call_presenter('simple_format', @_); }
  78 sub button_tag               { return _call_presenter('button_tag',               @_); }
  79 sub submit_tag               { return _call_presenter('submit_tag',               @_); }
  80 sub ajax_submit_tag          { return _call_presenter('ajax_submit_tag',          @_); }
  81 sub link                     { return _call_presenter('link',                     @_); }
  82 sub input_number_tag         { return _call_presenter('input_number_tag',         @_); }
  83 sub textarea_tag             { return _call_presenter('textarea_tag',             @_); }
  84
  85 sub _set_id_attribute {
  86   my ($attributes, $name, $unique) = @_;
  87   SL::Presenter::Tag::_set_id_attribute($attributes, $name, $unique);
  88 }
  89
  90 sub img_tag {
  91   my ($self, %options) = _hashify(1, @_);
  92
  93   $options{alt} ||= '';
  94
  95   return $self->html_tag('img', undef, %options);
  96 }
  97
  98 sub radio_button_tag {
  99   my ($self, $name, %attributes) = _hashify(2, @_);
 100
 101   $attributes{value}   = 1 unless exists $attributes{value};
 102
 103   _set_id_attribute(\%attributes, $name, 1);
 104   my $label            = delete $attributes{label};
 105
 106   _set_id_attribute(\%attributes, $name . '_' . $attributes{value});
 107
 108   if ($attributes{checked}) {
 109     $attributes{checked} = 'checked';
 110   } else {
 111     delete $attributes{checked};
 112   }
 113
 114   my $code  = $self->html_tag('input', undef,  %attributes, name => $name, type => 'radio');
 115   $code    .= $self->html_tag('label', $label, for => $attributes{id}) if $label;
 116
 117   return $code;
 118 }
 119
 120 sub div_tag {
 121   my ($self, $content, @slurp) = @_;
 122   return $self->html_tag('div', $content, @slurp);
 123 }
 124
 125 sub ul_tag {
 126   my ($self, $content, @slurp) = @_;
 127   return $self->html_tag('ul', $content, @slurp);
 128 }
 129
 130 sub li_tag {
 131   my ($self, $content, @slurp) = @_;
 132   return $self->html_tag('li', $content, @slurp);
 133 }
 134
 135 sub yes_no_tag {
 136   my ($self, $name, $value, %attributes) = _hashify(3, @_);
 137
 138   return $self->select_tag($name, [ [ 1 => $::locale->text('Yes') ], [ 0 => $::locale->text('No') ] ], default => $value ? 1 : 0, %attributes);
 139 }
 140
 141 sub stylesheet_tag {
 142   my $self = shift;
 143   my $code = '';
 144
 145   foreach my $file (@_) {
 146     $file .= '.css'        unless $file =~ m/\.css$/;
 147     $file  = "css/${file}" unless $file =~ m|/|;
 148
 149     $code .= qq|<link rel="stylesheet" href="${file}" type="text/css" media="screen" />|;
 150   }
 151
 152   return $code;
 153 }
 154
 155 my $date_tag_id_idx = 0;
 156 sub date_tag {
 157   my ($self, $name, $value, %params) = _hashify(3, @_);
 158
 159   _set_id_attribute(\%params, $name);
 160   my @onchange = $params{onchange} ? (onChange => delete $params{onchange}) : ();
 161   my @classes  = $params{no_cal} || $params{readonly} ? () : ('datepicker');
 162   push @classes, delete($params{class}) if $params{class};
 163   my %class    = @classes ? (class => join(' ', @classes)) : ();
 164
 165   $::request->layout->add_javascripts('kivi.Validator.js');
 166   $::request->presenter->need_reinit_widgets($params{id});
 167
 168   return $self->input_tag(
 169     $name, blessed($value) ? $value->to_lxoffice : $value,
 170     size   => 11,
 171     "data-validate" => "date",
 172     %params,
 173     %class, @onchange,
 174   );
 175 }
 176
 177 # simple version with select_tag
 178 sub vendor_selector {
 179   my ($self, $name, $value, %params) = _hashify(3, @_);
 180
 181   my $actual_vendor_id = (defined $::form->{"$name"})? ((ref $::form->{"$name"}) ? $::form->{"$name"}->id : $::form->{"$name"}) :
 182                          (ref $value && $value->can('id')) ? $value->id : '';
 183
 184   return $self->select_tag($name, SL::DB::Manager::Vendor->get_all(),
 185                                   default      => $actual_vendor_id,
 186                                   title_sub    => sub { $_[0]->vendornumber . " : " . $_[0]->name },
 187                                   'with_empty' => 1,
 188                                   %params);
 189 }
 190
 191
 192 # simple version with select_tag
 193 sub part_selector {
 194   my ($self, $name, $value, %params) = _hashify(3, @_);
 195
 196   my $actual_part_id = (defined $::form->{"$name"})? ((ref $::form->{"$name"})? $::form->{"$name"}->id : $::form->{"$name"}) :
 197                        (ref $value && $value->can('id')) ? $value->id : '';
 198
 199   return $self->select_tag($name, SL::DB::Manager::Part->get_all(),
 200                            default      => $actual_part_id,
 201                            title_sub    => sub { $_[0]->partnumber . " : " . $_[0]->description },
 202                            with_empty   => 1,
 203                            %params);
 204 }
 205
 206
 207 sub javascript_tag {
 208   my $self = shift;
 209   my $code = '';
 210
 211   foreach my $file (@_) {
 212     $file .= '.js'        unless $file =~ m/\.js$/;
 213     $file  = "js/${file}" unless $file =~ m|/|;
 214
 215     $code .= qq|<script type="text/javascript" src="${file}"></script>|;
 216   }
 217
 218   return $code;
 219 }
 220
 221 sub tabbed {
 222   my ($self, $tabs, %params) = _hashify(2, @_);
 223   my $id       = $params{id} || 'tab_' . _tag_id();
 224
 225   $params{selected} *= 1;
 226
 227   die 'L.tabbed needs an arrayred of tabs for first argument'
 228     unless ref $tabs eq 'ARRAY';
 229
 230   my (@header, @blocks);
 231   for my $i (0..$#$tabs) {
 232     my $tab = $tabs->[$i];
 233
 234     next if $tab eq '';
 235
 236     my $tab_id = "__tab_id_$i";
 237     push @header, $self->li_tag($self->link('#' . $tab_id, $tab->{name}));
 238     push @blocks, $self->div_tag($tab->{data}, id => $tab_id);
 239   }
 240
 241   return '' unless @header;
 242
 243   my $ul = $self->ul_tag(join('', @header), id => $id);
 244   return $self->div_tag(join('', $ul, @blocks), class => 'tabwidget');
 245 }
 246
 247 sub tab {
 248   my ($self, $name, $src, %params) = _hashify(3, @_);
 249
 250   $params{method} ||= 'process';
 251
 252   return () if defined $params{if} && !$params{if};
 253
 254   my $data;
 255   if ($params{method} eq 'raw') {
 256     $data = $src;
 257   } elsif ($params{method} eq 'process') {
 258     $data = $self->_context->process($src, %{ $params{args} || {} });
 259   } else {
 260     die "unknown tag method '$params{method}'";
 261   }
 262
 263   return () unless $data;
 264
 265   return +{ name => $name, data => $data };
 266 }
 267
 268 sub areainput_tag {
 269   my ($self, $name, $value, %attributes) = _hashify(3, @_);
 270
 271   my $cols    = delete $attributes{cols} || delete $attributes{size};
 272   my $minrows = delete $attributes{min_rows} || 1;
 273   my $maxrows = delete $attributes{max_rows};
 274   my $rows    = $::form->numtextrows($value, $cols, $maxrows, $minrows);
 275
 276   $attributes{id} ||= _tag_id();
 277   my $id            = $attributes{id};
 278
 279   return $self->textarea_tag($name, $value, %attributes, rows => $rows, cols => $cols) if $rows > 1;
 280
 281   return '<span>'
 282     . $self->input_tag($name, $value, %attributes, size => $cols)
 283     . "<img src=\"image/edit-entry.png\" onclick=\"kivi.switch_areainput_to_textarea('${id}')\" style=\"margin-left: 2px;\">"
 284     . '</span>';
 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>