2.4.4 (2023-08-14)

Patch Release

  • Converting Excel argument and return values to and from java.time.LocalDate and java.time.LocalDateTime now works with dates prior to 1970.

2.4.3 (2023-03-29)

Patch Release

  • Querying the com.exceljava.jinx package version using Package.getImplementationVersion() would work corectly for Java 8 and below but return null when using Java 9 or above. This has been fixed to work for all Java runtime versions.

2.4.2 (2022-10-07)

Patch Release

  • Fix an issue where Java methods with variable arguments (varargs) wouldn’t behave correctly if there were no argument annotations.

  • 2d arrays passed as varargs were incorrectly being flattened to 1d arrays.

2.4.1 (2022-05-24)

Patch Release

  • Fix a performance problem in certain situations when loading resources.

  • Added a new option library_path in the [JAVA] section of the jinx.ini file to allow setting the paths to load native libraries from. Unlike the -Djava.library.path JVM option, paths specified using this new setting can be relative paths (relative to the jinx.ini file).

2.4.0 (2021-09-24)

New Features

  • Log Rolling.

    Jinx can automatically roll its log file to avoid long running Excel processes generating huge log files. This is controlled by some new options in the [LOG] section of the jinx.ini file.

    See Logging Config for details.

Improvements

  • Improved performance of resizing and formatting multiple arrays. The old style (CSE) Array resizing and formatting is now batched to avoid disabling and re-enabling Excel’s auto-calc mode repeatedly. This does not affect dynamic arrays.

  • ExcelAddIn.getExcelApplication() would occasionally cause Excel to crash if called outside of a macro or menu function due to a bug in the internal Excel C API function xlGetHwnd used. A work-around has been created for this to avoid using that API function in situations where it may fail.

2.3.2 (2021-09-03)

Patch Release

  • Fix an issue where argument converters for a registered type weren’t being correctly applied when calling methods taking an array of that registered type.

2.3.1 (2021-04-20)

Patch Release

  • Missing parameters are passed to Java methods as null (where possible), but for ExcelReference an error was being thrown instead. This is now fixed and ExcelReference parameters will be passed a null value if the Excel argument is missing.

2.3.0 (2021-04-16)

Improvements

  • Custom return type conversions now work automatically with RTD functions.

    Functions returning Rtd<T> where the T type has a registered return type conversion function will now get the Rtd value converted automatically when notifying Excel of an updated value.

  • Demote errors caused by user inputs or exceptions raised by user Java methods to warnings instead of critical errors.

  • Improve handling of unicode paths in the jinx.ini config file.

Fixes

  • Fix a nullptr exception that would occur when an input to an Rtd function in Excel was changed to an empty cell.

2.2.0 (2020-11-19)

New Features

  • New option to recalculate cells when opening a workbook.

    @ExcelFunction has a new option, recalculateOnOpen. If set any cell using that function in a saved workbook will be recalculated when the workbook is opened.

Improvements

  • Rtd objects can be re-used.

    RTD objects can be re-used between Excel functions, allowing a single RTD object to be returned from multiple calls to the same, or other, functions.

    This simplifies cases where an RTD object is a singleton, or global instance, that may be returned multiple times in the same workbook.

  • Two new environment variables JINX_LICENSE_KEY and JINX_LICENSE_FILE can be used to configure the license key instead of putting it in the jinx.ini config file.

Changes

  • The software license agreement has been updated.

    See Terms and Conditions or the software license agreement PDF file included in the Jinx download for details.

  • Free version is more limited.

    The free version of Jinx now only includes up to five worksheet functions and macros and does not include RTD functions or functions that use the object cache.

2.1.3 (2020-11-06)

Patch Release

  • Don’t revert to the free or evaluation mode if a license file becomes unavailable after Excel has started.

2.1.2 (2020-07-03)

Patch Release

  • Fixed an issue to do with resource loading after reloading Jinx.

    When reloading and using a shadow path for class loading, after rebuilding a JAR and reloading Jinx the resources would still be loaded from the old JAR file. This has been fixed and the updated JAR file is now used when loading resources.

