src/MacOSX/video_macosx.mm

/*
 *  $Id: video_macosx.mm,v 1.3 2002/05/30 12:43:32 nigel Exp $
 *
 *  video_macosx.mm - Interface between Basilisk II and Cocoa windowing.
 *                    Based on video_amiga.cpp and video_x.cpp
 *
 *  Basilisk II (C) 1997-2002 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 "sysdeps.h"

#ifdef HAVE_PTHREADS
# include <pthread.h>
#endif

#include <adb.h>
#include <cpu_emulation.h>
#include <main.h>
#include "macos_util_macosx.h"
#include "main_macosx.h"
#include <prefs.h>
#include <user_strings.h>
#include "video_macosx.h"

#define DEBUG 0
#include "debug.h"

#import <Foundation/NSString.h>                         // Needed for NSLog(@"")
#import "misc_macosx.h"                                         // WarningSheet() prototype


// Global variables
uint8           display_type = DISPLAY_WINDOW,  // These are used by PrefsEditor
                        frame_skip;     
uint16          init_width  = MIN_WIDTH,                // as well as this code
                        init_height = MIN_HEIGHT,
                        init_depth  = 32;

                EmulatorView    *output = nil;          // Set by [EmulatorView init]
                NSWindow                *the_win = nil;         // Set by [Emulator awakeFromNib]
static  void                    *the_buffer = NULL;


#ifdef CGIMAGEREF
static CGImageRef               imageRef = nil;
#endif

#ifdef NSBITMAP
#import <AppKit/NSBitmapImageRep.h>

static NSBitmapImageRep *bitmap = nil;
#endif

// These record changes we made in setting full screen mode
static CGDirectDisplayID        theDisplay   = NULL;
static CFDictionaryRef          originalMode = NULL,
                                                        newMode      = NULL;
static BOOL                                     singleDisplay = YES;


// Prototypes

static bool video_open  (const video_mode &mode);
static void video_close (void);


/*
 *  Utility functions
 */

static uint8
bits_from_depth(const video_depth depth)
{
        int bits = 1 << depth;
//      if (bits == 16)
//              bits = 15;
//      else if (bits == 32)
//              bits = 24;
        return bits;
}

static char *
colours_from_depth(const video_depth depth)
{
        switch ( depth )
        {
                case VDEPTH_1BIT : return "Monochrome";
                case VDEPTH_2BIT : return "4 colours";
                case VDEPTH_4BIT : return "16 colours";
                case VDEPTH_8BIT : return "256 colours";
                case VDEPTH_16BIT: return "Thousands of colours";
                case VDEPTH_32BIT: return "Millions of colours";
        }

        return "illegal colour depth";
}

static char *
colours_from_depth(const uint16 depth)
{
        return colours_from_depth(DepthModeForPixelDepth(depth) );
}

bool
parse_screen_prefs(const char *mode_str)
{
        if (sscanf(mode_str, "win/%hd/%hd/%hd",
                                &init_width, &init_height, &init_depth) == 3)
                display_type = DISPLAY_WINDOW;
        else if (sscanf(mode_str, "win/%hd/%hd", &init_width, &init_height) == 2)
                display_type  = DISPLAY_WINDOW;
        else if (strcmp(mode_str, "full") == 0)
                display_type = DISPLAY_SCREEN;
        else if (sscanf(mode_str, "full/%hd/%hd/%hd",
                                        &init_width, &init_height, &init_depth) == 3)
                display_type = DISPLAY_SCREEN;
        else if (sscanf(mode_str, "full/%hd/%hd", &init_width, &init_height) == 2)
                display_type = DISPLAY_SCREEN;
        else if (sscanf(mode_str, "opengl/%hd/%hd/%hd",
                                        &init_width, &init_height, &init_depth) == 3)
                display_type = DISPLAY_OPENGL;
        else if (sscanf(mode_str, "opengl/%hd/%hd", &init_width, &init_height) == 2)
                display_type = DISPLAY_OPENGL;
        else return false;

        return true;
}


