Dukascopy JForex API

https://www.dukascopy.com/client/javadoc3/
Admin
The Dukascopy JForex API provides interfaces for accessing trading account information, managing...
Tokens:394,704
Snippets:4,335
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
### Get Started Strategies

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/system/IClient.html

Returns a map of IDs to strategies started by the current process.

```java
java.util.Map<java.lang.Long,IStrategy> getStartedStrategies()
```

--------------------------------

### Start Strategy with Default Parameters

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/strategy/local/ILocalStrategyManager.html

Method signature and usage examples for starting a strategy using default settings.

```java
java.util.concurrent.Future<IStrategyResponse<java.util.UUID>> startStrategy(java.io.File strategyFile)
                                                                      throws java.io.IOException
```

```java
 // start a strategy without fetching the id
 strategyManager.startStrategy(jfxFile);

 // start and fetch the id
 IStrategyResponse <UUID> startResponse = strategyManager.startStrategy(jfxFile).get();
 if (startResponse.isError()) {
     System.err.println("Strategy failed to start: " + startResponse.getErrorMessage());
 } else {
     myStrategyId = startResponse.getResult();
     System.out.println("Strategy successfully started: " + myStrategyId);
 }
```

--------------------------------

### start()

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IDownloadableStrategy.html

Initializes and starts the strategy execution.

```APIDOC
## void start()

### Description
Starts the strategy. Throws JFException if an error occurs during startup.
```

--------------------------------

### Initialize History Context

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IHistory.html

Example setup for accessing history and console services within an IStrategy.

```java
 private IHistory history;
 private IConsole console;

 private Instrument instrument = Instrument.EURUSD;
 private IFeedDescriptor feedDescriptor = new RenkoFeedDescriptor(instrument, PriceRange.TWO_PIPS, OfferSide.ASK);
 private double avgPrice = 0;
 private int itemCount = 0;

  @Override
 public void onStart(final IContext context) throws JFException {
     history = context.getHistory();
     console = context.getConsole();
```

--------------------------------

### Start a strategy with custom parameters

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/strategy/remote/IRemoteStrategyManager.html

Demonstrates starting a strategy with a specific array of parameters, ensuring the array size and types match the strategy's Configurable fields.

```java
 // start a strategy without fetching the id
 strategyManager.startStrategy(jfxFile, new Object[]{"param value", 1, "another param value"});

 // start and fetch the id
 IStrategyResponse <UUID> startResponse = strategyManager.startStrategy(jfxFile, new Object[]{"param value", 1, "another param value"}).get();
 if (startResponse.isError()) {
     System.err.println("Strategy failed to start: " + startResponse.getErrorMessage());
 } else {
     myStrategyId = startResponse.getResult();
     System.out.println("Strategy successfully started: " + myStrategyId);
 }
```

--------------------------------

### Start a strategy with default parameters

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/strategy/remote/IRemoteStrategyManager.html

Demonstrates starting a strategy using a JFX file and handling the resulting Future to retrieve the strategy ID or error message.

```java
 // start a strategy without fetching the id
 strategyManager.startStrategy(jfxFile);

 // start and fetch the id
 IStrategyResponse <UUID> startResponse = strategyManager.startStrategy(jfxFile).get();
 if (startResponse.isError()) {
     System.err.println("Strategy failed to start: " + startResponse.getErrorMessage());
 } else {
     myStrategyId = startResponse.getResult();
     System.out.println("Strategy successfully started: " + myStrategyId);
 }
```

--------------------------------

### IDownloadableStrategy.start

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/class-use/JFException.html

Starts the downloadable strategy.

```APIDOC
## IDownloadableStrategy.start

### Description
Starts the execution of the downloadable strategy.

### Method
- void start()
```

--------------------------------

### Start Strategy from File

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IStrategies.html

Starts a strategy from a JFX file. This method is deprecated; use IClient.startStrategy(IStrategy) instead.

```java
@Deprecated
long	startStrategy(java.io.File	jfxFile,
                               IStrategyListener	listener,
                               java.util.Map<java.lang.String,java.lang.Object>	configurables,
                               boolean	fullAccess)
                        throws JFException
```

--------------------------------

### Get start index

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/indicators/HiLowIndicator.html

Calculates the starting index for the indicator based on the provided input parameters.

```java
public int startIndex(int si,
                      java.lang.Object[] outputValues)
```

--------------------------------

### Start Strategy Instance

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IStrategies.html

Starts a strategy instance. This method is deprecated; use IClient.startStrategy(IStrategy) instead.

```java
@Deprecated
long	startStrategy(IStrategy	strategy,
                               IStrategyListener	listener,
                               boolean	fullAccess)
                        throws JFException
```

--------------------------------

### Configurable Parameter Usage Examples

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/Configurable.html

Examples demonstrating how to apply @Configurable to various field types, including primitives, collections, and custom classes.

```java
    @Configurable(value = "int param", stepSize = 3)
    public int intParam = 1;
    @Configurable(value = "double param", stepSize = 0.5)
    public double doubleParam = 0.5;
    @Configurable("bool param")
    public boolean boolParam = true;
    @Configurable("text param")
    public String textParam = "some text";
    @Configurable("")
    public File file = new File(".");
    @Configurable(value="current time", description="default is current time")
    public Calendar currentTime = Calendar.getInstance();
    @Configurable("")
    public Color color = new Color(100, 100, 100);
    @Configurable("instrument (enum)")
    public Instrument instrument = Instrument.EURUSD;
    @Configurable("")
    public Set<Instrument> instruments = new HashSet<Instrument>(
            Arrays.asList(new Instrument[] {Instrument.EURUSD, Instrument.AUDCAD}) 
    );
    @Configurable("")
    public IFeedDescriptor renkoFeedDescriptor = new RenkoFeedDescriptor(Instrument.EURUSD, PriceRange.TWO_PIPS, OfferSide.ASK);
    
    //date/time usage possibilities
    
    private static Calendar myCalendar;
    static {
        myCalendar = Calendar.getInstance();
        myCalendar.set(2012, Calendar.JULY, 17, 14, 30, 00);
    }
    
    @Configurable(value="particular time", description="17th july 14:30")    
    public Calendar particularTime = myCalendar;
    
    private static Calendar calTodayAt5am;
    static {
        calTodayAt5am = Calendar.getInstance();
        calTodayAt5am.set(Calendar.HOUR_OF_DAY, 5);
        calTodayAt5am.set(Calendar.MINUTE, 0);
        calTodayAt5am.set(Calendar.SECOND, 0);
    }
    
    @Configurable(value="time in millis", description="default is today at 5am", datetimeAsLong=true)    
    public long timeInMillis = calTodayAt5am.getTimeInMillis();
    
    //custom enum
    
    enum Mode { 
        BUY,
        SELL,
        NONE
    }

    @Configurable("mode (enum param)")
    public Mode mode = Mode.BUY;

    //custom class with self-typed constants
    
    static class Person {
        
        public static final Person FOO = new Person("foo");
        
        public static final Person BAR = new Person("bar");
        
        public final String name;
        
        public Person(String name){
            this.name = name;
        }
        
        @Override 
        public String toString(){
            return name;
        }
    }
    
    @Configurable("")
    public Person person;
    
    @Configurable("")
    public List<Person> persons;
```

