image/qimagereader.cpp

QString key = pair.left(index);

never executed: }

626

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

627

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());

628

executed: }

Execution Count:66

629 } -

630

executed: }

Execution Count:12

631 -

632 /*! -

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

634 call setDevice() or setFileName(). -

635 */ -

636 QImageReader::QImageReader() -

637 : d(new QImageReaderPrivate(this)) -

638 { -

639

executed: }

Execution Count:87

640 -

641 /*! -

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

643 image format \a format. -

644 */ -

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

646 : d(new QImageReaderPrivate(this)) -

647 { -

648

d->device = device;

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

649

d->format = format;

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

650

QFile *file = new QFile(fileName);

executed: }

Execution Count:252

252

651 -

652 /*! -

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

654 and the image format \a format. -

655 -

656 \sa setFileName() -

657 */ -

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

659 : d(new QImageReaderPrivate(this)) -

660 { -

661

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

662

d->device = file;

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

663

d->deleteDevice = true;

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

664

d->format = format;

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

665

executed: }

Execution Count:1399

1399

666 -

667 /*! -

668 Destructs the QImageReader object. -

669 */ -

670 QImageReader::~QImageReader() -

671 { -

672

delete d;

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

673

executed: }

Execution Count:1738

1738

674 -

675 /*! -

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

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

678 -

679 \snippet code/src_gui_image_qimagereader.cpp 0 -

680 -

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

682 QImageReader supports. -

683 -

684 \sa format() -

685 */ -

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

687 { -

688

d->format = format;

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

689

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

never executed: }

690 -

691 /*! -

692 Returns the format QImageReader uses for reading images. -

693 -

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

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

696 -

697 \snippet code/src_gui_image_qimagereader.cpp 1 -

698 -

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

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

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

702 -

703 \sa setFormat(), supportedImageFormats() -

704 */ -

705 QByteArray QImageReader::format() const -

706 { -

707

evaluated: d->format.isEmpty()

TRUE	FALSE
yes Evaluation Count:190	yes Evaluation Count:45

45-190

708

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

evaluated: !d->initHandler()

TRUE	FALSE
yes Evaluation Count:4	yes Evaluation Count:186

4-186

709

return QByteArray();

executed: return QByteArray();

Execution Count:4

710

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

Execution Count:186

186

711 } -

712 -

713

return d->format;

executed: return d->format;

Execution Count:45

714 } -

715 -

716 /*! -

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

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

719 -

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

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

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

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

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

725 image format: -

726 -

727 \list -

728 -

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

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

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

732 first plugin that supports reading for this format. -

733 -

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

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

736 suffix. -

737 -

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

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

740 -

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

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

743 -

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

745 when trying to read the image. -

746 -

747 \endlist -

748 -

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

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

751 name extensions are tested). -

752 -

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

754 */ -

755 void QImageReader::setAutoDetectImageFormat(bool enabled) -

756 { -

757

d->autoDetectImageFormat = enabled;

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

758

return d->autoDetectImageFormat;

executed: }

Execution Count:10

759 -

760 /*! -

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

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

763 -

764 \sa setAutoDetectImageFormat() -

765 */ -

766 bool QImageReader::autoDetectImageFormat() const -

767 { -

768

never executed: return d->autoDetectImageFormat;

769 } -

770 -

771 -

772 /*! -

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

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

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

776 -

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

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

779 the plugin is compatible or not. -

780 -

781 This also disables auto detecting the image format. -

782 -

783 \sa decideFormatFromContent() -

784 */ -

785 -

786 void QImageReader::setDecideFormatFromContent(bool ignored) -

787 { -

788

d->ignoresFormatAndExtension = ignored;

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

789

return d->ignoresFormatAndExtension;

executed: }

Execution Count:80

790 -

791 -

792 /*! -

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

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

795 extension. -

796 -

797 \sa setDecideFormatFromContent() -

798 */ -

799 -

800 bool QImageReader::decideFormatFromContent() const -

801 { -

802

never executed: return d->ignoresFormatAndExtension;

803 } -

804 -

805 -

