1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the Qt Mobility Components.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "bearercloud.h"

    43 #include "cloud.h"

    44 

    45 #include <QGraphicsTextItem>

    46 #include <QTimer>

    47 #include <QDateTime>

    48 #include <QHostInfo>

    49 

    50 #include <QDebug>

    51 

    52 #include <math.h>

    53 

    54 #ifndef M_PI

    55 #define M_PI 3.14159265358979323846

    56 #endif

    57 

    58 //! [0]

    59 BearerCloud::BearerCloud(QObject *parent)

    60 :   QGraphicsScene(parent), timerId(0)

    61 {

    62     setSceneRect(-300, -300, 600, 600);

    63 

    64     qsrand(QDateTime::currentDateTime().toTime_t());

    65 

    66     offset[QNetworkConfiguration::Active] = 2 * M_PI * qrand() / RAND_MAX;

    67     offset[QNetworkConfiguration::Discovered] = offset[QNetworkConfiguration::Active] + M_PI / 6;

    68     offset[QNetworkConfiguration::Defined] = offset[QNetworkConfiguration::Discovered] - M_PI / 6;

    69     offset[QNetworkConfiguration::Undefined] = offset[QNetworkConfiguration::Undefined] + M_PI / 6;

    70 

    71     thisDevice = new QGraphicsTextItem(QHostInfo::localHostName());

    72     thisDevice->setData(0, QLatin1String("This Device"));

    73     thisDevice->setPos(thisDevice->boundingRect().width() / -2,

    74                        thisDevice->boundingRect().height() / -2);

    75     addItem(thisDevice);

    76 

    77     qreal radius = Cloud::getRadiusForState(QNetworkConfiguration::Active);

    78     QGraphicsEllipseItem *orbit = new QGraphicsEllipseItem(-radius, -radius, 2*radius, 2*radius);

    79     orbit->setPen(QColor(Qt::green));

    80     addItem(orbit);

    81     radius = Cloud::getRadiusForState(QNetworkConfiguration::Discovered);

    82     orbit = new QGraphicsEllipseItem(-radius, -radius, 2*radius, 2*radius);

    83     orbit->setPen(QColor(Qt::blue));

    84     addItem(orbit);

    85     radius = Cloud::getRadiusForState(QNetworkConfiguration::Defined);

    86     orbit = new QGraphicsEllipseItem(-radius, -radius, 2*radius, 2*radius);

    87     orbit->setPen(QColor(Qt::darkGray));

    88     addItem(orbit);

    89     radius = Cloud::getRadiusForState(QNetworkConfiguration::Undefined);

    90     orbit = new QGraphicsEllipseItem(-radius, -radius, 2*radius, 2*radius);

    91     orbit->setPen(QColor(Qt::lightGray));

    92     addItem(orbit);

    93 

    94     connect(&manager, SIGNAL(configurationAdded(QNetworkConfiguration)),

    95             this, SLOT(configurationAdded(QNetworkConfiguration)));

    96     connect(&manager, SIGNAL(configurationRemoved(QNetworkConfiguration)),

    97             this, SLOT(configurationRemoved(QNetworkConfiguration)));

    98     connect(&manager, SIGNAL(configurationChanged(QNetworkConfiguration)),

    99             this, SLOT(configurationChanged(QNetworkConfiguration)));

   100 

   101     QTimer::singleShot(0, this, SLOT(updateConfigurations()));

   102 }

   103 //! [0]

   104 

   105 BearerCloud::~BearerCloud()

   106 {

   107 }

   108 

   109 void BearerCloud::cloudMoved()

   110 {

   111     if (!timerId)

   112         timerId = startTimer(1000 / 25);

   113 }

   114 

   115 void BearerCloud::timerEvent(QTimerEvent *)

   116 {

   117     QList<Cloud *> clouds;

   118     foreach (QGraphicsItem *item, items()) {

   119         if (Cloud *cloud = qgraphicsitem_cast<Cloud *>(item))

   120             clouds << cloud;

   121     }

   122 

   123     foreach (Cloud *cloud, clouds)

   124         cloud->calculateForces();

   125 

   126     bool cloudsMoved = false;

   127     foreach (Cloud *cloud, clouds)

   128         cloudsMoved |= cloud->advance();

   129 

   130     if (!cloudsMoved) {

   131         killTimer(timerId);

   132         timerId = 0;

   133     }

   134 }

   135 

   136 //! [2]

   137 void BearerCloud::configurationAdded(const QNetworkConfiguration &config)

   138 {

   139     const QNetworkConfiguration::StateFlags state = config.state();

   140 

   141     configStates.insert(state, config.identifier());

   142 

   143     const qreal radius = Cloud::getRadiusForState(state);

   144     const int count = configStates.count(state);

   145     const qreal angle = 2 * M_PI / count;

   146 

   147     Cloud *item = new Cloud(config);

   148     configurations.insert(config.identifier(), item);

   149 

   150     item->setPos(radius * cos((count-1) * angle + offset[state]),

   151                  radius * sin((count-1) * angle + offset[state]));

   152 

   153     addItem(item);

   154 

   155     cloudMoved();

   156 }

   157 //! [2]

   158 

   159 //! [3]

   160 void BearerCloud::configurationRemoved(const QNetworkConfiguration &config)

   161 {

   162     foreach (const QNetworkConfiguration::StateFlags &state, configStates.uniqueKeys())

   163         configStates.remove(state, config.identifier());

   164 

   165     Cloud *item = configurations.take(config.identifier());

   166 

   167     item->setFinalScale(0.0);

   168     item->setDeleteAfterAnimation(true);

   169 

   170     cloudMoved();

   171 }

   172 //! [3]

   173 

   174 //! [4]

   175 void BearerCloud::configurationChanged(const QNetworkConfiguration &config)

   176 {

   177     foreach (const QNetworkConfiguration::StateFlags &state, configStates.uniqueKeys())

   178         configStates.remove(state, config.identifier());

   179 

   180     configStates.insert(config.state(), config.identifier());

   181 

   182     cloudMoved();

   183 }

   184 //! [4]

   185 

   186 //! [1]

   187 void BearerCloud::updateConfigurations()

   188 {

   189     QList<QNetworkConfiguration> allConfigurations = manager.allConfigurations();

   190 

   191     while (!allConfigurations.isEmpty())

   192         configurationAdded(allConfigurations.takeFirst());

   193 

   194     cloudMoved();

   195 }

   196 //! [1]

   197