Changeset 3 in projects

Timestamp:

Jul 19, 2008, 2:16:27 PM (15 years ago)

Author:

sven

Message:

Das Lochstreifenvisualisierungsprogramm wurde komplett umgeschrieben. Die
Datei gtkprogram.c wurde aufgeteilt in ein neues Objekt, GtkPaperTape,
welches alle Zeichenoperationen mit dem Lowlevel-Objekt LOCHSTREIFEN
abgleicht sowie zahlreiche GUI-Menues und aehnliches zur Verfuegung stellt.
Letztlich sieht die Verzeichnisstruktur jetzt so aus:

• lochstreifen.c, lochstreifen.h: Das LOCHSTREIFEN Cairo-Zeichenobjekt
• gtkpapertape.c, gtkpapertape.h: Das GtkPaperTape GTK-Widget
• gtk.c: Ein GTK-Programm, welches das GtkPaperTape-Widget in einem Fenster anzeigt.
• cli.c: Ein Kommandozeilenprogramm, welches ein Kommandozeileninterface (per Aufrufparameter) fuer das LOCHSTREIFEN-Objekt bietet

Location:

visualisator

Files:

• Makefile (modified) (1 diff)
• cli.c (moved) (moved from visualisator/create-image.c)
• gtk-ohne-widget.c (copied) (copied from visualisator/gtkprogram.c) (10 diffs)
• gtk.c (moved) (moved from visualisator/gtkprogram.c) (1 diff)
• gtkpapertape.c (added)
• gtkpapertape.h (added)
• gtkprogram (modified) (previous)
• lochstreifen.c (modified) (8 diffs)
• lochstreifen.h (modified) (1 diff)
• test.png (deleted)

visualisator/Makefile

@@ -12 +12 @@
         gcc -o binary $(CAIROFLAGS) create-image.c $(BACKEND)
         
-gtk: gtkprogram.c $(BACKEND)
-        gcc -o gtkprogram $(GTKFLAGS) gtkprogram.c $(BACKEND)
+gtk: gtk.c $(BACKEND)
+        gcc -o gtkprogram $(GTKFLAGS) gtkpapertape.c gtk.c $(BACKEND)
 
 

visualisator/gtk-ohne-widget.c

@@ -37 +37 @@
 #include <string.h> // strlen()
 #include <gtk/gtk.h>
-#include "lochstreifen.h"
+#include "gtkpapertape.h"
 
 #include <time.h> // NUR WAEHREND DEBUGGING 
@@ -45 +45 @@
 // Muss leider global sein, damit ein Zugriff von mehreren Funktionen moeglich ist
 GtkWidget *window; // Hauptfenster
-GtkWidget *lochstreifen_widget, *lochstreifen_statusbar; // Widget, das Lochstreifen haelt, Statusleiste
-LOCHSTREIFEN *lochstreifen; // das Lochstreifen-Objekt
 GTimer *last_statusbar_update; // fuer Statusbar-Prioritaetenbehandlung
 GtkWidget *fit_screen_toggle; // Auswahlbox im Ansichtmenue, um Autozoom umzuschalten.
@@ -87 +85 @@
 void message_error(gchar *heading, gchar *text);
 
-GtkWidget *fast_stock_menuitem(const GtkWidget *parentmenu, const gchar *stock_id) {
-    /* erzeugt schnell mal ein menuitem mit dem entsprechenden Stock-Dingsda
-       und gibt es zurueck */
-    GtkWidget *menuitem;
-    menuitem = gtk_image_menu_item_new_from_stock(stock_id, NULL);
-    gtk_menu_shell_append (GTK_MENU_SHELL (parentmenu), menuitem);
-    gtk_widget_show (menuitem);
-    return menuitem;
-}
-
-GtkWidget *fast_menuitem(const GtkWidget *parentmenu, const gchar *label) {
-    /* erzeugt schnell mal ein menuitem mit der entsprechenden Beschriftung und gibts
-       zurueck */
-    GtkWidget *menuitem;
-    menuitem = gtk_menu_item_new_with_label(label);
-    gtk_menu_shell_append (GTK_MENU_SHELL (parentmenu), menuitem);
-    gtk_widget_show (menuitem);
-    return menuitem;
-}
-
-
-GtkWidget *fast_menu_tearoff(const GtkWidget *parentmenu) {
-    /* Schnell mal ein Abreissitem hinzufuegen */
-    GtkWidget *menuitem;
-    menuitem = gtk_tearoff_menu_item_new ();
-    gtk_menu_shell_append (GTK_MENU_SHELL (parentmenu), menuitem);
-    gtk_widget_show (menuitem);
-    return menuitem;
-}
-
-GtkWidget *fast_menu_seperator(const GtkWidget *parentmenu) {
-    /* Schnell einen Seperator */
-    GtkWidget *menuitem;
-    menuitem = gtk_separator_menu_item_new();
-    gtk_menu_shell_append(GTK_MENU_SHELL(parentmenu), menuitem);
-    gtk_widget_show(menuitem);
-    return menuitem;
-}
-
-void redraw_lochstreifen(gboolean i_have_resized_the_lochstreifen) {
-    /**
-     * Zentrale Funktion zum Aufrufen um den Lochstreifen manuell neu
-     * zu zeichnen. Wenn der Parameter TRUE ist, wird signalisiert,
-     * dass die Groesse des Lochstreifens sich (wie auch immer) geaendert
-     * hat (neue Daten, Zoom, etc. pp) -- also wird ggf. ein neues
-     * size request abgesetzt, je nach Zoomeinstellungen (Autozoom!)
-     **/
-    if(i_have_resized_the_lochstreifen) {
-        if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(fit_screen_toggle))) {
-            // Lochstreifengroesse wird automatisch dem Fenster angepasst,
-            // dafuer werden die size requests anders gestellt, damit kein nervender
-            // Scrollbalken fuer die angepasste Dimension kommt.
-            // siehe transform_fit_lochstreifen
-           if(lochstreifen_get_orientation(lochstreifen) == 1)
-               // Mindestdimensionen: Breite festgelegt durch Daten, Hoehe variabel
-               gtk_widget_set_size_request(lochstreifen_widget, lochstreifen_get_width(lochstreifen), -1);
-           else
-               gtk_widget_set_size_request(lochstreifen_widget, -1, lochstreifen_get_height(lochstreifen));
-        } else {
-            // Lochstreifengroesse wird nicht automatisch dem Fenster angepasst.
-            // Ganz normal Breite und Hoehe wuenschen.
-            gtk_widget_set_size_request(lochstreifen_widget, // neue Groesse erfordern.
-                lochstreifen_get_width(lochstreifen),
-                lochstreifen_get_height(lochstreifen));
-        }
-    } // i have resized...
-    gtk_widget_queue_draw(lochstreifen_widget); // neuzeichnen.
-}
-
-gboolean export_lochstreifen(GtkWidget *widget, gchar *format) {
-    cairo_surface_t *surface;
-    cairo_t *cr;
-    cairo_status_t status;
-    GtkWidget *chooser;
-    char *filename;
-
-    // gewuenschten Dateinamen kriegen
-    chooser = gtk_file_chooser_dialog_new(
-        g_strdup_printf("Dateiname fuer %s-Export auswaehlen", format),
-        GTK_WINDOW(window),
-        GTK_FILE_CHOOSER_ACTION_SAVE,
-        GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
-        GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
-        NULL);
-    gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(chooser), TRUE);
-
-    if(gtk_dialog_run(GTK_DIALOG(chooser)) == GTK_RESPONSE_ACCEPT) {
-        filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(chooser));
-    }
-    gtk_widget_destroy(chooser);
-
-    lochstreifen_flush_only_start_area(lochstreifen); // damit der ganze Lochstreifen gezeichnet wird,  vgl. expose_lochstreifen
-    if(strcmp(format, "PNG") == 0) {
-        // PNG erstellen
-        surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
-            lochstreifen_get_width(lochstreifen),
-            lochstreifen_get_height(lochstreifen)
-        );
-        cr = cairo_create(surface);
-        lochstreifen_draw(lochstreifen, cr);
-        status = cairo_surface_write_to_png (surface, filename);
-        message_statusbar(
-            g_strdup_printf("PNG-Datei (%d x %d Pixel, 24bit) wurde exportiert: %s",
-                lochstreifen_get_width(lochstreifen),
-                lochstreifen_get_height(lochstreifen),
-                cairo_status_to_string(status))
-        );
-    } else if(strcmp(format, "SVG") == 0) {
-        // SVG erstellen
-        double width,height;
-        // SVG-Surface erwartet Breite in Punkt, 1pt = 1/72 inch
-        width = 72 * lochstreifen_get_width(lochstreifen) / (double)fast_get_dpi();
-        height = 72 * lochstreifen_get_height(lochstreifen) / (double)fast_get_dpi();
-        // irgendwie spinnt der Compiler und meint ohne den folgenden unsinnigen
-        // exipliten Typcastings "Warnung: Zuweisung erzeugt Zeiger von Ganzzahl ohne Typkonvertierung"
-        surface = (cairo_surface_t *)cairo_svg_surface_create((char*)filename, (double)width, (double)height);
-
-        cr = cairo_create(surface);
-        lochstreifen_draw(lochstreifen, cr);
-
-        message_statusbar(
-            g_strdup_printf("SVG-Datei (%.2f x %.2f Punkt) wurde exportiert: %s",
-                width, height,
-                cairo_status_to_string(cairo_surface_status(surface))
-            )
-        );
-    } else {
-        message_statusbar("Gewuenschter Exporttyp nicht feststellbar!");
-    }
-
-    cairo_surface_destroy(surface);
-    cairo_destroy(cr);
-    g_free(filename);
-}
-
-gboolean null_bytes_dialog (GtkWidget *widget, gpointer data) {
-    GtkWidget *dialog, *table, *input_start, *input_end, *label;
-    GtkWidget *box;
-
-    dialog = gtk_message_dialog_new(GTK_WINDOW(window),
-        GTK_DIALOG_DESTROY_WITH_PARENT,
-        GTK_MESSAGE_QUESTION,
-        GTK_BUTTONS_OK_CANCEL,
-        "Nullbytes");
-    gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
-        "Am Anfang und am Ende der angezeigten Datei koennen\n"
-        "zusaetzliche \"virtuelle\" Nullbytes angezeigt werden,\n"
-        "die in der Datei nicht gespeichert sind. Je nach Farbeinstellung\n"
-        "sieht man nur Fuehrungsloecher - damit sieht der\n"
-        "Lochstreifen realistischer aus.");
-
-    input_start = gtk_spin_button_new_with_range(0., 10000., 1.);
-    gtk_spin_button_set_value(GTK_SPIN_BUTTON(input_start), (gdouble)lochstreifen->empty_start);
-    input_end = gtk_spin_button_new_with_range(0., 10000., 1.);
-    gtk_spin_button_set_value(GTK_SPIN_BUTTON(input_end), (gdouble)lochstreifen->empty_end);
-
-    box = gtk_table_new(2, 2, FALSE);
-    gtk_table_set_row_spacings(GTK_TABLE(box), 5);
-    label = gtk_label_new("Nullbytes am Anfang: ");
-    gtk_table_attach_defaults(GTK_TABLE(box), label,
-       0, 1, 0, 1); 
-    gtk_table_attach_defaults(GTK_TABLE(box), input_start,
-       1, 2, 0, 1); 
-    label = gtk_label_new("Nullbytes am Ende: ");
-    gtk_table_attach_defaults(GTK_TABLE(box), label,
-       0, 1, 1, 2); 
-    gtk_table_attach_defaults(GTK_TABLE(box), input_end,
-       1, 2, 1, 2); 
-
-    gtk_container_add(GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
-                       box);
-    gtk_widget_show_all (dialog);
-
-    if(gtk_dialog_run(GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) {
-        lochstreifen->empty_start = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(input_start));
-        lochstreifen->empty_end = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(input_end));
-        message_statusbar(
-            g_strdup_printf("Vorne werden nun %d Nullbytes angezeigt, hinten %d.",
-                lochstreifen->empty_start, lochstreifen->empty_end)
-        );
-
-        redraw_lochstreifen(TRUE);
-    } else
-        message_statusbar("Anzahl der Nullbytes wurde nicht veraendert.");
-    gtk_widget_destroy (dialog);
-}
-
-gboolean expose_lochstreifen(GtkWidget *widget, GdkEventExpose *event, gpointer data) {
-    /* Calllback für das "expose_event" - Zeichenevent */
-    cairo_t *cr;
-    time_t TIME;
-    time(&TIME);
-    //LOCHSTREIFEN *l;
-    
-    // mal testen:
-    gdk_window_clear_area(widget->window,
-        event->area.x, event->area.y, event->area.width, event->area.height);
-    
-    cr = gdk_cairo_create(widget->window);
-    //l = (LOCHSTREIFEN *)data;
-
-    printf("%d Neuzeichnen: x|y = (%d|%d), width*height = %d * %d\n", TIME,
-                        event->area.x, event->area.y,
-                        event->area.width, event->area.height);
-    // Clipping, um das Neuzeichnen zu beschleunigen. Ist das sinnvoll?
-    /*cairo_rectangle (cr,
-                        event->area.x, event->area.y,
-                        event->area.width, event->area.height);
-    cairo_clip (cr);*/
-    
-    
-    lochstreifen_set_only_start_area(lochstreifen,
-                        event->area.x, event->area.y,
-                        event->area.width, event->area.height);
-     
-    lochstreifen_draw(lochstreifen, cr);
-    /*printf("Fertig (real width*height = %d * %d)\n", lochstreifen_get_width(lochstreifen),
-        lochstreifen_get_height(lochstreifen));
-    */
-    cairo_destroy(cr);
-    return FALSE;
-}
-
-int fast_get_dpi() {
-    /**
-     * Mal schnell die Aufloesung als Ganzzahl zurueckgeben.
-     * Der Rueckgabewert gibt also die Anzahl der Pixel an, die auf dem Monitor
-     * einen Zoll breit sein sollten...
-     **/
-    GdkScreen *screen = gdk_screen_get_default();
-    if(screen == NULL) {
-        printf("Konnte GdkScreen zwecks DPI-Auslesung nicht erkennen!\n");
-        return;
-    }
-
-    gdouble dpi = gdk_screen_get_resolution(screen);
-    if(dpi < 0) {
-        printf("Screenresolution (%f) nicht feststellbar\n", dpi);
-        return;
-    }
-    return (int)rint(dpi); // noch sauber runden.
-}
-
-gboolean transform_fit_lochstreifen(GtkWidget *widget, GdkEventConfigure *event, gpointer data) {
-    // Bei Groessenveraenderungen des Lochstreifenwidgets wird dies
-    // aufgerufen, wenn "an Bildschirmgroesse anpassen" gewuenscht ist
-
-    // Das Scrollwidget davon unterrichten, nur noch in einer Richtung zu scrollen, damit
-    // es beim Verkleinern des Fensters nicht meint, genug Platz zu haben und sich die Lochstreifen-
-    // groesse gar nicht anpasst.
-    // muss bloederweise hier gemacht werden, weil man ja nachtraeglich die Ausrichtung des
-    // Lochstreifens aendern koennte.
-    int orientation = lochstreifen_get_orientation(lochstreifen); // 1 = horizontal
-
-    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(gtk_widget_get_parent(gtk_widget_get_parent(lochstreifen_widget))),
-        orientation == 1 ? GTK_POLICY_AUTOMATIC : GTK_POLICY_NEVER,
-        orientation == 1 ? GTK_POLICY_NEVER : GTK_POLICY_AUTOMATIC);
-
-    // Mindestgroessenberechnungen nach redraw_lochstreifen verlagert.
-    if(lochstreifen_get_orientation(lochstreifen) == 1) {
-        // horizontal ausgerichteter Lochstreifen => Hoehe fixieren.
-        lochstreifen_set_d_by_height(lochstreifen, event->height);
-        // Mindestdimensionssetzen verlagert nach redraw_lochstreifen,
-        // damit nicht Datengroessenaenderung die Sachen wieder kaputtmachen
-        // Mindestdimensionen: Breite festgelegt durch Daten, Hoehe variabel
-    } else {
-        // vertikal ausgerichtet => Breite fixieren
-        lochstreifen_set_d_by_width(lochstreifen, event->width);
-        // set size request verschoben nach redraw_lochstreifen, siehe oben
-    }
-
-    redraw_lochstreifen(TRUE);
-    return FALSE;
-}
-
-void transform_lochstreifen(GtkWidget *widget, gpointer data) {
-    char action = *((char *)data);
-    char *status_comment;
-    byte_t status_type = 0; // 0 = nix ersetzen, 1 = Ansicht in % einsetzen, 2 = Drehausrichtung einsetzen
-    if(action == '+') {
-        lochstreifen_set_d(lochstreifen, lochstreifen->d + 3); // vergroessern
-        status_comment = "Ansicht vergroessert auf %d%%";
-        status_type = 1;
-        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(fit_screen_toggle), FALSE); // nicht automatisch anpassen
-    } else if(action == '-') {
-        if(lochstreifen->d - 3 < 1) {
-            message_statusbar("Der Lochstreifen kann nicht kleiner gezeichnet werden!");
-            return;
-        }
-        lochstreifen_set_d(lochstreifen, lochstreifen->d - 3); // verkleinern
-        status_comment = "Ansicht verkleinert auf %d%%";
-        status_type = 1;
-        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(fit_screen_toggle), FALSE); // nicht automatisch anpassen
-    } else if(action == '=') { // 100% = "Lebensgroesse2
-        lochstreifen_set_d(lochstreifen, (int)rint((float)fast_get_dpi()/(float)16)); // ein Loch ist etwa 1/16 Zoll breit
-        status_comment = "Wirkliche Lebensgroesse eingestellt (kann bei falscher Monitoreinstellung abweichen)";
-        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(fit_screen_toggle), FALSE); // nicht automatisch anpassen
-    } else if(action == '[') { // an Bildschirmgroesse anpassen
-        if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))) {
-            // Checkbox wurde aktiviert
-            g_signal_connect(G_OBJECT(lochstreifen_widget), "configure_event", G_CALLBACK(transform_fit_lochstreifen), NULL);
-            // den Container resizen damit die erste Anpassung inkraft tritt
-            gtk_widget_queue_resize_no_redraw(lochstreifen_widget); // neugezeichnet wird unten.
-            status_comment = "Lochstreifen passt sich nun stets dem Anzeigebereich an";
-        } else {
-            // Checkbox wurde deaktiviert
-            g_signal_handlers_disconnect_by_func(G_OBJECT(lochstreifen_widget), G_CALLBACK(transform_fit_lochstreifen), NULL);
-            // Scrollwidget wieder zuruecksetzen.
-            gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(gtk_widget_get_parent(gtk_widget_get_parent(lochstreifen_widget))),
-                GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
-
-            return;
-            // nichts ausgeben, weil auch durch andere Sachen aufgerufen
-        }
-    } else if(action == 'S') { // Statusleiste einblenden/ausblenden
-        if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))) {
-             // Checkbox wurde aktiviert
-             gtk_widget_show(lochstreifen_statusbar);
-             status_comment = "Statusleiste wird (wieder) angezeigt.";
-        } else gtk_widget_hide(lochstreifen_statusbar);
-    } else if(action == '>') { // Drehen mit Uhrzeigersinn
-        //lochstreifen_rotate(lochstreifen);
-        lochstreifen_set_direction(lochstreifen, 4, -1,-1);
-        status_comment = "Lochstreifen im Uhrzeigersinn gedreht (%s)";
-        status_type = 2;
-    } else if(action == '<') { // Drehen gegen Uhrzeigersinn
-        lochstreifen_set_direction(lochstreifen, 5, -1,-1);
-        status_comment = "Lochstreifen gegen Uhrzeigersinn gedreht (%s)";
-        status_type = 2;
-    } else if(action == '_') { // horizontal Spiegeln
-        lochstreifen_set_direction(lochstreifen, -1, 2, -1);
-        status_comment = "Lochstreifen wurde vertikal gespiegelt (Datenreihenfolge umgedreht, d.h. links und rechts vertauscht)";
-    } else if(action == '|') { // vertikal spiegeln
-        lochstreifen_set_direction(lochstreifen, -1, -1, 2);
-        status_comment = "Lochstreifen wurde horizontal gespiegelt (unten und oben vertauscht)";
-    }
-    redraw_lochstreifen(TRUE);
-
-    // Ausgaben fuer Statuszeile vorbereiten
-    if(status_comment == NULL || strlen(status_comment) == 0) return; // gibt nichts zu sagen
-    if(status_type == 1) {
-        // % von realer Groesse angeben.
-        message_statusbar(
-            g_strdup_printf(status_comment, (int)((float)lochstreifen->d / ((float)fast_get_dpi()/(float)16) * 100)) // siehe action=='='
-        );
-    } else if(status_type == 2) {
-        // Ausrichtung angeben als String
-        char *ausrichtung;
-        switch(lochstreifen->drehung) {
-            case 0: ausrichtung = "horizontal, von links nach rechts"; break;
-            case 1: ausrichtung = "vertikal, von oben nach unten"; break;
-            case 2: ausrichtung = "horizontal, von rechts nach links"; break;
-            case 3: ausrichtung = "vertikal, von unten nach oben"; break;
-            default: ausrichtung = "*** ERROR - ungueltige Ausrichtung";
-        }
-        message_statusbar(
-            g_strdup_printf(status_comment, ausrichtung)
-        );
-    } else // status_type == 0
-        message_statusbar(status_comment);
-}
-
-void change_constant_gui(GtkWidget *widget, gpointer data) {
-    // GUI zur Aenderung der Konstanten anzeigen...
-    printf("Pending...\n");
-}
-
-GdkColor *color_cairo2gdk(cairo_pattern_t *pattern);
 
 gboolean open_lochstreifen_file(char *filename) {
@@ -544 +174 @@
 }
 
