image/qimagereader.cpp

QString key = pair.left(index);

never executed: }

615

executed (the execution status of this line is deduced): QString key = pair.left(index);

616

text.insert(key, pair.mid(index + 2).simplified());

executed (the execution status of this line is deduced): text.insert(key, pair.mid(index + 2).simplified());

617

executed: }

Execution Count:66

618 } -

619

executed: }

Execution Count:12

620 -

621 /*! -

622 Constructs an empty QImageReader object. Before reading an image, -

623 call setDevice() or setFileName(). -

624 */ -

625 QImageReader::QImageReader() -

626 : d(new QImageReaderPrivate(this)) -

627 { -

628

executed: }

Execution Count:87

629 -

630 /*! -

631 Constructs a QImageReader object with the device \a device and the -

632 image format \a format. -

633 */ -

634 QImageReader::QImageReader(QIODevice *device, const QByteArray &format) -

635 : d(new QImageReaderPrivate(this)) -

636 { -

637

d->device = device;

executed (the execution status of this line is deduced): d->device = device;

638

d->format = format;

executed (the execution status of this line is deduced): d->format = format;

639

QFile *file = new QFile(fileName);

executed: }

Execution Count:252

252

640 -

641 /*! -

642 Constructs a QImageReader object with the file name \a fileName -

643 and the image format \a format. -

644 -

645 \sa setFileName() -

646 */ -

647 QImageReader::QImageReader(const QString &fileName, const QByteArray &format) -

648 : d(new QImageReaderPrivate(this)) -

649 { -

650

executed (the execution status of this line is deduced): QFile *file = new QFile(fileName);

651

d->device = file;

executed (the execution status of this line is deduced): d->device = file;

652

d->deleteDevice = true;

executed (the execution status of this line is deduced): d->deleteDevice = true;

653

d->format = format;

executed (the execution status of this line is deduced): d->format = format;

654

executed: }

Execution Count:1361

1361

655 -

656 /*! -

657 Destructs the QImageReader object. -

658 */ -

659 QImageReader::~QImageReader() -

660 { -

661

delete d;

executed (the execution status of this line is deduced): delete d;

662

executed: }

Execution Count:1700

1700

663 -

664 /*! -

665 Sets the format QImageReader will use when reading images, to \a -

666 format. \a format is a case insensitive text string. Example: -

667 -

668 \snippet code/src_gui_image_qimagereader.cpp 0 -

669 -

670 You can call supportedImageFormats() for the full list of formats -

671 QImageReader supports. -

672 -

673 \sa format() -

674 */ -

675 void QImageReader::setFormat(const QByteArray &format) -

676 { -

677

d->format = format;

never executed (the execution status of this line is deduced): d->format = format;

678

if (d->format.isEmpty()) {

never executed: }

679 -

680 /*! -

681 Returns the format QImageReader uses for reading images. -

682 -

683 You can call this function after assigning a device to the -

684 reader to determine the format of the device. For example: -

685 -

686 \snippet code/src_gui_image_qimagereader.cpp 1 -

687 -

688 If the reader cannot read any image from the device (e.g., there is no -

689 image there, or the image has already been read), or if the format is -

690 unsupported, this function returns an empty QByteArray(). -

691 -

692 \sa setFormat(), supportedImageFormats() -

693 */ -

694 QByteArray QImageReader::format() const -

695 { -

696

evaluated: d->format.isEmpty()

TRUE	FALSE
yes Evaluation Count:188	yes Evaluation Count:43

43-188

697

return d->handler->canRead() ? d->handler->format() : QByteArray();

evaluated: !d->initHandler()

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:184

4-184

698

return QByteArray();

executed: return QByteArray();

Execution Count:4

699

executed: return d->handler->canRead() ? d->handler->format() : QByteArray();

Execution Count:184

184

700 } -

701 -

702

return d->format;

executed: return d->format;

Execution Count:43

703 } -

704 -

705 /*! -

706 If \a enabled is true, image format autodetection is enabled; otherwise, -

707 it is disabled. By default, autodetection is enabled. -

708 -

709 QImageReader uses an extensive approach to detecting the image format; -

710 firstly, if you pass a file name to QImageReader, it will attempt to -

711 detect the file extension if the given file name does not point to an -

712 existing file, by appending supported default extensions to the given file -

713 name, one at a time. It then uses the following approach to detect the -

714 image format: -

715 -

716 \list -

717 -

718 \li Image plugins are queried first, based on either the optional format -

719 string, or the file name suffix (if the source device is a file). No -

720 content detection is done at this stage. QImageReader will choose the -

721 first plugin that supports reading for this format. -

722 -

723 \li If no plugin supports the image format, Qt's built-in handlers are -

724 checked based on either the optional format string, or the file name -

725 suffix. -

726 -

727 \li If no capable plugins or built-in handlers are found, each plugin is -

728 tested by inspecting the content of the data stream. -

729 -

730 \li If no plugins could detect the image format based on data contents, -

731 each built-in image handler is tested by inspecting the contents. -

732 -

733 \li Finally, if all above approaches fail, QImageReader will report failure -

734 when trying to read the image. -

735 -

736 \endlist -

737 -

738 By disabling image format autodetection, QImageReader will only query the -

739 plugins and built-in handlers based on the format string (i.e., no file -

740 name extensions are tested). -

741 -

742 \sa QImageIOHandler::canRead(), QImageIOPlugin::capabilities() -

743 */ -

