0f030a1802
--HG-- extra : convert_revision : svn%3Ac70aab31-4412-0410-b14c-859654838e24/trunk%401938
334 lines
9.1 KiB
C
334 lines
9.1 KiB
C
/*
|
|
SDL - Simple DirectMedia Layer
|
|
Copyright (C) 1997-2006 Sam Lantinga
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2.1 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
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with this library; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
Sam Lantinga
|
|
slouken@libsdl.org
|
|
*/
|
|
#include "SDL_config.h"
|
|
|
|
/* Utilities for getting and setting the X display mode */
|
|
|
|
#include "SDL_timer.h"
|
|
#include "SDL_events.h"
|
|
#include "../../events/SDL_events_c.h"
|
|
#include "SDL_cgxvideo.h"
|
|
#include "SDL_cgxwm_c.h"
|
|
#include "SDL_cgxmodes_c.h"
|
|
|
|
#define CGX_DEBUG
|
|
|
|
static void
|
|
set_best_resolution(_THIS, int width, int height)
|
|
{
|
|
Uint32 idok;
|
|
int depth = 8;
|
|
|
|
if (SDL_Display)
|
|
depth =
|
|
GetCyberMapAttr(SDL_Display->RastPort.BitMap, CYBRMATTR_DEPTH);
|
|
|
|
idok = BestCModeIDTags(CYBRBIDTG_NominalWidth, width,
|
|
CYBRBIDTG_NominalHeight, height,
|
|
CYBRBIDTG_Depth, depth, TAG_DONE);
|
|
|
|
if (idok != INVALID_ID) {
|
|
if (SDL_Display) {
|
|
if (currently_fullscreen)
|
|
CloseScreen(SDL_Display);
|
|
else
|
|
UnlockPubScreen(NULL, SDL_Display);
|
|
}
|
|
SDL_Display = GFX_Display =
|
|
OpenScreenTags(NULL, SA_Width, width, SA_Height, height,
|
|
SA_Depth, depth, SA_DisplayID, idok,
|
|
SA_ShowTitle, FALSE, TAG_DONE);
|
|
}
|
|
}
|
|
|
|
static void
|
|
get_real_resolution(_THIS, int *w, int *h)
|
|
{
|
|
*w = /*SDL_Display->Width */ SDL_Window->Width - SDL_Window->BorderLeft -
|
|
SDL_Window->BorderRight;
|
|
*h = /*SDL_Display->Height */ SDL_Window->Height -
|
|
SDL_Window->BorderBottom - SDL_Window->BorderTop;
|
|
}
|
|
|
|
static void
|
|
move_cursor_to(_THIS, int x, int y)
|
|
{
|
|
/* XWarpPointer(SDL_Display, None, SDL_Root, 0, 0, 0, 0, x, y); */
|
|
|
|
/* DA FARE! */
|
|
}
|
|
|
|
static void
|
|
add_visual(_THIS, int depth, int class)
|
|
{
|
|
Uint32 tID;
|
|
|
|
tID = BestCModeIDTags(CYBRBIDTG_Depth, depth,
|
|
CYBRBIDTG_NominalWidth, 640,
|
|
CYBRBIDTG_NominalHeight, 480, TAG_DONE);
|
|
|
|
if (tID != INVALID_ID) {
|
|
int n = this->hidden->nvisuals;
|
|
|
|
this->hidden->visuals[n].depth = depth;
|
|
this->hidden->visuals[n].visual = tID;
|
|
this->hidden->visuals[n].bpp = GetCyberIDAttr(CYBRIDATTR_BPPIX, tID);
|
|
this->hidden->nvisuals++;
|
|
}
|
|
}
|
|
|
|
#define TrueColor 1
|
|
#define PseudoColor 2
|
|
|
|
int
|
|
CGX_GetVideoModes(_THIS)
|
|
{
|
|
int i;
|
|
ULONG nextid;
|
|
int nmodes = 0;
|
|
|
|
SDL_modelist = NULL;
|
|
|
|
nextid = NextDisplayInfo(INVALID_ID);
|
|
|
|
while (nextid != INVALID_ID) {
|
|
if (IsCyberModeID(nextid)) {
|
|
DisplayInfoHandle h;
|
|
|
|
if (h = FindDisplayInfo(nextid)) {
|
|
struct DimensionInfo info;
|
|
|
|
if (GetDisplayInfoData
|
|
(h, (char *) &info, sizeof(struct DimensionInfo),
|
|
DTAG_DIMS, NULL)) {
|
|
int ok = 0;
|
|
|
|
for (i = 0; i < nmodes; i++) {
|
|
if (SDL_modelist[i]->w == (info.Nominal.MaxX + 1)
|
|
&& SDL_modelist[i]->h == (info.Nominal.MaxY + 1))
|
|
ok = 1;
|
|
}
|
|
|
|
if (!ok) {
|
|
nmodes++;
|
|
|
|
SDL_modelist =
|
|
(SDL_Rect **) SDL_realloc(SDL_modelist,
|
|
(nmodes +
|
|
1) *
|
|
sizeof(SDL_Rect *));
|
|
SDL_modelist[nmodes] = NULL;
|
|
|
|
if (SDL_modelist) {
|
|
SDL_modelist[nmodes - 1] = (SDL_Rect *)
|
|
SDL_malloc(sizeof(SDL_Rect));
|
|
|
|
if (SDL_modelist[nmodes - 1] == NULL)
|
|
break;
|
|
|
|
SDL_modelist[nmodes - 1]->x = 0;
|
|
SDL_modelist[nmodes - 1]->y = 0;
|
|
SDL_modelist[nmodes - 1]->w =
|
|
info.Nominal.MaxX + 1;
|
|
SDL_modelist[nmodes - 1]->h =
|
|
info.Nominal.MaxY + 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
nextid = NextDisplayInfo(nextid);
|
|
}
|
|
|
|
|
|
this->hidden->nvisuals = 0;
|
|
/* Search for the visuals in deepest-first order, so that the first
|
|
will be the richest one */
|
|
add_visual(this, 32, TrueColor);
|
|
add_visual(this, 24, TrueColor);
|
|
add_visual(this, 16, TrueColor);
|
|
add_visual(this, 15, TrueColor);
|
|
add_visual(this, 8, PseudoColor);
|
|
|
|
if (this->hidden->nvisuals == 0) {
|
|
SDL_SetError("Found no sufficiently capable CGX visuals");
|
|
return -1;
|
|
}
|
|
|
|
if (SDL_modelist == NULL) {
|
|
SDL_modelist = (SDL_Rect **) SDL_malloc((1 + 1) * sizeof(SDL_Rect *));
|
|
i = 0;
|
|
if (SDL_modelist) {
|
|
SDL_modelist[i] = (SDL_Rect *) SDL_malloc(sizeof(SDL_Rect));
|
|
if (SDL_modelist[i]) {
|
|
SDL_modelist[i]->x = 0;
|
|
SDL_modelist[i]->y = 0;
|
|
SDL_modelist[i]->w = SDL_Display->Width;
|
|
SDL_modelist[i]->h = SDL_Display->Height;
|
|
++i;
|
|
}
|
|
SDL_modelist[i] = NULL;
|
|
}
|
|
}
|
|
|
|
D(if (SDL_modelist) {
|
|
bug("CGX video mode list: (%ld)\n", nmodes);
|
|
for (i = 0; SDL_modelist[i]; ++i) {
|
|
bug("\t%ld x %ld\n", SDL_modelist[i]->w, SDL_modelist[i]->h);}
|
|
}
|
|
);
|
|
|
|
D( {
|
|
bug("CGX visuals list: (%ld)\n", this->hidden->nvisuals);
|
|
for (i = 0; i < this->hidden->nvisuals; i++)
|
|
bug("\t%lx - depth: %ld bpp: %ld\n",
|
|
this->hidden->visuals[i].visual,
|
|
this->hidden->visuals[i].depth, this->hidden->visuals[i].bpp);}
|
|
);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
CGX_SupportedVisual(_THIS, SDL_PixelFormat * format)
|
|
{
|
|
int i;
|
|
for (i = 0; i < this->hidden->nvisuals; i++) {
|
|
if (this->hidden->visuals[i].depth == format->BitsPerPixel) // Era bpp
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
SDL_Rect **
|
|
CGX_ListModes(_THIS, SDL_PixelFormat * format, Uint32 flags)
|
|
{
|
|
if (CGX_SupportedVisual(this, format)) {
|
|
if (flags & SDL_FULLSCREEN) {
|
|
return (SDL_modelist);
|
|
} else {
|
|
return ((SDL_Rect **) - 1);
|
|
}
|
|
} else {
|
|
return ((SDL_Rect **) 0);
|
|
}
|
|
}
|
|
|
|
void
|
|
CGX_FreeVideoModes(_THIS)
|
|
{
|
|
int i;
|
|
|
|
if (SDL_modelist) {
|
|
for (i = 0; SDL_modelist[i]; ++i) {
|
|
SDL_free(SDL_modelist[i]);
|
|
}
|
|
SDL_free(SDL_modelist);
|
|
SDL_modelist = NULL;
|
|
}
|
|
}
|
|
|
|
int
|
|
CGX_ResizeFullScreen(_THIS)
|
|
{
|
|
int x, y;
|
|
int real_w, real_h;
|
|
|
|
if (currently_fullscreen) {
|
|
/* Per ora non faccio nulla qui */
|
|
}
|
|
return (1);
|
|
}
|
|
|
|
void
|
|
_QueueEnterFullScreen(_THIS)
|
|
{
|
|
}
|
|
|
|
int
|
|
CGX_EnterFullScreen(_THIS)
|
|
{
|
|
int okay;
|
|
Uint32 saved_flags;
|
|
|
|
okay = 1;
|
|
saved_flags = this->screen->flags;
|
|
|
|
if (!currently_fullscreen) {
|
|
int real_w, real_h;
|
|
|
|
/* Map the fullscreen window to blank the screen */
|
|
get_real_resolution(this, &real_w, &real_h);
|
|
|
|
CGX_DestroyWindow(this, this->screen);
|
|
set_best_resolution(this, real_w, real_h);
|
|
|
|
currently_fullscreen = 1;
|
|
this->screen->flags = saved_flags;
|
|
|
|
CGX_CreateWindow(this, this->screen, real_w, real_h,
|
|
GetCyberMapAttr(SDL_Display->RastPort.BitMap,
|
|
CYBRMATTR_DEPTH),
|
|
this->screen->flags);
|
|
|
|
/* Set the new resolution */
|
|
okay = CGX_ResizeFullScreen(this);
|
|
if (!okay) {
|
|
CGX_LeaveFullScreen(this);
|
|
}
|
|
/* Set the colormap */
|
|
/*
|
|
if ( SDL_XColorMap ) {
|
|
XInstallColormap(SDL_Display, SDL_XColorMap);
|
|
}
|
|
*/
|
|
}
|
|
// CGX_GrabInputNoLock(this, this->input_grab | SDL_GRAB_FULLSCREEN);
|
|
return (okay);
|
|
}
|
|
|
|
int
|
|
CGX_LeaveFullScreen(_THIS)
|
|
{
|
|
if (currently_fullscreen) {
|
|
int width, height;
|
|
if (SDL_Window) {
|
|
CloseWindow(SDL_Window);
|
|
SDL_Window = NULL;
|
|
}
|
|
CloseScreen(SDL_Display);
|
|
|
|
GFX_Display = SDL_Display = LockPubScreen(NULL);
|
|
|
|
currently_fullscreen = 0;
|
|
|
|
CGX_CreateWindow(this, this->screen, this->screen->w,
|
|
this->screen->h,
|
|
GetCyberMapAttr(SDL_Display->RastPort.BitMap,
|
|
CYBRMATTR_DEPTH),
|
|
this->screen->flags);
|
|
CGX_ResizeImage(this, this->screen, 0L);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
/* vi: set ts=4 sw=4 expandtab: */
|