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', @_); }
85 sub div_tag { return _call_presenter('div_tag', @_); }
87 sub _set_id_attribute {
88 my ($attributes, $name, $unique) = @_;
89 SL::Presenter::Tag::_set_id_attribute($attributes, $name, $unique);
93 my ($self, %options) = _hashify(1, @_);
97 return $self->html_tag('img', undef, %options);
100 sub radio_button_tag {
101 my ($self, $name, %attributes) = _hashify(2, @_);
103 $attributes{value} = 1 unless exists $attributes{value};
105 _set_id_attribute(\%attributes, $name, 1);
106 my $label = delete $attributes{label};
108 _set_id_attribute(\%attributes, $name . '_' . $attributes{value});
110 if ($attributes{checked}) {
111 $attributes{checked} = 'checked';
113 delete $attributes{checked};
116 my $code = $self->html_tag('input', undef, %attributes, name => $name, type => 'radio');
117 $code .= $self->html_tag('label', $label, for => $attributes{id}) if $label;
123 my ($self, $content, @slurp) = @_;
124 return $self->html_tag('ul', $content, @slurp);
128 my ($self, $content, @slurp) = @_;
129 return $self->html_tag('li', $content, @slurp);
133 my ($self, $name, $value, %attributes) = _hashify(3, @_);
135 return $self->select_tag($name, [ [ 1 => $::locale->text('Yes') ], [ 0 => $::locale->text('No') ] ], default => $value ? 1 : 0, %attributes);
142 foreach my $file (@_) {
143 $file .= '.css' unless $file =~ m/\.css$/;
144 $file = "css/${file}" unless $file =~ m|/|;
146 $code .= qq|<link rel="stylesheet" href="${file}" type="text/css" media="screen" />|;
153 # simple version with select_tag
154 sub vendor_selector {
155 my ($self, $name, $value, %params) = _hashify(3, @_);
157 my $actual_vendor_id = (defined $::form->{"$name"})? ((ref $::form->{"$name"}) ? $::form->{"$name"}->id : $::form->{"$name"}) :
158 (ref $value && $value->can('id')) ? $value->id : '';
160 return $self->select_tag($name, SL::DB::Manager::Vendor->get_all(),
161 default => $actual_vendor_id,
162 title_sub => sub { $_[0]->vendornumber . " : " . $_[0]->name },
168 # simple version with select_tag
170 my ($self, $name, $value, %params) = _hashify(3, @_);
172 my $actual_part_id = (defined $::form->{"$name"})? ((ref $::form->{"$name"})? $::form->{"$name"}->id : $::form->{"$name"}) :
173 (ref $value && $value->can('id')) ? $value->id : '';
175 return $self->select_tag($name, SL::DB::Manager::Part->get_all(),
176 default => $actual_part_id,
177 title_sub => sub { $_[0]->partnumber . " : " . $_[0]->description },
187 foreach my $file (@_) {
188 $file .= '.js' unless $file =~ m/\.js$/;
189 $file = "js/${file}" unless $file =~ m|/|;
191 $code .= qq|<script type="text/javascript" src="${file}"></script>|;
198 my ($self, $tabs, %params) = _hashify(2, @_);
199 my $id = $params{id} || 'tab_' . _tag_id();
201 $params{selected} *= 1;
203 die 'L.tabbed needs an arrayred of tabs for first argument'
204 unless ref $tabs eq 'ARRAY';
206 my (@header, @blocks);
207 for my $i (0..$#$tabs) {
208 my $tab = $tabs->[$i];
212 my $tab_id = "__tab_id_$i";
213 push @header, $self->li_tag($self->link('#' . $tab_id, $tab->{name}));
214 push @blocks, $self->div_tag($tab->{data}, id => $tab_id);
217 return '' unless @header;
219 my $ul = $self->ul_tag(join('', @header), id => $id);
220 return $self->div_tag(join('', $ul, @blocks), class => 'tabwidget');
224 my ($self, $name, $src, %params) = _hashify(3, @_);
226 $params{method} ||= 'process';
228 return () if defined $params{if} && !$params{if};
231 if ($params{method} eq 'raw') {
233 } elsif ($params{method} eq 'process') {
234 $data = $self->_context->process($src, %{ $params{args} || {} });
236 die "unknown tag method '$params{method}'";
239 return () unless $data;
241 return +{ name => $name, data => $data };
245 my ($self, $name, $value, %attributes) = _hashify(3, @_);
247 my $cols = delete $attributes{cols} || delete $attributes{size};
248 my $minrows = delete $attributes{min_rows} || 1;
249 my $maxrows = delete $attributes{max_rows};
250 my $rows = $::form->numtextrows($value, $cols, $maxrows, $minrows);
252 $attributes{id} ||= _tag_id();
253 my $id = $attributes{id};
255 return $self->textarea_tag($name, $value, %attributes, rows => $rows, cols => $cols) if $rows > 1;
258 . $self->input_tag($name, $value, %attributes, size => $cols)
259 . "<img src=\"image/edit-entry.png\" onclick=\"kivi.switch_areainput_to_textarea('${id}')\" style=\"margin-left: 2px;\">"
263 sub multiselect2side {
264 my ($self, $id, %params) = _hashify(2, @_);
266 $params{labelsx} = "\"" . _J($params{labelsx} || $::locale->text('Available')) . "\"";
267 $params{labeldx} = "\"" . _J($params{labeldx} || $::locale->text('Selected')) . "\"";
268 $params{moveOptions} = 'false';
270 my $vars = join(', ', map { "${_}: " . $params{$_} } keys %params);
272 <script type="text/javascript">
273 \$().ready(function() {
274 \$('#${id}').multiselect2side({ ${vars} });
282 sub sortable_element {
283 my ($self, $selector, %params) = _hashify(2, @_);
285 my %attributes = ( distance => 5,
286 helper => <<'JAVASCRIPT' );
287 function(event, ui) {
288 ui.children().each(function() {
289 $(this).width($(this).width());
297 if ($params{url} && $params{with}) {
298 my $as = $params{as} || $params{with};
299 my $filter = ".filter(function(idx) { return this.substr(0, " . length($params{with}) . ") == '$params{with}'; })";
300 $filter .= ".map(function(idx, str) { return str.replace('$params{with}_', ''); })";
302 my $params_js = $params{params} ? qq| + ($params{params})| : '';
303 my $ajax_return = '';
304 if ($params{ajax_return}) {
305 $ajax_return = 'kivi.eval_json_result';
308 $stop_event = <<JAVASCRIPT;
309 \$.post('$params{url}'${params_js}, { '${as}[]': \$(\$('${selector}').sortable('toArray'))${filter}.toArray() }, $ajax_return);
313 if (!$params{dont_recolor}) {
314 $stop_event .= <<JAVASCRIPT;
315 \$('${selector}>*:odd').removeClass('listrow1').removeClass('listrow0').addClass('listrow0');
316 \$('${selector}>*:even').removeClass('listrow1').removeClass('listrow0').addClass('listrow1');
321 $attributes{stop} = <<JAVASCRIPT;
322 function(event, ui) {
329 $params{handle} = '.dragdrop' unless exists $params{handle};
330 $attributes{handle} = "'$params{handle}'" if $params{handle};
332 my $attr_str = join(', ', map { "${_}: $attributes{$_}" } keys %attributes);
334 my $code = <<JAVASCRIPT;
335 <script type="text/javascript">
337 \$( "${selector}" ).sortable({ ${attr_str} })
347 return '<pre>' . Data::Dumper::Dumper(@_) . '</pre>';
350 sub sortable_table_header {
351 my ($self, $by, %params) = _hashify(2, @_);
353 my $controller = $self->{CONTEXT}->stash->get('SELF');
354 my $models = $params{models} || $self->{CONTEXT}->stash->get('MODELS');
355 my $sort_spec = $models->get_sort_spec;
356 my $by_spec = $sort_spec->{$by};
357 my %current_sort_params = $models->get_current_sort_params;
358 my ($image, $new_dir) = ('', $current_sort_params{dir});
359 my $title = delete($params{title}) || $::locale->text($by_spec->{title});
361 if ($current_sort_params{sort_by} eq $by) {
362 my $current_dir = $current_sort_params{sort_dir} ? 'up' : 'down';
363 $image = '<img border="0" src="image/' . $current_dir . '.png">';
364 $new_dir = 1 - ($current_sort_params{sort_dir} || 0);
367 $params{ $models->sorted->form_params->[0] } = $by;
368 $params{ $models->sorted->form_params->[1] } = ($new_dir ? '1' : '0');
370 return '<a href="' . $models->get_callback(%params) . '">' . _H($title) . $image . '</a>';
373 sub paginate_controls {
374 my ($self, %params) = _hashify(1, @_);
376 my $controller = $self->{CONTEXT}->stash->get('SELF');
377 my $models = $params{models} || $self->{CONTEXT}->stash->get('MODELS');
378 my $pager = $models->paginated;
379 # my $paginate_spec = $controller->get_paginate_spec;
381 my %paginate_params = $models->get_paginate_args;
383 my %template_params = (
384 pages => \%paginate_params,
386 my %url_params = _hashify(0, @_);
387 $url_params{ $pager->form_params->[0] } = delete $url_params{page};
388 $url_params{ $pager->form_params->[1] } = delete $url_params{per_page} if exists $url_params{per_page};
390 return $models->get_callback(%url_params);
395 return SL::Presenter->get->render('common/paginate', %template_params);
404 SL::Templates::Plugin::L -- Layouting / tag generation
408 Usage from a template:
412 [% L.select_tag('direction', [ [ 'left', 'To the left' ], [ 'right', 'To the right', 1 ] ]) %]
414 [% L.select_tag('direction', [ { direction => 'left', display => 'To the left' },
415 { direction => 'right', display => 'To the right' } ],
416 value_key => 'direction', title_key => 'display', default => 'right')) %]
418 [% L.select_tag('direction', [ { direction => 'left', display => 'To the left' },
419 { direction => 'right', display => 'To the right', selected => 1 } ],
420 value_key => 'direction', title_key => 'display')) %]
424 A module modeled a bit after Rails' ActionView helpers. Several small
425 functions that create HTML tags from various kinds of data sources.
427 The C<id> attribute is usually calculated automatically. This can be
428 overridden by either specifying an C<id> attribute or by setting
433 =head2 LOW-LEVEL FUNCTIONS
435 The following items are just forwarded to L<SL::Presenter::Tag>:
439 =item * C<name_to_id $name>
441 =item * C<stringify_attributes %items>
443 =item * C<html_tag $tag_name, $content_string, %attributes>
447 =head2 HIGH-LEVEL FUNCTIONS
449 The following functions are just forwarded to L<SL::Presenter::Tag>:
453 =item * C<input_tag $name, $value, %attributes>
455 =item * C<hidden_tag $name, $value, %attributes>
457 =item * C<checkbox_tag $name, %attributes>
459 =item * C<select_tag $name, \@collection, %attributes>
461 =item * C<link $href, $content, %attributes>
465 Available high-level functions implemented in this module:
469 =item C<yes_no_tag $name, $value, %attributes>
471 Creates a HTML 'select' tag with the two entries C<yes> and C<no> by
472 calling L<select_tag>. C<$value> determines
473 which entry is selected. The C<%attributes> are passed through to
476 =item C<textarea_tag $name, $value, %attributes>
478 Creates a HTML 'textarea' tag named C<$name> with the content
479 C<$value> and with arbitrary HTML attributes from C<%attributes>. The
480 tag's C<id> defaults to C<name_to_id($name)>.
482 =item C<date_tag $name, $value, %attributes>
484 Creates a date input field, with an attached javascript that will open a
487 =item C<radio_button_tag $name, %attributes>
489 Creates a HTML 'input type=radio' tag named C<$name> with arbitrary
490 HTML attributes from C<%attributes>. The tag's C<value> defaults to
491 C<1>. The tag's C<id> defaults to C<name_to_id($name . "_" . $value)>.
493 If C<%attributes> contains a key C<label> then a HTML 'label' tag is
494 created with said C<label>. No attribute named C<label> is created in
497 =item C<javascript_tag $file1, $file2, $file3...>
499 Creates a HTML 'E<lt>script type="text/javascript" src="..."E<gt>'
500 tag for each file name parameter passed. Each file name will be
501 postfixed with '.js' if it isn't already and prefixed with 'js/' if it
502 doesn't contain a slash.
504 =item C<stylesheet_tag $file1, $file2, $file3...>
506 Creates a HTML 'E<lt>link rel="text/stylesheet" href="..."E<gt>' tag
507 for each file name parameter passed. Each file name will be postfixed
508 with '.css' if it isn't already and prefixed with 'css/' if it doesn't
511 =item C<tabbed \@tab, %attributes>
513 Will create a tabbed area. The tabs should be created with the helper function
517 L.tab(LxERP.t8('Basic Data'), 'part/_main_tab.html'),
518 L.tab(LxERP.t8('Custom Variables'), 'part/_cvar_tab.html', if => SELF.display_cvar_tab),
521 =item C<areainput_tag $name, $content, %PARAMS>
523 Creates a generic input tag or textarea tag, depending on content size. The
524 amount of desired rows must be either given with the C<rows> parameter or can
525 be computed from the value and the C<cols> paramter, Accepted parameters
526 include C<min_rows> for rendering a minimum of rows if a textarea is displayed.
528 You can force input by setting rows to 1, and you can force textarea by setting
531 =item C<multiselect2side $id, %params>
533 Creates a JavaScript snippet calling the jQuery function
534 C<multiselect2side> on the select control with the ID C<$id>. The
535 select itself is not created. C<%params> can contain the following
542 The label of the list of available options. Defaults to the
543 translation of 'Available'.
547 The label of the list of selected options. Defaults to the
548 translation of 'Selected'.
552 =item C<sortable_element $selector, %params>
554 Makes the children of the DOM element C<$selector> (a jQuery selector)
555 sortable with the I<jQuery UI Selectable> library. The children can be
556 dragged & dropped around. After dropping an element an URL can be
557 postet to with the element IDs of the sorted children.
559 If this is used then the JavaScript file C<js/jquery-ui.js> must be
560 included manually as well as it isn't loaded via C<$::form-gt;header>.
562 C<%params> can contain the following entries:
568 The URL to POST an AJAX request to after a dragged element has been
569 dropped. The AJAX request's return value is ignored by default. If given then
570 C<$params{with}> must be given as well.
574 If trueish then the AJAX request's return is accepted.
578 A string that is interpreted as the prefix of the children's ID. Upon
579 POSTing the result each child whose ID starts with C<$params{with}> is
580 considered. The prefix and the following "_" is removed from the
581 ID. The remaining parts of the IDs of those children are posted as a
582 single array parameter. The array parameter's name is either
583 C<$params{as}> or, missing that, C<$params{with}>.
587 Sets the POST parameter name for AJAX request after dropping an
588 element (see C<$params{with}>).
592 An optional jQuery selector specifying which part of the child element
593 is dragable. If the parameter is not given then it defaults to
594 C<.dragdrop> matching DOM elements with the class C<dragdrop>. If the
595 parameter is set and empty then the whole child element is dragable,
596 and clicks through to underlying elements like inputs or links might
599 =item C<dont_recolor>
601 If trueish then the children will not be recolored. The default is to
602 recolor the children by setting the class C<listrow0> on odd and
603 C<listrow1> on even entries.
607 An optional JavaScript string that is evaluated before sending the
608 POST request. The result must be a string that is appended to the URL.
614 <script type="text/javascript" src="js/jquery-ui.js"></script>
616 <table id="thing_list">
618 <tr><td>This</td><td>That</td></tr>
621 <tr id="thingy_2"><td>stuff</td><td>more stuff</td></tr>
622 <tr id="thingy_15"><td>stuff</td><td>more stuff</td></tr>
623 <tr id="thingy_6"><td>stuff</td><td>more stuff</td></tr>
627 [% L.sortable_element('#thing_list tbody',
628 url => 'controller.pl?action=SystemThings/reorder',
631 recolor_rows => 1) %]
633 After dropping e.g. the third element at the top of the list a POST
634 request would be made to the C<reorder> action of the C<SystemThings>
635 controller with a single parameter called C<thing_ids> -- an array
636 containing the values C<[ 6, 2, 15 ]>.
640 Dumps the Argument using L<Data::Dumper> into a E<lt>preE<gt> block.
642 =item C<sortable_table_header $by, %params>
644 Create a link and image suitable for placement in a table
645 header. C<$by> must be an index set up by the controller with
646 L<SL::Controller::Helper::make_sorted>.
648 The optional parameter C<$params{title}> can override the column title
649 displayed to the user. Otherwise the column title from the
650 controller's sort spec is used.
652 The other parameters in C<%params> are passed unmodified to the
653 underlying call to L<SL::Controller::Base::url_for>.
655 See the documentation of L<SL::Controller::Helper::Sorted> for an
656 overview and further usage instructions.
658 =item C<paginate_controls>
660 Create a set of links used to paginate a list view.
662 See the documentation of L<SL::Controller::Helper::Paginated> for an
663 overview and further usage instructions.
667 =head2 CONVERSION FUNCTIONS
671 =item C<tab, description, target, %PARAMS>
673 Creates a tab for C<tabbed>. The description will be used as displayed name.
674 The target should be a block or template that can be processed. C<tab> supports
675 a C<method> parameter, which can override the process method to apply target.
676 C<method => 'raw'> will just include the given text as is. I was too lazy to
677 implement C<include> properly.
679 Also an C<if> attribute is supported, so that tabs can be suppressed based on
680 some occasion. In this case the supplied block won't even get processed, and
681 the resulting tab will get ignored by C<tabbed>:
683 L.tab('Awesome tab wih much info', '_much_info.html', if => SELF.wants_all)
685 =item C<truncate $text, [%params]>
687 See L<SL::Presenter::Text/truncate>.
689 =item C<simple_format $text>
691 See L<SL::Presenter::Text/simple_format>.
695 =head1 MODULE AUTHORS
697 Moritz Bunkus E<lt>m.bunkus@linet-services.deE<gt>
699 L<http://linet-services.de>