Frodo4/Src/Display_Be.h

/*
 *  Display_Be.h - C64 graphics display, emulator window handling,
 *                 Be specific stuff
 *
 *  Frodo (C) 1994-1997,2002-2003 Christian Bauer
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  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, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <AppKit.h>
#include <InterfaceKit.h>
#include <GameKit.h>
#include <string.h>

#include "C64.h"
#include "main.h"


#define BIT_BANG 0
#define MGA_HACK 1


// Window thread messages
const uint32 MSG_REDRAW = 1;


// C64 display and window frame
const BRect DisplayFrame = BRect(0, 0, DISPLAY_X-1, DISPLAY_Y-1);
const BRect WindowFrame = BRect(0, 0, DISPLAY_X-1, DISPLAY_Y-1 + 16);


// Background color
const rgb_color fill_gray = {208, 208, 208, 0};
const rgb_color shine_gray = {232, 232, 232, 0};
const rgb_color shadow_gray = {152, 152, 152, 0};


/*
  C64 keyboard matrix:

    Bit 7   6   5   4   3   2   1   0
  0    CUD  F5  F3  F1  F7 CLR RET DEL
  1    SHL  E   S   Z   4   A   W   3
  2     X   T   F   C   6   D   R   5
  3     V   U   H   B   8   G   Y   7
  4     N   O   K   M   0   J   I   9
  5     ,   @   :   .   -   L   P   +
  6     /   ^   =  SHR HOM  ;   *   Ł
  7    R/S  Q   C= SPC  2  CTL  <-  1
*/


/*
  Tables for key translation
  Bit 0..2: row/column in C64 keyboard matrix
  Bit 3   : implicit shift
  Bit 5   : joystick emulation (bit 0..4: mask)
*/

const int key_byte[128] = {
          -1,   7,   0,8+0,   0,8+0,  0, 8+0,
           0, 8+0,  -1, -1,  -1, -1, -1,  -1,

           7,   7,   7,  7,   1,  1,  2,   2,
           3,   3,   4,  4,   5,  5,  0, 8+0,

           6,   6,  -1, -1,  -1, -1, -1,   7,
           1,   1,   2,  2,   3,  3,  4,   4,

           5,   5,   6,  6,   0,  6,  6,0x25,
        0x21,0x29,  -1,  1,   1,  1,  2,   2,

           3,   3,   4,  4,   5,  5,  6,   0,
        0x24,0x30,0x28,  1,   1,  2,  2,   3,

           3,   4,   4,  5,   5,  6,  6, 8+0,
        0x26,0x22,0x2a,  0,   7, -1,  7,  -1,

        0x30, 8+0,   0,  0,0x30, -1,  7,   7,
          -1,  -1,  -1, -1,  -1, -1, -1,  -1,

          -1,  -1,  -1, -1,  -1, -1, -1,  -1,
          -1,  -1,  -1, -1,  -1, -1, -1,  -1
};

const int key_bit[128] = {
        -1,  7,  4,  4,  5,  5,  6,  6,
         3,  3, -1, -1, -1, -1, -1, -1,

         7,  1,  0,  3,  0,  3,  0,  3,
         0,  3,  0,  3,  0,  3,  0,  0,

         3,  0, -1, -1, -1, -1, -1,  6,
         1,  6,  1,  6,  1,  6,  1,  6,

         1,  6,  1,  6,  0,  0,  5, -1,
        -1, -1, -1,  7,  2,  5,  2,  5,

         2,  5,  2,  5,  2,  5,  2,  1,
        -1, -1, -1,  7,  4,  7,  4,  7,

         4,  7,  4,  7,  4,  7,  4,  7,
        -1, -1, -1,  1,  2, -1,  4, -1,

         5,  2,  7,  2, -1, -1,  5,  5,
        -1, -1, -1, -1, -1, -1, -1, -1,

        -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1
};


/*
 *  A simple view class for blitting a bitmap on the screen
 */

class BitmapView : public BView {
public:
        BitmapView(BRect frame, BBitmap *bitmap);
        virtual void Draw(BRect update);
        virtual void KeyDown(const char *bytes, int32 numBytes);
        void ChangeBitmap(BBitmap *bitmap);

private:
        BBitmap *the_bitmap;
};


/*
 *  Class for the main C64 display window
 */

class SpeedoView;
class LEDView;

class C64Window : public BDirectWindow {
public:
        C64Window();

