?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bump product version to 5.0.4.1
[LibreOffice.git] / svl / source / svdde / ddesvr.cxx
blob923222b7b9a19e18cd0fa319da21f43edb9abbd9
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20
21 #define UNICODE
22 #include "ddeimp.hxx"
23 #include <algorithm>
24 #include <comphelper/string.hxx>
25 #include <rtl/ustring.hxx>
26 #include <svl/svdde.hxx>
27 #include <tools/debug.hxx>
28 #include <osl/thread.h>
29 #include <o3tl/sorted_vector.hxx>
30
31 enum DdeItemType
32 {
33 DDEITEM,
34 DDEGETPUTITEM
35 };
36
37 struct DdeItemImpData
38 {
39 sal_uLong nHCnv;
40 sal_uInt16 nCnt;
41
42 DdeItemImpData( sal_uLong nH ) : nHCnv( nH ), nCnt( 1 ) {}
43 };
44
45 class DdeItemImp {
46 public:
47 DdeItemImp() : mvData() {}
48
49 size_t size() const { return mvData.size(); }
50
51 std::vector<DdeItemImpData>::iterator begin() { return mvData.begin(); }
52
53 void erase(std::vector<DdeItemImpData>::iterator it) { mvData.erase(it); }
54
55 void push_back(const DdeItemImpData& rData) { mvData.push_back(rData); }
56
57 DdeItemImpData& operator[](size_t i) { return mvData[i]; }
58
59 private:
60 std::vector<DdeItemImpData> mvData;
61 };
62
63 HDDEDATA CALLBACK DdeInternal::SvrCallback(
64 WORD nCode, WORD nCbType, HCONV hConv, HSZ hText1, HSZ hText2,
65 HDDEDATA hData, DWORD, DWORD )
66 {
67 DdeServices& rAll = DdeService::GetServices();
68 DdeService* pService;
69 DdeTopic* pTopic;
70 DdeItem* pItem;
71 DdeData* pData;
72 Conversation* pC;
73
74 DdeInstData* pInst = ImpGetInstData();
75 DBG_ASSERT(pInst,"SVDDE:No instance data");
76
77 switch( nCode )
78 {
79 case XTYP_WILDCONNECT:
80 {
81 int nTopics = 0;
82
83 TCHAR chTopicBuf[250];
84 if( hText1 )
85 DdeQueryString( pInst->hDdeInstSvr, hText1, chTopicBuf,
86 sizeof(chTopicBuf)/sizeof(TCHAR), CP_WINUNICODE );
87
88 for (DdeServices::iterator aI = rAll.begin(); aI != rAll.end(); ++aI)
89 {
90 pService = *aI;
91 if ( !hText2 || ( *pService->pName == hText2 ) )
92 {
93 OUString sTopics( pService->Topics() );
94 if (!sTopics.isEmpty())
95 {
96 if( hText1 )
97 {
98 sal_Int32 n = 0;
99 while( -1 != n )
100 {
101 OUString s( sTopics.getToken( 0, '\t', n ));
102 if( s == reinterpret_cast<const sal_Unicode*>(chTopicBuf) )
103 ++nTopics;
104 }
105 }
106 else
107 nTopics += comphelper::string::getTokenCount(sTopics, '\t');
108 }
109 }
110 }
111
112 if( !nTopics )
113 return (HDDEDATA)NULL;
114
115 HSZPAIR* pPairs = new HSZPAIR [nTopics + 1];
116
117 HSZPAIR* q = pPairs;
118 for (DdeServices::iterator aI = rAll.begin(); aI != rAll.end(); ++aI)
119 {
120 pService = *aI;
121 if ( !hText2 || (*pService->pName == hText2 ) )
122 {
123 OUString sTopics( pService->Topics() );
124 sal_Int32 n = 0;
125 while( -1 != n )
126 {
127 OUString s( sTopics.getToken( 0, '\t', n ));
128 s = comphelper::string::remove(s, '\n');
129 s = comphelper::string::remove(s, '\r');
130 if( !hText1 || s == reinterpret_cast<const sal_Unicode*>(chTopicBuf) )
131 {
132 DdeString aDStr( pInst->hDdeInstSvr, s );
133 pTopic = FindTopic( *pService, (HSZ)aDStr );
134 if( pTopic )
135 {
136 q->hszSvc = *pService->pName;
137 q->hszTopic = *pTopic->pName;
138 q++;
139 }
140 }
141 }
142 }
143 }
144
145 q->hszSvc = NULL;
146 q->hszTopic = NULL;
147 HDDEDATA h = DdeCreateDataHandle(
148 pInst->hDdeInstSvr, (LPBYTE) pPairs,
149 sizeof(HSZPAIR) * (nTopics+1),
150 0, NULL, nCbType, 0);
151 delete [] pPairs;
152 return h;
153 }
154
155 case XTYP_CONNECT:
156 pService = FindService( hText2 );
157 if ( pService)
158 pTopic = FindTopic( *pService, hText1 );
159 else
160 pTopic = NULL;
161 if ( pTopic )
162 return (HDDEDATA)DDE_FACK;
163 else
164 return (HDDEDATA) NULL;
165
166 case XTYP_CONNECT_CONFIRM:
167 pService = FindService( hText2 );
168 if ( pService )
169 {
170 pTopic = FindTopic( *pService, hText1 );
171 if ( pTopic )
172 {
173 pTopic->Connect( (sal_IntPtr) hConv );
174 pC = new Conversation;
175 pC->hConv = hConv;
176 pC->pTopic = pTopic;
177 pService->pConv->push_back( pC );
178 }
179 }
180 return (HDDEDATA)NULL;
181 }
182
183 for (DdeServices::iterator aI = rAll.begin(); aI != rAll.end(); ++aI)
184 {
185 pService = *aI;
186 for ( size_t i = 0, n = pService->pConv->size(); i < n; ++i )
187 {
188 pC = (*pService->pConv)[ i ];
189 if ( pC->hConv == hConv )
190 goto found;
191 }
192 }
193
194 return (HDDEDATA) DDE_FNOTPROCESSED;
195
196 found:
197 if ( nCode == XTYP_DISCONNECT)
198 {
199 pC->pTopic->_Disconnect( (sal_IntPtr) hConv );
200 for ( ConvList::iterator it = pService->pConv->begin();
201 it != pService->pConv->end();
202 ++it
203 ) {
204 if ( *it == pC )
205 {
206 delete *it;
207 pService->pConv->erase( it );
208 break;
209 }
210 }
211 return (HDDEDATA)NULL;
212 }
213
214 bool bExec = nCode == XTYP_EXECUTE;
215 pTopic = pC->pTopic;
216 if ( pTopic && !bExec )
217 pItem = FindItem( *pTopic, hText2 );
218 else
219 pItem = NULL;
220
221 if ( !bExec && !pService->HasCbFormat( nCbType ) )
222 pItem = NULL;
223 if ( !pItem && !bExec )
224 return (HDDEDATA)DDE_FNOTPROCESSED;
225 if ( pItem )
226 pTopic->aItem = pItem->GetName();
227 else
228 (pTopic->aItem).clear();
229
230 bool bRes = false;
231 pInst->hCurConvSvr = (sal_IntPtr)hConv;
232 switch( nCode )
233 {
234 case XTYP_REQUEST:
235 case XTYP_ADVREQ:
236 {
237 OUString aRes; // Must be free not until the end!
238 if ( pTopic->IsSystemTopic() )
239 {
240 if ( pTopic->aItem == reinterpret_cast<const sal_Unicode*>(SZDDESYS_ITEM_TOPICS) )
241 aRes = pService->Topics();
242 else if ( pTopic->aItem == reinterpret_cast<const sal_Unicode*>(SZDDESYS_ITEM_SYSITEMS) )
243 aRes = pService->SysItems();
244 else if ( pTopic->aItem == reinterpret_cast<const sal_Unicode*>(SZDDESYS_ITEM_STATUS) )
245 aRes = pService->Status();
246 else if ( pTopic->aItem == reinterpret_cast<const sal_Unicode*>(SZDDESYS_ITEM_FORMATS) )
247 aRes = pService->Formats();
248 else if ( pTopic->aItem == reinterpret_cast<const sal_Unicode*>(SZDDESYS_ITEM_HELP) )
249 aRes = pService->GetHelp();
250 else
251 aRes = pService->SysTopicGet( pTopic->aItem );
252
253 if ( !aRes.isEmpty() )
254 pData = new DdeData( aRes );
255 else
256 pData = NULL;
257 }
258 else if( DDEGETPUTITEM == pItem->nType )
259 {
260 pData = ((DdeGetPutItem*)pItem)->Get( DdeData::GetInternalFormat( nCbType ) );
261 }
262 else
263 {
264 pData = pTopic->Get( DdeData::GetInternalFormat( nCbType ));
265 }
266
267 if ( pData )
268 {
269 return DdeCreateDataHandle( pInst->hDdeInstSvr,
270 (LPBYTE)pData->pImp->pData,
271 pData->pImp->nData,
272 0, hText2,
273 DdeData::GetExternalFormat(
274 pData->pImp->nFmt ),
275 0 );
276 }
277 }
278 break;
279
280 case XTYP_POKE:
281 if ( !pTopic->IsSystemTopic() )
282 {
283 DdeData d;
284 d.pImp->hData = hData;
285 d.pImp->nFmt = DdeData::GetInternalFormat( nCbType );
286 d.Lock();
287 if( DDEGETPUTITEM == pItem->nType )
288 bRes = ((DdeGetPutItem*)pItem)->Put( &d );
289 else
290 bRes = pTopic->Put( &d );
291 }
292 pInst->hCurConvSvr = 0;
293 if ( bRes )
294 return (HDDEDATA)DDE_FACK;
295 else
296 return (HDDEDATA) DDE_FNOTPROCESSED;
297
298 case XTYP_ADVSTART:
299 {
300 // Is the Item turning into a HotLink for the first time?
301 if( !pItem->pImpData && pTopic->StartAdviseLoop() )
302 {
303 // Then the Item has been exchanged
304 std::vector<DdeItem*>::iterator it(std::find(pTopic->aItems.begin(),
305 pTopic->aItems.end(),
306 pItem));
307 if (it != pTopic->aItems.end())
308 pTopic->aItems.erase(it);
309
310 std::vector<DdeItem*>::iterator iter;
311 for( iter = pTopic->aItems.begin();
312 iter != pTopic->aItems.end();
313 ++iter )
314 {
315 if( *(*iter)->pName == hText2 )
316 {
317 // It was exchanged indeed
318 delete pItem;
319 pItem = 0;
320 break;
321 }
322 }
323
324 if( pItem )
325 // It was not exchange, so back in
326 pTopic->aItems.push_back(pItem);
327 else
328 pItem = iter != pTopic->aItems.end() ? *iter : NULL;
329 }
330
331 if (pItem)
332 {
333 pItem->IncMonitor( (sal_IntPtr)hConv );
334 pInst->hCurConvSvr = 0;
335 }
336 }
337 return (HDDEDATA)sal_True;
338
339 case XTYP_ADVSTOP:
340 pItem->DecMonitor( (sal_IntPtr)hConv );
341 if( !pItem->pImpData )
342 pTopic->StopAdviseLoop();
343 pInst->hCurConvSvr = 0;
344 return (HDDEDATA)sal_True;
345
346 case XTYP_EXECUTE:
347 {
348 DdeData aExec;
349 aExec.pImp->hData = hData;
350 aExec.pImp->nFmt = DdeData::GetInternalFormat( nCbType );
351 aExec.Lock();
352 OUString aName;
353
354 aName = (const sal_Unicode *)aExec.pImp->pData;
355
356 if( pTopic->IsSystemTopic() )
357 bRes = pService->SysTopicExecute( &aName );
358 else
359 bRes = pTopic->Execute( &aName );
360 }
361 pInst->hCurConvSvr = 0;
362 if ( bRes )
363 return (HDDEDATA)DDE_FACK;
364 else
365 return (HDDEDATA)DDE_FNOTPROCESSED;
366 }
367
368 return (HDDEDATA)NULL;
369 }
370
371 DdeService* DdeInternal::FindService( HSZ hService )
372 {
373 DdeServices& rSvc = DdeService::GetServices();
374 for (DdeServices::iterator aI = rSvc.begin(); aI != rSvc.end(); ++aI)
375 {
376 DdeService* s = *aI;
377 if ( *s->pName == hService )
378 return s;
379 }
380
381 return NULL;
382 }
383
384 DdeTopic* DdeInternal::FindTopic( DdeService& rService, HSZ hTopic )
385 {
386 std::vector<DdeTopic*>::iterator iter;
387 std::vector<DdeTopic*> &rTopics = rService.aTopics;
388 bool bContinue = false;
389 DdeInstData* pInst = ImpGetInstData();
390 DBG_ASSERT(pInst,"SVDDE:No instance data");
391
392 do
393 { // middle check loop
394 for ( iter = rTopics.begin(); iter != rTopics.end(); ++iter )
395 {
396 if ( *(*iter)->pName == hTopic )
397 return *iter;
398 }
399
400 bContinue = !bContinue;
401 if( !bContinue )
402 break;
403
404 // Let's query our subclass
405 TCHAR chBuf[250];
406 DdeQueryString(pInst->hDdeInstSvr,hTopic,chBuf,sizeof(chBuf)/sizeof(TCHAR),CP_WINUNICODE );
407 bContinue = rService.MakeTopic( reinterpret_cast<const sal_Unicode*>(chBuf) );
408 // We need to search again
409 }
410 while( bContinue );
411
412 return 0;
413 }
414
415 DdeItem* DdeInternal::FindItem( DdeTopic& rTopic, HSZ hItem )
416 {
417 std::vector<DdeItem*>::iterator iter;
418 std::vector<DdeItem*> &rItems = rTopic.aItems;
419 DdeInstData* pInst = ImpGetInstData();
420 DBG_ASSERT(pInst,"SVDDE:No instance data");
421 bool bContinue = false;
422
423 do
424 { // middle check loop
425 for ( iter = rItems.begin(); iter != rItems.end(); ++iter )
426 {
427 if ( *(*iter)->pName == hItem )
428 return *iter;
429 }
430 bContinue = !bContinue;
431 if( !bContinue )
432 break;
433
434 // Let's query our subclass
435 TCHAR chBuf[250];
436 DdeQueryString(pInst->hDdeInstSvr,hItem,chBuf,sizeof(chBuf)/sizeof(TCHAR),CP_WINUNICODE );
437 bContinue = rTopic.MakeItem( reinterpret_cast<const sal_Unicode*>(chBuf) );
438 // We need to search again
439 }
440 while( bContinue );
441
442 return 0;
443 }
444
445 DdeService::DdeService( const OUString& rService )
446 {
447 DdeInstData* pInst = ImpGetInstData();
448 if( !pInst )
449 pInst = ImpInitInstData();
450 pInst->nRefCount++;
451 pInst->nInstanceSvr++;
452
453 if ( !pInst->hDdeInstSvr )
454 {
455 nStatus = sal::static_int_cast< short >(
456 DdeInitialize( &pInst->hDdeInstSvr,
457 (PFNCALLBACK)DdeInternal::SvrCallback,
458 APPCLASS_STANDARD |
459 CBF_SKIP_REGISTRATIONS |
460 CBF_SKIP_UNREGISTRATIONS, 0L ) );
461 pInst->pServicesSvr = new DdeServices;
462 }
463 else
464 nStatus = DMLERR_NO_ERROR;
465
466 pConv = new ConvList;
467
468 if ( pInst->pServicesSvr )
469 pInst->pServicesSvr->push_back( this );
470
471 pName = new DdeString( pInst->hDdeInstSvr, rService );
472 if ( nStatus == DMLERR_NO_ERROR )
473 {
474 if ( !DdeNameService( pInst->hDdeInstSvr, *pName, NULL,
475 DNS_REGISTER | DNS_FILTEROFF ) )
476 {
477 nStatus = DMLERR_SYS_ERROR;
478 }
479 }
480 AddFormat( SotClipboardFormatId::STRING );
481 pSysTopic = new DdeTopic( reinterpret_cast<const sal_Unicode*>(SZDDESYS_TOPIC) );
482 pSysTopic->AddItem( DdeItem( reinterpret_cast<const sal_Unicode*>(SZDDESYS_ITEM_TOPICS) ) );
483 pSysTopic->AddItem( DdeItem( reinterpret_cast<const sal_Unicode*>(SZDDESYS_ITEM_SYSITEMS) ) );
484 pSysTopic->AddItem( DdeItem( reinterpret_cast<const sal_Unicode*>(SZDDESYS_ITEM_STATUS) ) );
485 pSysTopic->AddItem( DdeItem( reinterpret_cast<const sal_Unicode*>(SZDDESYS_ITEM_FORMATS) ) );
486 pSysTopic->AddItem( DdeItem( reinterpret_cast<const sal_Unicode*>(SZDDESYS_ITEM_HELP) ) );
487 AddTopic( *pSysTopic );
488 }
489
490 DdeService::~DdeService()
491 {
492 DdeInstData* pInst = ImpGetInstData();
493 DBG_ASSERT(pInst,"SVDDE:No instance data");
494 if ( pInst->pServicesSvr )
495 pInst->pServicesSvr->erase(std::remove(pInst->pServicesSvr->begin(), pInst->pServicesSvr->end(), this), pInst->pServicesSvr->end());
496
497 delete pSysTopic;
498 delete pName;
499
500 pInst->nInstanceSvr--;
501 pInst->nRefCount--;
502 if ( !pInst->nInstanceSvr && pInst->hDdeInstSvr )
503 {
504 if( DdeUninitialize( pInst->hDdeInstSvr ) )
505 {
506 pInst->hDdeInstSvr = 0;
507 delete pInst->pServicesSvr;
508 pInst->pServicesSvr = NULL;
509 if( pInst->nRefCount == 0)
510 ImpDeinitInstData();
511 }
512 }
513 delete pConv;
514 }
515
516 const OUString DdeService::GetName() const
517 {
518 return pName->toOUString();
519 }
520
521 DdeServices& DdeService::GetServices()
522 {
523 DdeInstData* pInst = ImpGetInstData();
524 DBG_ASSERT(pInst,"SVDDE:No instance data");
525 return *(pInst->pServicesSvr);
526 }
527
528 void DdeService::AddTopic( const DdeTopic& rTopic )
529 {
530 RemoveTopic( rTopic );
531 aTopics.push_back((DdeTopic *) &rTopic);
532 }
533
534 void DdeService::RemoveTopic( const DdeTopic& rTopic )
535 {
536 std::vector<DdeTopic*>::iterator iter;
537 for ( iter = aTopics.begin(); iter != aTopics.end(); ++iter )
538 {
539 if ( !DdeCmpStringHandles (*(*iter)->pName, *rTopic.pName ) )
540 {
541 aTopics.erase(iter);
542 // Delete all conversions!
543 // Or else we work on deleted topics!
544 for( size_t n = pConv->size(); n; )
545 {
546 Conversation* pC = (*pConv)[ --n ];
547 if( pC->pTopic == &rTopic )
548 {
549 ConvList::iterator it = pConv->begin();
550 ::std::advance( it, n );
551 delete *it;
552 pConv->erase( it );
553 }
554 }
555 break;
556 }
557 }
558 }
559
560 bool DdeService::HasCbFormat( sal_uInt16 nFmt )
561 {
562 for ( size_t i = 0, n = aFormats.size(); i < n; ++i )
563 if ( aFormats[ i ] == nFmt )
564 return true;
565 return false;
566 }
567
568 bool DdeService::HasFormat(SotClipboardFormatId nFmt)
569 {
570 return HasCbFormat( (sal_uInt16)DdeData::GetExternalFormat( nFmt ));
571 }
572
573 void DdeService::AddFormat(SotClipboardFormatId nFmt)
574 {
575 sal_uLong nExternalFmt = DdeData::GetExternalFormat( nFmt );
576 for ( size_t i = 0, n = aFormats.size(); i < n; ++i )
577 if ( (sal_uLong) aFormats[ i ] == nExternalFmt )
578 return;
579 aFormats.push_back( nExternalFmt );
580 }
581
582 void DdeService::RemoveFormat(SotClipboardFormatId nFmt)
583 {
584 sal_uLong nExternalFmt = DdeData::GetExternalFormat( nFmt );
585 for ( DdeFormats::iterator it = aFormats.begin(); it != aFormats.end(); ++it )
586 {
587 if ( (sal_uLong) *it == nExternalFmt )
588 {
589 aFormats.erase( it );
590 break;
591 }
592 }
593 }
594
595 DdeTopic::DdeTopic( const OUString& rName )
596 {
597 DdeInstData* pInst = ImpGetInstData();
598 DBG_ASSERT(pInst,"SVDDE:No instance data");
599 pName = new DdeString( pInst->hDdeInstSvr, rName );
600 }
601
602 DdeTopic::~DdeTopic()
603 {
604 std::vector<DdeItem*>::iterator iter;
605 for (iter = aItems.begin(); iter != aItems.end(); ++iter)
606 {
607 (*iter)->pMyTopic = 0;
608 delete *iter;
609 }
610
611 delete pName;
612 }
613
614 const OUString DdeTopic::GetName() const
615 {
616 return pName->toOUString();
617 }
618
619 bool DdeTopic::IsSystemTopic()
620 {
621 return GetName() == reinterpret_cast<const sal_Unicode*>(SZDDESYS_TOPIC);
622 }
623
624 DdeItem* DdeTopic::AddItem( const DdeItem& r )
625 {
626 DdeItem* s;
627 if( DDEGETPUTITEM == r.nType )
628 s = new DdeGetPutItem( r );
629 else
630 s = new DdeItem( r );
631
632 if ( s )
633 {
634 aItems.push_back( s );
635 s->pMyTopic = this;
636 }
637 return s;
638 }
639
640 void DdeTopic::InsertItem( DdeItem* pNew )
641 {
642 if( pNew )
643 {
644 aItems.push_back( pNew );
645 pNew->pMyTopic = this;
646 }
647 }
648
649 void DdeTopic::RemoveItem( const DdeItem& r )
650 {
651 std::vector<DdeItem*>::iterator iter;
652 for (iter = aItems.begin(); iter != aItems.end(); ++iter)
653 {
654 if ( !DdeCmpStringHandles (*(*iter)->pName, *r.pName ) )
655 break;
656 }
657
658 if ( iter != aItems.end() )
659 {
660 (*iter)->pMyTopic = 0;
661 delete *iter;
662 aItems.erase(iter);
663 }
664 }
665
666 void DdeTopic::NotifyClient( const OUString& rItem )
667 {
668 std::vector<DdeItem*>::iterator iter;
669 DdeInstData* pInst = ImpGetInstData();
670 DBG_ASSERT(pInst,"SVDDE:No instance data");
671 for ( iter = aItems.begin(); iter != aItems.end(); ++iter)
672 {
673 if ( (*iter)->GetName().equals(rItem) && (*iter)->pImpData)
674 {
675 DdePostAdvise( pInst->hDdeInstSvr, *pName, *(*iter)->pName );
676 break;
677 }
678 }
679 }
680
681 void DdeTopic::Connect( sal_IntPtr nId )
682 {
683 aConnectLink.Call( (void*)nId );
684 }
685
686 void DdeTopic::Disconnect( sal_IntPtr nId )
687 {
688 aDisconnectLink.Call( (void*)nId );
689 }
690
691 void DdeTopic::_Disconnect( sal_IntPtr nId )
692 {
693 std::vector<DdeItem*>::iterator iter;
694 for (iter = aItems.begin(); iter != aItems.end(); ++iter)
695 (*iter)->DecMonitor( nId );
696
697 Disconnect( nId );
698 }
699
700 DdeData* DdeTopic::Get(SotClipboardFormatId nFmt)
701 {
702 if ( aGetLink.IsSet() )
703 return (DdeData*)aGetLink.Call( (void*)nFmt );
704 else
705 return NULL;
706 }
707
708 bool DdeTopic::Put( const DdeData* r )
709 {
710 if ( aPutLink.IsSet() )
711 return aPutLink.Call( (void*) r );
712 else
713 return false;
714 }
715
716 bool DdeTopic::Execute( const OUString* r )
717 {
718 if ( aExecLink.IsSet() )
719 return aExecLink.Call( (void*)r );
720 else
721 return false;
722 }
723
724 long DdeTopic::GetConvId()
725 {
726 DdeInstData* pInst = ImpGetInstData();
727 DBG_ASSERT(pInst,"SVDDE:No instance data");
728 return pInst->hCurConvSvr;
729 }
730
731 bool DdeTopic::StartAdviseLoop()
732 {
733 return false;
734 }
735
736 bool DdeTopic::StopAdviseLoop()
737 {
738 return false;
739 }
740
741 DdeItem::DdeItem( const sal_Unicode* p )
742 {
743 DdeInstData* pInst = ImpGetInstData();
744 DBG_ASSERT(pInst,"SVDDE:No instance data");
745 pName = new DdeString( pInst->hDdeInstSvr, p );
746 nType = DDEITEM;
747 pMyTopic = 0;
748 pImpData = 0;
749 }
750
751 DdeItem::DdeItem( const OUString& r)
752 {
753 DdeInstData* pInst = ImpGetInstData();
754 DBG_ASSERT(pInst,"SVDDE:No instance data");
755 pName = new DdeString( pInst->hDdeInstSvr, r );
756 nType = DDEITEM;
757 pMyTopic = 0;
758 pImpData = 0;
759 }
760
761 DdeItem::DdeItem( const DdeItem& r)
762 {
763 DdeInstData* pInst = ImpGetInstData();
764 DBG_ASSERT(pInst,"SVDDE:No instance data");
765 pName = new DdeString( pInst->hDdeInstSvr, r.pName->toOUString() );
766 nType = DDEITEM;
767 pMyTopic = 0;
768 pImpData = 0;
769 }
770
771 DdeItem::~DdeItem()
772 {
773 if( pMyTopic )
774 pMyTopic->aItems.erase(std::remove(pMyTopic->aItems.begin(),
775 pMyTopic->aItems.end(),this));
776 delete pName;
777 delete pImpData;
778 }
779
780 const OUString DdeItem::GetName() const
781 {
782 return pName->toOUString();
783 }
784
785 void DdeItem::NotifyClient()
786 {
787 if( pMyTopic && pImpData )
788 {
789 DdeInstData* pInst = ImpGetInstData();
790 DBG_ASSERT(pInst,"SVDDE:No instance data");
791 DdePostAdvise( pInst->hDdeInstSvr, *pMyTopic->pName, *pName );
792 }
793 }
794
795 void DdeItem::IncMonitor( sal_uLong nHCnv )
796 {
797 if( !pImpData )
798 {
799 pImpData = new DdeItemImp;
800 if( DDEGETPUTITEM == nType )
801 ((DdeGetPutItem*)this)->AdviseLoop( true );
802 }
803 else
804 {
805 for( sal_uInt16 n = pImpData->size(); n; )
806 if( (*pImpData)[ --n ].nHCnv == nHCnv )
807 {
808 ++(*pImpData)[ n ].nHCnv;
809 return ;
810 }
811 }
812
813 pImpData->push_back( DdeItemImpData( nHCnv ) );
814 }
815
816 void DdeItem::DecMonitor( sal_uLong nHCnv )
817 {
818 if( pImpData )
819 {
820 for( sal_uInt16 n = 0; n < pImpData->size(); ++n )
821 {
822 DdeItemImpData* pData = &(*pImpData)[n];
823 if( pData->nHCnv == nHCnv )
824 {
825 if( !pData->nCnt || !--pData->nCnt )
826 {
827 if( 1 < pImpData->size() )
828 {
829 pImpData->erase(pImpData->begin() + n);
830 }
831 else
832 {
833 delete pImpData, pImpData = 0;
834 if( DDEGETPUTITEM == nType )
835 ((DdeGetPutItem*)this)->AdviseLoop( false );
836 }
837 }
838 return ;
839 }
840 }
841 }
842 }
843
844 short DdeItem::GetLinks()
845 {
846 short nCnt = 0;
847 if( pImpData )
848 {
849 for( sal_uInt16 n = pImpData->size(); n; )
850 {
851 nCnt = nCnt + (*pImpData)[ --n ].nCnt;
852 }
853 }
854 return nCnt;
855 }
856
857 DdeGetPutItem::DdeGetPutItem( const sal_Unicode* p )
858 : DdeItem( p )
859 {
860 nType = DDEGETPUTITEM;
861 }
862
863 DdeGetPutItem::DdeGetPutItem( const OUString& rStr )
864 : DdeItem( rStr )
865 {
866 nType = DDEGETPUTITEM;
867 }
868
869 DdeGetPutItem::DdeGetPutItem( const DdeItem& rItem )
870 : DdeItem( rItem )
871 {
872 nType = DDEGETPUTITEM;
873 }
874
875 DdeData* DdeGetPutItem::Get(SotClipboardFormatId)
876 {
877 return 0;
878 }
879
880 bool DdeGetPutItem::Put( const DdeData* )
881 {
882 return false;
883 }
884
885 void DdeGetPutItem::AdviseLoop( bool )
886 {
887 }
888
889 OUString DdeService::SysItems()
890 {
891 OUString s;
892 std::vector<DdeTopic*>::iterator iter;
893 std::vector<DdeItem*>::iterator iterItem;
894 for ( iter = aTopics.begin(); iter != aTopics.end(); ++iter )
895 {
896 if ( (*iter)->GetName() == reinterpret_cast<const sal_Unicode*>(SZDDESYS_TOPIC) )
897 {
898 short n = 0;
899 for ( iterItem = (*iter)->aItems.begin(); iterItem != (*iter)->aItems.end(); ++iterItem, n++ )
900 {
901 if ( n )
902 s += "\t";
903 s += (*iterItem)->GetName();
904 }
905 s += "\r\n";
906 }
907 }
908
909 return s;
910 }
911
912 OUString DdeService::Topics()
913 {
914 OUString s;
915 std::vector<DdeTopic*>::iterator iter;
916 short n = 0;
917
918 for ( iter = aTopics.begin(); iter != aTopics.end(); ++iter, n++ )
919 {
920 if ( n )
921 s += "\t";
922 s += (*iter)->GetName();
923 }
924 s += "\r\n";
925
926 return s;
927 }
928
929 OUString DdeService::Formats()
930 {
931 OUString s;
932 short n = 0;
933
934 for (size_t i = 0; i < aFormats.size(); ++i, ++n)
935 {
936 long f = aFormats[ i ];
937 if ( n )
938 s += "\t";
939
940 switch( (sal_uInt16)f )
941 {
942 case CF_TEXT:
943 s += "TEXT";
944 break;
945 case CF_BITMAP:
946 s += "BITMAP";
947 break;
948 default:
949 {
950 TCHAR buf[128];
951 GetClipboardFormatName( (UINT)f, buf, sizeof(buf) / sizeof(TCHAR) );
952 s += OUString(reinterpret_cast<sal_Unicode*>(buf));
953 }
954 break;
955 }
956
957 }
958 s += "\r\n";
959
960 return s;
961 }
962
963 OUString DdeService::Status()
964 {
965 return IsBusy() ? OUString("Busy\r\n") : OUString("Ready\r\n");
966 }
967
968 bool DdeService::IsBusy()
969 {
970 return false;
971 }
972
973 OUString DdeService::GetHelp()
974 {
975 return OUString();
976 }
977
978 bool DdeTopic::MakeItem( const OUString& )
979 {
980 return false;
981 }
982
983 bool DdeService::MakeTopic( const OUString& )
984 {
985 return false;
986 }
987
988 OUString DdeService::SysTopicGet( const OUString& )
989 {
990 return OUString();
991 }
992
993 bool DdeService::SysTopicExecute( const OUString* )
994 {
995 return false;
996 }
997
998 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE