chris/OSCAR-code
1
0
Fork 0
mirror of https://gitlab.com/pholy/OSCAR-code.git synced 2025-04-05 10:40:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Basic right/left click mouse zoom stuff

Browse Source
This commit is contained in:
Mark Watkins 2011-08-25 18:02:04 +10:00
parent acfcb664e1
commit d4f58730fe
12 changed files with 86 additions and 776 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
Graphs/gGraphView.cpp
View File

@ -159,6 +159,7 @@ gGraph::gGraph(gGraphView *graphview,QString title,int height) :
m_marginbottom=10;
m_marginleft=5;
m_marginright=10;
m_blockzoom=false;
}
gGraph::~gGraph()
{
@ -174,7 +175,6 @@ bool gGraph::isEmpty()
}
return empty;
}
void gGraph::invalidate()
{ // this may not be necessary, as scrollbar & resize issues a full redraw..
@ -345,46 +345,102 @@ void gGraph::mousePressEvent(QMouseEvent * event)
qDebug() << m_title << "Clicked" << x << y << left << right << top << bottom << m_width << m_height;
}
}
void gGraph::mouseReleaseEvent(QMouseEvent * event)
{
int y=event->pos().y();
int x=event->pos().x();
int w=m_width-(m_graphview->titleWidth+m_marginleft+left+right+m_marginright);
int h=m_height-(bottom+m_marginbottom);
int x2,y2;
int x2=m_graphview->pointClicked().x(),y2=m_graphview->pointClicked().y();
double xx=max_x-min_x;
double xmult=xx/double(w);
if (x>left+m_marginleft && x<w+m_marginleft+left && y>top+m_margintop && y<h) { // main area
if (event->button() & Qt::RightButton) {
ZoomX(2,x);
// zoom out.
} else if (event->button() & Qt::LeftButton) {
if (abs(x-x2)<4) {
ZoomX(0.5,x);
} else {
x-=left+m_marginleft;
y-=top+m_margintop;
x2=m_graphview->pointClicked().x()-left-m_marginleft;
y2=m_graphview->pointClicked().y()-top-m_margintop;
x2-=left+m_marginleft;
y2-=top+m_margintop;
qint64 j1=min_x+xmult*x;
qint64 j2=min_x+xmult*x2;
qint64 a1=MIN(j1,j2)
qint64 a2=MAX(j1,j2)
m_graphview->SetXBounds(a1,a2);
qDebug() << m_title << "Released" << min_x << max_x << j1 << j2 << x << y << x2 << y2 << left << right << top << bottom << m_width << m_height;
}
}
qDebug() << m_title << "Released" << min_x << max_x << x << y << x2 << y2 << left << right << top << bottom << m_width << m_height;
// qDebug() << m_title << "Released" << event->pos() << m_graphview->pointClicked() << left << top;
}
}
void gGraph::mouseWheelEvent(QMouseEvent * event)
{
qDebug() << m_title << "Wheel" << event->x() << event->y();
}
void gGraph::mouseDoubleClickEvent(QMouseEvent * event)
{
// qDebug() << m_title << "Double Clicked" << event->x() << event->y();
mousePressEvent(event);
qDebug() << m_title << "Double Clicked" << event->x() << event->y();
}
void gGraph::keyPressEvent(QKeyEvent * event)
{
qDebug() << m_title << "Key Pressed" << event->key();
}
void gGraph::ZoomX(double mult,int origin_px)
{
int width=m_width-(m_graphview->titleWidth+m_marginleft+left+right+m_marginright);
if (origin_px==0) origin_px=(width/2); else origin_px-=m_marginleft+left;
if (origin_px<0) origin_px=0;
if (origin_px>width) origin_px=width;
// Okay, I want it to zoom in centered on the mouse click area..
// Find X graph position of mouse click
// find current zoom width
// apply zoom
// center on point found in step 1.
qint64 min=min_x;
qint64 max=max_x;
double hardspan=rmax_x-rmin_x;
double span=max-min;
double ww=double(origin_px) / double(width);
double origin=ww * span;
//double center=0.5*span;
//double dist=(origin-center);
double q=span*mult;
if (q>hardspan) q=hardspan;
if (q<hardspan/400.0) q=hardspan/400.0;
min=min+origin-(q*ww);
max=min+q;
if (min<rmin_x) {
min=rmin_x;
max=min+q;
}
if (max>rmax_x) {
max=rmax_x;
min=max-q;
}
m_graphview->SetXBounds(min,max);
//updateSelectionTime(max-min);
}
// margin recalcs..
void gGraph::resize(int width, int height)
{

2
Graphs/gGraphView.h
View File

@ -160,6 +160,8 @@ protected:
virtual void mouseDoubleClickEvent(QMouseEvent * event);
virtual void keyPressEvent(QKeyEvent * event);
void ZoomX(double mult,int origin_px);
gGraphView * m_graphview;
QString m_title;
QVector<Layer *> m_layers;

2
Graphs/gLineChart.cpp
View File

@ -307,7 +307,7 @@ void gLineChart::paint(gGraph & w,int left, int top, int width, int height)
}
// Plot compressed accelerated vertex list
if (maxz>width) {
qDebug() << "gLineChart::Plot() maxz exceeded graph width" << "maxz = " << maxz << "width =" << width;
//qDebug() << "gLineChart::Plot() maxz exceeded graph width" << "maxz = " << maxz << "width =" << width;
maxz=width;
}
float ax1,ay1;

