VBoxDbgConsole.cpp@ 12478

Last change on this file since 12478 was 12180, checked in by vboxsync, 16 years ago
Debugger GUI: Qt4 port in progress.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 18.2 KB

Line
1	/* $Id: VBoxDbgConsole.cpp 12180 2008-09-06 18:31:18Z vboxsync $ */
2	/** @file
3	* VBox Debugger GUI - Console.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
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	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22
23	/*******************************************************************************
24	* Header Files *
25	*******************************************************************************/
26	#include "VBoxDbgConsole.h"
27
28	#ifdef VBOXDBG_USE_QT4
29	# include <QLabel>
30	# include <QApplication>
31	# include <QFont>
32	# include <QLineEdit>
33	# include <QHBoxLayout>
34	#else
35	# include <qlabel.h>
36	# include <qapplication.h>
37	# include <qfont.h>
38	# include <qtextview.h>
39	# include <qlineedit.h>
40	#endif
41
42	#include <VBox/dbg.h>
43	#include <VBox/cfgm.h>
44	#include <VBox/err.h>
45
46	#include <iprt/thread.h>
47	#include <iprt/tcp.h>
48	#include <VBox/log.h>
49	#include <iprt/assert.h>
50	#include <iprt/asm.h>
51	#include <iprt/alloc.h>
52	#include <iprt/string.h>
53
54
55
56
57	/*
58	*
59	* V B o x D b g C o n s o l e O u t p u t
60	* V B o x D b g C o n s o l e O u t p u t
61	* V B o x D b g C o n s o l e O u t p u t
62	*
63	*
64	*/
65
66
67	VBoxDbgConsoleOutput::VBoxDbgConsoleOutput(QWidget pParent/ = NULL/, const char pszName/* = NULL*/)
68	#ifdef VBOXDBG_USE_QT4
69	: QTextEdit(pParent),
70	#else
71	: QTextEdit(pParent, pszName),
72	#endif
73	m_uCurLine(0), m_uCurPos(0), m_hGUIThread(RTThreadNativeSelf())
74	{
75	setReadOnly(true);
76	setUndoRedoEnabled(false);
77	setOverwriteMode(true);
78	#ifdef VBOXDBG_USE_QT4
79	setPlainText("");
80	#else
81	setTextFormat(PlainText); /* minimal HTML: setTextFormat(LogText); */
82	#endif
83
84	#ifdef Q_WS_MAC
85	QFont Font("Monaco", 10, QFont::Normal, FALSE);
86	Font.setStyleStrategy(QFont::NoAntialias);
87	#else
88	QFont Font = font();
89	Font.setStyleHint(QFont::TypeWriter);
90	Font.setFamily("Courier [Monotype]");
91	#endif
92	setFont(Font);
93
94	/* green on black */
95	#ifdef VBOXDBG_USE_QT4
96	QPalette Pal(palette());
97	Pal.setColor(QPalette::Active, QPalette::Base, QColor(Qt::black));
98	setPalette(Pal);
99	setTextColor(QColor(qRgb(0, 0xe0, 0)));
100	#else
101	setPaper(QBrush(Qt::black));
102	setColor(QColor(qRgb(0, 0xe0, 0)));
103	#endif
104	NOREF(pszName);
105	}
106
107	VBoxDbgConsoleOutput::~VBoxDbgConsoleOutput()
108	{
109	Assert(m_hGUIThread == RTThreadNativeSelf());
110	}
111
112	void VBoxDbgConsoleOutput::appendText(const QString &rStr)
113	{
114	Assert(m_hGUIThread == RTThreadNativeSelf());
115
116	if (rStr.isEmpty() \|\| rStr.isNull() \|\| !rStr.length())
117	return;
118
119	/*
120	* Insert line by line.
121	*/
122	unsigned cch = rStr.length();
123	unsigned iPos = 0;
124	while (iPos < cch)
125	{
126	#ifdef VBOXDBG_USE_QT4
127	int iPosNL = rStr.indexOf('\n', iPos);
128	#else
129	int iPosNL = rStr.find('\n', iPos);
130	#endif
131	int iPosEnd = iPosNL >= 0 ? iPosNL : cch;
132	if ((unsigned)iPosNL != iPos)
133	{
134	QString Str = rStr.mid(iPos, iPosEnd - iPos);
135	if (m_uCurPos == 0)
136	append(Str);
137	else
138	#ifdef VBOXDBG_USE_QT4
139	insertPlainText(Str);
140	#else
141	insertAt(Str, m_uCurLine, m_uCurPos);
142	#endif
143	if (iPosNL >= 0)
144	{
145	m_uCurLine++;
146	m_uCurPos = 0;
147	}
148	else
149	m_uCurPos += Str.length();
150	}
151	else
152	{
153	m_uCurLine++;
154	m_uCurPos = 0;
155	}
156	/* next */
157	iPos = iPosEnd + 1;
158	}
159	}
160
161
162
163
164	/*
165	*
166	* V B o x D b g C o n s o l e I n p u t
167	* V B o x D b g C o n s o l e I n p u t
168	* V B o x D b g C o n s o l e I n p u t
169	*
170	*
171	*/
172
173
174	VBoxDbgConsoleInput::VBoxDbgConsoleInput(QWidget pParent/ = NULL/, const char pszName/* = NULL*/)
175	#ifdef VBOXDBG_USE_QT4
176	: QComboBox(pParent),
177	#else
178	: QComboBox(true, pParent, pszName),
179	#endif
180	m_iBlankItem(0), m_hGUIThread(RTThreadNativeSelf())
181	{
182	#ifdef VBOXDBG_USE_QT4
183	insertItem(m_iBlankItem, "");
184	setEditable(true);
185	setInsertPolicy(NoInsert);
186	#else
187	insertItem("", m_iBlankItem);
188	setInsertionPolicy(NoInsertion);
189	#endif
190	setMaxCount(50);
191	const QLineEdit *pEdit = lineEdit();
192	if (pEdit)
193	connect(pEdit, SIGNAL(returnPressed()), this, SLOT(returnPressed()));
194
195	NOREF(pszName);
196	}
197
198	VBoxDbgConsoleInput::~VBoxDbgConsoleInput()
199	{
200	Assert(m_hGUIThread == RTThreadNativeSelf());
201	}
202
203	void VBoxDbgConsoleInput::setLineEdit(QLineEdit *pEdit)
204	{
205	Assert(m_hGUIThread == RTThreadNativeSelf());
206	QComboBox::setLineEdit(pEdit);
207	if (lineEdit() == pEdit && pEdit)
208	connect(pEdit, SIGNAL(returnPressed()), this, SLOT(returnPressed()));
209	}
210
211	void VBoxDbgConsoleInput::returnPressed()
212	{
213	Assert(m_hGUIThread == RTThreadNativeSelf());
214	/* deal with the current command. */
215	QString Str = currentText();
216	emit commandSubmitted(Str);
217
218	/* update the history and clear the entry field */
219	#ifdef VBOXDBG_USE_QT4
220	if (itemText(m_iBlankItem - 1) != Str)
221	{
222	setItemText(m_iBlankItem, Str);
223	removeItem(m_iBlankItem - maxCount() - 1);
224	insertItem(++m_iBlankItem, "");
225	}
226
227	clearEditText();
228	setCurrentIndex(m_iBlankItem);
229	#else
230	if (text(m_iBlankItem - 1) != Str)
231	{
232	changeItem(Str, m_iBlankItem);
233	removeItem(m_iBlankItem - maxCount() - 1);
234	insertItem("", ++m_iBlankItem);
235	}
236
237	clearEdit();
238	setCurrentItem(m_iBlankItem);
239	#endif
240	}
241
242
243
244
245
246
247	/*
248	*
249	* V B o x D b g C o n s o l e
250	* V B o x D b g C o n s o l e
251	* V B o x D b g C o n s o l e
252	*
253	*
254	*/
255
256
257	VBoxDbgConsole::VBoxDbgConsole(PVM pVM, QWidget pParent/ = NULL/, const char pszName/* = NULL*/)
258	: VBoxDbgBase(pVM), m_pOutput(NULL), m_pInput(NULL),
259	m_pszInputBuf(NULL), m_cbInputBuf(0), m_cbInputBufAlloc(0),
260	m_pszOutputBuf(NULL), m_cbOutputBuf(0), m_cbOutputBufAlloc(0),
261	m_pTimer(NULL), m_fUpdatePending(false), m_Thread(NIL_RTTHREAD), m_EventSem(NIL_RTSEMEVENT), m_fTerminate(false)
262	{
263	#ifdef VBOXDBG_USE_QT4
264	setWindowTitle("VBoxDbg - Console");
265	#else
266	setCaption("VBoxDbg - Console");
267	#endif
268
269	NOREF(pszName);
270	NOREF(pParent);
271
272	/*
273	* Create the output text box.
274	*/
275	m_pOutput = new VBoxDbgConsoleOutput(this);
276
277	/* try figure a suitable size */
278	#ifdef VBOXDBG_USE_QT4
279	QLabel *pLabel = new QLabel( "11111111111111111111111111111111111111111111111111111111111111111111111111111112222222222", this);
280	#else
281	QLabel *pLabel = new QLabel(NULL, "11111111111111111111111111111111111111111111111111111111111111111111111111111112222222222", this); /// @todo
282	#endif
283	pLabel->setFont(m_pOutput->font());
284	QSize Size = pLabel->sizeHint();
285	delete pLabel;
286	Size.setWidth((int)(Size.width() * 1.10));
287	Size.setHeight(Size.width() / 2);
288	resize(Size);
289
290	/*
291	* Create the input combo box (with a label).
292	*/
293	#ifdef VBOXDBG_USE_QT4
294	QHBoxLayout *pLayout = new QHBoxLayout();
295	//pLayout->setSizeConstraint(QLayout::SetMaximumSize);
296
297	pLabel = new QLabel(" Command ");
298	pLayout->addWidget(pLabel);
299	pLabel->setMaximumSize(pLabel->sizeHint());
300	pLabel->setAlignment(Qt::AlignCenter);
301
302	m_pInput = new VBoxDbgConsoleInput(NULL);
303	pLayout->addWidget(m_pInput);
304	m_pInput->setDuplicatesEnabled(false);
305	connect(m_pInput, SIGNAL(commandSubmitted(const QString &)), this, SLOT(commandSubmitted(const QString &)));
306
307	# if 0//def Q_WS_MAC
308	pLabel = new QLabel(" ");
309	pLayout->addWidget(pLabel);
310	pLabel->setMaximumSize(20, m_pInput->sizeHint().height() + 6);
311	pLabel->setMinimumSize(20, m_pInput->sizeHint().height() + 6);
312	# endif
313
314	QWidget *pHBox = new QWidget(this);
315	pHBox->setLayout(pLayout);
316
317	#else /* QT3 */
318	QHBox *pHBox = new QHBox(this);
319
320	pLabel = new QLabel(NULL, " Command ", pHBox);
321	pLabel->setMaximumSize(pLabel->sizeHint());
322	pLabel->setAlignment(AlignHCenter \| AlignVCenter);
323
324	m_pInput = new VBoxDbgConsoleInput(pHBox);
325	m_pInput->setDuplicatesEnabled(false);
326	connect(m_pInput, SIGNAL(commandSubmitted(const QString &)), this, SLOT(commandSubmitted(const QString &)));
327
328	# ifdef Q_WS_MAC
329	pLabel = new QLabel(NULL, " ", pHBox); /// @todo
330	pLabel->setMaximumSize(20, m_pInput->sizeHint().height() + 6);
331	pLabel->setMinimumSize(20, m_pInput->sizeHint().height() + 6);
332	# endif
333	#endif /* QT3 */
334
335	#ifdef VBOXDBG_USE_QT4
336	/*
337	* Vertical layout box on the whole widget.
338	*/
339	QVBoxLayout *pVLayout = new QVBoxLayout;
340	pVLayout->setSpacing(5);
341	pVLayout->setContentsMargins(0, 0, 0, 0);
342	pVLayout->addWidget(m_pOutput);
343	pVLayout->addWidget(pHBox);
344	setLayout(pVLayout);
345	#endif
346
347	/*
348	* The tab order is from input to output, not the otherway around as it is by default.
349	*/
350	setTabOrder(m_pInput, m_pOutput);
351
352	/*
353	* Setup the timer.
354	*/
355	m_pTimer = new QTimer(this);
356	connect(m_pTimer, SIGNAL(timeout()), SLOT(updateOutput()));
357
358	/*
359	* Init the backend structure.
360	*/
361	m_Back.Core.pfnInput = backInput;
362	m_Back.Core.pfnRead = backRead;
363	m_Back.Core.pfnWrite = backWrite;
364	m_Back.pSelf = this;
365
366	/*
367	* Create the critical section, the event semaphore and the debug console thread.
368	*/
369	int rc = RTCritSectInit(&m_Lock);
370	AssertRC(rc);
371
372	rc = RTSemEventCreate(&m_EventSem);
373	AssertRC(rc);
374
375	rc = RTThreadCreate(&m_Thread, backThread, this, 0, RTTHREADTYPE_DEBUGGER, RTTHREADFLAGS_WAITABLE, "VBoxDbgC");
376	AssertRC(rc);
377	if (VBOX_FAILURE(rc))
378	m_Thread = NIL_RTTHREAD;
379	}
380
381	VBoxDbgConsole::~VBoxDbgConsole()
382	{
383	Assert(isGUIThread());
384
385	/*
386	* Wait for the thread.
387	*/
388	ASMAtomicXchgSize(&m_fTerminate, true);
389	RTSemEventSignal(m_EventSem);
390	if (m_Thread != NIL_RTTHREAD)
391	{
392	int rc = RTThreadWait(m_Thread, 15000, NULL);
393	AssertRC(rc);
394	m_Thread = NIL_RTTHREAD;
395	}
396
397	/*
398	* Free resources.
399	*/
400	delete m_pTimer;
401	m_pTimer = NULL;
402	RTCritSectDelete(&m_Lock);
403	RTSemEventDestroy(m_EventSem);
404	m_EventSem = 0;
405	m_pOutput = NULL;
406	m_pInput = NULL;
407	if (m_pszInputBuf)
408	{
409	RTMemFree(m_pszInputBuf);
410	m_pszInputBuf = NULL;
411	}
412	m_cbInputBuf = 0;
413	m_cbInputBufAlloc = 0;
414	}
415
416	void VBoxDbgConsole::commandSubmitted(const QString &rCommand)
417	{
418	Assert(isGUIThread());
419
420	lock();
421	RTSemEventSignal(m_EventSem);
422
423	#ifdef VBOXDBG_USE_QT4
424	QByteArray Utf8Array = rCommand.toUtf8();
425	const char *psz = Utf8Array.constData();
426	#else
427	const char *psz = rCommand;//.utf8();
428	#endif
429	size_t cb = strlen(psz);
430
431	/*
432	* Make sure we've got space for the input.
433	*/
434	if (cb + m_cbInputBuf >= m_cbInputBufAlloc)
435	{
436	size_t cbNew = RT_ALIGN_Z(cb + m_cbInputBufAlloc + 1, 128);
437	void *pv = RTMemRealloc(m_pszInputBuf, cbNew);
438	if (!pv)
439	{
440	unlock();
441	return;
442	}
443	m_pszInputBuf = (char *)pv;
444	m_cbInputBufAlloc = cbNew;
445	}
446
447	/*
448	* Add the input and output it.
449	*/
450	memcpy(m_pszInputBuf + m_cbInputBuf, psz, cb);
451	m_cbInputBuf += cb;
452	m_pszInputBuf[m_cbInputBuf++] = '\n';
453
454	m_pOutput->appendText(rCommand + "\n");
455	#ifdef VBOXDBG_USE_QT4
456	m_pOutput->ensureCursorVisible();
457	#else
458	m_pOutput->scrollToBottom();
459	#endif
460
461	m_fInputRestoreFocus = m_pInput->hasFocus(); /* dirty focus hack */
462	m_pInput->setEnabled(false);
463
464	unlock();
465	}
466
467	void VBoxDbgConsole::updateOutput()
468	{
469	Assert(isGUIThread());
470
471	lock();
472	m_fUpdatePending = false;
473	if (m_cbOutputBuf)
474	{
475	m_pOutput->appendText(QString::fromUtf8((const char *)m_pszOutputBuf, m_cbOutputBuf));
476	m_cbOutputBuf = 0;
477	}
478	unlock();
479	}
480
481
482	/**
483	* Lock the object.
484	*/
485	void VBoxDbgConsole::lock()
486	{
487	RTCritSectEnter(&m_Lock);
488	}
489
490	/**
491	* Unlocks the object.
492	*/
493	void VBoxDbgConsole::unlock()
494	{
495	RTCritSectLeave(&m_Lock);
496	}
497
498
499
500	/**
501	* Checks if there is input.
502	*
503	* @returns true if there is input ready.
504	* @returns false if there not input ready.
505	* @param pBack Pointer to VBoxDbgConsole::m_Back.
506	* @param cMillies Number of milliseconds to wait on input data.
507	*/
508	/static/ DECLCALLBACK(bool) VBoxDbgConsole::backInput(PDBGCBACK pBack, uint32_t cMillies)
509	{
510	VBoxDbgConsole *pThis = VBOXDBGCONSOLE_FROM_DBGCBACK(pBack);
511	pThis->lock();
512
513	/* questing for input means it's done processing. */
514	pThis->m_pInput->setEnabled(true);
515	/* dirty focus hack: */
516	if (pThis->m_fInputRestoreFocus)
517	QApplication::postEvent(pThis, new VBoxDbgConsoleEvent(VBoxDbgConsoleEvent::kInputRestoreFocus));
518
519	bool fRc = true;
520	if (!pThis->m_cbInputBuf)
521	{
522	pThis->unlock();
523	RTSemEventWait(pThis->m_EventSem, cMillies);
524	pThis->lock();
525	fRc = pThis->m_cbInputBuf \|\| pThis->m_fTerminate;
526	}
527
528	pThis->unlock();
529	return fRc;
530	}
531
532	/**
533	* Read input.
534	*
535	* @returns VBox status code.
536	* @param pBack Pointer to VBoxDbgConsole::m_Back.
537	* @param pvBuf Where to put the bytes we read.
538	* @param cbBuf Maximum nymber of bytes to read.
539	* @param pcbRead Where to store the number of bytes actually read.
540	* If NULL the entire buffer must be filled for a
541	* successful return.
542	*/
543	/static/ DECLCALLBACK(int) VBoxDbgConsole::backRead(PDBGCBACK pBack, void pvBuf, size_t cbBuf, size_t pcbRead)
544	{
545	VBoxDbgConsole *pThis = VBOXDBGCONSOLE_FROM_DBGCBACK(pBack);
546	Assert(pcbRead); /** @todo implement this bit */
547	if (pcbRead)
548	*pcbRead = 0;
549
550	pThis->lock();
551	int rc = VINF_SUCCESS;
552	if (!pThis->m_fTerminate)
553	{
554	if (pThis->m_cbInputBuf)
555	{
556	const char *psz = pThis->m_pszInputBuf;
557	size_t cbRead = RT_MIN(pThis->m_cbInputBuf, cbBuf);
558	memcpy(pvBuf, psz, cbRead);
559	psz += cbRead;
560	pThis->m_cbInputBuf -= cbRead;
561	if (*psz)
562	memmove(pThis->m_pszInputBuf, psz, pThis->m_cbInputBuf);
563	pThis->m_pszInputBuf[pThis->m_cbInputBuf] = '\0';
564	*pcbRead = cbRead;
565	}
566	}
567	else
568	rc = VERR_GENERAL_FAILURE;
569	pThis->unlock();
570	return rc;
571	}
572
573	/**
574	* Write (output).
575	*
576	* @returns VBox status code.
577	* @param pBack Pointer to VBoxDbgConsole::m_Back.
578	* @param pvBuf What to write.
579	* @param cbBuf Number of bytes to write.
580	* @param pcbWritten Where to store the number of bytes actually written.
581	* If NULL the entire buffer must be successfully written.
582	*/
583	/static/ DECLCALLBACK(int) VBoxDbgConsole::backWrite(PDBGCBACK pBack, const void pvBuf, size_t cbBuf, size_t pcbWritten)
584	{
585	VBoxDbgConsole *pThis = VBOXDBGCONSOLE_FROM_DBGCBACK(pBack);
586	int rc = VINF_SUCCESS;
587
588	pThis->lock();
589	if (cbBuf + pThis->m_cbOutputBuf >= pThis->m_cbOutputBufAlloc)
590	{
591	size_t cbNew = RT_ALIGN_Z(cbBuf + pThis->m_cbOutputBufAlloc + 1, 1024);
592	void *pv = RTMemRealloc(pThis->m_pszOutputBuf, cbNew);
593	if (!pv)
594	{
595	pThis->unlock();
596	if (pcbWritten)
597	*pcbWritten = 0;
598	return VERR_NO_MEMORY;
599	}
600	pThis->m_pszOutputBuf = (char *)pv;
601	pThis->m_cbOutputBufAlloc = cbNew;
602	}
603
604	/*
605	* Add the output.
606	*/
607	memcpy(pThis->m_pszOutputBuf + pThis->m_cbOutputBuf, pvBuf, cbBuf);
608	pThis->m_cbOutputBuf += cbBuf;
609	pThis->m_pszOutputBuf[pThis->m_cbOutputBuf] = '\0';
610	if (pcbWritten)
611	*pcbWritten = cbBuf;
612
613	if (pThis->m_fTerminate)
614	rc = VERR_GENERAL_FAILURE;
615
616	/*
617	* Tell the GUI thread to draw this text.
618	* We cannot do it from here without frequent crashes.
619	*/
620	if (!pThis->m_fUpdatePending)
621	QApplication::postEvent(pThis, new VBoxDbgConsoleEvent(VBoxDbgConsoleEvent::kUpdate));
622
623	pThis->unlock();
624
625	return rc;
626	}
627
628	/**
629	* The Debugger Console Thread
630	*
631	* @returns VBox status code (ignored).
632	* @param Thread The thread handle.
633	* @param pvUser Pointer to the VBoxDbgConsole object.s
634	*/
635	/static/ DECLCALLBACK(int) VBoxDbgConsole::backThread(RTTHREAD Thread, void *pvUser)
636	{
637	VBoxDbgConsole pThis = (VBoxDbgConsole )pvUser;
638	LogFlow(("backThread: Thread=%p pvUser=%p\n", (void *)Thread, pvUser));
639
640	NOREF(Thread);
641
642	/*
643	* Create and execute the console.
644	*/
645	int rc = pThis->dbgcCreate(&pThis->m_Back.Core, 0);
646	LogFlow(("backThread: returns %Vrc\n", rc));
647	if (!pThis->m_fTerminate)
648	QApplication::postEvent(pThis, new VBoxDbgConsoleEvent(VBoxDbgConsoleEvent::kTerminated));
649	return rc;
650	}
651
652	bool VBoxDbgConsole::event(QEvent *pGenEvent)
653	{
654	Assert(isGUIThread());
655	if (pGenEvent->type() == (QEvent::Type)VBoxDbgConsoleEvent::kEventNumber)
656	{
657	VBoxDbgConsoleEvent pEvent = (VBoxDbgConsoleEvent )pGenEvent;
658
659	switch (pEvent->command())
660	{
661	/* make update pending. */
662	case VBoxDbgConsoleEvent::kUpdate:
663	if (!m_fUpdatePending)
664	{
665	m_fUpdatePending = true;
666	#ifdef VBOXDBG_USE_QT4
667	m_pTimer->setSingleShot(true);
668	m_pTimer->start(10);
669	#else
670	m_pTimer->start(10, true /* single shot */);
671	#endif
672	}
673	break;
674
675	/* dirty hack: restores the focus */
676	case VBoxDbgConsoleEvent::kInputRestoreFocus:
677	if (m_fInputRestoreFocus)
678	{
679	m_fInputRestoreFocus = false;
680	if (!m_pInput->hasFocus())
681	m_pInput->setFocus();
682	}
683	break;
684
685	/* the thread terminated */
686	case VBoxDbgConsoleEvent::kTerminated:
687	m_pInput->setEnabled(false);
688	break;
689
690	/* paranoia */
691	default:
692	AssertMsgFailed(("command=%d\n", pEvent->command()));
693	break;
694	}
695	return true;
696	}
697
698	#ifdef VBOXDBG_USE_QT4
699	return QWidget::event(pGenEvent);
700	#else
701	return QVBox::event(pGenEvent);
702	#endif
703	}
704

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

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

Download in other formats: