showimg.cpp

Trolltech公司发布的图形界面操作系统。可在qt-embedded-2.3.10平台上编译为嵌入式图形界面操作系统。

	imagePanel->statusLabel()->setText( tr("Loading image...") );
	qApp->processEvents();

	QString	param;
	QImageIO iio;

	iio.setFileName(filename);

	iio.setParameters("GetHeaderInformation");
	if (iio.read() == FALSE) {
	    image.reset();
	    imagePanel->statusLabel()->setText(tr("Image load failed"));
	    imagePanel->setPixmap(QPixmap());

	    return;
	}

	imagewidth = iio.image().width();
	imageheight = iio.image().height();
	if ( !iio.image().bits() ) {
	    // GetHeaderInformation is supported

	    //
	    // Don't scale if we don't have to.
	    //
	    if (!smallScale &&
		    imagewidth < qApp->desktop()->width() &&
		    imageheight < qApp->desktop()->height()) {
		param.sprintf("%s", fastLoad ? "Fast" : ""); // No tr
	    } else {
		int maxsize = QMAX(qApp->desktop()->width(),
		    qApp->desktop()->height());

		//
		// Scale the image.  If we're loading fast, use the
		// shrink parameter to help out.
		//
		param.sprintf("Scale( %i, %i, %s ), %s, Shrink( %i )", // No tr
		    maxsize, maxsize, "ScaleMin",
		    fastLoad ? ", Fast" : "", // No tr
		    fastLoad ? QMAX(imagewidth/maxsize, imageheight/maxsize):1);

	    }
	    iio.setParameters(param);
	    iio.read();
	}
	image = iio.image();

	matrix.reset();
	rotated90 = FALSE;

	//
	// Don't rotate if the image is square.
	//
	if (imageheight != imagewidth) {
	    bool portraitDisplay = imagePanel->height() > imagePanel->width();
	    bool portraitImage = imageheight > imagewidth;
	
	    if (rot != rotate_none && portraitImage != portraitDisplay ) {
		rotated90 = TRUE;
		if ( rot == rotate_clockwise )
		    matrix.rotate( 90.0 );
		else
		    matrix.rotate( -90.0 );
	    }
	}
	scale( TRUE );
    } else {
	image.reset();
    }
}

void ImageViewer::setControls()
{
    bool validPicture = !image.isNull() && stack->visibleWidget() == imagePanel;
    propAction->setEnabled(validPicture);
    rotateAction->setEnabled(validPicture);
    flipAction->setEnabled(validPicture);
    fullscreenAction->setEnabled(validPicture);

    bool multipleImages = imageList.count() > 1;
    slideAction->setEnabled(multipleImages);
    prevImageAction->setEnabled(validPicture && multipleImages);
    nextImageAction->setEnabled(validPicture && multipleImages);

    if (edit) {
	edit->setItemEnabled(hflip_id, validPicture);
	edit->setItemEnabled(vflip_id, validPicture);
    }
}

bool ImageViewer::loadSelected()
{
    if ( stack->visibleWidget() == fileSelector ) {
	DocLnk link = fileSelector->selectedDocument();
	if ( link.fileKnown() ) {
	    delete doc;
	    doc = new DocLnk(link);

	    openFile( link.name(), link.file() );
	    filename = link.file();
	    return true;
	}
    }
    if ( !image.isNull() ) {
	closeFileSelector();
	return true;
    }
    return false;
}

int ImageViewer::h()
{
    if ( !isFullScreen)
#ifndef QTOPIA_PHONE
	 return  height() - menubar->heightForWidth( width() )
		    - imagePanel->statusLabel()->height();
#else
	 return  height() - imagePanel->statusLabel()->height();
#endif
    else
         return qApp->desktop()->height();
}