2.1.1 (2020-03-02)

Patch Release

  • Fix regression in passing cached objects to methods with argument type Object.

2.1.0 (2020-03-02)

New Features

New Features:

  • New setting startup_script added.

    Run a script when Excel starts, before Java is initialized. This can be used to script deployment of JAR files or other resources needed by the add-in.

    See Startup Script for details.

  • Type converters for generic array types.

    It is now possible to write write generic argument and return converts that work with arrays.

    See Generic Type Converters.

Improvements

  • Auto-resizing of CSE arrays is now still enabled even when Excel dynamic arrays are available.
  • Object cache now updates correctly when inserting or removing rows and columns.
  • Trap JVM attempting to shut down the process if the JVM initialization fails.

Notes

  • MinHook has been added to the open source components used by the Jinx Excel Add-in. Please see Open Source Notices for license details.

2.0.1 (2019-12-10)

Fixes

  • Fixed a problem that would cause ribbon actions @ExcelAction using instance (non-static) methods to crash Excel.

  • Automatic reloading is now triggered by changes to all files within folders listed on the classpath, not just files (i.e. now it works when specifying a folder of .class files as well as .jar files).

2.0.0 (2019-11-13)

New Features

  • Added ribbon support.

    The Excel ribbon can be customized with an XML resource, file or in code.

    See Ribbon Toolbars for details.

  • Automatic reloading.

    The Jinx add-in can now (optionally) reload automatically if any of the JARs or class files are updated.

    See Reloading for details.

  • Improved error handling.

    Error handling can now be customized via the ErrorHandler interface.

    See Error Handling for details.

  • Added ExcelReference.setValue(java.lang.Object) for setting values from a macro.

    This can be used in conjunction with ExcelAddIn.getReference(IUnknown) for writing values from a macro back to Excel. The Java values are converted to Excel types where possible, and where not possible the objects are cached and object handles written instead.

  • New form for @ExcelArgumentConverter.

    Argument converters can now (optionally) be generic methods using a bounded type parameter T. When used in this form as second arguement of type Class<T> is expected. This is used for argument converters that can convert to multiple types matching the bounded type parameter.

  • License renewals can now be downloaded automatically.

    If an internet connection is available, on renewal the new license key will be downloaded automatically. This avoids having to update the license key in the jinx.ini config file manually.

    If no internet connection is available, or the connection to the license server is blocked by a firewall, everything will work as before and the license key may still be updated manually.

Improvements

Fixes

  • Fixed an issue with loading multiple Jinx add-ins into the same Excel process.

1.6.4 (2019-10-18)

Fixes

1.6.3 (2019-09-03)

Fixes

  • The java_home setting can now be a relative path (relative to the jinx.ini config file).

1.6.2 (2019-08-09)

Fixes

  • Fixed an unusual edge case where the object cache would stop evicting objects after they were no longer required, causing the objects to never be collected.

  • Logging large (>1Mb) messages as a single line would cause a stack overflow error. These are now able to be handled without error.

  • Certain types of strings would cause issues when logged from Java and wouldn’t appear correctly in the log file. All strings logged from Java are now logged corrected.

1.6.1 (2019-06-26)

Fixes

  • Fix an issue where volatile cells could be continuously recalculated when also using cached objects.

1.6.0 (2019-05-29)

New Features

Improvements

  • @ExcelFunction takes a transpose option for returning 1d arrays as rows instead of columns.

  • Added built-in support for java.sql.Date, java.sql.Time and java.sql.Timestamp types.

  • Array resizing is suppressed for functions called as a nested function. For example, if a function inner is set to auto-resize, if called as =SUM(inner(A1)) it will not automatically resize the range it was called from.

    If the outer function is set to automatically resize, it will resize as before regardless of any nested functions.

Fixes

  • Fixed timezone issue when converting dates to/from Excel.

  • The jinx.ini config file would not be found if it was read-only. Now read-only config files are read correctly.

1.5.0 (2019-01-28)

