/*
    This file is part of the KDE libraries
    SPDX-FileCopyrightText: 1998 Jörg Habenicht <j.habenicht@europemail.com>

    SPDX-License-Identifier: LGPL-2.0-or-later
*/

#include "kruler.h"

#include <QFont>
#include <QPolygon>
#include <QStylePainter>

#define INIT_VALUE 0
#define INIT_MIN_VALUE 0
#define INIT_MAX_VALUE 100
#define INIT_TINY_MARK_DISTANCE 1
#define INIT_LITTLE_MARK_DISTANCE 5
#define INIT_MIDDLE_MARK_DISTANCE (INIT_LITTLE_MARK_DISTANCE * 2)
#define INIT_BIG_MARK_DISTANCE (INIT_LITTLE_MARK_DISTANCE * 10)
#define INIT_SHOW_TINY_MARK false
#define INIT_SHOW_LITTLE_MARK true
#define INIT_SHOW_MEDIUM_MARK true
#define INIT_SHOW_BIG_MARK true
#define INIT_SHOW_END_MARK true
#define INIT_SHOW_POINTER true
#define INIT_SHOW_END_LABEL true

#define INIT_PIXEL_PER_MARK (double)10.0 /* distance between 2 base marks in pixel */
#define INIT_OFFSET (-20)
#define INIT_LENGTH_FIX true
#define INIT_END_OFFSET 0

#define FIX_WIDTH 20 /* widget width in pixel */
#define LINE_END (FIX_WIDTH - 3)
#define END_MARK_LENGTH (FIX_WIDTH - 6)
#define END_MARK_X2 LINE_END
#define END_MARK_X1 (END_MARK_X2 - END_MARK_LENGTH)
#define BIG_MARK_LENGTH (END_MARK_LENGTH * 3 / 4)
#define BIG_MARK_X2 LINE_END
#define BIG_MARK_X1 (BIG_MARK_X2 - BIG_MARK_LENGTH)
#define MIDDLE_MARK_LENGTH (END_MARK_LENGTH / 2)
#define MIDDLE_MARK_X2 LINE_END
#define MIDDLE_MARK_X1 (MIDDLE_MARK_X2 - MIDDLE_MARK_LENGTH)
#define LITTLE_MARK_LENGTH (MIDDLE_MARK_LENGTH / 2)
#define LITTLE_MARK_X2 LINE_END
#define LITTLE_MARK_X1 (LITTLE_MARK_X2 - LITTLE_MARK_LENGTH)
#define BASE_MARK_LENGTH (LITTLE_MARK_LENGTH / 2)
#define BASE_MARK_X2 LINE_END
#define BASE_MARK_X1 (BASE_MARK_X2 - BASE_MARK_LENGTH)

#define LABEL_SIZE 8
#define END_LABEL_X 4
#define END_LABEL_Y (END_LABEL_X + LABEL_SIZE - 2)

#undef PROFILING

#ifdef PROFILING
#include <qdatetime.h>
#endif

class KRulerPrivate
{
public:
    int endOffset_length; /* marks the offset at the end of the ruler
                           * i.e. right side at horizontal and down side
                           * at vertical rulers.
                           * the ruler end mark is moved endOffset_length
                           * ticks away from the widget end.
                           * positive offset moves end mark inside the ruler.
                           * if lengthFix is true, endOffset_length holds the
                           * length of the ruler.
                           */
    int fontWidth; // ONLY valid for vertical rulers

    QAbstractSlider range;
    Qt::Orientation dir;
    int tmDist;
    int lmDist;
    int mmDist;
    int bmDist;
    int offset;
    bool showtm : 1; /* show tiny, little, medium, big, endmarks */
    bool showlm : 1;
    bool showmm : 1;
    bool showbm : 1;
    bool showem : 1;

    bool showpointer : 1;
    bool showEndL : 1;
    bool lengthFix : 1;

    double ppm; /* pixel per mark */

    QString endlabel;
};

KRuler::KRuler(QWidget *parent)
    : QAbstractSlider(parent)
    , d(new KRulerPrivate)
{
    setRange(INIT_MIN_VALUE, INIT_MAX_VALUE);
    setPageStep(10);
    setValue(INIT_VALUE);
    initWidget(Qt::Horizontal);
    setFixedHeight(FIX_WIDTH);
}

KRuler::KRuler(Qt::Orientation orient, QWidget *parent, Qt::WindowFlags f)
    : QAbstractSlider(parent)
    , d(new KRulerPrivate)
{
    setRange(INIT_MIN_VALUE, INIT_MAX_VALUE);
    setPageStep(10);
    setValue(INIT_VALUE);
    setWindowFlags(f);
    initWidget(orient);
    if (orient == Qt::Horizontal) {
        setFixedHeight(FIX_WIDTH);
    } else {
        setFixedWidth(FIX_WIDTH);
    }
}

