Commits

Anonymous committed 4b3a3df

CWS-TOOLING: integrate CWS dba32c
2009-06-29 20:53:25 +0200 fs r273484 : #i103138# Rectangle conversion
2009-06-29 20:51:50 +0200 fs r273483 : #i103138# yet more refactoring, now also setting the proper zoom level at the proper point in time
2009-06-29 13:40:26 +0200 fs r273470 : added svn:ignore to ignore output paths
2009-06-29 10:08:54 +0200 fs r273455 : #i103138#
refactored the code for positioning/zooming the control
Basically, we now allow adjustControlGeometry_throw (formerly known as positionControl_throw and setControlZoom) to
take an additional ViewTransformation parameter, describing the transformation to obtain the actual
control position/size. Consequently, positionControl itself also allows for a ViewTransformation parameter.
This has become necessary since during painting, the device which we created our control for might not necessarily
have a proper MapMode set. In this case, if we would use this map mode for calculating the control's position/size,
this would lead to wrong results.
Note that this problem was introduced by the fix for #i101398#: During the fix, we postponed the control creation
to a later time (when it is really needed). At this later time, the MapMode at the device is broken, at the earlier
time where we formerly crearted the control (createPrimitive2DSequence), it is not yet broken.
Whether or not the MapMode is defined as "broken" might depend on one's point of view, however ...
I consider it broken, since:
- we need the map mode to obtain the proper zoom level, which is to be forwarded to the control
- there are scenarios where the MapMode is *not* set to MAP_PIXEL (in those scenarios, everything works
fine), and there are scenarios where it *is* set to MAP_PIXEL (in those the bug 103138 appears).
It somehow feels wrong that one cannot rely on the device's map mode this way, but on the other hand
one has no possibility to obtain the current zoom by other means.
Note that one issue (still to be submitted) is left: In the page pane of a Draw/Impress document, controls
have a wrong text size. This is because in this pane, the above-mentioned "broken" map mode is used,
which means the controls have a zoom of "1:1" set, which is wrong here.
2009-06-25 13:41:35 +0200 msc r273380 : #100000# the tabs changed die to new properties
2009-06-24 12:42:40 +0200 msc r273330 : #102082# remove issue warning
2009-06-22 10:43:14 +0200 fs r273201 : createPrimitive2DSequence: care for being disposed
2009-06-18 12:35:13 +0200 oj r273109 : #i102305# make nooptfiles for gcc
2009-06-17 12:14:37 +0200 oj r273056 : #i102305# fix for linux
2009-06-17 07:20:22 +0200 oj r273046 : #i102305# move ValueTransfer into the for loop to avoid a crash under Linux
2009-06-17 07:17:28 +0200 oj r273045 : #i102305# use varchar
2009-06-15 14:11:27 +0200 fs r272983 : added since tag
2009-06-15 12:11:39 +0200 oj r272973 : #i102305# SAL_DLLPUBLIC_EXPORT inserted
2009-06-15 11:08:53 +0200 fs r272969 : #i10000#
2009-06-15 09:25:13 +0200 fs r272963 : merging fix for P1 issue #i102701#
2009-06-11 11:31:24 +0200 fs r272858 : #i10000# copied the fix which before the rebase was done in ../dialog/macropg.src
2009-06-11 09:38:14 +0200 fs r272846 : CWS-TOOLING: rebase CWS dba32c to trunk@272827 (milestone: DEV300:m50)
2009-06-02 09:53:10 +0200 fs r272483 : #i10000#
2009-05-29 15:55:03 +0200 fs r272465 : #i100818#
2009-05-29 12:58:43 +0200 fs r272452 : don't apply comphelper::getString on possibly VOID any
2009-05-29 10:38:35 +0200 oj r272437 : #i101519# handle where condition
2009-05-29 09:53:39 +0200 fs r272434 : #i100818# call into releaseStubs /without/ locked GlobalMutex
2009-05-28 07:53:44 +0200 oj r272375 : #i101369# parse tree changed
2009-05-27 14:53:36 +0200 fs r272347 : #i10000#
2009-05-27 09:29:15 +0200 oj r272327 : #i101626# check for double before hard cast
2009-05-27 09:13:58 +0200 oj r272326 : #i101626# handle void correctly
2009-05-27 08:04:39 +0200 oj r272321 : #i102256# wrong method signature used
2009-05-27 07:55:52 +0200 oj r272320 : #i101519# look up parameter typ if used in function
2009-05-27 06:49:07 +0200 oj r272319 : #i101519# set parameter from rowset as well
2009-05-26 13:30:56 +0200 oj r272297 : #i101987# impl XBatchExecution
2009-05-26 12:44:34 +0200 oj r272293 : #i101700# check if group is not set
2009-05-26 12:16:53 +0200 oj r272290 : #i101369# resolved some reduce7reduce problems with boolean_term and search_condition
2009-05-26 12:12:42 +0200 oj r272289 : #i101369# fix for or on one line criteria
2009-05-25 16:02:25 +0200 fs r272257 : #i999704# +PROPERTY_MOUSE_WHEEL_BEHAVIOR
2009-05-25 16:01:55 +0200 fs r272256 : merging the changes from CWS dba32b herein
2009-05-25 15:49:57 +0200 fs r272254 : #i999704#
2009-05-25 15:32:57 +0200 fs r272252 : #i99704# grid columns also to respect the MouseWheelBehavior property
2009-05-25 15:23:43 +0200 fs r272251 : don't pass empty Anys to ::comphelper::getString
2009-05-25 14:48:43 +0200 fs r272248 : merged changes from CWS dba32b herein
2009-05-25 14:44:40 +0200 fs r272247 : #i99704# support new MouseWheelBehavior property
2009-05-25 14:43:18 +0200 fs r272246 : #i99704# WheelWithoutFocus (peer property) superseded by MouseWheelBehavior (model property)
2009-05-25 14:41:03 +0200 fs r272245 : #i99704# no need to set the mouse wheel behavior at the peer, this is now a model property, having the right default
2009-05-25 14:39:31 +0200 fs r272243 : removed dead import
2009-05-25 14:35:36 +0200 fs r272242 : the new EnableVisible doesn't make sense for grid columns
2009-05-25 14:34:33 +0200 fs r272241 : #i99704# +MouseWheelBehavior - allow to enable/disable the mouse wheel for the control, or make it focus-dependent
2009-05-25 14:26:11 +0200 fs r272240 : #i99704# change MouseSettings wheel flag (NoWheelActionWithoutFocus) to a three-state option, allowing to completely ignore the mouse wheel
2009-05-23 21:35:59 +0200 fs r272213 : localize 'sub component opened/closed' event
2009-05-22 21:42:47 +0200 fs r272211 : #i102003#
2009-05-22 21:42:20 +0200 fs r272210 : grammar
2009-05-22 21:36:10 +0200 fs r272209 : #i102140# load only once, not twice, and show error messages during loading (and during any form action, that is) asynchronously
2009-05-22 21:35:11 +0200 fs r272208 : #i102140# +clear
2009-05-22 14:50:30 +0200 fs r272194 : #i102139# for newly created DB docs, set the MacroExecutionMode to USE_CONFIG
2009-05-22 12:03:42 +0200 fs r272180 : #i88878#
provided by noel.power@novell.com
implement a visibility property (EnableVisible) for toolkit controls, and usage in forms and UNO dialogs
2009-05-15 15:37:31 +0200 fs r271942 : #i100671# corrected some @since tags, so autodoc has better chances of correctly reading them
2009-05-15 15:33:11 +0200 fs r271940 : don't call comphelper::getFOO for VOID values
2009-05-15 15:08:31 +0200 fs r271937 : includes
2009-05-15 13:39:22 +0200 fs r271934 : #i101398# createPrimitive2DSequence: when we already have a control, use the old code. In particular, call positionControlForPaint
2009-05-15 12:33:48 +0200 fs r271933 : make the geometry a part of the ControlPrimitive2D's identity
2009-05-15 10:15:44 +0200 fs r271928 : #i10000#
2009-05-14 20:55:38 +0200 fs r271921 : #i101398# don't reuse the name PRIMITIVE_ID_CONTROLPRIMITIVE2D, make the name of our own ControlPrimitive2D unique
2009-05-14 20:55:31 +0200 fs r271920 : #i101398# don't reuse the name PRIMITIVE_ID_CONTROLPRIMITIVE2D, make the name of our own ControlPrimitive2D unique
2009-05-14 20:23:23 +0200 fs r271919 : #i101622#
2009-05-14 16:04:38 +0200 fs r271898 : don't use comphelper::getInt32 on voids
2009-05-14 16:04:12 +0200 fs r271897 : merge fix for issue whose number just slipped my memory ... (originally fixed in CWS dba32b)
2009-05-14 15:36:55 +0200 fs r271895 : merging changes from DEV300:m48
2009-05-07 14:43:19 +0200 fs r271670 : #i101477#
2009-05-07 14:37:30 +0200 fs r271668 : #i101477#
2009-05-07 09:27:30 +0200 oj r271628 : #i101343# remove pch
2009-05-06 09:36:02 +0200 fs r271568 : getFoo: diagnostics
2009-05-04 09:23:06 +0200 oj r271438 : CWS-TOOLING: rebase CWS dba32c to trunk@271427 (milestone: DEV300:m47)
2009-04-29 23:18:13 +0200 fs r271394 : #i101398# use a dedicated 2DPrimitive for UNO Controls, which is able to provide the B2DRange *without* actually creating the control
2009-04-29 13:52:25 +0200 fs r271366 : #i101308#

Comments (0)

Files changed (138)

bridges/source/remote/urp/urp_environment.cxx

             pImpl->m_pReader = 0;
 		}
 
-        ::osl::MutexGuard guard2( ::osl::Mutex::getGlobalMutex() );
-        if( ! g_bStaticDestructorsCalled )
+        bool bReleaseStubs = false;
         {
-            // delete the stubs
+            ::osl::MutexGuard guard2( ::osl::Mutex::getGlobalMutex() );
+            bReleaseStubs = !g_bStaticDestructorsCalled;
+        }
+        if( bReleaseStubs )
+        {
             releaseStubs( pEnvRemote );
         }
 	}

