bonjour tout le monde,

j'ai 3 checkbox dans une toolbox et je voudrais que quand j'en coche une les deux autres se décoche mais je ne sais pas comment faire.  Est ce que vous pourriez m'aider svp ?

voici le code que j'utilise:

IGUIEnvironment* env = Device->getGUIEnvironment();
    IGUIElement* root = env->getRootGUIElement();
    IGUIElement* e = root->getElementFromId(5000, true);
    if (e) e->remove();

    // créer la fenêtre de la toolbox
    IGUIWindow* wnd = env->addWindow(core::rect<s32>(600,25,800,480),
        false, L"Eau", 0, 5000);

    // création des tabs

    IGUITabControl* tab = env->addTabControl(
        core::rect<s32>(2,20,800-602,480-7), wnd, true, true);

    IGUITab* t1 = tab->addTab(L"Eau");

    // ajout des checkbox

    env->addStaticText(L"Format", core::rect<s32>(10,30,100,50), true, false, t1);
    env->addCheckBox(true, core::rect<s32>(10,55,200,75), t1, -1, L"Carre");
    env->addCheckBox(true, core::rect<s32>(10,80,200,100), t1, -1, L"Rond");
    env->addCheckBox(true, core::rect<s32>(10,105,200,125), t1, -1, L"Losange");

plop,

IGUICheckBox *cbCarre = env->addCheckBox(true, core::rect<s32>(10,55,200,75), t1, -1, L"Carre");
IGUICheckBox *cbRond = env->addCheckBox(true, core::rect<s32>(10,80,200,100), t1, -1, L"Rond");
IGUICheckBox *cbLosange = env->addCheckBox(true, core::rect<s32>(10,105,200,125), t1, -1, L"Losange");


// dans la boucle :

if (cbCarre->isChecked())
{
    cbRond->setChecked(false);
    cbLosange->setChecked(false);
}
// idem pour les 2 autres checkboxes

Tu peux sûrement faire plus propre c'est a l'arrache

oui je vais essayer
en tout cas merci beaucoup

Dernière modification par vrag (01-07-2007 19:43:01)

j'arrive pas a comprendre de quelle boucle tu me parle. Tu pourrais m'en dire plus stp ?

la boucle principale de ton programme style "while (device->run())"

