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_svx.hxx"
26 #include <svx/rubydialog.hxx>
27 #include <tools/shl.hxx>
28 #include <svx/dialmgr.hxx>
29 #include <svx/dialogs.hrc>
30 #include <rubydialog.hrc>
31 #include <sfx2/app.hxx>
32 #include <sfx2/dispatch.hxx>
33 #include <sfx2/viewfrm.hxx>
34 #include <svl/eitem.hxx>
35 #include <com/sun/star/frame/XController.hpp>
36 #include <com/sun/star/style/XStyle.hpp>
37 #include <com/sun/star/text/XRubySelection.hpp>
38 #include <com/sun/star/beans/PropertyValues.hpp>
39 #include <com/sun/star/beans/XPropertySet.hpp>
40 #include <com/sun/star/beans/XPropertySetInfo.hpp>
41 #include <com/sun/star/container/XNameContainer.hpp>
42 #include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
43 #include <com/sun/star/text/RubyAdjust.hpp>
44 #include <com/sun/star/view/XSelectionChangeListener.hpp>
45 #include <com/sun/star/view/XSelectionSupplier.hpp>
46 #ifndef _CPPUHELPER_IMPLBASE3_HXX_
47 #include <cppuhelper/implbase1.hxx>
48 #endif
49 #include <svtools/colorcfg.hxx>
50
51 using namespace com::sun::star::uno;
52 using namespace com::sun::star::frame;
53 using namespace com::sun::star::text;
54 using namespace com::sun::star::beans;
55 using namespace com::sun::star::style;
56 using namespace com::sun::star::text;
57 using namespace com::sun::star::view;
58 using namespace com::sun::star::lang;
59 using namespace com::sun::star::container;
60 using rtl::OUString;
61
62 #define C2U(cChar) rtl::OUString::createFromAscii(cChar)
63
64 SFX_IMPL_CHILDWINDOW( SvxRubyChildWindow, SID_RUBY_DIALOG );
65
66 static const sal_Char cRubyBaseText[] = "RubyBaseText";
67 static const sal_Char cRubyText[] = "RubyText";
68 static const sal_Char cCharacterStyles[] = "CharacterStyles";
69 static const sal_Char cRubyAdjust[] = "RubyAdjust";
70 static const sal_Char cRubyIsAbove[] = "RubyIsAbove";
71 static const sal_Char cDisplayName[] = "DisplayName";
72 static const sal_Char cRubyCharStyleName[] = "RubyCharStyleName";
73 static const sal_Char cRubies[] = "Rubies";
74 /* -----------------------------09.01.01 17:24--------------------------------
75
76 ---------------------------------------------------------------------------*/
SvxRubyChildWindow(Window * _pParent,sal_uInt16 nId,SfxBindings * pBindings,SfxChildWinInfo * pInfo)77 SvxRubyChildWindow::SvxRubyChildWindow( Window* _pParent, sal_uInt16 nId,
78 SfxBindings* pBindings, SfxChildWinInfo* pInfo) :
79 SfxChildWindow(_pParent, nId)
80 {
81 pWindow = new SvxRubyDialog( pBindings, this, _pParent, SVX_RES( RID_SVXDLG_RUBY ) );
82 SvxRubyDialog* pDlg = (SvxRubyDialog*) pWindow;
83
84 if ( pInfo->nFlags & SFX_CHILDWIN_ZOOMIN )
85 pDlg->RollUp();
86
87 eChildAlignment = SFX_ALIGN_NOALIGNMENT;
88
89 pDlg->Initialize( pInfo );
90 }
91 /* -----------------------------10.01.01 13:53--------------------------------
92
93 ---------------------------------------------------------------------------*/
GetInfo() const94 SfxChildWinInfo SvxRubyChildWindow::GetInfo() const
95 {
96 return SfxChildWindow::GetInfo();
97 }
98 /* -----------------------------09.01.01 17:17--------------------------------
99
100 ---------------------------------------------------------------------------*/
101 class SvxRubyData_Impl : public cppu::WeakImplHelper1
102 < ::com::sun::star::view::XSelectionChangeListener >
103 {
104 Reference<XModel> xModel;
105 Reference<XRubySelection> xSelection;
106 Sequence<PropertyValues> aRubyValues;
107 Reference<XController> xController;
108 sal_Bool bHasSelectionChanged;
109 public:
110 SvxRubyData_Impl();
111 ~SvxRubyData_Impl();
112
113 void SetController(Reference<XController> xCtrl);
GetModel()114 Reference<XModel> GetModel()
115 {
116 if(!xController.is())
117 xModel = 0;
118 else
119 xModel = xController->getModel();
120 return xModel;
121 }
HasSelectionChanged() const122 sal_Bool HasSelectionChanged() const{return bHasSelectionChanged;}
GetRubySelection()123 Reference<XRubySelection> GetRubySelection()
124 {
125 xSelection = Reference<XRubySelection>(xController, UNO_QUERY);
126 return xSelection;
127 }
UpdateRubyValues(sal_Bool bAutoUpdate)128 void UpdateRubyValues(sal_Bool bAutoUpdate)
129 {
130 if(!xSelection.is())
131 aRubyValues.realloc(0);
132 else
133 aRubyValues = xSelection->getRubyList(bAutoUpdate);
134 bHasSelectionChanged = sal_False;
135 }
GetRubyValues()136 Sequence<PropertyValues>& GetRubyValues() {return aRubyValues;}
137 void AssertOneEntry();
138
139 virtual void SAL_CALL selectionChanged( const ::com::sun::star::lang::EventObject& aEvent ) throw (RuntimeException);
140 virtual void SAL_CALL disposing( const ::com::sun::star::lang::EventObject& Source ) throw (RuntimeException);
141
142 };
143 //-----------------------------------------------------------------------------
SvxRubyData_Impl()144 SvxRubyData_Impl::SvxRubyData_Impl() :
145 bHasSelectionChanged(sal_False)
146 {
147 }
148 //-----------------------------------------------------------------------------
~SvxRubyData_Impl()149 SvxRubyData_Impl::~SvxRubyData_Impl()
150 {
151 }
152 //-----------------------------------------------------------------------------
SetController(Reference<XController> xCtrl)153 void SvxRubyData_Impl::SetController(Reference<XController> xCtrl)
154 {
155 if(xCtrl.get() != xController.get())
156 {
157 try
158 {
159 Reference<XSelectionSupplier> xSelSupp(xController, UNO_QUERY);
160 if(xSelSupp.is())
161 xSelSupp->removeSelectionChangeListener(this);
162
163 bHasSelectionChanged = sal_True;
164 xController = xCtrl;
165 xSelSupp = Reference<XSelectionSupplier>(xController, UNO_QUERY);
166 if(xSelSupp.is())
167 xSelSupp->addSelectionChangeListener(this);
168 }
169 catch(Exception&)
170 {}
171 }
172 }
173 //-----------------------------------------------------------------------------
selectionChanged(const EventObject &)174 void SvxRubyData_Impl::selectionChanged( const EventObject& ) throw (RuntimeException)
175 {
176 bHasSelectionChanged = sal_True;
177 }
178 //-----------------------------------------------------------------------------
disposing(const EventObject &)179 void SvxRubyData_Impl::disposing( const EventObject&) throw (RuntimeException)
180 {
181 try
182 {
183 Reference<XSelectionSupplier> xSelSupp(xController, UNO_QUERY);
184 if(xSelSupp.is())
185 xSelSupp->removeSelectionChangeListener(this);
186 }
187 catch(Exception&)
188 {}
189 xController = 0;
190 }
191 //-----------------------------------------------------------------------------
AssertOneEntry()192 void SvxRubyData_Impl::AssertOneEntry()
193 {
194 //create one entry
195 if(!aRubyValues.getLength())
196 {
197 aRubyValues.realloc(1);
198 Sequence<PropertyValue>& rValues = aRubyValues.getArray()[0];
199 rValues.realloc(5);
200 PropertyValue* pValues = rValues.getArray();
201 pValues[0].Name = C2U(cRubyBaseText);
202 pValues[1].Name = C2U(cRubyText);
203 pValues[2].Name = C2U(cRubyAdjust);
204 pValues[3].Name = C2U(cRubyIsAbove);
205 pValues[4].Name = C2U(cRubyCharStyleName);
206 }
207 }
208 /* ---------------------------------------------------------------------------
209
210 ---------------------------------------------------------------------------*/
SvxRubyDialog(SfxBindings * pBind,SfxChildWindow * pCW,Window * _pParent,const ResId & rResId)211 SvxRubyDialog::SvxRubyDialog( SfxBindings *pBind, SfxChildWindow *pCW,
212 Window* _pParent, const ResId& rResId ) :
213 SfxModelessDialog( pBind, pCW, _pParent, rResId ),
214 aLeftFT(this, ResId(FT_LEFT,*rResId.GetResMgr() )),
215 aLeft1ED(this, ResId(ED_LEFT_1,*rResId.GetResMgr() )),
216 aRightFT(this, ResId(FT_RIGHT,*rResId.GetResMgr() )),
217 aRight1ED(this, ResId(ED_RIGHT_1,*rResId.GetResMgr() )),
218 aLeft2ED(this, ResId(ED_LEFT_2,*rResId.GetResMgr() )),
219 aRight2ED(this, ResId(ED_RIGHT_2,*rResId.GetResMgr() )),
220 aLeft3ED(this, ResId(ED_LEFT_3,*rResId.GetResMgr() )),
221 aRight3ED(this, ResId(ED_RIGHT_3,*rResId.GetResMgr() )),
222 aLeft4ED(this, ResId(ED_LEFT_4,*rResId.GetResMgr() )),
223 aRight4ED(this, ResId(ED_RIGHT_4,*rResId.GetResMgr() )),
224 aScrollSB(this, ResId(SB_SCROLL,*rResId.GetResMgr() )),
225 aAutoDetectionCB(this, ResId(CB_AUTO_DETECT,*rResId.GetResMgr() )),
226 aAdjustFT(this, ResId(FT_ADJUST,*rResId.GetResMgr() )),
227 aAdjustLB(this, ResId(LB_ADJUST,*rResId.GetResMgr() )),
228 aPositionFT(this, ResId(FT_POSITION,*rResId.GetResMgr() )),
229 aPositionLB(this, ResId(LB_POSITION,*rResId.GetResMgr() )),
230 aCharStyleFT(this, ResId(FT_CHAR_STYLE,*rResId.GetResMgr() )),
231 aCharStyleLB(this, ResId(LB_CHAR_STYLE,*rResId.GetResMgr() )),
232 aStylistPB(this, ResId(PB_STYLIST,*rResId.GetResMgr() )),
233 aPreviewFT(this, ResId(FT_PREVIEW,*rResId.GetResMgr() )),
234 aPreviewWin(*this, ResId(WIN_PREVIEW,*rResId.GetResMgr() )),
235 aApplyPB(this, ResId(PB_APPLY,*rResId.GetResMgr() )),
236 aClosePB(this, ResId(PB_CLOSE,*rResId.GetResMgr() )),
237 aHelpPB(this, ResId(PB_HELP,*rResId.GetResMgr() )),
238 nLastPos(0),
239 nCurrentEdit(0),
240 bModified(sal_False),
241 pBindings(pBind)
242 {
243 xImpl = pImpl = new SvxRubyData_Impl;
244 FreeResource();
245 //#85638# automatic detection not yet available
246 aAutoDetectionCB.Hide();
247 aEditArr[0] = &aLeft1ED; aEditArr[1] = &aRight1ED;
248 aEditArr[2] = &aLeft2ED; aEditArr[3] = &aRight2ED;
249 aEditArr[4] = &aLeft3ED; aEditArr[5] = &aRight3ED;
250 aEditArr[6] = &aLeft4ED; aEditArr[7] = &aRight4ED;
251
252 aApplyPB.SetClickHdl(LINK(this, SvxRubyDialog, ApplyHdl_Impl));
253 aClosePB.SetClickHdl(LINK(this, SvxRubyDialog, CloseHdl_Impl));
254 aStylistPB.SetClickHdl(LINK(this, SvxRubyDialog, StylistHdl_Impl));
255 aAutoDetectionCB.SetClickHdl(LINK(this, SvxRubyDialog, AutomaticHdl_Impl));
256 aAdjustLB.SetSelectHdl(LINK(this, SvxRubyDialog, AdjustHdl_Impl));
257 aPositionLB.SetSelectHdl(LINK(this, SvxRubyDialog, PositionHdl_Impl));
258 aCharStyleLB.SetSelectHdl(LINK(this, SvxRubyDialog, CharStyleHdl_Impl));
259
260 Link aScrLk(LINK(this, SvxRubyDialog, ScrollHdl_Impl));
261 aScrollSB.SetScrollHdl( aScrLk );
262 aScrollSB.SetEndScrollHdl( aScrLk );
263
264 Link aEditLk(LINK(this, SvxRubyDialog, EditModifyHdl_Impl));
265 Link aScrollLk(LINK(this, SvxRubyDialog, EditScrollHdl_Impl));
266 Link aJumpLk(LINK(this, SvxRubyDialog, EditJumpHdl_Impl));
267 for(sal_uInt16 i = 0; i < 8; i++)
268 {
269 aEditArr[i]->SetModifyHdl(aEditLk);
270 aEditArr[i]->SetJumpHdl(aJumpLk);
271 if(!i || 7 == i)
272 aEditArr[i]->SetScrollHdl(aScrollLk);
273 }
274
275 UpdateColors();
276
277 String leftLabelName = aLeftFT.GetText(), rightLabelName = aRightFT.GetText();
278 aLeft2ED.SetAccessibleName(leftLabelName);
279 aLeft3ED.SetAccessibleName(leftLabelName);
280 aLeft4ED.SetAccessibleName(leftLabelName);
281 aRight2ED.SetAccessibleName(rightLabelName);
282 aRight3ED.SetAccessibleName(rightLabelName);
283 aRight4ED.SetAccessibleName(rightLabelName);
284 }
285 /* -----------------------------09.01.01 17:17--------------------------------
286
287 ---------------------------------------------------------------------------*/
~SvxRubyDialog()288 SvxRubyDialog::~SvxRubyDialog()
289 {
290 ClearCharStyleList();
291 EventObject aEvent;
292 xImpl->disposing(aEvent);
293 }
294 /* -----------------------------01.02.01 10:29--------------------------------
295
296 ---------------------------------------------------------------------------*/
ClearCharStyleList()297 void SvxRubyDialog::ClearCharStyleList()
298 {
299 for(sal_uInt16 i = 0; i < aCharStyleLB.GetEntryCount(); i++)
300 {
301 void* pData = aCharStyleLB.GetEntryData(i);
302 delete (OUString*)pData;
303 }
304 aCharStyleLB.Clear();
305 }
306 /* -----------------------------09.01.01 17:17--------------------------------
307
308 ---------------------------------------------------------------------------*/
Close()309 sal_Bool SvxRubyDialog::Close()
310 {
311 pBindings->GetDispatcher()->Execute( SID_RUBY_DIALOG,
312 SFX_CALLMODE_ASYNCHRON |
313 SFX_CALLMODE_RECORD);
314 return sal_True;
315 }
316 /* -----------------------------29.01.01 15:26--------------------------------
317
318 ---------------------------------------------------------------------------*/
Activate()319 void SvxRubyDialog::Activate()
320 {
321 SfxModelessDialog::Activate();
322 SfxPoolItem* pState = 0;
323 SfxItemState eState = pBindings->QueryState( SID_STYLE_DESIGNER, pState );
324 sal_Bool bEnable = (eState < SFX_ITEM_AVAILABLE) || !pState || !((SfxBoolItem*)pState)->GetValue();
325 aStylistPB.Enable(bEnable);
326 //get selection from current view frame
327 SfxViewFrame* pCurFrm = SfxViewFrame::Current();
328 Reference< XController > xCtrl = pCurFrm->GetFrame().GetController();
329 pImpl->SetController(xCtrl);
330 if(pImpl->HasSelectionChanged())
331 {
332
333 Reference< XRubySelection > xRubySel = pImpl->GetRubySelection();
334 pImpl->UpdateRubyValues(aAutoDetectionCB.IsChecked());
335 EnableControls(xRubySel.is());
336 if(xRubySel.is())
337 {
338 Reference< XModel > xModel = pImpl->GetModel();
339 const String sCharStyleSelect = aCharStyleLB.GetSelectEntry();
340 ClearCharStyleList();
341 Reference<XStyleFamiliesSupplier> xSupplier(xModel, UNO_QUERY);
342 if(xSupplier.is())
343 {
344 try
345 {
346 Reference<XNameAccess> xFam = xSupplier->getStyleFamilies();
347 Any aChar = xFam->getByName(C2U(cCharacterStyles));
348 Reference<XNameContainer> xChar;
349 aChar >>= xChar;
350 Reference<XIndexAccess> xCharIdx(xChar, UNO_QUERY);
351 if(xCharIdx.is())
352 {
353 OUString sUIName(C2U(cDisplayName));
354 for(sal_Int32 nStyle = 0; nStyle < xCharIdx->getCount(); nStyle++)
355 {
356 Any aStyle = xCharIdx->getByIndex(nStyle);
357 Reference<XStyle> xStyle;
358 aStyle >>= xStyle;
359 Reference<XPropertySet> xPrSet(xStyle, UNO_QUERY);
360 OUString sName, sCoreName;
361 if(xPrSet.is())
362 {
363 Reference<XPropertySetInfo> xInfo = xPrSet->getPropertySetInfo();
364 if(xInfo->hasPropertyByName(sUIName))
365 {
366 Any aName = xPrSet->getPropertyValue(sUIName);
367 aName >>= sName;
368 }
369 }
370 Reference<XNamed> xNamed(xStyle, UNO_QUERY);
371 if(xNamed.is())
372 {
373 sCoreName = xNamed->getName();
374 if(!sName.getLength())
375 sName = sCoreName;
376 }
377 if(sName.getLength())
378 {
379 sal_uInt16 nPos = aCharStyleLB.InsertEntry(sName);
380 aCharStyleLB.SetEntryData( nPos, new OUString(sCoreName) );
381
382 }
383 }
384 }
385 }
386 catch(Exception&)
387 {
388 DBG_ERROR("exception in style access");
389 }
390 if(sCharStyleSelect.Len())
391 aCharStyleLB.SelectEntry(sCharStyleSelect);
392 }
393 aCharStyleLB.Enable(xSupplier.is());
394 aCharStyleFT.Enable(xSupplier.is());
395 }
396 Update();
397 aPreviewWin.Invalidate();
398 }
399 }
400 /* -----------------------------29.01.01 15:26--------------------------------
401
402 ---------------------------------------------------------------------------*/
Deactivate()403 void SvxRubyDialog::Deactivate()
404 {
405 SfxModelessDialog::Deactivate();
406 }
407 /* -----------------------------30.01.01 15:35--------------------------------
408
409 ---------------------------------------------------------------------------*/
SetText(sal_Int32 nPos,Edit & rLeft,Edit & rRight)410 void SvxRubyDialog::SetText(sal_Int32 nPos, Edit& rLeft, Edit& rRight)
411 {
412 OUString sLeft, sRight;
413 const Sequence<PropertyValues>& aRubyValues = pImpl->GetRubyValues();
414 sal_Bool bEnable = aRubyValues.getLength() > nPos;
415 if(bEnable)
416 {
417 const Sequence<PropertyValue> aProps = aRubyValues.getConstArray()[nPos];
418 const PropertyValue* pProps = aProps.getConstArray();
419 for(sal_Int32 nProp = 0; nProp < aProps.getLength(); nProp++)
420 {
421 if(pProps[nProp].Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM(cRubyBaseText)))
422 pProps[nProp].Value >>= sLeft;
423 else if(pProps[nProp].Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM(cRubyText)))
424 pProps[nProp].Value >>= sRight;
425 }
426 }
427 else if(!nPos)
428 bEnable = sal_True;
429 rLeft.Enable(bEnable);
430 rRight.Enable(bEnable);
431 rLeft.SetText(sLeft);
432 rRight.SetText(sRight);
433 rLeft.SaveValue();
434 rRight.SaveValue();
435 }
436 //-----------------------------------------------------------------------------
GetText()437 void SvxRubyDialog::GetText()
438 {
439 long nTempLastPos = GetLastPos();
440 for(int i = 0; i < 8; i+=2)
441 {
442 if(aEditArr[i]->IsEnabled() &&
443 (aEditArr[i]->GetText() != aEditArr[i]->GetSavedValue() ||
444 aEditArr[i + 1]->GetText() != aEditArr[i + 1]->GetSavedValue()))
445 {
446 Sequence<PropertyValues>& aRubyValues = pImpl->GetRubyValues();
447 DBG_ASSERT(aRubyValues.getLength() > (i / 2 + nTempLastPos), "wrong index" );
448 SetModified(sal_True);
449 Sequence<PropertyValue> &rProps = aRubyValues.getArray()[i / 2 + nTempLastPos];
450 PropertyValue* pProps = rProps.getArray();
451 for(sal_Int32 nProp = 0; nProp < rProps.getLength(); nProp++)
452 {
453 if(pProps[nProp].Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM(cRubyBaseText)))
454 pProps[nProp].Value <<= OUString(aEditArr[i]->GetText());
455 else if(pProps[nProp].Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM(cRubyText)))
456 pProps[nProp].Value <<= OUString(aEditArr[i + 1]->GetText());
457 }
458 }
459 }
460 }
461 //-----------------------------------------------------------------------------
Update()462 void SvxRubyDialog::Update()
463 {
464 const Sequence<PropertyValues>& aRubyValues = pImpl->GetRubyValues();
465 sal_Int32 nLen = aRubyValues.getLength();
466 aScrollSB.Enable(nLen > 4);
467 aScrollSB.SetRange( Range(0, nLen > 4 ? nLen - 4 : 0));
468 aScrollSB.SetThumbPos(0);
469 SetLastPos(0);
470 SetModified(sal_False);
471
472 sal_Int16 nAdjust = -1;
473 sal_Int16 nPosition = -1;
474 OUString sCharStyleName, sTmp;
475 sal_Bool bCharStyleEqual = sal_True;
476 for(sal_Int32 nRuby = 0; nRuby < nLen; nRuby++)
477 {
478 const Sequence<PropertyValue> &rProps = aRubyValues.getConstArray()[nRuby];
479 const PropertyValue* pProps = rProps.getConstArray();
480 for(sal_Int32 nProp = 0; nProp < rProps.getLength(); nProp++)
481 {
482 if(nAdjust > -2 &&
483 pProps[nProp].Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM(cRubyAdjust)))
484 {
485 sal_Int16 nTmp = sal_Int16();
486 pProps[nProp].Value >>= nTmp;
487 if(!nRuby)
488 nAdjust = nTmp;
489 else if(nAdjust != nTmp)
490 nAdjust = -2;
491 }
492 if(nPosition > -2 &&
493 pProps[nProp].Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM(cRubyIsAbove)))
494 {
495 sal_Bool bTmp = *(sal_Bool*)pProps[nProp].Value.getValue();
496 if(!nRuby)
497 nPosition = bTmp ? 0 : 1;
498 else if( (!nPosition && !bTmp) || (nPosition == 1 && bTmp) )
499 nPosition = -2;
500 }
501 if(bCharStyleEqual &&
502 pProps[nProp].Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM(cRubyCharStyleName)))
503 {
504 pProps[nProp].Value >>= sTmp;
505 if(!nRuby)
506 sCharStyleName = sTmp;
507 else if(sCharStyleName != sTmp)
508 bCharStyleEqual = sal_False;
509 }
510 }
511 }
512 if(!nLen)
513 {
514 //enable selection if the ruby list is empty
515 nAdjust = 0;
516 nPosition = 0;
517 }
518 if(nAdjust > -1)
519 aAdjustLB.SelectEntryPos(nAdjust);
520 else
521 aAdjustLB.SetNoSelection();
522 if(nPosition > -1)
523 aPositionLB.SelectEntryPos(nPosition ? 1 : 0);
524 if(!nLen || (bCharStyleEqual && !sCharStyleName.getLength()))
525 sCharStyleName = C2U(cRubies);
526 if(sCharStyleName.getLength())
527 {
528 for(sal_uInt16 i = 0; i < aCharStyleLB.GetEntryCount(); i++)
529 {
530 const OUString* pCoreName = (const OUString*)aCharStyleLB.GetEntryData(i);
531 if(pCoreName && sCharStyleName == *pCoreName)
532 {
533 aCharStyleLB.SelectEntryPos(i);
534 break;
535 }
536 }
537 }
538 else
539 aCharStyleLB.SetNoSelection();
540
541 ScrollHdl_Impl(&aScrollSB);
542 }
543 /* -----------------------------16.02.01 14:01--------------------------------
544
545 ---------------------------------------------------------------------------*/
GetCurrentText(String & rBase,String & rRuby)546 void SvxRubyDialog::GetCurrentText(String& rBase, String& rRuby)
547 {
548 rBase = aEditArr[nCurrentEdit * 2]->GetText();
549 rRuby = aEditArr[nCurrentEdit * 2 + 1]->GetText();
550 }
551 /* -----------------------------31.01.01 14:09--------------------------------
552
553 ---------------------------------------------------------------------------*/
IMPL_LINK(SvxRubyDialog,ScrollHdl_Impl,ScrollBar *,pScroll)554 IMPL_LINK(SvxRubyDialog, ScrollHdl_Impl, ScrollBar*, pScroll)
555 {
556 long nPos = pScroll->GetThumbPos();
557 if(GetLastPos() != nPos)
558 {
559 GetText();
560 }
561 SetText(nPos++, aLeft1ED, aRight1ED);
562 SetText(nPos++, aLeft2ED, aRight2ED);
563 SetText(nPos++, aLeft3ED, aRight3ED);
564 SetText(nPos, aLeft4ED, aRight4ED);
565 SetLastPos(nPos - 3);
566 aPreviewWin.Invalidate();
567 return 0;
568 }
569 /* -----------------------------30.01.01 14:48--------------------------------
570
571 ---------------------------------------------------------------------------*/
IMPL_LINK(SvxRubyDialog,ApplyHdl_Impl,PushButton *,EMPTYARG)572 IMPL_LINK(SvxRubyDialog, ApplyHdl_Impl, PushButton*, EMPTYARG)
573 {
574 const Sequence<PropertyValues>& aRubyValues = pImpl->GetRubyValues();
575 if(!aRubyValues.getLength())
576 {
577 AssertOneEntry();
578 PositionHdl_Impl(&aPositionLB);
579 AdjustHdl_Impl(&aAdjustLB);
580 CharStyleHdl_Impl(&aCharStyleLB);
581 }
582 GetText();
583 //reset all edit fields - SaveValue is called
584 ScrollHdl_Impl(&aScrollSB);
585
586 Reference<XRubySelection> xSelection = pImpl->GetRubySelection();
587 if(IsModified() && xSelection.is())
588 {
589 try
590 {
591 xSelection->setRubyList(aRubyValues, aAutoDetectionCB.IsChecked());
592 }
593 catch(Exception& )
594 {
595 DBG_ERROR("Exception caught");
596 }
597 }
598 return 0;
599 }
600 /* -----------------------------29.01.01 09:38--------------------------------
601
602 ---------------------------------------------------------------------------*/
IMPL_LINK(SvxRubyDialog,CloseHdl_Impl,PushButton *,EMPTYARG)603 IMPL_LINK(SvxRubyDialog, CloseHdl_Impl, PushButton*, EMPTYARG)
604 {
605 Close();
606 return 0;
607 }
608 /* -----------------------------29.01.01 15:10--------------------------------
609
610 ---------------------------------------------------------------------------*/
IMPL_LINK(SvxRubyDialog,StylistHdl_Impl,PushButton *,EMPTYARG)611 IMPL_LINK(SvxRubyDialog, StylistHdl_Impl, PushButton*, EMPTYARG)
612 {
613 SfxPoolItem* pState = 0;
614 SfxItemState eState = pBindings->QueryState( SID_STYLE_DESIGNER, pState );
615 if(eState <= SFX_ITEM_SET || !pState || !((SfxBoolItem*)pState)->GetValue())
616 {
617 pBindings->GetDispatcher()->Execute( SID_STYLE_DESIGNER,
618 SFX_CALLMODE_ASYNCHRON |
619 SFX_CALLMODE_RECORD);
620 }
621 return 0;
622 }
623 /* -----------------------------30.01.01 15:32--------------------------------
624
625 ---------------------------------------------------------------------------*/
IMPL_LINK(SvxRubyDialog,AutomaticHdl_Impl,CheckBox *,pBox)626 IMPL_LINK(SvxRubyDialog, AutomaticHdl_Impl, CheckBox*, pBox)
627 {
628 pImpl->UpdateRubyValues(pBox->IsChecked());
629 Update();
630 return 0;
631 }
632 /* -----------------------------31.01.01 16:37--------------------------------
633
634 ---------------------------------------------------------------------------*/
IMPL_LINK(SvxRubyDialog,AdjustHdl_Impl,ListBox *,pBox)635 IMPL_LINK(SvxRubyDialog, AdjustHdl_Impl, ListBox*, pBox)
636 {
637 AssertOneEntry();
638 sal_Int16 nAdjust = pBox->GetSelectEntryPos();
639 Sequence<PropertyValues>& aRubyValues = pImpl->GetRubyValues();
640 for(sal_Int32 nRuby = 0; nRuby < aRubyValues.getLength(); nRuby++)
641 {
642 Sequence<PropertyValue> &rProps = aRubyValues.getArray()[nRuby];
643 PropertyValue* pProps = rProps.getArray();
644 for(sal_Int32 nProp = 0; nProp < rProps.getLength(); nProp++)
645 {
646 if(pProps[nProp].Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM(cRubyAdjust)))
647 pProps[nProp].Value <<= nAdjust;
648 }
649 SetModified(sal_True);
650 }
651 aPreviewWin.Invalidate();
652 return 0;
653 }
654 /* -----------------------------01.06.01 10:24--------------------------------
655
656 ---------------------------------------------------------------------------*/
IMPL_LINK(SvxRubyDialog,PositionHdl_Impl,ListBox *,pBox)657 IMPL_LINK(SvxRubyDialog, PositionHdl_Impl, ListBox*, pBox)
658 {
659 AssertOneEntry();
660 sal_Bool bAbove = !pBox->GetSelectEntryPos();
661 const Type& rType = ::getBooleanCppuType();
662 Sequence<PropertyValues>& aRubyValues = pImpl->GetRubyValues();
663 for(sal_Int32 nRuby = 0; nRuby < aRubyValues.getLength(); nRuby++)
664 {
665 Sequence<PropertyValue> &rProps = aRubyValues.getArray()[nRuby];
666 PropertyValue* pProps = rProps.getArray();
667 for(sal_Int32 nProp = 0; nProp < rProps.getLength(); nProp++)
668 {
669 if(pProps[nProp].Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM(cRubyIsAbove)))
670 pProps[nProp].Value.setValue(&bAbove, rType);
671 }
672 SetModified(sal_True);
673 }
674 aPreviewWin.Invalidate();
675 return 0;
676 }
677 /* -----------------------------01.02.01 10:06--------------------------------
678
679 ---------------------------------------------------------------------------*/
IMPL_LINK(SvxRubyDialog,CharStyleHdl_Impl,ListBox *,EMPTYARG)680 IMPL_LINK(SvxRubyDialog, CharStyleHdl_Impl, ListBox*, EMPTYARG )
681 {
682 AssertOneEntry();
683 OUString sStyleName;
684 if(LISTBOX_ENTRY_NOTFOUND != aCharStyleLB.GetSelectEntryPos())
685 sStyleName = *(OUString*) aCharStyleLB.GetEntryData(aCharStyleLB.GetSelectEntryPos());
686 Sequence<PropertyValues>& aRubyValues = pImpl->GetRubyValues();
687 for(sal_Int32 nRuby = 0; nRuby < aRubyValues.getLength(); nRuby++)
688 {
689 Sequence<PropertyValue> &rProps = aRubyValues.getArray()[nRuby];
690 PropertyValue* pProps = rProps.getArray();
691 for(sal_Int32 nProp = 0; nProp < rProps.getLength(); nProp++)
692 {
693 if(pProps[nProp].Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM(cRubyCharStyleName)))
694 {
695 pProps[nProp].Value <<= sStyleName;
696 }
697 }
698 SetModified(sal_True);
699 }
700 return 0;
701 }
702 /* -----------------------------16.02.01 08:35--------------------------------
703
704 ---------------------------------------------------------------------------*/
IMPL_LINK(SvxRubyDialog,EditModifyHdl_Impl,Edit *,pEdit)705 IMPL_LINK(SvxRubyDialog, EditModifyHdl_Impl, Edit*, pEdit)
706 {
707 for(sal_uInt16 i = 0; i < 8; i++)
708 {
709 if(pEdit == aEditArr[i])
710 {
711 nCurrentEdit = i / 2;
712 break;
713 }
714 }
715 aPreviewWin.Invalidate();
716 return 0;
717 }
718 /* -----------------------------17.07.01 09:11--------------------------------
719
720 ---------------------------------------------------------------------------*/
IMPL_LINK(SvxRubyDialog,EditScrollHdl_Impl,sal_Int32 *,pParam)721 IMPL_LINK(SvxRubyDialog, EditScrollHdl_Impl, sal_Int32*, pParam)
722 {
723 long nRet = 0;
724 if(aScrollSB.IsEnabled())
725 {
726 //scroll forward
727 if(*pParam > 0 && (aEditArr[7]->HasFocus() || aEditArr[6]->HasFocus() ))
728 {
729 if(aScrollSB.GetRangeMax() > aScrollSB.GetThumbPos())
730 {
731 aScrollSB.SetThumbPos(aScrollSB.GetThumbPos() + 1);
732 aEditArr[6]->GrabFocus();
733 nRet = 1;
734 }
735 }
736 //scroll backward
737 else if(aScrollSB.GetThumbPos() && (aEditArr[0]->HasFocus()||aEditArr[1]->HasFocus()) )
738 {
739 aScrollSB.SetThumbPos(aScrollSB.GetThumbPos() - 1);
740 aEditArr[1]->GrabFocus();
741 nRet = 1;
742 }
743 if(nRet)
744 ScrollHdl_Impl(&aScrollSB);
745 }
746 return nRet;
747 }
748 /* -----------------------------20.07.2001 15:18------------------------------
749
750 ---------------------------------------------------------------------------*/
IMPL_LINK(SvxRubyDialog,EditJumpHdl_Impl,sal_Int32 *,pParam)751 IMPL_LINK(SvxRubyDialog, EditJumpHdl_Impl, sal_Int32*, pParam)
752 {
753 sal_uInt16 nIndex = USHRT_MAX;
754 for(sal_uInt16 i = 0; i < 8; i++)
755 {
756 if(aEditArr[i]->HasFocus())
757 nIndex = i;
758 }
759 if(nIndex < 8)
760 {
761 if(*pParam > 0)
762 {
763 if(nIndex < 6)
764 aEditArr[nIndex + 2]->GrabFocus();
765 else if( EditScrollHdl_Impl(pParam))
766 aEditArr[nIndex]->GrabFocus();
767 }
768 else
769 {
770 if(nIndex > 1)
771 aEditArr[nIndex - 2]->GrabFocus();
772 else if( EditScrollHdl_Impl(pParam))
773 aEditArr[nIndex]->GrabFocus();
774 }
775 }
776 return 0;
777 };
778 /* -----------------------------19.06.01 11:33--------------------------------
779
780 ---------------------------------------------------------------------------*/
AssertOneEntry()781 void SvxRubyDialog::AssertOneEntry()
782 {
783 pImpl->AssertOneEntry();
784 }
785
786 // ----------------------------------------------------------------------------
787
UpdateColors(void)788 void SvxRubyDialog::UpdateColors( void )
789 {
790 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
791 svtools::ColorConfig aColorConfig;
792
793 Font aFnt( aPreviewWin.GetFont() );
794
795 Color aNewTextCol( aColorConfig.GetColorValue( svtools::FONTCOLOR ).nColor );
796 Color aNewFillCol( rStyleSettings.GetWindowColor() );
797
798 if( aNewFillCol != aFnt.GetFillColor() || aNewTextCol != aFnt.GetColor() )
799 {
800 aFnt.SetFillColor( aNewFillCol );
801 aFnt.SetColor( aNewTextCol );
802 aPreviewWin.SetFont( aFnt );
803
804 aPreviewWin.Invalidate();
805 }
806 }
807
808 // ----------------------------------------------------------------------------
809
DataChanged(const DataChangedEvent & rDCEvt)810 void SvxRubyDialog::DataChanged( const DataChangedEvent& rDCEvt )
811 {
812 SfxModelessDialog::DataChanged( rDCEvt );
813
814 if( ( rDCEvt.GetType() == DATACHANGED_SETTINGS ) && ( rDCEvt.GetFlags() & SETTINGS_STYLE ) )
815 UpdateColors();
816 }
817
818 /* -----------------------------29.01.01 15:44--------------------------------
819
820 ---------------------------------------------------------------------------*/
lcl_MoveBox(long nOffset,Edit & rLeft,Edit & rRight)821 void lcl_MoveBox(long nOffset, Edit& rLeft, Edit& rRight)
822 {
823 Size aLeftSz(rLeft.GetSizePixel());
824 Point aRightPos(rRight.GetPosPixel());
825 Size aRightSz(rRight.GetSizePixel());
826 aLeftSz.Width() += nOffset;
827 aRightSz.Width() -= nOffset;
828 aRightPos.X() += nOffset;
829 rLeft.SetSizePixel(aLeftSz);
830 rRight.SetPosSizePixel(aRightPos, aRightSz);
831
832 }
833 /* -----------------------------16.02.01 08:09--------------------------------
834
835 ---------------------------------------------------------------------------*/
RubyPreview(SvxRubyDialog & rParent,const ResId & rResId)836 RubyPreview::RubyPreview(SvxRubyDialog& rParent, const ResId& rResId) :
837 Window(&rParent, rResId),
838 rParentDlg(rParent)
839 {
840 SetMapMode(MAP_TWIP);
841 Size aWinSize = GetOutputSize();
842
843 Font aFont = GetFont();
844 aFont.SetHeight(aWinSize.Height() / 4);
845 SetFont(aFont);
846
847 SetBorderStyle( WINDOW_BORDER_MONO );
848 }
849 /* -----------------------------29.01.01 14:05--------------------------------
850
851 ---------------------------------------------------------------------------*/
Paint(const Rectangle &)852 void RubyPreview::Paint( const Rectangle& /* rRect */ )
853 {
854 Font aRubyFont = GetFont();
855 Font aSaveFont(aRubyFont);
856 aRubyFont.SetHeight(aRubyFont.GetHeight() * 70 / 100);
857
858 Size aWinSize = GetOutputSize();
859 Rectangle aRect(Point(0, 0), aWinSize);
860 SetLineColor();
861 SetFillColor( aSaveFont.GetFillColor() );
862 DrawRect(aRect);
863
864 String sBaseText, sRubyText;
865 rParentDlg.GetCurrentText(sBaseText, sRubyText);
866
867 long nTextHeight = GetTextHeight();
868 long nBaseWidth = GetTextWidth(sBaseText);
869 SetFont(aRubyFont);
870 long nRubyWidth = GetTextWidth(sRubyText);
871 SetFont(aSaveFont);
872
873 sal_uInt16 nAdjust = rParentDlg.aAdjustLB.GetSelectEntryPos();
874 //use center if no adjustment is available
875 if(nAdjust > 4)
876 nAdjust = 1;
877
878 //which part is stretched ?
879 sal_Bool bRubyStretch = nBaseWidth >= nRubyWidth;
880
881 long nCenter = aWinSize.Width() / 2;
882 long nLeftStart = nCenter - (bRubyStretch ? (nBaseWidth / 2) : (nRubyWidth / 2));
883 long nRightEnd = nCenter + (bRubyStretch ? (nBaseWidth / 2) : (nRubyWidth / 2));
884
885 long nYRuby = aWinSize.Height() / 4 - nTextHeight / 2;
886 long nYBase = aWinSize.Height() * 3 / 4 - nTextHeight / 2;
887
888 //use above also if no selection is set
889 sal_Bool bAbove = rParentDlg.aPositionLB.GetSelectEntryPos() != 1;
890 if(!bAbove)
891 {
892 long nTmp = nYRuby;
893 nYRuby = nYBase;
894 nYBase = nTmp;
895 }
896 long nYOutput, nOutTextWidth;
897 String sOutputText;
898
899
900 if(bRubyStretch)
901 {
902 DrawText( Point( nLeftStart , nYBase), sBaseText );
903 nYOutput = nYRuby;
904 sOutputText = sRubyText;
905 nOutTextWidth = nRubyWidth;
906 SetFont(aRubyFont);
907 }
908 else
909 {
910 SetFont(aRubyFont);
911 DrawText( Point( nLeftStart , nYRuby), sRubyText );
912 nYOutput = nYBase;
913 sOutputText = sBaseText;
914 nOutTextWidth = nBaseWidth;
915 SetFont(aSaveFont);
916 }
917
918 switch(nAdjust)
919 {
920 case RubyAdjust_LEFT:
921 DrawText( Point( nLeftStart , nYOutput), sOutputText );
922 break;
923 case RubyAdjust_RIGHT:
924 DrawText( Point( nRightEnd - nOutTextWidth, nYOutput), sOutputText );
925 break;
926 case RubyAdjust_INDENT_BLOCK:
927 {
928 long nCharWidth = GetTextWidth(String::CreateFromAscii("X"));
929 if(nOutTextWidth < (nRightEnd - nLeftStart - nCharWidth))
930 {
931 nCharWidth /= 2;
932 nLeftStart += nCharWidth;
933 nRightEnd -= nCharWidth;
934 }
935 }
936 // no break!
937 case RubyAdjust_BLOCK:
938 if(sOutputText.Len() > 1)
939 {
940 xub_StrLen nCount = sOutputText.Len();
941 long nSpace = ((nRightEnd - nLeftStart) - GetTextWidth(sOutputText)) / (nCount - 1);
942 for(xub_StrLen i = 0; i < nCount; i++)
943 {
944 sal_Unicode cChar = sOutputText.GetChar(i);
945 DrawText( Point( nLeftStart , nYOutput), cChar);
946 long nCharWidth = GetTextWidth(cChar);
947 nLeftStart += nCharWidth + nSpace;
948 }
949 break;
950 }
951 //no break;
952 case RubyAdjust_CENTER:
953 DrawText( Point( nCenter - nOutTextWidth / 2 , nYOutput), sOutputText );
954 break;
955 }
956 SetFont(aSaveFont);
957 }
958 /* -----------------------------16.02.01 15:12--------------------------------
959
960 ---------------------------------------------------------------------------*/
GetFocus()961 void RubyEdit::GetFocus()
962 {
963 GetModifyHdl().Call(this);
964 Edit::GetFocus();
965 }
966 /* -----------------------------17.07.01 09:00--------------------------------
967
968 ---------------------------------------------------------------------------*/
PreNotify(NotifyEvent & rNEvt)969 long RubyEdit::PreNotify( NotifyEvent& rNEvt )
970 {
971 long nHandled = 0;
972 if ( rNEvt.GetType() == EVENT_KEYINPUT )
973 {
974 const KeyEvent* pKEvt = rNEvt.GetKeyEvent();
975 const KeyCode& rKeyCode = pKEvt->GetKeyCode();
976 sal_uInt16 nMod = rKeyCode.GetModifier();
977 sal_uInt16 nCode = rKeyCode.GetCode();
978 if( nCode == KEY_TAB && (!nMod || KEY_SHIFT == nMod))
979 {
980 sal_Int32 nParam = KEY_SHIFT == nMod ? -1 : 1;
981 if(aScrollHdl.IsSet() && aScrollHdl.Call(&nParam))
982 nHandled = 1;
983 }
984 else if(KEY_UP == nCode || KEY_DOWN == nCode)
985 {
986 sal_Int32 nParam = KEY_UP == nCode ? -1 : 1;
987 aJumpHdl.Call(&nParam);
988 }
989 }
990 if(!nHandled)
991 nHandled = Edit::PreNotify(rNEvt);
992 return nHandled;
993 }
994
995