You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tqt3/src/widgets/qlabel.cpp

1192 lines
30 KiB

/**********************************************************************
**
** Implementation of TQLabel widget class
**
** Created : 941215
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of the widgets module of the TQt GUI Toolkit.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
** Software Foundation and appearing in the files LICENSE.GPL2
** and LICENSE.GPL3 included in the packaging of this file.
** Alternatively you may (at your option) use any later version
** of the GNU General Public License if such license has been
** publicly approved by Trolltech ASA (or its successors, if any)
** and the KDE Free TQt Foundation.
**
** Please review the following information to ensure GNU General
** Public Licensing requirements will be met:
** http://trolltech.com/products/qt/licenses/licensing/opensource/.
** If you are unsure which license is appropriate for your use, please
** review the following information:
** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
** or contact the sales department at sales@trolltech.com.
**
** This file may be used under the terms of the Q Public License as
** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
** included in the packaging of this file. Licensees holding valid TQt
** Commercial licenses may use this file in accordance with the TQt
** Commercial License Agreement provided with the Software.
**
** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
** herein.
**
**********************************************************************/
#include "ntqlabel.h"
#ifndef TQT_NO_LABEL
#include "ntqpainter.h"
#include "ntqdrawutil.h"
#include "ntqaccel.h"
#include "ntqmovie.h"
#include "ntqimage.h"
#include "ntqbitmap.h"
#include "ntqpicture.h"
#include "ntqapplication.h"
#include "ntqsimplerichtext.h"
#include "ntqstylesheet.h"
#include "ntqstyle.h"
class TQLabelPrivate
{
public:
TQLabelPrivate()
:img(0), pix(0), valid_hints( -1 )
{}
TQImage* img; // for scaled contents
TQPixmap* pix; // for scaled contents
TQSize sh;
TQSize msh;
int valid_hints; // stores the frameWidth() for the stored size hint, -1 otherwise
};
/*!
\class TQLabel ntqlabel.h
\brief The TQLabel widget provides a text or image display.
\ingroup basic
\ingroup text
\mainclass
TQLabel is used for displaying text or an image. No user
interaction functionality is provided. The visual appearance of
the label can be configured in various ways, and it can be used
for specifying a focus accelerator key for another widget.
A TQLabel can contain any of the following content types:
\table
\header \i Content \i Setting
\row \i Plain text
\i Pass a TQString to setText().
\row \i Rich text
\i Pass a TQString that contains rich text to setText().
\row \i A pixmap
\i Pass a TQPixmap to setPixmap().
\row \i A movie
\i Pass a TQMovie to setMovie().
\row \i A number
\i Pass an \e int or a \e double to setNum(), which converts
the number to plain text.
\row \i Nothing
\i The same as an empty plain text. This is the default. Set
by clear().
\endtable
When the content is changed using any of these functions, any
previous content is cleared.
The look of a TQLabel can be tuned in several ways. All the
settings of TQFrame are available for specifying a widget frame.
The positioning of the content within the TQLabel widget area can
be tuned with setAlignment() and setIndent(). For example, this
code sets up a sunken panel with a two-line text in the bottom
right corner (both lines being flush with the right side of the
label):
\code
TQLabel *label = new TQLabel( this );
label->setFrameStyle( TQFrame::Panel | TQFrame::Sunken );
label->setText( "first line\nsecond line" );
label->setAlignment( AlignBottom | AlignRight );
\endcode
A TQLabel is often used as a label for an interactive widget. For
this use TQLabel provides a useful mechanism for adding an
accelerator key (see TQAccel) that will set the keyboard focus to
the other widget (called the TQLabel's "buddy"). For example:
\code
TQLineEdit* phoneEdit = new TQLineEdit( this, "phoneEdit" );
TQLabel* phoneLabel = new TQLabel( phoneEdit, "&Phone:", this, "phoneLabel" );
\endcode
In this example, keyboard focus is transferred to the label's
buddy (the TQLineEdit) when the user presses Alt+P. You can
also use the setBuddy() function to accomplish the same thing.
<img src=qlabel-m.png> <img src=qlabel-w.png>
\sa TQLineEdit, TQTextEdit, TQPixmap, TQMovie,
\link guibooks.html#fowler GUI Design Handbook: Label\endlink
*/
/*!
\fn TQPicture * TQLabel::picture() const
Returns the label's picture or 0 if the label doesn't have a
picture.
*/
/*!
Constructs an empty label.
The \a parent, \a name and widget flag \a f, arguments are passed
to the TQFrame constructor.
\sa setAlignment(), setFrameStyle(), setIndent()
*/
TQLabel::TQLabel( TQWidget *parent, const char *name, WFlags f )
: TQFrame( parent, name, f | WMouseNoMask )
{
init();
}
/*!
Constructs a label that displays the text, \a text.
The \a parent, \a name and widget flag \a f, arguments are passed
to the TQFrame constructor.
\sa setText(), setAlignment(), setFrameStyle(), setIndent()
*/
TQLabel::TQLabel( const TQString &text, TQWidget *parent, const char *name,
WFlags f )
: TQFrame( parent, name, f | WMouseNoMask )
{
init();
setText( text );
}
/*!
Constructs a label that displays the text \a text. The label has a
buddy widget, \a buddy.
If the \a text contains an underlined letter (a letter preceded by
an ampersand, \&), and the text is in plain text format, when the
user presses Alt+ the underlined letter, focus is passed to the
buddy widget.
The \a parent, \a name and widget flag, \a f, arguments are passed
to the TQFrame constructor.
\sa setText(), setBuddy(), setAlignment(), setFrameStyle(),
setIndent()
*/
TQLabel::TQLabel( TQWidget *buddy, const TQString &text,
TQWidget *parent, const char *name, WFlags f )
: TQFrame( parent, name, f | WMouseNoMask )
{
init();
#ifndef TQT_NO_ACCEL
setBuddy( buddy );
#endif
setText( text );
}
/*!
Destroys the label.
*/
TQLabel::~TQLabel()
{
clearContents();
delete d;
}
void TQLabel::init()
{
lpixmap = 0;
#ifndef TQT_NO_MOVIE
lmovie = 0;
#endif
#ifndef TQT_NO_ACCEL
lbuddy = 0;
accel = 0;
#endif
lpixmap = 0;
#ifndef TQT_NO_PICTURE
lpicture = 0;
#endif
align = AlignAuto | AlignVCenter | ExpandTabs;
extraMargin = -1;
autoresize = FALSE;
scaledcontents = FALSE;
textformat = TQt::AutoText;
#ifndef TQT_NO_RICHTEXT
doc = 0;
#endif
setSizePolicy( TQSizePolicy( TQSizePolicy::Preferred, TQSizePolicy::Preferred ) );
d = new TQLabelPrivate;
}
/*!
\property TQLabel::text
\brief the label's text
If no text has been set this will return an empty string. Setting
the text clears any previous content, unless they are the same.
The text will be interpreted either as a plain text or as a rich
text, depending on the text format setting; see setTextFormat().
The default setting is \c AutoText, i.e. TQLabel will try to
auto-detect the format of the text set.
If the text is interpreted as a plain text and a buddy has been
set, the buddy accelerator key is updated from the new text.
The label resizes itself if auto-resizing is enabled.
Note that Qlabel is well-suited to display small rich text
documents, i.e. those small documents that get their document
specific settings (font, text color, link color) from the label's
palette and font properties. For large documents, use TQTextEdit
in read-only mode instead. TQTextEdit will flicker less on resize
and can also provide a scrollbar when necessary.
\sa text, setTextFormat(), setBuddy(), alignment
*/
void TQLabel::setText( const TQString &text )
{
if ( ltext == text )
return;
TQSize osh = sizeHint();
#ifndef TQT_NO_RICHTEXT
bool hadRichtext = doc != 0;
#endif
clearContents();
ltext = text;
#ifndef TQT_NO_RICHTEXT
bool useRichText = (textformat == RichText ||
( ( textformat == AutoText ) && TQStyleSheet::mightBeRichText(ltext) ) );
#else
bool useRichText = TRUE;
#endif
#ifndef TQT_NO_ACCEL
// ### Setting accelerators for rich text labels will not work.
// Eg. <b>&gt;Hello</b> will return ALT+G which is clearly
// not intended.
if ( !useRichText ) {
int p = TQAccel::shortcutKey( ltext );
if ( p ) {
if ( !accel )
accel = new TQAccel( this, "accel label accel" );
accel->connectItem( accel->insertItem( p ),
this, SLOT(acceleratorSlot()) );
}
}
#endif
#ifndef TQT_NO_RICHTEXT
if ( useRichText ) {
if ( !hadRichtext )
align |= WordBreak;
TQString t = ltext;
if ( align & AlignRight )
t.prepend( "<div align=\"right\">");
else if ( align & AlignHCenter )
t.prepend( "<div align=\"center\">");
if ( (align & WordBreak) == 0 )
t.prepend( "<nobr>" );
doc = new TQSimpleRichText( t, font() );
}
#endif
updateLabel( osh );
}
/*!
Clears any label contents. Equivalent to setText( "" ).
*/
void TQLabel::clear()
{
setText( TQString::fromLatin1("") );
}
/*!
\property TQLabel::pixmap
\brief the label's pixmap
If no pixmap has been set this will return an invalid pixmap.
Setting the pixmap clears any previous content, and resizes the
label if \l TQLabel::autoResize() is TRUE. The buddy accelerator,
if any, is disabled.
*/
void TQLabel::setPixmap( const TQPixmap &pixmap )
{
TQSize osh = sizeHint();
if ( !lpixmap || lpixmap->serialNumber() != pixmap.serialNumber() ) {
clearContents();
lpixmap = new TQPixmap( pixmap );
}
if ( lpixmap->depth() == 1 && !lpixmap->mask() )
lpixmap->setMask( *((TQBitmap *)lpixmap) );
updateLabel( osh );
}
#ifndef TQT_NO_PICTURE
/*!
Sets the label contents to \a picture. Any previous content is
cleared.
The buddy accelerator, if any, is disabled.
\sa picture(), setBuddy()
*/
void TQLabel::setPicture( const TQPicture &picture )
{
TQSize osh = sizeHint();
clearContents();
lpicture = new TQPicture( picture );
updateLabel( osh );
}
#endif // TQT_NO_PICTURE
/*!
Sets the label contents to plain text containing the textual
representation of integer \a num. Any previous content is cleared.
Does nothing if the integer's string representation is the same as
the current contents of the label.
The buddy accelerator, if any, is disabled.
The label resizes itself if auto-resizing is enabled.
\sa setText(), TQString::setNum(), setBuddy()
*/
void TQLabel::setNum( int num )
{
TQString str;
str.setNum( num );
setText( str );
}
/*!
\overload
Sets the label contents to plain text containing the textual
representation of double \a num. Any previous content is cleared.
Does nothing if the double's string representation is the same as
the current contents of the label.
The buddy accelerator, if any, is disabled.
The label resizes itself if auto-resizing is enabled.
\sa setText(), TQString::setNum(), setBuddy()
*/
void TQLabel::setNum( double num )
{
TQString str;
str.setNum( num );
setText( str );
}
/*!
\property TQLabel::alignment
\brief the alignment of the label's contents
The alignment is a bitwise OR of \c TQt::AlignmentFlags and \c
TQt::TextFlags values. The \c ExpandTabs, \c SingleLine and \c
ShowPrefix flags apply only if the label contains plain text;
otherwise they are ignored. The \c DontClip flag is always
ignored. \c WordBreak applies to both rich text and plain text
labels. The \c BreakAnywhere flag is not supported in TQLabel.
If the label has a buddy, the \c ShowPrefix flag is forced to
TRUE.
The default alignment is \c{AlignAuto | AlignVCenter | ExpandTabs}
if the label doesn't have a buddy and \c{AlignAuto | AlignVCenter
| ExpandTabs | ShowPrefix} if the label has a buddy. If the label
contains rich text, additionally \c WordBreak is turned on.
\sa TQt::AlignmentFlags, alignment, setBuddy(), text
*/
void TQLabel::setAlignment( int alignment )
{
if ( alignment == align )
return;
TQSize osh = sizeHint();
#ifndef TQT_NO_ACCEL
if ( lbuddy )
align = alignment | ShowPrefix;
else
#endif
align = alignment;
#ifndef TQT_NO_RICHTEXT
TQString t = ltext;
if ( !t.isNull() ) {
ltext = TQString::null;
setText( t );
}
#endif
updateLabel( osh );
}
/*!
\property TQLabel::indent
\brief the label's text indent in pixels
If a label displays text, the indent applies to the left edge if
alignment() is \c AlignLeft, to the right edge if alignment() is
\c AlignRight, to the top edge if alignment() is \c AlignTop, and
to to the bottom edge if alignment() is \c AlignBottom.
If indent is negative, or if no indent has been set, the label
computes the effective indent as follows: If frameWidth() is 0,
the effective indent becomes 0. If frameWidth() is greater than 0,
the effective indent becomes half the width of the "x" character
of the widget's current font().
\sa alignment, frameWidth(), font()
*/
void TQLabel::setIndent( int indent )
{
extraMargin = indent;
updateLabel( TQSize( -1, -1 ) );
}
/*!
\fn bool TQLabel::autoResize() const
\obsolete
Returns TRUE if auto-resizing is enabled, or FALSE if auto-resizing
is disabled.
Auto-resizing is disabled by default.
\sa setAutoResize()
*/
/*! \obsolete
Enables auto-resizing if \a enable is TRUE, or disables it if \a
enable is FALSE.
When auto-resizing is enabled the label will resize itself to fit
the contents whenever the contents change. The top-left corner is
not moved. This is useful for TQLabel widgets that are not managed by
a TQLayout (e.g., top-level widgets).
Auto-resizing is disabled by default.
\sa autoResize(), adjustSize(), sizeHint()
*/
void TQLabel::setAutoResize( bool enable )
{
if ( (bool)autoresize != enable ) {
autoresize = enable;
if ( autoresize )
adjustSize(); // calls resize which repaints
}
}
/*!
Returns the size that will be used if the width of the label is \a
w. If \a w is -1, the sizeHint() is returned.
*/
TQSize TQLabel::sizeForWidth( int w ) const
{
TQRect br;
TQPixmap *pix = pixmap();
#ifndef TQT_NO_PICTURE
TQPicture *pic = picture();
#else
const int pic = 0;
#endif
#ifndef TQT_NO_MOVIE
TQMovie *mov = movie();
#else
const int mov = 0;
#endif
int hextra = 2 * frameWidth();
int vextra = hextra;
TQFontMetrics fm( fontMetrics() );
int xw = fm.width( 'x' );
if ( !mov && !pix && !pic ) {
int m = indent();
if ( m < 0 && hextra ) // no indent, but we do have a frame
m = xw / 2 - margin();
if ( m >= 0 ) {
int horizAlign = TQApplication::horizontalAlignment( align );
if ( (horizAlign & AlignLeft) || (horizAlign & AlignRight ) )
hextra += m;
if ( (align & AlignTop) || (align & AlignBottom ) )
vextra += m;
}
}
if ( pix )
br = pix->rect();
#ifndef TQT_NO_PICTURE
else if ( pic )
br = pic->boundingRect();
#endif
#ifndef TQT_NO_MOVIE
else if ( mov )
br = mov->framePixmap().rect();
#endif
#ifndef TQT_NO_RICHTEXT
else if ( doc ) {
int oldW = doc->width();
if ( align & WordBreak ) {
if ( w < 0 )
doc->adjustSize();
else
doc->setWidth( w-hextra );
}
br = TQRect( 0, 0, doc->widthUsed(), doc->height() );
doc->setWidth( oldW );
}
#endif
else {
bool tryWidth = (w < 0) && (align & WordBreak);
if ( tryWidth )
w = xw * 80;
else if ( w < 0 )
w = 2000;
w -= hextra;
br = fm.boundingRect( 0, 0, w ,2000, alignment(), text() );
if ( tryWidth && br.height() < 4*fm.lineSpacing() && br.width() > w/2 )
br = fm.boundingRect( 0, 0, w/2, 2000, alignment(), text() );
if ( tryWidth && br.height() < 2*fm.lineSpacing() && br.width() > w/4 )
br = fm.boundingRect( 0, 0, w/4, 2000, alignment(), text() );
}
int wid = br.width() + hextra;
int hei = br.height() + vextra;
return TQSize( wid, hei );
}
/*!
\reimp
*/
int TQLabel::heightForWidth( int w ) const
{
if (
#ifndef TQT_NO_RICHTEXT
doc ||
#endif
(align & WordBreak) )
return sizeForWidth( w ).height();
return TQWidget::heightForWidth( w );
}
/*!\reimp
*/
TQSize TQLabel::sizeHint() const
{
if ( d->valid_hints != frameWidth() )
(void) TQLabel::minimumSizeHint();
return d->sh;
}
/*!
\reimp
*/
TQSize TQLabel::minimumSizeHint() const
{
if ( d->valid_hints == frameWidth() )
return d->msh;
constPolish();
d->valid_hints = frameWidth();
d->sh = sizeForWidth( -1 );
TQSize sz( -1, -1 );
if (
#ifndef TQT_NO_RICHTEXT
!doc &&
#endif
(align & WordBreak) == 0 ) {
sz = d->sh;
} else {
// think about caching these for performance
sz.rwidth() = sizeForWidth( 0 ).width();
sz.rheight() = sizeForWidth(TQWIDGETSIZE_MAX).height();
if ( d->sh.height() < sz.height() )
sz.rheight() = d->sh.height();
}
if ( sizePolicy().horData() == TQSizePolicy::Ignored )
sz.rwidth() = -1;
if ( sizePolicy().verData() == TQSizePolicy::Ignored )
sz.rheight() = -1;
d->msh = sz;
return sz;
}
/*!
\reimp
*/
void TQLabel::resizeEvent( TQResizeEvent* e )
{
TQFrame::resizeEvent( e );
#ifdef TQT_NO_RICHTEXT
static const bool doc = FALSE;
#endif
// optimize for standard labels
if ( frameShape() == NoFrame && (align & WordBreak) == 0 && !doc &&
( e->oldSize().width() >= e->size().width() && (align & AlignLeft ) == AlignLeft )
&& ( e->oldSize().height() >= e->size().height() && (align & AlignTop ) == AlignTop ) ) {
setWFlags( WResizeNoErase );
return;
}
clearWFlags( WResizeNoErase );
TQRect cr = contentsRect();
if ( !lpixmap || !cr.isValid() ||
// masked pixmaps can only reduce flicker when being top/left
// aligned and when we do not perform scaled contents
( lpixmap->hasAlpha() && ( scaledcontents || ( ( align & (AlignLeft|AlignTop) ) != (AlignLeft|AlignTop) ) ) ) )
return;
setWFlags( WResizeNoErase );
if ( !scaledcontents ) {
// don't we all love TQFrame? Reduce pixmap flicker
TQRegion reg = TQRect( TQPoint(0, 0), e->size() );
reg = reg.subtract( cr );
int x = cr.x();
int y = cr.y();
int w = lpixmap->width();
int h = lpixmap->height();
if ( (align & TQt::AlignVCenter) == TQt::AlignVCenter )
y += cr.height()/2 - h/2;
else if ( (align & TQt::AlignBottom) == TQt::AlignBottom)
y += cr.height() - h;
if ( (align & TQt::AlignRight) == TQt::AlignRight )
x += cr.width() - w;
else if ( (align & TQt::AlignHCenter) == TQt::AlignHCenter )
x += cr.width()/2 - w/2;
if ( x > cr.x() )
reg = reg.unite( TQRect( cr.x(), cr.y(), x - cr.x(), cr.height() ) );
if ( y > cr.y() )
reg = reg.unite( TQRect( cr.x(), cr.y(), cr.width(), y - cr.y() ) );
if ( x + w < cr.right() )
reg = reg.unite( TQRect( x + w, cr.y(), cr.right() - x - w, cr.height() ) );
if ( y + h < cr.bottom() )
reg = reg.unite( TQRect( cr.x(), y + h, cr.width(), cr.bottom() - y - h ) );
erase( reg );
}
}
/*!
Draws the label contents using the painter \a p.
*/
void TQLabel::drawContents( TQPainter *p )
{
TQRect cr = contentsRect();
TQPixmap *pix = pixmap();
#ifndef TQT_NO_PICTURE
TQPicture *pic = picture();
#else
const int pic = 0;
#endif
#ifndef TQT_NO_MOVIE
TQMovie *mov = movie();
#else
const int mov = 0;
#endif
if ( !mov && !pix && !pic ) {
int m = indent();
if ( m < 0 && frameWidth() ) // no indent, but we do have a frame
m = fontMetrics().width('x') / 2 - margin();
if ( m > 0 ) {
int hAlign = TQApplication::horizontalAlignment( align );
if ( hAlign & AlignLeft )
cr.setLeft( cr.left() + m );
if ( hAlign & AlignRight )
cr.setRight( cr.right() - m );
if ( align & AlignTop )
cr.setTop( cr.top() + m );
if ( align & AlignBottom )
cr.setBottom( cr.bottom() - m );
}
}
#ifndef TQT_NO_MOVIE
if ( mov ) {
// ### should add movie to qDrawItem
TQRect r = style().itemRect( p, cr, align, isEnabled(), &(mov->framePixmap()),
TQString::null );
// ### could resize movie frame at this point
p->drawPixmap(r.x(), r.y(), mov->framePixmap() );
}
else
#endif
#ifndef TQT_NO_RICHTEXT
if ( doc ) {
doc->setWidth(p, cr.width() );
int rh = doc->height();
int yo = 0;
if ( align & AlignVCenter )
yo = (cr.height()-rh)/2;
else if ( align & AlignBottom )
yo = cr.height()-rh;
if (! isEnabled() &&
style().styleHint(TQStyle::SH_EtchDisabledText, this)) {
TQColorGroup cg = colorGroup();
cg.setColor( TQColorGroup::Text, cg.light() );
doc->draw(p, cr.x()+1, cr.y()+yo+1, cr, cg, 0);
}
// TQSimpleRichText always draws with TQColorGroup::Text as with
// background mode PaletteBase. TQLabel typically has
// background mode PaletteBackground, so we create a temporary
// color group with the text color adjusted.
TQColorGroup cg = colorGroup();
if ( backgroundMode() != PaletteBase && isEnabled() )
cg.setColor( TQColorGroup::Text, paletteForegroundColor() );
doc->draw(p, cr.x(), cr.y()+yo, cr, cg, 0);
} else
#endif
#ifndef TQT_NO_PICTURE
if ( pic ) {
TQRect br = pic->boundingRect();
int rw = br.width();
int rh = br.height();
if ( scaledcontents ) {
p->save();
p->translate( cr.x(), cr.y() );
#ifndef TQT_NO_TRANSFORMATIONS
p->scale( (double)cr.width()/rw, (double)cr.height()/rh );
#endif
p->drawPicture( -br.x(), -br.y(), *pic );
p->restore();
} else {
int xo = 0;
int yo = 0;
if ( align & AlignVCenter )
yo = (cr.height()-rh)/2;
else if ( align & AlignBottom )
yo = cr.height()-rh;
if ( align & AlignRight )
xo = cr.width()-rw;
else if ( align & AlignHCenter )
xo = (cr.width()-rw)/2;
p->drawPicture( cr.x()+xo-br.x(), cr.y()+yo-br.y(), *pic );
}
} else
#endif
{
#ifndef TQT_NO_IMAGE_SMOOTHSCALE
if ( scaledcontents && pix ) {
if ( !d->img )
d->img = new TQImage( lpixmap->convertToImage() );
if ( !d->pix )
d->pix = new TQPixmap;
if ( d->pix->size() != cr.size() )
d->pix->convertFromImage( d->img->smoothScale( cr.width(), cr.height() ) );
pix = d->pix;
}
#endif
int alignment = align;
if ((align & ShowPrefix) && ((!style().styleHint(TQStyle::SH_UnderlineAccelerator, this)) || ((style().styleHint(TQStyle::SH_HideUnderlineAcceleratorWhenAltUp, this)) && (!style().acceleratorsShown())))) {
alignment |= NoAccel;
}
// ordinary text or pixmap label
style().drawItem( p, cr, alignment, colorGroup(), isEnabled(),
pix, ltext );
}
}
/*!
Updates the label, but not the frame.
*/
void TQLabel::updateLabel( TQSize oldSizeHint )
{
d->valid_hints = -1;
TQSizePolicy policy = sizePolicy();
bool wordBreak = align & WordBreak;
policy.setHeightForWidth( wordBreak );
if ( policy != sizePolicy() )
setSizePolicy( policy );
if ( sizeHint() != oldSizeHint )
updateGeometry();
if ( autoresize ) {
adjustSize();
update( contentsRect() );
} else {
update( contentsRect() );
}
}
/*!
\internal
Internal slot, used to set focus for accelerator labels.
*/
#ifndef TQT_NO_ACCEL
void TQLabel::acceleratorSlot()
{
if ( !lbuddy )
return;
TQWidget * w = lbuddy;
while ( w->focusProxy() )
w = w->focusProxy();
if ( !w->hasFocus() &&
w->isEnabled() &&
w->isVisible() &&
w->focusPolicy() != NoFocus ) {
TQFocusEvent::setReason( TQFocusEvent::Shortcut );
w->setFocus();
TQFocusEvent::resetReason();
}
}
#endif
/*!
\internal
Internal slot, used to clean up if the buddy widget dies.
*/
#ifndef TQT_NO_ACCEL
void TQLabel::buddyDied() // I can't remember if I cried.
{
lbuddy = 0;
}
/*!
Sets this label's buddy to \a buddy.
When the user presses the accelerator key indicated by this label,
the keyboard focus is transferred to the label's buddy widget.
The buddy mechanism is only available for TQLabels that contain
plain text in which one letter is prefixed with an ampersand, \&.
This letter is set as the accelerator key. The letter is displayed
underlined, and the '\&' is not displayed (i.e. the \c ShowPrefix
alignment flag is turned on; see setAlignment()).
In a dialog, you might create two data entry widgets and a label
for each, and set up the geometry layout so each label is just to
the left of its data entry widget (its "buddy"), for example:
\code
TQLineEdit *nameEd = new TQLineEdit( this );
TQLabel *nameLb = new TQLabel( "&Name:", this );
nameLb->setBuddy( nameEd );
TQLineEdit *phoneEd = new TQLineEdit( this );
TQLabel *phoneLb = new TQLabel( "&Phone:", this );
phoneLb->setBuddy( phoneEd );
// ( layout setup not shown )
\endcode
With the code above, the focus jumps to the Name field when the
user presses Alt+N, and to the Phone field when the user presses
Alt+P.
To unset a previously set buddy, call this function with \a buddy
set to 0.
\sa buddy(), setText(), TQAccel, setAlignment()
*/
void TQLabel::setBuddy( TQWidget *buddy )
{
if ( buddy )
setAlignment( alignment() | ShowPrefix );
else
setAlignment( alignment() & ~ShowPrefix );
if ( lbuddy )
disconnect( lbuddy, SIGNAL(destroyed()), this, SLOT(buddyDied()) );
lbuddy = buddy;
if ( !lbuddy )
return;
#ifndef TQT_NO_RICHTEXT
if ( !( textformat == RichText || (textformat == AutoText &&
TQStyleSheet::mightBeRichText(ltext) ) ) )
#endif
{
int p = TQAccel::shortcutKey( ltext );
if ( p ) {
if ( !accel )
accel = new TQAccel( this, "accel label accel" );
accel->connectItem( accel->insertItem( p ),
this, SLOT(acceleratorSlot()) );
}
}
connect( lbuddy, SIGNAL(destroyed()), this, SLOT(buddyDied()) );
}
/*!
Returns this label's buddy, or 0 if no buddy is currently set.
\sa setBuddy()
*/
TQWidget * TQLabel::buddy() const
{
return lbuddy;
}
#endif //TQT_NO_ACCEL
#ifndef TQT_NO_MOVIE
void TQLabel::movieUpdated(const TQRect& rect)
{
TQMovie *mov = movie();
if ( mov && !mov->isNull() ) {
TQRect r = contentsRect();
r = style().itemRect( 0, r, align, isEnabled(), &(mov->framePixmap()),
TQString::null );
r.moveBy(rect.x(), rect.y());
r.setWidth(TQMIN(r.width(), rect.width()));
r.setHeight(TQMIN(r.height(), rect.height()));
repaint( r, mov->framePixmap().mask() != 0 );
}
}
void TQLabel::movieResized( const TQSize& size )
{
d->valid_hints = -1;
if ( autoresize )
adjustSize();
movieUpdated( TQRect( TQPoint(0,0), size ) );
updateGeometry();
}
/*!
Sets the label contents to \a movie. Any previous content is
cleared.
The buddy accelerator, if any, is disabled.
The label resizes itself if auto-resizing is enabled.
\sa movie(), setBuddy()
*/
void TQLabel::setMovie( const TQMovie& movie )
{
TQSize osh = sizeHint();
clearContents();
lmovie = new TQMovie( movie );
lmovie->connectResize(this, SLOT(movieResized(const TQSize&)));
lmovie->connectUpdate(this, SLOT(movieUpdated(const TQRect&)));
if ( !lmovie->running() ) // Assume that if the movie is running,
updateLabel( osh ); // resize/update signals will come soon enough
}
#endif // TQT_NO_MOVIE
/*!
\internal
Clears any contents, without updating/repainting the label.
*/
void TQLabel::clearContents()
{
#ifndef TQT_NO_RICHTEXT
delete doc;
doc = 0;
#endif
delete lpixmap;
lpixmap = 0;
#ifndef TQT_NO_PICTURE
delete lpicture;
lpicture = 0;
#endif
delete d->img;
d->img = 0;
delete d->pix;
d->pix = 0;
ltext = TQString::null;
#ifndef TQT_NO_ACCEL
if ( accel )
accel->clear();
#endif
#ifndef TQT_NO_MOVIE
if ( lmovie ) {
lmovie->disconnectResize(this, SLOT(movieResized(const TQSize&)));
lmovie->disconnectUpdate(this, SLOT(movieUpdated(const TQRect&)));
delete lmovie;
lmovie = 0;
}
#endif
}
#ifndef TQT_NO_MOVIE
/*!
Returns a pointer to the label's movie, or 0 if no movie has been
set.
\sa setMovie()
*/
TQMovie* TQLabel::movie() const
{
return lmovie;
}
#endif // TQT_NO_MOVIE
/*!
\property TQLabel::backgroundMode
\brief the label's background mode
Get this property with backgroundMode().
\sa TQWidget::setBackgroundMode()
*/
/*!
\property TQLabel::textFormat
\brief the label's text format
See the \c TQt::TextFormat enum for an explanation of the possible
options.
The default format is \c AutoText.
\sa text
*/
TQt::TextFormat TQLabel::textFormat() const
{
return textformat;
}
void TQLabel::setTextFormat( TQt::TextFormat format )
{
if ( format != textformat ) {
textformat = format;
TQString t = ltext;
if ( !t.isNull() ) {
ltext = TQString::null;
setText( t );
}
}
}
/*!
\reimp
*/
void TQLabel::fontChange( const TQFont & )
{
if ( !ltext.isEmpty() ) {
#ifndef TQT_NO_RICHTEXT
if ( doc )
doc->setDefaultFont( font() );
#endif
updateLabel( TQSize( -1, -1 ) );
}
}
#ifndef TQT_NO_IMAGE_SMOOTHSCALE
/*!
\property TQLabel::scaledContents
\brief whether the label will scale its contents to fill all
available space.
When enabled and the label shows a pixmap, it will scale the
pixmap to fill the available space.
This property's default is FALSE.
\sa setScaledContents()
*/
bool TQLabel::hasScaledContents() const
{
return scaledcontents;
}
void TQLabel::setScaledContents( bool enable )
{
if ( (bool)scaledcontents == enable )
return;
scaledcontents = enable;
if ( !enable ) {
delete d->img;
d->img = 0;
delete d->pix;
d->pix = 0;
}
update( contentsRect() );
}
#endif // TQT_NO_IMAGE_SMOOTHSCALE
/*!
Sets the font used on the TQLabel to font \a f.
*/
void TQLabel::setFont( const TQFont &f )
{
TQFrame::setFont( f );
}
#endif // TQT_NO_LABEL