/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2009 Sam Lantinga
    Copyright (C) 2001  Hsieh-Fu Tsai
    Copyright (C) 2002  Greg Haerr <greg@censoft.com>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    Sam Lantinga
    slouken@libsdl.org
    
    Hsieh-Fu Tsai
    clare@setabox.com
*/
#include "SDL_config.h"

#include "SDL_thread.h"
#include "SDL_video.h"
#include "../SDL_pixels_c.h"
#include "../../events/SDL_events_c.h"

#define MWINCLUDECOLORS
#include "SDL_nxvideo.h"
#include "SDL_nxmodes_c.h"
#include "SDL_nxwm_c.h"
#include "SDL_nxmouse_c.h"
#include "SDL_nximage_c.h"
#include "SDL_nxevents_c.h"

// Initialization/Query functions
static int NX_VideoInit(_THIS, SDL_PixelFormat * vformat);
static SDL_Surface *NX_SetVideoMode(_THIS, SDL_Surface * current, int width,
                                    int height, int bpp, Uint32 flags);
static int NX_SetColors(_THIS, int firstcolor, int ncolors,
                        SDL_Color * colors);
static void NX_VideoQuit(_THIS);
static void NX_DestroyWindow(_THIS, SDL_Surface * screen);
static int NX_ToggleFullScreen(_THIS, int on);
static void NX_UpdateMouse(_THIS);
static int NX_SetGammaRamp(_THIS, Uint16 * ramp);
static int NX_GetGammaRamp(_THIS, Uint16 * ramp);

// Microwin driver bootstrap functions
static int
NX_Available()
{
    Dprintf("enter NX_Available\n");

    if (GrOpen() < 0)
        return 0;
    GrClose();

    Dprintf("leave NX_Available\n");
    return 1;
}

static void
NX_DeleteDevice(SDL_VideoDevice * device)
{
    Dprintf("enter NX_DeleteDevice\n");

    if (device) {
        if (device->hidden)
            SDL_free(device->hidden);
        if (device->gl_data)
            SDL_free(device->gl_data);
        SDL_free(device);
    }

    Dprintf("leave NX_DeleteDevice\n");
}

static SDL_VideoDevice *
NX_CreateDevice(int devindex)
{
    SDL_VideoDevice *device;

    Dprintf("enter NX_CreateDevice\n");

    // Initialize all variables that we clean on shutdown
    device = (SDL_VideoDevice *) SDL_malloc(sizeof(SDL_VideoDevice));
    if (device) {
        SDL_memset(device, 0, (sizeof *device));
        device->hidden = (struct SDL_PrivateVideoData *)
            SDL_malloc((sizeof *device->hidden));
        device->gl_data = NULL;
    }
    if ((device == NULL) || (device->hidden == NULL)) {
        SDL_OutOfMemory();
        NX_DeleteDevice(device);
        return 0;
    }
    SDL_memset(device->hidden, 0, (sizeof *device->hidden));

    // Set the function pointers
    device->VideoInit = NX_VideoInit;
    device->ListModes = NX_ListModes;
    device->SetVideoMode = NX_SetVideoMode;
    device->ToggleFullScreen = NX_ToggleFullScreen;
    device->UpdateMouse = NX_UpdateMouse;
    device->CreateYUVOverlay = NULL;
    device->SetColors = NX_SetColors;
    device->UpdateRects = NULL;
    device->VideoQuit = NX_VideoQuit;
    device->AllocHWSurface = NULL;
    device->CheckHWBlit = NULL;
    device->FillHWRect = NULL;
    device->SetHWColorKey = NULL;
    device->SetHWAlpha = NULL;
    device->LockHWSurface = NULL;
    device->UnlockHWSurface = NULL;
    device->FlipHWSurface = NULL;
    device->FreeHWSurface = NULL;
    device->SetGamma = NULL;
    device->GetGamma = NULL;
    device->SetGammaRamp = NX_SetGammaRamp;
    device->GetGammaRamp = NX_GetGammaRamp;

#if SDL_VIDEO_OPENGL
    device->GL_LoadLibrary = NULL;
    device->GL_GetProcAddress = NULL;
    device->GL_GetAttribute = NULL;
    device->GL_MakeCurrent = NULL;
    device->GL_SwapBuffers = NULL;
#endif

    device->SetIcon = NULL;
    device->SetCaption = NX_SetCaption;
    device->IconifyWindow = NULL;
    device->GrabInput = NULL;
    device->GetWMInfo = NX_GetWMInfo;
    device->FreeWMCursor = NX_FreeWMCursor;
    device->CreateWMCursor = NX_CreateWMCursor;
    device->ShowWMCursor = NX_ShowWMCursor;
    device->WarpWMCursor = NX_WarpWMCursor;
    device->CheckMouseMode = NULL;
    device->InitOSKeymap = NX_InitOSKeymap;
    device->PumpEvents = NX_PumpEvents;

    device->free = NX_DeleteDevice;

    Dprintf("leave NX_CreateDevice\n");
    return device;
}

