controlwidgetbase.cpp

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

    getButtonPix( FALSE );
    //getButtonPix( TRUE ); // delayed

    imagesScaled = TRUE;
    //qDebug("scaled %s images", skinType.latin1() ); 
}


void ControlWidgetBase::setButtonData( MediaButton *mediaButtons, int count )
{
    for (int butType = 0; butType < MaxButtonTypes; butType++) {
	buttonMap[butType] = -1;
	for (int i = 0; i < count; i++)
	    if ( mediaButtons[i].buttonType == butType )
		buttonMap[butType] = i;
    }
    buttons = mediaButtons;
    buttonCount = count;
    setSkin( skinFile );

    // Intialise state
    setLength( mediaPlayerState->length() );
    setPosition( mediaPlayerState->position() );
    setLooping( mediaPlayerState->looping() );
    setPaused( mediaPlayerState->paused() );
    setPlaying( mediaPlayerState->playing() );
    setSeekable( mediaPlayerState->seekable() );
    setFullscreen( mediaPlayerState->fullscreen() );
}


void ControlWidgetBase::setPaused( bool b )
{
    // setToggleButton( PauseButton, b );
    setToggleButton( PlayButton, !b );

#ifdef QTOPIA_PHONE
    QString text = "";
    QString pixmap;
    if (!mediaPlayerState->seeking()) {
	if (b) {
	    text = mediaPlayerState->playing() ? tr("Resume") : tr("Play");
	    pixmap = "play";
	} else {
	    text = tr("Pause");
	    pixmap = "pause";
	}
	ContextBar::setLabel( this, Key_Select, pixmap, text );
    } else {
	ContextBar::setLabel( this, Key_Select, ContextBar::NoLabel);
    }
#endif
}


void ControlWidgetBase::setLooping( bool b )
{
    setToggleButton( LoopButton, b );
}


void ControlWidgetBase::setPlaying( bool b )
{
    setToggleButton( PlayButton, b );
}


void ControlWidgetBase::setFullscreen( bool b )
{
    setToggleButton( FullscreenButton, b );
}


void ControlWidgetBase::setSeekable( bool b )
{
    slider.setEnabled( b );
    slider.setDisabled( !b );
    if ( b ) {
	slider.unsetPalette();
    } else {
	QColorGroup cg;
	for (int role = 0; role < QColorGroup::NColorRoles; role++) {
	    QColor color = slider.palette().color( QPalette::Normal, (QColorGroup::ColorRole)role );
	    cg.setColor( (QColorGroup::ColorRole)role, color.light(300) );
	}
	slider.setPalette( QPalette(cg,cg,cg) );
    }
}


void ControlWidgetBase::setToggleButton( MediaButtonType butType, bool down )
{
    int i = buttonMap[butType];
    if ( i != -1 && down != buttons[i].isDown )
	toggleButton( i );
}


void ControlWidgetBase::toggleButton( int i )
{
    buttons[i].isDown = !buttons[i].isDown;
    QPainter p( this );
    paintButton( p, i );
    drawOverlays();
}


void ControlWidgetBase::getButtonPix( bool down )
{
    if ( !mediaButtonImg[down].scaled && !mediaButtonImg[down].unscaledImg.isNull() ) {
	// QImage tmpImg = fastScale( mediaButtonImg[down], actualScaleW, actualScaleH );
	QImage tmpImg = mediaButtonImg[down].unscaledImg.smoothScale( actualScaleW, actualScaleH );
	if (!tmpImg.isNull()) {
	    QPoint pt( xoff, yoff );
	    mediaButtonImg[down].scaledPix.resize( actualScaleW, actualScaleH );
	    QPainter p;
	    p.begin( &mediaButtonImg[down].scaledPix );
	    p.drawTiledPixmap( mediaButtonImg[down].scaledPix.rect(), background.scaledPix, pt );
	    p.drawImage( mediaButtonImg[down].offset, tmpImg );
	    p.end();
	    mediaButtonImg[down].scaled = TRUE;
	    //qDebug("scaled %s buttons", skinType.latin1() );
	}
    }
}