806 /*! -

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

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

809 otherwise left unchanged. -

810 -

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

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

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

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

815 to open the device. -

816 -

817 \sa device(), setFileName() -

818 */ -

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

820 { -

821

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

822

delete d->device;

executed: delete d->device;

Execution Count:2

823

d->device = device;

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

824

d->deleteDevice = false;

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

825

delete d->handler;

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

826

d->handler = 0;

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

827

d->text.clear();

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

828

setDevice(new QFile(fileName));

executed: }

Execution Count:88

829 -

830 /*! -

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

832 device has been assigned. -

833 */ -

834 QIODevice *QImageReader::device() const -

835 { -

836

return d->device;

executed: return d->device;

Execution Count:47

837 } -

838 -

839 /*! -

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

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

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

843 -

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

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

846 a matching file. -

847 -

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

849 */ -

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

851 { -

852

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

853

d->deleteDevice = true;

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

854

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

executed: }

Execution Count:84

855 -

856 /*! -

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

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

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

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

861 returned. -

862 -

863 \sa setFileName(), setDevice() -

864 */ -

865 QString QImageReader::fileName() const -

866 { -

867

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

868

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

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

Execution Count:1692

1692

869 } -

870 -

871 /*! -

872 \since 4.2 -

873 -

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

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

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

877 -

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

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

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

881 -

882 \sa quality() -

883 */ -

884 void QImageReader::setQuality(int quality) -

885 { -

886

d->quality = quality;

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

887

executed: }

Execution Count:19

888 -

889 /*! -

890 \since 4.2 -

891 -

892 Returns the quality level of the image. -

893 -

894 \sa setQuality() -

895 */ -

896 int QImageReader::quality() const -

897 { -

898

return d->quality;

never executed: return d->quality;

899 } -

900 -

901 -

902 /*! -

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

904 contents. -

905 -

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

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

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

909 -

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

911 */ -

912 QSize QImageReader::size() const -

913 { -

914

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

evaluated: !d->initHandler()

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

3-59

915

return QSize();

executed: return QSize();

Execution Count:3

916 -

917

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

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

0-59

918

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

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

Execution Count:59

919 -

920

return QSize();

never executed: return QSize();

921 } -

922 -

923 /*! -

924 \since 4.5 -

925 -

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

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

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

929 -

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

931 an invalid format. -

932 -

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

934 */ -

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

936 { -

937

return QImage::Format_Invalid;

partially evaluated: !d->initHandler()

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

0-19

938

never executed: return QImage::Format_Invalid;

939 -

940

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

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

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

2-17

941

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

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

Execution Count:17

942 -

943

return QImage::Format_Invalid;

executed: return QImage::Format_Invalid;

Execution Count:2

944 } -

945 -

946 /*! -

947 \since 4.1 -

948 -

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

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

951 a certain key. -

952 -

953 Support for this option is implemented through -

954 QImageIOHandler::Description. -

955 -

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

957 */ -

958 QStringList QImageReader::textKeys() const -

959 { -

960

d->getText();

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

961

return d->text.keys();

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

962 } -

963 -

964 /*! -

965 \since 4.1 -

966 -

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

968 -

969 Support for this option is implemented through -

970 QImageIOHandler::Description. -

971 -

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

973 */ -

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

975 { -

976

d->getText();

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

977

return d->text.value(key);

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

Execution Count:36

978 } -

979 -

980 /*! -

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

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

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

984 -

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

986 */ -

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

988 { -

989

d->clipRect = rect;

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

990

executed: }

Execution Count:14

991 -

992 /*! -

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

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

995 QRect is returned. -

996 -

997 \sa setClipRect() -

998 */ -

999 QRect QImageReader::clipRect() const -

1000 { -

1001

return d->clipRect;

never executed: return d->clipRect;

1002 } -

1003 -

1004 /*! -

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

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

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

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

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

1010 Qt::SmoothScaling. -

1011 -

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

1013 */ -

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

1015 { -

1016

d->scaledSize = size;

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

1017

d->scaledClipRect = rect;

executed: }

Execution Count:71

1018 -

1019 /*! -

1020 Returns the scaled size of the image. -

1021 -

1022 \sa setScaledSize() -

1023 */ -

