| /************************************************************** |
| * |
| * 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_extensions.hxx" |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <tools/config.hxx> |
| #include <vcl/msgbox.hxx> |
| #include <sanedlg.hxx> |
| #include <sanedlg.hrc> |
| #include <grid.hxx> |
| #include <math.h> |
| #include <vcl/dibtools.hxx> |
| |
| #define USE_SAVE_STATE |
| #undef SAVE_ALL_STATES |
| |
| ResId SaneResId( sal_uInt32 nID ) |
| { |
| static ResMgr* pResMgr = ResMgr::CreateResMgr( "san" ); |
| return ResId( nID, *pResMgr ); |
| } |
| |
| SaneDlg::SaneDlg( Window* pParent, Sane& rSane ) : |
| ModalDialog( pParent, SaneResId( RID_SANE_DIALOG ) ), |
| mrSane( rSane ), |
| mbIsDragging( sal_False ), |
| mbDragDrawn( sal_False ), |
| maMapMode( MAP_APPFONT ), |
| maOKButton( this, SaneResId( RID_SCAN_OK ) ), |
| maCancelButton( this, SaneResId( RID_SCAN_CANCEL ) ), |
| maDeviceInfoButton( this, SaneResId( RID_DEVICEINFO_BTN ) ), |
| maPreviewButton( this, SaneResId( RID_PREVIEW_BTN ) ), |
| maButtonOption( this, SaneResId( RID_SCAN_BUTTON_OPTION_BTN ) ), |
| maOptionsTxt( this, SaneResId( RID_SCAN_OPTION_TXT ) ), |
| maOptionTitle( this, SaneResId( RID_SCAN_OPTIONTITLE_TXT ) ), |
| maOptionDescTxt( this, SaneResId( RID_SCAN_OPTION_DESC_TXT ) ), |
| maVectorTxt( this, SaneResId( RID_SCAN_NUMERIC_VECTOR_TXT ) ), |
| maScanLeftTxt( this, SaneResId( RID_SCAN_LEFT_TXT ) ), |
| maLeftField( this, SaneResId( RID_SCAN_LEFT_BOX ) ), |
| maScanTopTxt( this, SaneResId( RID_SCAN_TOP_TXT ) ), |
| maTopField( this, SaneResId( RID_SCAN_TOP_BOX ) ), |
| maRightTxt( this, SaneResId( RID_SCAN_RIGHT_TXT ) ), |
| maRightField( this, SaneResId( RID_SCAN_RIGHT_BOX ) ), |
| maBottomTxt( this, SaneResId( RID_SCAN_BOTTOM_TXT ) ), |
| maBottomField( this, SaneResId( RID_SCAN_BOTTOM_BOX ) ), |
| maDeviceBoxTxt( this, SaneResId( RID_DEVICE_BOX_TXT ) ), |
| maDeviceBox( this, SaneResId( RID_DEVICE_BOX ) ), |
| maReslTxt( this, SaneResId( RID_SCAN_RESOLUTION_TXT ) ), |
| maReslBox( this, SaneResId( RID_SCAN_RESOLUTION_BOX ) ), |
| maAdvancedTxt( this, SaneResId( RID_SCAN_ADVANCED_TXT ) ), |
| maAdvancedBox( this, SaneResId( RID_SCAN_ADVANCED_BOX ) ), |
| maVectorBox( this, SaneResId( RID_SCAN_NUMERIC_VECTOR_BOX ) ), |
| maQuantumRangeBox( this, SaneResId( RID_SCAN_QUANTUM_RANGE_BOX ) ), |
| maStringRangeBox( this, SaneResId( RID_SCAN_STRING_RANGE_BOX ) ), |
| maPreviewBox( this, SaneResId( RID_PREVIEW_BOX ) ), |
| maAreaBox( this, SaneResId( RID_SCANAREA_BOX ) ), |
| maBoolCheckBox( this, SaneResId( RID_SCAN_BOOL_OPTION_BOX ) ), |
| maStringEdit( this, SaneResId( RID_SCAN_STRING_OPTION_EDT ) ), |
| maNumericEdit( this, SaneResId( RID_SCAN_NUMERIC_OPTION_EDT ) ), |
| maOptionBox( this, SaneResId( RID_SCAN_OPTION_BOX ) ), |
| mpRange( 0 ) |
| { |
| if( Sane::IsSane() ) |
| { |
| InitDevices(); // opens first sane device |
| DisableOption(); |
| InitFields(); |
| } |
| |
| maDeviceInfoButton.SetClickHdl( LINK( this, SaneDlg, ClickBtnHdl ) ); |
| maPreviewButton.SetClickHdl( LINK( this, SaneDlg, ClickBtnHdl ) ); |
| maButtonOption.SetClickHdl( LINK( this, SaneDlg, ClickBtnHdl ) ); |
| maDeviceBox.SetSelectHdl( LINK( this, SaneDlg, SelectHdl ) ); |
| maOptionBox.SetSelectHdl( LINK( this, SaneDlg, OptionsBoxSelectHdl ) ); |
| maOKButton.SetClickHdl( LINK( this, SaneDlg, ClickBtnHdl ) ); |
| maCancelButton.SetClickHdl( LINK( this, SaneDlg, ClickBtnHdl ) ); |
| maBoolCheckBox.SetClickHdl( LINK( this, SaneDlg, ClickBtnHdl ) ); |
| maStringEdit.SetModifyHdl( LINK( this, SaneDlg, ModifyHdl ) ); |
| maNumericEdit.SetModifyHdl( LINK( this, SaneDlg, ModifyHdl ) ); |
| maVectorBox.SetModifyHdl( LINK( this, SaneDlg, ModifyHdl ) ); |
| maReslBox.SetModifyHdl( LINK( this, SaneDlg, ModifyHdl ) ); |
| maStringRangeBox.SetSelectHdl( LINK( this, SaneDlg, SelectHdl ) ); |
| maQuantumRangeBox.SetSelectHdl( LINK( this, SaneDlg, SelectHdl ) ); |
| maLeftField.SetModifyHdl( LINK( this, SaneDlg, ModifyHdl ) ); |
| maRightField.SetModifyHdl( LINK( this, SaneDlg, ModifyHdl ) ); |
| maTopField.SetModifyHdl( LINK( this, SaneDlg, ModifyHdl ) ); |
| maBottomField.SetModifyHdl( LINK( this, SaneDlg, ModifyHdl ) ); |
| maAdvancedBox.SetClickHdl( LINK( this, SaneDlg, ClickBtnHdl ) ); |
| |
| maOldLink = mrSane.SetReloadOptionsHdl( LINK( this, SaneDlg, ReloadSaneOptionsHdl ) ); |
| |
| maOptionBox.SetNodeBitmaps( |
| Bitmap( SaneResId( RID_SCAN_BITMAP_PLUS ) ), |
| Bitmap( SaneResId( RID_SCAN_BITMAP_MINUS ) ) |
| ); |
| maOptionBox.SetStyle( maOptionBox.GetStyle()| |
| WB_HASLINES | |
| WB_HASBUTTONS | |
| WB_NOINITIALSELECTION | |
| WB_HASBUTTONSATROOT | |
| WB_HASLINESATROOT |
| ); |
| FreeResource(); |
| } |
| |
| SaneDlg::~SaneDlg() |
| { |
| } |
| |
| short SaneDlg::Execute() |
| { |
| if( ! Sane::IsSane() ) |
| { |
| ErrorBox aErrorBox( NULL, WB_OK | WB_DEF_OK, |
| String( SaneResId( RID_SANE_NOSANELIB_TXT ) ) ); |
| aErrorBox.Execute(); |
| return sal_False; |
| } |
| LoadState(); |
| return ModalDialog::Execute(); |
| } |
| |
| void SaneDlg::InitDevices() |
| { |
| if( ! Sane::IsSane() ) |
| return; |
| |
| if( mrSane.IsOpen() ) |
| mrSane.Close(); |
| mrSane.ReloadDevices(); |
| maDeviceBox.Clear(); |
| for( int i = 0; i < Sane::CountDevices(); i++ ) |
| maDeviceBox.InsertEntry( Sane::GetName( i ) ); |
| if( Sane::CountDevices() ) |
| { |
| mrSane.Open( 0 ); |
| maDeviceBox.SelectEntry( Sane::GetName( 0 ) ); |
| |
| } |
| } |
| |
| void SaneDlg::InitFields() |
| { |
| if( ! Sane::IsSane() ) |
| return; |
| |
| int nOption, i, nValue; |
| double fValue; |
| sal_Bool bSuccess = sal_False; |
| const char *ppSpecialOptions[] = { |
| "resolution", |
| "tl-x", |
| "tl-y", |
| "br-x", |
| "br-y", |
| "preview" |
| }; |
| |
| mbDragEnable = sal_True; |
| maReslBox.Clear(); |
| maMinTopLeft = Point( 0, 0 ); |
| maMaxBottomRight = Point( PREVIEW_WIDTH, PREVIEW_HEIGHT ); |
| |
| if( ! mrSane.IsOpen() ) |
| return; |
| |
| // set Resolution |
| nOption = mrSane.GetOptionByName( "resolution" ); |
| if( nOption != -1 ) |
| { |
| double fRes; |
| |
| bSuccess = mrSane.GetOptionValue( nOption, fRes ); |
| if( bSuccess ) |
| { |
| maReslBox.Enable( sal_True ); |
| |
| maReslBox.SetValue( (long)fRes ); |
| double *pDouble = NULL; |
| nValue = mrSane.GetRange( nOption, pDouble ); |
| if( nValue > -1 ) |
| { |
| if( nValue ) |
| { |
| maReslBox.SetMin( (long)pDouble[0] ); |
| maReslBox.SetMax( (long)pDouble[ nValue-1 ] ); |
| for( i=0; i<nValue; i++ ) |
| { |
| if( i == 0 || i == nValue-1 || ! ( ((int)pDouble[i]) % 20) ) |
| maReslBox.InsertValue( (long)pDouble[i] ); |
| } |
| } |
| else |
| { |
| maReslBox.SetMin( (long)pDouble[0] ); |
| maReslBox.SetMax( (long)pDouble[1] ); |
| maReslBox.InsertValue( (long)pDouble[0] ); |
| // mh@openoffice.org: issue 68557: Can only select 75 and 2400 dpi in Scanner dialogue |
| // scanner allows random setting of dpi resolution, a slider might be useful |
| // support that |
| // workaround: offer at least some more standard dpi resolution between |
| // min and max value |
| int bGot300 = 0; |
| for ( int nRes = (long) pDouble[0] * 2; nRes < (long) pDouble[1]; nRes = nRes * 2 ) |
| { |
| if ( !bGot300 && nRes > 300 ) { |
| nRes = 300; bGot300 = 1; |
| } |
| maReslBox.InsertValue(nRes); |
| } |
| maReslBox.InsertValue( (long)pDouble[1] ); |
| } |
| if( pDouble ) |
| delete [] pDouble; |
| } |
| else |
| maReslBox.Enable( sal_False ); |
| } |
| } |
| else |
| maReslBox.Enable( sal_False ); |
| |
| // set scan area |
| for( i = 0; i < 4; i++ ) |
| { |
| char const *pOptionName = NULL; |
| MetricField* pField = NULL; |
| switch( i ) |
| { |
| case 0: |
| pOptionName = "tl-x"; |
| pField = &maLeftField; |
| break; |
| case 1: |
| pOptionName = "tl-y"; |
| pField = &maTopField; |
| break; |
| case 2: |
| pOptionName = "br-x"; |
| pField = &maRightField; |
| break; |
| case 3: |
| pOptionName = "br-y"; |
| pField = &maBottomField; |
| } |
| nOption = pOptionName ? mrSane.GetOptionByName( pOptionName ) : -1; |
| bSuccess = sal_False; |
| if( nOption != -1 ) |
| { |
| bSuccess = mrSane.GetOptionValue( nOption, fValue, 0 ); |
| if( bSuccess ) |
| { |
| if( mrSane.GetOptionUnit( nOption ) == SANE_UNIT_MM ) |
| { |
| pField->SetUnit( FUNIT_MM ); |
| pField->SetValue( (int)fValue, FUNIT_MM ); |
| } |
| else // SANE_UNIT_PIXEL |
| { |
| pField->SetValue( (int)fValue, FUNIT_CUSTOM ); |
| pField->SetCustomUnitText( String::CreateFromAscii( "Pixel" ) ); |
| } |
| switch( i ) { |
| case 0: maTopLeft.X() = (int)fValue;break; |
| case 1: maTopLeft.Y() = (int)fValue;break; |
| case 2: maBottomRight.X() = (int)fValue;break; |
| case 3: maBottomRight.Y() = (int)fValue;break; |
| } |
| } |
| double *pDouble = NULL; |
| nValue = mrSane.GetRange( nOption, pDouble ); |
| if( nValue > -1 ) |
| { |
| if( pDouble ) |
| { |
| pField->SetMin( (long)pDouble[0] ); |
| if( nValue ) |
| pField->SetMax( (long)pDouble[ nValue-1 ] ); |
| else |
| pField->SetMax( (long)pDouble[ 1 ] ); |
| delete [] pDouble; |
| } |
| switch( i ) { |
| case 0: maMinTopLeft.X() = pField->GetMin();break; |
| case 1: maMinTopLeft.Y() = pField->GetMin();break; |
| case 2: maMaxBottomRight.X() = pField->GetMax();break; |
| case 3: maMaxBottomRight.Y() = pField->GetMax();break; |
| } |
| } |
| else |
| { |
| switch( i ) { |
| case 0: maMinTopLeft.X() = (int)fValue;break; |
| case 1: maMinTopLeft.Y() = (int)fValue;break; |
| case 2: maMaxBottomRight.X() = (int)fValue;break; |
| case 3: maMaxBottomRight.Y() = (int)fValue;break; |
| } |
| } |
| pField->Enable( sal_True ); |
| } |
| else |
| { |
| mbDragEnable = sal_False; |
| pField->SetMin( 0 ); |
| switch( i ) { |
| case 0: |
| maMinTopLeft.X() = 0; |
| maTopLeft.X() = 0; |
| pField->SetMax( PREVIEW_WIDTH ); |
| pField->SetValue( 0 ); |
| break; |
| case 1: |
| maMinTopLeft.Y() = 0; |
| maTopLeft.Y() = 0; |
| pField->SetMax( PREVIEW_HEIGHT ); |
| pField->SetValue( 0 ); |
| break; |
| case 2: |
| maMaxBottomRight.X() = PREVIEW_WIDTH; |
| maBottomRight.X() = PREVIEW_WIDTH; |
| pField->SetMax( PREVIEW_WIDTH ); |
| pField->SetValue( PREVIEW_WIDTH ); |
| break; |
| case 3: |
| maMaxBottomRight.Y() = PREVIEW_HEIGHT; |
| maBottomRight.Y() = PREVIEW_HEIGHT; |
| pField->SetMax( PREVIEW_HEIGHT ); |
| pField->SetValue( PREVIEW_HEIGHT ); |
| break; |
| } |
| pField->Enable( sal_False ); |
| } |
| } |
| maTopLeft = GetPixelPos( maTopLeft ); |
| maBottomRight = GetPixelPos( maBottomRight ); |
| maPreviewRect = Rectangle( maTopLeft, |
| Size( maBottomRight.X() - maTopLeft.X(), |
| maBottomRight.Y() - maTopLeft.Y() ) |
| ); |
| // fill OptionBox |
| maOptionBox.Clear(); |
| SvLBoxEntry* pParentEntry = 0; |
| sal_Bool bGroupRejected = sal_False; |
| for( i = 1; i < mrSane.CountOptions(); i++ ) |
| { |
| String aOption=mrSane.GetOptionName( i ); |
| sal_Bool bInsertAdvanced = |
| mrSane.GetOptionCap( i ) & SANE_CAP_ADVANCED && |
| ! maAdvancedBox.IsChecked() ? sal_False : sal_True; |
| if( mrSane.GetOptionType( i ) == SANE_TYPE_GROUP ) |
| { |
| if( bInsertAdvanced ) |
| { |
| aOption = mrSane.GetOptionTitle( i ); |
| pParentEntry = maOptionBox.InsertEntry( aOption ); |
| bGroupRejected = sal_False; |
| } |
| else |
| bGroupRejected = sal_True; |
| } |
| else if( aOption.Len() && |
| ! ( mrSane.GetOptionCap( i ) & |
| ( |
| SANE_CAP_HARD_SELECT | |
| SANE_CAP_INACTIVE |
| ) ) && |
| bInsertAdvanced && ! bGroupRejected ) |
| { |
| sal_Bool bIsSpecial = sal_False; |
| for( size_t n = 0; !bIsSpecial && |
| n < sizeof(ppSpecialOptions)/sizeof(ppSpecialOptions[0]); n++ ) |
| { |
| if( aOption.EqualsAscii( ppSpecialOptions[n] ) ) |
| bIsSpecial=sal_True; |
| } |
| if( ! bIsSpecial ) |
| { |
| if( pParentEntry ) |
| maOptionBox.InsertEntry( aOption, pParentEntry ); |
| else |
| maOptionBox.InsertEntry( aOption ); |
| } |
| } |
| } |
| } |
| |
| IMPL_LINK( SaneDlg, ClickBtnHdl, Button*, pButton ) |
| { |
| if( mrSane.IsOpen() ) |
| { |
| if( pButton == &maDeviceInfoButton ) |
| { |
| String aString( SaneResId( RID_SANE_DEVICEINFO_TXT ) ); |
| String aSR( RTL_CONSTASCII_USTRINGPARAM( "%s" ) ); |
| aString.SearchAndReplace( aSR, Sane::GetName( mrSane.GetDeviceNumber() ) ); |
| aString.SearchAndReplace( aSR, Sane::GetVendor( mrSane.GetDeviceNumber() ) ); |
| aString.SearchAndReplace( aSR, Sane::GetModel( mrSane.GetDeviceNumber() ) ); |
| aString.SearchAndReplace( aSR, Sane::GetType( mrSane.GetDeviceNumber() ) ); |
| InfoBox aInfoBox( this, aString ); |
| aInfoBox.Execute(); |
| } |
| else if( pButton == &maPreviewButton ) |
| AcquirePreview(); |
| else if( pButton == &maBoolCheckBox ) |
| { |
| mrSane.SetOptionValue( mnCurrentOption, |
| maBoolCheckBox.IsChecked() ? |
| (sal_Bool)sal_True : (sal_Bool)sal_False ); |
| } |
| else if( pButton == &maButtonOption ) |
| { |
| |
| SANE_Value_Type nType = mrSane.GetOptionType( mnCurrentOption ); |
| switch( nType ) |
| { |
| case SANE_TYPE_BUTTON: |
| mrSane.ActivateButtonOption( mnCurrentOption ); |
| break; |
| case SANE_TYPE_FIXED: |
| case SANE_TYPE_INT: |
| { |
| int nElements = mrSane.GetOptionElements( mnCurrentOption ); |
| double* x = new double[ nElements ]; |
| double* y = new double[ nElements ]; |
| for( int i = 0; i < nElements; i++ ) |
| x[ i ] = (double)i; |
| mrSane.GetOptionValue( mnCurrentOption, y ); |
| |
| GridWindow aGrid( x, y, nElements, this ); |
| aGrid.SetText( mrSane.GetOptionName( mnCurrentOption ) ); |
| aGrid.setBoundings( 0, mfMin, nElements, mfMax ); |
| if( aGrid.Execute() && aGrid.getNewYValues() ) |
| mrSane.SetOptionValue( mnCurrentOption, aGrid.getNewYValues() ); |
| |
| delete [] x; |
| delete [] y; |
| } |
| break; |
| case SANE_TYPE_BOOL: |
| case SANE_TYPE_STRING: |
| case SANE_TYPE_GROUP: |
| break; |
| } |
| } |
| else if( pButton == &maAdvancedBox ) |
| { |
| ReloadSaneOptionsHdl( NULL ); |
| } |
| } |
| if( pButton == &maOKButton ) |
| { |
| double fRes = (double)maReslBox.GetValue(); |
| SetAdjustedNumericalValue( "resolution", fRes ); |
| mrSane.SetReloadOptionsHdl( maOldLink ); |
| UpdateScanArea( sal_True ); |
| SaveState(); |
| EndDialog( mrSane.IsOpen() ? 1 : 0 ); |
| } |
| else if( pButton == &maCancelButton ) |
| { |
| mrSane.SetReloadOptionsHdl( maOldLink ); |
| mrSane.Close(); |
| EndDialog( 0 ); |
| } |
| return 0; |
| } |
| |
| IMPL_LINK( SaneDlg, SelectHdl, ListBox*, pListBox ) |
| { |
| if( pListBox == &maDeviceBox && Sane::IsSane() && Sane::CountDevices() ) |
| { |
| String aNewDevice = maDeviceBox.GetSelectEntry(); |
| int nNumber; |
| if( aNewDevice.Equals( Sane::GetName( nNumber = mrSane.GetDeviceNumber() ) ) ) |
| { |
| mrSane.Close(); |
| mrSane.Open( nNumber ); |
| InitFields(); |
| } |
| } |
| if( mrSane.IsOpen() ) |
| { |
| if( pListBox == &maQuantumRangeBox ) |
| { |
| ByteString aValue( maQuantumRangeBox.GetSelectEntry(), osl_getThreadTextEncoding() ); |
| double fValue = atof( aValue.GetBuffer() ); |
| mrSane.SetOptionValue( mnCurrentOption, fValue, mnCurrentElement ); |
| } |
| else if( pListBox == &maStringRangeBox ) |
| { |
| mrSane.SetOptionValue( mnCurrentOption, maStringRangeBox.GetSelectEntry() ); |
| } |
| } |
| return 0; |
| } |
| |
| IMPL_LINK( SaneDlg, OptionsBoxSelectHdl, SvTreeListBox*, pBox ) |
| { |
| if( pBox == &maOptionBox && Sane::IsSane() ) |
| { |
| String aOption = |
| maOptionBox.GetEntryText( maOptionBox.FirstSelected() ); |
| int nOption = mrSane.GetOptionByName( ByteString( aOption, osl_getThreadTextEncoding() ).GetBuffer() ); |
| if( nOption != -1 && nOption != mnCurrentOption ) |
| { |
| DisableOption(); |
| mnCurrentOption = nOption; |
| maOptionTitle.SetText( mrSane.GetOptionTitle( mnCurrentOption ) ); |
| SANE_Value_Type nType = mrSane.GetOptionType( mnCurrentOption ); |
| SANE_Constraint_Type nConstraint; |
| switch( nType ) |
| { |
| case SANE_TYPE_BOOL: EstablishBoolOption();break; |
| case SANE_TYPE_STRING: |
| nConstraint = mrSane.GetOptionConstraintType( mnCurrentOption ); |
| if( nConstraint == SANE_CONSTRAINT_STRING_LIST ) |
| EstablishStringRange(); |
| else |
| EstablishStringOption(); |
| break; |
| case SANE_TYPE_FIXED: |
| case SANE_TYPE_INT: |
| { |
| nConstraint = mrSane.GetOptionConstraintType( mnCurrentOption ); |
| int nElements = mrSane.GetOptionElements( mnCurrentOption ); |
| mnCurrentElement = 0; |
| if( nConstraint == SANE_CONSTRAINT_RANGE || |
| nConstraint == SANE_CONSTRAINT_WORD_LIST ) |
| EstablishQuantumRange(); |
| else |
| { |
| mfMin = mfMax = 0.0; |
| EstablishNumericOption(); |
| } |
| if( nElements > 1 ) |
| { |
| if( nElements <= 10 ) |
| { |
| maVectorBox.SetValue( 1 ); |
| maVectorBox.SetMin( 1 ); |
| maVectorBox.SetMax( |
| mrSane.GetOptionElements( mnCurrentOption ) ); |
| maVectorBox.Show( sal_True ); |
| maVectorTxt.Show( sal_True ); |
| } |
| else |
| { |
| DisableOption(); |
| // bring up dialog only on button click |
| EstablishButtonOption(); |
| } |
| } |
| } |
| break; |
| case SANE_TYPE_BUTTON: |
| EstablishButtonOption(); |
| break; |
| default: break; |
| } |
| } |
| } |
| return 0; |
| } |
| |
| IMPL_LINK( SaneDlg, ModifyHdl, Edit*, pEdit ) |
| { |
| if( mrSane.IsOpen() ) |
| { |
| if( pEdit == &maStringEdit ) |
| { |
| mrSane.SetOptionValue( mnCurrentOption, maStringEdit.GetText() ); |
| } |
| else if( pEdit == &maReslBox ) |
| { |
| double fRes = (double)maReslBox.GetValue(); |
| int nOption = mrSane.GetOptionByName( "resolution" ); |
| if( nOption != -1 ) |
| { |
| double* pDouble = NULL; |
| int nValues = mrSane.GetRange( nOption, pDouble ); |
| if( nValues > 0 ) |
| { |
| int i; |
| for( i = 0; i < nValues; i++ ) |
| { |
| if( fRes == pDouble[i] ) |
| break; |
| } |
| if( i >= nValues ) |
| fRes = pDouble[0]; |
| } |
| else if( nValues == 0 ) |
| { |
| if( fRes < pDouble[ 0 ] ) |
| fRes = pDouble[ 0 ]; |
| if( fRes > pDouble[ 1 ] ) |
| fRes = pDouble[ 1 ]; |
| } |
| maReslBox.SetValue( (sal_uLong)fRes ); |
| } |
| } |
| else if( pEdit == &maNumericEdit ) |
| { |
| double fValue; |
| char pBuf[256]; |
| ByteString aContents( maNumericEdit.GetText(), osl_getThreadTextEncoding() ); |
| fValue = atof( aContents.GetBuffer() ); |
| if( mfMin != mfMax && ( fValue < mfMin || fValue > mfMax ) ) |
| { |
| if( fValue < mfMin ) |
| fValue = mfMin; |
| else if( fValue > mfMax ) |
| fValue = mfMax; |
| sprintf( pBuf, "%g", fValue ); |
| maNumericEdit.SetText( String( pBuf, osl_getThreadTextEncoding() ) ); |
| } |
| mrSane.SetOptionValue( mnCurrentOption, fValue, mnCurrentElement ); |
| } |
| else if( pEdit == &maVectorBox ) |
| { |
| char pBuf[256]; |
| mnCurrentElement = maVectorBox.GetValue()-1; |
| double fValue; |
| mrSane.GetOptionValue( mnCurrentOption, fValue, mnCurrentElement ); |
| sprintf( pBuf, "%g", fValue ); |
| String aValue( pBuf, osl_getThreadTextEncoding() ); |
| maNumericEdit.SetText( aValue ); |
| maQuantumRangeBox.SelectEntry( aValue ); |
| } |
| else if( pEdit == &maTopField ) |
| { |
| Point aPoint( 0, maTopField.GetValue() ); |
| aPoint = GetPixelPos( aPoint ); |
| maTopLeft.Y() = aPoint.Y(); |
| DrawDrag(); |
| } |
| else if( pEdit == &maLeftField ) |
| { |
| Point aPoint( maLeftField.GetValue(), 0 ); |
| aPoint = GetPixelPos( aPoint ); |
| maTopLeft.X() = aPoint.X(); |
| DrawDrag(); |
| } |
| else if( pEdit == &maBottomField ) |
| { |
| Point aPoint( 0, maBottomField.GetValue() ); |
| aPoint = GetPixelPos( aPoint ); |
| maBottomRight.Y() = aPoint.Y(); |
| DrawDrag(); |
| } |
| else if( pEdit == &maRightField ) |
| { |
| Point aPoint( maRightField.GetValue(), 0 ); |
| aPoint = GetPixelPos( aPoint ); |
| maBottomRight.X() = aPoint.X(); |
| DrawDrag(); |
| } |
| } |
| return 0; |
| } |
| |
| IMPL_LINK( SaneDlg, ReloadSaneOptionsHdl, Sane*, /*pSane*/ ) |
| { |
| mnCurrentOption = -1; |
| mnCurrentElement = 0; |
| DisableOption(); |
| // #92024# preserve preview rect, should only be set |
| // initially or in AcquirePreview |
| Rectangle aPreviewRect = maPreviewRect; |
| InitFields(); |
| maPreviewRect = aPreviewRect; |
| Rectangle aDummyRect( Point( 0, 0 ), GetSizePixel() ); |
| Paint( aDummyRect ); |
| return 0; |
| } |
| |
| void SaneDlg::AcquirePreview() |
| { |
| if( ! mrSane.IsOpen() ) |
| return; |
| |
| UpdateScanArea( sal_True ); |
| // set small resolution for preview |
| double fResl = (double)maReslBox.GetValue(); |
| SetAdjustedNumericalValue( "resolution", 30.0 ); |
| |
| int nOption = mrSane.GetOptionByName( "preview" ); |
| if( nOption == -1 ) |
| { |
| String aString( SaneResId( RID_SANE_NORESOLUTIONOPTION_TXT ) ); |
| WarningBox aBox( this, WB_OK_CANCEL | WB_DEF_OK, aString ); |
| if( aBox.Execute() == RET_CANCEL ) |
| return; |
| } |
| else |
| mrSane.SetOptionValue( nOption, (sal_Bool)sal_True ); |
| |
| BitmapTransporter aTransporter; |
| if( ! mrSane.Start( aTransporter ) ) |
| { |
| ErrorBox aErrorBox( this, WB_OK | WB_DEF_OK, |
| String( SaneResId( RID_SANE_SCANERROR_TXT ) ) ); |
| aErrorBox.Execute(); |
| } |
| else |
| { |
| #if OSL_DEBUG_LEVEL > 1 |
| aTransporter.getStream().Seek( STREAM_SEEK_TO_END ); |
| fprintf( stderr, "Previewbitmapstream contains %d bytes\n", (int)aTransporter.getStream().Tell() ); |
| #endif |
| aTransporter.getStream().Seek( STREAM_SEEK_TO_BEGIN ); |
| ReadDIB(maPreviewBitmap, aTransporter.getStream(), true); |
| } |
| |
| SetAdjustedNumericalValue( "resolution", fResl ); |
| maReslBox.SetValue( (sal_uLong)fResl ); |
| |
| if( mbDragEnable ) |
| maPreviewRect = Rectangle( maTopLeft, |
| Size( maBottomRight.X() - maTopLeft.X(), |
| maBottomRight.Y() - maTopLeft.Y() ) |
| ); |
| else |
| { |
| Size aBMSize( maPreviewBitmap.GetSizePixel() ); |
| if( aBMSize.Width() > aBMSize.Height() ) |
| { |
| int nVHeight = (maBottomRight.X() - maTopLeft.X()) * aBMSize.Height() / aBMSize.Width(); |
| maPreviewRect = Rectangle( Point( maTopLeft.X(), ( maTopLeft.Y() + maBottomRight.Y() )/2 - nVHeight/2 ), |
| Size( maBottomRight.X() - maTopLeft.X(), |
| nVHeight ) ); |
| } |
| else |
| { |
| int nVWidth = (maBottomRight.Y() - maTopLeft.Y()) * aBMSize.Width() / aBMSize.Height(); |
| maPreviewRect = Rectangle( Point( ( maTopLeft.X() + maBottomRight.X() )/2 - nVWidth/2, maTopLeft.Y() ), |
| Size( nVWidth, |
| maBottomRight.Y() - maTopLeft.Y() ) ); |
| } |
| } |
| |
| Paint( Rectangle( Point( 0, 0 ), GetSizePixel() ) ); |
| } |
| |
| void SaneDlg::Paint( const Rectangle& rRect ) |
| { |
| SetMapMode( maMapMode ); |
| SetFillColor( Color( COL_WHITE ) ); |
| SetLineColor( Color( COL_WHITE ) ); |
| DrawRect( Rectangle( Point( PREVIEW_UPPER_LEFT, PREVIEW_UPPER_TOP ), |
| Size( PREVIEW_WIDTH, PREVIEW_HEIGHT ) ) ); |
| SetMapMode( MapMode( MAP_PIXEL ) ); |
| // check for sane values |
| DrawBitmap( maPreviewRect.TopLeft(), maPreviewRect.GetSize(), |
| maPreviewBitmap ); |
| |
| mbDragDrawn = sal_False; |
| DrawDrag(); |
| |
| ModalDialog::Paint( rRect ); |
| } |
| |
| void SaneDlg::DisableOption() |
| { |
| maBoolCheckBox.Show( sal_False ); |
| maStringEdit.Show( sal_False ); |
| maNumericEdit.Show( sal_False ); |
| maQuantumRangeBox.Show( sal_False ); |
| maStringRangeBox.Show( sal_False ); |
| maButtonOption.Show( sal_False ); |
| maVectorBox.Show( sal_False ); |
| maVectorTxt.Show( sal_False ); |
| maOptionDescTxt.Show( sal_False ); |
| } |
| |
| void SaneDlg::EstablishBoolOption() |
| { |
| sal_Bool bSuccess, bValue; |
| |
| bSuccess = mrSane.GetOptionValue( mnCurrentOption, bValue ); |
| if( bSuccess ) |
| { |
| maOptionDescTxt.SetText( mrSane.GetOptionName( mnCurrentOption ) ); |
| maOptionDescTxt.Show( sal_True ); |
| maBoolCheckBox.Check( bValue ); |
| maBoolCheckBox.Show( sal_True ); |
| } |
| } |
| |
| void SaneDlg::EstablishStringOption() |
| { |
| sal_Bool bSuccess; |
| ByteString aValue; |
| |
| bSuccess = mrSane.GetOptionValue( mnCurrentOption, aValue ); |
| if( bSuccess ) |
| { |
| maOptionDescTxt.SetText( mrSane.GetOptionName( mnCurrentOption ) ); |
| maOptionDescTxt.Show( sal_True ); |
| maStringEdit.SetText( String( aValue, osl_getThreadTextEncoding() ) ); |
| maStringEdit.Show( sal_True ); |
| } |
| } |
| |
| void SaneDlg::EstablishStringRange() |
| { |
| const char** ppStrings = mrSane.GetStringConstraint( mnCurrentOption ); |
| maStringRangeBox.Clear(); |
| for( int i = 0; ppStrings[i] != 0; i++ ) |
| maStringRangeBox.InsertEntry( String( ppStrings[i], osl_getThreadTextEncoding() ) ); |
| ByteString aValue; |
| mrSane.GetOptionValue( mnCurrentOption, aValue ); |
| maStringRangeBox.SelectEntry( String( aValue, osl_getThreadTextEncoding() ) ); |
| maStringRangeBox.Show( sal_True ); |
| maOptionDescTxt.SetText( mrSane.GetOptionName( mnCurrentOption ) ); |
| maOptionDescTxt.Show( sal_True ); |
| } |
| |
| void SaneDlg::EstablishQuantumRange() |
| { |
| if( mpRange ) |
| { |
| delete [] mpRange; |
| mpRange = 0; |
| } |
| int nValues = mrSane.GetRange( mnCurrentOption, mpRange ); |
| if( nValues == 0 ) |
| { |
| mfMin = mpRange[ 0 ]; |
| mfMax = mpRange[ 1 ]; |
| delete [] mpRange; |
| mpRange = 0; |
| EstablishNumericOption(); |
| } |
| else if( nValues > 0 ) |
| { |
| char pBuf[ 256 ]; |
| maQuantumRangeBox.Clear(); |
| mfMin = mpRange[ 0 ]; |
| mfMax = mpRange[ nValues-1 ]; |
| for( int i = 0; i < nValues; i++ ) |
| { |
| sprintf( pBuf, "%g", mpRange[ i ] ); |
| maQuantumRangeBox.InsertEntry( String( pBuf, osl_getThreadTextEncoding() ) ); |
| } |
| double fValue; |
| if( mrSane.GetOptionValue( mnCurrentOption, fValue, mnCurrentElement ) ) |
| { |
| sprintf( pBuf, "%g", fValue ); |
| maQuantumRangeBox.SelectEntry( String( pBuf, osl_getThreadTextEncoding() ) ); |
| } |
| maQuantumRangeBox.Show( sal_True ); |
| String aText( mrSane.GetOptionName( mnCurrentOption ) ); |
| aText += ' '; |
| aText += mrSane.GetOptionUnitName( mnCurrentOption ); |
| maOptionDescTxt.SetText( aText ); |
| maOptionDescTxt.Show( sal_True ); |
| } |
| } |
| |
| void SaneDlg::EstablishNumericOption() |
| { |
| sal_Bool bSuccess; |
| double fValue; |
| |
| bSuccess = mrSane.GetOptionValue( mnCurrentOption, fValue ); |
| if( ! bSuccess ) |
| return; |
| |
| char pBuf[256]; |
| String aText( mrSane.GetOptionName( mnCurrentOption ) ); |
| aText += ' '; |
| aText += mrSane.GetOptionUnitName( mnCurrentOption ); |
| if( mfMin != mfMax ) |
| { |
| sprintf( pBuf, " < %g ; %g >", mfMin, mfMax ); |
| aText += String( pBuf, osl_getThreadTextEncoding() ); |
| } |
| maOptionDescTxt.SetText( aText ); |
| maOptionDescTxt.Show( sal_True ); |
| sprintf( pBuf, "%g", fValue ); |
| maNumericEdit.SetText( String( pBuf, osl_getThreadTextEncoding() ) ); |
| maNumericEdit.Show( sal_True ); |
| } |
| |
| void SaneDlg::EstablishButtonOption() |
| { |
| maOptionDescTxt.SetText( mrSane.GetOptionName( mnCurrentOption ) ); |
| maOptionDescTxt.Show( sal_True ); |
| maButtonOption.Show( sal_True ); |
| } |
| |
| #define RECT_SIZE_PIX 7 |
| |
| void SaneDlg::MouseMove( const MouseEvent& rMEvt ) |
| { |
| if( mbIsDragging ) |
| { |
| Point aMousePos = rMEvt.GetPosPixel(); |
| // move into valid area |
| Point aLogicPos = GetLogicPos( aMousePos ); |
| aMousePos = GetPixelPos( aLogicPos ); |
| switch( meDragDirection ) |
| { |
| case TopLeft: maTopLeft = aMousePos; break; |
| case Top: maTopLeft.Y() = aMousePos.Y(); break; |
| case TopRight: |
| maTopLeft.Y() = aMousePos.Y(); |
| maBottomRight.X() = aMousePos.X(); |
| break; |
| case Right: maBottomRight.X() = aMousePos.X(); break; |
| case BottomRight: maBottomRight = aMousePos; break; |
| case Bottom: maBottomRight.Y() = aMousePos.Y(); break; |
| case BottomLeft: |
| maTopLeft.X() = aMousePos.X(); |
| maBottomRight.Y() = aMousePos.Y(); |
| break; |
| case Left: maTopLeft.X() = aMousePos.X(); break; |
| default: break; |
| } |
| int nSwap; |
| if( maTopLeft.X() > maBottomRight.X() ) |
| { |
| nSwap = maTopLeft.X(); |
| maTopLeft.X() = maBottomRight.X(); |
| maBottomRight.X() = nSwap; |
| } |
| if( maTopLeft.Y() > maBottomRight.Y() ) |
| { |
| nSwap = maTopLeft.Y(); |
| maTopLeft.Y() = maBottomRight.Y(); |
| maBottomRight.Y() = nSwap; |
| } |
| DrawDrag(); |
| UpdateScanArea( sal_False ); |
| } |
| ModalDialog::MouseMove( rMEvt ); |
| } |
| |
| void SaneDlg::MouseButtonDown( const MouseEvent& rMEvt ) |
| { |
| Point aMousePixel = rMEvt.GetPosPixel(); |
| |
| if( ! mbIsDragging && mbDragEnable ) |
| { |
| int nMiddleX = ( maBottomRight.X() - maTopLeft.X() ) / 2 - RECT_SIZE_PIX/2 + maTopLeft.X(); |
| int nMiddleY = ( maBottomRight.Y() - maTopLeft.Y() ) / 2 - RECT_SIZE_PIX/2 + maTopLeft.Y(); |
| if( aMousePixel.Y() >= maTopLeft.Y() && |
| aMousePixel.Y() < maTopLeft.Y() + RECT_SIZE_PIX ) |
| { |
| if( aMousePixel.X() >= maTopLeft.X() && |
| aMousePixel.X() < maTopLeft.X() + RECT_SIZE_PIX ) |
| { |
| meDragDirection = TopLeft; |
| aMousePixel = maTopLeft; |
| mbIsDragging = sal_True; |
| } |
| else if( aMousePixel.X() >= nMiddleX && |
| aMousePixel.X() < nMiddleX + RECT_SIZE_PIX ) |
| { |
| meDragDirection = Top; |
| aMousePixel.Y() = maTopLeft.Y(); |
| mbIsDragging = sal_True; |
| } |
| else if( aMousePixel.X() > maBottomRight.X() - RECT_SIZE_PIX && |
| aMousePixel.X() <= maBottomRight.X() ) |
| { |
| meDragDirection = TopRight; |
| aMousePixel = Point( maBottomRight.X(), maTopLeft.Y() ); |
| mbIsDragging = sal_True; |
| } |
| } |
| else if( aMousePixel.Y() >= nMiddleY && |
| aMousePixel.Y() < nMiddleY + RECT_SIZE_PIX ) |
| { |
| if( aMousePixel.X() >= maTopLeft.X() && |
| aMousePixel.X() < maTopLeft.X() + RECT_SIZE_PIX ) |
| { |
| meDragDirection = Left; |
| aMousePixel.X() = maTopLeft.X(); |
| mbIsDragging = sal_True; |
| } |
| else if( aMousePixel.X() > maBottomRight.X() - RECT_SIZE_PIX && |
| aMousePixel.X() <= maBottomRight.X() ) |
| { |
| meDragDirection = Right; |
| aMousePixel.X() = maBottomRight.X(); |
| mbIsDragging = sal_True; |
| } |
| } |
| else if( aMousePixel.Y() <= maBottomRight.Y() && |
| aMousePixel.Y() > maBottomRight.Y() - RECT_SIZE_PIX ) |
| { |
| if( aMousePixel.X() >= maTopLeft.X() && |
| aMousePixel.X() < maTopLeft.X() + RECT_SIZE_PIX ) |
| { |
| meDragDirection = BottomLeft; |
| aMousePixel = Point( maTopLeft.X(), maBottomRight.Y() ); |
| mbIsDragging = sal_True; |
| } |
| else if( aMousePixel.X() >= nMiddleX && |
| aMousePixel.X() < nMiddleX + RECT_SIZE_PIX ) |
| { |
| meDragDirection = Bottom; |
| aMousePixel.Y() = maBottomRight.Y(); |
| mbIsDragging = sal_True; |
| } |
| else if( aMousePixel.X() > maBottomRight.X() - RECT_SIZE_PIX && |
| aMousePixel.X() <= maBottomRight.X() ) |
| { |
| meDragDirection = BottomRight; |
| aMousePixel = maBottomRight; |
| mbIsDragging = sal_True; |
| } |
| } |
| } |
| if( mbIsDragging ) |
| { |
| SetPointerPosPixel( aMousePixel ); |
| DrawDrag(); |
| } |
| ModalDialog::MouseButtonDown( rMEvt ); |
| } |
| |
| void SaneDlg::MouseButtonUp( const MouseEvent& rMEvt ) |
| { |
| if( mbIsDragging ) |
| { |
| UpdateScanArea( sal_True ); |
| } |
| mbIsDragging = sal_False; |
| |
| ModalDialog::MouseButtonUp( rMEvt ); |
| } |
| |
| void SaneDlg::DrawRectangles( Point& rUL, Point& rBR ) |
| { |
| int nMiddleX, nMiddleY; |
| Point aBL, aUR; |
| |
| aUR = Point( rBR.X(), rUL.Y() ); |
| aBL = Point( rUL.X(), rBR.Y() ); |
| nMiddleX = ( rBR.X() - rUL.X() ) / 2 + rUL.X(); |
| nMiddleY = ( rBR.Y() - rUL.Y() ) / 2 + rUL.Y(); |
| |
| DrawLine( rUL, aBL ); |
| DrawLine( aBL, rBR ); |
| DrawLine( rBR, aUR ); |
| DrawLine( aUR, rUL ); |
| DrawRect( Rectangle( rUL, Size( RECT_SIZE_PIX,RECT_SIZE_PIX ) ) ); |
| DrawRect( Rectangle( aBL, Size( RECT_SIZE_PIX, -RECT_SIZE_PIX ) ) ); |
| DrawRect( Rectangle( rBR, Size( -RECT_SIZE_PIX, -RECT_SIZE_PIX ) ) ); |
| DrawRect( Rectangle( aUR, Size( -RECT_SIZE_PIX, RECT_SIZE_PIX ) ) ); |
| DrawRect( Rectangle( Point( nMiddleX - RECT_SIZE_PIX/2, rUL.Y() ), Size( RECT_SIZE_PIX, RECT_SIZE_PIX ) ) ); |
| DrawRect( Rectangle( Point( nMiddleX - RECT_SIZE_PIX/2, rBR.Y() ), Size( RECT_SIZE_PIX, -RECT_SIZE_PIX ) ) ); |
| DrawRect( Rectangle( Point( rUL.X(), nMiddleY - RECT_SIZE_PIX/2 ), Size( RECT_SIZE_PIX, RECT_SIZE_PIX ) ) ); |
| DrawRect( Rectangle( Point( rBR.X(), nMiddleY - RECT_SIZE_PIX/2 ), Size( -RECT_SIZE_PIX, RECT_SIZE_PIX ) ) ); |
| } |
| |
| void SaneDlg::DrawDrag() |
| { |
| static Point aLastUL, aLastBR; |
| |
| if( ! mbDragEnable ) |
| return; |
| |
| RasterOp eROP = GetRasterOp(); |
| SetRasterOp( ROP_INVERT ); |
| SetMapMode( MapMode( MAP_PIXEL ) ); |
| |
| if( mbDragDrawn ) |
| DrawRectangles( aLastUL, aLastBR ); |
| |
| aLastUL = maTopLeft; |
| aLastBR = maBottomRight; |
| DrawRectangles( maTopLeft, maBottomRight ); |
| |
| mbDragDrawn = sal_True; |
| SetRasterOp( eROP ); |
| SetMapMode( maMapMode ); |
| } |
| |
| Point SaneDlg::GetPixelPos( const Point& rIn ) |
| { |
| Point aConvert( |
| ( ( rIn.X() * PREVIEW_WIDTH ) / |
| ( maMaxBottomRight.X() - maMinTopLeft.X() ) ) |
| + PREVIEW_UPPER_LEFT, |
| ( ( rIn.Y() * PREVIEW_HEIGHT ) |
| / ( maMaxBottomRight.Y() - maMinTopLeft.Y() ) ) |
| + PREVIEW_UPPER_TOP ); |
| |
| return LogicToPixel( aConvert, maMapMode ); |
| } |
| |
| Point SaneDlg::GetLogicPos( const Point& rIn ) |
| { |
| Point aConvert = PixelToLogic( rIn, maMapMode ); |
| aConvert.X() -= PREVIEW_UPPER_LEFT; |
| aConvert.Y() -= PREVIEW_UPPER_TOP; |
| if( aConvert.X() < 0 ) |
| aConvert.X() = 0; |
| if( aConvert.X() >= PREVIEW_WIDTH ) |
| aConvert.X() = PREVIEW_WIDTH-1; |
| if( aConvert.Y() < 0 ) |
| aConvert.Y() = 0; |
| if( aConvert.Y() >= PREVIEW_HEIGHT ) |
| aConvert.Y() = PREVIEW_HEIGHT-1; |
| |
| aConvert.X() *= ( maMaxBottomRight.X() - maMinTopLeft.X() ); |
| aConvert.X() /= PREVIEW_WIDTH; |
| aConvert.Y() *= ( maMaxBottomRight.Y() - maMinTopLeft.Y() ); |
| aConvert.Y() /= PREVIEW_HEIGHT; |
| return aConvert; |
| } |
| |
| void SaneDlg::UpdateScanArea( sal_Bool bSend ) |
| { |
| if( ! mbDragEnable ) |
| return; |
| |
| Point aUL = GetLogicPos( maTopLeft ); |
| Point aBR = GetLogicPos( maBottomRight ); |
| |
| maLeftField.SetValue( aUL.X() ); |
| maTopField.SetValue( aUL.Y() ); |
| maRightField.SetValue( aBR.X() ); |
| maBottomField.SetValue( aBR.Y() ); |
| |
| if( ! bSend ) |
| return; |
| |
| if( mrSane.IsOpen() ) |
| { |
| SetAdjustedNumericalValue( "tl-x", (double)aUL.X() ); |
| SetAdjustedNumericalValue( "tl-y", (double)aUL.Y() ); |
| SetAdjustedNumericalValue( "br-x", (double)aBR.X() ); |
| SetAdjustedNumericalValue( "br-y", (double)aBR.Y() ); |
| } |
| } |
| |
| sal_Bool SaneDlg::LoadState() |
| { |
| #ifdef USE_SAVE_STATE |
| int i; |
| |
| if( ! Sane::IsSane() ) |
| return sal_False; |
| |
| const char* pEnv = getenv("HOME"); |
| String aFileName( pEnv ? pEnv : "", osl_getThreadTextEncoding() ); |
| aFileName += String( RTL_CONSTASCII_USTRINGPARAM( "/.so_sane_state" ) ); |
| Config aConfig( aFileName ); |
| if( ! aConfig.HasGroup( "SANE" ) ) |
| return sal_False; |
| |
| aConfig.SetGroup( "SANE" ); |
| ByteString aString = aConfig.ReadKey( "SO_LastSaneDevice" ); |
| for( i = 0; i < Sane::CountDevices() && ! aString.Equals( ByteString( Sane::GetName( i ), osl_getThreadTextEncoding() ) ); i++ ) ; |
| if( i == Sane::CountDevices() ) |
| return sal_False; |
| |
| mrSane.Close(); |
| mrSane.Open( aString.GetBuffer() ); |
| |
| DisableOption(); |
| InitFields(); |
| |
| if( mrSane.IsOpen() ) |
| { |
| int iMax = aConfig.GetKeyCount(); |
| for( i = 0; i < iMax; i++ ) |
| { |
| aString = aConfig.GetKeyName( i ); |
| ByteString aValue = aConfig.ReadKey( i ); |
| int nOption = mrSane.GetOptionByName( aString.GetBuffer() ); |
| if( nOption != -1 ) |
| { |
| if( aValue.CompareTo( "BOOL=", 5 ) == COMPARE_EQUAL ) |
| { |
| aValue.Erase( 0, 5 ); |
| sal_Bool aBOOL = (sal_Bool)aValue.ToInt32(); |
| mrSane.SetOptionValue( nOption, aBOOL ); |
| } |
| else if( aValue.CompareTo( "STRING=", 7 ) == COMPARE_EQUAL ) |
| { |
| aValue.Erase( 0, 7 ); |
| mrSane.SetOptionValue( nOption, String( aValue, osl_getThreadTextEncoding() ) ); |
| } |
| else if( aValue.CompareTo( "NUMERIC=", 8 ) == COMPARE_EQUAL ) |
| { |
| aValue.Erase( 0, 8 ); |
| int nMax = aValue.GetTokenCount( ':' ); |
| double fValue=0.0; |
| for( int n = 0; n < nMax ; n++ ) |
| { |
| ByteString aSub = aValue.GetToken( n, ':' ); |
| sscanf( aSub.GetBuffer(), "%lg", &fValue ); |
| SetAdjustedNumericalValue( aString.GetBuffer(), fValue, n ); |
| } |
| } |
| } |
| } |
| } |
| |
| DisableOption(); |
| InitFields(); |
| |
| return sal_True; |
| #else |
| return sal_False; |
| #endif |
| } |
| |
| void SaneDlg::SaveState() |
| { |
| #ifdef USE_SAVE_STATE |
| if( ! Sane::IsSane() ) |
| return; |
| |
| const char* pEnv = getenv( "HOME" ); |
| String aFileName( pEnv ? pEnv : "", osl_getThreadTextEncoding() ); |
| aFileName.AppendAscii( "/.so_sane_state" ); |
| |
| Config aConfig( aFileName ); |
| aConfig.DeleteGroup( "SANE" ); |
| aConfig.SetGroup( "SANE" ); |
| aConfig.WriteKey( "SO_LastSANEDevice", ByteString( maDeviceBox.GetSelectEntry(), RTL_TEXTENCODING_UTF8 ) ); |
| |
| #ifdef SAVE_ALL_STATES |
| for( int i = 1; i < mrSane.CountOptions(); i++ ) |
| { |
| String aOption=mrSane.GetOptionName( i ); |
| SANE_Value_Type nType = mrSane.GetOptionType( i ); |
| switch( nType ) |
| { |
| case SANE_TYPE_BOOL: |
| { |
| sal_Bool bValue; |
| if( mrSane.GetOptionValue( i, bValue ) ) |
| { |
| ByteString aString( "BOOL=" ); |
| aString += (sal_uLong)bValue; |
| aConfig.WriteKey( aOption, aString ); |
| } |
| } |
| break; |
| case SANE_TYPE_STRING: |
| { |
| String aString( "STRING=" ); |
| String aValue; |
| if( mrSane.GetOptionValue( i, aValue ) ) |
| { |
| aString += aValue; |
| aConfig.WriteKey( aOption, aString ); |
| } |
| } |
| break; |
| case SANE_TYPE_FIXED: |
| case SANE_TYPE_INT: |
| { |
| String aString( "NUMERIC=" ); |
| double fValue; |
| char buf[256]; |
| for( int n = 0; n < mrSane.GetOptionElements( i ); n++ ) |
| { |
| if( ! mrSane.GetOptionValue( i, fValue, n ) ) |
| break; |
| if( n > 0 ) |
| aString += ":"; |
| sprintf( buf, "%lg", fValue ); |
| aString += buf; |
| } |
| if( n >= mrSane.GetOptionElements( i ) ) |
| aConfig.WriteKey( aOption, aString ); |
| } |
| break; |
| default: |
| break; |
| } |
| } |
| #else |
| static char const* pSaveOptions[] = { |
| "resolution", |
| "tl-x", |
| "tl-y", |
| "br-x", |
| "br-y" |
| }; |
| for( size_t i = 0; |
| i < (sizeof(pSaveOptions)/sizeof(pSaveOptions[0])); |
| i++ ) |
| { |
| ByteString aOption = pSaveOptions[i]; |
| int nOption = mrSane.GetOptionByName( pSaveOptions[i] ); |
| if( nOption > -1 ) |
| { |
| SANE_Value_Type nType = mrSane.GetOptionType( nOption ); |
| switch( nType ) |
| { |
| case SANE_TYPE_BOOL: |
| { |
| sal_Bool bValue; |
| if( mrSane.GetOptionValue( nOption, bValue ) ) |
| { |
| ByteString aString( "BOOL=" ); |
| aString += ByteString::CreateFromInt32(bValue); |
| aConfig.WriteKey( aOption, aString ); |
| } |
| } |
| break; |
| case SANE_TYPE_STRING: |
| { |
| ByteString aString( "STRING=" ); |
| ByteString aValue; |
| if( mrSane.GetOptionValue( nOption, aValue ) ) |
| { |
| aString += aValue; |
| aConfig.WriteKey( aOption, aString ); |
| } |
| } |
| break; |
| case SANE_TYPE_FIXED: |
| case SANE_TYPE_INT: |
| { |
| ByteString aString( "NUMERIC=" ); |
| double fValue; |
| char buf[256]; |
| int n; |
| |
| for( n = 0; n < mrSane.GetOptionElements( nOption ); n++ ) |
| { |
| if( ! mrSane.GetOptionValue( nOption, fValue, n ) ) |
| break; |
| if( n > 0 ) |
| aString += ":"; |
| sprintf( buf, "%lg", fValue ); |
| aString += buf; |
| } |
| if( n >= mrSane.GetOptionElements( nOption ) ) |
| aConfig.WriteKey( aOption, aString ); |
| } |
| break; |
| default: |
| break; |
| } |
| } |
| } |
| #endif |
| #endif |
| } |
| |
| sal_Bool SaneDlg::SetAdjustedNumericalValue( |
| const char* pOption, |
| double fValue, |
| int nElement ) |
| { |
| int nOption; |
| if( ! Sane::IsSane() || ! mrSane.IsOpen() || ( nOption = mrSane.GetOptionByName( pOption ) ) == -1 ) |
| return sal_False; |
| |
| if( nElement < 0 || nElement >= mrSane.GetOptionElements( nOption ) ) |
| return sal_False; |
| |
| double* pValues = NULL; |
| int nValues; |
| if( ( nValues = mrSane.GetRange( nOption, pValues ) ) < 0 ) |
| return sal_False; |
| |
| #if OSL_DEBUG_LEVEL > 1 |
| fprintf( stderr, "SaneDlg::SetAdjustedNumericalValue( \"%s\", %lg ) ", |
| pOption, fValue ); |
| #endif |
| |
| if( nValues ) |
| { |
| int nNearest = 0; |
| double fNearest = 1e6; |
| for( int i = 0; i < nValues; i++ ) |
| { |
| if( fabs( fValue - pValues[ i ] ) < fNearest ) |
| { |
| fNearest = fabs( fValue - pValues[ i ] ); |
| nNearest = i; |
| } |
| } |
| fValue = pValues[ nNearest ]; |
| } |
| else |
| { |
| if( fValue < pValues[0] ) |
| fValue = pValues[0]; |
| if( fValue > pValues[1] ) |
| fValue = pValues[1]; |
| } |
| delete [] pValues; |
| mrSane.SetOptionValue( nOption, fValue, nElement ); |
| #if OSL_DEBUG_LEVEL > 1 |
| fprintf( stderr, "yields %lg\n", fValue ); |
| #endif |
| |
| |
| return sal_True; |
| } |