package org.jtheque.ui.utils.windows.dialogs; /* * Copyright JTheque (Baptiste Wicht) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ import org.jtheque.core.utils.OSGiUtils; import org.jtheque.i18n.Internationalizable; import org.jtheque.i18n.InternationalizableContainer; import org.jtheque.i18n.LanguageService; import org.jtheque.ui.Controller; import org.jtheque.ui.Model; import org.jtheque.ui.UIUtils; import org.jtheque.ui.WindowState; import org.jtheque.ui.WindowView; import org.jtheque.ui.constraints.Constraint; import org.jtheque.ui.utils.actions.ActionFactory; import org.jtheque.ui.utils.windows.ManagedWindow; import org.jtheque.utils.SimplePropertiesCache; import org.jtheque.utils.ui.SwingUtils; import org.osgi.framework.BundleContext; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; import org.springframework.osgi.context.BundleContextAware; import javax.annotation.PostConstruct; import javax.swing.Action; import javax.swing.JComponent; import javax.swing.JDialog; import javax.swing.JFrame; import java.awt.Component; import java.awt.Container; import java.awt.Frame; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; import java.util.Collection; /** * A swing dialog view. * * @author Baptiste Wicht */ public abstract class SwingDialogView<T extends Model> extends JDialog implements ManagedWindow, WindowView, InternationalizableContainer, BundleContextAware, ApplicationContextAware { private T model; private final org.jtheque.ui.utils.windows.WindowState state = new org.jtheque.ui.utils.windows.WindowState(this); private String id; private int defaultWidth = -1; private int defaultHeight = 1; /** * Construct a SwingDialogView modal to the main view. */ protected SwingDialogView() { super(SimplePropertiesCache.<Frame>get("mainView", Frame.class)); } @PostConstruct @Override public final void build() { setModal(true); state.build(); setResizable(true); setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE); //To allow save of the state of the window before closing the view addWindowListener(new WindowAdapter() { @Override public void windowClosing(WindowEvent e) { closeDown(); } }); getService(LanguageService.class).addInternationalizable(this); super.setContentPane(state.getContent()); init(); if (id != null && defaultHeight > 0 && defaultWidth > 0) { getService(UIUtils.class).configureView(this, id, defaultWidth, defaultHeight); } } /** * Init the view. */ protected abstract void init(); /** * Set the content pane of the dialog. * * @param contentPane The content pane to set. */ public void setContentPane(JComponent contentPane) { state.getContent().setView(contentPane); } @Override public Container getContentPane() { return state.getContent().getView(); } @Override public void setContentPane(Container contentPane) { throw new UnsupportedOperationException("Cannot set the content pane"); } @Override public void setGlassPane(Component glassPane) { state.setGlassPane(glassPane); refresh(); } @Override public Component getGlassPane() { return state.getContent().getGlassPane(); } @Override public void closeDown() { if (id != null) { getService(UIUtils.class).saveState(this, id); } setVisible(false); } @Override public void display() { state.display(); } @Override public final void toFirstPlan() { toFront(); } @Override public void sendMessage(String message, Object value) { throw new UnsupportedOperationException(); } @Override public final void refresh() { SwingUtils.refresh(this); } /** * Set the title key. * * @param key The internationalization key. * @param replaces The replacements objects for the i18n methods. */ protected final void setTitleKey(String key, Object... replaces) { state.setTitleKey(key, replaces); } /** * Indicate that the view location and size is managed by the UIUtils service. * * @param id The id of the view, must be unique. * @param defaultWidth The default width. * @param defaultHeight The default height. */ protected void setDefaults(String id, int defaultWidth, int defaultHeight) { this.id = id; this.defaultWidth = defaultWidth; this.defaultHeight = defaultHeight; } @Override public void addInternationalizable(Internationalizable internationalizable) { state.addInternationalizable(internationalizable); } @Override public void refreshText(LanguageService languageService) { state.refreshText(languageService); } /** * Set the model of the view. * * @param model The model of the view. */ public void setModel(T model) { this.model = model; } @Override public T getModel() { return model; } @Override public final JDialog getImpl() { return this; } @Override public final boolean validateContent() { return state.validateContent(); } @Override public void validate(Collection<org.jtheque.errors.Error> errors) { state.validate(errors); //Default validation using constraint } /** * Add the constraint to the view. The filed will be configured by the constraint. * * @param field The field to validate. * @param constraint The constraint to add. */ protected void addConstraint(Object field, Constraint constraint) { state.addConstraint(field, constraint); } @Override public void setBundleContext(BundleContext bundleContext) { state.setBundleContext(bundleContext); } @Override public void setApplicationContext(ApplicationContext applicationContext) { state.setApplicationContext(applicationContext); } /** * Return the internationalized message. * * @param key The internationalization key. * @param replaces The replacement objects to use. * * @return the internationalized message. */ protected String getMessage(String key, Object... replaces) { return getService(LanguageService.class).getMessage(key, replaces); } /** * Return the service of the given class. * * @param classz The class to get the service. * @param <T> The type of service. * * @return The service of the given class if it's exists otherwise null. */ protected <T> T getService(Class<T> classz) { return OSGiUtils.getService(state.getBundleContext(), classz); } /** * Return the bean of the given class using the application context. * * @param classz The classz of the bean to get from application context. * @param <T> The type of bean to get. * * @return The bean of the given class or null if it doesn't exist. */ protected <T> T getBean(Class<T> classz) { return state.getApplicationContext().getBean(classz); } /** * Set the controller of the view. * * @param controller The controller of the view. */ public void setController(Controller<?> controller) { state.setController(controller); } @Override public Action getAction(String key) { return ActionFactory.createAction(key, state.getController()); } @Override public WindowState getWindowState() { return state; } }