LeLibby - User Manual

Release 1.0.2


Table of Contents

Introduction

Disclaimer
Please note, that LeLibby is experimental software. It has been tested successully with several PCG data files of the Triton Le and other instruments of the Triton family which are the Triton Tr, Triton Classic, Triton Studio and Triton Extreme. Limited support is also available for PCG files created by the KORG Karma and the X50. Use the software at your own risk! Damages of any kind caused by the use of this software are not in the responsibility of the author!

The documentation is far from being complete. Check back regularly!

Synopsis
	java -jar LeLibby.jar [OPTIONS] [file] [file]	

	Options:
           --version .................. displays version information
           --param-file=paramFile ..... XML file with parameter descriptions
           --work-dir=directory ....... The default directory to work in
           --no-preset-params ......... do not use the preset parameters
           --help ..................... this information
	

Basic Features
This section lists the features that LeLibby supports:

  • Two separate windows for different PCG files that enable you to easily transfer items from one PCG file to another as long as they belong to the same Triton model.
  • Cloning of an entire PCG file
  • Moving and copying items within one PCG file
  • When moving programs within one PCG file LeLibby ensures that combinations using these programs are updated with the new positions of the programs provided that combination data is also stored in the PCG file.
  • Creating combinations based on programs
  • Drag and Drop support for copying items to the second PCG file.
  • Support for copying combinations including their used programs between different PCG files.
  • Programs and Combinations copied between PCGs of different Triton models are converted automatically.
  • Sorting of items alphabetically or - in case of programs/combis - categorically. Sorting can either be applied to a whole section or bank or a selection.
  • Searching for item names (programs, combis, etc.) within one section
  • Finding of duplicate items
  • Filling a bank with a single item, e.g. InitialProgram...
  • Modification of program/combi/drumkit/arpeggio parameters
  • Modification of global instrument parameters, like master tuning, etc.
  • Dumping item contents in hexadecimal format
  • Exporting the contents of a loaded PCG file to a HTML file
  • Creation of bank archives which can hold up to 130 banks of programs, combinations, drum kits and arpeggio patterns
  • Smart Sorting items
  • ...

Restrictions
  • If the order of arpeggios becomes changed, programs and combinations using those arpeggios will not be updated with the new positions
  • A PCG file cannot be created from scratch.

GUI
The GUI of LeLibby is separated into two PCG parts enabling you to load two separate PCG files into the application. On top of each part is the section selector that defines which kind of data is shown in the item list below. This depends on the sections that are stored in a PCG file. Maybe some PCG file only stores programs while another one stores the full range of data available.

Between the section selector and the item list is the toolbar with buttons for basic operations. The tooltip texts (which appear when you move the mouse over them) should contain enough information about the functionality of each button.

The area between the PCG parts has buttons for cloning and copying items from one PCG file to the other. Again, take a look at the tool tips!

Using LeLibby as librarian

Contents of this chapter
This section describes aspects of the main purpose that LeLibby should fulfill and that it was created for. It should not be a description of the elements of the GUI and which action they trigger (reading the tool tips should be sufficient), rather it will outline some principles that should be taken into consideration when processing your PCG data files.

Dependencies between programs and combinations
One big advantage of LeLibby is that you are able to move around your programs - even between banks - without affecting the combinations using these programs. LeLibby takes care that combinations always use the right programs. The second "Big Thing" is the ability to copy entire combinations including the programs they use from one PCG file to another.

As you know combinations use programs as their timbres (usually 8 for the Tritons). But combinations do not store all the program data (which would be a waste of storage capacity). Rather they have references to the locations (which is bank and index) of the programs they are using.

The author expects that the main usage of LeLibby will be to administrate libraries of programs and combinations. Therefore there are two basic principles which are covered by LeLibby:

  1. moving programs within the same PCG file should not result in different-sounding combinations
  2. moving or copying combinations between different PCG files should not result in different sounding combinations