1024 QSize QImageReader::scaledSize() const -

1025 { -

1026

return d->scaledSize;

executed: return d->scaledSize;

Execution Count:141

141

1027 } -

1028 -

1029 /*! -

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

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

1032 applied after the image has been scaled. -

1033 -

1034 \sa scaledClipRect(), setScaledSize() -

1035 */ -

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

1037 { -

1038

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

1039

return d->scaledClipRect;

executed: }

Execution Count:13

1040 -

1041 /*! -

1042 Returns the scaled clip rect of the image. -

1043 -

1044 \sa setScaledClipRect() -

1045 */ -

1046 QRect QImageReader::scaledClipRect() const -

1047 { -

1048

never executed: return d->scaledClipRect;

1049 } -

1050 -

1051 /*! -

1052 \since 4.1 -

1053 -

1054 Sets the background color to \a color. -

1055 Image formats that support this operation are expected to -

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

1057 -

1058 \sa backgroundColor(), read() -

1059 */ -

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

1061 { -

1062

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

evaluated: !d->initHandler()

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

2-19

1063

return;

executed: return;

Execution Count:2

1064

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

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

0-19

1065

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

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

1066

executed: }

Execution Count:19

1067 -

1068 /*! -

1069 \since 4.1 -

1070 -

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

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

1073 an invalid color is returned. -

1074 -

1075 \sa setBackgroundColor(), read() -

1076 */ -

1077 QColor QImageReader::backgroundColor() const -

1078 { -

1079

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

evaluated: !d->initHandler()

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

2-19

1080

return QColor();

executed: return QColor();

Execution Count:2

1081

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

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

0-19

1082

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

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

1083

return QColor();

executed: return QColor();

Execution Count:19

1084 } -

1085 -

1086 /*! -

1087 \since 4.1 -

1088 -

1089 Returns true if the image format supports animation; -

1090 otherwise, false is returned. -

1091 -

1092 \sa QMovie::supportedFormats() -

1093 */ -

1094 bool QImageReader::supportsAnimation() const -

1095 { -

1096

evaluated: !d->initHandler()

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

2-53

1097

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

executed: return false;

Execution Count:2

1098

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

TRUE	FALSE
yes Evaluation Count:6	yes Evaluation Count:47

6-47

1099

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

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

Execution Count:6

1100

executed: return false;

Execution Count:47

1101 } -

1102 -

1103 /*! -

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

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

1106 data); otherwise returns false. -

1107 -

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

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

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

1111 -

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

1113 all frames have been read. -

1114 -

1115 \sa read(), supportedImageFormats() -

1116 */ -

1117 bool QImageReader::canRead() const -

1118 { -

1119

evaluated: !d->initHandler()

TRUE	FALSE
yes Evaluation Count:3	yes Evaluation Count:393

3-393

1120

return d->handler->canRead();

executed: return false;

Execution Count:3

1121 -

1122

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

Execution Count:393

393

1123 } -

1124 -

1125 /*! -

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

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

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

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

1130 -

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

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

1133 read, a null image will be returned. -

1134 -

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

1136 */ -

1137 QImage QImageReader::read() -

1138 { -

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

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

1141

QImage image;

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

1142

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

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

Execution Count:1663

1663

1143 } -

1144 -

1145 /*! -

1146 \overload -

1147 -

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

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

1150 -

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

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

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

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

1155 images with the same format and size. -

1156 -

1157 \snippet code/src_gui_image_qimagereader.cpp 2 -

1158 -

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

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

1161 be returned. -

1162 -

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

1164 */ -

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

1166 { -

1167

if (!image) {

partially evaluated: !image

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

0-1848

1168

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

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

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

1169

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

never executed: return false;

1170 } -

1171 -

1172

evaluated: !d->handler

TRUE	FALSE
yes Evaluation Count:1286	yes Evaluation Count:562

evaluated: !d->initHandler()

TRUE	FALSE
yes Evaluation Count:30	yes Evaluation Count:1256

30-1286

1173

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

executed: return false;

Execution Count:30

1174 -

1175 // set the handler specific options. -

1176

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

TRUE	FALSE
yes Evaluation Count:626	yes Evaluation Count:1192

evaluated: d->scaledSize.isValid()

TRUE	FALSE
yes Evaluation Count:24	yes Evaluation Count:602

24-1192

1177

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

1178

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

partially evaluated: d->clipRect.isNull()

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

0-24

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

1180 // if the handler also supports ClipRect. -

1181

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

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

1182

executed: }