        virtual bool QuitRequested(void);
        virtual void MessageReceived(BMessage *msg);
        virtual void DirectConnected(direct_buffer_info *info);

        BBitmap *TheBitmap[2];
        SpeedoView *Speedometer;
        LEDView *LED[4];

#if BIT_BANG
        uint8 *bits;
        int bytes_per_row;
#endif

private:
        BitmapView *main_view;
};


/*
 *  Class for the main C64 display using the GameKit
 */

class C64Screen : public BWindowScreen {
public:
        C64Screen(C64Display *display) : BWindowScreen("Frodo", B_8_BIT_640x480, &error), the_display(display)
        {
                Lock();
                TheBitmap = new BBitmap(DisplayFrame, B_COLOR_8_BIT);
                main_view = new BitmapView(Bounds(), TheBitmap);
                AddChild(main_view);
                main_view->MakeFocus();
                Connected = false;
                first_connected = true;
#if MGA_HACK
                mga_ready = false;
#endif
                Unlock();
        }
        ~C64Screen()
        {
                delete TheBitmap;
        }

        virtual void ScreenConnected(bool active);
        virtual void DispatchMessage(BMessage *msg, BHandler *handler);
        void DrawLED(int i, int state);
        void DrawSpeedometer(void);
        void FillRect(int x1, int y1, int x2, int y2, int color);

        bool Connected;                 // Flag: screen connected
        int Speed;
        char SpeedoStr[16];             // Speedometer value converted to a string
        BBitmap *TheBitmap;

private:
        C64Display *the_display;
        BitmapView *main_view;
        bool first_connected;
        status_t error;

#if MGA_HACK
        area_id mga_clone_area;
        volatile uint8 *isa_io;
        bool mga_ready;

        void CRTC_out(int reg, uint8 val) {isa_io[0x3d4] = reg; __eieio(); isa_io[0x3d5] = val; __eieio();}
        uint8 CRTC_in(int reg) {isa_io[0x3d4] = reg; __eieio(); return isa_io[0x3d5];}
        void SEQ_out(int reg, uint8 val) {isa_io[0x3c4] = reg; __eieio(); isa_io[0x3c5] = val; __eieio();}
        uint8 SEQ_in(int reg) {isa_io[0x3c4] = reg; __eieio(); return isa_io[0x3c5];}
        void GDC_out(int reg, uint8 val) {isa_io[0x3ce] = reg; __eieio(); isa_io[0x3cf] = val; __eieio();}
        uint8 GDC_in(int reg) {isa_io[0x3ce] = reg; __eieio(); return isa_io[0x3cf];}
        void ATC_out(int reg, uint8 val) {isa_io[0x3c0] = reg; __eieio(); isa_io[0x3c0] = val; __eieio();}
#endif
};


/*
 *  Class for speedometer
 */

class SpeedoView : public BView {
public:
        SpeedoView(BRect frame);
        virtual void Draw(BRect update);
        virtual void Pulse(void);
        void SetValue(int percent);

private:
        char speedostr[16];             // Speedometer value converted to a string
        BRect bounds;
};


/*
 *  Class for drive LED
 */

class LEDView : public BView {
public:
        LEDView(BRect frame, const char *label);
        virtual void Draw(BRect update);
        virtual void Pulse(void);
        void DrawLED(void);
        void SetState(int state);

private:
        int current_state;
        const char *the_label;
        BRect bounds;
};


/*
 *  Display constructor: Create window/screen
 */

C64Display::C64Display(C64 *the_c64) : TheC64(the_c64)
{
        // LEDs off
        for (int i=0; i<4; i++)
                led_state[i] = old_led_state[i] = LED_OFF;

        // Open window/screen
        draw_bitmap = 1;
        if (ThePrefs.DisplayType == DISPTYPE_SCREEN) {
                using_screen = true;
                the_screen = new C64Screen(this);
                the_screen->Show();
                while (!the_screen->Connected)
                        snooze(20000);
        } else {
                using_screen = false;
                the_window = new C64Window();
                the_window->Show();
        }

        // Prepare key_info buffer
        get_key_info(&old_key_info);
}


/*
 *  Display destructor
 */

C64Display::~C64Display()
{
        if (using_screen) {
                the_screen->Lock();
                the_screen->Quit();
        } else {
                the_window->Lock();
                the_window->Quit();
        }
}


/*
 *  Prefs may have changed
 */

