lib/program_card/functor/image.cc

Go to the documentation of this file.

//
// canola - canon canola 1614p emulator
// Copyright (C) 2011, 2012 Peter Miller
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License, version 3, as
// published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include <lib/ac/assert.h>
#include <pangomm.h>
#include <pangomm/init.h>

#include <lib/context_saver.h>
#include <lib/opcode.h>
#include <lib/program_card/functor/image.h>
#include <lib/std_string_printf.h>


program_card_functor_image::~program_card_functor_image()
{
}


program_card_functor_image::program_card_functor_image() :
    trim_corners(false),
    perforations(true),
    disassemble(false),
    arrow(false),
    card_num(0),
    card_count(0),
    color("blue"),
    style(style_aus),
    accuracy(0),
    step_count(0)
{
}


void
program_card_functor_image::set_position(int cn, int cc)
{
    assert(cc >= 1);
    assert(cn >= 1);
    assert(cn <= cc);
    card_num = cn;
    card_count = cc;
}


#define card_width 1360
#define card_height 4425
#define hole_width 73.6
#define hole_height 30.8


static inline double
y_from_row(double row)
{
    // floating arg because sometimes want halfway in between
    return 199.910199833 + 104.489383847 * row;
}


static inline double
x_from_bit(double bit)
{
    // floating arg because sometimes want halfway in between
    return 1056.19285714 - 151.321428571 * bit;
}


void
program_card_functor_image::outline(const Cairo::RefPtr<Cairo::Context> &cr)
{
    // 1360x4425
    cr->move_to(0, 4425);
    cr->line_to(1360, 4425);
    if (trim_corners)
    {
        cr->line_to(1360, 109);
        cr->line_to(1360 - 120, 0);
        cr->line_to(120, 0);
        cr->line_to(0, 109);
    }
    else
    {
        cr->line_to(1360, 0);
        cr->line_to(0, 0);
    }
    cr->close_path();
}


