X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Ftitlewidget.cpp;h=163db3b39b3ab3fab47504ea41d8a1feabe15452;hb=459decee5e330552ef73b7cb363dbbe38fdc7e87;hp=04209c090bfb323f678c293070a4a64dc5f4285a;hpb=ff6eaabf7a1377cb50d476310e2ee6e18eabd08e;p=kdenlive

diff --git a/src/titlewidget.cpp b/src/titlewidget.cpp
index 04209c09..163db3b3 100644
--- a/src/titlewidget.cpp
+++ b/src/titlewidget.cpp
@@ -17,6 +17,7 @@
 
 #include "titlewidget.h"
 #include "kdenlivesettings.h"
+#include "KoSliderCombo.h"
 
 #include <cmath>
 
@@ -25,6 +26,8 @@
 #include <KFileDialog>
 #include <KStandardDirs>
 #include <KMessageBox>
+#include <kio/netaccess.h>
+#include <kdeversion.h>
 
 #include <QDomDocument>
 #include <QGraphicsItem>
@@ -36,14 +39,24 @@
 #include <QTextBlockFormat>
 #include <QTextCursor>
 
+#if QT_VERSION >= 0x040600
+#include <QGraphicsEffect>
+#include <QGraphicsBlurEffect>
+#include <QGraphicsDropShadowEffect>
+#endif
+
 int settingUp = false;
 
 const int IMAGEITEM = 7;
 const int RECTITEM = 3;
 const int TEXTITEM = 8;
-static bool insertingValues = false;
 
-TitleWidget::TitleWidget(KUrl url, QString projectTitlePath, Render *render, QWidget *parent) :
+const int NOEFFECT = 0;
+const int BLUREFFECT = 1;
+const int SHADOWEFFECT = 2;
+const int TYPEWRITEREFFECT = 3;
+
+TitleWidget::TitleWidget(KUrl url, Timecode tc, QString projectTitlePath, Render *render, QWidget *parent) :
         QDialog(parent),
         Ui::TitleWidget_UI(),
         m_startViewport(NULL),
