git.sesse.net Git - kdenlive/blob - src/geometryval.cpp

   1 /***************************************************************************
   2                           geomeytrval.cpp  -  description
   3                              -------------------
   4     begin                : 03 Aug 2008
   5     copyright            : (C) 2008 by Marco Gittler
   6     email                : g.marco@freenet.de
   7  ***************************************************************************/
   8
   9 /***************************************************************************
  10  *                                                                         *
  11  *   This program is free software; you can redistribute it and/or modify  *
  12  *   it under the terms of the GNU General Public License as published by  *
  13  *   the Free Software Foundation; either version 2 of the License, or     *
  14  *   (at your option) any later version.                                   *
  15  *                                                                         *
  16  ***************************************************************************/
  17
  18 #include "geometryval.h"
  19 #include "graphicsscenerectmove.h"
  20 #include "kdenlivesettings.h"
  21
  22 #include <KDebug>
  23
  24 #include <QGraphicsView>
  25 #include <QVBoxLayout>
  26 #include <QGraphicsRectItem>
  27 #include <QMenu>
  28 #include <QInputDialog>
  29
  30
  31 Geometryval::Geometryval(const MltVideoProfile profile, Timecode t, QPoint frame_size, int startPoint, QWidget* parent) :
  32         QWidget(parent),
  33         m_profile(profile),
  34         m_paramRect(NULL),
  35         m_geom(NULL),
  36         m_path(NULL),
  37         m_fixedMode(false),
  38         m_frameSize(frame_size),
  39         m_startPoint(startPoint),
  40         m_timePos(t)
  41 {
  42     setupUi(this);
  43     toolbarlayout->addWidget(&m_timePos);
  44     toolbarlayout->insertStretch(-1);
  45
  46     QVBoxLayout* vbox = new QVBoxLayout(widget);
  47     m_sceneview = new QGraphicsView(this);
  48     m_sceneview->setBackgroundBrush(QBrush(Qt::black));
  49     vbox->addWidget(m_sceneview);
  50     vbox->setContentsMargins(0, 0, 0, 0);
  51
  52     QVBoxLayout* vbox2 = new QVBoxLayout(keyframeWidget);
  53     m_helper = new KeyframeHelper(this);
  54     vbox2->addWidget(m_helper);
  55     vbox2->setContentsMargins(0, 0, 0, 0);
  56
  57     connect(m_helper, SIGNAL(positionChanged(int)), this, SLOT(slotPositionChanged(int)));
  58     connect(m_helper, SIGNAL(keyframeMoved(int)), this, SLOT(slotKeyframeMoved(int)));
  59     connect(m_helper, SIGNAL(addKeyframe(int)), this, SLOT(slotAddFrame(int)));
  60     connect(m_helper, SIGNAL(removeKeyframe(int)), this, SLOT(slotDeleteFrame(int)));
  61
  62     m_scene = new GraphicsSceneRectMove(this);
  63     m_scene->setTool(TITLE_SELECT);
  64     m_sceneview->setScene(m_scene);
  65     m_dar = (m_profile.height * m_profile.display_aspect_num / (double) m_profile.display_aspect_den) / (double) m_profile.width;
  66
  67     m_realWidth = (int)(profile.height * profile.display_aspect_num / (double) profile.display_aspect_den);
  68     QGraphicsRectItem *frameBorder = new QGraphicsRectItem(QRectF(0, 0, m_realWidth, profile.height));
  69     frameBorder->setZValue(-1100);
  70     frameBorder->setBrush(QColor(255, 255, 0, 30));
  71     frameBorder->setPen(QPen(QBrush(QColor(255, 255, 255, 255)), 1.0, Qt::DashLine));
  72     m_scene->addItem(frameBorder);
  73
  74     buttonNext->setIcon(KIcon("media-skip-forward"));
  75     buttonNext->setToolTip(i18n("Go to next keyframe"));
  76     buttonPrevious->setIcon(KIcon("media-skip-backward"));
  77     buttonPrevious->setToolTip(i18n("Go to previous keyframe"));
  78     buttonAdd->setIcon(KIcon("document-new"));
  79     buttonAdd->setToolTip(i18n("Add keyframe"));
  80     buttonDelete->setIcon(KIcon("edit-delete"));
  81     buttonDelete->setToolTip(i18n("Delete keyframe"));
  82
  83     m_configMenu = new QMenu(i18n("Misc..."), this);
  84     buttonMenu->setMenu(m_configMenu);
  85     buttonMenu->setPopupMode(QToolButton::MenuButtonPopup);
  86
  87     m_editOptions = m_configMenu->addAction(KIcon("system-run"), i18n("Show/Hide options"));
  88     m_editOptions->setCheckable(true);
  89     buttonMenu->setDefaultAction(m_editOptions);
  90     connect(m_editOptions, SIGNAL(triggered()), this, SLOT(slotSwitchOptions()));
  91     slotSwitchOptions();
  92
  93     m_reset = m_configMenu->addAction(KIcon("view-refresh"), i18n("Reset"), this, SLOT(slotResetPosition()));
  94
  95     m_syncAction = m_configMenu->addAction(i18n("Sync timeline cursor"), this, SLOT(slotSyncCursor()));
  96     m_syncAction->setCheckable(true);
  97     m_syncAction->setChecked(KdenliveSettings::transitionfollowcursor());
  98
  99     //scene->setSceneRect(0, 0, profile.width * 2, profile.height * 2);
 100     //view->fitInView(m_frameBorder, Qt::KeepAspectRatio);
 101     const double sc = 100.0 / profile.height * 0.8;
 102     QRectF srect = m_sceneview->sceneRect();
 103     m_sceneview->setSceneRect(srect.x(), -srect.height() / 3 + 10, srect.width(), srect.height() + srect.height() / 3 * 2 - 10);
 104     m_scene->setZoom(sc);
 105     m_sceneview->centerOn(frameBorder);
 106     m_sceneview->setMouseTracking(true);
 107     connect(buttonNext , SIGNAL(clicked()) , this , SLOT(slotNextFrame()));
 108     connect(buttonPrevious , SIGNAL(clicked()) , this , SLOT(slotPreviousFrame()));
 109     connect(buttonDelete , SIGNAL(clicked()) , this , SLOT(slotDeleteFrame()));
 110     connect(buttonAdd , SIGNAL(clicked()) , this , SLOT(slotAddFrame()));
 111     connect(m_scene, SIGNAL(actionFinished()), this, SLOT(slotUpdateTransitionProperties()));
 112
 113     buttonhcenter->setIcon(KIcon("kdenlive-align-hor"));
 114     buttonhcenter->setToolTip(i18n("Align item horizontally"));
 115     buttonvcenter->setIcon(KIcon("kdenlive-align-vert"));
 116     buttonvcenter->setToolTip(i18n("Align item vertically"));
 117     buttontop->setIcon(KIcon("kdenlive-align-top"));
 118     buttontop->setToolTip(i18n("Align item to top"));
 119     buttonbottom->setIcon(KIcon("kdenlive-align-bottom"));
 120     buttonbottom->setToolTip(i18n("Align item to bottom"));
 121     buttonright->setIcon(KIcon("kdenlive-align-right"));
 122     buttonright->setToolTip(i18n("Align item to right"));
 123     buttonleft->setIcon(KIcon("kdenlive-align-left"));
 124     buttonleft->setToolTip(i18n("Align item to left"));
 125
 126     connect(buttonhcenter, SIGNAL(clicked()), this, SLOT(slotAlignHCenter()));
 127     connect(buttonvcenter, SIGNAL(clicked()), this, SLOT(slotAlignVCenter()));
 128     connect(buttontop, SIGNAL(clicked()), this, SLOT(slotAlignTop()));
 129     connect(buttonbottom, SIGNAL(clicked()), this, SLOT(slotAlignBottom()));
 130     connect(buttonright, SIGNAL(clicked()), this, SLOT(slotAlignRight()));
 131     connect(buttonleft, SIGNAL(clicked()), this, SLOT(slotAlignLeft()));
 132     connect(spinX, SIGNAL(valueChanged(int)), this, SLOT(slotGeometryX(int)));
 133     connect(spinY, SIGNAL(valueChanged(int)), this, SLOT(slotGeometryY(int)));
 134     connect(spinWidth, SIGNAL(valueChanged(int)), this, SLOT(slotGeometryWidth(int)));
 135     connect(spinHeight, SIGNAL(valueChanged(int)), this, SLOT(slotGeometryHeight(int)));
 136     connect(spinResize, SIGNAL(editingFinished()), this, SLOT(slotResizeCustom()));
 137     connect(buttonResize, SIGNAL(clicked()), this, SLOT(slotResizeOriginal()));
 138
 139     connect(this, SIGNAL(parameterChanged()), this, SLOT(slotUpdateGeometry()));
 140 }
 141
 142
 143 Geometryval::~Geometryval()
 144 {
 145     m_scene->disconnect();
 146     delete m_syncAction;
 147     delete m_configMenu;
 148     delete m_paramRect;
 149     delete m_path;
 150     delete m_helper;
 151     delete m_geom;
 152     delete m_sceneview;
 153     delete m_scene;
 154 }
 155
 156
 157 void Geometryval::slotAlignHCenter()
 158 {
 159     if (!keyframeSelected())
 160         return;
 161     m_paramRect->setPos((m_realWidth - m_paramRect->rect().width()) / 2, m_paramRect->pos().y());
 162     slotUpdateTransitionProperties();
 163 }
 164
 165 void Geometryval::slotAlignVCenter()
 166 {
 167     if (!keyframeSelected())
 168         return;
 169     m_paramRect->setPos(m_paramRect->pos().x(), (m_profile.height - m_paramRect->rect().height()) / 2);
 170     slotUpdateTransitionProperties();
 171 }
 172
 173 void Geometryval::slotAlignTop()
 174 {
 175     if (!keyframeSelected())
 176         return;
 177     m_paramRect->setPos(m_paramRect->pos().x(), 0);
 178     slotUpdateTransitionProperties();
 179 }
 180
 181 void Geometryval::slotAlignBottom()
 182 {
 183     if (!keyframeSelected())
 184         return;
 185     m_paramRect->setPos(m_paramRect->pos().x(), m_profile.height - m_paramRect->rect().height());
 186     slotUpdateTransitionProperties();
 187 }
 188
 189 void Geometryval::slotAlignLeft()
 190 {
 191     if (!keyframeSelected())
 192         return;
 193     m_paramRect->setPos(0, m_paramRect->pos().y());
 194     slotUpdateTransitionProperties();
 195 }
 196
 197 void Geometryval::slotAlignRight()
 198 {
 199     if (!keyframeSelected())
 200         return;
 201     m_paramRect->setPos(m_realWidth - m_paramRect->rect().width(), m_paramRect->pos().y());
 202     slotUpdateTransitionProperties();
 203 }
 204
 205 void Geometryval::slotResizeOriginal()
 206 {
 207     if (!keyframeSelected())
 208         return;
 209     if (m_frameSize.isNull())
 210         m_paramRect->setRect(0, 0, m_realWidth, m_profile.height);
 211     else
 212         m_paramRect->setRect(0, 0, m_frameSize.x(), m_frameSize.y());
 213     slotUpdateTransitionProperties();
 214 }
 215
 216 void Geometryval::slotResizeCustom()
 217 {
 218     if (!keyframeSelected())
 219         return;
 220     int value = spinResize->value();
 221     m_paramRect->setRect(0, 0, m_realWidth * value / 100, m_profile.height * value / 100);
 222     slotUpdateTransitionProperties();
 223 }
 224
 225 void Geometryval::slotTransparencyChanged(int transp)
 226 {
 227     int pos = m_timePos.getValue();
 228     Mlt::GeometryItem item;
 229     int error = m_geom->fetch(&item, pos);
 230     if (error || item.key() == false) {
 231         // no keyframe under cursor
 232         return;
 233     }
 234     item.mix(transp);
 235     m_paramRect->setBrush(QColor(255, 0, 0, transp));
 236     m_geom->insert(item);
 237     emit parameterChanged();
 238 }
 239
 240 void Geometryval::slotSyncCursor()
 241 {
 242     KdenliveSettings::setTransitionfollowcursor(m_syncAction->isChecked());
 243 }
 244
 245 void Geometryval::updateTimecodeFormat()
 246 {
 247     m_timePos.slotUpdateTimeCodeFormat();
 248 }
 249
 250 void Geometryval::slotPositionChanged(int pos, bool seek)
 251 {
 252     if (pos == -1) {
 253         pos = m_timePos.getValue();
 254     }
 255     kDebug() << "// POS CHANGED: " << pos << ", SEK: " << seek;
 256     if (seek && KdenliveSettings::transitionfollowcursor()) emit seekToPos(pos + m_startPoint);
 257     m_timePos.setValue(pos);
 258     //spinPos->setValue(pos);
 259     m_helper->blockSignals(true);
 260     m_helper->setValue(pos);
 261     m_helper->blockSignals(false);
 262     Mlt::GeometryItem item;
 263     int error = m_geom->fetch(&item, pos);
 264     if (error || item.key() == false) {
 265         // no keyframe under cursor, adjust buttons
 266         buttonAdd->setEnabled(true);
 267         buttonDelete->setEnabled(false);
 268         widget->setEnabled(false);
 269         spinTransp->setEnabled(false);
 270         frameOptions->setEnabled(false);
 271         m_reset->setEnabled(false);
 272     } else {
 273         buttonAdd->setEnabled(false);
 274         buttonDelete->setEnabled(true);
 275         widget->setEnabled(true);
 276         spinTransp->setEnabled(true);
 277         frameOptions->setEnabled(true);
 278         m_reset->setEnabled(true);
 279     }
 280
 281     m_paramRect->setPos(item.x() * m_dar, item.y());
 282     m_paramRect->setRect(0, 0, item.w() * m_dar, item.h());
 283     spinTransp->setValue(item.mix());
 284     m_paramRect->setBrush(QColor(255, 0, 0, item.mix()));
 285     slotUpdateGeometry();
 286 }
 287
 288 void Geometryval::slotDeleteFrame(int pos)
 289 {
 290     // check there is more than one keyframe
 291     Mlt::GeometryItem item;
 292     int frame = m_timePos.getValue();
 293
 294     if (pos == -1) pos = frame;
 295     int error = m_geom->next_key(&item, pos + 1);
 296     if (error) {
 297         error = m_geom->prev_key(&item, pos - 1);
 298         if (error || item.frame() == pos) return;
 299     }
 300
 301     m_geom->remove(frame);
 302     buttonAdd->setEnabled(true);
 303     buttonDelete->setEnabled(false);
 304     widget->setEnabled(false);
 305     spinTransp->setEnabled(false);
 306     frameOptions->setEnabled(false);
 307     m_reset->setEnabled(false);
 308     m_helper->update();
 309     slotPositionChanged(pos, false);
 310     updateTransitionPath();
 311     emit parameterChanged();
 312 }
 313
 314 void Geometryval::slotAddFrame(int pos)
 315 {
 316     int frame = m_timePos.getValue();
 317     if (pos == -1) pos = frame;
 318     Mlt::GeometryItem item;
 319     item.frame(pos);
 320     QRectF r = m_paramRect->rect().normalized();
 321     QPointF rectpos = m_paramRect->pos();
 322     item.x(rectpos.x() / m_dar);
 323     item.y(rectpos.y());
 324     item.w(r.width() / m_dar);
 325     item.h(r.height());
 326     item.mix(spinTransp->value());
 327     m_geom->insert(item);
 328     buttonAdd->setEnabled(false);
 329     buttonDelete->setEnabled(true);
 330     widget->setEnabled(true);
 331     spinTransp->setEnabled(true);
 332     frameOptions->setEnabled(true);
 333     m_reset->setEnabled(true);
 334     m_helper->update();
 335     emit parameterChanged();
 336 }
 337
 338 void Geometryval::slotNextFrame()
 339 {
 340     Mlt::GeometryItem item;
 341     int error = m_geom->next_key(&item, m_helper->value() + 1);
 342     int pos;
 343     kDebug() << "// SEEK TO NEXT KFR: " << error;
 344     if (error) {
 345         // Go to end
 346         pos = m_helper->frameLength;
 347     } else pos = item.frame();
 348     m_timePos.setValue(pos);
 349     slotPositionChanged();
 350 }
 351
 352 void Geometryval::slotPreviousFrame()
 353 {
 354     Mlt::GeometryItem item;
 355     int error = m_geom->prev_key(&item, m_helper->value() - 1);
 356     kDebug() << "// SEEK TO NEXT KFR: " << error;
 357     if (error) return;
 358     int pos = item.frame();
 359     m_timePos.setValue(pos);
 360     slotPositionChanged();
 361 }
 362
 363
 364 QString Geometryval::getValue() const
 365 {
 366     return m_geom->serialise();
 367 }
 368
 369 void Geometryval::setupParam(const QDomElement par, int minFrame, int maxFrame)
 370 {
 371     QString val = par.attribute("value");
 372     if (par.attribute("fixed") == "1") {
 373         m_fixedMode = true;
 374         buttonPrevious->setHidden(true);
 375         buttonNext->setHidden(true);
 376         buttonDelete->setHidden(true);
 377         buttonAdd->setHidden(true);
 378         spinTransp->setMaximum(500);
 379         label_pos->setHidden(true);
 380         m_helper->setHidden(true);
 381         m_timePos.setHidden(true);
 382     }
 383     if (par.attribute("opacity") == "false") {
 384         label_opacity->setHidden(true);
 385         spinTransp->setHidden(true);
 386     }
 387     char *tmp = (char *) qstrdup(val.toUtf8().data());
 388     if (m_geom) m_geom->parse(tmp, maxFrame - minFrame, m_profile.width, m_profile.height);
 389     else m_geom = new Mlt::Geometry(tmp, maxFrame - minFrame, m_profile.width, m_profile.height);
 390     delete[] tmp;
 391
 392     //kDebug() << " / / UPDATING TRANSITION VALUE: " << m_geom->serialise();
 393     //read param her and set rect
 394     if (!m_fixedMode) {
 395         m_helper->setKeyGeometry(m_geom, maxFrame - minFrame - 1);
 396         m_helper->update();
 397         /*QDomDocument doc;
 398         doc.appendChild(doc.importNode(par, true));
 399         kDebug() << "IMPORTED TRANS: " << doc.toString();*/
 400         if (m_path == NULL) {
 401             m_path = new QGraphicsPathItem();
 402             m_path->setPen(QPen(Qt::red));
 403             m_scene->addItem(m_path);
 404         }
 405         updateTransitionPath();
 406     }
 407     Mlt::GeometryItem item;
 408
 409     m_geom->fetch(&item, 0);
 410     delete m_paramRect;
 411     m_paramRect = new QGraphicsRectItem(QRectF(0, 0, item.w() * m_dar, item.h()));
 412     m_paramRect->setPos(item.x() * m_dar, item.y());
 413     m_paramRect->setZValue(0);
 414     m_paramRect->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
 415
 416     m_paramRect->setPen(QPen(QBrush(QColor(255, 0, 0, 255)), 1.0));
 417     m_scene->addItem(m_paramRect);
 418     slotPositionChanged(0, false);
 419     slotUpdateGeometry();
 420     if (!m_fixedMode) {
 421         m_timePos.setRange(0, maxFrame - minFrame - 1);
 422         connect(&m_timePos, SIGNAL(editingFinished()), this , SLOT(slotPositionChanged()));
 423     }
 424     connect(spinTransp, SIGNAL(valueChanged(int)), this , SLOT(slotTransparencyChanged(int)));
 425 }
 426
 427 void Geometryval::updateTransitionPath()
 428 {
 429     if (m_fixedMode) return;
 430     Mlt::GeometryItem item;
 431     int pos = 0;
 432     int counter = 0;
 433     QPainterPath path;
 434     while (true) {
 435         if (m_geom->next_key(&item, pos) == 1) break;
 436         pos = item.frame();
 437         if (counter == 0) {
 438             path.moveTo(item.x() * m_dar + item.w() * m_dar / 2, item.y() + item.h() / 2);
 439         } else {
 440             path.lineTo(item.x() * m_dar + item.w() * m_dar / 2, item.y() + item.h() / 2);
 441         }
 442         counter++;
 443         pos++;
 444     }
 445     m_path->setPath(path);
 446 }
 447
 448 void Geometryval::slotUpdateTransitionProperties()
 449 {
 450     int pos = m_timePos.getValue();
 451     Mlt::GeometryItem item;
 452     int error = m_geom->next_key(&item, pos);
 453     if (error || item.frame() != pos) {
 454         // no keyframe under cursor
 455         return;
 456     }
 457     QRectF r = m_paramRect->rect().normalized();
 458     QPointF rectpos = m_paramRect->pos();
 459     item.x(rectpos.x() / m_dar);
 460     item.y(rectpos.y());
 461     item.w(r.width() / m_dar);
 462     item.h(r.height());
 463     m_geom->insert(item);
 464     updateTransitionPath();
 465     emit parameterChanged();
 466 }
 467
 468 void Geometryval::slotResetPosition()
 469 {
 470     spinX->setValue(0);
 471     spinY->setValue(0);
 472
 473     if (m_frameSize.isNull()) {
 474         spinWidth->setValue(m_realWidth);
 475         spinHeight->setValue(m_profile.height);
 476     } else {
 477         spinWidth->setValue(m_frameSize.x());
 478         spinHeight->setValue(m_frameSize.y());
 479     }
 480 }
 481
 482 void Geometryval::setFrameSize(QPoint p)
 483 {
 484     m_frameSize = p;
 485 }
 486
 487
 488 void Geometryval::slotKeyframeMoved(int pos)
 489 {
 490     slotPositionChanged(pos);
 491     slotUpdateTransitionProperties();
 492 }
 493
 494 void Geometryval::slotSwitchOptions()
 495 {
 496     if (frameOptions->isHidden()) {
 497         frameOptions->setHidden(false);
 498         m_editOptions->setChecked(true);
 499     } else {
 500         frameOptions->setHidden(true);
 501         m_editOptions->setChecked(false);
 502     }
 503     //adjustSize();
 504 }
 505
 506 void Geometryval::slotGeometryX(int value)
 507 {
 508     if (!keyframeSelected())
 509         return;
 510     m_paramRect->setPos(value, spinY->value());
 511     slotUpdateTransitionProperties();
 512 }
 513
 514 void Geometryval::slotGeometryY(int value)
 515 {
 516     if (!keyframeSelected())
 517         return;
 518     m_paramRect->setPos(spinX->value(), value);
 519     slotUpdateTransitionProperties();
 520 }
 521
 522 void Geometryval::slotGeometryWidth(int value)
 523 {
 524     if (!keyframeSelected())
 525         return;
 526     m_paramRect->setRect(0, 0, value, spinHeight->value());
 527     slotUpdateTransitionProperties();
 528 }
 529
 530 void Geometryval::slotGeometryHeight(int value)
 531 {
 532     if (!keyframeSelected())
 533         return;
 534     m_paramRect->setRect(0, 0, spinWidth->value(), value);
 535     slotUpdateTransitionProperties();
 536 }
 537
 538 void Geometryval::slotUpdateGeometry()
 539 {
 540     QRectF r = m_paramRect->rect().normalized();
 541
 542     spinX->blockSignals(true);
 543     spinY->blockSignals(true);
 544     spinWidth->blockSignals(true);
 545     spinHeight->blockSignals(true);
 546     spinResize->blockSignals(true);
 547
 548     spinX->setValue(m_paramRect->pos().x());
 549     spinY->setValue(m_paramRect->pos().y());
 550     spinWidth->setValue(r.width());
 551     spinHeight->setValue(r.height());
 552     spinResize->setValue(m_paramRect->rect().width() * 100 / m_realWidth);
 553
 554     spinX->blockSignals(false);
 555     spinY->blockSignals(false);
 556     spinWidth->blockSignals(false);
 557     spinHeight->blockSignals(false);
 558     spinResize->blockSignals(false);
 559 }
 560
 561 bool Geometryval::keyframeSelected()
 562 {
 563     Mlt::GeometryItem item;
 564     int pos = m_timePos.getValue();
 565     if (m_geom->fetch(&item, pos) || item.key() == false) return false;
 566     return true;
 567 }
 568
 569
 570