| /************************************************************** |
| * |
| * 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_sw.hxx" |
| |
| |
| #define _SVSTDARR_STRINGSSORTDTOR |
| #define _SVSTDARR_USHORTSSORT |
| #define _SVSTDARR_USHORTS |
| |
| |
| #include <redline.hxx> |
| #include <tools/datetime.hxx> |
| #include <vcl/msgbox.hxx> |
| #include <svl/svstdarr.hxx> |
| #include <svl/eitem.hxx> |
| #include <sfx2/viewfrm.hxx> |
| #include <sfx2/dispatch.hxx> |
| #include <svx/ctredlin.hxx> |
| #include <svx/postattr.hxx> |
| #include <swtypes.hxx> |
| #include <wrtsh.hxx> |
| #include <view.hxx> |
| #include <swmodule.hxx> |
| #ifndef _REDLNDLG_HXX |
| #define _REDLNACCEPTDLG |
| #include <redlndlg.hxx> |
| #endif |
| #include <swwait.hxx> |
| #include <uitool.hxx> |
| |
| #include <helpid.h> |
| #include <cmdid.h> |
| #include <misc.hrc> |
| #include <redlndlg.hrc> |
| #include <shells.hrc> |
| |
| // -> #111827# |
| #include <comcore.hrc> |
| #include <swundo.hxx> |
| #include <SwRewriter.hxx> |
| // <- #111827# |
| |
| #include <vector> |
| #include <svx/svxdlg.hxx> |
| #include <svx/dialogs.hrc> |
| |
| #include <unomid.h> |
| |
| #include <docsh.hxx> |
| |
| #include <IDocumentRedlineAccess.hxx> |
| |
| /*------------------------------------------------------------------------ |
| Beschreibung: |
| ------------------------------------------------------------------------*/ |
| |
| SFX_IMPL_MODELESSDIALOG( SwRedlineAcceptChild, FN_REDLINE_ACCEPT ) |
| |
| SV_IMPL_PTRARR(SwRedlineDataParentArr, SwRedlineDataParentPtr) |
| SV_IMPL_OP_PTRARR_SORT(SwRedlineDataParentSortArr, SwRedlineDataParentPtr) |
| SV_IMPL_PTRARR(SwRedlineDataChildArr, SwRedlineDataChildPtr) |
| SV_IMPL_PTRARR(SvLBoxEntryArr, SvLBoxEntryPtr) |
| |
| static sal_uInt16 nSortMode = 0xffff; |
| static sal_Bool bSortDir = sal_True; |
| |
| /*------------------------------------------------------------------------ |
| Beschreibung: |
| ------------------------------------------------------------------------*/ |
| |
| SwRedlineAcceptChild::SwRedlineAcceptChild( Window* _pParent, |
| sal_uInt16 nId, |
| SfxBindings* pBindings, |
| SfxChildWinInfo* pInfo ) : |
| SwChildWinWrapper( _pParent, nId ) |
| { |
| pWindow = new SwModelessRedlineAcceptDlg( pBindings, this, _pParent); |
| |
| ((SwModelessRedlineAcceptDlg *)pWindow)->Initialize(pInfo); |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: Nach Dok-Wechsel Dialog neu initialisieren |
| --------------------------------------------------------------------*/ |
| |
| sal_Bool SwRedlineAcceptChild::ReInitDlg(SwDocShell *pDocSh) |
| { |
| sal_Bool bRet; |
| |
| if ((bRet = SwChildWinWrapper::ReInitDlg(pDocSh)) == sal_True) // Sofort aktualisieren, Dok-Wechsel |
| ((SwModelessRedlineAcceptDlg*)GetWindow())->Activate(); |
| |
| return bRet; |
| } |
| |
| /*------------------------------------------------------------------------ |
| Beschreibung: |
| ------------------------------------------------------------------------*/ |
| |
| SwModelessRedlineAcceptDlg::SwModelessRedlineAcceptDlg( SfxBindings* _pBindings, |
| SwChildWinWrapper* pChild, |
| Window *_pParent) : |
| SfxModelessDialog(_pBindings, pChild, _pParent, SW_RES(DLG_REDLINE_ACCEPT)), |
| pChildWin (pChild) |
| { |
| pImplDlg = new SwRedlineAcceptDlg(this); |
| |
| FreeResource(); |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| void SwModelessRedlineAcceptDlg::Activate() |
| { |
| SwView *pView = ::GetActiveView(); |
| |
| if (!pView) // Kann passieren, wenn man auf eine andere App umschaltet, wenn |
| return; // vorher eine Listbox im Dialog den Focus hatte (eigentlich THs Bug) |
| |
| SwDocShell *pDocSh = pView->GetDocShell(); |
| |
| if (pChildWin->GetOldDocShell() != pDocSh) |
| { // Dok-Wechsel |
| SwWait aWait( *pDocSh, false ); |
| SwWrtShell* pSh = pView->GetWrtShellPtr(); |
| |
| pChildWin->SetOldDocShell(pDocSh); // Rekursion vermeiden (durch Modified-Hdl) |
| |
| sal_Bool bMod = pSh->IsModified(); |
| SfxBoolItem aShow(FN_REDLINE_SHOW, sal_True); |
| pSh->GetView().GetViewFrame()->GetDispatcher()->Execute( |
| FN_REDLINE_SHOW, SFX_CALLMODE_SYNCHRON|SFX_CALLMODE_RECORD, &aShow, 0L); |
| if (!bMod) |
| pSh->ResetModified(); |
| pImplDlg->Init(); |
| |
| return; |
| } |
| |
| pImplDlg->Activate(); |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| void SwModelessRedlineAcceptDlg::Initialize(SfxChildWinInfo *pInfo) |
| { |
| String aStr; |
| if (pInfo != NULL) |
| pImplDlg->Initialize(pInfo->aExtraString); |
| |
| SfxModelessDialog::Initialize(pInfo); |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| void SwModelessRedlineAcceptDlg::FillInfo(SfxChildWinInfo& rInfo) const |
| { |
| SfxModelessDialog::FillInfo(rInfo); |
| pImplDlg->FillInfo(rInfo.aExtraString); |
| } |
| |
| /*------------------------------------------------------------------------ |
| Beschreibung: |
| ------------------------------------------------------------------------*/ |
| |
| void SwModelessRedlineAcceptDlg::Resize() |
| { |
| pImplDlg->Resize(); |
| SfxModelessDialog::Resize(); |
| } |
| |
| /*------------------------------------------------------------------------ |
| Beschreibung: |
| ------------------------------------------------------------------------*/ |
| |
| SwModelessRedlineAcceptDlg::~SwModelessRedlineAcceptDlg() |
| { |
| delete pImplDlg; |
| } |
| |
| /*------------------------------------------------------------------------ |
| Beschreibung: |
| ------------------------------------------------------------------------*/ |
| |
| SwRedlineAcceptDlg::SwRedlineAcceptDlg(Dialog *pParent, sal_Bool bAutoFmt) : |
| pParentDlg (pParent), |
| aTabPagesCTRL (pParent, SW_RES(CTRL_TABPAGES)), |
| aPopup (SW_RES(MN_REDLINE_POPUP)), |
| sInserted (SW_RES(STR_REDLINE_INSERTED)), |
| sDeleted (SW_RES(STR_REDLINE_DELETED)), |
| sFormated (SW_RES(STR_REDLINE_FORMATED)), |
| sTableChgd (SW_RES(STR_REDLINE_TABLECHG)), |
| sFmtCollSet (SW_RES(STR_REDLINE_FMTCOLLSET)), |
| sAutoFormat (SW_RES(STR_REDLINE_AUTOFMT)), |
| bOnlyFormatedRedlines( sal_False ), |
| bHasReadonlySel ( sal_False ), |
| bRedlnAutoFmt (bAutoFmt), |
| bInhibitActivate( false ) |
| { |
| aTabPagesCTRL.SetHelpId(HID_REDLINE_CTRL); |
| pTPView = aTabPagesCTRL.GetViewPage(); |
| pTable = pTPView->GetTableControl(); |
| |
| pTPView->InsertWriterHeader(); |
| pTPView->SetAcceptClickHdl(LINK(this, SwRedlineAcceptDlg, AcceptHdl)); |
| pTPView->SetAcceptAllClickHdl(LINK(this, SwRedlineAcceptDlg, AcceptAllHdl)); |
| pTPView->SetRejectClickHdl(LINK(this, SwRedlineAcceptDlg, RejectHdl)); |
| pTPView->SetRejectAllClickHdl(LINK(this, SwRedlineAcceptDlg, RejectAllHdl)); |
| pTPView->SetUndoClickHdl(LINK(this, SwRedlineAcceptDlg, UndoHdl)); |
| |
| aTabPagesCTRL.GetFilterPage()->SetReadyHdl(LINK(this, SwRedlineAcceptDlg, FilterChangedHdl)); |
| |
| ListBox *pActLB = aTabPagesCTRL.GetFilterPage()->GetLbAction(); |
| pActLB->InsertEntry(sInserted); |
| pActLB->InsertEntry(sDeleted); |
| pActLB->InsertEntry(sFormated); |
| pActLB->InsertEntry(sTableChgd); |
| |
| if (HasRedlineAutoFmt()) |
| { |
| pActLB->InsertEntry(sFmtCollSet); |
| pActLB->InsertEntry(sAutoFormat); |
| pTPView->ShowUndo(sal_True); |
| pTPView->DisableUndo(); // Noch gibts keine UNDO-Events |
| } |
| |
| pActLB->SelectEntryPos(0); |
| |
| pTable->SetStyle(pTable->GetStyle()|WB_HASLINES|WB_CLIPCHILDREN|WB_HASBUTTONS|WB_HASBUTTONSATROOT|WB_HSCROLL); |
| pTable->SetNodeDefaultImages(); |
| pTable->SetSelectionMode(MULTIPLE_SELECTION); |
| pTable->SetHighlightRange(1); |
| |
| static long aStaticTabs[]= |
| { |
| 4,10,70,120,170 |
| }; |
| |
| pTable->SetTabs(aStaticTabs); |
| |
| // Minimalgroesse setzen |
| Size aMinSz(aTabPagesCTRL.GetMinSizePixel()); |
| Point aPos(aTabPagesCTRL.GetPosPixel()); |
| |
| aMinSz.Width() += (aPos.X() * 2 - 1); |
| aMinSz.Height() += (aPos.Y() * 2 - 1); |
| pParentDlg->SetMinOutputSizePixel(aMinSz); |
| |
| if (pParentDlg->GetOutputSizePixel().Width() < aMinSz.Width()) |
| pParentDlg->SetOutputSizePixel(Size(aMinSz.Width(), pParentDlg->GetOutputSizePixel().Height())); |
| if (pParentDlg->GetOutputSizePixel().Height() < aMinSz.Height()) |
| pParentDlg->SetOutputSizePixel(Size(pParentDlg->GetOutputSizePixel().Width(), aMinSz.Height())); |
| |
| pTable->SortByCol(nSortMode, bSortDir); |
| |
| aOldSelectHdl = pTable->GetSelectHdl(); |
| aOldDeselectHdl = pTable->GetDeselectHdl(); |
| pTable->SetSelectHdl(LINK(this, SwRedlineAcceptDlg, SelectHdl)); |
| pTable->SetDeselectHdl(LINK(this, SwRedlineAcceptDlg, DeselectHdl)); |
| pTable->SetCommandHdl(LINK(this, SwRedlineAcceptDlg, CommandHdl)); |
| |
| // Flackern der Buttons vermeiden: |
| aDeselectTimer.SetTimeout(100); |
| aDeselectTimer.SetTimeoutHdl(LINK(this, SwRedlineAcceptDlg, SelectHdl)); |
| |
| // Mehrfachselektion der selben Texte vermeiden: |
| aSelectTimer.SetTimeout(100); |
| aSelectTimer.SetTimeoutHdl(LINK(this, SwRedlineAcceptDlg, GotoHdl)); |
| } |
| |
| /*------------------------------------------------------------------------ |
| Beschreibung: |
| ------------------------------------------------------------------------*/ |
| |
| SwRedlineAcceptDlg::~SwRedlineAcceptDlg() |
| { |
| } |
| |
| /*------------------------------------------------------------------------ |
| Beschreibung: |
| ------------------------------------------------------------------------*/ |
| |
| void SwRedlineAcceptDlg::Init(sal_uInt16 nStart) |
| { |
| SwWait aWait( *::GetActiveView()->GetDocShell(), false ); |
| pTable->SetUpdateMode(sal_False); |
| aUsedSeqNo.Remove((sal_uInt16)0, aUsedSeqNo.Count()); |
| |
| if (nStart) |
| RemoveParents(nStart, aRedlineParents.Count() - 1); |
| else |
| { |
| pTable->Clear(); |
| aRedlineChilds.DeleteAndDestroy(0, aRedlineChilds.Count()); |
| aRedlineParents.DeleteAndDestroy(nStart, aRedlineParents.Count() - nStart); |
| } |
| |
| // Parents einfuegen |
| InsertParents(nStart); |
| InitAuthors(); |
| |
| pTable->SetUpdateMode(sal_True); |
| // #i69618# this moves the list box to the right position, visually |
| SvLBoxEntry* pSelEntry = pTable->FirstSelected(); |
| if( pSelEntry ) |
| pTable->MakeVisible( pSelEntry, sal_True ); //#i70937#, force the scroll |
| } |
| |
| /*------------------------------------------------------------------------ |
| Beschreibung: |
| ------------------------------------------------------------------------*/ |
| |
| void SwRedlineAcceptDlg::InitAuthors() |
| { |
| SwWrtShell* pSh = ::GetActiveView()->GetWrtShellPtr(); |
| |
| SvxTPFilter *pFilterPage = aTabPagesCTRL.GetFilterPage(); |
| |
| String sAuthor; |
| SvStringsSortDtor aStrings; |
| String sOldAuthor(pFilterPage->GetSelectedAuthor()); |
| pFilterPage->ClearAuthors(); |
| |
| String sParent; |
| const sal_uInt16 nRedlineCount = pSh->GetRedlineCount(); |
| |
| bOnlyFormatedRedlines = sal_True; |
| bHasReadonlySel = sal_False; |
| sal_Bool bIsNotFormated = sal_False; |
| sal_uInt16 i; |
| |
| // Autoren ermitteln |
| for ( i = 0; i < nRedlineCount; i++) |
| { |
| const SwRedline& rRedln = pSh->GetRedline(i); |
| |
| if( bOnlyFormatedRedlines && nsRedlineType_t::REDLINE_FORMAT != rRedln.GetType() ) |
| bOnlyFormatedRedlines = sal_False; |
| |
| //JP 27.9.2001: make no sense if we handle readonly sections |
| // if( !bHasReadonlySel && rRedln.HasReadonlySel() ) |
| // bHasReadonlySel = sal_True; |
| |
| String *pAuthor = new String(rRedln.GetAuthorString()); |
| if (!aStrings.Insert(pAuthor)) |
| delete pAuthor; |
| |
| for (sal_uInt16 nStack = 1; nStack < rRedln.GetStackCount(); nStack++) |
| { |
| pAuthor = new String(rRedln.GetAuthorString(nStack)); |
| if (!aStrings.Insert(pAuthor)) |
| delete pAuthor; |
| } |
| } |
| |
| for (i = 0; i < aStrings.Count(); i++) |
| pFilterPage->InsertAuthor(*aStrings[i]); |
| |
| if (pFilterPage->SelectAuthor(sOldAuthor) == LISTBOX_ENTRY_NOTFOUND && aStrings.Count()) |
| pFilterPage->SelectAuthor(*aStrings[0]); |
| |
| sal_Bool bEnable = pTable->GetEntryCount() != 0 && !pSh->getIDocumentRedlineAccess()->GetRedlinePassword().getLength(); |
| sal_Bool bSel = pTable->FirstSelected() != 0; |
| |
| { |
| SvLBoxEntry* pSelEntry = pTable->FirstSelected(); |
| while (pSelEntry) |
| { |
| const sal_uInt16 nPos = GetRedlinePos(*pSelEntry); |
| if ( nPos < nRedlineCount ) |
| { |
| const SwRedline& rRedln = pSh->GetRedline( nPos ); |
| bIsNotFormated |= nsRedlineType_t::REDLINE_FORMAT != rRedln.GetType(); |
| } |
| pSelEntry = pTable->NextSelected(pSelEntry); |
| } |
| } |
| |
| pTPView->EnableAccept( bEnable && bSel ); |
| pTPView->EnableReject( bEnable && bIsNotFormated && bSel ); |
| pTPView->EnableAcceptAll( bEnable && !bHasReadonlySel ); |
| pTPView->EnableRejectAll( bEnable && !bHasReadonlySel && |
| !bOnlyFormatedRedlines ); |
| } |
| |
| /*------------------------------------------------------------------------ |
| Beschreibung: |
| ------------------------------------------------------------------------*/ |
| |
| String SwRedlineAcceptDlg::GetRedlineText( const SwRedline& rRedln, |
| DateTime &rDateTime, sal_uInt16 nStack) |
| { |
| String sEntry(GetActionText(rRedln, nStack)); |
| sEntry += '\t'; |
| sEntry += rRedln.GetAuthorString(nStack); |
| sEntry += '\t'; |
| |
| const DateTime &rDT = rRedln.GetTimeStamp(nStack); |
| rDateTime = rDT; |
| |
| sEntry += GetAppLangDateTimeString( rDT ); |
| sEntry += '\t'; |
| |
| sEntry += rRedln.GetComment(nStack); |
| |
| return sEntry; |
| } |
| |
| /*------------------------------------------------------------------------ |
| Beschreibung: |
| ------------------------------------------------------------------------*/ |
| |
| const String &SwRedlineAcceptDlg::GetActionText(const SwRedline& rRedln, sal_uInt16 nStack) |
| { |
| switch( rRedln.GetType(nStack) ) |
| { |
| case nsRedlineType_t::REDLINE_INSERT: return sInserted; |
| case nsRedlineType_t::REDLINE_DELETE: return sDeleted; |
| case nsRedlineType_t::REDLINE_FORMAT: return sFormated; |
| case nsRedlineType_t::REDLINE_TABLE: return sTableChgd; |
| case nsRedlineType_t::REDLINE_FMTCOLL: return sFmtCollSet; |
| default:;//prevent warning |
| } |
| |
| return aEmptyStr; |
| } |
| |
| /*------------------------------------------------------------------------ |
| Beschreibung: |
| ------------------------------------------------------------------------*/ |
| |
| void SwRedlineAcceptDlg::Resize() |
| { |
| Size aSz(pParentDlg->GetOutputSizePixel()); |
| |
| Point aPos(aTabPagesCTRL.GetPosPixel()); |
| |
| aSz.Width() -= (aPos.X() * 2 - 1); |
| aSz.Height() -= (aPos.Y() * 2 - 1); |
| |
| aTabPagesCTRL.SetOutputSizePixel(aSz); |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: Nach Aktivierung neu initialisieren |
| --------------------------------------------------------------------*/ |
| |
| void SwRedlineAcceptDlg::Activate() |
| { |
| // prevent update if flag is set (#102547#) |
| if( bInhibitActivate ) |
| return; |
| |
| SwView *pView = ::GetActiveView(); |
| SwWait aWait( *pView->GetDocShell(), false ); |
| |
| aUsedSeqNo.Remove((sal_uInt16)0, aUsedSeqNo.Count()); |
| |
| if (!pView) // Kann passieren, wenn man auf eine andere App umschaltet, wenn |
| return; // vorher eine Listbox im Dialog den Focus hatte (eigentlich THs Bug) |
| |
| /* if (HasRedlineAutoFmt()) |
| { |
| Init(); |
| return; |
| }*/ |
| |
| // Hat sich was geaendert? |
| SwWrtShell* pSh = pView->GetWrtShellPtr(); |
| sal_uInt16 nCount = pSh->GetRedlineCount(); |
| |
| // Anzahl und Pointer ueberpruefen |
| SwRedlineDataParent *pParent = 0; |
| sal_uInt16 i; |
| |
| for ( i = 0; i < nCount; i++) |
| { |
| const SwRedline& rRedln = pSh->GetRedline(i); |
| |
| if (i >= aRedlineParents.Count()) |
| { |
| // Neue Eintraege wurden angehaengt |
| Init(i); |
| return; |
| } |
| |
| pParent = aRedlineParents[i]; |
| if (&rRedln.GetRedlineData() != pParent->pData) |
| { |
| // Redline-Parents wurden eingefuegt, geaendert oder geloescht |
| if ((i = CalcDiff(i, sal_False)) == USHRT_MAX) |
| return; |
| continue; |
| } |
| |
| const SwRedlineData *pRedlineData = rRedln.GetRedlineData().Next(); |
| const SwRedlineDataChild *pBackupData = pParent->pNext; |
| |
| if (!pRedlineData && pBackupData) |
| { |
| // Redline-Childs wurden geloescht |
| if ((i = CalcDiff(i, sal_True)) == USHRT_MAX) |
| return; |
| continue; |
| } |
| else |
| { |
| while (pRedlineData) |
| { |
| if (pRedlineData != pBackupData->pChild) |
| { |
| // Redline-Childs wurden eingefuegt, geaendert oder geloescht |
| if ((i = CalcDiff(i, sal_True)) == USHRT_MAX) |
| return; |
| continue; |
| } |
| if (pBackupData) |
| pBackupData = pBackupData->pNext; |
| pRedlineData = pRedlineData->Next(); |
| } |
| } |
| } |
| |
| if (nCount != aRedlineParents.Count()) |
| { |
| // Redlines wurden am Ende geloescht |
| Init(nCount); |
| return; |
| } |
| |
| // Kommentar ueberpruefen |
| for (i = 0; i < nCount; i++) |
| { |
| const SwRedline& rRedln = pSh->GetRedline(i); |
| pParent = aRedlineParents[i]; |
| |
| if(!rRedln.GetComment().Equals(pParent->sComment)) |
| { |
| if (pParent->pTLBParent) |
| { |
| // Nur Kommentar aktualisieren |
| String sComment(rRedln.GetComment()); |
| sComment.SearchAndReplaceAll((sal_Unicode)_LF,(sal_Unicode)' '); |
| pTable->SetEntryText(sComment, pParent->pTLBParent, 3); |
| } |
| pParent->sComment = rRedln.GetComment(); |
| } |
| } |
| |
| InitAuthors(); |
| } |
| |
| /* -----------------05.06.98 13:06------------------- |
| * |
| * --------------------------------------------------*/ |
| |
| sal_uInt16 SwRedlineAcceptDlg::CalcDiff(sal_uInt16 nStart, sal_Bool bChild) |
| { |
| if (!nStart) |
| { |
| Init(); |
| return USHRT_MAX; |
| } |
| |
| pTable->SetUpdateMode(sal_False); |
| SwView *pView = ::GetActiveView(); |
| SwWrtShell* pSh = pView->GetWrtShellPtr(); |
| sal_uInt16 nAutoFmt = HasRedlineAutoFmt() ? nsRedlineType_t::REDLINE_FORM_AUTOFMT : 0; |
| SwRedlineDataParent *pParent = aRedlineParents[nStart]; |
| const SwRedline& rRedln = pSh->GetRedline(nStart); |
| |
| if (bChild) // Sollte eigentlich nie vorkommen, aber sicher ist sicher... |
| { |
| // Alle Childs des Eintrags wegwerfen und neu initialisieren |
| SwRedlineDataChildPtr pBackupData = (SwRedlineDataChildPtr)pParent->pNext; |
| SwRedlineDataChildPtr pNext; |
| |
| while (pBackupData) |
| { |
| pNext = (SwRedlineDataChildPtr)pBackupData->pNext; |
| if (pBackupData->pTLBChild) |
| pTable->RemoveEntry(pBackupData->pTLBChild); |
| |
| aRedlineChilds.DeleteAndDestroy(aRedlineChilds.GetPos(pBackupData), 1); |
| pBackupData = pNext; |
| } |
| pParent->pNext = 0; |
| |
| // Neue Childs einfuegen |
| InsertChilds(pParent, rRedln, nAutoFmt); |
| |
| pTable->SetUpdateMode(sal_True); |
| return nStart; |
| } |
| |
| // Wurden Eintraege geloescht? |
| const SwRedlineData *pRedlineData = &rRedln.GetRedlineData(); |
| sal_uInt16 i; |
| for ( i = nStart + 1; i < aRedlineParents.Count(); i++) |
| { |
| if (aRedlineParents[i]->pData == pRedlineData) |
| { |
| // Eintraege von nStart bis i-1 entfernen |
| RemoveParents(nStart, i - 1); |
| pTable->SetUpdateMode(sal_True); |
| return nStart - 1; |
| } |
| } |
| |
| // Wurden Eintraege eingefuegt? |
| sal_uInt16 nCount = pSh->GetRedlineCount(); |
| pRedlineData = aRedlineParents[nStart]->pData; |
| |
| for (i = nStart + 1; i < nCount; i++) |
| { |
| if (&pSh->GetRedline(i).GetRedlineData() == pRedlineData) |
| { |
| // Eintraege von nStart bis i-1 einfuegen |
| InsertParents(nStart, i - 1); |
| pTable->SetUpdateMode(sal_True); |
| return nStart - 1; |
| } |
| } |
| |
| pTable->SetUpdateMode(sal_True); |
| Init(nStart); // Alle Eintraege bis zum Ende abgleichen |
| return USHRT_MAX; |
| } |
| |
| /* -----------------05.06.98 13:57------------------- |
| * |
| * --------------------------------------------------*/ |
| |
| void SwRedlineAcceptDlg::InsertChilds(SwRedlineDataParent *pParent, const SwRedline& rRedln, const sal_uInt16 nAutoFmt) |
| { |
| String sChild; |
| SwRedlineDataChild *pLastRedlineChild = 0; |
| const SwRedlineData *pRedlineData = &rRedln.GetRedlineData(); |
| sal_Bool bAutoFmt = (rRedln.GetRealType() & nAutoFmt) != 0; |
| |
| const String *pAction = &GetActionText(rRedln); |
| sal_Bool bValidParent = !sFilterAction.Len() || sFilterAction == *pAction; |
| bValidParent = bValidParent && pTable->IsValidEntry(&rRedln.GetAuthorString(), &rRedln.GetTimeStamp(), &rRedln.GetComment()); |
| if (nAutoFmt) |
| { |
| sal_uInt16 nPos; |
| |
| if (pParent->pData->GetSeqNo() && !aUsedSeqNo.Insert(pParent, nPos)) // Gibts schon |
| { |
| if (pParent->pTLBParent) |
| { |
| pTable->SetEntryText(sAutoFormat, aUsedSeqNo[nPos]->pTLBParent, 0); |
| pTable->RemoveEntry(pParent->pTLBParent); |
| pParent->pTLBParent = 0; |
| } |
| return; |
| } |
| bValidParent = bValidParent && bAutoFmt; |
| } |
| sal_Bool bValidTree = bValidParent; |
| |
| for (sal_uInt16 nStack = 1; nStack < rRedln.GetStackCount(); nStack++) |
| { |
| pRedlineData = pRedlineData->Next(); |
| |
| SwRedlineDataChildPtr pRedlineChild = new SwRedlineDataChild; |
| pRedlineChild->pChild = pRedlineData; |
| aRedlineChilds.Insert(pRedlineChild, aRedlineChilds.Count()); |
| |
| if ( pLastRedlineChild ) |
| pLastRedlineChild->pNext = pRedlineChild; |
| else |
| pParent->pNext = pRedlineChild; |
| |
| pAction = &GetActionText(rRedln, nStack); |
| sal_Bool bValidChild = !sFilterAction.Len() || sFilterAction == *pAction; |
| bValidChild = bValidChild && pTable->IsValidEntry(&rRedln.GetAuthorString(nStack), &rRedln.GetTimeStamp(nStack), &rRedln.GetComment()); |
| if (nAutoFmt) |
| bValidChild = bValidChild && bAutoFmt; |
| bValidTree |= bValidChild; |
| |
| if (bValidChild) |
| { |
| RedlinData *pData = new RedlinData; |
| pData->pData = pRedlineChild; |
| pData->bDisabled = sal_True; |
| sChild = GetRedlineText(rRedln, pData->aDateTime, nStack); |
| |
| SvLBoxEntry* pChild = pTable->InsertEntry(sChild, pData, pParent->pTLBParent); |
| |
| pRedlineChild->pTLBChild = pChild; |
| if (!bValidParent) |
| pTable->Expand(pParent->pTLBParent); |
| } |
| else |
| pRedlineChild->pTLBChild = 0; |
| |
| pLastRedlineChild = pRedlineChild; |
| } |
| |
| if (pLastRedlineChild) |
| pLastRedlineChild->pNext = 0; |
| |
| if (!bValidTree && pParent->pTLBParent) |
| { |
| pTable->RemoveEntry(pParent->pTLBParent); |
| pParent->pTLBParent = 0; |
| if (nAutoFmt) |
| aUsedSeqNo.Remove(pParent); |
| } |
| } |
| |
| /* -----------------05.06.98 15:20------------------- |
| * |
| * --------------------------------------------------*/ |
| |
| void SwRedlineAcceptDlg::RemoveParents(sal_uInt16 nStart, sal_uInt16 nEnd) |
| { |
| SwWrtShell* pSh = ::GetActiveView()->GetWrtShellPtr(); |
| sal_uInt16 nCount = pSh->GetRedlineCount(); |
| |
| SvLBoxEntryArr aLBoxArr; |
| |
| // Wegen Bug der TLB, die bei Remove den SelectHandler IMMER ruft: |
| pTable->SetSelectHdl(aOldSelectHdl); |
| pTable->SetDeselectHdl(aOldDeselectHdl); |
| sal_Bool bChildsRemoved = sal_False; |
| pTable->SelectAll(sal_False); |
| |
| // Hinter dem letzten Eintrag Cursor setzen, da sonst Performance-Problem in TLB. |
| // TLB wuerde sonst bei jedem Remove den Cursor erneut umsetzen (teuer) |
| sal_uInt16 nPos = Min((sal_uInt16)nCount, (sal_uInt16)aRedlineParents.Count()); |
| SvLBoxEntry *pCurEntry = NULL; |
| while( ( pCurEntry == NULL ) && ( nPos > 0 ) ) |
| { |
| --nPos; |
| pCurEntry = aRedlineParents[nPos]->pTLBParent; |
| } |
| |
| if (pCurEntry) |
| pTable->SetCurEntry(pCurEntry); |
| |
| SvLBoxTreeList* pModel = pTable->GetModel(); |
| |
| for (sal_uInt16 i = nStart; i <= nEnd; i++) |
| { |
| if (!bChildsRemoved && aRedlineParents[i]->pNext) |
| { |
| SwRedlineDataChildPtr pChildPtr = (SwRedlineDataChildPtr)aRedlineParents[i]->pNext; |
| sal_uInt16 nChildPos = aRedlineChilds.GetPos(pChildPtr); |
| |
| if (nChildPos != USHRT_MAX) |
| { |
| sal_uInt16 nChilds = 0; |
| |
| while (pChildPtr) |
| { |
| pChildPtr = (SwRedlineDataChildPtr)pChildPtr->pNext; |
| nChilds++; |
| } |
| |
| aRedlineChilds.DeleteAndDestroy(nChildPos, nChilds); |
| bChildsRemoved = sal_True; |
| } |
| } |
| SvLBoxEntry *pEntry = aRedlineParents[i]->pTLBParent; |
| if (pEntry) |
| { |
| long nIdx = aLBoxArr.Count() - 1L; |
| sal_uLong nAbsPos = pModel->GetAbsPos(pEntry); |
| while (nIdx >= 0 && |
| pModel->GetAbsPos(aLBoxArr[ static_cast< sal_uInt16 >(nIdx) ]) > nAbsPos) |
| nIdx--; |
| aLBoxArr.Insert( pEntry, static_cast< sal_uInt16 >(++nIdx) ); |
| } |
| } |
| |
| // TLB von hinten abraeumen |
| long nIdx = (long)aLBoxArr.Count() - 1L; |
| while (nIdx >= 0) |
| pTable->RemoveEntry(aLBoxArr[ static_cast< sal_uInt16 >(nIdx--) ]); |
| |
| pTable->SetSelectHdl(LINK(this, SwRedlineAcceptDlg, SelectHdl)); |
| pTable->SetDeselectHdl(LINK(this, SwRedlineAcceptDlg, DeselectHdl)); |
| // Durch Remove wurde leider wieder dauernd von der TLB selektiert... |
| pTable->SelectAll(sal_False); |
| |
| aRedlineParents.DeleteAndDestroy( nStart, nEnd - nStart + 1); |
| } |
| |
| /* -----------------05.06.98 15:20------------------- |
| * |
| * --------------------------------------------------*/ |
| |
| void SwRedlineAcceptDlg::InsertParents(sal_uInt16 nStart, sal_uInt16 nEnd) |
| { |
| SwView *pView = ::GetActiveView(); |
| SwWrtShell* pSh = pView->GetWrtShellPtr(); |
| sal_uInt16 nAutoFmt = HasRedlineAutoFmt() ? nsRedlineType_t::REDLINE_FORM_AUTOFMT : 0; |
| |
| String sParent; |
| const sal_uInt16 nCount = pSh->GetRedlineCount(); |
| nEnd = Min((sal_uInt16)nEnd, (sal_uInt16)(nCount - 1)); // Handelt auch nEnd=USHRT_MAX (bis zum Ende) ab |
| |
| if (nEnd == USHRT_MAX) |
| return; // Keine Redlines im Dokument |
| |
| RedlinData *pData; |
| SvLBoxEntry *pParent; |
| SwRedlineDataParentPtr pRedlineParent; |
| const SwRedline* pCurrRedline; |
| if( !nStart && !pTable->FirstSelected() ) |
| { |
| pCurrRedline = pSh->GetCurrRedline(); |
| if( !pCurrRedline ) |
| { |
| pSh->SwCrsrShell::Push(); |
| if( 0 == (pCurrRedline = pSh->SelNextRedline())) |
| pCurrRedline = pSh->SelPrevRedline(); |
| pSh->SwCrsrShell::Pop( sal_False ); |
| } |
| } |
| else |
| pCurrRedline = 0; |
| |
| for (sal_uInt16 i = nStart; i <= nEnd; i++) |
| { |
| const SwRedline& rRedln = pSh->GetRedline(i); |
| const SwRedlineData *pRedlineData = &rRedln.GetRedlineData(); |
| |
| pRedlineParent = new SwRedlineDataParent; |
| pRedlineParent->pData = pRedlineData; |
| pRedlineParent->pNext = 0; |
| String sComment(rRedln.GetComment()); |
| sComment.SearchAndReplaceAll((sal_Unicode)_LF,(sal_Unicode)' '); |
| pRedlineParent->sComment = sComment; |
| aRedlineParents.Insert(pRedlineParent, i); |
| |
| pData = new RedlinData; |
| pData->pData = pRedlineParent; |
| pData->bDisabled = sal_False; |
| |
| sParent = GetRedlineText(rRedln, pData->aDateTime); |
| pParent = pTable->InsertEntry(sParent, pData, 0, i); |
| if( pCurrRedline == &rRedln ) |
| { |
| pTable->SetCurEntry( pParent ); |
| pTable->Select( pParent ); |
| pTable->MakeVisible( pParent ); |
| } |
| |
| pRedlineParent->pTLBParent = pParent; |
| |
| InsertChilds(pRedlineParent, rRedln, nAutoFmt); |
| } |
| } |
| |
| /* -----------------05.06.98 13:06------------------- |
| * |
| * --------------------------------------------------*/ |
| |
| void SwRedlineAcceptDlg::CallAcceptReject( sal_Bool bSelect, sal_Bool bAccept ) |
| { |
| SwWrtShell* pSh = ::GetActiveView()->GetWrtShellPtr(); |
| SvLBoxEntry* pEntry = bSelect ? pTable->FirstSelected() : pTable->First(); |
| sal_uLong nPos = LONG_MAX; |
| |
| typedef std::vector<SvLBoxEntry*> ListBoxEntries_t; |
| ListBoxEntries_t aRedlines; |
| |
| // don't activate |
| DBG_ASSERT( bInhibitActivate == false, |
| "recursive call of CallAcceptReject?"); |
| bInhibitActivate = true; |
| |
| // collect redlines-to-be-accepted/rejected in aRedlines vector |
| while( pEntry ) |
| { |
| if( !pTable->GetParent( pEntry ) ) |
| { |
| if( bSelect && LONG_MAX == nPos ) |
| nPos = pTable->GetModel()->GetAbsPos( pEntry ); |
| |
| RedlinData *pData = (RedlinData *)pEntry->GetUserData(); |
| |
| if( !pData->bDisabled ) |
| aRedlines.push_back( pEntry ); |
| } |
| |
| pEntry = bSelect ? pTable->NextSelected(pEntry) : pTable->Next(pEntry); |
| } |
| |
| sal_Bool (SwEditShell:: *FnAccRej)( sal_uInt16 ) = &SwEditShell::AcceptRedline; |
| if( !bAccept ) |
| FnAccRej = &SwEditShell::RejectRedline; |
| |
| SwWait aWait( *pSh->GetView().GetDocShell(), true ); |
| pSh->StartAction(); |
| |
| // #111827# |
| if (aRedlines.size() > 1) |
| { |
| String aTmpStr; |
| { |
| SwRewriter aRewriter; |
| aRewriter.AddRule(UNDO_ARG1, |
| String::CreateFromInt32(aRedlines.size())); |
| aTmpStr = aRewriter.Apply(String(SW_RES(STR_N_REDLINES))); |
| } |
| |
| SwRewriter aRewriter; |
| aRewriter.AddRule(UNDO_ARG1, aTmpStr); |
| |
| pSh->StartUndo(bAccept? UNDO_ACCEPT_REDLINE : UNDO_REJECT_REDLINE, |
| &aRewriter); |
| } |
| |
| // accept/reject the the redlines in aRedlines. The absolute |
| // position may change during the process (e.g. when two redlines |
| // are merged in result of another one being deleted), so the |
| // position must be resolved late and checked before using it. |
| // (cf #102547#) |
| ListBoxEntries_t::iterator aEnd = aRedlines.end(); |
| for( ListBoxEntries_t::iterator aIter = aRedlines.begin(); |
| aIter != aEnd; |
| aIter++ ) |
| { |
| const sal_uInt16 nPosition = GetRedlinePos( **aIter ); |
| if( nPosition != USHRT_MAX ) |
| (pSh->*FnAccRej)( nPosition ); |
| } |
| |
| // #111827# |
| if (aRedlines.size() > 1) |
| { |
| pSh->EndUndo(); |
| } |
| |
| pSh->EndAction(); |
| |
| bInhibitActivate = false; |
| Activate(); |
| |
| if( ULONG_MAX != nPos && pTable->GetEntryCount() ) |
| { |
| if( nPos >= pTable->GetEntryCount() ) |
| nPos = pTable->GetEntryCount() - 1; |
| pEntry = pTable->GetEntry( nPos ); |
| if( !pEntry && nPos-- ) |
| pEntry = pTable->GetEntry( nPos ); |
| if( pEntry ) |
| { |
| pTable->Select( pEntry ); |
| pTable->MakeVisible( pEntry ); |
| pTable->SetCurEntry(pEntry); |
| } |
| } |
| pTPView->EnableUndo(); |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| sal_uInt16 SwRedlineAcceptDlg::GetRedlinePos( const SvLBoxEntry& rEntry ) const |
| { |
| SwWrtShell* pSh = ::GetActiveView()->GetWrtShellPtr(); |
| return pSh->FindRedlineOfData( *((SwRedlineDataParent*)((RedlinData *) |
| rEntry.GetUserData())->pData)->pData ); |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| IMPL_LINK( SwRedlineAcceptDlg, AcceptHdl, void*, EMPTYARG) |
| { |
| CallAcceptReject( sal_True, sal_True ); |
| return 0; |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| IMPL_LINK( SwRedlineAcceptDlg, AcceptAllHdl, void*, EMPTYARG ) |
| { |
| CallAcceptReject( sal_False, sal_True ); |
| return 0; |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| IMPL_LINK( SwRedlineAcceptDlg, RejectHdl, void*, EMPTYARG ) |
| { |
| CallAcceptReject( sal_True, sal_False ); |
| return 0; |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| IMPL_LINK( SwRedlineAcceptDlg, RejectAllHdl, void*, EMPTYARG ) |
| { |
| CallAcceptReject( sal_False, sal_False ); |
| return 0; |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| IMPL_LINK( SwRedlineAcceptDlg, UndoHdl, void*, EMPTYARG ) |
| { |
| SwView * pView = ::GetActiveView(); |
| pView->GetViewFrame()->GetDispatcher()-> |
| Execute(SID_UNDO, SFX_CALLMODE_SYNCHRON); |
| pTPView->EnableUndo(pView->GetSlotState(SID_UNDO) != 0); |
| |
| Activate(); |
| |
| return 0; |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| IMPL_LINK( SwRedlineAcceptDlg, FilterChangedHdl, void*, EMPTYARG ) |
| { |
| SvxTPFilter *pFilterTP = aTabPagesCTRL.GetFilterPage(); |
| |
| if (pFilterTP->IsAction()) |
| sFilterAction = pFilterTP->GetLbAction()->GetSelectEntry(); |
| else |
| sFilterAction = aEmptyStr; |
| |
| Init(); |
| |
| return 0; |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| IMPL_LINK( SwRedlineAcceptDlg, DeselectHdl, void*, EMPTYARG ) |
| { |
| // Flackern der Buttons vermeiden: |
| aDeselectTimer.Start(); |
| |
| return 0; |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| IMPL_LINK( SwRedlineAcceptDlg, SelectHdl, void*, EMPTYARG ) |
| { |
| aDeselectTimer.Stop(); |
| aSelectTimer.Start(); |
| |
| return 0; |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| IMPL_LINK( SwRedlineAcceptDlg, GotoHdl, void*, EMPTYARG ) |
| { |
| SwWrtShell* pSh = ::GetActiveView()->GetWrtShellPtr(); |
| aSelectTimer.Stop(); |
| |
| sal_Bool bIsNotFormated = sal_False; |
| sal_Bool bSel = sal_False; |
| |
| //#98883# don't select redlines while the dialog is not focussed |
| //#107938# But not only ask pTable if it has the focus. To move |
| // the selection to the selected redline any child of pParentDlg |
| // may the focus. |
| SvLBoxEntry* pSelEntry = 0; |
| |
| if (pParentDlg->HasChildPathFocus()) |
| pSelEntry = pTable->FirstSelected(); |
| |
| if( pSelEntry ) |
| { |
| SvLBoxEntry* pActEntry = pSelEntry; |
| pSh->StartAction(); |
| pSh->EnterStdMode(); |
| pSh->SetCareWin(pParentDlg); |
| |
| while (pSelEntry) |
| { |
| if (pTable->GetParent(pSelEntry)) |
| { |
| pActEntry = pTable->GetParent(pSelEntry); |
| |
| if (pTable->IsSelected(pActEntry)) |
| { |
| pSelEntry = pActEntry = pTable->NextSelected(pSelEntry); |
| continue; // Nicht zweimal selektieren |
| } |
| } |
| else |
| bSel = sal_True; |
| |
| // #98864# find the selected redline (ignore, if the redline is already gone) |
| const sal_uInt16 nPos = GetRedlinePos(*pActEntry); |
| if ( nPos < pSh->GetRedlineCount() ) |
| { |
| |
| const SwRedline& rRedln = pSh->GetRedline( nPos ); |
| bIsNotFormated |= nsRedlineType_t::REDLINE_FORMAT != rRedln.GetType(); |
| |
| if (pSh->GotoRedline(nPos, sal_True)) |
| { |
| pSh->SetInSelect(); |
| pSh->EnterAddMode(); |
| } |
| } |
| |
| pSelEntry = pActEntry = pTable->NextSelected(pSelEntry); |
| } |
| |
| pSh->LeaveAddMode(); |
| pSh->EndAction(); |
| pSh->SetCareWin(NULL); |
| } |
| sal_Bool bEnable = !pSh->getIDocumentRedlineAccess()->GetRedlinePassword().getLength(); |
| pTPView->EnableAccept( bEnable && bSel /*&& !bReadonlySel*/ ); |
| pTPView->EnableReject( bEnable && bSel && bIsNotFormated /*&& !bReadonlySel*/ ); |
| pTPView->EnableRejectAll( bEnable && !bOnlyFormatedRedlines && !bHasReadonlySel ); |
| |
| return 0; |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| IMPL_LINK( SwRedlineAcceptDlg, CommandHdl, void*, EMPTYARG ) |
| { |
| const CommandEvent aCEvt(pTable->GetCommandEvent()); |
| |
| switch ( aCEvt.GetCommand() ) |
| { |
| case COMMAND_CONTEXTMENU: |
| { |
| SwWrtShell* pSh = ::GetActiveView()->GetWrtShellPtr(); |
| SvLBoxEntry* pEntry = pTable->FirstSelected(); |
| const SwRedline *pRed = 0; |
| |
| if (pEntry) |
| { |
| SvLBoxEntry* pTopEntry = pEntry; |
| |
| if (pTable->GetParent(pEntry)) |
| pTopEntry = pTable->GetParent(pEntry); |
| |
| const sal_uInt16 nPos = GetRedlinePos(*pTopEntry); |
| |
| // Bei geschuetzten Bereichen kommentieren disablen |
| if ((pRed = pSh->GotoRedline(nPos, sal_True)) != 0) |
| { |
| if( pSh->IsCrsrPtAtEnd() ) |
| pSh->SwapPam(); |
| pSh->SetInSelect(); |
| } |
| } |
| |
| aPopup.EnableItem( MN_EDIT_COMMENT, pEntry && pRed && |
| !pTable->GetParent(pEntry) && |
| !pTable->NextSelected(pEntry) |
| //JP 27.9.2001: make no sense if we handle readonly sections |
| // && pRed->HasReadonlySel() |
| ); |
| |
| aPopup.EnableItem( MN_SUB_SORT, pTable->First() != 0 ); |
| sal_uInt16 nColumn = pTable->GetSortedCol(); |
| if (nColumn == 0xffff) |
| nColumn = 4; |
| |
| PopupMenu *pSubMenu = aPopup.GetPopupMenu(MN_SUB_SORT); |
| if (pSubMenu) |
| { |
| for (sal_uInt16 i = MN_SORT_ACTION; i < MN_SORT_ACTION + 5; i++) |
| pSubMenu->CheckItem(i, sal_False); |
| |
| pSubMenu->CheckItem(nColumn + MN_SORT_ACTION); |
| } |
| |
| sal_uInt16 nRet = aPopup.Execute(pTable, aCEvt.GetMousePosPixel()); |
| |
| switch( nRet ) |
| { |
| case MN_EDIT_COMMENT: |
| { |
| String sComment; |
| if (pEntry) |
| { |
| if (pTable->GetParent(pEntry)) |
| pEntry = pTable->GetParent(pEntry); |
| |
| const sal_uInt16 nPos = GetRedlinePos(*pEntry); |
| if ( nPos >= pSh->GetRedlineCount() ) |
| { |
| break; |
| } |
| const SwRedline &rRedline = pSh->GetRedline(nPos); |
| |
| |
| /* enable again once we have redline comments in the margin |
| sComment = rRedline.GetComment(); |
| if ( sComment == String(::rtl::OUString::createFromAscii("")) ) |
| GetActiveView()->GetDocShell()->Broadcast(SwRedlineHint(&rRedline,SWREDLINE_INSERTED)); |
| const_cast<SwRedline&>(rRedline).Broadcast(SwRedlineHint(&rRedline,SWREDLINE_FOCUS)); |
| */ |
| |
| sComment = rRedline.GetComment(); |
| SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); |
| DBG_ASSERT(pFact, "Dialogdiet fail!"); |
| ::DialogGetRanges fnGetRange = pFact->GetDialogGetRangesFunc( RID_SVXDLG_POSTIT ); |
| DBG_ASSERT(fnGetRange, "Dialogdiet fail! GetRanges()"); |
| SfxItemSet aSet( pSh->GetAttrPool(), fnGetRange() ); |
| |
| aSet.Put(SvxPostItTextItem(sComment.ConvertLineEnd(), SID_ATTR_POSTIT_TEXT)); |
| aSet.Put(SvxPostItAuthorItem(rRedline.GetAuthorString(), SID_ATTR_POSTIT_AUTHOR)); |
| |
| aSet.Put(SvxPostItDateItem( GetAppLangDateTimeString( |
| rRedline.GetRedlineData().GetTimeStamp() ), |
| SID_ATTR_POSTIT_DATE )); |
| |
| AbstractSvxPostItDialog* pDlg = pFact->CreateSvxPostItDialog( pParentDlg, aSet, sal_False ); |
| DBG_ASSERT(pDlg, "Dialogdiet fail!"); |
| |
| pDlg->HideAuthor(); |
| |
| sal_uInt16 nResId = 0; |
| switch( rRedline.GetType() ) |
| { |
| case nsRedlineType_t::REDLINE_INSERT: |
| nResId = STR_REDLINE_INSERTED; |
| break; |
| case nsRedlineType_t::REDLINE_DELETE: |
| nResId = STR_REDLINE_DELETED; |
| break; |
| case nsRedlineType_t::REDLINE_FORMAT: |
| nResId = STR_REDLINE_FORMATED; |
| break; |
| case nsRedlineType_t::REDLINE_TABLE: |
| nResId = STR_REDLINE_TABLECHG; |
| break; |
| default:;//prevent warning |
| } |
| String sTitle(SW_RES(STR_REDLINE_COMMENT)); |
| if( nResId ) |
| sTitle += SW_RESSTR( nResId ); |
| pDlg->SetText(sTitle); |
| |
| pSh->SetCareWin(pDlg->GetWindow()); |
| |
| if ( pDlg->Execute() == RET_OK ) |
| { |
| const SfxItemSet* pOutSet = pDlg->GetOutputItemSet(); |
| String sMsg(((const SvxPostItTextItem&)pOutSet->Get(SID_ATTR_POSTIT_TEXT)).GetValue()); |
| |
| // Kommentar einfuegen bzw aendern |
| pSh->SetRedlineComment(sMsg); |
| sMsg.SearchAndReplaceAll((sal_Unicode)_LF,(sal_Unicode)' '); |
| pTable->SetEntryText(sMsg, pEntry, 3); |
| } |
| |
| delete pDlg; |
| pSh->SetCareWin(NULL); |
| } |
| |
| } |
| break; |
| |
| case MN_SORT_ACTION: |
| case MN_SORT_AUTHOR: |
| case MN_SORT_DATE: |
| case MN_SORT_COMMENT: |
| case MN_SORT_POSITION: |
| { |
| bSortDir = sal_True; |
| if (nRet - MN_SORT_ACTION == 4 && pTable->GetSortedCol() == 0xffff) |
| break; // Haben wir schon |
| |
| nSortMode = nRet - MN_SORT_ACTION; |
| if (nSortMode == 4) |
| nSortMode = 0xffff; // unsortiert bzw sortiert nach Position |
| |
| if (pTable->GetSortedCol() == nSortMode) |
| bSortDir = !pTable->GetSortDirection(); |
| |
| SwWait aWait( *::GetActiveView()->GetDocShell(), false ); |
| pTable->SortByCol(nSortMode, bSortDir); |
| if (nSortMode == 0xffff) |
| Init(); // Alles neu fuellen |
| } |
| break; |
| } |
| } |
| break; |
| } |
| |
| return 0; |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| void SwRedlineAcceptDlg::Initialize(const String& rExtraData) |
| { |
| if (rExtraData.Len()) |
| { |
| sal_uInt16 nPos = rExtraData.Search(C2S("AcceptChgDat:")); |
| |
| // Versuche, den Alignment-String "ALIGN:(...)" einzulesen; wenn |
| // er nicht vorhanden ist, liegt eine "altere Version vor |
| if (nPos != STRING_NOTFOUND) |
| { |
| sal_uInt16 n1 = rExtraData.Search('(', nPos); |
| if (n1 != STRING_NOTFOUND) |
| { |
| sal_uInt16 n2 = rExtraData.Search(')', n1); |
| if (n2 != STRING_NOTFOUND) |
| { |
| // Alignment-String herausschneiden |
| String aStr = rExtraData.Copy(nPos, n2 - nPos + 1); |
| aStr.Erase(0, n1 - nPos + 1); |
| |
| if (aStr.Len()) |
| { |
| sal_uInt16 nCount = static_cast< sal_uInt16 >(aStr.ToInt32()); |
| |
| for (sal_uInt16 i = 0; i < nCount; i++) |
| { |
| sal_uInt16 n3 = aStr.Search(';'); |
| aStr.Erase(0, n3 + 1); |
| pTable->SetTab(i, aStr.ToInt32(), MAP_PIXEL); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| void SwRedlineAcceptDlg::FillInfo(String &rExtraData) const |
| { |
| rExtraData.AppendAscii("AcceptChgDat:("); |
| |
| sal_uInt16 nCount = pTable->TabCount(); |
| |
| rExtraData += String::CreateFromInt32(nCount); |
| rExtraData += ';'; |
| for(sal_uInt16 i = 0; i < nCount; i++) |
| { |
| rExtraData += String::CreateFromInt32( pTable->GetTab(i) ); |
| rExtraData += ';'; |
| } |
| rExtraData += ')'; |
| } |