gdi32 draw.ts Rectangle add Palette

[wintops]

  if (isPaletteIndex(brush.color)) {
          const pal = emu.handles.get<PaletteInfo>(dc.selectedPalette);
          const [r, g, b] = resolveColor(brush.color, pal);
          dc.ctx.fillStyle = `rgb(${r},${g},${b})`;
        } 
    
else    
      dc.ctx.fillStyle = colorToCSS(brush.color);
      dc.ctx.fillRect(left, top, right - left, bottom - top);
    }

user32 FillRect too

[wintops]

`
gdi32.register('StretchDIBits', 13, () => {
const hdc = emu.readArg(0);
const xDest = emu.readArg(1) | 0;
const yDest = emu.readArg(2) | 0;
const destWidth = emu.readArg(3);
const destHeight = emu.readArg(4);
const xSrc = emu.readArg(5) | 0;
const ySrc = emu.readArg(6) | 0;
const srcWidth = emu.readArg(7);
const srcHeight = emu.readArg(8);
const bitsPtr = emu.readArg(9);
const bmiPtr = emu.readArg(10);
const fuUsage = emu.readArg(11); // DIB_RGB_COLORS=0, DIB_PAL_COLORS=1
const rop = emu.readArg(12); // 一般传 SRCCOPY = 0x00CC0020

const dc = emu.getDC(hdc);
if (!dc || !bitsPtr || !bmiPtr) return 0;

// 读取 BITMAPINFOHEADER
const biSize = emu.memory.readU32(bmiPtr);
const biWidth = Math.abs(emu.memory.readI32(bmiPtr + 4));
const biHeight = emu.memory.readI32(bmiPtr + 8);
const biBitCount = emu.memory.readU16(bmiPtr + 14);
const biCompression = emu.memory.readU32(bmiPtr + 16);
const biClrUsed = emu.memory.readU32(bmiPtr + 32);
const isBottomUp = biHeight > 0;
const absHeight = Math.abs(biHeight);

if (biCompression !== 0) return 0; // 只支持 BI_RGB

// 构建调色板
const numColors = biClrUsed || (biBitCount <= 8 ? (1 << biBitCount) : 0);
let palette;
if (fuUsage === 1 && numColors > 0) {
palette = resolvePaletteColors(emu, dc, bmiPtr, biSize, numColors);
} else {
palette = [];
const paletteOffset = bmiPtr + biSize;
for (let i = 0; i < numColors; i++) {
const b = emu.memory.readU8(paletteOffset + i * 4);
const g = emu.memory.readU8(paletteOffset + i * 4 + 1);
const r = emu.memory.readU8(paletteOffset + i * 4 + 2);
palette.push([r, g, b]);
}
}

// 计算行对齐
let paddedRow;
if (biBitCount === 1) paddedRow = ((Math.ceil(biWidth / 8)) + 3) & ~3;
else if (biBitCount === 4) paddedRow = ((Math.ceil(biWidth / 2)) + 3) & ~3;
else if (biBitCount === 8) paddedRow = (biWidth + 3) & ~3;
else if (biBitCount === 24) paddedRow = (biWidth * 3 + 3) & ~3;
else if (biBitCount === 32) paddedRow = biWidth * 4;
else return 0;

// 源图有效区域裁剪
const srcW = Math.min(srcWidth, biWidth - xSrc);
const srcH = Math.min(srcHeight, absHeight - ySrc);
if (srcW <= 0 || srcH <= 0 || destWidth <= 0 || destHeight <= 0) return 0;

// ==============================================
// 先把源DIB读取成 ImageData（和 SetDIBitsToDevice 一致）
// ==============================================
const srcImage = dc.ctx.createImageData(srcW, srcH);
const srcPx = srcImage.data;

for (let y = 0; y < srcH; y++) {
const scanLine = isBottomUp ? (ySrc + srcH - 1 - y) : (ySrc + y);
const rowStart = bitsPtr + scanLine * paddedRow;

for (let x = 0; x < srcW; x++) {
  const sx = xSrc + x;
  const off = (y * srcW + x) * 4;
  let r = 0, g = 0, b = 0;

  if (biBitCount === 4) {
    const byteVal = emu.memory.readU8(rowStart + (sx >> 1));
    const idx = (sx & 1) === 0 ? (byteVal >> 4) & 0x0F : byteVal & 0x0F;
    [r, g, b] = palette[idx] || [0, 0, 0];
  } else if (biBitCount === 8) {
    const idx = emu.memory.readU8(rowStart + sx);
    [r, g, b] = palette[idx] || [0, 0, 0];
  } else if (biBitCount === 1) {
    const idx = (emu.memory.readU8(rowStart + (sx >> 3)) >> (7 - (sx & 7))) & 1;
    [r, g, b] = palette[idx] || [0, 0, 0];
  } else if (biBitCount === 24) {
    const o = rowStart + sx * 3;
    b = emu.memory.readU8(o);
    g = emu.memory.readU8(o+1);
    r = emu.memory.readU8(o+2);
  } else if (biBitCount === 32) {
    const o = rowStart + sx * 4;
    b = emu.memory.readU8(o);
    g = emu.memory.readU8(o+1);
    r = emu.memory.readU8(o+2);
  }

  srcPx[off] = r;
  srcPx[off+1] = g;
  srcPx[off+2] = b;
  srcPx[off+3] = 255;
}

}

// ==============================================
// Stretch 核心：缩放绘制（Canvas 原生支持）
// ==============================================
dc.ctx.save();
dc.ctx.imageSmoothingEnabled = false; // 像素风/复古风格用 nearest
dc.ctx.drawImage(
createCanvasFromImageData(srcImage),
0, 0, srcW, srcH, // 源
xDest, yDest, destWidth, destHeight // 目标（缩放）
);
dc.ctx.restore();

emu.syncDCToCanvas(hdc);
return 1; // 成功
});

// 辅助函数：把 ImageData 转成 Canvas 用于 drawImage
function createCanvasFromImageData(imgData) {
const c = document.createElement('canvas');
c.width = imgData.width;
c.height = imgData.height;
const ctx = c.getContext('2d');
ctx.putImageData(imgData, 0, 0);
return c;
}
`