void C64Display::NewPrefs(Prefs *prefs)
{
        if (prefs->DisplayType == DISPTYPE_SCREEN) {
                if (!using_screen) {
                        // Switch to full screen display
                        using_screen = true;
                        the_window->Lock();
                        the_window->Quit();
                        the_screen = new C64Screen(this);
                        the_screen->Show();
                        while (!the_screen->Connected)
                                snooze(20000);
                }
        } else {
                if (using_screen) {
                        // Switch to window display
                        using_screen = false;
                        the_screen->Lock();
                        the_screen->Quit();
                        the_window = new C64Window();
                        the_window->Show();
                }
        }
}


/*
 *  Redraw bitmap (let the window thread do it)
 */

void C64Display::Update(void)
{
        if (using_screen) {

                // Update LEDs/speedometer
                for (int i=0; i<4; i++)
                        the_screen->DrawLED(i, led_state[i]);
                the_screen->DrawSpeedometer();

                // Update C64 display in dobule scan mode
                if (ThePrefs.DoubleScan) {
                        uint8 *src = (uint8 *)the_screen->TheBitmap->Bits();
                        uint32 src_xmod = the_screen->TheBitmap->BytesPerRow();
                        src += src_xmod * 16 + 32;
                        uint8 *dest = (uint8 *)the_screen->CardInfo()->frame_buffer;
                        uint32 dest_xmod = the_screen->CardInfo()->bytes_per_row;
#ifdef __POWERPC__
                        double tmp[1];
                        for (int y=0; y<240; y++) {
                                uint32 *p = (uint32 *)src - 1;
                                double *q1 = (double *)dest - 1;
                                double *q2 = q1 + dest_xmod / sizeof(double);
                                for (int x=0; x<80; x++) {
                                        uint32 val = *(++p);
                                        uint8 *r = (uint8 *)&tmp[1];
                                        *(--r) = val;
                                        *(--r) = val;
                                        val >>= 8;
                                        *(--r) = val;
                                        *(--r) = val;
                                        val >>= 8;
                                        *(--r) = val;
                                        *(--r) = val;
                                        val >>= 8;
                                        *(--r) = val;
                                        *(--r) = val;
                                        double tmp2 = tmp[0];
                                        *(++q1) = tmp2;
                                        *(++q2) = tmp2;
                                }
                                src += src_xmod;
                                dest += dest_xmod * 2;
                        }
#else
                        for (int y=0; y<240; y++) {
                                uint32 *p = (uint32 *)src;
                                uint32 *q1 = (uint32 *)dest;
                                uint32 *q2 = q1 + dest_xmod / sizeof(uint32);
                                for (int x=0; x<80; x++) {
                                        uint32 val = *p++;
                                        uint32 tmp = val & 0x000000ff;
                                        tmp |= (val << 8) & 0x0000ff00;
                                        tmp |= (val << 8) & 0x00ff0000;
                                        tmp |= (val << 16) & 0xff000000;
                                        *q1++ = tmp;
                                        *q2++ = tmp;
                                        tmp = (val >> 16) & 0x000000ff;
                                        tmp |= (val >> 8) & 0x0000ff00;
                                        tmp |= (val >> 8) & 0x00ff0000;
                                        tmp |= val & 0xff000000;
                                        *q1++ = tmp;
                                        *q2++ = tmp;
                                }
                                src += src_xmod;
                                dest += dest_xmod * 2;
                        }
#endif
                }

        } else {

#if !BIT_BANG
                // Update C64 display
                BMessage msg(MSG_REDRAW);
                msg.AddInt32("bitmap", draw_bitmap);
                the_window->PostMessage(&msg);
                draw_bitmap ^= 1;
#endif

                // Update LEDs
                for (int i=0; i<4; i++)
                        if (led_state[i] != old_led_state[i]) {
                                the_window->LED[i]->SetState(led_state[i]);
                                old_led_state[i] = led_state[i];
                        }
        }
}


/*
 *  Set value displayed by the speedometer
 */

void C64Display::Speedometer(int speed)
{
        if (using_screen) {
                the_screen->Speed = speed;
                sprintf(the_screen->SpeedoStr, "%3d%%", speed);
        } else
                the_window->Speedometer->SetValue(speed);
}


/*
 *  Return pointer to bitmap data
 */

uint8 *C64Display::BitmapBase(void)
{
        if (using_screen) {
                if (ThePrefs.DoubleScan)
                        return (uint8 *)the_screen->TheBitmap->Bits();
                else
                        return (uint8 *)the_screen->CardInfo()->frame_buffer;
        } else
#if BIT_BANG
                return (uint8 *)the_window->bits;
#else
                return (uint8 *)the_window->TheBitmap[draw_bitmap]->Bits();
#endif
}