VideoBootStrap NX_bootstrap = {
    "nanox", "nanox", NX_Available, NX_CreateDevice
};

static void
create_aux_windows(_THIS)
{
    GR_WM_PROPERTIES props;

    Dprintf("enter create_aux_windows\n");

    // Don't create any extra windows if we are being managed
    if (SDL_windowid) {
        FSwindow = 0;
        return;
    }

    if (FSwindow && FSwindow != GR_ROOT_WINDOW_ID) {
        GrDestroyWindow(FSwindow);
    }

    FSwindow = GrNewWindow(GR_ROOT_WINDOW_ID, 0, 0, 1, 1, 0, BLACK, BLACK);
    props.flags = GR_WM_FLAGS_PROPS;
    props.props = GR_WM_PROPS_NODECORATE;
    GrSetWMProperties(FSwindow, &props);

    GrSelectEvents(FSwindow, (GR_EVENT_MASK_EXPOSURE |
                              GR_EVENT_MASK_BUTTON_DOWN |
                              GR_EVENT_MASK_BUTTON_UP |
                              GR_EVENT_MASK_FOCUS_IN |
                              GR_EVENT_MASK_FOCUS_OUT |
                              GR_EVENT_MASK_KEY_DOWN | GR_EVENT_MASK_KEY_UP |
                              GR_EVENT_MASK_MOUSE_ENTER |
                              GR_EVENT_MASK_MOUSE_EXIT |
                              GR_EVENT_MASK_MOUSE_MOTION |
                              GR_EVENT_MASK_UPDATE |
                              GR_EVENT_MASK_CLOSE_REQ));

    Dprintf("leave create_aux_windows\n");
}

int
NX_VideoInit(_THIS, SDL_PixelFormat * vformat)
{
    GR_SCREEN_INFO si;

    Dprintf("enter NX_VideoInit\n");

    if (GrOpen() < 0) {
        SDL_SetError("GrOpen() fail");
        return -1;
    }
    // use share memory to speed up
#ifdef NANOX_SHARE_MEMORY
    GrReqShmCmds(0xFFFF);
#endif

    SDL_Window = 0;
    FSwindow = 0;

    GammaRamp_R = NULL;
    GammaRamp_G = NULL;
    GammaRamp_B = NULL;

    GrGetScreenInfo(&si);
    SDL_Visual.bpp = si.bpp;

    /* Determine the current screen size */
    this->info.current_w = si.cols;
    this->info.current_h = si.rows;

    // GetVideoMode
    SDL_modelist = (SDL_Rect **) SDL_malloc(sizeof(SDL_Rect *) * 2);
    if (SDL_modelist) {
        SDL_modelist[0] = (SDL_Rect *) SDL_malloc(sizeof(SDL_Rect));
        if (SDL_modelist[0]) {
            SDL_modelist[0]->x = 0;
            SDL_modelist[0]->y = 0;
            SDL_modelist[0]->w = si.cols;
            SDL_modelist[0]->h = si.rows;
        }
        SDL_modelist[1] = NULL;
    }

    pixel_type = si.pixtype;
    SDL_Visual.red_mask = si.rmask;
    SDL_Visual.green_mask = si.gmask;
    SDL_Visual.blue_mask = si.bmask;

    vformat->BitsPerPixel = SDL_Visual.bpp;
    if (vformat->BitsPerPixel > 8) {
        vformat->Rmask = SDL_Visual.red_mask;
        vformat->Gmask = SDL_Visual.green_mask;
        vformat->Bmask = SDL_Visual.blue_mask;
    }
    // See if we have been passed a window to use
    SDL_windowid = getenv("SDL_WINDOWID");

    // Create the fullscreen (and managed windows : no implement)
    create_aux_windows(this);

    Dprintf("leave NX_VideoInit\n");
    return 0;
}

void
NX_VideoQuit(_THIS)
{
    Dprintf("enter NX_VideoQuit\n");

    // Start shutting down the windows
    NX_DestroyImage(this, this->screen);
    NX_DestroyWindow(this, this->screen);
    if (FSwindow && FSwindow != GR_ROOT_WINDOW_ID) {
        GrDestroyWindow(FSwindow);
    }
    NX_FreeVideoModes(this);
    SDL_free(GammaRamp_R);
    SDL_free(GammaRamp_G);
    SDL_free(GammaRamp_B);

#ifdef ENABLE_NANOX_DIRECT_FB
    if (Clientfb)
        GrCloseClientFramebuffer();
#endif
    GrClose();

    Dprintf("leave NX_VideoQuit\n");
}

