Add docstrings to LfpDisplayNode

Author: jsiegle

Plugins/LfpDisplayNode/LfpChannelDisplay.cpp

@@ -780,6 +780,11 @@ void LfpChannelDisplay::setInputInverted(bool isInverted)
     }
 }
 
+bool LfpChannelDisplay::getInputInverted()
+{
+    return inputInverted;
+}
+
 void LfpChannelDisplay::setDrawMethod(bool isDrawMethod)
 {
 

Plugins/LfpDisplayNode/LfpChannelDisplay.h

@@ -129,6 +129,9 @@ class LfpChannelDisplay : public Component
     /** Sets whether this channel display should be inverted */
     void setInputInverted(bool);
 
+    /** Returns whether this channel display is inverted */
+    bool getInputInverted();
+
     /** Sets whether this channel display can be inverted */
     void setCanBeInverted(bool);
 

Plugins/LfpDisplayNode/LfpDisplay.cpp

@@ -113,9 +113,9 @@ LfpDisplay::LfpDisplay(LfpDisplaySplitter* c, Viewport* v)
 
     addMouseListener(this, true);
 
-    for (int i = 0; i < 8; i++)
+    for (int ttlLine = 0; ttlLine < 8; ttlLine++)
     {
-        eventDisplayEnabled[i] = true;
+        eventDisplayEnabled[ttlLine] = true;
     }
 
     savedChannelState.insertMultiple(0, true, 10000); // max 10k channels
@@ -444,7 +444,7 @@ void LfpDisplay::refresh()
         totalPixelsToFill = canvasSplit->screenBufferWidth - fillfrom + fillto;
     }
 
-	//std::cout << fillfrom << " : " << fillto << " ::: " << "totalPixelsToFill: " << totalPixelsToFill << std::endl;
+	std::cout << fillfrom << " : " << fillto << " ::: " << "totalPixelsToFill: " << totalPixelsToFill << std::endl;
 
     int topBorder = viewport->getViewPositionY();
     int bottomBorder = viewport->getViewHeight() + topBorder;
@@ -659,6 +659,19 @@ void LfpDisplay::setInputInverted(bool isInverted)
 
 }
 
+Array<bool> LfpDisplay::getInputInverted()
+{
+
+    Array<bool> invertedState;
+
+    for (int i = 0; i < numChans; i++)
+    {
+		invertedState.add(channels[i]->getInputInverted());
+    }
+
+    return invertedState;
+}
+
 void LfpDisplay::setDrawMethod(bool isDrawMethod)
 {
     for (int i = 0; i < numChans; i++)
@@ -715,6 +728,13 @@ void LfpDisplay::orderChannelsByDepth(bool state)
 
 }
 
+bool LfpDisplay::shouldOrderChannelsByDepth()
+{
+
+    return channelsOrderedByDepth;
+
+}
+
 int LfpDisplay::getChannelDisplaySkipAmount()
 {
     return displaySkipAmt;
@@ -1238,15 +1258,15 @@ void LfpDisplay::mouseDown(const MouseEvent& event)
 
 }
 
-bool LfpDisplay::setEventDisplayState(int ch, bool state)
+bool LfpDisplay::setEventDisplayState(int ttlLine, bool state)
 {
-    eventDisplayEnabled[ch] = state;
-    return eventDisplayEnabled[ch];
+    eventDisplayEnabled[ttlLine] = state;
+    return eventDisplayEnabled[ttlLine];
 }
 
-bool LfpDisplay::getEventDisplayState(int ch)
+bool LfpDisplay::getEventDisplayState(int ttlLine)
 {
-    return eventDisplayEnabled[ch];
+    return eventDisplayEnabled[ttlLine];
 }
 
 void LfpDisplay::setEnabledState(bool state, int chan, bool updateSaved)

Plugins/LfpDisplayNode/LfpDisplay.h

