Mercurial Mercurial > oss > FCL > sf > app > phone / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
phoneuis/bubblemanager2/bubblestyle/src/bubblestyleplugin.cpp
changeset 22 6bb1b21d2484
parent 21 92ab7f8d0eab
child 27 2f8f8080a020
equal deleted inserted replaced
21:92ab7f8d0eab 22:6bb1b21d2484 
    26 #include <hbframeitem.h>
 
    26 #include <hbframeitem.h>
 
    27 #include <hbframedrawer.h>
 
    27 #include <hbframedrawer.h>
 
    28 #include <hbfontspec.h>
 
    28 #include <hbfontspec.h>
 
    29 #include <hbdeviceprofile.h>
 
    29 #include <hbdeviceprofile.h>
 
    30 #include <hbcolorscheme.h>
 
    30 #include <hbcolorscheme.h>
 
       
    31 #include <hbstringutil.h>
 
    31 
    32 
    32 static const int BUBBLE_ICON_ANIM_INTERVAL = 500; // ms
 
    33 static const int BUBBLE_ICON_ANIM_INTERVAL = 500; // ms
 
    33 
    34 
    34 BubbleStylePlugin::BubbleStylePlugin()
 
    35 BubbleStylePlugin::BubbleStylePlugin()
 
    35 {
 
    36 {
 
    53 int BubbleStylePlugin::primitiveCount() const
 
    54 int BubbleStylePlugin::primitiveCount() const
 
    54 {
 
    55 {
 
    55     return BP_Bubble_primitive_count;
 
    56     return BP_Bubble_primitive_count;
 
    56 }
 
    57 }
 
    57 
    58 
    58 HbWidgetBase* BubbleStylePlugin::createPrimitive(
 
    59 QGraphicsItem* BubbleStylePlugin::createPrimitive(
 
    59     HbStyle::Primitive primitive, 
    60     HbStyle::Primitive primitive, 
    60     QGraphicsItem *parent) const
 
    61     QGraphicsItem *parent) const
 
    61 {
 
    62 {
 
    62     HbWidgetBase* item = 0;
 
    63     QGraphicsItem* item = 0;
 
    63     
    64     
    64     switch(primitive) {
 
    65     switch(primitive) {
 
    65     case BP_Bubble_frame: {
 
    66     case BP_Bubble_frame: {
 
    66         HbFrameItem* frame = new HbFrameItem(parent);
 
    67         HbFrameItem* frame = new HbFrameItem(parent);
 
    67         frame->setZValue(-1.0);
 
    68         frame->setZValue(-1.0);
 
    85         break;
 
    86         break;
 
    86     case BP_NumberType_icon: {
 
    87     case BP_NumberType_icon: {
 
    87         HbIconItem* icon = new HbIconItem(parent);
 
    88         HbIconItem* icon = new HbIconItem(parent);
 
    88         item = icon;
 
    89         item = icon;
 
    89         }
 
    90         }
 
    90         break;    
    91         break;
 
       
    92     case BP_Ciphering_icon: {
 
       
    93         HbIconItem* icon = new HbIconItem(parent);
 
       
    94         item = icon;
 
       
    95         }
 
       
    96         break;
 
    91     default:
 
    97     default:
 
    92         break;
 
    98         break;
 
    93     } // switch
 
    99     } // switch
 
    94 
   100 
    95     return item;    
   101     return item;    
   117         frame->frameDrawer().setFrameGraphicsName("qtg_fr_list_normal");
 
   123         frame->frameDrawer().setFrameGraphicsName("qtg_fr_list_normal");
 
   118         }
 
   124         }
 
   119         break;                
   125         break;                
   120 
   126 
   121     case BP_Text1_text: {
 
   127     case BP_Text1_text: {
 
   122         HbTextItem* text = static_cast<HbTextItem*>(item);
 
   128         HbTextItem* textItem = static_cast<HbTextItem*>(item);
 
   123         text->setText( opt->mText1 );
 
   129         setText(textItem, opt->mText1, opt->mText1Clip);
 
   124         text->setElideMode( opt->mText1Clip );
 
   130         setFont(textItem, primitive, opt);
 
   125         setFont(text, primitive, opt);
 
       
   126         }
 
   131         }
 
   127         break;    
   132         break;    
   128     
   133     
   129     case BP_Text2_text: {
 
   134     case BP_Text2_text: {
 
   130         HbTextItem* text = static_cast<HbTextItem*>(item);
 
   135         HbTextItem* textItem = static_cast<HbTextItem*>(item);
 
   131         text->setText( opt->mText2 );
 
   136         setText(textItem, opt->mText2, opt->mText2Clip);
 
   132         text->setElideMode( opt->mText2Clip );
 
   137         setFont(textItem, primitive, opt);
 
   133         setFont(text, primitive, opt);
 
       
   134         }
 
   138         }
 
   135         break;    
   139         break;    
   136 
   140 
   137     case BP_Text3_text: {
 
   141     case BP_Text3_text: {
 
   138         HbTextItem* text = static_cast<HbTextItem*>(item);
 
   142         HbTextItem* textItem = static_cast<HbTextItem*>(item);
 
   139         text->setText( opt->mText3 );
 
   143         setText(textItem, opt->mText3, opt->mText3Clip);
 
   140         text->setElideMode( opt->mText3Clip );
 
   144         setFont(textItem, primitive, opt);
 
   141         setFont(text, primitive, opt);
 
       
   142         }
 
   145         }
 
   143         break;    
   146         break;    
   144     
   147     
   145     case BP_CallStatus_icon: {
 
   148     case BP_CallStatus_icon: {
 
   146         setCallStatusIcons(static_cast<BubbleAnimIconItem*>(item), opt);
 
   149         setCallStatusIcons(static_cast<BubbleAnimIconItem*>(item), opt);
 
   150     case BP_NumberType_icon: {
 
   153     case BP_NumberType_icon: {
 
   151         HbIconItem* icon = static_cast<HbIconItem*>(item);
 
   154         HbIconItem* icon = static_cast<HbIconItem*>(item);
 
   152         if ( (( opt->mCallState == BubbleManagerIF::Incoming ) ||
 
   155         if ( (( opt->mCallState == BubbleManagerIF::Incoming ) ||
 
   153               ( opt->mCallState == BubbleManagerIF::Waiting )) &&
 
   156               ( opt->mCallState == BubbleManagerIF::Waiting )) &&
 
   154              ( opt->mCallFlags & BubbleManagerIF::Diverted ) ) {
 
   157              ( opt->mCallFlags & BubbleManagerIF::Diverted ) ) {
 
   155             icon->setIconName(":/resources/qgn_indi_call_diverted.svg");
 
   158             icon->setIconName(":/qgn_indi_call_diverted.svg");
 
   156 
   159             setIconColor(icon);
 
   157             // to be done via css when possible
 
       
   158             QColor color;
 
       
   159             color = HbColorScheme::color("list_item_title_normal");
 
       
   160             if (color.isValid()) {
 
       
   161                 icon->setColor(color);
 
       
   162             }
 
       
   163 
       
   164             icon->show();
 
   160             icon->show();
 
   165             } else {
 
   161             } else {
 
   166             icon->setIconName(QString());
 
   162             icon->setIconName(QString());
 
   167             icon->hide();
 
   163             icon->hide();
 
   168             }
 
   164             }
 
   169         }
 
   165         }
 
   170         break;
 
   166         break;
 
   171 
   167 
       
   168     case BP_Ciphering_icon: {
 
       
   169         HbIconItem* icon = static_cast<HbIconItem*>(item);
 
       
   170         if ( opt->mCallFlags & BubbleManagerIF::NoCiphering ) {
 
       
   171             icon->setIconName("qtg_mono_ciphering_off");
 
       
   172             setIconColor(icon);
 
       
   173             icon->show();
 
       
   174             } else {
 
       
   175             icon->setIconName(QString());
 
       
   176             icon->hide();
 
       
   177             }
 
       
   178         }
 
       
   179         break;
 
       
   180 
   172     default:
 
   181     default:
 
   173         break;
 
   182         break;
 
   174     } // switch
 
   183     } // switch
 
   175 }
 
   184 }
 
   176 
   185 
   177 void BubbleStylePlugin::setFont(HbTextItem* item, int primitive, const BubbleStyleOption *option) const
 
   186 void BubbleStylePlugin::setText(
 
       
   187     HbTextItem* item,
 
       
   188     const QString& text,
 
       
   189     Qt::TextElideMode clip) const
 
       
   190 {
 
       
   191     if (clip == Qt::ElideLeft) {
 
       
   192         // convert phonenumber to phone ui language
 
       
   193         QString converted = HbStringUtil::convertDigits(text);
 
       
   194         item->setText(converted);
 
       
   195     } else {
 
       
   196         item->setText( text );
 
       
   197     }
 
       
   198     item->setElideMode( clip );
 
       
   199 }
 
       
   200 
       
   201 void BubbleStylePlugin::setFont(
 
       
   202     HbTextItem* item,
 
       
   203     int primitive,
 
       
   204     const BubbleStyleOption *option) const
 
   178 {
 
   205 {
 
   179     int primitiveLineNumber = 0;
 
   206     int primitiveLineNumber = 0;
 
   180     if (primitive==BP_Text1_text) {
 
   207     if (primitive==BP_Text1_text) {
 
   181         primitiveLineNumber = 1;
 
   208         primitiveLineNumber = 1;
 
   182     } else if (primitive==BP_Text2_text) {
 
   209     } else if (primitive==BP_Text2_text) {
 
   202     } else {
 
   229     } else {
 
   203         item->setTextColor(Qt::black);
 
   230         item->setTextColor(Qt::black);
 
   204     }
 
   231     }
 
   205 }
 
   232 }
 
   206 
   233 
       
   234 void BubbleStylePlugin::setIconColor(HbIconItem* icon) const
 
       
   235 {
 
       
   236     // to be done via css when possible
 
       
   237     QColor color;
 
       
   238     color = HbColorScheme::color("list_item_title_normal");
 
       
   239     if (color.isValid()) {
 
       
   240         icon->setColor(color);
 
       
   241     }
 
       
   242 }
 
       
   243 
   207 QString BubbleStylePlugin::layoutPath() const
 
   244 QString BubbleStylePlugin::layoutPath() const
 
   208 {
 
   245 {
 
   209    QString path(":/");
 
   246    QString path(":/");
 
   210    return path;
 
   247    return path;
 
   211 }
 
   248 }
 
   216     switch(opt->mCallState) {
 
   253     switch(opt->mCallState) {
 
   217     case BubbleManagerIF::Incoming:
 
   254     case BubbleManagerIF::Incoming:
 
   218     case BubbleManagerIF::Alerting:
 
   255     case BubbleManagerIF::Alerting:
 
   219     case BubbleManagerIF::Waiting:
 
   256     case BubbleManagerIF::Waiting:
 
   220         if ( opt->mCallFlags & BubbleManagerIF::VoIPCall ) {
 
   257         if ( opt->mCallFlags & BubbleManagerIF::VoIPCall ) {
 
   221             anim->appendIcon(":/qtg_large_voip_received_call.svg");
 
   258             anim->appendIcon("qtg_large_voip_received_call");
 
   222             anim->appendIcon(":/qtg_large_voip_dialled_call.svg");
 
   259             anim->appendIcon("qtg_large_voip_dialled_call");
 
   223         } else if ( opt->mCallFlags & BubbleManagerIF::Video ) {
 
   260         } else if ( opt->mCallFlags & BubbleManagerIF::Video ) {
 
   224             anim->appendIcon(":/qtg_large_video_received_call.svg");
 
   261             anim->appendIcon("qtg_large_video_received_call");
 
   225             anim->appendIcon(":/qtg_large_video_dialled_call.svg");         
   262             anim->appendIcon("qtg_large_video_dialled_call");
 
   226         } else {
 
   263         } else {
 
   227             anim->appendIcon(":/pri_large_green_handset.svg");
 
   264             anim->appendIcon("qtg_large_active_call");
 
   228             anim->appendIcon(":/pri_large_yellow_handset.svg");
 
   265             anim->appendIcon("qtg_large_waiting_call");
 
   229         }
 
   266         }
 
   230         break;
 
   267         break;
 
   231     case BubbleManagerIF::Outgoing:
 
   268     case BubbleManagerIF::Outgoing:
 
   232     case BubbleManagerIF::Active:
 
   269     case BubbleManagerIF::Active:
 
   233         if ( opt->mCallFlags & BubbleManagerIF::VoIPCall ) {
 
   270         if ( opt->mCallFlags & BubbleManagerIF::VoIPCall ) {
 
   234             anim->appendIcon(":/qtg_large_voip_received_call.svg");
 
   271             anim->appendIcon("qtg_large_voip_received_call");
 
   235         } else if ( opt->mCallFlags & BubbleManagerIF::Video ) {
 
   272         } else if ( opt->mCallFlags & BubbleManagerIF::Video ) {
 
   236             anim->appendIcon(":/qtg_large_video_received_call.svg");
 
   273             anim->appendIcon("qtg_large_video_received_call");
 
   237         } else {
 
   274         } else {
 
   238             anim->appendIcon(":/pri_large_green_handset.svg");
 
   275             anim->appendIcon("qtg_large_active_call");
 
   239         }            
   276         }            
   240         break;
 
   277         break;
 
   241     case BubbleManagerIF::OnHold:
 
   278     case BubbleManagerIF::OnHold:
 
   242         if ( opt->mCallFlags & BubbleManagerIF::VoIPCall ) {
 
   279         if ( opt->mCallFlags & BubbleManagerIF::VoIPCall ) {
 
   243             anim->appendIcon(":/qtg_large_voip_dialled_call.svg");
 
   280             anim->appendIcon("qtg_large_voip_dialled_call");
 
   244         } else if ( opt->mCallFlags & BubbleManagerIF::Video ) {
 
   281         } else if ( opt->mCallFlags & BubbleManagerIF::Video ) {
 
   245             anim->appendIcon(":/qtg_large_video_dialled_call.svg");
 
   282             anim->appendIcon("qtg_large_video_dialled_call");
 
   246         } else {
 
   283         } else {
 
   247             anim->appendIcon(":/pri_large_yellow_handset.svg");
 
   284             anim->appendIcon("qtg_large_waiting_call");
 
   248         }                      
   285         }                      
   249         break;
 
   286         break;
 
   250     case BubbleManagerIF::Disconnected:
 
   287     case BubbleManagerIF::Disconnected:
 
   251     case BubbleManagerIF::AlertToDisconnected:
 
   288     case BubbleManagerIF::AlertToDisconnected:
 
   252         if ( opt->mCallFlags & BubbleManagerIF::VoIPCall ) {
 
   289         if ( opt->mCallFlags & BubbleManagerIF::VoIPCall ) {
 
   253             anim->appendIcon(":/qtg_large_voip_missed_call.svg");
 
   290             anim->appendIcon("qtg_large_voip_missed_call");
 
   254         } else if ( opt->mCallFlags & BubbleManagerIF::Video ) {
 
   291         } else if ( opt->mCallFlags & BubbleManagerIF::Video ) {
 
   255             anim->appendIcon(":/qtg_large_video_missed_call.svg");
 
   292             anim->appendIcon("qtg_large_video_missed_call");
 
   256         } else {
 
   293         } else {
 
   257             anim->appendIcon(":/pri_large_red_handset.svg");
 
   294             anim->appendIcon("qtg_large_end_call");
 
   258         }           
   295         }           
   259         break;
 
   296         break;
 
   260     default:
 
   297     default:
 
   261         break;
 
   298         break;
 
   262     }
 
   299     }
FCL/sf/app/phone