Dimension2DPropertyEditor.java
001 /*
002  * SPDX-License-Identifier: Apache-2.0
003  *
004  * Copyright 2008-2017 the original author or authors.
005  *
006  * Licensed under the Apache License, Version 2.0 (the "License");
007  * you may not use this file except in compliance with the License.
008  * You may obtain a copy of the License at
009  *
010  *     http://www.apache.org/licenses/LICENSE-2.0
011  *
012  * Unless required by applicable law or agreed to in writing, software
013  * distributed under the License is distributed on an "AS IS" BASIS,
014  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015  * See the License for the specific language governing permissions and
016  * limitations under the License.
017  */
018 package griffon.javafx.editors;
019 
020 import griffon.core.editors.AbstractPropertyEditor;
021 import griffon.metadata.PropertyEditorFor;
022 import javafx.geometry.Dimension2D;
023 
024 import java.util.List;
025 import java.util.Map;
026 
027 import static griffon.util.GriffonNameUtils.isBlank;
028 
029 /**
030  @author Andres Almiray
031  */
032 @PropertyEditorFor(Dimension2D.class)
033 public class Dimension2DPropertyEditor extends AbstractPropertyEditor {
034     @Override
035     public String getAsText() {
036         if (null == getValue()) return null;
037         Dimension2D dimension = (Dimension2DgetValue();
038         return dimension.getWidth() ", " + dimension.getHeight();
039     }
040 
041     @Override
042     protected void setValueInternal(Object value) {
043         if (null == value) {
044             super.setValueInternal(null);
045         else if (value instanceof CharSequence) {
046             handleAsString(String.valueOf(value));
047         else if (value instanceof List) {
048             handleAsList((Listvalue);
049         else if (value instanceof Map) {
050             handleAsMap((Mapvalue);
051         else if (value instanceof Number) {
052             handleAsNumber((Numbervalue);
053         else if (value instanceof Dimension2D) {
054             super.setValueInternal(value);
055         else {
056             throw illegalValue(value, Dimension2D.class);
057         }
058     }
059 
060     protected void handleAsString(String str) {
061         if (isBlank(str)) {
062             super.setValueInternal(null);
063             return;
064         }
065 
066         String[] parts = str.split(",");
067         switch (parts.length) {
068             case 1:
069                 double s = parseValue(parts[0]);
070                 super.setValueInternal(new Dimension2D(s, s));
071                 break;
072             case 2:
073                 double w = parseValue(parts[0]);
074                 double h = parseValue(parts[1]);
075                 super.setValueInternal(new Dimension2D(w, h));
076                 break;
077             default:
078                 throw illegalValue(str, Dimension2D.class);
079         }
080     }
081 
082     protected void handleAsList(List<?> list) {
083         if (list.isEmpty()) {
084             super.setValueInternal(null);
085             return;
086         }
087 
088         switch (list.size()) {
089             case 1:
090                 double s = parseValue(list.get(0));
091                 super.setValueInternal(new Dimension2D(s, s));
092                 break;
093             case 2:
094                 double w = parseValue(list.get(0));
095                 double h = parseValue(list.get(1));
096                 super.setValueInternal(new Dimension2D(w, h));
097                 break;
098             default:
099                 throw illegalValue(list, Dimension2D.class);
100         }
101     }
102 
103     protected void handleAsMap(Map<?, ?> map) {
104         if (map.isEmpty()) {
105             super.setValueInternal(null);
106             return;
107         }
108 
109         double w = getMapValue(map, "width"0);
110         double h = getMapValue(map, "height"0);
111         super.setValueInternal(new Dimension2D(w, h));
112     }
113 
114     protected double parseValue(Object value) {
115         if (value instanceof CharSequence) {
116             return parse(String.valueOf(value));
117         else if (value instanceof Number) {
118             return parse((Numbervalue);
119         }
120         throw illegalValue(value, Dimension2D.class);
121     }
122 
123     protected double parse(String val) {
124         try {
125             return Double.parseDouble(val.trim());
126         catch (NumberFormatException e) {
127             throw illegalValue(val, Dimension2D.class, e);
128         }
129     }
130 
131     protected double parse(Number val) {
132         return val.doubleValue();
133     }
134 
135     protected double getMapValue(Map<?, ?> map, String key, double defaultValue) {
136         Object val = map.get(key);
137         if (null == valval = map.get(String.valueOf(key.charAt(0)));
138         if (null == val) {
139             return defaultValue;
140         else if (val instanceof CharSequence) {
141             return parse(String.valueOf(val));
142         else if (val instanceof Number) {
143             return parse((Numberval);
144         }
145         throw illegalValue(map, Dimension2D.class);
146     }
147 
148     protected void handleAsNumber(Number value) {
149         double s = parse(value);
150         super.setValueInternal(new Dimension2D(s, s));
151     }
152 }