void ControlWidgetBase::getButtonMask( int button )
{
    if ( imgButtonMask.isNull() || mediaButtonImg[0].unscaledImg.isNull() )
	return;

    if ( !mediaButtonMask[button].scaled && mediaButtonMask[button].loaded ) {
	mediaButtonMask[button].scaled = TRUE;

	if ( buttons[button].hasImage ) {
	    getButtonPix( TRUE );

	    //qDebug( "creating %s %s file", skinType.latin1(), buttons[button].skinImage );

            int srcW = mediaButtonImg[0].unscaledImg.width();
            int srcH = mediaButtonImg[0].unscaledImg.height();
            QImage tmpImg(srcW, srcH, 1, 2, QImage::BigEndian);
            tmpImg.fill(0);
	    int x1 = mediaButtonMask[button].offset.x();
	    int y1 = mediaButtonMask[button].offset.y();
            int w1 = mediaButtonMask[button].unscaledImg.width();
            int h1 = mediaButtonMask[button].unscaledImg.height();
            //### This loop ideally needs optimizing away by rolling this in to the loop below
            for (int j1 = 0; j1<h1 && j1+y1<srcH; j1++)
                for (int i1 = 0; i1<w1 && i1+x1<srcW; i1++)
                      tmpImg.setPixel(i1+x1,j1+y1,mediaButtonMask[button].unscaledImg.pixelIndex(i1,j1));

	    int w = actualScaleW;
	    int h = actualScaleH;
	    int iw = srcW;
	    int ih = srcH;
	    int dx = iw * 65535 / w;
	    int dy = ih * 65535 / h;
	    uchar **src = tmpImg.jumpTable();
	    uchar **dest = imgButtonMask.jumpTable();
            uchar bits[(((w+8)*(h+1))/8)+32]; // over allocate just to be safe
	    uchar *dst = bits - 1;
	    for ( int j = 0, y = 0; j < h; j++, y+=dy ) {
		uchar *srcLine = src[y>>16];
		uchar *line = dest[j];
		for ( int i = 0, x = 0, bit = 8; i < w; i++, x+=dx, bit++ ) {
		    int srcBit = 7 - ((x>>16) % 8);
		    int srcOfs = (x>>16) / 8;
		    uint pixel = srcLine[ srcOfs ] & (1 << srcBit);
		    if ( bit == 8 ) {
			bit = 0;
                        *(++dst) = 0;
		    }
		    if ( pixel ) {
			line[i] = button + 1;
			*dst |= 1 << bit;
		    }
		}
	    }

	    mediaButtonMask[button].scaledPix = QBitmap( w, h, bits, TRUE );
	}
    }
}


void ControlWidgetBase::paintButton( QPainter& p, int button )
{
    if ( !canPaint || !imagesLoaded || !imagesScaled || !buttons[button].hasImage )
	return;
    getButtonMask(button);
    bool down = buttons[button].isDown; 
    if ( !mediaButtonMask[button].scaledPix.isNull() && mediaButtonMask[button].scaledPix.isQBitmap() )
        mediaButtonImg[down].scaledPix.setMask( *(QBitmap*)&mediaButtonMask[button].scaledPix );
    if ( !mediaButtonImg[down].scaledPix.isNull() )
        p.drawPixmap( xoff, yoff, mediaButtonImg[down].scaledPix );
}


void ControlWidgetBase::drawOverlays()
{
    if ( drawVolume )
	drawVolumeOverlay(true);
}


void ControlWidgetBase::updateVolume()
{
    // Display an on-screen display volume
    if ( drawVolume == true )
	hideVolumeOverlay();
    drawVolume = true;
    drawVolumeOverlay(false);
    volumeTimeout.start(1000, true);
}