--------------------------------

### Asynchronous Bar Analysis Example

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IHistory.html

Example demonstrating how to calculate average close price and maximum bar height for the last week of 1-minute bars using readBars.

```java
 private IHistory history;
 private IConsole console;

 double maxHeight = Double.MIN_VALUE, avgClose = 0;
 int barCount, greenCount;
 private Instrument instrument = Instrument.EURUSD;
 private Period period = Period.ONE_MIN;

  @Override
 public void onStart(final IContext context) throws JFException {
     history = context.getHistory();
     console = context.getConsole();
     context.setSubscribedInstruments(Collections.singleton(instrument), true);
     long lastTickTime = history.getLastTick(instrument).getTime();
     final long from = history.getBarStart(period, lastTickTime - Period.DAILY.getInterval() * 7);
     final long to = history.getTimeForNBarsBack(period, lastTickTime, 2);

     history.readBars(instrument, period, OfferSide.BID, Filter.WEEKENDS, from, to,

     new LoadingDataListener() {
          @Override
         public void newTick(Instrument instrument, long time, double ask, double bid, double askVol, double bidVol) {}

          @Override
         public void newBar(Instrument instrument, Period period, OfferSide side, long time, double open, double close, double low, double high, double vol) {
             barCount++;
             maxHeight = Math.max(Math.abs(open - close), maxHeight);
             avgClose = barCount == 1 ? close : round(avgClose + ((close - avgClose) / (double)barCount));
             if(close - open > 0){
                 greenCount++;
             }
         }

         private double round(double amount) {
             return (new BigDecimal(amount)).setScale(instrument.getPipScale() + 1, BigDecimal.ROUND_HALF_UP).doubleValue();
         }
     },
     new LoadingProgressListener() {

          @Override
         public void dataLoaded(long start, long end, long currentPosition, String information) {
         }

          @Override
         public void loadingFinished(boolean allDataLoaded, long start, long end, long currentPosition) {
             console.getOut().format("Loaded %s %s candles (%s green, %s red) %s  - %s max bar height=%.1fpips average close=%.5f"
                     barCount, period, greenCount, barCount - greenCount, DateUtils.format(from), DateUtils.format(to), maxHeight/instrument.getPipValue(), avgClose).println();
             context.stop();
         }

          @Override
         public boolean stopJob() {
             return false;
         }
     });
 }
```

--------------------------------

### Start Strategy

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/system/ITesterClient.html

Initiates the execution of a strategy with a progress listener.

```java
long startStrategy(IStrategy strategy,
                   LoadingProgressListener testerProgressListener)
            throws java.lang.IllegalStateException,
                   java.lang.IllegalArgumentException
```

--------------------------------

### getStart()

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/ITimeDomain.html

Retrieves the start time value.

```APIDOC
## long getStart()

### Description
Returns the start time as a long value.

### Returns
- **long** - The start time.
```

--------------------------------

### Subscribe to Feed Example

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IContext.html

Example of subscribing to a Point and Figure feed.

```java
 // create type-safe descriptor
 ITailoredFeedDescriptor <IPointAndFigure> descriptor = new PointAndFigureFeedDescriptor(Instrument.EURUSD, PriceRange.THREE_PIPS, ReversalAmount.THREE, OfferSide.ASK);

 // create type-safe listener
 ITailoredFeedListener <IPointAndFigure> listener = new ITailoredFeedListener <IPointAndFigure>() {
      @Override
     public void onFeedData(ITailoredFeedDescriptor <IPointAndFigure> feedDescriptor, IPointAndFigure feedData) {
         // Print IPointAndFigure specific data without casting
         console.getOut().println(feedData.isRising());
     }
 };

 // subscribe
 context.subscribeToFeed(descriptor, listener);
```

--------------------------------

### startStrategy(IStrategy, LoadingProgressListener)

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/system/ITesterClient.html

Starts the execution of a strategy.

```APIDOC
## long startStrategy(IStrategy strategy, LoadingProgressListener testerProgressListener)

### Description
Starts the provided strategy.

### Parameters
- **strategy** (IStrategy) - The strategy to start.
- **testerProgressListener** (LoadingProgressListener) - Listener for progress updates.

### Throws
- **java.lang.IllegalStateException**
- **java.lang.IllegalArgumentException**
```

--------------------------------

### getStartTime()

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/strategy/IStrategyDescriptor.html

Retrieves the start time of the strategy on the remote server.

```APIDOC
### long getStartTime()

Returns the strategy start time on the remote server.
```

--------------------------------

### Asynchronous bar data processing example

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IHistory.html

This example demonstrates how to use readBars to process 100,000 1-minute bars asynchronously, calculating average close price and maximum bar height.