@@ -51,48 +64,136 @@ TitleWidget::TitleWidget(KUrl url, QString projectTitlePath, Render *render, QWi
         m_render(render),
         m_count(0),
         m_unicodeDialog(new UnicodeDialog(UnicodeDialog::InputHex)),
-        m_projectTitlePath(projectTitlePath)
+        m_projectTitlePath(projectTitlePath),
+        m_tc(tc)
 {
     setupUi(this);
     setFont(KGlobalSettings::toolBarFont());
-    //toolBox->setFont(KGlobalSettings::toolBarFont());
     frame_properties->setEnabled(false);
-    rect_properties->setFixedHeight(frame_properties->height() + 4);
-    no_properties->setFixedHeight(frame_properties->height() + 4);
-    image_properties->setFixedHeight(frame_properties->height() + 4);
-    text_properties->setFixedHeight(frame_properties->height() + 4);
     frame_properties->setFixedHeight(frame_toolbar->height());
+
+    // Set combo sliders values
+    textAlpha->setMinimum(0);
+    textAlpha->setMaximum(255);
+    textAlpha->setDecimals(0);
+    textAlpha->setValue(255);
+    textAlpha->setToolTip(i18n("Font color opacity"));
+
+    textOutlineAlpha->setMinimum(0);
+    textOutlineAlpha->setMaximum(255);
+    textOutlineAlpha->setDecimals(0);
+    textOutlineAlpha->setValue(255);
+    textOutlineAlpha->setToolTip(i18n("Outline color opacity"));
+
+    textOutline->setMinimum(0);
+    textOutline->setMaximum(200);
+    textOutline->setDecimals(0);
+    textOutline->setValue(0);
+    textOutline->setToolTip(i18n("Outline width"));
+
+    backgroundAlpha->setMinimum(0);
+    backgroundAlpha->setMaximum(255);
+    backgroundAlpha->setDecimals(0);
+    backgroundAlpha->setValue(0);
+    backgroundAlpha->setToolTip(i18n("Background color opacity"));
+
+    itemrotatex->setMinimum(-360);
+    itemrotatex->setMaximum(360);
+    itemrotatex->setDecimals(0);
+    itemrotatex->setValue(0);
+    itemrotatex->setToolTip(i18n("Rotation around the X axis"));
+
+    itemrotatey->setMinimum(-360);
+    itemrotatey->setMaximum(360);
+    itemrotatey->setDecimals(0);
+    itemrotatey->setValue(0);
+    itemrotatey->setToolTip(i18n("Rotation around the Y axis"));
+
+    itemrotatez->setMinimum(-360);
+    itemrotatez->setMaximum(360);
+    itemrotatez->setDecimals(0);
+    itemrotatez->setValue(0);
+    itemrotatez->setToolTip(i18n("Rotation around the Z axis"));
+
+    rectBAlpha->setMinimum(0);
+    rectBAlpha->setMaximum(255);
+    rectBAlpha->setDecimals(0);
+    rectBAlpha->setValue(255);
+    rectBAlpha->setToolTip(i18n("Color opacity"));
+
+    rectFAlpha->setMinimum(0);
+    rectFAlpha->setMaximum(255);
+    rectFAlpha->setDecimals(0);
+    rectFAlpha->setValue(255);
+    rectFAlpha->setToolTip(i18n("Border opacity"));
+
+    rectLineWidth->setMinimum(0);
+    rectLineWidth->setMaximum(100);
+    rectLineWidth->setDecimals(0);
+    rectLineWidth->setValue(0);
+    rectLineWidth->setToolTip(i18n("Border width"));
+
+    itemzoom->setSuffix(i18n("%"));
     m_frameWidth = render->renderWidth();
     m_frameHeight = render->renderHeight();
-    showToolbars(TITLE_NONE);
+    showToolbars(TITLE_SELECT);
+
+    //TODO: get default title duration instead of hardcoded one
+    title_duration->setText(m_tc.getTimecode(GenTime(5000 / 1000.0)));
 
-    connect(kcolorbutton, SIGNAL(clicked()), this, SLOT(slotChangeBackground())) ;
-    connect(horizontalSlider, SIGNAL(valueChanged(int)), this, SLOT(slotChangeBackground())) ;
+    connect(backgroundColor, SIGNAL(clicked()), this, SLOT(slotChangeBackground())) ;
+    connect(backgroundAlpha, SIGNAL(valueChanged(qreal, bool)), this, SLOT(slotChangeBackground())) ;
 
     connect(fontColorButton, SIGNAL(clicked()), this, SLOT(slotUpdateText())) ;
+    connect(textOutlineColor, SIGNAL(clicked()), this, SLOT(slotUpdateText())) ;
     connect(font_family, SIGNAL(currentFontChanged(const QFont &)), this, SLOT(slotUpdateText())) ;
     connect(font_size, SIGNAL(valueChanged(int)), this, SLOT(slotUpdateText())) ;
-    connect(textAlpha, SIGNAL(valueChanged(int)), this, SLOT(slotUpdateText()));
+    connect(textAlpha, SIGNAL(valueChanged(qreal, bool)), this, SLOT(slotUpdateText()));
+    connect(textOutline, SIGNAL(valueChanged(qreal, bool)), this, SLOT(slotUpdateText()));
+    connect(textOutlineAlpha, SIGNAL(valueChanged(qreal, bool)), this, SLOT(slotUpdateText()));
     connect(font_weight_box, SIGNAL(currentIndexChanged(int)), this, SLOT(slotUpdateText()));
 
-    connect(rectFAlpha, SIGNAL(valueChanged(int)), this, SLOT(rectChanged()));
-    connect(rectBAlpha, SIGNAL(valueChanged(int)), this, SLOT(rectChanged()));
+    connect(font_family, SIGNAL(editTextChanged(const QString &)), this, SLOT(slotFontText(const QString&)));
+
+    connect(rectFAlpha, SIGNAL(valueChanged(qreal, bool)), this, SLOT(rectChanged()));
+    connect(rectBAlpha, SIGNAL(valueChanged(qreal, bool)), this, SLOT(rectChanged()));
     connect(rectFColor, SIGNAL(clicked()), this, SLOT(rectChanged()));
     connect(rectBColor, SIGNAL(clicked()), this, SLOT(rectChanged()));
-    connect(rectLineWidth, SIGNAL(valueChanged(int)), this, SLOT(rectChanged()));
+    connect(rectLineWidth, SIGNAL(valueChanged(qreal, bool)), this, SLOT(rectChanged()));
 
-    connect(startViewportX, SIGNAL(valueChanged(int)), this, SLOT(setupViewports()));
+    /*connect(startViewportX, SIGNAL(valueChanged(int)), this, SLOT(setupViewports()));
     connect(startViewportY, SIGNAL(valueChanged(int)), this, SLOT(setupViewports()));
     connect(startViewportSize, SIGNAL(valueChanged(int)), this, SLOT(setupViewports()));
     connect(endViewportX, SIGNAL(valueChanged(int)), this, SLOT(setupViewports()));
     connect(endViewportY, SIGNAL(valueChanged(int)), this, SLOT(setupViewports()));
-    connect(endViewportSize, SIGNAL(valueChanged(int)), this, SLOT(setupViewports()));
+    connect(endViewportSize, SIGNAL(valueChanged(int)), this, SLOT(setupViewports()));*/
+
+    // Fill effects
+    effect_list->addItem(i18n("None"), NOEFFECT);
+    effect_list->addItem(i18n("Typewriter"), TYPEWRITEREFFECT);
+    effect_list->addItem(i18n("Blur"), BLUREFFECT);
+
 
     connect(zValue, SIGNAL(valueChanged(int)), this, SLOT(zIndexChanged(int)));
     connect(itemzoom, SIGNAL(valueChanged(int)), this, SLOT(itemScaled(int)));
-    connect(itemrotate, SIGNAL(valueChanged(int)), this, SLOT(itemRotate(int)));
+    connect(itemrotatex, SIGNAL(valueChanged(qreal, bool)), this, SLOT(itemRotateX(qreal)));
+    connect(itemrotatey, SIGNAL(valueChanged(qreal, bool)), this, SLOT(itemRotateY(qreal)));
+    connect(itemrotatez, SIGNAL(valueChanged(qreal, bool)), this, SLOT(itemRotateZ(qreal)));
     connect(itemhcenter, SIGNAL(clicked()), this, SLOT(itemHCenter()));
     connect(itemvcenter, SIGNAL(clicked()), this, SLOT(itemVCenter()));
+    connect(itemtop, SIGNAL(clicked()), this, SLOT(itemTop()));
+    connect(itembottom, SIGNAL(clicked()), this, SLOT(itemBottom()));
+    connect(itemleft, SIGNAL(clicked()), this, SLOT(itemLeft()));
+    connect(itemright, SIGNAL(clicked()), this, SLOT(itemRight()));
+    connect(effect_list, SIGNAL(currentIndexChanged(int)), this, SLOT(slotAddEffect(int)));
+    connect(typewriter_delay, SIGNAL(valueChanged(int)), this, SLOT(slotEditTypewriter(int)));
+    connect(typewriter_start, SIGNAL(valueChanged(int)), this, SLOT(slotEditTypewriter(int)));
+    connect(blur_radius, SIGNAL(valueChanged(int)), this, SLOT(slotEditBlur(int)));
+    connect(shadow_radius, SIGNAL(valueChanged(int)), this, SLOT(slotEditShadow()));
+    connect(shadow_x, SIGNAL(valueChanged(int)), this, SLOT(slotEditShadow()));
+    connect(shadow_y, SIGNAL(valueChanged(int)), this, SLOT(slotEditShadow()));
+    effect_stack->setHidden(true);
+    effect_frame->setEnabled(false);
 
     connect(origin_x_left, SIGNAL(clicked()), this, SLOT(slotOriginXClicked()));
     connect(origin_y_top, SIGNAL(clicked()), this, SLOT(slotOriginYClicked()));
@@ -154,6 +255,37 @@ TitleWidget::TitleWidget(KUrl url, QString projectTitlePath, Render *render, QWi
     connect(m_unicodeAction, SIGNAL(triggered()), this, SLOT(slotInsertUnicode()));
     buttonInsertUnicode->setDefaultAction(m_unicodeAction);
 
+    m_zUp = new QAction(KIcon("kdenlive-zindex-up"), QString(), this);
+    m_zUp->setShortcut(Qt::Key_PageUp);
+    m_zUp->setToolTip(i18n("Raise object"));
+    connect(m_zUp, SIGNAL(triggered()), this, SLOT(slotZIndexUp()));
+    zUp->setDefaultAction(m_zUp);
+
+    m_zDown = new QAction(KIcon("kdenlive-zindex-down"), QString(), this);
+    m_zDown->setShortcut(Qt::Key_PageDown);
+    m_zDown->setToolTip(i18n("Lower object"));
+    connect(m_zDown, SIGNAL(triggered()), this, SLOT(slotZIndexDown()));
+    zDown->setDefaultAction(m_zDown);
+
+    m_zTop = new QAction(KIcon("kdenlive-zindex-top"), QString(), this);
+    m_zTop->setShortcut(Qt::Key_Home);
+    m_zTop->setToolTip(i18n("Raise object to top"));
+    connect(m_zTop, SIGNAL(triggered()), this, SLOT(slotZIndexTop()));
+    zTop->setDefaultAction(m_zTop);
+
+    m_zBottom = new QAction(KIcon("kdenlive-zindex-bottom"), QString(), this);
+    m_zBottom->setShortcut(Qt::Key_End);
+    m_zBottom->setToolTip(i18n("Lower object to bottom"));
+    connect(m_zBottom, SIGNAL(triggered()), this, SLOT(slotZIndexBottom()));
+    zBottom->setDefaultAction(m_zBottom);
+
+    zDown->setIcon(KIcon("kdenlive-zindex-down"));
+    zTop->setIcon(KIcon("kdenlive-zindex-top"));
+    zBottom->setIcon(KIcon("kdenlive-zindex-bottom"));
+    connect(zDown, SIGNAL(clicked()), this, SLOT(slotZIndexDown()));
+    connect(zTop, SIGNAL(clicked()), this, SLOT(slotZIndexTop()));
+    connect(zBottom, SIGNAL(clicked()), this, SLOT(slotZIndexBottom()));
+
     origin_x_left->setToolTip(i18n("Invert x axis and change 0 point"));
     origin_y_top->setToolTip(i18n("Invert y axis and change 0 point"));
     rectBColor->setToolTip(i18n("Select fill color"));
@@ -163,18 +295,29 @@ TitleWidget::TitleWidget(KUrl url, QString projectTitlePath, Render *render, QWi
     zoom_slider->setToolTip(i18n("Zoom"));
     buttonRealSize->setToolTip(i18n("Original size (1:1)"));
     buttonFitZoom->setToolTip(i18n("Fit zoom"));
-    kcolorbutton->setToolTip(i18n("Select background color"));
-    horizontalSlider->setToolTip(i18n("Background Transparency"));
+    backgroundColor->setToolTip(i18n("Select background color"));
+    backgroundAlpha->setToolTip(i18n("Background Transparency"));
 
     itemhcenter->setIcon(KIcon("kdenlive-align-hor"));
     itemhcenter->setToolTip(i18n("Align item horizontally"));
     itemvcenter->setIcon(KIcon("kdenlive-align-vert"));
     itemvcenter->setToolTip(i18n("Align item vertically"));
+    itemtop->setIcon(KIcon("kdenlive-align-top"));
+    itemtop->setToolTip(i18n("Align item to top"));
+    itembottom->setIcon(KIcon("kdenlive-align-bottom"));
+    itembottom->setToolTip(i18n("Align item to bottom"));
+    itemright->setIcon(KIcon("kdenlive-align-right"));
+    itemright->setToolTip(i18n("Align item to right"));
+    itemleft->setIcon(KIcon("kdenlive-align-left"));
+    itemleft->setToolTip(i18n("Align item to left"));
+
 
     QHBoxLayout *layout = new QHBoxLayout;
     frame_toolbar->setLayout(layout);
-    layout->setContentsMargins(2, 2, 2, 2);
+    layout->setContentsMargins(0, 0, 0, 0);
     QToolBar *m_toolbar = new QToolBar("titleToolBar", this);
+    int s = style()->pixelMetric(QStyle::PM_SmallIconSize);
+    m_toolbar->setIconSize(QSize(s, s));
 
     m_buttonCursor = m_toolbar->addAction(KIcon("transform-move"), QString());
     m_buttonCursor->setCheckable(true);
@@ -217,8 +360,10 @@ TitleWidget::TitleWidget(KUrl url, QString projectTitlePath, Render *render, QWi
     // initialize graphic scene
     m_scene = new GraphicsSceneRectMove(this);
     graphicsView->setScene(m_scene);
-    m_titledocument.setScene(m_scene);
+    graphicsView->setMouseTracking(true);
+    m_titledocument.setScene(m_scene, m_frameWidth, m_frameHeight);
     connect(m_scene, SIGNAL(changed(QList<QRectF>)), this, SLOT(slotChanged()));
+    connect(font_size, SIGNAL(valueChanged(int)), m_scene, SLOT(slotUpdateFontSize(int)));
 
     // a gradient background
     /*QRadialGradient *gradient = new QRadialGradient(0, 0, 10);
@@ -230,7 +375,7 @@ TitleWidget::TitleWidget(KUrl url, QString projectTitlePath, Render *render, QWi
     qtrans.scale(2.0, 2.0);
     m_frameImage->setTransform(qtrans);
     m_frameImage->setZValue(-1200);
-    m_frameImage->setFlags(QGraphicsItem::ItemClipsToShape);
+    m_frameImage->setFlags(0);
     displayBackgroundFrame();
     graphicsView->scene()->addItem(m_frameImage);
 
@@ -250,26 +395,35 @@ TitleWidget::TitleWidget(KUrl url, QString projectTitlePath, Render *render, QWi
     m_frameBorder->setPen(framepen);
     m_frameBorder->setZValue(-1100);
     m_frameBorder->setBrush(Qt::transparent);
-    m_frameBorder->setFlags(QGraphicsItem::ItemClipsToShape);
+    m_frameBorder->setFlags(0);
     graphicsView->scene()->addItem(m_frameBorder);
 
     // mbd: load saved settings
     readChoices();
 
-    initViewports();
-    QTimer::singleShot(500, this, SLOT(slotAdjustZoom()));
     graphicsView->show();
     //graphicsView->setRenderHint(QPainter::Antialiasing);
     graphicsView->setInteractive(true);
     //graphicsView->resize(400, 300);
     kDebug() << "// TITLE WIDGWT: " << graphicsView->viewport()->width() << "x" << graphicsView->viewport()->height();
     //toolBox->setItemEnabled(2, false);
-    if (!url.isEmpty()) {
-        m_count = m_titledocument.loadDocument(url, m_startViewport, m_endViewport) + 1;
-        slotSelectTool();
-    } else {
+    m_startViewport = new QGraphicsRectItem(QRectF(0, 0, m_frameWidth, m_frameHeight));
+    m_endViewport = new QGraphicsRectItem(QRectF(0, 0, m_frameWidth, m_frameHeight));
+    m_startViewport->setData(0, m_frameWidth);
+    m_startViewport->setData(1, m_frameHeight);
+    m_endViewport->setData(0, m_frameWidth);
+    m_endViewport->setData(1, m_frameHeight);
+
+    if (!url.isEmpty()) loadTitle(url);
+    else {
         slotTextTool();
+        QTimer::singleShot(200, this, SLOT(slotAdjustZoom()));
     }
+    initAnimation();
+    connect(anim_start, SIGNAL(toggled(bool)), this, SLOT(slotAnimStart(bool)));
+    connect(anim_end, SIGNAL(toggled(bool)), this, SLOT(slotAnimEnd(bool)));
+
+    buttonBox->button(QDialogButtonBox::Ok)->setEnabled(KdenliveSettings::hastitleproducer());
 }
 
 TitleWidget::~TitleWidget()
@@ -281,6 +435,10 @@ TitleWidget::~TitleWidget()
     delete m_buttonSave;
     delete m_buttonLoad;
     delete m_unicodeAction;
+    delete m_zUp;
+    delete m_zDown;
+    delete m_zTop;
+    delete m_zBottom;
 
     delete m_unicodeDialog;
     delete m_frameBorder;
@@ -309,6 +467,7 @@ QStringList TitleWidget::getFreeTitleInfo(const KUrl &projectUrl, bool isClone)
     return result;
 }
 
+// static
 QString TitleWidget::getTitleResourceFromName(const KUrl &projectUrl, const QString &titleName)
 {
     QStringList result;
@@ -317,6 +476,37 @@ QString TitleWidget::getTitleResourceFromName(const KUrl &projectUrl, const QStr
     return titlePath + titleName + ".png";
 }
 
+// static
+QStringList TitleWidget::extractImageList(QString xml)
+{
+    QStringList result;
+    if (xml.isEmpty()) return result;
+    QDomDocument doc;
+    doc.setContent(xml);
+    QDomNodeList images = doc.elementsByTagName("content");
+    for (int i = 0; i < images.count(); i++) {
+        if (images.at(i).toElement().hasAttribute("url"))
+            result.append(images.at(i).toElement().attribute("url"));
+    }
+    return result;
+}
+
+// static
+QStringList TitleWidget::extractFontList(QString xml)
+{
+    QStringList result;
+    if (xml.isEmpty()) return result;
+    QDomDocument doc;
+    doc.setContent(xml);
+    QDomNodeList images = doc.elementsByTagName("content");
+    for (int i = 0; i < images.count(); i++) {
+        if (images.at(i).toElement().hasAttribute("font"))
+            result.append(images.at(i).toElement().attribute("font"));
+    }
+    return result;
+}
+
+
 //virtual
 void TitleWidget::resizeEvent(QResizeEvent * /*event*/)
 {
@@ -357,7 +547,12 @@ void TitleWidget::slotSelectTool()
             break;
         }
     }
+
     enableToolbars(t);
+    if (t == TITLE_RECTANGLE && (l.at(0) == m_endViewport || l.at(0) == m_startViewport)) {
+        //graphicsView->centerOn(l.at(0));
+        t = TITLE_SELECT;
+    }
     showToolbars(t);
 
     if (l.size() > 0) {
@@ -371,7 +566,9 @@ void TitleWidget::slotSelectTool()
 
 void TitleWidget::slotImageTool()
 {
-    KUrl url = KFileDialog::getOpenUrl(KUrl(), "*.svg *.png *.jpg *.jpeg *.gif *.raw", this, i18n("Load Image"));
+    // TODO: find a way to get a list of all supported image types...
+    QString allExtensions = "image/gif image/jpeg image/png image/x-tga image/x-bmp image/svg+xml image/tiff image/x-xcf-gimp image/x-vnd.adobe.photoshop image/x-pcx image/x-exr";
+    KUrl url = KFileDialog::getOpenUrl(KUrl(), allExtensions, this, i18n("Load Image")); //"*.svg *.png *.jpg *.jpeg *.gif *.raw"
     if (!url.isEmpty()) {
         if (url.path().endsWith(".svg")) {
             QGraphicsSvgItem *svg = new QGraphicsSvgItem(url.toLocalFile());
@@ -391,77 +588,21 @@ void TitleWidget::slotImageTool()
     }
     m_scene->setTool(TITLE_SELECT);
     showToolbars(TITLE_SELECT);
-    checkButton(TITLE_NONE);
+    checkButton(TITLE_SELECT);
 }
 
 void TitleWidget::showToolbars(TITLETOOL toolType)
 {
-    switch (toolType) {
-    case TITLE_TEXT:
-        rect_properties->setHidden(true);
-        image_properties->setHidden(true);
-        no_properties->setHidden(true);
-        text_properties->setHidden(false);
-        break;
-    case TITLE_RECTANGLE:
-        image_properties->setHidden(true);
-        no_properties->setHidden(true);
-        text_properties->setHidden(true);
-        rect_properties->setHidden(false);
-        break;
-    case TITLE_IMAGE:
-        no_properties->setHidden(true);
-        text_properties->setHidden(true);
-        rect_properties->setHidden(true);
-        image_properties->setHidden(false);
-        break;
-    default:
-        text_properties->setHidden(true);
-        rect_properties->setHidden(true);
-        image_properties->setHidden(true);
-        no_properties->setHidden(false);
-        break;
-    }
+    toolbar_stack->setCurrentIndex((int) toolType);
 }
 
 void TitleWidget::enableToolbars(TITLETOOL toolType)
 {
     // TITLETOOL is defined in graphicsscenerectmove.h
-    bool bFrame = false;
-    bool bText = false;
-    bool bRect = false;
-    bool bImage = false;
-    bool bValue_w = false;
-    bool bValue_h = false;
-
-    switch (toolType) {
-    case TITLE_SELECT:
-        break;
-    case TITLE_TEXT:
-        bFrame = true;
-        bText = true;
-        break;
-    case TITLE_RECTANGLE:
-        bFrame = true;
-        bRect = true;
-        bValue_w = true;
-        bValue_h = true;
-        break;
-    case TITLE_IMAGE:
-        bFrame = true;
-        bValue_w = true;
-        bValue_h = true;
-        bImage = true;
-        break;
-    default:
-        break;
-    }
-    frame_properties->setEnabled(bFrame);
-    text_properties->setEnabled(bText);
-    rect_properties->setEnabled(bRect);
-    image_properties->setEnabled(bImage);
-    value_w->setEnabled(bValue_w);
-    value_h->setEnabled(bValue_h);
+    bool enable = false;
+    if (toolType == TITLE_RECTANGLE || toolType == TITLE_IMAGE) enable = true;
+    value_w->setEnabled(enable);
+    value_h->setEnabled(enable);
 }
 
 void TitleWidget::checkButton(TITLETOOL toolType)
@@ -484,7 +625,7 @@ void TitleWidget::checkButton(TITLETOOL toolType)
     case TITLE_IMAGE:
         bImage = true;
         break;
-    case TITLE_NONE:
+    default:
         break;
     }
 
@@ -500,10 +641,11 @@ void TitleWidget::displayBackgroundFrame()
         QPixmap bg(m_frameWidth / 2, m_frameHeight / 2);
         QPixmap pattern(20, 20);
         pattern.fill();
+        QColor bgcolor(210, 210, 210);
         QPainter p;
         p.begin(&pattern);
-        p.fillRect(QRect(0, 0, 10, 10), QColor(210, 210, 210));
-        p.fillRect(QRect(10, 10, 20, 20), QColor(210, 210, 210));
+        p.fillRect(QRect(0, 0, 10, 10), bgcolor);
+        p.fillRect(QRect(10, 10, 20, 20), bgcolor);
         p.end();
         QBrush br(pattern);
 
@@ -512,15 +654,13 @@ void TitleWidget::displayBackgroundFrame()
         p.end();
         m_frameImage->setPixmap(bg);
     } else {
-        m_frameImage->setPixmap(m_render->extractFrame((int) m_render->seekPosition().frames(m_render->fps()), m_frameWidth / 2, m_frameHeight / 2));
+        m_frameImage->setPixmap(QPixmap::fromImage(m_render->extractFrame((int) m_render->seekPosition().frames(m_render->fps()), m_frameWidth / 2, m_frameHeight / 2)));
     }
 }
 
-void TitleWidget::initViewports()
+void TitleWidget::initAnimation()
 {
-    m_startViewport = new QGraphicsPolygonItem(QPolygonF(QRectF(0, 0, 0, 0)));
-    m_endViewport = new QGraphicsPolygonItem(QPolygonF(QRectF(0, 0, 0, 0)));
-
+    align_box->setEnabled(false);
     QPen startpen(Qt::DotLine);
     QPen endpen(Qt::DashDotLine);
     startpen.setColor(QColor(100, 200, 100, 140));
@@ -529,17 +669,19 @@ void TitleWidget::initViewports()
     m_startViewport->setPen(startpen);
     m_endViewport->setPen(endpen);
 
-    startViewportSize->setValue(100);
-    endViewportSize->setValue(100);
-
     m_startViewport->setZValue(-1000);
     m_endViewport->setZValue(-1000);
 
-    m_startViewport->setFlags(/*QGraphicsItem::ItemIsMovable|*/QGraphicsItem::ItemIsSelectable);
-    m_endViewport->setFlags(/*QGraphicsItem::ItemIsMovable|*/QGraphicsItem::ItemIsSelectable);
+    m_startViewport->setFlags(0);
+    m_endViewport->setFlags(0);
 
     graphicsView->scene()->addItem(m_startViewport);
     graphicsView->scene()->addItem(m_endViewport);
+
+    connect(keep_aspect, SIGNAL(toggled(bool)), this, SLOT(slotKeepAspect(bool)));
+    connect(resize50, SIGNAL(clicked()), this, SLOT(slotResize50()));
+    connect(resize100, SIGNAL(clicked()), this, SLOT(slotResize100()));
+    connect(resize200, SIGNAL(clicked()), this, SLOT(slotResize200()));
 }
 
 void TitleWidget::slotUpdateZoom(int pos)
@@ -587,6 +729,7 @@ void TitleWidget::slotNewRect(QGraphicsRectItem * rect)
     b.setAlpha(rectBAlpha->value());
     rect->setBrush(QBrush(b));
     rect->setZValue(m_count++);
+    rect->setData(ZOOMFACTOR, 100);
     //setCurrentItem(rect);
     //graphicsView->setFocus();
 }
@@ -606,6 +749,23 @@ void TitleWidget::slotNewText(QGraphicsTextItem *tt)
     QColor color = fontColorButton->color();
     color.setAlpha(textAlpha->value());
     tt->setDefaultTextColor(color);
+
+    QTextCursor cur(tt->document());
+    cur.select(QTextCursor::Document);
+    QTextBlockFormat format = cur.blockFormat();
+    QTextCharFormat cformat = cur.charFormat();
+    QColor outlineColor = textOutlineColor->color();
+    outlineColor.setAlpha(textOutlineAlpha->value());
+    double outlineWidth = textOutline->value() / 10.0;
+
+    tt->setData(101, outlineWidth);
+    tt->setData(102, outlineColor);
+    if (outlineWidth > 0.0) cformat.setTextOutline(QPen(outlineColor, outlineWidth));
+
+    cformat.setForeground(QBrush(color));
+    cur.setCharFormat(cformat);
+    cur.setBlockFormat(format);
+    tt->setTextCursor(cur);
     tt->setZValue(m_count++);
     setCurrentItem(tt);
 }
