From d796c9dd933ab96ec83b9a634feedd5d32e1ba3f Mon Sep 17 00:00:00 2001 From: Timothy Pearson Date: Tue, 8 Nov 2011 12:31:36 -0600 Subject: Test conversion to TQt3 from Qt3 8c6fc1f8e35fd264dd01c582ca5e7549b32ab731 --- doc/html/customstyles.html | 213 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 213 insertions(+) create mode 100644 doc/html/customstyles.html (limited to 'doc/html/customstyles.html') diff --git a/doc/html/customstyles.html b/doc/html/customstyles.html new file mode 100644 index 000000000..47e6afc4b --- /dev/null +++ b/doc/html/customstyles.html @@ -0,0 +1,213 @@ + + + + + +Style overview + + + + + + + +

Style overview

+ + + +

A style in TQt implements the look and feel found in a GUI for a +particular platform. For example, Windows platforms may use the +Windows or Windows-XP style, Unix platforms may use the Motif style, +and so on. +

This is a short guide that describes the steps that are necessary to +get started creating and using custom styles with the TQt 3.x style +API. First, we go through the steps necessary to create a style: +

Pick a base style to inherit from. +
Re-implement the necessary functions in the derived class. +

+Then we explain how to use the new style from within your own +applications, or as a plugin that can be used by existing TQt +applications. +

Creating a custom style +

1. Pick a base style to inherit from. +

The first step is to pick one of the base styles provided with TQt to +build your custom style from. The choice will depend on what look and +feel you are trying to achieve. We recommend that you choose from the +TQWindowsStyle derived classes or the TQMotifStyle derived classes. +These are the two base look and feel classes in the TQt style engine. +Inheriting directly from TQCommonStyle is also an option if you want to +start almost from scratch when implementing your style. In this simple +example we will inherit from TQWindowsStyle. +

2. Re-implement the necessary functions in your derived class. +

Depending on which parts of the base style you want to change, you +must re-implement the functions that are used to draw those parts +of the interface. If you take a look at the TQStyle documentation, +you will find a list of the different primitives, controls and complex +controls. In this example we will first change the look of the +standard arrows that are used in the TQWindowsStyle. The arrows are +PrimitiveElements that are drawn by the drawPrimitive() function, +so we need to re-implement that function. We need the following class +declaration: +

+#include <qwindowsstyle.h>
+
+class CustomStyle : public TQWindowsStyle {
+    Q_OBJECT
+public:
+    CustomStyle();
+    ~CustomStyle();
+
+    void drawPrimitive( PrimitiveElement pe,
+                        TQPainter *p,
+                        const TQRect & r,
+                        const TQColorGroup & cg,
+                        SFlags flags = Style_Default,
+                        const TQStyleOption & = TQStyleOption::Default ) const;
+
+private:
+    // Disabled copy constructor and operator=
+    CustomStyle( const CustomStyle & );
+    CustomStyle& operator=( const CustomStyle & );
+};
+

+ +

Note that we disable the copy constructor and the '=' operator for our +style. TQObject is the base class for all style classes in TQt, and a +TQObject inherently cannot be copied since there are some aspects of it +that are not copyable. +

From the TQStyle docs we see that PE_ArrowUp, PE_ArrowDown, PE_ArrowLeft and PE_ArrowRight are the primitives we need to do +something with. We get the following in our drawPrimitive() function: +

+CustomStyle::CustomStyle()
+{
+}
+
+CustomStyle::~CustomStyle()
+{
+}
+
+void CustomStyle::drawPrimitive( PrimitiveElement pe,
+                                 TQPainter * p,
+                                 const TQRect & r,
+                                 const TQColorGroup & cg,
+                                 SFlags flags,
+                                 const TQStyleOption & opt ) const
+{
+    // we are only interested in the arrows
+    if (pe >= PE_ArrowUp && pe <= PE_ArrowLeft) {
+        TQPointArray pa( 3 );
+        // make the arrow cover half the area it is supposed to be 
+        // painted on
+        int x = r.x();
+        int y = r.y();
+        int w = r.width() / 2;
+        int h = r.height() / 2;
+        x += (r.width() - w) / 2;
+        y += (r.height() - h) /2;
+
+        switch( pe ) {
+        case PE_ArrowDown:
+            pa.setPoint( 0, x, y );
+            pa.setPoint( 1, x + w, y );
+            pa.setPoint( 2, x + w / 2, y + h );
+            break;
+        case PE_ArrowUp:
+            pa.setPoint( 0, x, y + h );
+            pa.setPoint( 1, x + w, y + h );
+            pa.setPoint( 2, x + w / 2, y );
+            break;
+        case PE_ArrowLeft:
+            pa.setPoint( 0, x + w, y );
+            pa.setPoint( 1, x + w, y + h );
+            pa.setPoint( 2, x, y + h / 2 );
+            break;
+        case PE_ArrowRight:
+            pa.setPoint( 0, x, y );
+            pa.setPoint( 1, x, y + h );
+            pa.setPoint( 2, x + w, y + h / 2 );
+            break;
+        default: break;
+            
+        }
+
+        // use different colors to indicate that the arrow is 
+        // enabled/disabled
+        if ( flags & Style_Enabled ) {
+            p->setPen( cg.mid() );
+            p->setBrush( cg.brush( TQColorGroup::ButtonText ) );
+        } else {
+            p->setPen( cg.buttonText() );
+            p->setBrush( cg.brush( TQColorGroup::Mid ) );
+        }
+        p->drawPolygon( pa );
+    } else {
+        // let the base style handle the other primitives
+        TQWindowsStyle::drawPrimitive( pe, p, r, cg, flags, data );
+    }
+}
+

+ +

Using a custom style +

There are several ways of using a custom style in a TQt application. +The simplest way is to include the following lines of code in the +application's main() function: +

+#include "customstyle.h"
+
+int main( int argc, char ** argv )
+{
+    TQApplication::setStyle( new CustomStyle() );
+    // do the usual routine on creating your TQApplication object etc.
+}
+

+ +

Note that you must also include the customstyle.h and customstyle.cpp files in your project. +

2. Creating and using a pluggable style +

You may want to make your style available for use in other +applications, some of which may not be yours and are not available for +you to recompile. The TQt Plugin system makes it possible to create +styles as plugins. Styles created as plugins are loaded as shared +objects at runtime by TQt itself. Please refer to the TQt Plugin documentation for more +information on how to go about creating a style plugin. +

Compile your plugin and put it into $QTDIR/plugins/styles. We now have +a pluggable style that TQt can load automatically. To use your new +style with existing applications, simply start the application with +the following argument: +

+./application -style custom
+

+ +

The application will use the look and feel from the custom style you +implemented. +

+ +

Trademarks +

TQt 3.3.8

+ -- cgit v1.2.1