--- libgig/trunk/src/gig.cpp	2014/05/31 20:54:39	2584
+++ libgig/trunk/src/gig.cpp	2014/06/07 15:19:58	2601
@@ -3759,6 +3759,56 @@
         return dimreg;
     }
 
+    int Region::GetDimensionRegionIndexByValue(const uint DimValues[8]) {
+        uint8_t bits;
+        int veldim = -1;
+        int velbitpos;
+        int bitpos = 0;
+        int dimregidx = 0;
+        for (uint i = 0; i < Dimensions; i++) {
+            if (pDimensionDefinitions[i].dimension == dimension_velocity) {
+                // the velocity dimension must be handled after the other dimensions
+                veldim = i;
+                velbitpos = bitpos;
+            } else {
+                switch (pDimensionDefinitions[i].split_type) {
+                    case split_type_normal:
+                        if (pDimensionRegions[0]->DimensionUpperLimits[i]) {
+                            // gig3: all normal dimensions (not just the velocity dimension) have custom zone ranges
+                            for (bits = 0 ; bits < pDimensionDefinitions[i].zones ; bits++) {
+                                if (DimValues[i] <= pDimensionRegions[bits << bitpos]->DimensionUpperLimits[i]) break;
+                            }
+                        } else {
+                            // gig2: evenly sized zones
+                            bits = uint8_t(DimValues[i] / pDimensionDefinitions[i].zone_size);
+                        }
+                        break;
+                    case split_type_bit: // the value is already the sought dimension bit number
+                        const uint8_t limiter_mask = (0xff << pDimensionDefinitions[i].bits) ^ 0xff;
+                        bits = DimValues[i] & limiter_mask; // just make sure the value doesn't use more bits than allowed
+                        break;
+                }
+                dimregidx |= bits << bitpos;
+            }
+            bitpos += pDimensionDefinitions[i].bits;
+        }
+        dimregidx &= 255;
+        DimensionRegion* dimreg = pDimensionRegions[dimregidx];
+        if (!dimreg) return -1;
+        if (veldim != -1) {
+            // (dimreg is now the dimension region for the lowest velocity)
+            if (dimreg->VelocityTable) // custom defined zone ranges
+                bits = dimreg->VelocityTable[DimValues[veldim] & 127];
+            else // normal split type
+                bits = uint8_t((DimValues[veldim] & 127) / pDimensionDefinitions[veldim].zone_size);
+
+            const uint8_t limiter_mask = (1 << pDimensionDefinitions[veldim].bits) - 1;
+            dimregidx |= (bits & limiter_mask) << velbitpos;
+            dimregidx &= 255;
+        }
+        return dimregidx;
+    }
+
     /**
      * Returns the appropriate DimensionRegion for the given dimension bit
      * numbers (zone index). You usually use <i>GetDimensionRegionByValue</i>
@@ -4129,6 +4179,16 @@
         this->pGroup = pGroup;
     }
 
+    /**
+     * Returns the script group this script currently belongs to. Each script
+     * is a member of exactly one ScriptGroup.
+     *
+     * @returns current script group
+     */
+    ScriptGroup* Script::GetGroup() const {
+        return pGroup;
+    }
+
     void Script::RemoveAllScriptReferences() {
         File* pFile = pGroup->pFile;
         for (int i = 0; pFile->GetInstrument(i); ++i) {
@@ -4610,7 +4670,25 @@
         scriptPoolFileOffsets.clear();
     }
 
-    /** @brief Add new instrument script slot (gig format extension)
+    /** @brief Get instrument script (gig format extension).
+     *
+     * Returns the real-time instrument script of instrument script slot
+     * @a index.
+     *
+     * @note This is an own format extension which did not exist i.e. in the
+     * GigaStudio 4 software. It will currently only work with LinuxSampler and
+     * gigedit.
+     *
+     * @param index - instrument script slot index
+     * @returns script or NULL if index is out of bounds
+     */
+    Script* Instrument::GetScriptOfSlot(uint index) {
+        LoadScripts();
+        if (index >= pScriptRefs->size()) return NULL;
+        return pScriptRefs->at(index).script;
+    }
+
+    /** @brief Add new instrument script slot (gig format extension).
      *
      * Add the given real-time instrument script reference to this instrument,
      * which shall be executed by the sampler for for this instrument. The