Line data Source code
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 : #include <string.h>
21 : #include <vcl/svpforlokit.hxx>
22 : #include <vcl/syswin.hxx>
23 :
24 : #include "headless/svpframe.hxx"
25 : #include "headless/svpinst.hxx"
26 : #include "headless/svpgdi.hxx"
27 :
28 : #include <basebmp/bitmapdevice.hxx>
29 : #include <basebmp/scanlineformats.hxx>
30 : #include <basegfx/vector/b2ivector.hxx>
31 :
32 : using namespace basebmp;
33 : using namespace basegfx;
34 :
35 : SvpSalFrame* SvpSalFrame::s_pFocusFrame = NULL;
36 :
37 : #ifdef IOS
38 : #define SvpSalGraphics AquaSalGraphics
39 : #endif
40 :
41 : #ifndef IOS
42 :
43 : namespace {
44 : /// Decouple SalFrame lifetime from damagetracker lifetime
45 0 : struct DamageTracker : public basebmp::IBitmapDeviceDamageTracker
46 : {
47 0 : virtual ~DamageTracker() {}
48 0 : virtual void damaged( const basegfx::B2IBox& ) const SAL_OVERRIDE {}
49 : };
50 : }
51 :
52 0 : void SvpSalFrame::enableDamageTracker( bool bOn )
53 : {
54 0 : if( m_bDamageTracking == bOn )
55 0 : return;
56 0 : if( m_aFrame.get() )
57 : {
58 0 : if( m_bDamageTracking )
59 0 : m_aFrame->setDamageTracker( basebmp::IBitmapDeviceDamageTrackerSharedPtr() );
60 : else
61 : m_aFrame->setDamageTracker(
62 0 : basebmp::IBitmapDeviceDamageTrackerSharedPtr( new DamageTracker ) );
63 : }
64 0 : m_bDamageTracking = bOn;
65 : }
66 :
67 : #endif
68 :
69 6925 : SvpSalFrame::SvpSalFrame( SvpSalInstance* pInstance,
70 : SalFrame* pParent,
71 : sal_uLong nSalFrameStyle,
72 : bool bTopDown,
73 : basebmp::Format nScanlineFormat,
74 : SystemParentData* ) :
75 : m_pInstance( pInstance ),
76 : m_pParent( static_cast<SvpSalFrame*>(pParent) ),
77 : m_nStyle( nSalFrameStyle ),
78 : m_bVisible( false ),
79 : m_bTopDown( bTopDown ),
80 : #ifndef IOS
81 : m_bDamageTracking( false ),
82 : #endif
83 : m_nScanlineFormat( nScanlineFormat ),
84 : m_nMinWidth( 0 ),
85 : m_nMinHeight( 0 ),
86 : m_nMaxWidth( 0 ),
87 6925 : m_nMaxHeight( 0 )
88 : {
89 : // SAL_DEBUG("SvpSalFrame::SvpSalFrame: " << this);
90 : // fast and easy cross-platform wiping of the data
91 6925 : memset( static_cast<void *>(&m_aSystemChildData), 0, sizeof( SystemEnvData ) );
92 6925 : m_aSystemChildData.nSize = sizeof( SystemEnvData );
93 : #ifdef IOS
94 : // Nothing
95 : #elif defined ANDROID
96 : // Nothing
97 : #else
98 6925 : m_aSystemChildData.pSalFrame = this;
99 6925 : m_aSystemChildData.nDepth = 24;
100 : #endif
101 :
102 6925 : if( m_pParent )
103 3295 : m_pParent->m_aChildren.push_back( this );
104 :
105 6925 : if( m_pInstance )
106 6925 : m_pInstance->registerFrame( this );
107 :
108 6925 : SetPosSize( 0, 0, 800, 600, SAL_FRAME_POSSIZE_WIDTH | SAL_FRAME_POSSIZE_HEIGHT );
109 6925 : }
110 :
111 20727 : SvpSalFrame::~SvpSalFrame()
112 : {
113 6909 : if( m_pInstance )
114 6909 : m_pInstance->deregisterFrame( this );
115 :
116 6909 : std::list<SvpSalFrame*> Children = m_aChildren;
117 20727 : for( std::list<SvpSalFrame*>::iterator it = Children.begin();
118 13818 : it != Children.end(); ++it )
119 0 : (*it)->SetParent( m_pParent );
120 6909 : if( m_pParent )
121 3293 : m_pParent->m_aChildren.remove( this );
122 :
123 6909 : if( s_pFocusFrame == this )
124 : {
125 : // SAL_DEBUG("SvpSalFrame::~SvpSalFrame: losing focus: " << this);
126 9 : s_pFocusFrame = NULL;
127 : // call directly here, else an event for a destroyed frame would be dispatched
128 9 : CallCallback( SALEVENT_LOSEFOCUS, NULL );
129 : // if the handler has not set a new focus frame
130 : // pass focus to another frame, preferably a document style window
131 9 : if( s_pFocusFrame == NULL )
132 : {
133 9 : const std::list< SalFrame* >& rFrames( m_pInstance->getFrames() );
134 21 : for( std::list< SalFrame* >::const_iterator it = rFrames.begin(); it != rFrames.end(); ++it )
135 : {
136 16 : SvpSalFrame* pFrame = const_cast<SvpSalFrame*>(static_cast<const SvpSalFrame*>(*it));
137 20 : if( pFrame->m_bVisible &&
138 8 : pFrame->m_pParent == NULL &&
139 4 : (pFrame->m_nStyle & (SAL_FRAME_STYLE_MOVEABLE |
140 : SAL_FRAME_STYLE_SIZEABLE |
141 : SAL_FRAME_STYLE_CLOSEABLE) ) != 0
142 : )
143 : {
144 4 : pFrame->GetFocus();
145 4 : break;
146 : }
147 : }
148 : }
149 6909 : }
150 13818 : }
151 :
152 9665 : void SvpSalFrame::GetFocus()
153 : {
154 9665 : if( s_pFocusFrame == this )
155 16136 : return;
156 :
157 3194 : if( (m_nStyle & (SAL_FRAME_STYLE_OWNERDRAWDECORATION | SAL_FRAME_STYLE_FLOAT)) == 0 )
158 : {
159 3194 : if( s_pFocusFrame )
160 30 : s_pFocusFrame->LoseFocus();
161 : // SAL_DEBUG("SvpSalFrame::GetFocus(): " << this);
162 3194 : s_pFocusFrame = this;
163 3194 : m_pInstance->PostEvent( this, NULL, SALEVENT_GETFOCUS );
164 : }
165 : }
166 :
167 3215 : void SvpSalFrame::LoseFocus()
168 : {
169 3215 : if( s_pFocusFrame == this )
170 : {
171 : // SAL_DEBUG("SvpSalFrame::LoseFocus: " << this);
172 3180 : m_pInstance->PostEvent( this, NULL, SALEVENT_LOSEFOCUS );
173 3180 : s_pFocusFrame = NULL;
174 : }
175 3215 : }
176 :
177 256157 : SalGraphics* SvpSalFrame::AcquireGraphics()
178 : {
179 256157 : SvpSalGraphics* pGraphics = new SvpSalGraphics();
180 : #ifndef IOS
181 256157 : pGraphics->setDevice( m_aFrame );
182 : #endif
183 256157 : m_aGraphics.push_back( pGraphics );
184 256157 : return pGraphics;
185 : }
186 :
187 255799 : void SvpSalFrame::ReleaseGraphics( SalGraphics* pGraphics )
188 : {
189 255799 : SvpSalGraphics* pSvpGraphics = dynamic_cast<SvpSalGraphics*>(pGraphics);
190 255799 : m_aGraphics.remove( pSvpGraphics );
191 255799 : delete pSvpGraphics;
192 255799 : }
193 :
194 99080 : bool SvpSalFrame::PostEvent( void* pData )
195 : {
196 99080 : m_pInstance->PostEvent( this, pData, SALEVENT_USEREVENT );
197 99080 : return true;
198 : }
199 :
200 2949 : void SvpSalFrame::PostPaint(bool bImmediate) const
201 : {
202 2949 : if( m_bVisible )
203 : {
204 2944 : SalPaintEvent aPEvt(0, 0, maGeometry.nWidth, maGeometry.nHeight);
205 2944 : aPEvt.mbImmediateUpdate = bImmediate;
206 2944 : CallCallback( SALEVENT_PAINT, &aPEvt );
207 : }
208 2949 : }
209 :
210 6792 : void SvpSalFrame::SetTitle( const OUString& )
211 : {
212 6792 : }
213 :
214 3278 : void SvpSalFrame::SetIcon( sal_uInt16 )
215 : {
216 3278 : }
217 :
218 0 : void SvpSalFrame::SetMenu( SalMenu* )
219 : {
220 0 : }
221 :
222 0 : void SvpSalFrame::DrawMenuBar()
223 : {
224 0 : }
225 :
226 4952 : void SvpSalFrame::SetExtendedFrameStyle( SalExtStyle )
227 : {
228 4952 : }
229 :
230 6378 : void SvpSalFrame::Show( bool bVisible, bool bNoActivate )
231 : {
232 6378 : if( bVisible && ! m_bVisible )
233 : {
234 : // SAL_DEBUG("SvpSalFrame::Show: showing: " << this);
235 3191 : m_bVisible = true;
236 3191 : m_pInstance->PostEvent( this, NULL, SALEVENT_RESIZE );
237 6382 : if( ! bNoActivate )
238 3179 : GetFocus();
239 : }
240 3187 : else if( ! bVisible && m_bVisible )
241 : {
242 : // SAL_DEBUG("SvpSalFrame::Show: hiding: " << this);
243 3185 : m_bVisible = false;
244 3185 : m_pInstance->PostEvent( this, NULL, SALEVENT_RESIZE );
245 3185 : LoseFocus();
246 : }
247 : else
248 : {
249 : // SAL_DEBUG("SvpSalFrame::Show: nothihg: " << this);
250 : }
251 6378 : }
252 :
253 2 : void SvpSalFrame::SetMinClientSize( long nWidth, long nHeight )
254 : {
255 2 : m_nMinWidth = nWidth;
256 2 : m_nMinHeight = nHeight;
257 2 : }
258 :
259 0 : void SvpSalFrame::SetMaxClientSize( long nWidth, long nHeight )
260 : {
261 0 : m_nMaxWidth = nWidth;
262 0 : m_nMaxHeight = nHeight;
263 0 : }
264 :
265 16128 : void SvpSalFrame::SetPosSize( long nX, long nY, long nWidth, long nHeight, sal_uInt16 nFlags )
266 : {
267 16128 : if( (nFlags & SAL_FRAME_POSSIZE_X) != 0 )
268 3120 : maGeometry.nX = nX;
269 16128 : if( (nFlags & SAL_FRAME_POSSIZE_Y) != 0 )
270 3120 : maGeometry.nY = nY;
271 16128 : if( (nFlags & SAL_FRAME_POSSIZE_WIDTH) != 0 )
272 : {
273 16112 : maGeometry.nWidth = nWidth;
274 16112 : if( m_nMaxWidth > 0 && maGeometry.nWidth > (unsigned int)m_nMaxWidth )
275 0 : maGeometry.nWidth = m_nMaxWidth;
276 16112 : if( m_nMinWidth > 0 && maGeometry.nWidth < (unsigned int)m_nMinWidth )
277 0 : maGeometry.nWidth = m_nMinWidth;
278 : }
279 16128 : if( (nFlags & SAL_FRAME_POSSIZE_HEIGHT) != 0 )
280 : {
281 16112 : maGeometry.nHeight = nHeight;
282 16112 : if( m_nMaxHeight > 0 && maGeometry.nHeight > (unsigned int)m_nMaxHeight )
283 0 : maGeometry.nHeight = m_nMaxHeight;
284 16112 : if( m_nMinHeight > 0 && maGeometry.nHeight < (unsigned int)m_nMinHeight )
285 0 : maGeometry.nHeight = m_nMinHeight;
286 : }
287 : #ifndef IOS
288 16128 : B2IVector aFrameSize( maGeometry.nWidth, maGeometry.nHeight );
289 16128 : if( ! m_aFrame.get() || m_aFrame->getSize() != aFrameSize )
290 : {
291 10793 : if( aFrameSize.getX() == 0 )
292 3 : aFrameSize.setX( 1 );
293 10793 : if( aFrameSize.getY() == 0 )
294 3 : aFrameSize.setY( 1 );
295 10793 : sal_Int32 nStride = basebmp::getBitmapDeviceStrideForWidth(m_nScanlineFormat, aFrameSize.getX());
296 10793 : m_aFrame = createBitmapDevice( aFrameSize, m_bTopDown, m_nScanlineFormat, nStride );
297 10793 : if (m_bDamageTracking)
298 : m_aFrame->setDamageTracker(
299 0 : basebmp::IBitmapDeviceDamageTrackerSharedPtr( new DamageTracker ) );
300 : // update device in existing graphics
301 113220 : for( std::list< SvpSalGraphics* >::iterator it = m_aGraphics.begin();
302 75480 : it != m_aGraphics.end(); ++it )
303 : {
304 26947 : (*it)->setDevice( m_aFrame );
305 : }
306 : }
307 16128 : if( m_bVisible )
308 13 : m_pInstance->PostEvent( this, NULL, SALEVENT_RESIZE );
309 : #endif
310 16128 : }
311 :
312 6443 : void SvpSalFrame::GetClientSize( long& rWidth, long& rHeight )
313 : {
314 6443 : if( m_bVisible )
315 : {
316 3019 : rWidth = maGeometry.nWidth;
317 3019 : rHeight = maGeometry.nHeight;
318 : }
319 : else
320 3424 : rWidth = rHeight = 0;
321 6443 : }
322 :
323 10544 : void SvpSalFrame::GetWorkArea( Rectangle& rRect )
324 : {
325 : rRect = Rectangle( Point( 0, 0 ),
326 10544 : Size( VIRTUAL_DESKTOP_WIDTH, VIRTUAL_DESKTOP_HEIGHT ) );
327 10544 : }
328 :
329 24779 : SalFrame* SvpSalFrame::GetParent() const
330 : {
331 24779 : return m_pParent;
332 : }
333 :
334 : #define _FRAMESTATE_MASK_GEOMETRY \
335 : (WINDOWSTATE_MASK_X | WINDOWSTATE_MASK_Y | \
336 : WINDOWSTATE_MASK_WIDTH | WINDOWSTATE_MASK_HEIGHT)
337 :
338 3209 : void SvpSalFrame::SetWindowState( const SalFrameState *pState )
339 : {
340 3209 : if (pState == NULL)
341 3209 : return;
342 :
343 : // Request for position or size change
344 3209 : if (pState->mnMask & _FRAMESTATE_MASK_GEOMETRY)
345 : {
346 3092 : long nX = maGeometry.nX;
347 3092 : long nY = maGeometry.nY;
348 3092 : long nWidth = maGeometry.nWidth;
349 3092 : long nHeight = maGeometry.nHeight;
350 :
351 : // change requested properties
352 3092 : if (pState->mnMask & WINDOWSTATE_MASK_X)
353 3092 : nX = pState->mnX;
354 3092 : if (pState->mnMask & WINDOWSTATE_MASK_Y)
355 3092 : nY = pState->mnY;
356 3092 : if (pState->mnMask & WINDOWSTATE_MASK_WIDTH)
357 3092 : nWidth = pState->mnWidth;
358 3092 : if (pState->mnMask & WINDOWSTATE_MASK_HEIGHT)
359 3092 : nHeight = pState->mnHeight;
360 :
361 : SetPosSize( nX, nY, nWidth, nHeight,
362 : SAL_FRAME_POSSIZE_X | SAL_FRAME_POSSIZE_Y |
363 3092 : SAL_FRAME_POSSIZE_WIDTH | SAL_FRAME_POSSIZE_HEIGHT );
364 : }
365 : }
366 :
367 12876 : bool SvpSalFrame::GetWindowState( SalFrameState* pState )
368 : {
369 12876 : pState->mnState = WINDOWSTATE_STATE_NORMAL;
370 12876 : pState->mnX = maGeometry.nX;
371 12876 : pState->mnY = maGeometry.nY;
372 12876 : pState->mnWidth = maGeometry.nWidth;
373 12876 : pState->mnHeight = maGeometry.nHeight;
374 12876 : pState->mnMask = _FRAMESTATE_MASK_GEOMETRY | WINDOWSTATE_MASK_STATE;
375 :
376 12876 : return true;
377 : }
378 :
379 0 : void SvpSalFrame::ShowFullScreen( bool, sal_Int32 )
380 : {
381 : SetPosSize( 0, 0, VIRTUAL_DESKTOP_WIDTH, VIRTUAL_DESKTOP_HEIGHT,
382 0 : SAL_FRAME_POSSIZE_WIDTH | SAL_FRAME_POSSIZE_HEIGHT );
383 0 : }
384 :
385 0 : void SvpSalFrame::StartPresentation( bool )
386 : {
387 0 : }
388 :
389 0 : void SvpSalFrame::SetAlwaysOnTop( bool )
390 : {
391 0 : }
392 :
393 6482 : void SvpSalFrame::ToTop( sal_uInt16 )
394 : {
395 6482 : GetFocus();
396 6482 : }
397 :
398 3 : void SvpSalFrame::SetPointer( PointerStyle )
399 : {
400 3 : }
401 :
402 8 : void SvpSalFrame::CaptureMouse( bool )
403 : {
404 8 : }
405 :
406 4 : void SvpSalFrame::SetPointerPos( long, long )
407 : {
408 4 : }
409 :
410 73437 : void SvpSalFrame::Flush()
411 : {
412 73437 : }
413 :
414 0 : void SvpSalFrame::Sync()
415 : {
416 0 : }
417 :
418 5537 : void SvpSalFrame::SetInputContext( SalInputContext* )
419 : {
420 5537 : }
421 :
422 0 : void SvpSalFrame::EndExtTextInput( EndExtTextInputFlags )
423 : {
424 0 : }
425 :
426 43180 : OUString SvpSalFrame::GetKeyName( sal_uInt16 )
427 : {
428 43180 : return OUString();
429 : }
430 :
431 0 : bool SvpSalFrame::MapUnicodeToKeyCode( sal_Unicode, LanguageType, vcl::KeyCode& )
432 : {
433 0 : return false;
434 : }
435 :
436 3059 : LanguageType SvpSalFrame::GetInputLanguage()
437 : {
438 3059 : return LANGUAGE_DONTKNOW;
439 : }
440 :
441 666 : void SvpSalFrame::UpdateSettings( AllSettings& )
442 : {
443 666 : }
444 :
445 0 : void SvpSalFrame::Beep()
446 : {
447 0 : }
448 :
449 8900 : const SystemEnvData* SvpSalFrame::GetSystemData() const
450 : {
451 8900 : return &m_aSystemChildData;
452 : }
453 :
454 249 : SalFrame::SalPointerState SvpSalFrame::GetPointerState()
455 : {
456 249 : SalPointerState aState;
457 249 : aState.mnState = 0;
458 249 : return aState;
459 : }
460 :
461 0 : KeyIndicatorState SvpSalFrame::GetIndicatorState()
462 : {
463 0 : return KeyIndicatorState::NONE;
464 : }
465 :
466 0 : void SvpSalFrame::SimulateKeyPress( sal_uInt16 /*nKeyCode*/ )
467 : {
468 0 : }
469 :
470 2464 : void SvpSalFrame::SetParent( SalFrame* pNewParent )
471 : {
472 2464 : if( m_pParent )
473 2464 : m_pParent->m_aChildren.remove( this );
474 2464 : m_pParent = static_cast<SvpSalFrame*>(pNewParent);
475 2464 : }
476 :
477 0 : bool SvpSalFrame::SetPluginParent( SystemParentData* )
478 : {
479 0 : return true;
480 : }
481 :
482 0 : void SvpSalFrame::ResetClipRegion()
483 : {
484 0 : }
485 :
486 0 : void SvpSalFrame::BeginSetClipRegion( sal_uLong )
487 : {
488 0 : }
489 :
490 0 : void SvpSalFrame::UnionClipRegion( long, long, long, long )
491 : {
492 0 : }
493 :
494 0 : void SvpSalFrame::EndSetClipRegion()
495 : {
496 0 : }
497 :
498 0 : SalFrame* GetSvpFocusFrameForLibreOfficeKit()
499 : {
500 0 : return SvpSalFrame::GetFocusFrame();
501 : }
502 :
503 0 : vcl::Window* GetSalFrameWindowForLibreOfficeKit(SalFrame *pSF)
504 : {
505 0 : return pSF->GetWindow();
506 801 : }
507 :
508 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