@@ -643,8 +803,13 @@ void TitleWidget::selectionChanged()
     value_w->blockSignals(true);
     value_h->blockSignals(true);
     itemzoom->blockSignals(true);
-    itemrotate->blockSignals(true);
+    itemrotatex->blockSignals(true);
+    itemrotatey->blockSignals(true);
+    itemrotatez->blockSignals(true);
     if (l.size() == 0) {
+        effect_stack->setHidden(true);
+        effect_frame->setEnabled(false);
+        effect_list->setCurrentIndex(0);
         bool blockX = !origin_x_left->signalsBlocked();
         bool blockY = !origin_y_top->signalsBlocked();
         if (blockX) origin_x_left->blockSignals(true);
@@ -653,15 +818,77 @@ void TitleWidget::selectionChanged()
         origin_y_top->setChecked(false);
         updateTextOriginX();
         updateTextOriginY();
-        enableToolbars(TITLE_NONE);
+        enableToolbars(TITLE_SELECT);
         if (blockX) origin_x_left->blockSignals(false);
         if (blockY) origin_y_top->blockSignals(false);
+        itemzoom->setEnabled(false);
+        itemrotatex->setEnabled(false);
+        itemrotatey->setEnabled(false);
+        itemrotatez->setEnabled(false);
+        frame_properties->setEnabled(false);
     } else if (l.size() == 1) {
+        effect_frame->setEnabled(true);
+        frame_properties->setEnabled(true);
+        if (l.at(0) != m_startViewport && l.at(0) != m_endViewport) {
+            itemzoom->setEnabled(true);
+            itemrotatex->setEnabled(true);
+            itemrotatey->setEnabled(true);
+            itemrotatez->setEnabled(true);
+        } else {
+            itemzoom->setEnabled(false);
+            itemrotatex->setEnabled(false);
+            itemrotatey->setEnabled(false);
+            itemrotatez->setEnabled(false);
+            updateInfoText();
+        }
         if (l.at(0)->type() == TEXTITEM) {
             showToolbars(TITLE_TEXT);
             QGraphicsTextItem* i = static_cast <QGraphicsTextItem *>(l.at(0));
+            if (!i->data(100).isNull()) {
+                // Item has an effect
+                QStringList effdata = i->data(100).toStringList();
+                QString effectName = effdata.takeFirst();
+                if (effectName == "typewriter") {
+                    QStringList params = effdata.at(0).split(';');
+                    typewriter_delay->setValue(params.at(0).toInt());
+                    typewriter_start->setValue(params.at(1).toInt());
+                    effect_list->setCurrentIndex(effect_list->findData((int) TYPEWRITEREFFECT));
+                    effect_stack->setHidden(false);
+                }
+            } else {
+#if QT_VERSION >= 0x040600
+                if (i->graphicsEffect()) {
+                    QGraphicsBlurEffect *blur = static_cast <QGraphicsBlurEffect *>(i->graphicsEffect());
+                    if (blur) {
+                        effect_list->setCurrentIndex(effect_list->findData((int) BLUREFFECT));
+                        int rad = (int) blur->blurRadius();
+                        blur_radius->setValue(rad);
+                        effect_stack->setHidden(false);
+                    } else {
+                        QGraphicsDropShadowEffect *shad = static_cast <QGraphicsDropShadowEffect *>(i->graphicsEffect());
+                        if (shad) {
+                            effect_list->setCurrentIndex(effect_list->findData((int) SHADOWEFFECT));
+                            shadow_radius->setValue(shad->blurRadius());
+                            shadow_x->setValue(shad->xOffset());
+                            shadow_y->setValue(shad->yOffset());
+                            effect_stack->setHidden(false);
+                        }
+                    }
+                } else {
+                    effect_list->blockSignals(true);
+                    effect_list->setCurrentIndex(effect_list->findData((int) NOEFFECT));
+                    effect_list->blockSignals(false);
+                    effect_stack->setHidden(true);
+                }
+#else
+                effect_list->blockSignals(true);
+                effect_list->setCurrentIndex(effect_list->findData((int) NOEFFECT));
+                effect_list->blockSignals(false);
+                effect_stack->setHidden(true);
+#endif
+            }
             //if (l[0]->hasFocus())
-            toolBox->setCurrentIndex(0);
+            //toolBox->setCurrentIndex(0);
             //toolBox->setItemEnabled(2, true);
             font_size->blockSignals(true);
             font_family->blockSignals(true);
@@ -678,14 +905,33 @@ void TitleWidget::selectionChanged()
             QFont font = i->font();
             font_family->setCurrentFont(font);
             font_size->setValue(font.pixelSize());
+            m_scene->slotUpdateFontSize(font.pixelSize());
             buttonItalic->setChecked(font.italic());
             buttonUnder->setChecked(font.underline());
             setFontBoxWeight(font.weight());
 
-            QColor color = i->defaultTextColor();
-            fontColorButton->setColor(color);
+            QTextCursor cursor(i->document());
+            cursor.select(QTextCursor::Document);
+            QColor color = cursor.charFormat().foreground().color();
             textAlpha->setValue(color.alpha());
+            color.setAlpha(255);
+            fontColorButton->setColor(color);
 
+            if (!i->data(101).isNull()) {
+                textOutline->blockSignals(true);
+                textOutline->setValue(i->data(101).toDouble()*10);
+                textOutline->blockSignals(false);
+            }
+            if (!i->data(102).isNull()) {
+                textOutlineColor->blockSignals(true);
+                textOutlineAlpha->blockSignals(true);
+                color = QColor(i->data(102).toString());
+                textOutlineAlpha->setValue(color.alpha());
+                color.setAlpha(255);
+                textOutlineColor->setColor(color);
+                textOutlineColor->blockSignals(false);
+                textOutlineAlpha->blockSignals(false);
+            }
             QTextCursor cur = i->textCursor();
             QTextBlockFormat format = cur.blockFormat();
             if (i->textWidth() == -1) buttonAlignNone->setChecked(true);
@@ -714,24 +960,33 @@ void TitleWidget::selectionChanged()
             showToolbars(TITLE_RECTANGLE);
             settingUp = true;
             QGraphicsRectItem *rec = static_cast <QGraphicsRectItem *>(l.at(0));
-            toolBox->setCurrentIndex(0);
-            //toolBox->setItemEnabled(3, true);
-            rectFAlpha->setValue(rec->pen().color().alpha());
-            rectBAlpha->setValue(rec->brush().color().alpha());
-            //kDebug() << rec->brush().color().alpha();
-            QColor fcol = rec->pen().color();
-            QColor bcol = rec->brush().color();
-            //fcol.setAlpha(255);
-            //bcol.setAlpha(255);
-            rectFColor->setColor(fcol);
-            rectBColor->setColor(bcol);
-            settingUp = false;
-            rectLineWidth->setValue(rec->pen().width());
+            if (rec == m_startViewport || rec == m_endViewport) {
+                /*toolBox->setCurrentIndex(3);
+                toolBox->widget(0)->setEnabled(false);
+                toolBox->widget(1)->setEnabled(false);*/
+                enableToolbars(TITLE_SELECT);
+            } else {
+                /*toolBox->widget(0)->setEnabled(true);
+                toolBox->widget(1)->setEnabled(true);
+                toolBox->setCurrentIndex(0);*/
+                //toolBox->setItemEnabled(3, true);
+                rectFAlpha->setValue(rec->pen().color().alpha());
+                rectBAlpha->setValue(rec->brush().color().alpha());
+                //kDebug() << rec->brush().color().alpha();
+                QColor fcol = rec->pen().color();
+                QColor bcol = rec->brush().color();
+                //fcol.setAlpha(255);
+                //bcol.setAlpha(255);
+                rectFColor->setColor(fcol);
+                rectBColor->setColor(bcol);
+                settingUp = false;
+                rectLineWidth->setValue(rec->pen().width());
+                enableToolbars(TITLE_RECTANGLE);
+            }
 
             updateAxisButtons(l.at(0));
             updateCoordinates(rec);
             updateDimension(rec);
-            enableToolbars(TITLE_RECTANGLE);
 
         } else if (l.at(0)->type() == IMAGEITEM) {
             showToolbars(TITLE_IMAGE);
@@ -743,21 +998,24 @@ void TitleWidget::selectionChanged()
 
         } else {
             //toolBox->setCurrentIndex(0);
-            showToolbars(TITLE_NONE);
-            enableToolbars(TITLE_NONE);
-            /*frame_properties->setEnabled(false);
-            text_properties->setEnabled(false);
-            rect_properties->setEnabled(false);*/
+            showToolbars(TITLE_SELECT);
+            enableToolbars(TITLE_SELECT);
+            frame_properties->setEnabled(false);
         }
         zValue->setValue((int)l.at(0)->zValue());
-        itemzoom->setValue((int)(m_transformations.value(l.at(0)).scalex * 100.0 + 0.5));
-        itemrotate->setValue((int)(m_transformations.value(l.at(0)).rotate));
+        if (!l.at(0)->data(ZOOMFACTOR).isNull()) itemzoom->setValue(l.at(0)->data(ZOOMFACTOR).toInt());
+        else itemzoom->setValue((int)(m_transformations.value(l.at(0)).scalex * 100.0 + 0.5));
+        itemrotatex->setValue((int)(m_transformations.value(l.at(0)).rotatex));
+        itemrotatey->setValue((int)(m_transformations.value(l.at(0)).rotatey));
+        itemrotatez->setValue((int)(m_transformations.value(l.at(0)).rotatez));
         value_x->blockSignals(false);
         value_y->blockSignals(false);
         value_w->blockSignals(false);
         value_h->blockSignals(false);
         itemzoom->blockSignals(false);
-        itemrotate->blockSignals(false);
+        itemrotatex->blockSignals(false);
+        itemrotatey->blockSignals(false);
+        itemrotatez->blockSignals(false);
     }
 }
 