-void colorize_lochstreifen(GtkWidget *widget, gpointer data) {
-    cairo_pattern_t **target = (cairo_pattern_t **)data; // Doppellink noetig weil Adressaenderung
-    GdkColor color;
-    gtk_color_button_get_color(GTK_COLOR_BUTTON(widget), &color);
-    /*double red, green, blue;
-    printf("Farben gewaehlt: R=%i G=%i B=%i\n",color.red, color.green, color.blue);
-        red = ((double)color.red / (double)G_MAXUINT16); // G_MAXUINT16 = 2^16 weil Farben = guint16
-        green = ((double)color.green / (double)G_MAXUINT16);
-        blue = ((double)color.blue / (double)G_MAXUINT16);
-
-    printf("Farben == R=%f G=%f B=%f\n",
-        red,green,blue);*/
-
-    //if(*target != NULL) cairo_pattern_destroy(*target); // damit nicht sinnlos Speicher zugemuellt wird
-    *target = cairo_pattern_create_rgb(
-        // darauf muss man erst mal kommen: Vorher in double casten, denn sonst
-        // berechnet er einen unsigned short (=guint16), der einfach auf 0 ab oder
-        // auf 1 hochrundet. (double)(guint16/G_MAXUNIT16) gibt also stets 0,000 oder 1,000.
-        (double)((double)color.red / (double)G_MAXUINT16), // G_MAXUINT16 = 2^16 weil Farben = guint16
-        (double)((double)color.green / (double)G_MAXUINT16),
-        (double)((double)color.blue / (double)G_MAXUINT16));
-    //printf("%s\n", cairo_status_to_string(cairo_pattern_status(*target)));
-
-    GdkColor *g = color_cairo2gdk(*target);
-    //printf("Farben zurueck: R=%d G=%d B=%d\n", g->red, g->green, g->blue);
-        //gtk_color_button_get_alpha(GTK_COLOR_BUTTON(widget)) / 65535);
-    redraw_lochstreifen(FALSE);
-    //    gtk_color_button_get_alpha(GTK_COLOR_BUTTON(widget)) / 65535);
-
-    // noch mal schnell RGB-Wert fuer Statuszeile ausgeben
-    message_statusbar(
-        g_strdup_printf("Farbe geaendert auf RGB (%d|%d|%d)",
-        (int)((double)color.red / (double)G_MAXUINT16 * 255),
-        (int)((double)color.red / (double)G_MAXUINT16 * 255),
-        (int)((double)color.red / (double)G_MAXUINT16 * 255)
-        )
-    );
-}
-
-
-GtkWidget *fast_color_menuitem(const GtkWidget *parentmenu, const char *dialog_title, const char *labeltext, GdkColor *initialColor, GtkSizeGroup *label_nice_sizegroup) {
-    /* Schnell ein Colorchooser-Button inklusive Richtextlabel in einem
-       Menuitem einbauen. Gibt das Colorchooserbutton-Widget zurück,
-       initialColor kann NULL sein. GtkSizeGroup auch. */
-    GtkWidget *menuitem, *menubox, *colorbutton, *label;
-    menuitem = gtk_menu_item_new();
-    menubox = gtk_hbox_new(FALSE, 4);
-    gtk_container_add(GTK_CONTAINER(menuitem), menubox);
-    gtk_widget_show(menubox);
-
-    colorbutton = gtk_color_button_new();
-    //gtk_color_button_set_use_alpha(GTK_COLOR_BUTTON(colorbutton), TRUE); // doch kein Alpha, das bringt nichts.
-    gtk_color_button_set_title(GTK_COLOR_BUTTON(colorbutton), dialog_title);
-    gtk_box_pack_start(GTK_BOX(menubox), colorbutton, FALSE, FALSE, 0);
-    gtk_widget_show(colorbutton);
-
-    label = gtk_label_new(NULL);
-    gtk_label_set_markup(GTK_LABEL(label), labeltext);
-    gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_CENTER);
-    gtk_box_pack_start(GTK_BOX(menubox), label, TRUE, TRUE, 0);
-    gtk_widget_show(label);
-
-    g_signal_connect_swapped(menuitem, "activate", G_CALLBACK(gtk_button_clicked), colorbutton);
-
-    if(initialColor != NULL) {
-        //printf("Farben:\n");
-        //printf("\tr%i g%i b%i\n", initialColor->red, initialColor->green, initialColor->blue);
-        gtk_color_button_set_color(GTK_COLOR_BUTTON(colorbutton), initialColor);
-    }
-    if(label_nice_sizegroup != NULL) {
-        gtk_size_group_add_widget(label_nice_sizegroup, label);
-    }
-
-    gtk_widget_show (menuitem);
-    gtk_menu_shell_append (GTK_MENU_SHELL (parentmenu), menuitem);
-    return colorbutton;
-}
-
-GdkColor *color_cairo2gdk(cairo_pattern_t *pattern) {
-    /** Kleine Behelfsfunktion, um von einem Cairopattern die Farbe im GDK-format zu ziehen
-        ALPHA wird ganz nett ignoriert :) */
-    GdkColor *c = malloc(sizeof(GdkColor));
-    double red, green, blue, alpha;
-    if(pattern != NULL)
-        cairo_pattern_get_rgba(pattern, &red, &green, &blue, &alpha);
-    else
-        { red=1; green=1; blue=1; } // pattern ist NULL => nehmen mir mal weiss ;-)
-    c->red = red * 65535; // 2^16
-    c->green = green * 65535;
-    c->blue = blue * 65535;
-    return c;
-}
 
 gboolean startup_sequence_loop(gpointer state) { //real_data_length) {
@@ -706 +244 @@
 }
 
