001 /*
002 * Copyright 2008-2016 the original author or authors.
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016 package org.codehaus.griffon.runtime.swing;
017
018 import griffon.core.CallableWithArgs;
019 import griffon.core.GriffonApplication;
020 import griffon.core.RunnableWithArgs;
021 import griffon.core.view.WindowDisplayHandler;
022 import griffon.exceptions.InstanceNotFoundException;
023 import griffon.swing.SwingWindowDisplayHandler;
024 import org.codehaus.griffon.runtime.core.view.ConfigurableWindowDisplayHandler;
025 import org.slf4j.Logger;
026 import org.slf4j.LoggerFactory;
027
028 import javax.annotation.Nonnull;
029 import javax.inject.Inject;
030 import javax.inject.Named;
031 import javax.swing.JInternalFrame;
032 import java.awt.Window;
033 import java.util.Map;
034
035 import static griffon.util.AnnotationUtils.named;
036 import static griffon.util.GriffonNameUtils.requireNonBlank;
037 import static java.util.Objects.requireNonNull;
038
039 /**
040 * @author Andres Almiray
041 * @since 2.0.0
042 */
043 public class ConfigurableSwingWindowDisplayHandler extends ConfigurableWindowDisplayHandler<Window> implements SwingWindowDisplayHandler {
044 private static final Logger LOG = LoggerFactory.getLogger(ConfigurableSwingWindowDisplayHandler.class);
045
046 @Inject
047 public ConfigurableSwingWindowDisplayHandler(@Nonnull GriffonApplication application, @Nonnull @Named("defaultWindowDisplayHandler") SwingWindowDisplayHandler delegateWindowsDisplayHandler) {
048 super(application, delegateWindowsDisplayHandler);
049 }
050
051 public void show(@Nonnull String name, @Nonnull JInternalFrame window) {
052 requireNonBlank(name, ERROR_NAME_BLANK);
053 requireNonNull(window, ERROR_WINDOW_NULL);
054
055 Map<String, Object> options = windowBlock(name);
056 if (!options.isEmpty()) {
057 Object handler = options.get("show");
058 if (canBeRun(handler)) {
059 LOG.trace("Showing {} with show: handler", name);
060 run(handler, name, window);
061 return;
062 } else if (options.get("handler") instanceof SwingWindowDisplayHandler) {
063 LOG.trace("Showing {} with handler: handler", name);
064 ((SwingWindowDisplayHandler) options.get("handler")).show(name, window);
065 return;
066 }
067 }
068
069 SwingWindowDisplayHandler handler = resolveSwingWindowDisplayHandler(name);
070 if (handler != null) {
071 LOG.trace("Showing {} with injected handler", name);
072 handler.show(name, window);
073 return;
074 }
075
076 options = windowManagerBlock();
077 if (!options.isEmpty()) {
078 Object defaultShow = options.get("defaultShow");
079 if (canBeRun(defaultShow)) {
080 LOG.trace("Showing {} with defaultShow: handler", name);
081 run(defaultShow, name, window);
082 return;
083 }
084 }
085
086 LOG.trace("Showing {} with default handler", name);
087 fetchDefaultWindowDisplayHandler().show(name, window);
088 }
089
090 public void hide(@Nonnull String name, @Nonnull JInternalFrame window) {
091 requireNonBlank(name, ERROR_NAME_BLANK);
092 requireNonNull(window, ERROR_WINDOW_NULL);
093
094 Map<String, Object> options = windowBlock(name);
095 if (!options.isEmpty()) {
096 Object handler = options.get("hide");
097 if (canBeRun(handler)) {
098 LOG.trace("Hiding {} with hide: handler", name);
099 run(handler, name, window);
100 return;
101 } else if (options.get("handler") instanceof SwingWindowDisplayHandler) {
102 LOG.trace("Hiding {} with handler: handler", name);
103 ((SwingWindowDisplayHandler) options.get("handler")).hide(name, window);
104 return;
105 }
106 }
107
108 SwingWindowDisplayHandler handler = resolveSwingWindowDisplayHandler(name);
109 if (handler != null) {
110 LOG.trace("Hiding {} with injected handler", name);
111 handler.hide(name, window);
112 return;
113 }
114
115 options = windowManagerBlock();
116 if (!options.isEmpty()) {
117 Object defaultHide = options.get("defaultHide");
118 if (canBeRun(defaultHide)) {
119 LOG.trace("Hiding {} with defaultHide: handler", name);
120 run(defaultHide, name, window);
121 return;
122 }
123 }
124
125 LOG.trace("Hiding {} with default handler", name);
126 fetchDefaultWindowDisplayHandler().hide(name, window);
127 }
128
129 protected void run(@Nonnull Object handler, @Nonnull String name, @Nonnull JInternalFrame window) {
130 if (handler instanceof RunnableWithArgs) {
131 ((RunnableWithArgs) handler).run(name, window);
132 } else if (handler instanceof CallableWithArgs) {
133 ((CallableWithArgs<?>) handler).call(name, window);
134 }
135 }
136
137 @Nonnull
138 protected SwingWindowDisplayHandler fetchDefaultWindowDisplayHandler() {
139 Object handler = windowManagerBlock().get("defaultHandler");
140 return (SwingWindowDisplayHandler) (handler instanceof SwingWindowDisplayHandler ? handler : getDelegateWindowsDisplayHandler());
141 }
142
143 @Override
144 protected boolean handleShowByInjectedHandler(@Nonnull String name, @Nonnull Window window) {
145 try {
146 SwingWindowDisplayHandler handler = getApplication().getInjector()
147 .getInstance(SwingWindowDisplayHandler.class, named(name));
148 LOG.trace("Showing {} with injected handler", name);
149 handler.show(name, window);
150 return true;
151 } catch (InstanceNotFoundException infe) {
152 return super.handleShowByInjectedHandler(name, window);
153 }
154 }
155
156 @Override
157 protected boolean handleHideByInjectedHandler(@Nonnull String name, @Nonnull Window window) {
158 try {
159 SwingWindowDisplayHandler handler = getApplication().getInjector()
160 .getInstance(SwingWindowDisplayHandler.class, named(name));
161 LOG.trace("Hiding {} with injected handler", name);
162 handler.hide(name, window);
163 return true;
164 } catch (InstanceNotFoundException infe) {
165 return super.handleHideByInjectedHandler(name, window);
166 }
167 }
168
169 protected SwingWindowDisplayHandler resolveSwingWindowDisplayHandler(@Nonnull String name) {
170 try {
171 return getApplication().getInjector()
172 .getInstance(SwingWindowDisplayHandler.class, named(name));
173 } catch (InstanceNotFoundException infe1) {
174 try {
175 WindowDisplayHandler handler = getApplication().getInjector()
176 .getInstance(WindowDisplayHandler.class, named(name));
177 if (handler instanceof SwingWindowDisplayHandler) {
178 return ((SwingWindowDisplayHandler) handler);
179 }
180 } catch (InstanceNotFoundException infe2) {
181 // ignore
182 }
183 }
184
185 return null;
186 }
187 }
|