Rename basic widget nt* related files to equivalent tq*

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>

1 files changed, 976 insertions, 0 deletions

diff --git a/src/widgets/tqdial.cpp b/src/widgets/tqdial.cpp
new file mode 100644
index 000000000..75793b5c1
--- /dev/null
+++ b/src/widgets/tqdial.cpp
@@ -0,0 +1,976 @@
+/****************************************************************************
+**
+** Implementation of the dial widget
+**
+** Created : 979899
+**
+** 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 "tqdial.h"
+
+#ifndef TQT_NO_DIAL
+
+#include "tqpainter.h"
+#include "tqpointarray.h"
+#include "tqcolor.h"
+#include "ntqapplication.h"
+#include "tqregion.h"
+#include "tqbitmap.h"
+#include "tqstyle.h"
+#if defined(QT_ACCESSIBILITY_SUPPORT)
+#include "ntqaccessible.h"
+#endif
+
+#include <math.h> // sin(), cos(), atan()
+//### Forutsetter linking med math lib - Jfr kommentar i tqpainter_x11.cpp!
+
+static const double m_pi = 3.14159265358979323846;
+static const double rad_factor = 180.0 / m_pi;
+
+
+class TQDialPrivate
+{
+public:
+    TQDialPrivate()
+    {
+	wrapping = FALSE;
+	tracking = TRUE;
+	doNotEmit = FALSE;
+	target = 3.7;
+	mousePressed = FALSE;
+    }
+
+    bool wrapping;
+    bool tracking;
+    bool doNotEmit;
+    double target;
+    TQRect eraseArea;
+    bool eraseAreaValid;
+    bool showNotches;
+    bool onlyOutside;
+    bool mousePressed;
+
+    TQPointArray lines;
+};
+
+
+/*!
+    \class TQDial tqdial.h
+
+    \brief The TQDial class provides a rounded range control (like a speedometer or potentiometer).
+
+    \ingroup basic
+    \mainclass
+
+    TQDial is used when the user needs to control a value within a
+    program-definable range, and the range either wraps around
+    (typically, 0..359 degrees) or the dialog layout needs a square
+    widget.
+
+    Both API- and UI-wise, the dial is very similar to a \link TQSlider
+    slider. \endlink Indeed, when wrapping() is FALSE (the default)
+    there is no real difference between a slider and a dial. They
+    have the same signals, slots and member functions, all of which do
+    the same things. Which one you use depends only on your taste
+    and on the application.
+
+    The dial initially emits valueChanged() signals continuously while
+    the slider is being moved; you can make it emit the signal less
+    often by calling setTracking(FALSE). dialMoved() is emitted
+    continuously even when tracking() is FALSE.
+
+    The slider also emits dialPressed() and dialReleased() signals
+    when the mouse button is pressed and released. But note that the
+    dial's value can change without these signals being emitted; the
+    keyboard and wheel can be used to change the value.
+
+    Unlike the slider, TQDial attempts to draw a "nice" number of
+    notches rather than one per lineStep(). If possible, the number
+    of notches drawn is one per lineStep(), but if there aren't enough
+    pixels to draw every one, TQDial will draw every second, third
+    etc., notch. notchSize() returns the number of units per notch,
+    hopefully a multiple of lineStep(); setNotchTarget() sets the
+    target distance between neighbouring notches in pixels. The
+    default is 3.75 pixels.
+
+    Like the slider, the dial makes the TQRangeControl functions
+    setValue(), addLine(), subtractLine(), addPage() and
+    subtractPage() available as slots.
+
+    The dial's keyboard interface is fairly simple: The left/up and
+    right/down arrow keys move by lineStep(), page up and page down by
+    pageStep() and Home and End to minValue() and maxValue().
+
+    <img src=tqdial-m.png> <img src=tqdial-w.png>
+
+    \sa TQScrollBar TQSpinBox
+    \link guibooks.html#fowler GUI Design Handbook: Slider\endlink
+*/
+
+
+
+
+/*!
+    Constructs a dial called \a name with parent \a parent. \a f is
+    propagated to the TQWidget constructor. It has the default range of
+    a TQRangeControl.
+*/
+
+TQDial::TQDial( TQWidget *parent, const char *name, WFlags f )
+    : TQWidget( parent, name, f | WNoAutoErase ), TQRangeControl()
+{
+    d = new TQDialPrivate;
+    d->eraseAreaValid = FALSE;
+    d->showNotches = FALSE;
+    d->onlyOutside = FALSE;
+    setFocusPolicy( TQWidget::WheelFocus );
+}
+
+
+
+/*!
+    Constructs a dial called \a name with parent \a parent. The dial's
+    value can never be smaller than \a minValue or greater than \a
+    maxValue. Its page step size is \a pageStep, and its initial value
+    is \a value.
+
+    \a value is forced to be within the legal range.
+*/
+
+TQDial::TQDial( int minValue, int maxValue, int pageStep, int value,
+	      TQWidget *parent, const char *name )
+    : TQWidget( parent, name, WNoAutoErase ),
+      TQRangeControl( minValue, maxValue, 1, pageStep, value )
+{
+    d = new TQDialPrivate;
+    d->eraseAreaValid = FALSE;
+    d->showNotches = FALSE;
+    d->onlyOutside = FALSE;
+    setFocusPolicy( TQWidget::WheelFocus );
+}
+
+/*!
+    Destroys the dial.
+*/
+TQDial::~TQDial()
+{
+    delete d;
+}
+
+
+void TQDial::setTracking( bool enable )
+{
+    d->tracking = enable;
+}
+
+
+/*!
+    \property TQDial::tracking
+    \brief whether tracking is enabled
+
+    If TRUE (the default), tracking is enabled. This means that the
+    arrow can be moved using the mouse; otherwise the arrow cannot be
+    moved with the mouse.
+*/
+
+bool TQDial::tracking() const
+{
+    return d ? d->tracking : TRUE;
+}
+
+void TQDial::setValue( int newValue )
+{ // ### set doNotEmit?	 Matthias?
+    TQRangeControl::setValue( newValue );
+}
+
+
+/*!
+    Increments the dial's value() by one lineStep().
+*/
+
+void TQDial::addLine()
+{
+    TQRangeControl::addLine();
+}
+
+
+/*!
+    Decrements the dial's value() by one lineStep().
+*/
+
+void TQDial::subtractLine()
+{
+    TQRangeControl::subtractLine();
+}
+
+
+/*! \reimp */
+
+void TQDial::resizeEvent( TQResizeEvent * e )
+{
+    d->lines.resize( 0 );
+    TQWidget::resizeEvent( e );
+}
+
+
+/*!
+  \reimp
+*/
+
+void TQDial::paintEvent( TQPaintEvent * e )
+{
+    repaintScreen( &e->rect() );
+}
+
+/*!
+    Paints the dial using clip region \a cr.
+*/
+
+void TQDial::repaintScreen( const TQRect *cr )
+{
+    TQPainter p;
+    p.begin( this );
+
+    bool resetClipping = FALSE;
+
+    // calculate clip-region for erasing background
+    if ( cr ) {
+	p.setClipRect( *cr );
+    } else if ( !d->onlyOutside && d->eraseAreaValid ) {
+	TQRegion reg = d->eraseArea;
+	double a;
+	reg = reg.subtract( calcArrow( a ) );
+	p.setClipRegion( reg );
+	resetClipping = TRUE;
+    }
+
+    TQRect br( calcDial() );
+    p.setPen( NoPen );
+    // if ( style() == MotifStyle )
+    // p.setBrush( colorGroup().brush( TQColorGroup::Mid ) );
+    // else {
+    TQBrush b;
+    if ( colorGroup().brush( TQColorGroup::Light ).pixmap() )
+	b = TQBrush( colorGroup().brush( TQColorGroup::Light ) );
+    else
+	b = TQBrush( colorGroup().light(), Dense4Pattern );
+    p.setBrush( b );
+    p.setBackgroundMode( OpaqueMode );
+    // }
+
+    TQRect te = br;
+    te.setWidth(te.width()+2);
+    te.setHeight(te.height()+2);
+    // erase background of dial
+    if ( !d->onlyOutside ) {
+	p.drawEllipse( te );
+    }
+
+    // erase remaining space around the dial
+    TQRegion remaining( 0, 0, width(), height() );
+    remaining = remaining.subtract( TQRegion( te, TQRegion::Ellipse ) );
+    if ( p.hasClipping() )
+	remaining = remaining.intersect( p.clipRegion() );
+    erase(remaining);
+
+    if ( resetClipping ) {
+	if ( cr )
+	    p.setClipRect( *cr );
+	else
+	    p.setClipRect( TQRect( 0, 0, width(), height() ) );
+    }
+
+    // draw notches
+    if ( d->showNotches ) {
+	calcLines();
+	p.setPen( colorGroup().foreground() );
+	p.drawLineSegments( d->lines );
+    }
+
+    // calculate and paint arrow
+    p.setPen( TQPen( colorGroup().dark() ) );
+    p.drawArc( te, 60 * 16, 180 * 16 );
+    p.setPen( TQPen( colorGroup().light() ) );
+    p.drawArc( te, 240 * 16, 180 * 16 );
+
+    double a;
+    TQPointArray arrow( calcArrow( a ) );
+    TQRect ea( arrow.boundingRect() );
+    d->eraseArea = ea;
+    d->eraseAreaValid = TRUE;
+
+    p.setPen( NoPen );
+    p.setBrush( colorGroup().brush( TQColorGroup::Button ) );
+    if ( !d->onlyOutside )
+	p.drawPolygon( arrow );
+
+    a = angle( TQPoint( width() / 2, height() / 2 ), arrow[ 0 ] );
+    p.setBrush( TQt::NoBrush );
+
+    // that's still a hack...
+    if ( a <= 0 || a > 200 ) {
+	p.setPen( colorGroup().light() );
+	p.drawLine( arrow[ 2 ], arrow[ 0 ] );
+	p.drawLine( arrow[ 1 ], arrow[ 2 ] );
+	p.setPen( colorGroup().dark() );
+	p.drawLine( arrow[ 0 ], arrow[ 1 ] );
+    } else if ( a > 0 && a < 45 ) {
+	p.setPen( colorGroup().light() );
+	p.drawLine( arrow[ 2 ], arrow[ 0 ] );
+	p.setPen( colorGroup().dark() );
+	p.drawLine( arrow[ 1 ], arrow[ 2 ] );
+	p.drawLine( arrow[ 0 ], arrow[ 1 ] );
+    } else if ( a >= 45 && a < 135 ) {
+	p.setPen( colorGroup().dark() );
+	p.drawLine( arrow[ 2 ], arrow[ 0 ] );
+	p.drawLine( arrow[ 1 ], arrow[ 2 ] );
+	p.setPen( colorGroup().light() );
+	p.drawLine( arrow[ 0 ], arrow[ 1 ] );
+    } else if ( a >= 135 && a < 200 ) {
+	p.setPen( colorGroup().dark() );
+	p.drawLine( arrow[ 2 ], arrow[ 0 ] );
+	p.setPen( colorGroup().light() );
+	p.drawLine( arrow[ 0 ], arrow[ 1 ] );
+	p.drawLine( arrow[ 1 ], arrow[ 2 ] );
+    }
+
+    // draw focus rect around the dial
+    if ( hasFocus() ) {
+	p.setClipping( FALSE );
+	br.setWidth( br.width() + 2 );
+	br.setHeight( br.height() + 2 );
+	if ( d->showNotches ) {
+	    int r = TQMIN( width(), height() ) / 2;
+	    br.moveBy( -r / 6, - r / 6 );
+	    br.setWidth( br.width() + r / 3 );
+	    br.setHeight( br.height() + r / 3 );
+	}
+	// strange, but else we get redraw errors on Windows
+	p.end();
+	p.begin( this );
+	p.save();
+	p.setPen( TQPen( colorGroup().background() ) );
+	p.setBrush( NoBrush );
+	p.drawRect( br );
+	p.restore();
+	style().drawPrimitive( TQStyle::PE_FocusRect, &p, br, colorGroup());
+    }
+    p.end();
+}
+
+
+/*!
+  \reimp
+*/
+
+void TQDial::keyPressEvent( TQKeyEvent * e )
+{
+    switch ( e->key() ) {
+    case Key_Left: case Key_Down:
+	subtractLine();
+	break;
+    case Key_Right: case Key_Up:
+	addLine();
+	break;
+    case Key_Prior:
+	subtractPage();
+	break;
+    case Key_Next:
+	addPage();
+	break;
+    case Key_Home:
+	setValue( minValue() );
+	break;
+    case Key_End:
+	setValue( maxValue() );
+	break;
+    default:
+	e->ignore();
+	break;
+    }
+}
+
+
+/*!
+  \reimp
+*/
+
+void TQDial::mousePressEvent( TQMouseEvent * e )
+{
+    d->mousePressed = TRUE;
+    setValue( valueFromPoint( e->pos() ) );
+    emit dialPressed();
+}
+
+
+/*!
+  \reimp
+*/
+
+void TQDial::mouseReleaseEvent( TQMouseEvent * e )
+{
+    d->mousePressed = FALSE;
+    setValue( valueFromPoint( e->pos() ) );
+    emit dialReleased();
+}
+
+
+/*!
+  \reimp
+*/
+
+void TQDial::mouseMoveEvent( TQMouseEvent * e )
+{
+    if ( !d->mousePressed )
+	return;
+    if ( !d->tracking || (e->state() & LeftButton) == 0 )
+	return;
+    d->doNotEmit = TRUE;
+    setValue( valueFromPoint( e->pos() ) );
+    emit dialMoved( value() );
+    d->doNotEmit = FALSE;
+}
+
+
+/*!
+  \reimp
+*/
+#ifndef TQT_NO_WHEELEVENT
+void TQDial::wheelEvent( TQWheelEvent *e )
+{
+    setValue( value() - e->delta() / 120 );
+}
+#endif
+
+/*!
+  \reimp
+*/
+
+void TQDial::focusInEvent( TQFocusEvent * )
+{
+    d->onlyOutside = TRUE;
+    repaintScreen();
+    d->onlyOutside = FALSE;
+}
+
+
+/*!
+  \reimp
+*/
+
+void TQDial::focusOutEvent( TQFocusEvent * )
+{
+    d->onlyOutside = TRUE;
+    repaintScreen();
+    d->onlyOutside = FALSE;
+}
+
+/*!
+    Reimplemented to ensure the display is correct and to emit the
+    valueChanged(int) signal when appropriate.
+*/
+
+void TQDial::valueChange()
+{
+    d->lines.resize( 0 );
+    repaintScreen();
+    if ( d->tracking || !d->doNotEmit ) {
+	emit valueChanged( value() );
+#if defined(QT_ACCESSIBILITY_SUPPORT)
+	TQAccessible::updateAccessibility( this, 0, TQAccessible::ValueChanged );
+#endif
+    }
+}
+
+
+/*!
+    Reimplemented to ensure tick-marks are consistent with the new range.
+*/
+
+void TQDial::rangeChange()
+{
+    d->lines.resize( 0 );
+    repaintScreen();
+}
+
+
+/*!
+  \internal
+*/
+
+int TQDial::valueFromPoint( const TQPoint & p ) const
+{
+    double yy = (double)height()/2.0 - p.y();
+    double xx = (double)p.x() - width()/2.0;
+    double a = (xx || yy) ? atan2(yy, xx) : 0;
+        
+    if ( a < m_pi/-2 )
+	a = a + m_pi*2;
+
+    int dist = 0;
+    int minv = minValue(), maxv = maxValue();
+
+    if ( minValue() < 0 ) {
+	dist = -minValue();
+	minv = 0;
+	maxv = maxValue() + dist;
+    }
+
+    int r = maxv - minv;
+    int v;
+    if ( d->wrapping )
+	v =  (int)(0.5 + minv + r*(m_pi*3/2-a)/(2*m_pi));
+    else
+	v =  (int)(0.5 + minv + r*(m_pi*4/3-a)/(m_pi*10/6));
+
+    if ( dist > 0 )
+	v -= dist;
+
+    return bound( v );
+}
+
+
+/*!
+  \internal
+*/
+
+double TQDial::angle( const TQPoint &p1, const TQPoint &p2 ) const
+{
+    double _angle = 0.0;
+
+    if ( p1.x() == p2.x() ) {
+	if ( p1.y() < p2.y() )
+	    _angle = 270.0;
+	else
+	    _angle = 90.0;
+    } else  {
+	double x1, x2, y1, y2;
+
+	if ( p1.x() <= p2.x() ) {
+	    x1 = p1.x(); y1 = p1.y();
+	    x2 = p2.x(); y2 = p2.y();
+	} else {
+	    x2 = p1.x(); y2 = p1.y();
+	    x1 = p2.x(); y1 = p2.y();
+	}
+
+	double m = -( y2 - y1 ) / ( x2 - x1 );
+	_angle = atan( m ) *  rad_factor;
+
+	if ( p1.x() < p2.x() )
+	    _angle = 180.0 - _angle;
+	else
+	    _angle = -_angle;
+    }
+
+    return _angle;
+}
+
+void TQDial::setWrapping( bool enable )
+{
+    if ( d->wrapping == enable )
+	return;
+    d->lines.resize( 0 );
+    d->wrapping = enable;
+    d->eraseAreaValid = FALSE;
+    repaintScreen();
+}
+
+
+/*!
+    \property TQDial::wrapping
+    \brief whether wrapping is enabled
+
+    If TRUE, wrapping is enabled. This means that the arrow can be
+    turned around 360°. Otherwise there is some space at the bottom of
+    the dial which is skipped by the arrow.
+
+    This property's default is FALSE.
+*/
+
+bool TQDial::wrapping() const
+{
+    return d->wrapping;
+}
+
+
+/*!
+    \property TQDial::notchSize
+    \brief the current notch size
+
+    The notch size is in range control units, not pixels, and if
+    possible it is a multiple of lineStep() that results in an
+    on-screen notch size near notchTarget().
+
+    \sa notchTarget() lineStep()
+*/
+
+int TQDial::notchSize() const
+{
+    // radius of the arc
+    int r = TQMIN( width(), height() )/2;
+    // length of the whole arc
+    int l = (int)(r*(d->wrapping ? 6 : 5)*m_pi/6);
+    // length of the arc from minValue() to minValue()+pageStep()
+    if ( maxValue() > minValue()+pageStep() )
+	l = (int)(0.5 + l * pageStep() / (maxValue()-minValue()));
+    // length of a lineStep() arc
+    l = l * lineStep() / pageStep();
+    if ( l < 1 )
+	l = 1;
+    // how many times lineStep can be draw in d->target pixels
+    l = (int)(0.5 + d->target / l);
+    // we want notchSize() to be a non-zero multiple of lineStep()
+    if ( !l )
+	l = 1;
+    return lineStep() * l;
+}
+
+void TQDial::setNotchTarget( double target )
+{
+    d->lines.resize( 0 );
+    d->target = target;
+    d->eraseAreaValid = FALSE;
+    d->onlyOutside = TRUE;
+    repaintScreen();
+    d->onlyOutside = FALSE;
+}
+
+
+/*!
+    \property TQDial::notchTarget
+    \brief the target number of pixels between notches
+
+    The notch target is the number of pixels TQDial attempts to put
+    between each notch.
+
+    The actual size may differ from the target size.
+*/
+
+double TQDial::notchTarget() const
+{
+    return d->target;
+}
+
+
+/*!
+    Increments the dial's value() by one pageStep() of steps.
+*/
+
+void TQDial::addPage()
+{
+    TQRangeControl::addPage();
+}
+
+
+/*!
+    Decrements the dial's value() by one pageStep() of steps.
+*/
+
+void TQDial::subtractPage()
+{
+    TQRangeControl::subtractPage();
+}
+
+
+/*!
+    \fn void TQDial::valueChanged( int value )
+
+    This signal is emitted whenever the dial's \a value changes. The
+    frequency of this signal is influenced by setTracking().
+*/
+
+/*!
+    \fn void TQDial::dialPressed()
+
+    This signal is emitted when the user begins mouse interaction with
+    the dial.
+
+    \sa dialReleased()
+*/
+
+/*!
+    \fn void TQDial::dialMoved( int value )
+
+    This signal is emitted whenever the dial \a value changes. The
+    frequency of this signal is \e not influenced by setTracking().
+
+    \sa valueChanged()
+*/
+
+/*!
+    \fn void TQDial::dialReleased()
+
+    This signal is emitted when the user ends mouse interaction with
+    the dial.
+
+    \sa dialPressed()
+*/
+
+void TQDial::setNotchesVisible( bool b )
+{
+    d->showNotches = b;
+    d->eraseAreaValid = FALSE;
+    d->onlyOutside = TRUE;
+    repaintScreen();
+    d->onlyOutside = FALSE;
+}
+
+/*!
+    \property TQDial::notchesVisible
+    \brief whether the notches are shown
+
+    If TRUE, the notches are shown. If FALSE (the default) notches are
+    not shown.
+*/
+bool TQDial::notchesVisible() const
+{
+    return d->showNotches;
+}
+
+/*!
+  \reimp
+*/
+
+TQSize TQDial::minimumSizeHint() const
+{
+    return TQSize( 50, 50 );
+}
+
+/*!
+  \reimp
+*/
+
+TQSize TQDial::sizeHint() const
+{
+    return TQSize( 100, 100 ).expandedTo( TQApplication::globalStrut() );
+}
+
+
+
+/*!
+  \internal
+*/
+
+TQPointArray TQDial::calcArrow( double &a ) const
+{
+    int r = TQMIN( width(), height() ) / 2;
+    if ( maxValue() == minValue() )
+	a = m_pi / 2;
+    else if ( d->wrapping )
+	a = m_pi * 3 / 2 - ( value() - minValue() ) * 2 * m_pi / ( maxValue() - minValue() );
+    else
+	a = ( m_pi * 8 - ( value() - minValue() ) * 10 * m_pi / ( maxValue() - minValue() ) ) / 6;
+
+    int xc = width() / 2;
+    int yc = height() / 2;
+
+    int len = r - calcBigLineSize() - 5;
+    if ( len < 5 )
+	len = 5;
+    int back = len / 4;
+    if ( back < 1 )
+	back = 1;
+
+    TQPointArray arrow( 3 );
+    arrow[0] = TQPoint( (int)( 0.5 + xc + len * cos(a) ),
+		       (int)( 0.5 + yc -len * sin( a ) ) );
+    arrow[1] = TQPoint( (int)( 0.5 + xc + back * cos( a + m_pi * 5 / 6 ) ),
+		       (int)( 0.5 + yc - back * sin( a + m_pi * 5 / 6 ) ) );
+    arrow[2] = TQPoint( (int)( 0.5 + xc + back * cos( a - m_pi * 5 / 6 ) ),
+		       (int)( 0.5 + yc - back * sin( a - m_pi * 5 / 6 ) ) );
+    return arrow;
+}
+
+/*!
+  \internal
+*/
+
+TQRect TQDial::calcDial() const
+{
+    double r = TQMIN( width(), height() ) / 2.0;
+    double d_ = r / 6.0;
+    double dx = d_ + ( width() - 2 * r ) / 2.0 + 1;
+    double dy = d_ + ( height() - 2 * r ) / 2.0 + 1;
+    return TQRect( int(dx), int(dy),
+		int(r * 2 - 2 * d_ - 2), int(r * 2 - 2 * d_ - 2) );
+}
+
+/*!
+  \internal
+*/
+
+int TQDial::calcBigLineSize() const
+{
+    int r = TQMIN( width(), height() ) / 2;
+    int bigLineSize = r / 6;
+    if ( bigLineSize < 4 )
+	bigLineSize = 4;
+    if ( bigLineSize > r / 2 )
+	bigLineSize = r / 2;
+    return bigLineSize;
+}
+
+/*!
+  \internal
+*/
+
+void TQDial::calcLines()
+{
+    if ( !d->lines.size() ) {
+	double r = TQMIN( width(), height() ) / 2.0;
+	int bigLineSize = calcBigLineSize();
+	double xc = width() / 2.0;
+	double yc = height() / 2.0;
+	int ns = notchSize();
+	int notches = ( maxValue() + ns - 1 - minValue() ) / ns;
+	d->lines.resize( 2 + 2 * notches );
+	int smallLineSize = bigLineSize / 2;
+	int i;
+	for( i = 0; i <= notches; i++ ) {
+	    double angle = d->wrapping
+		? m_pi * 3 / 2 - i * 2 * m_pi / notches
+		: (m_pi * 8 - i * 10 * m_pi / notches) / 6;
+
+	    double s = sin( angle ); // sin/cos aren't defined as const...
+	    double c = cos( angle );
+	    if ( i == 0 || ( ((ns * i ) % pageStep() ) == 0 ) ) {
+		d->lines[2*i] = TQPoint( (int)( xc + ( r - bigLineSize ) * c ),
+					(int)( yc - ( r - bigLineSize ) * s ) );
+		d->lines[2*i+1] = TQPoint( (int)( xc + r * c ),
+					  (int)( yc - r * s ) );
+	    } else {
+		d->lines[2*i] = TQPoint( (int)( xc + ( r - 1 - smallLineSize ) * c ),
+					(int)( yc - ( r - 1 - smallLineSize ) * s ) );
+		d->lines[2*i+1] = TQPoint( (int)( xc + ( r - 1 ) * c ),
+					  (int)( yc -( r - 1 ) * s ) );
+	    }
+	}
+    }
+}
+
+/*!
+    \property TQDial::minValue
+    \brief the current minimum value
+
+    When setting this property, the \l TQDial::maxValue is adjusted if
+    necessary to ensure that the range remains valid.
+
+    \sa setRange()
+*/
+int TQDial::minValue() const
+{
+    return TQRangeControl::minValue();
+}
+
+/*!
+    \property TQDial::maxValue
+    \brief the current maximum value
+
+    When setting this property, the \l TQDial::minValue is adjusted if
+    necessary to ensure that the range remains valid.
+
+    \sa setRange()
+*/
+int TQDial::maxValue() const
+{
+    return TQRangeControl::maxValue();
+}
+
+void TQDial::setMinValue( int minVal )
+{
+    TQRangeControl::setMinValue( minVal );
+}
+
+void TQDial::setMaxValue( int maxVal )
+{
+    TQRangeControl::setMaxValue( maxVal );
+}
+
+/*!
+    \property TQDial::lineStep
+    \brief the current line step
+
+    setLineStep() calls the virtual stepChange() function if the new
+    line step is different from the previous setting.
+
+    \sa TQRangeControl::setSteps() pageStep setRange()
+*/
+
+int TQDial::lineStep() const
+{
+    return TQRangeControl::lineStep();
+}
+
+/*!
+    \property TQDial::pageStep
+    \brief the current page step
+
+    setPageStep() calls the virtual stepChange() function if the new
+    page step is different from the previous setting.
+
+    \sa stepChange()
+*/
+int TQDial::pageStep() const
+{
+    return TQRangeControl::pageStep();
+}
+
+void TQDial::setLineStep( int i )
+{
+    setSteps( i, pageStep() );
+}
+
+void TQDial::setPageStep( int i )
+{
+    setSteps( lineStep(), i );
+}
+
+/*!
+    \property TQDial::value
+    \brief the current dial value
+
+    This is guaranteed to be within the range
+    \l{TQDial::minValue}..\l{TQDial::maxValue}.
+
+    \sa minValue maxValue
+*/
+
+int TQDial::value() const
+{
+    return TQRangeControl::value();
+}
+
+#endif // QT_FEATURE_DIAL