static void
NX_DestroyWindow(_THIS, SDL_Surface * screen)
{
    Dprintf("enter NX_DestroyWindow\n");

    if (!SDL_windowid) {
        if (screen && (screen->flags & SDL_FULLSCREEN)) {
            screen->flags &= ~SDL_FULLSCREEN;
            NX_LeaveFullScreen(this);
        }
        // Destroy the output window
        if (SDL_Window && SDL_Window != GR_ROOT_WINDOW_ID) {
            GrDestroyWindow(SDL_Window);
        }
    }
    // Free the graphics context
    if (!SDL_GC) {
        GrDestroyGC(SDL_GC);
        SDL_GC = 0;
    }

    Dprintf("leave NX_DestroyWindow\n");
}

static int
NX_CreateWindow(_THIS, SDL_Surface * screen,
                int w, int h, int bpp, Uint32 flags)
{
    Dprintf("enter NX_CreateWindow\n");

    // If a window is already present, destroy it and start fresh
    if (SDL_Window && SDL_Window != GR_ROOT_WINDOW_ID) {
        NX_DestroyWindow(this, screen);
    }
    // See if we have been given a window id
    if (SDL_windowid) {
        SDL_Window = SDL_strtol(SDL_windowid, NULL, 0);
    } else {
        SDL_Window = 0;
    }

    if (!SDL_ReallocFormat(screen, bpp, SDL_Visual.red_mask,
                           SDL_Visual.green_mask, SDL_Visual.blue_mask, 0))
        return -1;

    // Create (or use) the nanox display window
    if (!SDL_windowid) {

        SDL_Window =
            GrNewWindow(GR_ROOT_WINDOW_ID, 0, 0, w, h, 0, BLACK, WHITE);

        GrSelectEvents(SDL_Window, (GR_EVENT_MASK_EXPOSURE |
                                    GR_EVENT_MASK_BUTTON_DOWN |
                                    GR_EVENT_MASK_BUTTON_UP |
                                    GR_EVENT_MASK_FOCUS_IN |
                                    GR_EVENT_MASK_FOCUS_OUT |
                                    GR_EVENT_MASK_KEY_DOWN |
                                    GR_EVENT_MASK_KEY_UP |
                                    GR_EVENT_MASK_MOUSE_ENTER |
                                    GR_EVENT_MASK_MOUSE_EXIT |
                                    GR_EVENT_MASK_MOUSE_MOTION |
                                    GR_EVENT_MASK_UPDATE |
                                    GR_EVENT_MASK_CLOSE_REQ));
    }

    /* Create the graphics context here, once we have a window */
    SDL_GC = GrNewGC();
    if (SDL_GC == 0) {
        SDL_SetError("Couldn't create graphics context");
        return (-1);
    }
    // Map them both and go fullscreen, if requested
    if (!SDL_windowid) {
        GrMapWindow(SDL_Window);
        if (flags & SDL_FULLSCREEN) {
            screen->flags |= SDL_FULLSCREEN;
            NX_EnterFullScreen(this);
        } else {
            screen->flags &= ~SDL_FULLSCREEN;
        }
    }
#ifdef ENABLE_NANOX_DIRECT_FB
    /* attempt allocating the client side framebuffer */
    Clientfb = GrOpenClientFramebuffer();
    /* NULL return will default to using GrArea() */
#endif

    Dprintf("leave NX_CreateWindow\n");
    return 0;
}

SDL_Surface *
NX_SetVideoMode(_THIS, SDL_Surface * current,
                int width, int height, int bpp, Uint32 flags)
{
    Dprintf("enter NX_SetVideoMode\n");

    // Lock the event thread, in multi-threading environments
    SDL_Lock_EventThread();

    bpp = SDL_Visual.bpp;
    if (NX_CreateWindow(this, current, width, height, bpp, flags) < 0) {
        current = NULL;
        goto done;
    }

    if (current->w != width || current->h != height) {
        current->w = width;
        current->h = height;
        current->pitch = SDL_CalculatePitch(current);
        NX_ResizeImage(this, current, flags);
    }
    current->flags |= (flags & (SDL_RESIZABLE | SDL_NOFRAME));

  done:
    SDL_Unlock_EventThread();

    Dprintf("leave NX_SetVideoMode\n");

    // We're done!
    return current;
}

