bool unpack(const UByte& _b1, const UByte& _b2)
{
loadR( utypeGet<UByte, true>(_b1, 5, 0));
loadG( utypeGet<UByte, true>(_b1, 3, 5)
| utypeGet<UByte, false>(_b2, 3, 3));
loadB( utypeGet<UByte, true>(_b2, 5, 3));
return true;
}
uint32 get24_dis(void)
{
uint8 b; uint16 a;
a = *(uint16*)(uint8*)(bytes + bcnt) = loadW(pc);
pc += 2; bcnt += 2;
b = bytes[bcnt++] = loadB(pc++);
return ((uint32)b << 16) | (uint32)a;
}
bool unpack(const UByte& _b1, const UByte& _b2, const UByte& _b3)
{
loadR(utypeGet<UByte, true>(_b1, 8, 0));
loadG(utypeGet<UByte, true>(_b2, 8, 0));
loadB(utypeGet<UByte, true>(_b3, 8, 0));
return true;
}
_u32 get24_dis(void)
{
_u8 b; _u16 a;
a = *(_u16*)(_u8*)(bytes + bcnt) = loadW(pc);
pc += 2; bcnt += 2;
b = bytes[bcnt++] = loadB(pc++);
return ((_u32)b << 16) | (_u32)a;
}
static uint8 NGP_z80_readbyte(uint16 address)
{
if (address <= 0xFFF)
return loadB(0x7000 + address);
if (address == 0x8000)
{
return CommByte;
}
return 0;
}
static void make_flash_commit(std::vector<uint8> &flashdata)
{
FlashFileHeader header;
uint8 *fileptr;
flashdata.clear();
//No flash data?
if (block_count == 0)
return;
//Optimise before writing
optimise_blocks();
//Build a header;
header.valid_flash_id = FLASH_VALID_ID;
header.block_count = block_count;
header.total_file_length = sizeof(FlashFileHeader);
for (int i = 0; i < block_count; i++)
{
header.total_file_length += sizeof(FlashFileBlockHeader);
header.total_file_length += blocks[i].data_length;
}
//Write the flash data
flashdata.resize(header.total_file_length);
//Copy header
memcpy(&flashdata[0], &header, sizeof(FlashFileHeader));
fileptr = &flashdata[0] + sizeof(FlashFileHeader);
//Copy blocks
for (int i = 0; i < block_count; i++)
{
memcpy(fileptr, &blocks[i], sizeof(FlashFileBlockHeader));
fileptr += sizeof(FlashFileBlockHeader);
//Copy data
for (uint32 j = 0; j < blocks[i].data_length; j++)
{
*fileptr = loadB(blocks[i].start_address + j);
fileptr++;
}
}
}
void
MainWindow::createActions(){
openAction = new QAction( tr("&Open..."), this );
openAction->setStatusTip(tr("Open an existing molecular file"));
connect( openAction, SIGNAL( triggered() ), this, SLOT( openFile() ) );
viewAxisAction=new QAction(tr("&Axis"), this);
viewAxisAction->setStatusTip(tr("Show Axis"));
viewAxisAction->setCheckable(true);
connect(viewAxisAction, SIGNAL(triggered()), this, SLOT(viewAxis()));
viewStickAction=new QAction(tr("&Stick"), this);
viewStickAction->setStatusTip( tr("Stick Model") );
viewStickAction->setCheckable(true);
connect(viewStickAction, SIGNAL(triggered()), this, SLOT(viewStick()));
viewSphereAction=new QAction(tr("&Sphere"),this);
viewSphereAction->setStatusTip(tr("Sphere Model"));
viewSphereAction->setCheckable(true);
connect(viewSphereAction, SIGNAL(triggered()), this, SLOT(viewSphere()));
viewSurfaceAction=new QAction(tr("&Surface"),this);
viewSurfaceAction->setStatusTip(tr("Surface Model"));
viewSurfaceAction->setCheckable(true);
connect(viewSurfaceAction, SIGNAL(triggered()), this, SLOT(viewSurface()));
//---------------------------------------------------------------------------
dockAction = new QAction( tr("&Dock"), this );
dockAction->setStatusTip(tr("Config docking parameters."));
connect( dockAction, SIGNAL( triggered() ), this, SLOT(dockConfig() ) );
//----------------------- config dock --------------------------------------------------------
confDlg = new ConfigDialog;
connect( confDlg, SIGNAL( loadP(QString) ), this, SLOT(openFile(QString)) );
connect( confDlg, SIGNAL( loadB(vector<float>) ), molViewer, SLOT( sDrawDots(vector<float>) ) );
connect( confDlg, SIGNAL( loadL(QString) ), this, SLOT(openFile(QString)) );
connect( confDlg, SIGNAL( dockRun() ), this, SLOT(dockRun()) );
//-- textEdit
// connect( deDock, SIGNAL(emitString(QString)), termEdit, SLOT(append(QString)) );
// connect( this, SIGNAL(emitRun()), deDock, SLOT(run()) );
}
uint16 loadW(uint32 address)
{
address &= 0xFFFFFF;
if(address & 1)
{
uint16 ret;
ret = loadB(address);
ret |= loadB(address + 1) << 8;
return(ret);
}
if(FastReadMap[address >> 16])
return(MDFN_de16lsb<true>(&FastReadMap[address >> 16][address]));
uint16* ptr = (uint16*)translate_address_read(address);
if(ptr)
return MDFN_de16lsb<true>(ptr);
if(address >= 0x8000 && address <= 0xbfff)
return(NGPGfx->read16(address));
if(address >= 0x4000 && address <= 0x7fff)
{
return(MDFN_de16lsb<true>(CPUExRAM + address - 0x4000));
}
if(address == 0x50)
return(SC0BUF);
if(address >= 0x70 && address <= 0x7F)
{
uint16 ret;
ret = int_read8(address);
ret |= int_read8(address + 1) << 8;
return(ret);
}
if(address >= 0x90 && address <= 0x97)
{
uint16 ret;
ret = rtc_read8(address);
ret |= rtc_read8(address + 1) << 8;
return(ret);
}
if(address >= 0x20 && address <= 0x29)
{
uint16 ret;
ret = timer_read8(address);
ret |= timer_read8(address + 1) << 8;
return(ret);
}
if(address == 0xBC)
return Z80_ReadComm();
//printf("UNK W R: %08x\n", address);
return(0);
}
uint8 get8_dis(void)
{
uint8 a = bytes[bcnt++] = loadB(pc++);
return a;
}
void Macro::draw(QGraphicsScene* scene, QColor background, QColor font) {
//size 241, 281
//QBrush Ybrush(Qt::blue);
//scene->setBackgroundBrush(Ybrush);
QFont titleFont("Times", 10, QFont::Bold);
QGraphicsTextItem * titleItem = new QGraphicsTextItem;
titleItem->setPos(70,10);
titleItem->setDefaultTextColor(font);
titleItem->setFont(titleFont);
titleItem->setPlainText("Macro Recorder");
scene->addItem(titleItem);
QFont actFont("Times", 9, QFont::Bold);
QGraphicsTextItem * actItem = new QGraphicsTextItem;
actItem->setPos(30,40);
actItem->setDefaultTextColor(font);
actItem->setFont(actFont);
if (activationKeyRec == false) {
QChar key = static_cast<char>(activationKey);
QString sKey = key;
actItem->setPlainText("Activation Key: (" + sKey + ")");
}
else {
actItem->setPlainText("Activation Key: RECORDING");
}
scene->addItem(actItem);
QBrush onB(font);
QPen onP(font);
scene->addRect(160,150,40,40, onP, onB);
scene->addRect(160,200,40,40, onP, onB);
QFont onFont("Times", 11, QFont::Bold);
QGraphicsTextItem * onItem = new QGraphicsTextItem;
onItem->setPos(166,158);
if (on) {
onItem->setDefaultTextColor(Qt::yellow);
}
else {
onItem->setDefaultTextColor(Qt::black);
}
onItem->setFont(onFont);
onItem->setPlainText("On");
scene->addItem(onItem);
QFont offFont("Times", 11, QFont::Bold);
QGraphicsTextItem * offItem = new QGraphicsTextItem;
offItem->setPos(166,208);
if (on) {
offItem->setDefaultTextColor(Qt::black);
}
else {
offItem->setDefaultTextColor(Qt::yellow);
}
offItem->setFont(offFont);
offItem->setPlainText("Off");
scene->addItem(offItem);
if (recording) {
QBrush recB(Qt::red);
QPen recP(Qt::red);
scene->addRect(60,80,30,30, recP, recB);
}
else {
QBrush recB(font);
QPen recP(font);
scene->addRect(60,80,30,30, recP, recB);
}
QBrush loadB(font);
QPen loadP(font);
scene->addRect(140,80,30,30, loadP, loadB);
QFont loadFont("Times", 7, QFont::Bold);
QGraphicsTextItem * loadItem = new QGraphicsTextItem;
loadItem->setPos(140,85);
loadItem->setDefaultTextColor(Qt::black);
loadItem->setFont(loadFont);
loadItem->setPlainText("Load");
scene->addItem(loadItem);
QFont recFont("Times", 8, QFont::Bold);
QGraphicsTextItem * recItem = new QGraphicsTextItem;
recItem->setPos(61,83);
recItem->setDefaultTextColor(Qt::black);
recItem->setFont(recFont);
recItem->setPlainText("Rec");
scene->addItem(recItem);
}
