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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 94 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); 114 Reference<XModel> GetModel() 115 { 116 if(!xController.is()) 117 xModel = 0; 118 else 119 xModel = xController->getModel(); 120 return xModel; 121 } 122 sal_Bool HasSelectionChanged() const{return bHasSelectionChanged;} 123 Reference<XRubySelection> GetRubySelection() 124 { 125 xSelection = Reference<XRubySelection>(xController, UNO_QUERY); 126 return xSelection; 127 } 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 } 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 //----------------------------------------------------------------------------- 144 SvxRubyData_Impl::SvxRubyData_Impl() : 145 bHasSelectionChanged(sal_False) 146 { 147 } 148 //----------------------------------------------------------------------------- 149 SvxRubyData_Impl::~SvxRubyData_Impl() 150 { 151 } 152 //----------------------------------------------------------------------------- 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 //----------------------------------------------------------------------------- 174 void SvxRubyData_Impl::selectionChanged( const EventObject& ) throw (RuntimeException) 175 { 176 bHasSelectionChanged = sal_True; 177 } 178 //----------------------------------------------------------------------------- 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 //----------------------------------------------------------------------------- 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 288 SvxRubyDialog::~SvxRubyDialog() 289 { 290 ClearCharStyleList(); 291 EventObject aEvent; 292 xImpl->disposing(aEvent); 293 } 294 /* -----------------------------01.02.01 10:29-------------------------------- 295 296 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 403 void SvxRubyDialog::Deactivate() 404 { 405 SfxModelessDialog::Deactivate(); 406 } 407 /* -----------------------------30.01.01 15:35-------------------------------- 408 409 ---------------------------------------------------------------------------*/ 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 //----------------------------------------------------------------------------- 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 //----------------------------------------------------------------------------- 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 603 IMPL_LINK(SvxRubyDialog, CloseHdl_Impl, PushButton*, EMPTYARG) 604 { 605 Close(); 606 return 0; 607 } 608 /* -----------------------------29.01.01 15:10-------------------------------- 609 610 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 781 void SvxRubyDialog::AssertOneEntry() 782 { 783 pImpl->AssertOneEntry(); 784 } 785 786 // ---------------------------------------------------------------------------- 787 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 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 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 ---------------------------------------------------------------------------*/ 961 void RubyEdit::GetFocus() 962 { 963 GetModifyHdl().Call(this); 964 Edit::GetFocus(); 965 } 966 /* -----------------------------17.07.01 09:00-------------------------------- 967 968 ---------------------------------------------------------------------------*/ 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