/*    egui.cpp
 *
 *    Copyright (c) 1994-1996, Marko Macek
 *
 *    You may distribute under the terms of either the GNU General Public
 *    License or the Artistic License, as specified in the README file.
 *
 */

#include "fte.h"

int LastEventChar = -1;

EFrame::EFrame(int XSize, int YSize): GFrame(XSize, YSize) {
    CMap = 0;
    CModel = 0;
    frames = this;
}

EFrame::~EFrame() {
}

void EFrame::Update() {
    GxView *V = (GxView *)Active;

    if (V) {
        if (CModel != ActiveModel && ActiveModel) {
            char Title[256] = ""; //fte: ";
            char STitle[256] = ""; //"fte: ";

            ActiveModel->GetTitle((char *)(Title + 0), sizeof(Title) - 0,
                                  (char *)(STitle + 0), sizeof(STitle) - 0);
            ConSetTitle(Title, STitle);
            CModel = ActiveModel;
        }
    }
    GFrame::Update();
}

void EFrame::UpdateMenu() {
    GxView *V = (GxView *)Active;
    EEventMap *Map = 0;

    if (V)
        Map = V->GetEventMap();

    if (Map != CMap || CMap == 0) {
        const char *Menu = 0;
        const char *OMenu = 0;
        // set menu

        if (CMap)
            OMenu = CMap->GetMenu(EM_MainMenu);
        if (Map)
            Menu = Map->GetMenu(EM_MainMenu);
        if (Menu == 0)
            Menu = "Main";
        CMap = Map;

        if (OMenu && strcmp(OMenu, Menu) == 0) {
            // ok
        } else {
            SetMenu(Menu);
        }
    } /*else if (CMap == 0 && Map == 0) {
        SetMenu("Main");
    }*/

    GFrame::UpdateMenu();
}

EGUI::EGUI(int &argc, char **argv, int XSize, int YSize): GUI(argc, argv, XSize, YSize) {
    ActiveMap = 0;
    OverrideMap = 0;
    strcpy(CharMap, "");
}

EGUI::~EGUI() {
}

int EGUI::ExecCommand(GxView *view, int Command, ExState &State) {
    if (Command & CMD_EXT)
        return ExecMacro(view, Command & ~CMD_EXT);

    if (Command == ExFail)
        return ErFAIL;

    if (view->IsModelView()) {
        ExModelView *V = (ExModelView *)view->Top;
        EView *View = V->View;

        switch (Command) {
        case ExFileClose:               return FileClose(View, State);
        case ExFileCloseAll:            return FileCloseAll(View, State);
        case ExExitEditor:              return ExitEditor(View);
        case ExIncrementalSearch:
#ifdef CONFIG_I_SEARCH
            return View->MView->Win->IncrementalSearch(View);
#else
            return ErFAIL;
#endif
        }
    }
    switch (Command) {
    case ExWinRefresh:              view->Repaint(); return 1;
    case ExWinNext:                 return WinNext(view);
    case ExWinPrev:                 return WinPrev(view);
    case ExShowEntryScreen:         return ShowEntryScreen();
    case ExRunProgram:              return RunProgram(State, view);
    case ExRunProgramAsync:         return RunProgramAsync(State, view);
    case ExMainMenu:                return MainMenu(State, view);
    case ExShowMenu:                return ShowMenu(State, view);
    case ExLocalMenu:               return LocalMenu(view);
    case ExFrameNew:                return FrameNew();
    case ExFrameNext:               return FrameNext(view);
    case ExFramePrev:               return FramePrev(view);

    case ExWinHSplit:               return WinHSplit(view);
    case ExWinClose:                return WinClose(view);
    case ExWinZoom:                 return WinZoom(view);
    case ExWinResize:               return WinResize(State, view);
    case ExDesktopSaveAs:           return DesktopSaveAs(State, view);
    case ExDesktopSave:
        if (DesktopFileName[0] != 0)
            return SaveDesktop(DesktopFileName);
        return 0;
    case ExChangeKeys:
        {
            char kmaps[64] = "";
            EEventMap *m;

            if (State.GetStrParam(0, kmaps, sizeof(kmaps)) == 0) {
                SetOverrideMap(0, 0);
                return 0;
            }
            m = FindEventMap(kmaps);
            if (m == 0)
                return 0;
            SetOverrideMap(m->KeyMap, m->Name);
            return 1;
        }
    }
    return view->ExecCommand(Command, State);
}

