--- /dev/null
+This is octave-java.info, produced by makeinfo version 4.11 from
+octave-java.texi.
+
+\r
+
+\1f
+File: octave-java.info, Node: Top, Next: javaclasspath, Up: (dir)
+
+1 Using Octave (and Matlab) with Java
+*************************************
+
+\r \r This description is based on the Octave package `java-1.2.8'. The
+`java' package usually installs its script files (.m) in the directory
+`.../share/Octave/packages/java-1.2.8' and its binary (.oct) files in
+`.../libexec/Octave/packages/java-1.2.8'. \r \r You can get help on
+specific functions in Octave by executing the help command\r with the
+name of a function from this package:\r
+ Octave > help javaObject\r
+ \r You can view this help file in Octave by executing the info
+command with \r just the word java:\r
+ Octave > doc java\r
+ \r
+
+Note on calling Octave from Java
+================================
+
+The `java' package is designed for calling Java from Octave.\r If you
+want to call Octave from Java, you might want to use a library like \r
+`javaOctave' [http://kenai.com/projects/javaOctave] or\r `joPas'
+[http://jopas.sourceforge.net]. \r
+
+2 Table of Contents
+*******************
+
+\r Available Functions\r
+
+* Menu:
+
+* javaclasspath:: get the class path of the JVM\r
+* javaaddpath:: add a path to the class path of the JVM\r
+* javarmpath:: remove a path to the class path of the JVM\r
+* javamem:: get information about available memory\r
+* javaArray:: create a Java array\r
+* javaObject:: create a Java object\r
+* java_new:: create a Java object\r
+* javaMethod:: invoke a method on the Java object\r
+* java_invoke:: invoke a method on the Java object\r
+* java_get:: get a field on the Java object\r
+* java_set:: set a field on the Java object\r
+* javamethods:: list the available methods of a Java objects\r
+* javafields:: list the available fields of a Java objects\r
+* msgbox:: display a dialog box\r
+* errordlg:: display a dialog with an error symbol\r
+* listdlg:: display a dialog with a selection list\r
+* warndlg:: display a dialog with a warning symbol\r
+* helpdlg:: display a dialog with a help symbol\r
+* inputdlg:: display a dialog with edit fields\r
+* questdlg:: display a dialog with a question icon\r
+
+ Frequently Asked Questions
+
+* Menu:
+
+* How to distinguish between Octave and Matlab?::\r
+* How to make Java classes available?::\r
+* How to create an instance of a Java class?::\r
+* How can I handle memory limitations?::\r
+* How to compile the java package in Octave?::\r
+* Which TeX symbols are implemented in the dialog functions?::\r
+ \r
+
+3 Available Functions
+*********************
+
+\1f
+File: octave-java.info, Node: javaclasspath, Next: javaaddpath, Prev: Top, Up: Top
+
+\r
+
+3.1 javaclasspath
+=================
+
+\r
+
+ -- Function file: javaclasspath
+ -- Function file: STATIC = javaclasspath
+ -- Function file: [STATIC, DYNAMIC] = javaclasspath
+ -- Function file: PATH = javaclasspath (WHAT)
+ \r Return the class path of the Java virtual machine as a cell
+ array of strings. \r \r If called without an input parameter:\r
+ * If no output variable is given, the result is simply printed
+ \r to the standard output.\r
+
+ * If one output variable STATIC is given, the result is\r the
+ static classpath.\r
+
+ * If two output variables STATIC and DYNAMIC are \r given, the
+ first variable will contain the static classpath,\r the
+ second will be filled with the dynamic claspath.\r
+ \r If called with a single input parameter WHAT:\r
+ If no output parameter is given:\r
+
+ * The result is printed to the standard output similar to the
+ call without input parameter.
+ \r If the output parameter PATH is used:\r
+
+ * If WHAT is '-static' the static classpath is returned.\r
+
+ * If WHAT is '-dynamic' the dynamic classpath is returned.\r
+
+ * If WHAT is '-all' the static and the dynamic classpath \r are
+ returned in a single cell array.\r
+ \r For the example two entries have been added to the static
+ classpath using the file `classpath.txt'.\r \r Example: \r
+ Octave > javaclasspath('-all')\r
+ STATIC JAVA PATH\r
+ \r
+ z:/someclasses.jar\r
+ z:/classdir/classfiles\r
+ \r
+ DYNAMIC JAVA PATH\r
+ - empty -\r
+ \r
+ Octave > javaaddpath('z:/dynamic');\r
+ Octave > ps = javaclasspath('-all')\r
+ ps =\r
+ {\r
+ [1,1] = z:/someclasses.jar\r
+ [1,2] = z:/classdir/classfiles\r
+ [1,3] = z:/dynamic\r
+ }\r
+ \r
+
+ *See also:* *note javaaddpath: doc-javaaddpath,\r *note
+ javarmpath: doc-javarmpath,\r *note How to make Java
+ classes available to Octave?: doc-FAQ.\r
+ \r
+
+\1f
+File: octave-java.info, Node: javaaddpath, Next: javarmpath, Prev: javaclasspath, Up: Top
+
+3.2 javaaddpath
+===============
+
+\r
+
+ -- Function File: javaaddpath (PATH)
+ \r Add PATH to the dynamic class path of the Java virtual machine.
+ PATH can be either a directory where .class files can be found, or
+ a .jar file containing Java classes. In both cases the directory
+ or file must exist. \r \r Example: \r \r This example adds a Java
+ archive and a directory containing .CLASS files to the CLASSPATH
+ and displays the current CLASSPATH list. \r \r
+ Octave > javaaddpath('C:/java/myclasses.jar'); \r
+ Octave > javaaddpath('C:/java/classes'); \r
+ Octave > javaclasspath; \r
+ ans = \r
+ { \r
+ [1,1] = C:\java\myclasses.jar \r
+ [1,2] = C:\java\classes \r
+ } \r
+
+ *See also:* *note javaclasspath: doc-javaclasspath, *note
+ javarmpath: doc-javarmpath,\r *note How to make Java
+ classes available to Octave?: doc-FAQ.\r
+ \r
+
+\1f
+File: octave-java.info, Node: javarmpath, Next: javamem, Prev: javaaddpath, Up: Top
+
+3.3 javarmpath
+==============
+
+\r
+
+ -- Function File: javarmpath (PATH)
+ Remove PATH from the dynamic class path of the Java virtual
+ machine. PATH can be either a directory where .class files can be
+ found, or a .jar file containing Java classes. \r \r Example: This
+ example removes one of the directories added in the example for
+ the `javaaddpath' function. \r \r
+ Octave > javarmpath('C:/java/classes'); \r
+ Octave > javaclasspath \r
+ { \r
+ [1,1] = C:\java\myclasses.jar \r
+ } \r
+ \r
+
+ *See also:* *note javaaddpath: doc-javaaddpath, *note
+ javaclasspath: doc-javaclasspath,\r *note How to make
+ Java classes available to Octave?: doc-FAQ.\r
+ \r
+
+\1f
+File: octave-java.info, Node: javamem, Next: javaArray, Prev: javarmpath, Up: Top
+
+3.4 javamem
+===========
+
+\r
+
+ -- Function File: javamem
+ -- Function File: [JMEM] = javamem
+ \r Show current memory status of the java virtual machine (JVM)\r
+ & run garbage collector.\r \r When no return argument is given the
+ info is echoed to the screen.\r Otherwise, cell array JMEM
+ contains MAXIMUM, TOTAL, and\r FREE memory (in bytes).\r \r All
+ java-based routines are run in the JVM's shared memory pool,\r a
+ dedicated and separate part of memory claimed by the JVM from\r
+ your computer's total memory (which comprises physical RAM and\r
+ virtual memory / swap space on hard disk).\r \r The maximum
+ available memory can be set using the file `java.opts'\r (in the
+ same subdirectory where `javaaddpath.m' lives, see \r `which
+ javaaddpath'. Usually that is:
+ \r [/usr]/share/Octave/packages/java-1.2.8.\r \r `java.opts' is a
+ plain text file. It can contain memory related \r options,
+ starting with `-X'.\r In the following exmaple, the first line
+ specifies the initial \r memory size in megabytes, the second line
+ specifies the requested \r maximum size:\r
+ -Xms64m\r
+ -Xmx512m\r
+ You can adapt these values if your system has limited available\r
+ physical memory. When no `java.opts' file is present, the default\r
+ assignments are depending on system hardware and Java version. \r
+ Typically these are an initial memory size of RAM/64 and \r a
+ maximum memory size of MIN(RAM/4, 1GB), where RAM\r is the amount
+ of installed memory.\r \r In the output of javamem TOTAL MEMORY is
+ what the operating\r system has currently assigned to the JVM and
+ depends on actual \r and active memory usage.\r FREE MEMORY is
+ self-explanatory. During operation of java-based\r Octave
+ functions the amounts of Total and Free memory will vary,\r due to
+ java's own cleaning up and your operating system's memory\r
+ management.\r \r Example:\r
+ Octave > javamem\r
+ Java virtual machine (JVM) memory info:\r
+ Maximum available memory: 247 MB;\r
+ (...running garbage collector...)\r
+ OK, current status:\r
+ Total memory in virtual machine: 15 MB;\r
+ Free memory in virtual machine: 15 MB;\r
+ 2 CPUs available.\r
+ \r
+ Octave > [MEM] = javamem()\r
+ MEM =\r
+ {\r
+ [1,1] = 259522560\r
+ [2,1] = 16318464\r
+ [3,1] = 16085576\r
+ }\r
+ \r
+
+ *See also:* *note How can I handle memory limitations?: doc-FAQ.\r
+ \r
+
+\1f
+File: octave-java.info, Node: javaArray, Next: javaObject, Prev: javamem, Up: Top
+
+3.5 javaArray
+=============
+
+\r
+
+ -- Function File: ARRAY = javaArray (CLASS, [M, N, ...])
+ -- Function File: ARRAY = javaArray (CLASS, M, N, ...)
+ \r Create a Java array of size `[M, N, ...]' with elements of
+ class CLASS. CLASS can be a Java object representing a class or a
+ string containing the fully qualified class name. \r The generated
+ array is uninitialized, all elements are set to null if CLASS is a
+ reference type, or to a default value (usually 0) if CLASS is a
+ primitive type. \r \r Example: This example creates a (2 x 2)
+ array of Java STRING objects and assigns a value to one of the
+ elements. Finally it displays the type of A.\r
+ Octave > a = javaArray('java.lang.String', 2, 2); \r
+ Octave > a(1,1) = 'Hello'; \r
+ Octave > a\r
+ a =\r
+ <Java object: java.lang.String[][]>\r
+\r
+
+\1f
+File: octave-java.info, Node: javaObject, Next: java_new, Prev: javaArray, Up: Top
+
+3.6 javaObject
+==============
+
+\r
+
+ -- Function File: OBJECT = javaObject (CLASS, [ARG1, ..., ARGN])
+ \r Create a Java object of class CLASS, by calling the class
+ constructor with the given arguments ARG1, ..., ARGN. The CLASS
+ name should be given in fully qualified string form (including any
+ package prefix). In Matlab you should avoid to use the import
+ statement and the short form of object creation. \r \r Example:
+ This example demonstrates two ways to create a Java `StringBuffer'
+ object. The first variant creates an uninitialized STRINGBUFFER
+ object, while the second variant calls a constructor with the
+ given initial `String'. Then it displays the type of `o', and
+ finally the content of the `StringBuffer' object is displayed by
+ using its `toString' method.\r \r
+ Octave > o = javaObject('java.lang.StringBuffer'); \r
+ Octave > o = javaObject('java.lang.StringBuffer', 'Initial'); \r
+ Octave > o \r
+ o =\r
+ <Java object: java.lang.StringBuffer>\r
+ Octave > o.toString \r
+ ans = Initial\r
+ \r Equivalent to the `java_new' function.\r For compatibility with
+ Matlab it is recommended to use the `javaObject' function. \r \r
+
+ *See also:* *note java_new: doc-java_new.\r
+ \r
+
+\1f
+File: octave-java.info, Node: java_new, Next: javaMethod, Prev: javaObject, Up: Top
+
+3.7 java_new
+============
+
+\r
+
+ -- Function File: OBJECT = java_new (CLASS, [ARG1, ..., ARGN])
+ \r Create a Java object of class CLASS, by calling the class
+ constructor with the given arguments ARG1, ..., ARGN. \r
+ Equivalent to the `javaObject' function. \r For compatibility with
+ Matlab it is recommended to use the `javaObject' function. \r \r
+ Example: \r
+ Octave > o = java_new('java.lang.StringBuffer', 'Initial'); \r
+ Octave > o \r
+ o =\r
+ <Java object: java.lang.StringBuffer>\r
+ Octave > o.toString \r
+ ans = Initial\r
+ \r
+
+ *See also:* *note javaObject: doc-javaObject.\r
+ \r
+
+\1f
+File: octave-java.info, Node: javaMethod, Next: java_invoke, Prev: java_new, Up: Top
+
+3.8 javaMethod
+==============
+
+\r
+
+ -- Function File: RET = javaMethod (NAME, OBJECT[, ARG1, ..., ARGN])
+ \r Invoke the method NAME on the Java object OBJECT with the
+ arguments ARG1, ... For static methods, OBJECT can be a string
+ representing the fully qualified name of the corresponding class.
+ The function returns the result of the method invocation. \r When
+ OBJECT is a regular Java object, the structure-like indexing can
+ be used as a shortcut syntax. For instance, the two statements in
+ the example are equivalent. \r \r Example: \r
+ Octave > ret = javaMethod("method1", x, 1.0, "a string")\r
+ Octave > ret = x.method1(1.0, "a string") \r
+ \r
+
+ *See also:* *note javamethods: doc-javamethods.\r
+ \r
+
+\1f
+File: octave-java.info, Node: java_invoke, Next: java_get, Prev: javaMethod, Up: Top
+
+3.9 java_invoke
+===============
+
+\r
+
+ -- Function File: RET = java_invoke (OBJECT, NAME[, ARG1, ..., ARGN])
+ \r Invoke the method NAME on the Java object OBJECT with the
+ arguments ARG1, ... For static methods, OBJECT can be a string
+ representing the fully qualified name of the corresponding class.
+ The function returns the result of the method invocation.
+ Equivalent to the `javaMethod' function. When OBJECT is a regular
+ Java object, the structure-like indexing can be used as a shortcut
+ syntax. For instance, the two statements in the example are
+ equivalent. \r \r Example: \r
+ Octave > ret = java_invoke(x, "method1", 1.0, "a string") \r
+ Octave > ret = x.method1(1.0, "a string") \r
+ \r
+
+ *See also:* *note javamethods: doc-javamethods.\r
+ \r
+
+\1f
+File: octave-java.info, Node: java_get, Next: java_set, Prev: java_invoke, Up: Top
+
+3.10 java_get
+=============
+
+\r
+
+ -- Function File: VAL = java_get (OBJECT, NAME)
+ \r Get the value of the field NAME of the Java object OBJECT. For
+ static fields, OBJECT can be a string representing the fully
+ qualified name of the corresponding class. \r \r When OBJECT is a
+ regular Java object, the structure-like indexing can be used as a
+ shortcut syntax. For instance, the two statements in the example
+ are equivalent \r \r Example: \r
+ Octave > java_get(x, "field1") \r
+ Octave > x.field1 \r
+ \r
+
+ *See also:* *note javafields: doc-javafields,\r *note
+ java_set: doc-java_set.\r
+ \r
+
+\1f
+File: octave-java.info, Node: java_set, Next: javamethods, Prev: java_get, Up: Top
+
+3.11 java_set
+=============
+
+\r
+
+ -- Function File: OBJECT = java_set (OBJECT, NAME, VALUE)
+ \r Set the value of the field NAME of the Java object OBJECT to
+ VALUE. For static fields, OBJECT can be a string representing the
+ fully qualified named of the corresponding Java class. \r When
+ OBJECT is a regular Java object, the structure-like indexing can
+ be used as a shortcut syntax. For instance, the two statements in
+ the example are equivalent \r \r Example: \r
+ Octave > java_set(x, "field1", val) \r
+ Octave > x.field1 = val \r
+ \r
+
+ *See also:* *note javafields: doc-javafields,\r *note
+ java_get: doc-java_get.\r
+ \r
+
+\1f
+File: octave-java.info, Node: javamethods, Next: javafields, Prev: java_set, Up: Top
+
+3.12 javamethods
+================
+
+\r
+
+ -- Function File: M = javamethods (CLASSNAME)
+ -- Function File: M = javamethods (OBJECT)
+ \r Given a string with a Java class name CLASSNAME or a regular
+ Java object OBJECT, this function returns a cell array containing
+ descriptions of all methods of the Java class CLASSNAME
+ respectively the class of OBJECT. \r \r Examples: The first
+ example shows how the methods of a class can be queried, while the
+ second example works with the methods of a concrete instance of a
+ class. Note that creation of a `java.lang.Double' object requires
+ an initializer (in the example the value 1.2). \r
+ Octave > m = javamethods('java.lang.Double'); \r
+ Octave > size(m) \r
+ ans = \r
+ 1 30 \r
+ \r
+ Octave > m{7} \r
+ ans = double longBitsToDouble(long) \r
+ \r
+ Octave > o = javaObject('java.lang.Double', 1.2); \r
+ Octave > m = javamethods(o); \r
+ Octave > size(m) \r
+ ans = \r
+ 1 30 \r
+ \r
+ Octave > m{7} \r
+ ans = double longBitsToDouble(long) \r
+ \r
+
+ *See also:* *note javafields: doc-javafields,\r *note
+ java_invoke: doc-java_invoke.\r
+ \r
+
+\1f
+File: octave-java.info, Node: javafields, Next: msgbox, Prev: javamethods, Up: Top
+
+3.13 javafields
+===============
+
+\r
+
+ -- Function File: F = javafields (CLASSNAME)
+ -- Function File: F = javafields (OBJECT)
+ \r Given a string with a Java class name CLASSNAME or a regular
+ Java object OBJECT, this function returns a cell array containing
+ the descriptions for all fields of the Java class CLASSNAME
+ respectively the class of OBJECT. \r \r Examples: \r \r The first
+ example shows how the fields of a class can be queried without
+ creating an instance of the class. \r
+ Octave > f = javafields('java.lang.Double'); \r
+ Octave > size(f)\r
+ ans =\r
+ 1 10\r
+ \r
+ Octave > f{7}\r
+ ans = public static final int java.lang.Double.MAX_EXPONENT \r
+ \r The second example works with the fields of an instance of a
+ class. Note that creation of a `java.lang.Double' object requires
+ an initializer (in the example a value of 1.2 is specified). \r
+ Octave > o = javaObject('java.lang.Double', 1.2); \r
+ Octave > f = javafields(o); \r
+ Octave > size(f) \r
+ ans = \r
+ 1 10 \r
+ \r
+ Octave > f{7} \r
+ ans = public static final int java.lang.Double.MAX_EXPONENT \r
+ \r
+
+ *See also:* *note java_set: doc-java_set,\r *note
+ java_get: doc-java_get.\r
+ \r
+
+\1f
+File: octave-java.info, Node: msgbox, Next: errordlg, Prev: javafields, Up: Top
+
+3.14 msgbox
+===========
+
+\r
+
+ -- Function File: F = msgbox (MESSAGE)
+ -- Function File: F = msgbox (MESSAGE, TITLE)
+ -- Function File: F = msgbox (MESSAGE, TITLE, ICON)
+ \r Displays a MESSAGE using a dialog box. The parameter TITLE can
+ be used to optionally decorate the dialog caption. \r The third
+ optional parameter ICON can be either `'error'', `'help'' or
+ `'warn''\r and selectes the corresponding icon.\r If it is
+ omitted, no icon is shown.\r \r Examples: The first example shows
+ a dialog box without a caption text, whereas the second example
+ specifies a caption text of its own. \r The third example also
+ demonstrates how a character \r according to the TeX symbol set
+ can be specified. It is important to include a space character\r
+ after the symbol code and how to embed a newline character (ASCII
+ code 10) into the string.\r \r
+ Octave > msgbox('This is an important message'); \r
+ Octave > msgbox('Do not forget to feed the cat.', 'Remember');\r
+ Octave > msgbox(['I \heartsuit Octave!',10, ...\r
+ ' Even if I hate it sometimes.'], ...\r
+ 'I Confess','warn');\r
+ \r \0\b[image src="images/image003.png"\0\b]\r \r
+
+ *See also:* *note errordlg: doc-errordlg,\r *note
+ helpdlg: doc-helpdlg,\r *note warndlg: doc-warndlg.\r
+ \r
+
+\1f
+File: octave-java.info, Node: errordlg, Next: helpdlg, Prev: msgbox, Up: Top
+
+3.15 errordlg
+=============
+
+\r
+
+ -- Function File: F = errordlg (MESSAGE)
+ -- Function File: F = errordlg (MESSAGE, TITLE)
+ \r Displays the MESSAGE using an error dialog box. The TITLE can
+ be used optionally to decorate the dialog caption instead of the
+ default title "Error Dialog". \r \r Examples: The first example
+ shows a dialog box with default caption, whereas the second
+ example specifies a its own caption \r
+ Octave > errordlg('Oops, an expected error occured'); \r
+ \0\b[image src="images/image001.png"\0\b]\r
+ Octave > errordlg('Another error occured', 'Oops'); \r
+ \r
+
+ *See also:* *note helpdlg: doc-helpdlg,\r *note inputdlg:
+ doc-inputdlg,\r *note listdlg: doc-listdlg,\r
+ *note questdlg: doc-questdlg,\r *note warndlg:
+ doc-warndlg.\r
+ \r
+
+\1f
+File: octave-java.info, Node: helpdlg, Next: inputdlg, Prev: errordlg, Up: Top
+
+3.16 helpdlg
+============
+
+\r
+
+ -- Function File: F = helpdlg (MESSAGE)
+ -- Function File: F = helpdlg (MESSAGE, TITLE)
+ \r Displays the MESSAGE using a help dialog box. The help message
+ can consist of multiple lines, separated by a newline character.
+ The TITLE can be used optionally to decorate the dialog caption
+ bar instead of the default title "Help Dialog". \r \r Examples:
+ The first example shows a dialog box with default caption, whereas
+ the next two examples specify their own caption. Note that if the
+ backslash escape notation is used in a double quoted string, it is
+ immediately replaced by Octave with a newline.\r If it is
+ contained in a single quoted string, it is not replaced by Octave,
+ \r but later by the dialog function.\r \r
+ Octave > helpdlg('This is a short notice'); \r
+ Octave > helpdlg(['line #1',10,'line #2'], 'Inventory'); \r
+ Octave > helpdlg("1 eel\n9 buckazoids\n2 peas", 'Inventory'); \r
+ \r \0\b[image src="images/image004.png"\0\b]\r \r
+
+ *See also:* *note errordlg: doc-errordlg,\r *note
+ inputdlg: doc-inputdlg,\r *note listdlg: doc-listdlg,\r
+ *note questdlg: doc-questdlg,\r *note warndlg:
+ doc-warndlg.\r
+ \r
+
+\1f
+File: octave-java.info, Node: inputdlg, Next: listdlg, Prev: helpdlg, Up: Top
+
+3.17 inputdlg
+=============
+
+\r
+
+ -- Function File: C = inputdlg (PROMPT)
+ -- Function File: C = inputdlg (PROMPT, TITLE)
+ -- Function File: C = inputdlg (PROMPT, TITLE, ROWSCOLS)
+ -- Function File: C = inputdlg (PROMPT, TITLE, ROWSCOLS, DEFAULTS)
+ \r Returns the user's inputs from a multi-textfield dialog box in
+ form of a cell array of strings. If the user closed the dialog
+ with the Cancel button, en empty cell array is returned. This can
+ be checked with the ISEMPTY function. The first argument PROMPT is
+ mandatory. It is a cell array with strings labeling each text
+ field. The optional string TITLE can be used as the caption of the
+ dialog. The size of the text fields can be defined by the argument
+ ROWSCOLS, which can be either a scalar to define the number of
+ columns used for each text field, a vector to define the number of
+ rows for each text field individually, or a matrix to define the
+ number of rows and columns for each text field individually. It is
+ possible to place default values into the text fields by supplying
+ a cell array of strings for the argument DEFAULTS. \r \r Examples:
+ The first example shows a simple usage of the input dialog box
+ without defaults. \r
+ Octave > prompt = {'Width','Height','Depth'}; \r
+ Octave > dims = inputdlg(prompt, 'Enter Box Dimensions'); \r
+ Octave > volume = str2num(dims{1}) * ... \r
+ str2num(dims{2}) * str2num(dims{3}); \r
+ \r \0\b[image src="images/image005.png"\0\b]\r \r The second
+ example shows the application of a scalar for the number of rows
+ and a cell array with default values. \r
+ Octave > prompt = {'Width', 'Height', 'Depth'}; \r
+ Octave > defaults = {'1.1', '2.2', '3.3'}; \r
+ Octave > title = 'Enter Box Dimensions'; \r
+ Octave > dims = inputdlg(prompt, title, 1, defaults); \r
+ Octave > dims \r
+ dims = \r
+ {\r
+ [1,1] = 1.1 \r
+ [2,1] = 2.2 \r
+ [3,1] = 3.3 \r
+ }\r
+ \r \0\b[image src="images/image006.png"\0\b]\r \r The third
+ example shows the application of row height and column width
+ specification.. \r
+ Octave > prompt = {'Width', 'Height', 'Depth'}; \r
+ Octave > defaults = {'1.1', '2.2', '3.3'}; \r
+ Octave > rc = [1,10; 2,20; 3,30]; \r
+ Octave > title = 'Enter Box Dimensions'; \r
+ Octave > dims = inputdlg(prompt, title, rc, defaults); \r
+ \r \0\b[image src="images/image007.png"\0\b]\r \r
+
+ *See also:* *note errordlg: doc-errordlg,\r *note
+ helpdlg: doc-helpdlg,\r *note listdlg: doc-listdlg,\r
+ *note questdlg: doc-questdlg,\r *note warndlg:
+ doc-warndlg.\r
+ \r
+
+\1f
+File: octave-java.info, Node: listdlg, Next: questdlg, Prev: inputdlg, Up: Top
+
+3.18 listdlg
+============
+
+\r
+
+ -- Function File: [SEL, OK] = listdlg (KEY, VALUE[, KEY, VALUE, ...])
+ \r This function returns the inputs from a list dialog box. The
+ result is returned as a vector of indices and a flag. The vector
+ SEL contains the 1-based indices of all list items selected by the
+ user. The flag OK is 1 if the user closed the dialog with the OK
+ Button, otherwise it is 0 and SEL is empty.. The arguments of this
+ function are specified in the form of KEY, VALUE pairs. At least
+ the `'ListString'' argument pair must be specified. It is also
+ possible to preselect items in the list in order to provide a
+ default selection. \r \r The KEY and VALUE pairs can be selected
+ from the following list: \r \r
+ `ListString'
+ a cell array of strings comprising the content of the list.\r
+
+ `SelectionMode'
+ can be either `'single'' or `'multiple''. \r
+
+ `ListSize'
+ a vector with two elements `[width, height]' defining the
+ size of the list field in pixels. \r
+
+ `InitialValue'
+ a vector containing 1-based indices of preselected elements.\r
+
+ `Name'
+ a string to be used as the dialog caption.\r
+
+ `PromptString'
+ a cell array of strings to be displayed above the list
+ field.\r
+
+ `OKString'
+ a string used to label the OK button.\r
+
+ `CancelString'
+ a string used to label the Cancel button.\r
+ \r Example:\r
+ Octave > [s,ok] = listdlg('ListString', ... \r
+ {'An item', 'another', 'yet another'}, ...\r
+ 'Name', 'Selection Dialog', ...\r
+ 'SelectionMode', 'Multiple', ...\r
+ 'PromptString',['Select an item...',10,'...or multiple items']);\r
+ \r
+ Octave > imax = length(s); \r
+ Octave > for i=1:1:imax \r
+ Octave > disp(s(i)); \r
+ Octave > end \r
+ \r \0\b[image src="images/image002.png"\0\b]\r \r
+
+ *See also:* *note errordlg: doc-errordlg,\r *note
+ helpdlg: doc-helpdlg,\r *note inputdlg: doc-inputdlg,\r
+ *note questdlg: doc-questdlg,\r *note warndlg:
+ doc-warndlg.\r
+ \r
+
+\1f
+File: octave-java.info, Node: questdlg, Next: warndlg, Prev: listdlg, Up: Top
+
+3.19 questdlg
+=============
+
+\r
+
+ -- Function File: C = questdlg (MESSAGE, TITLE)
+ -- Function File: C = questdlg (MESSAGE, TITLE, DEFAULT)
+ -- Function File: C = questdlg (MESSAGE, TITLE, BTN1, BTN2, DEFAULT)
+ -- Function File: C = questdlg (MESSAGE, TITLE, BTN1, BTN2, BTN3,
+ DEFAULT)
+ \r Displays the MESSAGE using a question dialog box with a caption
+ TITLE. The dialog contains two or three buttons which all close
+ the dialog. It returns the caption of the activated button.\r \r
+ If only MESSAGE and TITLE are specified, three buttons with the
+ default captions "Yes",\r "No", "Cancel" are used.\r The string
+ DEFAULT identifies the default button, which is activated by
+ pressing the ENTER key. It must match one of the strings given in
+ BTN1, BTN2 or BTN3. If only two button captions BTN1 and BTN2 are
+ specified, the dialog will have only these two buttons. \r \r \r
+ Examples: The first example shows a dialog box with two buttons,
+ whereas the next example demonstrates the use of three buttons. \r
+ Octave > questdlg('Select your gender', 'Sex', ... \r
+ 'Male', 'Female', 'Female'); \r
+ \r \0\b[image src="images/image008.png"\0\b]\r \r
+ Octave > questdlg('Select your gender', 'Sex', ... \r
+ 'Male', 'dont know', 'Female', 'Female'); \r
+ \r \0\b[image src="images/image009.png"\0\b]\r \r
+
+ *See also:* *note errordlg: doc-errordlg,\r *note
+ helpdlg: doc-helpdlg,\r *note inputdlg: doc-inputdlg,\r
+ *note listdlg: doc-listdlg,\r *note warndlg:
+ doc-warndlg.\r
+ \r
+
+\1f
+File: octave-java.info, Node: warndlg, Next: How to distinguish between Octave and Matlab?, Prev: questdlg, Up: Top
+
+3.20 warndlg
+============
+
+\r
+
+ -- Function File: F = warndlg (MESSAGE)
+ -- Function File: F = warndlg (MESSAGE, TITLE)
+ \r Displays a MESSAGE using a warning dialog box. The TITLE can be
+ used optionally to decorate the dialog caption instead of the
+ default title "Warning Dialog". \r \r Examples: The first example
+ shows a dialog box with default caption, whereas the second
+ example specifies a caption text of its own. The second example
+ also demonstrates how a character \r according to the TeX symbol
+ set can be specified. It is important to include a space
+ character\r after the symbol code. The \n character can be used to
+ start a new line. \r The third example shows an alternate way to
+ embed the newline character (the newline character has the ASCII
+ code 10) into the string.\r Please refer to the Octave manual for
+ the difference between single and double quoted\r strings.\r \r
+ Octave > warndlg('An expected warning occured'); \r
+ Octave > warndlg('I \heartsuit Octave!\nEven if I hate her sometimes.', ...\r
+ 'Confession');\r
+ Octave > warndlg(['I \heartsuit Octave!',10, ...\r
+ ' Even if I hate her sometimes.'], ...\r
+ 'I Confess');\r
+ \r \0\b[image src="images/image003.png"\0\b]\r \r
+
+ *See also:* *note errordlg: doc-errordlg,\r *note
+ helpdlg: doc-helpdlg,\r *note inputdlg: doc-inputdlg,\r
+ *note listdlg: doc-listdlg,\r *note questdlg:
+ doc-questdlg.\r
+ \r
+
+4 FAQ - Frequently asked Questions
+**********************************
+
+\1f
+File: octave-java.info, Node: How to distinguish between Octave and Matlab?, Next: How to make Java classes available?, Prev: warndlg, Up: Top
+
+4.1 How to distinguish between Octave and Matlab?
+=================================================
+
+\r Octave and Matlab are very similar, but handle Java slightly
+different. Therefore it may be necessary to detect the environment and
+use the appropriate functions. The following function can be used to
+detect the environment. Due to the persistent variable it can be called
+repeatedly without a heavy performance hit. \r \r Example: \r
+ %% \r
+ %% Return: true if the environment is Octave. \r
+ %% \r
+ function ret = isOctave \r
+ persistent retval; % speeds up repeated calls \r
+ \r
+ if isempty(retval)\r
+ retval = (exist('Octave_VERSION','builtin') > 0); \r
+ end \r
+ \r
+ ret = retval; \r
+ end \r
+ \r
+
+\1f
+File: octave-java.info, Node: How to make Java classes available?, Next: How to create an instance of a Java class?, Prev: How to distinguish between Octave and Matlab?, Up: Top
+
+4.2 How to make Java classes available to Octave?
+=================================================
+
+\r Java finds classes by searching a CLASSPATH. This is a list of Java
+archive files and/or directories containing class files.\r In Octave
+and Matlab the CLASSPATH is composed of two parts:\r
+ * the STATIC CLASSPATH is initialized once at startup of the JVM,
+ and\r
+
+ * the DYNAMIC CLASSPATH which can be modified at runtime.\r
+ Octave searches the STATIC CLASSPATH first, then the DYNAMIC
+CLASSPATH.\r Classes appearing in the STATIC as well as in the DYNAMIC
+CLASSPATH will therefore be found in the STATIC CLASSPATH and loaded
+from this location.\r
+\r Classes which shall be used regularly or must be available to all
+users should be \r added to the STATIC CLASSPATH. \r The STATIC
+CLASSPATH is populated once from the contents of a plain text file
+named `classpath.txt' when the Java Virtual Machine starts. This file
+contains one line for each individual classpath to be added to the
+STATIC CLASSPATH.\r These lines can identify single class files,
+directories containing class files or Java archives with complete class
+file hierarchies.\r Comment lines starting with a `#' or a `%'
+character are ignored.\r \r The search rules for the file
+`classpath.txt' are:\r
+ * First, Octave searches for the file `classpath.txt' in your home
+ directory,\r If such a file is found, it is read and defines the
+ initial STATIC CLASSPATH.\r Thus it is possible to build an
+ initial static classpath on a 'per user' basis.\r \r
+
+ * Next, Octave looks for another file `classpath.txt' in the package
+ installation directory.\r This is where `javaclasspath.m' resides,
+ usually something like `...\share\Octave\packages\java-1.2.8'. \r
+ You can find this directory by executing the command\r
+ pkg list\r
+ If this file exists, its contents is also appended to the static
+ classpath.\r Note that the archives and class directories defined
+ in this file will affect all users.\r
+ \r Classes which are used only by a specific script should be placed
+in the DYNAMIC CLASSPATH. This portion of the classpath can be modified
+at runtime using the `javaaddpath' and `javarmpath' functions. \r \r
+Example: \r
+ Octave > base_path = 'C:/Octave/java_files'; \r
+ \r
+ Octave > % add two JARchives to the dynamic classpath \r
+ Octave > javaaddpath([base_path, '/someclasses.jar']); \r
+ Octave > javaaddpath([base_path, '/moreclasses.jar']); \r
+ \r
+ Octave > % check the dynamic classpath \r
+ Octave > p = javaclasspath; \r
+ Octave > disp(p{1}); \r
+ C:/Octave/java_files/someclasses.jar\r
+ Octave > disp(p{2}); \r
+ C:/Octave/java_files/moreclasses.jar\r
+ \r
+ Octave > % remove the first element from the classpath \r
+ Octave > javarmpath([base_path, '/someclasses.jar']); \r
+ Octave > p = javaclasspath; \r
+ Octave > disp(p{1}); \r
+ C:/Octave/java_files/moreclasses.jar\r
+ \r
+ Octave > % provoke an error\r
+ Octave > disp(p{2}); \r
+ error: A(I): Index exceeds matrix dimension. \r
+ \r Another way to add files to the DYNAMIC CLASSPATH exclusively for
+your user account is to use the file `.octaverc' which is stored in
+your home directory.\r All Octave commands in this file are executed
+each time you start a new instance of Octave. \r The following example
+adds the directory `octave' to Octave's search path and \r the archive
+`myclasses.jar' in this directory to the Java search path.\r
+ % content of .octaverc:\r
+ addpath('~/octave');\r
+ javaaddpath('~/octave/myclasses.jar');\r
+ \r
+
+\1f
+File: octave-java.info, Node: How to create an instance of a Java class?, Next: How can I handle memory limitations?, Prev: How to make Java classes available?, Up: Top
+
+4.3 How to create an instance of a Java class?
+==============================================
+
+\r If your code shall work under Octave as well as Matlab you should
+use the function `javaObject' to create Java objects. The function
+`java_new' is Octave specific and does not exist in the Matlab
+environment.\r \r Example 1, suitable for Octave but not for Matlab: \r
+ Passenger = java_new('package.FirstClass', row, seat);\r
+ \r Example 2, which works in Octave as well as in Matlab: \r
+ Passenger = javaObject('package.FirstClass', row, seat);\r
+ \r
+
+\1f
+File: octave-java.info, Node: How can I handle memory limitations?, Next: How to compile the java package in Octave?, Prev: How to create an instance of a Java class?, Up: Top
+
+4.4 How can I handle memory limitations?
+========================================
+
+\r In order to execute Java code Octave creates a Java Virtual Machine
+(JVM). Such a JVM allocates a fixed amount of initial memory and may
+expand this pool up to a fixed maximum memory limit. The default values
+depend on the Java version (see *note javamem: doc-javamem.).\r The
+memory pool is shared by all Java objects running in the JVM.\r This
+strict memory limit is intended mainly to avoid that runaway
+applications inside web browsers or in enterprise servers can consume
+all memory and crash the system. \r When the maximum memory limit is
+hit, Java code will throw exceptions so that applications will fail or
+behave unexpectedly.\r \r In Octave as well as in Matlab, you can
+specify options for the creation of the JVM inside a file named
+`java.opts'. \r This is a text file where you can enter lines
+containing `-X' and `-D' options handed to the JVM during
+initialization. \r \r In Octave, the Java options file must be located
+in the directory where `javaclasspath.m' resides, i.e. the package
+installation directory, usually something like
+...\SHARE\OCTAVE\PACKAGES\JAVA-1.2.8. You can find this directory by
+executing \r
+ pkg list\r
+ \r In Matlab, the options file goes into the MATLABROOT/BIN/ARCH
+directory or in your personal Matlab startup directory (can be
+determined by a `pwd' command). MATLABROOT is the Matlab root directory
+and ARCH is your system architecture, which you find by issuing the
+commands `matlabroot' respectively `computer('arch')'.\r \r The `-X'
+options allow you to increase the maximum amount of memory available to
+the JVM to 256 Megabytes by adding the following line to the
+`java.opts' file: \r
+ -Xmx256m \r
+ \r The maximum possible amount of memory depends on your system. On
+a Windows system with 2 Gigabytes main memory you should be able to set
+this maximum to about 1 Gigabyte.\r \r If your application requires a
+large amount of memory from the beginning, you can also specify the
+initial amount of memory allocated to the JVM. Adding the following
+line to the `java.opts' file starts the JVM with 64 Megabytes of
+initial memory:\r
+ -Xms64m \r
+ \r For more details on the available `-X' options of your Java
+Virtual Machine issue the command `java -X' at the operating system
+command prompt and consult the Java documentation.\r \r \r The `-D'
+options can be used to define system properties which can then be used
+by Java classes inside Octave. System properties can be retrieved by
+using the `getProperty()' methods of the `java.lang.System' class. The
+following example line defines the property MYPROPERTY and assigns it
+the string `12.34'. \r
+ -DMyProperty=12.34\r
+ The value of this property can then be retrieved as a string by a
+Java object or in Octave:\r
+ Octave > javaMethod('java.lang.System', 'getProperty', 'MyProperty');\r
+ ans = 12.34\r
+ \r
+
+*See also:* *note javamem: doc-javamem.\r \r
+
+\1f
+File: octave-java.info, Node: How to compile the java package in Octave?, Next: Which TeX symbols are implemented in the dialog functions?, Prev: How can I handle memory limitations?, Up: Top
+
+4.5 How to compile the java package in Octave?
+==============================================
+
+\r Most Octave installations come with the JAVA package pre-installed.
+In case you want to replace this package with a more recent version,
+you must perform the following steps: \r \r
+
+4.5.1 Uninstall the currently installed package JAVA
+----------------------------------------------------
+
+Check whether the JAVA package is already installed by issuing\r the
+`pkg list' command:\r
+ Octave > pkg list\r
+ Package Name | Version | Installation directory\r
+ --------------+---------+-----------------------\r
+ java *| 1.2.8 | /home/octavio/octave/java-1.2.8\r
+ Octave > \r
+ \r If the JAVA package appears in the list you must uninstall it
+first by issuing the command \r
+ Octave > pkg uninstall java\r
+ Octave > pkg list\r
+ \r Now the java package should not be listed anymore. If you have
+used the JAVA package during the current session of Octave, you have to
+exit and restart Octave before you can uninstall the package. This is
+because the system keeps certain libraries in memory after they have
+been loaded once.\r \r
+
+4.5.2 Make sure that the build environment is configured properly
+-----------------------------------------------------------------
+
+The installation process requires that the environment variable
+`JAVA_HOME' points to the Java Development Kit (JDK) on your computer.
+\r \r
+ * Note that JDK is not equal to JRE (Java Runtime Environment). The
+ JDK home directory contains subdirectories with include, library
+ and executable files which are required to compile the JAVA
+ package. These files are not part of the JRE, so you definitely
+ need the JDK. \r
+
+ * Do not use backslashes but ordinary slashes in the path. \r
+ \r Set the environment variable `JAVA_HOME' according to your local
+JDK installation. Please adapt the path in the following examples
+according to the JDK installation on your system.
+\r If you are using a Windows system that might be: \r
+ Octave > setenv("JAVA_HOME","C:/Java/jdk1.6.0_21");\r
+ Note, that on both system types, Windows as well as Linux, you must
+use the forward slash '/' as the separator, not the backslash '\'.\r \r
+If you are using a Linux system this would look probably more like: \r
+ Octave > setenv("JAVA_HOME","/usr/local/jdk1.6.0_21");\r
+ \r
+
+4.5.3 Compile and install the package in Octave
+-----------------------------------------------
+
+If you have for example saved the package archive on your Z: drive the
+command would be: \r
+ Octave> pkg install -verbose z:/java-1.2.8.tar.gz\r
+ or if you have Linux and the package file is stored in your home
+directory: \r
+ Octave > pkg install -verbose ~/java-1.2.8.tar.gz\r
+ The option `-verbose' will produce some lengthy output, which should
+not show any errors \r (maybe a few warnings at best). \r \r You can
+then produce a list of all installed packages: \r
+ Octave > pkg list\r
+ \r This list of packages should now include the package JAVA:\r
+ Octave > pkg list\r
+ Package Name | Version | Installation directory\r
+ --------------+---------+-----------------------\r
+ java *| 1.2.8 | /home/octavio/octave/java-1.2.8\r
+ Octave > \r
+ \r
+
+4.5.4 Test the java package installation
+----------------------------------------
+
+\r The following code creates a Java string object, which however is
+automatically converted to an Octave string:\r
+ Octave > s = javaObject('java.lang.String', 'Hello OctaveString') \r
+ s = Hello OctaveString \r
+ \r Note that the java package automatically transforms the Java
+String object to an Octave string. This means that you cannot apply
+Java String methods to the result. \r \r This "auto boxing" scheme
+seems to be implemented for the following Java classes: \r
+ * java.lang.Integer\r
+
+ * java.lang.Double \r
+
+ * java.lang.Boolean \r
+
+ * java.lang.String \r
+ \r If you instead create an object for which no "auto-boxing" is
+implemented, `javaObject' returns the genuine Java object: \r
+ Octave > v = javaObject('java.util.Vector') \r
+ v = \r
+ <Java object: java.util.Vector> \r
+ Octave > v.add(12); \r
+ Octave > v.get(0) \r
+ ans = 12 \r
+ \r If you have created such a Java object, you can apply all methods
+of the Java class to the returned object. Note also that for some
+objects you must specify an initializer: \r
+ % not: \r
+ Octave > d = javaObject('java.lang.Double') \r
+ error: [java] java.lang.NoSuchMethodException: java.lang.Double \r
+ % but: \r
+ Octave > d = javaObject('java.lang.Double',12.34) \r
+ d = 12.340 \r
+ \r
+
+\1f
+File: octave-java.info, Node: Which TeX symbols are implemented in the dialog functions?, Prev: How to compile the java package in Octave?, Up: Top
+
+4.6 Which TeX symbols are implemented in the dialog functions?
+==============================================================
+
+\r The dialog functions contain a translation table for TeX like symbol
+codes. Thus messages and labels can be tailored to show some common
+mathematical symbols or Greek characters. No further TeX formatting
+codes are supported. The characters are translated to their Unicode
+equivalent. However, not all characters may be displayable on your
+system. This depends on the font used by the Java system on your
+computer.\r \r Each TeX symbol code must be terminated by a space
+character to make it distinguishable from the surrounding text.
+Therefore the string `\alpha =12.0' will produce the desired result,
+whereas `\alpha=12.0' would produce the literal text '\ALPHA=12.0'.\r \r
+
+*See also:* *note errordlg: doc-errordlg,\r *note helpdlg:
+doc-helpdlg,\r *note inputdlg: doc-inputdlg,\r *note
+listdlg: doc-listdlg,\r *note msgbox: doc-msgbox,\r
+*note questdlg: doc-questdlg,\r *note warndlg: doc-warndlg.\r
+\r \r \r
+
+Index
+=====
+
+\r
+
+\0\b[index\0\b]
+* Menu:
+
+* array, creating a Java array: javaArray. (line 6)
+* available functions: Top. (line 29)
+* calling Java from Octave: Top. (line 6)
+* calling Octave from Java: Top. (line 16)
+* classes, making available to Octave: How to make Java classes available?.
+ (line 6)
+* classpath, adding new path: javaaddpath. (line 6)
+* classpath, difference between static and dynamic: How to make Java classes available?.
+ (line 6)
+* classpath, displaying: javaclasspath. (line 8)
+* classpath, dynamic <1>: javaaddpath. (line 6)
+* classpath, dynamic: javaclasspath. (line 8)
+* classpath, removing path: javarmpath. (line 6)
+* classpath, setting: How to make Java classes available?.
+ (line 6)
+* classpath, static: javaclasspath. (line 8)
+* classpath.txt: How to make Java classes available?.
+ (line 6)
+* compiling the java package, how?: How to compile the java package in Octave?.
+ (line 6)
+* dialog, displaying a help dialog: helpdlg. (line 6)
+* dialog, displaying a list dialog: listdlg. (line 6)
+* dialog, displaying a question dialog: questdlg. (line 6)
+* dialog, displaying a warning dialog <1>: warndlg. (line 6)
+* dialog, displaying a warning dialog: msgbox. (line 6)
+* dialog, displaying an error dialog: errordlg. (line 6)
+* dialog, displaying an input dialog: inputdlg. (line 6)
+* dynamic classpath <1>: How to make Java classes available?.
+ (line 6)
+* dynamic classpath: javaclasspath. (line 8)
+* dynamic classpath, adding new path: javaaddpath. (line 6)
+* field, returning value of Java object field: java_get. (line 6)
+* field, setting value of Java object field: java_set. (line 6)
+* fields, displaying available fields of a Java object: javafields.
+ (line 6)
+* functions, available in the package java: Top. (line 29)
+* instance, how to create: How to create an instance of a Java class?.
+ (line 6)
+* java package, how to compile?: How to compile the java package in Octave?.
+ (line 6)
+* java package, how to install?: How to compile the java package in Octave?.
+ (line 6)
+* java package, how to uninstall?: How to compile the java package in Octave?.
+ (line 6)
+* Java, calling from Octave: Top. (line 6)
+* Java, using with Octave: Top. (line 6)
+* memory, displaying Java memory status: javamem. (line 6)
+* memory, limitations: How can I handle memory limitations?.
+ (line 6)
+* method, invoking a method of a Java object <1>: java_invoke. (line 6)
+* method, invoking a method of a Java object: javaMethod. (line 6)
+* methods, displaying available methods of a Java object: javamethods.
+ (line 6)
+* object, creating a Java object <1>: java_new. (line 6)
+* object, creating a Java object: javaObject. (line 6)
+* object, how to create: How to create an instance of a Java class?.
+ (line 6)
+* Octave and Matlab, how to distinguish between: How to distinguish between Octave and Matlab?.
+ (line 6)
+* Octave, calling from Java: Top. (line 16)
+* package java, available functions: Top. (line 29)
+* package, how to compile?: How to compile the java package in Octave?.
+ (line 6)
+* path, adding to classpath: javaaddpath. (line 6)
+* path, removing from classpath: javarmpath. (line 6)
+* static classpath <1>: How to make Java classes available?.
+ (line 6)
+* static classpath: javaclasspath. (line 8)
+* symbols, translation table: Which TeX symbols are implemented in the dialog functions?.
+ (line 6)
+* TeX symbols, translation table: Which TeX symbols are implemented in the dialog functions?.
+ (line 6)
+* translation table for TeX symbols: Which TeX symbols are implemented in the dialog functions?.
+ (line 6)
+* using Octave with Java: Top. (line 6)
+
+ \r
+
+
+\1f
+Tag Table:
+Node: Top\7f87
+Node: javaclasspath\7f2609
+Ref: doc-javaclasspath\7f2739
+Node: javaaddpath\7f4789
+Ref: doc-javaaddpath\7f4919
+Node: javarmpath\7f5818
+Ref: doc-javarmpath\7f5940
+Node: javamem\7f6642
+Ref: doc-javamem\7f6756
+Node: javaArray\7f9286
+Ref: doc-javaArray\7f9404
+Node: javaObject\7f10242
+Ref: doc-javaObject\7f10363
+Node: java_new\7f11628
+Ref: doc-java_new\7f11746
+Node: javaMethod\7f12376
+Ref: doc-javaMethod\7f12499
+Node: java_invoke\7f13225
+Ref: doc-java_invoke\7f13350
+Node: java_get\7f14123
+Ref: doc-java_get\7f14242
+Node: java_set\7f14859
+Ref: doc-java_set\7f14978
+Node: javamethods\7f15629
+Ref: doc-javamethods\7f15756
+Node: javafields\7f16975
+Ref: doc-javafields\7f17098
+Node: msgbox\7f18392
+Ref: doc-msgbox\7f18504
+Node: errordlg\7f19854
+Ref: doc-errordlg\7f19967
+Node: helpdlg\7f20771
+Ref: doc-helpdlg\7f20884
+Node: inputdlg\7f22115
+Ref: doc-inputdlg\7f22229
+Node: listdlg\7f24956
+Ref: doc-listdlg\7f25069
+Node: questdlg\7f27274
+Ref: doc-questdlg\7f27388
+Node: warndlg\7f28988
+Ref: doc-warndlg\7f29138
+Node: How to distinguish between Octave and Matlab?\7f30751
+Ref: doc-FAQ\7f31002
+Node: How to make Java classes available?\7f31650
+Node: How to create an instance of a Java class?\7f35404
+Node: How can I handle memory limitations?\7f36140
+Node: How to compile the java package in Octave?\7f39263
+Node: Which TeX symbols are implemented in the dialog functions?\7f44056
+\1f
+End Tag Table
+
+\1f
+Local Variables:
+coding: utf-8
+End:
git://git.creatis.insa-lyon.fr / CreaPhase.git / blobdiff