421 lines
9.0 KiB
C++
Executable File
421 lines
9.0 KiB
C++
Executable File
|
|
|
|
|
|
#include "EventTools.h"
|
|
#include "EventGraphic.h"
|
|
#include "Event.h"
|
|
|
|
#include <NGLLogger/NGLLoggerBootstrap.h>
|
|
#include <math.h>
|
|
#include <QPainter>
|
|
#include <QDebug>
|
|
|
|
|
|
namespace LtsTimelineClassic
|
|
{
|
|
|
|
#define logger NGL::NGLLoggerBootstrap::getNGLRootLogger().getNGLLogger("Timeline.EventTools")
|
|
#ifdef LTS_DEBUG
|
|
|
|
#endif
|
|
#ifdef VERBOSE
|
|
#define dbg_print(x) qWarning() << #x << x
|
|
#else
|
|
#define dbg_print(x) (void)x;
|
|
#endif
|
|
|
|
qint64 EventTools::s_minAdjusted = 0;
|
|
qint64 EventTools::s_maxAdjusted = 1;
|
|
qint64 EventTools::s_minTimeline = 0;
|
|
qint64 EventTools::s_maxTimeline = 1;
|
|
qint64 EventTools::s_sbPos = 0;
|
|
qint64 EventTools::s_zoomFactor = 1;
|
|
int EventTools::s_paintMin = 0;
|
|
int EventTools::s_paintDiff = 0;
|
|
bool EventTools::s_isValid = false;
|
|
qint64 EventTools::s_diff = 0;
|
|
int EventTools::s_sectionHeight = 0;
|
|
int EventTools::s_test = 0;
|
|
qint64 EventTools::s_blockSizeTime = 0;
|
|
bool EventTools::s_inUse = false;
|
|
|
|
|
|
|
|
|
|
void EventTools::setValues(const qint64 min, const qint64 max, const qint64 sbPos, const qint64 zoomFactor)
|
|
{
|
|
if (s_minTimeline == min && s_maxTimeline == max && s_sbPos == sbPos && s_zoomFactor == zoomFactor)
|
|
return;
|
|
|
|
s_sbPos = sbPos;
|
|
s_zoomFactor = zoomFactor;
|
|
|
|
|
|
|
|
|
|
s_isValid = false;
|
|
|
|
s_minAdjusted = s_sbPos;
|
|
|
|
double d_max = s_minAdjusted;
|
|
d_max += s_zoomFactor;
|
|
|
|
s_maxAdjusted = d_max;
|
|
s_diff = s_maxAdjusted - s_minAdjusted;
|
|
|
|
s_minTimeline = min;
|
|
s_maxTimeline = max - EventTools::s_diff + (EventTools::getBlockSizeTime() * 2);
|
|
|
|
recalcBlockSizeTime();
|
|
|
|
if (min > 0 && max > 1)
|
|
{
|
|
s_isValid = true;
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
}
|
|
|
|
#ifdef VERBOSE
|
|
qWarning() << "\r\n\r\nEventTools::setValues: " << "\r\n"
|
|
<< "s_sbPos" << s_sbPos << "\r\n"
|
|
<< "s_zoomFactor" << s_zoomFactor << "\r\n"
|
|
<< "s_minTimeline" << s_minTimeline << "\r\n"
|
|
<< "s_maxTimeline" << s_maxTimeline << "\r\n"
|
|
<< "s_isValid" << s_isValid << "\r\n"
|
|
<< "s_minAdjusted" << s_minAdjusted << "\r\n"
|
|
<< "s_maxAdjusted" << (long)s_maxAdjusted << "\r\n"
|
|
<< "s_diff" << s_diff << "\r\n"
|
|
;
|
|
#endif
|
|
}
|
|
|
|
|
|
void EventTools::setSection(const int x, const int length)
|
|
{
|
|
s_paintMin = x;
|
|
s_paintDiff = length;
|
|
|
|
}
|
|
|
|
|
|
bool EventTools::isValid()
|
|
{
|
|
#ifdef VERBOSE
|
|
if (!s_isValid)
|
|
qWarning() << "<<<< INVALID EVENT TOOLS!!";
|
|
|
|
qWarning() << "\r\nEventTools::isValid: " << "\r\n"
|
|
<< "s_isValid" << s_isValid << "\r\n"
|
|
;
|
|
#endif
|
|
|
|
return s_isValid;
|
|
}
|
|
|
|
qint64 EventTools::getAdjustedMin()
|
|
{
|
|
if (!isValid())
|
|
return 0;
|
|
|
|
return s_minAdjusted;
|
|
}
|
|
|
|
qint64 EventTools::getAdjustedMax()
|
|
{
|
|
if (!isValid())
|
|
return 1;
|
|
|
|
return s_maxAdjusted;
|
|
}
|
|
|
|
qint64 EventTools::getTimelineMin()
|
|
{
|
|
if (!isValid())
|
|
return 0;
|
|
|
|
return s_minTimeline;
|
|
}
|
|
|
|
qint64 EventTools::getScrollbarPosition()
|
|
{
|
|
return s_sbPos;
|
|
}
|
|
|
|
qint64 EventTools::getTimelineMax()
|
|
{
|
|
if (!isValid())
|
|
return 1;
|
|
|
|
return s_maxTimeline;
|
|
}
|
|
|
|
int EventTools::getEventPosition(qint64 eventTime)
|
|
{
|
|
qint64 min = s_minAdjusted;
|
|
|
|
qint64 diff = s_diff;
|
|
|
|
|
|
|
|
|
|
if (diff == 0)
|
|
{
|
|
#ifdef VERBOSE
|
|
qWarning() << "\n\ngetEventPosition: diff == 0\n";
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
double pDiff = s_paintDiff;
|
|
double pMin = s_paintMin;
|
|
|
|
double x1 = eventTime;
|
|
x1 -= min;
|
|
x1 /= diff;
|
|
|
|
double x2 = x1;
|
|
x2 *= pDiff;
|
|
x2 += pMin;
|
|
|
|
#ifdef VERBOSE
|
|
qWarning() << "\r\n\r\nEventTools::getEventPosition: " << "\r\n"
|
|
<< "min" << min << "\r\n"
|
|
<< "diff" << diff << "\r\n"
|
|
<< "pDiff" << pDiff << "\r\n"
|
|
<< "pMin" << pMin << "\r\n"
|
|
<< (long)x1 << "[x1]" << "= (" << eventTime << "[eventTime]" << "-" << min << "[min]" << ") /" << diff << "[diff]" << "\r\n"
|
|
<< (long)x2 << "[x2]" << "= (" << (long)x1 << "[x1]" << "*" << pDiff << "[pDiff]" << ") +" << pMin << "[pMin]" << "\r\n"
|
|
;
|
|
|
|
dbg_print(min);
|
|
#endif
|
|
|
|
return qRound(x2);
|
|
}
|
|
|
|
qint64 EventTools::getEventTime(double eventPosition)
|
|
{
|
|
if (!isValid())
|
|
{
|
|
|
|
return 0;
|
|
}
|
|
|
|
if (eventPosition > 999999)
|
|
{
|
|
|
|
WARNING_LOG(logger) << "getEventTime: pos > 999999 => returning 0" ;
|
|
return 0;
|
|
}
|
|
|
|
double min = s_minAdjusted;
|
|
double diff = s_diff;
|
|
double pDiff = s_paintDiff;
|
|
|
|
if (pDiff < 1)
|
|
{
|
|
|
|
WARNING_LOG(logger) << "getEventTime: pDiff < 1" ;
|
|
return 0;
|
|
}
|
|
|
|
double pMin = s_paintMin;
|
|
|
|
double x1 = eventPosition;
|
|
x1 -= pMin;
|
|
x1 /= pDiff;
|
|
|
|
double x2 = x1;
|
|
x2 *= diff;
|
|
x2 += min;
|
|
|
|
return qRound64(x2);
|
|
}
|
|
|
|
|
|
void EventTools::drawMarkLines(QPainter *painter, const EventList &eventList, int viewHeight)
|
|
{
|
|
if (!isValid())
|
|
return;
|
|
|
|
|
|
|
|
for (int k = 0; k < eventList.count(); k++)
|
|
{
|
|
Event *e = eventList.at(k);
|
|
int pos = getEventPosition(e->startTime());
|
|
|
|
if (pos < (s_paintMin) || pos > (s_paintMin + s_paintDiff))
|
|
continue;
|
|
|
|
painter->drawLine(pos, 0, pos, viewHeight);
|
|
}
|
|
}
|
|
|
|
|
|
void EventTools::recalcBlockSizeTime()
|
|
{
|
|
s_blockSizeTime = _getBlockSizeTime();
|
|
}
|
|
|
|
|
|
qint64 EventTools::_getBlockSizeTime()
|
|
{
|
|
|
|
int startPos = getEventPosition(s_minAdjusted);
|
|
int endPos = getEventPosition(s_maxAdjusted);
|
|
|
|
int posDiff = endPos - startPos;
|
|
|
|
if (posDiff < 1)
|
|
{
|
|
|
|
return 0;
|
|
}
|
|
|
|
qint64 diff = s_maxAdjusted - s_minAdjusted;
|
|
|
|
double pixelWidthInSeconds = diff;
|
|
pixelWidthInSeconds /= posDiff;
|
|
|
|
int eventGraphicsWidth = eventWidth();
|
|
qint64 result = eventGraphicsWidth; result *= pixelWidthInSeconds;
|
|
|
|
#ifdef VERBOSE
|
|
qWarning() << "\r\n\r\nEventTools::recalcBlockSizeTime: " << "\r\n"
|
|
<< "minAdj" << s_minAdjusted << "\r\n"
|
|
<< "maxAdj" << s_maxAdjusted << "\r\n"
|
|
<< "endPos" << endPos << "\r\n"
|
|
<< "diff" << diff << "\r\n"
|
|
<< "pixelWidthInSeconds" << pixelWidthInSeconds << "\r\n"
|
|
<< "eventGraphicsWidth" << eventGraphicsWidth << "\r\n"
|
|
<< "result" << result << "\r\n"
|
|
<< "(duration > result) ?" << (duration > result)
|
|
;
|
|
#endif
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
qint64 EventTools::getBlockSizeTime(qint64 duration)
|
|
{
|
|
if (duration < s_blockSizeTime)
|
|
return s_blockSizeTime;
|
|
else
|
|
return duration;
|
|
}
|
|
|
|
|
|
void EventTools::drawEvents(QPainter *painter, const EventGraphicList &eventGraphicList, const int verticalPosition )
|
|
{
|
|
painter->save();
|
|
|
|
|
|
painter->setClipping(true);
|
|
painter->setClipRect(QRect(s_paintMin, verticalPosition, s_paintDiff, s_sectionHeight));
|
|
|
|
|
|
for (int i = 0; i < eventGraphicList.count(); i++)
|
|
{
|
|
EventGraphic *eg = eventGraphicList.at(i);
|
|
|
|
if (!eg)
|
|
{
|
|
|
|
|
|
continue;
|
|
}
|
|
|
|
qint64 eventStart = eg->lowestTime();
|
|
|
|
if (eventStart == 0)
|
|
continue;
|
|
|
|
|
|
|
|
#ifdef VERBOSE
|
|
qWarning() << "\r\n\r\nEventTools::drawEvents" << "\r\n"
|
|
<< "eventStart" << eventStart << "\r\n";
|
|
#endif
|
|
|
|
qint64 eventDuration = eg->getDuration();
|
|
|
|
int newEventPosition = getEventPosition(eventStart);
|
|
|
|
int newEventEndPosition = 0;
|
|
int finalEventEndPos = 0;
|
|
|
|
int eventGraphicsWidth = eventWidth();
|
|
|
|
if (eventDuration > 1)
|
|
{
|
|
qint64 eventPosition = eventStart;
|
|
eventPosition += eventDuration;
|
|
newEventEndPosition = getEventPosition(eventPosition);
|
|
finalEventEndPos = GetEndPos(newEventEndPosition, eventGraphicsWidth);
|
|
}
|
|
else
|
|
{
|
|
newEventEndPosition = newEventPosition;
|
|
}
|
|
|
|
|
|
if (newEventPosition + (newEventEndPosition - newEventPosition) < ((-eventGraphicsWidth) + s_paintMin) ||
|
|
newEventPosition > (s_paintMin + s_paintDiff))
|
|
{
|
|
#ifdef VERBOSE
|
|
qWarning() << "\n\ndrawEvents: boundary check result was negative\n" <<
|
|
" newEventPosition=" << newEventPosition << "\n" <<
|
|
" newEventEndPosition=" << newEventPosition << "\n" <<
|
|
" eventGraphicsWidth=" << eventGraphicsWidth << "\n" <<
|
|
" s_paintMin=" << s_paintMin << "\n" <<
|
|
" s_paintDiff=" << s_paintDiff << "\n";
|
|
#endif
|
|
continue;
|
|
}
|
|
|
|
|
|
|
|
int finalEventPos = newEventPosition;
|
|
|
|
QRect eventGraphicRect(finalEventPos, verticalPosition + 2, eventGraphicsWidth, s_sectionHeight - 6);
|
|
|
|
|
|
|
|
eg->drawEventGraphic(painter, eventGraphicRect);
|
|
|
|
#ifdef VERBOSE
|
|
qWarning() << "drawEvents > actually draw an event at "
|
|
"x=" << eventGraphicRect.x() << " "
|
|
"y=" << eventGraphicRect.y() << " "
|
|
"eventStart=" << eventStart ;
|
|
#endif
|
|
|
|
if (eventDuration > 1 &&
|
|
(finalEventEndPos - 1) > finalEventPos)
|
|
{
|
|
QRect eventGraphicEndRect(finalEventEndPos, verticalPosition + 2, eventGraphicsWidth, s_sectionHeight - 6);
|
|
eg->drawEventGraphic(painter, eventGraphicEndRect);
|
|
|
|
|
|
|
|
QRect eventWholeRect(newEventPosition + (eventGraphicsWidth / 2)
|
|
|
|
, verticalPosition + 2
|
|
, (newEventEndPosition - newEventPosition) - (eventGraphicsWidth)
|
|
, s_sectionHeight - 6);
|
|
|
|
eg->drawDurationBackground(painter, eventWholeRect);
|
|
}
|
|
}
|
|
|
|
painter->restore();
|
|
}
|
|
|
|
}
|