diff options
Diffstat (limited to 'wizards/com/sun/star/wizards/ui/FilterComponent.java')
| -rw-r--r-- | wizards/com/sun/star/wizards/ui/FilterComponent.java | 953 |
1 files changed, 953 insertions, 0 deletions
diff --git a/wizards/com/sun/star/wizards/ui/FilterComponent.java b/wizards/com/sun/star/wizards/ui/FilterComponent.java new file mode 100644 index 000000000000..50b855ab3693 --- /dev/null +++ b/wizards/com/sun/star/wizards/ui/FilterComponent.java @@ -0,0 +1,953 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ +package com.sun.star.wizards.ui; + +// import java.util.Vector; +import com.sun.star.awt.TextEvent; +import com.sun.star.awt.VclWindowPeerAttribute; +import com.sun.star.awt.XControl; +import com.sun.star.awt.XListBox; +import com.sun.star.awt.XRadioButton; +import com.sun.star.beans.PropertyAttribute; +import com.sun.star.beans.PropertyValue; +import com.sun.star.beans.XPropertyContainer; +import com.sun.star.beans.XPropertySet; +import com.sun.star.lang.EventObject; +import com.sun.star.lang.IllegalArgumentException; +import com.sun.star.lang.XMultiServiceFactory; +import com.sun.star.sdb.SQLFilterOperator; +import com.sun.star.sdbc.DataType; +import com.sun.star.uno.Any; +import com.sun.star.uno.AnyConverter; +import com.sun.star.uno.Exception; +import com.sun.star.uno.Type; +import com.sun.star.uno.TypeClass; +import com.sun.star.uno.UnoRuntime; +import com.sun.star.uno.XInterface; +import com.sun.star.wizards.common.NumberFormatter; +import com.sun.star.wizards.common.Helper; +import com.sun.star.wizards.common.JavaTools; +import com.sun.star.wizards.db.FieldColumn; +import com.sun.star.wizards.db.QueryMetaData; +import com.sun.star.wizards.db.SQLQueryComposer; +import java.util.logging.Level; +import java.util.logging.Logger; + +public class FilterComponent +{ + + private Integer IStep; + private int RowCount; + private static String[] sLogicOperators; + private XRadioButton optMatchAny; + private String slblFieldNames; + private String slblOperators; + private String slblValue; + WizardDialog CurUnoDialog; + private int BaseID = 2300; + private String sIncSuffix; + private ControlRow[] oControlRows; + private String sDuplicateCondition; + final int SOOPTORMODE = 100; + final int SOOPTANDMODE = 101; + QueryMetaData oQueryMetaData; + int iDateTimeFormat; + int iDateFormat; + int iTimeFormat; + private PropertyValue[][] filterconditions; + private short curtabindex; + XMultiServiceFactory xMSF; + final int SO_FIRSTFIELDNAME = 1; + final int SO_SECONDFIELDNAME = 2; + final int SO_THIRDFIELDNAME = 3; + final int SO_FOURTHFIELDNAME = 4; + int[] SO_FIELDNAMELIST = new int[] + { + SO_FIRSTFIELDNAME, SO_SECONDFIELDNAME, SO_THIRDFIELDNAME, SO_FOURTHFIELDNAME + }; + final int SO_FIRSTCONDITION = 5; + final int SO_SECONDCONDITION = 6; + final int SO_THIRDCONDITION = 7; + final int SO_FOURTHCONDITION = 8; + int[] SO_CONDITIONLIST = new int[] + { + SO_FIRSTCONDITION, SO_SECONDCONDITION, SO_THIRDCONDITION, SO_FOURTHCONDITION + }; + final int SO_FIRSTTEXTFIELD = 1; + final int SO_SECONDTEXTFIELD = 2; + final int SO_THIRDTEXTFIELD = 3; + final int SO_FOURTHTEXTFIELD = 4; + int[] SO_TEXTFIELDLIST = new int[] + { + SO_FIRSTTEXTFIELD, SO_SECONDTEXTFIELD, SO_THIRDTEXTFIELD, SO_FOURTHTEXTFIELD + }; + final int SO_FIRSTBOOLFIELDNAME = 256 + 1; + final int SO_SECONDBOOLFIELDNAME = 256 + 2; + final int SO_THIRDBOOLFIELDNAME = 256 + 3; + final int SO_FOURTHBOOLFIELDNAME = 256 + 4; + int SO_BOOLEANLIST[] = + { + SO_FIRSTBOOLFIELDNAME, SO_SECONDBOOLFIELDNAME, SO_THIRDBOOLFIELDNAME, SO_FOURTHBOOLFIELDNAME + }; + final int SO_OPTQUERYMODE = 5; + int SOI_MATCHALL = 0; + int SOI_MATCHANY = 1; + int curHelpID; + + class ItemListenerImpl implements com.sun.star.awt.XItemListener + { + public void itemStateChanged(com.sun.star.awt.ItemEvent EventObject) + { + int iKey = CurUnoDialog.getControlKey(EventObject.Source, CurUnoDialog.ControlList); + String sControlName = ""; + switch (iKey) + { + case SO_FIRSTFIELDNAME: + case SO_SECONDFIELDNAME: + case SO_THIRDFIELDNAME: + case SO_FOURTHFIELDNAME: + sControlName = getControlName(EventObject.Source); + String sControlNameSuffix = sIncSuffix + "_" + getIndexNumber(sControlName); + XListBox xCurFieldListBox = (XListBox) UnoRuntime.queryInterface(XListBox.class, CurUnoDialog.xDlgContainer.getControl(sControlName)); + String CurDisplayFieldName = xCurFieldListBox.getSelectedItem(); + FieldColumn CurFieldColumn = new FieldColumn(oQueryMetaData, CurDisplayFieldName); + + String sControlNameTextValue = "txtValue" + sControlNameSuffix; + XControl xValueControl = CurUnoDialog.xDlgContainer.getControl(sControlNameTextValue); + XInterface xValueModel = (XInterface) UnoDialog.getModel(xValueControl); + Helper.setUnoPropertyValue(xValueModel, "TreatAsNumber", Boolean.valueOf(CurFieldColumn.isNumberFormat())); + final NumberFormatter aNumberFormatter = oQueryMetaData.getNumberFormatter(); + aNumberFormatter.setNumberFormat(xValueModel, CurFieldColumn.getDBFormatKey(), aNumberFormatter); + + break; + case SO_FIRSTCONDITION: + case SO_SECONDCONDITION: + case SO_THIRDCONDITION: + case SO_FOURTHCONDITION: + sControlName = getControlName(EventObject.Source); + break; + case SOOPTORMODE: + case SOOPTANDMODE: + return; + + case SO_FIRSTBOOLFIELDNAME: + case SO_SECONDBOOLFIELDNAME: + case SO_THIRDBOOLFIELDNAME: + case SO_FOURTHBOOLFIELDNAME: + sControlName = getControlName(EventObject.Source); + break; + + default: + break; + } + togglefollowingControlRow(sControlName); + } + + public void disposing(com.sun.star.lang.EventObject eventObject) + { + } + } + + class TextListenerImpl implements com.sun.star.awt.XTextListener + { + + public void textChanged(TextEvent EventObject) + { + String sName = getControlName(EventObject.Source); + togglefollowingControlRow(sName); + } + + public void disposing(EventObject eventObject) + { + } + + public void actionPerformed(com.sun.star.awt.ActionEvent actionEvent) + { + getfilterstate(); + } + } + + public static String getIndexNumber(String _sStr) + { + String sLastNumber = _sStr.substring(_sStr.length() - 1, _sStr.length()); + return sLastNumber; + } + + /** + * Enable the next ControlRow if the Condition is complete in the current line + * + * @param _scurName every control name ends with something like _1, _2, _3 this is the index number + * we try to interpret to check which line we currently use. (number - 1) + */ + private void togglefollowingControlRow(String _scurName) + { + // String sNameSuffix = sIncSuffix + "_" + _scurName.substring(_scurName.length() - 1, _scurName.length()); + int Index = Integer.valueOf(getIndexNumber(_scurName)).intValue(); + if (Index < oControlRows.length) + { + boolean bValue = oControlRows[Index - 1].isConditionComplete(); + oControlRows[Index].setEnabled(bValue); + } + } + + private String getControlName(Object _oSourceevent) + { + try + { + XControl xControl = (XControl) UnoRuntime.queryInterface(XControl.class, _oSourceevent); + XPropertySet xPSet = (XPropertySet) UnoRuntime.queryInterface(XPropertySet.class, xControl.getModel()); + final String sName = AnyConverter.toString(xPSet.getPropertyValue("Name")); + return sName; + } + catch (Exception e) + { + e.printStackTrace(System.out); + } + return ""; + } + + public PropertyValue[][] getFilterConditions() + { + // ControlRow CurControlRow; + // getfilterstate(); + int nFilterCount = getFilterCount(); + if (nFilterCount > 0) + { + final SQLQueryComposer composer = oQueryMetaData.getSQLQueryComposer(); + try + { + final String serviceName = "com.sun.star.beans.PropertyBag"; + final XPropertyContainer column = (XPropertyContainer) UnoRuntime.queryInterface(XPropertyContainer.class, oQueryMetaData.xMSF.createInstance(serviceName)); + + column.addProperty("Type", PropertyAttribute.BOUND, DataType.VARCHAR); + column.addProperty("Name", PropertyAttribute.BOUND, ""); + column.addProperty("Value", (short)( PropertyAttribute.MAYBEVOID | PropertyAttribute.REMOVABLE ), null ); + final XPropertySet columnSet = UnoRuntime.queryInterface(XPropertySet.class, column); + + if ( composer.getQuery().length() == 0) + { + final String fromClause = composer.getFromClause(); + StringBuilder sql = new StringBuilder(); + sql.append(composer.getSelectClause(true)); + sql.append(' '); + sql.append(fromClause); + composer.getQueryComposer().setElementaryQuery(sql.toString()); + } + composer.getQueryComposer().setStructuredFilter( new PropertyValue[][] {} ); + for (int i = 0; i < RowCount; i++) + { + ControlRow currentControlRow = oControlRows[i]; + if (currentControlRow.isEnabled()) + { + if (currentControlRow.isConditionComplete()) + { + String sFieldName = currentControlRow.getSelectedFieldName(); + int nOperator = (int) currentControlRow.getSelectedOperator(); + FieldColumn aFieldColumn = oQueryMetaData.getFieldColumnByDisplayName(sFieldName); + columnSet.setPropertyValue("Name", aFieldColumn.getFieldName()); + columnSet.setPropertyValue("Type", aFieldColumn.getXColumnPropertySet().getPropertyValue("Type")); + Object value = currentControlRow.getValue(); + switch(aFieldColumn.getFieldType()) + { + case DataType.TIMESTAMP: + case DataType.DATE: + value = ((Double)value) - oQueryMetaData.getNullDateCorrection(); + break; + } + column.removeProperty( "Value" ); + final short operator = currentControlRow.getSelectedOperator(); + if ( ( operator == SQLFilterOperator.SQLNULL ) + || ( operator == SQLFilterOperator.NOT_SQLNULL ) + || AnyConverter.isVoid( value ) + ) + { + column.addProperty("Value", (short)( PropertyAttribute.MAYBEVOID | PropertyAttribute.REMOVABLE ), new String() ); + value = new Any( new Type( TypeClass.VOID ), null ); + } + else + column.addProperty("Value", (short)( PropertyAttribute.MAYBEVOID | PropertyAttribute.REMOVABLE ), value ); + columnSet.setPropertyValue("Value", value); + composer.getQueryComposer().appendFilterByColumn(columnSet, getfilterstate() == this.SOI_MATCHALL,nOperator); + } + } + } + filterconditions = composer.getNormalizedStructuredFilter(); + int[] iduplicate = JavaTools.getDuplicateFieldIndex(filterconditions); + if (iduplicate[0] != -1) + { + PropertyValue aduplicatecondition = filterconditions[iduplicate[0]][iduplicate[1]]; + String smsgDuplicateCondition = getDisplayCondition(sDuplicateCondition, aduplicatecondition, null); + CurUnoDialog.showMessageBox("WarningBox", VclWindowPeerAttribute.OK, smsgDuplicateCondition); + CurUnoDialog.vetoableChange(new java.beans.PropertyChangeEvent(CurUnoDialog, "Steps", Integer.valueOf(1), Integer.valueOf(2))); + return new PropertyValue[][]{}; + } + } + catch (Exception ex) + { + Logger.getLogger(FilterComponent.class.getName()).log(Level.SEVERE, null, ex); + } + } + else + { + filterconditions = new PropertyValue[0][0]; + } + return filterconditions; + } + + public static String getDisplayCondition(String _BaseString, PropertyValue _filtercondition, QueryMetaData _CurDBMetaData) + { + try + { + String FieldName; + if (_CurDBMetaData != null) + { + FieldColumn CurDBFieldColumn = _CurDBMetaData.getFieldColumnByDisplayName(_filtercondition.Name); + FieldName = CurDBFieldColumn.getFieldTitle(); + } + else + { + FieldName = _filtercondition.Name; + } + String sreturn = JavaTools.replaceSubString(_BaseString, FieldName, "<FIELDNAME>"); + String soperator = sLogicOperators[_filtercondition.Handle - 1]; + sreturn = JavaTools.replaceSubString(sreturn, soperator, "<LOGICOPERATOR>"); + String sDisplayValue = ""; + if (!AnyConverter.isVoid(_filtercondition.Value)) + { + sDisplayValue = AnyConverter.toString(_filtercondition.Value); + } + sreturn = JavaTools.replaceSubString(sreturn, sDisplayValue, "<VALUE>"); + return sreturn; + } + catch (IllegalArgumentException e) + { + e.printStackTrace(System.out); + } + return ""; + } + + private int getfilterstate() + { + boolean bisany = true; + int ifilterstate = SOI_MATCHALL; + bisany = (this.optMatchAny.getState()) == true; + if (bisany) + { + ifilterstate = SOI_MATCHANY; + } + else + { + ifilterstate = SOI_MATCHALL; + } + return ifilterstate; + } + + private int getFilterCount() + { + int a = 0; + for (int i = 0; i < RowCount; i++) + { + if (oControlRows[i].isEnabled() && oControlRows[i].isConditionComplete()) + { + a++; + } + } + return a; + } + + /** Creates a new instance of FilterComponent + * @param CurUnoDialog + * @param _xMSF + * @param iStep + * @param iPosX + * @param iPosY + * @param iWidth + * @param FilterCount + * @param _oQueryMetaData + * @param _firstHelpID + */ + public FilterComponent(WizardDialog CurUnoDialog, XMultiServiceFactory _xMSF, int iStep, int iPosX, int iPosY, int iWidth, int FilterCount, QueryMetaData _oQueryMetaData, int _firstHelpID) + { + this.curHelpID = _firstHelpID; + this.xMSF = _xMSF; + this.IStep = Integer.valueOf(iStep); + + curtabindex = UnoDialog.setInitialTabindex(iStep); + this.CurUnoDialog = CurUnoDialog; + this.RowCount = FilterCount; + this.oQueryMetaData = _oQueryMetaData; + boolean bEnabled; + sIncSuffix = com.sun.star.wizards.common.Desktop.getIncrementSuffix(CurUnoDialog.getDlgNameAccess(), "optMatchAll"); + + String soptMatchAll = CurUnoDialog.m_oResource.getResText(BaseID + 9); + String soptMatchAny = CurUnoDialog.m_oResource.getResText(BaseID + 10); + slblFieldNames = CurUnoDialog.m_oResource.getResText(BaseID + 17); + slblOperators = CurUnoDialog.m_oResource.getResText(BaseID + 24); + slblValue = CurUnoDialog.m_oResource.getResText(BaseID + 25); + sLogicOperators = CurUnoDialog.m_oResource.getResArray(BaseID + 26, 10 /* 7 */); // =, <>, <, >, <=, >=, like, !like, is null, !is null + + sDuplicateCondition = CurUnoDialog.m_oResource.getResText(BaseID + 89); + + // create Radiobuttons + // * match all + // * match one + CurUnoDialog.insertRadioButton("optMatchAll" + sIncSuffix, SOOPTANDMODE, new ItemListenerImpl(), + new String[] + { + "Height", + "HelpURL", + "Label", + "PositionX", + "PositionY", + "State", + "Step", + "TabIndex", + "Width" + }, + new Object[] + { + Integer.valueOf(9), + "HID:" + curHelpID++, + soptMatchAll, + Integer.valueOf(iPosX), + Integer.valueOf(iPosY), + Short.valueOf((short) 1), + IStep, + Short.valueOf(curtabindex++), + Integer.valueOf(203) + }); + optMatchAny = CurUnoDialog.insertRadioButton("optMatchAny" + sIncSuffix, SOOPTORMODE, new ItemListenerImpl(), + new String[] + { + "Height", + "HelpURL", + "Label", + "PositionX", + "PositionY", + "Step", + "TabIndex", + "Width" + }, + new Object[] + { + Integer.valueOf(9), + "HID:" + curHelpID++, + soptMatchAny, + Integer.valueOf(iPosX), + Integer.valueOf(iPosY + 12), + IStep, + Short.valueOf(curtabindex++), + Integer.valueOf(203) + }); + getfilterstate(); + + oControlRows = new ControlRow[FilterCount]; + for (int i = 0; i < FilterCount; i++) + { + bEnabled = (i == 0); + oControlRows[i] = new ControlRow(iPosX, iPosY + 20, i, bEnabled, (this.curHelpID + (i * 3))); + iPosY += 43; + } + } + + public void initialize(PropertyValue[][] _filterconditions, String[] _fieldnames) + { + int i; + for (i = 0; i < RowCount; i++) + { + oControlRows[i].setFieldNames(_fieldnames); + // oControlRows[i].setFieldNames(aFieldNamesWithAdditionalEmpty); + } + this.filterconditions = _filterconditions; + PropertyValue[] curfilterconditions; + // int a; + if (_filterconditions.length == 1) + { + curfilterconditions = filterconditions[0]; + for (i = 0; i < curfilterconditions.length; i++) + { + oControlRows[i].setCondition(filterconditions[0][i]); + } + } + else + { + for (i = 0; i < filterconditions.length; i++) + { + oControlRows[i].setCondition(filterconditions[i][0]); + } + } + while (i < oControlRows.length) + { + oControlRows[i].settovoid(); + boolean bdoenable; + if (i > 0) + { + bdoenable = oControlRows[i - 1].isConditionComplete(); + } + else + { + bdoenable = true; + } + oControlRows[i].setEnabled(bdoenable); + i++; + } + } + + public void addNumberFormats() + { + iDateFormat = oQueryMetaData.getNumberFormatter().defineNumberFormat("YYYY-MM-DD"); + iTimeFormat = oQueryMetaData.getNumberFormatter().defineNumberFormat("HH:MM:SS"); + iDateTimeFormat = oQueryMetaData.getNumberFormatter().defineNumberFormat("YYYY-MM-DD HH:MM:SS"); + } + + // ------------------------------------------------------------------------- + // + // + // ------------------------------------------------------------------------- + final class ControlRow + { + private final static int SOLSTFIELDNAME = 3; + private final static int SOLSTOPERATOR = 4; + private final static int SOTXTVALUE = 5; + protected XInterface[] ControlElements = new XInterface[6]; + private boolean m_bEnabled; + String[] FieldNames; + + protected ControlRow(int iCompPosX, int iCompPosY, int Index, boolean _bEnabled, int _firstRowHelpID) + { + int nFieldWidth = 71; + int nOperatorWidth = 70; + int nValueWidth = 44; + + int nPosX1 = iCompPosX + 10; + int nPosX2 = iCompPosX + 10 + nFieldWidth + 6; // 87 + int nPosX3 = iCompPosX + 10 + nFieldWidth + 6 + nOperatorWidth + 6; + + + try + { + String sCompSuffix = sIncSuffix + "_" + String.valueOf(Index + 1); + m_bEnabled = _bEnabled; + + // Label Field + ControlElements[0] = (XInterface) CurUnoDialog.insertLabel("lblFieldNames" + sCompSuffix, + new String[] + { + "Enabled", + "Height", + "Label", + "PositionX", + "PositionY", + "Step", + "TabIndex", + "Width" + }, + new Object[] + { + Boolean.valueOf(isEnabled()), + Integer.valueOf(9), + slblFieldNames, + Integer.valueOf(nPosX1), + Integer.valueOf(iCompPosY + 13), + IStep, + Short.valueOf(curtabindex++), + Integer.valueOf(nFieldWidth) + }); + + // Label Operator + ControlElements[1] = (XInterface) CurUnoDialog.insertLabel("lblOperators" + sCompSuffix, + new String[] + { + "Enabled", + "Height", + "Label", + "PositionX", + "PositionY", + "Step", + "TabIndex", + "Width" + }, + new Object[] + { + Boolean.valueOf(isEnabled()), + Integer.valueOf(9), + slblOperators, + Integer.valueOf(nPosX2), + Integer.valueOf(iCompPosY + 13), + IStep, + Short.valueOf(curtabindex++), + Integer.valueOf(nOperatorWidth) + }); + + // Label Value + ControlElements[2] = (XInterface) CurUnoDialog.insertLabel("lblValue" + sCompSuffix, + new String[] + { + "Enabled", + "Height", + "Label", + "PositionX", + "PositionY", + "Step", + "TabIndex", + "Width" + }, + new Object[] + { + Boolean.valueOf(isEnabled()), + Integer.valueOf(9), + slblValue, + Integer.valueOf(nPosX3), + Integer.valueOf(iCompPosY + 13), + IStep, + Short.valueOf(curtabindex++), + Integer.valueOf(nValueWidth) + }); + + // Listbox Fields + ControlElements[SOLSTFIELDNAME] = (XInterface) CurUnoDialog.insertListBox("lstFieldName" + sCompSuffix, SO_FIELDNAMELIST[Index], null, new ItemListenerImpl(), + new String[] + { + "Enabled", + "Dropdown", + "Height", + "HelpURL", + "LineCount", + "PositionX", + "PositionY", + "Step", + "TabIndex", + "Width" + }, + new Object[] + { + Boolean.valueOf(isEnabled()), + Boolean.TRUE, + Integer.valueOf(13), + "HID:" + _firstRowHelpID++, + Short.valueOf(UnoDialog.getListBoxLineCount() /* 7 */), + Integer.valueOf(nPosX1), + Integer.valueOf(iCompPosY + 23), + IStep, + Short.valueOf(curtabindex++), + Integer.valueOf(nFieldWidth) + }); + + // Listbox Operators + ControlElements[SOLSTOPERATOR] = (XInterface) CurUnoDialog.insertListBox("lstOperator" + sCompSuffix, SO_CONDITIONLIST[Index], null, new ItemListenerImpl(), + new String[] + { + "Enabled", + "Dropdown", + "Height", + "HelpURL", + "LineCount", + "PositionX", + "PositionY", + "Step", + "StringItemList", + "TabIndex", + "Width" + }, + new Object[] + { + Boolean.valueOf(isEnabled()), + Boolean.TRUE, + Integer.valueOf(13), + "HID:" + _firstRowHelpID++, + Short.valueOf((short) sLogicOperators.length /* 7 */), + Integer.valueOf(nPosX2), + Integer.valueOf(iCompPosY + 23), + IStep, + sLogicOperators, + Short.valueOf(curtabindex++), + Integer.valueOf(nOperatorWidth) + }); + ControlElements[SOTXTVALUE] = (XInterface) CurUnoDialog.insertFormattedField("txtValue" + sCompSuffix, SO_TEXTFIELDLIST[Index], new TextListenerImpl(), + new String[] + { + "Enabled", + "Height", + "HelpURL", + "PositionX", + "PositionY", + "Step", + "TabIndex", + "Width" + }, + new Object[] + { + Boolean.valueOf(isEnabled()), + Integer.valueOf(13), + "HID:" + _firstRowHelpID++, + Integer.valueOf(nPosX3), + Integer.valueOf(iCompPosY + 23), + IStep, + Short.valueOf(curtabindex++), + Integer.valueOf(nValueWidth) + }); + } + catch (Exception exception) + { + exception.printStackTrace(System.out); + } + } + + /** + * @returns true if the current condition is complete, all needed fields are filled with values. + * So we can enable the next. + */ + boolean isConditionComplete() + { + try + { + short[] SelFields = (short[]) AnyConverter.toArray(Helper.getUnoPropertyValue(UnoDialog.getModel(ControlElements[SOLSTFIELDNAME]), "SelectedItems")); + if (SelFields.length > 0) + { + int nSelOperator = getSelectedOperator(); + // short[] SelOperator = (short[]) AnyConverter.toArray(Helper.getUnoPropertyValue(UnoDialog.getModel(ControlElements[SOLSTOPERATOR]), "SelectedItems")); + if (nSelOperator == com.sun.star.sdb.SQLFilterOperator.SQLNULL + || /* is null */ nSelOperator == com.sun.star.sdb.SQLFilterOperator.NOT_SQLNULL) /* is not null */ + + { + // disable value field + Helper.setUnoPropertyValue(UnoDialog.getModel(ControlElements[2]), "Enabled", Boolean.FALSE); + Helper.setUnoPropertyValue(UnoDialog.getModel(ControlElements[SOTXTVALUE]), "Enabled", Boolean.FALSE); + + return true; + } + else + { + // enable value field + Helper.setUnoPropertyValue(UnoDialog.getModel(ControlElements[2]), "Enabled", Boolean.TRUE); + Helper.setUnoPropertyValue(UnoDialog.getModel(ControlElements[SOTXTVALUE]), "Enabled", Boolean.TRUE); + } + if (nSelOperator != -1) + { + Object oValue = Helper.getUnoPropertyValue(UnoDialog.getModel(ControlElements[SOTXTVALUE]), "EffectiveValue"); + if (!AnyConverter.isVoid(oValue)) + { + String sValue = (String.valueOf(oValue)); + return (!sValue.equals("")); + } + } + } + return false; + } + catch (Exception exception) + { + exception.printStackTrace(System.out); + return false; + } + } + + protected void setCondition(PropertyValue _filtercondition) + { + try + { + XListBox xFieldsListBox = (XListBox) UnoRuntime.queryInterface(XListBox.class, ControlElements[SOLSTFIELDNAME]); + xFieldsListBox.selectItem(_filtercondition.Name, true); + XListBox xOperatorListBox = (XListBox) UnoRuntime.queryInterface(XListBox.class, ControlElements[SOLSTOPERATOR]); + xOperatorListBox.selectItemPos((short) (_filtercondition.Handle - 1), true); + + if (AnyConverter.isString(_filtercondition.Value)) + { + String sValue = AnyConverter.toString(_filtercondition.Value); + if (sValue.indexOf("{D '") > -1) + { + sValue = JavaTools.replaceSubString(sValue, "", "{D '"); + sValue = JavaTools.replaceSubString(sValue, "", "' }"); + try + { + oQueryMetaData.getNumberFormatter().convertStringToNumber(iDateFormat, sValue); + } + catch (java.lang.Exception ex) + { + Logger.getLogger(FilterComponent.class.getName()).log(Level.SEVERE, null, ex); + } + } + else if (sValue.indexOf("{T '") > -1) + { + sValue = JavaTools.replaceSubString(sValue, "", "{T '"); + sValue = JavaTools.replaceSubString(sValue, "", "' }"); + try + { + oQueryMetaData.getNumberFormatter().convertStringToNumber(iTimeFormat, sValue); + } + catch (java.lang.Exception ex) + { + Logger.getLogger(FilterComponent.class.getName()).log(Level.SEVERE, null, ex); + } + } + } + else if (AnyConverter.isBoolean(_filtercondition.Value)) + { + boolean b = AnyConverter.toBoolean(_filtercondition.Value); + double nValue = 0.0; + if (b) + { + nValue = 1.0; + } + Helper.setUnoPropertyValue(UnoDialog.getModel(ControlElements[SOTXTVALUE]), "EffectiveValue", nValue); + } + else + { + Helper.setUnoPropertyValue(UnoDialog.getModel(ControlElements[SOTXTVALUE]), "EffectiveValue", _filtercondition.Value); + } + } + catch (Exception e) + { + e.printStackTrace(System.out); + } + } + + protected void setFieldNames(String[] _FieldNames) + { + Helper.setUnoPropertyValue(UnoDialog.getModel(ControlElements[SOLSTFIELDNAME]), "StringItemList", _FieldNames); + FieldNames = _FieldNames; + } + + protected boolean isEnabled() + { + return m_bEnabled; + } + + private void settovoid() + { + WizardDialog.deselectListBox(ControlElements[SOLSTFIELDNAME]); + WizardDialog.deselectListBox(ControlElements[SOLSTOPERATOR]); + Helper.setUnoPropertyValue(UnoDialog.getModel(ControlElements[SOTXTVALUE]), "EffectiveValue", com.sun.star.uno.Any.VOID); + } + + private void setEnabled(boolean _bEnabled) + { + // enable all Controls Fieldname, operator, value + for (int i = 0; i < ControlElements.length; i++) + { + Helper.setUnoPropertyValue(UnoDialog.getModel(ControlElements[i]), "Enabled", Boolean.valueOf(_bEnabled)); + } + m_bEnabled = _bEnabled; + if (isEnabled()) + { + short[] iselected = new short[] + { + }; + try + { + iselected = (short[]) AnyConverter.toArray(Helper.getUnoPropertyValue(UnoDialog.getModel(ControlElements[SOLSTOPERATOR]), "SelectedItems")); + } + catch (Exception e) + { + e.printStackTrace(System.out); + } + if ((iselected.length) == 0) + { + Helper.setUnoPropertyValue(UnoDialog.getModel(ControlElements[SOLSTOPERATOR]), "SelectedItems", new short[] + { + 0 + }); + } + } + else if (!isConditionComplete()) + { + WizardDialog.deselectListBox(ControlElements[SOLSTOPERATOR]); + } + } + + protected String getSelectedFieldName() + { + try + { + short[] SelFields = (short[]) AnyConverter.toArray(Helper.getUnoPropertyValue(UnoDialog.getModel(ControlElements[SOLSTFIELDNAME]), "SelectedItems")); + return FieldNames[SelFields[0]]; + } + catch (Exception exception) + { + exception.printStackTrace(System.out); + } + return null; + } + + // TODO: check if it is really useful to match the indices of the listbox the API constants + // =, <>, <, >, <=, >=, like, !like, is null, !is null + protected short getSelectedOperator() + { + try + { + short[] SelFields = (short[]) AnyConverter.toArray(Helper.getUnoPropertyValue(UnoDialog.getModel(ControlElements[SOLSTOPERATOR]), "SelectedItems")); + switch (SelFields[0]) + { + case 0: + return com.sun.star.sdb.SQLFilterOperator.EQUAL; + case 1: + return com.sun.star.sdb.SQLFilterOperator.NOT_EQUAL; + case 2: + return com.sun.star.sdb.SQLFilterOperator.LESS; + case 3: + return com.sun.star.sdb.SQLFilterOperator.GREATER; + case 4: + return com.sun.star.sdb.SQLFilterOperator.LESS_EQUAL; + case 5: + return com.sun.star.sdb.SQLFilterOperator.GREATER_EQUAL; + case 6: + return com.sun.star.sdb.SQLFilterOperator.LIKE; + case 7: + return com.sun.star.sdb.SQLFilterOperator.NOT_LIKE; + case 8: + return com.sun.star.sdb.SQLFilterOperator.SQLNULL; + case 9: + return com.sun.star.sdb.SQLFilterOperator.NOT_SQLNULL; + default: + return -1; + } + } + catch (Exception exception) + { + exception.printStackTrace(System.out); + } + return -1; + } + + // TODO make a difference between Text and Numbers + protected Object getValue() + { + return (Helper.getUnoPropertyValue(UnoDialog.getModel(ControlElements[SOTXTVALUE]), "EffectiveValue")); + } + + protected Object getText() + { + return (Helper.getUnoPropertyValue(UnoDialog.getModel(ControlElements[SOTXTVALUE]), "Text")); + } + + protected String getDateTimeString(boolean bgetDate) + { + double dblValue = ((Double) getValue()).doubleValue(); + NumberFormatter oNumberFormatter = oQueryMetaData.getNumberFormatter(); + return oNumberFormatter.convertNumberToString(iDateTimeFormat, dblValue); + } + } +} |