widgets.cpp

#include "widgets.h"
#include "main.h"
#include "utils.h"
#include "sound.h"


//////////////////////////////////////////////////////////////////
//
// Button
//
//////////////////////////////////////////////////////////////////


Button::Button(int x, int y, const std::wstring &name, Command *cmd, 
        bool transparent)
{
    image = loadImage(name, transparent);
    highlighted = adjustBrightness(image, 1.5, transparent);

    left = x;
    top = y;
    width = image->w;
    height = image->h;

    mouseInside = false;
    command = cmd;
}


Button::Button(int x, int y, int w, int h, Font *font, 
        int fR, int fG, int fB, int hR, int hG, int hB,
        const std::wstring &text, Command *cmd)
{
    left = x;
    top = y;
    width = w;
    height = h;

    SDL_Surface *s = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h,
            24, 0x00FF0000, 0x0000FF00, 0x000000FF, 0/*0xFF000000*/);
    SDL_Rect src = { x, y, width, height };
    SDL_Rect dst = { 0, 0, width, height };
    SDL_BlitSurface(screen.getSurface(), &src, s, &dst);
    
    int tW, tH;
    font->getSize(text, tW, tH);
    font->draw(s, (width - tW) / 2, (height - tH) / 2, fR, fG, fB, true, text);
    image = SDL_DisplayFormat(s);
    SDL_BlitSurface(screen.getSurface(), &src, s, &dst);
    font->draw(s, (width - tW) / 2, (height - tH) / 2, hR, hG, hB, true, text);
    highlighted = SDL_DisplayFormat(s);
    SDL_FreeSurface(s);
    
    mouseInside = false;
    command = cmd;
}


Button::Button(int x, int y, int w, int h, Font *font, 
        int r, int g, int b, const std::wstring &bg, 
        const std::wstring &text, bool bevel, Command *cmd)
{
    left = x;
    top = y;
    width = w;
    height = h;

    SDL_Surface *s = screen.getSurface();
    image = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 
            s->format->BitsPerPixel, s->format->Rmask, s->format->Gmask,
            s->format->Bmask, s->format->Amask);

    SDL_Surface *tile = loadImage(bg, true);
    SDL_Rect src = { 0, 0, tile->w, tile->h };
    SDL_Rect dst = { 0, 0, tile->w, tile->h };
    for (int j = 0; j < height; j += tile->h)
        for (int i = 0; i < width; i += tile->w) {
            dst.x = i;
            dst.y = j;
            SDL_BlitSurface(tile, &src, image, &dst);
        }
    SDL_FreeSurface(tile);

    if (bevel) {
        SDL_LockSurface(image);
        drawBevel(image, 0, 0, width, height, false, 1);
        drawBevel(image, 1, 1, width - 2, height - 2, true, 1);
        SDL_UnlockSurface(image);
    }
    
    int tW, tH;
    font->getSize(text, tW, tH);
    font->draw(image, (width - tW) / 2, (height - tH) / 2, r, g, b, true, text);
    
    highlighted = adjustBrightness(image, 1.5, false);
    SDL_SetColorKey(image, SDL_SRCCOLORKEY, getCornerPixel(image));
    SDL_SetColorKey(highlighted, SDL_SRCCOLORKEY, getCornerPixel(highlighted));
    
    mouseInside = false;
    command = cmd;
}



Button::Button(int x, int y, int w, int h, Font *font, 
        int r, int g, int b, const std::wstring &bg, 
        const std::wstring &text, Command *cmd)
{
    left = x;
    top = y;
    width = w;
    height = h;

    SDL_Surface *s = screen.getSurface();
    image = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 
            s->format->BitsPerPixel, s->format->Rmask, s->format->Gmask,
            s->format->Bmask, s->format->Amask);

    SDL_Surface *tile = loadImage(bg);
    SDL_Rect src = { 0, 0, tile->w, tile->h };
    SDL_Rect dst = { 0, 0, tile->w, tile->h };
    for (int j = 0; j < height; j += tile->h)
        for (int i = 0; i < width; i += tile->w) {
            dst.x = i;
            dst.y = j;
            SDL_BlitSurface(tile, &src, image, &dst);
        }
    SDL_FreeSurface(tile);

    SDL_LockSurface(image);
    drawBevel(image, 0, 0, width, height, false, 1);
    drawBevel(image, 1, 1, width - 2, height - 2, true, 1);
    SDL_UnlockSurface(image);
    
    int tW, tH;
    font->getSize(text, tW, tH);
    font->draw(image, (width - tW) / 2, (height - tH) / 2, r, g, b, true, text);
    
    highlighted = adjustBrightness(image, 1.5, false);
    
    mouseInside = false;
    command = cmd;
}