744 void QImageReader::setAutoDetectImageFormat(bool enabled) -

745 { -

746

d->autoDetectImageFormat = enabled;

executed (the execution status of this line is deduced): d->autoDetectImageFormat = enabled;

747

return d->autoDetectImageFormat;

executed: }

Execution Count:10

748 -

749 /*! -

750 Returns true if image format autodetection is enabled on this image -

751 reader; otherwise returns false. By default, autodetection is enabled. -

752 -

753 \sa setAutoDetectImageFormat() -

754 */ -

755 bool QImageReader::autoDetectImageFormat() const -

756 { -

757

never executed: return d->autoDetectImageFormat;

758 } -

759 -

760 -

761 /*! -

762 If \a ignored is set to true, then the image reader will ignore -

763 specified formats or file extensions and decide which plugin to -

764 use only based on the contents in the datastream. -

765 -

766 Setting this flag means that all image plugins gets loaded. Each -

767 plugin will read the first bytes in the image data and decide if -

768 the plugin is compatible or not. -

769 -

770 This also disables auto detecting the image format. -

771 -

772 \sa decideFormatFromContent() -

773 */ -

774 -

775 void QImageReader::setDecideFormatFromContent(bool ignored) -

776 { -

777

d->ignoresFormatAndExtension = ignored;

executed (the execution status of this line is deduced): d->ignoresFormatAndExtension = ignored;

778

return d->ignoresFormatAndExtension;

executed: }

Execution Count:80

779 -

780 -

781 /*! -

782 Returns whether the image reader should decide which plugin to use -

783 only based on the contents of the datastream rather than on the file -

784 extension. -

785 -

786 \sa setDecideFormatFromContent() -

787 */ -

788 -

789 bool QImageReader::decideFormatFromContent() const -

790 { -

791

never executed: return d->ignoresFormatAndExtension;

792 } -

793 -

794 -

795 /*! -

796 Sets QImageReader's device to \a device. If a device has already -

797 been set, the old device is removed from QImageReader and is -

798 otherwise left unchanged. -

799 -

800 If the device is not already open, QImageReader will attempt to -

801 open the device in \l QIODevice::ReadOnly mode by calling -

802 open(). Note that this does not work for certain devices, such as -

803 QProcess, QTcpSocket and QUdpSocket, where more logic is required -

804 to open the device. -

805 -

806 \sa device(), setFileName() -

807 */ -

808 void QImageReader::setDevice(QIODevice *device) -

809 { -

810

if (d->device && d->deleteDevice)

evaluated: d->device

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:84

evaluated: d->deleteDevice

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:2

2-84

811

delete d->device;

executed: delete d->device;

Execution Count:2

812

d->device = device;

executed (the execution status of this line is deduced): d->device = device;

813

d->deleteDevice = false;

executed (the execution status of this line is deduced): d->deleteDevice = false;

814

delete d->handler;

executed (the execution status of this line is deduced): delete d->handler;

815

d->handler = 0;

executed (the execution status of this line is deduced): d->handler = 0;

816

d->text.clear();

executed (the execution status of this line is deduced): d->text.clear();

817

setDevice(new QFile(fileName));

executed: }

Execution Count:88

818 -

819 /*! -

820 Returns the device currently assigned to QImageReader, or 0 if no -

821 device has been assigned. -

822 */ -

823 QIODevice *QImageReader::device() const -

824 { -

825

return d->device;

executed: return d->device;

Execution Count:47

826 } -

827 -

828 /*! -

829 Sets the file name of QImageReader to \a fileName. Internally, -

830 QImageReader will create a QFile object and open it in \l -

831 QIODevice::ReadOnly mode, and use this when reading images. -

832 -

833 If \a fileName does not include a file extension (e.g., .png or .bmp), -

834 QImageReader will cycle through all supported extensions until it finds -

835 a matching file. -

836 -

837 \sa fileName(), setDevice(), supportedImageFormats() -

838 */ -

839 void QImageReader::setFileName(const QString &fileName) -

840 { -

841

executed (the execution status of this line is deduced): setDevice(new QFile(fileName));

842

d->deleteDevice = true;

executed (the execution status of this line is deduced): d->deleteDevice = true;

843

QFile *file = qobject_cast<QFile *>(d->device);

executed: }

Execution Count:84

844 -

845 /*! -

846 If the currently assigned device is a QFile, or if setFileName() -

847 has been called, this function returns the name of the file -

848 QImageReader reads from. Otherwise (i.e., if no device has been -

849 assigned or the device is not a QFile), an empty QString is -

850 returned. -

851 -

852 \sa setFileName(), setDevice() -

853 */ -

854 QString QImageReader::fileName() const -

855 { -

856

executed (the execution status of this line is deduced): QFile *file = qobject_cast<QFile *>(d->device);

857

return file ? file->fileName() : QString();

executed: return file ? file->fileName() : QString();

Execution Count:1661

1661

858 } -

859 -