```java
 private IHistory history;
 private IConsole console;

 double maxHeight = Double.MIN_VALUE, avgClose = 0;
 int barCount, greenCount;
 private Period period = Period.ONE_MIN;

  @Override
 public void onStart(final IContext context) throws JFException {
     history = context.getHistory();
     console = context.getConsole();

     IFinancialInstrumentProvider instrumentProvider = context.getFinancialInstrumentProvider();
     final IFinancialInstrument financialInstrument = instrumentProvider.getFinancialInstrument("EUR/USD");

     context.setSubscribedFinancialInstruments(Collections.singleton(financialInstrument), true);
     long lastTickTime = history.getLastTick(financialInstrument).getTime();
     final long to = history.getTimeForNBarsBack(period, lastTickTime, 2);

     history.readBars(financialInstrument, period, OfferSide.BID, Filter.WEEKENDS, 100000, to, 0,

     new LoadingFinancialDataListener() {
          @Override
         public void newTick(IFinancialInstrument financialInstrument, long time, double ask, double bid, double askVol, double bidVol) {}

          @Override
         public void newBar(IFinancialInstrument financialInstrument, Period period, OfferSide side, long time, double open, double close, double low, double high, double vol) {
             barCount++;
             maxHeight = Math.max(Math.abs(open - close), maxHeight);
             avgClose = barCount == 1 ? close : round(avgClose + ((close - avgClose) / (double)barCount));
             if(close - open > 0){
                 greenCount++;
             }
         }

         private double round(double amount) {
             return (new BigDecimal(amount)).setScale(financialInstrument.getPipScale() + 1, BigDecimal.ROUND_HALF_UP).doubleValue();
         }
     },
     new LoadingProgressListener() {

          @Override
         public void dataLoaded(long start, long end, long currentPosition, String information) {
         }

          @Override
         public void loadingFinished(boolean allDataLoaded, long start, long end, long currentPosition) {
             console.getOut().format("Loaded %s %s candles (%s green, %s red) till %s max bar height=%.1fpips average close=%.5f",
                     barCount, period, greenCount, barCount - greenCount, DateUtils.format(to), maxHeight/financialInstrument.getPipValue(), avgClose).println();
             context.stop();
         }
```

--------------------------------

### startStrategy(java.io.File strategyFile)

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/strategy/local/ILocalStrategyManager.html

Starts a strategy using its default parameters.

```APIDOC
## startStrategy(java.io.File strategyFile)

### Description
Starts a strategy with default parameters.

### Parameters
- **strategyFile** (java.io.File) - Required - The strategy .jfx file to run.

### Returns
- **java.util.concurrent.Future<IStrategyResponse<java.util.UUID>>** - A Future object for obtaining the server response.

### Throws
- **java.io.IOException** - In case of strategyFile read/load error.
```

--------------------------------

### getStartedStrategies()

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/strategy/IStrategyManager.html

Retrieves a list of all currently started strategies.

```APIDOC
## java.util.concurrent.Future<IStrategyResponse<java.util.Set<DESCRIPTOR>>> getStartedStrategies()

### Description
Returns a set of started strategies.

### Returns
- **Future** - A Future object for obtaining the server response containing the set of strategy descriptors.
```

--------------------------------

### onStart(long strategyId)

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IStrategyListener.html

Invoked when a new strategy starts.

```APIDOC
## void onStart(long strategyId)

### Description
Called when a new strategy starts.

### Parameters
- **strategyId** (long) - The unique identifier of the started strategy.
```

--------------------------------

### ITesterClient.startStrategy

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/class-use/LoadingProgressListener.html

Starts a strategy with various configuration options, including a progress listener for the tester.

```APIDOC
## ITesterClient.startStrategy(IStrategy strategy, LoadingProgressListener testerProgressListener, ...)

### Description
Starts the execution of a strategy. The testerProgressListener is used to monitor the progress of data loading or initialization required for the strategy.

### Parameters
- **strategy** (IStrategy) - Required - The strategy instance to start.
- **testerProgressListener** (LoadingProgressListener) - Required - The listener to track progress during the strategy startup phase.

### Returns
- **long** - The identifier for the started strategy.
```

--------------------------------

### Calculate Indicator with Base Period Example

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IIndicators.html

Example of calculating an indicator using a specific base period.

```java
 Object[] result = indicators.calculateIndicator(Instrument.EURUSD,
      Period.ONE_HOUR, new OfferSide[] {OfferSide.ASK, OfferSide.ASK}, Period.MONTHLY, "OBV",
      new AppliedPrice[]{AppliedPrice.CLOSE}, new Object[]{}, 1);
 double obv = (Double)(result[0]);
```

--------------------------------

### Execute Task Example

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IContext.html

Example of using executeTask to run code from a non-strategy thread.

```java
 Thread thread = new Thread(new Runnable() {
      public void run() {
          try {
              context.executeTask(task);
          } catch (Exception e) {
              console.getErr().println(Thread.currentThread().getName() + " " + e);
          }
      }
  });
 thread.start();
```

--------------------------------

### startStrategy(java.io.File strategyFile, java.lang.Object[] params)

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/strategy/local/ILocalStrategyManager.html

Starts a strategy with custom parameters.

```APIDOC
## startStrategy(java.io.File strategyFile, java.lang.Object[] params)

### Description
Starts a strategy with custom parameters. The parameter array size and value types must match the strategy's public Configurable fields.

### Parameters
- **strategyFile** (java.io.File) - Required - The strategy .jfx file to run.
- **params** (java.lang.Object[]) - Required - The strategy parameters.

### Returns
- **java.util.concurrent.Future<IStrategyResponse<java.util.UUID>>** - A Future object for obtaining the server response.

### Throws
- **java.io.IOException** - In case of strategyFile read/load error.
- **JFException** - In case of parameter error, such as incorrect array size or wrong value type.
```

--------------------------------

### Submit a BuyStop Order Example

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IEngine.html

Demonstrates setting up the environment and submitting a BuyStop order using the IEngine interface.

```java
 public void onStart(IContext context) throws JFException {
     IEngine engine = context.getEngine();
     IHistory history = context.getHistory();
     IFinancialInstrumentProvider instrumentProvider = context.getFinancialInstrumentProvider();

     IFinancialInstrument financialInstrument = instrumentProvider.getFinancialInstrument("EUR/USD");
     context.setSubscribedFinancialInstruments(Collections.singleton(financialInstrument), true);

     ITick lastTick = history.getLastTick(financialInstrument);
     double price = lastTick.getAsk() + financialInstrument.getPipValue() * 5;
     IOrder order = engine.submitOrder("BuyStopOrder", financialInstrument, IEngine.OrderCommand.BUYSTOP, 0.1, price, 20);
 }
```

