OS X: Clicks on fully transparent parts of windows no longer passes through in Qt 5.6

// mainwindow.h
#include <QMainWindow>

class MainWindow : public QMainWindow
{
	Q_OBJECT
public:
	MainWindow(QWidget *parent = 0);
protected:
	void paintEvent(QPaintEvent *);
};

// main.cpp
#include <QApplication>
#include <QPainter>
#include "mainwindow.h"

MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent)
{
    setAttribute(Qt::WA_TranslucentBackground);
	setWindowFlags(Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint);
}

void MainWindow::paintEvent(QPaintEvent *)
{
	QPainter windowPainter(this);
	windowPainter.setBrush(Qt::red);
	windowPainter.drawRect(QRect(0,0,50,50));
	windowPainter.setBrush(Qt::transparent);
	windowPainter.drawRect(rect().adjusted(0,0,-1,-1));
}

int main(int argc, char *argv[])
{
	QApplication a(argc, argv);
	MainWindow window;	
	window.show();
	return a.exec();
}

void MyWindow::updateMask()
{
    // In my case, the window contains a single top-level widget that does all of
    // the rendering named contentsWidget.
    // In order for this method to work, your widgets may need to be structured
    // like that too:
    QRect grabRect = rect().translated(-contentsWidget->geometry().topLeft());
    QBitmap widgetMask = contentsWidget->grab(grabRect).mask();
    
    if (devicePixelRatio() == 2) {
        // Unfortunately masks cannot be retina resolution, so if our widget is
        // on a retina display, we have to generate a mask at non-retina
        // resolution. But just rendering on a non-retina paint device and then
        // generating a mask unfortunately doesn't work, as there'll inevitably
        // be some pixels in the mask that should be black but are actually
        // white. The right way to do it is to render at retina resolution, and
        // then scale the bitmap mask down to the right size. But a normal
        // scale won't do -- each pixel on our mask needs to be black if any of
        // the four retina pixels that comprise it are black, i.e. a bitwise-OR
        // of the four pixels. So we need to do the scaling ourselves:
        QImage maskImage = widgetMask.toImage();    
        QImage scaledMaskImage(maskImage.size()/2, maskImage.format());
        
        for(int y = 0; y < scaledMaskImage.height(); ++y) {
            uint16_t *line1 = (uint16_t *)maskImage.scanLine(y*2);
            uint16_t *line2 = (uint16_t *)maskImage.scanLine(y*2+1);
            uint8_t *line = scaledMaskImage.scanLine(y);
            
            for(int x = 0; x < scaledMaskImage.bytesPerLine(); ++x) {
                uint16_t a = line1[x];
                uint16_t b = line2[x];
                
                // This expression is the simplified version of the full expression
                // that will combine the mask's bits together as described above.
                line[x] = ~uint8_t((a     & 0x0001) |
                                   (a>>1  & 0x0003) |
                                   (a>>2  & 0x0006) |
                                   (a>>3  & 0x000C) |
                                   (a>>4  & 0x0018) |
                                   (a>>5  & 0x0030) |
                                   (a>>6  & 0x0060) |
                                   (a>>7  & 0x00C0) |
                                   (a>>8  & 0x0080) |                
                                   (b     & 0x0001) |
                                   (b>>1  & 0x0003) |
                                   (b>>2  & 0x0006) |
                                   (b>>3  & 0x000C) |
                                   (b>>4  & 0x0018) |
                                   (b>>5  & 0x0030) |
                                   (b>>6  & 0x0060) |
                                   (b>>7  & 0x00C0) |
                                   (b>>8  & 0x0080));                
                // Not sure why it's necessary to negate this value given that
                // we're using the same format of image as the original mask
            }
        }

        setMask(QBitmap::fromImage(scaledMaskImage));
    } else {
        setMask(widgetMask);
    }
}

void MyWindow::updateMask()
{
    // In my case, the window contains a single top-level widget that does all of
    // the rendering named contentsWidget.
    // In order for this method to work, your widgets may need to be structured
    // like that too:
    QRect grabRect = rect().translated(-contentsWidget->geometry().topLeft());
    QBitmap widgetMask = contentsWidget->grab(grabRect).mask();
    
    if (devicePixelRatio() == 2) {
        // Unfortunately masks cannot be retina resolution, so if our widget is
        // on a retina display, we have to generate a mask at non-retina
        // resolution. But just rendering on a non-retina paint device and then
        // generating a mask unfortunately doesn't work, as there'll inevitably
        // be some pixels in the mask that should be black but are actually
        // white. The right way to do it is to render at retina resolution, and
        // then scale the bitmap mask down to the right size. But a normal
        // scale won't do -- each pixel on our mask needs to be black if any of
        // the four retina pixels that comprise it are black, i.e. a bitwise-OR
        // of the four pixels. So we need to do the scaling ourselves:
        QImage maskImage = widgetMask.toImage();    
        QImage scaledMaskImage(maskImage.size()/2, maskImage.format());
        
        for(int y = 0; y < scaledMaskImage.height(); ++y) {
            uint16_t *line1 = (uint16_t *)maskImage.scanLine(y*2);
            uint16_t *line2 = (uint16_t *)maskImage.scanLine(y*2+1);
            uint8_t *line = scaledMaskImage.scanLine(y);
            
            for(int x = 0; x < scaledMaskImage.bytesPerLine(); ++x) {
                uint16_t a = line1[x];
                uint16_t b = line2[x];
                
                // This expression is the simplified version of the full expression
                // that will combine the mask's bits together as described above.
                line[x] = ~uint8_t((a     & 0x0001) |
                                   (a>>1  & 0x0003) |
                                   (a>>2  & 0x0006) |
                                   (a>>3  & 0x000C) |
                                   (a>>4  & 0x0018) |
                                   (a>>5  & 0x0030) |
                                   (a>>6  & 0x0060) |
                                   (a>>7  & 0x00C0) |
                                   (a>>8  & 0x0080) |                
                                   (b     & 0x0001) |
                                   (b>>1  & 0x0003) |
                                   (b>>2  & 0x0006) |
                                   (b>>3  & 0x000C) |
                                   (b>>4  & 0x0018) |
                                   (b>>5  & 0x0030) |
                                   (b>>6  & 0x0060) |
                                   (b>>7  & 0x00C0) |
                                   (b>>8  & 0x0080));                
                // Not sure why it's necessary to negate this value given that
                // we're using the same format of image as the original mask
            }
        }

        setMask(QBitmap::fromImage(scaledMaskImage));
    } else {
        setMask(widgetMask);
    }
}