/*
 *  Return number of bytes per row
 */

int C64Display::BitmapXMod(void)
{
        if (using_screen) {
                if (ThePrefs.DoubleScan)
                        return the_screen->TheBitmap->BytesPerRow();
                else
                        return the_screen->CardInfo()->bytes_per_row;
        } else
#if BIT_BANG
                return the_window->bytes_per_row;
#else
                return the_window->TheBitmap[draw_bitmap]->BytesPerRow();
#endif
}


/*
 *  Poll the keyboard
 */

void C64Display::PollKeyboard(uint8 *key_matrix, uint8 *rev_matrix, uint8 *joystick)
{
        key_info the_key_info;
        int be_code, be_byte, be_bit, c64_byte, c64_bit;
        bool shifted;

        // Window must be active, command key must be up
        if (using_screen) {
                if (!the_screen->Connected)
                        return;
        } else
                if (!the_window->IsActive())
                        return;
        if (!(modifiers() & B_COMMAND_KEY)) {

                // Read the state of all keys
                get_key_info(&the_key_info);

                // Did anything change at all?
                if (!memcmp(&old_key_info, &the_key_info, sizeof(key_info)))
                        return;

                // Loop to convert BeOS keymap to C64 keymap
                for (be_code=0; be_code<0x68; be_code++) {
                        be_byte = be_code >> 3;
                        be_bit = 1 << (~be_code & 7);

                        // Key state changed?
                        if ((the_key_info.key_states[be_byte] & be_bit)
                             != (old_key_info.key_states[be_byte] & be_bit)) {

                                c64_byte = key_byte[be_code];
                                c64_bit = key_bit[be_code];
                                if (c64_byte != -1) {
                                        if (!(c64_byte & 0x20)) {

                                                // Normal keys
                                                shifted = c64_byte & 8;
                                                c64_byte &= 7;
                                                if (the_key_info.key_states[be_byte] & be_bit) {

                                                        // Key pressed
                                                        if (shifted) {
                                                                key_matrix[6] &= 0xef;
                                                                rev_matrix[4] &= 0xbf;
                                                        }
                                                        key_matrix[c64_byte] &= ~(1 << c64_bit);
                                                        rev_matrix[c64_bit] &= ~(1 << c64_byte);
                                                } else {

                                                        // Key released
                                                        if (shifted) {
                                                                key_matrix[6] |= 0x10;
                                                                rev_matrix[4] |= 0x40;
                                                        }
                                                        key_matrix[c64_byte] |= (1 << c64_bit);
                                                        rev_matrix[c64_bit] |= (1 << c64_byte);
                                                }
                                        } else {

                                                // Joystick emulation
                                                c64_byte &= 0x1f;
                                                if (the_key_info.key_states[be_byte] & be_bit)
                                                        *joystick &= ~c64_byte;
                                                else
                                                        *joystick |= c64_byte;
                                        }
                                }
                        }
                }

                old_key_info = the_key_info;
        }
}


/*
 *  Check if NumLock is down (for switching the joystick keyboard emulation)
 */

bool C64Display::NumLock(void)
{
        return modifiers() & B_NUM_LOCK;
}


/*
 *  Allocate C64 colors
 */

void C64Display::InitColors(uint8 *colors)
{
        BScreen scr(using_screen ? (BWindow *)the_screen : the_window);
        for (int i=0; i<256; i++)
                colors[i] = scr.IndexForColor(palette_red[i & 0x0f], palette_green[i & 0x0f], palette_blue[i & 0x0f]);
}


/*
 *  Pause display (GameKit only)
 */

void C64Display::Pause(void)
{
        if (using_screen)
                the_screen->Hide();
}


/*
 *  Resume display (GameKit only)
 */

void C64Display::Resume(void)
{
        if (using_screen)
                the_screen->Show();
}


/*
 *  Window constructor
 */

