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