2
Graphs/gSplitter.cpp
View File

@ -1,3 +1,5 @@
// This can die.
#include "gSplitter.h"
#include "graphwindow.h"
#include <QDebug>

2
Graphs/gTitle.cpp
View File

@ -1,3 +1,5 @@
// This can die. titles are now handled by gGraphView.
/*
gTitle (Graph Title) Implementation
Copyright (c)2011 Mark Watkins <jedimark@users.sourceforge.net>

7
Graphs/gYAxis.cpp
View File

@ -1,15 +1,14 @@
/********************************************************************
/*
gYAxis Implementation
Copyright (c)2011 Mark Watkins <jedimark@users.sourceforge.net>
License: GPL
*********************************************************************/
*/
#include <math.h>
#include <QDebug>
#include "gYAxis.h"
gYSpacer::gYSpacer(int spacer)
:Layer(EmptyChannel)
gYSpacer::gYSpacer(int spacer) :Layer(EmptyChannel)
{
};

102
Graphs/graphdata.cpp
View File

@ -1,102 +0,0 @@
/********************************************************************
gGraphData Implementation
Copyright (c)2011 Mark Watkins <jedimark@users.sourceforge.net>
License: GPL
*********************************************************************/
//#include "graphdata.h"
/*
gGraphData::gGraphData(int mp,gDataType t)
:vc(0),type(t),max_points(mp)
{
m_ready=false;
force_min_y=force_max_y=0;
}
gGraphData::~gGraphData()
{
}
void gGraphData::Update(Day *day)
{
Reload(day);
for (QList<gLayer *>::iterator i=notify_layers.begin();i!=notify_layers.end();i++) {
gGraphData *g=this;
if (!day) g=NULL;
(*i)->DataChanged(g);
}
}
void gGraphData::AddLayer(gLayer *g)
{
notify_layers.push_back(g);
}
bool gGraphData::isEmpty()
{
bool b=((vc==1) && (np[0]==0)) || vc==0;
return b;
}
gPointData::gPointData(int mp)
:gGraphData(mp,gDT_Point)
{
}
gPointData::~gPointData()
{
for (QVector<QPointD *>::iterator i=point.begin();i!=point.end();i++)
delete [] (*i);
}
void gPointData::AddSegment(int max_points)
{
maxsize.push_back(max_points);
np.push_back(0);
QPointD *p=new QPointD [max_points];
point.push_back(p);
}
double gPointData::CalcAverage()
{
double x,val=0;
int cnt=0;
for (int i=0;i<np[0];i++) {
x=point[0][i].x();
if ((x<min_x) || (x>max_x)) continue;
val+=point[0][i].y();
cnt++;
}
if (!cnt) return 0;
val/=cnt;
return val;
}
double gPointData::CalcMinY()
{
double x,val=0;
double min;
bool first=true;
for (int i=0;i<np[0];i++) {
x=point[0][i].x();
if ((x<min_x) || (x>max_x)) continue;
val=point[0][i].y();
if (first) {
min=val;
first=false;
} else
if (min>val) min=val;
}
return min;
}
double gPointData::CalcMaxY()
{
double x,val=0;
double max;
bool first=true;
for (int i=0;i<np[0];i++) {
x=point[0][i].x();
if ((x<min_x) || (x>max_x)) continue;
val=point[0][i].y();
if (first) {
max=val;
first=false;
} else
if (max<val) max=val;
}
return max;
}
*/