860 /*! -

861 \since 4.2 -

862 -

863 This is an image format specific function that sets the quality -

864 level of the image to \a quality. For image formats that do not -

865 support setting the quality, this value is ignored. -

866 -

867 The value range of \a quality depends on the image format. For -

868 example, the "jpeg" format supports a quality range from 0 (low -

869 quality, high compression) to 100 (high quality, low compression). -

870 -

871 \sa quality() -

872 */ -

873 void QImageReader::setQuality(int quality) -

874 { -

875

d->quality = quality;

executed (the execution status of this line is deduced): d->quality = quality;

876

executed: }

Execution Count:19

877 -

878 /*! -

879 \since 4.2 -

880 -

881 Returns the quality level of the image. -

882 -

883 \sa setQuality() -

884 */ -

885 int QImageReader::quality() const -

886 { -

887

return d->quality;

never executed: return d->quality;

888 } -

889 -

890 -

891 /*! -

892 Returns the size of the image, without actually reading the image -

893 contents. -

894 -

895 If the image format does not support this feature, this function returns -

896 an invalid size. Qt's built-in image handlers all support this feature, -

897 but custom image format plugins are not required to do so. -

898 -

899 \sa QImageIOHandler::ImageOption, QImageIOHandler::option(), QImageIOHandler::supportsOption() -

900 */ -

901 QSize QImageReader::size() const -

902 { -

903

if (d->handler->supportsOption(QImageIOHandler::Size))

evaluated: !d->initHandler()

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:59

3-59

904

return QSize();

executed: return QSize();

Execution Count:3

905 -

906

partially evaluated: d->handler->supportsOption(QImageIOHandler::Size)

TRUE	FALSE
yes Evaluation Count:59	no Evaluation Count:0

0-59

907

return d->handler->option(QImageIOHandler::Size).toSize();

executed: return d->handler->option(QImageIOHandler::Size).toSize();

Execution Count:59

908 -

909

return QSize();

never executed: return QSize();

910 } -

911 -

912 /*! -

913 \since 4.5 -

914 -

915 Returns the format of the image, without actually reading the image -

916 contents. The format describes the image format \l QImageReader::read() -

917 returns, not the format of the actual image. -

918 -

919 If the image format does not support this feature, this function returns -

920 an invalid format. -

921 -

922 \sa QImageIOHandler::ImageOption, QImageIOHandler::option(), QImageIOHandler::supportsOption() -

923 */ -

924 QImage::Format QImageReader::imageFormat() const -

925 { -

926

return QImage::Format_Invalid;

partially evaluated: !d->initHandler()

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:19

0-19

927

never executed: return QImage::Format_Invalid;

928 -

929

if (d->handler->supportsOption(QImageIOHandler::ImageFormat))

evaluated: d->handler->supportsOption(QImageIOHandler::ImageFormat)

TRUE	FALSE
yes Evaluation Count:17	yes Evaluation Count:2

2-17

930

return (QImage::Format)d->handler->option(QImageIOHandler::ImageFormat).toInt();

executed: return (QImage::Format)d->handler->option(QImageIOHandler::ImageFormat).toInt();

Execution Count:17

931 -

932

return QImage::Format_Invalid;

executed: return QImage::Format_Invalid;

Execution Count:2

933 } -

934 -

935 /*! -

936 \since 4.1 -

937 -

938 Returns the text keys for this image. You can use -

939 these keys with text() to list the image text for -

940 a certain key. -

941 -

942 Support for this option is implemented through -

943 QImageIOHandler::Description. -

944 -

945 \sa text(), QImageWriter::setText(), QImage::textKeys() -

946 */ -

947 QStringList QImageReader::textKeys() const -

948 { -

949

d->getText();

never executed (the execution status of this line is deduced): d->getText();

950

return d->text.keys();

never executed: return d->text.keys();

951 } -

952 -

953 /*! -

954 \since 4.1 -

955 -

956 Returns the image text associated with \a key. -

957 -

958 Support for this option is implemented through -

959 QImageIOHandler::Description. -

960 -

961 \sa textKeys(), QImageWriter::setText() -

962 */ -

963 QString QImageReader::text(const QString &key) const -

964 { -

965

d->getText();

executed (the execution status of this line is deduced): d->getText();

966

return d->text.value(key);

executed: return d->text.value(key);

Execution Count:36

967 } -

968 -

969 /*! -

970 Sets the image clip rect (also known as the ROI, or Region Of -

971 Interest) to \a rect. The coordinates of \a rect are relative to -

972 the untransformed image size, as returned by size(). -

973 -

974 \sa clipRect(), setScaledSize(), setScaledClipRect() -

975 */ -

976 void QImageReader::setClipRect(const QRect &rect) -

977 { -

978

d->clipRect = rect;

executed (the execution status of this line is deduced): d->clipRect = rect;

979

executed: }

Execution Count:14

980 -

981 /*! -

982 Returns the clip rect (also known as the ROI, or Region Of -

983 Interest) of the image. If no clip rect has been set, an invalid -

984 QRect is returned. -

985 -

986 \sa setClipRect() -

987 */ -

988 QRect QImageReader::clipRect() const -

989 { -

990

return d->clipRect;

never executed: return d->clipRect;

991 } -

992 -