mais quand je le met dans la boucle il me dit que c'est la première fois qu'il le voit dans le programme (normal puisque je l'ai fait dans une autre fonction que le main) et je ne sais pas comment faire pour que ça marche sans avoir a retaper tout le code de la fonction.
Désolé d'être aussi nul mais ce truc est important pour moi donc je veux le réussir

???
pas compris
envoie l'erreur qu'il te met et le code

je t'explique
mon code est fragmenté en plusieurs fonctions : int main() par exemple ou encore void createToolBoxEau() ( c'est là que je crée mes checkBox).
Ma boucle se trouve dans le main et mes définitions d'instruction (comme IGUIWindow* wnd = env->addWindow(core::rect<s32>(600,25,800,480), false, L"Eau", 0, 5000); ) sont dans ma fonction createToolBoxEau();
Donc forcément mon main ne les connais pas il me met :  'cbCarre' undeclared ( first use in this function)

ce que je veux dire c'est que tu me dit de mettre les if dans la boucle principale mais si je le fais ça compile pas.
Ce que je te demande c'est comment faire pour insérer la boucle avec les if pour que quand je clique sur une checkbox les deux autres se décoche.

J'ai essayé de la mettre dans ma fonction createToolBoxEau() mais quand je veux activer la toolbox le programme plante et je comprend pas pourquoi.

Dernière modification par vrag (01-07-2007 22:43:35)

Pour ça il faudrait les déclarer en variables globales.
Tu mets vers le début de ton programme, dans aucune fonction
IGUICheckBox *cbCarre;
avec les autres checkboxes
et après tu pourras les utiliser dans toutes tes fonctions
par ex
cbCarre = env->addCheckBox(true, core::rect<s32>(10,55,200,75), t1, -1, L"Carre");
Ca marchera mais les globales cay mal

vaut mieux englober ton programme dans une ou plusieurs classes avec le sceneMgr et les objets dans la partie privée de ta classe.

Je te conseille de bien te mettre dans le C++ avant d'attaquer irrlicht ca t'économisera pas mal de temps.

je suis en train de me familiarisé avec le C++

j'ai déclaré mes checkbox en début de programme mais quand je compile ça plante et je trouve pas où ça foire

envoie le message

tu veux que je t'envoi le rapport d'erreur windows ?
parce que la compilation marche mais quand la fenêtre s'ouvre il me met Irrlicht.exe a rencontré un problème et doit fermer. Nous vous prions de nous excuser pour le désagrément encouru.

ah ok c'est un rapport d'erreurs... non non ca sert à rien d'envoyer le rapport, envoie ton code.

alors je t'explique. Je me suis servi du tuto 9 d'irrlicht sur le meshviewer et je l'ai modifié en  fonction de mes besoins. J'ai aussi rajouter deux ou trois icones mais si tu les a pas c'est pas trop grave je pense (si tu les veux je te les envois). J'ai pas tout relié encore (loin de là) donc ya que le menu outil qui marche. Les checkbox sont dans l'outil eau ( outil-> terrain-> eau)
voila mon code

#include <irrlicht.h>
#include <iostream>

using namespace irr;
using namespace gui;

#pragma comment(lib, "Irrlicht.lib")


IrrlichtDevice *Device = 0;
core::stringc StartUpModelFile;
core::stringw MessageText;
core::stringw Caption;
scene::IAnimatedMeshSceneNode* Model = 0;
scene::ISceneNode* SkyBox = 0;

scene::ICameraSceneNode* Camera[2] = { 0, 0};

IGUICheckBox* cbCarre;
IGUICheckBox* cbRond;
IGUICheckBox* cbLosange;

/*
    toggles between various cameras
*/
void setActiveCamera ( scene::ICameraSceneNode* newActive )
{
    if ( 0 == Device )
        return;

    scene::ICameraSceneNode* active = Device->getSceneManager()->getActiveCamera ();

    newActive->setInputReceiverEnabled ( true );
    Device->getSceneManager()->setActiveCamera ( newActive );
}

/*
    The three following functions do several stuff used by the mesh viewer.
    The first function showAboutText() simply displays a messagebox with a caption
    and a message text. The texts will be stored in the MessageText and
    Caption variables at startup.
*/
void showAboutText()
{
    // create modal message box with the text
    // loaded from the xml file.
    Device->getGUIEnvironment()->addMessageBox(
        Caption.c_str(), MessageText.c_str());
}


/*
    The second function loadModel() loads a model and displays it using an
    addAnimatedMeshSceneNode and the scene manager. Nothing difficult. It also
    displays a short message box, if the model could not be loaded.
*/
void loadModel(const c8* fn)
{
    // modify the name if it a .pk3 file

    core::stringc filename ( fn );

    core::stringc extension;
    core::getFileNameExtension ( extension, filename );
    extension.make_lower();

    // if a texture is loaded apply it to the current model..
    if (    extension == ".jpg" ||
            extension == ".png" ||
            extension == ".tga" ||
            extension == ".pcx" ||
            extension == ".psd" ||
            extension == ".bmp"
        )
    {
        video::ITexture * texture = Device->getVideoDriver()->getTexture( filename.c_str() );
        if ( texture && Model )
        {
            // always reload texture
            Device->getVideoDriver()->removeTexture ( texture );
            texture = Device->getVideoDriver()->getTexture( filename.c_str() );

            Model->setMaterialTexture ( 0, texture );
        }
        return;
    }

    // if a archive is loaded add it to the FileSystems..
    if (    extension == ".pk3" ||
            extension == ".zip"
        )
    {
        Device->getFileSystem()->addZipFileArchive( filename.c_str () );
        return;
    }

    // load a model into the engine

    if (Model)
        Model->remove();

    Model = 0;

    scene::IAnimatedMesh* m = Device->getSceneManager()->getMesh( filename.c_str() );

    if (!m)
    {
        // model could not be loaded

        if (StartUpModelFile != filename)
            Device->getGUIEnvironment()->addMessageBox(
            Caption.c_str(), L"The model could not be loaded. " \
            L"Maybe it is not a supported file format.");
        return;
    }

    // set default material properties

    Model = Device->getSceneManager()->addAnimatedMeshSceneNode(m);
    Model->setMaterialFlag(video::EMF_LIGHTING, false);
//    Model->setMaterialFlag(video::EMF_BACK_FACE_CULLING, false);
    Model->setDebugDataVisible(scene::EDS_OFF);
    Model->setAnimationSpeed(30);
}


/*
    Finally, the third function creates a toolbox window. In this simple mesh viewer,
    this toolbox only contains a tab control with three edit boxes for changing
    the scale of the displayed model.
*/

void createToolBoxEau()
{
    // remove tool box if already there
    IGUIEnvironment* env = Device->getGUIEnvironment();
    IGUIElement* root = env->getRootGUIElement();
    IGUIElement* e = root->getElementFromId(5000, true);
    if (e) e->remove();

    // create the toolbox window
    IGUIWindow* wnd = env->addWindow(core::rect<s32>(600,25,800,480),
        false, L"Eau", 0, 5000);

    // create tab control and tabs
    IGUITabControl* tab = env->addTabControl(
        core::rect<s32>(2,20,800-602,480-7), wnd, true, true);

    IGUITab* t1 = tab->addTab(L"Eau");

    // add senseless checkbox
    env->addStaticText(L"Format", core::rect<s32>(10,30,100,50), true, false, t1);
    cbCarre = env->addCheckBox(true, core::rect<s32>(10,55,200,75), t1, -1, L"Carre");
    cbRond = env->addCheckBox(true, core::rect<s32>(10,80,200,100), t1, -1, L"Rond");
    cbLosange = env->addCheckBox(true, core::rect<s32>(10,105,200,125), t1, -1, L"Losange");

    env->addStaticText(L"Taille", core::rect<s32>(10,150,150,175), true, false, t1);
    IGUIScrollBar* scrollbar = env->addScrollBar(true, core::rect<s32>(10,170,150,185), t1, 104);
    scrollbar->setMax(16);


}

void createToolBoxCiel()
{
    //Atmosphère + nuage
    // remove tool box if already there
    IGUIEnvironment* env = Device->getGUIEnvironment();
    IGUIElement* root = env->getRootGUIElement();
    IGUIElement* a = root->getElementFromId(5100, true);
    if (a) a->remove();

    // create the toolbox window
    IGUIWindow* wnd = env->addWindow(core::rect<s32>(600,25,800,480),
        false, L"Ciel", 0, 5000);

    IGUITabControl* tab = env->addTabControl(
        core::rect<s32>(2,20,800-602,480-7), wnd, true, true);

    IGUITab* t1 = tab->addTab(L"Atmosphere");
    IGUITab* t2 = tab->addTab(L"Nuage");
}

void createToolBoxRelief()
{
    //Altitude + sol + relief
    // remove tool box if already there
    IGUIEnvironment* env = Device->getGUIEnvironment();
    IGUIElement* root = env->getRootGUIElement();
    IGUIElement* b = root->getElementFromId(5200, true);
    if (b) b->remove();

    // create the toolbox window
    IGUIWindow* wnd = env->addWindow(core::rect<s32>(600,25,800,480),
        false, L"Relief", 0, 5000);

    IGUITabControl* tab = env->addTabControl(
        core::rect<s32>(2,20,800-602,480-7), wnd, true, true);

    IGUITab* t1 = tab->addTab(L"Altitude");
    IGUITab* t2 = tab->addTab(L"Sol");
    IGUITab* t3 = tab->addTab(L"Relief");
}

void createToolBoxForet()
{
    // remove tool box if already there
    IGUIEnvironment* env = Device->getGUIEnvironment();
    IGUIElement* root = env->getRootGUIElement();
    IGUIElement* c = root->getElementFromId(5300, true);
    if (c) c->remove();

    // create the toolbox window
    IGUIWindow* wnd = env->addWindow(core::rect<s32>(600,25,800,480),
        false, L"Foret", 0, 5000);

    IGUITabControl* tab = env->addTabControl(
        core::rect<s32>(2,20,800-602,480-7), wnd, true, true);

    IGUITab* t1 = tab->addTab(L"Foret");
}

void createToolBoxInsertion()
{
    // remove tool box if already there
    IGUIEnvironment* env = Device->getGUIEnvironment();
    IGUIElement* root = env->getRootGUIElement();
    IGUIElement* d = root->getElementFromId(5400, true);
    if (d) d->remove();

    // create the toolbox window
    IGUIWindow* wnd = env->addWindow(core::rect<s32>(600,25,800,480),
        false, L"Insertion", 0, 5000);

    IGUITabControl* tab = env->addTabControl(
        core::rect<s32>(2,20,800-602,480-7), wnd, true, true);

    IGUITab* t1 = tab->addTab(L"Insertion");
}



/*
    To get all the events sent by the gui Elements, we need to create an event
    receiver. This one is really simple. If an event occurs, it checks the id
    of the caller and the event type, and starts an action based on these values.
    For example, if a menu item with id 100 was selected, if opens a file-open-dialog.
*/
class MyEventReceiver : public IEventReceiver
{
public:
    virtual bool OnEvent(SEvent event)
    {
        // Escape swaps Camera Input
        if (event.EventType == EET_KEY_INPUT_EVENT &&
            event.KeyInput.Key == irr::KEY_ESCAPE &&
            event.KeyInput.PressedDown == false)
        {
            if ( Device )
            {
                scene::ICameraSceneNode * camera = Device->getSceneManager()->getActiveCamera ();
                if ( camera )
                {
                    camera->setInputReceiverEnabled ( !camera->isInputReceiverEnabled() );
                }
                return true;
            }
        }

        if (event.EventType == EET_GUI_EVENT)
        {
            s32 id = event.GUIEvent.Caller->getID();
            IGUIEnvironment* env = Device->getGUIEnvironment();

            switch(event.GUIEvent.EventType)
            {
            case EGET_MENU_ITEM_SELECTED:
                {
                    // a menu item was clicked

                    IGUIContextMenu* menu = (IGUIContextMenu*)event.GUIEvent.Caller;
                    s32 id = menu->getItemCommandId(menu->getSelectedItem());

                    switch(id)
                    {

                    case 100: // File -> Open Model
                        env->addFileOpenDialog(L"Please select a model file to open");
                        break;

                    case 101: // File -> Set Model Archive
                        env->addFileOpenDialog(L"Please select your game archive/directory");
                        break;

                    case 200: // File -> Quit
                        Device->closeDevice();
                        break;

                    case 300: // View -> Skybox
                        SkyBox->setVisible(!SkyBox->isVisible());
                        break;

                    case 400: // View -> Debug Information
                        if (Model)
                            Model->setDebugDataVisible(Model->isDebugDataVisible() ? scene::EDS_OFF : scene::EDS_FULL);
                        break;

                    case 401:
                        createToolBoxEau();
                        break;

                    case 402:
                        createToolBoxRelief();
                        break;

                    case 403:
                        createToolBoxCiel();
                        break;

                    case 410:
                        createToolBoxForet();
                        break;

                    case 420:
                        createToolBoxInsertion();
                        break;

                    case 500: // Help->About
                        showAboutText();
                        break;

                    case 610: // View -> Material -> Solid
                        if (Model)
                            Model->setMaterialType(video::EMT_SOLID);
                        break;

                    case 620: // View -> Material -> Transparent
                        if (Model)
                            Model->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR);
                        break;

                    case 630: // View -> Material -> Reflection
                        if (Model)
                            Model->setMaterialType(video::EMT_SPHERE_MAP);
                        break;

                    case 1000:
                        setActiveCamera ( Camera[0] );
                        break;

                    case 1100:
                        setActiveCamera ( Camera[1] );
                        break;

                    }
                    break;
                }

            case EGET_FILE_SELECTED:
                {
                    // load the model file, selected in the file open dialog
                    IGUIFileOpenDialog* dialog =
                        (IGUIFileOpenDialog*)event.GUIEvent.Caller;
                    loadModel(core::stringc(dialog->getFilename()).c_str());
                }

            case EGET_SCROLL_BAR_CHANGED:

                // control skin transparency
                /*if (id == 104)
                {
                    s32 pos = ((IGUIScrollBar*)event.GUIEvent.Caller)->getPos();
                    for (s32 i=0; i<irr::gui::EGDC_COUNT ; ++i)
                    {
                        video::SColor col = env->getSkin()->getColor((EGUI_DEFAULT_COLOR)i);
                        col.setAlpha(pos);
                        env->getSkin()->setColor((EGUI_DEFAULT_COLOR)i, col);
                    }
                }
                break;*/

            case EGET_BUTTON_CLICKED:

                switch(id)
                {
                case 1101:
                    {
                        // set scale
                        gui::IGUIElement* root = env->getRootGUIElement();
                        core::vector3df scale;
                        core::stringc s;

                        s = root->getElementFromId(901, true)->getText();
                        scale.X = (f32)atof(s.c_str());
                        s = root->getElementFromId(902, true)->getText();
                        scale.Y = (f32)atof(s.c_str());
                        s = root->getElementFromId(903, true)->getText();
                        scale.Z = (f32)atof(s.c_str());

                        if (Model)
                            Model->setScale(scale);
                    }
                    break;
                case 1102:
                    env->addFileOpenDialog(L"Please select a model file to open");
                    break;
                case 1103:
                    showAboutText();
                    break;
                case 1104:
                    createToolBoxEau();
                    break;
                case 1105:
                    createToolBoxRelief();
                    break;
                case 1106:
                    createToolBoxCiel();
                    break;
                case 1107:
                    createToolBoxForet();
                    break;
                case 1108:
                    createToolBoxInsertion();
                    break;
                }

                break;
            }
        }

        return false;
    }
};


/*
    Most of the hard work is done. We only need to create the Irrlicht Engine device
    and all the buttons, menus and toolbars.
    We start up the engine as usual, using createDevice(). To make our application
    catch events, we set our eventreceiver as parameter. The #ifdef WIN32 preprocessor
    commands are not necesarry, but I included them to make the tutorial use DirectX on
    Windows and OpenGL on all other platforms like Linux.
    As you can see, there is also a unusual call to IrrlichtDevice::setResizeAble().
    This makes the render window resizeable, which is quite useful for a mesh viewer.
*/
int main()
{
    // ask user for driver

    video::E_DRIVER_TYPE driverType = video::EDT_OPENGL;

    // create device and exit if creation failed

    MyEventReceiver receiver;
    Device = createDevice(driverType, core::dimension2d<s32>(800, 600),
        16, false, false, false, &receiver);

    if (Device == 0)
        return 1; // could not create selected driver.

    Device->setResizeAble(true);

    Device->setWindowCaption(L"AoL_M");

    video::IVideoDriver* driver = Device->getVideoDriver();
    IGUIEnvironment* env = Device->getGUIEnvironment();
    scene::ISceneManager* smgr = Device->getSceneManager();

    driver->setTextureCreationFlag(video::ETCF_ALWAYS_32_BIT, true);

    smgr->addLightSceneNode();
    smgr->addLightSceneNode(0, core::vector3df(50,-50,100), video::SColorf(1.0f,1.0f,1.0f),20000);
    // add our media directory as "search path"
    Device->getFileSystem()->addFolderFileArchive ( "../../media/" );

    /*
        The next step is to read the configuration file. It is stored in the xml
        format and looks a little bit like this:

        <?xml version="1.0"?>
        <config>
            <startUpModel file="some filename" />
            <messageText caption="Irrlicht Engine Mesh Viewer">
                Hello!
            </messageText>
        </config>

        We need the data stored in there to be written into the global variables
        StartUpModelFile, MessageText and Caption. This is now done using the
        Irrlicht Engine integrated XML parser:
    */

    // read configuration from xml file

    io::IXMLReader* xml = Device->getFileSystem()->createXMLReader(
        "config.xml");

    while(xml && xml->read())
    {
        switch(xml->getNodeType())
        {
        case io::EXN_TEXT:
            // in this xml file, the only text which occurs is the messageText
            MessageText = xml->getNodeData();
            break;
        case io::EXN_ELEMENT:
            {
                if (core::stringw("startUpModel") == xml->getNodeName())
                    StartUpModelFile = xml->getAttributeValue(L"file");
                else
                if (core::stringw("messageText") == xml->getNodeName())
                    Caption = xml->getAttributeValue(L"caption");
            }
            break;
        }
    }

    if (xml)
        xml->drop(); // don't forget to delete the xml reader

    /*
        That wasn't difficult. Now we'll set a nicer font and create the
        Menu. It is possible to create submenus for every menu item. The call
        menu->addItem(L"File", -1, true, true); for example adds a new menu
        Item with the name "File" and the id -1. The following parameter says
        that the menu item should be enabled, and the last one says, that
        there should be a submenu. The submenu can now be accessed with
        menu->getSubMenu(0), because the "File" entry is the menu item with
        index 0.
    */

    // set a nicer font

    IGUISkin* skin = env->getSkin();
    IGUIFont* font = env->getFont("fonthaettenschweiler.bmp");
    if (font)
        skin->setFont(font);

    // create menu
    gui::IGUIContextMenu* menu = env->addMenu();
    menu->addItem(L"Fichier", -1, true, true);
    menu->addItem(L"Edition", -1, true, true);
    menu->addItem(L"Outils", -1, true, true);
    menu->addItem(L"Vues", -1, true, true);
    menu->addItem(L"Aide", -1, true, true);

    gui::IGUIContextMenu* submenu;
    submenu = menu->getSubMenu(0);
    submenu->addItem(L"Nouveau", 100);
    submenu->addItem(L"Ouvrir", 101);
    submenu->addItem(L"Enregistrer", 102);
    submenu->addItem(L"Enregistrer sous", 103);
    submenu->addItem(L"Revenir a la derniere sauvegarde", 104);
    submenu->addItem(L"Explorer les fichiers temporaires", 105);
    submenu->addSeparator();
    submenu->addItem(L"Quitter", 200);

    submenu = menu->getSubMenu(1);
    submenu->addItem(L"Annuler", 300);
    submenu->addItem(L"Repeter", 310);
    submenu->addItem(L"Copier", 320 );
    submenu->addItem(L"Coller", 330);
    submenu->addItem(L"Couper", 340);
    submenu->addItem(L"Generer", 350);
    submenu->addItem(L"Redimensionner", 360);
    submenu->addItem(L"Dupliquer", 370);

    submenu = menu->getSubMenu(2);
    submenu->addItem(L"Terrain",-1, true, true);
    submenu->addItem(L"Foret", 410);
    submenu->addItem(L"Insertion", 420);

    submenu = submenu->getSubMenu(0);
    submenu->addItem(L"Eau", 401);
    submenu->addItem(L"Relief", 402);
    submenu->addItem(L"Ciel", 403);

    submenu = menu->getSubMenu(3);
    submenu->addItem(L"Rendu", 500);
    submenu->addItem(L"Mode", -1, true, true);

    submenu = submenu->getSubMenu(1);
    submenu->addItem(L"Solide", 1000);
    submenu->addItem(L"Fil de fer", 1010);
    submenu->addItem(L"Avec texture", 1020);

    submenu= menu->getSubMenu(3);
    submenu->addItem(L"Camera", -1, true, true);
    submenu->addItem(L"Vue globale", 510);

    submenu = submenu->getSubMenu(2);
    submenu->addItem(L"FPS", 1100);
    submenu->addItem(L"Normale", 1110);


    submenu = menu->getSubMenu(4);
    submenu->addItem(L"Documentation", 600);
    submenu->addSeparator();
    submenu->addItem(L"A propos", 610);

    /*
        Below the toolbar, we want a toolbar, onto which we can place
        colored buttons and important looking stuff like a senseless
        combobox.
    */

    // create toolbar

    gui::IGUIToolBar* bar = env->addToolBar();

    video::ITexture* image = driver->getTexture("open.png");
    bar->addButton(1102, 0, L"Ouvrir",image, 0, false, true);

    image = driver->getTexture("eau.png");
    bar->addButton(1104, 0, L"Outil eau",image, 0, false, true);

    image = driver->getTexture("relief.png");
    bar->addButton(1105, 0, L"Outil Relief",image, 0, false, true);

    image = driver->getTexture("ciel.png");
    bar->addButton(1106, 0, L"Outil Ciel",image, 0, false, true);

    image = driver->getTexture("arbre.png");
    bar->addButton(1107, 0, L"Outil Arbre",image, 0, false, true);

    image = driver->getTexture("insertion.png");
    bar->addButton(1108, 0, L"Outil Insertion",image, 0, false, true);

    image = driver->getTexture("help.png");
    bar->addButton(1109, 0, L"Aide", image, 0, false, true);

    /*
        To make the editor look a little bit better, we disable transparent
        gui elements, and add a Irrlicht Engine logo. In addition, a text,
        which will show the current frame per second value is created, and
        the window caption changed.
    */

    // disable alpha

    for (s32 i=0; i<gui::EGDC_COUNT ; ++i)
    {
        video::SColor col = env->getSkin()->getColor((gui::EGUI_DEFAULT_COLOR)i);
        col.setAlpha(255);
        env->getSkin()->setColor((gui::EGUI_DEFAULT_COLOR)i, col);
    }


    /*
        That's nearly the whole application. We simply show the about
        message box at start up, and load the first model. To make everything
        look better, a skybox is created and a user controled camera,
        to make the application a little bit more interactive. Finally,
        everything is drawed in a standard drawing loop.
    */


    // add a camera scene node
    Camera[0] = smgr->addCameraSceneNodeMaya();
    Camera[1] = smgr->addCameraSceneNodeFPS();

    setActiveCamera ( Camera[0] );

    // draw everything

    while(Device->run() && driver)
    {
        if (Device->isWindowActive())
        {
            driver->beginScene(true, true, video::SColor(150,50,50,50));


            if(cbCarre->isChecked())
            {
                cbRond->setChecked(false);
                cbLosange->setChecked(false);
            }
            else if(cbRond->isChecked())
            {
                cbCarre->setChecked(false);
                cbLosange->setChecked(false);
            }

            else if(cbLosange->isChecked())
            {
                cbCarre->setChecked(false);
                cbRond->setChecked(false);
            }


            smgr->drawAll();
            env->drawAll();

            driver->endScene();
        }
        else
            Device->yield();
    }

    Device->drop();
    return 0;
}

Dernière modification par vrag (02-07-2007 14:43:51)

deja si ca plante à la compilation et non pas quand tu cliques sur le menu item ca veut dire que ca foire dans le main()
Commente ce que tu as ajouté et fais un flux de sortie std::cout pour afficher ce qui se fait au fur et à mesure dans la console. A chaque gros point du code t'ajoutes un std::cout << truc

alors sa plante dans la boucle juste avant les if
j'ai ouvert while(wnd) avant les if et je l'ai fermer après. Là le programme marche très bien mais les if ne marche plus. Par là je veux dire que quand je coche une checkBox les autres restent cochées.

Les commentaires je vais les rajouter dans pas longtemps, une fois que j'aurais résolu ce pb

Dernière modification par vrag (02-07-2007 19:47:56)

Hello,
Moi j'aurrai plustôt ciblé ça dans les events de chaques checkbox direct dans la classe du receiver comme ça pas d'appel de méthode à gérer ^^.

izguit :

Ca marchera mais les globales cay mal .

Je suis bien d'accord.
Sinon tu peut utiliser les id, tu mets une id à ta checkbox via setId ou quand tu la cree :
cbCarre = env->addCheckBox(true, core::rect<s32>(10,55,200,75), t1, id, L"Carre");
Chaque id doit etre unique et ensuite tu récupères le la check box en faisant dans ton main:
IGUICheckBox * cbCarre = gui->getRootGUIElement ()->getElementFromId(id,true);
Il faut peut etre faire un cast en rajoutant (IGUICheckBox *) après le egal.

C'est pratique mais il faut etre sur de son codeou faire une verification apres avec if (cbCarre)

Sinon tu peut aussi utiliser une structure ou tu mets toute les variables dont tu as besoin et tu fait passer le pointeur de cette variable a tes fonctions. C'est une aproche c et non c++ mais bon pour l'instant ton progamme est plus en c donc bon.

Sinon les autres methode proposé vont bien

Pour ton probleme c'est tres simple bien que pas facile a resoudre(enfin si mais c un peu chiant pour toi). Je crois que si j'ai bien compris ton code il y a une condition a qu'une toolbox soit creer donc di elle ne l'est pas encore le check n'existe pas non plus et le pointeur pointer donc vers n'importe quoi. C'est pour ca que normalement quand on ceer un pointeur on met tralala* tralala1 = 0; Comme ca le bug est repere plus facilement et c'est moin dangereux pour ton ordi. Pour resoudre ton probleme sinon il faut que tu vérifie que tes toolbox soit ouverte pour faire les tests que izguit t'a dit. Pour cela il faut rajouter une nouvelle variable tu genre bool toolboxcielopen = false; Que tu mets à true quand ta toolbox est ouverte et à false quand elle ne l'ai pas.
Sa va etre complique à mettre en place donc la methode proposé par copland me parait pas mal. Elle consiste à recuperer l'event quand tu clique sur une de tes checkbox et de mettre ton code de decochage/cochage dans MyEventReceiver car si tu clique sur une checkbox c'est qu'elle existe. Le probleme de la porte de tes variables reste entier : soit global, soit id.

J'ai pas le courage de me relire et c pas bien si tu ne comprend pas qq dis le moi et si tu veut un exemple pour dans l'event dit le aussi mais la g pas le courage.

dark calculator

déjà merci pour ton message
ensuite j'ai pas tout compris mais j'ai saisi ce que tu voulais dire. Je pense que je vais faire par le MyEventReceiver.
J'ai rajouté le code suivant dans l'EventReceiver

case EGET_CHECKBOX_CHANGED:
                {
                    if (cbCarre->isChecked())
                    {
                        cbRond->setChecked(false);
                        cbLosange->setChecked(false);
                    }
                    if (cbRond->isChecked())
                    {
                        cbCarre->setChecked(false);
                        cbLosange->setChecked(false);
                    }
                    if (cbLosange->isChecked())
                    {
                        cbRond->setChecked(false);
                        cbCarre->setChecked(false);
                    }
                }

ya du progrès parce que là ça marche a peu près
mais il y a un petit problème:
- je peux pas passer de cbRond à cbLosange ni de cbCarre à cbRond ou à cbLosange sans décocher la case. Par contre je peux passer de cbLosange à cbRond, de cbLosange à cbCarre et de cbRond a cbCarre

Comment faire pour résoudre ce problème ?


Merci d'avance

Dernière modification par vrag (03-07-2007 17:20:53)

salut

En fait je crois que le code de izguit ne va pas debuit le debut(sous toute reserve) Car il ne regarde pas si tu a clique dessus mais si elle est coche donc par exemple si carre est coche et que tu clique sur rond alors il y aura rond et carre de cocher. Ensuite vient ton code qui regarde en premier si carre est coche : c'est le cas du coup il decoche  rond et losange. Et donc les autres if ne s'applique pas. Au final on a toujours carre de coche meme si on a clique sur triangle. Le fait que parfois ca marche tient quasiment conte du hasard.
De plus ton code va si tu n'a pas d'autre check box mais si c'etait le cas tu aurait le meme bug qu'avant sachant que la checkbox cbCarre n'existe pas forcement si c'est une autre sur laquelle on a clique.

Donc je te donne le code que j'écrirait à ta place à vérifier car je ne peut pas le compiler dans l'immédiat :

class MyEventReceiver : public IEventReceiver
{
public:
    virtual bool OnEvent(SEvent event)
    {
        if (event.EventType == EET_GUI_EVENT)
        {
            s32 id = event.GUIEvent.Caller->getID();
            IGUIEnvironment* env = Device->getGUIEnvironment();
                        [....]
                              case EGET_CHECKBOX_CHANGED:
                              {
                                      switch (id)
                                      {
                                              case 1:
                                                  cbCarre->setChecked(true);
                                                  cbRond->setChecked(false);
                                                  cbLosange->setChecked(false);
                                              break;
                                              case 2:
                                                  cbCarre->setChecked(false);
                                                  cbRond->setChecked(true);
                                                  cbLosange->setChecked(false);
                                              break;
                                              case 3:
                                                  cbCarre->setChecked(false);
                                                  cbRond->setChecked(false);
                                                  cbLosange->setChecked(true);
                                              break;
                                         }
                               }[...]

Et il faut donner une id a tes checkbox par exemple 1,2,3 pour la donner il faut remplacer -1 par l'id quand tu cree une check box

Sinon j'ai eu une autre idée de code :

class MyEventReceiver : public IEventReceiver
{
public:
    virtual bool OnEvent(SEvent event)
    {
        if (event.EventType == EET_GUI_EVENT)
        {
            s32 id = event.GUIEvent.Caller->getID();
            IGUIEnvironment* env = Device->getGUIEnvironment();
                        [....]
                              case EGET_CHECKBOX_CHANGED:
                              {
                                          env->getRootGUIElement()->getElementFromId(1)->setChecked(false);
                                          env->getRootGUIElement()->getElementFromId(2)->setChecked(false);
                                          env->getRootGUIElement()->getElementFromId(3)->setChecked(false);
                                          env->getRootGUIElement()->getElementFromId(id)->setChecked(true);
                               }[...]

Je pense que le deuxieme est mieu mais a verifier en tous cas il  y a moin de test à faire mais une instructiuon de plus, à voir.
Sinon tu saurait peut etre obligé de remplacer env->getRootGUIElement()->getElementDromId(?)->setChecked(?); par ((IGUICheckedBox*) env->getRootGUIElement()->getElementDromId(1))->setChecked(false);

Voila je crois que j'ai encore une fois pas ete totalement claire n'hesite pas a posé des questions sur mon code qui ne passerat peut etre pas a la compilation car je suis pas sur des nom de fonctions

a+

dark calculator

Dernière modification par dark calculator (03-07-2007 23:31:36)

j'ai choisi la première solution et elle marche très bien.
Merci beaucoup à tout le monde. Grace a vous j'ai bien avancé. Si jamais j'ai encore besoin d'aide ( ce qui ne fais aucun doute) je reviendrais posté sur ce forum.

Et une dernière question : c'est pas getElementFromId() plutot que getElementDromId ?

Encore merci
a+

vrag :

Et une dernière question : c'est pas getElementFromId() plutot que getElementDromId ?

Je ne vois pas de quoi tu parles

Sinon je suis content que ca marche

a+

dark calculator