/*  Starshatter OpenSource Distribution
    Copyright (c) 1997-2004, Destroyer Studios LLC.
    All Rights Reserved.

    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright notice,
      this list of conditions and the following disclaimer in the documentation
      and/or other materials provided with the distribution.
    * Neither the name "Destroyer Studios" nor the names of its contributors
      may be used to endorse or promote products derived from this software
      without specific prior written permission.

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
    LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    POSSIBILITY OF SUCH DAMAGE.

    SUBSYSTEM:    nGenEx.lib
    FILE:         Slider.cpp
    AUTHOR:       John DiCamillo


    OVERVIEW
    ========
    Slider/Gauge ActiveWindow class
*/

#include "MemDebug.h"
#include "Slider.h"
#include "Video.h"
#include "Font.h"

// +--------------------------------------------------------------------+

Slider::Slider(ActiveWindow* p, int ax, int ay, int aw, int ah, DWORD aid)
: ActiveWindow(p->GetScreen(), ax, ay, aw, ah, aid, 0, p)
{
    captured       = false;
    dragging       = false;

    border_color   = Color::Black;
    fill_color     = Color::DarkBlue;

    active         = true;
    border         = true;
    num_leds       = 1;
    orientation    = 0;

    range_min      = 0;
    range_max      = 100;
    step_size      = 10;
    show_thumb     = 0;
    thumb_size     = -1;

    nvalues        = 1;
    ZeroMemory(value, sizeof(value));

    marker[0]      = -1;
    marker[1]      = -1;

    char buf[32];
    sprintf_s(buf, "Slider %d", id); //-V576
    desc = buf;
}

Slider::Slider(Screen* s, int ax, int ay, int aw, int ah, DWORD aid)
: ActiveWindow(s, ax, ay, aw, ah, aid)
{
    captured       = false;
    dragging       = false;

    border_color   = Color::Black;
    fill_color     = Color::DarkBlue;

    active         = true;
    border         = true;
    num_leds       = 1;
    orientation    = 0;

    range_min      = 0;
    range_max      = 100;
    step_size      = 10;
    show_thumb     = 0;
    thumb_size     = -1;

    nvalues        = 1;
    ZeroMemory(value, sizeof(value));

    marker[0]      = -1;
    marker[1]      = -1;

    char buf[32];
    sprintf_s(buf, "Slider %d", id); //-V576
    desc = buf;
}

Slider::~Slider()
{
}

// +--------------------------------------------------------------------+

