source: projects/web-frontend/generator.php @ 6

Last change on this file since 6 was 6, checked in by sven, 11 years ago

Completed documentation (everything in english) and licence issues (everything is
GPLv3 now).

File size: 23.3 KB
RevLine 
[1]1<?php
[6]2/**
3 * The Paper Tape Project -- Visualisation Web frontend
4 *
5 * This PHP setup is capable of serving PNG and SVG files to clients
6 * by using the cli.c interface to the LOCHSTREIFEN cairo drawing
7 * routines. See index.html for all possible GET parameters.
8 *
9 * Currently this is a german-only subproject.
10 *
11 * Copyright (C) 2008  Sven Köppel
12 *
13 * This program is free software; you can redistribute
14 * it and/or modify it under the terms of the GNU General
15 * Public License as published by the Free Software
16 * Foundation; either version 3 of the License, or (at
17 * your option) any later version.
18 *
19 * This program is distributed in the hope that it will
20 * be useful, but WITHOUT ANY WARRANTY; without even the
21 * implied warranty of MERCHANTABILITY or FITNESS FOR A
22 * PARTICULAR PURPOSE. See the GNU General Public License
23 * for more details.
24 *
25 * You should have received a copy of the GNU General
26 * Public License along with this program; if not, see
27 * <http://www.gnu.org/licenses/>.
28 *
29 **/
[1]30
31// Konstanten:
32$draw_program = "../visualisator/binary";
33
34// Ausgabeordner (ohne trailing slash)
35$output_dir = "temp";
36
37// mit Verbose-Switch wird der Programmaufruf verbose.
38$verbose = isset($_GET['verbose']) || isset($_POST['verbose']);
39$ajax = isset($_GET['ajax']); // ajax-antwort oder normale Webseite anzeigen?
40
41if(!$ajax)
42    echo makeHeader('Lochstreifenvisualisierung online');
43
44function makeHeader($title) {
45    // als Funktion wg. Report-Datei, die später noch generiert wird.
46    return <<<HERE
47<html>
48<head>
49   <title>$title - technikum29 Private Zone</title>
50   <link rel="stylesheet" href="http://dev.technikum29.de/src/private.design/style.css" type="text/css">
51   <link rel="stylesheet" href="design/formular.css" type="text/css">
52   <!--<script type="text/javascript" src="design/formular.js"></script>--><!-- hier nicht mehr -->
53   <meta name="date.initial" value="02.04.2008">
54   <meta http-equiv="content-type" content="text/html; charset=ISO-8859-1" />
55</head>
56<body>
57<h1><a href="../"><span>technikum29.de interne Projekte:</span></a><strong>Lochstreifenprojekt: Visualisierung</strong></h1>
58HERE;
59}
60
61/*
62 * Übersicht über POST-Parameter, die entgegen genommen werden:
63 
64   *'data-src' = file|input|font
65     -> file => 'data-file' (dateiupload)
66     -> form => 'data-form' = hex[0]|oct|bin|dec
67                'data-input' = auf Länge checken und format
68     -> font => 'data-text' = auf gute Zeichen checken ([a-zA-Z0-9 ])
69
70   *'format' = PNG|SVG
71   *'dimension-src' = width|height|diameter
72     -> width => dimension-width
73     -> height => dimension-height        jeweils auf int checken
74     -> diameter => dimension-diameter
75
76   *'alignment' => hor-[rtl|ltr]-[l|r] | ver-[btt|ttb]-[u|o]
77
78   komponenten = imagebg|tapebg|punched|notpunched|feedholes
79
80   *'show-'+[komponenten]  (nur toggle an/aus)
81   *'color-'+[komponenten] => #RRGGBB
82   *'lucency-'+[komponenten] => AA
83
84   *'empty-start', 'empty-end' => int
85*/
86
87if(empty($_POST)) {
88    // so einfach ist das.
89    print '<h2>Parameter fehlen</h2>';
90    exit; // ;)
91}
92
93function get($var) {
94    // kleine Helperfunktion
95    return isset($_POST[$var]) ? $_POST[$var] : false;
96}
97
98function my_ctype_digit($string) {
99    // meine Implementierung dieser netten Funkion
100    return preg_match('/^[0-9]+$/', $string);
101}
102
103// Sofort tötende Fehler. Anzuwenden bei brutalen Fehlern, die nicht
104// auf Fehleingabe im Formular berufen (Angriffsgefahr)
105function print_fatal($text) {
106    print "<h2>Falsche Benutzung!</h2>\n";
107    print '<p class="big-error">'.$text."</p>\n";
108    print "<p>Dieser Fehler wäre nicht aufgetreten, hätten sie das Formular benutzt.</p>";
109    exit;
110}
111
112// das große Fehlerarray.
113$errors = array();
114// das nicht-tödliche Warnungsarray
115$warnings = array();
116
117// mit allen Fehlern beenden
118function exit_errors() {
119    global $ajax,$errors,$warnings;
120
121    print "<h2>Fehler in den angegeben Daten</h2>";
122    foreach($warnings as $error) {
123        print '<p class="big-warning">'.$error."</p>\n";
124    }
125    foreach($errors as $error) {
126        print '<p class="big-error">'.$error."</p>\n";
127    }
128    if($ajax) {
129        print "<p>Gehen sie zurück zum Formular und korrigieren sie ihre Fehleingaben.
130               Klicken sie dann nochmals auf <i>Generieren</i>.</p>";
131        print '<p><a href="javascript:history.go();">Zurück zum Formular</a></p>';
132    }
133    exit;
134}
135
136// Schritt 1: Eingaben entgegennehmen und validieren
137
138// 1/6: Punch-Daten
139$input_source = get('data-src');
140switch($input_source) {
141    case 'file': // Dateiupload. Tja. Datei direkt dem Programm übergeben. Vorher
142                 // Größe checken. Also mal los:
143                 if($ajax) {
144                     // wenn Ajax benutzt wird, wird die Datei noch nicht hochgeladen.
145                     break; // also erst anschließend machbar.
146                 }
147                 if(!isset($_FILES['data-file'])) {
148                     $errors[] = "Keine Datei hochgeladen, obwohl Dateiupload als Datenquelle ausgewählt war!";
149                 } elseif($_FILES['data-file']['size'] > 500*1024) {
150                     $errors[] = "Die hochgeladene Datei ist größer als ein 500kb. Derart große
151                                  Lochstreifen sind aus Perfomancegründen nicht erlaubt. Laden sie
152                                  sich das Visualisierungsprogramm runter und erstellen sie lokal
153                                  ihre Mammutlochstreifen.";
154                 } elseif($_FILES['data-file']['size'] == 0) {
155                     $warnings[] = "Die hochgeladene Datei ist leer (0 Bytes Inhalt). Das gibt keinen sonderlich
156                                    spannenden Lochstreifen...";
157                 }
158                 $original_filename = $_FILES['data-file']['name']; // fuer den Report weiter unten
159                 $input_filename = $_FILES['data-file']['tmp_name'];
160                 // usw.
161                 break;
162    case 'input': // Daten direkt eingetippt. Na dann...
163                 $text = get('data-input');
164                 $form = get('data-form');
165                 $input_binary = 'abc';
166                 $parts = preg_split("/\s+|\n+/", $text);
167                 foreach($parts as $x => $byte) {
168                     if(!strlen($byte)) continue; // nur whitespace, Abfall durch das preg_split.
169
170                     // Alle Formen zu dezimal umwandeln.
171                     if($form == 'bin')
172                         $byte = bindec($byte);
173                     elseif($form == 'hex')
174                         $byte = hexdec($byte);
175                     elseif($form == 'oct')
176                         $byte = octdec($byte);
177                     elseif($form == 'hex0')
178                         $byte = hexdec(substr($byte,2)); // 0x wegschneiden.
179                     elseif($form != 'dec') {
180                         $errors[] = "Fehler: Ungültige Datenform <i>$form</i>!";
181                         break;
182                     }
183
184                     if(!is_numeric($byte)) {
185                         $errors[] = "Fehler: Byte $x mit dem Wert <i>$byte</i> ist keine entsprechende
186                                      Zahl des Types <i>$form</i>. Vielleicht haben sie nicht das
187                                      passende Format eingestellt, in dem sie ihre Daten eingegeben haben?";
188                         break;
189                      }
190
191                      $input_binary .= chr($byte); // <- the PHP way | the Perl way -> pack('C', $byte);
192                 } // foreach
193                 if(strlen($input_binary) > 1024*1024) {
194                     $errors[] = 'Sie haben über eine Millionen Bytes eingetippt! Derart große
195                                  Lochstreifen sind aus Perfomancegründen nicht erlaubt. Laden sie
196                                  sich das Visualisieurngsprogramm runter und erstellen sie ihren
197                                  Monsterstreifen lokal.';
198                     break; 
199                 } elseif(strlen($input_binary) == 0) {
200                     $errors[] = 'Sie haben keine Daten eingegeben, obwohl direkte Byteeingabe als
201                                  Datenquelle ausgewählt wurde!';
202                     break;
203                 }
204                 // so, jetzt liegts als $input_binary vor.
205                 break;
206    case 'font': // Text, der gepuncht werden soll
207                 $text = get('data-text');
208                 if(!preg_match('/^[a-zA-Z0-9 ]+$/', $text)) {
209                     $warnings[] = 'Im Text befinden sich nichtdruckbare Zeichen. Nur Buchstaben und Zahlen
210                                    können dargestellt werden, keine anderen Zeichen.';
211                 }
212                 if(strlen($text) == 0) {
213                     $errors[] = 'Sie haben keinen Text eingegeben, obwohl Textgenerierung als Datenquelle
214                                  ausgewählt wurde!';
215                 }
216                 if(strlen($text) > 1000) {
217                     $errors[] = 'Der Text ist mit über 1000 Zeichen eindeutig zu lang.
218                                  Aus Perfomancegründen ist das nicht erlaubt. Laden sie sich die
219                                  entsprechenden Programme runter und erstellen sie ihren Streifen lokal.';
220                 }
221                 // irgendwas mit dem Text machen.
222                 // und als $input_binary fertig machen.
223                 $input_binary = 'abc';
224                 break;
225    default:     $errors[] = "Ungültige Datenquelle! Es konnten keine Daten entgegengenommen werden!";
226}
227
228// 2/6: Formatfragen.
229$format = strtolower(get('format'));
230if($format != 'png' && $format != 'svg') {
231    $errors[] = "Ungültiges Ausgabeformat <i>$format</i>! Erlaubt sind nur PNG und SVG!";
232}
233
234// 3/6: Dimensionen
235$dsrc = get('dimension-src');
236if($dsrc == 'width' || $dsrc == 'height' || $dsrc == 'diameter') {
237    $size = get("dimension-$dsrc");
238    if(!my_ctype_digit($size)) {
239        $errors[] = "Die Größenangabe zu den Dimensionen, die der Lochstreifen annehmen soll,
240                     ist fehlerhaft: $size ist keine positive ganze Dezimazahl!";
241    } elseif($dsrc == 'diameter' && $size > 100) {
242        $errors[] = "Der Durchmesser eines Loches ist mit 100 pxieln zu groß, ein so großes Bild
243                     darf aus Perfomancegründen nicht generiert werden. Bitte kleineren Wert
244                     einstellen.";
245    } elseif($size > 1000*100) {
246        $errors[] = "Die Größenangabe von über 100.000 Pixel ist viel zu groß. Bitte kleineren Wert
247                     einstellen.";
248    }
249    // alles klar. $size und $dsrc
250} else
251    $errors[] = "Es wurde keine Größenangabe zum Lochstreifen gemacht!";
252
253
254// 4/6: Ausrichtung des Lochstreifens
255$alignment = get('alignment');
256if(preg_match('/^(hor)-(rtl|ltr)-([ou])$|^(ver)-(btt|ttb)-([lr])$/', $alignment, $m)) {
257    // so, jetzt mal zusammenpuzzeln...
258} else
259    $errors[] = "Ungültige Ausrichtung des Lochstreifens: $alignment war nicht in der Auswahl!";
260
261
262// 5/6: Den ganzen komponentenweiten Kram
263$comp = array('imagebg', 'tapebg', 'punched', 'notpunched', 'feedholes');
264$comp_visibility = array(); $comp_color = array();
265$comp_translation = array('Bildhintergrund', 'Lochstreifen', 'Löcher', 'Nicht-Löcher', 'Führungslöcher');
266
267foreach($comp as $x => $component) {
268    $comp_visibility[$x] = get("show-$component") ? 1 : 0;
269    $color = substr(get("color-$component"), 1); // das "#" wegstrippen
270    $lucency = get("lucency-$component");
271    if(!preg_match('/^[0-9a-fA-F]{6}$/', $color)) {
272        $errors[] = "Die Farbangabe <i>$color</i> für den Komponenten <i>$component</i> ist keine korrekte Hexadezimalfarbangabe.";
273        continue;
274    } elseif(!preg_match('/^[0-9a-fA-F]{2}$/', $lucency)) {
275        $errors[] = "Die Transparenzangabe <i>$lucency</i> für den Komponenten <i>$component</i> ist nicht korrekt.";
276        continue;
277    }
278    $comp_color[$x] = "#${color}${lucency}";
279}
280
281// 6/6: Empty-start, Empty-End
282$empty_start = get('empty-start');
283$empty_end = get('empty-end');
284if(!my_ctype_digit($empty_start))
285    $errors[] = "Die Anzahl leerer Startbytes ist keine positive ganze Zahl ($empty_start)";
286if(!my_ctype_digit($empty_end))
287    $errors[] = "Die Anzahl leerer Endbytes ist keine positive ganze Zahl ($empty_end)";
288
289// fertig.
290
291// Fehler ausgeben und beenden.
292if(!empty($errors)) {
293    exit_errors();
294}
295
296// keine Fehler aufgetreten und in Ajax-Mode: "ok" zurückgeben
297if($ajax) {
298    echo "ok";
299    exit;
300}
301
302// Wenn wir hier sind, gehts schon mal weiter.
303
304echo '<h2>Lochstreifengenerator</h2>';
305
306if(!empty($warnings)) {
307    // es gibt Warnungen...
308    echo '<p>Es sind Probleme aufgetaucht, die allerdings nicht wirklich schlimm sind, der
309          Lochstreifen wurde trotzdem generiert:</p>';
310    foreach($warnings as $error) {
311        print '<p class="big-warning">'.$error."</p>\n";
312    }
313}
314
315// so, Parameter zusammenfummeln.
316
317$exec_params = '';
318
319// 2/6: Format:
320$exec_params .= "-f$format ";
321
322// 6/6 Empty Bytes:
323if($empty_start) $exec_params .= "--empty-start=$empty_start ";
324if($empty_end)   $exec_params .= "--empty-end=$empty_end ";
325
326// 5/6 Komponenten
327foreach($comp as $x => $component) {
328    if($comp_visibility[$x]) {
329        $exec_params .= "--color-$component=".$comp_color[$x].' ';
330    } else {
331        $exec_params .= "--hide-$component ";
332    }
333}
334
335// 3/6  Dimensionen
336$exec_params .= "--$dsrc=$size";
337
338// 4/6 Transformations and Rotations
339$exec_params .= $transformation_string.' ';
340
341// Output Filename erstellen
342$source_range = array_merge(range('a','z'), range('0', '9'));
343$output_hash = '';
344foreach(array_rand($source_range, 10) as $x) { $output_hash .= $source_range[$x]; }
345/* //alternativ sowas wie:
346$tmpx = mt_rand(0,32); // tempoaer fuer nen kurzen hash
347if($tmpx-32 < 10) $tmpx *= -1;
348$output_hash = substr(md5(rand() * time()), $tmpx, $tmpx+10);*/
349
350$image_filename = $output_dir.'/'.$output_hash.'.'.$format;
351$exec_params .= "--output=$image_filename";
352
353// 1/6 Input Data
354if($input_source == 'file') {
355    $exec_params .= "  '".$input_filename."'";
356} else {
357    // Binäre Daten liegen als $input_binary vor und wollen
358    // per STDIN eingefüttert werden.
359}
360
361print "<p>Der Lochstreifen wird nun generiert...\n";
362flush(); // damit er das wenigstens sieht...
363
364if($verbose) {
365    print "<h2>Verbose-Ausgaben</h2>";
366    print "<p>Alles zusammengepanscht ergibt:</p>";
367    print "<tt>$draw_program $exec_params</tt>";
368    print "<p>Rufe auf...\n";
369}
370
371// in PHP brauchts nen mörderischen Aufwand, um jetzt dieses
372// Programm anzuschmeißen:
373
374$proc_ressource = proc_open("time $draw_program ".($verbose?'--verbose ':' ').$exec_params, array(
375    // descriptor array (0=stdin, 1=stdout, 2=stderr, like sh)
376    0 => array('pipe', 'r'), // Programm wird von STDIN lesen
377    1 => array('pipe', 'w'), // und zu STDOUT schreiben
378    2 => array('pipe', 'w'), // und zu STDERR auch schreiben
379), $pipes, NULL , NULL );
380
381if(is_resource($proc_ressource)) {
382    if($input_source != 'file') {
383        // Daten reinschreiben
384        fwrite($pipes[0], $input_binary);
385    }
386    fclose($pipes[0]); // nichts mehr zu schreiben
387
388    // STDOUT/STDERR lesen
389    $stdout = stream_get_contents($pipes[1]); 
390    $stderr =  stream_get_contents($pipes[2]); // fuer Speicherung der <times>-Ausgaben.
391
392    fclose($pipes[1]);
393    fclose($pipes[2]);
394    $return_value = proc_close($proc_ressource);
395
396    if($return_value) {
397        print "<p class='big-error'>Fehler: Generator wurde nicht ordnungsgemäß ausgeführt, das
398               Programm beendete mit <u>Statuscode $return_value</u>.</p>";
399    }
400
401    if($return_value || $verbose) {
402        if(!$verbose) {
403            print "<p>Folgende Ausgaben wurden zwecks Fehlersuche abgefangen:</p>\n";
404            print "<p>Aufruf: <tt>$draw_program $exec_params</tt>";
405        }
406
407        print "<pre>";
408        print "<b>STDOUT:</b>\n";
409        echo $stdout;
410
411        print "\n<b>STDERR:</b>\n";
412        echo $stderr;
413        print "</pre>";
414        print "\n<b>Return Value $return_value</b>\n";
415
416    }
417
418    // checken ob was gemacht wurde.
419    if(!is_file($image_filename)) {
420        print "<p class='big-error'>Gewünschtes Bild konnte nicht erstellt werden!</p>";
421        exit; // dann brauchts auch kein Report und so. Der braucht nämlich die Datei.
422    }
423} else
424    print '<p class="big-error">Konnte Generatorprozess nicht starten!</p>';
425
426// + Übersichtsseite machen, erst mal in String, und ausgeben.
427$dir_url = dirname($_SERVER['PHP_SELF']);
428$image_url = "$dir_url/$image_filename";
429$report_file = $output_dir.'/'.$output_hash.'.htm';
430$report_url = "$dir_url/$report_file";
431$filesize = DataSizeFormat(filesize($image_filename));
432
433$report = "<p>Der folgende Lochstreifen wurde am <b>".date('m.d.Y')." um ".date('H:i:s')." Uhr</b> von dem
434              Besucher mit der <b>IP-Adresse $_SERVER[REMOTE_ADDR]</b> generiert. Die erstellte Datei vom
435              Typ <b>".strtoupper($format)."</b> ist <b>$filesize</b> groß";
436
437if($format == 'png') {
438    $imagesize = GetImageSize($image_filename);
439    $report .= ", sie hat die Ausmaße von <b>$imagesize[0] x $imagesize[1]</b> Pixel.</p>\n";
440    $report .= "<p>Das Bild wurde gespeichert unter der Adresse <b><a href='$image_url'>$image_url</a></b>
441                und kann z.B. zur Weiterverwendung runtergeladen werden. Es sieht so aus:</p>
442                <p><img src='$image_url' alt='Der generierte Lochstreifen' $imagesize[2]></p>";
443} else {
444    $report .= ".</p><p>Das Bild wurde unter der Adresse <b><a href='$image_url'>$image_url</a></b> gespeichert.
445                Mit einem modernen Browser (Nicht Internet Explorer) können sie sich die SVG-Datei durch
446                Anklicken des Linkes anschauen. Laden sie sich (ansonten) die Datei runter und öffnen sie
447                es mit einem Vektorgrafikprogramm, z.B. mit dem frei erhältlichen <a href='www.inkscape.org'
448                >Inkscape</a>.</p>";
449}
450
451// Discmailer ;-)
452$report .= "<p>Bitte beachten sie: Die Verfügbarkeit des Bildes auf diesem Server gehört nicht in den
453            \"Dienstleistungsumfang\" des Generierungsprogramms. Das heißt, dass sie <u>durch Eingeben ihrer
454            Daten zugestimmt haben, dass diese mit dem Bild nach freiem Ermessen des Administrators gespeichert
455            werden und willkürlich gelöscht werden können</u>. Es besteht kein Anspruch auf selbst zeitlich
456            begrenztes Hosting! Wenn sie das Bild im Internet verfügbar machen wollen, können sie es z.B.
457            auf kostenlosen Bilderhostern hochladen. Suchen sie dazu mit der Suchmaschine ihres Vertrauens
458            nach so etwas wie z.B. \"<a href='http://www.google.de/search?q=free+image+hosting'
459            >image hosting</a>\"</i></p>";
460
461$report .= "<h3>Die Daten</h3>";
462
463// Daten als HEX aufbereiten
464if($input_source == 'file')
465    $input_binary = file_get_contents($input_filename);
466$report_input_source = array(
467    'file' => "als eine Datei mit dem Namen <b>$original_filename</b> hochgeladen",
468    'input' => "<b>$form</b>-kodiert eingetippt",
469    'font' => "als zu generierende Schrift eingetippt, zugrunde lag der Text <b>$text</b>"
470);
471
472$report .= "<p>Die Daten, die dem generierten Lochstreifen zugrundeliegen, wurden vom Benutzer
473            $report_input_source[$input_source]. Im folgenden wird ein Hexdump der <b>".strlen($input_binary)."
474            Bytes</b> angegeben, mit denen letztendlich der Lochstreifen generiert wurde. Mit geeigneten
475            Hilfmitteln (z.B. einem Hexeditor) können sie aus den Daten eine Binärdatei erstellen.";
476
477$report .= "<pre>";
478for($x=0; $x<strlen($input_binary); $x++) {
479    $report .= sprintf("%02x ", ord($input_binary[$x]));
480    if((($x+1) % 20) == 0) {
481        $report .= "\n";
482    }
483}
484$report .= "</pre>";
485
486// weitere Parameter abhandeln.
487
488$report .= "<h3>Weitere Parameter</h3>";
489
490$report .= "<p>Folgende Einstellungen/Farben liegen dem Lochstreifen zugrunde:</p><ul>";
491
492foreach($comp as $x => $c) {
493    $report .= "<li><b>$comp_translation[$x]</b> ($c): ".
494               ($comp_visibility[$x] ? "sichtbar, und zwar mit der Farbe <b>$comp_color[$x]</b> (Format #RRGGBBAA)"
495                                     : "nicht sichtbar (deaktiviert)");
496}
497
498$report .= "</ul>";
499
500$report .= "<p>Außerdem wurden <b>$empty_start leere Startbytes und $empty_end leere Endbytes</b> eingestellt.
501            Die eingestellte Rotation des Lochstreifens wird durch das folgende Bild verdeutlicht:</p>
502            <img src='$dir_url/design/$alignment.png' alt='$alignment'>
503            <p>Die Größe des Lochstreifens wurde von der Dimension <b>$dsrc</b> abhängig gemacht und auf
504            <b>$size</b> eingestellt.</p>";
505
506$report .= "<h3>Generierung</h3>";
507
508$report .= "<p>Mit dem Kommandozeilentool führ(t)en folgende <b>Parameter</b> zu der Generierung eines derart
509            gewünschten Lochstreifens:
510            <br><tt>$exec_params</tt>
511            <br>Durch Eingabe dieser Parameter mit den oben angezeigten Eingabedaten müsste jederzeit
512            das gleiche Bild reproduzierbar sein.</p>";
513
514$report .= "<!-- STDOUT:\n$stdout\n\nSTDERR:\n$stderr\n\n-->"; // debugging...
515
516$report .= "<p>Das Generieren des Lochstreifens nahm die folgende <b>Zeit in Anspruch</b>:<pre>$stderr</pre>
517            <p>Dabei steht <i>real</i> für die wirklich vergangene Zeit, die der Benutzer warten musste,
518            bevor er seinen Lochstreifen bekam, <i>user</i> für die tatsächliche Zeit, die das Programm
519            aktiv war (Abweichungen zu <i>real</i> können dadurch begründet sein, dass der Server noch
520            andere Sachen gleichzeit machte) und <i>system</i> für die Zeit, in der der Server wirklich
521            ernsthaft über den Lochstreifen nachgedacht hat ;-)</p>";
522
523//// REPORT zuende. Jetzt erst mal ausdrucken.
524
525if(!$verbose) echo "fertig</p>\n"; // als Antwort auf die "wird nun generiert..."-Ausgaben weit oben.
526echo "<p>Mit dem generierten Bild wurde eine Urkunde erstellt, in der alle Parameter, Daten und sonstige
527         interessante Dinge festgehalten sind. Es folgt nur dessen Inhalt:</p>";
528
529echo "<div class='big-okay' style='font-weight:normal'>"; // ;)
530echo $report;
531echo "</div>";
532
533echo "<p>Diese \"Urkunde\" wurde mit dem Bild zusammen gespeichert. Sie ist unter einer ähnlichen Adresse
534      wie das Bild erreichbar, und zwar unter <b><a href=\"$report_url\">$report_url</a></b>.</p>";
535
536echo "<p>Möchten sie noch etwas stanzen? <a href='$dir_url'>Erneut zum Stanzereingabeformular</a></p>";
537
538// und jetzt abspeichern!
539$fh = fopen($report_file, 'w');
540
541if(!$fh) {
542    print '<p class="big-error">Fehler: Konnte Report-File '.$report_file.' nicht zum Schreiben öffnen!</p>';
543    exit; // weil gibts ja nichts mehr zu tun.
544}
545
546fwrite($fh, makeHeader("Lochstreifen $output_hash -- Erstellungsbericht"));
547fwrite($fh, "<h2>Lochstreifen $output_hash</h2>");
548fwrite($fh, $report);
549fwrite($fh, "</body></html>");
550
551fclose($fh);
552
553// so, jetzt aber wirklich fertig. :)
554
555function DataSizeFormat($size,$ukb = "1024",$plain = "")
556{
557    // immer wieder eine schöne Funktion, die man sich von seinen
558    // alten Scripten immer wieder neu kopiert ;-)
559    $kb = $ukb;        // Kilobyte
560    $mb = $ukb * $kb;  // Megabyte
561    $gb = $ukb * $mb;  // Gigabyte
562    $tb = $ukb * $gb;  // Terabyte
563    $sp = '&nbsp;';    // No breaking space
564
565    if($size < $kb) {
566        $readable = $size;
567        $definition = $sp.'Byte';
568    }elseif($size < $mb) {
569        $readable = ($size/$kb);
570        $definition = $sp.'KB';
571    }elseif($size < $gb) {
572        $readable = ($size/$mb);
573        $definition = $sp.'MB';
574    }elseif($size < $tb) {
575        $readable = ($size/$gb);
576        $definition = $sp.'GB';
577    }else {
578        $readable = ($size/$tb);
579        $definition = $sp.'TB';
580    }
581    if ($plain == 1) {
582        $definition = "";
583    }
584    if ($size < $kb) {
585        if (empty($readable)) {
586            $readable = 0;
587        }
588        return $readable.$definition;
589    } else {
590        return number_format($readable,2).$definition;
591    }
592}
593
Note: See TracBrowser for help on using the repository browser.
© 2008 - 2013 technikum29 • Sven Köppel • Some rights reserved
Powered by Trac
Expect where otherwise noted, content on this site is licensed under a Creative Commons 3.0 License