Button::~Button()
{
    SDL_FreeSurface(image);
    SDL_FreeSurface(highlighted);
}


void Button::draw()
{
    if (mouseInside)
        screen.draw(left, top, highlighted);
    else
        screen.draw(left, top, image);
    screen.addRegionToUpdate(left, top, width, height);
}


void Button::getBounds(int &l, int &t, int &w, int &h)
{
    l = left;
    t = top;
    w = width;
    h = height;
}


bool Button::onMouseButtonDown(int button, int x, int y)
{
    if (isInRect(x, y, left, top, width, height)) {
        sound->play(L"click.wav");
        if (command)
            command->doAction();
        return true;
    } else
        return false;
}


bool Button::onMouseMove(int x, int y)
{
    bool in = isInRect(x, y, left, top, width, height);
    if (in != mouseInside) {
        mouseInside = in;
        draw();
    }
    return false;
}


//////////////////////////////////////////////////////////////////
//
// KeyAccel
//
//////////////////////////////////////////////////////////////////


KeyAccel::KeyAccel(SDLKey sym, Command *cmd)
{
    command = cmd;
    key = sym;
}


bool KeyAccel::onKeyDown(SDLKey k, unsigned char ch)
{
    if (key == k) {
        if (command)
            command->doAction();
        return true;
    } else
        return false;
}


//////////////////////////////////////////////////////////////////
//
// Area
//
//////////////////////////////////////////////////////////////////


Area::Area()
{
    timer = NULL;
}

Area::~Area()
{
    for (auto w : widgets)
        if (w && w->destroyByArea() && (! notManagedWidgets.count(w)))
            delete w;
}

void Area::add(Widget *widget, bool managed)
{
    widgets.push_back(widget);
    if (! managed)
        notManagedWidgets.insert(widget);
    widget->setParent(this);
}

void Area::remove(Widget *widget)
{
    widgets.remove(widget);
    notManagedWidgets.insert(widget);
}

void Area::handleEvent(const SDL_Event &event)
{
    switch (event.type) {
        case SDL_MOUSEBUTTONDOWN:
            for (auto w : widgets)
                if (w->onMouseButtonDown(event.button.button, 
                            event.button.x, event.button.y))
                    return;
            break;
        
        case SDL_MOUSEBUTTONUP:
            for (auto w : widgets)
                if (w->onMouseButtonUp(event.button.button, 
                            event.button.x, event.button.y))
                    return;
            break;
        
        case SDL_MOUSEMOTION:
            for (auto w : widgets)
                if (w->onMouseMove(event.motion.x, event.motion.y))
                    return;
            break;
        
        case SDL_VIDEOEXPOSE:
            for (auto w : widgets)
                w->draw();
            break;
        
        case SDL_KEYDOWN:
            for (auto w : widgets)
                if (w->onKeyDown(event.key.keysym.sym, 
                            (unsigned char)event.key.keysym.unicode))
                    return;
            break;
        
        case SDL_QUIT:
            exit(0);
    }
}

void Area::run()
{
    terminate = false;
    SDL_Event event;
    
    Uint32 lastTimer = 0;
    draw();
    screen.showMouse();
    
    bool runTimer = timer ? true : false;
    bool dispetchEvent;
    while (! terminate) {
        dispetchEvent = true;
        if (! timer) {
            SDL_WaitEvent(&event);
        } else {
            Uint32 now = SDL_GetTicks();
            if (now - lastTimer > time) {
                lastTimer = now;
                runTimer = true;
            }
            if (! SDL_PollEvent(&event)) {
                if (! runTimer) {
                    SDL_Delay(20);
                    continue;
                } else
                    dispetchEvent = false;
            }
        }
        screen.hideMouse();
        if (runTimer) {
            if (timer)
                timer->onTimer();
            runTimer = false;
        }
        if (dispetchEvent)
            handleEvent(event);
        if (! terminate) {
            screen.showMouse();
            screen.flush();
        }
    }
}