void
Slider::Draw()
{
    int x = 0;
    int y = 0;
    int w = rect.w;
    int h = rect.h;

    if (w < 1 || h < 1 || !shown)
    return;

    Rect  ctrl_rect(x,y,w,h);

    // draw the border:
    if (border) {
        Color oc = ShadeColor(border_color, 1);
        DrawRect(0,0,w-1,h-1,oc);
        DrawRect(1,1,w-2,h-2,oc);

        ctrl_rect.Deflate(2,2);
    }

    // draw the bevel:
    FillRect(ctrl_rect, back_color);
    DrawStyleRect(ctrl_rect, WIN_SUNK_FRAME);

    // HORIZONTAL
    if (orientation == 0) {
        // draw the leds:
        int led_width  = ((w - 6) / (num_leds)) - 1;
        int led_height = ((h - 5) / (nvalues))  - 1;

        if (nvalues < 2) {
            int fill_width  = (int) ((double)(w-4) * FractionalValue());
            int num_lit     = fill_width / (led_width+1);

            Color fc = ShadeColor(fill_color, 1);

            if (num_leds == 1) {
                FillRect(2,2,2+fill_width,h-3,fc);
            }
            else {
                int x0 = 2;

                for (int i = 0; i < num_lit; i++) {
                    FillRect(x0,2,x0+led_width,h-3,fc);
                    x0 += led_width + 1;
                }
            }

            // draw the thumb:
            if (thumb_size) {
                if (thumb_size < 0) thumb_size = h;

                thumb_pos = 2+fill_width;

                Rect thumb_rect(thumb_pos-thumb_size/2, 0, thumb_size, h);

                if (thumb_rect.x < 0)
                thumb_rect.x = 0;

                else if (thumb_rect.x > w-thumb_size)
                thumb_rect.x = w-thumb_size;

                if (show_thumb) {
                    FillRect(thumb_rect, back_color);
                    DrawStyleRect(thumb_rect, WIN_RAISED_FRAME);
                }
            }
        }

        else {
            Color fc = ShadeColor(fill_color, 1);

            int y0 = 3;

            for (int i = 0; i < nvalues; i++) {
                int fill_width  = (int) ((double)(w-6) * FractionalValue(i));
                FillRect(3,y0,3+fill_width,y0+led_height,fc);

                y0 += led_height+1;
            }
        }

        // draw the markers:
        if (marker[0] >= 0) {
            int   m = marker[0];
            Color c = ShadeColor(base_color, 1.6);    // full highlight
            DrawLine(m-3, 1, m+4,  1, c);
            c = ShadeColor(base_color, 1.3);          // soft highlight
            DrawLine(m-3, 2, m-3,  4, c);
            DrawLine(m-2, 4, m-2,  6, c);
            DrawLine(m-1, 6, m-1,  8, c);
            DrawLine(m  , 8, m  , 10, c);
            c = base_color;                           // body
            DrawLine(m-2, 2, m-2,  4, c);
            DrawLine(m-1, 2, m-1,  6, c);
            DrawLine(m  , 2, m  ,  8, c);
            DrawLine(m+1, 2, m+1,  6, c);
            DrawLine(m+2, 2, m+2,  4, c);
            c = ShadeColor(base_color, 0.5);          // shadow
            DrawLine(m+1, 6, m+1,  8, c);
            DrawLine(m+2, 4, m+2,  6, c);
            DrawLine(m+3, 2, m+3,  4, c);
        }

        if (marker[1] >= 0) {
            int   m = marker[0];
            Color c = ShadeColor(base_color, 0.5);    // shadow
            DrawLine(m-3, h-2, m+4, h-2, c);
            DrawLine(m+1, h-6, m+1, h-8, c);
            DrawLine(m+2, h-4, m+2, h-6, c);
            DrawLine(m+3, h-2, m+3, h-4, c);
            c = ShadeColor(base_color, 1.3);          // soft highlight
            DrawLine(m-3, h-2, m-3, h-4, c);
            DrawLine(m-2, h-4, m-2, h-6, c);
            DrawLine(m-1, h-6, m-1, h-8, c);
            DrawLine(m  , h-8, m  , h-10, c);
            c = base_color;                           // body
            DrawLine(m-2, h-2, m-2, h-4, c);
            DrawLine(m-1, h-2, m-1, h-6, c);
            DrawLine(m  , h-2, m  , h-8, c);
            DrawLine(m+1, h-2, m+1, h-6, c);
            DrawLine(m+2, h-2, m+2, h-4, c);
        }
    }

    // VERTICAL
    else {
        // draw the leds:
        int led_width  = ((w - 5) / (nvalues))  - 1;

        if (num_leds > 1) {
        }
        else {
            if (nvalues < 2) {
                led_width  = w - 4;
                int led_height = (int) ((double)(h-4) * FractionalValue());

                Color fc = ShadeColor(fill_color, 1);
                FillRect(2, h-2-led_height, 2+led_width, h-2, fc);

                // draw the thumb:
                if (thumb_size) {
                    if (thumb_size < 0) thumb_size = w;

                    thumb_pos = h-2-led_height;

                    Rect thumb_rect(0, thumb_pos-(thumb_size/2), w, thumb_size);

                    if (thumb_rect.y < 0)
                    thumb_rect.y = 0;

                    else if (thumb_rect.y > h-thumb_size)
                    thumb_rect.y = h-thumb_size;

                    if (show_thumb) {
                        FillRect(thumb_rect, back_color);
                        DrawStyleRect(thumb_rect, WIN_RAISED_FRAME);
                    }
                }
            }

            else {
                Color fc = ShadeColor(fill_color, 1);

                int x0 = 3;

                for (int i = 0; i < nvalues; i++) {
                    int led_height = (int) ((double)(h-6) * FractionalValue(i));
                    FillRect(x0,h-3-led_height,x0+led_width,h-3,fc);

                    x0 += led_width+1;
                }
            }
        }
    }
}

// +--------------------------------------------------------------------+

bool Slider::GetActive()
{
    return active;
}

void  Slider::SetActive(bool bNewValue)
{
    active = bNewValue;
}

bool  Slider::GetBorder()
{
    return border;
}

void  Slider::SetBorder(bool bNewValue)
{
    border = bNewValue;
}

Color  Slider::GetBorderColor()
{
    return border_color;
}

void  Slider::SetBorderColor(Color newValue)
{
    border_color = newValue;
}

Color Slider::GetFillColor()
{
    return fill_color;
}

void  Slider::SetFillColor(Color cNewValue)
{
    fill_color = cNewValue;
}

int   Slider::GetNumLeds()
{
    return num_leds;
}

void  Slider::SetNumLeds(int nNewValue)
{
    if (nNewValue >= 0) {
        num_leds = nNewValue;
    }
}

