void FileOpener::openFiles()
{
    if (isWaitingForMessageBox) {
        isWaitingForMessageBox = false;
        ASSERT(lastTopWin.isValid());
        if (lastTopWin.isValid()) {
            lastTopWin->requestCloseWindow(TopWin::CLOSED_SILENTLY);
            lastTopWin = NULL;
        }
    }

    ASSERT(!isWaitingForMessageBox)

    while (fileParameterList.isValid() && fileParameterList->getLength() > 0)
    {
        int    numberOfWindows  = fileParameterList->get(0).numberOfWindows;
        String fileName         = fileParameterList->get(0).fileName;
        String encoding         = fileParameterList->get(0).encoding;
        String resolvedFileName = File(fileName).getAbsoluteNameWithResolvedLinks();

        if (numberOfWindows <= 0)
        {
            numberOfWindows = 1;
        }

        RawPtr<TopWinList> topWins = TopWinList::getInstance();

        if (lastTopWin.isInvalid())
        {

            numberOfRaisedWindows = 0;

            for (int w = 0; w < topWins->getNumberOfTopWins() && numberOfRaisedWindows < numberOfWindows; ++w)
            {
                EditorTopWin* topWin = dynamic_cast<EditorTopWin*>(topWins->getTopWin(w));
                if (topWin != NULL && File(topWin->getFileName()).getAbsoluteNameWithResolvedLinks() == resolvedFileName) {
                    topWin->raise();
                    numberOfRaisedWindows += 1;
                    lastTopWin = topWin;
                }
            }

            if (lastTopWin.isInvalid() && numberOfRaisedWindows < numberOfWindows)
            {
                TextData::Ptr     textData     = TextData::create();
                LanguageMode::Ptr languageMode;
                HilitedText::Ptr  hilitedText;
                
                Nullable<String> errorMessage;

                try
                {
                    ByteBuffer buffer; 
                    File(fileName).loadInto(&buffer);
                    
                    Nullable<GlobalConfig::LanguageModeAndEncoding> result;
                    try
                    {
                        result = GlobalConfig::getInstance()
                                 ->getLanguageModeAndEncodingForFileNameAndContent
                                 (
                                   fileName, 
                                   &buffer
                                 );
                        languageMode = result.get().languageMode;
                        hilitedText  = HilitedText::create(textData, languageMode);
                    }
                    catch (ConfigException& ex) {
                        languageMode = GlobalConfig::getInstance()->getDefaultLanguageMode();
                        hilitedText  = HilitedText::create(textData, languageMode);
                        errorMessage = ex.getMessage();
                    }
                    
                    if (encoding.getLength() == 0 && result.isValid() && result.get().encoding.getLength() > 0) {
                        encoding = result.get().encoding;
                    }

                    textData->takeOverFileBuffer(fileName, encoding, &buffer);
                }
                catch (LuaException& ex)
                {
                    throw;
                }
                catch (BaseException& ex)
                {
                    try
                    {
                        if (!languageMode.isValid()) {
                            languageMode = GlobalConfig::getInstance()->getLanguageModeForFileName(fileName);
                        }
                        if (!hilitedText.isValid()) {
                            hilitedText  = HilitedText::create(textData, languageMode);
                        }
                    } catch (BaseException& ex2) {
                        languageMode = GlobalConfig::getInstance()->getDefaultLanguageMode();
                        hilitedText  = HilitedText::create(textData, languageMode);
                    }

                    isWaitingForMessageBox = true;
                    
                    bool fileNotExisting = false;
                    
                    try
                    {
                        throw;
                    }
                    catch (FileException& ex)
                    {
                        fileNotExisting = (ex.getErrno() == ENOENT);
                    }
                    catch (BaseException& ex)
                    {}
                    
                    if (fileNotExisting)
                    {
                        ByteBuffer emptyBuffer;
                        textData->takeOverBuffer(encoding, &emptyBuffer);
                        textData->setModifiedFlag(false);
                        textData->setRealFileName(fileName);
                    }
                    else {
                        textData->setPseudoFileName(fileName);
                    }

                    lastTopWin = EditorTopWin::create(hilitedText);

                    MessageBoxParameter p;
                    
                    if (fileParameterList->getLength() > 1)
                    {
                                        p.setTitle("Error opening files")
                                         .setMessage(ex.getMessage())
                                         .setAlternativeButton("A]bort all next files", newCallback(this, &FileOpener::handleAbortButton))
                                         .setCancelButton     ("S]kip to next file",    newCallback(this, &FileOpener::handleSkipFileButton));
                        if (fileNotExisting) {
                                        p.setDefaultButton    ("C]reate this file",     newCallback(this, &FileOpener::handleCreateFileButton));
                        } else {
                                        p.setDefaultButton    ("R]etry",                newCallback(this, &FileOpener::openFiles));
                        }
                    } 
                    else {
                                        p.setTitle("Error opening file")
                                         .setMessage(ex.getMessage())
                                         .setCancelButton     ("Ca]ncel",               newCallback(this, &FileOpener::handleAbortButton));
                        if (fileNotExisting && fileName.getLength() > 0) {
                                        p.setDefaultButton    ("C]reate this file",     newCallback(this, &FileOpener::handleCreateFileButton));
                        } else {
                                        p.setDefaultButton    ("R]etry",                newCallback(this, &FileOpener::openFiles));
                        }
                    }
                    lastTopWin->setModalMessageBox(p);
                    lastTopWin->show();
                    return;
                }
                lastTopWin = EditorTopWin::create(hilitedText);
                if (errorMessage.isValid()) {
                    MessageBoxParameter p;
                                        p.setTitle("Error opening file")
                                         .setMessage(errorMessage.get())
                                         .setCancelButton("O]K");
                    lastTopWin->setModalMessageBox(p);
                }
                lastTopWin->show();
                lastTopWin->raise();

                numberOfRaisedWindows += 1;
            }
        }

        for (int i = numberOfRaisedWindows; i < numberOfWindows; ++i)
        {
            EditorTopWin::Ptr win = EditorTopWin::create(lastTopWin->getHilitedText());
            win->show();
        }
        fileParameterList->remove(0);
        lastTopWin = NULL;
    }
    if ((fileParameterList.isInvalid() || fileParameterList->getLength() == 0) && !isWaitingForMessageBox) {
        fileParameterList.invalidate();
        openConfigFiles();
    }
}