Creation controle sans connaitre largeur

Bonjour,
J'aimerais pouvoir créer une fenetre contenant un nombre x de boutons, editbox ou static control, a partir de parametre donnés en entrée. Cependant comment créer un bouton par exemple , sans connaitre sa largeur et/ou hauteur??
La commande CW_USEDEFAULT à l'air d'initialiser à 0, donc le bouton ne s'affiche pas...
Exemple :
  hBtn = CreateWindowEx(0,TEXT("BUTTON"), TEXT("OK"), WS_VISIBLE | WS_CHILD,
    10, 10, 40, 20, hWnd, HMENU(ID_BUTTON), hInstance, NULL);
   // le bouton s'affiche, c'est normal
 moi je veux : 
  hBtn = CreateWindowEx(0,TEXT("BUTTON"), TEXT("OK"), WS_VISIBLE | WS_CHILD,
    10, 10, CW_USEDEFAULT, CW_USEDEFAULT, hWnd, HMENU(ID_BUTTON), hInstance, NULL);
// pour par exemple qu'il initialise la taille du bouton aux dimensions idéale par rapport à son texte.
// mais CW_USEDEFAULT ne fonctionne pas...
"CW_USEDEFAULT is valid only for overlapped windows; if CW_USEDEFAULT is specified for a pop-up or child window, the nWidth and nHeight parameter are set to zero"

Si quelqu'un a une idée, tous les exemples que j'ai cherché faisant référence à des créations de controle avec parametre connus...
Merci!

Pour créer un bouton qui s'adapte à la taille du texte, il faut que tu récupères la taille de ce texte.
Pour cela renseigne toi sur la fonction GetTextExtentPoint32.
Avec cette fonction tu vas récupérer la hauteur et la largeur de ta chaine. A partir de ça, tu choisis la taille de ton bouton : largeur +2*wdelta et hauteur +2*hdelta par exemple avec wdelta et hdelta qui sont mis en define pour que tu puisses régler l'espace entre les bords du bouton et le texte.

Vive le C
Savon

Merci pour ta réponse, je vais faire des recherches tout de suite.^^
J'aurais espérer un moyen plus simple, mais bon on fait pas tout ce qu'on veut.
A+

En galérant u peu (cause débutant en C sous evc... ;-) ),
j'ai reussit a peu pres a realiser ce que tu m'as dis de faire :
j'ai donc :
//definitions
#define wdelta 15
#define hdelta 15

char* contenu="&OK"; // ou bien char* contenu="&bouton tres long";
SIZE sz;

dans le case WM_PAINT:
GetTextExtentPoint32(hdc, ConvertAnsiToUnicode(contenu), strlen(contenu), &sz);
 et enfin
hBtn = CreateWindowEx(0,TEXT("BUTTON"), ConvertAnsiToUnicode(contenu), WS_VISIBLE | WS_CHILD,
    10, 10, sz.cx+2*wdelta, sz.cy+2*hdelta, hWnd, HMENU(ID_BUTTON), hInstance, NULL);

(ConvertAnsiToUnicode() es tune de mes fonction pour transforme de charset en unicode)

Cependant a l'affichage je garde un taille fixe... Pourtant, lorsque je clique sur le bouton, j'ai voulu vérifier en affichant la largeur sz.cx+2*wdelta, et la hauteur sz.cy+2*hdelta, et en fonction de la valeur de "contenu", il renvoie bien des largeurs différentes!!
Donc pourquoi a l'affichage ca ne se concretise pas? Je fais quelque chose qui ne va pas?

Autre question : je peux recuperer la valeur "contenu" grace a une phase de pasing realiser precedemment... Je voudrais donc lancer ma méthode "LanceParsing()" avant l'affichage de l'écran... Où dois-je l'appeler? j'ai essayer dans WM_CREATE et la phase se lance bien avant mais l'affichage de la fentre ensuite ne se fait pas...

Ca m'a l'air de venir du parametre hdc... Je ne sais pa trop comment l'utiliser. J'ai appelé GetTextExtentPoint32 dans WM_CREATE car il y avait un hdc de défini, résultat sz.cx et sz.cy égal toujours 14... si quelqu'un peutm'expliquer
( avant l'appel GetTextExtentPoint32 , hdc est défini ainsi :
case WM_PAINT:
      RECT rt;
      hdc = BeginPaint(hWnd, &ps);
      GetClientRect(hWnd, &rt);
      FillRect(hdc, &rt, (HBRUSH) (1));
 
     GetTextExtentPoint32(hdc, ConvertAnsiToUnicode(contenu), strlen(contenu), &sz);

      EndPaint(hWnd, &ps);
      break;
)


