diff --git a/sleepyhead/SleepLib/calcs.cpp b/sleepyhead/SleepLib/calcs.cpp
index f8a5fd2a..5041787d 100644
--- a/sleepyhead/SleepLib/calcs.cpp
+++ b/sleepyhead/SleepLib/calcs.cpp
@@ -23,16 +23,23 @@ extern double round(double number);
 
 bool SearchApnea(Session *session, qint64 time, qint64 dist)
 {
-    if (session->SearchEvent(CPAP_Obstructive,time,dist)) return true;
-    if (session->SearchEvent(CPAP_Apnea,time,dist)) return true;
-    if (session->SearchEvent(CPAP_ClearAirway,time,dist)) return true;
-    if (session->SearchEvent(CPAP_Hypopnea,time,dist)) return true;
+    if (session->SearchEvent(CPAP_Obstructive, time, dist))
+        return true;
+
+    if (session->SearchEvent(CPAP_Apnea, time, dist))
+        return true;
+
+    if (session->SearchEvent(CPAP_ClearAirway, time, dist))
+        return true;
+
+    if (session->SearchEvent(CPAP_Hypopnea, time, dist))
+        return true;
 
     return false;
 }
 
 // Sort BreathPeak by peak index
-bool operator<(const BreathPeak & p1, const BreathPeak & p2)
+bool operator<(const BreathPeak &p1, const BreathPeak &p2)
 {
     return p1.start < p2.start;
 }
@@ -41,164 +48,179 @@ bool operator<(const BreathPeak & p1, const BreathPeak & p2)
 //! \param samples Number of samples
 //! \param width number of surrounding samples to consider
 //! \param percentile fractional percentage, between 0 and 1
-void percentileFilter(EventDataType * input, EventDataType * output, int samples, int width, EventDataType percentile)
+void percentileFilter(EventDataType *input, EventDataType *output, int samples, int width,
+                      EventDataType percentile)
 {
-    if (samples<=0)
+    if (samples <= 0) {
         return;
+    }
 
-    if (percentile>1)
-        percentile=1;
+    if (percentile > 1) {
+        percentile = 1;
+    }
 
     QVector<EventDataType> buf(width);
-    int s,e;
-    int z1=width/2;
-    int z2=z1+(width % 2);
-    int nm1=samples-1;
+    int s, e;
+    int z1 = width / 2;
+    int z2 = z1 + (width % 2);
+    int nm1 = samples - 1;
     //int j;
 
     // Scan through all of input
-    for (int k=0;k < samples;k++) {
+    for (int k = 0; k < samples; k++) {
 
-        s=k-z1;
-        e=k+z2;
+        s = k - z1;
+        e = k + z2;
 
         // Cap bounds
-        if (s < 0) s=0;
-        if (e > nm1) e=nm1;
+        if (s < 0) { s = 0; }
+
+        if (e > nm1) { e = nm1; }
 
         //
-        int j=0;
-        for (int i=s; i < e; i++) {
-            buf[j++]=input[i];
+        int j = 0;
+
+        for (int i = s; i < e; i++) {
+            buf[j++] = input[i];
         }
+
         j--;
 
-        EventDataType val=j * percentile;
-        EventDataType fl=floor(val);
+        EventDataType val = j * percentile;
+        EventDataType fl = floor(val);
 
         // If even percentile, or already max value..
-        if ((val==fl) || (j>=width-1)) {
-            nth_element(buf.begin(),buf.begin()+j,buf.begin()+width-1);
-            val=buf[j];
+        if ((val == fl) || (j >= width - 1)) {
+            nth_element(buf.begin(), buf.begin() + j, buf.begin() + width - 1);
+            val = buf[j];
         } else {
             // Percentile lies between two points, interpolate.
-            double v1,v2;
-            nth_element(buf.begin(),buf.begin()+j,buf.begin()+width-1);
-            v1=buf[j];
-            nth_element(buf.begin(),buf.begin()+j+1,buf.begin()+width-1);
-            v2=buf[j+1];
+            double v1, v2;
+            nth_element(buf.begin(), buf.begin() + j, buf.begin() + width - 1);
+            v1 = buf[j];
+            nth_element(buf.begin(), buf.begin() + j + 1, buf.begin() + width - 1);
+            v2 = buf[j + 1];
 
-            val = v1 + (v2-v1)*(val-fl);
+            val = v1 + (v2 - v1) * (val - fl);
         }
-        output[k]=val;
+
+        output[k] = val;
     }
 }
 
-void xpassFilter(EventDataType * input, EventDataType * output, int samples, EventDataType weight)
+void xpassFilter(EventDataType *input, EventDataType *output, int samples, EventDataType weight)
 {
     // prime the first value
-    output[0]=input[0];
+    output[0] = input[0];
 
-    for (int i=1;i<samples;i++) {
-        output[i]=weight*input[i] + (1.0-weight)*output[i-1];
+    for (int i = 1; i < samples; i++) {
+        output[i] = weight * input[i] + (1.0 - weight) * output[i - 1];
     }
+
     //output[samples-1]=input[samples-1];
 }
 
 FlowParser::FlowParser()
 {
-    m_session=NULL;
-    m_flow=NULL;
-    m_filtered=NULL;
-    m_gain=1;
-    m_samples=0;
-    m_startsUpper=true;
+    m_session = NULL;
+    m_flow = NULL;
+    m_filtered = NULL;
+    m_gain = 1;
+    m_samples = 0;
+    m_startsUpper = true;
 
     // Allocate filter chain buffers..
-    m_filtered=(EventDataType *) malloc(max_filter_buf_size);
+    m_filtered = (EventDataType *) malloc(max_filter_buf_size);
 }
 FlowParser::~FlowParser()
 {
-    free (m_filtered);
-//    for (int i=0;i<num_filter_buffers;i++) {
-//        free(m_buffers[i]);
-//    }
+    free(m_filtered);
+    //    for (int i=0;i<num_filter_buffers;i++) {
+    //        free(m_buffers[i]);
+    //    }
 }
 void FlowParser::clearFilters()
 {
     m_filters.clear();
 }
 
-EventDataType * FlowParser::applyFilters(EventDataType * data, int samples)
+EventDataType *FlowParser::applyFilters(EventDataType *data, int samples)
 {
-    EventDataType *in=NULL,*out=NULL;
-    if (m_filters.size()==0) {
+    EventDataType *in = NULL, *out = NULL;
+
+    if (m_filters.size() == 0) {
         //qDebug() << "Trying to apply empty filter list in FlowParser..";
         return NULL;
     }
-    for (int i=0;i<num_filter_buffers;i++) {
-        m_buffers[i]=(EventDataType *) malloc(max_filter_buf_size);
+
+    for (int i = 0; i < num_filter_buffers; i++) {
+        m_buffers[i] = (EventDataType *) malloc(max_filter_buf_size);
     }
 
-    int numfilt=m_filters.size();
+    int numfilt = m_filters.size();
 
-    for (int i=0;i<numfilt;i++) {
-        if (i==0) {
-            in=data;
-            out=m_buffers[0];
-            if (in==out) {
+    for (int i = 0; i < numfilt; i++) {
+        if (i == 0) {
+            in = data;
+            out = m_buffers[0];
+
+            if (in == out) {
                 //qDebug() << "Error: If you need to use internal m_buffers as initial input, use the second one. No filters were applied";
                 return NULL;
             }
         } else {
-            in=m_buffers[(i+1) % num_filter_buffers];
-            out=m_buffers[i % num_filter_buffers];
+            in = m_buffers[(i + 1) % num_filter_buffers];
+            out = m_buffers[i % num_filter_buffers];
         }
 
         // If final link in chain, pass it back out to input data
-        if (i==numfilt-1) {
-            out=data;
+        if (i == numfilt - 1) {
+            out = data;
         }
 
-        Filter & filter=m_filters[i];
-        if (filter.type==FilterNone) {
+        Filter &filter = m_filters[i];
+
+        if (filter.type == FilterNone) {
             // Just copy it..
-            memcpy(in,out,samples*sizeof(EventDataType));
-        } else if (filter.type==FilterPercentile) {
-            percentileFilter(in,out,samples,filter.param1,filter.param2);
-        } else if (filter.type==FilterXPass) {
-            xpassFilter(in,out,samples,filter.param1);
+            memcpy(in, out, samples * sizeof(EventDataType));
+        } else if (filter.type == FilterPercentile) {
+            percentileFilter(in, out, samples, filter.param1, filter.param2);
+        } else if (filter.type == FilterXPass) {
+            xpassFilter(in, out, samples, filter.param1);
         }
     }
 
-    for (int i=0;i<num_filter_buffers;i++) {
+    for (int i = 0; i < num_filter_buffers; i++) {
         free(m_buffers[i]);
     }
+
     return out;
 }
-void FlowParser::openFlow(Session * session, EventList * flow)
+void FlowParser::openFlow(Session *session, EventList *flow)
 {
     if (!flow) {
         qDebug() << "called FlowParser::processFlow() with a null EventList!";
         return;
     }
-    m_session=session;
-    m_flow=flow;
-    m_gain=flow->gain();
-    m_rate=flow->rate();
-    m_samples=flow->count();
-    EventStoreType *inraw=flow->rawData();
+
+    m_session = session;
+    m_flow = flow;
+    m_gain = flow->gain();
+    m_rate = flow->rate();
+    m_samples = flow->count();
+    EventStoreType *inraw = flow->rawData();
 
     // Make sure we won't overflow internal buffers
     if (m_samples > max_filter_buf_size) {
-        qDebug() << "Error: Sample size exceeds max_filter_buf_size in FlowParser::openFlow().. Capping!!!";
-        m_samples=max_filter_buf_size;
+        qDebug() <<
+                 "Error: Sample size exceeds max_filter_buf_size in FlowParser::openFlow().. Capping!!!";
+        m_samples = max_filter_buf_size;
     }
 
     // Begin with the second internal buffer
-    EventDataType * buf=m_filtered;
+    EventDataType *buf = m_filtered;
     // Apply gain to waveform
-    EventStoreType *eptr=inraw+m_samples;
+    EventStoreType *eptr = inraw + m_samples;
 
     // Convert from store type to floats..
     for (; inraw < eptr; inraw++) {
@@ -206,79 +228,81 @@ void FlowParser::openFlow(Session * session, EventList * flow)
     }
 
     // Apply the rest of the filters chain
-    buf=applyFilters(m_filtered, m_samples);
+    buf = applyFilters(m_filtered, m_samples);
 
     calcPeaks(m_filtered, m_samples);
 }
 
 // Calculates breath upper & lower peaks for a chunk of EventList data
-void FlowParser::calcPeaks(EventDataType * input, int samples)
+void FlowParser::calcPeaks(EventDataType *input, int samples)
 {
-    if (samples<=0)
+    if (samples <= 0) {
         return;
+    }
 
-    EventDataType min=0,max=0, c, lastc=0;
+    EventDataType min = 0, max = 0, c, lastc = 0;
 
-    EventDataType zeroline=0;
+    EventDataType zeroline = 0;
 
-    double rate=m_flow->rate();
+    double rate = m_flow->rate();
 
-    double flowstart=m_flow->first();
-    double lasttime,time;
+    double flowstart = m_flow->first();
+    double lasttime, time;
 
-    double peakmax=flowstart, peakmin=flowstart;
+    double peakmax = flowstart, peakmin = flowstart;
 
-    time=lasttime=flowstart;
+    time = lasttime = flowstart;
     breaths.clear();
 
     // Estimate storage space needed using typical average breaths per minute.
-    m_minutes=double(m_flow->last() - m_flow->first()) / 60000.0;
-    const double avgbpm=20;
-    int guestimate=m_minutes*avgbpm;
+    m_minutes = double(m_flow->last() - m_flow->first()) / 60000.0;
+    const double avgbpm = 20;
+    int guestimate = m_minutes * avgbpm;
     breaths.reserve(guestimate);
 
     // Prime min & max, and see which side of the zero line we are starting from.
-    c=input[0];
-    min=max=c;
-    lastc=c;
-    m_startsUpper=(c >= zeroline);
+    c = input[0];
+    min = max = c;
+    lastc = c;
+    m_startsUpper = (c >= zeroline);
 
-    qint32 start=0,middle=0;//,end=0;
+    qint32 start = 0, middle = 0; //,end=0;
 
 
-    int sps=1000/m_rate;
-    int len=0, lastk=0; //lastlen=0
+    int sps = 1000 / m_rate;
+    int len = 0, lastk = 0; //lastlen=0
 
-    qint64 sttime=time;//, ettime=time;
+    qint64 sttime = time; //, ettime=time;
 
     // For each samples, find the peak upper and lower breath components
-    for (int k=0; k < samples; k++) {
-        c=input[k];
+    for (int k = 0; k < samples; k++) {
+        c = input[k];
 
         if (c >= zeroline) {
 
             // Did we just cross the zero line going up?
             if (lastc < zeroline) {
                 // This helps filter out dirty breaths..
-                len=k-start;
-                if ((max>3) && ((max-min) > 8) && (len>sps) && (middle > start))  {
+                len = k - start;
+
+                if ((max > 3) && ((max - min) > 8) && (len > sps) && (middle > start))  {
 
                     // peak detection may not be needed..
                     breaths.push_back(BreathPeak(min, max, start, middle, k)); //, peakmin, peakmax));
 
                     // Set max for start of the upper breath cycle
-                    max=c;
-                    peakmax=time;
+                    max = c;
+                    peakmax = time;
 
 
                     // Starting point of next breath cycle
-                    start=k;
-                    sttime=time;
+                    start = k;
+                    sttime = time;
                 }
             } else if (c > max) {
                 // Update upper breath peak
-                max=c;
-                peakmax=time;
+                max = c;
+                peakmax = time;
             }
         }
 
@@ -287,21 +311,22 @@ void FlowParser::calcPeaks(EventDataType * input, int samples)
 
             if (lastc >= zeroline) {
                 // Set min for start of the lower breath cycle
-                min=c;
-                peakmin=time;
-                middle=k;
+                min = c;
+                peakmin = time;
+                middle = k;
 
             } else if (c < min) {
                 // Update lower breath peak
-                min=c;
-                peakmin=time;
+                min = c;
+                peakmin = time;
             }
 
         }
-        lasttime=time;
-        time+=rate;
-        lastc=c;
-        lastk=k;
+
+        lasttime = time;
+        time += rate;
+        lastc = c;
+        lastk = k;
     }
 }
 
@@ -315,41 +340,44 @@ void FlowParser::calc(bool calcResp, bool calcTv, bool calcTi, bool calcTe, bool
     }
 
     // Don't even bother if only a few breaths in this chunk
-    const int lowthresh=4;
-    int nm=breaths.size();
-    if (nm < lowthresh)
+    const int lowthresh = 4;
+    int nm = breaths.size();
+
+    if (nm < lowthresh) {
         return;
+    }
 
-    const qint64 minute=60000;
+    const qint64 minute = 60000;
 
 
-    double start=m_flow->first();
-    double time=start;
+    double start = m_flow->first();
+    double time = start;
 
-    int bs,be,bm;
-    double st,et,mt;
+    int bs, be, bm;
+    double st, et, mt;
 
     /////////////////////////////////////////////////////////////////////////////////
     // Respiratory Rate setup
     /////////////////////////////////////////////////////////////////////////////////
-    EventDataType minrr=0,maxrr=0;
-    EventList * RR=NULL;
-    quint32 * rr_tptr=NULL;
-    EventStoreType * rr_dptr=NULL;
+    EventDataType minrr = 0, maxrr = 0;
+    EventList *RR = NULL;
+    quint32 *rr_tptr = NULL;
+    EventStoreType *rr_dptr = NULL;
+
     if (calcResp) {
-        RR=m_session->AddEventList(CPAP_RespRate,EVL_Event);
-        minrr=RR->Min(), maxrr=RR->Max();
+        RR = m_session->AddEventList(CPAP_RespRate, EVL_Event);
+        minrr = RR->Min(), maxrr = RR->Max();
         RR->setGain(0.2);
-        RR->setFirst(time+minute);
+        RR->setFirst(time + minute);
         RR->getData().resize(nm);
         RR->getTime().resize(nm);
-        rr_tptr=RR->rawTime();
-        rr_dptr=RR->rawData();
+        rr_tptr = RR->rawTime();
+        rr_dptr = RR->rawData();
     }
 
-    int rr_count=0;
+    int rr_count = 0;
 
-    double len, st2,et2,adj, stmin, b, rr=0;
+    double len, st2, et2, adj, stmin, b, rr = 0;
     double len2;
     int idx;
 
@@ -358,14 +386,16 @@ void FlowParser::calc(bool calcResp, bool calcTv, bool calcTi, bool calcTe, bool
     /////////////////////////////////////////////////////////////////////////////////
     // Inspiratory / Expiratory Time setup
     /////////////////////////////////////////////////////////////////////////////////
-    double lastte2=0,lastti2=0,lastte=0, lastti=0, te, ti, ti1, te1,c;
-    EventList * Te=NULL, * Ti=NULL;
+    double lastte2 = 0, lastti2 = 0, lastte = 0, lastti = 0, te, ti, ti1, te1, c;
+    EventList *Te = NULL, * Ti = NULL;
+
     if (calcTi) {
-        Ti=m_session->AddEventList(CPAP_Ti,EVL_Event);
+        Ti = m_session->AddEventList(CPAP_Ti, EVL_Event);
         Ti->setGain(0.02);
     }
+
     if (calcTe) {
-        Te=m_session->AddEventList(CPAP_Te,EVL_Event);
+        Te = m_session->AddEventList(CPAP_Te, EVL_Event);
         Te->setGain(0.02);
     }
 
@@ -373,49 +403,52 @@ void FlowParser::calc(bool calcResp, bool calcTv, bool calcTi, bool calcTe, bool
     /////////////////////////////////////////////////////////////////////////////////
     // Tidal Volume setup
     /////////////////////////////////////////////////////////////////////////////////
-    EventList * TV=NULL;
-    EventDataType mintv=0, maxtv=0, tv=0;
+    EventList *TV = NULL;
+    EventDataType mintv = 0, maxtv = 0, tv = 0;
     double val1, val2;
-    quint32 * tv_tptr=NULL;
-    EventStoreType * tv_dptr=NULL;
-    int tv_count=0;
+    quint32 *tv_tptr = NULL;
+    EventStoreType *tv_dptr = NULL;
+    int tv_count = 0;
+
     if (calcTv) {
-        TV=m_session->AddEventList(CPAP_TidalVolume,EVL_Event);
-        mintv=TV->Min(), maxtv=TV->Max();
+        TV = m_session->AddEventList(CPAP_TidalVolume, EVL_Event);
+        mintv = TV->Min(), maxtv = TV->Max();
         TV->setGain(20);
         TV->setFirst(start);
         TV->getData().resize(nm);
         TV->getTime().resize(nm);
-        tv_tptr=TV->rawTime();
-        tv_dptr=TV->rawData();
+        tv_tptr = TV->rawTime();
+        tv_dptr = TV->rawData();
     }
+
     /////////////////////////////////////////////////////////////////////////////////
     // Minute Ventilation setup
     /////////////////////////////////////////////////////////////////////////////////
-    EventList * MV=NULL;
+    EventList *MV = NULL;
     EventDataType mv;
+
     if (calcMv) {
-        MV=m_session->AddEventList(CPAP_MinuteVent,EVL_Event);
+        MV = m_session->AddEventList(CPAP_MinuteVent, EVL_Event);
         MV->setGain(0.125);
     }
 
-    EventDataType sps=(1000.0/m_rate); // Samples Per Second
+    EventDataType sps = (1000.0 / m_rate); // Samples Per Second
 
 
-    qint32 timeval=0; // Time relative to start
+    qint32 timeval = 0; // Time relative to start
 
-    for (idx=0;idx<nm;idx++) {
-        bs=breaths[idx].start;
-        bm=breaths[idx].middle;
-        be=breaths[idx].end;
+    for (idx = 0; idx < nm; idx++) {
+        bs = breaths[idx].start;
+        bm = breaths[idx].middle;
+        be = breaths[idx].end;
 
         // Calculate start, middle and end time of this breath
-        st=start+bs * m_rate;
-        mt=start+bm * m_rate;
+        st = start + bs * m_rate;
+        mt = start + bm * m_rate;
 
-        timeval=be * m_rate;
+        timeval = be * m_rate;
 
-        et=start+timeval;
+        et = start + timeval;
 
 
 
@@ -423,45 +456,51 @@ void FlowParser::calc(bool calcResp, bool calcTv, bool calcTi, bool calcTe, bool
         // Calculate Inspiratory Time (Ti) for this breath
         /////////////////////////////////////////////////////////////////////
         if (calcTi) {
-            ti=((mt-st)/1000.0)*50.0;
-            ti1=(lastti2+lastti+ti)/3.0;
-            Ti->AddEvent(mt,ti1);
-            lastti2=lastti;
-            lastti=ti;
+            ti = ((mt - st) / 1000.0) * 50.0;
+            ti1 = (lastti2 + lastti + ti) / 3.0;
+            Ti->AddEvent(mt, ti1);
+            lastti2 = lastti;
+            lastti = ti;
         }
+
         /////////////////////////////////////////////////////////////////////
         // Calculate Expiratory Time (Te) for this breath
         /////////////////////////////////////////////////////////////////////
         if (calcTe) {
-            te=((et-mt)/1000.0)*50.0;
+            te = ((et - mt) / 1000.0) * 50.0;
             // Average last three values..
-            te1=(lastte2+lastte+te)/3.0;
-            Te->AddEvent(mt,te1);
+            te1 = (lastte2 + lastte + te) / 3.0;
+            Te->AddEvent(mt, te1);
 
-            lastte2=lastte;
-            lastte=te;
+            lastte2 = lastte;
+            lastte = te;
         }
+
         /////////////////////////////////////////////////////////////////////
         // Calculate TidalVolume
         /////////////////////////////////////////////////////////////////////
         if (calcTv) {
-            val1=0, val2=0;
+            val1 = 0, val2 = 0;
+
             // Scan the upper breath
-            for (int j=bs;j<bm;j++)  {
+            for (int j = bs; j < bm; j++)  {
                 // convert flow to ml/s to L/min and divide by samples per second
-                c=double(qAbs(m_filtered[j])) * 1000.0 / 60.0 / sps;
-                val2+=c;
+                c = double(qAbs(m_filtered[j])) * 1000.0 / 60.0 / sps;
+                val2 += c;
                 //val2+=c*c; // for RMS
             }
+
             // calculate root mean square
             //double n=bm-bs;
             //double q=(1/n)*val2;
             //double x=sqrt(q)*2;
             //val2=x;
-            tv=val2;
+            tv = val2;
+
+            if (tv < mintv) { mintv = tv; }
+
+            if (tv > maxtv) { maxtv = tv; }
 
-            if (tv < mintv) mintv=tv;
-            if (tv > maxtv) maxtv=tv;
             *tv_tptr++ = timeval;
             *tv_dptr++ = tv / 20.0;
             tv_count++;
@@ -472,59 +511,71 @@ void FlowParser::calc(bool calcResp, bool calcTv, bool calcTi, bool calcTe, bool
         // Respiratory Rate Calculations
         /////////////////////////////////////////////////////////////////////
         if (calcResp) {
-            stmin=et-minute;
-            if (stmin < start)
-                stmin=start;
-            len=et-stmin;
-            rr=0;
-            len2=0;
+            stmin = et - minute;
+
+            if (stmin < start) {
+                stmin = start;
+            }
+
+            len = et - stmin;
+            rr = 0;
+            len2 = 0;
             //if ( len >= minute) {
-                //et2=et;
+            //et2=et;
 
-                // Step back through last minute and count breaths
-                for (int i=idx;i>=0;i--) {
-                    st2=start + double(breaths[i].start) * m_rate;
-                    et2=start + double(breaths[i].end) * m_rate;
-                    if (et2 < stmin)
-                        break;
+            // Step back through last minute and count breaths
+            for (int i = idx; i >= 0; i--) {
+                st2 = start + double(breaths[i].start) * m_rate;
+                et2 = start + double(breaths[i].end) * m_rate;
 
-                    len=et2-st2;
-                    if (st2 < stmin) {
-                        // Partial breath
-                        st2=stmin;
-                        adj=et2 - st2;
-                        b=(1.0 / len) * adj;
-                        len2+=adj;
-                    } else {
-                        b=1;
-                        len2+=len;
-                    }
-
-                    rr+=b;
+                if (et2 < stmin) {
+                    break;
                 }
-                if (len2 < minute) {
-                    rr*=minute/len2;
+
+                len = et2 - st2;
+
+                if (st2 < stmin) {
+                    // Partial breath
+                    st2 = stmin;
+                    adj = et2 - st2;
+                    b = (1.0 / len) * adj;
+                    len2 += adj;
+                } else {
+                    b = 1;
+                    len2 += len;
                 }
-                // Calculate min & max
-                if (rr < minrr)
-                    minrr=rr;
-                if (rr > maxrr)
-                    maxrr=rr;
 
-                // Add manually.. (much quicker)
-                *rr_tptr++ = timeval;
+                rr += b;
+            }
 
-                // Use the same gains as ResMed..
+            if (len2 < minute) {
+                rr *= minute / len2;
+            }
 
-                *rr_dptr++ = rr * 5.0;
-                rr_count++;
+            // Calculate min & max
+            if (rr < minrr) {
+                minrr = rr;
+            }
 
-                //rr->AddEvent(et,br * 50.0);
+            if (rr > maxrr) {
+                maxrr = rr;
+            }
+
+            // Add manually.. (much quicker)
+            *rr_tptr++ = timeval;
+
+            // Use the same gains as ResMed..
+
+            *rr_dptr++ = rr * 5.0;
+            rr_count++;
+
+            //rr->AddEvent(et,br * 50.0);
             //}
         }
+
         if (calcMv && calcResp && calcTv) {
-            mv=(tv/1000.0) * rr;
-            MV->AddEvent(et,mv * 8.0);
+            mv = (tv / 1000.0) * rr;
+            MV->AddEvent(et, mv * 8.0);
         }
     }
 
@@ -539,6 +590,7 @@ void FlowParser::calc(bool calcResp, bool calcTv, bool calcTi, bool calcTe, bool
         RR->setLast(et);
         RR->setCount(rr_count);
     }
+
     /////////////////////////////////////////////////////////////////////
     // Tidal Volume post filtering
     /////////////////////////////////////////////////////////////////////
@@ -554,132 +606,146 @@ void FlowParser::calc(bool calcResp, bool calcTv, bool calcTi, bool calcTe, bool
 
 void FlowParser::flagEvents()
 {
-    if (!PROFILE.cpap->userEventFlagging())  return;
+    if (!PROFILE.cpap->userEventFlagging()) { return; }
 
-    int numbreaths=breaths.size();
-    if (numbreaths<5) return;
+    int numbreaths = breaths.size();
 
-    EventDataType val,mx,mn;
+    if (numbreaths < 5) { return; }
+
+    EventDataType val, mx, mn;
     QVector<EventDataType> br;
 
     QVector<qint32> bstart;
     QVector<qint32> bend;
     //QVector<EventDataType> bvalue;
 
-    bstart.reserve(numbreaths*2);
-    bend.reserve(numbreaths*2);
+    bstart.reserve(numbreaths * 2);
+    bend.reserve(numbreaths * 2);
     //bvalue.reserve(numbreaths*2);
-    br.reserve(numbreaths*2);
+    br.reserve(numbreaths * 2);
 
-    double start=m_flow->first();
-   // double sps=1000.0/m_rate;
-    double st,et, dur; //mt
+    double start = m_flow->first();
+    // double sps=1000.0/m_rate;
+    double st, et, dur; //mt
     qint64 len;
 
-    bool allowDuplicates=PROFILE.cpap->userEventDuplicates();
+    bool allowDuplicates = PROFILE.cpap->userEventDuplicates();
 
-    for (int i=0;i<numbreaths;i++) {
-        mx=breaths[i].max;
-        mn=breaths[i].min;
+    for (int i = 0; i < numbreaths; i++) {
+        mx = breaths[i].max;
+        mn = breaths[i].min;
         br.push_back(qAbs(mx));
         br.push_back(qAbs(mn));
     }
+
     //EventList * uf2=m_session->AddEventList(CPAP_UserFlag2,EVL_Event);
     //EventList * uf3=m_session->AddEventList(CPAP_UserFlag3,EVL_Event);
 
-    const EventDataType perc=0.6;
-    int idx=float(br.size())*perc;
-    nth_element(br.begin(),br.begin()+idx,br.end()-1);
+    const EventDataType perc = 0.6;
+    int idx = float(br.size()) * perc;
+    nth_element(br.begin(), br.begin() + idx, br.end() - 1);
 
-    EventDataType peak=br[idx];//*(br.begin()+idx);
+    EventDataType peak = br[idx]; //*(br.begin()+idx);
 
-    EventDataType cutoffval=peak * (PROFILE.cpap->userFlowRestriction()/100.0);
+    EventDataType cutoffval = peak * (PROFILE.cpap->userFlowRestriction() / 100.0);
 
-    int bs,bm,be, bs1, bm1, be1;
-    for (int i=0;i<numbreaths;i++) {
-        bs=breaths[i].start;
-        bm=breaths[i].middle;
-        be=breaths[i].end;
+    int bs, bm, be, bs1, bm1, be1;
 
-        mx=breaths[i].max;
-        mn=breaths[i].min;
-        val=mx - mn;
+    for (int i = 0; i < numbreaths; i++) {
+        bs = breaths[i].start;
+        bm = breaths[i].middle;
+        be = breaths[i].end;
 
-//        if (qAbs(mx) > cutoffval) {
-            bs1=bs;
-            for (;bs1<be;bs1++) {
-                if (qAbs(m_filtered[bs1]) > cutoffval) {
-                    break;
-                }
-            }
+        mx = breaths[i].max;
+        mn = breaths[i].min;
+        val = mx - mn;
 
-            bm1=bm;
-            for (;bm1>bs;bm1--) {
-                if (qAbs(m_filtered[bm1]) > cutoffval) {
-                    break;
-                }
+        //        if (qAbs(mx) > cutoffval) {
+        bs1 = bs;
+
+        for (; bs1 < be; bs1++) {
+            if (qAbs(m_filtered[bs1]) > cutoffval) {
+                break;
             }
-            if (bm1>=bs1) {
-                bstart.push_back(bs1);
-                bend.push_back(bm1);
+        }
+
+        bm1 = bm;
+
+        for (; bm1 > bs; bm1--) {
+            if (qAbs(m_filtered[bm1]) > cutoffval) {
+                break;
             }
-  //      }
-    //    if (qAbs(mn) > cutoffval) {
-            bm1=bm;
-            for (;bm1<be;bm1++) {
-                if (qAbs(m_filtered[bm1]) > cutoffval) {
-                    break;
-                }
+        }
+
+        if (bm1 >= bs1) {
+            bstart.push_back(bs1);
+            bend.push_back(bm1);
+        }
+
+        //      }
+        //    if (qAbs(mn) > cutoffval) {
+        bm1 = bm;
+
+        for (; bm1 < be; bm1++) {
+            if (qAbs(m_filtered[bm1]) > cutoffval) {
+                break;
             }
-            be1=be;
-            for (;be1>bm;be1--) {
-                if (qAbs(m_filtered[be1]) > cutoffval) {
-                    break;
-                }
+        }
+
+        be1 = be;
+
+        for (; be1 > bm; be1--) {
+            if (qAbs(m_filtered[be1]) > cutoffval) {
+                break;
             }
-            if (be1>=bm1) {
-                bstart.push_back(bm1);
-                bend.push_back(be1);
-            }
-//        }
-         st=start + bs1 * m_rate;
-         et=start + be1  * m_rate;
-//         uf2->AddEvent(st,0);
-//         uf3->AddEvent(et,0);
+        }
+
+        if (be1 >= bm1) {
+            bstart.push_back(bm1);
+            bend.push_back(be1);
+        }
+
+        //        }
+        st = start + bs1 * m_rate;
+        et = start + be1  * m_rate;
+        //         uf2->AddEvent(st,0);
+        //         uf3->AddEvent(et,0);
 
     }
 
 
-    EventDataType duration=PROFILE.cpap->userEventDuration();
+    EventDataType duration = PROFILE.cpap->userEventDuration();
     //double lastst=start, lastet=start;
     //EventDataType v;
-    int bsize=bstart.size();
-    EventList * uf1=NULL;
+    int bsize = bstart.size();
+    EventList *uf1 = NULL;
 
-    for (int i=0;i<bsize-1;i++) {
-        bs=bend[i];
-        be=bstart[i+1];
-        st=start + bs * m_rate;
-        et=start + be  * m_rate;
+    for (int i = 0; i < bsize - 1; i++) {
+        bs = bend[i];
+        be = bstart[i + 1];
+        st = start + bs * m_rate;
+        et = start + be  * m_rate;
 
-        len=et-st;
-        dur=len/1000.0;
-        if (dur>=duration) {
-            if (allowDuplicates || !SearchApnea(m_session,et-len/2,15000)) {
+        len = et - st;
+        dur = len / 1000.0;
+
+        if (dur >= duration) {
+            if (allowDuplicates || !SearchApnea(m_session, et - len / 2, 15000)) {
                 if (!uf1) {
-                    uf1=m_session->AddEventList(CPAP_UserFlag1,EVL_Event);
+                    uf1 = m_session->AddEventList(CPAP_UserFlag1, EVL_Event);
                 }
-                uf1->AddEvent(et-len/2,dur);
+
+                uf1->AddEvent(et - len / 2, dur);
             }
         }
     }
 }
 
-void calcRespRate(Session *session, FlowParser * flowparser)
+void calcRespRate(Session *session, FlowParser *flowparser)
 {
-    if (session->machine()->GetType()!=MT_CPAP) return;
+    if (session->machine()->GetType() != MT_CPAP) { return; }
 
-//    if (session->machine()->GetClass()!=STR_MACH_PRS1) return;
+    //    if (session->machine()->GetClass()!=STR_MACH_PRS1) return;
 
     if (!session->eventlist.contains(CPAP_FlowRate)) {
         //qDebug() << "calcRespRate called without FlowRate waveform available";
@@ -687,45 +753,53 @@ void calcRespRate(Session *session, FlowParser * flowparser)
     }
 
     bool trashfp;
+
     if (!flowparser) {
-        flowparser=new FlowParser();
-        trashfp=true;
+        flowparser = new FlowParser();
+        trashfp = true;
         //qDebug() << "calcRespRate called without valid FlowParser object.. using a slow throw-away!";
         //return;
     } else {
-        trashfp=false;
+        trashfp = false;
     }
 
-    bool calcResp=!session->eventlist.contains(CPAP_RespRate);
-    bool calcTv=!session->eventlist.contains(CPAP_TidalVolume);
-    bool calcTi=!session->eventlist.contains(CPAP_Ti);
-    bool calcTe=!session->eventlist.contains(CPAP_Te);
-    bool calcMv=!session->eventlist.contains(CPAP_MinuteVent);
+    bool calcResp = !session->eventlist.contains(CPAP_RespRate);
+    bool calcTv = !session->eventlist.contains(CPAP_TidalVolume);
+    bool calcTi = !session->eventlist.contains(CPAP_Ti);
+    bool calcTe = !session->eventlist.contains(CPAP_Te);
+    bool calcMv = !session->eventlist.contains(CPAP_MinuteVent);
 
 
-    int z=(calcResp ? 1 : 0) + (calcTv ? 1 : 0) + (calcMv ? 1 : 0);
+    int z = (calcResp ? 1 : 0) + (calcTv ? 1 : 0) + (calcMv ? 1 : 0);
 
     // If any of these three missing, remove all, and switch all on
-    if (z>0 && z<3) {
-        if (!calcResp && !calcTv && !calcMv)
-        calcTv=calcMv=calcResp=true;
+    if (z > 0 && z < 3) {
+        if (!calcResp && !calcTv && !calcMv) {
+            calcTv = calcMv = calcResp = true;
+        }
 
-        QVector<EventList *> & list=session->eventlist[CPAP_RespRate];
-        for (int i=0;i<list.size();i++) {
+        QVector<EventList *> &list = session->eventlist[CPAP_RespRate];
+
+        for (int i = 0; i < list.size(); i++) {
             delete list[i];
         }
+
         session->eventlist[CPAP_RespRate].clear();
 
-        QVector<EventList *> & list2=session->eventlist[CPAP_TidalVolume];
-        for (int i=0;i<list2.size();i++) {
+        QVector<EventList *> &list2 = session->eventlist[CPAP_TidalVolume];
+
+        for (int i = 0; i < list2.size(); i++) {
             delete list2[i];
         }
+
         session->eventlist[CPAP_TidalVolume].clear();
 
-        QVector<EventList *> & list3=session->eventlist[CPAP_MinuteVent];
-        for (int i=0;i<list3.size();i++) {
+        QVector<EventList *> &list3 = session->eventlist[CPAP_MinuteVent];
+
+        for (int i = 0; i < list3.size(); i++) {
             delete list3[i];
         }
+
         session->eventlist[CPAP_MinuteVent].clear();
     }
 
@@ -738,73 +812,82 @@ void calcRespRate(Session *session, FlowParser * flowparser)
     //flowparser->addFilter(FilterPercentile,5,0.5);
     //flowparser->addFilter(FilterXPass,0.5);
     EventList *flow;
-    for (int ws=0; ws < session->eventlist[CPAP_FlowRate].size(); ws++) {
-        flow=session->eventlist[CPAP_FlowRate][ws];
+
+    for (int ws = 0; ws < session->eventlist[CPAP_FlowRate].size(); ws++) {
+        flow = session->eventlist[CPAP_FlowRate][ws];
+
         if (flow->count() > 20) {
             flowparser->openFlow(session, flow);
-            flowparser->calc(calcResp, calcTv, calcTi ,calcTe, calcMv);
+            flowparser->calc(calcResp, calcTv, calcTi , calcTe, calcMv);
             flowparser->flagEvents();
         }
     }
+
     if (trashfp) {
         delete flowparser;
     }
 }
 
 
-EventDataType calcAHI(Session *session,qint64 start, qint64 end)
+EventDataType calcAHI(Session *session, qint64 start, qint64 end)
 {
-    bool rdi=PROFILE.general->calculateRDI();
+    bool rdi = PROFILE.general->calculateRDI();
 
-    double hours,ahi,cnt;
-    if (start<0) {
+    double hours, ahi, cnt;
+
+    if (start < 0) {
         // much faster..
-        hours=session->hours();
-        cnt=session->count(CPAP_Obstructive)
-                +session->count(CPAP_Hypopnea)
-                +session->count(CPAP_ClearAirway)
-                +session->count(CPAP_Apnea);
+        hours = session->hours();
+        cnt = session->count(CPAP_Obstructive)
+              + session->count(CPAP_Hypopnea)
+              + session->count(CPAP_ClearAirway)
+              + session->count(CPAP_Apnea);
 
         if (rdi) {
-            cnt+=session->count(CPAP_RERA);
+            cnt += session->count(CPAP_RERA);
         }
 
-        ahi=cnt/hours;
+        ahi = cnt / hours;
     } else {
-        hours=double(end-start)/3600000L;
-        if (hours==0) return 0;
-        cnt=session->rangeCount(CPAP_Obstructive,start,end)
-                +session->rangeCount(CPAP_Hypopnea,start,end)
-                +session->rangeCount(CPAP_ClearAirway,start,end)
-                +session->rangeCount(CPAP_Apnea,start,end);
+        hours = double(end - start) / 3600000L;
+
+        if (hours == 0) { return 0; }
+
+        cnt = session->rangeCount(CPAP_Obstructive, start, end)
+              + session->rangeCount(CPAP_Hypopnea, start, end)
+              + session->rangeCount(CPAP_ClearAirway, start, end)
+              + session->rangeCount(CPAP_Apnea, start, end);
 
         if (rdi) {
-            cnt+=session->rangeCount(CPAP_RERA,start,end);
+            cnt += session->rangeCount(CPAP_RERA, start, end);
         }
 
-        ahi=cnt/hours;
+        ahi = cnt / hours;
     }
+
     return ahi;
 }
 
 int calcAHIGraph(Session *session)
 {
-    bool calcrdi=session->machine()->GetClass()=="PRS1";
+    bool calcrdi = session->machine()->GetClass() == "PRS1";
     //PROFILE.general->calculateRDI()
 
 
-    const qint64 window_step=30000; // 30 second windows
-    double window_size=p_profile->cpap->AHIWindow();
-    qint64 window_size_ms=window_size*60000L;
+    const qint64 window_step = 30000; // 30 second windows
+    double window_size = p_profile->cpap->AHIWindow();
+    qint64 window_size_ms = window_size * 60000L;
 
-    bool zeroreset=p_profile->cpap->AHIReset();
+    bool zeroreset = p_profile->cpap->AHIReset();
 
-    if (session->machine()->GetType()!=MT_CPAP) return 0;
+    if (session->machine()->GetType() != MT_CPAP) { return 0; }
 
-    bool hasahi=session->eventlist.contains(CPAP_AHI);
-    bool hasrdi=session->eventlist.contains(CPAP_RDI);
-    if (hasahi && hasrdi)
-        return 0; // abort if already there
+    bool hasahi = session->eventlist.contains(CPAP_AHI);
+    bool hasrdi = session->eventlist.contains(CPAP_RDI);
+
+    if (hasahi && hasrdi) {
+        return 0;    // abort if already there
+    }
 
     if (!(!hasahi && !hasrdi)) {
         session->destroyEvent(CPAP_AHI);
@@ -816,136 +899,147 @@ int calcAHIGraph(Session *session)
             !session->channelExists(CPAP_Apnea) &&
             !session->channelExists(CPAP_ClearAirway) &&
             !session->channelExists(CPAP_RERA)
-            ) return 0;
+       ) { return 0; }
 
-    qint64 first=session->first(),
-           last=session->last(),
+    qint64 first = session->first(),
+           last = session->last(),
            f;
 
-    EventList *AHI=new EventList(EVL_Event);
+    EventList *AHI = new EventList(EVL_Event);
     AHI->setGain(0.02);
     session->eventlist[CPAP_AHI].push_back(AHI);
 
-    EventList *RDI=NULL;
+    EventList *RDI = NULL;
 
     if (calcrdi) {
-        RDI=new EventList(EVL_Event);
+        RDI = new EventList(EVL_Event);
         RDI->setGain(0.02);
         session->eventlist[CPAP_RDI].push_back(RDI);
     }
 
-    EventDataType ahi,rdi;
+    EventDataType ahi, rdi;
 
-    qint64 ti=first,lastti=first;
+    qint64 ti = first, lastti = first;
 
-    double avgahi=0;
-    double avgrdi=0;
-    int cnt=0;
+    double avgahi = 0;
+    double avgrdi = 0;
+    int cnt = 0;
 
     double events;
-    double hours=(window_size/60.0);
+    double hours = (window_size / 60.0);
+
     if (zeroreset) {
         // I personally don't see the point of resetting each hour.
         do {
             // For each window, in 30 second increments
-            for (qint64 t=ti;t < ti+window_size_ms; t+=window_step) {
-                if (t > last)
+            for (qint64 t = ti; t < ti + window_size_ms; t += window_step) {
+                if (t > last) {
                     break;
-                events=session->rangeCount(CPAP_Obstructive,ti,t)
-                        +session->rangeCount(CPAP_Hypopnea,ti,t)
-                        +session->rangeCount(CPAP_ClearAirway,ti,t)
-                        +session->rangeCount(CPAP_Apnea,ti,t);
+                }
+
+                events = session->rangeCount(CPAP_Obstructive, ti, t)
+                         + session->rangeCount(CPAP_Hypopnea, ti, t)
+                         + session->rangeCount(CPAP_ClearAirway, ti, t)
+                         + session->rangeCount(CPAP_Apnea, ti, t);
 
                 ahi = events / hours;
 
-                AHI->AddEvent(t,ahi * 50);
-                avgahi+=ahi;
+                AHI->AddEvent(t, ahi * 50);
+                avgahi += ahi;
 
                 if (calcrdi) {
-                    events+=session->rangeCount(CPAP_RERA,ti,t);
-                    rdi=events / hours;
-                    RDI->AddEvent(t,rdi * 50);
-                    avgrdi+=rdi;
+                    events += session->rangeCount(CPAP_RERA, ti, t);
+                    rdi = events / hours;
+                    RDI->AddEvent(t, rdi * 50);
+                    avgrdi += rdi;
                 }
 
                 cnt++;
             }
-            lastti=ti;
-            ti+=window_size_ms;
-        } while (ti<last);
+
+            lastti = ti;
+            ti += window_size_ms;
+        } while (ti < last);
 
     } else {
-        for (ti=first;ti<last;ti+=window_step) {
-            f=ti-window_size_ms;
+        for (ti = first; ti < last; ti += window_step) {
+            f = ti - window_size_ms;
             //hours=window_size; //double(ti-f)/3600000L;
 
-            events=session->rangeCount(CPAP_Obstructive,f,ti)
-                    +session->rangeCount(CPAP_Hypopnea,f,ti)
-                    +session->rangeCount(CPAP_ClearAirway,f,ti)
-                    +session->rangeCount(CPAP_Apnea,f,ti);
+            events = session->rangeCount(CPAP_Obstructive, f, ti)
+                     + session->rangeCount(CPAP_Hypopnea, f, ti)
+                     + session->rangeCount(CPAP_ClearAirway, f, ti)
+                     + session->rangeCount(CPAP_Apnea, f, ti);
 
-            ahi=events/hours;
-            avgahi+=ahi;
-            AHI->AddEvent(ti,ahi * 50);
+            ahi = events / hours;
+            avgahi += ahi;
+            AHI->AddEvent(ti, ahi * 50);
 
             if (calcrdi) {
-                events+=session->rangeCount(CPAP_RERA,f,ti);
-                rdi=events/hours;
-                RDI->AddEvent(ti,rdi * 50);
-                avgrdi+=rdi;
+                events += session->rangeCount(CPAP_RERA, f, ti);
+                rdi = events / hours;
+                RDI->AddEvent(ti, rdi * 50);
+                avgrdi += rdi;
             }
 
             cnt++;
-            lastti=ti;
-            ti+=window_step;
+            lastti = ti;
+            ti += window_step;
         }
     }
-    AHI->AddEvent(lastti,0);
-    if (calcrdi)
-        RDI->AddEvent(lastti,0);
+
+    AHI->AddEvent(lastti, 0);
+
+    if (calcrdi) {
+        RDI->AddEvent(lastti, 0);
+    }
 
     if (!cnt) {
-            avgahi=0;
-            avgrdi=0;
+        avgahi = 0;
+        avgrdi = 0;
     } else {
-        avgahi/=double(cnt);
-        avgrdi/=double(cnt);
+        avgahi /= double(cnt);
+        avgrdi /= double(cnt);
     }
+
     cnt++;
-    session->setAvg(CPAP_AHI,avgahi);
-    if (calcrdi)
-        session->setAvg(CPAP_RDI,avgrdi);
+    session->setAvg(CPAP_AHI, avgahi);
+
+    if (calcrdi) {
+        session->setAvg(CPAP_RDI, avgrdi);
+    }
+
     return cnt;
 }
 struct TimeValue {
     TimeValue() {
-        time=0;
-        value=0;
+        time = 0;
+        value = 0;
     }
     TimeValue(qint64 t, EventStoreType v) {
-        time=t;
-        value=v;
+        time = t;
+        value = v;
     }
-    TimeValue(const TimeValue & copy) {
-        time=copy.time;
-        value=copy.value;
+    TimeValue(const TimeValue &copy) {
+        time = copy.time;
+        value = copy.value;
     }
     qint64 time;
     EventStoreType value;
 };
 
 struct zMaskProfile {
-public:
+  public:
     zMaskProfile(MaskType type, QString name);
     ~zMaskProfile();
 
     void reset() { pressureleaks.clear(); }
-    void scanLeaks(Session * session);
-    void scanPressure(Session * session);
+    void scanLeaks(Session *session);
+    void scanPressure(Session *session);
     void updatePressureMin();
-    void updateProfile(Session * session);
+    void updateProfile(Session *session);
 
-    void load(Profile * profile);
+    void load(Profile *profile);
     void save();
 
     QMap<EventStoreType, EventDataType> pressuremax;
@@ -959,27 +1053,28 @@ public:
 
     EventDataType calcLeak(EventStoreType pressure);
 
-protected:
-    static const quint32 version=0;
-    void scanLeakList(EventList * leak);
-    void scanPressureList(EventList * el);
+  protected:
+    static const quint32 version = 0;
+    void scanLeakList(EventList *leak);
+    void scanPressureList(EventList *el);
 
     MaskType    m_type;
     QString     m_name;
-    Profile     * m_profile;
+    Profile      *m_profile;
     QString     m_filename;
 
-    QMap<EventStoreType, QMap<EventStoreType,quint32> > pressureleaks;
-    EventDataType maxP,minP,maxL,minL,m_factor;
+    QMap<EventStoreType, QMap<EventStoreType, quint32> > pressureleaks;
+    EventDataType maxP, minP, maxL, minL, m_factor;
 };
 
 
-bool operator<(const TimeValue &p1, const TimeValue & p2) {
+bool operator<(const TimeValue &p1, const TimeValue &p2)
+{
     return p1.time < p2.time;
 }
 
 zMaskProfile::zMaskProfile(MaskType type, QString name)
-    :m_type(type), m_name(name)
+    : m_type(type), m_name(name)
 {
 }
 zMaskProfile::~zMaskProfile()
@@ -987,22 +1082,25 @@ zMaskProfile::~zMaskProfile()
     save();
 }
 
-void zMaskProfile::load(Profile * profile)
+void zMaskProfile::load(Profile *profile)
 {
-    m_profile=profile;
-    m_filename=m_profile->Get("{"+STR_GEN_DataFolder+"}/MaskProfile.mp");
+    m_profile = profile;
+    m_filename = m_profile->Get("{" + STR_GEN_DataFolder + "}/MaskProfile.mp");
     QFile f(m_filename);
-    if (!f.open(QFile::ReadOnly))
+
+    if (!f.open(QFile::ReadOnly)) {
         return;
+    }
 
     QDataStream in(&f);
     in.setVersion(QDataStream::Qt_4_6);
     in.setByteOrder(QDataStream::LittleEndian);
 
-    quint32 m,v;
+    quint32 m, v;
     in >> m;
     in >> v;
-    if (m!=magic) {
+
+    if (m != magic) {
         qDebug() << "Magic wrong in zMaskProfile::load";
     }
 
@@ -1011,12 +1109,15 @@ void zMaskProfile::load(Profile * profile)
 }
 void zMaskProfile::save()
 {
-    if (m_filename.isEmpty())
+    if (m_filename.isEmpty()) {
         return;
+    }
 
     QFile f(m_filename);
-    if (!f.open(QFile::WriteOnly))
+
+    if (!f.open(QFile::WriteOnly)) {
         return;
+    }
 
     QDataStream out(&f);
     out.setVersion(QDataStream::Qt_4_6);
@@ -1029,101 +1130,110 @@ void zMaskProfile::save()
     f.close();
 }
 
-void zMaskProfile::scanPressureList(EventList * el)
+void zMaskProfile::scanPressureList(EventList *el)
 {
-    qint64 start=el->first();
-    int count=el->count();
-    EventStoreType * dptr=el->rawData();
-    EventStoreType * eptr=dptr+count;
-    quint32 * tptr=el->rawTime();
+    qint64 start = el->first();
+    int count = el->count();
+    EventStoreType *dptr = el->rawData();
+    EventStoreType *eptr = dptr + count;
+    quint32 *tptr = el->rawTime();
     qint64 time;
     EventStoreType pressure;
 
-    for (;dptr < eptr; dptr++) {
-        time=start+ *tptr++;
-        pressure=*dptr;
-        Pressure.push_back(TimeValue(time,pressure));
+    for (; dptr < eptr; dptr++) {
+        time = start + *tptr++;
+        pressure = *dptr;
+        Pressure.push_back(TimeValue(time, pressure));
     }
 }
-void zMaskProfile::scanPressure(Session * session)
+void zMaskProfile::scanPressure(Session *session)
 {
     Pressure.clear();
 
-    int prescnt=0;
+    int prescnt = 0;
+
     //EventStoreType pressure;
     if (session->eventlist.contains(CPAP_Pressure)) {
-        prescnt=session->count(CPAP_Pressure);
+        prescnt = session->count(CPAP_Pressure);
         Pressure.reserve(prescnt);
-        for (int j=0;j<session->eventlist[CPAP_Pressure].size();j++) {
-            QVector<EventList *> & el=session->eventlist[CPAP_Pressure];
-            for (int e=0;e<el.size();e++) {
+
+        for (int j = 0; j < session->eventlist[CPAP_Pressure].size(); j++) {
+            QVector<EventList *> &el = session->eventlist[CPAP_Pressure];
+
+            for (int e = 0; e < el.size(); e++) {
                 scanPressureList(el[e]);
             }
         }
     } else if (session->eventlist.contains(CPAP_IPAP)) {
-        prescnt=session->count(CPAP_IPAP);
+        prescnt = session->count(CPAP_IPAP);
         Pressure.reserve(prescnt);
-        for (int j=0;j<session->eventlist[CPAP_IPAP].size();j++) {
-            QVector<EventList *> & el=session->eventlist[CPAP_IPAP];
-            for (int e=0;e<el.size();e++) {
+
+        for (int j = 0; j < session->eventlist[CPAP_IPAP].size(); j++) {
+            QVector<EventList *> &el = session->eventlist[CPAP_IPAP];
+
+            for (int e = 0; e < el.size(); e++) {
                 scanPressureList(el[e]);
             }
         }
     }
+
     qSort(Pressure);
 }
-void zMaskProfile::scanLeakList(EventList * el)
+void zMaskProfile::scanLeakList(EventList *el)
 {
-    qint64 start=el->first();
-    int count=el->count();
-    EventStoreType * dptr=el->rawData();
-    EventStoreType * eptr=dptr+count;
-    quint32 * tptr=el->rawTime();
+    qint64 start = el->first();
+    int count = el->count();
+    EventStoreType *dptr = el->rawData();
+    EventStoreType *eptr = dptr + count;
+    quint32 *tptr = el->rawTime();
     //EventDataType gain=el->gain();
 
-    EventStoreType pressure,leak;
+    EventStoreType pressure, leak;
 
     //EventDataType fleak;
     QMap<EventStoreType, EventDataType>::iterator pmin;
     qint64 ti;
     bool found;
-    for (;dptr<eptr;dptr++) {
-        leak=*dptr;
-        ti=start + *tptr++;
 
-        found=false;
-        pressure=Pressure[0].value;
-        if (Pressure.size()>1) {
-            for (int i=0;i<Pressure.size()-1;i++) {
-                const TimeValue & p1=Pressure[i];
-                const TimeValue & p2=Pressure[i+1];
+    for (; dptr < eptr; dptr++) {
+        leak = *dptr;
+        ti = start + *tptr++;
+
+        found = false;
+        pressure = Pressure[0].value;
+
+        if (Pressure.size() > 1) {
+            for (int i = 0; i < Pressure.size() - 1; i++) {
+                const TimeValue &p1 = Pressure[i];
+                const TimeValue &p2 = Pressure[i + 1];
 
                 if ((p2.time > ti) && (p1.time <= ti)) {
-                    pressure=p1.value;
-                    found=true;
+                    pressure = p1.value;
+                    found = true;
                     break;
-                } else if (p2.time==ti) {
-                    pressure=p2.value;
-                    found=true;
+                } else if (p2.time == ti) {
+                    pressure = p2.value;
+                    found = true;
                     break;
                 }
             }
         } else {
-            found=true;
+            found = true;
         }
+
         if (found) {
             pressureleaks[pressure][leak]++;
-//            pmin=pressuremin.find(pressure);
-//            fleak=EventDataType(leak) * gain;
-//            if (pmin==pressuremin.end()) {
-//                pressuremin[pressure]=fleak;
-//                pressurecount[pressure]=pressureleaks[pressure][leak];
-//            } else {
-//                if (pmin.value() > fleak) {
-//                    pmin.value()=fleak;
-//                    pressurecount[pressure]=pressureleaks[pressure][leak];
-//                }
-//            }
+            //            pmin=pressuremin.find(pressure);
+            //            fleak=EventDataType(leak) * gain;
+            //            if (pmin==pressuremin.end()) {
+            //                pressuremin[pressure]=fleak;
+            //                pressurecount[pressure]=pressureleaks[pressure][leak];
+            //            } else {
+            //                if (pmin.value() > fleak) {
+            //                    pmin.value()=fleak;
+            //                    pressurecount[pressure]=pressureleaks[pressure][leak];
+            //                }
+            //            }
         } else {
             //int i=5;
         }
@@ -1131,16 +1241,17 @@ void zMaskProfile::scanLeakList(EventList * el)
 
 
 }
-void zMaskProfile::scanLeaks(Session * session)
+void zMaskProfile::scanLeaks(Session *session)
 {
-    QVector<EventList *> & elv=session->eventlist[CPAP_LeakTotal];
-    for (int i=0;i<elv.size();i++) {
+    QVector<EventList *> &elv = session->eventlist[CPAP_LeakTotal];
+
+    for (int i = 0; i < elv.size(); i++) {
         scanLeakList(elv[i]);
     }
 }
 void zMaskProfile::updatePressureMin()
 {
-    QMap<EventStoreType, QMap<EventStoreType,quint32> >::iterator it;
+    QMap<EventStoreType, QMap<EventStoreType, quint32> >::iterator it;
 
     EventStoreType pressure;
     //EventDataType perc=0.1;
@@ -1148,301 +1259,341 @@ void zMaskProfile::updatePressureMin()
     //int idx1, idx2,
     int lks;
     double SN;
-    double percentile=0.40;
+    double percentile = 0.40;
 
-    double p=100.0*percentile;
-    double nth,nthi;
+    double p = 100.0 * percentile;
+    double nth, nthi;
 
-    int sum1,sum2,w1,w2,N,k;
+    int sum1, sum2, w1, w2, N, k;
 
-    for (it=pressureleaks.begin();it!=pressureleaks.end();it++) {
-        pressure=it.key();
-        QMap<EventStoreType,quint32> & leakmap = it.value();
-        lks=leakmap.size();
-        SN=0;
+    for (it = pressureleaks.begin(); it != pressureleaks.end(); it++) {
+        pressure = it.key();
+        QMap<EventStoreType, quint32> &leakmap = it.value();
+        lks = leakmap.size();
+        SN = 0;
 
         // First sum total counts of all leaks
-        for (QMap<EventStoreType,quint32>::iterator lit=leakmap.begin();lit!=leakmap.end();lit++) {
-            SN+=lit.value();
+        for (QMap<EventStoreType, quint32>::iterator lit = leakmap.begin(); lit != leakmap.end(); lit++) {
+            SN += lit.value();
         }
 
 
-        nth=double(SN)*percentile; // index of the position in the unweighted set would be
-        nthi=floor(nth);
+        nth = double(SN) * percentile; // index of the position in the unweighted set would be
+        nthi = floor(nth);
 
-        sum1=0,sum2=0;
-        w1=0,w2=0;
+        sum1 = 0, sum2 = 0;
+        w1 = 0, w2 = 0;
 
-        EventDataType v1=0,v2;
+        EventDataType v1 = 0, v2;
 
-        N=leakmap.size();
-        k=0;
+        N = leakmap.size();
+        k = 0;
 
-        bool found=false;
-        double total=0;
-        for (QMap<EventStoreType,quint32>::iterator lit=leakmap.begin();lit!=leakmap.end();lit++,k++) {
-            total+=lit.value();
+        bool found = false;
+        double total = 0;
+
+        for (QMap<EventStoreType, quint32>::iterator lit = leakmap.begin(); lit != leakmap.end();
+                lit++, k++) {
+            total += lit.value();
         }
-        pressuretotal[pressure]=total;
-        for (QMap<EventStoreType,quint32>::iterator lit=leakmap.begin();lit!=leakmap.end();lit++,k++) {
-        //for (k=0;k < N;k++) {
-            v1=lit.key();
-            w1=lit.value();
-            sum1+=w1;
+
+        pressuretotal[pressure] = total;
+
+        for (QMap<EventStoreType, quint32>::iterator lit = leakmap.begin(); lit != leakmap.end();
+                lit++, k++) {
+            //for (k=0;k < N;k++) {
+            v1 = lit.key();
+            w1 = lit.value();
+            sum1 += w1;
 
             if (sum1 > nthi) {
-                pressuremin[pressure]=v1;
-                pressurecount[pressure]=w1;
-                found=true;
+                pressuremin[pressure] = v1;
+                pressurecount[pressure] = w1;
+                found = true;
                 break;
             }
+
             if (sum1 == nthi) {
                 break; // boundary condition
             }
         }
-        if (found) continue;
-        if (k>=N) {
-            pressuremin[pressure]=v1;
-            pressurecount[pressure]=w1;
+
+        if (found) { continue; }
+
+        if (k >= N) {
+            pressuremin[pressure] = v1;
+            pressurecount[pressure] = w1;
             continue;
         }
 
-        v2=(leakmap.begin()+(k+1)).key();
-        w2=(leakmap.begin()+(k+1)).value();
-        sum2=sum1+w2;
+        v2 = (leakmap.begin() + (k + 1)).key();
+        w2 = (leakmap.begin() + (k + 1)).value();
+        sum2 = sum1 + w2;
         // value lies between v1 and v2
 
-        double px=100.0/double(SN); // Percentile represented by one full value
+        double px = 100.0 / double(SN); // Percentile represented by one full value
 
         // calculate percentile ranks
-        double p1=px * (double(sum1)-(double(w1)/2.0));
-        double p2=px * (double(sum2)-(double(w2)/2.0));
+        double p1 = px * (double(sum1) - (double(w1) / 2.0));
+        double p2 = px * (double(sum2) - (double(w2) / 2.0));
 
         // calculate linear interpolation
-        double v=v1 + ((p-p1)/(p2-p1)) * (v2-v1);
-        pressuremin[pressure]=v;
-        pressurecount[pressure]=w1;
+        double v = v1 + ((p - p1) / (p2 - p1)) * (v2 - v1);
+        pressuremin[pressure] = v;
+        pressurecount[pressure] = w1;
 
     }
 }
 
 EventDataType zMaskProfile::calcLeak(EventStoreType pressure)
 {
-    if (maxP==minP)
+    if (maxP == minP) {
         return pressuremin[pressure];
+    }
 
-    EventDataType leak=(pressure-minP) * (m_factor) + minL;
+    EventDataType leak = (pressure - minP) * (m_factor) + minL;
     return leak;
 
 }
 
-void zMaskProfile::updateProfile(Session * session)
+void zMaskProfile::updateProfile(Session *session)
 {
     scanPressure(session);
     scanLeaks(session);
     updatePressureMin();
 
 
-    if (pressuremin.size()<=1) {
-        maxP=minP=0;
-        maxL=minL=0;
-        m_factor=0;
+    if (pressuremin.size() <= 1) {
+        maxP = minP = 0;
+        maxL = minL = 0;
+        m_factor = 0;
         return;
     }
-    EventDataType p,l,tmp,mean,sum;
-    minP=250,maxP=0;
-    minL=1000, maxL=0;
 
-    long cnt=0, vcnt;
+    EventDataType p, l, tmp, mean, sum;
+    minP = 250, maxP = 0;
+    minL = 1000, maxL = 0;
+
+    long cnt = 0, vcnt;
     int n;
 
     EventDataType maxcnt, maxval, lastval, lastcnt;
 
-    for (QMap<EventStoreType, QMap<EventStoreType,quint32> >::iterator it=pressureleaks.begin();it!=pressureleaks.end();it++)  {
-        p=it.key();
-        l=pressuremin[p];
-        QMap<EventStoreType,quint32> & leakval=it.value();
-        cnt=0;
-        vcnt=-1;
-        n=leakval.size();
-        sum=0;
+    for (QMap<EventStoreType, QMap<EventStoreType, quint32> >::iterator it = pressureleaks.begin();
+            it != pressureleaks.end(); it++)  {
+        p = it.key();
+        l = pressuremin[p];
+        QMap<EventStoreType, quint32> &leakval = it.value();
+        cnt = 0;
+        vcnt = -1;
+        n = leakval.size();
+        sum = 0;
+
+        maxcnt = 0, maxval = 0, lastval = 0, lastcnt = 0;
+
+        for (QMap<EventStoreType, quint32>::iterator lit = leakval.begin(); lit != leakval.end(); lit++) {
+            cnt += lit.value();
 
-        maxcnt=0, maxval=0, lastval=0, lastcnt=0;
-        for (QMap<EventStoreType,quint32>::iterator lit=leakval.begin();lit!=leakval.end();lit++) {
-            cnt+=lit.value();
             if (lit.value() > maxcnt) {
-                lastcnt=maxcnt;
-                maxcnt=lit.value();
-                lastval=maxval;
-                maxval=lit.key();
+                lastcnt = maxcnt;
+                maxcnt = lit.value();
+                lastval = maxval;
+                maxval = lit.key();
 
             }
-            sum+=lit.key() * lit.value();
-            if (lit.key()==(EventStoreType)l) {
-                vcnt=lit.value();
+
+            sum += lit.key() * lit.value();
+
+            if (lit.key() == (EventStoreType)l) {
+                vcnt = lit.value();
             }
         }
-        pressuremean[p]=mean=sum / EventDataType(cnt);
+
+        pressuremean[p] = mean = sum / EventDataType(cnt);
+
         if (lastval > 0) {
-            maxval=qMax(maxval,lastval); //((maxval*maxcnt)+(lastval*lastcnt)) / (maxcnt+lastcnt);
+            maxval = qMax(maxval, lastval); //((maxval*maxcnt)+(lastval*lastcnt)) / (maxcnt+lastcnt);
         }
-        pressuremax[p]=lastval;
-        sum=0;
-        for (QMap<EventStoreType,quint32>::iterator lit=leakval.begin();lit!=leakval.end();lit++) {
-            tmp=lit.key()-mean;
-            sum+=tmp * tmp;
-        }
-        pressurestddev[p]=tmp=sqrt(sum / EventDataType(n));
 
-        if (vcnt>=0) {
-            tmp=1.0 / EventDataType(cnt) * EventDataType(vcnt);
+        pressuremax[p] = lastval;
+        sum = 0;
+
+        for (QMap<EventStoreType, quint32>::iterator lit = leakval.begin(); lit != leakval.end(); lit++) {
+            tmp = lit.key() - mean;
+            sum += tmp * tmp;
+        }
+
+        pressurestddev[p] = tmp = sqrt(sum / EventDataType(n));
+
+        if (vcnt >= 0) {
+            tmp = 1.0 / EventDataType(cnt) * EventDataType(vcnt);
 
         }
     }
+
     QMap<EventStoreType, EventDataType> pressureval;
     QMap<EventStoreType, EventDataType> pressureval2;
-    EventDataType max=0,tmp2,tmp3;
-    for (QMap<EventStoreType, EventDataType>::iterator it=pressuretotal.begin();it!=pressuretotal.end();it++) {
-        if (max < it.value()) max=it.value();
-    }
-    for (QMap<EventStoreType, EventDataType>::iterator it=pressuretotal.begin();it!=pressuretotal.end();it++) {
-        p=it.key();
-        tmp=pressurecount[p];
-        tmp2=it.value();
+    EventDataType max = 0, tmp2, tmp3;
+
+    for (QMap<EventStoreType, EventDataType>::iterator it = pressuretotal.begin();
+            it != pressuretotal.end(); it++) {
+        if (max < it.value()) { max = it.value(); }
+    }
+
+    for (QMap<EventStoreType, EventDataType>::iterator it = pressuretotal.begin();
+            it != pressuretotal.end(); it++) {
+        p = it.key();
+        tmp = pressurecount[p];
+        tmp2 = it.value();
+
+        tmp3 = (tmp / tmp2) * (tmp2 / max);
 
-        tmp3=(tmp / tmp2) * (tmp2 / max);
         if (tmp3 > 0.05) {
-            tmp=pressuremean[p];
-            if (tmp>0) {
-                pressureval[p]=tmp; // / tmp2;
-                if (p < minP) minP = p;
-                if (p > maxP) maxP = p;
-                if (tmp < minL) minL = tmp;
-                if (tmp > maxL) maxL = tmp;
+            tmp = pressuremean[p];
+
+            if (tmp > 0) {
+                pressureval[p] = tmp; // / tmp2;
+
+                if (p < minP) { minP = p; }
+
+                if (p > maxP) { maxP = p; }
+
+                if (tmp < minL) { minL = tmp; }
+
+                if (tmp > maxL) { maxL = tmp; }
             }
         }
     }
 
-    if ((maxP==minP)  || (minL==maxL) || (minP==250) || (minL==1000)) {
+    if ((maxP == minP)  || (minL == maxL) || (minP == 250) || (minL == 1000)) {
         // crappy data set
-        maxP=minP=0;
-        maxL=minL=0;
-        m_factor=0;
+        maxP = minP = 0;
+        maxL = minL = 0;
+        m_factor = 0;
         return;
     }
+
     m_factor = (maxL - minL) / (maxP - minP);
 
-//    for (QMap<EventStoreType, EventDataType>::iterator it=pressuremin.begin();it!=pressuremin.end()-1;it++) {
-//        p1=it.key();
-//        p2=(it+1).key();
-//        l1=it.value();
-//        l2=(it+1).value();
-//        if (l2 > l1) {
-//            factor=(l2 - l1) / (p2 - p1);
-//            sum+=factor;
-//            cnt++;
-//        }
-//    }
+    //    for (QMap<EventStoreType, EventDataType>::iterator it=pressuremin.begin();it!=pressuremin.end()-1;it++) {
+    //        p1=it.key();
+    //        p2=(it+1).key();
+    //        l1=it.value();
+    //        l2=(it+1).value();
+    //        if (l2 > l1) {
+    //            factor=(l2 - l1) / (p2 - p1);
+    //            sum+=factor;
+    //            cnt++;
+    //        }
+    //    }
 
-//    m_factor=sum/double(cnt);
+    //    m_factor=sum/double(cnt);
 
-//    int i=0;
-//    if (i==1) {
-//        QFile f("/home/mark/leaks.csv");
-//        f.open(QFile::WriteOnly);
-//        QTextStream out(&f);
-//        EventDataType p,l,c;
-//        QString fmt;
-//        for (QMap<EventStoreType, EventDataType>::iterator it=pressuremin.begin();it!=pressuremin.end();it++) {
-//            p=EventDataType(it.key()/10.0);
-//            l=it.value();
-//            fmt=QString("%1,%2\n").arg(p,0,'f',1).arg(l);
-//            out << fmt;
-//        }
+    //    int i=0;
+    //    if (i==1) {
+    //        QFile f("/home/mark/leaks.csv");
+    //        f.open(QFile::WriteOnly);
+    //        QTextStream out(&f);
+    //        EventDataType p,l,c;
+    //        QString fmt;
+    //        for (QMap<EventStoreType, EventDataType>::iterator it=pressuremin.begin();it!=pressuremin.end();it++) {
+    //            p=EventDataType(it.key()/10.0);
+    //            l=it.value();
+    //            fmt=QString("%1,%2\n").arg(p,0,'f',1).arg(l);
+    //            out << fmt;
+    //        }
 
     // cruft
-//        for (QMap<EventStoreType, QMap<EventStoreType,quint32> >::iterator it=pressureleaks.begin();it!=pressureleaks.end();it++)  {
-//            QMap<EventStoreType,quint32> & leakval=it.value();
-//            for (QMap<EventStoreType,quint32>::iterator lit=leakval.begin();lit!=leakval.end();lit++) {
-//                l=lit.key();
-//                c=lit.value();
-//                fmt=QString("%1,%2,%3\n").arg(p,0,'f',2).arg(l).arg(c);
-//                out << fmt;
-//            }
-//        }
-//        f.close();
-//    }
+    //        for (QMap<EventStoreType, QMap<EventStoreType,quint32> >::iterator it=pressureleaks.begin();it!=pressureleaks.end();it++)  {
+    //            QMap<EventStoreType,quint32> & leakval=it.value();
+    //            for (QMap<EventStoreType,quint32>::iterator lit=leakval.begin();lit!=leakval.end();lit++) {
+    //                l=lit.key();
+    //                c=lit.value();
+    //                fmt=QString("%1,%2,%3\n").arg(p,0,'f',2).arg(l).arg(c);
+    //                out << fmt;
+    //            }
+    //        }
+    //        f.close();
+    //    }
 }
 
 QMutex zMaskmutex;
-zMaskProfile mmaskProfile(Mask_NasalPillows,"ResMed Swift FX");
-bool mmaskFirst=true;
+zMaskProfile mmaskProfile(Mask_NasalPillows, "ResMed Swift FX");
+bool mmaskFirst = true;
 
 int calcLeaks(Session *session)
 {
 
-    if (session->machine()->GetType()!=MT_CPAP) return 0;
-    if (session->eventlist.contains(CPAP_Leak)) return 0; // abort if already there
-    if (!session->eventlist.contains(CPAP_LeakTotal)) return 0; // can't calculate without this..
+    if (session->machine()->GetType() != MT_CPAP) { return 0; }
+
+    if (session->eventlist.contains(CPAP_Leak)) { return 0; } // abort if already there
+
+    if (!session->eventlist.contains(CPAP_LeakTotal)) { return 0; } // can't calculate without this..
 
     zMaskmutex.lock();
-    zMaskProfile * maskProfile=&mmaskProfile;
+    zMaskProfile *maskProfile = &mmaskProfile;
+
     if (mmaskFirst) {
-        mmaskFirst=false;
+        mmaskFirst = false;
         maskProfile->load(p_profile);
     }
-//    if (!maskProfile) {
-//        maskProfile=new zMaskProfile(Mask_NasalPillows,"ResMed Swift FX");
-//    }
+
+    //    if (!maskProfile) {
+    //        maskProfile=new zMaskProfile(Mask_NasalPillows,"ResMed Swift FX");
+    //    }
     maskProfile->reset();
     maskProfile->updateProfile(session);
 
-    EventList *leak=session->AddEventList(CPAP_Leak,EVL_Event,1);
+    EventList *leak = session->AddEventList(CPAP_Leak, EVL_Event, 1);
 
-    for (int i=0;i<session->eventlist[CPAP_LeakTotal].size();i++) {
-        EventList & el=*session->eventlist[CPAP_LeakTotal][i];
-        EventDataType gain=el.gain(),tmp,val;
+    for (int i = 0; i < session->eventlist[CPAP_LeakTotal].size(); i++) {
+        EventList &el = *session->eventlist[CPAP_LeakTotal][i];
+        EventDataType gain = el.gain(), tmp, val;
         int count = el.count();
-        EventStoreType *dptr=el.rawData();
-        EventStoreType *eptr=dptr+count;
-        quint32 * tptr=el.rawTime();
-        qint64 start=el.first(),ti;
+        EventStoreType *dptr = el.rawData();
+        EventStoreType *eptr = dptr + count;
+        quint32 *tptr = el.rawTime();
+        qint64 start = el.first(), ti;
         EventStoreType pressure;
-        tptr=el.rawTime();
-        start=el.first();
+        tptr = el.rawTime();
+        start = el.first();
 
         bool found;
-        for (; dptr < eptr; dptr++) {
-            tmp=EventDataType(*dptr) * gain;
-            ti=start+ *tptr++;
 
-            found=false;
-            pressure=maskProfile->Pressure[0].value;
-            for (int i=0;i<maskProfile->Pressure.size()-1;i++) {
-                const TimeValue & p1=maskProfile->Pressure[i];
-                const TimeValue & p2=maskProfile->Pressure[i+1];
+        for (; dptr < eptr; dptr++) {
+            tmp = EventDataType(*dptr) * gain;
+            ti = start + *tptr++;
+
+            found = false;
+            pressure = maskProfile->Pressure[0].value;
+
+            for (int i = 0; i < maskProfile->Pressure.size() - 1; i++) {
+                const TimeValue &p1 = maskProfile->Pressure[i];
+                const TimeValue &p2 = maskProfile->Pressure[i + 1];
 
                 if ((p2.time > ti) && (p1.time <= ti)) {
-                    pressure=p1.value;
-                    found=true;
+                    pressure = p1.value;
+                    found = true;
                     break;
-                } else if (p2.time==ti) {
-                    pressure=p2.value;
-                    found=true;
+                } else if (p2.time == ti) {
+                    pressure = p2.value;
+                    found = true;
                     break;
                 }
             }
+
             if (found) {
-                val=tmp-maskProfile->calcLeak(pressure);
+                val = tmp - maskProfile->calcLeak(pressure);
 
                 if (val < 0) {
-                    val=0;
+                    val = 0;
                 }
 
-                leak->AddEvent(ti,val);
+                leak->AddEvent(ti, val);
             }
         }
     }
+
     zMaskmutex.unlock();
     return leak->count();
 }
@@ -1450,88 +1601,99 @@ int calcLeaks(Session *session)
 
 int calcPulseChange(Session *session)
 {
-    if (session->eventlist.contains(OXI_PulseChange)) return 0;
+    if (session->eventlist.contains(OXI_PulseChange)) { return 0; }
 
-    QHash<ChannelID,QVector<EventList *> >::iterator it=session->eventlist.find(OXI_Pulse);
-    if (it==session->eventlist.end()) return 0;
+    QHash<ChannelID, QVector<EventList *> >::iterator it = session->eventlist.find(OXI_Pulse);
 
-    EventDataType val,val2,change,tmp;
-    qint64 time,time2;
-    qint64 window=PROFILE.oxi->pulseChangeDuration();
-    window*=1000;
+    if (it == session->eventlist.end()) { return 0; }
 
-    change=PROFILE.oxi->pulseChangeBPM();
+    EventDataType val, val2, change, tmp;
+    qint64 time, time2;
+    qint64 window = PROFILE.oxi->pulseChangeDuration();
+    window *= 1000;
 
-    EventList *pc=new EventList(EVL_Event,1,0,0,0,0,true);
+    change = PROFILE.oxi->pulseChangeBPM();
+
+    EventList *pc = new EventList(EVL_Event, 1, 0, 0, 0, 0, true);
     pc->setFirst(session->first(OXI_Pulse));
     qint64 lastt;
-    EventDataType lv=0;
-    int li=0;
+    EventDataType lv = 0;
+    int li = 0;
 
     int max;
-    for (int e=0;e<it.value().size();e++) {
-        EventList & el=*(it.value()[e]);
 
-        for (unsigned i=0;i<el.count();i++) {
-            val=el.data(i);
-            time=el.time(i);
+    for (int e = 0; e < it.value().size(); e++) {
+        EventList &el = *(it.value()[e]);
+
+        for (unsigned i = 0; i < el.count(); i++) {
+            val = el.data(i);
+            time = el.time(i);
 
 
-            lastt=0;
-            lv=change;
-            max=0;
+            lastt = 0;
+            lv = change;
+            max = 0;
+
+            for (unsigned j = i + 1; j < el.count(); j++) { // scan ahead in the window
+                time2 = el.time(j);
+
+                if (time2 > time + window) { break; }
+
+                val2 = el.data(j);
+                tmp = qAbs(val2 - val);
 
-            for (unsigned j=i+1;j<el.count();j++) { // scan ahead in the window
-                time2=el.time(j);
-                if (time2 > time+window) break;
-                val2=el.data(j);
-                tmp=qAbs(val2-val);
                 if (tmp > lv) {
-                    lastt=time2;
-                    if (tmp>max) max=tmp;
+                    lastt = time2;
+
+                    if (tmp > max) { max = tmp; }
+
                     //lv=tmp;
-                    li=j;
+                    li = j;
                 }
             }
-            if (lastt>0) {
-                qint64 len=(lastt-time)/1000.0;
-                pc->AddEvent(lastt,len,tmp);
-                i=li;
+
+            if (lastt > 0) {
+                qint64 len = (lastt - time) / 1000.0;
+                pc->AddEvent(lastt, len, tmp);
+                i = li;
 
             }
         }
     }
-    if (pc->count()==0) {
+
+    if (pc->count() == 0) {
         delete pc;
         return 0;
     }
+
     session->eventlist[OXI_PulseChange].push_back(pc);
-    session->setMin(OXI_PulseChange,pc->Min());
-    session->setMax(OXI_PulseChange,pc->Max());
-    session->setCount(OXI_PulseChange,pc->count());
-    session->setFirst(OXI_PulseChange,pc->first());
-    session->setLast(OXI_PulseChange,pc->last());
+    session->setMin(OXI_PulseChange, pc->Min());
+    session->setMax(OXI_PulseChange, pc->Max());
+    session->setCount(OXI_PulseChange, pc->count());
+    session->setFirst(OXI_PulseChange, pc->first());
+    session->setLast(OXI_PulseChange, pc->last());
     return pc->count();
 }
 
 
 int calcSPO2Drop(Session *session)
 {
-    if (session->eventlist.contains(OXI_SPO2Drop)) return 0;
+    if (session->eventlist.contains(OXI_SPO2Drop)) { return 0; }
 
-    QHash<ChannelID,QVector<EventList *> >::iterator it=session->eventlist.find(OXI_SPO2);
-    if (it==session->eventlist.end()) return 0;
+    QHash<ChannelID, QVector<EventList *> >::iterator it = session->eventlist.find(OXI_SPO2);
 
-    EventDataType val,val2,change,tmp;
-    qint64 time,time2;
-    qint64 window=PROFILE.oxi->spO2DropDuration();
-    window*=1000;
-    change=PROFILE.oxi->spO2DropPercentage();
+    if (it == session->eventlist.end()) { return 0; }
 
-    EventList *pc=new EventList(EVL_Event,1,0,0,0,0,true);
+    EventDataType val, val2, change, tmp;
+    qint64 time, time2;
+    qint64 window = PROFILE.oxi->spO2DropDuration();
+    window *= 1000;
+    change = PROFILE.oxi->spO2DropPercentage();
+
+    EventList *pc = new EventList(EVL_Event, 1, 0, 0, 0, 0, true);
     qint64 lastt;
-    EventDataType lv=0;
-    int li=0;
+    EventDataType lv = 0;
+    int li = 0;
 
     // Fix me.. Time scale varies.
     //const unsigned ringsize=30;
@@ -1539,45 +1701,60 @@ int calcSPO2Drop(Session *session)
     //qint64 rtime[ringsize]={0};
     //int rp=0;
     int min;
-    int cnt=0;
-    tmp=0;
+    int cnt = 0;
+    tmp = 0;
 
-    qint64 start=0;
+    qint64 start = 0;
 
     // Calculate median baseline
     QList<EventDataType> med;
-    for (int e=0;e<it.value().size();e++) {
-        EventList & el=*(it.value()[e]);
-        for (unsigned i=0;i<el.count();i++) {
-            val=el.data(i);
-            time=el.time(i);
-            if (val>0) med.push_back(val);
-            if (!start) start=time;
-            if (time > start+3600000) break; // just look at the first hour
-            tmp+=val;
+
+    for (int e = 0; e < it.value().size(); e++) {
+        EventList &el = *(it.value()[e]);
+
+        for (unsigned i = 0; i < el.count(); i++) {
+            val = el.data(i);
+            time = el.time(i);
+
+            if (val > 0) { med.push_back(val); }
+
+            if (!start) { start = time; }
+
+            if (time > start + 3600000) { break; } // just look at the first hour
+
+            tmp += val;
             cnt++;
         }
     }
-    EventDataType baseline=0;
-    if (med.size()>0) {
+
+    EventDataType baseline = 0;
+
+    if (med.size() > 0) {
         qSort(med);
 
-        int midx=float(med.size())*0.90;
-        if (midx>med.size()-1) midx=med.size()-1;
-        if (midx<0) midx=0;
-        baseline=med[midx];
+        int midx = float(med.size()) * 0.90;
+
+        if (midx > med.size() - 1) { midx = med.size() - 1; }
+
+        if (midx < 0) { midx = 0; }
+
+        baseline = med[midx];
     }
-    session->settings[OXI_SPO2Drop]=baseline;
+
+    session->settings[OXI_SPO2Drop] = baseline;
     //EventDataType baseline=round(tmp/EventDataType(cnt));
     EventDataType current;
     qDebug() << "Calculated baseline" << baseline;
 
-    for (int e=0;e<it.value().size();e++) {
-        EventList & el=*(it.value()[e]);
-        for (unsigned i=0;i<el.count();i++) {
-            current=el.data(i);
-            if (!current) continue;
-            time=el.time(i);
+    for (int e = 0; e < it.value().size(); e++) {
+        EventList &el = *(it.value()[e]);
+
+        for (unsigned i = 0; i < el.count(); i++) {
+            current = el.data(i);
+
+            if (!current) { continue; }
+
+            time = el.time(i);
             /*ring[rp]=val;
             rtime[rp]=time;
             rp++;
@@ -1601,39 +1778,45 @@ int calcSPO2Drop(Session *session)
                 tmp=(ring[j]+val)/2;
             } else tmp/=EventDataType(cnt); */
 
-            val=baseline;
-            lastt=0;
-            lv=val;
+            val = baseline;
+            lastt = 0;
+            lv = val;
 
 
-            min=val;
-            for (unsigned j=i;j<el.count();j++) { // scan ahead in the window
-                time2=el.time(j);
+            min = val;
+
+            for (unsigned j = i; j < el.count(); j++) { // scan ahead in the window
+                time2 = el.time(j);
                 //if (time2 > time+window) break;
-                val2=el.data(j);
+                val2 = el.data(j);
 
-                if (val2 > baseline-change) break;
-                lastt=time2;
-                li=j+1;
+                if (val2 > baseline - change) { break; }
+
+                lastt = time2;
+                li = j + 1;
             }
-            if (lastt>0) {
-                qint64 len=(lastt-time);
-                if (len>=window) {
-                    pc->AddEvent(lastt,len/1000,val-min);
-                    i=li;
+
+            if (lastt > 0) {
+                qint64 len = (lastt - time);
+
+                if (len >= window) {
+                    pc->AddEvent(lastt, len / 1000, val - min);
+                    i = li;
                 }
             }
         }
     }
-    if (pc->count()==0) {
+
+    if (pc->count() == 0) {
         delete pc;
         return 0;
     }
+
     session->eventlist[OXI_SPO2Drop].push_back(pc);
-    session->setMin(OXI_SPO2Drop,pc->Min());
-    session->setMax(OXI_SPO2Drop,pc->Max());
-    session->setCount(OXI_SPO2Drop,pc->count());
-    session->setFirst(OXI_SPO2Drop,pc->first());
-    session->setLast(OXI_SPO2Drop,pc->last());
+    session->setMin(OXI_SPO2Drop, pc->Min());
+    session->setMax(OXI_SPO2Drop, pc->Max());
+    session->setCount(OXI_SPO2Drop, pc->count());
+    session->setFirst(OXI_SPO2Drop, pc->first());
+    session->setLast(OXI_SPO2Drop, pc->last());
     return pc->count();
 }
diff --git a/sleepyhead/SleepLib/calcs.h b/sleepyhead/SleepLib/calcs.h
index 2ccbdf8c..ad78a2a6 100644
--- a/sleepyhead/SleepLib/calcs.h
+++ b/sleepyhead/SleepLib/calcs.h
@@ -17,29 +17,30 @@
 //! param samples Number of samples
 //! width number of surrounding samples to consider
 //! percentile fractional percentage, between 0 and 1
-void percentileFilter(EventDataType * input, EventDataType * output, int samples, int width, EventDataType percentile);
-void xpassFilter(EventDataType * input, EventDataType * output, int samples, EventDataType weight);
+void percentileFilter(EventDataType *input, EventDataType *output, int samples, int width,
+                      EventDataType percentile);
+void xpassFilter(EventDataType *input, EventDataType *output, int samples, EventDataType weight);
 
-enum FilterType { FilterNone=0, FilterPercentile, FilterXPass };
+enum FilterType { FilterNone = 0, FilterPercentile, FilterXPass };
 
 struct Filter {
-    Filter(FilterType t,EventDataType p1,EventDataType p2,EventDataType p3) {
-        type=t;
-        param1=p1;
-        param2=p2;
-        param3=p3;
+    Filter(FilterType t, EventDataType p1, EventDataType p2, EventDataType p3) {
+        type = t;
+        param1 = p1;
+        param2 = p2;
+        param3 = p3;
     }
     Filter() {
-        type=FilterNone;
-        param1=0;
-        param2=0;
-        param3=0;
+        type = FilterNone;
+        param1 = 0;
+        param2 = 0;
+        param3 = 0;
     }
-    Filter(const Filter & copy) {
-        type=copy.type;
-        param1=copy.param1;
-        param2=copy.param2;
-        param3=copy.param3;
+    Filter(const Filter &copy) {
+        type = copy.type;
+        param1 = copy.param1;
+        param2 = copy.param2;
+        param3 = copy.param3;
     }
 
     FilterType type;
@@ -49,28 +50,29 @@ struct Filter {
 };
 
 struct BreathPeak {
-    BreathPeak() { min=0; max=0; start=0; middle=0; end=0; } // peakmin=0; peakmax=0;  }
-    BreathPeak(EventDataType _min, EventDataType _max, qint32 _start, qint32 _middle,  qint32 _end) {//, qint64 _peakmin, qint64 _peakmax) {
-        min=_min;
-        max=_max;
-        start=_start;
-        middle=_middle;
-        end=_end;
+    BreathPeak() { min = 0; max = 0; start = 0; middle = 0; end = 0; } // peakmin=0; peakmax=0;  }
+    BreathPeak(EventDataType _min, EventDataType _max, qint32 _start, qint32 _middle,
+               qint32 _end) {//, qint64 _peakmin, qint64 _peakmax) {
+        min = _min;
+        max = _max;
+        start = _start;
+        middle = _middle;
+        end = _end;
         //peakmax=_peakmax;
         //peakmin=_peakmin;
     }
-    BreathPeak(const BreathPeak & copy) {
-        min=copy.min;
-        max=copy.max;
-        start=copy.start;
-        middle=copy.middle;
-        end=copy.end;
+    BreathPeak(const BreathPeak &copy) {
+        min = copy.min;
+        max = copy.max;
+        start = copy.start;
+        middle = copy.middle;
+        end = copy.end;
         //peakmin=copy.peakmin;
         //peakmax=copy.peakmax;
     }
-    int samplelength() { return end-start; }
-    int upperLength() { return middle-start; }
-    int lowerLength() { return end-middle; }
+    int samplelength() { return end - start; }
+    int upperLength() { return middle - start; }
+    int lowerLength() { return end - middle; }
 
     EventDataType min;   // peak value
     EventDataType max;   // peak value
@@ -81,15 +83,16 @@ struct BreathPeak {
     //qint64 peakmax;     // max peak index
 };
 
-bool operator<(const BreathPeak & p1, const BreathPeak & p2);
+bool operator<(const BreathPeak &p1, const BreathPeak &p2);
 
-const int num_filter_buffers=2;
+const int num_filter_buffers = 2;
 
-const int max_filter_buf_size=2097152*sizeof(EventDataType);
+const int max_filter_buf_size = 2097152 * sizeof(EventDataType);
 
 //! \brief Class to process Flow Rate waveform data
-class FlowParser {
-public:
+class FlowParser
+{
+  public:
     FlowParser();
     ~FlowParser();
 
@@ -97,17 +100,17 @@ public:
     void clearFilters();
 
     //! \brief Applies the filter chain to input, with supplied number of samples
-    EventDataType * applyFilters(EventDataType * input, int samples);
+    EventDataType *applyFilters(EventDataType *input, int samples);
 
     //! \brief Add the filter
-    void addFilter(FilterType ft, EventDataType p1=0, EventDataType p2=0, EventDataType p3=0) {
-        m_filters.push_back(Filter(ft,p1,p2,p3));
+    void addFilter(FilterType ft, EventDataType p1 = 0, EventDataType p2 = 0, EventDataType p3 = 0) {
+        m_filters.push_back(Filter(ft, p1, p2, p3));
     }
     //! \brief Opens the flow rate EventList, applies the input filter chain, and calculates peaks
-    void openFlow(Session * session, EventList * flow);
+    void openFlow(Session *session, EventList *flow);
 
     //! \brief Calculates the upper and lower breath peaks
-    void calcPeaks(EventDataType * input, int samples);
+    void calcPeaks(EventDataType *input, int samples);
 
     // Minute vent needs Resp & TV calcs made here..
     void calc(bool calcResp, bool calcTv, bool calcTi, bool calcTe, bool calcMv);
@@ -119,33 +122,33 @@ public:
 
 
     QList<Filter> m_filters;
-protected:
+  protected:
     QVector<BreathPeak> breaths;
 
     int m_samples;
-    EventList * m_flow;
-    Session * m_session;
+    EventList *m_flow;
+    Session *m_session;
     EventDataType m_gain;
     EventDataType m_rate;
     EventDataType m_minutes;
     //! \brief The filtered waveform
-    EventDataType * m_filtered;
+    EventDataType *m_filtered;
     //! \brief BreathPeak's start on positive cycle?
     bool m_startsUpper;
-private:
-    EventDataType * m_buffers[num_filter_buffers];
+  private:
+    EventDataType *m_buffers[num_filter_buffers];
 };
 
-bool SearchApnea(Session *session, qint64 time, qint64 dist=15000);
+bool SearchApnea(Session *session, qint64 time, qint64 dist = 15000);
 
 //! \brief Calculate Respiratory Rate, Tidal Volume & Minute Ventilation for PRS1 data
-void calcRespRate(Session *session, FlowParser * flowparser=NULL);
+void calcRespRate(Session *session, FlowParser *flowparser = NULL);
 
 //! \brief Calculates the sliding window AHI graph
 int calcAHIGraph(Session *session);
 
 //! \brief Calculates AHI for a session between start & end (a support function for the sliding window graph)
-EventDataType calcAHI(Session *session,qint64 start=-1, qint64 end=-1);
+EventDataType calcAHI(Session *session, qint64 start = -1, qint64 end = -1);
 
 //! \brief Leaks calculations for PRS1
 int calcLeaks(Session *session);
diff --git a/sleepyhead/SleepLib/common.cpp b/sleepyhead/SleepLib/common.cpp
index cb82e64b..b03d6ce9 100644
--- a/sleepyhead/SleepLib/common.cpp
+++ b/sleepyhead/SleepLib/common.cpp
@@ -24,64 +24,69 @@ const QString getDeveloperName()
 
 const QString getAppName()
 {
-    QString name=STR_AppName;
+    QString name = STR_AppName;
 #ifdef UNSTABLE_BUILD
-    name+=STR_Unstable;
+    name += STR_Unstable;
 #endif
     return name;
 }
 
 const QString getDefaultAppRoot()
 {
-    QString approot=STR_AppRoot;
+    QString approot = STR_AppRoot;
 #ifdef UNSTABLE_BUILD
-    approot+=STR_Unstable;
+    approot += STR_Unstable;
 #endif
     return approot;
 }
 
 
-qint64 timezoneOffset() {
-    static bool ok=false;
-    static qint64 _TZ_offset=0;
+qint64 timezoneOffset()
+{
+    static bool ok = false;
+    static qint64 _TZ_offset = 0;
 
-    if (ok) return _TZ_offset;
-    QDateTime d1=QDateTime::currentDateTime();
-    QDateTime d2=d1;
+    if (ok) { return _TZ_offset; }
+
+    QDateTime d1 = QDateTime::currentDateTime();
+    QDateTime d2 = d1;
     d1.setTimeSpec(Qt::UTC);
-    _TZ_offset=d2.secsTo(d1);
-    _TZ_offset*=1000L;
+    _TZ_offset = d2.secsTo(d1);
+    _TZ_offset *= 1000L;
     return _TZ_offset;
 }
 
 QString weightString(float kg, UnitSystem us)
 {
-    if (us==US_Undefined)
-        us=PROFILE.general->unitSystem();
-
-    if (us==US_Metric) {
-        return QString("%1kg").arg(kg,0,'f',2);
-    } else if (us==US_Archiac) {
-        int oz=(kg*1000.0) / (float)ounce_convert;
-        int lb=oz / 16.0;
-        oz = oz % 16;
-        return QString("%1lb %2oz").arg(lb,0,10).arg(oz);
+    if (us == US_Undefined) {
+        us = PROFILE.general->unitSystem();
     }
-    return("Bad UnitSystem");
+
+    if (us == US_Metric) {
+        return QString("%1kg").arg(kg, 0, 'f', 2);
+    } else if (us == US_Archiac) {
+        int oz = (kg * 1000.0) / (float)ounce_convert;
+        int lb = oz / 16.0;
+        oz = oz % 16;
+        return QString("%1lb %2oz").arg(lb, 0, 10).arg(oz);
+    }
+
+    return ("Bad UnitSystem");
 }
 
-bool operator <(const ValueCount & a, const ValueCount & b)
+bool operator <(const ValueCount &a, const ValueCount &b)
 {
-     return a.value < b.value;
+    return a.value < b.value;
 }
 
-bool removeDir(const QString & path)
+bool removeDir(const QString &path)
 {
     bool result = true;
     QDir dir(path);
 
     if (dir.exists(path)) {
-        Q_FOREACH(QFileInfo info, dir.entryInfoList(QDir::NoDotAndDotDot | QDir::System | QDir::Hidden  | QDir::AllDirs | QDir::Files, QDir::DirsFirst)) {
+        Q_FOREACH(QFileInfo info, dir.entryInfoList(QDir::NoDotAndDotDot | QDir::System | QDir::Hidden  |
+                  QDir::AllDirs | QDir::Files, QDir::DirsFirst)) {
             if (info.isDir()) { // Recurse to remove this child directory
                 result = removeDir(info.absoluteFilePath());
             } else { // File
@@ -254,157 +259,158 @@ QString STR_TR_WAvg;   // Short form of Weighted Average
 
 void initializeStrings()
 {
-    STR_UNIT_CM=QObject::tr("cm");
-    STR_UNIT_INCH=QObject::tr("\"");
-    STR_UNIT_FOOT=QObject::tr("ft");
-    STR_UNIT_POUND=QObject::tr("lb");
-    STR_UNIT_OUNCE=QObject::tr("oz");
-    STR_UNIT_KG=QObject::tr("Kg");
-    STR_UNIT_CMH2O=QObject::tr("cmH2O");
-    STR_UNIT_Hours=QObject::tr("Hours");
+    STR_UNIT_CM = QObject::tr("cm");
+    STR_UNIT_INCH = QObject::tr("\"");
+    STR_UNIT_FOOT = QObject::tr("ft");
+    STR_UNIT_POUND = QObject::tr("lb");
+    STR_UNIT_OUNCE = QObject::tr("oz");
+    STR_UNIT_KG = QObject::tr("Kg");
+    STR_UNIT_CMH2O = QObject::tr("cmH2O");
+    STR_UNIT_Hours = QObject::tr("Hours");
 
-    STR_UNIT_BPM=QObject::tr("bpm");          // Beats per Minute
-    STR_UNIT_LPM=QObject::tr("L/m");          // Litres per Minute
+    STR_UNIT_BPM = QObject::tr("bpm");        // Beats per Minute
+    STR_UNIT_LPM = QObject::tr("L/m");        // Litres per Minute
 
-    STR_MESSAGE_ERROR=QObject::tr("Error");
-    STR_MESSAGE_WARNING=QObject::tr("Warning");
+    STR_MESSAGE_ERROR = QObject::tr("Error");
+    STR_MESSAGE_WARNING = QObject::tr("Warning");
 
-    STR_TR_BMI=QObject::tr("BMI");                // Short form of Body Mass Index
-    STR_TR_Weight=QObject::tr("Weight");
-    STR_TR_Zombie=QObject::tr("Zombie");
-    STR_TR_PulseRate=QObject::tr("Pulse Rate");   // Pulse / Heart rate
-    STR_TR_SpO2=QObject::tr("SpO2");
-    STR_TR_Plethy=QObject::tr("Plethy");          // Plethysomogram
-    STR_TR_Pressure=QObject::tr("Pressure");
+    STR_TR_BMI = QObject::tr("BMI");              // Short form of Body Mass Index
+    STR_TR_Weight = QObject::tr("Weight");
+    STR_TR_Zombie = QObject::tr("Zombie");
+    STR_TR_PulseRate = QObject::tr("Pulse Rate"); // Pulse / Heart rate
+    STR_TR_SpO2 = QObject::tr("SpO2");
+    STR_TR_Plethy = QObject::tr("Plethy");        // Plethysomogram
+    STR_TR_Pressure = QObject::tr("Pressure");
 
-    STR_TR_Daily=QObject::tr("Daily");
-    STR_TR_Overview=QObject::tr("Overview");
-    STR_TR_Oximetry=QObject::tr("Oximetry");
+    STR_TR_Daily = QObject::tr("Daily");
+    STR_TR_Overview = QObject::tr("Overview");
+    STR_TR_Oximetry = QObject::tr("Oximetry");
 
-    STR_TR_Oximeter=QObject::tr("Oximeter");
-    STR_TR_EventFlags=QObject::tr("Event Flags");
+    STR_TR_Oximeter = QObject::tr("Oximeter");
+    STR_TR_EventFlags = QObject::tr("Event Flags");
 
     // Machine type names.
-    STR_TR_CPAP=QObject::tr("CPAP");      // Constant Positive Airway Pressure
-    STR_TR_BIPAP=QObject::tr("BiPAP");    // Bi-Level Positive Airway Pressure
-    STR_TR_BiLevel=QObject::tr("Bi-Level"); // Another name for BiPAP
-    STR_TR_EPAP=QObject::tr("EPAP");      // Expiratory Positive Airway Pressure
-    STR_TR_EPAPLo=QObject::tr("Min EPAP"); // Lower Expiratory Positive Airway Pressure
-    STR_TR_EPAPHi=QObject::tr("Max EPAP"); // Higher Expiratory Positive Airway Pressure
-    STR_TR_IPAP=QObject::tr("IPAP");      // Inspiratory Positive Airway Pressure
-    STR_TR_IPAPLo=QObject::tr("Min IPAP");  // Lower Inspiratory Positive Airway Pressure
-    STR_TR_IPAPHi=QObject::tr("Max IPAP");  // Higher Inspiratory Positive Airway Pressure
-    STR_TR_APAP=QObject::tr("APAP");      // Automatic Positive Airway Pressure
-    STR_TR_ASV=QObject::tr("ASV");        // Assisted Servo Ventilator
-    STR_TR_STASV=QObject::tr("ST/ASV");
+    STR_TR_CPAP = QObject::tr("CPAP");    // Constant Positive Airway Pressure
+    STR_TR_BIPAP = QObject::tr("BiPAP");  // Bi-Level Positive Airway Pressure
+    STR_TR_BiLevel = QObject::tr("Bi-Level"); // Another name for BiPAP
+    STR_TR_EPAP = QObject::tr("EPAP");    // Expiratory Positive Airway Pressure
+    STR_TR_EPAPLo = QObject::tr("Min EPAP"); // Lower Expiratory Positive Airway Pressure
+    STR_TR_EPAPHi = QObject::tr("Max EPAP"); // Higher Expiratory Positive Airway Pressure
+    STR_TR_IPAP = QObject::tr("IPAP");    // Inspiratory Positive Airway Pressure
+    STR_TR_IPAPLo = QObject::tr("Min IPAP"); // Lower Inspiratory Positive Airway Pressure
+    STR_TR_IPAPHi = QObject::tr("Max IPAP"); // Higher Inspiratory Positive Airway Pressure
+    STR_TR_APAP = QObject::tr("APAP");    // Automatic Positive Airway Pressure
+    STR_TR_ASV = QObject::tr("ASV");      // Assisted Servo Ventilator
+    STR_TR_STASV = QObject::tr("ST/ASV");
 
-    STR_TR_Humidifier=QObject::tr("Humidifier");
+    STR_TR_Humidifier = QObject::tr("Humidifier");
 
-    STR_TR_H=QObject::tr("H");        // Short form of Hypopnea
-    STR_TR_OA=QObject::tr("OA");      // Short form of Obstructive Apnea
-    STR_TR_UA=QObject::tr("A");       // Short form of Unspecified Apnea
-    STR_TR_CA=QObject::tr("CA");      // Short form of Clear Airway Apnea
-    STR_TR_FL=QObject::tr("FL");      // Short form of Flow Limitation
-    STR_TR_LE=QObject::tr("LE");      // Short form of Leak Event
-    STR_TR_EP=QObject::tr("EP");      // Short form of Expiratory Puff
-    STR_TR_VS=QObject::tr("VS");      // Short form of Vibratory Snore
-    STR_TR_VS2=QObject::tr("VS2");    // Short form of Secondary Vibratory Snore (Some Philips Respironics Machines have two sources)
-    STR_TR_RERA=QObject::tr("RERA");  // Acronym for Respiratory Effort Related Arousal
-    STR_TR_PP=QObject::tr("PP");      // Short form for Pressure Pulse
-    STR_TR_P=QObject::tr("P");        // Short form for Pressure Event
-    STR_TR_RE=QObject::tr("RE");      // Short form of Respiratory Effort Related Arousal
-    STR_TR_NR=QObject::tr("NR");      // Short form of Non Responding event? (forgot sorry)
-    STR_TR_NRI=QObject::tr("NRI");    // Sorry I Forgot.. it's a flag on Intellipap machines
-    STR_TR_O2=QObject::tr("O2");      // SpO2 Desaturation
-    STR_TR_PC=QObject::tr("PC");      // Short form for Pulse Change
-    STR_TR_UF1=QObject::tr("UF1");      // Short form for User Flag 1
-    STR_TR_UF2=QObject::tr("UF2");      // Short form for User Flag 2
-    STR_TR_UF3=QObject::tr("UF3");      // Short form for User Flag 3
+    STR_TR_H = QObject::tr("H");      // Short form of Hypopnea
+    STR_TR_OA = QObject::tr("OA");    // Short form of Obstructive Apnea
+    STR_TR_UA = QObject::tr("A");     // Short form of Unspecified Apnea
+    STR_TR_CA = QObject::tr("CA");    // Short form of Clear Airway Apnea
+    STR_TR_FL = QObject::tr("FL");    // Short form of Flow Limitation
+    STR_TR_LE = QObject::tr("LE");    // Short form of Leak Event
+    STR_TR_EP = QObject::tr("EP");    // Short form of Expiratory Puff
+    STR_TR_VS = QObject::tr("VS");    // Short form of Vibratory Snore
+    STR_TR_VS2 =
+        QObject::tr("VS2");  // Short form of Secondary Vibratory Snore (Some Philips Respironics Machines have two sources)
+    STR_TR_RERA = QObject::tr("RERA"); // Acronym for Respiratory Effort Related Arousal
+    STR_TR_PP = QObject::tr("PP");    // Short form for Pressure Pulse
+    STR_TR_P = QObject::tr("P");      // Short form for Pressure Event
+    STR_TR_RE = QObject::tr("RE");    // Short form of Respiratory Effort Related Arousal
+    STR_TR_NR = QObject::tr("NR");    // Short form of Non Responding event? (forgot sorry)
+    STR_TR_NRI = QObject::tr("NRI");  // Sorry I Forgot.. it's a flag on Intellipap machines
+    STR_TR_O2 = QObject::tr("O2");    // SpO2 Desaturation
+    STR_TR_PC = QObject::tr("PC");    // Short form for Pulse Change
+    STR_TR_UF1 = QObject::tr("UF1");    // Short form for User Flag 1
+    STR_TR_UF2 = QObject::tr("UF2");    // Short form for User Flag 2
+    STR_TR_UF3 = QObject::tr("UF3");    // Short form for User Flag 3
 
 
 
-    STR_TR_PS=QObject::tr("PS");      // Short form of Pressure Support
-    STR_TR_AHI=QObject::tr("AHI");    // Short form of Apnea Hypopnea Index
-    STR_TR_RDI=QObject::tr("RDI");    // Short form of Respiratory Distress Index
-    STR_TR_AI=QObject::tr("AI");      // Short form of Apnea Index
-    STR_TR_HI=QObject::tr("HI");      // Short form of Hypopnea Index
-    STR_TR_UAI=QObject::tr("UAI");    // Short form of Uncatagorized Apnea Index
-    STR_TR_CAI=QObject::tr("CAI");    // Short form of Clear Airway Index
-    STR_TR_FLI=QObject::tr("FLI");    // Short form of Flow Limitation Index
-    STR_TR_REI=QObject::tr("REI");    // Short form of RERA Index
-    STR_TR_EPI=QObject::tr("EPI");    // Short form of Expiratory Puff Index
-    STR_TR_CSR=QObject::tr("ÇSR");    // Short form of Cheyne Stokes Respiration
-    STR_TR_PB=QObject::tr("PB");      // Short form of Periodic Breathing
+    STR_TR_PS = QObject::tr("PS");    // Short form of Pressure Support
+    STR_TR_AHI = QObject::tr("AHI");  // Short form of Apnea Hypopnea Index
+    STR_TR_RDI = QObject::tr("RDI");  // Short form of Respiratory Distress Index
+    STR_TR_AI = QObject::tr("AI");    // Short form of Apnea Index
+    STR_TR_HI = QObject::tr("HI");    // Short form of Hypopnea Index
+    STR_TR_UAI = QObject::tr("UAI");  // Short form of Uncatagorized Apnea Index
+    STR_TR_CAI = QObject::tr("CAI");  // Short form of Clear Airway Index
+    STR_TR_FLI = QObject::tr("FLI");  // Short form of Flow Limitation Index
+    STR_TR_REI = QObject::tr("REI");  // Short form of RERA Index
+    STR_TR_EPI = QObject::tr("EPI");  // Short form of Expiratory Puff Index
+    STR_TR_CSR = QObject::tr("ÇSR");  // Short form of Cheyne Stokes Respiration
+    STR_TR_PB = QObject::tr("PB");    // Short form of Periodic Breathing
 
 
     // Graph Titles
-    STR_TR_IE=QObject::tr("IE");      // Inspiratory Expiratory Ratio
-    STR_TR_InspTime=QObject::tr("Insp. Time");    // Inspiratory Time
-    STR_TR_ExpTime=QObject::tr("Exp. Time");      // Expiratory Time
-    STR_TR_RespEvent=QObject::tr("Resp. Event");    // Respiratory Event
-    STR_TR_FlowLimitation=QObject::tr("Flow Limitation");
-    STR_TR_FlowLimit=QObject::tr("Flow Limit");
-    STR_TR_PatTrigBreath=QObject::tr("Pat. Trig. Breath"); // Patient Triggered Breath
-    STR_TR_TgtMinVent=QObject::tr("Tgt. Min. Vent");        // Target Minute Ventilation
-    STR_TR_TargetVent=QObject::tr("Target Vent.");          // Target Ventilation
-    STR_TR_MinuteVent=QObject::tr("Minute Vent."); // Minute Ventilation
-    STR_TR_TidalVolume=QObject::tr("Tidal Volume");
-    STR_TR_RespRate=QObject::tr("Resp. Rate");    // Respiratory Rate
-    STR_TR_Snore=QObject::tr("Snore");
-    STR_TR_Leak=QObject::tr("Leak");
-    STR_TR_Leaks=QObject::tr("Leaks");
-    STR_TR_TotalLeaks=QObject::tr("Total Leaks");
-    STR_TR_UnintentionalLeaks=QObject::tr("Unintentional Leaks");
-    STR_TR_MaskPressure=QObject::tr("MaskPressure");
-    STR_TR_FlowRate=QObject::tr("Flow Rate");
-    STR_TR_SleepStage=QObject::tr("Sleep Stage");
-    STR_TR_Usage=QObject::tr("Usage");
-    STR_TR_Sessions=QObject::tr("Sessions");
-    STR_TR_PrRelief=QObject::tr("Pr. Relief"); // Pressure Relief
+    STR_TR_IE = QObject::tr("IE");    // Inspiratory Expiratory Ratio
+    STR_TR_InspTime = QObject::tr("Insp. Time");  // Inspiratory Time
+    STR_TR_ExpTime = QObject::tr("Exp. Time");    // Expiratory Time
+    STR_TR_RespEvent = QObject::tr("Resp. Event");  // Respiratory Event
+    STR_TR_FlowLimitation = QObject::tr("Flow Limitation");
+    STR_TR_FlowLimit = QObject::tr("Flow Limit");
+    STR_TR_PatTrigBreath = QObject::tr("Pat. Trig. Breath"); // Patient Triggered Breath
+    STR_TR_TgtMinVent = QObject::tr("Tgt. Min. Vent");      // Target Minute Ventilation
+    STR_TR_TargetVent = QObject::tr("Target Vent.");        // Target Ventilation
+    STR_TR_MinuteVent = QObject::tr("Minute Vent."); // Minute Ventilation
+    STR_TR_TidalVolume = QObject::tr("Tidal Volume");
+    STR_TR_RespRate = QObject::tr("Resp. Rate");  // Respiratory Rate
+    STR_TR_Snore = QObject::tr("Snore");
+    STR_TR_Leak = QObject::tr("Leak");
+    STR_TR_Leaks = QObject::tr("Leaks");
+    STR_TR_TotalLeaks = QObject::tr("Total Leaks");
+    STR_TR_UnintentionalLeaks = QObject::tr("Unintentional Leaks");
+    STR_TR_MaskPressure = QObject::tr("MaskPressure");
+    STR_TR_FlowRate = QObject::tr("Flow Rate");
+    STR_TR_SleepStage = QObject::tr("Sleep Stage");
+    STR_TR_Usage = QObject::tr("Usage");
+    STR_TR_Sessions = QObject::tr("Sessions");
+    STR_TR_PrRelief = QObject::tr("Pr. Relief"); // Pressure Relief
 
-    STR_TR_NoData=QObject::tr("No Data");
-    STR_TR_Bookmarks=QObject::tr("Bookmarks");
-    STR_TR_SleepyHead=QObject::tr("SleepyHead");
-    STR_TR_SleepyHeadVersion=STR_TR_SleepyHead+" v"+VersionString;
+    STR_TR_NoData = QObject::tr("No Data");
+    STR_TR_Bookmarks = QObject::tr("Bookmarks");
+    STR_TR_SleepyHead = QObject::tr("SleepyHead");
+    STR_TR_SleepyHeadVersion = STR_TR_SleepyHead + " v" + VersionString;
 
-    STR_TR_Mode=QObject::tr("Mode");
-    STR_TR_Model=QObject::tr("Model");
-    STR_TR_Brand=QObject::tr("Brand");
-    STR_TR_Serial=QObject::tr("Serial");
-    STR_TR_Machine=QObject::tr("Machine");
-    STR_TR_Channel=QObject::tr("Channel");
-    STR_TR_Settings=QObject::tr("Settings");
+    STR_TR_Mode = QObject::tr("Mode");
+    STR_TR_Model = QObject::tr("Model");
+    STR_TR_Brand = QObject::tr("Brand");
+    STR_TR_Serial = QObject::tr("Serial");
+    STR_TR_Machine = QObject::tr("Machine");
+    STR_TR_Channel = QObject::tr("Channel");
+    STR_TR_Settings = QObject::tr("Settings");
 
-    STR_TR_Inclination=QObject::tr("Inclination");
-    STR_TR_Orientation=QObject::tr("Orientation");
+    STR_TR_Inclination = QObject::tr("Inclination");
+    STR_TR_Orientation = QObject::tr("Orientation");
 
-    STR_TR_Name=QObject::tr("Name");
-    STR_TR_DOB=QObject::tr("DOB");    // Date of Birth
-    STR_TR_Phone=QObject::tr("Phone");
-    STR_TR_Address=QObject::tr("Address");
-    STR_TR_Email=QObject::tr("Email");
-    STR_TR_PatientID=QObject::tr("Patient ID");
-    STR_TR_Date=QObject::tr("Date");
+    STR_TR_Name = QObject::tr("Name");
+    STR_TR_DOB = QObject::tr("DOB");  // Date of Birth
+    STR_TR_Phone = QObject::tr("Phone");
+    STR_TR_Address = QObject::tr("Address");
+    STR_TR_Email = QObject::tr("Email");
+    STR_TR_PatientID = QObject::tr("Patient ID");
+    STR_TR_Date = QObject::tr("Date");
 
-    STR_TR_BedTime=QObject::tr("Bedtime");
-    STR_TR_WakeUp=QObject::tr("Wake-up");
-    STR_TR_MaskTime=QObject::tr("Mask Time");
-    STR_TR_Unknown=QObject::tr("Unknown");
-    STR_TR_None=QObject::tr("None");
-    STR_TR_Ready=QObject::tr("Ready");
+    STR_TR_BedTime = QObject::tr("Bedtime");
+    STR_TR_WakeUp = QObject::tr("Wake-up");
+    STR_TR_MaskTime = QObject::tr("Mask Time");
+    STR_TR_Unknown = QObject::tr("Unknown");
+    STR_TR_None = QObject::tr("None");
+    STR_TR_Ready = QObject::tr("Ready");
 
-    STR_TR_First=QObject::tr("First");
-    STR_TR_Last=QObject::tr("Last");
-    STR_TR_Start=QObject::tr("Start");
-    STR_TR_End=QObject::tr("End");
-    STR_TR_On=QObject::tr("On");
-    STR_TR_Off=QObject::tr("Off");
+    STR_TR_First = QObject::tr("First");
+    STR_TR_Last = QObject::tr("Last");
+    STR_TR_Start = QObject::tr("Start");
+    STR_TR_End = QObject::tr("End");
+    STR_TR_On = QObject::tr("On");
+    STR_TR_Off = QObject::tr("Off");
 
-    STR_TR_Min=QObject::tr("Min");    // Minimum
-    STR_TR_Max=QObject::tr("Max");    // Maximum
+    STR_TR_Min = QObject::tr("Min");  // Minimum
+    STR_TR_Max = QObject::tr("Max");  // Maximum
 
-    STR_TR_Average=QObject::tr("Average");
-    STR_TR_Median=QObject::tr("Median");
-    STR_TR_Avg=QObject::tr("Avg");        // Average
-    STR_TR_WAvg=QObject::tr("W-Avg");     // Weighted Average
+    STR_TR_Average = QObject::tr("Average");
+    STR_TR_Median = QObject::tr("Median");
+    STR_TR_Avg = QObject::tr("Avg");      // Average
+    STR_TR_WAvg = QObject::tr("W-Avg");   // Weighted Average
 }
diff --git a/sleepyhead/SleepLib/common.h b/sleepyhead/SleepLib/common.h
index 51329ea1..7c001263 100644
--- a/sleepyhead/SleepLib/common.h
+++ b/sleepyhead/SleepLib/common.h
@@ -28,11 +28,11 @@ enum UnitSystem { US_Undefined, US_Metric, US_Archiac };
 typedef float EventDataType;
 
 struct ValueCount {
-    ValueCount() { value=0; count=0; p=0; }
-    ValueCount(const ValueCount & copy) {
-        value=copy.value;
-        count=copy.count;
-        p=copy.p;
+    ValueCount() { value = 0; count = 0; p = 0; }
+    ValueCount(const ValueCount &copy) {
+        value = copy.value;
+        count = copy.count;
+        p = copy.p;
     }
     EventDataType value;
     qint64 count;
@@ -40,21 +40,21 @@ struct ValueCount {
 };
 
 // Primarily sort by value
-bool operator <(const ValueCount & a, const ValueCount & b);
+bool operator <(const ValueCount &a, const ValueCount &b);
 
-const float ounce_convert=28.3495231F; // grams
-const float pound_convert=ounce_convert*16;
+const float ounce_convert = 28.3495231F; // grams
+const float pound_convert = ounce_convert * 16;
 
-QString weightString(float kg, UnitSystem us=US_Undefined);
+QString weightString(float kg, UnitSystem us = US_Undefined);
 
 //! \brief Mercilessly trash a directory
-bool removeDir(const QString & path);
+bool removeDir(const QString &path);
 
 
 #ifdef UNSTABLE_BUILD
-const QString STR_Unstable="-Unstable";
+const QString STR_Unstable = "-Unstable";
 #else
-const QString STR_Unstable="";
+const QString STR_Unstable = "";
 #endif
 
 const QString getAppName();
@@ -68,44 +68,44 @@ void initializeStrings();
 // Preference Name Strings
 ///////////////////////////////////////////////////////////////////////////////////////////////
 
-const QString STR_GEN_Profile="Profile";
-const QString STR_GEN_SkipLogin="SkipLoginScreen";
-const QString STR_GEN_UpdatesLastChecked="UpdatesLastChecked";
-const QString STR_GEN_UpdatesAutoCheck="Updates_AutoCheck";
-const QString STR_GEN_UpdateCheckFrequency="Updates_CheckFrequency";
-const QString STR_GEN_DataFolder="DataFolder";
+const QString STR_GEN_Profile = "Profile";
+const QString STR_GEN_SkipLogin = "SkipLoginScreen";
+const QString STR_GEN_UpdatesLastChecked = "UpdatesLastChecked";
+const QString STR_GEN_UpdatesAutoCheck = "Updates_AutoCheck";
+const QString STR_GEN_UpdateCheckFrequency = "Updates_CheckFrequency";
+const QString STR_GEN_DataFolder = "DataFolder";
 
-const QString STR_GEN_On=QObject::tr("On");
-const QString STR_GEN_Off=QObject::tr("Off");
+const QString STR_GEN_On = QObject::tr("On");
+const QString STR_GEN_Off = QObject::tr("Off");
 
-const QString STR_PREF_AllowEarlyUpdates="AllowEarlyUpdates";
+const QString STR_PREF_AllowEarlyUpdates = "AllowEarlyUpdates";
 
-const QString STR_PROP_Brand="Brand";
-const QString STR_PROP_Model="Model";
-const QString STR_PROP_Series="Series";
-const QString STR_PROP_ModelNumber="ModelNumber";
-const QString STR_PROP_SubModel="SubModel";
-const QString STR_PROP_Serial="Serial";
-const QString STR_PROP_DataVersion="DataVersion";
-const QString STR_PROP_Path="Path";
-const QString STR_PROP_BackupPath="BackupPath";
-const QString STR_PROP_LastImported="LastImported";
+const QString STR_PROP_Brand = "Brand";
+const QString STR_PROP_Model = "Model";
+const QString STR_PROP_Series = "Series";
+const QString STR_PROP_ModelNumber = "ModelNumber";
+const QString STR_PROP_SubModel = "SubModel";
+const QString STR_PROP_Serial = "Serial";
+const QString STR_PROP_DataVersion = "DataVersion";
+const QString STR_PROP_Path = "Path";
+const QString STR_PROP_BackupPath = "BackupPath";
+const QString STR_PROP_LastImported = "LastImported";
 
-const QString STR_MACH_ResMed="ResMed";
-const QString STR_MACH_PRS1="PRS1";
-const QString STR_MACH_Journal="Journal";
-const QString STR_MACH_Intellipap="Intellipap";
-const QString STR_MACH_FPIcon="FPIcon";
-const QString STR_MACH_MSeries="MSeries";
-const QString STR_MACH_CMS50="CMS50";
-const QString STR_MACH_ZEO="Zeo";
+const QString STR_MACH_ResMed = "ResMed";
+const QString STR_MACH_PRS1 = "PRS1";
+const QString STR_MACH_Journal = "Journal";
+const QString STR_MACH_Intellipap = "Intellipap";
+const QString STR_MACH_FPIcon = "FPIcon";
+const QString STR_MACH_MSeries = "MSeries";
+const QString STR_MACH_CMS50 = "CMS50";
+const QString STR_MACH_ZEO = "Zeo";
 
-const QString STR_PREF_VersionString="VersionString";
-const QString STR_PREF_Language="Language";
+const QString STR_PREF_VersionString = "VersionString";
+const QString STR_PREF_Language = "Language";
 
-const QString STR_AppName="SleepyHead";
-const QString STR_DeveloperName="Jedimark";
-const QString STR_AppRoot="SleepyHeadData";
+const QString STR_AppName = "SleepyHead";
+const QString STR_DeveloperName = "Jedimark";
+const QString STR_AppRoot = "SleepyHeadData";
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 // Commonly used translatable text strings
@@ -167,7 +167,8 @@ extern QString STR_TR_FL;      // Short form of Flow Limitation
 extern QString STR_TR_LE;      // Short form of Leak Event
 extern QString STR_TR_EP;      // Short form of Expiratory Puff
 extern QString STR_TR_VS;      // Short form of Vibratory Snore
-extern QString STR_TR_VS2;     // Short form of Secondary Vibratory Snore (Some Philips Respironics Machines have two sources)
+extern QString
+STR_TR_VS2;     // Short form of Secondary Vibratory Snore (Some Philips Respironics Machines have two sources)
 extern QString STR_TR_RERA;    // Acronym for Respiratory Effort Related Arousal
 extern QString STR_TR_PP;      // Short form for Pressure Pulse
 extern QString STR_TR_P;       // Short form for Pressure Event
diff --git a/sleepyhead/SleepLib/day.cpp b/sleepyhead/SleepLib/day.cpp
index 528de188..cb007d6d 100644
--- a/sleepyhead/SleepLib/day.cpp
+++ b/sleepyhead/SleepLib/day.cpp
@@ -16,15 +16,16 @@
 #include <algorithm>
 
 Day::Day(Machine *m)
-:machine(m)
+    : machine(m)
 {
-    d_firstsession=true;
+    d_firstsession = true;
 }
 Day::~Day()
 {
     QList<Session *>::iterator s;
-    for (s=sessions.begin();s!=sessions.end();++s) {
-        delete (*s);
+
+    for (s = sessions.begin(); s != sessions.end(); ++s) {
+        delete(*s);
     }
 
 }
@@ -32,11 +33,14 @@ MachineType Day::machine_type()
 {
     return machine->GetType();
 }
-Session *Day::find(SessionID sessid) {
-    for (int i=0;i<size();i++) {
-        if (sessions[i]->session()==sessid)
+Session *Day::find(SessionID sessid)
+{
+    for (int i = 0; i < size(); i++) {
+        if (sessions[i]->session() == sessid) {
             return sessions[i];
+        }
     }
+
     return NULL;
 }
 
@@ -46,183 +50,209 @@ void Day::AddSession(Session *s)
         qWarning("Day::AddSession called with NULL session object");
         return;
     }
-//    if (d_firstsession) {
-//        d_firstsession=false;
-//        d_first=s->first();
-//        d_last=s->last();
-//    } else {
-//        if (d_first > s->first()) d_first = s->first();
-//        if (d_last < s->last()) d_last = s->last();
-//    }
+
+    //    if (d_firstsession) {
+    //        d_firstsession=false;
+    //        d_first=s->first();
+    //        d_last=s->last();
+    //    } else {
+    //        if (d_first > s->first()) d_first = s->first();
+    //        if (d_last < s->last()) d_last = s->last();
+    //    }
     sessions.push_back(s);
 }
 
 EventDataType Day::settings_sum(ChannelID code)
 {
-    EventDataType val=0;
+    EventDataType val = 0;
     QList<Session *>::iterator s;
-    for (s=sessions.begin();s!=sessions.end();s++) {
-        if (!(*s)->enabled()) continue;
 
-        Session & sess=*(*s);
-        QHash<ChannelID,QVariant>::iterator i=sess.settings.find(code);
-        if (i!=sess.settings.end()) {
-            val+=i.value().toDouble();
+    for (s = sessions.begin(); s != sessions.end(); s++) {
+        if (!(*s)->enabled()) { continue; }
+
+        Session &sess = *(*s);
+        QHash<ChannelID, QVariant>::iterator i = sess.settings.find(code);
+
+        if (i != sess.settings.end()) {
+            val += i.value().toDouble();
         }
     }
+
     return val;
 }
 
 EventDataType Day::settings_max(ChannelID code)
 {
-    EventDataType val=0,tmp;
+    EventDataType val = 0, tmp;
 
-    bool fir=true;
+    bool fir = true;
     QList<Session *>::iterator s;
-    for (s=sessions.begin();s!=sessions.end();s++) {
-        if (!(*s)->enabled())
-            continue;
 
-        Session & sess=*(*s);
-        QHash<ChannelID,QVariant>::iterator i=sess.settings.find(code);
-        if (i!=sess.settings.end()) {
-            tmp=i.value().toDouble();
+    for (s = sessions.begin(); s != sessions.end(); s++) {
+        if (!(*s)->enabled()) {
+            continue;
+        }
+
+        Session &sess = *(*s);
+        QHash<ChannelID, QVariant>::iterator i = sess.settings.find(code);
+
+        if (i != sess.settings.end()) {
+            tmp = i.value().toDouble();
+
             if (fir) {
-                val=tmp;
-                fir=false;
-            } else if (tmp>val) val=tmp;
+                val = tmp;
+                fir = false;
+            } else if (tmp > val) { val = tmp; }
         }
     }
+
     return val;
 }
 EventDataType Day::settings_min(ChannelID code)
 {
-    EventDataType val=0,tmp;
-    bool fir=true;
+    EventDataType val = 0, tmp;
+    bool fir = true;
     // Cache this?
 
     QList<Session *>::iterator s;
-    for (s=sessions.begin();s!=sessions.end();s++) {
-        if (!(*s)->enabled()) continue;
 
-        Session & sess=*(*s);
-        QHash<ChannelID,QVariant>::iterator i=sess.settings.find(code);
-        if (i!=sess.settings.end()) {
-            tmp=i.value().toDouble();
+    for (s = sessions.begin(); s != sessions.end(); s++) {
+        if (!(*s)->enabled()) { continue; }
+
+        Session &sess = *(*s);
+        QHash<ChannelID, QVariant>::iterator i = sess.settings.find(code);
+
+        if (i != sess.settings.end()) {
+            tmp = i.value().toDouble();
+
             if (fir) {
-                val=tmp;
-                fir=false;
+                val = tmp;
+                fir = false;
             } else {
-                if (val<tmp) val=tmp;
+                if (val < tmp) { val = tmp; }
             }
         }
     }
+
     return val;
 }
 
 EventDataType Day::settings_avg(ChannelID code)
 {
-    EventDataType val=0;
+    EventDataType val = 0;
 
-    int cnt=0;
+    int cnt = 0;
     QList<Session *>::iterator s;
-    for (s=sessions.begin();s!=sessions.end();s++) {
-        if (!(*s)->enabled()) continue;
 
-        Session & sess=*(*s);
-        QHash<ChannelID,QVariant>::iterator i=sess.settings.find(code);
-        if (i!=sess.settings.end()) {
-            val+=i.value().toDouble();
+    for (s = sessions.begin(); s != sessions.end(); s++) {
+        if (!(*s)->enabled()) { continue; }
+
+        Session &sess = *(*s);
+        QHash<ChannelID, QVariant>::iterator i = sess.settings.find(code);
+
+        if (i != sess.settings.end()) {
+            val += i.value().toDouble();
             cnt++;
         }
     }
-    val/=EventDataType(cnt);
+
+    val /= EventDataType(cnt);
     return val;
 }
 EventDataType Day::settings_wavg(ChannelID code)
 {
-    double s0=0,s1=0,s2=0,tmp;
-    for (QList<Session *>::iterator s=sessions.begin();s!=sessions.end();s++) {
-        if (!(*s)->enabled()) continue;
+    double s0 = 0, s1 = 0, s2 = 0, tmp;
 
-        Session & sess=*(*s);
+    for (QList<Session *>::iterator s = sessions.begin(); s != sessions.end(); s++) {
+        if (!(*s)->enabled()) { continue; }
 
-        QHash<ChannelID,QVariant>::iterator i=sess.settings.find(code);
-        if (i!=sess.settings.end()) {
-            s0=sess.hours();
-            tmp=i.value().toDouble();
-            s1+=tmp*s0;
-            s2+=s0;
+        Session &sess = *(*s);
+
+        QHash<ChannelID, QVariant>::iterator i = sess.settings.find(code);
+
+        if (i != sess.settings.end()) {
+            s0 = sess.hours();
+            tmp = i.value().toDouble();
+            s1 += tmp * s0;
+            s2 += s0;
         }
     }
-    if (s2==0) return 0;
-    tmp=(s1/s2);
+
+    if (s2 == 0) { return 0; }
+
+    tmp = (s1 / s2);
     return tmp;
 }
 
 
-EventDataType Day::percentile(ChannelID code,EventDataType percentile)
+EventDataType Day::percentile(ChannelID code, EventDataType percentile)
 {
-//    QHash<ChannelID, QHash<EventDataType, EventDataType> >::iterator pi;
-//    pi=perc_cache.find(code);
-//    if (pi!=perc_cache.end()) {
-//        QHash<EventDataType, EventDataType> & hsh=pi.value();
-//        QHash<EventDataType, EventDataType>::iterator hi=hsh.find(
-//        if (hi!=pi.value().end()) {
-//            return hi.value();
-//        }
-//    }
+    //    QHash<ChannelID, QHash<EventDataType, EventDataType> >::iterator pi;
+    //    pi=perc_cache.find(code);
+    //    if (pi!=perc_cache.end()) {
+    //        QHash<EventDataType, EventDataType> & hsh=pi.value();
+    //        QHash<EventDataType, EventDataType>::iterator hi=hsh.find(
+    //        if (hi!=pi.value().end()) {
+    //            return hi.value();
+    //        }
+    //    }
     // Cache this calculation?
 
     QList<Session *>::iterator s;
 
     QHash<EventStoreType, qint64> wmap;
 
-    qint64 SN=0;
+    qint64 SN = 0;
 
-    EventDataType lastgain=0, gain=0;
+    EventDataType lastgain = 0, gain = 0;
     // First Calculate count of all events
     bool timeweight;
 
-    for (s=sessions.begin();s!=sessions.end();s++) {
-        if (!(*s)->enabled()) continue;
+    for (s = sessions.begin(); s != sessions.end(); s++) {
+        if (!(*s)->enabled()) { continue; }
 
-        Session & sess=*(*s);
-        QHash<ChannelID,QHash<EventStoreType, EventStoreType> > ::iterator ei=sess.m_valuesummary.find(code);
-        if (ei==sess.m_valuesummary.end()) continue;
+        Session &sess = *(*s);
+        QHash<ChannelID, QHash<EventStoreType, EventStoreType> > ::iterator ei = sess.m_valuesummary.find(
+                    code);
 
-        QHash<ChannelID,QHash<EventStoreType, quint32> > ::iterator tei=sess.m_timesummary.find(code);
-        timeweight=(tei!=sess.m_timesummary.end());
-        gain=sess.m_gain[code];
+        if (ei == sess.m_valuesummary.end()) { continue; }
+
+        QHash<ChannelID, QHash<EventStoreType, quint32> > ::iterator tei = sess.m_timesummary.find(code);
+        timeweight = (tei != sess.m_timesummary.end());
+        gain = sess.m_gain[code];
 
         // Here's assuming gains don't change accross a days sessions
         // Can't assume this in any multi day calculations..
-        if  (lastgain>0) {
-            if (gain!=lastgain) {
+        if (lastgain > 0) {
+            if (gain != lastgain) {
                 qDebug() << "Gains differ across sessions: " << gain << lastgain;
             }
         }
-        lastgain=gain;
+
+        lastgain = gain;
 
         int value;
         qint64 weight;
+
         //qint64 tval;
         if (timeweight) {
-            for (QHash<EventStoreType, quint32>::iterator i=tei.value().begin();i!=tei.value().end();i++) {
-                value=i.key();
-                weight=i.value();
-                SN+=weight;
-                wmap[value]+=weight;
+            for (QHash<EventStoreType, quint32>::iterator i = tei.value().begin(); i != tei.value().end();
+                    i++) {
+                value = i.key();
+                weight = i.value();
+                SN += weight;
+                wmap[value] += weight;
             }
         } else {
-            for (QHash<EventStoreType, EventStoreType>::iterator i=ei.value().begin();i!=ei.value().end();i++) {
+            for (QHash<EventStoreType, EventStoreType>::iterator i = ei.value().begin(); i != ei.value().end();
+                    i++) {
 
-                value=i.key();
-                weight=i.value();
+                value = i.key();
+                weight = i.value();
 
-                SN+=weight;
+                SN += weight;
 
-                wmap[value]+=weight;
+                wmap[value] += weight;
             }
         }
     }
@@ -230,182 +260,201 @@ EventDataType Day::percentile(ChannelID code,EventDataType percentile)
     QVector<ValueCount> valcnt;
 
     // Build sorted list of value/counts
-    for (QHash<EventStoreType, qint64>::iterator n=wmap.begin();n!=wmap.end();n++) {
+    for (QHash<EventStoreType, qint64>::iterator n = wmap.begin(); n != wmap.end(); n++) {
         ValueCount vc;
-        vc.value=EventDataType(n.key()) * gain;
-        vc.count=n.value();
-        vc.p=0;
+        vc.value = EventDataType(n.key()) * gain;
+        vc.count = n.value();
+        vc.p = 0;
         valcnt.push_back(vc);
     }
+
     // sort by weight, then value
     qSort(valcnt);
 
     //double SN=100.0/double(N); // 100% / overall sum
-    double p=100.0*percentile;
+    double p = 100.0 * percentile;
 
-    double nth=double(SN)*percentile; // index of the position in the unweighted set would be
-    double nthi=floor(nth);
+    double nth = double(SN) * percentile; // index of the position in the unweighted set would be
+    double nthi = floor(nth);
 
-    qint64 sum1=0,sum2=0;
-    qint64 w1,w2=0;
-    double v1=0,v2;
+    qint64 sum1 = 0, sum2 = 0;
+    qint64 w1, w2 = 0;
+    double v1 = 0, v2;
 
-    int N=valcnt.size();
-    int k=0;
+    int N = valcnt.size();
+    int k = 0;
 
-    for (k=0;k < N;k++) {
-        v1=valcnt[k].value;
-        w1=valcnt[k].count;
-        sum1+=w1;
+    for (k = 0; k < N; k++) {
+        v1 = valcnt[k].value;
+        w1 = valcnt[k].count;
+        sum1 += w1;
 
         if (sum1 > nthi) {
             return v1;
         }
-        if (sum1 == nthi){
+
+        if (sum1 == nthi) {
             break; // boundary condition
         }
     }
-    if (k>=N)
-        return v1;
 
-    v2=valcnt[k+1].value;
-    w2=valcnt[k+1].count;
-    sum2=sum1+w2;
+    if (k >= N) {
+        return v1;
+    }
+
+    v2 = valcnt[k + 1].value;
+    w2 = valcnt[k + 1].count;
+    sum2 = sum1 + w2;
     // value lies between v1 and v2
 
-    double px=100.0/double(SN); // Percentile represented by one full value
+    double px = 100.0 / double(SN); // Percentile represented by one full value
 
     // calculate percentile ranks
-    double p1=px * (double(sum1)-(double(w1)/2.0));
-    double p2=px * (double(sum2)-(double(w2)/2.0));
+    double p1 = px * (double(sum1) - (double(w1) / 2.0));
+    double p2 = px * (double(sum2) - (double(w2) / 2.0));
 
     // calculate linear interpolation
-    double v=v1 + ((p-p1)/(p2-p1)) * (v2-v1);
+    double v = v1 + ((p - p1) / (p2 - p1)) * (v2 - v1);
 
     return v;
 
-//                p1.....p.............p2
-//                37     55            70
+    //                p1.....p.............p2
+    //                37     55            70
 
 }
 
 EventDataType Day::p90(ChannelID code)
 {
-    return percentile(code,0.90);
+    return percentile(code, 0.90);
 }
 
 EventDataType Day::avg(ChannelID code)
 {
-    double val=0;
+    double val = 0;
     // Cache this?
-    int cnt=0;
+    int cnt = 0;
     QList<Session *>::iterator s;
 
     // Don't assume sessions are in order.
-    for (s=sessions.begin();s!=sessions.end();s++) {
-        if (!(*s)->enabled()) continue;
+    for (s = sessions.begin(); s != sessions.end(); s++) {
+        if (!(*s)->enabled()) { continue; }
+
+        Session &sess = *(*s);
 
-        Session & sess=*(*s);
         if (sess.m_avg.contains(code)) {
-            val+=sess.avg(code);
+            val += sess.avg(code);
             cnt++;
         }
     }
-    if (cnt==0) return 0;
-    return EventDataType(val/float(cnt));
+
+    if (cnt == 0) { return 0; }
+
+    return EventDataType(val / float(cnt));
 }
 
 EventDataType Day::sum(ChannelID code)
 {
     // Cache this?
-    EventDataType val=0;
+    EventDataType val = 0;
     QList<Session *>::iterator s;
 
-    for (s=sessions.begin();s!=sessions.end();s++) {
-        if (!(*s)->enabled()) continue;
+    for (s = sessions.begin(); s != sessions.end(); s++) {
+        if (!(*s)->enabled()) { continue; }
+
+        Session &sess = *(*s);
 
-        Session & sess=*(*s);
         if (sess.m_sum.contains(code)) {
-            val+=sess.sum(code);
+            val += sess.sum(code);
         }
     }
+
     return val;
 }
 
 EventDataType Day::wavg(ChannelID code)
 {
-    double s0=0,s1=0,s2=0;
+    double s0 = 0, s1 = 0, s2 = 0;
     qint64 d;
-    for (QList<Session *>::iterator s=sessions.begin();s!=sessions.end();s++) {
-        if (!(*s)->enabled()) continue;
 
-        Session & sess=*(*s);
+    for (QList<Session *>::iterator s = sessions.begin(); s != sessions.end(); s++) {
+        if (!(*s)->enabled()) { continue; }
+
+        Session &sess = *(*s);
 
         if (sess.m_wavg.contains(code)) {
-            d=sess.length();//.last(code)-sess.first(code);
-            s0=double(d)/3600000.0;
-            if (s0>0) {
-                s1+=sess.wavg(code)*s0;
-                s2+=s0;
+            d = sess.length(); //.last(code)-sess.first(code);
+            s0 = double(d) / 3600000.0;
+
+            if (s0 > 0) {
+                s1 += sess.wavg(code) * s0;
+                s2 += s0;
             }
         }
     }
-    if (s2==0)
-        return 0;
 
-    return (s1/s2);
+    if (s2 == 0) {
+        return 0;
+    }
+
+    return (s1 / s2);
 }
 // Total session time in milliseconds
 qint64 Day::total_time()
 {
-    qint64 d_totaltime=0;
+    qint64 d_totaltime = 0;
     // Sessions may overlap.. :(
-    QMultiMap<qint64,bool> range;
+    QMultiMap<qint64, bool> range;
 
     //range.reserve(size()*2);
 
-    for (QList<Session *>::iterator s=begin();s!=end();s++) {
-        if (!(*s)->enabled()) continue;
+    for (QList<Session *>::iterator s = begin(); s != end(); s++) {
+        if (!(*s)->enabled()) { continue; }
 
-        Session & sess=*(*s);
-        range.insert(sess.first(),0);
-        range.insert(sess.last(),1);
-        d_totaltime+=sess.length();
+        Session &sess = *(*s);
+        range.insert(sess.first(), 0);
+        range.insert(sess.last(), 1);
+        d_totaltime += sess.length();
     }
 
-    qint64 ti=0;
+    qint64 ti = 0;
     bool b;
-    int nest=0;
-    qint64 total=0;
+    int nest = 0;
+    qint64 total = 0;
+
     // This is my implementation of a typical "brace counting" algorithm mentioned here:
     // http://stackoverflow.com/questions/7468948/problem-calculating-overlapping-date-ranges
-    for (QMultiMap<qint64,bool>::iterator it=range.begin();it!=range.end();it++) {
-        b=it.value();
+    for (QMultiMap<qint64, bool>::iterator it = range.begin(); it != range.end(); it++) {
+        b = it.value();
+
         if (!b) {
-            if (!ti) ti=it.key();
+            if (!ti) { ti = it.key(); }
+
             nest++;
         } else {
             if (--nest <= 0) {
-                total+=it.key()-ti;
-                ti=0;
+                total += it.key() - ti;
+                ti = 0;
             }
         }
     }
 
-    if (total!=d_totaltime) {
+    if (total != d_totaltime) {
         qDebug() << "Sessions Times overlaps!" << total << d_totaltime;
     }
+
     return total; //d_totaltime;
 }
 bool Day::hasEnabledSessions()
 {
-    bool b=false;
-    for (QList<Session *>::iterator s=begin();s!=end();s++) {
+    bool b = false;
+
+    for (QList<Session *>::iterator s = begin(); s != end(); s++) {
         if ((*s)->enabled()) {
-            b=true;
+            b = true;
             break;
         }
     }
+
     return b;
 }
 
@@ -428,272 +477,334 @@ bool Day::hasEnabledSessions()
 
 qint64 Day::first(ChannelID code)
 {
-    qint64 date=0;
+    qint64 date = 0;
     qint64 tmp;
 
-    for (QList<Session *>::iterator s=sessions.begin();s!=sessions.end();s++) {
-        if (!(*s)->enabled()) continue;
-        tmp=(*s)->first(code);
-        if (!tmp) continue;
+    for (QList<Session *>::iterator s = sessions.begin(); s != sessions.end(); s++) {
+        if (!(*s)->enabled()) { continue; }
+
+        tmp = (*s)->first(code);
+
+        if (!tmp) { continue; }
+
         if (!date) {
-            date=tmp;
+            date = tmp;
         } else {
-            if (tmp<date) date=tmp;
+            if (tmp < date) { date = tmp; }
         }
     }
+
     return date;
 }
 
 qint64 Day::last(ChannelID code)
 {
-    qint64 date=0;
+    qint64 date = 0;
     qint64 tmp;
 
-    for (QList<Session *>::iterator s=sessions.begin();s!=sessions.end();s++) {
-        if (!(*s)->enabled()) continue;
-        tmp=(*s)->last(code);
-        if (!tmp) continue;
+    for (QList<Session *>::iterator s = sessions.begin(); s != sessions.end(); s++) {
+        if (!(*s)->enabled()) { continue; }
+
+        tmp = (*s)->last(code);
+
+        if (!tmp) { continue; }
+
         if (!date) {
-            date=tmp;
+            date = tmp;
         } else {
-            if (tmp>date) date=tmp;
+            if (tmp > date) { date = tmp; }
         }
     }
+
     return date;
 }
 
 EventDataType Day::Min(ChannelID code)
 {
-    EventDataType min=0;
+    EventDataType min = 0;
     EventDataType tmp;
-    bool first=true;
-    for (QList<Session *>::iterator s=sessions.begin();s!=sessions.end();s++) {
-        if (!(*s)->enabled()) continue;
+    bool first = true;
 
-        if (!(*s)->m_min.contains(code))
+    for (QList<Session *>::iterator s = sessions.begin(); s != sessions.end(); s++) {
+        if (!(*s)->enabled()) { continue; }
+
+        if (!(*s)->m_min.contains(code)) {
             continue;
-        tmp=(*s)->Min(code);
+        }
+
+        tmp = (*s)->Min(code);
+
         if (first) {
-            min=tmp;
-            first=false;
+            min = tmp;
+            first = false;
         } else {
-            if (tmp<min) min=tmp;
+            if (tmp < min) { min = tmp; }
         }
     }
+
     return min;
 }
 
 EventDataType Day::physMin(ChannelID code)
 {
-    EventDataType min=0;
+    EventDataType min = 0;
     EventDataType tmp;
-    bool first=true;
-    for (QList<Session *>::iterator s=sessions.begin();s!=sessions.end();s++) {
-        if (!(*s)->enabled()) continue;
+    bool first = true;
+
+    for (QList<Session *>::iterator s = sessions.begin(); s != sessions.end(); s++) {
+        if (!(*s)->enabled()) { continue; }
 
         // MW: I meant to check this instead.
-        if (!(*s)->m_min.contains(code))
+        if (!(*s)->m_min.contains(code)) {
             continue;
+        }
+
+        tmp = (*s)->physMin(code);
 
-        tmp=(*s)->physMin(code);
         if (first) {
-            min=tmp;
-            first=false;
+            min = tmp;
+            first = false;
         } else {
-            if (tmp<min) min=tmp;
+            if (tmp < min) { min = tmp; }
         }
     }
+
     return min;
 }
 
 bool Day::hasData(ChannelID code, SummaryType type)
 {
-    bool has=false;
-    for (QList<Session *>::iterator s=sessions.begin();s!=sessions.end();s++) {
-        if (!(*s)->enabled()) continue;
-        Session *sess=*s;
-        switch(type) {
-//        case ST_90P:
-//            has=sess->m_90p.contains(code);
-//            break;
+    bool has = false;
+
+    for (QList<Session *>::iterator s = sessions.begin(); s != sessions.end(); s++) {
+        if (!(*s)->enabled()) { continue; }
+
+        Session *sess = *s;
+
+        switch (type) {
+        //        case ST_90P:
+        //            has=sess->m_90p.contains(code);
+        //            break;
         case ST_PERC:
-            has=sess->m_valuesummary.contains(code);
+            has = sess->m_valuesummary.contains(code);
             break;
+
         case ST_MIN:
-            has=sess->m_min.contains(code);
+            has = sess->m_min.contains(code);
             break;
+
         case ST_MAX:
-            has=sess->m_max.contains(code);
+            has = sess->m_max.contains(code);
             break;
+
         case ST_CNT:
-            has=sess->m_cnt.contains(code);
+            has = sess->m_cnt.contains(code);
             break;
+
         case ST_AVG:
-            has=sess->m_avg.contains(code);
+            has = sess->m_avg.contains(code);
             break;
+
         case ST_WAVG:
-            has=sess->m_wavg.contains(code);
+            has = sess->m_wavg.contains(code);
             break;
+
         case ST_CPH:
-            has=sess->m_cph.contains(code);
+            has = sess->m_cph.contains(code);
             break;
+
         case ST_SPH:
-            has=sess->m_sph.contains(code);
+            has = sess->m_sph.contains(code);
             break;
+
         case ST_FIRST:
-            has=sess->m_firstchan.contains(code);
+            has = sess->m_firstchan.contains(code);
             break;
+
         case ST_LAST:
-            has=sess->m_lastchan.contains(code);
+            has = sess->m_lastchan.contains(code);
             break;
+
         case ST_SUM:
-            has=sess->m_sum.contains(code);
+            has = sess->m_sum.contains(code);
             break;
+
         default:
             break;
         }
 
-        if (has) break;
+        if (has) { break; }
     }
+
     return has;
 }
 
 EventDataType Day::Max(ChannelID code)
 {
-    EventDataType max=0;
+    EventDataType max = 0;
     EventDataType tmp;
-    bool first=true;
-    for (QList<Session *>::iterator s=sessions.begin();s!=sessions.end();s++) {
-        if (!(*s)->enabled()) continue;
+    bool first = true;
+
+    for (QList<Session *>::iterator s = sessions.begin(); s != sessions.end(); s++) {
+        if (!(*s)->enabled()) { continue; }
+
+        if (!(*s)->m_max.contains(code)) { continue; }
+
+        //        if ((*s)->eventlist.find(code)==(*s)->eventlist.end()) continue;
+        tmp = (*s)->Max(code);
 
-        if (!(*s)->m_max.contains(code)) continue;
-//        if ((*s)->eventlist.find(code)==(*s)->eventlist.end()) continue;
-        tmp=(*s)->Max(code);
         if (first) {
-            max=tmp;
-            first=false;
+            max = tmp;
+            first = false;
         } else {
-            if (tmp>max) max=tmp;
+            if (tmp > max) { max = tmp; }
         }
     }
+
     return max;
 }
 
 EventDataType Day::physMax(ChannelID code)
 {
-    EventDataType max=0;
+    EventDataType max = 0;
     EventDataType tmp;
-    bool first=true;
-    for (QList<Session *>::iterator s=sessions.begin();s!=sessions.end();s++) {
-        if (!(*s)->enabled())
+    bool first = true;
+
+    for (QList<Session *>::iterator s = sessions.begin(); s != sessions.end(); s++) {
+        if (!(*s)->enabled()) {
             continue;
+        }
 
         // MW: I meant to check this instead.
-        if (!(*s)->m_max.contains(code))
+        if (!(*s)->m_max.contains(code)) {
             continue;
+        }
+
+        tmp = (*s)->physMax(code);
 
-        tmp=(*s)->physMax(code);
         if (first) {
-            max=tmp;
-            first=false;
+            max = tmp;
+            first = false;
         } else {
-            if (tmp>max) max=tmp;
+            if (tmp > max) { max = tmp; }
         }
     }
+
     return max;
 }
 EventDataType Day::cph(ChannelID code)
 {
-    double sum=0;
+    double sum = 0;
+
     //EventDataType h=0;
-    for (int i=0;i<sessions.size();i++) {
-        if (!sessions[i]->enabled()) continue;
-        if (!sessions[i]->m_cnt.contains(code)) continue;
-        sum+=sessions[i]->count(code);
+    for (int i = 0; i < sessions.size(); i++) {
+        if (!sessions[i]->enabled()) { continue; }
+
+        if (!sessions[i]->m_cnt.contains(code)) { continue; }
+
+        sum += sessions[i]->count(code);
         //h+=sessions[i]->hours();
     }
-    sum/=hours();
+
+    sum /= hours();
     return sum;
 }
 
 EventDataType Day::sph(ChannelID code)
 {
-    EventDataType sum=0;
-    EventDataType h=0;
-    for (int i=0;i<sessions.size();i++) {
-        if (!sessions[i]->enabled()) continue;
-        if (!sessions[i]->m_sum.contains(code)) continue;
-        sum+=sessions[i]->sum(code)/3600.0;//*sessions[i]->hours();
+    EventDataType sum = 0;
+    EventDataType h = 0;
+
+    for (int i = 0; i < sessions.size(); i++) {
+        if (!sessions[i]->enabled()) { continue; }
+
+        if (!sessions[i]->m_sum.contains(code)) { continue; }
+
+        sum += sessions[i]->sum(code) / 3600.0; //*sessions[i]->hours();
         //h+=sessions[i]->hours();
     }
-    h=hours();
-    sum=(100.0/h)*sum;
+
+    h = hours();
+    sum = (100.0 / h) * sum;
     return sum;
 }
 
 int Day::count(ChannelID code)
 {
-    int sum=0;
-    for (int i=0;i<sessions.size();i++) {
-        if (!sessions[i]->enabled()) continue;
-        sum+=sessions[i]->count(code);
+    int sum = 0;
+
+    for (int i = 0; i < sessions.size(); i++) {
+        if (!sessions[i]->enabled()) { continue; }
+
+        sum += sessions[i]->count(code);
     }
+
     return sum;
 }
 bool Day::settingExists(ChannelID id)
 {
-    for (int j=0;j<sessions.size();j++) {
-        if (!sessions[j]->enabled()) continue;
-        QHash<ChannelID,QVariant>::iterator i=sessions[j]->settings.find(id);
-        if (i!=sessions[j]->settings.end()) {
+    for (int j = 0; j < sessions.size(); j++) {
+        if (!sessions[j]->enabled()) { continue; }
+
+        QHash<ChannelID, QVariant>::iterator i = sessions[j]->settings.find(id);
+
+        if (i != sessions[j]->settings.end()) {
             return true;
         }
     }
+
     return false;
 }
 bool Day::eventsLoaded()
 {
-    bool r=false;
-    for (int i=0;i<sessions.size();i++) {
+    bool r = false;
+
+    for (int i = 0; i < sessions.size(); i++) {
         if (sessions[i]->eventsLoaded()) {
-            r=true;
+            r = true;
             break;
         }
     }
+
     return r;
 }
 
 bool Day::channelExists(ChannelID id)
 {
-    bool r=false;
-    for (int i=0;i<sessions.size();i++) {
-        if (!sessions[i]->enabled()) continue;
+    bool r = false;
+
+    for (int i = 0; i < sessions.size(); i++) {
+        if (!sessions[i]->enabled()) { continue; }
 
         if (sessions[i]->eventlist.contains(id)) {
-            r=true;
+            r = true;
             break;
         }
     }
+
     return r;
-//    return channelHasData(id);
+    //    return channelHasData(id);
     //if (machine->hasChannel(id)) return true;
     //return false;
 }
 bool Day::channelHasData(ChannelID id)
 {
-    bool r=false;
-    for (int i=0;i<sessions.size();i++) {
-        if (!sessions[i]->enabled()) continue;
+    bool r = false;
+
+    for (int i = 0; i < sessions.size(); i++) {
+        if (!sessions[i]->enabled()) { continue; }
 
         if (sessions[i]->channelExists(id)) {
-            r=true;
+            r = true;
             break;
         }
+
         if (sessions[i]->m_valuesummary.contains(id)) {
-            r=true;
+            r = true;
             break;
         }
     }
+
     return r;
 }
 
@@ -701,7 +812,7 @@ void Day::OpenEvents()
 {
     QList<Session *>::iterator s;
 
-    for (s=sessions.begin();s!=sessions.end();s++) {
+    for (s = sessions.begin(); s != sessions.end(); s++) {
         (*s)->OpenEvents();
     }
 }
@@ -709,53 +820,61 @@ void Day::CloseEvents()
 {
     QList<Session *>::iterator s;
 
-    for (s=sessions.begin();s!=sessions.end();s++) {
+    for (s = sessions.begin(); s != sessions.end(); s++) {
         (*s)->TrashEvents();
     }
 }
 
 qint64 Day::first()
 {
-    qint64 date=0;
+    qint64 date = 0;
     qint64 tmp;
 
-    for (QList<Session *>::iterator s=sessions.begin();s!=sessions.end();s++) {
-        if (!(*s)->enabled()) continue;
-        tmp=(*s)->first();
-        if (!tmp) continue;
+    for (QList<Session *>::iterator s = sessions.begin(); s != sessions.end(); s++) {
+        if (!(*s)->enabled()) { continue; }
+
+        tmp = (*s)->first();
+
+        if (!tmp) { continue; }
+
         if (!date) {
-            date=tmp;
+            date = tmp;
         } else {
-            if (tmp<date) date=tmp;
+            if (tmp < date) { date = tmp; }
         }
     }
+
     return date;
-//    return d_first;
+    //    return d_first;
 }
 
 //! \brief Returns the last session time of this day
 qint64 Day::last()
 {
-    qint64 date=0;
+    qint64 date = 0;
     qint64 tmp;
 
-    for (QList<Session *>::iterator s=sessions.begin();s!=sessions.end();s++) {
-        if (!(*s)->enabled()) continue;
-        tmp=(*s)->last();
-        if (!tmp) continue;
+    for (QList<Session *>::iterator s = sessions.begin(); s != sessions.end(); s++) {
+        if (!(*s)->enabled()) { continue; }
+
+        tmp = (*s)->last();
+
+        if (!tmp) { continue; }
+
         if (!date) {
-            date=tmp;
+            date = tmp;
         } else {
-            if (tmp>date) date=tmp;
+            if (tmp > date) { date = tmp; }
         }
     }
+
     return date;
-//    return d_last;
+    //    return d_last;
 }
 
-void Day::removeSession(Session * sess)
+void Day::removeSession(Session *sess)
 {
-    if (sessions.removeAll(sess)<1) {
-//        int i=5;
+    if (sessions.removeAll(sess) < 1) {
+        //        int i=5;
     }
 }
diff --git a/sleepyhead/SleepLib/day.h b/sleepyhead/SleepLib/day.h
index 4bae703e..52098d3e 100644
--- a/sleepyhead/SleepLib/day.h
+++ b/sleepyhead/SleepLib/day.h
@@ -33,7 +33,7 @@ class Session;
     */
 class Day
 {
-public:
+  public:
     Day(Machine *m);
     ~Day();
 
@@ -77,7 +77,7 @@ public:
     EventDataType wavg(ChannelID code);
 
     //! \brief Returns a requested Percentile of all this sessions' events for this day
-    EventDataType percentile(ChannelID code,EventDataType percentile);
+    EventDataType percentile(ChannelID code, EventDataType percentile);
 
     //! \brief Returns if the cache contains SummaryType information about the requested code
     bool hasData(ChannelID code, SummaryType type);
@@ -122,7 +122,7 @@ public:
     bool hasEnabledSessions();
 
     //! \brief Return the total time in decimal hours for this day
-    EventDataType hours() { return double(total_time())/3600000.0; }
+    EventDataType hours() { return double(total_time()) / 3600000.0; }
 
     //! \brief Return the session indexed by i
     Session *operator [](int i) { return sessions[i]; }
@@ -133,7 +133,7 @@ public:
     QList<Session *>::iterator end() { return sessions.end(); }
 
     //! \brief Finds and returns the index of a session, otherwise -1 if it's not there
-    int find(Session * sess) { return sessions.indexOf(sess); }
+    int find(Session *sess) { return sessions.indexOf(sess); }
 
     Session *find(SessionID sessid);
 
@@ -149,7 +149,7 @@ public:
     void CloseEvents();
 
     //! \brief Returns this days sessions list
-    QList<Session *> & getSessions() { return sessions; }
+    QList<Session *> &getSessions() { return sessions; }
 
     //! \brief Returns true if this Day contains loaded Event Data for this channel.
     bool channelExists(ChannelID id);
@@ -163,14 +163,14 @@ public:
     //! \brief Returns true if this day contains the supplied settings Channel id
     bool settingExists(ChannelID id);
 
-    void removeSession(Session * sess);
+    void removeSession(Session *sess);
 
-protected:
+  protected:
     //! \brief A Vector containing all sessions for this day
     QList<Session *> sessions;
     QHash<ChannelID, QHash<EventDataType, EventDataType> > perc_cache;
     //qint64 d_first,d_last;
-private:
+  private:
     bool d_firstsession;
 };
 
diff --git a/sleepyhead/SleepLib/event.cpp b/sleepyhead/SleepLib/event.cpp
index 20aa29f1..7499984f 100644
--- a/sleepyhead/SleepLib/event.cpp
+++ b/sleepyhead/SleepLib/event.cpp
@@ -12,19 +12,21 @@
 #include <QDebug>
 #include "event.h"
 
-EventList::EventList(EventListType et,EventDataType gain, EventDataType offset, EventDataType min, EventDataType max,double rate,bool second_field)
-    :m_type(et),m_gain(gain),m_offset(offset),m_min(min),m_max(max),m_rate(rate),m_second_field(second_field)
+EventList::EventList(EventListType et, EventDataType gain, EventDataType offset, EventDataType min,
+                     EventDataType max, double rate, bool second_field)
+    : m_type(et), m_gain(gain), m_offset(offset), m_min(min), m_max(max), m_rate(rate),
+      m_second_field(second_field)
 {
-    m_first=m_last=0;
-    m_count=0;
+    m_first = m_last = 0;
+    m_count = 0;
 
-    if (min==max) {  // Update Min & Max unless forceably set here..
-        m_update_minmax=true;
-        m_min2=m_min=999999999;
-        m_max2=m_max=-999999999;
+    if (min == max) { // Update Min & Max unless forceably set here..
+        m_update_minmax = true;
+        m_min2 = m_min = 999999999;
+        m_max2 = m_max = -999999999;
 
     } else {
-        m_update_minmax=false;
+        m_update_minmax = false;
     }
 
     m_data.reserve(2048);
@@ -36,11 +38,11 @@ EventList::~EventList()
 }
 void EventList::clear()
 {
-    m_min2=m_min=999999999;
-    m_max2=m_max=-999999999;
-    m_update_minmax=true;
-    m_first=m_last=0;
-    m_count=0;
+    m_min2 = m_min = 999999999;
+    m_max2 = m_max = -999999999;
+    m_update_minmax = true;
+    m_first = m_last = 0;
+    m_count = 0;
 
     m_data.clear();
     m_data2.clear();
@@ -50,16 +52,16 @@ void EventList::clear()
 
 qint64 EventList::time(quint32 i)
 {
-    if (m_type==EVL_Event) {
-        return m_first+qint64(m_time[i]);
+    if (m_type == EVL_Event) {
+        return m_first + qint64(m_time[i]);
     }
 
-    return m_first+qint64((EventDataType(i)*m_rate));
+    return m_first + qint64((EventDataType(i) * m_rate));
 }
 
 EventDataType EventList::data(quint32 i)
 {
-    return EventDataType(m_data[i])*m_gain;
+    return EventDataType(m_data[i]) * m_gain;
 }
 EventDataType EventList::data2(quint32 i)
 {
@@ -71,35 +73,41 @@ void EventList::AddEvent(qint64 time, EventStoreType data)
     m_data.push_back(data);
 
     // Apply gain & offset
-    EventDataType val=EventDataType(data)*m_gain; // ignoring m_offset
+    EventDataType val = EventDataType(data) * m_gain; // ignoring m_offset
 
     if (m_update_minmax) {
-        if (m_count==0) {
-            m_max=m_min=val;
+        if (m_count == 0) {
+            m_max = m_min = val;
         } else {
-            if (m_min>val) m_min=val;
-            if (m_max<val) m_max=val;
+            if (m_min > val) { m_min = val; }
+
+            if (m_max < val) { m_max = val; }
         }
     }
 
     if (!m_first) {
-        m_first=time;
-        m_last=time;
+        m_first = time;
+        m_last = time;
     }
-    if (m_first>time) {
+
+    if (m_first > time) {
         // Crud.. Update all the previous records
         // This really shouldn't happen.
 
-        qint32 t=(m_first-time);
-        for (quint32 i=0;i<m_count;i++) {
-            m_time[i]-=t;
-        }
-        m_first=time;
-    }
-    if (m_last < time)
-        m_last=time;
+        qint32 t = (m_first - time);
 
-    quint32 t=(time-m_first);
+        for (quint32 i = 0; i < m_count; i++) {
+            m_time[i] -= t;
+        }
+
+        m_first = time;
+    }
+
+    if (m_last < time) {
+        m_last = time;
+    }
+
+    quint32 t = (time - m_first);
 
     m_time.push_back(t);
     m_count++;
@@ -112,182 +120,213 @@ void EventList::AddEvent(qint64 time, EventStoreType data, EventStoreType data2)
 
     if (m_second_field) {
         m_data2.push_back(data2);
-        if (m_min2>data2) m_min2=data2;
-        if (m_max2<data2) m_max2=data2;
+
+        if (m_min2 > data2) { m_min2 = data2; }
+
+        if (m_max2 < data2) { m_max2 = data2; }
     }
 
-    EventDataType val=EventDataType(data)*m_gain+m_offset;
+    EventDataType val = EventDataType(data) * m_gain + m_offset;
+
     if (m_update_minmax) {
-        if (m_min>val) m_min=val;
-        if (m_max<val) m_max=val;
+        if (m_min > val) { m_min = val; }
+
+        if (m_max < val) { m_max = val; }
     }
 
     if (!m_first) {
-        m_first=time;
-        m_last=time;
+        m_first = time;
+        m_last = time;
     }
-    if (m_first>time) {
+
+    if (m_first > time) {
         // Crud.. Update all the previous records
         // This really shouldn't happen.
 
-        qint32 t=(m_first-time);
-        for (quint32 i=0;i<m_count;i++) {
-            m_time[i]-=t;
-        }
-        m_first=time;
-    }
-    if (m_last < time)
-        m_last=time;
+        qint32 t = (m_first - time);
 
-    quint32 t=(time-m_first);
+        for (quint32 i = 0; i < m_count; i++) {
+            m_time[i] -= t;
+        }
+
+        m_first = time;
+    }
+
+    if (m_last < time) {
+        m_last = time;
+    }
+
+    quint32 t = (time - m_first);
 
     m_time.push_back(t);
     m_count++;
 }
 
 // Adds a consecutive waveform chunk
-void EventList::AddWaveform(qint64 start, qint16 * data, int recs, qint64 duration)
+void EventList::AddWaveform(qint64 start, qint16 *data, int recs, qint64 duration)
 {
-    if (m_type!=EVL_Waveform) {
+    if (m_type != EVL_Waveform) {
         qWarning() << "Attempted to add waveform data to non-waveform object";
         return;
     }
+
     if (!m_rate) {
         qWarning() << "Attempted to add waveform without setting sample rate";
         return;
     }
-    qint64 last=start+duration;
+
+    qint64 last = start + duration;
+
     if (!m_first) {
-        m_first=start;
-        m_last=last;
+        m_first = start;
+        m_last = last;
     }
-    if (m_last>start) {
+
+    if (m_last > start) {
         //qWarning() << "Attempted to add waveform with previous timestamp";
-       // return;
+        // return;
 
         // technically start should equal m_last+1 sample.. check this too.
     }
-    if (m_last<last) {
-        m_last=last;
+
+    if (m_last < last) {
+        m_last = last;
     }
+
     // TODO: Check waveform chunk really is contiguos
     //double rate=duration/recs;
 
     //realloc buffers.
-    int r=m_count;
-    m_count+=recs;
+    int r = m_count;
+    m_count += recs;
     m_data.resize(m_count);
 
-    EventStoreType *edata=m_data.data();
+    EventStoreType *edata = m_data.data();
 
     EventStoreType raw;
-    qint16 * ep=data+recs;
-    qint16 * sp;
-    EventStoreType * dp=&edata[r];
+    qint16 *ep = data + recs;
+    qint16 *sp;
+    EventStoreType *dp = &edata[r];
 
     if (m_update_minmax) {
-        register EventDataType min=m_min,max=m_max,val,gain=m_gain;
+        register EventDataType min = m_min, max = m_max, val, gain = m_gain;
+
         //if (m_offset;
-        for (sp=data; sp<ep; sp++) {
-            *dp++=raw=*sp;
-            val=EventDataType(*sp)*gain+m_offset;
-            if (min > val) min=val;
-            if (max < val) max=val;
+        for (sp = data; sp < ep; sp++) {
+            *dp++ = raw = *sp;
+            val = EventDataType(*sp) * gain + m_offset;
+
+            if (min > val) { min = val; }
+
+            if (max < val) { max = val; }
         }
-        m_min=min;
-        m_max=max;
+
+        m_min = min;
+        m_max = max;
     } else {
         //register EventDataType val,gain=m_gain;
-        for (sp=data; sp < ep; sp++) {
-            *dp++=raw=*sp;
+        for (sp = data; sp < ep; sp++) {
+            *dp++ = raw = *sp;
             //val=EventDataType(raw)*gain;
         }
     }
 
 }
-void EventList::AddWaveform(qint64 start, unsigned char * data, int recs, qint64 duration)
+void EventList::AddWaveform(qint64 start, unsigned char *data, int recs, qint64 duration)
 {
-    if (m_type!=EVL_Waveform) {
+    if (m_type != EVL_Waveform) {
         qWarning() << "Attempted to add waveform data to non-waveform object";
         return;
     }
+
     if (!m_rate) {
         qWarning() << "Attempted to add waveform without setting sample rate";
         return;
     }
+
     // duration=recs*rate;
-    qint64 last=start+duration;
+    qint64 last = start + duration;
+
     if (!m_first) {
-        m_first=start;
-        m_last=last;
+        m_first = start;
+        m_last = last;
     }
-    if (m_last>start) {
+
+    if (m_last > start) {
         //qWarning() << "Attempted to add waveform with previous timestamp";
-       // return;
+        // return;
 
         // technically start should equal m_last+1 sample.. check this too.
     }
-    if (m_last<last) {
-        m_last=last;
+
+    if (m_last < last) {
+        m_last = last;
     }
 
     // TODO: Check waveform chunk really is contiguos
 
     //realloc buffers.
-    int r=m_count;
-    m_count+=recs;
+    int r = m_count;
+    m_count += recs;
     m_data.resize(m_count);
 
-    EventStoreType *edata=m_data.data();
+    EventStoreType *edata = m_data.data();
     EventStoreType raw;
     EventDataType val;
 
-    unsigned char * sp;
-    unsigned char * ep=data+recs;
-    EventStoreType * dp=&edata[r];
+    unsigned char *sp;
+    unsigned char *ep = data + recs;
+    EventStoreType *dp = &edata[r];
 
     if (m_update_minmax) {
         // ignoring m_offset
-        for (sp=data; sp < ep; sp++) {
-            raw=*sp;
-            val=EventDataType(raw)*m_gain;
-            if (m_min>val) m_min=val;
-            if (m_max<val) m_max=val;
-            *dp++=raw;
+        for (sp = data; sp < ep; sp++) {
+            raw = *sp;
+            val = EventDataType(raw) * m_gain;
+
+            if (m_min > val) { m_min = val; }
+
+            if (m_max < val) { m_max = val; }
+
+            *dp++ = raw;
         }
     } else {
-        for (sp=data; sp < ep; sp++) {
-            raw=*sp;
-            val=EventDataType(raw)*m_gain;
-            *dp++=raw;
+        for (sp = data; sp < ep; sp++) {
+            raw = *sp;
+            val = EventDataType(raw) * m_gain;
+            *dp++ = raw;
         }
     }
 
 }
-void EventList::AddWaveform(qint64 start, char * data, int recs, qint64 duration)
+void EventList::AddWaveform(qint64 start, char *data, int recs, qint64 duration)
 {
-    if (m_type!=EVL_Waveform) {
+    if (m_type != EVL_Waveform) {
         qWarning() << "Attempted to add waveform data to non-waveform object";
         return;
     }
+
     if (!m_rate) {
         qWarning() << "Attempted to add waveform without setting sample rate";
         return;
     }
+
     // duration=recs*rate;
-    qint64 last=start+duration;
+    qint64 last = start + duration;
+
     if (!m_first) {
-        m_first=start;
-        m_last=last;
+        m_first = start;
+        m_last = last;
     } else {
-        if (m_last>start) {
+        if (m_last > start) {
             //qWarning() << "Attempted to add waveform with previous timestamp";
             //return;
 
             // technically start should equal m_last+1 sample.. check this too.
         }
-        if (m_last<last) {
-            m_last=last;
+
+        if (m_last < last) {
+            m_last = last;
         }
     }
 
@@ -295,31 +334,34 @@ void EventList::AddWaveform(qint64 start, char * data, int recs, qint64 duration
 
     //realloc buffers.
 
-    int r=m_count;
-    m_count+=recs;
+    int r = m_count;
+    m_count += recs;
     m_data.resize(m_count);
 
-    EventStoreType *edata=m_data.data();
+    EventStoreType *edata = m_data.data();
     EventStoreType raw;
     EventDataType val;
 
-    char * sp;
-    char * ep=data+recs;
-    EventStoreType * dp=&edata[r];
+    char *sp;
+    char *ep = data + recs;
+    EventStoreType *dp = &edata[r];
 
     if (m_update_minmax) {
-        for (sp=data; sp < ep; sp++) {
-            raw=*sp;
-            val=EventDataType(val)*m_gain+m_offset;
-            if (m_min>val) m_min=val;
-            if (m_max<val) m_max=val;
-            *dp++=raw;
+        for (sp = data; sp < ep; sp++) {
+            raw = *sp;
+            val = EventDataType(val) * m_gain + m_offset;
+
+            if (m_min > val) { m_min = val; }
+
+            if (m_max < val) { m_max = val; }
+
+            *dp++ = raw;
         }
     } else {
-        for (sp=data; sp < ep; sp++) {
-            raw=*sp;
-            val=EventDataType(val)*m_gain+m_offset;
-            *dp++=raw;
+        for (sp = data; sp < ep; sp++) {
+            raw = *sp;
+            val = EventDataType(val) * m_gain + m_offset;
+            *dp++ = raw;
         }
     }
 }
diff --git a/sleepyhead/SleepLib/event.h b/sleepyhead/SleepLib/event.h
index 176c1214..05861138 100644
--- a/sleepyhead/SleepLib/event.h
+++ b/sleepyhead/SleepLib/event.h
@@ -26,8 +26,9 @@ enum EventListType { EVL_Waveform, EVL_Event };
 class EventList
 {
     friend class Session;
-public:
-    EventList(EventListType et,EventDataType gain=1.0, EventDataType offset=0.0, EventDataType min=0.0, EventDataType max=0.0, double rate=0.0,bool second_field=false);
+  public:
+    EventList(EventListType et, EventDataType gain = 1.0, EventDataType offset = 0.0,
+              EventDataType min = 0.0, EventDataType max = 0.0, double rate = 0.0, bool second_field = false);
     ~EventList();
 
     //! \brief Wipe the event list so it can be reused
@@ -37,15 +38,15 @@ public:
       Note, data2 is only used if second_field is specified in the constructor */
     void AddEvent(qint64 time, EventStoreType data);
     void AddEvent(qint64 time, EventStoreType data, EventStoreType data2);
-    void AddWaveform(qint64 start, qint16 * data, int recs, qint64 duration);
-    void AddWaveform(qint64 start, unsigned char * data, int recs, qint64 duration);
-    void AddWaveform(qint64 start, char * data, int recs, qint64 duration);
+    void AddWaveform(qint64 start, qint16 *data, int recs, qint64 duration);
+    void AddWaveform(qint64 start, unsigned char *data, int recs, qint64 duration);
+    void AddWaveform(qint64 start, char *data, int recs, qint64 duration);
 
     //! \brief Returns a count of records contained in this EventList
-    inline const quint32 & count() { return m_count; }
+    inline const quint32 &count() { return m_count; }
 
     //! \brief Manually sets a count of records contained in this EventList
-    void setCount(quint32 count) { m_count=count; }
+    void setCount(quint32 count) { m_count = count; }
 
     //! \brief Returns a raw ("ungained") data value from index position i
     inline EventStoreType raw(int i) { return m_data[i]; }
@@ -66,96 +67,96 @@ public:
     bool hasSecondField() { return m_second_field; }
 
     //! \brief Returns the first events/waveforms starting time in milliseconds since epoch
-    inline const qint64 & first() { return m_first; }
+    inline const qint64 &first() { return m_first; }
 
     //! \brief Returns the last events/waveforms ending time in milliseconds since epoch
-    inline const qint64 & last() { return m_last; }
+    inline const qint64 &last() { return m_last; }
 
     //! \brief Returns the timespan covered by this EventList, in milliseconds since epoch
-    inline qint64 duration() { return m_last-m_first; }
+    inline qint64 duration() { return m_last - m_first; }
 
     //! \brief Sets the first events/waveforms starting time in milliseconds since epoch
-    void setFirst(qint64 val) { m_first=val; }
+    void setFirst(qint64 val) { m_first = val; }
     //! \brief Sets the last events/waveforms ending time in milliseconds since epoch
-    void setLast(qint64 val) { m_last=val; }
+    void setLast(qint64 val) { m_last = val; }
 
     //! \brief Set this EventList to either EVL_Waveform or EVL_Event type
-    void setType(EventListType type) { m_type=type; }
+    void setType(EventListType type) { m_type = type; }
 
     //! \brief Change the gain multiplier value
-    void setGain(EventDataType v) { m_gain=v; }
+    void setGain(EventDataType v) { m_gain = v; }
 
     //! \brief Change the gain offset value
-    void setOffset(EventDataType v) { m_offset=v; }
+    void setOffset(EventDataType v) { m_offset = v; }
 
     //! \brief Set the Minimum value for data
-    void setMin(EventDataType v) { m_min=v; }
+    void setMin(EventDataType v) { m_min = v; }
 
     //! \brief Set the Maximum value for data
-    void setMax(EventDataType v) { m_max=v; }
+    void setMax(EventDataType v) { m_max = v; }
 
     //! \brief Set the Minimum value for data2
-    void setMin2(EventDataType v) { m_min2=v; }
+    void setMin2(EventDataType v) { m_min2 = v; }
 
     //! \brief Set the Maximum value for data2
-    void setMax2(EventDataType v) { m_max2=v; }
+    void setMax2(EventDataType v) { m_max2 = v; }
 
     //! \brief Set the sample rate
-    void setRate(EventDataType v) { m_rate=v; }
+    void setRate(EventDataType v) { m_rate = v; }
 
     //void setCode(ChannelID id) { m_code=id; }
 
     //! \brief Return the Minimum data value
-    inline const EventDataType & Min() { return m_min; }
+    inline const EventDataType &Min() { return m_min; }
 
     //! \brief Return the Maximum data value
-    inline const EventDataType & Max() { return m_max; }
+    inline const EventDataType &Max() { return m_max; }
 
     //! \brief Return the Minimum data2 value
-    inline const EventDataType & min2() { return m_min2; }
+    inline const EventDataType &min2() { return m_min2; }
 
     //! \brief Return the Maximum data value
-    inline const EventDataType & max2() { return m_max2; }
+    inline const EventDataType &max2() { return m_max2; }
 
     //! \brief Return the gain value
-    inline const EventDataType & gain() { return m_gain; }
+    inline const EventDataType &gain() { return m_gain; }
 
     //! \brief Return the gain offset
-    inline const EventDataType & offset() { return m_offset; }
+    inline const EventDataType &offset() { return m_offset; }
 
     //! \brief Return the sample rate
-    inline const EventDataType & rate() { return m_rate; }
+    inline const EventDataType &rate() { return m_rate; }
 
     //! \brief Return the EventList type, either EVL_Waveform or EVL_Event
-    inline const EventListType & type() { return m_type; }
+    inline const EventListType &type() { return m_type; }
     //inline const ChannelID & code() { return m_code; }
 
     //! \brief Returns whether or not min/max values are updated while adding events
-    inline const bool & update_minmax() { return m_update_minmax; }
+    inline const bool &update_minmax() { return m_update_minmax; }
 
     //! \brief Returns the dimension (units type) of the contained data object
     QString dimension() { return m_dimension; }
 
     //! \brief Sets the dimension (units type) of the contained data object
-    void setDimension(QString dimension) { m_dimension=dimension; }
+    void setDimension(QString dimension) { m_dimension = dimension; }
 
     //! \brief Returns the data storage vector
-    QVector<EventStoreType> & getData() { return m_data; }
+    QVector<EventStoreType> &getData() { return m_data; }
 
     //! \brief Returns the data2 storage vector
-    QVector<EventStoreType> & getData2() { return m_data2; }
+    QVector<EventStoreType> &getData2() { return m_data2; }
 
     //! \brief Returns the time storage vector (only used in EVL_Event types)
-    QVector<quint32> & getTime() { return m_time; }
+    QVector<quint32> &getTime() { return m_time; }
 
     // Don't mess with these without considering the consequences
-    void rawDataResize(quint32 i) { m_data.resize(i); m_count=i; }
-    void rawData2Resize(quint32 i) { m_data2.resize(i); m_count=i; }
-    void rawTimeResize(quint32 i) { m_time.resize(i); m_count=i; }
-    EventStoreType * rawData() { return m_data.data(); }
-    EventStoreType * rawData2() { return m_data2.data(); }
-    quint32 * rawTime() { return m_time.data(); }
-protected:
+    void rawDataResize(quint32 i) { m_data.resize(i); m_count = i; }
+    void rawData2Resize(quint32 i) { m_data2.resize(i); m_count = i; }
+    void rawTimeResize(quint32 i) { m_time.resize(i); m_count = i; }
+    EventStoreType *rawData() { return m_data.data(); }
+    EventStoreType *rawData2() { return m_data2.data(); }
+    quint32 *rawTime() { return m_time.data(); }
+  protected:
 
     //! \brief The time storage vector, in 32bits delta format, added as offsets to m_first
     QVector<quint32> m_time;
@@ -175,13 +176,13 @@ protected:
 
     EventDataType m_gain;
     EventDataType m_offset;
-    EventDataType m_min,m_min2;
-    EventDataType m_max,m_max2;
+    EventDataType m_min, m_min2;
+    EventDataType m_max, m_max2;
     EventDataType m_rate;     // Waveform sample rate
 
     QString m_dimension;
 
-    qint64 m_first,m_last;
+    qint64 m_first, m_last;
     bool m_update_minmax;
     bool m_second_field;
 };
diff --git a/sleepyhead/SleepLib/loader_plugins/cms50_loader.cpp b/sleepyhead/SleepLib/loader_plugins/cms50_loader.cpp
index b2348cb0..38527fe4 100644
--- a/sleepyhead/SleepLib/loader_plugins/cms50_loader.cpp
+++ b/sleepyhead/SleepLib/loader_plugins/cms50_loader.cpp
@@ -42,7 +42,7 @@ CMS50Loader::CMS50Loader()
 CMS50Loader::~CMS50Loader()
 {
 }
-int CMS50Loader::Open(QString & path,Profile *profile)
+int CMS50Loader::Open(QString &path, Profile *profile)
 {
     // CMS50 folder structure detection stuff here.
 
@@ -60,61 +60,73 @@ int CMS50Loader::Open(QString & path,Profile *profile)
 
     // This bit needs modifying for the SPO2 folder detection.
     QDir dir(path);
-    QString tmp=path+"/Data";  // The directory path containing the .spor/.spo2 files
+    QString tmp = path + "/Data"; // The directory path containing the .spor/.spo2 files
 
     if ((dir.exists("SpO2 Review.ini") || dir.exists("SpO2.ini"))
             && dir.exists("Data")) {
-             // SPO2Review/etc software
+        // SPO2Review/etc software
 
-            return OpenCMS50(tmp,profile);
+        return OpenCMS50(tmp, profile);
     }
 
     return 0;
 }
-int CMS50Loader::OpenCMS50(QString & path, Profile *profile)
+int CMS50Loader::OpenCMS50(QString &path, Profile *profile)
 {
-    QString filename,pathname;
+    QString filename, pathname;
     QList<QString> files;
     QDir dir(path);
 
-    if (!dir.exists())
+    if (!dir.exists()) {
         return 0;
+    }
 
-    if(qprogress) qprogress->setValue(0);
+    if (qprogress) { qprogress->setValue(0); }
 
     dir.setFilter(QDir::Files | QDir::Hidden | QDir::NoSymLinks);
     dir.setSorting(QDir::Name);
-    QFileInfoList flist=dir.entryInfoList();
+    QFileInfoList flist = dir.entryInfoList();
 
     QString fn;
-    for (int i=0;i<flist.size();i++) {
-        QFileInfo fi=flist.at(i);
-        fn=fi.fileName().toLower();
+
+    for (int i = 0; i < flist.size(); i++) {
+        QFileInfo fi = flist.at(i);
+        fn = fi.fileName().toLower();
+
         if (fn.endsWith(".spor") || fn.endsWith(".spo2")) {
             files.push_back(fi.canonicalFilePath());
         }
+
         //if (loader_progress) loader_progress->Pulse();
 
     }
-    int size=files.size();
-    if (size==0) return 0;
 
-    Machine *mach=CreateMachine(profile);
-    int cnt=0;
-    for (QList<QString>::iterator n=files.begin();n!=files.end();n++,++cnt) {
-        if (qprogress) qprogress->setValue((float(cnt)/float(size)*50.0));
+    int size = files.size();
+
+    if (size == 0) { return 0; }
+
+    Machine *mach = CreateMachine(profile);
+    int cnt = 0;
+
+    for (QList<QString>::iterator n = files.begin(); n != files.end(); n++, ++cnt) {
+        if (qprogress) { qprogress->setValue((float(cnt) / float(size) * 50.0)); }
+
         QApplication::processEvents();
-        OpenSPORFile((*n),mach,profile);
+        OpenSPORFile((*n), mach, profile);
     }
+
     mach->Save();
-    if (qprogress) qprogress->setValue(100);
+
+    if (qprogress) { qprogress->setValue(100); }
+
     return 1;
 }
 
-bool CMS50Loader::OpenSPORFile(QString path,Machine *mach,Profile *profile)
+bool CMS50Loader::OpenSPORFile(QString path, Machine *mach, Profile *profile)
 {
-    if (!mach || !profile)
+    if (!mach || !profile) {
         return false;
+    }
 
     QFile f(path);
     unsigned char tmp[256];
@@ -122,102 +134,122 @@ bool CMS50Loader::OpenSPORFile(QString path,Machine *mach,Profile *profile)
     qint16 data_starts;
     qint16 some_code;
     qint16 some_more_code;
-    int seconds=0,num_records;
+    int seconds = 0, num_records;
     int br;
 
-    if (!f.open(QIODevice::ReadOnly))
+    if (!f.open(QIODevice::ReadOnly)) {
         return false;
+    }
 
     // Find everything after the last _
 
-    QString str=path.section("/",-1);
-    str=str.section("_",-1);
-    str=str.section(".",0,0);
+    QString str = path.section("/", -1);
+    str = str.section("_", -1);
+    str = str.section(".", 0, 0);
 
     QDateTime dt;
-    if (str.length()==14) {
-        dt=QDateTime::fromString(str,"yyyyMMddHHmmss");
-    } else if (str.length()==12) {
-        dt=QDateTime::fromString(str,"yyyyMMddHHmm");
+
+    if (str.length() == 14) {
+        dt = QDateTime::fromString(str, "yyyyMMddHHmmss");
+    } else if (str.length() == 12) {
+        dt = QDateTime::fromString(str, "yyyyMMddHHmm");
     } else {
         qDebug() << "CMS50::Spo[r2] Dodgy date field";
         return false;
     }
-    if (!dt.isValid())
+
+    if (!dt.isValid()) {
         return false;
+    }
 
-    SessionID sessid=dt.toTime_t(); // Import date becomes session id
+    SessionID sessid = dt.toTime_t(); // Import date becomes session id
 
-    if (mach->SessionExists(sessid))
-        return false; // Already imported
+    if (mach->SessionExists(sessid)) {
+        return false;    // Already imported
+    }
 
-    br=f.read((char *)tmp,2);
-    if (br!=2) return false;
-    data_starts=tmp[0] | (tmp[1] << 8);
+    br = f.read((char *)tmp, 2);
 
-    br=f.read((char *)tmp,2);
-    if (br!=2) return false;
-    some_code=tmp[0] | (tmp[1] << 8); // 512 or 256 observed
+    if (br != 2) { return false; }
+
+    data_starts = tmp[0] | (tmp[1] << 8);
+
+    br = f.read((char *)tmp, 2);
+
+    if (br != 2) { return false; }
+
+    some_code = tmp[0] | (tmp[1] << 8); // 512 or 256 observed
     Q_UNUSED(some_code);
 
-    br=f.read((char *)tmp,2);
-    if (br!=2) return false;
-    seconds=tmp[0] | (tmp[1] << 8);
+    br = f.read((char *)tmp, 2);
+
+    if (br != 2) { return false; }
+
+    seconds = tmp[0] | (tmp[1] << 8);
 
     if (!seconds) {
-        num_records=(f.size()-data_starts);
-        seconds=num_records/2;
+        num_records = (f.size() - data_starts);
+        seconds = num_records / 2;
     } else {
-        num_records=seconds << 1;
+        num_records = seconds << 1;
     }
-    if (seconds<60) {
+
+    if (seconds < 60) {
         // Don't bother importing short sessions
         return false;
     }
 
-    br=f.read((char *)tmp,2);
-    if (br!=2) return false;
-    some_more_code=tmp[0] | (tmp[1] << 8);  // == 0
+    br = f.read((char *)tmp, 2);
+
+    if (br != 2) { return false; }
+
+    some_more_code = tmp[0] | (tmp[1] << 8); // == 0
     Q_UNUSED(some_more_code);
 
-    br=f.read((char *)tmp,34); // Read widechar date record
-    if (br!=34) return false;
+    br = f.read((char *)tmp, 34); // Read widechar date record
 
-    for (int i=0;i<17;i++) {   // Convert to 8bit
-        tmp[i]=tmp[i << 1];
+    if (br != 34) { return false; }
+
+    for (int i = 0; i < 17; i++) { // Convert to 8bit
+        tmp[i] = tmp[i << 1];
     }
-    tmp[17]=0;
-    QString datestr=(char *)tmp;
+
+    tmp[17] = 0;
+    QString datestr = (char *)tmp;
     QDateTime date;
     qint64 starttime;
-    if (datestr.isEmpty()) { // Has Internal date record, so use it
-        date=QDateTime::fromString(datestr,"MM/dd/yy HH:mm:ss");
-        QDate d2=date.date();
 
-        if (d2.year()<2000) { // Nice to see CMS50 is Y2K friendly..
-            d2.setDate(d2.year()+100,d2.month(),d2.day());
+    if (datestr.isEmpty()) { // Has Internal date record, so use it
+        date = QDateTime::fromString(datestr, "MM/dd/yy HH:mm:ss");
+        QDate d2 = date.date();
+
+        if (d2.year() < 2000) { // Nice to see CMS50 is Y2K friendly..
+            d2.setDate(d2.year() + 100, d2.month(), d2.day());
             date.setDate(d2);
         }
+
         if (!date.isValid()) {
             qDebug() << "Invalid date time retreieved in CMS50::OpenSPO[R2]File";
             return false;
         }
-        starttime=qint64(date.toTime_t())*1000L;
+
+        starttime = qint64(date.toTime_t()) * 1000L;
     } else if (dt.isValid()) { // Else take the filenames date
-        date=dt;
-        starttime=qint64(dt.toTime_t())*1000L;
+        date = dt;
+        starttime = qint64(dt.toTime_t()) * 1000L;
     } else {  // Has nothing, so add it up to current time
         qDebug() << "CMS50: Couldn't get any start date indication";
-        date=QDateTime::currentDateTime();
-        date=date.addSecs(-seconds);
-        starttime=qint64(date.toTime_t())*1000L;
+        date = QDateTime::currentDateTime();
+        date = date.addSecs(-seconds);
+        starttime = qint64(date.toTime_t()) * 1000L;
     }
 
     f.seek(data_starts);
 
-    buffer=new char [num_records];
-    br=f.read(buffer,num_records);
-    if (br!=num_records) {
+    buffer = new char [num_records];
+    br = f.read(buffer, num_records);
+
+    if (br != num_records) {
         qDebug() << "Short .spo[R2] File: " << path;
         delete [] buffer;
         return false;
@@ -226,80 +258,96 @@ bool CMS50Loader::OpenSPORFile(QString path,Machine *mach,Profile *profile)
     //QDateTime last_pulse_time=date;
     //QDateTime last_spo2_time=date;
 
-    EventDataType last_pulse=buffer[0];
-    EventDataType last_spo2=buffer[1];
-    EventDataType cp=0,cs=0;
+    EventDataType last_pulse = buffer[0];
+    EventDataType last_spo2 = buffer[1];
+    EventDataType cp = 0, cs = 0;
 
-    Session *sess=new Session(mach,sessid);
+    Session *sess = new Session(mach, sessid);
     sess->updateFirst(starttime);
-    EventList *oxip=sess->AddEventList(OXI_Pulse,EVL_Event);
-    EventList *oxis=sess->AddEventList(OXI_SPO2,EVL_Event);
+    EventList *oxip = sess->AddEventList(OXI_Pulse, EVL_Event);
+    EventList *oxis = sess->AddEventList(OXI_SPO2, EVL_Event);
 
-    oxip->AddEvent(starttime,last_pulse);
-    oxis->AddEvent(starttime,last_spo2);
+    oxip->AddEvent(starttime, last_pulse);
+    oxis->AddEvent(starttime, last_spo2);
 
-    EventDataType PMin=0,PMax=0,SMin=0,SMax=0,PAvg=0,SAvg=0;
-    int PCnt=0,SCnt=0;
-    qint64 tt=starttime;
+    EventDataType PMin = 0, PMax = 0, SMin = 0, SMax = 0, PAvg = 0, SAvg = 0;
+    int PCnt = 0, SCnt = 0;
+    qint64 tt = starttime;
     //fixme: Need two lasttime values here..
-    qint64 lasttime=starttime;
+    qint64 lasttime = starttime;
 
-    bool first_p=true,first_s=true;
+    bool first_p = true, first_s = true;
 
-    for (int i=2;i<num_records;i+=2) {
-        cp=buffer[i];
-        cs=buffer[i+1];
-        if (last_pulse!=cp) {
-            oxip->AddEvent(tt,cp);
-            if (tt>lasttime) lasttime=tt;
-            if (cp>0) {
+    for (int i = 2; i < num_records; i += 2) {
+        cp = buffer[i];
+        cs = buffer[i + 1];
+
+        if (last_pulse != cp) {
+            oxip->AddEvent(tt, cp);
+
+            if (tt > lasttime) { lasttime = tt; }
+
+            if (cp > 0) {
                 if (first_p) {
-                    PMin=cp;
-                    first_p=false;
+                    PMin = cp;
+                    first_p = false;
                 } else {
-                    if (PMin>cp) PMin=cp;
+                    if (PMin > cp) { PMin = cp; }
                 }
-                PAvg+=cp;
+
+                PAvg += cp;
                 PCnt++;
             }
         }
-        if (last_spo2!=cs) {
-            oxis->AddEvent(tt,cs);
-            if (tt>lasttime) lasttime=tt;
-            if (cs>0) {
+
+        if (last_spo2 != cs) {
+            oxis->AddEvent(tt, cs);
+
+            if (tt > lasttime) { lasttime = tt; }
+
+            if (cs > 0) {
                 if (first_s) {
-                    SMin=cs;
-                    first_s=false;
+                    SMin = cs;
+                    first_s = false;
                 } else {
-                    if (SMin>cs) SMin=cs;
+                    if (SMin > cs) { SMin = cs; }
                 }
-                SAvg+=cs;
+
+                SAvg += cs;
                 SCnt++;
             }
         }
-        last_pulse=cp;
-        last_spo2=cs;
-        if (PMax<cp) PMax=cp;
-        if (SMax<cs) SMax=cs;
-        tt+=1000; // An educated guess of 1 second. Verified by gcz@cpaptalk
+
+        last_pulse = cp;
+        last_spo2 = cs;
+
+        if (PMax < cp) { PMax = cp; }
+
+        if (SMax < cs) { SMax = cs; }
+
+        tt += 1000; // An educated guess of 1 second. Verified by gcz@cpaptalk
     }
-    if (cp) oxip->AddEvent(tt,cp);
-    if (cs) oxis->AddEvent(tt,cs);
+
+    if (cp) { oxip->AddEvent(tt, cp); }
+
+    if (cs) { oxis->AddEvent(tt, cs); }
 
     sess->updateLast(tt);
 
-    EventDataType pa=0,sa=0;
-    if (PCnt>0) pa=PAvg/double(PCnt);
-    if (SCnt>0) sa=SAvg/double(SCnt);
+    EventDataType pa = 0, sa = 0;
 
-    sess->setMin(OXI_Pulse,PMin);
-    sess->setMax(OXI_Pulse,PMax);
-    sess->setAvg(OXI_Pulse,pa);
-    sess->setMin(OXI_SPO2,SMin);
-    sess->setMax(OXI_SPO2,SMax);
-    sess->setAvg(OXI_SPO2,sa);
+    if (PCnt > 0) { pa = PAvg / double(PCnt); }
 
-    mach->AddSession(sess,profile);
+    if (SCnt > 0) { sa = SAvg / double(SCnt); }
+
+    sess->setMin(OXI_Pulse, PMin);
+    sess->setMax(OXI_Pulse, PMax);
+    sess->setAvg(OXI_Pulse, pa);
+    sess->setMin(OXI_SPO2, SMin);
+    sess->setMax(OXI_SPO2, SMax);
+    sess->setAvg(OXI_SPO2, sa);
+
+    mach->AddSession(sess, profile);
     sess->SetChanged(true);
     delete [] buffer;
 
@@ -307,16 +355,17 @@ bool CMS50Loader::OpenSPORFile(QString path,Machine *mach,Profile *profile)
 }
 Machine *CMS50Loader::CreateMachine(Profile *profile)
 {
-    if (!profile)
+    if (!profile) {
         return NULL;
+    }
 
     // NOTE: This only allows for one CMS50 machine per profile..
     // Upgrading their oximeter will use this same record..
 
-    QList<Machine *> ml=profile->GetMachines(MT_OXIMETER);
+    QList<Machine *> ml = profile->GetMachines(MT_OXIMETER);
 
-    for (QList<Machine *>::iterator i=ml.begin(); i!=ml.end(); i++) {
-        if ((*i)->GetClass()==cms50_class_name)  {
+    for (QList<Machine *>::iterator i = ml.begin(); i != ml.end(); i++) {
+        if ((*i)->GetClass() == cms50_class_name)  {
             return (*i);
             break;
         }
@@ -324,29 +373,30 @@ Machine *CMS50Loader::CreateMachine(Profile *profile)
 
     qDebug() << "Create CMS50 Machine Record";
 
-    Machine *m=new Oximeter(profile,0);
+    Machine *m = new Oximeter(profile, 0);
     m->SetClass(cms50_class_name);
-    m->properties[STR_PROP_Brand]="Contec";
-    m->properties[STR_PROP_Model]="CMS50X";
-    m->properties[STR_PROP_DataVersion]=QString::number(cms50_data_version);
+    m->properties[STR_PROP_Brand] = "Contec";
+    m->properties[STR_PROP_Model] = "CMS50X";
+    m->properties[STR_PROP_DataVersion] = QString::number(cms50_data_version);
 
     profile->AddMachine(m);
-    QString path="{"+STR_GEN_DataFolder+"}/"+m->GetClass()+"_"+m->hexid()+"/";
-    m->properties[STR_PROP_Path]=path;
+    QString path = "{" + STR_GEN_DataFolder + "}/" + m->GetClass() + "_" + m->hexid() + "/";
+    m->properties[STR_PROP_Path] = path;
 
     return m;
 }
 
 
 
-static bool cms50_initialized=false;
+static bool cms50_initialized = false;
 
 void CMS50Loader::Register()
 {
-    if (cms50_initialized) return;
+    if (cms50_initialized) { return; }
+
     qDebug() << "Registering CMS50Loader";
     RegisterLoader(new CMS50Loader());
     //InitModelMap();
-    cms50_initialized=true;
+    cms50_initialized = true;
 }
 
diff --git a/sleepyhead/SleepLib/loader_plugins/cms50_loader.h b/sleepyhead/SleepLib/loader_plugins/cms50_loader.h
index 1fb6a94a..cd22c860 100644
--- a/sleepyhead/SleepLib/loader_plugins/cms50_loader.h
+++ b/sleepyhead/SleepLib/loader_plugins/cms50_loader.h
@@ -14,8 +14,8 @@
 
 #include "SleepLib/machine_loader.h"
 
-const QString cms50_class_name="CMS50";
-const int cms50_data_version=4;
+const QString cms50_class_name = "CMS50";
+const int cms50_data_version = 4;
 
 
 /*! \class CMS50Loader
@@ -23,26 +23,26 @@ const int cms50_data_version=4;
     */
 class CMS50Loader : public MachineLoader
 {
-    public:
+  public:
 
 
-        CMS50Loader();
-        virtual ~CMS50Loader();
-        virtual int Open(QString & path,Profile *profile);
-        static void Register();
+    CMS50Loader();
+    virtual ~CMS50Loader();
+    virtual int Open(QString &path, Profile *profile);
+    static void Register();
 
-        virtual int Version() { return cms50_data_version; }
-        virtual const QString & ClassName() { return cms50_class_name; }
+    virtual int Version() { return cms50_data_version; }
+    virtual const QString &ClassName() { return cms50_class_name; }
 
-        Machine *CreateMachine(Profile *profile);
+    Machine *CreateMachine(Profile *profile);
 
 
-    protected:
-        int OpenCMS50(QString & path, Profile *profile);
-        bool OpenSPORFile(QString path, Machine * machine,Profile *profile);
+  protected:
+    int OpenCMS50(QString &path, Profile *profile);
+    bool OpenSPORFile(QString path, Machine *machine, Profile *profile);
 
-    private:
-        char *buffer;
+  private:
+    char *buffer;
 };
 
 #endif // CMS50LOADER_H
diff --git a/sleepyhead/SleepLib/loader_plugins/icon_loader.cpp b/sleepyhead/SleepLib/loader_plugins/icon_loader.cpp
index 1d4cbb39..89411564 100644
--- a/sleepyhead/SleepLib/loader_plugins/icon_loader.cpp
+++ b/sleepyhead/SleepLib/loader_plugins/icon_loader.cpp
@@ -20,10 +20,10 @@
 
 extern QProgressBar *qprogress;
 
-FPIcon::FPIcon(Profile *p,MachineID id)
-    :CPAP(p,id)
+FPIcon::FPIcon(Profile *p, MachineID id)
+    : CPAP(p, id)
 {
-    m_class=fpicon_class_name;
+    m_class = fpicon_class_name;
 }
 
 FPIcon::~FPIcon()
@@ -32,50 +32,55 @@ FPIcon::~FPIcon()
 
 FPIconLoader::FPIconLoader()
 {
-    m_buffer=NULL;
+    m_buffer = NULL;
 }
 
 FPIconLoader::~FPIconLoader()
 {
 }
 
-int FPIconLoader::Open(QString & path,Profile *profile)
+int FPIconLoader::Open(QString &path, Profile *profile)
 {
     QString newpath;
 
-    path=path.replace("\\","/");
+    path = path.replace("\\", "/");
 
-    if (path.endsWith("/"))
+    if (path.endsWith("/")) {
         path.chop(1);
-
-    QString dirtag="FPHCARE";
-    if (path.endsWith("/"+dirtag)) {
-        newpath=path;
-    } else {
-        newpath=path+"/"+dirtag;
     }
 
-    newpath+="/ICON/";
+    QString dirtag = "FPHCARE";
+
+    if (path.endsWith("/" + dirtag)) {
+        newpath = path;
+    } else {
+        newpath = path + "/" + dirtag;
+    }
+
+    newpath += "/ICON/";
 
     QString filename;
 
     QDir dir(newpath);
 
-    if ((!dir.exists() || !dir.isReadable()))
+    if ((!dir.exists() || !dir.isReadable())) {
         return 0;
+    }
 
     dir.setFilter(QDir::NoDotAndDotDot | QDir::Dirs | QDir::Files | QDir::Hidden | QDir::NoSymLinks);
     dir.setSorting(QDir::Name);
-    QFileInfoList flist=dir.entryInfoList();
+    QFileInfoList flist = dir.entryInfoList();
 
     QStringList SerialNumbers;
 
     bool ok;
-    for (int i=0;i<flist.size();i++) {
-        QFileInfo fi=flist.at(i);
-        QString filename=fi.fileName();
+
+    for (int i = 0; i < flist.size(); i++) {
+        QFileInfo fi = flist.at(i);
+        QString filename = fi.fileName();
 
         filename.toInt(&ok);
+
         if (ok) {
             SerialNumbers.push_back(filename);
         }
@@ -84,183 +89,199 @@ int FPIconLoader::Open(QString & path,Profile *profile)
     Machine *m;
 
     QString npath;
-    for (int i=0;i<SerialNumbers.size();i++) {
-        QString & sn=SerialNumbers[i];
-        m=CreateMachine(sn,profile);
 
-        npath=newpath+"/"+sn;
+    for (int i = 0; i < SerialNumbers.size(); i++) {
+        QString &sn = SerialNumbers[i];
+        m = CreateMachine(sn, profile);
+
+        npath = newpath + "/" + sn;
+
         try {
-            if (m) OpenMachine(m,npath,profile);
-        } catch(OneTypePerDay e) {
+            if (m) { OpenMachine(m, npath, profile); }
+        } catch (OneTypePerDay e) {
             profile->DelMachine(m);
             MachList.erase(MachList.find(sn));
-            QMessageBox::warning(NULL,"Import Error","This Machine Record cannot be imported in this profile.\nThe Day records overlap with already existing content.",QMessageBox::Ok);
+            QMessageBox::warning(NULL, "Import Error",
+                                 "This Machine Record cannot be imported in this profile.\nThe Day records overlap with already existing content.",
+                                 QMessageBox::Ok);
             delete m;
         }
     }
+
     return MachList.size();
 }
 
 struct FPWaveChunk {
-    FPWaveChunk(){
-        st=0;
-        duration=0;
-        flow=NULL;
-        pressure=NULL;
-        leak=NULL;
-        file=0;
+    FPWaveChunk() {
+        st = 0;
+        duration = 0;
+        flow = NULL;
+        pressure = NULL;
+        leak = NULL;
+        file = 0;
     }
-    FPWaveChunk(qint64 start, qint64 dur,int f) { st=start; duration=dur; file=f, flow=NULL; leak=NULL; pressure=NULL; }
-    FPWaveChunk(const FPWaveChunk & copy) {
-        st=copy.st;
-        duration=copy.duration;
-        flow=copy.flow;
-        leak=copy.leak;
-        pressure=copy.pressure;
-        file=copy.file;
+    FPWaveChunk(qint64 start, qint64 dur, int f) { st = start; duration = dur; file = f, flow = NULL; leak = NULL; pressure = NULL; }
+    FPWaveChunk(const FPWaveChunk &copy) {
+        st = copy.st;
+        duration = copy.duration;
+        flow = copy.flow;
+        leak = copy.leak;
+        pressure = copy.pressure;
+        file = copy.file;
     }
     qint64 st;
     qint64 duration;
     int file;
-    EventList * flow;
-    EventList * leak;
-    EventList * pressure;
+    EventList *flow;
+    EventList *leak;
+    EventList *pressure;
 };
 
-bool operator<(const FPWaveChunk & a, const FPWaveChunk & b) {
+bool operator<(const FPWaveChunk &a, const FPWaveChunk &b)
+{
     return (a.st < b.st);
 }
 
-int FPIconLoader::OpenMachine(Machine *mach, QString & path, Profile * profile)
+int FPIconLoader::OpenMachine(Machine *mach, QString &path, Profile *profile)
 {
     qDebug() << "Opening FPIcon " << path;
     QDir dir(path);
-    if (!dir.exists() || (!dir.isReadable()))
-         return false;
+
+    if (!dir.exists() || (!dir.isReadable())) {
+        return false;
+    }
 
     dir.setFilter(QDir::NoDotAndDotDot | QDir::Dirs | QDir::Files | QDir::Hidden | QDir::NoSymLinks);
     dir.setSorting(QDir::Name);
-    QFileInfoList flist=dir.entryInfoList();
+    QFileInfoList flist = dir.entryInfoList();
 
-    QString filename,fpath;
-    if (qprogress) qprogress->setValue(0);
+    QString filename, fpath;
+
+    if (qprogress) { qprogress->setValue(0); }
 
     QStringList summary, log, flw, det;
 
-    for (int i=0;i<flist.size();i++) {
-        QFileInfo fi=flist.at(i);
-        filename=fi.fileName();
-        fpath=path+"/"+filename;
-        if (filename.left(3).toUpper()=="SUM") {
+    for (int i = 0; i < flist.size(); i++) {
+        QFileInfo fi = flist.at(i);
+        filename = fi.fileName();
+        fpath = path + "/" + filename;
+
+        if (filename.left(3).toUpper() == "SUM") {
             summary.push_back(fpath);
-            OpenSummary(mach,fpath,profile);
-        } else if (filename.left(3).toUpper()=="DET") {
+            OpenSummary(mach, fpath, profile);
+        } else if (filename.left(3).toUpper() == "DET") {
             det.push_back(fpath);
-        } else if (filename.left(3).toUpper()=="FLW") {
+        } else if (filename.left(3).toUpper() == "FLW") {
             flw.push_back(fpath);
-        } else if (filename.left(3).toUpper()=="LOG") {
+        } else if (filename.left(3).toUpper() == "LOG") {
             log.push_back(fpath);
         }
     }
-    for (int i=0;i<det.size();i++) {
-        OpenDetail(mach,det[i],profile);
+
+    for (int i = 0; i < det.size(); i++) {
+        OpenDetail(mach, det[i], profile);
     }
-    for (int i=0;i<flw.size();i++) {
-        OpenFLW(mach,flw[i],profile);
+
+    for (int i = 0; i < flw.size(); i++) {
+        OpenFLW(mach, flw[i], profile);
     }
+
     SessionID sid;//,st;
-    float hours,mins;
+    float hours, mins;
 
     qDebug() << "Last 20 Sessions";
 
-    int cnt=0;
+    int cnt = 0;
     QDateTime dt;
     QString a;
-    QMap<SessionID, Session *>::iterator it=Sessions.end();
+    QMap<SessionID, Session *>::iterator it = Sessions.end();
     it--;
-    dt=QDateTime::fromTime_t(qint64(it.value()->first())/1000L);
-    QDate date=dt.date().addDays(-7);
+    dt = QDateTime::fromTime_t(qint64(it.value()->first()) / 1000L);
+    QDate date = dt.date().addDays(-7);
     it++;
 
     do {
         it--;
-        Session *sess=it.value();
-        sid=sess->session();
-        hours=sess->hours();
-        mins=hours*60;
-        dt=QDateTime::fromTime_t(sid);
+        Session *sess = it.value();
+        sid = sess->session();
+        hours = sess->hours();
+        mins = hours * 60;
+        dt = QDateTime::fromTime_t(sid);
+
+        if (sess->channelDataExists(CPAP_FlowRate)) { a = "(flow)"; }
+        else { a = ""; }
 
-        if (sess->channelDataExists(CPAP_FlowRate)) a="(flow)"; else a="";
         qDebug() << cnt << ":" << dt << "session" << sid << "," << mins << "minutes" << a;
 
-        if (dt.date()<date) break;
+        if (dt.date() < date) { break; }
+
         ++cnt;
 
-    } while (it!=Sessions.begin());
+    } while (it != Sessions.begin());
 
 
-//    qDebug() << "Unmatched Sessions";
-//    QList<FPWaveChunk> chunks;
-//    for (QMap<int,QDate>::iterator dit=FLWDate.begin();dit!=FLWDate.end();dit++) {
-//        int k=dit.key();
-//        //QDate date=dit.value();
-////        QList<Session *> values = SessDate.values(date);
-//        for (int j=0;j<FLWTS[k].size();j++) {
+    //    qDebug() << "Unmatched Sessions";
+    //    QList<FPWaveChunk> chunks;
+    //    for (QMap<int,QDate>::iterator dit=FLWDate.begin();dit!=FLWDate.end();dit++) {
+    //        int k=dit.key();
+    //        //QDate date=dit.value();
+    ////        QList<Session *> values = SessDate.values(date);
+    //        for (int j=0;j<FLWTS[k].size();j++) {
 
-//            FPWaveChunk chunk(FLWTS[k].at(j),FLWDuration[k].at(j),k);
-//            chunk.flow=FLWMapFlow[k].at(j);
-//            chunk.leak=FLWMapLeak[k].at(j);
-//            chunk.pressure=FLWMapPres[k].at(j);
+    //            FPWaveChunk chunk(FLWTS[k].at(j),FLWDuration[k].at(j),k);
+    //            chunk.flow=FLWMapFlow[k].at(j);
+    //            chunk.leak=FLWMapLeak[k].at(j);
+    //            chunk.pressure=FLWMapPres[k].at(j);
 
-//            chunks.push_back(chunk);
+    //            chunks.push_back(chunk);
 
-//            zz=FLWTS[k].at(j)/1000;
-//            dur=double(FLWDuration[k].at(j))/60000.0;
-//            bool b,c=false;
-//            if (Sessions.contains(zz)) b=true; else b=false;
-//            if (b) {
-//                if (Sessions[zz]->channelDataExists(CPAP_FlowRate)) c=true;
-//            }
-//            qDebug() << k << "-" <<j << ":" << zz << qRound(dur) << "minutes" << (b ? "*" : "") << (c ? QDateTime::fromTime_t(zz).toString() : "");
-//        }
-//    }
-//    qSort(chunks);
-//    bool b,c;
-//    for (int i=0;i<chunks.size();i++) {
-//        const FPWaveChunk & chunk=chunks.at(i);
-//        zz=chunk.st/1000;
-//        dur=double(chunk.duration)/60000.0;
-//        if (Sessions.contains(zz)) b=true; else b=false;
-//        if (b) {
-//            if (Sessions[zz]->channelDataExists(CPAP_FlowRate)) c=true;
-//        }
-//        qDebug() << chunk.file << ":" << i << zz << dur << "minutes" << (b ? "*" : "") << (c ? QDateTime::fromTime_t(zz).toString() : "");
-//    }
+    //            zz=FLWTS[k].at(j)/1000;
+    //            dur=double(FLWDuration[k].at(j))/60000.0;
+    //            bool b,c=false;
+    //            if (Sessions.contains(zz)) b=true; else b=false;
+    //            if (b) {
+    //                if (Sessions[zz]->channelDataExists(CPAP_FlowRate)) c=true;
+    //            }
+    //            qDebug() << k << "-" <<j << ":" << zz << qRound(dur) << "minutes" << (b ? "*" : "") << (c ? QDateTime::fromTime_t(zz).toString() : "");
+    //        }
+    //    }
+    //    qSort(chunks);
+    //    bool b,c;
+    //    for (int i=0;i<chunks.size();i++) {
+    //        const FPWaveChunk & chunk=chunks.at(i);
+    //        zz=chunk.st/1000;
+    //        dur=double(chunk.duration)/60000.0;
+    //        if (Sessions.contains(zz)) b=true; else b=false;
+    //        if (b) {
+    //            if (Sessions[zz]->channelDataExists(CPAP_FlowRate)) c=true;
+    //        }
+    //        qDebug() << chunk.file << ":" << i << zz << dur << "minutes" << (b ? "*" : "") << (c ? QDateTime::fromTime_t(zz).toString() : "");
+    //    }
 
     mach->Save();
 
     return true;
 }
 
-QDateTime FPIconLoader::readFPDateTime(quint8 * data)
+QDateTime FPIconLoader::readFPDateTime(quint8 *data)
 {
-    quint32 ts=(data[3] << 24) | (data[2] << 16) | ((data[1] << 8) | data[0]);// ^ 0xc00000;
+    quint32 ts = (data[3] << 24) | (data[2] << 16) | ((data[1] << 8) | data[0]); // ^ 0xc00000;
     // 0x20a41b18
 
-    quint8 day=ts & 0x1f; // 0X18      24
+    quint8 day = ts & 0x1f; // 0X18      24
     ts >>= 5;               // 10520D8
-    quint8 month=ts & 0x0f;   // 0X08      8
+    quint8 month = ts & 0x0f; // 0X08      8
     ts >>= 4;               // 10520D
-    quint8 year=ts & 0x3f;  // 0X0D      13
+    quint8 year = ts & 0x3f; // 0X0D      13
     ts >>= 6;               // 4148
-    quint8 second=ts & 0x3f;// 0X08      8
+    quint8 second = ts & 0x3f; // 0X08      8
     ts >>= 6;               // 20A
-    quint8 minute=ts & 0x3f;// 0A        10
+    quint8 minute = ts & 0x3f; // 0A        10
     ts >>= 6;               // 10
-    quint8 hour=ts & 0x1f;  // 10        16
-    QDate date=QDate(2000+year,month,day);
-    QTime time=QTime(hour,minute,second);
-    QDateTime datetime=QDateTime(date,time);
+    quint8 hour = ts & 0x1f; // 10        16
+    QDate date = QDate(2000 + year, month, day);
+    QTime time = QTime(hour, minute, second);
+    QDateTime datetime = QDateTime(date, time);
     return datetime;
 }
 
@@ -300,7 +321,7 @@ hour=(ts >> 12) & 0x1f; */
 // 0x01ff 8 bit additive sum checksum byte of previous header bytes
 
 // 0x0200-0x0203 32bit timestamp in
-bool FPIconLoader::OpenFLW(Machine * mach,QString filename, Profile * profile)
+bool FPIconLoader::OpenFLW(Machine *mach, QString filename, Profile *profile)
 {
     Q_UNUSED(mach);
     Q_UNUSED(profile);
@@ -309,33 +330,40 @@ bool FPIconLoader::OpenFLW(Machine * mach,QString filename, Profile * profile)
     quint32 ts;
     double ti;
 
-    EventList * flow=NULL, * pressure=NULL, *leak=NULL;
+    EventList *flow = NULL, * pressure = NULL, *leak = NULL;
     QDateTime datetime;
 
-    unsigned char * buf, *endbuf;
+    unsigned char *buf, *endbuf;
 
 
     qDebug() << filename;
     QByteArray header;
     QFile file(filename);
+
     if (!file.open(QFile::ReadOnly)) {
         qDebug() << "Couldn't open" << filename;
         return false;
     }
-    header=file.read(0x200);
-    if (header.size()!=0x200) {
+
+    header = file.read(0x200);
+
+    if (header.size() != 0x200) {
         qDebug() << "Short file" << filename;
         return false;
     }
-    unsigned char hsum=0xff;
-    for (int i=0;i<0x1ff;i++) {
-        hsum+=header[i];
+
+    unsigned char hsum = 0xff;
+
+    for (int i = 0; i < 0x1ff; i++) {
+        hsum += header[i];
     }
-    if (hsum!=header[0x1ff]) {
+
+    if (hsum != header[0x1ff]) {
         qDebug() << "Header checksum mismatch" << filename;
     }
+
     QTextStream htxt(&header);
-    QString h1,version,fname,serial,model,type;
+    QString h1, version, fname, serial, model, type;
     htxt >> h1;
     htxt >> version;
     htxt >> fname;
@@ -344,87 +372,93 @@ bool FPIconLoader::OpenFLW(Machine * mach,QString filename, Profile * profile)
     htxt >> type;
 
     if (mach->properties[STR_PROP_Model].isEmpty()) {
-        mach->properties[STR_PROP_Model]=model+" "+type;
+        mach->properties[STR_PROP_Model] = model + " " + type;
     }
 
     fname.chop(4);
-    QString num=fname.right(4);
-    int filenum=num.toInt();
+    QString num = fname.right(4);
+    int filenum = num.toInt();
 
-    data=file.readAll();
+    data = file.readAll();
 
-    buf=(unsigned char *)data.data();
-    endbuf=buf+data.size();
+    buf = (unsigned char *)data.data();
+    endbuf = buf + data.size();
 
-    t1=buf[1] << 8 | buf[0];
-    if (t1==0xfafe)  // End of file marker..
-    {
+    t1 = buf[1] << 8 | buf[0];
+
+    if (t1 == 0xfafe) { // End of file marker..
         qDebug() << "FaFE observed in" << filename;
         return false;
     }
 
-    datetime=readFPDateTime(buf);
-    buf+=4;
+    datetime = readFPDateTime(buf);
+    buf += 4;
 
 
     QDate date;
     QTime time;
+
     if (!datetime.isValid()) {
         qDebug() << "DateTime invalid in OpenFLW:" << filename;
         return false;
     }  else {
-        date=datetime.date();
-        time=datetime.time();
-        ts=datetime.toTime_t();
+        date = datetime.date();
+        time = datetime.time();
+        ts = datetime.toTime_t();
     }
 
-    ti=qint64(ts)*1000L;
+    ti = qint64(ts) * 1000L;
 
     EventStoreType pbuf[256];
 
-    QMap<SessionID, Session *>::iterator sit=Sessions.find(ts);
+    QMap<SessionID, Session *>::iterator sit = Sessions.find(ts);
 
     Session *sess;
 
-    bool newsess=false;
-    if (sit!=Sessions.end()) {
-        sess=sit.value();
-        qDebug() << filenum << ":" << date << sess->session() << ":" << sess->hours()*60.0;
+    bool newsess = false;
+
+    if (sit != Sessions.end()) {
+        sess = sit.value();
+        qDebug() << filenum << ":" << date << sess->session() << ":" << sess->hours() * 60.0;
     } else {
-        qint64 k=-1;
-        Session * s1=NULL;
-        sess=NULL;
-        for (sit=Sessions.begin();sit!=Sessions.end();sit++) {
-            s1=sit.value();
-            qint64 z=qAbs(s1->first()-ti);
-            if (z<3600000) {
-                if ((k<0) || (k>z)) {
-                    k=z;
-                    sess=s1;
+        qint64 k = -1;
+        Session *s1 = NULL;
+        sess = NULL;
+
+        for (sit = Sessions.begin(); sit != Sessions.end(); sit++) {
+            s1 = sit.value();
+            qint64 z = qAbs(s1->first() - ti);
+
+            if (z < 3600000) {
+                if ((k < 0) || (k > z)) {
+                    k = z;
+                    sess = s1;
                 }
             }
         }
+
         if (sess) {
             sess->set_first(ti);
-            sess->setFirst(CPAP_FlowRate,ti);
-            sess->setFirst(CPAP_MaskPressure,ti);
+            sess->setFirst(CPAP_FlowRate, ti);
+            sess->setFirst(CPAP_MaskPressure, ti);
         } else {
-            sess=new Session(mach,ts);
+            sess = new Session(mach, ts);
             sess->set_first(ti);
-            sess->setFirst(CPAP_FlowRate,ti);
-            sess->setFirst(CPAP_MaskPressure,ti);
-            newsess=true;
+            sess->setFirst(CPAP_FlowRate, ti);
+            sess->setFirst(CPAP_MaskPressure, ti);
+            newsess = true;
             qDebug() << filenum << ":" << date << "couldn't find matching session for" << ts;
         }
     }
 
-    const int samples_per_block=50;
-    const double rate=1000.0/double(samples_per_block);
+    const int samples_per_block = 50;
+    const double rate = 1000.0 / double(samples_per_block);
 
     // F&P Overwrites this file, not appends to it.
-    flow=new EventList(EVL_Waveform,1.0,0,0,0,rate);
+    flow = new EventList(EVL_Waveform, 1.0, 0, 0, 0, rate);
     //leak=new EventList(EVL_Event,1.0,0,0,0,rate*double(samples_per_block)); // 1 per second
-    pressure=new EventList(EVL_Event,0.01,0,0,0,rate*double(samples_per_block)); // 1 per second
+    pressure = new EventList(EVL_Event, 0.01, 0, 0, 0,
+                             rate * double(samples_per_block)); // 1 per second
 
     flow->setFirst(ti);
     //leak->setFirst(ti);
@@ -437,95 +471,111 @@ bool FPIconLoader::OpenFLW(Machine * mach,QString filename, Profile * profile)
     qint16 tmp;
 
     do {
-        quint8 * p=buf;
+        quint8 *p = buf;
+
         // Scan ahead looking for end of block, marked by ff ff
         do {
             p++;
-            if (p>=endbuf) {
+
+            if (p >= endbuf) {
                 delete flow;
                 delete leak;
                 delete pressure;
                 return false;
             }
-        } while (!((p[0]==0xff) && (p[1]==0xff)));
+        } while (!((p[0] == 0xff) && (p[1] == 0xff)));
 
         // The Pressure and lkaj codes are before the end of block marker
-        p-=3;
-        pr=p[1] << 8 | p[0];
-        lkaj=p[2];
-        int i=0;
+        p -= 3;
+        pr = p[1] << 8 | p[0];
+        lkaj = p[2];
+        int i = 0;
 
-        pressure->AddEvent(ti,pr);
+        pressure->AddEvent(ti, pr);
         //leak->AddEvent(ti,lkaj);
 
         do {
-            tmp=buf[1] << 8 | buf[0];
-            val=(EventDataType(tmp)/100.0)-lkaj;
-            if (val<-128) val=-128;
-            else if (val>128) val=128;
-            buf+=2;
+            tmp = buf[1] << 8 | buf[0];
+            val = (EventDataType(tmp) / 100.0) - lkaj;
 
-            pbuf[i++]=val;
-        } while (buf<p);
-        flow->AddWaveform(ti,pbuf,i,rate);
-        ti+=i*rate;
+            if (val < -128) { val = -128; }
+            else if (val > 128) { val = 128; }
 
-        buf=p+5;
+            buf += 2;
 
-        if (buf>=endbuf)
+            pbuf[i++] = val;
+        } while (buf < p);
+
+        flow->AddWaveform(ti, pbuf, i, rate);
+        ti += i * rate;
+
+        buf = p + 5;
+
+        if (buf >= endbuf) {
             break;
-    } while (!((buf[0]==0xff) && (buf[1]==0x7f)));
+        }
+    } while (!((buf[0] == 0xff) && (buf[1] == 0x7f)));
 
 
     if (sess) {
-        sess->setLast(CPAP_FlowRate,ti);
-        sess->setLast(CPAP_MaskPressure,ti);
+        sess->setLast(CPAP_FlowRate, ti);
+        sess->setLast(CPAP_MaskPressure, ti);
         sess->eventlist[CPAP_FlowRate].push_back(flow);
-       // sess->eventlist[CPAP_Leak].push_back(leak);
+        // sess->eventlist[CPAP_Leak].push_back(leak);
         sess->eventlist[CPAP_MaskPressure].push_back(pressure);
     }
-    if (newsess)
-        mach->AddSession(sess,profile);
+
+    if (newsess) {
+        mach->AddSession(sess, profile);
+    }
+
     return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////
 // Open Summary file
 ////////////////////////////////////////////////////////////////////////////////////////////
-bool FPIconLoader::OpenSummary(Machine * mach,QString filename, Profile * profile)
+bool FPIconLoader::OpenSummary(Machine *mach, QString filename, Profile *profile)
 {
     qDebug() << filename;
     QByteArray header;
     QFile file(filename);
+
     if (!file.open(QFile::ReadOnly)) {
         qDebug() << "Couldn't open" << filename;
         return false;
     }
-    header=file.read(0x200);
-    if (header.size()!=0x200) {
+
+    header = file.read(0x200);
+
+    if (header.size() != 0x200) {
         qDebug() << "Short file" << filename;
         return false;
     }
-    unsigned char hsum=0xff;
-    for (int i=0;i<0x1ff;i++) {
-        hsum+=header[i];
+
+    unsigned char hsum = 0xff;
+
+    for (int i = 0; i < 0x1ff; i++) {
+        hsum += header[i];
     }
-    if (hsum!=header[0x1ff]) {
+
+    if (hsum != header[0x1ff]) {
         qDebug() << "Header checksum mismatch" << filename;
     }
+
     QTextStream htxt(&header);
-    QString h1,version,fname,serial,model,type;
+    QString h1, version, fname, serial, model, type;
     htxt >> h1;
     htxt >> version;
     htxt >> fname;
     htxt >> serial;
     htxt >> model;
     htxt >> type;
-    mach->properties[STR_PROP_Model]=model+" "+type;
+    mach->properties[STR_PROP_Model] = model + " " + type;
 
 
     QByteArray data;
-    data=file.readAll();
+    data = file.readAll();
     //long size=data.size(),pos=0;
     QDataStream in(data);
     in.setVersion(QDataStream::Qt_4_6);
@@ -534,50 +584,51 @@ bool FPIconLoader::OpenSummary(Machine * mach,QString filename, Profile * profil
     quint16 t1;//,t2;
     quint32 ts;
     //QByteArray line;
-    unsigned char a1,a2, a3,a4, a5, p1, p2,  p3, p4, p5, j1, j2, j3 ,j4,j5,j6,j7, x1, x2;
+    unsigned char a1, a2, a3, a4, a5, p1, p2,  p3, p4, p5, j1, j2, j3 , j4, j5, j6, j7, x1, x2;
 
-    quint16 d1,d2,d3;
+    quint16 d1, d2, d3;
 
 
     QDateTime datetime;
 
-    int runtime,usage;
+    int runtime, usage;
 
-    int day,month,year,hour,minute,second;
+    int day, month, year, hour, minute, second;
     QDate date;
 
     do {
         in >> a1;
         in >> a2;
-        t1=a2 << 8 | a1;
+        t1 = a2 << 8 | a1;
 
-        if (t1==0xfafe)
+        if (t1 == 0xfafe) {
             break;
+        }
 
-        day=t1 & 0x1f;
-        month=(t1 >> 5) & 0x0f;
-        year=2000+((t1 >> 9) & 0x3f);
+        day = t1 & 0x1f;
+        month = (t1 >> 5) & 0x0f;
+        year = 2000 + ((t1 >> 9) & 0x3f);
 
         in >> a1;
         in >> a2;
 
-        ts=((a2 << 8) | a1) << 1;
-        ts|=(t1 >> 15) & 1;
+        ts = ((a2 << 8) | a1) << 1;
+        ts |= (t1 >> 15) & 1;
 
-        second=(ts & 0x3f);
-        minute=(ts >> 6) & 0x3f;
-        hour=(ts >> 12) & 0x1f;
+        second = (ts & 0x3f);
+        minute = (ts >> 6) & 0x3f;
+        hour = (ts >> 12) & 0x1f;
 
-        datetime=QDateTime(QDate(year,month,day),QTime(hour,minute,second));
+        datetime = QDateTime(QDate(year, month, day), QTime(hour, minute, second));
 
-        date=datetime.date();
-        ts=datetime.toTime_t();
+        date = datetime.date();
+        ts = datetime.toTime_t();
 
         // the following two quite often match in value
         in >> a1;  // 0x04 Run Time
         in >> a2;  // 0x05 Usage Time
-        runtime=a1 * 360; // durations are in tenth of an hour intervals
-        usage=a2 * 360;
+        runtime = a1 * 360; // durations are in tenth of an hour intervals
+        usage = a2 * 360;
 
         in >> a3;  // 0x06  // Ramps???
         in >> a4;  // 0x07  // a pressure value?
@@ -606,37 +657,39 @@ bool FPIconLoader::OpenSummary(Machine * mach,QString filename, Profile * profil
         in >> x2;  // 0x1c    // humidifier setting
 
         if (!mach->SessionExists(ts)) {
-            Session *sess=new Session(mach,ts);
-            sess->really_set_first(qint64(ts)*1000L);
-            sess->really_set_last(qint64(ts+usage)*1000L);
+            Session *sess = new Session(mach, ts);
+            sess->really_set_first(qint64(ts) * 1000L);
+            sess->really_set_last(qint64(ts + usage) * 1000L);
             sess->SetChanged(true);
             sess->setCount(CPAP_Obstructive, j2);
             sess->setCount(CPAP_Hypopnea, j3);
-            SessDate.insert(date,sess);
-//            sess->setCount(CPAP_Obstructive,j1);
-//            sess->setCount(CPAP_Hypopnea,j2);
-//            sess->setCount(CPAP_ClearAirway,j3);
-//            sess->setCount(CPAP_Apnea,j4);
+            SessDate.insert(date, sess);
+
+            //            sess->setCount(CPAP_Obstructive,j1);
+            //            sess->setCount(CPAP_Hypopnea,j2);
+            //            sess->setCount(CPAP_ClearAirway,j3);
+            //            sess->setCount(CPAP_Apnea,j4);
             //sess->setCount(CPAP_,j5);
-            if (p1!=p2) {
-                sess->settings[CPAP_Mode]=(int)MODE_APAP;
-                sess->settings[CPAP_PressureMin]=p3/10.0;
-                sess->settings[CPAP_PressureMax]=p4/10.0;
+            if (p1 != p2) {
+                sess->settings[CPAP_Mode] = (int)MODE_APAP;
+                sess->settings[CPAP_PressureMin] = p3 / 10.0;
+                sess->settings[CPAP_PressureMax] = p4 / 10.0;
             } else {
-                sess->settings[CPAP_Mode]=(int)MODE_CPAP;
-                sess->settings[CPAP_Pressure]=p1/10.0;
+                sess->settings[CPAP_Mode] = (int)MODE_CPAP;
+                sess->settings[CPAP_Pressure] = p1 / 10.0;
             }
-            sess->settings[CPAP_HumidSetting]=x2;
+
+            sess->settings[CPAP_HumidSetting] = x2;
             //sess->settings[CPAP_PresReliefType]=PR_SENSAWAKE;
-            Sessions[ts]=sess;
-            mach->AddSession(sess,profile);
+            Sessions[ts] = sess;
+            mach->AddSession(sess, profile);
         }
     } while (!in.atEnd());
 
     return true;
 }
 
-bool FPIconLoader::OpenDetail(Machine * mach, QString filename, Profile * profile)
+bool FPIconLoader::OpenDetail(Machine *mach, QString filename, Profile *profile)
 {
     Q_UNUSED(mach);
     Q_UNUSED(profile);
@@ -644,25 +697,31 @@ bool FPIconLoader::OpenDetail(Machine * mach, QString filename, Profile * profil
     qDebug() << filename;
     QByteArray header;
     QFile file(filename);
+
     if (!file.open(QFile::ReadOnly)) {
         qDebug() << "Couldn't open" << filename;
         return false;
     }
-    header=file.read(0x200);
-    if (header.size()!=0x200) {
+
+    header = file.read(0x200);
+
+    if (header.size() != 0x200) {
         qDebug() << "Short file" << filename;
         return false;
     }
-    unsigned char hsum=0;
-    for (int i=0;i<0x1ff;i++) {
-        hsum+=header[i];
+
+    unsigned char hsum = 0;
+
+    for (int i = 0; i < 0x1ff; i++) {
+        hsum += header[i];
     }
-    if (hsum!=header[0x1ff]) {
+
+    if (hsum != header[0x1ff]) {
         qDebug() << "Header checksum mismatch" << filename;
     }
 
     QByteArray index;
-    index=file.read(0x800);
+    index = file.read(0x800);
     //long size=index.size(),pos=0;
     QDataStream in(index);
 
@@ -681,45 +740,48 @@ bool FPIconLoader::OpenDetail(Machine * mach, QString filename, Profile * profil
 
     quint16 t1;
     quint16 strt;
-    quint8 recs,z1,z2;
+    quint8 recs, z1, z2;
 
-    int day,month,year,hour,minute,second;
+    int day, month, year, hour, minute, second;
+
+    int totalrecs = 0;
 
-    int totalrecs=0;
     do {
         in >> z1;
         in >> z2;
-        t1=z2 << 8 | z1;
+        t1 = z2 << 8 | z1;
 
-        if (t1==0xfafe)
+        if (t1 == 0xfafe) {
             break;
+        }
 
-        day=t1 & 0x1f;
-        month=(t1 >> 5) & 0x0f;
-        year=2000+((t1 >> 9) & 0x3f);
+        day = t1 & 0x1f;
+        month = (t1 >> 5) & 0x0f;
+        year = 2000 + ((t1 >> 9) & 0x3f);
 
         in >> z1;
         in >> z2;
         //
 
-        ts=((z2 << 8) | z1) << 1;
-        ts|=(t1 >> 15) & 1;
+        ts = ((z2 << 8) | z1) << 1;
+        ts |= (t1 >> 15) & 1;
 
         //
-        second=(ts & 0x3f);
-        minute=(ts >> 6) & 0x3f;
-        hour=(ts >> 12) & 0x1f;
+        second = (ts & 0x3f);
+        minute = (ts >> 6) & 0x3f;
+        hour = (ts >> 12) & 0x1f;
 
-        datetime=QDateTime(QDate(year,month,day),QTime(hour,minute,second));
+        datetime = QDateTime(QDate(year, month, day), QTime(hour, minute, second));
         //datetime=datetime.toTimeSpec(Qt::UTC);
 
-        ts=datetime.toTime_t();
+        ts = datetime.toTime_t();
 
-        date=datetime.date();
-        time=datetime.time();
+        date = datetime.date();
+        time = datetime.time();
         in >> strt;
         in >> recs;
-        totalrecs+=recs;
+        totalrecs += recs;
+
         if (Sessions.contains(ts)) {
             times.push_back(ts);
             start.push_back(strt);
@@ -727,108 +789,123 @@ bool FPIconLoader::OpenDetail(Machine * mach, QString filename, Profile * profil
         }
     } while (!in.atEnd());
 
-    QByteArray databytes=file.readAll();
+    QByteArray databytes = file.readAll();
 
     in.setVersion(QDataStream::Qt_4_6);
     in.setByteOrder(QDataStream::BigEndian);
     // 5 byte repeating patterns
 
-    quint8 * data=(quint8 *)databytes.data();
+    quint8 *data = (quint8 *)databytes.data();
 
     qint64 ti;
-    quint8 pressure,leak, a1,a2,a3;
+    quint8 pressure, leak, a1, a2, a3;
     SessionID sessid;
     Session *sess;
     int idx;
-    for (int r=0;r<start.size();r++) {
-        sessid=times[r];
-        sess=Sessions[sessid];
-        ti=qint64(sessid)*1000L;
+
+    for (int r = 0; r < start.size(); r++) {
+        sessid = times[r];
+        sess = Sessions[sessid];
+        ti = qint64(sessid) * 1000L;
         sess->really_set_first(ti);
-        EventList * LK=sess->AddEventList(CPAP_LeakTotal,EVL_Event,1);
-        EventList * PR=sess->AddEventList(CPAP_Pressure,EVL_Event,0.1);
-        EventList * FLG=sess->AddEventList(CPAP_FLG,EVL_Event);
-        EventList * OA=sess->AddEventList(CPAP_Obstructive,EVL_Event);
-        EventList * H=sess->AddEventList(CPAP_Hypopnea,EVL_Event);
-        EventList * FL=sess->AddEventList(CPAP_FlowLimit,EVL_Event);
+        EventList *LK = sess->AddEventList(CPAP_LeakTotal, EVL_Event, 1);
+        EventList *PR = sess->AddEventList(CPAP_Pressure, EVL_Event, 0.1);
+        EventList *FLG = sess->AddEventList(CPAP_FLG, EVL_Event);
+        EventList *OA = sess->AddEventList(CPAP_Obstructive, EVL_Event);
+        EventList *H = sess->AddEventList(CPAP_Hypopnea, EVL_Event);
+        EventList *FL = sess->AddEventList(CPAP_FlowLimit, EVL_Event);
 
-        unsigned stidx=start[r];
-        int rec=records[r];
+        unsigned stidx = start[r];
+        int rec = records[r];
 
-        idx=stidx*15;
-        for (int i=0;i<rec;i++) {
-            for (int j=0;j<3;j++) {
-                pressure=data[idx];
-                leak=data[idx+1];
-                a1=data[idx+2];
-                a2=data[idx+3];
-                a3=data[idx+4];
-                PR->AddEvent(ti,pressure);
-                LK->AddEvent(ti,leak);
-                if (a1>0) OA->AddEvent(ti,a1);
-                if (a2>0) H->AddEvent(ti,a2);
-                if (a3>0) FL->AddEvent(ti,a3);
-                FLG->AddEvent(ti,a3);
-                ti+=120000L;
-                idx+=5;
+        idx = stidx * 15;
+
+        for (int i = 0; i < rec; i++) {
+            for (int j = 0; j < 3; j++) {
+                pressure = data[idx];
+                leak = data[idx + 1];
+                a1 = data[idx + 2];
+                a2 = data[idx + 3];
+                a3 = data[idx + 4];
+                PR->AddEvent(ti, pressure);
+                LK->AddEvent(ti, leak);
+
+                if (a1 > 0) { OA->AddEvent(ti, a1); }
+
+                if (a2 > 0) { H->AddEvent(ti, a2); }
+
+                if (a3 > 0) { FL->AddEvent(ti, a3); }
+
+                FLG->AddEvent(ti, a3);
+                ti += 120000L;
+                idx += 5;
             }
         }
-      //  sess->really_set_last(ti-360000L);
-//        sess->SetChanged(true);
- //       mach->AddSession(sess,profile);
+
+        //  sess->really_set_last(ti-360000L);
+        //        sess->SetChanged(true);
+        //       mach->AddSession(sess,profile);
     }
 
     return 1;
 }
 
 
-Machine *FPIconLoader::CreateMachine(QString serial,Profile *profile)
+Machine *FPIconLoader::CreateMachine(QString serial, Profile *profile)
 {
-    if (!profile)
+    if (!profile) {
         return NULL;
+    }
+
     qDebug() << "Create Machine " << serial;
 
-    QList<Machine *> ml=profile->GetMachines(MT_CPAP);
-    bool found=false;
+    QList<Machine *> ml = profile->GetMachines(MT_CPAP);
+    bool found = false;
     QList<Machine *>::iterator i;
     Machine *m;
-    for (i=ml.begin(); i!=ml.end(); i++) {
-        if (((*i)->GetClass()==fpicon_class_name) && ((*i)->properties[STR_PROP_Serial]==serial)) {
-            MachList[serial]=*i;
-            found=true;
-            m=*i;
+
+    for (i = ml.begin(); i != ml.end(); i++) {
+        if (((*i)->GetClass() == fpicon_class_name) && ((*i)->properties[STR_PROP_Serial] == serial)) {
+            MachList[serial] = *i;
+            found = true;
+            m = *i;
             break;
         }
     }
+
     if (!found) {
-        m=new FPIcon(profile,0);
+        m = new FPIcon(profile, 0);
     }
-    m->properties[STR_PROP_Brand]="Fisher & Paykel";
-    m->properties[STR_PROP_Series]=STR_MACH_FPIcon;
-    m->properties[STR_PROP_Model]=STR_MACH_FPIcon;
-    if (found)
+
+    m->properties[STR_PROP_Brand] = "Fisher & Paykel";
+    m->properties[STR_PROP_Series] = STR_MACH_FPIcon;
+    m->properties[STR_PROP_Model] = STR_MACH_FPIcon;
+
+    if (found) {
         return m;
+    }
 
 
-    MachList[serial]=m;
+    MachList[serial] = m;
     profile->AddMachine(m);
 
-    m->properties[STR_PROP_Serial]=serial;
-    m->properties[STR_PROP_DataVersion]=QString::number(fpicon_data_version);
+    m->properties[STR_PROP_Serial] = serial;
+    m->properties[STR_PROP_DataVersion] = QString::number(fpicon_data_version);
 
-    QString path="{"+STR_GEN_DataFolder+"}/"+m->GetClass()+"_"+serial+"/";
-    m->properties[STR_PROP_Path]=path;
-    m->properties[STR_PROP_BackupPath]=path+"Backup/";
+    QString path = "{" + STR_GEN_DataFolder + "}/" + m->GetClass() + "_" + serial + "/";
+    m->properties[STR_PROP_Path] = path;
+    m->properties[STR_PROP_BackupPath] = path + "Backup/";
 
     return m;
 }
 
-bool fpicon_initialized=false;
+bool fpicon_initialized = false;
 void FPIconLoader::Register()
 {
-    if (fpicon_initialized) return;
+    if (fpicon_initialized) { return; }
+
     qDebug() << "Registering F&P Icon Loader";
     RegisterLoader(new FPIconLoader());
     //InitModelMap();
-    fpicon_initialized=true;
+    fpicon_initialized = true;
 }
diff --git a/sleepyhead/SleepLib/loader_plugins/icon_loader.h b/sleepyhead/SleepLib/loader_plugins/icon_loader.h
index 389c7b09..e078973f 100644
--- a/sleepyhead/SleepLib/loader_plugins/icon_loader.h
+++ b/sleepyhead/SleepLib/loader_plugins/icon_loader.h
@@ -23,25 +23,25 @@
 //********************************************************************************************
 // Please INCREMENT the following value when making changes to this loaders implementation.
 //
-const int fpicon_data_version=2;
+const int fpicon_data_version = 2;
 //
 //********************************************************************************************
 
 /*! \class FPIcon
     \brief F&P Icon customized machine object
     */
-class FPIcon:public CPAP
+class FPIcon: public CPAP
 {
-public:
-    FPIcon(Profile *p,MachineID id=0);
+  public:
+    FPIcon(Profile *p, MachineID id = 0);
     virtual ~FPIcon();
 };
 
 
-const int fpicon_load_buffer_size=1024*1024;
+const int fpicon_load_buffer_size = 1024 * 1024;
 
 
-const QString fpicon_class_name=STR_MACH_FPIcon;
+const QString fpicon_class_name = STR_MACH_FPIcon;
 
 /*! \class FPIconLoader
     \brief Loader for Fisher & Paykel Icon data
@@ -50,38 +50,38 @@ const QString fpicon_class_name=STR_MACH_FPIcon;
 
 class FPIconLoader : public MachineLoader
 {
-public:
+  public:
     FPIconLoader();
     virtual ~FPIconLoader();
 
     //! \brief Scans path for F&P Icon data signature, and Loads any new data
-    virtual int Open(QString & path,Profile *profile);
+    virtual int Open(QString &path, Profile *profile);
 
-    int OpenMachine(Machine *mach, QString & path, Profile * profile);
+    int OpenMachine(Machine *mach, QString &path, Profile *profile);
 
-    bool OpenSummary(Machine *mach, QString path, Profile * profile);
-    bool OpenDetail(Machine *mach, QString path, Profile * profile);
-    bool OpenFLW(Machine * mach,QString filename, Profile * profile);
+    bool OpenSummary(Machine *mach, QString path, Profile *profile);
+    bool OpenDetail(Machine *mach, QString path, Profile *profile);
+    bool OpenFLW(Machine *mach, QString filename, Profile *profile);
 
     //! \brief Returns SleepLib database version of this F&P Icon loader
     virtual int Version() { return fpicon_data_version; }
 
     //! \brief Returns the machine class name of this CPAP machine, "FPIcon"
-    virtual const QString & ClassName() { return fpicon_class_name; }
+    virtual const QString &ClassName() { return fpicon_class_name; }
 
     //! \brief Creates a machine object, indexed by serial number
-    Machine *CreateMachine(QString serial,Profile *profile);
+    Machine *CreateMachine(QString serial, Profile *profile);
 
     //! \brief Registers this MachineLoader with the master list, so F&P Icon data can load
     static void Register();
 
-protected:
-    QDateTime readFPDateTime(quint8 * data);
+  protected:
+    QDateTime readFPDateTime(quint8 *data);
 
     QString last;
-    QHash<QString,Machine *> MachList;
+    QHash<QString, Machine *> MachList;
     QMap<SessionID, Session *> Sessions;
-    QMultiMap<QDate,Session *> SessDate;
+    QMultiMap<QDate, Session *> SessDate;
     //QMap<int,QList<EventList *> > FLWMapFlow;
     //QMap<int,QList<EventList *> > FLWMapLeak;
     //QMap<int,QList<EventList *> > FLWMapPres;
@@ -89,7 +89,7 @@ protected:
     //QMap<int,QList<qint64> > FLWTS;
     //QMap<int,QDate> FLWDate;
 
-    unsigned char * m_buffer;
+    unsigned char *m_buffer;
 };
 
 #endif // ICON_LOADER_H
diff --git a/sleepyhead/SleepLib/loader_plugins/intellipap_loader.cpp b/sleepyhead/SleepLib/loader_plugins/intellipap_loader.cpp
index de6a7200..43d5c663 100644
--- a/sleepyhead/SleepLib/loader_plugins/intellipap_loader.cpp
+++ b/sleepyhead/SleepLib/loader_plugins/intellipap_loader.cpp
@@ -17,10 +17,10 @@
 
 extern QProgressBar *qprogress;
 
-Intellipap::Intellipap(Profile *p,MachineID id)
-    :CPAP(p,id)
+Intellipap::Intellipap(Profile *p, MachineID id)
+    : CPAP(p, id)
 {
-    m_class=intellipap_class_name;
+    m_class = intellipap_class_name;
 }
 
 Intellipap::~Intellipap()
@@ -29,27 +29,28 @@ Intellipap::~Intellipap()
 
 IntellipapLoader::IntellipapLoader()
 {
-    m_buffer=NULL;
+    m_buffer = NULL;
 }
 
 IntellipapLoader::~IntellipapLoader()
 {
 }
 
-int IntellipapLoader::Open(QString & path,Profile *profile)
+int IntellipapLoader::Open(QString &path, Profile *profile)
 {
     // Check for SL directory
     // Check for DV5MFirm.bin?
     QString newpath;
 
-    path=path.replace("\\","/");
+    path = path.replace("\\", "/");
 
-    QString dirtag="SL";
-    if (path.endsWith("/"+dirtag)) {
+    QString dirtag = "SL";
+
+    if (path.endsWith("/" + dirtag)) {
         return 0;
         //newpath=path;
     } else {
-        newpath=path+"/"+dirtag;
+        newpath = path + "/" + dirtag;
     }
 
     QString filename;
@@ -57,84 +58,94 @@ int IntellipapLoader::Open(QString & path,Profile *profile)
     //////////////////////////
     // Parse the Settings File
     //////////////////////////
-    filename=newpath+"/SET1";
+    filename = newpath + "/SET1";
     QFile f(filename);
-    if (!f.exists()) return 0;
+
+    if (!f.exists()) { return 0; }
+
     f.open(QFile::ReadOnly);
     QTextStream tstream(&f);
 
-    QHash<QString,QString> lookup;
-    lookup["Sn"]=STR_PROP_Serial;
-    lookup["Mn"]=STR_PROP_ModelNumber;
-    lookup["Mo"]="PAPMode"; // 0=cpap, 1=auto
+    QHash<QString, QString> lookup;
+    lookup["Sn"] = STR_PROP_Serial;
+    lookup["Mn"] = STR_PROP_ModelNumber;
+    lookup["Mo"] = "PAPMode"; // 0=cpap, 1=auto
     //lookup["Pn"]="Pn";
-    lookup["Pu"]="MaxPressure";
-    lookup["Pl"]="MinPressure";
+    lookup["Pu"] = "MaxPressure";
+    lookup["Pl"] = "MinPressure";
     //lookup["Ds"]="Ds";
     //lookup["Pc"]="Pc";
-    lookup["Pd"]="RampPressure"; // Delay Pressure
-    lookup["Dt"]="RampTime";  // Delay Time
+    lookup["Pd"] = "RampPressure"; // Delay Pressure
+    lookup["Dt"] = "RampTime"; // Delay Time
     //lookup["Ld"]="Ld";
     //lookup["Lh"]="Lh";
     //lookup["FC"]="FC";
     //lookup["FE"]="FE";
     //lookup["FL"]="FL";
-    lookup["A%"]="ApneaThreshold";
-    lookup["Ad"]="ApneaDuration";
-    lookup["H%"]="HypopneaThreshold";
-    lookup["Hd"]="HypopneaDuration";
+    lookup["A%"] = "ApneaThreshold";
+    lookup["Ad"] = "ApneaDuration";
+    lookup["H%"] = "HypopneaThreshold";
+    lookup["Hd"] = "HypopneaDuration";
     //lookup["Pi"]="Pi"; //080
     //lookup["Pe"]="Pe"; //WF
-    lookup["Ri"]="SmartFlexIRnd"; // Inhale Rounding (0-5)
-    lookup["Re"]="SmartFlexERnd"; // Exhale Rounding (0-5)
+    lookup["Ri"] = "SmartFlexIRnd"; // Inhale Rounding (0-5)
+    lookup["Re"] = "SmartFlexERnd"; // Exhale Rounding (0-5)
     //lookup["Bu"]="Bu"; //WF
     //lookup["Ie"]="Ie"; //20
     //lookup["Se"]="Se"; //05
     //lookup["Si"]="Si"; //05
     //lookup["Mi"]="Mi"; //0
-    lookup["Uh"]="HoursMeter"; //0000.0
-    lookup["Up"]="ComplianceMeter"; //0000.0
+    lookup["Uh"] = "HoursMeter"; //0000.0
+    lookup["Up"] = "ComplianceMeter"; //0000.0
     //lookup["Er"]="ErrorCode"; // E00
     //lookup["El"]="LastErrorCode"; // E00 00/00/0000
     //lookup["Hp"]="Hp"; //1
     //lookup["Hs"]="Hs"; //02
     //lookup["Lu"]="LowUseThreshold"; // defaults to 0 (4 hours)
-    lookup["Sf"]="SmartFlex";
-    lookup["Sm"]="SmartFlexMode";
-    lookup["Ks=s"]="Ks_s";
-    lookup["Ks=i"]="Ks_i";
+    lookup["Sf"] = "SmartFlex";
+    lookup["Sm"] = "SmartFlexMode";
+    lookup["Ks=s"] = "Ks_s";
+    lookup["Ks=i"] = "Ks_i";
+
+    QHash<QString, QString> set1;
+    QHash<QString, QString>::iterator hi;
 
-    QHash<QString,QString> set1;
-    QHash<QString,QString>::iterator hi;
     while (1) {
-        QString line=tstream.readLine();
-        if ((line.length()<=2) ||
-           (line.isNull())) break;
-        QString key=line.section("\t",0,0).trimmed();
-        hi=lookup.find(key);
-        if (hi!=lookup.end()) {
-            key=hi.value();
+        QString line = tstream.readLine();
+
+        if ((line.length() <= 2) ||
+                (line.isNull())) { break; }
+
+        QString key = line.section("\t", 0, 0).trimmed();
+        hi = lookup.find(key);
+
+        if (hi != lookup.end()) {
+            key = hi.value();
         }
 
-        QString value=line.section("\t",1).trimmed();
-        set1[key]=value;
+        QString value = line.section("\t", 1).trimmed();
+        set1[key] = value;
         qDebug() << key << "=" << value;
     }
 
-    Machine *mach=NULL;
+    Machine *mach = NULL;
+
     if (set1.contains(STR_PROP_Serial)) {
-        mach=CreateMachine(set1[STR_PROP_Serial],profile);
+        mach = CreateMachine(set1[STR_PROP_Serial], profile);
     }
+
     if (!mach) {
         qDebug() << "Couldn't get Intellipap machine record";
         return 0;
     }
 
     // Refresh properties data..
-    for (QHash<QString,QString>::iterator i=set1.begin();i!=set1.end();i++) {
-        mach->properties[i.key()]=i.value();
+    for (QHash<QString, QString>::iterator i = set1.begin(); i != set1.end(); i++) {
+        mach->properties[i.key()] = i.value();
     }
-    mach->properties[STR_PROP_Model]=STR_MACH_Intellipap+" "+mach->properties[STR_PROP_ModelNumber];
+
+    mach->properties[STR_PROP_Model] = STR_MACH_Intellipap + " " +
+                                       mach->properties[STR_PROP_ModelNumber];
 
     f.close();
 
@@ -142,85 +153,92 @@ int IntellipapLoader::Open(QString & path,Profile *profile)
     // Parse the Session Index
     //////////////////////////
     unsigned char buf[27];
-    filename=newpath+"/U";
+    filename = newpath + "/U";
     f.setFileName(filename);
-    if (!f.exists()) return 0;
+
+    if (!f.exists()) { return 0; }
 
     QVector<quint32> SessionStart;
     QVector<quint32> SessionEnd;
-    QHash<SessionID,Session *> Sessions;
+    QHash<SessionID, Session *> Sessions;
 
     quint32 ts1, ts2;//, length;
     //unsigned char cs;
     f.open(QFile::ReadOnly);
-    int cnt=0;
-    QDateTime epoch(QDate(2002,1,1),QTime(0,0,0),Qt::UTC); // Intellipap Epoch
-    int ep=epoch.toTime_t();
+    int cnt = 0;
+    QDateTime epoch(QDate(2002, 1, 1), QTime(0, 0, 0), Qt::UTC); // Intellipap Epoch
+    int ep = epoch.toTime_t();
+
     do {
-        cnt=f.read((char *)buf,9);
-        ts1=(buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
-        ts2=(buf[4] << 24) | (buf[5] << 16) | (buf[6] << 8) | buf[7];
-        ts1+=ep;
-        ts2+=ep;
+        cnt = f.read((char *)buf, 9);
+        ts1 = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
+        ts2 = (buf[4] << 24) | (buf[5] << 16) | (buf[6] << 8) | buf[7];
+        ts1 += ep;
+        ts2 += ep;
         SessionStart.append(ts1);
         SessionEnd.append(ts2);
         //cs=buf[8];
-    } while (cnt>0);
+    } while (cnt > 0);
+
     qDebug() << "U file logs" << SessionStart.size() << "sessions.";
     f.close();
 
     //////////////////////////
     // Parse the Session Data
     //////////////////////////
-    filename=newpath+"/L";
+    filename = newpath + "/L";
     f.setFileName(filename);
-    if (!f.exists()) return 0;
+
+    if (!f.exists()) { return 0; }
 
     f.open(QFile::ReadOnly);
-    long size=f.size();
-    int recs=size/26;
-    m_buffer=new unsigned char [size];
+    long size = f.size();
+    int recs = size / 26;
+    m_buffer = new unsigned char [size];
 
-    if (size!=f.read((char *)m_buffer,size)) {
-        qDebug()  << "Couldn't read 'L' data"<< filename;
+    if (size != f.read((char *)m_buffer, size)) {
+        qDebug()  << "Couldn't read 'L' data" << filename;
         return 0;
     }
 
     Session *sess;
     SessionID sid;
-    for (int i=0;i<SessionStart.size();i++) {
-        sid=SessionStart[i];
+
+    for (int i = 0; i < SessionStart.size(); i++) {
+        sid = SessionStart[i];
+
         if (mach->SessionExists(sid)) {
             // knock out the already imported sessions..
-            SessionStart[i]=0;
-            SessionEnd[i]=0;
+            SessionStart[i] = 0;
+            SessionEnd[i] = 0;
         } else if (!Sessions.contains(sid)) {
-            sess=Sessions[sid]=new Session(mach,sid);
+            sess = Sessions[sid] = new Session(mach, sid);
             sess->SetChanged(true);
-            sess->AddEventList(CPAP_IPAP,EVL_Event);
-            sess->AddEventList(CPAP_EPAP,EVL_Event);
-            sess->AddEventList(CPAP_Pressure,EVL_Event);
+            sess->AddEventList(CPAP_IPAP, EVL_Event);
+            sess->AddEventList(CPAP_EPAP, EVL_Event);
+            sess->AddEventList(CPAP_Pressure, EVL_Event);
 
-            sess->AddEventList(INTELLIPAP_Unknown1,EVL_Event);
-            sess->AddEventList(INTELLIPAP_Unknown2,EVL_Event);
+            sess->AddEventList(INTELLIPAP_Unknown1, EVL_Event);
+            sess->AddEventList(INTELLIPAP_Unknown2, EVL_Event);
 
-            sess->AddEventList(CPAP_LeakTotal,EVL_Event);
-            sess->AddEventList(CPAP_MaxLeak,EVL_Event);
-            sess->AddEventList(CPAP_TidalVolume,EVL_Event);
-            sess->AddEventList(CPAP_MinuteVent,EVL_Event);
-            sess->AddEventList(CPAP_RespRate,EVL_Event);
-            sess->AddEventList(CPAP_Snore,EVL_Event);
+            sess->AddEventList(CPAP_LeakTotal, EVL_Event);
+            sess->AddEventList(CPAP_MaxLeak, EVL_Event);
+            sess->AddEventList(CPAP_TidalVolume, EVL_Event);
+            sess->AddEventList(CPAP_MinuteVent, EVL_Event);
+            sess->AddEventList(CPAP_RespRate, EVL_Event);
+            sess->AddEventList(CPAP_Snore, EVL_Event);
         } else {
             // If there is a double up, null out the earlier session
             // otherwise there will be a crash on shutdown.
-            for (int z=0;z<SessionStart.size();z++) {
-                if (SessionStart[z]==(quint32)sid) {
-                    SessionStart[z]=0;
-                    SessionEnd[z]=0;
+            for (int z = 0; z < SessionStart.size(); z++) {
+                if (SessionStart[z] == (quint32)sid) {
+                    SessionStart[z] = 0;
+                    SessionEnd[z] = 0;
                     break;
                 }
             }
-            QDateTime d=QDateTime::fromTime_t(sid);
+
+            QDateTime d = QDateTime::fromTime_t(sid);
             qDebug() << sid << "has double ups" << d;
             /*Session *sess=Sessions[sid];
             Sessions.erase(Sessions.find(sid));
@@ -230,197 +248,226 @@ int IntellipapLoader::Open(QString & path,Profile *profile)
         }
     }
 
-    long pos=0;
-    for (int i=0;i<recs;i++) {
+    long pos = 0;
+
+    for (int i = 0; i < recs; i++) {
         // convert timestamp to real epoch
-        ts1=((m_buffer[pos] << 24) | (m_buffer[pos+1] << 16) | (m_buffer[pos+2] << 8) | m_buffer[pos+3]) + ep;
+        ts1 = ((m_buffer[pos] << 24) | (m_buffer[pos + 1] << 16) | (m_buffer[pos + 2] << 8) | m_buffer[pos
+                + 3]) + ep;
 
-        for (int j=0;j<SessionStart.size();j++) {
-            sid=SessionStart[j];
-            if (!sid) continue;
-            if ((ts1>=(quint32)sid) && (ts1<=SessionEnd[j])){
-                Session *sess=Sessions[sid];
-                qint64 time=quint64(ts1)*1000L;
-                sess->eventlist[CPAP_Pressure][0]->AddEvent(time,m_buffer[pos+0xd]/10.0); // current pressure
-                sess->eventlist[CPAP_EPAP][0]->AddEvent(time,m_buffer[pos+0x13]/10.0); // epap / low
-                sess->eventlist[CPAP_IPAP][0]->AddEvent(time,m_buffer[pos+0x14]/10.0); // ipap / high
+        for (int j = 0; j < SessionStart.size(); j++) {
+            sid = SessionStart[j];
 
-                sess->eventlist[CPAP_LeakTotal][0]->AddEvent(time,m_buffer[pos+0x7]); // "Average Leak"
-                sess->eventlist[CPAP_MaxLeak][0]->AddEvent(time,m_buffer[pos+0x6]); // "Max Leak"
+            if (!sid) { continue; }
 
-                int rr=m_buffer[pos+0xa];
-                sess->eventlist[CPAP_RespRate][0]->AddEvent(time,rr); // Respiratory Rate
-                sess->eventlist[INTELLIPAP_Unknown1][0]->AddEvent(time,m_buffer[pos+0xf]); //
-                sess->eventlist[INTELLIPAP_Unknown1][0]->AddEvent(time,m_buffer[pos+0xc]);
+            if ((ts1 >= (quint32)sid) && (ts1 <= SessionEnd[j])) {
+                Session *sess = Sessions[sid];
+                qint64 time = quint64(ts1) * 1000L;
+                sess->eventlist[CPAP_Pressure][0]->AddEvent(time, m_buffer[pos + 0xd] / 10.0); // current pressure
+                sess->eventlist[CPAP_EPAP][0]->AddEvent(time, m_buffer[pos + 0x13] / 10.0); // epap / low
+                sess->eventlist[CPAP_IPAP][0]->AddEvent(time, m_buffer[pos + 0x14] / 10.0); // ipap / high
 
-                sess->eventlist[CPAP_Snore][0]->AddEvent(time,m_buffer[pos+0x4]); //4/5??
+                sess->eventlist[CPAP_LeakTotal][0]->AddEvent(time, m_buffer[pos + 0x7]); // "Average Leak"
+                sess->eventlist[CPAP_MaxLeak][0]->AddEvent(time, m_buffer[pos + 0x6]); // "Max Leak"
+
+                int rr = m_buffer[pos + 0xa];
+                sess->eventlist[CPAP_RespRate][0]->AddEvent(time, rr); // Respiratory Rate
+                sess->eventlist[INTELLIPAP_Unknown1][0]->AddEvent(time, m_buffer[pos + 0xf]); //
+                sess->eventlist[INTELLIPAP_Unknown1][0]->AddEvent(time, m_buffer[pos + 0xc]);
+
+                sess->eventlist[CPAP_Snore][0]->AddEvent(time, m_buffer[pos + 0x4]); //4/5??
 
                 // 0x0f == Leak Event
                 // 0x04 == Snore?
-                if (m_buffer[pos+0xf]>0) { // Leak Event
+                if (m_buffer[pos + 0xf] > 0) { // Leak Event
                     if (!sess->eventlist.contains(CPAP_LeakFlag)) {
-                        sess->AddEventList(CPAP_LeakFlag,EVL_Event);
+                        sess->AddEventList(CPAP_LeakFlag, EVL_Event);
                     }
-                    sess->eventlist[CPAP_LeakFlag][0]->AddEvent(time,m_buffer[pos+0xf]);
+
+                    sess->eventlist[CPAP_LeakFlag][0]->AddEvent(time, m_buffer[pos + 0xf]);
                 }
 
-                if (m_buffer[pos+0x5]>4) { // This matches Exhale Puff.. not sure why 4
+                if (m_buffer[pos + 0x5] > 4) { // This matches Exhale Puff.. not sure why 4
                     if (!sess->eventlist.contains(CPAP_ExP)) {
-                        sess->AddEventList(CPAP_ExP,EVL_Event);
+                        sess->AddEventList(CPAP_ExP, EVL_Event);
                     }
 
-                    for (int q=0;q<m_buffer[pos+0x5];q++)
-                        sess->eventlist[CPAP_ExP][0]->AddEvent(time,m_buffer[pos+0x5]);
+                    for (int q = 0; q < m_buffer[pos + 0x5]; q++) {
+                        sess->eventlist[CPAP_ExP][0]->AddEvent(time, m_buffer[pos + 0x5]);
+                    }
                 }
 
-                if (m_buffer[pos+0x10]>0) {
+                if (m_buffer[pos + 0x10] > 0) {
                     if (!sess->eventlist.contains(CPAP_Obstructive)) {
-                        sess->AddEventList(CPAP_Obstructive,EVL_Event);
+                        sess->AddEventList(CPAP_Obstructive, EVL_Event);
+                    }
+
+                    for (int q = 0; q < m_buffer[pos + 0x10]; q++) {
+                        sess->eventlist[CPAP_Obstructive][0]->AddEvent(time, m_buffer[pos + 0x10]);
                     }
-                    for (int q=0;q<m_buffer[pos+0x10];q++)
-                        sess->eventlist[CPAP_Obstructive][0]->AddEvent(time,m_buffer[pos+0x10]);
                 }
 
-                if (m_buffer[pos+0x11]>0) {
+                if (m_buffer[pos + 0x11] > 0) {
                     if (!sess->eventlist.contains(CPAP_Hypopnea)) {
-                        sess->AddEventList(CPAP_Hypopnea,EVL_Event);
+                        sess->AddEventList(CPAP_Hypopnea, EVL_Event);
+                    }
+
+                    for (int q = 0; q < m_buffer[pos + 0x11]; q++) {
+                        sess->eventlist[CPAP_Hypopnea][0]->AddEvent(time, m_buffer[pos + 0x11]);
                     }
-                    for (int q=0;q<m_buffer[pos+0x11];q++)
-                        sess->eventlist[CPAP_Hypopnea][0]->AddEvent(time,m_buffer[pos+0x11]);
                 }
-                if (m_buffer[pos+0x12]>0) { // NRI // is this == to RERA?? CA??
+
+                if (m_buffer[pos + 0x12] > 0) { // NRI // is this == to RERA?? CA??
                     if (!sess->eventlist.contains(CPAP_NRI)) {
-                        sess->AddEventList(CPAP_NRI,EVL_Event);
+                        sess->AddEventList(CPAP_NRI, EVL_Event);
+                    }
+
+                    for (int q = 0; q < m_buffer[pos + 0x12]; q++) {
+                        sess->eventlist[CPAP_NRI][0]->AddEvent(time, m_buffer[pos + 0x12]);
                     }
-                    for (int q=0;q<m_buffer[pos+0x12];q++)
-                        sess->eventlist[CPAP_NRI][0]->AddEvent(time,m_buffer[pos+0x12]);
                 }
-                quint16 tv=(m_buffer[pos+0x8] << 8) | m_buffer[pos+0x9]; // correct
 
-                sess->eventlist[CPAP_TidalVolume][0]->AddEvent(time,tv);
+                quint16 tv = (m_buffer[pos + 0x8] << 8) | m_buffer[pos + 0x9]; // correct
 
-                EventDataType mv=tv*rr; // MinuteVent=TidalVolume * Respiratory Rate
-                sess->eventlist[CPAP_MinuteVent][0]->AddEvent(time,mv/1000.0);
+                sess->eventlist[CPAP_TidalVolume][0]->AddEvent(time, tv);
+
+                EventDataType mv = tv * rr; // MinuteVent=TidalVolume * Respiratory Rate
+                sess->eventlist[CPAP_MinuteVent][0]->AddEvent(time, mv / 1000.0);
                 break;
             }
 
         }
-        pos+=26;
+
+        pos += 26;
     }
-    for (int i=0;i<SessionStart.size();i++) {
-        SessionID sid=SessionStart[i];
+
+    for (int i = 0; i < SessionStart.size(); i++) {
+        SessionID sid = SessionStart[i];
+
         if (sid) {
-            sess=Sessions[sid];
+            sess = Sessions[sid];
             //if (sess->eventlist.size()==0) {
-             //   delete sess;
-             //   continue;
+            //   delete sess;
+            //   continue;
             //}
-            quint64 first=qint64(sid)*1000L;
-            quint64 last=qint64(SessionEnd[i])*1000L;
+            quint64 first = qint64(sid) * 1000L;
+            quint64 last = qint64(SessionEnd[i]) * 1000L;
 
-            sess->settings[CPAP_PresReliefType]=(PRTypes)PR_SMARTFLEX;
-            int i=set1["SmartFlex"].toInt();
-            sess->settings[CPAP_PresReliefSet]=i;
-            int sfm=set1["SmartFlexMode"].toInt();
-            if (sfm==0) {
-                sess->settings[CPAP_PresReliefMode]=PM_FullTime;
+            sess->settings[CPAP_PresReliefType] = (PRTypes)PR_SMARTFLEX;
+            int i = set1["SmartFlex"].toInt();
+            sess->settings[CPAP_PresReliefSet] = i;
+            int sfm = set1["SmartFlexMode"].toInt();
+
+            if (sfm == 0) {
+                sess->settings[CPAP_PresReliefMode] = PM_FullTime;
             } else {
-                sess->settings[CPAP_PresReliefMode]=PM_RampOnly;
+                sess->settings[CPAP_PresReliefMode] = PM_RampOnly;
             }
 
-            EventDataType max=sess->Max(CPAP_IPAP);
-            EventDataType min=sess->Min(CPAP_EPAP);
-            EventDataType pres=sess->Min(CPAP_Pressure);
-            if (max==min) {
-                sess->settings[CPAP_Mode]=(int)MODE_CPAP;
-                sess->settings[CPAP_Pressure]=min;
+            EventDataType max = sess->Max(CPAP_IPAP);
+            EventDataType min = sess->Min(CPAP_EPAP);
+            EventDataType pres = sess->Min(CPAP_Pressure);
+
+            if (max == min) {
+                sess->settings[CPAP_Mode] = (int)MODE_CPAP;
+                sess->settings[CPAP_Pressure] = min;
             } else {
-                sess->settings[CPAP_Mode]=(int)MODE_APAP;
-                sess->settings[CPAP_PressureMin]=min;
-                sess->settings[CPAP_PressureMax]=max;
+                sess->settings[CPAP_Mode] = (int)MODE_APAP;
+                sess->settings[CPAP_PressureMin] = min;
+                sess->settings[CPAP_PressureMax] = max;
             }
+
             sess->eventlist.erase(sess->eventlist.find(CPAP_IPAP));
             sess->eventlist.erase(sess->eventlist.find(CPAP_EPAP));
             sess->m_min.erase(sess->m_min.find(CPAP_EPAP));
             sess->m_max.erase(sess->m_max.find(CPAP_EPAP));
-            if (pres<min) {
-                sess->settings[CPAP_RampPressure]=pres;
+
+            if (pres < min) {
+                sess->settings[CPAP_RampPressure] = pres;
             }
 
             //quint64 len=last-first;
             //if (len>0) {
-                //if (!sess->first()) {
-                    sess->set_first(first);
-                    sess->set_last(last);
-               // }
-                sess->UpdateSummaries();
-                mach->AddSession(sess,profile);
+            //if (!sess->first()) {
+            sess->set_first(first);
+            sess->set_last(last);
+            // }
+            sess->UpdateSummaries();
+            mach->AddSession(sess, profile);
             /*} else {
                 delete sess;
             }*/
         }
     }
-    mach->properties[STR_PROP_DataVersion]=QString().sprintf("%i",intellipap_data_version);
+
+    mach->properties[STR_PROP_DataVersion] = QString().sprintf("%i", intellipap_data_version);
 
     mach->Save();
 
     delete [] m_buffer;
 
-    if (qprogress) qprogress->setValue(100);
+    if (qprogress) { qprogress->setValue(100); }
 
     f.close();
 
     return 1;
 }
 
-Machine *IntellipapLoader::CreateMachine(QString serial,Profile *profile)
+Machine *IntellipapLoader::CreateMachine(QString serial, Profile *profile)
 {
-    if (!profile)
+    if (!profile) {
         return NULL;
+    }
+
     qDebug() << "Create Machine " << serial;
 
-    QList<Machine *> ml=profile->GetMachines(MT_CPAP);
-    bool found=false;
+    QList<Machine *> ml = profile->GetMachines(MT_CPAP);
+    bool found = false;
     QList<Machine *>::iterator i;
-    Machine *m=NULL;
-    for (i=ml.begin(); i!=ml.end(); i++) {
-        if (((*i)->GetClass()==intellipap_class_name) && ((*i)->properties[STR_PROP_Serial]==serial)) {
-            MachList[serial]=*i; //static_cast<CPAP *>(*i);
-            found=true;
-            m=*i;
+    Machine *m = NULL;
+
+    for (i = ml.begin(); i != ml.end(); i++) {
+        if (((*i)->GetClass() == intellipap_class_name) && ((*i)->properties[STR_PROP_Serial] == serial)) {
+            MachList[serial] = *i; //static_cast<CPAP *>(*i);
+            found = true;
+            m = *i;
             break;
         }
     }
+
     if (!found) {
-        m=new Intellipap(profile,0);
+        m = new Intellipap(profile, 0);
     }
-    m->properties[STR_PROP_Brand]="DeVilbiss";
-    m->properties[STR_PROP_Series]=STR_MACH_Intellipap;
 
-    if (found)
+    m->properties[STR_PROP_Brand] = "DeVilbiss";
+    m->properties[STR_PROP_Series] = STR_MACH_Intellipap;
+
+    if (found) {
         return m;
+    }
 
 
-    MachList[serial]=m;
+    MachList[serial] = m;
     profile->AddMachine(m);
 
-    m->properties[STR_PROP_Serial]=serial;
-    m->properties[STR_PROP_DataVersion]=QString::number(intellipap_data_version);
+    m->properties[STR_PROP_Serial] = serial;
+    m->properties[STR_PROP_DataVersion] = QString::number(intellipap_data_version);
 
-    QString path="{"+STR_GEN_DataFolder+"}/"+m->GetClass()+"_"+serial+"/";
-    m->properties[STR_PROP_Path]=path;
-    m->properties[STR_PROP_BackupPath]=path+"Backup/";
+    QString path = "{" + STR_GEN_DataFolder + "}/" + m->GetClass() + "_" + serial + "/";
+    m->properties[STR_PROP_Path] = path;
+    m->properties[STR_PROP_BackupPath] = path + "Backup/";
 
     return m;
 }
 
 
-bool intellipap_initialized=false;
+bool intellipap_initialized = false;
 void IntellipapLoader::Register()
 {
-    if (intellipap_initialized) return;
+    if (intellipap_initialized) { return; }
+
     qDebug() << "Registering IntellipapLoader";
     RegisterLoader(new IntellipapLoader());
     //InitModelMap();
-    intellipap_initialized=true;
+    intellipap_initialized = true;
 }
diff --git a/sleepyhead/SleepLib/loader_plugins/intellipap_loader.h b/sleepyhead/SleepLib/loader_plugins/intellipap_loader.h
index 828ad2c8..1ad6f1d9 100644
--- a/sleepyhead/SleepLib/loader_plugins/intellipap_loader.h
+++ b/sleepyhead/SleepLib/loader_plugins/intellipap_loader.h
@@ -22,25 +22,25 @@
 //********************************************************************************************
 // Please INCREMENT the following value when making changes to this loaders implementation.
 //
-const int intellipap_data_version=2;
+const int intellipap_data_version = 2;
 //
 //********************************************************************************************
 
 /*! \class Intellipap
     \brief Intellipap customized machine object
     */
-class Intellipap:public CPAP
+class Intellipap: public CPAP
 {
-public:
-    Intellipap(Profile *p,MachineID id=0);
+  public:
+    Intellipap(Profile *p, MachineID id = 0);
     virtual ~Intellipap();
 };
 
 
-const int intellipap_load_buffer_size=1024*1024;
+const int intellipap_load_buffer_size = 1024 * 1024;
 
 
-const QString intellipap_class_name=STR_MACH_Intellipap;
+const QString intellipap_class_name = STR_MACH_Intellipap;
 
 /*! \class IntellipapLoader
     \brief Loader for DeVilbiss Intellipap Auto data
@@ -48,28 +48,28 @@ const QString intellipap_class_name=STR_MACH_Intellipap;
     */
 class IntellipapLoader : public MachineLoader
 {
-public:
+  public:
     IntellipapLoader();
     virtual ~IntellipapLoader();
     //! \brief Scans path for Intellipap data signature, and Loads any new data
-    virtual int Open(QString & path,Profile *profile);
+    virtual int Open(QString &path, Profile *profile);
 
     //! \brief Returns SleepLib database version of this IntelliPap loader
     virtual int Version() { return intellipap_data_version; }
 
     //! \brief Returns the machine class name of this IntelliPap, "Intellipap"
-    virtual const QString & ClassName() { return intellipap_class_name; }
+    virtual const QString &ClassName() { return intellipap_class_name; }
 
     //! \brief Creates a machine object, indexed by serial number
-    Machine *CreateMachine(QString serial,Profile *profile);
+    Machine *CreateMachine(QString serial, Profile *profile);
 
     //! \brief Registers this MachineLoader with the master list, so Intellipap data can load
     static void Register();
-protected:
+  protected:
     QString last;
-    QHash<QString,Machine *> MachList;
+    QHash<QString, Machine *> MachList;
 
-    unsigned char * m_buffer;
+    unsigned char *m_buffer;
 };
 
 
diff --git a/sleepyhead/SleepLib/loader_plugins/mseries_loader.cpp b/sleepyhead/SleepLib/loader_plugins/mseries_loader.cpp
index 97c3b44d..9e141e50 100644
--- a/sleepyhead/SleepLib/loader_plugins/mseries_loader.cpp
+++ b/sleepyhead/SleepLib/loader_plugins/mseries_loader.cpp
@@ -17,12 +17,12 @@ extern QProgressBar *qprogress;
 
 
 
-MSeries::MSeries(Profile *p,MachineID id)
-    :CPAP(p,id)
+MSeries::MSeries(Profile *p, MachineID id)
+    : CPAP(p, id)
 {
-    m_class=mseries_class_name;
-    properties[STR_PROP_Brand]="Respironics";
-    properties[STR_PROP_Model]=STR_MACH_MSeries;
+    m_class = mseries_class_name;
+    properties[STR_PROP_Brand] = "Respironics";
+    properties[STR_PROP_Model] = STR_MACH_MSeries;
 }
 
 MSeries::~MSeries()
@@ -31,8 +31,8 @@ MSeries::~MSeries()
 
 MSeriesLoader::MSeriesLoader()
 {
-    epoch=QDateTime(QDate(2000,1,1),QTime(0,0,0),Qt::UTC).toTime_t();
-    epoch-=QDateTime(QDate(1970,1,1),QTime(0,0,0),Qt::UTC).toTime_t();
+    epoch = QDateTime(QDate(2000, 1, 1), QTime(0, 0, 0), Qt::UTC).toTime_t();
+    epoch -= QDateTime(QDate(1970, 1, 1), QTime(0, 0, 0), Qt::UTC).toTime_t();
 }
 
 MSeriesLoader::~MSeriesLoader()
@@ -113,284 +113,322 @@ blockLayoutOffsets   {
                     */
 
 
-int MSeriesLoader::Open(QString & path,Profile *profile)
+int MSeriesLoader::Open(QString &path, Profile *profile)
 {
     Q_UNUSED(profile);
     // Until a smartcard reader is written, this is not an auto-scanner.. it just opens a block file..
 
     QFile file(path);
-    if (!file.exists()) return 0;
-    if (file.size()!=32768)    // Check filesize matches smartcard?
+
+    if (!file.exists()) { return 0; }
+
+    if (file.size() != 32768) { // Check filesize matches smartcard?
         return 0;
+    }
 
     if (!file.open(QFile::ReadOnly)) {
         qDebug() << "Couldn't open M-Series file:" << path;
         return 0;
     }
-    QByteArray block=file.readAll();
+
+    QByteArray block = file.readAll();
 
 
     // Thanks to Phil Gillam for the pointers on this one..
 
-    const unsigned char * cardinfo=(unsigned char *)block.data();
-    quint16 magic=cardinfo[0] << 8 | cardinfo[1];
-    if (magic!=0x5249) { // "RI" Respironics Magic number
+    const unsigned char *cardinfo = (unsigned char *)block.data();
+    quint16 magic = cardinfo[0] << 8 | cardinfo[1];
+
+    if (magic != 0x5249) { // "RI" Respironics Magic number
         return 0;
     }
+
     //quint8 cardtype=cardinfo[2];
     //quint8 cardver=cardinfo[3];
 
-    quint16 user_offset=(cardinfo[4] << 8) | cardinfo[5];
+    quint16 user_offset = (cardinfo[4] << 8) | cardinfo[5];
     //quint16 rx_offset=(cardinfo[8] << 8) | cardinfo[9];
-    quint16 control_offset=(cardinfo[12] << 8) | cardinfo[13];
+    quint16 control_offset = (cardinfo[12] << 8) | cardinfo[13];
     //quint16 data_offset=(cardinfo[16] << 8) | cardinfo[17];
 
 
-    const char * userinfo=block.data()+user_offset;
-    QString setname=QString(userinfo+0x1);
-    QString firstname=QString(userinfo+0x11);
-    QString lastname=QString(userinfo+0x2a);
-    QString serial=QString(userinfo+0x43);
+    const char *userinfo = block.data() + user_offset;
+    QString setname = QString(userinfo + 0x1);
+    QString firstname = QString(userinfo + 0x11);
+    QString lastname = QString(userinfo + 0x2a);
+    QString serial = QString(userinfo + 0x43);
     serial.truncate(10);
-    QString model=QString(userinfo+0x4d);
-    QString textdata=QString(userinfo+0x57);
-    quint8 userinfochk=*(userinfo+0x77);
-    quint8 tmp=0;
-    for (int i=0;i<0x77;i++) {
-        tmp+=userinfo[i];
+    QString model = QString(userinfo + 0x4d);
+    QString textdata = QString(userinfo + 0x57);
+    quint8 userinfochk = *(userinfo + 0x77);
+    quint8 tmp = 0;
+
+    for (int i = 0; i < 0x77; i++) {
+        tmp += userinfo[i];
     }
-    if (tmp!=userinfochk) {
+
+    if (tmp != userinfochk) {
         qDebug() << "MSeries UserInfo block checksum failure" << path;
     }
 
     //const unsigned char * rxblock=(unsigned char *)block.data()+rx_offset;
 
-    unsigned char * controlblock=(unsigned char *)block.data()+control_offset;
-    quint16 count=controlblock[0] << 8 | controlblock[1]; // number of control blocks
-    if (controlblock[1]!=controlblock[2]) {
+    unsigned char *controlblock = (unsigned char *)block.data() + control_offset;
+    quint16 count = controlblock[0] << 8 | controlblock[1]; // number of control blocks
+
+    if (controlblock[1] != controlblock[2]) {
         qDebug() << "Control block count does not match." << path;
     }
+
     QList<quint16> head, tail;
-    controlblock+=3;
-    quint16 datastarts,dataends,tmp16,h16,t16;
-    if (controlblock[0]) {
-        datastarts=controlblock[1] | (controlblock[2] << 8);
-        dataends=controlblock[3] | (controlblock[4] << 8);
-    }
-    controlblock+=6;
+    controlblock += 3;
+    quint16 datastarts, dataends, tmp16, h16, t16;
 
     if (controlblock[0]) {
-        if ((controlblock[1] | (controlblock[2] << 8))!=datastarts) {
+        datastarts = controlblock[1] | (controlblock[2] << 8);
+        dataends = controlblock[3] | (controlblock[4] << 8);
+    }
+
+    controlblock += 6;
+
+    if (controlblock[0]) {
+        if ((controlblock[1] | (controlblock[2] << 8)) != datastarts) {
             qDebug() << "Non matching card size start identifier" << path;
         }
-        if ((controlblock[3] | (controlblock[4] << 8))!=dataends) {
+
+        if ((controlblock[3] | (controlblock[4] << 8)) != dataends) {
             qDebug() << "Non matching card size end identifier" << path;
         }
     }
-    controlblock+=6;
-    count-=2;
 
-    tmp16=controlblock[0] | controlblock[1] << 8;
+    controlblock += 6;
+    count -= 2;
 
-    controlblock+=2;
-    for (int i=0;i<count/2;i++) {
+    tmp16 = controlblock[0] | controlblock[1] << 8;
+
+    controlblock += 2;
+
+    for (int i = 0; i < count / 2; i++) {
         if (controlblock[0]) {
-            h16=controlblock[1] | (controlblock[2] << 8);
-            t16=controlblock[3] | (controlblock[4] << 8);
+            h16 = controlblock[1] | (controlblock[2] << 8);
+            t16 = controlblock[3] | (controlblock[4] << 8);
             head.push_back(h16);
             tail.push_back(t16);
         }
-        controlblock+=6;
+
+        controlblock += 6;
+
         if (controlblock[0]) {
-            if ((controlblock[1] | (controlblock[2] << 8))!=h16) {
+            if ((controlblock[1] | (controlblock[2] << 8)) != h16) {
                 qDebug() << "Non matching control block head value" << path;
             }
-            if ((controlblock[3] | (controlblock[4] << 8))!=t16) {
+
+            if ((controlblock[3] | (controlblock[4] << 8)) != t16) {
                 qDebug() << "Non matching control block tail value" << path;
             }
         }
-        controlblock+=6;
+
+        controlblock += 6;
     }
 
-    unsigned char *cb=controlblock;
-    quint16 u1,u2,u3,u4,d1;
-    quint32 ts,st,lt;
+    unsigned char *cb = controlblock;
+    quint16 u1, u2, u3, u4, d1;
+    quint32 ts, st, lt;
     QDateTime dt;
     QDate date;
     QTime time;
 
-    for (int chk=0;chk<7;chk++) {
-        ts=cb[0] << 24 | cb[1] << 16 | cb[2] << 8 | cb[3];
+    for (int chk = 0; chk < 7; chk++) {
+        ts = cb[0] << 24 | cb[1] << 16 | cb[2] << 8 | cb[3];
         //ts-=epoch;
-        dt=QDateTime::fromTime_t(ts);
-        date=dt.date();
-        time=dt.time();
+        dt = QDateTime::fromTime_t(ts);
+        date = dt.date();
+        time = dt.time();
         qDebug() << "New Sparse Chunk" << chk << dt << hex << ts;
 
-        cb+=4;
-        quint8 sum=0;
-        for (int i=0;i<0x268;i++) sum+=cb[i];
-        if (cb[0x268]==sum) {
+        cb += 4;
+        quint8 sum = 0;
+
+        for (int i = 0; i < 0x268; i++) { sum += cb[i]; }
+
+        if (cb[0x268] == sum) {
             qDebug() << "Checksum bad for block" << chk << path;
         }
-        cb+=0x26a;
+
+        cb += 0x26a;
     }
 
-    unsigned char * endcard=(unsigned char *)block.data()+dataends;
-    bool done=false;
+    unsigned char *endcard = (unsigned char *)block.data() + dataends;
+    bool done = false;
     qint64 ti;
-    int cnt=0;
+    int cnt = 0;
+
     do {
-        ts=cb[0] << 24 | cb[1] << 16 | cb[2] << 8 | cb[3];
-        lt=st=ts;
-        ti=qint64(ts)*1000L;
-        dt=QDateTime::fromTime_t(ts);
-        date=dt.date();
-        time=dt.time();
+        ts = cb[0] << 24 | cb[1] << 16 | cb[2] << 8 | cb[3];
+        lt = st = ts;
+        ti = qint64(ts) * 1000L;
+        dt = QDateTime::fromTime_t(ts);
+        date = dt.date();
+        time = dt.time();
         qDebug() << "Details New Data Chunk" << cnt << dt << hex << ts;
 
-        cb+=4;
+        cb += 4;
+
         do {
-            if (cb[0]==0xfe) { // not sure what this means
+            if (cb[0] == 0xfe) { // not sure what this means
                 cb++;
             }
-            u1=cb[0] << 8 | cb[1]; // expecting 0xCXXX
 
-            if (u1==0xffff) { // adjust timestamp code
-                cb+=2;
-                u1=cb[0];
+            u1 = cb[0] << 8 | cb[1]; // expecting 0xCXXX
+
+            if (u1 == 0xffff) { // adjust timestamp code
+                cb += 2;
+                u1 = cb[0];
                 cb++;
 
-                if (cb[0]==0xfe) {
-                    u1=cb[0] << 8 | cb[1]; // fe 0a, followed by timestamp
-                    cb+=2;
+                if (cb[0] == 0xfe) {
+                    u1 = cb[0] << 8 | cb[1]; // fe 0a, followed by timestamp
+                    cb += 2;
                     break; // start on the next timestamp
                 }
             } else {
                 if ((cb[0] & 0xc0) == 0xc0) {
-                    cb+=2;
+                    cb += 2;
                     u1 &= 0x0fff; // time delta??
-                    lt=ts;
-                    ts=st+(u1*60);
-                    ti=qint64(ts) * 1000L;
+                    lt = ts;
+                    ts = st + (u1 * 60);
+                    ti = qint64(ts) * 1000L;
 
-                    d1=cb[0] << 8 | cb[1];
-                    u2=cb[2] << 8 | cb[3];
-                    u3=cb[4] << 8 | cb[5];
-                    u4=cb[6] << 8 | cb[7];
-                    if ((d1!=0xf302) || (u2!=0xf097) || (u3!=0xf2ff) || (u4!=0xf281)) {
+                    d1 = cb[0] << 8 | cb[1];
+                    u2 = cb[2] << 8 | cb[3];
+                    u3 = cb[4] << 8 | cb[5];
+                    u4 = cb[6] << 8 | cb[7];
+
+                    if ((d1 != 0xf302) || (u2 != 0xf097) || (u3 != 0xf2ff) || (u4 != 0xf281)) {
                         qDebug() << "Lost details sync reading M-Series file" << path;
                         return false;
                     }
-                    cb+=8;
-                } else cb++;
-                dt=QDateTime::fromTime_t(ts);
+
+                    cb += 8;
+                } else { cb++; }
+
+                dt = QDateTime::fromTime_t(ts);
                 qDebug() << "Details Data Chunk" << cnt++ << dt;
 
                 do {
-                    d1=cb[0] << 8 | cb[1];
-                    cb+=2;
+                    d1 = cb[0] << 8 | cb[1];
+                    cb += 2;
 
-                    if (d1==0x7f0a) { // end of entire block
-                        done=true;
+                    if (d1 == 0x7f0a) { // end of entire block
+                        done = true;
                         break;
                     }
+
                     if ((d1 & 0xb000) == 0xb000) {
                         qDebug() << "Duration" << (d1 & 0x7ff);
                         break; // end of section
                     }
+
                     // process binary data..
                     // 64 c0
-                } while (cb<endcard);
+                } while (cb < endcard);
             }
-        } while (cb<endcard && !done);
+        } while (cb < endcard && !done);
     } while (cb < endcard && !done);
 
-    done=false;
+    done = false;
     //bool first=true;
     quint8 exch;
-    cnt=0;
+    cnt = 0;
+
     do {
-        u1=cb[0] << 8 | cb[1];
-        if (u1!=0xfe0b) {
-            done=true;
+        u1 = cb[0] << 8 | cb[1];
+
+        if (u1 != 0xfe0b) {
+            done = true;
             break;
         }
-        cb+=2;
-        st=ts=cb[0] << 24 | cb[1] << 16 | cb[2] << 8 | cb[3];
-        dt=QDateTime::fromTime_t(ts);
-        date=dt.date();
-        time=dt.time();
+
+        cb += 2;
+        st = ts = cb[0] << 24 | cb[1] << 16 | cb[2] << 8 | cb[3];
+        dt = QDateTime::fromTime_t(ts);
+        date = dt.date();
+        time = dt.time();
         //qDebug() << "Summary Data Chunk" << cnt << dt << hex << ts;
-        cb+=4;
+        cb += 4;
+
         while (cb < endcard) {
-            if (((cb[0]&0xc0)!=0xc0) || ((cb[0]&0xf0)==0xf0)) {
+            if (((cb[0] & 0xc0) != 0xc0) || ((cb[0] & 0xf0) == 0xf0)) {
                 // what is this for??
-                exch=cb[0];
+                exch = cb[0];
                 cb++;
             }
 
-            u1=(cb[0] << 8 | cb[1]) & 0x7ff; // time delta
+            u1 = (cb[0] << 8 | cb[1]) & 0x7ff; // time delta
 
-            u2=(cb[2] << 8 | cb[3]) & 0x7ff;  // 0xBX XX??
-            ts=st+u1*60;
-            dt=QDateTime::fromTime_t(ts);
+            u2 = (cb[2] << 8 | cb[3]) & 0x7ff; // 0xBX XX??
+            ts = st + u1 * 60;
+            dt = QDateTime::fromTime_t(ts);
             //qDebug() << "Summary Sub Chunk" << dt << u1 << u2 << hex << ts;
-            cb+=4;
-            if (cb[0]==0xff) break;
+            cb += 4;
+
+            if (cb[0] == 0xff) { break; }
         }
+
         cb++; // ff;
 
-//        05905: "22 48 00 00 04 01 01 5C 9E 30 00 F0 00 01 73 00 00 00 F2  Sat Jul 9 2011 10:44:25"
-//        05905: "20 58 00 00 00 00 00 32 69 88 00 70 00 01 73 00 00 00 AF  Sun Jul 10 2011 05:09:21"
-//        05906: "22 00 00 00 0B 00 01 4E 79 F8 02 70 00 01 73 00 00 00 56  Sun Jul 10 2011 10:27:05"
-//        05907: "21 4C 00 00 11 00 01 5C 95 F8 01 F0 00 01 73 00 00 00 54  Mon Jul 11 2011 10:59:42"
-//        05908: "20 A8 00 00 02 00 01 4E 7D 88 00 F0 00 01 73 00 00 00 90  Tue Jul 12 2011 03:44:38"
-//        05909: "21 94 00 00 34 01 01 6A 96 D8 01 70 00 01 73 00 00 00 FC  Tue Jul 12 2011 10:30:49"
-//        05910: "21 84 00 00 19 01 01 6A A2 30 00 F0 00 01 73 00 00 00 3E  Wed Jul 13 2011 10:30:14"
-//        05911: "22 38 00 00 3F 01 01 86 B2 A0 00 F1 00 01 73 00 00 00 F4  Thu Jul 14 2011 10:01:50"
-//        05912: "21 68 00 00 36 01 01 5C 91 F8 02 70 00 01 73 00 00 00 BF  Fri Jul 15 2011 10:46:33"
-//        05913: "22 6C 0E 00 A1 01 01 78 AB 10 00 F0 00 01 73 00 00 00 9A  Sat Jul 16 2011 10:44:56"
+        //        05905: "22 48 00 00 04 01 01 5C 9E 30 00 F0 00 01 73 00 00 00 F2  Sat Jul 9 2011 10:44:25"
+        //        05905: "20 58 00 00 00 00 00 32 69 88 00 70 00 01 73 00 00 00 AF  Sun Jul 10 2011 05:09:21"
+        //        05906: "22 00 00 00 0B 00 01 4E 79 F8 02 70 00 01 73 00 00 00 56  Sun Jul 10 2011 10:27:05"
+        //        05907: "21 4C 00 00 11 00 01 5C 95 F8 01 F0 00 01 73 00 00 00 54  Mon Jul 11 2011 10:59:42"
+        //        05908: "20 A8 00 00 02 00 01 4E 7D 88 00 F0 00 01 73 00 00 00 90  Tue Jul 12 2011 03:44:38"
+        //        05909: "21 94 00 00 34 01 01 6A 96 D8 01 70 00 01 73 00 00 00 FC  Tue Jul 12 2011 10:30:49"
+        //        05910: "21 84 00 00 19 01 01 6A A2 30 00 F0 00 01 73 00 00 00 3E  Wed Jul 13 2011 10:30:14"
+        //        05911: "22 38 00 00 3F 01 01 86 B2 A0 00 F1 00 01 73 00 00 00 F4  Thu Jul 14 2011 10:01:50"
+        //        05912: "21 68 00 00 36 01 01 5C 91 F8 02 70 00 01 73 00 00 00 BF  Fri Jul 15 2011 10:46:33"
+        //        05913: "22 6C 0E 00 A1 01 01 78 AB 10 00 F0 00 01 73 00 00 00 9A  Sat Jul 16 2011 10:44:56"
 
 
         // 0x04 Vibratory Snore
         cnt++;
         QString a;
-        for (int i=0;i<0x13;i++) {
-            a+=QString().sprintf("%02X ",cb[i]);
+
+        for (int i = 0; i < 0x13; i++) {
+            a += QString().sprintf("%02X ", cb[i]);
         }
-        a+=" "+date.toString()+" "+time.toString();
+
+        a += " " + date.toString() + " " + time.toString();
         qDebug() << a;
-        cb+=0x13;
+        cb += 0x13;
     } while (cb < endcard && !done);
 
     //graph data
     //starts with timestamp.. or time delta if high bit is set.
 
-//    validFlagOne = 3,
-//    headPtrOne = 4,
-//    tailPtrOne = 6,
-//    cdbChecksumOne = 8,
-//    validFlagTwo = 9
-//    headPtrTwo = 10,
-//    tailPtrTwo = 12,
-//    cdbChecksumTwo = 14,
+    //    validFlagOne = 3,
+    //    headPtrOne = 4,
+    //    tailPtrOne = 6,
+    //    cdbChecksumOne = 8,
+    //    validFlagTwo = 9
+    //    headPtrTwo = 10,
+    //    tailPtrTwo = 12,
+    //    cdbChecksumTwo = 14,
 
-//    const char * datablock=block.data()+data_offset;
-//    quint8 basicCompliance=datablock[1];
-//    quint8 fosq=datablock[2];
-//    quint8 smartAutoCPAPProfile=datablock[3];
-//    quint8 smartAutoCPAPTrend=datablock[4];
-//    quint8 ventProfile=datablock[6];
-//    quint8 ventCompliance1=datablock[7];
-//    quint8 sleepProfile1=datablock[8];
-//    quint8 sleepTrend1=datablock[9];
-//    quint8 sleepProfile2=datablock[10];
-//    quint8 sleepTrend2=datablock[11];
-//    quint8 ventProfile2=datablock[12];
-//    quint8 ventCompliance2=datablock[13];
-//    quint8 sleepProfile3=datablock[14];
-//    quint8 sleepTrend3=datablock[15];
+    //    const char * datablock=block.data()+data_offset;
+    //    quint8 basicCompliance=datablock[1];
+    //    quint8 fosq=datablock[2];
+    //    quint8 smartAutoCPAPProfile=datablock[3];
+    //    quint8 smartAutoCPAPTrend=datablock[4];
+    //    quint8 ventProfile=datablock[6];
+    //    quint8 ventCompliance1=datablock[7];
+    //    quint8 sleepProfile1=datablock[8];
+    //    quint8 sleepTrend1=datablock[9];
+    //    quint8 sleepProfile2=datablock[10];
+    //    quint8 sleepTrend2=datablock[11];
+    //    quint8 ventProfile2=datablock[12];
+    //    quint8 ventCompliance2=datablock[13];
+    //    quint8 sleepProfile3=datablock[14];
+    //    quint8 sleepTrend3=datablock[15];
 
 
     // 0xa6: 01 00 b2 7f ff 31
@@ -415,24 +453,24 @@ int MSeriesLoader::Open(QString & path,Profile *profile)
 
     // idx 0x159 =
 
-//    basicCompliance = 1,
-//    fosq = 2,
-//    sleepProfile = 8,
-//    sleepProfile2 = 10,
-//    sleepProfile3 = 14,
-//    sleepTrend = 9,
-//    sleepTrend2 = 11,
-//    sleepTrend3 = 15,
-//    smartAutoCPAPProfile = 3,
-//    smartAutoCPAPTrend = 4,
-//    ventCompliance2 = 13,
-//    ventilatorCompliance = 7,
-//    ventilatorProfile = 6,
-//    ventProfile2 = 12
+    //    basicCompliance = 1,
+    //    fosq = 2,
+    //    sleepProfile = 8,
+    //    sleepProfile2 = 10,
+    //    sleepProfile3 = 14,
+    //    sleepTrend = 9,
+    //    sleepTrend2 = 11,
+    //    sleepTrend3 = 15,
+    //    smartAutoCPAPProfile = 3,
+    //    smartAutoCPAPTrend = 4,
+    //    ventCompliance2 = 13,
+    //    ventilatorCompliance = 7,
+    //    ventilatorProfile = 6,
+    //    ventProfile2 = 12
 
-//    Invalid = 0xff,
-//    startChar = 0xfe,
-//    stopChar = 0x7f
+    //    Invalid = 0xff,
+    //    startChar = 0xfe,
+    //    stopChar = 0x7f
 
 
     //Machine *mach=CreateMachine(serial,profile);
@@ -445,45 +483,50 @@ int MSeriesLoader::Open(QString & path,Profile *profile)
     return 1;
 }
 
-Machine *MSeriesLoader::CreateMachine(QString serial,Profile *profile)
+Machine *MSeriesLoader::CreateMachine(QString serial, Profile *profile)
 {
-    if (!profile)
+    if (!profile) {
         return NULL;
+    }
+
     qDebug() << "Create Machine " << serial;
 
-    QList<Machine *> ml=profile->GetMachines(MT_CPAP);
-    bool found=false;
+    QList<Machine *> ml = profile->GetMachines(MT_CPAP);
+    bool found = false;
     QList<Machine *>::iterator i;
-    for (i=ml.begin(); i!=ml.end(); i++) {
-        if (((*i)->GetClass()==mseries_class_name) && ((*i)->properties[STR_PROP_Serial]==serial)) {
-            MachList[serial]=*i;
-            found=true;
+
+    for (i = ml.begin(); i != ml.end(); i++) {
+        if (((*i)->GetClass() == mseries_class_name) && ((*i)->properties[STR_PROP_Serial] == serial)) {
+            MachList[serial] = *i;
+            found = true;
             break;
         }
     }
-    if (found) return *i;
 
-    Machine *m=new MSeries(profile,0);
+    if (found) { return *i; }
 
-    MachList[serial]=m;
+    Machine *m = new MSeries(profile, 0);
+
+    MachList[serial] = m;
     profile->AddMachine(m);
 
-    m->properties[STR_PROP_Serial]=serial;
-    m->properties[STR_PROP_DataVersion]=QString::number(mseries_data_version);
+    m->properties[STR_PROP_Serial] = serial;
+    m->properties[STR_PROP_DataVersion] = QString::number(mseries_data_version);
 
-    QString path="{"+STR_GEN_DataFolder+"}/"+m->GetClass()+"_"+serial+"/";
-    m->properties[STR_PROP_Path]=path;
-    m->properties[STR_PROP_BackupPath]=path+"Backup/";
+    QString path = "{" + STR_GEN_DataFolder + "}/" + m->GetClass() + "_" + serial + "/";
+    m->properties[STR_PROP_Path] = path;
+    m->properties[STR_PROP_BackupPath] = path + "Backup/";
 
     return m;
 }
 
-bool mseries_initialized=false;
+bool mseries_initialized = false;
 void MSeriesLoader::Register()
 {
-    if (mseries_initialized) return;
+    if (mseries_initialized) { return; }
+
     qDebug() << "Registering RemStar M-Series Loader";
     RegisterLoader(new MSeriesLoader());
     //InitModelMap();
-    mseries_initialized=true;
+    mseries_initialized = true;
 }
diff --git a/sleepyhead/SleepLib/loader_plugins/mseries_loader.h b/sleepyhead/SleepLib/loader_plugins/mseries_loader.h
index cafbbb95..827c9ec9 100644
--- a/sleepyhead/SleepLib/loader_plugins/mseries_loader.h
+++ b/sleepyhead/SleepLib/loader_plugins/mseries_loader.h
@@ -21,48 +21,48 @@
 //********************************************************************************************
 // Please INCREMENT the following value when making changes to this loaders implementation.
 //
-const int mseries_data_version=2;
+const int mseries_data_version = 2;
 //
 //********************************************************************************************
 
 /*! \class MSeries
     \brief RemStar M-Series customized machine object
     */
-class MSeries:public CPAP
+class MSeries: public CPAP
 {
-public:
-    MSeries(Profile *p,MachineID id=0);
+  public:
+    MSeries(Profile *p, MachineID id = 0);
     virtual ~MSeries();
 };
 
 
-const int mseries_load_buffer_size=1024*1024;
+const int mseries_load_buffer_size = 1024 * 1024;
 
 
-const QString mseries_class_name=STR_MACH_MSeries;
+const QString mseries_class_name = STR_MACH_MSeries;
 
 class MSeriesLoader : public MachineLoader
 {
-public:
+  public:
     MSeriesLoader();
     virtual ~MSeriesLoader();
 
     //! \brief Opens M-Series block device
-    virtual int Open(QString & file,Profile *profile);
+    virtual int Open(QString &file, Profile *profile);
 
     //! \brief Returns the database version of this loader
     virtual int Version() { return mseries_data_version; }
 
     //! \brief Return the ClassName, in this case "MSeries"
-    virtual const QString & ClassName() { return mseries_class_name; }
+    virtual const QString &ClassName() { return mseries_class_name; }
 
     //! \brief Create a new PRS1 machine record, indexed by Serial number.
-    Machine *CreateMachine(QString serial,Profile *profile);
+    Machine *CreateMachine(QString serial, Profile *profile);
 
     //! \brief Register this Module to the list of Loaders, so it knows to search for PRS1 data.
     static void Register();
-protected:
-    QHash<QString,Machine *> MachList;
+  protected:
+    QHash<QString, Machine *> MachList;
     quint32 epoch;
 };
 
diff --git a/sleepyhead/SleepLib/loader_plugins/prs1_loader.cpp b/sleepyhead/SleepLib/loader_plugins/prs1_loader.cpp
index 97e87c3e..2f521402 100644
--- a/sleepyhead/SleepLib/loader_plugins/prs1_loader.cpp
+++ b/sleepyhead/SleepLib/loader_plugins/prs1_loader.cpp
@@ -24,7 +24,7 @@
 #include "SleepLib/calcs.h"
 
 
-const int PRS1_MAGIC_NUMBER=2;
+const int PRS1_MAGIC_NUMBER = 2;
 //const int PRS1_SUMMARY_FILE=1;
 //const int PRS1_EVENT_FILE=2;
 //const int PRS1_WAVEFORM_FILE=5;
@@ -40,7 +40,7 @@ const int PRS1_MAGIC_NUMBER=2;
 
 extern QProgressBar *qprogress;
 
-QHash<int,QString> ModelMap;
+QHash<int, QString> ModelMap;
 
 #define PRS1_CRC_CHECK
 
@@ -84,7 +84,7 @@ static const crc_t crc_table[256] = {
 
 crc_t CRC16(const unsigned char *data, size_t data_len)
 {
-    crc_t crc=0;
+    crc_t crc = 0;
     unsigned int tbl_idx;
 
     while (data_len--) {
@@ -93,13 +93,14 @@ crc_t CRC16(const unsigned char *data, size_t data_len)
 
         data++;
     }
+
     return crc & 0xffff;
 }
 #endif
 
-PRS1::PRS1(Profile *p,MachineID id):CPAP(p,id)
+PRS1::PRS1(Profile *p, MachineID id): CPAP(p, id)
 {
-    m_class=prs1_class_name;
+    m_class = prs1_class_name;
 }
 PRS1::~PRS1()
 {
@@ -112,203 +113,232 @@ PRS1::~PRS1()
 struct WaveHeaderList {
     quint16 interleave;
     quint8  sample_format;
-    WaveHeaderList(quint16 i,quint8 f){ interleave=i; sample_format=f; }
+    WaveHeaderList(quint16 i, quint8 f) { interleave = i; sample_format = f; }
 };
 
 
 PRS1Loader::PRS1Loader()
 {
     //genCRCTable();
-    m_buffer=NULL;
+    m_buffer = NULL;
 }
 
 PRS1Loader::~PRS1Loader()
 {
 }
-Machine *PRS1Loader::CreateMachine(QString serial,Profile *profile)
+Machine *PRS1Loader::CreateMachine(QString serial, Profile *profile)
 {
-    if (!profile)
+    if (!profile) {
         return NULL;
+    }
+
     qDebug() << "Create Machine " << serial;
 
-    QList<Machine *> ml=profile->GetMachines(MT_CPAP);
-    bool found=false;
+    QList<Machine *> ml = profile->GetMachines(MT_CPAP);
+    bool found = false;
     QList<Machine *>::iterator i;
-    Machine *m=NULL;
+    Machine *m = NULL;
 
-    for (i=ml.begin(); i!=ml.end(); i++) {
-        if (((*i)->GetClass()==STR_MACH_PRS1) && ((*i)->properties[STR_PROP_Serial]==serial)) {
-            PRS1List[serial]=*i; //static_cast<CPAP *>(*i);
-            found=true;
-            m=*i;
+    for (i = ml.begin(); i != ml.end(); i++) {
+        if (((*i)->GetClass() == STR_MACH_PRS1) && ((*i)->properties[STR_PROP_Serial] == serial)) {
+            PRS1List[serial] = *i; //static_cast<CPAP *>(*i);
+            found = true;
+            m = *i;
             break;
         }
     }
+
     if (!found) {
-        m=new PRS1(profile,0);
+        m = new PRS1(profile, 0);
     }
-    m->properties[STR_PROP_Brand]="Philips Respironics";
-    m->properties[STR_PROP_Series]="System One";
+
+    m->properties[STR_PROP_Brand] = "Philips Respironics";
+    m->properties[STR_PROP_Series] = "System One";
 
     if (found) {
         return m;
     }
 
-    PRS1List[serial]=m;
+    PRS1List[serial] = m;
     profile->AddMachine(m);
 
-    m->properties[STR_PROP_Serial]=serial;
-    m->properties[STR_PROP_DataVersion]=QString::number(prs1_data_version);
+    m->properties[STR_PROP_Serial] = serial;
+    m->properties[STR_PROP_DataVersion] = QString::number(prs1_data_version);
 
-    QString path="{"+STR_GEN_DataFolder+"}/"+m->GetClass()+"_"+serial+"/";
-    m->properties[STR_PROP_Path]=path;
-    m->properties[STR_PROP_BackupPath]=path+"Backup/";
+    QString path = "{" + STR_GEN_DataFolder + "}/" + m->GetClass() + "_" + serial + "/";
+    m->properties[STR_PROP_Path] = path;
+    m->properties[STR_PROP_BackupPath] = path + "Backup/";
 
     return m;
 }
 bool isdigit(QChar c)
 {
-    if ((c>='0') && (c<='9')) return true;
+    if ((c >= '0') && (c <= '9')) { return true; }
+
     return false;
 }
 
-const QString PR_STR_PSeries="P-Series";
+const QString PR_STR_PSeries = "P-Series";
 
-int PRS1Loader::Open(QString & path,Profile *profile)
+int PRS1Loader::Open(QString &path, Profile *profile)
 {
     QString newpath;
-    path=path.replace("\\","/");
+    path = path.replace("\\", "/");
 
-    if (path.endsWith("/"+PR_STR_PSeries)) {
-        newpath=path;
+    if (path.endsWith("/" + PR_STR_PSeries)) {
+        newpath = path;
     } else {
-        newpath=path+"/"+PR_STR_PSeries;
+        newpath = path + "/" + PR_STR_PSeries;
     }
+
     qDebug() << "PRS1Loader::Open path=" << newpath;
 
     QDir dir(newpath);
 
-    if ((!dir.exists() || !dir.isReadable()))
+    if ((!dir.exists() || !dir.isReadable())) {
         return 0;
+    }
 
     dir.setFilter(QDir::NoDotAndDotDot | QDir::Dirs | QDir::Files | QDir::Hidden | QDir::NoSymLinks);
     dir.setSorting(QDir::Name);
-    QFileInfoList flist=dir.entryInfoList();
+    QFileInfoList flist = dir.entryInfoList();
 
     QList<QString> SerialNumbers;
     QList<QString>::iterator sn;
 
-    for (int i=0;i<flist.size();i++) {
-        QFileInfo fi=flist.at(i);
-        QString filename=fi.fileName();
+    for (int i = 0; i < flist.size(); i++) {
+        QFileInfo fi = flist.at(i);
+        QString filename = fi.fileName();
 
-        if ((filename[0]=='P') && (isdigit(filename[1])) && (isdigit(filename[2]))) {
+        if ((filename[0] == 'P') && (isdigit(filename[1])) && (isdigit(filename[2]))) {
             SerialNumbers.push_back(filename);
-        } else if (filename.toLower()=="last.txt") { // last.txt points to the current serial number
-            QString file=fi.canonicalFilePath();
+        } else if (filename.toLower() == "last.txt") { // last.txt points to the current serial number
+            QString file = fi.canonicalFilePath();
             QFile f(file);
+
             if (!fi.isReadable()) {
                 qDebug() << "PRS1Loader: last.txt exists but I couldn't read it!";
                 continue;
             }
+
             if (!f.open(QIODevice::ReadOnly)) {
                 qDebug() << "PRS1Loader: last.txt exists but I couldn't open it!";
                 continue;
             }
-            last=f.readLine(64);
-            last=last.trimmed();
+
+            last = f.readLine(64);
+            last = last.trimmed();
             f.close();
         }
     }
 
-    if (SerialNumbers.empty()) return 0;
+    if (SerialNumbers.empty()) { return 0; }
 
-    m_buffer=new unsigned char [max_load_buffer_size]; //allocate once and reuse.
+    m_buffer = new unsigned char [max_load_buffer_size]; //allocate once and reuse.
     Machine *m;
-    for (sn=SerialNumbers.begin(); sn!=SerialNumbers.end(); sn++) {
-        QString s=*sn;
-        m=CreateMachine(s,profile);
+
+    for (sn = SerialNumbers.begin(); sn != SerialNumbers.end(); sn++) {
+        QString s = *sn;
+        m = CreateMachine(s, profile);
+
         try {
-            if (m)
-                OpenMachine(m,newpath+"/"+(*sn),profile);
-        } catch(OneTypePerDay e) {
+            if (m) {
+                OpenMachine(m, newpath + "/" + (*sn), profile);
+            }
+        } catch (OneTypePerDay e) {
             profile->DelMachine(m);
             PRS1List.erase(PRS1List.find(s));
-            QMessageBox::warning(NULL,QObject::tr("Import Error"),QObject::tr("This Machine Record cannot be imported in this profile.\nThe Day records overlap with already existing content."),QMessageBox::Ok);
+            QMessageBox::warning(NULL, QObject::tr("Import Error"),
+                                 QObject::tr("This Machine Record cannot be imported in this profile.\nThe Day records overlap with already existing content."),
+                                 QMessageBox::Ok);
             delete m;
         }
     }
+
     delete [] m_buffer;
     return PRS1List.size();
 }
 
-bool PRS1Loader::ParseProperties(Machine *m,QString filename)
+bool PRS1Loader::ParseProperties(Machine *m, QString filename)
 {
     QFile f(filename);
-    if (!f.open(QIODevice::ReadOnly))
+
+    if (!f.open(QIODevice::ReadOnly)) {
         return false;
+    }
 
     QString line;
-    QHash<QString,QString> prop;
+    QHash<QString, QString> prop;
 
-    QString s=f.readLine();
-    QChar sep='=';
-    QString key,value;
+    QString s = f.readLine();
+    QChar sep = '=';
+    QString key, value;
 
     while (!f.atEnd()) {
-        key=s.section(sep,0,0); //BeforeFirst(sep);
-        if (key==s) continue;
-        value=s.section(sep,1).trimmed(); //AfterFirst(sep).Strip();
-        if (value==s) continue;
-        prop[key]=value;
-        s=f.readLine();
+        key = s.section(sep, 0, 0); //BeforeFirst(sep);
+
+        if (key == s) { continue; }
+
+        value = s.section(sep, 1).trimmed(); //AfterFirst(sep).Strip();
+
+        if (value == s) { continue; }
+
+        prop[key] = value;
+        s = f.readLine();
     }
+
     bool ok;
-    QString pt=prop["ProductType"];
-    int i=pt.toInt(&ok,16);
+    QString pt = prop["ProductType"];
+    int i = pt.toInt(&ok, 16);
+
     if (ok) {
-        if (ModelMap.find(i)!=ModelMap.end()) {
-            m->properties[STR_PROP_Model]=ModelMap[i];
+        if (ModelMap.find(i) != ModelMap.end()) {
+            m->properties[STR_PROP_Model] = ModelMap[i];
         }
     }
-    if (prop["SerialNumber"]!=m->properties[STR_PROP_Serial]) {
-        qDebug() << "Serial Number in PRS1 properties.txt doesn't match directory structure";
-    } else prop.erase(prop.find("SerialNumber")); // already got it stored.
 
-    for (QHash<QString,QString>::iterator i=prop.begin(); i!=prop.end(); i++) {
-        m->properties[i.key()]=i.value();
+    if (prop["SerialNumber"] != m->properties[STR_PROP_Serial]) {
+        qDebug() << "Serial Number in PRS1 properties.txt doesn't match directory structure";
+    } else { prop.erase(prop.find("SerialNumber")); } // already got it stored.
+
+    for (QHash<QString, QString>::iterator i = prop.begin(); i != prop.end(); i++) {
+        m->properties[i.key()] = i.value();
     }
 
     f.close();
     return true;
 }
 
-int PRS1Loader::OpenMachine(Machine *m,QString path,Profile *profile)
+int PRS1Loader::OpenMachine(Machine *m, QString path, Profile *profile)
 {
 
     qDebug() << "Opening PRS1 " << path;
     QDir dir(path);
-    if (!dir.exists() || (!dir.isReadable()))
-         return false;
+
+    if (!dir.exists() || (!dir.isReadable())) {
+        return false;
+    }
 
 
     dir.setFilter(QDir::NoDotAndDotDot | QDir::Dirs | QDir::Files | QDir::Hidden | QDir::NoSymLinks);
     dir.setSorting(QDir::Name);
-    QFileInfoList flist=dir.entryInfoList();
+    QFileInfoList flist = dir.entryInfoList();
 
     QString filename;
-    if (qprogress) qprogress->setValue(0);
+
+    if (qprogress) { qprogress->setValue(0); }
 
     QList<QString> paths;
-    for (int i=0;i<flist.size();i++) {
-        QFileInfo fi=flist.at(i);
-        filename=fi.fileName();
 
-         if ((filename[0].toLower()=='p') && (isdigit(filename[1]))) {
+    for (int i = 0; i < flist.size(); i++) {
+        QFileInfo fi = flist.at(i);
+        filename = fi.fileName();
+
+        if ((filename[0].toLower() == 'p') && (isdigit(filename[1]))) {
             paths.push_back(fi.canonicalFilePath());
-        } else if (filename.toLower()=="properties.txt") {
-            ParseProperties(m,fi.canonicalFilePath());
-        } else if (filename.toLower()=="e") {
+        } else if (filename.toLower() == "properties.txt") {
+            ParseProperties(m, fi.canonicalFilePath());
+        } else if (filename.toLower() == "e") {
             // Error files..
             // Reminder: I have been given some info about these. should check it over.
         }
@@ -317,94 +347,111 @@ int PRS1Loader::OpenMachine(Machine *m,QString path,Profile *profile)
     SessionID sid;
     long ext;
     QHash<SessionID, QStringList> sessfiles;
-    int size=paths.size();
-    int cnt=0;
+    int size = paths.size();
+    int cnt = 0;
     bool ok;
 
     new_sessions.clear();
-    for (QList<QString>::iterator p=paths.begin(); p!=paths.end(); p++) {
+
+    for (QList<QString>::iterator p = paths.begin(); p != paths.end(); p++) {
         dir.setPath(*p);
-        if (!dir.exists() || !dir.isReadable()) continue;
-        flist=dir.entryInfoList();
 
-        for (int i=0;i<flist.size();i++) {
-            QFileInfo fi=flist.at(i);
-            QString ext_s=fi.fileName().section(".",-1);
-            QString session_s=fi.fileName().section(".",0,-2);
+        if (!dir.exists() || !dir.isReadable()) { continue; }
 
-            ext=ext_s.toLong(&ok);
-            if (!ok)
+        flist = dir.entryInfoList();
+
+        for (int i = 0; i < flist.size(); i++) {
+            QFileInfo fi = flist.at(i);
+            QString ext_s = fi.fileName().section(".", -1);
+            QString session_s = fi.fileName().section(".", 0, -2);
+
+            ext = ext_s.toLong(&ok);
+
+            if (!ok) {
                 continue;
+            }
 
-            sid=session_s.toLong(&ok);
-            if (!ok)
+            sid = session_s.toLong(&ok);
+
+            if (!ok) {
                 continue;
+            }
 
-            if (m->SessionExists(sid))
-                continue; // could skip this and error check data by reloading summary.
+            if (m->SessionExists(sid)) {
+                continue;    // could skip this and error check data by reloading summary.
+            }
 
-            if ((ext==1) || (ext==0)) {
-                OpenFile(m,fi.canonicalFilePath()); // Open just the summary files first round
+            if ((ext == 1) || (ext == 0)) {
+                OpenFile(m, fi.canonicalFilePath()); // Open just the summary files first round
             } else {
                 sessfiles[sid].push_back(fi.canonicalFilePath()); // and keep the rest of the names
             }
         }
     }
-    cnt=0;
-    size=new_sessions.size();
-    for (QHash<SessionID, Session *>::iterator it=new_sessions.begin();it!=new_sessions.end();it++) {
-        sid=it.key();
+
+    cnt = 0;
+    size = new_sessions.size();
+
+    for (QHash<SessionID, Session *>::iterator it = new_sessions.begin(); it != new_sessions.end();
+            it++) {
+        sid = it.key();
 
         if (sessfiles.contains(sid)) {
-            for (int j=0;j<sessfiles[sid].size();j++) {
-                QString name=sessfiles[sid][j];
+            for (int j = 0; j < sessfiles[sid].size(); j++) {
+                QString name = sessfiles[sid][j];
+
                 if (name.endsWith(".002")) {
-                    OpenFile(m,name);
+                    OpenFile(m, name);
                 } else if (name.endsWith(".005")) {
-                    OpenWaveforms(sid,name);
+                    OpenWaveforms(sid, name);
                 }
             }
         }
+
         // sessions are fully loaded here..
 
-        if ((++cnt % 10)==0) {
-            if (qprogress) qprogress->setValue(0.0+(float(cnt)/float(size)*100.0));
+        if ((++cnt % 10) == 0) {
+            if (qprogress) { qprogress->setValue(0.0 + (float(cnt) / float(size) * 100.0)); }
+
             QApplication::processEvents();
         }
     }
+
     // strictly can do this in the above loop, but this is cautionary
-    cnt=0;
+    cnt = 0;
+
     //QVector<SessionID> KillList;
-    for (QHash<SessionID, Session *>::iterator it=new_sessions.begin();it!=new_sessions.end();it++) {
-        Session *sess=it.value();
+    for (QHash<SessionID, Session *>::iterator it = new_sessions.begin(); it != new_sessions.end();
+            it++) {
+        Session *sess = it.value();
 
         if ((sess->length()) == 0) {
-        //const double ignore_thresh=300.0/3600.0;// Ignore useless sessions under 5 minute
-        //if (sess->hours()<=ignore_thresh) {
+            //const double ignore_thresh=300.0/3600.0;// Ignore useless sessions under 5 minute
+            //if (sess->hours()<=ignore_thresh) {
             qDebug() << "Ignoring empty session" << sess->session();
-            SessionID id=sess->session();
+            SessionID id = sess->session();
             delete sess;
-            new_sessions[id]=NULL;
+            new_sessions[id] = NULL;
             //KillList.push_back(id);
             continue;
         }
 
-        if (sess->count(CPAP_IPAP)>0) {
+        if (sess->count(CPAP_IPAP) > 0) {
             //sess->summaryCPAP_Mode]!=MODE_ASV)
-            if (sess->settings[CPAP_Mode].toInt()!=(int)MODE_ASV) {
-                sess->settings[CPAP_Mode]=MODE_BIPAP;
+            if (sess->settings[CPAP_Mode].toInt() != (int)MODE_ASV) {
+                sess->settings[CPAP_Mode] = MODE_BIPAP;
             }
 
-            if (sess->settings[CPAP_PresReliefType].toInt()!=PR_NONE) {
-                sess->settings[CPAP_PresReliefType]=PR_BIFLEX;
+            if (sess->settings[CPAP_PresReliefType].toInt() != PR_NONE) {
+                sess->settings[CPAP_PresReliefType] = PR_BIFLEX;
             }
 
-            EventDataType min=sess->settings[CPAP_PressureMin].toDouble();
-            EventDataType max=sess->settings[CPAP_PressureMax].toDouble();
-            sess->settings[CPAP_EPAP]=min;
-            sess->settings[CPAP_IPAP]=max;
+            EventDataType min = sess->settings[CPAP_PressureMin].toDouble();
+            EventDataType max = sess->settings[CPAP_PressureMax].toDouble();
+            sess->settings[CPAP_EPAP] = min;
+            sess->settings[CPAP_IPAP] = max;
 
-            sess->settings[CPAP_PS]=max-min;
+            sess->settings[CPAP_PS] = max - min;
             sess->settings.erase(sess->settings.find(CPAP_PressureMin));
             sess->settings.erase(sess->settings.find(CPAP_PressureMax));
 
@@ -418,34 +465,39 @@ int PRS1Loader::OpenMachine(Machine *m,QString path,Profile *profile)
         } else {
 
             if (!sess->settings.contains(CPAP_Pressure) && !sess->settings.contains(CPAP_PressureMin)) {
-                sess->settings[CPAP_BrokenSummary]=true;
+                sess->settings[CPAP_BrokenSummary] = true;
+
                 //sess->set_last(sess->first());
-                if (sess->Min(CPAP_Pressure)==sess->Max(CPAP_Pressure)) {
-                    sess->settings[CPAP_Mode]=MODE_CPAP; // no ramp
+                if (sess->Min(CPAP_Pressure) == sess->Max(CPAP_Pressure)) {
+                    sess->settings[CPAP_Mode] = MODE_CPAP; // no ramp
                 } else {
-                    sess->settings[CPAP_Mode]=MODE_UNKNOWN;
+                    sess->settings[CPAP_Mode] = MODE_UNKNOWN;
                 }
+
                 //sess->Set("FlexMode",PR_UNKNOWN);
             }
 
         }
-        if (sess->settings[CPAP_Mode].toInt()==(int)MODE_CPAP) {
+
+        if (sess->settings[CPAP_Mode].toInt() == (int)MODE_CPAP) {
             //sess->settings[CPAP_PressureMax]=sess->settings[CPAP_PressureMin];
         }
 
         sess->SetChanged(true);
-        m->AddSession(sess,profile);
-        if ((++cnt % 10) ==0) {
+        m->AddSession(sess, profile);
+
+        if ((++cnt % 10) == 0) {
             //if (qprogress) qprogress->setValue(33.0+(float(cnt)/float(size)*33.0));
             QApplication::processEvents();
         }
 
     }
 
-    m->properties[STR_PROP_DataVersion]=QString::number(prs1_data_version);
-    m->properties[STR_PROP_LastImported]=QDateTime::currentDateTime().toString(Qt::ISODate);
+    m->properties[STR_PROP_DataVersion] = QString::number(prs1_data_version);
+    m->properties[STR_PROP_LastImported] = QDateTime::currentDateTime().toString(Qt::ISODate);
     m->Save(); // Save any new sessions to disk in our format
-    if (qprogress) qprogress->setValue(100);
+
+    if (qprogress) { qprogress->setValue(100); }
 
     return cnt;
 }
@@ -463,21 +515,22 @@ int PRS1Loader::OpenMachine(Machine *m,QString path,Profile *profile)
 
 //};// __attribute__((packed));
 
-bool PRS1Loader::ParseSummary(Machine *mach, qint32 sequence, quint32 timestamp, unsigned char *data, quint16 size, int family, int familyVersion)
+bool PRS1Loader::ParseSummary(Machine *mach, qint32 sequence, quint32 timestamp,
+                              unsigned char *data, quint16 size, int family, int familyVersion)
 {
     if (mach->SessionExists(sequence)) {
-    	qDebug() << "sessionexists exit";
+        qDebug() << "sessionexists exit";
         return false;
     }
 
-    if (size<44-16) {
-	qDebug() << "size exit";
+    if (size < 44 - 16) {
+        qDebug() << "size exit";
         return false;
     }
 
-    Session *session=new Session(mach,sequence);
-    session->really_set_first(qint64(timestamp)*1000L);
-    EventDataType max,min;
+    Session *session = new Session(mach, sequence);
+    session->really_set_first(qint64(timestamp) * 1000L);
+    EventDataType max, min;
 
     //////////////////////////////////////////////////////////////////////////////////////////
     // ASV Codes (Family 5) Recheck 17/10/2013
@@ -511,58 +564,61 @@ bool PRS1Loader::ParseSummary(Machine *mach, qint32 sequence, quint32 timestamp,
     //avg_tidalvol=EventDataType(data[0x39])*10.0;  // Average Tidal Volume
     //////////////////////////////////////////////////////////////////////////////////////////
 
-    min=float(data[0x03])/10.0;   // Min EPAP
-    max=float(data[0x04])/10.0;   // Max EPAP
-    int offset=0;
+    min = float(data[0x03]) / 10.0; // Min EPAP
+    max = float(data[0x04]) / 10.0; // Max EPAP
+    int offset = 0;
 
-    if (family==5) { //data[0x05]!=0) { // This is a time value for ASV stuff
-        offset=4;   // non zero adds 4 extra fields..
-    } else if (family == 0 && familyVersion >= 4)
-        offset=2;
+    if (family == 5) { //data[0x05]!=0) { // This is a time value for ASV stuff
+        offset = 4; // non zero adds 4 extra fields..
+    } else if (family == 0 && familyVersion >= 4) {
+        offset = 2;
+    }
 
-    session->settings[CPAP_RampTime]=(int)data[offset+0x06]; // Minutes. Convert to seconds/hours here?
-    session->settings[CPAP_RampPressure]=(EventDataType)data[offset+0x07]/10.0;
+    session->settings[CPAP_RampTime] = (int)data[offset +
+                                       0x06]; // Minutes. Convert to seconds/hours here?
+    session->settings[CPAP_RampPressure] = (EventDataType)data[offset + 0x07] / 10.0;
 
-    if (max>0) { // Ignoring bipap until we see some more data during import
-        session->settings[CPAP_Mode]=(family==5) ? (int)MODE_ASV : (int)MODE_APAP;
+    if (max > 0) { // Ignoring bipap until we see some more data during import
+        session->settings[CPAP_Mode] = (family == 5) ? (int)MODE_ASV : (int)MODE_APAP;
 
-        session->settings[CPAP_PressureMin]=(EventDataType)min;
-        session->settings[CPAP_PressureMax]=(EventDataType)max;
+        session->settings[CPAP_PressureMin] = (EventDataType)min;
+        session->settings[CPAP_PressureMax] = (EventDataType)max;
     } else {
-        session->settings[CPAP_Mode]=(int)MODE_CPAP;
-        session->settings[CPAP_Pressure]=(EventDataType)min;
+        session->settings[CPAP_Mode] = (int)MODE_CPAP;
+        session->settings[CPAP_Pressure] = (EventDataType)min;
     }
 
     // This is incorrect..
-    if (data[offset+0x08] & 0x80) { // Flex Setting
-        if (data[offset+0x08] & 0x08) {
-            if (max>0) {
-                if (family==5) {
-                    session->settings[CPAP_PresReliefType]=(int)PR_BIFLEX;
+    if (data[offset + 0x08] & 0x80) { // Flex Setting
+        if (data[offset + 0x08] & 0x08) {
+            if (max > 0) {
+                if (family == 5) {
+                    session->settings[CPAP_PresReliefType] = (int)PR_BIFLEX;
                 } else {
-                    session->settings[CPAP_PresReliefType]=(int)PR_AFLEX;
+                    session->settings[CPAP_PresReliefType] = (int)PR_AFLEX;
                 }
-            }
-            else session->settings[CPAP_PresReliefType]=(int)PR_CFLEXPLUS;
-        } else session->settings[CPAP_PresReliefType]=(int)PR_CFLEX;
-    } else session->settings[CPAP_PresReliefType]=(int)PR_NONE;
+            } else { session->settings[CPAP_PresReliefType] = (int)PR_CFLEXPLUS; }
+        } else { session->settings[CPAP_PresReliefType] = (int)PR_CFLEX; }
+    } else { session->settings[CPAP_PresReliefType] = (int)PR_NONE; }
 
-    session->settings[CPAP_PresReliefMode]=(int)PM_FullTime; // only has one mode
+    session->settings[CPAP_PresReliefMode] = (int)PM_FullTime; // only has one mode
 
 
-    session->settings[CPAP_PresReliefSet]=(int)(data[offset+0x08] & 7);
-    session->settings[PRS1_SysLock]=(data[offset+0x0a]&0x80)==0x80;
-    session->settings[PRS1_HoseDiam]=((data[offset+0x0a]&0x08)?"15mm":"22mm");
-    session->settings[PRS1_AutoOff]=(data[offset+0x0c]&0x10)==0x10;
-    session->settings[PRS1_MaskAlert]=(data[offset+0x0c]&0x08)==0x08;
-    session->settings[PRS1_ShowAHI]=(data[offset+0x0c]&0x04)==0x04;
+    session->settings[CPAP_PresReliefSet] = (int)(data[offset + 0x08] & 7);
+    session->settings[PRS1_SysLock] = (data[offset + 0x0a] & 0x80) == 0x80;
+    session->settings[PRS1_HoseDiam] = ((data[offset + 0x0a] & 0x08) ? "15mm" : "22mm");
+    session->settings[PRS1_AutoOff] = (data[offset + 0x0c] & 0x10) == 0x10;
+    session->settings[PRS1_MaskAlert] = (data[offset + 0x0c] & 0x08) == 0x08;
+    session->settings[PRS1_ShowAHI] = (data[offset + 0x0c] & 0x04) == 0x04;
 
     if (family == 0 && familyVersion >= 4) {
-        if ((data[offset+0x0a]&0x04)==0x04) // heated tubing off
-            session->settings[CPAP_HumidSetting]=(int)data[offset+0x09]&0x0f;
-        else
-            session->settings[CPAP_HumidSetting]=(int)(data[offset+0x09]&0x30)>>4;
-        session->settings[PRS1_SysOneResistSet]=(int)(data[offset+0x0b]&0x38)>>3;
+        if ((data[offset + 0x0a] & 0x04) == 0x04) { // heated tubing off
+            session->settings[CPAP_HumidSetting] = (int)data[offset + 0x09] & 0x0f;
+        } else {
+            session->settings[CPAP_HumidSetting] = (int)(data[offset + 0x09] & 0x30) >> 4;
+        }
+
+        session->settings[PRS1_SysOneResistSet] = (int)(data[offset + 0x0b] & 0x38) >> 3;
         /* These should be added to channels, if they are correct(?) */
         /* for now, leave commented out                              */
         /*
@@ -572,39 +628,42 @@ bool PRS1Loader::ParseSummary(Machine *mach, qint32 sequence, quint32 timestamp,
             + (data[offset+0x0a]&0x03);
         */
     } else {
-        session->settings[CPAP_HumidSetting]=(int)data[offset+0x09]&0x0f;
-        session->settings[PRS1_HumidStatus]=(data[offset+0x09]&0x80)==0x80;
-        session->settings[PRS1_SysOneResistStat]=(data[offset+0x0a]&0x40)==0x40;
-        session->settings[PRS1_SysOneResistSet]=(int)data[offset+0x0a]&7;
+        session->settings[CPAP_HumidSetting] = (int)data[offset + 0x09] & 0x0f;
+        session->settings[PRS1_HumidStatus] = (data[offset + 0x09] & 0x80) == 0x80;
+        session->settings[PRS1_SysOneResistStat] = (data[offset + 0x0a] & 0x40) == 0x40;
+        session->settings[PRS1_SysOneResistSet] = (int)data[offset + 0x0a] & 7;
     }
 
     unsigned duration;
 
     // up to this point appears to becorrect for 0x01 & 0x00
-    if (size<59) {
-        duration=data[offset+0x12] | (data[offset+0x13] << 8);
-        duration*=2;
-        session->really_set_last(qint64(timestamp+duration)*1000L);
-        if (max>0) {
-            session->setMin(CPAP_Pressure,min);
-            session->setMax(CPAP_Pressure,max);
+    if (size < 59) {
+        duration = data[offset + 0x12] | (data[offset + 0x13] << 8);
+        duration *= 2;
+        session->really_set_last(qint64(timestamp + duration) * 1000L);
+
+        if (max > 0) {
+            session->setMin(CPAP_Pressure, min);
+            session->setMax(CPAP_Pressure, max);
             //session->setWavg(CPAP_Pressure,min);
         }
     } else {
 
         // 0X28 & 0X29 is length on r5
-        if (family == 0 && familyVersion >= 4)
+        if (family == 0 && familyVersion >= 4) {
             offset += 12;
+        }
+
+        duration = data[offset + 0x14] | (data[offset + 0x15] << 8);
 
-        duration=data[offset+0x14] | (data[offset+0x15] << 8);
         if (!duration) {
-	    qDebug() << "!duration exit";
+            qDebug() << "!duration exit";
             delete session;
             return false;
         }
 
-        session->really_set_last(qint64(timestamp+duration)*1000L);
-        float hours=float(duration)/3600.0;
+        session->really_set_last(qint64(timestamp + duration) * 1000L);
+        float hours = float(duration) / 3600.0;
 
         // Not using these because sometimes this summary is broken.
         //EventDataType minp,maxp,avgp,p90p;
@@ -614,66 +673,70 @@ bool PRS1Loader::ParseSummary(Machine *mach, qint32 sequence, quint32 timestamp,
         //p90p=float(data[offset+0x18])/10.0;
         //avgp=float(data[offset+0x19])/10.0;
 
-        short minp=data[offset+0x16];
-        short maxp=data[offset+0x17];
-        short medp=data[offset+0x19];
-        short p90p=data[offset+0x18];
+        short minp = data[offset + 0x16];
+        short maxp = data[offset + 0x17];
+        short medp = data[offset + 0x19];
+        short p90p = data[offset + 0x18];
 
-        if (family<5) {
-            if (minp>0) session->setMin(CPAP_Pressure,EventDataType(minp)*0.10);
-            if (maxp>0) session->setMax(CPAP_Pressure,EventDataType(maxp)*0.10);
-            if (medp>0) session->setWavg(CPAP_Pressure,EventDataType(medp)*0.10); // ??
+        if (family < 5) {
+            if (minp > 0) { session->setMin(CPAP_Pressure, EventDataType(minp) * 0.10); }
 
-            session->m_gain[CPAP_Pressure]=0.1;
-            session->m_valuesummary[CPAP_Pressure][minp]=5;
-            session->m_valuesummary[CPAP_Pressure][medp]=46;
-            session->m_valuesummary[CPAP_Pressure][p90p]=44;
-            session->m_valuesummary[CPAP_Pressure][maxp]=5;
+            if (maxp > 0) { session->setMax(CPAP_Pressure, EventDataType(maxp) * 0.10); }
+
+            if (medp > 0) { session->setWavg(CPAP_Pressure, EventDataType(medp) * 0.10); } // ??
+
+            session->m_gain[CPAP_Pressure] = 0.1;
+            session->m_valuesummary[CPAP_Pressure][minp] = 5;
+            session->m_valuesummary[CPAP_Pressure][medp] = 46;
+            session->m_valuesummary[CPAP_Pressure][p90p] = 44;
+            session->m_valuesummary[CPAP_Pressure][maxp] = 5;
         }
 
-//        if (p90p>0) {
-//            session->set90p(CPAP_Pressure,p90p);
-//        }
+        //        if (p90p>0) {
+        //            session->set90p(CPAP_Pressure,p90p);
+        //        }
 
         int oc, cc, hc, rc, fc;
-        session->setCount(CPAP_Obstructive,oc=(int)data[offset+0x1C] | (data[offset+0x1D] << 8));
-        session->setCount(CPAP_ClearAirway,cc=(int)data[offset+0x20] | (data[offset+0x21] << 8));
-        session->setCount(CPAP_Hypopnea,hc=(int)data[offset+0x2A] | (data[offset+0x2B] << 8));
-        session->setCount(CPAP_RERA,rc=(int)data[offset+0x2E] | (data[offset+0x2F] << 8));
-        session->setCount(CPAP_FlowLimit,fc=(int)data[offset+0x30] | (data[offset+0x31] << 8));
+        session->setCount(CPAP_Obstructive, oc = (int)data[offset + 0x1C] | (data[offset + 0x1D] << 8));
+        session->setCount(CPAP_ClearAirway, cc = (int)data[offset + 0x20] | (data[offset + 0x21] << 8));
+        session->setCount(CPAP_Hypopnea, hc = (int)data[offset + 0x2A] | (data[offset + 0x2B] << 8));
+        session->setCount(CPAP_RERA, rc = (int)data[offset + 0x2E] | (data[offset + 0x2F] << 8));
+        session->setCount(CPAP_FlowLimit, fc = (int)data[offset + 0x30] | (data[offset + 0x31] << 8));
 
-        session->setCph(CPAP_Obstructive,float(oc/hours));
-        session->setCph(CPAP_ClearAirway,float(cc/hours));
-        session->setCph(CPAP_Hypopnea,float(hc/hours));
-        session->setCph(CPAP_RERA,float(rc/hours));
-        session->setCph(CPAP_FlowLimit,float(fc/hours));
+        session->setCph(CPAP_Obstructive, float(oc / hours));
+        session->setCph(CPAP_ClearAirway, float(cc / hours));
+        session->setCph(CPAP_Hypopnea, float(hc / hours));
+        session->setCph(CPAP_RERA, float(rc / hours));
+        session->setCph(CPAP_FlowLimit, float(fc / hours));
     }
 
     // Set recommended Graph values..
-    session->setPhysMax(CPAP_LeakTotal,120);
-    session->setPhysMin(CPAP_LeakTotal,0);
-    session->setPhysMax(CPAP_Pressure,25);
-    session->setPhysMin(CPAP_Pressure,4);
-    session->setPhysMax(CPAP_IPAP,25);
-    session->setPhysMin(CPAP_IPAP,4);
-    session->setPhysMax(CPAP_EPAP,25);
-    session->setPhysMin(CPAP_EPAP,4);
-    session->setPhysMax(CPAP_PS,25);
-    session->setPhysMin(CPAP_PS,0);
+    session->setPhysMax(CPAP_LeakTotal, 120);
+    session->setPhysMin(CPAP_LeakTotal, 0);
+    session->setPhysMax(CPAP_Pressure, 25);
+    session->setPhysMin(CPAP_Pressure, 4);
+    session->setPhysMax(CPAP_IPAP, 25);
+    session->setPhysMin(CPAP_IPAP, 4);
+    session->setPhysMax(CPAP_EPAP, 25);
+    session->setPhysMin(CPAP_EPAP, 4);
+    session->setPhysMax(CPAP_PS, 25);
+    session->setPhysMin(CPAP_PS, 0);
 
 
-    new_sessions[sequence]=session;
+    new_sessions[sequence] = session;
     return true;
 }
-bool PRS1Loader::Parse002v5(qint32 sequence, quint32 timestamp, unsigned char *buffer, quint16 size)
+bool PRS1Loader::Parse002v5(qint32 sequence, quint32 timestamp, unsigned char *buffer,
+                            quint16 size)
 {
     if (!new_sessions.contains(sequence)) {
         qDebug() << "contains squence exit";
-	return false;
+        return false;
     }
-    Session *session=new_sessions[sequence];
 
-    ChannelID Codes[]={
+    Session *session = new_sessions[sequence];
+
+    ChannelID Codes[] = {
         PRS1_00, PRS1_01, CPAP_Pressure, CPAP_EPAP, CPAP_PressurePulse, CPAP_Obstructive,
         CPAP_ClearAirway, CPAP_Hypopnea, PRS1_08,  CPAP_FlowLimit, PRS1_0A, CPAP_CSR,
         PRS1_0C, CPAP_VSnore, PRS1_0E, PRS1_0F,
@@ -681,27 +744,27 @@ bool PRS1Loader::Parse002v5(qint32 sequence, quint32 timestamp, unsigned char *b
         CPAP_LeakTotal, PRS1_12
     };
 
-    int ncodes=sizeof(Codes)/sizeof(ChannelID);
-    EventList * Code[0x20]={NULL};
+    int ncodes = sizeof(Codes) / sizeof(ChannelID);
+    EventList *Code[0x20] = {NULL};
 
-    EventList * OA=session->AddEventList(CPAP_Obstructive, EVL_Event);
-    EventList * HY=session->AddEventList(CPAP_Hypopnea, EVL_Event);
-    EventList * CSR=session->AddEventList(CPAP_CSR, EVL_Event);
-    EventList * LEAK=session->AddEventList(CPAP_LeakTotal,EVL_Event);
-    EventList * SNORE=session->AddEventList(CPAP_Snore,EVL_Event);
-    EventList * IPAP=session->AddEventList(CPAP_IPAP,EVL_Event,0.1);
-    EventList * EPAP=session->AddEventList(CPAP_EPAP,EVL_Event,0.1);
-    EventList * PS=session->AddEventList(CPAP_PS,EVL_Event,0.1);
-    EventList * IPAPLo=session->AddEventList(CPAP_IPAPLo,EVL_Event,0.1);
-    EventList * IPAPHi=session->AddEventList(CPAP_IPAPHi,EVL_Event,0.1);
-    EventList * RR=session->AddEventList(CPAP_RespRate,EVL_Event);
-    EventList * PTB=session->AddEventList(CPAP_PTB,EVL_Event);
+    EventList *OA = session->AddEventList(CPAP_Obstructive, EVL_Event);
+    EventList *HY = session->AddEventList(CPAP_Hypopnea, EVL_Event);
+    EventList *CSR = session->AddEventList(CPAP_CSR, EVL_Event);
+    EventList *LEAK = session->AddEventList(CPAP_LeakTotal, EVL_Event);
+    EventList *SNORE = session->AddEventList(CPAP_Snore, EVL_Event);
+    EventList *IPAP = session->AddEventList(CPAP_IPAP, EVL_Event, 0.1);
+    EventList *EPAP = session->AddEventList(CPAP_EPAP, EVL_Event, 0.1);
+    EventList *PS = session->AddEventList(CPAP_PS, EVL_Event, 0.1);
+    EventList *IPAPLo = session->AddEventList(CPAP_IPAPLo, EVL_Event, 0.1);
+    EventList *IPAPHi = session->AddEventList(CPAP_IPAPHi, EVL_Event, 0.1);
+    EventList *RR = session->AddEventList(CPAP_RespRate, EVL_Event);
+    EventList *PTB = session->AddEventList(CPAP_PTB, EVL_Event);
 
-    EventList * MV=session->AddEventList(CPAP_MinuteVent,EVL_Event);
-    EventList * TV=session->AddEventList(CPAP_TidalVolume,EVL_Event,10);
+    EventList *MV = session->AddEventList(CPAP_MinuteVent, EVL_Event);
+    EventList *TV = session->AddEventList(CPAP_TidalVolume, EVL_Event, 10);
 
-    EventList * CA=NULL; //session->AddEventList(CPAP_ClearAirway, EVL_Event);
-    EventList * VS=NULL, * FL=NULL;//,* RE=NULL,* VS2=NULL;
+    EventList *CA = NULL; //session->AddEventList(CPAP_ClearAirway, EVL_Event);
+    EventList *VS = NULL, * FL = NULL; //,* RE=NULL,* VS2=NULL;
 
     //EventList * PRESSURE=NULL;
     //EventList * PP=NULL;
@@ -710,258 +773,293 @@ bool PRS1Loader::Parse002v5(qint32 sequence, quint32 timestamp, unsigned char *b
 
 
     //qint64 start=timestamp;
-    qint64 t=qint64(timestamp)*1000L;
+    qint64 t = qint64(timestamp) * 1000L;
     session->updateFirst(t);
     qint64 tt;
-    int pos=0;
-    int cnt=0;
+    int pos = 0;
+    int cnt = 0;
     short delta;//,duration;
     QDateTime d;
-    bool badcode=false;
-    unsigned char lastcode3=0,lastcode2=0,lastcode=0,code=0;
-    int lastpos=0,startpos=0,lastpos2=0,lastpos3=0;
+    bool badcode = false;
+    unsigned char lastcode3 = 0, lastcode2 = 0, lastcode = 0, code = 0;
+    int lastpos = 0, startpos = 0, lastpos2 = 0, lastpos3 = 0;
 
-    while (pos<size) {
-        lastcode3=lastcode2;
-        lastcode2=lastcode;
-        lastcode=code;
-        lastpos3=lastpos2;
-        lastpos2=lastpos;
-        lastpos=startpos;
-        startpos=pos;
-        code=buffer[pos++];
-        if (code>=ncodes) {
+    while (pos < size) {
+        lastcode3 = lastcode2;
+        lastcode2 = lastcode;
+        lastcode = code;
+        lastpos3 = lastpos2;
+        lastpos2 = lastpos;
+        lastpos = startpos;
+        startpos = pos;
+        code = buffer[pos++];
+
+        if (code >= ncodes) {
             qDebug() << "Illegal PRS1 code " << hex << int(code) << " appeared at " << hex << startpos;
-            qDebug() << "1: (" << int(lastcode ) << hex << lastpos << ")";
-            qDebug() << "2: (" << int(lastcode2) << hex << lastpos2 <<")";
-            qDebug() << "3: (" << int(lastcode3) << hex << lastpos3 <<")";
+            qDebug() << "1: (" << int(lastcode) << hex << lastpos << ")";
+            qDebug() << "2: (" << int(lastcode2) << hex << lastpos2 << ")";
+            qDebug() << "3: (" << int(lastcode3) << hex << lastpos3 << ")";
             return false;
         }
-        if (code==0) {
-        } else
-        if (code!=0x12) {
-            delta=buffer[pos];
+
+        if (code == 0) {
+        } else if (code != 0x12) {
+            delta = buffer[pos];
             //duration=buffer[pos+1];
             //delta=buffer[pos+1] << 8 | buffer[pos];
-            pos+=2;
-            t+=qint64(delta)*1000L;
+            pos += 2;
+            t += qint64(delta) * 1000L;
         }
-        ChannelID cpapcode=Codes[(int)code];
+
+        ChannelID cpapcode = Codes[(int)code];
         //EventDataType PS;
-        tt=t;
+        tt = t;
         cnt++;
-        int fc=0;
+        int fc = 0;
 
         switch (code) {
         case 0x00: // Unknown (ASV Pressure value)
             // offset?
-            data[0]=buffer[pos++];
+            data[0] = buffer[pos++];
             fc++;
-            if (!buffer[pos-1]) {   // WTH???
-                data[1]=buffer[pos++];
+
+            if (!buffer[pos - 1]) { // WTH???
+                data[1] = buffer[pos++];
                 fc++;
             }
-            if (!buffer[pos-1]) {
-                data[2]=buffer[pos++];
+
+            if (!buffer[pos - 1]) {
+                data[2] = buffer[pos++];
                 fc++;
             }
+
             break;
+
         case 0x01: // Unknown
             if (!Code[1]) {
-                if (!(Code[1]=session->AddEventList(cpapcode,EVL_Event,0.1))) return false;
+                if (!(Code[1] = session->AddEventList(cpapcode, EVL_Event, 0.1))) { return false; }
             }
-            Code[1]->AddEvent(t,0);
+
+            Code[1]->AddEvent(t, 0);
             break;
 
         case 0x02: // Pressure ???
-            data[0]=buffer[pos++];
-//            if (!Code[2]) {
-//                if (!(Code[2]=session->AddEventList(cpapcode,EVL_Event,0.1))) return false;
-//            }
-//            Code[2]->AddEvent(t,data[0]);
+            data[0] = buffer[pos++];
+            //            if (!Code[2]) {
+            //                if (!(Code[2]=session->AddEventList(cpapcode,EVL_Event,0.1))) return false;
+            //            }
+            //            Code[2]->AddEvent(t,data[0]);
             break;
+
         case 0x04: // Pressure Pulse??
-            data[0]=buffer[pos++];
+            data[0] = buffer[pos++];
+
             if (!Code[3]) {
-                if (!(Code[3]=session->AddEventList(cpapcode,EVL_Event))) return false;
+                if (!(Code[3] = session->AddEventList(cpapcode, EVL_Event))) { return false; }
             }
-            Code[3]->AddEvent(t,data[0]);
+
+            Code[3]->AddEvent(t, data[0]);
             break;
 
         case 0x05:
             //code=CPAP_Obstructive;
-            data[0]=buffer[pos++];
-            tt-=qint64(data[0])*1000L; // Subtract Time Offset
-            OA->AddEvent(tt,data[0]);
+            data[0] = buffer[pos++];
+            tt -= qint64(data[0]) * 1000L; // Subtract Time Offset
+            OA->AddEvent(tt, data[0]);
             break;
 
         case 0x06:
             //code=CPAP_ClearAirway;
-            data[0]=buffer[pos++];
-            tt-=qint64(data[0])*1000L; // Subtract Time Offset
+            data[0] = buffer[pos++];
+            tt -= qint64(data[0]) * 1000L; // Subtract Time Offset
+
             if (!CA) {
-                if (!(CA=session->AddEventList(cpapcode,EVL_Event))) return false;
+                if (!(CA = session->AddEventList(cpapcode, EVL_Event))) { return false; }
             }
-            CA->AddEvent(tt,data[0]);
+
+            CA->AddEvent(tt, data[0]);
             break;
+
         case 0x07:
             //code=CPAP_Hypopnea;
-            data[0]=buffer[pos++];
-            tt-=qint64(data[0])*1000L; // Subtract Time Offset
-            HY->AddEvent(tt,data[0]);
+            data[0] = buffer[pos++];
+            tt -= qint64(data[0]) * 1000L; // Subtract Time Offset
+            HY->AddEvent(tt, data[0]);
             break;
+
         case 0x08: // ???
-            data[0]=buffer[pos++];
-            tt-=qint64(data[0])*1000L; // Subtract Time Offset
-            qDebug() << "Code 8 found at " << hex << pos-1 << " " << tt;
-	    if (!Code[10]) {
-                if (!(Code[10]=session->AddEventList(cpapcode,EVL_Event))) return false;
+            data[0] = buffer[pos++];
+            tt -= qint64(data[0]) * 1000L; // Subtract Time Offset
+            qDebug() << "Code 8 found at " << hex << pos - 1 << " " << tt;
+
+            if (!Code[10]) {
+                if (!(Code[10] = session->AddEventList(cpapcode, EVL_Event))) { return false; }
             }
 
             //????
             //data[1]=buffer[pos++]; // ???
-            Code[10]->AddEvent(tt,data[0]);
-	    pos++;
+            Code[10]->AddEvent(tt, data[0]);
+            pos++;
             break;
+
         case 0x09: // ASV Codes
             //code=CPAP_FlowLimit;
-            data[0]=buffer[pos++];
-            tt-=qint64(data[0])*1000L; // Subtract Time Offset
+            data[0] = buffer[pos++];
+            tt -= qint64(data[0]) * 1000L; // Subtract Time Offset
+
             if (!FL) {
-                if (!(FL=session->AddEventList(cpapcode,EVL_Event))) return false;
+                if (!(FL = session->AddEventList(cpapcode, EVL_Event))) { return false; }
             }
-            FL->AddEvent(tt,data[0]);
+
+            FL->AddEvent(tt, data[0]);
 
             break;
 
         case 0x0a:
-            data[0]=buffer[pos++];
-            tt-=qint64(data[0])*1000L; // Subtract Time Offset
+            data[0] = buffer[pos++];
+            tt -= qint64(data[0]) * 1000L; // Subtract Time Offset
+
             if (!Code[7]) {
-                if (!(Code[7]=session->AddEventList(cpapcode,EVL_Event))) return false;
+                if (!(Code[7] = session->AddEventList(cpapcode, EVL_Event))) { return false; }
             }
-            Code[7]->AddEvent(tt,data[0]);
+
+            Code[7]->AddEvent(tt, data[0]);
             break;
 
 
         case 0x0b: // Cheyne Stokes
-            data[0]=((unsigned char *)buffer)[pos+1]<<8 | ((unsigned char *)buffer)[pos];
+            data[0] = ((unsigned char *)buffer)[pos + 1] << 8 | ((unsigned char *)buffer)[pos];
             //data[0]*=2;
-            pos+=2;
-            data[1]=((unsigned char *)buffer)[pos]; //|buffer[pos+1] << 8
-            pos+=1;
+            pos += 2;
+            data[1] = ((unsigned char *)buffer)[pos]; //|buffer[pos+1] << 8
+            pos += 1;
             //tt-=delta;
-            tt-=qint64(data[1])*1000L;
+            tt -= qint64(data[1]) * 1000L;
+
             if (!CSR) {
-                if (!(CSR=session->AddEventList(cpapcode,EVL_Event))) {
-		    qDebug() << "!CSR addeventlist exit";
+                if (!(CSR = session->AddEventList(cpapcode, EVL_Event))) {
+                    qDebug() << "!CSR addeventlist exit";
                     return false;
-		}
+                }
             }
-            CSR->AddEvent(tt,data[0]);
+
+            CSR->AddEvent(tt, data[0]);
             break;
 
         case 0x0c:
-            data[0]=buffer[pos++];
-            tt-=qint64(data[0])*1000L; // Subtract Time Offset
-	    qDebug() << "Code 12 found at " << hex << pos-1 << " " << tt;
+            data[0] = buffer[pos++];
+            tt -= qint64(data[0]) * 1000L; // Subtract Time Offset
+            qDebug() << "Code 12 found at " << hex << pos - 1 << " " << tt;
+
             if (!Code[8]) {
-                if (!(Code[8]=session->AddEventList(cpapcode,EVL_Event))) return false;
+                if (!(Code[8] = session->AddEventList(cpapcode, EVL_Event))) { return false; }
             }
-            Code[8]->AddEvent(tt,data[0]);
-	    pos+=2;
+
+            Code[8]->AddEvent(tt, data[0]);
+            pos += 2;
             break;
 
         case 0x0d: // All the other ASV graph stuff.
-            IPAP->AddEvent(t,data[0]=buffer[pos++]);    // 00=IAP
-            data[4]=buffer[pos++];
-            IPAPLo->AddEvent(t,data[4]);                // 01=IAP Low
-            data[5]=buffer[pos++];
-            IPAPHi->AddEvent(t,data[5]);                // 02=IAP High
-            LEAK->AddEvent(t,buffer[pos++]);            // 03=LEAK
-            RR->AddEvent(t,buffer[pos++]);              // 04=Breaths Per Minute
-            PTB->AddEvent(t,buffer[pos++]);             // 05=Patient Triggered Breaths
-            MV->AddEvent(t,buffer[pos++]);              // 06=Minute Ventilation
+            IPAP->AddEvent(t, data[0] = buffer[pos++]); // 00=IAP
+            data[4] = buffer[pos++];
+            IPAPLo->AddEvent(t, data[4]);               // 01=IAP Low
+            data[5] = buffer[pos++];
+            IPAPHi->AddEvent(t, data[5]);               // 02=IAP High
+            LEAK->AddEvent(t, buffer[pos++]);           // 03=LEAK
+            RR->AddEvent(t, buffer[pos++]);             // 04=Breaths Per Minute
+            PTB->AddEvent(t, buffer[pos++]);            // 05=Patient Triggered Breaths
+            MV->AddEvent(t, buffer[pos++]);             // 06=Minute Ventilation
             //tmp=buffer[pos++] * 10.0;
-            TV->AddEvent(t,buffer[pos++]);              // 07=Tidal Volume
-            SNORE->AddEvent(t,data[2]=buffer[pos++]);   // 08=Snore
-            if (data[2]>0) {
+            TV->AddEvent(t, buffer[pos++]);             // 07=Tidal Volume
+            SNORE->AddEvent(t, data[2] = buffer[pos++]); // 08=Snore
+
+            if (data[2] > 0) {
                 if (!VS) {
-                    if (!(VS=session->AddEventList(CPAP_VSnore,EVL_Event))) {
-			qDebug() << "!VS eventlist exit";
+                    if (!(VS = session->AddEventList(CPAP_VSnore, EVL_Event))) {
+                        qDebug() << "!VS eventlist exit";
                         return false;
-		    }
+                    }
                 }
-                VS->AddEvent(t,0); //data[2]); // VSnore
+
+                VS->AddEvent(t, 0); //data[2]); // VSnore
             }
-            EPAP->AddEvent(t,data[1]=buffer[pos++]);    // 09=EPAP
-            data[2]=data[0]-data[1];
-            PS->AddEvent(t,data[2]);            // Pressure Support
+
+            EPAP->AddEvent(t, data[1] = buffer[pos++]); // 09=EPAP
+            data[2] = data[0] - data[1];
+            PS->AddEvent(t, data[2]);           // Pressure Support
             break;
+
         case 0x03: // BIPAP Pressure
             qDebug() << "0x03 Observed in ASV data!!????";
 
-            data[0]=buffer[pos++];
-            data[1]=buffer[pos++];
-//            data[0]/=10.0;
-//            data[1]/=10.0;
-//            session->AddEvent(new Event(t,CPAP_EAP, 0, data, 1));
-//            session->AddEvent(new Event(t,CPAP_IAP, 0, &data[1], 1));
+            data[0] = buffer[pos++];
+            data[1] = buffer[pos++];
+            //            data[0]/=10.0;
+            //            data[1]/=10.0;
+            //            session->AddEvent(new Event(t,CPAP_EAP, 0, data, 1));
+            //            session->AddEvent(new Event(t,CPAP_IAP, 0, &data[1], 1));
             break;
+
         case 0x11: // Not Leak Rate
             qDebug() << "0x11 Observed in ASV data!!????";
             //if (!Code[24]) {
-             //   Code[24]=new EventList(cpapcode,EVL_Event);
+            //   Code[24]=new EventList(cpapcode,EVL_Event);
             //}
             //Code[24]->AddEvent(t,buffer[pos++]);
             break;
+
         case 0x0e: // Unknown
             qDebug() << "0x0E Observed in ASV data!!????";
-            data[0]=buffer[pos++]; // << 8) | buffer[pos];
+            data[0] = buffer[pos++]; // << 8) | buffer[pos];
             //session->AddEvent(new Event(t,cpapcode, 0, data, 1));
             break;
 
         case 0x10: // Unknown
             qDebug() << "0x10 Observed in ASV data!!????";
-            data[0]=buffer[pos++]; // << 8) | buffer[pos];
-            data[1]=buffer[pos++];
-            data[2]=buffer[pos++];
+            data[0] = buffer[pos++]; // << 8) | buffer[pos];
+            data[1] = buffer[pos++];
+            data[2] = buffer[pos++];
             //session->AddEvent(new Event(t,cpapcode, 0, data, 3));
             break;
+
         case 0x0f:
             qDebug() << "0x0f Observed in ASV data!!????";
 
-            data[0]=buffer[pos+1]<<8 | buffer[pos];
-            pos+=2;
-            data[1]=buffer[pos]; //|buffer[pos+1] << 8
-            pos+=1;
-            tt-=qint64(data[1])*1000L;
+            data[0] = buffer[pos + 1] << 8 | buffer[pos];
+            pos += 2;
+            data[1] = buffer[pos]; //|buffer[pos+1] << 8
+            pos += 1;
+            tt -= qint64(data[1]) * 1000L;
             //session->AddEvent(new Event(tt,cpapcode, 0, data, 2));
             break;
+
         case 0x12: // Summary
             qDebug() << "0x12 Observed in ASV data!!????";
-            data[0]=buffer[pos++];
-            data[1]=buffer[pos++];
-            data[2]=buffer[pos+1]<<8 | buffer[pos];
-            pos+=2;
+            data[0] = buffer[pos++];
+            data[1] = buffer[pos++];
+            data[2] = buffer[pos + 1] << 8 | buffer[pos];
+            pos += 2;
             //session->AddEvent(new Event(t,cpapcode, 0, data,3));
             break;
+
         default:  // ERROR!!!
-            qWarning() << "Some new fandangled PRS1 code detected " << hex << int(code) << " at " << pos-1;
-            badcode=true;
+            qWarning() << "Some new fandangled PRS1 code detected " << hex << int(code) << " at " << pos - 1;
+            badcode = true;
             break;
         }
+
         if (badcode) {
             break;
         }
     }
+
     session->updateLast(t);
     session->m_cnt.clear();
     session->m_cph.clear();
-    session->settings[CPAP_IPAPLo]=session->Min(CPAP_IPAPLo);
-    session->settings[CPAP_IPAPHi]=session->Max(CPAP_IPAPHi);
-    session->settings[CPAP_PSMax]=session->Max(CPAP_IPAPHi) - session->Min(CPAP_EPAP);
-    session->settings[CPAP_PSMin]=session->Min(CPAP_IPAPLo) - session->Min(CPAP_EPAP);
+    session->settings[CPAP_IPAPLo] = session->Min(CPAP_IPAPLo);
+    session->settings[CPAP_IPAPHi] = session->Max(CPAP_IPAPHi);
+    session->settings[CPAP_PSMax] = session->Max(CPAP_IPAPHi) - session->Min(CPAP_EPAP);
+    session->settings[CPAP_PSMin] = session->Min(CPAP_IPAPLo) - session->Min(CPAP_EPAP);
 
     session->m_valuesummary[CPAP_Pressure].clear();
     session->m_valuesummary.erase(session->m_valuesummary.find(CPAP_Pressure));
@@ -970,247 +1068,300 @@ bool PRS1Loader::Parse002v5(qint32 sequence, quint32 timestamp, unsigned char *b
 
 }
 
-bool PRS1Loader::Parse002(qint32 sequence, quint32 timestamp, unsigned char *buffer, quint16 size, int family, int familyVersion)
+bool PRS1Loader::Parse002(qint32 sequence, quint32 timestamp, unsigned char *buffer, quint16 size,
+                          int family, int familyVersion)
 {
-    if (!new_sessions.contains(sequence))
+    if (!new_sessions.contains(sequence)) {
         return false;
+    }
 
     unsigned char code;
-    EventList * Code[0x20]={0};
+    EventList *Code[0x20] = {0};
     EventDataType data[10];
-    int cnt=0;
+    int cnt = 0;
     short delta;
     int tdata;
     quint64 pos;
-    qint64 t=qint64(timestamp)*1000L,tt;
+    qint64 t = qint64(timestamp) * 1000L, tt;
 
-    Session *session=new_sessions[sequence];
+    Session *session = new_sessions[sequence];
     session->updateFirst(t);
 
-    EventList * OA=session->AddEventList(CPAP_Obstructive, EVL_Event);
-    EventList * HY=session->AddEventList(CPAP_Hypopnea, EVL_Event);
-    EventList * CSR=session->AddEventList(CPAP_CSR, EVL_Event);
-    EventList * LEAK=session->AddEventList(CPAP_LeakTotal,EVL_Event);
-    EventList * SNORE=session->AddEventList(CPAP_Snore,EVL_Event);
+    EventList *OA = session->AddEventList(CPAP_Obstructive, EVL_Event);
+    EventList *HY = session->AddEventList(CPAP_Hypopnea, EVL_Event);
+    EventList *CSR = session->AddEventList(CPAP_CSR, EVL_Event);
+    EventList *LEAK = session->AddEventList(CPAP_LeakTotal, EVL_Event);
+    EventList *SNORE = session->AddEventList(CPAP_Snore, EVL_Event);
 
-    EventList * CA=NULL; //session->AddEventList(CPAP_ClearAirway, EVL_Event);
-    EventList * VS=NULL, * VS2=NULL, * FL=NULL,* RE=NULL;
+    EventList *CA = NULL; //session->AddEventList(CPAP_ClearAirway, EVL_Event);
+    EventList *VS = NULL, * VS2 = NULL, * FL = NULL, * RE = NULL;
 
-    EventList * PRESSURE=NULL;
-    EventList * EPAP=NULL;
-    EventList * IPAP=NULL;
-    EventList * PS=NULL;
+    EventList *PRESSURE = NULL;
+    EventList *EPAP = NULL;
+    EventList *IPAP = NULL;
+    EventList *PS = NULL;
 
-    EventList * PP=NULL;
+    EventList *PP = NULL;
 
     //session->AddEventList(CPAP_VSnore, EVL_Event);
     //EventList * VS=session->AddEventList(CPAP_Obstructive, EVL_Event);
-    unsigned char lastcode3=0,lastcode2=0,lastcode=0;
-    int lastpos=0,startpos=0,lastpos2=0,lastpos3=0;
+    unsigned char lastcode3 = 0, lastcode2 = 0, lastcode = 0;
+    int lastpos = 0, startpos = 0, lastpos2 = 0, lastpos3 = 0;
 
-    for (pos=0;pos<size;) {
-        lastcode3=lastcode2;
-        lastcode2=lastcode;
-        lastcode=code;
-        lastpos3=lastpos2;
-        lastpos2=lastpos;
-        lastpos=startpos;
-        startpos=pos;
-        code=buffer[pos++];
-        if (code>0x12) {
+    for (pos = 0; pos < size;) {
+        lastcode3 = lastcode2;
+        lastcode2 = lastcode;
+        lastcode = code;
+        lastpos3 = lastpos2;
+        lastpos2 = lastpos;
+        lastpos = startpos;
+        startpos = pos;
+        code = buffer[pos++];
+
+        if (code > 0x12) {
             qDebug() << "Illegal PRS1 code " << hex << int(code) << " appeared at " << hex << startpos;
-            qDebug() << "1: (" << hex << int(lastcode ) << hex << lastpos << ")";
-            qDebug() << "2: (" << hex << int(lastcode2) << hex << lastpos2 <<")";
-            qDebug() << "3: (" << hex << int(lastcode3) << hex << lastpos3 <<")";
+            qDebug() << "1: (" << hex << int(lastcode) << hex << lastpos << ")";
+            qDebug() << "2: (" << hex << int(lastcode2) << hex << lastpos2 << ")";
+            qDebug() << "3: (" << hex << int(lastcode3) << hex << lastpos3 << ")";
             return false;
         }
-        if (code!=0x12) {
-            delta=buffer[pos+1] << 8 | buffer[pos];
-            pos+=2;
-            t+=qint64(delta)*1000L;
-            tt=t;
+
+        if (code != 0x12) {
+            delta = buffer[pos + 1] << 8 | buffer[pos];
+            pos += 2;
+            t += qint64(delta) * 1000L;
+            tt = t;
         }
+
         cnt++;
+
         switch (code) {
 
         case 0x00: // Unknown 00
             if (!Code[0]) {
-                if (!(Code[0]=session->AddEventList(PRS1_00,EVL_Event))) return false;
+                if (!(Code[0] = session->AddEventList(PRS1_00, EVL_Event))) { return false; }
             }
-            Code[0]->AddEvent(t,buffer[pos++]);
 
-            if (family == 0 && familyVersion >=4)
+            Code[0]->AddEvent(t, buffer[pos++]);
+
+            if (family == 0 && familyVersion >= 4) {
                 pos++;
+            }
+
             break;
+
         case 0x01: // Unknown
             if (!Code[1]) {
-                if (!(Code[1]=session->AddEventList(PRS1_01,EVL_Event))) return false;
+                if (!(Code[1] = session->AddEventList(PRS1_01, EVL_Event))) { return false; }
             }
-            Code[1]->AddEvent(t,0);
+
+            Code[1]->AddEvent(t, 0);
+
             if (family == 0 && familyVersion >= 4) {
                 if (!PRESSURE) {
-                    PRESSURE=session->AddEventList(CPAP_Pressure,EVL_Event,0.1);
-                    if (!PRESSURE) return false;
+                    PRESSURE = session->AddEventList(CPAP_Pressure, EVL_Event, 0.1);
+
+                    if (!PRESSURE) { return false; }
                 }
-                PRESSURE->AddEvent(t,buffer[pos++]);
+
+                PRESSURE->AddEvent(t, buffer[pos++]);
             }
+
             break;
+
         case 0x02: // Pressure
             if (family == 0 && familyVersion >= 4) {  // BiPAP Pressure
                 if (!EPAP) {
-                    if (!(EPAP=session->AddEventList(CPAP_EPAP,EVL_Event,0.1))) return false;
-                    if (!(IPAP=session->AddEventList(CPAP_IPAP,EVL_Event,0.1))) return false;
-                    if (!(PS=session->AddEventList(CPAP_PS,EVL_Event,0.1))) return false;
-                }
-                EPAP->AddEvent(t,data[0]=buffer[pos++]);
-                IPAP->AddEvent(t,data[1]=buffer[pos++]);
-                PS->AddEvent(t,data[1]-data[0]);
-            }
-            else {
-                if (!PRESSURE) {
-                    PRESSURE=session->AddEventList(CPAP_Pressure,EVL_Event,0.1);
-                    if (!PRESSURE) return false;
+                    if (!(EPAP = session->AddEventList(CPAP_EPAP, EVL_Event, 0.1))) { return false; }
+
+                    if (!(IPAP = session->AddEventList(CPAP_IPAP, EVL_Event, 0.1))) { return false; }
+
+                    if (!(PS = session->AddEventList(CPAP_PS, EVL_Event, 0.1))) { return false; }
                 }
 
-                PRESSURE->AddEvent(t,buffer[pos++]);
+                EPAP->AddEvent(t, data[0] = buffer[pos++]);
+                IPAP->AddEvent(t, data[1] = buffer[pos++]);
+                PS->AddEvent(t, data[1] - data[0]);
+            } else {
+                if (!PRESSURE) {
+                    PRESSURE = session->AddEventList(CPAP_Pressure, EVL_Event, 0.1);
+
+                    if (!PRESSURE) { return false; }
+                }
+
+                PRESSURE->AddEvent(t, buffer[pos++]);
             }
+
             break;
+
         case 0x03: // BIPAP Pressure
             if (!EPAP) {
-                if (!(EPAP=session->AddEventList(CPAP_EPAP,EVL_Event,0.1))) return false;
-                if (!(IPAP=session->AddEventList(CPAP_IPAP,EVL_Event,0.1))) return false;
-                if (!(PS=session->AddEventList(CPAP_PS,EVL_Event,0.1))) return false;
+                if (!(EPAP = session->AddEventList(CPAP_EPAP, EVL_Event, 0.1))) { return false; }
+
+                if (!(IPAP = session->AddEventList(CPAP_IPAP, EVL_Event, 0.1))) { return false; }
+
+                if (!(PS = session->AddEventList(CPAP_PS, EVL_Event, 0.1))) { return false; }
             }
-            EPAP->AddEvent(t,data[0]=buffer[pos++]);
-            IPAP->AddEvent(t,data[1]=buffer[pos++]);
-            PS->AddEvent(t,data[1]-data[0]);
+
+            EPAP->AddEvent(t, data[0] = buffer[pos++]);
+            IPAP->AddEvent(t, data[1] = buffer[pos++]);
+            PS->AddEvent(t, data[1] - data[0]);
             break;
+
         case 0x04: // Pressure Pulse
             if (!PP) {
-                if (!(PP=session->AddEventList(CPAP_PressurePulse,EVL_Event))) return false;
+                if (!(PP = session->AddEventList(CPAP_PressurePulse, EVL_Event))) { return false; }
             }
-            PP->AddEvent(t,buffer[pos++]);
+
+            PP->AddEvent(t, buffer[pos++]);
             break;
+
         case 0x05: // RERA
-            data[0]=buffer[pos++];
-            tt=t-(qint64(data[0])*1000L);
+            data[0] = buffer[pos++];
+            tt = t - (qint64(data[0]) * 1000L);
+
             if (!RE) {
-                if (!(RE=session->AddEventList(CPAP_RERA,EVL_Event))) return false;
+                if (!(RE = session->AddEventList(CPAP_RERA, EVL_Event))) { return false; }
             }
-            RE->AddEvent(tt,data[0]);
+
+            RE->AddEvent(tt, data[0]);
             break;
 
         case 0x06: // Obstructive Apoanea
-            data[0]=buffer[pos++];
-            tt=t-(qint64(data[0])*1000L);
-            OA->AddEvent(tt,data[0]);
+            data[0] = buffer[pos++];
+            tt = t - (qint64(data[0]) * 1000L);
+            OA->AddEvent(tt, data[0]);
             break;
+
         case 0x07: // Clear Airway
-            data[0]=buffer[pos++];
-            tt=t-(qint64(data[0])*1000L);
+            data[0] = buffer[pos++];
+            tt = t - (qint64(data[0]) * 1000L);
+
             if (!CA) {
-                if (!(CA=session->AddEventList(CPAP_ClearAirway,EVL_Event))) return false;
+                if (!(CA = session->AddEventList(CPAP_ClearAirway, EVL_Event))) { return false; }
             }
-            CA->AddEvent(tt,data[0]);
+
+            CA->AddEvent(tt, data[0]);
             break;
 
         case 0x0a: // Hypopnea
-            data[0]=buffer[pos++];
-            tt=t-(qint64(data[0])*1000L);
-            HY->AddEvent(tt,data[0]);
+            data[0] = buffer[pos++];
+            tt = t - (qint64(data[0]) * 1000L);
+            HY->AddEvent(tt, data[0]);
             break;
 
         case 0x0c: // Flow Limitation
-            data[0]=buffer[pos++];
-            tt=t-(qint64(data[0])*1000L);
+            data[0] = buffer[pos++];
+            tt = t - (qint64(data[0]) * 1000L);
+
             if (!FL) {
-                if (!(FL=session->AddEventList(CPAP_FlowLimit,EVL_Event))) return false;
+                if (!(FL = session->AddEventList(CPAP_FlowLimit, EVL_Event))) { return false; }
             }
-            FL->AddEvent(tt,data[0]);
+
+            FL->AddEvent(tt, data[0]);
             break;
 
         case 0x0b: // Hypopnea related code
-            data[0]=buffer[pos++];
-            data[1]=buffer[pos++];
+            data[0] = buffer[pos++];
+            data[1] = buffer[pos++];
+
             if (!Code[12]) {
-                if (!(Code[12]=session->AddEventList(PRS1_0B,EVL_Event))) return false;
+                if (!(Code[12] = session->AddEventList(PRS1_0B, EVL_Event))) { return false; }
             }
+
             // FIXME
-            Code[12]->AddEvent(t,data[0]);
+            Code[12]->AddEvent(t, data[0]);
             break;
 
         case 0x0d: // Vibratory Snore
             if (!VS) {
-                if (!(VS=session->AddEventList(CPAP_VSnore,EVL_Event))) return false;
+                if (!(VS = session->AddEventList(CPAP_VSnore, EVL_Event))) { return false; }
             }
-            VS->AddEvent(t,0);
+
+            VS->AddEvent(t, 0);
             break;
+
         case 0x11: // Leak Rate & Snore Graphs
-            data[0]=buffer[pos++];
-            data[1]=buffer[pos++];
+            data[0] = buffer[pos++];
+            data[1] = buffer[pos++];
 
-            LEAK->AddEvent(t,data[0]);
-            SNORE->AddEvent(t,data[1]);
+            LEAK->AddEvent(t, data[0]);
+            SNORE->AddEvent(t, data[1]);
 
-            if (data[1]>0) {
+            if (data[1] > 0) {
                 if (!VS2) {
-                    if (!(VS2=session->AddEventList(CPAP_VSnore2,EVL_Event))) return false;
+                    if (!(VS2 = session->AddEventList(CPAP_VSnore2, EVL_Event))) { return false; }
                 }
-                VS2->AddEvent(t,data[1]);
+
+                VS2->AddEvent(t, data[1]);
             }
 
-            if (family == 0 && familyVersion >=4)
+            if (family == 0 && familyVersion >= 4) {
                 pos++;
+            }
+
             break;
+
         case 0x0e: // Unknown
-            data[0]=((char *)buffer)[pos++];
-            data[1]=buffer[pos++]; //(buffer[pos+1] << 8) | buffer[pos];
+            data[0] = ((char *)buffer)[pos++];
+            data[1] = buffer[pos++]; //(buffer[pos+1] << 8) | buffer[pos];
             //data[0]/=10.0;
             //pos+=2;
-            data[2]=buffer[pos++];
+            data[2] = buffer[pos++];
 
             if (!Code[17]) {
-                if (!(Code[17]=session->AddEventList(PRS1_0E,EVL_Event))) return false;
+                if (!(Code[17] = session->AddEventList(PRS1_0E, EVL_Event))) { return false; }
             }
-            tdata=unsigned(data[1]) << 8 | unsigned(data[0]);
-            Code[17]->AddEvent(t,tdata);
+
+            tdata = unsigned(data[1]) << 8 | unsigned(data[0]);
+            Code[17]->AddEvent(t, tdata);
             //qDebug() << hex << data[0] << data[1] << data[2];
             //session->AddEvent(new Event(t,cpapcode, 0, data, 3));
             //tt-=data[1]*1000;
             //session->AddEvent(new Event(t,CPAP_CSR, data, 2));
             break;
+
         case 0x10: // Unknown
-            data[0]=buffer[pos++]; // << 8) | buffer[pos];
-            data[1]=buffer[pos++];
-            data[2]=buffer[pos++];
+            data[0] = buffer[pos++]; // << 8) | buffer[pos];
+            data[1] = buffer[pos++];
+            data[2] = buffer[pos++];
+
             if (!Code[20]) {
-                if (!(Code[20]=session->AddEventList(PRS1_10,EVL_Event))) return false;
+                if (!(Code[20] = session->AddEventList(PRS1_10, EVL_Event))) { return false; }
             }
-            Code[20]->AddEvent(t,data[0]);
+
+            Code[20]->AddEvent(t, data[0]);
             break;
+
         case 0x0f: // Cheyne Stokes Respiration
-            data[0]=buffer[pos+1]<<8 | buffer[pos];
-            pos+=2;
-            data[1]=buffer[pos++];
-            tt=t-qint64(data[1])*1000L;
-            CSR->AddEvent(tt,data[0]);
+            data[0] = buffer[pos + 1] << 8 | buffer[pos];
+            pos += 2;
+            data[1] = buffer[pos++];
+            tt = t - qint64(data[1]) * 1000L;
+            CSR->AddEvent(tt, data[0]);
             break;
+
         case 0x12: // Summary
-            data[0]=buffer[pos++];
-            data[1]=buffer[pos++];
-            data[2]=buffer[pos+1]<<8 | buffer[pos];
-            pos+=2;
+            data[0] = buffer[pos++];
+            data[1] = buffer[pos++];
+            data[2] = buffer[pos + 1] << 8 | buffer[pos];
+            pos += 2;
+
             if (!Code[24]) {
-                if (!(Code[24]=session->AddEventList(PRS1_12,EVL_Event))) return false;
+                if (!(Code[24] = session->AddEventList(PRS1_12, EVL_Event))) { return false; }
             }
-            Code[24]->AddEvent(t,data[0]);
+
+            Code[24]->AddEvent(t, data[0]);
             break;
+
         default:
             // ERROR!!!
-            qWarning() << "Some new fandangled PRS1 code detected in" << sequence << hex << int(code) << " at " << pos-1;
+            qWarning() << "Some new fandangled PRS1 code detected in" << sequence << hex << int(
+                           code) << " at " << pos - 1;
             return false;
         }
     }
+
     session->updateLast(t);
     session->m_cnt.clear();
     session->m_cph.clear();
@@ -1251,107 +1402,129 @@ bool PRS1Loader::Parse002(qint32 sequence, quint32 timestamp, unsigned char *buf
 
 bool PRS1Loader::OpenFile(Machine *mach, QString filename)
 {
-    int sequence,family, familyVersion;
+    int sequence, family, familyVersion;
     quint32 timestamp;
     qint64 pos;
-    unsigned char ext,sum, htype;
-    unsigned char *header,*data;
-    int chunk,hl;
-    quint16 size,datasize,c16,crc;
+    unsigned char ext, sum, htype;
+    unsigned char *header, *data;
+    int chunk, hl;
+    quint16 size, datasize, c16, crc;
 
     // waveform stuff
     vector<WaveHeaderList> whl;
-    quint16 interleave,duration,num_signals;
+    quint16 interleave, duration, num_signals;
     quint8  sample_format;
 
     QFile f(filename);
-    if (!f.exists())
-        return false;
 
-    if (!f.open(QIODevice::ReadOnly))
-        return false;
-
-    qint64 filesize=f.size();
-
-    if (filesize>max_load_buffer_size) {
-        qWarning() << "Waveform too big, increase max_load_buffer_size in PRS1Loader sourcecode" << filename;
+    if (!f.exists()) {
         return false;
     }
 
-    if (f.read((char *)m_buffer,filesize)<filesize) {
+    if (!f.open(QIODevice::ReadOnly)) {
+        return false;
+    }
+
+    qint64 filesize = f.size();
+
+    if (filesize > max_load_buffer_size) {
+        qWarning() << "Waveform too big, increase max_load_buffer_size in PRS1Loader sourcecode" <<
+                   filename;
+        return false;
+    }
+
+    if (f.read((char *)m_buffer, filesize) < filesize) {
         qDebug() << "Couldn't read full file" << filename;
         return false;
     }
-    pos=0;
-    bool wasfaulty=false, faulty=false;
-    for (chunk=0;pos<filesize;++chunk, pos+=size) {
-        header=&m_buffer[pos];
-        if (header[0]!=PRS1_MAGIC_NUMBER) {
-            if (chunk==0)
-	    	qDebug() << "Invalid magic number" << filename;
-                return false;
+
+    pos = 0;
+    bool wasfaulty = false, faulty = false;
+
+    for (chunk = 0; pos < filesize; ++chunk, pos += size) {
+        header = &m_buffer[pos];
+
+        if (header[0] != PRS1_MAGIC_NUMBER) {
+            if (chunk == 0) {
+                qDebug() << "Invalid magic number" << filename;
+            }
+
+            return false;
             break;
         }
 
-        size=(header[2] << 8) | header[1];
-        htype=header[3]; // 00 = normal // 01=waveform // could be a bool?
+        size = (header[2] << 8) | header[1];
+        htype = header[3]; // 00 = normal // 01=waveform // could be a bool?
         Q_UNUSED(htype);
-        family=header[4]; // == 5
-        familyVersion=header[5];
-        ext=header[6];
-        sequence=(header[10] << 24) | (header[9] << 16) | (header[8] << 8) | header[7];
-        timestamp=(header[14] << 24) | (header[13] << 16) | (header[12] << 8) | header[11];
+        family = header[4]; // == 5
+        familyVersion = header[5];
+        ext = header[6];
+        sequence = (header[10] << 24) | (header[9] << 16) | (header[8] << 8) | header[7];
+        timestamp = (header[14] << 24) | (header[13] << 16) | (header[12] << 8) | header[11];
 
         qDebug() << "family: " << family << " familyversion: " << familyVersion;
 
-        if (ext==5) {
-            duration=header[0xf] | header[0x10] << 8;    // block duration in seconds
+        if (ext == 5) {
+            duration = header[0xf] | header[0x10] << 8;  // block duration in seconds
             Q_UNUSED(duration);
-            num_signals=header[0x12] | header[0x13] << 8;
-            if (num_signals>2) {
+            num_signals = header[0x12] | header[0x13] << 8;
+
+            if (num_signals > 2) {
                 qWarning() << "More than 2 Waveforms in " << filename;
                 return false;
             }
-            long pos2=0x14+(num_signals-1)*3;
+
+            long pos2 = 0x14 + (num_signals - 1) * 3;
+
             // add the in reverse...
-            for (int i=0;i<num_signals;i++) {
-                interleave=header[pos2] | header[pos2+1] << 8;
-                sample_format=header[pos2+2];
-                whl.push_back(WaveHeaderList(interleave,sample_format));
-                pos2-=3;
+            for (int i = 0; i < num_signals; i++) {
+                interleave = header[pos2] | header[pos2 + 1] << 8;
+                sample_format = header[pos2 + 2];
+                whl.push_back(WaveHeaderList(interleave, sample_format));
+                pos2 -= 3;
             }
-            hl=15+6+(num_signals*3);
 
-        } else hl=16;
+            hl = 15 + 6 + (num_signals * 3);
 
-        wasfaulty=faulty;
-        sum=0;
-        for (int i=0; i<hl-1; i++) sum+=header[i];
-        unsigned char c8=header[hl-1];
-        if (sum!=c8) {
-            if (chunk==0) {
+        } else { hl = 16; }
+
+        wasfaulty = faulty;
+        sum = 0;
+
+        for (int i = 0; i < hl - 1; i++) { sum += header[i]; }
+
+        unsigned char c8 = header[hl - 1];
+
+        if (sum != c8) {
+            if (chunk == 0) {
                 qDebug() << "File" << filename << "has faulty header at" << pos;
-                if ((size>0) && (pos+size<filesize) && (header[size]==2)) {
-                    faulty=true;
+
+                if ((size > 0) && (pos + size < filesize) && (header[size] == 2)) {
+                    faulty = true;
                     continue;
                 }
 
-                return (chunk!=0);
+                return (chunk != 0);
             }
+
             break;
         }
-        datasize=size-hl-2;
 
-        data=&header[hl];
+        datasize = size - hl - 2;
+
+        data = &header[hl];
 
 #ifdef PRS1_CRC_CHECK
-        c16=CRC16(data,datasize);
-        crc=(data[datasize+1] << 8) | data[datasize];
-        if (crc!=c16) {
-            qDebug() << "File" << filename << "failed CRC check at chunk" << chunk << "wanted" << crc << "got" << c16;
-            faulty=true;
+        c16 = CRC16(data, datasize);
+        crc = (data[datasize + 1] << 8) | data[datasize];
+
+        if (crc != c16) {
+            qDebug() << "File" << filename << "failed CRC check at chunk" << chunk << "wanted" << crc << "got"
+                     << c16;
+            faulty = true;
             continue;
         }
+
 #endif
 
         if (wasfaulty) {
@@ -1360,236 +1533,279 @@ bool PRS1Loader::OpenFile(Machine *mach, QString filename)
 
 
         qDebug() << "Loading" << QDir::toNativeSeparators(filename) << sequence << timestamp << size;
+
         //if (ext==0) ParseCompliance(data,size);
-        if (ext<=1) {
-            ParseSummary(mach,sequence,timestamp,data,datasize,family,familyVersion);
-        } else if (ext==2) {
-            if (family==5) {
-               if (!Parse002v5(sequence,timestamp,data,datasize)) {
-                   qDebug() << "in file: " << QDir::toNativeSeparators(filename);
-               }
+        if (ext <= 1) {
+            ParseSummary(mach, sequence, timestamp, data, datasize, family, familyVersion);
+        } else if (ext == 2) {
+            if (family == 5) {
+                if (!Parse002v5(sequence, timestamp, data, datasize)) {
+                    qDebug() << "in file: " << QDir::toNativeSeparators(filename);
+                }
             } else {
-               Parse002(sequence,timestamp,data,datasize, family, familyVersion);
+                Parse002(sequence, timestamp, data, datasize, family, familyVersion);
             }
-        } else if (ext==5) {
+        } else if (ext == 5) {
             //ParseWaveform(mach,sequence,timestamp,data,datasize,duration,num_signals,interleave,sample_format);
         }
     }
+
     return true;
 }
 
 
 bool PRS1Loader::OpenWaveforms(SessionID sid, QString filename)
 {
-    Session * session=new_sessions[sid];
+    Session *session = new_sessions[sid];
     //int sequence,seconds,br,htype,version,numsignals;
     QFile file(filename);
+
     if (!file.open(QIODevice::ReadOnly)) {
         qWarning() << "Couldn't open waveform file" << filename;
         return false;
     }
 
-    int pos,br,size=file.size();
-    if (size>max_load_buffer_size) {
-        qWarning() << "Waveform too big, increase max_load_buffer_size in PRS1Loader sourcecode" << filename;
+    int pos, br, size = file.size();
+
+    if (size > max_load_buffer_size) {
+        qWarning() << "Waveform too big, increase max_load_buffer_size in PRS1Loader sourcecode" <<
+                   filename;
         return false;
     }
 
-    br=file.read((char *)m_buffer,size);
-    if (br<size) {
+    br = file.read((char *)m_buffer, size);
+
+    if (br < size) {
         qWarning() << "Couldn't read waveform data.. Disk error?" << filename;
         return false;
     }
 
     // Look at the initial header and assume this header size for the lot.
-    if ((m_buffer[0]!=2) || (m_buffer[6]!=0x05)) {
+    if ((m_buffer[0] != 2) || (m_buffer[6] != 0x05)) {
         qWarning() << "Not correct waveform format" << filename;
         return false;
     }
+
     //quint8 version=m_buffer[4];
-    quint32 start=m_buffer[0xb] | m_buffer[0xc] << 8 | m_buffer[0xd] << 16 | m_buffer[0x0e] << 24;
+    quint32 start = m_buffer[0xb] | m_buffer[0xc] << 8 | m_buffer[0xd] << 16 | m_buffer[0x0e] << 24;
 
-    session->updateFirst(qint64(start)*1000L);
+    session->updateFirst(qint64(start) * 1000L);
 
-    quint16 num_signals=m_buffer[0x12] | m_buffer[0x13] << 8;
-    if (num_signals>2) {
+    quint16 num_signals = m_buffer[0x12] | m_buffer[0x13] << 8;
+
+    if (num_signals > 2) {
         qWarning() << "More than 2 Waveforms in " << filename;
         return false;
     }
-    pos=0x14+(num_signals-1)*3;
+
+    pos = 0x14 + (num_signals - 1) * 3;
     vector<WaveHeaderList> whl;
+
     // add the in reverse...
-    for (int i=0;i<num_signals;i++) {
-        quint16 interleave=m_buffer[pos] | m_buffer[pos+1] << 8;
-        quint8  sample_format=m_buffer[pos+2];
-        whl.push_back(WaveHeaderList(interleave,sample_format));
-        pos-=3;
+    for (int i = 0; i < num_signals; i++) {
+        quint16 interleave = m_buffer[pos] | m_buffer[pos + 1] << 8;
+        quint8  sample_format = m_buffer[pos + 2];
+        whl.push_back(WaveHeaderList(interleave, sample_format));
+        pos -= 3;
     }
-    int hl=15+5+(num_signals*3);
-    quint16 duration,length=0;
-    quint32 timestamp,lasttimestamp;
+
+    int hl = 15 + 5 + (num_signals * 3);
+    quint16 duration, length = 0;
+    quint32 timestamp, lasttimestamp;
 
 
-    pos=0;
-    int block=0;
-    lasttimestamp=start;
-    duration=0;
-    int corrupt=0;
+    pos = 0;
+    int block = 0;
+    lasttimestamp = start;
+    duration = 0;
+    int corrupt = 0;
     char waveform[2][500000];
     int wlength[2];
     qint64 wdur[2];
+
     //EventList *evl[num_signals];
-    for (int i=0;i<num_signals;i++) {
-        wlength[i]=0;
-        wdur[i]=0;
+    for (int i = 0; i < num_signals; i++) {
+        wlength[i] = 0;
+        wdur[i] = 0;
         //evl[i]=NULL;
 
         //waveform[i].resize(500000);
     }
+
     //SampleFormat *wf[num_signals];
     //EventList *FlowData=EventList(CPAP_FlowRate, EVL_Waveform,1,0,-128,128);
     //EventList *MaskData=EventList(CPAP_MaskPressure, EVL_Waveform,1,0,-128,128);
 
     //QString FlowRate=CPAP_FlowRate;
     //QString MaskPressure="MaskPressure";
-    ChannelID wc[2]={CPAP_FlowRate,CPAP_MaskPressure};
+    ChannelID wc[2] = {CPAP_FlowRate, CPAP_MaskPressure};
+
     do {
-        timestamp=m_buffer[pos+0xb] | m_buffer[pos+0xc] << 8 | m_buffer[pos+0xd] << 16 | m_buffer[pos+0x0e] << 24;
-        register unsigned char sum8=0;
-        for (int i=0;i<hl;i++) sum8+=m_buffer[pos+i];
-        if (m_buffer[pos+hl]!=sum8) {
-            if (block==0) {
+        timestamp = m_buffer[pos + 0xb] | m_buffer[pos + 0xc] << 8 | m_buffer[pos + 0xd] << 16 |
+                    m_buffer[pos + 0x0e] << 24;
+        register unsigned char sum8 = 0;
+
+        for (int i = 0; i < hl; i++) { sum8 += m_buffer[pos + i]; }
+
+        if (m_buffer[pos + hl] != sum8) {
+            if (block == 0) {
                 qDebug() << "Faulty Header Checksum, aborting" << filename;
                 return false;
             }
-            if (++corrupt>3) {
+
+            if (++corrupt > 3) {
                 qDebug() << "3 Faulty Waveform Headers in a row.. Aborting" << filename;
                 return false;
             }
+
             qDebug() << "Faulty Header Checksum, skipping block" << block;
-            pos+=length;
+            pos += length;
             continue;
         } else {
-            int diff=timestamp-(lasttimestamp+duration);
-            if (block==1) {
-                if (diff>0)
-                    start-=diff;
+            int diff = timestamp - (lasttimestamp + duration);
+
+            if (block == 1) {
+                if (diff > 0) {
+                    start -= diff;
+                }
             }
-            length=m_buffer[pos+0x1] | m_buffer[pos+0x2] << 8;      // block length in bytes
-            duration=m_buffer[pos+0xf] | m_buffer[pos+0x10] << 8;    // block duration in seconds
+
+            length = m_buffer[pos + 0x1] | m_buffer[pos + 0x2] << 8; // block length in bytes
+            duration = m_buffer[pos + 0xf] | m_buffer[pos + 0x10] << 8; // block duration in seconds
 
 
-            if (diff<0) {
+            if (diff < 0) {
                 qDebug() << "Padding waveform to keep sync" << block;
+
                 //diff=qAbs(diff);
-                for (int i=0;i<num_signals;i++) {
-                    for (int j=0;j<diff;j++) {
-                        for (int k=0;k<whl[i].interleave;k++)
-                            waveform[i][wlength[i]++]=0;
+                for (int i = 0; i < num_signals; i++) {
+                    for (int j = 0; j < diff; j++) {
+                        for (int k = 0; k < whl[i].interleave; k++) {
+                            waveform[i][wlength[i]++] = 0;
+                        }
                     }
-                    wdur[i]+=diff;
+
+                    wdur[i] += diff;
                 }
 
-            } else
-            if (diff>0 && wlength[0]>0)  {
-                qDebug() << "Timestamp resync" << block << diff << corrupt << duration << timestamp-lasttimestamp << filename;
+            } else if (diff > 0 && wlength[0] > 0)  {
+                qDebug() << "Timestamp resync" << block << diff << corrupt << duration << timestamp - lasttimestamp
+                         << filename;
 
 
-                for (int i=0;i<num_signals;i++) {
-                    double rate=(double(wdur[i])*1000.0)/double(wlength[i]);
+                for (int i = 0; i < num_signals; i++) {
+                    double rate = (double(wdur[i]) * 1000.0) / double(wlength[i]);
                     double gain;
-                    if (i==1) gain=0.1; else gain=1;
-                    EventList *a=session->AddEventList(wc[i],EVL_Waveform,gain,0,0,0,rate);
+
+                    if (i == 1) { gain = 0.1; }
+                    else { gain = 1; }
+
+                    EventList *a = session->AddEventList(wc[i], EVL_Waveform, gain, 0, 0, 0, rate);
+
                     //EventList *a=new EventList(wc[i],EVL_Waveform,gain,0,0,0,rate);
                     //session->machine()->registerChannel(wc[i]);
-                    if (whl[i].sample_format)
-                        a->AddWaveform(qint64(start)*1000L,(unsigned char *)waveform[i],wlength[i],qint64(wdur[i])*1000L);
-                    else {
-                        a->AddWaveform(qint64(start)*1000L,(char *)waveform[i],wlength[i],qint64(wdur[i])*1000L);
+                    if (whl[i].sample_format) {
+                        a->AddWaveform(qint64(start) * 1000L, (unsigned char *)waveform[i], wlength[i],
+                                       qint64(wdur[i]) * 1000L);
+                    } else {
+                        a->AddWaveform(qint64(start) * 1000L, (char *)waveform[i], wlength[i], qint64(wdur[i]) * 1000L);
                     }
-                    if (wc[i]==CPAP_FlowRate) {
+
+                    if (wc[i] == CPAP_FlowRate) {
                         a->setMax(120);
                         a->setMin(-120);
-                    } else if (wc[i]==CPAP_MaskPressure) {
-//                       int v=ceil(a->Max()/5);
-//                        a->setMax(v*5);
-//                        v=floor(a->Min()/5);
-//                        a->setMin(v*5);
+                    } else if (wc[i] == CPAP_MaskPressure) {
+                        //                       int v=ceil(a->Max()/5);
+                        //                        a->setMax(v*5);
+                        //                        v=floor(a->Min()/5);
+                        //                        a->setMin(v*5);
                     }
 
-                    session->updateLast(start+(qint64(wdur[i])*1000L));
-                    wlength[i]=0;
-                    wdur[i]=0;
+                    session->updateLast(start + (qint64(wdur[i]) * 1000L));
+                    wlength[i] = 0;
+                    wdur[i] = 0;
                 }
-                start=timestamp;
-                corrupt=0;
+
+                start = timestamp;
+                corrupt = 0;
             }
         }
 
-        pos+=hl+1;
+        pos += hl + 1;
+
         //qDebug() <<  (duration*num_signals*whl[0].interleave) << duration;
-        if (num_signals==1) { // no interleave.. this is much quicker.
-            int bs=duration*whl[0].interleave;
-            memcpy((char *)&(waveform[0])[wlength[0]],(char *)&m_buffer[pos],bs);
+        if (num_signals == 1) { // no interleave.. this is much quicker.
+            int bs = duration * whl[0].interleave;
+            memcpy((char *) & (waveform[0])[wlength[0]], (char *)&m_buffer[pos], bs);
 
-            wlength[0]+=bs;
+            wlength[0] += bs;
 
-            pos+=bs;
+            pos += bs;
         } else {
-            for (int i=0;i<duration;i++) {
-                for (int s=0;s<num_signals;s++) {
-                    memcpy((char *)&(waveform[s])[wlength[s]],(char *)&m_buffer[pos],whl[s].interleave);
-                    wlength[s]+=whl[s].interleave;
-                    pos+=whl[s].interleave;
+            for (int i = 0; i < duration; i++) {
+                for (int s = 0; s < num_signals; s++) {
+                    memcpy((char *) & (waveform[s])[wlength[s]], (char *)&m_buffer[pos], whl[s].interleave);
+                    wlength[s] += whl[s].interleave;
+                    pos += whl[s].interleave;
                 }
             }
         }
-        for (int i=0;i<num_signals;i++) wdur[i]+=duration;
-        pos+=2;
+
+        for (int i = 0; i < num_signals; i++) { wdur[i] += duration; }
+
+        pos += 2;
         block++;
-        lasttimestamp=timestamp;
-    } while (pos<size);
+        lasttimestamp = timestamp;
+    } while (pos < size);
 
-    for (int i=0;i<num_signals;i++) {
-        double rate=(double(wdur[i])*1000.0)/double(wlength[i]);
+    for (int i = 0; i < num_signals; i++) {
+        double rate = (double(wdur[i]) * 1000.0) / double(wlength[i]);
         double gain;
-        if (i==1) gain=0.1; else gain=1;
-        EventList *a=session->AddEventList(wc[i],EVL_Waveform,gain,0,0,0,rate);
 
-        if (whl[i].sample_format)
-            a->AddWaveform(qint64(start)*1000L,(unsigned char *)waveform[i],wlength[i],qint64(wdur[i])*1000L);
-        else {
-            a->AddWaveform(qint64(start)*1000L,(char *)waveform[i],wlength[i],qint64(wdur[i])*1000L);
+        if (i == 1) { gain = 0.1; }
+        else { gain = 1; }
+
+        EventList *a = session->AddEventList(wc[i], EVL_Waveform, gain, 0, 0, 0, rate);
+
+        if (whl[i].sample_format) {
+            a->AddWaveform(qint64(start) * 1000L, (unsigned char *)waveform[i], wlength[i],
+                           qint64(wdur[i]) * 1000L);
+        } else {
+            a->AddWaveform(qint64(start) * 1000L, (char *)waveform[i], wlength[i], qint64(wdur[i]) * 1000L);
         }
-        if (wc[i]==CPAP_FlowRate) {
+
+        if (wc[i] == CPAP_FlowRate) {
             a->setMax(120);
             a->setMin(-120);
-        } else if (wc[i]==CPAP_MaskPressure) {
+        } else if (wc[i] == CPAP_MaskPressure) {
         }
-        session->updateLast(start+qint64(wdur[i])*1000L);
+
+        session->updateLast(start + qint64(wdur[i]) * 1000L);
     }
+
     // lousy family 5 check to see if already has RespRate
     return true;
 }
 
 void InitModelMap()
 {
-    ModelMap[0x34]="RemStar Pro with C-Flex+";
-    ModelMap[0x35]="RemStar Auto with A-Flex";
-    ModelMap[0x36]="RemStar BiPAP Pro with Bi-Flex";
-    ModelMap[0x37]="RemStar BiPAP Auto with Bi-Flex";
-    ModelMap[0x38]="RemStar Plus :(";
-    ModelMap[0x41]="BiPAP autoSV Advanced";
+    ModelMap[0x34] = "RemStar Pro with C-Flex+";
+    ModelMap[0x35] = "RemStar Auto with A-Flex";
+    ModelMap[0x36] = "RemStar BiPAP Pro with Bi-Flex";
+    ModelMap[0x37] = "RemStar BiPAP Auto with Bi-Flex";
+    ModelMap[0x38] = "RemStar Plus :(";
+    ModelMap[0x41] = "BiPAP autoSV Advanced";
 }
 
-bool initialized=false;
+bool initialized = false;
 void PRS1Loader::Register()
 {
-    if (initialized) return;
+    if (initialized) { return; }
+
     qDebug() << "Registering PRS1Loader";
     RegisterLoader(new PRS1Loader());
     InitModelMap();
-    initialized=true;
+    initialized = true;
 }
 
 
diff --git a/sleepyhead/SleepLib/loader_plugins/prs1_loader.h b/sleepyhead/SleepLib/loader_plugins/prs1_loader.h
index f0f666ce..aebb215b 100644
--- a/sleepyhead/SleepLib/loader_plugins/prs1_loader.h
+++ b/sleepyhead/SleepLib/loader_plugins/prs1_loader.h
@@ -23,57 +23,57 @@
 //********************************************************************************************
 // Please INCREMENT the following value when making changes to this loaders implementation.
 //
-const int prs1_data_version=10;
+const int prs1_data_version = 10;
 //
 //********************************************************************************************
 
 /*! \class PRS1
     \brief PRS1 customized machine object (via CPAP)
     */
-class PRS1:public CPAP
+class PRS1: public CPAP
 {
-public:
-    PRS1(Profile *p,MachineID id=0);
+  public:
+    PRS1(Profile *p, MachineID id = 0);
     virtual ~PRS1();
 };
 
 
-const int max_load_buffer_size=1024*1024;
+const int max_load_buffer_size = 1024 * 1024;
 
 
-const QString prs1_class_name=STR_MACH_PRS1;
+const QString prs1_class_name = STR_MACH_PRS1;
 
 /*! \class PRS1Loader
     \brief Philips Respironics System One Loader Module
     */
 class PRS1Loader : public MachineLoader
 {
-public:
+  public:
     PRS1Loader();
     virtual ~PRS1Loader();
     //! \brief Scans directory path for valid PRS1 signature
-    virtual int Open(QString & path,Profile *profile);
+    virtual int Open(QString &path, Profile *profile);
 
     //! \brief Returns the database version of this loader
     virtual int Version() { return prs1_data_version; }
 
     //! \brief Return the ClassName, in this case "PRS1"
-    virtual const QString & ClassName() { return prs1_class_name; }
+    virtual const QString &ClassName() { return prs1_class_name; }
 
     //! \brief Create a new PRS1 machine record, indexed by Serial number.
-    Machine *CreateMachine(QString serial,Profile *profile);
+    Machine *CreateMachine(QString serial, Profile *profile);
 
     //! \brief Register this Module to the list of Loaders, so it knows to search for PRS1 data.
     static void Register();
-protected:
+  protected:
     QString last;
-    QHash<QString,Machine *> PRS1List;
+    QHash<QString, Machine *> PRS1List;
 
     //! \brief Opens the SD folder structure for this machine, scans for data files and imports any new sessions
-    int OpenMachine(Machine *m,QString path,Profile *profile);
+    int OpenMachine(Machine *m, QString path, Profile *profile);
 
     //! \brief Parses "properties.txt" file containing machine information
-    bool ParseProperties(Machine *m,QString filename);
+    bool ParseProperties(Machine *m, QString filename);
 
     //bool OpenSummary(Session *session,QString filename);
     //bool OpenEvents(Session *session,QString filename);
@@ -85,10 +85,12 @@ protected:
     //bool ParseWaveform(qint32 sequence, quint32 timestamp, unsigned char *data, quint16 size, quint16 duration, quint16 num_signals, quint16 interleave, quint8 sample_format);
 
     //! \brief Parse a data chunk from the .000 (brick) and .001 (summary) files.
-    bool ParseSummary(Machine *mach, qint32 sequence, quint32 timestamp, unsigned char *data, quint16 size, int family, int familyVersion);
+    bool ParseSummary(Machine *mach, qint32 sequence, quint32 timestamp, unsigned char *data,
+                      quint16 size, int family, int familyVersion);
 
     //! \brief Parse a single data chunk from a .002 file containing event data for a standard system one machine
-    bool Parse002(qint32 sequence, quint32 timestamp, unsigned char *data, quint16 size, int family, int familyVersion);
+    bool Parse002(qint32 sequence, quint32 timestamp, unsigned char *data, quint16 size, int family,
+                  int familyVersion);
 
     //! \brief Parse a single data chunk from a .002 file containing event data for a family 5 ASV machine (which has a different format)
     bool Parse002v5(qint32 sequence, quint32 timestamp, unsigned char *data, quint16 size);
@@ -98,7 +100,7 @@ protected:
 
     //bool Parse002(Session *session,unsigned char *buffer,int size,qint64 timestamp,long fpos);
     //bool Parse002ASV(Session *session,unsigned char *buffer,int size,qint64 timestamp,long fpos);
-    unsigned char * m_buffer;
+    unsigned char *m_buffer;
     QHash<SessionID, Session *> extra_session;
 
     //! \brief PRS1 Data files can store multiple sessions, so store them in this list for later processing.
diff --git a/sleepyhead/SleepLib/loader_plugins/resmed_loader.cpp b/sleepyhead/SleepLib/loader_plugins/resmed_loader.cpp
index 60f5802d..60baf058 100644
--- a/sleepyhead/SleepLib/loader_plugins/resmed_loader.cpp
+++ b/sleepyhead/SleepLib/loader_plugins/resmed_loader.cpp
@@ -28,59 +28,68 @@
 #endif
 
 extern QProgressBar *qprogress;
-QHash<int,QString> RMS9ModelMap;
+QHash<int, QString> RMS9ModelMap;
 QHash<ChannelID, QVector<QString> > resmed_codes;
 
-const QString STR_ext_TGT="tgt";
-const QString STR_ext_CRC="crc";
-const QString STR_ext_EDF="edf";
-const QString STR_ext_gz=".gz";
+const QString STR_ext_TGT = "tgt";
+const QString STR_ext_CRC = "crc";
+const QString STR_ext_EDF = "edf";
+const QString STR_ext_gz = ".gz";
 
 
 // Looks up foreign language Signal names that match this channelID
-EDFSignal * EDFParser::lookupSignal(ChannelID ch)
+EDFSignal *EDFParser::lookupSignal(ChannelID ch)
 {
     QHash<ChannelID, QVector<QString> >::iterator ci;
-    QHash<QString,EDFSignal *>::iterator jj;
-    ci=resmed_codes.find(ch);
+    QHash<QString, EDFSignal *>::iterator jj;
+    ci = resmed_codes.find(ch);
 
-    if (ci==resmed_codes.end())
+    if (ci == resmed_codes.end()) {
         return NULL;
+    }
 
-    for (int i=0;i<ci.value().size();i++) {
-        jj=lookup.find(ci.value()[i]);
-        if (jj==lookup.end())
+    for (int i = 0; i < ci.value().size(); i++) {
+        jj = lookup.find(ci.value()[i]);
+
+        if (jj == lookup.end()) {
             continue;
+        }
+
         return jj.value();
     }
 
     return NULL;
 }
 
-EDFSignal * EDFParser::lookupName(QString name)
+EDFSignal *EDFParser::lookupName(QString name)
 {
-    QHash<QString,EDFSignal *>::iterator i=lookup.find(name);
-    if (i!=lookup.end()) return i.value();
+    QHash<QString, EDFSignal *>::iterator i = lookup.find(name);
+
+    if (i != lookup.end()) { return i.value(); }
+
     return NULL;
 }
 
 EDFParser::EDFParser(QString name)
 {
-    buffer=NULL;
+    buffer = NULL;
     Open(name);
 }
 EDFParser::~EDFParser()
 {
     QVector<EDFSignal>::iterator s;
-    for (s=edfsignals.begin();s!=edfsignals.end();s++) {
-        if ((*s).data) delete [] (*s).data;
+
+    for (s = edfsignals.begin(); s != edfsignals.end(); s++) {
+        if ((*s).data) { delete [](*s).data; }
     }
-    if (buffer) delete [] buffer;
+
+    if (buffer) { delete [] buffer; }
 }
 qint16 EDFParser::Read16()
 {
-    if ((pos + long(sizeof(qint16))) > filesize)
+    if ((pos + long(sizeof(qint16))) > filesize) {
         return 0;
+    }
 
     qint16 res = *(qint16 *)&buffer[pos];
     pos += sizeof(qint16);
@@ -88,27 +97,32 @@ qint16 EDFParser::Read16()
 }
 QString EDFParser::Read(unsigned n)
 {
-    if ((pos + n) > filesize)
+    if ((pos + n) > filesize) {
         return "";
+    }
 
     QString str;
+
     for (unsigned i = 0; i < n; i++) {
         str += buffer[pos++];
     }
+
     return str.trimmed();
 }
 bool EDFParser::Parse()
 {
     bool ok;
-    QString temp,temp2;
+    QString temp, temp2;
 
-    version=QString::fromLatin1(header.version,8).toLong(&ok);
-    if (!ok)
+    version = QString::fromLatin1(header.version, 8).toLong(&ok);
+
+    if (!ok) {
         return false;
+    }
 
     //patientident=QString::fromLatin1(header.patientident,80);
-    recordingident=QString::fromLatin1(header.recordingident,80); // Serial number is in here..
-    int snp=recordingident.indexOf("SRN=");
+    recordingident = QString::fromLatin1(header.recordingident, 80); // Serial number is in here..
+    int snp = recordingident.indexOf("SRN=");
     serialnumber.clear();
     /*char * idx=index(header.recordingident,'=');
     idx++;
@@ -118,46 +132,63 @@ bool EDFParser::Parse()
         ++idx;
     } */
 
-    for (int i=snp+4;i<recordingident.length();i++) {
-        if (recordingident[i]==' ')
+    for (int i = snp + 4; i < recordingident.length(); i++) {
+        if (recordingident[i] == ' ') {
             break;
-        serialnumber+=recordingident[i];
+        }
+
+        serialnumber += recordingident[i];
     }
-    QDateTime startDate=QDateTime::fromString(QString::fromLatin1(header.datetime,16),"dd.MM.yyHH.mm.ss");
+
+    QDateTime startDate = QDateTime::fromString(QString::fromLatin1(header.datetime, 16),
+                          "dd.MM.yyHH.mm.ss");
     //startDate.toTimeSpec(Qt::UTC);
 
-    QDate d2=startDate.date();
-    if (d2.year()<2000) {
-        d2.setDate(d2.year()+100,d2.month(),d2.day());
+    QDate d2 = startDate.date();
+
+    if (d2.year() < 2000) {
+        d2.setDate(d2.year() + 100, d2.month(), d2.day());
         startDate.setDate(d2);
     }
+
     if (!startDate.isValid()) {
         qDebug() << "Invalid date time retreieved parsing EDF File " << filename;
         return false;
     }
-    startdate=qint64(startDate.toTime_t())*1000L;
+
+    startdate = qint64(startDate.toTime_t()) * 1000L;
     //startdate-=timezoneOffset();
 
     //qDebug() << startDate.toString("yyyy-MM-dd HH:mm:ss");
 
-    num_header_bytes=QString::fromLatin1(header.num_header_bytes,8).toLong(&ok);
-    if (!ok)
+    num_header_bytes = QString::fromLatin1(header.num_header_bytes, 8).toLong(&ok);
+
+    if (!ok) {
         return false;
+    }
+
     //reserved44=QString::fromLatin1(header.reserved,44);
-    num_data_records=QString::fromLatin1(header.num_data_records,8).toLong(&ok);
-    if (!ok)
-        return false;
+    num_data_records = QString::fromLatin1(header.num_data_records, 8).toLong(&ok);
 
-    dur_data_record=QString::fromLatin1(header.dur_data_records,8).toDouble(&ok)*1000.0;
-    if (!ok)
-        return false;
-    num_signals=QString::fromLatin1(header.num_signals,4).toLong(&ok);
-    if (!ok)
+    if (!ok) {
         return false;
+    }
 
-    enddate=startdate+dur_data_record*qint64(num_data_records);
-   // if (dur_data_record==0)
-     //   return false;
+    dur_data_record = QString::fromLatin1(header.dur_data_records, 8).toDouble(&ok) * 1000.0;
+
+    if (!ok) {
+        return false;
+    }
+
+    num_signals = QString::fromLatin1(header.num_signals, 4).toLong(&ok);
+
+    if (!ok) {
+        return false;
+    }
+
+    enddate = startdate + dur_data_record * qint64(num_data_records);
+    // if (dur_data_record==0)
+    //   return false;
 
     // this could be loaded quicker by transducer_type[signal] etc..
 
@@ -171,41 +202,50 @@ bool EDFParser::Parse()
         lookup[signal.label] = &signal; // Safe: edfsignals won't move.
     }
 
-    for (int i=0;i<num_signals;i++) edfsignals[i].transducer_type=Read(80);
+    for (int i = 0; i < num_signals; i++) { edfsignals[i].transducer_type = Read(80); }
 
-    for (int i=0;i<num_signals;i++) edfsignals[i].physical_dimension=Read(8);
-    for (int i=0;i<num_signals;i++) edfsignals[i].physical_minimum=Read(8).toDouble(&ok);
-    for (int i=0;i<num_signals;i++) edfsignals[i].physical_maximum=Read(8).toDouble(&ok);
-    for (int i=0;i<num_signals;i++) edfsignals[i].digital_minimum=Read(8).toDouble(&ok);
-    for (int i=0;i<num_signals;i++) {
+    for (int i = 0; i < num_signals; i++) { edfsignals[i].physical_dimension = Read(8); }
+
+    for (int i = 0; i < num_signals; i++) { edfsignals[i].physical_minimum = Read(8).toDouble(&ok); }
+
+    for (int i = 0; i < num_signals; i++) { edfsignals[i].physical_maximum = Read(8).toDouble(&ok); }
+
+    for (int i = 0; i < num_signals; i++) { edfsignals[i].digital_minimum = Read(8).toDouble(&ok); }
+
+    for (int i = 0; i < num_signals; i++) {
         EDFSignal &e = edfsignals[i];
-        e.digital_maximum=Read(8).toDouble(&ok);
-        e.gain=(e.physical_maximum-e.physical_minimum)/(e.digital_maximum-e.digital_minimum);
-        e.offset=0;
+        e.digital_maximum = Read(8).toDouble(&ok);
+        e.gain = (e.physical_maximum - e.physical_minimum) / (e.digital_maximum - e.digital_minimum);
+        e.offset = 0;
     }
 
-    for (int i=0;i<num_signals;i++) edfsignals[i].prefiltering=Read(80);
-    for (int i=0;i<num_signals;i++) edfsignals[i].nr=Read(8).toLong(&ok);
-    for (int i=0;i<num_signals;i++) edfsignals[i].reserved=Read(32);
+    for (int i = 0; i < num_signals; i++) { edfsignals[i].prefiltering = Read(80); }
+
+    for (int i = 0; i < num_signals; i++) { edfsignals[i].nr = Read(8).toLong(&ok); }
+
+    for (int i = 0; i < num_signals; i++) { edfsignals[i].reserved = Read(32); }
 
     // allocate the buffers
-    for (int i=0;i<num_signals;i++) {
+    for (int i = 0; i < num_signals; i++) {
         //qDebug//cout << "Reading signal " << signals[i]->label << endl;
         EDFSignal &sig = edfsignals[i];
 
-        long recs=sig.nr * num_data_records;
-        if (num_data_records<0)
+        long recs = sig.nr * num_data_records;
+
+        if (num_data_records < 0) {
             return false;
-        sig.data=new qint16 [recs];
-        sig.pos=0;
+        }
+
+        sig.data = new qint16 [recs];
+        sig.pos = 0;
     }
 
-    for (int x=0;x<num_data_records;x++) {
-        for (int i=0;i<num_signals;i++) {
+    for (int x = 0; x < num_data_records; x++) {
+        for (int i = 0; i < num_signals; i++) {
             EDFSignal &sig = edfsignals[i];
-            memcpy((char *)&sig.data[sig.pos],(char *)&buffer[pos],sig.nr*2);
-            sig.pos+=sig.nr;
-            pos+=sig.nr*2;
+            memcpy((char *)&sig.data[sig.pos], (char *)&buffer[pos], sig.nr * 2);
+            sig.pos += sig.nr;
+            pos += sig.nr * 2;
             // big endian will probably screw up without this..
             /*for (int j=0;j<sig.nr;j++) {
                 qint16 t=Read16();
@@ -222,42 +262,51 @@ bool EDFParser::Open(QString name)
     //Urk.. This needs fixing for VC++, as it doesn't have packed attribute type..
 
     if (name.endsWith(STR_ext_gz)) {
-        filename=name.mid(0,-3);
+        filename = name.mid(0, -3);
         QFile fi(name);
         fi.open(QFile::ReadOnly);
-        fi.seek(fi.size()-4);
+        fi.seek(fi.size() - 4);
         unsigned char ch[4];
-        fi.read((char *)ch,4);
-        filesize=ch[0] | (ch [1] << 8) | (ch[2] << 16) | (ch[3] << 24);
-        datasize=filesize-EDFHeaderSize;
-        if (datasize<0) return false;
+        fi.read((char *)ch, 4);
+        filesize = ch[0] | (ch [1] << 8) | (ch[2] << 16) | (ch[3] << 24);
+        datasize = filesize - EDFHeaderSize;
+
+        if (datasize < 0) { return false; }
+
         qDebug() << "Size of" << name << "uncompressed=" << filesize;
-        gzFile f=gzopen(name.toLatin1(),"rb");
+        gzFile f = gzopen(name.toLatin1(), "rb");
+
         if (!f) {
             qDebug() << "EDFParser::Open() Couldn't open file" << name;
             return false;
         }
-        gzread(f,(char *)&header,EDFHeaderSize);
-        buffer=new char [datasize];
+
+        gzread(f, (char *)&header, EDFHeaderSize);
+        buffer = new char [datasize];
         //gzbuffer(f,65536*2);
-        gzread(f,buffer,datasize);
+        gzread(f, buffer, datasize);
         gzclose(f);
     } else {
         QFile f(name);
-        if (!f.open(QIODevice::ReadOnly))
-            return false;
-        filename=name;
-        filesize=f.size();
-        datasize=filesize-EDFHeaderSize;
-        if (datasize<0) return false;
 
-        f.read((char *)&header,EDFHeaderSize);
+        if (!f.open(QIODevice::ReadOnly)) {
+            return false;
+        }
+
+        filename = name;
+        filesize = f.size();
+        datasize = filesize - EDFHeaderSize;
+
+        if (datasize < 0) { return false; }
+
+        f.read((char *)&header, EDFHeaderSize);
         //qDebug() << "Opening " << name;
-        buffer=new char [datasize];
-        f.read(buffer,datasize);
+        buffer = new char [datasize];
+        f.read(buffer, datasize);
         f.close();
     }
-    pos=0;
+
+    pos = 0;
     return true;
 }
 
@@ -268,108 +317,121 @@ ResmedLoader::~ResmedLoader()
 {
 }
 
-Machine *ResmedLoader::CreateMachine(QString serial,Profile *profile)
+Machine *ResmedLoader::CreateMachine(QString serial, Profile *profile)
 {
-    if (!profile) return NULL;
-    QList<Machine *> ml=profile->GetMachines(MT_CPAP);
-    bool found=false;
+    if (!profile) { return NULL; }
+
+    QList<Machine *> ml = profile->GetMachines(MT_CPAP);
+    bool found = false;
     QList<Machine *>::iterator i;
-    Machine *m=NULL;
-    for (i=ml.begin(); i!=ml.end(); i++) {
-        if (((*i)->GetClass()==resmed_class_name) && ((*i)->properties[STR_PROP_Serial]==serial)) {
-            ResmedList[serial]=*i; //static_cast<CPAP *>(*i);
-            found=true;
-            m=*i;
+    Machine *m = NULL;
+
+    for (i = ml.begin(); i != ml.end(); i++) {
+        if (((*i)->GetClass() == resmed_class_name) && ((*i)->properties[STR_PROP_Serial] == serial)) {
+            ResmedList[serial] = *i; //static_cast<CPAP *>(*i);
+            found = true;
+            m = *i;
             break;
         }
     }
+
     if (!found) {
-        m=new CPAP(profile,0);
+        m = new CPAP(profile, 0);
     }
 
-    m->properties[STR_PROP_Brand]=STR_MACH_ResMed;
-    m->properties[STR_PROP_Series]="S9";
-    if (found)
+    m->properties[STR_PROP_Brand] = STR_MACH_ResMed;
+    m->properties[STR_PROP_Series] = "S9";
+
+    if (found) {
         return m;
+    }
 
     qDebug() << "Create ResMed Machine" << serial;
     m->SetClass(resmed_class_name);
 
-    ResmedList[serial]=m;
+    ResmedList[serial] = m;
     profile->AddMachine(m);
 
-    m->properties[STR_PROP_Serial]=serial;
-    m->properties[STR_PROP_DataVersion]=QString::number(resmed_data_version);
+    m->properties[STR_PROP_Serial] = serial;
+    m->properties[STR_PROP_DataVersion] = QString::number(resmed_data_version);
 
-    QString path="{"+STR_GEN_DataFolder+"}/"+m->GetClass()+"_"+serial+"/";
-    m->properties[STR_PROP_Path]=path;
-    m->properties[STR_PROP_BackupPath]=path+"Backup/";
+    QString path = "{" + STR_GEN_DataFolder + "}/" + m->GetClass() + "_" + serial + "/";
+    m->properties[STR_PROP_Path] = path;
+    m->properties[STR_PROP_BackupPath] = path + "Backup/";
 
     return m;
 }
 
-long event_cnt=0;
+long event_cnt = 0;
 
-const QString RMS9_STR_datalog="DATALOG";
-const QString RMS9_STR_idfile="Identification.";
-const QString RMS9_STR_strfile="STR.";
+const QString RMS9_STR_datalog = "DATALOG";
+const QString RMS9_STR_idfile = "Identification.";
+const QString RMS9_STR_strfile = "STR.";
 
 
-int ResmedLoader::Open(QString & path,Profile *profile)
+int ResmedLoader::Open(QString &path, Profile *profile)
 {
 
     QString serial;                 // Serial number
-    QString key,value;
+    QString key, value;
     QString line;
     QString newpath;
     QString filename;
 
-    QHash<QString,QString> idmap;   // Temporary properties hash
+    QHash<QString, QString> idmap;  // Temporary properties hash
 
-    path=path.replace("\\","/");
+    path = path.replace("\\", "/");
 
     // Strip off end "/" if any
-    if (path.endsWith("/"))
-        path=path.section("/",0,-2);
+    if (path.endsWith("/")) {
+        path = path.section("/", 0, -2);
+    }
 
     // Strip off DATALOG from path, and set newpath to the path contianing DATALOG
     if (path.endsWith(RMS9_STR_datalog)) {
-        newpath=path+"/";
-        path=path.section("/",0,-2);
+        newpath = path + "/";
+        path = path.section("/", 0, -2);
     } else {
-        newpath=path+"/"+RMS9_STR_datalog+"/";
+        newpath = path + "/" + RMS9_STR_datalog + "/";
     }
 
     // Add separator back
-    path+="/";
+    path += "/";
 
     // Check DATALOG folder exists and is readable
-    if (!QDir().exists(newpath))
+    if (!QDir().exists(newpath)) {
         return 0;
+    }
 
     ///////////////////////////////////////////////////////////////////////////////////
     // Parse Identification.tgt file (containing serial number and machine information)
     ///////////////////////////////////////////////////////////////////////////////////
-    filename=path+RMS9_STR_idfile+STR_ext_TGT;
+    filename = path + RMS9_STR_idfile + STR_ext_TGT;
     QFile f(filename);
+
     // Abort if this file is dodgy..
-    if (!f.exists() || !f.open(QIODevice::ReadOnly))
+    if (!f.exists() || !f.open(QIODevice::ReadOnly)) {
         return 0;
+    }
 
     // Parse # entries into idmap.
     while (!f.atEnd()) {
-        line=f.readLine().trimmed();
+        line = f.readLine().trimmed();
+
         if (!line.isEmpty()) {
-            key=line.section(" ",0,0);
-            value=line.section(" ",1);
-            key=key.section("#",1);
-            if (key=="SRN") {
-                key=STR_PROP_Serial;
-                serial=value;
+            key = line.section(" ", 0, 0);
+            value = line.section(" ", 1);
+            key = key.section("#", 1);
+
+            if (key == "SRN") {
+                key = STR_PROP_Serial;
+                serial = value;
             }
-            idmap[key]=value;
+
+            idmap[key] = value;
         }
     }
+
     f.close();
 
     // Abort if no serial number
@@ -379,11 +441,13 @@ int ResmedLoader::Open(QString & path,Profile *profile)
     }
 
     // Early check for STR.edf file, so we can early exit before creating faulty machine record.
-    QString strpath=path+RMS9_STR_strfile+STR_ext_EDF;  // STR.edf file
+    QString strpath = path + RMS9_STR_strfile + STR_ext_EDF; // STR.edf file
     f.setFileName(strpath);
+
     if (!f.exists()) { // No STR.edf.. Do we have a STR.edf.gz?
-        strpath+=STR_ext_gz;
+        strpath += STR_ext_gz;
         f.setFileName(strpath);
+
         if (!f.exists()) {
             qDebug() << "Missing STR.edf file";
             return 0;
@@ -393,31 +457,36 @@ int ResmedLoader::Open(QString & path,Profile *profile)
     ///////////////////////////////////////////////////////////////////////////////////
     // Create machine object (unless it's already registered)
     ///////////////////////////////////////////////////////////////////////////////////
-    Machine *m=CreateMachine(serial,profile);
+    Machine *m = CreateMachine(serial, profile);
 
-    bool create_backups=PROFILE.session->backupCardData();
-    bool compress_backups=PROFILE.session->compressBackupData();
+    bool create_backups = PROFILE.session->backupCardData();
+    bool compress_backups = PROFILE.session->compressBackupData();
 
-    QString backup_path=PROFILE.Get(m->properties[STR_PROP_BackupPath]);
-    if (backup_path.isEmpty())
-        backup_path=PROFILE.Get(m->properties[STR_PROP_Path])+"Backup/";
+    QString backup_path = PROFILE.Get(m->properties[STR_PROP_BackupPath]);
 
-    if (path==backup_path) {
-        create_backups=false;
+    if (backup_path.isEmpty()) {
+        backup_path = PROFILE.Get(m->properties[STR_PROP_Path]) + "Backup/";
+    }
+
+    if (path == backup_path) {
+        create_backups = false;
     }
 
     ///////////////////////////////////////////////////////////////////////////////////
     // Parse the idmap into machine objects properties, (overwriting any old values)
     ///////////////////////////////////////////////////////////////////////////////////
-    for (QHash<QString,QString>::iterator i=idmap.begin();i!=idmap.end();i++) {
-        m->properties[i.key()]=i.value();
+    for (QHash<QString, QString>::iterator i = idmap.begin(); i != idmap.end(); i++) {
+        m->properties[i.key()] = i.value();
 
-        if (i.key()=="PCD") { // Lookup Product Code for real model string
+        if (i.key() == "PCD") { // Lookup Product Code for real model string
             bool ok;
-            int j=i.value().toInt(&ok);
-            if (ok)
-                m->properties[STR_PROP_Model]=RMS9ModelMap[j];
-            m->properties[STR_PROP_ModelNumber]=i.value();
+            int j = i.value().toInt(&ok);
+
+            if (ok) {
+                m->properties[STR_PROP_Model] = RMS9ModelMap[j];
+            }
+
+            m->properties[STR_PROP_ModelNumber] = i.value();
         }
     }
 
@@ -425,11 +494,13 @@ int ResmedLoader::Open(QString & path,Profile *profile)
     // Open and Parse STR.edf file
     ///////////////////////////////////////////////////////////////////////////////////
     EDFParser stredf(strpath);
+
     if (!stredf.Parse()) {
         qDebug() << "Faulty file" << RMS9_STR_strfile;
         return 0;
     }
-    if (stredf.serialnumber!=serial) {
+
+    if (stredf.serialnumber != serial) {
         qDebug() << "Identification.tgt Serial number doesn't match STR.edf!";
     }
 
@@ -444,68 +515,71 @@ int ResmedLoader::Open(QString & path,Profile *profile)
     ///////////////////////////////////////////////////////////////////////////////////
     if (create_backups) {
         if (!dir.exists(backup_path)) {
-            if (!dir.mkpath(backup_path+RMS9_STR_datalog)) {
+            if (!dir.mkpath(backup_path + RMS9_STR_datalog)) {
                 qDebug() << "Could not create S9 backup directory :-/";
             }
         }
 
         // Copy Identification files to backup folder
-        QFile::copy(path+RMS9_STR_idfile+STR_ext_TGT,backup_path+RMS9_STR_idfile+STR_ext_TGT);
-        QFile::copy(path+RMS9_STR_idfile+STR_ext_CRC,backup_path+RMS9_STR_idfile+STR_ext_CRC);
+        QFile::copy(path + RMS9_STR_idfile + STR_ext_TGT, backup_path + RMS9_STR_idfile + STR_ext_TGT);
+        QFile::copy(path + RMS9_STR_idfile + STR_ext_CRC, backup_path + RMS9_STR_idfile + STR_ext_CRC);
 
-        QDateTime dts=QDateTime::fromMSecsSinceEpoch(stredf.startdate);
-        dir.mkpath(backup_path+"STR_Backup");
-        QString strmonthly=backup_path+"STR_Backup/STR-"+dts.toString("yyyyMM")+"."+STR_ext_EDF;
+        QDateTime dts = QDateTime::fromMSecsSinceEpoch(stredf.startdate);
+        dir.mkpath(backup_path + "STR_Backup");
+        QString strmonthly = backup_path + "STR_Backup/STR-" + dts.toString("yyyyMM") + "." + STR_ext_EDF;
 
         //copy STR files to backup folder
         if (strpath.endsWith(STR_ext_gz)) { // Already compressed. Don't bother decompressing..
-            QFile::copy(strpath,backup_path+RMS9_STR_strfile+STR_ext_EDF+STR_ext_gz);
+            QFile::copy(strpath, backup_path + RMS9_STR_strfile + STR_ext_EDF + STR_ext_gz);
         } else { // Compress STR file to backup folder
-            QString strf=backup_path+RMS9_STR_strfile+STR_ext_EDF;
+            QString strf = backup_path + RMS9_STR_strfile + STR_ext_EDF;
 
             // Copy most recent to STR.edf
-            if (QFile::exists(strf))
+            if (QFile::exists(strf)) {
                 QFile::remove(strf);
+            }
 
-            if (QFile::exists(strf+STR_ext_gz))
-                QFile::remove(strf+STR_ext_gz);
+            if (QFile::exists(strf + STR_ext_gz)) {
+                QFile::remove(strf + STR_ext_gz);
+            }
 
             compress_backups ?
-                compressFile(strpath,strf)
+            compressFile(strpath, strf)
             :
-                QFile::copy(strpath,strf);
+            QFile::copy(strpath, strf);
 
         }
+
         // Keep one STR.edf backup every month
-        if (!QFile::exists(strmonthly) && !QFile::exists(strmonthly+".gz")) {
+        if (!QFile::exists(strmonthly) && !QFile::exists(strmonthly + ".gz")) {
             compress_backups ?
-                compressFile(strpath,strmonthly)
+            compressFile(strpath, strmonthly)
             :
-                QFile::copy(strpath,strmonthly);
+            QFile::copy(strpath, strmonthly);
         }
 
         // Meh.. these can be calculated if ever needed for ResScan SDcard export
-        QFile::copy(path+"STR.crc",backup_path+"STR.crc");
+        QFile::copy(path + "STR.crc", backup_path + "STR.crc");
     }
 
     ///////////////////////////////////////////////////////////////////////////////////
     // Process the actual STR.edf data
     ///////////////////////////////////////////////////////////////////////////////////
 
-    qint64 numrecs=stredf.GetNumDataRecords();
-    qint64 duration=numrecs*stredf.GetDuration();
-    int days=duration/86400000L; // GetNumDataRecords = this.. Duh!
+    qint64 numrecs = stredf.GetNumDataRecords();
+    qint64 duration = numrecs * stredf.GetDuration();
+    int days = duration / 86400000L; // GetNumDataRecords = this.. Duh!
 
     //QDateTime dt1=QDateTime::fromTime_t(stredf.startdate/1000L);
     //QDateTime dt2=QDateTime::fromTime_t(stredf.enddate/1000L);
     //QDate dd1=dt1.date();
     //QDate dd2=dt2.date();
 
-//    for (int s=0;s<stredf.GetNumSignals();s++) {
-//        EDFSignal &es = stredf.edfsignals[s];
-//        long recs=es.nr*stredf.GetNumDataRecords();
-//        //qDebug() << "STREDF:" << es.label << recs;
-//    }
+    //    for (int s=0;s<stredf.GetNumSignals();s++) {
+    //        EDFSignal &es = stredf.edfsignals[s];
+    //        long recs=es.nr*stredf.GetNumDataRecords();
+    //        //qDebug() << "STREDF:" << es.label << recs;
+    //    }
 
     // Process STR.edf and find first and last time for each day
 
@@ -516,58 +590,58 @@ int ResmedLoader::Open(QString & path,Profile *profile)
     QList<int> strday;
     QList<bool> dayfoo;
 
-    QHash<qint16,QList<time_t> > daystarttimes;
-    QHash<qint16,QList<time_t> > dayendtimes;
+    QHash<qint16, QList<time_t> > daystarttimes;
+    QHash<qint16, QList<time_t> > dayendtimes;
     //qint16 on,off;
     //qint16 o1[10],o2[10];
     //time_t st,et;
-    time_t time=stredf.startdate/1000L; // == 12pm on first day
-//    for (int i=0;i<days;i++) {
-//        EDFSignal *maskon=stredf.lookup["Mask On"];
-//        EDFSignal *maskoff=stredf.lookup["Mask Off"];
-//        int j=i*10;
+    time_t time = stredf.startdate / 1000L; // == 12pm on first day
+    //    for (int i=0;i<days;i++) {
+    //        EDFSignal *maskon=stredf.lookup["Mask On"];
+    //        EDFSignal *maskoff=stredf.lookup["Mask Off"];
+    //        int j=i*10;
 
-//        // Counts for on and off don't line up, and I'm not sure why
-//        // The extra 'off' always seems to start with a 1 at the beginning
-//        // A signal it's carried over from the day before perhaps? (noon boundary)
-//        int ckon=0,ckoff=0;
-//        for (int k=0;k<10;k++) {
-//            on=maskon->data[j+k];
-//            off=maskoff->data[j+k];
-//            o1[k]=on;
-//            o2[k]=off;
-//            if (on >= 0) ckon++;
-//            if (off >= 0) ckoff++;
-//        }
+    //        // Counts for on and off don't line up, and I'm not sure why
+    //        // The extra 'off' always seems to start with a 1 at the beginning
+    //        // A signal it's carried over from the day before perhaps? (noon boundary)
+    //        int ckon=0,ckoff=0;
+    //        for (int k=0;k<10;k++) {
+    //            on=maskon->data[j+k];
+    //            off=maskoff->data[j+k];
+    //            o1[k]=on;
+    //            o2[k]=off;
+    //            if (on >= 0) ckon++;
+    //            if (off >= 0) ckoff++;
+    //        }
 
-//        // set to true if day starts with machine running
-//        int offset=ckoff-ckon;
-//        dayfoo.push_back(offset>0);
+    //        // set to true if day starts with machine running
+    //        int offset=ckoff-ckon;
+    //        dayfoo.push_back(offset>0);
 
-//        st=0,et=0;
-//        time_t l,f;
+    //        st=0,et=0;
+    //        time_t l,f;
 
-//        // Find the Min & Max times for this day
-//        for (int k=0;k<ckon;k++) {
-//            on=o1[k];
-//            off=o2[k+offset];
-//            f=time+on*60;
-//            l=time+off*60;
-//            daystarttimes[i].push_back(f);
-//            dayendtimes[i].push_back(l);
+    //        // Find the Min & Max times for this day
+    //        for (int k=0;k<ckon;k++) {
+    //            on=o1[k];
+    //            off=o2[k+offset];
+    //            f=time+on*60;
+    //            l=time+off*60;
+    //            daystarttimes[i].push_back(f);
+    //            dayendtimes[i].push_back(l);
 
-//            if (!st || (st > f)) st=f;
-//            if (!et || (et < l)) et=l;
-//        }
-//        strfirst.push_back(st);
-//        strlast.push_back(et);
-//        strday.push_back(i);
-//        dayused[i]=ckon;
-//        time+=86400;
-//    }
+    //            if (!st || (st > f)) st=f;
+    //            if (!et || (et < l)) et=l;
+    //        }
+    //        strfirst.push_back(st);
+    //        strlast.push_back(et);
+    //        strday.push_back(i);
+    //        dayused[i]=ckon;
+    //        time+=86400;
+    //    }
 
     // reset time to first day
-    time=stredf.startdate/1000;
+    time = stredf.startdate / 1000;
 
     ///////////////////////////////////////////////////////////////////////////////////
     // Open DATALOG file and build list of session files
@@ -576,13 +650,16 @@ int ResmedLoader::Open(QString & path,Profile *profile)
     QStringList dirs;
     dirs.push_back(newpath);
     dir.setFilter(QDir::Dirs | QDir::Hidden | QDir::NoDotAndDotDot);
-    QFileInfoList flist=dir.entryInfoList();
+    QFileInfoList flist = dir.entryInfoList();
     bool ok;
-    for (int i=0;i<flist.size();i++) {
-        QFileInfo fi=flist.at(i);
-        filename=fi.fileName();
-        if (filename.length()==4) {
+
+    for (int i = 0; i < flist.size(); i++) {
+        QFileInfo fi = flist.at(i);
+        filename = fi.fileName();
+
+        if (filename.length() == 4) {
             filename.toInt(&ok);
+
             if (ok) {
                 dirs.push_back(fi.canonicalFilePath());
             }
@@ -595,53 +672,56 @@ int ResmedLoader::Open(QString & path,Profile *profile)
     QString fullname;
     bool gz;
     int size;
-    QMap<SessionID,QStringList>::iterator si;
+    QMap<SessionID, QStringList>::iterator si;
 
     sessfiles.clear();
 
-    for (int dc=0;dc<dirs.size();dc++) {
+    for (int dc = 0; dc < dirs.size(); dc++) {
 
         dir.setPath(dirs.at(dc));
         dir.setFilter(QDir::Files | QDir::Hidden | QDir::NoSymLinks);
         dir.setSorting(QDir::Name);
-        flist=dir.entryInfoList();
+        flist = dir.entryInfoList();
 
-        size=flist.size();
+        size = flist.size();
 
 
         // For each file in flist...
-        for (int i=0;i<size;i++) {
-            QFileInfo fi=flist.at(i);
-            filename=fi.fileName();
+        for (int i = 0; i < size; i++) {
+            QFileInfo fi = flist.at(i);
+            filename = fi.fileName();
 
             // Forget about it if it can't be read.
-            if (!fi.isReadable())
+            if (!fi.isReadable()) {
                 continue;
+            }
 
             if (filename.endsWith(STR_ext_gz)) {
                 filename.chop(3);
-                gz=true;
-            } else gz=false;
+                gz = true;
+            } else { gz = false; }
 
             // Accept only .edf and .edf.gz files
-            if (filename.right(4).toLower() != "."+STR_ext_EDF)
+            if (filename.right(4).toLower() != "." + STR_ext_EDF) {
                 continue;
+            }
 
-            fullname=fi.canonicalFilePath();
+            fullname = fi.canonicalFilePath();
 
             // Extract the session date out of the filename
-            datestr=filename.section("_",0,1);
+            datestr = filename.section("_", 0, 1);
 
             // Take the filename's date, and
-            date=QDateTime::fromString(datestr,"yyyyMMdd_HHmmss");
-            date=date.toUTC();
+            date = QDateTime::fromString(datestr, "yyyyMMdd_HHmmss");
+            date = date.toUTC();
 
             // Skip file if dates invalid, the filename is clearly wrong..
-            if (!date.isValid())
+            if (!date.isValid()) {
                 continue;
+            }
 
             // convert this date to UNIX epoch to form the sessionID
-            sessionid=date.toTime_t();
+            sessionid = date.toTime_t();
 
             ////////////////////////////////////////////////////////////////////////////////////////////
             // Resmed bugs up on the session filenames.. More than these 3 seconds
@@ -649,584 +729,599 @@ int ResmedLoader::Open(QString & path,Profile *profile)
             // Moral of the story, when writing firmware and saving in batches, use the same datetimes,
             // and provide firmware updates for free to your customers.
             ////////////////////////////////////////////////////////////////////////////////////////////
-            si=sessfiles.find(sessionid);
+            si = sessfiles.find(sessionid);
 
-            if (si==sessfiles.end()) {
+            if (si == sessfiles.end()) {
                 // Scan 3 seconds either way for sessions..
-                for (int j=1;j<3;j++) {
+                for (int j = 1; j < 3; j++) {
 
-                    if ((si=sessfiles.find(sessionid+j)) != sessfiles.end()) {
-                        sessionid+=j;
+                    if ((si = sessfiles.find(sessionid + j)) != sessfiles.end()) {
+                        sessionid += j;
                         break;
-                    } else if ((si=sessfiles.find(sessionid-j)) != sessfiles.end()) {
-                        sessionid-=j;
+                    } else if ((si = sessfiles.find(sessionid - j)) != sessfiles.end()) {
+                        sessionid -= j;
                         break;
                     }
                 }
             }
 
-            fullname=backup(fullname, backup_path);
+            fullname = backup(fullname, backup_path);
 
             // Push current filename to ordered-by-sessionid list
-            if (si!=sessfiles.end()) {
+            if (si != sessfiles.end()) {
                 // Ignore if already compressed version of the same file exists.. (just in case)
 
-                bool skip=false;
-                // check for any other versions of the same file.
-                for (int i=0;i<si.value().size();i++) {
-                    QString st=si.value().at(i).section("/",-1);
-                    if (st.endsWith(STR_ext_gz))
-                        st.chop(3);
+                bool skip = false;
 
-                    if (st==filename)
-                        skip=true;
+                // check for any other versions of the same file.
+                for (int i = 0; i < si.value().size(); i++) {
+                    QString st = si.value().at(i).section("/", -1);
+
+                    if (st.endsWith(STR_ext_gz)) {
+                        st.chop(3);
+                    }
+
+                    if (st == filename) {
+                        skip = true;
+                    }
                 }
-                if (!skip)
+
+                if (!skip) {
                     si.value().push_back(fullname);
+                }
             } else {
                 sessfiles[sessionid].push_back(fullname);
             }
 
-          //  if ((i % 10)==0) {
-                // Update the progress bar
-                if (qprogress) qprogress->setValue((float(i+1)/float(size)*10.0));
-                QApplication::processEvents();
-          //  }
+            //  if ((i % 10)==0) {
+            // Update the progress bar
+            if (qprogress) { qprogress->setValue((float(i + 1) / float(size) * 10.0)); }
+
+            QApplication::processEvents();
+            //  }
         }
     }
 
     QString fn;
     Session *sess;
-    int cnt=0;
-    size=sessfiles.size();
+    int cnt = 0;
+    size = sessfiles.size();
 
-    QHash<SessionID,int> sessday;
+    QHash<SessionID, int> sessday;
 
 
     /////////////////////////////////////////////////////////////////////////////
     // Scan over file list and knock out of dayused list
     /////////////////////////////////////////////////////////////////////////////
     //int dn;
-//    for (QMap<SessionID,QStringList>::iterator si=sessfiles.begin();si!=sessfiles.end();si++) {
-//        sessionid=si.key();
+    //    for (QMap<SessionID,QStringList>::iterator si=sessfiles.begin();si!=sessfiles.end();si++) {
+    //        sessionid=si.key();
 
-//        // Earliest possible day number
-//        int edn=((sessionid-time)/86400)-1;
-//        if (edn<0) edn=0;
+    //        // Earliest possible day number
+    //        int edn=((sessionid-time)/86400)-1;
+    //        if (edn<0) edn=0;
 
-//        // Find real day number from str.edf mask on/off data.
-//        dn=-1;
-//        for (int j=edn;j<strfirst.size();j++){
-//            st=strfirst.at(j);
-//            if (sessionid>=st) {
-//                et=strlast.at(j);
-//                if (sessionid<(et+300)) {
-//                    dn=j;
-//                    break;
-//                }
-//            }
-//        }
-//        // If found, mark day off so STR.edf summary data isn't used instead of the real thing.
-//        if (dn>=0) {
-//            dayused[dn]=0;
-//        }
-//    }
+    //        // Find real day number from str.edf mask on/off data.
+    //        dn=-1;
+    //        for (int j=edn;j<strfirst.size();j++){
+    //            st=strfirst.at(j);
+    //            if (sessionid>=st) {
+    //                et=strlast.at(j);
+    //                if (sessionid<(et+300)) {
+    //                    dn=j;
+    //                    break;
+    //                }
+    //            }
+    //        }
+    //        // If found, mark day off so STR.edf summary data isn't used instead of the real thing.
+    //        if (dn>=0) {
+    //            dayused[dn]=0;
+    //        }
+    //    }
 
     EDFSignal *sig;
 
     /////////////////////////////////////////////////////////////////////////////
     // For all days not in session lists, (to get at days without data records)
     /////////////////////////////////////////////////////////////////////////////
-//    for (dn=0;dn<days;dn++) {
-//        // Skip days with loadable data.
-//        if (!dayused[dn])
-//            continue;
+    //    for (dn=0;dn<days;dn++) {
+    //        // Skip days with loadable data.
+    //        if (!dayused[dn])
+    //            continue;
 
-//        if (!daystarttimes.contains(dn))
-//            continue;
+    //        if (!daystarttimes.contains(dn))
+    //            continue;
 
-//        sess=NULL;
+    //        sess=NULL;
 
-//        int scnt=daystarttimes[dn].size(); // count of sessions for this day
+    //        int scnt=daystarttimes[dn].size(); // count of sessions for this day
 
-//        // Create a new session for each mask on/off segment in a day
-//        // But only populate the last one with summary data.
-//        for (int j=0;j<scnt;j++) {
-//            st=daystarttimes[dn].at(j);
+    //        // Create a new session for each mask on/off segment in a day
+    //        // But only populate the last one with summary data.
+    //        for (int j=0;j<scnt;j++) {
+    //            st=daystarttimes[dn].at(j);
 
-//            // Skip if session already exists
-//            if (m->SessionExists(st))
-//                continue;
+    //            // Skip if session already exists
+    //            if (m->SessionExists(st))
+    //                continue;
 
-//            et=dayendtimes[dn].at(j);
+    //            et=dayendtimes[dn].at(j);
 
-//            // Create the session
-//            sess=new Session(m,st);
-//            sess->really_set_first(qint64(st)*1000L);
-//            sess->really_set_last(qint64(et)*1000L);
-//            sess->SetChanged(true);
-//            m->AddSession(sess,profile);
-//        }
-//        // Add the actual data to the last session
-//        EventDataType tmp,dur;
-//        if (sess) {
-//            /////////////////////////////////////////////////////////////////////
-//            // CPAP Mode
-//            /////////////////////////////////////////////////////////////////////
-//            int mode;
-//            sig=stredf.lookupSignal(CPAP_Mode);
-//            if (sig) {
-//                mode=sig->data[dn];
-//            } else mode=0;
+    //            // Create the session
+    //            sess=new Session(m,st);
+    //            sess->really_set_first(qint64(st)*1000L);
+    //            sess->really_set_last(qint64(et)*1000L);
+    //            sess->SetChanged(true);
+    //            m->AddSession(sess,profile);
+    //        }
+    //        // Add the actual data to the last session
+    //        EventDataType tmp,dur;
+    //        if (sess) {
+    //            /////////////////////////////////////////////////////////////////////
+    //            // CPAP Mode
+    //            /////////////////////////////////////////////////////////////////////
+    //            int mode;
+    //            sig=stredf.lookupSignal(CPAP_Mode);
+    //            if (sig) {
+    //                mode=sig->data[dn];
+    //            } else mode=0;
 
 
-//            /////////////////////////////////////////////////////////////////////
-//            // EPR Settings
-//            /////////////////////////////////////////////////////////////////////
-//            sess->settings[CPAP_PresReliefType]=PR_EPR;
+    //            /////////////////////////////////////////////////////////////////////
+    //            // EPR Settings
+    //            /////////////////////////////////////////////////////////////////////
+    //            sess->settings[CPAP_PresReliefType]=PR_EPR;
 
-//            // Note: AutoSV machines don't have both fields
-//            sig=stredf.lookupSignal(RMS9_EPR);
-//            if (sig) {
-//                sess->settings[CPAP_PresReliefMode]=EventDataType(sig->data[dn])*sig->gain;
-//            }
-//            sig=stredf.lookupSignal(RMS9_EPRSet);
-//            if (sig)  {
-//                sess->settings[CPAP_PresReliefSet]=EventDataType(sig->data[dn])*sig->gain;
-//            }
+    //            // Note: AutoSV machines don't have both fields
+    //            sig=stredf.lookupSignal(RMS9_EPR);
+    //            if (sig) {
+    //                sess->settings[CPAP_PresReliefMode]=EventDataType(sig->data[dn])*sig->gain;
+    //            }
+    //            sig=stredf.lookupSignal(RMS9_EPRSet);
+    //            if (sig)  {
+    //                sess->settings[CPAP_PresReliefSet]=EventDataType(sig->data[dn])*sig->gain;
+    //            }
 
 
-//            /////////////////////////////////////////////////////////////////////
-//            // Set Min & Max pressures depending on CPAP mode
-//            /////////////////////////////////////////////////////////////////////
-//            if (mode==0) {
-//                sess->settings[CPAP_Mode]=MODE_CPAP;
-//                sig=stredf.lookupSignal(RMS9_SetPressure); // ?? What's meant by Set Pressure?
-//                if (sig) {
-//                    EventDataType pressure=sig->data[dn]*sig->gain;
-//                    sess->settings[CPAP_Pressure]=pressure;
-//                }
-//            } else { // VPAP or Auto
-//                if (mode>5) {
-//                    if (mode>=7)
-//                        sess->settings[CPAP_Mode]=MODE_ASV;
-//                    else
-//                        sess->settings[CPAP_Mode]=MODE_BIPAP;
+    //            /////////////////////////////////////////////////////////////////////
+    //            // Set Min & Max pressures depending on CPAP mode
+    //            /////////////////////////////////////////////////////////////////////
+    //            if (mode==0) {
+    //                sess->settings[CPAP_Mode]=MODE_CPAP;
+    //                sig=stredf.lookupSignal(RMS9_SetPressure); // ?? What's meant by Set Pressure?
+    //                if (sig) {
+    //                    EventDataType pressure=sig->data[dn]*sig->gain;
+    //                    sess->settings[CPAP_Pressure]=pressure;
+    //                }
+    //            } else { // VPAP or Auto
+    //                if (mode>5) {
+    //                    if (mode>=7)
+    //                        sess->settings[CPAP_Mode]=MODE_ASV;
+    //                    else
+    //                        sess->settings[CPAP_Mode]=MODE_BIPAP;
 
-//                    EventDataType tmp,epap=0,ipap=0;
-//                    if ((sig=stredf.lookupName("EPAP"))) {
-//                        epap=sig->data[dn]*sig->gain;
-//                        sess->settings[CPAP_EPAP]=epap;
-//                        sess->setMin(CPAP_EPAP,epap);
-//                    }
-//                    if ((sig=stredf.lookupName("IPAP"))) {
-//                        ipap=sig->data[dn]*sig->gain;
-//                        sess->settings[CPAP_IPAP]=ipap;
-//                    }
-//                    if ((sig=stredf.lookupName("PS"))) {
-//                        tmp=sig->data[dn]*sig->gain;
-//                        sess->settings[CPAP_PS]=tmp; // technically this is IPAP-EPAP
-//                        if (!ipap) {
-//                            // not really possible. but anyway, just in case..
-//                            sess->settings[CPAP_IPAP]=epap+tmp;
-//                        }
-//                    }
-//                    if ((sig=stredf.lookupName("Min PS"))) {
-//                        tmp=sig->data[dn]*sig->gain;
-//                        sess->settings[CPAP_PSMin]=tmp;
-//                        sess->settings[CPAP_IPAPLo]=epap+tmp;
-//                        sess->setMin(CPAP_IPAP,epap+tmp);
-//                    }
-//                    if ((sig=stredf.lookupName("Max PS"))) {
-//                        tmp=sig->data[dn]*sig->gain;
-//                        sess->settings[CPAP_PSMax]=tmp;
-//                        sess->settings[CPAP_IPAPHi]=epap+tmp;
-//                    }
-//                    if ((sig=stredf.lookupName("RR"))) { // Is this a setting to force respiratory rate on S/T machines?
-//                        tmp=sig->data[dn];
-//                        sess->settings[CPAP_RespRate]=tmp*sig->gain;
-//                    }
+    //                    EventDataType tmp,epap=0,ipap=0;
+    //                    if ((sig=stredf.lookupName("EPAP"))) {
+    //                        epap=sig->data[dn]*sig->gain;
+    //                        sess->settings[CPAP_EPAP]=epap;
+    //                        sess->setMin(CPAP_EPAP,epap);
+    //                    }
+    //                    if ((sig=stredf.lookupName("IPAP"))) {
+    //                        ipap=sig->data[dn]*sig->gain;
+    //                        sess->settings[CPAP_IPAP]=ipap;
+    //                    }
+    //                    if ((sig=stredf.lookupName("PS"))) {
+    //                        tmp=sig->data[dn]*sig->gain;
+    //                        sess->settings[CPAP_PS]=tmp; // technically this is IPAP-EPAP
+    //                        if (!ipap) {
+    //                            // not really possible. but anyway, just in case..
+    //                            sess->settings[CPAP_IPAP]=epap+tmp;
+    //                        }
+    //                    }
+    //                    if ((sig=stredf.lookupName("Min PS"))) {
+    //                        tmp=sig->data[dn]*sig->gain;
+    //                        sess->settings[CPAP_PSMin]=tmp;
+    //                        sess->settings[CPAP_IPAPLo]=epap+tmp;
+    //                        sess->setMin(CPAP_IPAP,epap+tmp);
+    //                    }
+    //                    if ((sig=stredf.lookupName("Max PS"))) {
+    //                        tmp=sig->data[dn]*sig->gain;
+    //                        sess->settings[CPAP_PSMax]=tmp;
+    //                        sess->settings[CPAP_IPAPHi]=epap+tmp;
+    //                    }
+    //                    if ((sig=stredf.lookupName("RR"))) { // Is this a setting to force respiratory rate on S/T machines?
+    //                        tmp=sig->data[dn];
+    //                        sess->settings[CPAP_RespRate]=tmp*sig->gain;
+    //                    }
 
-//                    if ((sig=stredf.lookupName("Easy-Breathe"))) {
-//                        tmp=sig->data[dn]*sig->gain;
+    //                    if ((sig=stredf.lookupName("Easy-Breathe"))) {
+    //                        tmp=sig->data[dn]*sig->gain;
 
-//                        sess->settings[CPAP_PresReliefSet]=tmp;
-//                        sess->settings[CPAP_PresReliefType]=(int)PR_EASYBREATHE;
-//                        sess->settings[CPAP_PresReliefMode]=(int)PM_FullTime;
-//                    }
+    //                        sess->settings[CPAP_PresReliefSet]=tmp;
+    //                        sess->settings[CPAP_PresReliefType]=(int)PR_EASYBREATHE;
+    //                        sess->settings[CPAP_PresReliefMode]=(int)PM_FullTime;
+    //                    }
 
-//                } else {
-//                    sess->settings[CPAP_Mode]=MODE_APAP;
-//                    sig=stredf.lookupSignal(CPAP_PressureMin);
-//                    if (sig) {
-//                        EventDataType pressure=sig->data[dn]*sig->gain;
-//                        sess->settings[CPAP_PressureMin]=pressure;
-//                        //sess->setMin(CPAP_Pressure,pressure);
-//                    }
-//                    sig=stredf.lookupSignal(CPAP_PressureMax);
-//                    if (sig) {
-//                        EventDataType pressure=sig->data[dn]*sig->gain;
-//                        sess->settings[CPAP_PressureMax]=pressure;
-//                        //sess->setMax(CPAP_Pressure,pressure);
-//                    }
-//                }
-//            }
+    //                } else {
+    //                    sess->settings[CPAP_Mode]=MODE_APAP;
+    //                    sig=stredf.lookupSignal(CPAP_PressureMin);
+    //                    if (sig) {
+    //                        EventDataType pressure=sig->data[dn]*sig->gain;
+    //                        sess->settings[CPAP_PressureMin]=pressure;
+    //                        //sess->setMin(CPAP_Pressure,pressure);
+    //                    }
+    //                    sig=stredf.lookupSignal(CPAP_PressureMax);
+    //                    if (sig) {
+    //                        EventDataType pressure=sig->data[dn]*sig->gain;
+    //                        sess->settings[CPAP_PressureMax]=pressure;
+    //                        //sess->setMax(CPAP_Pressure,pressure);
+    //                    }
+    //                }
+    //            }
 
-//            EventDataType valmed=0,valmax=0,val95=0;
+    //            EventDataType valmed=0,valmax=0,val95=0;
 
-//            /////////////////////////////////////////////////////////////////////
-//            // Leak Summary
-//            /////////////////////////////////////////////////////////////////////
-//            if ((sig=stredf.lookupName("Leak Med"))) {
-//                valmed=sig->data[dn];
-//                if (valmed>=0) {
-//                    sess->m_gain[CPAP_Leak]=sig->gain*60.0;
+    //            /////////////////////////////////////////////////////////////////////
+    //            // Leak Summary
+    //            /////////////////////////////////////////////////////////////////////
+    //            if ((sig=stredf.lookupName("Leak Med"))) {
+    //                valmed=sig->data[dn];
+    //                if (valmed>=0) {
+    //                    sess->m_gain[CPAP_Leak]=sig->gain*60.0;
 
-//                    sess->m_valuesummary[CPAP_Leak][valmed]=51;
-//                }
-//            }
-//            if ((sig=stredf.lookupName("Leak 95"))) {
-//                val95=sig->data[dn];
-//                if (val95>=0)
-//                    sess->m_valuesummary[CPAP_Leak][val95]=45;
-//            }
-//            if ((sig=stredf.lookupName("Leak Max"))) {
-//                valmax=sig->data[dn];
-//                if (valmax>=0) {
-//                    sess->setMax(CPAP_Leak,valmax*sig->gain*60.0);
-//                    sess->m_valuesummary[CPAP_Leak][valmax]=4;
-//                }
-//            }
+    //                    sess->m_valuesummary[CPAP_Leak][valmed]=51;
+    //                }
+    //            }
+    //            if ((sig=stredf.lookupName("Leak 95"))) {
+    //                val95=sig->data[dn];
+    //                if (val95>=0)
+    //                    sess->m_valuesummary[CPAP_Leak][val95]=45;
+    //            }
+    //            if ((sig=stredf.lookupName("Leak Max"))) {
+    //                valmax=sig->data[dn];
+    //                if (valmax>=0) {
+    //                    sess->setMax(CPAP_Leak,valmax*sig->gain*60.0);
+    //                    sess->m_valuesummary[CPAP_Leak][valmax]=4;
+    //                }
+    //            }
 
-//            /////////////////////////////////////////////////////////////////////
-//            // Minute Ventilation Summary
-//            /////////////////////////////////////////////////////////////////////
-//            if ((sig=stredf.lookupName("Min Vent Med"))) {
-//                valmed=sig->data[dn];
-//                sess->m_gain[CPAP_MinuteVent]=sig->gain;
-//                sess->m_valuesummary[CPAP_MinuteVent][valmed]=51;
-//            }
-//            if ((sig=stredf.lookupName("Min Vent 95"))) {
-//                val95=sig->data[dn];
-//                sess->m_valuesummary[CPAP_MinuteVent][val95]=45;
-//            }
-//            if ((sig=stredf.lookupName("Min Vent Max"))) {
-//                valmax=sig->data[dn];
-//                sess->setMax(CPAP_MinuteVent,valmax*sig->gain);
-//                sess->m_valuesummary[CPAP_MinuteVent][valmax]=4;
-//            }
-//            /////////////////////////////////////////////////////////////////////
-//            // Respiratory Rate Summary
-//            /////////////////////////////////////////////////////////////////////
-//            if ((sig=stredf.lookupName("RR Med"))) {
-//                valmed=sig->data[dn];
-//                sess->m_gain[CPAP_RespRate]=sig->gain;
-//                sess->m_valuesummary[CPAP_RespRate][valmed]=51;
-//            }
-//            if ((sig=stredf.lookupName("RR 95"))) {
-//                val95=sig->data[dn];
-//                sess->m_valuesummary[CPAP_RespRate][val95]=45;
-//            }
-//            if ((sig=stredf.lookupName("RR Max"))) {
-//                valmax=sig->data[dn];
-//                sess->setMax(CPAP_RespRate,valmax*sig->gain);
-//                sess->m_valuesummary[CPAP_RespRate][valmax]=4;
-//            }
+    //            /////////////////////////////////////////////////////////////////////
+    //            // Minute Ventilation Summary
+    //            /////////////////////////////////////////////////////////////////////
+    //            if ((sig=stredf.lookupName("Min Vent Med"))) {
+    //                valmed=sig->data[dn];
+    //                sess->m_gain[CPAP_MinuteVent]=sig->gain;
+    //                sess->m_valuesummary[CPAP_MinuteVent][valmed]=51;
+    //            }
+    //            if ((sig=stredf.lookupName("Min Vent 95"))) {
+    //                val95=sig->data[dn];
+    //                sess->m_valuesummary[CPAP_MinuteVent][val95]=45;
+    //            }
+    //            if ((sig=stredf.lookupName("Min Vent Max"))) {
+    //                valmax=sig->data[dn];
+    //                sess->setMax(CPAP_MinuteVent,valmax*sig->gain);
+    //                sess->m_valuesummary[CPAP_MinuteVent][valmax]=4;
+    //            }
+    //            /////////////////////////////////////////////////////////////////////
+    //            // Respiratory Rate Summary
+    //            /////////////////////////////////////////////////////////////////////
+    //            if ((sig=stredf.lookupName("RR Med"))) {
+    //                valmed=sig->data[dn];
+    //                sess->m_gain[CPAP_RespRate]=sig->gain;
+    //                sess->m_valuesummary[CPAP_RespRate][valmed]=51;
+    //            }
+    //            if ((sig=stredf.lookupName("RR 95"))) {
+    //                val95=sig->data[dn];
+    //                sess->m_valuesummary[CPAP_RespRate][val95]=45;
+    //            }
+    //            if ((sig=stredf.lookupName("RR Max"))) {
+    //                valmax=sig->data[dn];
+    //                sess->setMax(CPAP_RespRate,valmax*sig->gain);
+    //                sess->m_valuesummary[CPAP_RespRate][valmax]=4;
+    //            }
 
-//            /////////////////////////////////////////////////////////////////////
-//            // Tidal Volume Summary
-//            /////////////////////////////////////////////////////////////////////
-//            if ((sig=stredf.lookupName("Tid Vol Med"))) {
-//                valmed=sig->data[dn];
-//                sess->m_gain[CPAP_TidalVolume]=sig->gain*1000.0;
-//                sess->m_valuesummary[CPAP_TidalVolume][valmed]=51;
-//            }
-//            if ((sig=stredf.lookupName("Tid Vol 95"))) {
-//                val95=sig->data[dn];
-//                sess->m_valuesummary[CPAP_TidalVolume][val95]=45;
-//            }
-//            if ((sig=stredf.lookupName("Tid Vol Max"))) {
-//                valmax=sig->data[dn];
-//                sess->setMax(CPAP_TidalVolume,valmax*sig->gain*1000.0);
-//                sess->m_valuesummary[CPAP_TidalVolume][valmax]=4;
-//            }
+    //            /////////////////////////////////////////////////////////////////////
+    //            // Tidal Volume Summary
+    //            /////////////////////////////////////////////////////////////////////
+    //            if ((sig=stredf.lookupName("Tid Vol Med"))) {
+    //                valmed=sig->data[dn];
+    //                sess->m_gain[CPAP_TidalVolume]=sig->gain*1000.0;
+    //                sess->m_valuesummary[CPAP_TidalVolume][valmed]=51;
+    //            }
+    //            if ((sig=stredf.lookupName("Tid Vol 95"))) {
+    //                val95=sig->data[dn];
+    //                sess->m_valuesummary[CPAP_TidalVolume][val95]=45;
+    //            }
+    //            if ((sig=stredf.lookupName("Tid Vol Max"))) {
+    //                valmax=sig->data[dn];
+    //                sess->setMax(CPAP_TidalVolume,valmax*sig->gain*1000.0);
+    //                sess->m_valuesummary[CPAP_TidalVolume][valmax]=4;
+    //            }
 
-//            /////////////////////////////////////////////////////////////////////
-//            // Target Minute Ventilation Summary
-//            /////////////////////////////////////////////////////////////////////
-//            if ((sig=stredf.lookupName("Targ Vent Med"))) {
-//                valmed=sig->data[dn];
-//                sess->m_gain[CPAP_TgMV]=sig->gain;
-//                sess->m_valuesummary[CPAP_TgMV][valmed]=51;
-//            }
-//            if ((sig=stredf.lookupName("Targ Vent 95"))) {
-//                val95=sig->data[dn];
-//                sess->m_valuesummary[CPAP_TgMV][val95]=45;
-//            }
-//            if ((sig=stredf.lookupName("Targ Vent Max"))) {
-//                valmax=sig->data[dn];
-//                sess->setMax(CPAP_TgMV,valmax*sig->gain);
-//                sess->m_valuesummary[CPAP_TgMV][valmax]=4;
-//            }
+    //            /////////////////////////////////////////////////////////////////////
+    //            // Target Minute Ventilation Summary
+    //            /////////////////////////////////////////////////////////////////////
+    //            if ((sig=stredf.lookupName("Targ Vent Med"))) {
+    //                valmed=sig->data[dn];
+    //                sess->m_gain[CPAP_TgMV]=sig->gain;
+    //                sess->m_valuesummary[CPAP_TgMV][valmed]=51;
+    //            }
+    //            if ((sig=stredf.lookupName("Targ Vent 95"))) {
+    //                val95=sig->data[dn];
+    //                sess->m_valuesummary[CPAP_TgMV][val95]=45;
+    //            }
+    //            if ((sig=stredf.lookupName("Targ Vent Max"))) {
+    //                valmax=sig->data[dn];
+    //                sess->setMax(CPAP_TgMV,valmax*sig->gain);
+    //                sess->m_valuesummary[CPAP_TgMV][valmax]=4;
+    //            }
 
 
-//            /////////////////////////////////////////////////////////////////////
-//            // I:E Summary
-//            /////////////////////////////////////////////////////////////////////
-//            if ((sig=stredf.lookupName("I:E Med"))) {
-//                valmed=sig->data[dn];
-//                sess->m_gain[CPAP_IE]=sig->gain;
-//                sess->m_valuesummary[CPAP_IE][valmed]=51;
-//            }
-//            if ((sig=stredf.lookupName("I:E 95"))) {
-//                val95=sig->data[dn];
-//                sess->m_valuesummary[CPAP_IE][val95]=45;
-//            }
-//            if ((sig=stredf.lookupName("I:E Max"))) {
-//                valmax=sig->data[dn];
-//                sess->setMax(CPAP_IE,valmax*sig->gain);
-//                sess->m_valuesummary[CPAP_IE][valmax]=4;
-//            }
+    //            /////////////////////////////////////////////////////////////////////
+    //            // I:E Summary
+    //            /////////////////////////////////////////////////////////////////////
+    //            if ((sig=stredf.lookupName("I:E Med"))) {
+    //                valmed=sig->data[dn];
+    //                sess->m_gain[CPAP_IE]=sig->gain;
+    //                sess->m_valuesummary[CPAP_IE][valmed]=51;
+    //            }
+    //            if ((sig=stredf.lookupName("I:E 95"))) {
+    //                val95=sig->data[dn];
+    //                sess->m_valuesummary[CPAP_IE][val95]=45;
+    //            }
+    //            if ((sig=stredf.lookupName("I:E Max"))) {
+    //                valmax=sig->data[dn];
+    //                sess->setMax(CPAP_IE,valmax*sig->gain);
+    //                sess->m_valuesummary[CPAP_IE][valmax]=4;
+    //            }
 
-//            /////////////////////////////////////////////////////////////////////
-//            // Mask Pressure Summary
-//            /////////////////////////////////////////////////////////////////////
-//            if ((sig=stredf.lookupName("Mask Pres Med"))) {
-//                valmed=sig->data[dn];
-//                if (valmed >= 0) {
-//                    sess->m_gain[CPAP_Pressure]=sig->gain;
-//                    sess->m_valuesummary[CPAP_Pressure][valmed]=51;
-//                }
-//            }
-//            if ((sig=stredf.lookupName("Mask Pres 95"))) {
-//                val95=sig->data[dn];
-//                if (val95 >= 0) {
-//                    sess->m_valuesummary[CPAP_Pressure][val95]=45;
-//                }
-//            }
-//            if ((sig=stredf.lookupName("Mask Pres Max"))) {
-//                valmax=sig->data[dn];
-//                if (valmax >= 0) {
-//                    sess->setMax(CPAP_Pressure,valmax*sig->gain);
-//                    sess->m_valuesummary[CPAP_Pressure][valmax]=4;
-//                }
-//            }
-//            /////////////////////////////////////////////////////////////////////
-//            // Therapy Pressure Summary
-//            /////////////////////////////////////////////////////////////////////
-//            if ((sig=stredf.lookupName("Therapy Pres Me"))) {
-//                valmed=sig->data[dn];
-//                if (valmed >= 0) {
-//                    //sess->m_gain[CPAP_Pressure]=sig->gain;
-//                    //sess->m_valuesummary[CPAP_Pressure][valmed]=51;
-//                }
-//            }
-//            if ((sig=stredf.lookupName("Therapy Pres 95"))) {
-//                val95=sig->data[dn];
-//                if (val95 >= 0) {
-////                    sess->m_valuesummary[CPAP_Pressure][val95]=45;
-//                }
-//            }
-//            if ((sig=stredf.lookupName("Therapy Pres Ma"))) {
-//                valmax=sig->data[dn];
-//                if (valmax >= 0) {
-////                    sess->setMax(CPAP_Pressure,valmax*sig->gain);
-////                    sess->m_valuesummary[CPAP_Pressure][valmax]=4;
-//                }
-//            }
+    //            /////////////////////////////////////////////////////////////////////
+    //            // Mask Pressure Summary
+    //            /////////////////////////////////////////////////////////////////////
+    //            if ((sig=stredf.lookupName("Mask Pres Med"))) {
+    //                valmed=sig->data[dn];
+    //                if (valmed >= 0) {
+    //                    sess->m_gain[CPAP_Pressure]=sig->gain;
+    //                    sess->m_valuesummary[CPAP_Pressure][valmed]=51;
+    //                }
+    //            }
+    //            if ((sig=stredf.lookupName("Mask Pres 95"))) {
+    //                val95=sig->data[dn];
+    //                if (val95 >= 0) {
+    //                    sess->m_valuesummary[CPAP_Pressure][val95]=45;
+    //                }
+    //            }
+    //            if ((sig=stredf.lookupName("Mask Pres Max"))) {
+    //                valmax=sig->data[dn];
+    //                if (valmax >= 0) {
+    //                    sess->setMax(CPAP_Pressure,valmax*sig->gain);
+    //                    sess->m_valuesummary[CPAP_Pressure][valmax]=4;
+    //                }
+    //            }
+    //            /////////////////////////////////////////////////////////////////////
+    //            // Therapy Pressure Summary
+    //            /////////////////////////////////////////////////////////////////////
+    //            if ((sig=stredf.lookupName("Therapy Pres Me"))) {
+    //                valmed=sig->data[dn];
+    //                if (valmed >= 0) {
+    //                    //sess->m_gain[CPAP_Pressure]=sig->gain;
+    //                    //sess->m_valuesummary[CPAP_Pressure][valmed]=51;
+    //                }
+    //            }
+    //            if ((sig=stredf.lookupName("Therapy Pres 95"))) {
+    //                val95=sig->data[dn];
+    //                if (val95 >= 0) {
+    ////                    sess->m_valuesummary[CPAP_Pressure][val95]=45;
+    //                }
+    //            }
+    //            if ((sig=stredf.lookupName("Therapy Pres Ma"))) {
+    //                valmax=sig->data[dn];
+    //                if (valmax >= 0) {
+    ////                    sess->setMax(CPAP_Pressure,valmax*sig->gain);
+    ////                    sess->m_valuesummary[CPAP_Pressure][valmax]=4;
+    //                }
+    //            }
 
-//            /////////////////////////////////////////////////////////////////////
-//            // Inspiratory Pressure (IPAP) Summary
-//            /////////////////////////////////////////////////////////////////////
-//            if ((sig=stredf.lookupName("Insp Pres Med"))) {
-//                valmed=sig->data[dn];
-//                sess->m_gain[CPAP_IPAP]=sig->gain;
-//                sess->m_valuesummary[CPAP_IPAP][valmed]=51;
-//            }
-//            if ((sig=stredf.lookupName("Insp Pres 95"))) {
-//                val95=sig->data[dn];
-//                sess->m_valuesummary[CPAP_IPAP][val95]=45;
-//            }
-//            if ((sig=stredf.lookupName("Insp Pres Max"))) {
-//                valmax=sig->data[dn];
-//                sess->setMax(CPAP_IPAP,valmax*sig->gain);
-//                sess->m_valuesummary[CPAP_IPAP][valmax]=4;
-//            }
-//            /////////////////////////////////////////////////////////////////////
-//            // Expiratory Pressure (EPAP) Summary
-//            /////////////////////////////////////////////////////////////////////
-//            if ((sig=stredf.lookupName("Exp Pres Med"))) {
-//                valmed=sig->data[dn];
-//                if (valmed>=0) {
-//                    sess->m_gain[CPAP_EPAP]=sig->gain;
-//                    sess->m_valuesummary[CPAP_EPAP][valmed]=51;
-//                }
-//            }
-//            if ((sig=stredf.lookupName("Exp Pres 95"))) {
-//                if (val95>=0) {
-//                    val95=sig->data[dn];
-//                    sess->m_valuesummary[CPAP_EPAP][val95]=45;
-//                }
-//            }
-//            if ((sig=stredf.lookupName("Exp Pres Max"))) {
-//                valmax=sig->data[dn];
-//                if (valmax>=0) {
-//                    sess->setMax(CPAP_EPAP,valmax*sig->gain);
-//                    sess->m_valuesummary[CPAP_EPAP][valmax]=4;
-//                }
-//            }
+    //            /////////////////////////////////////////////////////////////////////
+    //            // Inspiratory Pressure (IPAP) Summary
+    //            /////////////////////////////////////////////////////////////////////
+    //            if ((sig=stredf.lookupName("Insp Pres Med"))) {
+    //                valmed=sig->data[dn];
+    //                sess->m_gain[CPAP_IPAP]=sig->gain;
+    //                sess->m_valuesummary[CPAP_IPAP][valmed]=51;
+    //            }
+    //            if ((sig=stredf.lookupName("Insp Pres 95"))) {
+    //                val95=sig->data[dn];
+    //                sess->m_valuesummary[CPAP_IPAP][val95]=45;
+    //            }
+    //            if ((sig=stredf.lookupName("Insp Pres Max"))) {
+    //                valmax=sig->data[dn];
+    //                sess->setMax(CPAP_IPAP,valmax*sig->gain);
+    //                sess->m_valuesummary[CPAP_IPAP][valmax]=4;
+    //            }
+    //            /////////////////////////////////////////////////////////////////////
+    //            // Expiratory Pressure (EPAP) Summary
+    //            /////////////////////////////////////////////////////////////////////
+    //            if ((sig=stredf.lookupName("Exp Pres Med"))) {
+    //                valmed=sig->data[dn];
+    //                if (valmed>=0) {
+    //                    sess->m_gain[CPAP_EPAP]=sig->gain;
+    //                    sess->m_valuesummary[CPAP_EPAP][valmed]=51;
+    //                }
+    //            }
+    //            if ((sig=stredf.lookupName("Exp Pres 95"))) {
+    //                if (val95>=0) {
+    //                    val95=sig->data[dn];
+    //                    sess->m_valuesummary[CPAP_EPAP][val95]=45;
+    //                }
+    //            }
+    //            if ((sig=stredf.lookupName("Exp Pres Max"))) {
+    //                valmax=sig->data[dn];
+    //                if (valmax>=0) {
+    //                    sess->setMax(CPAP_EPAP,valmax*sig->gain);
+    //                    sess->m_valuesummary[CPAP_EPAP][valmax]=4;
+    //                }
+    //            }
 
-//            /////////////////////////////////////////////////////////////////////
-//            // Duration and Event Indices
-//            /////////////////////////////////////////////////////////////////////
-//            dur=0;
-//            if ((sig=stredf.lookupName("Mask Dur"))) {
-//                dur=sig->data[dn]*sig->gain;
-//                dur/=60.0f; // convert to hours.
-//            }
-//            if ((sig=stredf.lookupName("OAI"))) { // Obstructive Apnea Index
-//                tmp=sig->data[dn]*sig->gain;
-//                if (tmp>=0) {
-//                    sess->setCph(CPAP_Obstructive,tmp);
-//                    sess->setCount(CPAP_Obstructive,tmp*dur); // Converting from indice to counts..
-//                }
-//            }
-//            if ((sig=stredf.lookupName("HI"))) { // Hypopnea Index
-//                tmp=sig->data[dn]*sig->gain;
-//                if (tmp>=0) {
-//                    sess->setCph(CPAP_Hypopnea,tmp);
-//                    sess->setCount(CPAP_Hypopnea,tmp*dur);
-//                }
-//            }
-//            if ((sig=stredf.lookupName("UAI"))) { // Unspecified Apnea Index
-//                tmp=sig->data[dn]*sig->gain;
-//                if (tmp>=0) {
-//                    sess->setCph(CPAP_Apnea,tmp);
-//                    sess->setCount(CPAP_Apnea,tmp*dur);
-//                }
-//            }
-//            if ((sig=stredf.lookupName("CAI"))) { // "Central" Apnea Index
-//                tmp=sig->data[dn]*sig->gain;
-//                if (tmp>=0) {
-//                    sess->setCph(CPAP_ClearAirway,tmp);
-//                    sess->setCount(CPAP_ClearAirway,tmp*dur);
-//                }
-//            }
+    //            /////////////////////////////////////////////////////////////////////
+    //            // Duration and Event Indices
+    //            /////////////////////////////////////////////////////////////////////
+    //            dur=0;
+    //            if ((sig=stredf.lookupName("Mask Dur"))) {
+    //                dur=sig->data[dn]*sig->gain;
+    //                dur/=60.0f; // convert to hours.
+    //            }
+    //            if ((sig=stredf.lookupName("OAI"))) { // Obstructive Apnea Index
+    //                tmp=sig->data[dn]*sig->gain;
+    //                if (tmp>=0) {
+    //                    sess->setCph(CPAP_Obstructive,tmp);
+    //                    sess->setCount(CPAP_Obstructive,tmp*dur); // Converting from indice to counts..
+    //                }
+    //            }
+    //            if ((sig=stredf.lookupName("HI"))) { // Hypopnea Index
+    //                tmp=sig->data[dn]*sig->gain;
+    //                if (tmp>=0) {
+    //                    sess->setCph(CPAP_Hypopnea,tmp);
+    //                    sess->setCount(CPAP_Hypopnea,tmp*dur);
+    //                }
+    //            }
+    //            if ((sig=stredf.lookupName("UAI"))) { // Unspecified Apnea Index
+    //                tmp=sig->data[dn]*sig->gain;
+    //                if (tmp>=0) {
+    //                    sess->setCph(CPAP_Apnea,tmp);
+    //                    sess->setCount(CPAP_Apnea,tmp*dur);
+    //                }
+    //            }
+    //            if ((sig=stredf.lookupName("CAI"))) { // "Central" Apnea Index
+    //                tmp=sig->data[dn]*sig->gain;
+    //                if (tmp>=0) {
+    //                    sess->setCph(CPAP_ClearAirway,tmp);
+    //                    sess->setCount(CPAP_ClearAirway,tmp*dur);
+    //                }
+    //            }
 
-//        }
+    //        }
 
-//    }
-    backup_path+=RMS9_STR_datalog+"/";
+    //    }
+    backup_path += RMS9_STR_datalog + "/";
+
+    QString backupfile, backfile, crcfile, yearstr, bkuppath;
 
-    QString backupfile,backfile, crcfile, yearstr, bkuppath;
     /////////////////////////////////////////////////////////////////////////////
     // Scan through new file list and import sessions
     /////////////////////////////////////////////////////////////////////////////
-    for (QMap<SessionID,QStringList>::iterator si=sessfiles.begin();si!=sessfiles.end();si++) {
-        sessionid=si.key();
+    for (QMap<SessionID, QStringList>::iterator si = sessfiles.begin(); si != sessfiles.end(); si++) {
+        sessionid = si.key();
 
         // Skip file if already imported
-        if (m->SessionExists(sessionid))
+        if (m->SessionExists(sessionid)) {
             continue;
+        }
 
         // Create the session
-        sess=new Session(m,sessionid);
+        sess = new Session(m, sessionid);
 
         QString oldbkfile;
+
         // Process EDF File List
-        for (int i=0;i<si.value().size();++i) {
-            fullname=si.value()[i];
-            filename=fullname.section("/",-1);
-            gz=(filename.right(3).toLower()==STR_ext_gz);
+        for (int i = 0; i < si.value().size(); ++i) {
+            fullname = si.value()[i];
+            filename = fullname.section("/", -1);
+            gz = (filename.right(3).toLower() == STR_ext_gz);
 
 
-//            yearstr=filename.left(4);
-//            bkuppath=backup_path;
-//            int year=yearstr.toInt(&ok,10);
-//            if (ok) {
-//                bkuppath+=yearstr+"/";
-//                dir.mkpath(bkuppath);
-//            }
+            //            yearstr=filename.left(4);
+            //            bkuppath=backup_path;
+            //            int year=yearstr.toInt(&ok,10);
+            //            if (ok) {
+            //                bkuppath+=yearstr+"/";
+            //                dir.mkpath(bkuppath);
+            //            }
 
-//            // Copy the EDF file to the backup folder
-//            if (create_backups) {
-//                oldbkfile=backup_path+filename;
-//                backupfile=bkuppath+filename;
+            //            // Copy the EDF file to the backup folder
+            //            if (create_backups) {
+            //                oldbkfile=backup_path+filename;
+            //                backupfile=bkuppath+filename;
 
-//                bool dobackup=true;
+            //                bool dobackup=true;
 
-//                if (QFile::exists(oldbkfile+STR_ext_gz))
-//                    QFile::remove(oldbkfile+STR_ext_gz);
-//                if (QFile::exists(oldbkfile))
-//                    QFile::remove(oldbkfile);
+            //                if (QFile::exists(oldbkfile+STR_ext_gz))
+            //                    QFile::remove(oldbkfile+STR_ext_gz);
+            //                if (QFile::exists(oldbkfile))
+            //                    QFile::remove(oldbkfile);
 
-//                if (!gz && QFile::exists(backupfile+STR_ext_gz)) {
-//                    dobackup=false; // gzipped edf.. assume it's already a backup
-//                } else if (QFile::exists(backupfile)) {
-//                    if (gz) {
-//                        // don't bother, it's already there and compressed.
-//                        dobackup=false;
-//                    } else {
-//                        // non compressed file is there..
-//                        if (compress_backups) {
-//                            // remove old edf file, as we are writing a compressed one
-//                            QFile::remove(backupfile);
-//                        } else { // don't bother copying it.
-//                            dobackup=false;
-//                        }
-//                    }
-//                }
-//                if (dobackup) {
-//                    if (!gz) {
-//                        compress_backups ?
-//                            compressFile(fullname, backupfile)
-//                        :
-//                            QFile::copy(fullname, backupfile);
-//                    } else {
-//                        // already compressed, just copy it.
-//                        QFile::copy(fullname, backupfile);
-//                    }
-//                }
+            //                if (!gz && QFile::exists(backupfile+STR_ext_gz)) {
+            //                    dobackup=false; // gzipped edf.. assume it's already a backup
+            //                } else if (QFile::exists(backupfile)) {
+            //                    if (gz) {
+            //                        // don't bother, it's already there and compressed.
+            //                        dobackup=false;
+            //                    } else {
+            //                        // non compressed file is there..
+            //                        if (compress_backups) {
+            //                            // remove old edf file, as we are writing a compressed one
+            //                            QFile::remove(backupfile);
+            //                        } else { // don't bother copying it.
+            //                            dobackup=false;
+            //                        }
+            //                    }
+            //                }
+            //                if (dobackup) {
+            //                    if (!gz) {
+            //                        compress_backups ?
+            //                            compressFile(fullname, backupfile)
+            //                        :
+            //                            QFile::copy(fullname, backupfile);
+            //                    } else {
+            //                        // already compressed, just copy it.
+            //                        QFile::copy(fullname, backupfile);
+            //                    }
+            //                }
 
-//                if (!gz) {
-//                    backfile=filename.replace(".edf",".crc",Qt::CaseInsensitive);
-//                } else {
-//                    backfile=filename.replace(".edf.gz",".crc",Qt::CaseInsensitive);
-//                }
+            //                if (!gz) {
+            //                    backfile=filename.replace(".edf",".crc",Qt::CaseInsensitive);
+            //                } else {
+            //                    backfile=filename.replace(".edf.gz",".crc",Qt::CaseInsensitive);
+            //                }
 
-//                backupfile=bkuppath+backfile;
-//                crcfile=newpath+backfile;
-//                QFile::copy(crcfile, backupfile);
-//            }
+            //                backupfile=bkuppath+backfile;
+            //                crcfile=newpath+backfile;
+            //                QFile::copy(crcfile, backupfile);
+            //            }
 
             EDFParser edf(fullname);
 
             // Parse the actual file
-            if (!edf.Parse())
+            if (!edf.Parse()) {
                 continue;
+            }
 
             // Give a warning if doesn't match the machine serial number in Identification.tgt
-            if (edf.serialnumber!=serial) {
+            if (edf.serialnumber != serial) {
                 qDebug() << "edf Serial number doesn't match Identification.tgt";
             }
 
-            fn=filename.section("_",-1).section(".",0,0).toLower();
+            fn = filename.section("_", -1).section(".", 0, 0).toLower();
 
-            if (fn=="eve") LoadEVE(sess,edf);
-            else if (fn=="pld") LoadPLD(sess,edf);
-            else if (fn=="brp") LoadBRP(sess,edf);
-            else if (fn=="sad") LoadSAD(sess,edf);
+            if (fn == "eve") { LoadEVE(sess, edf); }
+            else if (fn == "pld") { LoadPLD(sess, edf); }
+            else if (fn == "brp") { LoadBRP(sess, edf); }
+            else if (fn == "sad") { LoadSAD(sess, edf); }
         }
-        if ((++cnt%10) ==0) {
-            if (qprogress) qprogress->setValue(10.0+(float(cnt)/float(size)*90.0));
+
+        if ((++cnt % 10) == 0) {
+            if (qprogress) { qprogress->setValue(10.0 + (float(cnt) / float(size) * 90.0)); }
+
             QApplication::processEvents();
         }
-        int mode=0;
-        EventDataType prset=0, prmode=0;
+
+        int mode = 0;
+        EventDataType prset = 0, prmode = 0;
         qint64 dif;
         int dn;
 
-        if (!sess) continue;
+        if (!sess) { continue; }
+
         if (!sess->first()) {
             delete sess;
             continue;
@@ -1234,42 +1329,330 @@ int ResmedLoader::Open(QString & path,Profile *profile)
 
             sess->SetChanged(true);
 
-            dif=sess->first()-stredf.startdate;
+            dif = sess->first() - stredf.startdate;
+
+            dn = dif / 86400000L;
+
+            if ((dn >= 0) && (dn < days)) {
+                sig = stredf.lookupSignal(CPAP_Mode);
 
-            dn=dif/86400000L;
-            if ((dn>=0) && (dn<days)) {
-                sig=stredf.lookupSignal(CPAP_Mode);
                 if (sig) {
-                    mode=sig->data[dn];
-                } else mode=0;
+                    mode = sig->data[dn];
+                } else { mode = 0; }
 
 
 
 
                 // Ramp, Fulltime
+                // AutoSV machines don't have both fields
+                sig = stredf.lookupSignal(RMS9_EPR);
+
+                if (sig) {
+                    sess->settings[CPAP_PresReliefType] = PR_EPR;
+                    prmode = EventDataType(sig->data[dn]) * sig->gain;
+
+                    // Off,
+                    if (prmode < 0) {
+                        // Kaart's data has -1 here.. Not sure what it means.
+                        prmode = 0;
+                    } else if (prmode > sig->physical_maximum) {
+                        prmode = sig->physical_maximum;
+                    }
+
+                    // My VPAP (using EasyBreathe) and JM's Elite (using none) have 0
+                    sess->settings[CPAP_PresReliefMode] = prmode;
+                }
+
+                sig = stredf.lookupSignal(RMS9_EPRSet);
+
+                if (sig)  {
+                    prset = EventDataType(sig->data[dn]) * sig->gain;
+
+                    if (prset > sig->physical_maximum) {
+                        prset = sig->physical_maximum;
+                    } else if (prset < sig->physical_minimum) {
+                        prset = sig->physical_minimum;
+                    }
+
+                    sess->settings[CPAP_PresReliefSet] = prset;
+                }
+
+
+                if (mode == 0) {
+                    sess->settings[CPAP_Mode] = MODE_CPAP;
+                    sig = stredf.lookupSignal(RMS9_SetPressure); // ?? What's meant by Set Pressure?
+
+                    if (sig) {
+                        EventDataType pressure = sig->data[dn] * sig->gain;
+                        sess->settings[CPAP_Pressure] = pressure;
+                    }
+                } else if (mode > 5) {
+                    if (mode >= 7) {
+                        sess->settings[CPAP_Mode] =
+                            MODE_ASV;    // interestingly, last digit of model number matches these when in full mode.
+                    } else {
+                        sess->settings[CPAP_Mode] = MODE_BIPAP;
+                    }
+
+                    EventDataType tmp, epap = 0, ipap = 0;
+
+
+                    // All S9 machines have Set Pressure
+                    // Elite has Min Pressure and Max Pressure
+                    // VPAP Auto has EPAP, Min EPAP, IPAP and Max IPAP, and PS
+                    // VPAP Adapt 36007 has just EPAP and PSLo/Hi,
+                    // VPAP Adapt 36037 has EPAPLo, EPAPHi and PSLo/Hi
+
+
+                    if (stredf.lookup.contains("EPAP")) {
+                        sig = stredf.lookup["EPAP"];
+                        epap = sig->data[dn] * sig->gain;
+                        sess->settings[CPAP_EPAP] = epap;
+                    }
+
+                    if (stredf.lookup.contains("IPAP")) {
+                        sig = stredf.lookup["IPAP"];
+                        ipap = sig->data[dn] * sig->gain;
+                        sess->settings[CPAP_IPAP] = ipap;
+                    }
+
+                    if (stredf.lookup.contains("Min EPAP")) {
+                        sig = stredf.lookup["Min EPAP"];
+                        epap = sig->data[dn] * sig->gain;
+                        sess->settings[CPAP_EPAPLo] = epap;
+                    }
+
+                    if (stredf.lookup.contains("Max EPAP")) {
+                        sig = stredf.lookup["Max EPAP"];
+                        epap = sig->data[dn] * sig->gain;
+                        sess->settings[CPAP_EPAPHi] = epap;
+                    }
+
+                    if (stredf.lookup.contains("Min IPAP")) {
+                        sig = stredf.lookup["Min IPAP"];
+                        ipap = sig->data[dn] * sig->gain;
+                        sess->settings[CPAP_IPAPLo] = ipap;
+                    }
+
+                    if (stredf.lookup.contains("Max IPAP")) {
+                        sig = stredf.lookup["Max IPAP"];
+                        ipap = sig->data[dn] * sig->gain;
+                        sess->settings[CPAP_IPAPHi] = ipap;
+                    }
+
+                    if (stredf.lookup.contains("PS")) {
+                        sig = stredf.lookup["PS"];
+                        tmp = sig->data[dn] * sig->gain;
+                        sess->settings[CPAP_PS] = tmp; // plain VPAP Pressure support
+                    }
+
+                    if (stredf.lookup.contains("Min PS")) {
+                        sig = stredf.lookup["Min PS"];
+                        tmp = sig->data[dn] * sig->gain;
+                        sess->settings[CPAP_PSMin] = tmp;
+                    }
+
+                    if (stredf.lookup.contains("Max PS")) {
+                        sig = stredf.lookup["Max PS"];
+                        tmp = sig->data[dn] * sig->gain;
+                        sess->settings[CPAP_PSMax] = tmp;
+                    }
+
+                    if (stredf.lookup.contains("RR")) { // Is this a setting to force respiratory rate on S/T machines?
+                        sig = stredf.lookup["RR"];
+                        tmp = sig->data[dn];
+                        sess->settings[CPAP_RespRate] = tmp * sig->gain;
+                    }
+
+                    // this is not a setting on any machine I've played with, I think it's just an indication of the type of motor
+                    if (stredf.lookup.contains("Easy-Breathe")) {
+                        sig = stredf.lookup["Easy-Breathe"];
+                        tmp = sig->data[dn] * sig->gain;
+
+                        sess->settings[CPAP_PresReliefSet] = tmp;
+                        sess->settings[CPAP_PresReliefType] = (int)PR_EASYBREATHE;
+                        sess->settings[CPAP_PresReliefMode] = (int)PM_FullTime;
+                    }
+
+                } else {
+                    sess->settings[CPAP_Mode] = MODE_APAP;
+                    sig = stredf.lookupSignal(CPAP_PressureMin);
+
+                    if (sig) {
+                        EventDataType pressure = sig->data[dn] * sig->gain;
+                        sess->settings[CPAP_PressureMin] = pressure;
+                        //sess->setMin(CPAP_Pressure,pressure);
+                    }
+
+                    sig = stredf.lookupSignal(CPAP_PressureMax);
+
+                    if (sig) {
+                        EventDataType pressure = sig->data[dn] * sig->gain;
+                        sess->settings[CPAP_PressureMax] = pressure;
+                        //sess->setMax(CPAP_Pressure,pressure);
+                    }
+
+                }
+            }
+
+
+            // The following only happens when the STR.edf file is not up to date..
+            // This will only happen when the user fails to back up their SDcard properly.
+            // Basically takes a guess.
+            //            bool dodgy=false;
+            //            if (!sess->settings.contains(CPAP_Mode)) {
+            //                //The following is a lame assumption if 50th percentile == max, then it's CPAP
+            //                EventDataType max=sess->Max(CPAP_Pressure);
+            //                EventDataType p50=sess->percentile(CPAP_Pressure,0.60);
+            //                EventDataType p502=sess->percentile(CPAP_MaskPressure,0.60);
+            //                p50=qMax(p50, p502);
+            //                if (max==0) {
+            //                    dodgy=true;
+            //                } else if (qAbs(max-p50)<1.8) {
+            //                    max=round(max*10.0)/10.0;
+            //                    sess->settings[CPAP_Mode]=MODE_CPAP;
+            //                    if (max<1) {
+            //                        int i=5;
+            //                    }
+            //                    sess->settings[CPAP_PressureMin]=max;
+            //                    EventDataType epr=round(sess->Max(CPAP_EPAP)*10.0)/10.0;
+            //                    int i=max-epr;
+            //                    sess->settings[CPAP_PresReliefType]=PR_EPR;
+            //                    prmode=(i>0) ? 0 : 1;
+            //                    sess->settings[CPAP_PresReliefMode]=prmode;
+            //                    sess->settings[CPAP_PresReliefSet]=i;
+
+
+            //                } else {
+            //                    // It's not cpap, so just take the highest setting for this machines history.
+            //                    // This may fail if the missing str data is at the beginning of a fresh import.
+            //                    CPAPMode mode=(CPAPMode)(int)PROFILE.calcSettingsMax(CPAP_Mode,MT_CPAP,sess->machine()->FirstDay(),sess->machine()->LastDay());
+            //                    if (mode<MODE_APAP) mode=MODE_APAP;
+            //                    sess->settings[CPAP_Mode]=mode;
+            //                    // Assuming 10th percentile should cover for ramp/warmup
+            //                    sess->settings[CPAP_PressureMin]=sess->percentile(CPAP_Pressure,0.10);
+            //                    sess->settings[CPAP_PressureMax]=sess->Max(CPAP_Pressure);
+            //                }
+            //            }
+            //Rather than take a dodgy guess, EPR settings can take a hit, and this data can simply be missed..
+
+            // Add the session to the machine & profile objects
+            //if (!dodgy)
+            m->AddSession(sess, profile);
+        }
+    }
+
+    /////////////////////////////////////////////////////////////////////////////////
+    // Process STR.edf now all valid Session data is imported
+    /////////////////////////////////////////////////////////////////////////////////
+    /*
+        qint64 tt=stredf.startdate;
+        QDateTime dt=QDateTime::fromMSecsSinceEpoch(tt);
+        QDateTime mt;
+        QDate d;
+
+        EDFSignal *maskon=stredf.lookup["Mask On"];
+        EDFSignal *maskoff=stredf.lookup["Mask Off"];
+        int nr1=maskon->nr;
+        int nr2=maskoff->nr;
+
+        qint64 mon, moff;
+
+        int mode;
+        EventDataType prset, prmode;
+
+        SessionID sid;
+        for (int dn=0; dn < days; dn++, tt+=86400000L) {
+            dt=QDateTime::fromMSecsSinceEpoch(tt);
+            d=dt.date();
+            Day * day=PROFILE.GetDay(d, MT_CPAP);
+            if (day) {
+                continue;
+            }
+            QString a;
+            // Todo: check session start times.
+            // mask time is in minutes per day, assuming starting from 12 noon
+            // Also to think about: users who are too lazy to set their clocks, or who have flat clock batteries.
+
+            int nr=maskon->nr;
+            int j=dn * nr;
+            qint16 m_on=-1, m_off=-1, m_off2=0;
+            for (int i=0;i<10;i++) {
+                m_on=maskon->data[j+i];
+                if ((i>0) && (m_on >=0) && (m_on < m_off)) {
+                    qDebug() << "Mask on before previous off";
+                }
+                m_off=maskoff->data[j+i];
+                m_off2=m_off;
+
+
+                if ((m_on >= 0) && (m_off < 0)) {
+                    // valid session.. but machine turned off the next day
+                    // look ahead and pinch the end time from tomorrows record
+                    if ((dn+1) > days) {
+                        qDebug() << "Last record should have contained a mask off event :(";
+                        continue;
+                    }
+                    m_off=maskoff->data[j + nr];
+
+                    if (maskon->data[j + nr] < 0) {
+                        qDebug() << dn << "Looking ahead maskon should be < 0";
+                        continue;
+                    }
+                    if (m_off < 0) {
+                        qDebug() << dn << "Looking ahead maskoff should be > 0";
+                        continue;
+                    }
+
+                    // It's in the next day, so add one day in minutes..
+                    m_off+=1440;
+
+                    // Valid
+
+                } else if ((m_off >= 0) && (m_on < 0)) {
+
+                    if (i>0) {
+                        qDebug() << "WTH!??? Mask off but no on";
+                    }
+                    // first record of day.. might already be on (crossing noon)
+                    // Safely ignore because they are picked up on the other day.
+                    continue;
+                } else if ((m_off < 0) && (m_on < 0))
+                    continue;
+
+                mon=tt + m_on * 60000L;
+                moff=tt + m_off * 60000L;
+
+                sid=mon/1000L;
+                QDateTime on=QDateTime::fromMSecsSinceEpoch(mon);
+                QDateTime off=QDateTime::fromMSecsSinceEpoch(moff);
+
+                sess=new Session(m,sid);
+                sess->set_first(mon);
+                sess->set_last(moff);
+
+                sig=stredf.lookupSignal(CPAP_Mode);
+                if (sig) {
+                    mode=sig->data[dn];
+                } else mode=0;
+
+                sess->settings[CPAP_PresReliefType]=PR_EPR;
+
                 // AutoSV machines don't have both fields
                 sig=stredf.lookupSignal(RMS9_EPR);
                 if (sig) {
-                    sess->settings[CPAP_PresReliefType]=PR_EPR;
                     prmode=EventDataType(sig->data[dn])*sig->gain;
-                    // Off,
-                    if (prmode<0) {
-                        // Kaart's data has -1 here.. Not sure what it means.
-                        prmode=0;
-                    } else if (prmode > sig->physical_maximum) {
-                        prmode=sig->physical_maximum;
+                    if (prmode>sig->physical_maximum) {
+                        int i=5;
                     }
-                    // My VPAP (using EasyBreathe) and JM's Elite (using none) have 0
                     sess->settings[CPAP_PresReliefMode]=prmode;
                 }
 
                 sig=stredf.lookupSignal(RMS9_EPRSet);
                 if (sig)  {
                     prset=EventDataType(sig->data[dn])*sig->gain;
-                    if (prset > sig->physical_maximum) {
-                        prset=sig->physical_maximum;
-                    } else if (prset < sig->physical_minimum) {
-                        prset=sig->physical_minimum;
+                    if (prset>sig->physical_maximum) {
+                        int i=5;
                     }
                     sess->settings[CPAP_PresReliefSet]=prset;
                 }
@@ -1284,20 +1667,11 @@ int ResmedLoader::Open(QString & path,Profile *profile)
                     }
                 } else if (mode>5) {
                     if (mode>=7)
-                        sess->settings[CPAP_Mode]=MODE_ASV; // interestingly, last digit of model number matches these when in full mode.
+                        sess->settings[CPAP_Mode]=MODE_ASV;
                     else
                         sess->settings[CPAP_Mode]=MODE_BIPAP;
 
                     EventDataType tmp,epap=0,ipap=0;
-
-
-                    // All S9 machines have Set Pressure
-                    // Elite has Min Pressure and Max Pressure
-                    // VPAP Auto has EPAP, Min EPAP, IPAP and Max IPAP, and PS
-                    // VPAP Adapt 36007 has just EPAP and PSLo/Hi,
-                    // VPAP Adapt 36037 has EPAPLo, EPAPHi and PSLo/Hi
-
-
                     if (stredf.lookup.contains("EPAP")) {
                         sig=stredf.lookup["EPAP"];
                         epap=sig->data[dn]*sig->gain;
@@ -1308,42 +1682,27 @@ int ResmedLoader::Open(QString & path,Profile *profile)
                         ipap=sig->data[dn]*sig->gain;
                         sess->settings[CPAP_IPAP]=ipap;
                     }
-
-                    if (stredf.lookup.contains("Min EPAP")) {
-                        sig=stredf.lookup["Min EPAP"];
-                        epap=sig->data[dn]*sig->gain;
-                        sess->settings[CPAP_EPAPLo]=epap;
-                    }
-                    if (stredf.lookup.contains("Max EPAP")) {
-                        sig=stredf.lookup["Max EPAP"];
-                        epap=sig->data[dn]*sig->gain;
-                        sess->settings[CPAP_EPAPHi]=epap;
-                    }
-
-                    if (stredf.lookup.contains("Min IPAP")) {
-                        sig=stredf.lookup["Min IPAP"];
-                        ipap=sig->data[dn]*sig->gain;
-                        sess->settings[CPAP_IPAPLo]=ipap;
-                    }
-                    if (stredf.lookup.contains("Max IPAP")) {
-                        sig=stredf.lookup["Max IPAP"];
-                        ipap=sig->data[dn]*sig->gain;
-                        sess->settings[CPAP_IPAPHi]=ipap;
-                    }
                     if (stredf.lookup.contains("PS")) {
                         sig=stredf.lookup["PS"];
                         tmp=sig->data[dn]*sig->gain;
-                        sess->settings[CPAP_PS]=tmp; // plain VPAP Pressure support
+                        sess->settings[CPAP_PS]=tmp; // technically this is IPAP-EPAP
+                        if (!ipap) {
+                            // not really possible. but anyway, just in case..
+                            sess->settings[CPAP_IPAP]=epap+tmp;
+                        }
                     }
                     if (stredf.lookup.contains("Min PS")) {
                         sig=stredf.lookup["Min PS"];
                         tmp=sig->data[dn]*sig->gain;
                         sess->settings[CPAP_PSMin]=tmp;
+                        sess->settings[CPAP_IPAPLo]=epap+tmp;
+                        sess->setMin(CPAP_IPAP,epap+tmp);
                     }
                     if (stredf.lookup.contains("Max PS")) {
                         sig=stredf.lookup["Max PS"];
                         tmp=sig->data[dn]*sig->gain;
                         sess->settings[CPAP_PSMax]=tmp;
+                        sess->settings[CPAP_IPAPHi]=epap+tmp;
                     }
                     if (stredf.lookup.contains("RR")) { // Is this a setting to force respiratory rate on S/T machines?
                         sig=stredf.lookup["RR"];
@@ -1351,7 +1710,6 @@ int ResmedLoader::Open(QString & path,Profile *profile)
                         sess->settings[CPAP_RespRate]=tmp*sig->gain;
                     }
 
-                    // this is not a setting on any machine I've played with, I think it's just an indication of the type of motor
                     if (stredf.lookup.contains("Easy-Breathe")) {
                         sig=stredf.lookup["Easy-Breathe"];
                         tmp=sig->data[dn]*sig->gain;
@@ -1377,298 +1735,64 @@ int ResmedLoader::Open(QString & path,Profile *profile)
                     }
 
                 }
-            }
 
-
-            // The following only happens when the STR.edf file is not up to date..
-            // This will only happen when the user fails to back up their SDcard properly.
-            // Basically takes a guess.
-//            bool dodgy=false;
-//            if (!sess->settings.contains(CPAP_Mode)) {
-//                //The following is a lame assumption if 50th percentile == max, then it's CPAP
-//                EventDataType max=sess->Max(CPAP_Pressure);
-//                EventDataType p50=sess->percentile(CPAP_Pressure,0.60);
-//                EventDataType p502=sess->percentile(CPAP_MaskPressure,0.60);
-//                p50=qMax(p50, p502);
-//                if (max==0) {
-//                    dodgy=true;
-//                } else if (qAbs(max-p50)<1.8) {
-//                    max=round(max*10.0)/10.0;
-//                    sess->settings[CPAP_Mode]=MODE_CPAP;
-//                    if (max<1) {
-//                        int i=5;
-//                    }
-//                    sess->settings[CPAP_PressureMin]=max;
-//                    EventDataType epr=round(sess->Max(CPAP_EPAP)*10.0)/10.0;
-//                    int i=max-epr;
-//                    sess->settings[CPAP_PresReliefType]=PR_EPR;
-//                    prmode=(i>0) ? 0 : 1;
-//                    sess->settings[CPAP_PresReliefMode]=prmode;
-//                    sess->settings[CPAP_PresReliefSet]=i;
-
-
-//                } else {
-//                    // It's not cpap, so just take the highest setting for this machines history.
-//                    // This may fail if the missing str data is at the beginning of a fresh import.
-//                    CPAPMode mode=(CPAPMode)(int)PROFILE.calcSettingsMax(CPAP_Mode,MT_CPAP,sess->machine()->FirstDay(),sess->machine()->LastDay());
-//                    if (mode<MODE_APAP) mode=MODE_APAP;
-//                    sess->settings[CPAP_Mode]=mode;
-//                    // Assuming 10th percentile should cover for ramp/warmup
-//                    sess->settings[CPAP_PressureMin]=sess->percentile(CPAP_Pressure,0.10);
-//                    sess->settings[CPAP_PressureMax]=sess->Max(CPAP_Pressure);
-//                }
-//            }
-            //Rather than take a dodgy guess, EPR settings can take a hit, and this data can simply be missed..
-
-            // Add the session to the machine & profile objects
-            //if (!dodgy)
                 m->AddSession(sess,profile);
+
+                a=QString("[%3] %1:%2, ").arg(on.toString()).arg(off.toString()).arg(sid);
+                qDebug() << a.toStdString().data();
+            }
+
+
         }
-    }
-
-/////////////////////////////////////////////////////////////////////////////////
-// Process STR.edf now all valid Session data is imported
-/////////////////////////////////////////////////////////////////////////////////
-/*
-    qint64 tt=stredf.startdate;
-    QDateTime dt=QDateTime::fromMSecsSinceEpoch(tt);
-    QDateTime mt;
-    QDate d;
-
-    EDFSignal *maskon=stredf.lookup["Mask On"];
-    EDFSignal *maskoff=stredf.lookup["Mask Off"];
-    int nr1=maskon->nr;
-    int nr2=maskoff->nr;
-
-    qint64 mon, moff;
-
-    int mode;
-    EventDataType prset, prmode;
-
-    SessionID sid;
-    for (int dn=0; dn < days; dn++, tt+=86400000L) {
-        dt=QDateTime::fromMSecsSinceEpoch(tt);
-        d=dt.date();
-        Day * day=PROFILE.GetDay(d, MT_CPAP);
-        if (day) {
-            continue;
-        }
-        QString a;
-        // Todo: check session start times.
-        // mask time is in minutes per day, assuming starting from 12 noon
-        // Also to think about: users who are too lazy to set their clocks, or who have flat clock batteries.
-
-        int nr=maskon->nr;
-        int j=dn * nr;
-        qint16 m_on=-1, m_off=-1, m_off2=0;
-        for (int i=0;i<10;i++) {
-            m_on=maskon->data[j+i];
-            if ((i>0) && (m_on >=0) && (m_on < m_off)) {
-                qDebug() << "Mask on before previous off";
-            }
-            m_off=maskoff->data[j+i];
-            m_off2=m_off;
-
-
-            if ((m_on >= 0) && (m_off < 0)) {
-                // valid session.. but machine turned off the next day
-                // look ahead and pinch the end time from tomorrows record
-                if ((dn+1) > days) {
-                    qDebug() << "Last record should have contained a mask off event :(";
-                    continue;
-                }
-                m_off=maskoff->data[j + nr];
-
-                if (maskon->data[j + nr] < 0) {
-                    qDebug() << dn << "Looking ahead maskon should be < 0";
-                    continue;
-                }
-                if (m_off < 0) {
-                    qDebug() << dn << "Looking ahead maskoff should be > 0";
-                    continue;
-                }
-
-                // It's in the next day, so add one day in minutes..
-                m_off+=1440;
-
-                // Valid
-
-            } else if ((m_off >= 0) && (m_on < 0)) {
-
-                if (i>0) {
-                    qDebug() << "WTH!??? Mask off but no on";
-                }
-                // first record of day.. might already be on (crossing noon)
-                // Safely ignore because they are picked up on the other day.
-                continue;
-            } else if ((m_off < 0) && (m_on < 0))
-                continue;
-
-            mon=tt + m_on * 60000L;
-            moff=tt + m_off * 60000L;
-
-            sid=mon/1000L;
-            QDateTime on=QDateTime::fromMSecsSinceEpoch(mon);
-            QDateTime off=QDateTime::fromMSecsSinceEpoch(moff);
-
-            sess=new Session(m,sid);
-            sess->set_first(mon);
-            sess->set_last(moff);
-
-            sig=stredf.lookupSignal(CPAP_Mode);
-            if (sig) {
-                mode=sig->data[dn];
-            } else mode=0;
-
-            sess->settings[CPAP_PresReliefType]=PR_EPR;
-
-            // AutoSV machines don't have both fields
-            sig=stredf.lookupSignal(RMS9_EPR);
-            if (sig) {
-                prmode=EventDataType(sig->data[dn])*sig->gain;
-                if (prmode>sig->physical_maximum) {
-                    int i=5;
-                }
-                sess->settings[CPAP_PresReliefMode]=prmode;
-            }
-
-            sig=stredf.lookupSignal(RMS9_EPRSet);
-            if (sig)  {
-                prset=EventDataType(sig->data[dn])*sig->gain;
-                if (prset>sig->physical_maximum) {
-                    int i=5;
-                }
-                sess->settings[CPAP_PresReliefSet]=prset;
-            }
-
-
-            if (mode==0) {
-                sess->settings[CPAP_Mode]=MODE_CPAP;
-                sig=stredf.lookupSignal(RMS9_SetPressure); // ?? What's meant by Set Pressure?
-                if (sig) {
-                    EventDataType pressure=sig->data[dn]*sig->gain;
-                    sess->settings[CPAP_Pressure]=pressure;
-                }
-            } else if (mode>5) {
-                if (mode>=7)
-                    sess->settings[CPAP_Mode]=MODE_ASV;
-                else
-                    sess->settings[CPAP_Mode]=MODE_BIPAP;
-
-                EventDataType tmp,epap=0,ipap=0;
-                if (stredf.lookup.contains("EPAP")) {
-                    sig=stredf.lookup["EPAP"];
-                    epap=sig->data[dn]*sig->gain;
-                    sess->settings[CPAP_EPAP]=epap;
-                }
-                if (stredf.lookup.contains("IPAP")) {
-                    sig=stredf.lookup["IPAP"];
-                    ipap=sig->data[dn]*sig->gain;
-                    sess->settings[CPAP_IPAP]=ipap;
-                }
-                if (stredf.lookup.contains("PS")) {
-                    sig=stredf.lookup["PS"];
-                    tmp=sig->data[dn]*sig->gain;
-                    sess->settings[CPAP_PS]=tmp; // technically this is IPAP-EPAP
-                    if (!ipap) {
-                        // not really possible. but anyway, just in case..
-                        sess->settings[CPAP_IPAP]=epap+tmp;
-                    }
-                }
-                if (stredf.lookup.contains("Min PS")) {
-                    sig=stredf.lookup["Min PS"];
-                    tmp=sig->data[dn]*sig->gain;
-                    sess->settings[CPAP_PSMin]=tmp;
-                    sess->settings[CPAP_IPAPLo]=epap+tmp;
-                    sess->setMin(CPAP_IPAP,epap+tmp);
-                }
-                if (stredf.lookup.contains("Max PS")) {
-                    sig=stredf.lookup["Max PS"];
-                    tmp=sig->data[dn]*sig->gain;
-                    sess->settings[CPAP_PSMax]=tmp;
-                    sess->settings[CPAP_IPAPHi]=epap+tmp;
-                }
-                if (stredf.lookup.contains("RR")) { // Is this a setting to force respiratory rate on S/T machines?
-                    sig=stredf.lookup["RR"];
-                    tmp=sig->data[dn];
-                    sess->settings[CPAP_RespRate]=tmp*sig->gain;
-                }
-
-                if (stredf.lookup.contains("Easy-Breathe")) {
-                    sig=stredf.lookup["Easy-Breathe"];
-                    tmp=sig->data[dn]*sig->gain;
-
-                    sess->settings[CPAP_PresReliefSet]=tmp;
-                    sess->settings[CPAP_PresReliefType]=(int)PR_EASYBREATHE;
-                    sess->settings[CPAP_PresReliefMode]=(int)PM_FullTime;
-                }
-
-            } else {
-                sess->settings[CPAP_Mode]=MODE_APAP;
-                sig=stredf.lookupSignal(CPAP_PressureMin);
-                if (sig) {
-                    EventDataType pressure=sig->data[dn]*sig->gain;
-                    sess->settings[CPAP_PressureMin]=pressure;
-                    //sess->setMin(CPAP_Pressure,pressure);
-                }
-                sig=stredf.lookupSignal(CPAP_PressureMax);
-                if (sig) {
-                    EventDataType pressure=sig->data[dn]*sig->gain;
-                    sess->settings[CPAP_PressureMax]=pressure;
-                    //sess->setMax(CPAP_Pressure,pressure);
-                }
-
-            }
-
-            m->AddSession(sess,profile);
-
-            a=QString("[%3] %1:%2, ").arg(on.toString()).arg(off.toString()).arg(sid);
-            qDebug() << a.toStdString().data();
-        }
-
-
-    }
-*/
+    */
 
 #ifdef DEBUG_EFFICIENCY
     {
-        qint64 totalbytes=0;
-        qint64 totalns=0;
-    qDebug() << "Time Delta Efficiency Information";
-    for (QHash<ChannelID,qint64>::iterator it=channel_efficiency.begin();it!=channel_efficiency.end();it++) {
-        ChannelID code=it.key();
-        qint64 value=it.value();
-        qint64 ns=channel_time[code];
-        totalbytes+=value;
-        totalns+=ns;
-        double secs=double(ns)/1000000000.0L;
-        QString s=value < 0 ? "saved" : "cost";
-        qDebug() << "Time-Delta conversion for "+schema::channel[code].label()+" "+s+" "+QString::number(qAbs(value))+" bytes and took "+QString::number(secs,'f',4)+"s";
-    }
-    qDebug() << "Total toTimeDelta function usage:" << totalbytes << "in" << double(totalns)/1000000000.0 << "seconds";
+        qint64 totalbytes = 0;
+        qint64 totalns = 0;
+        qDebug() << "Time Delta Efficiency Information";
+
+        for (QHash<ChannelID, qint64>::iterator it = channel_efficiency.begin();
+                it != channel_efficiency.end(); it++) {
+            ChannelID code = it.key();
+            qint64 value = it.value();
+            qint64 ns = channel_time[code];
+            totalbytes += value;
+            totalns += ns;
+            double secs = double(ns) / 1000000000.0L;
+            QString s = value < 0 ? "saved" : "cost";
+            qDebug() << "Time-Delta conversion for " + schema::channel[code].label() + " " + s + " " +
+                     QString::number(qAbs(value)) + " bytes and took " + QString::number(secs, 'f', 4) + "s";
+        }
+
+        qDebug() << "Total toTimeDelta function usage:" << totalbytes << "in" << double(
+                     totalns) / 1000000000.0 << "seconds";
     }
 #endif
 
     if (m) {
         m->Save();
     }
-    if (qprogress) qprogress->setValue(100);
+
+    if (qprogress) { qprogress->setValue(100); }
+
     qDebug() << "Total Events " << event_cnt;
     return 1;
 }
 
 QString ResmedLoader::backup(QString fullname, QString backup_path, bool compress)
 {
-    QString filename,yearstr,newname,oldname;
-    bool ok, gz=(fullname.right(3).toLower()==STR_ext_gz);
+    QString filename, yearstr, newname, oldname;
+    bool ok, gz = (fullname.right(3).toLower() == STR_ext_gz);
 
-    filename=fullname.section("/",-1);
+    filename = fullname.section("/", -1);
 
-    if (gz)
+    if (gz) {
         filename.chop(3);
+    }
 
-    yearstr=filename.left(4);
-    yearstr.toInt(&ok,10);
+    yearstr = filename.left(4);
+    yearstr.toInt(&ok, 10);
 
 
     if (!ok) {
@@ -1676,574 +1800,646 @@ QString ResmedLoader::backup(QString fullname, QString backup_path, bool compres
         return "";
     }
 
-    newname=backup_path+RMS9_STR_datalog+"/"+yearstr;
+    newname = backup_path + RMS9_STR_datalog + "/" + yearstr;
     QDir dir;
     dir.mkpath(newname);
-    newname+="/"+filename;
+    newname += "/" + filename;
 
-    QString tmpname=newname;
+    QString tmpname = newname;
 
-    if (compress)
-        newname+=STR_ext_gz;
+    if (compress) {
+        newname += STR_ext_gz;
+    }
 
     // First make sure the correct backup exists.
     if (!QFile::exists(newname)) {
         if (compress) {
             gz ?
-                QFile::copy(fullname,newname)       // Already compressed.. copy it to the right location
+            QFile::copy(fullname, newname)      // Already compressed.. copy it to the right location
             :
-                compressFile(fullname,newname);
+            compressFile(fullname, newname);
         } else {
             // dont really care if it's compressed and not meant to be, leave it that way
-            QFile::copy(fullname,newname);
+            QFile::copy(fullname, newname);
         }
     } // else backup already exists...
 
     // Now the correct backup is in place, we can trash any
     if (compress) {
         // Remove any uncompressed duplicate
-        if (QFile::exists(tmpname))
+        if (QFile::exists(tmpname)) {
             QFile::remove(tmpname);
+        }
     } else {
         // Delete the non compressed copy and choose it instead.
-        if (QFile::exists(tmpname+STR_ext_gz)) {
+        if (QFile::exists(tmpname + STR_ext_gz)) {
             QFile::remove(tmpname);
-            newname=tmpname+STR_ext_gz;
+            newname = tmpname + STR_ext_gz;
         }
 
     }
 
     // Remove any traces from old backup directory structure
-    oldname=backup_path+RMS9_STR_datalog+"/"+filename;
-    if (QFile::exists(oldname))
-        QFile::remove(oldname);
+    oldname = backup_path + RMS9_STR_datalog + "/" + filename;
 
-    if (QFile::exists(oldname+STR_ext_gz))
-        QFile::remove(oldname+STR_ext_gz);
+    if (QFile::exists(oldname)) {
+        QFile::remove(oldname);
+    }
+
+    if (QFile::exists(oldname + STR_ext_gz)) {
+        QFile::remove(oldname + STR_ext_gz);
+    }
 
     return newname;
 }
 
 
-bool ResmedLoader::LoadEVE(Session *sess,EDFParser &edf)
+bool ResmedLoader::LoadEVE(Session *sess, EDFParser &edf)
 {
     // EVEnt records have useless duration record.
 
     QString t;
     long recs;
     double duration;
-    char * data;
+    char *data;
     char c;
     long pos;
-    bool sign,ok;
+    bool sign, ok;
     double d;
     double tt;
     //ChannelID code;
     //Event *e;
     //totaldur=edf.GetNumDataRecords()*edf.GetDuration();
 
-//    EventList *EL[4]={NULL};
+    //    EventList *EL[4]={NULL};
     sess->updateFirst(edf.startdate);
     //if (edf.enddate>edf.startdate) sess->set_last(edf.enddate);
 
-    EventList *OA=NULL, *HY=NULL, *CA=NULL, *UA=NULL;
+    EventList *OA = NULL, *HY = NULL, *CA = NULL, *UA = NULL;
 
     // Allow for empty sessions..
-    OA=sess->AddEventList(CPAP_Obstructive,EVL_Event);
-    HY=sess->AddEventList(CPAP_Hypopnea,EVL_Event);
-    UA=sess->AddEventList(CPAP_Apnea,EVL_Event);
+    OA = sess->AddEventList(CPAP_Obstructive, EVL_Event);
+    HY = sess->AddEventList(CPAP_Hypopnea, EVL_Event);
+    UA = sess->AddEventList(CPAP_Apnea, EVL_Event);
 
-    for (int s=0;s<edf.GetNumSignals();s++) {
-        recs=edf.edfsignals[s].nr*edf.GetNumDataRecords()*2;
+    for (int s = 0; s < edf.GetNumSignals(); s++) {
+        recs = edf.edfsignals[s].nr * edf.GetNumDataRecords() * 2;
 
-        data=(char *)edf.edfsignals[s].data;
-        pos=0;
-        tt=edf.startdate;
+        data = (char *)edf.edfsignals[s].data;
+        pos = 0;
+        tt = edf.startdate;
         sess->updateFirst(tt);
-        duration=0;
-        while (pos<recs) {
-            c=data[pos];
-            if ((c!='+') && (c!='-'))
+        duration = 0;
+
+        while (pos < recs) {
+            c = data[pos];
+
+            if ((c != '+') && (c != '-')) {
                 break;
-            if (data[pos++]=='+') sign=true; else sign=false;
-            t="";
-            c=data[pos];
+            }
+
+            if (data[pos++] == '+') { sign = true; }
+            else { sign = false; }
+
+            t = "";
+            c = data[pos];
+
             do {
-                t+=c;
+                t += c;
                 pos++;
-                c=data[pos];
-            } while ((c!=20) && (c!=21)); // start code
-            d=t.toDouble(&ok);
+                c = data[pos];
+            } while ((c != 20) && (c != 21)); // start code
+
+            d = t.toDouble(&ok);
+
             if (!ok) {
                 qDebug() << "Faulty EDF EVE file " << edf.filename;
                 break;
             }
-            if (!sign) d=-d;
-            tt=edf.startdate+qint64(d*1000.0);
-            duration=0;
+
+            if (!sign) { d = -d; }
+
+            tt = edf.startdate + qint64(d * 1000.0);
+            duration = 0;
             // First entry
 
-            if (data[pos]==21) {
+            if (data[pos] == 21) {
                 pos++;
                 // get duration.
-                t="";
+                t = "";
+
                 do {
-                    t+=data[pos];
+                    t += data[pos];
                     pos++;
-                } while ((data[pos]!=20) && (pos<recs)); // start code
-                duration=t.toDouble(&ok);
+                } while ((data[pos] != 20) && (pos < recs)); // start code
+
+                duration = t.toDouble(&ok);
+
                 if (!ok) {
                     qDebug() << "Faulty EDF EVE file (at %" << pos << ") " << edf.filename;
                     break;
                 }
             }
-            while ((data[pos]==20) && (pos<recs)) {
-                t="";
+
+            while ((data[pos] == 20) && (pos < recs)) {
+                t = "";
                 pos++;
-                if (data[pos]==0)
+
+                if (data[pos] == 0) {
                     break;
-                if (data[pos]==20) {
+                }
+
+                if (data[pos] == 20) {
                     pos++;
                     break;
                 }
 
                 do {
-                    t+=tolower(data[pos++]);
-                } while ((data[pos]!=20) && (pos<recs)); // start code
+                    t += tolower(data[pos++]);
+                } while ((data[pos] != 20) && (pos < recs)); // start code
+
                 if (!t.isEmpty()) {
-                    if (t=="obstructive apnea") {
-                        OA->AddEvent(tt,duration);
-                    } else if (t=="hypopnea") {
-                        HY->AddEvent(tt,duration+10); // Only Hyponea's Need the extra duration???
-                    } else if (t=="apnea") {
-                        UA->AddEvent(tt,duration);
-                    } else if (t=="central apnea") {
+                    if (t == "obstructive apnea") {
+                        OA->AddEvent(tt, duration);
+                    } else if (t == "hypopnea") {
+                        HY->AddEvent(tt, duration + 10); // Only Hyponea's Need the extra duration???
+                    } else if (t == "apnea") {
+                        UA->AddEvent(tt, duration);
+                    } else if (t == "central apnea") {
                         // Not all machines have it, so only create it when necessary..
                         if (!CA) {
-                            if (!(CA=sess->AddEventList(CPAP_ClearAirway,EVL_Event))) return false;
+                            if (!(CA = sess->AddEventList(CPAP_ClearAirway, EVL_Event))) { return false; }
                         }
-                        CA->AddEvent(tt,duration);
+
+                        CA->AddEvent(tt, duration);
                     } else {
-                        if (t!="recording starts") {
+                        if (t != "recording starts") {
                             qDebug() << "Unobserved ResMed annotation field: " << t;
                         }
                     }
                 }
-                if (pos>=recs) {
+
+                if (pos >= recs) {
                     qDebug() << "Short EDF EVE file" << edf.filename;
                     break;
                 }
-               // pos++;
+
+                // pos++;
             }
-            while ((data[pos]==0) && pos<recs) pos++;
-            if (pos>=recs) break;
+
+            while ((data[pos] == 0) && pos < recs) { pos++; }
+
+            if (pos >= recs) { break; }
         }
+
         sess->updateLast(tt);
-       // qDebug(data);
+        // qDebug(data);
     }
+
     return true;
 }
-bool ResmedLoader::LoadBRP(Session *sess,EDFParser &edf)
+bool ResmedLoader::LoadBRP(Session *sess, EDFParser &edf)
 {
     QString t;
     sess->updateFirst(edf.startdate);
-    qint64 duration=edf.GetNumDataRecords()*edf.GetDuration();
-    sess->updateLast(edf.startdate+duration);
+    qint64 duration = edf.GetNumDataRecords() * edf.GetDuration();
+    sess->updateLast(edf.startdate + duration);
 
-    for (int s=0;s<edf.GetNumSignals();s++) {
+    for (int s = 0; s < edf.GetNumSignals(); s++) {
         EDFSignal &es = edf.edfsignals[s];
         //qDebug() << "BRP:" << es.digital_maximum << es.digital_minimum << es.physical_maximum << es.physical_minimum;
-        long recs=es.nr*edf.GetNumDataRecords();
+        long recs = es.nr * edf.GetNumDataRecords();
         ChannelID code;
-        if (es.label=="Flow") {
-            es.gain*=60.0;
-            es.physical_minimum*=60.0;
-            es.physical_maximum*=60.0;
-            es.physical_dimension="L/M";
-            code=CPAP_FlowRate;
+
+        if (es.label == "Flow") {
+            es.gain *= 60.0;
+            es.physical_minimum *= 60.0;
+            es.physical_maximum *= 60.0;
+            es.physical_dimension = "L/M";
+            code = CPAP_FlowRate;
         } else if (es.label.startsWith("Mask Pres")) {
-            code=CPAP_MaskPressureHi;
+            code = CPAP_MaskPressureHi;
         } else if (es.label.startsWith("Resp Event")) {
-            code=CPAP_RespEvent;
+            code = CPAP_RespEvent;
         } else {
             qDebug() << "Unobserved ResMed BRP Signal " << es.label;
             continue;
         }
-        double rate=double(duration)/double(recs);
-        EventList *a=sess->AddEventList(code,EVL_Waveform,es.gain,es.offset,0,0,rate);
+
+        double rate = double(duration) / double(recs);
+        EventList *a = sess->AddEventList(code, EVL_Waveform, es.gain, es.offset, 0, 0, rate);
         a->setDimension(es.physical_dimension);
-        a->AddWaveform(edf.startdate,es.data,recs,duration);
-        sess->setMin(code,a->Min());
-        sess->setMax(code,a->Max());
-        sess->setPhysMin(code,es.physical_minimum);
-        sess->setPhysMax(code,es.physical_maximum);
+        a->AddWaveform(edf.startdate, es.data, recs, duration);
+        sess->setMin(code, a->Min());
+        sess->setMax(code, a->Max());
+        sess->setPhysMin(code, es.physical_minimum);
+        sess->setPhysMax(code, es.physical_maximum);
     }
+
     return true;
 }
-void ResmedLoader::ToTimeDelta(Session *sess,EDFParser &edf, EDFSignal & es, ChannelID code, long recs, qint64 duration,EventDataType t_min,EventDataType t_max,bool square)
+void ResmedLoader::ToTimeDelta(Session *sess, EDFParser &edf, EDFSignal &es, ChannelID code,
+                               long recs, qint64 duration, EventDataType t_min, EventDataType t_max, bool square)
 {
-    if (t_min==t_max) {
-        t_min=es.physical_minimum;
-        t_max=es.physical_maximum;
+    if (t_min == t_max) {
+        t_min = es.physical_minimum;
+        t_max = es.physical_maximum;
     }
+
 #ifdef DEBUG_EFFICIENCY
     QElapsedTimer time;
     time.start();
 #endif
 
 
-    double rate=(duration/recs); // milliseconds per record
-    double tt=edf.startdate;
+    double rate = (duration / recs); // milliseconds per record
+    double tt = edf.startdate;
     //sess->UpdateFirst(tt);
-    EventStoreType c,last;
+    EventStoreType c, last;
 
-    int startpos=0;
+    int startpos = 0;
 
-    if ((code==CPAP_Pressure) || (code==CPAP_IPAP) || (code==CPAP_EPAP)) {
-        startpos=20; // Shave the first 20 seconds of pressure data
-        tt+=rate*startpos;
+    if ((code == CPAP_Pressure) || (code == CPAP_IPAP) || (code == CPAP_EPAP)) {
+        startpos = 20; // Shave the first 20 seconds of pressure data
+        tt += rate * startpos;
     }
-    qint16 * sptr=es.data;
-    qint16 * eptr=sptr+recs;
-    sptr+=startpos;
 
-    EventDataType min=t_max,max=t_min,tmp;
+    qint16 *sptr = es.data;
+    qint16 *eptr = sptr + recs;
+    sptr += startpos;
 
-    EventList *el=NULL;
-    if (recs>startpos+1) {
+    EventDataType min = t_max, max = t_min, tmp;
+
+    EventList *el = NULL;
+
+    if (recs > startpos + 1) {
 
         // Prime last with a good starting value
         do {
-            last=*sptr++;
-            tmp=EventDataType(last) * es.gain;
+            last = *sptr++;
+            tmp = EventDataType(last) * es.gain;
 
             if ((tmp >= t_min) && (tmp <= t_max)) {
-                min=tmp;
-                max=tmp;
-                el=sess->AddEventList(code,EVL_Event,es.gain,es.offset,0,0);
+                min = tmp;
+                max = tmp;
+                el = sess->AddEventList(code, EVL_Event, es.gain, es.offset, 0, 0);
 
-                el->AddEvent(tt,last);
-                tt+=rate;
+                el->AddEvent(tt, last);
+                tt += rate;
 
                 break;
             }
-            tt+=rate;
+
+            tt += rate;
 
         } while (sptr < eptr);
-        if (!el)
+
+        if (!el) {
             return;
+        }
 
         for (; sptr < eptr; sptr++) { //int i=startpos;i<recs;i++) {
-            c=*sptr; //es.data[i];
+            c = *sptr; //es.data[i];
 
-            if (last!=c) {
+            if (last != c) {
                 if (square) {
-                    tmp=EventDataType(last) * es.gain;
-                    if ((tmp >= t_min) && (tmp <= t_max)) {
-                        if (tmp < min)
-                            min=tmp;
-                        if (tmp > max)
-                            max=tmp;
+                    tmp = EventDataType(last) * es.gain;
 
-                        el->AddEvent(tt,last);
+                    if ((tmp >= t_min) && (tmp <= t_max)) {
+                        if (tmp < min) {
+                            min = tmp;
+                        }
+
+                        if (tmp > max) {
+                            max = tmp;
+                        }
+
+                        el->AddEvent(tt, last);
                     } else {
                         // Out of bounds value, start a new eventlist
-                        if (el->count()>1) {
+                        if (el->count() > 1) {
                             // that should be in session, not the eventlist.. handy for debugging though
                             el->setDimension(es.physical_dimension);
 
-                            el=sess->AddEventList(code,EVL_Event,es.gain,es.offset,0,0);
+                            el = sess->AddEventList(code, EVL_Event, es.gain, es.offset, 0, 0);
                         } else {
                             el->clear(); // reuse the object
                         }
                     }
                 }
-                tmp=EventDataType(c) * es.gain;
-                if ((tmp >= t_min) && (tmp <= t_max)) {
-                    if (tmp < min)
-                        min=tmp;
-                    if (tmp > max)
-                        max=tmp;
 
-                    el->AddEvent(tt,c);
+                tmp = EventDataType(c) * es.gain;
+
+                if ((tmp >= t_min) && (tmp <= t_max)) {
+                    if (tmp < min) {
+                        min = tmp;
+                    }
+
+                    if (tmp > max) {
+                        max = tmp;
+                    }
+
+                    el->AddEvent(tt, c);
                 } else {
-                    if (el->count()>1) {
+                    if (el->count() > 1) {
                         el->setDimension(es.physical_dimension);
 
                         // Create and attach new EventList
-                        el=sess->AddEventList(code,EVL_Event,es.gain,es.offset,0,0);
-                    } else el->clear();
+                        el = sess->AddEventList(code, EVL_Event, es.gain, es.offset, 0, 0);
+                    } else { el->clear(); }
                 }
             }
-            tt+=rate;
 
-            last=c;
+            tt += rate;
+
+            last = c;
         }
-        tmp=EventDataType(c) * es.gain;
+
+        tmp = EventDataType(c) * es.gain;
+
         if ((tmp >= t_min) && (tmp <= t_max)) {
-            el->AddEvent(tt,c);
+            el->AddEvent(tt, c);
         }
-        sess->setMin(code,min);
-        sess->setMax(code,max);
-        sess->setPhysMin(code,es.physical_minimum);
-        sess->setPhysMax(code,es.physical_maximum);
+
+        sess->setMin(code, min);
+        sess->setMax(code, max);
+        sess->setPhysMin(code, es.physical_minimum);
+        sess->setPhysMax(code, es.physical_maximum);
         sess->updateLast(tt);
     }
 
 #ifdef DEBUG_EFFICIENCY
-    qint64 t=time.nsecsElapsed();
-    int cnt=el->count();
-    int bytes=cnt * (sizeof(EventStoreType)+sizeof(quint32));
-    int wvbytes=recs * (sizeof(EventStoreType));
-    QHash<ChannelID,qint64>::iterator it=channel_efficiency.find(code);
-    if (it==channel_efficiency.end()) {
-       channel_efficiency[code]=wvbytes-bytes;
-       channel_time[code]=t;
+    qint64 t = time.nsecsElapsed();
+    int cnt = el->count();
+    int bytes = cnt * (sizeof(EventStoreType) + sizeof(quint32));
+    int wvbytes = recs * (sizeof(EventStoreType));
+    QHash<ChannelID, qint64>::iterator it = channel_efficiency.find(code);
+
+    if (it == channel_efficiency.end()) {
+        channel_efficiency[code] = wvbytes - bytes;
+        channel_time[code] = t;
     } else {
-        it.value()+=wvbytes-bytes;
-        channel_time[code]+=t;
+        it.value() += wvbytes - bytes;
+        channel_time[code] += t;
     }
+
 #endif
 
     //return el;
 }
-bool ResmedLoader::LoadSAD(Session *sess,EDFParser &edf)
+bool ResmedLoader::LoadSAD(Session *sess, EDFParser &edf)
 {
     QString t;
     sess->updateFirst(edf.startdate);
-    qint64 duration=edf.GetNumDataRecords()*edf.GetDuration();
-    sess->updateLast(edf.startdate+duration);
+    qint64 duration = edf.GetNumDataRecords() * edf.GetDuration();
+    sess->updateLast(edf.startdate + duration);
 
-    for (int s=0;s<edf.GetNumSignals();s++) {
+    for (int s = 0; s < edf.GetNumSignals(); s++) {
         EDFSignal &es = edf.edfsignals[s];
         //qDebug() << "SAD:" << es.label << es.digital_maximum << es.digital_minimum << es.physical_maximum << es.physical_minimum;
-        long recs=es.nr*edf.GetNumDataRecords();
+        long recs = es.nr * edf.GetNumDataRecords();
         ChannelID code;
+
         if (es.label.startsWith("Puls")) {
-            code=OXI_Pulse;
-        } else if (es.label=="SpO2") {
-            code=OXI_SPO2;
+            code = OXI_Pulse;
+        } else if (es.label == "SpO2") {
+            code = OXI_SPO2;
         } else {
             qDebug() << "Unobserved ResMed SAD Signal " << es.label;
             continue;
         }
-        bool hasdata=false;
-        for (int i=0;i<recs;i++) {
-            if (es.data[i]!=-1) {
-                hasdata=true;
+
+        bool hasdata = false;
+
+        for (int i = 0; i < recs; i++) {
+            if (es.data[i] != -1) {
+                hasdata = true;
                 break;
             }
         }
+
         if (hasdata) {
-            if (code==OXI_Pulse) {
-                ToTimeDelta(sess,edf,es, code,recs,duration);
-                sess->setPhysMax(code,180);
-                sess->setPhysMin(code,18);
-            } else if (code==OXI_SPO2) {
-                es.physical_minimum=60;
-                ToTimeDelta(sess,edf,es, code,recs,duration);
-                sess->setPhysMax(code,100);
-                sess->setPhysMin(code,60);
+            if (code == OXI_Pulse) {
+                ToTimeDelta(sess, edf, es, code, recs, duration);
+                sess->setPhysMax(code, 180);
+                sess->setPhysMin(code, 18);
+            } else if (code == OXI_SPO2) {
+                es.physical_minimum = 60;
+                ToTimeDelta(sess, edf, es, code, recs, duration);
+                sess->setPhysMax(code, 100);
+                sess->setPhysMin(code, 60);
             }
         }
 
     }
+
     return true;
 }
 
 
-bool ResmedLoader::LoadPLD(Session *sess,EDFParser &edf)
+bool ResmedLoader::LoadPLD(Session *sess, EDFParser &edf)
 {
     // Is it save to assume the order does not change here?
-    enum PLDType { MaskPres=0, TherapyPres, ExpPress, Leak, RR, Vt, Mv, SnoreIndex, FFLIndex, U1, U2 };
+    enum PLDType { MaskPres = 0, TherapyPres, ExpPress, Leak, RR, Vt, Mv, SnoreIndex, FFLIndex, U1, U2 };
 
-    qint64 duration=edf.GetNumDataRecords()*edf.GetDuration();
+    qint64 duration = edf.GetNumDataRecords() * edf.GetDuration();
     sess->updateFirst(edf.startdate);
-    sess->updateLast(edf.startdate+duration);
+    sess->updateLast(edf.startdate + duration);
     QString t;
-    int emptycnt=0;
-    EventList *a=NULL;
+    int emptycnt = 0;
+    EventList *a = NULL;
     double rate;
     long recs;
     ChannelID code;
-    for (int s=0;s<edf.GetNumSignals();s++) {
-        a=NULL;
+
+    for (int s = 0; s < edf.GetNumSignals(); s++) {
+        a = NULL;
         EDFSignal &es = edf.edfsignals[s];
-        recs=es.nr*edf.GetNumDataRecords();
-        if (recs<=0) continue;
-        rate=double(duration)/double(recs);
+        recs = es.nr * edf.GetNumDataRecords();
+
+        if (recs <= 0) { continue; }
+
+        rate = double(duration) / double(recs);
+
         //qDebug() << "EVE:" << es.digital_maximum << es.digital_minimum << es.physical_maximum << es.physical_minimum << es.gain;
-        if (es.label=="Snore Index") {
-            code=CPAP_Snore;
-            ToTimeDelta(sess,edf,es, code,recs,duration,es.digital_maximum);
+        if (es.label == "Snore Index") {
+            code = CPAP_Snore;
+            ToTimeDelta(sess, edf, es, code, recs, duration, es.digital_maximum);
         } else if (es.label.startsWith("Therapy Pres")) {
-            code=CPAP_Pressure; //TherapyPressure;
-            es.physical_maximum=25;
-            es.physical_minimum=4;
-            ToTimeDelta(sess,edf,es, code,recs,duration,0,0);
-        } else if (es.label=="Insp Pressure") {
-            code=CPAP_IPAP;
-            sess->settings[CPAP_Mode]=MODE_BIPAP;
-            es.physical_maximum=25;
-            es.physical_minimum=4;
-            ToTimeDelta(sess,edf,es, code,recs,duration,0,0);
-        } else if ((es.label=="MV") || (es.label=="VM")){
-            code=CPAP_MinuteVent;
-            ToTimeDelta(sess,edf,es, code,recs,duration,0,0);
-        } else if ((es.label=="RR") || (es.label=="AF") || (es.label=="FR")) {
-            code=CPAP_RespRate;
-            a=sess->AddEventList(code,EVL_Waveform,es.gain,es.offset,0,0,rate);
-            a->AddWaveform(edf.startdate,es.data,recs,duration);
-        } else if ((es.label=="Vt") || (es.label=="VC")) {
-            code=CPAP_TidalVolume;
-            es.gain*=1000.0;
-            es.physical_maximum*=1000.0;
-            es.physical_minimum*=1000.0;
-//            es.digital_maximum*=1000.0;
-//            es.digital_minimum*=1000.0;
-            ToTimeDelta(sess,edf,es, code,recs,duration,0,0);
-        } else if ((es.label=="Leak") || (es.label.startsWith("Leck")) || (es.label.startsWith("Lekk")) || (es.label.startsWith("Läck")) || es.label.startsWith("Läck")) {
-            code=CPAP_Leak;
-            es.gain*=60;
-            es.physical_maximum*=60;
-            es.physical_minimum*=60;
-//            es.digital_maximum*=60.0;
-//            es.digital_minimum*=60.0;
-            es.physical_dimension="L/M";
-            ToTimeDelta(sess,edf,es, code,recs,duration,0,0,true);
-            sess->setPhysMax(code,120.0);
-            sess->setPhysMin(code,0);
-        } else if (es.label=="FFL Index") {
-            code=CPAP_FLG;
-            ToTimeDelta(sess,edf,es, code,recs,duration,0,0);
+            code = CPAP_Pressure; //TherapyPressure;
+            es.physical_maximum = 25;
+            es.physical_minimum = 4;
+            ToTimeDelta(sess, edf, es, code, recs, duration, 0, 0);
+        } else if (es.label == "Insp Pressure") {
+            code = CPAP_IPAP;
+            sess->settings[CPAP_Mode] = MODE_BIPAP;
+            es.physical_maximum = 25;
+            es.physical_minimum = 4;
+            ToTimeDelta(sess, edf, es, code, recs, duration, 0, 0);
+        } else if ((es.label == "MV") || (es.label == "VM")) {
+            code = CPAP_MinuteVent;
+            ToTimeDelta(sess, edf, es, code, recs, duration, 0, 0);
+        } else if ((es.label == "RR") || (es.label == "AF") || (es.label == "FR")) {
+            code = CPAP_RespRate;
+            a = sess->AddEventList(code, EVL_Waveform, es.gain, es.offset, 0, 0, rate);
+            a->AddWaveform(edf.startdate, es.data, recs, duration);
+        } else if ((es.label == "Vt") || (es.label == "VC")) {
+            code = CPAP_TidalVolume;
+            es.gain *= 1000.0;
+            es.physical_maximum *= 1000.0;
+            es.physical_minimum *= 1000.0;
+            //            es.digital_maximum*=1000.0;
+            //            es.digital_minimum*=1000.0;
+            ToTimeDelta(sess, edf, es, code, recs, duration, 0, 0);
+        } else if ((es.label == "Leak") || (es.label.startsWith("Leck")) || (es.label.startsWith("Lekk"))
+                   || (es.label.startsWith("Läck")) || es.label.startsWith("Läck")) {
+            code = CPAP_Leak;
+            es.gain *= 60;
+            es.physical_maximum *= 60;
+            es.physical_minimum *= 60;
+            //            es.digital_maximum*=60.0;
+            //            es.digital_minimum*=60.0;
+            es.physical_dimension = "L/M";
+            ToTimeDelta(sess, edf, es, code, recs, duration, 0, 0, true);
+            sess->setPhysMax(code, 120.0);
+            sess->setPhysMin(code, 0);
+        } else if (es.label == "FFL Index") {
+            code = CPAP_FLG;
+            ToTimeDelta(sess, edf, es, code, recs, duration, 0, 0);
         } else if (es.label.startsWith("Mask Pres")) {
-            code=CPAP_MaskPressure;
-            es.physical_maximum=25;
-            es.physical_minimum=4;
+            code = CPAP_MaskPressure;
+            es.physical_maximum = 25;
+            es.physical_minimum = 4;
 
-            ToTimeDelta(sess,edf,es, code,recs,duration,0,0);
+            ToTimeDelta(sess, edf, es, code, recs, duration, 0, 0);
         } else if (es.label.startsWith("Exp Press")) {
-            code=CPAP_EPAP;//ExpiratoryPressure
-            es.physical_maximum=25;
-            es.physical_minimum=4;
+            code = CPAP_EPAP; //ExpiratoryPressure
+            es.physical_maximum = 25;
+            es.physical_minimum = 4;
 
-            ToTimeDelta(sess,edf,es, code,recs,duration,0,0);
+            ToTimeDelta(sess, edf, es, code, recs, duration, 0, 0);
         } else if (es.label.startsWith("I:E")) {
-            code=CPAP_IE;//I:E ratio?
-            a=sess->AddEventList(code,EVL_Waveform,es.gain,es.offset,0,0,rate);
-            a->AddWaveform(edf.startdate,es.data,recs,duration);
+            code = CPAP_IE; //I:E ratio?
+            a = sess->AddEventList(code, EVL_Waveform, es.gain, es.offset, 0, 0, rate);
+            a->AddWaveform(edf.startdate, es.data, recs, duration);
             //a=ToTimeDelta(sess,edf,es, code,recs,duration,0,0);
         } else if (es.label.startsWith("Ti")) {
-            code=CPAP_Ti;
-            a=sess->AddEventList(code,EVL_Waveform,es.gain,es.offset,0,0,rate);
-            a->AddWaveform(edf.startdate,es.data,recs,duration);
+            code = CPAP_Ti;
+            a = sess->AddEventList(code, EVL_Waveform, es.gain, es.offset, 0, 0, rate);
+            a->AddWaveform(edf.startdate, es.data, recs, duration);
             //a=ToTimeDelta(sess,edf,es, code,recs,duration,0,0);
         } else if (es.label.startsWith("Te")) {
-            code=CPAP_Te;
-            a=sess->AddEventList(code,EVL_Waveform,es.gain,es.offset,0,0,rate);
-            a->AddWaveform(edf.startdate,es.data,recs,duration);
+            code = CPAP_Te;
+            a = sess->AddEventList(code, EVL_Waveform, es.gain, es.offset, 0, 0, rate);
+            a->AddWaveform(edf.startdate, es.data, recs, duration);
             //a=ToTimeDelta(sess,edf,es, code,recs,duration,0,0);
         } else if (es.label.startsWith("TgMV")) {
-            code=CPAP_TgMV;
-            a=sess->AddEventList(code,EVL_Waveform,es.gain,es.offset,0,0,rate);
-            a->AddWaveform(edf.startdate,es.data,recs,duration);
+            code = CPAP_TgMV;
+            a = sess->AddEventList(code, EVL_Waveform, es.gain, es.offset, 0, 0, rate);
+            a->AddWaveform(edf.startdate, es.data, recs, duration);
             //a=ToTimeDelta(sess,edf,es, code,recs,duration,0,0);
-        } else if (es.label=="") {
-            if (emptycnt==0) {
-                code=RMS9_E01;
-                ToTimeDelta(sess,edf,es, code,recs,duration);
-            } else if (emptycnt==1) {
-                code=RMS9_E02;
-                ToTimeDelta(sess,edf,es, code,recs,duration);
+        } else if (es.label == "") {
+            if (emptycnt == 0) {
+                code = RMS9_E01;
+                ToTimeDelta(sess, edf, es, code, recs, duration);
+            } else if (emptycnt == 1) {
+                code = RMS9_E02;
+                ToTimeDelta(sess, edf, es, code, recs, duration);
             } else {
                 qDebug() << "Unobserved Empty Signal " << es.label;
             }
+
             emptycnt++;
         } else {
             qDebug() << "Unobserved ResMed PLD Signal " << es.label;
-            a=NULL;
+            a = NULL;
         }
+
         if (a) {
-            sess->setMin(code,a->Min());
-            sess->setMax(code,a->Max());
-            sess->setPhysMin(code,es.physical_minimum);
-            sess->setPhysMax(code,es.physical_maximum);
+            sess->setMin(code, a->Min());
+            sess->setMax(code, a->Max());
+            sess->setPhysMin(code, es.physical_minimum);
+            sess->setPhysMax(code, es.physical_maximum);
             a->setDimension(es.physical_dimension);
         }
     }
+
     return true;
 }
 
-const QString RMS9_STR_Escape="S9 Escape";
-const QString RMS9_STR_EscapeAuto="S9 Escape Auto";
-const QString RMS9_STR_Elite="S9 Elite";
-const QString RMS9_STR_AutoSet="S9 AutoSet";
-const QString RMS9_STR_AutoSetForHer="S9 AutoSet for Her";
-const QString RMS9_STR_AutoSetCS="S9 AutoSet CS";
-const QString RMS9_STR_AutoSet25="S9 AutoSet 25";
-const QString RMS9_STR_VPAP_S="S9 VPAP S";
-const QString RMS9_STR_VPAP_Auto="S9 VPAP Auto";
-const QString RMS9_STR_VPAP_Adapt="S9 VPAP Adapt";
-const QString RMS9_STR_VPAP_ST="S9 VPAP ST";
-const QString RMS9_STR_VPAP_STA="S9 VPAP ST-A";
-const QString RMS9_STR_VPAP_ST22="S9 VPAP ST 22";
+const QString RMS9_STR_Escape = "S9 Escape";
+const QString RMS9_STR_EscapeAuto = "S9 Escape Auto";
+const QString RMS9_STR_Elite = "S9 Elite";
+const QString RMS9_STR_AutoSet = "S9 AutoSet";
+const QString RMS9_STR_AutoSetForHer = "S9 AutoSet for Her";
+const QString RMS9_STR_AutoSetCS = "S9 AutoSet CS";
+const QString RMS9_STR_AutoSet25 = "S9 AutoSet 25";
+const QString RMS9_STR_VPAP_S = "S9 VPAP S";
+const QString RMS9_STR_VPAP_Auto = "S9 VPAP Auto";
+const QString RMS9_STR_VPAP_Adapt = "S9 VPAP Adapt";
+const QString RMS9_STR_VPAP_ST = "S9 VPAP ST";
+const QString RMS9_STR_VPAP_STA = "S9 VPAP ST-A";
+const QString RMS9_STR_VPAP_ST22 = "S9 VPAP ST 22";
 
 void ResInitModelMap()
 {
     // Escape Series
-    RMS9ModelMap[36001]=RMS9ModelMap[36011]=RMS9ModelMap[36021]=RMS9ModelMap[36141]=
-    RMS9ModelMap[36201]=RMS9ModelMap[36221]=RMS9ModelMap[36261]=RMS9ModelMap[36301]=
-    RMS9ModelMap[36361]=RMS9_STR_Escape;
+    RMS9ModelMap[36001] = RMS9ModelMap[36011] = RMS9ModelMap[36021] = RMS9ModelMap[36141] =
+                              RMS9ModelMap[36201] = RMS9ModelMap[36221] = RMS9ModelMap[36261] = RMS9ModelMap[36301] =
+                                          RMS9ModelMap[36361] = RMS9_STR_Escape;
 
     // Escape Auto Series
-    RMS9ModelMap[36002]=RMS9ModelMap[36012]=RMS9ModelMap[36022]=RMS9ModelMap[36302]=
-    RMS9ModelMap[36362]=RMS9_STR_EscapeAuto;
+    RMS9ModelMap[36002] = RMS9ModelMap[36012] = RMS9ModelMap[36022] = RMS9ModelMap[36302] =
+                              RMS9ModelMap[36362] = RMS9_STR_EscapeAuto;
 
     // Elite Series
-    RMS9ModelMap[36003]=RMS9ModelMap[36013]=RMS9ModelMap[36023]=RMS9ModelMap[36103]=
-    RMS9ModelMap[36113]=RMS9ModelMap[36123]=RMS9ModelMap[36143]=RMS9ModelMap[36203]=
-    RMS9ModelMap[36223]=RMS9ModelMap[36243]=RMS9ModelMap[36263]=RMS9ModelMap[36303]=
-    RMS9ModelMap[36343]=RMS9ModelMap[36363]=RMS9_STR_Elite;
+    RMS9ModelMap[36003] = RMS9ModelMap[36013] = RMS9ModelMap[36023] = RMS9ModelMap[36103] =
+                              RMS9ModelMap[36113] = RMS9ModelMap[36123] = RMS9ModelMap[36143] = RMS9ModelMap[36203] =
+                                          RMS9ModelMap[36223] = RMS9ModelMap[36243] = RMS9ModelMap[36263] = RMS9ModelMap[36303] =
+                                                  RMS9ModelMap[36343] = RMS9ModelMap[36363] = RMS9_STR_Elite;
 
     // AutoSet Series
-    RMS9ModelMap[36005]=RMS9ModelMap[36015]=RMS9ModelMap[36025]=RMS9ModelMap[36105]=
-    RMS9ModelMap[36115]=RMS9ModelMap[36125]=RMS9ModelMap[36145]=RMS9ModelMap[36205]=
-    RMS9ModelMap[36225]=RMS9ModelMap[36245]=RMS9ModelMap[36265]=RMS9ModelMap[36305]=
-    RMS9ModelMap[36325]=RMS9ModelMap[36345]=RMS9ModelMap[36365]=RMS9_STR_AutoSet;
+    RMS9ModelMap[36005] = RMS9ModelMap[36015] = RMS9ModelMap[36025] = RMS9ModelMap[36105] =
+                              RMS9ModelMap[36115] = RMS9ModelMap[36125] = RMS9ModelMap[36145] = RMS9ModelMap[36205] =
+                                          RMS9ModelMap[36225] = RMS9ModelMap[36245] = RMS9ModelMap[36265] = RMS9ModelMap[36305] =
+                                                  RMS9ModelMap[36325] = RMS9ModelMap[36345] = RMS9ModelMap[36365] = RMS9_STR_AutoSet;
 
     // AutoSet CS Series
-    RMS9ModelMap[36100]=RMS9ModelMap[36110]=RMS9ModelMap[36120]=RMS9ModelMap[36140]=
-    RMS9ModelMap[36200]=RMS9ModelMap[36220]=RMS9ModelMap[36360]=RMS9_STR_AutoSetCS;
+    RMS9ModelMap[36100] = RMS9ModelMap[36110] = RMS9ModelMap[36120] = RMS9ModelMap[36140] =
+                              RMS9ModelMap[36200] = RMS9ModelMap[36220] = RMS9ModelMap[36360] = RMS9_STR_AutoSetCS;
 
     // AutoSet 25 Series
-    RMS9ModelMap[36106]=RMS9ModelMap[36116]=RMS9ModelMap[36126]=RMS9ModelMap[36146]=
-    RMS9ModelMap[36206]=RMS9ModelMap[36226]=RMS9ModelMap[36366]=RMS9_STR_AutoSet25;
+    RMS9ModelMap[36106] = RMS9ModelMap[36116] = RMS9ModelMap[36126] = RMS9ModelMap[36146] =
+                              RMS9ModelMap[36206] = RMS9ModelMap[36226] = RMS9ModelMap[36366] = RMS9_STR_AutoSet25;
 
     // Girly "For Her" AutoSet Series
-    RMS9ModelMap[36065]=RMS9_STR_AutoSetForHer;
+    RMS9ModelMap[36065] = RMS9_STR_AutoSetForHer;
 
     // VPAP S Series (+H5i +Climate Control)
-    RMS9ModelMap[36004]=RMS9ModelMap[36014]=RMS9ModelMap[36024]=RMS9ModelMap[36114]=
-    RMS9ModelMap[36124]=RMS9ModelMap[36144]=RMS9ModelMap[36204]=RMS9ModelMap[36224]=
-    RMS9ModelMap[36284]=RMS9ModelMap[36304]=RMS9_STR_VPAP_S;
+    RMS9ModelMap[36004] = RMS9ModelMap[36014] = RMS9ModelMap[36024] = RMS9ModelMap[36114] =
+                              RMS9ModelMap[36124] = RMS9ModelMap[36144] = RMS9ModelMap[36204] = RMS9ModelMap[36224] =
+                                          RMS9ModelMap[36284] = RMS9ModelMap[36304] = RMS9_STR_VPAP_S;
 
     // VPAP Auto Series (+H5i +Climate Control)
-    RMS9ModelMap[36006]=RMS9ModelMap[36016]=RMS9ModelMap[36026]=RMS9_STR_VPAP_Auto;
+    RMS9ModelMap[36006] = RMS9ModelMap[36016] = RMS9ModelMap[36026] = RMS9_STR_VPAP_Auto;
 
 
     // VPAP Adapt Series (+H5i +Climate Control)
     // Trev's 36037 supports variable EPAP...
-    RMS9ModelMap[36037]=RMS9ModelMap[36007]=RMS9ModelMap[36017]=RMS9ModelMap[36027]=RMS9ModelMap[36367]=RMS9_STR_VPAP_Adapt;
+    RMS9ModelMap[36037] = RMS9ModelMap[36007] = RMS9ModelMap[36017] = RMS9ModelMap[36027] =
+                              RMS9ModelMap[36367] = RMS9_STR_VPAP_Adapt;
 
     // VPAP ST Series (+H5i +Climate Control)
-    RMS9ModelMap[36008]=RMS9ModelMap[36018]=RMS9ModelMap[36028]=RMS9ModelMap[36108]=
-    RMS9ModelMap[36148]=RMS9ModelMap[36208]=RMS9ModelMap[36228]=RMS9ModelMap[36368]=RMS9_STR_VPAP_ST;
+    RMS9ModelMap[36008] = RMS9ModelMap[36018] = RMS9ModelMap[36028] = RMS9ModelMap[36108] =
+                              RMS9ModelMap[36148] = RMS9ModelMap[36208] = RMS9ModelMap[36228] = RMS9ModelMap[36368] =
+                                          RMS9_STR_VPAP_ST;
 
     // VPAP ST 22 Series
-    RMS9ModelMap[36118]=RMS9ModelMap[36128]=RMS9_STR_VPAP_ST22;
+    RMS9ModelMap[36118] = RMS9ModelMap[36128] = RMS9_STR_VPAP_ST22;
 
     // VPAP ST-A Series
-    RMS9ModelMap[36039]=RMS9ModelMap[36159]=RMS9ModelMap[36169]=RMS9ModelMap[36379]=RMS9_STR_VPAP_STA;
+    RMS9ModelMap[36039] = RMS9ModelMap[36159] = RMS9ModelMap[36169] = RMS9ModelMap[36379] =
+                              RMS9_STR_VPAP_STA;
 
 
     //    36003, 36013, 36023, 36103, 36113, 36123, 36143, 36203,
@@ -2258,35 +2454,35 @@ void ResInitModelMap()
     //    36284, 36304 S9 VPAP S (+ H5i, + Climate Control)
     //    36006, 36016, 36026 S9 VPAP AUTO (+ H5i, + Climate Control)
 
-//    36007, 36017, 36027, 36367
-//    S9 VPAP ADAPT (+ H5i, + Climate
-//    Control)
-//    36008, 36018, 36028, 36108, 36148, 36208, 36228, 36368 S9 VPAP ST (+ H5i, + Climate Control)
-//    36100, 36110, 36120, 36140, 36200, 36220, 36360 S9 AUTOSET CS
-//    36106, 36116, 36126, 36146, 36206, 36226, 36366 S9 AUTOSET 25
-//    36118, 36128 S9 VPAP ST 22
-//    36039, 36159, 36169, 36379 S9 VPAP ST-A
-//    24921, 24923, 24925, 24926, 24927 ResMed Power Station II (RPSII)
-//    33030 S8 Compact
-//    33001, 33007, 33013, 33036, 33060 S8 Escape
-//    33032 S8 Lightweight
-//    33033 S8 AutoScore
-//    33048, 33051, 33052, 33053, 33054, 33061 S8 Escape II
-//    33055 S8 Lightweight II
-//    33021 S8 Elite
-//    33039, 33045, 33062, 33072, 33073, 33074, 33075 S8 Elite II
-//    33044 S8 AutoScore II
-//    33105, 33112, 33126 S8 AutoSet (including Spirit & Vantage)
-//    33128, 33137 S8 Respond
-//    33129, 33141, 33150 S8 AutoSet II
-//    33136, 33143, 33144, 33145, 33146, 33147, 33148 S8 AutoSet Spirit II
-//    33138 S8 AutoSet C
-//    26101, 26121 VPAP Auto 25
-//    26119, 26120 VPAP S
-//    26110, 26122 VPAP ST
-//    26104, 26105, 26125, 26126 S8 Auto 25
-//    26102, 26103, 26106, 26107, 26108, 26109, 26123, 26127 VPAP IV
-//    26112, 26113, 26114, 26115, 26116, 26117, 26118, 26124 VPAP IV ST
+    //    36007, 36017, 36027, 36367
+    //    S9 VPAP ADAPT (+ H5i, + Climate
+    //    Control)
+    //    36008, 36018, 36028, 36108, 36148, 36208, 36228, 36368 S9 VPAP ST (+ H5i, + Climate Control)
+    //    36100, 36110, 36120, 36140, 36200, 36220, 36360 S9 AUTOSET CS
+    //    36106, 36116, 36126, 36146, 36206, 36226, 36366 S9 AUTOSET 25
+    //    36118, 36128 S9 VPAP ST 22
+    //    36039, 36159, 36169, 36379 S9 VPAP ST-A
+    //    24921, 24923, 24925, 24926, 24927 ResMed Power Station II (RPSII)
+    //    33030 S8 Compact
+    //    33001, 33007, 33013, 33036, 33060 S8 Escape
+    //    33032 S8 Lightweight
+    //    33033 S8 AutoScore
+    //    33048, 33051, 33052, 33053, 33054, 33061 S8 Escape II
+    //    33055 S8 Lightweight II
+    //    33021 S8 Elite
+    //    33039, 33045, 33062, 33072, 33073, 33074, 33075 S8 Elite II
+    //    33044 S8 AutoScore II
+    //    33105, 33112, 33126 S8 AutoSet (including Spirit & Vantage)
+    //    33128, 33137 S8 Respond
+    //    33129, 33141, 33150 S8 AutoSet II
+    //    33136, 33143, 33144, 33145, 33146, 33147, 33148 S8 AutoSet Spirit II
+    //    33138 S8 AutoSet C
+    //    26101, 26121 VPAP Auto 25
+    //    26119, 26120 VPAP S
+    //    26110, 26122 VPAP ST
+    //    26104, 26105, 26125, 26126 S8 Auto 25
+    //    26102, 26103, 26106, 26107, 26108, 26109, 26123, 26127 VPAP IV
+    //    26112, 26113, 26114, 26115, 26116, 26117, 26118, 26124 VPAP IV ST
 
 
     /* S8 Series
@@ -2350,7 +2546,7 @@ void ResInitModelMap()
 
     resmed_codes[CPAP_Mode].push_back("Mode");
     resmed_codes[CPAP_Mode].push_back("Modus"); // Dutch & German
-    resmed_codes[CPAP_Mode].push_back("Funktion"); // Swedish 
+    resmed_codes[CPAP_Mode].push_back("Funktion"); // Swedish
 
     resmed_codes[RMS9_SetPressure].push_back("Eingest. Druck");    // German
     resmed_codes[RMS9_SetPressure].push_back("Ingestelde druk");   // Dutch
@@ -2384,13 +2580,14 @@ void ResInitModelMap()
 }
 
 
-bool resmed_initialized=false;
+bool resmed_initialized = false;
 void ResmedLoader::Register()
 {
-    if (resmed_initialized) return;
+    if (resmed_initialized) { return; }
+
     qDebug() << "Registering ResmedLoader";
     RegisterLoader(new ResmedLoader());
     ResInitModelMap();
-    resmed_initialized=true;
+    resmed_initialized = true;
 }
 
diff --git a/sleepyhead/SleepLib/loader_plugins/resmed_loader.h b/sleepyhead/SleepLib/loader_plugins/resmed_loader.h
index 87d40a94..2d845272 100644
--- a/sleepyhead/SleepLib/loader_plugins/resmed_loader.h
+++ b/sleepyhead/SleepLib/loader_plugins/resmed_loader.h
@@ -23,12 +23,12 @@
 //********************************************************************************************
 // Please INCREMENT the following value when making changes to this loaders implementation.
 //
-const int resmed_data_version=6;
+const int resmed_data_version = 6;
 //
 //********************************************************************************************
 
 
-const QString resmed_class_name=STR_MACH_ResMed;
+const QString resmed_class_name = STR_MACH_ResMed;
 
 /*! \struct EDFHeader
     \brief  Represents the EDF+ header structure, used as a place holder while processing the text data.
@@ -46,18 +46,18 @@ struct EDFHeader {
     char num_signals[4];
 }
 #ifndef BUILD_WITH_MSVC
-__attribute__ ((packed))
+__attribute__((packed))
 #endif
 ;
 
-const int EDFHeaderSize=sizeof(EDFHeader);
+const int EDFHeaderSize = sizeof(EDFHeader);
 
 /*! \struct EDFSignal
     \brief Contains information about a single EDF+ Signal
     \note More information on the EDF+ file format can be obtained from http://edfplus.info
     */
 struct EDFSignal {
-public:
+  public:
     //! \brief Name of this Signal
     QString label;
 
@@ -95,7 +95,7 @@ public:
     QString reserved;
 
     //! \brief Pointer to the signals sample data
-    qint16 * data;
+    qint16 *data;
 
     //! \brief a non-EDF extra used internally to count the signal data
     int pos;
@@ -108,9 +108,9 @@ public:
     */
 class EDFParser
 {
-public:
+  public:
     //! \brief Constructs an EDFParser object, opening the filename if one supplied
-    EDFParser(QString filename="");
+    EDFParser(QString filename = "");
 
     ~EDFParser();
 
@@ -127,11 +127,11 @@ public:
     QVector<EDFSignal> edfsignals;
 
     //! \brief An by-name indexed into the EDFSignal data
-    QHash<QString,EDFSignal *> lookup;
+    QHash<QString, EDFSignal *> lookup;
 
     //! \brief Look up signal names by SleepLib ChannelID.. A little "ResMed"ified.. :/
-    EDFSignal * lookupSignal(ChannelID);
-    EDFSignal * lookupName(QString name);
+    EDFSignal *lookupSignal(ChannelID);
+    EDFSignal *lookupName(QString name);
 
     //! \brief Returns the number of signals contained in this EDF file
     long GetNumSignals() { return num_signals; }
@@ -176,52 +176,53 @@ public:
     */
 class ResmedLoader : public MachineLoader
 {
-public:
+  public:
     ResmedLoader();
     virtual ~ResmedLoader();
 
     //! \brief Scans for S9 SD folder structure signature, and loads any new data if found
-    virtual int Open(QString & path,Profile *profile);
+    virtual int Open(QString &path, Profile *profile);
 
     //! \brief Returns the version number of this ResMed loader
     virtual int Version() { return resmed_data_version; }
 
     //! \brief Returns the Machine class name of this loader. ("ResMed")
-    virtual const QString & ClassName() { return resmed_class_name; }
+    virtual const QString &ClassName() { return resmed_class_name; }
 
     //! \brief Converts EDFSignal data to time delta packed EventList, and adds to Session
-    void ToTimeDelta(Session *sess,EDFParser &edf, EDFSignal & es, ChannelID code, long recs,qint64 duration,EventDataType min=0,EventDataType max=0,bool square=false);
+    void ToTimeDelta(Session *sess, EDFParser &edf, EDFSignal &es, ChannelID code, long recs,
+                     qint64 duration, EventDataType min = 0, EventDataType max = 0, bool square = false);
 
     //! \brief Create Machine record, and index it by serial number
-    Machine *CreateMachine(QString serial,Profile *profile);
+    Machine *CreateMachine(QString serial, Profile *profile);
 
     //! \brief Register the ResmedLoader with the list of other machine loaders
     static void Register();
-protected:
-    QHash<QString,Machine *> ResmedList;
+  protected:
+    QHash<QString, Machine *> ResmedList;
 
     //! \brief Parse the EVE Event annotation data, and save to Session * sess
     //! This contains all Hypopnea, Obstructive Apnea, Central and Apnea codes
-    bool LoadEVE(Session *sess,EDFParser &edf);
+    bool LoadEVE(Session *sess, EDFParser &edf);
 
     //! \brief Parse the BRP High Resolution data, and save to Session * sess
     //! This contains Flow Rate, Mask Pressure, and Resp. Event  data
-    bool LoadBRP(Session *sess,EDFParser &edf);
+    bool LoadBRP(Session *sess, EDFParser &edf);
 
     //! \brief Parse the SAD Pulse oximetry attachment data, and save to Session * sess
     //! This contains Pulse Rate and SpO2 Oxygen saturation data
-    bool LoadSAD(Session *sess,EDFParser &edf);
+    bool LoadSAD(Session *sess, EDFParser &edf);
 
     //! \brief Parse the PRD low resolution data, and save to Session * sess
     //! This contains the Pressure, Leak, Respiratory Rate, Minute Ventilation, Tidal Volume, etc..
-    bool LoadPLD(Session *sess,EDFParser &edf);
+    bool LoadPLD(Session *sess, EDFParser &edf);
 
-    QString backup(QString file, QString backup_path, bool compress=false);
+    QString backup(QString file, QString backup_path, bool compress = false);
 
-    QMap<SessionID,QStringList> sessfiles;
+    QMap<SessionID, QStringList> sessfiles;
 #ifdef DEBUG_EFFICIENCY
-    QHash<ChannelID,qint64> channel_efficiency;
-    QHash<ChannelID,qint64> channel_time;
+    QHash<ChannelID, qint64> channel_efficiency;
+    QHash<ChannelID, qint64> channel_time;
 #endif
 };
 
diff --git a/sleepyhead/SleepLib/loader_plugins/somnopose_loader.cpp b/sleepyhead/SleepLib/loader_plugins/somnopose_loader.cpp
index 7474c4b5..5c7b7aef 100644
--- a/sleepyhead/SleepLib/loader_plugins/somnopose_loader.cpp
+++ b/sleepyhead/SleepLib/loader_plugins/somnopose_loader.cpp
@@ -30,24 +30,24 @@ SomnoposeLoader::~SomnoposeLoader()
 {
     //dtor
 }
-int SomnoposeLoader::Open(QString & path,Profile *profile)
+int SomnoposeLoader::Open(QString &path, Profile *profile)
 {
     Q_UNUSED(path)
     Q_UNUSED(profile)
 
     QString newpath;
 
-    QString dirtag="somnopose";
+    QString dirtag = "somnopose";
 
     // Could Scan the ZEO folder for a list of CSVs
 
-    path=path.replace("\\","/");
+    path = path.replace("\\", "/");
 
-    if (path.toLower().endsWith("/"+dirtag)) {
+    if (path.toLower().endsWith("/" + dirtag)) {
         return 0;
         //newpath=path;
     } else {
-        newpath=path+"/"+dirtag.toUpper();
+        newpath = path + "/" + dirtag.toUpper();
     }
 
     //QString filename;
@@ -58,13 +58,14 @@ int SomnoposeLoader::Open(QString & path,Profile *profile)
 }
 Machine *SomnoposeLoader::CreateMachine(Profile *profile)
 {
-    if (!profile)
+    if (!profile) {
         return NULL;
+    }
 
-    QList<Machine *> ml=profile->GetMachines(MT_POSITION);
+    QList<Machine *> ml = profile->GetMachines(MT_POSITION);
 
-    for (QList<Machine *>::iterator i=ml.begin(); i!=ml.end(); i++) {
-        if ((*i)->GetClass()==somnopose_class_name)  {
+    for (QList<Machine *>::iterator i = ml.begin(); i != ml.end(); i++) {
+        if ((*i)->GetClass() == somnopose_class_name)  {
             return (*i);
             break;
         }
@@ -72,18 +73,18 @@ Machine *SomnoposeLoader::CreateMachine(Profile *profile)
 
     qDebug("Create Somnopose Machine Record");
 
-    Machine *m=new PositionSensor(profile,0);
+    Machine *m = new PositionSensor(profile, 0);
     m->SetType(MT_POSITION);
     m->SetClass(somnopose_class_name);
-    m->properties[STR_PROP_Brand]="Somnopose";
-    m->properties[STR_PROP_Model]="Somnopose Position Data";
-    m->properties[STR_PROP_DataVersion]=QString::number(somnopose_data_version);
+    m->properties[STR_PROP_Brand] = "Somnopose";
+    m->properties[STR_PROP_Model] = "Somnopose Position Data";
+    m->properties[STR_PROP_DataVersion] = QString::number(somnopose_data_version);
 
     profile->AddMachine(m);
 
-    QString path="{"+STR_GEN_DataFolder+"}/"+m->GetClass()+"_"+m->hexid()+"/";
-    m->properties[STR_PROP_Path]=path;
-    m->properties[STR_PROP_BackupPath]=path+"Backup/";
+    QString path = "{" + STR_GEN_DataFolder + "}/" + m->GetClass() + "_" + m->hexid() + "/";
+    m->properties[STR_PROP_Path] = path;
+    m->properties[STR_PROP_BackupPath] = path + "Backup/";
 
     return m;
 }
@@ -91,6 +92,7 @@ Machine *SomnoposeLoader::CreateMachine(Profile *profile)
 int SomnoposeLoader::OpenFile(QString filename)
 {
     QFile file(filename);
+
     if (filename.toLower().endsWith(".csv")) {
         if (!file.open(QFile::ReadOnly)) {
             qDebug() << "Couldn't open Somnopose data file" << filename;
@@ -104,79 +106,95 @@ int SomnoposeLoader::OpenFile(QString filename)
     QTextStream ts(&file);
 
     // Read header line and determine order of fields
-    QString hdr=ts.readLine();
-    QStringList headers=hdr.split(",");
+    QString hdr = ts.readLine();
+    QStringList headers = hdr.split(",");
 
-    int col_inclination=-1, col_orientation=-1, col_timestamp=-1;
+    int col_inclination = -1, col_orientation = -1, col_timestamp = -1;
 
-    int hdr_size=headers.size();
-    for (int i=0;i<hdr_size;i++) {
-        if (headers.at(i).compare("timestamp",Qt::CaseInsensitive)==0)
-            col_timestamp=i;
-        if (headers.at(i).compare("inclination",Qt::CaseInsensitive)==0)
-            col_inclination=i;
-        if (headers.at(i).compare("orientation",Qt::CaseInsensitive)==0)
-            col_orientation=i;
+    int hdr_size = headers.size();
+
+    for (int i = 0; i < hdr_size; i++) {
+        if (headers.at(i).compare("timestamp", Qt::CaseInsensitive) == 0) {
+            col_timestamp = i;
+        }
+
+        if (headers.at(i).compare("inclination", Qt::CaseInsensitive) == 0) {
+            col_inclination = i;
+        }
+
+        if (headers.at(i).compare("orientation", Qt::CaseInsensitive) == 0) {
+            col_orientation = i;
+        }
     }
 
     // Check we have all fields available
-    if ((col_timestamp<0) || (col_inclination<0) || (col_orientation<0)) {
+    if ((col_timestamp < 0) || (col_inclination < 0) || (col_orientation < 0)) {
         return 0;
     }
 
-    QDateTime epoch(QDate(2001,1,1),QTime(0,0,0));
-    qint64 ep=qint64(epoch.toTime_t())*1000,time;
+    QDateTime epoch(QDate(2001, 1, 1), QTime(0, 0, 0));
+    qint64 ep = qint64(epoch.toTime_t()) * 1000, time;
 
-    double timestamp,orientation, inclination;
+    double timestamp, orientation, inclination;
     QString data;
     QStringList fields;
     bool ok;
 
-    bool first=true;
-    Machine *mach=CreateMachine(p_profile);
-    Session *sess=NULL;
+    bool first = true;
+    Machine *mach = CreateMachine(p_profile);
+    Session *sess = NULL;
     SessionID sid;
 
-    EventList *ev_orientation=NULL, *ev_inclination=NULL;
+    EventList *ev_orientation = NULL, *ev_inclination = NULL;
 
-    while (!(data=ts.readLine()).isEmpty()) {
-        fields=data.split(",");
+    while (!(data = ts.readLine()).isEmpty()) {
+        fields = data.split(",");
 
-        if (fields.size() < hdr_size)  // missing fields.. skip this record
+        if (fields.size() < hdr_size) { // missing fields.. skip this record
             continue;
+        }
 
-        timestamp=fields[col_timestamp].toDouble(&ok);
-        if (!ok) continue;
-        orientation=fields[col_orientation].toDouble(&ok);
-        if (!ok) continue;
-        inclination=fields[col_inclination].toDouble(&ok);
-        if (!ok) continue;
+        timestamp = fields[col_timestamp].toDouble(&ok);
+
+        if (!ok) { continue; }
+
+        orientation = fields[col_orientation].toDouble(&ok);
+
+        if (!ok) { continue; }
+
+        inclination = fields[col_inclination].toDouble(&ok);
+
+        if (!ok) { continue; }
 
         // convert to milliseconds since epoch
-        time=(timestamp*1000.0)+ep;
+        time = (timestamp * 1000.0) + ep;
 
         if (first) {
-            sid=time/1000;
+            sid = time / 1000;
+
             if (mach->SessionExists(sid)) {
                 return 0; // Already imported
             }
-            sess=new Session(mach,sid);
-            sess->really_set_first(time);
-            ev_orientation=sess->AddEventList(POS_Orientation,EVL_Event,1,0,0,0);
-            ev_inclination=sess->AddEventList(POS_Inclination,EVL_Event,1,0,0,0);
-            first=false;
-        }
-        sess->set_last(time);
-        ev_orientation->AddEvent(time,orientation);
-        ev_inclination->AddEvent(time,inclination);
 
-      //  QDateTime dt=QDateTime::fromMSecsSinceEpoch(time);
-      //  qDebug() << dt << orientation << inclination;
+            sess = new Session(mach, sid);
+            sess->really_set_first(time);
+            ev_orientation = sess->AddEventList(POS_Orientation, EVL_Event, 1, 0, 0, 0);
+            ev_inclination = sess->AddEventList(POS_Inclination, EVL_Event, 1, 0, 0, 0);
+            first = false;
+        }
+
+        sess->set_last(time);
+        ev_orientation->AddEvent(time, orientation);
+        ev_inclination->AddEvent(time, inclination);
+
+        //  QDateTime dt=QDateTime::fromMSecsSinceEpoch(time);
+        //  qDebug() << dt << orientation << inclination;
     }
-    sess->setMin(POS_Orientation,ev_orientation->Min());
-    sess->setMax(POS_Orientation,ev_orientation->Max());
-    sess->setMin(POS_Inclination,ev_inclination->Min());
-    sess->setMax(POS_Inclination,ev_inclination->Max());
+
+    sess->setMin(POS_Orientation, ev_orientation->Min());
+    sess->setMax(POS_Orientation, ev_orientation->Max());
+    sess->setMin(POS_Inclination, ev_inclination->Min());
+    sess->setMax(POS_Inclination, ev_inclination->Max());
 
     sess->really_set_last(time);
     sess->SetChanged(true);
@@ -188,14 +206,15 @@ int SomnoposeLoader::OpenFile(QString filename)
 }
 
 
-static bool somnopose_initialized=false;
+static bool somnopose_initialized = false;
 
 void SomnoposeLoader::Register()
 {
-    if (somnopose_initialized) return;
+    if (somnopose_initialized) { return; }
+
     qDebug("Registering SomnoposeLoader");
     RegisterLoader(new SomnoposeLoader());
     //InitModelMap();
-    somnopose_initialized=true;
+    somnopose_initialized = true;
 }
 
diff --git a/sleepyhead/SleepLib/loader_plugins/somnopose_loader.h b/sleepyhead/SleepLib/loader_plugins/somnopose_loader.h
index 9cfcbd01..f4d36664 100644
--- a/sleepyhead/SleepLib/loader_plugins/somnopose_loader.h
+++ b/sleepyhead/SleepLib/loader_plugins/somnopose_loader.h
@@ -14,8 +14,8 @@
 
 #include "SleepLib/machine_loader.h"
 
-const QString somnopose_class_name="Somnopose";
-const int somnopose_data_version=1;
+const QString somnopose_class_name = "Somnopose";
+const int somnopose_data_version = 1;
 
 
 /*! \class SomnoposeLoader
@@ -23,21 +23,21 @@ const int somnopose_data_version=1;
 */
 class SomnoposeLoader : public MachineLoader
 {
-    public:
-        SomnoposeLoader();
-        virtual ~SomnoposeLoader();
-        virtual int Open(QString & path,Profile *profile);
-        virtual int OpenFile(QString filename);
-        static void Register();
+  public:
+    SomnoposeLoader();
+    virtual ~SomnoposeLoader();
+    virtual int Open(QString &path, Profile *profile);
+    virtual int OpenFile(QString filename);
+    static void Register();
 
-        virtual int Version() { return somnopose_data_version; }
-        virtual const QString & ClassName() { return somnopose_class_name; }
+    virtual int Version() { return somnopose_data_version; }
+    virtual const QString &ClassName() { return somnopose_class_name; }
 
 
-        Machine *CreateMachine(Profile *profile);
+    Machine *CreateMachine(Profile *profile);
 
-    protected:
-    private:
+  protected:
+  private:
 };
 
 #endif // SOMNOPOSELOADER_H
diff --git a/sleepyhead/SleepLib/loader_plugins/zeo_loader.cpp b/sleepyhead/SleepLib/loader_plugins/zeo_loader.cpp
index 3404c32b..62bf86d1 100644
--- a/sleepyhead/SleepLib/loader_plugins/zeo_loader.cpp
+++ b/sleepyhead/SleepLib/loader_plugins/zeo_loader.cpp
@@ -30,24 +30,24 @@ ZEOLoader::~ZEOLoader()
 {
     //dtor
 }
-int ZEOLoader::Open(QString & path,Profile *profile)
+int ZEOLoader::Open(QString &path, Profile *profile)
 {
     Q_UNUSED(path)
     Q_UNUSED(profile)
 
     QString newpath;
 
-    QString dirtag="zeo";
+    QString dirtag = "zeo";
 
     // Could Scan the ZEO folder for a list of CSVs
 
-    path=path.replace("\\","/");
+    path = path.replace("\\", "/");
 
-    if (path.toLower().endsWith("/"+dirtag)) {
+    if (path.toLower().endsWith("/" + dirtag)) {
         return 0;
         //newpath=path;
     } else {
-        newpath=path+"/"+dirtag.toUpper();
+        newpath = path + "/" + dirtag.toUpper();
     }
 
     //QString filename;
@@ -58,16 +58,17 @@ int ZEOLoader::Open(QString & path,Profile *profile)
 }
 Machine *ZEOLoader::CreateMachine(Profile *profile)
 {
-    if (!profile)
+    if (!profile) {
         return NULL;
+    }
 
     // NOTE: This only allows for one ZEO machine per profile..
     // Upgrading their ZEO will use this same record..
 
-    QList<Machine *> ml=profile->GetMachines(MT_SLEEPSTAGE);
+    QList<Machine *> ml = profile->GetMachines(MT_SLEEPSTAGE);
 
-    for (QList<Machine *>::iterator i=ml.begin(); i!=ml.end(); i++) {
-        if ((*i)->GetClass()==zeo_class_name)  {
+    for (QList<Machine *>::iterator i = ml.begin(); i != ml.end(); i++) {
+        if ((*i)->GetClass() == zeo_class_name)  {
             return (*i);
             break;
         }
@@ -75,18 +76,18 @@ Machine *ZEOLoader::CreateMachine(Profile *profile)
 
     qDebug("Create ZEO Machine Record");
 
-    Machine *m=new SleepStage(profile,0);
+    Machine *m = new SleepStage(profile, 0);
     m->SetType(MT_SLEEPSTAGE);
     m->SetClass(zeo_class_name);
-    m->properties[STR_PROP_Brand]="ZEO";
-    m->properties[STR_PROP_Model]="Personal Sleep Coach";
-    m->properties[STR_PROP_DataVersion]=QString::number(zeo_data_version);
+    m->properties[STR_PROP_Brand] = "ZEO";
+    m->properties[STR_PROP_Model] = "Personal Sleep Coach";
+    m->properties[STR_PROP_DataVersion] = QString::number(zeo_data_version);
 
     profile->AddMachine(m);
 
-    QString path="{"+STR_GEN_DataFolder+"}/"+m->GetClass()+"_"+m->hexid()+"/";
-    m->properties[STR_PROP_Path]=path;
-    m->properties[STR_PROP_BackupPath]=path+"Backup/";
+    QString path = "{" + STR_GEN_DataFolder + "}/" + m->GetClass() + "_" + m->hexid() + "/";
+    m->properties[STR_PROP_Path] = path;
+    m->properties[STR_PROP_BackupPath] = path + "Backup/";
 
     return m;
 }
@@ -120,6 +121,7 @@ Machine *ZEOLoader::CreateMachine(Profile *profile)
 int ZEOLoader::OpenFile(QString filename)
 {
     QFile file(filename);
+
     if (filename.toLower().endsWith(".csv")) {
         if (!file.open(QFile::ReadOnly)) {
             qDebug() << "Couldn't open zeo file" << filename;
@@ -130,16 +132,17 @@ int ZEOLoader::OpenFile(QString filename)
         return 0;
         // not supported.
     }
+
     QTextStream text(&file);
-    QString headerdata=text.readLine();
-    QStringList header=headerdata.split(",");
+    QString headerdata = text.readLine();
+    QStringList header = headerdata.split(",");
     QString line;
     QStringList linecomp;
     QDateTime start_of_night, end_of_night, rise_time;
     SessionID sid;
 
     //const qint64 WindowSize=30000;
-    qint64 st,tt;
+    qint64 st, tt;
     int stage;
 
     int ZQ, TotalZ, TimeToZ, TimeInWake, TimeInREM, TimeInLight, TimeInDeep, Awakenings;
@@ -150,159 +153,217 @@ int ZEOLoader::OpenFile(QString filename)
 
     QStringList SG, DSG;
 
-    Machine *mach=CreateMachine(p_profile);
+    Machine *mach = CreateMachine(p_profile);
 
 
-    int idxZQ=header.indexOf("ZQ");
-    int idxTotalZ=header.indexOf("Total Z");
-    int idxAwakenings=header.indexOf("Awakenings");
-    int idxSG=header.indexOf("Sleep Graph");
-    int idxDSG=header.indexOf("Detailed Sleep Graph");
-    int idxTimeInWake=header.indexOf("Time in Wake");
-    int idxTimeToZ=header.indexOf("Time to Z");
-    int idxTimeInREM=header.indexOf("Time in REM");
-    int idxTimeInLight=header.indexOf("Time in Light");
-    int idxTimeInDeep=header.indexOf("Time in Deep");
-    int idxStartOfNight=header.indexOf("Start of Night");
-    int idxEndOfNight=header.indexOf("End of Night");
-    int idxRiseTime=header.indexOf("Rise Time");
-    int idxAlarmReason=header.indexOf("Alarm Reason");
-    int idxSnoozeTime=header.indexOf("Snooze Time");
-    int idxWakeTone=header.indexOf("Wake Tone");
-    int idxWakeWindow=header.indexOf("Wake Window");
-    int idxAlarmType=header.indexOf("Alarm Type");
-    int idxFirstAlaramRing=header.indexOf("First Alarm Ring");
-    int idxLastAlaramRing=header.indexOf("Last Alarm Ring");
-    int idxFirstSnoozeTime=header.indexOf("First Snooze Time");
-    int idxLastSnoozeTime=header.indexOf("Last Snooze Time");
-    int idxSetAlarmTime=header.indexOf("Set Alarm Time");
-    int idxMorningFeel=header.indexOf("Morning Feel");
-    int idxFirmwareVersion=header.indexOf("Firmware Version");
-    int idxMyZEOVersion=header.indexOf("My ZEO Version");
+    int idxZQ = header.indexOf("ZQ");
+    int idxTotalZ = header.indexOf("Total Z");
+    int idxAwakenings = header.indexOf("Awakenings");
+    int idxSG = header.indexOf("Sleep Graph");
+    int idxDSG = header.indexOf("Detailed Sleep Graph");
+    int idxTimeInWake = header.indexOf("Time in Wake");
+    int idxTimeToZ = header.indexOf("Time to Z");
+    int idxTimeInREM = header.indexOf("Time in REM");
+    int idxTimeInLight = header.indexOf("Time in Light");
+    int idxTimeInDeep = header.indexOf("Time in Deep");
+    int idxStartOfNight = header.indexOf("Start of Night");
+    int idxEndOfNight = header.indexOf("End of Night");
+    int idxRiseTime = header.indexOf("Rise Time");
+    int idxAlarmReason = header.indexOf("Alarm Reason");
+    int idxSnoozeTime = header.indexOf("Snooze Time");
+    int idxWakeTone = header.indexOf("Wake Tone");
+    int idxWakeWindow = header.indexOf("Wake Window");
+    int idxAlarmType = header.indexOf("Alarm Type");
+    int idxFirstAlaramRing = header.indexOf("First Alarm Ring");
+    int idxLastAlaramRing = header.indexOf("Last Alarm Ring");
+    int idxFirstSnoozeTime = header.indexOf("First Snooze Time");
+    int idxLastSnoozeTime = header.indexOf("Last Snooze Time");
+    int idxSetAlarmTime = header.indexOf("Set Alarm Time");
+    int idxMorningFeel = header.indexOf("Morning Feel");
+    int idxFirmwareVersion = header.indexOf("Firmware Version");
+    int idxMyZEOVersion = header.indexOf("My ZEO Version");
 
     bool ok;
     bool dodgy;
-    do {
-        line=text.readLine();
-        dodgy=false;
-        if (line.isEmpty()) continue;
-        linecomp=line.split(",");
-        ZQ=linecomp[idxZQ].toInt(&ok);
-        if (!ok) dodgy=true;
-        TotalZ=linecomp[idxTotalZ].toInt(&ok);
-        if (!ok) dodgy=true;
-        TimeToZ=linecomp[idxTimeToZ].toInt(&ok);
-        if (!ok) dodgy=true;
-        TimeInWake=linecomp[idxTimeInWake].toInt(&ok);
-        if (!ok) dodgy=true;
-        TimeInREM=linecomp[idxTimeInREM].toInt(&ok);
-        if (!ok) dodgy=true;
-        TimeInLight=linecomp[idxTimeInLight].toInt(&ok);
-        if (!ok) dodgy=true;
-        TimeInDeep=linecomp[idxTimeInDeep].toInt(&ok);
-        if (!ok) dodgy=true;
-        Awakenings=linecomp[idxAwakenings].toInt(&ok);
-        if (!ok) dodgy=true;
-        start_of_night=QDateTime::fromString(linecomp[idxStartOfNight],"MM/dd/yyyy HH:mm");
-        if (!start_of_night.isValid()) dodgy=true;
-        end_of_night=QDateTime::fromString(linecomp[idxEndOfNight],"MM/dd/yyyy HH:mm");
-        if (!end_of_night.isValid()) dodgy=true;
-        rise_time=QDateTime::fromString(linecomp[idxRiseTime],"MM/dd/yyyy HH:mm");
-        if (!rise_time.isValid()) dodgy=true;
 
-        AlarmReason=linecomp[idxAlarmReason].toInt(&ok);
-        if (!ok) dodgy=true;
-        SnoozeTime=linecomp[idxSnoozeTime].toInt(&ok);
-        if (!ok) dodgy=true;
-        WakeTone=linecomp[idxWakeTone].toInt(&ok);
-        if (!ok) dodgy=true;
-        WakeWindow=linecomp[idxWakeWindow].toInt(&ok);
-        if (!ok) dodgy=true;
-        AlarmType=linecomp[idxAlarmType].toInt(&ok);
-        if (!ok) dodgy=true;
+    do {
+        line = text.readLine();
+        dodgy = false;
+
+        if (line.isEmpty()) { continue; }
+
+        linecomp = line.split(",");
+        ZQ = linecomp[idxZQ].toInt(&ok);
+
+        if (!ok) { dodgy = true; }
+
+        TotalZ = linecomp[idxTotalZ].toInt(&ok);
+
+        if (!ok) { dodgy = true; }
+
+        TimeToZ = linecomp[idxTimeToZ].toInt(&ok);
+
+        if (!ok) { dodgy = true; }
+
+        TimeInWake = linecomp[idxTimeInWake].toInt(&ok);
+
+        if (!ok) { dodgy = true; }
+
+        TimeInREM = linecomp[idxTimeInREM].toInt(&ok);
+
+        if (!ok) { dodgy = true; }
+
+        TimeInLight = linecomp[idxTimeInLight].toInt(&ok);
+
+        if (!ok) { dodgy = true; }
+
+        TimeInDeep = linecomp[idxTimeInDeep].toInt(&ok);
+
+        if (!ok) { dodgy = true; }
+
+        Awakenings = linecomp[idxAwakenings].toInt(&ok);
+
+        if (!ok) { dodgy = true; }
+
+        start_of_night = QDateTime::fromString(linecomp[idxStartOfNight], "MM/dd/yyyy HH:mm");
+
+        if (!start_of_night.isValid()) { dodgy = true; }
+
+        end_of_night = QDateTime::fromString(linecomp[idxEndOfNight], "MM/dd/yyyy HH:mm");
+
+        if (!end_of_night.isValid()) { dodgy = true; }
+
+        rise_time = QDateTime::fromString(linecomp[idxRiseTime], "MM/dd/yyyy HH:mm");
+
+        if (!rise_time.isValid()) { dodgy = true; }
+
+        AlarmReason = linecomp[idxAlarmReason].toInt(&ok);
+
+        if (!ok) { dodgy = true; }
+
+        SnoozeTime = linecomp[idxSnoozeTime].toInt(&ok);
+
+        if (!ok) { dodgy = true; }
+
+        WakeTone = linecomp[idxWakeTone].toInt(&ok);
+
+        if (!ok) { dodgy = true; }
+
+        WakeWindow = linecomp[idxWakeWindow].toInt(&ok);
+
+        if (!ok) { dodgy = true; }
+
+        AlarmType = linecomp[idxAlarmType].toInt(&ok);
+
+        if (!ok) { dodgy = true; }
 
         if (!linecomp[idxFirstAlaramRing].isEmpty()) {
-            FirstAlarmRing=QDateTime::fromString(linecomp[idxFirstAlaramRing],"MM/dd/yyyy HH:mm");
-            if (!FirstAlarmRing.isValid()) dodgy=true;
+            FirstAlarmRing = QDateTime::fromString(linecomp[idxFirstAlaramRing], "MM/dd/yyyy HH:mm");
+
+            if (!FirstAlarmRing.isValid()) { dodgy = true; }
         }
+
         if (!linecomp[idxLastAlaramRing].isEmpty()) {
-            LastAlarmRing=QDateTime::fromString(linecomp[idxLastAlaramRing],"MM/dd/yyyy HH:mm");
-            if (!LastAlarmRing.isValid()) dodgy=true;
+            LastAlarmRing = QDateTime::fromString(linecomp[idxLastAlaramRing], "MM/dd/yyyy HH:mm");
+
+            if (!LastAlarmRing.isValid()) { dodgy = true; }
         }
+
         if (!linecomp[idxFirstSnoozeTime].isEmpty()) {
-            FirstSnoozeTime=QDateTime::fromString(linecomp[idxFirstSnoozeTime],"MM/dd/yyyy HH:mm");
-            if (!FirstSnoozeTime.isValid()) dodgy=true;
+            FirstSnoozeTime = QDateTime::fromString(linecomp[idxFirstSnoozeTime], "MM/dd/yyyy HH:mm");
+
+            if (!FirstSnoozeTime.isValid()) { dodgy = true; }
         }
+
         if (!linecomp[idxLastSnoozeTime].isEmpty()) {
-            LastSnoozeTime=QDateTime::fromString(linecomp[idxLastSnoozeTime],"MM/dd/yyyy HH:mm");
-            if (!LastSnoozeTime.isValid()) dodgy=true;
+            LastSnoozeTime = QDateTime::fromString(linecomp[idxLastSnoozeTime], "MM/dd/yyyy HH:mm");
+
+            if (!LastSnoozeTime.isValid()) { dodgy = true; }
         }
+
         if (!linecomp[idxSetAlarmTime].isEmpty()) {
-            SetAlarmTime=QDateTime::fromString(linecomp[idxSetAlarmTime],"MM/dd/yyyy HH:mm");
-            if (!SetAlarmTime.isValid()) dodgy=true;
+            SetAlarmTime = QDateTime::fromString(linecomp[idxSetAlarmTime], "MM/dd/yyyy HH:mm");
+
+            if (!SetAlarmTime.isValid()) { dodgy = true; }
         }
-        MorningFeel=linecomp[idxMorningFeel].toInt(&ok);
 
-        if (!ok) MorningFeel=0;
+        MorningFeel = linecomp[idxMorningFeel].toInt(&ok);
 
-        FirmwareVersion=linecomp[idxFirmwareVersion];
-        if (idxMyZEOVersion>=0) MyZeoVersion=linecomp[idxMyZEOVersion];
+        if (!ok) { MorningFeel = 0; }
 
-        if (dodgy)
+        FirmwareVersion = linecomp[idxFirmwareVersion];
+
+        if (idxMyZEOVersion >= 0) { MyZeoVersion = linecomp[idxMyZEOVersion]; }
+
+        if (dodgy) {
             continue;
-        SG=linecomp[idxSG].split(" ");
-        DSG=linecomp[idxDSG].split(" ");
+        }
 
-        const int WindowSize=30000;
-        sid=start_of_night.toTime_t();
-        if (DSG.size()==0)
+        SG = linecomp[idxSG].split(" ");
+        DSG = linecomp[idxDSG].split(" ");
+
+        const int WindowSize = 30000;
+        sid = start_of_night.toTime_t();
+
+        if (DSG.size() == 0) {
             continue;
-        if (mach->SessionExists(sid))
+        }
+
+        if (mach->SessionExists(sid)) {
             continue;
-        Session *sess=new Session(mach,sid);
+        }
 
-        sess->settings[ZEO_Awakenings]=Awakenings;
-        sess->settings[ZEO_MorningFeel]=MorningFeel;
-        sess->settings[ZEO_TimeToZ]=TimeToZ;
-        sess->settings[ZEO_ZQ]=ZQ;
-        sess->settings[ZEO_TimeInWake]=TimeInWake;
-        sess->settings[ZEO_TimeInREM]=TimeInREM;
-        sess->settings[ZEO_TimeInLight]=TimeInLight;
-        sess->settings[ZEO_TimeInDeep]=TimeInDeep;
+        Session *sess = new Session(mach, sid);
 
-        st=qint64(start_of_night.toTime_t()) * 1000L;
+        sess->settings[ZEO_Awakenings] = Awakenings;
+        sess->settings[ZEO_MorningFeel] = MorningFeel;
+        sess->settings[ZEO_TimeToZ] = TimeToZ;
+        sess->settings[ZEO_ZQ] = ZQ;
+        sess->settings[ZEO_TimeInWake] = TimeInWake;
+        sess->settings[ZEO_TimeInREM] = TimeInREM;
+        sess->settings[ZEO_TimeInLight] = TimeInLight;
+        sess->settings[ZEO_TimeInDeep] = TimeInDeep;
+
+        st = qint64(start_of_night.toTime_t()) * 1000L;
         sess->really_set_first(st);
-        tt=st;
-        EventList * sleepstage=sess->AddEventList(ZEO_SleepStage,EVL_Event,1,0,0,4);
-        for (int i=0;i<DSG.size();i++) {
-            stage=DSG[i].toInt(&ok);
+        tt = st;
+        EventList *sleepstage = sess->AddEventList(ZEO_SleepStage, EVL_Event, 1, 0, 0, 4);
+
+        for (int i = 0; i < DSG.size(); i++) {
+            stage = DSG[i].toInt(&ok);
+
             if (ok) {
-                sleepstage->AddEvent(tt,stage);
+                sleepstage->AddEvent(tt, stage);
             }
-            tt+=WindowSize;
+
+            tt += WindowSize;
         }
+
         sess->really_set_last(tt);
-        int size=DSG.size();
+        int size = DSG.size();
         sess->SetChanged(true);
-        mach->AddSession(sess,p_profile);
+        mach->AddSession(sess, p_profile);
 
 
-        qDebug() << linecomp[0] << start_of_night << end_of_night << rise_time << size << "30 second chunks";
+        qDebug() << linecomp[0] << start_of_night << end_of_night << rise_time << size <<
+                 "30 second chunks";
 
     } while (!line.isNull());
+
     mach->Save();
     return true;
 }
 
 
-static bool zeo_initialized=false;
+static bool zeo_initialized = false;
 
 void ZEOLoader::Register()
 {
-    if (zeo_initialized) return;
+    if (zeo_initialized) { return; }
+
     qDebug("Registering ZEOLoader");
     RegisterLoader(new ZEOLoader());
     //InitModelMap();
-    zeo_initialized=true;
+    zeo_initialized = true;
 }
 
diff --git a/sleepyhead/SleepLib/loader_plugins/zeo_loader.h b/sleepyhead/SleepLib/loader_plugins/zeo_loader.h
index 4b545bb4..bfcc57a0 100644
--- a/sleepyhead/SleepLib/loader_plugins/zeo_loader.h
+++ b/sleepyhead/SleepLib/loader_plugins/zeo_loader.h
@@ -14,8 +14,8 @@
 
 #include "SleepLib/machine_loader.h"
 
-const QString zeo_class_name="ZEO";
-const int zeo_data_version=1;
+const QString zeo_class_name = "ZEO";
+const int zeo_data_version = 1;
 
 
 /*! \class ZEOLoader
@@ -23,21 +23,21 @@ const int zeo_data_version=1;
 */
 class ZEOLoader : public MachineLoader
 {
-    public:
-        ZEOLoader();
-        virtual ~ZEOLoader();
-        virtual int Open(QString & path,Profile *profile);
-        virtual int OpenFile(QString filename);
-        static void Register();
+  public:
+    ZEOLoader();
+    virtual ~ZEOLoader();
+    virtual int Open(QString &path, Profile *profile);
+    virtual int OpenFile(QString filename);
+    static void Register();
 
-        virtual int Version() { return zeo_data_version; }
-        virtual const QString & ClassName() { return zeo_class_name; }
+    virtual int Version() { return zeo_data_version; }
+    virtual const QString &ClassName() { return zeo_class_name; }
 
 
-        Machine *CreateMachine(Profile *profile);
+    Machine *CreateMachine(Profile *profile);
 
-    protected:
-    private:
+  protected:
+  private:
 };
 
 #endif // ZEOLOADER_H
diff --git a/sleepyhead/SleepLib/machine.cpp b/sleepyhead/SleepLib/machine.cpp
index 24700355..5ab6012e 100644
--- a/sleepyhead/SleepLib/machine.cpp
+++ b/sleepyhead/SleepLib/machine.cpp
@@ -22,40 +22,44 @@
 #include <algorithm>
 #include "SleepLib/schema.h"
 
-extern QProgressBar * qprogress;
+extern QProgressBar *qprogress;
 
 //////////////////////////////////////////////////////////////////////////////////////////
 // Machine Base-Class implmementation
 //////////////////////////////////////////////////////////////////////////////////////////
-Machine::Machine(Profile *p,MachineID id)
+Machine::Machine(Profile *p, MachineID id)
 {
     day.clear();
-    highest_sessionid=0;
-    profile=p;
+    highest_sessionid = 0;
+    profile = p;
+
     if (!id) {
         srand(time(NULL));
         MachineID temp;
+
         do {
             temp = rand();
-        } while (profile->machlist.find(temp)!=profile->machlist.end());
+        } while (profile->machlist.find(temp) != profile->machlist.end());
 
-        m_id=temp;
+        m_id = temp;
+
+    } else { m_id = id; }
 
-    } else m_id=id;
     //qDebug() << "Create Machine: " << hex << m_id; //%lx",m_id);
-    m_type=MT_UNKNOWN;
-    firstsession=true;
+    m_type = MT_UNKNOWN;
+    firstsession = true;
 }
 Machine::~Machine()
 {
     qDebug() << "Destroy Machine" << m_class;
-    for (QMap<QDate,Day *>::iterator d=day.begin();d!=day.end();d++) {
+
+    for (QMap<QDate, Day *>::iterator d = day.begin(); d != day.end(); d++) {
         delete d.value();
     }
 }
 Session *Machine::SessionExists(SessionID session)
 {
-    if (sessionlist.find(session)!=sessionlist.end()) {
+    if (sessionlist.find(session) != sessionlist.end()) {
         return sessionlist[session];
     } else {
         return NULL;
@@ -65,25 +69,27 @@ Session *Machine::SessionExists(SessionID session)
 // Find date this session belongs in
 QDate Machine::pickDate(qint64 first)
 {
-    QTime split_time=PROFILE.session->daySplitTime();
-    int combine_sessions=PROFILE.session->combineCloseSessions();
+    QTime split_time = PROFILE.session->daySplitTime();
+    int combine_sessions = PROFILE.session->combineCloseSessions();
 
-    QDateTime d2=QDateTime::fromTime_t(first/1000);
+    QDateTime d2 = QDateTime::fromTime_t(first / 1000);
 
-    QDate date=d2.date();
-    QTime time=d2.time();
+    QDate date = d2.date();
+    QTime time = d2.time();
 
-    int closest_session=0;
+    int closest_session = 0;
 
-    if (time<split_time) {
-        date=date.addDays(-1);
+    if (time < split_time) {
+        date = date.addDays(-1);
     } else if (combine_sessions > 0) {
-        QMap<QDate,Day *>::iterator dit=day.find(date.addDays(-1)); // Check Day Before
+        QMap<QDate, Day *>::iterator dit = day.find(date.addDays(-1)); // Check Day Before
+
         if (dit != day.end()) {
-            QDateTime lt=QDateTime::fromTime_t(dit.value()->last()/1000L);
-            closest_session=lt.secsTo(d2)/60;
+            QDateTime lt = QDateTime::fromTime_t(dit.value()->last() / 1000L);
+            closest_session = lt.secsTo(d2) / 60;
+
             if (closest_session < combine_sessions) {
-                date=date.addDays(-1);
+                date = date.addDays(-1);
             }
         }
     }
@@ -91,104 +97,118 @@ QDate Machine::pickDate(qint64 first)
     return date;
 }
 
-QDate Machine::AddSession(Session *s,Profile *p)
+QDate Machine::AddSession(Session *s, Profile *p)
 {
     if (!s) {
         qWarning() << "Empty Session in Machine::AddSession()";
         return QDate();
     }
+
     if (!p) {
         qWarning() << "Empty Profile in Machine::AddSession()";
         return QDate();
     }
-    if (s->session()>highest_sessionid)
-        highest_sessionid=s->session();
+
+    if (s->session() > highest_sessionid) {
+        highest_sessionid = s->session();
+    }
 
 
-    QTime split_time=PROFILE.session->daySplitTime();
-    int combine_sessions=PROFILE.session->combineCloseSessions();
-    int ignore_sessions=PROFILE.session->ignoreShortSessions();
+    QTime split_time = PROFILE.session->daySplitTime();
+    int combine_sessions = PROFILE.session->combineCloseSessions();
+    int ignore_sessions = PROFILE.session->ignoreShortSessions();
 
-    int session_length=s->last()-s->first();
-    session_length/=60000;
+    int session_length = s->last() - s->first();
+    session_length /= 60000;
 
-    sessionlist[s->session()]=s; // To make sure it get's saved later even if it's not wanted.
+    sessionlist[s->session()] = s; // To make sure it get's saved later even if it's not wanted.
 
     //int drift=PROFILE.cpap->clockDrift();
 
-    QDateTime d2=QDateTime::fromTime_t(s->first()/1000);
+    QDateTime d2 = QDateTime::fromTime_t(s->first() / 1000);
 
-    QDate date=d2.date();
-    QTime time=d2.time();
+    QDate date = d2.date();
+    QTime time = d2.time();
 
-    QMap<QDate,Day *>::iterator dit,nextday;
+    QMap<QDate, Day *>::iterator dit, nextday;
 
-    bool combine_next_day=false;
-    int closest_session=0;
+    bool combine_next_day = false;
+    int closest_session = 0;
 
-    if (time<split_time) {
-        date=date.addDays(-1);
+    if (time < split_time) {
+        date = date.addDays(-1);
     } else if (combine_sessions > 0) {
-        dit=day.find(date.addDays(-1)); // Check Day Before
-        if (dit!=day.end()) {
-            QDateTime lt=QDateTime::fromTime_t(dit.value()->last()/1000);
-            closest_session=lt.secsTo(d2)/60;
-            if (closest_session<combine_sessions) {
-                date=date.addDays(-1);
+        dit = day.find(date.addDays(-1)); // Check Day Before
+
+        if (dit != day.end()) {
+            QDateTime lt = QDateTime::fromTime_t(dit.value()->last() / 1000);
+            closest_session = lt.secsTo(d2) / 60;
+
+            if (closest_session < combine_sessions) {
+                date = date.addDays(-1);
             }
         } else {
-            nextday=day.find(date.addDays(1));// Check Day Afterwards
-            if (nextday!=day.end()) {
-                QDateTime lt=QDateTime::fromTime_t(nextday.value()->first()/1000);
-                closest_session=d2.secsTo(lt)/60;
+            nextday = day.find(date.addDays(1)); // Check Day Afterwards
+
+            if (nextday != day.end()) {
+                QDateTime lt = QDateTime::fromTime_t(nextday.value()->first() / 1000);
+                closest_session = d2.secsTo(lt) / 60;
+
                 if (closest_session < combine_sessions) {
                     // add todays here. pull all tomorrows records to this date.
-                    combine_next_day=true;
+                    combine_next_day = true;
                 }
             }
         }
     }
 
-    if (session_length<ignore_sessions) {
+    if (session_length < ignore_sessions) {
         //if (!closest_session || (closest_session>=60))
         return QDate();
     }
 
     if (!firstsession) {
-        if (firstday>date) firstday=date;
-        if (lastday<date) lastday=date;
+        if (firstday > date) { firstday = date; }
+
+        if (lastday < date) { lastday = date; }
     } else {
-        firstday=lastday=date;
-        firstsession=false;
+        firstday = lastday = date;
+        firstsession = false;
     }
 
 
-    Day *dd=NULL;
-    dit=day.find(date);
-    if (dit==day.end()) {
+    Day *dd = NULL;
+    dit = day.find(date);
+
+    if (dit == day.end()) {
         //QString dstr=date.toString("yyyyMMdd");
         //qDebug("Adding Profile Day %s",dstr.toLatin1().data());
-        dd=new Day(this);
-        day[date]=dd;
+        dd = new Day(this);
+        day[date] = dd;
         // Add this Day record to profile
-        p->AddDay(date,dd,m_type);
+        p->AddDay(date, dd, m_type);
     } else {
-        dd=*dit;
+        dd = *dit;
     }
+
     dd->AddSession(s);
 
     if (combine_next_day) {
-        for (QList<Session *>::iterator i=nextday.value()->begin();i!=nextday.value()->end();i++) {
+        for (QList<Session *>::iterator i = nextday.value()->begin(); i != nextday.value()->end(); i++) {
             dd->AddSession(*i);
         }
-        QMap<QDate,QList<Day *> >::iterator nd=p->daylist.find(date.addDays(1));
-        for (QList<Day *>::iterator i=nd->begin();i!=nd->end();i++) {
-            if (*i==nextday.value()) {
+
+        QMap<QDate, QList<Day *> >::iterator nd = p->daylist.find(date.addDays(1));
+
+        for (QList<Day *>::iterator i = nd->begin(); i != nd->end(); i++) {
+            if (*i == nextday.value()) {
                 nd.value().erase(i);
             }
         }
+
         day.erase(nextday);
     }
+
     return date;
 }
 
@@ -197,20 +217,23 @@ QDate Machine::AddSession(Session *s,Profile *p)
 bool Machine::Purge(int secret)
 {
     // Boring api key to stop this function getting called by accident :)
-    if (secret!=3478216) return false;
+    if (secret != 3478216) { return false; }
 
 
     // It would be joyous if this function screwed up..
 
-    QString path=profile->Get(properties[STR_PROP_Path]); //STR_GEN_DataFolder)+"/"+m_class+"_";
+    QString path = profile->Get(properties[STR_PROP_Path]); //STR_GEN_DataFolder)+"/"+m_class+"_";
     //if (properties.contains(STR_PROP_Serial)) path+=properties[STR_PROP_Serial]; else path+=hexid();
 
     QDir dir(path);
 
-    if (!dir.exists()) // It doesn't exist anyway.
+    if (!dir.exists()) { // It doesn't exist anyway.
         return true;
-    if (!dir.isReadable())
+    }
+
+    if (!dir.isReadable()) {
         return false;
+    }
 
 
     qDebug() << "Purging " << QDir::toNativeSeparators(path);
@@ -218,26 +241,28 @@ bool Machine::Purge(int secret)
     dir.setFilter(QDir::Files | QDir::Hidden | QDir::NoSymLinks);
     dir.setSorting(QDir::Name);
 
-    QFileInfoList list=dir.entryInfoList();
-    int could_not_kill=0;
+    QFileInfoList list = dir.entryInfoList();
+    int could_not_kill = 0;
 
-    for (int i=0;i<list.size();++i) {
-        QFileInfo fi=list.at(i);
-        QString fullpath=fi.canonicalFilePath();
+    for (int i = 0; i < list.size(); ++i) {
+        QFileInfo fi = list.at(i);
+        QString fullpath = fi.canonicalFilePath();
         //int j=fullpath.lastIndexOf(".");
 
-        QString ext_s=fullpath.section('.',-1);//right(j);
+        QString ext_s = fullpath.section('.', -1); //right(j);
         bool ok;
-        ext_s.toInt(&ok,10);
+        ext_s.toInt(&ok, 10);
+
         if (ok) {
             qDebug() << "Deleting " << QDir::toNativeSeparators(fullpath);
             dir.remove(fullpath);
-        } else could_not_kill++;
+        } else { could_not_kill++; }
 
     }
-    if (could_not_kill>0) {
-      //  qWarning() << "Could not purge path\n" << path << "\n\n" << could_not_kill << " file(s) remain.. Suggest manually deleting this path\n";
-    //    return false;
+
+    if (could_not_kill > 0) {
+        //  qWarning() << "Could not purge path\n" << path << "\n\n" << could_not_kill << " file(s) remain.. Suggest manually deleting this path\n";
+        //    return false;
     }
 
     return true;
@@ -248,130 +273,159 @@ bool Machine::Purge(int secret)
 
 bool Machine::Load()
 {
-    QString path=profile->Get(properties[STR_PROP_Path]); //STR_GEN_DataFolder)+"/"+m_class+"_"+hexid();
+    QString path = profile->Get(
+                       properties[STR_PROP_Path]); //STR_GEN_DataFolder)+"/"+m_class+"_"+hexid();
 
     QDir dir(path);
     qDebug() << "Loading " << QDir::toNativeSeparators(path);
 
-    if (!dir.exists() || !dir.isReadable())
+    if (!dir.exists() || !dir.isReadable()) {
         return false;
+    }
 
     dir.setFilter(QDir::Files | QDir::Hidden | QDir::NoSymLinks);
     dir.setSorting(QDir::Name);
 
-    QFileInfoList list=dir.entryInfoList();
+    QFileInfoList list = dir.entryInfoList();
 
     typedef QVector<QString> StringList;
-    QMap<SessionID,StringList> sessfiles;
-    QMap<SessionID,StringList>::iterator s;
+    QMap<SessionID, StringList> sessfiles;
+    QMap<SessionID, StringList>::iterator s;
 
-    QString fullpath,ext_s,sesstr;
+    QString fullpath, ext_s, sesstr;
     int ext;
     SessionID sessid;
     bool ok;
-    for (int i=0;i<list.size();i++) {
-        QFileInfo fi=list.at(i);
-        fullpath=fi.canonicalFilePath();
-        ext_s=fi.fileName().section(".",-1);
-        ext=ext_s.toInt(&ok,10);
-        if (!ok) continue;
 
-        sesstr=fi.fileName().section(".",0,-2);
-        sessid=sesstr.toLong(&ok,16);
-        if (!ok) continue;
-        if (sessfiles[sessid].capacity()==0) sessfiles[sessid].resize(3);
-        sessfiles[sessid][ext]=fi.canonicalFilePath();
+    for (int i = 0; i < list.size(); i++) {
+        QFileInfo fi = list.at(i);
+        fullpath = fi.canonicalFilePath();
+        ext_s = fi.fileName().section(".", -1);
+        ext = ext_s.toInt(&ok, 10);
+
+        if (!ok) { continue; }
+
+        sesstr = fi.fileName().section(".", 0, -2);
+        sessid = sesstr.toLong(&ok, 16);
+
+        if (!ok) { continue; }
+
+        if (sessfiles[sessid].capacity() == 0) { sessfiles[sessid].resize(3); }
+
+        sessfiles[sessid][ext] = fi.canonicalFilePath();
     }
 
-    int size=sessfiles.size();
-    int cnt=0;
-    for (s=sessfiles.begin(); s!=sessfiles.end(); s++) {
-        if ((++cnt % 50)==0) { // This is slow.. :-/
-            if (qprogress) qprogress->setValue((float(cnt)/float(size)*100.0));
+    int size = sessfiles.size();
+    int cnt = 0;
+
+    for (s = sessfiles.begin(); s != sessfiles.end(); s++) {
+        if ((++cnt % 50) == 0) { // This is slow.. :-/
+            if (qprogress) { qprogress->setValue((float(cnt) / float(size) * 100.0)); }
+
             QApplication::processEvents();
         }
 
-        Session *sess=new Session(this,s.key());
+        Session *sess = new Session(this, s.key());
 
         if (sess->LoadSummary(s.value()[0])) {
-             sess->SetEventFile(s.value()[1]);
-             //sess->OpenEvents();
-             AddSession(sess,profile);
+            sess->SetEventFile(s.value()[1]);
+            //sess->OpenEvents();
+            AddSession(sess, profile);
         } else {
             qWarning() << "Error unpacking summary data";
             delete sess;
         }
     }
-    if (qprogress) qprogress->setValue(100);
+
+    if (qprogress) { qprogress->setValue(100); }
+
     return true;
 }
 bool Machine::SaveSession(Session *sess)
 {
-    QString path=profile->Get(properties[STR_PROP_Path]); //STR_GEN_DataFolder)+"/"+m_class+"_"+hexid();
-    if (sess->IsChanged()) sess->Store(path);
+    QString path = profile->Get(
+                       properties[STR_PROP_Path]); //STR_GEN_DataFolder)+"/"+m_class+"_"+hexid();
+
+    if (sess->IsChanged()) { sess->Store(path); }
+
     return true;
 }
 
 bool Machine::Save()
 {
     //int size;
-    int cnt=0;
+    int cnt = 0;
 
-    QString path=profile->Get(properties[STR_PROP_Path]); //STR_GEN_DataFolder)+"/"+m_class+"_"+hexid();
+    QString path = profile->Get(
+                       properties[STR_PROP_Path]); //STR_GEN_DataFolder)+"/"+m_class+"_"+hexid();
     QDir dir(path);
+
     if (!dir.exists()) {
         dir.mkdir(path);
     }
 
-    QHash<SessionID,Session *>::iterator s;
+    QHash<SessionID, Session *>::iterator s;
 
     m_savelist.clear();
-    for (s=sessionlist.begin(); s!=sessionlist.end(); s++) {
+
+    for (s = sessionlist.begin(); s != sessionlist.end(); s++) {
         cnt++;
+
         if ((*s)->IsChanged()) {
             m_savelist.push_back(*s);
         }
     }
-    savelistCnt=0;
-    savelistSize=m_savelist.size();
-    bool cachesessions=PROFILE.session->cacheSessions();
+
+    savelistCnt = 0;
+    savelistSize = m_savelist.size();
+    bool cachesessions = PROFILE.session->cacheSessions();
+
     if (!PROFILE.session->multithreading()) {
-        for (int i=0;i<savelistSize;i++) {
-            if ((i % 10) ==0) {
-                qprogress->setValue(0+(float(savelistCnt)/float(savelistSize)*100.0));
+        for (int i = 0; i < savelistSize; i++) {
+            if ((i % 10) == 0) {
+                qprogress->setValue(0 + (float(savelistCnt) / float(savelistSize) * 100.0));
                 QApplication::processEvents();
             }
-            Session *s=m_savelist.at(i);
+
+            Session *s = m_savelist.at(i);
             s->UpdateSummaries();
             s->Store(path);
-            if (!cachesessions)
+
+            if (!cachesessions) {
                 s->TrashEvents();
+            }
+
             savelistCnt++;
 
         }
+
         return true;
     }
-    int threads=QThread::idealThreadCount();
-    savelistSem=new QSemaphore(threads);
+
+    int threads = QThread::idealThreadCount();
+    savelistSem = new QSemaphore(threads);
     savelistSem->acquire(threads);
-    QVector<SaveThread*>thread;
-    for (int i=0;i<threads;i++) {
-        thread.push_back(new SaveThread(this,path));
-        QObject::connect(thread[i],SIGNAL(UpdateProgress(int)),qprogress,SLOT(setValue(int)));
+    QVector<SaveThread *>thread;
+
+    for (int i = 0; i < threads; i++) {
+        thread.push_back(new SaveThread(this, path));
+        QObject::connect(thread[i], SIGNAL(UpdateProgress(int)), qprogress, SLOT(setValue(int)));
         thread[i]->start();
     }
-    while (!savelistSem->tryAcquire(threads,250)) {
+
+    while (!savelistSem->tryAcquire(threads, 250)) {
         if (qprogress) {
-        //    qprogress->setValue(66.0+(float(savelistCnt)/float(savelistSize)*33.0));
-           QApplication::processEvents();
+            //    qprogress->setValue(66.0+(float(savelistCnt)/float(savelistSize)*33.0));
+            QApplication::processEvents();
         }
     }
 
-    for (int i=0;i<threads;i++) {
+    for (int i = 0; i < threads; i++) {
         while (thread[i]->isRunning()) {
             SaveThread::msleep(250);
             QApplication::processEvents();
         }
+
         delete thread[i];
     }
 
@@ -387,29 +441,34 @@ bool Machine::Save()
 
 void SaveThread::run()
 {
-    bool cachesessions=PROFILE.session->cacheSessions();
+    bool cachesessions = PROFILE.session->cacheSessions();
 
-    while (Session *sess=machine->popSaveList()) {
-        int i=(float(machine->savelistCnt)/float(machine->savelistSize)*100.0);
+    while (Session *sess = machine->popSaveList()) {
+        int i = (float(machine->savelistCnt) / float(machine->savelistSize) * 100.0);
         emit UpdateProgress(i);
         sess->UpdateSummaries();
         sess->Store(path);
-        if (!cachesessions)
+
+        if (!cachesessions) {
             sess->TrashEvents();
+        }
     }
+
     machine->savelistSem->release(1);
 }
 
 Session *Machine::popSaveList()
 {
 
-    Session *sess=NULL;
+    Session *sess = NULL;
     savelistMutex.lock();
-    if (m_savelist.size()>0) {
-        sess=m_savelist.at(0);
+
+    if (m_savelist.size() > 0) {
+        sess = m_savelist.at(0);
         m_savelist.pop_front();
         savelistCnt++;
     }
+
     savelistMutex.unlock();
     return sess;
 }
@@ -417,9 +476,9 @@ Session *Machine::popSaveList()
 //////////////////////////////////////////////////////////////////////////////////////////
 // CPAP implmementation
 //////////////////////////////////////////////////////////////////////////////////////////
-CPAP::CPAP(Profile *p,MachineID id):Machine(p,id)
+CPAP::CPAP(Profile *p, MachineID id): Machine(p, id)
 {
-    m_type=MT_CPAP;
+    m_type = MT_CPAP;
 }
 
 CPAP::~CPAP()
@@ -429,9 +488,9 @@ CPAP::~CPAP()
 //////////////////////////////////////////////////////////////////////////////////////////
 // Oximeter Class implmementation
 //////////////////////////////////////////////////////////////////////////////////////////
-Oximeter::Oximeter(Profile *p,MachineID id):Machine(p,id)
+Oximeter::Oximeter(Profile *p, MachineID id): Machine(p, id)
 {
-    m_type=MT_OXIMETER;
+    m_type = MT_OXIMETER;
 }
 
 Oximeter::~Oximeter()
@@ -441,9 +500,9 @@ Oximeter::~Oximeter()
 //////////////////////////////////////////////////////////////////////////////////////////
 // SleepStage Class implmementation
 //////////////////////////////////////////////////////////////////////////////////////////
-SleepStage::SleepStage(Profile *p,MachineID id):Machine(p,id)
+SleepStage::SleepStage(Profile *p, MachineID id): Machine(p, id)
 {
-    m_type=MT_SLEEPSTAGE;
+    m_type = MT_SLEEPSTAGE;
 }
 SleepStage::~SleepStage()
 {
@@ -452,9 +511,9 @@ SleepStage::~SleepStage()
 //////////////////////////////////////////////////////////////////////////////////////////
 // PositionSensor Class implmementation
 //////////////////////////////////////////////////////////////////////////////////////////
-PositionSensor::PositionSensor(Profile *p,MachineID id):Machine(p,id)
+PositionSensor::PositionSensor(Profile *p, MachineID id): Machine(p, id)
 {
-    m_type=MT_POSITION;
+    m_type = MT_POSITION;
 }
 PositionSensor::~PositionSensor()
 {
@@ -462,14 +521,19 @@ PositionSensor::~PositionSensor()
 
 
 ChannelID NoChannel, SESSION_ENABLED;
-ChannelID CPAP_IPAP, CPAP_IPAPLo, CPAP_IPAPHi, CPAP_EPAP, CPAP_EPAPLo, CPAP_EPAPHi, CPAP_Pressure, CPAP_PS, CPAP_Mode, CPAP_AHI,
-CPAP_PressureMin, CPAP_PressureMax, CPAP_RampTime, CPAP_RampPressure, CPAP_Obstructive, CPAP_Hypopnea,
-CPAP_ClearAirway, CPAP_Apnea, CPAP_CSR, CPAP_LeakFlag, CPAP_ExP, CPAP_NRI, CPAP_VSnore, CPAP_VSnore2,
-CPAP_RERA, CPAP_PressurePulse, CPAP_FlowLimit, CPAP_FlowRate, CPAP_MaskPressure, CPAP_MaskPressureHi,
-CPAP_RespEvent, CPAP_Snore, CPAP_MinuteVent, CPAP_RespRate, CPAP_TidalVolume, CPAP_PTB, CPAP_Leak,
-CPAP_LeakMedian, CPAP_LeakTotal, CPAP_MaxLeak, CPAP_FLG, CPAP_IE, CPAP_Te, CPAP_Ti, CPAP_TgMV,
-CPAP_UserFlag1, CPAP_UserFlag2, CPAP_UserFlag3, CPAP_BrokenSummary, CPAP_BrokenWaveform, CPAP_RDI,
-CPAP_PresReliefSet, CPAP_PresReliefMode, CPAP_PresReliefType, CPAP_PSMin, CPAP_PSMax, CPAP_Test1, CPAP_Test2;
+ChannelID CPAP_IPAP, CPAP_IPAPLo, CPAP_IPAPHi, CPAP_EPAP, CPAP_EPAPLo, CPAP_EPAPHi, CPAP_Pressure,
+          CPAP_PS, CPAP_Mode, CPAP_AHI,
+          CPAP_PressureMin, CPAP_PressureMax, CPAP_RampTime, CPAP_RampPressure, CPAP_Obstructive,
+          CPAP_Hypopnea,
+          CPAP_ClearAirway, CPAP_Apnea, CPAP_CSR, CPAP_LeakFlag, CPAP_ExP, CPAP_NRI, CPAP_VSnore,
+          CPAP_VSnore2,
+          CPAP_RERA, CPAP_PressurePulse, CPAP_FlowLimit, CPAP_FlowRate, CPAP_MaskPressure,
+          CPAP_MaskPressureHi,
+          CPAP_RespEvent, CPAP_Snore, CPAP_MinuteVent, CPAP_RespRate, CPAP_TidalVolume, CPAP_PTB, CPAP_Leak,
+          CPAP_LeakMedian, CPAP_LeakTotal, CPAP_MaxLeak, CPAP_FLG, CPAP_IE, CPAP_Te, CPAP_Ti, CPAP_TgMV,
+          CPAP_UserFlag1, CPAP_UserFlag2, CPAP_UserFlag3, CPAP_BrokenSummary, CPAP_BrokenWaveform, CPAP_RDI,
+          CPAP_PresReliefSet, CPAP_PresReliefMode, CPAP_PresReliefType, CPAP_PSMin, CPAP_PSMax, CPAP_Test1,
+          CPAP_Test2;
 
 
 ChannelID RMS9_E01, RMS9_E02, RMS9_EPR, RMS9_EPRSet, RMS9_SetPressure;
@@ -477,16 +541,21 @@ ChannelID INTP_SmartFlex;
 ChannelID INTELLIPAP_Unknown1, INTELLIPAP_Unknown2;
 
 ChannelID PRS1_00, PRS1_01, PRS1_08, PRS1_0A, PRS1_0B, PRS1_0C, PRS1_0E, PRS1_0F, PRS1_10, PRS1_12,
-PRS1_FlexMode, PRS1_FlexSet, PRS1_HumidStatus, CPAP_HumidSetting, PRS1_SysLock, PRS1_SysOneResistStat,
-PRS1_SysOneResistSet, PRS1_HoseDiam, PRS1_AutoOn, PRS1_AutoOff, PRS1_MaskAlert, PRS1_ShowAHI;
+          PRS1_FlexMode, PRS1_FlexSet, PRS1_HumidStatus, CPAP_HumidSetting, PRS1_SysLock,
+          PRS1_SysOneResistStat,
+          PRS1_SysOneResistSet, PRS1_HoseDiam, PRS1_AutoOn, PRS1_AutoOff, PRS1_MaskAlert, PRS1_ShowAHI;
 
 ChannelID OXI_Pulse, OXI_SPO2, OXI_PulseChange, OXI_SPO2Drop, OXI_Plethy;
 
-ChannelID Journal_Notes, Journal_Weight, Journal_BMI, Journal_ZombieMeter, Bookmark_Start, Bookmark_End, Bookmark_Notes;
+ChannelID Journal_Notes, Journal_Weight, Journal_BMI, Journal_ZombieMeter, Bookmark_Start,
+          Bookmark_End, Bookmark_Notes;
 
 
-ChannelID ZEO_SleepStage, ZEO_ZQ, ZEO_TotalZ, ZEO_TimeToZ, ZEO_TimeInWake, ZEO_TimeInREM, ZEO_TimeInLight, ZEO_TimeInDeep, ZEO_Awakenings,
-ZEO_AlarmReason, ZEO_SnoozeTime, ZEO_WakeTone, ZEO_WakeWindow, ZEO_AlarmType, ZEO_MorningFeel, ZEO_FirmwareVersion,
-ZEO_FirstAlarmRing, ZEO_LastAlarmRing, ZEO_FirstSnoozeTime, ZEO_LastSnoozeTime, ZEO_SetAlarmTime, ZEO_RiseTime;
+ChannelID ZEO_SleepStage, ZEO_ZQ, ZEO_TotalZ, ZEO_TimeToZ, ZEO_TimeInWake, ZEO_TimeInREM,
+          ZEO_TimeInLight, ZEO_TimeInDeep, ZEO_Awakenings,
+          ZEO_AlarmReason, ZEO_SnoozeTime, ZEO_WakeTone, ZEO_WakeWindow, ZEO_AlarmType, ZEO_MorningFeel,
+          ZEO_FirmwareVersion,
+          ZEO_FirstAlarmRing, ZEO_LastAlarmRing, ZEO_FirstSnoozeTime, ZEO_LastSnoozeTime, ZEO_SetAlarmTime,
+          ZEO_RiseTime;
 
 ChannelID POS_Orientation, POS_Inclination;
diff --git a/sleepyhead/SleepLib/machine.h b/sleepyhead/SleepLib/machine.h
index 5f5453d8..0f3ef13c 100644
--- a/sleepyhead/SleepLib/machine.h
+++ b/sleepyhead/SleepLib/machine.h
@@ -40,21 +40,21 @@ class Machine;
 /*! \class SaveThread
     \brief This class is used in the multithreaded save code.. It accelerates the indexing of summary data.
     */
-class SaveThread:public QThread
+class SaveThread: public QThread
 {
     Q_OBJECT
-public:
-    SaveThread(Machine *m,QString p) { machine=m; path=p; }
+  public:
+    SaveThread(Machine *m, QString p) { machine = m; path = p; }
 
     //! \brief Static millisecond sleep function.. Can be used from anywhere
     static void msleep(unsigned long msecs) { QThread::msleep(msecs); }
 
     //! \brief Start Save processing thread running
     virtual void run();
-protected:
+  protected:
     Machine *machine;
     QString path;
-signals:
+  signals:
     //! \brief Signal sent to update the Progress Bar
     void UpdateProgress(int i);
 };
@@ -66,13 +66,13 @@ signals:
     */
 class Machine
 {
-public:
+  public:
     /*! \fn Machine(Profile *p,MachineID id=0);
         \brief Constructs a Machine object in Profile p, and with MachineID id
 
         If supplied MachineID is zero, it will generate a new unused random one.
         */
-    Machine(Profile *p,MachineID id=0);
+    Machine(Profile *p, MachineID id = 0);
     virtual ~Machine();
 
     //! \brief Load all Machine summary data
@@ -87,50 +87,50 @@ public:
     bool Purge(int secret);
 
     //! \brief Contains a secondary index of day data, containing just this machines sessions
-    QMap<QDate,Day *> day;
+    QMap<QDate, Day *> day;
 
     //! \brief Contains all sessions for this machine, indexed by SessionID
-    QHash<SessionID,Session *> sessionlist;
+    QHash<SessionID, Session *> sessionlist;
 
     //! \brief List of text machine properties, like brand, model, etc...
-    QHash<QString,QString> properties;
+    QHash<QString, QString> properties;
 
     //! \brief Returns a pointer to a valid Session object if SessionID exists
-    Session * SessionExists(SessionID session);
+    Session *SessionExists(SessionID session);
 
     //! \brief Adds the session to this machine object, and the Master Profile list. (used during load)
-    QDate AddSession(Session *s,Profile *p);
+    QDate AddSession(Session *s, Profile *p);
 
     //! \brief Find the date this session belongs in, according to profile settings
     QDate pickDate(qint64 start);
 
     //! \brief Sets the Class of machine (Used to reference the particular loader that created it)
-    void SetClass(QString t) { m_class=t; }
+    void SetClass(QString t) { m_class = t; }
 
     //! \brief Sets the type of machine, according to MachineType enum
-    void SetType(MachineType t) { m_type=t; }
+    void SetType(MachineType t) { m_type = t; }
 
     //! \brief Returns the Class of machine (Used to reference the particular loader that created it)
-    const QString & GetClass() { return m_class; }
+    const QString &GetClass() { return m_class; }
 
     //! \brief Returns the type of machine, according to MachineType enum
-    const MachineType & GetType() { return m_type; }
+    const MachineType &GetType() { return m_type; }
 
     //! \brief Returns the machineID as a lower case hexadecimal string
-    QString hexid() { return QString().sprintf("%08lx",m_id); }
+    QString hexid() { return QString().sprintf("%08lx", m_id); }
 
 
     //! \brief Unused, increments the most recent sessionID
-    SessionID CreateSessionID() { return highest_sessionid+1; }
+    SessionID CreateSessionID() { return highest_sessionid + 1; }
 
     //! \brief Returns this objects MachineID
-    const MachineID & id() { return m_id; }
+    const MachineID &id() { return m_id; }
 
     //! \brief Returns the date of the first loaded Session
-    const QDate & FirstDay() { return firstday; }
+    const QDate &FirstDay() { return firstday; }
 
     //! \brief Returns the date of the most recent loaded Session
-    const QDate & LastDay() { return lastday; }
+    const QDate &LastDay() { return lastday; }
 
     //! \brief Grab the next task in the multithreaded save code
     Session *popSaveList();
@@ -143,8 +143,8 @@ public:
     QMutex savelistMutex;
     QSemaphore *savelistSem;
 
-protected:
-    QDate firstday,lastday;
+  protected:
+    QDate firstday, lastday;
     SessionID highest_sessionid;
     MachineID m_id;
     QString m_class;
@@ -159,10 +159,10 @@ protected:
 /*! \class CPAP
     \brief A CPAP classed machine object..
     */
-class CPAP:public Machine
+class CPAP: public Machine
 {
-public:
-    CPAP(Profile *p,MachineID id=0);
+  public:
+    CPAP(Profile *p, MachineID id = 0);
     virtual ~CPAP();
 };
 
@@ -170,34 +170,34 @@ public:
 /*! \class Oximeter
     \brief An Oximeter classed machine object..
     */
-class Oximeter:public Machine
+class Oximeter: public Machine
 {
-public:
-    Oximeter(Profile *p,MachineID id=0);
+  public:
+    Oximeter(Profile *p, MachineID id = 0);
     virtual ~Oximeter();
-protected:
+  protected:
 };
 
 /*! \class SleepStage
     \brief A SleepStage classed machine object..
     */
-class SleepStage:public Machine
+class SleepStage: public Machine
 {
-public:
-    SleepStage(Profile *p,MachineID id=0);
+  public:
+    SleepStage(Profile *p, MachineID id = 0);
     virtual ~SleepStage();
-protected:
+  protected:
 };
 
 /*! \class PositionSensor
     \brief A PositionSensor classed machine object..
     */
-class PositionSensor:public Machine
+class PositionSensor: public Machine
 {
-public:
-    PositionSensor(Profile *p,MachineID id=0);
+  public:
+    PositionSensor(Profile *p, MachineID id = 0);
     virtual ~PositionSensor();
-protected:
+  protected:
 };
 
 #endif // MACHINE_H
diff --git a/sleepyhead/SleepLib/machine_common.h b/sleepyhead/SleepLib/machine_common.h
index 53571790..7f75b89f 100644
--- a/sleepyhead/SleepLib/machine_common.h
+++ b/sleepyhead/SleepLib/machine_common.h
@@ -33,7 +33,7 @@ class BoundsError {};
 //! \brief Exception class for to trap old database versions.
 class OldDBVersion {};
 
-const quint32 magic=0xC73216AB; // Magic number for SleepyHead Data Files.. Don't touch!
+const quint32 magic = 0xC73216AB; // Magic number for SleepyHead Data Files.. Don't touch!
 
 //const int max_number_event_fields=10;
 // This should probably move somewhere else
@@ -50,28 +50,25 @@ enum SummaryType { ST_CNT, ST_SUM, ST_AVG, ST_WAVG, ST_PERC, ST_90P, ST_MIN, ST_
 /*! \enum MachineType
     \brief Generalized type of a machine
   */
-enum MachineType { MT_UNKNOWN=0,MT_CPAP,MT_OXIMETER,MT_SLEEPSTAGE,MT_JOURNAL,MT_POSITION };
+enum MachineType { MT_UNKNOWN = 0, MT_CPAP, MT_OXIMETER, MT_SLEEPSTAGE, MT_JOURNAL, MT_POSITION };
 //void InitMapsWithoutAwesomeInitializerLists();
 
 
 /*! \enum CPAPMode
     \brief CPAP Machines mode of operation
   */
-enum CPAPMode//:short
-{
-    MODE_UNKNOWN=0,MODE_CPAP,MODE_APAP,MODE_BIPAP,MODE_ASV
+enum CPAPMode { //:short
+    MODE_UNKNOWN = 0, MODE_CPAP, MODE_APAP, MODE_BIPAP, MODE_ASV
 };
 
 /*! \enum PRTypes
     \brief Pressure Relief Types, used by CPAP machines
   */
-enum PRTypes//:short
-{
-    PR_UNKNOWN=0,PR_NONE,PR_CFLEX,PR_CFLEXPLUS,PR_AFLEX,PR_BIFLEX,PR_EPR,PR_SMARTFLEX,PR_EASYBREATHE,PR_SENSAWAKE
+enum PRTypes { //:short
+    PR_UNKNOWN = 0, PR_NONE, PR_CFLEX, PR_CFLEXPLUS, PR_AFLEX, PR_BIFLEX, PR_EPR, PR_SMARTFLEX, PR_EASYBREATHE, PR_SENSAWAKE
 };
-enum PRModes//:short
-{
-    PM_UNKNOWN=0,PM_RampOnly,PM_FullTime
+enum PRModes { //:short
+    PM_UNKNOWN = 0, PM_RampOnly, PM_FullTime
 };
 
 
@@ -85,35 +82,45 @@ enum PRModes//:short
     */
 
 enum MCDataType
-{ MC_bool=0, MC_int, MC_long, MC_float, MC_double, MC_string, MC_datetime };
+{ MC_bool = 0, MC_int, MC_long, MC_float, MC_double, MC_string, MC_datetime };
 
 
-extern ChannelID NoChannel,SESSION_ENABLED;
-extern ChannelID CPAP_IPAP, CPAP_IPAPLo, CPAP_IPAPHi, CPAP_EPAP, CPAP_EPAPLo, CPAP_EPAPHi, CPAP_Pressure, CPAP_PS, CPAP_PSMin, CPAP_PSMax,
-CPAP_Mode, CPAP_AHI,
-CPAP_PressureMin, CPAP_PressureMax, CPAP_RampTime, CPAP_RampPressure, CPAP_Obstructive, CPAP_Hypopnea,
-CPAP_ClearAirway, CPAP_Apnea, CPAP_CSR, CPAP_LeakFlag, CPAP_ExP, CPAP_NRI, CPAP_VSnore, CPAP_VSnore2,
-CPAP_RERA, CPAP_PressurePulse, CPAP_FlowLimit, CPAP_FlowRate, CPAP_MaskPressure, CPAP_MaskPressureHi,
-CPAP_RespEvent, CPAP_Snore, CPAP_MinuteVent, CPAP_RespRate, CPAP_TidalVolume, CPAP_PTB, CPAP_Leak,
-CPAP_LeakMedian, CPAP_LeakTotal, CPAP_MaxLeak, CPAP_FLG, CPAP_IE, CPAP_Te, CPAP_Ti, CPAP_TgMV,
-CPAP_UserFlag1, CPAP_UserFlag2, CPAP_UserFlag3, CPAP_BrokenSummary, CPAP_BrokenWaveform, CPAP_RDI,
-CPAP_PresReliefSet, CPAP_PresReliefMode, CPAP_PresReliefType, CPAP_Test1, CPAP_Test2;
+extern ChannelID NoChannel, SESSION_ENABLED;
+extern ChannelID CPAP_IPAP, CPAP_IPAPLo, CPAP_IPAPHi, CPAP_EPAP, CPAP_EPAPLo, CPAP_EPAPHi,
+       CPAP_Pressure, CPAP_PS, CPAP_PSMin, CPAP_PSMax,
+       CPAP_Mode, CPAP_AHI,
+       CPAP_PressureMin, CPAP_PressureMax, CPAP_RampTime, CPAP_RampPressure, CPAP_Obstructive,
+       CPAP_Hypopnea,
+       CPAP_ClearAirway, CPAP_Apnea, CPAP_CSR, CPAP_LeakFlag, CPAP_ExP, CPAP_NRI, CPAP_VSnore,
+       CPAP_VSnore2,
+       CPAP_RERA, CPAP_PressurePulse, CPAP_FlowLimit, CPAP_FlowRate, CPAP_MaskPressure,
+       CPAP_MaskPressureHi,
+       CPAP_RespEvent, CPAP_Snore, CPAP_MinuteVent, CPAP_RespRate, CPAP_TidalVolume, CPAP_PTB, CPAP_Leak,
+       CPAP_LeakMedian, CPAP_LeakTotal, CPAP_MaxLeak, CPAP_FLG, CPAP_IE, CPAP_Te, CPAP_Ti, CPAP_TgMV,
+       CPAP_UserFlag1, CPAP_UserFlag2, CPAP_UserFlag3, CPAP_BrokenSummary, CPAP_BrokenWaveform, CPAP_RDI,
+       CPAP_PresReliefSet, CPAP_PresReliefMode, CPAP_PresReliefType, CPAP_Test1, CPAP_Test2;
 
 extern ChannelID RMS9_E01, RMS9_E02, RMS9_EPR, RMS9_EPRSet, RMS9_SetPressure;
 extern ChannelID INTP_SmartFlex;
-extern ChannelID PRS1_00, PRS1_01, PRS1_08, PRS1_0A, PRS1_0B, PRS1_0C, PRS1_0E, PRS1_0F, PRS1_10, PRS1_12,
-PRS1_FlexMode, PRS1_FlexSet, PRS1_HumidStatus, CPAP_HumidSetting, PRS1_SysLock, PRS1_SysOneResistStat,
-PRS1_SysOneResistSet, PRS1_HoseDiam, PRS1_AutoOn, PRS1_AutoOff, PRS1_MaskAlert, PRS1_ShowAHI;
+extern ChannelID PRS1_00, PRS1_01, PRS1_08, PRS1_0A, PRS1_0B, PRS1_0C, PRS1_0E, PRS1_0F, PRS1_10,
+       PRS1_12,
+       PRS1_FlexMode, PRS1_FlexSet, PRS1_HumidStatus, CPAP_HumidSetting, PRS1_SysLock,
+       PRS1_SysOneResistStat,
+       PRS1_SysOneResistSet, PRS1_HoseDiam, PRS1_AutoOn, PRS1_AutoOff, PRS1_MaskAlert, PRS1_ShowAHI;
 
 extern ChannelID INTELLIPAP_Unknown1, INTELLIPAP_Unknown2;
 
 extern ChannelID OXI_Pulse, OXI_SPO2, OXI_PulseChange, OXI_SPO2Drop, OXI_Plethy;
 
-extern ChannelID Journal_Notes, Journal_Weight, Journal_BMI, Journal_ZombieMeter, Bookmark_Start, Bookmark_End, Bookmark_Notes;
+extern ChannelID Journal_Notes, Journal_Weight, Journal_BMI, Journal_ZombieMeter, Bookmark_Start,
+       Bookmark_End, Bookmark_Notes;
 
-extern ChannelID ZEO_SleepStage, ZEO_ZQ, ZEO_TotalZ, ZEO_TimeToZ, ZEO_TimeInWake, ZEO_TimeInREM, ZEO_TimeInLight, ZEO_TimeInDeep, ZEO_Awakenings,
-ZEO_AlarmReason, ZEO_SnoozeTime, ZEO_WakeTone, ZEO_WakeWindow, ZEO_AlarmType, ZEO_MorningFeel, ZEO_FirmwareVersion,
-ZEO_FirstAlarmRing, ZEO_LastAlarmRing, ZEO_FirstSnoozeTime, ZEO_LastSnoozeTime, ZEO_SetAlarmTime, ZEO_RiseTime;
+extern ChannelID ZEO_SleepStage, ZEO_ZQ, ZEO_TotalZ, ZEO_TimeToZ, ZEO_TimeInWake, ZEO_TimeInREM,
+       ZEO_TimeInLight, ZEO_TimeInDeep, ZEO_Awakenings,
+       ZEO_AlarmReason, ZEO_SnoozeTime, ZEO_WakeTone, ZEO_WakeWindow, ZEO_AlarmType, ZEO_MorningFeel,
+       ZEO_FirmwareVersion,
+       ZEO_FirstAlarmRing, ZEO_LastAlarmRing, ZEO_FirstSnoozeTime, ZEO_LastSnoozeTime, ZEO_SetAlarmTime,
+       ZEO_RiseTime;
 
 extern ChannelID POS_Orientation, POS_Inclination;
 
diff --git a/sleepyhead/SleepLib/machine_loader.cpp b/sleepyhead/SleepLib/machine_loader.cpp
index f6eb3b7a..61700691 100644
--- a/sleepyhead/SleepLib/machine_loader.cpp
+++ b/sleepyhead/SleepLib/machine_loader.cpp
@@ -28,9 +28,10 @@ void RegisterLoader(MachineLoader *loader)
 }
 void DestroyLoaders()
 {
-    for (QList<MachineLoader *>::iterator i=m_loaders.begin(); i!=m_loaders.end(); i++) {
-        delete (*i);
+    for (QList<MachineLoader *>::iterator i = m_loaders.begin(); i != m_loaders.end(); i++) {
+        delete(*i);
     }
+
     m_loaders.clear();
 }
 
@@ -45,44 +46,52 @@ MachineLoader::MachineLoader()
 }*/
 MachineLoader::~MachineLoader()
 {
-    for (QList<Machine *>::iterator m=m_machlist.begin();m!=m_machlist.end();m++) {
+    for (QList<Machine *>::iterator m = m_machlist.begin(); m != m_machlist.end(); m++) {
         delete *m;
     }
 }
 
 bool MachineLoader::compressFile(QString inpath, QString outpath)
 {
-    if (outpath.isEmpty())
-        outpath=inpath+".gz";
-    else if (!outpath.endsWith(".gz")) {
-        outpath+=".gz";
+    if (outpath.isEmpty()) {
+        outpath = inpath + ".gz";
+    } else if (!outpath.endsWith(".gz")) {
+        outpath += ".gz";
     }
 
     QFile f(inpath);
+
     if (!f.exists(inpath)) {
         qDebug() << "compressFile()" << inpath << "does not exist";
         return false;
     }
-    qint64 size=f.size();
+
+    qint64 size = f.size();
+
     if (!f.open(QFile::ReadOnly)) {
         qDebug() << "compressFile() Couldn't open" << inpath;
         return false;
     }
-    char * buf=new char [size];
-    if (!f.read(buf,size)) {
+
+    char *buf = new char [size];
+
+    if (!f.read(buf, size)) {
         delete buf;
         qDebug() << "compressFile() Couldn't read all of" << inpath;
         return false;
     }
+
     f.close();
-    gzFile gz=gzopen(outpath.toLatin1(),"wb");
+    gzFile gz = gzopen(outpath.toLatin1(), "wb");
+
     //gzbuffer(gz,65536*2);
     if (!gz) {
-        qDebug() << "compressFile() Couldn't open" << outpath <<"for writing";
+        qDebug() << "compressFile() Couldn't open" << outpath << "for writing";
         delete buf;
         return false;
     }
-    gzwrite(gz,buf,size);
+
+    gzwrite(gz, buf, size);
     gzclose(gz);
     delete buf;
     return true;
diff --git a/sleepyhead/SleepLib/machine_loader.h b/sleepyhead/SleepLib/machine_loader.h
index e5617c1c..331c13ba 100644
--- a/sleepyhead/SleepLib/machine_loader.h
+++ b/sleepyhead/SleepLib/machine_loader.h
@@ -21,7 +21,7 @@
     */
 class MachineLoader
 {
-public:
+  public:
     MachineLoader();
     virtual ~MachineLoader();
 
@@ -29,43 +29,43 @@ public:
     //virtual Machine * CreateMachine() {};
 
     //! \brief Override this to scan path and detect new machine data
-    virtual int Open(QString & path,Profile *)=0;   // Scans for new content
+    virtual int Open(QString &path, Profile *) = 0; // Scans for new content
 
     //! \brief Override to returns the Version number of this MachineLoader
-    virtual int Version()=0;
+    virtual int Version() = 0;
 
     //! \brief Override to returns the class name of this MachineLoader
-    virtual const QString & ClassName()=0;
+    virtual const QString &ClassName() = 0;
 
-    bool compressFile(QString inpath, QString outpath="");
+    bool compressFile(QString inpath, QString outpath = "");
 
 
- /*
-    MachineLoader(Profile *profile,QString & classname);
-    virtual void LoadMachineList();
-    virtual void SaveMachineList();
-    virtual bool LoadSummaries();
-    virtual bool LoadEvents();
-    virtual bool LoadWaveforms();
-    virtual bool Scan(QString &)=0;   // Scans for new content
+    /*
+       MachineLoader(Profile *profile,QString & classname);
+       virtual void LoadMachineList();
+       virtual void SaveMachineList();
+       virtual bool LoadSummaries();
+       virtual bool LoadEvents();
+       virtual bool LoadWaveforms();
+       virtual bool Scan(QString &)=0;   // Scans for new content
 
-    virtual bool LoadAll();
-    virtual bool SaveAll();
+       virtual bool LoadAll();
+       virtual bool SaveAll();
 
-    virtual bool LoadSummary(Machine * m, QString & filename);
-    virtual bool LoadEvent(Machine * m, QString & filename);
-    virtual bool LoadWaveform(Machine * m, QString & filename);
+       virtual bool LoadSummary(Machine * m, QString & filename);
+       virtual bool LoadEvent(Machine * m, QString & filename);
+       virtual bool LoadWaveform(Machine * m, QString & filename);
 
-    virtual bool SaveSummary(Machine * m, QString & filename);
-    virtual bool SaveEvent(Machine * m, QString & filename);
-    virtual bool SaveWaveform(Machine * m, QString & filename);*/
+       virtual bool SaveSummary(Machine * m, QString & filename);
+       virtual bool SaveEvent(Machine * m, QString & filename);
+       virtual bool SaveWaveform(Machine * m, QString & filename);*/
 
-protected:
+  protected:
     //! \brief Contains a list of Machine records known by this loader
     QList<Machine *> m_machlist;
     QString m_class;
     MachineType m_type;
-    Profile * m_profile;
+    Profile *m_profile;
 };
 
 // Put in machine loader class as static??
diff --git a/sleepyhead/SleepLib/preferences.cpp b/sleepyhead/SleepLib/preferences.cpp
index 65bdce88..bccaae92 100644
--- a/sleepyhead/SleepLib/preferences.cpp
+++ b/sleepyhead/SleepLib/preferences.cpp
@@ -27,29 +27,31 @@
 #include "common.h"
 #include "preferences.h"
 
-const QString & getUserName()
+const QString &getUserName()
 {
     static QString userName;
-    userName=getenv("USER");
+    userName = getenv("USER");
 
     if (userName.isEmpty()) {
-        userName=QObject::tr("Windows User");
+        userName = QObject::tr("Windows User");
 
 #if defined (Q_OS_WIN32)
-    #if defined(UNICODE)
-    if (QSysInfo::WindowsVersion >= QSysInfo::WV_NT) {
-        TCHAR winUserName[UNLEN + 1]; // UNLEN is defined in LMCONS.H
-        DWORD winUserNameSize = sizeof(winUserName);
-        GetUserNameW( winUserName, &winUserNameSize );
-        userName = QString::fromStdWString( winUserName );
-    } else
-    #endif
-    {
-        char winUserName[UNLEN + 1]; // UNLEN is defined in LMCONS.H
-        DWORD winUserNameSize = sizeof(winUserName);
-        GetUserNameA( winUserName, &winUserNameSize );
-        userName = QString::fromLocal8Bit( winUserName );
-    }
+#if defined(UNICODE)
+
+        if (QSysInfo::WindowsVersion >= QSysInfo::WV_NT) {
+            TCHAR winUserName[UNLEN + 1]; // UNLEN is defined in LMCONS.H
+            DWORD winUserNameSize = sizeof(winUserName);
+            GetUserNameW(winUserName, &winUserNameSize);
+            userName = QString::fromStdWString(winUserName);
+        } else
+#endif
+        {
+            char winUserName[UNLEN + 1]; // UNLEN is defined in LMCONS.H
+            DWORD winUserNameSize = sizeof(winUserName);
+            GetUserNameA(winUserName, &winUserNameSize);
+            userName = QString::fromLocal8Bit(winUserName);
+        }
+
 #endif
     }
 
@@ -61,16 +63,18 @@ QString GetAppRoot()
 {
     QSettings settings(getDeveloperName(), getAppName());
 
-    QString HomeAppRoot=settings.value("Settings/AppRoot").toString();
+    QString HomeAppRoot = settings.value("Settings/AppRoot").toString();
 
 #if QT_VERSION  < QT_VERSION_CHECK(5,0,0)
-    const QString desktopFolder=QDesktopServices::storageLocation(QDesktopServices::DocumentsLocation);
+    const QString desktopFolder = QDesktopServices::storageLocation(
+                                      QDesktopServices::DocumentsLocation);
 #else
-    const QString desktopFolder=QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
+    const QString desktopFolder = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
 #endif
 
-    if (HomeAppRoot.isEmpty())
-        HomeAppRoot=desktopFolder+"/"+getDefaultAppRoot();
+    if (HomeAppRoot.isEmpty()) {
+        HomeAppRoot = desktopFolder + "/" + getDefaultAppRoot();
+    }
 
     return HomeAppRoot;
 }
@@ -78,28 +82,28 @@ QString GetAppRoot()
 
 Preferences::Preferences()
 {
-    p_name="Preferences";
-    p_path=GetAppRoot();
+    p_name = "Preferences";
+    p_path = GetAppRoot();
 }
 
-Preferences::Preferences(QString name,QString filename)
+Preferences::Preferences(QString name, QString filename)
 {
     if (name.endsWith(STR_ext_XML)) {
-        p_name=name.section(".",0,0);
+        p_name = name.section(".", 0, 0);
     } else {
-        p_name=name;
+        p_name = name;
     }
 
     if (filename.isEmpty()) {
-        p_filename=GetAppRoot()+"/"+p_name+STR_ext_XML;
+        p_filename = GetAppRoot() + "/" + p_name + STR_ext_XML;
     } else {
         if (!filename.contains("/")) {
-            p_filename=GetAppRoot()+"/";
-        } else p_filename="";
+            p_filename = GetAppRoot() + "/";
+        } else { p_filename = ""; }
 
-        p_filename+=filename;
+        p_filename += filename;
 
-        if (!p_filename.endsWith(STR_ext_XML)) p_filename+=STR_ext_XML;
+        if (!p_filename.endsWith(STR_ext_XML)) { p_filename += STR_ext_XML; }
     }
 }
 
@@ -122,41 +126,48 @@ Preferences::~Preferences()
 const QString Preferences::Get(QString name)
 {
     QString temp;
-    QChar obr=QChar('{');
-    QChar cbr=QChar('}');
-    QString t,a,ref; // How I miss Regular Expressions here..
-    if (p_preferences.find(name)!=p_preferences.end()) {
-        temp="";
-        t=p_preferences[name].toString();
-        if (p_preferences[name].type()!=QVariant::String) {
+    QChar obr = QChar('{');
+    QChar cbr = QChar('}');
+    QString t, a, ref; // How I miss Regular Expressions here..
+
+    if (p_preferences.find(name) != p_preferences.end()) {
+        temp = "";
+        t = p_preferences[name].toString();
+
+        if (p_preferences[name].type() != QVariant::String) {
             return t;
         }
     } else {
-        t=name; // parse the string..
+        t = name; // parse the string..
     }
+
     while (t.contains(obr)) {
-        temp+=t.section(obr,0,0);
-        a=t.section(obr,1);
+        temp += t.section(obr, 0, 0);
+        a = t.section(obr, 1);
+
         if (a.startsWith("{")) {
-            temp+=obr;
-            t=a.section(obr,1);
+            temp += obr;
+            t = a.section(obr, 1);
             continue;
         }
-        ref=a.section(cbr,0,0);
 
-        if (ref.toLower()=="home") {
-            temp+=GetAppRoot();
-        } else if (ref.toLower()=="user") {
-            temp+=getUserName();
-        } else if (ref.toLower()=="sep") { // redundant in QT
-            temp+="/";
+        ref = a.section(cbr, 0, 0);
+
+        if (ref.toLower() == "home") {
+            temp += GetAppRoot();
+        } else if (ref.toLower() == "user") {
+            temp += getUserName();
+        } else if (ref.toLower() == "sep") { // redundant in QT
+            temp += "/";
         } else {
-            temp+=Get(ref);
+            temp += Get(ref);
         }
-        t=a.section(cbr,1);
+
+        t = a.section(cbr, 1);
     }
-    temp+=t;
-    temp.replace("}}","}"); // Make things look a bit better when escaping braces.
+
+    temp += t;
+    temp.replace("}}", "}"); // Make things look a bit better when escaping braces.
 
     return temp;
 }
@@ -164,133 +175,154 @@ const QString Preferences::Get(QString name)
 
 bool Preferences::Open(QString filename)
 {
-    if (!filename.isEmpty())
-        p_filename=filename;
+    if (!filename.isEmpty()) {
+        p_filename = filename;
+    }
 
     QDomDocument doc(p_name);
     QFile file(p_filename);
     qDebug() << "Scanning " << QDir::toNativeSeparators(p_filename);
+
     if (!file.open(QIODevice::ReadOnly)) {
         qWarning() << "Could not open" << QDir::toNativeSeparators(p_filename);
         return false;
     }
+
     if (!doc.setContent(&file)) {
         qWarning() << "Invalid XML Content in" << QDir::toNativeSeparators(p_filename);
         return false;
     }
+
     file.close();
 
 
-    QDomElement root=doc.documentElement();
+    QDomElement root = doc.documentElement();
+
     if (root.tagName() != STR_AppName) {
         return false;
     }
 
-    root=root.firstChildElement();
+    root = root.firstChildElement();
+
     if (root.tagName() != p_name) {
         return false;
     }
 
     bool ok;
     p_preferences.clear();
-    QDomNode n=root.firstChild();
+    QDomNode n = root.firstChild();
+
     while (!n.isNull()) {
-        QDomElement e=n.toElement();
+        QDomElement e = n.toElement();
+
         if (!e.isNull()) {
-            QString name=e.tagName();
-            QString type=e.attribute("type").toLower();
-            QString value=e.text();;
-            if (type=="double") {
+            QString name = e.tagName();
+            QString type = e.attribute("type").toLower();
+            QString value = e.text();;
+
+            if (type == "double") {
                 double d;
-                d=value.toDouble(&ok);
+                d = value.toDouble(&ok);
+
                 if (ok) {
-                    p_preferences[name]=d;
+                    p_preferences[name] = d;
                 } else {
                     qDebug() << "XML Error:" << name << "=" << value << "??";
                 }
-            } else if (type=="qlonglong") {
+            } else if (type == "qlonglong") {
                 qint64 d;
-                d=value.toLongLong(&ok);
+                d = value.toLongLong(&ok);
+
                 if (ok) {
-                    p_preferences[name]=d;
+                    p_preferences[name] = d;
                 } else {
                     qDebug() << "XML Error:" << name << "=" << value << "??";
                 }
-            } else if (type=="int") {
+            } else if (type == "int") {
                 int d;
-                d=value.toInt(&ok);
+                d = value.toInt(&ok);
+
                 if (ok) {
-                    p_preferences[name]=d;
+                    p_preferences[name] = d;
                 } else {
                     qDebug() << "XML Error:" << name << "=" << value << "??";
                 }
-            } else
-            if (type=="bool") {
-                QString v=value.toLower();
-                if ((v=="true") || (v=="on") || (v=="yes")) {
-                    p_preferences[name]=true;
-                } else
-                if ((v=="false") || (v=="off") || (v=="no")) {
-                    p_preferences[name]=false;
+            } else if (type == "bool") {
+                QString v = value.toLower();
+
+                if ((v == "true") || (v == "on") || (v == "yes")) {
+                    p_preferences[name] = true;
+                } else if ((v == "false") || (v == "off") || (v == "no")) {
+                    p_preferences[name] = false;
                 } else {
                     int d;
-                    d=value.toInt(&ok);
+                    d = value.toInt(&ok);
+
                     if (ok) {
-                        p_preferences[name]=d!=0;
+                        p_preferences[name] = d != 0;
                     } else {
                         qDebug() << "XML Error:" << name << "=" << value << "??";
                     }
                 }
-            } else if (type=="qdatetime") {
+            } else if (type == "qdatetime") {
                 QDateTime d;
-                d=QDateTime::fromString(value,"yyyy-MM-dd HH:mm:ss");
-                if (d.isValid())
-                    p_preferences[name]=d;
-                else
-                    qWarning() << "XML Error: Invalid DateTime record" << name << value;
+                d = QDateTime::fromString(value, "yyyy-MM-dd HH:mm:ss");
 
-            } else if (type=="qtime") {
+                if (d.isValid()) {
+                    p_preferences[name] = d;
+                } else {
+                    qWarning() << "XML Error: Invalid DateTime record" << name << value;
+                }
+
+            } else if (type == "qtime") {
                 QTime d;
-                d=QTime::fromString(value,"hh:mm:ss");
-                if (d.isValid())
-                    p_preferences[name]=d;
-                else
+                d = QTime::fromString(value, "hh:mm:ss");
+
+                if (d.isValid()) {
+                    p_preferences[name] = d;
+                } else {
                     qWarning() << "XML Error: Invalid Time record" << name << value;
+                }
 
             } else  {
-                p_preferences[name]=value;
+                p_preferences[name] = value;
             }
 
         }
-        n=n.nextSibling();
+
+        n = n.nextSibling();
     }
-    root=root.nextSiblingElement();
+
+    root = root.nextSiblingElement();
     ExtraLoad(root);
     return true;
 }
 
 bool Preferences::Save(QString filename)
 {
-    if (!filename.isEmpty())
-        p_filename=filename;
+    if (!filename.isEmpty()) {
+        p_filename = filename;
+    }
 
     QDomDocument doc(p_name);
 
     QDomElement droot = doc.createElement(STR_AppName);
-    doc.appendChild( droot );
+    doc.appendChild(droot);
 
-    QDomElement root=doc.createElement(p_name);
+    QDomElement root = doc.createElement(p_name);
     droot.appendChild(root);
 
-    for (QHash<QString,QVariant>::iterator i=p_preferences.begin(); i!=p_preferences.end(); i++) {
-        QVariant::Type type=i.value().type();
-        if (type==QVariant::Invalid) continue;
+    for (QHash<QString, QVariant>::iterator i = p_preferences.begin(); i != p_preferences.end(); i++) {
+        QVariant::Type type = i.value().type();
 
-        QDomElement cn=doc.createElement(i.key());
-        cn.setAttribute("type",i.value().typeName());
-        if (type==QVariant::DateTime) {
+        if (type == QVariant::Invalid) { continue; }
+
+        QDomElement cn = doc.createElement(i.key());
+        cn.setAttribute("type", i.value().typeName());
+
+        if (type == QVariant::DateTime) {
             cn.appendChild(doc.createTextNode(i.value().toDateTime().toString("yyyy-MM-dd HH:mm:ss")));
-        } else if (type==QVariant::Time) {
+        } else if (type == QVariant::Time) {
             cn.appendChild(doc.createTextNode(i.value().toTime().toString("hh:mm:ss")));
         } else {
             cn.appendChild(doc.createTextNode(i.value().toString()));
@@ -302,9 +334,11 @@ bool Preferences::Save(QString filename)
     droot.appendChild(ExtraSave(doc));
 
     QFile file(p_filename);
+
     if (!file.open(QIODevice::WriteOnly)) {
         return false;
     }
+
     QTextStream ts(&file);
     ts << doc.toString();
     file.close();
diff --git a/sleepyhead/SleepLib/preferences.h b/sleepyhead/SleepLib/preferences.h
index 8b9e8e54..b47b9c11 100644
--- a/sleepyhead/SleepLib/preferences.h
+++ b/sleepyhead/SleepLib/preferences.h
@@ -19,17 +19,17 @@
 #include <QDomDocument>
 #include <map>
 
-const QString STR_ext_XML=".xml";
+const QString STR_ext_XML = ".xml";
 
 extern QString GetAppRoot(); //returns app root path plus trailing path separator.
 
 inline QString PrefMacro(QString s)
 {
-    return "{"+s+"}";
+    return "{" + s + "}";
 }
 
 //! \brief Returns a QString containing the Username, according to the Operating System
-const QString & getUserName();
+const QString &getUserName();
 
 
 /*! \class Preferences
@@ -38,9 +38,9 @@ const QString & getUserName();
     */
 class Preferences
 {
-public:
+  public:
     //! \brief Constructs a Preferences object 'name', and remembers sets the filename
-    Preferences(QString name,QString filename="");
+    Preferences(QString name, QString filename = "");
     Preferences();
     virtual ~Preferences();
 
@@ -48,13 +48,13 @@ public:
     const QString Get(QString name);
 
     //! \brief Returns the QVariant value of the selected preference.. Note, preference must exist, and will not expand {} macros
-    QVariant & operator[](QString name) {
+    QVariant &operator[](QString name) {
         return p_preferences[name];
     }
 
     //! \brief Sets the Preference 'name' to QVariant 'value'
-    void Set(QString name,QVariant value) {
-        p_preferences[name]=value;
+    void Set(QString name, QVariant value) {
+        p_preferences[name] = value;
     }
 
     //! \brief Returns true if preference 'name' exists
@@ -64,61 +64,65 @@ public:
 
     //! \brief Returns true if preference 'name' exists, and contains a boolean true value
     bool ExistsAndTrue(QString name) {
-        QHash<QString,QVariant>::iterator i=p_preferences.find(name);
-        if (i==p_preferences.end()) return false;
+        QHash<QString, QVariant>::iterator i = p_preferences.find(name);
+
+        if (i == p_preferences.end()) { return false; }
+
         return i.value().toBool();
     }
 
     //! \brief Removes preference 'name' from this Preferences group
     void Erase(QString name) {
-        QHash<QString,QVariant>::iterator i=p_preferences.find(name);
-        if (i!=p_preferences.end())
+        QHash<QString, QVariant>::iterator i = p_preferences.find(name);
+
+        if (i != p_preferences.end()) {
             p_preferences.erase(i);
+        }
     }
 
     //! \brief Derive from this to handle Loading of any custom XML sections
-    virtual void ExtraLoad(QDomElement & root) { root=root; }
+    virtual void ExtraLoad(QDomElement &root) { root = root; }
 
     //! \brief Derive from this to handle Saving of any custom XML sections
     //! \return Must return a QDomElement to be inserted into the generated XML
-    virtual QDomElement ExtraSave(QDomDocument & doc) { doc=doc; QDomElement e; return e; }
+    virtual QDomElement ExtraSave(QDomDocument &doc) { doc = doc; QDomElement e; return e; }
 
     //! \brief Opens, processes the XML for this Preferences group, loading all preferences stored therein.
     //! \note If filename is empty, it will use the one specified in the constructor
     //! \returns true if succesful
-    virtual bool Open(QString filename="");
+    virtual bool Open(QString filename = "");
 
     //! \brief Saves all preferences to XML file.
     //! \note If filename is empty, it will use the one specified in the constructor
     //! \returns true if succesful
-    virtual bool Save(QString filename="");
+    virtual bool Save(QString filename = "");
 
     //! \note Sets a comment string whici will be stored in the XML
-    void SetComment(const QString & str) {
-        p_comment=str;
+    void SetComment(const QString &str) {
+        p_comment = str;
     }
 
     //! \brief Finds a given preference.
     //! \returns a QHash<QString,QString>::iterator pointing to the preference named 'key', or an empty end() iterator
-    inline QHash<QString,QVariant>::iterator find(QString key) { return p_preferences.find(key); }
+    inline QHash<QString, QVariant>::iterator find(QString key) { return p_preferences.find(key); }
 
     //! \brief Returns an empty iterator pointing to the end of the preferences list
-    inline QHash<QString,QVariant>::iterator end() { return p_preferences.end(); }
+    inline QHash<QString, QVariant>::iterator end() { return p_preferences.end(); }
 
     //! \brief Returns an iterator pointing to the first item in the preferences list
-    inline QHash<QString,QVariant>::iterator begin() { return p_preferences.begin(); }
+    inline QHash<QString, QVariant>::iterator begin() { return p_preferences.begin(); }
 
     //int  GetCode(QString name); // For registering/looking up new preference code.
 
     //! \brief Stores all the variants indexed by a QString name for this Preferences object
-    QHash<QString,QVariant> p_preferences;
+    QHash<QString, QVariant> p_preferences;
 
-    void setPath(const QString & path) { p_path=path; }
-    void setFilename(const QString & filename) { p_filename=filename; }
+    void setPath(const QString &path) { p_path = path; }
+    void setFilename(const QString &filename) { p_filename = filename; }
 
     const QString name() { return p_name; }
 
-protected:
+  protected:
     //QHash<int,QString> p_codes;
     QString p_comment;
     QString p_name;
diff --git a/sleepyhead/SleepLib/profiles.cpp b/sleepyhead/SleepLib/profiles.cpp
index e646ae9e..5453f531 100644
--- a/sleepyhead/SleepLib/profiles.cpp
+++ b/sleepyhead/SleepLib/profiles.cpp
@@ -25,49 +25,54 @@
 #include <QApplication>
 #include "mainwindow.h"
 
-extern MainWindow * mainwin;
+extern MainWindow *mainwin;
 Preferences *p_pref;
 Preferences *p_layout;
-Profile * p_profile;
+Profile *p_profile;
 
 
 
 Profile::Profile()
-:Preferences(),is_first_day(true)
+    : Preferences(), is_first_day(true)
 {
-    p_name=STR_GEN_Profile;
-    p_path=PREF.Get("{home}/Profiles");
+    p_name = STR_GEN_Profile;
+    p_path = PREF.Get("{home}/Profiles");
     machlist.clear();
 
-    doctor=new DoctorInfo(this);
-    user=new UserInfo(this);
-    cpap=new CPAPSettings(this);
-    oxi=new OxiSettings(this);
-    appearance=new AppearanceSettings(this);
-    session=new SessionSettings(this);
-    general=new UserSettings(this);
+    doctor = new DoctorInfo(this);
+    user = new UserInfo(this);
+    cpap = new CPAPSettings(this);
+    oxi = new OxiSettings(this);
+    appearance = new AppearanceSettings(this);
+    session = new SessionSettings(this);
+    general = new UserSettings(this);
 }
 Profile::Profile(QString path)
-:Preferences(),is_first_day(true)
+    : Preferences(), is_first_day(true)
 {
-    p_name=STR_GEN_Profile;
-    if (path.isEmpty())
-        p_path=GetAppRoot();
-    else p_path=path;
-    (*this)[STR_GEN_DataFolder]=p_path;
-    path=path.replace("\\","/");
-    if (!p_path.endsWith("/"))
-        p_path+="/";
-    p_filename=p_path+p_name+STR_ext_XML;
+    p_name = STR_GEN_Profile;
+
+    if (path.isEmpty()) {
+        p_path = GetAppRoot();
+    } else { p_path = path; }
+
+    (*this)[STR_GEN_DataFolder] = p_path;
+    path = path.replace("\\", "/");
+
+    if (!p_path.endsWith("/")) {
+        p_path += "/";
+    }
+
+    p_filename = p_path + p_name + STR_ext_XML;
     machlist.clear();
 
-    doctor=NULL;
-    user=NULL;
-    cpap=NULL;
-    oxi=NULL;
-    appearance=NULL;
-    session=NULL;
-    general=NULL;
+    doctor = NULL;
+    user = NULL;
+    cpap = NULL;
+    oxi = NULL;
+    appearance = NULL;
+    session = NULL;
+    general = NULL;
 }
 bool Profile::Save(QString filename)
 {
@@ -84,70 +89,84 @@ Profile::~Profile()
     delete appearance;
     delete session;
     delete general;
-    for (QHash<MachineID,Machine *>::iterator i=machlist.begin(); i!=machlist.end(); i++) {
+
+    for (QHash<MachineID, Machine *>::iterator i = machlist.begin(); i != machlist.end(); i++) {
         delete i.value();
     }
 }
 
 bool Profile::Open(QString filename)
 {
-    bool b=Preferences::Open(filename);
-    doctor=new DoctorInfo(this);
-    user=new UserInfo(this);
-    cpap=new CPAPSettings(this);
-    oxi=new OxiSettings(this);
-    appearance=new AppearanceSettings(this);
-    session=new SessionSettings(this);
-    general=new UserSettings(this);
+    bool b = Preferences::Open(filename);
+    doctor = new DoctorInfo(this);
+    user = new UserInfo(this);
+    cpap = new CPAPSettings(this);
+    oxi = new OxiSettings(this);
+    appearance = new AppearanceSettings(this);
+    session = new SessionSettings(this);
+    general = new UserSettings(this);
     return b;
 }
 
 void Profile::DataFormatError(Machine *m)
 {
-    QString msg=QObject::tr("Software changes have been made that require the reimporting of the following machines data:\n\n");
-    msg=msg+m->properties[STR_PROP_Brand]+" "+m->properties[STR_PROP_Model]+" "+m->properties[STR_PROP_Serial];
-    msg=msg+QObject::tr("I can automatically purge this data for you, or you can cancel now and continue to run in a previous version.\n\n");
-    msg=msg+QObject::tr("Would you like me to purge this data this for you so you can run the new version?");
+    QString msg =
+        QObject::tr("Software changes have been made that require the reimporting of the following machines data:\n\n");
+    msg = msg + m->properties[STR_PROP_Brand] + " " + m->properties[STR_PROP_Model] + " " +
+          m->properties[STR_PROP_Serial];
+    msg = msg +
+          QObject::tr("I can automatically purge this data for you, or you can cancel now and continue to run in a previous version.\n\n");
+    msg = msg +
+          QObject::tr("Would you like me to purge this data this for you so you can run the new version?");
 
-    if (QMessageBox::warning(NULL,QObject::tr("Machine Database Changes"),msg,QMessageBox::Yes | QMessageBox::Cancel,QMessageBox::Yes)==QMessageBox::Yes) {
+    if (QMessageBox::warning(NULL, QObject::tr("Machine Database Changes"), msg,
+                             QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes) == QMessageBox::Yes) {
 
-        if (!m->Purge(3478216)) { // Do not copy this line without thinking.. You will be eaten by a Grue if you do
+        if (!m->Purge(
+                    3478216)) { // Do not copy this line without thinking.. You will be eaten by a Grue if you do
 
-            QMessageBox::critical(NULL,QObject::tr("Purge Failed"),QObject::tr("Sorry, I could not purge this data, which means this version of SleepyHead can't start.. SleepyHead's Data folder needs to be removed manually\n\nThis folder currently resides at the following location:\n")+PREF[STR_GEN_DataFolder].toString(),QMessageBox::Ok);
+            QMessageBox::critical(NULL, QObject::tr("Purge Failed"),
+                                  QObject::tr("Sorry, I could not purge this data, which means this version of SleepyHead can't start.. SleepyHead's Data folder needs to be removed manually\n\nThis folder currently resides at the following location:\n")
+                                  + PREF[STR_GEN_DataFolder].toString(), QMessageBox::Ok);
             QApplication::exit(-1);
         }
     } else {
         QApplication::exit(-1);
     }
+
     return;
 
 }
 void Profile::LoadMachineData()
 {
-    QHash<MachineID,QMap<QDate,QHash<ChannelID, EventDataType> > > cache;
+    QHash<MachineID, QMap<QDate, QHash<ChannelID, EventDataType> > > cache;
 
-    for (QHash<MachineID,Machine *>::iterator i=machlist.begin(); i!=machlist.end(); i++) {
-        Machine *m=i.value();
+    for (QHash<MachineID, Machine *>::iterator i = machlist.begin(); i != machlist.end(); i++) {
+        Machine *m = i.value();
+
+        MachineLoader *loader = GetLoader(m->GetClass());
 
-        MachineLoader *loader=GetLoader(m->GetClass());
         if (loader) {
-            long v=loader->Version();
-            long cv=0;
-            if (m->properties.find(STR_PROP_DataVersion)==m->properties.end()) {
-                m->properties[STR_PROP_DataVersion]="0";
+            long v = loader->Version();
+            long cv = 0;
+
+            if (m->properties.find(STR_PROP_DataVersion) == m->properties.end()) {
+                m->properties[STR_PROP_DataVersion] = "0";
             }
+
             bool ok;
-            cv=m->properties[STR_PROP_DataVersion].toLong(&ok);
-            if (!ok || cv<v) {
+            cv = m->properties[STR_PROP_DataVersion].toLong(&ok);
+
+            if (!ok || cv < v) {
                 DataFormatError(m);
                 // It may exit above and not return here..
                 QString s;
-                s.sprintf("%li",v);
-                m->properties[STR_PROP_DataVersion]=s; // Dont need to nag again if they are too lazy.
+                s.sprintf("%li", v);
+                m->properties[STR_PROP_DataVersion] = s; // Dont need to nag again if they are too lazy.
             } else {
                 try {
                     m->Load();
-                } catch (OldDBVersion e){
+                } catch (OldDBVersion e) {
                     DataFormatError(m);
                 }
             }
@@ -161,115 +180,138 @@ void Profile::LoadMachineData()
  * @brief Machine XML section in profile.
  * @param root
  */
-void Profile::ExtraLoad(QDomElement & root)
+void Profile::ExtraLoad(QDomElement &root)
 {
-    if (root.tagName()!="Machines") {
+    if (root.tagName() != "Machines") {
         qDebug() << "No Machines Tag in Profiles.xml";
         return;
     }
-    QDomElement elem=root.firstChildElement();
-    while (!elem.isNull()) {
-        QString pKey=elem.tagName();
 
-        if (pKey!="Machine") {
+    QDomElement elem = root.firstChildElement();
+
+    while (!elem.isNull()) {
+        QString pKey = elem.tagName();
+
+        if (pKey != "Machine") {
             qWarning() << "Profile::ExtraLoad() pKey!=\"Machine\"";
-            elem=elem.nextSiblingElement();
+            elem = elem.nextSiblingElement();
             continue;
         }
+
         int m_id;
         bool ok;
-        m_id=elem.attribute("id","").toInt(&ok);
+        m_id = elem.attribute("id", "").toInt(&ok);
         int mt;
-        mt=elem.attribute("type","").toInt(&ok);
-        MachineType m_type=(MachineType)mt;
+        mt = elem.attribute("type", "").toInt(&ok);
+        MachineType m_type = (MachineType)mt;
 
-        QString m_class=elem.attribute("class","");
+        QString m_class = elem.attribute("class", "");
         //MachineLoader *ml=GetLoader(m_class);
         Machine *m;
+
         //if (ml) {
         //   ml->CreateMachine
         //}
-        if (m_type==MT_CPAP)
-            m=new CPAP(this,m_id);
-        else if (m_type==MT_OXIMETER)
-            m=new Oximeter(this,m_id);
-        else if (m_type==MT_SLEEPSTAGE)
-            m=new SleepStage(this,m_id);
-        else if (m_type==MT_POSITION)
-            m=new PositionSensor(this,m_id);
-        else {
-            m=new Machine(this,m_id);
+        if (m_type == MT_CPAP) {
+            m = new CPAP(this, m_id);
+        } else if (m_type == MT_OXIMETER) {
+            m = new Oximeter(this, m_id);
+        } else if (m_type == MT_SLEEPSTAGE) {
+            m = new SleepStage(this, m_id);
+        } else if (m_type == MT_POSITION) {
+            m = new PositionSensor(this, m_id);
+        } else {
+            m = new Machine(this, m_id);
             m->SetType(m_type);
         }
+
         m->SetClass(m_class);
         AddMachine(m);
-        QDomElement e=elem.firstChildElement();
-        for (; !e.isNull(); e=e.nextSiblingElement()) {
-            QString pKey=e.tagName();
-            m->properties[pKey]=e.text();
+        QDomElement e = elem.firstChildElement();
+
+        for (; !e.isNull(); e = e.nextSiblingElement()) {
+            QString pKey = e.tagName();
+            m->properties[pKey] = e.text();
         }
-        elem=elem.nextSiblingElement();
+
+        elem = elem.nextSiblingElement();
     }
 }
-void Profile::AddMachine(Machine *m) {
+void Profile::AddMachine(Machine *m)
+{
     if (!m) {
         qWarning() << "Empty Machine in Profile::AddMachine()";
         return;
     }
-    machlist[m->id()]=m;
+
+    machlist[m->id()] = m;
 };
-void Profile::DelMachine(Machine *m) {
+void Profile::DelMachine(Machine *m)
+{
     if (!m) {
         qWarning() << "Empty Machine in Profile::AddMachine()";
         return;
     }
+
     machlist.erase(machlist.find(m->id()));
 };
 
 
 // Potential Memory Leak Here..
-QDomElement Profile::ExtraSave(QDomDocument & doc)
+QDomElement Profile::ExtraSave(QDomDocument &doc)
 {
-    QDomElement mach=doc.createElement("Machines");
-    for (QHash<MachineID,Machine *>::iterator i=machlist.begin(); i!=machlist.end(); i++) {
-        QDomElement me=doc.createElement("Machine");
-        Machine *m=i.value();
-        me.setAttribute("id",(int)m->id());
-        me.setAttribute("type",(int)m->GetType());
-        me.setAttribute("class",m->GetClass());
-        if (!m->properties.contains(STR_PROP_Path)) m->properties[STR_PROP_Path]="{DataFolder}/"+m->GetClass()+"_"+m->hexid();
+    QDomElement mach = doc.createElement("Machines");
 
-        for (QHash<QString,QString>::iterator j=i.value()->properties.begin(); j!=i.value()->properties.end(); j++) {
-            QDomElement mp=doc.createElement(j.key());
+    for (QHash<MachineID, Machine *>::iterator i = machlist.begin(); i != machlist.end(); i++) {
+        QDomElement me = doc.createElement("Machine");
+        Machine *m = i.value();
+        me.setAttribute("id", (int)m->id());
+        me.setAttribute("type", (int)m->GetType());
+        me.setAttribute("class", m->GetClass());
+
+        if (!m->properties.contains(STR_PROP_Path)) { m->properties[STR_PROP_Path] = "{DataFolder}/" + m->GetClass() + "_" + m->hexid(); }
+
+        for (QHash<QString, QString>::iterator j = i.value()->properties.begin();
+                j != i.value()->properties.end(); j++) {
+            QDomElement mp = doc.createElement(j.key());
             mp.appendChild(doc.createTextNode(j.value()));
             //mp->LinkEndChild(new QDomText(j->second.toLatin1()));
             me.appendChild(mp);
         }
+
         mach.appendChild(me);
     }
+
     return mach;
 
 }
 
-void Profile::AddDay(QDate date,Day *day,MachineType mt) {
+void Profile::AddDay(QDate date, Day *day, MachineType mt)
+{
     //date+=wxTimeSpan::Day();
     if (!day)  {
         qDebug() << "Profile::AddDay called with null day object";
         return;
     }
+
     if (is_first_day) {
-        m_first=m_last=date;
-        is_first_day=false;
+        m_first = m_last = date;
+        is_first_day = false;
+    }
+
+    if (m_first > date) {
+        m_first = date;
+    }
+
+    if (m_last < date) {
+        m_last = date;
     }
-    if (m_first>date)
-        m_first=date;
-    if (m_last<date)
-        m_last=date;
 
     // Check for any other machines of same type.. Throw an exception if one already exists.
-    QList<Day *> & dl=daylist[date];
-    for (QList<Day *>::iterator a=dl.begin();a!=dl.end();a++) {
-        if ((*a)->machine->GetType()==mt) {
+    QList<Day *> &dl = daylist[date];
+
+    for (QList<Day *>::iterator a = dl.begin(); a != dl.end(); a++) {
+        if ((*a)->machine->GetType() == mt) {
 
             // disabled this because two machines isn't all that bad
             //            if (QMessageBox::question(NULL,"Different Machine Detected","This data comes from another machine to what's usually imported, and has overlapping data.\nThis new data will override any older data from the old machine. Are you sure you want to do this?",QMessageBox::Yes,QMessageBox::No)==QMessageBox::No) {
@@ -279,93 +321,110 @@ void Profile::AddDay(QDate date,Day *day,MachineType mt) {
             break;
         }
     }
+
     daylist[date].push_back(day);
 }
 
 // Get Day record if data available for date and machine type, and has enabled session data, else return NULL
-Day * Profile::GetGoodDay(QDate date,MachineType type)
+Day *Profile::GetGoodDay(QDate date, MachineType type)
 {
-    Day *day=NULL;
+    Day *day = NULL;
 
-    QMap<QDate,QList<Day *> >::iterator dli=daylist.find(date);
-    if (dli!=daylist.end()) {
+    QMap<QDate, QList<Day *> >::iterator dli = daylist.find(date);
 
-        for (QList<Day *>::iterator di=(*dli).begin();di!=(*dli).end();di++) {
+    if (dli != daylist.end()) {
 
-            if (type==MT_UNKNOWN) { // Who cares.. We just want to know there is data available.
-                day=(*di);
+        for (QList<Day *>::iterator di = (*dli).begin(); di != (*dli).end(); di++) {
+
+            if (type == MT_UNKNOWN) { // Who cares.. We just want to know there is data available.
+                day = (*di);
                 break;
             }
-            if ((*di)->machine_type()==type) {
-                bool b=false;
-                for (int i=0;i<(*di)->size();i++) {
+
+            if ((*di)->machine_type() == type) {
+                bool b = false;
+
+                for (int i = 0; i < (*di)->size(); i++) {
                     if ((*(*di))[i]->enabled()) {
-                        b=true;
+                        b = true;
                         break;
                     }
                 }
+
                 if (b) {
-                    day=(*di);
+                    day = (*di);
                     break;
                 }
             }
         }
     }
+
     return day;
 }
 
-Day * Profile::GetDay(QDate date,MachineType type)
+Day *Profile::GetDay(QDate date, MachineType type)
 {
-    Day *tmp,*day=NULL;
-    if (daylist.find(date)!=daylist.end()) {
-        for (QList<Day *>::iterator di=daylist[date].begin();di!=daylist[date].end();di++) {
-            tmp=*di;
+    Day *tmp, *day = NULL;
+
+    if (daylist.find(date) != daylist.end()) {
+        for (QList<Day *>::iterator di = daylist[date].begin(); di != daylist[date].end(); di++) {
+            tmp = *di;
+
             if (!tmp) {
                 qDebug() << "This should never happen in Profile::GetDay()";
                 break;
             }
 
-            if (type==MT_UNKNOWN) { // Who cares.. We just want to know there is data available.
-                day=tmp;
+            if (type == MT_UNKNOWN) { // Who cares.. We just want to know there is data available.
+                day = tmp;
                 break;
             }
-            if (tmp->machine_type()==type) {
-                day=tmp;
+
+            if (tmp->machine_type() == type) {
+                day = tmp;
                 break;
             }
         }
     }
+
     return day;
 }
 
 
 int Profile::Import(QString path)
 {
-    int c=0;
+    int c = 0;
     qDebug() << "Importing " << path;
-    path=path.replace("\\","/");
-    if (path.endsWith("/"))
-        path.chop(1);
+    path = path.replace("\\", "/");
 
-    QList<MachineLoader *>loaders=GetLoaders();
-    for (QList<MachineLoader *>::iterator i=loaders.begin(); i!=loaders.end(); i++) {
-        if (c+=(*i)->Open(path,this))
-            break;
+    if (path.endsWith("/")) {
+        path.chop(1);
     }
+
+    QList<MachineLoader *>loaders = GetLoaders();
+
+    for (QList<MachineLoader *>::iterator i = loaders.begin(); i != loaders.end(); i++) {
+        if (c += (*i)->Open(path, this)) {
+            break;
+        }
+    }
+
     //qDebug() << "Import Done";
     return c;
 }
 
-MachineLoader * GetLoader(QString name)
+MachineLoader *GetLoader(QString name)
 {
-    MachineLoader *l=NULL;
-    QList<MachineLoader *>loaders=GetLoaders();
-    for (QList<MachineLoader *>::iterator i=loaders.begin(); i!=loaders.end(); i++) {
-        if ((*i)->ClassName()==name) {
-            l=*i;
+    MachineLoader *l = NULL;
+    QList<MachineLoader *>loaders = GetLoaders();
+
+    for (QList<MachineLoader *>::iterator i = loaders.begin(); i != loaders.end(); i++) {
+        if ((*i)->ClassName() == name) {
+            l = *i;
             break;
         }
     }
+
     return l;
 }
 
@@ -374,52 +433,66 @@ MachineLoader * GetLoader(QString name)
 QList<Machine *> Profile::GetMachines(MachineType t)
 {
     QList<Machine *> vec;
-    QHash<MachineID,Machine *>::iterator i;
+    QHash<MachineID, Machine *>::iterator i;
 
-    for (i=machlist.begin(); i!=machlist.end(); i++) {
+    for (i = machlist.begin(); i != machlist.end(); i++) {
         if (!i.value()) {
             qWarning() << "Profile::GetMachines() i->second == NULL";
             continue;
         }
-        MachineType mt=i.value()->GetType();
-        if ((t==MT_UNKNOWN) || (mt==t)) {
+
+        MachineType mt = i.value()->GetType();
+
+        if ((t == MT_UNKNOWN) || (mt == t)) {
             vec.push_back(i.value());
         }
     }
+
     return vec;
 }
 
-Machine * Profile::GetMachine(MachineType t)
+Machine *Profile::GetMachine(MachineType t)
 {
-    QList<Machine *>vec=GetMachines(t);
-    if (vec.size()==0)
+    QList<Machine *>vec = GetMachines(t);
+
+    if (vec.size() == 0) {
         return NULL;
+    }
+
     return vec[0];
 
 }
 
-void Profile::RemoveSession(Session * sess)
+void Profile::RemoveSession(Session *sess)
 {
-    QMap<QDate,QList<Day *> >::iterator di;
+    QMap<QDate, QList<Day *> >::iterator di;
 
-    for (di=daylist.begin();di!=daylist.end();di++) {
-        for (int d=0;d<di.value().size();d++) {
-            Day *day=di.value()[d];
+    for (di = daylist.begin(); di != daylist.end(); di++) {
+        for (int d = 0; d < di.value().size(); d++) {
+            Day *day = di.value()[d];
 
-            int i=day->getSessions().indexOf(sess);
-            if (i>=0) {
-                for (;i<day->getSessions().size()-1;i++) {
-                    day->getSessions()[i]=day->getSessions()[i+1];
+            int i = day->getSessions().indexOf(sess);
+
+            if (i >= 0) {
+                for (; i < day->getSessions().size() - 1; i++) {
+                    day->getSessions()[i] = day->getSessions()[i + 1];
                 }
+
                 day->getSessions().pop_back();
-                qint64 first=0,last=0;
-                for (int i=0;i<day->getSessions().size();i++) {
-                    Session & sess=*day->getSessions()[i];
-                    if (!first || first>sess.first())
-                        first=sess.first();
-                    if (!last || last<sess.last())
-                        last=sess.last();
+                qint64 first = 0, last = 0;
+
+                for (int i = 0; i < day->getSessions().size(); i++) {
+                    Session &sess = *day->getSessions()[i];
+
+                    if (!first || first > sess.first()) {
+                        first = sess.first();
+                    }
+
+                    if (!last || last < sess.last()) {
+                        last = sess.last();
+                    }
                 }
+
                 // day->setFirst(first);
                 // day->setLast(last);
                 return;
@@ -435,20 +508,21 @@ QString SHA1(QString pass)
     return pass;
 }
 
-namespace Profiles
-{
+namespace Profiles {
 
-QMap<QString,Profile *> profiles;
+QMap<QString, Profile *> profiles;
 
 void Done()
 {
     PREF.Save();
     LAYOUT.Save();
+
     // Only save the open profile..
-    for (QMap<QString,Profile *>::iterator i=profiles.begin(); i!=profiles.end(); i++) {
+    for (QMap<QString, Profile *>::iterator i = profiles.begin(); i != profiles.end(); i++) {
         i.value()->Save();
         delete i.value();
     }
+
     profiles.clear();
     delete p_pref;
     delete p_layout;
@@ -457,32 +531,37 @@ void Done()
 
 Profile *Get(QString name)
 {
-    if (profiles.find(name)!=profiles.end())
+    if (profiles.find(name) != profiles.end()) {
         return profiles[name];
+    }
 
     return NULL;
 }
 Profile *Create(QString name)
 {
-    QString path=PREF.Get("{home}/Profiles/")+name;
+    QString path = PREF.Get("{home}/Profiles/") + name;
     QDir dir(path);
-    if (!dir.exists(path))
+
+    if (!dir.exists(path)) {
         dir.mkpath(path);
+    }
+
     //path+="/"+name;
-    Profile *prof=new Profile(path);
+    Profile *prof = new Profile(path);
     prof->Open();
-    profiles[name]=prof;
+    profiles[name] = prof;
     prof->user->setUserName(name);
     //prof->Set("Realname",realname);
     //if (!password.isEmpty()) prof.user->setPassword(password);
-    prof->Set(STR_GEN_DataFolder,QString("{home}/Profiles/{")+QString(STR_UI_UserName)+QString("}"));
+    prof->Set(STR_GEN_DataFolder, QString("{home}/Profiles/{") + QString(STR_UI_UserName) +
+              QString("}"));
 
-    Machine *m=new Machine(prof,0);
+    Machine *m = new Machine(prof, 0);
     m->SetClass("Journal");
-    m->properties[STR_PROP_Brand]="Journal";
-    m->properties[STR_PROP_Model]="Journal Data Machine Object";
-    m->properties[STR_PROP_Serial]=m->hexid();
-    m->properties[STR_PROP_Path]="{DataFolder}/"+m->GetClass()+"_"+m->hexid();
+    m->properties[STR_PROP_Brand] = "Journal";
+    m->properties[STR_PROP_Model] = "Journal Data Machine Object";
+    m->properties[STR_PROP_Serial] = m->hexid();
+    m->properties[STR_PROP_Path] = "{DataFolder}/" + m->GetClass() + "_" + m->hexid();
     m->SetType(MT_JOURNAL);
     prof->AddMachine(m);
 
@@ -506,13 +585,13 @@ Profile *Get()
 void Scan()
 {
     //InitMapsWithoutAwesomeInitializerLists();
-    p_pref=new Preferences("Preferences");
-    p_layout=new Preferences("Layout");
+    p_pref = new Preferences("Preferences");
+    p_layout = new Preferences("Layout");
 
     PREF.Open();
     LAYOUT.Open();
 
-    QString path=PREF.Get("{home}/Profiles");
+    QString path = PREF.Get("{home}/Profiles");
     QDir dir(path);
 
     if (!dir.exists(path)) {
@@ -521,6 +600,7 @@ void Scan()
         //Create(getUserName(),getUserName(),"");
         return;
     }
+
     if (!dir.isReadable()) {
         qWarning() << "Can't open " << path;
         return;
@@ -529,21 +609,21 @@ void Scan()
     dir.setFilter(QDir::Dirs | QDir::NoDotAndDotDot);
     //dir.setSorting(QDir::Name);
 
-    QFileInfoList list=dir.entryInfoList();
+    QFileInfoList list = dir.entryInfoList();
 
     //QString username=getUserName();
     //if (list.size()==0) { // No profiles.. Create one.
-        //Create(username,username,"");
-        //return;
+    //Create(username,username,"");
+    //return;
     //}
 
     // Iterate through subdirectories and load profiles..
-    for (int i=0;i<list.size();i++) {
-        QFileInfo fi=list.at(i);
-        QString npath=fi.canonicalFilePath();
-        Profile *prof=new Profile(npath);
+    for (int i = 0; i < list.size(); i++) {
+        QFileInfo fi = list.at(i);
+        QString npath = fi.canonicalFilePath();
+        Profile *prof = new Profile(npath);
         prof->Open();  // Read it's XML file..
-        profiles[fi.fileName()]=prof;
+        profiles[fi.fileName()] = prof;
     }
 
 }
@@ -553,368 +633,505 @@ void Scan()
 
 int Profile::countDays(MachineType mt, QDate start, QDate end)
 {
-    if (!start.isValid())
+    if (!start.isValid()) {
         return 0;
+    }
+
     //start=LastDay(mt);
-    if (!end.isValid())
+    if (!end.isValid()) {
         return 0;
+    }
+
     //end=LastDay(mt);
-    QDate date=start;
-    if (date.isNull())
+    QDate date = start;
+
+    if (date.isNull()) {
         return 0;
+    }
 
 
-    int days=0;
+    int days = 0;
+
     do {
-        Day * day=GetGoodDay(date,mt);
+        Day *day = GetGoodDay(date, mt);
+
         if (day) {
-            if ((mt==MT_UNKNOWN) || (day->machine->GetType()==mt)) days++;
+            if ((mt == MT_UNKNOWN) || (day->machine->GetType() == mt)) { days++; }
         }
-        date=date.addDays(1);
-    } while (date<=end);
+
+        date = date.addDays(1);
+    } while (date <= end);
+
     return days;
 
 }
 
 EventDataType Profile::calcCount(ChannelID code, MachineType mt, QDate start, QDate end)
 {
-    if (!start.isValid())
-        start=LastGoodDay(mt);
-    if (!end.isValid())
-        end=LastGoodDay(mt);
-    QDate date=start;
-    if (date.isNull())
-        return 0;
+    if (!start.isValid()) {
+        start = LastGoodDay(mt);
+    }
+
+    if (!end.isValid()) {
+        end = LastGoodDay(mt);
+    }
+
+    QDate date = start;
+
+    if (date.isNull()) {
+        return 0;
+    }
+
+    double val = 0;
 
-    double val=0;
     do {
-        Day * day=GetGoodDay(date,mt);
+        Day *day = GetGoodDay(date, mt);
+
         if (day) {
-            val+=day->count(code);
+            val += day->count(code);
         }
-        date=date.addDays(1);
-    } while (date<=end);
+
+        date = date.addDays(1);
+    } while (date <= end);
+
     return val;
 }
 double Profile::calcSum(ChannelID code, MachineType mt, QDate start, QDate end)
 {
-    if (!start.isValid())
-        start=LastGoodDay(mt);
-    if (!end.isValid())
-        end=LastGoodDay(mt);
-    QDate date=start;
+    if (!start.isValid()) {
+        start = LastGoodDay(mt);
+    }
+
+    if (!end.isValid()) {
+        end = LastGoodDay(mt);
+    }
+
+    QDate date = start;
+
+    double val = 0;
 
-    double val=0;
     do {
-        Day * day=GetGoodDay(date,mt);
+        Day *day = GetGoodDay(date, mt);
+
         if (day) {
-            val+=day->sum(code);
+            val += day->sum(code);
         }
-        date=date.addDays(1);
-    } while (date<=end);
+
+        date = date.addDays(1);
+    } while (date <= end);
+
     return val;
 }
 EventDataType Profile::calcHours(MachineType mt, QDate start, QDate end)
 {
-    if (!start.isValid())
-        start=LastGoodDay(mt);
-    if (!end.isValid())
-        end=LastGoodDay(mt);
-    QDate date=start;
-    if (date.isNull())
-        return 0;
+    if (!start.isValid()) {
+        start = LastGoodDay(mt);
+    }
+
+    if (!end.isValid()) {
+        end = LastGoodDay(mt);
+    }
+
+    QDate date = start;
+
+    if (date.isNull()) {
+        return 0;
+    }
+
+    double val = 0;
 
-    double val=0;
     do {
-        Day * day=GetGoodDay(date,mt);
+        Day *day = GetGoodDay(date, mt);
+
         if (day) {
-            val+=day->hours();
+            val += day->hours();
         }
-        date=date.addDays(1);
-    } while (date<=end);
+
+        date = date.addDays(1);
+    } while (date <= end);
+
     return val;
 }
 EventDataType Profile::calcAvg(ChannelID code, MachineType mt, QDate start, QDate end)
 {
-    if (!start.isValid())
-        start=LastGoodDay(mt);
-    if (!end.isValid())
-        end=LastGoodDay(mt);
-    QDate date=start;
-    if (date.isNull())
-        return 0;
+    if (!start.isValid()) {
+        start = LastGoodDay(mt);
+    }
+
+    if (!end.isValid()) {
+        end = LastGoodDay(mt);
+    }
+
+    QDate date = start;
+
+    if (date.isNull()) {
+        return 0;
+    }
+
+    double val = 0;
+    int cnt = 0;
 
-    double val=0;
-    int cnt=0;
     do {
-        Day * day=GetGoodDay(date,mt);
+        Day *day = GetGoodDay(date, mt);
+
         if (day) {
-            val+=day->sum(code);
+            val += day->sum(code);
             cnt++;
         }
-        date=date.addDays(1);
-    } while (date<=end);
-    if (!cnt)
+
+        date = date.addDays(1);
+    } while (date <= end);
+
+    if (!cnt) {
         return 0;
-    return val/float(cnt);
+    }
+
+    return val / float(cnt);
 }
 EventDataType Profile::calcWavg(ChannelID code, MachineType mt, QDate start, QDate end)
 {
-    if (!start.isValid())
-        start=LastGoodDay(mt);
-    if (!end.isValid())
-        end=LastGoodDay(mt);
-    QDate date=start;
-    if (date.isNull())
-        return 0;
+    if (!start.isValid()) {
+        start = LastGoodDay(mt);
+    }
 
-    double val=0,tmp,tmph,hours=0;
-    do {
-        Day * day=GetGoodDay(date,mt);
-        if (day) {
-            tmph=day->hours();
-            tmp=day->wavg(code);
-            val+=tmp*tmph;
-            hours+=tmph;
-        }
-        date=date.addDays(1);
-    } while (date<=end);
-    if (!hours)
+    if (!end.isValid()) {
+        end = LastGoodDay(mt);
+    }
+
+    QDate date = start;
+
+    if (date.isNull()) {
         return 0;
-    val=val/hours;
+    }
+
+    double val = 0, tmp, tmph, hours = 0;
+
+    do {
+        Day *day = GetGoodDay(date, mt);
+
+        if (day) {
+            tmph = day->hours();
+            tmp = day->wavg(code);
+            val += tmp * tmph;
+            hours += tmph;
+        }
+
+        date = date.addDays(1);
+    } while (date <= end);
+
+    if (!hours) {
+        return 0;
+    }
+
+    val = val / hours;
     return val;
 }
 EventDataType Profile::calcMin(ChannelID code, MachineType mt, QDate start, QDate end)
 {
-    if (!start.isValid())
-        start=LastGoodDay(mt);
-    if (!end.isValid())
-        end=LastGoodDay(mt);
-    QDate date=start;
-    if (date.isNull())
+    if (!start.isValid()) {
+        start = LastGoodDay(mt);
+    }
+
+    if (!end.isValid()) {
+        end = LastGoodDay(mt);
+    }
+
+    QDate date = start;
+
+    if (date.isNull()) {
         return 0;
+    }
 
 
-    double min=99999999,tmp;
+    double min = 99999999, tmp;
+
     do {
-        Day * day=GetGoodDay(date,mt);
+        Day *day = GetGoodDay(date, mt);
+
         if (day) {
-            tmp=day->Min(code);
-            if (min>tmp)
-                min=tmp;
+            tmp = day->Min(code);
+
+            if (min > tmp) {
+                min = tmp;
+            }
         }
-        date=date.addDays(1);
-    } while (date<=end);
-    if (min>=99999999)
-        min=0;
+
+        date = date.addDays(1);
+    } while (date <= end);
+
+    if (min >= 99999999) {
+        min = 0;
+    }
+
     return min;
 }
 EventDataType Profile::calcMax(ChannelID code, MachineType mt, QDate start, QDate end)
 {
-    if (!start.isValid())
-        start=LastGoodDay(mt);
-    if (!end.isValid())
-        end=LastGoodDay(mt);
-    QDate date=start;
+    if (!start.isValid()) {
+        start = LastGoodDay(mt);
+    }
+
+    if (!end.isValid()) {
+        end = LastGoodDay(mt);
+    }
+
+    QDate date = start;
+
+    double max = -99999999, tmp;
 
-    double max=-99999999,tmp;
     do {
-        Day * day=GetGoodDay(date,mt);
+        Day *day = GetGoodDay(date, mt);
+
         if (day) {
-            tmp=day->Max(code);
-            if (max<tmp)
-                max=tmp;
+            tmp = day->Max(code);
+
+            if (max < tmp) {
+                max = tmp;
+            }
         }
-        date=date.addDays(1);
-    } while (date<=end);
-    if (max<=-99999999)
-        max=0;
+
+        date = date.addDays(1);
+    } while (date <= end);
+
+    if (max <= -99999999) {
+        max = 0;
+    }
+
     return max;
 }
 EventDataType Profile::calcSettingsMin(ChannelID code, MachineType mt, QDate start, QDate end)
 {
-    if (!start.isValid())
-        start=LastGoodDay(mt);
-    if (!end.isValid())
-        end=LastGoodDay(mt);
-    QDate date=start;
-    if (date.isNull())
-        return 0;
+    if (!start.isValid()) {
+        start = LastGoodDay(mt);
+    }
+
+    if (!end.isValid()) {
+        end = LastGoodDay(mt);
+    }
+
+    QDate date = start;
+
+    if (date.isNull()) {
+        return 0;
+    }
+
+    double min = 99999999, tmp;
 
-    double min=99999999,tmp;
     do {
-        Day * day=GetGoodDay(date,mt);
+        Day *day = GetGoodDay(date, mt);
+
         if (day) {
-            tmp=day->settings_min(code);
-            if (min>tmp)
-                min=tmp;
+            tmp = day->settings_min(code);
+
+            if (min > tmp) {
+                min = tmp;
+            }
         }
-        date=date.addDays(1);
-    } while (date<=end);
-    if (min>=99999999)
-        min=0;
+
+        date = date.addDays(1);
+    } while (date <= end);
+
+    if (min >= 99999999) {
+        min = 0;
+    }
+
     return min;
 }
 EventDataType Profile::calcSettingsMax(ChannelID code, MachineType mt, QDate start, QDate end)
 {
-    if (!start.isValid())
-        start=LastGoodDay(mt);
-    if (!end.isValid())
-        end=LastGoodDay(mt);
-    QDate date=start;
-    if (date.isNull())
-        return 0;
+    if (!start.isValid()) {
+        start = LastGoodDay(mt);
+    }
+
+    if (!end.isValid()) {
+        end = LastGoodDay(mt);
+    }
+
+    QDate date = start;
+
+    if (date.isNull()) {
+        return 0;
+    }
+
+    double max = -99999999, tmp;
 
-    double max=-99999999,tmp;
     do {
-        Day * day=GetGoodDay(date,mt);
+        Day *day = GetGoodDay(date, mt);
+
         if (day) {
-            tmp=day->settings_max(code);
-            if (max<tmp)
-                max=tmp;
+            tmp = day->settings_max(code);
+
+            if (max < tmp) {
+                max = tmp;
+            }
         }
-        date=date.addDays(1);
-    } while (date<=end);
-    if (max<=-99999999)
-        max=0;
+
+        date = date.addDays(1);
+    } while (date <= end);
+
+    if (max <= -99999999) {
+        max = 0;
+    }
+
     return max;
 }
 
 struct CountSummary {
-    CountSummary(EventStoreType v) :val(v), count(0), time(0) {}
+    CountSummary(EventStoreType v) : val(v), count(0), time(0) {}
     EventStoreType val;
     EventStoreType count;
     quint32 time;
 };
 
-EventDataType Profile::calcPercentile(ChannelID code, EventDataType percent, MachineType mt, QDate start, QDate end)
+EventDataType Profile::calcPercentile(ChannelID code, EventDataType percent, MachineType mt,
+                                      QDate start, QDate end)
 {
-    if (!start.isValid())
-        start=LastGoodDay(mt);
-    if (!end.isValid())
-        end=LastGoodDay(mt);
+    if (!start.isValid()) {
+        start = LastGoodDay(mt);
+    }
 
-    QDate date=start;
-    if (date.isNull())
+    if (!end.isValid()) {
+        end = LastGoodDay(mt);
+    }
+
+    QDate date = start;
+
+    if (date.isNull()) {
         return 0;
+    }
 
     QMap<EventDataType, qint64> wmap;
     QMap<EventDataType, qint64>::iterator wmi;
 
-    QHash<ChannelID,QHash<EventStoreType, EventStoreType> >::iterator vsi;
-    QHash<ChannelID,QHash<EventStoreType, quint32> >::iterator tsi;
+    QHash<ChannelID, QHash<EventStoreType, EventStoreType> >::iterator vsi;
+    QHash<ChannelID, QHash<EventStoreType, quint32> >::iterator tsi;
     EventDataType gain;
     //bool setgain=false;
     EventDataType value;
     int weight;
 
-    qint64 SN=0;
+    qint64 SN = 0;
     bool timeweight;
+
     do {
-        Day * day=GetGoodDay(date,mt);
+        Day *day = GetGoodDay(date, mt);
+
         if (day) {
-            for (int i=0;i<day->size();i++) {
-                for (QList<Session *>::iterator s=day->begin();s!=day->end();s++) {
-                    if (!(*s)->enabled())
+            for (int i = 0; i < day->size(); i++) {
+                for (QList<Session *>::iterator s = day->begin(); s != day->end(); s++) {
+                    if (!(*s)->enabled()) {
                         continue;
+                    }
 
-                    Session *sess=*s;
-                    gain=sess->m_gain[code];
-                    if (!gain) gain=1;
-                    vsi=sess->m_valuesummary.find(code);
-                    if (vsi==sess->m_valuesummary.end()) continue;
-                    tsi=sess->m_timesummary.find(code);
-                    timeweight=(tsi!=sess->m_timesummary.end());
+                    Session *sess = *s;
+                    gain = sess->m_gain[code];
 
-                    QHash<EventStoreType, EventStoreType> & vsum=vsi.value();
-                    QHash<EventStoreType, quint32> & tsum=tsi.value();
+                    if (!gain) { gain = 1; }
+
+                    vsi = sess->m_valuesummary.find(code);
+
+                    if (vsi == sess->m_valuesummary.end()) { continue; }
+
+                    tsi = sess->m_timesummary.find(code);
+                    timeweight = (tsi != sess->m_timesummary.end());
+
+                    QHash<EventStoreType, EventStoreType> &vsum = vsi.value();
+                    QHash<EventStoreType, quint32> &tsum = tsi.value();
 
                     if (timeweight) {
-                        for (QHash<EventStoreType, quint32>::iterator k=tsum.begin();k!=tsum.end();k++) {
-                            weight=k.value();
-                            value=EventDataType(k.key())*gain;
+                        for (QHash<EventStoreType, quint32>::iterator k = tsum.begin(); k != tsum.end(); k++) {
+                            weight = k.value();
+                            value = EventDataType(k.key()) * gain;
 
-                            SN+=weight;
-                            wmi=wmap.find(value);
-                            if (wmi==wmap.end()) {
-                                wmap[value]=weight;
+                            SN += weight;
+                            wmi = wmap.find(value);
+
+                            if (wmi == wmap.end()) {
+                                wmap[value] = weight;
                             } else {
-                                wmi.value()+=weight;
+                                wmi.value() += weight;
                             }
                         }
                     } else {
-                        for (QHash<EventStoreType, EventStoreType>::iterator k=vsum.begin();k!=vsum.end();k++) {
-                            weight=k.value();
-                            value=EventDataType(k.key())*gain;
+                        for (QHash<EventStoreType, EventStoreType>::iterator k = vsum.begin(); k != vsum.end(); k++) {
+                            weight = k.value();
+                            value = EventDataType(k.key()) * gain;
 
-                            SN+=weight;
-                            wmi=wmap.find(value);
-                            if (wmi==wmap.end()) {
-                                wmap[value]=weight;
+                            SN += weight;
+                            wmi = wmap.find(value);
+
+                            if (wmi == wmap.end()) {
+                                wmap[value] = weight;
                             } else {
-                                wmi.value()+=weight;
+                                wmi.value() += weight;
                             }
                         }
                     }
                 }
             }
         }
-        date=date.addDays(1);
-    } while (date<=end);
+
+        date = date.addDays(1);
+    } while (date <= end);
+
     QVector<ValueCount> valcnt;
 
     // Build sorted list of value/counts
-    for (wmi=wmap.begin();wmi!=wmap.end();wmi++) {
+    for (wmi = wmap.begin(); wmi != wmap.end(); wmi++) {
         ValueCount vc;
-        vc.value=wmi.key();
-        vc.count=wmi.value();
-        vc.p=0;
+        vc.value = wmi.key();
+        vc.count = wmi.value();
+        vc.p = 0;
         valcnt.push_back(vc);
     }
+
     // sort by weight, then value
     qSort(valcnt);
 
     //double SN=100.0/double(N); // 100% / overall sum
-    double p=100.0*percent;
+    double p = 100.0 * percent;
 
-    double nth=double(SN)*percent; // index of the position in the unweighted set would be
-    double nthi=floor(nth);
+    double nth = double(SN) * percent; // index of the position in the unweighted set would be
+    double nthi = floor(nth);
 
-    qint64 sum1=0,sum2=0;
-    qint64 w1,w2=0;
-    double v1=0,v2=0;
+    qint64 sum1 = 0, sum2 = 0;
+    qint64 w1, w2 = 0;
+    double v1 = 0, v2 = 0;
 
-    int N=valcnt.size();
-    int k=0;
+    int N = valcnt.size();
+    int k = 0;
 
-    for (k=0;k < N;k++) {
-        v1=valcnt[k].value;
-        w1=valcnt[k].count;
-        sum1+=w1;
+    for (k = 0; k < N; k++) {
+        v1 = valcnt[k].value;
+        w1 = valcnt[k].count;
+        sum1 += w1;
 
         if (sum1 > nthi) {
             return v1;
         }
-        if (sum1 == nthi){
+
+        if (sum1 == nthi) {
             break; // boundary condition
         }
     }
-    if (k>=N)
-        return v1;
 
-    v2=valcnt[k+1].value;
-    w2=valcnt[k+1].count;
-    sum2=sum1+w2;
+    if (k >= N) {
+        return v1;
+    }
+
+    v2 = valcnt[k + 1].value;
+    w2 = valcnt[k + 1].count;
+    sum2 = sum1 + w2;
     // value lies between v1 and v2
 
-    double px=100.0/double(SN); // Percentile represented by one full value
+    double px = 100.0 / double(SN); // Percentile represented by one full value
 
     // calculate percentile ranks
-    double p1=px * (double(sum1)-(double(w1)/2.0));
-    double p2=px * (double(sum2)-(double(w2)/2.0));
+    double p1 = px * (double(sum1) - (double(w1) / 2.0));
+    double p2 = px * (double(sum2) - (double(w2) / 2.0));
 
     // calculate linear interpolation
-    double v=v1 + ((p-p1)/(p2-p1)) * (v2-v1);
+    double v = v1 + ((p - p1) / (p2 - p1)) * (v2 - v1);
 
     //  p1.....p.............p2
     //  37     55            70
@@ -925,85 +1142,121 @@ EventDataType Profile::calcPercentile(ChannelID code, EventDataType percent, Mac
 // Lookup first day record of the specified machine type, or return the first day overall if MT_UNKNOWN
 QDate Profile::FirstDay(MachineType mt)
 {
-    if ((mt==MT_UNKNOWN) || (!m_last.isValid()) || (!m_first.isValid()))
+    if ((mt == MT_UNKNOWN) || (!m_last.isValid()) || (!m_first.isValid())) {
         return m_first;
+    }
+
+    QDate d = m_first;
 
-    QDate d=m_first;
     do {
-        if (GetDay(d,mt)!=NULL)
+        if (GetDay(d, mt) != NULL) {
             return d;
-        d=d.addDays(1);
-    } while (d<=m_last);
+        }
+
+        d = d.addDays(1);
+    } while (d <= m_last);
+
     return m_last;
 }
 
 // Lookup last day record of the specified machine type, or return the first day overall if MT_UNKNOWN
 QDate Profile::LastDay(MachineType mt)
 {
-    if ((mt==MT_UNKNOWN) || (!m_last.isValid()) || (!m_first.isValid()))
+    if ((mt == MT_UNKNOWN) || (!m_last.isValid()) || (!m_first.isValid())) {
         return m_last;
-    QDate d=m_last;
+    }
+
+    QDate d = m_last;
+
     do {
-        if (GetDay(d,mt)!=NULL)
+        if (GetDay(d, mt) != NULL) {
             return d;
-        d=d.addDays(-1);
-    } while (d>=m_first);
+        }
+
+        d = d.addDays(-1);
+    } while (d >= m_first);
+
     return m_first;
 }
 
 QDate Profile::FirstGoodDay(MachineType mt)
 {
-    if (mt==MT_UNKNOWN) //|| (!m_last.isValid()) || (!m_first.isValid()))
+    if (mt == MT_UNKNOWN) { //|| (!m_last.isValid()) || (!m_first.isValid()))
         return FirstDay();
+    }
 
-    QDate d=FirstDay(mt);
-    QDate l=LastDay(mt);
-    if (!d.isValid() || !l.isValid())
+    QDate d = FirstDay(mt);
+    QDate l = LastDay(mt);
+
+    if (!d.isValid() || !l.isValid()) {
         return QDate();
+    }
+
     do {
-        if (GetGoodDay(d,mt)!=NULL)
+        if (GetGoodDay(d, mt) != NULL) {
             return d;
-        d=d.addDays(1);
-    } while (d<=l);
+        }
+
+        d = d.addDays(1);
+    } while (d <= l);
+
     return l; //m_last;
 }
 QDate Profile::LastGoodDay(MachineType mt)
 {
-    if (mt==MT_UNKNOWN) //|| (!m_last.isValid()) || (!m_first.isValid()))
+    if (mt == MT_UNKNOWN) { //|| (!m_last.isValid()) || (!m_first.isValid()))
         return FirstDay();
-    QDate d=LastDay(mt);
-    QDate f=FirstDay(mt);
-    if (!(d.isValid() && f.isValid()))
+    }
+
+    QDate d = LastDay(mt);
+    QDate f = FirstDay(mt);
+
+    if (!(d.isValid() && f.isValid())) {
         return QDate();
+    }
+
     do {
-        if (GetGoodDay(d,mt)!=NULL)
+        if (GetGoodDay(d, mt) != NULL) {
             return d;
-        d=d.addDays(-1);
-    } while (d>=f);
+        }
+
+        d = d.addDays(-1);
+    } while (d >= f);
+
     return f; //m_first;
 }
 bool Profile::hasChannel(ChannelID code)
 {
-    QDate d=LastDay();
-    QDate f=FirstDay();
-    if (!(d.isValid() && f.isValid()))
+    QDate d = LastDay();
+    QDate f = FirstDay();
+
+    if (!(d.isValid() && f.isValid())) {
         return false;
-    QMap<QDate,QList<Day *> >::iterator dit;
-    bool found=false;
+    }
+
+    QMap<QDate, QList<Day *> >::iterator dit;
+    bool found = false;
+
     do {
-        dit=daylist.find(d);
-        if (dit!=daylist.end()) {
-            for (int i=0;i<dit.value().size();i++) {
-                Day *day=dit.value().at(i);
+        dit = daylist.find(d);
+
+        if (dit != daylist.end()) {
+            for (int i = 0; i < dit.value().size(); i++) {
+                Day *day = dit.value().at(i);
+
                 if (day->channelHasData(code)) {
-                    found=true;
+                    found = true;
                     break;
                 }
             }
         }
-        if (found)
+
+        if (found) {
             break;
-        d=d.addDays(-1);
-    } while (d>=f);
+        }
+
+        d = d.addDays(-1);
+    } while (d >= f);
+
     return found;
 }
diff --git a/sleepyhead/SleepLib/profiles.h b/sleepyhead/SleepLib/profiles.h
index 98e83399..10f90f38 100644
--- a/sleepyhead/SleepLib/profiles.h
+++ b/sleepyhead/SleepLib/profiles.h
@@ -43,9 +43,9 @@ class SessionSettings;
   \date 28/04/11
   \brief The User profile system, containing all information for a user, and an index into all Machine data
  */
-class Profile:public Preferences
+class Profile: public Preferences
 {
-public:
+  public:
     //! \brief Creates a new Profile object 'name' (which is usually just set to "Profile", the XML filename is derived from this)
     Profile(QString name);
 
@@ -53,15 +53,15 @@ public:
     Profile();
     virtual ~Profile();
 
-    virtual bool Open(QString filename="");
+    virtual bool Open(QString filename = "");
 
     //! \brief Save Profile object (This is an extension to Preference::Save(..))
-    virtual bool Save(QString filename="");
+    virtual bool Save(QString filename = "");
 
     bool is_first_day;
 
     //! \brief List of machines, indexed by MachineID
-    QHash<MachineID,Machine *> machlist;
+    QHash<MachineID, Machine *> machlist;
 
     //! \brief Add machine to this profiles machlist
     void AddMachine(Machine *m);
@@ -81,54 +81,63 @@ public:
     int Import(QString path);
 
     //! \brief Remove a session from day object, without deleting the Session object
-    void RemoveSession(Session * sess);
+    void RemoveSession(Session *sess);
 
     //! \brief Add Day record to Profile Day list
-    void AddDay(QDate date,Day *day,MachineType mt);
+    void AddDay(QDate date, Day *day, MachineType mt);
 
     //! \brief Get Day record if data available for date and machine type, else return NULL
-    Day * GetDay(QDate date,MachineType type=MT_UNKNOWN);
+    Day *GetDay(QDate date, MachineType type = MT_UNKNOWN);
 
     //! \brief Get Day record if data available for date and machine type, and has enabled session data, else return NULL
-    Day * GetGoodDay(QDate date,MachineType type);
+    Day *GetGoodDay(QDate date, MachineType type);
 
 
     //! \brief Returns a list of all machines of type t
-    QList<Machine *> GetMachines(MachineType t=MT_UNKNOWN);
+    QList<Machine *> GetMachines(MachineType t = MT_UNKNOWN);
 
     //! \brief Returns the machine of type t used on date, NULL if none..
-    Machine * GetMachine(MachineType t,QDate date);
+    Machine *GetMachine(MachineType t, QDate date);
 
     //! \brief return the first machine of type t
-    Machine * GetMachine(MachineType t);
+    Machine *GetMachine(MachineType t);
 
     //! \brief Returns true if this profile stores this variable identified by key
     bool contains(QString key) { return p_preferences.contains(key); }
 
-    int countDays(MachineType mt=MT_UNKNOWN, QDate start=QDate(), QDate end=QDate());
-    EventDataType calcCount(ChannelID code, MachineType mt=MT_CPAP, QDate start=QDate(), QDate end=QDate());
-    double calcSum(ChannelID code, MachineType mt=MT_CPAP, QDate start=QDate(), QDate end=QDate());
-    EventDataType calcHours(MachineType mt=MT_CPAP, QDate start=QDate(), QDate end=QDate());
-    EventDataType calcAvg(ChannelID code, MachineType mt=MT_CPAP, QDate start=QDate(), QDate end=QDate());
-    EventDataType calcWavg(ChannelID code, MachineType mt=MT_CPAP, QDate start=QDate(), QDate end=QDate());
-    EventDataType calcMin(ChannelID code, MachineType mt=MT_CPAP, QDate start=QDate(), QDate end=QDate());
-    EventDataType calcMax(ChannelID code, MachineType mt=MT_CPAP, QDate start=QDate(), QDate end=QDate());
-    EventDataType calcPercentile(ChannelID code, EventDataType percent, MachineType mt=MT_CPAP, QDate start=QDate(), QDate end=QDate());
+    int countDays(MachineType mt = MT_UNKNOWN, QDate start = QDate(), QDate end = QDate());
+    EventDataType calcCount(ChannelID code, MachineType mt = MT_CPAP, QDate start = QDate(),
+                            QDate end = QDate());
+    double calcSum(ChannelID code, MachineType mt = MT_CPAP, QDate start = QDate(),
+                   QDate end = QDate());
+    EventDataType calcHours(MachineType mt = MT_CPAP, QDate start = QDate(), QDate end = QDate());
+    EventDataType calcAvg(ChannelID code, MachineType mt = MT_CPAP, QDate start = QDate(),
+                          QDate end = QDate());
+    EventDataType calcWavg(ChannelID code, MachineType mt = MT_CPAP, QDate start = QDate(),
+                           QDate end = QDate());
+    EventDataType calcMin(ChannelID code, MachineType mt = MT_CPAP, QDate start = QDate(),
+                          QDate end = QDate());
+    EventDataType calcMax(ChannelID code, MachineType mt = MT_CPAP, QDate start = QDate(),
+                          QDate end = QDate());
+    EventDataType calcPercentile(ChannelID code, EventDataType percent, MachineType mt = MT_CPAP,
+                                 QDate start = QDate(), QDate end = QDate());
 
     bool hasChannel(ChannelID code);
 
-    EventDataType calcSettingsMin(ChannelID code, MachineType mt=MT_CPAP, QDate start=QDate(), QDate end=QDate());
-    EventDataType calcSettingsMax(ChannelID code, MachineType mt=MT_CPAP, QDate start=QDate(), QDate end=QDate());
+    EventDataType calcSettingsMin(ChannelID code, MachineType mt = MT_CPAP, QDate start = QDate(),
+                                  QDate end = QDate());
+    EventDataType calcSettingsMax(ChannelID code, MachineType mt = MT_CPAP, QDate start = QDate(),
+                                  QDate end = QDate());
 
-    virtual void ExtraLoad(QDomElement & root);
-    virtual QDomElement ExtraSave(QDomDocument & doc);
+    virtual void ExtraLoad(QDomElement &root);
+    virtual QDomElement ExtraSave(QDomDocument &doc);
 
-    QMap<QDate,QList<Day *> > daylist;
-    QDate FirstDay(MachineType mt=MT_UNKNOWN);
-    QDate LastDay(MachineType mt=MT_UNKNOWN);
+    QMap<QDate, QList<Day *> > daylist;
+    QDate FirstDay(MachineType mt = MT_UNKNOWN);
+    QDate LastDay(MachineType mt = MT_UNKNOWN);
 
-    QDate FirstGoodDay(MachineType mt=MT_UNKNOWN);
-    QDate LastGoodDay(MachineType mt=MT_UNKNOWN);
+    QDate FirstGoodDay(MachineType mt = MT_UNKNOWN);
+    QDate LastGoodDay(MachineType mt = MT_UNKNOWN);
 
     QString dataFolder() { return (*this).Get("{DataFolder}"); }
 
@@ -141,17 +150,17 @@ public:
     SessionSettings *session;
 
 
-protected:
-    QDate m_first,m_last;
+  protected:
+    QDate m_first, m_last;
 
 };
 
 class MachineLoader;
-extern MachineLoader * GetLoader(QString name);
+extern MachineLoader *GetLoader(QString name);
 
 extern Preferences *p_pref;
 extern Preferences *p_layout;
-extern Profile * p_profile;
+extern Profile *p_profile;
 
 // these are bad and must change
 #define PREF (*p_pref)
@@ -159,111 +168,115 @@ extern Profile * p_profile;
 #define PROFILE (*p_profile)
 
 // DoctorInfo Strings
-const QString STR_DI_Name="DoctorName";
-const QString STR_DI_Phone="DoctorPhone";
-const QString STR_DI_Email="DoctorEmail";
-const QString STR_DI_Practice="DoctorPractice";
-const QString STR_DI_Address="DoctorAddress";
-const QString STR_DI_PatientID="DoctorPatientID";
+const QString STR_DI_Name = "DoctorName";
+const QString STR_DI_Phone = "DoctorPhone";
+const QString STR_DI_Email = "DoctorEmail";
+const QString STR_DI_Practice = "DoctorPractice";
+const QString STR_DI_Address = "DoctorAddress";
+const QString STR_DI_PatientID = "DoctorPatientID";
 
 // UserInfo Strings
-const QString STR_UI_DOB="DOB";
-const QString STR_UI_FirstName="FirstName";
-const QString STR_UI_LastName="LastName";
-const QString STR_UI_UserName="UserName";
-const QString STR_UI_Password="Password";
-const QString STR_UI_Address="Address";
-const QString STR_UI_Phone="Phone";
-const QString STR_UI_EmailAddress="EmailAddress";
-const QString STR_UI_Country="Country";
-const QString STR_UI_Height="Height";
-const QString STR_UI_Gender="Gender";
-const QString STR_UI_TimeZone="TimeZone";
-const QString STR_UI_DST="DST";
+const QString STR_UI_DOB = "DOB";
+const QString STR_UI_FirstName = "FirstName";
+const QString STR_UI_LastName = "LastName";
+const QString STR_UI_UserName = "UserName";
+const QString STR_UI_Password = "Password";
+const QString STR_UI_Address = "Address";
+const QString STR_UI_Phone = "Phone";
+const QString STR_UI_EmailAddress = "EmailAddress";
+const QString STR_UI_Country = "Country";
+const QString STR_UI_Height = "Height";
+const QString STR_UI_Gender = "Gender";
+const QString STR_UI_TimeZone = "TimeZone";
+const QString STR_UI_DST = "DST";
 
 // OxiSettings Strings
-const QString STR_OS_EnableOximetry="EnableOximetry";
-const QString STR_OS_SyncOximetry="SyncOximetry";
-const QString STR_OS_OximeterType="OximeterType";
-const QString STR_OS_OxiDiscardThreshold="OxiDiscardThreshold";
-const QString STR_OS_SPO2DropDuration="SPO2DropDuration";
-const QString STR_OS_SPO2DropPercentage="SPO2DropPercentage";
-const QString STR_OS_PulseChangeDuration="PulseChangeDuration";
-const QString STR_OS_PulseChangeBPM="PulseChangeBPM";
+const QString STR_OS_EnableOximetry = "EnableOximetry";
+const QString STR_OS_SyncOximetry = "SyncOximetry";
+const QString STR_OS_OximeterType = "OximeterType";
+const QString STR_OS_OxiDiscardThreshold = "OxiDiscardThreshold";
+const QString STR_OS_SPO2DropDuration = "SPO2DropDuration";
+const QString STR_OS_SPO2DropPercentage = "SPO2DropPercentage";
+const QString STR_OS_PulseChangeDuration = "PulseChangeDuration";
+const QString STR_OS_PulseChangeBPM = "PulseChangeBPM";
 
 // CPAPSettings Strings
-const QString STR_CS_ComplianceHours="ComplianceHours";
-const QString STR_CS_ShowCompliance="ShowCompliance";
-const QString STR_CS_ShowLeaksMode="ShowLeaksMode";
-const QString STR_CS_MaskStartDate="MaskStartDate";
-const QString STR_CS_MaskDescription="MaskDescription";
-const QString STR_CS_MaskType="MaskType";
-const QString STR_CS_PrescribedMode="CPAPPrescribedMode";
-const QString STR_CS_PrescribedMinPressure="CPAPPrescribedMinPressure";
-const QString STR_CS_PrescribedMaxPressure="CPAPPrescribedMaxPressure";
-const QString STR_CS_UntreatedAHI="UntreatedAHI";
-const QString STR_CS_Notes="CPAPNotes";
-const QString STR_CS_DateDiagnosed="DateDiagnosed";
-const QString STR_CS_UserEventFlagging="UserEventFlagging";
-const QString STR_CS_UserFlowRestriction="UserFlowRestriction";
-const QString STR_CS_UserEventDuration="UserEventDuration";
-const QString STR_CS_UserEventDuplicates="UserEventDuplicates";
-const QString STR_CS_AHIWindow="AHIWindow";
-const QString STR_CS_AHIReset="AHIReset";
-const QString STR_CS_ClockDrift="ClockDrift";
+const QString STR_CS_ComplianceHours = "ComplianceHours";
+const QString STR_CS_ShowCompliance = "ShowCompliance";
+const QString STR_CS_ShowLeaksMode = "ShowLeaksMode";
+const QString STR_CS_MaskStartDate = "MaskStartDate";
+const QString STR_CS_MaskDescription = "MaskDescription";
+const QString STR_CS_MaskType = "MaskType";
+const QString STR_CS_PrescribedMode = "CPAPPrescribedMode";
+const QString STR_CS_PrescribedMinPressure = "CPAPPrescribedMinPressure";
+const QString STR_CS_PrescribedMaxPressure = "CPAPPrescribedMaxPressure";
+const QString STR_CS_UntreatedAHI = "UntreatedAHI";
+const QString STR_CS_Notes = "CPAPNotes";
+const QString STR_CS_DateDiagnosed = "DateDiagnosed";
+const QString STR_CS_UserEventFlagging = "UserEventFlagging";
+const QString STR_CS_UserFlowRestriction = "UserFlowRestriction";
+const QString STR_CS_UserEventDuration = "UserEventDuration";
+const QString STR_CS_UserEventDuplicates = "UserEventDuplicates";
+const QString STR_CS_AHIWindow = "AHIWindow";
+const QString STR_CS_AHIReset = "AHIReset";
+const QString STR_CS_ClockDrift = "ClockDrift";
 
 // ImportSettings Strings
-const QString STR_IS_DaySplitTime="DaySplitTime";
-const QString STR_IS_CacheSessions="MemoryHog";
-const QString STR_IS_CombineCloseSessions="CombineCloserSessions";
-const QString STR_IS_IgnoreShorterSessions="IgnoreShorterSessions";
-const QString STR_IS_Multithreading="EnableMultithreading";
-const QString STR_IS_BackupCardData="BackupCardData";
-const QString STR_IS_CompressBackupData="CompressBackupData";
-const QString STR_IS_CompressSessionData="CompressSessionData";
+const QString STR_IS_DaySplitTime = "DaySplitTime";
+const QString STR_IS_CacheSessions = "MemoryHog";
+const QString STR_IS_CombineCloseSessions = "CombineCloserSessions";
+const QString STR_IS_IgnoreShorterSessions = "IgnoreShorterSessions";
+const QString STR_IS_Multithreading = "EnableMultithreading";
+const QString STR_IS_BackupCardData = "BackupCardData";
+const QString STR_IS_CompressBackupData = "CompressBackupData";
+const QString STR_IS_CompressSessionData = "CompressSessionData";
 
 // AppearanceSettings Strings
-const QString STR_AS_GraphHeight="GraphHeight";
-const QString STR_AS_AntiAliasing="UseAntiAliasing";
-const QString STR_AS_GraphSnapshots="EnableGraphSnapshots";
-const QString STR_AS_Animations="AnimationsAndTransitions";
-const QString STR_AS_SquareWave="SquareWavePlots";
-const QString STR_AS_OverlayType="OverlayType";
-const QString STR_AS_OverviewLinechartMode="OverviewLinechartMode";
-const QString STR_AS_UsePixmapCaching="UsePixmapCaching";
-const QString STR_AS_AllowYAxisScaling="AllowYAxisScaling";
-const QString STR_AS_GraphTooltips="GraphTooltips";
+const QString STR_AS_GraphHeight = "GraphHeight";
+const QString STR_AS_AntiAliasing = "UseAntiAliasing";
+const QString STR_AS_GraphSnapshots = "EnableGraphSnapshots";
+const QString STR_AS_Animations = "AnimationsAndTransitions";
+const QString STR_AS_SquareWave = "SquareWavePlots";
+const QString STR_AS_OverlayType = "OverlayType";
+const QString STR_AS_OverviewLinechartMode = "OverviewLinechartMode";
+const QString STR_AS_UsePixmapCaching = "UsePixmapCaching";
+const QString STR_AS_AllowYAxisScaling = "AllowYAxisScaling";
+const QString STR_AS_GraphTooltips = "GraphTooltips";
 
 // UserSettings Strings
-const QString STR_US_UnitSystem="UnitSystem";
-const QString STR_US_EventWindowSize="EventWindowSize";
-const QString STR_US_SkipEmptyDays="SkipEmptyDays";
-const QString STR_US_RebuildCache="RebuildCache";
-const QString STR_US_ShowDebug="ShowDebug";
-const QString STR_US_LinkGroups="LinkGroups";
-const QString STR_US_CalculateRDI="CalculateRDI";
-const QString STR_US_ShowSerialNumbers="ShowSerialNumbers";
-const QString STR_US_PrefCalcMiddle="PrefCalcMiddle";
-const QString STR_US_PrefCalcPercentile="PrefCalcPercentile";
-const QString STR_US_PrefCalcMax="PrefCalcMax";
-const QString STR_US_TooltipTimeout="TooltipTimeout";
-const QString STR_US_ScrollDampening="ScrollDampening";
+const QString STR_US_UnitSystem = "UnitSystem";
+const QString STR_US_EventWindowSize = "EventWindowSize";
+const QString STR_US_SkipEmptyDays = "SkipEmptyDays";
+const QString STR_US_RebuildCache = "RebuildCache";
+const QString STR_US_ShowDebug = "ShowDebug";
+const QString STR_US_LinkGroups = "LinkGroups";
+const QString STR_US_CalculateRDI = "CalculateRDI";
+const QString STR_US_ShowSerialNumbers = "ShowSerialNumbers";
+const QString STR_US_PrefCalcMiddle = "PrefCalcMiddle";
+const QString STR_US_PrefCalcPercentile = "PrefCalcPercentile";
+const QString STR_US_PrefCalcMax = "PrefCalcMax";
+const QString STR_US_TooltipTimeout = "TooltipTimeout";
+const QString STR_US_ScrollDampening = "ScrollDampening";
 
 
 class DoctorInfo
 {
-public:
-    DoctorInfo(Profile *p) : m_profile(p)
-    {
-        if (!m_profile->contains(STR_DI_Name)) (*m_profile)[STR_DI_Name]=QString();
-        if (!m_profile->contains(STR_DI_Phone)) (*m_profile)[STR_DI_Phone]=QString();
-        if (!m_profile->contains(STR_DI_Email)) (*m_profile)[STR_DI_Email]=QString();
-        if (!m_profile->contains(STR_DI_Practice)) (*m_profile)[STR_DI_Practice]=QString();
-        if (!m_profile->contains(STR_DI_Address)) (*m_profile)[STR_DI_Address]=QString();
-        if (!m_profile->contains(STR_DI_PatientID)) (*m_profile)[STR_DI_PatientID]=QString();
+  public:
+    DoctorInfo(Profile *p) : m_profile(p) {
+        if (!m_profile->contains(STR_DI_Name)) { (*m_profile)[STR_DI_Name] = QString(); }
+
+        if (!m_profile->contains(STR_DI_Phone)) { (*m_profile)[STR_DI_Phone] = QString(); }
+
+        if (!m_profile->contains(STR_DI_Email)) { (*m_profile)[STR_DI_Email] = QString(); }
+
+        if (!m_profile->contains(STR_DI_Practice)) { (*m_profile)[STR_DI_Practice] = QString(); }
+
+        if (!m_profile->contains(STR_DI_Address)) { (*m_profile)[STR_DI_Address] = QString(); }
+
+        if (!m_profile->contains(STR_DI_PatientID)) { (*m_profile)[STR_DI_PatientID] = QString(); }
     }
     ~DoctorInfo() {}
-    void setProfile(Profile *p) { m_profile=p; }
+    void setProfile(Profile *p) { m_profile = p; }
 
     const QString name() { return (*m_profile)[STR_DI_Name].toString(); }
     const QString phone() { return (*m_profile)[STR_DI_Phone].toString(); }
@@ -272,12 +285,12 @@ public:
     const QString address() { return (*m_profile)[STR_DI_Address].toString(); }
     const QString patientID() { return (*m_profile)[STR_DI_PatientID].toString(); }
 
-    void setName(QString name) { (*m_profile)[STR_DI_Name]=name; }
-    void setPhone(QString phone) { (*m_profile)[STR_DI_Phone]=phone; }
-    void setEmail(QString phone) { (*m_profile)[STR_DI_Email]=phone; }
-    void setPracticeName(QString practice) { (*m_profile)[STR_DI_Practice]=practice; }
-    void setAddress(QString address) { (*m_profile)[STR_DI_Address]=address; }
-    void setPatientID(QString pid) { (*m_profile)[STR_DI_PatientID]=pid; }
+    void setName(QString name) { (*m_profile)[STR_DI_Name] = name; }
+    void setPhone(QString phone) { (*m_profile)[STR_DI_Phone] = phone; }
+    void setEmail(QString phone) { (*m_profile)[STR_DI_Email] = phone; }
+    void setPracticeName(QString practice) { (*m_profile)[STR_DI_Practice] = practice; }
+    void setAddress(QString address) { (*m_profile)[STR_DI_Address] = address; }
+    void setPatientID(QString pid) { (*m_profile)[STR_DI_PatientID] = pid; }
 
     Profile *m_profile;
 };
@@ -288,28 +301,39 @@ public:
     */
 class UserInfo
 {
-public:
+  public:
     //! \brief Create UserInfo object given Profile *p, and initialize the defaults
-    UserInfo(Profile *p) : m_profile(p)
-    {
-        if (!m_profile->contains(STR_UI_DOB)) (*m_profile)[STR_UI_DOB]=QDate(1970,1,1);
-        if (!m_profile->contains(STR_UI_FirstName)) (*m_profile)[STR_UI_FirstName]=QString();
-        if (!m_profile->contains(STR_UI_LastName)) (*m_profile)[STR_UI_LastName]=QString();
-        if (!m_profile->contains(STR_UI_UserName)) (*m_profile)[STR_UI_UserName]=QString();
-        if (!m_profile->contains(STR_UI_Password)) (*m_profile)[STR_UI_Password]=QString();
-        if (!m_profile->contains(STR_UI_Address)) (*m_profile)[STR_UI_Address]=QString();
-        if (!m_profile->contains(STR_UI_Phone)) (*m_profile)[STR_UI_Phone]=QString();
-        if (!m_profile->contains(STR_UI_EmailAddress)) (*m_profile)[STR_UI_EmailAddress]=QString();
-        if (!m_profile->contains(STR_UI_Country)) (*m_profile)[STR_UI_Country]=QString();
-        if (!m_profile->contains(STR_UI_Height)) (*m_profile)[STR_UI_Height]=0.0;
-        if (!m_profile->contains(STR_UI_Gender)) (*m_profile)[STR_UI_Gender]=(int)GenderNotSpecified;
-        if (!m_profile->contains(STR_UI_TimeZone)) (*m_profile)[STR_UI_TimeZone]=QString();
-        if (!m_profile->contains(STR_UI_DST)) (*m_profile)[STR_UI_DST]=false;
+    UserInfo(Profile *p) : m_profile(p) {
+        if (!m_profile->contains(STR_UI_DOB)) { (*m_profile)[STR_UI_DOB] = QDate(1970, 1, 1); }
+
+        if (!m_profile->contains(STR_UI_FirstName)) { (*m_profile)[STR_UI_FirstName] = QString(); }
+
+        if (!m_profile->contains(STR_UI_LastName)) { (*m_profile)[STR_UI_LastName] = QString(); }
+
+        if (!m_profile->contains(STR_UI_UserName)) { (*m_profile)[STR_UI_UserName] = QString(); }
+
+        if (!m_profile->contains(STR_UI_Password)) { (*m_profile)[STR_UI_Password] = QString(); }
+
+        if (!m_profile->contains(STR_UI_Address)) { (*m_profile)[STR_UI_Address] = QString(); }
+
+        if (!m_profile->contains(STR_UI_Phone)) { (*m_profile)[STR_UI_Phone] = QString(); }
+
+        if (!m_profile->contains(STR_UI_EmailAddress)) { (*m_profile)[STR_UI_EmailAddress] = QString(); }
+
+        if (!m_profile->contains(STR_UI_Country)) { (*m_profile)[STR_UI_Country] = QString(); }
+
+        if (!m_profile->contains(STR_UI_Height)) { (*m_profile)[STR_UI_Height] = 0.0; }
+
+        if (!m_profile->contains(STR_UI_Gender)) { (*m_profile)[STR_UI_Gender] = (int)GenderNotSpecified; }
+
+        if (!m_profile->contains(STR_UI_TimeZone)) { (*m_profile)[STR_UI_TimeZone] = QString(); }
+
+        if (!m_profile->contains(STR_UI_DST)) { (*m_profile)[STR_UI_DST] = false; }
 
     }
     ~UserInfo() {}
 
-    void setProfile(Profile *p) { m_profile=p; }
+    void setProfile(Profile *p) { m_profile = p; }
 
     QDate DOB() { return (*m_profile)[STR_UI_DOB].toDate(); }
     const QString firstName() { return (*m_profile)[STR_UI_FirstName].toString(); }
@@ -324,30 +348,32 @@ public:
     const QString timeZone() { return (*m_profile)[STR_UI_TimeZone].toString(); }
     bool daylightSaving() { return (*m_profile)[STR_UI_DST].toBool(); }
 
-    void setDOB(QDate date) { (*m_profile)[STR_UI_DOB]=date; }
-    void setFirstName(QString name) { (*m_profile)[STR_UI_FirstName]=name; }
-    void setLastName(QString name) { (*m_profile)[STR_UI_LastName]=name; }
-    void setUserName(QString username) { (*m_profile)[STR_UI_UserName]=username; }
-    void setAddress(QString address) { (*m_profile)[STR_UI_Address]=address; }
-    void setPhone(QString phone) { (*m_profile)[STR_UI_Phone]=phone; }
-    void setEmail(QString email) { (*m_profile)[STR_UI_EmailAddress]=email; }
-    void setHeight(double height) { (*m_profile)[STR_UI_Height]=height; }
-    void setCountry(QString country) { (*m_profile)[STR_UI_Country]=country; }
-    void setGender(Gender g) { (*m_profile)[STR_UI_Gender]=(int)g; }
-    void setTimeZone(QString tz) { (*m_profile)[STR_UI_TimeZone]=tz; }
-    void setDaylightSaving(bool ds) { (*m_profile)[STR_UI_DST]=ds; }
+    void setDOB(QDate date) { (*m_profile)[STR_UI_DOB] = date; }
+    void setFirstName(QString name) { (*m_profile)[STR_UI_FirstName] = name; }
+    void setLastName(QString name) { (*m_profile)[STR_UI_LastName] = name; }
+    void setUserName(QString username) { (*m_profile)[STR_UI_UserName] = username; }
+    void setAddress(QString address) { (*m_profile)[STR_UI_Address] = address; }
+    void setPhone(QString phone) { (*m_profile)[STR_UI_Phone] = phone; }
+    void setEmail(QString email) { (*m_profile)[STR_UI_EmailAddress] = email; }
+    void setHeight(double height) { (*m_profile)[STR_UI_Height] = height; }
+    void setCountry(QString country) { (*m_profile)[STR_UI_Country] = country; }
+    void setGender(Gender g) { (*m_profile)[STR_UI_Gender] = (int)g; }
+    void setTimeZone(QString tz) { (*m_profile)[STR_UI_TimeZone] = tz; }
+    void setDaylightSaving(bool ds) { (*m_profile)[STR_UI_DST] = ds; }
 
     bool hasPassword() {
         return !((*m_profile)[STR_UI_Password].toString().isEmpty());
     }
     bool checkPassword(QString password) {
-        QByteArray ba=password.toUtf8();
-        return ((*m_profile)[STR_UI_Password].toString()==QString(QCryptographicHash::hash(ba,QCryptographicHash::Sha1).toHex()));
+        QByteArray ba = password.toUtf8();
+        return ((*m_profile)[STR_UI_Password].toString() == QString(QCryptographicHash::hash(ba,
+                QCryptographicHash::Sha1).toHex()));
     }
     void setPassword(QString password) {
-        QByteArray ba=password.toUtf8();
+        QByteArray ba = password.toUtf8();
         // Hash me.
-        (*m_profile)[STR_UI_Password]=QString(QCryptographicHash::hash(ba,QCryptographicHash::Sha1).toHex());
+        (*m_profile)[STR_UI_Password] = QString(QCryptographicHash::hash(ba,
+                                                QCryptographicHash::Sha1).toHex());
     }
 
     Profile *m_profile;
@@ -359,22 +385,28 @@ public:
     */
 class OxiSettings
 {
-public:
+  public:
     //! \brief Create OxiSettings object given Profile *p, and initialize the defaults
-    OxiSettings(Profile *p) :m_profile(p)
-    {
-        if (!m_profile->contains(STR_OS_EnableOximetry)) (*m_profile)[STR_OS_EnableOximetry]=false;
-        if (!m_profile->contains(STR_OS_SyncOximetry)) (*m_profile)[STR_OS_SyncOximetry]=true;
-        if (!m_profile->contains(STR_OS_OximeterType)) (*m_profile)[STR_OS_OximeterType]="CMS50";
-        if (!m_profile->contains(STR_OS_OxiDiscardThreshold)) (*m_profile)[STR_OS_OxiDiscardThreshold]=0.0;
-        if (!m_profile->contains(STR_OS_SPO2DropDuration)) (*m_profile)[STR_OS_SPO2DropDuration]=8.0;
-        if (!m_profile->contains(STR_OS_SPO2DropPercentage)) (*m_profile)[STR_OS_SPO2DropPercentage]=3.0;
-        if (!m_profile->contains(STR_OS_PulseChangeDuration)) (*m_profile)[STR_OS_PulseChangeDuration]=8.0;
-        if (!m_profile->contains(STR_OS_PulseChangeBPM)) (*m_profile)[STR_OS_PulseChangeBPM]=5.0;
+    OxiSettings(Profile *p) : m_profile(p) {
+        if (!m_profile->contains(STR_OS_EnableOximetry)) { (*m_profile)[STR_OS_EnableOximetry] = false; }
+
+        if (!m_profile->contains(STR_OS_SyncOximetry)) { (*m_profile)[STR_OS_SyncOximetry] = true; }
+
+        if (!m_profile->contains(STR_OS_OximeterType)) { (*m_profile)[STR_OS_OximeterType] = "CMS50"; }
+
+        if (!m_profile->contains(STR_OS_OxiDiscardThreshold)) { (*m_profile)[STR_OS_OxiDiscardThreshold] = 0.0; }
+
+        if (!m_profile->contains(STR_OS_SPO2DropDuration)) { (*m_profile)[STR_OS_SPO2DropDuration] = 8.0; }
+
+        if (!m_profile->contains(STR_OS_SPO2DropPercentage)) { (*m_profile)[STR_OS_SPO2DropPercentage] = 3.0; }
+
+        if (!m_profile->contains(STR_OS_PulseChangeDuration)) { (*m_profile)[STR_OS_PulseChangeDuration] = 8.0; }
+
+        if (!m_profile->contains(STR_OS_PulseChangeBPM)) { (*m_profile)[STR_OS_PulseChangeBPM] = 5.0; }
     }
     ~OxiSettings() {}
 
-    void setProfile(Profile *p) { m_profile=p; }
+    void setProfile(Profile *p) { m_profile = p; }
 
     bool oximetryEnabled()  { return (*m_profile)[STR_OS_EnableOximetry].toBool(); }
     bool syncOximetry() { return (*m_profile)[STR_OS_SyncOximetry].toBool(); }
@@ -385,14 +417,14 @@ public:
     double pulseChangeDuration() { return (*m_profile)[STR_OS_PulseChangeDuration].toDouble(); }
     double pulseChangeBPM() { return (*m_profile)[STR_OS_PulseChangeBPM].toDouble(); }
 
-    void setOximetryEnabled(bool enabled)  { (*m_profile)[STR_OS_EnableOximetry]=enabled; }
-    void setSyncOximetry(bool synced) { (*m_profile)[STR_OS_SyncOximetry]=synced; }
-    void setOximeterType(QString oxitype) { (*m_profile)[STR_OS_OximeterType]=oxitype; }
-    void setOxiDiscardThreshold(double thresh) { (*m_profile)[STR_OS_OxiDiscardThreshold]=thresh; }
-    void setSpO2DropDuration(double duration) { (*m_profile)[STR_OS_SPO2DropDuration]=duration; }
-    void setSpO2DropPercentage(double percentage) { (*m_profile)[STR_OS_SPO2DropPercentage]=percentage; }
-    void setPulseChangeDuration(double duration) { (*m_profile)[STR_OS_PulseChangeDuration]=duration; }
-    void setPulseChangeBPM(double bpm) { (*m_profile)[STR_OS_PulseChangeBPM]=bpm; }
+    void setOximetryEnabled(bool enabled)  { (*m_profile)[STR_OS_EnableOximetry] = enabled; }
+    void setSyncOximetry(bool synced) { (*m_profile)[STR_OS_SyncOximetry] = synced; }
+    void setOximeterType(QString oxitype) { (*m_profile)[STR_OS_OximeterType] = oxitype; }
+    void setOxiDiscardThreshold(double thresh) { (*m_profile)[STR_OS_OxiDiscardThreshold] = thresh; }
+    void setSpO2DropDuration(double duration) { (*m_profile)[STR_OS_SPO2DropDuration] = duration; }
+    void setSpO2DropPercentage(double percentage) { (*m_profile)[STR_OS_SPO2DropPercentage] = percentage; }
+    void setPulseChangeDuration(double duration) { (*m_profile)[STR_OS_PulseChangeDuration] = duration; }
+    void setPulseChangeBPM(double bpm) { (*m_profile)[STR_OS_PulseChangeBPM] = bpm; }
 
     Profile *m_profile;
 };
@@ -402,36 +434,53 @@ public:
     */
 class CPAPSettings
 {
-public:
+  public:
     //! \brief Create CPAPSettings object given Profile *p, and initialize the defaults
-    CPAPSettings(Profile *p) :m_profile(p)
-    {
-        if (!m_profile->contains(STR_CS_ComplianceHours)) (*m_profile)[STR_CS_ComplianceHours]=4;
-        if (!m_profile->contains(STR_CS_ShowCompliance)) (*m_profile)[STR_CS_ShowCompliance]=true;
-        if (!m_profile->contains(STR_CS_ShowLeaksMode)) (*m_profile)[STR_CS_ShowLeaksMode]=0;
+    CPAPSettings(Profile *p) : m_profile(p) {
+        if (!m_profile->contains(STR_CS_ComplianceHours)) { (*m_profile)[STR_CS_ComplianceHours] = 4; }
+
+        if (!m_profile->contains(STR_CS_ShowCompliance)) { (*m_profile)[STR_CS_ShowCompliance] = true; }
+
+        if (!m_profile->contains(STR_CS_ShowLeaksMode)) { (*m_profile)[STR_CS_ShowLeaksMode] = 0; }
+
         // TODO: Check if this date is initiliazed yet
-        if (!m_profile->contains(STR_CS_MaskStartDate)) (*m_profile)[STR_CS_MaskStartDate]=QDate();
-        if (!m_profile->contains(STR_CS_MaskDescription)) (*m_profile)[STR_CS_MaskDescription]=QString();
-        if (!m_profile->contains(STR_CS_MaskType)) (*m_profile)[STR_CS_MaskType]=Mask_Unknown;
-        if (!m_profile->contains(STR_CS_PrescribedMode)) (*m_profile)[STR_CS_PrescribedMode]=MODE_UNKNOWN;
-        if (!m_profile->contains(STR_CS_PrescribedMinPressure)) (*m_profile)[STR_CS_PrescribedMinPressure]=0.0;
-        if (!m_profile->contains(STR_CS_PrescribedMaxPressure)) (*m_profile)[STR_CS_PrescribedMaxPressure]=0.0;
-        if (!m_profile->contains(STR_CS_UntreatedAHI)) (*m_profile)[STR_CS_UntreatedAHI]=0.0;
-        if (!m_profile->contains(STR_CS_Notes)) (*m_profile)[STR_CS_Notes]=QString();
-        if (!m_profile->contains(STR_CS_DateDiagnosed)) (*m_profile)[STR_CS_DateDiagnosed]=QDate();
-        if (!m_profile->contains(STR_CS_UserFlowRestriction)) (*m_profile)[STR_CS_UserFlowRestriction]=20.0;
-        if (!m_profile->contains(STR_CS_UserEventDuration)) (*m_profile)[STR_CS_UserEventDuration]=10.0;
-        if (!m_profile->contains(STR_CS_UserEventDuplicates)) (*m_profile)[STR_CS_UserEventDuplicates]=false;
-        if (!m_profile->contains(STR_CS_UserEventFlagging)) (*m_profile)[STR_CS_UserEventFlagging]=false;
-        if (!m_profile->contains(STR_CS_AHIWindow)) (*m_profile)[STR_CS_AHIWindow]=60.0;
-        if (!m_profile->contains(STR_CS_AHIReset)) (*m_profile)[STR_CS_AHIReset]=false;
-        if (!m_profile->contains(STR_CS_ClockDrift)) (*m_profile)[STR_CS_ClockDrift]=m_clock_drift=(int)0;
-        else m_clock_drift=(*m_profile)[STR_CS_ClockDrift].toInt();
+        if (!m_profile->contains(STR_CS_MaskStartDate)) { (*m_profile)[STR_CS_MaskStartDate] = QDate(); }
+
+        if (!m_profile->contains(STR_CS_MaskDescription)) { (*m_profile)[STR_CS_MaskDescription] = QString(); }
+
+        if (!m_profile->contains(STR_CS_MaskType)) { (*m_profile)[STR_CS_MaskType] = Mask_Unknown; }
+
+        if (!m_profile->contains(STR_CS_PrescribedMode)) { (*m_profile)[STR_CS_PrescribedMode] = MODE_UNKNOWN; }
+
+        if (!m_profile->contains(STR_CS_PrescribedMinPressure)) { (*m_profile)[STR_CS_PrescribedMinPressure] = 0.0; }
+
+        if (!m_profile->contains(STR_CS_PrescribedMaxPressure)) { (*m_profile)[STR_CS_PrescribedMaxPressure] = 0.0; }
+
+        if (!m_profile->contains(STR_CS_UntreatedAHI)) { (*m_profile)[STR_CS_UntreatedAHI] = 0.0; }
+
+        if (!m_profile->contains(STR_CS_Notes)) { (*m_profile)[STR_CS_Notes] = QString(); }
+
+        if (!m_profile->contains(STR_CS_DateDiagnosed)) { (*m_profile)[STR_CS_DateDiagnosed] = QDate(); }
+
+        if (!m_profile->contains(STR_CS_UserFlowRestriction)) { (*m_profile)[STR_CS_UserFlowRestriction] = 20.0; }
+
+        if (!m_profile->contains(STR_CS_UserEventDuration)) { (*m_profile)[STR_CS_UserEventDuration] = 10.0; }
+
+        if (!m_profile->contains(STR_CS_UserEventDuplicates)) { (*m_profile)[STR_CS_UserEventDuplicates] = false; }
+
+        if (!m_profile->contains(STR_CS_UserEventFlagging)) { (*m_profile)[STR_CS_UserEventFlagging] = false; }
+
+        if (!m_profile->contains(STR_CS_AHIWindow)) { (*m_profile)[STR_CS_AHIWindow] = 60.0; }
+
+        if (!m_profile->contains(STR_CS_AHIReset)) { (*m_profile)[STR_CS_AHIReset] = false; }
+
+        if (!m_profile->contains(STR_CS_ClockDrift)) { (*m_profile)[STR_CS_ClockDrift] = m_clock_drift = (int)0; }
+        else { m_clock_drift = (*m_profile)[STR_CS_ClockDrift].toInt(); }
     }
 
     ~CPAPSettings() { }
 
-    void setProfile(Profile *p) { m_profile=p; }
+    void setProfile(Profile *p) { m_profile = p; }
 
     //Getters
     double complianceHours() { return (*m_profile)[STR_CS_ComplianceHours].toDouble(); }
@@ -455,25 +504,25 @@ public:
     int clockDrift() { return m_clock_drift; }
 
     //Setters
-    void setMode(CPAPMode mode) { (*m_profile)[STR_CS_PrescribedMode]=(int)mode; }
-    void setMinPressure(double pressure) { (*m_profile)[STR_CS_PrescribedMinPressure]=pressure; }
-    void setMaxPressure(double pressure) { (*m_profile)[STR_CS_PrescribedMaxPressure]=pressure; }
-    void setUntreatedAHI(double ahi) { (*m_profile)[STR_CS_UntreatedAHI]=ahi; }
-    void setNotes(QString notes) { (*m_profile)[STR_CS_Notes]=notes; }
-    void setDateDiagnosed(QDate date) { (*m_profile)[STR_CS_DateDiagnosed]=date; }
-    void setComplianceHours(double hours) { (*m_profile)[STR_CS_ComplianceHours]=hours; }
-    void setShowComplianceInfo(bool b) { (*m_profile)[STR_CS_ShowCompliance]=b; }
-    void setLeakMode(int leakmode) { (*m_profile)[STR_CS_ShowLeaksMode]=(int)leakmode; }
-    void setMaskStartDate(QDate date) { (*m_profile)[STR_CS_MaskStartDate]=date; }
-    void setMaskDescription(QString description) { (*m_profile)[STR_CS_MaskDescription]=description; }
-    void setMaskType(MaskType masktype) { (*m_profile)[STR_CS_MaskType]=(int)masktype; }
-    void setUserFlowRestriction(double flow) { (*m_profile)[STR_CS_UserFlowRestriction]=flow; }
-    void setUserEventDuration(double duration) { (*m_profile)[STR_CS_UserEventDuration]=duration; }
-    void setAHIWindow(double window) { (*m_profile)[STR_CS_AHIWindow]=window; }
-    void setAHIReset(bool reset) { (*m_profile)[STR_CS_AHIReset]=reset; }
-    void setUserEventFlagging(bool flagging) { (*m_profile)[STR_CS_UserEventFlagging]=flagging; }
-    void setUserEventDuplicates(bool dup) { (*m_profile)[STR_CS_UserEventDuplicates]=dup; }
-    void setClockDrift(int seconds) { (*m_profile)[STR_CS_ClockDrift]=m_clock_drift=(int)seconds; }
+    void setMode(CPAPMode mode) { (*m_profile)[STR_CS_PrescribedMode] = (int)mode; }
+    void setMinPressure(double pressure) { (*m_profile)[STR_CS_PrescribedMinPressure] = pressure; }
+    void setMaxPressure(double pressure) { (*m_profile)[STR_CS_PrescribedMaxPressure] = pressure; }
+    void setUntreatedAHI(double ahi) { (*m_profile)[STR_CS_UntreatedAHI] = ahi; }
+    void setNotes(QString notes) { (*m_profile)[STR_CS_Notes] = notes; }
+    void setDateDiagnosed(QDate date) { (*m_profile)[STR_CS_DateDiagnosed] = date; }
+    void setComplianceHours(double hours) { (*m_profile)[STR_CS_ComplianceHours] = hours; }
+    void setShowComplianceInfo(bool b) { (*m_profile)[STR_CS_ShowCompliance] = b; }
+    void setLeakMode(int leakmode) { (*m_profile)[STR_CS_ShowLeaksMode] = (int)leakmode; }
+    void setMaskStartDate(QDate date) { (*m_profile)[STR_CS_MaskStartDate] = date; }
+    void setMaskDescription(QString description) { (*m_profile)[STR_CS_MaskDescription] = description; }
+    void setMaskType(MaskType masktype) { (*m_profile)[STR_CS_MaskType] = (int)masktype; }
+    void setUserFlowRestriction(double flow) { (*m_profile)[STR_CS_UserFlowRestriction] = flow; }
+    void setUserEventDuration(double duration) { (*m_profile)[STR_CS_UserEventDuration] = duration; }
+    void setAHIWindow(double window) { (*m_profile)[STR_CS_AHIWindow] = window; }
+    void setAHIReset(bool reset) { (*m_profile)[STR_CS_AHIReset] = reset; }
+    void setUserEventFlagging(bool flagging) { (*m_profile)[STR_CS_UserEventFlagging] = flagging; }
+    void setUserEventDuplicates(bool dup) { (*m_profile)[STR_CS_UserEventDuplicates] = dup; }
+    void setClockDrift(int seconds) { (*m_profile)[STR_CS_ClockDrift] = m_clock_drift = (int)seconds; }
 
     Profile *m_profile;
 
@@ -485,22 +534,28 @@ public:
     */
 class SessionSettings
 {
-public:
+  public:
     //! \brief Create ImportSettings object given Profile *p, and initialize the defaults
-    SessionSettings(Profile *p) :m_profile(p)
-    {
-        if (!m_profile->contains(STR_IS_DaySplitTime)) (*m_profile)[STR_IS_DaySplitTime]=QTime(12,0,0);
-        if (!m_profile->contains(STR_IS_CacheSessions)) (*m_profile)[STR_IS_CacheSessions]=false;
-        if (!m_profile->contains(STR_IS_CombineCloseSessions)) (*m_profile)[STR_IS_CombineCloseSessions]=240;
-        if (!m_profile->contains(STR_IS_IgnoreShorterSessions)) (*m_profile)[STR_IS_IgnoreShorterSessions]=5;
-        if (!m_profile->contains(STR_IS_Multithreading)) (*m_profile)[STR_IS_Multithreading]=QThread::idealThreadCount() > 1;
-        if (!m_profile->contains(STR_IS_BackupCardData)) (*m_profile)[STR_IS_BackupCardData]=true;
-        if (!m_profile->contains(STR_IS_CompressBackupData)) (*m_profile)[STR_IS_CompressBackupData]=false;
-        if (!m_profile->contains(STR_IS_CompressSessionData)) (*m_profile)[STR_IS_CompressSessionData]=false;
+    SessionSettings(Profile *p) : m_profile(p) {
+        if (!m_profile->contains(STR_IS_DaySplitTime)) { (*m_profile)[STR_IS_DaySplitTime] = QTime(12, 0, 0); }
+
+        if (!m_profile->contains(STR_IS_CacheSessions)) { (*m_profile)[STR_IS_CacheSessions] = false; }
+
+        if (!m_profile->contains(STR_IS_CombineCloseSessions)) { (*m_profile)[STR_IS_CombineCloseSessions] = 240; }
+
+        if (!m_profile->contains(STR_IS_IgnoreShorterSessions)) { (*m_profile)[STR_IS_IgnoreShorterSessions] = 5; }
+
+        if (!m_profile->contains(STR_IS_Multithreading)) { (*m_profile)[STR_IS_Multithreading] = QThread::idealThreadCount() > 1; }
+
+        if (!m_profile->contains(STR_IS_BackupCardData)) { (*m_profile)[STR_IS_BackupCardData] = true; }
+
+        if (!m_profile->contains(STR_IS_CompressBackupData)) { (*m_profile)[STR_IS_CompressBackupData] = false; }
+
+        if (!m_profile->contains(STR_IS_CompressSessionData)) { (*m_profile)[STR_IS_CompressSessionData] = false; }
     }
     ~SessionSettings() {}
 
-    void setProfile(Profile *p) { m_profile=p; }
+    void setProfile(Profile *p) { m_profile = p; }
 
     QTime daySplitTime() { return (*m_profile)[STR_IS_DaySplitTime].toTime(); }
     bool cacheSessions() { return (*m_profile)[STR_IS_CacheSessions].toBool(); }
@@ -511,14 +566,14 @@ public:
     bool compressBackupData() { return (*m_profile)[STR_IS_CompressBackupData].toBool(); }
     bool backupCardData() { return (*m_profile)[STR_IS_BackupCardData].toBool(); }
 
-    void setDaySplitTime(QTime time) { (*m_profile)[STR_IS_DaySplitTime]=time; }
-    void setCacheSessions(bool c) { (*m_profile)[STR_IS_CacheSessions]=c; }
-    void setCombineCloseSessions(double val) { (*m_profile)[STR_IS_CombineCloseSessions]=val; }
-    void setIgnoreShortSessions(double val) { (*m_profile)[STR_IS_IgnoreShorterSessions]=val; }
-    void setMultithreading(bool enabled) { (*m_profile)[STR_IS_Multithreading]=enabled; }
-    void setBackupCardData(bool enabled) { (*m_profile)[STR_IS_BackupCardData]=enabled; }
-    void setCompressBackupData(bool enabled) { (*m_profile)[STR_IS_CompressBackupData]=enabled; }
-    void setCompressSessionData(bool enabled) { (*m_profile)[STR_IS_CompressSessionData]=enabled; }
+    void setDaySplitTime(QTime time) { (*m_profile)[STR_IS_DaySplitTime] = time; }
+    void setCacheSessions(bool c) { (*m_profile)[STR_IS_CacheSessions] = c; }
+    void setCombineCloseSessions(double val) { (*m_profile)[STR_IS_CombineCloseSessions] = val; }
+    void setIgnoreShortSessions(double val) { (*m_profile)[STR_IS_IgnoreShorterSessions] = val; }
+    void setMultithreading(bool enabled) { (*m_profile)[STR_IS_Multithreading] = enabled; }
+    void setBackupCardData(bool enabled) { (*m_profile)[STR_IS_BackupCardData] = enabled; }
+    void setCompressBackupData(bool enabled) { (*m_profile)[STR_IS_CompressBackupData] = enabled; }
+    void setCompressSessionData(bool enabled) { (*m_profile)[STR_IS_CompressSessionData] = enabled; }
 
     Profile *m_profile;
 };
@@ -528,24 +583,32 @@ public:
     */
 class AppearanceSettings
 {
-public:
+  public:
     //! \brief Create AppearanceSettings object given Profile *p, and initialize the defaults
-    AppearanceSettings(Profile *p) :m_profile(p)
-    {
-        if (!m_profile->contains(STR_AS_GraphHeight)) (*m_profile)[STR_AS_GraphHeight]=180.0;
-        if (!m_profile->contains(STR_AS_AntiAliasing)) (*m_profile)[STR_AS_AntiAliasing]=false; // i think it's ugly
-        if (!m_profile->contains(STR_AS_GraphSnapshots)) (*m_profile)[STR_AS_GraphSnapshots]=true;
-        if (!m_profile->contains(STR_AS_Animations)) (*m_profile)[STR_AS_Animations]=true;
-        if (!m_profile->contains(STR_AS_SquareWave)) (*m_profile)[STR_AS_SquareWave]=false;
-        if (!m_profile->contains(STR_AS_AllowYAxisScaling)) (*m_profile)[STR_AS_AllowYAxisScaling]=true;
-        if (!m_profile->contains(STR_AS_GraphTooltips)) (*m_profile)[STR_AS_GraphTooltips]=true;
-        if (!m_profile->contains(STR_AS_UsePixmapCaching)) (*m_profile)[STR_AS_UsePixmapCaching]=true;
-        if (!m_profile->contains(STR_AS_OverlayType)) (*m_profile)[STR_AS_OverlayType]=ODT_Bars;
-        if (!m_profile->contains(STR_AS_OverviewLinechartMode)) (*m_profile)[STR_AS_OverviewLinechartMode]=OLC_Bartop;
+    AppearanceSettings(Profile *p) : m_profile(p) {
+        if (!m_profile->contains(STR_AS_GraphHeight)) { (*m_profile)[STR_AS_GraphHeight] = 180.0; }
+
+        if (!m_profile->contains(STR_AS_AntiAliasing)) { (*m_profile)[STR_AS_AntiAliasing] = false; } // i think it's ugly
+
+        if (!m_profile->contains(STR_AS_GraphSnapshots)) { (*m_profile)[STR_AS_GraphSnapshots] = true; }
+
+        if (!m_profile->contains(STR_AS_Animations)) { (*m_profile)[STR_AS_Animations] = true; }
+
+        if (!m_profile->contains(STR_AS_SquareWave)) { (*m_profile)[STR_AS_SquareWave] = false; }
+
+        if (!m_profile->contains(STR_AS_AllowYAxisScaling)) { (*m_profile)[STR_AS_AllowYAxisScaling] = true; }
+
+        if (!m_profile->contains(STR_AS_GraphTooltips)) { (*m_profile)[STR_AS_GraphTooltips] = true; }
+
+        if (!m_profile->contains(STR_AS_UsePixmapCaching)) { (*m_profile)[STR_AS_UsePixmapCaching] = true; }
+
+        if (!m_profile->contains(STR_AS_OverlayType)) { (*m_profile)[STR_AS_OverlayType] = ODT_Bars; }
+
+        if (!m_profile->contains(STR_AS_OverviewLinechartMode)) { (*m_profile)[STR_AS_OverviewLinechartMode] = OLC_Bartop; }
     }
     ~AppearanceSettings() {}
 
-    void setProfile(Profile *p) { m_profile=p; }
+    void setProfile(Profile *p) { m_profile = p; }
 
     //! \brief Returns the normal (unscaled) height of a graph
     int graphHeight() { return (*m_profile)[STR_AS_GraphHeight].toInt(); }
@@ -564,31 +627,31 @@ public:
     //! \brief Whether to show graph tooltips
     bool graphTooltips() { return (*m_profile)[STR_AS_GraphTooltips].toBool(); }
     //! \brief Returns the type of overlay flags (which are displayed over the Flow Waveform)
-    OverlayDisplayType overlayType() { return (OverlayDisplayType )(*m_profile)[STR_AS_OverlayType].toInt(); }
+    OverlayDisplayType overlayType() { return (OverlayDisplayType)(*m_profile)[STR_AS_OverlayType].toInt(); }
     //! \brief Returns the display type of Overview pages linechart
-    OverviewLinechartModes overviewLinechartMode() { return (OverviewLinechartModes )(*m_profile)[STR_AS_OverviewLinechartMode].toInt(); }
+    OverviewLinechartModes overviewLinechartMode() { return (OverviewLinechartModes)(*m_profile)[STR_AS_OverviewLinechartMode].toInt(); }
 
 
     //! \brief Set the normal (unscaled) height of a graph.
-    void setGraphHeight(int height) { (*m_profile)[STR_AS_GraphHeight]=height; }
+    void setGraphHeight(int height) { (*m_profile)[STR_AS_GraphHeight] = height; }
     //! \brief Set to true to turn on AntiAliasing (the graphical smoothing method)
-    void setAntiAliasing(bool aa) { (*m_profile)[STR_AS_AntiAliasing]=aa; }
+    void setAntiAliasing(bool aa) { (*m_profile)[STR_AS_AntiAliasing] = aa; }
     //! \brief Set to true if renderPixmap functions are in use, which takes snapshots of graphs.
-    void setGraphSnapshots(bool gs) { (*m_profile)[STR_AS_GraphSnapshots]=gs; }
+    void setGraphSnapshots(bool gs) { (*m_profile)[STR_AS_GraphSnapshots] = gs; }
     //! \brief Set to true if Graphical animations & Transitions will be drawn
-    void setAnimations(bool anim) { (*m_profile)[STR_AS_Animations]=anim; }
+    void setAnimations(bool anim) { (*m_profile)[STR_AS_Animations] = anim; }
     //! \brief Set to true to use Pixmap Caching of Text and other graphics caching speedup techniques
-    void setUsePixmapCaching(bool b) { (*m_profile)[STR_AS_UsePixmapCaching]=b; }
+    void setUsePixmapCaching(bool b) { (*m_profile)[STR_AS_UsePixmapCaching] = b; }
     //! \brief Set whether or not to useSquare Wave plots (where possible)
-    void setSquareWavePlots(bool sw) { (*m_profile)[STR_AS_SquareWave]=sw; }
+    void setSquareWavePlots(bool sw) { (*m_profile)[STR_AS_SquareWave] = sw; }
     //! \brief Sets the type of overlay flags (which are displayed over the Flow Waveform)
-    void setOverlayType(OverlayDisplayType od) { (*m_profile)[STR_AS_OverlayType]=(int)od; }
+    void setOverlayType(OverlayDisplayType od) { (*m_profile)[STR_AS_OverlayType] = (int)od; }
     //! \brief Sets the type of overlay flags (which are displayed over the Flow Waveform)
-    void setOverviewLinechartMode(OverviewLinechartModes od) { (*m_profile)[STR_AS_OverviewLinechartMode]=(int)od; }
+    void setOverviewLinechartMode(OverviewLinechartModes od) { (*m_profile)[STR_AS_OverviewLinechartMode] = (int)od; }
     //! \brief Sets whether to allow double clicking on Y-Axis labels to change vertical scaling mode
-    void setAllowYAxisScaling(bool b) {  (*m_profile)[STR_AS_AllowYAxisScaling]=b; }
+    void setAllowYAxisScaling(bool b) {  (*m_profile)[STR_AS_AllowYAxisScaling] = b; }
     //! \brief Sets whether to allow double clicking on Y-Axis labels to change vertical scaling mode
-    void setGraphTooltips(bool b) {  (*m_profile)[STR_AS_GraphTooltips]=b; }
+    void setGraphTooltips(bool b) {  (*m_profile)[STR_AS_GraphTooltips] = b; }
 
     Profile *m_profile;
 };
@@ -598,27 +661,38 @@ public:
     */
 class UserSettings
 {
-public:
+  public:
     //! \brief Create UserSettings object given Profile *p, and initialize the defaults
-    UserSettings(Profile *p) :m_profile(p)
-    {
-        if (!m_profile->contains(STR_US_UnitSystem)) (*m_profile)[STR_US_UnitSystem]=US_Metric;
-        if (!m_profile->contains(STR_US_EventWindowSize)) (*m_profile)[STR_US_EventWindowSize]=4.0;
-        if (!m_profile->contains(STR_US_SkipEmptyDays)) (*m_profile)[STR_US_SkipEmptyDays]=true;
-        if (!m_profile->contains(STR_US_RebuildCache)) (*m_profile)[STR_US_RebuildCache]=false; // can't remember..
-        if (!m_profile->contains(STR_US_ShowDebug)) (*m_profile)[STR_US_ShowDebug]=false;
-        if (!m_profile->contains(STR_US_LinkGroups)) (*m_profile)[STR_US_LinkGroups]=true; // can't remember..
-        if (!m_profile->contains(STR_US_CalculateRDI)) (*m_profile)[STR_US_CalculateRDI]=false;
-        if (!m_profile->contains(STR_US_ShowSerialNumbers)) (*m_profile)[STR_US_ShowSerialNumbers]=false;
-        if (!m_profile->contains(STR_US_PrefCalcMiddle)) (*m_profile)[STR_US_PrefCalcMiddle]=(int)0;
-        if (!m_profile->contains(STR_US_PrefCalcPercentile)) (*m_profile)[STR_US_PrefCalcPercentile]=(double)95.0;
-        if (!m_profile->contains(STR_US_PrefCalcMax)) (*m_profile)[STR_US_PrefCalcMax]=(int)0;
-        if (!m_profile->contains(STR_US_TooltipTimeout)) (*m_profile)[STR_US_TooltipTimeout]=(int)2500;
-        if (!m_profile->contains(STR_US_ScrollDampening)) (*m_profile)[STR_US_ScrollDampening]=(int)50;
+    UserSettings(Profile *p) : m_profile(p) {
+        if (!m_profile->contains(STR_US_UnitSystem)) { (*m_profile)[STR_US_UnitSystem] = US_Metric; }
+
+        if (!m_profile->contains(STR_US_EventWindowSize)) { (*m_profile)[STR_US_EventWindowSize] = 4.0; }
+
+        if (!m_profile->contains(STR_US_SkipEmptyDays)) { (*m_profile)[STR_US_SkipEmptyDays] = true; }
+
+        if (!m_profile->contains(STR_US_RebuildCache)) { (*m_profile)[STR_US_RebuildCache] = false; } // can't remember..
+
+        if (!m_profile->contains(STR_US_ShowDebug)) { (*m_profile)[STR_US_ShowDebug] = false; }
+
+        if (!m_profile->contains(STR_US_LinkGroups)) { (*m_profile)[STR_US_LinkGroups] = true; } // can't remember..
+
+        if (!m_profile->contains(STR_US_CalculateRDI)) { (*m_profile)[STR_US_CalculateRDI] = false; }
+
+        if (!m_profile->contains(STR_US_ShowSerialNumbers)) { (*m_profile)[STR_US_ShowSerialNumbers] = false; }
+
+        if (!m_profile->contains(STR_US_PrefCalcMiddle)) { (*m_profile)[STR_US_PrefCalcMiddle] = (int)0; }
+
+        if (!m_profile->contains(STR_US_PrefCalcPercentile)) { (*m_profile)[STR_US_PrefCalcPercentile] = (double)95.0; }
+
+        if (!m_profile->contains(STR_US_PrefCalcMax)) { (*m_profile)[STR_US_PrefCalcMax] = (int)0; }
+
+        if (!m_profile->contains(STR_US_TooltipTimeout)) { (*m_profile)[STR_US_TooltipTimeout] = (int)2500; }
+
+        if (!m_profile->contains(STR_US_ScrollDampening)) { (*m_profile)[STR_US_ScrollDampening] = (int)50; }
     }
     ~UserSettings() {}
 
-    void setProfile(Profile *p) { m_profile=p; }
+    void setProfile(Profile *p) { m_profile = p; }
 
     UnitSystem unitSystem() { return (UnitSystem)(*m_profile)[STR_US_UnitSystem].toInt(); }
     double eventWindowSize() { return (*m_profile)[STR_US_EventWindowSize].toDouble(); }
@@ -635,28 +709,27 @@ public:
     int scrollDampening() { return (*m_profile)[STR_US_ScrollDampening].toInt(); }
 
 
-    void setUnitSystem(UnitSystem us) { (*m_profile)[STR_US_UnitSystem]=(int)us; }
-    void setEventWindowSize(double size) { (*m_profile)[STR_US_EventWindowSize]=size; }
-    void setSkipEmptyDays(bool skip) { (*m_profile)[STR_US_SkipEmptyDays]=skip; }
-    void setRebuildCache(bool rebuild) { (*m_profile)[STR_US_RebuildCache]=rebuild; }
-    void setShowDebug(bool b) { (*m_profile)[STR_US_ShowDebug]=b; }
-    void setLinkGroups(bool link) { (*m_profile)[STR_US_LinkGroups]=link; }
-    void setCalculateRDI(bool rdi) { (*m_profile)[STR_US_CalculateRDI]=rdi; }
-    void setShowSerialNumbers(bool enabled) { (*m_profile)[STR_US_ShowSerialNumbers]=enabled; }
-    void setPrefCalcMiddle(int i) { (*m_profile)[STR_US_PrefCalcMiddle]=i; }
-    void setPrefCalcPercentile(double p) { (*m_profile)[STR_US_PrefCalcPercentile]=p; }
-    void setPrefCalcMax(int i) { (*m_profile)[STR_US_PrefCalcMax]=i; }
-    void setTooltipTimeout(int i) { (*m_profile)[STR_US_TooltipTimeout]=i; }
-    void setScrollDampening(int i) { (*m_profile)[STR_US_ScrollDampening]=i; }
+    void setUnitSystem(UnitSystem us) { (*m_profile)[STR_US_UnitSystem] = (int)us; }
+    void setEventWindowSize(double size) { (*m_profile)[STR_US_EventWindowSize] = size; }
+    void setSkipEmptyDays(bool skip) { (*m_profile)[STR_US_SkipEmptyDays] = skip; }
+    void setRebuildCache(bool rebuild) { (*m_profile)[STR_US_RebuildCache] = rebuild; }
+    void setShowDebug(bool b) { (*m_profile)[STR_US_ShowDebug] = b; }
+    void setLinkGroups(bool link) { (*m_profile)[STR_US_LinkGroups] = link; }
+    void setCalculateRDI(bool rdi) { (*m_profile)[STR_US_CalculateRDI] = rdi; }
+    void setShowSerialNumbers(bool enabled) { (*m_profile)[STR_US_ShowSerialNumbers] = enabled; }
+    void setPrefCalcMiddle(int i) { (*m_profile)[STR_US_PrefCalcMiddle] = i; }
+    void setPrefCalcPercentile(double p) { (*m_profile)[STR_US_PrefCalcPercentile] = p; }
+    void setPrefCalcMax(int i) { (*m_profile)[STR_US_PrefCalcMax] = i; }
+    void setTooltipTimeout(int i) { (*m_profile)[STR_US_TooltipTimeout] = i; }
+    void setScrollDampening(int i) { (*m_profile)[STR_US_ScrollDampening] = i; }
 
     Profile *m_profile;
 };
 
 
-namespace Profiles
-{
+namespace Profiles {
 
-extern QMap<QString,Profile *> profiles;
+extern QMap<QString, Profile *> profiles;
 void Scan(); // Initialize and load Profile
 void Done(); // Save all Profile objects and clear list
 
diff --git a/sleepyhead/SleepLib/schema.cpp b/sleepyhead/SleepLib/schema.cpp
index a3efe8cd..8e1f8ff2 100644
--- a/sleepyhead/SleepLib/schema.cpp
+++ b/sleepyhead/SleepLib/schema.cpp
@@ -29,288 +29,444 @@ ChannelList channel;
 Channel EmptyChannel;
 Channel *SessionEnabledChannel;
 
-QHash<QString,ChanType> ChanTypes;
-QHash<QString,DataType> DataTypes;
-QHash<QString,ScopeType> Scopes;
+QHash<QString, ChanType> ChanTypes;
+QHash<QString, DataType> DataTypes;
+QHash<QString, ScopeType> Scopes;
 
-bool schema_initialized=false;
+bool schema_initialized = false;
 
 void init()
 {
-    if (schema_initialized) return;
-    schema_initialized=true;
+    if (schema_initialized) { return; }
 
-    EmptyChannel=Channel(0,DATA,DAY,"Empty","Empty", "Empty Channel","","");
-    SessionEnabledChannel=new Channel(1,DATA,DAY,"Enabled","Enabled","Session Enabled","","");
+    schema_initialized = true;
 
-    channel.channels[1]=SessionEnabledChannel;
-    channel.names["Enabled"]=SessionEnabledChannel;
-    SESSION_ENABLED=1;
-    ChanTypes["data"]=DATA;
+    EmptyChannel = Channel(0, DATA, DAY, "Empty", "Empty", "Empty Channel", "", "");
+    SessionEnabledChannel = new Channel(1, DATA, DAY, "Enabled", "Enabled", "Session Enabled", "", "");
+
+    channel.channels[1] = SessionEnabledChannel;
+    channel.names["Enabled"] = SessionEnabledChannel;
+    SESSION_ENABLED = 1;
+    ChanTypes["data"] = DATA;
     //Types["waveform"]=WAVEFORM;
-    ChanTypes["setting"]=SETTING;
+    ChanTypes["setting"] = SETTING;
 
-    Scopes["session"]=SESSION;
-    Scopes["day"]=DAY;
-    Scopes["machine"]=MACHINE;
-    Scopes["global"]=GLOBAL;
+    Scopes["session"] = SESSION;
+    Scopes["day"] = DAY;
+    Scopes["machine"] = MACHINE;
+    Scopes["global"] = GLOBAL;
 
-    DataTypes[""]=DEFAULT;
-    DataTypes["bool"]=BOOL;
-    DataTypes["double"]=DOUBLE;
-    DataTypes["integer"]=INTEGER;
-    DataTypes["string"]=STRING;
-    DataTypes["richtext"]=RICHTEXT;
-    DataTypes["date"]=DATE;
-    DataTypes["datetime"]=DATETIME;
-    DataTypes["time"]=TIME;
+    DataTypes[""] = DEFAULT;
+    DataTypes["bool"] = BOOL;
+    DataTypes["double"] = DOUBLE;
+    DataTypes["integer"] = INTEGER;
+    DataTypes["string"] = STRING;
+    DataTypes["richtext"] = RICHTEXT;
+    DataTypes["date"] = DATE;
+    DataTypes["datetime"] = DATETIME;
+    DataTypes["time"] = TIME;
 
     if (!schema::channel.Load(":/docs/channels.xml")) {
-        QMessageBox::critical(0,QObject::tr("Error"),QObject::tr("Couldn't parse Channels.xml, this build is seriously borked, no choice but to abort!!"),QMessageBox::Ok);
+        QMessageBox::critical(0, QObject::tr("Error"),
+                              QObject::tr("Couldn't parse Channels.xml, this build is seriously borked, no choice but to abort!!"),
+                              QMessageBox::Ok);
         QApplication::exit(-1);
     }
 
-//    <channel id="0x110c" class="data" name="Pressure" details="Pressure" label="Pressure" unit="cmH20" color="dark green"/>
-//    <channel id="0x110d" class="data" name="IPAP" details="Inspiratory Pressure" label="IPAP" unit="cmH20" color="orange"/>
-//    <channel id="0x110e" class="data" name="EPAP" details="Expiratory Pressure" label="EPAP" unit="cmH20" color="light blue"/>
-//    <channel id="0x110f" class="data" name="PS" details="Pressure Support" label="PS" unit="cmH20" color="dark blue"/>
-//    <channel id="0x1110" class="data" name="IPAPLo" details="Inspiratory Pressure Lo" label="IPAP Lo" unit="cmH20" color="grey"/>
-//    <channel id="0x1111" class="data" name="IPAPHi" details="Inspiratory Pressure Hi" label="IPAP Hi" unit="cmH20" color="grey"/>
-//    <channel id="0x111a" class="setting" name="PSMin" details="Pressure Support Min" label="PS Min" unit="cmH20" color="dark cyan"/>
-//    <channel id="0x111b" class="setting" name="PSMax" details="Pressure Support Max" label="PS Max" unit="cmH20" color="dark magenta"/>
-//    <channel id="0x1020" class="data" name="PressureMin" details="Min Therapy Pressure" label="Pressure" color="black"/>
-//    <channel id="0x1021" class="data" name="PressureMax" details="Max Therapy Pressure" label="Pressure" color="black"/>
-//    <channel id="0x1022" class="data" name="RampTime" details="Ramp Time" label="Ramp Time" color="black"/>
-//    <channel id="0x1023" class="data" name="RampPressure" details="Ramp Starting Pressure" label="Ramp Pr." color="black"/>
+    //    <channel id="0x110c" class="data" name="Pressure" details="Pressure" label="Pressure" unit="cmH20" color="dark green"/>
+    //    <channel id="0x110d" class="data" name="IPAP" details="Inspiratory Pressure" label="IPAP" unit="cmH20" color="orange"/>
+    //    <channel id="0x110e" class="data" name="EPAP" details="Expiratory Pressure" label="EPAP" unit="cmH20" color="light blue"/>
+    //    <channel id="0x110f" class="data" name="PS" details="Pressure Support" label="PS" unit="cmH20" color="dark blue"/>
+    //    <channel id="0x1110" class="data" name="IPAPLo" details="Inspiratory Pressure Lo" label="IPAP Lo" unit="cmH20" color="grey"/>
+    //    <channel id="0x1111" class="data" name="IPAPHi" details="Inspiratory Pressure Hi" label="IPAP Hi" unit="cmH20" color="grey"/>
+    //    <channel id="0x111a" class="setting" name="PSMin" details="Pressure Support Min" label="PS Min" unit="cmH20" color="dark cyan"/>
+    //    <channel id="0x111b" class="setting" name="PSMax" details="Pressure Support Max" label="PS Max" unit="cmH20" color="dark magenta"/>
+    //    <channel id="0x1020" class="data" name="PressureMin" details="Min Therapy Pressure" label="Pressure" color="black"/>
+    //    <channel id="0x1021" class="data" name="PressureMax" details="Max Therapy Pressure" label="Pressure" color="black"/>
+    //    <channel id="0x1022" class="data" name="RampTime" details="Ramp Time" label="Ramp Time" color="black"/>
+    //    <channel id="0x1023" class="data" name="RampPressure" details="Ramp Starting Pressure" label="Ramp Pr." color="black"/>
 
-    QString GRP_CPAP="CPAP";
-    QString GRP_POS="POS";
-    QString GRP_OXI="OXI";
+    QString GRP_CPAP = "CPAP";
+    QString GRP_POS = "POS";
+    QString GRP_OXI = "OXI";
     // Pressure Related Settings
 
     // Lookup Code strings are used internally and not meant to be tranlsated
 
     //                  Group                ChannelID            Code    Type     Scope    Lookup Code      Translable Name                 Description                                   Shortened Name              Units String            FieldType   Default Color
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_Pressure      = 0x110C, DATA,    SESSION, "Pressure",      STR_TR_Pressure,                QObject::tr("Therapy Pressure"),              STR_TR_Pressure,            STR_UNIT_CMH2O,         DEFAULT,    QColor("dark green")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_IPAP          = 0x110D, DATA,    SESSION, "IPAP",          STR_TR_IPAP,                    QObject::tr("Inspiratory Pressure"),          STR_TR_IPAP,                STR_UNIT_CMH2O,         DEFAULT,    QColor("orange")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_IPAPLo        = 0x1110, DATA,    SESSION, "IPAPLo",        STR_TR_IPAPLo,                  QObject::tr("Lower Inspiratory Pressure"),    STR_TR_IPAPLo,              STR_UNIT_CMH2O,         DEFAULT,    QColor("orange")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_IPAPHi        = 0x1111, DATA,    SESSION, "IPAPHi",        STR_TR_IPAPHi,                  QObject::tr("Higher Inspiratory Pressure"),   STR_TR_IPAPHi,              STR_UNIT_CMH2O,         DEFAULT,    QColor("orange")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_EPAP          = 0x110E, DATA,    SESSION, "EPAP",          STR_TR_EPAP,                    QObject::tr("Expiratory Pressure"),           STR_TR_EPAP,                STR_UNIT_CMH2O,         DEFAULT,    QColor("light blue")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_EPAPLo        = 0x111C, DATA,    SESSION, "EPAPLo",        STR_TR_EPAPLo,                  QObject::tr("Lower Expiratory Pressure"),     STR_TR_EPAPLo,              STR_UNIT_CMH2O,         DEFAULT,    QColor("light blue")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_EPAPHi        = 0x111D, DATA,    SESSION, "EPAPHi",        STR_TR_EPAPHi,                  QObject::tr("Higher Expiratory Pressure"),    STR_TR_EPAPHi,              STR_UNIT_CMH2O,         DEFAULT,    QColor("aqua")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_PS            = 0x110F, DATA,    SESSION, "PS",            STR_TR_PS,                      QObject::tr("Pressure Support"),              STR_TR_PS,                  STR_UNIT_CMH2O,         DEFAULT,    QColor("grey")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_PSMin         = 0x111A, SETTING, SESSION, "PSMin",         QObject::tr("PS Min") ,         QObject::tr("Pressure Support Minimum"),      QObject::tr("PS Min"),      STR_UNIT_CMH2O,         DEFAULT,    QColor("dark cyan")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_PSMax         = 0x111B, SETTING, SESSION, "PSMax",         QObject::tr("PS Max"),          QObject::tr("Pressure Support Maximum"),      QObject::tr("PS Max"),      STR_UNIT_CMH2O,         DEFAULT,    QColor("dark magenta")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_PressureMin   = 0x1020, SETTING, SESSION, "PressureMin",   QObject::tr("Min Pressure") ,   QObject::tr("Minimum Therapy Pressure"),      QObject::tr("Pr. Min"),     STR_UNIT_CMH2O,         DEFAULT,    QColor("black")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_PressureMax   = 0x1021, SETTING, SESSION, "PressureMax",   QObject::tr("Max Pressure"),    QObject::tr("Maximum Therapy Pressure"),      QObject::tr("Pr. Max"),     STR_UNIT_CMH2O,         DEFAULT,    QColor("black")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_RampTime      = 0x1022, SETTING, SESSION, "RampTime",      QObject::tr("Ramp Time") ,      QObject::tr("Ramp Delay Period"),             QObject::tr("Ramp Time"),   QObject::tr("minutes"), DEFAULT,    QColor("black")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_RampPressure  = 0x1023, SETTING, SESSION, "RampPressure",  QObject::tr("Ramp Pressure"),   QObject::tr("Starting Ramp Pressure"),        QObject::tr("Ramp Pr."),    STR_UNIT_CMH2O,         DEFAULT,    QColor("black")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_Pressure      = 0x110C, DATA,    SESSION,
+                        "Pressure",      STR_TR_Pressure,                QObject::tr("Therapy Pressure"),
+                        STR_TR_Pressure,            STR_UNIT_CMH2O,         DEFAULT,    QColor("dark green")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_IPAP          = 0x110D, DATA,    SESSION, "IPAP",
+                        STR_TR_IPAP,                    QObject::tr("Inspiratory Pressure"),          STR_TR_IPAP,
+                        STR_UNIT_CMH2O,         DEFAULT,    QColor("orange")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_IPAPLo        = 0x1110, DATA,    SESSION, "IPAPLo",
+                        STR_TR_IPAPLo,                  QObject::tr("Lower Inspiratory Pressure"),    STR_TR_IPAPLo,
+                        STR_UNIT_CMH2O,         DEFAULT,    QColor("orange")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_IPAPHi        = 0x1111, DATA,    SESSION, "IPAPHi",
+                        STR_TR_IPAPHi,                  QObject::tr("Higher Inspiratory Pressure"),   STR_TR_IPAPHi,
+                        STR_UNIT_CMH2O,         DEFAULT,    QColor("orange")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_EPAP          = 0x110E, DATA,    SESSION, "EPAP",
+                        STR_TR_EPAP,                    QObject::tr("Expiratory Pressure"),           STR_TR_EPAP,
+                        STR_UNIT_CMH2O,         DEFAULT,    QColor("light blue")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_EPAPLo        = 0x111C, DATA,    SESSION, "EPAPLo",
+                        STR_TR_EPAPLo,                  QObject::tr("Lower Expiratory Pressure"),     STR_TR_EPAPLo,
+                        STR_UNIT_CMH2O,         DEFAULT,    QColor("light blue")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_EPAPHi        = 0x111D, DATA,    SESSION, "EPAPHi",
+                        STR_TR_EPAPHi,                  QObject::tr("Higher Expiratory Pressure"),    STR_TR_EPAPHi,
+                        STR_UNIT_CMH2O,         DEFAULT,    QColor("aqua")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_PS            = 0x110F, DATA,    SESSION, "PS",
+                        STR_TR_PS,                      QObject::tr("Pressure Support"),              STR_TR_PS,
+                        STR_UNIT_CMH2O,         DEFAULT,    QColor("grey")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_PSMin         = 0x111A, SETTING, SESSION, "PSMin",
+                        QObject::tr("PS Min") ,         QObject::tr("Pressure Support Minimum"),
+                        QObject::tr("PS Min"),      STR_UNIT_CMH2O,         DEFAULT,    QColor("dark cyan")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_PSMax         = 0x111B, SETTING, SESSION, "PSMax",
+                        QObject::tr("PS Max"),          QObject::tr("Pressure Support Maximum"),
+                        QObject::tr("PS Max"),      STR_UNIT_CMH2O,         DEFAULT,    QColor("dark magenta")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_PressureMin   = 0x1020, SETTING, SESSION,
+                        "PressureMin",   QObject::tr("Min Pressure") ,   QObject::tr("Minimum Therapy Pressure"),
+                        QObject::tr("Pr. Min"),     STR_UNIT_CMH2O,         DEFAULT,    QColor("black")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_PressureMax   = 0x1021, SETTING, SESSION,
+                        "PressureMax",   QObject::tr("Max Pressure"),    QObject::tr("Maximum Therapy Pressure"),
+                        QObject::tr("Pr. Max"),     STR_UNIT_CMH2O,         DEFAULT,    QColor("black")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_RampTime      = 0x1022, SETTING, SESSION,
+                        "RampTime",      QObject::tr("Ramp Time") ,      QObject::tr("Ramp Delay Period"),
+                        QObject::tr("Ramp Time"),   QObject::tr("minutes"), DEFAULT,    QColor("black")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_RampPressure  = 0x1023, SETTING, SESSION,
+                        "RampPressure",  QObject::tr("Ramp Pressure"),   QObject::tr("Starting Ramp Pressure"),
+                        QObject::tr("Ramp Pr."),    STR_UNIT_CMH2O,         DEFAULT,    QColor("black")));
 
-//      <channel id="0x1000" class="data" name="CSR" details="Periodic Breathing" label="PB" unit="% of night" color="light green"/>
-//      <channel id="0x1001" class="data" name="ClearAirway" details="Clear Airway Apnea" label="CA" unit="events/hour" color="purple"/>
-//      <channel id="0x1002" class="data" name="Obstructive" details="Obstructive Apnea" label="OA" unit="events/hour" color="#40c0ff"/>
-//      <channel id="0x1003" class="data" name="Hypopnea" details="Hypopnea" label="H" unit="events/hour" color="blue"/>
-//      <channel id="0x1004" class="data" name="Apnea" details="Unspecified Apnea" label="UA" unit="events/hour" color="dark green"/>
-//      <channel id="0x1005" class="data" name="FlowLimit" details="Flow Limitation" label="FL" unit="events/hour" color="#404040"/>
-//      <channel id="0x1006" class="data" name="RERA" details="Resp. Effort Related Arousal" unit="events/hour" label="RERA" color="gold"/>
-//      <channel id="0x1007" class="data" name="VSnore" details="Vibratory Snore" label="VS" unit="events/hour" color="red"/>
-//      <channel id="0x1008" class="data" name="VSnore2" details="Vibratory Snore #2" label="VS2" unit="events/hour" color="orange"/>
-//      <channel id="0x1009" class="data" name="PressurePulse" details="Pressure Pulse" label="PP" unit="events/hour" color="dark red"/>
-//      <channel id="0x100a" class="data" name="LeakFlag" details="Leak Event" label="L" unit="events/hour" color="dark blue"/>
-//      <channel id="0x100b" class="data" name="NRI" details="Non-Responding Event" label="NRI" unit="events/hour" color="orange"/>
-//      <channel id="0x100c" class="data" name="ExP" details="Exhale Puff" label="EP" unit="events/hour" color="dark magenta"/>
-//      <channel id="0x101e" class="data" name="UserFlag1" details="User Flag #1" label="UF1" unit="events/hour" color="dark cyan"/>
-//      <channel id="0x101f" class="data" name="UserFlag2" details="User Flag #2" label="UF2" unit="events/hour" color="dark blue"/>
-//      <channel id="0x1024" class="data" name="UserFlag3" details="User Flag #3" label="UF3" unit="events/hour" color="dark grey"/>
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_CSR           = 0x1000, DATA,    SESSION, "CSR",            QObject::tr("Periodic Breathing"),                    QObject::tr("A period of periodic breathing"),                                                          QObject::tr("PB"),       QObject::tr("%"),            DEFAULT,    QColor("light green")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_ClearAirway   = 0x1001, DATA,    SESSION, "ClearAirway",    QObject::tr("Clear Airway Apnea"),                    QObject::tr("An apnea where the airway is open"),                                                       QObject::tr("CA"),       QObject::tr("events/hr"),    DEFAULT,    QColor("purple")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_Obstructive   = 0x1002, DATA,    SESSION, "Obstructive",    QObject::tr("Obstructive Apnea"),                     QObject::tr("An apnea caused by airway obstruction"),                                                   QObject::tr("OA"),       QObject::tr("events/hr"),    DEFAULT,    QColor("#40c0ff")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_Hypopnea      = 0x1003, DATA,    SESSION, "Hypopnea",       QObject::tr("Hypopnea"),                              QObject::tr("A partially obstructed airway"),                                                           QObject::tr("H"),        QObject::tr("events/hr"),    DEFAULT,    QColor("blue")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_Apnea         = 0x1004, DATA,    SESSION, "Apnea",          QObject::tr("Unclassified Apnea"),                    QObject::tr("An apnea that could not fit into a category"),                                             QObject::tr("UA"),       QObject::tr("events/hr"),    DEFAULT,    QColor("dark green")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_FlowLimit     = 0x1005, DATA,    SESSION, "FlowLimit",      QObject::tr("Flow Limitation"),                       QObject::tr("An restriction in breathing from normal, causing a flattening of the flow waveform."),     QObject::tr("FL"),       QObject::tr("events/hr"),    DEFAULT,    QColor("#404040")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_RERA          = 0x1006, DATA,    SESSION, "RERA",           QObject::tr("Respiratory Effort Related Arousal"),    QObject::tr("An restriction in breathing that causes an either an awakening or sleep disturbance."),    QObject::tr("RE"),       QObject::tr("events/hr"),    DEFAULT,    QColor("gold")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_VSnore        = 0x1007, DATA,    SESSION, "VSnore",         QObject::tr("Vibratory Snore"),                       QObject::tr("A vibratory snore"),                                                                       QObject::tr("VS"),       QObject::tr("events/hr"),    DEFAULT,    QColor("red")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_VSnore2       = 0x1008, DATA,    SESSION, "VSnore2",        QObject::tr("Vibratory Snore"),                       QObject::tr("A vibratory snore as detcted by a System One machine"),                                    QObject::tr("VS2"),      QObject::tr("events/hr"),    DEFAULT,    QColor("red")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_PressurePulse = 0x1009, DATA,    SESSION, "PressurePulse",  QObject::tr("Pressure Pulse"),                        QObject::tr("A pulse of pressure 'pinged' to detect a closed airway."),                                 QObject::tr("PP"),       QObject::tr("events/hr"),    DEFAULT,    QColor("dark red")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_LeakFlag      = 0x100a, DATA,    SESSION, "LeakFlag",       QObject::tr("Large Leak"),                            QObject::tr("A large mask leak affecting machine performance."),                                        QObject::tr("LL"),       QObject::tr("events/hr"),    DEFAULT,    QColor("dark blue")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_NRI           = 0x100b, DATA,    SESSION, "NRI",            QObject::tr("Non Responding Event"),                  QObject::tr("A type of respiratory event that won't respond to a pressure increase."),                  QObject::tr("NR"),       QObject::tr("events/hr"),    DEFAULT,    QColor("orange")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_ExP           = 0x100c, DATA,    SESSION, "ExP",            QObject::tr("Expiratory Puff"),                       QObject::tr("Intellipap event where you breathe out your mouth."),                                      QObject::tr("EP"),       QObject::tr("events/hr"),    DEFAULT,    QColor("dark magenta")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_UserFlag1     = 0x101e, DATA,    SESSION, "UserFlag1",      QObject::tr("User Flag #1"),                          QObject::tr("A user definable event detected by SleepyHead's flow waveform processor."),                QObject::tr("UF1"),      QObject::tr("events/hr"),    DEFAULT,    QColor("dark cyan")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_UserFlag2     = 0x101f, DATA,    SESSION, "UserFlag2",      QObject::tr("User Flag #2"),                          QObject::tr("A user definable event detected by SleepyHead's flow waveform processor."),                QObject::tr("UF2"),      QObject::tr("events/hr"),    DEFAULT,    QColor("dark blue")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_UserFlag3     = 0x1024, DATA,    SESSION, "UserFlag3",      QObject::tr("User Flag #3"),                          QObject::tr("A user definable event detected by SleepyHead's flow waveform processor."),                QObject::tr("UF3"),      QObject::tr("events/hr"),    DEFAULT,    QColor("dark grey")));
+    //      <channel id="0x1000" class="data" name="CSR" details="Periodic Breathing" label="PB" unit="% of night" color="light green"/>
+    //      <channel id="0x1001" class="data" name="ClearAirway" details="Clear Airway Apnea" label="CA" unit="events/hour" color="purple"/>
+    //      <channel id="0x1002" class="data" name="Obstructive" details="Obstructive Apnea" label="OA" unit="events/hour" color="#40c0ff"/>
+    //      <channel id="0x1003" class="data" name="Hypopnea" details="Hypopnea" label="H" unit="events/hour" color="blue"/>
+    //      <channel id="0x1004" class="data" name="Apnea" details="Unspecified Apnea" label="UA" unit="events/hour" color="dark green"/>
+    //      <channel id="0x1005" class="data" name="FlowLimit" details="Flow Limitation" label="FL" unit="events/hour" color="#404040"/>
+    //      <channel id="0x1006" class="data" name="RERA" details="Resp. Effort Related Arousal" unit="events/hour" label="RERA" color="gold"/>
+    //      <channel id="0x1007" class="data" name="VSnore" details="Vibratory Snore" label="VS" unit="events/hour" color="red"/>
+    //      <channel id="0x1008" class="data" name="VSnore2" details="Vibratory Snore #2" label="VS2" unit="events/hour" color="orange"/>
+    //      <channel id="0x1009" class="data" name="PressurePulse" details="Pressure Pulse" label="PP" unit="events/hour" color="dark red"/>
+    //      <channel id="0x100a" class="data" name="LeakFlag" details="Leak Event" label="L" unit="events/hour" color="dark blue"/>
+    //      <channel id="0x100b" class="data" name="NRI" details="Non-Responding Event" label="NRI" unit="events/hour" color="orange"/>
+    //      <channel id="0x100c" class="data" name="ExP" details="Exhale Puff" label="EP" unit="events/hour" color="dark magenta"/>
+    //      <channel id="0x101e" class="data" name="UserFlag1" details="User Flag #1" label="UF1" unit="events/hour" color="dark cyan"/>
+    //      <channel id="0x101f" class="data" name="UserFlag2" details="User Flag #2" label="UF2" unit="events/hour" color="dark blue"/>
+    //      <channel id="0x1024" class="data" name="UserFlag3" details="User Flag #3" label="UF3" unit="events/hour" color="dark grey"/>
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_CSR           = 0x1000, DATA,    SESSION, "CSR",
+                        QObject::tr("Periodic Breathing"),
+                        QObject::tr("A period of periodic breathing"),
+                        QObject::tr("PB"),       QObject::tr("%"),            DEFAULT,    QColor("light green")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_ClearAirway   = 0x1001, DATA,    SESSION,
+                        "ClearAirway",    QObject::tr("Clear Airway Apnea"),
+                        QObject::tr("An apnea where the airway is open"),
+                        QObject::tr("CA"),       QObject::tr("events/hr"),    DEFAULT,    QColor("purple")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_Obstructive   = 0x1002, DATA,    SESSION,
+                        "Obstructive",    QObject::tr("Obstructive Apnea"),
+                        QObject::tr("An apnea caused by airway obstruction"),
+                        QObject::tr("OA"),       QObject::tr("events/hr"),    DEFAULT,    QColor("#40c0ff")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_Hypopnea      = 0x1003, DATA,    SESSION,
+                        "Hypopnea",       QObject::tr("Hypopnea"),
+                        QObject::tr("A partially obstructed airway"),
+                        QObject::tr("H"),        QObject::tr("events/hr"),    DEFAULT,    QColor("blue")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_Apnea         = 0x1004, DATA,    SESSION, "Apnea",
+                        QObject::tr("Unclassified Apnea"),
+                        QObject::tr("An apnea that could not fit into a category"),
+                        QObject::tr("UA"),       QObject::tr("events/hr"),    DEFAULT,    QColor("dark green")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_FlowLimit     = 0x1005, DATA,    SESSION,
+                        "FlowLimit",      QObject::tr("Flow Limitation"),
+                        QObject::tr("An restriction in breathing from normal, causing a flattening of the flow waveform."),
+                        QObject::tr("FL"),       QObject::tr("events/hr"),    DEFAULT,    QColor("#404040")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_RERA          = 0x1006, DATA,    SESSION, "RERA",
+                        QObject::tr("Respiratory Effort Related Arousal"),
+                        QObject::tr("An restriction in breathing that causes an either an awakening or sleep disturbance."),
+                        QObject::tr("RE"),       QObject::tr("events/hr"),    DEFAULT,    QColor("gold")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_VSnore        = 0x1007, DATA,    SESSION, "VSnore",
+                        QObject::tr("Vibratory Snore"),                       QObject::tr("A vibratory snore"),
+                        QObject::tr("VS"),       QObject::tr("events/hr"),    DEFAULT,    QColor("red")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_VSnore2       = 0x1008, DATA,    SESSION, "VSnore2",
+                        QObject::tr("Vibratory Snore"),
+                        QObject::tr("A vibratory snore as detcted by a System One machine"),
+                        QObject::tr("VS2"),      QObject::tr("events/hr"),    DEFAULT,    QColor("red")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_PressurePulse = 0x1009, DATA,    SESSION,
+                        "PressurePulse",  QObject::tr("Pressure Pulse"),
+                        QObject::tr("A pulse of pressure 'pinged' to detect a closed airway."),
+                        QObject::tr("PP"),       QObject::tr("events/hr"),    DEFAULT,    QColor("dark red")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_LeakFlag      = 0x100a, DATA,    SESSION,
+                        "LeakFlag",       QObject::tr("Large Leak"),
+                        QObject::tr("A large mask leak affecting machine performance."),
+                        QObject::tr("LL"),       QObject::tr("events/hr"),    DEFAULT,    QColor("dark blue")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_NRI           = 0x100b, DATA,    SESSION, "NRI",
+                        QObject::tr("Non Responding Event"),
+                        QObject::tr("A type of respiratory event that won't respond to a pressure increase."),
+                        QObject::tr("NR"),       QObject::tr("events/hr"),    DEFAULT,    QColor("orange")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_ExP           = 0x100c, DATA,    SESSION, "ExP",
+                        QObject::tr("Expiratory Puff"),
+                        QObject::tr("Intellipap event where you breathe out your mouth."),
+                        QObject::tr("EP"),       QObject::tr("events/hr"),    DEFAULT,    QColor("dark magenta")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_UserFlag1     = 0x101e, DATA,    SESSION,
+                        "UserFlag1",      QObject::tr("User Flag #1"),
+                        QObject::tr("A user definable event detected by SleepyHead's flow waveform processor."),
+                        QObject::tr("UF1"),      QObject::tr("events/hr"),    DEFAULT,    QColor("dark cyan")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_UserFlag2     = 0x101f, DATA,    SESSION,
+                        "UserFlag2",      QObject::tr("User Flag #2"),
+                        QObject::tr("A user definable event detected by SleepyHead's flow waveform processor."),
+                        QObject::tr("UF2"),      QObject::tr("events/hr"),    DEFAULT,    QColor("dark blue")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_UserFlag3     = 0x1024, DATA,    SESSION,
+                        "UserFlag3",      QObject::tr("User Flag #3"),
+                        QObject::tr("A user definable event detected by SleepyHead's flow waveform processor."),
+                        QObject::tr("UF3"),      QObject::tr("events/hr"),    DEFAULT,    QColor("dark grey")));
 
-//    <channel id="0x1800" class="data" name="Pulse" details="Pulse Rate" label="Pulse Rate" unit="bpm" color="red"/>
-//     <channel id="0x1801" class="data" name="SPO2" details="Oxygen Saturation" label="SpO2" unit="%" color="blue"/>
-//     <channel id="0x1802" class="data" name="Plethy" details="Plethysomogram" label="Plethy" color="black"/>
-//     <channel id="0x1803" class="data" name="PulseChange" details="Pulse Change" label="Pulse Change" color="light gray"/>
-//     <channel id="0x1804" class="data" name="SPO2Drop" details="SPO2Drop" label="SPO2 Drop" color="light blue"/>
-    schema::channel.add(GRP_OXI,new Channel(OXI_Pulse           = 0x1800, DATA,    SESSION, "Pulse",            QObject::tr("Pulse Rate"),                    QObject::tr("Heart rate in beats per minute"),                                                                QObject::tr("Pulse Rate"), QObject::tr("%"),            DEFAULT,    QColor("red")));
-    schema::channel.add(GRP_OXI,new Channel(OXI_SPO2            = 0x1801, DATA,    SESSION, "SPO2",             QObject::tr("SpO2 %"),                        QObject::tr("Blood-oxygen saturation percentage"),                                                            QObject::tr("SpO2"),       QObject::tr("bpm"),          DEFAULT,    QColor("blue")));
-    schema::channel.add(GRP_OXI,new Channel(OXI_Plethy          = 0x1802, DATA,    SESSION, "Plethy",           QObject::tr("Plethysomogram"),                QObject::tr("An optical Photo-plethysomogram showing heart rhythm"),                                          QObject::tr("Plethy"),     QObject::tr("hz"),           DEFAULT,    QColor("#404040")));
-    schema::channel.add(GRP_OXI,new Channel(OXI_PulseChange     = 0x1803, DATA,    SESSION, "PulseChange",      QObject::tr("Pulse Change"),                  QObject::tr("A sudden (user definable) change in heart rate"),                                                QObject::tr("PC"),         QObject::tr("events/hr"),    DEFAULT,    QColor("light grey")));
-    schema::channel.add(GRP_OXI,new Channel(OXI_SPO2Drop        = 0x1804, DATA,    SESSION, "SPO2Drop",         QObject::tr("SpO2 Drop"),                     QObject::tr("A sudden (user definable) drop in blood oxygen saturation"),                                     QObject::tr("SD"),         QObject::tr("events/hr"),    DEFAULT,    QColor("light blue")));
+    //    <channel id="0x1800" class="data" name="Pulse" details="Pulse Rate" label="Pulse Rate" unit="bpm" color="red"/>
+    //     <channel id="0x1801" class="data" name="SPO2" details="Oxygen Saturation" label="SpO2" unit="%" color="blue"/>
+    //     <channel id="0x1802" class="data" name="Plethy" details="Plethysomogram" label="Plethy" color="black"/>
+    //     <channel id="0x1803" class="data" name="PulseChange" details="Pulse Change" label="Pulse Change" color="light gray"/>
+    //     <channel id="0x1804" class="data" name="SPO2Drop" details="SPO2Drop" label="SPO2 Drop" color="light blue"/>
+    schema::channel.add(GRP_OXI, new Channel(OXI_Pulse           = 0x1800, DATA,    SESSION, "Pulse",
+                        QObject::tr("Pulse Rate"),                    QObject::tr("Heart rate in beats per minute"),
+                        QObject::tr("Pulse Rate"), QObject::tr("%"),            DEFAULT,    QColor("red")));
+    schema::channel.add(GRP_OXI, new Channel(OXI_SPO2            = 0x1801, DATA,    SESSION, "SPO2",
+                        QObject::tr("SpO2 %"),                        QObject::tr("Blood-oxygen saturation percentage"),
+                        QObject::tr("SpO2"),       QObject::tr("bpm"),          DEFAULT,    QColor("blue")));
+    schema::channel.add(GRP_OXI, new Channel(OXI_Plethy          = 0x1802, DATA,    SESSION, "Plethy",
+                        QObject::tr("Plethysomogram"),
+                        QObject::tr("An optical Photo-plethysomogram showing heart rhythm"),
+                        QObject::tr("Plethy"),     QObject::tr("hz"),           DEFAULT,    QColor("#404040")));
+    schema::channel.add(GRP_OXI, new Channel(OXI_PulseChange     = 0x1803, DATA,    SESSION,
+                        "PulseChange",      QObject::tr("Pulse Change"),
+                        QObject::tr("A sudden (user definable) change in heart rate"),
+                        QObject::tr("PC"),         QObject::tr("events/hr"),    DEFAULT,    QColor("light grey")));
+    schema::channel.add(GRP_OXI, new Channel(OXI_SPO2Drop        = 0x1804, DATA,    SESSION,
+                        "SPO2Drop",         QObject::tr("SpO2 Drop"),
+                        QObject::tr("A sudden (user definable) drop in blood oxygen saturation"),
+                        QObject::tr("SD"),         QObject::tr("events/hr"),    DEFAULT,    QColor("light blue")));
 
-//      <channel id="0x1100" class="data" name="FlowRate" details="Flow Rate" label="Flow Rate" unit="L/min" color="black"/>
-//      <channel id="0x1101" class="data" name="MaskPressure" details="Mask Pressure" label="Mask Pressure" unit="cmH20" color="blue"/>
-//      <channel id="0x1102" class="data" name="MaskPressureHi" details="Mask Pressure" label="Mask Pressure (Hi-Res)" unit="cmH20" color="blue" link="0x1101"/>
-//      <channel id="0x1103" class="data" name="TidalVolume" details="Tidal Volume" label="Tidal Volume" unit="ml" color="magenta"/>
-//      <channel id="0x1104" class="data" name="Snore" details="Snore" label="Snore" unit="unknown" color="grey"/>
-//      <channel id="0x1105" class="data" name="MinuteVent" details="Minute Ventilation" label="Minute Vent." unit="L/min" color="dark cyan"/>
-//      <channel id="0x1106" class="data" name="RespRate" details="Respiratory Rate" label="Resp. Rate" unit="breaths/min" color="dark magenta"/>
-//      <channel id="0x1107" class="data" name="PTB" details="Patient Triggered Breaths" label="Pat. Trig. Breaths" unit="%" color="dark grey"/>
-//      <channel id="0x1108" class="data" name="Leak" details="Leak Rate" label="Leaks" unit="L/min" color="dark green"/>
+    //      <channel id="0x1100" class="data" name="FlowRate" details="Flow Rate" label="Flow Rate" unit="L/min" color="black"/>
+    //      <channel id="0x1101" class="data" name="MaskPressure" details="Mask Pressure" label="Mask Pressure" unit="cmH20" color="blue"/>
+    //      <channel id="0x1102" class="data" name="MaskPressureHi" details="Mask Pressure" label="Mask Pressure (Hi-Res)" unit="cmH20" color="blue" link="0x1101"/>
+    //      <channel id="0x1103" class="data" name="TidalVolume" details="Tidal Volume" label="Tidal Volume" unit="ml" color="magenta"/>
+    //      <channel id="0x1104" class="data" name="Snore" details="Snore" label="Snore" unit="unknown" color="grey"/>
+    //      <channel id="0x1105" class="data" name="MinuteVent" details="Minute Ventilation" label="Minute Vent." unit="L/min" color="dark cyan"/>
+    //      <channel id="0x1106" class="data" name="RespRate" details="Respiratory Rate" label="Resp. Rate" unit="breaths/min" color="dark magenta"/>
+    //      <channel id="0x1107" class="data" name="PTB" details="Patient Triggered Breaths" label="Pat. Trig. Breaths" unit="%" color="dark grey"/>
+    //      <channel id="0x1108" class="data" name="Leak" details="Leak Rate" label="Leaks" unit="L/min" color="dark green"/>
 
-//      <channel id="0x1109" class="data" name="IE" details="Inspiratory:Expiratory" label="I:E" unit="ratio" color="dark red"/>
-//      <channel id="0x110a" class="data" name="Te" details="Expiratory Time" label="Exp Time" unit="seconds" color="dark green"/>
-//      <channel id="0x110b" class="data" name="Ti" details="Inspiratory Time" label="Insp Time" unit="seconds" color="dark blue"/>
-//      <channel id="0x1112" class="data" name="RespEvent" details="Respiratory Events" label="Resp Events" unit="" color="black"/>
-//      <channel id="0x1113" class="data" name="FLG" details="Flow Limit Graph" label="Flow Limit" unit="0-1" color="dark grey"/>
-//      <channel id="0x1114" class="data" name="TgMV" details="Target Minute Ventilation" label="Target Vent." unit="" color="dark cyan"/>
-//      <channel id="0x1115" class="data" name="MaxLeak" details="Maximum Leak" label="MaxLeaks" unit="L/min" color="dark red"/>
-//      <channel id="0x1116" class="data" name="AHI" details="Apnea / Hypopnea Index" label="AHI/Hr" unit="events/hr" color="dark red"/>
-//      <channel id="0x1117" class="data" name="LeakTotal" details="Total Leak Rate" label="Total Leaks" unit="L/min" color="dark green"/>
-//      <channel id="0x1118" class="data" name="LeakMedian" details="Median Leak Rate" label="Median Leaks" unit="L/min" color="dark green"/>
-//      <channel id="0x1119" class="data" name="RDI" details="Respiratory Disturbance Index" label="RDI" unit="events/hr" color="dark red"/>
+    //      <channel id="0x1109" class="data" name="IE" details="Inspiratory:Expiratory" label="I:E" unit="ratio" color="dark red"/>
+    //      <channel id="0x110a" class="data" name="Te" details="Expiratory Time" label="Exp Time" unit="seconds" color="dark green"/>
+    //      <channel id="0x110b" class="data" name="Ti" details="Inspiratory Time" label="Insp Time" unit="seconds" color="dark blue"/>
+    //      <channel id="0x1112" class="data" name="RespEvent" details="Respiratory Events" label="Resp Events" unit="" color="black"/>
+    //      <channel id="0x1113" class="data" name="FLG" details="Flow Limit Graph" label="Flow Limit" unit="0-1" color="dark grey"/>
+    //      <channel id="0x1114" class="data" name="TgMV" details="Target Minute Ventilation" label="Target Vent." unit="" color="dark cyan"/>
+    //      <channel id="0x1115" class="data" name="MaxLeak" details="Maximum Leak" label="MaxLeaks" unit="L/min" color="dark red"/>
+    //      <channel id="0x1116" class="data" name="AHI" details="Apnea / Hypopnea Index" label="AHI/Hr" unit="events/hr" color="dark red"/>
+    //      <channel id="0x1117" class="data" name="LeakTotal" details="Total Leak Rate" label="Total Leaks" unit="L/min" color="dark green"/>
+    //      <channel id="0x1118" class="data" name="LeakMedian" details="Median Leak Rate" label="Median Leaks" unit="L/min" color="dark green"/>
+    //      <channel id="0x1119" class="data" name="RDI" details="Respiratory Disturbance Index" label="RDI" unit="events/hr" color="dark red"/>
 
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_FlowRate          = 0x1100, DATA,    SESSION, "FlowRate",          QObject::tr("Flow Rate"),                          QObject::tr("Breathing flow rate waveform"),                 QObject::tr("Flow Rate"),          QObject::tr("L/min"),    DEFAULT,    QColor("black")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_MaskPressure      = 0x1101, DATA,    SESSION, "MaskPressure",      QObject::tr("Mask Pressure"),                      QObject::tr("Mask Pressure"),                                QObject::tr("Mask Pressure"),      QObject::tr("cmH2O"),    DEFAULT,    QColor("black")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_MaskPressureHi    = 0x1102, DATA,    SESSION, "MaskPressureHi",    QObject::tr("Mask Pressure"),                      QObject::tr("Mask Pressure (High resolution)"),              QObject::tr("Mask Pressure"),      QObject::tr("cmH2O"),    DEFAULT,    QColor("black"),0x1101)); // linked to CPAP_MaskPressure
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_TidalVolume       = 0x1103, DATA,    SESSION, "TidalVolume",       QObject::tr("Tidal Volume"),                       QObject::tr("Amount of air displaced per breath"),           QObject::tr("Tidal Volume"),       QObject::tr("L/min"),    DEFAULT,    QColor("magenta")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_Snore             = 0x1104, DATA,    SESSION, "Snore",             QObject::tr("Snore"),                              QObject::tr("Graph displaying snore volume"),                QObject::tr("Snore"),              QObject::tr("??"),       DEFAULT,    QColor("grey")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_MinuteVent        = 0x1105, DATA,    SESSION, "MinuteVent",        QObject::tr("Minute Ventilation"),                 QObject::tr("Amount of air displaced per minute"),           QObject::tr("Minute Vent."),       QObject::tr("L/min"),    DEFAULT,    QColor("dark cyan")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_RespRate          = 0x1106, DATA,    SESSION, "RespRate",          QObject::tr("Respiratory Rate"),                   QObject::tr("Rate of breaths per minute"),                   QObject::tr("Resp. Rate"),         QObject::tr("Bpm"),      DEFAULT,    QColor("dark magenta")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_PTB               = 0x1107, DATA,    SESSION, "PTB",               QObject::tr("Patient Triggered Breaths"),          QObject::tr("Percentage of breaths triggered by patient"),   QObject::tr("Pat. Trig. Breaths"), QObject::tr("%"),        DEFAULT,    QColor("dark grey")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_Leak              = 0x1108, DATA,    SESSION, "Leak",              QObject::tr("Leak Rate"),                          QObject::tr("Rate of detected mask leakage"),                QObject::tr("Leak Rate"),          QObject::tr("L/min"),    DEFAULT,    QColor("dark green")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_IE                = 0x1109, DATA,    SESSION, "IE",                QObject::tr("I:E Ratio"),                          QObject::tr("Ratio between Inspiratory and Expiratory time"),QObject::tr("I:E Ratio"),          QObject::tr("ratio"),    DEFAULT,    QColor("dark red")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_Te                = 0x110A, DATA,    SESSION, "Te",                QObject::tr("Expiratory Time"),                    QObject::tr("Time taken to breathe out"),                    QObject::tr("Exp. Time"),          QObject::tr("seconds"),  DEFAULT,    QColor("dark green")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_Ti                = 0x110B, DATA,    SESSION, "Ti",                QObject::tr("Inspiratory Time"),                   QObject::tr("Time taken to breathe in"),                     QObject::tr("Insp. Time"),         QObject::tr("seconds"),  DEFAULT,    QColor("dark blue")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_RespEvent         = 0x1112, DATA,    SESSION, "RespEvent",         QObject::tr("Respiratory Event"),                  QObject::tr("A ResMed data source showing Respiratory Events"),  QObject::tr("Resp. Event"),    QObject::tr("events"),   DEFAULT,    QColor("black")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_FLG               = 0x1113, DATA,    SESSION, "FLG",               QObject::tr("Flow Limitation"),                    QObject::tr("Graph showing severity of flow limitations"),   QObject::tr("Flow Limit."),        QObject::tr("0-1"),      DEFAULT,    QColor("dark gray")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_TgMV              = 0x1114, DATA,    SESSION, "TgMV",              QObject::tr("Target Minute Ventilation"),          QObject::tr("Target Minute Ventilation?"),                   QObject::tr("Target Vent."),       QObject::tr("??"),       DEFAULT,    QColor("dark cyan")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_MaxLeak           = 0x1115, DATA,    SESSION, "MaxLeak",           QObject::tr("Maximum Leak"),                       QObject::tr("The maximum rate of mask leakage"),             QObject::tr("Max Leaks"),          QObject::tr("L/min"),    DEFAULT,    QColor("dark red")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_AHI               = 0x1116, DATA,    SESSION, "AHI",               QObject::tr("Apnea Hypopnea Index"),               QObject::tr("Graph showing running AHI for the past hour"),  QObject::tr("AHI"),                QObject::tr("events/hour"), DEFAULT,  QColor("dark red")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_LeakTotal         = 0x1117, DATA,    SESSION, "LeakTotal",         QObject::tr("Total Leak Rate"),                    QObject::tr("Detected mask leakage including natural Mask leakages"),  QObject::tr("Total Leaks"), QObject::tr("L/min"),    DEFAULT,    QColor("dark green")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_LeakMedian        = 0x1118, DATA,    SESSION, "LeakMedian",        QObject::tr("Median Leak Rate"),                   QObject::tr("Median rate of detected mask leakage"),         QObject::tr("Median Leaks"),          QObject::tr("L/min"),    DEFAULT,    QColor("dark green")));
-    schema::channel.add(GRP_CPAP,new Channel(CPAP_RDI               = 0x1119, DATA,    SESSION, "RDI",               QObject::tr("Respiratory Disturbance Index"),      QObject::tr("Graph showing running RDI for the past hour"),  QObject::tr("RDI"),                QObject::tr("events/hour"), DEFAULT,  QColor("dark red")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_FlowRate          = 0x1100, DATA,    SESSION,
+                        "FlowRate",          QObject::tr("Flow Rate"),
+                        QObject::tr("Breathing flow rate waveform"),                 QObject::tr("Flow Rate"),
+                        QObject::tr("L/min"),    DEFAULT,    QColor("black")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_MaskPressure      = 0x1101, DATA,    SESSION,
+                        "MaskPressure",      QObject::tr("Mask Pressure"),
+                        QObject::tr("Mask Pressure"),                                QObject::tr("Mask Pressure"),
+                        QObject::tr("cmH2O"),    DEFAULT,    QColor("black")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_MaskPressureHi    = 0x1102, DATA,    SESSION,
+                        "MaskPressureHi",    QObject::tr("Mask Pressure"),
+                        QObject::tr("Mask Pressure (High resolution)"),              QObject::tr("Mask Pressure"),
+                        QObject::tr("cmH2O"),    DEFAULT,    QColor("black"), 0x1101)); // linked to CPAP_MaskPressure
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_TidalVolume       = 0x1103, DATA,    SESSION,
+                        "TidalVolume",       QObject::tr("Tidal Volume"),
+                        QObject::tr("Amount of air displaced per breath"),           QObject::tr("Tidal Volume"),
+                        QObject::tr("L/min"),    DEFAULT,    QColor("magenta")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_Snore             = 0x1104, DATA,    SESSION,
+                        "Snore",             QObject::tr("Snore"),
+                        QObject::tr("Graph displaying snore volume"),                QObject::tr("Snore"),
+                        QObject::tr("??"),       DEFAULT,    QColor("grey")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_MinuteVent        = 0x1105, DATA,    SESSION,
+                        "MinuteVent",        QObject::tr("Minute Ventilation"),
+                        QObject::tr("Amount of air displaced per minute"),           QObject::tr("Minute Vent."),
+                        QObject::tr("L/min"),    DEFAULT,    QColor("dark cyan")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_RespRate          = 0x1106, DATA,    SESSION,
+                        "RespRate",          QObject::tr("Respiratory Rate"),
+                        QObject::tr("Rate of breaths per minute"),                   QObject::tr("Resp. Rate"),
+                        QObject::tr("Bpm"),      DEFAULT,    QColor("dark magenta")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_PTB               = 0x1107, DATA,    SESSION, "PTB",
+                        QObject::tr("Patient Triggered Breaths"),
+                        QObject::tr("Percentage of breaths triggered by patient"),   QObject::tr("Pat. Trig. Breaths"),
+                        QObject::tr("%"),        DEFAULT,    QColor("dark grey")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_Leak              = 0x1108, DATA,    SESSION,
+                        "Leak",              QObject::tr("Leak Rate"),
+                        QObject::tr("Rate of detected mask leakage"),                QObject::tr("Leak Rate"),
+                        QObject::tr("L/min"),    DEFAULT,    QColor("dark green")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_IE                = 0x1109, DATA,    SESSION, "IE",
+                        QObject::tr("I:E Ratio"),
+                        QObject::tr("Ratio between Inspiratory and Expiratory time"), QObject::tr("I:E Ratio"),
+                        QObject::tr("ratio"),    DEFAULT,    QColor("dark red")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_Te                = 0x110A, DATA,    SESSION, "Te",
+                        QObject::tr("Expiratory Time"),                    QObject::tr("Time taken to breathe out"),
+                        QObject::tr("Exp. Time"),          QObject::tr("seconds"),  DEFAULT,    QColor("dark green")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_Ti                = 0x110B, DATA,    SESSION, "Ti",
+                        QObject::tr("Inspiratory Time"),                   QObject::tr("Time taken to breathe in"),
+                        QObject::tr("Insp. Time"),         QObject::tr("seconds"),  DEFAULT,    QColor("dark blue")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_RespEvent         = 0x1112, DATA,    SESSION,
+                        "RespEvent",         QObject::tr("Respiratory Event"),
+                        QObject::tr("A ResMed data source showing Respiratory Events"),  QObject::tr("Resp. Event"),
+                        QObject::tr("events"),   DEFAULT,    QColor("black")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_FLG               = 0x1113, DATA,    SESSION, "FLG",
+                        QObject::tr("Flow Limitation"),
+                        QObject::tr("Graph showing severity of flow limitations"),   QObject::tr("Flow Limit."),
+                        QObject::tr("0-1"),      DEFAULT,    QColor("dark gray")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_TgMV              = 0x1114, DATA,    SESSION,
+                        "TgMV",              QObject::tr("Target Minute Ventilation"),
+                        QObject::tr("Target Minute Ventilation?"),                   QObject::tr("Target Vent."),
+                        QObject::tr("??"),       DEFAULT,    QColor("dark cyan")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_MaxLeak           = 0x1115, DATA,    SESSION,
+                        "MaxLeak",           QObject::tr("Maximum Leak"),
+                        QObject::tr("The maximum rate of mask leakage"),             QObject::tr("Max Leaks"),
+                        QObject::tr("L/min"),    DEFAULT,    QColor("dark red")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_AHI               = 0x1116, DATA,    SESSION, "AHI",
+                        QObject::tr("Apnea Hypopnea Index"),
+                        QObject::tr("Graph showing running AHI for the past hour"),  QObject::tr("AHI"),
+                        QObject::tr("events/hour"), DEFAULT,  QColor("dark red")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_LeakTotal         = 0x1117, DATA,    SESSION,
+                        "LeakTotal",         QObject::tr("Total Leak Rate"),
+                        QObject::tr("Detected mask leakage including natural Mask leakages"),  QObject::tr("Total Leaks"),
+                        QObject::tr("L/min"),    DEFAULT,    QColor("dark green")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_LeakMedian        = 0x1118, DATA,    SESSION,
+                        "LeakMedian",        QObject::tr("Median Leak Rate"),
+                        QObject::tr("Median rate of detected mask leakage"),         QObject::tr("Median Leaks"),
+                        QObject::tr("L/min"),    DEFAULT,    QColor("dark green")));
+    schema::channel.add(GRP_CPAP, new Channel(CPAP_RDI               = 0x1119, DATA,    SESSION, "RDI",
+                        QObject::tr("Respiratory Disturbance Index"),
+                        QObject::tr("Graph showing running RDI for the past hour"),  QObject::tr("RDI"),
+                        QObject::tr("events/hour"), DEFAULT,  QColor("dark red")));
 
-    schema::channel.add(GRP_POS,new Channel(POS_Orientation         = 0x2990, DATA,    SESSION, "Orientation",      QObject::tr("Orientation"),                         QObject::tr("Sleep position in degrees"),  QObject::tr("Orientation"),  QObject::tr("degrees"), DEFAULT,  QColor("dark blue")));
-    schema::channel.add(GRP_POS,new Channel(POS_Inclination         = 0x2991, DATA,    SESSION, "Inclination",      QObject::tr("Inclination"),                         QObject::tr("Upright angle in degrees"),  QObject::tr("Inclination"),  QObject::tr("degrees"), DEFAULT,  QColor("dark magenta")));
+    schema::channel.add(GRP_POS, new Channel(POS_Orientation         = 0x2990, DATA,    SESSION,
+                        "Orientation",      QObject::tr("Orientation"),
+                        QObject::tr("Sleep position in degrees"),  QObject::tr("Orientation"),  QObject::tr("degrees"),
+                        DEFAULT,  QColor("dark blue")));
+    schema::channel.add(GRP_POS, new Channel(POS_Inclination         = 0x2991, DATA,    SESSION,
+                        "Inclination",      QObject::tr("Inclination"),
+                        QObject::tr("Upright angle in degrees"),  QObject::tr("Inclination"),  QObject::tr("degrees"),
+                        DEFAULT,  QColor("dark magenta")));
 
 
 
-    NoChannel=0;
-//    CPAP_IPAP=schema::channel["IPAP"].id();
-//    CPAP_IPAPLo=schema::channel["IPAPLo"].id();
-//    CPAP_IPAPHi=schema::channel["IPAPHi"].id();
-//    CPAP_EPAP=schema::channel["EPAP"].id();
-//    CPAP_Pressure=schema::channel["Pressure"].id();
-//    CPAP_PS=schema::channel["PS"].id();
-//    CPAP_PSMin=schema::channel["PSMin"].id();
-//    CPAP_PSMax=schema::channel["PSMax"].id();
-    CPAP_Mode=schema::channel["PAPMode"].id();
-    CPAP_BrokenSummary=schema::channel["BrokenSummary"].id();
-    CPAP_BrokenWaveform=schema::channel["BrokenWaveform"].id();
-//    CPAP_PressureMin=schema::channel["PressureMin"].id();
-//    CPAP_PressureMax=schema::channel["PressureMax"].id();
-//    CPAP_RampTime=schema::channel["RampTime"].id();
-//    CPAP_RampPressure=schema::channel["RampPressure"].id();
-//    CPAP_Obstructive=schema::channel["Obstructive"].id();
-//    CPAP_Hypopnea=schema::channel["Hypopnea"].id();
-//    CPAP_ClearAirway=schema::channel["ClearAirway"].id();
-//    CPAP_Apnea=schema::channel["Apnea"].id();
-//    CPAP_CSR=schema::channel["CSR"].id();
-//    CPAP_LeakFlag=schema::channel["LeakFlag"].id();
-//    CPAP_ExP=schema::channel["ExP"].id();
-//    CPAP_NRI=schema::channel["NRI"].id();
-//    CPAP_VSnore=schema::channel["VSnore"].id();
-//    CPAP_VSnore2=schema::channel["VSnore2"].id();
-//    CPAP_RERA=schema::channel["RERA"].id();
-//    CPAP_PressurePulse=schema::channel["PressurePulse"].id();
-//    CPAP_FlowLimit=schema::channel["FlowLimit"].id();
-//    CPAP_FlowRate=schema::channel["FlowRate"].id();
-//    CPAP_MaskPressure=schema::channel["MaskPressure"].id();
-//    CPAP_MaskPressureHi=schema::channel["MaskPressureHi"].id();
-//    CPAP_RespEvent=schema::channel["RespEvent"].id();
-//    CPAP_Snore=schema::channel["Snore"].id();
-//    CPAP_MinuteVent=schema::channel["MinuteVent"].id();
-//    CPAP_RespRate=schema::channel["RespRate"].id();
-//    CPAP_TidalVolume=schema::channel["TidalVolume"].id();
-//    CPAP_PTB=schema::channel["PTB"].id();
-//    CPAP_Leak=schema::channel["Leak"].id();
-//    CPAP_LeakMedian=schema::channel["LeakMedian"].id();
-//    CPAP_LeakTotal=schema::channel["LeakTotal"].id();
-//    CPAP_MaxLeak=schema::channel["MaxLeak"].id();
-//    CPAP_FLG=schema::channel["FLG"].id();
-//    CPAP_IE=schema::channel["IE"].id();
-//    CPAP_Te=schema::channel["Te"].id();
-//    CPAP_Ti=schema::channel["Ti"].id();
-//    CPAP_TgMV=schema::channel["TgMV"].id();
-    CPAP_Test1=schema::channel["TestChan1"].id();
-    CPAP_Test2=schema::channel["TestChan2"].id();
+    NoChannel = 0;
+    //    CPAP_IPAP=schema::channel["IPAP"].id();
+    //    CPAP_IPAPLo=schema::channel["IPAPLo"].id();
+    //    CPAP_IPAPHi=schema::channel["IPAPHi"].id();
+    //    CPAP_EPAP=schema::channel["EPAP"].id();
+    //    CPAP_Pressure=schema::channel["Pressure"].id();
+    //    CPAP_PS=schema::channel["PS"].id();
+    //    CPAP_PSMin=schema::channel["PSMin"].id();
+    //    CPAP_PSMax=schema::channel["PSMax"].id();
+    CPAP_Mode = schema::channel["PAPMode"].id();
+    CPAP_BrokenSummary = schema::channel["BrokenSummary"].id();
+    CPAP_BrokenWaveform = schema::channel["BrokenWaveform"].id();
+    //    CPAP_PressureMin=schema::channel["PressureMin"].id();
+    //    CPAP_PressureMax=schema::channel["PressureMax"].id();
+    //    CPAP_RampTime=schema::channel["RampTime"].id();
+    //    CPAP_RampPressure=schema::channel["RampPressure"].id();
+    //    CPAP_Obstructive=schema::channel["Obstructive"].id();
+    //    CPAP_Hypopnea=schema::channel["Hypopnea"].id();
+    //    CPAP_ClearAirway=schema::channel["ClearAirway"].id();
+    //    CPAP_Apnea=schema::channel["Apnea"].id();
+    //    CPAP_CSR=schema::channel["CSR"].id();
+    //    CPAP_LeakFlag=schema::channel["LeakFlag"].id();
+    //    CPAP_ExP=schema::channel["ExP"].id();
+    //    CPAP_NRI=schema::channel["NRI"].id();
+    //    CPAP_VSnore=schema::channel["VSnore"].id();
+    //    CPAP_VSnore2=schema::channel["VSnore2"].id();
+    //    CPAP_RERA=schema::channel["RERA"].id();
+    //    CPAP_PressurePulse=schema::channel["PressurePulse"].id();
+    //    CPAP_FlowLimit=schema::channel["FlowLimit"].id();
+    //    CPAP_FlowRate=schema::channel["FlowRate"].id();
+    //    CPAP_MaskPressure=schema::channel["MaskPressure"].id();
+    //    CPAP_MaskPressureHi=schema::channel["MaskPressureHi"].id();
+    //    CPAP_RespEvent=schema::channel["RespEvent"].id();
+    //    CPAP_Snore=schema::channel["Snore"].id();
+    //    CPAP_MinuteVent=schema::channel["MinuteVent"].id();
+    //    CPAP_RespRate=schema::channel["RespRate"].id();
+    //    CPAP_TidalVolume=schema::channel["TidalVolume"].id();
+    //    CPAP_PTB=schema::channel["PTB"].id();
+    //    CPAP_Leak=schema::channel["Leak"].id();
+    //    CPAP_LeakMedian=schema::channel["LeakMedian"].id();
+    //    CPAP_LeakTotal=schema::channel["LeakTotal"].id();
+    //    CPAP_MaxLeak=schema::channel["MaxLeak"].id();
+    //    CPAP_FLG=schema::channel["FLG"].id();
+    //    CPAP_IE=schema::channel["IE"].id();
+    //    CPAP_Te=schema::channel["Te"].id();
+    //    CPAP_Ti=schema::channel["Ti"].id();
+    //    CPAP_TgMV=schema::channel["TgMV"].id();
+    CPAP_Test1 = schema::channel["TestChan1"].id();
+    CPAP_Test2 = schema::channel["TestChan2"].id();
 
-    CPAP_PresReliefSet=schema::channel["PresRelSet"].id();
-    CPAP_PresReliefMode=schema::channel["PresRelMode"].id();
-    CPAP_PresReliefType=schema::channel["PresRelType"].id();
+    CPAP_PresReliefSet = schema::channel["PresRelSet"].id();
+    CPAP_PresReliefMode = schema::channel["PresRelMode"].id();
+    CPAP_PresReliefType = schema::channel["PresRelType"].id();
 
-//    CPAP_UserFlag1=schema::channel["UserFlag1"].id();
-//    CPAP_UserFlag2=schema::channel["UserFlag2"].id();
-//    CPAP_UserFlag3=schema::channel["UserFlag3"].id();
-    RMS9_E01=schema::channel["RMS9_E01"].id();
-    RMS9_E02=schema::channel["RMS9_E02"].id();
-    RMS9_EPR=schema::channel["EPR"].id();
-    RMS9_EPRSet=schema::channel["EPRSet"].id();
-    RMS9_SetPressure=schema::channel["SetPressure"].id();
-    PRS1_00=schema::channel["PRS1_00"].id();
-    PRS1_01=schema::channel["PRS1_01"].id();
-    PRS1_08=schema::channel["PRS1_08"].id();
-    PRS1_0A=schema::channel["PRS1_0A"].id();
-    PRS1_0B=schema::channel["PRS1_0B"].id();
-    PRS1_0C=schema::channel["PRS1_0C"].id();
-    PRS1_0E=schema::channel["PRS1_0E"].id();
-    PRS1_0F=schema::channel["PRS1_0F"].id();
-    PRS1_10=schema::channel["PRS1_10"].id();
-    PRS1_12=schema::channel["PRS1_12"].id();
-    PRS1_FlexMode=schema::channel["FlexMode"].id();
-    PRS1_FlexSet=schema::channel["FlexSet"].id();
-    PRS1_HumidStatus=schema::channel["HumidStat"].id();
-    CPAP_HumidSetting=schema::channel["HumidSet"].id();
-    PRS1_SysLock=schema::channel["SysLock"].id();
-    PRS1_SysOneResistStat=schema::channel["SysOneResistStat"].id();
-    PRS1_SysOneResistSet=schema::channel["SysOneResistSet"].id();
-    PRS1_HoseDiam=schema::channel["HoseDiam"].id();
-    PRS1_AutoOn=schema::channel["AutoOn"].id();
-    PRS1_AutoOff=schema::channel["AutoOff"].id();
-    PRS1_MaskAlert=schema::channel["MaskAlert"].id();
-    PRS1_ShowAHI=schema::channel["ShowAHI"].id();
-    INTELLIPAP_Unknown1=schema::channel["IntUnk1"].id();
-    INTELLIPAP_Unknown2=schema::channel["IntUnk2"].id();
-//    OXI_Pulse=schema::channel["Pulse"].id();
-//    OXI_SPO2=schema::channel["SPO2"].id();
-//    OXI_PulseChange=schema::channel["PulseChange"].id();
-//    OXI_SPO2Drop=schema::channel["SPO2Drop"].id();
-//    OXI_Plethy=schema::channel["Plethy"].id();
-//    CPAP_AHI=schema::channel["AHI"].id();
-//    CPAP_RDI=schema::channel["RDI"].id();
-    Journal_Notes=schema::channel["Journal"].id();
-    Journal_Weight=schema::channel["Weight"].id();
-    Journal_BMI=schema::channel["BMI"].id();
-    Journal_ZombieMeter=schema::channel["ZombieMeter"].id();
-    Bookmark_Start=schema::channel["BookmarkStart"].id();
-    Bookmark_End=schema::channel["BookmarkEnd"].id();
-    Bookmark_Notes=schema::channel["BookmarkNotes"].id();
+    //    CPAP_UserFlag1=schema::channel["UserFlag1"].id();
+    //    CPAP_UserFlag2=schema::channel["UserFlag2"].id();
+    //    CPAP_UserFlag3=schema::channel["UserFlag3"].id();
+    RMS9_E01 = schema::channel["RMS9_E01"].id();
+    RMS9_E02 = schema::channel["RMS9_E02"].id();
+    RMS9_EPR = schema::channel["EPR"].id();
+    RMS9_EPRSet = schema::channel["EPRSet"].id();
+    RMS9_SetPressure = schema::channel["SetPressure"].id();
+    PRS1_00 = schema::channel["PRS1_00"].id();
+    PRS1_01 = schema::channel["PRS1_01"].id();
+    PRS1_08 = schema::channel["PRS1_08"].id();
+    PRS1_0A = schema::channel["PRS1_0A"].id();
+    PRS1_0B = schema::channel["PRS1_0B"].id();
+    PRS1_0C = schema::channel["PRS1_0C"].id();
+    PRS1_0E = schema::channel["PRS1_0E"].id();
+    PRS1_0F = schema::channel["PRS1_0F"].id();
+    PRS1_10 = schema::channel["PRS1_10"].id();
+    PRS1_12 = schema::channel["PRS1_12"].id();
+    PRS1_FlexMode = schema::channel["FlexMode"].id();
+    PRS1_FlexSet = schema::channel["FlexSet"].id();
+    PRS1_HumidStatus = schema::channel["HumidStat"].id();
+    CPAP_HumidSetting = schema::channel["HumidSet"].id();
+    PRS1_SysLock = schema::channel["SysLock"].id();
+    PRS1_SysOneResistStat = schema::channel["SysOneResistStat"].id();
+    PRS1_SysOneResistSet = schema::channel["SysOneResistSet"].id();
+    PRS1_HoseDiam = schema::channel["HoseDiam"].id();
+    PRS1_AutoOn = schema::channel["AutoOn"].id();
+    PRS1_AutoOff = schema::channel["AutoOff"].id();
+    PRS1_MaskAlert = schema::channel["MaskAlert"].id();
+    PRS1_ShowAHI = schema::channel["ShowAHI"].id();
+    INTELLIPAP_Unknown1 = schema::channel["IntUnk1"].id();
+    INTELLIPAP_Unknown2 = schema::channel["IntUnk2"].id();
+    //    OXI_Pulse=schema::channel["Pulse"].id();
+    //    OXI_SPO2=schema::channel["SPO2"].id();
+    //    OXI_PulseChange=schema::channel["PulseChange"].id();
+    //    OXI_SPO2Drop=schema::channel["SPO2Drop"].id();
+    //    OXI_Plethy=schema::channel["Plethy"].id();
+    //    CPAP_AHI=schema::channel["AHI"].id();
+    //    CPAP_RDI=schema::channel["RDI"].id();
+    Journal_Notes = schema::channel["Journal"].id();
+    Journal_Weight = schema::channel["Weight"].id();
+    Journal_BMI = schema::channel["BMI"].id();
+    Journal_ZombieMeter = schema::channel["ZombieMeter"].id();
+    Bookmark_Start = schema::channel["BookmarkStart"].id();
+    Bookmark_End = schema::channel["BookmarkEnd"].id();
+    Bookmark_Notes = schema::channel["BookmarkNotes"].id();
 
-    ZEO_SleepStage=schema::channel["SleepStage"].id();
-    ZEO_ZQ=schema::channel["ZeoZQ"].id();
-    ZEO_Awakenings=schema::channel["Awakenings"].id();
-    ZEO_MorningFeel=schema::channel["MorningFeel"].id();
-    ZEO_TimeInWake=schema::channel["TimeInWake"].id();
-    ZEO_TimeInREM=schema::channel["TimeInREM"].id();
-    ZEO_TimeInLight=schema::channel["TimeInLight"].id();
-    ZEO_TimeInDeep=schema::channel["TimeInDeep"].id();
-    ZEO_TimeToZ=schema::channel["TimeToZ"].id();
+    ZEO_SleepStage = schema::channel["SleepStage"].id();
+    ZEO_ZQ = schema::channel["ZeoZQ"].id();
+    ZEO_Awakenings = schema::channel["Awakenings"].id();
+    ZEO_MorningFeel = schema::channel["MorningFeel"].id();
+    ZEO_TimeInWake = schema::channel["TimeInWake"].id();
+    ZEO_TimeInREM = schema::channel["TimeInREM"].id();
+    ZEO_TimeInLight = schema::channel["TimeInLight"].id();
+    ZEO_TimeInDeep = schema::channel["TimeInDeep"].id();
+    ZEO_TimeToZ = schema::channel["TimeToZ"].id();
 }
 
-Channel::Channel(ChannelID id, ChanType type, ScopeType scope, QString code, QString fullname, QString description, QString label, QString unit, DataType datatype, QColor color, int link):
+Channel::Channel(ChannelID id, ChanType type, ScopeType scope, QString code, QString fullname,
+                 QString description, QString label, QString unit, DataType datatype, QColor color, int link):
     m_id(id),
     m_type(type),
     m_scope(scope),
@@ -326,16 +482,16 @@ Channel::Channel(ChannelID id, ChanType type, ScopeType scope, QString code, QSt
 }
 bool Channel::isNull()
 {
-    return (this==&EmptyChannel);
+    return (this == &EmptyChannel);
 }
 
 ChannelList::ChannelList()
-    :m_doctype("channels")
+    : m_doctype("channels")
 {
 }
 ChannelList::~ChannelList()
 {
-    for (QHash<ChannelID,Channel *>::iterator i=channels.begin();i!=channels.end();i++) {
+    for (QHash<ChannelID, Channel *>::iterator i = channels.begin(); i != channels.end(); i++) {
         delete i.value();
     }
 }
@@ -344,40 +500,47 @@ bool ChannelList::Load(QString filename)
     QDomDocument doc(m_doctype);
     QFile file(filename);
     qDebug() << "Opening " << filename;
+
     if (!file.open(QIODevice::ReadOnly)) {
         qWarning() << "Could not open" << filename;
         return false;
     }
+
     QString errorMsg;
     int errorLine;
-    if (!doc.setContent(&file,false,&errorMsg,&errorLine)) {
+
+    if (!doc.setContent(&file, false, &errorMsg, &errorLine)) {
         qWarning() << "Invalid XML Content in" << filename;
-        qWarning() << "Error line" << errorLine <<":" << errorMsg;
+        qWarning() << "Error line" << errorLine << ":" << errorMsg;
         return false;
     }
+
     file.close();
 
 
-    QDomElement root=doc.documentElement();
+    QDomElement root = doc.documentElement();
+
     if (root.tagName().toLower() != "channels") {
         return false;
     }
-    QString language=root.attribute("language","en");
-    QString version=root.attribute("version","");
+
+    QString language = root.attribute("language", "en");
+    QString version = root.attribute("version", "");
 
     if (version.isEmpty()) {
         qWarning() << "No Version Field in" << m_doctype << "Schema, assuming 1.0" << filename;
-        version="1.0";
+        version = "1.0";
     }
 
     qDebug() << "Processing xml file:" << m_doctype << language << version;
-    QDomNodeList grp=root.elementsByTagName("group");
-    QDomNode node,n,ch;
+    QDomNodeList grp = root.elementsByTagName("group");
+    QDomNode node, n, ch;
     QDomElement e;
 
     bool ok;
-    int id,linkid;
-    QString chantype,scopestr,typestr,name,group,idtxt,details,label,unit,datatypestr,defcolor,link;
+    int id, linkid;
+    QString chantype, scopestr, typestr, name, group, idtxt, details, label, unit, datatypestr,
+            defcolor, link;
     ChanType type;
     DataType datatype;
     Channel *chan;
@@ -385,121 +548,138 @@ bool ChannelList::Load(QString filename)
     //bool multi;
     ScopeType scope;
     int line;
-    for (int i=0;i<grp.size();i++) {
-        node=grp.at(i);
-        group=node.toElement().attribute("name");
+
+    for (int i = 0; i < grp.size(); i++) {
+        node = grp.at(i);
+        group = node.toElement().attribute("name");
         //qDebug() << "Group Name" << group;
         // Why do I have to skip the first node here? (shows up empty)
-        n=node.firstChildElement();
+        n = node.firstChildElement();
 
         while (!n.isNull()) {
-            line=n.lineNumber();
-            e=n.toElement();
+            line = n.lineNumber();
+            e = n.toElement();
 
-            if (e.nodeName().toLower()!="channel") {
-                qWarning() << "Ignoring unrecognized schema type "<< e.nodeName() << "in" << filename << "line" << line;
+            if (e.nodeName().toLower() != "channel") {
+                qWarning() << "Ignoring unrecognized schema type " << e.nodeName() << "in" << filename << "line" <<
+                           line;
                 continue;
             }
 
-            ch=n.firstChild();
-            n=n.nextSibling();
+            ch = n.firstChild();
+            n = n.nextSibling();
+
+            idtxt = e.attribute("id");
+            id = idtxt.toInt(&ok, 16);
 
-            idtxt=e.attribute("id");
-            id=idtxt.toInt(&ok,16);
             if (!ok) {
-                qWarning() << "Dodgy ID number "<< e.nodeName() << "in" << filename << "line" << line;
+                qWarning() << "Dodgy ID number " << e.nodeName() << "in" << filename << "line" << line;
                 continue;
             }
 
-            chantype=e.attribute("class","data").toLower();
+            chantype = e.attribute("class", "data").toLower();
+
             if (!ChanTypes.contains(chantype)) {
-                qWarning() << "Dodgy class "<< chantype << "in" << filename << "line" << line;
+                qWarning() << "Dodgy class " << chantype << "in" << filename << "line" << line;
                 continue;
             }
-            type=ChanTypes[chantype];
 
-            scopestr=e.attribute("scope","session");
-            if (scopestr.at(0)==QChar('!')) {
-                scopestr=scopestr.mid(1);
+            type = ChanTypes[chantype];
+
+            scopestr = e.attribute("scope", "session");
+
+            if (scopestr.at(0) == QChar('!')) {
+                scopestr = scopestr.mid(1);
                 //multi=true;
             } //multi=false;
+
             if (!Scopes.contains(scopestr)) {
-                qWarning() << "Dodgy Scope "<< scopestr << "in" << filename << "line" << line;
+                qWarning() << "Dodgy Scope " << scopestr << "in" << filename << "line" << line;
                 continue;
             }
-            scope=Scopes[scopestr];
-            name=e.attribute("name","");
-            details=e.attribute("details","");
-            label=e.attribute("label","");
+
+            scope = Scopes[scopestr];
+            name = e.attribute("name", "");
+            details = e.attribute("details", "");
+            label = e.attribute("label", "");
 
             if (name.isEmpty() || details.isEmpty() || label.isEmpty()) {
                 qWarning() << "Missing name,details or label attribute in" << filename << "line" << line;
                 continue;
             }
-            unit=e.attribute("unit");
 
-            defcolor=e.attribute("color","black");
-            color=QColor(defcolor);
+            unit = e.attribute("unit");
+
+            defcolor = e.attribute("color", "black");
+            color = QColor(defcolor);
+
             if (!color.isValid()) {
-                qWarning() << "Invalid Color "<< defcolor<< "in" << filename << "line" << line;
-                color=Qt::black;
+                qWarning() << "Invalid Color " << defcolor << "in" << filename << "line" << line;
+                color = Qt::black;
             }
 
-            datatypestr=e.attribute("type","").toLower();
+            datatypestr = e.attribute("type", "").toLower();
+
+            link = e.attribute("link", "");
 
-            link=e.attribute("link","");
             if (!link.isEmpty()) {
-                linkid=link.toInt(&ok,16);
+                linkid = link.toInt(&ok, 16);
+
                 if (!ok) {
-                    qWarning() << "Dodgy Link ID number "<< e.nodeName() << "in" << filename << " line" << line;
+                    qWarning() << "Dodgy Link ID number " << e.nodeName() << "in" << filename << " line" << line;
                 }
-            } else linkid=0;
+            } else { linkid = 0; }
 
             if (DataTypes.contains(datatypestr)) {
-                datatype=DataTypes[typestr];
+                datatype = DataTypes[typestr];
             } else {
-                qWarning() << "Ignoring unrecognized schema datatype in" << filename <<"line" << line;
+                qWarning() << "Ignoring unrecognized schema datatype in" << filename << "line" << line;
                 continue;
             }
 
             if (channels.contains(id)) {
-                qWarning() << "Schema already contains id" << id << "in" << filename <<"line" << line;
+                qWarning() << "Schema already contains id" << id << "in" << filename << "line" << line;
                 continue;
             }
+
             if (names.contains(name)) {
-                qWarning() << "Schema already contains name" << name << "in" << filename <<"line" << line;
+                qWarning() << "Schema already contains name" << name << "in" << filename << "line" << line;
                 continue;
             }
-            chan=new Channel(id,type,scope,name,name,details,label,unit,datatype,color,linkid);
-            channels[id]=chan;
-            names[name]=chan;
+
+            chan = new Channel(id, type, scope, name, name, details, label, unit, datatype, color, linkid);
+            channels[id] = chan;
+            names[name] = chan;
             //qDebug() << "Channel" << id << name << label;
-            groups[group][name]=chan;
-            if (linkid>0) {
+            groups[group][name] = chan;
+
+            if (linkid > 0) {
                 if (channels.contains(linkid)) {
-                    Channel *it=channels[linkid];
+                    Channel *it = channels[linkid];
                     it->m_links.push_back(chan);
                     //int i=0;
                 } else {
-                    qWarning() << "Linked channel must be defined first in" << filename <<"line" << line;
+                    qWarning() << "Linked channel must be defined first in" << filename << "line" << line;
                 }
             }
 
             // process children
-            while(!ch.isNull()) {
-                e=ch.toElement();
-                QString sub=ch.nodeName().toLower();
-                QString id2str,name2str;
+            while (!ch.isNull()) {
+                e = ch.toElement();
+                QString sub = ch.nodeName().toLower();
+                QString id2str, name2str;
                 int id2;
-                if (sub=="option") {
-                    id2str=e.attribute("id");
-                    id2=id2str.toInt(&ok,10);
-                    name2str=e.attribute("value");
+
+                if (sub == "option") {
+                    id2str = e.attribute("id");
+                    id2 = id2str.toInt(&ok, 10);
+                    name2str = e.attribute("value");
                     //qDebug() << sub << id2 << name2str;
-                    chan->addOption(id2,name2str);
-                } else if (sub=="color") {
+                    chan->addOption(id2, name2str);
+                } else if (sub == "color") {
                 }
-                ch=ch.nextSibling();
+
+                ch = ch.nextSibling();
             }
         }
     }
@@ -507,24 +687,28 @@ bool ChannelList::Load(QString filename)
     return true;
 }
 
-void ChannelList::add(QString group,Channel * chan)
+void ChannelList::add(QString group, Channel *chan)
 {
-    Q_ASSERT(chan!=NULL);
+    Q_ASSERT(chan != NULL);
+
     if (channels.contains(chan->id())) {
         qWarning() << "Channels already contains id" << chan->id() << chan->code();
         Q_ASSERT(false);
         return;
     }
+
     if (names.contains(chan->code())) {
         qWarning() << "Channels already contains name" << chan->id() << chan->code();
         Q_ASSERT(false);
         return;
     }
-    channels[chan->id()]=chan;
-    names[chan->code()]=chan;
-    groups[group][chan->code()]=chan;
+
+    channels[chan->id()] = chan;
+    names[chan->code()] = chan;
+    groups[group][chan->code()] = chan;
+
     if (channels.contains(chan->linkid())) {
-        Channel *it=channels[chan->linkid()];
+        Channel *it = channels[chan->linkid()];
         it->m_links.push_back(chan);
         //int i=0;
     } else {
diff --git a/sleepyhead/SleepLib/schema.h b/sleepyhead/SleepLib/schema.h
index 6fe8e341..76af9ae2 100644
--- a/sleepyhead/SleepLib/schema.h
+++ b/sleepyhead/SleepLib/schema.h
@@ -19,29 +19,29 @@
 #include "machine_common.h"
 
 namespace GraphFlags {
-const quint32 Shadow=1;
-const quint32 Foobar=2;
-const quint32 XTicker=4;
-const quint32 YTicker=8;
-const quint32 XGrid=16;
-const quint32 YGrid=32;
+const quint32 Shadow = 1;
+const quint32 Foobar = 2;
+const quint32 XTicker = 4;
+const quint32 YTicker = 8;
+const quint32 XGrid = 16;
+const quint32 YGrid = 32;
 }
 
 namespace schema {
 
 enum Function {
-    NONE=0, AVG, WAVG, MIN, MAX, SUM, CNT, P90, CPH, SPH, HOURS, SET
+    NONE = 0, AVG, WAVG, MIN, MAX, SUM, CNT, P90, CPH, SPH, HOURS, SET
 };
 
 enum ChanType {
-    DATA=0, SETTING
+    DATA = 0, SETTING
 };
 
 enum DataType {
-    DEFAULT=0, INTEGER, BOOL, DOUBLE, STRING, RICHTEXT, DATE, TIME, DATETIME
+    DEFAULT = 0, INTEGER, BOOL, DOUBLE, STRING, RICHTEXT, DATE, TIME, DATETIME
 };
 enum ScopeType {
-    GLOBAL=0, MACHINE, DAY, SESSION
+    GLOBAL = 0, MACHINE, DAY, SESSION
 };
 class Channel;
 extern Channel EmptyChannel;
@@ -51,36 +51,40 @@ extern Channel EmptyChannel;
     */
 class Channel
 {
-public:
-    Channel() { m_id=0; }
-    Channel(ChannelID id, ChanType type, ScopeType scope, QString code, QString fullname, QString description, QString label, QString unit,DataType datatype=DEFAULT, QColor=Qt::black, int link=0);
-    void addColor(Function f, QColor color) { m_colors[f]=color; }
-    void addOption(int i, QString option) { m_options[i]=option; }
+  public:
+    Channel() { m_id = 0; }
+    Channel(ChannelID id, ChanType type, ScopeType scope, QString code, QString fullname,
+            QString description, QString label, QString unit, DataType datatype = DEFAULT, QColor = Qt::black,
+            int link = 0);
+    void addColor(Function f, QColor color) { m_colors[f] = color; }
+    void addOption(int i, QString option) { m_options[i] = option; }
 
-    const int & id() { return m_id; }
-    const ChanType & type() { return m_type; }
-    const QString & code() { return m_code; }
-    const QString & fullname() { return m_fullname; }
-    const QString & description() { return m_description; }
-    const QString & label() { return m_label; }
-    const QString & units() { return m_unit; }
-    const int & linkid() { return m_link; }
+    const int &id() { return m_id; }
+    const ChanType &type() { return m_type; }
+    const QString &code() { return m_code; }
+    const QString &fullname() { return m_fullname; }
+    const QString &description() { return m_description; }
+    const QString &label() { return m_label; }
+    const QString &units() { return m_unit; }
+    const int &linkid() { return m_link; }
 
-    void setLabel(QString label) { m_label=label; }
-    void setUnit(QString unit) { m_unit=unit; }
-    void setDescription(QString desc) { m_description=desc; }
+    void setLabel(QString label) { m_label = label; }
+    void setUnit(QString unit) { m_unit = unit; }
+    void setDescription(QString desc) { m_description = desc; }
     QString option(int i) {
-        if (m_options.contains(i))
+        if (m_options.contains(i)) {
             return m_options[i];
+        }
+
         return QString();
     }
-    QColor & defaultColor() { return m_defaultcolor; }
-    void setDefaultColor(QColor color) { m_defaultcolor=color; }
-    QHash<int,QString> m_options;
-    QHash<Function,QColor> m_colors;
+    QColor &defaultColor() { return m_defaultcolor; }
+    void setDefaultColor(QColor color) { m_defaultcolor = color; }
+    QHash<int, QString> m_options;
+    QHash<Function, QColor> m_colors;
     QList<Channel *> m_links;              // better versions of this data type
     bool isNull();
-protected:
+  protected:
     int m_id;
     ChanType m_type;
     ScopeType m_scope;
@@ -101,7 +105,7 @@ protected:
     */
 class ChannelList
 {
-public:
+  public:
     ChannelList();
     virtual ~ChannelList();
 
@@ -111,31 +115,33 @@ public:
     //! \brief Stores Channel list to XML file specified by filename
     bool Save(QString filename);
 
-    void add(QString group,Channel * chan);
+    void add(QString group, Channel *chan);
 
     //! \brief Looks up Channel in this List with the index idx, returns EmptyChannel if not found
-    Channel & operator[](ChannelID idx) {
-        if (channels.contains(idx))
+    Channel &operator[](ChannelID idx) {
+        if (channels.contains(idx)) {
             return *channels[idx];
-        else
+        } else {
             return EmptyChannel;
+        }
     }
     //! \brief Looks up Channel from this list by name, returns Empty Channel if not found.
-    Channel & operator[](QString name) {
-        if (names.contains(name))
+    Channel &operator[](QString name) {
+        if (names.contains(name)) {
             return *names[name];
-        else
+        } else {
             return EmptyChannel;
+        }
     }
 
     //! \brief Channel List indexed by integer ID
-    QHash<ChannelID,Channel *> channels;
+    QHash<ChannelID, Channel *> channels;
 
     //! \brief Channel List index by name
-    QHash<QString,Channel *> names;
+    QHash<QString, Channel *> names;
 
     //! \brief Channel List indexed by group
-    QHash<QString,QHash<QString,Channel *> > groups;
+    QHash<QString, QHash<QString, Channel *> > groups;
     QString m_doctype;
 };
 extern ChannelList channel;
diff --git a/sleepyhead/SleepLib/session.cpp b/sleepyhead/SleepLib/session.cpp
index a7bfd8c4..0500a4c8 100644
--- a/sleepyhead/SleepLib/session.cpp
+++ b/sleepyhead/SleepLib/session.cpp
@@ -24,30 +24,32 @@
 using namespace std;
 
 
-const quint16 filetype_summary=0;
-const quint16 filetype_data=1;
+const quint16 filetype_summary = 0;
+const quint16 filetype_data = 1;
 
 // This is the uber important database version for SleepyHeads internal storage
 // Increment this after stuffing with Session's save & load code.
-const quint16 summary_version=12;
-const quint16 events_version=10;
+const quint16 summary_version = 12;
+const quint16 events_version = 10;
 
-Session::Session(Machine * m,SessionID session)
+Session::Session(Machine *m, SessionID session)
 {
-    s_lonesession=false;
-    if (!session) {
-        session=m->CreateSessionID();
-    }
-    s_machine=m;
-    s_session=session;
-    s_changed=false;
-    s_events_loaded=false;
-    _first_session=true;
-    s_enabled=-1;
+    s_lonesession = false;
 
-    s_first=s_last=0;
-    s_eventfile="";
-    s_evchecksum_checked=false;
+    if (!session) {
+        session = m->CreateSessionID();
+    }
+
+    s_machine = m;
+    s_session = session;
+    s_changed = false;
+    s_events_loaded = false;
+    _first_session = true;
+    s_enabled = -1;
+
+    s_first = s_last = 0;
+    s_eventfile = "";
+    s_evchecksum_checked = false;
 
 }
 Session::~Session()
@@ -58,28 +60,35 @@ Session::~Session()
 void Session::TrashEvents()
 // Trash this sessions Events and release memory.
 {
-    QHash<ChannelID,QVector<EventList *> >::iterator i;
+    QHash<ChannelID, QVector<EventList *> >::iterator i;
     QVector<EventList *>::iterator j;
-    for (i=eventlist.begin(); i!=eventlist.end(); i++) {
-        for (j=i.value().begin(); j!=i.value().end(); j++) {
+
+    for (i = eventlist.begin(); i != eventlist.end(); i++) {
+        for (j = i.value().begin(); j != i.value().end(); j++) {
             delete *j;
         }
     }
-    s_events_loaded=false;
+
+    s_events_loaded = false;
     eventlist.clear();
 }
 
 //const int max_pack_size=128;
-bool Session::OpenEvents() {
-    if (s_events_loaded)
+bool Session::OpenEvents()
+{
+    if (s_events_loaded) {
         return true;
+    }
 
-    s_events_loaded=eventlist.size() > 0;
-    if (s_events_loaded)
+    s_events_loaded = eventlist.size() > 0;
+
+    if (s_events_loaded) {
         return true;
+    }
 
     if (!s_eventfile.isEmpty()) {
-        bool b=LoadEvents(s_eventfile);
+        bool b = LoadEvents(s_eventfile);
+
         if (!b) {
             qWarning() << "Error Unpacking Events" << s_eventfile;
             return false;
@@ -87,7 +96,7 @@ bool Session::OpenEvents() {
     }
 
 
-    return s_events_loaded=true;
+    return s_events_loaded = true;
 }
 
 bool Session::Store(QString path)
@@ -95,27 +104,31 @@ bool Session::Store(QString path)
 // {DataDir}/{MachineID}/{SessionID}.{ext}
 {
     QDir dir(path);
-    if (!dir.exists(path))
+
+    if (!dir.exists(path)) {
         dir.mkpath(path);
+    }
 
     QString base;
-    base.sprintf("%08lx",s_session);
-    base=path+"/"+base;
+    base.sprintf("%08lx", s_session);
+    base = path + "/" + base;
     //qDebug() << "Storing Session: " << base;
     bool a;
-    a=StoreSummary(base+".000"); // if actually has events
+    a = StoreSummary(base + ".000"); // if actually has events
+
     //qDebug() << " Summary done";
-    if (eventlist.size()>0) {
-        s_eventfile=base+".001";
+    if (eventlist.size() > 0) {
+        s_eventfile = base + ".001";
         StoreEvents(s_eventfile);
     } else { // who cares..
         //qDebug() << "Trying to save empty events file";
     }
-    //qDebug() << " Events done";
-    s_changed=false;
-    s_events_loaded=true;
 
-        //TrashEvents();
+    //qDebug() << " Events done";
+    s_changed = false;
+    s_events_loaded = true;
+
+    //TrashEvents();
     //} else {
     //    qDebug() << "Session::Store() No event data saved" << s_session;
     //}
@@ -173,6 +186,7 @@ bool Session::LoadSummary(QString filename)
     }
 
     QFile file(filename);
+
     if (!file.open(QIODevice::ReadOnly)) {
         qDebug() << "Couldn't open summary file" << filename;
         return false;
@@ -188,21 +202,25 @@ bool Session::LoadSummary(QString filename)
     //QHash<ChannelID,MCDataType> mctype;
     //QVector<ChannelID> mcorder;
     in >> t32;
-    if (t32!=magic) {
+
+    if (t32 != magic) {
         qDebug() << "Wrong magic number in " << filename;
         return false;
     }
 
     quint16 version;
     in >> version;      // DB Version
-    if (version<6) {
+
+    if (version < 6) {
         //throw OldDBVersion();
-        qWarning() << "Old dbversion "<< version << "summary file.. Sorry, you need to purge and reimport";
+        qWarning() << "Old dbversion " << version <<
+                   "summary file.. Sorry, you need to purge and reimport";
         return false;
     }
 
     in >> t16;      // File Type
-    if (t16!=filetype_summary) {
+
+    if (t16 != filetype_summary) {
         qDebug() << "Wrong file type"; //wrong file type
         return false;
     }
@@ -210,91 +228,114 @@ bool Session::LoadSummary(QString filename)
 
     qint32 ts32;
     in >> ts32;      // MachineID (dont need this result)
-    if (ts32!=s_machine->id()) {
-        qWarning() << "Machine ID does not match in" << filename << " I will try to load anyway in case you know what your doing.";
+
+    if (ts32 != s_machine->id()) {
+        qWarning() << "Machine ID does not match in" << filename <<
+                   " I will try to load anyway in case you know what your doing.";
     }
 
     in >> t32;      // Sessionid;
-    s_session=t32;
+    s_session = t32;
 
     in >> s_first;  // Start time
     in >> s_last;   // Duration // (16bit==Limited to 18 hours)
 
-    QHash<ChannelID,EventDataType> cruft;
+    QHash<ChannelID, EventDataType> cruft;
 
-    if (version<7) {
+    if (version < 7) {
         // This code is deprecated.. just here incase anyone tries anything crazy...
-        QHash<QString,QVariant> v1;
+        QHash<QString, QVariant> v1;
         in >> v1;
         settings.clear();
         ChannelID code;
-        for (QHash<QString,QVariant>::iterator i=v1.begin();i!=v1.end();i++) {
-            code=schema::channel[i.key()].id();
-            settings[code]=i.value();
+
+        for (QHash<QString, QVariant>::iterator i = v1.begin(); i != v1.end(); i++) {
+            code = schema::channel[i.key()].id();
+            settings[code] = i.value();
         }
-        QHash<QString,int> zcnt;
+
+        QHash<QString, int> zcnt;
         in >> zcnt;
-        for (QHash<QString,int>::iterator i=zcnt.begin();i!=zcnt.end();i++) {
-            code=schema::channel[i.key()].id();
-            m_cnt[code]=i.value();
+
+        for (QHash<QString, int>::iterator i = zcnt.begin(); i != zcnt.end(); i++) {
+            code = schema::channel[i.key()].id();
+            m_cnt[code] = i.value();
         }
-        QHash<QString,double> zsum;
+
+        QHash<QString, double> zsum;
         in >> zsum;
-        for (QHash<QString,double>::iterator i=zsum.begin();i!=zsum.end();i++) {
-            code=schema::channel[i.key()].id();
-            m_cnt[code]=i.value();
+
+        for (QHash<QString, double>::iterator i = zsum.begin(); i != zsum.end(); i++) {
+            code = schema::channel[i.key()].id();
+            m_cnt[code] = i.value();
         }
-        QHash<QString,EventDataType> ztmp;
+
+        QHash<QString, EventDataType> ztmp;
         in >> ztmp; // avg
-        for (QHash<QString,EventDataType>::iterator i=ztmp.begin();i!=ztmp.end();i++) {
-            code=schema::channel[i.key()].id();
-            m_avg[code]=i.value();
+
+        for (QHash<QString, EventDataType>::iterator i = ztmp.begin(); i != ztmp.end(); i++) {
+            code = schema::channel[i.key()].id();
+            m_avg[code] = i.value();
         }
+
         ztmp.clear();
         in >> ztmp; // wavg
-        for (QHash<QString,EventDataType>::iterator i=ztmp.begin();i!=ztmp.end();i++) {
-            code=schema::channel[i.key()].id();
-            m_wavg[code]=i.value();
+
+        for (QHash<QString, EventDataType>::iterator i = ztmp.begin(); i != ztmp.end(); i++) {
+            code = schema::channel[i.key()].id();
+            m_wavg[code] = i.value();
         }
+
         ztmp.clear();
         in >> ztmp; // 90p
         ztmp.clear();
         in >> ztmp; // min
-        for (QHash<QString,EventDataType>::iterator i=ztmp.begin();i!=ztmp.end();i++) {
-            code=schema::channel[i.key()].id();
-            m_min[code]=i.value();
+
+        for (QHash<QString, EventDataType>::iterator i = ztmp.begin(); i != ztmp.end(); i++) {
+            code = schema::channel[i.key()].id();
+            m_min[code] = i.value();
         }
+
         ztmp.clear();
         in >> ztmp; // max
-        for (QHash<QString,EventDataType>::iterator i=ztmp.begin();i!=ztmp.end();i++) {
-            code=schema::channel[i.key()].id();
-            m_max[code]=i.value();
+
+        for (QHash<QString, EventDataType>::iterator i = ztmp.begin(); i != ztmp.end(); i++) {
+            code = schema::channel[i.key()].id();
+            m_max[code] = i.value();
         }
 
         ztmp.clear();
         in >> ztmp; // cph
-        for (QHash<QString,EventDataType>::iterator i=ztmp.begin();i!=ztmp.end();i++) {
-            code=schema::channel[i.key()].id();
-            m_cph[code]=i.value();
+
+        for (QHash<QString, EventDataType>::iterator i = ztmp.begin(); i != ztmp.end(); i++) {
+            code = schema::channel[i.key()].id();
+            m_cph[code] = i.value();
         }
+
         ztmp.clear();
         in >> ztmp; // sph
-        for (QHash<QString,EventDataType>::iterator i=ztmp.begin();i!=ztmp.end();i++) {
-            code=schema::channel[i.key()].id();
-            m_sph[code]=i.value();
+
+        for (QHash<QString, EventDataType>::iterator i = ztmp.begin(); i != ztmp.end(); i++) {
+            code = schema::channel[i.key()].id();
+            m_sph[code] = i.value();
         }
-        QHash<QString,quint64> ztim;
+
+        QHash<QString, quint64> ztim;
         in >> ztim; //firstchan
-        for (QHash<QString,quint64>::iterator i=ztim.begin();i!=ztim.end();i++) {
-            code=schema::channel[i.key()].id();
-            m_firstchan[code]=i.value();
+
+        for (QHash<QString, quint64>::iterator i = ztim.begin(); i != ztim.end(); i++) {
+            code = schema::channel[i.key()].id();
+            m_firstchan[code] = i.value();
         }
+
         ztim.clear();
         in >> ztim; // lastchan
-        for (QHash<QString,quint64>::iterator i=ztim.begin();i!=ztim.end();i++) {
-            code=schema::channel[i.key()].id();
-            m_lastchan[code]=i.value();
+
+        for (QHash<QString, quint64>::iterator i = ztim.begin(); i != ztim.end(); i++) {
+            code = schema::channel[i.key()].id();
+            m_lastchan[code] = i.value();
         }
+
         //SetChanged(true);
     } else {
         in >> settings;
@@ -302,9 +343,11 @@ bool Session::LoadSummary(QString filename)
         in >> m_sum;
         in >> m_avg;
         in >> m_wavg;
+
         if (version < 11) {
             cruft.clear();
             in >> cruft; // 90%
+
             if (version >= 10) {
                 cruft.clear();
                 in >> cruft;// med
@@ -312,13 +355,16 @@ bool Session::LoadSummary(QString filename)
                 in >> cruft; //p95
             }
         }
+
         in >> m_min;
         in >> m_max;
+
         // Added 24/10/2013 by MW to support physical graph min/max values
-        if (version>=12) {
+        if (version >= 12) {
             in >> m_physmin;
             in >> m_physmax;
         }
+
         in >> m_cph;
         in >> m_sph;
         in >> m_firstchan;
@@ -327,6 +373,7 @@ bool Session::LoadSummary(QString filename)
         if (version >= 8) {
             in >> m_valuesummary;
             in >> m_timesummary;
+
             if (version >= 9) {
                 in >> m_gain;
             }
@@ -342,10 +389,11 @@ bool Session::LoadSummary(QString filename)
         UpdateSummaries();
         StoreSummary(filename);
     }
+
     return true;
 }
 
-const quint16 compress_method=1;
+const quint16 compress_method = 1;
 
 bool Session::StoreEvents(QString filename)
 {
@@ -353,7 +401,7 @@ bool Session::StoreEvents(QString filename)
     file.open(QIODevice::WriteOnly);
 
     QByteArray headerbytes;
-    QDataStream header(&headerbytes,QIODevice::WriteOnly);
+    QDataStream header(&headerbytes, QIODevice::WriteOnly);
     header.setVersion(QDataStream::Qt_4_6);
     header.setByteOrder(QDataStream::LittleEndian);
 
@@ -365,29 +413,31 @@ bool Session::StoreEvents(QString filename)
     header << s_first;
     header << s_last;
 
-    quint16 compress=0;
+    quint16 compress = 0;
 
-    if (p_profile->session->compressSessionData())
-        compress=compress_method;
+    if (p_profile->session->compressSessionData()) {
+        compress = compress_method;
+    }
 
     header << (quint16)compress;
 
     header << (quint16)s_machine->GetType();// Machine Type
 
     QByteArray databytes;
-    QDataStream out(&databytes,QIODevice::WriteOnly);
+    QDataStream out(&databytes, QIODevice::WriteOnly);
     out.setVersion(QDataStream::Qt_4_6);
     out.setByteOrder(QDataStream::LittleEndian);
 
     out << (qint16)eventlist.size(); // Number of event categories
 
-    QHash<ChannelID,QVector<EventList *> >::iterator i;
+    QHash<ChannelID, QVector<EventList *> >::iterator i;
 
-    for (i=eventlist.begin(); i!=eventlist.end(); i++) {
+    for (i = eventlist.begin(); i != eventlist.end(); i++) {
         out << i.key(); // ChannelID
         out << (qint16)i.value().size();
-        for (int j=0;j<i.value().size();j++) {
-            EventList &e=*i.value()[j];
+
+        for (int j = 0; j < i.value().size(); j++) {
+            EventList &e = *i.value()[j];
             out << e.first();
             out << e.last();
             out << (qint32)e.count();
@@ -399,55 +449,58 @@ bool Session::StoreEvents(QString filename)
             out << e.Max();
             out << e.dimension();
             out << e.hasSecondField();
+
             if (e.hasSecondField()) {
                 out << e.min2();
                 out << e.max2();
             }
         }
     }
-    for (i=eventlist.begin(); i!=eventlist.end(); i++) {
-        for (int j=0;j<i.value().size();j++) {
-            EventList &e=*i.value()[j];
+
+    for (i = eventlist.begin(); i != eventlist.end(); i++) {
+        for (int j = 0; j < i.value().size(); j++) {
+            EventList &e = *i.value()[j];
             // ****** This is assuming little endian ******
 
             // Store the raw event list data in EventStoreType (16bit short)
-            EventStoreType *ptr=e.m_data.data();
-            out.writeRawData((char *)ptr,e.count() << 1);
+            EventStoreType *ptr = e.m_data.data();
+            out.writeRawData((char *)ptr, e.count() << 1);
 
             //*** Don't delete these comments ***
-//            for (quint32 c=0;c<e.count();c++) {
-//                out << *ptr++;//e.raw(c);
-//            }
+            //            for (quint32 c=0;c<e.count();c++) {
+            //                out << *ptr++;//e.raw(c);
+            //            }
 
             // Store the second field, only if there
             if (e.hasSecondField()) {
-                ptr=e.m_data2.data();
-                out.writeRawData((char *)ptr,e.count() << 1);
+                ptr = e.m_data2.data();
+                out.writeRawData((char *)ptr, e.count() << 1);
                 //*** Don't delete these comments ***
-//                for (quint32 c=0;c<e.count();c++) {
-//                    out << *ptr++; //e.raw2(c);
-//                }
+                //                for (quint32 c=0;c<e.count();c++) {
+                //                    out << *ptr++; //e.raw2(c);
+                //                }
             }
 
             // Store the time delta fields for non-waveform EventLists
-            if (e.type()!=EVL_Waveform) {
-                quint32 * tptr=e.m_time.data();
-                out.writeRawData((char *)tptr,e.count() << 2);
+            if (e.type() != EVL_Waveform) {
+                quint32 *tptr = e.m_time.data();
+                out.writeRawData((char *)tptr, e.count() << 2);
                 //*** Don't delete these comments ***
-//                for (quint32 c=0;c<e.count();c++) {
-//                    out << *tptr++; //e.getTime()[c];
-//                }
+                //                for (quint32 c=0;c<e.count();c++) {
+                //                    out << *tptr++; //e.getTime()[c];
+                //                }
             }
         }
     }
 
-    qint32 datasize=databytes.size();
+    qint32 datasize = databytes.size();
 
     // Checksum the _uncompressed_ data
-    quint16 chk=0;
+    quint16 chk = 0;
+
     if (compress) {
         // This checksum is hideously slow.. only using during compression, and not sure I should at all :-/
-        chk=qChecksum(databytes.data(),databytes.size());
+        chk = qChecksum(databytes.data(), databytes.size());
     }
 
     header << datasize;
@@ -455,10 +508,10 @@ bool Session::StoreEvents(QString filename)
 
     QByteArray data;
 
-    if (compress>0) {
-        data=qCompress(databytes);
+    if (compress > 0) {
+        data = qCompress(databytes);
     } else {
-        data=databytes;
+        data = databytes;
     }
 
     file.write(headerbytes);
@@ -468,8 +521,8 @@ bool Session::StoreEvents(QString filename)
 }
 bool Session::LoadEvents(QString filename)
 {
-    quint32 magicnum,machid,sessid;
-    quint16 version,type,crc16,machtype,compmethod;
+    quint32 magicnum, machid, sessid;
+    quint16 version, type, crc16, machtype, compmethod;
     quint8 t8;
     qint32 datasize;
 
@@ -479,12 +532,13 @@ bool Session::LoadEvents(QString filename)
     }
 
     QFile file(filename);
+
     if (!file.open(QIODevice::ReadOnly)) {
         qDebug() << "Couldn't open file" << filename;
         return false;
     }
 
-    QByteArray headerbytes=file.read(42);
+    QByteArray headerbytes = file.read(42);
 
     QDataStream header(headerbytes);
     header.setVersion(QDataStream::Qt_4_6);
@@ -498,22 +552,22 @@ bool Session::LoadEvents(QString filename)
     header >> s_first;          //(qint64)
     header >> s_last;           //(qint64)
 
-    if (type!=filetype_data) {
+    if (type != filetype_data) {
         qDebug() << "Wrong File Type in " << filename;
         return false;
     }
 
-    if (magicnum!=magic) {
-         qWarning() << "Wrong Magic number in " << filename;
-         return false;
+    if (magicnum != magic) {
+        qWarning() << "Wrong Magic number in " << filename;
+        return false;
     }
 
-    if (version<6) {    // prior to version 6 is too old to deal with
+    if (version < 6) {  // prior to version 6 is too old to deal with
         qDebug() << "Old File Version, can't open file";
         return false;
     }
 
-    if (version<10) {
+    if (version < 10) {
         file.seek(32);
     } else {
         header >> compmethod;   // Compression Method (quint16)
@@ -522,28 +576,32 @@ bool Session::LoadEvents(QString filename)
         header >> crc16;        // CRC16 of Uncompressed Data (quint16)
     }
 
-    QByteArray databytes,temp=file.readAll();
+    QByteArray databytes, temp = file.readAll();
     file.close();
 
-    if (version>=10) {
-        if (compmethod>0) {
-            databytes=qUncompress(temp);
+    if (version >= 10) {
+        if (compmethod > 0) {
+            databytes = qUncompress(temp);
+
             if (!s_evchecksum_checked) {
-                if (databytes.size()!=datasize) {
+                if (databytes.size() != datasize) {
                     qDebug() << "File" << filename << "has returned wrong datasize";
                     return false;
                 }
-                quint16 crc=qChecksum(databytes.data(),databytes.size());
-                if (crc!=crc16) {
+
+                quint16 crc = qChecksum(databytes.data(), databytes.size());
+
+                if (crc != crc16) {
                     qDebug() << "CRC Doesn't match in" << filename;
                     return false;
                 }
-                s_evchecksum_checked=true;
+
+                s_evchecksum_checked = true;
             }
         } else {
-            databytes=temp;
+            databytes = temp;
         }
-    } else databytes=temp;
+    } else { databytes = temp; }
 
     QDataStream in(databytes);
     in.setVersion(QDataStream::Qt_4_6);
@@ -553,51 +611,56 @@ bool Session::LoadEvents(QString filename)
     in >> mcsize;   // number of Machine Code lists
 
     ChannelID code;
-    qint64 ts1,ts2;
+    qint64 ts1, ts2;
     qint32 evcount;
     EventListType elt;
-    EventDataType rate,gain,offset,mn,mx;
+    EventDataType rate, gain, offset, mn, mx;
     qint16 size2;
     QVector<ChannelID> mcorder;
     QVector<qint16> sizevec;
     QString dim;
-    for (int i=0;i<mcsize;i++) {
-        if (version<8) {
+
+    for (int i = 0; i < mcsize; i++) {
+        if (version < 8) {
             QString txt;
             in >> txt;
-            code=schema::channel[txt].id();
+            code = schema::channel[txt].id();
         } else {
             in >> code;
         }
+
         mcorder.push_back(code);
         in >> size2;
         sizevec.push_back(size2);
-        for (int j=0;j<size2;j++) {
+
+        for (int j = 0; j < size2; j++) {
             in >> ts1;
             in >> ts2;
             in >> evcount;
             in >> t8;
-            elt=(EventListType)t8;
+            elt = (EventListType)t8;
             in >> rate;
             in >> gain;
             in >> offset;
             in >> mn;
             in >> mx;
             in >> dim;
-            bool second_field=false;
-            if (version>=7) // version 7 added this field
-                in >> second_field;
+            bool second_field = false;
 
-            EventList *elist=AddEventList(code,elt,gain,offset,mn,mx,rate,second_field);
+            if (version >= 7) { // version 7 added this field
+                in >> second_field;
+            }
+
+            EventList *elist = AddEventList(code, elt, gain, offset, mn, mx, rate, second_field);
             elist->setDimension(dim);
 
             //eventlist[code].push_back(elist);
-            elist->m_count=evcount;
-            elist->m_first=ts1;
-            elist->m_last=ts2;
+            elist->m_count = evcount;
+            elist->m_first = ts1;
+            elist->m_last = ts2;
 
             if (second_field) {
-                EventDataType min,max;
+                EventDataType min, max;
                 in >> min;
                 in >> max;
                 elist->setMin2(min);
@@ -609,64 +672,71 @@ bool Session::LoadEvents(QString filename)
     //EventStoreType t;
     //quint32 x;
 
-    for (int i=0;i<mcsize;i++) {
-        code=mcorder[i];
-        size2=sizevec[i];
-        for (int j=0;j<size2;j++) {
-            EventList &evec=*eventlist[code][j];
+    for (int i = 0; i < mcsize; i++) {
+        code = mcorder[i];
+        size2 = sizevec[i];
+
+        for (int j = 0; j < size2; j++) {
+            EventList &evec = *eventlist[code][j];
             evec.m_data.resize(evec.m_count);
-            EventStoreType *ptr=evec.m_data.data();
+            EventStoreType *ptr = evec.m_data.data();
 
             // ****** This is assuming little endian ******
 
             in.readRawData((char *)ptr, evec.m_count << 1);
+
             //*** Don't delete these comments ***
-//            for (quint32 c=0;c<evec.m_count;c++) {
-//                in >> t;
-//                *ptr++=t;
-//            }
+            //            for (quint32 c=0;c<evec.m_count;c++) {
+            //                in >> t;
+            //                *ptr++=t;
+            //            }
             if (evec.hasSecondField()) {
                 evec.m_data2.resize(evec.m_count);
-                ptr=evec.m_data2.data();
+                ptr = evec.m_data2.data();
 
-                in.readRawData((char *)ptr,evec.m_count << 1);
+                in.readRawData((char *)ptr, evec.m_count << 1);
                 //*** Don't delete these comments ***
-//                for (quint32 c=0;c<evec.m_count;c++) {
-//                    in >> t;
-//                    *ptr++=t;
-//                }
+                //                for (quint32 c=0;c<evec.m_count;c++) {
+                //                    in >> t;
+                //                    *ptr++=t;
+                //                }
             }
-            if (evec.type()!=EVL_Waveform) {
-                evec.m_time.resize(evec.m_count);
-                quint32 * tptr=evec.m_time.data();
 
-                in.readRawData((char *)tptr,evec.m_count << 2);
+            if (evec.type() != EVL_Waveform) {
+                evec.m_time.resize(evec.m_count);
+                quint32 *tptr = evec.m_time.data();
+
+                in.readRawData((char *)tptr, evec.m_count << 2);
                 //*** Don't delete these comments ***
-//                for (quint32 c=0;c<evec.m_count;c++) {
-//                    in >> x;
-//                    *tptr++=x;
-//                }
+                //                for (quint32 c=0;c<evec.m_count;c++) {
+                //                    in >> x;
+                //                    *tptr++=x;
+                //                }
             }
         }
     }
 
-    if (version<events_version) {
+    if (version < events_version) {
         qDebug() << "Upgrading Events file" << filename << "to version" << events_version;
         UpdateSummaries();
         StoreEvents(filename);
     }
+
     return true;
 }
 
 void Session::destroyEvent(ChannelID code)
 {
-    QHash<ChannelID,QVector<EventList *> >::iterator it=eventlist.find(code);
-    if (it!=eventlist.end()) {
-        for (int i=0;i<it.value().size();i++) {
+    QHash<ChannelID, QVector<EventList *> >::iterator it = eventlist.find(code);
+
+    if (it != eventlist.end()) {
+        for (int i = 0; i < it.value().size(); i++) {
             delete it.value()[i];
         }
+
         eventlist.erase(it);
     }
+
     m_gain.erase(m_gain.find(code));
     m_firstchan.erase(m_firstchan.find(code));
     m_lastchan.erase(m_lastchan.find(code));
@@ -685,78 +755,85 @@ void Session::destroyEvent(ChannelID code)
 
 void Session::updateCountSummary(ChannelID code)
 {
-    QHash<ChannelID,QVector<EventList *> >::iterator ev=eventlist.find(code);
-    if (ev==eventlist.end()) return;
+    QHash<ChannelID, QVector<EventList *> >::iterator ev = eventlist.find(code);
 
-    QHash<ChannelID,QHash<EventStoreType, EventStoreType> >::iterator vs=m_valuesummary.find(code);
-    if (vs!=m_valuesummary.end()) // already calculated?
+    if (ev == eventlist.end()) { return; }
+
+    QHash<ChannelID, QHash<EventStoreType, EventStoreType> >::iterator vs = m_valuesummary.find(code);
+
+    if (vs != m_valuesummary.end()) { // already calculated?
         return;
+    }
 
     QHash<EventStoreType, EventStoreType> valsum;
     QHash<EventStoreType, quint32> timesum;
 
-    EventDataType raw,lastraw=0;
-    qint64 start,time,lasttime=0;
-    qint32 len,cnt;
-    quint32 * tptr;
-    EventStoreType * dptr, * eptr;
-    for (int i=0;i<ev.value().size();i++) {
-        EventList & e=*(ev.value()[i]);
-        start=e.first();
-        cnt=e.count();
-        dptr=e.rawData();
-        eptr=dptr+cnt;
+    EventDataType raw, lastraw = 0;
+    qint64 start, time, lasttime = 0;
+    qint32 len, cnt;
+    quint32 *tptr;
+    EventStoreType *dptr, * eptr;
 
-        EventDataType rate=0;
+    for (int i = 0; i < ev.value().size(); i++) {
+        EventList &e = *(ev.value()[i]);
+        start = e.first();
+        cnt = e.count();
+        dptr = e.rawData();
+        eptr = dptr + cnt;
 
-        m_gain[code]=e.gain();
+        EventDataType rate = 0;
 
-        if (e.type()==EVL_Event) {
-            lastraw=*dptr++;
-            tptr=e.rawTime();
-            lasttime=start + *tptr++;
+        m_gain[code] = e.gain();
+
+        if (e.type() == EVL_Event) {
+            lastraw = *dptr++;
+            tptr = e.rawTime();
+            lasttime = start + *tptr++;
             // Event version
 
-            for (;dptr < eptr; dptr++) {
-                 time=start + *tptr++;
-                 raw=*dptr;
+            for (; dptr < eptr; dptr++) {
+                time = start + *tptr++;
+                raw = *dptr;
 
-                 valsum[raw]++;
+                valsum[raw]++;
 
-                 // elapsed time in seconds since last event occurred
-                 len=(time-lasttime) / 1000L;
+                // elapsed time in seconds since last event occurred
+                len = (time - lasttime) / 1000L;
 
-                 timesum[lastraw]+=len;
+                timesum[lastraw] += len;
 
-                 lastraw=raw;
-                 lasttime=time;
+                lastraw = raw;
+                lasttime = time;
             }
         } else {
             // Waveform version, first just count
-            for (;dptr < eptr; dptr++) {
-                raw=*dptr;
+            for (; dptr < eptr; dptr++) {
+                raw = *dptr;
                 valsum[raw]++;
             }
 
             // Then process the list of values, time is simply (rate * count)
-            rate=e.rate();
+            rate = e.rate();
             EventDataType t;
-            for (QHash<EventStoreType, EventStoreType>::iterator it=valsum.begin(); it!=valsum.end(); it++) {
-                t=EventDataType(it.value())*rate;
-                timesum[it.key()]+=t;
+
+            for (QHash<EventStoreType, EventStoreType>::iterator it = valsum.begin(); it != valsum.end();
+                    it++) {
+                t = EventDataType(it.value()) * rate;
+                timesum[it.key()] += t;
             }
         }
     }
-    if (valsum.size()==0) return;
 
-    m_valuesummary[code]=valsum;
-    m_timesummary[code]=timesum;
+    if (valsum.size() == 0) { return; }
+
+    m_valuesummary[code] = valsum;
+    m_timesummary[code] = timesum;
 }
 
 void Session::UpdateSummaries()
 {
     ChannelID id;
-    QHash<ChannelID,QVector<EventList *> >::iterator c;
+    QHash<ChannelID, QVector<EventList *> >::iterator c;
     calcAHIGraph(this);
 
     // Calculates RespRate and related waveforms (Tv, MV, Te, Ti) if missing
@@ -766,25 +843,32 @@ void Session::UpdateSummaries()
     calcSPO2Drop(this);
     calcPulseChange(this);
 
-    for (c=eventlist.begin();c!=eventlist.end();c++) {
-        id=c.key();
-        if (schema::channel[id].type()==schema::DATA) {
+    for (c = eventlist.begin(); c != eventlist.end(); c++) {
+        id = c.key();
+
+        if (schema::channel[id].type() == schema::DATA) {
             //sum(id); // avg calculates this and cnt.
-            if (c.value().size()>0) {
-                EventList * el=c.value()[0];
-                EventDataType gain=el->gain();
-                m_gain[id]=gain;
+            if (c.value().size() > 0) {
+                EventList *el = c.value()[0];
+                EventDataType gain = el->gain();
+                m_gain[id] = gain;
             }
-            if (!((id==CPAP_FlowRate) || (id==CPAP_MaskPressureHi) || (id==CPAP_RespEvent) || (id==CPAP_MaskPressure)))
+
+            if (!((id == CPAP_FlowRate) || (id == CPAP_MaskPressureHi) || (id == CPAP_RespEvent)
+                    || (id == CPAP_MaskPressure))) {
                 updateCountSummary(id);
+            }
 
             Min(id);
             Max(id);
             count(id);
             last(id);
             first(id);
-            if (((id==CPAP_FlowRate) || (id==CPAP_MaskPressureHi) || (id==CPAP_RespEvent) || (id==CPAP_MaskPressure)))
+
+            if (((id == CPAP_FlowRate) || (id == CPAP_MaskPressureHi) || (id == CPAP_RespEvent)
+                    || (id == CPAP_MaskPressure))) {
                 continue;
+            }
 
             cph(id);
             sph(id);
@@ -796,617 +880,768 @@ void Session::UpdateSummaries()
 
 bool Session::SearchEvent(ChannelID code, qint64 time, qint64 dist)
 {
-    qint64 t,start;
-    QHash<ChannelID,QVector<EventList *> >::iterator it;
-    it=eventlist.find(code);
-    quint32 * tptr;
+    qint64 t, start;
+    QHash<ChannelID, QVector<EventList *> >::iterator it;
+    it = eventlist.find(code);
+    quint32 *tptr;
     int cnt;
+
     //qint64 rate;
-    if (it!=eventlist.end()) {
-        for (int i=0;i<it.value().size();i++)  {
-            EventList *el=it.value()[i];
-//            rate=el->rate();
-            cnt=el->count();
+    if (it != eventlist.end()) {
+        for (int i = 0; i < it.value().size(); i++)  {
+            EventList *el = it.value()[i];
+            //            rate=el->rate();
+            cnt = el->count();
 
             // why would this be necessary???
-            if (el->type()==EVL_Waveform) {
+            if (el->type() == EVL_Waveform) {
                 qDebug() << "Called SearchEvent on a waveform object!";
                 return false;
             } else {
-                start=el->first();
-                tptr=el->rawTime();
-                for (int j=0;j<cnt;j++) {
-                    t=start + *tptr++;
-                    if (qAbs(time - t) < dist)
+                start = el->first();
+                tptr = el->rawTime();
+
+                for (int j = 0; j < cnt; j++) {
+                    t = start + *tptr++;
+
+                    if (qAbs(time - t) < dist) {
                         return true;
+                    }
                 }
             }
         }
     }
+
     return false;
 }
 
 bool Session::enabled()
 {
-    if (s_enabled>=0) {
-        return s_enabled!=0;
+    if (s_enabled >= 0) {
+        return s_enabled != 0;
     }
+
     if (!settings.contains(SESSION_ENABLED)) {
-        bool b=true;
-        settings[SESSION_ENABLED]=b;
-        s_enabled=b ? 1 : 0;
+        bool b = true;
+        settings[SESSION_ENABLED] = b;
+        s_enabled = b ? 1 : 0;
         return b;
     }
-    s_enabled=settings[SESSION_ENABLED].toBool() ? 1 : 0;
+
+    s_enabled = settings[SESSION_ENABLED].toBool() ? 1 : 0;
     return s_enabled;
 }
 
 void Session::setEnabled(bool b)
 {
-    settings[SESSION_ENABLED]=s_enabled=b;
+    settings[SESSION_ENABLED] = s_enabled = b;
     SetChanged(true);
 }
 
 
 EventDataType Session::Min(ChannelID id)
 {
-    QHash<ChannelID,EventDataType>::iterator i=m_min.find(id);
-    if (i!=m_min.end())
-        return i.value();
+    QHash<ChannelID, EventDataType>::iterator i = m_min.find(id);
 
-    QHash<ChannelID,QVector<EventList *> >::iterator j=eventlist.find(id);
-    if (j==eventlist.end()) {
-        m_min[id]=0;
+    if (i != m_min.end()) {
+        return i.value();
+    }
+
+    QHash<ChannelID, QVector<EventList *> >::iterator j = eventlist.find(id);
+
+    if (j == eventlist.end()) {
+        m_min[id] = 0;
         return 0;
     }
-    QVector<EventList *> & evec=j.value();
 
-    bool first=true;
-    EventDataType min=0,t1;
-    for (int i=0;i<evec.size();i++) {
-        if (evec[i]->count()==0)
+    QVector<EventList *> &evec = j.value();
+
+    bool first = true;
+    EventDataType min = 0, t1;
+
+    for (int i = 0; i < evec.size(); i++) {
+        if (evec[i]->count() == 0) {
             continue;
-        t1=evec[i]->Min();
-        if (t1==0 && t1==evec[i]->Max()) continue;
+        }
+
+        t1 = evec[i]->Min();
+
+        if (t1 == 0 && t1 == evec[i]->Max()) { continue; }
+
         if (first) {
-            min=t1;
-            first=false;
+            min = t1;
+            first = false;
         } else {
-            if (min>t1) min=t1;
+            if (min > t1) { min = t1; }
         }
     }
-    m_min[id]=min;
+
+    m_min[id] = min;
     return min;
 }
 EventDataType Session::Max(ChannelID id)
 {
-    QHash<ChannelID,EventDataType>::iterator i=m_max.find(id);
-    if (i!=m_max.end())
-        return i.value();
+    QHash<ChannelID, EventDataType>::iterator i = m_max.find(id);
 
-    QHash<ChannelID,QVector<EventList *> >::iterator j=eventlist.find(id);
-    if (j==eventlist.end()) {
-        m_max[id]=0;
+    if (i != m_max.end()) {
+        return i.value();
+    }
+
+    QHash<ChannelID, QVector<EventList *> >::iterator j = eventlist.find(id);
+
+    if (j == eventlist.end()) {
+        m_max[id] = 0;
         return 0;
     }
-    QVector<EventList *> & evec=j.value();
 
-    bool first=true;
-    EventDataType max=0,t1;
-    for (int i=0;i<evec.size();i++) {
-        if (evec[i]->count()==0) continue;
-        t1=evec[i]->Max();
-        if (t1==0 && t1==evec[i]->Min()) continue;
+    QVector<EventList *> &evec = j.value();
+
+    bool first = true;
+    EventDataType max = 0, t1;
+
+    for (int i = 0; i < evec.size(); i++) {
+        if (evec[i]->count() == 0) { continue; }
+
+        t1 = evec[i]->Max();
+
+        if (t1 == 0 && t1 == evec[i]->Min()) { continue; }
+
         if (first) {
-            max=t1;
-            first=false;
+            max = t1;
+            first = false;
         } else {
-            if (max<t1) max=t1;
+            if (max < t1) { max = t1; }
         }
     }
-    m_max[id]=max;
+
+    m_max[id] = max;
     return max;
 }
 
 ////
 EventDataType Session::physMin(ChannelID id)
 {
-    QHash<ChannelID,EventDataType>::iterator i=m_physmin.find(id);
-    if (i!=m_physmin.end())
-        return i.value();
+    QHash<ChannelID, EventDataType>::iterator i = m_physmin.find(id);
 
-    QHash<ChannelID,QVector<EventList *> >::iterator j=eventlist.find(id);
-    if (j==eventlist.end()) {
-        m_physmin[id]=0;
+    if (i != m_physmin.end()) {
+        return i.value();
+    }
+
+    QHash<ChannelID, QVector<EventList *> >::iterator j = eventlist.find(id);
+
+    if (j == eventlist.end()) {
+        m_physmin[id] = 0;
         return 0;
     }
-    EventDataType min=round(Min(id));
-    m_physmin[id]=min;
+
+    EventDataType min = round(Min(id));
+    m_physmin[id] = min;
     return min;
 }
 EventDataType Session::physMax(ChannelID id)
 {
-    QHash<ChannelID,EventDataType>::iterator i=m_physmax.find(id);
-    if (i!=m_physmax.end())
-        return i.value();
+    QHash<ChannelID, EventDataType>::iterator i = m_physmax.find(id);
 
-    QHash<ChannelID,QVector<EventList *> >::iterator j=eventlist.find(id);
-    if (j==eventlist.end()) {
-        m_physmax[id]=0;
+    if (i != m_physmax.end()) {
+        return i.value();
+    }
+
+    QHash<ChannelID, QVector<EventList *> >::iterator j = eventlist.find(id);
+
+    if (j == eventlist.end()) {
+        m_physmax[id] = 0;
         return 0;
     }
-    EventDataType max=round(Max(id)+0.5);
-    m_physmax[id]=max;
+
+    EventDataType max = round(Max(id) + 0.5);
+    m_physmax[id] = max;
     return max;
 }
 
 
 qint64 Session::first(ChannelID id)
 {
-    qint64 drift=qint64(PROFILE.cpap->clockDrift())*1000L;
+    qint64 drift = qint64(PROFILE.cpap->clockDrift()) * 1000L;
     qint64 tmp;
-    QHash<ChannelID,quint64>::iterator i=m_firstchan.find(id);
-    if (i!=m_firstchan.end()) {
-        tmp=i.value();
-        if (s_machine->GetType()==MT_CPAP)
-            tmp+=drift;
+    QHash<ChannelID, quint64>::iterator i = m_firstchan.find(id);
+
+    if (i != m_firstchan.end()) {
+        tmp = i.value();
+
+        if (s_machine->GetType() == MT_CPAP) {
+            tmp += drift;
+        }
+
         return tmp;
     }
 
-    QHash<ChannelID,QVector<EventList *> >::iterator j=eventlist.find(id);
-    if (j==eventlist.end())
-        return 0;
-    QVector<EventList *> & evec=j.value();
+    QHash<ChannelID, QVector<EventList *> >::iterator j = eventlist.find(id);
+
+    if (j == eventlist.end()) {
+        return 0;
+    }
+
+    QVector<EventList *> &evec = j.value();
+
+    bool first = true;
+    qint64 min = 0, t1;
+
+    for (int i = 0; i < evec.size(); i++) {
+        t1 = evec[i]->first();
 
-    bool first=true;
-    qint64 min=0,t1;
-    for (int i=0;i<evec.size();i++) {
-        t1=evec[i]->first();
         if (first) {
-            min=t1;
-            first=false;
+            min = t1;
+            first = false;
         } else {
-            if (min>t1) min=t1;
+            if (min > t1) { min = t1; }
         }
     }
-    m_firstchan[id]=min;
-    if (s_machine->GetType()==MT_CPAP)
-        min+=drift;
+
+    m_firstchan[id] = min;
+
+    if (s_machine->GetType() == MT_CPAP) {
+        min += drift;
+    }
+
     return min;
 }
 qint64 Session::last(ChannelID id)
 {
-    qint64 drift=qint64(PROFILE.cpap->clockDrift())*1000L;
+    qint64 drift = qint64(PROFILE.cpap->clockDrift()) * 1000L;
     qint64 tmp;
-    QHash<ChannelID,quint64>::iterator i=m_lastchan.find(id);
-    if (i!=m_lastchan.end()) {
-        tmp=i.value();
-        if (s_machine->GetType()==MT_CPAP)
-            tmp+=drift;
+    QHash<ChannelID, quint64>::iterator i = m_lastchan.find(id);
+
+    if (i != m_lastchan.end()) {
+        tmp = i.value();
+
+        if (s_machine->GetType() == MT_CPAP) {
+            tmp += drift;
+        }
+
         return tmp;
     }
-    QHash<ChannelID,QVector<EventList *> >::iterator j=eventlist.find(id);
-    if (j==eventlist.end())
-        return 0;
-    QVector<EventList *> & evec=j.value();
 
-    bool first=true;
-    qint64 max=0,t1;
-    for (int i=0;i<evec.size();i++) {
-        t1=evec[i]->last();
+    QHash<ChannelID, QVector<EventList *> >::iterator j = eventlist.find(id);
+
+    if (j == eventlist.end()) {
+        return 0;
+    }
+
+    QVector<EventList *> &evec = j.value();
+
+    bool first = true;
+    qint64 max = 0, t1;
+
+    for (int i = 0; i < evec.size(); i++) {
+        t1 = evec[i]->last();
+
         if (first) {
-            max=t1;
-            first=false;
+            max = t1;
+            first = false;
         } else {
-            if (max<t1) max=t1;
+            if (max < t1) { max = t1; }
         }
     }
 
-    m_lastchan[id]=max;
-    if (s_machine->GetType()==MT_CPAP)
-        max+=drift;
+    m_lastchan[id] = max;
+
+    if (s_machine->GetType() == MT_CPAP) {
+        max += drift;
+    }
+
     return max;
 }
 bool Session::channelDataExists(ChannelID id)
 {
     if (s_events_loaded) {
-        QHash<ChannelID,QVector<EventList *> >::iterator j=eventlist.find(id);
-        if (j==eventlist.end())  // eventlist not loaded.
+        QHash<ChannelID, QVector<EventList *> >::iterator j = eventlist.find(id);
+
+        if (j == eventlist.end()) { // eventlist not loaded.
             return false;
+        }
+
         return true;
     } else {
         qDebug() << "Calling channelDataExists without open eventdata!";
     }
+
     return false;
 }
 bool Session::channelExists(ChannelID id)
 {
-    if (!enabled()) return false;
+    if (!enabled()) { return false; }
+
     if (s_events_loaded) {
-        QHash<ChannelID,QVector<EventList *> >::iterator j=eventlist.find(id);
-        if (j==eventlist.end())  // eventlist not loaded.
+        QHash<ChannelID, QVector<EventList *> >::iterator j = eventlist.find(id);
+
+        if (j == eventlist.end()) { // eventlist not loaded.
             return false;
+        }
     } else {
-        QHash<ChannelID,int>::iterator q=m_cnt.find(id);
-        if (q==m_cnt.end())
+        QHash<ChannelID, int>::iterator q = m_cnt.find(id);
+
+        if (q == m_cnt.end()) {
             return false;
-        if (q.value()==0) return false;
+        }
+
+        if (q.value() == 0) { return false; }
     }
+
     return true;
 }
 
-int Session::rangeCount(ChannelID id, qint64 first,qint64 last)
+int Session::rangeCount(ChannelID id, qint64 first, qint64 last)
 {
-    QHash<ChannelID,QVector<EventList *> >::iterator j=eventlist.find(id);
-    if (j==eventlist.end()) {
+    QHash<ChannelID, QVector<EventList *> >::iterator j = eventlist.find(id);
+
+    if (j == eventlist.end()) {
         return 0;
     }
-    QVector<EventList *> & evec=j.value();
-    int sum=0,cnt;
 
-    qint64 t,start;
-    for (int i=0;i<evec.size();i++) {
-        EventList & ev=*evec[i];
-        if ((ev.last() < first) || (ev.first() > last))
+    QVector<EventList *> &evec = j.value();
+    int sum = 0, cnt;
+
+    qint64 t, start;
+
+    for (int i = 0; i < evec.size(); i++) {
+        EventList &ev = *evec[i];
+
+        if ((ev.last() < first) || (ev.first() > last)) {
             continue;
+        }
 
         if (ev.type() == EVL_Waveform) {
-            qint64 et=last;
-            if (et > ev.last())
-                et=ev.last();
+            qint64 et = last;
 
-            qint64 st=first;
-            if (st < ev.first())
-                st=ev.first();
+            if (et > ev.last()) {
+                et = ev.last();
+            }
 
-            t=(et - st) / ev.rate();
-            sum+=t;
+            qint64 st = first;
+
+            if (st < ev.first()) {
+                st = ev.first();
+            }
+
+            t = (et - st) / ev.rate();
+            sum += t;
         } else {
-            cnt=ev.count();
-            start=ev.first();
-            quint32 * tptr=ev.rawTime();
-            quint32 * eptr=tptr+cnt;
-            for (;tptr < eptr; tptr++) {
-                t=start + *tptr;
+            cnt = ev.count();
+            start = ev.first();
+            quint32 *tptr = ev.rawTime();
+            quint32 *eptr = tptr + cnt;
+
+            for (; tptr < eptr; tptr++) {
+                t = start + *tptr;
 
                 if (t >= first) {
-                    if (t<=last) {
+                    if (t <= last) {
                         sum++;
-                    } else break;
+                    } else { break; }
                 }
             }
         }
     }
+
     return sum;
 }
-double Session::rangeSum(ChannelID id, qint64 first,qint64 last)
+double Session::rangeSum(ChannelID id, qint64 first, qint64 last)
 {
-    QHash<ChannelID,QVector<EventList *> >::iterator j=eventlist.find(id);
-    if (j==eventlist.end()) {
+    QHash<ChannelID, QVector<EventList *> >::iterator j = eventlist.find(id);
+
+    if (j == eventlist.end()) {
         return 0;
     }
-    QVector<EventList *> & evec=j.value();
-    double sum=0,gain;
 
-    qint64 t,start;
-    EventStoreType * dptr, * eptr;
-    quint32 * tptr;
-    int cnt,idx=0;
+    QVector<EventList *> &evec = j.value();
+    double sum = 0, gain;
+
+    qint64 t, start;
+    EventStoreType *dptr, * eptr;
+    quint32 *tptr;
+    int cnt, idx = 0;
 
     qint64 rate;
-    for (int i=0;i < evec.size();i++) {
-        EventList & ev=*evec[i];
-        if ((ev.last() < first) || (ev.first() > last))
+
+    for (int i = 0; i < evec.size(); i++) {
+        EventList &ev = *evec[i];
+
+        if ((ev.last() < first) || (ev.first() > last)) {
             continue;
-        start=ev.first();
-        dptr=ev.rawData();
-        cnt=ev.count();
-        eptr=dptr+cnt;
-        gain=ev.gain();
-        rate=ev.rate();
-        if (ev.type()==EVL_Waveform) {
+        }
+
+        start = ev.first();
+        dptr = ev.rawData();
+        cnt = ev.count();
+        eptr = dptr + cnt;
+        gain = ev.gain();
+        rate = ev.rate();
+
+        if (ev.type() == EVL_Waveform) {
             if (first > ev.first()) {
                 // Skip the samples before first
-                idx=(first - ev.first()) / rate;
+                idx = (first - ev.first()) / rate;
             }
 
-            dptr+=idx; //???? foggy.
+            dptr += idx; //???? foggy.
 
-            t=start;
-            for (;dptr < eptr; dptr++) { //int j=idx;j<cnt;j++) {
+            t = start;
+
+            for (; dptr < eptr; dptr++) { //int j=idx;j<cnt;j++) {
                 if (t <= last) {
-                    sum+=EventDataType(*dptr) * gain;
-                } else break;
-                t+=rate;
+                    sum += EventDataType(*dptr) * gain;
+                } else { break; }
+
+                t += rate;
             }
         } else {
-            tptr=ev.rawTime();
+            tptr = ev.rawTime();
+
+            for (; dptr < eptr; dptr++) {
+                t = start + *tptr++;
 
-            for (;dptr < eptr; dptr++) {
-                t=start + *tptr++;
                 if (t >= first) {
                     if (t <= last) {
-                        sum+=EventDataType(*dptr) * gain;
-                    } else break;
+                        sum += EventDataType(*dptr) * gain;
+                    } else { break; }
                 }
             }
         }
     }
+
     return sum;
 }
-EventDataType Session::rangeMin(ChannelID id, qint64 first,qint64 last)
+EventDataType Session::rangeMin(ChannelID id, qint64 first, qint64 last)
 {
-    QHash<ChannelID,QVector<EventList *> >::iterator j=eventlist.find(id);
-    if (j==eventlist.end()) {
+    QHash<ChannelID, QVector<EventList *> >::iterator j = eventlist.find(id);
+
+    if (j == eventlist.end()) {
         return 0;
     }
-    QVector<EventList *> & evec=j.value();
-    EventDataType gain,v,min=999999999;
 
-    qint64 t,start,rate;
-    EventStoreType * dptr, * eptr;
-    quint32 * tptr;
-    int cnt,idx;
+    QVector<EventList *> &evec = j.value();
+    EventDataType gain, v, min = 999999999;
 
-    for (int i=0;i<evec.size();i++) {
-        EventList & ev=*evec[i];
-        if ((ev.last() < first) || (ev.first() > last))
+    qint64 t, start, rate;
+    EventStoreType *dptr, * eptr;
+    quint32 *tptr;
+    int cnt, idx;
+
+    for (int i = 0; i < evec.size(); i++) {
+        EventList &ev = *evec[i];
+
+        if ((ev.last() < first) || (ev.first() > last)) {
             continue;
+        }
 
-        dptr=ev.rawData();
-        start=ev.first();
-        cnt=ev.count();
-        eptr=dptr+cnt;
-        gain=ev.gain();
+        dptr = ev.rawData();
+        start = ev.first();
+        cnt = ev.count();
+        eptr = dptr + cnt;
+        gain = ev.gain();
 
-        if (ev.type()==EVL_Waveform) {
-            rate=ev.rate();
-            t=start;
-            idx=0;
+        if (ev.type() == EVL_Waveform) {
+            rate = ev.rate();
+            t = start;
+            idx = 0;
 
             if (first > ev.first()) {
                 // Skip the samples before first
-                idx=(first - ev.first())/rate;
+                idx = (first - ev.first()) / rate;
             }
-            dptr+=idx;
+
+            dptr += idx;
 
             for (; dptr < eptr; dptr++) { //int j=idx;j<cnt;j++) {
-                if (t<=last) {
-                    v=EventDataType(*dptr) * gain;
-                    if (v<min)
-                        min=v;
-                } else break;
-                t+=rate;
+                if (t <= last) {
+                    v = EventDataType(*dptr) * gain;
+
+                    if (v < min) {
+                        min = v;
+                    }
+                } else { break; }
+
+                t += rate;
             }
         } else {
-            tptr=ev.rawTime();
+            tptr = ev.rawTime();
+
             for (; dptr < eptr; dptr++) { //int j=0;j<cnt;j++) {
-                t=start + *tptr++;
+                t = start + *tptr++;
+
                 if (t >= first) {
                     if (t <= last) {
-                        v=EventDataType(*dptr) * gain;
-                        if (v<min)
-                            min=v;
-                    } else break;
+                        v = EventDataType(*dptr) * gain;
+
+                        if (v < min) {
+                            min = v;
+                        }
+                    } else { break; }
                 }
             }
         }
     }
+
     return min;
 }
-EventDataType Session::rangeMax(ChannelID id, qint64 first,qint64 last)
+EventDataType Session::rangeMax(ChannelID id, qint64 first, qint64 last)
 {
-    QHash<ChannelID,QVector<EventList *> >::iterator j=eventlist.find(id);
-    if (j==eventlist.end()) {
+    QHash<ChannelID, QVector<EventList *> >::iterator j = eventlist.find(id);
+
+    if (j == eventlist.end()) {
         return 0;
     }
-    QVector<EventList *> & evec=j.value();
-    EventDataType gain,v,max=-999999999;
 
-    qint64 t,start,rate;
-    EventStoreType * dptr, * eptr;
-    quint32 * tptr;
-    int cnt,idx;
+    QVector<EventList *> &evec = j.value();
+    EventDataType gain, v, max = -999999999;
 
-    for (int i=0;i<evec.size();i++) {
-        EventList & ev=*evec[i];
-        if ((ev.last() < first) || (ev.first() > last))
+    qint64 t, start, rate;
+    EventStoreType *dptr, * eptr;
+    quint32 *tptr;
+    int cnt, idx;
+
+    for (int i = 0; i < evec.size(); i++) {
+        EventList &ev = *evec[i];
+
+        if ((ev.last() < first) || (ev.first() > last)) {
             continue;
+        }
 
-        start=ev.first();
-        dptr=ev.rawData();
-        cnt=ev.count();
-        eptr=dptr + cnt;
-        gain=ev.gain();
-        if (ev.type()==EVL_Waveform) {
-            rate=ev.rate();
-            t=start;
-            idx=0;
+        start = ev.first();
+        dptr = ev.rawData();
+        cnt = ev.count();
+        eptr = dptr + cnt;
+        gain = ev.gain();
+
+        if (ev.type() == EVL_Waveform) {
+            rate = ev.rate();
+            t = start;
+            idx = 0;
 
             if (first > ev.first()) {
                 // Skip the samples before first
-                idx=(first - ev.first())/rate;
+                idx = (first - ev.first()) / rate;
             }
-            dptr+=idx;
+
+            dptr += idx;
+
             for (; dptr < eptr; dptr++) { //int j=idx;j<cnt;j++) {
-                if (t<=last) {
-                    v=EventDataType(*dptr) * gain;
-                    if (v>max) max=v;
-                } else break;
-                t+=rate;
+                if (t <= last) {
+                    v = EventDataType(*dptr) * gain;
+
+                    if (v > max) { max = v; }
+                } else { break; }
+
+                t += rate;
             }
         } else {
-            tptr=ev.rawTime();
-            for (;dptr < eptr; dptr++) {
-                t=start + *tptr++;
-                if (t>=first) {
-                    if (t<=last) {
-                        v=EventDataType(*dptr) * gain;
-                        if (v>max) max=v;
-                    } else break;
+            tptr = ev.rawTime();
+
+            for (; dptr < eptr; dptr++) {
+                t = start + *tptr++;
+
+                if (t >= first) {
+                    if (t <= last) {
+                        v = EventDataType(*dptr) * gain;
+
+                        if (v > max) { max = v; }
+                    } else { break; }
                 }
             }
         }
     }
+
     return max;
 }
 
 int Session::count(ChannelID id)
 {
-    QHash<ChannelID,int>::iterator i=m_cnt.find(id);
-    if (i!=m_cnt.end())
-        return i.value();
+    QHash<ChannelID, int>::iterator i = m_cnt.find(id);
 
-    QHash<ChannelID,QVector<EventList *> >::iterator j=eventlist.find(id);
-    if (j==eventlist.end()) {
-        m_cnt[id]=0;
+    if (i != m_cnt.end()) {
+        return i.value();
+    }
+
+    QHash<ChannelID, QVector<EventList *> >::iterator j = eventlist.find(id);
+
+    if (j == eventlist.end()) {
+        m_cnt[id] = 0;
         return 0;
     }
-    QVector<EventList *> & evec=j.value();
 
-    int sum=0;
-    for (int i=0;i<evec.size();i++) {
-        sum+=evec[i]->count();
+    QVector<EventList *> &evec = j.value();
+
+    int sum = 0;
+
+    for (int i = 0; i < evec.size(); i++) {
+        sum += evec[i]->count();
     }
-    m_cnt[id]=sum;
+
+    m_cnt[id] = sum;
     return sum;
 }
 
 double Session::sum(ChannelID id)
 {
-    QHash<ChannelID,double>::iterator i=m_sum.find(id);
-    if (i!=m_sum.end())
-        return i.value();
+    QHash<ChannelID, double>::iterator i = m_sum.find(id);
 
-    QHash<ChannelID,QVector<EventList *> >::iterator j=eventlist.find(id);
-    if (j==eventlist.end()) {
-        m_sum[id]=0;
+    if (i != m_sum.end()) {
+        return i.value();
+    }
+
+    QHash<ChannelID, QVector<EventList *> >::iterator j = eventlist.find(id);
+
+    if (j == eventlist.end()) {
+        m_sum[id] = 0;
         return 0;
     }
-    QVector<EventList *> & evec=j.value();
 
-    double gain,sum=0;
-    EventStoreType * dptr, * eptr;
+    QVector<EventList *> &evec = j.value();
+
+    double gain, sum = 0;
+    EventStoreType *dptr, * eptr;
     int cnt;
-    for (int i=0;i<evec.size();i++) {
-        EventList & ev=*(evec[i]);
-        gain=ev.gain();
-        cnt=ev.count();
-        dptr=ev.rawData();
-        eptr=dptr+cnt;
+
+    for (int i = 0; i < evec.size(); i++) {
+        EventList &ev = *(evec[i]);
+        gain = ev.gain();
+        cnt = ev.count();
+        dptr = ev.rawData();
+        eptr = dptr + cnt;
 
         for (; dptr < eptr; dptr++) {
-            sum+=double(*dptr) * gain;
+            sum += double(*dptr) * gain;
         }
     }
-    m_sum[id]=sum;
+
+    m_sum[id] = sum;
     return sum;
 }
 
 EventDataType Session::avg(ChannelID id)
 {
-    QHash<ChannelID,EventDataType>::iterator i=m_avg.find(id);
-    if (i!=m_avg.end())
-        return i.value();
+    QHash<ChannelID, EventDataType>::iterator i = m_avg.find(id);
 
-    QHash<ChannelID,QVector<EventList *> >::iterator j=eventlist.find(id);
-    if (j==eventlist.end()) {
-        m_avg[id]=0;
+    if (i != m_avg.end()) {
+        return i.value();
+    }
+
+    QHash<ChannelID, QVector<EventList *> >::iterator j = eventlist.find(id);
+
+    if (j == eventlist.end()) {
+        m_avg[id] = 0;
         return 0;
     }
-    QVector<EventList *> & evec=j.value();
 
-    double val=0,gain;
-    int cnt=0;
-    EventStoreType * dptr, * eptr;
-    for (int i=0;i<evec.size();i++) {
-        EventList & ev=*(evec[i]);
-        dptr=ev.rawData();
-        gain=ev.gain();
-        cnt=ev.count();
-        eptr=dptr+cnt;
+    QVector<EventList *> &evec = j.value();
+
+    double val = 0, gain;
+    int cnt = 0;
+    EventStoreType *dptr, * eptr;
+
+    for (int i = 0; i < evec.size(); i++) {
+        EventList &ev = *(evec[i]);
+        dptr = ev.rawData();
+        gain = ev.gain();
+        cnt = ev.count();
+        eptr = dptr + cnt;
 
         for (; dptr < eptr; dptr++) {
-            val+=double(*dptr) * gain;
+            val += double(*dptr) * gain;
         }
     }
 
-    if (cnt>0) { // Shouldn't really happen.. Should aways contain data
-        val/=double(cnt);
+    if (cnt > 0) { // Shouldn't really happen.. Should aways contain data
+        val /= double(cnt);
     }
-    m_avg[id]=val;
+
+    m_avg[id] = val;
     return val;
 }
 EventDataType Session::cph(ChannelID id) // count per hour
 {
-    QHash<ChannelID,EventDataType>::iterator i=m_cph.find(id);
-    if (i!=m_cph.end())
+    QHash<ChannelID, EventDataType>::iterator i = m_cph.find(id);
+
+    if (i != m_cph.end()) {
         return i.value();
+    }
 
-    EventDataType val=count(id);
-    val/=hours();
+    EventDataType val = count(id);
+    val /= hours();
 
-    m_cph[id]=val;
+    m_cph[id] = val;
     return val;
 }
 EventDataType Session::sph(ChannelID id) // sum per hour, assuming id is a time field in seconds
 {
-    QHash<ChannelID,EventDataType>::iterator i=m_sph.find(id);
-    if (i!=m_sph.end())
-        return i.value();
+    QHash<ChannelID, EventDataType>::iterator i = m_sph.find(id);
 
-    EventDataType val=sum(id)/3600.0;
-    val=100.0 / hours() * val;
-    m_sph[id]=val;
+    if (i != m_sph.end()) {
+        return i.value();
+    }
+
+    EventDataType val = sum(id) / 3600.0;
+    val = 100.0 / hours() * val;
+    m_sph[id] = val;
     return val;
 }
 
-bool sortfunction (EventStoreType i,EventStoreType j) { return (i<j); }
+bool sortfunction(EventStoreType i, EventStoreType j) { return (i < j); }
 
-EventDataType Session::percentile(ChannelID id,EventDataType percent)
+EventDataType Session::percentile(ChannelID id, EventDataType percent)
 {
-    QHash<ChannelID,QVector<EventList *> >::iterator jj=eventlist.find(id);
-    if (jj==eventlist.end())
+    QHash<ChannelID, QVector<EventList *> >::iterator jj = eventlist.find(id);
+
+    if (jj == eventlist.end()) {
         return 0;
-    QVector<EventList *> & evec=jj.value();
+    }
+
+    QVector<EventList *> &evec = jj.value();
 
     if (percent > 1.0) {
         qWarning() << "Session::percentile() called with > 1.0";
         return 0;
     }
 
-    int size=evec.size();
-    if (size==0)
+    int size = evec.size();
+
+    if (size == 0) {
         return 0;
+    }
 
     QVector<EventStoreType> array;
 
-    EventDataType gain=evec[0]->gain();
+    EventDataType gain = evec[0]->gain();
 
-    EventStoreType * dptr, * sptr, *eptr;
+    EventStoreType *dptr, * sptr, *eptr;
 
-    int tt=0,cnt=0;
-    for (int i=0;i<size;i++) {
-        EventList & ev=*evec[i];
-        cnt=ev.count();
-        tt+=cnt;
+    int tt = 0, cnt = 0;
+
+    for (int i = 0; i < size; i++) {
+        EventList &ev = *evec[i];
+        cnt = ev.count();
+        tt += cnt;
     }
+
     array.resize(tt);
 
-    for (int i=0;i<size;i++) {
-        EventList & ev=*evec[i];
-        sptr=ev.rawData();
-        dptr=array.data();
+    for (int i = 0; i < size; i++) {
+        EventList &ev = *evec[i];
+        sptr = ev.rawData();
+        dptr = array.data();
+
+        eptr = sptr + cnt;
 
-        eptr=sptr+cnt;
         for (; sptr < eptr; sptr++) {
             *dptr++ = * sptr;
         }
     }
 
-    int n=array.size()*percent;
-    if (n>array.size()-1) n--;
-    nth_element(array.begin(), array.begin()+n, array.end());
+    int n = array.size() * percent;
+
+    if (n > array.size() - 1) { n--; }
+
+    nth_element(array.begin(), array.begin() + n, array.end());
 
     // slack, no averaging.. fixme if this function is ever used..
     return array[n] * gain;
@@ -1414,48 +1649,57 @@ EventDataType Session::percentile(ChannelID id,EventDataType percent)
 
 EventDataType Session::wavg(ChannelID id)
 {
-    QHash<EventStoreType,quint32> vtime;
-    QHash<ChannelID,EventDataType>::iterator i=m_wavg.find(id);
-    if (i!=m_wavg.end())
+    QHash<EventStoreType, quint32> vtime;
+    QHash<ChannelID, EventDataType>::iterator i = m_wavg.find(id);
+
+    if (i != m_wavg.end()) {
         return i.value();
+    }
 
     updateCountSummary(id);
 
-    QHash<ChannelID,QHash<EventStoreType, quint32> >::iterator j2=m_timesummary.find(id);
+    QHash<ChannelID, QHash<EventStoreType, quint32> >::iterator j2 = m_timesummary.find(id);
 
-    if (j2==m_timesummary.end())
+    if (j2 == m_timesummary.end()) {
         return 0;
-
-    QHash<EventStoreType, quint32> & timesum=j2.value();
-
-    if (!m_gain.contains(id))
-        return 0;
-
-    double s0=0,s1=0,s2;
-
-    EventDataType val, gain=m_gain[id];
-    for (QHash<EventStoreType, quint32>::iterator vi=timesum.begin();vi!=timesum.end();vi++) {
-        val=vi.key() * gain;
-        s2=vi.value();
-        s0+=s2;
-        s1+=val * s2;
     }
-    if (s0>0) {
-        val=s1/s0;
-    } else val=0;
 
-    m_wavg[id]=val;
+    QHash<EventStoreType, quint32> &timesum = j2.value();
+
+    if (!m_gain.contains(id)) {
+        return 0;
+    }
+
+    double s0 = 0, s1 = 0, s2;
+
+    EventDataType val, gain = m_gain[id];
+
+    for (QHash<EventStoreType, quint32>::iterator vi = timesum.begin(); vi != timesum.end(); vi++) {
+        val = vi.key() * gain;
+        s2 = vi.value();
+        s0 += s2;
+        s1 += val * s2;
+    }
+
+    if (s0 > 0) {
+        val = s1 / s0;
+    } else { val = 0; }
+
+    m_wavg[id] = val;
     return val;
 }
 
-EventList * Session::AddEventList(ChannelID code, EventListType et,EventDataType gain,EventDataType offset,EventDataType min, EventDataType max,EventDataType rate,bool second_field)
+EventList *Session::AddEventList(ChannelID code, EventListType et, EventDataType gain,
+                                 EventDataType offset, EventDataType min, EventDataType max, EventDataType rate, bool second_field)
 {
-    schema::Channel * channel=&schema::channel[code];
+    schema::Channel *channel = &schema::channel[code];
+
     if (!channel) {
         qWarning() << "Channel" << code << "does not exist!";
         //return NULL;
     }
-    EventList * el=new EventList(et,gain,offset,min,max,rate,second_field);
+
+    EventList *el = new EventList(et, gain, offset, min, max, rate, second_field);
 
     eventlist[code].push_back(el);
     //s_machine->registerChannel(chan);
@@ -1464,42 +1708,56 @@ EventList * Session::AddEventList(ChannelID code, EventListType et,EventDataType
 void Session::offsetSession(qint64 offset)
 {
     //qDebug() << "Session starts" << QDateTime::fromTime_t(s_first/1000).toString("yyyy-MM-dd HH:mm:ss");
-    s_first+=offset;
-    s_last+=offset;
-    QHash<ChannelID,quint64>::iterator it;
+    s_first += offset;
+    s_last += offset;
+    QHash<ChannelID, quint64>::iterator it;
 
-    for (it=m_firstchan.begin();it!=m_firstchan.end();it++) {
-        if (it.value()>0)
-            it.value()+=offset;
-    }
-    for (it=m_lastchan.begin();it!=m_lastchan.end();it++) {
-        if (it.value()>0)
-            it.value()+=offset;
-    }
-
-    QHash<ChannelID,QVector<EventList *> >::iterator i;
-    for (i=eventlist.begin();i!=eventlist.end();i++) {
-        for (int j=0;j<i.value().size();j++) {
-            EventList *e=i.value()[j];
-
-            e->setFirst(e->first()+offset);
-            e->setLast(e->last()+offset);
+    for (it = m_firstchan.begin(); it != m_firstchan.end(); it++) {
+        if (it.value() > 0) {
+            it.value() += offset;
         }
     }
-    qDebug() << "Session now starts" << QDateTime::fromTime_t(s_first/1000).toString("yyyy-MM-dd HH:mm:ss");
+
+    for (it = m_lastchan.begin(); it != m_lastchan.end(); it++) {
+        if (it.value() > 0) {
+            it.value() += offset;
+        }
+    }
+
+    QHash<ChannelID, QVector<EventList *> >::iterator i;
+
+    for (i = eventlist.begin(); i != eventlist.end(); i++) {
+        for (int j = 0; j < i.value().size(); j++) {
+            EventList *e = i.value()[j];
+
+            e->setFirst(e->first() + offset);
+            e->setLast(e->last() + offset);
+        }
+    }
+
+    qDebug() << "Session now starts" << QDateTime::fromTime_t(s_first /
+             1000).toString("yyyy-MM-dd HH:mm:ss");
 
 }
 
-qint64 Session::first() {
-    qint64 start=s_first;
-    if (s_machine->GetType()==MT_CPAP)
-        start+=qint64(PROFILE.cpap->clockDrift())*1000L;
+qint64 Session::first()
+{
+    qint64 start = s_first;
+
+    if (s_machine->GetType() == MT_CPAP) {
+        start += qint64(PROFILE.cpap->clockDrift()) * 1000L;
+    }
+
     return start;
 }
 
-qint64 Session::last() {
-    qint64 last=s_last;
-    if (s_machine->GetType()==MT_CPAP)
-        last+=qint64(PROFILE.cpap->clockDrift())*1000L;
+qint64 Session::last()
+{
+    qint64 last = s_last;
+
+    if (s_machine->GetType() == MT_CPAP) {
+        last += qint64(PROFILE.cpap->clockDrift()) * 1000L;
+    }
+
     return last;
 }
diff --git a/sleepyhead/SleepLib/session.h b/sleepyhead/SleepLib/session.h
index 8dc7e13c..229921c2 100644
--- a/sleepyhead/SleepLib/session.h
+++ b/sleepyhead/SleepLib/session.h
@@ -30,12 +30,12 @@ class Machine;
     */
 class Session
 {
-public:
+  public:
     /*! \fn Session(Machine *,SessionID);
         \brief Create a session object belonging to Machine, with supplied SessionID
         If sessionID is 0, the next in sequence will be picked
         */
-    Session(Machine *,SessionID);
+    Session(Machine *, SessionID);
     virtual ~Session();
 
     //! \brief Stores the session in the directory supplied by path
@@ -62,10 +62,10 @@ public:
     void TrashEvents();
 
     //! \brief Search for Event code happening within dist milliseconds of supplied time (ms since epoch)
-    bool SearchEvent(ChannelID code, qint64 time, qint64 dist=15000);
+    bool SearchEvent(ChannelID code, qint64 time, qint64 dist = 15000);
 
     //! \brief Return the sessionID
-    inline const SessionID & session() {
+    inline const SessionID &session() {
         return s_session;
     }
 
@@ -83,46 +83,47 @@ public:
 
     //! \brief Return the millisecond length of this session
     qint64 length() {
-        return s_last-s_first;
+        return s_last - s_first;
     }
 
     //! \brief Set this Sessions ID (Not does not update indexes)
     void SetSessionID(SessionID s) {
-        s_session=s;
+        s_session = s;
     }
 
     //! \brief Moves all of this session data by offset d milliseconds
     void offsetSession(qint64 d);
 
     //! \brief Just set the start of the timerange without comparing
-    void really_set_first(qint64 d) { s_first=d; }
+    void really_set_first(qint64 d) { s_first = d; }
 
     //! \brief Just set the end of the timerange without comparing
-    void really_set_last(qint64 d) { s_last=d; }
+    void really_set_last(qint64 d) { s_last = d; }
 
     void set_first(qint64 d) {
-        if (!s_first) s_first=d;
-        else if (d<s_first) s_first=d;
+        if (!s_first) { s_first = d; }
+        else if (d < s_first) { s_first = d; }
     }
     void set_last(qint64 d) {
-        if (d<=s_first) {
+        if (d <= s_first) {
             qWarning() << "Session::set_last() d<=s_first";
             return;
         }
-        if (!s_last) s_last=d;
-        else if (s_last<d) s_last=d;
+
+        if (!s_last) { s_last = d; }
+        else if (s_last < d) { s_last = d; }
     }
 
     //! \brief Return Session Length in decimal hours
     double hours() {
-        double t=(s_last-s_first)/3600000.0;
+        double t = (s_last - s_first) / 3600000.0;
         return t;
     }
 
     //! \brief Flag this Session as dirty, so Machine object can save it
     void SetChanged(bool val) {
-        s_changed=val;
-        s_events_loaded=val; // dirty hack putting this here
+        s_changed = val;
+        s_events_loaded = val; // dirty hack putting this here
     }
 
     //! \brief Return this Sessions dirty status
@@ -131,33 +132,33 @@ public:
     }
 
     //! \brief Contains all the EventLists, indexed by ChannelID
-    QHash<ChannelID,QVector<EventList *> > eventlist;
+    QHash<ChannelID, QVector<EventList *> > eventlist;
 
     //! \brief Sessions Settings List, contianing single settings for this session.
-    QHash<ChannelID,QVariant> settings;
+    QHash<ChannelID, QVariant> settings;
 
     // Session caches
-    QHash<ChannelID,int> m_cnt;
-    QHash<ChannelID,double> m_sum;
-    QHash<ChannelID,EventDataType> m_avg;
-    QHash<ChannelID,EventDataType> m_wavg;
+    QHash<ChannelID, int> m_cnt;
+    QHash<ChannelID, double> m_sum;
+    QHash<ChannelID, EventDataType> m_avg;
+    QHash<ChannelID, EventDataType> m_wavg;
 
-    QHash<ChannelID,EventDataType> m_min; // The actual minimum
-    QHash<ChannelID,EventDataType> m_max;
+    QHash<ChannelID, EventDataType> m_min; // The actual minimum
+    QHash<ChannelID, EventDataType> m_max;
 
     // This could go in channels, but different machines interpret it differently
     // Under the new SleepyLib data Device model this can be done, but unfortunately not here..
-    QHash<ChannelID,EventDataType> m_physmin; // The physical minimum for graph display purposes
-    QHash<ChannelID,EventDataType> m_physmax; // The physical maximum
+    QHash<ChannelID, EventDataType> m_physmin; // The physical minimum for graph display purposes
+    QHash<ChannelID, EventDataType> m_physmax; // The physical maximum
 
-    QHash<ChannelID,EventDataType> m_cph;  // Counts per hour (eg AHI)
-    QHash<ChannelID,EventDataType> m_sph;  // % indice (eg % night in CSR)
-    QHash<ChannelID,quint64> m_firstchan;
-    QHash<ChannelID,quint64> m_lastchan;
+    QHash<ChannelID, EventDataType> m_cph; // Counts per hour (eg AHI)
+    QHash<ChannelID, EventDataType> m_sph; // % indice (eg % night in CSR)
+    QHash<ChannelID, quint64> m_firstchan;
+    QHash<ChannelID, quint64> m_lastchan;
 
-    QHash<ChannelID,QHash<EventStoreType, EventStoreType> > m_valuesummary;
-    QHash<ChannelID,QHash<EventStoreType, quint32> > m_timesummary;
-    QHash<ChannelID,EventDataType> m_gain;
+    QHash<ChannelID, QHash<EventStoreType, EventStoreType> > m_valuesummary;
+    QHash<ChannelID, QHash<EventStoreType, quint32> > m_timesummary;
+    QHash<ChannelID, EventDataType> m_gain;
 
     //! \brief Generates sum and time data for each distinct value in 'code' events..
     void updateCountSummary(ChannelID code);
@@ -166,50 +167,54 @@ public:
     void destroyEvent(ChannelID code);
 
     // UpdateSummaries may recalculate all these, but it may be faster setting upfront
-    void setCount(ChannelID id,int val) { m_cnt[id]=val; }
-    void setSum(ChannelID id,EventDataType val) { m_sum[id]=val; }
-    void setMin(ChannelID id,EventDataType val) { m_min[id]=val; }
-    void setMax(ChannelID id,EventDataType val) { m_max[id]=val; }
-    void setPhysMin(ChannelID id,EventDataType val) { m_physmin[id]=val; }
-    void setPhysMax(ChannelID id,EventDataType val) { m_physmax[id]=val; }
-    void updateMin(ChannelID id,EventDataType val) {
-        QHash<ChannelID,EventDataType>::iterator i=m_min.find(id);
-        if (i==m_min.end())
-            m_min[id]=val;
-        else if (i.value() > val)
+    void setCount(ChannelID id, int val) { m_cnt[id] = val; }
+    void setSum(ChannelID id, EventDataType val) { m_sum[id] = val; }
+    void setMin(ChannelID id, EventDataType val) { m_min[id] = val; }
+    void setMax(ChannelID id, EventDataType val) { m_max[id] = val; }
+    void setPhysMin(ChannelID id, EventDataType val) { m_physmin[id] = val; }
+    void setPhysMax(ChannelID id, EventDataType val) { m_physmax[id] = val; }
+    void updateMin(ChannelID id, EventDataType val) {
+        QHash<ChannelID, EventDataType>::iterator i = m_min.find(id);
+
+        if (i == m_min.end()) {
+            m_min[id] = val;
+        } else if (i.value() > val) {
             i.value() = val;
+        }
     }
-    void updateMax(ChannelID id,EventDataType val) {
-        QHash<ChannelID,EventDataType>::iterator i=m_max.find(id);
-        if (i==m_max.end())
-            m_max[id]=val;
-        else if (i.value() < val)
+    void updateMax(ChannelID id, EventDataType val) {
+        QHash<ChannelID, EventDataType>::iterator i = m_max.find(id);
+
+        if (i == m_max.end()) {
+            m_max[id] = val;
+        } else if (i.value() < val) {
             i.value() = val;
+        }
     }
 
-    void setAvg(ChannelID id,EventDataType val) { m_avg[id]=val; }
-    void setWavg(ChannelID id,EventDataType val) { m_wavg[id]=val; }
-//    void setMedian(ChannelID id,EventDataType val) { m_med[id]=val; }
-//    void set90p(ChannelID id,EventDataType val) { m_90p[id]=val; }
-//    void set95p(ChannelID id,EventDataType val) { m_95p[id]=val; }
-    void setCph(ChannelID id,EventDataType val) { m_cph[id]=val; }
-    void setSph(ChannelID id,EventDataType val) { m_sph[id]=val; }
-    void setFirst(ChannelID id,qint64 val) { m_firstchan[id]=val; }
-    void setLast(ChannelID id,qint64 val) { m_lastchan[id]=val; }
+    void setAvg(ChannelID id, EventDataType val) { m_avg[id] = val; }
+    void setWavg(ChannelID id, EventDataType val) { m_wavg[id] = val; }
+    //    void setMedian(ChannelID id,EventDataType val) { m_med[id]=val; }
+    //    void set90p(ChannelID id,EventDataType val) { m_90p[id]=val; }
+    //    void set95p(ChannelID id,EventDataType val) { m_95p[id]=val; }
+    void setCph(ChannelID id, EventDataType val) { m_cph[id] = val; }
+    void setSph(ChannelID id, EventDataType val) { m_sph[id] = val; }
+    void setFirst(ChannelID id, qint64 val) { m_firstchan[id] = val; }
+    void setLast(ChannelID id, qint64 val) { m_lastchan[id] = val; }
 
     int count(ChannelID id);
 
     //! \brief Returns the Count of all events of type id between time range
-    int rangeCount(ChannelID id, qint64 first,qint64 last);
+    int rangeCount(ChannelID id, qint64 first, qint64 last);
 
     //! \brief Returns the Sum of all events of type id between time range
-    double rangeSum(ChannelID id, qint64 first,qint64 last);
+    double rangeSum(ChannelID id, qint64 first, qint64 last);
 
     //! \brief Returns the minimum of events of type id between time range
-    EventDataType rangeMin(ChannelID id, qint64 first,qint64 last);
+    EventDataType rangeMin(ChannelID id, qint64 first, qint64 last);
 
     //! \brief Returns the maximum of events of type id between time range
-    EventDataType rangeMax(ChannelID id, qint64 first,qint64 last);
+    EventDataType rangeMax(ChannelID id, qint64 first, qint64 last);
 
     //! \brief Returns (and caches) the Sum of all events of type id
     double sum(ChannelID id);
@@ -248,7 +253,7 @@ public:
     EventDataType sph(ChannelID id);
 
     //! \brief Returns (without caching) the requested Percentile of all events of type id
-    EventDataType percentile(ChannelID id,EventDataType percentile);
+    EventDataType percentile(ChannelID id, EventDataType percentile);
 
     //! \brief Returns true if the channel has events loaded, or a record of a count for when they are not
     bool channelExists(ChannelID name);
@@ -257,18 +262,18 @@ public:
     bool channelDataExists(ChannelID id);
 
     bool IsLoneSession() { return s_lonesession; }
-    void SetLoneSession(bool b) { s_lonesession=b; }
+    void SetLoneSession(bool b) { s_lonesession = b; }
 
     bool eventsLoaded() { return s_events_loaded; }
 
     //! \brief Sets the event file linked to the summary (during load, for ondemand loading)
-    void SetEventFile(QString & filename) { s_eventfile=filename; }
+    void SetEventFile(QString &filename) { s_eventfile = filename; }
 
     //! \brief Update this sessions first time if it's less than the current record
-    inline void updateFirst(qint64 v) { if (!s_first) s_first=v; else if (s_first>v) s_first=v; }
+    inline void updateFirst(qint64 v) { if (!s_first) { s_first = v; } else if (s_first > v) { s_first = v; } }
 
     //! \brief Update this sessions latest time if it's more than the current record
-    inline void updateLast(qint64 v) { if (!s_last) s_last=v; else if (s_last<v) s_last=v; }
+    inline void updateLast(qint64 v) { if (!s_last) { s_last = v; } else if (s_last < v) { s_last = v; } }
 
     //! \brief Returns (and caches) the first time for Channel code
     qint64 first(ChannelID code);
@@ -280,11 +285,13 @@ public:
     void UpdateSummaries();
 
     //! \brief Creates and returns a new EventList for the supplied Channel code
-    EventList * AddEventList(ChannelID code, EventListType et, EventDataType gain=1.0, EventDataType offset=0.0, EventDataType min=0.0, EventDataType max=0.0, EventDataType rate=0.0, bool second_field=false);
+    EventList *AddEventList(ChannelID code, EventListType et, EventDataType gain = 1.0,
+                            EventDataType offset = 0.0, EventDataType min = 0.0, EventDataType max = 0.0,
+                            EventDataType rate = 0.0, bool second_field = false);
 
     //! \brief Returns this sessions MachineID
-    Machine * machine() { return s_machine; }
-protected:
+    Machine *machine() { return s_machine; }
+  protected:
     SessionID s_session;
 
     Machine *s_machine;