-gboolean update_statusbar(GtkWidget *lochstreifenwidget, GdkEventMotion *event, gpointer egal) {
-    /**
-     * In der Statuszeile beim Ueberfahren des Lochstreifens die aktuellen
-     * Werte anzeigen :-)
-     *
-     **/
-    gchar *msg;
-    int x,y,byte;
-
-    // erst nach 4 Sekunden einer "wichtigen" Nachricht wieder die Statuszeile
-    // mit diesen weniger wichtigen Infos befoelkern.
-    if(last_statusbar_update != NULL && g_timer_elapsed(last_statusbar_update, NULL) < 4) return;
-
-    // Statuszeile auf jeden Fall leeren.
-    gtk_statusbar_pop(GTK_STATUSBAR(lochstreifen_statusbar), 0);
-    byte = lochstreifen_byte_by_coordinate(lochstreifen, (int)event->x, (int)event->y);
-    if(byte > 0) {
-        gchar *msg; byte_t value,bit;
-        value = lochstreifen->data[byte-1]; // weil ab 1 zaehlen => -1 weil array ab 0 zaehlt
-
-        // Bitdarstellung selbst machen (printf hat sowas wohl nicht)
-        char bitdarstellung[9]; bitdarstellung[8] = '\0'; // Nullterminierung
-        for(bit=0; bit<8; bit++) {bitdarstellung[bit] = (((value >> bit) & 0x01) == 0x01) ? '1':'0';}
-
-        msg = g_strdup_printf("Byte %03d von %03d: Wert dez=%03d bin=%s okt=%03o hex=%02X",
-                              byte, lochstreifen->data_length,
-                              value, bitdarstellung, value, value);
-        gtk_statusbar_push(GTK_STATUSBAR(lochstreifen_statusbar), 0, msg);
-        g_free(msg);
-    } else if(byte == 0) {
-        //gtk_statusbar_push(statusbar, 0, "Zeiger befindet sich außerhalb");
-        // Zeiger befindet sich ausserhalb. Nichts hier ausgeben.
-        // d.h. Statusbar wurde exiplit geleert und bleibt leer.
-    } else if(byte == -1) {
-        gtk_statusbar_push(GTK_STATUSBAR(lochstreifen_statusbar), 0,
-            "Mauszeiger befindet sich auf den zusaetzlichen Nullbytes.");
-    }
-
-    return FALSE;
-}
-
-void message_statusbar(char *msg) {
-    /**
-     * Kurze Nachrichten in der Statuszeile anzeigen.
-     * Diese Nachrichten bleiben mindestens 4 Sekunden lang sichtbar, bevor z.B.
-     * die Position des Mauscursors wieder erscheint. Dafuer dient der Timer.
-     **/
-    gtk_statusbar_pop(GTK_STATUSBAR(lochstreifen_statusbar), 0);
-    gtk_statusbar_push(GTK_STATUSBAR(lochstreifen_statusbar), 0, msg);
-    // Statusbar-Timer erst hier einrichten, damit nach Programmstart man nicht
-    // erst 4 Sekunden warten muss.
-    if(last_statusbar_update == NULL)
-        last_statusbar_update = g_timer_new(); // wird automatisch gestartet
-    else
-        g_timer_start(last_statusbar_update); // Timer zuruecksetzen
-}
-
-gboolean scroll_lochstreifen(GtkWidget *lochstreifenwidget, GdkEventScroll *event, gpointer user_data) {
-    /**
-      Beim Scrollen auf dem Widget wird das GTK_SCROLLED_WINDOW (user_data) gescrollt, je nach
-      Ausrichtung des Streifens. Nur eindimensionales Scrolling, nicht 2d. (wer hat schon eine
-      Apple Mighty Mouse ;-) )
-     **/
-    GtkAdjustment* adjustment;
-    gdouble t;
-    if(lochstreifen->drehung % 2 == 0) {
-        // Lochstreifen ist horizontal ausgreichtet
-        adjustment = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(user_data));
-        if(adjustment == NULL) { printf("hadjustment = NULL!\n"); return FALSE; }
-        t = gtk_adjustment_get_value(adjustment) + lochstreifen->d * // um eine Lochbreite scrollen
-                  ((event->direction == GDK_SCROLL_UP || event->direction == GDK_SCROLL_RIGHT) ? -1 : 1);
-                  // nach rechts oder links scrollen
-/*        );
-        printf("Set to %f\n", gtk_adjustment_get_value(adjustment) + (gdouble)adjustment->step_increment * 
-                  (event->direction == GDK_SCROLL_UP || event->direction == GDK_SCROLL_RIGHT) ? (gdouble)1 : (gdouble)-1);*/
-    } else {
-        // nach oben bzw. unten scrollen
-        adjustment = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(user_data));
-        if(adjustment == NULL) { printf("vadjustment = NULL!\n"); return FALSE; }
-        t = gtk_adjustment_get_value(adjustment) + lochstreifen->d * 
-            ((event->direction == GDK_SCROLL_UP || event->direction == GDK_SCROLL_RIGHT) ? -1 : 1);
-          // nach oben oder unten scrollen
-    }
-    printf("Scroll Is: %f | up: %f | down: %f | shall be: %f\n", gtk_adjustment_get_value(adjustment), adjustment->lower, adjustment->upper, t);
-
-    if(t < adjustment->lower) t = adjustment->lower;
-    if(t > adjustment->upper) t = adjustment->upper;
-    gtk_adjustment_set_value(adjustment, t);
-    // geht nicht:
-    //g_signal_emit_by_name(lochstreifen_widget, "motion-notify-event"); // Mauszeigerbewegung simulieren => Statuszeile updaten
-}
-
 int main(int argc, char *argv[]) {
     GtkWidget *mainbox;
@@ -831 +277 @@
         "activate", G_CALLBACK(open_lochstreifen_file_dialog), window);
     fast_menu_seperator(menu);
-    g_signal_connect(G_OBJECT(fast_menuitem(menu, "Grafik als PNG exportieren...")),
-        "activate", G_CALLBACK(export_lochstreifen), "PNG");
-    g_signal_connect(G_OBJECT(fast_menuitem(menu, "Grafik als SVG exportieren...")),
-        "activate", G_CALLBACK(export_lochstreifen), "SVG");
+    gtk_paper_tape_menu_export(menu);
     fast_menu_seperator(menu);
     g_signal_connect(G_OBJECT(fast_stock_menuitem(menu, GTK_STOCK_QUIT)),
@@ -846 +289 @@
     // Zweites Menue: Ansicht
     menu = gtk_menu_new();
-    fast_menu_tearoff(menu);
-    g_signal_connect(G_OBJECT(fast_stock_menuitem(menu, GTK_STOCK_ZOOM_IN)),
-        "activate", G_CALLBACK(transform_lochstreifen), "+");
-    g_signal_connect(G_OBJECT(fast_stock_menuitem(menu, GTK_STOCK_ZOOM_OUT)),
-        "activate", G_CALLBACK(transform_lochstreifen), "-");
-    g_signal_connect(G_OBJECT(fast_stock_menuitem(menu, GTK_STOCK_ZOOM_100)),
-        "activate", G_CALLBACK(transform_lochstreifen), "=");
-    //g_signal_connect(G_OBJECT(fast_stock_menuitem(menu, GTK_STOCK_ZOOM_FIT)),
-    //    "activate", G_CALLBACK(transform_lochstreifen), "[");
-    menuitem = gtk_check_menu_item_new_with_mnemonic("Groesse dem Fenster _anpassen");
-    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), FALSE);
-    g_signal_connect(G_OBJECT(menuitem), "toggled", G_CALLBACK(transform_lochstreifen), "[");
-    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
-    gtk_widget_show (menuitem);
-    fit_screen_toggle = menuitem; // auch hier global speichern, weil es in einer Funktion gebraucht wird.
-
-    g_signal_connect(G_OBJECT(fast_stock_menuitem(menu, GTK_STOCK_PROPERTIES)), //"Groessenverhaeltnisse aendern...")),
-        "activate", G_CALLBACK(change_constant_gui), NULL);
-    fast_menu_seperator(menu);
-    g_signal_connect(G_OBJECT(fast_menuitem(menu, "Drehen im Uhrzeigersinn")),
-        "activate", G_CALLBACK(transform_lochstreifen), ">");
-    g_signal_connect(G_OBJECT(fast_menuitem(menu, "Drehen gegen den Uhrzeigersinn")),
-        "activate", G_CALLBACK(transform_lochstreifen), "<");
-    g_signal_connect(G_OBJECT(fast_menuitem(menu, "Horizontal spiegeln (Datenreihenfolge umkehren)")),
-        "activate", G_CALLBACK(transform_lochstreifen), "|");
-    g_signal_connect(G_OBJECT(fast_menuitem(menu, "Vertikal spiegeln (Bitpositionen drehen)")),
-        "activate", G_CALLBACK(transform_lochstreifen), "_");
-    fast_menu_seperator(menu);
-    g_signal_connect(G_OBJECT(fast_menuitem(menu, "Anzahl Nullbytes einstellen...")),
-        "activate", G_CALLBACK(null_bytes_dialog), NULL);
-    menuitem = gtk_check_menu_item_new_with_mnemonic("_Statusleiste anzeigen");
-    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), TRUE);
-    g_signal_connect(G_OBJECT(menuitem), "toggled", G_CALLBACK(transform_lochstreifen), "S");
-    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
-    gtk_widget_show (menuitem);
+    gtk_paper_tape_menu_view(menu);
 
     menuitem = gtk_menu_item_new_with_mnemonic("_Ansicht");
@@ -889 +298 @@
     // Drittes Menue: Farben
     menu = gtk_menu_new();
-    color_sizes = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
-    fast_menu_tearoff(menu);
-    g_signal_connect(G_OBJECT(fast_color_menuitem(menu, "Farbe des Lochstreifens waehlen",
-        "Farbe des <b>Lochstreifens</b>", color_cairo2gdk(lochstreifen->streifenbg), color_sizes)),
-        "color-set", G_CALLBACK(colorize_lochstreifen), &(lochstreifen->streifenbg));
-    //gtk_color_button_set_color(GTK_COLOR_BUTTON(menuitem), color_cairo2gdk(lochstreifen->streifenbg));
-
-    fast_menu_seperator(menu);
-    g_signal_connect(G_OBJECT(fast_color_menuitem(menu, "Farbe der Loecher waehlen",
-        "Farbe der <b>Loecher</b> waehlen\n(binaere einsen)", color_cairo2gdk(lochstreifen->punched), color_sizes)),
-        "color-set", G_CALLBACK(colorize_lochstreifen), &(lochstreifen->punched));
-    fast_menu_seperator(menu);
-    g_signal_connect(G_OBJECT(fast_color_menuitem(menu, "Farbe der Nicht-Loecher waehlen",
-         "Farbe der <b>Nullen</b> waehlen\n(nicht gelochte Bits)", color_cairo2gdk(lochstreifen->notpunched), color_sizes)),
-        "color-set", G_CALLBACK(colorize_lochstreifen), &(lochstreifen->notpunched));
-    fast_menu_seperator(menu);
-    g_signal_connect(G_OBJECT(fast_color_menuitem(menu, "Farbe der Lochstreifen-Fuehrungsloecher waehlen",
-        "Farbe der <b>Fuehrungs-loecher</b>\nwaehlen (kleine Loecher)", color_cairo2gdk(lochstreifen->fuehrung), color_sizes)),
-        "color-set", G_CALLBACK(colorize_lochstreifen), &(lochstreifen->fuehrung));
-    fast_menu_seperator(menu);
-    g_signal_connect(G_OBJECT(fast_color_menuitem(menu, "Farbe der Hintergrund waehlen",
-        "<b>Hintergrundfarbe</b> waehlen\n(um dem Streifen rum)", color_cairo2gdk(lochstreifen->hintergrund), color_sizes)),
-        "color-set", G_CALLBACK(colorize_lochstreifen), &(lochstreifen->hintergrund));
+    gtk_paper_tape_menu_colors(menu);
 
     menuitem = gtk_menu_item_new_with_mnemonic("_Farben");
@@ -918 +305 @@
     gtk_widget_show (menuitem);
 
-    // So jetzt aber Inhalt: Das Hauptwidget.
-    lochstreifen_set_d(lochstreifen, 20);
+
 
     // Daten einlesen.
@@ -963 +349 @@
     }
 
