jQuery-Script/Methode zum Anstoßen von Downloads
[kivitendo-erp.git] / SL / Template / LaTeX.pm
1 package SL::Template::LaTeX;
2
3 use parent qw(SL::Template::Simple);
4
5 use strict;
6
7 use Cwd;
8 use Unicode::Normalize qw();
9
10 sub new {
11   my $type = shift;
12
13   my $self = $type->SUPER::new(@_);
14
15   return $self;
16 }
17
18 sub format_string {
19   my ($self, $variable) = @_;
20   my $form = $self->{"form"};
21
22   $variable = $main::locale->quote_special_chars('Template/LaTeX', $variable);
23
24   # Allow some HTML markup to be converted into the output format's
25   # corresponding markup code, e.g. bold or italic.
26   my %markup_replace = ('b' => 'textbf',
27                         'i' => 'textit',
28                         'u' => 'underline');
29
30   foreach my $key (keys(%markup_replace)) {
31     my $new = $markup_replace{$key};
32     $variable =~ s/\$\<\$${key}\$\>\$(.*?)\$<\$\/${key}\$>\$/\\${new}\{$1\}/gi;
33   }
34
35   $variable =~ s/[\x00-\x1f]//g;
36
37   return $variable;
38 }
39
40 sub parse_foreach {
41   my ($self, $var, $text, $start_tag, $end_tag, @indices) = @_;
42
43   my ($form, $new_contents) = ($self->{"form"}, "");
44
45   my $ary = $self->_get_loop_variable($var, 1, @indices);
46
47   my $sum                          = 0;
48   my $current_page                 = 1;
49   my ($current_line, $corrent_row) = (0, 1);
50   my $description_array            = $self->_get_loop_variable("description",     1);
51   my $longdescription_array        = $self->_get_loop_variable("longdescription", 1);
52   my $linetotal_array              = $self->_get_loop_variable("linetotal",       1);
53
54   $form->{TEMPLATE_ARRAYS}->{cumulatelinetotal} = [];
55
56   # forech block hasn't given us an array. ignore
57   return $new_contents unless ref $ary eq 'ARRAY';
58
59   for (my $i = 0; $i < scalar(@{$ary}); $i++) {
60     # do magic markers
61     $form->{"__first__"}   = $i == 0;
62     $form->{"__last__"}    = ($i + 1) == scalar(@{$ary});
63     $form->{"__odd__"}     = (($i + 1) % 2) == 1;
64     $form->{"__counter__"} = $i + 1;
65
66   #everything from here to the next marker should be removed after the release of 2.7.0
67     if (   ref $description_array       eq 'ARRAY'
68         && scalar @{$description_array} == scalar @{$ary}
69         && $self->{"chars_per_line"}    != 0)
70     {
71       my $lines = int(length($description_array->[$i]) / $self->{"chars_per_line"});
72       my $lpp;
73
74       $description_array->[$i] =~ s/(\\newline\s?)*$//;
75       $lines++ while ($description_array->[$i] =~ m/\\newline/g);
76       $lines++;
77
78       if ($current_page == 1) {
79         $lpp = $self->{"lines_on_first_page"};
80       } else {
81         $lpp = $self->{"lines_on_second_page"};
82       }
83
84       # Yes we need a manual page break -- or the user has forced one
85       if (   (($current_line + $lines) > $lpp)
86           || ($description_array->[$i]     =~ /<pagebreak>/)
87           || (   ref $longdescription_array eq 'ARRAY'
88               && $longdescription_array->[$i] =~ /<pagebreak>/)) {
89         my $pb = $self->{"pagebreak_block"};
90
91         # replace the special variables <%sumcarriedforward%>
92         # and <%lastpage%>
93
94         my $psum = $form->format_amount($self->{"myconfig"}, $sum, 2);
95         $pb =~ s/$self->{tag_start_qm}sumcarriedforward$self->{tag_end_qm}/$psum/g;
96         $pb =~ s/$self->{tag_start_qm}lastpage$self->{tag_end_qm}/$current_page/g;
97
98         my $new_text = $self->parse_block($pb, (@indices, $i));
99         return undef unless (defined($new_text));
100         $new_contents .= $new_text;
101
102         $current_page++;
103         $current_line = 0;
104       }
105       $current_line += $lines;
106     }
107   #stop removing code here.
108
109     if (   ref $linetotal_array eq 'ARRAY'
110         && $i < scalar(@{$linetotal_array})) {
111       $sum += $form->parse_amount($self->{"myconfig"}, $linetotal_array->[$i]);
112     }
113
114     $form->{TEMPLATE_ARRAYS}->{cumulatelinetotal}->[$i] = $form->format_amount($self->{"myconfig"}, $sum, 2);
115
116     my $new_text = $self->parse_block($text, (@indices, $i));
117     return undef unless (defined($new_text));
118     $new_contents .= $start_tag . $new_text . $end_tag;
119   }
120   map({ delete($form->{"__${_}__"}); } qw(first last odd counter));
121
122   return $new_contents;
123 }
124
125 sub find_end {
126   my ($self, $text, $pos, $var, $not) = @_;
127
128   my $tag_start_len = length $self->{tag_start};
129
130   my $depth = 1;
131   $pos = 0 unless ($pos);
132
133   while ($pos < length($text)) {
134     $pos++;
135
136     next if (substr($text, $pos - 1, length($self->{tag_start})) ne $self->{tag_start});
137
138     my $keyword_pos = $pos - 1 + $tag_start_len;
139
140     if ((substr($text, $keyword_pos, 2) eq 'if') || (substr($text, $keyword_pos, 7) eq 'foreach')) {
141       $depth++;
142
143     } elsif ((substr($text, $keyword_pos, 4) eq 'else') && (1 == $depth)) {
144       if (!$var) {
145         $self->{"error"} =
146             "$self->{tag_start}else$self->{tag_end} outside of "
147           . "$self->{tag_start}if$self->{tag_end} / "
148           . "$self->{tag_start}ifnot$self->{tag_end}.";
149         return undef;
150       }
151
152       my $block = substr($text, 0, $pos - 1);
153       substr($text, 0, $pos - 1) = "";
154       $text =~ s!^$self->{tag_start_qm}.+?$self->{tag_end_qm}!!;
155       $text =  $self->{tag_start} . 'if' . ($not ?  " " : "not ") . $var . $self->{tag_end} . $text;
156
157       return ($block, $text);
158
159     } elsif (substr($text, $keyword_pos, 3) eq 'end') {
160       $depth--;
161       if ($depth == 0) {
162         my $block = substr($text, 0, $pos - 1);
163         substr($text, 0, $pos - 1) = "";
164         $text =~ s!^$self->{tag_start_qm}.+?$self->{tag_end_qm}!!;
165
166         return ($block, $text);
167       }
168     }
169   }
170
171   return undef;
172 }
173
174 sub parse_block {
175   $main::lxdebug->enter_sub();
176
177   my ($self, $contents, @indices) = @_;
178
179   my $new_contents = "";
180
181   while ($contents ne "") {
182     my $pos_if      = index($contents, $self->{tag_start} . 'if');
183     my $pos_foreach = index($contents, $self->{tag_start} . 'foreach');
184
185     if ((-1 == $pos_if) && (-1 == $pos_foreach)) {
186       $new_contents .= $self->substitute_vars($contents, @indices);
187       last;
188     }
189
190     if ((-1 == $pos_if) || ((-1 != $pos_foreach) && ($pos_if > $pos_foreach))) {
191       $new_contents .= $self->substitute_vars(substr($contents, 0, $pos_foreach), @indices);
192       substr($contents, 0, $pos_foreach) = "";
193
194       if ($contents !~ m|^$self->{tag_start_qm}foreach (.+?)$self->{tag_end_qm}|) {
195         $self->{"error"} = "Malformed $self->{tag_start}foreach$self->{tag_end}.";
196         $main::lxdebug->leave_sub();
197         return undef;
198       }
199
200       my $var = $1;
201
202       substr($contents, 0, length($&)) = "";
203
204       my $block;
205       ($block, $contents) = $self->find_end($contents);
206       if (!$block) {
207         $self->{"error"} = "Unclosed $self->{tag_start}foreach$self->{tag_end}." unless ($self->{"error"});
208         $main::lxdebug->leave_sub();
209         return undef;
210       }
211
212       my $new_text = $self->parse_foreach($var, $block, "", "", @indices);
213       if (!defined($new_text)) {
214         $main::lxdebug->leave_sub();
215         return undef;
216       }
217       $new_contents .= $new_text;
218
219     } else {
220       if (!$self->_parse_block_if(\$contents, \$new_contents, $pos_if, @indices)) {
221         $main::lxdebug->leave_sub();
222         return undef;
223       }
224     }
225   }
226
227   $main::lxdebug->leave_sub();
228
229   return $new_contents;
230 }
231
232 sub parse_first_line {
233   my $self = shift;
234   my $line = shift || "";
235
236   if ($line =~ m/([^\s]+)set-tag-style([^\s]+)/) {
237     if ($1 eq $2) {
238       $self->{error} = "The tag start and end markers must not be equal.";
239       return 0;
240     }
241
242     $self->set_tag_style($1, $2);
243   }
244
245   return 1;
246 }
247
248 sub _parse_config_option {
249   my $self = shift;
250   my $line = shift;
251
252   $line =~ s/^\s*//;
253   $line =~ s/\s*$//;
254
255   my ($key, $value) = split m/\s*=\s*/, $line, 2;
256
257   if ($key eq 'tag-style') {
258     $self->set_tag_style(split(m/\s+/, $value, 2));
259   }
260 }
261
262 sub _parse_config_lines {
263   my $self  = shift;
264   my $lines = shift;
265
266   my ($comment_start, $comment_end) = ("", "");
267
268   if (ref $self eq 'SL::Template::LaTeX') {
269     $comment_start = '\s*%';
270   } elsif (ref $self eq 'SL::Template::HTML') {
271     $comment_start = '\s*<!--';
272     $comment_end   = '(?:--)?>\s*';
273   } else {
274     $comment_start = '\s*\#';
275   }
276
277   my $num_lines = scalar @{ $lines };
278   my $i         = 0;
279
280   while ($i < $num_lines) {
281     my $line = $lines->[$i];
282
283     if ($line !~ m/^${comment_start}\s*config\s*:(.*?)${comment_end}$/i) {
284       $i++;
285       next;
286     }
287
288     $self->_parse_config_option($1);
289     splice @{ $lines }, $i, 1;
290     $num_lines--;
291   }
292 }
293
294 sub _force_mandatory_packages {
295   my $self  = shift;
296   my $lines = shift;
297
298   my (%used_packages, $document_start_line, $last_usepackage_line);
299
300   foreach my $i (0 .. scalar @{ $lines } - 1) {
301     if ($lines->[$i] =~ m/\\usepackage[^\{]*{(.*?)}/) {
302       $used_packages{$1} = 1;
303       $last_usepackage_line = $i;
304
305     } elsif ($lines->[$i] =~ m/\\begin{document}/) {
306       $document_start_line = $i;
307       last;
308
309     }
310   }
311
312   my $insertion_point = defined($document_start_line)  ? $document_start_line
313                       : defined($last_usepackage_line) ? $last_usepackage_line
314                       :                                  scalar @{ $lines } - 1;
315
316   foreach my $package (qw(textcomp)) {
317     next if $used_packages{$package};
318     splice @{ $lines }, $insertion_point, 0, "\\usepackage{${package}}\n";
319     $insertion_point++;
320   }
321 }
322
323 sub parse {
324   my $self = $_[0];
325   local *OUT = $_[1];
326   my $form = $self->{"form"};
327
328   if (!open(IN, "$form->{templates}/$form->{IN}")) {
329     $self->{"error"} = "$!";
330     return 0;
331   }
332   binmode IN, ":utf8" if $::locale->is_utf8;
333   my @lines = <IN>;
334   close(IN);
335
336   $self->_parse_config_lines(\@lines);
337   $self->_force_mandatory_packages(\@lines) if (ref $self eq 'SL::Template::LaTeX');
338
339   my $contents = join("", @lines);
340
341   # detect pagebreak block and its parameters
342   if ($contents =~ /$self->{tag_start_qm}pagebreak\s+(\d+)\s+(\d+)\s+(\d+)\s*$self->{tag_end_qm}(.*?)$self->{tag_start_qm}end(\s*pagebreak)?$self->{tag_end_qm}/s) {
343     $self->{"chars_per_line"} = $1;
344     $self->{"lines_on_first_page"} = $2;
345     $self->{"lines_on_second_page"} = $3;
346     $self->{"pagebreak_block"} = $4;
347
348     substr($contents, length($`), length($&)) = "";
349   }
350
351   $self->{"forced_pagebreaks"} = [];
352
353   my $new_contents = $self->parse_block($contents);
354   if (!defined($new_contents)) {
355     $main::lxdebug->leave_sub();
356     return 0;
357   }
358
359   if ($::locale->is_utf8) {
360     binmode OUT, ":utf8";
361     print OUT Unicode::Normalize::normalize('C', $new_contents);
362
363   } else {
364     print OUT $new_contents;
365   }
366
367   if ($form->{"format"} =~ /postscript/i) {
368     return $self->convert_to_postscript();
369   } elsif ($form->{"format"} =~ /pdf/i) {
370     return $self->convert_to_pdf();
371   } else {
372     return 1;
373   }
374 }
375
376 sub convert_to_postscript {
377   my ($self) = @_;
378   my ($form, $userspath) = ($self->{"form"}, $self->{"userspath"});
379
380   # Convert the tex file to postscript
381
382   if (!chdir("$userspath")) {
383     $self->{"error"} = "chdir : $!";
384     $self->cleanup();
385     return 0;
386   }
387
388   $form->{tmpfile} =~ s/\Q$userspath\E\///g;
389
390   my $latex = $self->_get_latex_path();
391   my $old_home = $ENV{HOME};
392   my $old_openin_any = $ENV{openin_any};
393   $ENV{HOME}   = $userspath =~ m|^/| ? $userspath : getcwd();
394   $ENV{openin_any} = "p";
395
396   for (my $run = 1; $run <= 2; $run++) {
397     system("${latex} --interaction=nonstopmode $form->{tmpfile} " .
398            "> $form->{tmpfile}.err");
399     if ($?) {
400       $ENV{HOME} = $old_home;
401       $ENV{openin_any} = $old_openin_any;
402       $self->{"error"} = $form->cleanup($latex);
403       return 0;
404     }
405   }
406
407   $form->{tmpfile} =~ s/tex$/dvi/;
408
409   system("dvips $form->{tmpfile} -o -q > /dev/null");
410   $ENV{HOME} = $old_home;
411   $ENV{openin_any} = $old_openin_any;
412
413   if ($?) {
414     $self->{"error"} = "dvips : $!";
415     $self->cleanup('dvips');
416     return 0;
417   }
418   $form->{tmpfile} =~ s/dvi$/ps/;
419
420   $self->cleanup();
421
422   return 1;
423 }
424
425 sub convert_to_pdf {
426   my ($self) = @_;
427   my ($form, $userspath) = ($self->{"form"}, $self->{"userspath"});
428
429   # Convert the tex file to PDF
430
431   if (!chdir("$userspath")) {
432     $self->{"error"} = "chdir : $!";
433     $self->cleanup();
434     return 0;
435   }
436
437   $form->{tmpfile} =~ s/\Q$userspath\E\///g;
438
439   my $latex = $self->_get_latex_path();
440   my $old_home = $ENV{HOME};
441   my $old_openin_any = $ENV{openin_any};
442   $ENV{HOME}   = $userspath =~ m|^/| ? $userspath : getcwd();
443   $ENV{openin_any} = "p";
444
445   for (my $run = 1; $run <= 2; $run++) {
446     system("${latex} --interaction=nonstopmode $form->{tmpfile} " .
447            "> $form->{tmpfile}.err");
448     if ($?) {
449       $ENV{HOME}     = $old_home;
450       $ENV{openin_any} = $old_openin_any;
451       $self->{error} = $form->cleanup($latex);
452       return 0;
453     }
454   }
455
456   $ENV{HOME} = $old_home;
457   $ENV{openin_any} = $old_openin_any;
458   $form->{tmpfile} =~ s/tex$/pdf/;
459
460   $self->cleanup();
461 }
462
463 sub _get_latex_path {
464   return $::lx_office_conf{applications}->{latex} || 'pdflatex';
465 }
466
467 sub get_mime_type() {
468   my ($self) = @_;
469
470   if ($self->{"form"}->{"format"} =~ /postscript/i) {
471     return "application/postscript";
472   } else {
473     return "application/pdf";
474   }
475 }
476
477 sub uses_temp_file {
478   return 1;
479 }
480
481 1;