Palette* MuseScore::newLinesPalette()
{
Palette* sp = new Palette;
sp->setName(QT_TRANSLATE_NOOP("Palette", "Lines"));
sp->setMag(.8);
sp->setGrid(82, 35);
sp->setDrawGrid(true);
qreal w = gscore->spatium() * 8;
Slur* slur = new Slur(gscore);
slur->setId(0);
sp->append(slur, qApp->translate("lines", "Slur"));
Hairpin* gabel0 = new Hairpin(gscore);
gabel0->setHairpinType(Hairpin::CRESCENDO);
gabel0->setLen(w);
sp->append(gabel0, qApp->translate("lines", "Crescendo"));
Hairpin* gabel1 = new Hairpin(gscore);
gabel1->setHairpinType(Hairpin::DECRESCENDO);
gabel1->setLen(w);
sp->append(gabel1, QT_TRANSLATE_NOOP("Palette", "Diminuendo"));
Volta* volta = new Volta(gscore);
volta->setVoltaType(VoltaType::CLOSED);
volta->setLen(w);
volta->setText("1.");
QList<int> il;
il.append(1);
volta->setEndings(il);
sp->append(volta, QT_TRANSLATE_NOOP("Palette", "Prima volta"));
volta = new Volta(gscore);
volta->setVoltaType(VoltaType::CLOSED);
volta->setLen(w);
volta->setText("2.");
il.clear();
il.append(2);
volta->setEndings(il);
sp->append(volta, QT_TRANSLATE_NOOP("Palette", "Seconda volta"));
volta = new Volta(gscore);
volta->setVoltaType(VoltaType::CLOSED);
volta->setLen(w);
volta->setText("3.");
il.clear();
il.append(3);
volta->setEndings(il);
sp->append(volta, QT_TRANSLATE_NOOP("Palette", "Terza volta"));
volta = new Volta(gscore);
volta->setVoltaType(VoltaType::OPEN);
volta->setLen(w);
volta->setText("2.");
il.clear();
il.append(2);
volta->setEndings(il);
sp->append(volta, QT_TRANSLATE_NOOP("Palette", "Seconda volta 2"));
Ottava* ottava = new Ottava(gscore);
ottava->setOttavaType(OttavaType::OTTAVA_8VA);
ottava->setLen(w);
sp->append(ottava, QT_TRANSLATE_NOOP("Palette", "8va"));
ottava = new Ottava(gscore);
ottava->setOttavaType(OttavaType::OTTAVA_8VB);
ottava->setLen(w);
ottava->setPlacement(Element::BELOW);
sp->append(ottava, QT_TRANSLATE_NOOP("Palette", "8vb"));
ottava = new Ottava(gscore);
ottava->setOttavaType(OttavaType::OTTAVA_15MA);
ottava->setLen(w);
sp->append(ottava, QT_TRANSLATE_NOOP("Palette", "15ma"));
ottava = new Ottava(gscore);
ottava->setOttavaType(OttavaType::OTTAVA_15MB);
ottava->setLen(w);
ottava->setPlacement(Element::BELOW);
sp->append(ottava, QT_TRANSLATE_NOOP("Palette", "15mb"));
ottava = new Ottava(gscore);
ottava->setOttavaType(OttavaType::OTTAVA_22MA);
ottava->setLen(w);
sp->append(ottava, QT_TRANSLATE_NOOP("Palette", "22ma"));
ottava = new Ottava(gscore);
ottava->setOttavaType(OttavaType::OTTAVA_22MB);
ottava->setLen(w);
sp->append(ottava, QT_TRANSLATE_NOOP("Palette", "22mb"));
Pedal* pedal = new Pedal(gscore);
pedal->setLen(w);
sp->append(pedal, QT_TRANSLATE_NOOP("Palette", "Pedal"));
pedal = new Pedal(gscore);
pedal->setLen(w);
pedal->setEndHookType(HOOK_45);
sp->append(pedal, QT_TRANSLATE_NOOP("Palette", "Pedal"));
pedal = new Pedal(gscore);
pedal->setLen(w);
pedal->setBeginSymbol(SymId::noSym);
pedal->setBeginHook(true);
pedal->setBeginHookType(HOOK_45);
pedal->setEndHookType(HOOK_45);
sp->append(pedal, QT_TRANSLATE_NOOP("Palette", "Pedal"));
pedal = new Pedal(gscore);
pedal->setLen(w);
pedal->setBeginSymbol(SymId::noSym);
pedal->setBeginHook(true);
pedal->setBeginHookType(HOOK_45);
sp->append(pedal, QT_TRANSLATE_NOOP("Palette", "Pedal"));
Trill* trill = new Trill(gscore);
trill->setLen(w);
sp->append(trill, QT_TRANSLATE_NOOP("Palette", "Trill line"));
trill = new Trill(gscore);
trill->setTrillType("upprall");
trill->setLen(w);
sp->append(trill, QT_TRANSLATE_NOOP("Palette", "Upprall line"));
trill = new Trill(gscore);
trill->setTrillType("downprall");
trill->setLen(w);
sp->append(trill, QT_TRANSLATE_NOOP("Palette", "Downprall line"));
trill = new Trill(gscore);
trill->setTrillType("prallprall");
trill->setLen(w);
sp->append(trill, QT_TRANSLATE_NOOP("Palette", "Prallprall line"));
trill = new Trill(gscore);
trill->setTrillType("pure");
trill->setLen(w);
sp->append(trill, QT_TRANSLATE_NOOP("Palette", "Wavy line"));
TextLine* textLine = new TextLine(gscore);
textLine->setLen(w);
textLine->setBeginText("VII", gscore->textStyle(TEXT_STYLE_TEXTLINE));
textLine->setEndHook(true);
sp->append(textLine, QT_TRANSLATE_NOOP("Palette", "Text line"));
TextLine* line = new TextLine(gscore);
line->setLen(w);
line->setDiagonal(true);
sp->append(line, QT_TRANSLATE_NOOP("Palette", "Line"));
Ambitus* a = new Ambitus(gscore);
sp->append(a, QT_TRANSLATE_NOOP("Palette", "Ambitus"));
return sp;
}
void StandGrapher::createGui()
{
//--------------------------------------------------
// Universal button creator for the navigation bars
//--------------------------------------------------
class ButtonCreator
{
public:
static QPushButton * create(QWidget * parent, const QString & objName, const QIcon & icon,
const QKeySequence & key, QString toolTip, QWidget * target, const char * slot)
{
QPushButton * button = new QPushButton(parent);
button->setObjectName(objName);
button->setFocusPolicy(Qt::NoFocus);
connect(button, SIGNAL(pressed()), target, slot);
button->setIconSize(QSize(32, 32));
button->setIcon(QIcon(icon));
if (!key.isEmpty())
toolTip += " " + tr("(Shortcut: <b>%1</b>)").arg(key.toString());
button->setToolTip(toolTip);
QShortcut * shortcut = new QShortcut(key, target);
connect(shortcut, SIGNAL(activated()), target, slot);
return button;
}
};
QList<QPushButton *> buttons;
//-------------------------------------------
// Horizontal tool box
//-------------------------------------------
hToolBox = new QFrame(this);
hToolBox->setFrameStyle(QFrame::StyledPanel | QFrame::Plain);
hToolBox->setAutoFillBackground(true);
hToolBox->setCursor(Qt::ArrowCursor);
hToolBox->installEventFilter(this);
// Create buttons
buttons << ButtonCreator::create(hToolBox, "Start_button", QIcon(":/start.png"),
Qt::Key_Home, tr("Start"), this, SLOT(slotStart()));
buttons << ButtonCreator::create(hToolBox, "Prev_button", QIcon(":/previous.png"),
Qt::Key_Left, tr("Previous"), this, SLOT(slotPrevious()));
buttons << ButtonCreator::create(hToolBox, "HFit_button", QIcon(":/fit.png"),
QKeySequence(), tr("Fit horizontally"), this, SLOT(slotFit()));
buttons << ButtonCreator::create(hToolBox, "Next_button", QIcon(":/next.png"),
Qt::Key_Right, tr("Next"), this, SLOT(slotNext()));
buttons << ButtonCreator::create(hToolBox, "Finish_button", QIcon(":/finish.png"),
Qt::Key_End, tr("End"), this, SLOT(slotEnd()));
buttons << ButtonCreator::create(hToolBox, "HZoomIn_button", QIcon(":/plus.png"),
Qt::Key_Plus, tr("Wider"), this, SLOT(slotZoomIn()));
buttons << ButtonCreator::create(hToolBox, "HZoomOut_button", QIcon(":/minus.png"),
Qt::Key_Minus, tr("Narrower"), this, SLOT(slotZoomOut()));
// Layout buttons
QHBoxLayout * hLayout = new QHBoxLayout(hToolBox);
foreach(QPushButton * button, buttons)
hLayout->addWidget(button);
hToolBox->setLayout(hLayout);
//-------------------------------------------
// Vertical tool box
//-------------------------------------------
vToolBox = new QFrame(this);
vToolBox->setFrameStyle(QFrame::StyledPanel | QFrame::Plain);
vToolBox->setAutoFillBackground(true);
vToolBox->setCursor(Qt::ArrowCursor);
vToolBox->installEventFilter(this);
buttons.clear();
buttons << ButtonCreator::create(vToolBox, "Up_button", QIcon(":/up.png"),
Qt::Key_Up, tr("Up"), this, SLOT(slotUp()));
buttons << ButtonCreator::create(vToolBox, "VFit_button", QIcon(":/fit_vert.png"),
QKeySequence(), tr("Fit vertically"), this, SLOT(slotVFit()));
buttons << ButtonCreator::create(vToolBox, "Down_button", QIcon(":/down.png"),
Qt::Key_Down, tr("Down"), this, SLOT(slotDown()));
buttons << ButtonCreator::create(vToolBox, "VZoomIn_button", QIcon(":/plus.png"),
Qt::SHIFT+Qt::Key_Plus, tr("Wider"), this, SLOT(slotVZoomIn()));
buttons << ButtonCreator::create(vToolBox, "VZoomOut_button", QIcon(":/minus.png"),
Qt::SHIFT+Qt::Key_Minus, tr("Narrower"), this, SLOT(slotVZoomOut()));
// Layout buttons
QVBoxLayout * vLayout = new QVBoxLayout(vToolBox);
foreach(QPushButton * button, buttons)
vLayout->addWidget(button);
vToolBox->setLayout(vLayout);
//-------------------------------------------
// Tool Box
//-------------------------------------------
toolBox = new QFrame(this);
toolBox->setFrameStyle(QFrame::StyledPanel | QFrame::Plain);
toolBox->setAutoFillBackground(true);
toolBox->setCursor(Qt::ArrowCursor);
toolBox->installEventFilter(this);
buttons.clear();
// Filter button
filterButton = new QPushButton(toolBox);
filterButton->setIcon(QIcon(":/filter.png"));
filterButton->setCheckable(true);
filterButton->setShortcut(Qt::Key_F);
filterButton->setToolTip(tr("Filter window"));
connect(filterButton, SIGNAL(released()), this, SLOT(slotFilterWindow()));
buttons << filterButton;
filterWindow = new ParamsFilterWidget(this);
connect(filterWindow, SIGNAL( modelChanged(Stand_trace_model::Ptr) ),
this, SLOT( setModel(Stand_trace_model::Ptr) ));
connect(filterWindow, SIGNAL(windowClosed()),
filterButton, SLOT(toggle()));
// Drawing lines option
drawLinesButton = new QPushButton(toolBox);
drawLinesButton->setIcon(QIcon(":/draw_lines.png"));
drawLinesButton->setCheckable(true);
drawLinesButton->setChecked(true);
drawLinesButton->setShortcut(Qt::Key_L);
drawLinesButton->setToolTip(tr("Draw lines"));
connect(drawLinesButton, SIGNAL(released()), this, SLOT(slotDrawLineSwither()));
buttons << drawLinesButton;
// Antialiasing option
antialiasingButton = new QPushButton(toolBox);
antialiasingButton->setIcon(QIcon(":/antialiasing.png"));
antialiasingButton->setCheckable(true);
antialiasingButton->setChecked(antialiasing);
antialiasingButton->setShortcut(Qt::Key_A);
antialiasingButton->setToolTip(tr("Antialiasing"));
connect(antialiasingButton, SIGNAL(clicked(bool)), this, SLOT(slotAntialiasingSwither(bool)));
buttons << antialiasingButton;
// Print button
printButton = new QPushButton(toolBox);
printButton->setIcon(QIcon(":/printer.png"));
printButton->setShortcut(Qt::Key_P);
printButton->setToolTip(tr("Print"));
connect(printButton, SIGNAL(released()), this, SLOT(slotPrintGraph()));
buttons << printButton;
// Setup buttons
foreach (QPushButton * button, buttons) {
button->setIconSize(QSize(16, 16));
button->setFocusPolicy(Qt::NoFocus);
button->setToolTip(button->toolTip() + " " +
tr("(Shortcut: <b>%1</b>)").arg(button->shortcut().toString()));
}
void refreshEscrowTable(EscrowModelType type)
{
cachedEscrowTable.clear();
{
string strMethod = string("escrowlist");
UniValue params(UniValue::VARR);
UniValue result ;
string name_str;
string time_str;
string seller_str;
string arbiter_str;
string status_str;
string offeraccept_str;
string offer_str;
string offertitle_str;
string total_str;
string buyer_str;
int unixTime;
QDateTime dateTime;
try {
result = tableRPC.execute(strMethod, params);
if (result.type() == UniValue::VARR)
{
name_str = "";
time_str = "";
seller_str = "";
arbiter_str = "";
status_str = "";
offeraccept_str = "";
offer_str = "";
offertitle_str = "";
total_str = "";
buyer_str = "";
const UniValue &arr = result.get_array();
for (unsigned int idx = 0; idx < arr.size(); idx++) {
const UniValue& input = arr[idx];
if (input.type() != UniValue::VOBJ)
continue;
const UniValue& o = input.get_obj();
name_str = "";
name_str = "";
seller_str = "";
arbiter_str = "";
status_str = "";
offeraccept_str = "";
offer_str = "";
total_str = "";
const UniValue& name_value = find_value(o, "escrow");
if (name_value.type() == UniValue::VSTR)
name_str = name_value.get_str();
const UniValue& time_value = find_value(o, "time");
if (time_value.type() == UniValue::VSTR)
time_str = time_value.get_str();
const UniValue& seller_value = find_value(o, "seller");
if (seller_value.type() == UniValue::VSTR)
seller_str = seller_value.get_str();
const UniValue& arbiter_value = find_value(o, "arbiter");
if (arbiter_value.type() == UniValue::VSTR)
arbiter_str = arbiter_value.get_str();
const UniValue& buyer_value = find_value(o, "buyer");
if (buyer_value.type() == UniValue::VSTR)
buyer_str = buyer_value.get_str();
const UniValue& offer_value = find_value(o, "offer");
if (offer_value.type() == UniValue::VSTR)
offer_str = offer_value.get_str();
const UniValue& offertitle_value = find_value(o, "offertitle");
if (offertitle_value.type() == UniValue::VSTR)
offertitle_str = offertitle_value.get_str();
const UniValue& offeraccept_value = find_value(o, "offeracceptlink");
if (offeraccept_value.type() == UniValue::VSTR)
offeraccept_str = offeraccept_value.get_str();
const UniValue& total_value = find_value(o, "total");
if (total_value.type() == UniValue::VSTR)
total_str = total_value.get_str();
const UniValue& status_value = find_value(o, "status");
if (status_value.type() == UniValue::VSTR)
status_str = status_value.get_str();
unixTime = atoi(time_str.c_str());
dateTime.setTime_t(unixTime);
time_str = dateTime.toString().toStdString();
updateEntry(QString::fromStdString(name_str), QString::fromStdString(time_str), QString::fromStdString(seller_str), QString::fromStdString(arbiter_str), QString::fromStdString(offer_str), QString::fromStdString(offertitle_str), QString::fromStdString(offeraccept_str), QString::fromStdString(total_str), QString::fromStdString(status_str), QString::fromStdString(buyer_str), type, CT_NEW);
}
}
}
catch (UniValue& objError)
{
return;
}
catch(std::exception& e)
{
return;
}
}
// qLowerBound() and qUpperBound() require our cachedEscrowTable list to be sorted in asc order
qSort(cachedEscrowTable.begin(), cachedEscrowTable.end(), EscrowTableEntryLessThan());
}
//! This function corrects the DNs in a given brick.
//! It also stores results in frameletOffsetsForBand every time the
//! band changes so it doesn't have to re-project at every framelet.
//! Equivalent changes are calculated for the next framelet... that is,
//! equivalent pixels. This function both calculates and applies these.
void RemoveSeam(Buffer &out, int framelet, int band,
bool matchIsEven) {
// Apply fixes from last pass. Basically all changes happen in two
// places, because the DNs exist in two cubes, this is the second
// place.
for(int fix = 0; fix < nextFrameletFixes.size(); fix ++) {
QPair<int, int> fixLoc = nextFrameletFixes[fix].first;
double fixDn = nextFrameletFixes[fix].second;
try {
int outIndex = out.Index(fixLoc.first, fixLoc.second, band);
out[outIndex] = fixDn;
}
catch(IException &) {
}
}
nextFrameletFixes.clear();
// Match == goodData. "goodData" is the top of the next framelet.
Cube *goodDataCube = (matchIsEven) ? evenCube : oddCube;
// "badData" is the bottom of the current framelet, what we were given.
Cube *badDataCube = (matchIsEven) ? oddCube : evenCube;
Camera *goodCam = goodDataCube->camera();
Camera *badCam = badDataCube->camera();
// Verify we're at the correct band
goodCam->SetBand(band);
badCam->SetBand(band);
// Absolute line number for top of framelets.
int goodDataStart = frameletSize * (framelet + 1);
int badDataStart = frameletSize * framelet;
// Start corrections to the current brick at this line
int badLineStart = goodDataStart - overlapSize - 1;
// End corrections to the current brick at this line
int badLineEnd = goodDataStart - 1;
int offsetSample = 0;
int offsetLine = 0;
// Loop left to right, top to bottom of problematic area at bottom of framelet
for(int badLine = badLineStart; badLine <= badLineEnd; badLine ++) {
for(int sample = 1; sample <= out.SampleDimension(); sample ++) {
// A fair good data weight is the % across problematic area so fair
double goodDataWeight = (double)(badLine - badLineStart) /
(double)(badLineEnd - badLineStart);
// But good data is good, so let's bias it towards the good data
goodDataWeight *= 2;
if(goodDataWeight > 1) goodDataWeight = 1;
// Bad data weight is the inverse of the good data's weight.
double badDataWeight = 1.0 - goodDataWeight;
int outIndex = out.Index(sample, badLine, band);
// This is the indexing scheme for frameletOffsetsForBand
int optimizeIndex = (badLine - badLineStart) * out.SampleDimension() +
sample - 1;
// Does the optimized (pre-calculated) translation from bad to good
// exist?
if(optimizeIndex < frameletOffsetsForBand.size()) {
// This offset any good? If not then do nothing.
if(!frameletOffsetsForBand[optimizeIndex].Valid())
continue;
// Use optimization!
offsetSample = frameletOffsetsForBand[optimizeIndex].SampleOffset();
offsetLine = frameletOffsetsForBand[optimizeIndex].LineOffset();
ASSERT(frameletOffsetsForBand[optimizeIndex].Sample() == sample);
}
// There is no pre-calculated translation, calculate it
else if(badCam->SetImage(sample, badLine)) {
double lat = badCam->UniversalLatitude();
double lon = badCam->UniversalLongitude();
if(goodCam->SetUniversalGround(lat, lon)) {
double goodSample = goodCam->Sample();
double goodLine = goodCam->Line();
// Set the current offset for correction
offsetSample = (int)(goodSample - sample + 0.5);
offsetLine = (int)(goodLine - badLine + 0.5);
// Remember this calculation for future passes
frameletOffsetsForBand.push_back(Offset(sample, badLine - badDataStart,
offsetSample, offsetLine));
}
else {
// Don't do anything since we failed at this pixel; it will be copied
// from the input directly
frameletOffsetsForBand.push_back(Offset());
continue;
}
}
// Translate current sample,line (bad) to (good) data's sample,line
double goodSample = offsetSample + sample;
double goodLine = offsetLine + badLine;
// Get the pixel we're missing (good)
Portal p(1, 1, goodDataCube->pixelType());
p.SetPosition(goodSample, goodLine, band);
goodDataCube->read(p);
// Attempt to apply weighted average
if(!Isis::IsSpecial(p[0]) && !Isis::IsSpecial(out[outIndex])) {
out[outIndex] = p[0] * goodDataWeight + out[outIndex] * badDataWeight;
}
else if(!Isis::IsSpecial(p[0])) {
out[outIndex] = p[0];
}
// Apply change to next framelet also
QPair<int, int> fixLoc((int)(goodSample + 0.5),
(int)(goodLine + 0.5));
QPair< QPair<int, int>, double > fix(fixLoc, out[outIndex]);
nextFrameletFixes.push_back(fix);
}
}
}
// calculates the metatypes for the method
// the slot must have the parameters in the following form:
// - zero or more value or const-ref parameters of any kind
// - zero or one const ref of QDBusMessage
// - zero or more non-const ref parameters
// No parameter may be a template.
// this function returns -1 if the parameters don't match the above form
// this function returns the number of *input* parameters, including the QDBusMessage one if any
// this function does not check the return type, so metaTypes[0] is always 0 and always present
// metaTypes.count() >= retval + 1 in all cases
//
// sig must be the normalised signature for the method
int qDBusParametersForMethod(const QMetaMethod &mm, QList<int>& metaTypes)
{
QDBusMetaTypeId::init();
QList<QByteArray> parameterTypes = mm.parameterTypes();
metaTypes.clear();
metaTypes.append(0); // return type
int inputCount = 0;
bool seenMessage = false;
QList<QByteArray>::ConstIterator it = parameterTypes.constBegin();
QList<QByteArray>::ConstIterator end = parameterTypes.constEnd();
for ( ; it != end; ++it) {
const QByteArray &type = *it;
if (type.endsWith('*')) {
//qWarning("Could not parse the method '%s'", mm.signature());
// pointer?
return -1;
}
if (type.endsWith('&')) {
QByteArray basictype = type;
basictype.truncate(type.length() - 1);
int id = qDBusNameToTypeId(basictype);
if (id == 0) {
//qWarning("Could not parse the method '%s'", mm.signature());
// invalid type in method parameter list
return -1;
} else if (QDBusMetaType::typeToSignature(id) == 0)
return -1;
metaTypes.append( id );
seenMessage = true; // it cannot appear anymore anyways
continue;
}
if (seenMessage) { // && !type.endsWith('&')
//qWarning("Could not parse the method '%s'", mm.signature());
// non-output parameters after message or after output params
return -1; // not allowed
}
int id = qDBusNameToTypeId(type);
if (id == 0) {
//qWarning("Could not parse the method '%s'", mm.signature());
// invalid type in method parameter list
return -1;
}
if (id == QDBusMetaTypeId::message)
seenMessage = true;
else if (QDBusMetaType::typeToSignature(id) == 0)
return -1;
metaTypes.append(id);
++inputCount;
}
return inputCount;
}
void Settings::SetDefaultSettings()
{
pMain->showMaximized();
QList<int> intList;
intList.append(qRound(pMain->GetUi()->splitter->height()*.5));
intList.append(qRound(pMain->GetUi()->splitter->height()*.25));
intList.append(qRound(pMain->GetUi()->splitter->height()*.25));
pMain->GetUi()->splitter->setSizes(intList);
intList.clear();
intList.append(qRound(pMain->GetUi()->splitter->width()*.25));
intList.append(qRound(pMain->GetUi()->splitter->width()*.75));
pMain->GetUi()->rulesSplitter->setSizes(intList);
intList.clear();
intList.append(qRound(pMain->GetUi()->splitter->width()*.80));
intList.append(qRound(pMain->GetUi()->splitter->width()*.20));
pMain->GetUi()->browserSplitter->setSizes(intList);
intList.clear();
intList.append(50);
intList.append(25);
intList.append(25);
intList.append(25);
intList.append(600);
intList.append(150);
intList.append(100);
intList.append(70);
for(int i = 0; i < intList.size(); i++)
pMain->GetUi()->browserTable->setColumnWidth(i, intList.at(i));
pMain->GetUi()->browserTable->horizontalHeader()->setSectionResizeMode(1, QHeaderView::Fixed);
pMain->GetUi()->browserTable->horizontalHeader()->setSectionResizeMode(2, QHeaderView::Fixed);
pMain->GetUi()->browserTable->horizontalHeader()->setSectionResizeMode(3, QHeaderView::Fixed);
pMain->GetUi()->browserTable->horizontalHeaderItem(5)->setTextAlignment(Qt::AlignLeft);
pMain->GetUi()->browserTable->horizontalHeaderItem(6)->setTextAlignment(Qt::AlignLeft);
intList.clear();
intList.append(125);
intList.append(125);
for(int i = 0; i < intList.size(); i++)
pMain->GetUi()->rulesTable->setColumnWidth(i, intList.at(i));
intList.clear();
intList.append(75);
intList.append(225);
intList.append(100);
intList.append(150);
intList.append(200);
for(int i = 0; i < intList.size(); i++)
pMain->GetUi()->playerTable->setColumnWidth(i, intList.at(i));
qsrand((uint)(QTime::currentTime()).msec());
pMain->u16logPort = qrand() % ((PORT_MAX + 1) - PORT_MIN) + PORT_MIN;
pMain->showLoggingInfo = true;
}
int QgsSnapper::snapMapPoint( const QgsPoint& mapCoordPoint, QList<QgsSnappingResult>& snappingResult, const QList<QgsPoint>& excludePoints )
{
snappingResult.clear();
QMultiMap<double, QgsSnappingResult> snappingResultList;//all snapping results
QMultiMap<double, QgsSnappingResult> currentResultList; //snapping results of examined layer
//start point in (output) map coordinates
QgsPoint layerCoordPoint; //start point in layer coordinates
QgsSnappingResult newResult;
QList<QgsSnapper::SnapLayer>::iterator snapLayerIt;
for ( snapLayerIt = mSnapLayers.begin(); snapLayerIt != mSnapLayers.end(); ++snapLayerIt )
{
if ( !snapLayerIt->mLayer->hasGeometryType() )
continue;
currentResultList.clear();
//transform point from map coordinates to layer coordinates
layerCoordPoint = mMapSettings.mapToLayerCoordinates( snapLayerIt->mLayer, mapCoordPoint );
double tolerance = QgsTolerance::toleranceInMapUnits( snapLayerIt->mTolerance, snapLayerIt->mLayer, mMapSettings, snapLayerIt->mUnitType );
if ( snapLayerIt->mLayer->snapWithContext( layerCoordPoint, tolerance,
currentResultList, snapLayerIt->mSnapTo ) != 0 )
{
//error
}
//transform each result from layer crs to map crs (including distance)
QMultiMap<double, QgsSnappingResult>::iterator currentResultIt;
for ( currentResultIt = currentResultList.begin(); currentResultIt != currentResultList.end(); ++currentResultIt )
{
//for each snapping result: transform start point, snap point and other points into map coordinates to find out distance
//store results in snapping result list
newResult = currentResultIt.value();
newResult.snappedVertex = mMapSettings.layerToMapCoordinates( snapLayerIt->mLayer, currentResultIt.value().snappedVertex );
newResult.beforeVertex = mMapSettings.layerToMapCoordinates( snapLayerIt->mLayer, currentResultIt.value().beforeVertex );
newResult.afterVertex = mMapSettings.layerToMapCoordinates( snapLayerIt->mLayer, currentResultIt.value().afterVertex );
snappingResultList.insert( sqrt( newResult.snappedVertex.sqrDist( mapCoordPoint ) ), newResult );
}
}
//excluded specific points from result
cleanResultList( snappingResultList, excludePoints );
//evaluate results according to snap mode
QMultiMap<double, QgsSnappingResult>::iterator evalIt = snappingResultList.begin();
if ( evalIt == snappingResultList.end() )
{
return 0;
}
//Gives a priority to vertex snapping over segment snapping
QgsSnappingResult returnResult = evalIt.value();
for ( evalIt = snappingResultList.begin(); evalIt != snappingResultList.end(); ++evalIt )
{
if ( evalIt.value().snappedVertexNr != -1 )
{
returnResult = evalIt.value();
snappingResultList.erase( evalIt );
break;
}
}
//We return the preferred result
snappingResult.push_back( returnResult );
if ( mSnapMode == QgsSnapper::SnapWithOneResult )
{
//return only a single result, nothing more to do
}
else if ( mSnapMode == QgsSnapper::SnapWithResultsForSamePosition )
{
//take all snapping results within a certain tolerance because rounding differences may occur
double tolerance = 0.000001;
for ( evalIt = snappingResultList.begin(); evalIt != snappingResultList.end(); ++evalIt )
{
if ( returnResult.snappedVertex.sqrDist( evalIt.value().snappedVertex ) < tolerance*tolerance )
{
snappingResult.push_back( evalIt.value() );
}
}
}
else //take all results
{
for ( evalIt = snappingResultList.begin(); evalIt != snappingResultList.end(); ++evalIt )
{
snappingResult.push_back( evalIt.value() );
}
}
return 0;
}
// The index timer has expired. Look for any unindexed notes or resources
void IndexRunner::index() {
if (disableIndexing)
return;
if (!keepRunning || pauseIndexing) {
return;
}
if (!init)
initialize();
indexTimer->stop(); // Stop the timer because we are already working
indexTimer->setInterval(global.minIndexInterval);
QList<qint32> lids;
NoteTable noteTable(&db->conn);
ResourceTable resourceTable(&db->conn);
bool endMsgNeeded = false;
int countPause = global.indexNoteCountPause;
QList<qint32> finishedLids;
// Get any unindexed notes
if (keepRunning && !pauseIndexing && noteTable.getIndexNeeded(lids) > 0) {
QApplication::processEvents();
endMsgNeeded = true;
QLOG_DEBUG() << "Unindexed Notes found: " << lids.size();
// Index any undindexed note content.
for (int i=0; keepRunning && !pauseIndexing && i<lids.size(); i++) {
QApplication::processEvents();
Note n;
noteTable.get(n, lids[i], false, false);
indexNote(lids[i],n);
finishedLids.append(lids[i]);
if (countPause <=0) {
flushCache();
for (int j=0; j<finishedLids.size(); j++)
noteTable.setIndexNeeded(finishedLids[j], false);
indexTimer->start();
return;
}
countPause--;
}
}
if (keepRunning && !pauseIndexing)
flushCache();
for (int j=0; !pauseIndexing && keepRunning && j<finishedLids.size(); j++)
noteTable.setIndexNeeded(finishedLids[j], false);
lids.clear(); // Clear out the list so we can start on resources
if (!keepRunning || pauseIndexing) {
indexTimer->start();
return;
}
countPause = global.indexResourceCountPause;
finishedLids.clear();
// Start indexing resources
if (keepRunning && !pauseIndexing && resourceTable.getIndexNeeded(lids) > 0) {
endMsgNeeded = true;
// Index each resource that is needed.
for (int i=0; keepRunning && !pauseIndexing && i<lids.size(); i++) {
QApplication::processEvents();
Resource r;
resourceTable.get(r, lids.at(i), false);
qint32 noteLid = noteTable.getLid(r.noteGuid);
indexRecognition(noteLid, r);
QString mime = "";
if (r.mime.isSet())
mime = r.mime;
if (mime == "application/pdf")
indexPdf(noteLid, r);
else {
if (mime.startsWith("application", Qt::CaseInsensitive))
indexAttachment(noteLid, r);
}
finishedLids.append(lids[i]);
if (countPause <=0) {
flushCache();
for (int j=0; keepRunning && !pauseIndexing && j<finishedLids.size(); j++) {
resourceTable.setIndexNeeded(finishedLids[j], false);
}
indexTimer->start();
return;
}
countPause--;
}
}
if (!keepRunning || pauseIndexing) {
indexTimer->start();
return;
}
if (keepRunning && !pauseIndexing)
flushCache();
for (int j=0; keepRunning && !pauseIndexing && j<finishedLids.size(); j++) {
resourceTable.setIndexNeeded(finishedLids[j], false);
}
if (endMsgNeeded) {
QLOG_DEBUG() << "Indexing completed";
}
indexTimer->setInterval(global.maxIndexInterval);
indexTimer->start();
}
QVariantMap QgsDissolveAlgorithm::processAlgorithm( const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingFeedback *feedback ) const
{
std::unique_ptr< QgsFeatureSource > source( parameterAsSource( parameters, QStringLiteral( "INPUT" ), context ) );
if ( !source )
return QVariantMap();
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, source->fields(), QgsWkbTypes::multiType( source->wkbType() ), source->sourceCrs(), dest ) );
if ( !sink )
return QVariantMap();
QStringList fields = parameterAsFields( parameters, QStringLiteral( "FIELD" ), context );
long count = source->featureCount();
if ( count <= 0 )
return QVariantMap();
QgsFeature f;
QgsFeatureIterator it = source->getFeatures();
double step = 100.0 / count;
int current = 0;
if ( fields.isEmpty() )
{
// dissolve all - not using fields
bool firstFeature = true;
// we dissolve geometries in blocks using unaryUnion
QList< QgsGeometry > geomQueue;
QgsFeature outputFeature;
while ( it.nextFeature( f ) )
{
if ( feedback->isCanceled() )
{
break;
}
if ( firstFeature )
{
outputFeature = f;
firstFeature = false;
}
if ( f.hasGeometry() && f.geometry() )
{
geomQueue.append( f.geometry() );
if ( geomQueue.length() > 10000 )
{
// queue too long, combine it
QgsGeometry tempOutputGeometry = QgsGeometry::unaryUnion( geomQueue );
geomQueue.clear();
geomQueue << tempOutputGeometry;
}
}
feedback->setProgress( current * step );
current++;
}
outputFeature.setGeometry( QgsGeometry::unaryUnion( geomQueue ) );
sink->addFeature( outputFeature );
}
else
{
QList< int > fieldIndexes;
Q_FOREACH ( const QString &field, fields )
{
int index = source->fields().lookupField( field );
if ( index >= 0 )
fieldIndexes << index;
}
QHash< QVariant, QgsAttributes > attributeHash;
QHash< QVariant, QList< QgsGeometry > > geometryHash;
while ( it.nextFeature( f ) )
{
if ( feedback->isCanceled() )
{
break;
}
if ( f.hasGeometry() && f.geometry() )
{
QVariantList indexAttributes;
Q_FOREACH ( int index, fieldIndexes )
{
indexAttributes << f.attribute( index );
}
if ( !attributeHash.contains( indexAttributes ) )
{
// keep attributes of first feature
attributeHash.insert( indexAttributes, f.attributes() );
}
geometryHash[ indexAttributes ].append( f.geometry() );
}
bool JsonParser::read( QIODevice* device )
{
// Assert previous document got released.
delete m_document;
m_document = new GeoDataDocument;
Q_ASSERT( m_document );
// Read file data
QJsonParseError error;
const QJsonDocument jsonDoc = QJsonDocument::fromJson(device->readAll(), &error);
if (jsonDoc.isNull()) {
qDebug() << "Error parsing GeoJSON : " << error.errorString();
return false;
}
// Start parsing
const QJsonValue featuresValue = jsonDoc.object().value(QStringLiteral("features"));
// In GeoJSON format, geometries are stored in features, so we iterate on features
if (featuresValue.isArray()) {
const QJsonArray featureArray = featuresValue.toArray();
// Parse each feature
for (int featureIndex = 0; featureIndex < featureArray.size(); ++featureIndex) {
const QJsonObject featureObject = featureArray[featureIndex].toObject();
// Check if the feature contains a geometry
const QJsonValue geometryValue = featureObject.value(QStringLiteral("geometry"));
if (geometryValue.isObject()) {
const QJsonObject geometryObject = geometryValue.toObject();
// Variables for creating the geometry
QList<GeoDataGeometry*> geometryList;
QList<GeoDataPlacemark*> placemarkList;
// Create the different geometry types
const QString geometryType = geometryObject.value(QStringLiteral("type")).toString().toUpper();
if (geometryType == QLatin1String("POLYGON")) {
// Check first that there are coordinates
const QJsonValue coordinatesValue = geometryObject.value(QStringLiteral("coordinates"));
if (coordinatesValue.isArray()) {
const QJsonArray coordinateArray = coordinatesValue.toArray();
GeoDataPolygon * geom = new GeoDataPolygon( RespectLatitudeCircle | Tessellate );
// Coordinates first array will be the outer boundary, if there are more
// positions those will be inner holes
for (int ringIndex = 0 ; ringIndex < coordinateArray.size(); ++ringIndex) {
const QJsonArray ringArray = coordinateArray[ringIndex].toArray();
GeoDataLinearRing linearRing;
for (int coordinatePairIndex = 0; coordinatePairIndex < ringArray.size(); ++coordinatePairIndex) {
const QJsonArray coordinatePairArray = ringArray[coordinatePairIndex].toArray();
const qreal longitude = coordinatePairArray.at(0).toDouble();
const qreal latitude = coordinatePairArray.at(1).toDouble();
linearRing.append( GeoDataCoordinates( longitude , latitude , 0 , GeoDataCoordinates::Degree ) );
}
// Outer ring
if (ringIndex == 0) {
geom->setOuterBoundary( linearRing );
}
// Inner holes
else {
geom->appendInnerBoundary( linearRing );
}
}
geometryList.append( geom );
}
} else if (geometryType == QLatin1String("MULTIPOLYGON")) {
// Check first that there are coordinates
const QJsonValue coordinatesValue = geometryObject.value(QStringLiteral("coordinates"));
if (coordinatesValue.isArray()) {
const QJsonArray coordinateArray = coordinatesValue.toArray();
for (int polygonIndex = 0; polygonIndex < coordinateArray.size(); ++polygonIndex) {
const QJsonArray polygonArray = coordinateArray[polygonIndex].toArray();
GeoDataPolygon * geom = new GeoDataPolygon( RespectLatitudeCircle | Tessellate );
// Coordinates first array will be the outer boundary, if there are more
// positions those will be inner holes
for (int ringIndex = 0 ; ringIndex < polygonArray.size(); ++ringIndex) {
const QJsonArray ringArray = polygonArray[ringIndex].toArray();
GeoDataLinearRing linearRing;
for (int coordinatePairIndex = 0; coordinatePairIndex < ringArray.size(); ++coordinatePairIndex) {
const QJsonArray coordinatePairArray = ringArray[coordinatePairIndex].toArray();
const qreal longitude = coordinatePairArray.at(0).toDouble();
const qreal latitude = coordinatePairArray.at(1).toDouble();
linearRing.append( GeoDataCoordinates( longitude , latitude , 0 , GeoDataCoordinates::Degree ) );
}
// Outer ring
if (ringIndex == 0) {
geom->setOuterBoundary( linearRing );
}
// Inner holes
else {
geom->appendInnerBoundary( linearRing );
}
}
geometryList.append( geom );
}
}
} else if (geometryType == QLatin1String("LINESTRING")) {
// Check first that there are coordinates
const QJsonValue coordinatesValue = geometryObject.value(QStringLiteral("coordinates"));
if (coordinatesValue.isArray()) {
const QJsonArray coordinateArray = coordinatesValue.toArray();
GeoDataLineString * geom = new GeoDataLineString( RespectLatitudeCircle | Tessellate );
for (int coordinatePairIndex = 0; coordinatePairIndex < coordinateArray.size(); ++coordinatePairIndex) {
const QJsonArray coordinatePairArray = coordinateArray[coordinatePairIndex].toArray();
const qreal longitude = coordinatePairArray.at(0).toDouble();
const qreal latitude = coordinatePairArray.at(1).toDouble();
geom->append( GeoDataCoordinates( longitude , latitude , 0 , GeoDataCoordinates::Degree ) );
}
geometryList.append( geom );
}
} else if (geometryType == QLatin1String("MULTILINESTRING")) {
// Check first that there are coordinates
const QJsonValue coordinatesValue = geometryObject.value(QStringLiteral("coordinates"));
if (coordinatesValue.isArray()) {
const QJsonArray coordinateArray = coordinatesValue.toArray();
for (int lineStringIndex = 0; lineStringIndex < coordinateArray.size(); ++lineStringIndex) {
const QJsonArray lineStringArray = coordinateArray[lineStringIndex].toArray();
GeoDataLineString * geom = new GeoDataLineString( RespectLatitudeCircle | Tessellate );
for (int coordinatePairIndex = 0; coordinatePairIndex < lineStringArray.size(); ++coordinatePairIndex) {
const QJsonArray coordinatePairArray = lineStringArray[coordinatePairIndex].toArray();
const qreal longitude = coordinatePairArray.at(0).toDouble();
const qreal latitude = coordinatePairArray.at(1).toDouble();
geom->append( GeoDataCoordinates( longitude , latitude , 0 , GeoDataCoordinates::Degree ) );
}
geometryList.append( geom );
}
}
} else if (geometryType == QLatin1String("POINT")) {
// Check first that there are coordinates
const QJsonValue coordinatesValue = geometryObject.value(QStringLiteral("coordinates"));
if (coordinatesValue.isArray()) {
const QJsonArray coordinatePairArray = coordinatesValue.toArray();
GeoDataPoint * geom = new GeoDataPoint();
const qreal longitude = coordinatePairArray.at(0).toDouble();
const qreal latitude = coordinatePairArray.at(1).toDouble();
geom->setCoordinates( GeoDataCoordinates( longitude , latitude , 0 , GeoDataCoordinates::Degree ) );
geometryList.append( geom );
}
} else if (geometryType == QLatin1String("MULTIPOINT")) {
// Check first that there are coordinates
const QJsonValue coordinatesValue = geometryObject.value(QStringLiteral("coordinates"));
if (coordinatesValue.isArray()) {
const QJsonArray coordinateArray = coordinatesValue.toArray();
for (int pointIndex = 0; pointIndex < coordinateArray.size(); ++pointIndex) {
const QJsonArray coordinatePairArray = coordinateArray[pointIndex].toArray();
GeoDataPoint * geom = new GeoDataPoint();
const qreal longitude = coordinatePairArray.at(0).toDouble();
const qreal latitude = coordinatePairArray.at(1).toDouble();
geom->setCoordinates( GeoDataCoordinates( longitude , latitude , 0 , GeoDataCoordinates::Degree ) );
geometryList.append( geom );
}
}
}
// Parse the features properties
const QJsonValue propertiesValue = featureObject.value(QStringLiteral("properties"));
if (!geometryList.isEmpty() && propertiesValue.isObject()) {
const QJsonObject propertiesObject = propertiesValue.toObject();
// First create a placemark for each geometry, there could be multi geometries
// that are translated into more than one geometry/placemark
for ( int numberGeometries = 0 ; numberGeometries < geometryList.length() ; numberGeometries++ ) {
GeoDataPlacemark * placemark = new GeoDataPlacemark();
placemarkList.append( placemark );
}
OsmPlacemarkData osmData;
QJsonObject::ConstIterator it = propertiesObject.begin();
const QJsonObject::ConstIterator end = propertiesObject.end();
for ( ; it != end; ++it) {
if (it.value().isObject() || it.value().isArray()) {
qDebug() << "Skipping property, values of type arrays and objects not supported:" << it.key();
continue;
}
// pass value through QVariant to also get bool & numbers
osmData.addTag(it.key(), it.value().toVariant().toString());
}
// If the property read, is the features name
const auto tagIter = osmData.findTag(QStringLiteral("name"));
if (tagIter != osmData.tagsEnd()) {
const QString& name = tagIter.value();
for (int pl = 0 ; pl < placemarkList.length(); ++pl) {
placemarkList.at(pl)->setName(name);
}
}
const GeoDataPlacemark::GeoDataVisualCategory category = StyleBuilder::determineVisualCategory(osmData);
if (category != GeoDataPlacemark::None) {
// Add the visual category to all the placemarks
for (int pl = 0 ; pl < placemarkList.length(); ++pl) {
placemarkList.at(pl)->setVisualCategory(category);
placemarkList.at(pl)->setOsmData(osmData);
}
}
}
// Add the geometry to the document
if ( geometryList.length() == placemarkList.length() ) {
while( placemarkList.length() > 0 ) {
GeoDataPlacemark * placemark = placemarkList.last();
placemarkList.pop_back();
GeoDataGeometry * geom = geometryList.last();
geometryList.pop_back();
placemark->setGeometry( geom );
placemark->setVisible( true );
m_document->append( placemark );
}
}
// If geometries or placemarks missing inside the lists, delete them
qDeleteAll( geometryList.begin(), geometryList.end() );
geometryList.clear();
qDeleteAll( placemarkList.begin(), placemarkList.end() );
placemarkList.clear();
}
}
}
return true;
}
void
AbstractTrackTableCommitter::commit( const QList<Meta::SqlTrackPtr> &tracks )
{
// Note: The code is greatly inspired by the old ScanResultProcessor
// by jeffrai
// Note2: The code is optimized for batch update.
// Reason: a single update is completely harmless and not frequent.
// The real difficulty is the collection scanner and it's runtime
// Especially with collections larger than 30000 tracks.
if( tracks.isEmpty() )
return;
m_storage = tracks.first()->sqlCollection()->sqlStorage();
// -- get the maximum size for our commit
static int maxSize = 0;
if( maxSize == 0 )
{
QStringList res = m_storage->query( "SHOW VARIABLES LIKE 'max_allowed_packet';" );
if( res.size() < 2 || res[1].toInt() == 0 )
{
warning() << "Uh oh! For some reason MySQL thinks there isn't a max allowed size!";
return;
}
debug() << "obtained max_allowed_packet is " << res[1];
maxSize = res[1].toInt() / 3; //for safety, due to multibyte encoding
}
QStringList fields = getFields();
const QString updateQueryStart = "UPDATE LOW_PRIORITY "+tableName()+" SET ";
const QString insertQueryStart = "INSERT INTO "+tableName()+
" ("+fields.join(",")+") VALUES ";
QList< Meta::SqlTrackPtr > insertedTracks;
QString insertQuery;
insertQuery.reserve( 1024 ); // a sensible initial size
foreach( Meta::SqlTrackPtr track, tracks )
{
QStringList values = getValues( track.data() );
// -- update
if( getId( track.data() ) > 0 )
{
// we just commit all values to save code complexity.
// we would need to track the real changed fields otherwise
QString updateQuery;
updateQuery.reserve( 256 ); // a sensible initial size
for( int i = 0; i < fields.count() && i < values.count(); i++ )
{
if( !updateQuery.isEmpty() )
updateQuery += ", ";
updateQuery += fields.at( i );
updateQuery += '=';
updateQuery += values.at( i );
}
updateQuery = updateQueryStart + updateQuery +
" WHERE id=" + QString::number( getId( track.data() ) ) + ';';
m_storage->query( updateQuery );
}
else
// -- insert
{
QString newValues = '(' + values.join(",") + ')';
// - if the insertQuery is long enough, commit it.
if( insertQueryStart.length() + insertQuery.length() + newValues.length() + 1 >= maxSize - 3 ) // ";"
{
// commit
insertQuery = insertQueryStart + insertQuery + ';';
int firstId = m_storage->insert( insertQuery, tableName() );
// set the resulting ids
if( firstId <= 0 )
warning() << "Insert failed.";
for( int i = 0; i < insertedTracks.count(); i++ )
setId( const_cast<Meta::SqlTrack*>(insertedTracks.at( i ).data()),
firstId + i );
insertQuery.clear();
insertedTracks.clear();
}
if( !insertQuery.isEmpty() )
insertQuery += ',';
insertQuery += newValues;
insertedTracks.append( track );
}
}
void SymbolNode::getChildList( QList<Ptr>& childList ) const
{
childList.clear();
for (ConstChildIterator pChild = childConstBegin(); pChild != childConstEnd(); ++pChild)
childList.push_back(pChild.value());
}
unsigned char* QgsDistanceArea::measurePolygon( unsigned char* feature, double* area, double* perimeter, bool hasZptr )
{
// get number of rings in the polygon
unsigned int numRings = *(( int* )( feature + 1 + sizeof( int ) ) );
if ( numRings == 0 )
return 0;
// Set pointer to the first ring
unsigned char* ptr = feature + 1 + 2 * sizeof( int );
QList<QgsPoint> points;
QgsPoint pnt;
double x, y;
if ( area )
*area = 0;
if ( perimeter )
*perimeter = 0;
try
{
for ( unsigned int idx = 0; idx < numRings; idx++ )
{
int nPoints = *(( int* )ptr );
ptr += 4;
// Extract the points from the WKB and store in a pair of
// vectors.
for ( int jdx = 0; jdx < nPoints; jdx++ )
{
x = *(( double * ) ptr );
ptr += sizeof( double );
y = *(( double * ) ptr );
ptr += sizeof( double );
if ( hasZptr )
{
// totally ignore Z value
ptr += sizeof( double );
}
pnt = QgsPoint( x, y );
if ( mProjectionsEnabled && ( mEllipsoid != "NONE" ) )
{
pnt = mCoordTransform->transform( pnt );
}
points.append( pnt );
}
if ( points.size() > 2 )
{
if ( area )
{
double areaTmp = computePolygonArea( points );
if ( idx == 0 )
{
// exterior ring
*area += areaTmp;
}
else
{
*area -= areaTmp; // interior rings
}
}
if ( perimeter )
{
*perimeter += measureLine( points );
}
}
points.clear();
if ( !area )
{
break;
}
}
}
catch ( QgsCsException &cse )
{
Q_UNUSED( cse );
QgsMessageLog::logMessage( QObject::tr( "Caught a coordinate system exception while trying to transform a point. Unable to calculate polygon area or perimeter." ) );
}
return ptr;
}
bool DigitizerSetTreeItem::addData(const FIFFLIB::FiffDigPointSet& tDigitizer, Qt3DCore::QEntity* parent)
{
bool state = false;
//parsing the digitizer List
QList<FIFFLIB::FiffDigPoint> tNasion;
QList<FIFFLIB::FiffDigPoint> tLAP;
QList<FIFFLIB::FiffDigPoint> tRAP;
QList<FIFFLIB::FiffDigPoint> tHpi;
QList<FIFFLIB::FiffDigPoint> tEeg;
QList<FIFFLIB::FiffDigPoint> tExtra;
for(int i = 0; i < tDigitizer.size(); ++i){
switch (tDigitizer[i].kind) {
case FIFFV_POINT_CARDINAL:
switch (tDigitizer[i].ident) {
case FIFFV_POINT_LPA:
tLAP.append(tDigitizer[i]);
break;
case FIFFV_POINT_NASION:
tNasion.append(tDigitizer[i]);
break;
case FIFFV_POINT_RPA:
tRAP.append(tDigitizer[i]);
break;
default:
break;
}
break;
case FIFFV_POINT_HPI:
tHpi.append(tDigitizer[i]);
break;
case FIFFV_POINT_EEG:
tEeg.append(tDigitizer[i]);
break;
case FIFFV_POINT_EXTRA:
tExtra.append(tDigitizer[i]);
break;
default:
break;
}
}
// Find the Digitizer Items
QList<QStandardItem*> itemList = this->findChildren(Data3DTreeModelItemTypes::DigitizerItem);
if (!tLAP.empty()){
//Create a LAP digitizer item
DigitizerTreeItem* digitizerItem = new DigitizerTreeItem(Data3DTreeModelItemTypes::DigitizerItem,"LAP");
state = digitizerItem->addData(tLAP, parent);
itemList << digitizerItem;
itemList << new QStandardItem(digitizerItem->toolTip());
this->appendRow(itemList);
itemList.clear();
}
if (!tNasion.empty()){
//Create a Nasion digitizer item
DigitizerTreeItem* digitizerItem = new DigitizerTreeItem(Data3DTreeModelItemTypes::DigitizerItem,"Nasion");
state = digitizerItem->addData(tNasion, parent);
itemList << digitizerItem;
itemList << new QStandardItem(digitizerItem->toolTip());
this->appendRow(itemList);
itemList.clear();
}
if (!tRAP.empty()){
//Create a RAO digitizer item
DigitizerTreeItem* digitizerItem = new DigitizerTreeItem(Data3DTreeModelItemTypes::DigitizerItem,"RAP");
state = digitizerItem->addData(tRAP, parent);
itemList << digitizerItem;
itemList << new QStandardItem(digitizerItem->toolTip());
this->appendRow(itemList);
itemList.clear();
}
if (!tHpi.empty()){
//Create a HPI digitizer item
DigitizerTreeItem* digitizerItem = new DigitizerTreeItem(Data3DTreeModelItemTypes::DigitizerItem,"HPI");
state = digitizerItem->addData(tHpi, parent);
itemList << digitizerItem;
itemList << new QStandardItem(digitizerItem->toolTip());
this->appendRow(itemList);
itemList.clear();
}
if (!tEeg.empty()){
//Create a EEG digitizer item
DigitizerTreeItem* digitizerItem = new DigitizerTreeItem(Data3DTreeModelItemTypes::DigitizerItem,"EEG/ECG");
state = digitizerItem->addData(tEeg, parent);
itemList << digitizerItem;
itemList << new QStandardItem(digitizerItem->toolTip());
this->appendRow(itemList);
itemList.clear();
}
if (!tExtra.empty()){
//Create a extra digitizer item
DigitizerTreeItem* digitizerItem = new DigitizerTreeItem(Data3DTreeModelItemTypes::DigitizerItem,"Extra");
state = digitizerItem->addData(tExtra, parent);
itemList << digitizerItem;
itemList << new QStandardItem(digitizerItem->toolTip());
this->appendRow(itemList);
itemList.clear();
}
return state;
}
void MainWindow::loadListFile()
{
qDebug() << "Loading list file:" << listFile->text();
QFile lf(listFile->text());
if (!lf.open(QFile::ReadOnly)) {
qWarning("Cannot open list file!");
return;
}
QTextStream ts(&lf);
ts.setCodec("UTF-8");
if (ts.status() != QTextStream::Ok) {
lf.close();
qWarning("Cannot construct text stream!");
return;
}
tree->clear();
QTreeWidgetItem *item = tree->invisibleRootItem();
while (!ts.atEnd()) {
QString line = ts.readLine();
if (line.isEmpty())
continue;
if (!filter->text().isEmpty())
if (QRegExp(filter->text(), Qt::CaseInsensitive).indexIn(line) == -1)
continue;
QStringList lv = line.split('/', QString::SkipEmptyParts);
// Extract parent path
QList<QTreeWidgetItem *> list;
while (item && item != tree->invisibleRootItem()) {
list.push_front(item);
item = item->parent();
}
while (!lv.isEmpty()) {
QString str = lv.takeFirst();
// TODO: parent folder .. support
if (str.isEmpty() || str == ".")
continue;
// Remove common path from parent path
if (!list.isEmpty()) {
QTreeWidgetItem *it = list.takeFirst();
if (it->text(0) == str) {
item = it;
continue;
} else
list.clear();
}
// Find entry
if (!item)
item = tree->invisibleRootItem();
int i;
for (i = 0; i < item->childCount(); i++)
if (item->child(i)->text(0) == str)
break;
if (i == item->childCount())
item = new QTreeWidgetItem(item, QStringList(str));
else
item = item->child(i);
}
}
// Sort entries
tree->sortByColumn(0, Qt::AscendingOrder);
// Add file icons
QFileIconProvider fip;
QMap<QString, QIcon> iconMap;
QTreeWidgetItemIterator it(tree->invisibleRootItem());
while (*++it) // Ignore root
if ((*it)->childCount())
(*it)->setIcon(0, fip.icon(fip.Folder));
else {
QFileInfo fi((*it)->text(0));
QString sfx = fi.suffix();
#if 0 // FIXME: File icon retrieval not working
QIcon icon = iconMap[sfx];
if (icon.isNull()) {
QTemporaryFile tf(QDir::tempPath() + "/XXXXXX." + sfx);
tf.open();
iconMap[sfx] = icon = fip.icon(fip.File/*QFileInfo(tf)*/);
}
(*it)->setIcon(0, icon);
#else
iconMap[sfx] = fip.icon(fip.File);
#endif
}
qDebug() << "List file loaded.";
lf.close();
}
SoundGenerator::SoundGenerator(QObject *parent)
: QObject(parent)
, m_clockCount(0)
, m_function(Inactive)
, m_device(0)
, m_timer(new QTimer(this))
{
m_channelA.fineTune = 0;
m_channelA.coarseTune = 0;
m_channelA.amplitudeLevel = 0;
m_channelA.mixValue = 0;
m_channelA.toneOutput = 0;
m_channelA.counter = 0;
m_channelB.fineTune = 0;
m_channelB.coarseTune = 0;
m_channelB.amplitudeLevel = 0;
m_channelB.mixValue = 0;
m_channelB.toneOutput = 0;
m_channelB.counter = 0;
m_channelC.fineTune = 0;
m_channelC.coarseTune = 0;
m_channelC.amplitudeLevel = 0;
m_channelC.mixValue = 0;
m_channelC.toneOutput = 0;
m_channelC.counter = 0;
m_envelope.fineTune = 0;
m_envelope.coarseTune = 0;
m_envelope.counter = 0;
m_envelope.shapePosition = 0;
m_envelope.shouldHold = true;
m_mixerA.isChannelNoiseOn = false;
m_mixerA.isChannelToneOn = false;
m_mixerB.isChannelNoiseOn = false;
m_mixerB.isChannelToneOn = false;
m_mixerC.isChannelNoiseOn = false;
m_mixerC.isChannelToneOn = false;
m_noise.period = 0;
m_noise.rng = 1;
m_noise.noiseOutput = 0xff;
m_noise.counter = 0;
QList<byte_t> shape;
shape << 15 << 14 << 13 << 12 << 11 << 10 << 9 << 8 << 7 << 6 << 5 << 4 << 3 << 2 << 1 << 0;
ENVELOPE_SHAPES.append(shape);
ENVELOPE_SHAPES.append(shape);
ENVELOPE_SHAPES.append(shape);
ENVELOPE_SHAPES.append(shape);
shape.clear();
shape << 0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10 << 11 << 12 << 13 << 14 << 15 << 0;
ENVELOPE_SHAPES.append(shape);
ENVELOPE_SHAPES.append(shape);
ENVELOPE_SHAPES.append(shape);
ENVELOPE_SHAPES.append(shape);
shape.clear();
shape << 15 << 14 << 13 << 12 << 11 << 10 << 9 << 8 << 7 << 6 << 5 << 4 << 3 << 2 << 1 << 0;
ENVELOPE_SHAPES.append(shape);
ENVELOPE_SHAPES.append(shape);
shape.clear();
shape << 15 << 14 << 13 << 12 << 11 << 10 << 9 << 8 << 7 << 6 << 5 << 4 << 3 << 2 << 1 << 0
<< 0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10 << 11 << 12 << 13 << 14 << 15;
ENVELOPE_SHAPES.append(shape);
shape.clear();
shape << 15 << 14 << 13 << 12 << 11 << 10 << 9 << 8 << 7 << 6 << 5 << 4 << 3 << 2 << 1 << 0 << 15;
ENVELOPE_SHAPES.append(shape);
shape.clear();
shape << 0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10 << 11 << 12 << 13 << 14 << 15;
ENVELOPE_SHAPES.append(shape);
ENVELOPE_SHAPES.append(shape);
shape.clear();
shape << 0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10 << 11 << 12 << 13 << 14 << 15
<< 15 << 14 << 13 << 12 << 11 << 10 << 9 << 8 << 7 << 6 << 5 << 4 << 3 << 2 << 1 << 0;
ENVELOPE_SHAPES.append(shape);
shape.clear();
shape << 0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10 << 11 << 12 << 13 << 14 << 15 << 0;
ENVELOPE_SHAPES.append(shape);
m_envelope.currentShape = ENVELOPE_SHAPES[0];
m_audioBuffer.resize(882000);
m_bufferPos = 0;
m_bufferPtr = reinterpret_cast<qint8 *>(m_audioBuffer.data());
connect(m_timer, SIGNAL(timeout()), SLOT(timerExpired()));
m_timer->start(20);
}
/**
* Rearranges the lines, arcs or opened polylines entities
* in this container, non-recoursive.
* document can not be null
*
* @retval true contour are closed
* @retval false if the contour is not closed
*
* @author Rallaz
*/
bool RS_ActionPolylineSegment::convertPolyline(RS_Entity* selectedEntity) {
RS_DEBUG->print("RS_ActionPolylineSegment::convertPolyline");
QList<RS_Entity*> remaining;
QList<RS_Entity*> completed;
RS_Vector start = selectedEntity->getStartpoint();
RS_Vector end = selectedEntity->getEndpoint();
completed.append(selectedEntity);
//get list with useful entities
for (unsigned i=0; i<container->count(); ++i) {
RS_Entity* e1 = container->entityAt(i);
if (e1->isLocked() || !e1->isVisible() || e1 == selectedEntity) continue;
if (e1->rtti()==RS2::EntityLine || e1->rtti()==RS2::EntityArc
|| e1->rtti()==RS2::EntityPolyline) {
if (targetEntity->rtti()==RS2::EntityPolyline && ((RS_Polyline*)targetEntity)->isClosed())
continue;
if (e1 == selectedEntity)
continue;
remaining.append(e1);
}
}
// find all connected entities:
bool done = true;
do {
done = true;
for (int i=(remaining.size() -1) ; i>=0; --i) {
RS_Entity* e=remaining.at(i);
if (e->getEndpoint().distanceTo(start) < 1.0e-4) {
completed.prepend( e);
start = e->getStartpoint();
remaining.removeAt(i);
done = false;
} else if (e->getStartpoint().distanceTo(start) < 1.0e-4) {
completed.prepend( e);
start = e->getEndpoint();
remaining.removeAt(i);
done = false;
} else if (e->getEndpoint().distanceTo(end) < 1.0e-4) {
completed.append( e);
end = e->getStartpoint();
remaining.removeAt(i);
done = false;
} else if (e->getStartpoint().distanceTo(end) < 1.0e-4) {
completed.append( e);
end = e->getEndpoint();
remaining.removeAt(i);
done = false;
}
}
} while (!done);
//cleanup for no more needed list
remaining.clear();
bool closed = false;
if (document) {
document->startUndoCycle();
bool revert = false;
double bulge = 0.0;
if (end.distanceTo(start) < 1.0e-4)
closed = true;
RS_Polyline* newPolyline = new RS_Polyline(container, RS_PolylineData(RS_Vector(false), RS_Vector(false), closed));
newPolyline->setLayerToActive();
newPolyline->setPenToActive();
//complete polyline
end =start;
while (!completed.isEmpty()) {
RS_Entity* e2= completed.takeFirst();
e2->setUndoState(true);
document->addUndoable(e2);
if (e2->getStartpoint().distanceTo(end) < 1.0e-4) {
revert = false;
start = e2->getStartpoint();
end = e2->getEndpoint();
} else {
revert = true;
start = e2->getEndpoint();
end = e2->getStartpoint();
}
if (e2->rtti()==RS2::EntityArc) {
if (revert)
bulge = ((RS_Arc*)e2)->getBulge()*-1;
else
bulge = ((RS_Arc*)e2)->getBulge();
} else
bulge = 0.0;
if (e2->rtti()==RS2::EntityPolyline) {
newPolyline->addVertex(start, bulge);
end = appendPol(newPolyline, (RS_Polyline*)e2, revert);
} else
newPolyline->addVertex(start, bulge);
}
if (closed)
newPolyline->setClosed(true);
else
newPolyline->addVertex(end, bulge);
newPolyline->endPolyline();
container->addEntity(newPolyline);
if (graphicView) {
graphicView->drawEntity(newPolyline);
}
document->addUndoable(newPolyline);
document->endUndoCycle();
}
RS_DEBUG->print("RS_ActionPolylineSegment::convertPolyline: OK");
return closed;
}
void OscilloscopeEngine::processOscilloscopeData(SamplesList leftChannelData, SamplesList rightChannelData)
{
if (!m_isRunning) {
return;
}
// qDebug() << "Got" << samples.length() << "samples";
if (m_capturedChannels == CHANNEL_NONE) {
return;
}
SamplesList *buffer = NULL;
SamplesList *samples = NULL;
// I. Select primary channel
if (m_capturedChannels != CHANNEL_BOTH) {
// For single channel capture, process only one buffer.
if (m_capturedChannels == CHANNEL_LEFT) {
buffer = &m_samplesInputBufferLeft;
samples = &leftChannelData;
} else if (m_capturedChannels == CHANNEL_RIGHT) {
buffer = &m_samplesInputBufferRight;
samples = &rightChannelData;
}
} else {
// For both channel capture, only one channel is selected for Normal or Single triggering
if (m_triggerChannel == CHANNEL_LEFT) {
buffer = &m_samplesInputBufferLeft;
} else if (m_triggerChannel == CHANNEL_RIGHT) {
buffer = &m_samplesInputBufferRight;
} else if (m_triggerMode != TRIG_AUTO) {
qWarning() << "For non-auto trigger mode an one channel have to be choosen for triggering";
Q_ASSERT(false);
return;
}
}
// II. For both channel capture we have to check buffers state - samples must be captured simultaneously
if (m_capturedChannels == CHANNEL_BOTH) {
// This is not a bug when
if (m_samplesInputBufferLeft.size() != m_samplesInputBufferRight.size()) {
qWarning() << "Audio input buffers are not synced. Reset them."
<< "Left:" << m_samplesInputBufferLeft.size()
<< "Right:" << m_samplesInputBufferRight.size();
m_samplesInputBufferLeft.clear();
m_samplesInputBufferRight.clear();
// Q_ASSERT(false);
}
if (leftChannelData.size() != rightChannelData.size()) {
qWarning() << "Fresh audio samples are not synced. Reset them."
<< "Left:" << leftChannelData.size()
<< "Right:" << rightChannelData.size();
leftChannelData.clear();
rightChannelData.clear();
// Q_ASSERT(false);
}
}
// III. Trigger mode: Automatic - display data immediatelly if there are enough data in buffer
if (m_triggerMode == TRIG_AUTO) {
if (m_capturedChannels != CHANNEL_BOTH) {
buffer->append(*samples);
if (buffer->size() < m_frameLength) {
return;
}
} else {
m_samplesInputBufferLeft.append(leftChannelData);
m_samplesInputBufferRight.append(rightChannelData);
if (m_samplesInputBufferLeft.size() < m_frameLength) {
return;
}
}
displayOscilloscopeChannelData(0, m_frameLength, m_frameLength);
return;
}
// IV. Trigger mode: Single - if data acqured, the graph have to hold data
if ((m_triggerMode == TRIG_SINGLE) && m_dataForSingleCaptureAcqured) {
return;
}
// V. Trigger mode: Normal or Single (when trigger hasn't fired yet)
if ((m_triggerMode == TRIG_NORMAL) or (m_triggerMode == TRIG_SINGLE)) {
// Fill buffers with samples
if (m_capturedChannels != CHANNEL_BOTH) {
buffer->append(*samples);
if (buffer->size() < m_frameLength * 2) {
return;
}
} else {
m_samplesInputBufferLeft.append(leftChannelData);
m_samplesInputBufferRight.append(rightChannelData);
if (m_samplesInputBufferLeft.size() < m_frameLength * 2) {
return;
}
}
// Find moments when signal intersects trigger line by required slope
// Start searching with offset in half of frame length, because this half has been already plotted
QList<int> eventsOffsets;
for (int offset = m_frameLength / 2 - 1; offset < buffer->size(); ++offset) {
qreal cur = buffer->at(offset);
qreal prev = buffer->at(offset - 1);
if (m_triggerSlope == TRIG_RISING) {
if ((prev <= m_triggerLevel) && (cur >= m_triggerLevel)) {
eventsOffsets.append(offset);
}
} else {
if ((prev >= m_triggerLevel) && (cur <= m_triggerLevel)) {
eventsOffsets.append(offset);
}
}
}
if (eventsOffsets.size() > 0) {
// take first event in next frame
for (int i = 0; i < eventsOffsets.size(); ++i) {
int offset = eventsOffsets[i];
if (offset >= m_frameLength * 3 / 2) {
// there is not enough data for display full frame
eventsOffsets.clear();
break;
}
if (offset >= m_frameLength / 2) {
displayOscilloscopeChannelData(offset - m_frameLength / 2, m_frameLength, m_frameLength / 2);
m_dataForSingleCaptureAcqured = true;
return;
}
}
// or select last event
if (eventsOffsets.size() > 0) {
int offset = eventsOffsets.last();
displayOscilloscopeChannelData(offset - m_frameLength / 2, m_frameLength, m_frameLength / 2);
m_dataForSingleCaptureAcqured = true;
return;
}
}
// buffer is overflowed
if (buffer->size() > m_frameLength * 2) {
if (m_capturedChannels != CHANNEL_BOTH) {
*buffer = buffer->mid(m_frameLength);
} else {
m_samplesInputBufferLeft = m_samplesInputBufferLeft.mid(m_frameLength);
m_samplesInputBufferRight = m_samplesInputBufferRight.mid(m_frameLength);
}
}
}
}
int QgsMapCanvasSnapper::snapToBackgroundLayers( const QgsPoint& point, QList<QgsSnappingResult>& results, const QList<QgsPoint>& excludePoints )
{
results.clear();
if ( !mSnapper )
return 5;
//topological editing on?
int topologicalEditing = QgsProject::instance()->readNumEntry( "Digitizing", "/TopologicalEditing", 0 );
//snapping on intersection on?
int intersectionSnapping = QgsProject::instance()->readNumEntry( "Digitizing", "/IntersectionSnapping", 0 );
if ( topologicalEditing == 0 )
{
if ( intersectionSnapping == 0 )
mSnapper->setSnapMode( QgsSnapper::SnapWithOneResult );
else
mSnapper->setSnapMode( QgsSnapper::SnapWithResultsWithinTolerances );
}
else if ( intersectionSnapping == 0 )
{
mSnapper->setSnapMode( QgsSnapper::SnapWithResultsForSamePosition );
}
else
{
mSnapper->setSnapMode( QgsSnapper::SnapWithResultsWithinTolerances );
}
QgsVectorLayer* currentVectorLayer = dynamic_cast<QgsVectorLayer*>( mMapCanvas->currentLayer() );
if ( !currentVectorLayer )
{
return 1;
}
//read snapping settings from project
QStringList layerIdList, enabledList, toleranceList, toleranceUnitList, snapToList;
bool ok, snappingDefinedInProject;
QSettings settings;
QString snappingMode = QgsProject::instance()->readEntry( "Digitizing", "/SnappingMode", "current_layer", &snappingDefinedInProject );
QString defaultSnapToleranceUnit = snappingDefinedInProject ? QgsProject::instance()->readEntry( "Digitizing", "/DefaultSnapToleranceUnit" ) : settings.value( "/qgis/digitizing/default_snapping_tolerance_unit", "0" ).toString();
QString defaultSnapType = snappingDefinedInProject ? QgsProject::instance()->readEntry( "Digitizing", "/DefaultSnapType" ) : settings.value( "/qgis/digitizing/default_snap_mode", "off" ).toString();
QString defaultSnapTolerance = snappingDefinedInProject ? QString::number( QgsProject::instance()->readDoubleEntry( "Digitizing", "/DefaultSnapTolerance" ) ) : settings.value( "/qgis/digitizing/default_snapping_tolerance", "0" ).toString();
if ( !snappingDefinedInProject && defaultSnapType == "off" )
{
return 0;
}
if ( snappingMode == "current_layer" || !snappingDefinedInProject )
{
layerIdList.append( currentVectorLayer->id() );
enabledList.append( "enabled" );
toleranceList.append( defaultSnapTolerance );
toleranceUnitList.append( defaultSnapToleranceUnit );
snapToList.append( defaultSnapType );
}
else if ( snappingMode == "all_layers" )
{
QList<QgsMapLayer*> allLayers = mMapCanvas->layers();
QList<QgsMapLayer*>::const_iterator layerIt = allLayers.constBegin();
for ( ; layerIt != allLayers.constEnd(); ++layerIt )
{
if ( !( *layerIt ) )
{
continue;
}
layerIdList.append(( *layerIt )->id() );
enabledList.append( "enabled" );
toleranceList.append( defaultSnapTolerance );
toleranceUnitList.append( defaultSnapToleranceUnit );
snapToList.append( defaultSnapType );
}
}
else //advanced
{
layerIdList = QgsProject::instance()->readListEntry( "Digitizing", "/LayerSnappingList", QStringList(), &ok );
enabledList = QgsProject::instance()->readListEntry( "Digitizing", "/LayerSnappingEnabledList", QStringList(), &ok );
toleranceList = QgsProject::instance()->readListEntry( "Digitizing", "/LayerSnappingToleranceList", QStringList(), &ok );
toleranceUnitList = QgsProject::instance()->readListEntry( "Digitizing", "/LayerSnappingToleranceUnitList", QStringList(), &ok );
snapToList = QgsProject::instance()->readListEntry( "Digitizing", "/LayerSnapToList", QStringList(), &ok );
}
if ( !( layerIdList.size() == enabledList.size() &&
layerIdList.size() == toleranceList.size() &&
layerIdList.size() == toleranceUnitList.size() &&
layerIdList.size() == snapToList.size() ) )
{
// lists must have the same size, otherwise something is wrong
return 1;
}
QList<QgsSnapper::SnapLayer> snapLayers;
QgsSnapper::SnapLayer snapLayer;
// set layers, tolerances, snap to segment/vertex to QgsSnapper
QStringList::const_iterator layerIt( layerIdList.constBegin() );
QStringList::const_iterator tolIt( toleranceList.constBegin() );
QStringList::const_iterator tolUnitIt( toleranceUnitList.constBegin() );
QStringList::const_iterator snapIt( snapToList.constBegin() );
QStringList::const_iterator enabledIt( enabledList.constBegin() );
for ( ; layerIt != layerIdList.constEnd(); ++layerIt, ++tolIt, ++tolUnitIt, ++snapIt, ++enabledIt )
{
if ( *enabledIt != "enabled" )
{
// skip layer if snapping is not enabled
continue;
}
//layer
QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( QgsMapLayerRegistry::instance()->mapLayer( *layerIt ) );
if ( !vlayer || !vlayer->hasGeometryType() )
continue;
snapLayer.mLayer = vlayer;
//tolerance
snapLayer.mTolerance = tolIt->toDouble();
snapLayer.mUnitType = ( QgsTolerance::UnitType ) tolUnitIt->toInt();
// segment or vertex
if ( *snapIt == "to vertex" || *snapIt == "to_vertex" )
{
snapLayer.mSnapTo = QgsSnapper::SnapToVertex;
}
else if ( *snapIt == "to segment" || *snapIt == "to_segment" )
{
snapLayer.mSnapTo = QgsSnapper::SnapToSegment;
}
else if ( *snapIt == "to vertex and segment" || *snapIt == "to_vertex_and_segment" )
{
snapLayer.mSnapTo = QgsSnapper::SnapToVertexAndSegment;
}
else //off
{
continue;
}
snapLayers.append( snapLayer );
}
mSnapper->setSnapLayers( snapLayers );
if ( mSnapper->snapMapPoint( point, results, excludePoints ) != 0 )
return 4;
if ( intersectionSnapping != 1 )
return 0;
QVector<QgsSnappingResult> segments;
QVector<QgsSnappingResult> points;
for ( QList<QgsSnappingResult>::const_iterator it = results.constBegin();
it != results.constEnd();
++it )
{
if ( it->snappedVertexNr == -1 )
{
QgsDebugMsg( "segment" );
segments.push_back( *it );
}
else
{
QgsDebugMsg( "no segment" );
points.push_back( *it );
}
}
if ( segments.count() < 2 )
return 0;
QList<QgsSnappingResult> myResults;
for ( QVector<QgsSnappingResult>::const_iterator oSegIt = segments.constBegin();
oSegIt != segments.constEnd();
++oSegIt )
{
QgsDebugMsg( QString::number( oSegIt->beforeVertexNr ) );
QVector<QgsPoint> vertexPoints;
vertexPoints.append( oSegIt->beforeVertex );
vertexPoints.append( oSegIt->afterVertex );
QgsGeometry* lineA = QgsGeometry::fromPolyline( vertexPoints );
for ( QVector<QgsSnappingResult>::iterator iSegIt = segments.begin();
iSegIt != segments.end();
++iSegIt )
{
QVector<QgsPoint> vertexPoints;
vertexPoints.append( iSegIt->beforeVertex );
vertexPoints.append( iSegIt->afterVertex );
QgsGeometry* lineB = QgsGeometry::fromPolyline( vertexPoints );
QgsGeometry* intersectionPoint = lineA->intersection( lineB );
delete lineB;
if ( intersectionPoint && intersectionPoint->type() == QGis::Point )
{
//We have to check the intersection point is inside the tolerance distance for both layers
double toleranceA = 0;
double toleranceB = 0;
for ( int i = 0 ;i < snapLayers.size();++i )
{
if ( snapLayers[i].mLayer == oSegIt->layer )
{
toleranceA = QgsTolerance::toleranceInMapUnits( snapLayers[i].mTolerance, snapLayers[i].mLayer, mMapCanvas->mapSettings(), snapLayers[i].mUnitType );
}
if ( snapLayers[i].mLayer == iSegIt->layer )
{
toleranceB = QgsTolerance::toleranceInMapUnits( snapLayers[i].mTolerance, snapLayers[i].mLayer, mMapCanvas->mapSettings(), snapLayers[i].mUnitType );
}
}
QgsGeometry* cursorPoint = QgsGeometry::fromPoint( point );
double distance = intersectionPoint->distance( *cursorPoint );
if ( distance < toleranceA && distance < toleranceB )
{
iSegIt->snappedVertex = intersectionPoint->asPoint();
myResults.append( *iSegIt );
}
delete cursorPoint;
}
delete intersectionPoint;
}
delete lineA;
}
if ( myResults.length() > 0 )
{
results.clear();
results = myResults;
}
return 0;
}
bool QgsNativeMetadataValidator::validate( const QgsLayerMetadata &metadata, QList<ValidationResult> &results ) const
{
results.clear();
bool result = true;
if ( metadata.identifier().isEmpty() )
{
result = false;
results << ValidationResult( QObject::tr( "identifier" ), QObject::tr( "Identifier element is required." ) );
}
if ( metadata.language().isEmpty() )
{
result = false;
results << ValidationResult( QObject::tr( "language" ), QObject::tr( "Language element is required." ) );
}
if ( metadata.type().isEmpty() )
{
result = false;
results << ValidationResult( QObject::tr( "type" ), QObject::tr( "Type element is required." ) );
}
if ( metadata.title().isEmpty() )
{
result = false;
results << ValidationResult( QObject::tr( "title" ), QObject::tr( "Title element is required." ) );
}
if ( metadata.abstract().isEmpty() )
{
result = false;
results << ValidationResult( QObject::tr( "abstract" ), QObject::tr( "Abstract element is required." ) );
}
if ( metadata.licenses().isEmpty() )
{
result = false;
results << ValidationResult( QObject::tr( "license" ), QObject::tr( "At least one license is required." ) );
}
if ( !metadata.crs().isValid() )
{
result = false;
results << ValidationResult( QObject::tr( "crs" ), QObject::tr( "A valid CRS element is required." ) );
}
int index = 0;
Q_FOREACH ( const QgsLayerMetadata::SpatialExtent &extent, metadata.extent().spatialExtents() )
{
if ( !extent.extentCrs.isValid() )
{
result = false;
results << ValidationResult( QObject::tr( "extent" ), QObject::tr( "A valid CRS element for the spatial extent is required." ), index );
}
if ( extent.bounds.width() == 0.0 || extent.bounds.height() == 0.0 )
{
result = false;
results << ValidationResult( QObject::tr( "extent" ), QObject::tr( "A valid spatial extent is required." ), index );
}
index++;
}
if ( metadata.contacts().isEmpty() )
{
result = false;
results << ValidationResult( QObject::tr( "contacts" ), QObject::tr( "At least one contact is required." ) );
}
if ( metadata.links().isEmpty() )
{
result = false;
results << ValidationResult( QObject::tr( "links" ), QObject::tr( "At least one link is required." ) );
}
// validate keywords
QgsLayerMetadata::KeywordMap keywords = metadata.keywords();
QgsLayerMetadata::KeywordMap::const_iterator keywordIt = keywords.constBegin();
index = 0;
for ( ; keywordIt != keywords.constEnd(); ++keywordIt )
{
if ( keywordIt.key().isEmpty() )
{
result = false;
results << ValidationResult( QObject::tr( "keywords" ), QObject::tr( "Keyword vocabulary cannot be empty." ), index );
}
if ( keywordIt.value().isEmpty() )
{
result = false;
results << ValidationResult( QObject::tr( "keywords" ), QObject::tr( "Keyword list cannot be empty." ), index );
}
index++;
}
// validate contacts
index = 0;
Q_FOREACH ( const QgsLayerMetadata::Contact &contact, metadata.contacts() )
{
if ( contact.name.isEmpty() )
{
result = false;
results << ValidationResult( QObject::tr( "contacts" ), QObject::tr( "Contact name cannot be empty." ), index );
}
index++;
}
// validate links
index = 0;
Q_FOREACH ( const QgsLayerMetadata::Link &link, metadata.links() )
{
if ( link.name.isEmpty() )
{
result = false;
results << ValidationResult( QObject::tr( "links" ), QObject::tr( "Link name cannot be empty." ), index );
}
if ( link.type.isEmpty() )
{
result = false;
results << ValidationResult( QObject::tr( "links" ), QObject::tr( "Link type cannot be empty." ), index );
}
if ( link.url.isEmpty() )
{
result = false;
results << ValidationResult( QObject::tr( "links" ), QObject::tr( "Link url cannot be empty." ), index );
}
index++;
}
return result;
}
void TexecutorSupply::createQuestionsList(QList<TQAgroup> &list) {
char openStr[6];
// for (int i = 0; i < 6; i++)
for (int i = 0; i < Tcore::gl()->Gtune()->stringNr(); i++)
openStr[i] = Tcore::gl()->Gtune()->str(i + 1).chromatic();
/** FIXING MISTAKE RELATED WITH A NEW VALIDATION WAY DURING SAVING NEW LEVEL
* When there is no guitar in a level,
* add to question list only the lowest position sounds.
* In this way question list contains proper number of questions. */
if (!m_level->canBeGuitar() && !m_level->answerIsSound()) // adjust fret range
m_level->onlyLowPos = true;
if (!m_playCorrections || m_level->instrument != e_noInstrument || m_level->showStrNr || m_level->canBeGuitar()) {
// qDebug() << "Question list created fret by fret. Tune:" << Tcore::gl()->Gtune()->name << Tcore::gl()->Gtune()->stringNr();
if (m_level->instrument == e_noInstrument && Tcore::gl()->instrument != e_noInstrument) {
// if (Tnote(Tcore::gl()->hiString().chromatic() + m_hiFret).chromatic() < m_level->hiNote.chromatic())
// m_hiFret = m_level->hiNote.chromatic() - Tcore::gl()->hiString().chromatic();
// if (Tnote(Tcore::gl()->loString().chromatic() + m_loFret).chromatic() > m_level->loNote.chromatic())
// m_loFret = Tcore::gl()->loString().chromatic() - m_level->loNote.chromatic();
char hi = m_hiFret, lo = m_loFret;
if (!m_level->adjustFretsToScale(lo, hi))
qDebug() << "Cant adjust fret range. Corrections will be played!";
m_loFret = lo;
m_hiFret = hi;
}
if (m_level->loFret != m_loFret || m_level->hiFret != m_hiFret)
qDebug() << "Fret range of a level adjusted to current instrument [" << m_loFret << m_hiFret << "]";
for(int s = 0; s < Tcore::gl()->Gtune()->stringNr(); s++) {
if (m_level->usedStrings[Tcore::gl()->strOrder(s)])// check string by strOrder
for (int f = m_loFret; f <= m_hiFret; f++) {
Tnote n = Tnote(Tcore::gl()->Gtune()->str(Tcore::gl()->strOrder(s) + 1).chromatic() + f);
if (n.chromatic() >= m_level->loNote.chromatic() &&
n.chromatic() <= m_level->hiNote.chromatic()) {
bool hope = true; // we still have hope that note is proper for the level
if (m_level->onlyLowPos) {
if (s > 0) {
// we have to check when note is on the lowest positions.
// Is it really lowest position when strOrder[s] is 0 - it is the highest sting
char diff = openStr[Tcore::gl()->strOrder(s-1)] - openStr[Tcore::gl()->strOrder(s)];
if( (f - diff) >= m_loFret && (f - diff) <= m_hiFret)
hope = false; //There is the same note on highest string
else
hope = true;
}
}
if (hope && m_level->useKeySign && m_level->onlyCurrKey)
hope = isNoteInKey(n);
if (hope) {
if (n.alter && (!m_level->withFlats && !m_level->withSharps))
continue;
else {
TfingerPos ff = TfingerPos(Tcore::gl()->strOrder(s) + 1, f);
addToList(list, n, ff);
}
}
}
}
}
} else {
// qDebug() << "Question list created note by note";
for (int nNr = m_level->loNote.chromatic(); nNr <= m_level->hiNote.chromatic(); nNr++) {
Tnote n = Tnote(nNr);
bool hope = true; // we still have hope that note is proper for the level
if (hope && m_level->useKeySign && m_level->onlyCurrKey)
hope = isNoteInKey(n);
if (hope) {
if (n.alter && (!m_level->withFlats && !m_level->withSharps))
continue;
else {
TfingerPos ff = TfingerPos();
addToList(list, n, ff);
}
}
}
}
// for (int i = 0; i < list.size(); i++)
// qDebug() << i << (int)list[i].pos.str() << "f"
// << (int)list[i].pos.fret() << " note: "
// << QString::fromStdString(list[i].note.getName());
// generate m_fretFretList if needed
m_fretFretList.clear();
if (m_level->questionAs.isFret() && m_level->answersAs[TQAtype::e_asFretPos].isFret()) {
QList<TfingerPos> tmpSameList;
for (int i = 0; i < list.size(); i++) {
tmpSameList.clear();
getTheSamePos(list[i].pos, tmpSameList);
if (!tmpSameList.isEmpty())
m_fretFretList << (quint16)i;
}
// for (int i = 0; i < m_fretFretList.size(); i++)
// qDebug() << m_fretFretList.at(i) << (int)list[m_fretFretList.at(i)].pos.str() << "f"
// << (int)list[m_fretFretList.at(i)].pos.fret() << " note: "
// << QString::fromStdString(list[m_fretFretList.at(i)].note.getName());
// qDebug() << "question list for only guitar created\nnumber:" << m_fretFretList.size() <<
// " among:" << list.size();
}
qsrand(QDateTime::currentDateTime().toTime_t());
if (m_level->canBeMelody())
m_obligQuestNr = qBound(5, 250 / m_level->melodyLen, 30); // longer melody - less questions
else
m_obligQuestNr = qBound(20, list.size() * 4, 250);
if (m_level->useKeySign && !m_level->isSingleKey)
m_obligQuestNr = qMax(m_obligQuestNr, (m_level->hiKey.value() - m_level->loKey.value() + 1) * 5);
m_obligQuestNr = qMax(qaPossibilities() * 4, m_obligQuestNr);
}
void WiresharkApplication::clearRecentItems() {
qDeleteAll(recent_items_.begin(), recent_items_.end());
recent_items_.clear();
emit updateRecentItemStatus(NULL, 0, false);
}
void MainScreen::doSend()
{
QList<int> order = randomizeBuyers();
//QList<Participant> receivers(m_participants.size());
typedef QPair<Participant, Participant> ParticipantPair;
QList<ParticipantPair> pairs;
bool success = false;
while(!success)
{
bool errorOccurred = false;
for(int i = 0; !errorOccurred && i < m_participants.size(); ++i)
{
// refactor the drafting out into it's own class. The Input reader
// should not know about how drafting occurs
int j = order[i];
Participant buyer(m_participants.value(j)["name"].value<QString>(), m_participants.value(j)["email"].value<QString>(), m_participants.value(j)["exl"].value<QStringList>());
Participant receiver(m_participants.value(i)["name"].value<QString>(), m_participants.value(i)["email"].value<QString>(), m_participants.value(i)["exl"].value<QStringList>());
if(!IsValidPair(buyer, receiver))
{
errorOccurred = true;
}
else
{
pairs.append(ParticipantPair(buyer,receiver));
}
}
if(errorOccurred)
{
order = randomizeBuyers();
pairs.clear();
}
else
{
success = true;
}
}
AccountService* as = new AccountService();
Account account = as->defaultAccount(Service::Messages);
MessageService ms;
m_subject = m_mainPage->findChild<TextField*>("emailSubject")->text();
QString body = "<p>" + m_mainPage->findChild<TextArea*>("emailBody")->text() + "</p>";
for(int i = 0; i < pairs.size(); ++i)
{
QString greeting = "<p>Hi " + pairs[i].first.getName() + "!</p>";
QString youGot = "You Received: " + pairs[i].second.getName();
MessageBuilder* builder = MessageBuilder::create(account.id());
MessageContact rto = MessageContact(-1,MessageContact::To,pairs[i].first.getName(), pairs[i].first.getEmail());
QString fullMsg = greeting + body + youGot;
QByteArray bodyData = fullMsg.toAscii();
builder->subject(m_subject);
bool added;
builder->addRecipient(rto,&added);
builder->body(MessageBody::Html,bodyData);
Message message = *builder;
/*
connect(&m_messageService, SIGNAL( messageUpdated(bb::pim::account::AccountKey, bb::pim::message::ConversationKey, bb::pim::message::MessageKey, bb::pim::message::MessageUpdate) ),
&m_ml,
SLOT( messageUpdate(bb::pim::account::AccountKey, bb::pim::message::ConversationKey, bb::pim::message::MessageKey, bb::pim::message::MessageUpdate) ) );
*/
/*MessageKey mk = */ms.send(account.id(), message);
/*Message sentMessage = ms.message(account.id(), mk);
m_ml.setAk(account.id());
m_ml.setMk(sentMessage.id());
m_ml.setCk(sentMessage.conversationId());
m_ml.setMsg(sentMessage);*/
//********************************************************
// Set created root object as the application scene
//m_navPane->setBackButtonsVisible(false);
}
m_worker->exit();
}
ConfigureEvent_EnableDisableObject::ConfigureEvent_EnableDisableObject(int menuID, int menuType, QWidget *parent) : QDialog(parent)
{
QList<MenuObject*> menuObjects;
QStringList objectNames;
StorageFile storageFile;
QString storageLocation;
setupUi(this);
if (menuType == MenuObject::MENUTYPE_MAINMENU)
{
ProjectData::DataReference<MainMenuLayout> *layoutRef = new ProjectData::DataReference<MainMenuLayout>(menuID, __FILE__, __LINE__);
menuObjects = (*layoutRef)->getObjectsByType(MenuObject::TYPE_FRAME);
menuObjects += (*layoutRef)->getObjectsByType(MenuObject::TYPE_TEXT);
menuObjects += (*layoutRef)->getObjectsByType(MenuObject::TYPE_IMAGE);
menuObjects += (*layoutRef)->getObjectsByType(MenuObject::TYPE_SELECTABLEAREA);
menuObjects += (*layoutRef)->getObjectsByType(MenuObject::TYPE_SCROLLAREA);
menuObjects += (*layoutRef)->getObjectsByType(MenuObject::TYPE_ITEMLIST);
for (int i = 0; i < menuObjects.size(); ++i)
objectNames.append(menuObjects[i]->getName());
objectNames.sort();
cboxMenuObject->addItems(objectNames);
menuObjects.clear();
delete layoutRef;
}
else if (menuType == MenuObject::MENUTYPE_POPUPMENU)
{
ProjectData::DataReference<PopupMenuLayout> *layoutRef = new ProjectData::DataReference<PopupMenuLayout>(menuID, __FILE__, __LINE__);
menuObjects = (*layoutRef)->getObjectsByType(MenuObject::TYPE_FRAME);
menuObjects += (*layoutRef)->getObjectsByType(MenuObject::TYPE_TEXT);
menuObjects += (*layoutRef)->getObjectsByType(MenuObject::TYPE_IMAGE);
menuObjects += (*layoutRef)->getObjectsByType(MenuObject::TYPE_SELECTABLEAREA);
menuObjects += (*layoutRef)->getObjectsByType(MenuObject::TYPE_SCROLLAREA);
menuObjects += (*layoutRef)->getObjectsByType(MenuObject::TYPE_ITEMLIST);
for (int i = 0; i < menuObjects.size(); ++i)
objectNames.append(menuObjects[i]->getName());
objectNames.sort();
cboxMenuObject->addItems(objectNames);
menuObjects.clear();
delete layoutRef;
}
else if (menuType == MenuObject::MENUTYPE_TITLESCREENMENU)
{
TitleMenuLayout *layout = ProjectData::titleMenuLayout;
menuObjects = layout->getObjectsByType(MenuObject::TYPE_FRAME);
menuObjects += layout->getObjectsByType(MenuObject::TYPE_TEXT);
menuObjects += layout->getObjectsByType(MenuObject::TYPE_IMAGE);
menuObjects += layout->getObjectsByType(MenuObject::TYPE_SELECTABLEAREA);
menuObjects += layout->getObjectsByType(MenuObject::TYPE_SCROLLAREA);
menuObjects += layout->getObjectsByType(MenuObject::TYPE_ITEMLIST);
for (int i = 0; i < menuObjects.size(); ++i)
objectNames.append(menuObjects[i]->getName());
objectNames.sort();
cboxMenuObject->addItems(objectNames);
menuObjects.clear();
layout = NULL;
}
if (cboxMenuObject->count() == 0)
{
cboxMenuObject->addItem("No Selectable Areas or Item Lists To Select");
buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
}
resize(sizeHint().width(), sizeHint().height());
setMinimumWidth(width());
setMaximumWidth(width());
setMinimumHeight(height());
setMaximumHeight(height());
}
//
// Slot to update the configuration then exit. Called when ui.pushButton_ok
// is clicked. Step through each page of the QToolBox and send any entries
// to connman.
void PropertiesEditor::updateConfiguration()
{
// Some variables
QString s;
QStringList sl;
QList<QVariant> vlist;
QMap<QString,QVariant> dict;
QDBusInterface* iface_serv = new QDBusInterface(DBUS_SERVICE, objpath.path(), "net.connman.Service", QDBusConnection::systemBus(), this);
QList<QLineEdit*> lep;
QStringList slp;
// QCheckboxes
// Only update if changed
if (ui.checkBox_autoconnect->isChecked() != objmap.value("AutoConnect").toBool() ) {
vlist.clear();
vlist << "AutoConnect";
vlist << QVariant::fromValue(QDBusVariant(ui.checkBox_autoconnect->isChecked()) );
shared::processReply(iface_serv->callWithArgumentList(QDBus::AutoDetect, "SetProperty", vlist) );
}
// QLineEdits (nameservers, timeservers and domains)
lep.clear();
slp.clear();
lep << ui.lineEdit_nameservers << ui.lineEdit_timeservers << ui.lineEdit_domains;
slp << "Nameservers.Configuration" << "Timeservers.Configuration" << "Domains.Configuration";
for (int i = 0; i < lep.count(); ++i) {
s = lep.at(i)->text();
s.replace(',', ' ');
s.replace(';', ' ');
s = s.simplified();
if (s.isEmpty() ) sl.clear();
else sl = s.split(' ');
// Only update if an entry has changed.
if (sl != objmap.value(slp.at(i)).toStringList()) {
vlist.clear();
vlist << slp.at(i);
vlist << QVariant::fromValue(QDBusVariant(sl) );
shared::processReply(iface_serv->callWithArgumentList(QDBus::AutoDetect, "SetProperty", vlist) );
} // if
} //for
// ipv4
// Only update if an entry has changed.
if ((ui.comboBox_ipv4method->currentText() != TranslateStrings::cmtr(ipv4map.value("Method").toString()) ) |
(ui.lineEdit_ipv4address->text() != TranslateStrings::cmtr(ipv4map.value("Address").toString()) ) |
(ui.lineEdit_ipv4netmask->text() != TranslateStrings::cmtr(ipv4map.value("Netmask").toString()) ) |
(ui.lineEdit_ipv4gateway->text() != TranslateStrings::cmtr(ipv4map.value("Gateway").toString())) ) {
vlist.clear();
lep.clear();
slp.clear();
dict.clear();
vlist << "IPv4.Configuration";
dict.insert("Method", sl_ipv4_method.at(ui.comboBox_ipv4method->currentIndex()) );
lep << ui.lineEdit_ipv4address << ui.lineEdit_ipv4netmask << ui.lineEdit_ipv4gateway;
slp << "Address" << "Netmask" << "Gateway";
for (int i = 0; i < lep.count(); ++i) {
s = lep.at(i)->text();
s = s.simplified(); // really should not be needed with the validator
if (s.isEmpty() ) s.clear();
dict.insert(slp.at(i), s);
} // for
vlist << QVariant::fromValue(QDBusVariant(dict) );
shared::processReply(iface_serv->callWithArgumentList(QDBus::AutoDetect, "SetProperty", vlist) );
} // if ipv4 changed
// ipv6
// Only update if an entry has changed.
if ((ui.comboBox_ipv6method->currentText() != TranslateStrings::cmtr(ipv6map.value("Method").toString()) ) |
(static_cast<uint>(ui.spinBox_ipv6prefixlength->value()) != ipv6map.value("PrefixLength").toUInt() ) |
(ui.lineEdit_ipv6address->text() != TranslateStrings::cmtr(ipv6map.value("Address").toString()) ) |
(ui.lineEdit_ipv6gateway->text() != TranslateStrings::cmtr(ipv6map.value("Gateway").toString()) ) |
(ui.comboBox_ipv6privacy->currentText() != TranslateStrings::cmtr(ipv6map.value("Privacy").toString())) ) {
vlist.clear();
lep.clear();
slp.clear();
dict.clear();
vlist << "IPv6.Configuration";
dict.insert("Method", sl_ipv6_method.at(ui.comboBox_ipv6method->currentIndex()) );
dict.insert("PrefixLength", QVariant::fromValue(static_cast<quint8>(ui.spinBox_ipv6prefixlength->value())) );
dict.insert("Privacy", sl_ipv6_privacy.at(ui.comboBox_ipv6privacy->currentIndex()) );
lep << ui.lineEdit_ipv6address << ui.lineEdit_ipv6gateway;
slp << "Address" << "Gateway";
for (int i = 0; i < lep.count(); ++i) {
s = lep.at(i)->text();
s = s.simplified(); // really should not be needed with the validator
if (s.isEmpty() ) s.clear();
dict.insert(slp.at(i), s);
} // for
vlist << QVariant::fromValue(QDBusVariant(dict) );
shared::processReply(iface_serv->callWithArgumentList(QDBus::AutoDetect, "SetProperty", vlist) );
} // if ipv6 changed
// proxy
// Only update if an entry has changed.
if ((ui.comboBox_proxymethod->currentText() != TranslateStrings::cmtr(proxmap.value("Method").toString()) ) |
(ui.lineEdit_proxyservers->text() != proxmap.value("Servers").toStringList().join("\n") ) |
(ui.lineEdit_proxyexcludes->text() != proxmap.value("Excludes").toStringList().join("\n") ) |
(ui.lineEdit_proxyurl->text() != proxmap.value("URL").toString()) ) {
vlist.clear();
lep.clear();
slp.clear();
dict.clear();
vlist << "Proxy.Configuration";
dict.insert("Method", sl_proxy_method.at(ui.comboBox_proxymethod->currentIndex()) );
lep << ui.lineEdit_proxyurl << ui.lineEdit_proxyservers << ui.lineEdit_proxyexcludes;
slp << "URL" << "Servers" << "Excludes";
for (int i = 0; i < lep.count(); ++i) {
s = lep.at(i)->text();
s = s.simplified();
// URL is a single string
if ( i == 0 ) {
if (s.isEmpty() ) s.clear();
dict.insert(slp.at(i), s);
} // if
// remanider are an array of strings
else {
if (s.isEmpty() ) sl.clear();
else sl = s.split(' ');
dict.insert(slp.at(i), sl);
} //else
} // for
vlist << QVariant::fromValue(QDBusVariant(dict) );
qDebug() << dict;
shared::processReply(iface_serv->callWithArgumentList(QDBus::AutoDetect, "SetProperty", vlist) );
} // if proxy changed
// cleanup
iface_serv->deleteLater();
this->accept();
}
void EdrcPlugin::testValidatorTestThree()
{
// Create validator & test lists
ConsultResultValidator validator;
validator.setCrId(1);
QList<int> selectedIds;
QList<int> wrongIds;
// Create criterias using csv {ID;SORT;LABEL;INDENT;WEIGHT}
QString csv =
"1;2;++1| GROUP 1;1;2\n"
"2;3; ++1| MANDATORY 3.CHILD1;2;2\n"
"3;4; ++1| MANDATORY 3.CHILD2;2;2\n"
"4;5; ++1| MANDATORY 3.CHILD2;2;2\n"
"20;6; ;1;8\n"
"5;7;++1| GROUP 2;1;2\n"
"6;8; ++1| MANDATORY 3.CHILD1;2;2\n"
"21;9; ;1;8\n"
"7;10;+ - OPTIONAL 1;1;6\n"
"8;11;+ - OPTIONAL 2;1;6\n"
"9;12;+ - OPTIONAL 3;1;6\n"
"10;13; ;1;8\n"
"11;14;+ - OPTIONAL 1;1;6\n"
;
QList<ConsultResultCriteria> criterias;
foreach(const QString &line, csv.split("\n", QString::SkipEmptyParts))
criterias << criteria(line);
validator.setAvailableCriterias(criterias);
// Test 1 : missing one mandatory
selectedIds << 7 << 8 << 9 << 11;
wrongIds << 1 << 5;
testValidator(&validator, selectedIds, wrongIds, "Test3: missing one mandatory 1");
selectedIds.clear();
wrongIds.clear();
// Test 1bis : missing one mandatory
selectedIds << 2 << 7 << 8 << 9;
wrongIds << 1 << 5;
testValidator(&validator, selectedIds, wrongIds, "Test3: missing one mandatory 2");
selectedIds.clear();
wrongIds.clear();
// Test 1ter : missing one signifiant in the second group
selectedIds << 1 << 2 << 5;
wrongIds << 6;
testValidator(&validator, selectedIds, wrongIds, "Test3: missing one signifiant in the second group");
selectedIds.clear();
wrongIds.clear();
// Test 2 : missing children
selectedIds << 1 << 4 << 5;
wrongIds << 6;
testValidator(&validator, selectedIds, wrongIds, "Test3: missing children");
selectedIds.clear();
wrongIds.clear();
// Test 3 : ok
selectedIds << 1 << 2;
testValidator(&validator, selectedIds, wrongIds, "Test3: Correct coding 1");
selectedIds.clear();
wrongIds.clear();
// Test 4 : ok
selectedIds << 1 << 2 << 6 << 5;
testValidator(&validator, selectedIds, wrongIds, "Test3: Correct coding 2");
selectedIds.clear();
wrongIds.clear();
// Test 5 : ok
selectedIds << 5 << 6;
testValidator(&validator, selectedIds, wrongIds, "Test3: Correct coding 3");
selectedIds.clear();
wrongIds.clear();
}
// read zone file, allowing for zones with or without end dates
bool HrZones::read(QFile &file)
{
defaults_from_user = false;
scheme.zone_default.clear();
scheme.zone_default_is_pct.clear();
scheme.zone_default_name.clear();
scheme.zone_default_desc.clear();
scheme.zone_default_trimp.clear();
scheme.nzones_default = 0;
ranges.clear();
// set up possible warning dialog
warning = QString();
int warning_lines = 0;
const int max_warning_lines = 100;
// macro to append lines to the warning
#define append_to_warning(s) \
if (warning_lines < max_warning_lines) \
warning.append(s); \
else if (warning_lines == max_warning_lines) \
warning.append("...\n"); \
warning_lines ++;
// read using text mode takes care of end-lines
if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
err = "can't open file";
return false;
}
QTextStream fileStream(&file);
QRegExp commentrx("\\s*#.*$");
QRegExp blankrx("^[ \t]*$");
QRegExp rangerx[] = {
QRegExp("^\\s*(?:from\\s+)?" // optional "from"
"((\\d\\d\\d\\d)[-/](\\d{1,2})[-/](\\d{1,2})|BEGIN)" // begin date
"\\s*([,:]?\\s*(LT)\\s*=\\s*(\\d+))?" // optional {LT = integer (optional %)}
"\\s*([,:]?\\s*(RestHr)\\s*=\\s*(\\d+))?" // optional {RestHr = integer (optional %)}
"\\s*([,:]?\\s*(MaxHr)\\s*=\\s*(\\d+))?" // optional {MaxHr = integer (optional %)}
"\\s*:?\\s*$", // optional :
Qt::CaseInsensitive),
QRegExp("^\\s*(?:from\\s+)?" // optional "from"
"((\\d\\d\\d\\d)[-/](\\d{1,2})[-/](\\d{1,2})|BEGIN)" // begin date
"\\s+(?:until|to|-)\\s+" // until
"((\\d\\d\\d\\d)[-/](\\d{1,2})[-/](\\d{1,2})|END)?" // end date
"\\s*:?,?\\s*((LT)\\s*=\\s*(\\d+))?" // optional {LT = integer (optional %)}
"\\s*:?,?\\s*((RestHr)\\s*=\\s*(\\d+))?" // optional {RestHr = integer (optional %)}
"\\s*:?,?\\s*((MaxHr)\\s*=\\s*(\\d+))?" // optional {MaxHr = integer (optional %)}
"\\s*:?\\s*$", // optional :
Qt::CaseInsensitive)
};
QRegExp zonerx("^\\s*([^ ,][^,]*),\\s*([^ ,][^,]*),\\s*"
"(\\d+)\\s*(%?)\\s*(?:,\\s*(\\d+(\\.\\d+)?)\\s*)?$",
Qt::CaseInsensitive);//
QRegExp zonedefaultsx("^\\s*(?:zone)?\\s*defaults?\\s*:?\\s*$",
Qt::CaseInsensitive);
int lineno = 0;
// the current range in the file
// ZoneRange *range = NULL;
bool in_range = false;
QDate begin = date_zero, end = date_infinity;
int lt = 0;
int restHr = 0;
int maxHr = 0;
QList<HrZoneInfo> zoneInfos;
// true if zone defaults are found in the file (then we need to write them)
bool zones_are_defaults = false;
while (! fileStream.atEnd() ) {
++lineno;
QString line = fileStream.readLine();
int pos = commentrx.indexIn(line, 0);
if (pos != -1)
line = line.left(pos);
if (blankrx.indexIn(line, 0) == 0)
goto next_line;
// check for default zone range definition (may be followed by hr zone definitions)
if (zonedefaultsx.indexIn(line, 0) != -1) {
zones_are_defaults = true;
// defaults are allowed only at the beginning of the file
if (ranges.size()) {
err = "HR Zone defaults must be specified at head of hr.zones file";
return false;
}
// only one set of defaults is allowed
if (scheme.nzones_default) {
err = "Only one set of zone defaults may be specified in hr.zones file";
return false;
}
goto next_line;
}
// check for range specification (may be followed by zone definitions)
for (int r=0; r<2; r++) {
if (rangerx[r].indexIn(line, 0) != -1) {
if (in_range) {
// if zones are empty, then generate them
HrZoneRange range(begin, end, lt, restHr, maxHr);
range.zones = zoneInfos;
if (range.zones.empty()) {
if (range.lt > 0) setHrZonesFromLT(range);
else {
err = tr("line %1: read new range without reading "
"any zones for previous one").arg(lineno);
file.close();
return false;
}
} else {
qSort(range.zones);
}
ranges.append(range);
}
in_range = true;
zones_are_defaults = false;
zoneInfos.clear();
// process the beginning date
if (rangerx[r].cap(1) == "BEGIN")
begin = date_zero;
else {
begin = QDate(rangerx[r].cap(2).toInt(),
rangerx[r].cap(3).toInt(),
rangerx[r].cap(4).toInt());
}
// process an end date, if any, else it is null
if (rangerx[r].cap(5) == "END") end = date_infinity;
else if (rangerx[r].cap(6).toInt() || rangerx[r].cap(7).toInt() ||
rangerx[r].cap(8).toInt()) {
end = QDate(rangerx[r].cap(6).toInt(),
rangerx[r].cap(7).toInt(),
rangerx[r].cap(8).toInt());
} else {
end = QDate();
}
// set up the range, capturing LT if it's specified
// range = new ZoneRange(begin, end);
int nLT = (r ? 11 : 7);
if (rangerx[r].numCaptures() >= (nLT)) lt = rangerx[r].cap(nLT).toInt();
else lt = 0;
int nRestHr = (r ? 14 : 10);
if (rangerx[r].numCaptures() >= (nRestHr)) restHr = rangerx[r].cap(nRestHr).toInt();
else restHr = 0;
int nMaxHr = (r ? 17 : 13);
if (rangerx[r].numCaptures() >= (nRestHr)) maxHr = rangerx[r].cap(nMaxHr).toInt();
else maxHr = 0;
// bleck
goto next_line;
}
}
// check for zone definition
if (zonerx.indexIn(line, 0) != -1) {
if (! (in_range || zones_are_defaults)) {
err = tr("line %1: read zone without "
"preceeding date range").arg(lineno);
file.close();
return false;
}
int lo = zonerx.cap(3).toInt();
double trimp = zonerx.cap(5).toDouble();
// allow for zone specified as % of LT
bool lo_is_pct = false;
if (zonerx.cap(4) == "%") {
if (zones_are_defaults) lo_is_pct = true;
else if (lt > 0) lo = int(lo * lt / 100);
else {
err = tr("attempt to set zone based on % of "
"LT without setting LT in line number %1.\n").
arg(lineno);
file.close();
return false;
}
}
int hi = -1; // signal an undefined number
double tr = zonerx.cap(5).toDouble();
if (zones_are_defaults) {
scheme.nzones_default ++;
scheme.zone_default_is_pct.append(lo_is_pct);
scheme.zone_default.append(lo);
scheme.zone_default_name.append(zonerx.cap(1));
scheme.zone_default_desc.append(zonerx.cap(2));
scheme.zone_default_trimp.append(trimp);
defaults_from_user = true;
}
else {
HrZoneInfo zone(zonerx.cap(1), zonerx.cap(2), lo, hi, tr);
zoneInfos.append(zone);
}
}
next_line: {}
}
if (in_range) {
HrZoneRange range(begin, end, lt, restHr, maxHr);
range.zones = zoneInfos;
if (range.zones.empty()) {
if (range.lt > 0)
setHrZonesFromLT(range);
else {
err = tr("file ended without reading any zones for last range");
file.close();
return false;
}
}
else {
qSort(range.zones);
}
ranges.append(range);
}
file.close();
// sort the ranges
qSort(ranges);
// set the default zones if not in file
if (!scheme.nzones_default) {
// do we have a zone which is explicitly set?
for (int i=0; i<ranges.count(); i++) {
if (ranges[i].hrZonesSetFromLT == false) {
// set the defaults using this one!
scheme.nzones_default = ranges[i].zones.count();
for (int j=0; j<scheme.nzones_default; j++) {
scheme.zone_default.append(((double)ranges[i].zones[j].lo / (double)ranges[i].lt) * 100.00);
scheme.zone_default_is_pct.append(true);
scheme.zone_default_name.append(ranges[i].zones[j].name);
scheme.zone_default_desc.append(ranges[i].zones[j].desc);
scheme.zone_default_trimp.append(ranges[i].zones[j].trimp);
}
}
}
// still not set then reset to defaults as usual
if (!scheme.nzones_default) initializeZoneParameters();
}
// resolve undefined endpoints in ranges and zones
for (int nr = 0; nr < ranges.size(); nr ++) {
// clean up gaps or overlaps in zone ranges
if (ranges[nr].end.isNull())
ranges[nr].end =
(nr < ranges.size() - 1) ?
ranges[nr + 1].begin :
date_infinity;
else if ((nr < ranges.size() - 1) &&
(ranges[nr + 1].begin != ranges[nr].end)) {
append_to_warning(tr("Setting end date of range %1 "
"to start date of range %2.\n").
arg(nr + 1).
arg(nr + 2)
);
ranges[nr].end = ranges[nr + 1].begin;
}
else if ((nr == ranges.size() - 1) &&
(ranges[nr].end < QDate::currentDate())) {
append_to_warning(tr("Extending final range %1 to infinite "
"to include present date.\n").arg(nr + 1));
ranges[nr].end = date_infinity;
}
if (ranges[nr].lt <= 0) {
err = tr("LT must be greater than zero in zone "
"range %1 of hr.zones").arg(nr + 1);
return false;
}
if (ranges[nr].zones.size()) {
// check that the first zone starts with zero
ranges[nr].zones[0].lo = 0;
// resolve zone end powers
for (int nz = 0; nz < ranges[nr].zones.size(); nz ++) {
if (ranges[nr].zones[nz].hi == -1)
ranges[nr].zones[nz].hi =
(nz < ranges[nr].zones.size() - 1) ?
ranges[nr].zones[nz + 1].lo :
INT_MAX;
else if ((nz < ranges[nr].zones.size() - 1) &&
(ranges[nr].zones[nz].hi != ranges[nr].zones[nz + 1].lo)) {
if (abs(ranges[nr].zones[nz].hi - ranges[nr].zones[nz + 1].lo) > 4) {
append_to_warning(tr("Range %1: matching top of zone %2 "
"(%3) to bottom of zone %4 (%5).\n").
arg(nr + 1).
arg(ranges[nr].zones[nz].name).
arg(ranges[nr].zones[nz].hi).
arg(ranges[nr].zones[nz + 1].name).
arg(ranges[nr].zones[nz + 1].lo)
);
}
ranges[nr].zones[nz].hi = ranges[nr].zones[nz + 1].lo;
} else if ((nz == ranges[nr].zones.size() - 1) &&
(ranges[nr].zones[nz].hi < INT_MAX)) {
append_to_warning(tr("Range %1: setting top of zone %2 from %3 to MAX.\n").
arg(nr + 1).
arg(ranges[nr].zones[nz].name).
arg(ranges[nr].zones[nz].hi)
);
ranges[nr].zones[nz].hi = INT_MAX;
}
}
}
}
// mark zones as modified so pages which depend on zones can be updated
modificationTime = QDateTime::currentDateTime();
return true;
}
void EdrcPlugin::testValidatorTestOne()
{
// Create validator & test lists
ConsultResultValidator validator;
validator.setCrId(1);
QList<int> selectedIds;
QList<int> wrongIds;
// Create criterias using csv {ID;SORT;LABEL;INDENT;WEIGHT}
QString csv =
"0;0;++++ MANDATORY 1;1;1\n"
"1;1;++++ MANDATORY 2;1;1\n"
"2;2;++++ MANDATORY 3;1;1\n"
"3;3; ++1| MANDATORY 3.CHILD1;2;2\n"
"4;4; ++1| MANDATORY 3.CHILD2;2;2\n"
"5;5; ++1| MANDATORY 3.CHILD2;2;2\n"
"6;6; ;1;8\n"
"7;7;+ - OPTIONAL 1;1;6\n"
;
QList<ConsultResultCriteria> criterias;
foreach(const QString &line, csv.split("\n", QString::SkipEmptyParts))
criterias << criteria(line);
validator.setAvailableCriterias(criterias);
// Test 1 : missing one mandatory
selectedIds << 0 << 2 << 3 << 4 << 5;
wrongIds << 1;
testValidator(&validator, selectedIds, wrongIds, "Test1: missing one mandatory 1");
selectedIds.clear();
wrongIds.clear();
// Test 1bis : missing one mandatory
selectedIds << 0 << 1;
wrongIds << 2;
testValidator(&validator, selectedIds, wrongIds, "Test1: missing one mandatory 2");
selectedIds.clear();
wrongIds.clear();
// Test 1ter : missing one mandatory (child selected but not parent)
selectedIds << 0 << 1 << 3;
wrongIds << 2;
testValidator(&validator, selectedIds, wrongIds, "Test1: missing one mandatory (child selected but not parent)");
selectedIds.clear();
wrongIds.clear();
// Test 2 : missing children
selectedIds << 0 << 1 << 2;
wrongIds << 3 << 4 << 5;
testValidator(&validator, selectedIds, wrongIds, "Test1: missing children");
selectedIds.clear();
wrongIds.clear();
// Test 3 : ok
selectedIds << 0 << 1 << 2 << 3;
testValidator(&validator, selectedIds, wrongIds, "Test1: Correct coding 1");
selectedIds.clear();
wrongIds.clear();
// Test 4 : ok
selectedIds << 0 << 1 << 2 << 4;
testValidator(&validator, selectedIds, wrongIds, "Test1: Correct coding 2");
selectedIds.clear();
wrongIds.clear();
// Test 5 : ok
selectedIds << 0 << 1 << 2 << 5;
testValidator(&validator, selectedIds, wrongIds, "Test1: Correct coding 3");
selectedIds.clear();
wrongIds.clear();
}
void QgsPointDisplacementRenderer::createDisplacementGroups( QgsVectorLayer* vlayer, const QgsRectangle& viewExtent )
{
if ( !vlayer || ( vlayer->wkbType() != QGis::WKBPoint && vlayer->wkbType() != QGis::WKBPoint25D ) )
{
return;
}
mDisplacementGroups.clear();
mDisplacementIds.clear();
//use a spatial index to check if there is already a point at a position
QgsSpatialIndex spatialIndex;
//attributes
QgsAttributeList attList;
QList<QString> attributeStrings = usedAttributes();
QList<QString>::const_iterator attStringIt = attributeStrings.constBegin();
for ( ; attStringIt != attributeStrings.constEnd(); ++attStringIt )
{
attList.push_back( vlayer->fieldNameIndex( *attStringIt ) );
}
QgsFeature f;
QList<QgsFeatureId> intersectList;
QgsFeatureIterator fit = vlayer->getFeatures( QgsFeatureRequest().setFilterRect( viewExtent ).setSubsetOfAttributes( attList ) );
while ( fit.nextFeature( f ) )
{
intersectList.clear();
//check, if there is already a point at that position
if ( f.geometry() )
{
intersectList = spatialIndex.intersects( searchRect( f.geometry()->asPoint() ) );
if ( intersectList.empty() )
{
spatialIndex.insertFeature( f );
}
else
{
//go through all the displacement group maps and search an entry where the id equals the result of the spatial search
QgsFeatureId existingEntry = intersectList.at( 0 );
bool found = false;
QList< QMap<QgsFeatureId, QgsFeature> >::iterator it = mDisplacementGroups.begin();
for ( ; it != mDisplacementGroups.end(); ++it )
{
if ( it->size() > 0 && it->contains( existingEntry ) )
{
found = true;
QgsFeature feature;
it->insert( f.id(), f );
mDisplacementIds.insert( f.id() );
break;
}
}
if ( !found )//insert the already existing feature and the new one into a map
{
QMap<QgsFeatureId, QgsFeature> newMap;
QgsFeature existingFeature;
vlayer->getFeatures( QgsFeatureRequest().setFilterFid( existingEntry ) ).nextFeature( existingFeature );
newMap.insert( existingEntry, existingFeature );
mDisplacementIds.insert( existingEntry );
newMap.insert( f.id(), f );
mDisplacementIds.insert( f.id() );
mDisplacementGroups.push_back( newMap );
}
}
}
}
}
void
Configuration::readRules(QList<Rule> &rules, int *rules_version_return) {
// IMPROVE constants.h
// So wrong by the API specifications, but so right by the end results (no, I don't like doing it this way)
QSettings s("ProfileMatic", "rules");
// QSettings s("ajalkane", "ProfileMatic");
Rule defaultRule = Rule::createDefaultRule();
int rules_version = s.value("rulesVersion", 0).toInt();
if (rules_version_return != 0) {
*rules_version_return = rules_version;
}
int size = s.beginReadArray("rules");
for (int i = 0; i < size; ++i) {
s.setArrayIndex(i);
Rule r;
// r.ruleActive = s.value("ruleActive").toBool();
_assignRuleId(r, s.value("ruleId"));
r.setRuleName(s.value("ruleName").toString());
QList<int> daysList;
_readIntList(s, "days", "dayId", daysList);
r.setDays(QSet<int>::fromList(daysList));
QList<int> locationCells;
_readIntList(s, "locationCells", "cellId", locationCells);
r.setLocationCells(QSet<int>::fromList(locationCells));
QList<QString> wlans;
_readStringList(s, "wlans", "wlanName", wlans);
r.setWlan(QSet<QString>::fromList(wlans));
bool wlanTimeoutOk = false;
int wlanTimeout = s.value("wlanTimeout").toInt(&wlanTimeoutOk);
if (wlanTimeoutOk) {
r.setWlanTimeout(wlanTimeout);
}
QString timeStartStr = s.value("timeStart").toString();
QString timeEndStr = s.value("timeEnd").toString();
r.setTimeStart(QTime::fromString(timeStartStr));
r.setTimeEnd(rules_version == 0
? r.getTimeStart().addSecs(60)
: QTime::fromString(timeEndStr));
r.setProfile(s.value("profile").toString());
r.setRestoreProfile(s.value("restoreProfile", false).toBool());
bool profileVolumeOk = false;
int profileVolume = s.value("profileVolume").toInt(&profileVolumeOk);
if (profileVolumeOk) {
r.setProfileVolume(profileVolume);
}
bool flightModeOk = false;
int flightMode = s.value("flightMode").toInt(&flightModeOk);
if (flightModeOk) {
r.setFlightMode(flightMode);
}
r.setRestoreFlightMode(s.value("restoreFlightMode", false).toBool());
bool powerSavingModeOk = false;
int powerSavingMode = s.value("powerSavingMode").toInt(&powerSavingModeOk);
if (powerSavingModeOk) {
r.setPowerSavingMode(powerSavingMode);
}
r.setRestorePowerSavingMode(s.value("restorePowerSavingMode", false).toBool());
bool blueToothModeOk = false;
int blueToothMode = s.value("blueToothMode").toInt(&blueToothModeOk);
if (blueToothModeOk) {
r.setBlueToothMode(blueToothMode);
}
r.setRestoreBlueToothMode(s.value("restoreBlueToothMode", false).toBool());
bool cellularModeOk = false;
int cellularMode = s.value("cellularMode").toInt(&cellularModeOk);
if (cellularModeOk) {
r.setCellularMode(cellularMode);
}
r.setCommandLine(s.value("commandLine").toString());
QList<PresenceRule *> presenceRules;
_readPresenceRuleList(s, presenceRules);
r.setPresenceRules(presenceRules);
qDeleteAll(presenceRules);
presenceRules.clear();
r.setPresenceStatusMessage(s.value("presenceStatusMessage").toString());
r.setRestorePresence(s.value("restorePresence", r.getRestorePresence()).toBool());
r.setPresenceChangeType((Rule::PresenceChangeType) s.value("presenceChangeType", (int) Rule::CustomPresenceType).toInt());
// Make sure default rule is always last, and is created if it does not exist
if (!r.isDefaultRule()) {
rules << r;
} else {
defaultRule.actionsFrom(r);
}
qDebug("Configuration: index %d, ruleId: %s, ruleName: %s", i, qPrintable(r.getRuleId()), qPrintable(r.getRuleName()));
}
rules << defaultRule;
s.endArray();
// Write rules to finalize conversion
if (rules_version == 0) {
qDebug("Writing rules after conversion");
writeRules(rules);
}
}
