canola/calculator/gnome.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/config.h>
#include <gtkmm.h>
#include <gdkmm/window.h>
#include <libexplain/output.h>

#include <lib/sizeof.h>
#include <lib/unicode.h>
#include <lib/std_string_printf.h>

#include <canola/calculator/gnome.h>
#include <canola/debugger/gnome.h>
#include <canola/dialog/preferences.h>
#include <canola/dialog/prog_mode.h>
#include <canola/dialog/special_key_symbol.h>
#include <canola/load_image.h>
#include <canola/message_dialog/error.h>
#include <canola/window/card_reader.h>


calculator_gnome::~calculator_gnome()
{
    delete error_window;
}


static Gdk::RGBA black("#000000");
static Gdk::RGBA white("#FFFFFF");
static Gdk::RGBA red("#FF0000");


calculator_gnome::calculator_gnome() :
    button_uj("UJ", "blue", white),
    button_mj("MJ", "blue", white),
    button_ej("EJ", "blue", white),
    button_sj("SJ", "blue", white),
    button_fj("FJ", "blue", white),
    button_rv("RV", "black", white),
    button_cm1("CM\n1", "cream", black),
    button_c("C", "cream", black),
    button_chg_sign("CHG\nSIGN", "black", red),
    button_right(UNICODE_RIGHT, "black", white),
    button_cm2("CM\n2", "cream", black),
    button_clear_indicator("CI", "cream", black),
    button_n7("7", "white", black),
    button_n4("4", "white", black),
    button_n1("1", "white", black),
    button_n0("0", "wide-white", black),
    button_n8("8", "white", black),
    button_n5("5", "white", black),
    button_n2("2", "white", black),
    button_n9("9", "white", black),
    button_n6("6", "white", black),
    button_n3("3", "white", black),
    button_dot(".", "white", black),
    button_mul(UNICODE_MUL, "white", black),
    button_ent("ENT", "blue", white),
    button_start("S\nT\nA\nR\nT", "tall-blue", white),
    button_k("K", "black", white, true),
    button_div(UNICODE_DIV, "white", black),
    button_sqrt(UNICODE_SQRT, "white", black),
    button_minus_equals("-\n=", "white", red),
    button_plus_equals("+\n=", "white", black),
    button_am1("AM\n1", "black", white, true),
    button_m3("M\n3~", "black", white),
    button_m2("M\n2", "black", white),
    button_m1("M\n1", "black", white),
    button_sm3("SM\n3~", "black", white),
    button_mm2("M\n2", "black", red),
    button_mm1("M\n1", "black", red),
    button_cm3("CM\n3~", "cream", black),
    button_rm3("RM\n3~", "black", white),
    button_rm2("RM\n2", "black", white),
    button_rm1("RM\n1", "black", white),
    keyboard(4, 16, true),
    printer_label("Printer"),
    printer_power("Power"),
    printer_manual_calculation("Man\nCalc"), // ("Manual\nCalculation"),
    printer_display_print("Disp\nPrint"), // ("Display\nPrint"),
    printer_program_print("Prog\nPrint"), // ("Program\nPrint"),
    printer_paper_feed("Paper\nFeed"),
    debugger_label("Debugger"),
    error_window(0),
    animate_card_reader(true)
{
    set_icon(load_gui_image("canola"));

    // Build the menu bar across the top of the window.
    {
        menu_ui = Gtk::UIManager::create();

        Glib::RefPtr<Gtk::ActionGroup> file_menu =
            Gtk::ActionGroup::create();
        file_menu->add(Gtk::Action::create("MenuFile", "_File"));
        file_menu->add
        (
            Gtk::Action::create("LoadProg", "Load Program..."),
            sigc::mem_fun(*this, &calculator_gnome::on_load_program)
        );

        file_menu->add(Gtk::Action::create("SaveProg", "_Save Program..."),
            sigc::mem_fun(*this, &calculator_gnome::on_save_program));
        file_menu->add
        (
            Gtk::Action::create("SaveMemProg", "_Save Memories as Program..."),
            sigc::mem_fun(*this, &calculator_gnome::on_save_memories_as_program)
        );
        file_menu->add(Gtk::Action::create("Quit", Gtk::Stock::QUIT),
            sigc::mem_fun(*this, &calculator_gnome::on_quit));
        menu_ui->insert_action_group(file_menu);

        Glib::RefPtr<Gtk::ActionGroup> edit_menu =
            Gtk::ActionGroup::create();
        edit_menu->add(Gtk::Action::create("MenuEdit", "_Edit"));
        edit_menu->add
        (
            Gtk::Action::create("SpecialKeySym", "Special Key Symbol..."),
            sigc::mem_fun(*this, &calculator_gnome::on_special_key_symbol)
        );
        edit_menu->add
        (
            Gtk::Action::create("EditPrefs", "Preferences..."),
            sigc::mem_fun(*this, &calculator_gnome::on_edit_preferences)
        );
        menu_ui->insert_action_group(edit_menu);

        // tell the parent window to respond to
        // the specified keyboard shortcuts
        add_accel_group(menu_ui->get_accel_group());

        menu_ui->add_ui_from_string
        (
            "<ui>"
            "  <menubar name='MenuBar'>"
            "    <menu action='MenuFile'>"
            "      <menuitem action='LoadProg'/>"
            "      <menuitem action='SaveProg'/>"
            "      <menuitem action='SaveMemProg'/>"
            "      <menuitem action='Quit'/>"
            "    </menu>"
            "    <menu action='MenuEdit'>"
#if 0
            "      <menuitem action='Cut'/>"
            "      <menuitem action='Copy'/>"
            "      <menuitem action='Paste'/>"
#endif
            "      <menuitem action='SpecialKeySym'/>"
            "      <menuitem action='EditPrefs'/>"
            "    </menu>"
            "  </menubar>"
            "</ui>"
        );

        menu_bar = menu_ui->get_widget("/MenuBar");
    }

    const int layout_spacing = 20;

    Gdk::RGBA blue_normal("#27a1a6");
    Gdk::RGBA blue_active("#3bf7ff");
    Gdk::RGBA white("#ffffff");
    Gdk::RGBA black("#000000");
    Gdk::RGBA cream_normal("#ddcd92");
    //Gdk::RGBA cream_active("#ffeca8");
    Gdk::RGBA cream_active("#fff800");
    Gdk::RGBA red("#ff0000");
    Gdk::RGBA gray_normal("#404040");
    Gdk::RGBA gray_active("#202020");

    // ---------- the first set are the keyboard ---------------------------

    // first column
    button_uj.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_uj));
    keyboard.attach(button_uj, 0, 1, 0, 1);

    button_mj.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_mj));
    keyboard.attach(button_mj, 0, 1, 1, 2);

    button_ej.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_ej));
    keyboard.attach(button_ej, 0, 1, 2, 3);

    button_sj.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_sj));
    keyboard.attach(button_sj, 0, 1, 3, 4);

    // second column
    button_fj.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_fj));
    keyboard.attach(button_fj, 2, 3, 0, 1);

    button_rv.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_rv));
    keyboard.attach(button_rv, 2, 3, 1, 2);

    button_cm1.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_cm1));
    keyboard.attach(button_cm1, 2, 3, 2, 3);

    button_c.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_c));
    keyboard.attach(button_c, 2, 3, 3, 4);

    // column 3
    button_chg_sign.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_chg_sign));
    keyboard.attach(button_chg_sign, 3, 4, 0, 1);

    button_right.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_right));
    keyboard.attach(button_right, 3, 4, 1, 2);

    button_cm2.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_cm2));
    keyboard.attach(button_cm2, 3, 4, 2, 3);

    button_clear_indicator.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_clear_indicator));
    keyboard.attach(button_clear_indicator, 3, 4, 3, 4);

    // column 4
    button_n7.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_n7));
    keyboard.attach(button_n7, 5, 6, 0, 1);

    button_n4.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_n4));
    keyboard.attach(button_n4, 5, 6, 1, 2);

    button_n1.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_n1));
    keyboard.attach(button_n1, 5, 6, 2, 3);

    button_n0.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_n0));
    keyboard.attach(button_n0, 5, 7, 3, 4);

    // column 5
    button_n8.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_n8));
    keyboard.attach(button_n8, 6, 7, 0, 1);

    button_n5.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_n5));
    keyboard.attach(button_n5, 6, 7, 1, 2);

    button_n2.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_n2));
    keyboard.attach(button_n2, 6, 7, 2, 3);

    // column 6
    button_n9.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_n9));
    keyboard.attach(button_n9, 7, 8, 0, 1);

    button_n6.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_n6));
    keyboard.attach(button_n6, 7, 8, 1, 2);

    button_n3.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_n3));
    keyboard.attach(button_n3, 7, 8, 2, 3);

    button_dot.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_dot));
    keyboard.attach(button_dot, 7, 8, 3, 4);

    // column 7
    button_mul.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_mul));
    keyboard.attach(button_mul, 9, 10, 0, 1);

    button_ent.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_ent));
    keyboard.attach(button_ent, 9, 10, 1, 2);

    button_start.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_start));
    keyboard.attach(button_start, 9, 10, 2, 4);

    // column 8
    button_k.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_k_down));
    button_k.signal_released().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_k_up));
    keyboard.attach(button_k, 10, 11, 0, 1);

    // column 9
    button_div.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_div));
    keyboard.attach(button_div, 11, 12, 0, 1);

    button_sqrt.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_sqrt));
    keyboard.attach(button_sqrt, 11, 12, 1, 2);

    button_minus_equals.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_minus_equals));
    keyboard.attach(button_minus_equals, 11, 12, 2, 3);

    button_plus_equals.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_plus_equals));
    keyboard.attach(button_plus_equals, 11, 12, 3, 4);

    // column 10
    button_am1.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_am1_down));
    button_am1.signal_released().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_am1_up));
    keyboard.attach(button_am1, 13, 14, 0, 1);

    button_m3.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_m3_tilde));
    keyboard.attach(button_m3, 13, 14, 1, 2);

    button_m2.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_m2));
    keyboard.attach(button_m2, 13, 14, 2, 3);

    button_m1.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_m1));
    keyboard.attach(button_m1, 13, 14, 3, 4);

    // column 11
    button_sm3.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_sm3_tilde));
    keyboard.attach(button_sm3, 14, 15, 1, 2);

    button_mm2.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_mm2));
    keyboard.attach(button_mm2, 14, 15, 2, 3);

    button_mm1.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_mm1));
    keyboard.attach(button_mm1, 14, 15, 3, 4);

    // column 12
    button_cm3.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_cm3_tilde));
    keyboard.attach(button_cm3, 15, 16, 0, 1);

    button_rm3.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_rm3_tilde));
    keyboard.attach(button_rm3, 15, 16, 1, 2);

    button_rm2.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_rm2));
    keyboard.attach(button_rm2, 15, 16, 2, 3);

    button_rm1.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_rm1));
    keyboard.attach(button_rm1, 15, 16, 3, 4);

    signal_key_press_event().connect(sigc::mem_fun(*this,
        &calculator_gnome::do_key_press_event));

    // ---------- the next set are the controls ----------------------------
    //
    power_switch.set_value(1);
    control_group.pack_start(power_switch);
    power_switch.value_changed_signal().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_quit));

    program_mode_switch.set_value((int)program_mode_get());
    program_mode_switch.value_changed_signal().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_program_mode_switch_changed));
    control_group.pack_start(program_mode_switch);

    program_selector_switch.set_value((int)program_selector_get());
    program_selector_switch.value_changed_signal().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_program_selector_switch_changed));
    control_group.pack_start(program_selector_switch);

    rounding_switch.set_value((int)precision_and_rounding_get().get_rounding());
    rounding_switch.value_changed_signal().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_rounding_switch_changed));
    control_group.pack_start(rounding_switch);

    decimal_point_selector_dial_tree_model =
        Gtk::ListStore::create(decimal_point_selector_dial_columns);
    decimal_point_selector_dial.set_model(
        decimal_point_selector_dial_tree_model);
    {
        struct table_t
        {
            int value;
            const char *name;
        };

        static const table_t table[] =
        {
            { 0, "Integer" },
            { 1, "1 Places" },
            { 2, "2 Places" },
            { 3, "3 Places" },
            { 4, "4 Places" },
            { 5, "5 Places" },
            { 6, "6 Places" },
            { 7, "7 Places" },
            { 8, "8 Places" },
            { 10, "10 Places" },
            { 12, "12 Places" },
            { -1, "Floating" },
        };

        for (const table_t *tp = table; tp < ENDOF(table); ++tp)
        {
            Gtk::TreeModel::Row row =
                *(decimal_point_selector_dial_tree_model->append());
            row[decimal_point_selector_dial_columns.column_id] = tp->value;
            row[decimal_point_selector_dial_columns.column_name] = tp->name;

            if (tp->value == precision_and_rounding_get().get_precision())
                decimal_point_selector_dial.set_active(tp - table);
        }
    }
    decimal_point_selector_dial.pack_start(
        decimal_point_selector_dial_columns.column_name);
    decimal_point_selector_dial.signal_changed().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_decimal_point_selector_dial_changed));
    control_group.pack_start(decimal_point_selector_dial);

    control_group.set_spacing(layout_spacing);

    // ---------- bring all the calculator widgets together --------------------
    display_widget_aligner.add(display_widget);
    calculator_layout.pack_start(display_widget_aligner, Gtk::PACK_SHRINK);
    calculator_layout.pack_start(control_group, Gtk::PACK_SHRINK);
    calculator_layout.pack_start(keyboard, Gtk::PACK_SHRINK);
    calculator_layout.set_spacing(layout_spacing);

    // ---------- next are the printer widgets ---------------------------------
    right_hand_panel.append_page(printer_group, printer_label);

    printer_paper.set_size_request(100, 50);
    {
        Pango::FontDescription fdesc;
        fdesc.set_family("monospace");
        //fdesc.set_size(10 * PANGO_SCALE);
        printer_paper.override_font(fdesc);
    }
    {
        // create a "red" tag so that we can use it later
        Glib::RefPtr<Gtk::TextTag> tp =
            printer_paper.get_buffer()->create_tag("red");
        tp->property_foreground().set_value("red");
    }
    printer_paper.set_editable(false);
    printer_paper_scroller.add(printer_paper);
    printer_paper_scroller.set_policy(Gtk::POLICY_AUTOMATIC,
        Gtk::POLICY_AUTOMATIC);
    printer_group.pack_start(printer_paper_scroller);
    printer_group.set_border_width(layout_spacing / 2);
    printer_group.pack_start(printer_button_group, Gtk::PACK_SHRINK);
    printer_group.set_spacing(layout_spacing);
    printer_button_group.pack_start(printer_power);
    printer_power.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_printer_power));
    printer_button_group.pack_start(printer_manual_calculation);
    printer_button_group.pack_start(printer_display_print);
    printer_display_print.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_display_print));
    printer_button_group.pack_start(printer_program_print);
    printer_program_print.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_program_print));
    printer_button_group.pack_start(printer_paper_feed);
    printer_paper_feed.signal_clicked().connect(sigc::mem_fun(*this,
        &calculator_gnome::on_paper_feed));
    printer_button_group.set_homogeneous();

    // ---------- next are the debugger widgets --------------------------------
    right_hand_panel.append_page(debugger_content, debugger_label);
    debugger_content.address_value_changed_signal().connect(
        sigc::mem_fun(*this, &calculator_gnome::user_changed_debugger_address));

    // ---------- bring the two units (calculator and printer) together --------
    overall_layout.pack_start(calculator_layout, Gtk::PACK_SHRINK);
    overall_layout.pack_start(right_hand_panel);
    overall_layout.set_spacing(layout_spacing);
    overall_layout.set_border_width(layout_spacing);

    // ---------- pack the menu bar and everything else together ---------------
    menu_layout.pack_start(*menu_bar, Gtk::PACK_SHRINK);
    menu_layout.pack_start(overall_layout);
    add(menu_layout);

    override_background_color(custom_widget_background, Gtk::STATE_FLAG_NORMAL);

    load_preferences_file();
    update_display();
    show_all_children();
}


