001 /*
002 * Copyright 2008-2017 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 private static final String HANDLER = "handler";
046
047 @Inject
048 public ConfigurableSwingWindowDisplayHandler(@Nonnull GriffonApplication application, @Nonnull @Named("defaultWindowDisplayHandler") SwingWindowDisplayHandler delegateWindowsDisplayHandler) {
049 super(application, delegateWindowsDisplayHandler);
050 }
051
052 public void show(@Nonnull String name, @Nonnull JInternalFrame window) {
053 requireNonBlank(name, ERROR_NAME_BLANK);
054 requireNonNull(window, ERROR_WINDOW_NULL);
055
056 Map<String, Object> options = windowBlock(name);
057 if (!options.isEmpty()) {
058 Object handler = options.get("show");
059 if (canBeRun(handler)) {
060 LOG.trace("Showing {} with show: handler", name);
061 run(handler, name, window);
062 return;
063 } else if (options.get(HANDLER) instanceof SwingWindowDisplayHandler) {
064 LOG.trace("Showing {} with handler: handler", name);
065 ((SwingWindowDisplayHandler) options.get(HANDLER)).show(name, window);
066 return;
067 }
068 }
069
070 SwingWindowDisplayHandler handler = resolveSwingWindowDisplayHandler(name);
071 if (handler != null) {
072 LOG.trace("Showing {} with injected handler", name);
073 handler.show(name, window);
074 return;
075 }
076
077 options = windowManagerBlock();
078 if (!options.isEmpty()) {
079 Object defaultShow = options.get("defaultShow");
080 if (canBeRun(defaultShow)) {
081 LOG.trace("Showing {} with defaultShow: handler", name);
082 run(defaultShow, name, window);
083 return;
084 }
085 }
086
087 LOG.trace("Showing {} with default handler", name);
088 fetchDefaultWindowDisplayHandler().show(name, window);
089 }
090
091 public void hide(@Nonnull String name, @Nonnull JInternalFrame window) {
092 requireNonBlank(name, ERROR_NAME_BLANK);
093 requireNonNull(window, ERROR_WINDOW_NULL);
094
095 Map<String, Object> options = windowBlock(name);
096 if (!options.isEmpty()) {
097 Object handler = options.get("hide");
098 if (canBeRun(handler)) {
099 LOG.trace("Hiding {} with hide: handler", name);
100 run(handler, name, window);
101 return;
102 } else if (options.get(HANDLER) instanceof SwingWindowDisplayHandler) {
103 LOG.trace("Hiding {} with handler: handler", name);
104 ((SwingWindowDisplayHandler) options.get(HANDLER)).hide(name, window);
105 return;
106 }
107 }
108
109 SwingWindowDisplayHandler handler = resolveSwingWindowDisplayHandler(name);
110 if (handler != null) {
111 LOG.trace("Hiding {} with injected handler", name);
112 handler.hide(name, window);
113 return;
114 }
115
116 options = windowManagerBlock();
117 if (!options.isEmpty()) {
118 Object defaultHide = options.get("defaultHide");
119 if (canBeRun(defaultHide)) {
120 LOG.trace("Hiding {} with defaultHide: handler", name);
121 run(defaultHide, name, window);
122 return;
123 }
124 }
125
126 LOG.trace("Hiding {} with default handler", name);
127 fetchDefaultWindowDisplayHandler().hide(name, window);
128 }
129
130 protected void run(@Nonnull Object handler, @Nonnull String name, @Nonnull JInternalFrame window) {
131 if (handler instanceof RunnableWithArgs) {
132 ((RunnableWithArgs) handler).run(name, window);
133 } else if (handler instanceof CallableWithArgs) {
134 ((CallableWithArgs<?>) handler).call(name, window);
135 }
136 }
137
138 @Nonnull
139 @Override
140 protected SwingWindowDisplayHandler fetchDefaultWindowDisplayHandler() {
141 Object handler = windowManagerBlock().get("defaultHandler");
142 return (SwingWindowDisplayHandler) (handler instanceof SwingWindowDisplayHandler ? handler : getDelegateWindowsDisplayHandler());
143 }
144
145 @Override
146 protected boolean handleShowByInjectedHandler(@Nonnull String name, @Nonnull Window window) {
147 try {
148 SwingWindowDisplayHandler handler = getApplication().getInjector()
149 .getInstance(SwingWindowDisplayHandler.class, named(name));
150 LOG.trace("Showing {} with injected handler", name);
151 handler.show(name, window);
152 return true;
153 } catch (InstanceNotFoundException infe) {
154 return super.handleShowByInjectedHandler(name, window);
155 }
156 }
157
158 @Override
159 protected boolean handleHideByInjectedHandler(@Nonnull String name, @Nonnull Window window) {
160 try {
161 SwingWindowDisplayHandler handler = getApplication().getInjector()
162 .getInstance(SwingWindowDisplayHandler.class, named(name));
163 LOG.trace("Hiding {} with injected handler", name);
164 handler.hide(name, window);
165 return true;
166 } catch (InstanceNotFoundException infe) {
167 return super.handleHideByInjectedHandler(name, window);
168 }
169 }
170
171 protected SwingWindowDisplayHandler resolveSwingWindowDisplayHandler(@Nonnull String name) {
172 try {
173 return getApplication().getInjector()
174 .getInstance(SwingWindowDisplayHandler.class, named(name));
175 } catch (InstanceNotFoundException infe1) {
176 try {
177 WindowDisplayHandler handler = getApplication().getInjector()
178 .getInstance(WindowDisplayHandler.class, named(name));
179 if (handler instanceof SwingWindowDisplayHandler) {
180 return ((SwingWindowDisplayHandler) handler);
181 }
182 } catch (InstanceNotFoundException infe2) {
183 // ignore
184 }
185 }
186
187 return null;
188 }
189 }
|