1 /*!

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: Implements grid of numeric buttons

    15 *

    16 */

    17 

    18 #include <QPainter>

    19 

    20 #include <hbmainwindow.h>

    21 #include <hbcolorscheme.h>

    22 #include <hbevent.h>

    23 #include <hbinputkeymapfactory.h>

    24 #include <hbinputkeymap.h>

    25 #include <hbinpututils.h>

    26 #include <hbinputsettingproxy.h>

    27 #include <hbinputlanguage.h>

    28 

    29 #include "dialpadnumericbutton.h"

    30 #include "dialpadnumericbuttongrid.h"

    31 

    32 static const int DialpadRowCount = 4;

    33 static const int DialpadColumnCount = 3;

    34 // layout values in units

    35 static const qreal DialpadPrimaryTextSizeV = 5.25;

    36 static const qreal DialpadPrimaryTextSizeH = 4.5;

    37 static const qreal DialpadSecondaryTextSizeV = 3.8;

    38 static const qreal DialpadSecondaryTextSizeH = 3.3;

    39 static const qreal DialpadSecondaryTextSize2RowsV = 3.0;

    40 static const qreal DialpadSecondaryTextSize2RowsH = 2.6;

    41 static const qreal DialpadIconSizeV = 5.0;

    42 static const qreal DialpadIconSizeH = 4.25;

    43 static const qreal DialpadPrimaryTextLeftMargin  = 1.5;

    44 static const qreal DialpadPrimarySecondaryMargin  = 1.0;

    45 

    46 static const QLatin1String vmbxIcon("qtg_mono_voice_mailbox");

    47 

    48 static const int DialpadKeyCodeTable[DialpadRowCount*DialpadColumnCount] =

    49 {

    50     Qt::Key_1,        Qt::Key_2,      Qt::Key_3,

    51     Qt::Key_4,        Qt::Key_5,      Qt::Key_6,

    52     Qt::Key_7,        Qt::Key_8,      Qt::Key_9,

    53     Qt::Key_Asterisk, Qt::Key_0,      Qt::Key_NumberSign

    54 };

    55 

    56 DialpadNumericButtonGrid::DialpadNumericButtonGrid(

    57     const HbMainWindow& mainWindow,

    58     QGraphicsItem* parent) :

    59     HbInputButtonGroup(parent),

    60     mMainWindow(mainWindow),

    61     mUnit(.0),

    62     mMaxPrimaryLineWidth(.0),

    63     mPrimaryTextBaseline(.0)

    64 {

    65     setObjectName("numericButtons");

    66 

    67     // create buttons

    68     setGridSize(QSize(DialpadColumnCount, DialpadRowCount));

    69     setButtonBorderSize(0);    

    70 

    71     QList<HbInputButton*> buttons;

    72 

    73     for (int i = 0; i < DialpadRowCount * DialpadColumnCount; ++i) {

    74         DialpadNumericButton *item = new DialpadNumericButton(

    75             DialpadKeyCodeTable[i],

    76             QPoint(i % DialpadColumnCount, i / DialpadColumnCount));

    77         buttons.append(item);

    78 

    79         item->setType(HbInputButton::ButtonTypeNormal);

    80     }

    81 

    82     setButtons(buttons);

    83 

    84     // connect signals from buttons

    85     QObject::connect(this, SIGNAL(buttonPressed(const QKeyEvent&)),

    86                      this, SLOT(updateButtonLabels()));

    87     QObject::connect(this, SIGNAL(buttonReleased(const QKeyEvent&)),

    88                      this, SLOT(updateButtonLabels()));

    89     QObject::connect(this, SIGNAL(pressedButtonChanged(const QKeyEvent&,

    90                                                        const QKeyEvent&)),

    91                      this, SLOT(updateButtonLabels()));

    92 

    93     // update colors

    94     updateColorArray();

    95     // set button texts

    96     setButtonTexts();

    97     // set button icons

    98     button(0)->setIcon(HbIcon(vmbxIcon));

    99 

   100     // update button texts when input language is changed

   101     connect(HbInputSettingProxy::instance(),

   102             SIGNAL(globalInputLanguageChanged(HbInputLanguage)),

   103             this,

   104             SLOT(setButtonTexts()));

   105 }

   106 

   107 DialpadNumericButtonGrid::~DialpadNumericButtonGrid()

   108 {

   109 }

   110 

   111 void DialpadNumericButtonGrid::resetButtons()

   112 {

   113     cancelButtonPress();

   114 }

   115 

   116 QChar DialpadNumericButtonGrid::inputCharacter(int keyCode) const

   117 {

   118     return mGeneratedChar.value(keyCode);

   119 }

   120 

   121 void DialpadNumericButtonGrid::setButtonTexts()

   122 {

   123     HbInputLanguage inputLanguage =

   124         HbInputSettingProxy::instance()->globalInputLanguage();

   125     const HbKeymap *keymap =

   126         HbKeymapFactory::instance()->keymap(inputLanguage.language());

   127 

   128     mGeneratedChar.clear();

   129 

   130     if (keymap) {

   131         int buttonCount = (DialpadRowCount*DialpadColumnCount);

   132         for (int i = 0; i < buttonCount; i++) {

   133             int keyCode = DialpadKeyCodeTable[i];

   134 

   135             if (keyCode == Qt::Key_Asterisk) {

   136                 // asterisk is not localized

   137                 QChar asterisk('*');

   138                 button(i)->setText(asterisk);

   139                 button(i)->setSecondaryText(QLatin1String("+"));

   140                 mGeneratedChar.insert(Qt::Key_Asterisk, asterisk);

   141                 continue;

   142             }

   143 

   144             if (keyCode == Qt::Key_NumberSign) {

   145                 // number sign is not localized

   146                 QChar numberSign('#');

   147                 button(i)->setText(numberSign);

   148                 mGeneratedChar.insert(Qt::Key_NumberSign, numberSign);

   149                 continue;

   150             }

   151 

   152             int index = i;

   153             if (keyCode==Qt::Key_0) {

   154                 index = i-1;

   155             }

   156 

   157             const HbMappedKey *keyLabels =

   158                 keymap->keyForIndex(HbKeyboardVirtual12KeyLabels, index);

   159 

   160             //

   161             // set digits

   162             // todo: input digit depend on digit type setting

   163             // QChar numberChar(QLocale::system().zeroDigit().unicode()+

   164             //                 (keyCode-0x30));

   165             //

   166             QChar numberChar;

   167             if (keyLabels && keyLabels->chars.count()>=1 &&

   168                 keyLabels->chars.at(0).length()) {

   169                 numberChar = keyLabels->chars.at(0).at(0);

   170             } else {

   171                 // fallback to latin

   172                 numberChar = QChar(keyCode);

   173             }

   174 

   175             button(i)->setText(numberChar);

   176             mGeneratedChar.insert(keyCode,numberChar);

   177 

   178             //

   179             // set alphabets

   180             //

   181             if (keyLabels && keyLabels->chars.count()>=2) {

   182                 button(i)->setSecondaryText(keyLabels->chars.at(1));

   183                 if (keyLabels->chars.count()>=4) {

   184                     button(i)->setSecondary2ndRowText(keyLabels->chars.at(3));

   185                 } else {

   186                     button(i)->setSecondary2ndRowText(QString());

   187                 }

   188             }

   189         }

   190 

   191         updateButtonLabels();

   192     }

   193 }

   194 

   195 DialpadNumericButton* DialpadNumericButtonGrid::button(int i) const

   196 {

   197     return static_cast<DialpadNumericButton*>(HbInputButtonGroup::button(i));

   198 }

   199 

   200 void DialpadNumericButtonGrid::updateButtonLabels()

   201 {

   202     // update numeric buttons according to button state (pressed/released)

   203     updateIconColor();

   204     updateTextLayouts(rect().size());

   205     update();

   206 }

   207 

   208 void DialpadNumericButtonGrid::paint(

   209     QPainter* painter,

   210     const QStyleOptionGraphicsItem* option,

   211     QWidget* widget)

   212 {

   213     Q_UNUSED(option);

   214     Q_UNUSED(widget);

   215 

   216     // Paints empty buttons

   217     HbInputButtonGroup::paint(painter,option,widget);

   218 

   219     qreal cellWidth = boundingRect().width() / gridSize().width();

   220     qreal cellHeight = boundingRect().height() / gridSize().height();

   221 

   222     for (int i = 0; i < DialpadRowCount * DialpadColumnCount; i++) {

   223         DialpadNumericButton *item = button(i);

   224 

   225         if (!item->icon().isNull()) {

   226             // same as secondary text

   227             qreal x = (item->position().x() * cellWidth) +

   228                       (DialpadPrimaryTextLeftMargin * mUnit) +

   229                       (DialpadPrimarySecondaryMargin * mUnit) +

   230                       mMaxPrimaryLineWidth;

   231             // top align with some margin

   232             qreal y = item->position().y() * cellHeight + (cellHeight / 20.0);

   233 

   234             qreal width = item->icon().size().width();

   235             qreal height = item->icon().size().height();

   236 

   237             Qt::Alignment alignment =

   238                 static_cast<Qt::Alignment>(Qt::AlignTop | Qt::AlignLeft);

   239             item->icon().paint(painter,

   240                                QRectF(x,y,width,height),

   241                                Qt::KeepAspectRatio,

   242                                alignment);

   243         }                      

   244     }

   245 

   246     // Draw texts

   247     QPen origPen = painter->pen();

   248     for (int i = 0; i < mTextLayouts.count(); ++i) {

   249         if (i==SecondaryText) {

   250             // dimmed in normal state

   251             painter->setPen(mColors.at(Pressed+1));

   252         } else {

   253             // otherwise normal or pressed color

   254             painter->setPen(mColors.at(i/TextTypeCount));

   255         }

   256         mTextLayouts.at(i)->draw(painter, QPointF(0, 0));

   257     }

   258     painter->setPen(origPen);

   259 }

   260 

   261 void DialpadNumericButtonGrid::updateColorArray()

   262 {

   263     mColors.clear();

   264 

   265     QColor normalColor = HbColorScheme::color("qtc_input_button_normal");

   266     mColors.insert(Normal, normalColor);

   267 

   268     QColor pressedColor = HbColorScheme::color("qtc_input_button_pressed");

   269     mColors.insert(Pressed, pressedColor);

   270 

   271     // this is used for alphabets shown dimmed, use alpha until exact color

   272     // is specified

   273     QColor disabledColor = HbColorScheme::color("qtc_input_button_normal");

   274     disabledColor.setAlpha(128);

   275     mColors.insert(Pressed+1, disabledColor);

   276 }

   277 

   278 void DialpadNumericButtonGrid::updateIconColor()

   279 {

   280     for (int i = 0; i < (DialpadRowCount * DialpadColumnCount); i++) {

   281         DialpadNumericButton *item = button(i);

   282 

   283         if (item->state()==HbInputButton::ButtonStatePressed) {

   284             item->icon().setColor(mColors.at(Pressed));

   285         } else {

   286             item->icon().setColor(mColors.at(Normal));

   287         }

   288     }

   289 }

   290 

   291 void DialpadNumericButtonGrid::cancelButtonPress()

   292 {

   293     HbInputButtonGroup::cancelButtonPress();

   294     updateButtonLabels();

   295 }

   296 

   297 

   298 void DialpadNumericButtonGrid::setGeometry(const QRectF &rect)

   299 {

   300     HbInputButtonGroup::setGeometry(rect);

   301 

   302     mUnit = HbDeviceProfile::profile(&mMainWindow).unitValue();

   303 

   304     updateTextLayouts(rect.size());

   305 

   306     updateIconSizes();

   307 }

   308 

   309 void DialpadNumericButtonGrid::updateIconSizes()

   310 {

   311     qreal width =  mMainWindow.orientation() == Qt::Vertical ?

   312                    DialpadIconSizeV : DialpadIconSizeH;

   313     width *= mUnit;

   314 

   315     for (int i = 0; i < DialpadRowCount * DialpadColumnCount; i++) {

   316         DialpadNumericButton *item = button(i);

   317 

   318         if (!item->icon().isNull()) {

   319             item->icon().setWidth(width);

   320         }

   321     }

   322 }

   323 

   324 void DialpadNumericButtonGrid::changeEvent(QEvent *event)

   325 {

   326     HbInputButtonGroup::changeEvent(event);

   327 

   328     if (event->type() == HbEvent::ThemeChanged) {

   329         updateColorArray();

   330         updateIconColor();

   331     }

   332 }

   333 

   334 void DialpadNumericButtonGrid::updateTextLayouts(const QSizeF &size)

   335 {

   336     if (!size.width() && !size.height()) {

   337         return;

   338     }

   339 

   340     // get normal and pressed state texts

   341     QList<QString> textContent;

   342     bool useTwoRows;

   343 

   344     resolveTextContent(textContent, useTwoRows);

   345 

   346     // layout the texts

   347     createTextLayouts(size, textContent, useTwoRows);

   348 }

   349 

   350 void DialpadNumericButtonGrid::resolveTextContent(

   351     QList<QString> &content, bool& useTwoRows)

   352 {

   353     QString normalState;

   354     QString normalStateSecondary;

   355     QString pressedState;

   356     QString pressedStateSecondary;

   357 

   358     useTwoRows = false;

   359 

   360     for (int i = 0; i < (DialpadRowCount*DialpadColumnCount); i++) {

   361         DialpadNumericButton *item = button(i);

   362         if (item->state()==HbInputButton::ButtonStatePressed) {

   363             if (item->text().length()) {

   364                 pressedState.append(item->text());

   365                 pressedState.append(QChar(QChar::LineSeparator));

   366             }

   367 

   368             if (item->secondaryText().length()) {

   369                 pressedStateSecondary.append(item->secondaryText());

   370                 pressedStateSecondary.append(QChar(QChar::LineSeparator));

   371                 if (item->secondary2ndRowText().length()) {

   372                     pressedStateSecondary.append(item->secondary2ndRowText());

   373                     pressedStateSecondary.append(QChar(QChar::LineSeparator));

   374                     useTwoRows = true;

   375                 }

   376             }

   377         } else { // ButtonStateNormal

   378             if (item->text().length()) {

   379                 normalState.append(item->text());

   380                 normalState.append(QChar(QChar::LineSeparator));

   381             }

   382 

   383             if (item->secondaryText().length()) {

   384                 normalStateSecondary.append(item->secondaryText());

   385                 normalStateSecondary.append(QChar(QChar::LineSeparator));

   386                 if (item->secondary2ndRowText().length()) {

   387                     normalStateSecondary.append(item->secondary2ndRowText());

   388                     normalStateSecondary.append(QChar(QChar::LineSeparator));

   389                     useTwoRows = true;

   390                 }

   391             }

   392         }

   393     }

   394 

   395     content.insert(PrimaryText, normalState);

   396     content.insert(SecondaryText, normalStateSecondary);

   397     content.insert(TextTypeCount + Pressed, pressedState);

   398     content.insert(StateCount + SecondaryText, pressedStateSecondary);

   399 }

   400 

   401 void DialpadNumericButtonGrid::createTextLayouts(

   402     const QSizeF &size, const QList<QString> &content, bool useTwoRows)

   403 {

   404     // clear old layouts

   405     qDeleteAll(mTextLayouts);

   406     mTextLayouts.clear();

   407 

   408     if(!isButtonPressed()) {

   409         mMaxPrimaryLineWidth = 0;

   410     }

   411 

   412     QFont primaryFont = HbFontSpec(HbFontSpec::Primary).font();

   413     qreal primarySize = mMainWindow.orientation() == Qt::Vertical ?

   414                      DialpadPrimaryTextSizeV :

   415                      DialpadPrimaryTextSizeH;

   416     primaryFont.setPixelSize(primarySize * mUnit);

   417 

   418     QFont secondaryFont = HbFontSpec(HbFontSpec::Secondary).font();

   419     if (useTwoRows) {

   420         qreal secondarySize = mMainWindow.orientation() == Qt::Vertical ?

   421                          DialpadSecondaryTextSize2RowsV :

   422                          DialpadSecondaryTextSize2RowsH;

   423         secondaryFont.setPixelSize(secondarySize * mUnit);

   424     } else {

   425         qreal secondarySize = mMainWindow.orientation() == Qt::Vertical ?

   426                          DialpadSecondaryTextSizeV :

   427                          DialpadSecondaryTextSizeH;

   428         secondaryFont.setPixelSize(secondarySize * mUnit);

   429     }

   430 

   431     for (int i=0; i < (StateCount*TextTypeCount); i++ ) {

   432         QString text = content.at(i);

   433 

   434         if (!text.isNull()) {

   435             QTextLayout* textLayout;

   436             int type;

   437 

   438             if (i%TextTypeCount) {

   439                 textLayout = new QTextLayout(text,secondaryFont);

   440                 type = SecondaryText;

   441             } else {

   442                 textLayout = new QTextLayout(text,primaryFont);

   443                 type = PrimaryText;

   444             }

   445 

   446             mTextLayouts.append(textLayout);

   447 

   448             textLayout->beginLayout();

   449 

   450             int state = (i>=TextTypeCount) ? Pressed : Normal;

   451 

   452             layoutTextLines(size,*textLayout,state,type,useTwoRows);

   453 

   454             textLayout->endLayout();

   455 

   456             textLayout->setCacheEnabled(true);

   457         }

   458     }

   459 }

   460 

   461 void DialpadNumericButtonGrid::layoutTextLines(

   462     const QSizeF &size,

   463     QTextLayout &textLayout,

   464     int state,

   465     int type,

   466     bool useTwoRows)

   467 {

   468     QFontMetricsF fontMetrics(textLayout.font());

   469     qreal textHeight = fontMetrics.height();

   470     qreal textDescent = fontMetrics.descent();

   471 

   472     qreal cellWidth = size.width() / gridSize().width();

   473     qreal cellHeight = size.height() / gridSize().height();

   474     qreal maxLineWidth = 0;

   475 

   476     for (int j = 0; j < (DialpadRowCount*DialpadColumnCount); j++) {

   477         DialpadNumericButton *item = button(j);

   478 

   479         if ((type==PrimaryText && item->text().isNull()) ||

   480             (type==SecondaryText && item->secondaryText().isNull())) {

   481             continue; // no text for this button -> next button

   482         }

   483 

   484         if ( ( state==Normal &&

   485                item->state()==HbInputButton::ButtonStateReleased ) ||

   486              ( state==Pressed &&

   487                item->state()==HbInputButton::ButtonStatePressed ) ) {

   488             // layout text line

   489             if (type==SecondaryText) {

   490                 layoutSecondaryText(textLayout,*item,cellWidth,

   491                                     cellHeight,textHeight,textDescent,

   492                                     useTwoRows);

   493             } else {

   494                 layoutPrimaryText(textLayout,*item,cellWidth,

   495                                   cellHeight,textHeight);

   496 

   497                 // store line width, for drawing secondary text

   498                 qreal lineWidth = fontMetrics.width(item->text());

   499                 if (mMaxPrimaryLineWidth == 0 && (j>0 && j<10) &&

   500                     lineWidth > maxLineWidth) {

   501                     maxLineWidth = lineWidth;

   502                     mPrimaryTextBaseline = textHeight/2 - textDescent;

   503                 }

   504             }

   505         }

   506     }

   507 

   508     if (maxLineWidth!=0) {

   509         mMaxPrimaryLineWidth = maxLineWidth;

   510     }

   511 }

   512 

   513 void DialpadNumericButtonGrid::layoutPrimaryText(

   514     QTextLayout& layout,

   515     DialpadNumericButton& button,

   516     qreal cellWidth,

   517     qreal cellHeight,

   518     qreal textHeight) const

   519 {

   520     QTextLine line = layout.createLine();

   521     line.setNumColumns(button.text().length());

   522     qreal textPositionX = (button.position().x() * cellWidth) +

   523                     (DialpadPrimaryTextLeftMargin * mUnit)

   524                     + buttonBorderSize();

   525     qreal textPositionY = (button.position().y() +

   526                     (0.5 * button.size().height())) *

   527                     cellHeight - (0.5 * textHeight);

   528     line.setPosition(QPointF(textPositionX, textPositionY));

   529 }

   530 

   531 void DialpadNumericButtonGrid::layoutSecondaryText(

   532     QTextLayout& layout,

   533     DialpadNumericButton& button,

   534     qreal cellWidth,

   535     qreal cellHeight,

   536     qreal textHeight,

   537     qreal textDescent,

   538     bool useTwoRows) const

   539 {

   540     qreal textPositionX;

   541     qreal textPositionY;

   542 

   543     QTextLine line = layout.createLine();

   544 

   545     if (useTwoRows) {

   546         line.setNumColumns(button.secondaryText().length());

   547 

   548         textPositionX = (button.position().x() * cellWidth) +

   549                         (DialpadPrimaryTextLeftMargin * mUnit) +

   550                         mMaxPrimaryLineWidth +

   551                         (DialpadPrimarySecondaryMargin * mUnit)

   552                         + buttonBorderSize();

   553 

   554         if (button.secondary2ndRowText().length()) {

   555             textPositionY = (button.position().y() +

   556                             (0.5 * button.size().height())) *

   557                             cellHeight;

   558 

   559             QTextLine line2 = layout.createLine();

   560             line2.setNumColumns(button.secondary2ndRowText().length());

   561             line2.setPosition(QPointF(textPositionX,textPositionY-textHeight));

   562         } else {

   563             textPositionY = (button.position().y() +

   564                             (0.5 * button.size().height())) *

   565                             cellHeight - (0.5 * textHeight);

   566         }

   567     } else {

   568         line.setNumColumns(button.secondaryText().length());

   569         textPositionX = (button.position().x() * cellWidth) +

   570                         (DialpadPrimaryTextLeftMargin * mUnit) +

   571                         mMaxPrimaryLineWidth +

   572                         (DialpadPrimarySecondaryMargin * mUnit)

   573                         + buttonBorderSize();

   574         textPositionY = (button.position().y() +

   575                         (0.5 * button.size().height())) *

   576                         cellHeight + mPrimaryTextBaseline -

   577                         (textHeight - textDescent);

   578     }

   579     line.setPosition(QPointF(textPositionX, textPositionY));

   580 }

   581 

   582 bool DialpadNumericButtonGrid::isButtonPressed() const

   583 {

   584     bool pressed = false;

   585 

   586     for (int i = 0; i < (DialpadRowCount*DialpadColumnCount); i++) {

   587         if (button(i)->state()==HbInputButton::ButtonStatePressed) {

   588             pressed = true;

   589             break;

   590         }

   591     }

   592 

   593     return pressed;

   594 }