____                _       __
    / __ )____  _____   | |     / /___ ___________
   / __  / __ \/ ___/   | | /| / / __ `/ ___/ ___/
  / /_/ / /_/ (__  )    | |/ |/ / /_/ / /  (__  )
 /_____/\____/____/     |__/|__/\__,_/_/  /____/

       A futuristic real-time strategy game.
          This file is part of Bos Wars.

(C) Copyright 2001-2007 by the Bos Wars and Stratagus Project. Distributed under the "GNU General Public License"

---

ui.cpp

Go to the documentation of this file.

//     ____                _       __               
//    / __ )____  _____   | |     / /___ ___________
//   / __  / __ \/ ___/   | | /| / / __ `/ ___/ ___/
//  / /_/ / /_/ (__  )    | |/ |/ / /_/ / /  (__  ) 
// /_____/\____/____/     |__/|__/\__,_/_/  /____/  
//                                              
//       A futuristic real-time strategy game.
//          This file is part of Bos Wars.
//
//
//      (c) Copyright 1999-2008 by Lutz Sammer, Andreas Arens, and
//                                 Jimmy Salmon
//
//      This program is free software; you can redistribute it and/or modify
//      it under the terms of the GNU General Public License as published by
//      the Free Software Foundation; only version 2 of the License.
//
//      This program is distributed in the hope that it will be useful,
//      but WITHOUT ANY WARRANTY; without even the implied warranty of
//      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//      GNU General Public License for more details.
//
//      You should have received a copy of the GNU General Public License
//      along with this program; if not, write to the Free Software
//      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
//      02111-1307, USA.
//


/*----------------------------------------------------------------------------
--  Includes
----------------------------------------------------------------------------*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "stratagus.h"
#include "video.h"
#include "font.h"
#include "interface.h"
#include "map.h"
#include "ui.h"
#include "menus.h"
#include "iolib.h"
#include "unit.h"
#include "title.h"

/*----------------------------------------------------------------------------
-- Variables
----------------------------------------------------------------------------*/

bool RightButtonAttacks;                   


CUserInterface UI;

/*----------------------------------------------------------------------------
-- Functions
----------------------------------------------------------------------------*/

CUserInterface::CUserInterface() :
    MouseScroll(false), KeyScroll(false),
    MouseScrollSpeedDefault(0), MouseScrollSpeedControl(0),
    MouseWarpX(0), MouseWarpY(0),
    SingleSelectedButton(NULL),
    MaxSelectedFont(NULL), MaxSelectedTextX(0), MaxSelectedTextY(0),
    SingleTrainingButton(NULL),
    SingleTrainingFont(NULL), SingleTrainingTextX(0), SingleTrainingTextY(0),
    TrainingFont(NULL), TrainingTextX(0), TrainingTextY(0),
    CompletedBarColor(0), CompletedBarShadow(0),
    ViewportMode(VIEWPORT_SINGLE), MouseViewport(NULL),
    SelectedViewport(NULL), NumViewports(0),
    MessageFont(NULL), MessageScrollSpeed(5),
    ViewportCursorColor(0), Offset640X(0), Offset480Y(0),
    VictoryBackgroundG(NULL), DefeatBackgroundG(NULL)
{
    memset(&CompletedBarColorRGB, 0, sizeof(CompletedBarColorRGB));

    Point.Name = "cursor-point";
    Glass.Name = "cursor-glass";
    Cross.Name = "cursor-cross";
    YellowHair.Name = "cursor-yellow-hair";
    GreenHair.Name = "cursor-green-hair";
    RedHair.Name = "cursor-red-hair";
    Scroll.Name = "cursor-scroll";

    ArrowE.Name = "cursor-arrow-e";
    ArrowNE.Name = "cursor-arrow-ne";
    ArrowN.Name = "cursor-arrow-n";
    ArrowNW.Name = "cursor-arrow-nw";
    ArrowW.Name = "cursor-arrow-w";
    ArrowSW.Name = "cursor-arrow-sw";
    ArrowS.Name = "cursor-arrow-s";
    ArrowSE.Name = "cursor-arrow-se";

    NormalFontColor = "light-blue";
    ReverseFontColor = "yellow";
}