@@ -781,7 +1039,8 @@ void TitleWidget::slotValueChanged(int type)
 
         // Ratio width:height
         double phi = (double) i->boundingRect().width() / i->boundingRect().height();
-        double alpha = (double) t.rotate / 180.0 * M_PI;
+        // TODO: proper calculation for rotation around 3 axes
+        double alpha = (double) t.rotatez / 180.0 * M_PI;
 
         // New length
         double length = val;
@@ -805,7 +1064,9 @@ void TitleWidget::slotValueChanged(int type)
         t.scaley = scale;
         QTransform qtrans;
         qtrans.scale(scale, scale);
-        qtrans.rotate(t.rotate);
+        qtrans.rotate(t.rotatex, Qt::XAxis);
+        qtrans.rotate(t.rotatey, Qt::YAxis);
+        qtrans.rotate(t.rotatez, Qt::ZAxis);
         i->setTransform(qtrans);
         m_transformations[i] = t;
 
@@ -840,8 +1101,9 @@ void TitleWidget::updateDimension(QGraphicsItem *i)
 {
     value_w->blockSignals(true);
     value_h->blockSignals(true);
+    zValue->blockSignals(true);
 
-
+    zValue->setValue((int) i->zValue());
     if (i->type() == IMAGEITEM) {
         // Get multipliers for rotation/scaling
 
@@ -864,6 +1126,7 @@ void TitleWidget::updateDimension(QGraphicsItem *i)
         value_h->setValue((int) t->boundingRect().height());
     }
 
+    zValue->blockSignals(false);
     value_w->blockSignals(false);
     value_h->blockSignals(false);
 }
@@ -937,14 +1200,23 @@ void TitleWidget::updateCoordinates(QGraphicsItem *i)
 void TitleWidget::updateRotZoom(QGraphicsItem *i)
 {
     itemzoom->blockSignals(true);
-    itemrotate->blockSignals(false);
+    itemrotatex->blockSignals(true);
+    itemrotatey->blockSignals(true);
+    itemrotatez->blockSignals(true);
 
     Transform t = m_transformations.value(i);
-    itemzoom->setValue((int)(t.scalex * 100.0 + 0.5));
-    itemrotate->setValue((int)(t.rotate));
+
+    if (!i->data(ZOOMFACTOR).isNull()) itemzoom->setValue(i->data(ZOOMFACTOR).toInt());
+    else itemzoom->setValue((int)(t.scalex * 100.0 + 0.5));
+
+    itemrotatex->setValue((int)(t.rotatex));
+    itemrotatey->setValue((int)(t.rotatey));
+    itemrotatez->setValue((int)(t.rotatez));
 
     itemzoom->blockSignals(false);
-    itemrotate->blockSignals(false);
+    itemrotatex->blockSignals(false);
+    itemrotatey->blockSignals(false);
+    itemrotatez->blockSignals(false);
 }
 
 /** \brief Updates the position of an item by reading coordinates from the text fields */
@@ -1094,8 +1366,8 @@ void TitleWidget::updateAxisButtons(QGraphicsItem *i)
 
 void TitleWidget::slotChangeBackground()
 {
-    QColor color = kcolorbutton->color();
-    color.setAlpha(horizontalSlider->value());
+    QColor color = backgroundColor->color();
+    color.setAlpha(backgroundAlpha->value());
     m_frameBorder->setBrush(QBrush(color));
 }
 
@@ -1165,6 +1437,9 @@ void TitleWidget::slotUpdateText()
     QColor color = fontColorButton->color();
     color.setAlpha(textAlpha->value());
 
+    QColor outlineColor = textOutlineColor->color();
+    outlineColor.setAlpha(textOutlineAlpha->value());
+    double outlineWidth = textOutline->value() / 10.0;
     QGraphicsTextItem* item = NULL;
     QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
     if (l.size() == 1 && l.at(0)->type() == TEXTITEM) {
@@ -1172,7 +1447,8 @@ void TitleWidget::slotUpdateText()
     }
     if (!item) return;
     //if (item->textCursor().selection ().isEmpty())
-    QTextCursor cur = item->textCursor();
+    QTextCursor cur(item->document());
+    cur.select(QTextCursor::Document);
     QTextBlockFormat format = cur.blockFormat();
     if (buttonAlignLeft->isChecked() || buttonAlignCenter->isChecked() || buttonAlignRight->isChecked()) {
         item->setTextWidth(item->boundingRect().width());
@@ -1184,16 +1460,19 @@ void TitleWidget::slotUpdateText()
         item->setTextWidth(-1);
     }
 
-    {
-        item->setFont(font);
-        item->setDefaultTextColor(color);
-        cur.select(QTextCursor::Document);
-        cur.setBlockFormat(format);
-        item->setTextCursor(cur);
-        cur.clearSelection();
-        item->setTextCursor(cur);
+    item->setFont(font);
+    QTextCharFormat cformat = cur.charFormat();
 
-    }
+    item->setData(101, outlineWidth);
+    item->setData(102, outlineColor);
+    if (outlineWidth > 0.0) cformat.setTextOutline(QPen(outlineColor, outlineWidth, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
+
+    cformat.setForeground(QBrush(color));
+    cur.setCharFormat(cformat);
+    cur.setBlockFormat(format);
+    item->setTextCursor(cur);
+    cur.clearSelection();
+    item->setTextCursor(cur);
 }
 
 void TitleWidget::rectChanged()
@@ -1221,24 +1500,58 @@ void TitleWidget::itemScaled(int val)
         x.scaley = (double)val / 100.0;
         QTransform qtrans;
         qtrans.scale(x.scalex, x.scaley);
-        qtrans.rotate(x.rotate);
+        qtrans.rotate(x.rotatex, Qt::XAxis);
+        qtrans.rotate(x.rotatey, Qt::YAxis);
+        qtrans.rotate(x.rotatez, Qt::ZAxis);
         l[0]->setTransform(qtrans);
+        l[0]->setData(ZOOMFACTOR, val);
         m_transformations[l.at(0)] = x;
         updateDimension(l.at(0));
     }
 }
 
-void TitleWidget::itemRotate(int val)
+void TitleWidget::itemRotateX(qreal val)
+{
+    itemRotate(val, 0);
+}
+
+void TitleWidget::itemRotateY(qreal val)
+{
+    itemRotate(val, 1);
+}
+
+void TitleWidget::itemRotateZ(qreal val)
+{
+    itemRotate(val, 2);
+}
+
+void TitleWidget::itemRotate(qreal val, int axis)
 {
     QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
     if (l.size() == 1) {
         Transform x = m_transformations[l.at(0)];
-        x.rotate = (double)val;
+        switch (axis) {
+        case 0:
+            x.rotatex = val;
+            break;
+        case 1:
+            x.rotatey = val;
+            break;
+        case 2:
+            x.rotatez = val;
+            break;
+        }
+
+        l[0]->setData(ROTATEFACTOR, QList<QVariant>() << QVariant(x.rotatex) << QVariant(x.rotatey) << QVariant(x.rotatez));
+
         QTransform qtrans;
         qtrans.scale(x.scalex, x.scaley);
-        qtrans.rotate(x.rotate);
+        qtrans.rotate(x.rotatex, Qt::XAxis);
+        qtrans.rotate(x.rotatey, Qt::YAxis);
+        qtrans.rotate(x.rotatez, Qt::ZAxis);
         l[0]->setTransform(qtrans);
         m_transformations[l.at(0)] = x;
+        if (l[0]->data(ZOOMFACTOR).isNull()) l[0]->setData(ZOOMFACTOR, 100);
         updateDimension(l.at(0));
     }
 }