comphelper/source/misc/types.cxx

 sal_Int32 getINT32(const Any& _rAny)
 {
 	sal_Int32 nReturn = 0;
-	_rAny >>= nReturn;
-
+	OSL_VERIFY( _rAny >>= nReturn );
 	return nReturn;
 }
 
 sal_Int16 getINT16(const Any& _rAny)
 {
 	sal_Int16 nReturn = 0;
-	_rAny >>= nReturn;
+	OSL_VERIFY( _rAny >>= nReturn );
 	return nReturn;
 }
 
 double getDouble(const Any& _rAny)
 {
 	double nReturn = 0.0;
-	_rAny >>= nReturn;
+	OSL_VERIFY( _rAny >>= nReturn );
 	return nReturn;
 }
 
 float getFloat(const Any& _rAny)
 {
 	float nReturn = 0.0;
-	_rAny >>= nReturn;
+	OSL_VERIFY( _rAny >>= nReturn );
 	return nReturn;
 }
 
 ::rtl::OUString	getString(const Any& _rAny)
 {
 	::rtl::OUString nReturn;
-	_rAny >>= nReturn;
+	OSL_VERIFY( _rAny >>= nReturn );
 	return nReturn;
 }
 

comphelper/source/streaming/memorystream.cxx

     if ( location > static_cast< sal_Int64 >( maData.size() ) )
         maData.resize( static_cast< sal_Int32 >( location ) );
 
+    if ( location > static_cast< sal_Int64 >( maData.size() ) )
+        maData.resize( static_cast< sal_Int32 >( location ) );
+
 	mnCursor = static_cast< sal_Int32 >( location );
 }
 

connectivity/inc/connectivity/dbexception.hxx

 
 	const ::com::sun::star::uno::Any& get() const { return m_aContent; }
 
+    void    clear()
+    {
+        m_aContent.clear();
+        m_eType = UNDEFINED;
+    }
+
 protected:
 	void implDetermineType();
 };

connectivity/inc/connectivity/sqlparse.hxx

 		// compares the _sFunctionName with all known function names and return the DataType of the return value
 		static sal_Int32 getFunctionReturnType(const ::rtl::OUString& _sFunctionName, const IParseContext* pContext = NULL);
 
-
+        // returns the type for a parameter in a given function name
+        static sal_Int32 getFunctionParameterType(sal_uInt32 _nTokenId,sal_uInt32 _nPos);
 
 		void error(sal_Char *fmt);
 		int SQLlex();

connectivity/source/drivers/dbase/DTable.cxx

         cType[0] = aDBFColumn.db_typ;
         cType[1] = 0;
         aTypeName = ::rtl::OUString::createFromAscii(cType);
+OSL_TRACE("column type: %c",aDBFColumn.db_typ);
 
 		switch (aDBFColumn.db_typ)
 		{
 			case 'C':
-				eType = DataType::CHAR;
+				eType = DataType::VARCHAR;
                 aTypeName = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("VARCHAR"));
 				break;
 			case 'F':

connectivity/source/drivers/file/FStatement.cxx

 				aColumnNameList.push_back(pCol->getTokenValue());
 			}
 		}
-		if(!aColumnNameList.size())
+		if ( aColumnNameList.empty() )
 			throwFunctionSequenceException(*this);
 
 		// Werte ...
 		if (! SQL_ISTOKEN(pValuesOrQuerySpec->getChild(0),VALUES))
 			throwFunctionSequenceException(*this);
 
-		OSL_ENSURE(pValuesOrQuerySpec->count() == 2,"OResultSet: pValuesOrQuerySpec->count() != 2");
+		OSL_ENSURE(pValuesOrQuerySpec->count() == 4,"OResultSet: pValuesOrQuerySpec->count() != 4");
 
 		// Liste von Werten
-		OSQLParseNode * pInsertAtomCommalist = pValuesOrQuerySpec->getChild(1);
+		OSQLParseNode * pInsertAtomCommalist = pValuesOrQuerySpec->getChild(2);
 		OSL_ENSURE(pInsertAtomCommalist != NULL,"OResultSet: pInsertAtomCommalist darf nicht NULL sein!");
 		OSL_ENSURE(pInsertAtomCommalist->count() > 0,"OResultSet: pInsertAtomCommalist <= 0");
 
 		for (sal_uInt32 i = 0; i < pInsertAtomCommalist->count(); i++)
 		{
 			pRow_Value_Const = pInsertAtomCommalist->getChild(i); // row_value_constructor
-			if(pRow_Value_Const->count() == 3)	// '(' row_value_const_list ')'
+			OSL_ENSURE(pRow_Value_Const != NULL,"OResultSet: pRow_Value_Const darf nicht NULL sein!");
+			if(SQL_ISRULE(pRow_Value_Const,parameter))
 			{
-				pRow_Value_Const = pRow_Value_Const->getChild(1); // row_value_const_list
-				OSL_ENSURE(pRow_Value_Const != NULL,"OResultSet: pRow_Value_Const darf nicht NULL sein!");
-				if(SQL_ISRULE(pRow_Value_Const,parameter))
-				{
-					if(pRow_Value_Const->count() == aColumnNameList.size())
-						ParseAssignValues(aColumnNameList,pRow_Value_Const,nIndex++); // kann nur ein Columnname vorhanden sein pro Schleife
-					else
-					{
-//						aStatus.Set(SQL_STAT_ERROR,
-//						String::CreateFromAscii("S1000"),
-//						aStatus.CreateErrorMessage(String(SdbResId(STR_STAT_SYNTAX_ERROR))),
-//						0, String() );
-						throwFunctionSequenceException(*this);
-					}
-				}
-				else if(pRow_Value_Const->isToken())
-					ParseAssignValues(aColumnNameList,pRow_Value_Const,static_cast<xub_StrLen>(i));
-				else
-				{
-					if(pRow_Value_Const->count() == aColumnNameList.size())
-					{
-						for (sal_uInt32 j = 0; j < pRow_Value_Const->count(); ++j)
-							ParseAssignValues(aColumnNameList,pRow_Value_Const->getChild(j),nIndex++);
-					}
-					else
-						throwFunctionSequenceException(*this);
-				}
+				ParseAssignValues(aColumnNameList,pRow_Value_Const,nIndex++); // kann nur ein Columnname vorhanden sein pro Schleife
 			}
+			else if(pRow_Value_Const->isToken())
+				ParseAssignValues(aColumnNameList,pRow_Value_Const,static_cast<xub_StrLen>(i));
 			else
 			{
-				//	aStatus.SetStatementTooComplex();
-				throwFunctionSequenceException(*this);
+				if(pRow_Value_Const->count() == aColumnNameList.size())
+				{
+					for (sal_uInt32 j = 0; j < pRow_Value_Const->count(); ++j)
+						ParseAssignValues(aColumnNameList,pRow_Value_Const->getChild(j),nIndex++);
+				}
+				else
+					throwFunctionSequenceException(*this);
 			}
 		}
 	}

connectivity/source/drivers/jdbc/DatabaseMetaData.cxx

     const ::rtl::OUString* _pOptionalAdditionalString )
 {
     bool bCatalog = _rCatalog.hasValue();
-    ::rtl::OUString sCatalog( ::comphelper::getString( _rCatalog ) );
+    ::rtl::OUString sCatalog;
+    _rCatalog >>= sCatalog;
 
     bool bSchema = _rSchemaPattern.toChar() != '%';
 

connectivity/source/drivers/jdbc/ResultSet.cxx

     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "jdbc", "Ocke.Janssen@sun.com", "java_sql_ResultSet::getLong" );
     static jmethodID mID(NULL);
     jlong (JNIEnv::*pCallMethod)( jobject obj, jmethodID methodID, ... ) = &JNIEnv::CallLongMethod;
-    return callMethodWithIntArg<jlong>(pCallMethod,"getLong","(I)L",mID,columnIndex);
+    return callMethodWithIntArg<jlong>(pCallMethod,"getLong","(I)J",mID,columnIndex);
 }
 // -------------------------------------------------------------------------
 

connectivity/source/parse/sqlbison.y

 							     const connectivity::SQLNodeType eNodeType,
 								 const sal_uInt32 nNodeID = 0)
 {
-
+    OSL_TRACE("connectivity: Rule Number: %d,%d",eNodeType,nNodeID);
 	return new connectivity::OSQLInternalNode(pNewValue, eNodeType, nNodeID);
 }
 
 							    const connectivity::SQLNodeType eNodeType,
 								const sal_uInt32 nNodeID = 0)
 {
-
+    OSL_TRACE("connectivity: Rule Number: %d,%d",eNodeType,nNodeID);
 	return new connectivity::OSQLInternalNode(_NewValue, eNodeType, nNodeID);
 }
 
 							    const connectivity::SQLNodeType eNodeType,
 								const sal_uInt32 nNodeID = 0)
 {
-
+    OSL_TRACE("connectivity: Rule Number: %d,%d",eNodeType,nNodeID);
 	return new connectivity::OSQLInternalNode(_NewValue, eNodeType, nNodeID);
 }
 
 	;
 ***/
 
-/*sql:
-		{$$ = SQL_NEW_LISTRULE;}
-	;
-*/
 sql_not:
 	{$$ = SQL_NEW_RULE;}
 	|	SQL_TOKEN_NOT
 	;
-	/* manipulative statements */
+
+/* manipulative statements */
 
 sql:    manipulative_statement
 	;
 			$$->append($5);}
 	;
 values_or_query_spec:
-		SQL_TOKEN_VALUES table_value_const_list
+		SQL_TOKEN_VALUES '(' table_value_const_list ')'
 		{$$ = SQL_NEW_RULE;
 			$$->append($1);
-			$$->append($2);
+			$$->append($2 = newNode("(", SQL_NODE_PUNCTUATION));
+			$$->append($3);
+			$$->append($4 = newNode(")", SQL_NODE_PUNCTUATION));
 		}
 	;
 
 	;
 row_value_constructor:
 			row_value_constructor_elem
-	  |		'(' row_value_const_list ')'
+/*	  |		'(' row_value_const_list ')'
 			{
 				$$ = SQL_NEW_RULE;
 				$$->append($1 = newNode("(", SQL_NODE_PUNCTUATION));
 				$$->append($2);
 				$$->append($3 = newNode(")", SQL_NODE_PUNCTUATION));
 			}
-/*      |		subquery
-			{
-				$$ = SQL_NEW_RULE;
-				$$->append($1);
-			}*/
+			*/
 	;
 row_value_constructor_elem:
 			value_exp /*[^')']*/
 	  ;
 boolean_primary:
 		predicate