-    lochstreifen_widget = gtk_drawing_area_new();
-    gtk_widget_set_size_request (GTK_WIDGET (lochstreifen_widget),
-        lochstreifen_get_width(lochstreifen),
-        lochstreifen_get_height(lochstreifen)); // erst mal spasseshalber
-
-    scroll = gtk_scrolled_window_new(NULL, NULL);
-    gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), lochstreifen_widget); // weil nicht scrollable
-    // Scrollbalken nur anzeigen wenn benoetigt
-    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
-    gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll), GTK_SHADOW_NONE);
-    gtk_box_pack_start(GTK_BOX(mainbox), scroll, TRUE, TRUE, 0);
-    gtk_widget_show(scroll);
-
-    gtk_widget_show(lochstreifen_widget);
-    g_signal_connect(G_OBJECT(lochstreifen_widget), "expose_event", G_CALLBACK(expose_lochstreifen), NULL);
-    gtk_widget_add_events(lochstreifen_widget, GDK_POINTER_MOTION_MASK | GDK_SCROLL_MASK); // Mauscursor kriegen, Mausscrolling kriegen
-    g_signal_connect(G_OBJECT(lochstreifen_widget), "motion-notify-event", G_CALLBACK(update_statusbar), NULL);
-    g_signal_connect(G_OBJECT(lochstreifen_widget), "scroll-event", G_CALLBACK(scroll_lochstreifen), scroll);
+    papertape = gtk_paper_tape_new();
+    gtk_box_pack_start(GTK_BOX(mainbox), papertape->scroll, TRUE, TRUE, 0);
+
+    /// signal für Statusbar verbinden zu lokaler Funktion!
 
     // Statusbar hinzufuegen.

visualisator/gtk.c

@@ -1 +1 @@
 /**
- * GTK-Programm, welches mit dem per Cairo gezeichneten Lochstreifen
- * Dateien visualisieren kann.
+ * A simple example GTK program which uses all features of the GtkPaperTape
+ * widget in one window. No extra features, except of:
  *
- * Dabei wird die Flexibilitaet des Cairo-Zeichners voll ausgeschoepft:
- * Beliebige Dateien koennen zum Anzeigen geoeffnet werden, der Loch-
- * streifen kann in saemtlichen Farben frei variiert werden, die
- * anzuzeigenden Emptybytes koennen beliebig gesetzt werden.
- * Die Darstellung kann jederzeit in jede Richtung gedreht und gespiegelt
- * werden, ausserdem ist stufenloser Zoom sowie eine automatische
- * Groessenanpassung moeglich, sodass der Lochstreifen sich immer genau an die
- * Fenstergroesse anpasst und man sinnvoll einfach ueber die Daten "scrollen"
- * kann.
+ *   * handling of command line options by using the glib parser, thus
+ *   * being able to read from stdin or any files
+ *   * menu item to open files in the GUI
  *
- * Die aktuelle Ansicht des Lochstreifens kann einfach als PNG-Bild oder
- * SVG-Vektorgrafik in eine Datei exportiert werden. Die Aenderung der Datei
- * à la "Hexeditor" ist nicht vorgesehen, dafuer werden aber beim Ueberfahren
- * des Lochstreifens in der Statusleiste die Werte des Bytes, ueber dem man
- * sich befindet, aufgeschluesselt.
  *
- * Das Programm ist bewusst unaufdringlich gehalten; die meisten Nachrichten
- * werden ueber die Statuszeile ausgegeben. Die Bedienung erfolgt massgeblich
- * ueber das Menue.
+ * rewritten on 21.06.2008
  *
- * Je nach Kommandozeilenparameter wird von STDIN gelesen oder eine Datei
- * geoeffnet (mehr Informationen mit Aufruf --help).
- * Wird gar kein Parameter angegeben, dann wird eine kleine Startanimation
- * angezeigt, die von der Perfomance und Flexibilitaet des Zeichenprogramms
- * zeugt ;-)
- * 
- * -- Sven, November 2007
  *
  **/
-#include <stdio.h>
-#include <stdlib.h>
-#include <math.h> // rint()
-#include <string.h> // strlen()
-#include <gtk/gtk.h>
-#include "lochstreifen.h"
-
-#include <time.h> // NUR WAEHREND DEBUGGING 
-
-#define WINDOW_TITLE "Lochstreifen-Visualisierung" /* Standardtitel */
-
-// Muss leider global sein, damit ein Zugriff von mehreren Funktionen moeglich ist
-GtkWidget *window; // Hauptfenster
-GtkWidget *lochstreifen_widget, *lochstreifen_statusbar; // Widget, das Lochstreifen haelt, Statusleiste
-LOCHSTREIFEN *lochstreifen; // das Lochstreifen-Objekt
-GTimer *last_statusbar_update; // fuer Statusbar-Prioritaetenbehandlung
-GtkWidget *fit_screen_toggle; // Auswahlbox im Ansichtmenue, um Autozoom umzuschalten.
-gboolean startsequence_running = FALSE; // Ist TRUE, wenn die Startanimation laeuft
-
-// Die Daten, die bei der Startsequenz angezeigt werden, liegen hier als Bytearray
-// vor. Generierung mit
-// $ [generatorprogramm] | hexdump -e '11/1 "0x%02x, " "\n"'
-// "0x  , "-Zeichen wegschneiden.
-// Laenge feststellen mit wc -c
-
-int startsequence_length = 205;
-byte_t startsequence_data[] = {
-0xfc, 0x01, 0x02, 0x01, 0xfc, 0x00, 0x81, 0xff, 0x81, 0x00, 0xff,
-0x01, 0x01, 0x00, 0xff, 0x01, 0x01, 0x00, 0xff, 0x18, 0xc7, 0x00,
-0xff, 0x81, 0xff, 0x00, 0xff, 0x80, 0x60, 0x80, 0xff, 0x00, 0xff,
-0x80, 0x60, 0x80, 0xff, 0x00, 0xff, 0x91, 0x91, 0x00, 0xff, 0x40,
-0x3c, 0x02, 0xff, 0x00, 0x00, 0x00, 0x83, 0xb9, 0xc1, 0x00, 0xff,
-0x01, 0xff, 0x00, 0xff, 0x80, 0x60, 0x80, 0xff, 0x00, 0x00, 0x00,
-0x81, 0xff, 0x81, 0x00, 0xff, 0x40, 0x3c, 0x02, 0xff, 0x00, 0x80,
-0xff, 0x80, 0x00, 0xff, 0x91, 0x91, 0x00, 0xff, 0x88, 0xf7, 0x00,
-0xff, 0x88, 0x88, 0xff, 0x00, 0xff, 0x18, 0xc7, 0x00, 0x80, 0xff,
-0x80, 0x00, 0x81, 0xff, 0x81, 0x00, 0xfc, 0x01, 0xfc, 0x00, 0xff,
-0x91, 0x91, 0x00, 0xff, 0x40, 0x3c, 0x02, 0xff, 0x00, 0x00, 0x00,
-0xff, 0x01, 0x01, 0x00, 0xff, 0x81, 0xff, 0x00, 0xff, 0x81, 0x81,
-0x00, 0xff, 0x10, 0xff, 0x00, 0xf0, 0x91, 0x9f, 0x00, 0x80, 0xff,
-0x80, 0x00, 0xff, 0x88, 0xf7, 0x00, 0xff, 0x91, 0x91, 0x00, 0x81,
-0xff, 0x81, 0x00, 0xff, 0x90, 0x90, 0x00, 0xff, 0x91, 0x91, 0x00,
-0xff, 0x40, 0x3c, 0x02, 0xff, 0x00, 0x83, 0xb9, 0xc1, 0x00, 0xff,
-0x91, 0x91, 0x00, 0x81, 0xff, 0x81, 0x00, 0xff, 0x81, 0x81, 0x00,
-0xff, 0x10, 0xff, 0x00, 0xff, 0x40, 0x3c, 0x02, 0xff, 0x00, 0xff,
-0x91, 0x91, 0x00, 0xff, 0x88, 0xf7, 0x00
-};
-
-// zum Testen:
-/*int startsequence_length = 4;
-byte_t startsequence_data[] = { 0x00, 0x01, 0x02, 0x03 };*/
-
-void message_statusbar(char *msg);
-void message_error(gchar *heading, gchar *text);
-
-GtkWidget *fast_stock_menuitem(const GtkWidget *parentmenu, const gchar *stock_id) {
-    /* erzeugt schnell mal ein menuitem mit dem entsprechenden Stock-Dingsda
-       und gibt es zurueck */
-    GtkWidget *menuitem;
-    menuitem = gtk_image_menu_item_new_from_stock(stock_id, NULL);
-    gtk_menu_shell_append (GTK_MENU_SHELL (parentmenu), menuitem);
-    gtk_widget_show (menuitem);
-    return menuitem;
-}
-
-GtkWidget *fast_menuitem(const GtkWidget *parentmenu, const gchar *label) {
-    /* erzeugt schnell mal ein menuitem mit der entsprechenden Beschriftung und gibts
-       zurueck */
-    GtkWidget *menuitem;
-    menuitem = gtk_menu_item_new_with_label(label);
-    gtk_menu_shell_append (GTK_MENU_SHELL (parentmenu), menuitem);
-    gtk_widget_show (menuitem);
-    return menuitem;
-}
 
 
-GtkWidget *fast_menu_tearoff(const GtkWidget *parentmenu) {
-    /* Schnell mal ein Abreissitem hinzufuegen */
-    GtkWidget *menuitem;
-    menuitem = gtk_tearoff_menu_item_new ();
-    gtk_menu_shell_append (GTK_MENU_SHELL (parentmenu), menuitem);
-    gtk_widget_show (menuitem);
-    return menuitem;
-}
+#include <gtk/gtk.h>
+#include "gtkpapertape.h"
 
-GtkWidget *fast_menu_seperator(const GtkWidget *parentmenu) {
-    /* Schnell einen Seperator */
-    GtkWidget *menuitem;
-    menuitem = gtk_separator_menu_item_new();
-    gtk_menu_shell_append(GTK_MENU_SHELL(parentmenu), menuitem);
-    gtk_widget_show(menuitem);
-    return menuitem;
-}
+#define _(a) (a)
 
-void redraw_lochstreifen(gboolean i_have_resized_the_lochstreifen) {
-    /**
-     * Zentrale Funktion zum Aufrufen um den Lochstreifen manuell neu
-     * zu zeichnen. Wenn der Parameter TRUE ist, wird signalisiert,
-     * dass die Groesse des Lochstreifens sich (wie auch immer) geaendert
-     * hat (neue Daten, Zoom, etc. pp) -- also wird ggf. ein neues
-     * size request abgesetzt, je nach Zoomeinstellungen (Autozoom!)
-     **/
-    if(i_have_resized_the_lochstreifen) {
-        if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(fit_screen_toggle))) {
-            // Lochstreifengroesse wird automatisch dem Fenster angepasst,
-            // dafuer werden die size requests anders gestellt, damit kein nervender
-            // Scrollbalken fuer die angepasste Dimension kommt.
-            // siehe transform_fit_lochstreifen
-           if(lochstreifen_get_orientation(lochstreifen) == 1)
-               // Mindestdimensionen: Breite festgelegt durch Daten, Hoehe variabel
-               gtk_widget_set_size_request(lochstreifen_widget, lochstreifen_get_width(lochstreifen), -1);
-           else
-               gtk_widget_set_size_request(lochstreifen_widget, -1, lochstreifen_get_height(lochstreifen));
-        } else {
-            // Lochstreifengroesse wird nicht automatisch dem Fenster angepasst.
-            // Ganz normal Breite und Hoehe wuenschen.
-            gtk_widget_set_size_request(lochstreifen_widget, // neue Groesse erfordern.
-                lochstreifen_get_width(lochstreifen),
-                lochstreifen_get_height(lochstreifen));
-        }
-    } // i have resized...
-    gtk_widget_queue_draw(lochstreifen_widget); // neuzeichnen.
-}
+gboolean open_file_dialog(GtkWidget *menuitem, GtkPaperTape* papertape) {
+        /**
+         * displays an "open file" dialog which runs gtk_paper_tape_read_from_file() if success,
+         * is run by the menu item "open file"
+         **/
 
-gboolean export_lochstreifen(GtkWidget *widget, gchar *format) {
-    cairo_surface_t *surface;
-    cairo_t *cr;
-    cairo_status_t status;
-    GtkWidget *chooser;
-    char *filename;
+        GtkWidget *chooser;
+        chooser = gtk_file_chooser_dialog_new(
+                _("Select (binary) file to display as a paper tape"),
+                GTK_WINDOW(papertape->parent_window),
+                GTK_FILE_CHOOSER_ACTION_OPEN,
+                GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+                GTK_STOCK_OPEN, GTK_RESPONSE_OK,
+                NULL);
 
-    // gewuenschten Dateinamen kriegen
-    chooser = gtk_file_chooser_dialog_new(
-        g_strdup_printf("Dateiname fuer %s-Export auswaehlen", format),
-        GTK_WINDOW(window),
-        GTK_FILE_CHOOSER_ACTION_SAVE,
-        GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
-        GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
-        NULL);
-    gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(chooser), TRUE);
+        if(gtk_dialog_run(GTK_DIALOG(chooser)) == GTK_RESPONSE_OK) {
+                char *filename;
+                FILE *file;
 
-    if(gtk_dialog_run(GTK_DIALOG(chooser)) == GTK_RESPONSE_ACCEPT) {
-        filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(chooser));
-    }
-    gtk_widget_destroy(chooser);
+                filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER (chooser));
+                if(filename == NULL) {
+                        g_printf(_("No file selected to open.\n"));
+                        gtk_widget_destroy(GTK_WIDGET(chooser));
+                        return FALSE;
+                } else {
+                        gtk_paper_tape_read_from_file(papertape, filename);
+                        g_free(filename);
+                        gtk_widget_destroy(GTK_WIDGET(chooser));
+                        return TRUE;
+                }
+        }
+        gtk_widget_destroy(chooser);
+        return FALSE;
+} // open_file_dialog
 