calculator::pointer
calculator_gnome::create(void)
{
    return pointer(new calculator_gnome());
}


void
calculator_gnome::derived_update_display(const display &value)
{
    display_widget.set_value(value);
    update_debugger(debugger_content);
}


void
calculator_gnome::on_opcode(opcode_t op)
{
    calculator::on_opcode(op, location::pointer());
}


void
calculator_gnome::on_plus_equals(void)
{
    on_opcode(opcode_plus_equals);
}


void
calculator_gnome::on_minus_equals(void)
{
    on_opcode(opcode_minus_equals);
}


void
calculator_gnome::on_mul(void)
{
    on_opcode(opcode_mul);
}


void
calculator_gnome::on_div(void)
{
    on_opcode(opcode_div);
}


void
calculator_gnome::on_sqrt(void)
{
    on_opcode(opcode_sqrt);
}


void
calculator_gnome::on_ent(void)
{
    on_opcode(opcode_ent);
}


void
calculator_gnome::on_sj(void)
{
    on_opcode(opcode_sj);
}


void
calculator_gnome::on_ej(void)
{
    on_opcode(opcode_ej);
}


void
calculator_gnome::on_mj(void)
{
    on_opcode(opcode_mj);
}


void
calculator_gnome::on_uj(void)
{
    on_opcode(opcode_uj);
}