@@ -44,7 +44,8 @@ namespace LfpViewer {
     bitmap is drawn by the LfpViewport using Viewport::setViewedComponent.
  
  */
-class LfpDisplay : public Component, public Timer
+class LfpDisplay : public Component, 
+                   public Timer
 {
 public:
 
@@ -96,15 +97,25 @@ class LfpDisplay : public Component, public Timer
     /** Returns the display range for the specified channel type */
 	int getRange(ContinuousChannel::Type type);
 
+    /** Sets the channel height in pixels */
     void setChannelHeight(int r, bool resetSingle = true);
+
+    /** Returns the channel height in pixels */
     int getChannelHeight();
-    
-    ChannelColourScheme * getColourSchemePtr();
-        
+
     /** Caches a new channel height without updating the channels */
     void cacheNewChannelHeight(int r);
 
+    /** Gets a pointer to the current color scheme */
+    ChannelColourScheme* getColourSchemePtr();
+        
+    /** Sets whether the input should be inverted */
     void setInputInverted(bool);
+
+    /** Returns whether the input should be inverted across all channels */
+    Array<bool> getInputInverted();
+
+    /** Changes between super-sampled and per-pixel plotter */
     void setDrawMethod(bool);
 
     /** Returns a bool indicating if the channels are displayed in reverse order (true) */
@@ -115,30 +126,50 @@ class LfpDisplay : public Component, public Timer
 
     /** Reorders the displayed channels by depth if state == true and normal if false */
     void orderChannelsByDepth(bool state);
+
+    /** Returns true if channels are ordered by depth */
+    bool shouldOrderChannelsByDepth();
 
     /** Returns a factor of 2 by which the displayed channels should skip */
     int getChannelDisplaySkipAmount();
 
     /** Set the amount of channels to skip (hide) between each that is displayed */
     void setChannelDisplaySkipAmount(int skipAmt);
 
+    /** Updates colors across channels */
     void setColors();
 
+    /** Sets the index of the selected color scheme */
     void setActiveColourSchemeIdx(int index);
+
+    /** Gets the index of the selected color scheme */
     int getActiveColourSchemeIdx();
 
+    /** Returns the number of available color schemes*/
     int getNumColourSchemes();
+
+    /** Returns the names of the available color schemes*/
     StringArray getColourSchemeNameArray();
 
-    bool setEventDisplayState(int ch, bool state);
-    bool getEventDisplayState(int ch);
+    /** Sets whether events are displayed for a particular ttl line*/
+    bool setEventDisplayState(int ttlLine, bool state);
+
+    /** Returns whether events are displayed for a particular ttl line */
+    bool getEventDisplayState(int ttlLine);
 
+    /** Returns the number of adjacent channels of each color */
     int getColorGrouping();
+
+    /** Sets the number of adjacent channels of each color */
     void setColorGrouping(int i);
 
+    /** Sets whether a particular channel is enabled */
     void setEnabledState(bool state, int chan, bool updateSavedChans = true);
-    bool getEnabledState(int);
+
+    /** Returns whether a particular channel is enabled */
+    bool getEnabledState(int chan);
 
+    /** Sets the scroll offset for this display*/
     void setScrollPosition(int x, int y);
 
     /** Returns true if the median offset is enabled for plotting, else false */
@@ -187,9 +218,8 @@ class LfpDisplay : public Component, public Timer
         LfpChannelDisplayInfo* channelInfo;
     };
 
-    Array<LfpChannelTrack> drawableChannels;        // holds the channels and info that are
-                                                // drawable to the screen
-
+    /** Holds the channels that are being drawn */
+    Array<LfpChannelTrack> drawableChannels;
 
     /** Set the viewport's channel focus behavior.
      
@@ -214,18 +244,25 @@ class LfpDisplay : public Component, public Timer
     /** Returns a const pointer to the internally managed plotter method class */
     LfpBitmapPlotter * const getPlotterPtr() const;
 
+    /** Current background color (based on the selected color scheme)*/
     Colour backgroundColour;
 
+    /** Array of channel colors (based on the selected color scheme*/
     Array<Colour> channelColours;
 
-    OwnedArray<LfpChannelDisplay> channels;             // all channels
-    OwnedArray<LfpChannelDisplayInfo> channelInfo;      // all channelInfos
+    /** All available channels (even ones that are not drawn) */
+    OwnedArray<LfpChannelDisplay> channels;
 
-    void timerCallback() override;
-
+    /** All available display info objects (even ones that are not drawn) */
+    OwnedArray<LfpChannelDisplayInfo> channelInfo;
+    
+    /** Holds state of event display for first 8 ttl lines */
     bool eventDisplayEnabled[8];
-    bool displayIsPaused = false; // simple pause function, skips screen buffer updates
 
+    /** Enables simple pause function by skipping screen buffer updates */
+    bool displayIsPaused = false; 
+
+    /** Pointer to display options*/
     LfpDisplayOptions* options;
 
     /** Convenience struct to store all variables particular to zooming mechanics */
@@ -246,13 +283,19 @@ class LfpDisplay : public Component, public Timer
         bool unpauseOnScrollEnd;
     };
 
-    TrackZoomInfo_Struct trackZoomInfo; // and create an instance here
+    /** Instance of trackZoomInfo struct */
+    TrackZoomInfo_Struct trackZoomInfo; 
 
+    /** Stores whether or not channels are enabled */
     Array<bool> savedChannelState;
 
+    /** x-index of display bitmap updated on previous refresh */
     int lastBitmapIndex;
 
 private:
+
+    /** Used to throttle refresh speed when scrolling backwards */
+    void timerCallback() override;
 
     int singleChan;
 
@@ -266,7 +309,10 @@ class LfpDisplay : public Component, public Timer
 
     int numChans;
     int displaySkipAmt;
-    int cachedDisplayChannelHeight;     // holds a channel height if reset during single channel focus
+
+    /** Holds a channel height if reset during single channel focus */
+    int cachedDisplayChannelHeight;
+    
     float drawableSampleRate;
     uint32 drawableSubprocessor;
 