993 /*! -

994 Sets the scaled size of the image to \a size. The scaling is -

995 performed after the initial clip rect, but before the scaled clip -

996 rect is applied. The algorithm used for scaling depends on the -

997 image format. By default (i.e., if the image format does not -

998 support scaling), QImageReader will use QImage::scale() with -

999 Qt::SmoothScaling. -

1000 -

1001 \sa scaledSize(), setClipRect(), setScaledClipRect() -

1002 */ -

1003 void QImageReader::setScaledSize(const QSize &size) -

1004 { -

1005

d->scaledSize = size;

executed (the execution status of this line is deduced): d->scaledSize = size;

1006

d->scaledClipRect = rect;

executed: }

Execution Count:71

1007 -

1008 /*! -

1009 Returns the scaled size of the image. -

1010 -

1011 \sa setScaledSize() -

1012 */ -

1013 QSize QImageReader::scaledSize() const -

1014 { -

1015

return d->scaledSize;

executed: return d->scaledSize;

Execution Count:142

142

1016 } -

1017 -

1018 /*! -

1019 Sets the scaled clip rect to \a rect. The scaled clip rect is the -

1020 clip rect (also known as ROI, or Region Of Interest) that is -

1021 applied after the image has been scaled. -

1022 -

1023 \sa scaledClipRect(), setScaledSize() -

1024 */ -

1025 void QImageReader::setScaledClipRect(const QRect &rect) -

1026 { -

1027

executed (the execution status of this line is deduced): d->scaledClipRect = rect;

1028

return d->scaledClipRect;

executed: }

Execution Count:13

1029 -

1030 /*! -

1031 Returns the scaled clip rect of the image. -

1032 -

1033 \sa setScaledClipRect() -

1034 */ -

1035 QRect QImageReader::scaledClipRect() const -

1036 { -

1037

never executed: return d->scaledClipRect;

1038 } -

1039 -

1040 /*! -

1041 \since 4.1 -

1042 -

1043 Sets the background color to \a color. -

1044 Image formats that support this operation are expected to -

1045 initialize the background to \a color before reading an image. -

1046 -

1047 \sa backgroundColor(), read() -

1048 */ -

1049 void QImageReader::setBackgroundColor(const QColor &color) -

1050 { -

1051

if (d->handler->supportsOption(QImageIOHandler::BackgroundColor))

evaluated: !d->initHandler()

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:19

2-19

1052

return;

executed: return;

Execution Count:2

1053

partially evaluated: d->handler->supportsOption(QImageIOHandler::BackgroundColor)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:19

0-19

1054

d->handler->setOption(QImageIOHandler::BackgroundColor, color);

never executed: d->handler->setOption(QImageIOHandler::BackgroundColor, color);

1055

executed: }

Execution Count:19

1056 -

1057 /*! -

1058 \since 4.1 -

1059 -

1060 Returns the background color that's used when reading an image. -

1061 If the image format does not support setting the background color -

1062 an invalid color is returned. -

1063 -

1064 \sa setBackgroundColor(), read() -

1065 */ -

1066 QColor QImageReader::backgroundColor() const -

1067 { -

1068

if (d->handler->supportsOption(QImageIOHandler::BackgroundColor))

evaluated: !d->initHandler()

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:19

2-19

1069

return QColor();

executed: return QColor();

Execution Count:2

1070

partially evaluated: d->handler->supportsOption(QImageIOHandler::BackgroundColor)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:19

0-19

1071

return qvariant_cast<QColor>(d->handler->option(QImageIOHandler::BackgroundColor));

never executed: return qvariant_cast<QColor>(d->handler->option(QImageIOHandler::BackgroundColor));

1072

return QColor();

executed: return QColor();

Execution Count:19

1073 } -

1074 -

1075 /*! -

1076 \since 4.1 -

1077 -

1078 Returns true if the image format supports animation; -

1079 otherwise, false is returned. -

1080 -

1081 \sa QMovie::supportedFormats() -

1082 */ -

1083 bool QImageReader::supportsAnimation() const -

1084 { -

1085

evaluated: !d->initHandler()

TRUE	FALSE
yes Evaluation Count:2	yes Evaluation Count:51

2-51

1086

if (d->handler->supportsOption(QImageIOHandler::Animation))

executed: return false;

Execution Count:2

1087

evaluated: d->handler->supportsOption(QImageIOHandler::Animation)

TRUE	FALSE
yes Evaluation Count:6	yes Evaluation Count:45

6-45

1088

return d->handler->option(QImageIOHandler::Animation).toBool();

executed: return d->handler->option(QImageIOHandler::Animation).toBool();

Execution Count:6

1089

executed: return false;

Execution Count:45

1090 } -

1091 -

1092 /*! -

1093 Returns true if an image can be read for the device (i.e., the -

1094 image format is supported, and the device seems to contain valid -

1095 data); otherwise returns false. -

1096 -

1097 canRead() is a lightweight function that only does a quick test to -

1098 see if the image data is valid. read() may still return false -

1099 after canRead() returns true, if the image data is corrupt. -

1100 -

1101 For images that support animation, canRead() returns false when -

1102 all frames have been read. -

1103 -

1104 \sa read(), supportedImageFormats() -

1105 */ -