void
calculator_gnome::on_fj(void)
{
    on_opcode(opcode_fj);
}


void
calculator_gnome::on_m1(void)
{
    on_opcode(opcode_m1);
}


void
calculator_gnome::on_m2(void)
{
    on_opcode(opcode_m2);
}


void
calculator_gnome::on_mm1(void)
{
    on_opcode(opcode_mm1);
}


void
calculator_gnome::on_mm2(void)
{
    on_opcode(opcode_mm2);
}


void
calculator_gnome::on_rm1(void)
{
    on_opcode(opcode_rm1);
}


void
calculator_gnome::on_rm2(void)
{
    on_opcode(opcode_rm2);
}


void
calculator_gnome::on_clear_indicator(void)
{
    on_opcode(opcode_clear_indicator);
}


void
calculator_gnome::on_cm1(void)
{
    on_opcode(opcode_cm1);
}


void
calculator_gnome::on_cm2(void)
{
    on_opcode(opcode_cm2);
}


void
calculator_gnome::on_dot(void)
{
    on_opcode(opcode_dot);
}


void
calculator_gnome::on_rv(void)
{
    on_opcode(opcode_rv);
}


void
calculator_gnome::on_right(void)
{
    on_opcode(opcode_right);
}


void
calculator_gnome::on_chg_sign(void)
{
    on_opcode(opcode_chg_sign);
}


