Entry Dict::kanjiParse(const QString &raw)
{
unsigned int length = raw.length();
if (raw.left(5) == "DICT ")
return Entry(raw.right(length - 5));
if (raw.left(8) == "HEADING ")
return Entry(raw.right(length - 8), true);
QStringList readings;
QString kanji;
QStringList meanings;
QString curmeaning;
QString curreading;
QString strfreq;
QString strgrade;
QString strstrokes;
QString strmiscount = "";
bool prevwasspace = true;
QChar detailname;
QCString parsemode("kanji");
// if there are two S entries, second is common miscount
bool strokesset = false;
unsigned int i;
QChar ichar;
for (i = 0; i < length; i++)
{
ichar = raw.at(i);
if (ichar == ' ')
{
if (parsemode == "reading")
{
readings.append(curreading);
curreading = "";
}
else if (parsemode == "kanji")
{
parsemode = "misc";
}
else if (parsemode == "detail")
{
if (detailname == 'S')
strokesset = true;
parsemode = "misc";
}
else if (parsemode == "meaning")
{
curmeaning += ichar;
}
prevwasspace = true;
}
else if (ichar == '{')
{
parsemode = "meaning";
}
else if (ichar == '}')
{
meanings.append(curmeaning);
curmeaning = "";
}
else if (parsemode == "detail")
{
if (detailname == 'G')
{
strgrade += ichar;
}
else if (detailname == 'F')
{
strfreq += ichar;
}
else if (detailname == 'S')
{
if (strokesset)
strmiscount += ichar;
else
strstrokes += ichar;
}
prevwasspace = false;
}
else if (parsemode == "kanji")
{
kanji += ichar;
}
else if (parsemode == "meaning")
{
curmeaning += ichar;
}
else if (parsemode == "reading")
{
curreading += ichar;
}
else if (parsemode == "misc" && prevwasspace)
{
if (QRegExp("[A-Za-z0-9]").search(QString(ichar)) >= 0)
// is non-japanese?
{
detailname = ichar;
parsemode = "detail";
}
else
{
curreading = QString(ichar);
parsemode = "reading";
}
}
}
return (Entry(kanji, readings, meanings, strgrade.toUInt(), strfreq.toUInt(), strstrokes.toUInt(), strmiscount.toUInt()));
}
void AssemblyGraph::buildDeBruijnGraphFromGfa(QString fullFileName)
{
m_graphFileType = GFA;
QFile inputFile(fullFileName);
if (inputFile.open(QIODevice::ReadOnly))
{
std::vector<QString> edgeStartingNodeNames;
std::vector<QString> edgeEndingNodeNames;
std::vector<int> edgeOverlaps;
QTextStream in(&inputFile);
while (!in.atEnd())
{
QApplication::processEvents();
QString line = in.readLine();
QStringList lineParts = line.split(QRegExp("\t"));
if (lineParts.size() < 1)
continue;
//Lines beginning with "S" are sequence (node) lines
if (lineParts.at(0) == "S")
{
if (lineParts.size() < 3)
throw "load error";
QString nodeName = lineParts.at(1);
QString posNodeName = nodeName + "+";
QString negNodeName = nodeName + "-";
QByteArray sequence = lineParts.at(2).toLocal8Bit();
QByteArray revCompSequence = getReverseComplement(sequence);
//If there is an attribute holding the read depth, we'll use that.
//If there isn't, then we'll use zero.
double nodeReadDepth = 0.0;
for (int i = 3; i < lineParts.size(); ++i)
{
QString part = lineParts.at(i);
if (part.size() < 6)
continue;
else if (part.left(5) == "KC:f:")
nodeReadDepth = part.right(part.length() - 5).toDouble();
}
DeBruijnNode * node = new DeBruijnNode(posNodeName, nodeReadDepth, sequence);
DeBruijnNode * reverseComplementNode = new DeBruijnNode(negNodeName, nodeReadDepth, revCompSequence);
node->setReverseComplement(reverseComplementNode);
reverseComplementNode->setReverseComplement(node);
m_deBruijnGraphNodes.insert(posNodeName, node);
m_deBruijnGraphNodes.insert(negNodeName, reverseComplementNode);
}
//Lines beginning with "L" are link (edge) lines
else if (lineParts.at(0) == "L")
{
//Edges aren't made now, in case their sequence hasn't yet been specified.
//Instead, we save the starting and ending nodes and make the edges after
//we're done looking at the file.
if (lineParts.size() < 6)
throw "load error";
//Parts 1 and 3 hold the node names and parts 2 and 4 hold the corresponding +/-.
QString startingNode = lineParts.at(1) + lineParts.at(2);
QString endingNode = lineParts.at(3) + lineParts.at(4);
edgeStartingNodeNames.push_back(startingNode);
edgeEndingNodeNames.push_back(endingNode);
//Part 5 holds the node overlap cigar string
QString cigar = lineParts.at(5);
edgeOverlaps.push_back(getLengthFromCigar(cigar));
}
}
//Create all of the edges
for (size_t i = 0; i < edgeStartingNodeNames.size(); ++i)
{
QString node1Name = edgeStartingNodeNames[i];
QString node2Name = edgeEndingNodeNames[i];
int overlap = edgeOverlaps[i];
createDeBruijnEdge(node1Name, node2Name, overlap);
}
}
if (m_deBruijnGraphNodes.size() == 0)
throw "load error";
}
void LiteEditorWidget::keyPressEvent(QKeyEvent *e)
{
if (!m_completer) {
LiteEditorWidgetBase::keyPressEvent(e);
return;
}
if (m_inputCursorOffset > 0) {
m_completer->hidePopup();
LiteEditorWidgetBase::keyPressEvent(e);
return;
}
if (m_completer->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:
case Qt::Key_Shift:
e->ignore();
return; // let the completer do default behavior
case Qt::Key_N:
case Qt::Key_P:
if (e->modifiers() == Qt::ControlModifier) {
e->ignore();
return;
}
default:
break;
}
}
bool isInImport = false;
if (m_textLexer->isInStringOrComment(this->textCursor())) {
isInImport = m_textLexer->isInImport(this->textCursor());
if (!isInImport) {
LiteEditorWidgetBase::keyPressEvent(e);
m_completer->hidePopup();
return;
}
}
LiteEditorWidgetBase::keyPressEvent(e);
const bool ctrlOrShift = e->modifiers() & (Qt::ControlModifier | Qt::ShiftModifier);
//always break if ctrl is pressed and there's a key
// if (((e->modifiers() & Qt::ControlModifier) && !e->text().isEmpty())) {
// return;
// }
if (e->modifiers() & Qt::ControlModifier) {
if (!e->text().isEmpty()) {
m_completer->hidePopup();
}
return;
}
if (e->key() == Qt::Key_Tab || e->key() == Qt::Key_Backtab) {
return;
}
if (e->text().isEmpty()) {
if (e->key() != Qt::Key_Backspace) {
m_completer->hidePopup();
return;
}
}
//import line
if (isInImport) {
QString completionPrefix = importUnderCursor(textCursor());
if (completionPrefix.isEmpty()) {
return;
}
m_completer->setCompletionContext(LiteApi::CompleterImportContext);
m_completer->setCompletionPrefix("");
m_completer->startCompleter(completionPrefix);
return;
}
//static QString eow("~!@#$%^&*()+{}|:\"<>?,/;'[]\\-="); // end of word
static QString eow("~!@#$%^&*()+{}|\"<>?,/;'[]\\-="); // end of word
bool hasModifier = (e->modifiers() != Qt::NoModifier) && !ctrlOrShift;
QString completionPrefix = textUnderCursor(textCursor());
if (completionPrefix.startsWith("...")) {
completionPrefix = completionPrefix.mid(3);
} else if (completionPrefix.startsWith(".")) {
completionPrefix.insert(0,'@');
}
if (hasModifier ||
e->text().isEmpty() ||
( (completionPrefix.length() < m_completer->prefixMin()) && (completionPrefix.right(1) != ".") ) ||
eow.contains(e->text().right(1))) {
if (m_completer->popup()->isVisible()) {
m_completer->popup()->hide();
//fmt.Print( -> Print
if (e->text() == "(") {
QTextCursor cur = textCursor();
cur.movePosition(QTextCursor::Left);
QString lastPrefix = textUnderCursor(cur);
if (lastPrefix.startsWith(".")) {
lastPrefix.insert(0,"@");
}
if (!lastPrefix.isEmpty() &&
lastPrefix == m_completer->completionPrefix() ) {
if (lastPrefix == m_completer->currentCompletion() ||
lastPrefix.endsWith("."+m_completer->currentCompletion())) {
m_completer->updateCompleteInfo(m_completer->currentIndex());
}
}
}
}
return;
}
m_completer->setCompletionContext(LiteApi::CompleterCodeContext);
emit completionPrefixChanged(completionPrefix,false);
m_completer->startCompleter(completionPrefix);
}
void GUISummaryPane::update(const GUIUpdateData& ud)
{
RegisterThisFunction fnguard(__PRETTY_FUNCTION__);
if(!isVisible())return;
TelescopeController::TrackingState state = ud.tse.state;
if(m_sv_demand == SV_AUTO)
{
if((ud.tar_object!=0)&&(!ud.tar_object->useCorrections()))
m_sv = SV_ENCODER;
else if(ud.tar_object!=0)m_sv = SV_SKY;
}
else
{
m_sv = m_sv_demand;
}
if(state != TelescopeController::TS_COM_FAILURE)
{
int x=int(floor(30*(1+sin(fmod(ud.mjd*86400/2,1)*Angle::sc_twoPi))));
if((x!=m_lastx)||(ud.full_update)||(ud.replay))
{
QColor pcolor=QColor(255-x,x,x);
//QColor pcolor=QColor(255-60+x,60-x,60-x);
m_lastx=x;
QColor azindcolor = azel_ind_normcolor;
if((ud.tse.status.az.driveangle_deg >= WARNANGLE_CW)||
(ud.tse.status.az.driveangle_deg <= WARNANGLE_CC))
azindcolor=pcolor;
if((ud.full_update)||(ud.replay)||
(ud.tse.status.az.driveangle_deg >= WARNANGLE_CW)||
(ud.tse.status.az.driveangle_deg <= WARNANGLE_CC))
m_azdrangle->
setPixmap(m_az_ind->draw(ud.tse.status.az.driveangle_deg,
m_azel_ind_size,true,true,
azindcolor,true));
QColor elindcolor = azel_ind_normcolor;
if((ud.tse.status.el.driveangle_deg >= WARNANGLE_UP)||
(ud.tse.status.el.driveangle_deg <= WARNANGLE_DN))
elindcolor=pcolor;
if((ud.full_update)||(ud.replay)||
(ud.tse.status.el.driveangle_deg >= WARNANGLE_UP)||
(ud.tse.status.el.driveangle_deg <= WARNANGLE_DN))
m_eldrangle->
setPixmap(m_el_ind->draw(ud.tse.status.el.driveangle_deg,
m_azel_ind_size,true,true,
elindcolor,true));
}
if((ud.full_update)||(ud.replay))
{
m_azdrangle->setEnabled(true);
m_eldrangle->setEnabled(true);
QString tel_az;
QString tel_el;
if(m_sv == SV_ENCODER)
{
tel_az = QString("Enc: ")
+Angle::makeDeg(ud.tse.status.az.driveangle_deg)
.degString(2);
tel_el = QString("Enc: ")
+ Angle::makeDeg(ud.tse.status.el.driveangle_deg)
.degPM180String(2);
}
else
{
tel_az = ud.tel_azel.phi().degString(2);
tel_el = ud.tel_azel.latitude().degPM180String(2);
}
m_tel_az->setText(MAKEDEG(tel_az));
m_tel_az->setEnabled(true);
m_tel_el->setText(MAKEDEG(tel_el));
m_tel_el->setEnabled(true);
std::ostringstream az_speed_stream;
az_speed_stream << std::showpos << std::fixed
<< std::setprecision(3) << ud.az_smooth_speed;
m_azspeed->setText(MAKEDEG(az_speed_stream.str())+"/s");
m_azspeed->setEnabled(true);
std::ostringstream el_speed_stream;
el_speed_stream << std::showpos << std::fixed
<< std::setprecision(3) << ud.el_smooth_speed;
m_elspeed->setText(MAKEDEG(el_speed_stream.str())+"/s");
m_elspeed->setEnabled(true);
if(ud.tse.status.az.limitCwUp && ud.tse.status.az.limitCcwDown)
m_azlimit->setText("CW & CCW Limits");
else if(ud.tse.status.az.limitCwUp)
m_azlimit->setText("CW Limit");
else if(ud.tse.status.az.limitCcwDown)
m_azlimit->setText("CCW Limit");
else m_azlimit->setText("CW/CCW Limit");
activateLE(ud.tse.status.az.limitCwUp||ud.tse.status.az.limitCcwDown,
m_azlimit,color_fg_warn,color_bg_warn);
if(ud.tse.status.el.limitCwUp && ud.tse.status.el.limitCcwDown)
m_ellimit->setText("Up & Down Limits");
else if(ud.tse.status.el.limitCwUp)
m_ellimit->setText("Up Limit");
else if(ud.tse.status.el.limitCcwDown)
m_ellimit->setText("Down Limit");
else m_ellimit->setText("Up/Down Limit");
activateLE(ud.tse.status.el.limitCwUp||ud.tse.status.el.limitCcwDown,
m_ellimit,color_fg_warn,color_bg_warn);
switch(ud.tse.status.az.driveMode)
{
case ScopeAPI::DM_STANDBY:
m_azdrmode->setText("Standby");
activateLE(false,m_azdrmode,color_fg_on,color_bg_on);
break;
case ScopeAPI::DM_SLEW:
m_azdrmode->setText("Slew");
activateLE(true,m_azdrmode,color_fg_on,color_bg_on);
break;
case ScopeAPI::DM_POINT:
m_azdrmode->setText("Point");
activateLE(true,m_azdrmode,color_fg_on,color_bg_on);
break;
case ScopeAPI::DM_SPIN:
m_azdrmode->setText("Spin");
activateLE(true,m_azdrmode,color_fg_warn,color_bg_warn);
break;
case ScopeAPI::DM_SECTOR_SCAN:
m_azdrmode->setText("Scan");
activateLE(true,m_azdrmode,color_fg_warn,color_bg_warn);
break;
case ScopeAPI::DM_RASTER:
m_azdrmode->setText("Raster");
activateLE(true,m_azdrmode,color_fg_warn,color_bg_warn);
break;
case ScopeAPI::DM_CHANGING:
m_azdrmode->setText("Changing");
activateLE(true,m_azdrmode,color_fg_warn,color_bg_warn);
break;
case ScopeAPI::DM_UNKNOWN:
m_azdrmode->setText("Unknown");
activateLE(true,m_azdrmode,color_fg_warn,color_bg_warn);
break;
}
switch(ud.tse.status.el.driveMode)
{
case ScopeAPI::DM_STANDBY:
m_eldrmode->setText("Standby");
activateLE(false,m_eldrmode,color_fg_on,color_bg_on);
break;
case ScopeAPI::DM_SLEW:
m_eldrmode->setText("Slew");
activateLE(true,m_eldrmode,color_fg_on,color_bg_on);
break;
case ScopeAPI::DM_POINT:
m_eldrmode->setText("Point");
activateLE(true,m_eldrmode,color_fg_on,color_bg_on);
break;
case ScopeAPI::DM_SPIN:
m_eldrmode->setText("Spin");
activateLE(true,m_eldrmode,color_fg_warn,color_bg_warn);
break;
case ScopeAPI::DM_SECTOR_SCAN:
m_eldrmode->setText("Scan");
activateLE(true,m_eldrmode,color_fg_warn,color_bg_warn);
break;
case ScopeAPI::DM_RASTER:
m_eldrmode->setText("Raster");
activateLE(true,m_eldrmode,color_fg_warn,color_bg_warn);
break;
case ScopeAPI::DM_CHANGING:
m_eldrmode->setText("Changing");
activateLE(true,m_eldrmode,color_fg_warn,color_bg_warn);
break;
case ScopeAPI::DM_UNKNOWN:
m_eldrmode->setText("Unknown");
activateLE(true,m_eldrmode,color_fg_warn,color_bg_warn);
break;
}
bool interlock =
ud.tse.status.interlock||
ud.tse.status.interlockAzPullCord||
ud.tse.status.interlockAzStowPin||
ud.tse.status.interlockElStowPin||
ud.tse.status.interlockAzDoorOpen||
ud.tse.status.interlockElDoorOpen||
ud.tse.status.interlockSafeSwitch||
!ud.tse.status.remoteControl;
activateLE(interlock,m_interlock,color_fg_warn,color_bg_warn);
bool warn =
ud.tse.status.az.servo1Fail||
ud.tse.status.az.servo2Fail||
ud.tse.status.az.positionFault||
ud.tse.status.el.servo1Fail||
ud.tse.status.el.servo2Fail||
ud.tse.status.el.positionFault||
!ud.tse.status.checksumOK||
ud.tse.status.msgBadFrame||
ud.tse.status.msgCommandInvalid||
ud.tse.status.msgInputOverrun||
ud.tse.status.msgOutputOverrun;
activateLE(warn,m_error,color_fg_warn,color_bg_warn);
}
}
else if((ud.full_update)||(ud.replay))
{
m_tel_az->setText("");
m_tel_az->setEnabled(false);
m_tel_el->setText("");
m_tel_el->setEnabled(false);
m_azdrangle->
setPixmap(m_az_ind->draw(ud.tse.status.az.driveangle_deg,
m_azel_ind_size,false));
m_eldrangle->
setPixmap(m_el_ind->draw(ud.tse.status.el.driveangle_deg,
m_azel_ind_size,false));
m_azdrangle->setEnabled(false);
m_eldrangle->setEnabled(false);
m_azspeed->setText("");
m_azspeed->setEnabled(false);
m_elspeed->setText("");
m_elspeed->setEnabled(false);
m_azlimit->setText("CW/CCW Limit");
activateLE(false,m_azlimit,color_fg_warn,color_bg_warn);
m_ellimit->setText("Up/Down Limit");
activateLE(false,m_ellimit,color_fg_warn,color_bg_warn);
m_azdrmode->setText("Unknown");
activateLE(false,m_azdrmode,color_fg_warn,color_bg_warn);
m_eldrmode->setText("Unknown");
activateLE(false,m_eldrmode,color_fg_warn,color_bg_warn);
activateLE(false,m_interlock,color_fg_warn,color_bg_warn);
activateLE(false,m_error,color_fg_warn,color_bg_warn);
}
m_ut_date->setText(ud.date_string);
m_ut_utc->setText(ud.timeangle.hmsString(0));
m_ut_lmst->setText(ud.lmst.hmsString(0));
if(ud.tar_object)
{
if((ud.full_update)||(ud.replay))
{
m_src_name->setText(ud.tar_object->targetName(ud.mjd));
m_src_name->setEnabled(true);
}
QString src_az;
QString src_el;
if(m_sv == SV_ENCODER)
{
src_az = QString("Enc: ")
+ Angle::makeRad(ud.tar_az_driveangle).degString(2);
src_el = QString("Enc: ")
+ Angle::makeRad(ud.tar_el_driveangle).degPM180String(2);
}
else
{
src_az = ud.tar_azel.phi().degString(2);
src_el = ud.tar_azel.latitude().degPM180String(2);
}
m_src_az->setText(MAKEDEG(src_az));
m_src_az->setEnabled(true);
m_src_el->setText(MAKEDEG(src_el));
m_src_el->setEnabled(true);
if(!ud.in_limits)
{
m_src_az->setPaletteBackgroundColor(color_bg_warn);
m_src_az->setPaletteForegroundColor(color_fg_warn);
m_src_el->setPaletteBackgroundColor(color_bg_warn);
m_src_el->setPaletteForegroundColor(color_fg_warn);
}
else if((ud.target_moves)&&(fabs(ud.tar_az_speed)>ud.az_speed_limit))
{
m_src_az->unsetPalette();
if(ud.tv.tv_usec/500000==0)
{
m_src_az->setPaletteBackgroundColor(color_bg_warn);
m_src_az->setPaletteForegroundColor(color_fg_warn);
}
m_src_el->unsetPalette();
}
else if(!ud.in_limits30)
{
m_src_az->setPaletteBackgroundColor(color_bg_attn);
m_src_az->setPaletteForegroundColor(color_fg_attn);
m_src_el->setPaletteBackgroundColor(color_bg_attn);
m_src_el->setPaletteForegroundColor(color_fg_attn);
}
else if(((ud.target_moves)&&
(fabs(ud.tar_max_az_speed)>ud.az_speed_limit))||
((Angle::toDeg(ud.tar_az_driveangle)>90)&&
(Angle::toDeg(fabs(ud.tar_az_driveangle-
ud.tar_az_driveangle30))>270)))
{
m_src_az->unsetPalette();
if(ud.tv.tv_usec/500000==0)
{
m_src_az->setPaletteBackgroundColor(color_bg_attn);
m_src_az->setPaletteForegroundColor(color_fg_attn);
}
m_src_el->unsetPalette();
}
else
{
m_src_az->unsetPalette();
m_src_el->unsetPalette();
}
if(state != TelescopeController::TS_COM_FAILURE)
{
m_err_total->setText(ud.sep.deg180String(2));
m_err_total->setEnabled(true);
if((ud.latest_req==TelescopeController::REQ_TRACK)&&
(ud.sep.deg()>0.05))
{
m_err_total->setPaletteBackgroundColor(color_bg_warn);
m_err_total->setPaletteForegroundColor(color_fg_warn);
}
else
{
m_err_total->unsetPalette();
}
if(ud.az_sep>0)
m_err_az->setText(MAKEDEG(Angle::makeDeg(ud.az_sep).degString(2)));
else
{
QString txt = MAKEDEG(Angle::makeDeg(-ud.az_sep).degString(2));
m_err_az->setText(QString("-")+txt.right(txt.length()-1));
}
m_err_az->setEnabled(true);
if(ud.el_sep>0)
m_err_el->setText(MAKEDEG(Angle::makeDeg(ud.el_sep).
degPM180String(2)));
else
{
QString txt = MAKEDEG(Angle::makeDeg(-ud.el_sep).
degPM180String(2));
m_err_el->setText(QString("-")+txt.right(txt.length()-1));
}
m_err_el->setEnabled(true);
if((state==TelescopeController::TS_TRACK)&&(ud.sep.deg()<0.05))
{
m_err_eta->setText("");
m_err_eta->setEnabled(false);
}
else
{
m_err_eta->setText(ud.eta_string);
m_err_eta->setEnabled(true);
}
}
else
{
m_err_total->setText("");
m_err_total->setEnabled(false);
m_err_az->setText("");
m_err_az->setEnabled(false);
m_err_el->setText("");
m_err_el->setEnabled(false);
m_err_eta->setText("");
m_err_eta->setEnabled(false);
}
}
else if((ud.full_update)||(ud.replay))
{
m_src_name->setText("");
m_src_name->setEnabled(false);
m_src_az->setText("");
m_src_az->setEnabled(false);
m_src_el->setText("");
m_src_el->setEnabled(false);
m_err_total->setText("");
m_err_total->setEnabled(false);
m_err_az->setText("");
m_err_az->setEnabled(false);
m_err_el->setText("");
m_err_el->setEnabled(false);
m_err_eta->setText("");
m_err_eta->setEnabled(false);
}
if((ud.full_update)||(ud.replay))
m_selector->updateButtons(controlsEnabled(), ud.tse.state, ud.tse.req);
m_selector->animateButtons();
}
void ClsQHarborImpl::slotSaveParamSet() {
#ifdef DEBUG_CLSQHARBORIMPL
cout << "ClsQHarborImpl::slotSaveParamSet()" << endl;
#endif
QString qstrFileName = "";
bool bValidFile = false;
while(!bValidFile) {
qstrFileName = QFileDialog::getSaveFileName(
/*QDir::homeDirPath ()*/ "",
"Harbor ParamSet (*.pconf)",
this,
"Save File"
"Choose a filename to save under" );
/* append default extension here */
QString qstrExtension( ".pconf" );
QString qstrCurrentTail = qstrFileName.right(qstrExtension.length());
if(qstrCurrentTail.compare(qstrExtension)) {
qstrFileName.append(qstrExtension);
}
/* ------------------------------ */
QFileInfo qFileInfo(qstrFileName );
QString qstrPath = qFileInfo.dirPath(true);
qFileInfo.setFile (qstrPath);
if ( !qFileInfo.isWritable() ) {
int iReturn = QMessageBox::critical( this, "iqr",
"No permission to write in this directory\n",
"Retry", "Cancel", 0, 0, 1 );
if(iReturn == 1) {
return;
}
} else {
bValidFile = true;
}
}
if(qstrFileName.length()<=0) {
return;
}
if ( QFile::exists(qstrFileName) ) {
/* warning on overwrite */
int iReturn = QMessageBox::warning( this, "iqr",
"A file with the seleteced name exists\n",
"Overwrite", "Cancel", 0, 0, 1 );
if(iReturn == 1) {
return;
}
}
QDomDocument doc( "ParamSet" );
QDomElement root = doc.createElement( "ParamSet" );
doc.appendChild( root );
for(int ii = 0; ii<qtableEntries->numRows(); ii++) {
QDomElement parameter = doc.createElement( "Parameter" );
parameter.setAttribute ( "itemType", qtableEntries->text(ii, COL_TYPE) );
parameter.setAttribute ( "itemID", qtableEntries->text(ii, COL_ID) );
parameter.setAttribute ( "name", qtableEntries->text(ii, COL_PARAM_NAME) );
parameter.setAttribute ( "value", qtableEntries->text(ii, COL_VALUE) );
root.appendChild( parameter );
}
QString xml = doc.toString();
// cout << xml << endl;
QFile file(qstrFileName);
if ( file.open( IO_WriteOnly ) ) {
QTextStream stream( &file );
stream << doc.toString() << "\n";
file.close();
}
}
void Irc::parse(QString raw) {
if (raw.startsWith(':'))
raw = raw.right(raw.length() - 1);
#ifdef COLOR_WIPE
QString xraw; int len = 0; int olen = raw.length();
// dirty but useful color removal code
do {
do {
if ( raw [len] == '\003' ) { // color, veo muuucho color
len += 2;
if ( raw [len].isNumber() ) len++;
if ( raw [len] == ',' && raw [len+1].isDigit() ) { // color, veo aúuuun más color
len += 2;
if ( raw [len].isNumber() ) len++;
}
} else if ( raw [len] == '\002' || raw [len] == '\026' || raw [len] == '\035' ) // blablalba
len++;
} while ( raw [len] == '\003' || raw [len] == '\002'|| raw [len] == '\026'||
raw [len] == '\035' ); // esto es una guarrada pero evita varios control codes consecutivos
xraw.append(raw[len]);
len++;
} while( len < olen );
raw = xraw;
#endif
QStringList matrix = raw.split(' ');
if( matrix[0] == "PING" ) { // Recibido ping, pongoneamos.
sendData("PONG " + matrix[1]);
emit PingPong();
} else if ( matrix[0] == "ERROR" ) { // error de conexion, whichever
emit connError(raw.right(raw.length() - 7)); //quita el "ERROR :" del principio y deja el msj limpio
} else if ( matrix[1] == "PRIVMSG" || matrix[1] == "NOTICE" ) {
QString nick = matrix[0].left(matrix[0].indexOf('!'));
QString message = raw.right((raw.length() - 2) - raw.indexOf(" :"));
QString mask = matrix[0].mid(matrix[0].indexOf('!') + 1,(matrix[0].indexOf(" PRIVMSG") - nick.length()));
if ( matrix[1] == "PRIVMSG" ) {
if ( matrix[2].startsWith("#") ) { // mensaje de canal
if ( message.startsWith("\001") ) // /ctcp
if ( message.startsWith("\001ACTION ")) // me
emit chanme ( nick, mask, matrix[2], message.right((message.length() - 8)) );
else
emit chanctcp ( nick, mask, matrix[2], message.right((message.length() - 1)) );
else
emit chanmsg ( nick, mask, matrix[2], message );
} else { // mensaje en privado
if ( message.startsWith("\001") ) // /me
if ( message.startsWith("\001ACTION ")) // me
emit queryme ( nick, mask, message.right((message.length() - 8)) );
else
emit queryctcp ( nick, mask, message.right((message.length() - 1)) );
else
emit querymsg ( nick, mask, message );
}
} else if ( matrix[1] == "NOTICE" ) {
if ( matrix[2].startsWith("#") ) { // notice en canal
emit channotice ( nick, mask, matrix[2], message );
} else { // notice en privado
emit querynotice ( nick, mask, message );
}
}
} else if ( matrix[1] == "JOIN" ) { //join a un canal
QString nick = matrix[0].left(matrix[0].indexOf('!'));
QString mask = matrix[0].mid(matrix[0].indexOf('!') + 1,(matrix[0].indexOf(" JOIN") - nick.length()));
if( matrix[2].startsWith(':') )
emit join(nick,mask,matrix[2].right( matrix[2].length() -1 ));
else
emit join(nick,mask,matrix[2]);
} else if ( matrix[1] == "PART" || matrix[1] == "QUIT" ) { //handled together
QString message = "", chan = "";
if (raw.indexOf(" :") != -1)
message = raw.right((raw.length() - 2) - raw.indexOf(" :"));
QString nick = matrix[0].left(matrix[0].indexOf('!'));
QString mask = matrix[0].mid(matrix[0].indexOf('!') + 1,(matrix[0].indexOf(" PART") - nick.length()));
if ( matrix[1] == "PART" ) {
QString chan = raw.right((raw.length() - 1) - raw.indexOf(" #"));
chan = chan.left(chan.indexOf(" :"));
QString mask = matrix[0].mid(matrix[0].indexOf('!') + 1,(matrix[0].indexOf(" PART") - nick.length()));
emit part(nick,mask,chan,message);
} else if ( matrix[1] == "QUIT" ) {
QString mask = matrix[0].mid(matrix[0].indexOf('!') + 1,(matrix[0].indexOf(" QUIT") - nick.length()));
emit quit(nick,mask,message);
}
} else if ( matrix[1] == "NICK" ) {
QString nick = matrix[0].left(matrix[0].indexOf('!'));
QString mask = matrix[0].mid(matrix[0].indexOf('!') + 1,(matrix[0].indexOf(" NICK") - nick.length()));
QString newnick = raw.right((raw.length() - 2) - raw.indexOf(" :"));
if (newnick == ownNick)
emit ownNickChange(newnick);
emit nickChange(nick,mask,newnick);
} else if ( matrix[1] == "MODE" ) { // cambio de modo, pero no sé si es de usuario o canal.
if ( matrix[2].startsWith('#') ) { // c mode
QString nick = matrix[0].left(matrix[0].indexOf('!'));
QString mask = matrix[0].mid(matrix[0].indexOf('!') + 1,(matrix[0].indexOf(" MODE") - nick.length()));
QString chan = matrix[2];
QString mode = raw.right((raw.length() - raw.indexOf(" #")) - chan.length() - 2);
emit modeChange(nick,mask,chan,mode);
} else { // u mode
if( matrix[3].startsWith(':') )
emit umodeChange(matrix[0],matrix[2],matrix[3].right( matrix[3].length() -1 ));
else
emit umodeChange(matrix[0],matrix[2],matrix[3]);
}
} else if ( matrix[1] == "KICK" ) { // expulsión del canal
if ( matrix[2].startsWith('#') ) { // c mode
QString nick = matrix[0].left(matrix[0].indexOf('!'));
QString mask = matrix[0].mid(matrix[0].indexOf('!') + 1,(matrix[0].indexOf(" KICK") - nick.length()));
QString chan = matrix[2];
QString kicked = matrix[3];
QString message;
if (raw.indexOf(" :") != -1)
message = raw.right((raw.length() - 2) - raw.indexOf(" :"));
emit kick(nick,mask,chan,kicked,message);
}
else // u mode
emit umodeChange(matrix[0],matrix[2],raw.right((raw.length() - 2) - raw.indexOf(" :")));
}
bool isInt;
int code_msg = matrix[1].toInt( &isInt );
if( isInt ) {
switch ( code_msg ) {
case 001: // me es útil, así sé con qué nick entro xD
emit ownNickChange(matrix[2]);
ownNick = matrix[2];
if (!chans.isEmpty()) {
sendData("JOIN ",true);
sendData(chans);
}
status = STATUS_IDLE;
emit signedIn();
break;
case 254: // número de canales formados
emit totalChans(matrix[3]);
case 321: // chanlist begin
handleChanlist(false);
break;
case 322: // chanlist
handleChanlist(matrix[3],matrix[4],raw.right((raw.length() - 2) - raw.indexOf(" :")));
break;
case 323: // chanlist end
handleChanlist(true);
break;
case 332: //topic
emit topic(matrix[3],raw.right((raw.length() - 2) - raw.indexOf(" :")));
break;
case 333: //topic timestamp
emit topicTime(matrix[3],matrix[4],matrix[5]);
break;
case 353: // names
emit names(matrix[4], raw.right((raw.length() - 2) - raw.indexOf(" :")));
break;
case 366: // fin de /names
emit namesEnd(matrix[3]);
break;
case 372: // texto de motd
emit motd( raw.right((raw.length() - 2) - raw.indexOf(" :")));
break;
case 375: // inicio de motd
emit motdStart( raw.right((raw.length() - 2) - raw.indexOf(" :")));
break;
case 376: // fin de motd
emit motdEnd( raw.right((raw.length() - 2) - raw.indexOf(" :")));
break;
case 433: // nick en uso!
getNewRandomNick();
break;
case 471:
qDebug() << matrix[3] << "Cannot join channel (+l)";
break;
case 473:
qDebug() << matrix[3] << "Cannot join channel (+i)";
break;
case 474:
qDebug() << matrix[3] << "Cannot join channel (+b)";
break;
case 475:
qDebug() << matrix[3] << "Cannot join channel (+k)";
break;
default:
//qDebug() << "Numeric NO MANEJADO!" << matrix[1] << endl;
break;
}
}
}
/** \brief Handle a MythTV action for the Menus.
*
* \param action single action to be handled
* \return true if the action is not to EXEC another program
*/
bool MythThemedMenu::handleAction(const QString &action, const QString &password)
{
MythUIMenuCallbacks *cbs = GetMythUI()->GetMenuCBs();
if (((password == "SetupPinCode") &&
GetMythDB()->GetNumSetting("SetupPinCodeRequired", 0)) ||
(!password.isEmpty() && password != "SetupPinCode"))
{
if (!checkPinCode(password))
return true;
}
if (action.left(5) == "EXEC ")
{
QString rest = action.right(action.length() - 5);
if (cbs && cbs->exec_program)
cbs->exec_program(rest);
return false;
}
else if (action.left(7) == "EXECTV ")
{
QString rest = action.right(action.length() - 7).trimmed();
if (cbs && cbs->exec_program_tv)
cbs->exec_program_tv(rest);
}
else if (action.left(5) == "MENU ")
{
QString menu = action.right(action.length() - 5);
MythScreenStack *stack = GetScreenStack();
MythThemedMenu *newmenu = new MythThemedMenu("", menu, stack, menu,
false, m_state);
if (newmenu->foundTheme())
stack->AddScreen(newmenu);
else
delete newmenu;
}
else if (action.left(6) == "UPMENU")
{
m_wantpop = true;
}
else if (action.left(12) == "CONFIGPLUGIN")
{
QString rest = action.right(action.length() - 13);
if (cbs && cbs->configplugin)
cbs->configplugin(rest);
}
else if (action.left(6) == "PLUGIN")
{
QString rest = action.right(action.length() - 7);
if (cbs && cbs->plugin)
cbs->plugin(rest);
}
else if (action.left(8) == "SHUTDOWN")
{
if (m_allocedstate)
{
m_wantpop = true;
}
}
else if (action.left(5) == "EJECT")
{
if (cbs && cbs->eject)
cbs->eject();
}
else if (action.left(5) == "JUMP ")
{
QString rest = action.right(action.length() - 5);
GetMythMainWindow()->JumpTo(rest, false);
}
else if (action.left(6) == "MEDIA ")
{
// the format is MEDIA HANDLER URL
// TODO: allow spaces in the url
QStringList list = action.simplified().split(' ');
if (list.size() >= 3)
GetMythMainWindow()->HandleMedia(list[1], list[2]);
}
else
{
m_selection = action;
if (m_state->m_callback)
m_state->m_callback(m_state->m_callbackdata, m_selection);
else
VERBOSE(VB_IMPORTANT, "Unknown menu action: " + action);
}
return true;
}
int NetEin:: list_net(QString flag)
{
int pos = 0;
int pos1 = 0;
int i = 0;
int j;
QStringList adresse_;
QString adresse_eigen;
QString adresse2;
QString befehl;
QString homepath = QDir::homePath();
QString hostname_;
hostname_ = hostname();
// Eigenen Rechner nicht anzeigen
adresse_eigen = IP("localhost");
i = adresse_eigen.indexOf("name_query");
if (i > -1)
adresse_eigen = IP(hostname_);
adresse_ = adresse_eigen.split(" ");
adresse_eigen = adresse_[0];
//smbtree: zuverlässige und schnelle Linux-Rechner Suche. Windows-Rechner werden aber nicht erkannt
// -N verhindert die sudo-Abfrage
befehl = "smbtree -N 1> " + homepath + "/.config/qt5-fsarchiver/smbtree.txt";
system (befehl.toLatin1().data());
QFile file(homepath + "/.config/qt5-fsarchiver/smbtree.txt");
QTextStream ds(&file);
QString text = ds.readLine();
if (file.open(QIODevice::ReadWrite | QIODevice::Text)) {
text = ds.readLine();
while (!ds.atEnd()) {
text = ds.readLine();
// text = text.toLower();
pos = text.indexOf("IPC$ ");
if (pos > -1){
pos1 = text.indexOf(hostname_);
text = text.left(pos-1);
text = text.trimmed();
j = text.size();
text = text.right(j-2);
// if (pos1 == -1) {
text = text.toLower();
text = IP(text); // IP ermitteln
adresse_ = text.split(" ");
adresse2 = adresse_[0];
if (adresse2 != adresse_eigen){ // Eigenen Rechner nicht anzeigen
widget_net[i]= text;
i++;}
if (i > 99)
break;
// }
}}
}
file.close();
//Auswertung findsmb-qts Windows-Rechner werden erkannt
befehl = "findsmb-qt5 1> " + homepath + "/.config/qt5-fsarchiver/findsmb-qt.txt";
system (befehl.toLatin1().data());
QFile file1(homepath + "/.config/qt5-fsarchiver/findsmb-qt.txt");
QTextStream ds1(&file1);
QString adresse = ds1.readLine();
QString adresse1;
int k;
// Eigenen Rechner nicht anzeigen
hostname_ = hostname();
adresse_eigen = IP("localhost");
i = adresse_eigen.indexOf("name_query");
if (i > -1)
adresse_eigen = IP(hostname_);
adresse_ = adresse_eigen.split(" ");
adresse_eigen = adresse_[0];
if (file1.open(QIODevice::ReadWrite | QIODevice::Text)) {
for (k = 0; k < 5; k++){
adresse = ds1.readLine();
}
while (!ds1.atEnd()) {
adresse = ds1.readLine();
adresse = adresse.toLower();
k = adresse.size();
if (k > 0)
{ //findsmb findet die IP-Adresse nicht
adresse_ = adresse.split(" ");
j = adresse_[0].size();
adresse2 = adresse_[0];
adresse = adresse.right(k-j);
adresse = adresse.trimmed();
adresse_ = adresse.split(" ");
adresse = adresse_[0];
pos = adresse.indexOf("+");
if (pos == -1)
{
adresse = IP(adresse);
// Prüfung ob adresse im Array widget_net schon vorhanden ist
k = 0;
if (adresse2 != adresse_eigen) // Eigenen Rechner nicht anzeigen
k = Array_pruefen(adresse2);
if (k == 2) {
listWidget_net->addItem(adresse);
widget_net[i]= adresse;
i++;
}
}
}
}
}
file1.close();
// Dateien entfernen
if (file1.exists()){
befehl = "rm ~/.config/qt5-fsarchiver/findsmb-qt.txt";
system (befehl.toLatin1().data());
}
list_net_ssh(" ");
//Ermitteln widget_net Belegung
if (widget_net[0] == "" && flag == "1"){
QMessageBox::about(this,tr("Note","Hinweis"),
tr("There is currently no available network computer.\n","Es ist derzeit kein Netzwerkrechner.\n"));
return 1;
}
return 0;
}
void Xport::EditCart()
{
QString where="";
RDCart *cart;
int cart_number;
int include_cuts=0;
QString group_name;
QString value;
int number;
bool ok;
int line;
QString macro;
bool length_changed=false;
//
// Verify Post
//
if(!xport_post->getValue("CART_NUMBER",&cart_number)) {
XmlExit("Missing CART_NUMBER",400);
}
xport_post->getValue("INCLUDE_CUTS",&include_cuts);
//
// Verify User Perms
//
if(!xport_user->cartAuthorized(cart_number)) {
XmlExit("No such cart",404);
}
if(!xport_user->modifyCarts()) {
XmlExit("Unauthorized",401);
}
if(xport_post->getValue("GROUP_NAME",&group_name)) {
if(!xport_user->groupAuthorized(group_name)) {
XmlExit("No such group",404);
}
}
//
// Process Request
//
cart=new RDCart(cart_number);
if(!cart->exists()) {
delete cart;
XmlExit("No such cart",404);
}
if(xport_post->getValue("FORCED_LENGTH",&value)) {
number=RDSetTimeLength(value);
if(cart->type()==RDCart::Macro) {
delete cart;
XmlExit("Unsupported operation for cart type",403);
}
if(!cart->validateLengths(number)) {
delete cart;
XmlExit("Forced length out of range",403);
}
}
switch(cart->type()) {
case RDCart::Audio:
break;
case RDCart::Macro:
line=0;
while(xport_post->getValue(QString().sprintf("MACRO%d",line++),&value)) {
value.stripWhiteSpace();
if(value.right(1)!="!") {
delete cart;
XmlExit("Invalid macro data",400);
}
macro+=value;
}
cart->setMacros(macro);
break;
case RDCart::All:
break;
}
if(!group_name.isEmpty()) {
cart->setGroupName(group_name);
}
if(xport_post->getValue("TITLE",&value)) {
cart->setTitle(value);
}
if(xport_post->getValue("ARTIST",&value)) {
cart->setArtist(value);
}
if(xport_post->getValue("ALBUM",&value)) {
cart->setAlbum(value);
}
if(xport_post->getValue("YEAR",&value)) {
number=value.toInt(&ok);
if((ok)&&(number>0)) {
cart->setYear(number);
}
}
if(xport_post->getValue("LABEL",&value)) {
cart->setLabel(value);
}
if(xport_post->getValue("CLIENT",&value)) {
cart->setClient(value);
}
if(xport_post->getValue("AGENCY",&value)) {
cart->setAgency(value);
}
if(xport_post->getValue("PUBLISHER",&value)) {
cart->setPublisher(value);
}
if(xport_post->getValue("COMPOSER",&value)) {
cart->setComposer(value);
}
if(xport_post->getValue("USER_DEFINED",&value)) {
cart->setUserDefined(value);
}
if(xport_post->getValue("USAGE_CODE",&value)) {
number=value.toInt(&ok);
if((ok)&&(number>0)) {
cart->setUsageCode((RDCart::UsageCode)number);
}
}
if(xport_post->getValue("ENFORCE_LENGTH",&value)) {
number=value.toInt(&ok);
if((ok)&&(number>=0)&&(number<2)) {
cart->setEnforceLength(number);
length_changed=true;
}
}
if(xport_post->getValue("FORCED_LENGTH",&value)) {
cart->setForcedLength(RDSetTimeLength(value));
length_changed=true;
}
if(xport_post->getValue("ASYNCRONOUS",&value)) {
number=value.toInt(&ok);
if((ok)&&(number>=0)&&(number<2)) {
cart->setAsyncronous(number);
length_changed=true;
}
}
if(xport_post->getValue("OWNER",&value)) {
cart->setOwner(value);
}
if(xport_post->getValue("NOTES",&value)) {
cart->setNotes(value);
}
if(xport_post->getValue("SCHED_CODES",&value)) {
cart->setSchedCodes(value);
}
if(length_changed) {
cart->updateLength();
}
printf("Content-type: application/xml\n");
printf("Status: 200\n\n");
printf("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n");
printf("<cartList>\n");
printf("%s",(const char *)cart->xml(include_cuts));
delete cart;
printf("</cartList>\n");
Exit(0);
}
int Bully::extractPortFromIPnPort(QString nodeIPnPort) {
return nodeIPnPort.right(nodeIPnPort.length() - nodeIPnPort.indexOf(":") - 1).toInt();
}
int main(int argc, char *argv[])
{
QCoreApplication application(argc, argv);
application.addLibraryPath(".");
QTextStream out(stdout, QIODevice::WriteOnly);
if (application.argc() > 1)
{
QString databaseURL;
QString username;
QString passwd;
QString arguments;
QString xml_file = QString::null;
int report_grade = 0;
for (int counter = 1; counter < application.argc(); counter++)
{
QString arguments(application.argv()[counter]);
if (arguments.startsWith("-databaseURL=", Qt::CaseInsensitive))
databaseURL = arguments.right(arguments.length() - 13);
else if (arguments.startsWith("-username="******"-passwd=", Qt::CaseInsensitive))
passwd = arguments.right(arguments.length() - 8);
else if (arguments.startsWith("-f=", Qt::CaseInsensitive))
xml_file = arguments.right(arguments.length() - 3);
else if (arguments.startsWith("-grade=", Qt::CaseInsensitive))
report_grade = (arguments.right(arguments.length() - 7)).toInt();
else if(!arguments.startsWith("-"))
xml_file = arguments;
}
QString report_name = QString::null;
QString report_desc = QString::null;
QString report_src = QString::null;
if(xml_file != "") {
QFile file(xml_file);
if(file.open( QIODevice::ReadOnly )) {
QDomDocument doc;
QString errMsg;
int errLine, errCol;
if(doc.setContent(&file, &errMsg, &errLine, &errCol)) {
QDomElement root = doc.documentElement();
if(root.tagName() == "report") {
for(QDomNode n = root.firstChild();
!n.isNull(); n = n.nextSibling() ) {
if(n.nodeName() == "name") {
report_name = n.firstChild().nodeValue();
} else if(n.nodeName() == "description") {
report_desc = n.firstChild().nodeValue();
}
}
report_src = doc.toString();
if(report_name == "") {
out << "The document " << xml_file << " does not have a report name defined." << endl;
}
} else {
out << "XML Document " << xml_file << " does not have root node of report." << endl;
}
} else {
out << "Error parsing file " << xml_file << ": " << errMsg << " on line " << errLine << " column " << errCol << endl;
}
} else {
out << "Could not open the specified file: " << xml_file << endl;
}
} else {
out << "You must specify an XML file to load by using the -f= parameter." << endl;
}
if(report_name == "" || report_src == "") {
// an error message already should have been displayed to the user
exit(-1);
}
if ( (databaseURL != "") &&
(username != "") &&
(passwd != "") ) {
QSqlDatabase db;
// Open the Database Driver
db = databaseFromURL( databaseURL );
if (!db.isValid())
{
out << "Could not load the specified database driver." << endl;
exit(-1);
}
// Try to connect to the Database
db.setUserName(username);
db.setPassword(passwd);
if (!db.open())
{
out << "Host=" << db.hostName() << ", Database=" << db.databaseName() << ", port=" << db.port() << endl;
out << "Could not log into database. System Error: "
<< db.lastError().text() << endl;
exit(-1);
}
QSqlQuery().exec(getSqlFromTag("fmt05", db.driverName())); // MANU
// first we need to determine if there is already a report in the database of the same
// name and if so then we will perform an update instead of an insert
QSqlQuery qry;
qry.prepare(getSqlFromTag("fmt09", db.driverName())); // MANU
qry.bindValue(":report_name", report_name);
qry.bindValue(":report_grade", report_grade);
qry.exec();
QSqlQuery query;
if(qry.first()) {
// update
query.prepare(getSqlFromTag("fmt10", db.driverName())); // MANU
query.bindValue(":report_desc", report_desc);
query.bindValue(":report_src", report_src);
query.bindValue(":report_id", qry.value(0));
query.bindValue(":report_name", report_name);
} else {
// insert
query.prepare(getSqlFromTag("fmt11", db.driverName())); // MANU
query.bindValue(":report_name", report_name);
query.bindValue(":report_desc", report_desc);
query.bindValue(":report_src", report_src);
query.bindValue(":report_grade", report_grade);
}
if(!query.exec()) {
QSqlError err = query.lastError();
out << "Error: " << err.driverText() << endl
<< "\t" << err.databaseText() << endl;
exit(-1);
}
}
else if (databaseURL == "")
out << "You must specify a Database URL by using the -databaseURL= parameter." << endl;
else if (username == "")
out << "You must specify a Database Username by using the -username= parameter." << endl;
else if (passwd == "")
out << "You must specify a Database Password by using the -passwd= parameter." << endl;
}
else
out << "Usage: import -databaseURL='$' -username='******' -passwd='$' -grade=# -f='$'" << endl;
return 0;
}
void ClangAssistProposalItem::applyContextualContent(TextEditor::TextEditorWidget *editorWidget,
int basePosition) const
{
const CodeCompletion ccr = codeCompletion();
QString toInsert = text();
QString extraChars;
int extraLength = 0;
int cursorOffset = 0;
bool autoParenthesesEnabled = true;
if (m_completionOperator == T_SIGNAL || m_completionOperator == T_SLOT) {
extraChars += QLatin1Char(')');
if (m_typedChar == QLatin1Char('(')) // Eat the opening parenthesis
m_typedChar = QChar();
} else if (m_completionOperator == T_STRING_LITERAL || m_completionOperator == T_ANGLE_STRING_LITERAL) {
if (!toInsert.endsWith(QLatin1Char('/'))) {
extraChars += QLatin1Char((m_completionOperator == T_ANGLE_STRING_LITERAL) ? '>' : '"');
} else {
if (m_typedChar == QLatin1Char('/')) // Eat the slash
m_typedChar = QChar();
}
} else if (ccr.completionKind() == CodeCompletion::KeywordCompletionKind) {
CompletionChunksToTextConverter converter;
converter.setAddPlaceHolderPositions(true);
converter.setAddSpaces(true);
converter.setAddExtraVerticalSpaceBetweenBraces(true);
converter.parseChunks(ccr.chunks());
toInsert = converter.text();
if (converter.hasPlaceholderPositions())
cursorOffset = converter.placeholderPositions().at(0) - converter.text().size();
} else if (!ccr.text().isEmpty()) {
const TextEditor::CompletionSettings &completionSettings =
TextEditor::TextEditorSettings::instance()->completionSettings();
const bool autoInsertBrackets = completionSettings.m_autoInsertBrackets;
if (autoInsertBrackets &&
(ccr.completionKind() == CodeCompletion::FunctionCompletionKind
|| ccr.completionKind() == CodeCompletion::DestructorCompletionKind
|| ccr.completionKind() == CodeCompletion::SignalCompletionKind
|| ccr.completionKind() == CodeCompletion::SlotCompletionKind)) {
// When the user typed the opening parenthesis, he'll likely also type the closing one,
// in which case it would be annoying if we put the cursor after the already automatically
// inserted closing parenthesis.
const bool skipClosingParenthesis = m_typedChar != QLatin1Char('(');
if (completionSettings.m_spaceAfterFunctionName)
extraChars += QLatin1Char(' ');
extraChars += QLatin1Char('(');
if (m_typedChar == QLatin1Char('('))
m_typedChar = QChar();
// If the function doesn't return anything, automatically place the semicolon,
// unless we're doing a scope completion (then it might be function definition).
const QChar characterAtCursor = editorWidget->characterAt(editorWidget->position());
bool endWithSemicolon = m_typedChar == QLatin1Char(';')/*
|| (function->returnType()->isVoidType() && m_completionOperator != T_COLON_COLON)*/; //###
const QChar semicolon = m_typedChar.isNull() ? QLatin1Char(';') : m_typedChar;
if (endWithSemicolon && characterAtCursor == semicolon) {
endWithSemicolon = false;
m_typedChar = QChar();
}
// If the function takes no arguments, automatically place the closing parenthesis
if (!isOverloaded() && !ccr.hasParameters() && skipClosingParenthesis) {
extraChars += QLatin1Char(')');
if (endWithSemicolon) {
extraChars += semicolon;
m_typedChar = QChar();
}
} else if (autoParenthesesEnabled) {
const QChar lookAhead = editorWidget->characterAt(editorWidget->position() + 1);
if (MatchingText::shouldInsertMatchingText(lookAhead)) {
extraChars += QLatin1Char(')');
--cursorOffset;
if (endWithSemicolon) {
extraChars += semicolon;
--cursorOffset;
m_typedChar = QChar();
}
}
}
}
#if 0
if (autoInsertBrackets && data().canConvert<CompleteFunctionDeclaration>()) {
if (m_typedChar == QLatin1Char('('))
m_typedChar = QChar();
// everything from the closing parenthesis on are extra chars, to
// make sure an auto-inserted ")" gets replaced by ") const" if necessary
int closingParen = toInsert.lastIndexOf(QLatin1Char(')'));
extraChars = toInsert.mid(closingParen);
toInsert.truncate(closingParen);
}
#endif
}
// Append an unhandled typed character, adjusting cursor offset when it had been adjusted before
if (!m_typedChar.isNull()) {
extraChars += m_typedChar;
if (cursorOffset != 0)
--cursorOffset;
}
// Avoid inserting characters that are already there
const int endsPosition = editorWidget->position(TextEditor::EndOfLinePosition);
const QString existingText = editorWidget->textAt(editorWidget->position(), endsPosition - editorWidget->position());
int existLength = 0;
if (!existingText.isEmpty() && ccr.completionKind() != CodeCompletion::KeywordCompletionKind) {
// Calculate the exist length in front of the extra chars
existLength = toInsert.length() - (editorWidget->position() - basePosition);
while (!existingText.startsWith(toInsert.right(existLength))) {
if (--existLength == 0)
break;
}
}
for (int i = 0; i < extraChars.length(); ++i) {
const QChar a = extraChars.at(i);
const QChar b = editorWidget->characterAt(editorWidget->position() + i + existLength);
if (a == b)
++extraLength;
else
break;
}
toInsert += extraChars;
// Insert the remainder of the name
const int length = editorWidget->position() - basePosition + existLength + extraLength;
editorWidget->setCursorPosition(basePosition);
editorWidget->replace(length, toInsert);
if (cursorOffset)
editorWidget->setCursorPosition(editorWidget->position() + cursorOffset);
// indent the statement
if (ccr.completionKind() == CodeCompletion::KeywordCompletionKind) {
auto selectionCursor = editorWidget->textCursor();
selectionCursor.setPosition(basePosition);
selectionCursor.setPosition(basePosition + toInsert.size(), QTextCursor::KeepAnchor);
auto basePositionCursor = editorWidget->textCursor();
basePositionCursor.setPosition(basePosition);
if (hasOnlyBlanksBeforeCursorInLine(basePositionCursor))
editorWidget->textDocument()->autoIndent(selectionCursor);
}
}
int
QUimTextUtil::deletePrimaryTextInQLineEdit( enum UTextOrigin origin,
int former_req_len,
int latter_req_len )
{
QLineEdit *edit = static_cast<QLineEdit *>( mWidget );
QString text;
int len, precedence_len, following_len;
int preedit_len;
int former_del_start;
int latter_del_end;
preedit_len = mIc->getPreeditString().length();
text = edit->text(); // excluding preedit string
len = text.length();
precedence_len = edit->cursorPosition();
following_len = len - precedence_len;
switch ( origin ) {
case UTextOrigin_Cursor:
former_del_start = 0;
if ( former_req_len >= 0 ) {
if ( precedence_len > former_req_len )
former_del_start = precedence_len - former_req_len;
} else {
if (! ( ~former_req_len & ( ~UTextExtent_Line | ~UTextExtent_Full ) ) )
return -1;
}
latter_del_end = len + preedit_len;
if ( latter_req_len >= 0 ) {
if ( following_len > latter_req_len )
latter_del_end = precedence_len + preedit_len + latter_req_len;
} else {
if (! ( ~latter_req_len & ( ~UTextExtent_Line | ~UTextExtent_Full ) ) )
return -1;
}
break;
case UTextOrigin_Beginning:
former_del_start = 0;
latter_del_end = precedence_len + preedit_len;
if ( latter_req_len >= 0 ) {
if ( precedence_len < latter_req_len ) {
if ( following_len >= ( latter_req_len - precedence_len ) )
latter_del_end = preedit_len + latter_req_len;
else
latter_del_end = len + preedit_len;
}
} else {
if (! ( ~latter_req_len & ( ~UTextExtent_Line | ~UTextExtent_Full ) ) )
return -1;
latter_del_end = len + preedit_len;
}
break;
case UTextOrigin_End:
former_del_start = precedence_len;
latter_del_end = len + preedit_len;
if ( former_req_len < 0 ) {
if (! ( ~former_req_len & ( ~UTextExtent_Line | ~UTextExtent_Full ) ) )
return -1;
former_del_start = 0;
}
break;
case UTextOrigin_Unspecified:
default:
return -1;
}
edit->setText( text.left( former_del_start ) + text.right( len - latter_del_end + preedit_len ) );
edit->setCursorPosition( former_del_start );
return 0;
}
int
QUimTextUtil::acquirePrimaryTextInQTextEdit( enum UTextOrigin origin,
int former_req_len,
int latter_req_len,
char **former, char **latter )
{
QTextEdit *edit = static_cast<QTextEdit *>( mWidget );
QString text = edit->toPlainText(); // excluding preedit string
int len = text.length();
int preedit_len = mIc->getPreeditString().length();
int preedit_cursor_pos = mIc->getPreeditCursorPosition();
int cursor_index = edit->textCursor().position() + preedit_len;
int precedence_len = cursor_index - preedit_cursor_pos;
int following_len = len - precedence_len;
QString former_text;
QString latter_text;
switch ( origin ) {
case UTextOrigin_Cursor:
{
int offset = 0;
if ( former_req_len >= 0 ) {
if ( precedence_len > former_req_len )
offset = precedence_len - former_req_len;
} else {
if (! ( ~former_req_len
& ( ~UTextExtent_Line | ~UTextExtent_Full ) ) )
return -1;
}
*former = strdup(
text.mid( offset, precedence_len - offset ).toUtf8().data() );
offset = 0;
if ( latter_req_len >= 0 ) {
if ( following_len > latter_req_len )
offset = following_len - latter_req_len;
} else {
if (! ( ~latter_req_len
& ( ~UTextExtent_Line | ~UTextExtent_Full ) ) ) {
free( *former );
return -1;
}
}
*latter = strdup( text.mid( precedence_len + preedit_len,
following_len - offset ).toUtf8().data() );
break;
}
case UTextOrigin_Beginning:
*former = 0;
if ( latter_req_len >= 0 ) {
if ( precedence_len >= latter_req_len )
text = text.left( latter_req_len );
else {
former_text = text.left( precedence_len );
if ( following_len >= ( latter_req_len - precedence_len ) )
latter_text = text.mid( precedence_len + preedit_len,
( latter_req_len - precedence_len ) );
else
latter_text = text.mid( precedence_len + preedit_len,
following_len );
text = former_text + latter_text;
}
} else {
if (! ( ~latter_req_len
& ( ~UTextExtent_Line | ~UTextExtent_Full ) ) )
return -1;
former_text = text.left( precedence_len );
latter_text = text.mid( precedence_len + preedit_len,
following_len );
text = former_text + latter_text;
}
*latter = strdup( text.toUtf8().data() );
break;
case UTextOrigin_End:
if ( former_req_len >= 0 ) {
if ( following_len >= former_req_len )
text = text.right( former_req_len );
else {
latter_text = text.right( following_len );
if ( precedence_len >= ( former_req_len - following_len ) )
former_text = text.mid( precedence_len
- ( former_req_len - following_len ),
former_req_len - following_len );
else
former_text = text.left( precedence_len );
text = former_text + latter_text;
}
} else {
if (! ( ~former_req_len
& ( ~UTextExtent_Line | ~UTextExtent_Full ) ) )
return -1;
former_text = text.left( precedence_len );
latter_text = text.right( following_len );
text = former_text + latter_text;
}
*former = strdup( text.toUtf8().data() );
*latter = 0;
break;
case UTextOrigin_Unspecified:
default:
return -1;
}
return 0;
}
/* Helper function for getTimeZoneID() that provides an unprocessed time zone
id obtained using system-dependent means of identifying the system's time
zone. */
static QString getSystemTimeZoneID(void)
{
QString zone_id("UNDEF");
#ifdef USING_MINGW
// typedef struct _TIME_ZONE_INFORMATION { ...
// GetTimeZoneInformation();
// ...
// Sadly, Windows zone names are different to the (probably Unix)
// backend's names - "AUS Eastern Standard Time" vs "Australia/Sydney".
// Translation is not worthwhile. Leave it as UNDEF to check the offset.
#else
// Try to determine the time zone information by inspecting the system
// configuration
QString time_zone_file_path("/etc/timezone");
QString clock_file_path("/etc/sysconfig/clock");
QString zoneinfo_file_path("/etc/localtime");
QString zoneinfo_dir_path("/usr/share/zoneinfo");
// First, check time_zone_file_path (used by Debian-based systems)
if (read_time_zone_id(time_zone_file_path, zone_id))
return zone_id;
// Next, look for the ZONE entry in clock_file_path (used by Red Hat-based
// systems)
if (read_time_zone_id(clock_file_path, zone_id))
return zone_id;
// Next check zoneinfo_file_path
QFile zoneinfo_file(zoneinfo_file_path);
QFileInfo info(zoneinfo_file);
if (info.exists() && info.isFile())
{
QString tz;
if (info.isSymLink())
{
// The symlink refers to a file whose name contains the zone ID
tz = info.symLinkTarget();
}
else
{
// The zoneinfo_file is a copy of the file in the
// zoneinfo_dir_path, so search for the same file in
// zoneinfo_dir_path
tz = findZoneinfoFile(zoneinfo_file_path, zoneinfo_dir_path);
}
if (tz != "UNDEF")
{
int pos = 0;
// Get the zone ID from the filename
// Look for the basename of zoneinfo_dir_path in case it's a
// relative link
QString zoneinfo_dirname = zoneinfo_dir_path.section('/', -1);
if ((pos = tz.indexOf(zoneinfo_dirname)) != -1)
{
zone_id = tz.right(tz.size() - (pos + 1) -
zoneinfo_dirname.size());
}
}
else
{
// If we still haven't found a time zone, try localtime_r() to at
// least get the zone name/abbreviation (as opposed to the
// identifier for the set of rules governing the zone)
char name[64];
time_t t;
struct tm *result = (struct tm *)malloc(sizeof(*result));
if (result != NULL)
{
t = time(NULL);
localtime_r(&t, result);
if (result != NULL)
{
if (strftime(name, sizeof(name), "%Z", result) > 0)
zone_id = name;
free(result);
}
}
}
}
#endif
return zone_id;
}
void SearchLocationID::splitUrl(const QString &url_, QString &host, QString &path) const
{
int endhost = url_.find('/');
host = url_.left(endhost);
path = url_.right(url_.length() - endhost);
}
bool DecoderCUEFactory::supports(const QString &source) const
{
return source.right(4).toLower() == ".cue";
}
static ChipClass detectRadeonClass(const QString &chipset)
{
if (chipset.isEmpty())
return UnknownRadeon;
if (chipset.contains(QStringLiteral("R100")) ||
chipset.contains(QStringLiteral("RV100")) ||
chipset.contains(QStringLiteral("RS100")))
return R100;
if (chipset.contains(QStringLiteral("RV200")) ||
chipset.contains(QStringLiteral("RS200")) ||
chipset.contains(QStringLiteral("R200")) ||
chipset.contains(QStringLiteral("RV250")) ||
chipset.contains(QStringLiteral("RS300")) ||
chipset.contains(QStringLiteral("RV280")))
return R200;
if (chipset.contains(QStringLiteral("R300")) ||
chipset.contains(QStringLiteral("R350")) ||
chipset.contains(QStringLiteral("R360")) ||
chipset.contains(QStringLiteral("RV350")) ||
chipset.contains(QStringLiteral("RV370")) ||
chipset.contains(QStringLiteral("RV380")))
return R300;
if (chipset.contains(QStringLiteral("R420")) ||
chipset.contains(QStringLiteral("R423")) ||
chipset.contains(QStringLiteral("R430")) ||
chipset.contains(QStringLiteral("R480")) ||
chipset.contains(QStringLiteral("R481")) ||
chipset.contains(QStringLiteral("RV410")) ||
chipset.contains(QStringLiteral("RS400")) ||
chipset.contains(QStringLiteral("RC410")) ||
chipset.contains(QStringLiteral("RS480")) ||
chipset.contains(QStringLiteral("RS482")) ||
chipset.contains(QStringLiteral("RS600")) ||
chipset.contains(QStringLiteral("RS690")) ||
chipset.contains(QStringLiteral("RS740")))
return R400;
if (chipset.contains(QStringLiteral("RV515")) ||
chipset.contains(QStringLiteral("R520")) ||
chipset.contains(QStringLiteral("RV530")) ||
chipset.contains(QStringLiteral("R580")) ||
chipset.contains(QStringLiteral("RV560")) ||
chipset.contains(QStringLiteral("RV570")))
return R500;
if (chipset.contains(QStringLiteral("R600")) ||
chipset.contains(QStringLiteral("RV610")) ||
chipset.contains(QStringLiteral("RV630")) ||
chipset.contains(QStringLiteral("RV670")) ||
chipset.contains(QStringLiteral("RV620")) ||
chipset.contains(QStringLiteral("RV635")) ||
chipset.contains(QStringLiteral("RS780")) ||
chipset.contains(QStringLiteral("RS880")))
return R600;
if (chipset.contains(QStringLiteral("R700")) ||
chipset.contains(QStringLiteral("RV770")) ||
chipset.contains(QStringLiteral("RV730")) ||
chipset.contains(QStringLiteral("RV710")) ||
chipset.contains(QStringLiteral("RV740")))
return R700;
if (chipset.contains(QStringLiteral("EVERGREEN")) || // Not an actual chipset, but returned by R600G in 7.9
chipset.contains(QStringLiteral("CEDAR")) ||
chipset.contains(QStringLiteral("REDWOOD")) ||
chipset.contains(QStringLiteral("JUNIPER")) ||
chipset.contains(QStringLiteral("CYPRESS")) ||
chipset.contains(QStringLiteral("HEMLOCK")) ||
chipset.contains(QStringLiteral("PALM")))
return Evergreen;
if (chipset.contains(QStringLiteral("SUMO")) ||
chipset.contains(QStringLiteral("SUMO2")) ||
chipset.contains(QStringLiteral("BARTS")) ||
chipset.contains(QStringLiteral("TURKS")) ||
chipset.contains(QStringLiteral("CAICOS")) ||
chipset.contains(QStringLiteral("CAYMAN")))
return NorthernIslands;
QString name = extract(chipset, QStringLiteral("HD [0-9]{4}")); // HD followed by a space and 4 digits
if (!name.isEmpty()) {
const int id = name.right(4).toInt();
if (id == 6250 || id == 6310) // Palm
return Evergreen;
if (id >= 6000 && id < 7000)
return NorthernIslands; // HD 6xxx
if (id >= 5000 && id < 6000)
return Evergreen; // HD 5xxx
if (id >= 4000 && id < 5000)
return R700; // HD 4xxx
if (id >= 2000 && id < 4000) // HD 2xxx/3xxx
return R600;
return UnknownRadeon;
}
name = extract(chipset, QStringLiteral("X[0-9]{3,4}")); // X followed by 3-4 digits
if (!name.isEmpty()) {
const int id = name.mid(1, -1).toInt();
// X1xxx
if (id >= 1300)
return R500;
// X7xx, X8xx, X12xx, 2100
if ((id >= 700 && id < 1000) || id >= 1200)
return R400;
// X200, X3xx, X5xx, X6xx, X10xx, X11xx
if ((id >= 300 && id < 700) || (id >= 1000 && id < 1200))
return R300;
return UnknownRadeon;
}
name = extract(chipset, QStringLiteral("\\b[0-9]{4}\\b")); // A group of 4 digits
if (!name.isEmpty()) {
const int id = name.toInt();
// 7xxx
if (id >= 7000 && id < 8000)
return R100;
// 8xxx, 9xxx
if (id >= 8000 && id < 9500)
return R200;
// 9xxx
if (id >= 9500)
return R300;
if (id == 2100)
return R400;
}
return UnknownRadeon;
}
/*
Generate a value given a string, using formatting defined within this
class.
If the value can be formatted the formatted value is returned and 'ok' is true.
If the value can't be formatted an error string is returned and 'ok' is false
*/
QVariant QEStringFormatting::formatValue( const QString& text, bool& ok )
{
// Init
ok = false;
QVariant value;
// Strip unit if present
QString unitlessText = text;
if( addUnits )
{
if( dbEgu == unitlessText.right( dbEgu.length() ) )
unitlessText.chop( dbEgu.length() );
}
// Use the requested format, unless the requested format is 'default' in which case use the format determined from any value read.
formats f = format;
if( f == FORMAT_DEFAULT )
{
f = dbFormat;
}
// Format the value if an enumerated list
if( format == FORMAT_DEFAULT && dbEnumerations.size() )
{
// If value matched an enumeration, use it
for( int i = 0; i < dbEnumerations.size(); i++ )
{
if( unitlessText.compare( dbEnumerations[i] ) == 0 )
{
qulonglong ul = i;
value = QVariant( ul );
ok = true;
return value;
}
}
// Value does not match an enumeration
ok = false;
return QVariant( QString("Value does not match an enumeration value from the database.") );
}
// Format the value if a local enumerated list
if( format == FORMAT_LOCAL_ENUMERATE && localEnumerations.isDefined() )
{
return localEnumerations.textToValue( text, ok );
}
// If formating as a single value...
if( !dbFormatArray )
{
// Format the value if not enumerated
switch( f )
{
case FORMAT_DEFAULT:
{
value = QVariant( unitlessText );
ok = true;
}
break;
case FORMAT_FLOATING:
{
double d = unitlessText.toDouble( &ok );
if( ok )
{
value = QVariant( d );
}
}
break;
case FORMAT_INTEGER:
{
qlonglong ll = unitlessText.toLongLong( &ok );
if( ok )
{
value = QVariant( ll );
}
}
break;
case FORMAT_UNSIGNEDINTEGER:
{
qulonglong ul = unitlessText.toULongLong( &ok );
if( ok )
{
value = QVariant( ul );
}
}
break;
case FORMAT_TIME:
//??? to do
value = QVariant( unitlessText );
ok = true;
break;
case FORMAT_LOCAL_ENUMERATE:
//??? to do
value = QVariant( unitlessText );
ok = true;
break;
case FORMAT_STRING:
value = QVariant( unitlessText );
ok = true;
break;
};
}
// Formating as an array...
// Generally, just interpret the text as a single value and produce an array with a single value in it
// For unsigned int, however, use each character as a value as EPICS records of arrays of unsigned ints are often used for strings
// Some options don't make a lot of sense (an array of strings?)
else
{
QVariantList list;
int len = unitlessText.size();
switch( f )
{
case FORMAT_DEFAULT:
{
for( int i = 0; i < len; i++ )
{
list.append( QVariant( unitlessText[i] ));
}
// Zero terminate. Initially required for writing to area detector file name.
// (Readback string included all values up to a zero which might include parts of earlier, longer, filename)
list.append( QVariant( QChar( 0 )) );
ok = true;
}
break;
case FORMAT_FLOATING:
{
double d = unitlessText.toDouble( &ok );
if( ok )
{
list.append( QVariant( d ));
}
}
break;
case FORMAT_INTEGER:
{
qlonglong ll = unitlessText.toLongLong( &ok );
if( ok )
{
list.append( QVariant( ll ));
}
// Zero terminate. Initially required for writing to area detector file name.
// (Readback string included all values up to a zero which might include parts of earlier, longer, filename)
list.append( QVariant( (qlonglong)(0)) );
}
break;
case FORMAT_UNSIGNEDINTEGER:
{
for( int i = 0; i < len; i++ )
{
qulonglong ul = unitlessText[i].toLatin1();
list.append( QVariant( ul ));
}
// Zero terminate. Initially required for writing to area detector file name.
// (Readback string included all values up to a zero which might include parts of earlier, longer, filename)
list.append( QVariant( (qulonglong)(0) ) );
ok = true;
}
break;
case FORMAT_TIME:
//??? to do
list.append( QVariant( unitlessText ));
ok = true;
break;
case FORMAT_LOCAL_ENUMERATE:
//??? to do
list.append( QVariant( unitlessText ));
ok = true;
break;
case FORMAT_STRING:
list.append( QVariant( unitlessText ));
ok = true;
break;
}
value = list;
}
return value;
}
static ChipClass detectNVidiaClass(const QString &chipset)
{
QString name = extract(chipset, QStringLiteral("\\bNV[0-9,A-F]{2}\\b")); // NV followed by two hexadecimal digits
if (!name.isEmpty()) {
const int id = chipset.mid(2, -1).toInt(0, 16); // Strip the 'NV' from the id
switch(id & 0xf0) {
case 0x00:
case 0x10:
return NV10;
case 0x20:
return NV20;
case 0x30:
return NV30;
case 0x40:
case 0x60:
return NV40;
case 0x50:
case 0x80:
case 0x90:
case 0xA0:
return G80;
default:
return UnknownNVidia;
}
}
if (chipset.contains(QStringLiteral("GeForce2")) || chipset.contains(QStringLiteral("GeForce 256")))
return NV10;
if (chipset.contains(QStringLiteral("GeForce3")))
return NV20;
if (chipset.contains(QStringLiteral("GeForce4"))) {
if (chipset.contains(QStringLiteral("MX 420")) ||
chipset.contains(QStringLiteral("MX 440")) || // including MX 440SE
chipset.contains(QStringLiteral("MX 460")) ||
chipset.contains(QStringLiteral("MX 4000")) ||
chipset.contains(QStringLiteral("PCX 4300")))
return NV10;
return NV20;
}
// GeForce 5,6,7,8,9
name = extract(chipset, QStringLiteral("GeForce (FX |PCX |Go )?\\d{4}(M|\\b)")).trimmed();
if (!name.isEmpty()) {
if (!name[name.length() - 1].isDigit())
name.chop(1);
const int id = name.right(4).toInt();
if (id < 6000)
return NV30;
if (id >= 6000 && id < 8000)
return NV40;
if (id >= 8000)
return G80;
return UnknownNVidia;
}
// GeForce 100/200/300/400/500
name = extract(chipset, QStringLiteral("GeForce (G |GT |GTX |GTS )?\\d{3}(M|\\b)")).trimmed();
if (!name.isEmpty()) {
if (!name[name.length() - 1].isDigit())
name.chop(1);
const int id = name.right(3).toInt();
if (id >= 100 && id < 600) {
if (id >= 400)
return GF100;
return G80;
}
return UnknownNVidia;
}
return UnknownNVidia;
}
void MainObject::DispatchCommand(QString cmd)
{
bool processed=false;
int line;
QTime time;
bool ok=false;
bool overwrite=!edit_modified;
QStringList cmds;
QString verb;
cmd=cmd.stripWhiteSpace();
if(cmd.right(1)=="!") {
overwrite=true;
cmd=cmd.left(cmd.length()-1).stripWhiteSpace();
}
cmds=cmds.split(" ",cmd);
verb=cmds[0].lower();
//
// No loaded log needed for these
//
if(verb=="deletelog") {
if(rda->user()->deleteLog()) {
if(cmds.size()==2) {
Deletelog(cmds[1]);
}
else {
fprintf(stderr,"deletelog: invalid command arguments\n");
}
}
else {
fprintf(stderr,"deletelog: insufficient privileges [Delete Log]\n");
}
processed=true;
}
if((verb=="exit")||(verb=="quit")||(verb=="bye")) {
if(overwrite) {
exit(0);
}
else {
OverwriteError(verb);
}
processed=true;
}
if((verb=="help")||(verb=="?")) {
Help(cmds);
processed=true;
}
if(verb=="listlogs") {
ListLogs();
processed=true;
}
if(verb=="listservices") {
Listservices();
processed=true;
}
if(verb=="load") {
if(overwrite) {
if(cmds.size()==2) {
Load(cmds[1]);
}
else {
fprintf(stderr,"load: invalid command arguments\n");
}
}
else {
OverwriteError("load");
}
processed=true;
}
if(verb=="new") {
if(overwrite) {
if(cmds.size()==2) {
New(cmds[1]);
}
else {
fprintf(stderr,"new: invalid command arguments\n");
}
}
else {
OverwriteError("new");
}
processed=true;
}
//
// These need a log loaded
//
if((processed)||(edit_log_event!=NULL)) {
if(verb=="addcart") {
if(rda->user()->addtoLog()) {
if(cmds.size()==3) {
line=cmds[1].toInt(&ok);
if(ok&&(line>=0)) {
unsigned cartnum=cmds[2].toUInt(&ok);
if(ok&&(cartnum<=RD_MAX_CART_NUMBER)) {
Addcart(line,cartnum);
}
else {
fprintf(stderr,"addcart: invalid cart number\n");
}
}
else {
fprintf(stderr,"addcart: invalid line number\n");
}
}
else {
fprintf(stderr,"addcart: invalid command arguments\n");
}
}
else {
fprintf(stderr,"addcart: insufficient privileges [Add Log Items]\n");
}
processed=true;
}
if(verb=="addchain") {
if(rda->user()->addtoLog()) {
if(cmds.size()==3) {
line=cmds[1].toInt(&ok);
if(ok&&(line>=0)) {
Addchain(line,cmds[2]);
}
else {
fprintf(stderr,"addchain: invalid line number\n");
}
}
else {
fprintf(stderr,"addchain: invalid command arguments\n");
}
}
else {
fprintf(stderr,"addchain: insufficient privileges [Add Log Items]\n");
}
processed=true;
}
if(verb=="addmarker") {
if(rda->user()->addtoLog()) {
if(cmds.size()==2) {
line=cmds[1].toInt(&ok);
if(ok&&(line>=0)) {
Addmarker(line);
}
else {
fprintf(stderr,"addmarker: invalid line number\n");
}
}
else {
fprintf(stderr,"addmarker: invalid command arguments\n");
}
}
else {
fprintf(stderr,"addmarker: insufficient privileges [Add Log Items]\n");
}
processed=true;
}
if(verb=="addtrack") {
if(rda->user()->addtoLog()) {
if(cmds.size()==2) {
line=cmds[1].toInt(&ok);
if(ok&&(line>=0)) {
Addtrack(line);
}
else {
fprintf(stderr,"addtrack: invalid line number\n");
}
}
else {
fprintf(stderr,"addtrack: invalid command arguments\n");
}
}
else {
fprintf(stderr,"addtrack: insufficient privileges [Add Log Items]\n");
}
processed=true;
}
if(verb=="header") {
Header();
processed=true;
}
if(verb=="list") {
List();
processed=true;
}
if(verb=="remove") {
if(rda->user()->removefromLog()) {
if(cmds.size()==2) {
line=cmds[1].toInt(&ok);
if(ok&&(line>=0)&&(line<edit_log_event->size())) {
Remove(line);
}
else {
fprintf(stderr,"remove: invalid line number\n");
}
}
else {
fprintf(stderr,"remove: invalid command arguments\n");
}
}
else {
fprintf(stderr,"remove: insufficient privileges [Delete Log Items]\n");
}
processed=true;
}
if(verb=="save") {
if(rda->user()->arrangeLog()) {
Save();
}
else {
fprintf(stderr,"save: insufficient privileges [Rearrange Log Items]\n");
}
processed=true;
}
if(verb=="saveas") {
if(rda->user()->arrangeLog()) {
if(cmds.size()==2) {
if(cmds[1].length()>64) {
fprintf(stderr,"saveas: log name too long\n");
}
Saveas(cmds[1]);
}
else {
fprintf(stderr,"saveas: invalid command arguments\n");
}
}
else {
fprintf(stderr,
"saveas: insufficient privileges [Rearrange Log Items]\n");
}
processed=true;
}
if(verb=="setautorefresh") {
if(rda->user()->arrangeLog()) {
if(cmds.size()==2) {
QString arg=cmds[1].lower();
if((arg=="yes")||(arg=="true")||(arg=="y")) {
Setautorefresh(true);
processed=true;
}
if((arg=="no")||(arg=="false")||(arg=="n")) {
Setautorefresh(false);
processed=true;
}
if(!processed) {
fprintf(stderr,"setautorefresh: invalid command argument\n");
}
}
else {
fprintf(stderr,"setautorefresh: invalid command arguments\n");
}
}
else {
fprintf(stderr,
"setautorefresh: insufficient privileges [Rearrange Log Items]\n");
}
processed=true;
}
if(verb=="setcart") {
if(rda->user()->arrangeLog()) {
if(cmds.size()==3) {
line=cmds[1].toInt(&ok);
if(ok&&(line>=0)&&(line<edit_log_event->size())) {
unsigned cartnum=cmds[2].toUInt(&ok);
if(ok&&(cartnum<=RD_MAX_CART_NUMBER)) {
Setcart(line,cartnum);
}
else {
fprintf(stderr,"setcart: invalid cart number\n");
}
}
else {
fprintf(stderr,"setcart: invalid line number\n");
}
}
else {
fprintf(stderr,"setcart: invalid command arguments\n");
}
}
else {
fprintf(stderr,
"setcart: insufficient privileges [Rearrange Log Items]\n");
}
processed=true;
}
if(verb=="setcomment") {
if(rda->user()->arrangeLog()) {
if(cmds.size()>=3) {
line=cmds[1].toInt(&ok);
if(ok&&(line>=0)&&(line<edit_log_event->size())) {
cmds.remove(cmds.begin());
cmds.remove(cmds.begin());
Setcomment(line,cmds.join(" "));
}
else {
fprintf(stderr,"setcomment: invalid line number\n");
}
}
else {
fprintf(stderr,"setcomment: invalid command arguments\n");
}
}
else {
fprintf(stderr,
"setcomment: insufficient privileges [Rearrange Log Items]\n");
}
processed=true;
}
if(verb=="setdesc") {
if(rda->user()->arrangeLog()) {
if(cmds.size()>=2) {
cmds.erase(cmds.begin());
Setdesc(cmds.join(" "));
}
else {
fprintf(stderr,"setdesc: invalid command arguments\n");
}
}
else {
fprintf(stderr,
"setdesc: insufficient privileges [Rearrange Log Items]\n");
}
processed=true;
}
if(verb=="setenddate") {
if(rda->user()->arrangeLog()) {
if(cmds.size()==1) {
Setenddate(QDate());
}
else {
if(cmds.size()==2) {
QDate date=QDate::fromString(cmds[1],Qt::ISODate);
if(date.isValid()) {
Setenddate(date);
}
else {
fprintf(stderr,"setenddate: invalid date format\n");
}
}
else {
fprintf(stderr,"setenddate: invalid command arguments\n");
}
}
}
else {
fprintf(stderr,
"setenddate: insufficient privileges [Rearrange Log Items]\n");
}
processed=true;
}
if(verb=="setlabel") {
if(rda->user()->arrangeLog()) {
if(cmds.size()==3) {
line=cmds[1].toInt(&ok);
if(ok&&(line>=0)&&(line<edit_log_event->size())) {
Setlabel(line,cmds[2]);
}
else {
fprintf(stderr,"setlabel: invalid line number\n");
}
}
else {
fprintf(stderr,"setlabel: invalid command arguments\n");
}
}
else {
fprintf(stderr,
"setlabel: insufficient privileges [Rearrange Log Items]\n");
}
processed=true;
}
if(verb=="setpurgedate") {
if(rda->user()->arrangeLog()) {
if(cmds.size()==1) {
Setpurgedate(QDate());
}
else {
if(cmds.size()==2) {
QDate date=QDate::fromString(cmds[1],Qt::ISODate);
if(date.isValid()) {
Setpurgedate(date);
}
else {
fprintf(stderr,"setpurgedate: invalid date format\n");
}
}
else {
fprintf(stderr,"setpurgedate: invalid command arguments\n");
}
}
}
else {
fprintf(stderr,
"setpurgedate: insufficient privileges [Rearrange Log Items]\n");
}
processed=true;
}
if(verb=="setservice") {
if(rda->user()->arrangeLog()) {
if(cmds.size()==2) {
Setservice(cmds[1]);
}
else {
fprintf(stderr,"setservice: invalid command arguments\n");
}
}
else {
fprintf(stderr,
"setservice: insufficient privileges [Rearrange Log Items]\n");
}
processed=true;
}
if(verb=="setstartdate") {
if(rda->user()->arrangeLog()) {
if(cmds.size()==1) {
Setstartdate(QDate());
}
else {
if(cmds.size()==2) {
QDate date=QDate::fromString(cmds[1],Qt::ISODate);
if(date.isValid()) {
Setstartdate(date);
}
else {
fprintf(stderr,"setstartdate: invalid date format\n");
}
}
else {
fprintf(stderr,"setstartdate: invalid command arguments\n");
}
}
}
else {
fprintf(stderr,
"setstartdate: insufficient privileges [Rearrange Log Items]\n");
}
processed=true;
}
if(verb=="settime") {
if(rda->user()->arrangeLog()) {
if(cmds.size()>=3) {
line=cmds[1].toInt(&ok);
if(ok&&(line>=0)&&(line<edit_log_event->size())) {
RDLogLine::TimeType ttype=RDLogLine::NoTime;
if(cmds[2].lower()=="hard") {
ttype=RDLogLine::Hard;
}
if(cmds[2].lower()=="none") {
ttype=RDLogLine::Relative;
}
switch(ttype) {
case RDLogLine::Hard:
if(cmds.size()>=4) {
time=RDGetWebTime(cmds[3],&ok);
if(ok) {
Settime(line,ttype,time);
}
else {
fprintf(stderr,"settime: invalid time value\n");
}
}
else {
fprintf(stderr,"settime: missing time value\n");
}
break;
case RDLogLine::Relative:
Settime(line,ttype);
break;
case RDLogLine::NoTime:
fprintf(stderr,"settime: invalid time type\n");
break;
}
}
else {
fprintf(stderr,"settime: invalid line number\n");
}
}
else {
fprintf(stderr,"settime: invalid command arguments\n");
}
}
else {
fprintf(stderr,
"settime: insufficient privileges [Rearrange Log Items]\n");
}
processed=true;
}
if(verb=="settrans") {
if(rda->user()->arrangeLog()) {
if(cmds.size()==3) {
line=cmds[1].toInt(&ok);
if(ok&&(line>=0)&&(line<edit_log_event->size())) {
RDLogLine::TransType trans=RDLogLine::NoTrans;
if(cmds[2].lower()=="play") {
trans=RDLogLine::Play;
}
if(cmds[2].lower()=="segue") {
trans=RDLogLine::Segue;
}
if(cmds[2].lower()=="stop") {
trans=RDLogLine::Stop;
}
if(trans!=RDLogLine::NoTrans) {
Settrans(line,trans);
}
else {
fprintf(stderr,"settrans: invalid transition type\n");
}
}
else {
fprintf(stderr,"settrans: invalid line number\n");
}
}
else {
fprintf(stderr,"settrans: invalid command arguments\n");
}
}
else {
fprintf(stderr,
"settrans: insufficient privileges [Rearrange Log Items]\n");
}
processed=true;
}
if(verb=="unload") {
if(overwrite) {
Unload();
}
else {
OverwriteError("unload");
}
processed=true;
}
}
else {
fprintf(stderr,"%s: no log loaded\n",(const char *)verb);
processed=true;
}
if(!processed) {
fprintf(stderr,"invalid command\n");
}
PrintPrompt();
}
void EquationHighlighter::highlightBlock(const QString& text) {
//TODO: m_parent->checkTextValidity();
if (text.isEmpty())
return;
QTextCharFormat number;
QTextCharFormat function;
QTextCharFormat variable;
QTextCharFormat constant;
QTextCharFormat matchedParenthesis;
QPalette palette;
if (qGray(palette.color(QPalette::Base).rgb()) > 160) {
number.setForeground(QColor(0, 0, 127));
function.setForeground(QColor(85, 0, 0));
function.setFontWeight(QFont::Bold);
variable.setForeground(QColor(0, 85, 0));
constant.setForeground(QColor(85, 0, 0));
matchedParenthesis.setBackground(QColor(255, 255, 183));
} else {
number.setForeground(QColor(160, 160, 255));
function.setForeground(QColor(255, 160, 160));
function.setFontWeight(QFont::Bold);
variable.setForeground(QColor(160, 255, 160));
constant.setForeground(QColor(255, 160, 160));
matchedParenthesis.setBackground(QColor(85, 85, 0));
}
QTextCharFormat other;
static const QStringList& functions = ExpressionParser::getInstance()->functions();
static const QStringList& constants = ExpressionParser::getInstance()->constants();
for (int i = 0; i < text.length(); ++i) {
QString remaining = text.right(text.length() - i);
bool found = false;
//variables
foreach (const QString& var, m_variables) {
if (remaining.startsWith(var)) {
setFormat(i, var.length(), variable);
i += var.length() - 1;
found = true;
break;
}
}
if (found)
continue;
//functions
foreach (const QString& f, functions) {
if (remaining.startsWith(f)) {
setFormat(i, f.length(), function);
i += f.length() - 1;
found = true;
break;
}
}
if (found)
continue;
//constants
foreach (const QString& f, constants) {
if (remaining.startsWith(f)) {
setFormat(i, f.length(), function);
i += f.length() - 1;
found = true;
break;
}
}
if (found)
continue;
//TODO
/*
ushort u = text[i].unicode();
bool isFraction = (u >= 0xbc && u <= 0xbe) || (u >= 0x2153 && u <= 0x215e);
bool isPower = (u >= 0xb2 && u <= 0xb3) || (u == 0x2070) || (u >= 0x2074 && u <= 0x2079);
bool isDigit = text[i].isDigit();
bool isDecimalPoint = text[i] == QLocale().decimalPoint();
if (isFraction || isPower || isDigit || isDecimalPoint)
setFormat(i, 1, number);
else
setFormat(i, 1, other);
*/
}
//highlight matched brackets
int cursorPos = m_parent->textCursor().position();
if (cursorPos < 0)
cursorPos = 0;
// Adjust cursorpos to allow for a bracket before the cursor position
if (cursorPos >= text.size())
cursorPos = text.size() - 1;
else if (cursorPos > 0 && (text[cursorPos-1] == '(' || text[cursorPos-1] == ')'))
cursorPos--;
bool haveOpen = text[cursorPos] == '(';
bool haveClose = text[cursorPos] == ')';
if ((haveOpen || haveClose) && m_parent->hasFocus()) {
// Search for the other bracket
int inc = haveOpen ? 1 : -1; // which direction to search in
int level = 0;
for (int i = cursorPos; i >= 0 && i < text.size(); i += inc) {
if (text[i] == ')')
level--;
else if (text[i] == '(')
level++;
if (level == 0) {
// Matched!
setFormat(cursorPos, 1, matchedParenthesis);
setFormat(i, 1, matchedParenthesis);
break;
}
}
}
//TODO: highlight the position of the error
// if (m_errorPosition != -1) {
// QTextCharFormat error;
// error.setForeground(Qt::red);
//
// setFormat(m_errorPosition, 1, error);
// }
}
void GUIDetailsPane::update(const GUIUpdateData& ud)
{
RegisterThisFunction fnguard(__PRETTY_FUNCTION__);
if(!isVisible())return;
TelescopeController::TrackingState state = ud.tse.state;
if(m_sv_demand == SV_AUTO)
{
if((ud.tar_object!=0)&&(!ud.tar_object->useCorrections()))
m_sv = SV_ENCODER;
else if(ud.tar_object!=0)m_sv = SV_SKY;
}
else
{
m_sv = m_sv_demand;
}
if((ud.full_update)||(ud.replay))
{
if(state != TelescopeController::TS_COM_FAILURE)
m_ps->update(ud.tse.status,
ud.tse.az_driveangle_estimated_speed_dps,
ud.tse.el_driveangle_estimated_speed_dps);
else
m_ps->blank();
}
if(state != TelescopeController::TS_COM_FAILURE)
{
activateLE(true, m_tel_az, color_fg_attn, color_bg_attn);
activateLE(true, m_tel_el, color_fg_attn, color_bg_attn);
QString tel_az;
QString tel_el;
QString tel_ra;
QString tel_dec;
QString tel_l;
QString tel_b;
if(m_sv == SV_ENCODER)
{
tel_az = QString("Enc: ")
+Angle::makeDeg(ud.tse.status.az.driveangle_deg)
.degString(4);
tel_el = QString("Enc: ")
+ Angle::makeDeg(ud.tse.status.el.driveangle_deg)
.degPM180String(4);
tel_ra = "Enc: N/A";
tel_dec = "Enc: N/A";
tel_l = "Enc: N/A";
tel_b = "Enc: N/A";
}
else
{
tel_az = ud.tel_azel.phi().degString(4);
tel_el = ud.tel_azel.latitude().degPM180String(4);
tel_ra = ud.tel_radec.phi().hmsString(0);
tel_dec = ud.tel_radec.latitude().dmsString(0);
tel_l = MAKEDEG(ud.tel_gal.phi().degString(3));
tel_b = MAKEDEG(ud.tel_gal.latitude().degPM180String(3));
}
m_tel_ra->setText(tel_ra);
m_tel_ra->setEnabled(true);
m_tel_dec->setText(tel_dec);
m_tel_dec->setEnabled(true);
m_tel_az->setText(MAKEDEG(tel_az));
m_tel_az->setEnabled(true);
m_tel_el->setText(MAKEDEG(tel_el));
m_tel_el->setEnabled(true);
m_tel_l->setText(tel_l);
m_tel_l->setEnabled(true);
m_tel_b->setText(tel_b);
m_tel_b->setEnabled(true);
}
else
{
activateLE(false, m_tel_az, color_fg_attn, color_bg_attn);
activateLE(false, m_tel_el, color_fg_attn, color_bg_attn);
m_tel_ra->setText("");
m_tel_ra->setEnabled(false);
m_tel_dec->setText("");
m_tel_dec->setEnabled(false);
m_tel_az->setText("");
m_tel_az->setEnabled(false);
m_tel_el->setText("");
m_tel_el->setEnabled(false);
m_tel_l->setText("");
m_tel_l->setEnabled(false);
m_tel_b->setText("");
m_tel_b->setEnabled(false);
}
// --------------------------------------------------------------------------
// Update Times Etc
// --------------------------------------------------------------------------
m_ut_date->setText(ud.date_string);
m_ut_utc->setText(ud.timeangle.hmsString(1));
m_ut_lmst->setText(ud.lmst.hmsString(1));
m_ut_mjd->setText(QString::number(ud.mjd,'f',6));
if(ud.tar_object)
{
QString src_az;
QString src_el;
QString src_ra;
QString src_dec;
QString src_l;
QString src_b;
if(m_sv == SV_ENCODER)
{
src_az = QString("Enc: ")
+ Angle::makeRad(ud.tar_az_driveangle).degString(4);
src_el = QString("Enc: ")
+ Angle::makeRad(ud.tar_el_driveangle).degPM180String(4);
src_ra="Enc: N/A";
src_dec="Enc: N/A";
src_l="Enc: N/A";
src_b="Enc: N/A";
}
else
{
src_az = ud.tar_azel.phi().degString(2);
src_el = ud.tar_azel.latitude().degPM180String(4);
src_ra=ud.tar_radec.phi().hmsString(0);
src_dec=ud.tar_radec.latitude().dmsString(0);
src_l=MAKEDEG(ud.tar_gal.phi().degString(3));
src_b=MAKEDEG(ud.tar_gal.latitude().degPM180String(3));
}
m_src_az->setText(MAKEDEG(src_az));
m_src_az->setEnabled(true);
m_src_el->setText(MAKEDEG(src_el));
m_src_el->setEnabled(true);
if(!ud.in_limits)
{
m_src_az->setPaletteBackgroundColor(color_bg_warn);
m_src_az->setPaletteForegroundColor(color_fg_warn);
m_src_el->setPaletteBackgroundColor(color_bg_warn);
m_src_el->setPaletteForegroundColor(color_fg_warn);
}
else if((ud.target_moves)&&(fabs(ud.tar_az_speed)>ud.az_speed_limit))
{
m_src_az->unsetPalette();
if(ud.tv.tv_usec/500000==0)
{
m_src_az->setPaletteBackgroundColor(color_bg_warn);
m_src_az->setPaletteForegroundColor(color_fg_warn);
}
m_src_el->unsetPalette();
}
else if(!ud.in_limits30)
{
m_src_az->setPaletteBackgroundColor(color_bg_attn);
m_src_az->setPaletteForegroundColor(color_fg_attn);
m_src_el->setPaletteBackgroundColor(color_bg_attn);
m_src_el->setPaletteForegroundColor(color_fg_attn);
}
else if(((ud.target_moves)&&
(fabs(ud.tar_max_az_speed)>ud.az_speed_limit))||
((Angle::toDeg(ud.tar_az_driveangle)>90)&&
(Angle::toDeg(fabs(ud.tar_az_driveangle-
ud.tar_az_driveangle30))>270)))
{
m_src_az->unsetPalette();
if(ud.tv.tv_usec/500000==0)
{
m_src_az->setPaletteBackgroundColor(color_bg_attn);
m_src_az->setPaletteForegroundColor(color_fg_attn);
}
m_src_el->unsetPalette();
}
else
{
m_src_az->unsetPalette();
m_src_el->unsetPalette();
}
if((ud.full_update)||(ud.replay))
{
m_src_name->setText(ud.tar_object->targetName(ud.mjd));
m_src_name->setEnabled(true);
}
m_src_ra->setText(src_ra);
m_src_ra->setEnabled(true);
m_src_dec->setText(src_dec);
m_src_dec->setEnabled(true);
m_src_l->setText(src_l);
m_src_l->setEnabled(true);
m_src_b->setText(src_b);
m_src_b->setEnabled(true);
if(state != TelescopeController::TS_COM_FAILURE)
{
m_err_total->setText(ud.sep.deg180String(4));
m_err_total->setEnabled(true);
if((ud.latest_req==TelescopeController::REQ_TRACK)&&
(ud.sep.deg()>0.05))
{
m_err_total->setPaletteBackgroundColor(color_bg_warn);
m_err_total->setPaletteForegroundColor(color_fg_warn);
}
else
{
m_err_total->unsetPalette();
}
if(ud.az_sep>0)
m_err_az->setText(MAKEDEG(Angle::makeDeg(ud.az_sep).degString(4)));
else
{
QString txt = MAKEDEG(Angle::makeDeg(-ud.az_sep).degString(4));
m_err_az->setText(QString("-")+txt.right(txt.length()-1));
}
m_err_az->setEnabled(true);
if(ud.el_sep>0)
m_err_el->setText(MAKEDEG(Angle::makeDeg(ud.el_sep).
degPM180String(4)));
else
{
QString txt = MAKEDEG(Angle::makeDeg(-ud.el_sep).
degPM180String(4));
m_err_el->setText(QString("-")+txt.right(txt.length()-1));
}
m_err_el->setEnabled(true);
if((state==TelescopeController::TS_TRACK)&&(ud.sep.deg()<0.05))
{
m_err_eta->setText("");
m_err_eta->setEnabled(false);
}
else
{
m_err_eta->setText(ud.eta_string);
m_err_eta->setEnabled(true);
}
}
else
{
m_err_total->setText("");
m_err_total->setEnabled(false);
m_err_az->setText("");
m_err_az->setEnabled(false);
m_err_el->setText("");
m_err_el->setEnabled(false);
m_err_eta->setText("");
m_err_eta->setEnabled(false);
}
}
else if((ud.full_update)||(ud.replay))
{
m_src_name->setText("");
m_src_name->setEnabled(false);
m_src_ra->setText("");
m_src_ra->setEnabled(false);
m_src_dec->setText("");
m_src_dec->setEnabled(false);
m_src_az->setText("");
m_src_az->setEnabled(false);
m_src_el->setText("");
m_src_el->setEnabled(false);
m_src_l->setText("");
m_src_l->setEnabled(false);
m_src_b->setText("");
m_src_b->setEnabled(false);
m_err_total->setText("");
m_err_total->setEnabled(false);
m_err_az->setText("");
m_err_az->setEnabled(false);
m_err_el->setText("");
m_err_el->setEnabled(false);
m_err_eta->setText("");
m_err_eta->setEnabled(false);
}
if((ud.full_update)||(ud.replay))
m_selector->updateButtons(controlsEnabled(), ud.tse.state, ud.tse.req);
m_selector->animateButtons();
}
void Widget::tcpProcessData(QByteArray data, QTcpSocket* socket)
{
if (tcpReceivedDatas->contains("commfunction=login&") && tcpReceivedDatas->contains("&version=")) // Login request
{
QString postData = QString(*tcpReceivedDatas);
*tcpReceivedDatas = tcpReceivedDatas->right(postData.size()-postData.indexOf("version=")-8-4); // 4 : size of version number (ie:version=1344)
logMessage("TCP: Login request received :");
QFile file(QString(NETDATAPATH)+"/loginHeader.bin");
QFile fileServersList(SERVERSLISTFILEPATH);
QFile fileBadPassword(QString(NETDATAPATH)+"/loginWrongPassword.bin");
QFile fileAlready(QString(NETDATAPATH)+"/loginAlreadyConnected.bin");
QFile fileMaxRegistration(QString(NETDATAPATH)+"/loginMaxRegistered.bin");
QFile fileMaxConnected(QString(NETDATAPATH)+"/loginMaxConnected.bin");
if (!file.open(QIODevice::ReadOnly) || !fileBadPassword.open(QIODevice::ReadOnly)
|| !fileAlready.open(QIODevice::ReadOnly) || !fileMaxRegistration.open(QIODevice::ReadOnly)
|| !fileMaxConnected.open(QIODevice::ReadOnly) || !fileServersList.open(QIODevice::ReadOnly))
{
logStatusMessage("Error reading login data files");
stopServer();
}
else
{
bool ok=true;
postData = postData.right(postData.size()-postData.indexOf("username="******"passhash=")-9);
QString passhash = postData;
passhash.truncate(postData.indexOf('&'));
logMessage(QString("IP : ")+socket->peerAddress().toString());
logMessage(QString("Username : "******"Passhash : ")+passhash);
// Add player to the players list
Player player = Player::findPlayer(tcpPlayers, username);
if (player.name != username) // Not found, create a new player
{
// Check max registered number
if (tcpPlayers.size() >= maxRegistered)
{
logMessage("TCP: Registration failed, too much players registered");
socket->write(fileMaxRegistration.readAll());
ok = false;
}
else
{
logMessage("TCP: Creating user in database");
Player newPlayer;
newPlayer.name = username;
newPlayer.passhash = passhash;
newPlayer.IP = socket->peerAddress().toString();
newPlayer.connected = false; // The connection checks are done by the game servers
tcpPlayers << newPlayer;
if (!Player::savePlayers(tcpPlayers))
ok = false;
}
}
else // Found, compare passhashes, check if already connected
{
if (player.passhash != passhash) // Bad password
{
logMessage("TCP: Login failed, wrong password");
socket->write(fileBadPassword.readAll());
ok=false;
}
/*
else if (newPlayer.connected) // Already connected
{
logMessage("TCP: Login failed, player already connected");
socket->write(fileAlready.readAll());
ok=false;
}
*/
else // Good password
{
/*
// Check too many connected
int n=0;
for (int i=0;i<tcpPlayers.size();i++)
if (tcpPlayers[i].connected)
n++;
if (n>=maxConnected)
{
logMessage("TCP: Login failed, too much players connected");
socket->write(fileMaxConnected.readAll());
ok=false;
}
else
*/
{
player.reset();
player.IP = socket->peerAddress().toString();
player.lastPingTime = timestampNow();
player.connected = true;
}
}
}
if (ok) // Send servers list
{
QByteArray customData = file.readAll();
QByteArray data1 = QByteArray::fromHex("0D0A61757468726573706F6E73653A0A747275650A");
QByteArray sesskey = QCryptographicHash::hash(QString(passhash + saltPassword).toLatin1(), QCryptographicHash::Md5).toHex();
sesskey += passhash;
QByteArray data2 = QByteArray::fromHex("0A310A");
QByteArray serversList;
QByteArray line;
do {
line = fileServersList.readLine().trimmed();
serversList+=line;
serversList+=0x0A;
} while (!line.isEmpty());
serversList = serversList.trimmed();
QByteArray data3 = QByteArray::fromHex("0D0A300D0A0D0A");
int dataSize = data1.size() + sesskey.size() + data2.size() + serversList.size() - 2;
QString dataSizeStr = QString().setNum(dataSize, 16);
customData += dataSizeStr;
customData += data1;
customData += sesskey;
customData += data2;
customData += serversList;
customData += data3;
logMessage("TCP: Login successful, sending servers list");
socket->write(customData);
}
}
}
else if (data.contains("commfunction=removesession"))
{
logMessage("TCP: Session closed by client");
}
else // Unknown request, erase tcp buffer
{
// Display data
logMessage("TCP: Unknow request received : ");
logMessage(QString(data.data()));
}
// Delete the processed message from the buffer
*tcpReceivedDatas = tcpReceivedDatas->right(tcpReceivedDatas->size() - tcpReceivedDatas->indexOf(data) - data.size());
}
bool RemoteFile::Exists(const QString &url, struct stat *fileinfo)
{
if (url.isEmpty())
return false;
QUrl qurl(url);
QString filename = qurl.path();
QString sgroup = qurl.userName();
QString host = qurl.host();
if (isLocal(url) || gCoreContext->IsThisBackend(host))
{
LOG(VB_FILE, LOG_INFO,
QString("RemoteFile::Exists(): looking for local file: %1").arg(url));
bool fileExists = false;
QString fullFilePath = "";
if (url.startsWith("myth:"))
{
StorageGroup sGroup(sgroup, gCoreContext->GetHostName());
fullFilePath = sGroup.FindFile(filename);
if (!fullFilePath.isEmpty())
fileExists = true;
}
else
{
QFileInfo info(url);
fileExists = info.exists() /*&& info.isFile()*/;
fullFilePath = url;
}
if (fileExists)
{
if (stat(fullFilePath.toLocal8Bit().constData(), fileinfo) == -1)
{
LOG(VB_FILE, LOG_ERR,
QString("RemoteFile::Exists(): failed to stat file: %1").arg(fullFilePath) + ENO);
}
}
return fileExists;
}
LOG(VB_FILE, LOG_INFO,
QString("RemoteFile::Exists(): looking for remote file: %1").arg(url));
if (!qurl.fragment().isEmpty() || url.endsWith("#"))
filename = filename + "#" + qurl.fragment();
if (filename.startsWith("/"))
filename = filename.right(filename.length()-1);
if (filename.isEmpty())
return false;
QStringList strlist("QUERY_FILE_EXISTS");
strlist << filename;
if (!sgroup.isEmpty())
strlist << sgroup;
gCoreContext->SendReceiveStringList(strlist);
bool result = false;
if (!strlist.isEmpty() && strlist[0] == "1")
{
if ((strlist.size() >= 15) && fileinfo)
{
fileinfo->st_dev = strlist[2].toLongLong();
fileinfo->st_ino = strlist[3].toLongLong();
fileinfo->st_mode = strlist[4].toLongLong();
fileinfo->st_nlink = strlist[5].toLongLong();
fileinfo->st_uid = strlist[6].toLongLong();
fileinfo->st_gid = strlist[7].toLongLong();
fileinfo->st_rdev = strlist[8].toLongLong();
fileinfo->st_size = strlist[9].toLongLong();
#ifndef _WIN32
fileinfo->st_blksize = strlist[10].toLongLong();
fileinfo->st_blocks = strlist[11].toLongLong();
#endif
fileinfo->st_atime = strlist[12].toLongLong();
fileinfo->st_mtime = strlist[13].toLongLong();
fileinfo->st_ctime = strlist[14].toLongLong();
result = true;
}
else if (!fileinfo)
{
result = true;
}
}
return result;
}
bool RuleSet::parseLine(const QString &s) {
// ### use QRegExp::cap() instead of mid() and find()
// for our french friends -- Bernd
if(s.contains(QRegExp("flat_init_costs=\\(.*"))) {
// parse the time fields
QString token = s.mid(s.indexOf("flat_init_costs=(") + 17,
s.indexOf(")")-s.indexOf("flat_init_costs=(") - 17);
// printf("TOKEN=%s\n",token.ascii());
double after;
if(!parseRate(flat_init_costs, flat_init_duration, after, token))
return false;
//printf("COST %f DURATION %f\n",flat_init_costs,flat_init_duration);
if(! (flat_init_costs >= 0.0) )
return false;
if(! (flat_init_duration >= 0.0))
return false;
have_flat_init_costs = true;
return true;
}
if(s.contains(QRegExp("on\\(.*\\)between\\(.*\\)use\\(.*\\)"))) {
// parse the time fields
QString token = s.mid(s.indexOf("between(") + 8,
s.indexOf(")use")-s.indexOf("between(") - 8);
QTime t1, t2;
if(!parseTime(t1, t2, token))
return false;
// parse the rate fields
token = s.mid(s.indexOf("use(") + 4,
s.lastIndexOf(")")-s.indexOf("use(") - 4);
double costs;
double len;
double after;
if(!parseRate(costs, len, after, token))
return false;
// parse the days
token = s.mid(s.indexOf("on(") + 3,
s.indexOf(")betw")-s.indexOf("on(") - 3);
if(!parseEntries(token, QDate::currentDate().year(),
t1, t2, costs, len, after))
return false;
return true;
}
// check for the name
if(s.contains(QRegExp("name=.*"))) {
_name = s.right(s.length()-5);
return !_name.isEmpty();
}
// check default entry
if(s.contains(QRegExp("default=\\(.*\\)"))) {
QString token = s.mid(9, s.length() - 10);
double after;
if(parseRate(default_costs, default_len, after, token))
return true;
}
// check for "minimum costs"
if(s.contains(QRegExp("minimum_costs=.*"))) {
QString token = s.right(s.length() - strlen("minimum_costs="));
bool ok;
_minimum_costs = token.toDouble(&ok);
return ok;
}
// check currency settings
if(s.startsWith("currency_symbol=")) {
_currency_symbol = s.mid(16);
return true;
}
if(s.contains(QRegExp("currency_digits=.*"))) {
QString token = s.mid(16, s.length() - 16);
bool ok;
_currency_digits = token.toInt(&ok);
return ok && (_currency_digits >= 0);
}
// "currency_position" is deprecated so we'll simply ignore it
if(s.contains(QRegExp("currency_position=.*")))
return true;
// check per connection fee
if(s.contains(QRegExp("per_connection="))) {
QString token = s.mid(15, s.length()-15);
bool ok;
pcf = token.toDouble(&ok);
return ok;
}
return false;
}
void QTwitchChat::parseMessage()
{
if( !socket_ )
return;
if( socket_->state() == QAbstractSocket::ConnectedState )
{
QString line = socket_->readLine();
//qDebug() << line;
//поадекватнее надо быть
if( line.contains ( "376 " + DEFAULT_USER_NICK_NAME ) )
{
socket_->write( QString( "JOIN #" + channelName_ + "\r\n" ).toStdString().c_str() );
getSelf();
//emit newMessage( new QChatMessage( "qrc:/resources/twitchlogo.png", TWITCH_USER, "Connecting to " + channelName_ + "...", this ) );
if( isShowSystemMessages() )
emit newMessage( new QChatMessage( TWITCH_SERVICE, TWITCH_USER, "Connected to " + channelName_ + "...", "", this ) );
getStatistic();
if( statisticTimerId_ )
statisticTimerId_ = startTimer( statisticInterval_ );
}
else if( line.contains( "PING" ) )
{
qDebug() << line;
//socket_->write( "PONG tmi.twitch.tv\r\n" );
socket_->write( "PONG :tmi.twitch.tv\r\n" );
}
else
{
//TODO: parse message
if( line.contains( "PRIVMSG" ) && !line.contains( "HISTORYEND" ) && !line.contains( "USERCOLOR") )
{
QString nickName = line.mid( 1, line.indexOf( '!' ) - 1 );
QString message = line.right( line.size() - line.indexOf( ':', 1 ) - 1 );
//\r\n
message = message.left( message.size() - 2 );
//qDebug() << message;
message = QChatMessage::replaceEscapeCharecters( message );
message = insertEmotIcons( message );
//message = QChatMessage::insertLinks( message );
bool blackListUser = blackList().contains( nickName );
bool supportersListUser = supportersList().contains( nickName );
if( !isRemoveBlackListUsers() || !blackListUser )
{
if( blackListUser )
{
emit newMessage( new QChatMessage( TWITCH_SERVICE, nickName, message, "ignore", this ) );
}
else
{
if( supportersListUser )
{
emit newMessage( new QChatMessage( TWITCH_SERVICE, nickName, message, "supporter", this ) );
}
else
{
if( isContainsAliases( message ) )
{
emit newMessage( new QChatMessage( TWITCH_SERVICE, nickName, message, "alias", this ) );
}
else
{
emit newMessage( new QChatMessage( TWITCH_SERVICE, nickName, message, "", this ) );
}
}
}
}
}
}
if( socket_->canReadLine() )
{
parseMessage();
}
}
}
int RuleSet::load(const QString &filename) {
flat_init_costs = 0.0;
flat_init_duration = 0;
have_flat_init_costs = false;
QFile f(filename);
// delete old rules
rules.resize(0);
_name = "";
// ignore "No Accounting"
if(filename.isEmpty())
return 0;
if(!f.exists())
return -1;
if(!f.open(QIODevice::ReadOnly))
return -1;
char buffer[2048]; // safe
int lineno=0;
while(!f.atEnd()) {
// read continued lines
QString line;
bool backslashed;
do {
int br = f.readLine(buffer, sizeof(buffer));
if (br < 0) break;
if((br > 0) && (buffer[br-1] == '\n'))
buffer[br-1] = 0;
else
buffer[br] = 0;
lineno++;
line.append(QString::fromUtf8(buffer));
backslashed = (line.right(1) == "\\");
} while(!f.atEnd() && backslashed);
// strip whitespace
line = line.replace(QRegExp("[ \t\r]"), "");
// skip comment lines
if((line.left(1) == "#") || line.isEmpty())
continue;
// parse line
if(!parseLine(line)) {
f.close();
kError(5002) << "ERROR IN LINE " << lineno << endl;
return lineno;
}
}
f.close();
if(_name.length() > 0)
return 0;
else {
kError(5002) << "NO NAME DEFINED" << endl;
return -1;
}
}
LteMainWindow::LteMainWindow(QString t)
{
enableDebug = false;
tabWidget = new QTabWidget;
log = new QTextEdit;
tabWidget->addTab(log, tr("Log"));
createActions();
createMenus();
loadPlugins();
setCentralWidget(tabWidget);
setWindowTitle(tr("LTE Toolset V2"));
setWindowFlags(windowFlags() | Qt::WindowMinMaxButtonsHint);
setWindowState(windowState() | Qt::WindowMaximized);
//checkSqlDrivers();
//decodeLicense();
//convert timezone: from UTC to local time
validTime = QDateTime(QDate::fromString(t.left(QString("yyyyMMdd").size()), "yyyyMMdd"), QTime::fromString(t.right(QString("HHmmss").size()), "HHmmss"), Qt::UTC).toLocalTime().toString("yyyy-MM-dd HH:mm:ss");
}
Entry Dict::parse(const QString &raw)
{
unsigned int length = raw.length();
if (raw.left(5) == "DICT ")
return Entry(raw.right(length - 5));
if (raw.left(8) == "HEADING ")
return Entry(raw.right(length - 8), true);
QString reading;
QString kanji;
QStringList meanings;
QString curmeaning;
bool firstmeaning = true;
QCString parsemode("kanji");
unsigned int i;
for (i = 0; i < length; i++)
{
QChar ichar(raw.at(i));
if (ichar == '[')
{
parsemode = "reading";
}
else if (ichar == ']')
{
// do nothing
}
else if (ichar == '/')
{
if (!firstmeaning)
{
meanings.append(curmeaning);
curmeaning = "";
}
else
{
firstmeaning = false;
parsemode = "meaning";
}
}
else if (ichar == ' ')
{
if (parsemode == "meaning") // only one that needs the space
curmeaning += ' ';
}
else if (parsemode == "kanji")
{
kanji += ichar;
}
else if (parsemode == "meaning")
{
curmeaning += ichar;
}
else if (parsemode == "reading")
{
reading += ichar;
}
}
return (Entry(kanji, reading, meanings));
}
