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