phoneapp/phoneuiview2/src/phoneuiqtview.cpp
changeset 46 bc5a64e5bc3c
parent 45 6b911d05207e
child 51 f39ed5e045e0
child 60 1eef62f5c541
equal deleted inserted replaced
45:6b911d05207e 46:bc5a64e5bc3c
    13 *
    13 *
    14 * Description:  Phone UI's Qt view.
    14 * Description:  Phone UI's Qt view.
    15 *
    15 *
    16 */
    16 */
    17 #include <hbinstance.h>
    17 #include <hbinstance.h>
    18 #include <qsignalmapper>
    18 #include <QSignalMapper>
    19 #include <hbaction.h>
    19 #include <hbaction.h>
    20 #include <hbtoolbar.h>
    20 #include <hbtoolbar.h>
    21 #include <hbvolumesliderpopup.h>
    21 #include <hbvolumesliderpopup.h>
    22 #include <hbnamespace.h>
    22 #include <hbnamespace.h>
    23 #include <bubblemanager2.h>
    23 #include <bubblemanager2.h>
    34 #include "qtphonelog.h"
    34 #include "qtphonelog.h"
    35 
    35 
    36 PhoneUIQtView::PhoneUIQtView (HbMainWindow &window, QGraphicsItem *parent) :
    36 PhoneUIQtView::PhoneUIQtView (HbMainWindow &window, QGraphicsItem *parent) :
    37     HbView (parent),
    37     HbView (parent),
    38     m_window(window),
    38     m_window(window),
       
    39     m_bubbleManager(0),
       
    40     m_signalMapper(0),
    39     m_volumeSlider (0),
    41     m_volumeSlider (0),
    40     m_expandSignalMapper(0),
    42     m_expandSignalMapper(0),
    41     m_participantListSignalMapper(0),
    43     m_participantListSignalMapper(0),
    42     m_volumeCommandId(0),
    44     m_volumeCommandId(0),
       
    45     m_backAction(0),
       
    46     m_dialpad(0),
       
    47     m_menuSignalMapper(0),
    43     m_keyCapture(0),
    48     m_keyCapture(0),
    44     m_networkInfo(0)
    49     m_networkInfo(0),
       
    50     m_dialpadKeyHandler(0),
       
    51     m_restrictedMode(false)
    45 {
    52 {
    46     // Set network name
    53     // Set network name
    47     m_networkInfo = new QSystemNetworkInfo(this);
    54     m_networkInfo = new QSystemNetworkInfo(this);
    48     QString networkName = m_networkInfo->networkName(QSystemNetworkInfo::WcdmaMode);
    55     QString networkName = m_networkInfo->networkName(QSystemNetworkInfo::WcdmaMode);
    49     if(networkName.isEmpty()) {
    56     if(networkName.isEmpty()) {
    50         networkName = m_networkInfo->networkName(QSystemNetworkInfo::GsmMode);
    57         networkName = m_networkInfo->networkName(QSystemNetworkInfo::GsmMode);
    51     }
    58     }
    52     connect(m_networkInfo, SIGNAL (networkNameChanged(QSystemNetworkInfo::NetworkMode,QString)), this, SLOT(networkNameChanged(QSystemNetworkInfo::NetworkMode, QString)));
    59     connect(m_networkInfo, SIGNAL (networkNameChanged(QSystemNetworkInfo::NetworkMode,QString)),
       
    60             this, SLOT(networkNameChanged(QSystemNetworkInfo::NetworkMode, QString)));
    53     setTitle(networkName);
    61     setTitle(networkName);
    54 
    62 
    55     // Capturing long press of end key
    63     // Capturing long press of end key
    56     m_keyCapture = new XqKeyCapture();
    64     m_keyCapture = new XqKeyCapture();
    57     m_keyCapture->captureLongKey(Qt::Key_No);
       
    58     m_keyCapture->captureKey(Qt::Key_No);
       
    59     
    65     
    60     // Dialpad
    66     // Dialpad
    61     m_dialpad = new Dialpad(m_window);
    67     m_dialpad = new Dialpad(m_window);
    62     m_dialpad->setCallButtonEnabled(false);
    68     m_dialpad->setCallButtonEnabled(false);
    63     m_dialpad->setTapOutsideDismiss(true);
    69     m_dialpad->setTapOutsideDismiss(true);
    64     connect(&m_dialpad->editor(),SIGNAL(contentsChanged()),
       
    65             SLOT(onEditorContentChanged()));
       
    66     connect(m_dialpad,SIGNAL(aboutToClose()),this,
    70     connect(m_dialpad,SIGNAL(aboutToClose()),this,
    67                 SLOT(dialpadClosed()));
    71                 SLOT(dialpadClosed()));
    68     // enable key sequence handling during a call
       
    69     new DialpadKeyHandler(m_dialpad, DialpadKeyHandler::KeySequence, this);
       
    70     
    72     
    71     // Call handling widget
    73     // Call handling widget
    72     m_bubbleManager = new BubbleManager (this);
    74     m_bubbleManager = new BubbleManager (this);
    73     setWidget(m_bubbleManager);
    75     setWidget(m_bubbleManager);
    74 
    76 
    89     m_backAction = new HbAction(Hb::BackNaviAction, this);
    91     m_backAction = new HbAction(Hb::BackNaviAction, this);
    90     connect(m_backAction, SIGNAL(triggered()), this, SLOT(backButtonClicked()));
    92     connect(m_backAction, SIGNAL(triggered()), this, SLOT(backButtonClicked()));
    91     setNavigationAction(m_backAction);
    93     setNavigationAction(m_backAction);
    92 
    94 
    93     createToolBarActions();
    95     createToolBarActions();
       
    96 
       
    97     // Set restricted mode off, normal state
       
    98     setRestrictedMode(false);
    94 }
    99 }
    95 
   100 
    96 PhoneUIQtView::~PhoneUIQtView ()
   101 PhoneUIQtView::~PhoneUIQtView ()
    97 {
   102 {
    98     qDeleteAll(m_toolbarActions);
   103     qDeleteAll(m_toolbarActions);
   403 HbMenu &PhoneUIQtView::menuReference()
   408 HbMenu &PhoneUIQtView::menuReference()
   404 {
   409 {
   405     return *menu();
   410     return *menu();
   406 }
   411 }
   407 
   412 
       
   413 void PhoneUIQtView::captureKey(Qt::Key key, bool capture)
       
   414 {
       
   415     if (capture) {
       
   416         if (!m_keyCaptures.contains(key)) {
       
   417             m_keyCapture->captureLongKey(key);
       
   418             m_keyCapture->captureKey(key);
       
   419             m_keyCaptures.append(key);
       
   420         }
       
   421     } else {
       
   422         if (m_keyCaptures.contains(key)) {
       
   423             m_keyCapture->cancelCaptureKey(key);
       
   424             m_keyCapture->cancelCaptureLongKey(key);
       
   425             m_keyCaptures.removeOne(key);
       
   426         }
       
   427     }
       
   428 }
       
   429 
   408 void PhoneUIQtView::handleOrientationChange(Qt::Orientation orientation)
   430 void PhoneUIQtView::handleOrientationChange(Qt::Orientation orientation)
   409 {
   431 {
   410     if (orientation==Qt::Horizontal) {
   432     if (orientation==Qt::Horizontal) {
   411         toolBar()->setOrientation(Qt::Horizontal);
   433         toolBar()->setOrientation(Qt::Horizontal);
   412     }
   434     }
   434 
   456 
   435 bool PhoneUIQtView::eventFilter(QObject *watched, QEvent * event)
   457 bool PhoneUIQtView::eventFilter(QObject *watched, QEvent * event)
   436 {
   458 {
   437     Q_UNUSED(watched);
   459     Q_UNUSED(watched);
   438     PHONE_DEBUG2("PhoneUIQtView::eventFilter event type:", event->type());
   460     PHONE_DEBUG2("PhoneUIQtView::eventFilter event type:", event->type());
       
   461     
       
   462     // Allow send key only when there is callbutton enabled or no text in input field
       
   463     bool sendKeyAllowed = m_dialpad->isCallButtonEnabled() || 
       
   464             (m_dialpad->editor().text().length() == 0);
       
   465     
   439     if(event->type() == QEvent::KeyPress) {
   466     if(event->type() == QEvent::KeyPress) {
   440         QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
   467         QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
   441         PHONE_DEBUG2("PhoneUIQtView::eventFilter pressed key:", keyEvent->key());
   468         PHONE_DEBUG2("PhoneUIQtView::eventFilter pressed key:", keyEvent->key());
   442         PHONE_DEBUG2("PhoneUIQtView::eventFilter isAutoRepeat:", keyEvent->isAutoRepeat());
   469         PHONE_DEBUG2("PhoneUIQtView::eventFilter isAutoRepeat:", keyEvent->isAutoRepeat());
   443         emit keyPressed(keyEvent);        
   470         if ( (keyEvent->key() != Qt::Key_Yes && keyEvent->key() != Qt::Key_Enter) ||
   444         keyEvent->accept();
   471                 sendKeyAllowed) {
       
   472             emit keyPressed(keyEvent);        
       
   473             keyEvent->accept();
       
   474         }
   445         
   475         
   446         return false;
   476         return false;
   447     } else if(event->type() == QEvent::KeyRelease) {
   477     } else if(event->type() == QEvent::KeyRelease) {
   448         QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
   478         QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
   449         PHONE_DEBUG2("PhoneUIQtView::eventFilter released key:", keyEvent->key());
   479         PHONE_DEBUG2("PhoneUIQtView::eventFilter released key:", keyEvent->key());
   450         emit keyReleased(keyEvent);
   480         if ( (keyEvent->key() != Qt::Key_Yes && keyEvent->key() != Qt::Key_Enter) ||
   451         keyEvent->accept();
   481                 sendKeyAllowed) {
   452         
   482             emit keyReleased(keyEvent);
       
   483             keyEvent->accept();
       
   484         }
   453         return false;
   485         return false;
   454     } else if (event->type() == QEvent::WindowActivate){
   486     } else if (event->type() == QEvent::WindowActivate){
   455         PHONE_DEBUG("PhoneUIQtView::eventFilter WindowActivate");
   487         PHONE_DEBUG("PhoneUIQtView::eventFilter WindowActivate");
   456         emit windowActivated();
   488         emit windowActivated();
   457         return false;
   489         return false;
   508     QCoreApplication::quit();
   540     QCoreApplication::quit();
   509 }
   541 }
   510 
   542 
   511 void PhoneUIQtView::setBackButtonVisible(bool visible)
   543 void PhoneUIQtView::setBackButtonVisible(bool visible)
   512 {
   544 {
   513     m_backAction->setEnabled(visible);
   545     if (!m_restrictedMode) {
       
   546         m_backAction->setEnabled(visible);
       
   547     }
       
   548 }
       
   549 
       
   550 void PhoneUIQtView::setRestrictedMode(bool restrictedMode)
       
   551 {
       
   552     m_restrictedMode = restrictedMode;
       
   553     m_backAction->setEnabled(!restrictedMode);
       
   554     m_dialpad->setCallButtonEnabled(false);
       
   555     m_dialpad->editor().setText(""); // Clead dialpad
       
   556     if (m_restrictedMode) {
       
   557         delete m_dialpadKeyHandler;
       
   558         m_dialpadKeyHandler = 0;
       
   559         m_dialpadKeyHandler = new DialpadKeyHandler(
       
   560                 m_dialpad, DialpadKeyHandler::EmergencyCall, this);
       
   561         disconnect(&m_dialpad->editor(),SIGNAL(contentsChanged()),
       
   562                 this, SLOT(onEditorContentChanged())); // Let emergency handler do updating 
       
   563     } else {
       
   564         delete m_dialpadKeyHandler;
       
   565         m_dialpadKeyHandler = 0;
       
   566         // enable key sequence handling during a call
       
   567         m_dialpadKeyHandler = new DialpadKeyHandler(
       
   568                 m_dialpad, DialpadKeyHandler::KeySequence, this);
       
   569         connect(&m_dialpad->editor(),SIGNAL(contentsChanged()),
       
   570                 SLOT(onEditorContentChanged())); // Update our self
       
   571     }
       
   572     
   514 }
   573 }
   515 
   574 
   516 void PhoneUIQtView::networkNameChanged(QSystemNetworkInfo::NetworkMode mode, const QString &netName)
   575 void PhoneUIQtView::networkNameChanged(QSystemNetworkInfo::NetworkMode mode, const QString &netName)
   517 {
   576 {
   518     if((mode == QSystemNetworkInfo::GsmMode) || 
   577     if((mode == QSystemNetworkInfo::GsmMode) || 
   519        (mode == QSystemNetworkInfo::WcdmaMode)) {
   578        (mode == QSystemNetworkInfo::WcdmaMode)) {
   520         setTitle(netName);
   579         setTitle(netName);
   521     }	
   580     }	
   522 }
   581 }
       
   582