projekt kivitendo

use File::Spec ();

use SL::Common ();

  my @pictures        = $self->prepare_pictures_for_printing;

  unlink @pictures unless ($::lx_office_conf{debug} || {})->{keep_temp_files};

  $::request->{layout}->use_javascript("${_}.js") for qw(jquery.jstree jquery/jquery.contextMenu requirement_spec);

sub prepare_pictures_for_printing {

  my ($self) = @_;

  my @files;

  my $userspath = File::Spec->rel2abs($::lx_office_conf{paths}->{userspath});

  my $target    =  "${userspath}/kivitendo-print-requirement-spec-picture-" . Common::unique_id() . '-';

  foreach my $picture (map { @{ $_->pictures } } @{ $self->requirement_spec->text_blocks }) {

    my $output_file_name        = $target . $picture->id . '.' . $picture->get_default_file_name_extension;

    $picture->{print_file_name} = File::Spec->abs2rel($output_file_name, $userspath);

    my $out                     = IO::File->new($output_file_name, 'w') || die("Could not create file " . $output_file_name);

    $out->binmode;

    $out->print($picture->picture_content);

    $out->close;

    push @files, $output_file_name;

  }

  return @files;

}

use SL::DB::RequirementSpecPicture;

  scalar                  => [ qw(text_block picture) ],

__PACKAGE__->run_before('load_requirement_spec_text_block', only => [qw(ajax_edit ajax_update ajax_delete ajax_flag dragged_and_dropped ajax_copy ajax_add_picture)]);

#

# actions for pictures

#

sub action_ajax_add_picture {

  my ($self) = @_;

  $self->picture(SL::DB::RequirementSpecPicture->new);

  $self->render('requirement_spec_text_block/_picture_form', { layout => 0 });

}

sub action_ajax_edit_picture {

  my ($self) = @_;

  $self->picture(SL::DB::RequirementSpecPicture->new(id => $::form->{picture_id})->load);

  $self->text_block($self->picture->text_block);

  $self->render('requirement_spec_text_block/_picture_form', { layout => 0 });

}

sub action_ajax_create_picture {

  my ($self, %params)              = @_;

  my $attributes                   = $::form->{ $::form->{form_prefix} } || die "Missing attributes";

  $attributes->{picture_file_name} = ((($::form->{ATTACHMENTS} || {})->{ $::form->{form_prefix} } || {})->{picture_content} || {})->{filename};

  my @errors                       = $self->picture(SL::DB::RequirementSpecPicture->new(%{ $attributes }))->validate;

  return $self->js->error(@errors)->render($self) if @errors;

  $self->picture->save;

  $self->text_block($self->picture->text_block);

  my $html = $self->render('requirement_spec_text_block/_text_block_picture', { output => 0 }, picture => $self->picture);

  $self->invalidate_version

    ->dialog->close('#jqueryui_popup_dialog')

    ->append('#text-block-' . $self->text_block->id . '-pictures', $html)

    ->show('#text-block-' . $self->text_block->id . '-pictures')

    ->render($self);

}

sub action_ajax_update_picture {

  my ($self)     = @_;

  my $attributes = $::form->{ $::form->{form_prefix} } || die "Missing attributes";

  $self->picture(SL::DB::RequirementSpecPicture->new(id => $::form->{id})->load);

  if (!$attributes->{picture_content}) {

    delete $attributes->{picture_content};

  } else {

    $attributes->{picture_file_name} = ((($::form->{ATTACHMENTS} || {})->{ $::form->{form_prefix} } || {})->{picture_content} || {})->{filename};

  }

  $self->picture->assign_attributes(%{ $attributes });

  my @errors = $self->picture->validate;

  return $self->js->error(@errors)->render($self) if @errors;

  $self->picture->save;

  $self->text_block($self->picture->text_block);

  my $html = $self->render('requirement_spec_text_block/_text_block_picture', { output => 0 }, picture => $self->picture);

  $self->invalidate_version

    ->dialog->close('#jqueryui_popup_dialog')

    ->replaceWith('#text-block-picture-' . $self->picture->id, $html)

    ->show('#text-block-' . $self->text_block->id . '-pictures')

    ->render($self);

}

