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 <svl/eitem.hxx>
21 : #include <svl/stritem.hxx>
22 : #include <sfx2/app.hxx>
23 : #include <sfx2/module.hxx>
24 : #include <sfx2/sfxsids.hrc>
25 : #include <dialmgr.hxx>
26 : #include <svx/dlgutil.hxx>
27 : #include <editeng/sizeitem.hxx>
28 : #include <editeng/brushitem.hxx>
29 : #include <grfpage.hxx>
30 : #include <svx/grfcrop.hxx>
31 : #include <rtl/ustring.hxx>
32 : #include <cuires.hrc>
33 : #include <tools/fract.hxx>
34 : #include <svx/dialogs.hrc>
35 : #include <vcl/builderfactory.hxx>
36 : #include <vcl/settings.hxx>
37 : #include <boost/scoped_ptr.hpp>
38 :
39 : #define CM_1_TO_TWIP 567
40 : #define TWIP_TO_INCH 1440
41 :
42 :
43 0 : static inline long lcl_GetValue( MetricField& rMetric, FieldUnit eUnit )
44 : {
45 0 : return static_cast<long>(rMetric.Denormalize( rMetric.GetValue( eUnit )));
46 : }
47 :
48 : /*--------------------------------------------------------------------
49 : description: crop graphic
50 : --------------------------------------------------------------------*/
51 :
52 0 : SvxGrfCropPage::SvxGrfCropPage ( vcl::Window *pParent, const SfxItemSet &rSet )
53 : : SfxTabPage(pParent, "CropPage", "cui/ui/croppage.ui", &rSet)
54 : , pLastCropField(0)
55 : , nOldWidth(0)
56 : , nOldHeight(0)
57 : , bReset(false)
58 : , bInitialized(false)
59 0 : , bSetOrigSize(false)
60 : {
61 0 : get(m_pCropFrame, "cropframe");
62 0 : get(m_pScaleFrame, "scaleframe");
63 0 : get(m_pSizeFrame, "sizeframe");
64 0 : get(m_pOrigSizeGrid, "origsizegrid");
65 0 : get(m_pZoomConstRB, "keepscale");
66 0 : get(m_pSizeConstRB, "keepsize");
67 0 : get(m_pOrigSizeFT, "origsizeft");
68 0 : get(m_pOrigSizePB, "origsize");
69 0 : get(m_pLeftMF, "left");
70 0 : get(m_pRightMF, "right");
71 0 : get(m_pTopMF, "top");
72 0 : get(m_pBottomMF, "bottom");
73 0 : get(m_pWidthZoomMF, "widthzoom");
74 0 : get(m_pHeightZoomMF, "heightzoom");
75 0 : get(m_pWidthMF, "width");
76 0 : get(m_pHeightMF, "height");
77 0 : get(m_pExampleWN, "preview");
78 :
79 0 : SetExchangeSupport();
80 :
81 : // set the correct metric
82 0 : const FieldUnit eMetric = GetModuleFieldUnit( rSet );
83 :
84 0 : SetFieldUnit( *m_pWidthMF, eMetric );
85 0 : SetFieldUnit( *m_pHeightMF, eMetric );
86 0 : SetFieldUnit( *m_pLeftMF, eMetric );
87 0 : SetFieldUnit( *m_pRightMF, eMetric );
88 0 : SetFieldUnit( *m_pTopMF , eMetric );
89 0 : SetFieldUnit( *m_pBottomMF, eMetric );
90 :
91 0 : Link<> aLk = LINK(this, SvxGrfCropPage, SizeHdl);
92 0 : m_pWidthMF->SetModifyHdl( aLk );
93 0 : m_pHeightMF->SetModifyHdl( aLk );
94 :
95 0 : aLk = LINK(this, SvxGrfCropPage, ZoomHdl);
96 0 : m_pWidthZoomMF->SetModifyHdl( aLk );
97 0 : m_pHeightZoomMF->SetModifyHdl( aLk );
98 :
99 0 : aLk = LINK(this, SvxGrfCropPage, CropHdl);
100 0 : m_pLeftMF->SetDownHdl( aLk );
101 0 : m_pRightMF->SetDownHdl( aLk );
102 0 : m_pTopMF->SetDownHdl( aLk );
103 0 : m_pBottomMF->SetDownHdl( aLk );
104 0 : m_pLeftMF->SetUpHdl( aLk );
105 0 : m_pRightMF->SetUpHdl( aLk );
106 0 : m_pTopMF->SetUpHdl( aLk );
107 0 : m_pBottomMF->SetUpHdl( aLk );
108 :
109 0 : aLk = LINK(this, SvxGrfCropPage, CropModifyHdl);
110 0 : m_pLeftMF->SetModifyHdl( aLk );
111 0 : m_pRightMF->SetModifyHdl( aLk );
112 0 : m_pTopMF->SetModifyHdl( aLk );
113 0 : m_pBottomMF->SetModifyHdl( aLk );
114 :
115 0 : aLk = LINK(this, SvxGrfCropPage, CropLoseFocusHdl);
116 0 : m_pLeftMF->SetLoseFocusHdl( aLk );
117 0 : m_pRightMF->SetLoseFocusHdl( aLk );
118 0 : m_pTopMF->SetLoseFocusHdl( aLk );
119 0 : m_pBottomMF->SetLoseFocusHdl( aLk );
120 :
121 0 : aLk = LINK(this, SvxGrfCropPage, OrigSizeHdl);
122 0 : m_pOrigSizePB->SetClickHdl( aLk );
123 :
124 0 : aTimer.SetTimeoutHdl(LINK(this, SvxGrfCropPage, Timeout));
125 0 : aTimer.SetTimeout( 1500 );
126 0 : }
127 :
128 0 : SvxGrfCropPage::~SvxGrfCropPage()
129 : {
130 0 : disposeOnce();
131 0 : }
132 :
133 0 : void SvxGrfCropPage::dispose()
134 : {
135 0 : aTimer.Stop();
136 0 : m_pCropFrame.clear();
137 0 : m_pZoomConstRB.clear();
138 0 : m_pSizeConstRB.clear();
139 0 : m_pLeftMF.clear();
140 0 : m_pRightMF.clear();
141 0 : m_pTopMF.clear();
142 0 : m_pBottomMF.clear();
143 0 : m_pScaleFrame.clear();
144 0 : m_pWidthZoomMF.clear();
145 0 : m_pHeightZoomMF.clear();
146 0 : m_pSizeFrame.clear();
147 0 : m_pWidthMF.clear();
148 0 : m_pHeightMF.clear();
149 0 : m_pOrigSizeGrid.clear();
150 0 : m_pOrigSizeFT.clear();
151 0 : m_pOrigSizePB.clear();
152 0 : m_pExampleWN.clear();
153 0 : pLastCropField.clear();
154 0 : SfxTabPage::dispose();
155 0 : }
156 :
157 0 : VclPtr<SfxTabPage> SvxGrfCropPage::Create(vcl::Window *pParent, const SfxItemSet *rSet)
158 : {
159 0 : return VclPtr<SvxGrfCropPage>::Create( pParent, *rSet );
160 : }
161 :
162 0 : void SvxGrfCropPage::Reset( const SfxItemSet *rSet )
163 : {
164 : const SfxPoolItem* pItem;
165 0 : const SfxItemPool& rPool = *rSet->GetPool();
166 :
167 0 : if(SfxItemState::SET == rSet->GetItemState( rPool.GetWhich(
168 0 : SID_ATTR_GRAF_KEEP_ZOOM ), true, &pItem ))
169 : {
170 0 : if( static_cast<const SfxBoolItem*>(pItem)->GetValue() )
171 0 : m_pZoomConstRB->Check();
172 : else
173 0 : m_pSizeConstRB->Check();
174 0 : m_pZoomConstRB->SaveValue();
175 : }
176 :
177 0 : sal_uInt16 nW = rPool.GetWhich( SID_ATTR_GRAF_CROP );
178 0 : if( SfxItemState::SET == rSet->GetItemState( nW, true, &pItem))
179 : {
180 0 : FieldUnit eUnit = MapToFieldUnit( rSet->GetPool()->GetMetric( nW ));
181 :
182 0 : const SvxGrfCrop* pCrop = static_cast<const SvxGrfCrop*>(pItem);
183 :
184 0 : m_pExampleWN->SetLeft( pCrop->GetLeft());
185 0 : m_pExampleWN->SetRight( pCrop->GetRight());
186 0 : m_pExampleWN->SetTop( pCrop->GetTop());
187 0 : m_pExampleWN->SetBottom( pCrop->GetBottom());
188 :
189 0 : m_pLeftMF->SetValue( m_pLeftMF->Normalize( pCrop->GetLeft()), eUnit );
190 0 : m_pRightMF->SetValue( m_pRightMF->Normalize( pCrop->GetRight()), eUnit );
191 0 : m_pTopMF->SetValue( m_pTopMF->Normalize( pCrop->GetTop()), eUnit );
192 0 : m_pBottomMF->SetValue( m_pBottomMF->Normalize( pCrop->GetBottom()), eUnit );
193 : }
194 : else
195 : {
196 0 : m_pLeftMF->SetValue( 0 );
197 0 : m_pRightMF->SetValue( 0 );
198 0 : m_pTopMF->SetValue( 0 );
199 0 : m_pBottomMF->SetValue( 0 );
200 : }
201 :
202 0 : nW = rPool.GetWhich( SID_ATTR_PAGE_SIZE );
203 0 : if ( SfxItemState::SET == rSet->GetItemState( nW, false, &pItem ) )
204 : {
205 : // orientation and size from the PageItem
206 0 : FieldUnit eUnit = MapToFieldUnit( rSet->GetPool()->GetMetric( nW ));
207 :
208 0 : aPageSize = static_cast<const SvxSizeItem*>(pItem)->GetSize();
209 :
210 0 : sal_Int64 nTmp = m_pHeightMF->Normalize(aPageSize.Height());
211 0 : m_pHeightMF->SetMax( nTmp, eUnit );
212 0 : nTmp = m_pWidthMF->Normalize(aPageSize.Width());
213 0 : m_pWidthMF->SetMax( nTmp, eUnit );
214 0 : nTmp = m_pWidthMF->Normalize( 23 );
215 0 : m_pHeightMF->SetMin( nTmp, eUnit );
216 0 : m_pWidthMF->SetMin( nTmp, eUnit );
217 : }
218 : else
219 : {
220 : aPageSize = OutputDevice::LogicToLogic(
221 : Size( CM_1_TO_TWIP, CM_1_TO_TWIP ),
222 : MapMode( MAP_TWIP ),
223 0 : MapMode( (MapUnit)rSet->GetPool()->GetMetric( nW ) ) );
224 : }
225 :
226 0 : bool bFound = false;
227 0 : if( SfxItemState::SET == rSet->GetItemState( SID_ATTR_GRAF_GRAPHIC, false, &pItem ) )
228 : {
229 0 : OUString referer;
230 : SfxStringItem const * it = static_cast<SfxStringItem const *>(
231 0 : rSet->GetItem(SID_REFERER));
232 0 : if (it != 0) {
233 0 : referer = it->GetValue();
234 : }
235 0 : const Graphic* pGrf = static_cast<const SvxBrushItem*>(pItem)->GetGraphic(referer);
236 0 : if( pGrf )
237 : {
238 0 : aOrigSize = GetGrfOrigSize( *pGrf );
239 0 : if (pGrf->GetType() == GRAPHIC_BITMAP && aOrigSize.Width() && aOrigSize.Height())
240 : {
241 0 : Bitmap aBitmap = pGrf->GetBitmap();
242 0 : aOrigPixelSize = aBitmap.GetSizePixel();
243 : }
244 :
245 0 : if( aOrigSize.Width() && aOrigSize.Height() )
246 : {
247 0 : CalcMinMaxBorder();
248 0 : m_pExampleWN->SetGraphic( *pGrf );
249 0 : m_pExampleWN->SetFrameSize( aOrigSize );
250 :
251 0 : bFound = true;
252 0 : if( !static_cast<const SvxBrushItem*>(pItem)->GetGraphicLink().isEmpty() )
253 0 : aGraphicName = static_cast<const SvxBrushItem*>(pItem)->GetGraphicLink();
254 : }
255 0 : }
256 : }
257 :
258 0 : GraphicHasChanged( bFound );
259 0 : bReset = true;
260 0 : ActivatePage( *rSet );
261 0 : bReset = false;
262 0 : }
263 :
264 0 : bool SvxGrfCropPage::FillItemSet(SfxItemSet *rSet)
265 : {
266 0 : const SfxItemPool& rPool = *rSet->GetPool();
267 0 : bool bModified = false;
268 0 : if( m_pWidthMF->IsValueChangedFromSaved() ||
269 0 : m_pHeightMF->IsValueChangedFromSaved() )
270 : {
271 0 : sal_uInt16 nW = rPool.GetWhich( SID_ATTR_GRAF_FRMSIZE );
272 0 : FieldUnit eUnit = MapToFieldUnit( rSet->GetPool()->GetMetric( nW ));
273 :
274 0 : SvxSizeItem aSz( nW );
275 :
276 : // size could already have been set from another page
277 : // #44204#
278 0 : const SfxItemSet* pExSet = GetTabDialog() ? GetTabDialog()->GetExampleSet() : NULL;
279 0 : const SfxPoolItem* pItem = 0;
280 0 : if( pExSet && SfxItemState::SET ==
281 0 : pExSet->GetItemState( nW, false, &pItem ) )
282 0 : aSz = *static_cast<const SvxSizeItem*>(pItem);
283 : else
284 0 : aSz = static_cast<const SvxSizeItem&>(GetItemSet().Get( nW ));
285 :
286 0 : Size aTmpSz( aSz.GetSize() );
287 0 : if( m_pWidthMF->IsValueChangedFromSaved() )
288 0 : aTmpSz.Width() = lcl_GetValue( *m_pWidthMF, eUnit );
289 0 : if( m_pHeightMF->IsValueChangedFromSaved() )
290 0 : aTmpSz.Height() = lcl_GetValue( *m_pHeightMF, eUnit );
291 0 : aSz.SetSize( aTmpSz );
292 0 : m_pWidthMF->SaveValue();
293 0 : m_pHeightMF->SaveValue();
294 :
295 0 : bModified |= 0 != rSet->Put( aSz );
296 :
297 0 : if( bSetOrigSize )
298 : {
299 : bModified |= 0 != rSet->Put( SvxSizeItem( rPool.GetWhich(
300 0 : SID_ATTR_GRAF_FRMSIZE_PERCENT ), Size( 0, 0 )) );
301 0 : }
302 : }
303 0 : if( m_pLeftMF->IsModified() || m_pRightMF->IsModified() ||
304 0 : m_pTopMF->IsModified() || m_pBottomMF->IsModified() )
305 : {
306 0 : sal_uInt16 nW = rPool.GetWhich( SID_ATTR_GRAF_CROP );
307 0 : FieldUnit eUnit = MapToFieldUnit( rSet->GetPool()->GetMetric( nW ));
308 0 : boost::scoped_ptr<SvxGrfCrop> pNew(static_cast<SvxGrfCrop*>(rSet->Get( nW ).Clone()));
309 :
310 0 : pNew->SetLeft( lcl_GetValue( *m_pLeftMF, eUnit ) );
311 0 : pNew->SetRight( lcl_GetValue( *m_pRightMF, eUnit ) );
312 0 : pNew->SetTop( lcl_GetValue( *m_pTopMF, eUnit ) );
313 0 : pNew->SetBottom( lcl_GetValue( *m_pBottomMF, eUnit ) );
314 0 : bModified |= 0 != rSet->Put( *pNew );
315 : }
316 :
317 0 : if( m_pZoomConstRB->IsValueChangedFromSaved() )
318 : {
319 : bModified |= 0 != rSet->Put( SfxBoolItem( rPool.GetWhich(
320 0 : SID_ATTR_GRAF_KEEP_ZOOM), m_pZoomConstRB->IsChecked() ) );
321 : }
322 :
323 0 : bInitialized = false;
324 :
325 0 : return bModified;
326 : }
327 :
328 0 : void SvxGrfCropPage::ActivatePage(const SfxItemSet& rSet)
329 : {
330 : #ifdef DBG_UTIL
331 : SfxItemPool* pPool = GetItemSet().GetPool();
332 : DBG_ASSERT( pPool, "Wo ist der Pool" );
333 : #endif
334 :
335 0 : bSetOrigSize = false;
336 :
337 : // Size
338 0 : Size aSize;
339 : const SfxPoolItem* pItem;
340 0 : if( SfxItemState::SET == rSet.GetItemState( SID_ATTR_GRAF_FRMSIZE, false, &pItem ) )
341 0 : aSize = static_cast<const SvxSizeItem*>(pItem)->GetSize();
342 :
343 0 : nOldWidth = aSize.Width();
344 0 : nOldHeight = aSize.Height();
345 :
346 0 : sal_Int64 nWidth = m_pWidthMF->Normalize(nOldWidth);
347 0 : sal_Int64 nHeight = m_pHeightMF->Normalize(nOldHeight);
348 :
349 0 : if (nWidth != m_pWidthMF->GetValue(FUNIT_TWIP))
350 : {
351 0 : if(!bReset)
352 : {
353 : // value was changed by wrap-tabpage and has to
354 : // be set with modify-flag
355 0 : m_pWidthMF->SetUserValue(nWidth, FUNIT_TWIP);
356 : }
357 : else
358 0 : m_pWidthMF->SetValue(nWidth, FUNIT_TWIP);
359 : }
360 0 : m_pWidthMF->SaveValue();
361 :
362 0 : if (nHeight != m_pHeightMF->GetValue(FUNIT_TWIP))
363 : {
364 0 : if (!bReset)
365 : {
366 : // value was changed by wrap-tabpage and has to
367 : // be set with modify-flag
368 0 : m_pHeightMF->SetUserValue(nHeight, FUNIT_TWIP);
369 : }
370 : else
371 0 : m_pHeightMF->SetValue(nHeight, FUNIT_TWIP);
372 : }
373 0 : m_pHeightMF->SaveValue();
374 0 : bInitialized = true;
375 :
376 0 : if( SfxItemState::SET == rSet.GetItemState( SID_ATTR_GRAF_GRAPHIC, false, &pItem ) )
377 : {
378 0 : const SvxBrushItem& rBrush = *static_cast<const SvxBrushItem*>(pItem);
379 0 : if( !rBrush.GetGraphicLink().isEmpty() &&
380 0 : aGraphicName != rBrush.GetGraphicLink() )
381 0 : aGraphicName = rBrush.GetGraphicLink();
382 :
383 0 : OUString referer;
384 : SfxStringItem const * it = static_cast<SfxStringItem const *>(
385 0 : rSet.GetItem(SID_REFERER));
386 0 : if (it != 0) {
387 0 : referer = it->GetValue();
388 : }
389 0 : const Graphic* pGrf = rBrush.GetGraphic(referer);
390 0 : if( pGrf )
391 : {
392 0 : m_pExampleWN->SetGraphic( *pGrf );
393 0 : aOrigSize = GetGrfOrigSize( *pGrf );
394 0 : if (pGrf->GetType() == GRAPHIC_BITMAP && aOrigSize.Width() > 1 && aOrigSize.Height() > 1) {
395 0 : Bitmap aBitmap = pGrf->GetBitmap();
396 0 : aOrigPixelSize = aBitmap.GetSizePixel();
397 : }
398 0 : m_pExampleWN->SetFrameSize(aOrigSize);
399 0 : GraphicHasChanged( aOrigSize.Width() && aOrigSize.Height() );
400 0 : CalcMinMaxBorder();
401 : }
402 : else
403 0 : GraphicHasChanged( false );
404 : }
405 :
406 0 : CalcZoom();
407 0 : }
408 :
409 0 : SfxTabPage::sfxpg SvxGrfCropPage::DeactivatePage(SfxItemSet *_pSet)
410 : {
411 0 : if ( _pSet )
412 0 : FillItemSet( _pSet );
413 0 : return LEAVE_PAGE;
414 : }
415 :
416 : /*--------------------------------------------------------------------
417 : description: scale changed, adjust size
418 : --------------------------------------------------------------------*/
419 :
420 0 : IMPL_LINK( SvxGrfCropPage, ZoomHdl, MetricField *, pField )
421 : {
422 0 : SfxItemPool* pPool = GetItemSet().GetPool();
423 : DBG_ASSERT( pPool, "Wo ist der Pool" );
424 : FieldUnit eUnit = MapToFieldUnit( pPool->GetMetric( pPool->GetWhich(
425 0 : SID_ATTR_GRAF_CROP ) ) );
426 :
427 0 : if( pField == m_pWidthZoomMF )
428 : {
429 0 : long nLRBorders = lcl_GetValue(*m_pLeftMF, eUnit)
430 0 : +lcl_GetValue(*m_pRightMF, eUnit);
431 0 : m_pWidthMF->SetValue( m_pWidthMF->Normalize(
432 0 : ((aOrigSize.Width() - nLRBorders) * pField->GetValue())/100L),
433 0 : eUnit);
434 : }
435 : else
436 : {
437 0 : long nULBorders = lcl_GetValue(*m_pTopMF, eUnit)
438 0 : +lcl_GetValue(*m_pBottomMF, eUnit);
439 0 : m_pHeightMF->SetValue( m_pHeightMF->Normalize(
440 0 : ((aOrigSize.Height() - nULBorders ) * pField->GetValue())/100L) ,
441 0 : eUnit );
442 : }
443 :
444 0 : return 0;
445 : }
446 :
447 : /*--------------------------------------------------------------------
448 : description: change size, adjust scale
449 : --------------------------------------------------------------------*/
450 :
451 0 : IMPL_LINK( SvxGrfCropPage, SizeHdl, MetricField *, pField )
452 : {
453 0 : SfxItemPool* pPool = GetItemSet().GetPool();
454 : DBG_ASSERT( pPool, "Wo ist der Pool" );
455 : FieldUnit eUnit = MapToFieldUnit( pPool->GetMetric( pPool->GetWhich(
456 0 : SID_ATTR_GRAF_CROP ) ) );
457 :
458 0 : Size aSize( lcl_GetValue(*m_pWidthMF, eUnit),
459 0 : lcl_GetValue(*m_pHeightMF, eUnit) );
460 :
461 0 : if(pField == m_pWidthMF)
462 : {
463 0 : long nWidth = aOrigSize.Width() -
464 0 : ( lcl_GetValue(*m_pLeftMF, eUnit) +
465 0 : lcl_GetValue(*m_pRightMF, eUnit) );
466 0 : if(!nWidth)
467 0 : nWidth++;
468 0 : sal_uInt16 nZoom = (sal_uInt16)( aSize.Width() * 100L / nWidth);
469 0 : m_pWidthZoomMF->SetValue(nZoom);
470 : }
471 : else
472 : {
473 0 : long nHeight = aOrigSize.Height() -
474 0 : ( lcl_GetValue(*m_pTopMF, eUnit) +
475 0 : lcl_GetValue(*m_pBottomMF, eUnit));
476 0 : if(!nHeight)
477 0 : nHeight++;
478 0 : sal_uInt16 nZoom = (sal_uInt16)( aSize.Height() * 100L/ nHeight);
479 0 : m_pHeightZoomMF->SetValue(nZoom);
480 : }
481 :
482 0 : return 0;
483 : }
484 :
485 : /*--------------------------------------------------------------------
486 : description: evaluate border
487 : --------------------------------------------------------------------*/
488 :
489 0 : IMPL_LINK( SvxGrfCropPage, CropHdl, const MetricField *, pField )
490 : {
491 0 : SfxItemPool* pPool = GetItemSet().GetPool();
492 : DBG_ASSERT( pPool, "Wo ist der Pool" );
493 : FieldUnit eUnit = MapToFieldUnit( pPool->GetMetric( pPool->GetWhich(
494 0 : SID_ATTR_GRAF_CROP ) ) );
495 :
496 0 : bool bZoom = m_pZoomConstRB->IsChecked();
497 0 : if( pField == m_pLeftMF || pField == m_pRightMF )
498 : {
499 0 : long nLeft = lcl_GetValue( *m_pLeftMF, eUnit );
500 0 : long nRight = lcl_GetValue( *m_pRightMF, eUnit );
501 0 : long nWidthZoom = static_cast<long>(m_pWidthZoomMF->GetValue());
502 0 : if(bZoom && ( ( ( aOrigSize.Width() - (nLeft + nRight )) * nWidthZoom )
503 0 : / 100 >= aPageSize.Width() ) )
504 : {
505 0 : if(pField == m_pLeftMF)
506 : {
507 0 : nLeft = aOrigSize.Width() -
508 0 : ( aPageSize.Width() * 100 / nWidthZoom + nRight );
509 0 : m_pLeftMF->SetValue( m_pLeftMF->Normalize( nLeft ), eUnit );
510 : }
511 : else
512 : {
513 0 : nRight = aOrigSize.Width() -
514 0 : ( aPageSize.Width() * 100 / nWidthZoom + nLeft );
515 0 : m_pRightMF->SetValue( m_pRightMF->Normalize( nRight ), eUnit );
516 : }
517 : }
518 0 : if (AllSettings::GetLayoutRTL())
519 : {
520 0 : m_pExampleWN->SetLeft(nRight);
521 0 : m_pExampleWN->SetRight(nLeft);
522 : }
523 : else
524 : {
525 0 : m_pExampleWN->SetLeft(nLeft);
526 0 : m_pExampleWN->SetRight(nRight);
527 : }
528 0 : if(bZoom)
529 : {
530 : // scale stays, recompute width
531 0 : ZoomHdl(m_pWidthZoomMF);
532 : }
533 : }
534 : else
535 : {
536 0 : long nTop = lcl_GetValue( *m_pTopMF, eUnit );
537 0 : long nBottom = lcl_GetValue( *m_pBottomMF, eUnit );
538 0 : long nHeightZoom = static_cast<long>(m_pHeightZoomMF->GetValue());
539 0 : if(bZoom && ( ( ( aOrigSize.Height() - (nTop + nBottom )) * nHeightZoom)
540 0 : / 100 >= aPageSize.Height()))
541 : {
542 0 : if(pField == m_pTopMF)
543 : {
544 0 : nTop = aOrigSize.Height() -
545 0 : ( aPageSize.Height() * 100 / nHeightZoom + nBottom);
546 0 : m_pTopMF->SetValue( m_pWidthMF->Normalize( nTop ), eUnit );
547 : }
548 : else
549 : {
550 0 : nBottom = aOrigSize.Height() -
551 0 : ( aPageSize.Height() * 100 / nHeightZoom + nTop);
552 0 : m_pBottomMF->SetValue( m_pWidthMF->Normalize( nBottom ), eUnit );
553 : }
554 : }
555 0 : m_pExampleWN->SetTop( nTop );
556 0 : m_pExampleWN->SetBottom( nBottom );
557 0 : if(bZoom)
558 : {
559 : // scale stays, recompute height
560 0 : ZoomHdl(m_pHeightZoomMF);
561 : }
562 : }
563 0 : m_pExampleWN->Invalidate();
564 : // size and border changed -> recompute scale
565 0 : if(!bZoom)
566 0 : CalcZoom();
567 0 : CalcMinMaxBorder();
568 0 : return 0;
569 : }
570 : /*--------------------------------------------------------------------
571 : description: set original size
572 : --------------------------------------------------------------------*/
573 :
574 0 : IMPL_LINK_NOARG(SvxGrfCropPage, OrigSizeHdl)
575 : {
576 0 : SfxItemPool* pPool = GetItemSet().GetPool();
577 : DBG_ASSERT( pPool, "Wo ist der Pool" );
578 : FieldUnit eUnit = MapToFieldUnit( pPool->GetMetric( pPool->GetWhich(
579 0 : SID_ATTR_GRAF_CROP ) ) );
580 :
581 0 : long nWidth = aOrigSize.Width() -
582 0 : lcl_GetValue( *m_pLeftMF, eUnit ) -
583 0 : lcl_GetValue( *m_pRightMF, eUnit );
584 0 : m_pWidthMF->SetValue( m_pWidthMF->Normalize( nWidth ), eUnit );
585 0 : long nHeight = aOrigSize.Height() -
586 0 : lcl_GetValue( *m_pTopMF, eUnit ) -
587 0 : lcl_GetValue( *m_pBottomMF, eUnit );
588 0 : m_pHeightMF->SetValue( m_pHeightMF->Normalize( nHeight ), eUnit );
589 0 : m_pWidthZoomMF->SetValue(100);
590 0 : m_pHeightZoomMF->SetValue(100);
591 0 : bSetOrigSize = true;
592 0 : return 0;
593 : }
594 : /*--------------------------------------------------------------------
595 : description: compute scale
596 : --------------------------------------------------------------------*/
597 :
598 0 : void SvxGrfCropPage::CalcZoom()
599 : {
600 0 : SfxItemPool* pPool = GetItemSet().GetPool();
601 : DBG_ASSERT( pPool, "Wo ist der Pool" );
602 : FieldUnit eUnit = MapToFieldUnit( pPool->GetMetric( pPool->GetWhich(
603 0 : SID_ATTR_GRAF_CROP ) ) );
604 :
605 0 : long nWidth = lcl_GetValue( *m_pWidthMF, eUnit );
606 0 : long nHeight = lcl_GetValue( *m_pHeightMF, eUnit );
607 0 : long nLRBorders = lcl_GetValue( *m_pLeftMF, eUnit ) +
608 0 : lcl_GetValue( *m_pRightMF, eUnit );
609 0 : long nULBorders = lcl_GetValue( *m_pTopMF, eUnit ) +
610 0 : lcl_GetValue( *m_pBottomMF, eUnit );
611 0 : sal_uInt16 nZoom = 0;
612 : long nDen;
613 0 : if( (nDen = aOrigSize.Width() - nLRBorders) > 0)
614 0 : nZoom = (sal_uInt16)((( nWidth * 1000L / nDen )+5)/10);
615 0 : m_pWidthZoomMF->SetValue(nZoom);
616 0 : if( (nDen = aOrigSize.Height() - nULBorders) > 0)
617 0 : nZoom = (sal_uInt16)((( nHeight * 1000L / nDen )+5)/10);
618 : else
619 0 : nZoom = 0;
620 0 : m_pHeightZoomMF->SetValue(nZoom);
621 0 : }
622 :
623 : /*--------------------------------------------------------------------
624 : description: set minimum/maximum values for the margins
625 : --------------------------------------------------------------------*/
626 :
627 0 : void SvxGrfCropPage::CalcMinMaxBorder()
628 : {
629 0 : SfxItemPool* pPool = GetItemSet().GetPool();
630 : DBG_ASSERT( pPool, "Wo ist der Pool" );
631 : FieldUnit eUnit = MapToFieldUnit( pPool->GetMetric( pPool->GetWhich(
632 0 : SID_ATTR_GRAF_CROP ) ) );
633 0 : long nR = lcl_GetValue(*m_pRightMF, eUnit );
634 0 : long nMinWidth = (aOrigSize.Width() * 10) /11;
635 0 : long nMin = nMinWidth - (nR >= 0 ? nR : 0);
636 0 : m_pLeftMF->SetMax( m_pLeftMF->Normalize(nMin), eUnit );
637 :
638 0 : long nL = lcl_GetValue(*m_pLeftMF, eUnit );
639 0 : nMin = nMinWidth - (nL >= 0 ? nL : 0);
640 0 : m_pRightMF->SetMax( m_pRightMF->Normalize(nMin), eUnit );
641 :
642 0 : long nUp = lcl_GetValue( *m_pTopMF, eUnit );
643 0 : long nMinHeight = (aOrigSize.Height() * 10) /11;
644 0 : nMin = nMinHeight - (nUp >= 0 ? nUp : 0);
645 0 : m_pBottomMF->SetMax( m_pBottomMF->Normalize(nMin), eUnit );
646 :
647 0 : long nLow = lcl_GetValue(*m_pBottomMF, eUnit );
648 0 : nMin = nMinHeight - (nLow >= 0 ? nLow : 0);
649 0 : m_pTopMF->SetMax( m_pTopMF->Normalize(nMin), eUnit );
650 0 : }
651 : /*--------------------------------------------------------------------
652 : description: set spinsize to 1/20 of the original size,
653 : fill FixedText with the original size
654 : --------------------------------------------------------------------*/
655 :
656 0 : void SvxGrfCropPage::GraphicHasChanged( bool bFound )
657 : {
658 0 : if( bFound )
659 : {
660 0 : SfxItemPool* pPool = GetItemSet().GetPool();
661 : DBG_ASSERT( pPool, "Wo ist der Pool" );
662 : FieldUnit eUnit = MapToFieldUnit( pPool->GetMetric( pPool->GetWhich(
663 0 : SID_ATTR_GRAF_CROP ) ));
664 :
665 0 : sal_Int64 nSpin = m_pLeftMF->Normalize(aOrigSize.Width()) / 20;
666 0 : nSpin = MetricField::ConvertValue( nSpin, aOrigSize.Width(), 0,
667 0 : eUnit, m_pLeftMF->GetUnit());
668 :
669 : // if the margin is too big, it is set to 1/3 on both pages
670 0 : long nR = lcl_GetValue( *m_pRightMF, eUnit );
671 0 : long nL = lcl_GetValue( *m_pLeftMF, eUnit );
672 0 : if((nL + nR) < - aOrigSize.Width())
673 : {
674 0 : long nVal = aOrigSize.Width() / -3;
675 0 : m_pRightMF->SetValue( m_pRightMF->Normalize( nVal ), eUnit );
676 0 : m_pLeftMF->SetValue( m_pLeftMF->Normalize( nVal ), eUnit );
677 0 : m_pExampleWN->SetLeft(nVal);
678 0 : m_pExampleWN->SetRight(nVal);
679 : }
680 0 : long nUp = lcl_GetValue(*m_pTopMF, eUnit );
681 0 : long nLow = lcl_GetValue(*m_pBottomMF, eUnit );
682 0 : if((nUp + nLow) < - aOrigSize.Height())
683 : {
684 0 : long nVal = aOrigSize.Height() / -3;
685 0 : m_pTopMF->SetValue( m_pTopMF->Normalize( nVal ), eUnit );
686 0 : m_pBottomMF->SetValue( m_pBottomMF->Normalize( nVal ), eUnit );
687 0 : m_pExampleWN->SetTop(nVal);
688 0 : m_pExampleWN->SetBottom(nVal);
689 : }
690 :
691 0 : m_pLeftMF->SetSpinSize(nSpin);
692 0 : m_pRightMF->SetSpinSize(nSpin);
693 0 : nSpin = m_pTopMF->Normalize(aOrigSize.Height()) / 20;
694 0 : nSpin = MetricField::ConvertValue( nSpin, aOrigSize.Width(), 0,
695 0 : eUnit, m_pLeftMF->GetUnit() );
696 0 : m_pTopMF->SetSpinSize(nSpin);
697 0 : m_pBottomMF->SetSpinSize(nSpin);
698 :
699 : // display original size
700 0 : const FieldUnit eMetric = GetModuleFieldUnit( GetItemSet() );
701 :
702 0 : ScopedVclPtrInstance< MetricField > aFld(this, WB_HIDE);
703 0 : SetFieldUnit( *aFld.get(), eMetric );
704 0 : aFld->SetDecimalDigits( m_pWidthMF->GetDecimalDigits() );
705 0 : aFld->SetMax( LONG_MAX - 1 );
706 :
707 0 : aFld->SetValue( aFld->Normalize( aOrigSize.Width() ), eUnit );
708 0 : OUString sTemp = aFld->GetText();
709 0 : aFld->SetValue( aFld->Normalize( aOrigSize.Height() ), eUnit );
710 : // multiplication sign (U+00D7)
711 0 : sTemp += OUString( sal_Unicode (0x00D7) );
712 0 : sTemp += aFld->GetText();
713 :
714 0 : if ( aOrigPixelSize.Width() && aOrigPixelSize.Height() ) {
715 0 : sal_Int32 ax = sal_Int32(floor((float)aOrigPixelSize.Width() /
716 0 : ((float)aOrigSize.Width()/TWIP_TO_INCH)+0.5));
717 0 : sal_Int32 ay = sal_Int32(floor((float)aOrigPixelSize.Height() /
718 0 : ((float)aOrigSize.Height()/TWIP_TO_INCH)+0.5));
719 0 : sTemp += " ";
720 0 : sTemp += CUI_RESSTR( RID_SVXSTR_PPI );
721 0 : OUString sPPI = OUString::number(ax);
722 0 : if (abs(ax - ay) > 1) {
723 0 : sPPI += OUString( sal_Unicode (0x00D7) );
724 0 : sPPI += OUString::number(ay);
725 : }
726 0 : sTemp = sTemp.replaceAll("%1", sPPI);
727 : }
728 0 : m_pOrigSizeFT->SetText( sTemp );
729 : }
730 :
731 0 : m_pCropFrame->Enable(bFound);
732 0 : m_pScaleFrame->Enable(bFound);
733 0 : m_pSizeFrame->Enable(bFound);
734 0 : m_pOrigSizeGrid->Enable(bFound);
735 0 : m_pZoomConstRB->Enable(bFound);
736 0 : }
737 :
738 0 : IMPL_LINK_NOARG_TYPED(SvxGrfCropPage, Timeout, Timer *, void)
739 : {
740 : DBG_ASSERT(pLastCropField,"Timeout ohne Feld?");
741 0 : CropHdl(pLastCropField);
742 0 : pLastCropField = 0;
743 0 : }
744 :
745 :
746 0 : IMPL_LINK( SvxGrfCropPage, CropLoseFocusHdl, MetricField*, pField )
747 : {
748 0 : aTimer.Stop();
749 0 : CropHdl(pField);
750 0 : pLastCropField = 0;
751 0 : return 0;
752 : }
753 :
754 :
755 0 : IMPL_LINK( SvxGrfCropPage, CropModifyHdl, MetricField *, pField )
756 : {
757 0 : aTimer.Start();
758 0 : pLastCropField = pField;
759 0 : return 0;
760 : }
761 :
762 0 : Size SvxGrfCropPage::GetGrfOrigSize( const Graphic& rGrf ) const
763 : {
764 0 : const MapMode aMapTwip( MAP_TWIP );
765 0 : Size aSize( rGrf.GetPrefSize() );
766 0 : if( MAP_PIXEL == rGrf.GetPrefMapMode().GetMapUnit() )
767 0 : aSize = PixelToLogic( aSize, aMapTwip );
768 : else
769 : aSize = OutputDevice::LogicToLogic( aSize,
770 0 : rGrf.GetPrefMapMode(), aMapTwip );
771 0 : return aSize;
772 : }
773 :
774 : /*****************************************************************/
775 :
776 0 : SvxCropExample::SvxCropExample( vcl::Window* pPar, WinBits nStyle )
777 : : Window( pPar, nStyle)
778 : , aFrameSize( OutputDevice::LogicToLogic(
779 : Size( CM_1_TO_TWIP / 2, CM_1_TO_TWIP / 2 ),
780 0 : MapMode( MAP_TWIP ), GetMapMode() ))
781 : , aTopLeft(0,0)
782 0 : , aBottomRight(0,0)
783 : {
784 0 : SetBorderStyle( WindowBorderStyle::MONO );
785 0 : }
786 :
787 0 : Size SvxCropExample::GetOptimalSize() const
788 : {
789 0 : return LogicToPixel(Size(78, 78), MAP_APPFONT);
790 : }
791 :
792 0 : VCL_BUILDER_DECL_FACTORY(SvxCropExample)
793 : {
794 0 : WinBits nWinStyle = 0;
795 0 : OString sBorder = VclBuilder::extractCustomProperty(rMap);
796 0 : if (!sBorder.isEmpty())
797 0 : nWinStyle |= WB_BORDER;
798 0 : rRet = VclPtr<SvxCropExample>::Create(pParent, nWinStyle);
799 0 : }
800 :
801 0 : void SvxCropExample::Paint(vcl::RenderContext& rRenderContext, const Rectangle&)
802 : {
803 0 : Size aWinSize(rRenderContext.PixelToLogic(rRenderContext.GetOutputSizePixel()));
804 0 : rRenderContext.SetLineColor();
805 0 : rRenderContext.SetFillColor(rRenderContext.GetSettings().GetStyleSettings().GetWindowColor());
806 0 : rRenderContext.SetRasterOp(ROP_OVERPAINT);
807 0 : rRenderContext.DrawRect(Rectangle(Point(), aWinSize));
808 :
809 0 : rRenderContext.SetLineColor(Color(COL_WHITE));
810 0 : Rectangle aRect(Point((aWinSize.Width() - aFrameSize.Width())/2,
811 0 : (aWinSize.Height() - aFrameSize.Height())/2),
812 0 : aFrameSize);
813 0 : aGrf.Draw(&rRenderContext, aRect.TopLeft(), aRect.GetSize());
814 :
815 0 : Size aSz(2, 0);
816 0 : aSz = rRenderContext.PixelToLogic(aSz);
817 0 : rRenderContext.SetFillColor(Color(COL_TRANSPARENT));
818 0 : rRenderContext.SetRasterOp(ROP_INVERT);
819 0 : aRect.Left() += aTopLeft.Y();
820 0 : aRect.Top() += aTopLeft.X();
821 0 : aRect.Right() -= aBottomRight.Y();
822 0 : aRect.Bottom() -= aBottomRight.X();
823 0 : rRenderContext.DrawRect(aRect);
824 0 : }
825 :
826 0 : void SvxCropExample::Resize()
827 : {
828 0 : SetFrameSize(aFrameSize);
829 0 : }
830 :
831 0 : void SvxCropExample::SetFrameSize( const Size& rSz )
832 : {
833 0 : aFrameSize = rSz;
834 0 : if(!aFrameSize.Width())
835 0 : aFrameSize.Width() = 1;
836 0 : if(!aFrameSize.Height())
837 0 : aFrameSize.Height() = 1;
838 0 : Size aWinSize( GetOutputSizePixel() );
839 0 : Fraction aXScale( aWinSize.Width() * 4, aFrameSize.Width() * 5 );
840 0 : Fraction aYScale( aWinSize.Height() * 4, aFrameSize.Height() * 5 );
841 :
842 0 : if( aYScale < aXScale )
843 0 : aXScale = aYScale;
844 :
845 0 : MapMode aMapMode( GetMapMode() );
846 :
847 0 : aMapMode.SetScaleX( aXScale );
848 0 : aMapMode.SetScaleY( aXScale );
849 :
850 0 : SetMapMode( aMapMode );
851 0 : Invalidate();
852 0 : }
853 :
854 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