void InitUserInterface(void)
{
    UI.Offset640X = (Video.Width - 640) / 2;
    UI.Offset480Y = (Video.Height - 480) / 2;

    //
    // Calculations
    //
    if (Map.Info.MapWidth) {
        if (UI.MapArea.EndX > Map.Info.MapWidth * TileSizeX - 1) {
            UI.MapArea.EndX = Map.Info.MapWidth * TileSizeX - 1;
        }
        if (UI.MapArea.EndY > Map.Info.MapHeight * TileSizeY - 1) {
            UI.MapArea.EndY = Map.Info.MapHeight * TileSizeY - 1;
        }
    }

    UI.SelectedViewport = UI.Viewports;

    SetViewportMode(VIEWPORT_SINGLE);

    UI.CompletedBarColor = Video.MapRGB(TheScreen->format,
        UI.CompletedBarColorRGB.r,
        UI.CompletedBarColorRGB.g,
        UI.CompletedBarColorRGB.b);
    UI.ViewportCursorColor = ColorWhite;
}

void CursorConfig::Load()
{
    Assert(!Name.empty());
    Cursor = CursorByIdent(Name);
    Assert(Name == Cursor->Ident);
}

void CUserInterface::Load(void)
{
    int i;

    //
    //  Load graphics
    //
    for (i = 0; i < (int)Fillers.size(); ++i) {
        Fillers[i].G->Load();
        Fillers[i].G->UseDisplayFormat();
    }

    for (i = 0; i < MaxCosts; ++i) {
        if (Resources[i].G) {
            Resources[i].G->Load();
            Resources[i].G->UseDisplayFormat();
        }
    }

    if (ButtonPanel.G) {
        ButtonPanel.G->Load();
        ButtonPanel.G->UseDisplayFormat();
    }
    if (PieMenu.G) {
        PieMenu.G->Load();
        PieMenu.G->UseDisplayFormat();
    }

    //
    //  Resolve cursors
    //
    Point.Load();
    Glass.Load();
    Cross.Load();
    YellowHair.Load();
    GreenHair.Load();
    RedHair.Load();
    Scroll.Load();

    ArrowE.Load();
    ArrowNE.Load();
    ArrowN.Load();
    ArrowNW.Load();
    ArrowW.Load();
    ArrowSW.Load();
    ArrowS.Load();
    ArrowSE.Load();
}

static void SaveViewports(CFile *file, const CUserInterface *ui)
{
    int i;
    const CViewport *vp;

    file->printf("DefineViewports(\"mode\", %d", ui->ViewportMode);
    for (i = 0; i < ui->NumViewports; ++i) {
        vp = &ui->Viewports[i];
        file->printf(",\n  \"viewport\", {%d, %d, %d}", vp->MapX, vp->MapY, 
            vp->Unit ? UnitNumber(vp->Unit) : -1);
    }
    file->printf(")\n\n");
}

void SaveUserInterface(CFile *file)
{
    SaveViewports(file, &UI);
}

CUserInterface::~CUserInterface()
{
}

void CleanUserInterface(void)
{
    int i;

    // Filler
    for (i = 0; i < (int)UI.Fillers.size(); ++i) {
        CGraphic::Free(UI.Fillers[i].G);
    }
    UI.Fillers.clear();

    // Resource Icons
    for (i = 0; i < MaxCosts; ++i) {
        CGraphic::Free(UI.Resources[i].G);
    }

    delete UI.SingleSelectedButton;
    UI.SelectedButtons.clear();
    delete UI.SingleTrainingButton;
    UI.SingleTrainingText.clear();
    UI.TrainingButtons.clear();
    UI.TrainingText.clear();
    UI.TransportingButtons.clear();

    // Button Panel
    CGraphic::Free(UI.ButtonPanel.G);

    // Pie Menu
    CGraphic::Free(UI.PieMenu.G);

    // Backgrounds
    CGraphic::Free(UI.VictoryBackgroundG);
    CGraphic::Free(UI.DefeatBackgroundG);

    // Title Screens
    if (TitleScreens) {
        for (i = 0; TitleScreens[i]; ++i) {
            delete TitleScreens[i];
        }
        delete[] TitleScreens;
        TitleScreens = NULL;
    }
}

#ifdef DEBUG
void FreeButtonStyles()
{
    std::map<std::string, ButtonStyle *>::iterator i;
    for (i = ButtonStyleHash.begin(); i != ButtonStyleHash.end(); ++i) {
        delete (*i).second;
    }
    ButtonStyleHash.clear();
}
#endif

CViewport *GetViewport(int x, int y)
{
    CViewport *vp;

    for (vp = UI.Viewports; vp < UI.Viewports + UI.NumViewports; ++vp) {
        if (x >= vp->X && x <= vp->EndX && y >= vp->Y && y <= vp->EndY) {
            return vp;
        }
    }
    return NULL;
}