void Area::finishEventLoop()
{
    terminate = true;
}


void Area::draw()
{
    for (auto w : widgets)
        w->draw();
}


void Area::setTimer(Uint32 interval, TimerHandler *t)
{
    time = interval;
    timer = t;
}


void Area::updateMouse()
{
    int x, y;
    SDL_GetMouseState(&x, &y);
    
    for (auto w : widgets)
        if (w->onMouseMove(x, y))
                    return;
}



//////////////////////////////////////////////////////////////////
//
// AnyKeyAccel
//
//////////////////////////////////////////////////////////////////



AnyKeyAccel::AnyKeyAccel()
{
    command = NULL;
}

AnyKeyAccel::AnyKeyAccel(Command *cmd)
{
    command = cmd;
}

AnyKeyAccel::~AnyKeyAccel()
{
}

bool AnyKeyAccel::onKeyDown(SDLKey key, unsigned char ch)
{
    if (((key >= SDLK_NUMLOCK) && (key <= SDLK_COMPOSE)) || 
            (key == SDLK_TAB) || (key == SDLK_UNKNOWN))
        return false;

    if (command)
        command->doAction();
    else
        area->finishEventLoop();
    return true;
}

bool AnyKeyAccel::onMouseButtonDown(int button, int x, int y)
{
    if (command)
        command->doAction();
    else
        area->finishEventLoop();
    return true;
}



//////////////////////////////////////////////////////////////////
//
// Window
//
//////////////////////////////////////////////////////////////////



Window::Window(int x, int y, int w, int h, const std::wstring &bg, 
                bool frameWidth, bool raised)
{
    left = x;
    top = y;
    width = w;
    height = h;
    
    SDL_Surface *s = screen.getSurface();
    SDL_Surface *win = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 
            s->format->BitsPerPixel, s->format->Rmask, s->format->Gmask,
            s->format->Bmask, s->format->Amask);

    SDL_Surface *tile = loadImage(bg);
    SDL_Rect src = { 0, 0, tile->w, tile->h };
    SDL_Rect dst = { 0, 0, tile->w, tile->h };
    for (int j = 0; j < height; j += tile->h)
        for (int i = 0; i < width; i += tile->w) {
            dst.x = i;
            dst.y = j;
            SDL_BlitSurface(tile, &src, win, &dst);
        }
    SDL_FreeSurface(tile);

    SDL_LockSurface(win);
    double k = 2.6;
    double f = 0.1;
    for (int i = 0; i < frameWidth; i++) {
        double ltK, rbK;
        if (raised) {
            ltK = k;  rbK = f;
        } else {
            ltK = f;  rbK = k;
        }
        for (int j = i; j < height - i - 1; j++)
            adjustBrightness(win, i, j, ltK);
        for (int j = i; j < width - i; j++)
            adjustBrightness(win, j, i, ltK);
        for (int j = i+1; j < height - i; j++)
            adjustBrightness(win, width - i - 1, j, rbK);
        for (int j = i; j < width - i - 1; j++)
            adjustBrightness(win, j, height - i - 1, rbK);
        k -= 0.2;
        f += 0.1;
    }
    SDL_UnlockSurface(win);
    
    background = SDL_DisplayFormat(win);
    SDL_FreeSurface(win);
}


Window::~Window()
{
    SDL_FreeSurface(background);
}


void Window::draw()
{
    screen.draw(left, top, background);
    screen.addRegionToUpdate(left, top, width, height);
}



//////////////////////////////////////////////////////////////////
//
// Label
//
//////////////////////////////////////////////////////////////////