@@ -1248,8 +1561,7 @@ void TitleWidget::itemHCenter()
     QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
     if (l.size() == 1) {
         QGraphicsItem *item = l.at(0);
-        QRectF br;
-        br = item->sceneBoundingRect();
+        QRectF br = item->sceneBoundingRect();
         int width = (int)br.width();
         int newPos = (int)((m_frameWidth - width) / 2);
         newPos += item->pos().x() - br.left(); // Check item transformation
@@ -1263,8 +1575,7 @@ void TitleWidget::itemVCenter()
     QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
     if (l.size() == 1) {
         QGraphicsItem *item = l.at(0);
-        QRectF br;
-        br = item->sceneBoundingRect();
+        QRectF br = item->sceneBoundingRect();
         int height = (int)br.height();
         int newPos = (int)((m_frameHeight - height) / 2);
         newPos += item->pos().y() - br.top(); // Check item transformation
@@ -1273,11 +1584,67 @@ void TitleWidget::itemVCenter()
     }
 }
 
+void TitleWidget::itemTop()
+{
+    QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
+    if (l.size() == 1) {
+        QGraphicsItem *item = l.at(0);
+        QRectF br = item->sceneBoundingRect();
+        double diff;
+        if (br.top() > 0) diff = -br.top();
+        else diff = -br.bottom();
+        item->moveBy(0, diff);
+        updateCoordinates(item);
+    }
+}
+
+void TitleWidget::itemBottom()
+{
+    QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
+    if (l.size() == 1) {
+        QGraphicsItem *item = l.at(0);
+        QRectF br = item->sceneBoundingRect();
+        double diff;
+        if (br.bottom() > m_frameHeight) diff = m_frameHeight - br.top();
+        else diff = m_frameHeight - br.bottom();
+        item->moveBy(0, diff);
+        updateCoordinates(item);
+    }
+}
+
+void TitleWidget::itemLeft()
+{
+    QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
+    if (l.size() == 1) {
+        QGraphicsItem *item = l.at(0);
+        QRectF br = item->sceneBoundingRect();
+        double diff;
+        if (br.left() > 0) diff = -br.left();
+        else diff = -br.right();
+        item->moveBy(diff, 0);
+        updateCoordinates(item);
+    }
+}
+
+void TitleWidget::itemRight()
+{
+    QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
+    if (l.size() == 1) {
+        QGraphicsItem *item = l.at(0);
+        QRectF br = item->sceneBoundingRect();
+        double diff;
+        if (br.right() < m_frameWidth) diff = m_frameWidth - br.right();
+        else diff = m_frameWidth - br.left();
+        item->moveBy(diff, 0);
+        updateCoordinates(item);
+    }
+}
+
 void TitleWidget::setupViewports()
 {
     //double aspect_ratio = 4.0 / 3.0;//read from project
     //better zoom centered, but render uses only the created rect, so no problem to change the zoom function
-    QRectF sp(0, 0, startViewportSize->value() * m_frameWidth / 100.0 , startViewportSize->value()* m_frameHeight / 100.0);
+    /*QRectF sp(0, 0, startViewportSize->value() * m_frameWidth / 100.0 , startViewportSize->value()* m_frameHeight / 100.0);
     QRectF ep(0, 0, endViewportSize->value() * m_frameWidth / 100.0, endViewportSize->value() * m_frameHeight / 100.0);
     // use a polygon thiat uses 16:9 and 4:3 rects forpreview the size in all aspect ratios ?
     QPolygonF spoly(sp);
@@ -1294,19 +1661,35 @@ void TitleWidget::setupViewports()
         m_endViewport->setData(0, endViewportX->value());
         m_endViewport->setData(1, endViewportY->value());
         m_endViewport->setData(2, endViewportSize->value());
-    }
+    }*/
 }
 
-void TitleWidget::loadTitle()
+void TitleWidget::loadTitle(KUrl url)
 {
-    KUrl url = KFileDialog::getOpenUrl(KUrl(m_projectTitlePath), "*.kdenlivetitle", this, i18n("Load Title"));
+    if (url.isEmpty()) url = KFileDialog::getOpenUrl(KUrl(m_projectTitlePath), "application/x-kdenlivetitle", this, i18n("Load Title"));
     if (!url.isEmpty()) {
         QList<QGraphicsItem *> items = m_scene->items();
         for (int i = 0; i < items.size(); i++) {
             if (items.at(i)->zValue() > -1000) delete items.at(i);
         }
         m_scene->clearTextSelection();
-        m_count = m_titledocument.loadDocument(url, m_startViewport, m_endViewport) + 1;
+        QDomDocument doc;
+        QString tmpfile;
+
+        if (KIO::NetAccess::download(url, tmpfile, 0)) {
+            QFile file(tmpfile);
+            if (file.open(QIODevice::ReadOnly)) {
+                doc.setContent(&file, false);
+                file.close();
+            } else return;
+            KIO::NetAccess::removeTempFile(tmpfile);
+        }
+        setXml(doc);
+
+        /*int out;
+        m_count = m_titledocument.loadDocument(url, m_startViewport, m_endViewport, &out) + 1;
+        adjustFrameSize();
+        title_duration->setText(m_tc.getTimecode(GenTime(out, m_render->fps())));
         insertingValues = true;
         startViewportX->setValue(m_startViewport->data(0).toInt());
         startViewportY->setValue(m_startViewport->data(1).toInt());
@@ -1314,16 +1697,31 @@ void TitleWidget::loadTitle()
         endViewportX->setValue(m_endViewport->data(0).toInt());
         endViewportY->setValue(m_endViewport->data(1).toInt());
         endViewportSize->setValue(m_endViewport->data(2).toInt());
+
         insertingValues = false;
         slotSelectTool();
+        slotAdjustZoom();*/
     }
 }
 
 void TitleWidget::saveTitle(KUrl url)
 {
-    if (url.isEmpty()) url = KFileDialog::getSaveUrl(KUrl(m_projectTitlePath), "*.kdenlivetitle", this, i18n("Save Title"));
+    if (anim_start->isChecked()) slotAnimStart(false);
+    if (anim_end->isChecked()) slotAnimEnd(false);
+    if (url.isEmpty()) {
+        KFileDialog *fs = new KFileDialog(KUrl(m_projectTitlePath), "application/x-kdenlivetitle", this);
+        fs->setOperationMode(KFileDialog::Saving);
+        fs->setMode(KFile::File);
+#if KDE_IS_VERSION(4,2,0)
+        fs->setConfirmOverwrite(true);
+#endif
+        fs->setKeepLocation(true);
+        fs->exec();
+        url = fs->selectedUrl();
+        delete fs;
+    }
     if (!url.isEmpty()) {
-        if (m_titledocument.saveDocument(url, m_startViewport, m_endViewport) == false)
+        if (m_titledocument.saveDocument(url, m_startViewport, m_endViewport, m_tc.getFrameCount(title_duration->text())) == false)
             KMessageBox::error(this, i18n("Cannot write to file %1", url.path()));
     }
 }
@@ -1331,17 +1729,28 @@ void TitleWidget::saveTitle(KUrl url)
 QDomDocument TitleWidget::xml()
 {
     QDomDocument doc = m_titledocument.xml(m_startViewport, m_endViewport);
-    if (cropImage->isChecked()) {
-        doc.documentElement().setAttribute("crop", 1);
-    }
+    doc.documentElement().setAttribute("out", m_tc.getFrameCount(title_duration->text()));
     return doc;
 }
 
+int TitleWidget::duration() const
+{
+    return m_tc.getFrameCount(title_duration->text());
+}
+
 void TitleWidget::setXml(QDomDocument doc)
 {
-    m_count = m_titledocument.loadFromXml(doc, m_startViewport, m_endViewport);
+    int out;
+    m_count = m_titledocument.loadFromXml(doc, m_startViewport, m_endViewport, &out);
+    adjustFrameSize();
+    title_duration->setText(m_tc.getTimecode(GenTime(out, m_render->fps())));
+    /*if (doc.documentElement().hasAttribute("out")) {
+    GenTime duration = GenTime(doc.documentElement().attribute("out").toDouble() / 1000.0);
+    title_duration->setText(m_tc.getTimecode(duration));
+    }
+    else title_duration->setText(m_tc.getTimecode(GenTime(5000)));*/
+
     QDomElement e = doc.documentElement();
-    cropImage->setChecked(e.hasAttribute("crop"));
     m_transformations.clear();
     QList <QGraphicsItem *> items = graphicsView->scene()->items();
     const double PI = 4.0 * atan(1.0);
@@ -1350,73 +1759,58 @@ void TitleWidget::setXml(QDomDocument doc)
         Transform x;
         x.scalex = t.m11();
         x.scaley = t.m22();
-        x.rotate = 180. / PI * atan2(-t.m21(), t.m11());
+        if (!items.at(i)->data(ROTATEFACTOR).isNull()) {
+            QList<QVariant> rotlist = items.at(i)->data(ROTATEFACTOR).toList();
+            if (rotlist.count() >= 3) {
+                x.rotatex = rotlist[0].toDouble();
+                x.rotatey = rotlist[1].toDouble();
+                x.rotatez = rotlist[2].toDouble();
+
+                // Try to adjust zoom
+                t.rotate(x.rotatex * (-1), Qt::XAxis);
+                t.rotate(x.rotatey * (-1), Qt::YAxis);
+                t.rotate(x.rotatez * (-1), Qt::ZAxis);
+                x.scalex = t.m11();
+                x.scaley = t.m22();
+            } else {
+                x.rotatex = 0;
+                x.rotatey = 0;
+                x.rotatez = 0;
+            }
+        } else {
+            x.rotatex = 0;
+            x.rotatey = 0;
+            x.rotatez = 180. / PI * atan2(-t.m21(), t.m11());
+        }
         m_transformations[items.at(i)] = x;
     }
     // mbd: Update the GUI color selectors to match the stuff from the loaded document
     QColor background_color = m_titledocument.getBackgroundColor();
