Home | All Classes | Main Classes | Annotated | Grouped Classes | Functions |

# Two simple Qt widgets (in-process)

The ActiveX controls in this example are simple QWidget subclasses reimplementing the paintEvent() method.

It demonstrates the implementation of a QAxFactory to provide multiple ActiveX controls in a single in process ActiveX server, and the use of the QAXFACTORY_EXPORT macro.

The first control draws a filled rectangle. The fill color is exposed as a property.

        class QAxWidget1 : public QWidget
        {
            Q_OBJECT
            Q_PROPERTY( QColor fillColor READ fillColor WRITE setFillColor )
        public:
            QAxWidget1( QWidget *parent = 0, const char *name = 0, WFlags f = 0 )
                : QWidget( parent, name, f ), fill_color( red )
            {
            }

            QColor fillColor() const
            {
                return fill_color;
            }
            void setFillColor( const QColor &fc )
            {
                fill_color = fc;
                repaint();
            }

        protected:
            void paintEvent( QPaintEvent *e )
            {
                QPainter paint( this );
                QRect r = rect();
                r.addCoords( 10, 10, -10, -10 );
                paint.fillRect( r, fill_color );
            }

        private:
            QColor fill_color;
        };

The second control draws a circle. The linewith is exposed as a property.

        class QAxWidget2 : public QWidget
        {
            Q_OBJECT
            Q_PROPERTY( int lineWidth READ lineWidth WRITE setLineWidth )
        public:
            QAxWidget2( QWidget *parent = 0, const char *name = 0, WFlags f = 0 )
                : QWidget( parent, name, f ), line_width( 1 )
            {
            }

            int lineWidth() const
            {
                return line_width;
            }
            void setLineWidth( int lw )
            {
                line_width = lw;
                repaint();
            }

        protected:
            void paintEvent( QPaintEvent *e )
            {
                QPainter paint( this );
                QPen pen = paint.pen();
                pen.setWidth( line_width );
                paint.setPen( pen );

                QRect r = rect();
                r.addCoords( 10, 10, -10, -10 );
                paint.drawEllipse( r );
            }

        private:
            int line_width;
        };

The controls are provided by an implementation of the QAxFactory.

The constructor just propagates the identifiers for the type library and the application to the QAxFactory.

        class ActiveQtFactory : public QAxFactory
        {
        public:
            ActiveQtFactory( const QUuid &lib, const QUuid &app )
                : QAxFactory( lib, app )
            {}

The featureList implementation returns the class names of the controls.

            QStringList featureList() const
            {
                QStringList list;
                list << "QAxWidget1";
                list << "QAxWidget2";
                return list;
            }

The implementations of the factory functions return the value for the requested key.

            QWidget *create( const QString &key, QWidget *parent, const char *name )
            {
                if ( key == "QAxWidget1" )
                    return new QAxWidget1( parent, name );
                if ( key == "QAxWidget2" )
                    return new QAxWidget2( parent, name );

                return 0;
            }
            QUuid classID( const QString &key ) const
            {
                if ( key == "QAxWidget1" )
                    return QUuid( "{1D9928BD-4453-4bdd-903D-E525ED17FDE5}" );
                if ( key == "QAxWidget2" )
                    return QUuid( "{58139D56-6BE9-4b17-937D-1B1EDEDD5B71}" );

                return QUuid();
            }
            QUuid interfaceID( const QString &key ) const
            {
                if ( key == "QAxWidget1" )
                    return QUuid( "{99F6860E-2C5A-42ec-87F2-43396F4BE389}" );
                if ( key == "QAxWidget2" )
                    return QUuid( "{B66280AB-08CC-4dcc-924F-58E6D7975B7D}" );

                return QUuid();
            }
            QUuid eventsID( const QString &key ) const
            {
                if ( key == "QAxWidget1" )
                    return QUuid( "{0A3E9F27-E4F1-45bb-9E47-63099BCCD0E3}" );
                if ( key == "QAxWidget2" )
                    return QUuid( "{D72BACBA-03C4-4480-B4BB-DE4FE3AA14A0}" );

                return QUuid();
            }

The `exposeToSuperClass` implementations returns the key for the "QAxWidget2", and calls the default implementation otherwise. The QAxWidget2 control will not expose properties or methods of any parent class, while QAxWidget1 exposes all properties, signals and slots of QWidget and QObject, too.

            QString exposeToSuperClass( const QString &key ) const
            {
                if ( key == "QAxWidget2" )
                    return key;
                return QAxFactory::exposeToSuperClass( key );
            }

The `hasStockEvents` implementation returns TRUE for the "QAxWidget2", and FALSE otherwise. The QAxWidget2 control will fire OLE stock events when the user interacts with the control.

            bool hasStockEvents( const QString &key ) const
            {
                if ( key == "QAxWidget2" )
                    return TRUE;
                return FALSE;
            }
        };

The factory is exported from the server using the QAXFACTORY_EXPORT macro. The implementation of `main` is just a dummy, but required for the linker.

        QAXFACTORY_EXPORT( ActiveQtFactory, "{98DE28B6-6CD3-4e08-B9FA-3D1DB43F1D2F}", "{05828915-AD1C-47ab-AB96-D6AD1E25F0E2}" )

To build the example you must first build the QAxServer library. Then run qmake and your make tool in `examples/multiple`.

The demonstration requires your WebBrowser to support ActiveX controls, and scripting to be enabled.

        <script language=javascript>
        function setColor( form )
        {
            Ax1.fillColor = form.colorEdit.value;
        }

        function setWidth( form )
        {
            Ax2.lineWidth = form.widthEdit.value;
        }
        </script>

        <p>
        This is one QWidget subclass:<br>
        <object ID="Ax1" CLASSID="CLSID:1D9928BD-4453-4bdd-903D-E525ED17FDE5"
        CODEBASE=http://www.trolltech.com/demos/multipleax.cab>
        [Object not available! Did you forget to build and register the server?]
        </object><br>
        <form>
        Fill Color: <input type="edit" ID="colorEdit" value = "red">
        <input type="button" value = "Set" onClick="setColor(this.form)">
        <input type="button" value = "Hide" onClick="Ax1.hide()">
        <input type="button" value = "Show" onClick="Ax1.show()">
        </form>

        <p>
        This is another QWidget subclass:<br>
        <object ID="Ax2" CLASSID="CLSID:58139D56-6BE9-4b17-937D-1B1EDEDD5B71"
        CODEBASE=http://www.trolltech.com/demos/multipleax.cab>
        [Object not available! Did you forget to build and register the server?]
        </object><br>
        <form>
        Line width: <input type="edit" ID="widthEdit" value = "1">
        <input type="button" value = "Set" onClick="setWidth(this.form)">
        </form>

See also The QAxServer Examples.