VirtualBox

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

Last change on this file since 43328 was 43328, checked in by vboxsync, 12 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette