Von cOsdItem ableiten

Hallo!
Ich sitze schon den ganzen Mittag vor einem Problem:
Ich will eine Klasse von cOsdItem ableiten, um eine Variable hinzuzufügen.
Folgende Deklaration:

class cXItem : public cOsdItem
{
public:
cXItem(const char *Text, bool m_Folder);


~cXItem();


bool isFolder() const;


private:
bool m_Folder;
};

Dann die implementierung:

cXmameItem::cXmameItem(const char *Text, bool Folder) : cOsdItem(Text), m_Folder(Folder)
{
}






cXItem::~cXItem()
{}






bool cXItem::isFolder() const
{
    return m_Folder;
}

Wenn ich nun ein XItem-Objekt anlege mit

for (m_MapIter = m_GameMap.begin(); m_MapIter != m_GameMap.end(); ++m_MapIter)
        {
            if ((m_MapIter->first).substr(0, 1) == Item->Text())
            {
                cXItem* GameName = new cXItem((m_MapIter->first).c_str(), false);
                Folder->Add(GameName);
            }
        }

dann ist isFolder() immer true, obwohl es false sein müsste.
Hab ich bei der Ableitung etwas falsch gemacht?

Ein paar Analysen ergaben, dass das Problem ganz wo anders herkommt.
Ich habe zu einem cOsdMenu mit AddSubMenu ein Untermenü hinzugefügt.
Wenn das Submenu offen ist, dann krieg ich mit
cXItem* Item = (cXItem*)Get(Current());
trotzdem nur das Item, dass ich im Hauptmenü ausgewählt hatte, und nicht das
aktuelle Item aus dem Submenu.

Na dann brauch ich ja für meine Zwecke nicht abzuleiten. Ich hatte ja
lediglich eine Variable und eine Methode hinzugefügt, ob das Item ein
Folder ist, oder nicht.
Ich hab nun wieder ein einfaches cOsdItem genommen.
Zu Testzwecken hab ich den Inhalt von Item mal in eine Datei umgeleitet,
da es immernoch nicht ging. Item ist immernoch das, vom Hauptmenü.

eOSState cGameList::Open()
{
    cOsdItem* Item = (cOsdItem*)Get(Current());
    if (!HasSubMenu())
    {
        cOsdMenu* Folder = new cOsdMenu(Item->Text());


        for (m_MapIter = m_GameMap.begin(); m_MapIter != m_GameMap.end(); ++m_MapIter)
        {
            if ((m_MapIter->first).substr(0, 1) == Item->Text())
            {
                cOsdItem* GameName = new cOsdItem((m_MapIter->first).c_str());
                Folder->Add(GameName);
            }
        }
        AddSubMenu(Folder);
        SetHelp("Open", "Info");
        return osUnknown;
    }
    else
    {
        std::stringstream SelectedGame;
        SelectedGame << Item->Text();
    std::stringstream Command;
    Command << "export DISPLAY=:0.0 && echo \"" << Item->Text() << "\" > /tmp/test";
    system(Command.str().c_str());
        return osUnknown;
    }
}

Es wird eigentlich folgendes gemacht. Im Hauptmenü werden Folders von A-Z
erstellt. In der GameMap sind Strings abgelegt. Die werden, falls ich im Haupt-
menü bin, entsprechend ihres Anfangsbuchstabens eingeordnet. Ich wähle
z. B. "B", dann werden nur die Einträge beginnend mit "B" angezeigt.
Wenn ich ein Item in einem Folder wähle, dann soll Command ausgeführt werden.
In /tmp/test steht immer nur der Anfangsbuchstabe. Item ist also immer das
vom Hauptmenü. Ansonsten geht alles soweit. Was mach ich da falsch?

