void
DigestTreeScene::updateNode(QString sessionPrefix, QString nick, uint64_t seqNo)
{
Roster_iterator it = m_roster.find(sessionPrefix);
if (it == m_roster.end()) {
DisplayUserPtr p(new DisplayUser());
p->setPrefix(sessionPrefix);
p->setSeq(seqNo);
m_roster.insert(p->getPrefix(), p);
plot(m_rootDigest);
}
else {
it.value()->setSeq(seqNo);
DisplayUserPtr p = it.value();
QGraphicsTextItem *item = p->getSeqTextItem();
QGraphicsRectItem *rectItem = p->getInnerRectItem();
std::string s = boost::lexical_cast<std::string>(p->getSeqNo());
item->setPlainText(s.c_str());
QRectF textBR = item->boundingRect();
QRectF rectBR = rectItem->boundingRect();
item->setPos(rectBR.x() + (rectBR.width() - textBR.width())/2,
rectBR.y() + (rectBR.height() - textBR.height())/2);
}
m_displayRootDigest->setPlainText(m_rootDigest);
updateNick(sessionPrefix, nick);
}
void BattleAbilitySelection::nextItem() {
if (_state == BattleAbilitySelection::ACTIONSELECTION) {
if (_currentItem == _activeItems.at(_activeItems.size()-1))
setCurrentItem(_activeItems.at(0));
else
setCurrentItem(_activeItems.at(_activeItems.indexOf(_currentItem)+1));
} else if (_state == BattleAbilitySelection::ABILITYSELECTION) {
if (_currentItem == _activeItems.last()) {
// If the last ability was selected, scroll back to the first one
if (_abilityIndex == (_abilities.size()-1)) {
createAbilities();
} else { /* Else scroll to the next ability */
for (int i = 0; i < _activeItems.size()-1; i++) {
QGraphicsTextItem *item = _activeItems.at(i);
item->setPlainText(_activeItems.at(i+1)->toPlainText());
}
_abilityIndex++;
Ability *ability = _abilities.at(_abilityIndex);
QGraphicsTextItem *item = _activeItems.at(_activeItems.size()-1);
item->setPlainText(ability->getName() + "\t" + QString::number(ability->getCost()) + " " + _currentBattler->getEnergy().first->getName());
}
} else {
_abilityIndex++;
setCurrentItem(_activeItems.at(_activeItems.indexOf(_currentItem)+1));
}
}
}
WeiboDialogPrivate() {
api = new WeiboApi;
qreal x = 6;
QGraphicsTextItem *title = new QGraphicsTextItem(titleBar);
title->setPos(x, 12);
title->setDefaultTextColor(Qt::white);
QFont f;
f.setPixelSize(23);
f.setBold(true);
title->setFont(f);
title->setPlainText(QObject::tr("New weibo (Sina)"));
qreal w = qApp->desktop()->width()/2 - 44;
statusEdit = new TextEdit(central);
statusEdit->setFont(f);
statusEdit->setDefaultTextColor(Qt::blue);
statusEdit->document()->setDocumentMargin(22);
qreal y = 22;
statusEdit->setPos(x, y);
statusEdit->document()->setTextWidth(qApp->desktop()->width()/2 - 8);
//statusEdit->setPlainText("Write something...");
qreal h = qApp->desktop()->height()*0.618;
statusEdit->resize(w, h);
y += statusEdit->size().height() + 12;
qreal hh = qMin<qreal>(qApp->desktop()->height()*0.314/2, 40); //TODO: calculate the line edit height
f.setBold(true);
QGraphicsTextItem *user = new QGraphicsTextItem(central);
f.setPixelSize(20);
user->setFont(f);
user->document()->setDocumentMargin(4);
user->setDefaultTextColor(QColor(33, 33, 33));
user->setPlainText(QObject::tr("User"));
user->setPos(x, y);
userEdit = new TextEdit(central);
userEdit->setPos(x + 120, y);
userEdit->resize(w - 120, hh);
userEdit->setDefaultTextColor(Qt::black);
userEdit->document()->setDocumentMargin(11);
userEdit->document()->setTextWidth(qApp->desktop()->width()/2 - 8);
y += hh + 2;
QGraphicsTextItem *passwd = new QGraphicsTextItem(central);
passwd->setFont(f);
passwd->document()->setDocumentMargin(4);
passwd->setDefaultTextColor(QColor(33, 33, 33));
passwd->setPlainText(QObject::tr("Password"));
passwd->setPos(x, y);
passwdEdit = new TextEdit(central);
passwdEdit->setPos(x + 120, y);
passwdEdit->resize(w - 120, hh);
passwdEdit->setDefaultTextColor(Qt::black);
passwdEdit->document()->setDocumentMargin(11);
statusEdit->setTextInteractionFlags(Qt::TextEditorInteraction);
userEdit->setTextInteractionFlags(Qt::TextEditorInteraction);
passwdEdit->setTextInteractionFlags(Qt::TextEditorInteraction);
f.setPixelSize(24);
userEdit->setFont(f);
passwdEdit->setFont(f);
passwdEdit->setEchoMode(TextEdit::Password);
}
void MainWindow::on_pushButton_clicked()
{
QGraphicsEllipseItem *ellipse2;
QGraphicsTextItem *texto;
QBrush redBrush(Qt::red);
//QBrush blueBrush(Qt::blue);
QPen blackPen(Qt::black);
blackPen.setWidth(1);
ellipse1 = scene->addEllipse(0, 10, 100, 100, blackPen, redBrush);
ellipse2 = scene->addEllipse(500, 10, 100, 100, blackPen, redBrush);
ellipse1->setAcceptDrops(true);
ellipse2->setAcceptDrops(true);
ellipse1->setFlag(QGraphicsItem::ItemIsMovable, true);
texto = new QGraphicsTextItem();
texto->setPos(0,50);
texto->setPlainText("Nodo X");
Nodo1->addToGroup(ellipse1);
Nodo1->addToGroup(texto);
Nodo1->setAcceptDrops(true);
Nodo1->setFlag(QGraphicsItem::ItemIsMovable, true);
scene->addItem(Nodo1);
ui->painter->setAcceptDrops(true);
ui->painter->setScene(scene);
ui->painter->scale(currentScale,currentScale);
}
Plansza::Plansza(int liczbaGraczy, QObject *parent)
: QGraphicsScene(parent), _liczbaGraczy(liczbaGraczy)
{
_stol = vector<Karta>(liczbaGraczy);
_deklaracje = vector<int>(liczbaGraczy);
_wziete = vector<int>(liczbaGraczy);
_punkty = vector<int>(liczbaGraczy, 0);
karty = QVector<QVector<KartaSprite*> >(liczbaGraczy);
_nrLewy = 1;
// deklaracje Items
QFont font;
font.setBold(true);
font.setPixelSize(25);
QGraphicsTextItem *item;
for (int i = 0; i < liczbaGraczy; i++) {
item = new QGraphicsTextItem;
item->setPlainText(tr("?"));
item->setFont(font);
item->setPos(0, i*50);
addItem(item);
deklaracjeItems.push_back(item);
}
setBackgroundBrush(Qt::green);
//setSceneRect(0, 0, 1000, 1000);
}
SEXP
scene_addText(SEXP scene, SEXP x, SEXP y, SEXP labels, SEXP html)
{
QGraphicsScene* s = unwrapQObject(scene, QGraphicsScene);
int nlab = length(labels);
int i, n = length(x);
for (i = 0; i < n; i++) {
QGraphicsTextItem *ti = s->addText(QString());
ti->setFont(QFont("Arial"));
if (LOGICAL(html)[0]) {
ti->setHtml(QString::fromLocal8Bit(CHAR(asChar(STRING_ELT(labels, i % nlab)))));
ti->setOpenExternalLinks(true);
ti->setToolTip("I am HTML!");
}
else {
ti->setPlainText(QString::fromLocal8Bit(CHAR(asChar(STRING_ELT(labels, i % nlab)))));
}
ti->setPos(REAL(x)[i], REAL(y)[i]);
ti->setFlags(QGraphicsItem::ItemIsMovable |
QGraphicsItem::ItemIsSelectable |
QGraphicsItem::ItemIsFocusable |
QGraphicsItem::ItemIgnoresTransformations);
}
return R_NilValue;
}
void KeypointItem::showDescription()
{
if(!placeHolder_ || !placeHolder_->isVisible())
{
if(!placeHolder_)
{
QString info = QString( "Keypoint = %1\n"
"Word = %2\n"
"Response = %3\n"
"Angle = %4\n"
"X = %5\n"
"Y = %6\n"
"Size = %7").arg(id_).arg(wordID_).arg(kpt_.response).arg(kpt_.angle).arg(kpt_.pt.x).arg(kpt_.pt.y).arg(kpt_.size);
placeHolder_ = new QGraphicsRectItem();
placeHolder_->setVisible(false);
this->scene()->addItem(placeHolder_);
placeHolder_->setBrush(QBrush(QColor ( 0, 0, 0, 170 ))); // Black transparent background
QGraphicsTextItem * text = new QGraphicsTextItem(placeHolder_);
text->setDefaultTextColor(this->pen().color().rgb());
text->setPlainText(info);
placeHolder_->setRect(text->boundingRect());
}
QPen pen = this->pen();
this->setPen(QPen(pen.color(), pen.width()+2));
placeHolder_->setZValue(this->zValue()+1);
placeHolder_->setPos(this->mapToScene(0,0));
placeHolder_->setVisible(true);
}
}
void Game::gameOver()
{
QGraphicsTextItem *gameOverLabel = new QGraphicsTextItem;
if (isWin)
{
gameOverLabel->setPlainText(QString("You Win"));
}
else
{
gameOverLabel->setPlainText(QString("Game Over"));
}
gameOverLabel->setDefaultTextColor(Qt::black);
gameOverLabel->setFont(QFont("times", 24));
gameOverLabel->setPos(-100, -250);
scene->addItem(gameOverLabel);
timer->stop();
}
void KeypointItem::showDescription()
{
if(!_placeHolder)
{
_placeHolder = new QGraphicsRectItem (this);
_placeHolder->setVisible(false);
_placeHolder->setBrush(QBrush(QColor ( 0, 0, 0, 170 ))); // Black transparent background
QGraphicsTextItem * text = new QGraphicsTextItem(_placeHolder);
text->setDefaultTextColor(this->pen().color().rgb());
if(_depth <= 0)
{
text->setPlainText(QString( "Id = %1\n"
"Dir = %3\n"
"Hessian = %4\n"
"X = %5\n"
"Y = %6\n"
"Size = %7").arg(_id).arg(_kpt.angle).arg(_kpt.response).arg(_kpt.pt.x).arg(_kpt.pt.y).arg(_kpt.size));
}
else
{
text->setPlainText(QString( "Id = %1\n"
"Dir = %3\n"
"Hessian = %4\n"
"X = %5\n"
"Y = %6\n"
"Size = %7\n"
"Depth = %8 m").arg(_id).arg(_kpt.angle).arg(_kpt.response).arg(_kpt.pt.x).arg(_kpt.pt.y).arg(_kpt.size).arg(_depth));
}
_placeHolder->setRect(text->boundingRect());
}
if(_placeHolder->parentItem())
{
_placeHolder->setParentItem(0); // Make it a to level item
}
QPen pen = this->pen();
this->setPen(QPen(pen.color(), _width+2));
_placeHolder->setZValue(this->zValue()+1);
_placeHolder->setPos(this->mapFromScene(0,0));
_placeHolder->setVisible(true);
}
void _graphics::paintServer()
{
server_x=PalletScene->width()/2-SERVER_RECT_WIDTH/2;
server_y=SERVER_RECT_HEIGHT;
QBrush br(Qt::white);
QPen pen(Qt::black);
PalletScene->addRect(server_x,server_y,SERVER_RECT_WIDTH,SERVER_RECT_HEIGHT,pen,br);
QGraphicsTextItem* io = new QGraphicsTextItem;
io->setPos(server_x,server_y);
io->setPlainText("SERVER");
PalletScene->addItem(io);
}
void _graphics::paintArbiter(int x, int y, int client_x, int client_y, char* text)
{
QBrush br(Qt::white);
QPen pen(Qt::black);
PalletScene->addLine(client_x+CLIENT_RECT_WIDTH/2,client_y+CLIENT_RECT_HEIGHT,x+ACTOR_CIRCLE_RADIUS/2,y,pen);
PalletScene->addEllipse(x,y,ACTOR_CIRCLE_RADIUS,ACTOR_CIRCLE_RADIUS,pen,br);
QGraphicsTextItem * io = new QGraphicsTextItem;
io->setPos(x,y);
io->setPlainText(text);
PalletScene->addItem(io);
}
void _graphics::paintClient(int x, int y, char* str)
{
QBrush br(Qt::white);
QPen pen(Qt::black);
PalletScene->addLine(server_x+SERVER_RECT_WIDTH/2,server_y+SERVER_RECT_HEIGHT,x+CLIENT_RECT_WIDTH/2,y,pen);
PalletScene->addRect(x,y,CLIENT_RECT_WIDTH,CLIENT_RECT_HEIGHT,pen, br);
QGraphicsTextItem* io = new QGraphicsTextItem;
io->setPos(x,y);
io->setPlainText(str);
PalletScene->addItem(io);
}
void BbScene::testAddText()
{
QGraphicsTextItem* item = new QGraphicsTextItem;
QFont font = QFont("Microsoft YaHei");
font.setPointSize(20);
item->setFont(font);
item->setPlainText("I am a clever mouse");
item->setPos(0, 0);
addItem(item);
}
void City::draw(QGraphicsScene &scene)
{
qDebug().noquote().nospace() << "Drawing city: " + name + " at ("
<< x << ", " << y << ")";
// circle
scene.addEllipse(x - 4, y - 4, 8, 8, QPen(Qt::black),
QBrush(Qt::red, Qt::SolidPattern));
QGraphicsTextItem *text = new QGraphicsTextItem;
text->setPos(x - 4, y - 8);
text->setPlainText(name);
scene.addItem(text);
}
void BattleAbilitySelection::previousItem() {
if (_state == BattleAbilitySelection::ACTIONSELECTION) {
if (_currentItem == _activeItems.at(0))
setCurrentItem(_activeItems.at(_activeItems.size()-1));
else
setCurrentItem(_activeItems.at(_activeItems.indexOf(_currentItem)-1));
} else if (_state == BattleAbilitySelection::ABILITYSELECTION) {
if (_currentItem == _activeItems.at(0)) {
// If the first ability was selected, scroll to the last one
if (_abilityIndex == 0) {
for (int i = (_activeItems.size()-1); i >= 0 ; i--) {
QGraphicsTextItem *item = _activeItems.at(i);
Ability *ability = _abilities.at(_abilities.size() - _activeItems.size() + i);
item->setPlainText(ability->getName() + "\t" + QString::number(ability->getCost()) + " " + _currentBattler->getEnergy().first->getName());
}
_abilityIndex = _abilities.size()-1;
setCurrentItem(_activeItems.at(_activeItems.size()-1));
} else { // Else scroll to the previous ability
for (int i = (_activeItems.size()-1); i > 0; i--) {
QGraphicsTextItem *item = _activeItems.at(i);
item->setPlainText(_activeItems.at(i-1)->toPlainText());
}
_abilityIndex--;
Ability *ability = _abilities.at(_abilityIndex);
QGraphicsTextItem *item = _activeItems.at(0);
item->setPlainText(ability->getName() + "\t" + QString::number(ability->getCost()) + " " + _currentBattler->getEnergy().first->getName());
}
} else {
_abilityIndex--;
setCurrentItem(_activeItems.at(_activeItems.indexOf(_currentItem)-1));
}
}
}
void _graphics::paintTraceObject(int x, int y, int arbiter_x, int arbiter_y, char *text, int type)
{
QBrush br(Qt::white);
QPen pen;
//PalletScene->addLine(server_x+SERVER_RECT_WIDTH/2,server_y+SERVER_RECT_HEIGHT,x+CLIENT_RECT_WIDTH/2,y,pen);
switch(type)
{
case 0:
pen.setColor(Qt::red);
break;
case 1:
pen.setColor(Qt::green);
break;
case 2:
pen.setColor(Qt::blue);
break;
}
if(x!=0 && y!=0)
{
PalletScene->addRect(x,y,CLIENT_RECT_WIDTH*2,CLIENT_RECT_HEIGHT,pen, br);
QGraphicsTextItem* io = new QGraphicsTextItem;
io->setPos(x,y);
io->setPlainText(text);
PalletScene->addItem(io);
}
else // Нет арбитра - когда инициализация
{
int message_x=x;
int message_y=y;
int init_x=0;
int init_y=20;
PalletScene->addRect(message_x,message_y,CLIENT_RECT_WIDTH*2,CLIENT_RECT_HEIGHT,pen, br);
QGraphicsTextItem* io2 = new QGraphicsTextItem;
io2->setPos(message_x,message_y);
io2->setPlainText(text);
PalletScene->addItem(io2);
pen.setColor(Qt::black);
PalletScene->addRect(init_x,init_y,CLIENT_RECT_WIDTH*2,CLIENT_RECT_HEIGHT,pen, br);
QGraphicsTextItem* io3 = new QGraphicsTextItem;
io3->setPos(init_x,init_y);
io3->setPlainText("createAndInitActors");
PalletScene->addItem(io3);
//PalletScene->addLine(init_x+CLIENT_RECT_WIDTH/2,init_y+CLIENT_RECT_HEIGHT,message_x+CLIENT_RECT_WIDTH/2,message_y,pen);
}
}
void MainWindow::paintEvent(QPaintEvent *e)
{
wierzcholek tmp;
QPen blackPen(Qt::black);
blackPen.setWidth(1);
int x_src, x_dst, y_src, y_dst;
x_src = x_dst = y_src = y_dst = 0;
for(std::list<wierzcholek>::iterator itr = wierzcholki.begin(); itr != wierzcholki.end(); itr++) {
scene->addEllipse(itr->x, itr->y, ECLIPSE_WIDTH, ECLIPSE_WIDTH, blackPen);
QGraphicsTextItem *io = new QGraphicsTextItem;
io->setPos(itr->x + ECLIPSE_WIDTH/4 - itr->nazwa.length(), itr->y + ECLIPSE_WIDTH/3);
io->setPlainText(itr->nazwa);
scene->addItem(io);
for(std::list<krawedz>::iterator itr2 = itr->krawedzie.begin(); itr2 != itr->krawedzie.end(); itr2++){
get_node(itr2->cel, tmp);
x_src = itr->x+ECLIPSE_WIDTH;
y_src = itr->y+ECLIPSE_WIDTH/2;
x_dst = tmp.x;
y_dst = tmp.y+ECLIPSE_WIDTH/2;
if(itr2->cel != "ujscie") {
QGraphicsTextItem *number = new QGraphicsTextItem;
number->setPos((x_src + x_dst)/2, (y_src + y_dst)/2);
number->setPlainText(QString::number(itr2->pojemnosc));
scene->addItem(number);
}
scene->addLine(x_src, y_src, x_dst, y_dst, blackPen);
}
}
}
void
DigestTreeScene::reDrawNode(DisplayUserPtr p, QColor rimColor)
{
QGraphicsRectItem *rimItem = p->getRimRectItem();
rimItem->setBrush(QBrush(rimColor));
QGraphicsRectItem *innerItem = p->getInnerRectItem();
innerItem->setBrush(QBrush(Qt::lightGray));
QGraphicsTextItem *seqTextItem = p->getSeqTextItem();
std::string s = boost::lexical_cast<std::string>(p->getSeqNo());
seqTextItem->setPlainText(s.c_str());
QRectF textBR = seqTextItem->boundingRect();
QRectF innerBR = innerItem->boundingRect();
seqTextItem->setPos(innerBR.x() + (innerBR.width() - textBR.width())/2,
innerBR.y() + (innerBR.height() - textBR.height())/2);
}
void mogs_qt_video_scene::DrawPoint( CvPoint in,
QString name)
{
QPen outlinePen(Qt::red);
outlinePen.setWidth(2);
addEllipse(in.x, in.y, 5, 5,outlinePen);
if (name != "")
{
QGraphicsTextItem * io = new QGraphicsTextItem;
io->setDefaultTextColor(Qt::red);
io->setPos(in.x -20,in.y);
io->setPlainText(name);
addItem(io);
}
}
QtTextPositionWidget::QtTextPositionWidget(const std::vector<std::string>& items)
{
QGraphicsScene * const scene = new QGraphicsScene(this);
this->setScene(scene);
std::for_each(items.begin(),items.end(),
[this,scene](const std::string& s)
{
QGraphicsTextItem * item = new QGraphicsTextItem;
item->setPlainText(s.c_str());
item->setFlags(QGraphicsItem::ItemIsMovable);
item->setPos(this->width() / 2.0, this->height() / 2.0);
scene->addItem(item);
}
);
}
QGraphicsItemGroup* MainWindow::createVisualNodo(string* names, int cant){
QGraphicsItemGroup* grupo = new QGraphicsItemGroup();
int posx = 0;
int dim = 50;
for(int x = 0; x < cant; x++){
QGraphicsRectItem* cuadro = new QGraphicsRectItem(posx,0,50,50);
cuadro->setBrush(QBrush(Qt::gray));
QGraphicsTextItem* texto = new QGraphicsTextItem();
texto->setPos(posx, dim/3);
texto->setPlainText(QString::fromStdString(names[x]));
grupo->addToGroup(cuadro);
grupo->addToGroup(texto);
posx+=dim;
}
return grupo;
}
void
DigestTreeScene::updateNick(QString sessionPrefix, QString nick)
{
Roster_iterator it = m_roster.find(sessionPrefix);
if (it != m_roster.end()) {
DisplayUserPtr p = it.value();
if (nick != p->getNick()) {
p->setNick(nick);
QGraphicsTextItem *nickItem = p->getNickTextItem();
QGraphicsRectItem *nickRectItem = p->getNickRectItem();
nickItem->setPlainText(p->getNick());
QRectF rectBR = nickRectItem->boundingRect();
QRectF nickBR = nickItem->boundingRect();
nickItem->setPos(rectBR.x() + (rectBR.width() - nickBR.width())/2, rectBR.y() + 5);
}
}
}
void BattleCharacterStatus::valueChanged(QString name) {
BattleCharacterItem *character = 0;
QGraphicsTextItem *infoItem = 0;
for (int i = 0; i < _characters.size(); i++) {
BattleCharacterItem *it = _characters.at(i);
if (!!it && (it->getName() == name)) {
character = it;
infoItem = _info.at(i);
break;
}
}
if (!!character) {
QString infoString;
infoString += character->getCharacter()->getName() + QString(":\n");
infoString += QString("Health: ") + QString::number(character->getHealth().second) + QString(" / ") + QString::number(character->getMaxHealth().second) + QString("\t");
infoString += QString("Energy: ") + QString::number(character->getEnergy().second) + QString(" / ") + QString::number(character->getMaxEnergy().second);
double percentage = (double)character->getHealth().second / (double)character->getMaxHealth().second * 100;
if (percentage > 60)
infoItem->setDefaultTextColor(Qt::green);
else if ((percentage <= 60) && (percentage > 25))
infoItem->setDefaultTextColor(Qt::yellow);
else if ((percentage <= 25) && (percentage > 0))
infoItem->setDefaultTextColor(Qt::red);
else
infoItem->setDefaultTextColor(Qt::gray);
infoItem->setPlainText(infoString);
QFont font("Times", 12, QFont::Bold);
infoItem->setFont(font);
QTextBlockFormat format;
format.setAlignment(Qt::AlignLeft);
QTextCursor cursor = infoItem->textCursor();
cursor.select(QTextCursor::Document);
cursor.mergeBlockFormat(format);
cursor.clearSelection();
infoItem->setTextCursor(cursor);
}
}
void BattleCharacterStatus::setCharacters(const QVector<BattleCharacterItem*> &characters) {
for (int i = 0; i < _info.size(); i++) {
delete _info.at(i);
}
_info.clear();
_characters = characters;
int y = 10;
for (int i = 0; i < _characters.size(); i++) {
BattleCharacterItem *character = _characters.at(i);
connect (character, SIGNAL(valueChanged(QString)), this, SLOT(valueChanged(QString)));
QString infoString;
infoString += character->getCharacter()->getName() + QString(":\n");
infoString += QString("Health: ") + QString::number(character->getHealth().second) + QString(" / ") + QString::number(character->getMaxHealth().second) + QString("\t");
infoString += QString("Energy: ") + QString::number(character->getEnergy().second) + QString(" / ") + QString::number(character->getMaxEnergy().second);
QGraphicsTextItem *infoItem = new QGraphicsTextItem(this);
_info.append(infoItem);
infoItem->setTextWidth(boundingRect().width());
infoItem->setDefaultTextColor(Qt::green);
infoItem->setPlainText(infoString);
QFont font("Times", 12, QFont::Bold);
infoItem->setFont(font);
QTextBlockFormat format;
format.setAlignment(Qt::AlignLeft);
QTextCursor cursor = infoItem->textCursor();
cursor.select(QTextCursor::Document);
cursor.mergeBlockFormat(format);
cursor.clearSelection();
infoItem->setTextCursor(cursor);
infoItem->setPos(10, y);
y += 50;
}
}
void KeypointItem::showDescription()
{
if(!_placeHolder)
{
_placeHolder = new QGraphicsRectItem (this);
_placeHolder->setVisible(false);
_placeHolder->setBrush(QBrush(QColor ( 0, 0, 0, 170 ))); // Black transparent background
QGraphicsTextItem * text = new QGraphicsTextItem(_placeHolder);
text->setDefaultTextColor(this->pen().color().rgb());
text->setPlainText(_info);
_placeHolder->setRect(text->boundingRect());
}
if(_placeHolder->parentItem())
{
_placeHolder->setParentItem(0); // Make it a to level item
}
QPen pen = this->pen();
this->setPen(QPen(pen.color(), _width+2));
_placeHolder->setZValue(this->zValue()+1);
_placeHolder->setPos(this->mapFromScene(0,0));
_placeHolder->setVisible(true);
}
void Visualiseur::miseAJourGraphique()
{
scene->clear();
QPolygonF Polygone ;
if(afficherTriangulation){
for (int i=0 ; i < triangles.size() ; i++ ){
triangles[i].transformerEnPolygone(Polygone , points);
scene->addPolygon(Polygone , QPen(Qt::blue , 1 )) ;
}
}
if(afficherCentres){
for (int i=0 ; i < triangles.size() ; i++ ){
QGraphicsTextItem* texte = new QGraphicsTextItem();
texte->scale(1 , -1 );
texte->setPlainText(QString::number(i));
texte->setPos(triangles[i].centroide.x()-1 , triangles[i].centroide.y() - 1);
scene->addItem(texte);
}
}
if(afficherSommets){
for (int i=0 ; i < points.size() ; i++ ){
QGraphicsTextItem* texte = new QGraphicsTextItem();
texte->scale(1 , -1 );
texte->setPlainText(QString::number(i));
texte->setDefaultTextColor(Qt::red);
texte->setPos(points[i].x()-1 , points[i].y() - 1);
scene->addItem(texte);
}
}
if (afficherCercle){
int id_triangle = fonctionsCommunes::Walk(curseur , points , triangles ) ;
scene->addEllipse(triangles[id_triangle].centre[0] -triangles[id_triangle].R ,
triangles[id_triangle].centre[1] -triangles[id_triangle].R ,
2*triangles[id_triangle].R , 2*triangles[id_triangle].R , QPen(Qt::gray)) ;
}
if (afficherWalk && (!trajectoireWalk.isEmpty()) && (triangleUniversel.inTriangle(curseur , points ))){
for (int i=0 ; i< trajectoireWalk.size() ; i ++ ){
QPolygonF P ;
triangles[trajectoireWalk[i]].transformerEnPolygone(P , points );
scene->addPolygon(P , QPen(Qt::black) , QBrush(QColor(0, 0,200, 30))) ;
}
}
if (afficherVoronoi && (triangles.size()> 1 )){
Voronoi.clear();
fonctionsCommunes::Voronoi( Voronoi , triangles ) ;
for (int i = 0 ; i < Voronoi.size() ; i ++ ){
scene->addLine(Voronoi[i] , QPen(Qt::red)) ;
}
}
if (afficherPlusProcheVoisin){
fonctionsCommunes::PlusProcheVoisin( curseur , triangles , points , procheVoisin ) ;
scene->addEllipse(procheVoisin.x() - 4 , procheVoisin.y() - 4 , 8 , 8 , QPen(Qt::red , 6)) ;
}
}
void Macro::draw(QGraphicsScene* scene, QColor background, QColor font) {
//size 241, 281
//QBrush Ybrush(Qt::blue);
//scene->setBackgroundBrush(Ybrush);
QFont titleFont("Times", 10, QFont::Bold);
QGraphicsTextItem * titleItem = new QGraphicsTextItem;
titleItem->setPos(70,10);
titleItem->setDefaultTextColor(font);
titleItem->setFont(titleFont);
titleItem->setPlainText("Macro Recorder");
scene->addItem(titleItem);
QFont actFont("Times", 9, QFont::Bold);
QGraphicsTextItem * actItem = new QGraphicsTextItem;
actItem->setPos(30,40);
actItem->setDefaultTextColor(font);
actItem->setFont(actFont);
if (activationKeyRec == false) {
QChar key = static_cast<char>(activationKey);
QString sKey = key;
actItem->setPlainText("Activation Key: (" + sKey + ")");
}
else {
actItem->setPlainText("Activation Key: RECORDING");
}
scene->addItem(actItem);
QBrush onB(font);
QPen onP(font);
scene->addRect(160,150,40,40, onP, onB);
scene->addRect(160,200,40,40, onP, onB);
QFont onFont("Times", 11, QFont::Bold);
QGraphicsTextItem * onItem = new QGraphicsTextItem;
onItem->setPos(166,158);
if (on) {
onItem->setDefaultTextColor(Qt::yellow);
}
else {
onItem->setDefaultTextColor(Qt::black);
}
onItem->setFont(onFont);
onItem->setPlainText("On");
scene->addItem(onItem);
QFont offFont("Times", 11, QFont::Bold);
QGraphicsTextItem * offItem = new QGraphicsTextItem;
offItem->setPos(166,208);
if (on) {
offItem->setDefaultTextColor(Qt::black);
}
else {
offItem->setDefaultTextColor(Qt::yellow);
}
offItem->setFont(offFont);
offItem->setPlainText("Off");
scene->addItem(offItem);
if (recording) {
QBrush recB(Qt::red);
QPen recP(Qt::red);
scene->addRect(60,80,30,30, recP, recB);
}
else {
QBrush recB(font);
QPen recP(font);
scene->addRect(60,80,30,30, recP, recB);
}
QBrush loadB(font);
QPen loadP(font);
scene->addRect(140,80,30,30, loadP, loadB);
QFont loadFont("Times", 7, QFont::Bold);
QGraphicsTextItem * loadItem = new QGraphicsTextItem;
loadItem->setPos(140,85);
loadItem->setDefaultTextColor(Qt::black);
loadItem->setFont(loadFont);
loadItem->setPlainText("Load");
scene->addItem(loadItem);
QFont recFont("Times", 8, QFont::Bold);
QGraphicsTextItem * recItem = new QGraphicsTextItem;
recItem->setPos(61,83);
recItem->setDefaultTextColor(Qt::black);
recItem->setFont(recFont);
recItem->setPlainText("Rec");
scene->addItem(recItem);
}
void OverviewDockWidget::addOverviewShape(OwlClass *cls)
{
qreal x = cls->overviewshape->pos().rx();
qreal y = cls->overviewshape->pos().ry();
int stat = cls->overviewshape->getStatus();
int gid = getGItemID(cls->shortname);
if(gid!=-1){
if(stat==gitem_status[gid]){
QPropertyAnimation * ani = new QPropertyAnimation(gitems[gid], "pos");
ani->setDuration(600);
ani->setStartValue(oripos[gid]);
qreal ex = oripos[gid].rx() + (x - oriabspos[gid].rx());
qreal ey = oripos[gid].ry() + (y - oriabspos[gid].ry());
ani->setEndValue(QPointF(ex, ey));
oripos[gid]=QPointF(ex,ey);
oriabspos[gid]=QPointF(x,y);
ani_group->addAnimation(ani);
return;
}
else{
m_scene->removeItem(gitems[gid]);
gitems.removeAt(gid);
gitem_status.removeAt(gid);
oripos.removeAt(gid);
oriabspos.removeAt(gid);
}
}
OverviewShape *its = NULL;
switch(stat)
{
case OverviewClassShape::STATUS_Hide:
break;
case OverviewClassShape::STATUS_OutDetailview:
// it = m_scene->addRect(x-2,y-2,4,4,QPen(QColor("black")),QBrush(QColor("gray")));
its = new OverviewShape();
its->setRect(x-2,y-2,4,4);
its->setPen(QPen(QColor("black")));
its->setBrush(QBrush(QColor("gray")));
m_scene->addItem(its);
// cout<<"x,y = "<<x<<","<<y<<endl;
// cout<<"POS = "<<its->pos().rx()<<","<<its->pos().ry()<<endl;
break;
case OverviewClassShape::STATUS_InDetailview_Default:
// it = m_scene->addRect(x-3,y-3,6,6,QPen(QColor("black")),QBrush(OwlClass::CLASS_SHAPE_COLOR));
its = new OverviewShape();
its->setRect(x-3,y-3,6,6);
its->setPen(QPen(QColor("black")));
its->setBrush(QBrush(OwlClass::CLASS_SHAPE_COLOR));
m_scene->addItem(its);
break;
case OverviewClassShape::STATUS_InDetailview_Focused:
// it = m_scene->addRect(x-3,y-3,6,6,QPen(QColor("black")),QBrush(OwlClass::CLASS_SHAPE_FOCUSED_COLOR));
its = new OverviewShape();
its->setRect(x-3,y-3,6,6);
its->setPen(QPen(QColor("black")));
its->setBrush(QBrush(OwlClass::CLASS_SHAPE_FOCUSED_COLOR));
m_scene->addItem(its);
break;
case OverviewClassShape::STATUS_InDetailview_SubFocused:
// it = m_scene->addRect(x-3,y-3,6,6,QPen(QColor("black")),QBrush(OwlClass::SUBCLASS_SHAPE_FOCUSED_COLOR));
its = new OverviewShape();
its->setRect(x-3,y-3,6,6);
its->setPen(QPen(QColor("black")));
its->setBrush(QBrush(OwlClass::SUBCLASS_SHAPE_FOCUSED_COLOR));
m_scene->addItem(its);
break;
case OverviewClassShape::STATUS_InDetailview_SuperFocused:
// it = m_scene->addRect(x-3,y-3,6,6,QPen(QColor("black")),QBrush(OwlClass::SUPERCLASS_SHAPE_FOCUSED_COLOR));
its = new OverviewShape();
its->setRect(x-3,y-3,6,6);
its->setPen(QPen(QColor("black")));
its->setBrush(QBrush(OwlClass::SUPERCLASS_SHAPE_FOCUSED_COLOR));
m_scene->addItem(its);
break;
case OverviewClassShape::STATUS_COMPACT:
{
QGraphicsTextItem * io = new QGraphicsTextItem();
io->setPos(x-8,y-8);
QFont font;
font.setPixelSize(7);
font.setBold(false);
font.setFamily("Calibri");
io->setFont(font);
io->setDefaultTextColor(QColor("black"));
QString s = QString::number(cls->subclasses.size());
io->setPlainText(s);
QGraphicsItem * it = m_scene->addRect(x-6,y-4,12,8,QPen(QColor("black")),QBrush(QColor("pink"),Qt::LinearGradientPattern));
m_scene->addItem(io);
this->lines.append(io);
this->lines.append(it);
for(int i=0;i<cls->subclasses.size();i++){
double sx = x+0.0001*i;
double sy = y+0.0001*i;
cls->subclasses[i]->overviewshape->setCentrePos(QPointF(sx,sy));
this->addOverviewShape(cls->subclasses[i]);
int gidx = getGItemID(cls->subclasses[i]->shortname);
if(gidx!=-1)this->hideclasses.append(gitems[gidx]);
}
}
break;
default:
break;
}
if(its != NULL){
its->setToolTip(cls->shortname);
oripos.append(its->pos());
oriabspos.append(QPointF(x,y));
gitems.append(its);
gitem_status.append(stat);
}
}
