Developing ActiveX client application code

Viewing a System.out message: The ActiveX to Enterprise JavaBeans (EJB) bridge does not have a console available to view Java System.out messages. To view these messages when running a stand-alone client program (such as Visual Basic), redirect the output to a file.

launchClientXJB.bat MyProgram.exe > output.txt

• To view the System.out messages when running a Service program such as Active Server Pages, override the Java System.out OutputStream object to FileOutputStream. For example, in VBScript:

  'Redirect system.out to a file
  ' Assume that oXJB is an initialized XJB.JClassFactory object
   Dim clsSystem
   Dim oOS
   Dim oPS
   Dim oArgs
  
  ' Get the System class
    Set clsSystem = oXJB.FindClass("java.lang.System")
  
  ' Create a FileOutputStream object
  ' Create a PrintStream object and assign to it our FileOutputStream
    Set oArgs = oXJB.GetArgsContainer  oArgs.AddObject "java.io.OutputStream", oOS
    Set oPS = oXJB.NewInstance(oXJB.FindClass("java.io.PrintStream"), oArgs)
  
  ' Set our System OutputStream to our file
    clsSystem.setOut oPS

ActiveX client application using helper methods for data type conversion. Generally, data type conversion between ActiveX (Visual Basic and VBScript) and Java methods occurs automatically, as described in ActiveX to EJB bridge, converting data types. However, the byte helper function and currency helper function are provided for cases where automatic conversion is not possible.

• Byte helper function
  Because the Java Byte data type is signed (-127 through 128) and the Visual Basic Byte data type is unsigned (0 through 255), convert unsigned Bytes to a Visual Basic Integers, which look like the Java signed byte. To make this conversion, you can use the following helper function:

  
  Private Function GetIntFromJavaByte(Byte jByte) as Integer
  	     GetIntFromJavaByte = (CInt(jByte) + 128) Mod 256 - 128
  End Function

• Currency helper function
  Visual Basic 6.0 cannot properly handle 64-bit integers like Java methods can (as the Long data type). Therefore, Visual Basic uses the Currency type, which is intrinsically a 64-bit data type. The only side effect of using the Currency type (the Variant type VT_CY) is that a decimal point is inserted into the type. To extract and manipulate the 64-bit Long value in Visual Basic, use code like the following example. For more details on this technique for converting Currency data types, see Q189862, HOWTO: Do 64-bit Arithmetic in VBA, on the Microsoft Knowledge Base.

  
  ' Currency Helper Types
  Private Type MungeCurr
      Value As Currency
  End Type
  Private Type Munge2Long
      LoValue As Long
      HiValue As Long
  End Type
  
  ' Currency Helper Functions
  Private Function CurrToText(ByVal Value As Currency) As String
      Dim Temp As String, L As Long
      Temp = Format$(Value, "#.0000")
      L = Len(Temp)
      Temp = Left$(Temp, L - 5) & Right$(Temp, 4)
      Do While Len(Temp) > 1 And Left$(Temp, 1) = "0"
          Temp = Mid$(Temp, 2)
      Loop
      Do While Len(Temp) > 2 And Left$(Temp, 2) = "-0"
          Temp = "-" & Mid$(Temp, 3)
      Loop
      CurrToText = Temp
  End Function
  
  Private Function TextToCurr(ByVal Value As String) As Currency
      Dim L As Long, Negative As Boolean
      Value = Trim$(Value)
      If Left$(Value, 1) = "-" Then
          Negative = True
          Value = Mid$(Value, 2)
      End If
      L = Len(Value)
      If L < 4 Then
          TextToCurr = CCur(IIf(Negative, "-0.", "0.") & _
                            Right$("0000" & Value, 4))
      Else
          TextToCurr = CCur(IIf(Negative, "-", "") & _
                            Left$(Value, L - 4) & "." & Right$(Value, 4))
      End If
  End Function
  
  ' Java Long as Currency Usage Example
  Dim LC As MungeCurr
  Dim L2 As Munge2Long
  
  ' Assign a Currency Value (really a Java Long)
  ' to the MungeCurr type variable
  LC.Value = cyTestIn
  
  ' Coerce the value to the Munge2Long type variable
  LSet L2 = LC
  
  ' Perform some operation on the value, now that we
  ' have it available in two 32-bit chunks
  L2.LoValue = L2.LoValue + 1
  
  ' Coerce the Munge value back into a currency value
  LSet LC = L2
  cyTestIn = LC.Value