652
Graphs/graphdata_custom.cpp
View File

@ -1,652 +0,0 @@
/********************************************************************
Custom graph data Implementations
Copyright (c)2011 Mark Watkins <jedimark@users.sourceforge.net>
License: GPL
*********************************************************************/
//#include <cmath>
//#include <QDebug>
//#include "graphdata_custom.h"
/*
WaveData::WaveData(ChannelID _code, int _size)
:gPointData(_size),code(_code)
{
}
WaveData::~WaveData()
{
}
void WaveData::Reload(Day *day)
{
vc=0;
if (!day) {
m_ready=false;
return;
}
min_x=day->first()/86400000.0;
max_x=day->last()/86400000.0;
if (max_x<min_x) {
min_y=max_y=0;
m_ready=false;
return;
}
max_y=0;
bool first=true;
// int chunk=0;
for (QVector<Session *>::iterator s=day->begin();s!=day->end(); s++) {
//qDebug() << "Processing waveform chunk " << chunk++;
if ((*s)->waveforms.find(code)==(*s)->waveforms.end()) continue;
for (QVector<Waveform *>::iterator l=(*s)->waveforms[code].begin();l!=(*s)->waveforms[code].end();l++) {
int ps=point.size();
if (vc>=ps) {
AddSegment(max_points); // TODO: Add size limit capabilities.
}
int t=0;
Waveform *w=(*l);
double st=w->start()/86400000.0;
double rate=double(w->duration())/w->samples()/86400000.0;
//qDebug() << "Waveform Chunk contains " << w->samples() << " samples";
for (int i=0;i<w->samples();i++) {
QPointD r(st,(*w)[i]);
st+=rate;
(point[vc][t++])=r;
if (t>=max_points) {
qWarning()<< "WaveData max_points exceeded";
break;
}
//assert(t<max_points);
if (first) {
max_y=min_y=r.y();
first=false;
} else {
if (r.y()<min_y) min_y=r.y();
if (r.y()>max_y) max_y=r.y();
}
}
np[vc]=t;
vc++;
}
}
min_y=floor(min_y);
max_y=ceil(max_y);
//double t1=MAX(fabs(min_y),fabs(max_y));
// Get clever here..
if (min_y<0) {
if (max_y>128) {
double j=MAX(max_y,fabs(min_y));
min_y=-j;
max_y=j;
} else if (max_y>90) {
max_y=120;
min_y=-120;
} else if (max_y>60) {
min_y=-90;
max_y=90;
} else {
min_y=-60;
max_y=60;
}
}
if (force_min_y!=force_max_y) {
min_y=force_min_y;
max_y=force_max_y;
}
real_min_x=min_x;
real_min_y=min_y;
real_max_x=max_x;
real_max_y=max_y;
m_ready=true;
//graph->Refresh(false);
}
EventData::EventData(ChannelID _code,int _field,int _size,bool _skipzero)
:gPointData(_size),code(_code),field(_field),skipzero(_skipzero)
{
}
EventData::~EventData()
{
}
void EventData::Reload(Day *day)
{
vc=0;
if (!day) {
m_ready=false;
return;
}
min_x=day->first()/86400000.0;
max_x=day->last()/86400000.0;
if (min_x>max_x) {
qWarning() << "EventData min_x > max_x";
return;
}
min_y=max_y=0;
int tt=0;
bool first=true;
EventDataType lastp=0;
for (QVector<Session *>::iterator s=day->begin();s!=day->end(); s++) {
if ((*s)->events.find(code)==(*s)->events.end()) continue;
if (vc>=(int)point.size()) {
AddSegment(max_points);
}
int t=0;
EventDataType p;
for (QVector<Event *>::iterator ev=(*s)->events[code].begin(); ev!=(*s)->events[code].end(); ev++) {
p=(*(*ev))[field];
if (((p!=0) && skipzero) || !skipzero) {
QPointD r((*ev)->time()/86400000.0,p);
point[vc][t++]=r;
if (t>=max_points) {
qWarning() << "EventData max_points exceeded";
break;
}
if (first) {
max_y=min_y=r.y();
//lastp=p;
first=false;
} else {
if (r.y()<min_y) min_y=r.y();
if (r.y()>max_y) max_y=r.y();
}
} else {
if ((p!=lastp) && (t>0)) { // There really should not be consecutive zeros.. just in case..
np[vc]=t;
tt+=t;
t=0;
vc++;
if (vc>=(int)point.size()) {
AddSegment(max_points);
}
}
}
lastp=p;
}
np[vc]=t;
if (t>0) {
tt+=t;
vc++;
}
}
if (tt>0) {
min_y=floor(min_y);
max_y=ceil(max_y+1);
if (min_y>1) min_y-=1;
}
if (force_min_y!=force_max_y) {
min_y=force_min_y;
max_y=force_max_y;
}
real_min_x=min_x;
real_min_y=min_y;
real_max_x=max_x;
real_max_y=max_y;
m_ready=true;
}
TAPData::TAPData(ChannelID _code)
:gPointData(256),code(_code)
{
AddSegment(max_points);
}
TAPData::~TAPData()
{
}
void TAPData::Reload(Day *day)
{
if (!day) {
m_ready=false;
return;
}
for (int i=0;i<max_slots;i++) pTime[i]=0;
int cnt=0;
bool first;
qint64 last;
int lastval=0,val;
int field=0;
for (QVector<Session *>::iterator s=day->begin();s!=day->end();s++) {
if ((*s)->events.find(code)==(*s)->events.end()) continue;
first=true;
for (QVector<Event *>::iterator e=(*s)->events[code].begin(); e!=(*s)->events[code].end(); e++) {
Event & ev =(*(*e));
val=ev[field]*10.0;
if (field>=ev.fields()) {
qWarning() << "Invalid Event field in TAPData::Reload";
return;
}
//if (field > ev.fields()) throw BoundsError();
if (first) {
first=false; // only bother setting lastval (below) this time.
} else {
double d=(ev.time()-last)/1000.0;
if (lastval>=max_slots) {
qWarning() << "TapData: lastval<max_slots";
break;
}
pTime[lastval]+=d;
}
cnt++;
last=ev.time();
lastval=val;
}
}
double TotalTime;
for (int i=0; i<max_slots; i++) {
TotalTime+=pTime[i];
}
int jj=0;
for (int i=0; i<max_slots; i++) {
if (pTime[i]>0) {
point[0][jj].setX(i/10.0);
point[0][jj].setY((100.0/TotalTime)*pTime[i]);
jj++;
}
}
np[0]=jj;
//graph->Refresh();
m_ready=true;
}
AHIData::AHIData()
:gPointData(256)
{
AddSegment(max_points);
}
AHIData::~AHIData()
{
}
void AHIData::Reload(Day *day)
{
if (!day) {
m_ready=false;
return;
}
point[0][0].setY(day->count(CPAP_Hypopnea)/day->hours());
point[0][0].setX(point[0][0].y());
point[0][1].setY(day->count(CPAP_Obstructive)/day->hours());
point[0][1].setX(point[0][1].y());
point[0][2].setY(day->count(CPAP_ClearAirway)/day->hours());
point[0][2].setX(point[0][2].y());
point[0][3].setY(day->count(CPAP_RERA)/day->hours());
point[0][3].setX(point[0][3].y());
point[0][4].setY(day->count(CPAP_FlowLimit)/day->hours());
point[0][4].setX(point[0][4].y());
//point[0][5].setY((100.0/day->hours())*(day->sum(CPAP_CSR)/3600.0));
//point[0][5].setX(point[0][5].y());
np[0]=5;
m_ready=true;
//REFRESH??
}
FlagData::FlagData(ChannelID _code,int _field,int _offset)
:gPointData(65536),code(_code),field(_field),offset(_offset)
{
AddSegment(max_points);
}
FlagData::~FlagData()
{
}
void FlagData::Reload(Day *day)
{
if (!day) {
m_ready=false;
return;
}
int c=0;
vc=0;
double v1,v2;
//bool first;
min_x=day->first()/86400000.0;
max_x=day->last()/86400000.0;
bool done=false;
for (QVector<Session *>::iterator s=day->begin();s!=day->end();s++) {
if ((*s)->events.find(code)==(*s)->events.end()) continue;
//first=true;
for (QVector<Event *>::iterator e=(*s)->events[code].begin(); e!=(*s)->events[code].end(); e++) {
Event & ev =(*(*e));
v2=v1=ev.time()/86400000.0;
if (offset>=0)
v1-=ev[offset]/86400.0;
point[vc][c].setX(v1);
point[vc][c].setY(v2);
v1=point[vc][c].x();
v2=point[vc][c].y();
c++;
if (c>=max_points) {
qWarning() << "FlagData: max_points exceeded";
done=true;
break;
}
if (first) {
min_y=v1;
first=false;
} else {
if (v1<min_x) min_x=v1;
}
if (v2>max_x) max_x=v2;
}
if (done) break;
}
min_y=0;//-value;
max_y=1;//value;
np[vc]=c;
vc++;
real_min_x=min_x;
real_min_y=min_y;
real_max_x=max_x;
real_max_y=max_y;
m_ready=true;
}
////////////////////////////////////////////////////////////////////////////////////////////
// Session Times Implementation
////////////////////////////////////////////////////////////////////////////////////////////
SessionTimes::SessionTimes(Profile * _profile)
:HistoryData(_profile,2048)
{
//AddSegment(max_points);
//if (profile->LastDay().isValid()) {
// QDateTime tmp;
// tmp.setDate(profile->FirstDay());
// real_min_x=tmp.toMSecsSinceEpoch()/86400000.0;
// tmp.setDate(profile->LastDay());
// real_max_x=(tmp.toMSecsSinceEpoch()/86400000.0)+1;
//}
//real_min_y=real_max_y=0;
}
SessionTimes::~SessionTimes()
{
}
void SessionTimes::ResetDateRange()
{
if (profile->LastDay().isValid()) {
QDateTime tmp;
tmp.setDate(profile->FirstDay());
real_min_x=tmp.toMSecsSinceEpoch()/86400000.0;
tmp.setDate(profile->LastDay());
real_max_x=(tmp.toMSecsSinceEpoch()/86400000.0)+1;
}
}
double SessionTimes::GetAverage()
{
double x,val=0;
int cnt=0;
for (int i=0;i<np[0];i++) {
x=point[0][i].x();
if ((x<min_x) || (x>max_x)) continue;
val+=point[0][i].y()-point[0][i].x();
cnt++;
}
if (!cnt) return 0;
val/=cnt;
return val;
}
void SessionTimes::SetDateRange(QDate start,QDate end)
{
qint64 x1=QDateTime(start).toMSecsSinceEpoch()/86400000.0;
qint64 x2=QDateTime(end.addDays(1)).toMSecsSinceEpoch()/86400000.0;
if (x1 < real_min_x) x1=real_min_x;
if (x2 > (real_max_x)) x2=(real_max_x);
min_x=x1;
max_x=x2;
for (QList<gLayer *>::iterator i=notify_layers.begin();i!=notify_layers.end();i++) {
(*i)->DataChanged(this);
} // Do nothing else.. Callers responsibility to Refresh window.
}
void SessionTimes::Reload(Day *day)
{
day=day; //shuttup warnings.. we don't use this.
QDateTime date;
vc=0;
bool done=false;
double st,et;
min_y=max_y=0;
min_x=max_x=0;
if (real_min_x<0) return;
if (real_max_x<0) return;
int i=0;
for (double x=floor(real_min_x);x<=ceil(real_max_x);x++) {
date=QDateTime::fromMSecsSinceEpoch(x*86400000.0L); // Ouch.. QDateTime conversions are slow as hell..
// date.setTime(QTime(0,0,0));
//if (profile->daylist.find(date.date())==profile->daylist.end()) continue;
Day *dy=profile->GetDay(date.date(),MT_CPAP);
if (!dy) continue;
//QVector<Day *> & daylist=profile->daylist[date.date()];
for (QVector<Session *>::iterator dd=dy->begin(); dd!=dy->end(); dd++) { // average any multiple data sets
st=double((*dd)->first())/86400000.0;
et=double((*dd)->last())/86400000.0;
point[vc][i].setX(st);
point[vc][i].setY(et);
i++;
if (i>max_points) {
qWarning("max_points is not enough in HistoryData");
done=true;
break;
}
}
if (done)
break;
}
np[vc]=i;
vc++;
min_x=real_min_x;
max_x=real_max_x;
if (force_min_y!=force_max_y) {
min_y=force_min_y;
max_y=force_max_y;
} else {
min_y=-12;
max_y=+12;
}
real_min_y=min_y;
real_max_y=max_y;
m_ready=true;
}
////////////////////////////////////////////////////////////////////////////////////////////
// HistoryData Implementation
////////////////////////////////////////////////////////////////////////////////////////////
HistoryData::HistoryData(Profile * _profile,int mpts)
:gPointData(mpts),profile(_profile)
{
AddSegment(max_points);
if (profile->LastDay().isValid()) {
QDateTime tmp;
tmp.setDate(profile->FirstDay());
real_min_x=tmp.toMSecsSinceEpoch()/86400000.0;
tmp.setDate(profile->LastDay());
real_max_x=(tmp.toMSecsSinceEpoch()/86400000.0)+1;
}
real_min_y=real_max_y=0;
}
HistoryData::~HistoryData()
{
}
void HistoryData::ResetDateRange()
{
if (profile->LastDay().isValid()) {
QDateTime tmp;
tmp.setDate(profile->FirstDay());
real_min_x=tmp.toMSecsSinceEpoch()/86400000.0;
tmp.setDate(profile->LastDay());
real_max_x=(tmp.toMSecsSinceEpoch()/86400000.0)+1;
}
// Reload(NULL);
}
double HistoryData::Calc(Day *day)
{
double h=day->hours();
double ahi=(day->summary_sum(CPAP_Obstructive) + day->summary_sum(CPAP_Hypopnea) + day->summary_sum(CPAP_ClearAirway)) / h;
if (ahi>1000) {
ahi=999;
}
return ahi;
}
void HistoryData::Reload(Day *day)
{
day=day; //shuttup warnings..
QDateTime date;
vc=0;
int i=0;
bool first=true;
bool done=false;
double y,lasty;
min_y=max_y=0;
min_x=max_x=0;
if (real_min_x<0) return;
if (real_max_x<0) return;
for (double x=floor(real_min_x);x<=ceil(real_max_x);x++) {
date=QDateTime::fromMSecsSinceEpoch(x*86400000.0L);
date.setTime(QTime(0,0,0));
if (profile->daylist.find(date.date())==profile->daylist.end()) continue;
y=0;
int z=0;
QVector<Day *> & daylist=profile->daylist[date.date()];
for (QVector<Day *>::iterator dd=daylist.begin(); dd!=daylist.end(); dd++) { // average any multiple data sets
Day *d=(*dd);
if (d->machine_type()==MT_CPAP) {
y+=Calc(d);
z++;
}
}
if (!z)
continue;
if (z>1)
y /= z;
if (first) {
// max_x=min_x=x;
lasty=max_y=min_y=y;
first=false;
}
point[vc][i].setX(x);
point[vc][i].setY(y);
if (y>max_y) max_y=y;
if (y<min_y) min_y=y;
//if (x<min_x) min_x=x;
//if (x>max_x) max_x=x;
i++;
if (i>max_points) {
qWarning("max_points is not enough in HistoryData");
done=true;
}
if (done) break;
lasty=y;
}
np[vc]=i;
vc++;
min_x=real_min_x;
max_x=real_max_x;
// max_x+=1;
//real_min_x=min_x;
//real_max_x=max_x;
if (force_min_y!=force_max_y) {
min_y=force_min_y;
max_y=force_max_y;
} else {
if (!((min_y==max_y) && (min_y==0))) {
if (min_y>1) min_y-=1;
max_y++;
}
}
// assert(max_y<10000000);
real_min_y=min_y;
real_max_y=max_y;
m_ready=true;
}
void HistoryData::SetDateRange(QDate start,QDate end)
{
qint64 x1=QDateTime(start).toMSecsSinceEpoch()/86400000.0;
qint64 x2=QDateTime(end.addDays(1)).toMSecsSinceEpoch()/86400000.0;
if (x1 < real_min_x) x1=real_min_x;
if (x2 > (real_max_x)) x2=(real_max_x);
min_x=x1;
max_x=x2;
for (QList<gLayer *>::iterator i=notify_layers.begin();i!=notify_layers.end();i++) {
(*i)->DataChanged(this);
} // Do nothing else.. Callers responsibility to Refresh window.
}
HistoryCodeData::HistoryCodeData(Profile *_profile,ChannelID _code)
:HistoryData(_profile),code(_code)
{
}
HistoryCodeData::~HistoryCodeData()
{
}
double HistoryCodeData::Calc(Day *day)
{
return day->summary_avg(code);
}
UsageHistoryData::UsageHistoryData(Profile *_profile,T_UHD _uhd)
:HistoryData(_profile),uhd(_uhd)
{
}
UsageHistoryData::~UsageHistoryData()
{
}
double UsageHistoryData::Calc(Day *day)
{
qint64 d;
double h;
if (uhd==UHD_Bedtime) {
d=day->first()/1000;
d%=86400;
h=d/3600;
if (h<12) h+=24;
h+=1.0/float(d%3600);
//d+=(day->first().time().minute()/60.0);
//d+=(day->first().time().second()/3600.0);
return h;
}
else if (uhd==UHD_Waketime) {
d=day->first()/1000;
d%=86400;
h=d/3600;
h+=1.0/float(d%3600);
//d=day->last().time().hour();
//d+=(day->last().time().minute()/60.0);
//d+=(day->last().time().second()/3600.0);
return h;
}
else if (uhd==UHD_Hours) {
return day->hours();
} else
return 0;
}
*/

