mirror of
https://gitlab.com/pholy/OSCAR-code.git
synced 2025-04-04 02:00:43 +00:00
1844 lines
69 KiB
C++
1844 lines
69 KiB
C++
/* user graph settings Implementation
|
|
*
|
|
* Copyright (c) 2019-2024 The OSCAR Team
|
|
*
|
|
* This file is subject to the terms and conditions of the GNU General Public
|
|
* License. See the file COPYING in the main directory of the source code
|
|
* for more details. */
|
|
|
|
// Issues no clear of results between runs or between passes.
|
|
// automatically open event. in graph view for events TAB
|
|
|
|
#define TEST_MACROS_ENABLEDoff
|
|
#include <test_macros.h>
|
|
|
|
#include <QWidget>
|
|
#include <QTabWidget>
|
|
#include <QListWidget>
|
|
#include <QProgressBar>
|
|
#include <QMessageBox>
|
|
#include <QAbstractButton>
|
|
#include <QPixmap>
|
|
#include <QSize>
|
|
#include <QChar>
|
|
#include <QLineEdit>
|
|
#include <QSpinBox>
|
|
#include <QDoubleSpinBox>
|
|
#include <QtGlobal>
|
|
#include <QHeaderView>
|
|
#include <QCoreApplication>
|
|
#include "dailySearchTab.h"
|
|
#include "SleepLib/day.h"
|
|
#include "SleepLib/profiles.h"
|
|
#include "SleepLib/journal.h"
|
|
#include "daily.h"
|
|
#include "SleepLib/machine_common.h"
|
|
|
|
enum DS_COL { DS_COL_LEFT=0, DS_COL_RIGHT, DS_COL_MAX };
|
|
enum DS_ROW{ DS_ROW_HEADER, DS_ROW_DATA };
|
|
#define DS_ROW_MAX (passDisplayLimit+DS_ROW_DATA)
|
|
|
|
|
|
/*
|
|
*
|
|
*
|
|
|
|
|
|
clear button
|
|
CLear button is always enabled and visible.
|
|
resets everything
|
|
next state: Match State
|
|
match button
|
|
open list of items to search
|
|
next state:Wait for start
|
|
next state:Searching
|
|
Same actions taken by clicking on Start Button.
|
|
Start Button
|
|
Starts or continues searching
|
|
disabled during searching
|
|
next state:Searching
|
|
Another Match Button
|
|
dispalys green if space available. Red if no more space.
|
|
disabled during searching
|
|
Saves Current match allowing for multiple matches
|
|
Display saved match.
|
|
State Not Changed.
|
|
open list of items to search
|
|
Results
|
|
column 1 (left most) loads date
|
|
column 2 (right most) loads date & open a different tab (Detailed, Events, Notes, Bookmark)
|
|
mark the check item selected. Can re-executed if necessary
|
|
|
|
States for search.
|
|
0) init state
|
|
goto ready to Match state
|
|
1) Match State (waitForSearchParameters)
|
|
Always Enabled except when searching. if searching then nextState is init;
|
|
start Button disabled && visible
|
|
AnotheMatch Button Visible with already saved matches
|
|
clear button
|
|
match selection for what to find
|
|
clears selections.
|
|
3) waitForStart allows match ,operation and value to be set
|
|
if no operation or value is required then nextState:Searching
|
|
Allows changing match, operation, or value.
|
|
Start && anotherMatch Buttons are enabled and green
|
|
next state: searching
|
|
4) searching
|
|
updates progress bar.
|
|
Updates result table.
|
|
Start && anotherMatch Buttons are disabled and gray.
|
|
next states : endOfSearch or Wait for Continuel
|
|
5) end of seaching
|
|
Start Button is red disables EndOfSearch.
|
|
anotherMatch Buttons is disabled and display red
|
|
next State : match.
|
|
6) WaitForContinue;
|
|
AnotherMatch is disabled (gtrayed out)
|
|
Start button displays continue search
|
|
Result Table is enabled.
|
|
Start Button is enabled & green
|
|
AnotherMatch button is diabled.
|
|
NextState: searching
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
/* layout of searchTAB
|
|
+========================+
|
|
| HELP |
|
|
+========================+
|
|
| HELPText |
|
|
+========================+
|
|
| Match | Clear | start |
|
|
|------------------------|
|
|
| control:cmd op value |
|
|
+========================+
|
|
| saved cmd op values |
|
|
+========================+
|
|
| Progress Bar |
|
|
+========================+
|
|
| Summary |
|
|
+========================+
|
|
| RESULTS |
|
|
+========================+
|
|
*/
|
|
|
|
|
|
DailySearchTab::DailySearchTab(Daily* daily , QWidget* searchTabWidget , QTabWidget* dailyTabWidget) :
|
|
daily(daily) , parent(daily) , searchTabWidget(searchTabWidget) ,dailyTabWidget(dailyTabWidget)
|
|
{
|
|
m_icon_selected = new QIcon(":/icons/checkmark.png");
|
|
m_icon_notSelected = new QIcon(":/icons/empty_box.png");
|
|
m_icon_configure = new QIcon(":/icons/cog.png");
|
|
|
|
createUi();
|
|
connectUi(true);
|
|
}
|
|
|
|
DailySearchTab::~DailySearchTab() {
|
|
connectUi(false);
|
|
delete m_icon_selected;
|
|
delete m_icon_notSelected;
|
|
delete m_icon_configure ;
|
|
};
|
|
|
|
void DailySearchTab::createUi() {
|
|
|
|
searchTabLayout = new QVBoxLayout(searchTabWidget);
|
|
|
|
resultTable = new QTableWidget(DS_ROW_MAX,DS_COL_MAX,searchTabWidget);
|
|
|
|
helpButton = new QPushButton(searchTabWidget);
|
|
helpText = new QTextEdit(searchTabWidget);
|
|
|
|
startWidget = new QWidget(searchTabWidget);
|
|
startLayout = new QHBoxLayout;
|
|
matchButton = new QPushButton( startWidget);
|
|
addMatchButton = new QPushButton( startWidget);
|
|
clearButton = new QPushButton( startWidget);
|
|
startButton = new QPushButton( startWidget);
|
|
|
|
|
|
commandWidget = new QWidget(searchTabWidget);
|
|
commandLayout = new QHBoxLayout();
|
|
commandButton = new QPushButton(commandWidget);
|
|
buttonGroup = new QButtonGroup(commandWidget);
|
|
operationCombo = new QComboBox(commandWidget);
|
|
operationButton = new QPushButton(commandWidget);
|
|
selectDouble = new QDoubleSpinBox(commandWidget);
|
|
selectInteger = new QSpinBox(commandWidget);
|
|
selectString = new QLineEdit(commandWidget);
|
|
selectUnits = new QLabel(commandWidget);
|
|
|
|
commandList = new QListWidget(resultTable);
|
|
|
|
cmdDescList = new QFrame(searchTabWidget);
|
|
cmdDescLayout = new QVBoxLayout(cmdDescList);
|
|
cmdDescLabelsUsed = 0;
|
|
|
|
summaryWidget = new QWidget(searchTabWidget);
|
|
summaryLayout = new QHBoxLayout();
|
|
summaryProgress = new QPushButton(summaryWidget);
|
|
summaryFound = new QPushButton(summaryWidget);
|
|
summaryMinMax = new QPushButton(summaryWidget);
|
|
progressBar = new QProgressBar(searchTabWidget);
|
|
|
|
populateControl();
|
|
|
|
searchTabLayout->setContentsMargins(0, 0, 0, 0);
|
|
searchTabLayout->addSpacing(2);
|
|
searchTabLayout->setMargin(2);
|
|
|
|
startLayout->addWidget(matchButton);
|
|
startLayout->addWidget(addMatchButton);
|
|
startLayout->addWidget(clearButton);
|
|
startLayout->addWidget(startButton);
|
|
startLayout->addStretch(0);
|
|
startLayout->addSpacing(2);
|
|
startLayout->setMargin(2);
|
|
startWidget->setLayout(startLayout);
|
|
|
|
commandLayout->addWidget(commandButton);
|
|
commandLayout->addWidget(operationCombo);
|
|
commandLayout->addWidget(operationButton);
|
|
commandLayout->addWidget(selectInteger);
|
|
commandLayout->addWidget(selectString);
|
|
commandLayout->addWidget(selectDouble);
|
|
commandLayout->addWidget(selectUnits);
|
|
|
|
commandLayout->setMargin(2);
|
|
commandLayout->setSpacing(2);
|
|
commandLayout->addStretch(0);
|
|
commandWidget->setLayout(commandLayout);
|
|
|
|
summaryLayout->addWidget(summaryProgress);
|
|
summaryLayout->addWidget(summaryFound);
|
|
summaryLayout->addWidget(summaryMinMax);
|
|
|
|
summaryLayout->setMargin(2);
|
|
summaryLayout->setSpacing(2);
|
|
summaryWidget->setLayout(summaryLayout);
|
|
|
|
|
|
QString styleSheetWidget = QString("border: 1px solid black; padding:none;");
|
|
startWidget->setStyleSheet(styleSheetWidget);
|
|
searchTabLayout ->addWidget(helpButton);
|
|
searchTabLayout ->addWidget(helpText);
|
|
searchTabLayout ->addWidget(startWidget);
|
|
searchTabLayout ->addWidget(commandWidget);
|
|
searchTabLayout ->addWidget(commandList);
|
|
searchTabLayout ->addWidget(cmdDescList);
|
|
searchTabLayout ->addWidget(progressBar);
|
|
searchTabLayout ->addWidget(summaryWidget);
|
|
searchTabLayout ->addWidget(resultTable);
|
|
|
|
// End of UI creatation
|
|
//Setup each BUtton / control item
|
|
|
|
QString styleButton=QString(
|
|
"QPushButton { color: black; border: 1px solid black; padding: 5px ;background-color:white; }"
|
|
"QPushButton:disabled { background-color: #EEEEFF;}"
|
|
//"QPushButton:disabled { color: #333333; border: 1px solid #333333; background-color: #dddddd;}"
|
|
);
|
|
QSizePolicy sizePolicyEP = QSizePolicy(QSizePolicy::Expanding,QSizePolicy::Preferred);
|
|
QSizePolicy sizePolicyEE = QSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
|
|
QSizePolicy sizePolicyEM = QSizePolicy(QSizePolicy::Expanding,QSizePolicy::Minimum);
|
|
QSizePolicy sizePolicyMM = QSizePolicy(QSizePolicy::Minimum,QSizePolicy::Minimum);
|
|
QSizePolicy sizePolicyMxMx = QSizePolicy(QSizePolicy::Maximum,QSizePolicy::Maximum);
|
|
Q_UNUSED (sizePolicyEP);
|
|
Q_UNUSED (sizePolicyMM);
|
|
Q_UNUSED (sizePolicyMxMx);
|
|
|
|
helpText->setReadOnly(true);
|
|
helpText->setLineWrapMode(QTextEdit::NoWrap);
|
|
QSize size = QFontMetrics(this->font()).size(0, helpString);
|
|
size.rheight() += 35 ; // scrollbar
|
|
size.rwidth() += 35 ; // scrollbar
|
|
helpText->setText(helpString);
|
|
helpText->setMinimumSize(textsize(this->font(),helpString));
|
|
helpText->setSizePolicy( sizePolicyEE );
|
|
|
|
helpButton->setStyleSheet( styleButton );
|
|
// helpButton->setText(tr("Help"));
|
|
helpMode = true;
|
|
on_helpButton_clicked();
|
|
|
|
matchButton->setIcon(*m_icon_configure);
|
|
matchButton->setStyleSheet( styleButton );
|
|
clearButton->setStyleSheet( styleButton );
|
|
addMatchButton->setStyleSheet( styleButton );
|
|
setText(matchButton,tr("Match"));
|
|
setText(clearButton,tr("Clear"));
|
|
|
|
|
|
commandButton->setStyleSheet("border:none;");
|
|
|
|
float height = float(commandList->count())*commandListItemHeight ;
|
|
commandList->setMinimumHeight(height);
|
|
commandList->setMinimumWidth(commandListItemMaxWidth);
|
|
setCommandPopupEnabled(false);
|
|
|
|
cmdDescLayout->addStretch(5);
|
|
cmdDescLayout->setSpacing(0);
|
|
cmdDescLayout->setContentsMargins(0,0,0,0);
|
|
cmdDescList->setLayout(cmdDescLayout);
|
|
cmdDescList->setSizePolicy(QSizePolicy::Minimum,QSizePolicy::Fixed);
|
|
cmdDescList->show();
|
|
|
|
setText(operationButton,"");
|
|
operationButton->setStyleSheet("border:none;");
|
|
operationButton->hide();
|
|
operationCombo->setSizePolicy(QSizePolicy::Minimum,QSizePolicy::Minimum);
|
|
setOperationPopupEnabled(false);
|
|
|
|
selectDouble->setSizePolicy(QSizePolicy::Minimum,QSizePolicy::Minimum);
|
|
selectInteger->setSizePolicy(QSizePolicy::Minimum,QSizePolicy::Minimum);
|
|
selectString->setSizePolicy(QSizePolicy::Minimum,QSizePolicy::Minimum);
|
|
selectUnits->setSizePolicy(QSizePolicy::Minimum,QSizePolicy::Minimum);
|
|
setText(selectUnits,"");
|
|
|
|
progressBar->setStyleSheet(
|
|
"QProgressBar{border: 1px solid black; text-align: center;}"
|
|
"QProgressBar::chunk { border: none; background-color: #ccddFF; } ");
|
|
|
|
|
|
summaryProgress->setStyleSheet( styleButton );
|
|
summaryFound->setStyleSheet( styleButton );
|
|
summaryMinMax->setStyleSheet( styleButton );
|
|
summaryProgress->setSizePolicy( sizePolicyEM ) ;
|
|
summaryFound->setSizePolicy( sizePolicyEM ) ;
|
|
summaryMinMax->setSizePolicy( sizePolicyEM ) ;
|
|
|
|
resultTable->horizontalHeader()->hide(); // hides numbers above each column
|
|
resultTable->horizontalHeader()->setStretchLastSection(true);
|
|
// get rid of selection coloring
|
|
resultTable->setStyleSheet("QTableView{background-color: white; selection-background-color: white; }");
|
|
|
|
float width = 14/*styleSheet:padding+border*/ + QFontMetrics(this->font()).size(Qt::TextSingleLine ,"WWW MMM 99 2222").width();
|
|
resultTable->setColumnWidth(DS_COL_LEFT, width);
|
|
|
|
width = 30/*iconWidthPlus*/+QFontMetrics(this->font()).size(Qt::TextSingleLine ,clearButton->text()).width();
|
|
//width = clearButton->width();
|
|
resultTable->setShowGrid(false);
|
|
|
|
|
|
setResult(DS_ROW_HEADER,0,QDate(),tr("DATE\nJumps to Date"));
|
|
setState( reset );
|
|
}
|
|
|
|
void DailySearchTab::connectUi(bool doConnect) {
|
|
if (doConnect) {
|
|
daily->connect(startButton, SIGNAL(clicked()), this, SLOT(on_startButton_clicked()) );
|
|
daily->connect(buttonGroup, SIGNAL(buttonReleased(QAbstractButton*)), this, SLOT(on_matchGroupButton_toggled(QAbstractButton*)));
|
|
daily->connect(clearButton, SIGNAL(clicked()), this, SLOT(on_clearButton_clicked()) );
|
|
daily->connect(matchButton, SIGNAL(clicked()), this, SLOT(on_matchButton_clicked()) );
|
|
daily->connect(addMatchButton, SIGNAL(clicked()), this, SLOT(on_addMatchButton_clicked()) );
|
|
daily->connect(helpButton , SIGNAL(clicked()), this, SLOT(on_helpButton_clicked()) );
|
|
|
|
daily->connect(commandButton, SIGNAL(clicked()), this, SLOT(on_commandButton_clicked()) );
|
|
daily->connect(operationButton, SIGNAL(clicked()), this, SLOT(on_operationButton_clicked()) );
|
|
daily->connect(operationCombo, SIGNAL(activated(int)), this, SLOT(on_operationCombo_activated(int) ));
|
|
|
|
daily->connect(selectInteger, SIGNAL(valueChanged(int)), this, SLOT(on_intValueChanged(int)) );
|
|
daily->connect(selectDouble, SIGNAL(valueChanged(double)), this, SLOT(on_doubleValueChanged(double)) );
|
|
daily->connect(selectString, SIGNAL(textEdited(QString)), this, SLOT(on_textEdited(QString)) );
|
|
|
|
} else {
|
|
daily->disconnect(startButton, SIGNAL(clicked()), this, SLOT(on_startButton_clicked()) );
|
|
daily->disconnect(buttonGroup, SIGNAL(buttonReleased(QAbstractButton*)), this, SLOT(on_matchGroupButton_toggled(QAbstractButton*)));
|
|
daily->disconnect(clearButton, SIGNAL(clicked()), this, SLOT(on_clearButton_clicked()) );
|
|
daily->disconnect(matchButton, SIGNAL(clicked()), this, SLOT(on_matchButton_clicked()) );
|
|
daily->disconnect(addMatchButton, SIGNAL(clicked()), this, SLOT(on_addMatchButton_clicked()) );
|
|
daily->disconnect(helpButton , SIGNAL(clicked()), this, SLOT(on_helpButton_clicked()) );
|
|
|
|
daily->disconnect(commandButton, SIGNAL(clicked()), this, SLOT(on_commandButton_clicked()) );
|
|
daily->disconnect(operationButton, SIGNAL(clicked()), this, SLOT(on_operationButton_clicked()) );
|
|
daily->disconnect(operationCombo, SIGNAL(activated(int)), this, SLOT(on_operationCombo_activated(int) ));
|
|
|
|
daily->disconnect(selectInteger, SIGNAL(valueChanged(int)), this, SLOT(on_intValueChanged(int)) );
|
|
daily->disconnect(selectDouble, SIGNAL(valueChanged(double)), this, SLOT(on_doubleValueChanged(double)) );
|
|
daily->disconnect(selectString, SIGNAL(textEdited(QString)), this, SLOT(on_textEdited(QString)) );
|
|
|
|
}
|
|
}
|
|
|
|
void DailySearchTab::addCommandItem(QString str,int topic) {
|
|
float scaleX= (float)(QWidget::logicalDpiX()*100.0)/(float)(QWidget::physicalDpiX());
|
|
float percentX = scaleX/100.0;
|
|
float width = QFontMetricsF(this->font()).size(Qt::TextSingleLine , str).width();
|
|
width += 30 ; // account for scrollbar width;
|
|
commandListItemMaxWidth = max (commandListItemMaxWidth, (width*percentX));
|
|
commandListItemHeight = QFontMetricsF(this->font()).size(Qt::TextSingleLine , str).height();
|
|
QAbstractButton* topicButton ;
|
|
//topicButton = new QCheckBox(str,commandList);
|
|
topicButton = new QRadioButton(str,commandList);
|
|
buttonGroup->addButton(topicButton,topic);
|
|
|
|
QListWidgetItem* item = new QListWidgetItem(commandList);
|
|
item->setData(Qt::UserRole,topic);
|
|
commandList->setItemWidget(item, topicButton);
|
|
}
|
|
|
|
void DailySearchTab::showOnlyAhiChannels(bool ahiOnly) {
|
|
for (int ind = 0; ind <commandList->count() ; ++ind) {
|
|
QListWidgetItem *item = commandList->item(ind);
|
|
QAbstractButton* topicButton = dynamic_cast<QAbstractButton*>(commandList->itemWidget(item));
|
|
if (!topicButton) continue;
|
|
int topic = buttonGroup->id(topicButton);
|
|
if (apneaLikeChannels.contains(topic)) {
|
|
item->setHidden(false);
|
|
} else {
|
|
if (topic == ST_CLEAR) {
|
|
topicButton->setChecked(true);
|
|
item->setHidden(true);
|
|
} else if (topic == ST_APNEA_ALL) {
|
|
item->setHidden(!ahiOnly);
|
|
} else {
|
|
item->setHidden(ahiOnly);
|
|
}
|
|
}
|
|
}
|
|
if (!ahiOnly) {
|
|
lastButton = nullptr;
|
|
lastTopic = ST_NONE ;
|
|
};
|
|
};
|
|
|
|
void DailySearchTab::on_matchGroupButton_toggled(QAbstractButton* topicButton ) {
|
|
if (topicButton) {
|
|
int topic = buttonGroup->id(topicButton);
|
|
if (lastTopic == ST_APNEA_LENGTH ) {
|
|
//menu was only ahi channels
|
|
apneaLikeChannels.clear();
|
|
if (topic == ST_APNEA_ALL ) {
|
|
initApneaLikeChannels();
|
|
} else {
|
|
// topic is ChannelIDA
|
|
apneaLikeChannels.push_back(topic);
|
|
}
|
|
process_match_info(lastButton->text(), ST_APNEA_LENGTH );
|
|
return;
|
|
}
|
|
lastButton = topicButton;
|
|
lastTopic = buttonGroup->id(topicButton);
|
|
if (lastTopic == ST_APNEA_LENGTH ) {
|
|
initApneaLikeChannels();
|
|
showOnlyAhiChannels(true);
|
|
return;
|
|
}
|
|
} else {
|
|
return;
|
|
}
|
|
process_match_info(lastButton->text(), lastTopic );
|
|
}
|
|
|
|
void DailySearchTab::initApneaLikeChannels() {
|
|
apneaLikeChannels = QVector<ChannelID>(ahiChannels);
|
|
if (p_profile->cpap->userEventFlagging()) {
|
|
apneaLikeChannels.push_back(CPAP_UserFlag1);
|
|
apneaLikeChannels.push_back(CPAP_UserFlag2);
|
|
}
|
|
}
|
|
|
|
void DailySearchTab::updateEvents(ChannelID id,QString fullname) {
|
|
if (commandEventList.contains(fullname)) return;
|
|
commandEventList.insert(fullname);
|
|
addCommandItem(fullname,id);
|
|
}
|
|
|
|
void DailySearchTab::populateControl() {
|
|
opCodeMap.clear();
|
|
opCodeMap.insert( opCodeStr(OP_LT),OP_LT);
|
|
opCodeMap.insert( opCodeStr(OP_GT),OP_GT);
|
|
opCodeMap.insert( opCodeStr(OP_LE),OP_LE);
|
|
opCodeMap.insert( opCodeStr(OP_GE),OP_GE);
|
|
opCodeMap.insert( opCodeStr(OP_EQ),OP_EQ);
|
|
opCodeMap.insert( opCodeStr(OP_NE),OP_NE);
|
|
|
|
// The order here is the order in the popup box
|
|
operationCombo->clear();
|
|
operationCombo->addItem(opCodeStr(OP_LT));
|
|
operationCombo->addItem(opCodeStr(OP_GT));
|
|
operationCombo->addItem(opCodeStr(OP_LE));
|
|
operationCombo->addItem(opCodeStr(OP_GE));
|
|
operationCombo->addItem(opCodeStr(OP_EQ));
|
|
operationCombo->addItem(opCodeStr(OP_NE));
|
|
|
|
// Now add events
|
|
commandList->clear();
|
|
addCommandItem(tr("Journal"),ST_JOURNAL);
|
|
addCommandItem(tr("Notes"),ST_NOTES);
|
|
addCommandItem(tr("Notes containing"),ST_NOTES_STRING);
|
|
addCommandItem(tr("Bookmarks"),ST_BOOKMARKS);
|
|
addCommandItem(tr("Bookmarks containing"),ST_BOOKMARKS_STRING);
|
|
addCommandItem(tr("AHI "),ST_AHI);
|
|
addCommandItem(tr("Daily Duration"),ST_DAILY_USAGE);
|
|
addCommandItem(tr("Session Duration" ),ST_SESSION_LENGTH);
|
|
addCommandItem(tr("Days Skipped"),ST_DAYS_SKIPPED);
|
|
addCommandItem(tr("Apnea Length"),ST_APNEA_LENGTH);
|
|
qint32 chans = schema::SPAN | schema::FLAG | schema::MINOR_FLAG;
|
|
if ( !p_profile->cpap->clinicalMode() ) {
|
|
addCommandItem(tr("Disabled Sessions"),ST_DISABLED_SESSIONS);
|
|
}
|
|
addCommandItem(tr("Number of Sessions"),ST_SESSIONS_QTY);
|
|
|
|
QDate date = p_profile->LastDay(MT_CPAP);
|
|
if ( !date.isValid()) return;
|
|
Day* day = p_profile->GetDay(date);
|
|
if (!day) return;
|
|
|
|
if (p_profile->general->showUnknownFlags()) chans |= schema::UNKNOWN;
|
|
QList<ChannelID> available;
|
|
available.append(day->getSortedMachineChannels(chans));
|
|
|
|
for (int i=0; i < available.size(); ++i) {
|
|
ChannelID id = available.at(i);
|
|
schema::Channel chan = schema::channel[ id ];
|
|
updateEvents(id,chan.fullname());
|
|
}
|
|
// these must be at end
|
|
addCommandItem(tr("All Apnea"),ST_APNEA_ALL);
|
|
addCommandItem("CLEAR",ST_CLEAR);
|
|
}
|
|
|
|
void DailySearchTab::setState(STATE newState) {
|
|
STATE prev=state;
|
|
state = newState;
|
|
//enum STATE { reset , waitForSearchTopic , matching , multpileMatches , waitForStart , autoStart , searching , endOfSeaching , waitForContinue , noDataFound};
|
|
switch (state) {
|
|
case multpileMatches :
|
|
break;
|
|
case matching :
|
|
if (prev == multpileMatches) {
|
|
matchButton->show();
|
|
addMatchButton->hide();
|
|
} else {
|
|
setState(reset);
|
|
}
|
|
break;
|
|
case reset :
|
|
clrCmdDescList();
|
|
match = matches.reset();
|
|
clearMatch() ;
|
|
setState(waitForSearchTopic);
|
|
break;
|
|
case waitForSearchTopic :
|
|
setColor(matchButton,green);
|
|
matchButton->show();
|
|
addMatchButton->hide();
|
|
startButton->hide();
|
|
hideResults(true);
|
|
progressBar->hide();
|
|
summaryWidget->hide();
|
|
setCommandPopupEnabled(false);
|
|
startButton_1stPass=true;
|
|
showOnlyAhiChannels(false);
|
|
break;
|
|
case waitForStart :
|
|
matchButton->hide();
|
|
addMatchButton->show();
|
|
startButton->show();
|
|
break;
|
|
case autoStart :
|
|
break;
|
|
case searching :
|
|
//if (prev == searching) break;
|
|
matchButton->hide();
|
|
addMatchButton->hide();
|
|
hideResults(true);
|
|
progressBar->show();
|
|
summaryWidget->show();
|
|
break;
|
|
case waitForContinue :
|
|
startButton->setEnabled(true);
|
|
startButton_1stPass=false;
|
|
setText(startButton,(tr("Continue Search")));
|
|
setColor(startButton,green);
|
|
matchButton->hide();
|
|
addMatchButton->hide();
|
|
hideResults(false);
|
|
break;
|
|
case endOfSeaching :
|
|
startButton->setEnabled(false);
|
|
setText(startButton,tr("End of Search"));
|
|
setColor(startButton,red);
|
|
matchButton->show();
|
|
addMatchButton->hide();
|
|
hideResults(false);
|
|
break;
|
|
case noDataFound :
|
|
startButton->setEnabled(false);
|
|
setText(startButton,tr("No Matches"));
|
|
setColor(startButton,red);
|
|
matchButton->show();
|
|
addMatchButton->hide();
|
|
hideResults(true);
|
|
break;
|
|
};
|
|
};
|
|
|
|
QRegExp Match::searchPatterToRegex (QString searchPattern) {
|
|
|
|
const static QChar bSlash('\\');
|
|
const static QChar asterisk('*');
|
|
const static QChar qMark('?');
|
|
const static QChar emptyChar('\0');
|
|
const QString emptyStr("");
|
|
const QString anyStr(".*");
|
|
const QString singleStr(".");
|
|
|
|
|
|
searchPattern = searchPattern.simplified();
|
|
//QString wilDebug = searchPattern;
|
|
//
|
|
// wildcard searches uses '*' , '?' and '\'
|
|
// '*' will match zero or more characters. '?' will match one character. the escape character '\' always matches the next character.
|
|
// '\\' will match '\'. '\*' will match '*'. '\?' mach for '?'. otherwise the '\' is ignored
|
|
|
|
// The user request will be mapped into a valid QRegularExpression. All RegExp meta characters in the request must be handled.
|
|
// Most of the meta characters will be escapped. backslash, asterisk, question mark will be treated.
|
|
// '\*' -> '\*'
|
|
// '\?' -> '\?'
|
|
// '*' -> '.*' // really asterisk followed by asterisk or questionmark -> as a single asterisk.
|
|
// '?' -> '.'
|
|
// '.' -> '\.' // default for all other meta characters.
|
|
// '\\' -> '[\\]'
|
|
|
|
// QT documentation states regex reserved characetrs are $ () * + . ? [ ] ^ {} | // seems to be missing / \ -
|
|
// Regular expression reserved characters / \ [ ] () {} | + ^ . $ ? * -
|
|
|
|
|
|
static const QString metaClass = QString( "[ / \\\\ \\[ \\] ( ) { } | + ^ . $ ? * - ]").replace(" ",""); // slash,bSlash,[,],(,),{,},+,^,.,$,?,*,-,|
|
|
static const QRegExp metaCharRegex(metaClass);
|
|
#if 0
|
|
// Verify search pattern
|
|
if (!metaCharRegex.isValid()) {
|
|
return QRegExp();
|
|
}
|
|
#endif
|
|
|
|
// regex meta characetrs. all regex meta character must be acounts to us regular expression to make wildcard work.
|
|
// they will be escaped. except for * and ? which will be treated separately
|
|
searchPattern = searchPattern.simplified(); // remove witespace at ends. and multiple white space to a single space.
|
|
|
|
// now handle each meta character requested.
|
|
int pos=0;
|
|
int len=1;
|
|
QString replace;
|
|
QChar metaChar;
|
|
QChar nextChar;
|
|
while (pos < (len = searchPattern.length()) ) {
|
|
pos = searchPattern.indexOf(metaCharRegex,pos);
|
|
if (pos<0) break;
|
|
metaChar = searchPattern.at(pos);
|
|
if (pos+1<len) {
|
|
nextChar = searchPattern.at(pos+1);
|
|
} else {
|
|
nextChar = emptyChar;
|
|
}
|
|
|
|
int replaceCount = 1;
|
|
if (metaChar == asterisk ){
|
|
int next=pos+1;
|
|
// discard any successive wildcard type of characters.
|
|
while ( (nextChar == asterisk ) || (nextChar == qMark ) ) {
|
|
searchPattern.remove(next,1);
|
|
len = searchPattern.length();
|
|
if (next>=len) break;
|
|
nextChar = searchPattern.at(next);
|
|
}
|
|
replace = anyStr; // if asterisk then write dot asterisk
|
|
} else if (metaChar == qMark ) {
|
|
replace = singleStr;
|
|
} else {
|
|
if ((metaChar == bSlash ) ) {
|
|
if ( ((nextChar == bSlash ) || (nextChar == asterisk ) || (nextChar == qMark ) ) ) {
|
|
pos+=2; continue;
|
|
}
|
|
replace = emptyStr; //match next character. same as deleteing the backslash
|
|
} else {
|
|
// Now have a regex reserved character that needs escaping.
|
|
// insert an escape '\' before meta characters.
|
|
replace = QString("\\%1").arg(metaChar);
|
|
}
|
|
}
|
|
searchPattern.replace(pos,replaceCount,replace);
|
|
pos+=replace.length(); // skip over characters added.
|
|
}
|
|
|
|
|
|
// searchPattern = QString("^.*%1.*$").arg(searchPattern); // add asterisk to end end points.
|
|
QRegExp convertedRegex =QRegExp(searchPattern,Qt::CaseInsensitive, QRegExp::RegExp);
|
|
// verify convertedRegex to use
|
|
if (!convertedRegex.isValid()) {
|
|
qWarning() << QFileInfo( __FILE__).baseName() <<"[" << __LINE__ << "] " << convertedRegex.errorString() << convertedRegex ;
|
|
return QRegExp();
|
|
}
|
|
return convertedRegex;
|
|
}
|
|
|
|
bool Match::compare(QString find , QString target)
|
|
{
|
|
OpCode opCode = operationOpCode;
|
|
bool ret=false;
|
|
if (opCode==OP_CONTAINS) {
|
|
ret = target.contains(find,Qt::CaseInsensitive);
|
|
} else if (opCode==OP_WILDCARD) {
|
|
QRegExp regex = searchPatterToRegex(find);
|
|
ret = target.contains(regex);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
bool Match::compare(int aa , int bb)
|
|
{
|
|
// OP_INVALID=0 , OP_LT=1 , OP_GT=2 , OP_NE=3 , OP_EQ=4 , OP_LE=5 , OP_GE=6 , OP_END_NUMERIC ,
|
|
OpCode opCode = operationOpCode;
|
|
if (opCode>=OP_END_NUMERIC) return false;
|
|
int mode=0;
|
|
if (aa <bb ) {
|
|
mode |= OP_LT;
|
|
} else if (aa >bb ) {
|
|
mode |= OP_GT;
|
|
} else {
|
|
mode |= OP_EQ;
|
|
}
|
|
bool result = ( (mode & (int)opCode)!=0);
|
|
return result;
|
|
}
|
|
|
|
QString Match::valueToString(int value, QString defaultValue) {
|
|
switch (valueMode) {
|
|
case hundredths :
|
|
return QString("%1").arg( (double(value)/100.0),0,'f',2);
|
|
break;
|
|
case hoursToMs:
|
|
case minutesToMs:
|
|
return formatTime(value);
|
|
break;
|
|
case displayWhole:
|
|
case opWhole:
|
|
return QString("%1").arg(value);
|
|
break;
|
|
case secondsDisplayString:
|
|
case displayString:
|
|
case opString:
|
|
return foundString;
|
|
break;
|
|
case invalidValueMode:
|
|
case notUsed:
|
|
break;
|
|
}
|
|
return defaultValue;
|
|
}
|
|
|
|
QSize DailySearchTab::setText(QLabel* label ,QString text) {
|
|
QSize size = textsize(label->font(),text);
|
|
int width = size.width();
|
|
width += 20 ; //margings
|
|
label->setMinimumWidth(width);
|
|
label->setSizePolicy(QSizePolicy::Fixed,QSizePolicy::Fixed);
|
|
label->setText(text);
|
|
return size;
|
|
}
|
|
|
|
QSize DailySearchTab::setText(QPushButton* but ,QString text) {
|
|
QSize size = textsize(but->font(),text);
|
|
int width = size.width();
|
|
width += but->iconSize().width();
|
|
width += 4 ; //margings
|
|
but->setMinimumWidth(width);
|
|
but->setSizePolicy(QSizePolicy::Fixed,QSizePolicy::Fixed);
|
|
but->setText(text);
|
|
return size;
|
|
}
|
|
|
|
void DailySearchTab::setResult(int row,int column,QDate date,QString text) {
|
|
if(column<0 || column>1) {
|
|
return;
|
|
} else if ( row < DS_ROW_HEADER || row >= DS_ROW_MAX) {
|
|
return;
|
|
}
|
|
|
|
QWidget* header = resultTable->cellWidget(row,column);
|
|
GPushButton* item;
|
|
if (header == nullptr) {
|
|
item = new GPushButton(row,column,date,this);
|
|
//item->setStyleSheet("QPushButton {text-align: left;vertical-align:top;}");
|
|
item->setStyleSheet(
|
|
"QPushButton { text-align: left;color: black; border: 1px solid black; padding: 5px ;background-color:white; }" );
|
|
resultTable->setCellWidget(row,column,item);
|
|
} else {
|
|
item = dynamic_cast<GPushButton *>(header);
|
|
if (item == nullptr) {
|
|
return;
|
|
}
|
|
item->setDate(date);
|
|
}
|
|
if (row == DS_ROW_HEADER) {
|
|
QSize size=setText(item,text);
|
|
resultTable->setRowHeight(DS_ROW_HEADER,8/*margins*/+size.height());
|
|
return; // skip make row visible if header. will be made visible with hideResults method
|
|
} else {
|
|
item->setIcon(*m_icon_notSelected);
|
|
if (column == 0) {
|
|
setText(item,date.toString());
|
|
} else {
|
|
setText(item,text);
|
|
}
|
|
}
|
|
if ( row == DS_ROW_DATA ) {
|
|
resultTable->setRowHidden(DS_ROW_HEADER,false);
|
|
}
|
|
resultTable->setRowHidden(row,false);
|
|
}
|
|
|
|
void Match::updateMinMaxValues(qint32 value)
|
|
{
|
|
foundValue = value;
|
|
if (!minMaxValid ) {
|
|
minMaxValid = true;
|
|
minInteger = value;
|
|
maxInteger = value;
|
|
} else if ( value < minInteger ) {
|
|
minInteger = value;
|
|
} else if ( value > maxInteger ) {
|
|
maxInteger = value;
|
|
}
|
|
}
|
|
|
|
bool DailySearchTab::matchFind(Match* myMatch ,Day* day, QDate& date, Qt::Alignment& alignment) {
|
|
bool found=false;
|
|
switch (myMatch->searchTopic) {
|
|
case ST_DAYS_SKIPPED :
|
|
found=!day;
|
|
break;
|
|
case ST_DISABLED_SESSIONS :
|
|
{
|
|
qint32 numDisabled=0;
|
|
QList<Session *> sessions = day->getSessions(MT_CPAP,true);
|
|
for (auto & sess : sessions) {
|
|
if (!sess->enabled()) {
|
|
numDisabled ++;
|
|
found=true;
|
|
}
|
|
}
|
|
myMatch->updateMinMaxValues(numDisabled);
|
|
}
|
|
break;
|
|
case ST_JOURNAL :
|
|
{
|
|
Session* journal=daily->GetJournalSession(date,false);
|
|
if (journal) {
|
|
myMatch->foundString = journal->settings[LastUpdated].toDateTime().toString();
|
|
myMatch->foundString.append(" ");
|
|
bool empty =true;
|
|
if ( journal->settings.contains(Bookmark_Start) ) {
|
|
if (journal->settings[Bookmark_Start].toList().size()>0) {
|
|
empty = false;
|
|
myMatch->foundString.append("B");
|
|
/* Not reuired.
|
|
if ( journal->settings.contains(Bookmark_Notes) ) {
|
|
if (journal->settings[Bookmark_Start].toList().size()>0) {
|
|
myMatch->foundString.append("n");
|
|
}
|
|
}
|
|
*/
|
|
}
|
|
}
|
|
if ( journal->settings.contains(Journal_Notes) ) {
|
|
myMatch->foundString.append("N");
|
|
empty = false;
|
|
}
|
|
if ( journal->settings.contains(Journal_Weight) ) {
|
|
myMatch->foundString.append("W");
|
|
empty = false;
|
|
}
|
|
if ( journal->settings.contains(Journal_ZombieMeter) ) {
|
|
myMatch->foundString.append("F");
|
|
empty = false;
|
|
}
|
|
if (empty) {
|
|
break;
|
|
myMatch->foundString.append(tr("Empty"));
|
|
}
|
|
found=true;
|
|
alignment=Qt::AlignLeft;
|
|
}
|
|
}
|
|
break;
|
|
case ST_NOTES :
|
|
{
|
|
Session* journal=daily->GetJournalSession(date,false);
|
|
if (journal && journal->settings.contains(Journal_Notes)) {
|
|
QString jcontents = Daily::convertHtmlToPlainText(journal->settings[Journal_Notes].toString());
|
|
myMatch->foundString = jcontents.simplified().left(stringDisplayLen).simplified();
|
|
found=true;
|
|
alignment=Qt::AlignLeft;
|
|
}
|
|
}
|
|
break;
|
|
case ST_BOOKMARKS :
|
|
{
|
|
Session* journal=daily->GetJournalSession(date,false);
|
|
if (journal && journal->settings.contains(Bookmark_Notes)) {
|
|
found=true;
|
|
QStringList notes = journal->settings[Bookmark_Notes].toStringList();
|
|
for ( const auto & note : notes) {
|
|
myMatch->foundString = note.simplified().left(stringDisplayLen).simplified();
|
|
alignment=Qt::AlignLeft;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case ST_BOOKMARKS_STRING :
|
|
{
|
|
Session* journal=daily->GetJournalSession(date,false);
|
|
if (journal && journal->settings.contains(Bookmark_Notes)) {
|
|
QStringList notes = journal->settings[Bookmark_Notes].toStringList();
|
|
QString findStr = selectString->text();
|
|
for ( const auto & note : notes) {
|
|
if (myMatch->compare(findStr , note))
|
|
{
|
|
found=true;
|
|
myMatch->foundString = note.simplified().left(stringDisplayLen).simplified();
|
|
alignment=Qt::AlignLeft;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case ST_NOTES_STRING :
|
|
{
|
|
Session* journal=daily->GetJournalSession(date,false);
|
|
if (journal && journal->settings.contains(Journal_Notes)) {
|
|
QString jcontents = Daily::convertHtmlToPlainText(journal->settings[Journal_Notes].toString());
|
|
QString findStr = selectString->text();
|
|
if (jcontents.contains(findStr,Qt::CaseInsensitive) ) {
|
|
found=true;
|
|
myMatch->foundString = jcontents.simplified().left(stringDisplayLen).simplified();
|
|
alignment=Qt::AlignLeft;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case ST_AHI :
|
|
{
|
|
EventDataType dahi =calculateAhi(day);
|
|
dahi += 0.005;
|
|
dahi *= 100.0;
|
|
int ahi = (int)dahi;
|
|
myMatch->updateMinMaxValues(ahi);
|
|
found = myMatch->compare (ahi , myMatch->compareValue);
|
|
myMatch->foundString = myMatch->valueToString( ahi,"----");
|
|
}
|
|
break;
|
|
case ST_CLEAR :
|
|
case ST_APNEA_ALL :
|
|
break; // should never get here
|
|
case ST_APNEA_LENGTH :
|
|
{
|
|
QList<Session *> sessions = day->getSessions(MT_CPAP);
|
|
QMap<ChannelID,int> values;
|
|
// find possible channeld to use
|
|
QList<ChannelID> chans;
|
|
for( auto code : apneaLikeChannels) {
|
|
if (day->count(code)) { chans.push_back(code); }
|
|
}
|
|
bool errorFound = false;
|
|
QString result;
|
|
if (!apneaLikeChannels.isEmpty()) {
|
|
for (Session* sess : sessions ) {
|
|
if (!sess->enabled()) continue;
|
|
auto keys = sess->eventlist.keys();
|
|
if (keys.size() <= 0) {
|
|
bool ok = sess->LoadSummary(false);
|
|
bool ok1 = sess->OpenEvents(false);
|
|
keys = sess->eventlist.keys();
|
|
if ((keys.size() <= 0) || !ok || !ok1 ) {
|
|
if ((keys.size() <= 0) || !ok || !ok1 ) {
|
|
errorFound |= true;
|
|
// skip this channel
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
for( ChannelID code : apneaLikeChannels) {
|
|
auto evlist = sess->eventlist.find(code);
|
|
if (evlist == sess->eventlist.end()) {
|
|
continue;
|
|
}
|
|
// Now we go through the event list for the *session* (not for the day)
|
|
for (int z=0;z<evlist.value().size();z++) {
|
|
EventList & ev=*(evlist.value()[z]);
|
|
for (quint32 o=0;o<ev.count();o++) {
|
|
int sec = evlist.value()[z]->raw(o);
|
|
//qint64 time = evlist.value()[z]->time(o);
|
|
if (apneaLikeChannels.size()==1) {
|
|
myMatch->updateMinMaxValues(sec);
|
|
}
|
|
if (myMatch->compare (sec , myMatch->compareValue)) {
|
|
// save value in map
|
|
auto it = values.find(code);
|
|
if (it == values.end() ) {
|
|
values.insert(code,sec);
|
|
} else {
|
|
// save max or min value in map
|
|
int saved_sec = it.value();
|
|
// save highest or lowest value.
|
|
if (myMatch->compare (sec ,saved_sec) ) {
|
|
*it = sec;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for ( auto it= values.begin() ; it != values.end() ; it++) {
|
|
ChannelID code = it.key();
|
|
int value = it.value();
|
|
result += QString("%1:%2 ").arg(schema::channel[ code ].label()).arg(value);
|
|
}
|
|
if (errorFound) {
|
|
daysSkipped++;
|
|
return false;
|
|
};
|
|
found = !result.isEmpty();
|
|
if (found) {
|
|
myMatch->foundString = result;
|
|
alignment=Qt::AlignLeft;
|
|
}
|
|
}
|
|
break;
|
|
case ST_SESSION_LENGTH :
|
|
{
|
|
bool valid=false;
|
|
qint64 value=0;
|
|
QList<Session *> sessions = day->getSessions(MT_CPAP);
|
|
for (auto & sess : sessions) {
|
|
qint64 ms = sess->length();
|
|
myMatch->updateMinMaxValues(ms);
|
|
if (myMatch->compare (ms , myMatch->compareValue) ) {
|
|
found =true;
|
|
}
|
|
if (!valid) {
|
|
valid=true;
|
|
value=ms;
|
|
} else if (myMatch->compare (ms , value) ) {
|
|
value=ms;
|
|
}
|
|
}
|
|
if (valid) myMatch->updateMinMaxValues(value);
|
|
myMatch->foundString = myMatch->valueToString( value,"----");
|
|
}
|
|
break;
|
|
case ST_SESSIONS_QTY :
|
|
{
|
|
QList<Session *> sessions = day->getSessions(MT_CPAP);
|
|
qint32 size = sessions.size();
|
|
myMatch->updateMinMaxValues(size);
|
|
found=myMatch->compare (size , myMatch->compareValue);
|
|
myMatch->foundString = myMatch->valueToString( size,"----");
|
|
}
|
|
break;
|
|
case ST_DAILY_USAGE :
|
|
{
|
|
QList<Session *> sessions = day->getSessions(MT_CPAP);
|
|
qint64 sum = 0 ;
|
|
for (auto & sess : sessions) {
|
|
sum += sess->length();
|
|
}
|
|
myMatch->updateMinMaxValues(sum);
|
|
found=myMatch->compare (sum , myMatch->compareValue);
|
|
myMatch->foundString = myMatch->valueToString( sum,"----");
|
|
}
|
|
break;
|
|
case ST_EVENT :
|
|
{
|
|
qint32 count = day->count(myMatch->channelId);
|
|
myMatch->updateMinMaxValues(count);
|
|
found=myMatch->compare (count , myMatch->compareValue);
|
|
myMatch->foundString = myMatch->valueToString( count,"----");
|
|
}
|
|
break;
|
|
case ST_NONE :
|
|
break;
|
|
}
|
|
return found;
|
|
};
|
|
|
|
void DailySearchTab::find(QDate& date) {
|
|
QCoreApplication::processEvents();
|
|
Day* day = p_profile->GetDay(date);
|
|
if ( (!day) && (match->searchTopic != ST_DAYS_SKIPPED)) { daysSkipped++; return;};
|
|
Qt::Alignment alignment=Qt::AlignCenter;
|
|
bool found=false;
|
|
QString result;
|
|
for (int idx = 0 ; idx < matches.size() ; ++idx ) {
|
|
if ((!day) && (match->searchTopic != ST_DAYS_SKIPPED)) break;
|
|
Match* tmpMatch = matches.at(idx);
|
|
if (tmpMatch->isEmpty()) { continue; };
|
|
|
|
found = matchFind(tmpMatch,day,date,alignment);
|
|
if (!found) return ;
|
|
result += tmpMatch->foundString;
|
|
result += " ";
|
|
};
|
|
if (!found) return ;
|
|
addItem(date , result,alignment );
|
|
passFound++;
|
|
daysFound++;
|
|
return ;
|
|
};
|
|
|
|
void DailySearchTab::search(QDate date) {
|
|
setState( searching );
|
|
if (!date.isValid()) {
|
|
qWarning() << "DailySearchTab::find invalid date." << date;
|
|
return;
|
|
}
|
|
startButton->setEnabled(false);
|
|
match->foundString.clear();
|
|
passFound=0;
|
|
while (date >= earliestDate) {
|
|
nextDate = date;
|
|
if (passFound >= passDisplayLimit) break;
|
|
|
|
find(date);
|
|
progressBar->setValue(++daysProcessed);
|
|
date=date.addDays(-1);
|
|
}
|
|
endOfPass();
|
|
return ;
|
|
};
|
|
|
|
void DailySearchTab::addItem(QDate date, QString value,Qt::Alignment alignment) {
|
|
int row = passFound;
|
|
Q_UNUSED(alignment);
|
|
setResult(DS_ROW_DATA+row,0,date,value);
|
|
setResult(DS_ROW_DATA+row,1,date,value);
|
|
}
|
|
|
|
void DailySearchTab::endOfPass() {
|
|
cmdDescList->show();
|
|
QString display;
|
|
if ((passFound >= passDisplayLimit) && (daysProcessed<daysTotal)) {
|
|
setState( waitForContinue );
|
|
} else if (daysFound>0) {
|
|
setState( endOfSeaching );
|
|
} else {
|
|
setState( noDataFound );
|
|
}
|
|
displayStatistics();
|
|
}
|
|
|
|
void DailySearchTab::hideCommand(bool showButton) {
|
|
//operationCombo->hide();
|
|
//operationCombo->clear();
|
|
operationButton->hide();
|
|
selectDouble->hide();
|
|
selectInteger->hide();
|
|
selectString->hide();
|
|
selectUnits->hide();
|
|
commandWidget->setVisible(showButton);
|
|
commandButton->setVisible(showButton);
|
|
};
|
|
|
|
void DailySearchTab::setCommandPopupEnabled(bool on) {
|
|
if (on) {
|
|
commandPopupEnabled=true;
|
|
hideCommand();
|
|
commandList->show();
|
|
} else {
|
|
commandPopupEnabled=false;
|
|
commandList->hide();
|
|
hideCommand(true/*show button*/);
|
|
}
|
|
}
|
|
|
|
void DailySearchTab::process_match_info(QString text, int topic) {
|
|
// here to select new search criteria
|
|
// must reset all variables and label, button, etc
|
|
clearMatch() ;
|
|
commandWidget->show();
|
|
match->matchName = text;
|
|
// get item selected
|
|
if (topic>=ST_EVENT) {
|
|
match->channelId = topic;
|
|
match->searchTopic = ST_EVENT;
|
|
} else {
|
|
match->searchTopic = (SearchTopic)topic;
|
|
}
|
|
|
|
match->valueMode = notUsed;
|
|
match->compareValue = 0;
|
|
|
|
// workaround for combo box alignmnet and sizing.
|
|
// copy selections to a pushbutton. hide combobox and show pushButton. Pushbutton activation can show popup.
|
|
// always hide first before show. allows for best fit
|
|
setText(commandButton, text);
|
|
setCommandPopupEnabled(false);
|
|
|
|
match->operationOpCode = OP_INVALID;
|
|
match->nextTab = TW_NONE;
|
|
match->compareString = "9999";
|
|
|
|
switch (match->searchTopic) {
|
|
case ST_NONE :
|
|
// should never get here.
|
|
setResult(DS_ROW_HEADER,1,QDate(),"");
|
|
match->nextTab = TW_NONE ;
|
|
setoperation( OP_INVALID ,notUsed);
|
|
break;
|
|
case ST_DAYS_SKIPPED :
|
|
setResult(DS_ROW_HEADER,1,QDate(),"");
|
|
// there is no graphs available in daily. or in the lefti sidebar so no jump match->nextTab = TW_DETAILED ;
|
|
setoperation(OP_NO_PARMS,notUsed);
|
|
break;
|
|
case ST_DISABLED_SESSIONS :
|
|
setResult(DS_ROW_HEADER,1,QDate(),tr("Number Disabled Session\nJumps to Date's Details "));
|
|
match->nextTab = TW_DETAILED ;
|
|
selectInteger->setValue(0);
|
|
setoperation(OP_NO_PARMS,displayWhole);
|
|
break;
|
|
case ST_JOURNAL :
|
|
setResult(DS_ROW_HEADER,1,QDate(),tr("JUmps\nJumps to Date's Notes"));
|
|
match->nextTab = TW_NOTES ;
|
|
setoperation( OP_NO_PARMS ,displayString);
|
|
break;
|
|
case ST_NOTES :
|
|
setResult(DS_ROW_HEADER,1,QDate(),tr("Note\nJumps to Date's Notes"));
|
|
match->nextTab = TW_NOTES ;
|
|
setoperation( OP_NO_PARMS ,displayString);
|
|
break;
|
|
case ST_BOOKMARKS :
|
|
setResult(DS_ROW_HEADER,1,QDate(),tr("Bookmark\nJumps to Date's Bookmark"));
|
|
match->nextTab = TW_BOOKMARK ;
|
|
setoperation( OP_NO_PARMS ,displayString);
|
|
break;
|
|
case ST_BOOKMARKS_STRING :
|
|
setResult(DS_ROW_HEADER,1,QDate(),tr("Bookmark\nJumps to Date's Bookmark"));
|
|
match->nextTab = TW_BOOKMARK ;
|
|
setoperation(OP_WILDCARD,opString);
|
|
selectString->clear();
|
|
break;
|
|
case ST_NOTES_STRING :
|
|
setResult(DS_ROW_HEADER,1,QDate(),tr("Note\nJumps to Date's Notes"));
|
|
match->nextTab = TW_NOTES ;
|
|
setoperation(OP_WILDCARD,opString);
|
|
selectString->clear();
|
|
break;
|
|
case ST_AHI :
|
|
setResult(DS_ROW_HEADER,1,QDate(),tr("AHI\nJumps to Date's Details"));
|
|
match->nextTab = TW_DETAILED ;
|
|
setoperation(OP_GT,hundredths);
|
|
setText(selectUnits,tr(" EventsPerHour"));
|
|
selectDouble->setValue(5.0);
|
|
selectDouble->setSingleStep(0.1);
|
|
break;
|
|
case ST_CLEAR :
|
|
case ST_APNEA_ALL :
|
|
break; // should never get here
|
|
case ST_APNEA_LENGTH :
|
|
DaysWithFileErrors = 0;
|
|
|
|
setResult(DS_ROW_HEADER,1,QDate(),tr("Set of Apnea:Length\nJumps to Date's Events"));
|
|
match->nextTab = TW_EVENTS ;
|
|
setoperation(OP_GE,secondsDisplayString);
|
|
|
|
selectInteger->setRange(0,999);
|
|
selectInteger->setValue(25);
|
|
setText(selectUnits,tr(" Seconds"));
|
|
break;
|
|
case ST_SESSION_LENGTH :
|
|
setResult(DS_ROW_HEADER,1,QDate(),tr("Session Duration\nJumps to Date's Details"));
|
|
match->nextTab = TW_DETAILED ;
|
|
setoperation(OP_LT,minutesToMs);
|
|
selectDouble->setValue(5.0);
|
|
setText(selectUnits,tr(" Minutes"));
|
|
selectDouble->setSingleStep(0.1);
|
|
selectInteger->setValue((int)selectDouble->value()*60000.0); //convert to ms
|
|
break;
|
|
case ST_SESSIONS_QTY :
|
|
setResult(DS_ROW_HEADER,1,QDate(),tr("Number of Sessions\nJumps to Date's Details"));
|
|
match->nextTab = TW_DETAILED ;
|
|
setoperation(OP_GT,opWhole);
|
|
selectInteger->setRange(0,999);
|
|
selectInteger->setValue(2);
|
|
setText(selectUnits,tr(" Sessions"));
|
|
break;
|
|
case ST_DAILY_USAGE :
|
|
setResult(DS_ROW_HEADER,1,QDate(),tr("Daily Duration\nJumps to Date's Details"));
|
|
match->nextTab = TW_DETAILED ;
|
|
setoperation(OP_LT,hoursToMs);
|
|
selectDouble->setValue(p_profile->cpap->complianceHours());
|
|
selectDouble->setSingleStep(0.1);
|
|
selectInteger->setValue((int)selectDouble->value()*3600000.0); //convert to ms
|
|
setText(selectUnits,tr(" Hours"));
|
|
break;
|
|
case ST_EVENT:
|
|
// Have an Event
|
|
setResult(DS_ROW_HEADER,1,QDate(),tr("Number of events\nJumps to Date's Events"));
|
|
match->nextTab = TW_EVENTS ;
|
|
setoperation(OP_GT,opWhole);
|
|
selectInteger->setValue(0);
|
|
setText(selectUnits,tr(" Events"));
|
|
break;
|
|
}
|
|
criteriaChanged();
|
|
match->opCodeStr = opCodeStr(match->operationOpCode);
|
|
QString uni = selectUnits->text();
|
|
match->units = uni;
|
|
|
|
addMatchButton->setText(tr("add another match?"));
|
|
addMatchButton->setVisible(true);
|
|
setState( waitForStart );
|
|
|
|
if (match->operationOpCode == OP_NO_PARMS ) {
|
|
// auto start searching
|
|
setState (autoStart);
|
|
//match->units = "";
|
|
//match->compareString="";
|
|
on_startButton_clicked();
|
|
return;
|
|
}
|
|
setColor(startButton,green);
|
|
setColor(addMatchButton , green);
|
|
return;
|
|
}
|
|
|
|
void DailySearchTab::on_operationButton_clicked() {
|
|
setState( waitForStart );
|
|
// only gets here for string operations
|
|
if (match->operationOpCode == OP_CONTAINS ) {
|
|
match->operationOpCode = OP_WILDCARD;
|
|
} else if (match->operationOpCode == OP_WILDCARD) {
|
|
match->operationOpCode = OP_CONTAINS ;
|
|
} else {
|
|
setOperationPopupEnabled(true);
|
|
}
|
|
QString text=opCodeStr(match->operationOpCode);
|
|
setText(operationButton,text);
|
|
criteriaChanged();
|
|
};
|
|
|
|
void DailySearchTab::on_operationCombo_activated(int index) {
|
|
// only gets here for numeric comparisions.
|
|
setState( waitForStart );
|
|
QString text = operationCombo->itemText(index);
|
|
OpCode opCode = opCodeMap[text];
|
|
match->operationOpCode = opCode;
|
|
match->opCodeStr = opCodeStr(match->operationOpCode);
|
|
setText(operationButton,match->opCodeStr);
|
|
setOperationPopupEnabled(false);
|
|
criteriaChanged();
|
|
};
|
|
|
|
void DailySearchTab::on_matchButton_clicked() {
|
|
setState (matching);
|
|
setCommandPopupEnabled(!commandPopupEnabled);
|
|
}
|
|
|
|
void DailySearchTab::on_commandButton_clicked() {
|
|
setCommandPopupEnabled(true);
|
|
}
|
|
|
|
void DailySearchTab::on_helpButton_clicked() {
|
|
helpMode = !helpMode;
|
|
if (helpMode) {
|
|
resultTable->setMinimumSize(QSize(50,200)+textsize(helpText->font(),helpString));
|
|
resultTable->setSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::MinimumExpanding);
|
|
helpButton->setText(tr("Click HERE to close Help"));
|
|
helpText ->show();
|
|
} else {
|
|
resultTable->setMinimumWidth(250);
|
|
helpText ->hide();
|
|
helpButton->setText(tr("Help"));
|
|
}
|
|
}
|
|
|
|
void DailySearchTab::on_clearButton_clicked()
|
|
{
|
|
setState( reset);
|
|
}
|
|
|
|
void DailySearchTab::setOperationPopupEnabled(bool on) {
|
|
if (on) {
|
|
operationButton->hide();
|
|
operationCombo->show();
|
|
operationCombo->showPopup();
|
|
} else {
|
|
operationCombo->hidePopup();
|
|
operationCombo->hide();
|
|
operationButton->show();
|
|
}
|
|
}
|
|
|
|
void DailySearchTab::setoperation(OpCode opCode,ValueMode mode) {
|
|
match->valueMode = mode;
|
|
match->operationOpCode = opCode;
|
|
setText(operationButton,opCodeStr(match->operationOpCode));
|
|
setOperationPopupEnabled(false);
|
|
|
|
if (opCode > OP_INVALID && opCode <OP_END_NUMERIC) {
|
|
// Have numbers
|
|
selectDouble->setDecimals(2);
|
|
selectDouble->setRange(0,999);
|
|
selectDouble->setDecimals(2);
|
|
selectInteger->setRange(0,999);
|
|
selectDouble->setSingleStep(0.1);
|
|
}
|
|
switch (match->valueMode) {
|
|
case hundredths :
|
|
selectUnits->show();
|
|
selectDouble->show();
|
|
break;
|
|
case hoursToMs:
|
|
setText(selectUnits,tr(" Hours"));
|
|
selectUnits->show();
|
|
selectDouble->show();
|
|
break;
|
|
case secondsDisplayString:
|
|
setText(selectUnits,tr(" Seconds"));
|
|
selectUnits->show();
|
|
selectInteger->show();
|
|
break;
|
|
case minutesToMs:
|
|
setText(selectUnits,tr(" Minutes"));
|
|
selectUnits->show();
|
|
selectDouble->setRange(0,9999);
|
|
selectDouble->show();
|
|
break;
|
|
case opWhole:
|
|
selectUnits->show();
|
|
selectInteger->show();
|
|
break;
|
|
case displayWhole:
|
|
selectInteger->hide();
|
|
break;
|
|
case opString:
|
|
operationButton->show();
|
|
selectString ->show();
|
|
break;
|
|
case displayString:
|
|
selectString ->hide();
|
|
break;
|
|
case invalidValueMode:
|
|
case notUsed:
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
void DailySearchTab::hideResults(bool hide) {
|
|
if (hide) {
|
|
for (int index = DS_ROW_HEADER; index<DS_ROW_MAX;index++) {
|
|
resultTable->setRowHidden(index,true);
|
|
}
|
|
}
|
|
progressBar->setMinimumHeight(matchButton->height());
|
|
//summaryWidget->setVisible(!hide);
|
|
}
|
|
|
|
QSize DailySearchTab::textsize(QFont font ,QString text) {
|
|
return QFontMetrics(font).size(0 , text);
|
|
}
|
|
|
|
void DailySearchTab::clearMatch()
|
|
{
|
|
commandWidget->hide();
|
|
DaysWithFileErrors = 0 ;
|
|
match->searchTopic = ST_NONE;
|
|
match->matchName.clear();
|
|
match->opCodeStr.clear();
|
|
match->compareString.clear();
|
|
match->units.clear();
|
|
match->foundString.clear();
|
|
match->label.clear();
|
|
|
|
// make these button text back to start.
|
|
addMatchButton->setVisible(matches.size()>1);
|
|
|
|
startButton->setText(tr("Start Search"));
|
|
startButton->setEnabled( false);
|
|
|
|
// hide widgets
|
|
//Reset Select area
|
|
commandList->hide();
|
|
setCommandPopupEnabled(false);
|
|
setText(commandButton,"");
|
|
commandButton->show();
|
|
|
|
operationCombo->hide();
|
|
setOperationPopupEnabled(false);
|
|
operationButton->hide();
|
|
selectDouble->hide();
|
|
selectInteger->hide();
|
|
selectString->hide();
|
|
selectUnits->hide();
|
|
selectUnits->clear();
|
|
|
|
}
|
|
|
|
QString Match::createMatchDescription() {
|
|
label = QString("%1 %2 %3 %4 " ).arg(matchName).arg(opCodeStr).arg(compareString).arg(units);
|
|
return label;
|
|
}
|
|
|
|
void DailySearchTab::on_addMatchButton_clicked() {
|
|
if (match->matchName.isEmpty()) { return; };
|
|
match->createMatchDescription();
|
|
QLabel* label = getCmdDescLabel();
|
|
label->setText(match->label);
|
|
label->setVisible(true);
|
|
QCoreApplication::processEvents();
|
|
|
|
Match* nmatch = matches.addMatch();
|
|
match = nmatch;
|
|
clearMatch();
|
|
setState(multpileMatches);
|
|
on_matchButton_clicked();
|
|
}
|
|
|
|
void DailySearchTab::on_startButton_clicked() {
|
|
setState( searching );
|
|
clearStatistics();
|
|
if (startButton_1stPass) {
|
|
|
|
match->createMatchDescription();
|
|
QLabel* label = getCmdDescLabel();
|
|
label->setText(match->label);
|
|
label->setVisible(true);
|
|
|
|
commandWidget->hide();
|
|
cmdDescList->show();
|
|
search (latestDate );
|
|
startButton_1stPass=false;
|
|
} else {
|
|
search (nextDate );
|
|
}
|
|
}
|
|
|
|
void DailySearchTab::on_intValueChanged(int ) {
|
|
selectInteger->findChild<QLineEdit*>()->deselect();
|
|
criteriaChanged();
|
|
}
|
|
|
|
void DailySearchTab::on_doubleValueChanged(double ) {
|
|
selectDouble->findChild<QLineEdit*>()->deselect();
|
|
criteriaChanged();
|
|
}
|
|
|
|
void DailySearchTab::on_textEdited(QString ) {
|
|
criteriaChanged();
|
|
}
|
|
|
|
void DailySearchTab::on_activated(GPushButton* item ) {
|
|
int row=item->row();
|
|
int col=item->column();
|
|
if (row<DS_ROW_DATA) return;
|
|
if (row>=DS_ROW_MAX) return;
|
|
row-=DS_ROW_DATA;
|
|
|
|
item->setIcon (*m_icon_selected);
|
|
if (match->searchTopic == ST_DAYS_SKIPPED) return;
|
|
daily->LoadDate( item->date() );
|
|
if ((col!=0) && match->nextTab>=0 && match->nextTab < dailyTabWidget->count()) {
|
|
dailyTabWidget->setCurrentIndex(match->nextTab); // 0 = details ; 1=events =2 notes ; 3=bookarks;
|
|
}
|
|
}
|
|
|
|
void DailySearchTab::clrCmdDescList() {
|
|
cmdDescLabelsUsed = 0 ;
|
|
for (int i = 0 ; i< cmdDescLabels.size(); i++) {
|
|
QLabel* label = cmdDescLabels[i];
|
|
label->setVisible(false);
|
|
label->setText("");
|
|
}
|
|
};
|
|
|
|
QLabel* DailySearchTab::getCmdDescLabel() {
|
|
quint32 size = cmdDescLabels.size();
|
|
QLabel* label ;
|
|
if (cmdDescLabelsUsed >= size ) {
|
|
QString styleLabel=QString(
|
|
"QLabel { color: black; border: 1px solid black; padding: 5px ;background-color:white; }"
|
|
"QLabel:disabled { background-color: #EEEEFF;}"
|
|
);
|
|
label = new QLabel();
|
|
cmdDescLabels.append(label);
|
|
label ->setStyleSheet( styleLabel );
|
|
label ->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Fixed);
|
|
cmdDescLayout ->addWidget(label);
|
|
}
|
|
label = cmdDescLabels[cmdDescLabelsUsed++];
|
|
label ->setVisible( true );
|
|
return label;
|
|
}
|
|
|
|
void DailySearchTab::setColor(QPushButton* button,QString color) {
|
|
QString style=QString(
|
|
"QPushButton { color: black; border: 1px solid black; padding: 5px ;background-color:%1; }").arg(color);
|
|
button->setStyleSheet(style);
|
|
QCoreApplication::processEvents();
|
|
}
|
|
|
|
void DailySearchTab::clearStatistics() {
|
|
summaryProgress->hide();
|
|
summaryFound->hide();
|
|
summaryMinMax->hide();
|
|
}
|
|
|
|
void DailySearchTab::displayStatistics() {
|
|
QString extra;
|
|
summaryProgress->show();
|
|
|
|
// display days searched
|
|
QString skip= daysSkipped==0?"":QString(tr(" Skip:%1")).arg(daysSkipped);
|
|
setText(summaryProgress,centerLine(QString(tr("%1/%2%3 days")).arg(daysProcessed).arg(daysTotal).arg(skip) ));
|
|
|
|
// display days found
|
|
setText(summaryFound,centerLine(QString(tr("Found %1 ")).arg(daysFound) ));
|
|
|
|
// display associated value
|
|
extra ="";
|
|
if (match->minMaxValid) {
|
|
if (match->valueMode == secondsDisplayString) {
|
|
extra = QString("%1 / %2").arg(match->minInteger).arg(match->maxInteger);
|
|
} else {
|
|
QString amin = match->valueToString(match->minInteger);
|
|
QString amax = match->valueToString(match->maxInteger);
|
|
extra = QString("%1 / %2").arg(amin).arg(amax);
|
|
}
|
|
}
|
|
if (extra.size()>0) {
|
|
setText(summaryMinMax,extra);
|
|
summaryMinMax->show();
|
|
} else {
|
|
if (DaysWithFileErrors) {
|
|
QString msg = tr("File errors:%1");
|
|
setText(summaryMinMax, QString(msg).arg(DaysWithFileErrors));
|
|
summaryMinMax->show();
|
|
} else {
|
|
summaryMinMax->hide();
|
|
}
|
|
}
|
|
summaryProgress->show();
|
|
summaryFound->show();
|
|
}
|
|
|
|
void DailySearchTab::criteriaChanged() {
|
|
// setup before start button
|
|
match->compareString = "";
|
|
|
|
if (match->valueMode != notUsed ) {
|
|
setText(operationButton,opCodeStr(match->operationOpCode));
|
|
operationButton->show();
|
|
}
|
|
switch (match->valueMode) {
|
|
case hundredths :
|
|
match->compareValue = (int)(selectDouble->value()*100.0); //convert to hundreths of AHI.
|
|
match->compareString = QString::number(selectDouble->value());
|
|
break;
|
|
case minutesToMs:
|
|
match->compareValue = (int)(selectDouble->value()*60000.0); //convert to ms
|
|
match->compareString = QString::number(selectDouble->value());
|
|
break;
|
|
case hoursToMs:
|
|
match->compareValue = (int)(selectDouble->value()*3600000.0); //convert to ms
|
|
match->compareString = QString::number(selectDouble->value());
|
|
break;
|
|
case secondsDisplayString:
|
|
case displayWhole:
|
|
case opWhole:
|
|
match->compareValue = selectInteger->value();
|
|
match->compareString = QString::number(selectInteger->value());
|
|
break;
|
|
case opString:
|
|
match->compareString = selectString->text();
|
|
break;
|
|
case displayString:
|
|
case invalidValueMode:
|
|
case notUsed:
|
|
break;
|
|
}
|
|
|
|
commandList->hide();
|
|
commandButton->show();
|
|
|
|
setText(startButton,tr("Start Search"));
|
|
setColor(startButton,green);
|
|
setColor(addMatchButton , green);
|
|
startButton->setEnabled( true);
|
|
|
|
|
|
match->minMaxValid = false;
|
|
match->minInteger = 0;
|
|
match->maxInteger = 0;
|
|
match->minDouble = 0.0;
|
|
match->maxDouble = 0.0;
|
|
earliestDate = p_profile->FirstDay(MT_CPAP);
|
|
latestDate = p_profile->LastDay(MT_CPAP);
|
|
daysTotal= 1+earliestDate.daysTo(latestDate);
|
|
daysFound=0;
|
|
daysSkipped=0;
|
|
daysProcessed=0;
|
|
|
|
//initialize progress bar.
|
|
|
|
progressBar->setMinimum(0);
|
|
progressBar->setMaximum(daysTotal);
|
|
progressBar->setTextVisible(true);
|
|
progressBar->setMinimumHeight(commandListItemHeight);
|
|
progressBar->setMaximumHeight(commandListItemHeight);
|
|
progressBar->reset();
|
|
}
|
|
|
|
// inputs character string.
|
|
// outputs cwa centered html string.
|
|
// converts \n to <br>
|
|
QString DailySearchTab::centerLine(QString line) {
|
|
return line;
|
|
return QString( "<center>%1</center>").arg(line).replace("\n","<br>");
|
|
}
|
|
|
|
QString DailySearchTab::helpStr()
|
|
{
|
|
QStringList str; str
|
|
<<tr("Finds days that match specified criteria.") <<"\n"
|
|
<<tr(" Searches from last day to first day.") <<"\n"
|
|
<<tr(" Skips Days with no graphing data.") <<"\n"
|
|
<<"\n"
|
|
<<tr("First click on Match Button then select topic.") <<"\n"
|
|
<<tr(" Then click on the operation to modify it.") <<"\n"
|
|
<<tr(" or update the value") <<"\n"
|
|
<<"\n"
|
|
<<tr("Topics without operations will automatically start.") <<"\n"
|
|
<<"\n"
|
|
<<tr("Compare Operations: numberic or character. ") <<"\n"
|
|
<<tr(" Numberic Operations: ") <<" > , >= , < , <= , == , != " <<"\n"
|
|
<<tr(" Character Operations: ") <<" == , *? " <<"\n"
|
|
<<"\n"
|
|
<<tr("Summary Line") <<"\n"
|
|
<<tr(" Left:Summary - Number of Day searched") <<"\n"
|
|
<<tr(" Center:Number of Items Found") <<"\n"
|
|
<<tr(" Right:Minimum/Maximum for item searched") <<"\n"
|
|
<<"\n"
|
|
<<tr("Result Table") <<"\n"
|
|
<<tr(" Column One: Date of match. Click selects date.") <<"\n"
|
|
<<tr(" Column two: Information. Click selects date.") <<"\n"
|
|
<<tr(" Then Jumps the appropiate tab.") <<"\n"
|
|
<<"\n"
|
|
<<tr("Wildcard Pattern Matching:") <<" *? " <<"\n"
|
|
<<tr(" Wildcards use 3 characters:") <<"\n"
|
|
<<tr(" Asterisk") <<" * " <<" "
|
|
<<tr(" Question Mark") <<" ? " <<" "
|
|
<<tr(" Backslash.") <<" \\ " <<"\n"
|
|
<<tr(" Asterisk matches any number of characters.") <<"\n"
|
|
<<tr(" Question Mark matches a single character.") <<"\n"
|
|
<<tr(" Backslash matches next character.") <<"\n\n"
|
|
;
|
|
return str.join("");
|
|
}
|
|
|
|
QString Match::formatTime (qint32 ms) {
|
|
qint32 hours = ms / 3600000;
|
|
ms = ms % 3600000;
|
|
qint32 minutes = ms / 60000;
|
|
ms = ms % 60000;
|
|
qint32 seconds = ms /1000;
|
|
return QString("%1:%2:%3").arg(hours).arg(minutes,2,10,QLatin1Char('0')).arg(seconds,2,10,QLatin1Char('0'));
|
|
}
|
|
|
|
QString DailySearchTab::opCodeStr(OpCode opCode) {
|
|
switch (opCode) {
|
|
case OP_LT : return "< ";
|
|
case OP_GT : return "> ";
|
|
case OP_GE : return ">=";
|
|
case OP_LE : return "<=";
|
|
case OP_EQ : return "==";
|
|
case OP_NE : return "!=";
|
|
case OP_CONTAINS : return "==";
|
|
case OP_WILDCARD : return "*?";
|
|
case OP_INVALID:
|
|
case OP_END_NUMERIC:
|
|
case OP_NO_PARMS : // return tr("Automatic Starting");
|
|
break;
|
|
}
|
|
return QString();
|
|
};
|
|
|
|
EventDataType DailySearchTab::calculateAhi(Day* day) {
|
|
if (!day) return 0.0;
|
|
// copied from daily.cpp
|
|
double hours=day->hours(MT_CPAP);
|
|
if (hours<=0) return 0;
|
|
EventDataType ahi=day->count(AllAhiChannels);
|
|
if (p_profile->general->calculateRDI()) ahi+=day->count(CPAP_RERA);
|
|
ahi/=hours;
|
|
return ahi;
|
|
}
|
|
|
|
GPushButton::GPushButton (int row,int column,QDate date,DailySearchTab* parent , ChannelID code, quint32 offset) :
|
|
QPushButton(parent), _parent(parent), _row(row), _column(column), _date(date), _code(code) , _offset(offset)
|
|
{
|
|
connect(this, SIGNAL(clicked()), this, SLOT(on_clicked()));
|
|
connect(this, SIGNAL(activated(GPushButton*)), _parent, SLOT(on_activated(GPushButton*)));
|
|
};
|
|
|
|
GPushButton::~GPushButton()
|
|
{
|
|
//the following disconnects trigger a crash during exit or profile change. - anytime daily is destroyed.
|
|
//disconnect(this, SIGNAL(clicked()), this, SLOT(on_clicked()));
|
|
//disconnect(this, SIGNAL(activated(GPushButton*)), _parent, SLOT(on_activated(GPushButton*)));
|
|
};
|
|
|
|
void GPushButton::on_clicked() {
|
|
emit activated(this);
|
|
};
|
|
|
|
Match* Matches::empty() {return &_empty;};
|
|
|
|
Matches::Matches() {
|
|
inuse = 0;
|
|
matchList.clear();
|
|
}
|
|
|
|
Matches::~Matches() {
|
|
clear();
|
|
while ( !matchList.isEmpty() ) {
|
|
Match* next = matchList.takeLast();
|
|
delete next;
|
|
}
|
|
}
|
|
|
|
void Matches::clear() {
|
|
for (int idx=0; idx < matchList.size(); idx++) {
|
|
Match* next = matchList.at(idx);
|
|
next->label = "";
|
|
}
|
|
inuse = 0;
|
|
}
|
|
|
|
Match* Matches::addMatch() {
|
|
if (inuse >= matchList.size()) {
|
|
Match* match = new Match(true);
|
|
matchList.push_back(match);
|
|
}
|
|
if (inuse<matchList.size()) {
|
|
Match* next = matchList.at(inuse);
|
|
next->label = next->createMatchDescription();
|
|
inuse ++;
|
|
return next;
|
|
}
|
|
return empty();
|
|
}
|
|
|