1106 bool QImageReader::canRead() const -

1107 { -

1108

evaluated: !d->initHandler()

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:392

3-392

1109

return d->handler->canRead();

executed: return false;

Execution Count:3

1110 -

1111

executed: return d->handler->canRead();

Execution Count:392

392

1112 } -

1113 -

1114 /*! -

1115 Reads an image from the device. On success, the image that was -

1116 read is returned; otherwise, a null QImage is returned. You can -

1117 then call error() to find the type of error that occurred, or -

1118 errorString() to get a human readable description of the error. -

1119 -

1120 For image formats that support animation, calling read() -

1121 repeatedly will return the next frame. When all frames have been -

1122 read, a null image will be returned. -

1123 -

1124 \sa canRead(), supportedImageFormats(), supportsAnimation(), QMovie -

1125 */ -

1126 QImage QImageReader::read() -

1127 { -

1128 // Because failed image reading might have side effects, we explicitly -

1129 // return a null image instead of the image we've just created. -

1130

QImage image;

executed (the execution status of this line is deduced): QImage image;

1131

return read(&image) ? image : QImage();

executed: return read(&image) ? image : QImage();

Execution Count:1626

1626

1132 } -

1133 -

1134 /*! -

1135 \overload -

1136 -

1137 Reads an image from the device into \a image, which must point to a -

1138 QImage. Returns true on success; otherwise, returns false. -

1139 -

1140 If \a image has same format and size as the image data that is about to be -

1141 read, this function may not need to allocate a new image before -

1142 reading. Because of this, it can be faster than the other read() overload, -

1143 which always constructs a new image; especially when reading several -

1144 images with the same format and size. -

1145 -

1146 \snippet code/src_gui_image_qimagereader.cpp 2 -

1147 -

1148 For image formats that support animation, calling read() repeatedly will -

1149 return the next frame. When all frames have been read, a null image will -

1150 be returned. -

1151 -

1152 \sa canRead(), supportedImageFormats(), supportsAnimation(), QMovie -

1153 */ -

1154 bool QImageReader::read(QImage *image) -

