win32 - how create a bitmap Region?

[Cambalinho]

how can i create a bitmap Region?
i did these function for create a bitmap Region:

class MemoryDC
{
private:
    HDC memoryDC;

public:
    MemoryDC ()
    {
        memoryDC=CreateCompatibleDC(NULL);
    }

    operator HDC() const
    {
        return memoryDC;
    }

    ~MemoryDC ()
    {
       DeleteDC(memoryDC);
    }
};

class BitmapDC
{
private:
    MemoryDC hdcbitmap;
    HGDIOBJ bitmapold;
    HBITMAP bitmapcurrent;
    int intwidth;
    int intheight;

    void init(int width, int height)
    {
        bitmapcurrent = CreateBitmap(width, height, 1, 32, NULL);
        bitmapold = SelectObject(hdcbitmap, bitmapcurrent);
        intwidth=width;
        intheight=height;
    }

    void destroy()
    {
        SelectObject(hdcbitmap, bitmapold);
        DeleteObject(bitmapcurrent);
    }

public:

    BitmapDC(int width, int height)
    {
        init(width, height);
    }

    BitmapDC()
    {
        init(1, 1);
    }

    void size(int width, int height)
    {
        destroy();
        init(width, height);
    }

    int Width()
    {
        return intwidth;
    }

    int Height()
    {
        return intheight;
    }

    BitmapDC& operator= (const BitmapDC &bitmapsource)
    {
        if (this == &bitmapsource)      // Same object?
            return *this;
        destroy();
        init(bitmapsource.intwidth, bitmapsource.intheight);
        BitBlt(bitmapsource, 0, 0, intwidth, intheight, bitmapsource, 0, 0, SRCCOPY);
        return *this;
    }

    BitmapDC& operator= (const HBITMAP &bitmapsource)
    {
        destroy();
        BITMAP bm;
        GetObject(bitmapsource,sizeof(bm),&bm);
        init(bm.bmWidth, bm.bmHeight);
        DrawHBITMAPtoHDC(bitmapsource,hdcbitmap);
        return *this;
    }

    //testing the bitmao value if is nullptr
    bool operator != ( nullptr_t ) const
    {
        return bitmapcurrent != nullptr;
    }

    bool operator==(const BitmapDC &other) const
    {
        return (other.bitmapcurrent == this->bitmapcurrent);
    }

    bool operator!=(const BitmapDC &other) const
    {
        return !(*this == other);
    }

    operator HBITMAP() const
    {
        return bitmapcurrent;
    }

    operator HDC() const
    {
        return hdcbitmap;
    }

    ~BitmapDC()
    {
       destroy();
    }
};

const int LastPixel=-1;
const int FirstPixel=-2;
void DrawHBITMAPtoHDC(HBITMAP hBitmap, HDC hdc, int PosX=0, int PosY=0, COLORREF backcolor=-1)
{
    BITMAP bm;
    HDC MemDCExercising = CreateCompatibleDC(hdc);
    HBITMAP oldbitmap =(HBITMAP) SelectObject(MemDCExercising, hBitmap);
    GetObject(hBitmap,sizeof(bm),&bm);
    if(backcolor==LastPixel)
        TransparentBlt(hdc, PosX, PosY, bm.bmWidth , bm.bmHeight, MemDCExercising, 0, 0,bm.bmWidth , bm.bmHeight,GetPixel(MemDCExercising,bm.bmWidth-1,bm.bmHeight-1));
    else if(backcolor==FirstPixel)
        TransparentBlt(hdc, PosX, PosY, bm.bmWidth , bm.bmHeight, MemDCExercising, 0, 0,bm.bmWidth , bm.bmHeight,GetPixel(MemDCExercising,0,0));
    else
        TransparentBlt(hdc, PosX, PosY, bm.bmWidth , bm.bmHeight, MemDCExercising, 0, 0,bm.bmWidth , bm.bmHeight,backcolor);
    SelectObject(MemDCExercising,oldbitmap);
    DeleteDC(MemDCExercising);
    DeleteObject(hBitmap);
}

HRGN CreateBitmapRegion(HBITMAP bitmap, COLORREF transparentcolor=-1)
{
    HRGN hRgn, hRgnTemp;
    COLORREF mask_color=transparentcolor;
    int x=0, y=0;
    BITMAP bm={0};
    GetObject(bitmap,sizeof(bm),&bm);

    hRgn = CreateRectRgn(0, 0, bm.bmWidth, bm.bmHeight);
    BitmapDC btDC(bm.bmWidth, bm.bmHeight);
    DrawHBITMAPtoHDC(bitmap,btDC);

    for (x = 0 ; x<bm.bmWidth-1; x++)
    {
        for (y = 0 ; y<bm.bmHeight-1; y++)
        {
            if (GetPixel(btDC,x,y) == mask_color)
            {
                hRgnTemp = CreateRectRgn(x, y, x+1, y+1);
                int a=0;
                a=CombineRgn(hRgn, hRgn, hRgnTemp, RGN_OR);
                if(a==ERROR || a== NULLREGION)
                    SetWindowText(ActivatedForm, "REgion error");
                DeleteObject(hRgnTemp);
            }
        }
    }
    return hRgn;
}

