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 org.codehaus.griffon.runtime.swing;
019
020 import griffon.core.CallableWithArgs;
021 import griffon.core.GriffonApplication;
022 import griffon.core.RunnableWithArgs;
023 import griffon.core.view.WindowDisplayHandler;
024 import griffon.exceptions.InstanceNotFoundException;
025 import griffon.swing.SwingWindowDisplayHandler;
026 import org.codehaus.griffon.runtime.core.view.ConfigurableWindowDisplayHandler;
027 import org.slf4j.Logger;
028 import org.slf4j.LoggerFactory;
029
030 import javax.annotation.Nonnull;
031 import javax.inject.Inject;
032 import javax.inject.Named;
033 import javax.swing.JInternalFrame;
034 import java.awt.Window;
035 import java.util.Map;
036
037 import static griffon.util.AnnotationUtils.named;
038 import static griffon.util.GriffonNameUtils.requireNonBlank;
039 import static java.util.Objects.requireNonNull;
040
041 /**
042 * @author Andres Almiray
043 * @since 2.0.0
044 */
045 public class ConfigurableSwingWindowDisplayHandler extends ConfigurableWindowDisplayHandler<Window> implements SwingWindowDisplayHandler {
046 private static final Logger LOG = LoggerFactory.getLogger(ConfigurableSwingWindowDisplayHandler.class);
047 private static final String HANDLER = "handler";
048
049 @Inject
050 public ConfigurableSwingWindowDisplayHandler(@Nonnull GriffonApplication application, @Nonnull @Named("defaultWindowDisplayHandler") SwingWindowDisplayHandler delegateWindowsDisplayHandler) {
051 super(application, delegateWindowsDisplayHandler);
052 }
053
054 public void show(@Nonnull String name, @Nonnull JInternalFrame window) {
055 requireNonBlank(name, ERROR_NAME_BLANK);
056 requireNonNull(window, ERROR_WINDOW_NULL);
057
058 Map<String, Object> options = windowBlock(name);
059 if (!options.isEmpty()) {
060 Object handler = options.get("show");
061 if (canBeRun(handler)) {
062 LOG.trace("Showing {} with show: handler", name);
063 run(handler, name, window);
064 return;
065 } else if (options.get(HANDLER) instanceof SwingWindowDisplayHandler) {
066 LOG.trace("Showing {} with handler: handler", name);
067 ((SwingWindowDisplayHandler) options.get(HANDLER)).show(name, window);
068 return;
069 }
070 }
071
072 SwingWindowDisplayHandler handler = resolveSwingWindowDisplayHandler(name);
073 if (handler != null) {
074 LOG.trace("Showing {} with injected handler", name);
075 handler.show(name, window);
076 return;
077 }
078
079 options = windowManagerBlock();
080 if (!options.isEmpty()) {
081 Object defaultShow = options.get("defaultShow");
082 if (canBeRun(defaultShow)) {
083 LOG.trace("Showing {} with defaultShow: handler", name);
084 run(defaultShow, name, window);
085 return;
086 }
087 }
088
089 LOG.trace("Showing {} with default handler", name);
090 fetchDefaultWindowDisplayHandler().show(name, window);
091 }
092
093 public void hide(@Nonnull String name, @Nonnull JInternalFrame window) {
094 requireNonBlank(name, ERROR_NAME_BLANK);
095 requireNonNull(window, ERROR_WINDOW_NULL);
096
097 Map<String, Object> options = windowBlock(name);
098 if (!options.isEmpty()) {
099 Object handler = options.get("hide");
100 if (canBeRun(handler)) {
101 LOG.trace("Hiding {} with hide: handler", name);
102 run(handler, name, window);
103 return;
104 } else if (options.get(HANDLER) instanceof SwingWindowDisplayHandler) {
105 LOG.trace("Hiding {} with handler: handler", name);
106 ((SwingWindowDisplayHandler) options.get(HANDLER)).hide(name, window);
107 return;
108 }
109 }
110
111 SwingWindowDisplayHandler handler = resolveSwingWindowDisplayHandler(name);
112 if (handler != null) {
113 LOG.trace("Hiding {} with injected handler", name);
114 handler.hide(name, window);
115 return;
116 }
117
118 options = windowManagerBlock();
119 if (!options.isEmpty()) {
120 Object defaultHide = options.get("defaultHide");
121 if (canBeRun(defaultHide)) {
122 LOG.trace("Hiding {} with defaultHide: handler", name);
123 run(defaultHide, name, window);
124 return;
125 }
126 }
127
128 LOG.trace("Hiding {} with default handler", name);
129 fetchDefaultWindowDisplayHandler().hide(name, window);
130 }
131
132 protected void run(@Nonnull Object handler, @Nonnull String name, @Nonnull JInternalFrame window) {
133 if (handler instanceof RunnableWithArgs) {
134 ((RunnableWithArgs) handler).run(name, window);
135 } else if (handler instanceof CallableWithArgs) {
136 ((CallableWithArgs<?>) handler).call(name, window);
137 }
138 }
139
140 @Nonnull
141 @Override
142 protected SwingWindowDisplayHandler fetchDefaultWindowDisplayHandler() {
143 Object handler = windowManagerBlock().get("defaultHandler");
144 return (SwingWindowDisplayHandler) (handler instanceof SwingWindowDisplayHandler ? handler : getDelegateWindowsDisplayHandler());
145 }
146
147 @Override
148 protected boolean handleShowByInjectedHandler(@Nonnull String name, @Nonnull Window window) {
149 try {
150 SwingWindowDisplayHandler handler = getApplication().getInjector()
151 .getInstance(SwingWindowDisplayHandler.class, named(name));
152 LOG.trace("Showing {} with injected handler", name);
153 handler.show(name, window);
154 return true;
155 } catch (InstanceNotFoundException infe) {
156 return super.handleShowByInjectedHandler(name, window);
157 }
158 }
159
160 @Override
161 protected boolean handleHideByInjectedHandler(@Nonnull String name, @Nonnull Window window) {
162 try {
163 SwingWindowDisplayHandler handler = getApplication().getInjector()
164 .getInstance(SwingWindowDisplayHandler.class, named(name));
165 LOG.trace("Hiding {} with injected handler", name);
166 handler.hide(name, window);
167 return true;
168 } catch (InstanceNotFoundException infe) {
169 return super.handleHideByInjectedHandler(name, window);
170 }
171 }
172
173 protected SwingWindowDisplayHandler resolveSwingWindowDisplayHandler(@Nonnull String name) {
174 try {
175 return getApplication().getInjector()
176 .getInstance(SwingWindowDisplayHandler.class, named(name));
177 } catch (InstanceNotFoundException infe1) {
178 try {
179 WindowDisplayHandler handler = getApplication().getInjector()
180 .getInstance(WindowDisplayHandler.class, named(name));
181 if (handler instanceof SwingWindowDisplayHandler) {
182 return ((SwingWindowDisplayHandler) handler);
183 }
184 } catch (InstanceNotFoundException infe2) {
185 // ignore
186 }
187 }
188
189 return null;
190 }
191 }
|