Si quelqu'un voit mon erreur  ( probablement de novice), qu'il n'hésite pas, je suis bloqué! :(

Est-ce cela que tu demandes ?
 (prog compilé en C avec Dev-C++)


#include <windows.h>

/*  Declare Windows procedure  */
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

/*  Make the class name into a global variable  */
char szClassName[ ] = "WindowsApp";


void youpi(HWND hwnd)
{
    int i;
    char      *noms[] = {"ici","Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi","a","LOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOONG!!!!"};
    int nb = 9;
    int last_taille_y=0;
    int last_taille_x=0;
    SIZE sz;
    for (i=0;i<nb;i++)
    {
        GetTextExtentPoint32(GetDC(hwnd), noms[i], strlen(noms[i]), &sz);
        if (last_taille_x+sz.cx+30 > 544)
        {
            last_taille_x=0;
            last_taille_y += sz.cy+10;
        }
    CreateWindowEx(0,TEXT("BUTTON"), TEXT(noms[i]), WS_VISIBLE | WS_CHILD,
    last_taille_x, last_taille_y, sz.cx+30, 20, hwnd, 0, NULL, NULL);
    last_taille_x +=sz.cx+30+5;
    }
}



int WINAPI WinMain (HINSTANCE hThisInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR lpszArgument,
                    int nFunsterStil)

{
    HWND hwnd;               /* This is the handle for our window */
    MSG messages;            /* Here messages to the application are saved */
    WNDCLASSEX wincl;        /* Data structure for the windowclass */

    /* The Window structure */
    wincl.hInstance = hThisInstance;
    wincl.lpszClassName = szClassName;
    wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
    wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
    wincl.cbSize = sizeof (WNDCLASSEX);

    /* Use default icon and mouse-pointer */
    wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
    wincl.lpszMenuName = NULL;                 /* No menu */
    wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
    wincl.cbWndExtra = 0;                      /* structure or the window instance */
    /* Use Windows's default color as the background of the window */
    wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;

    /* Register the window class, and if it fails quit the program */
    if (!RegisterClassEx (&wincl))
        return 0;

    /* The class is registered, let's create the program*/
    hwnd = CreateWindowEx (
           0,                   /* Extended possibilites for variation */
           szClassName,         /* Classname */
           "Windows App",       /* Title Text */
           WS_OVERLAPPEDWINDOW, /* default window */
           CW_USEDEFAULT,       /* Windows decides the position */
           CW_USEDEFAULT,       /* where the window ends up on the screen */
           544,                 /* The programs width */
           375,                 /* and height in pixels */
           HWND_DESKTOP,        /* The window is a child-window to desktop */
           NULL,                /* No menu */
           hThisInstance,       /* Program Instance handler */
           NULL                 /* No Window Creation data */
           );

       
    youpi(hwnd);

    /* Make the window visible on the screen */
    ShowWindow (hwnd, nFunsterStil);

    /* Run the message loop. It will run until GetMessage() returns 0 */
    while (GetMessage (&messages, NULL, 0, 0))
    {
        /* Translate virtual-key messages into character messages */
        TranslateMessage(&messages);
        /* Send message to WindowProcedure */
        DispatchMessage(&messages);
    }

    /* The program return-value is 0 - The value that PostQuitMessage() gave */
    return messages.wParam;
}


/*  This function is called by the Windows function DispatchMessage()  */

LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)                  /* handle the messages */
    {
        case WM_DESTROY:
            PostQuitMessage (0);       /* send a WM_QUIT to the message queue */
            break;
        default:                      /* for messages that we don't deal with */
            return DefWindowProc (hwnd, message, wParam, lParam);
    }

    return 0;
}

Salut,
Le HDC d'un controle n'est disponible qu'après sa création. Tu crées donc ton controle avec CreateWindow() en spécifiant une largeur et une hauteur à 0. Tu récupères son HDC avec GetDC(). Tu obtiens les dimensions du texte avec GetTextExtentPoint32(). Tu appliques ces dimensions au controle avec MoveWindow() ou SetWindowPos(). Ne pas oublier de libérer le HDC avec ReleaseDC().
GetTextExtentPoint32() a besoin du HDC pour connaitre la police sélectionnée dans ce dernier car les dimensions du texte dépendent justement de la police utilisée par le controle.

Merci beaucoup pour vos réponse, je vais regarder ca de plus près !
;-)