1 package SL::Template::Plugin::L;
3 use base qw( Template::Plugin );
6 use List::MoreUtils qw(apply);
7 use List::Util qw(max);
8 use Scalar::Util qw(blessed);
11 use SL::Presenter::ALL;
12 use SL::Presenter::Simple;
13 use SL::Util qw(_hashify);
17 { # This will give you an id for identifying html tags and such.
18 # It's guaranteed to be unique unless you exceed 10 mio calls per request.
19 # Do not use these id's to store information across requests.
20 my $_id_sequence = int rand 1e7;
22 return "id_" . ( $_id_sequence = ($_id_sequence + 1) % 1e7 );
28 return $::locale->quote_special_chars('HTML', $string);
33 $string =~ s/(\"|\'|\\)/\\$1/g;
38 my ($class, $context, @args) = @_;
46 die 'not an accessor' if @_ > 1;
47 return $_[0]->{CONTEXT};
51 my ($method, $self, @args) = @_;
53 my $presenter = $::request->presenter;
55 splice @args, -1, 1, %{ $args[-1] } if @args && (ref($args[-1]) eq 'HASH');
57 if (my $sub = SL::Presenter::Simple->can($method)) {
61 if ($presenter->can($method)) {
62 return $presenter->$method(@args);
65 $::lxdebug->message(LXDebug::WARN(), "SL::Presenter has no method named '$method'!");
69 sub name_to_id { return _call_presenter('name_to_id', @_); }
70 sub html_tag { return _call_presenter('html_tag', @_); }
71 sub hidden_tag { return _call_presenter('hidden_tag', @_); }
72 sub select_tag { return _call_presenter('select_tag', @_); }
73 sub checkbox_tag { return _call_presenter('checkbox_tag', @_); }
74 sub input_tag { return _call_presenter('input_tag', @_); }
75 sub javascript { return _call_presenter('javascript', @_); }
76 sub truncate { return _call_presenter('truncate', @_); }
77 sub simple_format { return _call_presenter('simple_format', @_); }
78 sub button_tag { return _call_presenter('button_tag', @_); }
79 sub submit_tag { return _call_presenter('submit_tag', @_); }
80 sub ajax_submit_tag { return _call_presenter('ajax_submit_tag', @_); }
81 sub link { return _call_presenter('link_tag', @_); }
82 sub input_number_tag { return _call_presenter('input_number_tag', @_); }
83 sub textarea_tag { return _call_presenter('textarea_tag', @_); }
84 sub date_tag { return _call_presenter('date_tag', @_); }
86 sub _set_id_attribute {
87 my ($attributes, $name, $unique) = @_;
88 SL::Presenter::Tag::_set_id_attribute($attributes, $name, $unique);
92 my ($self, %options) = _hashify(1, @_);
96 return $self->html_tag('img', undef, %options);
99 sub radio_button_tag {
100 my ($self, $name, %attributes) = _hashify(2, @_);
102 $attributes{value} = 1 unless exists $attributes{value};
104 _set_id_attribute(\%attributes, $name, 1);
105 my $label = delete $attributes{label};
107 _set_id_attribute(\%attributes, $name . '_' . $attributes{value});
109 if ($attributes{checked}) {
110 $attributes{checked} = 'checked';
112 delete $attributes{checked};
115 my $code = $self->html_tag('input', undef, %attributes, name => $name, type => 'radio');
116 $code .= $self->html_tag('label', $label, for => $attributes{id}) if $label;
122 my ($self, $content, @slurp) = @_;
123 return $self->html_tag('div', $content, @slurp);
127 my ($self, $content, @slurp) = @_;
128 return $self->html_tag('ul', $content, @slurp);
132 my ($self, $content, @slurp) = @_;
133 return $self->html_tag('li', $content, @slurp);
137 my ($self, $name, $value, %attributes) = _hashify(3, @_);
139 return $self->select_tag($name, [ [ 1 => $::locale->text('Yes') ], [ 0 => $::locale->text('No') ] ], default => $value ? 1 : 0, %attributes);
146 foreach my $file (@_) {
147 $file .= '.css' unless $file =~ m/\.css$/;
148 $file = "css/${file}" unless $file =~ m|/|;
150 $code .= qq|<link rel="stylesheet" href="${file}" type="text/css" media="screen" />|;
157 # simple version with select_tag
158 sub vendor_selector {
159 my ($self, $name, $value, %params) = _hashify(3, @_);
161 my $actual_vendor_id = (defined $::form->{"$name"})? ((ref $::form->{"$name"}) ? $::form->{"$name"}->id : $::form->{"$name"}) :
162 (ref $value && $value->can('id')) ? $value->id : '';
164 return $self->select_tag($name, SL::DB::Manager::Vendor->get_all(),
165 default => $actual_vendor_id,
166 title_sub => sub { $_[0]->vendornumber . " : " . $_[0]->name },
172 # simple version with select_tag
174 my ($self, $name, $value, %params) = _hashify(3, @_);
176 my $actual_part_id = (defined $::form->{"$name"})? ((ref $::form->{"$name"})? $::form->{"$name"}->id : $::form->{"$name"}) :
177 (ref $value && $value->can('id')) ? $value->id : '';
179 return $self->select_tag($name, SL::DB::Manager::Part->get_all(),
180 default => $actual_part_id,
181 title_sub => sub { $_[0]->partnumber . " : " . $_[0]->description },
191 foreach my $file (@_) {
192 $file .= '.js' unless $file =~ m/\.js$/;
193 $file = "js/${file}" unless $file =~ m|/|;
195 $code .= qq|<script type="text/javascript" src="${file}"></script>|;
202 my ($self, $tabs, %params) = _hashify(2, @_);
203 my $id = $params{id} || 'tab_' . _tag_id();
205 $params{selected} *= 1;
207 die 'L.tabbed needs an arrayred of tabs for first argument'
208 unless ref $tabs eq 'ARRAY';
210 my (@header, @blocks);
211 for my $i (0..$#$tabs) {
212 my $tab = $tabs->[$i];
216 my $tab_id = "__tab_id_$i";
217 push @header, $self->li_tag($self->link('#' . $tab_id, $tab->{name}));
218 push @blocks, $self->div_tag($tab->{data}, id => $tab_id);
221 return '' unless @header;
223 my $ul = $self->ul_tag(join('', @header), id => $id);
224 return $self->div_tag(join('', $ul, @blocks), class => 'tabwidget');
228 my ($self, $name, $src, %params) = _hashify(3, @_);
230 $params{method} ||= 'process';
232 return () if defined $params{if} && !$params{if};
235 if ($params{method} eq 'raw') {
237 } elsif ($params{method} eq 'process') {
238 $data = $self->_context->process($src, %{ $params{args} || {} });
240 die "unknown tag method '$params{method}'";
243 return () unless $data;
245 return +{ name => $name, data => $data };
249 my ($self, $name, $value, %attributes) = _hashify(3, @_);
251 my $cols = delete $attributes{cols} || delete $attributes{size};
252 my $minrows = delete $attributes{min_rows} || 1;
253 my $maxrows = delete $attributes{max_rows};
254 my $rows = $::form->numtextrows($value, $cols, $maxrows, $minrows);
256 $attributes{id} ||= _tag_id();
257 my $id = $attributes{id};
259 return $self->textarea_tag($name, $value, %attributes, rows => $rows, cols => $cols) if $rows > 1;
262 . $self->input_tag($name, $value, %attributes, size => $cols)
263 . "<img src=\"image/edit-entry.png\" onclick=\"kivi.switch_areainput_to_textarea('${id}')\" style=\"margin-left: 2px;\">"
267 sub multiselect2side {
268 my ($self, $id, %params) = _hashify(2, @_);
270 $params{labelsx} = "\"" . _J($params{labelsx} || $::locale->text('Available')) . "\"";
271 $params{labeldx} = "\"" . _J($params{labeldx} || $::locale->text('Selected')) . "\"";
272 $params{moveOptions} = 'false';
274 my $vars = join(', ', map { "${_}: " . $params{$_} } keys %params);
276 <script type="text/javascript">
277 \$().ready(function() {
278 \$('#${id}').multiselect2side({ ${vars} });
286 sub sortable_element {
287 my ($self, $selector, %params) = _hashify(2, @_);
289 my %attributes = ( distance => 5,
290 helper => <<'JAVASCRIPT' );
291 function(event, ui) {
292 ui.children().each(function() {
293 $(this).width($(this).width());
301 if ($params{url} && $params{with}) {
302 my $as = $params{as} || $params{with};
303 my $filter = ".filter(function(idx) { return this.substr(0, " . length($params{with}) . ") == '$params{with}'; })";
304 $filter .= ".map(function(idx, str) { return str.replace('$params{with}_', ''); })";
306 my $params_js = $params{params} ? qq| + ($params{params})| : '';
307 my $ajax_return = '';
308 if ($params{ajax_return}) {
309 $ajax_return = 'kivi.eval_json_result';
312 $stop_event = <<JAVASCRIPT;
313 \$.post('$params{url}'${params_js}, { '${as}[]': \$(\$('${selector}').sortable('toArray'))${filter}.toArray() }, $ajax_return);
317 if (!$params{dont_recolor}) {
318 $stop_event .= <<JAVASCRIPT;
319 \$('${selector}>*:odd').removeClass('listrow1').removeClass('listrow0').addClass('listrow0');
320 \$('${selector}>*:even').removeClass('listrow1').removeClass('listrow0').addClass('listrow1');
325 $attributes{stop} = <<JAVASCRIPT;
326 function(event, ui) {
333 $params{handle} = '.dragdrop' unless exists $params{handle};
334 $attributes{handle} = "'$params{handle}'" if $params{handle};
336 my $attr_str = join(', ', map { "${_}: $attributes{$_}" } keys %attributes);
338 my $code = <<JAVASCRIPT;
339 <script type="text/javascript">
341 \$( "${selector}" ).sortable({ ${attr_str} })
351 return '<pre>' . Data::Dumper::Dumper(@_) . '</pre>';
354 sub sortable_table_header {
355 my ($self, $by, %params) = _hashify(2, @_);
357 my $controller = $self->{CONTEXT}->stash->get('SELF');
358 my $models = $params{models} || $self->{CONTEXT}->stash->get('MODELS');
359 my $sort_spec = $models->get_sort_spec;
360 my $by_spec = $sort_spec->{$by};
361 my %current_sort_params = $models->get_current_sort_params;
362 my ($image, $new_dir) = ('', $current_sort_params{dir});
363 my $title = delete($params{title}) || $::locale->text($by_spec->{title});
365 if ($current_sort_params{sort_by} eq $by) {
366 my $current_dir = $current_sort_params{sort_dir} ? 'up' : 'down';
367 $image = '<img border="0" src="image/' . $current_dir . '.png">';
368 $new_dir = 1 - ($current_sort_params{sort_dir} || 0);
371 $params{ $models->sorted->form_params->[0] } = $by;
372 $params{ $models->sorted->form_params->[1] } = ($new_dir ? '1' : '0');
374 return '<a href="' . $models->get_callback(%params) . '">' . _H($title) . $image . '</a>';
377 sub paginate_controls {
378 my ($self, %params) = _hashify(1, @_);
380 my $controller = $self->{CONTEXT}->stash->get('SELF');
381 my $models = $params{models} || $self->{CONTEXT}->stash->get('MODELS');
382 my $pager = $models->paginated;
383 # my $paginate_spec = $controller->get_paginate_spec;
385 my %paginate_params = $models->get_paginate_args;
387 my %template_params = (
388 pages => \%paginate_params,
390 my %url_params = _hashify(0, @_);
391 $url_params{ $pager->form_params->[0] } = delete $url_params{page};
392 $url_params{ $pager->form_params->[1] } = delete $url_params{per_page} if exists $url_params{per_page};
394 return $models->get_callback(%url_params);
399 return SL::Presenter->get->render('common/paginate', %template_params);
408 SL::Templates::Plugin::L -- Layouting / tag generation
412 Usage from a template:
416 [% L.select_tag('direction', [ [ 'left', 'To the left' ], [ 'right', 'To the right', 1 ] ]) %]
418 [% L.select_tag('direction', [ { direction => 'left', display => 'To the left' },
419 { direction => 'right', display => 'To the right' } ],
420 value_key => 'direction', title_key => 'display', default => 'right')) %]
422 [% L.select_tag('direction', [ { direction => 'left', display => 'To the left' },
423 { direction => 'right', display => 'To the right', selected => 1 } ],
424 value_key => 'direction', title_key => 'display')) %]
428 A module modeled a bit after Rails' ActionView helpers. Several small
429 functions that create HTML tags from various kinds of data sources.
431 The C<id> attribute is usually calculated automatically. This can be
432 overridden by either specifying an C<id> attribute or by setting
437 =head2 LOW-LEVEL FUNCTIONS
439 The following items are just forwarded to L<SL::Presenter::Tag>:
443 =item * C<name_to_id $name>
445 =item * C<stringify_attributes %items>
447 =item * C<html_tag $tag_name, $content_string, %attributes>
451 =head2 HIGH-LEVEL FUNCTIONS
453 The following functions are just forwarded to L<SL::Presenter::Tag>:
457 =item * C<input_tag $name, $value, %attributes>
459 =item * C<hidden_tag $name, $value, %attributes>
461 =item * C<checkbox_tag $name, %attributes>
463 =item * C<select_tag $name, \@collection, %attributes>
465 =item * C<link $href, $content, %attributes>
469 Available high-level functions implemented in this module:
473 =item C<yes_no_tag $name, $value, %attributes>
475 Creates a HTML 'select' tag with the two entries C<yes> and C<no> by
476 calling L<select_tag>. C<$value> determines
477 which entry is selected. The C<%attributes> are passed through to
480 =item C<textarea_tag $name, $value, %attributes>
482 Creates a HTML 'textarea' tag named C<$name> with the content
483 C<$value> and with arbitrary HTML attributes from C<%attributes>. The
484 tag's C<id> defaults to C<name_to_id($name)>.
486 =item C<date_tag $name, $value, %attributes>
488 Creates a date input field, with an attached javascript that will open a
491 =item C<radio_button_tag $name, %attributes>
493 Creates a HTML 'input type=radio' tag named C<$name> with arbitrary
494 HTML attributes from C<%attributes>. The tag's C<value> defaults to
495 C<1>. The tag's C<id> defaults to C<name_to_id($name . "_" . $value)>.
497 If C<%attributes> contains a key C<label> then a HTML 'label' tag is
498 created with said C<label>. No attribute named C<label> is created in
501 =item C<javascript_tag $file1, $file2, $file3...>
503 Creates a HTML 'E<lt>script type="text/javascript" src="..."E<gt>'
504 tag for each file name parameter passed. Each file name will be
505 postfixed with '.js' if it isn't already and prefixed with 'js/' if it
506 doesn't contain a slash.
508 =item C<stylesheet_tag $file1, $file2, $file3...>
510 Creates a HTML 'E<lt>link rel="text/stylesheet" href="..."E<gt>' tag
511 for each file name parameter passed. Each file name will be postfixed
512 with '.css' if it isn't already and prefixed with 'css/' if it doesn't
515 =item C<tabbed \@tab, %attributes>
517 Will create a tabbed area. The tabs should be created with the helper function
521 L.tab(LxERP.t8('Basic Data'), 'part/_main_tab.html'),
522 L.tab(LxERP.t8('Custom Variables'), 'part/_cvar_tab.html', if => SELF.display_cvar_tab),
525 =item C<areainput_tag $name, $content, %PARAMS>
527 Creates a generic input tag or textarea tag, depending on content size. The
528 amount of desired rows must be either given with the C<rows> parameter or can
529 be computed from the value and the C<cols> paramter, Accepted parameters
530 include C<min_rows> for rendering a minimum of rows if a textarea is displayed.
532 You can force input by setting rows to 1, and you can force textarea by setting
535 =item C<multiselect2side $id, %params>
537 Creates a JavaScript snippet calling the jQuery function
538 C<multiselect2side> on the select control with the ID C<$id>. The
539 select itself is not created. C<%params> can contain the following
546 The label of the list of available options. Defaults to the
547 translation of 'Available'.
551 The label of the list of selected options. Defaults to the
552 translation of 'Selected'.
556 =item C<sortable_element $selector, %params>
558 Makes the children of the DOM element C<$selector> (a jQuery selector)
559 sortable with the I<jQuery UI Selectable> library. The children can be
560 dragged & dropped around. After dropping an element an URL can be
561 postet to with the element IDs of the sorted children.
563 If this is used then the JavaScript file C<js/jquery-ui.js> must be
564 included manually as well as it isn't loaded via C<$::form-gt;header>.
566 C<%params> can contain the following entries:
572 The URL to POST an AJAX request to after a dragged element has been
573 dropped. The AJAX request's return value is ignored by default. If given then
574 C<$params{with}> must be given as well.
578 If trueish then the AJAX request's return is accepted.
582 A string that is interpreted as the prefix of the children's ID. Upon
583 POSTing the result each child whose ID starts with C<$params{with}> is
584 considered. The prefix and the following "_" is removed from the
585 ID. The remaining parts of the IDs of those children are posted as a
586 single array parameter. The array parameter's name is either
587 C<$params{as}> or, missing that, C<$params{with}>.
591 Sets the POST parameter name for AJAX request after dropping an
592 element (see C<$params{with}>).
596 An optional jQuery selector specifying which part of the child element
597 is dragable. If the parameter is not given then it defaults to
598 C<.dragdrop> matching DOM elements with the class C<dragdrop>. If the
599 parameter is set and empty then the whole child element is dragable,
600 and clicks through to underlying elements like inputs or links might
603 =item C<dont_recolor>
605 If trueish then the children will not be recolored. The default is to
606 recolor the children by setting the class C<listrow0> on odd and
607 C<listrow1> on even entries.
611 An optional JavaScript string that is evaluated before sending the
612 POST request. The result must be a string that is appended to the URL.
618 <script type="text/javascript" src="js/jquery-ui.js"></script>
620 <table id="thing_list">
622 <tr><td>This</td><td>That</td></tr>
625 <tr id="thingy_2"><td>stuff</td><td>more stuff</td></tr>
626 <tr id="thingy_15"><td>stuff</td><td>more stuff</td></tr>
627 <tr id="thingy_6"><td>stuff</td><td>more stuff</td></tr>
631 [% L.sortable_element('#thing_list tbody',
632 url => 'controller.pl?action=SystemThings/reorder',
635 recolor_rows => 1) %]
637 After dropping e.g. the third element at the top of the list a POST
638 request would be made to the C<reorder> action of the C<SystemThings>
639 controller with a single parameter called C<thing_ids> -- an array
640 containing the values C<[ 6, 2, 15 ]>.
644 Dumps the Argument using L<Data::Dumper> into a E<lt>preE<gt> block.
646 =item C<sortable_table_header $by, %params>
648 Create a link and image suitable for placement in a table
649 header. C<$by> must be an index set up by the controller with
650 L<SL::Controller::Helper::make_sorted>.
652 The optional parameter C<$params{title}> can override the column title
653 displayed to the user. Otherwise the column title from the
654 controller's sort spec is used.
656 The other parameters in C<%params> are passed unmodified to the
657 underlying call to L<SL::Controller::Base::url_for>.
659 See the documentation of L<SL::Controller::Helper::Sorted> for an
660 overview and further usage instructions.
662 =item C<paginate_controls>
664 Create a set of links used to paginate a list view.
666 See the documentation of L<SL::Controller::Helper::Paginated> for an
667 overview and further usage instructions.
671 =head2 CONVERSION FUNCTIONS
675 =item C<tab, description, target, %PARAMS>
677 Creates a tab for C<tabbed>. The description will be used as displayed name.
678 The target should be a block or template that can be processed. C<tab> supports
679 a C<method> parameter, which can override the process method to apply target.
680 C<method => 'raw'> will just include the given text as is. I was too lazy to
681 implement C<include> properly.
683 Also an C<if> attribute is supported, so that tabs can be suppressed based on
684 some occasion. In this case the supplied block won't even get processed, and
685 the resulting tab will get ignored by C<tabbed>:
687 L.tab('Awesome tab wih much info', '_much_info.html', if => SELF.wants_all)
689 =item C<truncate $text, [%params]>
691 See L<SL::Presenter::Text/truncate>.
693 =item C<simple_format $text>
695 See L<SL::Presenter::Text/simple_format>.
699 =head1 MODULE AUTHORS
701 Moritz Bunkus E<lt>m.bunkus@linet-services.deE<gt>
703 L<http://linet-services.de>