C++ setLabel函数代码示例

//.........这里部分代码省略.........
		return (component = NULL);
	}

	// Get the basic component structure
	component = kernelWindowComponentNew(parent, params);
	if (!component)
		return (component);

	component->type = iconComponentType;

	// Set the functions
	component->draw = &draw;
	component->focus = &focus;
	component->setData = &setData;
	component->mouseEvent = &mouseEvent;
	component->keyEvent = &keyEvent;
	component->destroy = &destroy;

	// If default colors are requested, override the standard component colors
	// with the ones we prefer
	if (!(component->params.flags & WINDOW_COMPFLAG_CUSTOMFOREGROUND))
	{
		component->params.foreground.red = 0x28;
		component->params.foreground.green = 0x5D;
		component->params.foreground.blue = 0xAB;
		component->params.flags |= WINDOW_COMPFLAG_CUSTOMFOREGROUND;
	}
	if (!(component->params.flags & WINDOW_COMPFLAG_CUSTOMBACKGROUND))
	{
		memcpy((color *) &component->params.background, &COLOR_WHITE,
			sizeof(color));
		component->params.flags |= WINDOW_COMPFLAG_CUSTOMBACKGROUND;
	}

	// Always use our font
	component->params.font = windowVariables->font.varWidth.small.font;

	// Copy all the relevant data into our memory
	icon = kernelMalloc(sizeof(kernelWindowIcon));
	if (!icon)
	{
		kernelWindowComponentDestroy(component);
		return (component = NULL);
	}

	component->data = (void *) icon;

	// Copy the image to kernel memory
	if (kernelImageCopyToKernel(imageCopy, (image *) &icon->iconImage) < 0)
	{
		kernelWindowComponentDestroy(component);
		return (component = NULL);
	}

	// Icons use pure green as the transparency color
	icon->iconImage.transColor.blue = 0;
	icon->iconImage.transColor.green = 255;
	icon->iconImage.transColor.red = 0;

	// When the icon is selected, we do a little effect that makes the image
	// appear yellowish.
	if (kernelImageCopyToKernel(imageCopy, (image *) &icon->selectedImage) < 0)
	{
		kernelWindowComponentDestroy(component);
		return (component = NULL);
	}

	// Icons use pure green as the transparency color
	icon->selectedImage.transColor.blue = 0;
	icon->selectedImage.transColor.green = 255;
	icon->selectedImage.transColor.red = 0;

	for (count = 0; count < icon->selectedImage.pixels; count ++)
	{
		pix = &((pixel *) icon->selectedImage.data)[count];

		if (!PIXELS_EQ(pix, &icon->selectedImage.transColor))
		{
			pix->red = ((pix->red + 255) / 2);
			pix->green = ((pix->green + 255) / 2);
			pix->blue /= 2;
		}
	}

	if (component->params.font)
		setLabel(icon, label, (asciiFont *) component->params.font);

	// Now populate the main component
	component->width = max(imageCopy->width,
		((unsigned)(icon->labelWidth + 3)));
	component->height = (imageCopy->height + 5);
	if (component->params.font)
		component->height += (((asciiFont *)
			component->params.font)->glyphHeight * icon->labelLines);

	component->minWidth = component->width;
	component->minHeight = component->height;

	return (component);
}