sub action_ajax_delete_picture {

  my ($self) = @_;

  $self->picture(SL::DB::RequirementSpecPicture->new(id => $::form->{id})->load);

  $self->picture->delete;

  $self->text_block(SL::DB::RequirementSpecTextBlock->new(id => $self->picture->text_block_id)->load);

  $self->invalidate_version

    ->remove('#text-block-picture-' . $self->picture->id)

    ->action_if(!@{ $self->text_block->pictures }, 'hide', '#text-block-' . $self->text_block->id . '-pictures')

    ->render($self);

}

sub action_ajax_download_picture {

  my ($self) = @_;

  $self->picture(SL::DB::RequirementSpecPicture->new(id => $::form->{id})->load);

  $self->send_file(\$self->picture->{picture_content}, type => $self->picture->picture_content_type, name => $self->picture->picture_file_name);

}

use SL::DB::RequirementSpecPicture;

  requirement_spec_pictures            => 'RequirementSpecPicture',

# This file has been auto-generated only because it didn't exist.

# Feel free to modify it at will; it will not be overwritten automatically.

package SL::DB::Manager::RequirementSpecPicture;

use strict;

use SL::DB::Helper::Manager;

use base qw(SL::DB::Helper::Manager);

sub object_class { 'SL::DB::RequirementSpecPicture' }

__PACKAGE__->make_manager_methods;

1;

  previous_picture_number => { type => 'integer', default => '0', not_null => 1 },

# This file has been auto-generated. Do not modify it; it will be overwritten

# by rose_auto_create_model.pl automatically.

package SL::DB::RequirementSpecPicture;

use strict;

use base qw(SL::DB::Object);

__PACKAGE__->meta->table('requirement_spec_pictures');

__PACKAGE__->meta->columns(

  description            => { type => 'text' },

  id                     => { type => 'serial', not_null => 1 },

  itime                  => { type => 'timestamp', default => 'now()', not_null => 1 },

  mtime                  => { type => 'timestamp' },

  number                 => { type => 'text', not_null => 1 },

  picture_content        => { type => 'bytea', not_null => 1 },

  picture_content_type   => { type => 'text', not_null => 1 },

  picture_file_name      => { type => 'text', not_null => 1 },

  picture_height         => { type => 'integer', not_null => 1 },

  picture_mtime          => { type => 'timestamp', default => 'now()', not_null => 1 },

  picture_width          => { type => 'integer', not_null => 1 },

  position               => { type => 'integer', not_null => 1 },

  requirement_spec_id    => { type => 'integer', not_null => 1 },

  text_block_id          => { type => 'integer', not_null => 1 },

  thumbnail_content      => { type => 'bytea', not_null => 1 },

  thumbnail_content_type => { type => 'text', not_null => 1 },

  thumbnail_height       => { type => 'integer', not_null => 1 },

  thumbnail_width        => { type => 'integer', not_null => 1 },

);

__PACKAGE__->meta->primary_key_columns([ 'id' ]);

__PACKAGE__->meta->allow_inline_column_values(1);

__PACKAGE__->meta->foreign_keys(

  requirement_spec => {

    class       => 'SL::DB::RequirementSpec',

    key_columns => { requirement_spec_id => 'id' },

  },

  text_block => {

    class       => 'SL::DB::RequirementSpecTextBlock',

    key_columns => { text_block_id => 'id' },

  },

);

1;

