canola/window/card_reader.cc

Go to the documentation of this file.

//
// canola - canon canola 1614p emulator
// Copyright (C) 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/config.h>
#include <libexplain/gettimeofday.h>

#include <lib/program_card/functor/image/pixbuf.h>

#include <canola/calculator/gnome.h>
#include <canola/window/card_reader.h>


window_card_reader::~window_card_reader()
{
}


window_card_reader::window_card_reader(calculator_gnome *a_dst) :
    dst(*a_dst),
    pixels_per_second(100),
    pixels_per_instruction(1),
    current_address(0),
    current_card_number(0),
    currently_moving_left(false),
    current_card_started(0)
{
    set_transient_for(*a_dst);
    set_decorated(false);
    Glib::RefPtr<Gdk::Visual> vp = get_screen()->get_rgba_visual();
    if (vp)
    {
        set_app_paintable();
        gtk_widget_set_visual(Gtk::Widget::gobj(), vp->gobj());
    }
    else
    {
        fprintf(stderr, "%s: %d: transparency not available\n", __FILE__,
            __LINE__);
    }
    add(layout);
}


window_card_reader::pointer
window_card_reader::create(calculator_gnome *a_dst)
{
    return pointer(new window_card_reader(a_dst));
}


static double
get_time_of_day(void)
{
    timeval result;
    explain_gettimeofday_or_die(&result, 0);
    return (result.tv_usec * 1e-6 + result.tv_sec);
}


static int
get_position_x(int card_num)
{
    return (card_num * 30);
}


static int
get_position_y(int card_num)
{
    return (card_num * 10);
}


bool
window_card_reader::start(const std::string &src, bool binary)
{
    //
    // Load the card set into the proxy.  We use a proxy for two
    // reasons:
    // 1. We have to dole out the instrinctions on at a time, as the
    //    animation progresses, so as to emulate the reading of the
    //    opcode by the original optical reader.
    // 2. We have to store them as a "program" even in the case where
    //    the cards are a data set for one of the General Function card
    //    sets.
    //
    dst.program_mode_set(calculator::program_mode_learn);
    dst.clear_program();
    if (!dst.load_program(src, binary))
        return false;

    //
    // Now that we have the program, turn it into a set of images in pixbufs.
    // It is these pixbufs that can be displayed by Gtk::Image wigdets.
    //
    double dpi = get_screen()->get_resolution();
    card_pixbufs.clear();
    program_card_functor_image_pixbuf::pointer ffs =
        program_card_functor_image_pixbuf::create(card_pixbufs, dpi);
    ffs->set_disassemble(true);
    dst.program_card_walk(*ffs);
    ffs.reset();
    if (card_pixbufs.empty())
        return false;

    //
    // Calculate how fast the card will have to travel under the
    // simulated optical reader at the top of the window.
    //
    pixels_per_second = card_pixbufs[0]->get_height() / 4.;
    pixels_per_instruction = card_pixbufs[0]->get_height() / 40;
    assert(pixels_per_instruction >= 1);

    //
    // For each of the pixbufs, create a Gtk::Image widget to display
    // it.  We have to do this in reverse, so that the first card is the
    // last widget, and comes out on top of the visable stack of cards.
    //
    card_image_widgets.clear();
    for (size_t j = 0; j < card_pixbufs.size(); ++j)
    {
        size_t jj = card_pixbufs.size() - 1 - j;
        pixbuf_ptr_t pp = card_pixbufs[jj];
        assert(pp);
        if (pp)
        {
            gtk_image_ptr_t p(new Gtk::Image(pp));
            card_image_widgets.push_back(p);
            layout.put(*p, get_position_x(jj), get_position_y(jj));
        }
    }

    //
    // Show the window, and its card images, to the user.
    //
    assert(card_image_widgets.size() == card_pixbufs.size());
    if (is_composited())
    {
        layout.hide();
        show();
        Gdk::RGBA glass;
        glass.set_rgba(1., 1., 1., 0.);
        assert(get_window());
        get_window()->set_background(glass);
    }
    show_all_children();

    current_card_number = 0;
    currently_moving_left = false;
    current_card_started = get_time_of_day();
    current_address = 1;

    //
    // Start the animation timer running.
    //
    animation_timer =
        Glib::signal_timeout().connect
        (
            sigc::mem_fun(*this, &window_card_reader::on_animation_timer),
            1000 / 24
        );
    return true;
}


bool
window_card_reader::empty(void)
    const
{
    return card_image_widgets.empty();
}


bool
window_card_reader::on_animation_timer(void)
{
    if (current_card_number >= card_image_widgets.size())
    {
        done();
        return false;
    }

    int card_height = card_pixbufs[0]->get_height();
    double now = get_time_of_day();
    double t = now - current_card_started;
    int jj = card_image_widgets.size() - 1 - current_card_number;
    if (currently_moving_left)
    {
        int x0 = get_position_x(current_card_number);
        int y = get_position_y(current_card_number);
        int x = x0 - t * pixels_per_second;
        if (x <= 0)
        {
            x = 0;
            currently_moving_left = false;
            current_card_started = now;
        }
        layout.move(*card_image_widgets[jj], x, y);
    }
    else
    {
        int x = 0;
        int y0 = get_position_y(current_card_number);
        int yz = -card_height;
        int y = y0 - t * pixels_per_second;
        layout.move(*card_image_widgets[jj], x, y);
        if (y < 0)
        {
            int new_addr = -y / pixels_per_instruction;
            if (new_addr < 40)
            {
                new_addr += current_card_number * 40;
                ++new_addr;
                while (current_address <= new_addr)
                {
                    dst.forward(current_address);
                    ++current_address;
                }
            }
        }
        if (y < yz)
        {
            assert((current_address % 40) == 1);
            ++current_card_number;
            currently_moving_left = true;
            current_card_started = now;
        }
    }
    return true;
}


void
window_card_reader::done(void)
{
    //
    // No need for the time any more.
    //
    animation_timer.disconnect();

    //
    // Hide the window.
    //
    hide();

    //
    // Remove the image widgets from the layout.
    //
    while (!card_image_widgets.empty())
    {
        gtk_image_ptr_t wp = card_image_widgets.back();
        card_image_widgets.pop_back();
        layout.remove(*wp);
    }

    //
    // Free the card images.
    //
    card_pixbufs.clear();
}


bool
window_card_reader::is_busy(void)
{
    return animation_timer.connected();
}