-    lochstreifen_flush_only_start_area(lochstreifen); // damit der ganze Lochstreifen gezeichnet wird,  vgl. expose_lochstreifen
-    if(strcmp(format, "PNG") == 0) {
-        // PNG erstellen
-        surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
-            lochstreifen_get_width(lochstreifen),
-            lochstreifen_get_height(lochstreifen)
-        );
-        cr = cairo_create(surface);
-        lochstreifen_draw(lochstreifen, cr);
-        status = cairo_surface_write_to_png (surface, filename);
-        message_statusbar(
-            g_strdup_printf("PNG-Datei (%d x %d Pixel, 24bit) wurde exportiert: %s",
-                lochstreifen_get_width(lochstreifen),
-                lochstreifen_get_height(lochstreifen),
-                cairo_status_to_string(status))
-        );
-    } else if(strcmp(format, "SVG") == 0) {
-        // SVG erstellen
-        double width,height;
-        // SVG-Surface erwartet Breite in Punkt, 1pt = 1/72 inch
-        width = 72 * lochstreifen_get_width(lochstreifen) / (double)fast_get_dpi();
-        height = 72 * lochstreifen_get_height(lochstreifen) / (double)fast_get_dpi();
-        // irgendwie spinnt der Compiler und meint ohne den folgenden unsinnigen
-        // exipliten Typcastings "Warnung: Zuweisung erzeugt Zeiger von Ganzzahl ohne Typkonvertierung"
-        surface = (cairo_surface_t *)cairo_svg_surface_create((char*)filename, (double)width, (double)height);
+int main(int argc, char *argv[]) {
+        GtkWidget *window, *mainbox, *statusbar;
+        GtkPaperTape *papertape;
+        gtk_init(&argc, &argv);
+        
+        // main window generation
+        window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+        gtk_window_set_default_size(GTK_WINDOW(window), 600, 600);
+        gtk_window_set_title(GTK_WINDOW(window), "GtkPaperTape Demo");
+        g_signal_connect_swapped(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
+        
+        // generate main box (menubar + papertape whole widget)
+        mainbox = gtk_vbox_new(FALSE, 0);
+        gtk_container_add(GTK_CONTAINER(window), mainbox);
+        gtk_widget_show(mainbox);
+        
+        // main widget generation
+        papertape = GTK_PAPER_TAPE(gtk_paper_tape_new(window));
+        
+        // menus start
+        {
+                GtkWidget *menu, *menubar, *menuitem;
+                // menus
+                menubar = gtk_menu_bar_new();
+                gtk_box_pack_start(GTK_BOX(mainbox), menubar, FALSE, TRUE, 0);
+                gtk_widget_show(menubar);
+        
+                // FIRST menu: File {{{
+                menu = gtk_menu_new();
+                // Oeffnen
+                g_signal_connect(G_OBJECT(fast_stock_menuitem(menu, GTK_STOCK_OPEN)),
+                        "activate", G_CALLBACK(open_file_dialog), papertape);
+                fast_menu_seperator(menu);
+                gtk_paper_tape_menu_export(papertape, menu);
+                fast_menu_seperator(menu);
+                g_signal_connect(G_OBJECT(fast_stock_menuitem(menu, GTK_STOCK_QUIT)),
+                        "activate", G_CALLBACK(gtk_main_quit), NULL);
+        
+                menuitem = gtk_menu_item_new_with_mnemonic("_Datei");
+                gtk_menu_item_set_submenu(GTK_MENU_ITEM (menuitem), menu);
+                gtk_menu_shell_append(GTK_MENU_SHELL (menubar), menuitem);
+                gtk_widget_show (menuitem);
+        
+                // Zweites Menue: Ansicht
+                menu = gtk_menu_new();
+                gtk_paper_tape_menu_view(papertape, menu);
+        
+                menuitem = gtk_menu_item_new_with_mnemonic("_Ansicht");
+                gtk_menu_item_set_submenu(GTK_MENU_ITEM (menuitem), menu);
+                gtk_menu_shell_append(GTK_MENU_SHELL (menubar), menuitem);
+                gtk_widget_show (menuitem);
+        
+                // Drittes Menue: Farben
+                menu = gtk_menu_new();
+                gtk_paper_tape_menu_colors(papertape, menu);
+        
+                menuitem = gtk_menu_item_new_with_mnemonic("_Farben");
+                gtk_menu_item_set_submenu(GTK_MENU_ITEM (menuitem), menu);
+                gtk_menu_shell_append(GTK_MENU_SHELL (menubar), menuitem);
+                gtk_widget_show (menuitem);
+        }
+        // menus end
 
-        cr = cairo_create(surface);
-        lochstreifen_draw(lochstreifen, cr);
-
-        message_statusbar(
-            g_strdup_printf("SVG-Datei (%.2f x %.2f Punkt) wurde exportiert: %s",
-                width, height,
-                cairo_status_to_string(cairo_surface_status(surface))
-            )
-        );
-    } else {
-        message_statusbar("Gewuenschter Exporttyp nicht feststellbar!");
-    }
-
-    cairo_surface_destroy(surface);
-    cairo_destroy(cr);
-    g_free(filename);
-}
-
-gboolean null_bytes_dialog (GtkWidget *widget, gpointer data) {
-    GtkWidget *dialog, *table, *input_start, *input_end, *label;
-    GtkWidget *box;
-
-    dialog = gtk_message_dialog_new(GTK_WINDOW(window),
-        GTK_DIALOG_DESTROY_WITH_PARENT,
-        GTK_MESSAGE_QUESTION,
-        GTK_BUTTONS_OK_CANCEL,
-        "Nullbytes");
-    gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
-        "Am Anfang und am Ende der angezeigten Datei koennen\n"
-        "zusaetzliche \"virtuelle\" Nullbytes angezeigt werden,\n"
-        "die in der Datei nicht gespeichert sind. Je nach Farbeinstellung\n"
-        "sieht man nur Fuehrungsloecher - damit sieht der\n"
-        "Lochstreifen realistischer aus.");
-
-    input_start = gtk_spin_button_new_with_range(0., 10000., 1.);
-    gtk_spin_button_set_value(GTK_SPIN_BUTTON(input_start), (gdouble)lochstreifen->empty_start);
-    input_end = gtk_spin_button_new_with_range(0., 10000., 1.);
-    gtk_spin_button_set_value(GTK_SPIN_BUTTON(input_end), (gdouble)lochstreifen->empty_end);
-
-    box = gtk_table_new(2, 2, FALSE);
-    gtk_table_set_row_spacings(GTK_TABLE(box), 5);
-    label = gtk_label_new("Nullbytes am Anfang: ");
-    gtk_table_attach_defaults(GTK_TABLE(box), label,
-       0, 1, 0, 1); 
-    gtk_table_attach_defaults(GTK_TABLE(box), input_start,
-       1, 2, 0, 1); 
-    label = gtk_label_new("Nullbytes am Ende: ");
-    gtk_table_attach_defaults(GTK_TABLE(box), label,
-       0, 1, 1, 2); 
-    gtk_table_attach_defaults(GTK_TABLE(box), input_end,
-       1, 2, 1, 2); 
-
-    gtk_container_add(GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
-                       box);
-    gtk_widget_show_all (dialog);
-
-    if(gtk_dialog_run(GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) {
-        lochstreifen->empty_start = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(input_start));
-        lochstreifen->empty_end = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(input_end));
-        message_statusbar(
-            g_strdup_printf("Vorne werden nun %d Nullbytes angezeigt, hinten %d.",
-                lochstreifen->empty_start, lochstreifen->empty_end)
-        );
-
-        redraw_lochstreifen(TRUE);
-    } else
-        message_statusbar("Anzahl der Nullbytes wurde nicht veraendert.");
-    gtk_widget_destroy (dialog);
-}
-
-gboolean expose_lochstreifen(GtkWidget *widget, GdkEventExpose *event, gpointer data) {
-    /* Calllback für das "expose_event" - Zeichenevent */
-    cairo_t *cr;
-    time_t TIME;
-    time(&TIME);
-    //LOCHSTREIFEN *l;
-    
-    // mal testen:
-    gdk_window_clear_area(widget->window,
-        event->area.x, event->area.y, event->area.width, event->area.height);
-    
-    cr = gdk_cairo_create(widget->window);
-    //l = (LOCHSTREIFEN *)data;
-
-    printf("%d Neuzeichnen: x|y = (%d|%d), width*height = %d * %d\n", TIME,
-                        event->area.x, event->area.y,
-                        event->area.width, event->area.height);
-    // Clipping, um das Neuzeichnen zu beschleunigen. Ist das sinnvoll?
-    /*cairo_rectangle (cr,
-                        event->area.x, event->area.y,
-                        event->area.width, event->area.height);
-    cairo_clip (cr);*/
-    
-    
-    lochstreifen_set_only_start_area(lochstreifen,
-                        event->area.x, event->area.y,
-                        event->area.width, event->area.height);
-     
-    lochstreifen_draw(lochstreifen, cr);
-    /*printf("Fertig (real width*height = %d * %d)\n", lochstreifen_get_width(lochstreifen),
-        lochstreifen_get_height(lochstreifen));
-    */
-    cairo_destroy(cr);
-    return FALSE;
-}
-
-int fast_get_dpi() {
-    /**
-     * Mal schnell die Aufloesung als Ganzzahl zurueckgeben.
-     * Der Rueckgabewert gibt also die Anzahl der Pixel an, die auf dem Monitor
-     * einen Zoll breit sein sollten...
-     **/
-    GdkScreen *screen = gdk_screen_get_default();
-    if(screen == NULL) {
-        printf("Konnte GdkScreen zwecks DPI-Auslesung nicht erkennen!\n");
-        return;
-    }
-
-    gdouble dpi = gdk_screen_get_resolution(screen);
-    if(dpi < 0) {
-        printf("Screenresolution (%f) nicht feststellbar\n", dpi);
-        return;
-    }
-    return (int)rint(dpi); // noch sauber runden.
-}
-
-gboolean transform_fit_lochstreifen(GtkWidget *widget, GdkEventConfigure *event, gpointer data) {
-    // Bei Groessenveraenderungen des Lochstreifenwidgets wird dies
-    // aufgerufen, wenn "an Bildschirmgroesse anpassen" gewuenscht ist
-
-    // Das Scrollwidget davon unterrichten, nur noch in einer Richtung zu scrollen, damit
-    // es beim Verkleinern des Fensters nicht meint, genug Platz zu haben und sich die Lochstreifen-
-    // groesse gar nicht anpasst.
-    // muss bloederweise hier gemacht werden, weil man ja nachtraeglich die Ausrichtung des
-    // Lochstreifens aendern koennte.
-    int orientation = lochstreifen_get_orientation(lochstreifen); // 1 = horizontal
-
-    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(gtk_widget_get_parent(gtk_widget_get_parent(lochstreifen_widget))),
-        orientation == 1 ? GTK_POLICY_AUTOMATIC : GTK_POLICY_NEVER,
-        orientation == 1 ? GTK_POLICY_NEVER : GTK_POLICY_AUTOMATIC);
-
-    // Mindestgroessenberechnungen nach redraw_lochstreifen verlagert.
-    if(lochstreifen_get_orientation(lochstreifen) == 1) {
-        // horizontal ausgerichteter Lochstreifen => Hoehe fixieren.
-        lochstreifen_set_d_by_height(lochstreifen, event->height);
-        // Mindestdimensionssetzen verlagert nach redraw_lochstreifen,
-        // damit nicht Datengroessenaenderung die Sachen wieder kaputtmachen
-        // Mindestdimensionen: Breite festgelegt durch Daten, Hoehe variabel
-    } else {
-        // vertikal ausgerichtet => Breite fixieren
-        lochstreifen_set_d_by_width(lochstreifen, event->width);
-        // set size request verschoben nach redraw_lochstreifen, siehe oben
-    }
-
-    redraw_lochstreifen(TRUE);
-    return FALSE;
-}
-
-void transform_lochstreifen(GtkWidget *widget, gpointer data) {
-    char action = *((char *)data);
-    char *status_comment;
-    byte_t status_type = 0; // 0 = nix ersetzen, 1 = Ansicht in % einsetzen, 2 = Drehausrichtung einsetzen
-    if(action == '+') {
-        lochstreifen_set_d(lochstreifen, lochstreifen->d + 3); // vergroessern
-        status_comment = "Ansicht vergroessert auf %d%%";
-        status_type = 1;
-        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(fit_screen_toggle), FALSE); // nicht automatisch anpassen
-    } else if(action == '-') {
-        if(lochstreifen->d - 3 < 1) {
-            message_statusbar("Der Lochstreifen kann nicht kleiner gezeichnet werden!");
-            return;
-        }
-        lochstreifen_set_d(lochstreifen, lochstreifen->d - 3); // verkleinern
-        status_comment = "Ansicht verkleinert auf %d%%";
-        status_type = 1;
-        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(fit_screen_toggle), FALSE); // nicht automatisch anpassen
-    } else if(action == '=') { // 100% = "Lebensgroesse2
-        lochstreifen_set_d(lochstreifen, (int)rint((float)fast_get_dpi()/(float)16)); // ein Loch ist etwa 1/16 Zoll breit
-        status_comment = "Wirkliche Lebensgroesse eingestellt (kann bei falscher Monitoreinstellung abweichen)";
-        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(fit_screen_toggle), FALSE); // nicht automatisch anpassen
-    } else if(action == '[') { // an Bildschirmgroesse anpassen
-        if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))) {
-            // Checkbox wurde aktiviert
-            g_signal_connect(G_OBJECT(lochstreifen_widget), "configure_event", G_CALLBACK(transform_fit_lochstreifen), NULL);
-            // den Container resizen damit die erste Anpassung inkraft tritt
-            gtk_widget_queue_resize_no_redraw(lochstreifen_widget); // neugezeichnet wird unten.
-            status_comment = "Lochstreifen passt sich nun stets dem Anzeigebereich an";
-        } else {
-            // Checkbox wurde deaktiviert
-            g_signal_handlers_disconnect_by_func(G_OBJECT(lochstreifen_widget), G_CALLBACK(transform_fit_lochstreifen), NULL);
-            // Scrollwidget wieder zuruecksetzen.
-            gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(gtk_widget_get_parent(gtk_widget_get_parent(lochstreifen_widget))),
-                GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
-
-            return;
-            // nichts ausgeben, weil auch durch andere Sachen aufgerufen
-        }
-    } else if(action == 'S') { // Statusleiste einblenden/ausblenden
-        if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))) {
-             // Checkbox wurde aktiviert
-             gtk_widget_show(lochstreifen_statusbar);
-             status_comment = "Statusleiste wird (wieder) angezeigt.";
-        } else gtk_widget_hide(lochstreifen_statusbar);
-    } else if(action == '>') { // Drehen mit Uhrzeigersinn
-        //lochstreifen_rotate(lochstreifen);
-        lochstreifen_set_direction(lochstreifen, 4, -1,-1);
-        status_comment = "Lochstreifen im Uhrzeigersinn gedreht (%s)";
-        status_type = 2;
-    } else if(action == '<') { // Drehen gegen Uhrzeigersinn
-        lochstreifen_set_direction(lochstreifen, 5, -1,-1);
-        status_comment = "Lochstreifen gegen Uhrzeigersinn gedreht (%s)";
-        status_type = 2;
-    } else if(action == '_') { // horizontal Spiegeln
-        lochstreifen_set_direction(lochstreifen, -1, 2, -1);
-        status_comment = "Lochstreifen wurde vertikal gespiegelt (Datenreihenfolge umgedreht, d.h. links und rechts vertauscht)";
-    } else if(action == '|') { // vertikal spiegeln
-        lochstreifen_set_direction(lochstreifen, -1, -1, 2);
-        status_comment = "Lochstreifen wurde horizontal gespiegelt (unten und oben vertauscht)";
-    }
-    redraw_lochstreifen(TRUE);
-
-    // Ausgaben fuer Statuszeile vorbereiten
-    if(status_comment == NULL || strlen(status_comment) == 0) return; // gibt nichts zu sagen
-    if(status_type == 1) {
-        // % von realer Groesse angeben.
-        message_statusbar(
-            g_strdup_printf(status_comment, (int)((float)lochstreifen->d / ((float)fast_get_dpi()/(float)16) * 100)) // siehe action=='='
-        );
-    } else if(status_type == 2) {
-        // Ausrichtung angeben als String
-        char *ausrichtung;
-        switch(lochstreifen->drehung) {
-            case 0: ausrichtung = "horizontal, von links nach rechts"; break;
-            case 1: ausrichtung = "vertikal, von oben nach unten"; break;
-            case 2: ausrichtung = "horizontal, von rechts nach links"; break;
-            case 3: ausrichtung = "vertikal, von unten nach oben"; break;
-            default: ausrichtung = "*** ERROR - ungueltige Ausrichtung";
-        }
-        message_statusbar(
-            g_strdup_printf(status_comment, ausrichtung)
-        );
-    } else // status_type == 0
-        message_statusbar(status_comment);
-}
-
-void change_constant_gui(GtkWidget *widget, gpointer data) {
-    // GUI zur Aenderung der Konstanten anzeigen...
-    printf("Pending...\n");
-}
-
-GdkColor *color_cairo2gdk(cairo_pattern_t *pattern);
-
-gboolean open_lochstreifen_file(char *filename) {
-    /**
-     * Oeffnet die gewuenschte Datei.
-     * Bei Fehler wird FALSE zurueckgegeben
-     **/
-     int length; gchar *data;
-     gboolean ret;
-     GError *err;
-
-     ret = g_file_get_contents(filename, &data, &length, &err);
-
-     if(ret == FALSE) {
-          message_error("Fehler beim Oeffnen",
-              g_strdup_printf("Konnte die Datei '%s' nicht oeffnen: %s", filename,
-                  err->message)
-          );
-          return;
-     }
-
-     if(startsequence_running) {
-         // Startsequenz (wenn Programm ohne Lochstreifendatei gestartet wird) laeuft noch
-         // beenden, in dem startsequence_running auf FALSE gesetzt wird.
-         startsequence_running = FALSE;
-     }
-
-     lochstreifen_set_data(lochstreifen, length, (byte_t *)data, -1, -1);
-     message_statusbar("Die Datei wurde geoeffnet.");
-     gtk_window_set_title(GTK_WINDOW (window),
-         g_strdup_printf("%s - %s", basename(filename), WINDOW_TITLE)
-    );
-
-     // Neuzeichnen, usw.
-     redraw_lochstreifen(TRUE);
-}
-
-gboolean open_lochstreifen_file_dialog(GtkWidget *widget, GtkWidget *parentWindow) {
-    /**
-     * Zeigt den Datei-Oeffnen-Dialog an (als Callback-Funktion fuer das Datei-Menue)
-     *
-     *
-     **/
-    GtkWidget *chooser;
-    chooser = gtk_file_chooser_dialog_new(
-        "(Binaer-)datei zur Darstellung als Lochstreifen auswaehlen",
-        GTK_WINDOW(parentWindow),
-        GTK_FILE_CHOOSER_ACTION_OPEN,
-        GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
-        GTK_STOCK_OPEN, GTK_RESPONSE_OK,
-        NULL);
-    if(gtk_dialog_run(GTK_DIALOG(chooser)) == GTK_RESPONSE_OK) {
-        char *filename;
-        FILE *file;
-
-        filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER (chooser));
-        if(filename == NULL) {
-            message_error("Keine Datei geoeffnet.", NULL);
-            gtk_widget_destroy(GTK_WIDGET(chooser));
-            return FALSE;
-        }
-
-        /*file = fopen(filename, "r");
-        if(file == NULL) {
-            message_error("Fehler beim Oeffnen",
-                g_strdup_printf("Konnte die Datei '%s' nicht oeffnen: %s", filename,
-                    g_strerror (errno))
-            );
-            return;
-        }
-        open_lochstreifen_file(file);*/
-        open_lochstreifen_file(filename);
-        g_free(filename);
-    }
-    gtk_widget_destroy(chooser);
-    return FALSE;
-}
-
-void message_error(gchar *heading, gchar *text) {
-    GtkWidget *dialog;
-    dialog = gtk_message_dialog_new(GTK_WINDOW(window),
-        GTK_DIALOG_MODAL,
-        GTK_MESSAGE_ERROR,
-        GTK_BUTTONS_OK,
-        heading);
-    if(text != NULL) gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog), text);
-    gtk_dialog_run(GTK_DIALOG(dialog));
-    gtk_widget_destroy(GTK_WIDGET(dialog));
-}
-
-void colorize_lochstreifen(GtkWidget *widget, gpointer data) {
-    cairo_pattern_t **target = (cairo_pattern_t **)data; // Doppellink noetig weil Adressaenderung
-    GdkColor color;
-    gtk_color_button_get_color(GTK_COLOR_BUTTON(widget), &color);
-    /*double red, green, blue;
-    printf("Farben gewaehlt: R=%i G=%i B=%i\n",color.red, color.green, color.blue);
-        red = ((double)color.red / (double)G_MAXUINT16); // G_MAXUINT16 = 2^16 weil Farben = guint16
-        green = ((double)color.green / (double)G_MAXUINT16);
-        blue = ((double)color.blue / (double)G_MAXUINT16);
-
-    printf("Farben == R=%f G=%f B=%f\n",
-        red,green,blue);*/
-
-    //if(*target != NULL) cairo_pattern_destroy(*target); // damit nicht sinnlos Speicher zugemuellt wird
-    *target = cairo_pattern_create_rgb(
-        // darauf muss man erst mal kommen: Vorher in double casten, denn sonst
-        // berechnet er einen unsigned short (=guint16), der einfach auf 0 ab oder
-        // auf 1 hochrundet. (double)(guint16/G_MAXUNIT16) gibt also stets 0,000 oder 1,000.
-        (double)((double)color.red / (double)G_MAXUINT16), // G_MAXUINT16 = 2^16 weil Farben = guint16
-        (double)((double)color.green / (double)G_MAXUINT16),
-        (double)((double)color.blue / (double)G_MAXUINT16));
-    //printf("%s\n", cairo_status_to_string(cairo_pattern_status(*target)));
-
-    GdkColor *g = color_cairo2gdk(*target);
-    //printf("Farben zurueck: R=%d G=%d B=%d\n", g->red, g->green, g->blue);
-        //gtk_color_button_get_alpha(GTK_COLOR_BUTTON(widget)) / 65535);
-    redraw_lochstreifen(FALSE);
-    //    gtk_color_button_get_alpha(GTK_COLOR_BUTTON(widget)) / 65535);
-
-    // noch mal schnell RGB-Wert fuer Statuszeile ausgeben
-    message_statusbar(
-        g_strdup_printf("Farbe geaendert auf RGB (%d|%d|%d)",
-        (int)((double)color.red / (double)G_MAXUINT16 * 255),
-        (int)((double)color.red / (double)G_MAXUINT16 * 255),
-        (int)((double)color.red / (double)G_MAXUINT16 * 255)
-        )
-    );
-}
+        // attach papertape whole widget to mainbox
+        gtk_box_pack_start(GTK_BOX(mainbox),
+                GTK_WIDGET(gtk_paper_tape_get_whole_box(GTK_PAPER_TAPE(papertape))),
+                TRUE, TRUE, 0);
 
 
-GtkWidget *fast_color_menuitem(const GtkWidget *parentmenu, const char *dialog_title, const char *labeltext, GdkColor *initialColor, GtkSizeGroup *label_nice_sizegroup) {
-    /* Schnell ein Colorchooser-Button inklusive Richtextlabel in einem
-       Menuitem einbauen. Gibt das Colorchooserbutton-Widget zurück,
-       initialColor kann NULL sein. GtkSizeGroup auch. */
-    GtkWidget *menuitem, *menubox, *colorbutton, *label;
-    menuitem = gtk_menu_item_new();
-    menubox = gtk_hbox_new(FALSE, 4);
-    gtk_container_add(GTK_CONTAINER(menuitem), menubox);
-    gtk_widget_show(menubox);
+        // parse command options
+        {
+                char *filename = NULL;
+                gboolean read_from_stdin = FALSE;
+                GError *error = NULL;
+                GOptionContext *context;
+                byte_t show_mystart = 0; // eigene Startprozedur anzeigen?
+                GOptionEntry option_entries[] = {
+                        { "filename", 'f', 0, G_OPTION_ARG_FILENAME, &filename, _("file to open"), NULL },
+                        { "stdin", 's', 0, G_OPTION_ARG_NONE, &read_from_stdin, _("read from standard input"), NULL },
+                        { NULL }
+                };
 
-    colorbutton = gtk_color_button_new();
-    //gtk_color_button_set_use_alpha(GTK_COLOR_BUTTON(colorbutton), TRUE); // doch kein Alpha, das bringt nichts.
-    gtk_color_button_set_title(GTK_COLOR_BUTTON(colorbutton), dialog_title);
-    gtk_box_pack_start(GTK_BOX(menubox), colorbutton, FALSE, FALSE, 0);
-    gtk_widget_show(colorbutton);
+                context = g_option_context_new(_(" - GtkPaperTape visualisation"));
+                g_option_context_add_main_entries(context, option_entries, NULL);
+                g_option_context_add_group(context, gtk_get_option_group(TRUE));
+                g_option_context_parse(context, &argc, &argv, &error);
 
-    label = gtk_label_new(NULL);
-    gtk_label_set_markup(GTK_LABEL(label), labeltext);
-    gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_CENTER);
-    gtk_box_pack_start(GTK_BOX(menubox), label, TRUE, TRUE, 0);
-    gtk_widget_show(label);
+                if(read_from_stdin) {
+                        printf(_("%s: Reading data from standard input, will open window after EOF.\n"), argv[0]);
+                        byte_t *data;
+                        int length = file_get_contents(stdin, &data);
+                        gtk_paper_tape_set_data(papertape, length, data);
+                } else if(filename != NULL) {
+                        // eine Datei einlesen
+                        printf(_("Reading from file '%s'\n"), filename);
+                        if(!gtk_paper_tape_read_from_file(papertape, argv[1])) {
+                                printf(_("Failed to read from file!\n"));
+                                return 1;
+                        }
+                }
+        }
+        // end of parsing command options
 
