1 package SL::Template::Plugin::L;
3 use base qw( Template::Plugin );
5 use List::MoreUtils qw(apply);
6 use List::Util qw(max);
7 use Scalar::Util qw(blessed);
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;
18 return "id_" . ( $_id_sequence = ($_id_sequence + 1) % 1e7 );
24 return $::locale->quote_special_chars('HTML', $string);
29 $string =~ s/(\"|\'|\\)/\\$1/g;
34 return (@_ && (ref($_[0]) eq 'HASH')) ? %{ $_[0] } : @_;
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 if (!$presenter->can($method)) {
56 $::lxdebug->message(LXDebug::WARN(), "SL::Presenter has no method named '$method'!");
60 splice @args, -1, 1, %{ $args[-1] } if @args && (ref($args[-1]) eq 'HASH');
62 $presenter->$method(@args);
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', @_); }
72 sub _set_id_attribute {
73 my ($attributes, $name) = @_;
74 SL::Presenter::Tag::_set_id_attribute($attributes, $name);
78 my ($self, @slurp) = @_;
79 my %options = _hashify(@slurp);
83 return $self->html_tag('img', undef, %options);
87 my ($self, $name, $content, @slurp) = @_;
88 my %attributes = _hashify(@slurp);
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) : '';
95 return $self->html_tag('textarea', $content, %attributes, name => $name);
99 my ($self, $name, @slurp) = @_;
100 my %attributes = _hashify(@slurp);
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};
107 if ($attributes{checked}) {
108 $attributes{checked} = 'checked';
110 delete $attributes{checked};
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;
120 sub radio_button_tag {
123 my %attributes = _hashify(@_);
125 _set_id_attribute(\%attributes, $name);
126 $attributes{value} = 1 unless defined $attributes{value};
127 my $label = delete $attributes{label};
129 if ($attributes{checked}) {
130 $attributes{checked} = 'checked';
132 delete $attributes{checked};
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;
142 my ($self, $name, $value, @slurp) = @_;
143 return $self->input_tag($name, $value, _hashify(@slurp), type => 'hidden');
147 my ($self, $content, @slurp) = @_;
148 return $self->html_tag('div', $content, @slurp);
152 my ($self, $content, @slurp) = @_;
153 return $self->html_tag('ul', $content, @slurp);
157 my ($self, $content, @slurp) = @_;
158 return $self->html_tag('li', $content, @slurp);
162 my ($self, $href, $content, @slurp) = @_;
163 my %params = _hashify(@slurp);
167 return $self->html_tag('a', $content, %params, href => $href);
171 my ($self, $name, $value, @slurp) = @_;
172 my %attributes = _hashify(@slurp);
174 if ( $attributes{confirm} ) {
175 $attributes{onclick} = 'return confirm("'. _J(delete($attributes{confirm})) .'");';
178 return $self->input_tag($name, $value, %attributes, type => 'submit', class => 'submit');
182 my ($self, $onclick, $value, @slurp) = @_;
183 my %attributes = _hashify(@slurp);
185 _set_id_attribute(\%attributes, $attributes{name}) if $attributes{name};
186 $attributes{type} ||= 'button';
188 $onclick = 'if (!confirm("'. _J(delete($attributes{confirm})) .'")) return false; ' . $onclick if $attributes{confirm};
190 return $self->html_tag('input', undef, %attributes, value => $value, onclick => $onclick);
193 sub ajax_submit_tag {
194 my ($self, $url, $form_selector, $text, @slurp) = @_;
197 $form_selector = _J($form_selector);
198 my $onclick = qq|submit_ajax_form('${url}', '${form_selector}')|;
200 return $self->button_tag($onclick, $text, @slurp);
204 my ($self, $name, $value) = splice @_, 0, 3;
205 my %attributes = _hashify(@_);
207 return $self->select_tag($name, [ [ 1 => $::locale->text('Yes') ], [ 0 => $::locale->text('No') ] ], default => $value ? 1 : 0, %attributes);
211 my ($self, $data) = @_;
212 return $self->html_tag('script', $data, type => 'text/javascript');
219 foreach my $file (@_) {
220 $file .= '.css' unless $file =~ m/\.css$/;
221 $file = "css/${file}" unless $file =~ m|/|;
223 $code .= qq|<link rel="stylesheet" href="${file}" type="text/css" media="screen" />|;
229 my $date_tag_id_idx = 0;
231 my ($self, $name, $value, @slurp) = @_;
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');
238 return $self->input_tag(
239 $name, blessed($value) ? $value->to_lxoffice : $value,
241 onblur => "check_right_date_format(this);",
247 sub customer_picker {
248 my ($self, $name, $value, %params) = @_;
249 my $name_e = _H($name);
251 $::request->{layout}->add_javascripts('autocomplete_customer.js');
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);
257 # simple version with select_tag
258 sub vendor_selector {
259 my ($self, $name, $value, %params) = @_;
261 my $actual_vendor_id = (defined $::form->{"$name"})? ((ref $::form->{"$name"}) ? $::form->{"$name"}->id : $::form->{"$name"}) :
262 (ref $value && $value->can('id')) ? $value->id : '';
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 },
272 # simple version with select_tag
274 my ($self, $name, $value, %params) = @_;
276 my $actual_part_id = (defined $::form->{"$name"})? ((ref $::form->{"$name"})? $::form->{"$name"}->id : $::form->{"$name"}) :
277 (ref $value && $value->can('id')) ? $value->id : '';
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 },
291 foreach my $file (@_) {
292 $file .= '.js' unless $file =~ m/\.js$/;
293 $file = "js/${file}" unless $file =~ m|/|;
295 $code .= qq|<script type="text/javascript" src="${file}"></script>|;
302 my ($self, $tabs, @slurp) = @_;
303 my %params = _hashify(@slurp);
304 my $id = $params{id} || 'tab_' . _tag_id();
306 $params{selected} *= 1;
308 die 'L.tabbed needs an arrayred of tabs for first argument'
309 unless ref $tabs eq 'ARRAY';
311 my (@header, @blocks);
312 for my $i (0..$#$tabs) {
313 my $tab = $tabs->[$i];
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);
322 return '' unless @header;
324 my $ul = $self->ul_tag(join('', @header), id => $id);
325 return $self->div_tag(join('', $ul, @blocks), class => 'tabwidget');
329 my ($self, $name, $src, @slurp) = @_;
330 my %params = _hashify(@slurp);
332 $params{method} ||= 'process';
334 return () if defined $params{if} && !$params{if};
337 if ($params{method} eq 'raw') {
339 } elsif ($params{method} eq 'process') {
340 $data = $self->_context->process($src, %{ $params{args} || {} });
342 die "unknown tag method '$params{method}'";
345 return () unless $data;
347 return +{ name => $name, data => $data };
351 my ($self, $name, $value, @slurp) = @_;
352 my %attributes = _hashify(@slurp);
355 my $min = delete $attributes{min_rows} || 1;
357 if (exists $attributes{cols}) {
358 $cols = delete $attributes{cols};
359 $rows = $::form->numtextrows($value, $cols);
361 $rows = delete $attributes{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) : ()));
369 sub multiselect2side {
370 my ($self, $id, @slurp) = @_;
371 my %params = _hashify(@slurp);
373 $params{labelsx} = "\"" . _J($params{labelsx} || $::locale->text('Available')) . "\"";
374 $params{labeldx} = "\"" . _J($params{labeldx} || $::locale->text('Selected')) . "\"";
375 $params{moveOptions} = 'false';
377 my $vars = join(', ', map { "${_}: " . $params{$_} } keys %params);
379 <script type="text/javascript">
380 \$().ready(function() {
381 \$('#${id}').multiselect2side({ ${vars} });
389 sub sortable_element {
390 my ($self, $selector, @slurp) = @_;
391 my %params = _hashify(@slurp);
393 my %attributes = ( distance => 5,
394 helper => <<'JAVASCRIPT' );
395 function(event, ui) {
396 ui.children().each(function() {
397 $(this).width($(this).width());
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}_', ''); })";
410 $stop_event = <<JAVASCRIPT;
411 \$.post('$params{url}', { '${as}[]': \$(\$('${selector}').sortable('toArray'))${filter}.toArray() });
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');
423 $attributes{stop} = <<JAVASCRIPT;
424 function(event, ui) {
431 $params{handle} = '.dragdrop' unless exists $params{handle};
432 $attributes{handle} = "'$params{handle}'" if $params{handle};
434 my $attr_str = join(', ', map { "${_}: $attributes{$_}" } keys %attributes);
436 my $code = <<JAVASCRIPT;
437 <script type="text/javascript">
439 \$( "${selector}" ).sortable({ ${attr_str} })
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');
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')
461 require Data::Dumper;
462 return '<pre>' . Data::Dumper::Dumper(@_) . '</pre>';
465 sub sortable_table_header {
466 my ($self, $by, @slurp) = @_;
467 my %params = _hashify(@slurp);
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});
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);
482 $params{ $sort_spec->{FORM_PARAMS}->[0] } = $by;
483 $params{ $sort_spec->{FORM_PARAMS}->[1] } = ($new_dir ? '1' : '0');
485 return '<a href="' . $controller->get_callback(%params) . '">' . _H($title) . $image . '</a>';
488 sub paginate_controls {
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;
495 my %template_params = (
496 pages => \%paginate_params,
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};
502 return $controller->get_callback(%url_params);
506 return SL::Presenter->get->render('common/paginate', %template_params);
515 SL::Templates::Plugin::L -- Layouting / tag generation
519 Usage from a template:
523 [% L.select_tag('direction', [ [ 'left', 'To the left' ], [ 'right', 'To the right', 1 ] ]) %]
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')) %]
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')) %]
535 A module modeled a bit after Rails' ActionView helpers. Several small
536 functions that create HTML tags from various kinds of data sources.
538 The C<id> attribute is usually calculated automatically. This can be
539 overridden by either specifying an C<id> attribute or by setting
544 =head2 LOW-LEVEL FUNCTIONS
546 The following items are just forwarded to L<SL::Presenter::Tag>:
550 =item * C<name_to_id $name>
552 =item * C<stringify_attributes %items>
554 =item * C<html_tag $tag_name, $content_string, %attributes>
558 =head2 HIGH-LEVEL FUNCTIONS
560 The following functions are just forwarded to L<SL::Presenter::Tag>:
564 =item * C<input_tag $name, $value, %attributes>
566 =item * C<select_tag $name, \@collection, %attributes>
570 Available high-level functions implemented in this module:
574 =item C<yes_no_tag $name, $value, %attributes>
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
581 =item C<hidden_tag $name, $value, %attributes>
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)>.
587 =item C<submit_tag $name, $value, %attributes>
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)>.
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.
598 =item C<ajax_submit_tag $url, $form_selector, $text, %attributes>
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>.
606 =item C<button_tag $onclick, $text, %attributes>
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.
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.
617 =item C<textarea_tag $name, $value, %attributes>
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)>.
623 =item C<checkbox_tag $name, %attributes>
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>.
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
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.
637 =item C<date_tag $name, $value, %attributes>
639 Creates a date input field, with an attached javascript that will open a
642 =item C<radio_button_tag $name, %attributes>
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)>.
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
652 =item C<javascript_tag $file1, $file2, $file3...>
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.
659 =item C<stylesheet_tag $file1, $file2, $file3...>
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
666 =item C<tabbed \@tab, %attributes>
668 Will create a tabbed area. The tabs should be created with the helper function
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),
676 =item C<areainput_tag $name, $content, %PARAMS>
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.
683 You can force input by setting rows to 1, and you can force textarea by setting
686 =item C<multiselect2side $id, %params>
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
697 The label of the list of available options. Defaults to the
698 translation of 'Available'.
702 The label of the list of selected options. Defaults to the
703 translation of 'Selected'.
707 =item C<sortable_element $selector, %params>
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.
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>.
717 C<%params> can contain the following entries:
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.
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}>.
738 Sets the POST parameter name for AJAX request after dropping an
739 element (see C<$params{with}>).
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
750 =item C<dont_recolor>
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.
760 <script type="text/javascript" src="js/jquery-ui.js"></script>
762 <table id="thing_list">
764 <tr><td>This</td><td>That</td></tr>
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>
773 [% L.sortable_element('#thing_list tbody',
774 url => 'controller.pl?action=SystemThings/reorder',
777 recolor_rows => 1) %]
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 ]>.
786 Dumps the Argument using L<Data::Dumper> into a E<lt>preE<gt> block.
788 =item C<sortable_table_header $by, %params>
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>.
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.
798 The other parameters in C<%params> are passed unmodified to the
799 underlying call to L<SL::Controller::Base::url_for>.
801 See the documentation of L<SL::Controller::Helper::Sorted> for an
802 overview and further usage instructions.
804 =item C<paginate_controls>
806 Create a set of links used to paginate a list view.
808 See the documentation of L<SL::Controller::Helper::Paginated> for an
809 overview and further usage instructions.
813 =head2 CONVERSION FUNCTIONS
817 =item C<tab, description, target, %PARAMS>
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.
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>:
829 L.tab('Awesome tab wih much info', '_much_info.html', if => SELF.wants_all)
831 =item C<truncate $text, [%params]>
833 See L<SL::Presenter::Text/truncate>.
835 =item C<simple_format $text>
837 See L<SL::Presenter::Text/simple_format>.
841 =head1 MODULE AUTHORS
843 Moritz Bunkus E<lt>m.bunkus@linet-services.deE<gt>
845 L<http://linet-services.de>