373 lines
8.1 KiB
C++
373 lines
8.1 KiB
C++
#include "StdAfx.h"
|
|
#include "frontends/ncurses/nframe.h"
|
|
#include "frontends/ncurses/colors.h"
|
|
#include "frontends/ncurses/asciiart.h"
|
|
#include "frontends/ncurses/evdevpaddle.h"
|
|
|
|
#include "Interface.h"
|
|
#include "Memory.h"
|
|
#include "Log.h"
|
|
|
|
#include <signal.h>
|
|
#include <locale.h>
|
|
#include <stdlib.h>
|
|
|
|
namespace na2
|
|
{
|
|
|
|
struct NCurses
|
|
{
|
|
NCurses()
|
|
{
|
|
setlocale(LC_ALL, "");
|
|
initscr();
|
|
|
|
curs_set(0);
|
|
|
|
noecho();
|
|
cbreak();
|
|
set_escdelay(0);
|
|
|
|
// make sure this happens when ncurses is indeed initialised
|
|
colors.reset(new GraphicsColors(20, 20, 32));
|
|
}
|
|
~NCurses()
|
|
{
|
|
endwin();
|
|
colors.reset();
|
|
}
|
|
std::shared_ptr<GraphicsColors> colors;
|
|
};
|
|
|
|
NFrame::NFrame(const std::string & paddleDevice)
|
|
: myPaddleDevice(paddleDevice)
|
|
, myRows(-1)
|
|
, myColumns(-1)
|
|
{
|
|
// only initialise if actually used
|
|
// so we can run headless
|
|
}
|
|
|
|
void NFrame::Initialize()
|
|
{
|
|
LinuxFrame::Initialize();
|
|
myTextFlashCounter = 0;
|
|
myTextFlashState = 0;
|
|
myAsciiArt.reset(new ASCIIArt());
|
|
myPaddle.reset(new EvDevPaddle(myPaddleDevice));
|
|
Paddle::instance = myPaddle;
|
|
}
|
|
|
|
void NFrame::Destroy()
|
|
{
|
|
LinuxFrame::Destroy();
|
|
myTextFlashCounter = 0;
|
|
myTextFlashState = 0;
|
|
myFrame.reset();
|
|
myStatus.reset();
|
|
myAsciiArt.reset();
|
|
|
|
myPaddle.reset();
|
|
Paddle::instance.reset();
|
|
|
|
myNCurses.reset();
|
|
}
|
|
|
|
void NFrame::ProcessEvDev()
|
|
{
|
|
myPaddle->poll();
|
|
}
|
|
|
|
void NFrame::ChangeColumns(const int x)
|
|
{
|
|
myAsciiArt->changeColumns(x);
|
|
}
|
|
|
|
void NFrame::ChangeRows(const int x)
|
|
{
|
|
myAsciiArt->changeRows(x);
|
|
}
|
|
|
|
void NFrame::Init(int rows, int columns)
|
|
{
|
|
if (myRows != rows || myColumns != columns)
|
|
{
|
|
InitialiseNCurses();
|
|
if (columns < myColumns || rows < myRows)
|
|
{
|
|
werase(myStatus.get());
|
|
wrefresh(myStatus.get());
|
|
werase(myFrame.get());
|
|
wrefresh(myFrame.get());
|
|
}
|
|
|
|
myRows = rows;
|
|
myColumns = columns;
|
|
|
|
const int width = 1 + myColumns + 1;
|
|
const int left = (COLS - width) / 2;
|
|
|
|
myFrame.reset(newwin(1 + myRows + 1, width, 0, left), delwin);
|
|
box(myFrame.get(), 0 , 0);
|
|
wtimeout(myFrame.get(), 0);
|
|
keypad(myFrame.get(), true);
|
|
wrefresh(myFrame.get());
|
|
|
|
myStatus.reset(newwin(4, width, 1 + myRows + 1, left), delwin);
|
|
box(myStatus.get(), 0 , 0);
|
|
wrefresh(myStatus.get());
|
|
}
|
|
|
|
}
|
|
|
|
WINDOW * NFrame::GetWindow()
|
|
{
|
|
return myFrame.get();
|
|
}
|
|
|
|
WINDOW * NFrame::GetStatus()
|
|
{
|
|
return myStatus.get();
|
|
}
|
|
|
|
void NFrame::InitialiseNCurses()
|
|
{
|
|
if (!myNCurses)
|
|
{
|
|
myNCurses.reset(new NCurses());
|
|
}
|
|
}
|
|
|
|
void NFrame::VideoPresentScreen()
|
|
{
|
|
VideoUpdateFlash();
|
|
|
|
Video & video = GetVideo();
|
|
|
|
// see NTSC_SetVideoMode in NTSC.cpp
|
|
// we shoudl really use g_nTextPage and g_nHiresPage
|
|
const int displaypage2 = (video.VideoGetSWPAGE2() && !video.VideoGetSW80STORE()) ? 1 : 0;
|
|
|
|
myHiresBank1 = MemGetAuxPtr (0x2000 << displaypage2);
|
|
myHiresBank0 = MemGetMainPtr(0x2000 << displaypage2);
|
|
myTextBank1 = MemGetAuxPtr (0x400 << displaypage2);
|
|
myTextBank0 = MemGetMainPtr(0x400 << displaypage2);
|
|
|
|
typedef bool (NFrame::* VideoUpdateFuncPtr_t)(Video &, int, int, int, int, int);
|
|
|
|
VideoUpdateFuncPtr_t update = video.VideoGetSWTEXT()
|
|
? video.VideoGetSW80COL()
|
|
? &NFrame::Update80ColCell
|
|
: &NFrame::Update40ColCell
|
|
: video.VideoGetSWHIRES()
|
|
? (video.VideoGetSWDHIRES() && video.VideoGetSW80COL())
|
|
? &NFrame::UpdateDHiResCell
|
|
: &NFrame::UpdateHiResCell
|
|
: (video.VideoGetSWDHIRES() && video.VideoGetSW80COL())
|
|
? &NFrame::UpdateDLoResCell
|
|
: &NFrame::UpdateLoResCell;
|
|
|
|
int y = 0;
|
|
int ypixel = 0;
|
|
while (y < 20) {
|
|
int offset = ((y & 7) << 7) + ((y >> 3) * 40);
|
|
int x = 0;
|
|
int xpixel = 0;
|
|
while (x < 40) {
|
|
(this->*update)(video, x, y, xpixel, ypixel, offset + x);
|
|
++x;
|
|
xpixel += 14;
|
|
}
|
|
++y;
|
|
ypixel += 16;
|
|
}
|
|
|
|
if (video.VideoGetSWMIXED())
|
|
update = video.VideoGetSW80COL() ? &NFrame::Update80ColCell
|
|
: &NFrame::Update40ColCell;
|
|
|
|
while (y < 24) {
|
|
int offset = ((y & 7) << 7) + ((y >> 3) * 40);
|
|
int x = 0;
|
|
int xpixel = 0;
|
|
while (x < 40) {
|
|
(this->*update)(video, x, y, xpixel, ypixel, offset + x);
|
|
++x;
|
|
xpixel += 14;
|
|
}
|
|
++y;
|
|
ypixel += 16;
|
|
}
|
|
|
|
wrefresh(myFrame.get());
|
|
}
|
|
|
|
void NFrame::VideoUpdateFlash()
|
|
{
|
|
++myTextFlashCounter;
|
|
|
|
if (myTextFlashCounter == 16) // Flash rate = 0.5 * 60 / 16 Hz (as we need 2 changes for a period)
|
|
{
|
|
myTextFlashCounter = 0;
|
|
myTextFlashState = !myTextFlashState;
|
|
}
|
|
}
|
|
|
|
chtype NFrame::MapCharacter(Video & video, BYTE ch)
|
|
{
|
|
const char low = ch & 0x7f;
|
|
const char high = ch & 0x80;
|
|
|
|
chtype result = low;
|
|
|
|
const int code = low >> 5;
|
|
switch (code)
|
|
{
|
|
case 0: // 00 - 1F
|
|
result += 0x40; // UPPERCASE
|
|
break;
|
|
case 1: // 20 - 3F
|
|
// SPECIAL CHARACTER
|
|
break;
|
|
case 2: // 40 - 5F
|
|
// UPPERCASE
|
|
break;
|
|
case 3: // 60 - 7F
|
|
// LOWERCASE
|
|
if (high == 0 && !video.VideoGetSWAltCharSet())
|
|
{
|
|
result -= 0x40;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (result == 0x7f)
|
|
{
|
|
result = ACS_CKBOARD;
|
|
}
|
|
|
|
if (!high)
|
|
{
|
|
if (!video.VideoGetSWAltCharSet() && (low >= 0x40))
|
|
{
|
|
// result |= A_BLINK; // does not work on my terminal
|
|
if (myTextFlashState)
|
|
{
|
|
result |= A_REVERSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result |= A_REVERSE;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
bool NFrame::Update40ColCell(Video & video, int x, int y, int xpixel, int ypixel, int offset)
|
|
{
|
|
Init(24, 40);
|
|
myAsciiArt->init(1, 1);
|
|
|
|
BYTE ch = *(myTextBank0+offset);
|
|
|
|
const chtype ch2 = MapCharacter(video, ch);
|
|
mvwaddch(myFrame.get(), 1 + y, 1 + x, ch2);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool NFrame::Update80ColCell(Video & video, int x, int y, int xpixel, int ypixel, int offset)
|
|
{
|
|
Init(24, 80);
|
|
myAsciiArt->init(1, 2);
|
|
|
|
BYTE ch1 = *(myTextBank1+offset);
|
|
BYTE ch2 = *(myTextBank0+offset);
|
|
|
|
WINDOW * win = myFrame.get();
|
|
|
|
const chtype ch12 = MapCharacter(video, ch1);
|
|
mvwaddch(win, 1 + y, 1 + 2 * x, ch12);
|
|
|
|
const chtype ch22 = MapCharacter(video, ch2);
|
|
mvwaddch(win, 1 + y, 1 + 2 * x + 1, ch22);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool NFrame::UpdateLoResCell(Video &, int x, int y, int xpixel, int ypixel, int offset)
|
|
{
|
|
BYTE val = *(myTextBank0+offset);
|
|
|
|
const int pair = myNCurses->colors->getPair(val);
|
|
|
|
WINDOW * win = myFrame.get();
|
|
|
|
wcolor_set(win, pair, NULL);
|
|
if (myColumns == 40)
|
|
{
|
|
mvwaddstr(win, 1 + y, 1 + x, "\u2580");
|
|
}
|
|
else
|
|
{
|
|
mvwaddstr(win, 1 + y, 1 + 2 * x, "\u2580\u2580");
|
|
}
|
|
wcolor_set(win, 0, NULL);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool NFrame::UpdateDLoResCell(Video &, int x, int y, int xpixel, int ypixel, int offset)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
bool NFrame::UpdateHiResCell(Video &, int x, int y, int xpixel, int ypixel, int offset)
|
|
{
|
|
const BYTE * base = myHiresBank0 + offset;
|
|
|
|
const ASCIIArt::array_char_t & chs = myAsciiArt->getCharacters(base);
|
|
|
|
const auto shape = chs.shape();
|
|
const size_t rows = shape[0];
|
|
const size_t cols = shape[1];
|
|
|
|
Init(24 * rows, 40 * cols);
|
|
WINDOW * win = myFrame.get();
|
|
|
|
const GraphicsColors & colors = *myNCurses->colors;
|
|
|
|
for (size_t i = 0; i < rows; ++i)
|
|
{
|
|
for (size_t j = 0; j < cols; ++j)
|
|
{
|
|
const int pair = colors.getGrey(chs[i][j].foreground, chs[i][j].background);
|
|
|
|
wcolor_set(win, pair, NULL);
|
|
mvwaddstr(win, 1 + rows * y + i, 1 + cols * x + j, chs[i][j].c);
|
|
}
|
|
}
|
|
wcolor_set(win, 0, NULL);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool NFrame::UpdateDHiResCell(Video &, int x, int y, int xpixel, int ypixel, int offset)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
void NFrame::Cleanup()
|
|
{
|
|
GetFrame().Destroy();
|
|
}
|
|
|
|
int NFrame::FrameMessageBox(LPCSTR lpText, LPCSTR lpCaption, UINT uType)
|
|
{
|
|
LogFileOutput("MessageBox:\n%s\n%s\n\n", lpCaption, lpText);
|
|
return IDOK;
|
|
}
|
|
|
|
}
|