-    g_signal_connect_swapped(menuitem, "activate", G_CALLBACK(gtk_button_clicked), colorbutton);
-
-    if(initialColor != NULL) {
-        //printf("Farben:\n");
-        //printf("\tr%i g%i b%i\n", initialColor->red, initialColor->green, initialColor->blue);
-        gtk_color_button_set_color(GTK_COLOR_BUTTON(colorbutton), initialColor);
-    }
-    if(label_nice_sizegroup != NULL) {
-        gtk_size_group_add_widget(label_nice_sizegroup, label);
-    }
-
-    gtk_widget_show (menuitem);
-    gtk_menu_shell_append (GTK_MENU_SHELL (parentmenu), menuitem);
-    return colorbutton;
+        gtk_widget_show(window);
+        gtk_main();
+        return 0;
 }
-
-GdkColor *color_cairo2gdk(cairo_pattern_t *pattern) {
-    /** Kleine Behelfsfunktion, um von einem Cairopattern die Farbe im GDK-format zu ziehen
-        ALPHA wird ganz nett ignoriert :) */
-    GdkColor *c = malloc(sizeof(GdkColor));
-    double red, green, blue, alpha;
-    if(pattern != NULL)
-        cairo_pattern_get_rgba(pattern, &red, &green, &blue, &alpha);
-    else
-        { red=1; green=1; blue=1; } // pattern ist NULL => nehmen mir mal weiss ;-)
-    c->red = red * 65535; // 2^16
-    c->green = green * 65535;
-    c->blue = blue * 65535;
-    return c;
-}
-
-gboolean startup_sequence_loop(gpointer state) { //real_data_length) {
-    // siehe startup_sequence
-    //int state = *((int *)state_pointer);
-
-    // Schleife wird deaktiviert, in dem startsequence_running auf false gesetzt wird.
-    if(!startsequence_running)
-        return FALSE;
-
-    if(*((int*)state) <= startsequence_length) {
-        lochstreifen->data++; // Zeiger zeigt aufs naechse Byte
-        *((int*)state) += 1;
-    } else {
-        lochstreifen->data -= startsequence_length;
-        *((int*)state) = 0;
-    }
-
-
-    // einfach erst mal die Lochstreifendaten um eins verschieben.
-    /*if(lochstreifen->data_length < length) {
-        lochstreifen->data_length++;
-    }*/
-    /*
-    byte_t buf;
-    int x;
-    for(x = 1; x < lochstreifen->data_length;x++) {
-        buf = lochstreifen->data[x-1];
-        lochstreifen->data[x-1] = lochstreifen->data[x];
-        lochstreifen->data[x] = buf;
-    }*/
-
-    // neuzeichnen.
-    redraw_lochstreifen(TRUE);
-    printf("Neugezeichnet.\n");
-
-    return TRUE;
-    // true zurueckgeben, wenns weitergehen soll.
-}
-
-gboolean startup_sequence(GtkWidget *widget, gpointer datas) {
-    /**
-     * Die kleine "Startup-Sequenz" wird gezeigt, wenn es keine Daten anzuzeigen gibt.
-     * Dabei scrollt ein Text (eigene Darstellung) als Lochstreifen durch die Gegend.
-     *
-     **/
-    // Integer, um aktuelle Position zu speichern
-    int *state = malloc(sizeof(int));
-    *state = 0;
-    // Array mit gerade 2x Datenarray hintereinander erstellen.
-    byte_t *bufdata = malloc(startsequence_length*2); // Buffer mit doppelter Laenge erstellen
-    memcpy(bufdata, startsequence_data, startsequence_length); // Bufarray fuellen
-    memcpy(bufdata+startsequence_length, startsequence_data, startsequence_length); // und ein zweites mal
-    /*int x;
-    byte_t *data = malloc(sizeof(byte_t)*256);
-    for(x=0;x<256;x++) {
-        data[x] = (byte_t) (255-x);
-    }
-    */
-
-    /*int length_ = 256;
-    for(x=0; x<length_; x++) {
-        printf("%i von %i: 0x%x (=%c)\n", x, length_, data[x], data[x]);
-    }*/
-
-    lochstreifen_set_data(lochstreifen, startsequence_length, bufdata, 0, 0); // schon mal den ersten Wert.
-    //*length = 256;
-    g_timeout_add(1000, startup_sequence_loop, state); //length); // zur Main Loop hinzufuegen.
-    return FALSE;
-}
-
-gboolean update_statusbar(GtkWidget *lochstreifenwidget, GdkEventMotion *event, gpointer egal) {
-    /**
-     * In der Statuszeile beim Ueberfahren des Lochstreifens die aktuellen
-     * Werte anzeigen :-)
-     *
-     **/
-    gchar *msg;
-    int x,y,byte;
-
-    // erst nach 4 Sekunden einer "wichtigen" Nachricht wieder die Statuszeile
-    // mit diesen weniger wichtigen Infos befoelkern.
-    if(last_statusbar_update != NULL && g_timer_elapsed(last_statusbar_update, NULL) < 4) return;
-
-    // Statuszeile auf jeden Fall leeren.
-    gtk_statusbar_pop(GTK_STATUSBAR(lochstreifen_statusbar), 0);
-    byte = lochstreifen_byte_by_coordinate(lochstreifen, (int)event->x, (int)event->y);
-    if(byte > 0) {
-        gchar *msg; byte_t value,bit;
-        value = lochstreifen->data[byte-1]; // weil ab 1 zaehlen => -1 weil array ab 0 zaehlt
-
-        // Bitdarstellung selbst machen (printf hat sowas wohl nicht)
-        char bitdarstellung[9]; bitdarstellung[8] = '\0'; // Nullterminierung
-        for(bit=0; bit<8; bit++) {bitdarstellung[bit] = (((value >> bit) & 0x01) == 0x01) ? '1':'0';}
-
-        msg = g_strdup_printf("Byte %03d von %03d: Wert dez=%03d bin=%s okt=%03o hex=%02X",
-                              byte, lochstreifen->data_length,
-                              value, bitdarstellung, value, value);
-        gtk_statusbar_push(GTK_STATUSBAR(lochstreifen_statusbar), 0, msg);
-        g_free(msg);
-    } else if(byte == 0) {
-        //gtk_statusbar_push(statusbar, 0, "Zeiger befindet sich außerhalb");
-        // Zeiger befindet sich ausserhalb. Nichts hier ausgeben.
-        // d.h. Statusbar wurde exiplit geleert und bleibt leer.
-    } else if(byte == -1) {
-        gtk_statusbar_push(GTK_STATUSBAR(lochstreifen_statusbar), 0,
-            "Mauszeiger befindet sich auf den zusaetzlichen Nullbytes.");
-    }
-
-    return FALSE;
-}
-
-void message_statusbar(char *msg) {
-    /**
-     * Kurze Nachrichten in der Statuszeile anzeigen.
-     * Diese Nachrichten bleiben mindestens 4 Sekunden lang sichtbar, bevor z.B.
-     * die Position des Mauscursors wieder erscheint. Dafuer dient der Timer.
-     **/
-    gtk_statusbar_pop(GTK_STATUSBAR(lochstreifen_statusbar), 0);
-    gtk_statusbar_push(GTK_STATUSBAR(lochstreifen_statusbar), 0, msg);
-    // Statusbar-Timer erst hier einrichten, damit nach Programmstart man nicht
-    // erst 4 Sekunden warten muss.
-    if(last_statusbar_update == NULL)
-        last_statusbar_update = g_timer_new(); // wird automatisch gestartet
-    else
-        g_timer_start(last_statusbar_update); // Timer zuruecksetzen
-}
-
-gboolean scroll_lochstreifen(GtkWidget *lochstreifenwidget, GdkEventScroll *event, gpointer user_data) {
-    /**
-      Beim Scrollen auf dem Widget wird das GTK_SCROLLED_WINDOW (user_data) gescrollt, je nach
-      Ausrichtung des Streifens. Nur eindimensionales Scrolling, nicht 2d. (wer hat schon eine
-      Apple Mighty Mouse ;-) )
-     **/
-    GtkAdjustment* adjustment;
-    gdouble t;
-    if(lochstreifen->drehung % 2 == 0) {
-        // Lochstreifen ist horizontal ausgreichtet
-        adjustment = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(user_data));
-        if(adjustment == NULL) { printf("hadjustment = NULL!\n"); return FALSE; }
-        t = gtk_adjustment_get_value(adjustment) + lochstreifen->d * // um eine Lochbreite scrollen
-                  ((event->direction == GDK_SCROLL_UP || event->direction == GDK_SCROLL_RIGHT) ? -1 : 1);
-                  // nach rechts oder links scrollen
-/*        );
-        printf("Set to %f\n", gtk_adjustment_get_value(adjustment) + (gdouble)adjustment->step_increment * 
-                  (event->direction == GDK_SCROLL_UP || event->direction == GDK_SCROLL_RIGHT) ? (gdouble)1 : (gdouble)-1);*/
-    } else {
-        // nach oben bzw. unten scrollen
-        adjustment = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(user_data));
-        if(adjustment == NULL) { printf("vadjustment = NULL!\n"); return FALSE; }
-        t = gtk_adjustment_get_value(adjustment) + lochstreifen->d * 
-            ((event->direction == GDK_SCROLL_UP || event->direction == GDK_SCROLL_RIGHT) ? -1 : 1);
-          // nach oben oder unten scrollen
-    }
-    printf("Scroll Is: %f | up: %f | down: %f | shall be: %f\n", gtk_adjustment_get_value(adjustment), adjustment->lower, adjustment->upper, t);
-
-    if(t < adjustment->lower) t = adjustment->lower;
-    if(t > adjustment->upper) t = adjustment->upper;
-    gtk_adjustment_set_value(adjustment, t);
-    // geht nicht:
-    //g_signal_emit_by_name(lochstreifen_widget, "motion-notify-event"); // Mauszeigerbewegung simulieren => Statuszeile updaten
-}
-
-int main(int argc, char *argv[]) {
-    GtkWidget *mainbox;
-    GtkWidget *menubar, *menuitem, *menu;
-    GtkSizeGroup *color_sizes; // Damit Farbmenue einheitlich aussieht
-    GtkWidget *scroll;
-    GtkWidget *statusbar;
-    lochstreifen = lochstreifen_new(); // muss hier bereit zugewiesen werden weil benutzt
-
-    gtk_init (&argc, &argv);
-
-    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
-    gtk_window_set_default_size (GTK_WINDOW (window), 600, 600);
-    gtk_window_set_title(GTK_WINDOW (window), WINDOW_TITLE);
-    g_signal_connect_swapped(G_OBJECT(window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
-
-    mainbox = gtk_vbox_new(FALSE, 0);
-    gtk_container_add(GTK_CONTAINER (window), mainbox);
-    gtk_widget_show(mainbox);
-
-    statusbar = gtk_statusbar_new(); // erst nach Inhaltswidget hinzufuegen
-    lochstreifen_statusbar = statusbar; // quick & dirty global machen...
-
-    /* Menü */
-    menubar = gtk_menu_bar_new();
-    gtk_box_pack_start (GTK_BOX (mainbox), menubar, FALSE, TRUE, 0);
-    gtk_widget_show(menubar);
-
-    // Erstes Menue: Datei
-    menu = gtk_menu_new();
-    // Oeffnen
-    g_signal_connect(G_OBJECT(fast_stock_menuitem(menu, GTK_STOCK_OPEN)),
-        "activate", G_CALLBACK(open_lochstreifen_file_dialog), window);
-    fast_menu_seperator(menu);
-    g_signal_connect(G_OBJECT(fast_menuitem(menu, "Grafik als PNG exportieren...")),
-        "activate", G_CALLBACK(export_lochstreifen), "PNG");
-    g_signal_connect(G_OBJECT(fast_menuitem(menu, "Grafik als SVG exportieren...")),
-        "activate", G_CALLBACK(export_lochstreifen), "SVG");
-    fast_menu_seperator(menu);
-    g_signal_connect(G_OBJECT(fast_stock_menuitem(menu, GTK_STOCK_QUIT)),
-        "activate", G_CALLBACK(gtk_main_quit), NULL);
-
-    menuitem = gtk_menu_item_new_with_mnemonic("_Datei");
-    gtk_menu_item_set_submenu(GTK_MENU_ITEM (menuitem), menu);
-    gtk_menu_shell_append(GTK_MENU_SHELL (menubar), menuitem);
-    gtk_widget_show (menuitem);
-
-    // Zweites Menue: Ansicht
-    menu = gtk_menu_new();
-    fast_menu_tearoff(menu);
-    g_signal_connect(G_OBJECT(fast_stock_menuitem(menu, GTK_STOCK_ZOOM_IN)),
-        "activate", G_CALLBACK(transform_lochstreifen), "+");
-    g_signal_connect(G_OBJECT(fast_stock_menuitem(menu, GTK_STOCK_ZOOM_OUT)),
-        "activate", G_CALLBACK(transform_lochstreifen), "-");
-    g_signal_connect(G_OBJECT(fast_stock_menuitem(menu, GTK_STOCK_ZOOM_100)),
-        "activate", G_CALLBACK(transform_lochstreifen), "=");
-    //g_signal_connect(G_OBJECT(fast_stock_menuitem(menu, GTK_STOCK_ZOOM_FIT)),
-    //    "activate", G_CALLBACK(transform_lochstreifen), "[");
-    menuitem = gtk_check_menu_item_new_with_mnemonic("Groesse dem Fenster _anpassen");
-    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), FALSE);
-    g_signal_connect(G_OBJECT(menuitem), "toggled", G_CALLBACK(transform_lochstreifen), "[");
-    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
-    gtk_widget_show (menuitem);
-    fit_screen_toggle = menuitem; // auch hier global speichern, weil es in einer Funktion gebraucht wird.
-
-    g_signal_connect(G_OBJECT(fast_stock_menuitem(menu, GTK_STOCK_PROPERTIES)), //"Groessenverhaeltnisse aendern...")),
-        "activate", G_CALLBACK(change_constant_gui), NULL);
-    fast_menu_seperator(menu);
-    g_signal_connect(G_OBJECT(fast_menuitem(menu, "Drehen im Uhrzeigersinn")),
-        "activate", G_CALLBACK(transform_lochstreifen), ">");
-    g_signal_connect(G_OBJECT(fast_menuitem(menu, "Drehen gegen den Uhrzeigersinn")),
-        "activate", G_CALLBACK(transform_lochstreifen), "<");
-    g_signal_connect(G_OBJECT(fast_menuitem(menu, "Horizontal spiegeln (Datenreihenfolge umkehren)")),
-        "activate", G_CALLBACK(transform_lochstreifen), "|");
-    g_signal_connect(G_OBJECT(fast_menuitem(menu, "Vertikal spiegeln (Bitpositionen drehen)")),
-        "activate", G_CALLBACK(transform_lochstreifen), "_");
-    fast_menu_seperator(menu);
-    g_signal_connect(G_OBJECT(fast_menuitem(menu, "Anzahl Nullbytes einstellen...")),
-        "activate", G_CALLBACK(null_bytes_dialog), NULL);
-    menuitem = gtk_check_menu_item_new_with_mnemonic("_Statusleiste anzeigen");
-    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem), TRUE);
-    g_signal_connect(G_OBJECT(menuitem), "toggled", G_CALLBACK(transform_lochstreifen), "S");
-    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
-    gtk_widget_show (menuitem);
-
-    menuitem = gtk_menu_item_new_with_mnemonic("_Ansicht");
-    gtk_menu_item_set_submenu(GTK_MENU_ITEM (menuitem), menu);
-    gtk_menu_shell_append(GTK_MENU_SHELL (menubar), menuitem);
-    gtk_widget_show (menuitem);
-
-    // Drittes Menue: Farben
-    menu = gtk_menu_new();
-    color_sizes = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
-    fast_menu_tearoff(menu);
-    g_signal_connect(G_OBJECT(fast_color_menuitem(menu, "Farbe des Lochstreifens waehlen",
-        "Farbe des <b>Lochstreifens</b>", color_cairo2gdk(lochstreifen->streifenbg), color_sizes)),
-        "color-set", G_CALLBACK(colorize_lochstreifen), &(lochstreifen->streifenbg));
-    //gtk_color_button_set_color(GTK_COLOR_BUTTON(menuitem), color_cairo2gdk(lochstreifen->streifenbg));
-
-    fast_menu_seperator(menu);
-    g_signal_connect(G_OBJECT(fast_color_menuitem(menu, "Farbe der Loecher waehlen",
-        "Farbe der <b>Loecher</b> waehlen\n(binaere einsen)", color_cairo2gdk(lochstreifen->punched), color_sizes)),
-        "color-set", G_CALLBACK(colorize_lochstreifen), &(lochstreifen->punched));
-    fast_menu_seperator(menu);
-    g_signal_connect(G_OBJECT(fast_color_menuitem(menu, "Farbe der Nicht-Loecher waehlen",
-         "Farbe der <b>Nullen</b> waehlen\n(nicht gelochte Bits)", color_cairo2gdk(lochstreifen->notpunched), color_sizes)),
-        "color-set", G_CALLBACK(colorize_lochstreifen), &(lochstreifen->notpunched));
-    fast_menu_seperator(menu);
-    g_signal_connect(G_OBJECT(fast_color_menuitem(menu, "Farbe der Lochstreifen-Fuehrungsloecher waehlen",
-        "Farbe der <b>Fuehrungs-loecher</b>\nwaehlen (kleine Loecher)", color_cairo2gdk(lochstreifen->fuehrung), color_sizes)),
-        "color-set", G_CALLBACK(colorize_lochstreifen), &(lochstreifen->fuehrung));
-    fast_menu_seperator(menu);
-    g_signal_connect(G_OBJECT(fast_color_menuitem(menu, "Farbe der Hintergrund waehlen",
-        "<b>Hintergrundfarbe</b> waehlen\n(um dem Streifen rum)", color_cairo2gdk(lochstreifen->hintergrund), color_sizes)),
-        "color-set", G_CALLBACK(colorize_lochstreifen), &(lochstreifen->hintergrund));
-
-    menuitem = gtk_menu_item_new_with_mnemonic("_Farben");
-    gtk_menu_item_set_submenu(GTK_MENU_ITEM (menuitem), menu);
-    gtk_menu_shell_append(GTK_MENU_SHELL (menubar), menuitem);
-    gtk_widget_show (menuitem);
-
-    // So jetzt aber Inhalt: Das Hauptwidget.
-    lochstreifen_set_d(lochstreifen, 20);
-
-    // Daten einlesen.
-    {
-        char *filename = NULL;
-        gboolean read_from_stdin = FALSE;
-        gboolean no_splash = FALSE;
-        GError *error = NULL;
-        GOptionContext *context;
-        byte_t show_mystart = 0; // eigene Startprozedur anzeigen?
-        GOptionEntry option_entries[] = {
-           { "filename", 'f', 0, G_OPTION_ARG_FILENAME, &filename, "Datei zu oeffnen", NULL },
-           { "stdin", 's', 0, G_OPTION_ARG_NONE, &read_from_stdin, "Von Standardeingabe lesen", NULL },
-           { "no-splash", 'n', 0, G_OPTION_ARG_NONE, &no_splash,   "Keine Startanimation anzeigen, wenn ohne Datei gestartet", NULL },
-           { NULL }
-        };
-
-        context = g_option_context_new(" - Lochstreifenvisualisierung");
-        g_option_context_add_main_entries(context, option_entries, NULL);
-        g_option_context_add_group(context, gtk_get_option_group(TRUE));
-        g_option_context_parse(context, &argc, &argv, &error);
-
-        if(read_from_stdin) {
-            printf("%s: Lese Daten von Standardeingabe, erst nach EOF wird Fenster geoeffnet.\n",argv[0]);
-            byte_t *data;
-            int length = file_get_contents(stdin, &data);
-            lochstreifen_set_data(lochstreifen, length, data, 6, 6);
-        } else if(filename != NULL) {
-             // eine Datei einlesen
-             printf("Von Datei %s lesen\n", filename);
-             if(!open_lochstreifen_file(argv[1]))
-                 show_mystart = 1;
-        } else if(!no_splash) {
-            // Splash (=Start)-Sequenz anzeigen
-            show_mystart = 1;
-        }
-
-        // Daten wurde eingelesen -- oder auch nicht:
-        if(show_mystart != 0) {
-            g_signal_connect_after(G_OBJECT(window), "show", G_CALLBACK(startup_sequence), NULL);
-            startsequence_running = show_mystart;
-        } else startsequence_running = FALSE;
-    }
-
-    lochstreifen_widget = gtk_drawing_area_new();
-    gtk_widget_set_size_request (GTK_WIDGET (lochstreifen_widget),
-        lochstreifen_get_width(lochstreifen),
-        lochstreifen_get_height(lochstreifen)); // erst mal spasseshalber
-
-    scroll = gtk_scrolled_window_new(NULL, NULL);
-    gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), lochstreifen_widget); // weil nicht scrollable
-    // Scrollbalken nur anzeigen wenn benoetigt
-    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
-    gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll), GTK_SHADOW_NONE);
-    gtk_box_pack_start(GTK_BOX(mainbox), scroll, TRUE, TRUE, 0);
-    gtk_widget_show(scroll);
-
-    gtk_widget_show(lochstreifen_widget);
-    g_signal_connect(G_OBJECT(lochstreifen_widget), "expose_event", G_CALLBACK(expose_lochstreifen), NULL);
-    gtk_widget_add_events(lochstreifen_widget, GDK_POINTER_MOTION_MASK | GDK_SCROLL_MASK); // Mauscursor kriegen, Mausscrolling kriegen
-    g_signal_connect(G_OBJECT(lochstreifen_widget), "motion-notify-event", G_CALLBACK(update_statusbar), NULL);
-    g_signal_connect(G_OBJECT(lochstreifen_widget), "scroll-event", G_CALLBACK(scroll_lochstreifen), scroll);
-
-    // Statusbar hinzufuegen.
-    // Ich haette ja gerne eine maechtigere Statusbar, aber das geht wohl
-    // leider nicht. Ein paar Versuche, das Label dort wenigstens Pango-Formatierungs-Faehig
-    // zu machen:
-    /*gtk_container_forall(GTK_CONTAINER(statusbar), G_CALLBACK(fast_nicer_statusbar), NULL);
-    gboolean fast_nicer_statusbar(GtkWidget *statusbar_child, gpointer egal) {
-        GList *children;
-        gpointer child;
-        children = gtk_container_get_children(GTK_CONTAINER(statusbar));
-        
-        gtk_container_forall                (GtkContainer *container,
-                                                         GtkCallback callback,
-                                                         gpointer callback_data);
-        
-        //printf("Checke Kindelement von statusbar (%d)\n", g_list_length(children));
-        //while((child = g_list_next(children)) != NULL) {
-            if(GTK_IS_LABEL(statusbar_child)) {
-                printf("LABEL GEFUNDEN!\n");
-                gtk_label_set_use_markup(GTK_LABEL(statusbar_child), TRUE); // :-)
-            }
-            printf("Fand ein %s-Objekt.\n", G_OBJECT_TYPE_NAME(statusbar_child));
-        //}
-        //printf("Fertig.\n");
-    }    */
-    gtk_box_pack_start(GTK_BOX(mainbox), statusbar, FALSE, TRUE, 0);
-    gtk_widget_show(statusbar);
-
-    // TEST DEBUG:
-    //gtk_widget_set_redraw_on_allocate(lochstreifen_widget, TRUE);
-    //gtk_widget_set_double_buffered(lochstreifen_widget, FALSE);
-
-    gtk_widget_show(window);
-    gtk_main();
-    return 0;
-}