void
program_card_functor_image::draw(const Cairo::RefPtr<Cairo::Context> &cr,
    const unsigned char *data, size_t data_size)
{
    assert(data_size > 0);
    assert(data_size <= 40);

    // we get our drawing context scaled so that its units of
    // measurements are points.  Rescale to 600dpi, because that is the
    // scale of the card images the measurements were taken from.
    context_saver cs1(cr);
    {
        double dpi = 600;
        double s = 72. / dpi;
        cr->scale(s, s);
    }

    // Set the clipping region.
    outline(cr);
    // We add all of the holes to the clipping region
    // so that we have actual holes in the PNG and SVG outputs.
    for (unsigned row = 0; row < 40 && row < data_size; ++row)
    {
        double row_top = y_from_row(row) - (hole_height / 2);
        double row_bot = row_top + hole_height;
        unsigned char op = data[row];
        for (unsigned bit = 0; bit < 7; ++bit)
        {
            if (op & (1 << bit))
            {
                double col_lhs = x_from_bit(bit) - (hole_width / 2);
                double col_rhs = col_lhs + hole_width;
                // clockwise for holes
                cr->begin_new_sub_path();
                cr->move_to(col_rhs, row_top);
                cr->line_to(col_rhs, row_bot);
                cr->line_to(col_lhs, row_bot);
                cr->line_to(col_lhs, row_top);
                cr->close_path();
            }
        }
    }
    cr->clip();

    // Card background.
    {
        context_saver cs2(cr);
        if (color == "green")
            cr->set_source_rgb(133./255., 168./255., 135./255.);
        else if (color == "pink" || color == "red")
            cr->set_source_rgb(240./255., 128./255., 144./255.);
        else if (color == "gray" || color == "grey")
            cr->set_source_rgb(184./255., 199./255., 193./255.);
        else if (color == "cyan")
            cr->set_source_rgb(116./255., 170./255., 171./255.);
        else
            cr->set_source_rgb(95./255., 153./255., 168./255.); // blue
        cr->move_to(0, 4425);
        cr->line_to(1360, 4425);
        cr->line_to(1360, 0);
        cr->line_to(0, 0);
        cr->close_path();
        cr->fill();
    }

    //
    // Draw an outline around the card, it gives the card a more
    // definite edge.
    //
    outline(cr);
    cr->set_line_width(4);
    cr->stroke();

    cr->set_source_rgb(0, 0, 0);
    switch (style)
    {
    case style_blank:
        // dividing line
        {
            context_saver cs3(cr);
            cr->set_line_width(6);
            cr->move_to(1123, 0);
            cr->line_to(1123, 4425);
            cr->stroke();
        }

        // The bottom of the card gets labeled as being for the Canon
        // Canola 1614P.
        {
            context_saver cs4(cr);
            std::string text = "CANON CANOLA 1614P";
            cr->set_font_size(57);
            Cairo::TextExtents ext;
            cr->get_text_extents(text, ext);
            cr->move_to((1120 - ext.width) / 2, 4395);
            cr->show_text(text);
        }
        break;

    case style_ibm:
        {
            context_saver cs4(cr);
            std::string text = "IBM 6905920132 (46.2)  X71-9263";
            cr->set_font_size(36);
            Cairo::TextExtents ext;
            cr->get_text_extents(text, ext);
            cr->move_to((1360 - ext.width) / 2, 4401);
            cr->show_text(text);
        }
        goto aus_ibm_common;

    case style_aus:
        {
            context_saver csx(cr);
            std::string text = "IBM-/30131   PRINTED IN AUSTRALIA";
            cr->set_font_size(34);
            Cairo::TextExtents ext;
            cr->get_text_extents(text, ext);
            cr->move_to((1360 - ext.width) / 2, 4383);
            cr->show_text(text);
        }
    default:
        aus_ibm_common:
        {
            context_saver cs4(cr);
            double y2 = y_from_row(-0.5);
            double y1 = y2 / 2;
            double y3 = y_from_row(39.5);

            double x1 = x_from_bit(6.5);
            double x2 = x_from_bit(-0.5);

            cr->set_line_width(6);
            cr->move_to(x1, y1);
            cr->line_to(x2, y1);
            cr->move_to(0, y2);
            cr->line_to(card_width, y2);
            cr->move_to(0, y3);
            cr->line_to(card_width, y3);
            cr->move_to(x1, 0);
            cr->line_to(x1, y3);
            cr->move_to(x2, 0);
            cr->line_to(x2, y3);
            cr->move_to(x_from_bit(3.5), y1);
            cr->rel_line_to(0, y3 - y1);
            cr->stroke();

            cr->set_line_width(3);
            for (unsigned bit = 0; bit <= 6; ++bit)
            {
                cr->move_to(x_from_bit(bit), y2);
                cr->rel_line_to(0, y3 - y2);
            }
            cr->stroke();

            for (unsigned row = 0; row < 40; ++row)
            {
                if ((row % 10) == 9)
                    continue;
                cr->move_to(x1, y_from_row(row));
                cr->rel_line_to(x2 - x1, 0);
            }
            cr->stroke();

            cr->set_line_width(5);
            for (unsigned row = 9; row < 40; row += 10)
            {
                cr->move_to(x1, y_from_row(row));
                cr->rel_line_to(x2 - x1, 0);
            }
            cr->stroke();

            std::string text = "CANON PROGRAM CARD";
            cr->set_font_size(49);
            Cairo::TextExtents ext;
            cr->get_text_extents(text, ext);
            cr->move_to((x2 + x1 - ext.width) / 2, (y1 + ext.height) / 2);
            cr->show_text(text);

            cr->set_font_size(36);
            cr->move_to(x2 + 10, y2 - 46);
            cr->show_text("KEY");
            cr->move_to(x2 + 10, y2 - 12);
            cr->show_text("SYMBOL");

            {
                context_saver csa(cr);
                cr->rotate_degrees(90);
                text = "STEP";
                cr->get_text_extents(text, ext);
                cr->move_to(y2 - ext.width - 12, -(x1 - ext.height) + 10);
                cr->show_text(text);
            }

            for (int bit = 0; bit < 7; ++bit)
            {
                static const char *t[] =
                    { "1", "2", "4", "8", "10", "20", "40" };
                std::string text(t[bit]);
                double x = x_from_bit(bit);
                double y = y2 - 12;
                cr->get_text_extents(text, ext);
                cr->move_to(x - ext.width/2, y);
                cr->show_text(text);
            }

            for (unsigned row = 0; row < 40; ++row)
            {
                std::string text = std_string_printf("%d", row + 1);
                cr->get_text_extents(text, ext);
                double x = (x1 - ext.width) / 2;
                double y = y_from_row(row) + (ext.height / 2);
                cr->move_to(x, y);
                cr->show_text(text);
            }
        }
        break;
    }

    //
    // draw a directional arrow
    //
    if (arrow)
    {
        enum { x1 = 108, x2 = 230 };
        enum { y1 = 540, y2 = 1614 };
        context_saver cs9(cr);
        double cx = x_from_bit(3);
        double cy = y_from_row(-1);
        cr->move_to(cx, cy),
        cr->rel_line_to(-x2, y1),
        cr->rel_line_to(x2 - x1,  0),
        cr->rel_line_to(0, y2 - y1),
        cr->rel_line_to(2 * x1, 0),
        cr->rel_line_to(0,  y1 - y2),
        cr->rel_line_to(x2 - x1, 0),
        cr->close_path();
        cr->clip();

        enum { w = 2 };
        cr->set_line_width(2 * w);
        for (int n = -15; n <= 15; ++n)
        {
            double x = cx + n * ((x2 - w) / 15.);
            cr->move_to(x, cy);
            cr->rel_line_to(0, y2);
            cr->stroke();
        }
    }

    //
    // note where this card falls in the set
    //
    if (card_count > 0 && card_num >= 1 && card_num <= card_count)
    {
        std::string text = std_string_printf("%d of %d", card_num, card_count);
        context_saver cs9(cr);
        cr->set_font_size(600);
        Cairo::TextExtents ext;
        cr->get_text_extents(text, ext);
        cr->rotate_degrees(90);
        double baseline = y_from_row(38.5);
        cr->move_to(baseline - ext.width, -(1200 - ext.height) / 2);
        cr->set_source_rgba(0, 0, 0, 0.2);
        cr->show_text(text);
    }
    card_num = 0;
    card_count = 0;

    if (!title.empty())
    {
        context_saver cs9(cr);
        cr->set_font_size(180);
        Cairo::TextExtents ext;
        cr->get_text_extents(title, ext);
        cr->translate(card_width, 325);
        double ht = card_width - 1123;
        cr->rotate_degrees(90);
        double y = (ht + ext.height) / 2;
        if (disassemble)
            y += ht;
        cr->move_to(0, y);
        cr->show_text(title);
    }

    // The bits are the holes in the clipping region, so there is no
    // need to draw them, but we need to draw the perforations.
    if (perforations)
    {
        bool stroke = false;
        for (unsigned row = 0; row < 40; ++row)
        {
            double row_top = y_from_row(row) - (hole_height / 2);
            double row_bot = row_top + hole_height;
            unsigned char op = (row < data_size ? data[row] : 0);
            for (unsigned bit = 0; bit < 7; ++bit)
            {
                double col_lhs = x_from_bit(bit) - (hole_width / 2);
                double col_rhs = col_lhs + hole_width;
                if (!(op & (1 << bit)))
                {
                    cr->move_to(col_lhs, row_top);
                    cr->line_to(col_lhs, row_bot);
                    cr->line_to(col_rhs, row_bot);
                    cr->line_to(col_rhs, row_top);
                    cr->close_path();
                    stroke = true;
                }
            }
        }
        if (stroke)
        {
            cr->set_source_rgba(0, 0, 0, 0.2);
            cr->set_line_width(2);
            cr->stroke();
        }
    }

    // Draw the opcodes down the right hand side.
    if (disassemble)
    {
        cr->set_font_size(60);
        for (unsigned row = 0; row < 40 && row < data_size; ++row)
        {
            double row_top = y_from_row(row) - (hole_height / 2);
            double row_bot = row_top + hole_height;
            opcode_t op = (opcode_t)data[row];
            if (opcode_red(op))
                cr->set_source_rgb(0.8, 0, 0);
            else
                cr->set_source_rgb(0, 0, 0);
            std::string text = opcode_uname(op);
            Cairo::TextExtents ext;
            cr->get_text_extents(text, ext);
            cr->move_to((1360 + 1126 - ext.width) / 2, row_bot);
            cr->show_text(text);
        }
    }
}


