mirror of
https://github.com/kevinbentley/Descent3.git
synced 2025-01-22 19:55:23 +00:00
359 lines
9.2 KiB
C++
359 lines
9.2 KiB
C++
/*
|
|
* Descent 3
|
|
* Copyright (C) 2024 Parallax Software
|
|
*
|
|
* 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 3 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, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/*
|
|
* $Logfile: /DescentIII/Main/ddio_lnx/lnxkey.cpp $
|
|
* $Revision: 1.3 $
|
|
* $Date: 2004/02/25 00:04:06 $
|
|
* $Author: ryan $
|
|
*
|
|
* Linux keyboard routines
|
|
*
|
|
* $Log: lnxkey.cpp,v $
|
|
* Revision 1.3 2004/02/25 00:04:06 ryan
|
|
* Removed loki_utils dependency and ported to MacOS X (runs, but incomplete).
|
|
*
|
|
* Revision 1.2 2000/04/27 11:17:07 icculus
|
|
* Removed some keyboard drivers, added SDL hooks.
|
|
*
|
|
* Revision 1.1.1.1 2000/04/18 00:00:33 icculus
|
|
* initial checkin
|
|
*
|
|
*
|
|
* 13 7/14/99 9:06p Jeff
|
|
* added comment header
|
|
*
|
|
* $NoKeywords: $
|
|
*/
|
|
|
|
/*
|
|
* Linux Keyboard Interface, Non-SVGALIB Implementation
|
|
* $NoKeywords: $
|
|
*/
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Keyboard Interface
|
|
// ----------------------------------------------------------------------------
|
|
#include "pserror.h"
|
|
#include "mono.h"
|
|
#include "ddio.h"
|
|
#include "ddio_lnx.h"
|
|
#include "application.h"
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <getopt.h>
|
|
#include <signal.h>
|
|
#include <fcntl.h>
|
|
#include <termios.h>
|
|
// #include <linux/kd.h>
|
|
// #include <linux/vt.h>
|
|
#include <fcntl.h>
|
|
#include <sys/stat.h>
|
|
// #include <linux/keyboard.h>
|
|
#include <sys/ioctl.h>
|
|
#include <string.h>
|
|
#include <sys/time.h>
|
|
#include <sys/types.h>
|
|
// #include <linux/unistd.h>
|
|
|
|
volatile struct tLnxKeys {
|
|
union {
|
|
int up_ticks;
|
|
float up_time;
|
|
};
|
|
union {
|
|
int down_ticks;
|
|
float down_time;
|
|
};
|
|
bool status;
|
|
} LKeys[DDIO_MAX_KEYS];
|
|
|
|
// normal mode ddio
|
|
bool ddio_normal_InternalKeyInit(ddio_init_info *init_info);
|
|
void ddio_normal_InternalKeyClose();
|
|
bool ddio_normal_InternalKeyState(ubyte key);
|
|
void ddio_normal_InternalKeySuspend();
|
|
void ddio_normal_InternalKeyResume();
|
|
float ddio_normal_InternalKeyDownTime(ubyte key);
|
|
void ddio_normal_InternalResetKey(ubyte key);
|
|
bool ddio_normal_KeyFrame();
|
|
void ddio_normal_InternalKeyFrame(void);
|
|
|
|
// null mode ddio
|
|
bool ddio_null_InternalKeyInit(ddio_init_info *init_info);
|
|
void ddio_null_InternalKeyClose();
|
|
bool ddio_null_InternalKeyState(ubyte key);
|
|
void ddio_null_InternalKeySuspend();
|
|
void ddio_null_InternalKeyResume();
|
|
float ddio_null_InternalKeyDownTime(ubyte key);
|
|
void ddio_null_InternalResetKey(ubyte key);
|
|
bool ddio_null_KeyFrame();
|
|
void ddio_null_InternalKeyFrame(void);
|
|
|
|
// sdl mode ddio
|
|
bool ddio_sdl_InternalKeyInit(ddio_init_info *init_info);
|
|
void ddio_sdl_InternalKeyClose();
|
|
bool ddio_sdl_InternalKeyState(ubyte key);
|
|
void ddio_sdl_InternalKeySuspend();
|
|
void ddio_sdl_InternalKeyResume();
|
|
float ddio_sdl_InternalKeyDownTime(ubyte key);
|
|
void ddio_sdl_InternalResetKey(ubyte key);
|
|
bool ddio_sdl_KeyFrame();
|
|
void ddio_sdl_InternalKeyFrame(void);
|
|
|
|
/*
|
|
//xwin mode ddio
|
|
bool ddio_xwin_InternalKeyInit(ddio_init_info *init_info);
|
|
void ddio_xwin_InternalKeyClose();
|
|
bool ddio_xwin_InternalKeyState(ubyte key);
|
|
void ddio_xwin_InternalKeySuspend();
|
|
void ddio_xwin_InternalKeyResume();
|
|
float ddio_xwin_InternalKeyDownTime(ubyte key);
|
|
void ddio_xwin_InternalResetKey(ubyte key);
|
|
void ddio_xwin_InternalKeyFrame(void);
|
|
|
|
//svga mode ddio
|
|
bool ddio_svga_InternalKeyInit(ddio_init_info *init_info);
|
|
void ddio_svga_InternalKeyClose();
|
|
bool ddio_svga_InternalKeyState(ubyte key);
|
|
void ddio_svga_InternalKeySuspend();
|
|
void ddio_svga_InternalKeyResume();
|
|
float ddio_svga_InternalKeyDownTime(ubyte key);
|
|
void ddio_svga_InternalResetKey(ubyte key);
|
|
bool ddio_svga_KeyFrame();
|
|
void ddio_svga_InternalKeyFrame(void);
|
|
*/
|
|
|
|
enum {
|
|
Input_normal,
|
|
Input_null,
|
|
Input_sdl // Input_svga,Input_xwin
|
|
} Keyboard_mode;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Initialization of keyboard device.
|
|
// ----------------------------------------------------------------------------
|
|
|
|
bool ddio_InternalKeyInit(ddio_init_info *init_info) {
|
|
oeLnxApplication *app = (oeLnxApplication *)init_info->obj;
|
|
tLnxAppInfo app_info;
|
|
|
|
if (!app) {
|
|
return false;
|
|
}
|
|
|
|
app->get_info(&app_info);
|
|
|
|
// determine if we are to use normal or null mode
|
|
Keyboard_mode = Input_normal;
|
|
if (app_info.flags & APPFLAG_USESERVICE) {
|
|
// use null mode!
|
|
Keyboard_mode = Input_null;
|
|
} else {
|
|
Keyboard_mode = Input_sdl;
|
|
/*
|
|
if(app_info.flags&APPFLAG_USESVGA)
|
|
{
|
|
//use svgalib mode!
|
|
Keyboard_mode = Input_svga;
|
|
}
|
|
else if (app_info.m_Display) {
|
|
// we're under xwindows and we're not forcing any type of keyboard input.
|
|
Keyboard_mode = Input_xwin;
|
|
}
|
|
*/
|
|
}
|
|
|
|
switch (Keyboard_mode) {
|
|
case Input_normal:
|
|
return ddio_normal_InternalKeyInit(init_info);
|
|
case Input_null:
|
|
return ddio_null_InternalKeyInit(init_info);
|
|
case Input_sdl:
|
|
return ddio_sdl_InternalKeyInit(init_info);
|
|
|
|
// case Input_svga:
|
|
// return ddio_svga_InternalKeyInit(init_info);
|
|
// case Input_xwin:
|
|
// return ddio_xwin_InternalKeyInit(init_info);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void ddio_InternalKeyClose() {
|
|
switch (Keyboard_mode) {
|
|
case Input_normal:
|
|
return ddio_normal_InternalKeyClose();
|
|
case Input_null:
|
|
return ddio_null_InternalKeyClose();
|
|
case Input_sdl:
|
|
return ddio_sdl_InternalKeyClose();
|
|
/*
|
|
case Input_svga:
|
|
return ddio_svga_InternalKeyClose();
|
|
case Input_xwin:
|
|
return ddio_xwin_InternalKeyClose();
|
|
*/
|
|
}
|
|
}
|
|
|
|
bool ddio_InternalKeyState(ubyte key) {
|
|
switch (Keyboard_mode) {
|
|
case Input_normal:
|
|
return ddio_normal_InternalKeyState(key);
|
|
case Input_null:
|
|
return ddio_null_InternalKeyState(key);
|
|
case Input_sdl:
|
|
return ddio_sdl_InternalKeyState(key);
|
|
/*
|
|
case Input_svga:
|
|
return ddio_svga_InternalKeyState(key);
|
|
case Input_xwin:
|
|
return ddio_xwin_InternalKeyState(key);
|
|
*/
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void ddio_InternalKeySuspend() {
|
|
switch (Keyboard_mode) {
|
|
case Input_normal:
|
|
ddio_normal_InternalKeySuspend();
|
|
break;
|
|
case Input_null:
|
|
ddio_null_InternalKeySuspend();
|
|
break;
|
|
case Input_sdl:
|
|
return ddio_sdl_InternalKeySuspend();
|
|
|
|
/*
|
|
case Input_svga:
|
|
ddio_svga_InternalKeySuspend();
|
|
break;
|
|
case Input_xwin:
|
|
ddio_xwin_InternalKeySuspend();
|
|
break;
|
|
*/
|
|
}
|
|
}
|
|
|
|
void ddio_InternalKeyResume() {
|
|
switch (Keyboard_mode) {
|
|
case Input_normal:
|
|
ddio_normal_InternalKeyResume();
|
|
break;
|
|
case Input_null:
|
|
ddio_null_InternalKeyResume();
|
|
break;
|
|
case Input_sdl:
|
|
return ddio_sdl_InternalKeyResume();
|
|
|
|
/*
|
|
case Input_svga:
|
|
ddio_svga_InternalKeyResume();
|
|
break;
|
|
case Input_xwin:
|
|
ddio_xwin_InternalKeyResume();
|
|
break;
|
|
*/
|
|
}
|
|
}
|
|
|
|
float ddio_InternalKeyDownTime(ubyte key) {
|
|
switch (Keyboard_mode) {
|
|
case Input_normal:
|
|
return ddio_normal_InternalKeyDownTime(key);
|
|
case Input_null:
|
|
return ddio_null_InternalKeyDownTime(key);
|
|
case Input_sdl:
|
|
return ddio_sdl_InternalKeyDownTime(key);
|
|
/*
|
|
case Input_svga:
|
|
return ddio_svga_InternalKeyDownTime(key);
|
|
case Input_xwin:
|
|
return ddio_xwin_InternalKeyDownTime(key);
|
|
*/
|
|
}
|
|
|
|
return 0.0f;
|
|
}
|
|
|
|
void ddio_InternalResetKey(ubyte key) {
|
|
switch (Keyboard_mode) {
|
|
case Input_normal:
|
|
ddio_normal_InternalResetKey(key);
|
|
break;
|
|
case Input_null:
|
|
ddio_null_InternalResetKey(key);
|
|
break;
|
|
case Input_sdl:
|
|
return ddio_sdl_InternalResetKey(key);
|
|
/*
|
|
case Input_svga:
|
|
ddio_svga_InternalResetKey(key);
|
|
break;
|
|
case Input_xwin:
|
|
ddio_xwin_InternalResetKey(key);
|
|
break;
|
|
*/
|
|
}
|
|
}
|
|
|
|
bool ddio_KeyFrame() {
|
|
switch (Keyboard_mode) {
|
|
case Input_sdl:
|
|
break;
|
|
case Input_normal:
|
|
return ddio_normal_KeyFrame();
|
|
case Input_null:
|
|
return ddio_null_KeyFrame();
|
|
/*
|
|
case Input_svga:
|
|
return ddio_svga_KeyFrame();
|
|
*/
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void ddio_InternalKeyFrame(void) {
|
|
switch (Keyboard_mode) {
|
|
case Input_normal:
|
|
ddio_normal_InternalKeyFrame();
|
|
break;
|
|
case Input_null:
|
|
ddio_null_InternalKeyFrame();
|
|
break;
|
|
case Input_sdl:
|
|
return ddio_sdl_InternalKeyFrame();
|
|
/*
|
|
case Input_svga:
|
|
ddio_svga_InternalKeyFrame();
|
|
break;
|
|
case Input_xwin:
|
|
ddio_xwin_InternalKeyFrame();
|
|
break;
|
|
*/
|
|
}
|
|
}
|
|
|
|
void ddio_SetKeyboardLanguage(int) {}
|