visualisator/lochstreifen.c

@@ -157 +157 @@
     l->d = 10;
     l->data_length = 0;
+    l->data = NULL;
+    l->empty_start = 0;
+    l->empty_end = 0;
     l->debug = 0;
     l->hintergrund = NULL; // nicht zeichnen
@@ -168 +171 @@
     l->spiegelung_hor = 0;
     l->spiegelung_ver = 0;
+    l->highlight_byte = 0;
+    l->highlight_color = NULL;
     lochstreifen_flush_only_start_area(l);
     return l;
@@ -181 +186 @@
     if(empty_start >= 0) l->empty_start = empty_start;
     if(empty_end >= 0) l->empty_end = empty_end;
+}
+
+void lochstreifen_set_highlight(LOCHSTREIFEN* l, int byte_number) {
+    l->highlight_byte = byte_number;
+    if(l->highlight_color == NULL)
+        l->highlight_color = cairo_pattern_create_rgb(242/255, 255/255, 0);
 }
 
@@ -357 +368 @@
     else if(byte > l->data_length) return -1; // im Emptyendbereich
     else return byte; // im gueltigen Bereich -- Byte gefunden!
-
+}
+
+int lochstreifen_coordinate_by_byte(LOCHSTREIFEN *l, int byte) {
+    /**
+     * Anhang eines Bytes (fuers Datenarray, ab 0 zaehlend) wird -- abhaengig nach aktueller
+     * Ausrichtung des Lochstreifens -- die Koordinate des Bytes in der Dimension der
+     * Ausrichtung des Lochstreifens zurueckgegeben..
+     * Liegt der Lochstreifen horizontal, so wird die x-Koordinate zurueckgegeben. Liegt er
+     * vertikal, dann die y-Koordinate.
+     *
+     **/
+     int xy;
+     //if(lochstreifen_get_orientation(l)) { // horizontal = 1 | vertical = 0
+        xy = l->margin + l->abriss + (l->d + l->bspace) * (byte + l->empty_start);
+     //}
+
+     return xy;
+     // TODO! Richtige implementierung!
 }
 
