ConfigurableSwingWindowDisplayHandler.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 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(HANDLERinstanceof SwingWindowDisplayHandler) {
066                 LOG.trace("Showing {} with handler: handler", name);
067                 ((SwingWindowDisplayHandleroptions.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(HANDLERinstanceof SwingWindowDisplayHandler) {
105                 LOG.trace("Hiding {} with handler: handler", name);
106                 ((SwingWindowDisplayHandleroptions.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             ((RunnableWithArgshandler).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 ((SwingWindowDisplayHandlerhandler);
183                 }
184             catch (InstanceNotFoundException infe2) {
185                 // ignore
186             }
187         }
188 
189         return null;
190     }
191 }