-    horizontalSlider->blockSignals(true);
-    kcolorbutton->blockSignals(true);
-    horizontalSlider->setValue(background_color.alpha());
+    backgroundAlpha->blockSignals(true);
+    backgroundColor->blockSignals(true);
+    backgroundAlpha->setValue(background_color.alpha());
     background_color.setAlpha(255);
-    kcolorbutton->setColor(background_color);
-    horizontalSlider->blockSignals(false);
-    kcolorbutton->blockSignals(false);
-
+    backgroundColor->setColor(background_color);
+    backgroundAlpha->blockSignals(false);
+    backgroundColor->blockSignals(false);
+
+    /*startViewportX->setValue(m_startViewport->data(0).toInt());
+    startViewportY->setValue(m_startViewport->data(1).toInt());
+    startViewportSize->setValue(m_startViewport->data(2).toInt());
+    endViewportX->setValue(m_endViewport->data(0).toInt());
+    endViewportY->setValue(m_endViewport->data(1).toInt());
+    endViewportSize->setValue(m_endViewport->data(2).toInt());*/
+
+    QTimer::singleShot(200, this, SLOT(slotAdjustZoom()));
     slotSelectTool();
-}
-
-const QRect TitleWidget::renderedRect()
-{
-    int minX = 0;
-    int minY = 0;
-    int maxX = m_frameWidth;
-    int maxY = m_frameHeight;
-    if (!cropImage->isChecked()) {
-        m_scene->removeItem(m_startViewport);
-        m_scene->removeItem(m_endViewport);
-        QRect boundingRect = m_scene->itemsBoundingRect().toRect();
-        if (boundingRect.left() < 0) minX = boundingRect.left();
-        if (boundingRect.top() < 0) minY = boundingRect.top();
-        if (boundingRect.right() > maxX) maxX = boundingRect.right();
-        if (boundingRect.bottom() > maxY) maxY = boundingRect.bottom();
-        if (minX < 0) {
-            maxX = maxX - minX;
-        }
-        if (minY < 0) {
-            maxY = maxY - minY;
-        }
-    }
-    QRect rect(minX, minY, maxX, maxY);
-    return rect;
-}
-
-QImage TitleWidget::renderedPixmap()
-{
-    QRect rect = renderedRect();
-    QImage pix(rect.width(), rect.height(), QImage::Format_ARGB32);
-    pix.fill(Qt::transparent);
-    QPainter painter(&pix);
-    painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::HighQualityAntialiasing);
-    m_scene->clearTextSelection();
-    QPen framepen = m_frameBorder->pen();
-    m_frameBorder->setPen(Qt::NoPen);
-    m_startViewport->setVisible(false);
-    m_endViewport->setVisible(false);
-    m_frameImage->setVisible(false);
-
-    m_scene->render(&painter, QRectF(), rect); //QRectF(minX, minY, maxX - minX, maxY - minY));
-    painter.end();
-    m_frameBorder->setPen(framepen);
-    m_startViewport->setVisible(true);
-    m_endViewport->setVisible(true);
-    m_frameImage->setVisible(true);
-    return pix;
+    selectionChanged();
 }
 
 /** \brief Connected to the accepted signal - calls writeChoices */
 void TitleWidget::slotAccepted()
 {
+    if (anim_start->isChecked()) slotAnimStart(false);
+    if (anim_end->isChecked()) slotAnimEnd(false);
     writeChoices();
 }
 
@@ -1432,6 +1826,9 @@ void TitleWidget::writeChoices()
     titleConfig.writeEntry("font_pixel_size", font_size->value());
     titleConfig.writeEntry("font_color", fontColorButton->color());
     titleConfig.writeEntry("font_alpha", textAlpha->value());
+    titleConfig.writeEntry("font_outline", textOutline->value());
+    titleConfig.writeEntry("font_outline_color", textOutlineColor->color());
+    titleConfig.writeEntry("font_outline_alpha", textOutlineAlpha->value());
     titleConfig.writeEntry("font_weight", font_weight_box->itemData(font_weight_box->currentIndex()).toInt());
     titleConfig.writeEntry("font_italic", buttonItalic->isChecked());
     titleConfig.writeEntry("font_underlined", buttonUnder->isChecked());
@@ -1442,10 +1839,8 @@ void TitleWidget::writeChoices()
     titleConfig.writeEntry("rect_background_alpha", rectBAlpha->value());
     titleConfig.writeEntry("rect_line_width", rectLineWidth->value());
 
-    titleConfig.writeEntry("background_color", kcolorbutton->color());
-    titleConfig.writeEntry("background_alpha", horizontalSlider->value());
-
-    titleConfig.writeEntry("crop_image", cropImage->isChecked());
+    titleConfig.writeEntry("background_color", backgroundColor->color());
+    titleConfig.writeEntry("background_alpha", backgroundAlpha->value());
 
     //! \todo Not sure if I should sync - it is probably safe to do it
     config->sync();
@@ -1461,8 +1856,14 @@ void TitleWidget::readChoices()
     // read the entries
     font_family->setCurrentFont(titleConfig.readEntry("font_family", font_family->currentFont()));
     font_size->setValue(titleConfig.readEntry("font_pixel_size", font_size->value()));
+    m_scene->slotUpdateFontSize(font_size->value());
     fontColorButton->setColor(titleConfig.readEntry("font_color", fontColorButton->color()));
     textAlpha->setValue(titleConfig.readEntry("font_alpha", textAlpha->value()));
+
+    textOutlineColor->setColor(titleConfig.readEntry("font_outline_color", textOutlineColor->color()));
+    textOutlineAlpha->setValue(titleConfig.readEntry("font_outline_alpha", textOutlineAlpha->value()));
+    textOutline->setValue(titleConfig.readEntry("font_outline", textOutline->value()));
+
     int weight;
     if (titleConfig.readEntry("font_bold", false)) weight = QFont::Bold;
     else weight = titleConfig.readEntry("font_weight", font_weight_box->itemData(font_weight_box->currentIndex()).toInt());
@@ -1476,9 +1877,356 @@ void TitleWidget::readChoices()
     rectBAlpha->setValue(titleConfig.readEntry("rect_background_alpha", rectBAlpha->value()));
     rectLineWidth->setValue(titleConfig.readEntry("rect_line_width", rectLineWidth->value()));
 