// ncolors <= 256
int
NX_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color * colors)
{
    int i;
    GR_PALETTE pal;

    Dprintf("enter NX_SetColors\n");

    if (ncolors > 256)
        return 0;

    pal.count = ncolors;
    for (i = 0; i < ncolors; ++i) {
        pal.palette[i].r = colors[i].r;
        pal.palette[i].g = colors[i].g;
        pal.palette[i].b = colors[i].b;
    }
    GrSetSystemPalette(firstcolor, &pal);

    Dprintf("leave NX_SetColors\n");
    return 1;
}

static int
NX_ToggleFullScreen(_THIS, int on)
{
    SDL_Rect rect;
    Uint32 event_thread;

    Dprintf("enter NX_ToggleFullScreen\n");

    // Don't switch if we don't own the window
    if (SDL_windowid)
        return 0;

    // Don't lock if we are the event thread
    event_thread = SDL_EventThreadID();
    if (event_thread && (SDL_ThreadID() == event_thread)) {
        event_thread = 0;
    }
    if (event_thread) {
        SDL_Lock_EventThread();
    }

    if (on) {
        NX_EnterFullScreen(this);
    } else {
        this->screen->flags &= ~SDL_FULLSCREEN;
        NX_LeaveFullScreen(this);
    }

    rect.x = rect.y = 0;
    rect.w = this->screen->w, rect.h = this->screen->h;
    NX_NormalUpdate(this, 1, &rect);

    if (event_thread) {
        SDL_Unlock_EventThread();
    }

    Dprintf("leave NX_ToggleFullScreen\n");
    return 1;
}

// Update the current mouse state and position
static void
NX_UpdateMouse(_THIS)
{
    int x, y;
    GR_WINDOW_INFO info;
    GR_SCREEN_INFO si;


    Dprintf("enter NX_UpdateMouse\n");

    // Lock the event thread, in multi-threading environments
    SDL_Lock_EventThread();

    GrGetScreenInfo(&si);
    GrGetWindowInfo(SDL_Window, &info);
    x = si.xpos - info.x;
    y = si.ypos - info.y;
    if (x >= 0 && x <= info.width && y >= 0 && y <= info.height) {
        SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
        SDL_PrivateMouseMotion(0, 0, x, y);
    } else {
        SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
    }

    SDL_Unlock_EventThread();
    Dprintf("leave NX_UpdateMouse\n");
}

static int
NX_SetGammaRamp(_THIS, Uint16 * ramp)
{
    int i;
    Uint16 *red, *green, *blue;

    Dprintf("enter NX_SetGammaRamp\n");

    if (SDL_Visual.bpp != 32 && SDL_Visual.bpp != 24)
        return -1;

    if (!GammaRamp_R)
        GammaRamp_R = (Uint16 *) SDL_malloc(sizeof(Uint16) * CI_SIZE);
    if (!GammaRamp_G)
        GammaRamp_G = (Uint16 *) SDL_malloc(sizeof(Uint16) * CI_SIZE);
    if (!GammaRamp_B)
        GammaRamp_B = (Uint16 *) SDL_malloc(sizeof(Uint16) * CI_SIZE);
    if ((!GammaRamp_R) || (!GammaRamp_G) || (!GammaRamp_B)) {
        SDL_OutOfMemory();
        return -1;
    }

    for (i = 0; i < CI_SIZE; ++i)
        GammaRamp_R[i] = GammaRamp_G[i] = GammaRamp_B[i] = i;

    red = ramp;
    green = ramp + CI_SIZE;
    blue = green + CI_SIZE;

    for (i = 0; i < CI_SIZE; ++i) {
        GammaRamp_R[i] = red[i];
        GammaRamp_G[i] = green[i];
        GammaRamp_B[i] = blue[i];
    }
    SDL_UpdateRect(this->screen, 0, 0, 0, 0);

    Dprintf("leave NX_SetGammaRamp\n");
    return 0;
}

static int
NX_GetGammaRamp(_THIS, Uint16 * ramp)
{
    int i;
    Uint16 *red, *green, *blue;

    Dprintf("enter NX_GetGammaRamp\n");

    if (SDL_Visual.bpp != 32 && SDL_Visual.bpp != 24)
        return -1;
    red = ramp;
    green = ramp + CI_SIZE;
    blue = green + CI_SIZE;
    if (GammaRamp_R && GammaRamp_G && GammaRamp_B) {
        for (i = 0; i < CI_SIZE; ++i) {
            red[i] = GammaRamp_R[i];
            green[i] = GammaRamp_G[i];
            blue[i] = GammaRamp_B[i];
        }
    } else {
        for (i = 0; i < CI_SIZE; ++i)
            red[i] = green[i] = blue[i] = i;
    }

    Dprintf("leave NX_GetGammaRamp\n");
    return 0;
}

/* vi: set ts=4 sw=4 expandtab: */