Label::Label(Font *f, int x, int y, int r, int g, int b, std::wstring s,
        bool sh): text(s)
{
    font = f;
    left = x;
    top = y;
    red = r;
    green = g;
    blue = b;
    hAlign = ALIGN_LEFT;
    vAlign = ALIGN_TOP;
    shadow = sh;
}


Label::Label(Font *f, int x, int y, int w, int h, HorAlign hA, VerAlign vA, 
        int r, int g, int b, const std::wstring &s): 
                text(s)
{
    font = f;
    left = x;
    top = y;
    red = r;
    green = g;
    blue = b;
    hAlign = hA;
    vAlign = vA;
    width = w;
    height = h;
    shadow = true;
}


void Label::draw()
{
    int w, h, x, y;
    font->getSize(text, w, h);

    switch (hAlign) {
        case ALIGN_RIGHT: x = left + width - w; break;
        case ALIGN_CENTER: x = left + (width - w) / 2; break;
        default: x = left;
    }
    
    switch (vAlign) {
        case ALIGN_BOTTOM: y = top + height - h; break;
        case ALIGN_MIDDLE: y = top + (height - h) / 2; break;
        default: y = top;
    }
    
    font->draw(x, y, red,green,blue, shadow, text);
    screen.addRegionToUpdate(x, y, w, h);
}



//////////////////////////////////////////////////////////////////
//
// InputField
//
//////////////////////////////////////////////////////////////////


InputField::InputField(int x, int y, int w, int h, const std::wstring &background, 
        std::wstring &s, int maxLen, int r, int g, int b, Font *f): 
                Window(x, y, w, h, background, 1, false), text(s)
{
    maxLength = maxLen;
    red = r;
    green = g;
    blue = b;
    font = f;
    moveCursor(text.length());
    SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
    SDL_EnableUNICODE(1);
}

InputField::~InputField()
{
    SDL_EnableKeyRepeat(0, 0);
}

void InputField::draw()
{
    Window::draw();

    SDL_Rect rect = { left+1, top+1, width-2, height-2 };
    SDL_SetClipRect(screen.getSurface(), &rect);
    
    font->draw(left+1, top+1, red,green,blue, true, text);

    if (cursorVisible) {
        int pos = 0;
        if (cursorPos > 0)
            pos += font->getWidth(text.substr(0, cursorPos));
        for (int i = 2; i < height-2; i++) {
            screen.setPixel(left + pos, top + i, red, green, blue);
            screen.setPixel(left + pos + 1, top + i, red, green, blue);
        }
    }
    
    SDL_SetClipRect(screen.getSurface(), NULL);
}

void InputField::setParent(Area *a)
{
    Window::setParent(a);
    area->setTimer(100, this);
}


void InputField::onTimer()
{
    Uint32 now = SDL_GetTicks();
    if (now - lastCursor > 1000) {
        cursorVisible = ! cursorVisible;
        lastCursor = now;
        draw();
    }
}


bool InputField::onKeyDown(SDLKey key, unsigned char translatedChar)
{
    switch (key) {
        case SDLK_BACKSPACE:
            if (cursorPos > 0) {
                text.erase(cursorPos - 1, 1);
                moveCursor(cursorPos - 1);
            } else
                moveCursor(cursorPos);
            draw();
            return true;

        case SDLK_LEFT:
            if (cursorPos > 0)
                moveCursor(cursorPos - 1);
            else
                moveCursor(cursorPos);
            draw();
            return true;

        case SDLK_RIGHT:
            if (cursorPos < (int)text.length())
                moveCursor(cursorPos + 1);
            else
                moveCursor(cursorPos);
            draw();
            return true;

        case SDLK_HOME:
            moveCursor(0);
            draw();
            return true;

        case SDLK_END:
            moveCursor(text.length());
            draw();
            return true;

        case SDLK_DELETE:
            if (cursorPos < (int)text.length())
                text.erase(cursorPos, 1);
            moveCursor(cursorPos);
            draw();
            return true;

        default: ;
    }
    
    if (translatedChar > 31)
        onCharTyped(translatedChar);
    return false;
}

bool InputField::onKeyUp(SDLKey key)
{
    return false;
}