// Add mode to list of supported modes
static void
add_mode(const uint16 width, const uint16 height,
                 const uint32 resolution_id, const uint32 bytes_per_row,
                 const video_depth depth)
{
        vector<video_mode>::const_iterator      i,
                                                                                end = VideoModes.end();

        for (i = VideoModes.begin(); i != end; ++i)
                if ( i->x == width && i->y == height &&
                         i->bytes_per_row == bytes_per_row && i->depth == depth )
                {
                        D(NSLog(@"Duplicate mode (%hdx%hdx%ld, ID %02x, new ID %02x)\n",
                                                width, height, depth, i->resolution_id, resolution_id));
                        return;
                }

        video_mode mode;

        mode.x = width;
        mode.y = height;
        mode.resolution_id = resolution_id;
        mode.bytes_per_row = bytes_per_row;
        mode.depth = depth;

        D(bug("Added video mode: w=%d  h=%d  d=%d(%d bits)\n",
                                width, height, depth, bits_from_depth(depth) ));

        VideoModes.push_back(mode);
}

// Add standard list of windowed modes for given color depth
static void add_standard_modes(const video_depth depth)
{
        D(bug("add_standard_modes: depth=%d(%d bits)\n",
                                                depth, bits_from_depth(depth) ));

        add_mode(512,  384,  0x80, TrivialBytesPerRow(512,  depth), depth);
        add_mode(640,  480,  0x81, TrivialBytesPerRow(640,  depth), depth);
        add_mode(800,  600,  0x82, TrivialBytesPerRow(800,  depth), depth);
        add_mode(832,  624,  0x83, TrivialBytesPerRow(832,  depth), depth);
        add_mode(1024, 768,  0x84, TrivialBytesPerRow(1024, depth), depth);
        add_mode(1152, 768,  0x85, TrivialBytesPerRow(1152, depth), depth);
        add_mode(1152, 870,  0x86, TrivialBytesPerRow(1152, depth), depth);
        add_mode(1280, 1024, 0x87, TrivialBytesPerRow(1280, depth), depth);
        add_mode(1600, 1200, 0x88, TrivialBytesPerRow(1600, depth), depth);
}

// Helper function to get a 32bit int from a dictionary
static int32 getCFint32 (CFDictionaryRef dict, CFStringRef key)
{
        CFNumberRef     ref = CFDictionaryGetValue(dict, key);

        if ( ref )
        {
                int32   val;

                if ( CFNumberGetValue(ref, kCFNumberSInt32Type, &val) )
                        return val;
                else
                        NSLog(@"getCFint32() - Failed to get the value %@", key);
        }
        else
                NSLog(@"getCFint32() - Failed to get a 32bit int for %@", key);

        return 0;
}

static bool add_CGDirectDisplay_modes()
{
#define kMaxDisplays 8
        CGDirectDisplayID       displays[kMaxDisplays];
        CGDisplayErr            err;
        CGDisplayCount          n;
        int32                           oldRes = 0,
                                                res_id = 0x80;


        err = CGGetActiveDisplayList(kMaxDisplays, displays, &n);
        if ( err != CGDisplayNoErr )
                n = 1, displays[n] = kCGDirectMainDisplay;

        if ( n > 1 )
                singleDisplay = NO;

        for ( CGDisplayCount dc = 0; dc < n; ++dc )
        {
                CGDirectDisplayID       d = displays[dc];
                CFArrayRef                      m = CGDisplayAvailableModes(d);

                if ( ! m )                                      // Store the current display mode
                        add_mode(CGDisplayPixelsWide(d),
                                         CGDisplayPixelsHigh(d),
                                         res_id++, CGDisplayBytesPerRow(d),
                                         DepthModeForPixelDepth(CGDisplayBitsPerPixel(d)));
                else
                {
                        CFIndex  nModes = CFArrayGetCount(m);

                        for ( CFIndex mc = 0; mc < nModes; ++mc )
                        {
                                CFDictionaryRef modeSpec = CFArrayGetValueAtIndex(m, mc);

                                int32   bpp    = getCFint32(modeSpec, kCGDisplayBitsPerPixel);
                                int32   height = getCFint32(modeSpec, kCGDisplayHeight);
                                int32   width  = getCFint32(modeSpec, kCGDisplayWidth);
                                video_depth     depth = DepthModeForPixelDepth(bpp);

                                if ( ! bpp || ! height || ! width )
                                {
                                        NSLog(@"Could not get details of mode %d, display %d",
                                                        mc, dc);
                                        return false;
                                }
#if VERBOSE
                                else
                                        NSLog(@"Display %ld, spec = %@", d, modeSpec);
#endif

                                if ( ! oldRes )
                                        oldRes = width * height;
                                else
                                        if ( oldRes != width * height )
                                        {
                                                oldRes = width * height;
                                                ++res_id;
                                        }

                                add_mode(width, height, res_id, 0, depth);
                        }
                }
        }

        return true;
}