The essential precondition for these principles is that both the program and combination data are available in the PCG file. Otherwise you will not get the results that you would have expected. Let's have a look at 2 scenarios which produce results that do not follow the principles stated above:

  1. Assume you have stored a single program bank to a PCG file and you want to re-order the programs using LeLibby and then load the bank back into the Triton. We also assume that the programs of this bank are used by a couple of combinations.

    Let's say you move program A (which is used by combination XY) from index 45 to index 51, implicitely changing the indices of the programs within these bounds. But in your Triton combination XY has still a reference to program A at index 45. When you now load the re-ordered program bank back to the instrument combination XY will sound different now because the program on index 45 (the one that was on index 46 before) is a different program now.

    If you also had stored your combination banks in the PCG this mis-behavior could have been avoided. The conclusion here is that if you move around your programs be sure that the combination data is also available in the PCG file. LeLibby will then automatically correct the references in the combination.

  2. You have two PCG files and you want to transfer some combinations from file 1 to file 2 and then load file 2 back to your Triton. File 1 has the entire set of program and combination banks while file 2 only includes the combination banks. Now we can split this scenario again:

    1. The programs in PCG file 1 are different than those loaded in the Triton.
      Bad luck dude! You could copy a combination to file 2 and load the combi banks into your Triton. You will also see the same parameters on the screen but you will hear a different sound than the one you would have expected. Although the programs referenced by your combi were available in the PCG file they could not be copied because in the destination PCG no program banks were stored.
    2. The programs that are stored in PCG file 1 are exactly the same which are loaded in your Triton.
      Good luck dude! Because you had the same programs in your Triton as in the PCG file 1 there was actually no need to copy the programs to PCG 2 (which would not have been possible). Your combi will sound as you have expected.

So what is it good for?
Let's have a look at some use cases and recommendations.

  1. Using LeLibby as a librarian for programs

    If you just want to build your very private program collection and do not pay attention to combinations LeLibby is what you want. You load 2 PCG files with program banks into LeLibby and copy your favourite programs from PCG to PCG until you have the collection you want.
    Of course, when you load them into your Triton your combis will sound quite weird, but that's not the point in this case.

  2. Using LeLibby as a librarian for combinations

    Let's Say you want to grab your favourite combis from PCG 1 and store them in PCG 2. In this case you should make shure that all program banks are also stored in PCG 1, otherwise you will be surprised when you load PCG 2 into your Triton and start playing those combis. Also, if you want to collect combinations from different PCG files be aware that programs could become overwritten in your destination PCG.

  3. Using LeLibby to re-organize your banks of programs/combis etc.

    You play in a glorious rock band and the programs and combis that you use for your songs are distributed over the banks. Either you are a mastermind and know each location by heart or you are not (like me). Go ahead and use LeLibby to get your programs and combis into the right order (which will differ from gig to gig). Then you only have to press the "INC" button to get the correct sound for the next song.

Last word about copying combinations
With the availability of the Combi-Copy-Wizard transferring combinations between PCGs becomes an easy task. Learn more about the Combi-Copy-Wizard in the Combi-Copy-Wizad chapter.

Using LeLibby as parameter editor

Contents of this chapter
Each program, combination, drum kit and arpeggio pattern is a collection of parameters which can be modified using the panel of your Triton. All of those parameters are stored in PCG files. For example, the name of a program, the used ARP patterns in a combination, etc. Even global instrument parameters are available in the PCG file. LeLibby provides a "very generic" configurable interface to these kind of parameters. The following sections describe what you can do with it.