KRuler::KRuler(Qt::Orientation orient, int widgetWidth, QWidget *parent, Qt::WindowFlags f)
    : QAbstractSlider(parent)
    , d(new KRulerPrivate)
{
    setRange(INIT_MIN_VALUE, INIT_MAX_VALUE);
    setPageStep(10);
    setValue(INIT_VALUE);
    setWindowFlags(f);
    initWidget(orient);
    if (orient == Qt::Horizontal) {
        setFixedHeight(widgetWidth);
    } else {
        setFixedWidth(widgetWidth);
    }
}

void KRuler::initWidget(Qt::Orientation orientation)
{
    d->showpointer = INIT_SHOW_POINTER;
    d->showEndL = INIT_SHOW_END_LABEL;
    d->lengthFix = INIT_LENGTH_FIX;
    d->endOffset_length = INIT_END_OFFSET;

    d->tmDist = INIT_TINY_MARK_DISTANCE;
    d->lmDist = INIT_LITTLE_MARK_DISTANCE;
    d->mmDist = INIT_MIDDLE_MARK_DISTANCE;
    d->bmDist = INIT_BIG_MARK_DISTANCE;
    d->offset = INIT_OFFSET;
    d->showtm = INIT_SHOW_TINY_MARK;
    d->showlm = INIT_SHOW_LITTLE_MARK;
    d->showmm = INIT_SHOW_MEDIUM_MARK;
    d->showbm = INIT_SHOW_BIG_MARK;
    d->showem = INIT_SHOW_END_MARK;
    d->ppm = INIT_PIXEL_PER_MARK;
    d->dir = orientation;
}

KRuler::~KRuler() = default;

void KRuler::setTinyMarkDistance(int dist)
{
    if (dist != d->tmDist) {
        d->tmDist = dist;
        update(contentsRect());
    }
}

int KRuler::tinyMarkDistance() const
{
    return d->tmDist;
}

void KRuler::setLittleMarkDistance(int dist)
{
    if (dist != d->lmDist) {
        d->lmDist = dist;
        update(contentsRect());
    }
}

int KRuler::littleMarkDistance() const
{
    return d->lmDist;
}

void KRuler::setMediumMarkDistance(int dist)
{
    if (dist != d->mmDist) {
        d->mmDist = dist;
        update(contentsRect());
    }
}

int KRuler::mediumMarkDistance() const
{
    return d->mmDist;
}

void KRuler::setBigMarkDistance(int dist)
{
    if (dist != d->bmDist) {
        d->bmDist = dist;
        update(contentsRect());
    }
}

int KRuler::bigMarkDistance() const
{
    return d->bmDist;
}

void KRuler::setShowTinyMarks(bool show)
{
    if (show != d->showtm) {
        d->showtm = show;
        update(contentsRect());
    }
}

bool KRuler::showTinyMarks() const
{
    return d->showtm;
}

void KRuler::setShowLittleMarks(bool show)
{
    if (show != d->showlm) {
        d->showlm = show;
        update(contentsRect());
    }
}

bool KRuler::showLittleMarks() const
{
    return d->showlm;
}

void KRuler::setShowMediumMarks(bool show)
{
    if (show != d->showmm) {
        d->showmm = show;
        update(contentsRect());
    }
}

bool KRuler::showMediumMarks() const
{
    return d->showmm;
}

void KRuler::setShowBigMarks(bool show)
{
    if (show != d->showbm) {
        d->showbm = show;
        update(contentsRect());
    }
}

bool KRuler::showBigMarks() const
{
    return d->showbm;
}

void KRuler::setShowEndMarks(bool show)
{
    if (show != d->showem) {
        d->showem = show;
        update(contentsRect());
    }
}

bool KRuler::showEndMarks() const
{
    return d->showem;
}

void KRuler::setShowPointer(bool show)
{
    if (show != d->showpointer) {
        d->showpointer = show;
        update(contentsRect());
    }
}

bool KRuler::showPointer() const
{
    return d->showpointer;
}

void KRuler::setShowEndLabel(bool show)
{
    if (d->showEndL != show) {
        d->showEndL = show;
        update(contentsRect());
    }
}

bool KRuler::showEndLabel() const
{
    return d->showEndL;
}

void KRuler::setEndLabel(const QString &label)
{
    d->endlabel = label;

    // premeasure the fontwidth and save it
    if (d->dir == Qt::Vertical) {
        QFont font = this->font();
        font.setPointSize(LABEL_SIZE);
        QFontMetrics fm(font);
        d->fontWidth = fm.horizontalAdvance(d->endlabel);
    }
    update(contentsRect());
}

QString KRuler::endLabel() const
{
    return d->endlabel;
}

