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 use SL::Util qw(_hashify);
  11
  12 use strict;
  13
  14 { # This will give you an id for identifying html tags and such.
  15   # It's guaranteed to be unique unless you exceed 10 mio calls per request.
  16   # Do not use these id's to store information across requests.
  17 my $_id_sequence = int rand 1e7;
  18 sub _tag_id {
  19   return "id_" . ( $_id_sequence = ($_id_sequence + 1) % 1e7 );
  20 }
  21 }
  22
  23 sub _H {
  24   my $string = shift;
  25   return $::locale->quote_special_chars('HTML', $string);
  26 }
  27
  28 sub _J {
  29   my $string = shift;
  30   $string    =~ s/(\"|\'|\\)/\\$1/g;
  31   return $string;
  32 }
  33
  34 sub new {
  35   my ($class, $context, @args) = @_;
  36
  37   return bless {
  38     CONTEXT => $context,
  39   }, $class;
  40 }
  41
  42 sub _context {
  43   die 'not an accessor' if @_ > 1;
  44   return $_[0]->{CONTEXT};
  45 }
  46
  47 sub _call_presenter {
  48   my ($method, $self, @args) = @_;
  49
  50   my $presenter              = $::request->presenter;
  51
  52   if (!$presenter->can($method)) {
  53     $::lxdebug->message(LXDebug::WARN(), "SL::Presenter has no method named '$method'!");
  54     return '';
  55   }
  56
  57   splice @args, -1, 1, %{ $args[-1] } if @args && (ref($args[-1]) eq 'HASH');
  58
  59   $presenter->$method(@args);
  60 }
  61
  62 sub name_to_id    { return _call_presenter('name_to_id',    @_); }
  63 sub html_tag      { return _call_presenter('html_tag',      @_); }
  64 sub select_tag    { return _call_presenter('select_tag',    @_); }
  65 sub input_tag     { return _call_presenter('input_tag',     @_); }
  66 sub truncate      { return _call_presenter('truncate',      @_); }
  67 sub simple_format { return _call_presenter('simple_format', @_); }
  68
  69 sub _set_id_attribute {
  70   my ($attributes, $name) = @_;
  71   SL::Presenter::Tag::_set_id_attribute($attributes, $name);
  72 }
  73
  74 sub img_tag {
  75   my ($self, %options) = _hashify(1, @_);
  76
  77   $options{alt} ||= '';
  78
  79   return $self->html_tag('img', undef, %options);
  80 }
  81
  82 sub textarea_tag {
  83   my ($self, $name, $content, %attributes) = _hashify(3, @_);
  84
  85   _set_id_attribute(\%attributes, $name);
  86   $attributes{rows}  *= 1; # required by standard
  87   $attributes{cols}  *= 1; # required by standard
  88   $content            = $content ? _H($content) : '';
  89
  90   return $self->html_tag('textarea', $content, %attributes, name => $name);
  91 }
  92
  93 sub checkbox_tag {
  94   my ($self, $name, %attributes) = _hashify(2, @_);
  95
  96   _set_id_attribute(\%attributes, $name);
  97   $attributes{value}   = 1 unless defined $attributes{value};
  98   my $label            = delete $attributes{label};
  99   my $checkall         = delete $attributes{checkall};
 100
 101   if ($attributes{checked}) {
 102     $attributes{checked} = 'checked';
 103   } else {
 104     delete $attributes{checked};
 105   }
 106
 107   my $code  = $self->html_tag('input', undef,  %attributes, name => $name, type => 'checkbox');
 108   $code    .= $self->html_tag('label', $label, for => $attributes{id}) if $label;
 109   $code    .= $self->javascript(qq|\$('#$attributes{id}').checkall('$checkall');|) if $checkall;
 110
 111   return $code;
 112 }
 113
 114 sub radio_button_tag {
 115   my ($self, $name, %attributes) = _hashify(2, @_);
 116
 117   _set_id_attribute(\%attributes, $name);
 118   $attributes{value}   = 1 unless defined $attributes{value};
 119   my $label            = delete $attributes{label};
 120
 121   if ($attributes{checked}) {
 122     $attributes{checked} = 'checked';
 123   } else {
 124     delete $attributes{checked};
 125   }
 126
 127   my $code  = $self->html_tag('input', undef,  %attributes, name => $name, type => 'radio');
 128   $code    .= $self->html_tag('label', $label, for => $attributes{id}) if $label;
 129
 130   return $code;
 131 }
 132
 133 sub hidden_tag {
 134   my ($self, $name, $value, %attributes) = _hashify(3, @_);
 135   return $self->input_tag($name, $value, %attributes, type => 'hidden');
 136 }
 137
 138 sub div_tag {
 139   my ($self, $content, @slurp) = @_;
 140   return $self->html_tag('div', $content, @slurp);
 141 }
 142
 143 sub ul_tag {
 144   my ($self, $content, @slurp) = @_;
 145   return $self->html_tag('ul', $content, @slurp);
 146 }
 147
 148 sub li_tag {
 149   my ($self, $content, @slurp) = @_;
 150   return $self->html_tag('li', $content, @slurp);
 151 }
 152
 153 sub link {
 154   my ($self, $href, $content, %params) = _hashify(3, @_);
 155
 156   $href ||= '#';
 157
 158   return $self->html_tag('a', $content, %params, href => $href);
 159 }
 160
 161 sub submit_tag {
 162   my ($self, $name, $value, %attributes) = _hashify(3, @_);
 163
 164   if ( $attributes{confirm} ) {
 165     $attributes{onclick} = 'return confirm("'. _J(delete($attributes{confirm})) .'");';
 166   }
 167
 168   return $self->input_tag($name, $value, %attributes, type => 'submit', class => 'submit');
 169 }
 170
 171 sub button_tag {
 172   my ($self, $onclick, $value, %attributes) = _hashify(3, @_);
 173
 174   _set_id_attribute(\%attributes, $attributes{name}) if $attributes{name};
 175   $attributes{type} ||= 'button';
 176
 177   $onclick = 'if (!confirm("'. _J(delete($attributes{confirm})) .'")) return false; ' . $onclick if $attributes{confirm};
 178
 179   return $self->html_tag('input', undef, %attributes, value => $value, onclick => $onclick);
 180 }
 181
 182 sub ajax_submit_tag {
 183   my ($self, $url, $form_selector, $text, @slurp) = @_;
 184
 185   $url           = _J($url);
 186   $form_selector = _J($form_selector);
 187   my $onclick    = qq|submit_ajax_form('${url}', '${form_selector}')|;
 188
 189   return $self->button_tag($onclick, $text, @slurp);
 190 }
 191
 192 sub yes_no_tag {
 193   my ($self, $name, $value, %attributes) = _hashify(3, @_);
 194
 195   return $self->select_tag($name, [ [ 1 => $::locale->text('Yes') ], [ 0 => $::locale->text('No') ] ], default => $value ? 1 : 0, %attributes);
 196 }
 197
 198 sub javascript {
 199   my ($self, $data) = @_;
 200   return $self->html_tag('script', $data, type => 'text/javascript');
 201 }
 202
 203 sub stylesheet_tag {
 204   my $self = shift;
 205   my $code = '';
 206
 207   foreach my $file (@_) {
 208     $file .= '.css'        unless $file =~ m/\.css$/;
 209     $file  = "css/${file}" unless $file =~ m|/|;
 210
 211     $code .= qq|<link rel="stylesheet" href="${file}" type="text/css" media="screen" />|;
 212   }
 213
 214   return $code;
 215 }
 216
 217 my $date_tag_id_idx = 0;
 218 sub date_tag {
 219   my ($self, $name, $value, %params) = _hashify(3, @_);
 220
 221   _set_id_attribute(\%params, $name);
 222   my @onchange = $params{onchange} ? (onChange => delete $params{onchange}) : ();
 223   my @class    = $params{no_cal} || $params{readonly} ? () : (class => 'datepicker');
 224
 225   return $self->input_tag(
 226     $name, blessed($value) ? $value->to_lxoffice : $value,
 227     size   => 11,
 228     onblur => "check_right_date_format(this);",
 229     %params,
 230     @class, @onchange,
 231   );
 232 }
 233
 234 sub customer_picker {
 235   my ($self, $name, $value, %params) = @_;
 236   my $name_e    = _H($name);
 237
 238   $::request->{layout}->add_javascripts('autocomplete_customer.js');
 239
 240   $self->hidden_tag($name, (ref $value && $value->can('id') ? $value->id : ''), class => 'customer_autocomplete') .
 241   $self->input_tag("$name_e\_name", (ref $value && $value->can('name')) ? $value->name : '', %params);
 242 }
 243
 244 # simple version with select_tag
 245 sub vendor_selector {
 246   my ($self, $name, $value, %params) = @_;
 247
 248   my $actual_vendor_id = (defined $::form->{"$name"})? ((ref $::form->{"$name"}) ? $::form->{"$name"}->id : $::form->{"$name"}) :
 249                          (ref $value && $value->can('id')) ? $value->id : '';
 250
 251   return $self->select_tag($name, SL::DB::Manager::Vendor->get_all(),
 252                                   default      => $actual_vendor_id,
 253                                   title_sub    => sub { $_[0]->vendornumber . " : " . $_[0]->name },
 254                                   'with_empty' => 1,
 255                                   %params);
 256 }
 257
 258
 259 # simple version with select_tag
 260 sub part_selector {
 261   my ($self, $name, $value, %params) = @_;
 262
 263   my $actual_part_id = (defined $::form->{"$name"})? ((ref $::form->{"$name"})? $::form->{"$name"}->id : $::form->{"$name"}) :
 264                        (ref $value && $value->can('id')) ? $value->id : '';
 265
 266   return $self->select_tag($name, SL::DB::Manager::Part->get_all(),
 267                            default      => $actual_part_id,
 268                            title_sub    => sub { $_[0]->partnumber . " : " . $_[0]->description },
 269                            with_empty   => 1,
 270                            %params);
 271 }
 272
 273
 274 sub javascript_tag {
 275   my $self = shift;
 276   my $code = '';
 277
 278   foreach my $file (@_) {
 279     $file .= '.js'        unless $file =~ m/\.js$/;
 280     $file  = "js/${file}" unless $file =~ m|/|;
 281
 282     $code .= qq|<script type="text/javascript" src="${file}"></script>|;
 283   }
 284
 285   return $code;
 286 }
 287
 288 sub tabbed {
 289   my ($self, $tabs, %params) = _hashify(2, @_);
 290   my $id       = $params{id} || 'tab_' . _tag_id();
 291
 292   $params{selected} *= 1;
 293
 294   die 'L.tabbed needs an arrayred of tabs for first argument'
 295     unless ref $tabs eq 'ARRAY';
 296
 297   my (@header, @blocks);
 298   for my $i (0..$#$tabs) {
 299     my $tab = $tabs->[$i];
 300
 301     next if $tab eq '';
 302
 303     my $tab_id = "__tab_id_$i";
 304     push @header, $self->li_tag($self->link('#' . $tab_id, $tab->{name}));
 305     push @blocks, $self->div_tag($tab->{data}, id => $tab_id);
 306   }
 307
 308   return '' unless @header;
 309
 310   my $ul = $self->ul_tag(join('', @header), id => $id);
 311   return $self->div_tag(join('', $ul, @blocks), class => 'tabwidget');
 312 }
 313
 314 sub tab {
 315   my ($self, $name, $src, %params) = _hashify(3, @_);
 316
 317   $params{method} ||= 'process';
 318
 319   return () if defined $params{if} && !$params{if};
 320
 321   my $data;
 322   if ($params{method} eq 'raw') {
 323     $data = $src;
 324   } elsif ($params{method} eq 'process') {
 325     $data = $self->_context->process($src, %{ $params{args} || {} });
 326   } else {
 327     die "unknown tag method '$params{method}'";
 328   }
 329
 330   return () unless $data;
 331
 332   return +{ name => $name, data => $data };
 333 }
 334
 335 sub areainput_tag {
 336   my ($self, $name, $value, %attributes) = _hashify(3, @_);
 337
 338   my ($rows, $cols);
 339   my $min  = delete $attributes{min_rows} || 1;
 340
 341   if (exists $attributes{cols}) {
 342     $cols = delete $attributes{cols};
 343     $rows = $::form->numtextrows($value, $cols);
 344   } else {
 345     $rows = delete $attributes{rows} || 1;
 346   }
 347
 348   return $rows > 1
 349     ? $self->textarea_tag($name, $value, %attributes, rows => max($rows, $min), ($cols ? (cols => $cols) : ()))
 350     : $self->input_tag($name, $value, %attributes, ($cols ? (size => $cols) : ()));
 351 }
 352
 353 sub multiselect2side {
 354   my ($self, $id, %params) = _hashify(2, @_);
 355
 356   $params{labelsx}        = "\"" . _J($params{labelsx} || $::locale->text('Available')) . "\"";
 357   $params{labeldx}        = "\"" . _J($params{labeldx} || $::locale->text('Selected'))  . "\"";
 358   $params{moveOptions}    = 'false';
 359
 360   my $vars                = join(', ', map { "${_}: " . $params{$_} } keys %params);
 361   my $code                = <<EOCODE;
 362 <script type="text/javascript">
 363   \$().ready(function() {
 364     \$('#${id}').multiselect2side({ ${vars} });
 365   });
 366 </script>
 367 EOCODE
 368
 369   return $code;
 370 }
 371
 372 sub sortable_element {
 373   my ($self, $selector, %params) = _hashify(2, @_);
 374
 375   my %attributes = ( distance => 5,
 376                      helper   => <<'JAVASCRIPT' );
 377     function(event, ui) {
 378       ui.children().each(function() {
 379         $(this).width($(this).width());
 380       });
 381       return ui;
 382     }
 383 JAVASCRIPT
 384
 385   my $stop_event = '';
 386
 387   if ($params{url} && $params{with}) {
 388     my $as      = $params{as} || $params{with};
 389     my $filter  = ".filter(function(idx) { return this.substr(0, " . length($params{with}) . ") == '$params{with}'; })";
 390     $filter    .= ".map(function(idx, str) { return str.replace('$params{with}_', ''); })";
 391
 392     $stop_event = <<JAVASCRIPT;
 393         \$.post('$params{url}', { '${as}[]': \$(\$('${selector}').sortable('toArray'))${filter}.toArray() });
 394 JAVASCRIPT
 395   }
 396
 397   if (!$params{dont_recolor}) {
 398     $stop_event .= <<JAVASCRIPT;
 399         \$('${selector}>*:odd').removeClass('listrow1').removeClass('listrow0').addClass('listrow0');
 400         \$('${selector}>*:even').removeClass('listrow1').removeClass('listrow0').addClass('listrow1');
 401 JAVASCRIPT
 402   }
 403
 404   if ($stop_event) {
 405     $attributes{stop} = <<JAVASCRIPT;
 406       function(event, ui) {
 407         ${stop_event}
 408         return ui;
 409       }
 410 JAVASCRIPT
 411   }
 412
 413   $params{handle}     = '.dragdrop' unless exists $params{handle};
 414   $attributes{handle} = "'$params{handle}'" if $params{handle};
 415
 416   my $attr_str = join(', ', map { "${_}: $attributes{$_}" } keys %attributes);
 417
 418   my $code = <<JAVASCRIPT;
 419 <script type="text/javascript">
 420   \$(function() {
 421     \$( "${selector}" ).sortable({ ${attr_str} })
 422   });
 423 </script>
 424 JAVASCRIPT
 425
 426   return $code;
 427 }
 428
 429 sub online_help_tag {
 430   my ($self, $tag, %params) = _hashify(2, @_);
 431   my $cc                   = $::myconfig{countrycode};
 432   my $file                 = "doc/online/$cc/$tag.html";
 433   my $text                 = $params{text} || $::locale->text('Help');
 434
 435   die 'malformed help tag' unless $tag =~ /^[a-zA-Z0-9_]+$/;
 436   return unless -f $file;
 437   return $self->html_tag('a', $text, href => $file, class => 'jqModal')
 438 }
 439
 440 sub dump {
 441   my $self = shift;
 442   require Data::Dumper;
 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<submit_ajax_form()> in C<js/client_js.js>). The
 584 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>