i used the GetLastError() too, and i only get '6:The handle is invalid.'. i don't know i get these error. but imust see it after ;)
back to Regions: why i don't get the Regions? the child control is showed sometimes then isn't. the Region functions don't give me errors, only bad results :(

[coder777]

Currently you're doing nothing with the region. I guess you want clipping?

For that you need ExtSelectClipRgn(...):

https://msdn.microsoft.com/en-us/library/windows/desktop/dd162712%28v=vs.85%29.aspx

[
and maybe GetClipRgn(...):
https://msdn.microsoft.com/en-us/library/windows/desktop/dd144866%28v=vs.85%29.aspx
]

Something like this?

  HRGN clip_hr = CreateRectRgn(0, 0, bm.bmWidth, bm.bmHeight);

  // GetClipRgn(hdc, clip_hr);

  HRGN hr = CreateRectRgn(x, y, x+1, y+1); // A single pixel?

  ExtSelectClipRgn(hdc, hr, RGN_OR); // Or wouldn't change anything?

  DeleteObject(hr);

[Cambalinho]

now works fine:

BYTE* Get24BitPixels(HBITMAP pBitmap, WORD *pwWidth, WORD *pwHeight)
{
  // a bitmap object just to get bitmap width and height
	BITMAP bmpBmp;

  // pointer to original bitmap info
	LPBITMAPINFO pbmiInfo;

  // bitmap info will hold the new 24bit bitmap info
  BITMAPINFO bmiInfo;

  // width and height of the bitmap
  WORD wBmpWidth, wBmpHeight;

  // ---------------------------------------------------------
  // get some info from the bitmap
  // ---------------------------------------------------------
	GetObject(pBitmap, sizeof(bmpBmp),&bmpBmp);
  pbmiInfo   = (LPBITMAPINFO)&bmpBmp;

  // get width and height
	wBmpWidth  = (WORD)pbmiInfo->bmiHeader.biWidth;
	wBmpWidth -= (wBmpWidth%4);                       // width is 4 byte boundary aligned.
	wBmpHeight = (WORD)pbmiInfo->bmiHeader.biHeight;

  // copy to caller width and height parms
  *pwWidth  = wBmpWidth;
  *pwHeight = wBmpHeight;
  // ---------------------------------------------------------

	// allocate width * height * 24bits pixels
  BYTE *pPixels = new BYTE[wBmpWidth*wBmpHeight*3];
	if (!pPixels) return NULL;

  // get user desktop device context to get pixels from
	HDC hDC = GetWindowDC(NULL);

  // fill desired structure
	bmiInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	bmiInfo.bmiHeader.biWidth = wBmpWidth;
	bmiInfo.bmiHeader.biHeight = -wBmpHeight;
	bmiInfo.bmiHeader.biPlanes = 1;
	bmiInfo.bmiHeader.biBitCount = 24;
	bmiInfo.bmiHeader.biCompression = BI_RGB;
	bmiInfo.bmiHeader.biSizeImage = wBmpWidth*wBmpHeight*3;
	bmiInfo.bmiHeader.biXPelsPerMeter = 0;
	bmiInfo.bmiHeader.biYPelsPerMeter = 0;
	bmiInfo.bmiHeader.biClrUsed = 0;
	bmiInfo.bmiHeader.biClrImportant = 0;

  // get pixels from the original bitmap converted to 24bits
  int iRes = GetDIBits(hDC,pBitmap,0,wBmpHeight,(LPVOID)pPixels,&bmiInfo,DIB_RGB_COLORS);

  // release the device context
	ReleaseDC(NULL,hDC);

  // if failed, cancel the operation.
	if (!iRes)
  {
    delete pPixels;
    return NULL;
  };

  // return the pixel array
	return pPixels;
}

HRGN RegionbyBitmap(HBITMAP pBitmap,COLORREF clrTransparent=-1 )
{
    BYTE jTranspR = GetRValue(clrTransparent), jTranspG=GetGValue(clrTransparent), jTranspB=GetBValue(clrTransparent);
  // bitmap width and height
  WORD wBmpWidth,wBmpHeight;

  // the final region and a temporary region
  HRGN hRgn, hTmpRgn;

  // 24bit pixels from the bitmap
  BYTE *pPixels = Get24BitPixels(pBitmap, &wBmpWidth, &wBmpHeight);
  if (!pPixels) return NULL;

  // create our working region
  hRgn = CreateRectRgn(0,0,wBmpWidth,wBmpHeight);
  if (!hRgn) { delete pPixels; return NULL; }

  // ---------------------------------------------------------
  // scan the bitmap
  // ---------------------------------------------------------


  DWORD p=0;
  for (WORD y=0; y<wBmpHeight; y++)
  {
    for (WORD x=0; x<wBmpWidth; x++)
    {
      BYTE jRed   = pPixels[p+2];
      BYTE jGreen = pPixels[p+1];
      BYTE jBlue  = pPixels[p+0];

      if ((jRed == jTranspR && jGreen == jTranspG && jBlue == jTranspB))
      {
        // remove transparent color from region
        hTmpRgn = CreateRectRgn(x,y,x+1,y+1);
        CombineRgn(hRgn, hRgn, hTmpRgn, RGN_XOR);
        DeleteObject(hTmpRgn);


      }

      // next pixel
      p+=3;
    }
  }

  // release pixels
  delete pPixels;

  return hRgn;
}

thanks for all