Editing parameters in the parameter dialog
Double-Clicking on an item (or using the "Edit" command of the item's context menu) will display the parameter dialog which lists the available parameters in tabular form. The first column shows the parameter (or attribute) names while the second column shows the corresponding values currently assigned to the parameters. When clicking on a value the field becomes editable and allows the value to be changed.

When starting an edit session the parameters of the selected item are copied to an edit buffer. While editing all changes take place in this buffer. When you have done your modifications press the "COMMIT" button to store your modifications and close the parameter dialog. While editing an item you can use the "REVERT" button to undo your changes done so far. If you like to reload the original parameter values of an item as they are stored in the PCG file use the "RESET" button. Pressing the "CANCEL" button discards all changes and closes the parameter dialog. The diagram below shows the principles of parameter editing.

		  
                   Reset                         
                +----------+--------------------------+
                |          |                          |                    
                v          |                          |                    
  +-------------+      +---+----+                +----+-----+        +-----------+
  | Bank Item   | EDIT | Edit   | Making Changes | Modified | COMMIT | Modified  |
  | in PCG file |----->| Buffer |--------------->| Buffer   |------->| Bank Item |
  +-------------+      +--------+                +----+-----+        +-----+-----+
                           ^                          |                    |
                           |           REVERT         |                    |
                           +--------------------------+                    |
                           ^                                               |
                           |                      EDIT                     |
                           +-----------------------------------------------+
		

Configuration of customizable parameters
Parameters for programs, combis, etc. are stored in a format that conforms to the MIDI specifications of the respective instrument. For the Le you may download these specification from here. The MIDI specification tells you at which offset a parameter can be found and a value range that is applicable for this parameter. To be flexible at a high degree LeLibby reads those information from an external parameter definition file. This parameter definition file contains the description of the parameters that you would like to be able to modify. It's that simple: If you want to have access to a certain parameter that is not already included, simply add a corresponding entry to that file and the next time you start the program you will have the possibility to change it. The parameter definition file is encoded as XML file. The structure is described below.
By default LeLibby includes an parameter file with a bunch of definitions for a wide range of parameters both for the Triton Le and for the Triton Classic.

The parameter description file
As stated above the parameter description file is a XML file with a quite simple structure. Even if you are not familiar with XML it should be not too difficult to get the idea how to write your private parameter file.

Currently the following elements that have mutable parameters are supported:

  • global instrument settings
    • ...for the Le
    • ...for the Classic
  • program parameters
    • ...for the Le
    • ...for the Classic
  • combination parameters
    • ...for the Le
    • ...for the Classic
  • drum kit parameters
    • ...for the Le
    • ...for the Classic
  • arpeggio parameters
    • ...for the Le
    • ...for the Classic

To specify those elements in XML Syntax a <pcg_element> block is used, e.g.

		<pcg_element class="GLOBAL_COMMON">
			...parameter descriptions
		</pcg_element>
		
The <pcg_element> tag requires an attribute called class which identifies the element whose parameters are described. The valid class attribute values are:

  • GLOBAL_COMMON
  • GLOBAL_LE
  • GLOBAL_CLASSIC
  • PROGRAM_COMMON
  • PROGRAM_LE
  • PROGRAM_CLASSIC
  • COMBI_COMMON
  • COMBI_LE
  • COMBI_CLASSIC
  • DRUMKIT_COMMON
  • DRUMKIT_LE
  • DRUMKIT_CLASSIC
  • ARP_COMMON
  • ARP_LE
  • ARP_CLASSIC

The class identifiers ending with "_COMMON" can be used for the same parameters of different Triton models, if - and that's important - they are located at the same offset (according to the MIDI specification). For example most of the global parameters are located at the same offset for the Triton Classic and the Le. On the other hand program or combi parameters are located at different offsets due to the fact that the Le has only a single insert effect while the other Tritons have 5 of them. This means, if you describe program or combi parameters you will have to use the "*_LE" or "*_CLASSIC" identifiers respectively.

Parameter description with the <param> tag
The next step is now to specify the parameters themselves. A parameter description is identified by the <param> tag which is a child node of the <pcg_element> node. Two attributes for a parameter are common to all kinds of parameters: The name of the parameter and its byte offset (except for the type SHORTRANGE, see table below. Therefore almost all of the <param> tags require the two attributes:

  • name
  • offs

		Example: <param name="MFX1 Effect Type" offs="56">
			 ...
		         </param>
		

Another essential attritube of a parameter is its type. The table below lists the types and their required attributes that are currently supported:

Typeattributesdescription
BITbit the bit offset within the byte
BYTERANGEminthe minimum (integer) value
maxthe maximum (integer) value
signedif "true" parameter will be considered to get negative values
SHORTRANGEminthe minimum (integer) value
maxthe maximum (integer) value
msbthe offset of the most significant byte
lsbthe offset of the least significant byte
signedif "true" parameter will be considered to get negative values
BITRANGEminthe minimum (integer) value
maxthe maximum (integer) value
loBitthe offset of the lower bit
hiBitthe offset of the higher bit
NIBBLEminthe minimum (integer) value
maxthe maximum (integer) value
whicheither "0" for the lower or "1" for the higher nibble (= halfbyte)
BYTESET has no additional attributes
STRINGlen the length of the string in bytes
STRINGTABLEcountthe number of strings
lenthe length of a single string in bytes

Mapping parameter values to readable text
Now we know how to describe the parameters that we want to be able to modify in LeLibby but there's still a problem. Imagine that you are setting an insert effect via your instrument screen. You will get a list of available effects like "St. Compressor", "Reverb Hall", which you can choose from. Internally (and as saved in the PCG file) all the effect types and other parameters are simply represented by numbers. The mapping of those numbers to readable strings on the instrument screen is done by the instrument's software and is not part of the data that are stored in a PCG file. And that's what we also want to have in LeLibby: human-readable representations of numbers.

Therefore there's a possibility to define readable mappings for each parameter which will then be used in the user interface of LeLibby. There are different tags available to define the string mappings. The mapping nodes are child nodes of the <param> node.

The <mapping> and <automapping> tags
The most common mapping tag is <mapping>, for example:

		<param name="MFX 1 - OFF/ON" type="BIT" bit="6" offs="57">
			<mapping>OFF<mapping>
			<mapping>ON<mapping>
		</param>		
		

In the example above we define a parameter of type BIT at offset 57 and the bit offset of 6. Bits can have two values "0" or "1" and in this case "0" means MFX1 off and "1" means MFX1 on.

In some cases it is not necessary to have String mappings for values, e.g. for tempo settings. In this case we simply define the following:

		<param name="Velocity Curve" type="BYTERANGE" min="0" max="7" offs="2">
			<automapping from="1" to="8">
		</param>
		

Using the <automapping> tag with "from" and "to" attributes tells LeLibby to create a continuous range of mapping strings. Care must be taken when specifying the automapping range. Be sure to cover the same range than the parameter can have as numerical range!

The <predefmapping> tag
Finally, some parameters will have the same mapping strings, especially BIT parameters will often have the "OFF" - "ON" mapping for values 0 and 1. If you have a lot of those parameters it would be nice if you could define this mapping once and only refer to that predefined mapping. To do so you have to define a predefined mapping, like:

		<predefmappings>
			<mappinglist id="OFFON">
				<mapping>OFF<mapping>
				<mapping>ON<mapping>
			</mappinglist>
			
			<mappinglist id="somethingelse">
				<automapping from="0" to "7"/>
				<predefmapping ref="OFFON"/>
			</mappinglist>
		</predefmappgins>
		...
		...
		<param name="MFX 1 - OFF/ON" ...  >
			<predefmapping ref="OFFON"/>
		</param>
		

In LeLibby you are able to define <mappinglist> nodes inside the <predefmappings> section. Each of the mapping lists gets an id which can be referred later from within the <predefmapping> node of a <param> element. In a mapping list you can also refer to other mapping lists or use <automapping> nodes as well;

Using those mapping tags works for all of the numerical parameters which have continuously increasing value ranges. For BYTESET parameters this is not true.

Mapping BYTESET parameter values
These parameters could have value sets like 1,2,5,6,11,12. That's why BYTESET parameters do not require min and max attributes (see table above). In this special case we have to define a valueset and mappingset:

	    	<param name="Audio Input 1 Bus Select" type="BYTESET" offs="850">
		      	<valueset>
		        	<value>0</value>
		        	<value>1</value>
		        	<value>6</value>
		        	<value>7</value>
		        	<value>10</value>
		        	<value>12</value>
		      	</valueset>
		      	<mappingset>
		        	<predefmapping ref="AudioInBusSel_Le" />
		      	</mappingset>
	    	</param> 	
		
We Need a <valueset> and <mappingset> child node for BYTESET parameters. By the way, BYTESET parameters may also be used for continuous value ranges. In this case you may use the <autovalue> node as child of the <valueset> element, e.g.

	    	<param name="Audio Input 1 Bus Select" type="BYTESET" offs="850">
	      		<valueset>
	        		<autovalue from="0" to="12" />
	      		</valueset>
	      		<mappingset>
	        		<predefmapping ref="AudioInBusSel_Triton" />
	      		</mappingset>
	    	</param>	
		

Specifying timbre parameters of combinations
As you know combinations use programs (usually max. 8 of them on the Tritons) as their timbres and each timbre has the same parameters, like the MIDI status, key zone, transpose, etc. To specify those parameters in the parameter file one could specify the same parameter for each timbre using the same strategy as explained above, but that's boring. The only thing that changes from timbre to timbre is the offset where the parameter can be found in the PCG data. Fortunately the timbre parameter blocks are stored continuously in the PCG file so it is straightforward to read the timbre parameters in a loop. To instruct LeLibby to do so the <param> node accepts the child nodes

  • <repeats>
  • <blocksize>

Using these tags it is easy to specify timbre parameters, e.g.

	<param name="Timbre %n Volume" type="BYTERANGE" ...>
	        <repeats>7</repeats>
	        <blocksize>28</blocksize>
	        <automapping from="0" to="127" />
	</param>		
	
So what you actually do is to describe a parameter of the first timbre and use the <repeats> tag to specify how often this parameter occurs in subsequent timbres. For Classic and Le models this should always be set to seven. The <blocksize> tag indicates the size of the data block of a timbre, which is always 28 for Classic and Le models.
One thing you might have noticed is the "%n" in the name of the parameter. This simply tells the interpreter to replace the "%n" with the current timbre number.

BYTESET vs. BYTERANGE
Now you might ask why there's a BYTESET and also a BYTERANGE parameter type since a BYTERANGE is just a special case of a BYTESET. The answer is that LeLibby uses different widgets (=graphical elements) to display the parameters. For continuous numerical values a so called JSpinner is used while for BYTESETS a JComboBox is used. So if anyone doesn't like the JSpinner widget he might simply define the respective parameter to a BYTERANGE type and will get a JComboBox from now on.

Final Statement & How To Use
That's the magic about parameter configuration. As you already know LeLibby comes with a predefined parameter definition file which is contained in the jar archive. If you would like to take a look at it you can get it from here. You are welcome to extend the file according to your needs. If you use a private copy of the parameter file, you should use the "--no-preset-params" and "--param-file" arguments when starting LeLibby otherwise you will get parameters displayed twice.

Functional description

GUI Button commands
Move selected items one step up and down
  The selected items are moved by one position forward or backward. If program items are moved LeLibby ensures that combinations - as long as they are available in the PCG - are updated in order to point to the new program positions.
Move selected items 20 steps up and down
  The selected items are moved 20 steps forward or backward. If program items are moved LeLibby ensures that combinations - as long as they are available in the PCG - are updated in order to point to the new program positions.
Move selected items to the previous/subsequent bank
  The selected items of the currently selected bank are exchanged with the corresponding items of the previous or subsequent bank. If program items are moved LeLibby ensures that combinations - as long as they are available in the PCG - are updated in order to point to the new program positions.
Move all items of the selected bank to the previous/next bank
  All items of the currently selected bank are exchanged with the corresponding items of the previous or subsequent bank. If program items are moved LeLibby ensures that combinations - as long as they are available in the PCG - are updated in order to point to the new program positions.
Sort the entire section alphabetically
The items of the current section (i.e. programs, combinations, arps, drum kits) are sorted according to their names in ascending alphabetical order. If the program section is sorted LeLibby ensures that combinations - as long as they are available in the PCG - are updated in order to point to the new program positions.
Sort the entire section categorically
The items of the current section are sorted according to their category in ascending numerical order. If the program section is sorted LeLibby ensures that combinations - as long as they are available in the PCG - are updated in order to point to the new program positions.
Fill the selected bank with copies of the selected item
The selected bank is filled with copies of the currently selected item. Using this feature on programs may affect the sounding of combinations.
Open the global-parameters-dialog
If global data are stored in the PCG this button brings up a dialog where all global parameters can be edited.
Dump the contents of the PCG in text format
The contents of the PCG are dumped as ASCII text to a separate window in a human-readable form.
Dump the contents of the PCG to a HTML file
The contents of the PCG are dumped as HTML to a file. You will be asked for the file name of the HTML file to be generated.
Copy selected items to the other PCG
  The items that are currently selected are copied to the other PCG by overwriting the items in the destination PCG. Note that copying programs may affect the sounding of combinations in the destination PCG that use the overwritten program. For implications on copying combinations refer to chapter 2.
Copy all items of selected bank to the other PCG
  All items of the currently selected bank are copied to the other PCG by overwriting the items in the destination PCG. Note that copying programs may affect the sounding of combinations in the destination PCG that use the overwritten program. For implications on copying combinations refer to chapter 2.
Create an exact copy of a PCG
  An exact copy of the PCG is created and loaded into the other PCG panel.
Compare PCGs
Compares the PCGs (if loaded) and displays the result in a separate dialog
Find all duplicate items of this PCG
The PCG is queried for duplicate items and the results are displayed in a separate dialog in a tree-like style. An item is considered to be a duplicate of another item if both items have the same parameters, i.e. both items are sounding identically. Duplicate items do not necessarily have the same name or category!
Find items by name / pattern
The PCG is queried for items whose names or categories contain the search string and displays the result in a separate dialog in a tree-like style. The query is case-insensitive. The search string may also be composed as a so called "Regular Expression". For example, to search for items that contain the substring "Piano" or the substring "Guitar" one will have to enter a search string like this one: "RE:(.*Piano.*|.*Keyboard.*)". By starting the search string with "RE:" LeLibby knows that a RE follows and interprets the following string as regular expression. RE pattern matching is case-sensitive (in contrast to the simple substring search). For further information on regular expressions visit this page.
Find duplicates of selected items in the other PCG
  The second PCG is queried for duplicates of the items selected in the first PCG and the results are displayed in a separate dialog in a tree-like style. An item is considered to be a duplicate of another item if both items have the same parameters, i.e. both items are sounding identically. Duplicate items do not necessarily have the same name or category!
Initialize duplicate items of a section
A section is queried for duplicates and every duplicate item is then initialized with factory preload data. Initialized items will be named "~Initial Item~" and will belong to the category with the highest ordinal number.
Smart Ordering
Smart Ordering is a method to order items inside a single bank very quickly only by selecting items one after the other. Pressing the Smart Ordering button will make the smart ordering dialog appear. Now you can simply click on any item in the main list you wish add to your smart-ordered list. The items will displayed in the smart ordering dialog. Every item may be added only once to the smart ordering. Right-clicking on an item in the smart order dialog opens a popup menu allowing you to perform several tasks, e.g. delete an item from the smart-ordered list. After you have finished your selection, press the Commit button and LeLibby will order the items accordingly. Note that smart-ordering works only with a single bank.
Navigation Buttons
  Like in a web browser you can use these buttons to navigate between previously selected positions.
Append banks to Bank Archives
If a bank archive is loaded this button opens the bank archive expansion dialog that allows you to add more banks to the bank archive. This button is inactive if a regular PCG file is loaded.
Processing Error Indicator
  LeLibby generates error traces if any failure during PCG processing occurs. Although this should not be the case very frequently it will be good to know why an error occured (especially it is good to know for the author).
The error indicator will show up in a steady green color as long as everything is consistent. As soon as somthing unusual happens the indicator will start blinking. Clicking on the indicator will then open the trace window where a message describing the failure reason will be displayed. At the same time the indicator will stop blinking to show that the user has noticed the event.
Update Indicator
Appears if a newer version than the installed version is available for download. Clicking on the indicator will open an information dialog telling you some details about the available updates.

Common context menu commands
Select All Selects all items of the current bank
Select None Clears the selection of the current bank
Sort bank alphabetically The items of the current bank are sorted according to their names in ascending alphabetical order. If a program bank is sorted LeLibby ensures that combinations - as long as they are available in the PCG - are updated in order to point to the new program positions.
Sort bank categorically The items of the current bank are sorted according to their category in ascending numerical order. If the program section is sorted LeLibby ensures that combinations - as long as they are available in the PCG - are updated in order to point to the new program positions.

Common context menu commands specific to program banks
Search unused timbres This item is available if the context menu is popped up on a program bank. It is used to find programs that are not used by any combination. Of course, this command will only work if combination data is available in the same PCG.

Context menu commands on selected items
Edit The parameters of the selected item show up in a separate dialog and can be modified there. Double-Clicking on the item has the same effect.
Pack Non-continuous selections of bank items are re-ordered into a continuous selection.
Sort selected items alphabetically The selected items of the current bank are sorted according to their names in ascending alphabetical order. If program items are sorted LeLibby ensures that combinations - as long as they are available in the PCG - are updated in order to point to the new program positions.
Sort selected items categorically The selected items of the current bank are sorted according to their category in ascending numerical order. If the program section is sorted LeLibby ensures that combinations - as long as they are available in the PCG - are updated in order to point to the new program positions.
Search duplicates of '{item}' Searches the entire section for duplicates of the selected item of the current bank and displays the result in a separate dialog in a tree-like style.
Search duplicates of selected items Searches the entire section for duplicates of all selected items of the current bank and displays the result in a separate dialog in a tree-like style.
Hex Dump of '{item}' Displays a hex dump of the selected item of the current bank in a separate text window.
Hex Dump of selected items Displays a hex dump of all selected items of the current bank in a separate text window.

Context menu commands specific to selected programs
Find combis using '{item}' If available in the PCG all combinations are queried for references to the selected program. The result is displayed in a separate dialog in a tree-like style.
Find combis using selected timbres If available in the PCG all combinations are queried for references to the selected programs. A combination is considered to be matching if at least one of the selected items is used as timbre. The result is displayed in a separate dialog in a tree-like style.

Context menu commands specific to selected combinations
List timbres of '{item}' Displays the list of programs that are used by the selected combi in a separate dialog.
List timbres of selected timbres Displays the list of programs for each of the selected combi in a separate dialog.

Context menu commands specific to bank archive processing
Change Bank Name Allows you to change the bank name of a bank archive bank. This item will not be visible if a regular PCG file is loaded.

The Clipboard
Copy Copies the selected items to the clipboard.
Paste '{item}' Overwrites the context item (item under the mouse cursor, doesn't have to be selected) with the item from the clipboard if applicable. The following list summarizes which items may be overwritten by others:

  • Items in the same section of the same PCG
  • Items in the same type of section on the second PCG. If the PCGs are from different Triton models automatic conversion is provided for programs and combinations.
  • Combination items may be overwritten by program items of the same PCG (new with LeLibby V0.9.3).
As the item will not be deleted from the clipboard after overwriting this action can be repeated as often as you like.
Paste Overwrites items with the items from the clipboard beginning with the context item. All other restrictions apply as for overwriting single items.
Paste as Combi '{item}' This command is available if the clipboard contains program items and the context menu is opened on a combination item in the same PCG. Pasting a program on a combination creates a combination that uses the copied program as its timbres. Only the first timbre will be set to sound. Effect and controller settings are preserved from the program so the new combination will behave equally to the program.
Exchange with '{item}' Exchanges the context item with the original item the clipboard item is a copy of. The following list summarizes which items may be exchanged with others:

  • Items in the same section of the same PCG
  • Items in the same type of section on the second PCG. If the PCGs are from different Triton models automatic conversion is provided for programs and combinations.
Exchange with copied items Exchanges items with the items from the clipboard starting with the context item. All other restrictions apply as for exchanging single items.
Compare with '{item}' Compares the context item with the item on the clipboard. The result of the comparison is displayed in a separate dialog.

Drag & Drop support
In principle Drag & Drop does the same things like copying items between two different PCGs. Thus, the same restrictions as for overwriting items with items from the clipboard apply. Drag & Drop does not work within the same bank of the same PCG. To do Drag&Drop follow these steps:

  • Select the item(s) you want to copy to the other PCG
  • Click on one of the selected items and drag the items to the destination PCG
  • Release the mouse button above the destination item to

Managing combinations with the Combi-Copy-Wizard

Transferring Combinations between PCG files
The basic principle when copying combis between PCGs is that the copied destination combi sounds like the source combi. This implies that all programs used by a timbre also have to be copied to the destination PCG which is only possible if the destination PCG contains program banks. If the destination PCG does not contain program banks only the "pure" combination data without the referenced programs will be copied.

Combination copying is now done exclusively with the Combi-Copy-Wizard. It gives you very flexible control over how combinations and their corresponding timbre programs are copied from PCG to PCG. Thereby it lets you decide where to place timbre programs in the destination PCG either by different assignment policies (see below) or by individual assigment of destination programs.

Not let's take a look how the Combi-Copy-Wizard supports you in copying combinations. Whenever you try to copy combinations between PCGs the Combi-Copy-Wizard GUI opens automatically:

CombiCopyWizard GUI
The Combi-Copy-Wizard's GUI

The GUI is devided into four areas:

  • Combis to be copied
    All combinations that you have selected for being copied are displayed including their timbre programs. In front of each timbre you can see an icon indicating the MIDI status of the timbre:
    • The black note symbol refers to MIDI Status INT indicating that this timbre will be played back from the instrument's internal sound generator (via the Global MIDI channel).
    • The red rest symbol refers to MIDI Status OFF. These timbres are muted and are not played back at all.
    • The blue X symbol refers to MIDI Status EXT. MIDI events for those timbres are routed to their own MIDI channel.
    • The blue x2 symbol refers to MIDI Status EX2. MIDI events for those timbres are routed to their own MIDI channel.
    If you don't want timbres to be copied that are not played back from your instrument's internal sound generator you may set the destination program to "<<< not copied >>>" (see below).

  • Combis/Timbres to be overwritten
    Shows the list of combination and program locations that will be overwritten, e.g. Combi A013:Big Jazz Band will overwrite I-B013:ClassicAnaString. Timbre 1 which is C014:Sax Ensemble will overwrite I-C014:Stereo WaveSweep and so on. When selecting a timbre (left mouse click) a list of combinations which currently use this program will be displayed in the "Affected Destination Combis". You may notice that certain programs are displayed in different colors. The green color means that this program is not used by any combination in the destination PCG. Programs displayed in blue color indicate General MIDI programs which are not part of the destination PCG. Some timbres are shown as "<<< not copied >>>" which means that these timbres will be ignored and therefore not be copied from the source.

  • Affected Destination Combis
    If a program in the list of "Combis/Timbres to be overwritten" is selected this area shows the combinations of the destination PCG that use the selected program.

  • Timbre Assignment Policies
    On top of this are there's a combo box which will be activated when you select a program in the list of "Combis/Timbres to be overwritten". Using this combo box you may manually assign the destination program that will be overwritten. Like in the list of "Combis/Timbres to be overwritten" programs highlighted in green color indicate that they are not used by any combination in the destination PCG.

    Located beneath the combo box there are four policy assignment buttons. Using these buttons causes the Combi-Copy-Wizard to assign destination programs to be overwritten based on certain criteria. You can find detailed descriptions of each policy in the table below.

    Only Internal MIDI Timbres

    By activating this check box you tell LeLibby to ignore timbres that are not played back via the global MIDI channel in preset calculations. Many combis do not use all of their timbres and therefore you might wish only the sounding programs to be copied. If this is the case activate this check box. By default this feature is turned off.

    Copy Program References

    Internally a combination has lots of parameters describing the common combination attributes (like the combination name, category, used effects and Master-EQ settings) and a number of parameters specific to a timbre.

          Combination Structure
          +-------------------+
          | Noisy Stabber     |
          | ...               |  Common data block
          |                   |
          +----+----+----+----+
          | T1 | T2 | .. | T8 |
          |    |    |    |    |  Timbre data blocks
          | r1 | r2 | .. | r8 |
          |    |    |    |    |
          | .. | .. | .. | .. |
          |    |    |    |    |
          +----+----+----+----+ 
     
    Two special parameters of each timbre are the program bank and program index (r1..r8) referencing the program that is used as the timbre, so let's call them Program References. Using the "Copy Program References" check box you specify, whether the timbre data blocks are copied to the destination combi, if the referenced program is not available in the destination PCG (because the bank was not stored...). In versions prior to 0.9.6.2 timbre data blocks were not copied in such cases by default. Since version 0.9.6.2 this decision may be done by the user (although it is a good idea to have it enabled all the time, unless you really know what you do :-) ).

When you are finished with selecting the destination programs to be overwritten simply press the "Apply" button and LeLibby will copy the combinations according to your settings.

Destination Timbre Assignment Policies
Max. Possible The "Max. Possible" policy is the default preset that is used when the Combi-Copy-Wizard is started. It tries to
  1. assign source programs to equal programs in the destination PCG. If not applicable it tries to
  2. assign source programs to destination programs that are not used by combinations. If not applicable
  3. source programs are assigned to their equivalent position in the destination PCG.
Unused Only The "Find Unused" policy tries to find as much programs in the destination PCG that are not used by combinations. If no more unused programs are available then programs are assigned to their equivalent position in the destination PCG
1 : 1 The "1 : 1" policy simply assignes the source programs to their equivalent position in the destination PCG
Sequential The source programs are assigned to the destination programs starting with the first program of the first combination.

Bank Archives

What are Bank Archives

Bank Archive creation dialog
The Bank Archive creation dialog
Creating Bank Archives
documentation pending
Expanding Bank Archives
documentation pending