New Features

  • Classes with Excel features via annotation may now be loaded and scanned programmatically.

    The new ExcelAddIn.scan() methods can be used to scan one or more classes for annotated methods, and the new ExcelAddIn.rebind() method creates the Excel bindings for those methods.

  • When Jinx discovers non-static annotated methods while scanning classes, when necessary it will create instances of those classes. Any of those instances implementing the AutoCloseable interface (requires Java 7 or greater) are now closed when reloading the add-in.

  • ExcelAddIn.getClassLoader(boolean) is a new overload for getting both the reloadable ClassLoader and non-reloadable ClassLoader. If any classes are specified as being non-reloadable, they are loaded by the non-reloadable ClassLoader. The reloadable ClassLoader is replaced each time the add-in is reloaded, but the non-reloadable one is not.

  • ExcelAddIn.getShadowPath() is a new method for getting the path where the ClassLoaders copy jars and class files to. This may be used if implementing your own dynamic class loading.

  • New method ExcelAddIn.getCachedObjectsCount() added to check the number of cached objects.

  • The array resizing feature is now disabled automatically if the version of Excel being used supports dynamic arrays.

    This means no user code or config changes are required to be able to support add-ins being used in newer versions of Excel that are still also being used in older versions.

    The automatic disabling of the auto_resize behaviour can be turned off by the following config setting

    [JINX]
allow_auto_resizing_with_dynamic_arrays = 1

Improvements

  • Values in the ini file using substitutions can now specify defaults. For example, %(JINX_LOG_LEVEL:fine)s would use the JINX_LOG_LEVEL environment variable if set, otherwise it defaults to fine.

  • Classes with a public constructor taking an ExcelAddIn as a single parameter are now always constructed when scanning classes. Previously they would only be constructed if a non-static annotated method was found. This can be used to call user-code when Jinx is starting or reloading (for example, to dynamically load and scan other classes).

  • RTD functions can now safely be called multiple times in a single formula in the same cell.

Fixes

  • A potential conflict when both Jinx and PyXLL (the Python Excel Add-In) add-ins are installed together was identified and has been resolved.

  • Fixed an error that would occur when trying to auto-resize an array function on a sheet with an “’” in the sheet name.

  • Fix small memory leak in object cache.

  • A Java object reference leak when returning arrays of Objects has been fixed.

1.4.1 (2018-11-15)

Improvements

  • Reduced overhead of disabling calculations in the function wizard using the option ‘disableInFunctionWizard’ to @ExcelFunction.

Fixes

  • Classes loaded dynamically (e.g. using Guava’s ClassPath utilities) no longer cause a LinkageError if loaded twice.

  • Invalid and/or missing paths in the classpath are logged as warnings and ignored, rather that stopping the add-in from loading.

  • Classes listed in the config that can’t be logged as errors and skipped, allowing the rest of the classes to continue to be loaded without causing the add-in to fail from being loaded altogether.

1.4.0 (2018-08-29)

New Features

  • Added option ‘disableInFunctionWizard’ to @ExcelFunction to prevent selected methods from being called when in the Excel function wizard. This can be used for slow functions that cause Excel to become unresponsive, but it does add a small overhead to the function call and so should not be used with functions that are to be called a large number of time.

  • Added ‘notifyError’ method to Rtd. This can be used to send errors back to Excel from a real time data object.

  • Methods with variable numbers of arguments can be used as Excel functions. Exposing a Java method to Excel with a variable number of arguments using @ExcelFunction will now result in an Excel function that takes a variable number of arguments.

Improvements

  • Attempting to register an Rtd function as ‘thread safe’ will now log a warning and disregard the isThreadSafe option. This is because Rtd functions only work when called from the main thread. Previously registering an Rtd function as thread-safe would have resulted in an error when calling the function.

Fixes

  • Fix problem where alerts would sometimes not be re-enabled after resizing an array formula. This resulted in the user not seeing a confirm dialog when closing Excel.

  • Unregister menus and functions when Jinx is removed via the Add-Ins Excel menu.

1.3.1 (2018-08-15)