Execution Count:24

1183

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

executed: }

Execution Count:24

1184

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

TRUE	FALSE
yes Evaluation Count:194	yes Evaluation Count:1624

evaluated: !d->clipRect.isNull()

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

1-1624

1185

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

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

Execution Count:1

1186

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

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

TRUE	FALSE
yes Evaluation Count:194	yes Evaluation Count:1624

evaluated: !d->scaledClipRect.isNull()

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

1-1624

1187

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

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

Execution Count:1

1188

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

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

TRUE	FALSE
yes Evaluation Count:626	yes Evaluation Count:1192

626-1192

1189

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

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

Execution Count:626

626

1190 -

1191 // read the image -

1192

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

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

TRUE	FALSE
yes Evaluation Count:137	yes Evaluation Count:1681

137-1681

1193

d->imageReaderError = InvalidDataError;

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

1194

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");

1195

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

executed: return false;

Execution Count:137

137

1196 } -

1197 -

1198 // provide default implementations for any unsupported image -

1199 // options -

1200

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

TRUE	FALSE
yes Evaluation Count:168	yes Evaluation Count:1513

evaluated: !d->clipRect.isNull()

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

1-1513

1201

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

1202

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

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

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

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

1204

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

never executed: }

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

1206

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

1207

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

1208

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

never executed: }

1209 } else { -

1210

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

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

1212 // likely a broken handler. -

1213

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

never executed: }

1214

partially evaluated: d->scaledSize.isValid()

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

0-1

1215

*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);

1216

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

never executed: }

1217

partially evaluated: d->scaledClipRect.isValid()

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

0-1

1218

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

1221 } -

1222 } else { -

1223

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

TRUE	FALSE
yes Evaluation Count:584	yes Evaluation Count:1096

evaluated: d->scaledSize.isValid()

TRUE	FALSE
yes Evaluation Count:15	yes Evaluation Count:569

partially evaluated: d->clipRect.isNull()

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

0-1096

1224

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

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

1226

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

executed: }

Execution Count:1

1227 // provide all workarounds. -

1228

evaluated: d->scaledClipRect.isValid()

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

1-13

1229

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

1230

executed: }

Execution Count:1

1231

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

executed: }

Execution Count:14

1232 } else { -

1233

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

TRUE	FALSE
yes Evaluation Count:156	yes Evaluation Count:1509

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

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

0-1509

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

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

1236 // can't work around it. -

1237

if (d->clipRect.isValid())

never executed: }

1238 // provide all workarounds. -

1239

evaluated: d->clipRect.isValid()

TRUE	FALSE
yes Evaluation Count:13	yes Evaluation Count:1652

13-1652

1240

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

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

Execution Count:13

1241

if (d->scaledSize.isValid())

evaluated: d->scaledSize.isValid()

TRUE	FALSE
yes Evaluation Count:40	yes Evaluation Count:1625

40-1625

1242

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

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

Execution Count:40

1243

if (d->scaledClipRect.isValid())

evaluated: d->scaledClipRect.isValid()

TRUE	FALSE
yes Evaluation Count:11	yes Evaluation Count:1654

11-1654

1244

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

Execution Count:11

1245

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

executed: }

Execution Count:1665

1665

1246 } -

1247 } -

1248 -

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

1250

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

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

0-1681

1251

image->setDevicePixelRatio(2.0);

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

1252

never executed: }

1253 -

1254

return true;

executed: return true;

Execution Count:1681

1681

1255 } -

1256 -

1257 /*! -

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

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

1260 following image in the animation. -

1261 -

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

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

1264 this operation. -

1265 -

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

1267 */ -

1268 bool QImageReader::jumpToNextImage() -

1269 { -

1270

partially evaluated: !d->initHandler()

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

0-42

1271

return d->handler->jumpToNextImage();

never executed: return false;

1272

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

Execution Count:42

1273 } -