// Set Mac frame layout and base address (uses the_buffer/MacFrameBaseMac)
static void set_mac_frame_buffer(const video_depth depth)
{
#if !REAL_ADDRESSING && !DIRECT_ADDRESSING
        switch ( depth )
        {
        //      case VDEPTH_15BIT:
                case VDEPTH_16BIT: MacFrameLayout = FLAYOUT_HOST_555; break;
        //      case VDEPTH_24BIT:
                case VDEPTH_32BIT: MacFrameLayout = FLAYOUT_HOST_888; break;
                default                  : MacFrameLayout = FLAYOUT_DIRECT;
        }
        VideoMonitor.mac_frame_base = MacFrameBaseMac;

        // Set variables used by UAE memory banking
        MacFrameBaseHost = the_buffer;
        MacFrameSize = VideoMonitor.mode.bytes_per_row * VideoMonitor.mode.y;
        InitFrameBufferMapping();
#else
        VideoMonitor.mac_frame_base = Host2MacAddr(the_buffer);
#endif
        D(bug("VideoMonitor.mac_frame_base = %08x\n", VideoMonitor.mac_frame_base));
}

static void
resizeWinBy(const short deltaX, const short deltaY)
{
        NSRect  rect = [the_win frame];

        D(bug("resizeWinBy(%d,%d) - ", deltaX, deltaY));
        D(bug("old x=%g, y=%g", rect.size.width, rect.size.height));

        rect.size.width  += deltaX;
        rect.size.height += deltaY;

        D(bug(", new x=%g, y=%g\n", rect.size.width, rect.size.height));

        [the_win setFrame: rect display: YES];
        rect = [the_win frame];
}

void resizeWinTo(const uint16 newWidth, const uint16 newHeight)
{
        int             deltaX = newWidth  - [output width],
                        deltaY = newHeight - [output height];

        D(bug("resizeWinTo(%d,%d)\n", newWidth, newHeight));

        if ( deltaX || deltaY )
                resizeWinBy(deltaX, deltaY);
}