void KRuler::setRulerMetricStyle(KRuler::MetricStyle style)
{
    switch (style) {
    default: /* fall through */
    case Custom:
        return;
    case Pixel:
        setLittleMarkDistance(1);
        setMediumMarkDistance(5);
        setBigMarkDistance(10);

        setShowTinyMarks(false);
        setShowLittleMarks(true);
        setShowMediumMarks(true);
        setShowBigMarks(true);
        setShowEndMarks(true);

        update(contentsRect());
        setPixelPerMark(10.0);

        break;
    case Inch:
        setTinyMarkDistance(1);
        setLittleMarkDistance(2);
        setMediumMarkDistance(4);
        setBigMarkDistance(8);

        setShowTinyMarks(true);
        setShowLittleMarks(true);
        setShowMediumMarks(true);
        setShowBigMarks(true);
        setShowEndMarks(true);

        update(contentsRect());
        setPixelPerMark(9.0);

        break;
    case Millimetres: /* fall through */
    case Centimetres: /* fall through */
    case Metres:
        setLittleMarkDistance(1);
        setMediumMarkDistance(5);
        setBigMarkDistance(10);

        setShowTinyMarks(false);
        setShowLittleMarks(true);
        setShowMediumMarks(true);
        setShowBigMarks(true);
        setShowEndMarks(true);

        update(contentsRect());
        setPixelPerMark(3.0);
    }
    switch (style) {
    case Pixel:
        setEndLabel(QStringLiteral("pixel"));
        break;
    case Inch:
        setEndLabel(QStringLiteral("inch"));
        break;
    case Millimetres:
        setEndLabel(QStringLiteral("mm"));
        break;
    case Centimetres:
        setEndLabel(QStringLiteral("cm"));
        break;
    case Metres:
        setEndLabel(QStringLiteral("m"));
    default: /* never reached, see above switch */
             /* empty command */;
    }
    // if the style changes one of the values,
    // update would have been called inside the methods
    // -> no update() call needed here !
}

void KRuler::setPixelPerMark(double rate)
{
    // never compare floats against each other :)
    d->ppm = rate;
    update(contentsRect());
}

double KRuler::pixelPerMark() const
{
    return d->ppm;
}

void KRuler::setLength(int length)
{
    int tmp;
    if (d->lengthFix) {
        tmp = length;
    } else {
        tmp = width() - length;
    }
    if (tmp != d->endOffset_length) {
        d->endOffset_length = tmp;
        update(contentsRect());
    }
}

int KRuler::length() const
{
    if (d->lengthFix) {
        return d->endOffset_length;
    }
    return (width() - d->endOffset_length);
}

void KRuler::setLengthFixed(bool fix)
{
    d->lengthFix = fix;
}

bool KRuler::lengthFixed() const
{
    return d->lengthFix;
}

void KRuler::setOffset(int _offset)
{
    // debug("set offset %i", _offset);
    if (d->offset != _offset) {
        d->offset = _offset;
        update(contentsRect());
    }
}

int KRuler::offset() const
{
    return d->offset;
}

int KRuler::endOffset() const
{
    if (d->lengthFix) {
        return (width() - d->endOffset_length);
    }
    return d->endOffset_length;
}

void KRuler::slideUp(int count)
{
    if (count) {
        d->offset += count;
        update(contentsRect());
    }
}

void KRuler::slideDown(int count)
{
    if (count) {
        d->offset -= count;
        update(contentsRect());
    }
}

void KRuler::slotNewValue(int _value)
{
    int oldvalue = value();
    if (oldvalue == _value) {
        return;
    }
    //    setValue(_value);
    setValue(_value);
    if (value() == oldvalue) {
        return;
    }
    // get the rectangular of the old and the new ruler pointer
    // and repaint only him
    if (d->dir == Qt::Horizontal) {
        QRect oldrec(-5 + oldvalue, 10, 11, 6);
        QRect newrec(-5 + _value, 10, 11, 6);
        repaint(oldrec.united(newrec));
    } else {
        QRect oldrec(10, -5 + oldvalue, 6, 11);
        QRect newrec(10, -5 + _value, 6, 11);
        repaint(oldrec.united(newrec));
    }
}

void KRuler::slotNewOffset(int _offset)
{
    if (d->offset != _offset) {
        // setOffset(_offset);
        d->offset = _offset;
        repaint(contentsRect());
    }
}

void KRuler::slotEndOffset(int offset)
{
    int tmp;
    if (d->lengthFix) {
        tmp = width() - offset;
    } else {
        tmp = offset;
    }
    if (d->endOffset_length != tmp) {
        d->endOffset_length = tmp;
        repaint(contentsRect());
    }
}