-	  | '(' search_condition ')'
-		{
+	|   '(' search_condition ')'
+		{ // boolean_primary: rule 2
 			$$ = SQL_NEW_RULE;
 			$$->append($1 = newNode("(", SQL_NODE_PUNCTUATION));
 			$$->append($2);
 			$$->append($3 = newNode(")", SQL_NODE_PUNCTUATION));
 		}
-	;
-
-boolean_test:
-		boolean_primary
-	|	boolean_primary SQL_TOKEN_IS sql_not truth_value
-		{
-			$$ = SQL_NEW_RULE;
-			$$->append($1);
-			$$->append($2);
-			$$->append($3);
-			$$->append($4);
-		}
-	;
-boolean_factor:
-		boolean_test
-	|	SQL_TOKEN_NOT boolean_test
-		{
-			$$ = SQL_NEW_RULE;
-			$$->append($1);
-			$$->append($2);
-		}
-	;
-boolean_term:
-		boolean_factor
-	|	boolean_term SQL_TOKEN_AND boolean_factor
-		{
-			$$ = SQL_NEW_RULE;
-			$$->append($1);
-			$$->append($2);
-			$$->append($3);
-		}
 	|	row_value_constructor_elem  /*[^')' ',']*/
 		{
-    		if(xxx_pGLOBAL_SQLPARSER->inPredicateCheck())
+    		if(xxx_pGLOBAL_SQLPARSER->inPredicateCheck())// boolean_primary: rule 3
 			{
 			    $$ = SQL_NEW_RULE;
 			    sal_Int16 nErg = xxx_pGLOBAL_SQLPARSER->buildComparsionRule($$,$1);
 			else
 				YYERROR;
 		}
-	|	boolean_term SQL_TOKEN_AND literal
+	;
+
+boolean_test:
+		boolean_primary
+	|	boolean_primary SQL_TOKEN_IS sql_not truth_value
 		{
-		    if(xxx_pGLOBAL_SQLPARSER->inPredicateCheck())
-			{
-			    $$ = SQL_NEW_RULE;
-			    $$->append($1);
-			    $$->append($2);
-			    sal_Int16 nErg = xxx_pGLOBAL_SQLPARSER->buildComparsionRule($$,$3);
-			    if(nErg < 1)
-			    {
-				    delete $$;
-				    if(nErg)
-					    YYERROR;
-				    else
-					    YYABORT;
-			    }
-			}
-			else
-			    YYERROR;
-
+			$$ = SQL_NEW_RULE;
+			$$->append($1);
+			$$->append($2);
+			$$->append($3);
+			$$->append($4);
 		}
-	|	boolean_term SQL_TOKEN_AND SQL_TOKEN_STRING
+	;
+boolean_factor:
+        boolean_test
+	|   SQL_TOKEN_NOT boolean_test
+		{ // boolean_factor: rule 1
+		    $$ = SQL_NEW_RULE;
+		    $$->append($1);
+		    $$->append($2);
+		}
+	;
+boolean_term:
+		boolean_factor
+	|	boolean_term SQL_TOKEN_AND boolean_factor
 		{
-		    if(xxx_pGLOBAL_SQLPARSER->inPredicateCheck())
-			{
-			    $$ = SQL_NEW_RULE;
-			    $$->append($1);
-			    $$->append($2);
-			    sal_Int16 nErg = xxx_pGLOBAL_SQLPARSER->buildComparsionRule($$,$3);
-			    if(nErg < 1)
-			    {
-				    delete $$;
-				    if(nErg)
-					    YYERROR;
-				    else
-					    YYABORT;
-			    }
-			}
-			else
-			    YYERROR;
-
+			$$ = SQL_NEW_RULE; // boolean_term: rule 1
+			$$->append($1);
+			$$->append($2);
+			$$->append($3);
 		}
 	;
 search_condition:
 		boolean_term
 	|	search_condition SQL_TOKEN_OR boolean_term
 		{
-			$$ = SQL_NEW_RULE;
+			$$ = SQL_NEW_RULE; // search_condition
 			$$->append($1);
 			$$->append($2);
 			$$->append($3);
 comparison_predicate:
 		row_value_constructor comparison row_value_constructor
 		{
-			$$ = SQL_NEW_RULE;
+			$$ = SQL_NEW_RULE; // comparison_predicate: rule 1
 			$$->append($1);
 			$$->append($2);
 			$$->append($3);
 		}
 	|	comparison row_value_constructor
 		{
-			if(xxx_pGLOBAL_SQLPARSER->inPredicateCheck())
+			if(xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) // comparison_predicate: rule 2
 			{
 				$$ = SQL_NEW_RULE;
 				sal_Int16 nErg = xxx_pGLOBAL_SQLPARSER->buildPredicateRule($$,$2,$1);
 	;
 between_predicate:
 		row_value_constructor sql_not SQL_TOKEN_BETWEEN row_value_constructor SQL_TOKEN_AND row_value_constructor
-		{$$ = SQL_NEW_RULE;
+		{$$ = SQL_NEW_RULE; // between_predicate: rule 1
 			$$->append($1);
 			$$->append($2);
 			$$->append($3);
 		}
 	|	sql_not SQL_TOKEN_BETWEEN row_value_constructor SQL_TOKEN_AND row_value_constructor
 		{
-			if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck())
+			if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) // between_predicate: rule 2 
 			{
 				$$ = SQL_NEW_RULE;
 				
 like_predicate:
 		row_value_constructor SQL_TOKEN_NOT SQL_TOKEN_LIKE string_value_exp opt_escape
 		{
-			$$ = SQL_NEW_RULE;
+			$$ = SQL_NEW_RULE; // like_predicate: rule 1
 			$$->append($1);
 			$$->append($2);
 			$$->append($3);
 		}
 	|	row_value_constructor SQL_TOKEN_LIKE string_value_exp opt_escape
 		{
-			$$ = SQL_NEW_RULE;
+			$$ = SQL_NEW_RULE; // like_predicate: rule 2
 			$$->append($1);
 			$$->append($2);
 			$$->append($3);
 		}
 	|	row_value_constructor SQL_TOKEN_NOT SQL_TOKEN_LIKE value_exp_primary opt_escape
 		{
-			$$ = SQL_NEW_RULE;
+			$$ = SQL_NEW_RULE;  // like_predicate: rule 3
 			$$->append($1);
 			$$->append($2);
 			$$->append($3);
 		}
 	|	row_value_constructor SQL_TOKEN_LIKE value_exp_primary opt_escape
 		{
-			$$ = SQL_NEW_RULE;
+			$$ = SQL_NEW_RULE;  // like_predicate: rule 4
 			$$->append($1);
 			$$->append($2);
 			$$->append($3);
 		}
 	|	sql_not SQL_TOKEN_LIKE string_value_exp opt_escape
 		{
-			if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck())
+			if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck())  // like_predicate: rule 5
 			{
 				OSQLParseNode* pColumnRef = newNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::column_ref));
 				pColumnRef->append(newNode(xxx_pGLOBAL_SQLPARSER->getFieldName(),SQL_NODE_NAME));
 		}
 	|	sql_not SQL_TOKEN_LIKE value_exp_primary opt_escape
 		{
-			if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck())
+			if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) // like_predicate: rule 6
 			{
 				OSQLParseNode* pColumnRef = newNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::column_ref));
 				pColumnRef->append(newNode(xxx_pGLOBAL_SQLPARSER->getFieldName(),SQL_NODE_NAME));
 test_for_null:
 		row_value_constructor SQL_TOKEN_IS sql_not truth_value
 		{
-			$$ = SQL_NEW_RULE;
+			$$ = SQL_NEW_RULE; // test_for_null: rule 1
 			$$->append($1);
 			$$->append($2);
 			$$->append($3);
 		}
 	|	SQL_TOKEN_IS sql_not truth_value
 		{
-			if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck())
+			if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck())// test_for_null: rule 2
 			{
 				OSQLParseNode* pColumnRef = newNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::column_ref));
 				pColumnRef->append(newNode(xxx_pGLOBAL_SQLPARSER->getFieldName(),SQL_NODE_NAME));
 in_predicate:
 		row_value_constructor sql_not SQL_TOKEN_IN in_predicate_value
 		{
-			$$ = SQL_NEW_RULE;
+			$$ = SQL_NEW_RULE;// in_predicate: rule 1
 			$$->append($1);
 			$$->append($2);
 			$$->append($3);
 			$$->append($4);
 		}
-		|	sql_not SQL_TOKEN_IN in_predicate_value
+	|	sql_not SQL_TOKEN_IN in_predicate_value
 		{
-			if ( xxx_pGLOBAL_SQLPARSER->inPredicateCheck() )
+			if ( xxx_pGLOBAL_SQLPARSER->inPredicateCheck() )// in_predicate: rule 2
 			{
 				OSQLParseNode* pColumnRef = newNode(aEmptyString, SQL_NODE_RULE,OSQLParser::RuleID(OSQLParseNode::column_ref));
 				pColumnRef->append(newNode(xxx_pGLOBAL_SQLPARSER->getFieldName(),SQL_NODE_NAME));
 sql:
 		search_condition /* checking predicats */
 		{
-			if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck())
+			if (xxx_pGLOBAL_SQLPARSER->inPredicateCheck()) // sql: rule 1
 			{
 				$$ = $1;
 				if ( SQL_ISRULE($$,search_condition) )
 			}
 			else
 				YYERROR;
-		};
+		}
+	|   '(' sql ')' /* checking predicats */
+    ;
 %%
 
 

connectivity/source/parse/sqliterator.cxx

 		}
 		if ( bNotFound )
 		{
+            sal_Int32 nType = DataType::VARCHAR;
+            OSQLParseNode* pParent = _pColumnRef ? _pColumnRef->getParent() : NULL;
+            if ( pParent && (SQL_ISRULE(pParent,general_set_fct) || SQL_ISRULE(pParent,set_fct_spec)) )
+            {
+                const sal_uInt32 nCount = _pColumnRef->count();
+                sal_uInt32 i = 0;
+                for(; i < nCount;++i)
+                {
+                    if ( _pColumnRef->getChild(i) == _pParseNode )
+                        break;
+                }
+                nType = ::connectivity::OSQLParser::getFunctionParameterType( pParent->getChild(0)->getTokenID(), i+1);
+            }
+
 			::rtl::OUString aNewColName( getUniqueColumnName( sParameterName ) );
 
 			OParseColumn* pColumn = new OParseColumn(aNewColName,
 													ColumnValue::NULLABLE_UNKNOWN,
 													0,
 													0,
-													DataType::VARCHAR,
+													nType,
 													sal_False,
 													sal_False,
 													isCaseSensitive() );

connectivity/source/parse/sqlnode.cxx

 
     return nType;
 }
+// -----------------------------------------------------------------------------
+sal_Int32 OSQLParser::getFunctionParameterType(sal_uInt32 _nTokenId, sal_uInt32 _nPos)
+{
+    sal_Int32 nType = DataType::VARCHAR;
+
+    if(_nTokenId == SQL_TOKEN_CHAR)                 nType = DataType::INTEGER;
+    else if(_nTokenId == SQL_TOKEN_INSERT)
+    {
+        if ( _nPos == 2 || _nPos == 3 )
+            nType = DataType::INTEGER;
+    }
+    else if(_nTokenId == SQL_TOKEN_LEFT)
+    {
+        if ( _nPos == 2 )
+            nType = DataType::INTEGER;
+    }
+    else if(_nTokenId == SQL_TOKEN_LOCATE)
+    {
+        if ( _nPos == 3 )
+            nType = DataType::INTEGER;
+    }
+    else if(_nTokenId == SQL_TOKEN_LOCATE_2)
+    {
+        if ( _nPos == 3 )
+            nType = DataType::INTEGER;
+    }
+    else if( _nTokenId == SQL_TOKEN_REPEAT || _nTokenId == SQL_TOKEN_RIGHT )
+    {
+        if ( _nPos == 2 )
+            nType = DataType::INTEGER;
+    }
+    else if(_nTokenId == SQL_TOKEN_SPACE )
+    {
+        nType = DataType::INTEGER;
+    }
+    else if(_nTokenId == SQL_TOKEN_SUBSTRING)
+    {
+        if ( _nPos != 1 )
+            nType = DataType::INTEGER;
+    }
+    else if(_nTokenId == SQL_TOKEN_DATEDIFF)
+    {
+        if ( _nPos != 1 )
+            nType = DataType::TIMESTAMP;
+    }
+    else if(_nTokenId == SQL_TOKEN_DATEVALUE)
+        nType = DataType::DATE;
+    else if(_nTokenId == SQL_TOKEN_DAYNAME)
+        nType = DataType::DATE;
+    else if(_nTokenId == SQL_TOKEN_DAYOFMONTH)
+        nType = DataType::DATE;
+    else if(_nTokenId == SQL_TOKEN_DAYOFWEEK)
+        nType = DataType::DATE;
+    else if(_nTokenId == SQL_TOKEN_DAYOFYEAR)
+        nType = DataType::DATE;
+    else if(_nTokenId == SQL_TOKEN_EXTRACT)              nType = DataType::VARCHAR;
+    else if(_nTokenId == SQL_TOKEN_HOUR)                 nType = DataType::TIME;
+    else if(_nTokenId == SQL_TOKEN_MINUTE)               nType = DataType::TIME;
+    else if(_nTokenId == SQL_TOKEN_MONTH)                nType = DataType::DATE;
+    else if(_nTokenId == SQL_TOKEN_MONTHNAME)            nType = DataType::DATE;
+    else if(_nTokenId == SQL_TOKEN_NOW)                  nType = DataType::TIMESTAMP;
+    else if(_nTokenId == SQL_TOKEN_QUARTER)              nType = DataType::DATE;
+    else if(_nTokenId == SQL_TOKEN_SECOND)               nType = DataType::TIME;
+    else if(_nTokenId == SQL_TOKEN_TIMESTAMPADD)         nType = DataType::TIMESTAMP;
+    else if(_nTokenId == SQL_TOKEN_TIMESTAMPDIFF)        nType = DataType::TIMESTAMP;
+    else if(_nTokenId == SQL_TOKEN_TIMEVALUE)            nType = DataType::TIMESTAMP;
+    else if(_nTokenId == SQL_TOKEN_WEEK)                 nType = DataType::DATE;
+    else if(_nTokenId == SQL_TOKEN_YEAR)                 nType = DataType::DATE;
+
+    else if(_nTokenId == SQL_TOKEN_ABS)                  nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_ACOS)                 nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_ASIN)                 nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_ATAN)                 nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_ATAN2)                nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_CEILING)              nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_COS)                  nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_COT)                  nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_DEGREES)              nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_EXP)                  nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_FLOOR)                nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_LOGF)                 nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_LOG)                  nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_LOG10)                nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_LN)                   nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_MOD)                  nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_PI)                   nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_POWER)                nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_RADIANS)              nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_RAND)                 nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_ROUND)                nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_ROUNDMAGIC)           nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_SIGN)                 nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_SIN)                  nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_SQRT)                 nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_TAN)                  nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_TRUNCATE)             nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_COUNT)                nType = DataType::INTEGER;
+    else if(_nTokenId == SQL_TOKEN_MAX)                  nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_MIN)                  nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_AVG)                  nType = DataType::DOUBLE;
+    else if(_nTokenId == SQL_TOKEN_SUM)                  nType = DataType::DOUBLE;
+
+    else if(_nTokenId == SQL_TOKEN_LOWER)                nType = DataType::VARCHAR;
+    else if(_nTokenId == SQL_TOKEN_UPPER)                nType = DataType::VARCHAR;
+
+    return nType;
+}
 
 // -----------------------------------------------------------------------------
 const SQLError& OSQLParser::getErrorHelper() const

connectivity/source/resource/conn_shared_res.src

 };
 String STR_QUERY_INVALID_LIKE_COLUMN
 {
-    Text [ en-US ] = "The query can not be executed. The 'LIKE' can only be used with a column name.";
+    Text [ en-US ] = "The query can not be executed. You cannot use 'LIKE' with columns of this type.";
 };
 String STR_QUERY_INVALID_LIKE_STRING
 {
-    Text [ en-US ] = "The query can not be executed. The 'LIKE' can only be used with a string argument.";
+    Text [ en-US ] = "The query can not be executed. 'LIKE' can be used with a string argument only.";
 };
 String STR_QUERY_NOT_LIKE_TOO_COMPLEX
 {
-    Text [ en-US ] = "The query can not be executed. The 'NOT LIKE' is too complex.";
+    Text [ en-US ] = "The query can not be executed. The 'NOT LIKE' condition is too complex.";
 };
 String STR_QUERY_LIKE_WILDCARD
 {
-    Text [ en-US ] = "The query can not be executed. The 'LIKE' statement contains wildcard in the middle.";
+    Text [ en-US ] = "The query can not be executed. The 'LIKE' condition contains wildcard in the middle.";
 };
 String STR_QUERY_LIKE_WILDCARD_MANY
 {
-    Text [ en-US ] = "The query can not be executed. The 'LIKE' statement contains too many wildcards.";
+    Text [ en-US ] = "The query can not be executed. The 'LIKE' condition contains too many wildcards.";
 };
 String STR_INVALID_COLUMNNAME
 {

dbaccess/qa/complex/dbaccess/DatabaseDocument.java

 import com.sun.star.document.XDocumentEventListener;
 import com.sun.star.document.XEmbeddedScripts;
 import com.sun.star.document.XEventsSupplier;
-import com.sun.star.document.XScriptInvocationContext;
 import com.sun.star.frame.DoubleInitializationException;
 import com.sun.star.lang.XComponent;
 import com.sun.star.frame.XComponentLoader;

dbaccess/source/core/api/KeySet.cxx

 OKeySet::OKeySet(const connectivity::OSQLTable& _xTable,
                  const Reference< XIndexAccess>& _xTableKeys,
 				 const ::rtl::OUString& _rUpdateTableName,	  // this can be the alias or the full qualified name
-				 const Reference< XSingleSelectQueryAnalyzer >& _xComposer)
-            :m_pKeyColumnNames(NULL)
+				 const Reference< XSingleSelectQueryAnalyzer >& _xComposer,
+                 const ORowSetValueVector& _aParameterValueForCache)
+            :m_aParameterValueForCache(_aParameterValueForCache)
+            ,m_pKeyColumnNames(NULL)
 			,m_pColumnNames(NULL)
             ,m_pForeignColumnNames(NULL)
 			,m_xTable(_xTable)
 				break;
 			}
 		}
-	}
+	} // if ( aSeq.getLength() > 1 ) // special handling for join
+    const ::rtl::OUString sOldFilter = xAnalyzer->getFilter();
+    if ( sOldFilter.getLength() )
+    {
+        aFilter = sOldFilter + aAnd + aFilter;
+    }
     xAnalyzer->setFilter(aFilter.makeStringAndClear());
 	m_xStatement = m_xConnection->prepareStatement(xAnalyzer->getQueryWithSubstitution());
 	::comphelper::disposeComponent(xAnalyzer);
 	OSL_ENSURE(xParameter.is(),"No Parameter interface!");
 	xParameter->clearParameters();
 	sal_Int32 nPos=1;
+    connectivity::ORowVector< ORowSetValue >::Vector::const_iterator aParaIter = m_aParameterValueForCache.get().begin();
+    connectivity::ORowVector< ORowSetValue >::Vector::const_iterator aParaEnd = m_aParameterValueForCache.get().end();
+    for(++aParaIter;aParaIter != aParaEnd;++aParaIter,++nPos)
+    {
+        ::dbtools::setObjectWithInfo( xParameter, nPos, aParaIter->makeAny(), aParaIter->getTypeKind() );
+    }
 	connectivity::ORowVector< ORowSetValue >::Vector::const_iterator aIter = m_aKeyIter->second.first->get().begin();
 	SelectColumnsMetaData::const_iterator aPosIter = (*m_pKeyColumnNames).begin();
     SelectColumnsMetaData::const_iterator aPosEnd = (*m_pKeyColumnNames).end();

dbaccess/source/core/api/KeySet.hxx

 		
 		::std::vector< ::rtl::OUString >						m_aAutoColumns;	 // contains all columns which are autoincrement ones
 
+        ORowSetValueVector                                      m_aParameterValueForCache;
         SelectColumnsMetaData*                                  m_pKeyColumnNames;      // contains all key column names
         SelectColumnsMetaData*                                  m_pColumnNames;         // contains all column names
         SelectColumnsMetaData*                                  m_pForeignColumnNames;  // contains all column names of the rest
 		OKeySet(const connectivity::OSQLTable& _xTable,
                 const ::com::sun::star::uno::Reference< ::com::sun::star::container::XIndexAccess>& _xTableKeys,
 				const ::rtl::OUString& _rUpdateTableName,
-				const ::com::sun::star::uno::Reference< ::com::sun::star::sdb::XSingleSelectQueryAnalyzer >& _xComposer);
+				const ::com::sun::star::uno::Reference< ::com::sun::star::sdb::XSingleSelectQueryAnalyzer >& _xComposer,
+                const ORowSetValueVector& _aParameterValueForCache);
 		
 		// late ctor which can throw exceptions
 		virtual void construct(const ::com::sun::star::uno::Reference< ::com::sun::star::sdbc::XResultSet>& _xDriverSet);

