• Should gap and line thickness be scaled or what would be the expected behavior?
  
• Is NatTable doing something special here?
  
• And if so, why would NatTable have to do something special should this not be handled by SWT?
  
• If the issues only emerges with the SWT switch in play is it then really relevant or more to the point how relevant do you deem the issue?
  
• For example should the SWT switch be used when scaling is done via Windows anyways?
  
• Maybe we are not using the switch correctly?
  
• Has somebody else had the problem and maybe even found a workaround.
  

Should gap and line thickness be scaled or what would be the expected behavior?

Is NatTable doing something special here?

And if so, why would NatTable have to do something special should this not be handled by SWT?

If the issues only emerges with the SWT switch in play is it then really relevant or more to the point how relevant do you deem the issue?

For example should the SWT switch be used when scaling is done via Windows anyways?

Maybe we are not using the switch correctly?

As said before, NatTable does the upscaling internally by inspecting the DPI from the display. So from a NatTable point of view, that flag is not needed as it is not inspected.

    @Override
    public Control createExampleControl(Composite parent) {
        NatTable natTable = new NatTable(parent);
        natTable.setBackground(natTable.getShell().getDisplay().getSystemColor(SWT.COLOR_CYAN));
        return natTable;
    }

NatTable has not implemented anything to scale line thickness. You can see this also for line border decorators. That would be something we need to add. But there should be no gap. Might be some rounding issue because the rendering of the background is done taking the grid lines into account. And IIRC the issue is that they move a little bit more than they should. At least it was similar on printing.
...
NatTable is a custom painted control based on Canvas, so scaling is implemented internally. Some places seem to be missing like for example the grid lines.

As said before, NatTable does the upscaling internally by inspecting the DPI from the display. So from a NatTable point of view, that flag is not needed as it is not inspected.

• The NatTable scaling is never active because org.eclipse.nebula.widgets.nattable.util.GUIHelper.getDpiFactor(int) always returns 1 (even in a 4k environment with OS scaling disabled). This based on Display.getDefault().getDPI().x which returns 96. This makes sense becuase SWT uses org.eclipse.swt.internal.DPIUtil.deviceZoom for scaling.
  
  
• The acutal line width used for painting is set in
  

  org.eclipse.nebula.widgets.nattable.painter.layer.GridLineCellLayerPainter.paintLayer(ILayer, GC, int, int, Rectangle, IConfigRegistry)
  {
  ...
          // Draw GridLines
          if (this.renderGridLines) {
              // check if there is a configuration for the grid line width
              Integer width = configRegistry.getConfigAttribute(
                      CellConfigAttributes.GRID_LINE_WIDTH,
                      DisplayMode.NORMAL,
                      labels);
              this.gridLineWidth = (width != null) ? width : 1;
  
              int oldLineWidth = gc.getLineWidth();
              gc.setLineWidth(this.gridLineWidth);
  ...
  }
  

  
  
• For some reason in the context of NatTable a line width of exactly 1 is not scaled when painting. From what I can tell this should not be the case and is the reason for the issue. Please also see [1]. Any line width > 0 should be scaled with the swt.autoScale switch. Using a line width > 1 such as 2 works as expected, i.e. the line is scaled.
  
  
• As a workaround we set the scaled line width manually before calling #paintLayer : gc.setLineWidth(DPIUtil.autoScaleUp(this.gridLineWidth));
  
• NOTE gc.getGCData().lineWidth works as well in this case and returns 2.0f and might indicate that the scaling is partly applied but not working.
  
  
• This workaround works only for cells. If you point us to where the headers/borders are painted we could check this as well.
  
  

NatTable is based on Eclipse Helios with regards to the SWT API in use. Making use of a current API would possibly break existing projects that are not able to use the latest SWT API. So you need to be careful with a contribution.

I also think setting GC#setLineWidth() before paintLayer() is not correct. Other painters might change that on the way. So you would need to adjust that in every painter.
So to answer your question, you need to check every ILayerPainter and ICellPainter and check for occurences where a line width is not set correcly according to the scaling.
And you also need to ensure that the cell bounds are set correctly in adjustCellBounds. And the CompositeLayer needs to be adjusted to calculate not with a 1 pixel fixed border.