void
calculator_gnome::on_n0(void)
{
    on_opcode(opcode_n0);
}


void
calculator_gnome::on_n1(void)
{
    on_opcode(opcode_n1);
}


void
calculator_gnome::on_n2(void)
{
    on_opcode(opcode_n2);
}


void
calculator_gnome::on_n3(void)
{
    on_opcode(opcode_n3);
}


void
calculator_gnome::on_n4(void)
{
    on_opcode(opcode_n4);
}


void
calculator_gnome::on_n5(void)
{
    on_opcode(opcode_n5);
}


void
calculator_gnome::on_n6(void)
{
    on_opcode(opcode_n6);
}


void
calculator_gnome::on_n7(void)
{
    on_opcode(opcode_n7);
}


void
calculator_gnome::on_n8(void)
{
    on_opcode(opcode_n8);
}


void
calculator_gnome::on_n9(void)
{
    on_opcode(opcode_n9);
}


void
calculator_gnome::on_start(void)
{
    on_opcode(opcode_extended_start);
    update_debugger(debugger_content);
}


void
calculator_gnome::on_k_down(void)
{
    constant_mode_set(true);
}


void
calculator_gnome::on_k_up(void)
{
    constant_mode_set(false);
}


void
calculator_gnome::on_am1_down(void)
{
    accumulate_mode_set(true);
}


