CreateRectRgn ?

Jeg er ikke sikker på jeg har forstået hvad du vil, men dette eksempel opdeler et rektangel på 100*80 i 5*5 regioner.
Resultatet bliver altså:
[0] [0]    {top=1 bottom=16 left=1 right=20}
[0] [1]    {top=17 bottom=32 left=1 right=20}
[0] [2]    {top=33 bottom=48 left=1 right=20}
[0] [3]    {top=49 bottom=64 left=1 right=20}
[0] [4]    {top=65 bottom=80 left=1 right=20}
[1] [0]    {top=1 bottom=16 left=21 right=40}
[1] [1]    {top=17 bottom=32 left=21 right=40}
[1] [2]    {top=33 bottom=48 left=21 right=40}
[1] [3]    {top=49 bottom=64 left=21 right=40}
[1] [4]    {top=65 bottom=80 left=21 right=40}
[2] [0]    {top=1 bottom=16 left=41 right=60}
[2] [1]    {top=17 bottom=32 left=41 right=60}
[2] [2]    {top=33 bottom=48 left=41 right=60}
[2] [3]    {top=49 bottom=64 left=41 right=60}
[2] [4]    {top=65 bottom=80 left=41 right=60}
[3] [0]    {top=1 bottom=16 left=61 right=80}
[3] [1]    {top=17 bottom=32 left=61 right=80}
[3] [2]    {top=33 bottom=48 left=61 right=80}
[3] [3]    {top=49 bottom=64 left=61 right=80}
[3] [4]    {top=65 bottom=80 left=61 right=80}
[4] [0]    {top=1 bottom=16 left=81 right=100}
[4] [1]    {top=17 bottom=32 left=81 right=100}
[4] [2]    {top=33 bottom=48 left=81 right=100}
[4] [3]    {top=49 bottom=64 left=81 right=100}
[4] [4]    {top=65 bottom=80 left=81 right=100}


const int nRegions = 5; // gives 5 * 5 = 25 regions
CRgn regions[nRegions][nRegions]; // 2D array
int nWidth = 100; // Width to be divided amongst regions
int nHeight = 80; // Height to be divided amongst regions
for(int y=0; y<nRegions; ++y)
{
    for(int x=0; x<nRegions; ++x)
    {
        regions[x][y].CreateRectRgn(x*(nWidth/nRegions), y*(nHeight/nRegions), (x+1)*(nWidth/nRegions), (y+1)*(nHeight/nRegions));
    }
}

det er ligepræcis det jeg leder efter, men kunne jeg lokke dig til at kigge på hvorledes jeg kan lave så hver enkelt område bliver farvet henholdsvis sort og hvid så det kommer til at ligne et skakbrædt,  jeg bruger dette til at fylde med
FillRect(dc,&rect,(HBRUSH)GetStockObject(BLACK_BRUSH));
FillRect(dc,&rect,(HBRUSH)GetStockObject(WHITE_BRUSH));

en sidste ting,  hvorledes kan jeg gøre så det er  "layerrect" den indeler ?
Nu kender jeg ikke så meget til CRgn, kan du guide mig der ?

Jeg brugte kun CRgn fordi du referede til metoden CreateRectRgn og du "plejer" at bruge MFC så vidt jeg husker...
Det kan jo let ændres til rects, således

const int nRects = 5; // gives 5 * 5 = 25 rects
CRect rects[nRects][nRects]; // 2D array
int nWidth = 100; // Width to be divided amongst rects
int nHeight = 80; // Height to be divided amongst rects
for(int y=0; y<nRects; ++y)
{
    for(int x=0; x<nRects; ++x)
    {
        rects[x][y].SetRect(x*(nWidth/nRects)+1, y*(nHeight/nRects)+1, (x+1)*(nWidth/nRects), (y+1)*(nHeight/nRects));
    }
}

Jeg ved dog ikke hvad du mener med "layerrect"..?

hvorledes kunne jeg bruge det sammen med et statisk felt i dialogen,  jeg opretter et rect således i et bestemt område

CRect rectlayer;
m_st1.GetWindowRect(&rectlayer); // <-----  dette skal deles op i felter
ScreenToClient(rectlayer);

jeg kan ikke rigtig hitte ud af hvorledes jeg for placeret felterne andre steder end i øverste venstre hjørne ( i hele dialogen )og jeg ville meget gerne have udført dette på det jeg kalder CRect rectlayer som er et bestemt statisk vindue ( kaldet variablen  "m_st1" ) i min dialog.

Hvad med:

CRect rectlayer;
m_st1.GetWindowRect(&rectlayer);
ScreenToClient(rectlayer);
const int nRects = 5; // gives 5 * 5 = 25 rects
CRect rects[nRects][nRects]; // 2D array
int nWidth = rectlayer.Width(); // Width to be divided amongst rects
int nHeight = rectlayer.Height(); // Height to be divided amongst rects
for(int y=0; y<nRects; ++y)
{
    for(int x=0; x<nRects; ++x)
    {
        rects[x][y].SetRect(x*(nWidth/nRects)+rectlayer.left, y*(nHeight/nRects)+rectlayer.top, (x+1)*(nWidth/nRects)+rectlayer.left-1, (y+1)*(nHeight/nRects)+rectlayer.top-1);
    }
}

Du skal dog være opmærksom på, at her regnes med heltal og der derfor kommer nogle afrundinger...
Det gør at alle felter bliver lige store, men at felterne ikke nødvendigvis fylder hele dit rectlayer.

det med afrundinger kan man vel afhjælpe en smule med FLOAT ?

lige en enkelt ting,  kan et rect godt være 1*1 pixel  uden problemmer ?  har du erfaringer med det

Det med afrundinger var ikke nødvendigvis ment som et problem.
Som det er nu, vil et rect på fx 11x11 pixels give 4 felter med størrelsen 5x5 pixels og en rest-kant på 1 pixel i bredden
Hvis du hellere vil have rects på fx 5x5, 6x5, 5x6 og 6x6, kan du bruge float (eller double) til udregningen!

Et CRect objekt er jo egentlig bare 4 integers (left, top, right og bottom), så der er ikke noget der forhindrer dig at lave et rect 1x1 pixel.
Du kan endda også lade left være STØRRE end right...