// Open window
static bool init_window(const video_mode &mode)
{
#ifdef CGIMAGEREF
        CGColorSpaceRef         colourSpace;
        CGDataProviderRef       provider;
#endif
        short                           bitsPer, samplesPer;    // How big is each Pixel?
        int                                     the_buffer_size;

        D(bug("init_window: depth=%d(%d bits)\n",
                        mode.depth, bits_from_depth(mode.depth) ));


        // Set absolute mouse mode
        ADBSetRelMouseMode(false);


        // Open window
        if ( ! the_win )
        {
                ErrorAlert(STR_OPEN_WINDOW_ERR);
                return false;
        }
        resizeWinTo(mode.x, mode.y);


        // Create frame buffer ("height + 2" for safety)
        the_buffer_size = mode.bytes_per_row * (mode.y + 2);
        the_buffer = calloc(the_buffer_size, 1);
        if ( ! the_buffer )
        {
                NSLog(@"calloc(%d) failed", the_buffer_size);
                ErrorAlert(STR_NO_MEM_ERR);
                return false;
        }
        D(bug("the_buffer = %p\n", the_buffer));


        if ( mode.depth == VDEPTH_1BIT )
                bitsPer = 1;
        else
                bitsPer = 8;

        if ( mode.depth == VDEPTH_32BIT )
                samplesPer = 3;
        else
                samplesPer = 1;

#ifdef CGIMAGEREF
        switch ( mode.depth )
        {
                //case VDEPTH_1BIT:     colourSpace = CGColorSpaceCreateDeviceMono(); break
                case VDEPTH_8BIT:       colourSpace = CGColorSpaceCreateDeviceGray(); break;
                case VDEPTH_32BIT:      colourSpace = CGColorSpaceCreateDeviceRGB();  break;
                default:                        colourSpace = NULL;
        }

        if ( ! colourSpace )
        {
                ErrorAlert("No valid colour space");
                return false;
        }

        provider = CGDataProviderCreateWithData(NULL, the_buffer,
                                                                                        the_buffer_size, NULL);
        if ( ! provider )
        {
                ErrorAlert("Could not create CGDataProvider from buffer data");
                return false;
        }
        imageRef = CGImageCreate(mode.x,
                                                         mode.y,
                                                         bitsPer,
                                                         bits_from_depth(mode.depth),
                                                         mode.bytes_per_row,
                                                         colourSpace,
                                                         kCGImageAlphaNoneSkipFirst,
                                                         provider,
                                                         NULL,  // colourMap
                                                         NO,    // shouldInterpolate
                                                         kCGRenderingIntentDefault);
        if ( ! imageRef )
        {
                ErrorAlert("Could not create CGImage from CGDataProvider");
                return false;
        }
        CGDataProviderRelease(provider);
        CGColorSpaceRelease(colourSpace);

        [output readyToDraw: imageRef
                         imageWidth: mode.x
                        imageHeight: mode.y];
#else
        unsigned char *offsetBuffer = the_buffer;
        offsetBuffer += 1;      // OS X NSBitmaps are RGBA, but Basilisk generates ARGB
#endif

#ifdef NSBITMAP
        bitmap = [NSBitmapImageRep alloc];
        bitmap = [bitmap initWithBitmapDataPlanes: (unsigned char **) &offsetBuffer
                                                                   pixelsWide: mode.x
                                                                   pixelsHigh: mode.y
                                                                bitsPerSample: bitsPer
                              samplesPerPixel: samplesPer
                                     hasAlpha: NO
                                                                         isPlanar: NO
                                                           colorSpaceName: NSCalibratedRGBColorSpace
                                                                  bytesPerRow: mode.bytes_per_row
                                                                 bitsPerPixel: bits_from_depth(mode.depth)];

    if ( ! bitmap )
        {
                ErrorAlert("Could not allocate an NSBitmapImageRep");
                return false;
        }

        [output readyToDraw: bitmap
                         imageWidth: mode.x
                        imageHeight: mode.y];
#endif

#ifdef CGDRAWBITMAP
        [output readyToDraw: offsetBuffer
                                  width: mode.x
                                 height: mode.y
                                        bps: bitsPer
                                        spp: samplesPer
                                        bpp: bits_from_depth(mode.depth)
                                        bpr: mode.bytes_per_row
                           isPlanar: NO
                           hasAlpha: NO];
#endif

        // Set VideoMonitor
        VideoMonitor.mode = mode;
        set_mac_frame_buffer(mode.depth);

        return true;
}

#import <AppKit/NSEvent.h>
#import <Carbon/Carbon.h>

static bool init_screen(video_mode &mode)
{
        // Set absolute mouse mode
        ADBSetRelMouseMode(false);

        theDisplay = kCGDirectMainDisplay;      // For now

        originalMode = CGDisplayCurrentMode(theDisplay);
        if ( ! originalMode )
        {
                ErrorSheet(@"Could not get current mode of display", the_win);
                return false;
        }

        D(NSLog(@"About to call CGDisplayBestModeForParameters()"));
        newMode = CGDisplayBestModeForParameters(theDisplay,
                                                                                         bits_from_depth(mode.depth),
                                                                                                        mode.x, mode.y, NULL);
        if ( ! newMode )
        {
                ErrorSheet(@"Could not find a matching screen mode", the_win);
                return false;
        }

//      This sometimes takes ages to return after the window is genied,
//      so for now we leave it onscreen
//      [the_win miniaturize: nil];

        D(NSLog(@"About to call CGDisplayCapture()"));
        if ( CGDisplayCapture(theDisplay) != CGDisplayNoErr )
        {
//              [the_win deminiaturize: nil];
                ErrorSheet(@"Could not capture display", the_win);
                return false;
        }

        [output startedFullScreen: theDisplay];         // For mouse event processing

        D(NSLog(@"About to call CGDisplaySwitchToMode()"));
        if ( CGDisplaySwitchToMode(theDisplay, newMode) != CGDisplayNoErr )
        {
                CGDisplayRelease(theDisplay);
//              [the_win deminiaturize: nil];
                ErrorSheet(@"Could not switch to matching screen mode", the_win);
                return false;
        }

        if ( mode.bytes_per_row != CGDisplayBytesPerRow(theDisplay) )
        {
                D(bug("Bytes per row (%d) doesn't match current (%ld)\n",
                                mode.bytes_per_row, CGDisplayBytesPerRow(theDisplay)));
                mode.bytes_per_row = CGDisplayBytesPerRow(theDisplay);
        }

        HideMenuBar();

        if ( singleDisplay )
        {
                CGDisplayHideCursor(theDisplay);

                // Send real mouse to emulated location
                if ( CGDisplayMoveCursorToPoint(theDisplay, CGPointMake(15,15))
                                                                                                                != CGDisplayNoErr )
                {
                        video_close();
                        ErrorSheet(@"Could move (jump) cursor on screen", the_win);
                        return false;
                }
        }
        else
        {
                // Should set up something to hide the cursor when it enters theDisplay?
        }

        the_buffer = CGDisplayBaseAddress(theDisplay);
        if ( ! the_buffer )
        {
                video_close();
                ErrorSheet(@"Could not get base address of screen", the_win);
                return false;
        }

        // Set VideoMonitor
        VideoMonitor.mode = mode;
        set_mac_frame_buffer(mode.depth);


        return true;
}