static void FinishViewportModeConfiguration(CViewport new_vps[], int num_vps)
{
    int i;

    if (UI.NumViewports < num_vps) {
        //  Compute location of the viewport using oldviewport
        for (i = 0; i < num_vps; ++i) {
            const CViewport *vp;

            new_vps[i].MapX = 0;
            new_vps[i].MapY = 0;
            vp = GetViewport(new_vps[i].X, new_vps[i].Y);
            if (vp) {
                new_vps[i].OffsetX = new_vps[i].X - vp->X + vp->MapX * TileSizeX + vp->OffsetX;
                new_vps[i].OffsetY = new_vps[i].Y - vp->Y + vp->MapY * TileSizeY + vp->OffsetY;
            } else {
                new_vps[i].OffsetX = 0;
                new_vps[i].OffsetY = 0;
            }
        }
    } else {
        for (i = 0; i < num_vps; ++i) {
            new_vps[i].MapX = UI.Viewports[i].MapX;
            new_vps[i].MapY = UI.Viewports[i].MapY;
            new_vps[i].OffsetX = UI.Viewports[i].OffsetX;
            new_vps[i].OffsetY = UI.Viewports[i].OffsetY;
        }
    }

    // Affect the old viewport.
    for (i = 0; i < num_vps; ++i) {
        CViewport *vp;

        vp = UI.Viewports + i;
        vp->X = new_vps[i].X;
        vp->EndX = new_vps[i].EndX;
        vp->Y = new_vps[i].Y;
        vp->EndY = new_vps[i].EndY;
        vp->Set(new_vps[i].MapX, new_vps[i].MapY, new_vps[i].OffsetX, new_vps[i].OffsetY);
    }
    UI.NumViewports = num_vps;

    //
    //  Update the viewport pointers
    //
    UI.MouseViewport = GetViewport(CursorX, CursorY);
    if (UI.SelectedViewport > UI.Viewports + UI.NumViewports - 1) {
        UI.SelectedViewport = UI.Viewports + UI.NumViewports - 1;
    }
}

static void ClipViewport(CViewport *vp, int ClipX, int ClipY)
{
    // begin with maximum possible viewport size
    vp->EndX = vp->X + Map.Info.MapWidth * TileSizeX - 1;
    vp->EndY = vp->Y + Map.Info.MapHeight * TileSizeY - 1;

    // first clip it to MapArea size if necessary
    if (vp->EndX > ClipX) {
        vp->EndX = ClipX;
    }

    // the same for y
    if (vp->EndY > ClipY) {
        vp->EndY = ClipY;
    }

    Assert(vp->EndX <= UI.MapArea.EndX);
    Assert(vp->EndY <= UI.MapArea.EndY);
}

static void SetViewportModeSingle(void)
{
    CViewport new_vps[MAX_NUM_VIEWPORTS];

    DebugPrint("Single viewport set\n");

    new_vps[0].X = UI.MapArea.X;
    new_vps[0].Y = UI.MapArea.Y;
    ClipViewport(new_vps, UI.MapArea.EndX, UI.MapArea.EndY);

    FinishViewportModeConfiguration(new_vps, 1);
}

static void SetViewportModeSplitHoriz(void)
{
    CViewport new_vps[MAX_NUM_VIEWPORTS];

    DebugPrint("Two horizontal viewports set\n");

    new_vps[0].X = UI.MapArea.X;
    new_vps[0].Y = UI.MapArea.Y;
    ClipViewport(new_vps, UI.MapArea.EndX,
        UI.MapArea.Y + (UI.MapArea.EndY - UI.MapArea.Y + 1) / 2);

    new_vps[1].X = UI.MapArea.X;
    new_vps[1].Y = new_vps[0].EndY + 1;
    ClipViewport(new_vps + 1, UI.MapArea.EndX, UI.MapArea.EndY);

    FinishViewportModeConfiguration(new_vps, 2);
}