void
calculator_gnome::on_am1_up(void)
{
    accumulate_mode_set(false);
}


void
calculator_gnome::on_m3_tilde(void)
{
    on_opcode(opcode_extended_m3_tilde);
}


void
calculator_gnome::on_sm3_tilde(void)
{
    on_opcode(opcode_extended_sm3_tilde);
}


void
calculator_gnome::on_cm3_tilde(void)
{
    on_opcode(opcode_extended_cm3_tilde);
}


void
calculator_gnome::on_rm3_tilde(void)
{
    on_opcode(opcode_extended_rm3_tilde);
}


void
calculator_gnome::on_quit(void)
{
    exit(0);
}


void
calculator_gnome::on_error_v(const char *fmt, va_list ap)
{
    std::string text = std_string_printf_v(fmt, ap);
    if (!error_window)
        error_window = new message_dialog_error(*this);
    error_window->add_text(text);
}


static void
insert_at_end(Gtk::TextView &tv, const Glib::ustring &text)
{
    tv.get_buffer()->insert(tv.get_buffer()->end(), text);
}


static void
insert_at_end_red(Gtk::TextView &tv, const Glib::ustring &text)
{
    tv.get_buffer()->insert_with_tag(tv.get_buffer()->end(), text, "red");
}


static void
insert_space_until(Gtk::TextView &tv, int &column, int target)
{
    if (column >= target)
        return;
    Glib::ustring buffer;
    while (column < target)
    {
        buffer += ' ';
        ++column;
    }
    insert_at_end(tv, buffer);
}


