56 void HbVariant::HbVariantData::setDataType(Type dataType) |
56 void HbVariant::HbVariantData::setDataType(Type dataType) |
57 { |
57 { |
58 mDataType = dataType; |
58 mDataType = dataType; |
59 #ifdef HB_BIN_CSS |
59 #ifdef HB_BIN_CSS |
60 // Types that allocate memory from memory manager |
60 // Types that allocate memory from memory manager |
61 if (mDataType == String || mDataType == StringList || mDataType == Color) { |
61 if (mDataType == String || mDataType == StringList || mDataType == Color || mDataType == IntList) { |
62 // Does not matter if register same offset holder many times |
62 // Does not matter if register same offset holder many times |
63 HbCssConverterUtils::registerOffsetHolder(&mData.offset); |
63 HbCssConverterUtils::registerOffsetHolder(&mData.offset); |
64 } else { |
64 } else { |
65 HbCssConverterUtils::unregisterOffsetHolder(&mData.offset); |
65 HbCssConverterUtils::unregisterOffsetHolder(&mData.offset); |
66 } |
66 } |
205 HbVariant::HbVariant( const QColor &col, HbMemoryManager::MemoryType type ) |
205 HbVariant::HbVariant( const QColor &col, HbMemoryManager::MemoryType type ) |
206 : mMemoryType(type), mShared(false) |
206 : mMemoryType(type), mShared(false) |
207 { |
207 { |
208 initializeData(); |
208 initializeData(); |
209 fillColorData(col); |
209 fillColorData(col); |
|
210 |
|
211 #ifdef HB_BIN_CSS |
|
212 HbCssConverterUtils::registerOffsetHolder(&mDataOffset); |
|
213 #endif |
|
214 } |
|
215 |
|
216 /* |
|
217 * C'tor taking intlist |
|
218 */ |
|
219 HbVariant::HbVariant(const QList<int> &val, HbMemoryManager::MemoryType type) |
|
220 : mMemoryType( type ), mShared( false ) |
|
221 { |
|
222 initializeData(); |
|
223 fillIntListData(val); |
210 |
224 |
211 #ifdef HB_BIN_CSS |
225 #ifdef HB_BIN_CSS |
212 HbCssConverterUtils::registerOffsetHolder(&mDataOffset); |
226 HbCssConverterUtils::registerOffsetHolder(&mDataOffset); |
213 #endif |
227 #endif |
214 } |
228 } |
277 case HbVariant::String: |
291 case HbVariant::String: |
278 return int(getString().toLongLong()); |
292 return int(getString().toLongLong()); |
279 case HbVariant::Color: |
293 case HbVariant::Color: |
280 case HbVariant::StringList: |
294 case HbVariant::StringList: |
281 return 0; |
295 return 0; |
|
296 case HbVariant::IntList: |
|
297 if (data->listCount == 1) { |
|
298 const char *address = getAddress<char>(mMemoryType, data->mData.offset, mShared); |
|
299 return *((int*)address); |
|
300 } |
|
301 return 0; |
|
302 |
282 default: |
303 default: |
283 return 0; |
304 return 0; |
284 } |
305 } |
285 } |
306 } |
286 |
307 |
299 case HbVariant::String: |
320 case HbVariant::String: |
300 return getString(); |
321 return getString(); |
301 case HbVariant::Color: |
322 case HbVariant::Color: |
302 return getColor().name(); |
323 return getColor().name(); |
303 case HbVariant::StringList: |
324 case HbVariant::StringList: |
304 if (data->stringListCount == 1) { |
325 if (data->listCount == 1) { |
305 const char *address = getAddress<char>(mMemoryType, data->mData.offset, mShared); |
326 const char *address = getAddress<char>(mMemoryType, data->mData.offset, mShared); |
306 int length = *((int*)address); |
327 int length = *((int*)address); |
307 return QString((const QChar *)(address + sizeof(int)), length); |
328 return QString((const QChar *)(address + sizeof(int)), length); |
308 } |
329 } |
309 |
330 return QString(); |
|
331 case HbVariant::IntList: |
|
332 if (data->listCount == 1) { |
|
333 const char *address = getAddress<char>(mMemoryType, data->mData.offset, mShared); |
|
334 return QString::number(*((int*)address)); |
|
335 } |
310 return QString(); |
336 return QString(); |
311 default: |
337 default: |
312 return QString(); |
338 return QString(); |
313 } |
339 } |
314 } |
340 } |
381 address += sizeof(int); |
408 address += sizeof(int); |
382 |
409 |
383 QString string((const QChar *)address, length); |
410 QString string((const QChar *)address, length); |
384 list.append(string); |
411 list.append(string); |
385 address += sizeof(QChar) * length; |
412 address += sizeof(QChar) * length; |
|
413 } |
|
414 } else if (data->dataType() == HbVariant::IntList) { |
|
415 QList<int> intList = toIntList(); |
|
416 for (int i=0; i<intList.count(); i++) { |
|
417 list.append(QString::number(intList.at(i))); |
386 } |
418 } |
387 } else { |
419 } else { |
388 list.append(toString()); |
420 list.append(toString()); |
389 } |
421 } |
390 } |
422 } |
407 case HbVariant::String: |
439 case HbVariant::String: |
408 return double(getString().toDouble()); |
440 return double(getString().toDouble()); |
409 case HbVariant::Color: |
441 case HbVariant::Color: |
410 case HbVariant::StringList: |
442 case HbVariant::StringList: |
411 return double(); |
443 return double(); |
|
444 case HbVariant::IntList: |
|
445 if (data->listCount == 1) { |
|
446 return double(toInt()); |
|
447 } |
|
448 return double(); |
412 default: |
449 default: |
413 return double(); |
450 return double(); |
414 } |
451 } |
|
452 } |
|
453 |
|
454 /* |
|
455 * to get int list |
|
456 */ |
|
457 QList<int> HbVariant::toIntList() const |
|
458 { |
|
459 HbVariantData *data = getAddress<HbVariantData>(mMemoryType, mDataOffset, mShared); |
|
460 QList<int> list; |
|
461 |
|
462 if (data) { |
|
463 if (data->dataType() == HbVariant::IntList) { |
|
464 const char *address = getAddress<char>(mMemoryType, data->mData.offset, mShared); |
|
465 const char *end = address + data->listCount * sizeof(int); |
|
466 |
|
467 // Append strings to stringlist |
|
468 while (address < end) { |
|
469 list.append(*(int *)address); |
|
470 address += sizeof(int); |
|
471 } |
|
472 } else { |
|
473 list.append(toInt()); |
|
474 } |
|
475 } |
|
476 |
|
477 return list; |
415 } |
478 } |
416 |
479 |
417 /* |
480 /* |
418 * initializeData |
481 * initializeData |
419 */ |
482 */ |
486 } |
549 } |
487 } |
550 } |
488 |
551 |
489 // In stringlist case, set stringSize to indicate size allocated for the whole stringlist buffer |
552 // In stringlist case, set stringSize to indicate size allocated for the whole stringlist buffer |
490 data->stringSize = allocBytes; |
553 data->stringSize = allocBytes; |
491 data->stringListCount = stringList.count(); |
554 data->listCount = stringList.count(); |
492 |
555 |
493 data->setDataType(StringList); |
556 data->setDataType(StringList); |
494 if (oldOffset != -1) { |
557 if (oldOffset != -1) { |
495 // Free old memory block |
558 // Free old memory block |
496 HbMemoryUtils::freeMemory(mMemoryType, oldOffset); |
559 HbMemoryUtils::freeMemory(mMemoryType, oldOffset); |
518 HbMemoryUtils::freeMemory(mMemoryType, oldOffset); |
581 HbMemoryUtils::freeMemory(mMemoryType, oldOffset); |
519 } |
582 } |
520 } |
583 } |
521 |
584 |
522 /* |
585 /* |
|
586 * fillIntListData |
|
587 */ |
|
588 void HbVariant::fillIntListData(const QList<int> &intList) |
|
589 { |
|
590 GET_MEMORY_MANAGER(mMemoryType); |
|
591 HbVariantData *data = getAddress<HbVariantData>(mMemoryType, mDataOffset, mShared); |
|
592 qptrdiff oldOffset = reservesMemory(data) ? data->mData.offset : -1; |
|
593 |
|
594 if (intList.isEmpty()) { |
|
595 data->mData.offset = -1; |
|
596 } else { |
|
597 // allocate memory and copy data. |
|
598 data->mData.offset = manager->alloc(intList.count() * sizeof(int)); |
|
599 char *address = getAddress<char>(mMemoryType, data->mData.offset, mShared); |
|
600 |
|
601 for (int j=0; j<intList.count(); ++j) { |
|
602 *((int*)address) = intList.at(j); |
|
603 address += sizeof(int); |
|
604 } |
|
605 } |
|
606 |
|
607 data->stringSize = 0; |
|
608 data->listCount = intList.count(); |
|
609 |
|
610 data->setDataType(IntList); |
|
611 if (oldOffset != -1) { |
|
612 // Free old memory block |
|
613 HbMemoryUtils::freeMemory(mMemoryType, oldOffset); |
|
614 } |
|
615 } |
|
616 |
|
617 |
|
618 |
|
619 /* |
523 * = operator taking int |
620 * = operator taking int |
524 */ |
621 */ |
525 HbVariant & HbVariant::operator=(int val) |
622 HbVariant & HbVariant::operator=(int val) |
526 { |
623 { |
527 detach(); // This will update the mDataOffset to new location if ref > 1. |
624 detach(); // This will update the mDataOffset to new location if ref > 1. |
581 * = operator taking QStringList |
678 * = operator taking QStringList |
582 */ |
679 */ |
583 HbVariant& HbVariant::operator=(const QStringList& strList) |
680 HbVariant& HbVariant::operator=(const QStringList& strList) |
584 { |
681 { |
585 fillStringListData(strList); |
682 fillStringListData(strList); |
|
683 return *this; |
|
684 } |
|
685 |
|
686 /* |
|
687 * = operator taking QList<int> |
|
688 */ |
|
689 HbVariant& HbVariant::operator=(const QList<int>& intList) |
|
690 { |
|
691 fillIntListData(intList); |
586 return *this; |
692 return *this; |
587 } |
693 } |
588 |
694 |
589 /* |
695 /* |
590 * = operator taking HbVariant |
696 * = operator taking HbVariant |
634 if(data->dataType() == t) { |
740 if(data->dataType() == t) { |
635 return true; |
741 return true; |
636 } |
742 } |
637 switch(uint(t)) { |
743 switch(uint(t)) { |
638 case HbVariant::Int: |
744 case HbVariant::Int: |
639 return data->dataType() == HbVariant::Double |
745 if (data->dataType() == HbVariant::IntList) { |
640 || data->dataType() == HbVariant::String; |
746 return data->listCount <= 1; |
|
747 } else { |
|
748 return data->dataType() == HbVariant::Double |
|
749 || data->dataType() == HbVariant::String; |
|
750 } |
641 case HbVariant::Double: |
751 case HbVariant::Double: |
642 return data->dataType() == HbVariant::Int |
752 if (data->dataType() == HbVariant::IntList) { |
643 || data->dataType() == HbVariant::String; |
753 return data->listCount <= 1; |
|
754 } else { |
|
755 return data->dataType() == HbVariant::Int |
|
756 || data->dataType() == HbVariant::String; |
|
757 } |
644 case HbVariant::String: |
758 case HbVariant::String: |
645 if (data->dataType() == HbVariant::StringList) { |
759 if (data->dataType() == HbVariant::StringList |
646 return data->stringListCount <= 1; |
760 || data->dataType() == HbVariant::IntList) { |
|
761 return data->listCount <= 1; |
647 } else { |
762 } else { |
648 return data->dataType() == HbVariant::Int |
763 return data->dataType() == HbVariant::Int |
649 || data->dataType() == HbVariant::Double |
764 || data->dataType() == HbVariant::Double |
650 || data->dataType() == HbVariant::Color; |
765 || data->dataType() == HbVariant::Color; |
651 } |
766 } |
652 case HbVariant::StringList: |
767 case HbVariant::StringList: |
|
768 return data->dataType() == HbVariant::String |
|
769 || data->dataType() == HbVariant::IntList; |
653 case HbVariant::Color: |
770 case HbVariant::Color: |
654 return data->dataType() == HbVariant::String; |
771 return data->dataType() == HbVariant::String; |
|
772 case HbVariant::IntList: |
|
773 return data->dataType() == HbVariant::Int |
|
774 || data->dataType() == HbVariant::Double |
|
775 || data->dataType() == HbVariant::String |
|
776 || data->dataType() == HbVariant::IntList; |
655 default : |
777 default : |
656 return false; |
778 return false; |
657 } |
779 } |
658 } |
780 } |
659 |
781 |
726 fillStringData(num.constData(), num.length()); |
849 fillStringData(num.constData(), num.length()); |
727 return true; |
850 return true; |
728 } |
851 } |
729 case HbVariant::StringList: |
852 case HbVariant::StringList: |
730 // canConvert checks that there is max 1 string in the stringlist |
853 // canConvert checks that there is max 1 string in the stringlist |
731 if (data->stringListCount == 0) { |
854 if (data->listCount == 0) { |
732 fillStringData(0, 0); |
855 fillStringData(0, 0); |
733 } else { |
856 } else { |
734 QString string = toString(); |
857 QString string = toString(); |
735 fillStringData(string.constData(), string.length()); |
858 fillStringData(string.constData(), string.length()); |
736 } |
859 } |
760 case HbVariant::StringList: |
883 case HbVariant::StringList: |
761 switch(data->dataType()) { |
884 switch(data->dataType()) { |
762 case HbVariant::String: |
885 case HbVariant::String: |
763 strList.append(getString()); |
886 strList.append(getString()); |
764 fillStringListData(strList); |
887 fillStringListData(strList); |
|
888 return true; |
|
889 default: |
|
890 return false; |
|
891 } |
|
892 case HbVariant::IntList: |
|
893 switch(data->dataType()) { |
|
894 case HbVariant::Int: |
|
895 intList.append(data->mData.i); |
|
896 fillIntListData(intList); |
765 return true; |
897 return true; |
766 default: |
898 default: |
767 return false; |
899 return false; |
768 } |
900 } |
769 |
901 |
789 case HbVariant::StringList : |
921 case HbVariant::StringList : |
790 return QVariant(toStringList()); |
922 return QVariant(toStringList()); |
791 case HbVariant::Color : { |
923 case HbVariant::Color : { |
792 QVariant var = getColor(); |
924 QVariant var = getColor(); |
793 return var; |
925 return var; |
|
926 } |
|
927 case HbVariant::IntList : { |
|
928 QList<int> intList = toIntList(); |
|
929 QList<QVariant> variantList; |
|
930 for (int i=0; i<intList.count(); i++) { |
|
931 variantList.append(intList.at(i)); |
|
932 } |
|
933 return QVariant(variantList); |
794 } |
934 } |
795 default: |
935 default: |
796 return QVariant(); |
936 return QVariant(); |
797 } |
937 } |
798 } |
938 } |
813 data->mData.d=double(0); |
953 data->mData.d=double(0); |
814 break; |
954 break; |
815 case HbVariant::String : |
955 case HbVariant::String : |
816 case HbVariant::Color : |
956 case HbVariant::Color : |
817 case HbVariant::StringList : |
957 case HbVariant::StringList : |
|
958 case HbVariant::IntList : |
818 HbMemoryUtils::freeMemory(mMemoryType, data->mData.offset); |
959 HbMemoryUtils::freeMemory(mMemoryType, data->mData.offset); |
819 break; |
960 break; |
820 default: |
961 default: |
821 break; |
962 break; |
822 } |
963 } |
845 case HbVariant::Color: |
986 case HbVariant::Color: |
846 qDebug() << getColor(); |
987 qDebug() << getColor(); |
847 break; |
988 break; |
848 case HbVariant::StringList: |
989 case HbVariant::StringList: |
849 qDebug() << toStringList(); |
990 qDebug() << toStringList(); |
|
991 case HbVariant::IntList: |
|
992 qDebug() << toIntList(); |
850 default: |
993 default: |
851 qDebug() << "Invalid Type"; |
994 qDebug() << "Invalid Type"; |
852 } |
995 } |
853 } |
996 } |
854 #endif // CSS_PARSER_TRACES |
997 #endif // CSS_PARSER_TRACES |