dbaccess/source/core/api/RowSet.cxx

 			// this exception doesn't matter here because when we catch an exception
 			// then the driver doesn't support this feature
 		}
-
+        m_aParameterValueForCache.get().resize(1);
 		Reference< XParameters > xParam( m_xStatement, UNO_QUERY_THROW );
         size_t nParamCount( m_pParameters.is() ? m_pParameters->size() : m_aPrematureParamValues.get().size() );
         for ( size_t i=1; i<=nParamCount; ++i )
         {
             ORowSetValue& rParamValue( getParameterStorage( (sal_Int32)i ) );
             ::dbtools::setObjectWithInfo( xParam, i, rParamValue.makeAny(), rParamValue.getTypeKind() );
+            m_aParameterValueForCache.get().push_back(rParamValue);
         }
 
 		xResultSet = m_xStatement->executeQuery();
 
         {
             RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "frank.schoenheit@sun.com", "ORowSet::execute_NoApprove_NoNewConn: creating cache" );
-            m_pCache = new ORowSetCache( xResultSet, m_xComposer.get(), m_aContext, aComposedUpdateTableName, m_bModified, m_bNew );
+            m_pCache = new ORowSetCache( xResultSet, m_xComposer.get(), m_aContext, aComposedUpdateTableName, m_bModified, m_bNew,m_aParameterValueForCache );
             if ( m_nResultSetConcurrency == ResultSetConcurrency::READ_ONLY )
             {
                 m_nPrivileges = Privilege::SELECT;

dbaccess/source/core/api/RowSet.hxx

             (since we have not been executed, yet)
         */
         ORowSetValueVector                          m_aPrematureParamValues;
+        ORowSetValueVector                          m_aParameterValueForCache;
         ::std::bit_vector                           m_aParametersSet;
 
 		::cppu::OInterfaceContainerHelper			m_aRowsetListeners;

dbaccess/source/core/api/RowSetCache.cxx

                            const ::comphelper::ComponentContext& _rContext,
 						   const ::rtl::OUString& _rUpdateTableName,
 						   sal_Bool&	_bModified,
-						   sal_Bool&	_bNew)
+						   sal_Bool&	_bNew,
+                           const ORowSetValueVector& _aParameterValueForCache)
 	:m_xSet(_xRs)
 	,m_xMetaData(Reference< XResultSetMetaDataSupplier >(_xRs,UNO_QUERY)->getMetaData())
 	,m_aContext( _rContext )
-	,m_pCacheSet(NULL)
+    ,m_pCacheSet(NULL)
 	,m_pMatrix(NULL)
 	,m_pInsertMatrix(NULL)
     ,m_nLastColumnIndex(0)
 				}
 			}
 
-			OKeySet* pKeySet = new OKeySet(m_aUpdateTable,xUpdateTableKeys,aUpdateTableName ,_xAnalyzer);
+			OKeySet* pKeySet = new OKeySet(m_aUpdateTable,xUpdateTableKeys,aUpdateTableName ,_xAnalyzer,_aParameterValueForCache);
 			try
 			{
 				m_pCacheSet = pKeySet;

dbaccess/source/core/api/RowSetCache.hxx

 					 const ::comphelper::ComponentContext& _rContext,
 					 const ::rtl::OUString& _rUpdateTableName,
 					 sal_Bool&	_bModified,
-					 sal_Bool&	_bNew);
+					 sal_Bool&	_bNew,
+                     const ORowSetValueVector& _aParameterValueForCache);
 		~ORowSetCache();
 
 

dbaccess/source/core/api/statement.cxx

 						   ::getCppuType( (const Reference< XWarningsSupplier > *)0 ),
 						   ::getCppuType( (const Reference< XCloseable > *)0 ),
 						   ::getCppuType( (const Reference< XMultipleResults > *)0 ),
-						   ::getCppuType( (const Reference< XPreparedBatchExecution > *)0 ),
 						   ::getCppuType( (const Reference< ::com::sun::star::util::XCancellable > *)0 ),
 							OSubComponent::getTypes() );
 	Reference< XGeneratedResultSet > xGRes(m_xAggregateAsSet, UNO_QUERY);
 	if ( xGRes.is() )
 		aTypes = OTypeCollection(::getCppuType( (const Reference< XGeneratedResultSet > *)0 ),aTypes.getTypes());
+    Reference< XPreparedBatchExecution > xPreparedBatchExecution(m_xAggregateAsSet, UNO_QUERY);
+	if ( xPreparedBatchExecution.is() )
+		aTypes = OTypeCollection(::getCppuType( (const Reference< XPreparedBatchExecution > *)0 ),aTypes.getTypes());
 
 	return aTypes.getTypes();
 }
 					static_cast< XPropertySet * >( this ),
 					static_cast< XWarningsSupplier * >( this ),
 					static_cast< XCloseable * >( this ),
-					static_cast< XPreparedBatchExecution * >( this ),
 					static_cast< XMultipleResults * >( this ),
 					static_cast< ::com::sun::star::util::XCancellable * >( this ));
 		if ( !aIface.hasValue() )
 			Reference< XGeneratedResultSet > xGRes(m_xAggregateAsSet, UNO_QUERY);
 			if ( ::getCppuType( (const Reference< XGeneratedResultSet > *)0 ) == rType && xGRes.is() )
 				aIface = ::cppu::queryInterface(rType,static_cast< XGeneratedResultSet * >( this ));
+		} // if ( !aIface.hasValue() )
+        if ( !aIface.hasValue() )
+		{
+			Reference< XPreparedBatchExecution > xGRes(m_xAggregateAsSet, UNO_QUERY);
+			if ( ::getCppuType( (const Reference< XPreparedBatchExecution > *)0 ) == rType && xGRes.is() )
+				aIface = ::cppu::queryInterface(rType,static_cast< XPreparedBatchExecution * >( this ));
 		}
 	}
 	return aIface;
     ::rtl::OUString sSQL( impl_doEscapeProcessing_nothrow( _rSQL ) );
 	return m_xAggregateStatement->execute( sSQL );
 }
+//------------------------------------------------------------------------------
+void OStatement::addBatch( const rtl::OUString& _rSQL ) throw( SQLException, RuntimeException )
+{
+    RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OStatement::execute" );
+	MutexGuard aGuard(m_aMutex);
+	::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
+
+    // first check the meta data
+	Reference<XDatabaseMetaData> xMeta = Reference< XConnection > (m_xParent, UNO_QUERY)->getMetaData();
+	if (!xMeta.is() && !xMeta->supportsBatchUpdates())
+		throwFunctionSequenceException(*this);
+
+    ::rtl::OUString sSQL( impl_doEscapeProcessing_nothrow( _rSQL ) );
+	Reference< XBatchExecution >(m_xAggregateAsSet, UNO_QUERY)->addBatch( sSQL );
+}
+//------------------------------------------------------------------------------
+void OStatement::clearBatch( ) throw( SQLException, RuntimeException )
+{
+    RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OStatement::execute" );
+	MutexGuard aGuard(m_aMutex);
+	::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
+    // first check the meta data
+	Reference<XDatabaseMetaData> xMeta = Reference< XConnection > (m_xParent, UNO_QUERY)->getMetaData();
+	if (!xMeta.is() && !xMeta->supportsBatchUpdates())
+		throwFunctionSequenceException(*this);
+
+	Reference< XBatchExecution >(m_xAggregateAsSet, UNO_QUERY)->clearBatch();
+}
+//------------------------------------------------------------------------------
+Sequence< sal_Int32 > OStatement::executeBatch( ) throw( SQLException, RuntimeException )
+{
+    RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaccess", "Ocke.Janssen@sun.com", "OStatement::execute" );
+	MutexGuard aGuard(m_aMutex);
+	::connectivity::checkDisposed(OComponentHelper::rBHelper.bDisposed);
+    // first check the meta data
+	Reference<XDatabaseMetaData> xMeta = Reference< XConnection > (m_xParent, UNO_QUERY)->getMetaData();
+	if (!xMeta.is() && !xMeta->supportsBatchUpdates())
+		throwFunctionSequenceException(*this);
+	return Reference< XBatchExecution >(m_xAggregateAsSet, UNO_QUERY)->executeBatch( );
+}
 
 //------------------------------------------------------------------------------
 Reference< XConnection > OStatement::getConnection(void) throw( SQLException, RuntimeException )

dbaccess/source/core/inc/statement.hxx

 #ifndef _COM_SUN_STAR_SDBC_XPREPAREDBATCHEXECUTION_HDL_
 #include <com/sun/star/sdbc/XPreparedBatchExecution.hpp>
 #endif
+#include <com/sun/star/sdbc/XBatchExecution.hpp>
 #ifndef _COM_SUN_STAR_SDBC_XGENERATEDRESULTSET_HPP_
 #include <com/sun/star/sdbc/XGeneratedResultSet.hpp>
 #endif
 #ifndef _COMPHELPER_BROADCASTHELPER_HXX_
 #include <comphelper/broadcasthelper.hxx>
 #endif
-#ifndef _CPPUHELPER_IMPLBASE2_HXX_
-#include <cppuhelper/implbase2.hxx>
-#endif
+
+#include <cppuhelper/implbase3.hxx>
 
 //************************************************************
 //  OStatementBase
 //************************************************************
 //  OStatement
 //************************************************************
-typedef ::cppu::ImplHelper2 <   ::com::sun::star::sdbc::XStatement
+typedef ::cppu::ImplHelper3 <   ::com::sun::star::sdbc::XStatement
                             ,   ::com::sun::star::lang::XServiceInfo
+                            ,   ::com::sun::star::sdbc::XBatchExecution
                             >   OStatement_IFACE;
 class OStatement    :public OStatementBase
                     ,public OStatement_IFACE
     // OComponentHelper
 	virtual void SAL_CALL disposing();
 
