bool DiagramScene::showGrid()
{
if(maxvaluey==minvaluey)
maxvaluey=minvaluey+10;
int split = 10;
qreal xsteps = (maxvaluey-minvaluey)/4;
QFont font;
font.setPointSizeF((maxvaluey-minvaluey)*2*(prec/100));
grid = new QGraphicsLineItem();
//mouseline
mouseline = new QGraphicsLineItem(minvaluex*prec,-minvaluey*prec,minvaluex*prec,-maxvaluey*prec);
addItem(mouseline);
QGraphicsLineItem *yline = new QGraphicsLineItem(minvaluex*prec,-maxvaluey*prec,minvaluex*prec,-minvaluey*prec,grid);
Q_UNUSED(yline);
qreal stepsize = (maxvaluey-minvaluey)/split;
//y-axe
for(qreal value=minvaluey + stepsize; value <= maxvaluey; value=value+stepsize)
{
QGraphicsSimpleTextItem *text = new QGraphicsSimpleTextItem ( QString::number(value*yscale), grid);
text->setPos((minvaluex*prec+(maxvaluey-minvaluey)/100)*prec,-value*prec);
text->setFont(font);
}
xaxes = new QGraphicsLineItem(grid);
//x-axe
QGraphicsLineItem *xline = new QGraphicsLineItem(minvaluex*prec,-minvaluey*prec,maxvaluex*prec,-minvaluey*prec,xaxes);
Q_UNUSED(xline);
for(qreal value=minvaluex; value < maxvaluex; value=value+xsteps)
{
QGraphicsSimpleTextItem *text = new QGraphicsSimpleTextItem ( QString::number(value), xaxes);
text->setFont(font);
qreal th = text->boundingRect().bottomLeft().y()-text->boundingRect().topLeft().y();
text->setPos(value*prec+(minvaluex+(maxvaluey-minvaluey)/100)*prec, -minvaluey*prec-th);
}
//draw legend
legend.clear();
for(int index=0; index < data.size(); index++)
{
legend.push_back(new QGraphicsSimpleTextItem (data.keys().at(index), mouseline));
legend[index]->setFont(font);
qreal th = legend[index]->boundingRect().bottomLeft().y()-legend[index]->boundingRect().topLeft().y();
QGraphicsRectItem *rect = new QGraphicsRectItem( (minvaluex*prec+((maxvaluey-minvaluey)/100)*3)*prec, -maxvaluey*prec + index*th*1.5 , th,th, mouseline);
QBrush brush( QColor(((index+1)*948)%200+50,((index+1)*123)%200+50,((index+1)*11)%200+50));
rect->setBrush(brush);
legend[index]->setPos((minvaluex*prec+((maxvaluey-minvaluey)/100)*8)*prec,-maxvaluey*prec + index*th*1.5 );
}
addItem(grid);
return true;
}
ModelItemGraphics::ModelItemGraphics(const QPointF& Coords, const QString& ID,
QGraphicsItem* Parent):
QGraphicsRectItem(Coords.x(),Coords.y(),m_DefaultSize.width(),m_DefaultSize.height(),Parent),
m_ID(ID), m_Ghost(false), m_Initialized(false)
{
setPen(QPen(QBrush(QColor(BUILDER_MODELVIEW_BORDERCOLOR)),2));
setFlag(QGraphicsItem::ItemIsMovable);
setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
setCursor(QCursor(Qt::OpenHandCursor));
// Model item ID
QGraphicsSimpleTextItem* IDGraphics = new QGraphicsSimpleTextItem(ID,Parent);
IDGraphics->setParentItem(this);
QFont TmpFont = IDGraphics->font();
TmpFont.setPointSize(10);
IDGraphics->setFont(TmpFont);
QRectF IDRect = IDGraphics->boundingRect();
if (rect().width() < IDRect.width()+20)
setRect(Coords.x(),Coords.y(),IDRect.width()+20,m_DefaultSize.height());
IDGraphics->setPos((rect().width()/2)-(IDRect.width()/2),(m_DefaultSize.height()/2)-(IDRect.height()/2));
}
void EffectItemBase::createText(const QString &text)
{
QGraphicsSimpleTextItem * textItem = new QGraphicsSimpleTextItem(text, this);
QFont font = textItem->font();
font.setPointSize(FontSize);
textItem->setFont(font);
QRectF textBox = textItem->boundingRect();
QPointF offset = rect().center() - textBox.center();
textItem->translate(offset.x(), offset.y());
}
void VisualMatrix::initSprite()
{
_sprite = new QGraphicsWidget();
QGraphicsItem* item;
QGraphicsWidget* widget;
QGraphicsRectItem* rect;
QGraphicsColorizeEffect* effect;
QGraphicsSimpleTextItem* text;
QGraphicsProxyWidget* proxy;
QLabel* label;
QFont font;
// Frame
{
item = new QGraphicsPixmapItem(LoaderThread::instance()->getCachedPixmap(IMAGE_FRAME_BG));
item->setParentItem(_sprite);
item->setPos(0.0f, 0.0f);
}
// Frame
{
item = new QGraphicsPixmapItem(LoaderThread::instance()->getCachedPixmap(IMAGE_FRAME_MG));
item->setParentItem(_sprite);
item->setPos(0.0f, 0.0f);
}
// Avatar
{
widget = new QGraphicsWidget();
widget->resize(BLOCK_LARGE * 10, BLOCK_LARGE * 20);
widget->setFlags(QGraphicsItem::ItemClipsChildrenToShape);
widget->setParentItem(_sprite);
widget->setPos(170.0f, 50.0f);
item = new QGraphicsPixmapItem();
item->setParentItem(widget);
item->setPos(((BLOCK_LARGE * 10) - (320.0f / 0.75f)) * 0.5f, (BLOCK_LARGE * 20) - 320.0f);
_avatar = widget;
}
// Help
{
widget = new QGraphicsWidget();
widget->resize(BLOCK_LARGE * 10, BLOCK_LARGE * 20);
widget->setFlags(QGraphicsItem::ItemClipsChildrenToShape);
widget->setParentItem(_sprite);
widget->setPos(170.0f, 50.0f);
rect = new QGraphicsRectItem(0.0f, 0.0f, BLOCK_LARGE * 10, BLOCK_LARGE * 20);
rect->setBrush(QBrush(QColor::fromRgb(0x00, 0x00, 0x00, 0xC0)));
rect->setParentItem(widget);
font = QApplication::font();
font.setFamily("Arial");
font.setPixelSize(16);
font.setWeight(QFont::Bold);
font.setStretch(80);
text = new QGraphicsSimpleTextItem(tr("Slide left and right: Move."));
text->setBrush(QColor::fromRgb(0xC0, 0xC0, 0xC0));
text->setFont(font);
text->setParentItem(widget);
text->setPos(((BLOCK_LARGE * 10) - text->boundingRect().width()) * 0.5f, 217.0f - 6.0f);
text = new QGraphicsSimpleTextItem(tr("Swipe up: Hold. Swipe down: Drop."));
text->setBrush(QColor::fromRgb(0xC0, 0xC0, 0xC0));
text->setFont(font);
text->setParentItem(widget);
text->setPos(((BLOCK_LARGE * 10) - text->boundingRect().width()) * 0.5f, 237.0f - 6.0f);
text = new QGraphicsSimpleTextItem(tr("Pull back, and make circles: Rotate."));
text->setBrush(QColor::fromRgb(0xC0, 0xC0, 0xC0));
text->setFont(font);
text->setParentItem(widget);
text->setPos(((BLOCK_LARGE * 10) - text->boundingRect().width()) * 0.5f, 257.0f - 6.0f);
// widget->setVisible(false);
_sprite_help = widget;
}
// Lines
{
rect = new QGraphicsRectItem(120.0f - 1.0f, 220.0f - 1.0f, 8.0f + 2.0f, 144.0f + 2.0f);
rect->setBrush(QBrush(LoaderThread::instance()->getCachedPixmap(IMAGE_LINES_PROGRESS)));
rect->setParentItem(_sprite);
_sprite_lines = rect;
}
// Frame
{
item = new QGraphicsPixmapItem(LoaderThread::instance()->getCachedPixmap(IMAGE_FRAME_FG));
item->setParentItem(_sprite);
item->setPos(0.0f, 0.0f);
}
// Field
{
widget = new QGraphicsWidget();
widget->resize(BLOCK_LARGE * 10, BLOCK_LARGE * 20);
widget->setFlags(QGraphicsItem::ItemClipsChildrenToShape);
widget->setParentItem(_sprite);
widget->setPos(170.0f, 50.0f);
_sprite_field = widget;
_sprite_space.fill(NULL, _rows * _cols);
}
// Ghost
{
widget = new QGraphicsWidget();
widget->resize(BLOCK_LARGE * 4, BLOCK_LARGE * 4);
widget->setParentItem(_sprite_field);
widget->setPos(BLOCK_LARGE * getShapePositionInField(18, 3));
for (int i = 0; i < 4; ++i)
{
item = new QGraphicsPixmapItem(LoaderThread::instance()->getCachedPixmap(IMAGE_BLOCK_GHOST));
item->setParentItem(widget);
}
_sprite_ghost = widget;
}
// Tetromino
{
widget = new QGraphicsWidget();
widget->resize(BLOCK_LARGE * 4, BLOCK_LARGE * 4);
widget->setParentItem(_sprite_field);
widget->setPos(BLOCK_LARGE * getShapePositionInField(18, 3));
widget->setZValue(1.0f);
effect = new QGraphicsColorizeEffect(widget);
effect->setColor(QColor::fromRgb(0xFF, 0xFF, 0xFF));
effect->setStrength(0.0f);
widget->setGraphicsEffect(effect);
for (int i = 0; i < 4; ++i)
{
item = new QGraphicsPixmapItem();
item->setParentItem(widget);
}
_sprite_tetromino = widget;
}
// Hold
{
widget = new QGraphicsWidget();
widget->resize(BLOCK_LARGE * 4, BLOCK_LARGE * 2);
widget->setScale(BLOCK_SMALL / BLOCK_LARGE);
widget->setParentItem(_sprite);
widget->setPos(56.0f, 108.0f + BLOCK_SMALL);
effect = new QGraphicsColorizeEffect(widget);
effect->setColor(QColor::fromRgb(0xFF, 0xFF, 0xFF));
effect->setStrength(0.0f);
widget->setGraphicsEffect(effect);
for (int i = 0; i < 4; ++i)
{
item = new QGraphicsPixmapItem();
item->setParentItem(widget);
}
_sprite_hold = widget;
}
// Hold fail
{
item = new QGraphicsPixmapItem(LoaderThread::instance()->getCachedPixmap(IMAGE_FAIL));
item->setScale(BLOCK_SMALL / BLOCK_LARGE);
item->setParentItem(_sprite);
item->setPos(56.0f + (BLOCK_SMALL * 3), 108.0f + (BLOCK_SMALL * 3));
item->setVisible(false);
_sprite_holdFail = item;
}
// Next
{
widget = new QGraphicsWidget();
widget->resize(BLOCK_LARGE * 4, BLOCK_LARGE * 2);
widget->setScale(BLOCK_SMALL / BLOCK_LARGE);
widget->setParentItem(_sprite);
widget->setPos(460.0f, 108.0f + BLOCK_SMALL);
effect = new QGraphicsColorizeEffect(widget);
effect->setColor(QColor::fromRgb(0xFF, 0xFF, 0xFF));
effect->setStrength(0.0f);
widget->setGraphicsEffect(effect);
for (int i = 0; i < 4; ++i)
{
item = new QGraphicsPixmapItem();
item->setParentItem(widget);
}
_sprite_next << widget;
}
// Next
{
widget = new QGraphicsWidget();
widget->resize(BLOCK_LARGE * 4, BLOCK_LARGE * 2);
widget->setScale(BLOCK_SMALL / BLOCK_LARGE);
widget->setParentItem(_sprite);
widget->setPos(460.0f, 228.0f + BLOCK_SMALL);
effect = new QGraphicsColorizeEffect(widget);
effect->setColor(QColor::fromRgb(0xFF, 0xFF, 0xFF));
effect->setStrength(0.0f);
widget->setGraphicsEffect(effect);
for (int i = 0; i < 4; ++i)
{
item = new QGraphicsPixmapItem();
item->setParentItem(widget);
}
_sprite_next << widget;
}
// Next
{
widget = new QGraphicsWidget();
widget->resize(BLOCK_LARGE * 4, BLOCK_LARGE * 2);
widget->setScale(BLOCK_SMALL / BLOCK_LARGE);
widget->setParentItem(_sprite);
widget->setPos(460.0f, 292.0f + BLOCK_SMALL);
effect = new QGraphicsColorizeEffect(widget);
effect->setColor(QColor::fromRgb(0xFF, 0xFF, 0xFF));
effect->setStrength(0.0f);
widget->setGraphicsEffect(effect);
for (int i = 0; i < 4; ++i)
{
item = new QGraphicsPixmapItem();
item->setParentItem(widget);
}
_sprite_next << widget;
}
// Font
{
font = QApplication::font();
font.setCapitalization(QFont::AllUppercase);
}
// Hold
{
text = new QGraphicsSimpleTextItem(tr("Hold"));
text->setBrush(QColor::fromRgb(0x00, 0x00, 0x00));
text->setFont(font);
text->setParentItem(_sprite);
text->setPos(56.0f, 80.0f - 6.0f);
}
// Next
{
text = new QGraphicsSimpleTextItem(tr("Next"));
text->setBrush(QColor::fromRgb(0x00, 0x00, 0x00));
text->setFont(font);
text->setParentItem(_sprite);
text->setPos(526.0f - text->boundingRect().width(), 80.0f - 6.0f);
}
// Level
{
text = new QGraphicsSimpleTextItem(tr("Level"));
text->setBrush(QColor::fromRgb(0x00, 0x00, 0x00));
text->setFont(font);
text->setParentItem(_sprite);
text->setPos(56.0f, 316.0f - 6.0f);
}
// Level
{
label = new QLabel();
label->resize(48, 24);
label->setStyleSheet("background-color: transparent; color: #FFFFFF;");
label->setAlignment(Qt::AlignTop | Qt::AlignLeft);
proxy = new QGraphicsProxyWidget();
proxy->setParentItem(_sprite);
proxy->setWidget(label);
proxy->setPos(56.0f, 344.0f - 6.0f);
_sprite_level = label;
}
// Score
{
text = new QGraphicsSimpleTextItem(tr("Score"));
text->setBrush(QColor::fromRgb(0x00, 0x00, 0x00));
text->setFont(font);
text->setParentItem(_sprite);
text->setPos(176.0f, 564.0f - 6.0f);
}
// Score
{
label = new QLabel();
label->resize(148, 24);
label->setStyleSheet("background-color: transparent; color: #FFFFFF;");
label->setAlignment(Qt::AlignTop | Qt::AlignRight);
proxy = new QGraphicsProxyWidget();
proxy->setParentItem(_sprite);
proxy->setWidget(label);
proxy->setPos(256.0f, 564.0f - 6.0f);
_sprite_score = label;
}
// Countdown
{
widget = new QGraphicsWidget();
widget->resize(BLOCK_LARGE * 10, BLOCK_LARGE * 20);
widget->setFlags(QGraphicsItem::ItemClipsChildrenToShape);
widget->setParentItem(_sprite);
widget->setPos(170.0f, 50.0f);
rect = new QGraphicsRectItem(0.0f, 0.0f, BLOCK_LARGE * 10, BLOCK_LARGE * 20);
rect->setBrush(QBrush(QColor::fromRgb(0x00, 0x00, 0x00, 0xC0)));
rect->setParentItem(widget);
item = new QGraphicsPixmapItem(LoaderThread::instance()->getCachedPixmap(IMAGE_COUNT[0]));
item->setParentItem(widget);
item->setPos(77.0f, 197.0f);
item->setVisible(false);
_sprite_count << item;
item = new QGraphicsPixmapItem(LoaderThread::instance()->getCachedPixmap(IMAGE_COUNT[1]));
item->setParentItem(widget);
item->setPos(77.0f, 197.0f);
item->setVisible(false);
_sprite_count << item;
item = new QGraphicsPixmapItem(LoaderThread::instance()->getCachedPixmap(IMAGE_COUNT[2]));
item->setParentItem(widget);
item->setPos(77.0f, 197.0f);
item->setVisible(false);
_sprite_count << item;
widget->setVisible(false);
_sprite_countdown = widget;
}
// Game over
{
widget = new QGraphicsWidget();
widget->resize(BLOCK_LARGE * 10, BLOCK_LARGE * 20);
widget->setFlags(QGraphicsItem::ItemClipsChildrenToShape);
widget->setParentItem(_sprite);
widget->setPos(170.0f, 50.0f);
widget->setZValue(8.0f);
rect = new QGraphicsRectItem(0.0f, 0.0f, BLOCK_LARGE * 10, BLOCK_LARGE * 20);
rect->setBrush(QBrush(QColor::fromRgb(0x00, 0x00, 0x00, 0xC0)));
rect->setParentItem(widget);
item = new QGraphicsPixmapItem(LoaderThread::instance()->getCachedPixmap(IMAGE_OVER));
item->setParentItem(widget);
item->setPos(4.0f, 172.0f);
rect = new QGraphicsRectItem(0.0f, 0.0f, BLOCK_LARGE * 10, BLOCK_LARGE * 20);
rect->setBrush(QBrush(QColor::fromRgb(0xFF, 0xFF, 0xFF)));
rect->setParentItem(widget);
_sprite_overFlash = rect;
widget->setVisible(false);
_sprite_over = widget;
}
}
CalendarGraphicsItem::CalendarGraphicsItem(CalendarControl * cc, QGraphicsItem * parent)
: QGraphicsRectItem(0.0, 0.0, __width, __height, parent)
{
_controller = cc;
QDate today = QDate::currentDate();
QDate firstMonthDay = QDate(today.year(), today.month(), 1);
QDate firstCalendarDay = firstMonthDay.addDays(firstMonthDay.dayOfWeek() * -1);
if(firstMonthDay.dayOfWeek() < 2)
firstCalendarDay = firstCalendarDay.addDays(-7);
_selectedDay = today;
QString prev = QObject::tr("<");
QString prevprev = QObject::tr("<<");
QString next = QObject::tr(">");
QString nextnext = QObject::tr(">>");
QGraphicsSimpleTextItem * textItem;
QGraphicsRectItem * rectItem;
rectItem = new QGraphicsRectItem(0.0, 0.0, __width, __titleHeight, this);
rectItem->setBrush(blackFill);
_items.insert("titleBackground", rectItem);
textItem = new QGraphicsSimpleTextItem(today.toString("MMMM yyyy"), this);
textItem->setFont(monthfont);
textItem->setZValue(2);
textItem->setBrush(whiteFill);
QPointF ct = rectItem->boundingRect().center();
QRectF rt = textItem->boundingRect();
textItem->setPos(ct.x() - (rt.width() / 2),
ct.y() - (rt.height() / 2));
_items.insert("title", textItem);
qreal offset = 0.1 * __dpi;
qreal nw = 0;
GraphicsTextButtonItem * tbtnItem = 0;
tbtnItem = new GraphicsTextButtonItem(prevprev, this);
tbtnItem->setFont(navfont);
tbtnItem->setZValue(3);
tbtnItem->setBrush(Qt::lightGray);
tbtnItem->setRolloverBrush(Qt::green);
tbtnItem->scale(0.5, 1);
tbtnItem->setReceiver(this);
rt = tbtnItem->boundingRect();
tbtnItem->setPos(offset, ct.y() - (rt.height() / 2));
nw = rt.width();
_items.insert("fastrewind", tbtnItem);
tbtnItem = new GraphicsTextButtonItem(nextnext, this);
tbtnItem->setFont(navfont);
tbtnItem->setZValue(3);
tbtnItem->setBrush(Qt::lightGray);
tbtnItem->setRolloverBrush(Qt::green);
tbtnItem->scale(0.5, 1);
tbtnItem->setReceiver(this);
rt = tbtnItem->boundingRect();
tbtnItem->setPos(rectItem->boundingRect().right() - offset - (rt.width() / 2), ct.y() - (rt.height() / 2));
nw = qMax(nw, rt.width()) / 2;
offset += (nw * 1.5);
_items.insert("fastforward", tbtnItem);
tbtnItem = new GraphicsTextButtonItem(prev, this);
tbtnItem->setFont(navfont);
tbtnItem->setZValue(3);
tbtnItem->setBrush(Qt::lightGray);
tbtnItem->setRolloverBrush(Qt::green);
tbtnItem->scale(0.5, 1);
tbtnItem->setReceiver(this);
rt = tbtnItem->boundingRect();
tbtnItem->setPos(offset, ct.y() - (rt.height() / 2));
_items.insert("rewind", tbtnItem);
tbtnItem = new GraphicsTextButtonItem(next, this);
tbtnItem->setFont(navfont);
tbtnItem->setZValue(3);
tbtnItem->setBrush(Qt::lightGray);
tbtnItem->setRolloverBrush(Qt::green);
tbtnItem->scale(0.5, 1);
tbtnItem->setReceiver(this);
rt = tbtnItem->boundingRect();
tbtnItem->setPos(rectItem->boundingRect().right() - offset - (rt.width() / 2), ct.y() - (rt.height() / 2));
_items.insert("forward", tbtnItem);
QDate date;
qreal dayWidth = __width / 7.0;
QApplication::setOverrideCursor(Qt::WaitCursor);
for(int wday = 0; wday < 7; wday++)
{
for(int week = 0; week < 6; week++)
{
date = firstCalendarDay.addDays((7 * week) + wday);
if(0 == week)
{
rectItem = new QGraphicsRectItem(wday * dayWidth, 0.5 * __dpi, dayWidth, 0.25 * __dpi, this);
_items.insert(QString("weekday%1").arg(week), rectItem);
textItem = new QGraphicsSimpleTextItem(date.toString("dddd"), this);
textItem->setFont(wdayfont);
textItem->setZValue(2);
ct = rectItem->boundingRect().center();
rt = textItem->boundingRect();
textItem->setPos(ct.x() - (rt.width() / 2),
ct.y() - (rt.height() / 2));
_items.insert(QString("weekday%1Text").arg(week), textItem);
}
QBrush fill;
QBrush dayFill = blackFill;
if(date == _selectedDay)
fill = selectedFill;
else if(date.month() != today.month())
{
fill = nonMonthFill;
dayFill = nonMonthDayFill;
}
else if(date == today)
fill = todayFill;
else if(date.dayOfWeek() > 5)
fill = weekendFill;
rectItem = new QGraphicsRectItem(wday * dayWidth, (0.75 + (1.25 * week)) * __dpi, dayWidth, 1.25 * __dpi, this);
rectItem->setBrush(fill);
_items.insert(QString("day%1").arg((7 * week) + wday), rectItem);
rt = QRectF(rectItem->pos(), rectItem->boundingRect().size());
double offset = rt.width() / 3;
textItem = new QGraphicsSimpleTextItem(QString::number(date.day()), this);
textItem->setFont(dayfont);
textItem->setZValue(2);
textItem->setBrush(dayFill);
textItem->setPos(rectItem->boundingRect().topLeft());
textItem->moveBy(5.0, 5.0);
_items.insert(QString("day%1Number").arg((7 * week) + wday), textItem);
rt = QRectF(textItem->pos(), textItem->boundingRect().size());
QString additionalText;
if(_controller)
additionalText = _controller->contents(date);
textItem = new QGraphicsSimpleTextItem(additionalText, this);
textItem->setFont(notesfont);
textItem->setZValue(2);
textItem->setBrush(dayFill);
textItem->setPos(rt.left() + offset,
rt.top() + (rt.height() * 1.5));
_items.insert(QString("day%1Text").arg((7 * week) + wday), textItem);
}
}
QApplication::restoreOverrideCursor();
}
void CalendarGraphicsItem::setSelectedDay(const QDate & sDate)
{
//if(sDate == _selectedDay)
// return;
_selectedDay = sDate;
QDate today = QDate::currentDate();
QDate firstMonthDay = QDate(_selectedDay.year(), _selectedDay.month(), 1);
QDate firstCalendarDay = firstMonthDay.addDays(firstMonthDay.dayOfWeek() * -1);
if(firstMonthDay.dayOfWeek() < 2)
firstCalendarDay = firstCalendarDay.addDays(-7);
QGraphicsRectItem * titleBackground = static_cast<QGraphicsRectItem*>(_items["titleBackground"]);
QGraphicsSimpleTextItem * title = static_cast<QGraphicsSimpleTextItem*>(_items["title"]);
if(title && titleBackground)
{
title->setText(_selectedDay.toString("MMMM yyyy"));
QPointF ct = titleBackground->boundingRect().center();
QRectF rt = title->boundingRect();
title->setPos(ct.x() - (rt.width() / 2),
ct.y() - (rt.height() / 2));
}
QDate date;
QApplication::setOverrideCursor(Qt::WaitCursor);
for(int wday = 0; wday < 42; wday++)
{
date = firstCalendarDay.addDays(wday);
QBrush fill;
QBrush dayFill = blackFill;
if(date == _selectedDay)
fill = selectedFill;
else if(date.month() != _selectedDay.month())
{
fill = nonMonthFill;
dayFill = nonMonthDayFill;
}
else if(date == today)
fill = todayFill;
else if(date.dayOfWeek() > 5)
fill = weekendFill;
QString additionalText;
if(_controller)
additionalText = _controller->contents(date);
QGraphicsRectItem * ri = static_cast<QGraphicsRectItem*>(_items[QString("day%1").arg(wday)]);
if(ri)
ri->setBrush(fill);
QGraphicsSimpleTextItem * si = static_cast<QGraphicsSimpleTextItem*>(_items[QString("day%1Number").arg(wday)]);
if(si)
{
si->setText(QString::number(date.day()));
si->setBrush(dayFill);
}
QGraphicsSimpleTextItem * si2 = static_cast<QGraphicsSimpleTextItem*>(_items[QString("day%1Text").arg(wday)]);
if(si2)
{
si2->setText(additionalText);
si2->setBrush(dayFill);
}
}
QApplication::restoreOverrideCursor();
if(_controller)
_controller->setSelectedDay(_selectedDay);
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow),
_axis_len(97),_inertial_len(150)
{
ui->setupUi(this);
// Model
_model = new QStandardItemModel(5,3,parent);
_idx_seq1 = _model->index(0,0);
_idx_seq2 = _model->index(0,1);
_idx_seq3 = _model->index(0,2);
_idx_ang1 = _model->index(1,0);
_idx_ang2 = _model->index(1,1);
_idx_ang3 = _model->index(1,2);
_model->setData(_idx_seq1,QString("Roll"));
_model->setData(_idx_seq2,QString("Pitch"));
_model->setData(_idx_seq3,QString("Yaw"));
_model->setHeaderData(0,
Qt::Horizontal,
_model->data(_idx_seq1).toString());
_model->setHeaderData(1,
Qt::Horizontal,
_model->data(_idx_seq2).toString());
_model->setHeaderData(2,
Qt::Horizontal,
_model->data(_idx_seq3).toString());
_model->setData(_idx_ang1,0.0);
_model->setData(_idx_ang2,0.0);
_model->setData(_idx_ang3,0.0);
for ( int ii = 0 ; ii < 3 ; ii++ ) {
for ( int jj = 0 ; jj < 3 ; jj++ ) {
QModelIndex idx = _model->index(ii+2,jj);
qreal val = _mat(ii,jj);
_model->setData(idx,val);
}
}
// Minimum size policy ( i don't care about growing)
QSizePolicy size_policy_min(QSizePolicy::Minimum, QSizePolicy::Minimum);
QSizePolicy size_policy_fixed(QSizePolicy::Fixed,
QSizePolicy::Fixed);
// Sequence view
_sequenceview = new QTableView(parent);
_sequenceview->setModel(_model);
_sequenceview->verticalHeader()->setVisible(false);
_sequenceview->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
_sequenceview->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
_sequenceview->horizontalHeader()->setMovable(true);
for ( int ii = 0 ; ii < 6; ii++ ) {
_sequenceview->setRowHidden(ii,true);
}
_sequenceview->setRowHidden(1,false);
// Matrix view
_matrixview = new QTableView(parent);
_matrixview->setModel(_model);
_matrixview->horizontalHeader()->setVisible(false);
_matrixview->verticalHeader()->setVisible(false);
_matrixview->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
_matrixview->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
_matrixview->setRowHidden(0,true);
_matrixview->setRowHidden(1,true);
// Scene view
_scene = new QGraphicsScene(parent);
_scene->setBackgroundBrush(QBrush(Qt::white));
_gview = new QGraphicsView(_scene);
_gview->setRenderHint(QPainter::Antialiasing);
_gview->horizontalScrollBar()->setVisible(false);
_gview->verticalScrollBar()->setVisible(false);
_gview->setViewportUpdateMode(QGraphicsView::FullViewportUpdate);
_xinertial = new QGraphicsLineItem(QLine(QPoint(0,0),
QPoint(_inertial_len,0)));
_scene->addItem(_xinertial);
QGraphicsSimpleTextItem* xlabel = new
QGraphicsSimpleTextItem(QString("x"));
_scene->addItem(xlabel);
QRectF bb = xlabel->boundingRect();
xlabel->setPos(_inertial_len+10,-bb.height()/2.0);
_yinertial = new QGraphicsLineItem(QLine(QPoint(0,0),
QPoint(0,-_inertial_len)));
_scene->addItem(_yinertial);
QGraphicsSimpleTextItem* ylabel = new QGraphicsSimpleTextItem(QString("y"));
_scene->addItem(ylabel);
bb = ylabel->boundingRect();
ylabel->setPos(-bb.width()/2.0,-_inertial_len-10-bb.height()/2.0 );
_xitem = new QGraphicsLineItem(QLine(QPoint(0,0),QPoint(_axis_len,0)));
QPen xpen(Qt::red);
xpen.setWidth(6);
_xitem->setPen(xpen);
_yitem = new QGraphicsLineItem(QLine(QPoint(0,0),QPoint(0,-_axis_len)));
QPen ypen(Qt::green);
ypen.setWidth(6);
_yitem->setPen(ypen);
_zitem = new QGraphicsLineItem(QLine(QPoint(0,0),QPoint(0,0)));
QPen zpen(Qt::blue);
zpen.setWidth(6);
_zitem->setPen(zpen);
QGraphicsEllipseItem* ell = new QGraphicsEllipseItem(
-100,-100,200,200);
_scene->addItem(_xitem);
_scene->addItem(_yitem);
_scene->addItem(_zitem);
_scene->addItem(ell);
QPointF center = _scene->itemsBoundingRect().center();
_gview->centerOn(center);
// Connect
connect(_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)),
this,SLOT(_slot_model_data_changed(QModelIndex,QModelIndex)));
//
// Widget Layout
//
QWidget *mainwidget = new QWidget;
setCentralWidget(mainwidget);
setWindowTitle(tr("Euler"));
setUnifiedTitleAndToolBarOnMac(true);
QHBoxLayout *mainlayout = new QHBoxLayout;
QVBoxLayout *leftbox = new QVBoxLayout;
leftbox->addWidget(_sequenceview);
leftbox->addWidget(_matrixview);
mainlayout->addLayout(leftbox);
mainlayout->addWidget(_gview);
mainwidget->setLayout(mainlayout);
}
void TerrainProfileGraph::drawHoverCursor(const QPointF& position)
{
if (_hoverLine)
{
_scene->removeItem(_hoverLine);
delete _hoverLine;
_hoverLine = 0L;
}
if (_graphField.width() < 2 || _graphField.height() < 2)
return;
double xPos = position.x() < _graphField.x() ? _graphField.x() : (position.x() > _graphField.x() + _graphField.width() ? _graphField.x() + _graphField.width() : position.x());
QLineF vLine(xPos, _graphField.y(), xPos, _graphField.y() + _graphField.height());
QPointF* intersect = new QPointF;
bool foundIntersect = false;
for (int i=0; i < _graphLines.count(); i++)
{
if (vLine.intersect(_graphLines[i], intersect) == QLineF::BoundedIntersection)
{
foundIntersect = true;
break;
}
}
if (foundIntersect)
{
// Draw the upper line segment. Also serves as the parent item.
_hoverLine = new QGraphicsLineItem(xPos, _graphField.y(), xPos, intersect->y() - 3);
_hoverLine->setPen(_hoverPen);
_hoverLine->setZValue(OVERLAY_Z);
_scene->addItem(_hoverLine);
// Draw the box around the intersect point
QGraphicsRectItem* hoverBox = new QGraphicsRectItem(xPos - 3, intersect->y() - 3, 6, 6);
hoverBox->setPen(_hoverPen);
hoverBox->setBrush(Qt::NoBrush);
hoverBox->setZValue(OVERLAY_Z);
hoverBox->setParentItem(_hoverLine);
// Draw the lower line segment
QGraphicsLineItem* lowerLine = new QGraphicsLineItem(xPos, intersect->y() + 3, xPos, _graphField.y() + _graphField.height() + 5);
lowerLine->setPen(_hoverPen);
lowerLine->setZValue(OVERLAY_Z);
lowerLine->setParentItem(_hoverLine);
// Draw the text and background
double y = (1.0 - ((intersect->y() - _graphField.y()) / _graphField.height())) * (_graphMaxY - _graphMinY) + _graphMinY;
int textOffset = 10;
QGraphicsSimpleTextItem* hoverText = new QGraphicsSimpleTextItem(QString::number(y) + tr("m"));
hoverText->setBrush(QBrush(_axesColor));
hoverText->setFont(_graphFont);
hoverText->setZValue(OVERLAY_Z);
if (intersect->x() + textOffset + hoverText->boundingRect().width() < _graphField.x() + _graphField.width())
hoverText->setPos(intersect->x() + textOffset, intersect->y() - hoverText->boundingRect().height());
else
hoverText->setPos(intersect->x() - textOffset - hoverText->boundingRect().width(), intersect->y() - hoverText->boundingRect().height());
QGraphicsRectItem* hoverTextBackground = new QGraphicsRectItem(hoverText->x() - 3, hoverText->y() - 1,
hoverText->boundingRect().width() + 6,
hoverText->boundingRect().height() + 1);
hoverTextBackground->setPen(_axesPen);
hoverTextBackground->setBrush(QBrush(_graphColor));
hoverTextBackground->setZValue(OVERLAY_Z);
hoverTextBackground->setParentItem(_hoverLine);
hoverText->setParentItem(_hoverLine);
// Update callback
if (_positionCallback.valid())
{
double distanceFactor = ((xPos - _graphField.x()) / (double)_graphField.width());
osg::Vec3d worldStart, worldEnd;
_calculator->getStart(ALTMODE_ABSOLUTE).toWorld(worldStart);
_calculator->getEnd(ALTMODE_ABSOLUTE).toWorld(worldEnd);
double worldX = (worldEnd.x() - worldStart.x()) * distanceFactor + worldStart.x();
double worldY = (worldEnd.y() - worldStart.y()) * distanceFactor + worldStart.y();
double worldZ = (worldEnd.z() - worldStart.z()) * distanceFactor + worldStart.z();
GeoPoint mapPos;
mapPos.fromWorld(_calculator->getStart().getSRS(), osg::Vec3d(worldX, worldY, worldZ));
_positionCallback->updatePosition(mapPos.y(), mapPos.x(), hoverText->text().toStdString());
}
}
else
{
// No intersect found so just draw the full line at xPos
_hoverLine = new QGraphicsLineItem(xPos, _graphField.y(), xPos, _graphField.y() + _graphField.height() + 5);
_hoverLine->setPen(_hoverPen);
_hoverLine->setZValue(OVERLAY_Z);
_scene->addItem(_hoverLine);
}
// Draw distance text
double x = ((xPos - _graphField.x()) / _graphField.width()) * _totalDistance;
BoxedSimpleTextItem* distanceText = new BoxedSimpleTextItem(QString::number(x / 1000.0, 'f', 2) + tr("km"), _backgroundColor);
distanceText->setBrush(QBrush(_axesColor));
distanceText->setFont(_graphFont);
distanceText->setZValue(OVERLAY_Z);
if(xPos - 2 - distanceText->boundingRect().width() > _graphField.x())
{
distanceText->setPos(xPos - 2 - distanceText->boundingRect().width(), _graphField.y() + _graphField.height() + 2);
}
else
{
distanceText->setPos(xPos + 2, _graphField.y() + _graphField.height() + 2);
}
distanceText->setParentItem(_hoverLine);
// Draw selection box
drawSelectionBox(xPos);
delete intersect;
}
void TerrainProfileGraph::drawAxes(double yMin, double yMax, double yScale, double xMax, QRect &out_field)
{
QBrush axesBrush(_axesColor);
// Create min/max text items
QGraphicsSimpleTextItem* yMinText = new QGraphicsSimpleTextItem(QString::number(yMin));
yMinText->setBrush(axesBrush);
yMinText->setFont(_graphFont);
QGraphicsSimpleTextItem* yMaxText = new QGraphicsSimpleTextItem(QString::number(yMax));
yMaxText->setBrush(axesBrush);
yMaxText->setFont(_graphFont);
QGraphicsSimpleTextItem* xMaxText = new QGraphicsSimpleTextItem(QString::number(xMax));
xMaxText->setBrush(axesBrush);
xMaxText->setFont(_graphFont);
// Calculate positioning offsets and set out_field to actual graph bounds
double fontHalfHeight = yMinText->boundingRect().height() / 2.0;
int textSpacing = 8;
int xOffset = (int)osg::maximum(yMinText->boundingRect().width(), yMaxText->boundingRect().width()) + textSpacing;
int yOffset = (int)xMaxText->boundingRect().height() + textSpacing;
int xAxisY = _graphHeight - yOffset;
out_field.setCoords(xOffset, (int)fontHalfHeight, _graphWidth, xAxisY);
// Draw background rectangle
_scene->addRect(out_field, QPen(Qt::NoPen), QBrush(_fieldColor))->setZValue(FIELD_Z);
// Add min/max text items to the scene
yMinText->setPos(xOffset - textSpacing - yMinText->boundingRect().width(), xAxisY - fontHalfHeight);
yMinText->setZValue(AXES_Z);
_scene->addItem(yMinText);
yMaxText->setPos(xOffset - textSpacing - yMaxText->boundingRect().width(), 0);
yMaxText->setZValue(AXES_Z);
_scene->addItem(yMaxText);
xMaxText->setPos(_graphWidth - xMaxText->boundingRect().width(), _graphHeight - xMaxText->boundingRect().height());
xMaxText->setZValue(AXES_Z);
_scene->addItem(xMaxText);
// Draw the main axes and x-axis end cap
_scene->addLine(xOffset, fontHalfHeight, xOffset, xAxisY + 5, _axesPen)->setZValue(AXES_Z);
_scene->addLine(xOffset - 5, xAxisY, _graphWidth, xAxisY, _axesPen)->setZValue(AXES_Z);
_scene->addLine(_graphWidth, xAxisY - 5, _graphWidth, xAxisY + 5, _axesPen)->setZValue(AXES_Z);
// Draw horizontal graph lines
double yGraphScale = (yScale / (yMax - yMin)) * out_field.height();
double graphLineY = xAxisY - yGraphScale;
for (double y = yMin + yScale; y <= yMax; y += yScale)
{
_scene->addLine(xOffset - 5, graphLineY, _graphWidth, graphLineY, _axesPen)->setZValue(AXES_Z);;
if (y != yMax)
{
QGraphicsSimpleTextItem* yText = new QGraphicsSimpleTextItem(QString::number(y));
yText->setBrush(axesBrush);
yText->setFont(_graphFont);
yText->setPos(xOffset - textSpacing - yText->boundingRect().width(), graphLineY - fontHalfHeight);
yText->setZValue(AXES_Z);
_scene->addItem(yText);
}
graphLineY -= yGraphScale;
}
}
void ScheduleScreen::createScheduleScene()
{
QPen pen(Qt::blue);
QBrush brush(Qt::black);
QFont font = this->font();
font.setBold(true);
QFontMetrics fm(font);
weekHeight = (scene->height()/7.0)-(scene->height()*.025);
pointArea.setRect(fm.boundingRect("Wed").width()+20, 15, scene->width(), weekHeight*7);
timeWidth = ((pointArea.width() - pointArea.left())/4.0)-((pointArea.width() - pointArea.left())/4.0)/16;
timeBlockWidth = timeWidth/24.0; //15 min increments
pointArea.adjust(0,0,-timeBlockWidth, 0);
QDate date = QDate::fromString("Sun", "ddd");
for(int a = 0;a<7;a++)
{
pen.setColor(QColor(110+40*(a%2),110+40*(a%2),110+40*(a%2)));
brush.setColor(QColor(120+40*(a%2),120+40*(a%2),120+40*(a%2)));
scene->addRect(0,pointArea.top()+a*weekHeight,pointArea.width(),weekHeight, pen, brush);
pen.setColor(QColor(150,150,150));
brush.setColor(QColor(180,180,180));
scene->addRect(0,pointArea.top()+a*weekHeight,pointArea.left(),weekHeight-1, pen, brush);
date = date.addDays(1);
QString dateString = date.toString("ddd");
pen.setColor(QColor(50,50,50));
QPushButton* b = new QPushButton;
connect(b, SIGNAL(clicked(bool)), this, SLOT(disableRow(bool)));
b->setFlat(true);
b->setFont(font);
b->setFocusPolicy(Qt::NoFocus);
b->setMaximumWidth(pointArea.left()-4);
b->setMaximumHeight(weekHeight-4);
QPalette buttonPalette(QColor(180,180,180));
//buttonPalette.setColor(QPalette::Active, QPalette::Button, QColor(180,180,180));
b->setPalette(buttonPalette);
b->setCheckable(true);
b->setChecked(true);
b->setText(dateString);
b->setProperty("dayNumber", date.dayOfWeek()-1);
QGraphicsProxyWidget* textItem = new QGraphicsProxyWidget;
textItem->setWidget(b);
scene->addItem(textItem);
textItem->setPos(pointArea.left()/2 - textItem->boundingRect().width()/2, pointArea.top()+ a*weekHeight + weekHeight/2 - textItem->boundingRect().height()/2);
}
scene->addLine(pointArea.left(), pointArea.top()+1, pointArea.left(), scene->height()-1);
for(int a = 0;a<5;a++)
{
pen.setColor(QColor(110+40*(a%2),110+40*(a%2),110+40*(a%2)));
brush.setColor(QColor(120+40*(a%2),120+40*(a%2),120+40*(a%2)));
QString timeString = formatHourString(QTime(((a)*6)%24,0), m_globalSettings->timeFormat());
pen.setColor(QColor(200,200,200));
brush.setColor(QColor(200,200,200));
QGraphicsSimpleTextItem* textItem = scene->addSimpleText(timeString, font);
textItem->setBrush(brush);
textItem->setPos(timeBlockWidth*3+pointArea.left()+timeWidth*a - textItem->boundingRect().width()/2, pointArea.bottom() +6);
pen.setColor(QColor(188,188,188));
pen.setStyle(Qt::DashLine);
scene->addLine(timeBlockWidth*3+pointArea.left()+timeWidth*a, pointArea.top()+1, timeBlockWidth*3+pointArea.left()+timeWidth*a, pointArea.bottom()+3, pen);
}
}
GraphicsPortItem::GraphicsPortItem(GraphicsClientItemsClient *client_, const QString &fullPortName_, int style_, QFont font_, int padding, QGraphicsItem *parent) :
QGraphicsPathItem(parent),
client(client_),
fullPortName(fullPortName_),
shortPortName(fullPortName.split(":")[1]),
dataType(client->getPortType(fullPortName)),
isInput(client->getPortFlags(fullPortName) & JackPortIsInput),
style(style_),
font(font_),
showMenu(false)
{
bool gradient = false;
QColor captionColor(0xfc, 0xf9, 0xc2);
setPen(QPen(QBrush(Qt::black), 2));
setBrush(QBrush(captionColor));
setFlags(QGraphicsItem::ItemSendsScenePositionChanges);
setCursor(Qt::ArrowCursor);
font.setStyleStrategy(QFont::PreferAntialias);
QFontMetrics fontMetrics(font);
int portPadding = padding;
QGraphicsSimpleTextItem *portTextItem = new QGraphicsSimpleTextItem(shortPortName, this);
portTextItem->setFont(font);
portTextItem->setPos(portPadding, 0);
portRect = portTextItem->boundingRect().adjusted(-portPadding, -portPadding, portPadding, portPadding).translated(portTextItem->pos());
QPainterPath portPath;
if (style == 0) {
portPath = portPath.united(EllipsePath(portRect));
} else if (style == 1) {
portPath = portPath.united(SpeechBubblePath(portRect, portRect.height() / 4, portRect.height() / 4, Qt::AbsoluteSize));
} else if (style == 2) {
portPath = portPath.united(RoundedRectanglePath(portRect, portPadding + fontMetrics.height() / 2, portPadding + fontMetrics.height() / 2));
} else if (style == 3) {
portPath = portPath.united(RectanglePath(portRect));
}
setPath(portPath);
// register the port registration callback at the jack server:
QObject::connect(client, SIGNAL(portRegistered(QString,QString,int)), this, SLOT(onPortRegistered(QString,QString,int)), Qt::QueuedConnection);
QObject::connect(client, SIGNAL(portUnregistered(QString,QString,int)), this, SLOT(onPortUnregistered(QString,QString,int)), Qt::QueuedConnection);
QObject::connect(client, SIGNAL(portConnected(QString,QString)), this, SLOT(onPortConnected(QString,QString)), Qt::QueuedConnection);
QObject::connect(client, SIGNAL(portDisconnected(QString,QString)), this, SLOT(onPortDisconnected(QString,QString)), Qt::QueuedConnection);
if (gradient) {
QLinearGradient gradient(portRect.topLeft(), portRect.bottomRight());
gradient.setColorAt(0, Qt::white);
gradient.setColorAt(1, QColor("wheat"));
setBrush(QBrush(gradient));
}
// create the context menu:
connectMenu = contextMenu.addMenu("Connect");
disconnectMenu = contextMenu.addMenu("Disconnect");
// create the entries in connect- and disconnect-menus, as well as graphical representations of existing connections:
QStringList connectedPorts = client->getConnectedPorts(fullPortName);
QSet<QString> connectedPortsSet;
for (int i = 0; i < connectedPorts.size(); i++) {
// create an entry in the disconnect-menu:
QAction *action = disconnectMenu->addAction(connectedPorts[i]);
action->setData(connectedPorts[i]);
QObject::connect(action, SIGNAL(triggered()), this, SLOT(onDisconnectAction()));
mapPortNamesToActions[connectedPorts[i]] = action;
connectedPortsSet.insert(connectedPorts[i]);
// create a graphical representation of the connection:
if (isInput) {
client->getPortConnectionItem(connectedPorts[i], fullPortName)->setPos(fullPortName, getConnectionScenePos());
} else {
client->getPortConnectionItem(fullPortName, connectedPorts[i])->setPos(fullPortName, getConnectionScenePos());
}
}
// get all available ports that can be connected to this:
QStringList connectablePorts = client->getPorts(0, dataType.toAscii().data(), isInput ? JackPortIsOutput : JackPortIsInput);
for (int i = 0; i < connectablePorts.size(); i++) {
// skip ports that are already connected:
if (!connectedPortsSet.contains(connectablePorts[i])) {
// create an entry in the connect-menu:
QAction *action = connectMenu->addAction(connectablePorts[i]);
action->setData(connectablePorts[i]);
QObject::connect(action, SIGNAL(triggered()), this, SLOT(onConnectAction()));
mapPortNamesToActions[connectablePorts[i]] = action;
}
}
disconnectMenu->setEnabled(disconnectMenu->actions().size());
connectMenu->setEnabled(connectMenu->actions().size());
}
void GraphicsClientItem::initItem()
{
// delete all children (except the inner item):
QList<QGraphicsItem*> children = childItems();
for (int i = 0; i < children.size(); i++) {
if (children[i] != controlsItem) {
if (GraphicsPortItem *portItem = dynamic_cast<GraphicsPortItem*>(children[i])) {
portItem->deleteLater();
} else {
delete children[i];
}
}
}
bool gradient = false;
QFont commandsFont = font;
commandsFont.setBold(true);
commandsFont.setStyleStrategy(QFont::PreferAntialias);
QFontMetrics fontMetrics(font);
int portPadding = fontMetrics.height() / 3;
int padding = fontMetrics.height() + portPadding * 2;
QGraphicsSimpleTextItem *textItem = new QGraphicsSimpleTextItem(clientName, this);
textItem->setFont(font);
textItem->setPos(padding, padding);
QStringList inputPorts = clientItemsClient->getPorts(QString(QRegExp::escape(clientName) + ":.*").toAscii().data(), 0, JackPortIsInput);
QList<GraphicsPortItem*> inputPortItems;
int inputPortsWidth = -portPadding;
int minimumInputPortWidth = 0;
for (int i = 0; i < inputPorts.size(); i++) {
inputPortItems.append(new GraphicsPortItem(clientItemsClient, inputPorts[i], 3, font, portPadding, this));
if (isMacroItem()) {
QPen pen = inputPortItems.back()->pen();
pen.setColor(QColor("steelblue"));
inputPortItems.back()->setPen(pen);
}
inputPortsWidth += inputPortItems[i]->getRect().width() + portPadding;
if ((i == 0) || (inputPortItems[i]->getRect().width() < minimumInputPortWidth)) {
minimumInputPortWidth = inputPortItems[i]->getRect().width();
}
}
QStringList outputPorts = clientItemsClient->getPorts(QString(QRegExp::escape(clientName) + ":.*").toAscii().data(), 0, JackPortIsOutput);
QList<GraphicsPortItem*> outputPortItems;
int outputPortsWidth = -portPadding;
int minimumOutputPortWidth = 0;
for (int i = 0; i < outputPorts.size(); i++) {
outputPortItems.append(new GraphicsPortItem(clientItemsClient, outputPorts[i], 3, font, portPadding, this));
if (isMacroItem()) {
QPen pen = outputPortItems.back()->pen();
pen.setColor(QColor("steelblue"));
outputPortItems.back()->setPen(pen);
}
outputPortsWidth += outputPortItems[i]->getRect().width() + portPadding;
if ((i == 0) || (outputPortItems[i]->getRect().width() < minimumOutputPortWidth)) {
minimumOutputPortWidth = outputPortItems[i]->getRect().width();
}
}
rect = (textItem->boundingRect().translated(textItem->pos())).adjusted(-padding, -padding, padding, padding);
// if (rect.width() < inputPortsWidth + (portPadding - minimumInputPortWidth) * 2) {
// rect.setWidth(inputPortsWidth + (portPadding - minimumInputPortWidth) * 2);
// }
// if (rect.width() < outputPortsWidth + (portPadding - minimumOutputPortWidth) * 2) {
// rect.setWidth(outputPortsWidth + (portPadding - minimumOutputPortWidth) * 2);
// }
if (rect.width() < inputPortsWidth) {
rect.setWidth(inputPortsWidth);
}
if (rect.width() < outputPortsWidth) {
rect.setWidth(outputPortsWidth);
}
if (gradient) {
QLinearGradient gradient(rect.topLeft(), rect.bottomRight());
gradient.setColorAt(0, Qt::white);
gradient.setColorAt(1, QColor(0xfc, 0xf9, 0xc2));//QColor("royalblue").lighter());
setBrush(QBrush(gradient));
}
QPainterPath bodyPath;
if (clientStyle == 0) {
bodyPath = EllipsePath(rect);
} else if (clientStyle == 1) {
bodyPath = SpeechBubblePath(rect, rect.height() / 4, rect.height() / 4, Qt::AbsoluteSize);
} else if (clientStyle == 2){
bodyPath = RoundedRectanglePath(rect, padding + fontMetrics.height(), padding + fontMetrics.height());
} else if (clientStyle == 3) {
bodyPath = RectanglePath(rect);
}
for (int i = 0, x = (inputPortsWidth > rect.width() ? (rect.width() - inputPortsWidth) / 2 : 0); i < inputPorts.size(); i++) {
GraphicsPortItem *portItem = inputPortItems[i];
portItem->setFlag(QGraphicsItem::ItemStacksBehindParent, true);
portItem->setPos(x, 0);
QRectF portRect(portItem->getRect().translated(portItem->pos()));
QPainterPath portPath;
portPath.addRect(QRectF(portRect.topLeft(), 0.5 * (portRect.topRight() + portRect.bottomRight())));
int portStyle = (portItem->isAudioType() ? audioPortStyle : midiPortStyle);
if (portStyle == 0) {
portPath += EllipsePath(portRect);
} else if (portStyle == 1) {
portPath += SpeechBubblePath(portRect, 0.7, 0.7);
} else if (portStyle == 2) {
portPath += RoundedRectanglePath(portRect, portPadding + fontMetrics.height() / 2, portPadding + fontMetrics.height() / 2);
} else if (portStyle == 3) {
portPath += RectanglePath(portRect);
}
bodyPath -= portPath;
x += portRect.width() + portPadding;
}
for (int i = 0, x = (outputPortsWidth > rect.width() ? (rect.width() - outputPortsWidth) / 2 : 0); i < outputPorts.size(); i++) {
GraphicsPortItem *portItem = outputPortItems[i];
portItem->setFlag(QGraphicsItem::ItemStacksBehindParent, true);
portItem->setPos(x, rect.height() - fontMetrics.height());
QRectF portRect(portItem->getRect().translated(portItem->pos()));
QPainterPath portPath;
portPath.addRect(QRectF(0.5 * (portRect.topLeft() + portRect.bottomLeft()), portRect.bottomRight()));
int portStyle = (portItem->isAudioType() ? audioPortStyle : midiPortStyle);
if (portStyle == 0) {
portPath += EllipsePath(portRect);
} else if (portStyle == 1) {
portPath += SpeechBubblePath(portRect, 0.7, 0.7);
} else if (portStyle == 2) {
portPath += RoundedRectanglePath(portRect, portPadding + fontMetrics.height() / 2, portPadding + fontMetrics.height() / 2);
} else if (portStyle == 3) {
portPath += RectanglePath(portRect);
}
bodyPath -= portPath;
x += portRect.width() + portPadding;
}
QPainterPath combinedPath = bodyPath;
setPath(combinedPath);
}