void InputField::onCharTyped(unsigned char ch)
{
    if ((int)text.length() < maxLength) {
        wchar_t buf[2];
        buf[0] = ch;
        buf[1] = 0;
        text.insert(cursorPos, buf);
        moveCursor(cursorPos + 1);
    } else
        moveCursor(cursorPos);
    draw();
}
        
void InputField::moveCursor(int pos)
{
    lastCursor = SDL_GetTicks();
    cursorVisible = true;
    cursorPos = pos;
}


//////////////////////////////////////////////////////////////////
//
// Checkbox
//
//////////////////////////////////////////////////////////////////



Checkbox::Checkbox(int x, int y, int w, int h, Font *font, 
        int r, int g, int b, const std::wstring &bg, 
        bool &chk): checked(chk)
{
    left = x;
    top = y;
    width = w;
    height = h;
    checked = chk;

    SDL_Surface *s = screen.getSurface();
    image = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 
            s->format->BitsPerPixel, s->format->Rmask, s->format->Gmask,
            s->format->Bmask, s->format->Amask);

    SDL_Surface *tile = loadImage(bg);
    SDL_Rect src = { 0, 0, tile->w, tile->h };
    SDL_Rect dst = { 0, 0, tile->w, tile->h };
    for (int j = 0; j < height; j += tile->h)
        for (int i = 0; i < width; i += tile->w) {
            dst.x = i;
            dst.y = j;
            SDL_BlitSurface(tile, &src, image, &dst);
        }
    SDL_FreeSurface(tile);

    SDL_LockSurface(image);
    drawBevel(image, 0, 0, width, height, false, 1);
    drawBevel(image, 1, 1, width - 2, height - 2, true, 1);
    SDL_UnlockSurface(image);
    
    highlighted = adjustBrightness(image, 1.5, false);
    
    checkedImage = SDL_DisplayFormat(image);
    int tW, tH;
    font->getSize(L"X", tW, tH);
    tH += 2;
    tW += 2;
    font->draw(checkedImage, (width - tW) / 2, (height - tH) / 2, r, g, b, 
            true, L"X");
    checkedHighlighted = adjustBrightness(checkedImage, 1.5, false);
    
    mouseInside = false;
}


Checkbox::~Checkbox()
{
    SDL_FreeSurface(image);
    SDL_FreeSurface(highlighted);
    SDL_FreeSurface(checkedImage);
    SDL_FreeSurface(checkedHighlighted);
}


void Checkbox::draw()
{
    if (checked) {
        if (mouseInside)
            screen.draw(left, top, checkedHighlighted);
        else
            screen.draw(left, top, checkedImage);
    } else {
        if (mouseInside)
            screen.draw(left, top, highlighted);
        else
            screen.draw(left, top, image);
    }
    screen.addRegionToUpdate(left, top, width, height);
}


void Checkbox::getBounds(int &l, int &t, int &w, int &h)
{
    l = left;
    t = top;
    w = width;
    h = height;
}


bool Checkbox::onMouseButtonDown(int button, int x, int y)
{
    if (isInRect(x, y, left, top, width, height)) {
        sound->play(L"click.wav");
        checked = ! checked;
        draw();
        return true;
    } else
        return false;
}


bool Checkbox::onMouseMove(int x, int y)
{
    bool in = isInRect(x, y, left, top, width, height);
    if (in != mouseInside) {
        mouseInside = in;
        draw();
    }
    return false;
}


//////////////////////////////////////////////////////////////////////////////
//
// Picture
//
//////////////////////////////////////////////////////////////////////////////

Picture::Picture(int x, int y, const std::wstring &name, bool transparent)
{
    image = loadImage(name, transparent);
    left = x;
    top = y;
    width = image->w;
    height = image->h;
    managed = true;
}

Picture::Picture(int x, int y, SDL_Surface *img)
{
    image = img;
    left = x;
    top = y;
    width = image->w;
    height = image->h;
    managed = false;
}

Picture::~Picture() 
{ 
    if (managed)
        SDL_FreeSurface(image); 
}