+    // XBatchExecution
+	virtual void SAL_CALL addBatch( const ::rtl::OUString& sql ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+	virtual void SAL_CALL clearBatch(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+	virtual ::com::sun::star::uno::Sequence< sal_Int32 > SAL_CALL executeBatch(  ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::uno::RuntimeException);
+
+    using OStatementBase::addBatch;
+
 private:
     /** does escape processing for the given SQL command, if the our EscapeProcessing
         property allows so.

dbaccess/source/inc/dbustrings.hrc

 	DECLARE_CONSTASCII_USTRING(PROPERTY_DEFAULTCONTROL);
 	DECLARE_CONSTASCII_USTRING(PROPERTY_TABSTOP);
 	DECLARE_CONSTASCII_USTRING(PROPERTY_ENABLED);
+	DECLARE_CONSTASCII_USTRING(PROPERTY_MOUSE_WHEEL_BEHAVIOR);
 }
 
 #endif // DBACCESS_SHARED_DBUSTRINGS_HRC

dbaccess/source/shared/dbustrings.cxx

 	IMPLEMENT_CONSTASCII_USTRING(PROPERTY_TABSTOP, "TabStop");
 	IMPLEMENT_CONSTASCII_USTRING(PROPERTY_DEFAULTCONTROL, "DefaultControl");
 	IMPLEMENT_CONSTASCII_USTRING(PROPERTY_ENABLED, "Enabled");
+	IMPLEMENT_CONSTASCII_USTRING(PROPERTY_MOUSE_WHEEL_BEHAVIOR, "MouseWheelBehavior");
 }

dbaccess/source/ui/browser/brwctrlr.cxx

 	:SbaXDataBrowserController_Base(_rM)
     ,m_pClipbordNotifier( NULL )
 	,m_aAsyncGetCellFocus(LINK(this, SbaXDataBrowserController, OnAsyncGetCellFocus))
+    ,m_aAsyncDisplayError( LINK( this, SbaXDataBrowserController, OnAsyncDisplayError ) )
 	,m_sStateSaveRecord(ModuleRes(RID_STR_SAVE_CURRENT_RECORD))
 	,m_sStateUndoRecord(ModuleRes(RID_STR_UNDO_MODIFY_RECORD))
     ,m_sModuleIdentifier( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.sdb.DataSourceBrowser" ) ) )
 	,m_nFormActionNestingLevel(0)
 	,m_bLoadCanceled( sal_False )
     ,m_bClosingKillOpen( sal_False )
-	,m_bErrorOccured( sal_False )
     ,m_bCannotSelectUnfiltered( true )
 {
     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaui", "Ocke.Janssen@sun.com", "SbaXDataBrowserController::SbaXDataBrowserController" );
         }
     }
 
-	return _rxLoadable->isLoaded() && !errorOccured();
+	return _rxLoadable->isLoaded();
 }
 
 // -----------------------------------------------------------------------------
 	DBG_ASSERT(m_nPendingLoadFinished == 0, "SbaXDataBrowserController::suspend : there shouldn't be a pending load !");
 
 	m_aAsyncGetCellFocus.CancelCall();
+    m_aAsyncDisplayError.CancelCall();
 	m_aAsyncInvalidateAll.CancelCall();
 
 	sal_Bool bSuccess = SaveModified();
 }
 
 //------------------------------------------------------------------------------
+IMPL_LINK( SbaXDataBrowserController, OnAsyncDisplayError, void*, /* _pNotInterestedIn */ )
+{
+    OSQLMessageBox aDlg( getBrowserView(), m_aCurrentError );
+    aDlg.Execute();
+    return 0L;
+}
+
+//------------------------------------------------------------------------------
 void SbaXDataBrowserController::errorOccured(const ::com::sun::star::sdb::SQLErrorEvent& aEvent) throw( RuntimeException )
 {
     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaui", "Ocke.Janssen@sun.com", "SbaXDataBrowserController::errorOccured" );
-	SQLExceptionInfo aInfo(aEvent.Reason);
-	if ( aInfo.isValid() )
-	{
-		::vos::OGuard aGuard(Application::GetSolarMutex());
-        showError( aInfo );
-	}
-	if (m_nFormActionNestingLevel)
-		m_bErrorOccured = true;
+    ::osl::MutexGuard aGuard( getMutex() );
+
+    SQLExceptionInfo aInfo( aEvent.Reason );
+	if ( !aInfo.isValid() )
+        return;
+
+    if ( m_nFormActionNestingLevel )
+    {
+        OSL_ENSURE( !m_aCurrentError.isValid(), "SbaXDataBrowserController::errorOccured: can handle one error per transaction only!" );
+        m_aCurrentError = aInfo;
+    }
+    else
+        m_aAsyncDisplayError.Call();
 }
 
 //------------------------------------------------------------------------------
 //------------------------------------------------------------------------------
 void SbaXDataBrowserController::enterFormAction()
 {
-    RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaui", "Ocke.Janssen@sun.com", "SbaXDataBrowserController::enterFormAction" );
-	if (!m_nFormActionNestingLevel)
-		// first action -> reset flag
-		m_bErrorOccured = false;
+	if ( !m_nFormActionNestingLevel )
+		// first action -> reset
+        m_aCurrentError.clear();
 
 	++m_nFormActionNestingLevel;
 }
 //------------------------------------------------------------------------------
 void SbaXDataBrowserController::leaveFormAction()
 {
-    RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbaui", "Ocke.Janssen@sun.com", "SbaXDataBrowserController::leaveFormAction" );
-	DBG_ASSERT(m_nFormActionNestingLevel > 0, "SbaXDataBrowserController::leaveFormAction : invalid call !");
-	--m_nFormActionNestingLevel;
+	DBG_ASSERT( m_nFormActionNestingLevel > 0, "SbaXDataBrowserController::leaveFormAction : invalid call !" );
+	if ( --m_nFormActionNestingLevel > 0 )
+        return;
+
+    if ( !m_aCurrentError.isValid() )
+        return;
+
+    m_aAsyncDisplayError.Call();
 }
 
 // -------------------------------------------------------------------------

dbaccess/source/ui/browser/unodatbr.cxx

 
 /** === begin UNO includes === **/
 #include <com/sun/star/awt/LineEndFormat.hpp>
+#include <com/sun/star/awt/LineEndFormat.hpp>
+#include <com/sun/star/awt/MouseWheelBehavior.hpp>
 #include <com/sun/star/awt/TextAlign.hpp>
 #include <com/sun/star/awt/VisualEffect.hpp>
 #include <com/sun/star/beans/NamedValue.hpp>
                 aCopyProperties.push_back( PROPERTY_WIDTH );
 
                 // help text to display for the column
-                Any aDescription; aDescription <<= ::rtl::OUString();
+                Any aDescription;
 				if ( xColPSI->hasPropertyByName( PROPERTY_HELPTEXT ) )
-                    aDescription <<= ::comphelper::getString( xColumn->getPropertyValue( PROPERTY_HELPTEXT ) );
+                    aDescription = xColumn->getPropertyValue( PROPERTY_HELPTEXT );
+                if ( !aDescription.hasValue() )
+                    aDescription <<= ::rtl::OUString();
                 aInitialValues.push_back( NamedValue( PROPERTY_HELPTEXT, aDescription ) );
 
 				// ... horizontal justify
-                aInitialValues.push_back( NamedValue( PROPERTY_ALIGN, makeAny( sal_Int16( ::comphelper::getINT32( xColumn->getPropertyValue( PROPERTY_ALIGN ) ) ) ) ) );
+                Any aAlign; aAlign <<= sal_Int16( 0 );
+                Any aColAlign( xColumn->getPropertyValue( PROPERTY_ALIGN ) );
+                if ( aColAlign.hasValue() )
+                    aAlign <<= sal_Int16( ::comphelper::getINT32( aColAlign ) );
+                aInitialValues.push_back( NamedValue( PROPERTY_ALIGN, aAlign ) );
+
+                // don't allow the mouse to scroll in the cells
+				if ( xGridColPSI->hasPropertyByName( PROPERTY_MOUSE_WHEEL_BEHAVIOR ) )
+                    aInitialValues.push_back( NamedValue( PROPERTY_MOUSE_WHEEL_BEHAVIOR, makeAny( MouseWheelBehavior::SCROLL_DISABLED ) ) );
 
                 // now set all those values
                 for ( ::std::vector< NamedValue >::const_iterator property = aInitialValues.begin();
 		SvLBoxEntry* pCommandType = NULL;
 		SvLBoxEntry* pCommand = getObjectEntry( _rDataSourceName, _rCommand, _nCommandType, &pDataSource, &pCommandType, sal_True, _rxConnection );
 
-		//	if (pDataSource) // OJ change for the new app
+		if (pCommand)
 		{
-			if (pCommand)
+            bool bSuccess = true;
+			if ( _bSelectDirect )
 			{
-				if ( _bSelectDirect )
-				{
-					implSelect( pCommand );
-				}
-				else
-					m_pTreeView->getListBox().Select(pCommand);
-
+				bSuccess = implSelect( pCommand );
+			}
+			else
+            {
+				m_pTreeView->getListBox().Select( pCommand );
+            }
+
+            if ( bSuccess )
+            {
                 m_pTreeView->getListBox().MakeVisible(pCommand);
                 m_pTreeView->getListBox().SetCursor(pCommand);
+            }
+		}
+		else if (!pCommandType)
+		{
+			if ( m_pCurrentlyDisplayed )
+			{	// tell the old entry (if any) it has been deselected
+				selectPath(m_pCurrentlyDisplayed, sal_False);
+				m_pCurrentlyDisplayed = NULL;
 			}
-			else if (!pCommandType)
-			{
-				if ( m_pCurrentlyDisplayed )
-				{	// tell the old entry (if any) it has been deselected
-					selectPath(m_pCurrentlyDisplayed, sal_False);
-					m_pCurrentlyDisplayed = NULL;
-				}
-
-				// we have a command and need to display this in the rowset
-				return implLoadAnything(_rDataSourceName, _rCommand, _nCommandType, _bEscapeProcessing, _rxConnection);
-			}
+
+			// we have a command and need to display this in the rowset
+			return implLoadAnything(_rDataSourceName, _rCommand, _nCommandType, _bEscapeProcessing, _rxConnection);
 		}
 	}
 	return sal_False;
 
 	Reference< ::com::sun::star::form::XLoadable >	xLoadable = getLoadable();
 	bRebuild |= !xLoadable->isLoaded();
-	if(bRebuild)
+    bool bSuccess = true;
+	if ( bRebuild )
 	{
 		try
 		{
 			if ( !pConData->xConnection.is() )
 			{
 				unloadAndCleanup( sal_False );
-				return 0L;
+				return false;
 			}
 
 			Reference<XNameAccess> xNameAccess;
 								}
 								catch (Exception&)
 								{
+                                    DBG_UNHANDLED_EXCEPTION();
 								}
 							}
 						}
 			}
 
 			String sDataSourceName( getDataSourceAcessor( pConnection ) );