2
Graphs/graphlayer.cpp
View File

@ -1,3 +1,5 @@
// This file is Scheduled for destruction..
/*
gLayer Implementation
Copyright (c)2011 Mark Watkins <jedimark@users.sourceforge.net>

6
Graphs/graphwindow.cpp
View File

@ -1,8 +1,10 @@
/********************************************************************
// This file is Scheduled for destruction..
/*
gGraphWindow Implementation
Copyright (c)2011 Mark Watkins <jedimark@users.sourceforge.net>
License: GPL
*********************************************************************/
*/
#include <math.h>
#include <QDebug>

2
SleepyHeadQT.pro
View File

@ -42,8 +42,6 @@ SOURCES += main.cpp\
SleepLib/day.cpp \
Graphs/graphwindow.cpp \
Graphs/graphlayer.cpp \
Graphs/graphdata.cpp \
Graphs/graphdata_custom.cpp \
Graphs/gLineChart.cpp \
Graphs/gLineOverlay.cpp \
Graphs/gFooBar.cpp \

1
daily.cpp
View File

@ -86,6 +86,7 @@ Daily::Daily(QWidget *parent,QGLWidget * shared, MainWindow *mw)
fg->AddLayer((new gFlagsLine(CPAP_VSnore,QColor("red"),"VS")));
//fg->AddLayer(AddCPAP(new gFlagsLine(flags[8],QColor("dark green"),"U0E")));
//fg->AddLayer(AddCPAP(new gFlagsLine(flags[10],QColor("red"),"VS2"));
SF->setBlockZoom(true);
SF->AddLayer(AddCPAP(fg));
SF->AddLayer(new gYSpacer(),LayerLeft,gYAxis::Margin);
SF->AddLayer(new gXAxis(),LayerBottom,0,gXAxis::Margin);