void Debugger_Disasm::Step()
{
EmuThread_LockDraw(true);
Core_DoSingleStep();
EmuThread_LockDraw(false);
_dbg_update_();
}
void QtHost::SendGPUWait(u32 cmd, u32 addr, void *data)
{
EmuThread_LockDraw(false);
if((m_GPUFlag == 1 && (cmd == GE_CMD_PRIM || cmd == GE_CMD_BEZIER || cmd == GE_CMD_SPLINE)))
{
// Break after the draw
m_GPUFlag = 0;
}
else if(m_GPUFlag == 0)
{
mainWindow->GetDialogDisasm()->UpdateDisplayList();
mainWindow->GetDialogDisplaylist()->Update();
m_hGPUStepEvent.wait(m_hGPUStepMutex);
}
else if(m_GPUFlag == 2 && addr == m_GPUData)
{
mainWindow->GetDialogDisasm()->UpdateDisplayList();
mainWindow->GetDialogDisplaylist()->Update();
m_hGPUStepEvent.wait(m_hGPUStepMutex);
}
else if(m_GPUFlag == 3 && (cmd == GE_CMD_PRIM || cmd == GE_CMD_BEZIER || cmd == GE_CMD_SPLINE))
{
GPUgstate *state = (GPUgstate*)data;
u32 texAddr = (state->texaddr[0] & 0xFFFFF0) | ((state->texbufwidth[0]<<8) & 0x0F000000);
if(texAddr == m_GPUData)
{
mainWindow->GetDialogDisasm()->UpdateDisplayList();
mainWindow->GetDialogDisplaylist()->Update();
m_hGPUStepEvent.wait(m_hGPUStepMutex);
}
}
EmuThread_LockDraw(true);
}
void Debugger_Disasm::UpdateBreakpointsGUI()
{
u32 curBpAddr = 0;
QTreeWidgetItem* curItem = ui->breakpointsList->currentItem();
if(curItem)
curBpAddr = ui->breakpointsList->currentItem()->data(0,Qt::UserRole).toInt();
ui->breakpointsList->clear();
EmuThread_LockDraw(true);
for(int i = 0; i < CBreakPoints::GetNumBreakpoints(); i++)
{
u32 addr_ = CBreakPoints::GetBreakpointAddress(i);
if(!CBreakPoints::IsTempBreakPoint(addr_))
{
QTreeWidgetItem* item = new QTreeWidgetItem();
item->setText(0,QString("%1").arg(addr_,8,16,QChar('0')));
item->setData(0,Qt::UserRole,addr_);
ui->breakpointsList->addTopLevelItem(item);
if(curBpAddr == addr_)
ui->breakpointsList->setCurrentItem(item);
}
}
EmuThread_LockDraw(false);
}
void Debugger_Disasm::Go()
{
SetDebugMode(false);
EmuThread_LockDraw(true);
Core_EnableStepping(false);
EmuThread_LockDraw(false);
mainWindow->UpdateMenus();
}
void Debugger_Disasm::SetThreadStatus(ThreadStatus status)
{
EmuThread_LockDraw(true);
__KernelChangeThreadState(threadRowSelected->data(0,Qt::UserRole).toInt(), status);
EmuThread_LockDraw(false);
UpdateThread();
}
void QtHost::SendGPUWait()
{
EmuThread_LockDraw(false);
mainWindow->GetDialogDisasm()->UpdateDisplayList();
m_hGPUStepEvent.wait(m_hGPUStepMutex);
EmuThread_LockDraw(true);
}
void Debugger_Disasm::Skip()
{
CtrlDisAsmView *ptr = ui->DisasmView;
EmuThread_LockDraw(true);
cpu->SetPC(cpu->GetPC() + cpu->getInstructionSize(0));
EmuThread_LockDraw(false);
ptr->gotoPC();
UpdateDialog();
}
void Debugger_Disasm::Stop()
{
SetDebugMode(true);
EmuThread_LockDraw(true);
Core_EnableStepping(true);
EmuThread_LockDraw(false);
_dbg_update_();
mainWindow->UpdateMenus();
UpdateDialog();
}
void Debugger_Disasm::StepHLE()
{
EmuThread_LockDraw(true);
hleDebugBreak();
SetDebugMode(false);
_dbg_update_();
Core_EnableStepping(false);
EmuThread_LockDraw(false);
mainWindow->UpdateMenus();
}
void Debugger_Disasm::StepOver()
{
SetDebugMode(false);
EmuThread_LockDraw(true);
CBreakPoints::AddBreakPoint(cpu->GetPC()+cpu->getInstructionSize(0),true);
_dbg_update_();
Core_EnableStepping(false);
EmuThread_LockDraw(false);
mainWindow->UpdateMenus();
}
void QtHost::SendGPUStart()
{
EmuThread_LockDraw(false);
if(m_GPUFlag == -1)
{
m_GPUFlag = 0;
}
EmuThread_LockDraw(true);
}
void CtrlRegisterList::CopyValue()
{
int cat = category;
int reg = selection;
if (selection >= cpu->GetNumRegsInCategory(cat))
return;
EmuThread_LockDraw(true);
u32 val = cpu->GetRegValue(cat,reg);
EmuThread_LockDraw(false);
QApplication::clipboard()->setText(QString("%1").arg(val,8,16,QChar('0')));
}
void CtrlRegisterList::GotoDisAsm()
{
int cat = category;
int reg = selection;
if (selection >= cpu->GetNumRegsInCategory(cat))
return;
EmuThread_LockDraw(true);
u32 val = cpu->GetRegValue(cat,reg);
EmuThread_LockDraw(false);
emit GotoDisasm(val);
}
void CtrlRegisterList::GotoMemory()
{
int cat = category;
int reg = selection;
if (selection >= cpu->GetNumRegsInCategory(cat))
return;
EmuThread_LockDraw(true);
u32 val = cpu->GetRegValue(cat,reg);
EmuThread_LockDraw(false);
parentWindow->ShowMemory(val);
}
void GamePadDialog::showEvent(QShowEvent *)
{
#ifdef Q_WS_X11
// Hack to remove the X11 crash with threaded opengl when opening the first dialog
EmuThread_LockDraw(true);
QTimer::singleShot(100, this, SLOT(releaseLock()));
#endif
}
void CtrlMemView::Change()
{
EmuThread_LockDraw(true);
QString curVal = QString("%1").arg(Memory::ReadUnchecked_U32(selection),8,16,QChar('0'));
EmuThread_LockDraw(false);
bool ok;
QString text = QInputDialog::getText(this, tr("Set new value"),
tr("Set new value:"), QLineEdit::Normal,
curVal, &ok);
if (ok && !text.isEmpty())
{
EmuThread_LockDraw(true);
Memory::WriteUnchecked_U32(text.toUInt(0,16),selection);
EmuThread_LockDraw(false);
redraw();
}
}
void Debugger_Disasm::UpdateThreadGUI()
{
ui->threadList->clear();
EmuThread_LockDraw(true);
std::vector<DebugThreadInfo> threads = GetThreadsInfo();
EmuThread_LockDraw(false);
for(int i = 0; i < threads.size(); i++)
{
QTreeWidgetItem* item = new QTreeWidgetItem();
item->setText(0,QVariant(threads[i].id).toString());
item->setData(0,Qt::UserRole,threads[i].id);
item->setText(1,threads[i].name);
QString status = "";
if(threads[i].status & THREADSTATUS_RUNNING) status += "Running ";
if(threads[i].status & THREADSTATUS_WAIT) status += "Wait ";
if(threads[i].status & THREADSTATUS_READY) status += "Ready ";
if(threads[i].status & THREADSTATUS_SUSPEND) status += "Suspend ";
if(threads[i].status & THREADSTATUS_DORMANT) status += "Dormant ";
if(threads[i].status & THREADSTATUS_DEAD) status += "Dead ";
item->setText(2,status);
char temp[24];
sprintf(temp,"%08x",threads[i].curPC);
item->setText(3,temp);
item->setData(3,Qt::UserRole,threads[i].curPC);
sprintf(temp,"%08x",threads[i].entrypoint);
item->setText(4,temp);
item->setData(4,Qt::UserRole,threads[i].entrypoint);
if(threads[i].isCurrent)
{
for(int j = 0; j < 5; j++)
item->setTextColor(j,Qt::green);
}
ui->threadList->addTopLevelItem(item);
}
}
void Debugger_Disasm::UpdateThreadGUI()
{
ui->threadList->clear();
EmuThread_LockDraw(true);
std::vector<DebugThreadInfo> threads = GetThreadsInfo();
EmuThread_LockDraw(false);
for(size_t i = 0; i < threads.size(); i++)
{
QTreeWidgetItem* item = new QTreeWidgetItem();
item->setText(0,QString::number(threads[i].id));
item->setData(0,Qt::UserRole,threads[i].id);
item->setText(1,threads[i].name);
QString status = "";
if(threads[i].status & THREADSTATUS_RUNNING) status += "Running ";
if(threads[i].status & THREADSTATUS_WAIT) status += "Wait ";
if(threads[i].status & THREADSTATUS_READY) status += "Ready ";
if(threads[i].status & THREADSTATUS_SUSPEND) status += "Suspend ";
if(threads[i].status & THREADSTATUS_DORMANT) status += "Dormant ";
if(threads[i].status & THREADSTATUS_DEAD) status += "Dead ";
item->setText(2,status);
item->setText(3,QString("%1").arg(threads[i].curPC,8,16,QChar('0')));
item->setData(3,Qt::UserRole,threads[i].curPC);
item->setText(4,QString("%1").arg(threads[i].entrypoint,8,16,QChar('0')));
item->setData(4,Qt::UserRole,threads[i].entrypoint);
if(threads[i].isCurrent)
{
for(int j = 0; j < 5; j++)
item->setTextColor(j,Qt::green);
}
ui->threadList->addTopLevelItem(item);
}
for(int i = 0; i < ui->threadList->columnCount(); i++)
ui->threadList->resizeColumnToContents(i);
}
void CtrlRegisterList::Change()
{
int cat = category;
int reg = selection;
if (selection >= cpu->GetNumRegsInCategory(cat))
return;
EmuThread_LockDraw(true);
u32 val = cpu->GetRegValue(cat,reg);
EmuThread_LockDraw(false);
bool ok;
QString text = QInputDialog::getText(this, tr("Set new value"),
tr("Set new value:"), QLineEdit::Normal,
QString::number(val), &ok);
if (ok && !text.isEmpty())
{
EmuThread_LockDraw(true);
cpu->SetRegValue(cat,reg,text.toInt());
EmuThread_LockDraw(false);
redraw();
}
}
void Debugger_Disasm::showEvent(QShowEvent *)
{
#ifdef Q_WS_X11
// Hack to remove the X11 crash with threaded opengl when opening the first dialog
EmuThread_LockDraw(true);
QTimer::singleShot(100, this, SLOT(releaseLock()));
#endif
if(Core_IsStepping())
SetDebugMode(true);
else
SetDebugMode(false);
}
void MainWindow::CoreEmitWait(bool isWaiting)
{
// Unlock mutex while core is waiting;
EmuThread_LockDraw(!isWaiting);
}
void CtrlMemView::CopyValue()
{
EmuThread_LockDraw(true);
QApplication::clipboard()->setText(QString("%1").arg(Memory::ReadUnchecked_U32(selection),8,16,QChar('0')));
EmuThread_LockDraw(false);
}
void CtrlMemView::paintEvent(QPaintEvent *)
{
QPainter painter(this);
painter.setBrush(Qt::white);
painter.setPen(Qt::white);
painter.drawRect(rect());
if (!debugger)
return;
int width = rect().width();
int numRows=(rect().bottom()/rowHeight)/2+1;
QPen nullPen(0xFFFFFF);
QPen currentPen(0xFF000000);
QPen selPen(0x808080);
QBrush lbr(0xFFFFFF);
QBrush nullBrush(0xFFFFFF);
QBrush currentBrush(0xFFEFE8);
QBrush pcBrush(0x70FF70);
QPen textPen;
QFont normalFont("Arial", 10);
QFont alignedFont("Monospace", 10);
alignedFont.setStyleHint(QFont::Monospace);
painter.setFont(normalFont);
int i;
curAddress&=~(align-1);
for (i=-numRows; i<=numRows; i++)
{
unsigned int address=curAddress + i*align*alignMul;
int rowY1 = rect().bottom()/2 + rowHeight*i - rowHeight/2;
int rowY2 = rect().bottom()/2 + rowHeight*i + rowHeight/2;
char temp[256];
painter.setBrush(currentBrush);
if (selecting && address == (unsigned int)selection)
painter.setPen(selPen);
else
painter.setPen(i==0 ? currentPen : nullPen);
painter.drawRect(0, rowY1, 16-1, rowY2 - rowY1 - 1);
painter.drawRect(16, rowY1, width - 16 -1, rowY2 - rowY1 - 1);
painter.setBrush(nullBrush);
textPen.setColor(0x600000);
painter.setPen(textPen);
painter.setFont(alignedFont);
painter.drawText(17,rowY1-2+rowHeight, QString("%1").arg(address,8,16,QChar('0')));
textPen.setColor(0xFF000000);
painter.setPen(textPen);
if (debugger->isAlive())
{
switch(mode) {
case MV_NORMAL:
{
const char *m = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
if (Memory::IsValidAddress(address))
{
EmuThread_LockDraw(true);
u32 memory[4] = {
debugger->readMemory(address),
debugger->readMemory(address+4),
debugger->readMemory(address+8),
debugger->readMemory(address+12)
};
EmuThread_LockDraw(false);
m = (const char*)memory;
sprintf(temp, "%08x %08x %08x %08x ................",
memory[0],memory[1],memory[2],memory[3]);
}
for (int i=0; i<16; i++)
{
int c = (unsigned char)m[i];
if (c>=32 && c<255)
temp[i+37]=c;
}
}
painter.setFont(alignedFont);
painter.drawText(85,rowY1 - 2 + rowHeight, temp);
break;
case MV_SYMBOLS:
{
textPen.setColor(0x0000FF);
painter.setPen(textPen);
int fn = symbolMap.GetSymbolNum(address);
if (fn==-1)
{
sprintf(temp, "%s (ns)", Memory::GetAddressName(address));
}
else
sprintf(temp, "%s (0x%x b)", symbolMap.GetSymbolName(fn),symbolMap.GetSymbolSize(fn));
painter.drawText(205,rowY1 - 2 + rowHeight, temp);
textPen.setColor(0xFF000000);
painter.setPen(textPen);
if (align==4)
{
u32 value = Memory::ReadUnchecked_U32(address);
int symbolnum = symbolMap.GetSymbolNum(value);
if(symbolnum>=0)
sprintf(temp, "%08x [%s]", value, symbolMap.GetSymbolName(symbolnum));
}
else if (align==2)
{
u16 value = Memory::ReadUnchecked_U16(address);
int symbolnum = symbolMap.GetSymbolNum(value);
if(symbolnum>=0)
sprintf(temp, "%04x [%s]", value, symbolMap.GetSymbolName(symbolnum));
}
painter.drawText(85,rowY1 - 2 + rowHeight, temp);
break;
}
case MV_MAX: break;
}
}
}
}
void Debugger_Memory::releaseLock()
{
EmuThread_LockDraw(false);
}
void Debugger_Disasm::UpdateDisplayListGUI()
{
u32 curDlId = 0;
QTreeWidgetItem* curItem = ui->displayList->currentItem();
if(curItem)
curDlId = ui->displayList->currentItem()->data(0,Qt::UserRole).toInt();
ui->displayList->clear();
ui->displayListData->clear();
EmuThread_LockDraw(true);
const std::deque<DisplayList>& dlQueue = gpu->GetDisplayLists();
DisplayList* dl = gpu->GetCurrentDisplayList();
if(dl)
{
QTreeWidgetItem* item = new QTreeWidgetItem();
item->setText(0,QVariant(dl->id).toString());
item->setData(0, Qt::UserRole, dl->id);
switch(dl->status)
{
case PSP_GE_LIST_DONE: item->setText(1,"Done"); break;
case PSP_GE_LIST_QUEUED: item->setText(1,"Queued"); break;
case PSP_GE_LIST_DRAWING: item->setText(1,"Drawing"); break;
case PSP_GE_LIST_STALL_REACHED: item->setText(1,"Stall Reached"); break;
case PSP_GE_LIST_END_REACHED: item->setText(1,"End Reached"); break;
case PSP_GE_LIST_CANCEL_DONE: item->setText(1,"Cancel Done"); break;
default: break;
}
char temp[24];
sprintf(temp,"%08x",dl->startpc);
item->setText(2,temp);
item->setData(2, Qt::UserRole, dl->startpc);
sprintf(temp,"%08x",dl->pc);
item->setText(3,temp);
item->setData(3, Qt::UserRole, dl->pc);
ui->displayList->addTopLevelItem(item);
if(curDlId == dl->id)
{
ui->displayList->setCurrentItem(item);
displayListRowSelected = item;
ShowDLCode();
}
}
for(auto it = dlQueue.begin(); it != dlQueue.end(); ++it)
{
if(dl && it->id == dl->id)
continue;
QTreeWidgetItem* item = new QTreeWidgetItem();
item->setText(0,QVariant(it->id).toString());
item->setData(0, Qt::UserRole, it->id);
switch(it->status)
{
case PSP_GE_LIST_DONE: item->setText(1,"Done"); break;
case PSP_GE_LIST_QUEUED: item->setText(1,"Queued"); break;
case PSP_GE_LIST_DRAWING: item->setText(1,"Drawing"); break;
case PSP_GE_LIST_STALL_REACHED: item->setText(1,"Stall Reached"); break;
case PSP_GE_LIST_END_REACHED: item->setText(1,"End Reached"); break;
case PSP_GE_LIST_CANCEL_DONE: item->setText(1,"Cancel Done"); break;
default: break;
}
char temp[24];
sprintf(temp,"%08x",it->startpc);
item->setText(2,temp);
item->setData(2, Qt::UserRole, it->startpc);
sprintf(temp,"%08x",it->pc);
item->setText(3,temp);
item->setData(3, Qt::UserRole, it->pc);
ui->displayList->addTopLevelItem(item);
if(curDlId == it->id)
{
ui->displayList->setCurrentItem(item);
displayListRowSelected = item;
ShowDLCode();
}
}
EmuThread_LockDraw(false);
}
void GamePadDialog::releaseLock()
{
EmuThread_LockDraw(false);
}
void EmuThread::run()
{
running = true;
setCurrentThreadName("EmuThread");
host->UpdateUI();
host->InitGL(0);
EmuThread_LockDraw(true);
#ifndef USING_GLES2
glewInit();
#endif
NativeInitGraphics();
INFO_LOG(BOOT, "Starting up hardware.");
QElapsedTimer timer;
EmuThread_LockDraw(false);
while(running) {
//UpdateGamepad(*input_state);
timer.start();
gameMutex->lock();
bool gRun = gameRunning;
gameMutex->unlock();
if(gRun)
{
EmuThread_LockDraw(true);
if(needInitGame)
{
CoreParameter coreParameter;
coreParameter.fileToStart = fileToStart.toStdString();
coreParameter.enableSound = true;
coreParameter.gpuCore = GPU_GLES;
coreParameter.cpuCore = g_Config.bJit ? CPU_JIT : CPU_INTERPRETER;
coreParameter.enableDebugging = true;
coreParameter.printfEmuLog = false;
coreParameter.headLess = false;
coreParameter.renderWidth = (480 * g_Config.iWindowZoom) * (g_Config.SSAntiAliasing + 1);
coreParameter.renderHeight = (272 * g_Config.iWindowZoom) * (g_Config.SSAntiAliasing + 1);
coreParameter.outputWidth = dp_xres;
coreParameter.outputHeight = dp_yres;
coreParameter.pixelWidth = pixel_xres;
coreParameter.pixelHeight = pixel_yres;
coreParameter.startPaused = !g_Config.bAutoRun;
std::string error_string;
if (!PSP_Init(coreParameter, &error_string))
{
ERROR_LOG(BOOT, "Error loading: %s", error_string.c_str());
FinalShutdown();
return;
}
LayoutGamepad(dp_xres, dp_yres);
_dbg_update_();
host->UpdateDisassembly();
Core_EnableStepping(coreParameter.startPaused ? TRUE : FALSE);
globalUIState = coreParameter.startPaused ? UISTATE_PAUSEMENU : UISTATE_INGAME;
#ifdef _DEBUG
host->UpdateMemView();
#endif
host->BootDone();
needInitGame = false;
}
glstate.Restore();
glViewport(0, 0, pixel_xres, pixel_yres);
Matrix4x4 ortho;
ortho.setOrtho(0.0f, dp_xres, dp_yres, 0.0f, -1.0f, 1.0f);
glsl_bind(UIShader_Get());
glUniformMatrix4fv(UIShader_Get()->u_worldviewproj, 1, GL_FALSE, ortho.getReadPtr());
ReapplyGfxState();
Core_Run();
// Hopefully coreState is now CORE_NEXTFRAME
if (coreState == CORE_NEXTFRAME) {
// set back to running for the next frame
coreState = CORE_RUNNING;
qint64 time = timer.elapsed();
const int frameTime = (1.0f/60.0f) * 1000;
if(time < frameTime)
{
EmuThread_LockDraw(false);
msleep(frameTime-time);
EmuThread_LockDraw(true);
}
timer.start();
}
fbo_unbind();
UIShader_Prepare();
uiTexture->Bind(0);
glViewport(0, 0, pixel_xres, pixel_yres);
ui_draw2d.Begin(UIShader_Get(), DBMODE_NORMAL);
//if (g_Config.bShowTouchControls)
// DrawGamepad(ui_draw2d);
glsl_bind(UIShader_Get());
ui_draw2d.End();
ui_draw2d.Flush();
// Tiled renderers like PowerVR should benefit greatly from this. However - seems I can't call it?
#if defined(USING_GLES2)
bool hasDiscard = false; // TODO
if (hasDiscard) {
//glDiscardFramebuffer(GL_COLOR_EXT | GL_DEPTH_EXT | GL_STENCIL_EXT);
}
#endif
glWindow->swapBuffers();
EmuThread_LockDraw(false);
}
else
{
EmuThread_LockDraw(true);
glClearColor(0, 0, 0, 0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
time_update();
float t = (float)frames_ / 60.0f;
frames_++;
float alpha = t;
if (t > 1.0f) alpha = 1.0f;
float alphaText = alpha;
//if (t > 2.0f) alphaText = 3.0f - t;
glstate.Restore();
glViewport(0, 0, pixel_xres, pixel_yres);
Matrix4x4 ortho;
ortho.setOrtho(0.0f, dp_xres, dp_yres, 0.0f, -1.0f, 1.0f);
glsl_bind(UIShader_Get());
glUniformMatrix4fv(UIShader_Get()->u_worldviewproj, 1, GL_FALSE, ortho.getReadPtr());
ReapplyGfxState();
UIShader_Prepare();
glViewport(0, 0, pixel_xres, pixel_yres);
UIBegin(UIShader_Get());
DrawBackground(alpha);
ui_draw2d.SetFontScale(1.5f, 1.5f);
ui_draw2d.DrawText(UBUNTU48, "PPSSPP", dp_xres / 2, dp_yres / 2 - 30, colorAlpha(0xFFFFFFFF, alphaText), ALIGN_CENTER);
ui_draw2d.SetFontScale(1.0f, 1.0f);
ui_draw2d.DrawText(UBUNTU24, "Created by Henrik Rydgard", dp_xres / 2, dp_yres / 2 + 40, colorAlpha(0xFFFFFFFF, alphaText), ALIGN_CENTER);
ui_draw2d.DrawText(UBUNTU24, "Free Software under GPL 2.0", dp_xres / 2, dp_yres / 2 + 70, colorAlpha(0xFFFFFFFF, alphaText), ALIGN_CENTER);
ui_draw2d.DrawText(UBUNTU24, "www.ppsspp.org", dp_xres / 2, dp_yres / 2 + 130, colorAlpha(0xFFFFFFFF, alphaText), ALIGN_CENTER);
UIEnd();
globalUIState = UISTATE_MENU;
glsl_bind(UIShader_Get());
ui_draw2d.Flush();
glWindow->swapBuffers();
EmuThread_LockDraw(false);
qint64 time = timer.elapsed();
const int frameTime = (1.0f/60.0f) * 1000;
if(time < frameTime)
{
msleep(frameTime-time);
}
timer.start();
}
}
if(gameRunning)
{
stopGame();
}
}
void Debugger_Disasm::releaseLock()
{
EmuThread_LockDraw(false);
}
void Debugger_Disasm::UpdateDisplayListGUI()
{
u32 curDlId = 0;
QTreeWidgetItem* curItem = ui->displayList->currentItem();
if(curItem)
curDlId = ui->displayList->currentItem()->data(0,Qt::UserRole).toInt();
ui->displayList->clear();
EmuThread_LockDraw(true);
const std::list<int>& dlQueue = gpu->GetDisplayLists();
DisplayList* dl = gpu->GetCurrentDisplayList();
if(dl)
{
QTreeWidgetItem* item = new QTreeWidgetItem();
item->setText(0,QString::number(dl->id));
item->setData(0, Qt::UserRole, dl->id);
switch(dl->state)
{
case PSP_GE_DL_STATE_NONE: item->setText(1,"None"); break;
case PSP_GE_DL_STATE_QUEUED: item->setText(1,"Queued"); break;
case PSP_GE_DL_STATE_RUNNING: item->setText(1,"Running"); break;
case PSP_GE_DL_STATE_COMPLETED: item->setText(1,"Completed"); break;
case PSP_GE_DL_STATE_PAUSED: item->setText(1,"Paused"); break;
default: break;
}
item->setText(2,QString("%1").arg(dl->startpc,8,16,QChar('0')));
item->setData(2, Qt::UserRole, dl->startpc);
item->setText(3,QString("%1").arg(dl->pc,8,16,QChar('0')));
item->setData(3, Qt::UserRole, dl->pc);
ui->displayList->addTopLevelItem(item);
if(curDlId == (u32)dl->id)
{
ui->displayList->setCurrentItem(item);
displayListRowSelected = item;
}
}
for(auto listIdIt = dlQueue.begin(); listIdIt != dlQueue.end(); ++listIdIt)
{
DisplayList *it = gpu->getList(*listIdIt);
if(dl && it->id == dl->id)
continue;
QTreeWidgetItem* item = new QTreeWidgetItem();
item->setText(0,QString::number(it->id));
item->setData(0, Qt::UserRole, it->id);
switch(it->state)
{
case PSP_GE_DL_STATE_NONE: item->setText(1,"None"); break;
case PSP_GE_DL_STATE_QUEUED: item->setText(1,"Queued"); break;
case PSP_GE_DL_STATE_RUNNING: item->setText(1,"Running"); break;
case PSP_GE_DL_STATE_COMPLETED: item->setText(1,"Completed"); break;
case PSP_GE_DL_STATE_PAUSED: item->setText(1,"Paused"); break;
default: break;
}
item->setText(2,QString("%1").arg(it->startpc,8,16,QChar('0')));
item->setData(2, Qt::UserRole, it->startpc);
item->setText(3,QString("%1").arg(it->pc,8,16,QChar('0')));
item->setData(3, Qt::UserRole, it->pc);
ui->displayList->addTopLevelItem(item);
if(curDlId == (u32)it->id)
{
ui->displayList->setCurrentItem(item);
displayListRowSelected = item;
}
}
for(int i = 0; i < ui->displayList->columnCount(); i++)
ui->displayList->resizeColumnToContents(i);
EmuThread_LockDraw(false);
}