-			if ( implLoadAnything( sDataSourceName, aName, nCommandType, sal_True, pConData->xConnection ) )
-				// set the title of the beamer
-				;/*updateTitle();*/
-			else
+			bSuccess = implLoadAnything( sDataSourceName, aName, nCommandType, sal_True, pConData->xConnection );
+            if ( !bSuccess )
 			{	// clean up
 				criticalFail();
 			}
 			xRowSetProps->setPropertyValue(PROPERTY_ACTIVE_CONNECTION,Any());
 		}
 	}
-	return true;
+	return bSuccess;
 }
 
 // -----------------------------------------------------------------------------

dbaccess/source/ui/dlg/dbwizsetup.cxx

             ::comphelper::NamedValueCollection aArgs( xModel->getArgs() );
             aArgs.put( "Overwrite", sal_Bool( sal_True ) );
             aArgs.put( "InteractionHandler", xHandler );
+            aArgs.put( "MacroExecutionMode", MacroExecMode::USE_CONFIG );
 
             ::rtl::OUString sPath = m_pImpl->getDocumentUrl( *m_pOutSet );
 			xStore->storeAsURL( sPath, aArgs.getPropertyValues() );

dbaccess/source/ui/inc/brwctrlr.hxx

 
 namespace dbaui
 {
-
 	// =========================================================================
 
     typedef ::cppu::ImplInheritanceHelper9  <   OGenericUnoController
 		::osl::Mutex			m_aAsyncLoadSafety;		// for multi-thread access to our members
 
 		OAsyncronousLink		m_aAsyncGetCellFocus;
+        OAsyncronousLink        m_aAsyncDisplayError;
+        ::dbtools::SQLExceptionInfo m_aCurrentError;
 
 		String					m_sStateSaveRecord;
 		String					m_sStateUndoRecord;
 
 		sal_Bool				m_bLoadCanceled : 1;			// the load was canceled somehow
 		sal_Bool				m_bClosingKillOpen : 1;			// are we killing the load thread because we are to be suspended ?
-		sal_Bool				m_bErrorOccured : 1;			// see enter-/leaveFormAction
         bool                    m_bCannotSelectUnfiltered : 1;  // recieved an DATA_CANNOT_SELECT_UNFILTERED error
 
 	protected:
 		virtual void BeforeDrop();
 		virtual void AfterDrop();
 
+    public:
+
 	protected:
 		virtual ~SbaXDataBrowserController();
 
 
 		void enterFormAction();
 		void leaveFormAction();
-		bool errorOccured() const { return m_bErrorOccured; }
-			// As many form actions don't throw an exception but call their error handler instead we don't have
-			// a chance to recognize errors by exception catching.
-			// So for error recognition the above methods may be used.
+
 		// init the formatter if form changes
 		void initFormatter();
 
 			// (the alternative would be to lock the SolarMutex in OnOpenFinished to avoid problems with the needed updates,
 			// but playing with this mutex seems very hazardous to me ....)
 		DECL_LINK(OnAsyncGetCellFocus, void*);
+
+        DECL_LINK( OnAsyncDisplayError, void* );
 	};
 
 	//==================================================================

dbaccess/source/ui/querydesign/QueryDesignView.cxx

 				if ( SQL_ISRULE(pChild,search_condition) )
 					eErrorCode = GetORCriteria(_pView,_pSelectionBrw,pChild,nLevel,bHaving,bAddOrOnOneLine);
 				else
-                    eErrorCode = GetANDCriteria(_pView,_pSelectionBrw,pChild, bAddOrOnOneLine ? nLevel : nLevel++,bHaving,bAddOrOnOneLine);
+                    eErrorCode = GetANDCriteria(_pView,_pSelectionBrw,pChild, bAddOrOnOneLine ? nLevel : nLevel++,bHaving, i == 0 ? false : bAddOrOnOneLine);
 			}
 		}
 		else
 			eErrorCode = GetORCriteria(_pView,_pSelectionBrw,pCondition->getChild(1), nLevel2,bHaving,bMustAddOrOnOneLine );
 		}
 		// Das erste Element ist (wieder) eine AND-Verknuepfung
-		else if ( SQL_ISRULE(pCondition,boolean_term) && pCondition->count() == 3 )
+		else if ( SQL_ISRULE(pCondition,boolean_term) )
 		{
+            OSL_ENSURE(pCondition->count() == 3,"Illegal definifiton of boolean_term");
 			eErrorCode = GetANDCriteria(_pView,_pSelectionBrw,pCondition->getChild(0), nLevel,bHaving,bAddOrOnOneLine );
 			if ( eErrorCode == eOk )
 				eErrorCode = GetANDCriteria(_pView,_pSelectionBrw,pCondition->getChild(2), nLevel,bHaving,bAddOrOnOneLine );
 				!pEntryField->HasCriteria()					&&
 				pEntryField->isNoneFunction()				&&
 				pEntryField->GetOrderDir() == ORDER_NONE	&&
+                !pEntryField->IsGroupBy()                   &&
 				!pEntryField->GetFunction().getLength() )
 			rUnUsedFields.push_back(pEntryField);
 	}

dbaccess/source/ui/querydesign/SelectionBrowseBox.cxx

 	DBG_CHKTHIS(OSelectionBrowseBox,NULL);
 	DBG_ASSERT(rInfo.isValid() && !rInfo->IsEmpty(),"AddCondition:: OTableFieldDescRef sollte nicht Empty sein!");
 
-	OTableFieldDescRef pEntry;
+    OTableFieldDescRef pLastEntry;
 	Reference<XDatabaseMetaData> xMeta = xConnection->getMetaData();
 	::comphelper::UStringMixEqual bCase(xMeta.is() && xMeta->supportsMixedCaseQuotedIdentifiers());
 
     OTableFields::iterator aEnd = rFields.end();
 	for(;aIter != aEnd;++aIter)
 	{
-		pEntry = *aIter;
+		OTableFieldDescRef pEntry = *aIter;
 		const ::rtl::OUString	aField = pEntry->GetField();
 		const ::rtl::OUString	aAlias = pEntry->GetAlias();
 
 				if(!m_bGroupByUnRelated && pEntry->IsGroupBy())
 					pEntry->SetVisible(sal_True);
 			}
-			if (!pEntry->GetCriteria(nLevel).getLength() || _bAddOrOnOneLine )
+			if (!pEntry->GetCriteria(nLevel).getLength() )
 			{
-                String sCriteria = rValue;
-                if ( _bAddOrOnOneLine )
-                {
-                    String sOldCriteria = pEntry->GetCriteria( nLevel );
-                    if ( sOldCriteria.Len() )
-                    {
-                        sCriteria = String(RTL_CONSTASCII_USTRINGPARAM("("));
-                        sCriteria += sOldCriteria;
-                        sCriteria += String(RTL_CONSTASCII_USTRINGPARAM(" OR "));
-                        sCriteria += rValue;
-                        sCriteria += String(RTL_CONSTASCII_USTRINGPARAM(")"));
-                    }
-                }
-				pEntry->SetCriteria( nLevel, sCriteria);
+				pEntry->SetCriteria( nLevel, rValue);
 				if(nLevel == (m_nVisibleCount-BROW_CRIT1_ROW-1))
 				{
 					RowInserted( GetRowCount()-1, 1, TRUE );
 				}
                 m_bVisibleRow[BROW_CRIT1_ROW + nLevel] = sal_True;
 				break;
-			}
+			} // if (!pEntry->GetCriteria(nLevel).getLength() )
+            if ( _bAddOrOnOneLine )
+            {
+                pLastEntry = pEntry;
+            }
 		}
-	}
+	} // for(;aIter != getFields().end();++aIter)
+    if ( pLastEntry.isValid() )
+    {
+        String sCriteria = rValue;
+        String sOldCriteria = pLastEntry->GetCriteria( nLevel );
+        if ( sOldCriteria.Len() )
+        {
+            sCriteria = String(RTL_CONSTASCII_USTRINGPARAM("( "));
+            sCriteria += sOldCriteria;
+            sCriteria += String(RTL_CONSTASCII_USTRINGPARAM(" OR "));
+            sCriteria += rValue;
+            sCriteria += String(RTL_CONSTASCII_USTRINGPARAM(" )"));
+        }
+        pLastEntry->SetCriteria( nLevel, sCriteria);
+		if(nLevel == (m_nVisibleCount-BROW_CRIT1_ROW-1))
+		{
+			RowInserted( GetRowCount()-1, 1, TRUE );
+			m_bVisibleRow.push_back(sal_True);
+			++m_nVisibleCount;
+		}
+        m_bVisibleRow[BROW_CRIT1_ROW + nLevel] = sal_True;
+    }
 
-	if (aIter == getFields().end())
+	else if (aIter == getFields().end())
 	{
 		OTableFieldDescRef pTmp = InsertField(rInfo, BROWSER_INVALIDID, sal_False, sal_False );
 		if ( pTmp->isNumericOrAggreateFunction() && rInfo->IsGroupBy() ) // das GroupBy wird bereits von rInfo "ubernommen

dbaccess/source/ui/querydesign/query.src

 	Text [ en-US ] = "Join could not be processed" ;
 };
 
-String STR_QUERY_SAVEMODIFIED
-{
-	Text [ en-US ] = "The $object$ has been changed.\nDo you want to save the changes?" ;
-    Text [ x-comment ] = "For $object$, one of the values of the RSC_QUERY_OBJECT_TYPE resource will be inserted.";
-};
-
-Resource RSC_QUERY_OBJECT_TYPE
-{
-    String 1
-    {
-        Text [ en-US ] = "table view";
-    };
-    String 2
-    {
-        Text [ en-US ] = "query";
-    };
-    String 3
-    {
-        Text [ en-US ] = "SQL statement";
-    };
-};
-
 String STR_SVT_SQL_SYNTAX_ERROR
 {
 	Text [ en-US ] = "Syntax error in SQL statement" ;
 	Text [ en-US ] = " - %PRODUCTNAME Base: View Design";
 };
 