int EGUI::BeginMacro(GxView *view) {
    view->BeginMacro();
    return 1;
}

int EGUI::ExecMacro(GxView *view, int Macro) {
    int i, j;
    ExMacro *m;
    ExState State;

    if (Macro == -1)
        return ErFAIL;

    if (BeginMacro(view) == -1)
        return ErFAIL;

    State.Macro = Macro;
    State.Pos = 0;
    m = &Macros[State.Macro];
    for (; State.Pos < m->Count; State.Pos++) {
        i = State.Pos;
        if (m->cmds[i].type != CT_COMMAND ||
            m->cmds[i].u.num == ExNop)
            continue;

        for (j = 0; j < m->cmds[i].repeat; j++) {
            State.Pos = i + 1;
            if (ExecCommand(view, m->cmds[i].u.num, State) == 0 && !m->cmds[i].ign)
            {
                return ErFAIL;
            }
        }
        State.Pos = i;
    }
    return ErOK;
}

void EGUI::SetMsg(char *Msg) {
    static char CharMap[128] = "";

    if (Msg == 0) {
        strcpy(CharMap, "");
    } else {
        strcat(CharMap, "[");
        strcat(CharMap, Msg);
        strcat(CharMap, "]");
    }
    if (ActiveModel)
        ActiveModel->Msg(S_INFO, CharMap);
}

void EGUI::SetOverrideMap(EKeyMap *aMap, char *ModeName) {
    OverrideMap = aMap;
    if (aMap == 0)
        SetMsg(0);
    else
        SetMsg(ModeName);
}

void EGUI::SetMap(EKeyMap *aMap, KeySel *ks) {
    char key[32] = "";

    ActiveMap = aMap;
    if (ActiveMap == 0) {
        SetMsg(0);
    } else {
        if (ks != 0) {
            GetKeyName(key, *ks);
            SetMsg(key);
        }
    }
}

void EGUI::DispatchKey(GxView *view, TEvent &Event) {
    EEventMap *EventMap;
    EKeyMap *map;
    EKey *key = 0;
    char Ch;

    if (Event.Key.Code & kfModifier)
        return;

    LastEventChar = -1;
    if (GetCharFromEvent(Event, &Ch))
        LastEventChar = Ch;

    if ((EventMap = view->GetEventMap()) == 0)
        return;

    map = EventMap->KeyMap;

    if (ActiveMap || OverrideMap) {
        map = ActiveMap;
        if (OverrideMap)
            map = OverrideMap;
        while (map) {
            if ((key = map->FindKey(Event.Key.Code)) != 0) {
                if (key->fKeyMap) {
                    SetMap(key->fKeyMap, &key->fKey);
                    Event.What = evNone;
                    return ;
                } else {
                    SetMap(0, &key->fKey);
                    ExecMacro(view, key->Cmd);
                    Event.What = evNone;
                    return ;
                }
            }
            //            printf("Going up\n");
            map = map->fParent;
        }
        if (!OverrideMap) {
            SetMap(0, 0);
            Event.What = evNone;
        }
        return ;
    }
    while (EventMap) {
        if (map) {
            if ((key = map->FindKey(Event.Key.Code)) != 0) {
                if (key->fKeyMap) {
                    SetMap(key->fKeyMap, &key->fKey);
                    Event.What = evNone;
                    return ;
                } else {
                    ExecMacro(view, key->Cmd);
                    Event.What = evNone;
                    return ;
                }
            }
        }
        EventMap = EventMap->Parent;
        if (EventMap == 0) break;
        map = EventMap->KeyMap;
    }
//    if (GetCharFromEvent(Event, &Ch))
//        CharEvent(view, Event, Ch);
    SetMap(0, 0);
}

void EGUI::DispatchCommand(GxView *view, TEvent &Event) {
    if (Event.Msg.Command > 65536 + 16384)
    { // hack for PM toolbar
        Event.Msg.Command -= 65536 + 16384;
        BeginMacro(view);
        ExState State;
        State.Macro = 0;
        State.Pos = 0;
        ExecCommand(view, Event.Msg.Command, State);
        Event.What = evNone;
    } else if (Event.Msg.Command >= 65536) {
        Event.Msg.Command -= 65536;
        ExecMacro(view, Event.Msg.Command);
        Event.What = evNone;
    }
}