1155 { -

1156

if (!image) {

partially evaluated: !image

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1809

0-1809

1157

qWarning("QImageReader::read: cannot read into null pointer");

never executed (the execution status of this line is deduced):

 QMessageLogger("image/qimagereader.cpp", 1157, __PRETTY_FUNCTION__).warning("QImageReader::read: cannot read into null pointer");

1158

if (!d->handler && !d->initHandler())

never executed: return false;

1159 } -

1160 -

1161

evaluated: !d->handler

TRUE	FALSE
yes Evaluation Count:1251	yes Evaluation Count:558

evaluated: !d->initHandler()

TRUE	FALSE
yes Evaluation Count:24	yes Evaluation Count:1227

24-1251

1162

if (d->handler->supportsOption(QImageIOHandler::ScaledSize) && d->scaledSize.isValid()) {

executed: return false;

Execution Count:24

1163 -

1164 // set the handler specific options. -

1165

evaluated: d->handler->supportsOption(QImageIOHandler::ScaledSize)

TRUE	FALSE
yes Evaluation Count:602	yes Evaluation Count:1183

evaluated: d->scaledSize.isValid()

TRUE	FALSE
yes Evaluation Count:24	yes Evaluation Count:578

24-1183

1166

if ((d->handler->supportsOption(QImageIOHandler::ClipRect) && !d->clipRect.isNull())

evaluated: d->handler->supportsOption(QImageIOHandler::ClipRect)

TRUE	FALSE
yes Evaluation Count:20	yes Evaluation Count:4

partially evaluated: !d->clipRect.isNull()

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:20

0-20

1167

|| d->clipRect.isNull()) {

partially evaluated: d->clipRect.isNull()

TRUE	FALSE
yes Evaluation Count:24	no Evaluation Count:0

0-24

1168 // Only enable the ScaledSize option if there is no clip rect, or -

1169 // if the handler also supports ClipRect. -

1170

d->handler->setOption(QImageIOHandler::ScaledSize, d->scaledSize);

executed (the execution status of this line is deduced): d->handler->setOption(QImageIOHandler::ScaledSize, d->scaledSize);

1171

executed: }

Execution Count:24

1172

if (d->handler->supportsOption(QImageIOHandler::ClipRect) && !d->clipRect.isNull())

executed: }

Execution Count:24

1173

evaluated: d->handler->supportsOption(QImageIOHandler::ClipRect)

TRUE	FALSE
yes Evaluation Count:194	yes Evaluation Count:1591

evaluated: !d->clipRect.isNull()

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:193

1-1591

1174

d->handler->setOption(QImageIOHandler::ClipRect, d->clipRect);

executed: d->handler->setOption(QImageIOHandler::ClipRect, d->clipRect);

Execution Count:1

1175

if (d->handler->supportsOption(QImageIOHandler::ScaledClipRect) && !d->scaledClipRect.isNull())

evaluated: d->handler->supportsOption(QImageIOHandler::ScaledClipRect)

TRUE	FALSE
yes Evaluation Count:194	yes Evaluation Count:1591

evaluated: !d->scaledClipRect.isNull()

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:193

1-1591

1176

d->handler->setOption(QImageIOHandler::ScaledClipRect, d->scaledClipRect);

executed: d->handler->setOption(QImageIOHandler::ScaledClipRect, d->scaledClipRect);

Execution Count:1

1177

if (d->handler->supportsOption(QImageIOHandler::Quality))

evaluated: d->handler->supportsOption(QImageIOHandler::Quality)

TRUE	FALSE
yes Evaluation Count:602	yes Evaluation Count:1183

602-1183

1178

d->handler->setOption(QImageIOHandler::Quality, d->quality);

executed: d->handler->setOption(QImageIOHandler::Quality, d->quality);

Execution Count:602

602

1179 -

1180 // read the image -

1181

if (!d->handler->read(image)) {

evaluated: !d->handler->read(image)

TRUE	FALSE
yes Evaluation Count:135	yes Evaluation Count:1650

135-1650

1182

d->imageReaderError = InvalidDataError;

executed (the execution status of this line is deduced): d->imageReaderError = InvalidDataError;

1183

d->errorString = QLatin1String(QT_TRANSLATE_NOOP(QImageReader, "Unable to read image data"));

executed (the execution status of this line is deduced): d->errorString = QLatin1String("Unable to read image data");

1184

if (d->handler->supportsOption(QImageIOHandler::ClipRect) && !d->clipRect.isNull()) {

executed: return false;

Execution Count:135

135

1185 } -

1186 -

1187 // provide default implementations for any unsupported image -

1188 // options -

1189

evaluated: d->handler->supportsOption(QImageIOHandler::ClipRect)

TRUE	FALSE
yes Evaluation Count:168	yes Evaluation Count:1482

evaluated: !d->clipRect.isNull()

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:167

1-1482

1190

if (d->handler->supportsOption(QImageIOHandler::ScaledSize) && d->scaledSize.isValid()) {

partially evaluated: d->handler->supportsOption(QImageIOHandler::ScaledSize)

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

partially evaluated: d->scaledSize.isValid()

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

1191

if (d->handler->supportsOption(QImageIOHandler::ScaledClipRect) && !d->scaledClipRect.isNull()) {

never evaluated: d->handler->supportsOption(QImageIOHandler::ScaledClipRect)

never evaluated: !d->scaledClipRect.isNull()

1192 // all features are supported by the handler; nothing to do. -

1193

if (!d->scaledClipRect.isNull())

never executed: }

1194 // the image is already scaled, so apply scaled clipping. -

1195

never evaluated: !d->scaledClipRect.isNull()

1196

never executed: *image = image->copy(d->scaledClipRect);

1197

if (d->handler->supportsOption(QImageIOHandler::ScaledClipRect) && !d->scaledClipRect.isNull()) {

never executed: }

1198 } else { -

1199

partially evaluated: d->handler->supportsOption(QImageIOHandler::ScaledClipRect)

TRUE	FALSE
yes Evaluation Count:1	no Evaluation Count:0

partially evaluated: !d->scaledClipRect.isNull()

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

1200 // supports scaled clipping but not scaling, most -

1201 // likely a broken handler. -

1202

if (d->scaledSize.isValid()) {

never executed: }

1203

partially evaluated: d->scaledSize.isValid()

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

1204

*image = image->scaled(d->scaledSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);

never executed (the execution status of this line is deduced): *image = image->scaled(d->scaledSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);

1205

if (d->scaledClipRect.isValid()) {

never executed: }

1206

partially evaluated: d->scaledClipRect.isValid()

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1

0-1

1207

if (d->handler->supportsOption(QImageIOHandler::ScaledSize) && d->scaledSize.isValid() && d->clipRect.isNull()) {

never executed (the execution status of this line is deduced): *image = image->copy(d->scaledClipRect);

never executed: }

executed: }

Execution Count:1

1210 } -

1211 } else { -

1212

evaluated: d->handler->supportsOption(QImageIOHandler::ScaledSize)

TRUE	FALSE
yes Evaluation Count:560	yes Evaluation Count:1089

evaluated: d->scaledSize.isValid()

TRUE	FALSE
yes Evaluation Count:15	yes Evaluation Count:545

partially evaluated: d->clipRect.isNull()

TRUE	FALSE
yes Evaluation Count:15	no Evaluation Count:0

0-1089

1213

if (d->handler->supportsOption(QImageIOHandler::ScaledClipRect) && !d->scaledClipRect.isNull()) {

evaluated: d->handler->supportsOption(QImageIOHandler::ScaledClipRect)

TRUE	FALSE
yes Evaluation Count:11	yes Evaluation Count:4

evaluated: !d->scaledClipRect.isNull()

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:10

1-11

1214 // nothing to do (ClipRect is ignored!) -

1215

if (d->scaledClipRect.isValid()) {

executed: }

Execution Count:1

1216 // provide all workarounds. -

1217

evaluated: d->scaledClipRect.isValid()

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:13

1-13

1218

executed (the execution status of this line is deduced): *image = image->copy(d->scaledClipRect);

1219

executed: }

Execution Count:1

1220

if (d->handler->supportsOption(QImageIOHandler::ScaledClipRect) && !d->scaledClipRect.isNull()) {

executed: }

Execution Count:14

1221 } else { -

1222

evaluated: d->handler->supportsOption(QImageIOHandler::ScaledClipRect)

TRUE	FALSE
yes Evaluation Count:156	yes Evaluation Count:1478

partially evaluated: !d->scaledClipRect.isNull()

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:156

0-1478

1223 // this makes no sense; a handler that supports -

1224 // ScaledClipRect but not ScaledSize is broken, and we -

1225 // can't work around it. -

1226

if (d->clipRect.isValid())

never executed: }