@@ -297,5 +343,5 @@ class LfpDisplay : public Component, public Timer
     OwnedArray<ChannelColourScheme> colourSchemeList;
 };
 
-}; // namespace
+}; // end LfpViewer namespace
 #endif

Plugins/LfpDisplayNode/LfpDisplayCanvas.cpp

@@ -560,7 +560,7 @@ void LfpDisplayCanvas::mouseUp(const MouseEvent& e)
 {
     if (borderToDrag >= 0)
     {
-        std::cout << "Mouse up" << std::endl;
+        //std::cout << "Mouse up" << std::endl;
 
         resized();
         borderToDrag = -1;
@@ -967,22 +967,22 @@ void LfpDisplaySplitter::updateSettings()
 
     }
 
-    lfpDisplay->rebuildDrawableChannelsList();
+    lfpDisplay->rebuildDrawableChannelsList(); // calls setColors(), which calls refresh
 
     isLoading = false;
 
-    syncDisplay();
-    syncDisplayBuffer();
+    syncDisplay(); // sets lastBitmapIndex to 0
+    syncDisplayBuffer(); // sets displayBufferIndex to 0
 
     isUpdating = false;
 
-    lfpDisplay->setColors();
+    //lfpDisplay->setColors(); // calls refresh
 
     resized();
 
     lfpDisplay->restoreViewPosition();
 
-    lfpDisplay->refresh();
+    //lfpDisplay->refresh(); // calls refresh
 
 }
 
@@ -1249,7 +1249,7 @@ void LfpDisplaySplitter::updateScreenBuffer()
 
            // HELPFUL FOR DEBUGGING: 
 
-            /*if (channel == 0)
+            if (channel == 0)
                 std::cout << "Split "
                 << splitID << " ch: "
                 << channel << " sbi: "
@@ -1262,7 +1262,7 @@ void LfpDisplaySplitter::updateScreenBuffer()
                 << subSampleOffset << " max: "
                 << maxSamples << " playhead: "
                 << lfpDisplay->lastBitmapIndex
-                << std::endl;*/
+                << std::endl;
 
             int sampleNumber = 0;
 
@@ -1483,6 +1483,16 @@ void LfpDisplaySplitter::setTimebase(float t)
 {
     timebase = t;
 
+    if (timebase <= 0.1)
+    {
+        stopTimer();
+        startTimer(1000);
+    }
+    else {
+        stopTimer();
+        startTimer(50);
+    }
+
     if (trialAveraging)
     {
         numTrials = -1;
@@ -1660,8 +1670,11 @@ void LfpDisplaySplitter::visibleAreaChanged()
 
 void LfpDisplaySplitter::refresh()
 {
+    
     updateScreenBuffer();
-    if(shouldRebuildChannelList) {
+    
+    if(shouldRebuildChannelList) 
+    {
         shouldRebuildChannelList = false;
         lfpDisplay->rebuildDrawableChannelsList(); // calls resized()/refresh() after rebuilding list
     }

Plugins/LfpDisplayNode/LfpDisplayOptions.cpp

@@ -775,6 +775,10 @@ void LfpDisplayOptions::togglePauseButton(bool sendUpdate)
 
 void LfpDisplayOptions::setChannelsReversed(bool state)
 {
+
+    if (lfpDisplay->getChannelsReversed() == state) // ignore if we're not changing state
+        return;
+
     lfpDisplay->setChannelsReversed(state);
     canvasSplit->fullredraw = true;
 
@@ -791,6 +795,7 @@ void LfpDisplayOptions::setChannelsReversed(bool state)
 
 void LfpDisplayOptions::setInputInverted(bool state)
 {
+    
     lfpDisplay->setInputInverted(state);
 
     invertInputButton->setToggleState(state, dontSendNotification);
@@ -849,6 +854,9 @@ void LfpDisplayOptions::setAveraging(bool state)
 void LfpDisplayOptions::setSortByDepth(bool state)
 {
 
+    if (lfpDisplay->shouldOrderChannelsByDepth() == state)
+        return;
+         
     if (canvasSplit->displayBuffer != nullptr)
         lfpDisplay->orderChannelsByDepth(state);
 
@@ -1504,7 +1512,10 @@ void LfpDisplayOptions::loadParameters(XmlElement* xml)
             //LOGD("    --> setShowChannelNumbers: ", MS_FROM_START, " milliseconds");
             start = Time::getHighResolutionTicks();
 
-            setInputInverted(xmlNode->getBoolAttribute("isInverted", false));
+            bool shouldInvert = xmlNode->getBoolAttribute("isInverted", false);
+            
+			if (invertInputButton->getToggleState() != shouldInvert)
+                setInputInverted(shouldInvert);
 
             //LOGD("    --> setInputInverted: ", MS_FROM_START, " milliseconds");
             start = Time::getHighResolutionTicks();