C64Window::C64Window() : BDirectWindow(WindowFrame, "Frodo", B_TITLED_WINDOW, B_NOT_RESIZABLE | B_NOT_ZOOMABLE)
{
        // Move window to right position
        Lock();
        MoveTo(80, 60);

        // Set up menus
        BMenuBar *bar = new BMenuBar(Bounds(), "");
        BMenu *menu = new BMenu("Frodo");
        menu->AddItem(new BMenuItem("About Frodo" B_UTF8_ELLIPSIS, new BMessage(B_ABOUT_REQUESTED)));
        menu->AddItem(new BSeparatorItem);
        menu->AddItem(new BMenuItem("Preferences" B_UTF8_ELLIPSIS, new BMessage(MSG_PREFS), 'P'));
        menu->AddItem(new BSeparatorItem);
        menu->AddItem(new BMenuItem("Reset C64", new BMessage(MSG_RESET)));
        menu->AddItem(new BMenuItem("Insert next disk", new BMessage(MSG_NEXTDISK), 'D'));
        menu->AddItem(new BMenuItem("SAM" B_UTF8_ELLIPSIS, new BMessage(MSG_SAM), 'M'));
        menu->AddItem(new BSeparatorItem);
        menu->AddItem(new BMenuItem("Load snapshot" B_UTF8_ELLIPSIS, new BMessage(MSG_OPEN_SNAPSHOT), 'O'));
        menu->AddItem(new BMenuItem("Save snapshot" B_UTF8_ELLIPSIS, new BMessage(MSG_SAVE_SNAPSHOT), 'S'));
        menu->AddItem(new BSeparatorItem);
        menu->AddItem(new BMenuItem("Quit Frodo", new BMessage(B_QUIT_REQUESTED), 'Q'));
        menu->SetTargetForItems(be_app);
        bar->AddItem(menu);
        AddChild(bar);
        SetKeyMenuBar(bar);
        int mbar_height = int(bar->Frame().bottom) + 1;

        // Resize window to fit menu bar
        ResizeBy(0, mbar_height);

        // Allocate bitmaps
        TheBitmap[0] = new BBitmap(DisplayFrame, B_COLOR_8_BIT);
        TheBitmap[1] = new BBitmap(DisplayFrame, B_COLOR_8_BIT);

        // Create top view
        BRect b = Bounds();
        BView *top = new BView(BRect(0, mbar_height, b.right, b.bottom), "top", B_FOLLOW_NONE, 0);
        AddChild(top);

        // Create bitmap view
        main_view = new BitmapView(DisplayFrame, TheBitmap[0]);
        top->AddChild(main_view);
        main_view->MakeFocus();

        // Create speedometer
        Speedometer = new SpeedoView(BRect(0, DISPLAY_Y, DISPLAY_X/5-1, DISPLAY_Y+15));
        top->AddChild(Speedometer);

        // Create drive LEDs
        LED[0] = new LEDView(BRect(DISPLAY_X/5, DISPLAY_Y, DISPLAY_X*2/5-1, DISPLAY_Y+15), "Drive 8");
        top->AddChild(LED[0]);
        LED[1] = new LEDView(BRect(DISPLAY_X*2/5, DISPLAY_Y, DISPLAY_X*3/5-1, DISPLAY_Y+15), "Drive 9");
        top->AddChild(LED[1]);
        LED[2] = new LEDView(BRect(DISPLAY_X*3/5, DISPLAY_Y, DISPLAY_X*4/5-1, DISPLAY_Y+15), "Drive 10");
        top->AddChild(LED[2]);
        LED[3] = new LEDView(BRect(DISPLAY_X*4/5, DISPLAY_Y, DISPLAY_X-1, DISPLAY_Y+15), "Drive 11");
        top->AddChild(LED[3]);

        // Set pulse rate to 0.4 seconds for blinking drive LEDs
        SetPulseRate(400000);
        Unlock();
}


/*
 *  Closing the window quits Frodo
 */

bool C64Window::QuitRequested(void)
{
        be_app->PostMessage(B_QUIT_REQUESTED);
        return false;
}


/*
 *  Handles redraw messages
 */

void C64Window::MessageReceived(BMessage *msg)
{
        BMessage *msg2;

        switch (msg->what) {
                case MSG_REDRAW:  // Redraw bitmap
                        MessageQueue()->Lock();
                        while ((msg2 = MessageQueue()->FindMessage(MSG_REDRAW, 0)) != NULL) {
                                MessageQueue()->RemoveMessage(msg2);
                                delete msg2;
                        }
                        MessageQueue()->Unlock();
                        main_view->ChangeBitmap(TheBitmap[msg->FindInt32("bitmap")]);
                        Lock();
                        main_view->Draw(DisplayFrame);
                        Unlock();
                        break;

                default:
                        BWindow::MessageReceived(msg);
        }
}


/*
 *  Window connected/disconnected
 */