--------------------------------

### getBarStart

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IHistory.html

Calculates the starting time of a bar that includes a specific timestamp.

```APIDOC
## long getBarStart(Period period, long time)

### Description
Returns the starting time of the bar that includes the time specified in the 'time' parameter.
```

--------------------------------

### Get and Set Period Start

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/NewsFilter.html

Methods to retrieve or set the start date of the news subscription period.

```java
public final java.util.Date getFrom()
```

```java
public final void setFrom(java.util.Date fromDate)
```

--------------------------------

### getStartIndex()

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/indicators/HiLowIndicator.HiLow.html

Retrieves the start index of the HiLow range.

```APIDOC
## getStartIndex()

### Description
Returns the start index associated with this HiLow instance.

### Returns
- **int** - The start index.
```

--------------------------------

### Iterating Over StrategyMode Constants

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IEngine.StrategyMode.html

Example showing how to iterate over all available StrategyMode constants.

```java
for (IEngine.StrategyMode c : IEngine.StrategyMode.values())
	   System.out.println(c);
```

--------------------------------

### Get Current Bar Start Time

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IHistory.html

Returns the start time of the current bar being generated for an instrument and period.

```java
long getStartTimeOfCurrentBar(Instrument instrument,
                              Period period)
                       throws JFException
```

--------------------------------

### startStrategy(IStrategy, LoadingProgressListener, ITesterVisualModeParameters, ITesterExecution, ITesterUserInterface, boolean)

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/system/ITesterClient.html

Starts a strategy with full configuration options. If no GUI mode is used, parameters such as testerVisualModeParameters, testerExecution, and testerUserInterface should be set to null.

```APIDOC
## long startStrategy(IStrategy strategy, LoadingProgressListener testerProgressListener, ITesterVisualModeParameters testerVisualModeParameters, ITesterExecution testerExecution, ITesterUserInterface testerUserInterface, boolean writeHTDataToFiles)

### Description
Starts the strategy. If no GUI mode is used, then all of testerVisualModeParameters, testerExecution and testerUserInterface parameters should be null.

### Parameters
- **strategy** (IStrategy) - Strategy to run
- **testerProgressListener** (LoadingProgressListener) - Provides progress information, allows to cancel strategy
- **testerVisualModeParameters** (ITesterVisualModeParameters) - Visual mode optional parameters
- **testerExecution** (ITesterExecution) - Allows to control strategy execution process (stop, continue, cancel)
- **testerUserInterface** (ITesterUserInterface) - Provides access to various strategy testing GUI parts
- **writeHTDataToFiles** (boolean) - Flag to write HT data to files

### Returns
- **long** - Returns process id assigned to the strategy

### Throws
- **java.lang.IllegalStateException** - If not connected
- **java.lang.IllegalArgumentException** - If one of the parameters is null
```

--------------------------------

### getFrom / setFrom

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/NewsFilter.html

Gets or sets the start date of the subscription period.

```APIDOC
### Methods
`java.util.Date getFrom()`
`void setFrom(java.util.Date fromDate)`

### Description
Retrieves or updates the subscription's period start date.
```

--------------------------------

### IClient.runPlugin()

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/plugins/class-use/Plugin.html

Starts a plugin instance with an optional exception handler and GUI listener.

```APIDOC
## IClient.runPlugin()

### Description
Starts the specified plugin. Overloads allow for providing an exception handler and a GUI listener.

### Signatures
1. `java.util.UUID runPlugin(Plugin plugin, IStrategyExceptionHandler exceptionHandler)`
2. `java.util.UUID runPlugin(Plugin plugin, IStrategyExceptionHandler exceptionHandler, PluginGuiListener pluginGuiListener)`

### Parameters
- **plugin** (Plugin) - The plugin instance to start.
- **exceptionHandler** (IStrategyExceptionHandler) - Handler for strategy exceptions.
- **pluginGuiListener** (PluginGuiListener) - Optional listener for plugin GUI events.

### Returns
- **UUID** - The unique identifier of the started plugin.
```

--------------------------------

### onStart(IPluginContext context)

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/plugins/Plugin.html

Lifecycle method called when the plugin is started. It provides the IPluginContext to access system functionality.

```APIDOC
## void onStart(IPluginContext context)

### Description
Called on plugin start. This method is used to initialize the plugin and access system functionality via the provided context.

### Parameters
- **context** (IPluginContext) - Required - Allows access to all system functionality.

### Throws
- **JFException** - Thrown when strategy author ignores exceptions.
```

--------------------------------

### onStart(long processId)

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/system/ISystemListener.html

Callback method invoked when a new strategy is started.

```APIDOC
## void onStart(long processId)

### Description
Called when a new strategy is started.

### Parameters
- **processId** (long) - The unique identifier of the started strategy.
```

--------------------------------

### Get Time of First Candle

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IDataService.html

Returns the start time of the first feed data for the specified descriptor.

```java
long getTimeOfFirstCandle(IFeedDescriptor feedDescriptor)
```

--------------------------------

### Initialize Engine Context

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IEngine.html

Example of retrieving the engine and history from the context and subscribing to a financial instrument.

```java
 public void onStart(IContext context) throws JFException {
     IEngine engine = context.getEngine();
     IHistory history = context.getHistory();
     IFinancialInstrumentProvider instrumentProvider = context.getFinancialInstrumentProvider();

     IFinancialInstrument financialInstrument = instrumentProvider.getFinancialInstrument("EUR/USD");
     context.setSubscribedFinancialInstruments(Collections.singleton(financialInstrument), true);
```

--------------------------------

### Get Time for N Periods Forward

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/JFUtils.html

Calculates the starting time of a period located a specified number of periods in the future.

```java
long getTimeForNPeriodsForward(Period period,
                               long from,
                               int numberOfPeriods)
                        throws JFException
```

--------------------------------

