diff --git a/pom.xml b/pom.xml
index 460f126..3129687 100644
--- a/pom.xml
+++ b/pom.xml
@@ -21,7 +21,7 @@
     <groupId>com.miraisolutions</groupId>
     <artifactId>XLConnect</artifactId>
     <packaging>jar</packaging>
-    <version>2.0.1-SNAPSHOT</version>
+    <version>3.0.0-SNAPSHOT</version>
     <name>XLConnect</name>
     <url>https://mirai-solutions.ch/</url>
     <repositories>
diff --git a/src/main/java/com/miraisolutions/xlconnect/Attribute.java b/src/main/java/com/miraisolutions/xlconnect/Attribute.java
new file mode 100644
index 0000000..2bb150b
--- /dev/null
+++ b/src/main/java/com/miraisolutions/xlconnect/Attribute.java
@@ -0,0 +1,10 @@
+package com.miraisolutions.xlconnect;
+
+public enum Attribute {
+    WORKSHEET_SCOPE {
+        @Override
+        public String toString() {
+            return "worksheetScope";
+        }
+    }
+}
diff --git a/src/main/java/com/miraisolutions/xlconnect/BooleanWithAttributes.java b/src/main/java/com/miraisolutions/xlconnect/BooleanWithAttributes.java
new file mode 100644
index 0000000..ca944eb
--- /dev/null
+++ b/src/main/java/com/miraisolutions/xlconnect/BooleanWithAttributes.java
@@ -0,0 +1,25 @@
+package com.miraisolutions.xlconnect;
+
+public class BooleanWithAttributes extends ResultWithAttributes implements WithJNI{
+
+    private final boolean value;
+
+    public BooleanWithAttributes(Attribute attributeName, String attributeValue, boolean value) {
+        super(attributeName, attributeValue);
+        this.value = value;
+    }
+
+    public BooleanWithAttributes(boolean value) {
+        super();
+        this.value = value;
+    }
+
+    public boolean getValue() {
+        return value;
+    }
+
+    @Override
+    public String jni() {
+        return "Z";
+    }
+}
diff --git a/src/main/java/com/miraisolutions/xlconnect/DataFrameWithAttributes.java b/src/main/java/com/miraisolutions/xlconnect/DataFrameWithAttributes.java
new file mode 100644
index 0000000..3d72629
--- /dev/null
+++ b/src/main/java/com/miraisolutions/xlconnect/DataFrameWithAttributes.java
@@ -0,0 +1,19 @@
+package com.miraisolutions.xlconnect;
+
+import com.miraisolutions.xlconnect.data.DataFrame;
+
+public class DataFrameWithAttributes extends ResultWithAttributes{
+
+    private final DataFrame value;
+
+    public DataFrameWithAttributes(Attribute attributeName, String attributeValue, DataFrame value) {
+        super(attributeName, attributeValue);
+        this.value = value;
+    }
+
+
+    public DataFrame getValue() {
+        return value;
+    }
+
+}
diff --git a/src/main/java/com/miraisolutions/xlconnect/RDataFrameWithAttributes.java b/src/main/java/com/miraisolutions/xlconnect/RDataFrameWithAttributes.java
new file mode 100644
index 0000000..3306c63
--- /dev/null
+++ b/src/main/java/com/miraisolutions/xlconnect/RDataFrameWithAttributes.java
@@ -0,0 +1,20 @@
+package com.miraisolutions.xlconnect;
+
+import com.miraisolutions.xlconnect.integration.r.RDataFrameWrapper;
+
+import java.util.Map;
+
+public class RDataFrameWithAttributes extends ResultWithAttributes{
+
+    private final RDataFrameWrapper value;
+
+    public RDataFrameWithAttributes(Map<String, String[]> attributes, RDataFrameWrapper value) {
+        super(attributes);
+        this.value = value;
+    }
+
+    public RDataFrameWrapper getValue() {
+        return value;
+    }
+    
+}
diff --git a/src/main/java/com/miraisolutions/xlconnect/ResultWithAttributes.java b/src/main/java/com/miraisolutions/xlconnect/ResultWithAttributes.java
new file mode 100644
index 0000000..83112ea
--- /dev/null
+++ b/src/main/java/com/miraisolutions/xlconnect/ResultWithAttributes.java
@@ -0,0 +1,42 @@
+package com.miraisolutions.xlconnect;
+
+
+import java.util.*;
+
+/**
+ * Represent attributes to be set on an object in R as part of the result to be returned.
+ * Should be extended for each required type. Not using a generic typed value, because it looks like R can't retrieve it
+ * in a specific subtype (we get an Object instance).
+ */
+class ResultWithAttributes {
+
+    private final Map<String,String[]> attributes;
+
+    public ResultWithAttributes(Map<String,String[]> theAttributes) {
+        this.attributes = theAttributes;
+    }
+
+    public ResultWithAttributes() {
+        this(Collections.emptyMap());
+    }
+
+    public ResultWithAttributes(Attribute attributeName, String attributeValue) {
+        this(Collections.singletonMap(attributeName.toString(), new String[]{attributeValue}));
+    }
+
+    public Map<String, String[]> getAttributes() {
+        return Collections.unmodifiableMap(attributes);
+    }
+
+    public String[] getAttributeNames() {
+        return attributes.keySet().toArray(new String[0]);
+    }
+
+    /* public String[] getAttributeValues() {
+        return attributes.values().toArray(new String[0]);
+    }*/
+
+    public String[] getAttributeValue(String attributeName){
+        return attributes.get(attributeName);
+    }
+}
diff --git a/src/main/java/com/miraisolutions/xlconnect/WithJNI.java b/src/main/java/com/miraisolutions/xlconnect/WithJNI.java
new file mode 100644
index 0000000..f6efc33
--- /dev/null
+++ b/src/main/java/com/miraisolutions/xlconnect/WithJNI.java
@@ -0,0 +1,8 @@
+package com.miraisolutions.xlconnect;
+
+public interface WithJNI {
+    /**
+     * @return the JNI to use for the getValue() method
+     */
+    String jni();
+}
diff --git a/src/main/java/com/miraisolutions/xlconnect/Workbook.java b/src/main/java/com/miraisolutions/xlconnect/Workbook.java
index d47618b..ff21338 100644
--- a/src/main/java/com/miraisolutions/xlconnect/Workbook.java
+++ b/src/main/java/com/miraisolutions/xlconnect/Workbook.java
@@ -41,6 +41,9 @@
 import java.util.*;
 import java.util.function.Consumer;
 import java.util.stream.IntStream;
