VBoxDbgConsole.cpp@ 48935

Last change on this file since 48935 was 46727, checked in by vboxsync, 11 years ago
Debugger/VBoxDbgConsole: A legible font on S10 hosts for the debugger, spaces.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 19.6 KB

Line
1	/* $Id: VBoxDbgConsole.cpp 46727 2013-06-21 16:00:51Z vboxsync $ */
2	/** @file
3	* VBox Debugger GUI - Console.
4	*/
5
6	/*
7	* Copyright (C) 2006-2012 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*******************************************************************************
20	* Header Files *
21	*******************************************************************************/
22	#define LOG_GROUP LOG_GROUP_DBGG
23	#include "VBoxDbgConsole.h"
24
25	#include <QLabel>
26	#include <QApplication>
27	#include <QFont>
28	#include <QLineEdit>
29	#include <QHBoxLayout>
30	#include <QAction>
31	#include <QContextMenuEvent>
32
33	#include <VBox/dbg.h>
34	#include <VBox/vmm/cfgm.h>
35	#include <VBox/err.h>
36
37	#include <iprt/thread.h>
38	#include <iprt/tcp.h>
39	#include <VBox/log.h>
40	#include <iprt/assert.h>
41	#include <iprt/asm.h>
42	#include <iprt/alloc.h>
43	#include <iprt/string.h>
44
45
46
47
48	/*
49	*
50	* V B o x D b g C o n s o l e O u t p u t
51	* V B o x D b g C o n s o l e O u t p u t
52	* V B o x D b g C o n s o l e O u t p u t
53	*
54	*
55	*/
56
57
58	VBoxDbgConsoleOutput::VBoxDbgConsoleOutput(QWidget pParent/ = NULL/, const char pszName/* = NULL*/)
59	: QTextEdit(pParent), m_uCurLine(0), m_uCurPos(0), m_hGUIThread(RTThreadNativeSelf())
60	{
61	setReadOnly(true);
62	setUndoRedoEnabled(false);
63	setOverwriteMode(false);
64	setPlainText("");
65	setTextInteractionFlags(Qt::TextBrowserInteraction);
66	setAutoFormatting(QTextEdit::AutoAll);
67	setTabChangesFocus(true);
68	setAcceptRichText(false);
69
70	#ifdef Q_WS_MAC
71	QFont Font("Monaco", 10, QFont::Normal, FALSE);
72	Font.setStyleStrategy(QFont::NoAntialias);
73	#else
74	QFont Font = font();
75	Font.setStyleHint(QFont::TypeWriter);
76	Font.setFamily("Courier [Monotype]");
77	#endif
78	setFont(Font);
79
80	/* green on black */
81	QPalette Pal(palette());
82	Pal.setColor(QPalette::All, QPalette::Base, QColor(Qt::black));
83	setPalette(Pal);
84	setTextColor(QColor(qRgb(0, 0xe0, 0)));
85
86	#ifdef DEBUG_ramshankar
87	/* Solaris host (esp. S10) has illegible Courier font (bad aliasing). */
88	Font.setFamily("Monospace [Monotype]");
89	setFont(Font);
90
91	/* White on black while I'm at it. */
92	Pal.setColor(QPalette::All, QPalette::Base, QColor(Qt::white));
93	setPalette(Pal);
94	setTextColor(QColor(qRgb(0, 0, 0)));
95	#endif
96
97	NOREF(pszName);
98	}
99
100
101	VBoxDbgConsoleOutput::~VBoxDbgConsoleOutput()
102	{
103	Assert(m_hGUIThread == RTThreadNativeSelf());
104	}
105
106
107	void
108	VBoxDbgConsoleOutput::appendText(const QString &rStr, bool fClearSelection)
109	{
110	Assert(m_hGUIThread == RTThreadNativeSelf());
111
112	if (rStr.isEmpty() \|\| rStr.isNull() \|\| !rStr.length())
113	return;
114
115	/*
116	* Insert all in one go and make sure it's visible.
117	*
118	* We need to move the cursor and unselect any selected text before
119	* inserting anything, otherwise, text will disappear.
120	*/
121	QTextCursor Cursor = textCursor();
122	if (!fClearSelection && Cursor.hasSelection())
123	{
124	QTextCursor SavedCursor = Cursor;
125	Cursor.clearSelection();
126	Cursor.movePosition(QTextCursor::End);
127
128	Cursor.insertText(rStr);
129
130	setTextCursor(SavedCursor);
131	}
132	else
133	{
134	if (Cursor.hasSelection())
135	Cursor.clearSelection();
136	if (!Cursor.atEnd())
137	Cursor.movePosition(QTextCursor::End);
138
139	Cursor.insertText(rStr);
140
141	setTextCursor(Cursor);
142	ensureCursorVisible();
143	}
144	}
145
146
147
148
149	/*
150	*
151	* V B o x D b g C o n s o l e I n p u t
152	* V B o x D b g C o n s o l e I n p u t
153	* V B o x D b g C o n s o l e I n p u t
154	*
155	*
156	*/
157
158
159	VBoxDbgConsoleInput::VBoxDbgConsoleInput(QWidget pParent/ = NULL/, const char pszName/* = NULL*/)
160	: QComboBox(pParent), m_hGUIThread(RTThreadNativeSelf())
161	{
162	addItem(""); /* invariant: empty command line is the last item */
163
164	setEditable(true);
165	setInsertPolicy(NoInsert);
166	setAutoCompletion(false);
167	setMaxCount(50);
168	const QLineEdit *pEdit = lineEdit();
169	if (pEdit)
170	connect(pEdit, SIGNAL(returnPressed()), this, SLOT(returnPressed()));
171
172	NOREF(pszName);
173	}
174
175
176	VBoxDbgConsoleInput::~VBoxDbgConsoleInput()
177	{
178	Assert(m_hGUIThread == RTThreadNativeSelf());
179	}
180
181
182	void
183	VBoxDbgConsoleInput::setLineEdit(QLineEdit *pEdit)
184	{
185	Assert(m_hGUIThread == RTThreadNativeSelf());
186	QComboBox::setLineEdit(pEdit);
187	if (lineEdit() == pEdit && pEdit)
188	connect(pEdit, SIGNAL(returnPressed()), this, SLOT(returnPressed()));
189	}
190
191
192	void
193	VBoxDbgConsoleInput::returnPressed()
194	{
195	Assert(m_hGUIThread == RTThreadNativeSelf());
196
197	QString strCommand = currentText();
198	/* TODO: trim whitespace? */
199	if (strCommand.isEmpty())
200	return;
201
202	/* deal with the current command. */
203	emit commandSubmitted(strCommand);
204
205
206	/*
207	* Add current command to history.
208	*/
209	bool fNeedsAppending = true;
210
211	/* invariant: empty line at the end */
212	int iLastItem = count() - 1;
213	Assert(itemText(iLastItem).isEmpty());
214
215	/* have previous command? check duplicate. */
216	if (iLastItem > 0)
217	{
218	const QString strPrevCommand(itemText(iLastItem - 1));
219	if (strCommand == strPrevCommand)
220	fNeedsAppending = false;
221	}
222
223	if (fNeedsAppending)
224	{
225	/* history full? drop the oldest command. */
226	if (count() == maxCount())
227	{
228	removeItem(0);
229	--iLastItem;
230	}
231
232	/* insert before the empty line. */
233	insertItem(iLastItem, strCommand);
234	}
235
236	/* invariant: empty line at the end */
237	int iNewLastItem = count() - 1;
238	Assert(itemText(iNewLastItem).isEmpty());
239
240	/* select empty line to present "new" command line to the user */
241	setCurrentIndex(iNewLastItem);
242	}
243
244
245
246
247
248
249	/*
250	*
251	* V B o x D b g C o n s o l e
252	* V B o x D b g C o n s o l e
253	* V B o x D b g C o n s o l e
254	*
255	*
256	*/
257
258
259	VBoxDbgConsole::VBoxDbgConsole(VBoxDbgGui a_pDbgGui, QWidget a_pParent/* = NULL*/)
260	: VBoxDbgBaseWindow(a_pDbgGui, a_pParent), m_pOutput(NULL), m_pInput(NULL), m_fInputRestoreFocus(false),
261	m_pszInputBuf(NULL), m_cbInputBuf(0), m_cbInputBufAlloc(0),
262	m_pszOutputBuf(NULL), m_cbOutputBuf(0), m_cbOutputBufAlloc(0),
263	m_pTimer(NULL), m_fUpdatePending(false), m_Thread(NIL_RTTHREAD), m_EventSem(NIL_RTSEMEVENT),
264	m_fTerminate(false), m_fThreadTerminated(false)
265	{
266	setWindowTitle("VBoxDbg - Console");
267
268	/*
269	* Create the output text box.
270	*/
271	m_pOutput = new VBoxDbgConsoleOutput(this);
272
273	/* try figure a suitable size */
274	QLabel *pLabel = new QLabel( "11111111111111111111111111111111111111111111111111111111111111111111111111111112222222222", this);
275	pLabel->setFont(m_pOutput->font());
276	QSize Size = pLabel->sizeHint();
277	delete pLabel;
278	Size.setWidth((int)(Size.width() * 1.10));
279	Size.setHeight(Size.width() / 2);
280	resize(Size);
281
282	/*
283	* Create the input combo box (with a label).
284	*/
285	QHBoxLayout *pLayout = new QHBoxLayout();
286	//pLayout->setSizeConstraint(QLayout::SetMaximumSize);
287
288	pLabel = new QLabel(" Command ");
289	pLayout->addWidget(pLabel);
290	pLabel->setMaximumSize(pLabel->sizeHint());
291	pLabel->setAlignment(Qt::AlignCenter);
292
293	m_pInput = new VBoxDbgConsoleInput(NULL);
294	pLayout->addWidget(m_pInput);
295	m_pInput->setDuplicatesEnabled(false);
296	connect(m_pInput, SIGNAL(commandSubmitted(const QString &)), this, SLOT(commandSubmitted(const QString &)));
297
298	# if 0//def Q_WS_MAC
299	pLabel = new QLabel(" ");
300	pLayout->addWidget(pLabel);
301	pLabel->setMaximumSize(20, m_pInput->sizeHint().height() + 6);
302	pLabel->setMinimumSize(20, m_pInput->sizeHint().height() + 6);
303	# endif
304
305	QWidget *pHBox = new QWidget(this);
306	pHBox->setLayout(pLayout);
307
308	m_pInput->setEnabled(false); /* (we'll get a ready notification) */
309
310
311	/*
312	* Vertical layout box on the whole widget.
313	*/
314	QVBoxLayout *pVLayout = new QVBoxLayout();
315	pVLayout->setContentsMargins(0, 0, 0, 0);
316	pVLayout->setSpacing(5);
317	pVLayout->addWidget(m_pOutput);
318	pVLayout->addWidget(pHBox);
319	setLayout(pVLayout);
320
321	/*
322	* The tab order is from input to output, not the other way around as it is by default.
323	*/
324	setTabOrder(m_pInput, m_pOutput);
325	m_fInputRestoreFocus = true; /* hack */
326
327	/*
328	* Setup the timer.
329	*/
330	m_pTimer = new QTimer(this);
331	connect(m_pTimer, SIGNAL(timeout()), SLOT(updateOutput()));
332
333	/*
334	* Init the backend structure.
335	*/
336	m_Back.Core.pfnInput = backInput;
337	m_Back.Core.pfnRead = backRead;
338	m_Back.Core.pfnWrite = backWrite;
339	m_Back.Core.pfnSetReady = backSetReady;
340	m_Back.pSelf = this;
341
342	/*
343	* Create the critical section, the event semaphore and the debug console thread.
344	*/
345	int rc = RTCritSectInit(&m_Lock);
346	AssertRC(rc);
347
348	rc = RTSemEventCreate(&m_EventSem);
349	AssertRC(rc);
350
351	rc = RTThreadCreate(&m_Thread, backThread, this, 0, RTTHREADTYPE_DEBUGGER, RTTHREADFLAGS_WAITABLE, "VBoxDbgC");
352	AssertRC(rc);
353	if (RT_FAILURE(rc))
354	m_Thread = NIL_RTTHREAD;
355
356	/*
357	* Shortcuts.
358	*/
359	m_pFocusToInput = new QAction("", this);
360	m_pFocusToInput->setShortcut(QKeySequence("Ctrl+L"));
361	addAction(m_pFocusToInput);
362	connect(m_pFocusToInput, SIGNAL(triggered(bool)), this, SLOT(actFocusToInput()));
363
364	m_pFocusToOutput = new QAction("", this);
365	m_pFocusToOutput->setShortcut(QKeySequence("Ctrl+O"));
366	addAction(m_pFocusToOutput);
367	connect(m_pFocusToOutput, SIGNAL(triggered(bool)), this, SLOT(actFocusToOutput()));
368	}
369
370
371	VBoxDbgConsole::~VBoxDbgConsole()
372	{
373	Assert(isGUIThread());
374
375	/*
376	* Wait for the thread.
377	*/
378	ASMAtomicWriteBool(&m_fTerminate, true);
379	RTSemEventSignal(m_EventSem);
380	if (m_Thread != NIL_RTTHREAD)
381	{
382	int rc = RTThreadWait(m_Thread, 15000, NULL);
383	AssertRC(rc);
384	m_Thread = NIL_RTTHREAD;
385	}
386
387	/*
388	* Free resources.
389	*/
390	delete m_pTimer;
391	m_pTimer = NULL;
392	RTCritSectDelete(&m_Lock);
393	RTSemEventDestroy(m_EventSem);
394	m_EventSem = 0;
395	m_pOutput = NULL;
396	m_pInput = NULL;
397	if (m_pszInputBuf)
398	{
399	RTMemFree(m_pszInputBuf);
400	m_pszInputBuf = NULL;
401	}
402	m_cbInputBuf = 0;
403	m_cbInputBufAlloc = 0;
404
405	delete m_pFocusToInput;
406	m_pFocusToInput = NULL;
407	delete m_pFocusToOutput;
408	m_pFocusToOutput = NULL;
409	}
410
411
412	void
413	VBoxDbgConsole::commandSubmitted(const QString &rCommand)
414	{
415	Assert(isGUIThread());
416
417	lock();
418	RTSemEventSignal(m_EventSem);
419
420	QByteArray Utf8Array = rCommand.toUtf8();
421	const char *psz = Utf8Array.constData();
422	size_t cb = strlen(psz);
423
424	/*
425	* Make sure we've got space for the input.
426	*/
427	if (cb + m_cbInputBuf >= m_cbInputBufAlloc)
428	{
429	size_t cbNew = RT_ALIGN_Z(cb + m_cbInputBufAlloc + 1, 128);
430	void *pv = RTMemRealloc(m_pszInputBuf, cbNew);
431	if (!pv)
432	{
433	unlock();
434	return;
435	}
436	m_pszInputBuf = (char *)pv;
437	m_cbInputBufAlloc = cbNew;
438	}
439
440	/*
441	* Add the input and output it.
442	*/
443	memcpy(m_pszInputBuf + m_cbInputBuf, psz, cb);
444	m_cbInputBuf += cb;
445	m_pszInputBuf[m_cbInputBuf++] = '\n';
446
447	m_pOutput->appendText(rCommand + "\n", true /fClearSelection/);
448	m_pOutput->ensureCursorVisible();
449
450	m_fInputRestoreFocus = m_pInput->hasFocus(); /* dirty focus hack */
451	m_pInput->setEnabled(false);
452
453	Log(("VBoxDbgConsole::commandSubmitted: %s (input-enabled=%RTbool)\n", psz, m_pInput->isEnabled()));
454	unlock();
455	}
456
457
458	void
459	VBoxDbgConsole::updateOutput()
460	{
461	Assert(isGUIThread());
462
463	lock();
464	m_fUpdatePending = false;
465	if (m_cbOutputBuf)
466	{
467	m_pOutput->appendText(QString::fromUtf8((const char )m_pszOutputBuf, (int)m_cbOutputBuf), false /fClearSelection*/);
468	m_cbOutputBuf = 0;
469	}
470	unlock();
471	}
472
473
474	/**
475	* Lock the object.
476	*/
477	void
478	VBoxDbgConsole::lock()
479	{
480	RTCritSectEnter(&m_Lock);
481	}
482
483
484	/**
485	* Unlocks the object.
486	*/
487	void
488	VBoxDbgConsole::unlock()
489	{
490	RTCritSectLeave(&m_Lock);
491	}
492
493
494
495	/**
496	* Checks if there is input.
497	*
498	* @returns true if there is input ready.
499	* @returns false if there not input ready.
500	* @param pBack Pointer to VBoxDbgConsole::m_Back.
501	* @param cMillies Number of milliseconds to wait on input data.
502	*/
503	/static/ DECLCALLBACK(bool)
504	VBoxDbgConsole::backInput(PDBGCBACK pBack, uint32_t cMillies)
505	{
506	VBoxDbgConsole *pThis = VBOXDBGCONSOLE_FROM_DBGCBACK(pBack);
507	pThis->lock();
508
509	bool fRc = true;
510	if (!pThis->m_cbInputBuf)
511	{
512	/*
513	* Wait outside the lock for the requested time, then check again.
514	*/
515	pThis->unlock();
516	RTSemEventWait(pThis->m_EventSem, cMillies);
517	pThis->lock();
518	fRc = pThis->m_cbInputBuf
519	\|\| ASMAtomicUoReadBool(&pThis->m_fTerminate);
520	}
521
522	pThis->unlock();
523	return fRc;
524	}
525
526
527	/**
528	* Read input.
529	*
530	* @returns VBox status code.
531	* @param pBack Pointer to VBoxDbgConsole::m_Back.
532	* @param pvBuf Where to put the bytes we read.
533	* @param cbBuf Maximum nymber of bytes to read.
534	* @param pcbRead Where to store the number of bytes actually read.
535	* If NULL the entire buffer must be filled for a
536	* successful return.
537	*/
538	/static/ DECLCALLBACK(int)
539	VBoxDbgConsole::backRead(PDBGCBACK pBack, void pvBuf, size_t cbBuf, size_t pcbRead)
540	{
541	VBoxDbgConsole *pThis = VBOXDBGCONSOLE_FROM_DBGCBACK(pBack);
542	Assert(pcbRead); /** @todo implement this bit */
543	if (pcbRead)
544	*pcbRead = 0;
545
546	pThis->lock();
547	int rc = VINF_SUCCESS;
548	if (!ASMAtomicUoReadBool(&pThis->m_fTerminate))
549	{
550	if (pThis->m_cbInputBuf)
551	{
552	const char *psz = pThis->m_pszInputBuf;
553	size_t cbRead = RT_MIN(pThis->m_cbInputBuf, cbBuf);
554	memcpy(pvBuf, psz, cbRead);
555	psz += cbRead;
556	pThis->m_cbInputBuf -= cbRead;
557	if (*psz)
558	memmove(pThis->m_pszInputBuf, psz, pThis->m_cbInputBuf);
559	pThis->m_pszInputBuf[pThis->m_cbInputBuf] = '\0';
560	*pcbRead = cbRead;
561	}
562	}
563	else
564	rc = VERR_GENERAL_FAILURE;
565	pThis->unlock();
566	return rc;
567	}
568
569
570	/**
571	* Write (output).
572	*
573	* @returns VBox status code.
574	* @param pBack Pointer to VBoxDbgConsole::m_Back.
575	* @param pvBuf What to write.
576	* @param cbBuf Number of bytes to write.
577	* @param pcbWritten Where to store the number of bytes actually written.
578	* If NULL the entire buffer must be successfully written.
579	*/
580	/static/ DECLCALLBACK(int)
581	VBoxDbgConsole::backWrite(PDBGCBACK pBack, const void pvBuf, size_t cbBuf, size_t pcbWritten)
582	{
583	VBoxDbgConsole *pThis = VBOXDBGCONSOLE_FROM_DBGCBACK(pBack);
584	int rc = VINF_SUCCESS;
585
586	pThis->lock();
587	if (cbBuf + pThis->m_cbOutputBuf >= pThis->m_cbOutputBufAlloc)
588	{
589	size_t cbNew = RT_ALIGN_Z(cbBuf + pThis->m_cbOutputBufAlloc + 1, 1024);
590	void *pv = RTMemRealloc(pThis->m_pszOutputBuf, cbNew);
591	if (!pv)
592	{
593	pThis->unlock();
594	if (pcbWritten)
595	*pcbWritten = 0;
596	return VERR_NO_MEMORY;
597	}
598	pThis->m_pszOutputBuf = (char *)pv;
599	pThis->m_cbOutputBufAlloc = cbNew;
600	}
601
602	/*
603	* Add the output.
604	*/
605	memcpy(pThis->m_pszOutputBuf + pThis->m_cbOutputBuf, pvBuf, cbBuf);
606	pThis->m_cbOutputBuf += cbBuf;
607	pThis->m_pszOutputBuf[pThis->m_cbOutputBuf] = '\0';
608	if (pcbWritten)
609	*pcbWritten = cbBuf;
610
611	if (ASMAtomicUoReadBool(&pThis->m_fTerminate))
612	rc = VERR_GENERAL_FAILURE;
613
614	/*
615	* Tell the GUI thread to draw this text.
616	* We cannot do it from here without frequent crashes.
617	*/
618	if (!pThis->m_fUpdatePending)
619	QApplication::postEvent(pThis, new VBoxDbgConsoleEvent(VBoxDbgConsoleEvent::kUpdate));
620
621	pThis->unlock();
622
623	return rc;
624	}
625
626
627	/static/ DECLCALLBACK(void)
628	VBoxDbgConsole::backSetReady(PDBGCBACK pBack, bool fReady)
629	{
630	VBoxDbgConsole *pThis = VBOXDBGCONSOLE_FROM_DBGCBACK(pBack);
631	if (fReady)
632	QApplication::postEvent(pThis, new VBoxDbgConsoleEvent(VBoxDbgConsoleEvent::kInputEnable));
633	}
634
635
636	/**
637	* The Debugger Console Thread
638	*
639	* @returns VBox status code (ignored).
640	* @param Thread The thread handle.
641	* @param pvUser Pointer to the VBoxDbgConsole object.s
642	*/
643	/static/ DECLCALLBACK(int)
644	VBoxDbgConsole::backThread(RTTHREAD Thread, void *pvUser)
645	{
646	VBoxDbgConsole pThis = (VBoxDbgConsole )pvUser;
647	LogFlow(("backThread: Thread=%p pvUser=%p\n", (void *)Thread, pvUser));
648
649	NOREF(Thread);
650
651	/*
652	* Create and execute the console.
653	*/
654	int rc = pThis->dbgcCreate(&pThis->m_Back.Core, 0);
655
656	ASMAtomicUoWriteBool(&pThis->m_fThreadTerminated, true);
657	if (!ASMAtomicUoReadBool(&pThis->m_fTerminate))
658	QApplication::postEvent(pThis, new VBoxDbgConsoleEvent(rc == VINF_SUCCESS
659	? VBoxDbgConsoleEvent::kTerminatedUser
660	: VBoxDbgConsoleEvent::kTerminatedOther));
661	LogFlow(("backThread: returns %Rrc (m_fTerminate=%RTbool)\n", rc, ASMAtomicUoReadBool(&pThis->m_fTerminate)));
662	return rc;
663	}
664
665
666	bool
667	VBoxDbgConsole::event(QEvent *pGenEvent)
668	{
669	Assert(isGUIThread());
670	if (pGenEvent->type() == (QEvent::Type)VBoxDbgConsoleEvent::kEventNumber)
671	{
672	VBoxDbgConsoleEvent pEvent = (VBoxDbgConsoleEvent )pGenEvent;
673
674	switch (pEvent->command())
675	{
676	/* make update pending. */
677	case VBoxDbgConsoleEvent::kUpdate:
678	lock();
679	if (!m_fUpdatePending)
680	{
681	m_fUpdatePending = true;
682	m_pTimer->setSingleShot(true);
683	m_pTimer->start(10);
684	}
685	unlock();
686	break;
687
688	/* Re-enable the input field and restore focus. */
689	case VBoxDbgConsoleEvent::kInputEnable:
690	Log(("VBoxDbgConsole: kInputEnable (input-enabled=%RTbool)\n", m_pInput->isEnabled()));
691	m_pInput->setEnabled(true);
692	if ( m_fInputRestoreFocus
693	&& !m_pInput->hasFocus())
694	m_pInput->setFocus(); /* this is a hack. */
695	m_fInputRestoreFocus = false;
696	break;
697
698	/* The thread terminated by user command (exit, quit, bye). */
699	case VBoxDbgConsoleEvent::kTerminatedUser:
700	Log(("VBoxDbgConsole: kTerminatedUser (input-enabled=%RTbool)\n", m_pInput->isEnabled()));
701	m_pInput->setEnabled(false);
702	close();
703	break;
704
705	/* The thread terminated for some unknown reason., disable input */
706	case VBoxDbgConsoleEvent::kTerminatedOther:
707	Log(("VBoxDbgConsole: kTerminatedOther (input-enabled=%RTbool)\n", m_pInput->isEnabled()));
708	m_pInput->setEnabled(false);
709	break;
710
711	/* paranoia */
712	default:
713	AssertMsgFailed(("command=%d\n", pEvent->command()));
714	break;
715	}
716	return true;
717	}
718
719	return VBoxDbgBaseWindow::event(pGenEvent);
720	}
721
722
723	void
724	VBoxDbgConsole::closeEvent(QCloseEvent *a_pCloseEvt)
725	{
726	if (m_fThreadTerminated)
727	{
728	a_pCloseEvt->accept();
729	delete this;
730	}
731	}
732
733
734	void
735	VBoxDbgConsole::actFocusToInput()
736	{
737	if (!m_pInput->hasFocus())
738	m_pInput->setFocus(Qt::ShortcutFocusReason);
739	}
740
741
742	void
743	VBoxDbgConsole::actFocusToOutput()
744	{
745	if (!m_pOutput->hasFocus())
746	m_pOutput->setFocus(Qt::ShortcutFocusReason);
747	}
748

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Debugger/VBoxDbgConsole.cpp@ 48935

Download in other formats: