Revision 4598

View differences:

org.gvsig.raster/trunk/org.gvsig.raster/org.gvsig.raster.lib/org.gvsig.raster.lib.impl/src/main/java/org/gvsig/raster/impl/store/AbstractNewRasterStoreParameters.java
24 24

  
25 25
import java.awt.geom.AffineTransform;
26 26
import java.io.File;
27
import java.net.URI;
27 28

  
28 29
import org.cresques.cts.IProjection;
30

  
29 31
import org.gvsig.fmap.dal.coverage.dataset.Buffer;
30 32
import org.gvsig.fmap.dal.coverage.datastruct.Params;
31 33
import org.gvsig.fmap.dal.coverage.store.DataServerWriter;
......
48 50
	protected DelegatedDynObject       delegatedDynObject          = null;
49 51
	private static DynClass            DYNCLASS                    = null;
50 52
	private Buffer                     buffer                      = null;
51
	
53

  
52 54
	public AbstractNewRasterStoreParameters() {
53 55
		super();
54 56
		initialize();
55 57
	}
56
	
58

  
57 59
	public static void registerDynClass() {
58 60
	   	DynObjectManager dynman = ToolsLocator.getDynObjectManager();
59 61
    	DynClass dynClass = dynman.get(DYNCLASS_NAME);
60 62
    	DynField field;
61 63
    	if (dynClass == null) {
62 64
    		dynClass = dynman.add(DYNCLASS_NAME);
63
    		
65

  
64 66
    		field = dynClass.addDynFieldObject(FIELD_DATA_SERVER);
65 67
    		field.setDescription("Data server");
66 68
    		field.setClassOfValue(Object.class);
......
80 82
    		field.setDescription("band");
81 83
    		field.setClassOfValue(Integer.class);
82 84
    		field.setMandatory(false);
83
    		
85

  
84 86
    		field = dynClass.addDynFieldString(FIELD_WKT);
85 87
            field.setDescription("");
86 88
            field.setMandatory(false);
87 89
            field.setClassOfValue(String.class);
88
            
90

  
89 91
            field = dynClass.addDynFieldArray(FIELD_COLORINTERPRETATION);
90 92
            field.setDescription("Color interpretation by band");
91 93
            field.setMandatory(false);
92 94
            field.setClassOfValue(String.class);
93
            
95

  
94 96
            field = dynClass.addDynFieldString(FIELD_AFFINETRANSFORM);
95 97
    		field.setDescription("Affine transform");
96 98
    		field.setClassOfValue(String.class);
97 99
    		field.setMandatory(false);
98
    		
99
    		field = dynClass.addDynFieldString(FIELD_URI);
100

  
101
    		field = dynClass.addDynFieldObject(FIELD_URI);
100 102
    		field.setDescription("Uniform Resource Identifier (File name or URL)");
101
    		field.setClassOfValue(String.class);
103
    		field.setClassOfValue(URI.class);
102 104
    		field.setMandatory(false);
103
    		
105

  
104 106
            DYNCLASS = dynClass;
105 107
    	}
106
		
108

  
107 109
	}
108
	
110

  
109 111
	protected void initialize() {
110 112
		this.delegatedDynObject = (DelegatedDynObject) ToolsLocator
111 113
				.getDynObjectManager().createDynObject(
112 114
						DYNCLASS);
113 115
	}
114
	
116

  
115 117
	protected DelegatedDynObject getDelegatedDynObject() {
116 118
		return this.delegatedDynObject;
117 119
	}
118
	
120

  
119 121
	public Buffer getBuffer() {
120 122
		return buffer;
121 123
	}
......
131 133
			return s.substring(n + 1, s.length());
132 134
		return s;
133 135
	}
134
	
136

  
135 137
	public String getPath() {
136 138
		String s = getFile().toString();
137 139
		int n = s.lastIndexOf(File.separator);
......
139 141
			return s.substring(0, n);
140 142
		return s;
141 143
	}
142
	
144

  
143 145
	public IProjection getProjection() {
144 146
		return (IProjection) getDynValue(FIELD_SRS);
145 147
	}
146
	
148

  
147 149
	public Params getDriverParams() {
148 150
		return (Params)getDynValue(FIELD_PARAMS);
149 151
	}
150
	
152

  
151 153
	public void setDriverParams(Params params) {
152 154
		this.setDynValue(FIELD_PARAMS, params);
153 155
	}
154
	
156

  
155 157
	public void setBuffer(Buffer buffer) {
156 158
		this.buffer = buffer;
157 159
	}
158
	
160

  
159 161
	public int getBand() {
160 162
		if(getDynValue(FIELD_BAND) == null)
161 163
			return -1;
162 164
		return (Integer)getDynValue(FIELD_BAND);
163 165
	}
164
	
166

  
165 167
	public void setBand(int n) {
166 168
		this.setDynValue(FIELD_BAND, n);
167 169
	}
168
	
170

  
169 171
	public void setAffineTransform(AffineTransform at) {
170 172
		StringBuilder str = new StringBuilder();
171 173
		str.append(at.getScaleX());
......
181 183
		str.append(at.getTranslateY());
182 184
		this.setDynValue(FIELD_AFFINETRANSFORM, str);
183 185
	}
184
	
186

  
185 187
	public AffineTransform getAffineTransform() {
186 188
		if(getDynValue(FIELD_AFFINETRANSFORM) != null) {
187 189
			String str = (String)getDynValue(FIELD_AFFINETRANSFORM);
188 190
			String[] values = str.split(",");
189 191
			return new AffineTransform(
190
					new Double(values[0]), 
191
					new Double(values[1]), 
192
					new Double(values[2]), 
193
					new Double(values[3]), 
194
					new Double(values[4]), 
192
					new Double(values[0]),
193
					new Double(values[1]),
194
					new Double(values[2]),
195
					new Double(values[3]),
196
					new Double(values[4]),
195 197
					new Double(values[5]));
196 198
		}
197 199
		return null;
198 200
	}
199
	
201

  
200 202
	public void setWktProjection(String wkt) {
201 203
		this.setDynValue(FIELD_WKT, wkt);
202 204
	}
203
	
205

  
204 206
	public String getWktProjection() {
205 207
		return (String)getDynValue(FIELD_WKT);
206 208
	}
......
212 214
	public void setDestination(String path, String fileName) {
213 215
		this.setFile(new File(path, fileName));
214 216
	}
215
	
217

  
216 218
	public void setDestination(String fileName) {
217 219
		this.setFile(new File(fileName));
218 220
	}
......
220 222
	public void setProjection(IProjection projection) {
221 223
		this.setDynValue(FIELD_SRS, projection);
222 224
	}
223
	
225

  
224 226
	public boolean isValid() {
225 227
		if(getFileName() == null)
226 228
			return false;
227 229
		return true;
228 230
	}
229
	
231

  
230 232
	public DataServerWriter getDataServer() {
231 233
		return (DataServerWriter)getDynValue(FIELD_DATA_SERVER);
232 234
	}

Also available in: Unified diff