const QPixmap &ImageViewer::scaledPixmap( bool newImage )
{
    Q_UNUSED( newImage );

    int	sw = 0;
    int	sh = 0;

    if (!image.isNull()) {
	//
	// Leaves dimensions as they are if we're not scaling.
	//
	if (!smallScale &&
		image.width() < imagePanel->width() &&
		image.height() < h()) {
	    sw = image.width();
	    sh = image.height();
	} else {
	    //
	    // Setup scaling first.
	    //
	    sw = rotated90 ? h() : imagePanel->width();
	    sh = rotated90 ? imagePanel->width() : h();

	    int t1 = image.width() * sh;
	    int t2 = image.height() * sw;

	    if (t1 > t2) {
		sh = t2 / image.width();
	    } else {
		sw = t1 / image.height();
	    }
	}
    }

    //
    // Scale (and rotate, if required).
    //
    if ( rotated90 ) {
	if ( needPmScaled90 ) {
	    needPmScaled90 = FALSE;
	    if ( !pmScaled90.convertFromImage( image.smoothScale( sw, sh ) ) )
		pmScaled90.resize( 0, 0 );
	}
	return pmScaled = pmScaled90.xForm( matrix );
    } else {
	if ( needPmScaled0 ) {
	    needPmScaled0 = FALSE;
	    if ( !pmScaled0.convertFromImage( image.smoothScale( sw, sh ) ) )
		pmScaled0.resize( 0, 0 );
	}
	return pmScaled = pmScaled0.xForm( matrix );
    }
}


/*
  This functions scales the image to fit the widget size
*/
void ImageViewer::scale( bool newImage )
{
    if ( !image.isNull() ) {
	needPmScaled0 = TRUE;
	needPmScaled90 = TRUE;
	imagePanel->setPixmap( scaledPixmap( newImage ) );
	updateStatus();
    }
}

/*
  If a valid image was loaded it will be scaled to fit the new widget size
*/
void ImageViewer::resizeEvent( QResizeEvent * )
{
    QLabel *status = imagePanel->statusLabel();
    status->setGeometry( 0, height() - status->height(), width(),
	status->height() );

    if ( image.isNull() )		// there is no image loaded
	return;

    if ( image.hasAlphaBuffer() )
	erase();

    // if different size, scale pmScaled to new widget size
    if ( width() != imagePanel->w() || h() != imagePanel->h() )
	scale( FALSE );
}

void ImageViewer::setScaledImage()
{
    if ( loadSelected() ) {
	imagePanel->setPixmap( scaledPixmap( FALSE ) );
	updateStatus();
    }
}

void ImageViewer::hFlip()
{
    matrix.scale( -1.0, 1.0 );
    setScaledImage();
}

void ImageViewer::vFlip()
{
    matrix.scale( 1.0, -1.0 );
    setScaledImage();
}

void ImageViewer::rot180()
{
    matrix.rotate( 180.0 );
    setScaledImage();
}

void ImageViewer::rot90()
{
    rotated90 = !rotated90;
    matrix.rotate( -90.0 );
    setScaledImage();
}

void ImageViewer::rot270()
{
    rotated90 = !rotated90;
    matrix.rotate(90.0);
    setScaledImage();
}

void ImageViewer::toggleFullscreen()
{
    if ( isFullScreen )
	normalView();
    else
	fullScreen();
}

void ImageViewer::normalView()
{
    if ( bFromDocView || !imagePanel->parentWidget() ) {
	isFullScreen = FALSE;
	stack->addWidget( imagePanel, 1 );
	scale( FALSE );
	imagePanel->showStatus();
	stack->raiseWidget( imagePanel );
    }
}

void ImageViewer::fullScreen()
{
    // Full-screen and rotation options
    // contributed by Robert Wittams <[e-mail]>
    if ( imagePanel->parentWidget() && loadSelected() ) {
	isFullScreen = TRUE;
	imagePanel->reparent(0,QPoint(0,0));
	imagePanel->resize(qApp->desktop()->width(), qApp->desktop()->height());
	imagePanel->hideStatus();
	scale( FALSE );
	imagePanel->showFullScreen();
    }
}

void ImageViewer::slideShow( bool on )
{
    if (on) {
	if (!imageList.isEmpty()) {
	    slideTimer->start(slideDelay * 1000, FALSE);
	    filename = "";		// force restart
	    slideReverse ? prevImage() : nextImage();
	}
    } else {
	slideTimer->stop();
    }
}

void ImageViewer::slideUpdate()
{
    bool final_image = slideReverse ? prevImage() : nextImage();

    if (final_image && !slideRepeat) {
	slideTimer->stop();
	slideAction->setOn(FALSE);
    }
}

