VBoxDbgConsole.cpp@ 102839

Last change on this file since 102839 was 101107, checked in by vboxsync, 15 months ago
VBoxDbg: Rewrote the automatic window positioning to make it more flexible and to try keep the console window wide enough for at least 80 columns of text.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 29.4 KB

Line
1	/* $Id: VBoxDbgConsole.cpp 101107 2023-09-13 14:01:58Z vboxsync $ */
2	/** @file
3	* VBox Debugger GUI - Console.
4	*/
5
6	/*
7	* Copyright (C) 2006-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#define LOG_GROUP LOG_GROUP_DBGG
33	#include "VBoxDbgConsole.h"
34	#include "VBoxDbgGui.h"
35
36	#include <QLabel>
37	#include <QApplication>
38	#include <QFont>
39	#include <QLineEdit>
40	#include <QHBoxLayout>
41	#include <QAction>
42	#include <QContextMenuEvent>
43	#include <QMenu>
44	#include <QScrollBar>
45
46	#include <VBox/dbg.h>
47	#include <VBox/vmm/cfgm.h>
48	#include <iprt/errcore.h>
49
50	#include <iprt/thread.h>
51	#include <iprt/tcp.h>
52	#include <VBox/log.h>
53	#include <iprt/assert.h>
54	#include <iprt/asm.h>
55	#include <iprt/alloc.h>
56	#include <iprt/string.h>
57
58	#include <VBox/com/string.h>
59
60
61
62	/*
63	*
64	* V B o x D b g C o n s o l e O u t p u t
65	* V B o x D b g C o n s o l e O u t p u t
66	* V B o x D b g C o n s o l e O u t p u t
67	*
68	*
69	*/
70
71	/static/ const uint32_t VBoxDbgConsoleOutput::s_uMinFontSize = 6;
72
73
74	VBoxDbgConsoleOutput::VBoxDbgConsoleOutput(QWidget pParent/ = NULL/, IVirtualBox a_pVirtualBox /* = NULL */,
75	const char pszName/ = NULL*/)
76	: QTextEdit(pParent), m_uCurLine(0), m_uCurPos(0), m_hGUIThread(RTThreadNativeSelf()), m_pVirtualBox(a_pVirtualBox)
77	{
78	setReadOnly(true);
79	setUndoRedoEnabled(false);
80	setOverwriteMode(false);
81	setPlainText("");
82	setTextInteractionFlags(Qt::TextBrowserInteraction);
83	setAutoFormatting(QTextEdit::AutoAll);
84	setTabChangesFocus(true);
85	setAcceptRichText(false);
86
87	/*
88	* Create actions for color-scheme menu items.
89	*/
90	m_pGreenOnBlackAction = new QAction(tr("Green On Black"), this);
91	m_pGreenOnBlackAction->setCheckable(true);
92	m_pGreenOnBlackAction->setShortcut(QString("Ctrl+1"));
93	m_pGreenOnBlackAction->setData((int)kGreenOnBlack);
94	connect(m_pGreenOnBlackAction, SIGNAL(triggered()), this, SLOT(sltSelectColorScheme()));
95
96	m_pBlackOnWhiteAction = new QAction(tr("Black On White"), this);
97	m_pBlackOnWhiteAction->setCheckable(true);
98	m_pBlackOnWhiteAction->setShortcut(QString("Ctrl+2"));
99	m_pBlackOnWhiteAction->setData((int)kBlackOnWhite);
100	connect(m_pBlackOnWhiteAction, SIGNAL(triggered()), this, SLOT(sltSelectColorScheme()));
101
102	/* Create action group for grouping of exclusive color-scheme menu items. */
103	QActionGroup *pActionColorGroup = new QActionGroup(this);
104	pActionColorGroup->addAction(m_pGreenOnBlackAction);
105	pActionColorGroup->addAction(m_pBlackOnWhiteAction);
106	pActionColorGroup->setExclusive(true);
107
108	/*
109	* Create actions for font menu items.
110	*/
111	m_pCourierFontAction = new QAction(tr("Courier"), this);
112	m_pCourierFontAction->setCheckable(true);
113	m_pCourierFontAction->setShortcut(QString("Ctrl+D"));
114	m_pCourierFontAction->setData((int)kFontType_Courier);
115	connect(m_pCourierFontAction, SIGNAL(triggered()), this, SLOT(sltSelectFontType()));
116
117	m_pMonospaceFontAction = new QAction(tr("Monospace"), this);
118	m_pMonospaceFontAction->setCheckable(true);
119	m_pMonospaceFontAction->setShortcut(QString("Ctrl+M"));
120	m_pMonospaceFontAction->setData((int)kFontType_Monospace);
121	connect(m_pMonospaceFontAction, SIGNAL(triggered()), this, SLOT(sltSelectFontType()));
122
123	/* Create action group for grouping of exclusive font menu items. */
124	QActionGroup *pActionFontGroup = new QActionGroup(this);
125	pActionFontGroup->addAction(m_pCourierFontAction);
126	pActionFontGroup->addAction(m_pMonospaceFontAction);
127	pActionFontGroup->setExclusive(true);
128
129	/*
130	* Create actions for font size menu.
131	*/
132	uint32_t const uDefaultFontSize = font().pointSize();
133	m_pActionFontSizeGroup = new QActionGroup(this);
134	for (uint32_t i = 0; i < RT_ELEMENTS(m_apFontSizeActions); i++)
135	{
136	char szTitle[32];
137	RTStrPrintf(szTitle, sizeof(szTitle), s_uMinFontSize + i != uDefaultFontSize ? "%upt" : "%upt (default)",
138	s_uMinFontSize + i);
139	m_apFontSizeActions[i] = new QAction(tr(szTitle), this);
140	m_apFontSizeActions[i]->setCheckable(true);
141	m_apFontSizeActions[i]->setData(i + s_uMinFontSize);
142	connect(m_apFontSizeActions[i], SIGNAL(triggered()), this, SLOT(sltSelectFontSize()));
143	m_pActionFontSizeGroup->addAction(m_apFontSizeActions[i]);
144	}
145
146	/*
147	* Set the defaults (which syncs with the menu item checked state).
148	*/
149	/* color scheme: */
150	com::Bstr bstrColor;
151	HRESULT hrc = m_pVirtualBox ? m_pVirtualBox->GetExtraData(com::Bstr("DbgConsole/ColorScheme").raw(), bstrColor.asOutParam()) : E_FAIL;
152	if ( SUCCEEDED(hrc)
153	&& bstrColor.compareUtf8("blackonwhite", com::Bstr::CaseInsensitive) == 0)
154	setColorScheme(kBlackOnWhite, false /fSaveIt/);
155	else
156	setColorScheme(kGreenOnBlack, false /fSaveIt/);
157
158	/* font: */
159	com::Bstr bstrFont;
160	hrc = m_pVirtualBox ? m_pVirtualBox->GetExtraData(com::Bstr("DbgConsole/Font").raw(), bstrFont.asOutParam()) : E_FAIL;
161	if ( SUCCEEDED(hrc)
162	&& bstrFont.compareUtf8("monospace", com::Bstr::CaseInsensitive) == 0)
163	setFontType(kFontType_Monospace, false /fSaveIt/);
164	else
165	setFontType(kFontType_Courier, false /fSaveIt/);
166
167	/* font size: */
168	com::Bstr bstrFontSize;
169	hrc = m_pVirtualBox ? m_pVirtualBox->GetExtraData(com::Bstr("DbgConsole/FontSize").raw(), bstrFontSize.asOutParam()) : E_FAIL;
170	if (SUCCEEDED(hrc))
171	{
172	com::Utf8Str strFontSize(bstrFontSize);
173	uint32_t uFontSizePrf = strFontSize.strip().toUInt32();
174	if ( uFontSizePrf - s_uMinFontSize < (uint32_t)RT_ELEMENTS(m_apFontSizeActions)
175	&& uFontSizePrf != uDefaultFontSize)
176	setFontSize(uFontSizePrf, false /fSaveIt/);
177	}
178
179	NOREF(pszName);
180	}
181
182
183	VBoxDbgConsoleOutput::~VBoxDbgConsoleOutput()
184	{
185	Assert(m_hGUIThread == RTThreadNativeSelf());
186	if (m_pVirtualBox)
187	{
188	m_pVirtualBox->Release();
189	m_pVirtualBox = NULL;
190	}
191	}
192
193
194	void
195	VBoxDbgConsoleOutput::contextMenuEvent(QContextMenuEvent *pEvent)
196	{
197	/*
198	* Create the context menu and add the menu items.
199	*/
200	QMenu *pMenu = createStandardContextMenu();
201	pMenu->addSeparator();
202
203	QMenu *pColorMenu = pMenu->addMenu(tr("Co&lor Scheme"));
204	pColorMenu->addAction(m_pGreenOnBlackAction);
205	pColorMenu->addAction(m_pBlackOnWhiteAction);
206
207	QMenu *pFontMenu = pMenu->addMenu(tr("&Font Family"));
208	pFontMenu->addAction(m_pCourierFontAction);
209	pFontMenu->addAction(m_pMonospaceFontAction);
210
211	QMenu *pFontSize = pMenu->addMenu(tr("Font &Size"));
212	for (unsigned i = 0; i < RT_ELEMENTS(m_apFontSizeActions); i++)
213	pFontSize->addAction(m_apFontSizeActions[i]);
214
215	pMenu->exec(pEvent->globalPos());
216	delete pMenu;
217	}
218
219
220	void
221	VBoxDbgConsoleOutput::setColorScheme(VBoxDbgConsoleColor enmScheme, bool fSaveIt)
222	{
223	const char *pszSetting;
224	QAction *pAction;
225	switch (enmScheme)
226	{
227	case kGreenOnBlack:
228	setStyleSheet("QTextEdit { background-color: black; color: rgb(0, 224, 0) }");
229	pszSetting = "GreenOnBlack";
230	pAction = m_pGreenOnBlackAction;
231	break;
232	case kBlackOnWhite:
233	setStyleSheet("QTextEdit { background-color: white; color: black }");
234	pszSetting = "BlackOnWhite";
235	pAction = m_pBlackOnWhiteAction;
236	break;
237	default:
238	AssertFailedReturnVoid();
239	}
240
241	m_enmColorScheme = kGreenOnBlack;
242
243	/* When going through a slot, the action is typically checked already by Qt. */
244	if (!pAction->isChecked())
245	pAction->setChecked(true);
246
247	/* Make this setting persistent. */
248	if (m_pVirtualBox && fSaveIt)
249	m_pVirtualBox->SetExtraData(com::Bstr("DbgConsole/ColorScheme").raw(), com::Bstr(pszSetting).raw());
250	}
251
252
253	void
254	VBoxDbgConsoleOutput::setFontType(VBoxDbgConsoleFontType enmFontType, bool fSaveIt)
255	{
256	QFont Font = font();
257	QAction *pAction;
258	const char *pszSetting;
259	switch (enmFontType)
260	{
261	case kFontType_Courier:
262	#ifdef Q_WS_MAC
263	Font = QFont("Monaco", Font.pointSize(), QFont::Normal, FALSE);
264	Font.setStyleStrategy(QFont::NoAntialias);
265	#else
266	Font.setStyleHint(QFont::TypeWriter);
267	Font.setFamily("Courier [Monotype]");
268	#endif
269	pszSetting = "Courier";
270	pAction = m_pCourierFontAction;
271	break;
272
273	case kFontType_Monospace:
274	Font.setStyleHint(QFont::TypeWriter);
275	Font.setStyleStrategy(QFont::PreferAntialias);
276	Font.setFamily("Monospace [Monotype]");
277	pszSetting = "Monospace";
278	pAction = m_pMonospaceFontAction;
279	break;
280
281	default:
282	AssertFailedReturnVoid();
283	}
284
285	setFont(Font);
286
287	/* When going through a slot, the action is typically checked already by Qt. */
288	if (!pAction->isChecked())
289	pAction->setChecked(true);
290
291	/* Make this setting persistent. */
292	if (m_pVirtualBox && fSaveIt)
293	m_pVirtualBox->SetExtraData(com::Bstr("DbgConsole/Font").raw(), com::Bstr(pszSetting).raw());
294	}
295
296
297	void
298	VBoxDbgConsoleOutput::setFontSize(uint32_t uFontSize, bool fSaveIt)
299	{
300	uint32_t idxAction = uFontSize - s_uMinFontSize;
301	if (idxAction < (uint32_t)RT_ELEMENTS(m_apFontSizeActions))
302	{
303	if (!m_apFontSizeActions[idxAction]->isChecked())
304	m_apFontSizeActions[idxAction]->setChecked(true);
305
306	QFont Font = font();
307	Font.setPointSize(uFontSize);
308	setFont(Font);
309
310	/* Make this setting persistent if requested. */
311	if (fSaveIt && m_pVirtualBox)
312	m_pVirtualBox->SetExtraData(com::Bstr("DbgConsole/FontSize").raw(), com::BstrFmt("%u", uFontSize).raw());
313	}
314	}
315
316
317	void
318	VBoxDbgConsoleOutput::sltSelectColorScheme()
319	{
320	QAction pAction = qobject_cast<QAction >(sender());
321	if (pAction)
322	setColorScheme((VBoxDbgConsoleColor)pAction->data().toInt(), true /fSaveIt/);
323	}
324
325
326	void
327	VBoxDbgConsoleOutput::sltSelectFontType()
328	{
329	QAction pAction = qobject_cast<QAction >(sender());
330	if (pAction)
331	setFontType((VBoxDbgConsoleFontType)pAction->data().toInt(), true /fSaveIt/);
332	}
333
334
335	void
336	VBoxDbgConsoleOutput::sltSelectFontSize()
337	{
338	QAction pAction = qobject_cast<QAction >(sender());
339	if (pAction)
340	setFontSize(pAction->data().toUInt(), true /fSaveIt/);
341	}
342
343
344	void
345	VBoxDbgConsoleOutput::appendText(const QString &rStr, bool fClearSelection)
346	{
347	Assert(m_hGUIThread == RTThreadNativeSelf());
348
349	if (rStr.isEmpty() \|\| rStr.isNull() \|\| !rStr.length())
350	return;
351
352	/*
353	* Insert all in one go and make sure it's visible.
354	*
355	* We need to move the cursor and unselect any selected text before
356	* inserting anything, otherwise, text will disappear.
357	*/
358	QTextCursor Cursor = textCursor();
359	if (!fClearSelection && Cursor.hasSelection())
360	{
361	QTextCursor SavedCursor = Cursor;
362	Cursor.clearSelection();
363	Cursor.movePosition(QTextCursor::End);
364
365	Cursor.insertText(rStr);
366
367	setTextCursor(SavedCursor);
368	}
369	else
370	{
371	if (Cursor.hasSelection())
372	Cursor.clearSelection();
373	if (!Cursor.atEnd())
374	Cursor.movePosition(QTextCursor::End);
375
376	Cursor.insertText(rStr);
377
378	setTextCursor(Cursor);
379	ensureCursorVisible();
380	}
381	}
382
383
384
385
386	/*
387	*
388	* V B o x D b g C o n s o l e I n p u t
389	* V B o x D b g C o n s o l e I n p u t
390	* V B o x D b g C o n s o l e I n p u t
391	*
392	*
393	*/
394
395
396	VBoxDbgConsoleInput::VBoxDbgConsoleInput(QWidget pParent/ = NULL/, const char pszName/* = NULL*/)
397	: QComboBox(pParent), m_hGUIThread(RTThreadNativeSelf())
398	{
399	addItem(""); /* invariant: empty command line is the last item */
400
401	setEditable(true);
402	setInsertPolicy(NoInsert);
403	setCompleter(0);
404	setMaxCount(50);
405	const QLineEdit *pEdit = lineEdit();
406	if (pEdit)
407	connect(pEdit, SIGNAL(returnPressed()), this, SLOT(returnPressed()));
408
409	NOREF(pszName);
410	}
411
412
413	VBoxDbgConsoleInput::~VBoxDbgConsoleInput()
414	{
415	Assert(m_hGUIThread == RTThreadNativeSelf());
416	}
417
418
419	void
420	VBoxDbgConsoleInput::setLineEdit(QLineEdit *pEdit)
421	{
422	Assert(m_hGUIThread == RTThreadNativeSelf());
423	QComboBox::setLineEdit(pEdit);
424	if (lineEdit() == pEdit && pEdit)
425	connect(pEdit, SIGNAL(returnPressed()), this, SLOT(returnPressed()));
426	}
427
428
429	void
430	VBoxDbgConsoleInput::returnPressed()
431	{
432	Assert(m_hGUIThread == RTThreadNativeSelf());
433
434	QString strCommand = currentText();
435	/** @todo trim whitespace? */
436	if (strCommand.isEmpty())
437	return;
438
439	/* deal with the current command. */
440	emit commandSubmitted(strCommand);
441
442
443	/*
444	* Add current command to history.
445	*/
446	bool fNeedsAppending = true;
447
448	/* invariant: empty line at the end */
449	int iLastItem = count() - 1;
450	Assert(itemText(iLastItem).isEmpty());
451
452	/* have previous command? check duplicate. */
453	if (iLastItem > 0)
454	{
455	const QString strPrevCommand(itemText(iLastItem - 1));
456	if (strCommand == strPrevCommand)
457	fNeedsAppending = false;
458	}
459
460	if (fNeedsAppending)
461	{
462	/* history full? drop the oldest command. */
463	if (count() == maxCount())
464	{
465	removeItem(0);
466	--iLastItem;
467	}
468
469	/* insert before the empty line. */
470	insertItem(iLastItem, strCommand);
471	}
472
473	/* invariant: empty line at the end */
474	int iNewLastItem = count() - 1;
475	Assert(itemText(iNewLastItem).isEmpty());
476
477	/* select empty line to present "new" command line to the user */
478	setCurrentIndex(iNewLastItem);
479	}
480
481
482
483
484
485
486	/*
487	*
488	* V B o x D b g C o n s o l e
489	* V B o x D b g C o n s o l e
490	* V B o x D b g C o n s o l e
491	*
492	*
493	*/
494
495
496	VBoxDbgConsole::VBoxDbgConsole(VBoxDbgGui a_pDbgGui, QWidget a_pParent/* = NULL/, IVirtualBox a_pVirtualBox/* = NULL */)
497	: VBoxDbgBaseWindow(a_pDbgGui, a_pParent, "Console"), m_pOutput(NULL), m_pInput(NULL), m_fInputRestoreFocus(false),
498	m_pszInputBuf(NULL), m_cbInputBuf(0), m_cbInputBufAlloc(0),
499	m_pszOutputBuf(NULL), m_cbOutputBuf(0), m_cbOutputBufAlloc(0),
500	m_pTimer(NULL), m_fUpdatePending(false), m_Thread(NIL_RTTHREAD), m_EventSem(NIL_RTSEMEVENT),
501	m_fTerminate(false), m_fThreadTerminated(false)
502	{
503	/* Delete dialog on close: */
504	setAttribute(Qt::WA_DeleteOnClose);
505
506	/*
507	* Create the output text box.
508	*/
509	m_pOutput = new VBoxDbgConsoleOutput(this, a_pVirtualBox);
510
511	/* try figure a suitable size and tell the parent class. */
512	QLabel *pLabel = new QLabel("8888888888888888888888888888888888888888888888888888888888888888888888888888888", this);
513	pLabel->setFont(m_pOutput->font());
514	QSize Size = pLabel->sizeHint();
515	delete pLabel;
516	QSize SizeScrollBar(0,0);
517	QScrollBar *pScrollBar = m_pOutput->verticalScrollBar();
518	if (pScrollBar)
519	SizeScrollBar = pScrollBar->sizeHint();
520	vSetMinWidthHint(Size.width() + SizeScrollBar.width() + 1);
521
522	/*
523	* Create the input combo box (with a label).
524	*/
525	QHBoxLayout *pLayout = new QHBoxLayout();
526	//pLayout->setSizeConstraint(QLayout::SetMaximumSize);
527
528	pLabel = new QLabel(" Command ");
529	pLayout->addWidget(pLabel);
530	pLabel->setMaximumSize(pLabel->sizeHint());
531	pLabel->setAlignment(Qt::AlignCenter);
532
533	m_pInput = new VBoxDbgConsoleInput(NULL);
534	pLayout->addWidget(m_pInput);
535	m_pInput->setDuplicatesEnabled(false);
536	connect(m_pInput, SIGNAL(commandSubmitted(const QString &)), this, SLOT(commandSubmitted(const QString &)));
537
538	# if 0//def Q_WS_MAC
539	pLabel = new QLabel(" ");
540	pLayout->addWidget(pLabel);
541	pLabel->setMaximumSize(20, m_pInput->sizeHint().height() + 6);
542	pLabel->setMinimumSize(20, m_pInput->sizeHint().height() + 6);
543	# endif
544
545	QWidget *pHBox = new QWidget(this);
546	pHBox->setLayout(pLayout);
547
548	m_pInput->setEnabled(false); /* (we'll get a ready notification) */
549
550
551	/*
552	* Vertical layout box on the whole widget.
553	*/
554	QVBoxLayout *pVLayout = new QVBoxLayout();
555	pVLayout->setContentsMargins(0, 0, 0, 0);
556	pVLayout->setSpacing(5);
557	pVLayout->addWidget(m_pOutput);
558	pVLayout->addWidget(pHBox);
559	setLayout(pVLayout);
560
561	/*
562	* The tab order is from input to output, not the other way around as it is by default.
563	*/
564	setTabOrder(m_pInput, m_pOutput);
565	m_fInputRestoreFocus = true; /* hack */
566
567	/*
568	* Setup the timer.
569	*/
570	m_pTimer = new QTimer(this);
571	connect(m_pTimer, SIGNAL(timeout()), SLOT(updateOutput()));
572
573	/*
574	* Init the backend structure.
575	*/
576	m_Back.Core.pfnInput = backInput;
577	m_Back.Core.pfnRead = backRead;
578	m_Back.Core.pfnWrite = backWrite;
579	m_Back.Core.pfnSetReady = backSetReady;
580	m_Back.pSelf = this;
581
582	/*
583	* Create the critical section, the event semaphore and the debug console thread.
584	*/
585	int rc = RTCritSectInit(&m_Lock);
586	AssertRC(rc);
587
588	rc = RTSemEventCreate(&m_EventSem);
589	AssertRC(rc);
590
591	rc = RTThreadCreate(&m_Thread, backThread, this, 0, RTTHREADTYPE_DEBUGGER, RTTHREADFLAGS_WAITABLE, "VBoxDbgC");
592	AssertRC(rc);
593	if (RT_FAILURE(rc))
594	m_Thread = NIL_RTTHREAD;
595
596	/*
597	* Shortcuts.
598	*/
599	m_pFocusToInput = new QAction("", this);
600	m_pFocusToInput->setShortcut(QKeySequence("Ctrl+L"));
601	addAction(m_pFocusToInput);
602	connect(m_pFocusToInput, SIGNAL(triggered(bool)), this, SLOT(actFocusToInput()));
603
604	m_pFocusToOutput = new QAction("", this);
605	m_pFocusToOutput->setShortcut(QKeySequence("Ctrl+O"));
606	addAction(m_pFocusToOutput);
607	connect(m_pFocusToOutput, SIGNAL(triggered(bool)), this, SLOT(actFocusToOutput()));
608
609	addAction(m_pOutput->m_pBlackOnWhiteAction);
610	addAction(m_pOutput->m_pGreenOnBlackAction);
611	addAction(m_pOutput->m_pCourierFontAction);
612	addAction(m_pOutput->m_pMonospaceFontAction);
613	}
614
615
616	VBoxDbgConsole::~VBoxDbgConsole()
617	{
618	Assert(isGUIThread());
619
620	/*
621	* Wait for the thread.
622	*/
623	ASMAtomicWriteBool(&m_fTerminate, true);
624	RTSemEventSignal(m_EventSem);
625	if (m_Thread != NIL_RTTHREAD)
626	{
627	int rc = RTThreadWait(m_Thread, 15000, NULL);
628	AssertRC(rc);
629	m_Thread = NIL_RTTHREAD;
630	}
631
632	/*
633	* Free resources.
634	*/
635	delete m_pTimer;
636	m_pTimer = NULL;
637	RTCritSectDelete(&m_Lock);
638	RTSemEventDestroy(m_EventSem);
639	m_EventSem = 0;
640	m_pOutput = NULL;
641	m_pInput = NULL;
642	if (m_pszInputBuf)
643	{
644	RTMemFree(m_pszInputBuf);
645	m_pszInputBuf = NULL;
646	}
647	m_cbInputBuf = 0;
648	m_cbInputBufAlloc = 0;
649
650	delete m_pFocusToInput;
651	m_pFocusToInput = NULL;
652	delete m_pFocusToOutput;
653	m_pFocusToOutput = NULL;
654
655	if (m_pszOutputBuf)
656	{
657	RTMemFree(m_pszOutputBuf);
658	m_pszOutputBuf = NULL;
659	}
660	}
661
662
663	void
664	VBoxDbgConsole::commandSubmitted(const QString &rCommand)
665	{
666	Assert(isGUIThread());
667
668	lock();
669	RTSemEventSignal(m_EventSem);
670
671	QByteArray Utf8Array = rCommand.toUtf8();
672	const char *psz = Utf8Array.constData();
673	size_t cb = strlen(psz);
674
675	/*
676	* Make sure we've got space for the input.
677	*/
678	if (cb + m_cbInputBuf >= m_cbInputBufAlloc)
679	{
680	size_t cbNew = RT_ALIGN_Z(cb + m_cbInputBufAlloc + 1, 128);
681	void *pv = RTMemRealloc(m_pszInputBuf, cbNew);
682	if (!pv)
683	{
684	unlock();
685	return;
686	}
687	m_pszInputBuf = (char *)pv;
688	m_cbInputBufAlloc = cbNew;
689	}
690
691	/*
692	* Add the input and output it.
693	*/
694	memcpy(m_pszInputBuf + m_cbInputBuf, psz, cb);
695	m_cbInputBuf += cb;
696	m_pszInputBuf[m_cbInputBuf++] = '\n';
697
698	m_pOutput->appendText(rCommand + "\n", true /fClearSelection/);
699	m_pOutput->ensureCursorVisible();
700
701	m_fInputRestoreFocus = m_pInput->hasFocus(); /* dirty focus hack */
702	m_pInput->setEnabled(false);
703
704	Log(("VBoxDbgConsole::commandSubmitted: %s (input-enabled=%RTbool)\n", psz, m_pInput->isEnabled()));
705	unlock();
706	}
707
708
709	void
710	VBoxDbgConsole::updateOutput()
711	{
712	Assert(isGUIThread());
713
714	lock();
715	m_fUpdatePending = false;
716	if (m_cbOutputBuf)
717	{
718	m_pOutput->appendText(QString::fromUtf8((const char )m_pszOutputBuf, (int)m_cbOutputBuf), false /fClearSelection*/);
719	m_cbOutputBuf = 0;
720	}
721	unlock();
722	}
723
724
725	/**
726	* Lock the object.
727	*/
728	void
729	VBoxDbgConsole::lock()
730	{
731	RTCritSectEnter(&m_Lock);
732	}
733
734
735	/**
736	* Unlocks the object.
737	*/
738	void
739	VBoxDbgConsole::unlock()
740	{
741	RTCritSectLeave(&m_Lock);
742	}
743
744
745
746	/**
747	* Checks if there is input.
748	*
749	* @returns true if there is input ready.
750	* @returns false if there not input ready.
751	* @param pBack Pointer to VBoxDbgConsole::m_Back.
752	* @param cMillies Number of milliseconds to wait on input data.
753	*/
754	/static/ DECLCALLBACK(bool)
755	VBoxDbgConsole::backInput(PCDBGCIO pBack, uint32_t cMillies)
756	{
757	VBoxDbgConsole *pThis = VBOXDBGCONSOLE_FROM_DBGCIO(pBack);
758	pThis->lock();
759
760	bool fRc = true;
761	if (!pThis->m_cbInputBuf)
762	{
763	/*
764	* Wait outside the lock for the requested time, then check again.
765	*/
766	pThis->unlock();
767	RTSemEventWait(pThis->m_EventSem, cMillies);
768	pThis->lock();
769	fRc = pThis->m_cbInputBuf
770	\|\| ASMAtomicUoReadBool(&pThis->m_fTerminate);
771	}
772
773	pThis->unlock();
774	return fRc;
775	}
776
777
778	/**
779	* Read input.
780	*
781	* @returns VBox status code.
782	* @param pBack Pointer to VBoxDbgConsole::m_Back.
783	* @param pvBuf Where to put the bytes we read.
784	* @param cbBuf Maximum nymber of bytes to read.
785	* @param pcbRead Where to store the number of bytes actually read.
786	* If NULL the entire buffer must be filled for a
787	* successful return.
788	*/
789	/static/ DECLCALLBACK(int)
790	VBoxDbgConsole::backRead(PCDBGCIO pBack, void pvBuf, size_t cbBuf, size_t pcbRead)
791	{
792	VBoxDbgConsole *pThis = VBOXDBGCONSOLE_FROM_DBGCIO(pBack);
793	Assert(pcbRead); /** @todo implement this bit */
794	if (pcbRead)
795	*pcbRead = 0;
796
797	pThis->lock();
798	int rc = VINF_SUCCESS;
799	if (!ASMAtomicUoReadBool(&pThis->m_fTerminate))
800	{
801	if (pThis->m_cbInputBuf)
802	{
803	const char *psz = pThis->m_pszInputBuf;
804	size_t cbRead = RT_MIN(pThis->m_cbInputBuf, cbBuf);
805	memcpy(pvBuf, psz, cbRead);
806	psz += cbRead;
807	pThis->m_cbInputBuf -= cbRead;
808	if (*psz)
809	memmove(pThis->m_pszInputBuf, psz, pThis->m_cbInputBuf);
810	pThis->m_pszInputBuf[pThis->m_cbInputBuf] = '\0';
811	*pcbRead = cbRead;
812	}
813	}
814	else
815	rc = VERR_GENERAL_FAILURE;
816	pThis->unlock();
817	return rc;
818	}
819
820
821	/**
822	* Write (output).
823	*
824	* @returns VBox status code.
825	* @param pBack Pointer to VBoxDbgConsole::m_Back.
826	* @param pvBuf What to write.
827	* @param cbBuf Number of bytes to write.
828	* @param pcbWritten Where to store the number of bytes actually written.
829	* If NULL the entire buffer must be successfully written.
830	*/
831	/static/ DECLCALLBACK(int)
832	VBoxDbgConsole::backWrite(PCDBGCIO pBack, const void pvBuf, size_t cbBuf, size_t pcbWritten)
833	{
834	VBoxDbgConsole *pThis = VBOXDBGCONSOLE_FROM_DBGCIO(pBack);
835	int rc = VINF_SUCCESS;
836
837	pThis->lock();
838	if (cbBuf + pThis->m_cbOutputBuf >= pThis->m_cbOutputBufAlloc)
839	{
840	size_t cbNew = RT_ALIGN_Z(cbBuf + pThis->m_cbOutputBufAlloc + 1, 1024);
841	void *pv = RTMemRealloc(pThis->m_pszOutputBuf, cbNew);
842	if (!pv)
843	{
844	pThis->unlock();
845	if (pcbWritten)
846	*pcbWritten = 0;
847	return VERR_NO_MEMORY;
848	}
849	pThis->m_pszOutputBuf = (char *)pv;
850	pThis->m_cbOutputBufAlloc = cbNew;
851	}
852
853	/*
854	* Add the output.
855	*/
856	memcpy(pThis->m_pszOutputBuf + pThis->m_cbOutputBuf, pvBuf, cbBuf);
857	pThis->m_cbOutputBuf += cbBuf;
858	pThis->m_pszOutputBuf[pThis->m_cbOutputBuf] = '\0';
859	if (pcbWritten)
860	*pcbWritten = cbBuf;
861
862	if (ASMAtomicUoReadBool(&pThis->m_fTerminate))
863	rc = VERR_GENERAL_FAILURE;
864
865	/*
866	* Tell the GUI thread to draw this text.
867	* We cannot do it from here without frequent crashes.
868	*/
869	if (!pThis->m_fUpdatePending)
870	QApplication::postEvent(pThis, new VBoxDbgConsoleEvent(VBoxDbgConsoleEvent::kUpdate));
871
872	pThis->unlock();
873
874	return rc;
875	}
876
877
878	/static/ DECLCALLBACK(void)
879	VBoxDbgConsole::backSetReady(PCDBGCIO pBack, bool fReady)
880	{
881	VBoxDbgConsole *pThis = VBOXDBGCONSOLE_FROM_DBGCIO(pBack);
882	if (fReady)
883	QApplication::postEvent(pThis, new VBoxDbgConsoleEvent(VBoxDbgConsoleEvent::kInputEnable));
884	}
885
886
887	/static/ DECLCALLBACK(int)
888	VBoxDbgConsole::backThread(RTTHREAD Thread, void *pvUser)
889	{
890	VBoxDbgConsole pThis = (VBoxDbgConsole )pvUser;
891	LogFlow(("backThread: Thread=%p pvUser=%p\n", (void *)Thread, pvUser));
892
893	NOREF(Thread);
894
895	/*
896	* Create and execute the console.
897	*/
898	int rc = pThis->dbgcCreate(&pThis->m_Back.Core, 0);
899
900	ASMAtomicUoWriteBool(&pThis->m_fThreadTerminated, true);
901	if (!ASMAtomicUoReadBool(&pThis->m_fTerminate))
902	QApplication::postEvent(pThis, new VBoxDbgConsoleEvent(rc == VINF_SUCCESS
903	? VBoxDbgConsoleEvent::kTerminatedUser
904	: VBoxDbgConsoleEvent::kTerminatedOther));
905	LogFlow(("backThread: returns %Rrc (m_fTerminate=%RTbool)\n", rc, ASMAtomicUoReadBool(&pThis->m_fTerminate)));
906	return rc;
907	}
908
909
910	bool
911	VBoxDbgConsole::event(QEvent *pGenEvent)
912	{
913	Assert(isGUIThread());
914	if (pGenEvent->type() == (QEvent::Type)VBoxDbgConsoleEvent::kEventNumber)
915	{
916	VBoxDbgConsoleEvent pEvent = (VBoxDbgConsoleEvent )pGenEvent;
917
918	switch (pEvent->command())
919	{
920	/* make update pending. */
921	case VBoxDbgConsoleEvent::kUpdate:
922	lock();
923	if (!m_fUpdatePending)
924	{
925	m_fUpdatePending = true;
926	m_pTimer->setSingleShot(true);
927	m_pTimer->start(10);
928	}
929	unlock();
930	break;
931
932	/* Re-enable the input field and restore focus. */
933	case VBoxDbgConsoleEvent::kInputEnable:
934	Log(("VBoxDbgConsole: kInputEnable (input-enabled=%RTbool)\n", m_pInput->isEnabled()));
935	m_pInput->setEnabled(true);
936	if ( m_fInputRestoreFocus
937	&& !m_pInput->hasFocus())
938	m_pInput->setFocus(); /* this is a hack. */
939	m_fInputRestoreFocus = false;
940	break;
941
942	/* The thread terminated by user command (exit, quit, bye). */
943	case VBoxDbgConsoleEvent::kTerminatedUser:
944	Log(("VBoxDbgConsole: kTerminatedUser (input-enabled=%RTbool)\n", m_pInput->isEnabled()));
945	m_pInput->setEnabled(false);
946	close();
947	break;
948
949	/* The thread terminated for some unknown reason., disable input */
950	case VBoxDbgConsoleEvent::kTerminatedOther:
951	Log(("VBoxDbgConsole: kTerminatedOther (input-enabled=%RTbool)\n", m_pInput->isEnabled()));
952	m_pInput->setEnabled(false);
953	break;
954
955	/* paranoia */
956	default:
957	AssertMsgFailed(("command=%d\n", pEvent->command()));
958	break;
959	}
960	return true;
961	}
962
963	return VBoxDbgBaseWindow::event(pGenEvent);
964	}
965
966
967	void
968	VBoxDbgConsole::keyReleaseEvent(QKeyEvent *pEvent)
969	{
970	//RTAssertMsg2("VBoxDbgConsole::keyReleaseEvent: %d (%#x); mod=%#x\n", pEvent->key(), pEvent->key(), pEvent->modifiers());
971	switch (pEvent->key())
972	{
973	case Qt::Key_F5:
974	if (pEvent->modifiers() == 0)
975	commandSubmitted("g");
976	break;
977
978	case Qt::Key_F8:
979	if (pEvent->modifiers() == 0)
980	commandSubmitted("t");
981	break;
982
983	case Qt::Key_F10:
984	if (pEvent->modifiers() == 0)
985	commandSubmitted("p");
986	break;
987
988	case Qt::Key_F11:
989	if (pEvent->modifiers() == 0)
990	commandSubmitted("t");
991	else if (pEvent->modifiers() == Qt::ShiftModifier)
992	commandSubmitted("gu");
993	break;
994
995	case Qt::Key_Cancel: /* == break */
996	if (pEvent->modifiers() == Qt::ControlModifier)
997	commandSubmitted("stop");
998	break;
999	case Qt::Key_Delete:
1000	if (pEvent->modifiers() == Qt::AltModifier)
1001	commandSubmitted("stop");
1002	break;
1003	}
1004	}
1005
1006
1007	void
1008	VBoxDbgConsole::closeEvent(QCloseEvent *a_pCloseEvt)
1009	{
1010	if (m_fThreadTerminated)
1011	a_pCloseEvt->accept();
1012	}
1013
1014
1015	void
1016	VBoxDbgConsole::actFocusToInput()
1017	{
1018	if (!m_pInput->hasFocus())
1019	m_pInput->setFocus(Qt::ShortcutFocusReason);
1020	}
1021
1022
1023	void
1024	VBoxDbgConsole::actFocusToOutput()
1025	{
1026	if (!m_pOutput->hasFocus())
1027	m_pOutput->setFocus(Qt::ShortcutFocusReason);
1028	}
1029

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

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

Download in other formats: