add Plot method setBorderless() for plots without axes/ticks/labels

Author: bhaller

QtSLiM/QtSLiMGraphView.cpp

@@ -75,10 +75,15 @@ QtSLiMGraphView::QtSLiMGraphView(QWidget *p_parent, QtSLiMWindow *controller) :
     connect(controller, &QtSLiMWindow::controllerTickFinished, this, &QtSLiMGraphView::controllerTickFinished);
     connect(controller, &QtSLiMWindow::controllerRecycled, this, &QtSLiMGraphView::controllerRecycled);
 
-    x0_ = 0.0;
-    x1_ = 1.0;
-    y0_ = 0.0;
-    y1_ = 1.0;
+    original_x0_ = 0.0;
+    original_x1_ = 1.0;
+    original_y0_ = 0.0;
+    original_y1_ = 1.0;
+    
+    x0_ = original_x0_;
+    x1_ = original_x1_;
+    y0_ = original_y0_;
+    y1_ = original_y1_;
 
     showXAxis_ = true;
     allowXAxisUserRescale_ = true;
@@ -283,21 +288,30 @@ QComboBox *QtSLiMGraphView::newButtonInLayout(QHBoxLayout *p_layout)
 
 QRect QtSLiMGraphView::interiorRectForBounds(QRect bounds)
 {
+    // The interiorRect is the area which QtSLiMGraphView clips the plotting within.  So it is the live plot
+    // area, within the axes of the plot.  In a borderless plot, it is the full interior area of the window,
+    // but afer setting up clipping drawContents() will inset the interiorRect by the margins given to
+    // setBorderless(); the data area will be inset by the margins, but not clipped to the margins.  This is
+    // conceptually similar to the 4% expansion of the axis ranges done in bordered plots.
     QRect interiorRect = bounds;
-	
-	// For now, 10 pixels margin on a side if there is no axis, 40 pixels margin if there is an axis
-	
-	if (showXAxis_)
+    
+    // If the plot is borderless, there is no inset for the interior rect at all
+    if (is_borderless_)
+        return interiorRect;
+    
+    // For now, 10 pixels margin on a side if there is no axis, 40 pixels margin if there is an axis
+    
+    if (showXAxis_)
         interiorRect.adjust(50, 0, -10, 0);
-	else
+    else
         interiorRect.adjust(10, 0, -10, 0);
-	
-	if (showYAxis_)
+    
+    if (showYAxis_)
         interiorRect.adjust(0, 50, 0, -10);
-	else
+    else
         interiorRect.adjust(0, 10, 0, -10);
-	
-	return interiorRect;
+    
+    return interiorRect;
 }
 
 double QtSLiMGraphView::plotToDeviceX(double plotx, QRect interiorRect)
@@ -1150,6 +1164,50 @@ void QtSLiMGraphView::drawLegendInInteriorRect(QPainter &painter, QRect interior
 	}
 }
 
+void QtSLiMGraphView::setBorderless(bool isBorderless, double marginLeft, double marginTop, double marginRight, double marginBottom)
+{
+    // Convert to/from a borderless plot; this is used only by custom plots
+    is_borderless_ = isBorderless;
+    
+    borderless_margin_left_ = marginLeft;
+    borderless_margin_top_ = marginTop;
+    borderless_margin_right_ = marginRight;
+    borderless_margin_bottom_ = marginBottom;
+    
+    // x0/y0/x1/y1 do not change, but changing our borderless value reconfigures the axis ranges; unless they have been
+    // explicitly set by the user in the QtSLiM UI, they get re-evaluated based upon the original axis range
+    if (!xAxisIsUIRescaled_)
+    {
+		// we generally try to maintain original_x0_ and original_x1_ in sync with x0_ and x1_, but this is the
+		// only place where original_x0_ and original_x1_ actually matter outside of where they are locally set
+		// up -- the only place where we re-set x0_ and x1_ back to their original values, because we want to
+		// re-generate a new axis range based upon a changed is_borderless_ value
+        x0_ = original_x0_;
+        x1_ = original_x1_;
+        
+        //std::cout << "is_borderless_ == " << (is_borderless_ ? "T" : "F") << std::endl;
+        //std::cout << "   BEFORE: x0_ == " << x0_ << ", x1_ == " << x1_ << ", xAxisMin_ == " << xAxisMin_ << ", xAxisMax_ == " << xAxisMax_ << std::endl;
+        
+        configureAxisForRange(x0_, x1_, xAxisMin_, xAxisMax_, xAxisMajorTickInterval_, xAxisMinorTickInterval_,
+                              xAxisMajorTickModulus_, xAxisTickValuePrecision_);
+        
+        //std::cout << "   AFTER: x0_ == " << x0_ << ", x1_ == " << x1_ << ", xAxisMin_ == " << xAxisMin_ << ", xAxisMax_ == " << xAxisMax_ << std::endl;
+    }
+    
+    if (!yAxisIsUIRescaled_)
+    {
+		// we generally try to maintain original_y0_ and original_y1_ in sync with y0_ and y1_, but this is the
+		// only place where original_y0_ and original_y1_ actually matter outside of where they are locally set
+		// up -- the only place where we re-set y0_ and y1_ back to their original values, because we want to
+		// re-generate a new axis range based upon a changed is_borderless_ value
+        y0_ = original_y0_;
+        y1_ = original_y1_;
+        
+        configureAxisForRange(y0_, y1_, yAxisMin_, yAxisMax_, yAxisMajorTickInterval_, yAxisMinorTickInterval_,
+                              yAxisMajorTickModulus_, yAxisTickValuePrecision_);
+    }
+}
+
 void QtSLiMGraphView::drawContents(QPainter &painter)
 {
     // Set to a default color of black; I thought Qt did this for me, but apparently not
@@ -1202,7 +1260,11 @@ void QtSLiMGraphView::drawContents(QPainter &painter)
 		// We clip the interior drawing to the interior rect, so outliers get clipped out
         painter.save();
         painter.setClipRect(interiorRect, Qt::IntersectClip);
-		
+        
+        // When drawing borderless, we have margins by which we inset interiorRect, but we clip to bounds
+        if (is_borderless_)
+            interiorRect.adjust(borderless_margin_left_, borderless_margin_bottom_, -borderless_margin_right_, -borderless_margin_top_);
+        
 		drawGraph(painter, interiorRect);
 
         painter.restore();
@@ -1211,21 +1273,30 @@ void QtSLiMGraphView::drawContents(QPainter &painter)
 		if (!cachingNow_)
 		{
 			// Overdraw axes, ticks, and axis labels, if requested
-            if (showXAxis_)
-				drawXAxis(painter, interiorRect);
-			
-			if (showYAxis_)
-				drawYAxis(painter, interiorRect);
-			
-            if (showFullBox_)
-				drawFullBox(painter,interiorRect);
-			
-			if (showXAxis_ && showXAxisTicks_)
-				drawXAxisTicks(painter, interiorRect);
-			
-			if (showYAxis_ && showYAxisTicks_)
-				drawYAxisTicks(painter, interiorRect);
-			
+            if (!is_borderless_)
+            {
+                if (showXAxis_)
+                    drawXAxis(painter, interiorRect);
+                
+                if (showYAxis_)
+                    drawYAxis(painter, interiorRect);
+                
+                if (showFullBox_)
+                    drawFullBox(painter, interiorRect);
+                
+                if (showXAxis_ && showXAxisTicks_)
+                    drawXAxisTicks(painter, interiorRect);
+                
+                if (showYAxis_ && showYAxisTicks_)
+                    drawYAxisTicks(painter, interiorRect);
+            }
+            else
+            {
+                // when borderless, the "full box", if requested, frames the full bounds
+                if (showFullBox_)
+                    QtSLiMFrameRect(bounds, Qt::black, painter);
+            }
+            
 			// Overdraw the legend
 			if (legendVisible_)
 				drawLegendInInteriorRect(painter, interiorRect);
@@ -1582,10 +1653,14 @@ void QtSLiMGraphView::contextMenuEvent(QContextMenuEvent *p_event)
                     xAxisTickValuePrecision_ = choices[4].toInt();
                     xAxisMinorTickInterval_ = xAxisMajorTickInterval_ / xAxisMajorTickModulus_;
                     xAxisIsUserRescaled_ = true;
+                    xAxisIsUIRescaled_ = true;
 
                     // for now, these are the same, except in custom plots
-                    x0_ = xAxisMin_;
-                    x1_ = xAxisMax_;
+                    original_x0_ = xAxisMin_;
+                    original_x1_ = xAxisMax_;
+                    
+                    x0_ = original_x0_;
+                    x1_ = original_x1_;
 
                     invalidateDrawingCache();
                     update();
@@ -1608,10 +1683,14 @@ void QtSLiMGraphView::contextMenuEvent(QContextMenuEvent *p_event)
                         yAxisTickValuePrecision_ = choices[4].toInt();
                         yAxisMinorTickInterval_ = yAxisMajorTickInterval_ / yAxisMajorTickModulus_;
                         yAxisIsUserRescaled_ = true;
+                        yAxisIsUIRescaled_ = true;
 
                         // for now, these are the same, except in custom plots
-                        y0_ = yAxisMin_;
-                        y1_ = yAxisMax_;
+                        original_y0_ = yAxisMin_;
+                        original_y1_ = yAxisMax_;
+                        
+                        y0_ = original_y0_;
+                        y1_ = original_y1_;
 
                         invalidateDrawingCache();
                         update();
@@ -1632,7 +1711,8 @@ void QtSLiMGraphView::contextMenuEvent(QContextMenuEvent *p_event)
                             yAxisMax_ = (double)newPower;
 
                             // for now, these are the same, except in custom plots
-                            y1_ = yAxisMax_;
+                            original_y1_ = yAxisMax_;
+                            y1_ = original_y1_;
 
                             invalidateDrawingCache();
                             update();
@@ -1754,7 +1834,8 @@ void QtSLiMGraphView::setXAxisRangeFromTick(void)
 		xAxisTickValuePrecision_ = 0;
 
         // for now, these are the same, except in custom plots
-        x1_ = xAxisMax_;
+        original_x1_ = xAxisMax_;
+        x1_ = original_x1_;
 	}
 	else
 	{
@@ -1766,18 +1847,30 @@ void QtSLiMGraphView::setXAxisRangeFromTick(void)
 		xAxisTickValuePrecision_ = 0;
 
         // for now, these are the same, except in custom plots
-        x1_ = xAxisMax_;
+        original_x1_ = xAxisMax_;
+        x1_ = original_x1_;
 	}
 }
 
 void QtSLiMGraphView::configureAxisForRange(double &dim0, double &dim1, double &axisMin, double &axisMax,
                                             double &majorTickInterval, double &minorTickInterval,
                                             int &majorTickModulus, int &tickValuePrecision)
 {
-    // We call down to our R-inspired axis calculation methods to figure out a good axis layout.
-    // The call here, to _GScale(), is parallel to the point in R's plot.window() function where
-    // it calls down to GScale() for each of the two axes.
+    if (is_borderless_)
+    {
+        // For borderless plots, we leave the axis range untouched; the axis range does not get outset.
+        // However, drawContents() will inset the interiorRect by the margins given to setBorderless();
+        // that provides a similar way of framing the data with margins around them.
+        axisMin = dim0;
+        axisMax = dim1;
+    }
+    else
     {
+        // We call down to our R-inspired axis calculation methods to figure out a good axis layout.
+        // The call here, to _GScale(), is parallel to the point in R's plot.window() function where
+        // it calls down to GScale() for each of the two axes.  Note that this branch modifies dim0
+        // and dim1; we keep the "original_" versions of the axis ranges so that we can back that out
+        // in setBorderless().
         int nDivisions;
 
         //qDebug() << "configureAxisForRange() : original dim0 ==" << dim0 << ", dim1 ==" << dim1;

QtSLiM/QtSLiMGraphView.h

@@ -106,6 +106,8 @@ class QtSLiMGraphView : public QWidget
     virtual QString aboutString(void) = 0;
     virtual void drawGraph(QPainter &painter, QRect interiorRect);
 
+    void setBorderless(bool isBorderless, double marginLeft, double marginTop, double marginRight, double marginBottom);
+    
     bool writeToFile(QString fileName);
 
 public slots:
@@ -186,17 +188,25 @@ public slots:
     size_t tallyGUIMutationReferences(const std::vector<Haplosome *> &haplosomes, int muttype_index);
 
     // Properties; initialized in the constructor, these defaults are just zero-fill
-    // Note that the bounds in user coordinates (x0_/x1_/y0_/y1_) are now separate from
-    // the axis limits (xAxisMin_, ...), but at present they are always the same except
-    // for custom plots.  That may change, going forward, to improve axis behavior.
+    // The bounds in user coordinates (x0_/x1_/y0_/y1_) are the actual extents of the
+    // axes; this is somewhat unrelated to the positions at which tick and labels are
+    // drawn, which are prettified.  The axis limits (xAxisMin_, xAxisMax_, ...) express
+    // the limits of tick marks; they are the conceptual limits of the axes, but
+    // typically there are margins of 4% or so outside of that range so the data isn't
+    // right up against the edges of the plot.  The original axis limits provided
+    // by the user are kept in original_x0_ etc., since x0_ and xAxisMin_ do not
+    // necessarily reflect the original values; they can get changed for aesthetics.
+    // See QtSLiMGraphView::setBorderless() for the reason we need the original values.
+    double original_x0_ = 0.0, original_x1_ = 0.0, original_y0_ = 0.0, original_y1_ = 0.0;
     double x0_ = 0.0, x1_ = 0.0, y0_ = 0.0, y1_ = 0.0;  // coordinate space bounds
 
     double axisLabelSize_ = 15;
     double tickLabelSize_ = 10;
 
     bool showXAxis_ = false;
     bool allowXAxisUserRescale_ = false;
-    bool xAxisIsUserRescaled_ = false;
+    bool xAxisIsUserRescaled_ = false;      // the user gave a custom axis scale in any way (such as in createPlot())
+    bool xAxisIsUIRescaled_ = false;        // the user gave a custom axis scale in the QtSLiM UI, which has precedence
     bool showXAxisTicks_ = false;
     double xAxisMin_ = 0.0, xAxisMax_ = 0.0;
     double xAxisMajorTickInterval_ = 0.0, xAxisMinorTickInterval_ = 0.0;
@@ -210,7 +220,8 @@ public slots:
 
     bool showYAxis_ = false;
     bool allowYAxisUserRescale_ = false;
-    bool yAxisIsUserRescaled_ = false;
+    bool yAxisIsUserRescaled_ = false;      // the user gave a custom axis scale in any way (such as in createPlot())
+    bool yAxisIsUIRescaled_ = false;        // the user gave a custom axis scale in the QtSLiM UI, which has precedence
     bool showYAxisTicks_ = false;
     double yAxisMin_ = 0.0, yAxisMax_ = 0.0;
     double yAxisMajorTickInterval_ = 0.0, yAxisMinorTickInterval_ = 0.0;
@@ -242,6 +253,15 @@ public slots:
 
     bool tweakXAxisTickLabelAlignment_ = false;
 
+    // borderless plots show no axes, no ticks, no labels; this feature is used only for custom plots
+    // for borderless plots, the plot region is the whole window area, and the data range fills the plot
+    // that is inset by the margins given here, measured in pixels, to allow a bit of overflow
+    bool is_borderless_ = false;
+    double borderless_margin_left_ = 0.0;
+    double borderless_margin_right_ = 0.0;
+    double borderless_margin_top_ = 0.0;
+    double borderless_margin_bottom_ = 0.0;
+    
     // Prefab additions properties
     int histogramBinCount_ = 0;
     bool allowBinCountRescale_ = false;

QtSLiM/QtSLiMGraphView_1DSampleSFS.cpp

@@ -40,16 +40,22 @@ QtSLiMGraphView_1DSampleSFS::QtSLiMGraphView_1DSampleSFS(QWidget *p_parent, QtSL
     histogramBinCount_ = 20;        // this is also the haplosome sample size
     allowBinCountRescale_ = false;
 
-    x0_ = 0;
-    x1_ = histogramBinCount_;
+    original_x0_ = 0;
+    original_x1_ = histogramBinCount_;
+    
+    x0_ = original_x0_;
+    x1_ = original_x1_;
 
     xAxisMin_ = x0_;
     xAxisMax_ = x1_;
     xAxisHistogramStyle_ = true;
     xAxisTickValuePrecision_ = 0;
 
-    y0_ = -0.05;      // on log scale; we want a frequency of 1 to show slightly above baseline
-    y1_ = 3.0;        // on log scale; maximum power of 10
+    original_y0_ = -0.05;      // on log scale; we want a frequency of 1 to show slightly above baseline
+    original_y1_ = 3.0;        // on log scale; maximum power of 10
+    
+    y0_ = original_y0_;
+    y1_ = original_y1_;
 
     yAxisMin_ = y0_;
     yAxisMax_ = y1_;
@@ -245,7 +251,8 @@ void QtSLiMGraphView_1DSampleSFS::changeSampleSize(void)
         {
             histogramBinCount_ = newSampleSize;
             xAxisMax_ = histogramBinCount_;
-            x1_ = histogramBinCount_;               // the same as xAxisMax_, for base plots
+            original_x1_ = histogramBinCount_;               // the same as xAxisMax_, for base plots
+            x1_ = original_x1_;
             invalidateCachedData();
             update();
         }