1274 -

1275 /*! -

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

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

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

1279 -

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

1281 -

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

1283 */ -

1284 bool QImageReader::jumpToImage(int imageNumber) -

1285 { -

1286

partially evaluated: !d->initHandler()

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

0-60

1287

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

never executed: return false;

1288

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

Execution Count:60

1289 } -

1290 -

1291 /*! -

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

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

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

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

1296 -

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

1298 */ -

1299 int QImageReader::loopCount() const -

1300 { -

1301

partially evaluated: !d->initHandler()

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

0-11

1302

return d->handler->loopCount();

never executed: return -1;

1303

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

Execution Count:11

1304 } -

1305 -

1306 /*! -

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

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

1309 animation, 0 is returned. -

1310 -

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

1312 -

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

1314 */ -

1315 int QImageReader::imageCount() const -

1316 { -

1317

evaluated: !d->initHandler()

TRUE	FALSE
yes Evaluation Count:1	yes Evaluation Count:61

1-61

1318

return d->handler->imageCount();

executed: return -1;

Execution Count:1

1319

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

Execution Count:61

1320 } -

1321 -

1322 /*! -

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

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

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

1326 -

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

1328 -

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

1330 */ -

1331 int QImageReader::nextImageDelay() const -

1332 { -

1333

partially evaluated: !d->initHandler()

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

0-177

1334

return d->handler->nextImageDelay();

never executed: return -1;

1335

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

Execution Count:177

177

1336 } -

1337 -

1338 /*! -

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

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

1341 animation, 0 is returned. -

1342 -

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

1344 -

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

1346 */ -

1347 int QImageReader::currentImageNumber() const -

1348 { -

1349

never evaluated: !d->initHandler()

1350

return d->handler->currentImageNumber();

never executed: return -1;

1351

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

1352 } -

1353 -

1354 /*! -

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

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

1357 -

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

1359 */ -

1360 QRect QImageReader::currentImageRect() const -

1361 { -

1362

return d->handler->currentImageRect();

never evaluated: !d->initHandler()

1363

return QRect();

never executed: return QRect();

1364

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

1365 } -

1366 -

1367 /*! -

1368 Returns the type of error that occurred last. -

1369 -

1370 \sa ImageReaderError, errorString() -

1371 */ -

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

1373 { -

1374

return d->imageReaderError;

never executed: return d->imageReaderError;

1375 } -

1376 -

1377 /*! -

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

1379 occurred. -

1380 -

1381 \sa error() -

1382 */ -

1383 QString QImageReader::errorString() const -

1384 { -

1385

if (d->errorString.isEmpty())

partially evaluated: d->errorString.isEmpty()

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

0-240

1386

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

executed: return QLatin1String("Unknown error");

Execution Count:240

240

1387

return d->errorString;

never executed: return d->errorString;

1388 } -

1389 -

1390 /*! -

1391 \since 4.2 -

1392 -

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

1394 false. -

1395 -

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

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

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

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

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

1401 -

1402 \snippet code/src_gui_image_qimagereader.cpp 3 -

1403 -

1404 \sa QImageWriter::supportsOption() -

1405 */ -

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

1407 { -

1408

evaluated: !d->initHandler()

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

14-19

1409

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

executed: return false;

Execution Count:19

1410

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

Execution Count:14

1411 } -

1412 -

1413 /*! -

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

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

1416 */ -

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

1418 { -

1419

QFile file(fileName);

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

1420

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

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

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

0-29

1421

return QByteArray();

never executed: return QByteArray();

1422 -

1423

return imageFormat(&file);

executed: return imageFormat(&file);

Execution Count:29

1424 } -

1425 -

1426 /*! -

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

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

1429 -

1430 \sa QImageReader::autoDetectImageFormat() -

1431 */ -

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

1433 { -

1434

QByteArray format;

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

1435

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

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

1436

if (handler) {

partially evaluated: handler

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

0-29

1437

if (handler->canRead())

partially evaluated: handler->canRead()

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

0-29

1438

format = handler->format();

executed: format = handler->format();

Execution Count:29

1439

delete handler;

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

1440