+String STR_QUERY_SAVEMODIFIED
+{
+	Text [ en-US ] = "$object$ has been changed.\nDo you want to save the changes?" ;
+    Text [ x-comment ] = "For $object$, one of the values of the RSC_QUERY_OBJECT_TYPE resource will be inserted.";
+};
+
 String STR_ERROR_PARSING_STATEMENT
 {
-    Text [ en-US ] = "The SQL command which constitutes the $object$ could not be parsed.";
+    Text [ en-US ] = "$object$ is based on an SQL command which could not be parsed.";
     Text [ x-comment ] = "For $object$, one of the values of the RSC_QUERY_OBJECT_TYPE resource "
         "(except \"SQL command\", which doesn't make sense here) will be inserted.";
 };
 
 String STR_INFO_OPENING_IN_SQL_VIEW
 {
-    Text [ en-US ] = "The $object$ will be opened in SQL view.";
+    Text [ en-US ] = "$object$ will be opened in SQL view.";
     Text [ x-comment ] = "For $object$, one of the values of the RSC_QUERY_OBJECT_TYPE resource "
         "(except \"SQL command\", which doesn't make sense here) will be inserted.";
 };
 
+Resource RSC_QUERY_OBJECT_TYPE
+{
+    String 1
+    {
+        Text [ en-US ] = "The table view";
+    };
+    String 2
+    {
+        Text [ en-US ] = "The query";
+    };
+    String 3
+    {
+        Text [ en-US ] = "The SQL statement";
+    };
+};
+
 String STR_STATEMENT_WITHOUT_RESULT_SET
 {
     Text [ en-US ] = "The query does not create a result set, and thus cannot be part of another query.";

dbaccess/source/ui/querydesign/querycontroller.cxx

 								pNodeTmp = pTemp->getChild(1);
 								::connectivity::OSQLParseNode::absorptions(pNodeTmp);
 								pNodeTmp = pTemp->getChild(1);
+                                OSQLParseNode::compress(pNodeTmp);
+                                pNodeTmp = pTemp->getChild(1);
 							} // if ( pCondition ) // no where clause
                             ::rtl::OUString sTemp;
                             pNode->parseNodeToStr(sTemp,getConnection());

dbaccess/source/ui/tabledesign/TEditControl.cxx

 String OTableEditorCtrl::GetCellText( long nRow, sal_uInt16 nColId ) const
 {
 	DBG_CHKTHIS(OTableEditorCtrl,NULL);
-	//////////////////////////////////////////////////////////////////////
-	// Text aus Dokumentdaten holen
-	return ::comphelper::getString(const_cast<OTableEditorCtrl*>(this)->GetCellData( nRow, nColId ));
+    ::rtl::OUString sCellText;
+    const_cast< OTableEditorCtrl* >( this )->GetCellData( nRow, nColId ) >>= sCellText;
+	return sCellText;
 }
 
 //------------------------------------------------------------------------------

dbaccess/source/ui/uno/copytablewizard.cxx

         else
             (m_xDest.get()->*_pSetter)( m_rDestPos, value );
     }
-
-    template< typename VALUE_TYPE >
+ template< typename VALUE_TYPE >
     void transferComplexValue( VALUE_TYPE ( SAL_CALL XRow::*_pGetter )( sal_Int32 ),
         void (SAL_CALL XParameters::*_pSetter)( sal_Int32, const VALUE_TYPE& ) )
     {
-        VALUE_TYPE value( (m_xSource.get()->*_pGetter)( m_rSourcePos ) );
+        const VALUE_TYPE value( (m_xSource.get()->*_pGetter)( m_rSourcePos ) );
+               {
         if ( m_xSource->wasNull() )
             m_xDest->setNull( m_rDestPos, m_rColTypes[ m_rSourcePos ] );
         else
             (m_xDest.get()->*_pSetter)( m_rDestPos, value );
+               }
     }
-
     private:
         const sal_Int32&                    m_rSourcePos;
         const sal_Int32&                    m_rDestPos;
             bContinue = _rxSourceResultSet->next();
 
         if ( !bContinue )
+		{
             break;
+		}
 
         ++nRowCount;
         sal_Bool bInsertAutoIncrement = sal_True;
 
             sal_Int32 nDestColumn( 0 );
             sal_Int32 nSourceColumn( 1 );
-            ValueTransfer aTransfer( nSourceColumn, nDestColumn, aSourceColTypes, xRow, xStatementParams );
+			ValueTransfer aTransfer( nSourceColumn, nDestColumn, aSourceColTypes, xRow, xStatementParams );
 
             for ( ; aPosIter != aPosEnd; ++aPosIter )
             {
                     // otherwise we don't get the correct value when only the 2nd source column was selected
                     continue;
                 }
-
+            	
                 if ( bAutoIncrement && bInsertAutoIncrement )
                 {
                     xStatementParams->setInt( 1, nRowCount );

dbaccess/source/ui/uno/makefile.mk

         copytablewizard.src
 
 # ... object files ............................
+# workaround for issue http://qa.openoffice.org/issues/show_bug.cgi?id=102305 Linux specific
+.IF "$(COM)" == "GCC"
+NOOPTFILES=\
+		$(SLO)$/copytablewizard.obj
+.ENDIF
 
 SLOFILES=	\
+		$(SLO)$/copytablewizard.obj \
 		$(SLO)$/composerdialogs.obj	\
 		$(SLO)$/unosqlmessage.obj	\
 		$(SLO)$/unoadmin.obj	\
 		$(SLO)$/ColumnControl.obj	\
 		$(SLO)$/ColumnPeer.obj	\
 		$(SLO)$/dbinteraction.obj \
-		$(SLO)$/copytablewizard.obj \
         $(SLO)$/textconnectionsettings_uno.obj
 
 # --- Targets ----------------------------------

extensions/inc/extensio.hrc

 #define HID_PROP_LOCKED							(HID_FORMS_START +  22)
 #define HID_PROP_FORMATKEY						(HID_FORMS_START +  23)
 #define HID_PROP_REQUIRED						(HID_FORMS_START +  24)
-    // FREE
+#define HID_PROP_WHEEL_BEHAVIOR                 (HID_FORMS_START +  25)
     // FREE
 #define HID_PROP_UNIQUE							(HID_FORMS_START +  27)
 #define HID_PROP_CLASSID						(HID_FORMS_START +  28)
 #define HID_PROP_ECHO_CHAR						(HID_FORMS_START +	91)
 #define HID_PROP_EMPTY_IS_NULL					(HID_FORMS_START +	92)
 #define HID_PROP_DECIMAL_ACCURACY				(HID_FORMS_START +	93)
-	// FREE
+#define HID_PROP_ENABLE_VISIBLE                 (HID_FORMS_START +  94)
 #define HID_PROP_DEFAULT_BUTTON					(HID_FORMS_START +	95)
 #define HID_PROP_HIDDEN_VALUE					(HID_FORMS_START +	96)
 #define HID_PROP_TRISTATE						(HID_FORMS_START +  97)

extensions/source/propctrlr/formmetadata.cxx

         DEF_INFO_3( LITERALMASK,       LITERALMASK,        LITERALMASK,       FORM_VISIBLE, DIALOG_VISIBLE, COMPOSEABLE ),
         DEF_INFO_3( STRICTFORMAT,      STRICTFORMAT,       STRICTFORMAT,      FORM_VISIBLE, DIALOG_VISIBLE, COMPOSEABLE ),
         DEF_INFO_3( ENABLED,           ENABLED,            ENABLED,           FORM_VISIBLE, DIALOG_VISIBLE, COMPOSEABLE ),
+        DEF_INFO_3( ENABLE_VISIBLE,    ENABLE_VISIBLE,     ENABLE_VISIBLE,    FORM_VISIBLE, DIALOG_VISIBLE, COMPOSEABLE ),
         DEF_INFO_3( READONLY,          READONLY,           READONLY,          FORM_VISIBLE, DIALOG_VISIBLE, COMPOSEABLE ),
         DEF_INFO_3( PRINTABLE,         PRINTABLE,          PRINTABLE,         FORM_VISIBLE, DIALOG_VISIBLE, COMPOSEABLE ),
         DEF_INFO_3( STEP,              STEP,               STEP,              FORM_VISIBLE, DIALOG_VISIBLE, COMPOSEABLE ),
         DEF_INFO_3( TABSTOP,           TABSTOP,            TABSTOP,           FORM_VISIBLE, DIALOG_VISIBLE, COMPOSEABLE ),
         DEF_INFO_2( TABINDEX,          TABINDEX,           TABINDEX,          FORM_VISIBLE, DIALOG_VISIBLE ),
+        DEF_INFO_3( WHEEL_BEHAVIOR,    WHEEL_BEHAVIOR,     WHEEL_BEHAVIOR,    FORM_VISIBLE, ENUM, COMPOSEABLE ),
 
         DEF_INFO_2( BOUND_CELL,        BOUND_CELL,         BOUND_CELL,        FORM_VISIBLE, DATA_PROPERTY ),
         DEF_INFO_3( CELL_EXCHANGE_TYPE,CELL_EXCHANGE_TYPE, CELL_EXCHANGE_TYPE,FORM_VISIBLE, DATA_PROPERTY, ENUM ),
             case PROPERTY_ID_WRITING_MODE:
 				nStringItemsResId = RID_RSC_ENUM_WRITING_MODE;
                 break;
+            case PROPERTY_ID_WHEEL_BEHAVIOR:
+				nStringItemsResId = RID_RSC_ENUM_WHEEL_BEHAVIOR;
+                break;
             case PROPERTY_ID_TEXT_ANCHOR_TYPE:
 				nStringItemsResId = RID_RSC_ENUM_TEXT_ANCHOR_TYPE;
                 break;

extensions/source/propctrlr/formmetadata.hxx

     #define PROPERTY_ID_SCALE_MODE                  196
     #define PROPERTY_ID_INPUT_REQUIRED              197
     #define PROPERTY_ID_WRITING_MODE                198
-    #define PROPERTY_ID_TEXT_ANCHOR_TYPE            199
-    #define PROPERTY_ID_SHEET_ANCHOR_TYPE           200
+    #define PROPERTY_ID_ENABLE_VISIBLE              199
+    #define PROPERTY_ID_WHEEL_BEHAVIOR              200
+    #define PROPERTY_ID_TEXT_ANCHOR_TYPE            201
+    #define PROPERTY_ID_SHEET_ANCHOR_TYPE           202
 
 //............................................................................