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     my $params_js = $params{params} ? qq| + ($params{params})| : '';
 394
 395     $stop_event = <<JAVASCRIPT;
 396         \$.post('$params{url}'${params_js}, { '${as}[]': \$(\$('${selector}').sortable('toArray'))${filter}.toArray() });
 397 JAVASCRIPT
 398   }
 399
 400   if (!$params{dont_recolor}) {
 401     $stop_event .= <<JAVASCRIPT;
 402         \$('${selector}>*:odd').removeClass('listrow1').removeClass('listrow0').addClass('listrow0');
 403         \$('${selector}>*:even').removeClass('listrow1').removeClass('listrow0').addClass('listrow1');
 404 JAVASCRIPT
 405   }
 406
 407   if ($stop_event) {
 408     $attributes{stop} = <<JAVASCRIPT;
 409       function(event, ui) {
 410         ${stop_event}
 411         return ui;
 412       }
 413 JAVASCRIPT
 414   }
 415
 416   $params{handle}     = '.dragdrop' unless exists $params{handle};
 417   $attributes{handle} = "'$params{handle}'" if $params{handle};
 418
 419   my $attr_str = join(', ', map { "${_}: $attributes{$_}" } keys %attributes);
 420
 421   my $code = <<JAVASCRIPT;
 422 <script type="text/javascript">
 423   \$(function() {
 424     \$( "${selector}" ).sortable({ ${attr_str} })
 425   });
 426 </script>
 427 JAVASCRIPT
 428
 429   return $code;
 430 }
 431
 432 sub online_help_tag {
 433   my ($self, $tag, %params) = _hashify(2, @_);
 434   my $cc                   = $::myconfig{countrycode};
 435   my $file                 = "doc/online/$cc/$tag.html";
 436   my $text                 = $params{text} || $::locale->text('Help');
 437
 438   die 'malformed help tag' unless $tag =~ /^[a-zA-Z0-9_]+$/;
 439   return unless -f $file;
 440   return $self->html_tag('a', $text, href => $file, class => 'jqModal')
 441 }
 442
 443 sub dump {
 444   my $self = shift;
 445   return '<pre>' . Data::Dumper::Dumper(@_) . '</pre>';
 446 }
 447
 448 sub sortable_table_header {
 449   my ($self, $by, %params) = _hashify(2, @_);
 450
 451   my $controller          = $self->{CONTEXT}->stash->get('SELF');
 452   my $sort_spec           = $controller->get_sort_spec;
 453   my $by_spec             = $sort_spec->{$by};
 454   my %current_sort_params = $controller->get_current_sort_params;
 455   my ($image, $new_dir)   = ('', $current_sort_params{dir});
 456   my $title               = delete($params{title}) || $::locale->text($by_spec->{title});
 457
 458   if ($current_sort_params{by} eq $by) {
 459     my $current_dir = $current_sort_params{dir} ? 'up' : 'down';
 460     $image          = '<img border="0" src="image/' . $current_dir . '.png">';
 461     $new_dir        = 1 - ($current_sort_params{dir} || 0);
 462   }
 463
 464   $params{ $sort_spec->{FORM_PARAMS}->[0] } = $by;
 465   $params{ $sort_spec->{FORM_PARAMS}->[1] } = ($new_dir ? '1' : '0');
 466
 467   return '<a href="' . $controller->get_callback(%params) . '">' . _H($title) . $image . '</a>';
 468 }
 469
 470 sub paginate_controls {
 471   my ($self)          = @_;
 472
 473   my $controller      = $self->{CONTEXT}->stash->get('SELF');
 474   my $paginate_spec   = $controller->get_paginate_spec;
 475   my %paginate_params = $controller->get_current_paginate_params;
 476
 477   my %template_params = (
 478     pages             => \%paginate_params,
 479     url_maker         => sub {
 480       my %url_params                                    = _hashify(0, @_);
 481       $url_params{ $paginate_spec->{FORM_PARAMS}->[0] } = delete $url_params{page};
 482       $url_params{ $paginate_spec->{FORM_PARAMS}->[1] } = delete $url_params{per_page} if exists $url_params{per_page};
 483
 484       return $controller->get_callback(%url_params);
 485     },
 486   );
 487
 488   return SL::Presenter->get->render('common/paginate', %template_params);
 489 }
 490
 491 1;
 492
 493 __END__
 494
 495 =head1 NAME
 496
 497 SL::Templates::Plugin::L -- Layouting / tag generation
 498
 499 =head1 SYNOPSIS
 500
 501 Usage from a template:
 502
 503   [% USE L %]
 504
 505   [% L.select_tag('direction', [ [ 'left', 'To the left' ], [ 'right', 'To the right', 1 ] ]) %]
 506
 507   [% L.select_tag('direction', [ { direction => 'left',  display => 'To the left'  },
 508                                  { direction => 'right', display => 'To the right' } ],
 509                                value_key => 'direction', title_key => 'display', default => 'right')) %]
 510
 511   [% L.select_tag('direction', [ { direction => 'left',  display => 'To the left'  },
 512                                  { direction => 'right', display => 'To the right', selected => 1 } ],
 513                                value_key => 'direction', title_key => 'display')) %]
 514
 515 =head1 DESCRIPTION
 516
 517 A module modeled a bit after Rails' ActionView helpers. Several small
 518 functions that create HTML tags from various kinds of data sources.
 519
 520 The C<id> attribute is usually calculated automatically. This can be
 521 overridden by either specifying an C<id> attribute or by setting
 522 C<no_id> to trueish.
 523
 524 =head1 FUNCTIONS
 525
 526 =head2 LOW-LEVEL FUNCTIONS
 527
 528 The following items are just forwarded to L<SL::Presenter::Tag>:
 529
 530 =over 2
 531
 532 =item * C<name_to_id $name>
 533
 534 =item * C<stringify_attributes %items>
 535
 536 =item * C<html_tag $tag_name, $content_string, %attributes>
 537
 538 =back
 539
 540 =head2 HIGH-LEVEL FUNCTIONS
 541
 542 The following functions are just forwarded to L<SL::Presenter::Tag>:
 543
 544 =over 2
 545
 546 =item * C<input_tag $name, $value, %attributes>
 547
 548 =item * C<select_tag $name, \@collection, %attributes>
 549
 550 =back
 551
 552 Available high-level functions implemented in this module:
 553
 554 =over 4
 555
 556 =item C<yes_no_tag $name, $value, %attributes>
 557
 558 Creates a HTML 'select' tag with the two entries C<yes> and C<no> by
 559 calling L<select_tag>. C<$value> determines
 560 which entry is selected. The C<%attributes> are passed through to
 561 L<select_tag>.
 562
 563 =item C<hidden_tag $name, $value, %attributes>
 564
 565 Creates a HTML 'input type=hidden' tag named C<$name> with the value
 566 C<$value> and with arbitrary HTML attributes from C<%attributes>. The
 567 tag's C<id> defaults to C<name_to_id($name)>.
 568
 569 =item C<submit_tag $name, $value, %attributes>
 570
 571 Creates a HTML 'input type=submit class=submit' tag named C<$name> with the
 572 value C<$value> and with arbitrary HTML attributes from C<%attributes>. The
 573 tag's C<id> defaults to C<name_to_id($name)>.
 574
 575 If C<$attributes{confirm}> is set then a JavaScript popup dialog will
 576 be added via the C<onclick> handler asking the question given with
 577 C<$attributes{confirm}>. The request is only submitted if the user
 578 clicks the dialog's ok/yes button.
 579
 580 =item C<ajax_submit_tag $url, $form_selector, $text, %attributes>
 581
 582 Creates a HTML 'input type="button"' tag with a very specific onclick
 583 handler that submits the form given by the jQuery selector
 584 C<$form_selector> to the URL C<$url> (the actual JavaScript function
 585 called for that is C<kivi.submit_ajax_form()> in
 586 C<js/client_js.js>). The button's label will be C<$text>.
 587
 588 =item C<button_tag $onclick, $text, %attributes>
 589
 590 Creates a HTML 'input type="button"' tag with an onclick handler
 591 C<$onclick> and a value of C<$text>. The button does not have a name
 592 nor an ID by default.
 593
 594 If C<$attributes{confirm}> is set then a JavaScript popup dialog will
 595 be prepended to the C<$onclick> handler asking the question given with
 596 C<$attributes{confirm}>. The request is only submitted if the user
 597 clicks the dialog's "ok/yes" button.
 598
 599 =item C<textarea_tag $name, $value, %attributes>
 600
 601 Creates a HTML 'textarea' tag named C<$name> with the content
 602 C<$value> and with arbitrary HTML attributes from C<%attributes>. The
 603 tag's C<id> defaults to C<name_to_id($name)>.
 604
 605 =item C<checkbox_tag $name, %attributes>
 606
 607 Creates a HTML 'input type=checkbox' tag named C<$name> with arbitrary
 608 HTML attributes from C<%attributes>. The tag's C<id> defaults to
 609 C<name_to_id($name)>. The tag's C<value> defaults to C<1>.
 610
 611 If C<%attributes> contains a key C<label> then a HTML 'label' tag is
 612 created with said C<label>. No attribute named C<label> is created in
 613 that case.
 614
 615 If C<%attributes> contains a key C<checkall> then the value is taken as a
 616 JQuery selector and clicking this checkbox will also toggle all checkboxes
 617 matching the selector.
 618
 619 =item C<date_tag $name, $value, %attributes>
 620
 621 Creates a date input field, with an attached javascript that will open a
 622 calendar on click.
 623
 624 =item C<radio_button_tag $name, %attributes>
 625
 626 Creates a HTML 'input type=radio' tag named C<$name> with arbitrary
 627 HTML attributes from C<%attributes>. The tag's C<value> defaults to
 628 C<1>. The tag's C<id> defaults to C<name_to_id($name . "_" . $value)>.
 629
 630 If C<%attributes> contains a key C<label> then a HTML 'label' tag is
 631 created with said C<label>. No attribute named C<label> is created in
 632 that case.
 633
 634 =item C<javascript_tag $file1, $file2, $file3...>
 635
 636 Creates a HTML 'E<lt>script type="text/javascript" src="..."E<gt>'
 637 tag for each file name parameter passed. Each file name will be
 638 postfixed with '.js' if it isn't already and prefixed with 'js/' if it
 639 doesn't contain a slash.
 640
 641 =item C<stylesheet_tag $file1, $file2, $file3...>
 642
 643 Creates a HTML 'E<lt>link rel="text/stylesheet" href="..."E<gt>' tag
 644 for each file name parameter passed. Each file name will be postfixed
 645 with '.css' if it isn't already and prefixed with 'css/' if it doesn't
 646 contain a slash.
 647
 648 =item C<tabbed \@tab, %attributes>
 649
 650 Will create a tabbed area. The tabs should be created with the helper function
 651 C<tab>. Example:
 652
 653   [% L.tabbed([
 654     L.tab(LxERP.t8('Basic Data'),       'part/_main_tab.html'),
 655     L.tab(LxERP.t8('Custom Variables'), 'part/_cvar_tab.html', if => SELF.display_cvar_tab),
 656   ]) %]
 657
 658 =item C<areainput_tag $name, $content, %PARAMS>
 659
 660 Creates a generic input tag or textarea tag, depending on content size. The
 661 amount of desired rows must be either given with the C<rows> parameter or can
 662 be computed from the value and the C<cols> paramter, Accepted parameters
 663 include C<min_rows> for rendering a minimum of rows if a textarea is displayed.
 664
 665 You can force input by setting rows to 1, and you can force textarea by setting
 666 rows to anything >1.
 667
 668 =item C<multiselect2side $id, %params>
 669
 670 Creates a JavaScript snippet calling the jQuery function
 671 C<multiselect2side> on the select control with the ID C<$id>. The
 672 select itself is not created. C<%params> can contain the following
 673 entries:
 674
 675 =over 2
 676
 677 =item C<labelsx>
 678
 679 The label of the list of available options. Defaults to the
 680 translation of 'Available'.
 681
 682 =item C<labeldx>
 683
 684 The label of the list of selected options. Defaults to the
 685 translation of 'Selected'.
 686
 687 =back
 688
 689 =item C<sortable_element $selector, %params>
 690
 691 Makes the children of the DOM element C<$selector> (a jQuery selector)
 692 sortable with the I<jQuery UI Selectable> library. The children can be
 693 dragged & dropped around. After dropping an element an URL can be
 694 postet to with the element IDs of the sorted children.
 695
 696 If this is used then the JavaScript file C<js/jquery-ui.js> must be
 697 included manually as well as it isn't loaded via C<$::form-gt;header>.
 698
 699 C<%params> can contain the following entries:
 700
 701 =over 2
 702
 703 =item C<url>
 704
 705 The URL to POST an AJAX request to after a dragged element has been
 706 dropped. The AJAX request's return value is ignored. If given then
 707 C<$params{with}> must be given as well.
 708
 709 =item C<with>
 710
 711 A string that is interpreted as the prefix of the children's ID. Upon
 712 POSTing the result each child whose ID starts with C<$params{with}> is
 713 considered. The prefix and the following "_" is removed from the
 714 ID. The remaining parts of the IDs of those children are posted as a
 715 single array parameter. The array parameter's name is either
 716 C<$params{as}> or, missing that, C<$params{with}>.
 717
 718 =item C<as>
 719
 720 Sets the POST parameter name for AJAX request after dropping an
 721 element (see C<$params{with}>).
 722
 723 =item C<handle>
 724
 725 An optional jQuery selector specifying which part of the child element
 726 is dragable. If the parameter is not given then it defaults to
 727 C<.dragdrop> matching DOM elements with the class C<dragdrop>.  If the
 728 parameter is set and empty then the whole child element is dragable,
 729 and clicks through to underlying elements like inputs or links might
 730 not work.
 731
 732 =item C<dont_recolor>
 733
 734 If trueish then the children will not be recolored. The default is to
 735 recolor the children by setting the class C<listrow0> on odd and
 736 C<listrow1> on even entries.
 737
 738 =item C<params>
 739
 740 An optional JavaScript string that is evaluated before sending the
 741 POST request. The result must be a string that is appended to the URL.
 742
 743 =back
 744
 745 Example:
 746
 747   <script type="text/javascript" src="js/jquery-ui.js"></script>
 748
 749   <table id="thing_list">
 750     <thead>
 751       <tr><td>This</td><td>That</td></tr>
 752     </thead>
 753     <tbody>
 754       <tr id="thingy_2"><td>stuff</td><td>more stuff</td></tr>
 755       <tr id="thingy_15"><td>stuff</td><td>more stuff</td></tr>
 756       <tr id="thingy_6"><td>stuff</td><td>more stuff</td></tr>
 757     </tbody>
 758   <table>
 759
 760   [% L.sortable_element('#thing_list tbody',
 761                         url          => 'controller.pl?action=SystemThings/reorder',
 762                         with         => 'thingy',
 763                         as           => 'thing_ids',
 764                         recolor_rows => 1) %]
 765
 766 After dropping e.g. the third element at the top of the list a POST
 767 request would be made to the C<reorder> action of the C<SystemThings>
 768 controller with a single parameter called C<thing_ids> -- an array
 769 containing the values C<[ 6, 2, 15 ]>.
 770
 771 =item C<dump REF>
 772
 773 Dumps the Argument using L<Data::Dumper> into a E<lt>preE<gt> block.
 774
 775 =item C<sortable_table_header $by, %params>
 776
 777 Create a link and image suitable for placement in a table
 778 header. C<$by> must be an index set up by the controller with
 779 L<SL::Controller::Helper::make_sorted>.
 780
 781 The optional parameter C<$params{title}> can override the column title
 782 displayed to the user. Otherwise the column title from the
 783 controller's sort spec is used.
 784
 785 The other parameters in C<%params> are passed unmodified to the
 786 underlying call to L<SL::Controller::Base::url_for>.
 787
 788 See the documentation of L<SL::Controller::Helper::Sorted> for an
 789 overview and further usage instructions.
 790
 791 =item C<paginate_controls>
 792
 793 Create a set of links used to paginate a list view.
 794
 795 See the documentation of L<SL::Controller::Helper::Paginated> for an
 796 overview and further usage instructions.
 797
 798 =back
 799
 800 =head2 CONVERSION FUNCTIONS
 801
 802 =over 4
 803
 804 =item C<tab, description, target, %PARAMS>
 805
 806 Creates a tab for C<tabbed>. The description will be used as displayed name.
 807 The target should be a block or template that can be processed. C<tab> supports
 808 a C<method> parameter, which can override the process method to apply target.
 809 C<method => 'raw'> will just include the given text as is. I was too lazy to
 810 implement C<include> properly.
 811
 812 Also an C<if> attribute is supported, so that tabs can be suppressed based on
 813 some occasion. In this case the supplied block won't even get processed, and
 814 the resulting tab will get ignored by C<tabbed>:
 815
 816   L.tab('Awesome tab wih much info', '_much_info.html', if => SELF.wants_all)
 817
 818 =item C<truncate $text, [%params]>
 819
 820 See L<SL::Presenter::Text/truncate>.
 821
 822 =item C<simple_format $text>
 823
 824 See L<SL::Presenter::Text/simple_format>.
 825
 826 =back
 827
 828 =head1 MODULE AUTHORS
 829
 830 Moritz Bunkus E<lt>m.bunkus@linet-services.deE<gt>
 831
 832 L<http://linet-services.de>