int   Slider::GetOrientation()
{
    return orientation;
}

void  Slider::SetOrientation(int nNewValue)
{
    if (nNewValue == 0 || nNewValue == 1) {
        orientation = nNewValue;
    }
}

int   Slider::GetRangeMin()
{
    return range_min;
}

void  Slider::SetRangeMin(int nNewValue)
{
    range_min = nNewValue;
}

int   Slider::GetRangeMax()
{
    return range_max;
}

void  Slider::SetRangeMax(int nNewValue)
{
    range_max = nNewValue;
}

int   Slider::GetStepSize()
{
    return step_size;
}

void  Slider::SetStepSize(int nNewValue)
{
    if (nNewValue < range_max - range_min)
    step_size = nNewValue;
}

bool  Slider::GetShowThumb()
{
    return show_thumb?true:false;
}

void  Slider::SetShowThumb(bool bNewValue)
{
    show_thumb = bNewValue;
}

int   Slider::GetThumbSize()
{
    return thumb_size;
}

void  Slider::SetThumbSize(int nNewValue)
{
    if (nNewValue < range_max - range_min)
    thumb_size = nNewValue;
}

int   Slider::NumValues()
{
    return nvalues;
}

int   Slider::GetValue(int index)
{
    if (index >= 0 && index < nvalues)
    return value[index];

    return 0;
}

void  Slider::SetValue(int nNewValue, int index)
{
    if (index >= 0 && index < MAX_VAL) {
        value[index] = nNewValue;
        
        if (index >= nvalues)
        nvalues = index+1;
    }
}

void  Slider::SetMarker(int nNewValue, int index)
{
    if (index >= 0 && index < 2) {
        marker[index] = nNewValue;
    }
}

double Slider::FractionalValue(int index)
{
    if (index >= 0 && index < nvalues)
    return ((double) (value[index]-range_min)) / ((double) (range_max-range_min));

    return 0;
}

// +--------------------------------------------------------------------+

void  Slider::StepUp(int index)
{
    if (index >= 0 && index < nvalues) {
        value[index] += step_size;

        if (value[index] > range_max)
        value[index] = range_max;
    }
}

void  Slider::StepDown(int index)
{
    if (index >= 0 && index < nvalues) {
        value[index] -= step_size;

        if (value[index] < range_min)
        value[index] = range_min;
    }
}

// +--------------------------------------------------------------------+

int Slider::OnMouseMove(int x, int y)
{
    bool dirty = false;

    if (captured)
    {
        ActiveWindow* test = GetCapture();

        if (test != this)
        {
            captured = false;
            dirty = true;
        }

        else if (dragging)
        {
            mouse_x = x - rect.x;
            if (mouse_x < 0) mouse_x = 0;
            else if (mouse_x > rect.w) mouse_x = rect.w;

            mouse_y = rect.h - (y - rect.y);
            if (mouse_y < 0) mouse_y = 0;
            else if (mouse_y > rect.h) mouse_y = rect.h;

            // HORIZONTAL
            if (orientation == 0) {
                SetValue((int) ((double) mouse_x/rect.w * (range_max-range_min) + range_min));
            }

            // VERTICAL
            else {
                SetValue((int) ((double) mouse_y/rect.h * (range_max-range_min) + range_min));
            }

            dirty = true;
        }
    }

    if (dirty)
    OnClick();

    return ActiveWindow::OnMouseMove(x,y);
}

int Slider::OnLButtonDown(int x, int y)
{
    if (!active)
    return 0;

    if (!captured)
    captured = SetCapture();

    mouse_x = x - rect.x;
    mouse_y = y - rect.y;

    // HORIZONTAL
    if (orientation == 0) {
        if (mouse_x < thumb_pos-thumb_size/2) {
            StepDown();
        }

        else if (mouse_x > thumb_pos+thumb_size/2) {
            StepUp();
        }

        else {
            dragging = true;
        }
    }

    // VERTICAL
    else {
        if (mouse_y < thumb_pos-thumb_size/2) {
            StepUp();
        }

        else if (mouse_y > thumb_pos+thumb_size/2) {
            StepDown();
        }

        else {
            dragging = true;
        }
    }

    if (!dragging)
    OnClick();

    return ActiveWindow::OnLButtonDown(x,y);
}

int Slider::OnLButtonUp(int x, int y)
{
    if (!active)
    return 0;

    if (captured) {
        ReleaseCapture();
        captured = 0;
        dragging = false;
    }

    return ActiveWindow::OnLButtonUp(x,y);
}

int Slider::OnClick()
{
    return ActiveWindow::OnClick();
}