void
calculator_gnome::derived_print(const display &value)
{
    right_hand_panel.show();
    right_hand_panel.set_current_page(0);
    Glib::ustring buffer;
    for (int dignum = 15; dignum >= 0; --dignum)
    {
        const display::tube_t &tube = value.tubes[dignum];
        if (tube.digit >= 10)
            buffer += ' ';
        else
            buffer += (char)('0' + tube.digit);
        if (tube.dot)
            buffer += '.';
    }
    int column = 18;
    if (value.negative)
    {
        buffer += '-';
        ++column;
    }
    if (value.negative)
        insert_at_end_red(printer_paper, buffer);
    else
        insert_at_end(printer_paper, buffer);

    switch (value.column18)
    {
    case display::column18_blank:
        break;

    case display::column18_minus:
        if (!value.negative)
        {
            insert_space_until(printer_paper, column, 18);
            insert_at_end_red(printer_paper, "-");
            ++column;
        }
        break;

    case display::column18_ce:
        insert_space_until(printer_paper, column, 18);
        insert_at_end(printer_paper, "CE");
        column += 2;
        break;

    case display::column18_cm:
        insert_space_until(printer_paper, column, 18);
        insert_at_end(printer_paper, "CM");
        column += 2;
        break;

    case display::column18_e:
        insert_space_until(printer_paper, column, 18);
        insert_at_end(printer_paper, "E");
        ++column;
        break;

    case display::column18_fj:
        insert_space_until(printer_paper, column, 18);
        insert_at_end(printer_paper, "FJ");
        column += 2;
        break;

    case display::column18_ej:
        insert_space_until(printer_paper, column, 18);
        insert_at_end(printer_paper, "EJ");
        column += 2;
        break;

    case display::column18_uj:
        insert_space_until(printer_paper, column, 18);
        insert_at_end(printer_paper, "UJ");
        column += 2;
        break;

    case display::column18_mj:
        insert_space_until(printer_paper, column, 18);
        insert_at_end(printer_paper, "MJ");
        column += 2;
        break;

    case display::column18_sj:
        insert_space_until(printer_paper, column, 18);
        insert_at_end(printer_paper, "SJ");
        column += 2;
        break;

    case display::column18_rv:
        // Question: in which column is RV printed?
        insert_space_until(printer_paper, column, 18);
        insert_at_end(printer_paper, "RV");
        column += 2;
        break;

    case display::column18_sfj:
        // Question: in which column is SFJ printed?
        insert_space_until(printer_paper, column, 18);
        insert_at_end(printer_paper, "SFJ");
        column += 3;
        break;

    case display::column18_suj:
        // Question: in which column is SUJ printed?
        insert_space_until(printer_paper, column, 18);
        insert_at_end(printer_paper, "SUJ");
        column += 3;
        break;

    case display::column18_srj:
        // Question: in which column is SRJ printed?
        insert_space_until(printer_paper, column, 18);
        insert_at_end(printer_paper, "SRJ");
        column += 3;
        break;

    case display::column18_right:
        // Question: in which column is [->] printed?
        insert_space_until(printer_paper, column, 18);
        insert_at_end(printer_paper, UNICODE_RIGHT);
        ++column;
        break;

    case display::column18_cs:
        // Question: in which column is CHG_SIGN printed?
        insert_space_until(printer_paper, column, 18);
        insert_at_end_red(printer_paper, "CS");
        column += 2;
        break;

    default:
        break;
    }
    switch (value.column19)
    {
    case display::column19_blank:
        break;

    case display::column19_plus_equals:
        insert_space_until(printer_paper, column, 19);
        insert_at_end(printer_paper, "+=");
        column += 2;
        break;

    case display::column19_minus_equals:
        insert_space_until(printer_paper, column, 19);
        insert_at_end_red(printer_paper, "-=");
        column += 2;
        break;

    case display::column19_times:
        insert_space_until(printer_paper, column, 19);
        insert_at_end(printer_paper, UNICODE_MUL);
        ++column;
        break;

    case display::column19_divide:
        insert_space_until(printer_paper, column, 19);
        insert_at_end(printer_paper, UNICODE_DIV);
        ++column;
        break;

    case display::column19_sqrt:
        insert_space_until(printer_paper, column, 19);
        insert_at_end(printer_paper, UNICODE_SQRT);
        ++column;
        break;

    case display::column19_m_plus:
        insert_space_until(printer_paper, column, 19);
        insert_at_end(printer_paper, "M+");
        column += 2;
        break;

    case display::column19_m_minus:
        insert_space_until(printer_paper, column, 19);
        insert_at_end_red(printer_paper, "M-");
        column += 2;
        break;

    case display::column19_rm:
        insert_space_until(printer_paper, column, 19);
        insert_at_end(printer_paper, "RM");
        column += 2;
        break;

    case display::column19_sm:
        // Question: in which column is SM printed?
        insert_space_until(printer_paper, column, 19);
        insert_at_end(printer_paper, "SM");
        column += 2;
        break;

    case display::column19_print:
        insert_space_until(printer_paper, column, 19);
        insert_at_end(printer_paper, UNICODE_PRINT);
        ++column;
        break;

    default:
        break;
    }
    switch (value.column20)
    {
    case display::column20_blank:
        break;

    case display::column20_n1:
        insert_space_until(printer_paper, column, 20);
        insert_at_end(printer_paper, "1");
        ++column;
        break;

    case display::column20_fd:
        insert_space_until(printer_paper, column, 20);
        insert_at_end(printer_paper, "FD");
        column += 2;
        break;

    case display::column20_round_up:
        insert_space_until(printer_paper, column, 20);
        insert_at_end(printer_paper, UNICODE_UP);
        ++column;
        break;

    case display::column20_round_off:
        insert_space_until(printer_paper, column, 20);
        insert_at_end(printer_paper, "5/4");
        column += 3;
        break;

    case display::column20_round_down:
        insert_space_until(printer_paper, column, 20);
        insert_at_end(printer_paper, UNICODE_DOWN);
        ++column;
        break;

    case display::column20_dot:
        insert_space_until(printer_paper, column, 20);
        insert_at_end(printer_paper, ".");
        ++column;
        break;

    default:
        break;
    }
    switch (value.column21)
    {
    case display::column21_blank:
        break;

    case display::column21_n0:
    case display::column21_n1:
    case display::column21_n2:
    case display::column21_n3:
    case display::column21_n4:
    case display::column21_n5:
    case display::column21_n6:
    case display::column21_n7:
    case display::column21_n8:
    case display::column21_n9:
        {
            insert_space_until(printer_paper, column, 21);
            Glib::ustring buffer;
            buffer += (char)('0' + value.column21 - display::column21_n0);
            insert_at_end(printer_paper, buffer);
            ++column;
        }
        break;

    default:
        break;
    }
    insert_at_end(printer_paper, "\n");
    Gtk::TextBuffer::iterator end = printer_paper.get_buffer()->end();
    printer_paper.scroll_to(end, 0.);
}