int main(void)
{
    // seed pseudorandom number generator
    srand48(time(NULL));
 
    // instantiate window
    GWindow window = newGWindow(WIDTH, HEIGHT);
 
    // instantiate bricks
    initBricks(window);
 
    // instantiate ball, centered in middle of window
    GOval ball = initBall(window);
 
    // instantiate paddle, centered at bottom of window
    GRect paddle = initPaddle(window);
 
    // instantiate scoreboard, centered in middle of window, just above ball
    GLabel label = initScoreboard(window);
 
    // number of bricks initially
    int bricks = COLS * ROWS;
 
    // number of lives initially
    int lives = LIVES;
 
    // number of points initially
    int points = 0;
 
    // keep playing until game over
    double velocity_x = drand48() * 3;
    double velocity_y = 2.5;
     
    double x = getX(ball);
    double y = getY(ball);
    waitForClick();
    
    while (lives > 0 && bricks > 0)
    {
        GEvent event = getNextEvent(MOUSE_EVENT);
        if (event != NULL)
        
        if(getEventType(event) == MOUSE_MOVED)
        {
        double x = getX(event) - getWidth(paddle) / 2;
        double y = 500;
        setLocation(paddle, x, y);
        }
             
             
        move(ball, velocity_x, velocity_y);
        if (getY(ball) + getHeight(ball) > getHeight(window))
        {
            velocity_y = -velocity_y;
        }
        else if (getY(ball) <= 0)
        {
            velocity_y = -velocity_y;
        }
        else if (getX(ball) + getWidth(ball) > getWidth(window))
        {
            velocity_x = -velocity_x;
        }
        else if (getX(ball) <= 0)
        {
            velocity_x = -velocity_x;
        }
        
        GObject object = detectCollision(window, ball);
        if (object == paddle)
        {
          velocity_y = -velocity_y;  
        }
        
        if ((strcmp(getType(object), "GRect") == 0) && (object != paddle))    
        {
            points = points + 1;
            removeGWindow(window, object);
            velocity_y = -velocity_y;
            char s[12];
            sprintf(s, "Score: %i", points);
            setLabel(label, s);
        }
            if (points == 50)
            {
                char s[12];
                sprintf(s, "Well Done!");               
                setLabel(label, s);
                pause(10);    
                break;
            }
        
        if (getY(ball) + 95 >= getHeight(window))
        {
            lives = lives -1;
            removeGWindow(window, ball);
            waitForClick(); 
            ball = initBall(window);
            char t[12];
            sprintf(t, "Lives: %i", lives);
//.........这里部分代码省略.........

VSceneJumpEvent::VSceneJumpEvent( void ) :
        mTarget( String::EmptyString )
{
    setLabel( "SceneJumpEvent" );
}

void ofxUILabel::setFont(ofxUIFont *_font)
{
    font = _font;
    setLabel(label);
}

Axis::Axis( const Name name, const float value, const bool incremental ) : _name{ name }, _inc{ incremental }
{
	setLabel( axisName() );
	setValue( value );
}

void Altimeter::setUnit(DistanceUnit unit) {
    units = unit;
    setLabel(Units::unitName(units));
    repaintPixmap();
}

//=============================================================================
Object::Object(const char* label_in, int tracebackModeIn) : label_(0)
{
  setLabel(label_in);
  tracebackMode = (tracebackModeIn != -1) ? tracebackModeIn : tracebackMode;
}

LMPacket LMHandler::handle( 
	cv::Point2f 	borderPoints[ 3 ] 	,
	MazeData 	mazeData 		, 
	bool debugMode
	)
{

	if( debugMode )
	{

		std::cout << std::endl						;
		std::cout << "<!---------------------------------------------"	;

		std::cout << std::endl						;

		std::cout << "LMHandler.handle() called. handling..."		;
		std::cout << std::endl						;

	}

	if ( IsNull( mazeData ) )
	{

		std::cerr << "LMHandler: mazeData of type MazeData is Null"	;
		std::cerr << std::endl						;

		return LMPacketNull						;

	}

	if ( !mazeData.image.data )
	{

		std::cerr << "LMHandler: No mazeImage data!" 			;
		std::cerr << std::endl 						;

		return LMPacketNull						;

	}

	// Declare local variables
	cv::Mat 	annotatedImage				;
	cv::Mat 	processingImage				;
	cv::Point2f	startLocation				;
	cv::Point2f	endLocation				;
	cv::Point2f	ballLocation				;
	cv::Point2f	centerLocation				;
	
	cv::Point2f	criticalPoints[ 6 ]			;
	float		criticalAngles[ 6 ]			;
	float 		zeroAngle				;
	float		ballAngle				;
	int		sextantIndex				;
	float		scalingArray[ 5 ]			;
	float		normalizedBallAngle			; // our guy!

	std::vector< std::vector< cv::Point > > contours	;
	std::vector< std::vector< cv::Point > > approxContours	;
	std::vector< cv::Vec4i > hierarchy			;

	//std::vector< cv::Point > boundingTriangleVertices 	;
	int boundingTriangleIndex ;

	// Initialize local variables
	annotatedImage	= mazeData.image.clone( )		;
	startLocation	= mazeData.mazePoints[ 0 ] 		;
	endLocation	= mazeData.mazePoints[ 1 ] 		;
	ballLocation	= mazeData.mazePoints[ 2 ] 		;
	

	centerLocation = startLocation ;
	criticalPoints[ 0 ] = borderPoints[ 0 ] ; // one end of upos
	criticalPoints[ 2 ] = borderPoints[ 1 ] ; // one end of vpos
	criticalPoints[ 4 ] = borderPoints[ 2 ] ; // one end of wpos
	
	criticalPoints[ 1 ] = findMidPoint( criticalPoints[ 0 ] , criticalPoints[ 2 ] ); // one end of wneg
	criticalPoints[ 3 ] = findMidPoint( criticalPoints[ 2 ] , criticalPoints[ 4 ] ); // one end of uneg
	criticalPoints[ 5 ] = findMidPoint( criticalPoints[ 0 ] , criticalPoints[ 4 ] ); // one end of vneg

 	for ( int i = 0 ; i < 6 ; i++ )
 	{

 		std::stringstream ss;
		ss << std::to_string( i ) << std::fixed << std::setprecision( 0 ) << "(";
		ss <<  criticalPoints[ i ].x << "," << criticalPoints[ i ].y << ")";
		std::string label = ss.str();

		/*
		std::string label	;

	 	label.assign( std::to_string( i ) );
	 	label += "- ( ";
	 	label += std::to_string( criticalPoints[ i ].x ); 
	 	label += " ,  ";
	 	label += std::to_string( criticalPoints[ i ].y ); 
	 	label += " )";
		*/

 		setLabel( annotatedImage , label , criticalPoints[ i ]	)	; // start

//.........这里部分代码省略.........

VPostEffectToggleTrack::VPostEffectToggleTrack( void ) : 
        mPostEffect( NULL )
{
    setLabel( "PostEffectTrack" );
}

ToolBar::ToolBar(Slag* slag) : 
    slag(slag), 
    pattern_box(new QComboBox) 
{
    setLabel(tr("Playback controls"));

    // Play button
    QAction* play_action = new QAction(this);
    play_action->setAccel( Qt::Key_Space );
    play_action->setIconSet( QPixmap(":/icons/play.png") );
    addAction(play_action);
    connect(play_action, SIGNAL(activated()), slag,  SLOT(play()));

    // Stop button
    QAction* stop_action = new QAction(this);
    stop_action->setAccel( Qt::Key_Space );
    stop_action->setIconSet( QPixmap(":/icons/stop.png") );
    addAction(stop_action);
    connect(stop_action, SIGNAL(activated()), slag, SLOT(stop()));

    // Pattern choice box
    addSeparator();

    pattern_box->setMinimumWidth(100);
    addWidget(pattern_box);
    connect(pattern_box, SIGNAL(activated(const QString &)), 
            slag,        SLOT(patternChange(const QString &)));

    // Play mode: pattern or song
    QButtonGroup* mode_group = new QButtonGroup;
    mode_group->setExclusive(true);
    //mode_group->setLineWidth(0);
    //mode_group->setInsideMargin(2);

    pattern_mode_radio = new QRadioButton;
    pattern_mode_radio->setText(tr("Pattern"));
    mode_group->addButton(pattern_mode_radio);
    connect(pattern_mode_radio, SIGNAL(clicked()), 
            slag,               SLOT(setPatternMode()));
    addWidget(pattern_mode_radio);

    song_mode_radio = new QRadioButton;
    song_mode_radio->setText(tr("Song"));
    mode_group->addButton(song_mode_radio);
    connect(song_mode_radio, SIGNAL(clicked()), 
            slag,            SLOT(setSongMode()));
    addWidget(song_mode_radio);

    QCheckBox* loopCheckBox = new QCheckBox(tr("Loop"));
    loopCheckBox->setCheckState(Qt::Checked);
    connect(loopCheckBox, SIGNAL(stateChanged(int)), 
            slag,        SLOT(setLoopMode(int)));
    addWidget(loopCheckBox);

    // Tempo box
    addSeparator();
    
    tempoControl = new SpinSlider( 
            tr( "<font size=\"-1\">BPM:</font>" ) 
            );
    
    tempoControl->setMinimum(20);
    tempoControl->setMaximum(300);
    tempoControl->setValue(slag->song()->tempo());
    connect(tempoControl, SIGNAL(valueChanged(int)), slag, SLOT(setTempo(int)));
    addWidget(tempoControl);

    // Volume box
    volumeControl = new SpinSlider(tr( "<font size=\"-1\">Vol:</font>" ) );
    volumeControl->setValue(slag->song()->volumePercent());
    connect(volumeControl, SIGNAL(valueChanged(int)), 
            slag,    SLOT(setVolume(int)));
    addWidget(volumeControl);
}

VSceneJumpTrack::VSceneJumpTrack( void )
{
    setLabel( "SceneJumpTrack" );
}

void PlotZozMarker::setFont(const QFont Font)
{
    QwtText qwttMark(label());
    qwttMark.setFont(Font);
    setLabel(qwttMark);
}

void GLabel::setText(const std::string& str) {
    setLabel(str);
}

CLabel::CLabel (CRect &size, char *text): CParamDisplay (size)
{
	strcpy (label, "");
	setLabel (text);
}

void DlgUpdate::beginUpdateCheck() {
    progress->setMinimum(0);
    progress->setMaximum(0);
    setLabel("Checking for updates...");
    uChecker->check();
}