1227 // provide all workarounds. -

1228

evaluated: d->clipRect.isValid()

TRUE	FALSE
yes Evaluation Count:13	yes Evaluation Count:1621

13-1621

1229

*image = image->copy(d->clipRect);

executed: *image = image->copy(d->clipRect);

Execution Count:13

1230

if (d->scaledSize.isValid())

evaluated: d->scaledSize.isValid()

TRUE	FALSE
yes Evaluation Count:40	yes Evaluation Count:1594

40-1594

1231

*image = image->scaled(d->scaledSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);

executed: *image = image->scaled(d->scaledSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);

Execution Count:40

1232

if (d->scaledClipRect.isValid())

evaluated: d->scaledClipRect.isValid()

TRUE	FALSE
yes Evaluation Count:11	yes Evaluation Count:1623

11-1623

1233

executed: *image = image->copy(d->scaledClipRect);

Execution Count:11

1234

if (QFileInfo(fileName()).baseName().endsWith(QLatin1String("@2x"))) {

executed: }

Execution Count:1634

1634

1235 } -

1236 } -

1237 -

1238 // successful read; check for "@2x" file name suffix and set device pixel ratio. -

1239

partially evaluated: QFileInfo(fileName()).baseName().endsWith(QLatin1String("@2x"))

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:1650

0-1650

1240

image->setDevicePixelRatio(2.0);

never executed (the execution status of this line is deduced): image->setDevicePixelRatio(2.0);

1241

never executed: }

1242 -

1243

return true;

executed: return true;

Execution Count:1650

1650

1244 } -

1245 -

1246 /*! -

1247 For image formats that support animation, this function steps over the -

1248 current image, returning true if successful or false if there is no -

1249 following image in the animation. -

1250 -

1251 The default implementation calls read(), then discards the resulting -

1252 image, but the image handler may have a more efficient way of implementing -

1253 this operation. -

1254 -

1255 \sa jumpToImage(), QImageIOHandler::jumpToNextImage() -

1256 */ -

1257 bool QImageReader::jumpToNextImage() -

1258 { -

1259

partially evaluated: !d->initHandler()

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:42

0-42

1260

return d->handler->jumpToNextImage();

never executed: return false;

1261

executed: return d->handler->jumpToNextImage();

Execution Count:42

1262 } -

1263 -

1264 /*! -

1265 For image formats that support animation, this function skips to the image -

1266 whose sequence number is \a imageNumber, returning true if successful -

1267 or false if the corresponding image cannot be found. -

1268 -

1269 The next call to read() will attempt to read this image. -

1270 -

1271 \sa jumpToNextImage(), QImageIOHandler::jumpToImage() -

1272 */ -

1273 bool QImageReader::jumpToImage(int imageNumber) -

1274 { -

1275

partially evaluated: !d->initHandler()

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:60

0-60

1276

return d->handler->jumpToImage(imageNumber);

never executed: return false;

1277

executed: return d->handler->jumpToImage(imageNumber);

Execution Count:60

1278 } -

1279 -

1280 /*! -

1281 For image formats that support animation, this function returns the number -

1282 of times the animation should loop. If this function returns -1, it can -

1283 either mean the animation should loop forever, or that an error occurred. -

1284 If an error occurred, canRead() will return false. -

1285 -

1286 \sa supportsAnimation(), QImageIOHandler::loopCount(), canRead() -

1287 */ -

1288 int QImageReader::loopCount() const -

1289 { -

1290

partially evaluated: !d->initHandler()

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:11

0-11

1291

return d->handler->loopCount();

never executed: return -1;

1292

executed: return d->handler->loopCount();

Execution Count:11

1293 } -

1294 -

1295 /*! -

1296 For image formats that support animation, this function returns the total -

1297 number of images in the animation. If the format does not support -

1298 animation, 0 is returned. -

1299 -

1300 This function returns -1 if an error occurred. -

1301 -

1302 \sa supportsAnimation(), QImageIOHandler::imageCount(), canRead() -

1303 */ -

1304 int QImageReader::imageCount() const -

1305 { -

1306

evaluated: !d->initHandler()

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:59

1-59

1307

return d->handler->imageCount();

executed: return -1;

Execution Count:1

1308

executed: return d->handler->imageCount();

Execution Count:59

1309 } -

1310 -

1311 /*! -

1312 For image formats that support animation, this function returns the number -

1313 of milliseconds to wait until displaying the next frame in the animation. -

1314 If the image format doesn't support animation, 0 is returned. -

1315 -

1316 This function returns -1 if an error occurred. -

1317 -

1318 \sa supportsAnimation(), QImageIOHandler::nextImageDelay(), canRead() -

1319 */ -

1320 int QImageReader::nextImageDelay() const -