void C64Window::DirectConnected(direct_buffer_info *info)
{
#if BIT_BANG
        switch (info->buffer_state & B_DIRECT_MODE_MASK) {
                case B_DIRECT_STOP:
//                      acquire_sem(drawing_sem);
                        break;
                case B_DIRECT_MODIFY:
//                      acquire_sem(drawing_sem);
                case B_DIRECT_START:
                        bits = ((uint8 *)info->bits + info->window_bounds.top * info->bytes_per_row + info->window_bounds.left * info->bits_per_pixel / 8);
                        bytes_per_row = info->bytes_per_row;
//                      release_sem(drawing_sem);
                        break;
        }
#endif
}


/*
 *  Workspace activated/deactivated
 */

void C64Screen::ScreenConnected(bool active)
{
        if (active) {
                if (first_connected) {
                        first_connected = false;

#if MGA_HACK
                        mga_clone_area = -1;

                        // Construct register area name
                        char mga_area_name[64];
                        int bus = 0, device = 13, function = 0;
                        sprintf(mga_area_name, "102B_0519_%02X%02X%02X regs", bus, device, function);

                        // Find MGA register area
                        area_id mga_area = find_area(mga_area_name);
                        if (mga_area > 0) {

                                // Clone area, remove write protection
                                volatile uint8 *mga_io;
                                mga_clone_area = clone_area("mga registers", (void **)&mga_io, B_ANY_ADDRESS, B_READ_AREA | B_WRITE_AREA, mga_area);
                                if (mga_clone_area > 0) {
                                        isa_io = mga_io + 0x1c00;
                                        mga_ready = true;
                                }
                        }
#endif
                }

#if MGA_HACK
                if (mga_ready) {
                        CRTC_out(0x09, 1);                      // Enable double scan
                        int a = 4 * 640;
                        CRTC_out(0x0c, a >> 8);         // Center screen vertically
                        CRTC_out(0x0d, a);
                        // defaults:
                        //  total               0x67
                        //  display end 0x4f
                        //  blank start 0x4f
                        //  blank end     2b
                        //  sync start  0x53
                        //  sync end      1f
                        CRTC_out(0x00, 0x3f);           // Horizontal timing
                        CRTC_out(0x01, 0x2f);
                        CRTC_out(0x02, 0x2f);
                        CRTC_out(0x03, 0x83);
                        CRTC_out(0x04, 0x32);
                        CRTC_out(0x05, 0x1a);
                }
#endif

                FillRect(0, 0, 639, 479, 0);    // Clear screen
                the_display->TheC64->Resume();
                Connected = true;
        } else {
                the_display->TheC64->Pause();
                Connected = false;
        }
        BWindowScreen::ScreenConnected(active);
}


/*
 *  Simulate menu commands
 */

void C64Screen::DispatchMessage(BMessage *msg, BHandler *handler)
{
        switch (msg->what) {
                case B_KEY_DOWN: {
                        uint32 mods = msg->FindInt32("modifiers");
                        if (mods & B_COMMAND_KEY) {
                                uint32 key = msg->FindInt32("raw_char");
                                switch (key) {
                                        case 'p':
                                                be_app->PostMessage(MSG_PREFS);
                                                break;
                                        case 'd':
                                                be_app->PostMessage(MSG_NEXTDISK);
                                                break;
                                        case 'm':
                                                be_app->PostMessage(MSG_SAM);
                                                break;
                                }
                        }
                        BWindowScreen::DispatchMessage(msg, handler);
                        break;
                }

                default:
                        BWindowScreen::DispatchMessage(msg, handler);
        }
}


/*
 *  Draw drive LEDs
 */

void C64Screen::DrawLED(int i, int state)
{
        int maxy;
        if (ThePrefs.DoubleScan)
                maxy = 480;
        else
                maxy = DISPLAY_Y;

        switch (state) {
                case LED_ON:
                        FillRect(10+i*20, maxy-20, 20+i*20, maxy-12, 54);
                        break;
                case LED_ERROR_ON:
                        FillRect(10+i*20, maxy-20, 20+i*20, maxy-12, 44);
                        break;
        }
}


/*
 *  Draw speedometer
 */

