void ConsoleWidget::command(QString text)
{
text.remove(QRegExp("^\\s+")); // remove leading whitespace
if (text=="")
return;
handleColor(CW_DEFAULT_COLOR);
prompt();
if (!text.endsWith('\n'))
text = text + '\n';
insertPlainText(text);
emit textLine(text);
}
/*!
* \brief TextDoc::commentSelected toggles the comment of selected text
* See also QucsApp::slotEditActivate
*/
void TextDoc::commentSelected ()
{
QTextCursor cursor = this->textCursor();
if(!cursor.hasSelection())
return; // No selection available
// get range of selection
int start = cursor.selectionStart();
int end = cursor.selectionEnd();
cursor.setPosition(start);
int firstLine = cursor.blockNumber();
cursor.setPosition(end, QTextCursor::KeepAnchor);
int lastLine = cursor.blockNumber();
// use comment string indicator depending on language
QString co;
switch (language) {
case LANG_VHDL:
co = "--";
break;
case LANG_VERILOG:
case LANG_VERILOGA:
co = "//";
break;
case LANG_OCTAVE:
co = "%";
break;
default:
co = "";
break;
}
QStringList newlines;
for (int i=firstLine; i<=lastLine; i++) {
QString line = document()->findBlockByLineNumber(i).text();
if (line.startsWith(co)){
// uncomment
line.remove(0,co.length());
newlines << line;
}
else {
// comment
line = line.insert(0, co);
newlines << line;
}
}
insertPlainText(newlines.join("\n"));
}
void Logger::msg(QString s, int level) {
setTextColor(Qt::lightGray);
append(QTime::currentTime().toString("hh:mm:ss")+": ");
moveCursor(QTextCursor::End);
switch (level) {
case 0: setTextColor(Qt::black); break;
case 1: setTextColor(Qt::gray); break;
case 99: setTextColor(Qt::red); break;
}
insertPlainText(s);
repaint();
QEventLoop el(this);
el.processEvents(QEventLoop::ExcludeUserInputEvents);
}
//---------------------------------------------------------------------------
bool GUI_Main_Text_Summary::event (QEvent *Event)
{
if (Event->type()==QEvent::User)
{
//Showing
clear();
insertPlainText(QString().fromUtf8(ZenLib::Ztring(C->Summary()).To_UTF8().c_str()));
Event->accept();
return true;
}
return QTextEdit::event(Event);
}
void ConsoleWidget::print(QString text, QColor color)
{
emptyLine();
moveCursor(QTextCursor::End);
handleColor(color);
m_mutexPrint.lock();
if (text==m_lastLine)
{
if (!m_suppress)
{
insertPlainText("...\n");
m_suppress = true;
}
}
else
{
insertPlainText(text);
m_suppress = false;
}
m_lastLine = text;
m_waitPrint.wakeAll();
m_mutexPrint.unlock();
}
void CSVWorld::ScriptEdit::dropEvent (QDropEvent* event)
{
const CSMWorld::TableMimeData* mime = dynamic_cast<const CSMWorld::TableMimeData*> (event->mimeData());
setTextCursor (cursorForPosition (event->pos()));
if (mime->fromDocument (mDocument))
{
std::vector<CSMWorld::UniversalId> records (mime->getData());
for (std::vector<CSMWorld::UniversalId>::iterator it = records.begin(); it != records.end(); ++it)
{
if (mAllowedTypes.contains (it->getType()))
{
if (stringNeedsQuote(it->getId()))
{
insertPlainText(QString::fromUtf8 (('"' + it->getId() + '"').c_str()));
} else {
insertPlainText(QString::fromUtf8 (it->getId().c_str()));
}
}
}
}
}
void PgxConsole::historyUpCommand()
{
if(!history.isEmpty() && hit > 0) {
QTextCursor cursor = textCursor();
cursor.movePosition(QTextCursor::End);
setTextCursor(cursor);
cursor.select(QTextCursor::BlockUnderCursor);
if(cursor.hasSelection()) {
cursor.removeSelectedText();
appendPlainText(history.at(--hit));
}
else
insertPlainText(history.at(--hit));
}
}
// Enter key pressed
void Console::handleEnter() {
QString cmd = getCommand();
if (0 < cmd.length()) {
while (historyDown.count() > 0) {
historyUp.push(historyDown.pop());
}
historyUp.push(cmd);
}
moveToEndOfLine();
if (cmd.length() > 0) {
locked = true;
setFocus();
insertPlainText("\n");
emit command(cmd);
} else {
insertPlainText("\n");
insertPlainText(userPrompt);
ensureCursorVisible();
}
}
//---------------------------------------------------------------------------
bool GUI_Main_Core_Text::event (QEvent *Event)
{
if (Event->type()==QEvent::User)
{
//Showing
clear();
insertPlainText(QString().fromUtf8(ZenLib::Ztring(C->Core_Get()).To_Local().c_str()));
//Event accepting
Event->accept();
return true;
}
return QTextEdit::event(Event);
}
void PgxConsole::historyDownCommand()
{
if(!history.isEmpty() && hit < history.size()-1) {
QTextCursor cursor = textCursor();
cursor.movePosition(QTextCursor::End);
setTextCursor(cursor);
cursor.select(QTextCursor::BlockUnderCursor);
if(cursor.hasSelection()) {
cursor.removeSelectedText();
appendPlainText(history.value(++hit));
}
else
insertPlainText(history.value(++hit));
}
ensureCursorVisible();
}
// Arrow down pressed
void Console::handleHistoryDown() {
if (0 < historyDown.count() && historySkip) {
historyUp.push(historyDown.pop());
historySkip = false;
}
if (0 < historyDown.count()) {
QString cmd = historyDown.pop();
historyUp.push(cmd);
clearLine();
insertPlainText(cmd);
} else {
clearLine();
}
}
void ConsoleWidget::readStandardOut()
{
QByteArray array = m_process->readAll();
int i = array.lastIndexOf('\f');
if(i >= 0) {
setPlainText("");
array = array.mid(i + 1);
}
i = array.lastIndexOf('\a');
if(i >= 0) startBeep();
array.remove(i, 1);
insertPlainText(array);
moveCursor(QTextCursor::End, QTextCursor::KeepAnchor);
update();
}
void TextEdit::insertTextRegToModify(const QString& fieldname, const QString& key) {
DomModel *dommodel = ((QCmdCompleter*) c)->domModel();
if ( dommodel == NULL ) {
return;
}
QStringList list;
//bool iscommand = searchPrvsToken(list);
searchPrvsToken(list);
if ( list.count() > 0 && list.at(list.count()-1).startsWith("modificar") ) {
qDebug("...getUpdateString....(1)");
QString result = dommodel->getUpdateString(list.at(list.count()-1),fieldname,key,list);
qDebug("...getUpdateString....(2)");
insertPlainText(result);
updateDockSbMenu();
}
}
void LogWidget::appendLog(const QString& text)
{
QString t=text.trimmed()+"\n";
if(mScrollDirDown) {
appendPlainText(t);
QScrollBar *vsb=verticalScrollBar();
if(nullptr!=vsb) {
vsb->setValue(vsb->maximum());
}
} else {
moveCursor(QTextCursor::Start);
insertPlainText(t);
QScrollBar *vsb=verticalScrollBar();
if(nullptr!=vsb) {
vsb->setValue(vsb->minimum());
}
}
}
/*!
* \brief TextDoc::load loads a text document
* \return true/false if the document was opened with success
*/
bool TextDoc::load ()
{
QFile file (DocName);
if (!file.open (QIODevice::ReadOnly))
return false;
setLanguage (DocName);
QTextStream stream (&file);
insertPlainText(stream.read ());
document()->setModified(false);
slotSetChanged ();
file.close ();
lastSaved = QDateTime::currentDateTime ();
loadSettings ();
SimOpenDpl = simulation ? true : false;
refreshLanguage();
return true;
}
// implement replace function
void TextDoc::replace(const QString &str, const QString &str2, bool needConfirmed,
bool CaseSensitive, bool wordOnly, bool backward)
{
bool finded = baseSearch(str, CaseSensitive, wordOnly, backward);
int i;
if(finded) {
i = QMessageBox::Yes;
if (needConfirmed) {
i = QMessageBox::information(this,
tr("Replace..."), tr("Replace occurrence ?"),
QMessageBox::Yes | QMessageBox::Default,
QMessageBox::No | QMessageBox::Escape);
}
if(i == QMessageBox::Yes) {
insertPlainText(str2);
}
}
}
void CQExpressionWidget::setFunction(const std::string & function)
{
if (mpValidatorFunction == NULL)
{
mpValidatorFunction = new CQValidatorFunction(this, "");
mpValidatorFunction->revalidate();
}
// clear the text edit
clear();
mCursor = textCursor();
QTextCharFormat f1;
f1.setForeground(QColor(0, 0, 0));
setCurrentCharFormat(f1);
insertPlainText(FROM_UTF8(function));
}
void PythonCodeEditor::open(){
QFileDialog dlg;
#ifndef Q_WS_MAC
dlg.setOption(QFileDialog::DontUseNativeDialog);
#endif
dlg.setAcceptMode(QFileDialog::AcceptOpen);
dlg.setNameFilters( QStringList() << "Python script (*.py)" << "All files (*.*)" );
dlg.setDirectory( QDir::home() );
dlg.setFileMode(QFileDialog::ExistingFile);
if( dlg.exec() == QFileDialog::Accepted ){
QFile f(dlg.selectedFiles().first());
f.open(QFile::ReadOnly);
clear();
insertPlainText(f.readAll());
f.close();
}
}
void CodeEditor::putTab()
{
QString insertion = " ";
QTextCursor cursor = textCursor();
if (cursor.selectionEnd() - cursor.selectionStart() <= 0) {
insertPlainText(insertion);
} else {
QTextBlock firstBlock = document()->findBlock(cursor.selectionStart());
QTextBlock lastBlock = document()->findBlock(cursor.selectionEnd() - 1);
cursor.setPosition(firstBlock.position());
cursor.beginEditBlock();
do {
cursor.insertText(insertion);
} while (cursor.movePosition(QTextCursor::NextBlock) && cursor.position() <= lastBlock.position());
cursor.endEditBlock();
}
}
void PgxConsole::pasteFromClipboard()
{
if(!textCursor().atEnd()) {
if(textCursor().block().next().isValid()) {
QTextCursor cursor = textCursor();
cursor.movePosition(QTextCursor::End);
setTextCursor(cursor);
}
}
QClipboard *clipboard = QApplication::clipboard();
QString clipboard_text = clipboard->text();
QStringList clipboard_text_list = clipboard_text.trimmed().split("\n", QString::SkipEmptyParts);
int clipboard_text_list_size = clipboard_text_list.size();
for(int i = 0; i < clipboard_text_list_size; i++) {
insertPlainText(clipboard_text_list.at(i));
if(i != clipboard_text_list_size-1)
showView(clipboard_text_list.at(i));
}
}
void GLSLTextEditor::on_document_contentChanged(int position, int charsRemoved, int charsAdded)
{
if (charsAdded == 1)
{
QTextDocument* doc = document ();
QString text = doc->toPlainText();
if (text.length () <= position)
{
return;
}
if (text.at(position) == '\n')
{
unsigned openBraces = count_chars(text, "{", position) - count_chars(text, "}", position);
if (!openBraces)
{
return;
}
QString add;
for (unsigned i=0; i<openBraces; i++)
{
add.append(" ");
}
blockSignals(true);
insertPlainText(add);
blockSignals(false);
}
else if (text.at(position) == '}')
{
if (text.at(position-1) == ' ' && text.at(position-2) == ' ')
{
QTextCursor cursor = textCursor();
cursor.movePosition(QTextCursor::Left, QTextCursor::MoveAnchor, 1);
cursor.movePosition(QTextCursor::Left, QTextCursor::KeepAnchor, 2);
cursor.insertText("");
cursor.movePosition(QTextCursor::Right, QTextCursor::MoveAnchor, 1);
}
}
}
fflush(stdout);
}
void Console::keyPressEvent(QKeyEvent *e)
{
switch (e->key()) {
case Qt::Key_Backspace:
case Qt::Key_Left:
case Qt::Key_Right:
case Qt::Key_Up:
case Qt::Key_Down:
break;
case Qt::Key_Return:
clear();
break;
default:
emit getData(e->text().toLocal8Bit());
insertPlainText("Target Temp: ");
if (localEchoEnabled)
QPlainTextEdit::keyPressEvent(e);
}
}
void ConsoleWidget::prompt(QString text)
{
QString text2 = text;
moveCursor(QTextCursor::End);
handleColor(); // change to default color
// add space because it looks better
text2 += " ";
// go to new line if line isn't empty
emptyLine();
insertPlainText(text2);
m_lastLine = "";
// if we have trouble keeping viewport
QScrollBar *sb = verticalScrollBar();
sb->setSliderPosition(sb->maximum());
m_prompt = text2;
}
void CQExpressionWidget::slotSelectObject()
{
const CCopasiObject * pObject =
CCopasiSelectionDialog::getObjectSingle(this, mObjectClasses);
if (pObject)
{
// Check whether the object is valid
if (!CQSimpleSelectionTree::filter(mObjectClasses, pObject))
{
CQMessageBox::critical(this, "Invalid Selection",
"The use of the selected object is not allowed in this type of expression.");
return;
}
std::string Insert = pObject->getObjectDisplayName();
// We need to escape >
std::string::size_type pos = Insert.find_first_of("}");
while (pos != std::string::npos)
{
Insert.insert(pos, "\\");
pos += 2;
pos = Insert.find_first_of("}", pos);
}
mParseList[Insert] = pObject;
QTextCharFormat f1;
f1.setForeground(QColor(0, 0, 0));
QTextCharFormat f = mpExpressionHighlighter->mObjectDisplayFormat;
//QColor color2 = f.foreground().color();
setCurrentCharFormat(f);
insertPlainText(FROM_UTF8("{" + Insert + "}"));
setCurrentCharFormat(f1);
}
}
void DisplayWidget::addLine(const QString &text, const QString &type)
{
QString arrow_text = text;
arrow_text.prepend(QString("[%1 %2]:> ").arg(type).arg(lineNumber));
if (type == Input) {
moveCursor(QTextCursor::End);
moveCursor(QTextCursor::StartOfLine,QTextCursor::KeepAnchor);
textCursor().removeSelectedText();
insertPlainText(arrow_text);
}
if (type == Output) {
append(arrow_text);
append("");
lineNumber++;
append(QString("[%1 %2]:> ").arg(Input).arg(lineNumber));
moveCursor(QTextCursor::End);
}
}
MessageDialog::MessageDialog(const QString &nick, QWidget *parent) : QDialog(parent), ui(new Ui::MessageDialog)
{
ui->setupUi(this);
this->nick = nick;
setWindowTitle(nick);
QList<int> sizes;
sizes << 600 << 100;
ui->splitter->setSizes(sizes);
connect(ui->pushButtonSend, SIGNAL(clicked()), this, SLOT(sendPressed()));
connect(ui->plainTextEdit, SIGNAL(sendKeyPressed()), this, SLOT(sendPressed()));
//smiles
smilemenu = new QMenu(this);
smilewidgetaction = new QWidgetAction(smilemenu);
smilebar = new SmileBar();
smilewidgetaction->setDefaultWidget(smilebar);
smilemenu->addAction(smilewidgetaction);
connect(smilebar, SIGNAL(smileClicked(QString)), ui->plainTextEdit, SLOT(insertPlainText(QString)));
connect(smilebar, SIGNAL(smileClicked(QString)), ui->plainTextEdit, SLOT(setFocus()));
ui->toolButtonEmoticons->setMenu(smilemenu);
}
void ScriptEditorWidget::keyPressEvent(QKeyEvent * e)
{
if(m_pCompleter && m_pCompleter->popup()->isVisible())
{
switch(e->key())
{
case Qt::Key_Enter:
case Qt::Key_Return:
case Qt::Key_Escape:
case Qt::Key_Tab:
case Qt::Key_Backtab:
e->ignore();
return;
default:
break;
}
}
if(e->modifiers() == Qt::ControlModifier)
{
switch(e->key())
{
case Qt::Key_B:
insertPlainText("$b");
return;
case Qt::Key_K:
insertPlainText("$k");
return;
case Qt::Key_O:
insertPlainText("$o");
return;
case Qt::Key_U:
insertPlainText("$u");
return;
case Qt::Key_Enter:
case Qt::Key_Return:
case Qt::Key_PageUp:
e->ignore(); // allow the parent to process it
return;
break;
}
}
// Adapted from QT4 QCompleter example
bool isShortcut = ((e->modifiers() & Qt::ControlModifier) && e->key() == Qt::Key_E); // CTRL+E
if (!m_pCompleter || !isShortcut) // don't process the shortcut when we have a completer
QTextEdit::keyPressEvent(e);
const bool ctrlOrShift = e->modifiers() & (Qt::ControlModifier | Qt::ShiftModifier);
if (!m_pCompleter || (ctrlOrShift && e->text().isEmpty()))
return;
static QString eow("~!@#$%^&*()_+{}|:\"<>?,/;'[]\\-="); // end of word
bool hasModifier = (e->modifiers() != Qt::NoModifier) && !ctrlOrShift;
QString completionPrefix = textUnderCursor();
if (!isShortcut && (hasModifier || e->text().isEmpty()|| completionPrefix.length() < 3 || eow.contains(e->text().right(1))))
{
m_pCompleter->popup()->hide();
return;
}
if (completionPrefix != m_pCompleter->completionPrefix())
{
m_pCompleter->setCompletionPrefix(completionPrefix);
m_pCompleter->popup()->setCurrentIndex(m_pCompleter->completionModel()->index(0, 0));
}
QRect cr = cursorRect();
cr.setWidth(m_pCompleter->popup()->sizeHintForColumn(0)+ m_pCompleter->popup()->verticalScrollBar()->sizeHint().width());
m_pCompleter->complete(cr);
}
//-------------------------------------------------------------------------------------------------
void QCommandPrompt::keyPressEvent(QKeyEvent *e)
{
// Wenn Enter gedrückt wird, wird die Eingabe als Kommando interpretiert
switch(e->key())
{
case Qt::Key_Return:
{
// Alles zwischen Promptposition und dem Textende ist das Kommando
QString sAll = toPlainText();
QString sCmd = sAll.right(sAll.count() - m_nPromptPos);
if (sCmd.length()>0 && (m_vHistory.size()==0 || m_vHistory.back()!=sCmd) )
{
m_vHistory.push_back(sCmd);
while (m_vHistory.size() > m_nMaxHist)
m_vHistory.removeFirst();
m_nHistPos = m_vHistory.size() - 1;
}
sCmd = sCmd.trimmed();
if (!sCmd.isEmpty())
{
addLine(getPrompt() + sCmd.trimmed());
emit commandInput(sCmd);
}
// Textcursor ans Ende versetzen
QTextCursor tc = textCursor();
tc.movePosition(QTextCursor::End);
setTextCursor(tc);
}
break;
case Qt::Key_Up:
case Qt::Key_Down:
if (m_vHistory.size()==0)
break;
clearLineExceptPrompt();
insertPlainText(m_vHistory[m_nHistPos]);
m_nHistPos = m_nHistPos + ((e->key()==Qt::Key_Up) ? -1 : 1);
m_nHistPos = Utils::clamp(0, m_vHistory.size()-1, m_nHistPos);
break;
case Qt::Key_Home:
{
QTextCursor tc = textCursor();
Qt::KeyboardModifiers mod = e->modifiers();
if (mod & Qt::ShiftModifier)
tc.setPosition(m_nPromptPos, QTextCursor::KeepAnchor);
else
tc.setPosition(m_nPromptPos, QTextCursor::MoveAnchor);
setTextCursor(tc);
}
break;
case Qt::Key_Backspace:
case Qt::Key_Left:
{
int nPos = textCursor().position();
if (nPos > m_nPromptPos)
QPlainTextEdit::keyPressEvent(e);
}
break;
default:
{
int nPos = textCursor().position();
if (nPos < m_nPromptPos)
{
QTextCursor tc = textCursor();
tc.movePosition(QTextCursor::End);
setTextCursor(tc);
}
QPlainTextEdit::keyPressEvent(e);
}
}
}
void CodeArea::keyPressEvent(QKeyEvent *e)
{
if (mCompleter && mCompleter->popup()->isVisible())
{
// The following keys are forwarded by the completer to the widget
switch (e->key())
{
case Qt::Key_Enter:
case Qt::Key_Return:
case Qt::Key_Escape:
case Qt::Key_Tab:
case Qt::Key_Backtab:
e->ignore();
return; // let the completer do default behavior
default:
break;
}
}
{
switch (e->key()) {
case Qt::Key_Tab:
{
QTextCursor tc = textCursor();
if(tc.hasSelection())
{
}
if(!(e->modifiers() & (Qt::ShiftModifier | Qt::ControlModifier)))
{
this->insertPlainText(" ");
QTextCursor tc = textCursor();
tc.setPosition(tc.position());
setTextCursor(tc);
return;
}
}
case Qt::Key_Backtab:
{
QTextCursor tc = textCursor();
QTextBlock tb = tc.block();
QString str = tb.text();
int space = 4;
tc.movePosition(QTextCursor::StartOfLine);
foreach(QString s, str)
{
if(s == " "&& space!=0)
{
space--;
tc.movePosition(QTextCursor::Right);
tc.deletePreviousChar();
}
else
break;
}
return;
}
case Qt::Key_Return:
{
QTextCursor tc = textCursor();
QTextBlock tb = tc.block();
QString str = tb.text();
int space = 0;
foreach(QString s, str)
{
if(s == " ")
space++;
else
break;
}
insertPlainText("\n");
for(int x= 0; x <space;++x)
insertPlainText(" ");
tc.movePosition(QTextCursor::EndOfLine);
setTextCursor(tc);
e->accept();
return;
}
default:
break;
}
}
bool isShortcut = ((e->modifiers() & Qt::ControlModifier) && e->key() == Qt::Key_Space); // CTRL+E
if (!mCompleter || !isShortcut) // do not process the shortcut when we have a completer
QPlainTextEdit::keyPressEvent(e);
const bool ctrlOrShift = e->modifiers() & (Qt::ControlModifier | Qt::ShiftModifier);
if (!mCompleter || (ctrlOrShift && e->text().isEmpty()))
return;
static QString eow("~!@#$%^&*_+(){}|\"<>?,:./;'[]\\-="); // end of word
bool hasModifier = (e->modifiers() != Qt::NoModifier) && !ctrlOrShift;
QString completionPrefix = textUnderCursor();
/*if(completionPrefix.endsWith(")"))
{
completionPrefix.remove(completionPrefix.size()-1);
}*/
if (!isShortcut && (hasModifier || e->text().isEmpty()|| completionPrefix.length() < 3
|| eow.contains(e->text().right(1)))) {
mCompleter->popup()->hide();
return;
}
if (completionPrefix != mCompleter->completionPrefix()) {
mCompleter->setCompletionPrefix(completionPrefix);
mCompleter->popup()->setCurrentIndex(mCompleter->completionModel()->index(0, 0));
}
QRect cr = cursorRect();
cr.setWidth(mCompleter->popup()->sizeHintForColumn(0)
+ mCompleter->popup()->verticalScrollBar()->sizeHint().width());
mCompleter->complete(cr); // popup it up!
}
void ConsoleItemDelegate::setEditorData(QWidget *editor,
const QModelIndex &index) const
{
auto edtr = qobject_cast<ConsoleEdit*>(editor);
edtr->insertPlainText(index.data(ConsoleItem::ExpressionRole).toString());
}
