void XWindow::openWindow(const Pnt2f& ScreenPosition,
const Vec2f& Size,
const std::string& WindowName)
{
int argc(1);
char **argv = new char*[1];
(*argv)= "Bla";
XSetStandardProperties(this->getDisplay(), this->getWindow(), WindowName.c_str(), WindowName.c_str(), None, argv, argc, NULL);
attachWindow();
this->init();
XMapWindow(this->getDisplay(),
this->getWindow());
XEvent event;
XIfEvent(this->getDisplay(), &event, wait_for_map_notify, (char *)(this->getWindow()));
produceWindowOpened();
this->activate();
setPosition(ScreenPosition);
setSize(Vec2us(Size[0], Size[1]));
//Set things up to capture the delete window event
Atom wm_delete_window=XInternAtom(this->getDisplay(), "WM_DELETE_WINDOW", False);
XSetWMProtocols(this->getDisplay(), this->getWindow(), &wm_delete_window, 1);
Atom wm_protocols=XInternAtom(this->getDisplay(), "WM_PROTOCOLS", False);
}
//----------------------------------------------------------------------------//
RenderingWindow& RenderingSurface::createRenderingWindow(TextureTarget& target)
{
RenderingWindow* w = new RenderingWindow(target, *this);
attachWindow(*w);
return *w;
}
void RKWorkplace::addWindow (RKMDIWindow *window, bool attached) {
RK_TRACE (APP);
windows.append (window);
connect (window, SIGNAL (destroyed (QObject *)), this, SLOT (windowDestroyed (QObject *)));
if (attached) attachWindow (window);
else detachWindow (window, false);
}
void InspectorFrontendClientLocal::requestSetDockSide(DockSide dockSide)
{
if (dockSide == DockSide::Undocked) {
detachWindow();
setAttachedWindow(dockSide);
} else if (canAttachWindow()) {
attachWindow(dockSide);
setAttachedWindow(dockSide);
}
}
//----------------------------------------------------------------------------//
void RenderingSurface::transferRenderingWindow(RenderingWindow& window)
{
if (&window.getOwner() != this)
{
// detach window from it's current owner
window.getOwner().detatchWindow(window);
// add window to this surface.
attachWindow(window);
window.setOwner(*this);
}
}
//-----------------------------------------------
void CSmLabel::init(HINSTANCE hInst, HWND hOwner, HWND hWnd)
{
m_hInstance = hInst;
m_hOwner = hOwner;
attachWindow(hWnd);
// setup GDI
m_textColor = GetSysColor(COLOR_WINDOWTEXT);
m_hBrush = CreateSolidBrush(GetSysColor(COLOR_3DFACE));
HFONT hFont = (HFONT)SendMessage(hWnd, WM_GETFONT, 0, 0);
if (hFont != NULL)
GetObject(hFont,sizeof(m_lf),&m_lf);
else
GetObject((HFONT)GetStockObject(DEFAULT_GUI_FONT),sizeof(m_lf),&m_lf);
m_hFont = CreateFontIndirect(&m_lf);
m_hCursor = NULL;
}
void Button::setImage(const std::string imageName, const float sizeX, const float sizeY)
{
mImage.setImage(imageName, sizeX, sizeY);
attachWindow(mImage);
}
VkBool32 VKTS_APIENTRY engineRun()
{
if (g_engineState != VKTS_ENGINE_INIT_STATE)
{
logPrint(VKTS_LOG_ERROR, "Engine: Run failed! Not in initialize state.");
return VK_FALSE;
}
if (engineGetNumberUpdateThreads() < VKTS_MIN_UPDATE_THREADS || engineGetNumberUpdateThreads() > VKTS_MAX_UPDATE_THREADS)
{
logPrint(VKTS_LOG_ERROR, "Engine: Run failed! Number of update threads not correct.");
return VK_FALSE;
}
//
// Main thread gets all displays and windows attached.
//
const auto& displayList = _visualGetActiveDisplays();
for (size_t i = 0; i < displayList.size(); i++)
{
engineAttachDisplayToUpdateThread(displayList[i], g_allUpdateThreads[g_allUpdateThreads.size() - 1]);
}
const auto& windowList = _visualGetActiveWindows();
for (size_t i = 0; i < windowList.size(); i++)
{
engineAttachWindowToUpdateThread(windowList[i], g_allUpdateThreads[g_allUpdateThreads.size() - 1]);
}
//
g_engineState = VKTS_ENGINE_UPDATE_STATE;
logPrint(VKTS_LOG_INFO, "Engine: Started.");
// Task queue creation.
TaskQueueSP sendTaskQueue;
TaskQueueSP executedTaskQueue;
if (g_taskExecutorCount > 0)
{
sendTaskQueue = TaskQueueSP(new TaskQueue);
if (!sendTaskQueue.get())
{
logPrint(VKTS_LOG_ERROR, "Engine: Run failed! Could not create task queue.");
return VK_FALSE;
}
executedTaskQueue = TaskQueueSP(new TaskQueue);
if (!executedTaskQueue.get())
{
logPrint(VKTS_LOG_ERROR, "Engine: Run failed! Could not create task queue.");
return VK_FALSE;
}
}
// Message dispatcher creation.
MessageDispatcherSP messageDispatcher = MessageDispatcherSP(new MessageDispatcher());
if (!messageDispatcher.get())
{
logPrint(VKTS_LOG_ERROR, "Engine: Run failed! Could not create message dispatcher.");
return VK_FALSE;
}
// Object, needed for synchronizing the executors.
ExecutorSync executorSync;
//
// Task executor creation and launching,
//
SmartPointerVector<TaskExecutorSP> realTaskExecutors;
SmartPointerVector<ThreadSP> realTaskThreads;
for (uint32_t i = 0; i < g_taskExecutorCount; i++)
{
auto currentTaskExecutor = TaskExecutorSP(new TaskExecutor(i, executorSync, sendTaskQueue, executedTaskQueue));
if (!currentTaskExecutor.get())
{
logPrint(VKTS_LOG_ERROR, "Engine: Run failed! Could not create current task executor.");
return VK_FALSE;
}
auto currentRealThread = ThreadSP(new std::thread(&TaskExecutor::run, currentTaskExecutor));
if (!currentRealThread.get())
{
logPrint(VKTS_LOG_ERROR, "Engine: Run failed! Could not create current real thread.");
return VK_FALSE;
}
//
realTaskExecutors.append(currentTaskExecutor);
realTaskThreads.append(currentRealThread);
logPrint(VKTS_LOG_INFO, "Engine: Task %d started.", currentTaskExecutor->getIndex());
}
//
// Update Thread creation and launching.
//
UpdateThreadExecutorSP mainUpdateThreadExecutor;
SmartPointerVector<UpdateThreadExecutorSP> realUpdateThreadExecutors;
SmartPointerVector<ThreadSP> realUpdateThreads;
int32_t index = 0;
for (size_t updateThreadIndex = 0; updateThreadIndex < g_allUpdateThreads.size(); updateThreadIndex++)
{
const auto& currentUpdateThread = g_allUpdateThreads[updateThreadIndex];
//
const auto currentMessageDispatcher = (index == engineGetNumberUpdateThreads() - 1) ? messageDispatcher : MessageDispatcherSP();
//
auto currentUpdateThreadContext = UpdateThreadContextSP(new UpdateThreadContext((int32_t) updateThreadIndex, (int32_t) g_allUpdateThreads.size(), g_tickTime, sendTaskQueue, executedTaskQueue));
if (!currentUpdateThreadContext.get())
{
logPrint(VKTS_LOG_ERROR, "Engine: Run failed! Could not create update thread context.");
return VK_FALSE;
}
//
for (auto currentDisplayWalker = g_allAttachedDisplays.lower_bound(currentUpdateThread); currentDisplayWalker != g_allAttachedDisplays.upper_bound(currentUpdateThread); currentDisplayWalker++)
{
currentUpdateThreadContext->attachDisplay(currentDisplayWalker->second);
}
//
for (auto currentWindowWalker = g_allAttachedWindows.lower_bound(currentUpdateThread); currentWindowWalker != g_allAttachedWindows.upper_bound(currentUpdateThread); currentWindowWalker++)
{
currentUpdateThreadContext->attachWindow(currentWindowWalker->second);
}
//
if (index == engineGetNumberUpdateThreads() - 1)
{
// Last thread is the main thread.
mainUpdateThreadExecutor = UpdateThreadExecutorSP(new UpdateThreadExecutor(index, executorSync, currentUpdateThread, currentUpdateThreadContext, currentMessageDispatcher));
if (!mainUpdateThreadExecutor.get())
{
logPrint(VKTS_LOG_ERROR, "Engine: Run failed! Could not create main update thread executor.");
return VK_FALSE;
}
}
else
{
// Receive queue is the threads send queue.
auto currentUpdateThreadExecutor = UpdateThreadExecutorSP(new UpdateThreadExecutor(index, executorSync, currentUpdateThread, currentUpdateThreadContext, currentMessageDispatcher));
if (!currentUpdateThreadExecutor.get())
{
logPrint(VKTS_LOG_ERROR, "Engine: Run failed! Could not create current update thread executor.");
return VK_FALSE;
}
realUpdateThreadExecutors.append(currentUpdateThreadExecutor);
logPrint(VKTS_LOG_INFO, "Engine: Thread %d started.", currentUpdateThreadExecutor->getIndex());
auto currentRealThread = ThreadSP(new std::thread(&UpdateThreadExecutor::run, currentUpdateThreadExecutor));
if (!currentRealThread.get())
{
logPrint(VKTS_LOG_ERROR, "Engine: Run failed! Could not create current real thread.");
return VK_FALSE;
}
realUpdateThreads.append(currentRealThread);
}
index++;
}
// Run last thread and loop.
logPrint(VKTS_LOG_INFO, "Engine: Thread %d started.", mainUpdateThreadExecutor->getIndex());
mainUpdateThreadExecutor->run();
//
// Stopping everything.
//
logPrint(VKTS_LOG_INFO, "Engine: Thread %d stopped.", mainUpdateThreadExecutor->getIndex());
// Wait for all threads to finish in the reverse order they were created.
for (auto reverseIndex = static_cast<int32_t>(realUpdateThreads.size()) - 1; reverseIndex >= 0; reverseIndex--)
{
const auto& currentRealThread = realUpdateThreads[reverseIndex];
currentRealThread->join();
logPrint(VKTS_LOG_INFO, "Engine: Thread %d stopped.", reverseIndex);
}
realUpdateThreadExecutors.clear();
realUpdateThreads.clear();
//
if (sendTaskQueue.get())
{
// Empty the queue.
// As no update thread can feed the queue anymore, it is save to call reset.
sendTaskQueue->reset();
//
ITaskSP stopTask;
logPrint(VKTS_LOG_SEVERE, "Engine: Disabling task queue.");
for (uint32_t i = 0; i < g_taskExecutorCount; i++)
{
// Send an empty task to the queue, to exit the thread.
sendTaskQueue->addTask(stopTask);
}
}
// Wait for all tasks to finish in the reverse order they were created.
for (auto reverseIndex = static_cast<int32_t>(realTaskThreads.size()) - 1; reverseIndex >= 0; reverseIndex--)
{
const auto& currentRealThread = realTaskThreads[reverseIndex];
currentRealThread->join();
logPrint(VKTS_LOG_INFO, "Engine: Task %d stopped.", reverseIndex);
}
realTaskExecutors.clear();
realTaskThreads.clear();
//
g_engineState = VKTS_ENGINE_INIT_STATE;
logPrint(VKTS_LOG_INFO, "Engine: Stopped.");
return VK_TRUE;
}
//-----------------------------------------------
void CSmartEdit::init(HINSTANCE hInst, HWND hOwner, HWND hWnd)
{
m_hInstance = hInst;
m_hOwner = hOwner;
attachWindow(hWnd);
}