void
calculator_gnome::derived_feed(void)
{
    right_hand_panel.show();
    right_hand_panel.set_current_page(0);
    insert_at_end(printer_paper, "\n");
    Gtk::TextBuffer::iterator end = printer_paper.get_buffer()->end();
    printer_paper.scroll_to(end, 0.);
}


void
calculator_gnome::run(void)
{
    Gtk::Main::run(*this);
}


void
calculator_gnome::on_c(void)
{
    on_opcode(opcode_extended_c);
}


void
calculator_gnome::derived_off(void)
{
    hide();
}


void
calculator_gnome::on_display_print(void)
{
    on_opcode(opcode_extended_display_print);
}


void
calculator_gnome::on_paper_feed(void)
{
    on_opcode(opcode_extended_paper_feed);
}


void
calculator_gnome::on_program_print(void)
{
    on_opcode(opcode_extended_program_print);
}


void
calculator_gnome::on_printer_power(void)
{
    right_hand_panel.hide();
    resize(400, 100);
}


static std::string
getcwd(void)
{
    char buffer[2000];
    if (!getcwd(buffer, sizeof(buffer)))
        return ".";
    return buffer;
}


void
calculator_gnome::on_load_program(void)
{
    if (animate_card_reader && crp && crp->is_busy())
    {
        on_error
        (
            "The card reader is busy at the present time.  "
            "Try again when the card reader is not in use."
        );
        return;
    }

    Gtk::FileChooserDialog dialog("Load Program",
        Gtk::FILE_CHOOSER_ACTION_OPEN);
    dialog.set_transient_for(*this);
    dialog.set_current_folder(getcwd());

    Gtk::CheckButton binary("Binary");
    binary.show();
    dialog.get_action_area()->pack_start(binary);

    // Add response buttons the the dialog:
    dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
    dialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_OK);

    if (dialog.run() == Gtk::RESPONSE_OK)
    {
        dialog.hide();
        if (program_mode_get() != program_mode_learn)
            dialog_prog_mode(this).run();

        if (animate_card_reader)
        {
            right_hand_panel.show();

            // get window-relative coordinates of right hand panel
            int rhs_x = 0;
            int rhs_y = 0;
            right_hand_panel.translate_coordinates(*this, 0, 0, rhs_x, rhs_y);

            // get root coordinates of right hand panel
            int move_x = 0;
            int move_y = 0;
            Glib::RefPtr<Gdk::Window> window = get_window();
            window->get_root_coords(rhs_x, rhs_y, move_x, move_y);

            if (!crp)
                crp = window_card_reader::create(this);
            crp->start(dialog.get_filename(), binary.get_active());
            crp->move(move_x, move_y);
            crp->show();
        }
        else
        {
            load_program(dialog.get_filename().c_str(), binary.get_active());
        }

    }
}


void
calculator_gnome::on_save_program(void)
{
    Gtk::FileChooserDialog dialog("Save Program As",
        Gtk::FILE_CHOOSER_ACTION_SAVE);
    dialog.set_transient_for(*this);
    dialog.set_current_folder(getcwd());

    Gtk::CheckButton binary("Binary");
    binary.show();
    dialog.get_action_area()->pack_start(binary);

    // Add response buttons the the dialog:
    dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
    dialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_OK);

    if (dialog.run() == Gtk::RESPONSE_OK)
    {
        save_program_as(dialog.get_filename().c_str(), binary.get_active());
    }
}


void
calculator_gnome::on_save_memories_as_program(void)
{
    Gtk::FileChooserDialog dialog("Save Memories as Program",
        Gtk::FILE_CHOOSER_ACTION_SAVE);
    dialog.set_transient_for(*this);
    dialog.set_current_folder(getcwd());

    // Add response buttons the the dialog:
    dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
    dialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_OK);

    if (dialog.run() == Gtk::RESPONSE_OK)
    {
        save_memories_as_program(dialog.get_filename());
    }
}


