| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_svx.hxx" |
| #include <svx/rubydialog.hxx> |
| #include <tools/shl.hxx> |
| #include <svx/dialmgr.hxx> |
| #include <svx/dialogs.hrc> |
| #include <rubydialog.hrc> |
| #include <sfx2/app.hxx> |
| #include <sfx2/dispatch.hxx> |
| #include <sfx2/viewfrm.hxx> |
| #include <svl/eitem.hxx> |
| #include <com/sun/star/frame/XController.hpp> |
| #include <com/sun/star/style/XStyle.hpp> |
| #include <com/sun/star/text/XRubySelection.hpp> |
| #include <com/sun/star/beans/PropertyValues.hpp> |
| #include <com/sun/star/beans/XPropertySet.hpp> |
| #include <com/sun/star/beans/XPropertySetInfo.hpp> |
| #include <com/sun/star/container/XNameContainer.hpp> |
| #include <com/sun/star/style/XStyleFamiliesSupplier.hpp> |
| #include <com/sun/star/text/RubyAdjust.hpp> |
| #include <com/sun/star/view/XSelectionChangeListener.hpp> |
| #include <com/sun/star/view/XSelectionSupplier.hpp> |
| #ifndef _CPPUHELPER_IMPLBASE3_HXX_ |
| #include <cppuhelper/implbase1.hxx> |
| #endif |
| #include <svtools/colorcfg.hxx> |
| |
| using namespace com::sun::star::uno; |
| using namespace com::sun::star::frame; |
| using namespace com::sun::star::text; |
| using namespace com::sun::star::beans; |
| using namespace com::sun::star::style; |
| using namespace com::sun::star::text; |
| using namespace com::sun::star::view; |
| using namespace com::sun::star::lang; |
| using namespace com::sun::star::container; |
| using rtl::OUString; |
| |
| #define C2U(cChar) rtl::OUString::createFromAscii(cChar) |
| |
| SFX_IMPL_CHILDWINDOW( SvxRubyChildWindow, SID_RUBY_DIALOG ); |
| |
| static const sal_Char cRubyBaseText[] = "RubyBaseText"; |
| static const sal_Char cRubyText[] = "RubyText"; |
| static const sal_Char cCharacterStyles[] = "CharacterStyles"; |
| static const sal_Char cRubyAdjust[] = "RubyAdjust"; |
| static const sal_Char cRubyIsAbove[] = "RubyIsAbove"; |
| static const sal_Char cDisplayName[] = "DisplayName"; |
| static const sal_Char cRubyCharStyleName[] = "RubyCharStyleName"; |
| static const sal_Char cRubies[] = "Rubies"; |
| /* -----------------------------09.01.01 17:24-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| SvxRubyChildWindow::SvxRubyChildWindow( Window* _pParent, sal_uInt16 nId, |
| SfxBindings* pBindings, SfxChildWinInfo* pInfo) : |
| SfxChildWindow(_pParent, nId) |
| { |
| pWindow = new SvxRubyDialog( pBindings, this, _pParent, SVX_RES( RID_SVXDLG_RUBY ) ); |
| SvxRubyDialog* pDlg = (SvxRubyDialog*) pWindow; |
| |
| if ( pInfo->nFlags & SFX_CHILDWIN_ZOOMIN ) |
| pDlg->RollUp(); |
| |
| eChildAlignment = SFX_ALIGN_NOALIGNMENT; |
| |
| pDlg->Initialize( pInfo ); |
| } |
| /* -----------------------------10.01.01 13:53-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| SfxChildWinInfo SvxRubyChildWindow::GetInfo() const |
| { |
| return SfxChildWindow::GetInfo(); |
| } |
| /* -----------------------------09.01.01 17:17-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| class SvxRubyData_Impl : public cppu::WeakImplHelper1 |
| < ::com::sun::star::view::XSelectionChangeListener > |
| { |
| Reference<XModel> xModel; |
| Reference<XRubySelection> xSelection; |
| Sequence<PropertyValues> aRubyValues; |
| Reference<XController> xController; |
| sal_Bool bHasSelectionChanged; |
| public: |
| SvxRubyData_Impl(); |
| ~SvxRubyData_Impl(); |
| |
| void SetController(Reference<XController> xCtrl); |
| Reference<XModel> GetModel() |
| { |
| if(!xController.is()) |
| xModel = 0; |
| else |
| xModel = xController->getModel(); |
| return xModel; |
| } |
| sal_Bool HasSelectionChanged() const{return bHasSelectionChanged;} |
| Reference<XRubySelection> GetRubySelection() |
| { |
| xSelection = Reference<XRubySelection>(xController, UNO_QUERY); |
| return xSelection; |
| } |
| void UpdateRubyValues(sal_Bool bAutoUpdate) |
| { |
| if(!xSelection.is()) |
| aRubyValues.realloc(0); |
| else |
| aRubyValues = xSelection->getRubyList(bAutoUpdate); |
| bHasSelectionChanged = sal_False; |
| } |
| Sequence<PropertyValues>& GetRubyValues() {return aRubyValues;} |
| void AssertOneEntry(); |
| |
| virtual void SAL_CALL selectionChanged( const ::com::sun::star::lang::EventObject& aEvent ) throw (RuntimeException); |
| virtual void SAL_CALL disposing( const ::com::sun::star::lang::EventObject& Source ) throw (RuntimeException); |
| |
| }; |
| //----------------------------------------------------------------------------- |
| SvxRubyData_Impl::SvxRubyData_Impl() : |
| bHasSelectionChanged(sal_False) |
| { |
| } |
| //----------------------------------------------------------------------------- |
| SvxRubyData_Impl::~SvxRubyData_Impl() |
| { |
| } |
| //----------------------------------------------------------------------------- |
| void SvxRubyData_Impl::SetController(Reference<XController> xCtrl) |
| { |
| if(xCtrl.get() != xController.get()) |
| { |
| try |
| { |
| Reference<XSelectionSupplier> xSelSupp(xController, UNO_QUERY); |
| if(xSelSupp.is()) |
| xSelSupp->removeSelectionChangeListener(this); |
| |
| bHasSelectionChanged = sal_True; |
| xController = xCtrl; |
| xSelSupp = Reference<XSelectionSupplier>(xController, UNO_QUERY); |
| if(xSelSupp.is()) |
| xSelSupp->addSelectionChangeListener(this); |
| } |
| catch(Exception&) |
| {} |
| } |
| } |
| //----------------------------------------------------------------------------- |
| void SvxRubyData_Impl::selectionChanged( const EventObject& ) throw (RuntimeException) |
| { |
| bHasSelectionChanged = sal_True; |
| } |
| //----------------------------------------------------------------------------- |
| void SvxRubyData_Impl::disposing( const EventObject&) throw (RuntimeException) |
| { |
| try |
| { |
| Reference<XSelectionSupplier> xSelSupp(xController, UNO_QUERY); |
| if(xSelSupp.is()) |
| xSelSupp->removeSelectionChangeListener(this); |
| } |
| catch(Exception&) |
| {} |
| xController = 0; |
| } |
| //----------------------------------------------------------------------------- |
| void SvxRubyData_Impl::AssertOneEntry() |
| { |
| //create one entry |
| if(!aRubyValues.getLength()) |
| { |
| aRubyValues.realloc(1); |
| Sequence<PropertyValue>& rValues = aRubyValues.getArray()[0]; |
| rValues.realloc(5); |
| PropertyValue* pValues = rValues.getArray(); |
| pValues[0].Name = C2U(cRubyBaseText); |
| pValues[1].Name = C2U(cRubyText); |
| pValues[2].Name = C2U(cRubyAdjust); |
| pValues[3].Name = C2U(cRubyIsAbove); |
| pValues[4].Name = C2U(cRubyCharStyleName); |
| } |
| } |
| /* --------------------------------------------------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| SvxRubyDialog::SvxRubyDialog( SfxBindings *pBind, SfxChildWindow *pCW, |
| Window* _pParent, const ResId& rResId ) : |
| SfxModelessDialog( pBind, pCW, _pParent, rResId ), |
| aLeftFT(this, ResId(FT_LEFT,*rResId.GetResMgr() )), |
| aLeft1ED(this, ResId(ED_LEFT_1,*rResId.GetResMgr() )), |
| aRightFT(this, ResId(FT_RIGHT,*rResId.GetResMgr() )), |
| aRight1ED(this, ResId(ED_RIGHT_1,*rResId.GetResMgr() )), |
| aLeft2ED(this, ResId(ED_LEFT_2,*rResId.GetResMgr() )), |
| aRight2ED(this, ResId(ED_RIGHT_2,*rResId.GetResMgr() )), |
| aLeft3ED(this, ResId(ED_LEFT_3,*rResId.GetResMgr() )), |
| aRight3ED(this, ResId(ED_RIGHT_3,*rResId.GetResMgr() )), |
| aLeft4ED(this, ResId(ED_LEFT_4,*rResId.GetResMgr() )), |
| aRight4ED(this, ResId(ED_RIGHT_4,*rResId.GetResMgr() )), |
| aScrollSB(this, ResId(SB_SCROLL,*rResId.GetResMgr() )), |
| aAutoDetectionCB(this, ResId(CB_AUTO_DETECT,*rResId.GetResMgr() )), |
| aAdjustFT(this, ResId(FT_ADJUST,*rResId.GetResMgr() )), |
| aAdjustLB(this, ResId(LB_ADJUST,*rResId.GetResMgr() )), |
| aPositionFT(this, ResId(FT_POSITION,*rResId.GetResMgr() )), |
| aPositionLB(this, ResId(LB_POSITION,*rResId.GetResMgr() )), |
| aCharStyleFT(this, ResId(FT_CHAR_STYLE,*rResId.GetResMgr() )), |
| aCharStyleLB(this, ResId(LB_CHAR_STYLE,*rResId.GetResMgr() )), |
| aStylistPB(this, ResId(PB_STYLIST,*rResId.GetResMgr() )), |
| aPreviewFT(this, ResId(FT_PREVIEW,*rResId.GetResMgr() )), |
| aPreviewWin(*this, ResId(WIN_PREVIEW,*rResId.GetResMgr() )), |
| aApplyPB(this, ResId(PB_APPLY,*rResId.GetResMgr() )), |
| aClosePB(this, ResId(PB_CLOSE,*rResId.GetResMgr() )), |
| aHelpPB(this, ResId(PB_HELP,*rResId.GetResMgr() )), |
| nLastPos(0), |
| nCurrentEdit(0), |
| bModified(sal_False), |
| pBindings(pBind) |
| { |
| xImpl = pImpl = new SvxRubyData_Impl; |
| FreeResource(); |
| //#85638# automatic detection not yet available |
| aAutoDetectionCB.Hide(); |
| aEditArr[0] = &aLeft1ED; aEditArr[1] = &aRight1ED; |
| aEditArr[2] = &aLeft2ED; aEditArr[3] = &aRight2ED; |
| aEditArr[4] = &aLeft3ED; aEditArr[5] = &aRight3ED; |
| aEditArr[6] = &aLeft4ED; aEditArr[7] = &aRight4ED; |
| |
| aApplyPB.SetClickHdl(LINK(this, SvxRubyDialog, ApplyHdl_Impl)); |
| aClosePB.SetClickHdl(LINK(this, SvxRubyDialog, CloseHdl_Impl)); |
| aStylistPB.SetClickHdl(LINK(this, SvxRubyDialog, StylistHdl_Impl)); |
| aAutoDetectionCB.SetClickHdl(LINK(this, SvxRubyDialog, AutomaticHdl_Impl)); |
| aAdjustLB.SetSelectHdl(LINK(this, SvxRubyDialog, AdjustHdl_Impl)); |
| aPositionLB.SetSelectHdl(LINK(this, SvxRubyDialog, PositionHdl_Impl)); |
| aCharStyleLB.SetSelectHdl(LINK(this, SvxRubyDialog, CharStyleHdl_Impl)); |
| |
| Link aScrLk(LINK(this, SvxRubyDialog, ScrollHdl_Impl)); |
| aScrollSB.SetScrollHdl( aScrLk ); |
| aScrollSB.SetEndScrollHdl( aScrLk ); |
| |
| Link aEditLk(LINK(this, SvxRubyDialog, EditModifyHdl_Impl)); |
| Link aScrollLk(LINK(this, SvxRubyDialog, EditScrollHdl_Impl)); |
| Link aJumpLk(LINK(this, SvxRubyDialog, EditJumpHdl_Impl)); |
| for(sal_uInt16 i = 0; i < 8; i++) |
| { |
| aEditArr[i]->SetModifyHdl(aEditLk); |
| aEditArr[i]->SetJumpHdl(aJumpLk); |
| if(!i || 7 == i) |
| aEditArr[i]->SetScrollHdl(aScrollLk); |
| } |
| |
| UpdateColors(); |
| |
| String leftLabelName = aLeftFT.GetText(), rightLabelName = aRightFT.GetText(); |
| aLeft2ED.SetAccessibleName(leftLabelName); |
| aLeft3ED.SetAccessibleName(leftLabelName); |
| aLeft4ED.SetAccessibleName(leftLabelName); |
| aRight2ED.SetAccessibleName(rightLabelName); |
| aRight3ED.SetAccessibleName(rightLabelName); |
| aRight4ED.SetAccessibleName(rightLabelName); |
| } |
| /* -----------------------------09.01.01 17:17-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| SvxRubyDialog::~SvxRubyDialog() |
| { |
| ClearCharStyleList(); |
| EventObject aEvent; |
| xImpl->disposing(aEvent); |
| } |
| /* -----------------------------01.02.01 10:29-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| void SvxRubyDialog::ClearCharStyleList() |
| { |
| for(sal_uInt16 i = 0; i < aCharStyleLB.GetEntryCount(); i++) |
| { |
| void* pData = aCharStyleLB.GetEntryData(i); |
| delete (OUString*)pData; |
| } |
| aCharStyleLB.Clear(); |
| } |
| /* -----------------------------09.01.01 17:17-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| sal_Bool SvxRubyDialog::Close() |
| { |
| pBindings->GetDispatcher()->Execute( SID_RUBY_DIALOG, |
| SFX_CALLMODE_ASYNCHRON | |
| SFX_CALLMODE_RECORD); |
| return sal_True; |
| } |
| /* -----------------------------29.01.01 15:26-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| void SvxRubyDialog::Activate() |
| { |
| SfxModelessDialog::Activate(); |
| SfxPoolItem* pState = 0; |
| SfxItemState eState = pBindings->QueryState( SID_STYLE_DESIGNER, pState ); |
| sal_Bool bEnable = (eState < SFX_ITEM_AVAILABLE) || !pState || !((SfxBoolItem*)pState)->GetValue(); |
| aStylistPB.Enable(bEnable); |
| //get selection from current view frame |
| SfxViewFrame* pCurFrm = SfxViewFrame::Current(); |
| Reference< XController > xCtrl = pCurFrm->GetFrame().GetController(); |
| pImpl->SetController(xCtrl); |
| if(pImpl->HasSelectionChanged()) |
| { |
| |
| Reference< XRubySelection > xRubySel = pImpl->GetRubySelection(); |
| pImpl->UpdateRubyValues(aAutoDetectionCB.IsChecked()); |
| EnableControls(xRubySel.is()); |
| if(xRubySel.is()) |
| { |
| Reference< XModel > xModel = pImpl->GetModel(); |
| const String sCharStyleSelect = aCharStyleLB.GetSelectEntry(); |
| ClearCharStyleList(); |
| Reference<XStyleFamiliesSupplier> xSupplier(xModel, UNO_QUERY); |
| if(xSupplier.is()) |
| { |
| try |
| { |
| Reference<XNameAccess> xFam = xSupplier->getStyleFamilies(); |
| Any aChar = xFam->getByName(C2U(cCharacterStyles)); |
| Reference<XNameContainer> xChar; |
| aChar >>= xChar; |
| Reference<XIndexAccess> xCharIdx(xChar, UNO_QUERY); |
| if(xCharIdx.is()) |
| { |
| OUString sUIName(C2U(cDisplayName)); |
| for(sal_Int32 nStyle = 0; nStyle < xCharIdx->getCount(); nStyle++) |
| { |
| Any aStyle = xCharIdx->getByIndex(nStyle); |
| Reference<XStyle> xStyle; |
| aStyle >>= xStyle; |
| Reference<XPropertySet> xPrSet(xStyle, UNO_QUERY); |
| OUString sName, sCoreName; |
| if(xPrSet.is()) |
| { |
| Reference<XPropertySetInfo> xInfo = xPrSet->getPropertySetInfo(); |
| if(xInfo->hasPropertyByName(sUIName)) |
| { |
| Any aName = xPrSet->getPropertyValue(sUIName); |
| aName >>= sName; |
| } |
| } |
| Reference<XNamed> xNamed(xStyle, UNO_QUERY); |
| if(xNamed.is()) |
| { |
| sCoreName = xNamed->getName(); |
| if(!sName.getLength()) |
| sName = sCoreName; |
| } |
| if(sName.getLength()) |
| { |
| sal_uInt16 nPos = aCharStyleLB.InsertEntry(sName); |
| aCharStyleLB.SetEntryData( nPos, new OUString(sCoreName) ); |
| |
| } |
| } |
| } |
| } |
| catch(Exception&) |
| { |
| DBG_ERROR("exception in style access"); |
| } |
| if(sCharStyleSelect.Len()) |
| aCharStyleLB.SelectEntry(sCharStyleSelect); |
| } |
| aCharStyleLB.Enable(xSupplier.is()); |
| aCharStyleFT.Enable(xSupplier.is()); |
| } |
| Update(); |
| aPreviewWin.Invalidate(); |
| } |
| } |
| /* -----------------------------29.01.01 15:26-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| void SvxRubyDialog::Deactivate() |
| { |
| SfxModelessDialog::Deactivate(); |
| } |
| /* -----------------------------30.01.01 15:35-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| void SvxRubyDialog::SetText(sal_Int32 nPos, Edit& rLeft, Edit& rRight) |
| { |
| OUString sLeft, sRight; |
| const Sequence<PropertyValues>& aRubyValues = pImpl->GetRubyValues(); |
| sal_Bool bEnable = aRubyValues.getLength() > nPos; |
| if(bEnable) |
| { |
| const Sequence<PropertyValue> aProps = aRubyValues.getConstArray()[nPos]; |
| const PropertyValue* pProps = aProps.getConstArray(); |
| for(sal_Int32 nProp = 0; nProp < aProps.getLength(); nProp++) |
| { |
| if(pProps[nProp].Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM(cRubyBaseText))) |
| pProps[nProp].Value >>= sLeft; |
| else if(pProps[nProp].Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM(cRubyText))) |
| pProps[nProp].Value >>= sRight; |
| } |
| } |
| else if(!nPos) |
| bEnable = sal_True; |
| rLeft.Enable(bEnable); |
| rRight.Enable(bEnable); |
| rLeft.SetText(sLeft); |
| rRight.SetText(sRight); |
| rLeft.SaveValue(); |
| rRight.SaveValue(); |
| } |
| //----------------------------------------------------------------------------- |
| void SvxRubyDialog::GetText() |
| { |
| long nTempLastPos = GetLastPos(); |
| for(int i = 0; i < 8; i+=2) |
| { |
| if(aEditArr[i]->IsEnabled() && |
| (aEditArr[i]->GetText() != aEditArr[i]->GetSavedValue() || |
| aEditArr[i + 1]->GetText() != aEditArr[i + 1]->GetSavedValue())) |
| { |
| Sequence<PropertyValues>& aRubyValues = pImpl->GetRubyValues(); |
| DBG_ASSERT(aRubyValues.getLength() > (i / 2 + nTempLastPos), "wrong index" ); |
| SetModified(sal_True); |
| Sequence<PropertyValue> &rProps = aRubyValues.getArray()[i / 2 + nTempLastPos]; |
| PropertyValue* pProps = rProps.getArray(); |
| for(sal_Int32 nProp = 0; nProp < rProps.getLength(); nProp++) |
| { |
| if(pProps[nProp].Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM(cRubyBaseText))) |
| pProps[nProp].Value <<= OUString(aEditArr[i]->GetText()); |
| else if(pProps[nProp].Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM(cRubyText))) |
| pProps[nProp].Value <<= OUString(aEditArr[i + 1]->GetText()); |
| } |
| } |
| } |
| } |
| //----------------------------------------------------------------------------- |
| void SvxRubyDialog::Update() |
| { |
| const Sequence<PropertyValues>& aRubyValues = pImpl->GetRubyValues(); |
| sal_Int32 nLen = aRubyValues.getLength(); |
| aScrollSB.Enable(nLen > 4); |
| aScrollSB.SetRange( Range(0, nLen > 4 ? nLen - 4 : 0)); |
| aScrollSB.SetThumbPos(0); |
| SetLastPos(0); |
| SetModified(sal_False); |
| |
| sal_Int16 nAdjust = -1; |
| sal_Int16 nPosition = -1; |
| OUString sCharStyleName, sTmp; |
| sal_Bool bCharStyleEqual = sal_True; |
| for(sal_Int32 nRuby = 0; nRuby < nLen; nRuby++) |
| { |
| const Sequence<PropertyValue> &rProps = aRubyValues.getConstArray()[nRuby]; |
| const PropertyValue* pProps = rProps.getConstArray(); |
| for(sal_Int32 nProp = 0; nProp < rProps.getLength(); nProp++) |
| { |
| if(nAdjust > -2 && |
| pProps[nProp].Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM(cRubyAdjust))) |
| { |
| sal_Int16 nTmp = sal_Int16(); |
| pProps[nProp].Value >>= nTmp; |
| if(!nRuby) |
| nAdjust = nTmp; |
| else if(nAdjust != nTmp) |
| nAdjust = -2; |
| } |
| if(nPosition > -2 && |
| pProps[nProp].Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM(cRubyIsAbove))) |
| { |
| sal_Bool bTmp = *(sal_Bool*)pProps[nProp].Value.getValue(); |
| if(!nRuby) |
| nPosition = bTmp ? 0 : 1; |
| else if( (!nPosition && !bTmp) || (nPosition == 1 && bTmp) ) |
| nPosition = -2; |
| } |
| if(bCharStyleEqual && |
| pProps[nProp].Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM(cRubyCharStyleName))) |
| { |
| pProps[nProp].Value >>= sTmp; |
| if(!nRuby) |
| sCharStyleName = sTmp; |
| else if(sCharStyleName != sTmp) |
| bCharStyleEqual = sal_False; |
| } |
| } |
| } |
| if(!nLen) |
| { |
| //enable selection if the ruby list is empty |
| nAdjust = 0; |
| nPosition = 0; |
| } |
| if(nAdjust > -1) |
| aAdjustLB.SelectEntryPos(nAdjust); |
| else |
| aAdjustLB.SetNoSelection(); |
| if(nPosition > -1) |
| aPositionLB.SelectEntryPos(nPosition ? 1 : 0); |
| if(!nLen || (bCharStyleEqual && !sCharStyleName.getLength())) |
| sCharStyleName = C2U(cRubies); |
| if(sCharStyleName.getLength()) |
| { |
| for(sal_uInt16 i = 0; i < aCharStyleLB.GetEntryCount(); i++) |
| { |
| const OUString* pCoreName = (const OUString*)aCharStyleLB.GetEntryData(i); |
| if(pCoreName && sCharStyleName == *pCoreName) |
| { |
| aCharStyleLB.SelectEntryPos(i); |
| break; |
| } |
| } |
| } |
| else |
| aCharStyleLB.SetNoSelection(); |
| |
| ScrollHdl_Impl(&aScrollSB); |
| } |
| /* -----------------------------16.02.01 14:01-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| void SvxRubyDialog::GetCurrentText(String& rBase, String& rRuby) |
| { |
| rBase = aEditArr[nCurrentEdit * 2]->GetText(); |
| rRuby = aEditArr[nCurrentEdit * 2 + 1]->GetText(); |
| } |
| /* -----------------------------31.01.01 14:09-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| IMPL_LINK(SvxRubyDialog, ScrollHdl_Impl, ScrollBar*, pScroll) |
| { |
| long nPos = pScroll->GetThumbPos(); |
| if(GetLastPos() != nPos) |
| { |
| GetText(); |
| } |
| SetText(nPos++, aLeft1ED, aRight1ED); |
| SetText(nPos++, aLeft2ED, aRight2ED); |
| SetText(nPos++, aLeft3ED, aRight3ED); |
| SetText(nPos, aLeft4ED, aRight4ED); |
| SetLastPos(nPos - 3); |
| aPreviewWin.Invalidate(); |
| return 0; |
| } |
| /* -----------------------------30.01.01 14:48-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| IMPL_LINK(SvxRubyDialog, ApplyHdl_Impl, PushButton*, EMPTYARG) |
| { |
| const Sequence<PropertyValues>& aRubyValues = pImpl->GetRubyValues(); |
| if(!aRubyValues.getLength()) |
| { |
| AssertOneEntry(); |
| PositionHdl_Impl(&aPositionLB); |
| AdjustHdl_Impl(&aAdjustLB); |
| CharStyleHdl_Impl(&aCharStyleLB); |
| } |
| GetText(); |
| //reset all edit fields - SaveValue is called |
| ScrollHdl_Impl(&aScrollSB); |
| |
| Reference<XRubySelection> xSelection = pImpl->GetRubySelection(); |
| if(IsModified() && xSelection.is()) |
| { |
| try |
| { |
| xSelection->setRubyList(aRubyValues, aAutoDetectionCB.IsChecked()); |
| } |
| catch(Exception& ) |
| { |
| DBG_ERROR("Exception caught"); |
| } |
| } |
| return 0; |
| } |
| /* -----------------------------29.01.01 09:38-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| IMPL_LINK(SvxRubyDialog, CloseHdl_Impl, PushButton*, EMPTYARG) |
| { |
| Close(); |
| return 0; |
| } |
| /* -----------------------------29.01.01 15:10-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| IMPL_LINK(SvxRubyDialog, StylistHdl_Impl, PushButton*, EMPTYARG) |
| { |
| SfxPoolItem* pState = 0; |
| SfxItemState eState = pBindings->QueryState( SID_STYLE_DESIGNER, pState ); |
| if(eState <= SFX_ITEM_SET || !pState || !((SfxBoolItem*)pState)->GetValue()) |
| { |
| pBindings->GetDispatcher()->Execute( SID_STYLE_DESIGNER, |
| SFX_CALLMODE_ASYNCHRON | |
| SFX_CALLMODE_RECORD); |
| } |
| return 0; |
| } |
| /* -----------------------------30.01.01 15:32-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| IMPL_LINK(SvxRubyDialog, AutomaticHdl_Impl, CheckBox*, pBox) |
| { |
| pImpl->UpdateRubyValues(pBox->IsChecked()); |
| Update(); |
| return 0; |
| } |
| /* -----------------------------31.01.01 16:37-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| IMPL_LINK(SvxRubyDialog, AdjustHdl_Impl, ListBox*, pBox) |
| { |
| AssertOneEntry(); |
| sal_Int16 nAdjust = pBox->GetSelectEntryPos(); |
| Sequence<PropertyValues>& aRubyValues = pImpl->GetRubyValues(); |
| for(sal_Int32 nRuby = 0; nRuby < aRubyValues.getLength(); nRuby++) |
| { |
| Sequence<PropertyValue> &rProps = aRubyValues.getArray()[nRuby]; |
| PropertyValue* pProps = rProps.getArray(); |
| for(sal_Int32 nProp = 0; nProp < rProps.getLength(); nProp++) |
| { |
| if(pProps[nProp].Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM(cRubyAdjust))) |
| pProps[nProp].Value <<= nAdjust; |
| } |
| SetModified(sal_True); |
| } |
| aPreviewWin.Invalidate(); |
| return 0; |
| } |
| /* -----------------------------01.06.01 10:24-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| IMPL_LINK(SvxRubyDialog, PositionHdl_Impl, ListBox*, pBox) |
| { |
| AssertOneEntry(); |
| sal_Bool bAbove = !pBox->GetSelectEntryPos(); |
| const Type& rType = ::getBooleanCppuType(); |
| Sequence<PropertyValues>& aRubyValues = pImpl->GetRubyValues(); |
| for(sal_Int32 nRuby = 0; nRuby < aRubyValues.getLength(); nRuby++) |
| { |
| Sequence<PropertyValue> &rProps = aRubyValues.getArray()[nRuby]; |
| PropertyValue* pProps = rProps.getArray(); |
| for(sal_Int32 nProp = 0; nProp < rProps.getLength(); nProp++) |
| { |
| if(pProps[nProp].Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM(cRubyIsAbove))) |
| pProps[nProp].Value.setValue(&bAbove, rType); |
| } |
| SetModified(sal_True); |
| } |
| aPreviewWin.Invalidate(); |
| return 0; |
| } |
| /* -----------------------------01.02.01 10:06-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| IMPL_LINK(SvxRubyDialog, CharStyleHdl_Impl, ListBox*, EMPTYARG ) |
| { |
| AssertOneEntry(); |
| OUString sStyleName; |
| if(LISTBOX_ENTRY_NOTFOUND != aCharStyleLB.GetSelectEntryPos()) |
| sStyleName = *(OUString*) aCharStyleLB.GetEntryData(aCharStyleLB.GetSelectEntryPos()); |
| Sequence<PropertyValues>& aRubyValues = pImpl->GetRubyValues(); |
| for(sal_Int32 nRuby = 0; nRuby < aRubyValues.getLength(); nRuby++) |
| { |
| Sequence<PropertyValue> &rProps = aRubyValues.getArray()[nRuby]; |
| PropertyValue* pProps = rProps.getArray(); |
| for(sal_Int32 nProp = 0; nProp < rProps.getLength(); nProp++) |
| { |
| if(pProps[nProp].Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM(cRubyCharStyleName))) |
| { |
| pProps[nProp].Value <<= sStyleName; |
| } |
| } |
| SetModified(sal_True); |
| } |
| return 0; |
| } |
| /* -----------------------------16.02.01 08:35-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| IMPL_LINK(SvxRubyDialog, EditModifyHdl_Impl, Edit*, pEdit) |
| { |
| for(sal_uInt16 i = 0; i < 8; i++) |
| { |
| if(pEdit == aEditArr[i]) |
| { |
| nCurrentEdit = i / 2; |
| break; |
| } |
| } |
| aPreviewWin.Invalidate(); |
| return 0; |
| } |
| /* -----------------------------17.07.01 09:11-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| IMPL_LINK(SvxRubyDialog, EditScrollHdl_Impl, sal_Int32*, pParam) |
| { |
| long nRet = 0; |
| if(aScrollSB.IsEnabled()) |
| { |
| //scroll forward |
| if(*pParam > 0 && (aEditArr[7]->HasFocus() || aEditArr[6]->HasFocus() )) |
| { |
| if(aScrollSB.GetRangeMax() > aScrollSB.GetThumbPos()) |
| { |
| aScrollSB.SetThumbPos(aScrollSB.GetThumbPos() + 1); |
| aEditArr[6]->GrabFocus(); |
| nRet = 1; |
| } |
| } |
| //scroll backward |
| else if(aScrollSB.GetThumbPos() && (aEditArr[0]->HasFocus()||aEditArr[1]->HasFocus()) ) |
| { |
| aScrollSB.SetThumbPos(aScrollSB.GetThumbPos() - 1); |
| aEditArr[1]->GrabFocus(); |
| nRet = 1; |
| } |
| if(nRet) |
| ScrollHdl_Impl(&aScrollSB); |
| } |
| return nRet; |
| } |
| /* -----------------------------20.07.2001 15:18------------------------------ |
| |
| ---------------------------------------------------------------------------*/ |
| IMPL_LINK(SvxRubyDialog, EditJumpHdl_Impl, sal_Int32*, pParam) |
| { |
| sal_uInt16 nIndex = USHRT_MAX; |
| for(sal_uInt16 i = 0; i < 8; i++) |
| { |
| if(aEditArr[i]->HasFocus()) |
| nIndex = i; |
| } |
| if(nIndex < 8) |
| { |
| if(*pParam > 0) |
| { |
| if(nIndex < 6) |
| aEditArr[nIndex + 2]->GrabFocus(); |
| else if( EditScrollHdl_Impl(pParam)) |
| aEditArr[nIndex]->GrabFocus(); |
| } |
| else |
| { |
| if(nIndex > 1) |
| aEditArr[nIndex - 2]->GrabFocus(); |
| else if( EditScrollHdl_Impl(pParam)) |
| aEditArr[nIndex]->GrabFocus(); |
| } |
| } |
| return 0; |
| }; |
| /* -----------------------------19.06.01 11:33-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| void SvxRubyDialog::AssertOneEntry() |
| { |
| pImpl->AssertOneEntry(); |
| } |
| |
| // ---------------------------------------------------------------------------- |
| |
| void SvxRubyDialog::UpdateColors( void ) |
| { |
| const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); |
| svtools::ColorConfig aColorConfig; |
| |
| Font aFnt( aPreviewWin.GetFont() ); |
| |
| Color aNewTextCol( aColorConfig.GetColorValue( svtools::FONTCOLOR ).nColor ); |
| Color aNewFillCol( rStyleSettings.GetWindowColor() ); |
| |
| if( aNewFillCol != aFnt.GetFillColor() || aNewTextCol != aFnt.GetColor() ) |
| { |
| aFnt.SetFillColor( aNewFillCol ); |
| aFnt.SetColor( aNewTextCol ); |
| aPreviewWin.SetFont( aFnt ); |
| |
| aPreviewWin.Invalidate(); |
| } |
| } |
| |
| // ---------------------------------------------------------------------------- |
| |
| void SvxRubyDialog::DataChanged( const DataChangedEvent& rDCEvt ) |
| { |
| SfxModelessDialog::DataChanged( rDCEvt ); |
| |
| if( ( rDCEvt.GetType() == DATACHANGED_SETTINGS ) && ( rDCEvt.GetFlags() & SETTINGS_STYLE ) ) |
| UpdateColors(); |
| } |
| |
| /* -----------------------------29.01.01 15:44-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| void lcl_MoveBox(long nOffset, Edit& rLeft, Edit& rRight) |
| { |
| Size aLeftSz(rLeft.GetSizePixel()); |
| Point aRightPos(rRight.GetPosPixel()); |
| Size aRightSz(rRight.GetSizePixel()); |
| aLeftSz.Width() += nOffset; |
| aRightSz.Width() -= nOffset; |
| aRightPos.X() += nOffset; |
| rLeft.SetSizePixel(aLeftSz); |
| rRight.SetPosSizePixel(aRightPos, aRightSz); |
| |
| } |
| /* -----------------------------16.02.01 08:09-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| RubyPreview::RubyPreview(SvxRubyDialog& rParent, const ResId& rResId) : |
| Window(&rParent, rResId), |
| rParentDlg(rParent) |
| { |
| SetMapMode(MAP_TWIP); |
| Size aWinSize = GetOutputSize(); |
| |
| Font aFont = GetFont(); |
| aFont.SetHeight(aWinSize.Height() / 4); |
| SetFont(aFont); |
| |
| SetBorderStyle( WINDOW_BORDER_MONO ); |
| } |
| /* -----------------------------29.01.01 14:05-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| void RubyPreview::Paint( const Rectangle& /* rRect */ ) |
| { |
| Font aRubyFont = GetFont(); |
| Font aSaveFont(aRubyFont); |
| aRubyFont.SetHeight(aRubyFont.GetHeight() * 70 / 100); |
| |
| Size aWinSize = GetOutputSize(); |
| Rectangle aRect(Point(0, 0), aWinSize); |
| SetLineColor(); |
| SetFillColor( aSaveFont.GetFillColor() ); |
| DrawRect(aRect); |
| |
| String sBaseText, sRubyText; |
| rParentDlg.GetCurrentText(sBaseText, sRubyText); |
| |
| long nTextHeight = GetTextHeight(); |
| long nBaseWidth = GetTextWidth(sBaseText); |
| SetFont(aRubyFont); |
| long nRubyWidth = GetTextWidth(sRubyText); |
| SetFont(aSaveFont); |
| |
| sal_uInt16 nAdjust = rParentDlg.aAdjustLB.GetSelectEntryPos(); |
| //use center if no adjustment is available |
| if(nAdjust > 4) |
| nAdjust = 1; |
| |
| //which part is stretched ? |
| sal_Bool bRubyStretch = nBaseWidth >= nRubyWidth; |
| |
| long nCenter = aWinSize.Width() / 2; |
| long nLeftStart = nCenter - (bRubyStretch ? (nBaseWidth / 2) : (nRubyWidth / 2)); |
| long nRightEnd = nCenter + (bRubyStretch ? (nBaseWidth / 2) : (nRubyWidth / 2)); |
| |
| long nYRuby = aWinSize.Height() / 4 - nTextHeight / 2; |
| long nYBase = aWinSize.Height() * 3 / 4 - nTextHeight / 2; |
| |
| //use above also if no selection is set |
| sal_Bool bAbove = rParentDlg.aPositionLB.GetSelectEntryPos() != 1; |
| if(!bAbove) |
| { |
| long nTmp = nYRuby; |
| nYRuby = nYBase; |
| nYBase = nTmp; |
| } |
| long nYOutput, nOutTextWidth; |
| String sOutputText; |
| |
| |
| if(bRubyStretch) |
| { |
| DrawText( Point( nLeftStart , nYBase), sBaseText ); |
| nYOutput = nYRuby; |
| sOutputText = sRubyText; |
| nOutTextWidth = nRubyWidth; |
| SetFont(aRubyFont); |
| } |
| else |
| { |
| SetFont(aRubyFont); |
| DrawText( Point( nLeftStart , nYRuby), sRubyText ); |
| nYOutput = nYBase; |
| sOutputText = sBaseText; |
| nOutTextWidth = nBaseWidth; |
| SetFont(aSaveFont); |
| } |
| |
| switch(nAdjust) |
| { |
| case RubyAdjust_LEFT: |
| DrawText( Point( nLeftStart , nYOutput), sOutputText ); |
| break; |
| case RubyAdjust_RIGHT: |
| DrawText( Point( nRightEnd - nOutTextWidth, nYOutput), sOutputText ); |
| break; |
| case RubyAdjust_INDENT_BLOCK: |
| { |
| long nCharWidth = GetTextWidth(String::CreateFromAscii("X")); |
| if(nOutTextWidth < (nRightEnd - nLeftStart - nCharWidth)) |
| { |
| nCharWidth /= 2; |
| nLeftStart += nCharWidth; |
| nRightEnd -= nCharWidth; |
| } |
| } |
| // no break! |
| case RubyAdjust_BLOCK: |
| if(sOutputText.Len() > 1) |
| { |
| xub_StrLen nCount = sOutputText.Len(); |
| long nSpace = ((nRightEnd - nLeftStart) - GetTextWidth(sOutputText)) / (nCount - 1); |
| for(xub_StrLen i = 0; i < nCount; i++) |
| { |
| sal_Unicode cChar = sOutputText.GetChar(i); |
| DrawText( Point( nLeftStart , nYOutput), cChar); |
| long nCharWidth = GetTextWidth(cChar); |
| nLeftStart += nCharWidth + nSpace; |
| } |
| break; |
| } |
| //no break; |
| case RubyAdjust_CENTER: |
| DrawText( Point( nCenter - nOutTextWidth / 2 , nYOutput), sOutputText ); |
| break; |
| } |
| SetFont(aSaveFont); |
| } |
| /* -----------------------------16.02.01 15:12-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| void RubyEdit::GetFocus() |
| { |
| GetModifyHdl().Call(this); |
| Edit::GetFocus(); |
| } |
| /* -----------------------------17.07.01 09:00-------------------------------- |
| |
| ---------------------------------------------------------------------------*/ |
| long RubyEdit::PreNotify( NotifyEvent& rNEvt ) |
| { |
| long nHandled = 0; |
| if ( rNEvt.GetType() == EVENT_KEYINPUT ) |
| { |
| const KeyEvent* pKEvt = rNEvt.GetKeyEvent(); |
| const KeyCode& rKeyCode = pKEvt->GetKeyCode(); |
| sal_uInt16 nMod = rKeyCode.GetModifier(); |
| sal_uInt16 nCode = rKeyCode.GetCode(); |
| if( nCode == KEY_TAB && (!nMod || KEY_SHIFT == nMod)) |
| { |
| sal_Int32 nParam = KEY_SHIFT == nMod ? -1 : 1; |
| if(aScrollHdl.IsSet() && aScrollHdl.Call(&nParam)) |
| nHandled = 1; |
| } |
| else if(KEY_UP == nCode || KEY_DOWN == nCode) |
| { |
| sal_Int32 nParam = KEY_UP == nCode ? -1 : 1; |
| aJumpHdl.Call(&nParam); |
| } |
| } |
| if(!nHandled) |
| nHandled = Edit::PreNotify(rNEvt); |
| return nHandled; |
| } |
| |