void ImageViewer::updateStatus()
{
    if ( image.isNull() ) {
	if ( filename )
	    imagePanel->statusLabel()->setText( tr("Could not load image") );
	else
	    imagePanel->statusLabel()->setText( tr("No image - select Open "
		"from File menu.") );
    } else {
	QString message("%1x%2");
	message = message.arg(imagewidth).arg(imageheight);
	if ( imagewidth != imagePanel->w() || imageheight != imagePanel->h() )
	    message += QString(" [%1x%2]").arg(imagePanel->w()).arg(imagePanel->h());
	if ( image.numColors() > 0 ) {
	    message += tr(", %1 colors").arg(image.numColors());
	} else if ( image.depth() >= 16 ) {
	    message += tr(" True color");
	}
	if ( image.hasAlphaBuffer() ) {
	    if ( image.depth() == 8 ) {
		int i;
		bool alpha[256];
		int nalpha=0;

		for (i=0; i<256; i++)
		    alpha[i] = FALSE;

		for (i=0; i<image.numColors(); i++) {
		    int alevel = image.color(i) >> 24;
		    if (!alpha[alevel]) {
			alpha[alevel] = TRUE;
			nalpha++;
		    }
		}
		message += tr(", %1 alpha levels").arg(nalpha);
	    } else {
		// Too many pixels to bother counting.
		message += tr(", 8-bit alpha channel");
	    }
	}
	imagePanel->statusLabel()->setText(message);
    }
}

//
// Return the index into the imageList of the currently viewed
// image (ie. ImageViewer::filename in ImageViewer::imageList).
//
int
ImageViewer::imageIndex(void)
{
    QValueListConstIterator<DocLnk> i;
    int	index;

    if (imageList.count() == 0) {
	return -1;
    }

    for (index = 0, i = imageList.begin(); i != imageList.end(); ++i, index++) {
	if ((*i).file() == filename) {
	    return index;
	}
    }

    return -1;
}

//
// Display the image after the current one in the image list.
// Return TRUE if the next call to nextImage() will wrap around to the
// first image in the list (ie. we're now viewing the last image in the list).
//
bool
ImageViewer::nextImage(void)
{
    int	idx = 0;

    if (imageList.count() > 0) {
	idx = imageIndex();
	if (idx != -1) {
	    if (idx == int(imageList.count() - 1)) {
		idx = 0;
	    } else {
		idx++;
	    }
	} else {
	    idx = 0;
	}
	openFile(imageList[idx]);
    }

    return idx == int(imageList.count() - 1) ? TRUE : FALSE;
}

//
// Display the image preceeding the current one in the image list.
// Return TRUE if the next call to prevImage() will wrap around to the last
// image in the list (ie. we're now viewing the first image in the list).
//
bool
ImageViewer::prevImage(void)
{
    int idx = -1;

    if (imageList.count() > 0) {
	idx = imageIndex();
	if (idx != -1) {
	    if (idx == 0) {
		idx = imageList.count() - 1;
	    } else {
		idx--;
	    }
	} else {
	    idx = imageList.count() - 1;
	}
	openFile(imageList[idx]);
    }

    return idx == 0 ? TRUE : FALSE;
}

#ifdef QT_KEYPAD_MODE
void
ImageViewer::keyPressEvent(QKeyEvent *e)
{
    QMainWindow::keyPressEvent(e);
    if (!e->isAccepted()) {
	if ((e->key() != Key_Back && e->key() != Key_No) || stack->visibleWidget() != fileSelector) {
	    e->accept();
	    emit keypress(e->key());
	}
    }
}
#endif

void
ImageViewer::handleKeypress(int keycode)
{
    if ( stack->visibleWidget() == fileSelector )
	return;

    switch (keycode) {
    case Qt::Key_Right:
	nextImage();
	break;

    case Qt::Key_Left:
	prevImage();
	break;

    case Qt::Key_Up:
	rot270();
	break;

    case Qt::Key_Down:
	rot90();
	break;

    case Qt::Key_Escape:
#ifdef QT_KEYPAD_MODE
    case Qt::Key_Select:
#endif	// QT_KEYPAD_MODE
	if (isFullScreen) {
	    normalView();
	}
	break;


#ifdef QT_KEYPAD_MODE
    case Qt::Key_No:
    case Qt::Key_Back:
#endif
    case Qt::Key_Space:
	if (isFullScreen) {
	    normalView();
	} else {
	    if (bFromDocView) {
		close();
	    } else {
		open();
	    }
	}
	break;
    }
}