--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/phoneuis/bubblemanager2/tsrc/bubbletest2/bubbletestview.cpp Tue Aug 31 15:14:29 2010 +0300
@@ -0,0 +1,1023 @@
+/*!
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+#include <QtGui>
+#include <QDebug>
+#include <hbaction.h>
+#include <hbtoolbar.h>
+#include <bubblemanager2.h>
+#include <hbmenu.h>
+#include <hbmainwindow.h>
+#include "bubbletestview.h"
+#include <hbeffect.h>
+
+BubbleTestView::BubbleTestView(HbMainWindow& window, QGraphicsItem *parent) :
+ HbView (parent), mMainWindow(window), mMuted(0), mConfBubbleId(-1),
+ mProvideJoin(false)
+{
+ setFlags (QGraphicsItem::ItemIsFocusable);
+ setFocusPolicy (Qt::StrongFocus);
+ setTitle("BubbleTest2");
+
+ // the widget under the test
+ mBubbleManager = new BubbleManager (this);
+ setWidget(mBubbleManager);
+
+ // init toolbar
+ createToolBarActions();
+ //toolBar()->setOrientation(mMainWindow.orientation());
+ connect( &mMainWindow,SIGNAL(orientationChanged(Qt::Orientation)),
+ this,SLOT(handleOrientationChange(Qt::Orientation)));
+
+ // init menu
+ createMenuActions();
+
+ // create actions for push buttons
+ createBubbleActions();
+
+ // disable toolbar effects
+ HbEffect::disable(toolBar());
+}
+
+BubbleTestView::~BubbleTestView()
+{
+ toolBar()->clearActions();
+}
+
+void BubbleTestView::keyPressEvent(QKeyEvent *event)
+{
+ switch( event->key() )
+ {
+ case '1': // create incoming call
+ {
+ if ( mEmergencyCall->isChecked() ) {
+ return; // not supported
+ }
+
+ if ( mCalls.count() == 0 ) {
+ bubbleManager().startChanges();
+ int bubbleId = bubbleManager().createCallHeader();
+ setBubbleData(bubbleId, BubbleManager::Incoming);
+ setBubbleActions(bubbleId, BubbleManager::Incoming);
+ bubbleManager().endChanges();
+
+ // store this call
+ TestCall call;
+ call.bubbleId = bubbleId;
+ call.callState = BubbleManager::Incoming;
+ mCalls.append( call );
+
+ updateToolBarActions();
+
+ } else if ( !initializingCallExists() ) {
+ // waiting call
+ bubbleManager().startChanges();
+ int bubbleId = bubbleManager().createCallHeader();
+ setBubbleData(bubbleId, BubbleManager::Waiting);
+ setBubbleActions( bubbleId, BubbleManager::Waiting );
+ bubbleManager().setExpandedConferenceCallHeader(false);
+ bubbleManager().endChanges();
+
+ // store this call
+ TestCall call;
+ call.bubbleId = bubbleId;
+ call.callState = BubbleManager::Waiting;
+ mCalls.append( call );
+
+ setExpandActions();
+ updateToolBarActions();
+ }
+ break;
+ }
+
+ case '2': // create outgoing call
+ {
+ if ( !initializingCallExists() && (callCount()<3) ) {
+ bubbleManager().startChanges();
+ int bubbleId = bubbleManager().createCallHeader();
+ setBubbleData(bubbleId, BubbleManager::Outgoing);
+ setBubbleActions( bubbleId, BubbleManager::Outgoing );
+ bubbleManager().endChanges();
+
+ // store this call
+ TestCall call;
+ call.bubbleId = bubbleId;
+ call.callState = BubbleManager::Outgoing;
+ mCalls.append( call );
+
+ bubbleManager().setBubbleSelectionDisabled(false);
+ updateToolBarActions();
+ }
+ break;
+ }
+
+ case '3': // connect
+ {
+ int i,j;
+
+ if (callIndexByState(BubbleManagerIF::Outgoing, i)) {
+ // outgoing to alerting
+ bubbleManager().startChanges();
+ setBubbleData(mCalls[i].bubbleId, BubbleManager::Alerting);
+ bubbleManager().endChanges();
+ mCalls[i].callState = BubbleManager::Alerting;
+ return;
+ }
+
+ if (callCount()==3) {
+ // replace active call
+ bubbleManager().startChanges();
+ Q_ASSERT(callIndexByState(BubbleManagerIF::Active, j));
+ bubbleManager().removeCallHeader(mCalls[j].bubbleId);
+ mCalls.removeAt(j);
+ Q_ASSERT(callIndexByState(BubbleManagerIF::Waiting, i));
+ setBubbleData(mCalls[i].bubbleId, BubbleManager::Active);
+ setBubbleActions(mCalls[i].bubbleId, BubbleManager::Active);
+ bubbleManager().endChanges();
+ mCalls[i].callState = BubbleManager::Active;
+ setExpandActions();
+ updateToolBarActions();
+ bubbleManager().setBubbleSelectionDisabled(false);
+ } else if (callIndexByState(BubbleManagerIF::Incoming, i)||
+ callIndexByState(BubbleManagerIF::Alerting, i)||
+ callIndexByState(BubbleManagerIF::Waiting, i)) {
+ bubbleManager().startChanges();
+ setBubbleData(mCalls[i].bubbleId, BubbleManager::Active);
+ mProvideJoin = true; // bit hackish
+ setBubbleActions(mCalls[i].bubbleId, BubbleManager::Active);
+ mProvideJoin = false;
+ if (callIndexByState(BubbleManagerIF::Active, j)) {
+ setBubbleData(mCalls[j].bubbleId, BubbleManager::OnHold);
+ setBubbleActions(mCalls[j].bubbleId, BubbleManager::OnHold);
+ mCalls[j].callState = BubbleManager::OnHold;
+ }
+ bubbleManager().endChanges();
+ mCalls[i].callState = BubbleManager::Active;
+ setExpandActions();
+ updateToolBarActions();
+ bubbleManager().setBubbleSelectionDisabled(false);
+ }
+ break;
+ }
+
+ case '4': // hold
+ {
+ int i,j;
+
+ if (bubbleManager().isConferenceExpanded()) {
+ toggleHoldConference();
+ } else if (callCount()==1) {
+ // toggle hold
+ bubbleManager().startChanges();
+ if (callIndexByState(BubbleManagerIF::Active, i)||
+ callIndexByState(BubbleManagerIF::OnHold, i)) {
+ BubbleManagerIF::PhoneCallState state =
+ mCalls[i].callState == BubbleManagerIF::Active ?
+ BubbleManagerIF::OnHold : BubbleManagerIF::Active;
+
+ setBubbleData(mCalls[i].bubbleId, state);
+ setBubbleActions(mCalls[i].bubbleId, state );
+ mCalls[i].callState=state;
+ }
+ bubbleManager().endChanges();
+ updateToolBarActions();
+ } else if (callIndexByState(BubbleManagerIF::Active, i)) {
+ // swap calls
+ bubbleManager().startChanges();
+ if (callIndexByState(BubbleManagerIF::OnHold, j)) {
+ setBubbleData(mCalls[j].bubbleId, BubbleManager::Active);
+ setBubbleActions(mCalls[j].bubbleId, BubbleManager::Active );
+ mCalls[j].callState=BubbleManager::Active;
+ }
+ setBubbleData(mCalls[i].bubbleId, BubbleManager::OnHold);
+ setBubbleActions(mCalls[i].bubbleId, BubbleManager::OnHold );
+ mCalls[i].callState=BubbleManager::OnHold;
+ if (conferenceCallExists()) {
+ bubbleManager().setExpandedConferenceCallHeader(
+ bubbleIdByState(BubbleManager::Active)==mConfBubbleId);
+ }
+ bubbleManager().endChanges();
+ setExpandActions();
+ updateToolBarActions();
+ } else if (callIndexByState(BubbleManagerIF::Waiting, i)) {
+ // activate held call
+ bubbleManager().startChanges();
+ if (callIndexByState(BubbleManagerIF::OnHold, j)) {
+ setBubbleData(mCalls[j].bubbleId, BubbleManager::Active);
+ setBubbleActions(mCalls[j].bubbleId, BubbleManager::Active );
+ mCalls[j].callState=BubbleManager::Active;
+ }
+ bubbleManager().endChanges();
+ setExpandActions();
+ updateToolBarActions();
+ }
+ break;
+ }
+
+ case '5': // disconnect
+ {
+ int i,j;
+
+ if (callIndexByState(BubbleManagerIF::Disconnected, i)) {
+ bubbleManager().startChanges();
+ bubbleManager().removeCallHeader(mCalls[i].bubbleId);
+ // remove call
+ mCalls.removeAt(i);
+
+ if (mMuted) {
+ setMuted(); // unmute
+ }
+
+ bool expand = true;
+ QListIterator<TestCall> calls(mCalls);
+ while(calls.hasNext()) {
+ TestCall call = calls.next();
+ if (!call.isConf && !call.isInConf) {
+ expand = false;
+ }
+ }
+ bubbleManager().setExpandedConferenceCallHeader(expand);
+ bubbleManager().endChanges();
+
+ updateToolBarActions();
+ return;
+ }
+
+ if (callCount()) {
+ int expanded = bubbleManager().expandedBubble();
+ callIndexByBubbleId(expanded,i);
+ bubbleManager().startChanges();
+
+ if (mCalls.at(i).isConf) {
+ bubbleManager().removeConference();
+ mConfBubbleId = -1;
+ mCalls.removeAt(i);
+
+ QMutableListIterator<TestCall> calls(mCalls);
+ j=0;
+ while(calls.hasNext()) {
+ if (mCalls[j].isInConf) {
+ bubbleManager().removeCallHeader(mCalls[j].bubbleId);
+ mCalls.removeAt(j);
+ } else {
+ j++;
+ }
+ calls.next();
+ }
+ } else {
+ setBubbleData(mCalls[i].bubbleId, BubbleManager::Disconnected);
+ setBubbleActions(mCalls[i].bubbleId, BubbleManager::Disconnected);
+ mCalls[i].callState=BubbleManager::Disconnected;
+ }
+ bubbleManager().endChanges();
+ updateToolBarActions();
+ }
+ break;
+ }
+
+ case '7': // create/join conference
+ {
+ int activeCallId = bubbleIdByState(BubbleManagerIF::Active);
+ int heldCallId = bubbleIdByState(BubbleManagerIF::OnHold);
+ int i;
+
+ if (conferenceCallExists()&&(activeCallId!=-1)) {
+ int j;
+ callIndexByBubbleId(mConfBubbleId,j);
+ callIndexByBubbleId(activeCallId,i);
+ mCalls[i].isInConf = true;
+ mCalls[i].callState = BubbleManagerIF::Active;
+ mCalls[j].callState = BubbleManagerIF::Active;
+ bubbleManager().startChanges();
+ bubbleManager().addRowToConference(activeCallId);
+ bubbleManager().setExpandedConferenceCallHeader(true);
+ bubbleManager().setState(mConfBubbleId,BubbleManagerIF::Active);
+ setBubbleActions(mConfBubbleId,BubbleManagerIF::Active);
+ bubbleManager().endChanges();
+ } else if (activeCallId!=-1 && heldCallId!=-1) {
+ bubbleManager().startChanges();
+ mConfBubbleId = bubbleManager().createConference(heldCallId, activeCallId);
+ bubbleManager().setExpandedConferenceCallHeader(true);
+ bubbleManager().setState(mConfBubbleId,BubbleManagerIF::Active);
+ bubbleManager().setCli(mConfBubbleId,"Conference call",Qt::ElideRight);
+ if (mCallTimer->isChecked()) {
+ bubbleManager().setCallTime( mConfBubbleId, "00:00:00" );
+ }
+ bubbleManager().addAction(mConfBubbleId, mMute);
+ bubbleManager().addAction(mConfBubbleId, mEndConference);
+ bubbleManager().clearParticipantListActions();
+ bubbleManager().addParticipantListAction(mPrivate);
+ bubbleManager().addParticipantListAction(mDrop);
+ bubbleManager().setState(heldCallId,BubbleManagerIF::Active);
+ bubbleManager().setCallFlag(mConfBubbleId, BubbleManager::NoCiphering,
+ mCipheringOff->isChecked());
+ bubbleManager().endChanges();
+
+ callIndexByBubbleId(activeCallId,i);
+ mCalls[i].isInConf = true;
+ mCalls[i].callState = BubbleManagerIF::Active;
+ callIndexByBubbleId(heldCallId,i);
+ mCalls[i].isInConf = true;
+ mCalls[i].callState = BubbleManagerIF::Active;
+
+ // store the call
+ TestCall call;
+ call.bubbleId = mConfBubbleId;
+ call.callState = BubbleManagerIF::Active;
+ call.isConf = true;
+ call.isInConf = false;
+ mCalls.append(call);
+ }
+ break;
+ }
+
+ case '9': // conference shortcut
+ {
+ conferenceWizard();
+ break;
+ }
+
+ case '0': // updates
+ case Qt::Key_Space: // updates
+ {
+ if (mCallTimer->isChecked()) {
+ foreach (TestCall call, mCalls) {
+ if ( call.callState == BubbleManager::Active ||
+ call.callState == BubbleManager::OnHold ) {
+ bubbleManager().updateCallTime(call.bubbleId,"00:00:01");
+ }
+ }
+ }
+ }
+
+ default:
+ break;
+ }
+}
+
+bool BubbleTestView::initializingCallExists() const
+{
+ bool result = false;
+ foreach(TestCall call, mCalls) {
+ if (call.callState>=BubbleManagerIF::Incoming) {
+ result = true;
+ break;
+ }
+ }
+
+ return result;
+}
+
+bool BubbleTestView::conferenceCallExists() const
+{
+ bool result = false;
+ QListIterator<TestCall> i(mCalls);
+ while (i.hasNext()) {
+ if (i.next().isConf) {
+ result = true;
+ break;
+ }
+ }
+ return result;
+}
+
+int BubbleTestView::callCount() const
+{
+ int count = 0;
+ foreach(TestCall call, mCalls) {
+ if (!call.isInConf) {
+ count++;
+ }
+ }
+
+ return count;
+}
+
+bool BubbleTestView::callIndexByState(
+ BubbleManagerIF::PhoneCallState state, int& index)
+{
+ bool result = false;
+ int i = 0;
+ foreach(TestCall call, mCalls) {
+ if (call.callState==state && !call.isInConf) {
+ result = true;
+ index = i;
+ break;
+ }
+ i++;
+ }
+
+ return result;
+}
+
+bool BubbleTestView::callIndexByBubbleId(int bubbleId, int& index)
+{
+ bool result = false;
+ int i = 0;
+ foreach(TestCall call, mCalls) {
+ if (call.bubbleId==bubbleId) {
+ result = true;
+ index = i;
+ break;
+ }
+ i++;
+ }
+
+ return result;
+}
+
+BubbleManagerIF& BubbleTestView::bubbleManager()
+{
+ return *mBubbleManager;
+}
+
+void BubbleTestView::setBubbleData(int bubble, BubbleManagerIF::PhoneCallState state)
+{
+ bubbleManager().setState(bubble, state);
+
+ switch (state) {
+ case BubbleManager::Incoming:
+ {
+ if ( mContactName->isChecked() ) {
+ bubbleManager().setCli(bubble, "Gloria Andersson", Qt::ElideRight);
+ bubbleManager().setSecondaryCli( bubble, "+35850123456789" );
+ } else {
+ bubbleManager().setCli(bubble, "+35850123456789", Qt::ElideLeft);
+ }
+
+ setCallObject(bubble, ":resources/contactpic.jpg");
+ bubbleManager().setNumberType(bubble, BubbleManager::Mobile);
+ bubbleManager().setCallFlag(bubble, BubbleManager::Diverted, mCallDivert->isChecked());
+ bubbleManager().setCallFlag(bubble, BubbleManager::NoCiphering, mCipheringOff->isChecked());
+ bubbleManager().setLabel(bubble, "calling", Qt::ElideRight);
+ break;
+ }
+
+ case BubbleManager::Waiting:
+ {
+ if ( mContactName->isChecked() ) {
+ if (callCount()==2) {
+ bubbleManager().setCli(bubble, "Mary Poppins", Qt::ElideRight);
+ bubbleManager().setSecondaryCli(bubble, "+35840987654321");
+ } else {
+ bubbleManager().setCli(bubble, "John Doe", Qt::ElideRight);
+ bubbleManager().setSecondaryCli(bubble, "+35840987654321");
+ }
+ } else {
+ if (callCount()==2) {
+ bubbleManager().setCli(bubble, "+35850232323232", Qt::ElideLeft);
+ } else {
+ bubbleManager().setCli(bubble, "+35840987654321", Qt::ElideLeft);
+ }
+
+ }
+ setCallObject(bubble, ":resources/contactpic3.png");
+ bubbleManager().setNumberType(bubble, BubbleManager::Mobile);
+ bubbleManager().setCallFlag(bubble, BubbleManager::Diverted, mCallDivert->isChecked());
+ bubbleManager().setCallFlag(bubble, BubbleManager::NoCiphering, mCipheringOff->isChecked());
+ bubbleManager().setLabel(bubble, "waiting", Qt::ElideRight);
+ break;
+ }
+
+ case BubbleManager::Outgoing:
+ {
+ bubbleManager().setCallFlag(bubble, BubbleManager::NoCiphering, mCipheringOff->isChecked());
+
+ if (mEmergencyCall->isChecked()) {
+ bubbleManager().setCli( bubble, "emergency call", Qt::ElideRight );
+ bubbleManager().setLabel( bubble, "Attempting", Qt::ElideRight );
+ } else {
+ if ( mContactName->isChecked() ) {
+ bubbleManager().setCli( bubble, "Bart Simpson", Qt::ElideRight );
+ bubbleManager().setSecondaryCli( bubble, "+35890987654321" );
+ } else {
+ bubbleManager().setCli( bubble, "+35890987654321", Qt::ElideRight );
+ }
+ setCallObject(bubble, ":resources/contactpic2.jpg");
+ bubbleManager().setLabel( bubble, "Calling", Qt::ElideRight );
+ }
+ break;
+ }
+
+ case BubbleManager::Alerting:
+ {
+ if ( mEmergencyCall->isChecked() ) {
+ bubbleManager().setCli( bubble, "Emergency call", Qt::ElideRight );
+ }
+ break;
+ }
+
+ case BubbleManager::Active:
+ {
+ if ( mCallTimer->isChecked() ) {
+ bubbleManager().setCallTime( bubble, "00:00:00" );
+ }
+ break;
+ }
+
+ case BubbleManager::OnHold:
+ {
+ bubbleManager().setLabel( bubble, "on hold", Qt::ElideRight );
+ break;
+ }
+
+ case BubbleManager::Disconnected:
+ {
+ bubbleManager().setLabel( bubble, "disconnected", Qt::ElideRight );
+ break;
+ }
+
+ default:
+ {
+ break;
+ }
+ }
+}
+
+void BubbleTestView::setCallObject(int bubble, const QString& filename)
+{
+ if (mContactPicture->isChecked()) {
+ bubbleManager().setCallObjectImage(bubble, filename);
+ } else {
+ bubbleManager().setCallObjectFromTheme(bubble);
+ }
+}
+
+void BubbleTestView::setBubbleActions(int bubble, BubbleManagerIF::PhoneCallState state )
+{
+ if (bubble==mConfBubbleId) {
+ bubbleManager().clearActions(bubble);
+ bubbleManager().addAction(bubble, mMute);
+ bubbleManager().addAction(bubble, mEndConference);
+ return;
+ }
+
+ bubbleManager().clearActions(bubble);
+
+ switch (state) {
+ case BubbleManager::Incoming:
+ case BubbleManager::Waiting:
+ {
+ if (callCount()==2) {
+ bubbleManager().addAction( bubble, mReplace );
+ } else {
+ bubbleManager().addAction( bubble, mAnswer );
+ bubbleManager().addAction( bubble, mReject );
+ }
+ break;
+ }
+ case BubbleManager::Outgoing:
+ case BubbleManager::Alerting: // flow through
+ {
+ bubbleManager().addAction( bubble, mMute );
+ bubbleManager().addAction( bubble, mEndCall );
+ break;
+ }
+ case BubbleManager::OnHold:
+ {
+ if (mMuted) {
+ bubbleManager().addAction( bubble, mUnmute );
+ } else {
+ bubbleManager().addAction( bubble, mMute );
+ }
+ bubbleManager().addAction( bubble, mEndCall );
+ }
+ break;
+ default: // Active call
+ {
+ if (mMuted) {
+ bubbleManager().addAction( bubble, mUnmute );
+ } else {
+ bubbleManager().addAction( bubble, mMute );
+ }
+ bubbleManager().addAction( bubble, mEndCall );
+ break;
+ }
+ }
+}
+
+void BubbleTestView::setExpandActions()
+{
+ if (callCount() >= 2) {
+ int i;
+ int j;
+ int heldBubble = -1;
+ if (callIndexByState(BubbleManagerIF::Active,i) &&
+ callIndexByState(BubbleManagerIF::OnHold,j)) {
+ heldBubble = mCalls[j].bubbleId;
+ bubbleManager().setExpandAction(heldBubble, mSwap);
+ } else if (callIndexByState(BubbleManagerIF::Waiting,i) &&
+ callIndexByState(BubbleManagerIF::OnHold,j)) {
+ heldBubble = mCalls[j].bubbleId;
+ bubbleManager().setExpandAction(heldBubble, mUnhold);
+ }
+
+ // for rest set update toolbar action
+ QListIterator<TestCall> calls(mCalls);
+ while (calls.hasNext()) {
+ TestCall call = calls.next();
+ if (!call.isInConf && call.bubbleId!=heldBubble) {
+ bubbleManager().setExpandAction(call.bubbleId, mUpdateUiControls);
+ }
+ }
+ }
+}
+
+void BubbleTestView::answerCall()
+{
+ QKeyEvent event( QEvent::KeyPress, '3', 0 );
+ keyPressEvent(&event);
+}
+
+void BubbleTestView::endCall()
+{
+ QKeyEvent event( QEvent::KeyPress, '5', 0 );
+ keyPressEvent(&event);
+ keyPressEvent(&event);
+}
+
+void BubbleTestView::endConferenceCall()
+{
+ QKeyEvent event( QEvent::KeyPress, '5', 0 );
+ keyPressEvent(&event);
+}
+
+void BubbleTestView::rejectCall()
+{
+ QKeyEvent event( QEvent::KeyPress, '5', 0 );
+ keyPressEvent(&event);
+ keyPressEvent(&event);
+}
+
+void BubbleTestView::toggleHold()
+{
+ if (callCount() > 1) {
+ QTimer::singleShot(1000, this, SLOT(toggleHoldDelayed()));
+ } else {
+ QKeyEvent event( QEvent::KeyPress, '4', 0 );
+ keyPressEvent(&event);
+ }
+}
+
+void BubbleTestView::toggleHoldDelayed()
+{
+ QKeyEvent event( QEvent::KeyPress, '4', 0 );
+ keyPressEvent(&event);
+}
+
+void BubbleTestView::createIncomingCall()
+{
+ QKeyEvent event( QEvent::KeyPress, '1', 0 );
+ keyPressEvent(&event);
+ setFocus(); // hack because toolbar steals the focus
+}
+
+void BubbleTestView::createOutgoingCall()
+{
+ QKeyEvent event( QEvent::KeyPress, '2', 0 );
+ keyPressEvent(&event);
+ setFocus(); // hack because toolbar steals the focus
+}
+
+void BubbleTestView::setMuted()
+{
+ mMuted = !mMuted;
+ int bubble = bubbleManager().expandedBubble();
+ QListIterator<TestCall> calls(mCalls);
+ while (calls.hasNext()) {
+ TestCall call = calls.next();
+ if (call.bubbleId==bubble) {
+ bubbleManager().startChanges();
+ setBubbleActions(bubble, (BubbleManagerIF::PhoneCallState)call.callState);
+ bubbleManager().endChanges();
+ }
+ }
+
+ bubbleManager().setPhoneMuted( mMuted );
+ setFocus(); // hack because toolbar steals the focus
+}
+
+void BubbleTestView::joinToConference()
+{
+ QKeyEvent event( QEvent::KeyPress, '7', 0 );
+ keyPressEvent(&event);
+}
+
+void BubbleTestView::handlePrivate()
+{
+ int i;
+ qDebug() << "Handle private";
+ int selection = bubbleManager().selectionIdInConference();
+ qDebug() << "bubble:" << selection;
+ bubbleManager().startChanges();
+ if (bubbleManager().conferenceRowCount()>2) {
+ bubbleManager().removeRowFromConference(selection);
+ bubbleManager().setExpandedConferenceCallHeader(false);
+ callIndexByBubbleId(selection,i);
+ mCalls[i].isInConf = false;
+ setBubbleActions(mCalls[i].bubbleId,BubbleManagerIF::Active);
+ setBubbleData(mConfBubbleId,BubbleManagerIF::OnHold);
+ setExpandActions();
+ } else {
+ bubbleManager().removeConference();
+ callIndexByBubbleId(mConfBubbleId,i);
+ mCalls.removeAt(i);
+ mConfBubbleId = -1;
+ callIndexByBubbleId(selection,i);
+ int held = (i==0) ? 1 : 0; // ??
+ setBubbleActions(selection,BubbleManagerIF::Active);
+ setBubbleData(selection,BubbleManagerIF::Active);
+ setBubbleActions(held,BubbleManagerIF::OnHold);
+ setBubbleData(held,BubbleManagerIF::OnHold);
+ mCalls[i].isInConf = false;
+ mCalls[i].callState = BubbleManagerIF::Active;
+ int callId;
+ callIndexByBubbleId(held, callId);
+ mCalls[callId].callState = BubbleManagerIF::OnHold;
+ mCalls[callId].isInConf = false;
+ setExpandActions();
+ }
+ bubbleManager().endChanges();
+}
+
+void BubbleTestView::handleDrop()
+{
+ int i;
+ qDebug() << "Handle drop";
+ int selection = bubbleManager().selectionIdInConference();
+ qDebug() << "bubble:" << selection;
+ bubbleManager().startChanges();
+ if (bubbleManager().conferenceRowCount()>2) {
+ bubbleManager().removeRowFromConference(selection);
+ bubbleManager().removeCallHeader(selection);
+ callIndexByBubbleId(selection,i);
+ mCalls.removeAt(i);
+ } else {
+ bubbleManager().removeConference();
+ callIndexByBubbleId(mConfBubbleId,i);
+ mCalls.removeAt(i);
+ mConfBubbleId = -1;
+ bubbleManager().removeCallHeader(selection);
+ callIndexByBubbleId(selection,i);
+ mCalls.removeAt(i);
+ mCalls[0].isInConf = false;
+ setBubbleActions(mCalls[0].bubbleId,BubbleManagerIF::Active);
+ setExpandActions();
+ }
+ bubbleManager().endChanges();
+}
+
+void BubbleTestView::replaceActiveCall()
+{
+ QKeyEvent event( QEvent::KeyPress, '3', 0 );
+ keyPressEvent(&event);
+}
+
+void BubbleTestView::updateUiControls()
+{
+ if (conferenceCallExists()) {
+ bubbleManager().startChanges();
+ bubbleManager().setExpandedConferenceCallHeader(
+ bubbleManager().expandedBubble()==mConfBubbleId );
+ bubbleManager().endChanges();
+ }
+
+ updateToolBarActions();
+}
+
+void BubbleTestView::createToolBarActions()
+{
+ mCallIn = new HbAction("Call in", this);
+ connect( mCallIn, SIGNAL(triggered()), this, SLOT(createIncomingCall()), Qt::QueuedConnection );
+
+ mCallOut = new HbAction("Call out", this);
+ connect( mCallOut, SIGNAL(triggered()), this, SLOT(createOutgoingCall()), Qt::QueuedConnection );
+
+ mMute = new HbAction(HbIcon("qtg_mono_mic_mute"), "", this);
+ connect( mMute, SIGNAL(triggered()), this, SLOT(setMuted()), Qt::QueuedConnection );
+
+ mUnmute = new HbAction(HbIcon("qtg_mono_mic_unmute"), "", this);
+ connect( mUnmute, SIGNAL(triggered()), this, SLOT(setMuted()), Qt::QueuedConnection );
+
+ // not connected to anywhere
+ mActivateLoudspeaker = new HbAction(HbIcon("qtg_mono_speaker"), "", this);
+ connect( mActivateLoudspeaker, SIGNAL(triggered()), this, SLOT(createIncomingCall()), Qt::QueuedConnection );
+ mActivateHandset = new HbAction(HbIcon("qtg_mono_mobile"), "", this);
+ mSendMessage = new HbAction(HbIcon("qtg_mono_send"), "", this);
+ mSilence = new HbAction(HbIcon("qtg_mono_speaker_off"), "", this);
+ mOpenDialer = new HbAction(HbIcon("qtg_mono_dialer"), "", this);
+ mOpenContacts = new HbAction(HbIcon("qtg_mono_contacts"), "", this);
+
+ updateToolBarActions();
+}
+
+void BubbleTestView::createMenuActions()
+{
+ // HbMenu* typeMenu = menu()->addMenu("Call type"); current submenu layout sucks
+ menu()->addAction("Switch orientation",this,SLOT(switchOrientation()));
+ mCallDivert = menu()->addAction("Diverted call");
+ mCallTimer = menu()->addAction("Call timer");
+ mContactName = menu()->addAction("Contact name");
+ mContactPicture = menu()->addAction("Contact picture");
+ mCipheringOff = menu()->addAction("Ciphering off");
+ mEmergencyCall = menu()->addAction( "Emergency call" );
+ HbAction* exit = menu()->addAction( "Exit" );
+ mCallDivert->setCheckable(true);
+ mCallTimer->setCheckable(true);
+ mContactPicture->setCheckable(true);
+ mContactName->setCheckable(true);
+ mCipheringOff->setCheckable(true);
+ mEmergencyCall->setCheckable(true);
+ connect( exit, SIGNAL(triggered()), qApp, SLOT(quit()) );
+}
+
+void BubbleTestView::updateToolBarActions()
+{
+ toolBar()->clearActions();
+
+ if (!mCalls.count()) {
+ toolBar()->addAction(mCallIn);
+ toolBar()->addAction(mCallOut);
+ return;
+ }
+
+ int bubble = bubbleManager().expandedBubble();
+ int i;
+ callIndexByBubbleId(bubble,i);
+ int state = mCalls[i].callState;
+
+ if ( state == BubbleManagerIF::Incoming ||
+ state == BubbleManagerIF::Waiting ) {
+ toolBar()->addAction(mSendMessage);
+ toolBar()->addAction(mSilence);
+ } else {
+ toolBar()->addAction(mActivateLoudspeaker);
+
+ if (callCount()==1) {
+ toolBar()->addAction(mHold);
+ } else {
+ toolBar()->addAction(mSwap);
+ }
+
+ if (callCount()==1) {
+ toolBar()->addAction(mOpenContacts);
+ } else {
+ toolBar()->addAction(mJoin);
+ }
+
+ toolBar()->addAction(mOpenDialer);
+ }
+}
+
+void BubbleTestView::createBubbleActions()
+{
+ mAnswer = new HbAction( HbIcon("qtg_mono_call"),QString(), this);
+ mAnswer->setSoftKeyRole(QAction::PositiveSoftKey);
+ connect( mAnswer, SIGNAL( triggered() ), this, SLOT( answerCall() ) );
+
+ mReject= new HbAction( HbIcon("qtg_mono_reject_call"),QString(), this);
+ mReject->setSoftKeyRole(QAction::NegativeSoftKey);
+ connect( mReject, SIGNAL( triggered() ), this, SLOT( rejectCall() ) );
+
+ mHold = new HbAction( HbIcon("qtg_mono_hold_call"),QString(), this);
+ connect( mHold, SIGNAL( triggered() ), this, SLOT( toggleHold() ) );
+
+ mUnhold = new HbAction( HbIcon("qtg_mono_call"),QString(), this);
+ connect( mUnhold, SIGNAL( triggered() ), this, SLOT( toggleHold() ) );
+
+ mSwap = new HbAction( HbIcon("qtg_mono_hold_call"),QString(), this);
+ connect( mSwap, SIGNAL( triggered() ), this, SLOT( toggleHold() ) );
+
+ mEndCall = new HbAction(HbIcon("qtg_mono_end_call"),QString(), this);
+ mEndCall->setSoftKeyRole(QAction::NegativeSoftKey);
+ connect( mEndCall, SIGNAL( triggered() ), this, SLOT( endCall() ) );
+
+ mEndConference = new HbAction(HbIcon("qtg_mono_end_call"),QString(), this);
+ mEndConference->setSoftKeyRole(QAction::NegativeSoftKey);
+ connect( mEndConference, SIGNAL( triggered() ), this, SLOT( endConferenceCall() ) );
+
+ mJoin = new HbAction(HbIcon("qtg_mono_join_call"),QString(), this);
+ connect( mJoin, SIGNAL( triggered() ), this, SLOT(joinToConference()) );
+
+ mPrivate = new HbAction(HbIcon("qtg_mono_private_call"),QString(), this);
+ connect( mPrivate, SIGNAL( triggered() ), this, SLOT(handlePrivate()) );
+
+ mDrop = new HbAction(HbIcon("qtg_mono_drop_call"),QString(), this);
+ connect( mDrop, SIGNAL( triggered() ), this, SLOT(handleDrop()) );
+
+ mReplace = new HbAction(HbIcon("qtg_mono_replace_call"),QString(), this);
+ connect( mReplace, SIGNAL( triggered() ), this, SLOT(replaceActiveCall()) );
+
+ mUpdateUiControls = new HbAction(QString(), this);
+ connect( mUpdateUiControls, SIGNAL(triggered()), this, SLOT(updateUiControls()) );
+}
+
+int BubbleTestView::bubbleIdByState(BubbleManagerIF::PhoneCallState state)
+{
+ int bubbleId=-1;
+ foreach(TestCall call, mCalls) {
+ if ((call.callState==state) && !call.isInConf) {
+ bubbleId = call.bubbleId;
+ break;
+ }
+ }
+
+ return bubbleId;
+}
+
+void BubbleTestView::conferenceWizard() {
+ bubbleManager().startChanges();
+
+ for (int i=0; i<5; i++) {
+ sendKeyEvent('1');
+ sendKeyEvent('3');
+ sendKeyEvent('7');
+ }
+
+ bubbleManager().endChanges();
+}
+
+void BubbleTestView::sendKeyEvent(int key)
+{
+ QKeyEvent event( QEvent::KeyPress, key, 0 );
+ keyPressEvent(&event);
+}
+
+void BubbleTestView::switchOrientation()
+{
+ if (mMainWindow.orientation()==Qt::Vertical) {
+ mMainWindow.setOrientation(Qt::Horizontal);
+
+ } else {
+ mMainWindow.setOrientation(Qt::Vertical);
+ }
+}
+
+void BubbleTestView::handleOrientationChange(Qt::Orientation orientation)
+{
+ if (orientation==Qt::Horizontal) {
+ toolBar()->setOrientation(Qt::Horizontal);
+ }
+
+ mBubbleManager->handleOrientationChange(orientation);
+}
+
+void BubbleTestView::toggleHoldConference()
+{
+ int i;
+ if (callIndexByBubbleId(mConfBubbleId, i) ) {
+ BubbleManagerIF::PhoneCallState state =
+ (mCalls[i].callState == BubbleManagerIF::Active) ?
+ BubbleManagerIF::OnHold : BubbleManagerIF::Active;
+ bubbleManager().startChanges();
+ setBubbleData(mCalls[i].bubbleId, state);
+ setBubbleActions(mCalls[i].bubbleId, state );
+ qDebug() << "toggleHoldConference:" << state;
+ mCalls[i].callState=state;
+ bubbleManager().endChanges();
+ // update participants
+ QTimer::singleShot(500, this, SLOT(toggleConferenceHoldDelayed()));
+ }
+}
+
+void BubbleTestView::toggleConferenceHoldDelayed()
+{
+ int i;
+ callIndexByBubbleId(mConfBubbleId, i);
+ BubbleManagerIF::PhoneCallState confState =
+ (BubbleManagerIF::PhoneCallState)mCalls[i].callState;
+ // qDebug() << "toggleConferenceHoldDelayed state:" << confState;
+
+ QListIterator<TestCall> calls(mCalls);
+ int j=0;
+ while(calls.hasNext()) {
+ TestCall call = calls.next();
+ // qDebug() << "toggleConferenceHoldDelayed callState:" << call.callState;
+ if (call.isInConf && call.callState!=confState) {
+ bubbleManager().startChanges();
+ setBubbleData(call.bubbleId, confState);
+ setBubbleActions(call.bubbleId, confState);
+ mCalls[j].callState=confState;
+ bubbleManager().endChanges();
+ // next
+ QTimer::singleShot(500, this, SLOT(toggleConferenceHoldDelayed()));
+ break;
+ }
+ j++;
+ }
+}
+