SL/Template.pm

   1 #====================================================================
   2 # LX-Office ERP
   3 # Copyright (C) 2004
   4 # Based on SQL-Ledger Version 2.1.9
   5 # Web http://www.lx-office.org
   6 #
   7 #====================================================================
   8
   9 package SimpleTemplate;
  10
  11 # Parameters:
  12 #   1. The template's file name
  13 #   2. A reference to the Form object
  14 #   3. A reference to the myconfig hash
  15 #
  16 # Returns:
  17 #   A new template object
  18 sub new {
  19   my $type = shift;
  20   my $self = {};
  21
  22   bless($self, $type);
  23   $self->_init(@_);
  24
  25   return $self;
  26 }
  27
  28 sub _init {
  29   my $self = shift;
  30
  31   $self->{source}    = shift;
  32   $self->{form}      = shift;
  33   $self->{myconfig}  = shift;
  34   $self->{userspath} = shift;
  35
  36   $self->{error}     = undef;
  37   $self->{quot_re}   = '"';
  38
  39   $self->set_tag_style('<%', '%>');
  40 }
  41
  42 sub set_tag_style {
  43   my $self                    = shift;
  44   my $tag_start               = shift;
  45   my $tag_end                 = shift;
  46
  47   $self->{tag_start}          = $tag_start;
  48   $self->{tag_end}            = $tag_end;
  49   $self->{tag_start_qm}       = quotemeta $tag_start;
  50   $self->{tag_end_qm}         = quotemeta $tag_end;
  51
  52   $self->{substitute_vars_re} = "$self->{tag_start_qm}(.+?)$self->{tag_end_qm}";
  53 }
  54
  55 sub cleanup {
  56   my ($self) = @_;
  57 }
  58
  59 # Parameters:
  60 #   1. A typeglob for the file handle. The output will be written
  61 #      to this file handle.
  62 #
  63 # Returns:
  64 #   1 on success and undef or 0 if there was an error. In the latter case
  65 #   the calling function can retrieve the error message via $obj->get_error()
  66 sub parse {
  67   my $self = $_[0];
  68   local *OUT = $_[1];
  69
  70   print(OUT "Hallo!\n");
  71 }
  72
  73 sub get_error {
  74   my $self = shift;
  75
  76   return $self->{"error"};
  77 }
  78
  79 sub uses_temp_file {
  80   return 0;
  81 }
  82
  83 sub _get_loop_variable {
  84   my $self      = shift;
  85   my $var       = shift;
  86   my $get_array = shift;
  87   my @indices   = @_;
  88
  89   my $form      = $self->{form};
  90   my $value;
  91
  92   if (($get_array || @indices) && (ref $form->{TEMPLATE_ARRAYS} eq 'HASH') && (ref $form->{TEMPLATE_ARRAYS}->{$var} eq 'ARRAY')) {
  93     $value = $form->{TEMPLATE_ARRAYS}->{$var};
  94   } else {
  95     $value = $form->{$var};
  96   }
  97
  98   for (my $i = 0; $i < scalar(@indices); $i++) {
  99     last unless (ref($value) eq "ARRAY");
 100     $value = $value->[$indices[$i]];
 101   }
 102
 103   return $value;
 104 }
 105
 106 sub substitute_vars {
 107   my ($self, $text, @indices) = @_;
 108
 109   my $form = $self->{"form"};
 110
 111   while ($text =~ /$self->{substitute_vars_re}/) {
 112     my ($tag_pos, $tag_len) = ($-[0], $+[0] - $-[0]);
 113     my ($var, @options)     = split(/\s+/, $1);
 114
 115     my $value               = $self->_get_loop_variable($var, 0, @indices);
 116     $value                  = $self->format_string($value) unless (grep(/^NOESCAPE$/, @options));
 117
 118     substr($text, $tag_pos, $tag_len, $value);
 119   }
 120
 121   return $text;
 122 }
 123
 124 sub _parse_block_if {
 125   $main::lxdebug->enter_sub();
 126
 127   my $self         = shift;
 128   my $contents     = shift;
 129   my $new_contents = shift;
 130   my $pos_if       = shift;
 131   my @indices      = @_;
 132
 133   $$new_contents .= $self->substitute_vars(substr($$contents, 0, $pos_if), @indices);
 134   substr($$contents, 0, $pos_if) = "";
 135
 136   if ($$contents !~ m/^$self->{tag_start_qm}if
 137                      \s*
 138                      (not\b|\!)?           # $1 -- Eventuelle Negierung
 139                      \s+
 140                      (\b.+?\b)             # $2 -- Name der zu überprüfenden Variablen
 141                      (                     # $3 -- Beginn des optionalen Vergleiches
 142                        \s*
 143                        ([!=])              # $4 -- Negierung des Vergleiches speichern
 144                        ([=~])              # $5 -- Art des Vergleiches speichern
 145                        \s*
 146                        (                   # $6 -- Gequoteter String oder Bareword
 147                          $self->{quot_re}
 148                          (.*?)(?<!\\)      # $7 -- Gequoteter String -- direkter Vergleich mit eq bzw. ne oder Patternmatching; Escapete Anführungs als Teil des Strings belassen
 149                          $self->{quot_re}
 150                        |
 151                          (\b.+?\b)         # $8 -- Bareword -- als Index für $form benutzen
 152                        )
 153                      )?
 154                      \s*
 155                      $self->{tag_end_qm}
 156                     /x) {
 157     $self->{"error"} = "Malformed $self->{tag_start}if$self->{tag_end}.";
 158     $main::lxdebug->leave_sub();
 159     return undef;
 160   }
 161
 162   my $not           = $1;
 163   my $var           = $2;
 164   my $operator_neg  = $4; # '=' oder '!' oder undef, wenn kein Vergleich erkannt
 165   my $operator_type = $5; # '=' oder '~' für Stringvergleich oder Regex
 166   my $quoted_word   = $7; # nur gültig, wenn quoted string angegeben (siehe unten); dann "value" aus <%if var == "value" %>
 167   my $bareword      = $8; # undef, falls quoted string angegeben wurde; andernfalls "othervar" aus <%if var == othervar %>
 168
 169   $not = !$not if ($operator_neg && $operator_neg eq '!');
 170
 171   substr($$contents, 0, length($&)) = "";
 172
 173   my $block;
 174   ($block, $$contents) = $self->find_end($$contents, 0, $var, $not);
 175   if (!$block) {
 176     $self->{"error"} = "Unclosed $self->{tag_start}if$self->{tag_end}." unless ($self->{"error"});
 177     $main::lxdebug->leave_sub();
 178     return undef;
 179   }
 180
 181   my $value = $self->_get_loop_variable($var, 0, @indices);
 182   my $hit   = 0;
 183
 184   if ($operator_type) {
 185     my $compare_to = $bareword ? $self->_get_loop_variable($bareword, 0, @indices) : $quoted_word;
 186     if ($operator_type eq '=') {
 187       $hit         = ($not && !($value eq $compare_to))     || (!$not && ($value eq $compare_to));
 188     } else {
 189       $hit         = ($not && !($value =~ m/$compare_to/i)) || (!$not && ($value =~ m/$compare_to/i));
 190     }
 191
 192   } else {
 193     $hit           = ($not && ! $value)                     || (!$not &&  $value);
 194   }
 195
 196   if ($hit) {
 197     my $new_text = $self->parse_block($block, @indices);
 198     if (!defined($new_text)) {
 199       $main::lxdebug->leave_sub();
 200       return undef;
 201     }
 202     $$new_contents .= $new_text;
 203   }
 204
 205   $main::lxdebug->leave_sub();
 206
 207   return 1;
 208 }
 209
 210 1;
 211
 212 ####
 213 #### LaTeXTemplate
 214 ####
 215
 216 package LaTeXTemplate;
 217
 218 use vars qw(@ISA);
 219
 220 @ISA = qw(SimpleTemplate);
 221
 222 sub new {
 223   my $type = shift;
 224
 225   my $self = $type->SUPER::new(@_);
 226
 227   return $self;
 228 }
 229
 230 sub format_string {
 231   my ($self, $variable) = @_;
 232   my $form = $self->{"form"};
 233
 234   $variable = $main::locale->quote_special_chars('Template/LaTeX', $variable);
 235
 236   # Allow some HTML markup to be converted into the output format's
 237   # corresponding markup code, e.g. bold or italic.
 238   my %markup_replace = ('b' => 'textbf',
 239                         'i' => 'textit',
 240                         'u' => 'underline');
 241
 242   foreach my $key (keys(%markup_replace)) {
 243     my $new = $markup_replace{$key};
 244     $variable =~ s/\$\<\$${key}\$\>\$(.*?)\$<\$\/${key}\$>\$/\\${new}\{$1\}/gi;
 245   }
 246
 247   $variable =~ s/[\x00-\x1f]//g;
 248
 249   return $variable;
 250 }
 251
 252 sub parse_foreach {
 253   my ($self, $var, $text, $start_tag, $end_tag, @indices) = @_;
 254
 255   my ($form, $new_contents) = ($self->{"form"}, "");
 256
 257   my $ary = $self->_get_loop_variable($var, 1, @indices);
 258
 259   my $sum                          = 0;
 260   my $current_page                 = 1;
 261   my ($current_line, $corrent_row) = (0, 1);
 262   my $description_array            = $self->_get_loop_variable("description",     1);
 263   my $longdescription_array        = $self->_get_loop_variable("longdescription", 1);
 264   my $linetotal_array              = $self->_get_loop_variable("linetotal",       1);
 265
 266   $form->{TEMPLATE_ARRAYS}->{cumulatelinetotal} = [];
 267
 268   for (my $i = 0; $i < scalar(@{$ary}); $i++) {
 269     $form->{"__first__"}   = $i == 1;
 270     $form->{"__last__"}    = ($i + 1) == scalar(@{$ary});
 271     $form->{"__odd__"}     = (($i + 1) % 2) == 1;
 272     $form->{"__counter__"} = $i + 1;
 273
 274     if (scalar @{$description_array} == scalar @{$ary} && $self->{"chars_per_line"} != 0) {
 275       my $lines = int(length($description_array->[$i]) / $self->{"chars_per_line"});
 276       my $lpp;
 277
 278       $description_array->[$i] =~ s/(\\newline\s?)*$//;
 279       my $_description = $description_array->[$i];
 280       while ($_description =~ /\\newline/) {
 281         $lines++;
 282         $_description =~ s/\\newline//;
 283       }
 284       $lines++;
 285
 286       if ($current_page == 1) {
 287         $lpp = $self->{"lines_on_first_page"};
 288       } else {
 289         $lpp = $self->{"lines_on_second_page"};
 290       }
 291
 292       # Yes we need a manual page break -- or the user has forced one
 293       if ((($current_line + $lines) > $lpp) || ($description_array->[$i] =~ /<pagebreak>/) || ($longdescription_array->[$i] =~ /<pagebreak>/)) {
 294         my $pb = $self->{"pagebreak_block"};
 295
 296         # replace the special variables <%sumcarriedforward%>
 297         # and <%lastpage%>
 298
 299         my $psum = $form->format_amount($self->{"myconfig"}, $sum, 2);
 300         $pb =~ s/$self->{tag_start_qm}sumcarriedforward$self->{tag_end_qm}/$psum/g;
 301         $pb =~ s/$self->{tag_start_qm}lastpage$self->{tag_end_qm}/$current_page/g;
 302
 303         my $new_text = $self->parse_block($pb, (@indices, $i));
 304         return undef unless (defined($new_text));
 305         $new_contents .= $new_text;
 306
 307         $current_page++;
 308         $current_line = 0;
 309       }
 310       $current_line += $lines;
 311     }
 312
 313     if ($i < scalar(@{$linetotal_array})) {
 314       $sum += $form->parse_amount($self->{"myconfig"}, $linetotal_array->[$i]);
 315     }
 316
 317     $form->{TEMPLATE_ARRAYS}->{cumulatelinetotal}->[$i] = $form->format_amount($self->{"myconfig"}, $sum, 2);
 318
 319     my $new_text = $self->parse_block($text, (@indices, $i));
 320     return undef unless (defined($new_text));
 321     $new_contents .= $start_tag . $new_text . $end_tag;
 322   }
 323   map({ delete($form->{"__${_}__"}); } qw(first last odd counter));
 324
 325   return $new_contents;
 326 }
 327
 328 sub find_end {
 329   my ($self, $text, $pos, $var, $not) = @_;
 330
 331   my $tag_start_len = length $self->{tag_start};
 332
 333   my $depth = 1;
 334   $pos = 0 unless ($pos);
 335
 336   while ($pos < length($text)) {
 337     $pos++;
 338
 339     next if (substr($text, $pos - 1, length($self->{tag_start})) ne $self->{tag_start});
 340
 341     my $keyword_pos = $pos - 1 + $tag_start_len;
 342
 343     if ((substr($text, $keyword_pos, 2) eq 'if') || (substr($text, $keyword_pos, 3) eq 'for')) {
 344       $depth++;
 345
 346     } elsif ((substr($text, $keyword_pos, 4) eq 'else') && (1 == $depth)) {
 347       if (!$var) {
 348         $self->{"error"} =
 349             "$self->{tag_start}else$self->{tag_end} outside of "
 350           . "$self->{tag_start}if$self->{tag_end} / "
 351           . "$self->{tag_start}ifnot$self->{tag_end}.";
 352         return undef;
 353       }
 354
 355       my $block = substr($text, 0, $pos - 1);
 356       substr($text, 0, $pos - 1) = "";
 357       $text =~ s!^$self->{tag_start_qm}.+?$self->{tag_end_qm}!!;
 358       $text =  $self->{tag_start} . 'if' . ($not ?  " " : "not ") . $var . $self->{tag_end} . $text;
 359
 360       return ($block, $text);
 361
 362     } elsif (substr($text, $keyword_pos, 3) eq 'end') {
 363       $depth--;
 364       if ($depth == 0) {
 365         my $block = substr($text, 0, $pos - 1);
 366         substr($text, 0, $pos - 1) = "";
 367         $text =~ s!^$self->{tag_start_qm}.+?$self->{tag_end_qm}!!;
 368
 369         return ($block, $text);
 370       }
 371     }
 372   }
 373
 374   return undef;
 375 }
 376
 377 sub parse_block {
 378   $main::lxdebug->enter_sub();
 379
 380   my ($self, $contents, @indices) = @_;
 381
 382   my $new_contents = "";
 383
 384   while ($contents ne "") {
 385     my $pos_if      = index($contents, $self->{tag_start} . 'if');
 386     my $pos_foreach = index($contents, $self->{tag_start} . 'foreach');
 387
 388     if ((-1 == $pos_if) && (-1 == $pos_foreach)) {
 389       $new_contents .= $self->substitute_vars($contents, @indices);
 390       last;
 391     }
 392
 393     if ((-1 == $pos_if) || ((-1 != $pos_foreach) && ($pos_if > $pos_foreach))) {
 394       $new_contents .= $self->substitute_vars(substr($contents, 0, $pos_foreach), @indices);
 395       substr($contents, 0, $pos_foreach) = "";
 396
 397       if ($contents !~ m|^$self->{tag_start_qm}foreach (.+?)$self->{tag_end_qm}|) {
 398         $self->{"error"} = "Malformed $self->{tag_start}foreach$self->{tag_end}.";
 399         $main::lxdebug->leave_sub();
 400         return undef;
 401       }
 402
 403       my $var = $1;
 404
 405       substr($contents, 0, length($&)) = "";
 406
 407       my $block;
 408       ($block, $contents) = $self->find_end($contents);
 409       if (!$block) {
 410         $self->{"error"} = "Unclosed $self->{tag_start}foreach$self->{tag_end}." unless ($self->{"error"});
 411         $main::lxdebug->leave_sub();
 412         return undef;
 413       }
 414
 415       my $new_text = $self->parse_foreach($var, $block, "", "", @indices);
 416       if (!defined($new_text)) {
 417         $main::lxdebug->leave_sub();
 418         return undef;
 419       }
 420       $new_contents .= $new_text;
 421
 422     } else {
 423       if (!$self->_parse_block_if(\$contents, \$new_contents, $pos_if, @indices)) {
 424         $main::lxdebug->leave_sub();
 425         return undef;
 426       }
 427     }
 428   }
 429
 430   $main::lxdebug->leave_sub();
 431
 432   return $new_contents;
 433 }
 434
 435 sub parse_first_line {
 436   my $self = shift;
 437   my $line = shift || "";
 438
 439   if ($line =~ m/([^\s]+)set-tag-style([^\s]+)/) {
 440     if ($1 eq $2) {
 441       $self->{error} = "The tag start and end markers must not be equal.";
 442       return 0;
 443     }
 444
 445     $self->set_tag_style($1, $2);
 446   }
 447
 448   return 1;
 449 }
 450
 451 sub _parse_config_option {
 452   my $self = shift;
 453   my $line = shift;
 454
 455   $line =~ s/^\s*//;
 456   $line =~ s/\s*$//;
 457
 458   my ($key, $value) = split m/\s*=\s*/, $line, 2;
 459
 460   if ($key eq 'tag-style') {
 461     $self->set_tag_style(split(m/\s+/, $value, 2));
 462   }
 463 }
 464
 465 sub _parse_config_lines {
 466   my $self  = shift;
 467   my $lines = shift;
 468
 469   my ($comment_start, $comment_end) = ("", "");
 470
 471   if (ref $self eq 'LaTeXTemplate') {
 472     $comment_start = '\s*%';
 473   } elsif (ref $self eq 'HTMLTemplate') {
 474     $comment_start = '\s*<!--';
 475     $comment_end   = '>\s*';
 476   } else {
 477     $comment_start = '\s*\#';
 478   }
 479
 480   my $num_lines = scalar @{ $lines };
 481   my $i         = 0;
 482
 483   while ($i < $num_lines) {
 484     my $line = $lines->[$i];
 485
 486     if ($line !~ m/^${comment_start}\s*config\s*:(.*)${comment_end}$/i) {
 487       $i++;
 488       next;
 489     }
 490
 491     $self->_parse_config_option($1);
 492     splice @{ $lines }, $i, 1;
 493     $num_lines--;
 494   }
 495 }
 496
 497 sub _force_mandatory_packages {
 498   my $self  = shift;
 499   my $lines = shift;
 500
 501   my (%used_packages, $document_start_line);
 502
 503   foreach my $i (0 .. scalar @{ $lines } - 1) {
 504     if ($lines->[$i] =~ m/\\usepackage[^{]*{(.*?)}/) {
 505       $used_packages{$1} = 1;
 506
 507     } elsif ($lines->[$i] =~ m/\\begin{document}/) {
 508       $document_start_line = $i;
 509       last;
 510
 511     }
 512   }
 513
 514   $document_start_line = scalar @{ $lines } - 1 if (!defined $document_start_line);
 515
 516   if (!$used_packages{textcomp}) {
 517     splice @{ $lines }, $document_start_line, 0, "\\usepackage{textcomp}\n";
 518     $document_start_line++;
 519   }
 520 }
 521
 522 sub parse {
 523   my $self = $_[0];
 524   local *OUT = $_[1];
 525   my $form = $self->{"form"};
 526
 527   if (!open(IN, "$form->{templates}/$form->{IN}")) {
 528     $self->{"error"} = "$!";
 529     return 0;
 530   }
 531   my @lines = <IN>;
 532   close(IN);
 533
 534   $self->_parse_config_lines(\@lines);
 535   $self->_force_mandatory_packages(\@lines) if (ref $self eq 'LaTeXTemplate');
 536
 537   my $contents = join("", @lines);
 538
 539   # detect pagebreak block and its parameters
 540   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) {
 541     $self->{"chars_per_line"} = $1;
 542     $self->{"lines_on_first_page"} = $2;
 543     $self->{"lines_on_second_page"} = $3;
 544     $self->{"pagebreak_block"} = $4;
 545
 546     substr($contents, length($`), length($&)) = "";
 547   }
 548
 549   $self->{"forced_pagebreaks"} = [];
 550
 551   my $new_contents = $self->parse_block($contents);
 552   if (!defined($new_contents)) {
 553     $main::lxdebug->leave_sub();
 554     return 0;
 555   }
 556
 557   print(OUT $new_contents);
 558
 559   if ($form->{"format"} =~ /postscript/i) {
 560     return $self->convert_to_postscript();
 561   } elsif ($form->{"format"} =~ /pdf/i) {
 562     return $self->convert_to_pdf();
 563   } else {
 564     return 1;
 565   }
 566 }
 567
 568 sub convert_to_postscript {
 569   my ($self) = @_;
 570   my ($form, $userspath) = ($self->{"form"}, $self->{"userspath"});
 571
 572   # Convert the tex file to postscript
 573
 574   if (!chdir("$userspath")) {
 575     $self->{"error"} = "chdir : $!";
 576     $self->cleanup();
 577     return 0;
 578   }
 579
 580   $form->{tmpfile} =~ s/\Q$userspath\E\///g;
 581
 582   my $latex = $self->_get_latex_path();
 583
 584   for (my $run = 1; $run <= 2; $run++) {
 585     system("${latex} --interaction=nonstopmode $form->{tmpfile} " .
 586            "> $form->{tmpfile}.err");
 587     if ($?) {
 588       $self->{"error"} = $form->cleanup();
 589       $self->cleanup();
 590       return 0;
 591     }
 592   }
 593
 594   $form->{tmpfile} =~ s/tex$/dvi/;
 595
 596   system("dvips $form->{tmpfile} -o -q > /dev/null");
 597   if ($?) {
 598     $self->{"error"} = "dvips : $!";
 599     $self->cleanup();
 600     return 0;
 601   }
 602   $form->{tmpfile} =~ s/dvi$/ps/;
 603
 604   $self->cleanup();
 605
 606   return 1;
 607 }
 608
 609 sub convert_to_pdf {
 610   my ($self) = @_;
 611   my ($form, $userspath) = ($self->{"form"}, $self->{"userspath"});
 612
 613   # Convert the tex file to PDF
 614
 615   if (!chdir("$userspath")) {
 616     $self->{"error"} = "chdir : $!";
 617     $self->cleanup();
 618     return 0;
 619   }
 620
 621   $form->{tmpfile} =~ s/\Q$userspath\E\///g;
 622
 623   my $latex = $self->_get_latex_path();
 624
 625   for (my $run = 1; $run <= 2; $run++) {
 626     system("${latex} --interaction=nonstopmode $form->{tmpfile} " .
 627            "> $form->{tmpfile}.err");
 628     if ($?) {
 629       $self->{"error"} = $form->cleanup();
 630       $self->cleanup();
 631       return 0;
 632     }
 633   }
 634
 635   $form->{tmpfile} =~ s/tex$/pdf/;
 636
 637   $self->cleanup();
 638 }
 639
 640 sub _get_latex_path {
 641   return $main::latex_bin || 'pdflatex';
 642 }
 643
 644 sub get_mime_type() {
 645   my ($self) = @_;
 646
 647   if ($self->{"form"}->{"format"} =~ /postscript/i) {
 648     return "application/postscript";
 649   } else {
 650     return "application/pdf";
 651   }
 652 }
 653
 654 sub uses_temp_file {
 655   return 1;
 656 }
 657
 658
 659 ####
 660 #### HTMLTemplate
 661 ####
 662
 663 package HTMLTemplate;
 664
 665 use vars qw(@ISA);
 666
 667 @ISA = qw(LaTeXTemplate);
 668
 669 sub new {
 670   my $type = shift;
 671
 672   return $type->SUPER::new(@_);
 673 }
 674
 675 sub format_string {
 676   my ($self, $variable) = @_;
 677   my $form = $self->{"form"};
 678
 679   $variable = $main::locale->quote_special_chars('Template/HTML', $variable);
 680
 681   # Allow some HTML markup to be converted into the output format's
 682   # corresponding markup code, e.g. bold or italic.
 683   my @markup_replace = ('b', 'i', 's', 'u', 'sub', 'sup');
 684
 685   foreach my $key (@markup_replace) {
 686     $variable =~ s/\&lt;(\/?)${key}\&gt;/<$1${key}>/g;
 687   }
 688
 689   return $variable;
 690 }
 691
 692 sub get_mime_type() {
 693   my ($self) = @_;
 694
 695   if ($self->{"form"}->{"format"} =~ /postscript/i) {
 696     return "application/postscript";
 697   } elsif ($self->{"form"}->{"format"} =~ /pdf/i) {
 698     return "application/pdf";
 699   } else {
 700     return "text/html";
 701   }
 702 }
 703
 704 sub uses_temp_file {
 705   my ($self) = @_;
 706
 707   if ($self->{"form"}->{"format"} =~ /postscript/i) {
 708     return 1;
 709   } elsif ($self->{"form"}->{"format"} =~ /pdf/i) {
 710     return 1;
 711   } else {
 712     return 0;
 713   }
 714 }
 715
 716 sub convert_to_postscript {
 717   my ($self) = @_;
 718   my ($form, $userspath) = ($self->{"form"}, $self->{"userspath"});
 719
 720   # Convert the HTML file to postscript
 721
 722   if (!chdir("$userspath")) {
 723     $self->{"error"} = "chdir : $!";
 724     $self->cleanup();
 725     return 0;
 726   }
 727
 728   $form->{"tmpfile"} =~ s/\Q$userspath\E\///g;
 729   my $psfile = $form->{"tmpfile"};
 730   $psfile =~ s/.html/.ps/;
 731   if ($psfile eq $form->{"tmpfile"}) {
 732     $psfile .= ".ps";
 733   }
 734
 735   system("html2ps -f html2ps-config < $form->{tmpfile} > $psfile");
 736   if ($?) {
 737     $self->{"error"} = $form->cleanup();
 738     $self->cleanup();
 739     return 0;
 740   }
 741
 742   $form->{"tmpfile"} = $psfile;
 743
 744   $self->cleanup();
 745
 746   return 1;
 747 }
 748
 749 sub convert_to_pdf {
 750   my ($self) = @_;
 751   my ($form, $userspath) = ($self->{"form"}, $self->{"userspath"});
 752
 753   # Convert the HTML file to PDF
 754
 755   if (!chdir("$userspath")) {
 756     $self->{"error"} = "chdir : $!";
 757     $self->cleanup();
 758     return 0;
 759   }
 760
 761   $form->{"tmpfile"} =~ s/\Q$userspath\E\///g;
 762   my $pdffile = $form->{"tmpfile"};
 763   $pdffile =~ s/.html/.pdf/;
 764   if ($pdffile eq $form->{"tmpfile"}) {
 765     $pdffile .= ".pdf";
 766   }
 767
 768   system("html2ps -f html2ps-config < $form->{tmpfile} | ps2pdf - $pdffile");
 769   if ($?) {
 770     $self->{"error"} = $form->cleanup();
 771     $self->cleanup();
 772     return 0;
 773   }
 774
 775   $form->{"tmpfile"} = $pdffile;
 776
 777   $self->cleanup();
 778
 779   return 1;
 780 }
 781
 782
 783 ####
 784 #### PlainTextTemplate
 785 ####
 786
 787 package PlainTextTemplate;
 788
 789 use vars qw(@ISA);
 790
 791 @ISA = qw(LaTeXTemplate);
 792
 793 sub new {
 794   my $type = shift;
 795
 796   return $type->SUPER::new(@_);
 797 }
 798
 799 sub format_string {
 800   my ($self, $variable) = @_;
 801
 802   return $variable;
 803 }
 804
 805 sub get_mime_type {
 806   return "text/plain";
 807 }
 808
 809 sub parse {
 810 }
 811
 812 1;
 813
 814 ####
 815 #### OpenDocumentTemplate
 816 ####
 817
 818 package OpenDocumentTemplate;
 819
 820 use POSIX 'setsid';
 821 use vars qw(@ISA);
 822
 823 use Cwd;
 824 # use File::Copy;
 825 # use File::Spec;
 826 # use File::Temp qw(:mktemp);
 827 use IO::File;
 828
 829 @ISA = qw(SimpleTemplate);
 830
 831 sub new {
 832   my $type = shift;
 833
 834   $self = $type->SUPER::new(@_);
 835
 836   foreach my $module (qw(Archive::Zip Text::Iconv)) {
 837     eval("use ${module};");
 838     if ($@) {
 839       $self->{"form"}->error("The Perl module '${module}' could not be " .
 840                              "loaded. Support for OpenDocument templates " .
 841                              "does not work without it. Please install your " .
 842                              "distribution's package or get the module from " .
 843                              "CPAN ( http://www.cpan.org ).");
 844     }
 845   }
 846
 847   $self->{"rnd"}   = int(rand(1000000));
 848   $self->{"iconv"} = Text::Iconv->new($main::dbcharset, "UTF-8");
 849
 850   $self->set_tag_style('&lt;%', '%&gt;');
 851   $self->{quot_re} = '&quot;';
 852
 853   return $self;
 854 }
 855
 856 sub parse_foreach {
 857   my ($self, $var, $text, $start_tag, $end_tag, @indices) = @_;
 858
 859   my ($form, $new_contents) = ($self->{"form"}, "");
 860
 861   my $ary = $self->_get_loop_variable($var, 1, @indices);
 862
 863   for (my $i = 0; $i < scalar(@{$ary}); $i++) {
 864     $form->{"__first__"} = $i == 0;
 865     $form->{"__last__"} = ($i + 1) == scalar(@{$ary});
 866     $form->{"__odd__"} = (($i + 1) % 2) == 1;
 867     $form->{"__counter__"} = $i + 1;
 868     my $new_text = $self->parse_block($text, (@indices, $i));
 869     return undef unless (defined($new_text));
 870     $new_contents .= $start_tag . $new_text . $end_tag;
 871   }
 872   map({ delete($form->{"__${_}__"}); } qw(first last odd counter));
 873
 874   return $new_contents;
 875 }
 876
 877 sub find_end {
 878   my ($self, $text, $pos, $var, $not) = @_;
 879
 880   my $depth = 1;
 881   $pos = 0 unless ($pos);
 882
 883   while ($pos < length($text)) {
 884     $pos++;
 885
 886     next if (substr($text, $pos - 1, 5) ne '&lt;%');
 887
 888     if ((substr($text, $pos + 4, 2) eq 'if') || (substr($text, $pos + 4, 3) eq 'for')) {
 889       $depth++;
 890
 891     } elsif ((substr($text, $pos + 4, 4) eq 'else') && (1 == $depth)) {
 892       if (!$var) {
 893         $self->{"error"} = '<%else%> outside of <%if%> / <%ifnot%>.';
 894         return undef;
 895       }
 896
 897       my $block = substr($text, 0, $pos - 1);
 898       substr($text, 0, $pos - 1) = "";
 899       $text =~ s!^\&lt;\%[^\%]+\%\&gt;!!;
 900       $text = '&lt;%if' . ($not ?  " " : "not ") . $var . '%&gt;' . $text;
 901
 902       return ($block, $text);
 903
 904     } elsif (substr($text, $pos + 4, 3) eq 'end') {
 905       $depth--;
 906       if ($depth == 0) {
 907         my $block = substr($text, 0, $pos - 1);
 908         substr($text, 0, $pos - 1) = "";
 909         $text =~ s!^\&lt;\%[^\%]+\%\&gt;!!;
 910
 911         return ($block, $text);
 912       }
 913     }
 914   }
 915
 916   return undef;
 917 }
 918
 919 sub parse_block {
 920   $main::lxdebug->enter_sub();
 921
 922   my ($self, $contents, @indices) = @_;
 923
 924   my $new_contents = "";
 925
 926   while ($contents ne "") {
 927     if (substr($contents, 0, 1) eq "<") {
 928       $contents =~ m|^<[^>]+>|;
 929       my $tag = $&;
 930       substr($contents, 0, length($&)) = "";
 931
 932       if ($tag =~ m|<table:table-row|) {
 933         $contents =~ m|^(.*?)(</table:table-row[^>]*>)|;
 934         my $table_row = $1;
 935         my $end_tag = $2;
 936         substr($contents, 0, length($1) + length($end_tag)) = "";
 937
 938         if ($table_row =~ m|\&lt;\%foreachrow\s+(.*?)\%\&gt;|) {
 939           my $var = $1;
 940
 941           substr($table_row, length($`), length($&)) = "";
 942
 943           my ($t1, $t2) = $self->find_end($table_row, length($`));
 944           if (!$t1) {
 945             $self->{"error"} = "Unclosed <\%foreachrow\%>." unless ($self->{"error"});
 946             $main::lxdebug->leave_sub();
 947             return undef;
 948           }
 949
 950           my $new_text = $self->parse_foreach($var, $t1 . $t2, $tag, $end_tag, @indices);
 951           if (!defined($new_text)) {
 952             $main::lxdebug->leave_sub();
 953             return undef;
 954           }
 955           $new_contents .= $new_text;
 956
 957         } else {
 958           my $new_text = $self->parse_block($table_row, @indices);
 959           if (!defined($new_text)) {
 960             $main::lxdebug->leave_sub();
 961             return undef;
 962           }
 963           $new_contents .= $tag . $new_text . $end_tag;
 964         }
 965
 966       } else {
 967         $new_contents .= $tag;
 968       }
 969
 970     } else {
 971       $contents =~ /^[^<]+/;
 972       my $text = $&;
 973
 974       my $pos_if = index($text, '&lt;%if');
 975       my $pos_foreach = index($text, '&lt;%foreach');
 976
 977       if ((-1 == $pos_if) && (-1 == $pos_foreach)) {
 978         substr($contents, 0, length($text)) = "";
 979         $new_contents .= $self->substitute_vars($text, @indices);
 980         next;
 981       }
 982
 983       if ((-1 == $pos_if) || ((-1 != $pos_foreach) && ($pos_if > $pos_foreach))) {
 984         $new_contents .= $self->substitute_vars(substr($contents, 0, $pos_foreach), @indices);
 985         substr($contents, 0, $pos_foreach) = "";
 986
 987         if ($contents !~ m|^\&lt;\%foreach (.*?)\%\&gt;|) {
 988           $self->{"error"} = "Malformed <\%foreach\%>.";
 989           $main::lxdebug->leave_sub();
 990           return undef;
 991         }
 992
 993         my $var = $1;
 994
 995         substr($contents, 0, length($&)) = "";
 996
 997         my $block;
 998         ($block, $contents) = $self->find_end($contents);
 999         if (!$block) {
1000           $self->{"error"} = "Unclosed <\%foreach\%>." unless ($self->{"error"});
1001           $main::lxdebug->leave_sub();
1002           return undef;
1003         }
1004
1005         my $new_text = $self->parse_foreach($var, $block, "", "", @indices);
1006         if (!defined($new_text)) {
1007           $main::lxdebug->leave_sub();
1008           return undef;
1009         }
1010         $new_contents .= $new_text;
1011
1012       } else {
1013         if (!$self->_parse_block_if(\$contents, \$new_contents, $pos_if, @indices)) {
1014           $main::lxdebug->leave_sub();
1015           return undef;
1016         }
1017       }
1018     }
1019   }
1020
1021   $main::lxdebug->leave_sub();
1022
1023   return $new_contents;
1024 }
1025
1026 sub parse {
1027   $main::lxdebug->enter_sub();
1028
1029   my $self = $_[0];
1030   local *OUT = $_[1];
1031   my $form = $self->{"form"};
1032
1033   close(OUT);
1034
1035   my $file_name;
1036   if ($form->{"IN"} =~ m|^/|) {
1037     $file_name = $form->{"IN"};
1038   } else {
1039     $file_name = $form->{"templates"} . "/" . $form->{"IN"};
1040   }
1041
1042   my $zip = Archive::Zip->new();
1043   if (Archive::Zip::AZ_OK != $zip->read($file_name)) {
1044     $self->{"error"} = "File not found/is not a OpenDocument file.";
1045     $main::lxdebug->leave_sub();
1046     return 0;
1047   }
1048
1049   my $contents = $zip->contents("content.xml");
1050   if (!$contents) {
1051     $self->{"error"} = "File is not a OpenDocument file.";
1052     $main::lxdebug->leave_sub();
1053     return 0;
1054   }
1055
1056   my $rnd = $self->{"rnd"};
1057   my $new_styles = qq|<style:style style:name="TLXO${rnd}BOLD" style:family="text">
1058 <style:text-properties fo:font-weight="bold" style:font-weight-asian="bold" style:font-weight-complex="bold"/>
1059 </style:style>
1060 <style:style style:name="TLXO${rnd}ITALIC" style:family="text">
1061 <style:text-properties fo:font-style="italic" style:font-style-asian="italic" style:font-style-complex="italic"/>
1062 </style:style>
1063 <style:style style:name="TLXO${rnd}UNDERLINE" style:family="text">
1064 <style:text-properties style:text-underline-style="solid" style:text-underline-width="auto" style:text-underline-color="font-color"/>
1065 </style:style>
1066 <style:style style:name="TLXO${rnd}STRIKETHROUGH" style:family="text">
1067 <style:text-properties style:text-line-through-style="solid"/>
1068 </style:style>
1069 <style:style style:name="TLXO${rnd}SUPER" style:family="text">
1070 <style:text-properties style:text-position="super 58%"/>
1071 </style:style>
1072 <style:style style:name="TLXO${rnd}SUB" style:family="text">
1073 <style:text-properties style:text-position="sub 58%"/>
1074 </style:style>
1075 |;
1076
1077   $contents =~ s|</office:automatic-styles>|${new_styles}</office:automatic-styles>|;
1078   $contents =~ s|[\n\r]||gm;
1079
1080   my $new_contents = $self->parse_block($contents);
1081   if (!defined($new_contents)) {
1082     $main::lxdebug->leave_sub();
1083     return 0;
1084   }
1085
1086 #   $new_contents =~ s|>|>\n|g;
1087
1088   $zip->contents("content.xml", $new_contents);
1089
1090   my $styles = $zip->contents("styles.xml");
1091   if ($contents) {
1092     my $new_styles = $self->parse_block($styles);
1093     if (!defined($new_contents)) {
1094       $main::lxdebug->leave_sub();
1095       return 0;
1096     }
1097     $zip->contents("styles.xml", $new_styles);
1098   }
1099
1100   $zip->writeToFileNamed($form->{"tmpfile"}, 1);
1101
1102   my $res = 1;
1103   if ($form->{"format"} =~ /pdf/) {
1104     $res = $self->convert_to_pdf();
1105   }
1106
1107   $main::lxdebug->leave_sub();
1108   return $res;
1109 }
1110
1111 sub is_xvfb_running {
1112   $main::lxdebug->enter_sub();
1113
1114   my ($self) = @_;
1115
1116   local *IN;
1117   my $dfname = $self->{"userspath"} . "/xvfb_display";
1118   my $display;
1119
1120   $main::lxdebug->message(LXDebug::DEBUG2, "    Looking for $dfname\n");
1121   if ((-f $dfname) && open(IN, $dfname)) {
1122     my $pid = <IN>;
1123     chomp($pid);
1124     $display = <IN>;
1125     chomp($display);
1126     my $xauthority = <IN>;
1127     chomp($xauthority);
1128     close(IN);
1129
1130     $main::lxdebug->message(LXDebug::DEBUG2, "      found with $pid and $display\n");
1131
1132     if ((! -d "/proc/$pid") || !open(IN, "/proc/$pid/cmdline")) {
1133       $main::lxdebug->message(LXDebug::DEBUG2, "  no/wrong process #1\n");
1134       unlink($dfname, $xauthority);
1135       $main::lxdebug->leave_sub();
1136       return undef;
1137     }
1138     my $line = <IN>;
1139     close(IN);
1140     if ($line !~ /xvfb/i) {
1141       $main::lxdebug->message(LXDebug::DEBUG2, "      no/wrong process #2\n");
1142       unlink($dfname, $xauthority);
1143       $main::lxdebug->leave_sub();
1144       return undef;
1145     }
1146
1147     $ENV{"XAUTHORITY"} = $xauthority;
1148     $ENV{"DISPLAY"} = $display;
1149   } else {
1150     $main::lxdebug->message(LXDebug::DEBUG2, "      not found\n");
1151   }
1152
1153   $main::lxdebug->leave_sub();
1154
1155   return $display;
1156 }
1157
1158 sub spawn_xvfb {
1159   $main::lxdebug->enter_sub();
1160
1161   my ($self) = @_;
1162
1163   $main::lxdebug->message(LXDebug::DEBUG2, "spawn_xvfb()\n");
1164
1165   my $display = $self->is_xvfb_running();
1166
1167   if ($display) {
1168     $main::lxdebug->leave_sub();
1169     return $display;
1170   }
1171
1172   $display = 99;
1173   while ( -f "/tmp/.X${display}-lock") {
1174     $display++;
1175   }
1176   $display = ":${display}";
1177   $main::lxdebug->message(LXDebug::DEBUG2, "  display $display\n");
1178
1179   my $mcookie = `mcookie`;
1180   die("Installation error: mcookie not found.") if ($? != 0);
1181   chomp($mcookie);
1182
1183   $main::lxdebug->message(LXDebug::DEBUG2, "  mcookie $mcookie\n");
1184
1185   my $xauthority = "/tmp/.Xauthority-" . $$ . "-" . time() . "-" . int(rand(9999999));
1186   $ENV{"XAUTHORITY"} = $xauthority;
1187
1188   $main::lxdebug->message(LXDebug::DEBUG2, "  xauthority $xauthority\n");
1189
1190   system("xauth add \"${display}\" . \"${mcookie}\"");
1191   if ($? != 0) {
1192     $self->{"error"} = "Conversion to PDF failed because OpenOffice could not be started (xauth: $!)";
1193     $main::lxdebug->leave_sub();
1194     return undef;
1195   }
1196
1197   $main::lxdebug->message(LXDebug::DEBUG2, "  about to fork()\n");
1198
1199   my $pid = fork();
1200   if (0 == $pid) {
1201     $main::lxdebug->message(LXDebug::DEBUG2, "  Child execing\n");
1202     exec($main::xvfb_bin, $display, "-screen", "0", "640x480x8", "-nolisten", "tcp");
1203   }
1204   sleep(3);
1205   $main::lxdebug->message(LXDebug::DEBUG2, "  parent dont sleeping\n");
1206
1207   local *OUT;
1208   my $dfname = $self->{"userspath"} . "/xvfb_display";
1209   if (!open(OUT, ">$dfname")) {
1210     $self->{"error"} = "Conversion to PDF failed because OpenOffice could not be started ($dfname: $!)";
1211     unlink($xauthority);
1212     kill($pid);
1213     $main::lxdebug->leave_sub();
1214     return undef;
1215   }
1216   print(OUT "$pid\n$display\n$xauthority\n");
1217   close(OUT);
1218
1219   $main::lxdebug->message(LXDebug::DEBUG2, "  parent re-testing\n");
1220
1221   if (!$self->is_xvfb_running()) {
1222     $self->{"error"} = "Conversion to PDF failed because OpenOffice could not be started.";
1223     unlink($xauthority, $dfname);
1224     kill($pid);
1225     $main::lxdebug->leave_sub();
1226     return undef;
1227   }
1228
1229   $main::lxdebug->message(LXDebug::DEBUG2, "  spawn OK\n");
1230
1231   $main::lxdebug->leave_sub();
1232
1233   return $display;
1234 }
1235
1236 sub is_openoffice_running {
1237   $main::lxdebug->enter_sub();
1238
1239   system("./scripts/oo-uno-test-conn.py $main::openofficeorg_daemon_port " .
1240          "> /dev/null 2> /dev/null");
1241   my $res = $? == 0;
1242   $main::lxdebug->message(LXDebug::DEBUG2, "  is_openoffice_running(): $?\n");
1243
1244   $main::lxdebug->leave_sub();
1245
1246   return $res;
1247 }
1248
1249 sub spawn_openoffice {
1250   $main::lxdebug->enter_sub();
1251
1252   my ($self) = @_;
1253
1254   $main::lxdebug->message(LXDebug::DEBUG2, "spawn_openoffice()\n");
1255
1256   my ($try, $spawned_oo, $res);
1257
1258   $res = 0;
1259   for ($try = 0; $try < 15; $try++) {
1260     if ($self->is_openoffice_running()) {
1261       $res = 1;
1262       last;
1263     }
1264
1265     if (!$spawned_oo) {
1266       my $pid = fork();
1267       if (0 == $pid) {
1268         $main::lxdebug->message(LXDebug::DEBUG2, "  Child daemonizing\n");
1269         chdir('/');
1270         open(STDIN, '/dev/null');
1271         open(STDOUT, '>/dev/null');
1272         my $new_pid = fork();
1273         exit if ($new_pid);
1274         my $ssres = setsid();
1275         $main::lxdebug->message(LXDebug::DEBUG2, "  Child execing\n");
1276         my @cmdline = ($main::openofficeorg_writer_bin,
1277                        "-minimized", "-norestore", "-nologo", "-nolockcheck",
1278                        "-headless",
1279                        "-accept=socket,host=localhost,port=" .
1280                        $main::openofficeorg_daemon_port . ";urp;");
1281         exec(@cmdline);
1282       }
1283
1284       $main::lxdebug->message(LXDebug::DEBUG2, "  Parent after fork\n");
1285       $spawned_oo = 1;
1286       sleep(3);
1287     }
1288
1289     sleep($try >= 5 ? 2 : 1);
1290   }
1291
1292   if (!$res) {
1293     $self->{"error"} = "Conversion from OpenDocument to PDF failed because " .
1294       "OpenOffice could not be started.";
1295   }
1296
1297   $main::lxdebug->leave_sub();
1298
1299   return $res;
1300 }
1301
1302 sub convert_to_pdf {
1303   $main::lxdebug->enter_sub();
1304
1305   my ($self) = @_;
1306
1307   my $form = $self->{"form"};
1308
1309   my $filename = $form->{"tmpfile"};
1310   $filename =~ s/.odt$//;
1311   if (substr($filename, 0, 1) ne "/") {
1312     $filename = getcwd() . "/${filename}";
1313   }
1314
1315   if (substr($self->{"userspath"}, 0, 1) eq "/") {
1316     $ENV{'HOME'} = $self->{"userspath"};
1317   } else {
1318     $ENV{'HOME'} = getcwd() . "/" . $self->{"userspath"};
1319   }
1320
1321   if (!$self->spawn_xvfb()) {
1322     $main::lxdebug->leave_sub();
1323     return 0;
1324   }
1325
1326   my @cmdline;
1327   if (!$main::openofficeorg_daemon) {
1328     @cmdline = ($main::openofficeorg_writer_bin,
1329                 "-minimized", "-norestore", "-nologo", "-nolockcheck",
1330                 "-headless",
1331                 "file:${filename}.odt",
1332                 "macro://" . (split('/', $filename))[-1] .
1333                 "/Standard.Conversion.ConvertSelfToPDF()");
1334   } else {
1335     if (!$self->spawn_openoffice()) {
1336       $main::lxdebug->leave_sub();
1337       return 0;
1338     }
1339
1340     @cmdline = ("./scripts/oo-uno-convert-pdf.py",
1341                 $main::openofficeorg_daemon_port,
1342                 "${filename}.odt");
1343   }
1344
1345   system(@cmdline);
1346
1347   my $res = $?;
1348   if (0 == $?) {
1349     $form->{"tmpfile"} =~ s/odt$/pdf/;
1350
1351     unlink($filename . ".odt");
1352
1353     $main::lxdebug->leave_sub();
1354     return 1;
1355
1356   }
1357
1358   unlink($filename . ".odt", $filename . ".pdf");
1359   $self->{"error"} = "Conversion from OpenDocument to PDF failed. " .
1360     "Exit code: $res";
1361
1362   $main::lxdebug->leave_sub();
1363   return 0;
1364 }
1365
1366 sub format_string {
1367   my ($self, $variable) = @_;
1368   my $form = $self->{"form"};
1369   my $iconv = $self->{"iconv"};
1370
1371   $variable = $main::locale->quote_special_chars('Template/OpenDocument', $variable);
1372
1373   # Allow some HTML markup to be converted into the output format's
1374   # corresponding markup code, e.g. bold or italic.
1375   my $rnd = $self->{"rnd"};
1376   my %markup_replace = ("b" => "BOLD", "i" => "ITALIC", "s" => "STRIKETHROUGH",
1377                         "u" => "UNDERLINE", "sup" => "SUPER", "sub" => "SUB");
1378
1379   foreach my $key (keys(%markup_replace)) {
1380     my $value = $markup_replace{$key};
1381     $variable =~ s|\&lt;${key}\&gt;|<text:span text:style-name=\"TLXO${rnd}${value}\">|gi; #"
1382     $variable =~ s|\&lt;/${key}\&gt;|</text:span>|gi;
1383   }
1384
1385   return $iconv->convert($variable);
1386 }
1387
1388 sub get_mime_type() {
1389   if ($self->{"form"}->{"format"} =~ /pdf/) {
1390     return "application/pdf";
1391   } else {
1392     return "application/vnd.oasis.opendocument.text";
1393   }
1394 }
1395
1396 sub uses_temp_file {
1397   return 1;
1398 }
1399
1400
1401 ##########################################################
1402 ####
1403 #### XMLTemplate
1404 ####
1405 ##########################################################
1406
1407 package XMLTemplate;
1408
1409 use vars qw(@ISA);
1410
1411 @ISA = qw(HTMLTemplate);
1412
1413 sub new {
1414   #evtl auskommentieren
1415   my $type = shift;
1416
1417   return $type->SUPER::new(@_);
1418 }
1419
1420 sub format_string {
1421   my ($self, $variable) = @_;
1422   my $form = $self->{"form"};
1423
1424   $variable = $main::locale->quote_special_chars('Template/XML', $variable);
1425
1426   # Allow no markup to be converted into the output format
1427   my @markup_replace = ('b', 'i', 's', 'u', 'sub', 'sup');
1428
1429   foreach my $key (@markup_replace) {
1430     $variable =~ s/\&lt;(\/?)${key}\&gt;//g;
1431   }
1432
1433   return $variable;
1434 }
1435
1436 sub get_mime_type() {
1437   my ($self) = @_;
1438
1439   if ($self->{"form"}->{"format"} =~ /elsterwinston/i) {
1440     return "application/xml ";
1441   } elsif ($self->{"form"}->{"format"} =~ /elstertaxbird/i) {
1442     return "application/x-taxbird";
1443   } else {
1444     return "text";
1445   }
1446 }
1447
1448 sub uses_temp_file {
1449   # tempfile needet for XML Output
1450   return 1;
1451 }
1452
1453 1;