Ich denke, es liegt daran, das beim Aufruf von Open() das Folder noch kein
Submenu ist. Es wird ja erst in dieser Funktion zu einem.
Versteh ich das richtig?
Ich muss zuerst ein cOsdMenu Objekt erstellen, und diesem dann cOsdItems
hinzufügen. Danach miedes Menü mit AddSubMenu dem Hauptmenü
hinzufügen. Dann das nächste Submenu.
Oder lieg ich da falsch?
Ich hab das ganze jetzt so umgeschrieben, dass ProcessKey abhängig von
HasSubMenu eine Methode aufruft, die das Submenu generiert, und dann
zurückliefert. Ansonsten wird eine Methode Open aufgerufen, die dann
den Eintrag verarbeitet, wenn es kein Submenu ist.
Die Menüs funktionieren ja auch. Doch sobald ich im Submenu einen Eintrag
auswähle, dann hab ich nach Aufruf von Current trotzdemdas Item des
Hauptmenüs, also nur einen Anfangsbuchstaben.
Oder muss ich das Submenu in eine extra Klasse packen?
So sieht das ganze momentan aus:

void cGameList::createFolders()
{
    cOsdItem* Folder = new cOsdItem("#");
    Add(Folder);


    for (int i = 65; i != 91; i++)
    {
        char FolderName[1];
        sprintf(FolderName, "%c", i);
        cOsdItem* Folder = new cOsdItem(FolderName);
        Add(Folder);
    }
    SetHelp("Open");
}






eOSState cGameList::ProcessKey(eKeys Key)
{
    eOSState state=cOsdMenu::ProcessKey(Key);
    if (HasSubMenu())
    {
        switch (Key)
        {
        case kOk:
            Open();
            break;
        case kRed:
            Open();
        default:
            break;
        }
        return state;
    }


    switch (Key)
    {
    case kOk:
        return FillFolders();
        break;
    case kRed:
        return FillFolders();
    default:
        break;
    }
    return state;
}






void cGameList::Open()
{
    cOsdItem* Item = (cOsdItem*)Get(Current());
    std::stringstream SelectedGame;
    SelectedGame << Item->Text();

    //For testing only
    std::stringstream Command;
    Command << "export DISPLAY=:0.0 && echo \"" << Item->Text() << "\" > /tmp/test";
    system(Command.str().c_str());
}






eOSState cGameList::FillFolders()
{
    cOsdItem* Item = (cOsdItem*)Get(Current());
    cOsdMenu* Folder = new cOsdMenu(Item->Text());


    for (m_MapIter = m_GameMap.begin(); m_MapIter != m_GameMap.end(); ++m_MapIter)
    {
        if ((m_MapIter->first).substr(0, 1) == Item->Text())
        {
            cOsdItem* GameName = new cOsdItem((m_MapIter->first).c_str());
            Folder->Add(GameName);
        }
    }


    return AddSubMenu(Folder);
}

Wenn ich also nun das Plugin öffne, kann ich die Folder #, A-Z wählen.
Die Einträge aus der Map werden auch richtig einsortiert. Wenn ich also
das Folder A wähle, dann seh ich auch nur die Einträge mit dem Anfangs-
buchstaben A. Um den Inhalt zu überprüfen, lass ich mit der system-Methode
Item->Text() von Current nach /tmp/test schreiben.
Also, ich wähle das Folder A, dann einen Eintrag mit A, in /tmp/test steht A,
anstatt dem Namen des Eintrags.
Es sieht also so aus, als würde ein Current-Aufruf im Submenu, das Item des
Hauptmenüs nehmen.
Wahrscheinlich hab ich jetzt so viel geschrieben, dass keiner mehr mein
Problem versteht

Was ich auch nicht nachvollziehen kann:

cOsdItem* Item = (cOsdItem*)Get(Current());

Wo kommt das Get her?
Und Current() ist ja eine Methode von cOsdMenu, liefert aber das aktuell
gewählte Item?
Mein Submenu ist ja auch ein cOsdMenu. Warum liefert Current() dann
das Item vom Hauptmenü?

Hab ich nicht so ganz durchschaut, aber ich hab's hingekriegt. Ich hab das
Submenu in eine separate Klasse gepackt. Dann stimmt Current().