static void SetViewportModeSplitHoriz3(void)
{
    CViewport new_vps[MAX_NUM_VIEWPORTS];

    DebugPrint("Horizontal 3-way viewport division set\n");

    new_vps[0].X = UI.MapArea.X;
    new_vps[0].Y = UI.MapArea.Y;
    ClipViewport(new_vps, UI.MapArea.EndX,
        UI.MapArea.Y + (UI.MapArea.EndY - UI.MapArea.Y + 1) / 2);

    new_vps[1].X = UI.MapArea.X;
    new_vps[1].Y = new_vps[0].EndY + 1;
    ClipViewport(new_vps + 1,
        UI.MapArea.X + (UI.MapArea.EndX - UI.MapArea.X + 1) / 2,
        UI.MapArea.EndY);

    new_vps[2].X = new_vps[1].EndX + 1;
    new_vps[2].Y = new_vps[0].EndY + 1;
    ClipViewport(new_vps + 2, UI.MapArea.EndX, UI.MapArea.EndY);

    FinishViewportModeConfiguration(new_vps, 3);
}

static void SetViewportModeSplitVert(void)
{
    CViewport new_vps[MAX_NUM_VIEWPORTS];

    DebugPrint("Two vertical viewports set\n");

    new_vps[0].X = UI.MapArea.X;
    new_vps[0].Y = UI.MapArea.Y;
    ClipViewport(new_vps,
        UI.MapArea.X + (UI.MapArea.EndX - UI.MapArea.X + 1) / 2,
        UI.MapArea.EndY);

    new_vps[1].X = new_vps[0].EndX + 1;
    new_vps[1].Y = UI.MapArea.Y;
    ClipViewport(new_vps + 1, UI.MapArea.EndX, UI.MapArea.EndY);

    FinishViewportModeConfiguration(new_vps, 2);
}

static void SetViewportModeQuad(void)
{
    CViewport new_vps[MAX_NUM_VIEWPORTS];

    DebugPrint("Four viewports set\n");

    new_vps[0].X = UI.MapArea.X;
    new_vps[0].Y = UI.MapArea.Y;
    ClipViewport(new_vps,
        UI.MapArea.X + (UI.MapArea.EndX - UI.MapArea.X + 1) / 2,
        UI.MapArea.Y + (UI.MapArea.EndY - UI.MapArea.Y + 1) / 2);

    new_vps[1].X = new_vps[0].EndX + 1;
    new_vps[1].Y = UI.MapArea.Y;
    ClipViewport(new_vps + 1,
        UI.MapArea.EndX,
        UI.MapArea.Y + (UI.MapArea.EndY - UI.MapArea.Y + 1) / 2);

    new_vps[2].X = UI.MapArea.X;
    new_vps[2].Y = new_vps[0].EndY + 1;
    ClipViewport(new_vps + 2,
        UI.MapArea.X + (UI.MapArea.EndX - UI.MapArea.X + 1) / 2,
        UI.MapArea.EndY);

    new_vps[3].X = new_vps[1].X;
    new_vps[3].Y = new_vps[2].Y;
    ClipViewport(new_vps + 3, UI.MapArea.EndX, UI.MapArea.EndY);

    FinishViewportModeConfiguration(new_vps, 4);
}

void SetViewportMode(ViewportModeType new_mode)
{
    switch (UI.ViewportMode = new_mode) {
        case VIEWPORT_SINGLE:
            SetViewportModeSingle();
            break;
        case VIEWPORT_SPLIT_HORIZ:
            SetViewportModeSplitHoriz();
            break;
        case VIEWPORT_SPLIT_HORIZ3:
            SetViewportModeSplitHoriz3();
            break;
        case VIEWPORT_SPLIT_VERT:
            SetViewportModeSplitVert();
            break;
        case VIEWPORT_QUAD:
            SetViewportModeQuad();
            break;
        default:
            DebugPrint("trying to set an unknown mode!!\n");
            break;
    }
}

void CycleViewportMode(int step)
{
    int new_mode;

    new_mode = UI.ViewportMode + step;
    if (new_mode >= NUM_VIEWPORT_MODES) {
        new_mode = 0;
    }
    if (new_mode < 0) {
        new_mode = NUM_VIEWPORT_MODES - 1;
    }
    SetViewportMode((ViewportModeType)new_mode);
}

bool GetMouseScroll(void)
{
    return UI.MouseScroll;
}

void SetMouseScroll(bool enabled)
{
    UI.MouseScroll = enabled;
}

bool GetKeyScroll()
{
    return UI.KeyScroll;
}

void SetKeyScroll(bool enabled)
{
    UI.KeyScroll = enabled;
}

bool GetGrabMouse(void)
{
    return SdlGetGrabMouse();
}

void SetGrabMouse(bool enabled)
{
    ToggleGrabMouse(enabled ? 1 : -1);
}

bool GetLeaveStops(void)
{
    return LeaveStops;
}

void SetLeaveStops(bool enabled)
{
    LeaveStops = enabled;
}

---