void
program_card_functor_image::set_title(const std::string &text)
{
    title = text;
}


void
program_card_functor_image::set_arrow(bool value)
{
    arrow = value;
}


void
program_card_functor_image::set_color(const std::string &text)
{
    color = text;
}


void
program_card_functor_image::set_disassemble(bool value)
{
    disassemble = value;
}


void
program_card_functor_image::set_perforations(bool value)
{
    perforations = value;
}


void
program_card_functor_image::set_trim_corners(bool value)
{
    trim_corners = value;
}


void
program_card_functor_image::set_style(const std::string &text)
{
    if (text == "aus")
    {
        style = style_aus;
        color = "blue";
        perforations = true;
        arrow = false;
        trim_corners = false;
        disassemble = true;
    }
    else if (text == "ibm")
    {
        style = style_ibm;
        color = "grey";
        perforations = true;
        arrow = false;
        trim_corners = true;
        disassemble = true;
    }
    else if (text == "blank")
    {
        style = style_blank;
        color = "green";
        perforations = false;
        arrow = true;
        trim_corners = true;
        disassemble = false;
    }
}


void
program_card_functor_image::draw_envelope(
    const Cairo::RefPtr<Cairo::Context> &cr)
{
    context_saver cs1(cr);
    {
        double dpi = 600;
        double s = 72. / dpi;
        cr->scale(s, s);
    }

    enum { margin = 25 };
    enum { flap = 250 };
    enum { thumb = 300 }; // half inch

    const double ew = card_width + 2 * margin;
    const double eh = card_height + margin;

    cr->move_to(0, 0);
    cr->line_to(0, eh);
    cr->line_to(ew, eh);
    cr->line_to(ew + margin, eh + flap);
    cr->line_to(2 * ew - margin, eh + flap);
    cr->line_to(2 * ew, eh);
    cr->line_to(2 * ew + flap, card_height);
    cr->line_to(2 * ew + flap, margin);
    cr->line_to(2 * ew, 0);
    cr->line_to(ew + thumb, 0);
    cr->line_to(ew, thumb);
    cr->line_to(ew - thumb, 0);
    cr->close_path();
    cr->set_source_rgb(82./255, 171./255, 205./255);
    cr->fill_preserve();
    cr->set_source_rgb(0, 0, 0);
    cr->set_line_width(6);
    cr->stroke();

    cr->set_line_width(3);
    cr->move_to(ew, thumb);
    cr->line_to(ew, eh);
    cr->move_to(2 * ew, 0);
    cr->line_to(2 * ew, eh);
    cr->move_to(ew, eh);
    cr->line_to(2 * ew, eh);
    cr->stroke();

    // front of envelope
    {
        const double inset = 600/8;
        context_saver cs2(cr);
        cr->translate(ew, eh);
        cr->rotate_degrees(-90);

        //cr->move_to(0, 100);
        //cr->set_font_size(100);
        //cr->show_text("You are here.");

        cr->move_to(inset, inset);
        cr->line_to(inset, ew - inset);
        cr->line_to(eh - inset, ew - inset);
        if (inset < thumb * M_SQRT2)
        {
            double thumb_inset = thumb + inset * (M_SQRT2 - 1);
            cr->line_to(eh - inset, thumb_inset);
            cr->line_to(eh - thumb_inset, inset);
        }
        else
            cr->line_to(eh - inset, inset);
        cr->close_path();
        cr->stroke_preserve();
        cr->clip();
        cr->translate(inset, inset);
        double iw = eh - 2 * inset;

        // title
        if (!title.empty())
        {
            context_saver cs3(cr);
            cr->set_font_size(180);
            Cairo::TextExtents ext;
            cr->get_text_extents(title, ext);
            double x = 600/8;
            double y = (237 + ext.height) / 2;
            cr->move_to(x, y);
            cr->show_text(title);
        }
        cr->move_to(0, 237);
        cr->line_to(iw, 237);
        cr->stroke();

        std::string text;
        if (!sfj_list.empty())
        {
            text += "Subroutine Flag for Jump Symbol Codes Used: ";
            text += sfj_list + "\n";
        }
        if (accuracy > 0)
            text += std_string_printf("Accuracy: %d digits\n", accuracy);
        if (step_count)
            text += std_string_printf("Number of Steps: %d\n", step_count);
        text += std_string_printf("Number of Cards: %d\n", card_count);
        if (!fj_list.empty())
            text += "Flag for Jump Symbol Codes Used: " + fj_list + "\n";
        if (!memory_list.empty())
            text += "Memories Used: " + memory_list + "\n";

        cr->translate(iw / 2, 237);
        double ps = 600./72;
        cr->scale(ps, ps);
        Pango::init();
        cr->move_to(0, 0);
        Glib::RefPtr<Pango::Layout> plp = Pango::Layout::create(cr);
        Pango::FontDescription pango_font = Pango::FontDescription("sans 9");
        pango_font.set_weight(Pango::WEIGHT_NORMAL);
        plp->set_font_description(pango_font);
        plp->set_indent(-10 * Pango::SCALE);
        plp->set_width(Pango::SCALE * (iw / 2) / ps);
        plp->set_text(text);
        plp->add_to_cairo_context(cr);
        cr->fill();
    }
}


void
program_card_functor_image::set_sfj_list(const std::string &text)
{
    sfj_list = text;
}


void
program_card_functor_image::set_fj_list(const std::string &text)
{
    fj_list = text;
}


void
program_card_functor_image::set_memory_list(const std::string &text)
{
    memory_list = text;
}


void
program_card_functor_image::set_steps(int value)
{
    step_count = value;
}