svtools/source/plugapp/commtest.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: commtest.cxx,v $
  10  * $Revision: 1.6 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svtools.hxx"
  33 #include <vcl/svapp.hxx>
  34 #include <vcl/wrkwin.hxx>
  35 #include <vcl/toolbox.hxx>
  36
  37
  38 #include <tools/simplecm.hxx>
  39 #include "communi.hxx"
  40 #include "brooker.hxx"
  41 //#include <tools/bcst.hxx>
  42
  43 #include "commtest.hrc"
  44
  45
  46
  47 #define TCP_PORT 17612
  48
  49 #define CUniString( constAsciiStr ) UniString( RTL_CONSTASCII_USTRINGPARAM ( constAsciiStr ) )
  50
  51
  52 class PacketSender : public Timer
  53 {
  54     SvStream* mpData;
  55     CommunicationLinkRef mxCL;
  56
  57 public:
  58     PacketSender( ULONG nDelay, SvStream* pData, CommunicationLink* pCL );
  59     virtual void    Timeout();
  60 };
  61
  62 PacketSender::PacketSender( ULONG nDelay, SvStream* pData, CommunicationLink* pCL )
  63 : mpData( pData )
  64 , mxCL( pCL )
  65 {
  66     SetTimeout( nDelay );
  67     Start();
  68 }
  69
  70 void PacketSender::Timeout()
  71 {
  72     mxCL->TransferDataStream( mpData );
  73     delete mpData;
  74     delete this;
  75 }
  76
  77
  78
  79 class DelayedDeleter : public Timer
  80 {
  81     CommunicationManager *mpManager;
  82
  83 public:
  84     DelayedDeleter( ULONG nDelay, CommunicationManager *pManager );
  85     virtual void    Timeout();
  86 };
  87
  88 DelayedDeleter::DelayedDeleter( ULONG nDelay, CommunicationManager *pManager )
  89 : mpManager( pManager )
  90 {
  91     SetTimeout( nDelay );
  92     Start();
  93 }
  94
  95 void DelayedDeleter::Timeout()
  96 {
  97     delete mpManager;
  98     delete this;
  99 }
 100
 101
 102
 103
 104 class CommunicationTester : public Application
 105 {
 106     DECL_LINK( TBClick, ToolBox* );
 107     DECL_LINK( DataReceived, CommunicationLink* );
 108     DECL_LINK( ConnectionOpened, CommunicationLink* );
 109     DECL_LINK( ConnectionClosed, CommunicationLink* );
 110
 111
 112     CommunicationManager *pClientTcp, *pServerTcp;
 113     InformationBroadcaster *pBCSTSend;
 114     InformationBroadcaster *pBCSTListen;
 115     InformationBrooker *pBCSTBrooker;
 116 public:
 117     CommunicationTester();
 118
 119     virtual void Main();
 120 };
 121
 122 CommunicationTester IchSelber;
 123
 124 CommunicationTester::CommunicationTester()
 125 : pClientTcp( NULL )
 126 , pServerTcp( NULL )
 127 , pBCSTSend( NULL )
 128 , pBCSTListen( NULL )
 129 , pBCSTBrooker( NULL )
 130 {}
 131
 132 void CommunicationTester::Main()
 133 {
 134     ResMgr *pRes = ResMgr::CreateResMgr( "commtest" );
 135     Resource::SetResManager( pRes );
 136     WorkWindow aWW( NULL, WB_APP | WB_STDWORK );
 137     aWW.Show();
 138     ToolBox aTB( &aWW, ResId( TBMenu ) );
 139     aTB.Show();
 140     aTB.RecalcItems();
 141     aTB.SetFloatingMode( TRUE );
 142     aTB.SetFloatingMode( FALSE );
 143     aTB.SetClickHdl( LINK( this, CommunicationTester, TBClick ) );
 144
 145     Execute();
 146 }
 147
 148 #define SWITCH( pManager, ManagerClass )                                        \
 149 {                                                                                                                       \
 150     if ( pManager )                                                                                     \
 151     {                                                                                                           \
 152         pManager->StopCommunication();                                          \
 153         new DelayedDeleter( 1000, pManager );                           \
 154         pTB->SetItemState( pTB->GetCurItemId(), STATE_NOCHECK );        \
 155         pManager = NULL;                                                                        \
 156     }                                                                                                           \
 157     else                                                                                                        \
 158     {                                                                                                           \
 159         pManager = new ManagerClass;                                            \
 160         pManager->SetConnectionOpenedHdl( LINK( this, CommunicationTester, ConnectionOpened ) );\
 161         pManager->SetConnectionClosedHdl( LINK( this, CommunicationTester, ConnectionClosed ) );\
 162         pManager->SetDataReceivedHdl( LINK( this, CommunicationTester, DataReceived ) );\
 163         pTB->SetItemState( pTB->GetCurItemId(), STATE_CHECK );  \
 164     }                                                                                                           \
 165 }
 166
 167
 168 IMPL_LINK( CommunicationTester, TBClick, ToolBox*, pTB )
 169 {
 170     switch ( pTB->GetCurItemId() )
 171     {
 172         case SERVER_TCP:
 173             {
 174                 SWITCH( pServerTcp, CommunicationManagerServerViaSocket( TCP_PORT, (USHORT) 32000 ) );
 175                 if ( pServerTcp )
 176                     pServerTcp->StartCommunication();   // Am Port horchen
 177             }
 178             break;
 179         case CLIENT_TCP:
 180             {
 181                 SWITCH( pClientTcp, CommunicationManagerClientViaSocket( "localhost", TCP_PORT ) );
 182                 if ( pClientTcp )
 183                     pClientTcp->StartCommunication();   // Eine Verbindung aufbauen
 184             }
 185             break;
 186         case BCST_BROOKER:
 187             {
 188                 if ( pBCSTBrooker )
 189                 {
 190                     delete pBCSTBrooker;
 191                     pBCSTBrooker = NULL;
 192                 }
 193                 else
 194                 {
 195                     pBCSTBrooker = new InformationBrooker();
 196                 }
 197             }
 198             break;
 199         case BCST_LISTEN:
 200             {
 201                 if ( pBCSTListen )
 202                 {
 203                     delete pBCSTListen;
 204                     pBCSTListen = NULL;
 205                 }
 206                 else
 207                 {
 208                     pBCSTListen = new InformationBroadcaster();
 209                 }
 210             }
 211         case BCST_SEND:
 212             {
 213                 if ( pBCSTSend )
 214                 {
 215                     pBCSTSend->Broadcast( BCST_CAT_PL2X,      "Message: BCST_CAT_PL2X" );
 216                     pBCSTSend->Broadcast( BCST_CAT_MINORCOPY, "Message: BCST_CAT_MINORCOPY" );
 217                     pBCSTSend->Broadcast( BCST_CAT_DELIVER,   "Message: BCST_CAT_DELIVER" );
 218                     pBCSTSend->Broadcast( BCST_CAT_ALL,       "Message: BCST_CAT_ALL" );
 219                 }
 220                 else
 221                 {
 222                     pBCSTSend = new InformationBroadcaster();
 223                 }
 224             }
 225             break;
 226     }
 227     return 0;
 228 }
 229
 230 IMPL_LINK( CommunicationTester, ConnectionOpened, CommunicationLink*, pCL )
 231 {
 232     SvStream *pData = pCL->GetBestCommunicationStream();
 233     while ( pData->Tell() < 70 ) *pData << 123;
 234
 235     pCL->TransferDataStream( pData );
 236     return 0;
 237 }
 238
 239 IMPL_LINK( CommunicationTester, ConnectionClosed, CommunicationLink*, pCL )
 240 {
 241     return 0;
 242 }
 243
 244 IMPL_LINK( CommunicationTester, DataReceived, CommunicationLink*, pCL )
 245 {
 246     // Find Manager
 247     CommunicationManager* pManager;
 248     if ( pClientTcp && pClientTcp->IsLinkValid( pCL ) )
 249     {
 250         pManager = pClientTcp;
 251     }
 252     if ( pServerTcp && pServerTcp->IsLinkValid( pCL ) )
 253     {
 254         DBG_ASSERT( !pManager, "CommunicationLink bei mehreren Managern eingetragen");
 255         pManager = pServerTcp;
 256     }
 257     DBG_ASSERT( pCL->GetCommunicationManager() == pManager, "Manager des Link != Manager bei dem der Link Valid ist");
 258
 259     // Send Data Back (Echo)
 260     new PacketSender( 1000, pCL->GetServiceData(), pCL );
 261
 262     return 0;
 263 }
 264