SL/Template/Plugin/L.pm

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