;

  for (qw(previous_section_number previous_fb_number previous_picture_number)) {

    $self->$_(0) if !defined $self->$_;

  }

    $self->assign_attributes(map({ ($_ => $source->$_) } qw(type_id status_id customer_id project_id title hourly_rate time_estimation previous_section_number previous_fb_number previous_picture_number is_template)),

  # Clone text blocks and pictures.

  my $clone_picture = sub {

    my ($picture) = @_;

    my $cloned    = Rose::DB::Object::Helpers::clone_and_reset($picture);

    $cloned->position(undef);

    return $cloned;

  };

    $cloned->pictures([ map { $clone_picture->($_) } @{ $text_block->pictures_sorted } ]);

package SL::DB::RequirementSpecPicture;

use strict;

use Carp;

use GD;

use Image::Info;

use List::MoreUtils qw(apply);

use List::Util qw(max);

use Rose::DB::Object::Util;

use SL::DB::MetaSetup::RequirementSpecPicture;

use SL::DB::Manager::RequirementSpecPicture;

use SL::DB::Helper::ActsAsList;

use SL::Locale::String;

__PACKAGE__->meta->initialize;

__PACKAGE__->configure_acts_as_list(group_by => [qw(requirement_spec_id text_block_id)]);

__PACKAGE__->before_save(\&_create_picture_number);

__PACKAGE__->before_save(\&_update_thumbnail);

our %supported_mime_types = (

  'image/gif'  => { extension => 'gif', convert_to_png => 1, },

  'image/png'  => { extension => 'png' },

  'image/jpeg' => { extension => 'jpg' },

);

sub _create_picture_number {

  my ($self) = @_;

  return 1 if  $self->number;

  return 0 if !$self->requirement_spec_id;

  my $next_number = $self->requirement_spec->previous_picture_number + 1;

  $self->requirement_spec->update_attributes(previous_picture_number => $next_number) || return 0;

  $self->number($next_number);

  return 1;

}

sub _update_thumbnail {

  my ($self) = @_;

  return 1 if !$self->picture_content || !$self->picture_content_type || !Rose::DB::Object::Util::get_column_value_modified($self, 'picture_content');

  $self->create_thumbnail;

  return 1;

}

sub create_thumbnail {

  my ($self) = @_;

  croak "No picture set yet" if !$self->picture_content;

  my $image            = GD::Image->new($self->picture_content);

  my ($width, $height) = $image->getBounds;

  my $max_dim          = 64;

  my $curr_max         = max $width, $height, 1;

  my $factor           = $curr_max <= $max_dim ? 1 : $curr_max / $max_dim;

  my $new_width        = int($width  / $factor + 0.5);

  my $new_height       = int($height / $factor + 0.5);

  my $thumbnail        = GD::Image->new($new_width, $new_height);

  $thumbnail->copyResized($image, 0, 0, 0, 0, $new_width, $new_height, $width, $height);

  $self->thumbnail_content($thumbnail->png);

  $self->thumbnail_content_type('image/png');

  $self->thumbnail_width($new_width);

  $self->thumbnail_height($new_height);

  return 1;

}

sub update_type_and_dimensions {

  my ($self) = @_;

  return () if !$self->picture_content;

  return () if $self->picture_content_type && $self->picture_width && $self->picture_height && !Rose::DB::Object::Util::get_column_value_modified($self, 'picture_content');

  my @errors = $self->probe_type;

  return @errors if @errors;

  my $info = $supported_mime_types{ $self->picture_content_type };

  if ($info->{convert_to_png}) {

    $self->picture_content(GD::Image->new($self->picture_content)->png);

    $self->picture_content_type('image/png');

    $self->picture_file_name(apply { s/\.[^\.]+$//;  $_ .= '.png'; } $self->picture_file_name);

  }

  return ();

}

sub probe_type {

  my ($self) = @_;

  return (t8("No picture uploaded yet")) if !$self->picture_content;

  my $info = Image::Info::image_info(\$self->{picture_content});

  if (!$info || $info->{error} || !$info->{file_media_type} || !$supported_mime_types{ $info->{file_media_type} }) {

    $::lxdebug->warn("Image::Info error: " . $info->{error}) if $info && $info->{error};

    return (t8('Unsupported image type (supported types: #1)', join(' ', sort keys %supported_mime_types)));

  }

  $self->picture_content_type($info->{file_media_type});

  $self->picture_width($info->{width});

  $self->picture_height($info->{height});

  $self->picture_mtime(DateTime->now_local);

  $self->create_thumbnail;

  return ();

}

sub get_default_file_name_extension {

  my ($self) = @_;

  my $info = $supported_mime_types{ $self->picture_content_type } || croak("Unsupported content type " . $self->picture_content_type);

  return $info->{extension};

}

sub validate {

  my ($self) = @_;

  my @errors;

  push @errors, t8('The file name is missing') if !$self->picture_file_name;

  if (!length($self->picture_content // '')) {

    push @errors, t8('No picture has been uploaded');

  } else {

    push @errors, $self->update_type_and_dimensions;

  }

  return @errors;

}

1;

use Carp;

__PACKAGE__->meta->add_relationship(

  pictures => {

    type         => 'one to many',

    class        => 'SL::DB::RequirementSpecPicture',

    column_map   => { id => 'text_block_id' },

  },

);

sub pictures_sorted {

  my ($self, @args) = @_;

  croak "Not a writer" if @args;

  return [ sort { $a->position <=> $b->position } $self->pictures ];

}

  { name => "GD",                                  url => "http://search.cpan.org/~lds/",       debian => 'libgd-gd2-perl', },

  { name => "Image::Info",                         url => "http://search.cpan.org/~srezic/",    debian => 'libimage-info-perl' },

package SL::Template::Plugin::Base64;

use strict;

use vars qw($VERSION);

$VERSION = 0.01;

use base qw(Template::Plugin);

use Template::Plugin;

use Template::Stash;

use MIME::Base64 ();

$Template::Stash::SCALAR_OPS->{'encode_base64'} = \&_encode_base64;

$Template::Stash::SCALAR_OPS->{'decode_base64'} = \&_decode_base64;

sub new {

  my ($class, $context, $options) = @_;

  $context->define_filter('encode_base64', \&_encode_base64);

  $context->define_filter('decode_base64', \&_decode_base64);

  return bless {}, $class;

}

sub _encode_base64 {

  return MIME::Base64::encode_base64(shift, '');

}

sub _decode_base64 {

  my ($self, $var) = @_;

  return MIME::Base64::decode_base64(shift);

}

1;

__END__

=head1 NAME

SL::Template::Plugin::Base64 - TT2 interface to base64 encoding/decoding

=head1 SYNOPSIS

  [% USE Base64 -%]

  [% SELF.some_object.binary_stuff.encode_base64 -%]

  [% SELF.some_object.binary_stuff FILTER encode_base64 -%]

=head1 DESCRIPTION

The I<Base64> Template Toolkit plugin provides access to the Base64

routines from L<MIME::Base64>.

The following filters (and vmethods of the same name) are installed

into the current context:

=over 4

=item C<encode_base64>

Returns the string encoded as Base64.

=item C<decode_base64>

Returns the Base64 string decoded back to binary.

=back

As the filters are also available as vmethods the following are all

equivalent:

    FILTER encode_base64; content; END;

    content FILTER encode_base64;

    content.encode_base64;

=head1 AUTHOR

Moritz Bunkus E<lt>m.bunkus@linet-services.de<gt>

=cut

.context-menu-item.icon-add-picture { background-image: url("../image/add-picture.png"); }

.context-menu-item.icon-download    { background-image: url("../image/download.png"); }

.requirement-spec-text-block-picture-thumbnail {

  border-radius: 5px;

  border: 2px solid #ebebeb;

  float: left;

  margin-right: 20px;

  padding: 5px;

  text-align: center;

  width: 130px;

}

.requirement-spec-text-block-picture-thumbnail-img-container {

  height: 64px;

  margin: auto;

  padding: auto;

  width: 64px;

}

.requirement-spec-text-block-picture-thumbnail.selected {

  border: 2px solid #cbb120;

}

"Add picture":"Bild hinzufügen",

"Add picture to text block":"Bild dem Textblock hinzufügen",

"Delete picture":"Bild löschen",

"Download picture":"Bild herunterladen",

"Edit picture":"Bild bearbeiten",

"Text block picture actions":"Aktionen für Textblockbilder",

  if (/^text-block-picture-\d+$/.test(id))

    id = $(clicked_elt).closest('.text-block-context-menu').attr('id');

ns.find_text_block_picture_id = function(clicked_elt) {

  var id    = $(clicked_elt).attr('id');

  var match = id.match(/^text-block-picture-(\d+)$/);

  if (match)

    return match[1] * 1;

  return undefined;

};

ns.add_edit_text_block_picture_ajax_call = function(key, opt) {

  var title = key == 'add_picture' ? kivi.t8('Add picture to text block') : kivi.t8('Edit picture');

  kivi.popup_dialog({ url:    'controller.pl',

                      data:   { action:     'RequirementSpecTextBlock/ajax_' + key,

                                id:         ns.find_text_block_id(opt.$trigger),

                                picture_id: ns.find_text_block_picture_id(opt.$trigger) },

                      dialog: { title:      title }});

  return true;

};

ns.standard_text_block_picture_ajax_call = function(key, opt) {

  var data = {

      action: "RequirementSpecTextBlock/ajax_" + key

    , id:     ns.find_text_block_picture_id(opt.$trigger)

  };

  if (key == 'download_picture')

    $.download("controller.pl", data);

  else

    $.post("controller.pl", data, kivi.eval_json_result);

  return true;

};

ns.ask_delete_text_block_picture = function(key, opt) {

  if (confirm(kivi.t8("Are you sure?")))

    ns.standard_text_block_picture_ajax_call(key, opt);

  return true;

};

ns.handle_text_block_picture_popup_menu_markings = function(opt, add) {

  var id = ns.find_text_block_picture_id(opt.$trigger);

  if (id)

    $('#text-block-picture-' + id ).toggleClass('selected', add);

  return true;

};

ns.text_block_picture_popup_menu_shown = function(opt) {

  return ns.handle_text_block_picture_popup_menu_markings(opt, true);

};

ns.text_block_picture_popup_menu_hidden = function(opt) {

  return ns.handle_text_block_picture_popup_menu_markings(opt, false);

};

      , add_picture: { name: kivi.t8('Add picture to text block'), icon: "add-picture", callback: kivi.requirement_spec.add_edit_text_block_picture_ajax_call, disabled: kivi.requirement_spec.disable_edit_text_block_commands }

  $.contextMenu({

    selector: '.text-block-picture-context-menu',

    events:   {

        show: kivi.requirement_spec.text_block_picture_popup_menu_shown

      , hide: kivi.requirement_spec.text_block_picture_popup_menu_hidden

    },

    items:    $.extend({

        heading:          { name: kivi.t8('Text block picture actions'), className: 'context-menu-heading'                                                 }

      , add_picture:      { name: kivi.t8('Add picture'),      icon: "add-picture", callback: kivi.requirement_spec.add_edit_text_block_picture_ajax_call  }

      , edit_picture:     { name: kivi.t8('Edit picture'),     icon: "edit",        callback: kivi.requirement_spec.add_edit_text_block_picture_ajax_call  }

      , delete_picture:   { name: kivi.t8('Delete picture'),   icon: "delete",      callback: kivi.requirement_spec.ask_delete_text_block_picture          }

      , download_picture: { name: kivi.t8('Download picture'), icon: "download",    callback: kivi.requirement_spec.standard_text_block_picture_ajax_call  }

    }, general_actions)

  });

  var events = {

  'Add picture'                 => 'Bild hinzufügen',

  'Add picture to text block'   => 'Bild dem Textblock hinzufügen',

  'Current picture'             => 'Aktuelles Bild',

  'Delete picture'              => 'Bild löschen',

  'Dimensions'                  => 'Abmessungen',

  'Download picture'            => 'Bild herunterladen',

  'Edit picture'                => 'Bild bearbeiten',

  'Edit text block picture #1'  => 'Textblockbild #1 bearbeiten',

  'MIME type'                   => 'MIME-Typ',

  'No picture has been uploaded' => 'Es wurde kein Bild hochgeladen',

  'No picture uploaded yet'     => 'Noch kein Bild hochgeladen',

  'Picture #1: #2'              => 'Abbildung #1: #2',

  'Select file to upload'       => 'Datei zum Hochladen auswählen',

  'Text block picture actions'  => 'Aktionen für Textblockbilder',

  'The file name is missing'    => 'Der Dateiname fehlt',

  'Unsupported image type (supported types: #1)' => 'Nicht unterstützter Bildtyp (unterstützte Typen: #1)',

  'Uploaded at'                 => 'Hochgeladen um',

  'Vendor saved!'               => 'Lieferant gespeichert!',

  'Version'                     => 'Version',

-- @tag: requirement_spec_pictures

-- @description: Pflichtenhefte: Support für Bilder

-- @depends: requirement_specs

CREATE TABLE requirement_spec_pictures (

  id                     SERIAL    NOT NULL,

  requirement_spec_id    INTEGER   NOT NULL,

  text_block_id          INTEGER   NOT NULL,

  position               INTEGER   NOT NULL,

  number                 TEXT      NOT NULL,

  description            TEXT,

  picture_file_name      TEXT      NOT NULL,

  picture_content_type   TEXT      NOT NULL,

  picture_mtime          TIMESTAMP NOT NULL DEFAULT now(),

  picture_content        BYTEA     NOT NULL,

  picture_width          INTEGER   NOT NULL,

  picture_height         INTEGER   NOT NULL,

  thumbnail_content_type TEXT      NOT NULL,

  thumbnail_content      BYTEA     NOT NULL,

  thumbnail_width        INTEGER   NOT NULL,

  thumbnail_height       INTEGER   NOT NULL,

  itime                  TIMESTAMP NOT NULL DEFAULT now(),

  mtime                  TIMESTAMP,

  PRIMARY KEY (id),

  FOREIGN KEY (requirement_spec_id) REFERENCES requirement_specs            (id) ON DELETE CASCADE,

  FOREIGN KEY (text_block_id)       REFERENCES requirement_spec_text_blocks (id) ON DELETE CASCADE

);

CREATE TRIGGER mtime_requirement_spec_pictures BEFORE UPDATE ON requirement_spec_pictures FOR EACH ROW EXECUTE PROCEDURE set_mtime();

ALTER TABLE requirement_specs ADD COLUMN previous_picture_number INTEGER;

UPDATE requirement_specs SET previous_picture_number = 0;

ALTER TABLE requirement_specs ALTER COLUMN previous_picture_number SET NOT NULL;

ALTER TABLE requirement_specs ALTER COLUMN previous_picture_number SET DEFAULT 0;

%$( BLOCK picture_outputter )$

%  $( SET width_cm = (picture.picture_width / 150.0) * 2.54 )$

%  $( SET width_cm = width_cm < 16.4 ? width_cm : 16.4 )$

\begin{figure}[h!]

  \centering

  \includegraphics[width=$( width_cm )$cm,keepaspectratio]{$( picture.print_file_name )$}

\mbox{Abbildung $( picture.number )$: $( LxLatex.filter(picture.description ? picture.description : picture.picture_file_name) )$}

\end{figure}

%$( END )$

%      $( FOREACH picture = text_block.pictures_sorted.as_list )$

$( PROCESS picture_outputter picture=picture )$

%      $( END )$

[%- USE LxERP -%][%- USE L -%][%- USE HTML -%][%- USE JavaScript -%][% USE Base64 %][% SET style="width: 500px" %]

[% SET id_base = 'edit_text_block_picture_' _ (SELF.picture.id ? SELF.picture.id : 'new') %]

<form method="post" id="[% id_base %]_form" method="POST" enctype="multipart/form-data">

 [% L.hidden_tag('form_prefix',                    id_base,         id=id_base _ '_form_prefix') %]

 [% L.hidden_tag('id',                             SELF.picture.id, no_id=1) %]

 [% L.hidden_tag(id_base _ '.text_block_id',       SELF.text_block.id) %]

 [% L.hidden_tag(id_base _ '.requirement_spec_id', SELF.text_block.requirement_spec_id) %]

 <h2>

  [%- IF SELF.picture.id %]

   [%- LxERP.t8("Edit text block picture #1", SELF.picture.number) %]

  [%- ELSE %]

   [%- LxERP.t8("Add picture to text block") %]

  [%- END %]

 </h2>

 <table>

[% IF SELF.picture.number %]

  <tr>

   <th align="right">[%- LxERP.t8("Number") %]:</th>

   <td>[% HTML.escape(SELF.picture.number) %]</td>

  </tr>

[% END %]

  <tr>

   <th align="right">[%- LxERP.t8("Description") %]:</th>

   <td>[% L.input_tag(id_base _ '.description', SELF.picture.description, style=style) %]</td>

  </tr>

[% IF SELF.picture.picture_content %]

  <tr>

   <th align="right">[%- LxERP.t8("File name") %]:</th>

   <td>[% HTML.escape(SELF.picture.picture_file_name) %]</td>

  </tr>

  <tr>

   <th align="right">[%- LxERP.t8("MIME type") %]:</th>

   <td>[% HTML.escape(SELF.picture.picture_content_type) %]</td>

  </tr>

  <tr>

   <th align="right">[%- LxERP.t8("Dimensions") %]:</th>

   <td>[% HTML.escape(SELF.picture.picture_width) %]x[% HTML.escape(SELF.picture.picture_height) %]</td>

  </tr>

  <tr>

   <th align="right">[%- LxERP.t8("Uploaded at") %]:</th>

   <td>[% HTML.escape(SELF.picture.picture_mtime.to_kivitendo(precision='second')) %]</td>

  </tr>

[% END %]

  <tr>

   <th align="right">[%- LxERP.t8("Select file to upload") %]:</th>

   <td>[% L.input_tag(id_base _ '.picture_content', '', type='file') %]</td>

  </tr>

 </table>

 <p>

  [%- L.ajax_submit_tag('controller.pl?action=RequirementSpecTextBlock/ajax_' _ (SELF.picture.id ? 'update' : 'create') _ '_picture', '#' _ id_base _ '_form', LxERP.t8('Save'), no_id=1) %]

  <a href="#" onclick="$('#jqueryui_popup_dialog').dialog('close');">[%- LxERP.t8("Cancel") %]</a>

 </p>

</form>

[% IF SELF.picture.id %]

<h2>[% LxERP.t8("Current picture") %]</h2>

<div>

 <img src="data:[% HTML.escape(SELF.picture.picture_content_type) %];base64,[% SELF.picture.picture_content.encode_base64 %]">

</div>

[% END %]

 <div class="clearfix" id="text-block-[% HTML.escape(text_block.id) %]-pictures"[% UNLESS text_block.pictures.as_list.size %] style="display: none"[% END %]>

  [% FOREACH picture = text_block.pictures_sorted %]

   [% INCLUDE 'requirement_spec_text_block/_text_block_picture.html' picture=picture %]

  [% END %]

 </div>

[%- USE HTML -%][%- USE LxERP -%][% USE Base64 %]

[% SET title=LxERP.t8('Picture #1: #2', picture.number, picture.description ? picture.description _ ' (' _ picture.picture_file_name _ ')' : picture.picture_file_name) %]

<div id="text-block-picture-[% HTML.escape(picture.id) %]" class="requirement-spec-text-block-picture-thumbnail text-block-picture-context-menu">

 <div class="requirement-spec-text-block-picture-thumbnail-img-container">

  <img src="data:[% HTML.escape(picture.thumbnail_content_type) %];base64,[% picture.thumbnail_content.encode_base64 %]" alt="[% title %]">

 </div>

 <div>

  [% LxERP.t8('Picture #1: #2', picture.number, picture.description ? picture.description : picture.picture_file_name) %]

 </div>

</div>