void Picture::draw()
{
    screen.draw(left, top, image);
    screen.addRegionToUpdate(left, top, width, height);
}

void Picture::moveX(const int newX) 
{ 
    left = newX; 
}

void Picture::getBounds(int &l, int &t, int &w, int &h)
{
    l = left;
    t = top;
    w = width;
    h = height;
}


//////////////////////////////////////////////////////////////////
//
// Slider
//
//////////////////////////////////////////////////////////////////

Slider::Slider(int x, int y, int w, int h, float &v): value(v)
{
    left = x;
    top = y;
    width = w;
    height = h;
    background = NULL;
    createSlider(height);
    highlight = false;
    dragging = false;
}

Slider::~Slider()
{
    if (background)
        SDL_FreeSurface(background);
    if (slider)
        SDL_FreeSurface(slider);
    if (activeSlider)
        SDL_FreeSurface(activeSlider);
}

void Slider::draw()
{
    if (! background)
        createBackground();
    screen.draw(left, top, background);
    screen.addRegionToUpdate(left, top, width, height);
    int posX = valueToX(value);
    SDL_Surface *s = highlight ? activeSlider : slider;
    screen.draw(left + posX, top, s);
}

void Slider::createBackground()
{
    background = screen.createSubimage(left, top, width, height);
    int y = height / 2;
    SDL_LockSurface(background);
    drawBevel(background, 0, y - 2, width, 4, false, 1);
    SDL_UnlockSurface(background);
}

void Slider::createSlider(int size)
{
    SDL_Surface *s = screen.getSurface();
    SDL_Surface *image = SDL_CreateRGBSurface(SDL_SWSURFACE, size, size, 
            s->format->BitsPerPixel, s->format->Rmask, s->format->Gmask,
            s->format->Bmask, s->format->Amask);

    SDL_Surface *tile = loadImage(L"blue.bmp");
    SDL_Rect src = { 0, 0, tile->w, tile->h };
    SDL_Rect dst = { 0, 0, tile->w, tile->h };
    for (int j = 0; j < size; j += tile->h)
        for (int i = 0; i < size; i += tile->w) {
            dst.x = i;
            dst.y = j;
            SDL_BlitSurface(tile, &src, image, &dst);
        }
    SDL_FreeSurface(tile);

    SDL_LockSurface(image);
    drawBevel(image, 0, 0, size, size, false, 1);
    drawBevel(image, 1, 1, size - 2, size - 2, true, 1);
    SDL_UnlockSurface(image);
    
    activeSlider = adjustBrightness(image, 1.5, false);
    slider = SDL_DisplayFormat(image);
    
    SDL_FreeSurface(image);
}


bool Slider::onMouseButtonDown(int button, int x, int y)
{
    bool in = isInRect(x, y, left, top, width, height);
    if (in) {
        int sliderX = valueToX(value);
        bool hl = isInRect(x, y, left + sliderX, top, height, height);
        if (hl) {
            dragging = true;
            dragOffsetX = x - left - sliderX;
        }
    }
    return in;
}

bool Slider::onMouseButtonUp(int button, int x, int y)
{
    if (dragging) {
        dragging = false;
        return true;
    } else
        return false;
}


int Slider::valueToX(float value) 
{
    if (value < 0)
        value = 0.0f;
    if (value > 1)
        value = 1.0f;
    return (int)(((float)(width - height)) * value);
}


float Slider::xToValue(int pos) 
{
    if (0 > pos)
        pos = 0;
    if (width - height < pos)
        pos = width - height;
    return (float)pos / (float)(width - height);
}



bool Slider::onMouseMove(int x, int y)
{
    if (dragging) {
        float val = xToValue(x - left - dragOffsetX);
        if (val != value) {
            value = val;
            draw();
        }
        return true;
    }
    
    bool in = isInRect(x, y, left, top, width, height);
    if (in) {
        int sliderX = valueToX(value);
        bool hl = isInRect(x, y, left + sliderX, top, height, height);
        if (hl != highlight) {
            highlight = hl;
            draw();
        }
    } else
        if (highlight) {
            highlight = false;
            draw();
        }
    return in;
}