static const int8 Digits[11][8] = {     // Digit images
        {0x3c, 0x66, 0x6e, 0x76, 0x66, 0x66, 0x3c, 0x00},
        {0x18, 0x18, 0x38, 0x18, 0x18, 0x18, 0x7e, 0x00},
        {0x3c, 0x66, 0x06, 0x0c, 0x30, 0x60, 0x7e, 0x00},
        {0x3c, 0x66, 0x06, 0x1c, 0x06, 0x66, 0x3c, 0x00},
        {0x06, 0x0e, 0x1e, 0x66, 0x7f, 0x06, 0x06, 0x00},
        {0x7e, 0x60, 0x7c, 0x06, 0x06, 0x66, 0x3c, 0x00},
        {0x3c, 0x66, 0x60, 0x7c, 0x66, 0x66, 0x3c, 0x00},
        {0x7e, 0x66, 0x0c, 0x18, 0x18, 0x18, 0x18, 0x00},
        {0x3c, 0x66, 0x66, 0x3c, 0x66, 0x66, 0x3c, 0x00},
        {0x3c, 0x66, 0x66, 0x3e, 0x06, 0x66, 0x3c, 0x00},
        {0x62, 0x66, 0x0c, 0x18, 0x30, 0x66, 0x46, 0x00},
};

void C64Screen::DrawSpeedometer()
{
        // Don't display speedometer if we're running at about 100%
        if (Speed >= 50 && Speed <= 101)
                return;

        int maxx, maxy;
        if (ThePrefs.DoubleScan) {
                maxx = 640;
                maxy = 480;
        } else {
                maxx = DISPLAY_X;
                maxy = DISPLAY_Y;
        }

        char *s = SpeedoStr;
        char c;
        long xmod = CardInfo()->bytes_per_row;
        uint8 *p = (uint8 *)CardInfo()->frame_buffer + maxx - 8*8 + (maxy-20) * xmod;
        while ((c = *s++) != 0) {
                if (c == ' ')
                        continue;
                if (c == '%')
                        c = 10;
                else
                        c -= '0';
                uint8 *q = p;
                for (int y=0; y<8; y++) {
                        uint8 data = Digits[c][y];
                        for (int x=0; x<8; x++) {
                                if (data & (1 << (7-x)))
                                        q[x] = 255;
                                else
                                        q[x] = 0;
                        }
                        q += xmod;
                }
                p += 8;
        }
}


/*
 *  Fill rectangle
 */

void C64Screen::FillRect(int x1, int y1, int x2, int y2, int color)
{
        long xmod = CardInfo()->bytes_per_row;
        uint8 *p = (uint8 *)CardInfo()->frame_buffer + y1 * xmod + x1;
        int n = x2 - x1 + 1;
        for(int y=y1; y<=y2; y++) {
#ifdef __POWERPC__
                memset_nc(p, color, n);
#else
                memset(p, color, n);
#endif
                p += xmod;
        }
}


/*
 *  Bitmap view constructor
 */

BitmapView::BitmapView(BRect frame, BBitmap *bitmap) : BView(frame, "", B_FOLLOW_NONE, B_WILL_DRAW)
{
        ChangeBitmap(bitmap);
}


/*
 *  Blit the bitmap
 */

void BitmapView::Draw(BRect update)
{
        if (the_bitmap != NULL)
                DrawBitmapAsync(the_bitmap, update, update);
}


/*
 *  Receive special key-down events (main C64 keyboard handling is done in PollKeyboard)
 */

void BitmapView::KeyDown(const char *bytes, int32 numBytes)
{
        if (bytes[0] == B_FUNCTION_KEY || bytes[0] == '+' || bytes[0] == '-' || bytes[0] == '*' || bytes[0] == '/') {
                BMessage *msg = Window()->CurrentMessage();
                long key;
                if (msg->FindInt32("key", &key) == B_NO_ERROR) {
                        switch (key) {

                                case B_F11_KEY: // F11: NMI (Restore)
                                        be_app->PostMessage(MSG_NMI);
                                        break;

                                case B_F12_KEY: // F12: Reset
                                        be_app->PostMessage(MSG_RESET);
                                        break;

                                case 0x3a:              // '+' on keypad: Increase SkipFrames
                                        ThePrefs.SkipFrames++;
                                        break;

                                case 0x25:              // '-' on keypad: Decrease SkipFrames
                                        if (ThePrefs.SkipFrames > 1)
                                                ThePrefs.SkipFrames--;
                                        break;

                                case 0x24:              // '*' on keypad: Toggle speed limiter
                                        ThePrefs.LimitSpeed = !ThePrefs.LimitSpeed;
                                        break;

                                case 0x23:              // '/' on keypad: Toggle processor-level 1541 emulation
                                        be_app->PostMessage(MSG_TOGGLE_1541);
                                        break;
                        }
                }
        }
}