void ControlWidgetBase::drawVolumeOverlay(bool inPaintEvent)
{
    const int volYOff = 90;

    int w = width();
    int h = height();

    int vW = w * 90 / 100;
    int mW = vW / 10;
    int mH = mW * 3 / 2;
    int tickWidth = mW / 2;

    QPainter p(this);
    p.setPen( QColor( 0x10, 0xD0, 0x10 ) );
    p.setBrush( QColor( 0x10, 0xD0, 0x10 ) );

    QFont f;
    f.setPixelSize( mW );
    f.setBold( TRUE );
    p.setFont( f );
    p.drawText( (w - vW) / 2, h - volYOff + 20 - mH, tr("Volume") );

    int l, r;
    AudioDevice::volume(l, r);
    int newVolume = ((l + r) * 11) / (2*0x10000);
    for ( int i = 0; i < 10; i++ ) {
	if ( newVolume > i ) {
	    p.drawRect( (w - vW) / 2 + i * mW + 10, h - volYOff + 40 - mH, tickWidth, mH );
	} else {
	    if ( i + 1 == drawnVolume && !inPaintEvent )
		repaint( (w - vW) / 2 + i * mW + 10, h - volYOff + 40 - mH, tickWidth, mH );
	    p.drawRect( (w - vW) / 2 + i * mW + 13, h - volYOff + 40 - mH + mW/2, tickWidth / 2, mH - mW );
	}
    }
    drawnVolume = newVolume;

    if ( AudioDevice::muted() ) {
	f.setPixelSize( mH );
	p.setFont( f );
	p.setPen( QColor( 0xD0, 0x10, 0x10 ) );
	p.drawText( (w - vW) / 2 + 10, h - volYOff + 40 - mH, 
	    10*mW + tickWidth, mH, AlignHCenter | AlignVCenter, tr("Muted") );
    }
}


void ControlWidgetBase::hideVolumeOverlay()
{
    if ( drawVolume == false )
	return;
    drawVolume = false;
    drawnVolume = -1;
    // Get rid of the on-screen display stuff
    repaint(background.scaledPix.isNull());
}


void ControlWidgetBase::paintAllButtons( QPainter& p )
{
    // Get something there quick, effectively paints all buttons up
    if ( !mediaButtonImg[0].scaledPix.isNull() ) {
	mediaButtonImg[0].scaledPix.setMask( QBitmap() );
        p.drawPixmap( xoff, yoff, mediaButtonImg[0].scaledPix );
    }

    canPaint = TRUE;

    // Paint any down buttons
    for ( int i = 0; i < buttonCount; i++ ) {
	getButtonMask( i );
	if ( buttons[i].isDown ) 
	    paintButton( p, i );
    }
}


void ControlWidgetBase::sliderPressed()
{
    mediaPlayerState->setSeeking( true );
    sliderBeingMoved = TRUE;
}


void ControlWidgetBase::sliderReleased()
{
    if ( sliderBeingMoved ) {
	sliderBeingMoved = FALSE;
	if ( slider.width() == 0 )
	    return;
	// Use double precision to avoid integer overflows which can happen easily otherwise
	long val = long((double)slider.value() * mediaPlayerState->length() / slider.width());
	mediaPlayerState->setPosition( val );
	mediaPlayerState->setSeeking( false );
    }
}


void ControlWidgetBase::setPosition( long )
{
    virtualUpdateSlider();
}


void ControlWidgetBase::setLength( long )
{
    virtualUpdateSlider();
}


QString ControlWidgetBase::toTimeString( long length )
{
    int minutes = length / 60;
    int seconds = length % 60;
    return QString("%1:%2%3").arg( minutes ).arg( seconds / 10 ).arg( seconds % 10 );
}


QString ControlWidgetBase::timeAsString( long length )
{
    if ( mediaPlayerState->decoder() ) {
	if ( mediaPlayerState->decoder()->videoStreams() > 0 ) {
	    double frameRate = mediaPlayerState->decoder()->videoFrameRate( 0 );
	    if ( frameRate == 0.0 )
		frameRate = 1.0;
	    length = long((double)length / frameRate);
	} else {
	    int freq = mediaPlayerState->decoder()->audioFrequency( 0 );
	    if ( freq )
		length /= freq;
	}
    }
    return toTimeString( length );
}

 
void ControlWidgetBase::updateSlider()
{
    int i = mediaPlayerState->position();
    int max = mediaPlayerState->length();

    QString currentTime;
    QString totalTime;

    // Work out currentTime and totalTime strings
    if ( mediaPlayerState->decoderVersion() == Decoder_1_6 ) {
	MediaPlayerDecoder_1_6 *decoder = (MediaPlayerDecoder_1_6 *)mediaPlayerState->decoder();
	if ( decoder->currentTimeAvailable() ) 
	    currentTime = toTimeString( decoder->currentTime() / 1000 );
	else
	    currentTime = "?:??";
	if ( decoder->totalTimeAvailable() )
	    totalTime = " / " + toTimeString( decoder->totalTime() / 1000 );
    } else {
	currentTime = timeAsString( i );
	if ( max > 1 )
	    totalTime = " / " + timeAsString( max );
    }

    QString text = currentTime + totalTime;
    if ( text.length() > 12 )
        time.setText( currentTime );
    else
        time.setText( text );

    if ( max == 0 )
	return;

    // Will flicker too much if we don't do this.
    // Scale position to the pixel along the slider.
    int width = slider.width();
    int val = int((double)i * width / max);
    if ( !sliderBeingMoved ) {
	if ( slider.value() != val )
	    slider.setValue( val );
	if ( slider.maxValue() != width )
	    slider.setMaxValue( width );
    }
}