Patch Release.

  • Fix bug in the 32 bit build that affected some functions taking boolean or short parameters.

1.3.0 (2018-08-03)

New Features

  • Real time data (RTD) support. User defined functions can return an Rtd object that streams real time data back to Excel. See Real Time Data for details.

  • ‘treatErrorsAsNull’ option added to @ExcelFunction annotation. If set, if the argument in Excel is an error (eg. #N/A) then the value passed to the Java method will be null.

Improvements

  • Class loader now supports loading class files as well as JARs.

    In the classpath in the jinx config file you can specify a folder containing class files as well as JAR paths.

    When using the ‘shadow_path’ setting, any folders listed on the classpath will be recursively copied to the shadow path.

1.2.2 (2018-07-25)

Patch Release.

  • Fix conversion error for dates after 2038 in the 32 bit build (64 bit build was not affected).

1.2.1 (2018-07-05)

Patch Release.

  • Fix problem when passing #N/A to a method expecting an Object. Previously a NoClassDefFoundError exception would be thrown, but now #N/A is converted to java.util.NoSuchElementException.

1.2.0 (2018-07-03)

Improvements

  • Jagged (non-rectangular) arrays are now supported.

    When returning a 2d array, if not all the rows are the same length Jinx will pad them with #N/A.

1.1.0 (2018-06-18)

New Features

  • New config options reload_exclude and reload_include.

    Reloading Jinx works by creating a new ClassLoader each time the add-in is reloaded and loading the classes again. This can cause problems for some classes that have internal state in native DLLs which prevents them from reloading cleanly.

    To ensure user code can be reloaded properly, these problematic classes can now be excluded when reloading. These excluded classes are loaded in a separate ClassLoader that is never replaced.

    The example config shows how to exclude the Microsoft SQLServer JDBC classes, which are known to not reload cleanly.

    [JINX]
reload_exclude =
    com.microsoft.sqlserver.jdbc.*
    microsoft.sql.*
    mssql.*

1.0.2 (2018-06-07)

Patch release.

  • Fixed problem when configuring JVM with additional user options.

1.0.1 (2018-05-30)

Patch release.

  • Fixed problem when registering multiple macro functions.

1.0.0 (2018-05-16)

First non-beta release.

  • Example project and workbook added.
  • Added isHidden parameter to @ExcelFunction annotation.
  • Added getExcelAddin method to ExcelAddIn interface.
  • Primitive wrapper class parameters are passed null if the Excel argument is missing.
  • Embedded jar now has its package defined correctly.
  • Fixed problem when mixing static and instance methods.

0.2.2 (2018-04-11)

  • Improved speed of loading and reloading when using 1000s of functions.
  • Added ‘about’ dialog box.

0.2.1 (2018-04-06)

  • Fixed a problem where if no classes were specified in the config file then the developer tools and any classes specified in jar resources weren’t loaded.

0.2.0 (2018-03-27)

  • Added new ‘reload’ feature that reloads all classes allowing for development without restarting Excel. Accessed via the Jinx menu under Addins, or via the ExcelAddIn.reload method.
  • Added ‘shadow_path’ config option for coping Jars to a shadow directory before loading them. This means the original ones can be overwritten or deleted while Excel is still running.
  • New @ExcelMenu annotation for adding custom Excel menus.
  • New @ExcelMacro annotation for exposing methods as Excel macros.
  • Menu option for opening the current log file using the default application.

0.1.4 (2018-02-13)

  • Fix issue with some Java 6 runtimes where native methods weren’t being recognised.
  • Redirect JVM logging to Jinx log file.
  • Change default log level from finest to fine.

0.1.3 (2018-01-29)

  • Add new @ExcelReturnConverter annotation for converting returned values to Excel types.
  • Add support for java.time.LocalTime and java.time.LocalDateTime.
  • Check for cached objects when parameter type is Object.
  • Add support for arrays of cached objects.
  • Fix problem when returning zero length arrays.
  • Minor performance improvement to array resizing.

0.1.2 (2018-01-17)

First public beta release

© Copyright PyXLL Ltd.