static bool init_opengl(const video_mode &mode)
{
        ErrorAlert("Sorry. OpenGL mode is not implemented yet");
        return false;
}

/*
 *  Initialization
 */

bool VideoInit(bool classic)
{
        // Read frame skip prefs
        frame_skip = PrefsFindInt32("frameskip");
        if (frame_skip == 0)
                frame_skip = 1;

        // Get screen mode from preferences
        const char *mode_str;
        if (classic)
                mode_str = "win/512/342";
        else
                mode_str = PrefsFindString("screen");

        // Determine display_type and init_width, height & depth
        parse_screen_prefs(mode_str);

        // Construct list of supported modes
        if (classic)
                add_mode(512, 342, 0x80, 64, VDEPTH_1BIT);
        else
                switch ( display_type )
                {
                        case DISPLAY_SCREEN:
                                if ( ! add_CGDirectDisplay_modes() )
                                {
                                        ErrorAlert("Unable to get list of displays for full screen mode");
                                        return false;
                                }
                                break;
                        case DISPLAY_OPENGL:
                                // Same as window depths and sizes?
                        case DISPLAY_WINDOW:
                                //add_standard_modes(VDEPTH_1BIT);
                                //add_standard_modes(VDEPTH_8BIT);
                                //add_standard_modes(VDEPTH_16BIT);
                                add_standard_modes(VDEPTH_32BIT);
                                break;
                }

        video_init_depth_list();

#if DEBUG
        bug("Available video modes:\n");
        vector<video_mode>::const_iterator i, end = VideoModes.end();
        for (i = VideoModes.begin(); i != end; ++i)
                bug(" %dx%d (ID %02x), %s\n", i->x, i->y, i->resolution_id,
                                                                                colours_from_depth(i->depth));
#endif

        D(bug("VideoInit: width=%hd height=%hd depth=%d\n",
                                                init_width, init_height, init_depth));

        // Find requested default mode and open display
        if (VideoModes.size() > 0)
        {
                // Find mode with specified dimensions
                std::vector<video_mode>::const_iterator i, end = VideoModes.end();
                for (i = VideoModes.begin(); i != end; ++i)
                {
                        D(bug("VideoInit: w=%d h=%d d=%d\n",
                                        i->x, i->y, bits_from_depth(i->depth)));
                        if (i->x == init_width && i->y == init_height
                                        && bits_from_depth(i->depth) == init_depth)
                                return video_open(*i);
                }
        }

        char str[150];
        sprintf(str, "Cannot open selected video mode\r(%hd x %hd, %s).\r%s",
                        init_width, init_height,
                        colours_from_depth(init_depth), "Using lowest resolution");
        WarningAlert(str);

        return video_open(VideoModes[0]);
}


// Open display for specified mode
static bool video_open(const video_mode &mode)
{
        D(bug("video_open: width=%d  height=%d  depth=%d  bytes_per_row=%d\n",
                        mode.x, mode.y, bits_from_depth(mode.depth), mode.bytes_per_row));

        // Open display
        switch ( display_type )
        {
                case DISPLAY_WINDOW:    return init_window(mode);
                case DISPLAY_SCREEN:    return init_screen((video_mode &)mode);
                case DISPLAY_OPENGL:    return init_opengl(mode);
        }

        return false;
}