[wintops]

ShowWindow Maxamized

`
user32.register('ShowWindow', 2, () => {
const hwnd = emu.readArg(0);
const nCmdShow = emu.readArg(1);
const wnd = emu.handles.get(hwnd);
if (!wnd) return 0;

const wasVisible = wnd.visible;
const SW_HIDE = 0, SW_SHOWNORMAL = 1, SW_SHOWMINIMIZED = 2, SW_MAXIMIZE = 3;
const SW_SHOW = 5, SW_MINIMIZE = 6, SW_RESTORE = 9;
wnd.visible = nCmdShow !== SW_HIDE;

// Update minimized/maximized state
if (nCmdShow === SW_MINIMIZE || nCmdShow === SW_SHOWMINIMIZED) {
  wnd.minimized = true; wnd.maximized = false;
} else if (nCmdShow === SW_MAXIMIZE) {
  wnd.maximized = true; wnd.minimized = false;
  
  
   console.log(`[WND] ShowWindow maximized`);



 wnd.x = 0;

wnd.y = 0;
wnd.width = emu.screenWidth;
wnd.height = emu.screenHeight ;
console.log([WND] ShowWindow ${emu.screenWidth} ${ emu.screenHeight} ${wnd.width} ${ wnd.height});
wnd.needsPaint = true;

const { cw, ch } = getClientSize(wnd.style, wnd.hMenu !== null, wnd.width, wnd.height);

  emu.setupCanvasSize(cw, ch);
  emu.onWindowChange?.(wnd);

emu.postMessage(hwnd, 0x0005, 2, makeLParam(cw, ch)); // SIZE_MAXIMIZED
emu.notifyControlOverlays?.();

`