1321 { -

1322

partially evaluated: !d->initHandler()

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:178

0-178

1323

return d->handler->nextImageDelay();

never executed: return -1;

1324

executed: return d->handler->nextImageDelay();

Execution Count:178

178

1325 } -

1326 -

1327 /*! -

1328 For image formats that support animation, this function returns the -

1329 sequence number of the current frame. If the image format doesn't support -

1330 animation, 0 is returned. -

1331 -

1332 This function returns -1 if an error occurred. -

1333 -

1334 \sa supportsAnimation(), QImageIOHandler::currentImageNumber(), canRead() -

1335 */ -

1336 int QImageReader::currentImageNumber() const -

1337 { -

1338

never evaluated: !d->initHandler()

1339

return d->handler->currentImageNumber();

never executed: return -1;

1340

never executed: return d->handler->currentImageNumber();

1341 } -

1342 -

1343 /*! -

1344 For image formats that support animation, this function returns -

1345 the rect for the current frame. Otherwise, a null rect is returned. -

1346 -

1347 \sa supportsAnimation(), QImageIOHandler::currentImageRect() -

1348 */ -

1349 QRect QImageReader::currentImageRect() const -

1350 { -

1351

return d->handler->currentImageRect();

never evaluated: !d->initHandler()

1352

return QRect();

never executed: return QRect();

1353

never executed: return d->handler->currentImageRect();

1354 } -

1355 -

1356 /*! -

1357 Returns the type of error that occurred last. -

1358 -

1359 \sa ImageReaderError, errorString() -

1360 */ -

1361 QImageReader::ImageReaderError QImageReader::error() const -

1362 { -

1363

return d->imageReaderError;

never executed: return d->imageReaderError;

1364 } -

1365 -

1366 /*! -

1367 Returns a human readable description of the last error that -

1368 occurred. -

1369 -

1370 \sa error() -

1371 */ -

1372 QString QImageReader::errorString() const -

1373 { -

1374

if (d->errorString.isEmpty())

partially evaluated: d->errorString.isEmpty()

TRUE	FALSE
yes Evaluation Count:232	no Evaluation Count:0

0-232

1375

return QLatin1String(QT_TRANSLATE_NOOP(QImageReader, "Unknown error"));

executed: return QLatin1String("Unknown error");

Execution Count:232

232

1376

return d->errorString;

never executed: return d->errorString;

1377 } -

1378 -

1379 /*! -

1380 \since 4.2 -

1381 -

1382 Returns true if the reader supports \a option; otherwise returns -

1383 false. -

1384 -

1385 Different image formats support different options. Call this function to -

1386 determine whether a certain option is supported by the current format. For -

1387 example, the PNG format allows you to embed text into the image's metadata -

1388 (see text()), and the BMP format allows you to determine the image's size -

1389 without loading the whole image into memory (see size()). -

1390 -

1391 \snippet code/src_gui_image_qimagereader.cpp 3 -

1392 -

1393 \sa QImageWriter::supportsOption() -

1394 */ -

1395 bool QImageReader::supportsOption(QImageIOHandler::ImageOption option) const -

1396 { -

1397

evaluated: !d->initHandler()

TRUE	FALSE
yes Evaluation Count:19	yes Evaluation Count:14

14-19

1398

return d->handler->supportsOption(option);

executed: return false;

Execution Count:19

1399

executed: return d->handler->supportsOption(option);

Execution Count:14

1400 } -

1401 -

1402 /*! -

1403 If supported, this function returns the image format of the file -

1404 \a fileName. Otherwise, an empty string is returned. -

1405 */ -

1406 QByteArray QImageReader::imageFormat(const QString &fileName) -

1407 { -

1408

QFile file(fileName);

executed (the execution status of this line is deduced): QFile file(fileName);

1409

if (!file.open(QFile::ReadOnly))

partially evaluated: !file.open(QFile::ReadOnly)

TRUE	FALSE
no Evaluation Count:0	yes Evaluation Count:29

0-29

1410

return QByteArray();

never executed: return QByteArray();

1411 -

1412

return imageFormat(&file);

executed: return imageFormat(&file);

Execution Count:29

1413 } -

1414 -

1415 /*! -

1416 If supported, this function returns the image format of the device -

1417 \a device. Otherwise, an empty string is returned. -

1418 -

1419 \sa QImageReader::autoDetectImageFormat() -

1420 */ -

1421 QByteArray QImageReader::imageFormat(QIODevice *device) -

1422 { -

1423

QByteArray format;

executed (the execution status of this line is deduced): QByteArray format;

1424

QImageIOHandler *handler = createReadHandlerHelper(device, format, /* autoDetectImageFormat = */ true, false);

executed (the execution status of this line is deduced): QImageIOHandler *handler = createReadHandlerHelper(device, format, true, false);

1425

if (handler) {

partially evaluated: handler

TRUE	FALSE
yes Evaluation Count:29	no Evaluation Count:0

0-29

1426

if (handler->canRead())

partially evaluated: handler->canRead()

TRUE	FALSE
yes Evaluation Count:29	no Evaluation Count:0

0-29

1427

format = handler->format();

executed: format = handler->format();

Execution Count:29

1428

delete handler;

executed (the execution status of this line is deduced): delete handler;

1429