-    kcolorbutton->setColor(titleConfig.readEntry("background_color", kcolorbutton->color()));
-    horizontalSlider->setValue(titleConfig.readEntry("background_alpha", horizontalSlider->value()));
+    backgroundColor->setColor(titleConfig.readEntry("background_color", backgroundColor->color()));
+    backgroundAlpha->setValue(titleConfig.readEntry("background_alpha", backgroundAlpha->value()));
+}
+
+void TitleWidget::adjustFrameSize()
+{
+    m_frameWidth = m_titledocument.frameWidth();
+    m_frameHeight = m_titledocument.frameHeight();
+    m_frameBorder->setRect(0, 0, m_frameWidth, m_frameHeight);
+    displayBackgroundFrame();
+}
+
+void TitleWidget::slotAnimStart(bool anim)
+{
+    if (anim && anim_end->isChecked()) {
+        anim_end->setChecked(false);
+        m_endViewport->setZValue(-1000);
+        m_endViewport->setBrush(QBrush());
+    }
+    slotSelectTool();
+    QList<QGraphicsItem *> list = m_scene->items();
+    for (int i = 0; i < list.count(); i++) {
+        if (list.at(i)->zValue() > -1000) {
+            list.at(i)->setFlag(QGraphicsItem::ItemIsMovable, !anim);
+            list.at(i)->setFlag(QGraphicsItem::ItemIsSelectable, !anim);
+        }
+    }
+    align_box->setEnabled(anim);
+    itemzoom->setEnabled(!anim);
+    itemrotatex->setEnabled(!anim);
+    itemrotatey->setEnabled(!anim);
+    itemrotatez->setEnabled(!anim);
+    frame_toolbar->setEnabled(!anim);
+    toolbar_stack->setEnabled(!anim);
+    if (anim) {
+        keep_aspect->setChecked(!m_startViewport->data(0).isNull());
+        m_startViewport->setZValue(1100);
+        QColor col = m_startViewport->pen().color();
+        col.setAlpha(100);
+        m_startViewport->setBrush(col);
+        m_startViewport->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
+        m_startViewport->setSelected(true);
+        selectionChanged();
+        slotSelectTool();
+        if (m_startViewport->childItems().isEmpty()) addAnimInfoText();
+    } else {
+        m_startViewport->setZValue(-1000);
+        m_startViewport->setBrush(QBrush());
+        m_startViewport->setFlags(0);
+        if (!anim_end->isChecked()) deleteAnimInfoText();
+    }
+
+}
+
+void TitleWidget::slotAnimEnd(bool anim)
+{
+    if (anim && anim_start->isChecked()) {
+        anim_start->setChecked(false);
+        m_startViewport->setZValue(-1000);
+        m_startViewport->setBrush(QBrush());
+    }
+    slotSelectTool();
+    QList<QGraphicsItem *> list = m_scene->items();
+    for (int i = 0; i < list.count(); i++) {
+        if (list.at(i)->zValue() > -1000) {
+            list.at(i)->setFlag(QGraphicsItem::ItemIsMovable, !anim);
+            list.at(i)->setFlag(QGraphicsItem::ItemIsSelectable, !anim);
+        }
+    }
+    align_box->setEnabled(anim);
+    itemzoom->setEnabled(!anim);
+    itemrotatex->setEnabled(!anim);
+    itemrotatey->setEnabled(!anim);
+    itemrotatez->setEnabled(!anim);
+    frame_toolbar->setEnabled(!anim);
+    toolbar_stack->setEnabled(!anim);
+    if (anim) {
+        keep_aspect->setChecked(!m_endViewport->data(0).isNull());
+        m_endViewport->setZValue(1100);
+        QColor col = m_endViewport->pen().color();
+        col.setAlpha(100);
+        m_endViewport->setBrush(col);
+        m_endViewport->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
+        m_endViewport->setSelected(true);
+        selectionChanged();
+        slotSelectTool();
+        if (m_endViewport->childItems().isEmpty()) addAnimInfoText();
+    } else {
+        m_endViewport->setZValue(-1000);
+        m_endViewport->setBrush(QBrush());
+        m_endViewport->setFlags(0);
+        if (!anim_start->isChecked()) deleteAnimInfoText();
+    }
+}
+
+void TitleWidget::addAnimInfoText()
+{
+    // add text to anim viewport
+    QGraphicsTextItem *t = new QGraphicsTextItem(i18n("Start"), m_startViewport);
+    QGraphicsTextItem *t2 = new QGraphicsTextItem(i18n("End"), m_endViewport);
+    QFont font = t->font();
+    font.setPixelSize(m_startViewport->rect().width() / 10);
+    QColor col = m_startViewport->pen().color();
+    col.setAlpha(255);
+    t->setDefaultTextColor(col);
+    t->setFont(font);
+    font.setPixelSize(m_endViewport->rect().width() / 10);
+    col = m_endViewport->pen().color();
+    col.setAlpha(255);
+    t2->setDefaultTextColor(col);
+    t2->setFont(font);
+}
+
+void TitleWidget::updateInfoText()
+{
+    // update info text font
+    if (!m_startViewport->childItems().isEmpty()) {
+        QGraphicsTextItem *item = static_cast <QGraphicsTextItem *>(m_startViewport->childItems().at(0));
+        if (item) {
+            QFont font = item->font();
+            font.setPixelSize(m_startViewport->rect().width() / 10);
+            item->setFont(font);
+        }
+    }
+    if (!m_endViewport->childItems().isEmpty()) {
+        QGraphicsTextItem *item = static_cast <QGraphicsTextItem *>(m_endViewport->childItems().at(0));
+        if (item) {
+            QFont font = item->font();
+            font.setPixelSize(m_endViewport->rect().width() / 10);
+            item->setFont(font);
+        }
+    }
+}
+
+void TitleWidget::deleteAnimInfoText()
+{
+    // end animation editing, remove info text
+    while (!m_startViewport->childItems().isEmpty()) {
+        QGraphicsItem *item = m_startViewport->childItems().at(0);
+        m_scene->removeItem(item);
+        delete item;
+    }
+    while (!m_endViewport->childItems().isEmpty()) {
+        QGraphicsItem *item = m_endViewport->childItems().at(0);
+        m_scene->removeItem(item);
+        delete item;
+    }
+}
+
+
+void TitleWidget::slotKeepAspect(bool keep)
+{
+    if (m_endViewport->zValue() == 1100) {
+        m_endViewport->setData(0, keep == true ? m_frameWidth : QVariant());
+        m_endViewport->setData(1, keep == true ? m_frameHeight : QVariant());
+    } else {
+        m_startViewport->setData(0, keep == true ? m_frameWidth : QVariant());
+        m_startViewport->setData(1, keep == true ? m_frameHeight : QVariant());
+    }
+}
+
+void TitleWidget::slotResize50()
+{
+    if (m_endViewport->zValue() == 1100) {
+        m_endViewport->setRect(0, 0, m_frameWidth / 2, m_frameHeight / 2);
+    } else m_startViewport->setRect(0, 0, m_frameWidth / 2, m_frameHeight / 2);
+}
+
+void TitleWidget::slotResize100()
+{
+    if (m_endViewport->zValue() == 1100) {
+        m_endViewport->setRect(0, 0, m_frameWidth, m_frameHeight);
+    } else m_startViewport->setRect(0, 0, m_frameWidth, m_frameHeight);
+}
+
+void TitleWidget::slotResize200()
+{
+    if (m_endViewport->zValue() == 1100) {
+        m_endViewport->setRect(0, 0, m_frameWidth * 2, m_frameHeight * 2);
+    } else m_startViewport->setRect(0, 0, m_frameWidth * 2, m_frameHeight * 2);
+}
+
+void TitleWidget::slotAddEffect(int ix)
+{
+    QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
+    int effect = effect_list->itemData(ix).toInt();
+    if (effect == NOEFFECT) {
+        if (l.size() == 1) l[0]->setData(100, QVariant());
+        effect_stack->setHidden(true);
+        return;
+    }
+    effect_stack->setCurrentIndex(effect - 1);
+    effect_stack->setHidden(false);
+    if (effect == TYPEWRITEREFFECT) {
+        if (l.size() == 1 && l.at(0)->type() == TEXTITEM) {
+            QStringList effdata = QStringList() << "typewriter" << QString::number(typewriter_delay->value()) + ";" + QString::number(typewriter_start->value());
+            l[0]->setData(100, effdata);
+        }
+    }
+#if QT_VERSION < 0x040600
+    return;
+#else
+    if (effect == BLUREFFECT) {
+        // Blur effect
+        if (l.size() == 1) {
+            QGraphicsEffect *eff = new QGraphicsBlurEffect();
+            l[0]->setGraphicsEffect(eff);
+        }
+    } else if (effect == SHADOWEFFECT) {
+        if (l.size() == 1) {
+            QGraphicsEffect *eff = new QGraphicsDropShadowEffect();
+            l[0]->setGraphicsEffect(eff);
+        }
+    }
+
+#endif
+}
+
+
+void TitleWidget::slotFontText(const QString& s)
+{
+    const QFont f(s);
+    if (f.exactMatch()) {
+        // Font really exists (could also just be a «d» if the user
+        // starts typing «dejavu» for example).
+        font_family->setCurrentFont(f);
+    }
+    // Note: Typing dejavu serif does not recognize the font (takes sans)
+    // in older Qt versions.
+}
+
+void TitleWidget::slotEditTypewriter(int ix)
+{
+    QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
+    if (l.size() == 1) {
+        QStringList effdata = QStringList() << "typewriter" << QString::number(typewriter_delay->value()) + ";" + QString::number(typewriter_start->value());
+        l[0]->setData(100, effdata);
+    }
+}
+
+void TitleWidget::slotEditBlur(int ix)
+{
+#if QT_VERSION < 0x040600
+    return;
+#else
+    QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
+    if (l.size() == 1) {
+        QGraphicsEffect *eff = l[0]->graphicsEffect();
+        QGraphicsBlurEffect *blur = static_cast <QGraphicsBlurEffect *>(eff);
+        if (blur) blur->setBlurRadius(ix);
+    }
+#endif
+}
+
+void TitleWidget::slotEditShadow()
+{
+#if QT_VERSION < 0x040600
+    return;
+#else
+    QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
+    if (l.size() == 1) {
+        QGraphicsEffect *eff = l[0]->graphicsEffect();
+        QGraphicsDropShadowEffect *shadow = static_cast <QGraphicsDropShadowEffect *>(eff);
+        if (shadow) {
+            shadow->setBlurRadius(shadow_radius->value());
+            shadow->setOffset(shadow_x->value(), shadow_y->value());
+        }
+    }
+#endif
+}
+
+qreal TitleWidget::zIndexBounds(bool maxBound)
+{
+    qreal bound = maxBound ? -99 : 99;
+    QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
+    if (l.size() > 0) {
+        QList<QGraphicsItem*> lItems = graphicsView->scene()->items(l[0]->sceneBoundingRect(), Qt::IntersectsItemShape);
+        if (lItems.size() > 0) {
+            int n = lItems.size();
+            qreal z;
+            if (maxBound) {
+                for (int i = 0; i < n; i++) {
+                    z = lItems[i]->zValue();
+                    if (z > bound && !lItems[i]->isSelected()) {
+                        bound = z;
+                    }
+                }
+            } else {
+                // Get minimum z index.
+                for (int i = 0; i < n; i++) {
+                    z = lItems[i]->zValue();
+                    if (z < bound && !lItems[i]->isSelected() && z > -999) {
+                        // There are items at the very bottom (background e.g.) with z-index < -1000.
+                        bound = z;
+                    }
+                }
+            }
+        }
+    }
+    return bound;
+}
+
+void TitleWidget::slotZIndexUp()
+{
+    QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
+    if (l.size() >= 1) {
+        qreal currentZ = l[0]->zValue();
+        qreal max = zIndexBounds(true);
+        if (currentZ <= max) {
+            l[0]->setZValue(currentZ + 1);
+            updateDimension(l[0]);
+        }
+    }
+}
+
+void TitleWidget::slotZIndexTop()
+{
+    QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
+    if (l.size() >= 1) {
+        qreal currentZ = l[0]->zValue();
+        qreal max = zIndexBounds(true);
+        if (currentZ <= max) {
+            l[0]->setZValue(max + 1);
+            updateDimension(l[0]);
+        }
+    }
+}
 
-    cropImage->setChecked(titleConfig.readEntry("crop_image", cropImage->isChecked()));
+void TitleWidget::slotZIndexDown()
+{
+    QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
+    if (l.size() >= 1) {
+        qreal currentZ = l[0]->zValue();
+        qreal min = zIndexBounds(false);
+        if (currentZ >= min) {
+            l[0]->setZValue(currentZ - 1);
+            updateDimension(l[0]);
+        }
+    }
 }
 
+void TitleWidget::slotZIndexBottom()
+{
+    QList<QGraphicsItem*> l = graphicsView->scene()->selectedItems();
+    if (l.size() >= 1) {
+        qreal currentZ = l[0]->zValue();
+        qreal min = zIndexBounds(false);
+        if (currentZ >= min) {
+            l[0]->setZValue(min - 1);
+            updateDimension(l[0]);
+        }
+    }
+}