void ControlWidgetBase::stop()
{
    mediaPlayerState->setPlaying( false );
    setPosition( 0 );
    slider.setValue( 0 );
}


void ControlWidgetBase::play()
{
    if ( mediaPlayerState->playing() )
	mediaPlayerState->togglePaused();
    else
	mediaPlayerState->setPlaying( true );
}


void ControlWidgetBase::mouseMoveEvent( QMouseEvent *event )
{
    if ( imgButtonMask.isNull() )
	return;

    for ( int i = 0; i < buttonCount; i++ ) {
	if ( buttons[i].hasImage ) {
	    if ( event->state() == QMouseEvent::LeftButton ) {

		// The test to see if the mouse click is inside the button or not
		int x = event->pos().x() - xoff;
		int y = event->pos().y() - yoff;

		bool isOnButton = ( x > 0 && y > 0 && x < imgButtonMask.width()
		    && y < imgButtonMask.height() && imgButtonMask.pixelIndex( x, y ) == i + 1 );

		if ( isOnButton && !buttons[i].isHeld ) {
		    buttons[i].isHeld = TRUE;
		    toggleButton(i);
		    switch ( buttons[i].buttonType ) {
			case VolumeUpButton:	    emit moreClicked(); return;
			case VolumeDownButton:	    emit lessClicked(); return;
			case ForwardButton:	    emit forwardClicked(); return;
			case BackwardButton:	    emit backwardClicked(); return;
			default: break;
		    }
		} else if ( !isOnButton && buttons[i].isHeld ) {
		    buttons[i].isHeld = FALSE;
		    toggleButton(i);
		    switch ( buttons[i].buttonType ) {
			case VolumeUpButton:	    emit moreReleased(); return;
			case VolumeDownButton:	    emit lessReleased(); return;
			case ForwardButton:	    emit forwardReleased(); return;
			case BackwardButton:	    emit backwardReleased(); return;
			default: break;
		    }
		}
	    } else {
		if ( buttons[i].isHeld ) {
		    buttons[i].isHeld = FALSE;
		    if ( !buttons[i].isToggle && buttons[i].isDown )
			toggleButton( i );
		    switch ( buttons[i].buttonType ) {
			case PlayButton:	    play(); return;
			case StopButton:	    stop(); return;
			case PauseButton:	    mediaPlayerState->setPaused( buttons[i].isDown ); return;
			case NextButton:	    mediaPlayerState->setNext(); return;
			case PreviousButton:	    mediaPlayerState->setPrev(); return;
			case LoopButton:	    mediaPlayerState->setLooping( buttons[i].isDown ); return;
			case VolumeUpButton:	    emit moreReleased(); return;
			case VolumeDownButton:	    emit lessReleased(); return;
			case ForwardButton:	    emit forwardReleased(); return;
			case BackwardButton:	    emit backwardReleased(); return;
			case PlayListButton:	    mediaPlayerState->setList();  return;
			//case FullscreenButton:	mediaPlayerState->setFullscreen( TRUE ); makeVisible(); return;
			default: break;
		    }
		}
	    }
	}
    }
}


void ControlWidgetBase::mousePressEvent( QMouseEvent *event )
{
    mouseMoveEvent( event );
}


void ControlWidgetBase::mouseReleaseEvent( QMouseEvent *event )
{
    mouseMoveEvent( event );
}


void ControlWidgetBase::closeEvent( QCloseEvent* )
{
    mediaPlayerState->closeView();
}