@@ -375 +403 @@
     x1 = l->only_start_x; y1 = l->only_start_y;
     x2 = x1 + width; y2 = y1 + height;
-    
+
     /*int x1,y1,x2,y2,x3,y3,x4,y4;
     x1 = l->only_start_x; y1 = l->only_start_y;
@@ -412 +440 @@
          cairo_matrix_multiply(&matrix, &matrix, &temp);
     }
-    
+
     //if(l->drehung > 0) {
         /*cairo_matrix_rotate(&matrix, l->drehung/2 *M_PI);
@@ -428 +456 @@
     cairo_set_matrix(cr, &matrix);
     // -1, 0, 0, 1, width, 0 = spiegelung x-achse
-    
+
     //cairo_device_to_user(cr, (double*)&(l->only_start_x), (double*)&(l->only_start_y));
     cairo_device_to_user(cr, (double*)&(x1), (double*)&(y1));
@@ -508 +536 @@
         if(l->only_width != 0 && x > l->only_start_x + l->only_width) break;
 
+        // ggf. Byte hervorheben
+        if(byte == l->highlight_byte && l->highlight_color != NULL) {
+            cairo_set_source(cr, l->highlight_color);
+            cairo_rectangle(cr, x - l->bspace/2, l->margin, l->df*2 + l->bspace, height - 2*l->margin);
+            cairo_fill(cr);
+        }
+
         // Bits des entsprechenden Bytes durchgehen
         for(loch=0, y = l->margin + l->padding; loch < 8; y += l->d + l->hspace, loch++) {

visualisator/lochstreifen.h

@@ -51 +51 @@
     int only_height;  // gezeichnet.
 
+
+    /* Feature: Ein bestimmtes Byte hervorheben */
+    int highlight_byte; // Nummer des Bytes (von 0)
+    cairo_pattern_t *highlight_color; // Farben => wenn NULL, kein Highlight
+
     /* Debugausgaben machen => wenn debug != 0 ist! */
     byte_t debug;