Client app template and ui

client/ui/Controls/SlidingStackedWidget.cpp

@@ -0,0 +1,193 @@
+#include "SlidingStackedWidget.h"
+
+SlidingStackedWidget::SlidingStackedWidget(QWidget *parent)
+    : QStackedWidget(parent)
+{
+    if (parent != 0) {
+        m_mainwindow = parent;
+    }
+    else {
+        m_mainwindow = this;
+        qDebug().noquote() << "ATTENTION: untested mainwindow case !";
+    }
+    // parent should not be 0; not tested for any other case yet !!
+
+#ifdef Q_OS_SYMBIAN
+#ifndef __S60_50__
+    qDebug().noquote() << "WARNING: ONLY TESTED AND 5TH EDITION";
+#endif // __S60_50__
+#endif // Q_OS_SYMBIAN
+
+    // Now, initialize some private variables with default values
+    m_vertical = false;
+    // setVerticalMode(true);
+    m_speed = 500;
+    m_animationtype = QEasingCurve::OutBack; // check out the QEasingCurve documentation for different styles
+    m_now = 0;
+    m_next = 0;
+    m_wrap = false;
+    m_pnow = QPoint(0,0);
+    m_active = false;
+}
+
+SlidingStackedWidget::~SlidingStackedWidget() {
+}
+
+void SlidingStackedWidget::setVerticalMode(bool vertical) {
+    m_vertical = vertical;
+}
+
+void SlidingStackedWidget::setSpeed(int speed) {
+    m_speed = speed;
+}
+
+void SlidingStackedWidget::setAnimation(enum QEasingCurve::Type animationtype) {
+    m_animationtype = animationtype;
+}
+
+void SlidingStackedWidget::setWrap(bool wrap) {
+    m_wrap = wrap;
+}
+
+void SlidingStackedWidget::slideInNext() {
+    int now = currentIndex();
+    if (m_wrap || (now < count() - 1))
+        // count is inherit from QStackedWidget
+        slideInIdx(now + 1);
+}
+
+void SlidingStackedWidget::slideInPrev() {
+    int now = currentIndex();
+    if (m_wrap || (now > 0))
+        slideInIdx(now - 1);
+}
+
+void SlidingStackedWidget::slideInIdx(int idx, enum t_direction direction) {
+    // int idx, t_direction direction=AUTOMATIC
+    if (idx > count() - 1) {
+        direction = m_vertical ? TOP2BOTTOM : RIGHT2LEFT;
+        idx = (idx) % count();
+    }
+    else if (idx < 0) {
+        direction = m_vertical ? BOTTOM2TOP: LEFT2RIGHT;
+        idx = (idx + count()) % count();
+    }
+    slideInWgtImpl(widget(idx), direction);
+    // widget() is a function inherited from QStackedWidget
+}
+
+void SlidingStackedWidget::slideInWidget(QWidget *widget, SlidingStackedWidget::t_direction direction)
+{
+    Q_UNUSED(direction);
+
+#ifdef Q_OS_WIN
+    int idx = indexOf(widget);
+    slideInIdx(idx, direction);
+#endif
+
+#ifdef Q_OS_MAC
+    setCurrentWidget(widget);
+#endif
+}
+
+void SlidingStackedWidget::slideInWgtImpl(QWidget * newwidget, enum t_direction direction) {
+    if (m_active) {
+        return;
+    }
+    else m_active = true;
+
+    enum t_direction directionhint;
+    int now = currentIndex(); // currentIndex() is a function inherited from QStackedWidget
+    int next = indexOf(newwidget);
+    if (now == next) {
+        m_active = false;
+        return;
+    }
+    else if (now < next) {
+        directionhint = m_vertical ? TOP2BOTTOM : RIGHT2LEFT;
+    }
+    else {
+        directionhint = m_vertical ? BOTTOM2TOP : LEFT2RIGHT;
+    }
+    if (direction == AUTOMATIC) {
+        direction = directionhint;
+    }
+    // NOW....
+    // calculate the shifts
+
+    int offsetx = frameRect().width(); // inherited from mother
+    int offsety = frameRect().height(); // inherited from mother
+
+    // the following is important, to ensure that the new widget
+    // has correct geometry information when sliding in first time
+    widget(next)->setGeometry(0, 0, offsetx, offsety);
+
+    if (direction == BOTTOM2TOP) {
+        offsetx = 0;
+        offsety = -offsety;
+    }
+    else if (direction == TOP2BOTTOM) {
+        offsetx = 0;
+        // offsety = offsety;
+    }
+    else if (direction == RIGHT2LEFT) {
+        offsetx = -offsetx;
+        offsety = 0;
+    }
+    else if (direction == LEFT2RIGHT) {
+        // offsetx = offsetx;
+        offsety = 0;
+    }
+    // re-position the next widget outside/aside of the display area
+    QPoint pnext = widget(next)->pos();
+    QPoint pnow = widget(now)->pos();
+    m_pnow = pnow;
+
+    widget(next)->move(pnext.x() - offsetx, pnext.y() - offsety);
+    // make it visible/show
+    widget(next)->show();
+    widget(next)->raise();
+
+    // animate both, the now and next widget to the side, using animation framework
+    QPropertyAnimation *animnow = new QPropertyAnimation(widget(now), "pos");
+
+    animnow->setDuration(m_speed);
+    animnow->setEasingCurve(m_animationtype);
+    animnow->setStartValue(QPoint(pnow.x(), pnow.y()));
+    animnow->setEndValue(QPoint(offsetx + pnow.x(), offsety + pnow.y()));
+    QPropertyAnimation *animnext = new QPropertyAnimation(widget(next), "pos");
+    animnext->setDuration(m_speed);
+    animnext->setEasingCurve(m_animationtype);
+    animnext->setStartValue(QPoint(-offsetx + pnext.x(), offsety + pnext.y()));
+    animnext->setEndValue(QPoint(pnext.x(), pnext.y()));
+
+    QParallelAnimationGroup *animgroup = new QParallelAnimationGroup;
+
+    animgroup->addAnimation(animnow);
+    animgroup->addAnimation(animnext);
+
+    QObject::connect(animgroup, SIGNAL(finished()),this,SLOT(animationDoneSlot()));
+    m_next = next;
+    m_now = now;
+    m_active = true;
+    animgroup->start();
+
+    // note; the rest is done via a connect from the animation ready;
+    // animation->finished() provides a signal when animation is done;
+    // so we connect this to some post processing slot,
+    // that we implement here below in animationDoneSlot.
+}
+
+void SlidingStackedWidget::animationDoneSlot(void) {
+    // when ready, call the QStackedWidget slot setCurrentIndex(int)
+    setCurrentIndex(m_next); // this function is inherited from QStackedWidget
+    // then hide the outshifted widget now, and (may be done already implicitely by QStackedWidget)
+    widget(m_now)->hide();
+    // then set the position of the outshifted widget now back to its original
+    widget(m_now)->move(m_pnow);
+    // so that the application could also still call the QStackedWidget original functions/slots for changings
+    // widget(m_now)->update();
+    // setCurrentIndex(m_next); // this function is inherit from QStackedWidget
+    m_active = false;
+    emit animationFinished();
+}