+import java.util.stream.Collectors;
+
+import static com.miraisolutions.xlconnect.Attribute.WORKSHEET_SCOPE;
 
 
 /**
@@ -222,11 +225,12 @@ public void setSheetPos(String sheetName, int pos) {
         workbook.setSheetOrder(sheetName, pos);
     }
 
-    public String[] getDefinedNames(boolean validOnly) {
+    public String[] getDefinedNames(boolean validOnly, String worksheetScope) {
+
         return workbook.getAllNames().stream()
-                .filter(namedRegion -> !validOnly || isValidNamedRegion(namedRegion))
-                .map(Name::getNameName)
-                .toArray(String[]::new);
+                .filter(n -> (!validOnly || isValidNamedRegion(n)) &&
+                        (worksheetScope == null || n.getSheetIndex() == getSheetIndexForScope(worksheetScope)))
+                .map(Name::getNameName).toArray(String[]::new);
     }
 
 
@@ -234,6 +238,18 @@ private boolean isValidNamedRegion(Name region) {
         return !region.isDeleted() && hasValidWorkSheet(region);
     }
 
+    /**
+     * Returns the sheet index for the worksheet name or -1 if the sheet name is ""
+     * @param worksheetScope the worksheet name
+     * @throws NoSuchElementException if no worksheet exists with this name
+     */
+    private int getSheetIndexForScope(String worksheetScope) {
+        if (worksheetScope.isEmpty()) return -1;
+        int index = workbook.getSheetIndex(worksheetScope);
+        if (index < 0) throw new NoSuchElementException("Worksheet " + worksheetScope + " was not found!");
+        else return index;
+    }
+
     private boolean hasValidWorkSheet(Name region) {
         String sheetName = null;
         try {
@@ -247,10 +263,22 @@ public boolean existsSheet(String name) {
         return workbook.getSheet(name) != null;
     }
 
-    public boolean existsName(String name) {
-        return workbook.getName(name) != null;
+    public BooleanWithAttributes existsName(String name, String worksheetScope) {
+        try {
+            Name found = getName(name, worksheetScope);
+            String foundInScope = effectiveScope(worksheetScope, found);
+            return new BooleanWithAttributes(WORKSHEET_SCOPE, foundInScope, true);
+        } catch (IllegalArgumentException ignored) {
+            warnings.add(ignored.getMessage());
+            return worksheetScope != null ? new BooleanWithAttributes(WORKSHEET_SCOPE, worksheetScope, false) : new BooleanWithAttributes(false);
+        }
+    }
+
+    private String effectiveScope(String worksheetScope, Name found) {
+        return worksheetScope != null ? worksheetScope : found.getSheetIndex() >= 0 ? getSheet(found.getSheetIndex()).getSheetName() : "";
     }
 
+
     public void createSheet(String name) {
         if (name.length() > 31)
             throw new IllegalArgumentException("Sheet names are not allowed to contain more than 31 characters!");
@@ -279,56 +307,65 @@ public void renameSheet(String name, String newName) {
     }
 
     public void cloneSheet(int index, String newName) {
-        cloneSheet(workbook.getSheetName(index), newName);
+        Sheet sheet = workbook.cloneSheet(index);
+        String originalName = workbook.getSheetName(index);
+        workbook.setSheetName(workbook.getSheetIndex(sheet), newName);
+        // Copy names (named ranges) that are scoped to the original sheet, adapting the scope.
+        List<Name> originalNamedRanges = workbook.getAllNames().stream().filter(name -> name.getSheetIndex() == index).collect(Collectors.toList());
+        // we have to collect the original names *then* add the new names, otherwise we get concurrency issues creating names while iterating over them
+        originalNamedRanges.forEach(namedRange ->
+                createName(namedRange.getNameName(), namedRange.getRefersToFormula(), false, newName));
     }
 
     public void cloneSheet(String name, String newName) {
-        Sheet sheet = workbook.cloneSheet(workbook.getSheetIndex(name));
-        workbook.setSheetName(workbook.getSheetIndex(sheet), newName);
+        cloneSheet(workbook.getSheetIndex(name), newName);
     }
 
-    public void createName(String name, String formula, boolean overwrite) {
-        if (existsName(name)) {
+    public void createName(String name,  String formula, boolean overwrite, String worksheetScope) {
+        if (existsName(name, worksheetScope).getValue()) {
             if (overwrite) {
                 // Name already exists but we overwrite --> remove
-                removeName(name);
+                removeName(name, worksheetScope);
             } else {
                 // Name already exists, but we don't want to overwrite --> error
-                throw new IllegalArgumentException("Specified name '" + name + "' already exists!");
+                throw new IllegalArgumentException("Specified name '" + name + "' already exists " + displayWorksheetScope(worksheetScope));
             }
         }
 
         Name cname = workbook.createName();
+        if(worksheetScope != null) {
+            int sheetIndex = getSheetIndexForScope(worksheetScope);
+            if(sheetIndex >= 0) cname.setSheetIndex(sheetIndex);
+        }
         try {
             cname.setNameName(name);
             cname.setRefersToFormula(formula);
         } catch (Exception e) {
             // --> Clean up (= remove) name
             // Need to set dummy name in order to be able to remove it ...
-            String dummyNameName = "XLConnectDummyName";
-            cname.setNameName(dummyNameName);
-            removeName(dummyNameName);
+            workbook.removeName(cname);
             throw new IllegalArgumentException(e);
         }
     }
 
-    public void removeName(String name) {
-        Name cname = workbook.getName(name);
-        if (cname != null)
+    public void removeName(String name, String worksheetScope) {
+        if (existsName(name, worksheetScope).getValue()) {
+            Name cname = getName(name, worksheetScope);
             workbook.removeName(cname);
+        }
     }
 
-    public String getReferenceFormula(String name) {
-        return getName(name).getRefersToFormula();
+    public String getReferenceFormula(String name, String worksheetScope) {
+        return getName(name, worksheetScope).getRefersToFormula();
     }
 
     // Keep for backwards compatibility
     public int[] getReferenceCoordinates(String name) {
-        return getReferenceCoordinatesForName(name);
+        return getReferenceCoordinatesForName(name, null);
     }
 
-    public int[] getReferenceCoordinatesForName(String name) {
-        Name cname = getName(name);
+    public int[] getReferenceCoordinatesForName(String name, String worksheetScope) {
+        Name cname = getName(name, worksheetScope);
         AreaReference aref = new AreaReference(cname.getRefersToFormula(), workbook.getSpreadsheetVersion());
         // Get upper left corner
         CellReference first = aref.getFirstCell();
@@ -576,8 +613,8 @@ public void onErrorCell(ErrorBehavior eb) {
         this.onErrorCell = eb;
     }
 
-    public void writeNamedRegion(DataFrame data, String name, boolean header, boolean overwriteFormulaCells) {
-        Name cname = getName(name);
+    public void writeNamedRegion(DataFrame data, String name, boolean header, boolean overwriteFormulaCells, String worksheetScope) {
+        Name cname = getName(name, worksheetScope);
         checkName(cname);
 
         // Get sheet where name is defined in
@@ -603,10 +640,11 @@ public void writeNamedRegion(DataFrame data, String name, boolean header, boolea
         writeData(data, sheet, topLeft.getRow(), topLeft.getCol(), header, overwriteFormulaCells);
     }
 
-    public DataFrame readNamedRegion(String name, boolean header, ReadStrategy readStrategy, DataType[] colTypes,
-                                     boolean forceConversion, String dateTimeFormat, boolean takeCached, int[] subset) {
-        Name cname = getName(name);
+    public DataFrameWithAttributes readNamedRegion(String name, boolean header, DataType[] colTypes, boolean forceConversion, String dateTimeFormat,
+                                                   boolean takeCached, int[] subset, ReadStrategy readStrategy, String worksheetScope) {
+        Name cname = getName(name, worksheetScope);
         checkName(cname);
+        String foundInScope = effectiveScope(worksheetScope, cname);
 
         // Get sheet where name is defined in
         Sheet sheet = workbook.getSheet(cname.getSheetName());
@@ -620,8 +658,8 @@ public DataFrame readNamedRegion(String name, boolean header, ReadStrategy readS
         int nrows = bottomRight.getRow() - topLeft.getRow() + 1;
         int ncols = bottomRight.getCol() - topLeft.getCol() + 1;
 
-        return readData(sheet, topLeft.getRow(), topLeft.getCol(), nrows, ncols, header, readStrategy, colTypes,
-                forceConversion, dateTimeFormat, takeCached, subset);
+        return new DataFrameWithAttributes(WORKSHEET_SCOPE, foundInScope, readData(sheet, topLeft.getRow(), topLeft.getCol(), nrows, ncols, header, readStrategy, colTypes,
+                forceConversion, dateTimeFormat, takeCached, subset));
     }
 
     public DataFrame readTable(int worksheetIndex, String tableName, boolean header, ReadStrategy readStrategy,
@@ -656,7 +694,10 @@ public void writeWorksheet(DataFrame data, int worksheetIndex, int startRow, int
     }
 
     public void writeWorksheet(DataFrame data, String worksheetName, int startRow, int startCol, boolean header, boolean overwriteFormulaCells) {
-        writeWorksheet(data, workbook.getSheetIndex(worksheetName), startRow, startCol, header, overwriteFormulaCells);
+        int sheetIndex = workbook.getSheetIndex(worksheetName);
+        if(sheetIndex < 0)
+            throw new NoSuchElementException("Worksheet " + worksheetName + " was not found!");
+        writeWorksheet(data, sheetIndex, startRow, startCol, header, overwriteFormulaCells);
     }
 
     public void writeWorksheet(DataFrame data, int worksheetIndex, boolean header, boolean overwriteFormulaCells) {
@@ -715,8 +756,29 @@ public DataFrame readWorksheet(String worksheetName, int startRow, int startCol,
                 colTypes, forceConversion, dateTimeFormat, takeCached, subset, autofitRow, autofitCol);
     }
 
-    public void addImage(File imageFile, String name, boolean originalSize) throws IOException {
-        Name cname = getName(name);
+    public DataFrame readWorksheet(String worksheetName, int startRow, int startCol, int endRow, int endCol, boolean header) {
+        return readWorksheet(worksheetName, startRow, startCol, endRow, endCol, header, ReadStrategy.DEFAULT, 
+                null, false, "", false, null, true, true);
+    }
+    
+    public DataFrame readWorksheet(String worksheetName, int startRow, int startCol, int endRow, int endCol, boolean header,
+            boolean autofitRow, boolean autofitCol) {
+        return readWorksheet(worksheetName, startRow, startCol, endRow, endCol, header, ReadStrategy.DEFAULT,
+                null, false, "", false, null, autofitRow, autofitCol);
+    }
+
+    public DataFrame readWorksheet(String worksheetName, boolean header, ReadStrategy readStrategy, DataType[] colTypes, 
+            boolean forceConversion, String dateTimeFormat) {
+        return readWorksheet(worksheetName, -1, -1, -1, -1, header, readStrategy, colTypes, forceConversion, 
+                dateTimeFormat, false, null, true, true);
+    }
+
+    public DataFrame readWorksheet(String worksheetName, boolean header) {
+        return readWorksheet(worksheetName, header, ReadStrategy.DEFAULT, null, false, "");
+    }
+
+    public void addImage(File imageFile, String name, String worksheetScope, boolean originalSize) throws IOException {
+        Name cname = getName(name, worksheetScope);
 
         // Get sheet where name is defined in
         Sheet sheet = workbook.getSheet(cname.getSheetName());
@@ -726,7 +788,23 @@ public void addImage(File imageFile, String name, boolean originalSize) throws I
         CellReference topLeft = aref.getFirstCell();
         CellReference bottomRight = aref.getLastCell();
 
-        int imageType = getImageType(imageFile);
+        // Determine image type
+        int imageType;
+        String filename = imageFile.getName().toLowerCase();
+        if(filename.endsWith("jpg") || filename.endsWith("jpeg")) {
+            imageType = org.apache.poi.ss.usermodel.Workbook.PICTURE_TYPE_JPEG;
+        } else if(filename.endsWith("png")) {
+            imageType = org.apache.poi.ss.usermodel.Workbook.PICTURE_TYPE_PNG;
+        } else if(filename.endsWith("wmf")) {
+            imageType = org.apache.poi.ss.usermodel.Workbook.PICTURE_TYPE_WMF;
+        } else if(filename.endsWith("emf")) {
+            imageType = org.apache.poi.ss.usermodel.Workbook.PICTURE_TYPE_EMF;
+        } else if(filename.endsWith("bmp") || filename.endsWith("dib")) {
+            imageType = org.apache.poi.ss.usermodel.Workbook.PICTURE_TYPE_DIB;
+        } else if(filename.endsWith("pict") || filename.endsWith("pct") || filename.endsWith("pic")) {
+            imageType = org.apache.poi.ss.usermodel.Workbook.PICTURE_TYPE_PICT;
+        } else
+            throw new IllegalArgumentException("Image type \""+ filename.substring(filename.lastIndexOf('.')+1) +"\" not supported!");
         InputStream is = Files.newInputStream(imageFile.toPath());
         byte[] bytes = IOUtils.toByteArray(is);
         int imageIndex = workbook.addPicture(bytes, imageType);
@@ -754,31 +832,11 @@ public void addImage(File imageFile, String name, boolean originalSize) throws I
         anchor.setAnchorType(ClientAnchor.AnchorType.DONT_MOVE_AND_RESIZE);
 
         Picture picture = drawing.createPicture(anchor, imageIndex);
-        if (originalSize) picture.resize();
-    }
-
-    private static int getImageType(File imageFile) {
-        int imageType;
-        String filename = imageFile.getName().toLowerCase();
-        if (filename.endsWith("jpg") || filename.endsWith("jpeg")) {
-            imageType = org.apache.poi.ss.usermodel.Workbook.PICTURE_TYPE_JPEG;
-        } else if (filename.endsWith("png")) {
-            imageType = org.apache.poi.ss.usermodel.Workbook.PICTURE_TYPE_PNG;
-        } else if (filename.endsWith("wmf")) {
-            imageType = org.apache.poi.ss.usermodel.Workbook.PICTURE_TYPE_WMF;
-        } else if (filename.endsWith("emf")) {
-            imageType = org.apache.poi.ss.usermodel.Workbook.PICTURE_TYPE_EMF;
-        } else if (filename.endsWith("bmp") || filename.endsWith("dib")) {
-            imageType = org.apache.poi.ss.usermodel.Workbook.PICTURE_TYPE_DIB;
-        } else if (filename.endsWith("pict") || filename.endsWith("pct") || filename.endsWith("pic")) {
-            imageType = org.apache.poi.ss.usermodel.Workbook.PICTURE_TYPE_PICT;
-        } else
-            throw new IllegalArgumentException("Image type \"" + filename.substring(filename.lastIndexOf('.') + 1) + "\" not supported!");
-        return imageType;
+        if(originalSize) picture.resize();
     }
 
-    public void addImage(String filename, String name, boolean originalSize) throws IOException {
-        addImage(new File(filename), name, originalSize);
+    public void addImage(String filename, String name, boolean originalSize, String worksheetScope) throws IOException {
+        addImage(new File(filename), name, worksheetScope, originalSize);
     }
 
     public CellStyle createCellStyle(String name) {
@@ -911,6 +969,30 @@ Name getName(String name) {
             throw new IllegalArgumentException("Name '" + name + "' does not exist!");
     }
 
+    List<Name> getNames(String name) {
+        return Collections.unmodifiableList(workbook.getNames(name));
+    }
+
+    private Name getName(String name, String worksheetScope) {
+        if (worksheetScope == null)
+            return getName(name);
+        int sheetIndex = getSheetIndexForScope(worksheetScope);
+        List<Name> cNames = getNames(name);
+        for (Name n : cNames)
+            if (n.getSheetIndex() == sheetIndex)
+                return n;
+
+        StringBuffer names = new StringBuffer();
+        String worksheetScopeDisplay = displayWorksheetScope(worksheetScope);
+        cNames.forEach(n -> names.append(n.getSheetIndex() >= 0 ? workbook.getSheetName(n.getSheetIndex()) : "global scope").append(";"));
+        throw new IllegalArgumentException("Name '" + name + "' was not specified '" + worksheetScopeDisplay + "'! " +
+                "Found in sheets: " + names);
+    }
+
+    private String displayWorksheetScope(String worksheetScope) {
+        return null == worksheetScope ? "" : worksheetScope.isEmpty() ? "in global scope" : "in " +worksheetScope;
+    }
+
     // Checks only if the reference as such is valid
     private boolean isValidReference(String reference) {
         return reference != null && !reference.startsWith("#REF!") && !reference.startsWith("#NULL!");
@@ -1375,18 +1457,19 @@ public int getLastColumn(String sheetName) {
         return getLastColumn(getSheet(sheetName));
     }
 
-    public void appendNamedRegion(DataFrame data, String name, boolean header, boolean overwriteFormulaCells) {
-        Sheet sheet = workbook.getSheet(getName(name).getSheetName());
+    public void appendNamedRegion(DataFrame data, String name, boolean header, boolean overwriteFormulaCells, String worksheetScope) {
+        Sheet sheet = workbook.getSheet(getName(name, worksheetScope).getSheetName());
         // top, left, bottom, right
-        int[] coord = getReferenceCoordinates(name);
+        int[] coord = getReferenceCoordinatesForName(name, worksheetScope);
         writeData(data, sheet, coord[2] + 1, coord[1], header, overwriteFormulaCells);
         int bottom = coord[2] + data.rows();
         int right = Math.max(coord[1] + data.columns() - 1, coord[3]);
         CellRangeAddress cra = new CellRangeAddress(coord[0], bottom, coord[1], right);
         String formula = cra.formatAsString(sheet.getSheetName(), true);
-        createName(name, formula, true);
+        createName(name, formula, true, worksheetScope);
     }
 
+
     public void appendWorksheet(DataFrame data, int worksheetIndex, boolean header) {
         Sheet sheet = getSheet(worksheetIndex);
         int lastRow = getLastRow(worksheetIndex);
@@ -1451,10 +1534,10 @@ public void clearRangeFromReference(String reference) {
         clearRange(sheetName, coords);
     }
 
-    public void clearNamedRegion(String name) {
-        String sheetName = getName(name).getSheetName();
-        int[] coords = getReferenceCoordinates(name);
-        clearRange(sheetName, coords);
+    public void clearNamedRegion(String name, String worksheetScope) {
+        String dataSourceSheetName = getName(name, worksheetScope).getSheetName();
+        int[] coords = getReferenceCoordinatesForName(name, worksheetScope);
+        clearRange(dataSourceSheetName, coords);
     }
 
     public void createFreezePane(int sheetIndex, int colSplit, int rowSplit, int leftColumn, int topRow) {
diff --git a/src/main/java/com/miraisolutions/xlconnect/integration/r/RWorkbookWrapper.java b/src/main/java/com/miraisolutions/xlconnect/integration/r/RWorkbookWrapper.java
index c13ad26..c7c0fbe 100644
--- a/src/main/java/com/miraisolutions/xlconnect/integration/r/RWorkbookWrapper.java
+++ b/src/main/java/com/miraisolutions/xlconnect/integration/r/RWorkbookWrapper.java
@@ -20,10 +20,7 @@
 
 package com.miraisolutions.xlconnect.integration.r;
 
-import com.miraisolutions.xlconnect.CellStyle;
-import com.miraisolutions.xlconnect.ErrorBehavior;
-import com.miraisolutions.xlconnect.StyleAction;
-import com.miraisolutions.xlconnect.Workbook;
+import com.miraisolutions.xlconnect.*;
 import com.miraisolutions.xlconnect.data.DataFrame;
 import com.miraisolutions.xlconnect.data.DataType;
 import com.miraisolutions.xlconnect.data.ReadStrategy;
@@ -59,24 +56,24 @@ public void setSheetPos(String sheetName, int pos) {
         workbook.setSheetPos(sheetName, pos);
     }
 
-    public String[] getDefinedNames(boolean validOnly) {
-        return workbook.getDefinedNames(validOnly);
+    public String[] getDefinedNames(boolean validOnly, String worksheetScope) {
+        return workbook.getDefinedNames(validOnly, worksheetScope);
     }
 
     public void createSheet(String name) {
         workbook.createSheet(name);
     }
 
-    public void createName(String name, String formula, boolean overwrite) {
-        workbook.createName(name, formula, overwrite);
+    public void createName(String name, String formula, boolean overwrite, String worksheetScope) {
+        workbook.createName(name, formula, overwrite, worksheetScope);
     }
 
-    public void removeName(String name) {
-        workbook.removeName(name);
+    public void removeName(String name, String worksheetScope) {
+        workbook.removeName(name, worksheetScope);
     }
 
-    public String getReferenceFormula(String name) {
-        return workbook.getReferenceFormula(name);
+    public String getReferenceFormula(String name, String worksheetScope) {
+        return workbook.getReferenceFormula(name, worksheetScope);
     }
 
     public void removeSheet(String name) {
@@ -103,8 +100,8 @@ public void cloneSheet(String name, String newName) {
         workbook.cloneSheet(name, newName);
     }
 
-    public void writeNamedRegion(RDataFrameWrapper dataFrame, String name, boolean header, boolean overwriteFormulaCells) {
-        workbook.writeNamedRegion(dataFrame.dataFrame, name, header, overwriteFormulaCells);
+    public void writeNamedRegion(RDataFrameWrapper dataFrame, String name, boolean header, boolean overwriteFormulaCells, String worksheetScope) {
+        workbook.writeNamedRegion(dataFrame.dataFrame, name, header, overwriteFormulaCells, worksheetScope);
     }
 
     private static DataType[] dataTypeFromString(String[] colTypes) {
@@ -117,12 +114,12 @@ private static DataType[] dataTypeFromString(String[] colTypes) {
         return ctypes;
     }
 
-    public RDataFrameWrapper readNamedRegion(String name, boolean header, String[] colTypes,
+    public RDataFrameWithAttributes readNamedRegion(String name, boolean header, String[] colTypes,
                                              boolean forceConversion, String dateTimeFormat, boolean takeCached, int[] subset,
-                                             String readStrategy) {
-        DataFrame dataFrame = workbook.readNamedRegion(name, header, ReadStrategy.valueOf(readStrategy.toUpperCase()),
-                dataTypeFromString(colTypes), forceConversion, dateTimeFormat, takeCached, subset);
-        return new RDataFrameWrapper(dataFrame);
+                                             String readStrategy, String worksheetScope) {
+        DataFrameWithAttributes dataFrame = workbook.readNamedRegion(name, header, dataTypeFromString(colTypes), forceConversion,
+                dateTimeFormat, takeCached, subset, ReadStrategy.valueOf(readStrategy.toUpperCase()), worksheetScope);
+        return new RDataFrameWithAttributes(dataFrame.getAttributes(), new RDataFrameWrapper(dataFrame.getValue()));
     }
 
     public RDataFrameWrapper readTable(int worksheetIndex, String tableName, boolean header, String[] colTypes,
@@ -139,8 +136,8 @@ public RDataFrameWrapper readTable(String worksheetName, String tableName, boole
         return new RDataFrameWrapper(dataFrame);
     }
 
-    public boolean existsName(String name) {
-        return workbook.existsName(name);
+    public BooleanWithAttributes existsName(String name, String worksheetScope) {
+        return workbook.existsName(name, worksheetScope);
     }
 
     public boolean existsSheet(String name) {
@@ -229,9 +226,9 @@ public boolean isSheetVeryHidden(String sheetName) {
         return workbook.isSheetVeryHidden(sheetName);
     }
 
-    public void addImage(String filename, String name, boolean originalSize)
+    public void addImage(String filename, String name, boolean originalSize, String worksheetScope)
             throws IOException {
-        workbook.addImage(filename, name, originalSize);
+        workbook.addImage(filename, name, originalSize, worksheetScope);
     }
 
     public RCellStyleWrapper createCellStyle(String name) {
@@ -413,8 +410,8 @@ public int[] getReferenceCoordinates(String name) {
         return workbook.getReferenceCoordinates(name);
     }
 
-    public int[] getReferenceCoordinatesForName(String name) {
-        return workbook.getReferenceCoordinatesForName(name);
+    public int[] getReferenceCoordinatesForName(String name, String worksheetScope) {
+        return workbook.getReferenceCoordinatesForName(name, worksheetScope);
     }
 
     public int[] getReferenceCoordinatesForTable(int sheetIndex, String tableName) {
@@ -466,8 +463,8 @@ public int getLastColumn(String sheetName) {
     }
 
 
-    public void appendNamedRegion(RDataFrameWrapper data, String name, boolean header, boolean overwriteFormulaCells) {
-        workbook.appendNamedRegion(data.dataFrame, name, header, overwriteFormulaCells);
+    public void appendNamedRegion(RDataFrameWrapper data, String name, boolean header, boolean overwriteFormulaCells, String worksheetScope) {
+        workbook.appendNamedRegion(data.dataFrame, name, header, overwriteFormulaCells, worksheetScope);
     }
 
     public void appendWorksheet(RDataFrameWrapper data, int worksheetIndex, boolean header) {
@@ -498,8 +495,8 @@ public void clearRangeFromReference(String reference) {
         workbook.clearRangeFromReference(reference);
     }
 
-    public void clearNamedRegion(String name) {
-        workbook.clearNamedRegion(name);
+    public void clearNamedRegion(String name, String worksheetScope) {
+        workbook.clearNamedRegion(name, worksheetScope);
     }
 
     public void createFreezePane(int sheetIndex, int colSplit, int rowSplit, int leftColumn, int topRow) {
diff --git a/src/test/java/com/miraisolutions/xlconnect/BooleanWithAttributesTest.java b/src/test/java/com/miraisolutions/xlconnect/BooleanWithAttributesTest.java
new file mode 100644
index 0000000..c9d3f35
--- /dev/null
+++ b/src/test/java/com/miraisolutions/xlconnect/BooleanWithAttributesTest.java
@@ -0,0 +1,16 @@
+package com.miraisolutions.xlconnect;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class BooleanWithAttributesTest {
+
+    @Test
+    public void getTrueValue() {
+        BooleanWithAttributes underTest = new BooleanWithAttributes(Attribute.WORKSHEET_SCOPE, "bla", true);
+        assert underTest.getValue();
+        assertEquals(1, underTest.getAttributeNames().length);
+    }
+}
\ No newline at end of file