### Run Plugin

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/system/IClient.html

Starts a plugin with an optional exception handler and GUI listener.

```java
java.util.UUID runPlugin(Plugin plugin,
                         IStrategyExceptionHandler exceptionHandler)
                  throws java.lang.IllegalStateException,
                         java.lang.NullPointerException
```

```java
java.util.UUID runPlugin(Plugin plugin,
                         IStrategyExceptionHandler exceptionHandler,
                         PluginGuiListener pluginGuiListener)
                  throws java.lang.IllegalStateException,
                         java.lang.NullPointerException
```

--------------------------------

### Get Time for N Periods Back

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/JFUtils.html

Calculates the starting time of a period located a specified number of periods in the past.

```java
long getTimeForNPeriodsBack(Period period,
                            long to,
                            int numberOfPeriods)
                     throws JFException
```

--------------------------------

### onStart(IIndicatorContext context)

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/indicators/IIndicator.html

Initializes the indicator and provides access to system functionality.

```APIDOC
## void onStart(IIndicatorContext context)

### Description
Called on indicator initialization to set up necessary resources.

### Parameters
- **context** (IIndicatorContext) - Required - Allows access to system functionality.
```

--------------------------------

### runPlugin

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/system/IClient.html

Starts a plugin with an optional exception handler and GUI listener.

```APIDOC
## runPlugin(Plugin plugin, IStrategyExceptionHandler exceptionHandler)

### Description
Starts the plugin and returns the assigned strategy ID.

### Parameters
- **plugin** (Plugin) - The plugin to run.
- **exceptionHandler** (IStrategyExceptionHandler) - Optional handler for strategy exceptions.

### Returns
- **java.util.UUID** - The ID assigned to the strategy.
```

--------------------------------

### IClient.runPlugin

Source: https://www.dukascopy.com/client/javadoc3/index-all.html

Starts a plugin or strategy within the Dukascopy client environment.

```APIDOC
## IClient.runPlugin

### Description
Starts the execution of a plugin or strategy with optional exception handling and GUI listeners.

### Methods
- runPlugin(Plugin, IStrategyExceptionHandler)
- runPlugin(Plugin, IStrategyExceptionHandler, PluginGuiListener)
```

--------------------------------

### Get Last 30 Days Turnover

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/system/Commissions.html

Retrieves the turnover values for the last 30 days used at tester start time.

```java
public double[] getLast30DaysTurnoverAtStart()
```

--------------------------------

### Get Offer Side

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/feed/FeedInfo.html

Retrieves the current offer side configuration.

```java
public OfferSide getOfferSide()
```

--------------------------------

### Full Order Submission Example in onStart

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IEngine.html

A complete implementation within the onStart method to subscribe to an instrument and submit a Buy Stop order.

```java
 public void onStart(IContext context) throws JFException {
     IEngine engine = context.getEngine();
     IHistory history = context.getHistory();
     IFinancialInstrumentProvider instrumentProvider = context.getFinancialInstrumentProvider();

     IFinancialInstrument financialInstrument = instrumentProvider.getFinancialInstrument("EUR/USD");
     context.setSubscribedFinancialInstruments(Collections.singleton(financialInstrument), true);

     ITick lastTick = history.getLastTick(financialInstrument);
     double price = lastTick.getAsk() + financialInstrument.getPipValue() * 5;
     double sl = lastTick.getAsk() - financialInstrument.getPipValue() * 20;
     double tp = lastTick.getAsk() + financialInstrument.getPipValue() * 10;
     long SECOND = 1000;
     long gtt = lastTick.getTime() + 30 * SECOND; //withdraw after 30 secs
     IOrder order = engine.submitOrder("BuyStopOrder", financialInstrument, IEngine.OrderCommand.BUYSTOP, 0.1, price, 20, sl, tp, gtt);
 }
```

--------------------------------

### Retrieve Interval Start Time

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/system/tester/ITesterDataInterval.html

Returns the start timestamp of the interval.

```java
long getFrom()
```

--------------------------------

### onStart(IContext context)

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IStrategy.html

Called when the strategy starts. This is the primary location for initializing variables, subscribing to instruments, and setting up strategy resources.

```APIDOC
## void onStart(IContext context)

### Description
Called on strategy start. Used to initialize variables, subscribe to instruments and feeds, and perform other setup operations.

### Parameters
- **context** (IContext) - Required - Allows access to all system functionality.

### Throws
- **JFException** - Thrown when strategy author ignores exceptions.
```

--------------------------------

### Calculate Indicator Example

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IIndicators.html

Demonstrates how to calculate an indicator and perform type conversion on the result.

```java
 IFinancialInstrumentProvider instrumentProvider = context.getFinancialInstrumentProvider();
 IFinancialInstrument financialInstrument = instrumentProvider.getFinancialInstrument("EUR/USD");
 Object[] result = indicators.calculateIndicator(financialInstrument,
     Period.ONE_HOUR, new OfferSide[] {OfferSide.ASK}, "MINMAX",
     new AppliedPrice[]{AppliedPrice.CLOSE}, new Object[]{5}, 1);
 double min = (Double)(result[0]);
 double max = (Double)(result[1]);
```

--------------------------------

### Retrieve historical bars by time interval

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IHistory.html

Fetches a list of bars between a start and end time. Ensure the start time aligns with the bar start time for the specified period.

```java
 private IHistory history;
 private IConsole console;

  @Override
 public void onStart(final IContext context) throws JFException {
     history = context.getHistory();
     console = context.getConsole();

     IFinancialInstrumentProvider instrumentProvider = context.getFinancialInstrumentProvider();
     final IFinancialInstrument financialInstrument = instrumentProvider.getFinancialInstrument("EUR/USD");

     long prevBarTime = history.getPreviousBarStart(Period.ONE_HOUR, history.getLastTick(financialInstrument).getTime());
     long startTime =  history.getTimeForNBarsBack(Period.ONE_HOUR, prevBarTime, 5);
     List <IBar> bars = history.getBars(financialInstrument, Period.ONE_HOUR, OfferSide.BID, startTime, prevBarTime);
     int last = bars.size() - 1;
     console.getOut().format(
         "Previous bar close price=%.5f; 4th to previous bar close price=%.5f",
             bars.get(last).getClose(), bars.get(0).getClose()
     ).println();
 }
```

