/**************************************************************
*
* 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_sc.hxx"
//----------------------------------------------------------------------------
#include "rangelst.hxx"
#include "scitems.hxx"
#include <sfx2/bindings.hxx>
#include <sfx2/imagemgr.hxx>
#include <svl/zforlist.hxx>
#include <vcl/msgbox.hxx>
#include <vcl/svapp.hxx>
#include "uiitems.hxx"
#include "reffact.hxx"
#include "docsh.hxx"
#include "docfunc.hxx"
#include "cell.hxx"
#include "rangeutl.hxx"
#include "scresid.hxx"
#include "convuno.hxx"
#include "unonames.hxx"
#include "solveroptions.hxx"
#include "solverutil.hxx"
#include "optsolver.hrc"
#include "optsolver.hxx"
#include <com/sun/star/sheet/Solver.hpp>
#include <com/sun/star/sheet/XSolverDescription.hpp>
using namespace com::sun::star;
//----------------------------------------------------------------------------
ScSolverProgressDialog::ScSolverProgressDialog( Window* pParent )
: ModelessDialog( pParent, ScResId( RID_SCDLG_SOLVER_PROGRESS ) ),
maFtProgress ( this, ScResId( FT_PROGRESS ) ),
maFtTime ( this, ScResId( FT_TIMELIMIT ) ),
maFlButtons ( this, ScResId( FL_BUTTONS ) ),
maBtnOk ( this, ScResId( BTN_OK ) )
{
maBtnOk.Enable(sal_False);
FreeResource();
}
ScSolverProgressDialog::~ScSolverProgressDialog()
{
}
void ScSolverProgressDialog::HideTimeLimit()
{
maFtTime.Hide();
}
void ScSolverProgressDialog::SetTimeLimit( sal_Int32 nSeconds )
{
String aOld = maFtTime.GetText();
String aNew = aOld.GetToken(0,'#');
aNew += String::CreateFromInt32( nSeconds );
aNew += aOld.GetToken(1,'#');
maFtTime.SetText( aNew );
}
//----------------------------------------------------------------------------
ScSolverNoSolutionDialog::ScSolverNoSolutionDialog( Window* pParent, const String& rErrorText )
: ModalDialog( pParent, ScResId( RID_SCDLG_SOLVER_NOSOLUTION ) ),
maFtNoSolution ( this, ScResId( FT_NOSOLUTION ) ),
maFtErrorText ( this, ScResId( FT_ERRORTEXT ) ),
maFlButtons ( this, ScResId( FL_BUTTONS ) ),
maBtnOk ( this, ScResId( BTN_OK ) )
{
maFtErrorText.SetText( rErrorText );
FreeResource();
}
ScSolverNoSolutionDialog::~ScSolverNoSolutionDialog()
{
}
//----------------------------------------------------------------------------
ScSolverSuccessDialog::ScSolverSuccessDialog( Window* pParent, const String& rSolution )
: ModalDialog( pParent, ScResId( RID_SCDLG_SOLVER_SUCCESS ) ),
maFtSuccess ( this, ScResId( FT_SUCCESS ) ),
maFtResult ( this, ScResId( FT_RESULT ) ),
maFtQuestion ( this, ScResId( FT_QUESTION ) ),
maFlButtons ( this, ScResId( FL_BUTTONS ) ),
maBtnOk ( this, ScResId( BTN_OK ) ),
maBtnCancel ( this, ScResId( BTN_CANCEL ) )
{
String aMessage = maFtResult.GetText();
aMessage.Append( (sal_Char) ' ' );
aMessage.Append( rSolution );
maFtResult.SetText( aMessage );
FreeResource();
}
ScSolverSuccessDialog::~ScSolverSuccessDialog()
{
}
//----------------------------------------------------------------------------
ScCursorRefEdit::ScCursorRefEdit( ScAnyRefDlg* pParent, const ResId& rResId ) :
formula::RefEdit( pParent, pParent, rResId )
{
}
void ScCursorRefEdit::SetCursorLinks( const Link& rUp, const Link& rDown )
{
maCursorUpLink = rUp;
maCursorDownLink = rDown;
}
void ScCursorRefEdit::KeyInput( const KeyEvent& rKEvt )
{
KeyCode aCode = rKEvt.GetKeyCode();
bool bUp = (aCode.GetCode() == KEY_UP);
bool bDown = (aCode.GetCode() == KEY_DOWN);
if ( !aCode.IsShift() && !aCode.IsMod1() && !aCode.IsMod2() && ( bUp || bDown ) )
{
if ( bUp )
maCursorUpLink.Call( this );
else
maCursorDownLink.Call( this );
}
else
formula::RefEdit::KeyInput( rKEvt );
}
//----------------------------------------------------------------------------
ScOptSolverSave::ScOptSolverSave( const String& rObjective, sal_Bool bMax, sal_Bool bMin, sal_Bool bValue,
const String& rTarget, const String& rVariable,
const std::vector<ScOptConditionRow>& rConditions,
const String& rEngine,
const uno::Sequence<beans::PropertyValue>& rProperties ) :
maObjective( rObjective ),
mbMax( bMax ),
mbMin( bMin ),
mbValue( bValue ),
maTarget( rTarget ),
maVariable( rVariable ),
maConditions( rConditions ),
maEngine( rEngine ),
maProperties( rProperties )
{
}
//============================================================================
// class ScOptSolverDlg
//----------------------------------------------------------------------------
ScOptSolverDlg::ScOptSolverDlg( SfxBindings* pB, SfxChildWindow* pCW, Window* pParent,
ScDocShell* pDocSh, ScAddress aCursorPos )
: ScAnyRefDlg ( pB, pCW, pParent, RID_SCDLG_OPTSOLVER ),
//
maFtObjectiveCell ( this, ScResId( FT_OBJECTIVECELL ) ),
maEdObjectiveCell ( this, this, ScResId( ED_OBJECTIVECELL ) ),
maRBObjectiveCell ( this, ScResId( IB_OBJECTIVECELL ), &maEdObjectiveCell, this ),
maFtDirection ( this, ScResId( FT_DIRECTION ) ),
maRbMax ( this, ScResId( RB_MAX ) ),
maRbMin ( this, ScResId( RB_MIN ) ),
maRbValue ( this, ScResId( RB_VALUE ) ),
maEdTargetValue ( this, this, ScResId( ED_TARGET ) ),
maRBTargetValue ( this, ScResId( IB_TARGET ), &maEdTargetValue, this ),
maFtVariableCells ( this, ScResId( FT_VARIABLECELLS ) ),
maEdVariableCells ( this, this, ScResId( ED_VARIABLECELLS ) ),
maRBVariableCells ( this, ScResId( IB_VARIABLECELLS ), &maEdVariableCells, this),
maFlConditions ( this, ScResId( FL_CONDITIONS ) ),
maFtCellRef ( this, ScResId( FT_CELLREF ) ),
maEdLeft1 ( this, ScResId( ED_LEFT1 ) ),
maRBLeft1 ( this, ScResId( IB_LEFT1 ), &maEdLeft1, this ),
maFtOperator ( this, ScResId( FT_OPERATOR ) ),
maLbOp1 ( this, ScResId( LB_OP1 ) ),
maFtConstraint ( this, ScResId( FT_CONSTRAINT ) ),
maEdRight1 ( this, ScResId( ED_RIGHT1 ) ),
maRBRight1 ( this, ScResId( IB_RIGHT1 ), &maEdRight1, this ),
maBtnDel1 ( this, ScResId( IB_DELETE1 ) ),
maEdLeft2 ( this, ScResId( ED_LEFT2 ) ),
maRBLeft2 ( this, ScResId( IB_LEFT2 ), &maEdLeft2, this ),
maLbOp2 ( this, ScResId( LB_OP2 ) ),
maEdRight2 ( this, ScResId( ED_RIGHT2 ) ),
maRBRight2 ( this, ScResId( IB_RIGHT2 ), &maEdRight2, this ),
maBtnDel2 ( this, ScResId( IB_DELETE2 ) ),
maEdLeft3 ( this, ScResId( ED_LEFT3 ) ),
maRBLeft3 ( this, ScResId( IB_LEFT3 ), &maEdLeft3, this ),
maLbOp3 ( this, ScResId( LB_OP3 ) ),
maEdRight3 ( this, ScResId( ED_RIGHT3 ) ),
maRBRight3 ( this, ScResId( IB_RIGHT3 ), &maEdRight3, this ),
maBtnDel3 ( this, ScResId( IB_DELETE3 ) ),
maEdLeft4 ( this, ScResId( ED_LEFT4 ) ),
maRBLeft4 ( this, ScResId( IB_LEFT4 ), &maEdLeft4, this ),
maLbOp4 ( this, ScResId( LB_OP4 ) ),
maEdRight4 ( this, ScResId( ED_RIGHT4 ) ),
maRBRight4 ( this, ScResId( IB_RIGHT4 ), &maEdRight4, this ),
maBtnDel4 ( this, ScResId( IB_DELETE4 ) ),
maScrollBar ( this, ScResId( SB_SCROLL ) ),
maFlButtons ( this, ScResId( FL_BUTTONS ) ),
maBtnOpt ( this, ScResId( BTN_OPTIONS ) ),
maBtnHelp ( this, ScResId( BTN_HELP ) ),
maBtnCancel ( this, ScResId( BTN_CLOSE ) ),
maBtnSolve ( this, ScResId( BTN_SOLVE ) ),
maInputError ( ScResId( STR_INVALIDINPUT ) ),
maConditionError ( ScResId( STR_INVALIDCONDITION ) ),
//
mpDocShell ( pDocSh ),
mpDoc ( pDocSh->GetDocument() ),
mnCurTab ( aCursorPos.Tab() ),
mpEdActive ( NULL ),
mbDlgLostFocus ( false ),
nScrollPos ( 0 )
{
mpLeftEdit[0] = &maEdLeft1;
mpLeftButton[0] = &maRBLeft1;
mpRightEdit[0] = &maEdRight1;
mpRightButton[0] = &maRBRight1;
mpOperator[0] = &maLbOp1;
mpDelButton[0] = &maBtnDel1;
mpLeftEdit[1] = &maEdLeft2;
mpLeftButton[1] = &maRBLeft2;
mpRightEdit[1] = &maEdRight2;
mpRightButton[1] = &maRBRight2;
mpOperator[1] = &maLbOp2;
mpDelButton[1] = &maBtnDel2;
mpLeftEdit[2] = &maEdLeft3;
mpLeftButton[2] = &maRBLeft3;
mpRightEdit[2] = &maEdRight3;
mpRightButton[2] = &maRBRight3;
mpOperator[2] = &maLbOp3;
mpDelButton[2] = &maBtnDel3;
mpLeftEdit[3] = &maEdLeft4;
mpLeftButton[3] = &maRBLeft4;
mpRightEdit[3] = &maEdRight4;
mpRightButton[3] = &maRBRight4;
mpOperator[3] = &maLbOp4;
mpDelButton[3] = &maBtnDel4;
maRbMax.SetAccessibleRelationMemberOf(&maFtDirection);
maRbMin.SetAccessibleRelationMemberOf(&maFtDirection);
maRbValue.SetAccessibleRelationMemberOf(&maFtDirection);
maEdLeft2.SetAccessibleName(maFtCellRef.GetText());
maLbOp2.SetAccessibleName(maFtOperator.GetText());
maEdRight2.SetAccessibleName(maFtConstraint.GetText());
maEdLeft3.SetAccessibleName(maFtCellRef.GetText());
maLbOp3.SetAccessibleName(maFtOperator.GetText());
maEdRight3.SetAccessibleName(maFtConstraint.GetText());
maEdLeft4.SetAccessibleName(maFtCellRef.GetText());
maLbOp4.SetAccessibleName(maFtOperator.GetText());
maEdRight4.SetAccessibleName(maFtConstraint.GetText());
Init( aCursorPos );
FreeResource();
}
//----------------------------------------------------------------------------
ScOptSolverDlg::~ScOptSolverDlg()
{
}
//----------------------------------------------------------------------------
void ScOptSolverDlg::Init(const ScAddress& rCursorPos)
{
// Get the "Delete Rows" commandimagelist images from sfx instead of
// adding a second copy to sc (see ScTbxInsertCtrl::StateChanged)
rtl::OUString aSlotURL( RTL_CONSTASCII_USTRINGPARAM( "slot:" ));
aSlotURL += rtl::OUString::valueOf( sal_Int32( SID_DEL_ROWS ) );
uno::Reference<frame::XFrame> xFrame = GetBindings().GetActiveFrame();
Image aDelNm = ::GetImage( xFrame, aSlotURL, sal_False, sal_False );
Image aDelHC = ::GetImage( xFrame, aSlotURL, sal_False, sal_True ); // high contrast
for ( sal_uInt16 nRow = 0; nRow < EDIT_ROW_COUNT; ++nRow )
{
mpDelButton[nRow]->SetModeImage( aDelNm, BMP_COLOR_NORMAL );
mpDelButton[nRow]->SetModeImage( aDelHC, BMP_COLOR_HIGHCONTRAST );
}
maBtnOpt.SetClickHdl( LINK( this, ScOptSolverDlg, BtnHdl ) );
maBtnCancel.SetClickHdl( LINK( this, ScOptSolverDlg, BtnHdl ) );
maBtnSolve.SetClickHdl( LINK( this, ScOptSolverDlg, BtnHdl ) );
Link aLink = LINK( this, ScOptSolverDlg, GetFocusHdl );
maEdObjectiveCell.SetGetFocusHdl( aLink );
maRBObjectiveCell.SetGetFocusHdl( aLink );
maEdTargetValue.SetGetFocusHdl( aLink );
maRBTargetValue.SetGetFocusHdl( aLink );
maEdVariableCells.SetGetFocusHdl( aLink );
maRBVariableCells.SetGetFocusHdl( aLink );
maRbValue.SetGetFocusHdl( aLink );
for ( sal_uInt16 nRow = 0; nRow < EDIT_ROW_COUNT; ++nRow )
{
mpLeftEdit[nRow]->SetGetFocusHdl( aLink );
mpLeftButton[nRow]->SetGetFocusHdl( aLink );
mpRightEdit[nRow]->SetGetFocusHdl( aLink );
mpRightButton[nRow]->SetGetFocusHdl( aLink );
mpOperator[nRow]->SetGetFocusHdl( aLink );
}
aLink = LINK( this, ScOptSolverDlg, LoseFocusHdl );
maEdObjectiveCell.SetLoseFocusHdl( aLink );
maRBObjectiveCell.SetLoseFocusHdl( aLink );
maEdTargetValue. SetLoseFocusHdl( aLink );
maRBTargetValue. SetLoseFocusHdl( aLink );
maEdVariableCells.SetLoseFocusHdl( aLink );
maRBVariableCells.SetLoseFocusHdl( aLink );
for ( sal_uInt16 nRow = 0; nRow < EDIT_ROW_COUNT; ++nRow )
{
mpLeftEdit[nRow]->SetLoseFocusHdl( aLink );
mpLeftButton[nRow]->SetLoseFocusHdl( aLink );
mpRightEdit[nRow]->SetLoseFocusHdl( aLink );
mpRightButton[nRow]->SetLoseFocusHdl( aLink );
}
Link aCursorUp = LINK( this, ScOptSolverDlg, CursorUpHdl );
Link aCursorDown = LINK( this, ScOptSolverDlg, CursorDownHdl );
Link aCondModify = LINK( this, ScOptSolverDlg, CondModifyHdl );
for ( sal_uInt16 nRow = 0; nRow < EDIT_ROW_COUNT; ++nRow )
{
mpLeftEdit[nRow]->SetCursorLinks( aCursorUp, aCursorDown );
mpRightEdit[nRow]->SetCursorLinks( aCursorUp, aCursorDown );
mpLeftEdit[nRow]->SetModifyHdl( aCondModify );
mpRightEdit[nRow]->SetModifyHdl( aCondModify );
mpDelButton[nRow]->SetClickHdl( LINK( this, ScOptSolverDlg, DelBtnHdl ) );
mpOperator[nRow]->SetSelectHdl( LINK( this, ScOptSolverDlg, SelectHdl ) );
}
maEdTargetValue.SetModifyHdl( LINK( this, ScOptSolverDlg, TargetModifyHdl ) );
maScrollBar.SetEndScrollHdl( LINK( this, ScOptSolverDlg, ScrollHdl ) );
maScrollBar.SetScrollHdl( LINK( this, ScOptSolverDlg, ScrollHdl ) );
maScrollBar.SetPageSize( EDIT_ROW_COUNT );
maScrollBar.SetVisibleSize( EDIT_ROW_COUNT );
maScrollBar.SetLineSize( 1 );
// Range is set in ShowConditions
// get available solver implementations
//! sort by descriptions?
ScSolverUtil::GetImplementations( maImplNames, maDescriptions );
sal_Int32 nImplCount = maImplNames.getLength();
const ScOptSolverSave* pOldData = mpDocShell->GetSolverSaveData();
if ( pOldData )
{
maEdObjectiveCell.SetRefString( pOldData->GetObjective() );
maRbMax.Check( pOldData->GetMax() );
maRbMin.Check( pOldData->GetMin() );
maRbValue.Check( pOldData->GetValue() );
maEdTargetValue.SetRefString( pOldData->GetTarget() );
maEdVariableCells.SetRefString( pOldData->GetVariable() );
maConditions = pOldData->GetConditions();
maEngine = pOldData->GetEngine();
maProperties = pOldData->GetProperties();
}
else
{
maRbMax.Check();
String aCursorStr;
if ( !mpDoc->GetRangeAtBlock( ScRange(rCursorPos), &aCursorStr ) )
rCursorPos.Format( aCursorStr, SCA_ABS, NULL, mpDoc->GetAddressConvention() );
maEdObjectiveCell.SetRefString( aCursorStr );
if ( nImplCount > 0 )
maEngine = maImplNames[0]; // use first implementation
}
ShowConditions();
maEdObjectiveCell.GrabFocus();
mpEdActive = &maEdObjectiveCell;
}
//----------------------------------------------------------------------------
void ScOptSolverDlg::ReadConditions()
{
for ( sal_uInt16 nRow = 0; nRow < EDIT_ROW_COUNT; ++nRow )
{
ScOptConditionRow aRowEntry;
aRowEntry.aLeftStr = mpLeftEdit[nRow]->GetText();
aRowEntry.aRightStr = mpRightEdit[nRow]->GetText();
aRowEntry.nOperator = mpOperator[nRow]->GetSelectEntryPos();
long nVecPos = nScrollPos + nRow;
if ( nVecPos >= (long)maConditions.size() && !aRowEntry.IsDefault() )
maConditions.resize( nVecPos + 1 );
if ( nVecPos < (long)maConditions.size() )
maConditions[nVecPos] = aRowEntry;
// remove default entries at the end
size_t nSize = maConditions.size();
while ( nSize > 0 && maConditions[ nSize-1 ].IsDefault() )
--nSize;
maConditions.resize( nSize );
}
}
void ScOptSolverDlg::ShowConditions()
{
for ( sal_uInt16 nRow = 0; nRow < EDIT_ROW_COUNT; ++nRow )
{
ScOptConditionRow aRowEntry;
long nVecPos = nScrollPos + nRow;
if ( nVecPos < (long)maConditions.size() )
aRowEntry = maConditions[nVecPos];
mpLeftEdit[nRow]->SetRefString( aRowEntry.aLeftStr );
mpRightEdit[nRow]->SetRefString( aRowEntry.aRightStr );
mpOperator[nRow]->SelectEntryPos( aRowEntry.nOperator );
}
// allow to scroll one page behind the visible or stored rows
long nVisible = nScrollPos + EDIT_ROW_COUNT;
long nMax = std::max( nVisible, (long) maConditions.size() );
maScrollBar.SetRange( Range( 0, nMax + EDIT_ROW_COUNT ) );
maScrollBar.SetThumbPos( nScrollPos );
EnableButtons();
}
void ScOptSolverDlg::EnableButtons()
{
for ( sal_uInt16 nRow = 0; nRow < EDIT_ROW_COUNT; ++nRow )
{
long nVecPos = nScrollPos + nRow;
mpDelButton[nRow]->Enable( nVecPos < (long)maConditions.size() );
}
}
//----------------------------------------------------------------------------
sal_Bool ScOptSolverDlg::Close()
{
return DoClose( ScOptSolverDlgWrapper::GetChildWindowId() );
}
//----------------------------------------------------------------------------
void ScOptSolverDlg::SetActive()
{
if ( mbDlgLostFocus )
{
mbDlgLostFocus = false;
if( mpEdActive )
mpEdActive->GrabFocus();
}
else
{
GrabFocus();
}
RefInputDone();
}
//----------------------------------------------------------------------------
void ScOptSolverDlg::SetReference( const ScRange& rRef, ScDocument* pDocP )
{
if( mpEdActive )
{
if ( rRef.aStart != rRef.aEnd )
RefInputStart(mpEdActive);
// "target"/"value": single cell
bool bSingle = ( mpEdActive == &maEdObjectiveCell || mpEdActive == &maEdTargetValue );
String aStr;
ScAddress aAdr = rRef.aStart;
ScRange aNewRef( rRef );
if ( bSingle )
aNewRef.aEnd = aAdr;
String aName;
if ( pDocP->GetRangeAtBlock( aNewRef, &aName ) ) // named range: show name
aStr = aName;
else // format cell/range reference
{
sal_uInt16 nFmt = ( aAdr.Tab() == mnCurTab ) ? SCA_ABS : SCA_ABS_3D;
if ( bSingle )
aAdr.Format( aStr, nFmt, pDocP, pDocP->GetAddressConvention() );
else
rRef.Format( aStr, nFmt | SCR_ABS, pDocP, pDocP->GetAddressConvention() );
}
// variable cells can be several ranges, so only the selection is replaced
if ( mpEdActive == &maEdVariableCells )
{
String aVal = mpEdActive->GetText();
Selection aSel = mpEdActive->GetSelection();
aSel.Justify();
aVal.Erase( (xub_StrLen)aSel.Min(), (xub_StrLen)aSel.Len() );
aVal.Insert( aStr, (xub_StrLen)aSel.Min() );
Selection aNewSel( aSel.Min(), aSel.Min()+aStr.Len() );
mpEdActive->SetRefString( aVal );
mpEdActive->SetSelection( aNewSel );
}
else
mpEdActive->SetRefString( aStr );
ReadConditions();
EnableButtons();
// select "Value of" if a ref is input into "target" edit
if ( mpEdActive == &maEdTargetValue )
maRbValue.Check();
}
}
//----------------------------------------------------------------------------
sal_Bool ScOptSolverDlg::IsRefInputMode() const
{
return mpEdActive != NULL;
}
//----------------------------------------------------------------------------
// Handler:
IMPL_LINK( ScOptSolverDlg, BtnHdl, PushButton*, pBtn )
{
if ( pBtn == &maBtnSolve || pBtn == &maBtnCancel )
{
bool bSolve = ( pBtn == &maBtnSolve );
SetDispatcherLock( sal_False );
SwitchToDocument();
bool bClose = true;
if ( bSolve )
bClose = CallSolver();
if ( bClose )
{
// Close: write dialog settings to DocShell for subsequent calls
ReadConditions();
ScOptSolverSave aSave(
maEdObjectiveCell.GetText(), maRbMax.IsChecked(), maRbMin.IsChecked(), maRbValue.IsChecked(),
maEdTargetValue.GetText(), maEdVariableCells.GetText(), maConditions, maEngine, maProperties );
mpDocShell->SetSolverSaveData( aSave );
Close();
}
else
{
// no solution -> dialog is kept open
SetDispatcherLock( sal_True );
}
}
else if ( pBtn == &maBtnOpt )
{
//! move options dialog to UI lib?
ScSolverOptionsDialog* pOptDlg =
new ScSolverOptionsDialog( this, maImplNames, maDescriptions, maEngine, maProperties );
if ( pOptDlg->Execute() == RET_OK )
{
maEngine = pOptDlg->GetEngine();
maProperties = pOptDlg->GetProperties();
}
delete pOptDlg;
}
return 0;
}
//----------------------------------------------------------------------------
IMPL_LINK( ScOptSolverDlg, GetFocusHdl, Control*, pCtrl )
{
Edit* pEdit = NULL;
mpEdActive = NULL;
if( pCtrl == &maEdObjectiveCell || pCtrl == &maRBObjectiveCell )
pEdit = mpEdActive = &maEdObjectiveCell;
else if( pCtrl == &maEdTargetValue || pCtrl == &maRBTargetValue )
pEdit = mpEdActive = &maEdTargetValue;
else if( pCtrl == &maEdVariableCells || pCtrl == &maRBVariableCells )
pEdit = mpEdActive = &maEdVariableCells;
for ( sal_uInt16 nRow = 0; nRow < EDIT_ROW_COUNT; ++nRow )
{
if( pCtrl == mpLeftEdit[nRow] || pCtrl == mpLeftButton[nRow] )
pEdit = mpEdActive = mpLeftEdit[nRow];
else if( pCtrl == mpRightEdit[nRow] || pCtrl == mpRightButton[nRow] )
pEdit = mpEdActive = mpRightEdit[nRow];
else if( pCtrl == mpOperator[nRow] ) // focus on "operator" list box
mpEdActive = mpRightEdit[nRow]; // use right edit for ref input, but don't change selection
}
if( pCtrl == &maRbValue ) // focus on "Value of" radio button
mpEdActive = &maEdTargetValue; // use value edit for ref input, but don't change selection
if( pEdit )
pEdit->SetSelection( Selection( 0, SELECTION_MAX ) );
return 0;
}
//----------------------------------------------------------------------------
IMPL_LINK( ScOptSolverDlg, LoseFocusHdl, Control*, EMPTYARG )
{
mbDlgLostFocus = !IsActive();
return 0;
}
//----------------------------------------------------------------------------
IMPL_LINK( ScOptSolverDlg, DelBtnHdl, PushButton*, pBtn )
{
for ( sal_uInt16 nRow = 0; nRow < EDIT_ROW_COUNT; ++nRow )
if( pBtn == mpDelButton[nRow] )
{
sal_Bool bHadFocus = pBtn->HasFocus();
ReadConditions();
long nVecPos = nScrollPos + nRow;
if ( nVecPos < (long)maConditions.size() )
{
maConditions.erase( maConditions.begin() + nVecPos );
ShowConditions();
if ( bHadFocus && !pBtn->IsEnabled() )
{
// If the button is disabled, focus would normally move to the next control,
// (left edit of the next row). Move it to left edit of this row instead.
mpEdActive = mpLeftEdit[nRow];
mpEdActive->GrabFocus();
}
}
}
return 0;
}
//----------------------------------------------------------------------------
IMPL_LINK( ScOptSolverDlg, TargetModifyHdl, Edit*, EMPTYARG )
{
// modify handler for the target edit:
// select "Value of" if something is input into the edit
if ( maEdTargetValue.GetText().Len() )
maRbValue.Check();
return 0;
}
IMPL_LINK( ScOptSolverDlg, CondModifyHdl, Edit*, EMPTYARG )
{
// modify handler for the condition edits, just to enable/disable "delete" buttons
ReadConditions();
EnableButtons();
return 0;
}
IMPL_LINK( ScOptSolverDlg, SelectHdl, ListBox*, EMPTYARG )
{
// select handler for operator list boxes, just to enable/disable "delete" buttons
ReadConditions();
EnableButtons();
return 0;
}
IMPL_LINK( ScOptSolverDlg, ScrollHdl, ScrollBar*, EMPTYARG )
{
ReadConditions();
nScrollPos = maScrollBar.GetThumbPos();
ShowConditions();
if( mpEdActive )
mpEdActive->SetSelection( Selection( 0, SELECTION_MAX ) );
return 0;
}
IMPL_LINK( ScOptSolverDlg, CursorUpHdl, ScCursorRefEdit*, pEdit )
{
if ( pEdit == mpLeftEdit[0] || pEdit == mpRightEdit[0] )
{
if ( nScrollPos > 0 )
{
ReadConditions();
--nScrollPos;
ShowConditions();
if( mpEdActive )
mpEdActive->SetSelection( Selection( 0, SELECTION_MAX ) );
}
}
else
{
formula::RefEdit* pFocus = NULL;
for ( sal_uInt16 nRow = 1; nRow < EDIT_ROW_COUNT; ++nRow ) // second row or below: move focus
{
if ( pEdit == mpLeftEdit[nRow] )
pFocus = mpLeftEdit[nRow-1];
else if ( pEdit == mpRightEdit[nRow] )
pFocus = mpRightEdit[nRow-1];
}
if (pFocus)
{
mpEdActive = pFocus;
pFocus->GrabFocus();
}
}
return 0;
}
IMPL_LINK( ScOptSolverDlg, CursorDownHdl, ScCursorRefEdit*, pEdit )
{
if ( pEdit == mpLeftEdit[EDIT_ROW_COUNT-1] || pEdit == mpRightEdit[EDIT_ROW_COUNT-1] )
{
//! limit scroll position?
ReadConditions();
++nScrollPos;
ShowConditions();
if( mpEdActive )
mpEdActive->SetSelection( Selection( 0, SELECTION_MAX ) );
}
else
{
formula::RefEdit* pFocus = NULL;
for ( sal_uInt16 nRow = 0; nRow+1 < EDIT_ROW_COUNT; ++nRow ) // before last row: move focus
{
if ( pEdit == mpLeftEdit[nRow] )
pFocus = mpLeftEdit[nRow+1];
else if ( pEdit == mpRightEdit[nRow] )
pFocus = mpRightEdit[nRow+1];
}
if (pFocus)
{
mpEdActive = pFocus;
pFocus->GrabFocus();
}
}
return 0;
}
//----------------------------------------------------------------------------
void ScOptSolverDlg::ShowError( bool bCondition, formula::RefEdit* pFocus )
{
String aMessage = bCondition ? maConditionError : maInputError;
ErrorBox( this, WinBits( WB_OK | WB_DEF_OK ), aMessage ).Execute();
if (pFocus)
{
mpEdActive = pFocus;
pFocus->GrabFocus();
}
}
//----------------------------------------------------------------------------
bool ScOptSolverDlg::ParseRef( ScRange& rRange, const String& rInput, bool bAllowRange )
{
ScRangeUtil aRangeUtil;
ScAddress::Details aDetails(mpDoc->GetAddressConvention(), 0, 0);
sal_uInt16 nFlags = rRange.ParseAny( rInput, mpDoc, aDetails );
if ( nFlags & SCA_VALID )
{
if ( (nFlags & SCA_TAB_3D) == 0 )
rRange.aStart.SetTab( mnCurTab );
if ( (nFlags & SCA_TAB2_3D) == 0 )
rRange.aEnd.SetTab( rRange.aStart.Tab() );
return ( bAllowRange || rRange.aStart == rRange.aEnd );
}
else if ( aRangeUtil.MakeRangeFromName( rInput, mpDoc, mnCurTab, rRange, RUTL_NAMES, aDetails ) )
return ( bAllowRange || rRange.aStart == rRange.aEnd );
return false; // not recognized
}
bool ScOptSolverDlg::FindTimeout( sal_Int32& rTimeout )
{
bool bFound = false;
if ( !maProperties.getLength() )
maProperties = ScSolverUtil::GetDefaults( maEngine ); // get property defaults from component
sal_Int32 nPropCount = maProperties.getLength();
for (sal_Int32 nProp=0; nProp<nPropCount && !bFound; ++nProp)
{
const beans::PropertyValue& rValue = maProperties[nProp];
if ( rValue.Name.equalsAscii( SC_UNONAME_TIMEOUT ) )
bFound = ( rValue.Value >>= rTimeout );
}
return bFound;
}
bool ScOptSolverDlg::CallSolver() // return true -> close dialog after calling
{
// show progress dialog
ScSolverProgressDialog aProgress( this );
sal_Int32 nTimeout = 0;
if ( FindTimeout( nTimeout ) )
aProgress.SetTimeLimit( nTimeout );
else
aProgress.HideTimeLimit();
aProgress.Show();
aProgress.Update();
aProgress.Sync();
// try to make sure the progress dialog is painted before continuing
Application::Reschedule(true);
// collect solver parameters
ReadConditions();
uno::Reference<sheet::XSpreadsheetDocument> xDocument( mpDocShell->GetModel(), uno::UNO_QUERY );
ScRange aObjRange;
if ( !ParseRef( aObjRange, maEdObjectiveCell.GetText(), false ) )
{
ShowError( false, &maEdObjectiveCell );
return false;
}
table::CellAddress aObjective( aObjRange.aStart.Tab(), aObjRange.aStart.Col(), aObjRange.aStart.Row() );
// "changing cells" can be several ranges
ScRangeList aVarRanges;
if ( !ParseWithNames( aVarRanges, maEdVariableCells.GetText(), mpDoc ) )
{
ShowError( false, &maEdVariableCells );
return false;
}
uno::Sequence<table::CellAddress> aVariables;
sal_Int32 nVarPos = 0;
sal_uLong nRangeCount = aVarRanges.Count();
for (sal_uLong nRangePos=0; nRangePos<nRangeCount; ++nRangePos)
{
ScRange aRange(*aVarRanges.GetObject(nRangePos));
aRange.Justify();
SCTAB nTab = aRange.aStart.Tab();
// resolve into single cells
sal_Int32 nAdd = ( aRange.aEnd.Col() - aRange.aStart.Col() + 1 ) *
( aRange.aEnd.Row() - aRange.aStart.Row() + 1 );
aVariables.realloc( nVarPos + nAdd );
for (SCROW nRow = aRange.aStart.Row(); nRow <= aRange.aEnd.Row(); ++nRow)
for (SCCOL nCol = aRange.aStart.Col(); nCol <= aRange.aEnd.Col(); ++nCol)
aVariables[nVarPos++] = table::CellAddress( nTab, nCol, nRow );
}
uno::Sequence<sheet::SolverConstraint> aConstraints;
sal_Int32 nConstrPos = 0;
for ( std::vector<ScOptConditionRow>::const_iterator aConstrIter = maConditions.begin();
aConstrIter != maConditions.end(); ++aConstrIter )
{
if ( aConstrIter->aLeftStr.Len() )
{
sheet::SolverConstraint aConstraint;
// order of list box entries must match enum values
aConstraint.Operator = static_cast<sheet::SolverConstraintOperator>(aConstrIter->nOperator);
ScRange aLeftRange;
if ( !ParseRef( aLeftRange, aConstrIter->aLeftStr, true ) )
{
ShowError( true, NULL );
return false;
}
bool bIsRange = false;
ScRange aRightRange;
if ( ParseRef( aRightRange, aConstrIter->aRightStr, true ) )
{
if ( aRightRange.aStart == aRightRange.aEnd )
aConstraint.Right <<= table::CellAddress( aRightRange.aStart.Tab(),
aRightRange.aStart.Col(), aRightRange.aStart.Row() );
else if ( aRightRange.aEnd.Col()-aRightRange.aStart.Col() == aLeftRange.aEnd.Col()-aLeftRange.aStart.Col() &&
aRightRange.aEnd.Row()-aRightRange.aStart.Row() == aLeftRange.aEnd.Row()-aLeftRange.aStart.Row() )
bIsRange = true; // same size as "left" range, resolve into single cells
else
{
ShowError( true, NULL );
return false;
}
}
else
{
sal_uInt32 nFormat = 0; //! explicit language?
double fValue = 0.0;
if ( mpDoc->GetFormatTable()->IsNumberFormat( aConstrIter->aRightStr, nFormat, fValue ) )
aConstraint.Right <<= fValue;
else if ( aConstraint.Operator != sheet::SolverConstraintOperator_INTEGER &&
aConstraint.Operator != sheet::SolverConstraintOperator_BINARY )
{
ShowError( true, NULL );
return false;
}
}
// resolve into single cells
sal_Int32 nAdd = ( aLeftRange.aEnd.Col() - aLeftRange.aStart.Col() + 1 ) *
( aLeftRange.aEnd.Row() - aLeftRange.aStart.Row() + 1 );
aConstraints.realloc( nConstrPos + nAdd );
for (SCROW nRow = aLeftRange.aStart.Row(); nRow <= aLeftRange.aEnd.Row(); ++nRow)
for (SCCOL nCol = aLeftRange.aStart.Col(); nCol <= aLeftRange.aEnd.Col(); ++nCol)
{
aConstraint.Left = table::CellAddress( aLeftRange.aStart.Tab(), nCol, nRow );
if ( bIsRange )
aConstraint.Right <<= table::CellAddress( aRightRange.aStart.Tab(),
aRightRange.aStart.Col() + ( nCol - aLeftRange.aStart.Col() ),
aRightRange.aStart.Row() + ( nRow - aLeftRange.aStart.Row() ) );
aConstraints[nConstrPos++] = aConstraint;
}
}
}
sal_Bool bMaximize = maRbMax.IsChecked();
if ( maRbValue.IsChecked() )
{
// handle "value of" with an additional constraint (and then minimize)
sheet::SolverConstraint aConstraint;
aConstraint.Left = aObjective;
aConstraint.Operator = sheet::SolverConstraintOperator_EQUAL;
String aValStr = maEdTargetValue.GetText();
ScRange aRightRange;
if ( ParseRef( aRightRange, aValStr, false ) )
aConstraint.Right <<= table::CellAddress( aRightRange.aStart.Tab(),
aRightRange.aStart.Col(), aRightRange.aStart.Row() );
else
{
sal_uInt32 nFormat = 0; //! explicit language?
double fValue = 0.0;
if ( mpDoc->GetFormatTable()->IsNumberFormat( aValStr, nFormat, fValue ) )
aConstraint.Right <<= fValue;
else
{
ShowError( false, &maEdTargetValue );
return false;
}
}
aConstraints.realloc( nConstrPos + 1 );
aConstraints[nConstrPos++] = aConstraint;
}
// copy old document values
sal_Int32 nVarCount = aVariables.getLength();
uno::Sequence<double> aOldValues;
aOldValues.realloc( nVarCount );
for (nVarPos=0; nVarPos<nVarCount; ++nVarPos)
{
ScAddress aCellPos;
ScUnoConversion::FillScAddress( aCellPos, aVariables[nVarPos] );
aOldValues[nVarPos] = mpDoc->GetValue( aCellPos );
}
// create and initialize solver
uno::Reference<sheet::XSolver> xSolver = ScSolverUtil::GetSolver( maEngine );
DBG_ASSERT( xSolver.is(), "can't get solver component" );
if ( !xSolver.is() )
return false;
xSolver->setDocument( xDocument );
xSolver->setObjective( aObjective );
xSolver->setVariables( aVariables );
xSolver->setConstraints( aConstraints );
xSolver->setMaximize( bMaximize );
// set options
uno::Reference<beans::XPropertySet> xOptProp(xSolver, uno::UNO_QUERY);
if ( xOptProp.is() )
{
sal_Int32 nPropCount = maProperties.getLength();
for (sal_Int32 nProp=0; nProp<nPropCount; ++nProp)
{
const beans::PropertyValue& rValue = maProperties[nProp];
try
{
xOptProp->setPropertyValue( rValue.Name, rValue.Value );
}
catch ( uno::Exception & )
{
DBG_ERRORFILE("Exception in solver option property");
}
}
}
xSolver->solve();
sal_Bool bSuccess = xSolver->getSuccess();
aProgress.Hide();
bool bClose = false;
bool bRestore = true; // restore old values unless a solution is accepted
if ( bSuccess )
{
// put solution into document so it is visible when asking
uno::Sequence<double> aSolution = xSolver->getSolution();
if ( aSolution.getLength() == nVarCount )
{
mpDocShell->LockPaint();
ScDocFunc aFunc(*mpDocShell);
for (nVarPos=0; nVarPos<nVarCount; ++nVarPos)
{
ScAddress aCellPos;
ScUnoConversion::FillScAddress( aCellPos, aVariables[nVarPos] );
aFunc.PutCell( aCellPos, new ScValueCell( aSolution[nVarPos] ), sal_True );
}
mpDocShell->UnlockPaint();
}
//! else error?
// take formatted result from document (result value from component is ignored)
String aResultStr;
mpDoc->GetString( (SCCOL)aObjective.Column, (SCROW)aObjective.Row, (SCTAB)aObjective.Sheet, aResultStr );
ScSolverSuccessDialog aDialog( this, aResultStr );
if ( aDialog.Execute() == RET_OK )
{
// keep results and close dialog
bRestore = false;
bClose = true;
}
}
else
{
rtl::OUString aError;
uno::Reference<sheet::XSolverDescription> xDesc( xSolver, uno::UNO_QUERY );
if ( xDesc.is() )
aError = xDesc->getStatusDescription(); // error description from component
ScSolverNoSolutionDialog aDialog( this, aError );
aDialog.Execute();
}
if ( bRestore ) // restore old values
{
mpDocShell->LockPaint();
ScDocFunc aFunc(*mpDocShell);
for (nVarPos=0; nVarPos<nVarCount; ++nVarPos)
{
ScAddress aCellPos;
ScUnoConversion::FillScAddress( aCellPos, aVariables[nVarPos] );
aFunc.PutCell( aCellPos, new ScValueCell( aOldValues[nVarPos] ), sal_True );
}
mpDocShell->UnlockPaint();
}
return bClose;
}