/*
 *  Change view bitmap
 */

void BitmapView::ChangeBitmap(BBitmap *bitmap)
{
        the_bitmap = bitmap;
}


/*
 *  Speedometer constructor
 */

SpeedoView::SpeedoView(BRect frame) : BView(frame, "", B_FOLLOW_NONE, B_WILL_DRAW | B_PULSE_NEEDED)
{
        speedostr[0] = 0;
        bounds = Bounds();
        SetViewColor(fill_gray);
        SetFont(be_plain_font);
}


/*
 *  Draw speedometer
 */

void SpeedoView::Draw(BRect update)
{
        // Draw bevelled border
        SetHighColor(shine_gray);
        StrokeLine(BPoint(0, bounds.bottom), BPoint(0, 0));
        StrokeLine(BPoint(bounds.right, 0));
        SetHighColor(shadow_gray);
        StrokeLine(BPoint(bounds.right, bounds.bottom), BPoint(bounds.right, 1));

        // Draw text
        SetHighColor(0, 0, 0);
        DrawString(speedostr, BPoint(24, 12));
}


/*
 *  Update speedometer at regular intervals
 */

void SpeedoView::Pulse(void)
{
        Invalidate(BRect(1, 1, bounds.right-1, 15));
}


/*
 *  Set new speedometer value
 */

void SpeedoView::SetValue(int speed)
{
        sprintf(speedostr, "%d%%", speed);
}


/*
 *  LED view constructor
 */

LEDView::LEDView(BRect frame, const char *label) : BView(frame, "", B_FOLLOW_NONE, B_WILL_DRAW | B_PULSE_NEEDED)
{
        current_state = 0;
        the_label = label;
        bounds = Bounds();
        SetViewColor(fill_gray);
        SetFont(be_plain_font);
}


/*
 *  Draw drive LED
 */

void LEDView::Draw(BRect update)
{
        // Draw bevelled border
        SetHighColor(shine_gray);
        StrokeLine(BPoint(0, bounds.bottom), BPoint(0, 0));
        StrokeLine(BPoint(bounds.right, 0));
        SetHighColor(shadow_gray);
        StrokeLine(BPoint(bounds.right, bounds.bottom), BPoint(bounds.right, 1));

        // Draw label
        SetHighColor(0, 0, 0);
        SetLowColor(fill_gray);
        DrawString(the_label, BPoint(8, 12));

        // Draw LED
        SetHighColor(shadow_gray);
        StrokeLine(BPoint(bounds.right-24, 12), BPoint(bounds.right-24, 4));
        StrokeLine(BPoint(bounds.right-8, 4));
        SetHighColor(shine_gray);
        StrokeLine(BPoint(bounds.right-23, 12), BPoint(bounds.right-8, 12));
        StrokeLine(BPoint(bounds.right-8, 5));
        DrawLED();
}


/*
 *  Redraw just the LED
 */

void LEDView::DrawLED(void)
{
        Window()->Lock();
        switch (current_state) {
                case LED_OFF:
                case LED_ERROR_OFF:
                        SetHighColor(32, 32, 32);
                        break;
                case LED_ON:
                        SetHighColor(0, 240, 0);
                        break;
                case LED_ERROR_ON:
                        SetHighColor(240, 0, 0);
                        break;
        }
        FillRect(BRect(bounds.right-23, 5, bounds.right-9, 11));
        Window()->Unlock();
}


/*
 *  Set LED state
 */

void LEDView::SetState(int state)
{
        if (state != current_state) {
                current_state = state;
                DrawLED();
        }
}


/*
 *  Toggle red error LED
 */

void LEDView::Pulse(void)
{
        switch (current_state) {
                case LED_ERROR_ON:
                        current_state = LED_ERROR_OFF;
                        DrawLED();
                        break;
                case LED_ERROR_OFF:
                        current_state = LED_ERROR_ON;
                        DrawLED();
                        break;
        }
}


/*
 *  Show a requester
 */

long ShowRequester(char *str, char *button1, char *button2)
{
        BAlert *the_alert;
        
        the_alert = new BAlert("", str, button1, button2, NULL, B_WIDTH_AS_USUAL, B_STOP_ALERT);
        return the_alert->Go();
}
Revision:	1.3
Committed:	2003-07-09T13:54:01Z (20 years, 9 months ago) by cebix
Content type:	text/plain
Branch:	MAIN
Changes since 1.2:	+221 -17 lines
Log Message:	faster display (including dirty hardware hacks)