--------------------------------

### IDownloadableStrategies.init()

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/class-use/IEngine.StrategyMode.html

Initializes a downloadable strategy with a specified StrategyMode.

```APIDOC
## IDownloadableStrategies.init(String id, String name, IContext context, ComponentType type, IEngine.StrategyMode mode, Map<String, Object> configurables)

### Description
Initializes a strategy instance with the required configuration, including the IEngine.StrategyMode.
```

--------------------------------

### Start Trading Strategy

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/system/IClient.html

Initiates a strategy with either a default or custom exception handler.

```java
long startStrategy(IStrategy strategy)
            throws java.lang.IllegalStateException,
                   java.lang.NullPointerException
```

```java
long startStrategy(IStrategy strategy,
                   IStrategyExceptionHandler exceptionHandler)
            throws java.lang.IllegalStateException,
                   java.lang.NullPointerException
```

--------------------------------

### IDownloadableStrategies.init

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/class-use/JFException.html

Initializes a downloadable strategy.

```APIDOC
## IDownloadableStrategies.init

### Description
Initializes a strategy with the provided configuration and context.

### Method
- IDownloadableStrategy init(java.lang.String id, java.lang.String name, IContext context, IDownloadableStrategy.ComponentType type, IEngine.StrategyMode mode, java.util.Map<java.lang.String,java.lang.Object> configurables)
```

--------------------------------

### Subscribe to Instruments in onStart

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IStrategy.html

Use the onStart method to initialize strategy variables and subscribe to specific instruments using the IContext.

```java
 context.setSubscribedInstruments(new HashSet<Instrument>(Arrays.asList(Instrument.EURUSD, Instrument.AUDCAD), true));
```

--------------------------------

### Calculate bar start time

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IHistory.html

Returns the starting timestamp of the bar that contains the specified time.

```java
long getBarStart(Period period,
                 long time)
          throws JFException
```

--------------------------------

### IDownloadableStrategies.init()

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/class-use/IDownloadableStrategy.ComponentType.html

Initializes a downloadable strategy with a specific component type.

```APIDOC
## IDownloadableStrategies.init(String id, String name, IContext context, IDownloadableStrategy.ComponentType type, IEngine.StrategyMode mode, Map<String, Object> configurables)

### Description
Initializes a new downloadable strategy instance using the provided configuration parameters, including the component type.

### Parameters
- **id** (String) - Strategy identifier
- **name** (String) - Strategy name
- **context** (IContext) - Execution context
- **type** (IDownloadableStrategy.ComponentType) - The component type to assign
- **mode** (IEngine.StrategyMode) - The strategy execution mode
- **configurables** (Map<String, Object>) - Configuration map
```

--------------------------------

### Retrieve Strategy Start Time

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/strategy/IStrategyDescriptor.html

Returns the start time of the strategy on the remote server as a long value.

```java
long getStartTime()
```

--------------------------------

### Retrieve Started Strategies

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/strategy/IStrategyManager.html

Fetches a list of currently running remote strategies from the manager.

```java
 //Retrieve remote strategies from a remote strategy manager, to retrieve local strategies use ILocalStrategyManager
 IStrategyResponse <Set<IRemoteStrategyDescriptor>> listResponse = strategyManager.getStartedStrategies().get();
 if (listResponse.isError()) {
     System.err.println("Failed to retrieve remote strategy list");
 } else {
     Set <IRemoteStrategyDescriptor> strategyDescriptors = listResponse.getResult();
     System.out.println("Remotely started " + strategyDescriptors.size() + " strategies: ");
     for (IStrategyDescriptor strategyDescriptor : strategyDescriptors) {
         System.out.println(strategyDescriptor.toString());
     }
 }
```

--------------------------------

### startStrategy

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/system/ITesterClient.html

Starts a strategy for testing. If no GUI mode is used, parameters related to visual mode, execution control, and user interface should be null.

```APIDOC
## startStrategy

### Description
Starts the strategy execution process. Returns the process ID assigned to the strategy.

### Parameters
- **strategy** (IStrategy) - The strategy to run.
- **testerProgressListener** (LoadingProgressListener) - Provides progress information and allows strategy cancellation.
- **testerParametersForVisualMode** (ITesterParametersForVisualMode) - Optional parameters for visual mode.
- **testerExecution** (ITesterExecution) - Allows control over the strategy execution process (stop, continue, cancel).
- **testerUserInterface** (ITesterUserInterface) - Provides access to strategy testing GUI parts.
- **writeHTDataToFiles** (boolean) - If false, history loading and indicator calculation use real data from cache instead of interpolated data.

### Returns
- **long** - The process ID assigned to the strategy.

### Throws
- **java.lang.IllegalStateException** - If not connected.
- **java.lang.IllegalArgumentException** - If one of the parameters is null.
```

--------------------------------

### startStrategy(java.io.File strategyFile, java.lang.Object[] params, boolean stopOnError)

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/strategy/remote/IRemoteStrategyManager.html

Starts a strategy with parameters. The parameter array size and types should match the strategy's public Configurable fields.

```APIDOC
## startStrategy(java.io.File strategyFile, java.lang.Object[] params, boolean stopOnError)

### Description
Starts a strategy with parameters. Note that the parameter array size should match the strategy public Configurable field count, likewise the value types should match.

### Parameters
- **strategyFile** (java.io.File) - Required - Strategy jfx file to run.
- **params** (java.lang.Object[]) - Required - Strategy parameters.
- **stopOnError** (boolean) - Required - Stop strategy on error.

### Returns
- **java.util.concurrent.Future<IStrategyResponse<java.util.UUID>>** - Future object for obtaining the server response.

### Throws
- **java.io.IOException** - In case of strategyFile read/load error.
- **JFException** - In case of parameter error, i.e., incorrect array size or wrong value type.
```

--------------------------------

### Get Financial Instrument

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IOrder.html

Deprecated method to get the order's instrument. Use getInstrument() instead.