static void video_close()
{
        D(bug("video_close()\n"));

        switch ( display_type ) {
                case DISPLAY_WINDOW:
                        // Stop redraw thread
                        [output disableDrawing];

                        // Free frame buffer stuff
#ifdef CGIMAGEREF
                        CGImageRelease(imageRef);
#endif
#ifdef NSBITMAP
                        [bitmap release];
#endif
                        free(the_buffer);

                        break;

                case DISPLAY_SCREEN:
                        if ( theDisplay && originalMode )
                        {
                                if ( singleDisplay )
                                        CGDisplayShowCursor(theDisplay);
                                ShowMenuBar();
                                CGDisplaySwitchToMode(theDisplay, originalMode);
                                CGDisplayRelease(theDisplay);
                                //[the_win deminiaturize: nil];
                        }
                        break;

                case DISPLAY_OPENGL:
                        break;
        }
}


/*
 *  Deinitialization
 */

void VideoExit(void)
{
        video_close();
}


/*
 *  Set palette
 */

void video_set_palette(uint8 *pal, int num)
{
        if ( [output isFullScreen] && CGDisplayCanSetPalette(theDisplay)
                                                                && ! IsDirectMode(VideoMonitor.mode) )
        {
                CGDirectPaletteRef      CGpal;
                CGDisplayErr            err;


                CGpal = CGPaletteCreateWithByteSamples((CGDeviceByteColor *)pal, num);
                err   = CGDisplaySetPalette(theDisplay, CGpal);
                if ( err != noErr )
                        NSLog(@"Failed to set palette, error = %d", err);
                CGPaletteRelease(CGpal);
        }
}


/*
 *  Switch video mode
 */

void video_switch_to_mode(const video_mode &mode)
{
        char            *failure = NULL;


        D(bug("switch_to_current_mode(): width=%d  height=%d  depth=%d  bytes_per_row=%d\n", mode.x, mode.y, bits_from_depth(mode.depth), mode.bytes_per_row));

        if ( display_type == DISPLAY_SCREEN && originalMode )
        {
                D(NSLog(@"About to call CGDisplayBestModeForParameters()"));
                newMode = CGDisplayBestModeForParameters(theDisplay,
                                                                                                 bits_from_depth(mode.depth),
                                                                                                                mode.x, mode.y, NULL);
                if ( ! newMode )
                        failure = "Could not find a matching screen mode";
                else
                {
                        D(NSLog(@"About to call CGDisplaySwitchToMode()"));
                        if ( CGDisplaySwitchToMode(theDisplay, newMode) != CGDisplayNoErr )
                                failure = "Could not switch to matching screen mode";
                }

                if ( ! failure &&
                        mode.bytes_per_row != CGDisplayBytesPerRow(theDisplay) )
                {
                        D(bug("Bytes per row (%d) doesn't match current (%ld)\n",
                                        mode.bytes_per_row, CGDisplayBytesPerRow(theDisplay)));
                        ((video_mode &)mode).bytes_per_row
                                                                        = CGDisplayBytesPerRow(theDisplay);
                }

                if ( ! failure &&
                         ! ( the_buffer = CGDisplayBaseAddress(theDisplay) ) )
                        failure = "Could not get base address of screen";
                else
                        // Send emulated mouse to current location
                        [output processMouseMove: nil];
        }
        else if ( ! video_open(mode) )
                failure = "Could not video_open() requested mode";

        if ( failure )
        {
                NSLog(@"In switch_to_current_mode():");
                NSLog(@"%s.", failure);
                video_close();
                if ( display_type == DISPLAY_SCREEN )
                        ErrorAlert("Cannot switch screen to selected video mode");
                else
                        ErrorAlert(STR_OPEN_WINDOW_ERR);
                QuitEmulator();
        }
        else
                set_mac_frame_buffer(mode.depth);
}

/*
 *  Close down full-screen mode
 *      (if bringing up error alerts is unsafe while in full-screen mode)
 */

void VideoQuitFullScreen(void)
{
}


/*
 *  Mac VBL interrupt
 */

void VideoInterrupt(void)
{
}


// This function is called on non-threaded platforms from a timer interrupt
void VideoRefresh(void)
{
}
Revision:	1.4
Committed:	2002-06-05T10:11:40Z (22 years, 1 month ago) by nigel
Branch:	MAIN
Changes since 1.3:	+87 -37 lines
Log Message:	Sequencing changes in init_screen(), removed some global vars and functions, assorted tidyup, big changes to video_switch_to_mode()