void EGUI::DispatchEvent(GFrame *frame, GView *view, TEvent &Event) {
    GxView *xview = (GxView *) view;

    if (Event.What == evNone ||
        (Event.What == evMouseMove && Event.Mouse.Buttons == 0))
        return ;

    if (Event.What == evNotify && Event.Msg.Command == cmPipeRead) {
        Event.Msg.Model->NotifyPipe(Event.Msg.Param1);
        return;
    }
    if (xview->GetEventMap() != 0) {
        switch (Event.What) {
        case evKeyDown:
            DispatchKey(xview, Event);
            break;
        case evCommand:
            if (Event.Msg.Command >= 65536) {
                DispatchCommand(xview, Event);
            } else {
                switch (Event.Msg.Command) {
                case cmClose:
                    {
                        assert(ActiveView != 0);
                        FrameClose(ActiveView->MView->Win);
                        return;
                    }
                }
            }
        }
    }
    GUI::DispatchEvent(frame, view, Event);
#if defined(OS2) && !defined(DBMALLOC) && defined(CHECKHEAP)
    if (_heapchk() != _HEAPOK)
        DieError(0, "Heap memory is corrupt.");
#endif
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////

int EGUI::WinNext(GxView *view) {
    view->Parent->SelectNext(0);
    return 1;
}

int EGUI::WinPrev(GxView *view) {
    view->Parent->SelectNext(1);
    return 1;
}

int EGUI::FileCloseX(EView *View, int CreateNew, int XClose) {
    char Path[MAXPATH];

    // this should never fail!
    if (GetDefaultDirectory(View->Model, Path, sizeof(Path)) == 0)
        return 0;

    if (View->Model->ConfQuit(View->MView->Win)) {

        View->Model->DeleteRelated();

        // close everything that can be closed without confirmation if closing all
        if (XClose)
            while (View->Model->Next != View->Model &&
                   View->Model->Next->CanQuit())
                delete View->Model->Next;

        View->DeleteModel(View->Model);

#ifdef CONFIG_OBJ_DIRECTORY
        if (ActiveModel == 0 && CreateNew) {
            EView *V = ActiveView;
            EModel *m = new EDirectory(0, &ActiveModel, Path);
            assert(m != 0);

            do {
                V = V->Next;
                V->SelectModel(ActiveModel);
            } while (V != ActiveView);
            return 0;
        }
#endif

        if (ActiveModel == 0) {
            StopLoop();
        }
        return 1;
    }
    return 0;
}


int EGUI::FileClose(EView *View, ExState &State) {
    int x = 0;

    if (State.GetIntParam(View, &x) == 0)
        x = OpenAfterClose;

    return FileCloseX(View, x);
}

int EGUI::FileCloseAll(EView *View, ExState &State) {
    int x = 0;

    if (State.GetIntParam(View, &x) == 0)
        x = OpenAfterClose;

    while (ActiveModel)
        if (FileCloseX(View, x, 1) == 0) return 0;
    return 1;
}

int EGUI::WinHSplit(GxView *View) {
    GxView *view;
    ExModelView *edit;
    EView *win;
    int W, H;

    View->ConQuerySize(&W, &H);

    if (H < 8)
        return 0;
    view = new GxView(View->Parent);
    if (view == 0)
        return 0;
    win = new EView(ActiveModel);
    if (win == 0)
        return 0;
    edit = new ExModelView(win);
    if (edit == 0)
        return 0;
    view->PushView(edit);
    view->Parent->SelectNext(0);
    return 1;
}

int EGUI::WinClose(GxView *V) {
    EView *View = ActiveView;

    if (View->Next == View) {
        // when closing last window, close all files
        if (ExitEditor(View) == 0)
            return 0;
    } else {
        View->MView->Win->Parent->SelectNext(0);
        delete View->MView->Win;
    }
    return 1;
}

int EGUI::WinZoom(GxView *View) {
    GView *V = View->Next;
    GView *V1;

    while (V) {
        V1 = V;
        if (V == View)
            break;
        V = V->Next;
        delete V1;
    }
    return 1;
}

int EGUI::WinResize(ExState &State, GxView *View) {
    int Delta = 1;

    if (State.GetIntParam(0, &Delta)) {
        if (View->ExpandHeight(Delta) == 0)
            return 1;
    }
    return 0;
}

int EGUI::ExitEditor(EView *View) {
    EModel *B = ActiveModel;

    // check/save modified files
    while (ActiveModel) {
        if (ActiveModel->CanQuit()) ;
        else {
            View->SelectModel(ActiveModel);
            int rc = ActiveModel->ConfQuit(View->MView->Win, 1);
            if (rc == -2) {
                View->FileSaveAll();
                break;
            }
            if (rc == 0)
                return 0;
        }

        ActiveModel = ActiveModel->Next;
        if (ActiveModel == B)
            break;
    }

#ifdef CONFIG_DESKTOP
    if (SaveDesktopOnExit && DesktopFileName[0] != 0)
        SaveDesktop(DesktopFileName);
    else if (LoadDesktopMode == 2) {       // Ask about saving?
        GxView* gx = View->MView->Win;

        if (gx->GetStr("Save desktop As",
                       sizeof(DesktopFileName), DesktopFileName,
                       HIST_DEFAULT) != 0)
        {
            SaveDesktop(DesktopFileName);
        }
    }
#endif

    while (ActiveModel) {
        View->Model->DeleteRelated();  // delete related views first

        while (View->Model->Next != View->Model &&
               View->Model->Next->CanQuit())
            delete View->Model->Next;

        View->DeleteModel(View->Model);
    }

    StopLoop();
    return 1;
}

int EGUI::ShowEntryScreen() {
    return gui->ShowEntryScreen();
}

int EGUI::RunProgram(ExState &State, GxView *view) {
    static char Cmd[512] = "";

    if (ActiveModel)
        SetDefaultDirectory(ActiveModel);

    if (State.GetStrParam(ActiveView, Cmd, sizeof(Cmd)) == 0)
        if (view->GetStr("Run", sizeof(Cmd), Cmd, HIST_COMPILE) == 0) return 0;
    gui->RunProgram(RUN_WAIT, Cmd);
    return 1;
}

int EGUI::RunProgramAsync(ExState &State, GxView *view) {
    static char Cmd[512] = "";

    if (ActiveModel)
        SetDefaultDirectory(ActiveModel);

    if (State.GetStrParam(ActiveView, Cmd, sizeof(Cmd)) == 0)
        if (view->GetStr("Run", sizeof(Cmd), Cmd, HIST_COMPILE) == 0) return 0;
    gui->RunProgram(RUN_ASYNC, Cmd);
    return 1;
}

int EGUI::MainMenu(ExState &State, GxView *View) {
    char s[3];

    if (State.GetStrParam(0, s, sizeof(s)) == 0)
        s[0] = 0;

    View->Parent->ExecMainMenu(s[0]);
    return 1;
}

int EGUI::ShowMenu(ExState &State, GxView *View) {
    char MName[32] = "";

    if (State.GetStrParam(0, MName, sizeof(MName)) == 0)
        return 0;

    View->Parent->PopupMenu(MName);
    return 0;
}

int EGUI::LocalMenu(GxView *View) {
    EEventMap *Map = View->GetEventMap();
    const char *MName = 0;

    if (Map)
        MName = Map->GetMenu(EM_LocalMenu);
    if (MName == 0)
        MName = "Local";
    View->Parent->PopupMenu(MName);
    return 0;
}

int EGUI::DesktopSaveAs(ExState &State, GxView *view) {
    if (State.GetStrParam(0, DesktopFileName, sizeof(DesktopFileName)) == 0)
        if (view->GetFile("Save Desktop", sizeof(DesktopFileName), DesktopFileName, HIST_PATH, GF_SAVEAS) == 0)
            return 0;

    if (DesktopFileName[0] != 0)
        return SaveDesktop(DesktopFileName);
    return 0;
}

int EGUI::FrameNew() {
    GxView *view;
    ExModelView *edit;

    if (!multiFrame() && frames)
        return 0;

    (void)new EFrame(ScreenSizeX, ScreenSizeY);
    assert(frames != 0);

    //frames->SetMenu("Main"); //??

    view = new GxView(frames);
    assert(view != 0);

    (void)new EView(ActiveModel);
    assert(ActiveView != 0);

    edit = new ExModelView(ActiveView);
    assert(edit != 0);
    view->PushView(edit);
    frames->Show();
    return 1;
}

int EGUI::FrameClose(GxView *View) {
    assert(frames != 0);
    assert(View != 0);

    if (!frames->isLastFrame()) {
        deleteFrame(frames);
    } else {
        if (ExitEditor(ActiveView) == 0)
            return 0;
        deleteFrame(frames);
    }
    return 1;
}

int EGUI::FrameNext(GxView *View) {
    if (!frames->isLastFrame()) {
        frames->Next->Activate();
        return 1;
    }
    return 0;
}

int EGUI::FramePrev(GxView *View) {
    if (!frames->isLastFrame()) {
        frames->Prev->Activate();
        return 1;
    }
    return 0;
}

#ifdef CONFIG_DESKTOP
int EGUI::findDesktop(char *argv[]) {
    /*
     *  Locates the desktop file depending on the load desktop mode flag:
     *  0:  Try the "current" directory, then the FTE .exe directory (PC) or
     *      the user's homedir (Unix). Fail if not found (original FTE
     *      algorithm).
     *  1:  Try the current directory, then loop {go one directory UP and try}
     *      If not found, don't load a desktop!
     *  2:  As above, but asks to save the desktop if one was not found.
     *  This is called if the desktop is not spec'd on the command line.
     */
    switch (LoadDesktopMode) {
    default:
        //** 0: try curdir then "homedir"..
        //         fprintf(stderr, "ld: Mode 0\n");
        if (FileExists(DESKTOP_NAME))
            ExpandPath(DESKTOP_NAME, DesktopFileName);
        else {
            //** Use homedir,
#ifdef UNIX
            ExpandPath("~/" DESKTOP_NAME, DesktopFileName);
#else
            JustDirectory(argv[0], DesktopFileName);
            strcat(DesktopFileName, DESKTOP_NAME);
#endif
        }
        return FileExists(DesktopFileName);

    case 1:
    case 2:
        //** Try curdir, then it's owner(s)..
        ExpandPath(".", DesktopFileName);
        //fprintf(stderr, "ld: Mode 1 (start at %s)\n", DesktopFileName);

        for (;;) {
            //** Try current location,
            char *pe = DesktopFileName + strlen(DesktopFileName);
            Slash(DesktopFileName, 1);      // Add appropriate slash
            strcat(DesktopFileName, DESKTOP_NAME);

            //fprintf(stderr, "ld: Mode 1 (trying %s)\n", DesktopFileName);
            if (FileExists(DesktopFileName)) {
                //fprintf(stderr, "ld: Mode 1 (using %s)\n", DesktopFileName);
                return 1;
            }

            //** Not found. Remove added stuff, then go level UP,
            *pe = 0;

            // Remove the current part,
            char *p = SepRChr(DesktopFileName);

            if (p == NULL) {
                //** No desktop! Set default name in current directory,
                ExpandPath(".", DesktopFileName);
                Slash(DesktopFileName, 1);
                strcat(DesktopFileName, DESKTOP_NAME);

                SaveDesktopOnExit = 0;      // Don't save,
                return 0;                   // NOT found!!
            }
            *p = 0;                         // Truncate name at last
        }
    }
}

void EGUI::DoLoadDesktopOnEntry(int &/*argc*/, char **argv) {
    if (DesktopFileName[0] == 0)
        findDesktop(argv);

    if (DesktopFileName[0] != 0) {
        if (IsDirectory(DesktopFileName)) {
            Slash(DesktopFileName, 1);
            strcat(DesktopFileName, DESKTOP_NAME);
        }

        if (LoadDesktopOnEntry && FileExists(DesktopFileName))
            LoadDesktop(DesktopFileName);
    }
}
#endif

void EGUI::EditorInit() {
    SSBuffer = new EBuffer(0, (EModel **)&SSBuffer, "Scrap");
    assert(SSBuffer != 0);
    BFI(SSBuffer, BFI_Undo) = 0; // disable undo for clipboard
    ActiveModel = 0;
}

int EGUI::InterfaceInit(int &argc, char **argv) {
    if (FrameNew() == 0)
        DieError(1, "Failed to create window\n");
    return 0;
}

#ifdef CONFIG_HISTORY
void EGUI::DoLoadHistoryOnEntry(int &argc, char **argv) {
    if (HistoryFileName[0] == 0) {
#ifdef UNIX
        ExpandPath("~/.fte-history", HistoryFileName);
#else
        JustDirectory(argv[0], HistoryFileName);
        strcat(HistoryFileName, "fte.his");
#endif
    } else {
        char p[256];

        ExpandPath(HistoryFileName, p);
        if (IsDirectory(p)) {
            Slash(p, 1);
            strcat(p, HISTORY_NAME);
        }
        strcpy(HistoryFileName, p);
    }

    if (KeepHistory && FileExists(HistoryFileName))
        LoadHistory(HistoryFileName);
}

void EGUI::DoSaveHistoryOnExit() {
    if (KeepHistory && HistoryFileName[0] != 0)
        SaveHistory(HistoryFileName);

    // since we are exiting, free history
    ClearHistory();
}
#endif

int EGUI::CmdLoadFiles(int &argc, char **argv) {
    int QuoteNext = 0;
    int QuoteAll = 0;
    int GotoLine = 0;
    int LineNum = 1;
    int ColNum = 1;
    int ModeOverride = 0;
    char Mode[32];
    int LCount = 0;
    int ReadOnly = 0;

    for (int Arg = 1; Arg < argc; Arg++) {
        if (!QuoteAll && !QuoteNext && (argv[Arg][0] == '-')) {
            if (argv[Arg][1] == '-') {
                QuoteAll = 1;
            } else if (argv[Arg][1] == '!') {
                // handled before
            } else if (argv[Arg][1] == 'c' || argv[Arg][1] == 'C') {
                // ^
            } else if (argv[Arg][1] == 'D' || argv[Arg][1] == 'd') {
                // ^
            } else if (argv[Arg][1] == 'H') {
                // ^
            } else if (argv[Arg][1] == '+') {
                QuoteNext = 1;
            } else if (argv[Arg][1] == '#' || argv[Arg][1] == 'l') {
                LineNum = 1;
                ColNum = 1;
                if (strchr(argv[Arg], ',')) {
                    GotoLine = (2 == sscanf(argv[Arg] + 2, "%d,%d", &LineNum, &ColNum));
                } else {
                    GotoLine = (1 == sscanf(argv[Arg] + 2, "%d", &LineNum));
                }
                //                printf("Gotoline = %d, line = %d, col = %d\n", GotoLine, LineNum, ColNum);
            } else if (argv[Arg][1] == 'r') {
                ReadOnly = 1;
            } else if (argv[Arg][1] == 'm') {
                if (argv[Arg][2] == 0) {
                    ModeOverride = 0;
                } else {
                    ModeOverride = 1;
                    strcpy(Mode, argv[Arg] + 2);
                }
            } else if (argv[Arg][1] == 'T') {
                TagsAdd(argv[Arg] + 2);
            } else if (argv[Arg][1] == 't') {
                TagGoto(ActiveView, argv[Arg] + 2);
            } else {
                DieError(2, "Invalid command line option %s", argv[Arg]);
                return 0;
            }
        } else {
            char Path[MAXPATH];

            QuoteNext = 0;
            if (ExpandPath(argv[Arg], Path) == 0 && IsDirectory(Path)) {
                EModel *m = new EDirectory(cfAppend, &ActiveModel, Path);
                assert(ActiveModel != 0 && m != 0);
            } else {
                if (LCount != 0)
                    suspendLoads = 1;
                if (MultiFileLoad(cfAppend, argv[Arg],
                                  ModeOverride ? Mode : 0,
                                  ActiveView) == 0) {
                    suspendLoads = 0;
                    return 0;
                }
                suspendLoads = 0;

                if (GotoLine) {
                    if (((EBuffer *)ActiveModel)->Loaded == 0)
                        ((EBuffer *)ActiveModel)->Load();
                    if (GotoLine) {
                        GotoLine = 0;
                        ((EBuffer *)ActiveModel)->SetNearPosR(ColNum - 1, LineNum - 1);
                    } else {
                        int r, c;

                        if (RetrieveFPos(((EBuffer *)ActiveModel)->FileName, r, c) == 1)
                            ((EBuffer *)ActiveModel)->SetNearPosR(c, r);
                    }
                    //ActiveView->SelectModel(ActiveModel);
                }
                if (ReadOnly) {
                    ReadOnly = 0;
                    BFI(((EBuffer *)ActiveModel), BFI_ReadOnly) = 1;
                }
            }
            suspendLoads = 1;
            ActiveView->SelectModel(ActiveModel->Next);
            suspendLoads = 0;
            LCount++;
        }
    }
    EModel *P = ActiveModel;
    while (LCount-- > 0)
        P = P->Prev;
    ActiveView->SelectModel(P);
    return 1;
}

int EGUI::Start(int &argc, char **argv) {
    {
        int rc;

        rc = GUI::Start(argc, argv);

        if (rc)
            return rc;
    }

    if (InterfaceInit(argc, argv) != 0)
        return 2;

    EditorInit();

#ifdef CONFIG_HISTORY
    DoLoadHistoryOnEntry(argc, argv);
#endif

#ifdef CONFIG_DESKTOP
    DoLoadDesktopOnEntry(argc, argv);
#endif

    if (CmdLoadFiles(argc, argv) == 0)
        return 3;

    if (ActiveModel == 0) {
#ifdef CONFIG_OBJ_DIRECTORY
        char Path[MAXPATH];

        GetDefaultDirectory(0, Path, sizeof(Path));
        EModel *m = new EDirectory(0, &ActiveModel, Path);
        assert(ActiveModel != 0 && m != 0);
        ActiveView->SwitchToModel(ActiveModel);
#else
        Usage();
        return 1;
#endif
    }
    return 0;
}

void EGUI::EditorCleanup() {
    if (ActiveModel) {
        EModel *B, *N, *A;

        B = A = ActiveModel;
        do {
            N = B->Next;
            delete B;
            B = N;
        } while (B != A);
    }
    ActiveModel = 0;

    delete SSBuffer;
    SSBuffer = 0;

    if (ActiveView) {
        EView *BW, *NW, *AW;

        BW = AW = ActiveView;
        do {
            NW = BW->Next;
            delete BW;
            BW = NW;
        } while (BW != AW);
    }
    ActiveView = 0;
}

void EGUI::InterfaceCleanup() {
    while (frames)
        delete frames;
}

void EGUI::Stop() {
#ifdef CONFIG_HISTORY
    DoSaveHistoryOnExit();
#endif

    // free macros
    if (Macros!=NULL)
    {
        int i;

        while (CMacros--)
        {
            free(Macros[CMacros].Name);

            for (i=0; i<Macros[CMacros].Count; i++)
            {
                if (Macros[CMacros].cmds[i].type == CT_STRING)
                {
                    free(Macros[CMacros].cmds[i].u.string);
                }
            }

            free(Macros[CMacros].cmds);
        }

        free(Macros);

        Macros = NULL;
    }

    // free colorizers
    {
        EColorize *p;

        while ((p = Colorizers) != NULL) {
            Colorizers = Colorizers->Next;
            delete p;
        }
    }

    // free event maps
    {
        EEventMap *em;
                  
        while ((em = EventMaps) != NULL) {
            EventMaps = EventMaps->Next;
            delete em;
        }
    }

    // free modes
    {
        EMode *m;
                  
        while ((m = Modes) != NULL) {
            Modes = Modes->fNext;
            delete m;
        }
    }

    // free menus
    if (Menus)
    {
        int mc, c;

        while(MenuCount--)
        {
            mc = MenuCount;

            free(Menus[mc].Name);

            while(Menus[mc].Count--)
            {
                c = Menus[mc].Count;
                free(Menus[mc].Items[c].Name);
            }

            free(Menus[MenuCount].Items);
        }

        free(Menus);

        Menus = NULL;
    }

    // free completion rexexp filter
    {
        extern RxNode *CompletionFilter;

        RxFree(CompletionFilter);
    }

    // free CRegexp array from o_messages.cpp
    {
        FreeCRegexp();
    }

    // free configuration file path
    {
        free(ConfigSourcePath);
        ConfigSourcePath = NULL;
    }

    EditorCleanup();

    InterfaceCleanup();

    GUI::Stop();
}