void KRuler::paintEvent(QPaintEvent * /*e*/)
{
    //  debug ("KRuler::drawContents, %s",(horizontal==dir)?"horizontal":"vertical");

    QStylePainter p(this);
#ifdef PROFILING
    QTime time;
    time.start();
    for (int profile = 0; profile < 10; profile++) {
#endif

        int value = this->value();
        int minval = minimum();
        int maxval;
        if (d->dir == Qt::Horizontal) {
            maxval = maximum() + d->offset - (d->lengthFix ? (height() - d->endOffset_length) : d->endOffset_length);
        } else {
            maxval = maximum() + d->offset - (d->lengthFix ? (width() - d->endOffset_length) : d->endOffset_length);
        }
        // ioffsetval = value-offset;
        //    pixelpm = (int)ppm;
        //    left  = clip.left(),
        //    right = clip.right();
        double f;
        double fend;
        double offsetmin = (double)(minval - d->offset);
        double offsetmax = (double)(maxval - d->offset);
        double fontOffset = (((double)minval) > offsetmin) ? (double)minval : offsetmin;

        // draw labels
        QFont font = p.font();
        font.setPointSize(LABEL_SIZE);
        p.setFont(font);
        // draw littlemarklabel

        // draw mediummarklabel

        // draw bigmarklabel

        // draw endlabel
        if (d->showEndL) {
            if (d->dir == Qt::Horizontal) {
                p.translate(fontOffset, 0);
                p.drawText(END_LABEL_X, END_LABEL_Y, d->endlabel);
            } else { // rotate text +pi/2 and move down a bit
                // QFontMetrics fm(font);
#ifdef KRULER_ROTATE_TEST
                p.rotate(-90.0 + rotate);
                p.translate(-8.0 - fontOffset - d->fontWidth + xtrans, ytrans);
#else
            p.rotate(-90.0);
            p.translate(-8.0 - fontOffset - d->fontWidth, 0.0);
#endif
                p.drawText(END_LABEL_X, END_LABEL_Y, d->endlabel);
            }
            p.resetTransform();
        }

        // draw the tiny marks
        if (d->showtm) {
            fend = d->ppm * d->tmDist;
            for (f = offsetmin; f < offsetmax; f += fend) {
                if (d->dir == Qt::Horizontal) {
                    p.drawLine((int)f, BASE_MARK_X1, (int)f, BASE_MARK_X2);
                } else {
                    p.drawLine(BASE_MARK_X1, (int)f, BASE_MARK_X2, (int)f);
                }
            }
        }
        if (d->showlm) {
            // draw the little marks
            fend = d->ppm * d->lmDist;
            for (f = offsetmin; f < offsetmax; f += fend) {
                if (d->dir == Qt::Horizontal) {
                    p.drawLine((int)f, LITTLE_MARK_X1, (int)f, LITTLE_MARK_X2);
                } else {
                    p.drawLine(LITTLE_MARK_X1, (int)f, LITTLE_MARK_X2, (int)f);
                }
            }
        }
        if (d->showmm) {
            // draw medium marks
            fend = d->ppm * d->mmDist;
            for (f = offsetmin; f < offsetmax; f += fend) {
                if (d->dir == Qt::Horizontal) {
                    p.drawLine((int)f, MIDDLE_MARK_X1, (int)f, MIDDLE_MARK_X2);
                } else {
                    p.drawLine(MIDDLE_MARK_X1, (int)f, MIDDLE_MARK_X2, (int)f);
                }
            }
        }
        if (d->showbm) {
            // draw big marks
            fend = d->ppm * d->bmDist;
            for (f = offsetmin; f < offsetmax; f += fend) {
                if (d->dir == Qt::Horizontal) {
                    p.drawLine((int)f, BIG_MARK_X1, (int)f, BIG_MARK_X2);
                } else {
                    p.drawLine(BIG_MARK_X1, (int)f, BIG_MARK_X2, (int)f);
                }
            }
        }
        if (d->showem) {
            // draw end marks
            if (d->dir == Qt::Horizontal) {
                p.drawLine(minval - d->offset, END_MARK_X1, minval - d->offset, END_MARK_X2);
                p.drawLine(maxval - d->offset, END_MARK_X1, maxval - d->offset, END_MARK_X2);
            } else {
                p.drawLine(END_MARK_X1, minval - d->offset, END_MARK_X2, minval - d->offset);
                p.drawLine(END_MARK_X1, maxval - d->offset, END_MARK_X2, maxval - d->offset);
            }
        }

        // draw pointer
        if (d->showpointer) {
            QPolygon pa(4);
            if (d->dir == Qt::Horizontal) {
                pa.setPoints(3, value - 5, 10, value + 5, 10, value /*+0*/, 15);
            } else {
                pa.setPoints(3, 10, value - 5, 10, value + 5, 15, value /*+0*/);
            }
            p.setBrush(p.background().color());
            p.drawPolygon(pa);
        }

#ifdef PROFILING
    }
    int elapsed = time.elapsed();
    debug("paint time %i", elapsed);
#endif
}

#include "moc_kruler.cpp"