xref: /AOO41X/main/cui/source/tabpages/grfpage.cxx (revision 3b8558fd12b4776aa3c54a9fb2322537ca2a5e4c) 
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_cui.hxx"
26 
27 #include <tools/shl.hxx>
28 #include <svl/eitem.hxx>
29 #include <sfx2/app.hxx>
30 #include <sfx2/module.hxx>
31 #include <sfx2/sfxsids.hrc>
32 #include <dialmgr.hxx>
33 #include <svx/dlgutil.hxx>
34 #include <editeng/sizeitem.hxx>
35 #include <editeng/brshitem.hxx>
36 #include <grfpage.hxx>
37 #include <svx/grfcrop.hxx>
38 #include <grfpage.hrc>
39 #include <cuires.hrc>
40 #include <svx/dialogs.hrc> // for RID_SVXPAGE_GRFCROP
41 
42 #define CM_1_TO_TWIP 		567
43 
44 
45 inline long lcl_GetValue( MetricField& rMetric, FieldUnit eUnit )
46 {
47 	return static_cast<long>(rMetric.Denormalize( rMetric.GetValue( eUnit )));
48 }
49 
50 /*--------------------------------------------------------------------
51 	Beschreibung: Grafik zuschneiden
52  --------------------------------------------------------------------*/
53 
54 SvxGrfCropPage::SvxGrfCropPage ( Window *pParent, const SfxItemSet &rSet )
55 	: SfxTabPage( pParent, 	CUI_RES( RID_SVXPAGE_GRFCROP ), rSet ),
56     aCropFL(        this, CUI_RES( FL_CROP    )),
57     aZoomConstRB(   this, CUI_RES( RB_ZOOMCONST)),
58     aSizeConstRB(   this, CUI_RES( RB_SIZECONST)),
59     aLeftFT(        this, CUI_RES( FT_LEFT    )),
60     aLeftMF(        this, CUI_RES( MF_LEFT    )),
61     aRightFT(       this, CUI_RES( FT_RIGHT   )),
62     aRightMF(       this, CUI_RES( MF_RIGHT   )),
63     aTopFT(         this, CUI_RES( FT_TOP     )),
64     aTopMF(         this, CUI_RES( MF_TOP     )),
65     aBottomFT(      this, CUI_RES( FT_BOTTOM  )),
66     aBottomMF(      this, CUI_RES( MF_BOTTOM  )),
67     aZoomFL(        this, CUI_RES( FL_ZOOM    )),
68     aWidthZoomFT(   this, CUI_RES( FT_WIDTHZOOM )),
69 	aWidthZoomMF( 	this, CUI_RES( MF_WIDTHZOOM )),
70 	aHeightZoomFT( 	this, CUI_RES( FT_HEIGHTZOOM)),
71 	aHeightZoomMF( 	this, CUI_RES( MF_HEIGHTZOOM)),
72     aSizeFL(        this, CUI_RES( FL_SIZE    )),
73     aWidthFT(       this, CUI_RES( FT_WIDTH   )),
74     aWidthMF(       this, CUI_RES( MF_WIDTH   )),
75     aHeightFT(      this, CUI_RES( FT_HEIGHT  )),
76     aHeightMF(      this, CUI_RES( MF_HEIGHT  )),
77     aOrigSizeFT(    this, CUI_RES(FT_ORIG_SIZE)),
78 	aOrigSizePB( 	this, CUI_RES( PB_ORGSIZE )),
79     aExampleWN(     this, CUI_RES( WN_BSP     )),
80     pLastCropField(0),
81 	bInitialized(sal_False),
82 	bSetOrigSize(sal_False)
83 {
84 	FreeResource();
85 
86 	SetExchangeSupport();
87 
88     // set the correct metric
89 	const FieldUnit eMetric = GetModuleFieldUnit( rSet );
90 
91 	SetFieldUnit( aWidthMF, eMetric );
92 	SetFieldUnit( aHeightMF, eMetric );
93 	SetFieldUnit( aLeftMF, eMetric );
94 	SetFieldUnit( aRightMF, eMetric );
95 	SetFieldUnit( aTopMF , eMetric );
96 	SetFieldUnit( aBottomMF, eMetric );
97 
98 	Link aLk = LINK(this, SvxGrfCropPage, SizeHdl);
99 	aWidthMF.SetModifyHdl( aLk );
100 	aHeightMF.SetModifyHdl( aLk );
101 
102 	aLk = LINK(this, SvxGrfCropPage, ZoomHdl);
103 	aWidthZoomMF.SetModifyHdl( aLk );
104 	aHeightZoomMF.SetModifyHdl( aLk );
105 
106 	aLk = LINK(this, SvxGrfCropPage, CropHdl);
107 	aLeftMF.SetDownHdl( aLk );
108 	aRightMF.SetDownHdl( aLk );
109 	aTopMF.SetDownHdl( aLk );
110 	aBottomMF.SetDownHdl( aLk );
111 	aLeftMF.SetUpHdl( aLk );
112 	aRightMF.SetUpHdl( aLk );
113 	aTopMF.SetUpHdl( aLk );
114 	aBottomMF.SetUpHdl( aLk );
115 
116 	aLk = LINK(this, SvxGrfCropPage, CropModifyHdl);
117 	aLeftMF.SetModifyHdl( aLk );
118 	aRightMF.SetModifyHdl( aLk );
119 	aTopMF.SetModifyHdl( aLk );
120 	aBottomMF.SetModifyHdl( aLk );
121 
122 	aLk = LINK(this, SvxGrfCropPage, CropLoseFocusHdl);
123 	aLeftMF.SetLoseFocusHdl( aLk );
124 	aRightMF.SetLoseFocusHdl( aLk );
125 	aTopMF.SetLoseFocusHdl( aLk );
126 	aBottomMF.SetLoseFocusHdl( aLk );
127 
128 	aLk = LINK(this, SvxGrfCropPage, OrigSizeHdl);
129 	aOrigSizePB.SetClickHdl( aLk );
130 
131 	aTimer.SetTimeoutHdl(LINK(this, SvxGrfCropPage, Timeout));
132 	aTimer.SetTimeout( 1500 );
133 
134 	aOrigSizePB.SetAccessibleRelationLabeledBy( &aOrigSizeFT );
135 }
136 
137 /*--------------------------------------------------------------------
138 	Beschreibung:
139  --------------------------------------------------------------------*/
140 
141 SvxGrfCropPage::~SvxGrfCropPage()
142 {
143 	aTimer.Stop();
144 }
145 
146 /*--------------------------------------------------------------------
147 	Beschreibung:
148  --------------------------------------------------------------------*/
149 
150 SfxTabPage* SvxGrfCropPage::Create(Window *pParent, const SfxItemSet &rSet)
151 {
152 	return new SvxGrfCropPage( pParent, rSet );
153 }
154 /*--------------------------------------------------------------------
155 	Beschreibung:
156  --------------------------------------------------------------------*/
157 
158 void SvxGrfCropPage::Reset( const SfxItemSet &rSet )
159 {
160 	const SfxPoolItem* pItem;
161 	const SfxItemPool& rPool = *rSet.GetPool();
162 
163 	if(SFX_ITEM_SET == rSet.GetItemState( rPool.GetWhich(
164 									SID_ATTR_GRAF_KEEP_ZOOM ), sal_True, &pItem ))
165 	{
166 		if( ((const SfxBoolItem*)pItem)->GetValue() )
167 			aZoomConstRB.Check();
168 		else
169 			aSizeConstRB.Check();
170 		aZoomConstRB.SaveValue();
171 	}
172 
173 	sal_uInt16 nW = rPool.GetWhich( SID_ATTR_GRAF_CROP );
174 	if( SFX_ITEM_SET == rSet.GetItemState( nW, sal_True, &pItem))
175 	{
176 		FieldUnit eUnit = MapToFieldUnit( rSet.GetPool()->GetMetric( nW ));
177 
178 		SvxGrfCrop* pCrop =  (SvxGrfCrop*)pItem;
179 
180 		aExampleWN.SetLeft(		pCrop->GetLeft());
181 		aExampleWN.SetRight(	pCrop->GetRight());
182 		aExampleWN.SetTop(		pCrop->GetTop());
183 		aExampleWN.SetBottom(	pCrop->GetBottom());
184 
185 		aLeftMF.SetValue( aLeftMF.Normalize( pCrop->GetLeft()), eUnit );
186 		aRightMF.SetValue( aRightMF.Normalize( pCrop->GetRight()), eUnit );
187 		aTopMF.SetValue( aTopMF.Normalize( pCrop->GetTop()), eUnit );
188 		aBottomMF.SetValue( aBottomMF.Normalize( pCrop->GetBottom()), eUnit );
189 	}
190 	else
191 	{
192 		aLeftMF.SetValue( 0 );
193 		aRightMF.SetValue( 0 );
194 		aTopMF.SetValue( 0 );
195 		aBottomMF.SetValue( 0 );
196 	}
197 
198 	nW = rPool.GetWhich( SID_ATTR_PAGE_SIZE );
199 	if ( SFX_ITEM_SET == rSet.GetItemState( nW, sal_False, &pItem ) )
200 	{
201 		// Orientation und Size aus dem PageItem
202 		FieldUnit eUnit = MapToFieldUnit( rSet.GetPool()->GetMetric( nW ));
203 
204 		aPageSize = ((const SvxSizeItem*)pItem)->GetSize();
205 
206 		sal_Int64 nTmp = aHeightMF.Normalize(aPageSize.Height());
207 		aHeightMF.SetMax( nTmp, eUnit );
208 		nTmp = aWidthMF.Normalize(aPageSize.Width());
209 		aWidthMF.SetMax( nTmp, eUnit );
210 		nTmp = aWidthMF.Normalize( 23 );
211 		aHeightMF.SetMin( nTmp, eUnit );
212 		aWidthMF.SetMin( nTmp, eUnit );
213 	}
214 	else
215 	{
216 		aPageSize = OutputDevice::LogicToLogic(
217 						Size( CM_1_TO_TWIP,  CM_1_TO_TWIP ),
218 						MapMode( MAP_TWIP ),
219 						MapMode( (MapUnit)rSet.GetPool()->GetMetric( nW ) ) );
220 	}
221 
222 	sal_Bool bFound = sal_False;
223 	if( SFX_ITEM_SET == rSet.GetItemState( SID_ATTR_GRAF_GRAPHIC, sal_False, &pItem ) )
224 	{
225 		const Graphic* pGrf = ((SvxBrushItem*)pItem)->GetGraphic();
226 		if( pGrf )
227 			aOrigSize = GetGrfOrigSize( *pGrf );
228 
229 		if( aOrigSize.Width() && aOrigSize.Height() )
230 		{
231 			CalcMinMaxBorder();
232 			aExampleWN.SetGraphic( *pGrf );
233 			aExampleWN.SetFrameSize( aOrigSize );
234 
235 			bFound = sal_True;
236 			if( ((SvxBrushItem*)pItem)->GetGraphicLink() )
237 				aGraphicName = *((SvxBrushItem*)pItem)->GetGraphicLink();
238 		}
239 	}
240 
241 	GraphicHasChanged( bFound );
242 	bReset = sal_True;
243 	ActivatePage( rSet );
244 	bReset = sal_False;
245 }
246 
247 /*--------------------------------------------------------------------
248 	Beschreibung:
249  --------------------------------------------------------------------*/
250 
251 sal_Bool SvxGrfCropPage::FillItemSet(SfxItemSet &rSet)
252 {
253 	const SfxItemPool& rPool = *rSet.GetPool();
254 	sal_Bool bModified = sal_False;
255 	if( aWidthMF.GetSavedValue() != aWidthMF.GetText() ||
256 		aHeightMF.GetSavedValue() != aHeightMF.GetText() )
257 	{
258 		sal_uInt16 nW = rPool.GetWhich( SID_ATTR_GRAF_FRMSIZE );
259 		FieldUnit eUnit = MapToFieldUnit( rSet.GetPool()->GetMetric( nW ));
260 
261 		SvxSizeItem aSz( nW );
262 
263 		// die Groesse koennte schon von einer anderen Page gesetzt worden sein
264 		// #44204#
265 		const SfxItemSet* pExSet = GetTabDialog() ? GetTabDialog()->GetExampleSet() : NULL;
266 		const SfxPoolItem* pItem = 0;
267 		if( pExSet && SFX_ITEM_SET ==
268 				pExSet->GetItemState( nW, sal_False, &pItem ) )
269 			aSz = *(const SvxSizeItem*)pItem;
270 		else
271 			aSz = (const SvxSizeItem&)GetItemSet().Get( nW );
272 
273 		Size aTmpSz( aSz.GetSize() );
274 		if( aWidthMF.GetText() != aWidthMF.GetSavedValue() )
275 			aTmpSz.Width() = lcl_GetValue( aWidthMF, eUnit );
276 		if( aHeightMF.GetText() != aHeightMF.GetSavedValue() )
277 			aTmpSz.Height() = lcl_GetValue( aHeightMF, eUnit );
278 		aSz.SetSize( aTmpSz );
279 		aWidthMF.SaveValue();
280 		aHeightMF.SaveValue();
281 
282 		bModified |= 0 != rSet.Put( aSz );
283 
284 		if( bSetOrigSize )
285 		{
286 			bModified |= 0 != rSet.Put( SvxSizeItem( rPool.GetWhich(
287 						SID_ATTR_GRAF_FRMSIZE_PERCENT ), Size( 0, 0 )) );
288 		}
289 	}
290 	if( aLeftMF.IsModified() || aRightMF.IsModified() ||
291 		aTopMF.IsModified()  ||	aBottomMF.IsModified() )
292 	{
293 		sal_uInt16 nW = rPool.GetWhich( SID_ATTR_GRAF_CROP );
294 		FieldUnit eUnit = MapToFieldUnit( rSet.GetPool()->GetMetric( nW ));
295 		SvxGrfCrop* pNew = (SvxGrfCrop*)rSet.Get( nW ).Clone();
296 
297 		pNew->SetLeft( lcl_GetValue( aLeftMF, eUnit ) );
298 		pNew->SetRight( lcl_GetValue( aRightMF, eUnit ) );
299 		pNew->SetTop( lcl_GetValue( aTopMF, eUnit ) );
300 		pNew->SetBottom( lcl_GetValue( aBottomMF, eUnit ) );
301 		bModified |= 0 != rSet.Put( *pNew );
302 		delete pNew;
303 	}
304 
305 	if( aZoomConstRB.GetSavedValue() != aZoomConstRB.IsChecked() )
306 	{
307 		bModified |= 0 != rSet.Put( SfxBoolItem( rPool.GetWhich(
308 					SID_ATTR_GRAF_KEEP_ZOOM), aZoomConstRB.IsChecked() ) );
309 	}
310 
311 	bInitialized = sal_False;
312 
313 	return bModified;
314 }
315 
316 /*--------------------------------------------------------------------
317 	Beschreibung:
318  --------------------------------------------------------------------*/
319 
320 void SvxGrfCropPage::ActivatePage(const SfxItemSet& rSet)
321 {
322 #ifdef DBG_UTIL
323 	SfxItemPool* pPool = GetItemSet().GetPool();
324 	DBG_ASSERT( pPool, "Wo ist der Pool" );
325 #endif
326 
327 	bSetOrigSize = sal_False;
328 
329 	// Size
330 	Size aSize;
331 	const SfxPoolItem* pItem;
332 	if( SFX_ITEM_SET == rSet.GetItemState( SID_ATTR_GRAF_FRMSIZE, sal_False, &pItem ) )
333 		aSize = ((const SvxSizeItem*)pItem)->GetSize();
334 
335 	nOldWidth = aSize.Width();
336 	nOldHeight = aSize.Height();
337 
338 	sal_Int64 nWidth = aWidthMF.Normalize(nOldWidth);
339 	sal_Int64 nHeight = aHeightMF.Normalize(nOldHeight);
340 
341 	if (nWidth != aWidthMF.GetValue(FUNIT_TWIP))
342 	{
343 		if(!bReset)
344 		{
345 			// Wert wurde von Umlauf-Tabpage geaendert und muss
346 			// mit Modify-Flag gesetzt werden
347 			aWidthMF.SetUserValue(nWidth, FUNIT_TWIP);
348 		}
349 		else
350 			aWidthMF.SetValue(nWidth, FUNIT_TWIP);
351 	}
352 	aWidthMF.SaveValue();
353 
354 	if (nHeight != aHeightMF.GetValue(FUNIT_TWIP))
355 	{
356 		if (!bReset)
357 		{
358 			// Wert wurde von Umlauf-Tabpage geaendert und muss
359 			// mit Modify-Flag gesetzt werden
360 			aHeightMF.SetUserValue(nHeight, FUNIT_TWIP);
361 		}
362 		else
363 			aHeightMF.SetValue(nHeight, FUNIT_TWIP);
364 	}
365 	aHeightMF.SaveValue();
366 	bInitialized = sal_True;
367 
368 	if( SFX_ITEM_SET == rSet.GetItemState( SID_ATTR_GRAF_GRAPHIC, sal_False, &pItem ) )
369 	{
370 		const SvxBrushItem& rBrush = *(SvxBrushItem*)pItem;
371 		if( rBrush.GetGraphicLink() &&
372 			aGraphicName != *rBrush.GetGraphicLink() )
373 			aGraphicName = *rBrush.GetGraphicLink();
374 
375 		const Graphic* pGrf = rBrush.GetGraphic();
376 		if( pGrf )
377 		{
378 			aExampleWN.SetGraphic( *pGrf );
379 			aOrigSize = GetGrfOrigSize( *pGrf );
380 			aExampleWN.SetFrameSize(aOrigSize);
381 			GraphicHasChanged( aOrigSize.Width() && aOrigSize.Height() );
382 			CalcMinMaxBorder();
383 		}
384 		else
385 			GraphicHasChanged( sal_False );
386 	}
387 
388 	CalcZoom();
389 }
390 
391 /*--------------------------------------------------------------------
392 	Beschreibung:
393  --------------------------------------------------------------------*/
394 
395 int SvxGrfCropPage::DeactivatePage(SfxItemSet *_pSet)
396 {
397     if ( _pSet )
398         FillItemSet( *_pSet );
399 	return sal_True;
400 }
401 
402 /*--------------------------------------------------------------------
403 	Beschreibung: Massstab geaendert, Groesse anpassen
404  --------------------------------------------------------------------*/
405 
406 IMPL_LINK( SvxGrfCropPage, ZoomHdl, MetricField *, pField )
407 {
408 	SfxItemPool* pPool = GetItemSet().GetPool();
409 	DBG_ASSERT( pPool, "Wo ist der Pool" );
410 	FieldUnit eUnit = MapToFieldUnit( pPool->GetMetric( pPool->GetWhich(
411 													SID_ATTR_GRAF_CROP ) ) );
412 
413 	if( pField == &aWidthZoomMF )
414 	{
415 		long nLRBorders = lcl_GetValue(aLeftMF, eUnit)
416 						 +lcl_GetValue(aRightMF, eUnit);
417 		aWidthMF.SetValue( aWidthMF.Normalize(
418 			((aOrigSize.Width() - nLRBorders) * pField->GetValue())/100L),
419 			eUnit);
420 	}
421 	else
422 	{
423 		long nULBorders = lcl_GetValue(aTopMF, eUnit)
424 						 +lcl_GetValue(aBottomMF, eUnit);
425 		aHeightMF.SetValue( aHeightMF.Normalize(
426 			((aOrigSize.Height() - nULBorders ) * pField->GetValue())/100L) ,
427 			eUnit );
428 	}
429 
430 	return 0;
431 }
432 
433 /*--------------------------------------------------------------------
434 	Beschreibung: Groesse aendern, Massstab anpassen
435  --------------------------------------------------------------------*/
436 
437 IMPL_LINK( SvxGrfCropPage, SizeHdl, MetricField *, pField )
438 {
439 	SfxItemPool* pPool = GetItemSet().GetPool();
440 	DBG_ASSERT( pPool, "Wo ist der Pool" );
441 	FieldUnit eUnit = MapToFieldUnit( pPool->GetMetric( pPool->GetWhich(
442 													SID_ATTR_GRAF_CROP ) ) );
443 
444 	Size aSize( lcl_GetValue(aWidthMF, eUnit),
445 				lcl_GetValue(aHeightMF, eUnit) );
446 
447 	if(pField == &aWidthMF)
448 	{
449 		long nWidth = aOrigSize.Width() -
450 				( lcl_GetValue(aLeftMF, eUnit) +
451 				  lcl_GetValue(aRightMF, eUnit) );
452 		if(!nWidth)
453 			nWidth++;
454 		sal_uInt16 nZoom = (sal_uInt16)( aSize.Width() * 100L / nWidth);
455 		aWidthZoomMF.SetValue(nZoom);
456 	}
457 	else
458 	{
459 		long nHeight = aOrigSize.Height() -
460 				( lcl_GetValue(aTopMF, eUnit) +
461 				  lcl_GetValue(aBottomMF, eUnit));
462 		if(!nHeight)
463 			nHeight++;
464 		sal_uInt16 nZoom = (sal_uInt16)( aSize.Height() * 100L/ nHeight);
465 		aHeightZoomMF.SetValue(nZoom);
466 	}
467 
468 	return 0;
469 }
470 
471 /*--------------------------------------------------------------------
472 	Beschreibung: Raender auswerten
473  --------------------------------------------------------------------*/
474 
475 IMPL_LINK( SvxGrfCropPage, CropHdl, const MetricField *, pField )
476 {
477 	SfxItemPool* pPool = GetItemSet().GetPool();
478 	DBG_ASSERT( pPool, "Wo ist der Pool" );
479 	FieldUnit eUnit = MapToFieldUnit( pPool->GetMetric( pPool->GetWhich(
480 													SID_ATTR_GRAF_CROP ) ) );
481 
482 	sal_Bool bZoom = aZoomConstRB.IsChecked();
483 	if( pField == &aLeftMF || pField == &aRightMF )
484 	{
485 		long nLeft = lcl_GetValue( aLeftMF, eUnit );
486 		long nRight = lcl_GetValue( aRightMF, eUnit );
487 		long nWidthZoom = static_cast<long>(aWidthZoomMF.GetValue());
488 		if(bZoom && ( ( ( aOrigSize.Width() - (nLeft + nRight )) * nWidthZoom )
489 							/ 100 >= aPageSize.Width() ) )
490 		{
491 			if(pField == &aLeftMF)
492 			{
493 //				nLeft = aPageSize.Width() -
494 //					((nRight + aOrigSize.Width()) * nWidthZoom) / 100;
495 				nLeft = aOrigSize.Width() -
496 							( aPageSize.Width() * 100 / nWidthZoom + nRight );
497 				aLeftMF.SetValue( aLeftMF.Normalize( nLeft ), eUnit );
498 			}
499 			else
500 			{
501 //				nRight = aPageSize.Width() -
502 //					((nLeft - aOrigSize.Width()) * nWidthZoom) / 100;
503 				nRight = aOrigSize.Width() -
504 							( aPageSize.Width() * 100 / nWidthZoom + nLeft );
505 				aRightMF.SetValue( aRightMF.Normalize( nRight ), eUnit );
506 			}
507 		}
508 		aExampleWN.SetLeft(nLeft);
509 		aExampleWN.SetRight(nRight);
510 		if(bZoom)
511 		{
512 			//Massstab bleibt -> Breite neu berechnen
513 			ZoomHdl(&aWidthZoomMF);
514 		}
515 	}
516 	else
517 	{
518 		long nTop = lcl_GetValue( aTopMF, eUnit );
519 		long nBottom = lcl_GetValue( aBottomMF, eUnit );
520 		long nHeightZoom = static_cast<long>(aHeightZoomMF.GetValue());
521 		if(bZoom && ( ( ( aOrigSize.Height() - (nTop + nBottom )) * nHeightZoom)
522 											/ 100 >= aPageSize.Height()))
523 		{
524 			if(pField == &aTopMF)
525 			{
526 //				nTop = aPageSize.Height() -
527 //					((aOrigSize.Height() - nBottom) * nHeightZoom)/ 100;
528 				nTop = aOrigSize.Height() -
529 							( aPageSize.Height() * 100 / nHeightZoom + nBottom);
530 				aTopMF.SetValue( aWidthMF.Normalize( nTop ), eUnit );
531 			}
532 			else
533 			{
534 //				nBottom = aPageSize.Height() -
535 //					((aOrigSize.Height() - nTop)*nHeightZoom) / 100;
536 				nBottom = aOrigSize.Height() -
537 							( aPageSize.Height() * 100 / nHeightZoom + nTop);
538 				aBottomMF.SetValue( aWidthMF.Normalize( nBottom ), eUnit );
539 			}
540 		}
541 		aExampleWN.SetTop( nTop );
542 		aExampleWN.SetBottom( nBottom );
543 		if(bZoom)
544 		{
545 			//Massstab bleibt -> Hoehe neu berechnen
546 			ZoomHdl(&aHeightZoomMF);
547 		}
548 	}
549 	aExampleWN.Invalidate();
550 	//Groesse und Raender veraendert -> Massstab neu berechnen
551 	if(!bZoom)
552 		CalcZoom();
553 	CalcMinMaxBorder();
554 	return 0;
555 }
556 /*--------------------------------------------------------------------
557 	Beschreibung: Originalgroesse einstellen
558  --------------------------------------------------------------------*/
559 
560 IMPL_LINK( SvxGrfCropPage, OrigSizeHdl, PushButton *, EMPTYARG )
561 {
562 	SfxItemPool* pPool = GetItemSet().GetPool();
563 	DBG_ASSERT( pPool, "Wo ist der Pool" );
564 	FieldUnit eUnit = MapToFieldUnit( pPool->GetMetric( pPool->GetWhich(
565 													SID_ATTR_GRAF_CROP ) ) );
566 
567 	long nWidth = aOrigSize.Width() -
568 		lcl_GetValue( aLeftMF, eUnit ) -
569 		lcl_GetValue( aRightMF, eUnit );
570 	aWidthMF.SetValue( aWidthMF.Normalize( nWidth ), eUnit );
571 	long nHeight = aOrigSize.Height() -
572 		lcl_GetValue( aTopMF, eUnit ) -
573 		lcl_GetValue( aBottomMF, eUnit );
574 	aHeightMF.SetValue( aHeightMF.Normalize( nHeight ), eUnit );
575 	aWidthZoomMF.SetValue(100);
576 	aHeightZoomMF.SetValue(100);
577 	bSetOrigSize = sal_True;
578 	return 0;
579 }
580 /*--------------------------------------------------------------------
581 	Beschreibung: Massstab berechnen
582  --------------------------------------------------------------------*/
583 
584 void SvxGrfCropPage::CalcZoom()
585 {
586 	SfxItemPool* pPool = GetItemSet().GetPool();
587 	DBG_ASSERT( pPool, "Wo ist der Pool" );
588 	FieldUnit eUnit = MapToFieldUnit( pPool->GetMetric( pPool->GetWhich(
589 													SID_ATTR_GRAF_CROP ) ) );
590 
591 	long nWidth = lcl_GetValue( aWidthMF, eUnit );
592 	long nHeight = lcl_GetValue( aHeightMF, eUnit );
593 	long nLRBorders = lcl_GetValue( aLeftMF, eUnit ) +
594 					  lcl_GetValue( aRightMF, eUnit );
595 	long nULBorders = lcl_GetValue( aTopMF, eUnit ) +
596 					  lcl_GetValue( aBottomMF, eUnit );
597 	sal_uInt16 nZoom = 0;
598 	long nDen;
599 	if( (nDen = aOrigSize.Width() - nLRBorders) > 0)
600 		nZoom = (sal_uInt16)((( nWidth  * 1000L / nDen )+5)/10);
601 	aWidthZoomMF.SetValue(nZoom);
602 	if( (nDen = aOrigSize.Height() - nULBorders) > 0)
603 		nZoom = (sal_uInt16)((( nHeight * 1000L / nDen )+5)/10);
604 	else
605 		nZoom = 0;
606 	aHeightZoomMF.SetValue(nZoom);
607 }
608 
609 /*--------------------------------------------------------------------
610 	Beschreibung: Minimal-/Maximalwerte fuer die Raender setzen
611  --------------------------------------------------------------------*/
612 
613 void SvxGrfCropPage::CalcMinMaxBorder()
614 {
615 	SfxItemPool* pPool = GetItemSet().GetPool();
616 	DBG_ASSERT( pPool, "Wo ist der Pool" );
617 	FieldUnit eUnit = MapToFieldUnit( pPool->GetMetric( pPool->GetWhich(
618 													SID_ATTR_GRAF_CROP ) ) );
619 	long nR = lcl_GetValue(aRightMF, eUnit );
620 	long nMinWidth = (aOrigSize.Width() * 10) /11;
621 	long nMin = nMinWidth - (nR >= 0 ? nR : 0);
622 	aLeftMF.SetMax( aLeftMF.Normalize(nMin), eUnit );
623 
624 	long nL = lcl_GetValue(aLeftMF, eUnit );
625 	nMin = nMinWidth - (nL >= 0 ? nL : 0);
626 	aRightMF.SetMax( aRightMF.Normalize(nMin), eUnit );
627 
628 	// Zoom nicht unter 2%
629 /*	nMin = (aOrigSize.Width() * 102) /100;
630 	aLeftMF.SetMax(aPageSize.Width() - nR - nMin);
631 	aRightMF.SetMax(aPageSize.Width() - nL - nMin);
632 */
633 	long nUp  = lcl_GetValue( aTopMF, eUnit );
634 	long nMinHeight = (aOrigSize.Height() * 10) /11;
635 	nMin = nMinHeight - (nUp >= 0 ? nUp : 0);
636 	aBottomMF.SetMax( aBottomMF.Normalize(nMin), eUnit );
637 
638 	long nLow = lcl_GetValue(aBottomMF, eUnit );
639 	nMin = nMinHeight - (nLow >= 0 ? nLow : 0);
640 	aTopMF.SetMax( aTopMF.Normalize(nMin), eUnit );
641 
642 	// Zoom nicht unter 2%
643 /*	nMin = (aOrigSize.Height() * 102) /100;
644 	aTopMF.SetMax(aPageSize.Height() - nLow - nMin);
645 	aBottomMF.SetMax(aPageSize.Height() - nUp - nMin);*/
646 }
647 /*--------------------------------------------------------------------
648 	Beschreibung: 	Spinsize auf 1/20 der Originalgroesse setzen,
649 					FixedText mit der Originalgroesse fuellen
650  --------------------------------------------------------------------*/
651 
652 void SvxGrfCropPage::GraphicHasChanged( sal_Bool bFound )
653 {
654 	if( bFound )
655 	{
656 		SfxItemPool* pPool = GetItemSet().GetPool();
657 		DBG_ASSERT( pPool, "Wo ist der Pool" );
658 		FieldUnit eUnit = MapToFieldUnit( pPool->GetMetric( pPool->GetWhich(
659 													SID_ATTR_GRAF_CROP ) ));
660 
661 		sal_Int64 nSpin = aLeftMF.Normalize(aOrigSize.Width()) / 20;
662 		nSpin = MetricField::ConvertValue( nSpin, aOrigSize.Width(), 0,
663 									   		eUnit, aLeftMF.GetUnit());
664 
665 		// Ist der Rand zu gross, wird er auf beiden Seiten auf 1/3 eingestellt.
666 		long nR = lcl_GetValue( aRightMF, eUnit );
667 		long nL = lcl_GetValue( aLeftMF, eUnit );
668 		if((nL + nR) < - aOrigSize.Width())
669 		{
670 			long nVal = aOrigSize.Width() / -3;
671 			aRightMF.SetValue( aRightMF.Normalize( nVal ), eUnit );
672 			aLeftMF.SetValue( aLeftMF.Normalize( nVal ), eUnit );
673 			aExampleWN.SetLeft(nVal);
674 			aExampleWN.SetRight(nVal);
675 		}
676 		long nUp  = lcl_GetValue(aTopMF, eUnit );
677 		long nLow = lcl_GetValue(aBottomMF, eUnit );
678 		if((nUp + nLow) < - aOrigSize.Height())
679 		{
680 			long nVal = aOrigSize.Height() / -3;
681 			aTopMF.SetValue( aTopMF.Normalize( nVal ), eUnit );
682 			aBottomMF.SetValue( aBottomMF.Normalize( nVal ), eUnit );
683 			aExampleWN.SetTop(nVal);
684 			aExampleWN.SetBottom(nVal);
685 		}
686 
687 		aLeftMF.SetSpinSize(nSpin);
688 		aRightMF.SetSpinSize(nSpin);
689 		nSpin = aTopMF.Normalize(aOrigSize.Height()) / 20;
690 		nSpin = MetricField::ConvertValue( nSpin, aOrigSize.Width(), 0,
691 									   		eUnit, aLeftMF.GetUnit() );
692 		aTopMF.SetSpinSize(nSpin);
693 		aBottomMF.SetSpinSize(nSpin);
694 
695 		//Originalgroesse anzeigen
696 		const FieldUnit eMetric = GetModuleFieldUnit( GetItemSet() );
697 
698 		MetricField aFld(this, WB_HIDE);
699 		SetFieldUnit( aFld, eMetric );
700 		aFld.SetDecimalDigits( aWidthMF.GetDecimalDigits() );
701         aFld.SetMax( LONG_MAX - 1 );
702 
703 		aFld.SetValue( aFld.Normalize( aOrigSize.Width() ), eUnit );
704 		String sTemp = aFld.GetText();
705 		aFld.SetValue( aFld.Normalize( aOrigSize.Height() ), eUnit );
706 		sTemp += UniString::CreateFromAscii(" x ");
707 		sTemp += aFld.GetText();
708 		aOrigSizeFT.SetText(sTemp);
709 	}
710 	aLeftFT			.Enable(bFound);
711 	aLeftMF         .Enable(bFound);
712 	aRightFT        .Enable(bFound);
713 	aRightMF        .Enable(bFound);
714 	aTopFT          .Enable(bFound);
715 	aTopMF          .Enable(bFound);
716 	aBottomFT       .Enable(bFound);
717 	aBottomMF       .Enable(bFound);
718 	aSizeConstRB    .Enable(bFound);
719 	aZoomConstRB    .Enable(bFound);
720 	aWidthFT        .Enable(bFound);
721 	aWidthMF        .Enable(bFound);
722 	aHeightFT       .Enable(bFound);
723 	aHeightMF		.Enable(bFound);
724 	aWidthZoomFT    .Enable(bFound);
725 	aWidthZoomMF    .Enable(bFound);
726 	aHeightZoomFT   .Enable(bFound);
727 	aHeightZoomMF   .Enable(bFound);
728 	aExampleWN      .Enable(bFound);
729 	aOrigSizePB     .Enable(bFound);
730 	aOrigSizeFT     .Enable(bFound);
731 }
732 
733 IMPL_LINK( SvxGrfCropPage, Timeout, Timer *, EMPTYARG )
734 {
735 	DBG_ASSERT(pLastCropField,"Timeout ohne Feld?");
736 	CropHdl(pLastCropField);
737 	pLastCropField = 0;
738 	return 0;
739 }
740 
741 
742 IMPL_LINK( SvxGrfCropPage, CropLoseFocusHdl, MetricField*, pField )
743 {
744 	aTimer.Stop();
745 	CropHdl(pField);
746 	pLastCropField = 0;
747 	return 0;
748 }
749 
750 
751 IMPL_LINK( SvxGrfCropPage, CropModifyHdl, MetricField *, pField )
752 {
753 	aTimer.Start();
754 	pLastCropField = pField;
755 	return 0;
756 }
757 
758 Size SvxGrfCropPage::GetGrfOrigSize( const Graphic& rGrf ) const
759 {
760     const MapMode aMapTwip( MAP_TWIP );
761     Size aSize( rGrf.GetPrefSize() );
762     if( MAP_PIXEL == rGrf.GetPrefMapMode().GetMapUnit() )
763         aSize = PixelToLogic( aSize, aMapTwip );
764     else
765         aSize = OutputDevice::LogicToLogic( aSize,
766 										rGrf.GetPrefMapMode(), aMapTwip );
767 	return aSize;
768 }
769 
770 /*****************************************************************/
771 
772 SvxGrfCropPage::SvxCropExample::SvxCropExample( Window* pPar,
773 												const ResId& rResId )
774 	: Window( pPar, rResId ),
775     aFrameSize( OutputDevice::LogicToLogic(
776                             Size( CM_1_TO_TWIP / 2, CM_1_TO_TWIP / 2 ),
777                             MapMode( MAP_TWIP ), GetMapMode() )),
778     aTopLeft(0,0), aBottomRight(0,0)
779 {
780     SetBorderStyle( WINDOW_BORDER_MONO );
781 }
782 
783 void SvxGrfCropPage::SvxCropExample::Paint( const Rectangle& )
784 {
785 	Size aWinSize( PixelToLogic(GetOutputSizePixel() ));
786     SetLineColor();
787 	SetFillColor( GetSettings().GetStyleSettings().GetWindowColor() );
788 	SetRasterOp( ROP_OVERPAINT );
789     DrawRect( Rectangle( Point(), aWinSize ) );
790 
791     SetLineColor( Color( COL_WHITE ) );
792 	Rectangle aRect(Point((aWinSize.Width() - aFrameSize.Width())/2,
793 						  (aWinSize.Height() - aFrameSize.Height())/2),
794 						  aFrameSize );
795 	aGrf.Draw( this,  aRect.TopLeft(), aRect.GetSize() );
796 
797 	Size aSz( 2, 0 );
798 	aSz = PixelToLogic( aSz );
799 	SetFillColor( Color( COL_TRANSPARENT ) );
800 	SetRasterOp( ROP_INVERT );
801 	aRect.Left() 	+= aTopLeft.Y();
802 	aRect.Top() 	+= aTopLeft.X();
803 	aRect.Right() 	-= aBottomRight.Y();
804 	aRect.Bottom() 	-= aBottomRight.X();
805 	DrawRect( aRect );
806 }
807 
808 void SvxGrfCropPage::SvxCropExample::SetFrameSize( const Size& rSz )
809 {
810 	aFrameSize = rSz;
811 	if(!aFrameSize.Width())
812 		aFrameSize.Width() = 1;
813 	if(!aFrameSize.Height())
814 		aFrameSize.Height() = 1;
815 	Size aWinSize( GetOutputSizePixel() );
816 	Fraction aXScale( aWinSize.Width() * 4, aFrameSize.Width() * 5 );
817 	Fraction aYScale( aWinSize.Height() * 4, aFrameSize.Height() * 5 );
818 
819 	if( aYScale < aXScale )
820 		aXScale = aYScale;
821 
822 	MapMode aMapMode( GetMapMode() );
823 
824 	aMapMode.SetScaleX( aXScale );
825 	aMapMode.SetScaleY( aXScale );
826 
827 	SetMapMode( aMapMode );
828 	Invalidate();
829 }
830 
831 
832 
833 
834