```java
@Deprecated
IFinancialInstrument getFinancialInstrument()
```

--------------------------------

### onStart Method

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/indicators/Awesome2Oscillator.html

Initializes the indicator.

```java
public void onStart(IIndicatorContext context)
```

--------------------------------

### IHistory.getNextBarStart

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/class-use/Period.html

Returns the starting time of the bar next to the bar that includes the specified time.

```APIDOC
## long IHistory.getNextBarStart(Period period, long barTime)

### Description
Returns the starting time of the bar next to the bar that includes time specified in barTime parameter.
```

--------------------------------

### onStart(T t)

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IJFRunnable.html

Invoked when the runnable component is started. It receives the context of type T.

```APIDOC
## void onStart(T t)

### Description
Called to initialize or start the component. The method receives a context object of type T.

### Parameters
- **t** (T) - The context object required for the component execution.

### Throws
- **JFException** - Thrown if an error occurs during the start process.
```

--------------------------------

### Calculate previous bar start time

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IHistory.html

Returns the starting timestamp of the bar preceding the one that contains the specified time.

```java
long getPreviousBarStart(Period period,
                         long barTime)
                  throws JFException
```

--------------------------------

### Start Strategy with Visual Mode Parameters

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/system/ITesterClient.html

Initiates a strategy including visual mode configuration, execution control, and UI access.

```java
long	startStrategy(IStrategy	strategy,
                   LoadingProgressListener	testerProgressListener,
                   ITesterVisualModeParameters	testerVisualModeParameters,
                   ITesterExecution	testerExecution,
                   ITesterUserInterface	testerUserInterface)
            throws java.lang.IllegalStateException,
                   java.lang.IllegalArgumentException
```

```java
long	startStrategy(IStrategy	strategy,
                   LoadingProgressListener	testerProgressListener,
                   ITesterParametersForVisualMode	testerParametersForVisualMode,
                   ITesterExecution	testerExecution,
                   ITesterUserInterface	testerUserInterface)
            throws java.lang.IllegalStateException,
                   java.lang.IllegalArgumentException
```

--------------------------------

### Get Downloadable Strategies

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IContext.html

Accesses the interface for managing downloadable strategies.

```java
IDownloadableStrategies getDownloadableStrategies()
```

--------------------------------

### onStart Method Definition

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/indicators/IIndicator.html

Initializes the indicator and provides access to system functionality via the IIndicatorContext.

```java
void onStart(IIndicatorContext context)
```

--------------------------------

### Calculate next bar start time

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IHistory.html

Returns the starting timestamp of the bar following the one that contains the specified time.

```java
long getNextBarStart(Period period,
                     long barTime)
              throws JFException
```

--------------------------------

### Get Price Range

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/feed/FeedInfo.html

Retrieves the current price range configuration.

```java
public PriceRange getPriceRange()
```

--------------------------------

### init

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IDownloadableStrategies.html

Initializes a downloadable strategy with the provided identification, context, type, mode, and configuration map.

```APIDOC
## IDownloadableStrategy init(String id, String name, IContext context, ComponentType type, StrategyMode mode, Map<String, Object> configurables)

### Description
Initializes a new instance of a downloadable strategy. This method sets up the strategy environment and configuration required for execution.

### Parameters
- **id** (String) - The unique identifier for the strategy.
- **name** (String) - The display name of the strategy.
- **context** (IContext) - The execution context for the strategy.
- **type** (ComponentType) - The component type of the strategy.
- **mode** (StrategyMode) - The operational mode for the strategy engine.
- **configurables** (Map<String, Object>) - A map containing configuration parameters for the strategy.

### Throws
- **JFException** - Thrown if the initialization fails.

### Returns
- **IDownloadableStrategy** - The initialized strategy instance.
```

--------------------------------

### Start a strategy

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/system/ITesterClient.html

Initiates a strategy execution. If running without a GUI, pass null for visual mode, execution, and user interface parameters.

```java
long	startStrategy(IStrategy	strategy,
                   LoadingProgressListener	testerProgressListener,
                   ITesterParametersForVisualMode	testerParametersForVisualMode,
                   ITesterExecution	testerExecution,
                   ITesterUserInterface	testerUserInterface,
                   boolean	writeHTDataToFiles)
            throws java.lang.IllegalStateException,
                   java.lang.IllegalArgumentException
```

--------------------------------

### startIndex(int si, java.lang.Object[] outputValues)

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/indicators/HiLowIndicator.html

Calculates the starting index for the indicator processing.

```APIDOC
## startIndex(int si, java.lang.Object[] outputValues)

### Description
Determines the starting index for indicator calculations based on the provided input index and output values.

### Parameters
- **si** (int) - The starting index.
- **outputValues** (java.lang.Object[]) - The array of output values.

### Returns
- **int** - The calculated start index.
```

--------------------------------

### Initialize KagiFeedInfo with all parameters

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/feed/util/KagiFeedInfo.html

Constructor that sets all required fields for the Kagi feed descriptor.

```java
public KagiFeedInfo(IFinancialInstrument financialInstrument,
                    OfferSide offerSide,
                    PriceRange turnaroundAmount,
                    Period timeSession,
                    CreationPoint creationPoint,
                    Period basePeriod)
```

--------------------------------

### getCommentFont()

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IChart.html

Gets the comment's font.

```APIDOC
### Method
`java.awt.Font getCommentFont()`

### Description
Gets the comment's font.

### Returns
- **java.awt.Font** - Comment's font; if a font has not been set for comment, then the font defined in chart's theme for drawings is returned
```

--------------------------------

### Initialize History Variables

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IHistory.html

Example fields for tracking history and console state during data analysis.

```java
 private IHistory history;
 private IConsole console;

 private double avgPrice = 0;
 private int itemCount = 0;
```

--------------------------------

### IStrategies.startStrategy(File, IStrategyListener, Map, boolean)

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/class-use/IStrategyListener.html

Starts a strategy from a file with a listener for strategy events. This method is deprecated; use IClient.startStrategy(IStrategy) instead.