bool
calculator_gnome::do_key_press_event(GdkEventKey *event)
{
#if 0
    fprintf(stderr, "%s: %d: press:\n", __FILE__, __LINE__);
    fprintf(stderr, "  state = %d\n", event->state);
    fprintf(stderr, "  keyval = %d\n", event->keyval);
    fprintf(stderr, "  length = %d\n", event->length);
    fprintf(stderr, "  string = \"%.*s\"\n", event->length, event->string);
    fprintf(stderr, "  hardware_keycode = %d\n", event->hardware_keycode);
    fprintf(stderr, "  group = %d\n", event->group);
    fprintf(stderr, "  is_modifier = %d\n", event->is_modifier);
#endif
    switch (event->keyval)
    {
    case '0': case '1': case '2': case '3': case '4':
    case '5': case '6': case '7': case '8': case '9':
        on_opcode(opcode_t(opcode_n0 + (int)event->keyval - '0'));
        return false;

    case '.':
        on_opcode(opcode_dot);
        return false;

    case '-':
        on_opcode(opcode_minus_equals);
        return false;

    case '+':
    case '=':
        on_opcode(opcode_plus_equals);
        return false;

    case '*':
        on_opcode(opcode_mul);
        return false;

    case '/':
        on_opcode(opcode_div);
        return false;

    default:
        break;
    }
    return true;
}


void
calculator_gnome::on_program_mode_switch_changed(void)
{
    program_mode_t id = (program_mode_t)program_mode_switch.get_value();
    program_mode_set(id);
    if (id == calculator::program_mode_operation_check)
    {
        right_hand_panel.show();
        right_hand_panel.set_current_page(1);
        update_debugger(debugger_content);
    }
}


void
calculator_gnome::on_program_selector_switch_changed(void)
{
    program_selector_t id =
        (program_selector_t)program_selector_switch.get_value();
    program_selector_set(id);
}


void
calculator_gnome::program_mode_set_from_dialog(int id)
{
    program_mode_set((program_mode_t)id);
    program_mode_switch.set_value((int)program_mode_get());
}


void
calculator_gnome::on_rounding_switch_changed(void)
{
    precision_and_rounding_set
    (
        precision_and_rounding
        (
            precision_and_rounding_get().get_precision(),
            (precision_and_rounding::round_t)rounding_switch.get_value()
        )
    );
}


void
calculator_gnome::on_decimal_point_selector_dial_changed(void)
{
    Gtk::TreeModel::iterator iter = decimal_point_selector_dial.get_active();
    if (iter)
    {
        Gtk::TreeModel::Row row = *iter;
        if (row)
        {
            int id = row[decimal_point_selector_dial_columns.column_id];
            precision_and_rounding_set
            (
                precision_and_rounding
                (
                    id,
                    precision_and_rounding_get().get_rounding()
                )
            );
        }
    }
}


bool
calculator_gnome::on_clock_tick(void)
{
    clock_tick_event();
    if (clock_tick_expected())
        return true;
    clock_tick_timer.disconnect();
    return false;
}


void
calculator_gnome::clock_tick_start_running(void)
{
    if (!clock_tick_timer.connected())
    {
        // FIXME: make this configurable
        clock_tick_timer =
            Glib::signal_timeout().connect
            (
                sigc::mem_fun(*this, &calculator_gnome::on_clock_tick),
                100 // milliseconds
            );
    }
}


bool
calculator_gnome::on_printer_finished(void)
{
    printer_timer.disconnect();
    printer_finished_event();
    return false;
}


void
calculator_gnome::printer_timer_start_running(void)
{
    if (!printer_timer.connected())
    {
        printer_timer =
            Glib::signal_timeout().connect
            (
                sigc::mem_fun(*this, &calculator_gnome::on_printer_finished),
                420 // milliseconds
            );
    }
}


void
calculator_gnome::on_special_key_symbol(void)
{
    int n = dialog_special_key_symbol(this).run();
    if (n >= 0 && n < 128)
        on_opcode(opcode_t(n));
}


void
calculator_gnome::on_edit_preferences(void)
{
    dialog_preferences pref(this);
    pref.set_animate_card_reader(animate_card_reader);
    pref.set_strict_memory_numbers(strict_memory_number_checking_required());
    if (pref.run() == Gtk::RESPONSE_OK)
    {
        animate_card_reader = pref.get_animate_card_reader();
        strict_memory_number_checking_set(pref.get_strict_memory_numbers());
        save_preferences_file();
    }
}


void
calculator_gnome::load_preferences_file(void)
{
}


void
calculator_gnome::save_preferences_file(void)
{
}


void
calculator_gnome::user_changed_debugger_address(int n)
{
    set_address(n);
    update_debugger(debugger_content);
}


// vim: set ts=8 sw=4 et :