```APIDOC
## IStrategies.startStrategy(java.io.File, IStrategyListener, java.util.Map, boolean)

### Description
Starts a strategy from a JFX file. This method is deprecated.

### Parameters
- **jfxFile** (java.io.File) - The strategy file to start.
- **listener** (IStrategyListener) - The listener to receive strategy events.
- **configurables** (java.util.Map<java.lang.String,java.lang.Object>) - Configuration parameters for the strategy.
- **fullAccess** (boolean) - Whether the strategy should have full access.
```

--------------------------------

### Get Period

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/feed/FeedInfo.html

Retrieves the current period setting.

```java
public Period getPeriod()
```

--------------------------------

### Submit a Simple Buy/Sell Order

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IEngine.html

Example of submitting a basic Buy or Sell order using the IEngine interface.

```java
 public void onStart(IContext context) throws JFException {
     IEngine engine = context.getEngine();
     IHistory history = context.getHistory();
     IFinancialInstrumentProvider instrumentProvider = context.getFinancialInstrumentProvider();

     IFinancialInstrument financialInstrument = instrumentProvider.getFinancialInstrument("EUR/USD");
     context.setSubscribedFinancialInstruments(Collections.singleton(financialInstrument), true);

     IOrder order = engine.submitOrder("BuyStopOrder", financialInstrument, IEngine.OrderCommand.BUYSTOP, 0.1);
 }
```

--------------------------------

### IHistory.getPreviousBarStart

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/class-use/Period.html

Returns the starting time of the bar previous to the bar that includes the specified time.

```APIDOC
## long IHistory.getPreviousBarStart(Period period, long barTime)

### Description
Returns the starting time of the bar previous to the bar that includes time specified in barTime parameter.
```

--------------------------------

### Get Country

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/Instrument.html

Retrieves the country associated with the instrument.

```java
public java.lang.String getCountry()
```

--------------------------------

### Get PropertyChangeListeners

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IChartObject.html

Retrieves an array of all registered PropertyChangeListeners.

```java
java.beans.PropertyChangeListener[] getPropertyChangeListeners()
```

--------------------------------

### IChart.switchPickingPriceMode

Source: https://www.dukascopy.com/client/javadoc3/index-all.html

Starts or stops the price picking mode on a chart.

```APIDOC
## Method: IChart.switchPickingPriceMode

### Description
Starts or stops picking price from the chart.

### Parameters
- enabled (boolean) - Whether to enable or disable the mode
- listener (IChart.PickingPriceListener) - The listener to handle price picking events
```

--------------------------------

### setCharts

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/system/ITesterClient.html

Sets the charts that will be opened when the tester starts running.

```APIDOC
## void setCharts(java.util.Collection<IFeedDescriptor> feedDescriptors)

### Description
Sets the charts that will be opened when the tester starts running.

### Parameters
- **feedDescriptors** (java.util.Collection<IFeedDescriptor>) - Required - Feed descriptors for charts
```

--------------------------------

### Initialize Strategy Method

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IDownloadableStrategies.html

Initializes a strategy with the provided configuration parameters and context.

```java
IDownloadableStrategy init(java.lang.String id,
                           java.lang.String name,
                           IContext context,
                           IDownloadableStrategy.ComponentType type,
                           IEngine.StrategyMode mode,
                           java.util.Map<java.lang.String,java.lang.Object> configurables)
                    throws JFException
```

--------------------------------

### getTimeRange()

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/system/ITesterReportData.html

Retrieves the start and end timestamps of the strategy execution.

```APIDOC
### long getFrom()
Returns the start time in milliseconds.

### long getTo()
Returns the end time in milliseconds.
```

--------------------------------

### Initialize KagiFeedInfo with custom time session and creation point

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/feed/util/KagiFeedInfo.html

Constructor for Kagi data with a static turnaround price, time session, and creation point.

```java
public KagiFeedInfo(IFinancialInstrument financialInstrument,
                    OfferSide offerSide,
                    PriceRange turnaroundAmount,
                    Period timeSession,
                    CreationPoint creationPoint)
```

--------------------------------

### long getFrom()

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/system/tester/ITesterDataInterval.html

Retrieves the start timestamp of the data interval.

```APIDOC
### long getFrom()

Returns the start timestamp of the interval as a long value.
```

--------------------------------

### Iterate Over MarketSector Constants

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/INewsFilter.MarketSector.html

Example showing how to iterate over all available market sector constants.

```java
public static INewsFilter.MarketSector[] values()

for (INewsFilter.MarketSector c : INewsFilter.MarketSector.values())
	   System.out.println(c);
```

--------------------------------

### IClient.startStrategy(IStrategy strategy)

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/class-use/IStrategy.html

Starts the strategy with a default exception handler that will stop the strategy if it throws an exception.

```APIDOC
## IClient.startStrategy

### Description
Starts the strategy with default exception handler that will stop strategy if it trows exception.

### Parameters
- **strategy** (IStrategy) - The strategy to start.
```

--------------------------------

### Get User Interface

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IContext.html

Provides access to custom strategy tabs in the UI.

```java
IUserInterface getUserInterface()
```

--------------------------------

### switchPickingPriceMode

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IChart.html

Starts or stops the price picking mode from the chart.

```APIDOC
void switchPickingPriceMode(boolean isPickingPrice, IChart.PickingPriceListener listener)
```

--------------------------------

### Submit a BuyStop Order with SL and TP

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/IEngine.html

Example of submitting a BuyStop order including stop loss and take profit levels using the IEngine interface.

```java
     ITick lastTick = history.getLastTick(financialInstrument);
     double price = lastTick.getAsk() + financialInstrument.getPipValue() * 5;
     double sl = lastTick.getAsk() - financialInstrument.getPipValue() * 20;
     double tp = lastTick.getAsk() + financialInstrument.getPipValue() * 10;
     IOrder order = engine.submitOrder("BuyStopOrder", financialInstrument, IEngine.OrderCommand.BUYSTOP, 0.1, price, 20, sl, tp);
 }
```

--------------------------------

### Get Preferences

Source: https://www.dukascopy.com/client/javadoc3/com/dukascopy/api/system/IClient.html

Retrieves the global preference holder for the JForex-SDK.

```java
IPreferences getPreferences()
```
Tokens:
Raw