001 package nl.cwi.sen1.visplugin; 002 003 import java.util.ArrayList; 004 005 import nl.cwi.sen1.gui.Studio; 006 import nl.cwi.sen1.gui.plugin.DefaultStudioPlugin; 007 import nl.cwi.sen1.relationstores.Factory; 008 import nl.cwi.sen1.relationstores.types.Location; 009 import aterm.ATerm; 010 import aterm.pure.PureFactory; 011 012 /** 013 * The VisualizationPluginController class represents the base class for the 014 * different plugin controllers. 015 * 016 * @author Aldert Boerhoop 017 * @date 20-2-2007 018 */ 019 public abstract class VisualizationPluginController extends DefaultStudioPlugin 020 implements VisualizationPluginTif { 021 022 public enum requestType { 023 image, csv, rStore 024 }; 025 026 private static final String TOOL_NAME = "visualizationPlugin"; 027 028 private PureFactory m_pureFactory; 029 private Studio m_studio; 030 private String m_pluginName; 031 private ATerm[] m_supportedTypes; 032 private ArrayList<WindowProperties> m_openWindows; 033 private VisualizationPluginBridge m_bridge; 034 035 protected Factory m_factory; 036 037 /** 038 * Returns the bridge of the visualization plugin controller. 039 * 040 * @return The bridge object. 041 * 042 * @author Arend van Beelen 043 * @date 13-3-2007 044 */ 045 public VisualizationPluginBridge getBridge() { 046 return m_bridge; 047 } 048 049 /** 050 * Initialize the plugin 051 * 052 * @author Aldert Boerhoop 053 * @date 20-2-2007 054 * @param Studio studioArgument 055 */ 056 public void initStudioPlugin(Studio studioArgument) { 057 m_studio = studioArgument; 058 m_bridge = new VisualizationPluginBridge(m_studio.getATermFactory(), this); 059 060 initPluginController((aterm.pure.PureFactory) m_studio.getATermFactory()); 061 062 m_studio.connect(TOOL_NAME, m_bridge); 063 } 064 065 /** 066 * Initialize the plugin controller 067 * 068 * @author Aldert Boerhoop 069 * @date 21-2-2007 070 * @param PureFactory pureFactory that should be used by the controller 071 */ 072 public final void initPluginController(PureFactory pureFactory) { 073 m_pureFactory = pureFactory; 074 m_factory = Factory.getInstance(m_pureFactory); 075 076 VisualizationFactorySingleton.initInstances(m_pureFactory, m_factory); 077 078 m_openWindows = new ArrayList<WindowProperties>(); 079 m_pluginName = getPluginName(); 080 m_supportedTypes = getSupportedTypes(); 081 } 082 083 /** 084 * Visualize the fact (Incomming call from the toolbus) 085 * 086 * @author Aldert Boerhoop 087 * @date 20-2-2007 088 * @param Rstore id, Fact id and the fact to visualize 089 */ 090 public final void vpVisualizeFact(int storeId, int factId, ATerm fact) { 091 092 WindowProperties newWindowProperties = new WindowProperties(); 093 VisualizationPluginWindow newWindow = createWindow(); 094 095 newWindow.initializeWindow(m_studio, storeId, factId, m_factory.RTupleFromTerm(fact), m_factory, m_pluginName, this, m_openWindows.size()); 096 097 newWindow.displayVisualization(); 098 099 newWindowProperties.window = newWindow; 100 m_openWindows.add(newWindowProperties); 101 102 newWindow.executeOnLoad(); 103 104 } 105 106 /** 107 * Had to be implemented (studioplugin.getName) 108 * 109 * @author Aldert Boerhoop 110 * @date 20-2-2007 111 * @return The plugin name 112 */ 113 public final String getName() { 114 return getPluginName(); 115 } 116 117 /** 118 * Sends an out of date ack. to the asigned plugin window 119 * 120 * @author Aldert Boerhoop 121 * @date 20-2-2007 122 * @param Store id and the Fact id 123 */ 124 public final void vpFactOutOfDate(int storeId, int factId) { 125 if (m_openWindows != null) { 126 for (int i = 0; i < m_openWindows.size(); i++) { 127 128 WindowProperties windowProperties = m_openWindows.get(i); 129 VisualizationPluginWindow window = windowProperties.window; 130 131 if (window.getFactId() == factId && window.getStoreId() == storeId) { 132 window.factOutOfDate(); 133 } 134 } 135 } 136 } 137 138 /** 139 * The VPI will call this method when an rstore has been unloaded. 140 * The VisualizationController will check which VisualizationPluginWindows 141 * correspond with the specified rstoreId and these windows will be notified. 142 * 143 * @author Bas Basten 144 * @author Anton Lycklama a Nijeholt 145 * @date 14-03-2007 146 * 147 * @param rstoreId The rstoreId of the unloaded rstore. 148 */ 149 public final void vpRstoreUnloaded(int rstoreId) { 150 if (m_openWindows != null) { 151 for (int i = 0; i < m_openWindows.size(); i++) { 152 153 WindowProperties windowProperties = m_openWindows.get(i); 154 VisualizationPluginWindow window = windowProperties.window; 155 156 if (window.getStoreId() == rstoreId) { 157 window.rstoreUnloaded(); 158 } 159 } 160 } 161 } 162 163 /** 164 * Get the name of the plugin (Incomming call from the toolbus) 165 * 166 * @author Aldert Boerhoop 167 * @date 20-2-2007 return The plugin name as an ATerm 168 */ 169 public final ATerm vpGetName() { 170 return m_pureFactory.make("snd-value(vp-name(<str>))", m_pluginName); 171 } 172 173 /** 174 * Checks if the type is supported (Incomming call from the toolbus) 175 * 176 * @author Aldert Boerhoop 177 * @date 20-2-2007 return true if the type is supported else false 178 */ 179 public final ATerm vpIsTypeSupported(ATerm type) { 180 boolean typeSupported = isTypeSupported(type); 181 return m_pureFactory.make("snd-value(vp-type-supported(<bool>))", typeSupported); 182 } 183 184 /** 185 * Checks if a type is supported. Is overridable by children to support 186 * alternative ways to check for a type. For instance checking for n-size 187 * relations. 188 * 189 * @author Aldert Boerhoop 190 * @author Anton Lycklama 191 * @author Bas Basten 192 * @date 09-03-2007 193 */ 194 protected boolean isTypeSupported(ATerm type) { 195 if (m_supportedTypes != null) { 196 for (int i = 0; i < m_supportedTypes.length; i++) { 197 if (m_supportedTypes[i].toString().equals(type.toString())) { 198 return true; 199 } 200 } 201 } 202 return false; 203 } 204 205 /** 206 * Close the plugin 207 * 208 * @author Aldert Boerhoop 209 * @date 20-2-2007 210 * @param ATerm event 211 */ 212 public void recTerminate(ATerm event) { 213 fireStudioPluginClosed(); 214 } 215 216 public void recAckEvent(ATerm t0) { 217 } 218 219 /** 220 * Create a new instance of the plugin window 221 * 222 * @author Aldert Boerhoop 223 * @date 20-2-2007 224 * @return The instance of the plugin window 225 */ 226 public abstract VisualizationPluginWindow createWindow(); 227 228 /** 229 * Get the name of the plugin 230 * 231 * @author Aldert Boerhoop 232 * @date 20-2-2007 233 * @return The plugin name 234 */ 235 public abstract String getPluginName(); 236 237 /** 238 * Get the supported types of the plugin 239 * 240 * @author Aldert Boerhoop 241 * @date 20-2-2007 242 * @return The supported types 243 */ 244 public abstract ATerm[] getSupportedTypes(); 245 246 /** 247 * Opens a file dialog with the correct properties 248 * 249 * @author Aldert Boerhoop 250 * @date 15-3-2007 251 * @param requestType exportRequestType type of export, int windowId of the window who requested the export 252 */ 253 public void exportToClicked(requestType exportRequestType, int windowId) { 254 255 WindowProperties windowProperties = m_openWindows.get(windowId); 256 windowProperties.exportRequestType = exportRequestType; 257 258 String dialogTitle = "Export as"; 259 String paths = "[]"; 260 String extensions = ""; 261 262 System.out.println(exportRequestType); 263 264 switch (exportRequestType) { 265 266 case image: 267 extensions = ".png"; 268 break; 269 270 case csv: 271 extensions = ".csv"; 272 break; 273 274 case rStore: 275 extensions = ".rstore"; 276 break; 277 } 278 279 ATerm term = m_studio.getATermFactory().make( 280 "vp-open-file-dialog(<int>,<str>,<str>,<str>)", windowId, 281 dialogTitle, paths, extensions); 282 283 m_bridge.sendEvent(term); 284 } 285 286 /** 287 * Calls the correct function to handle the export 288 * 289 * @author Aldert Boerhoop 290 * @date 15-3-2007 291 * @param int windowId of the window who requested the export, String fileName thats entered in the file dialog 292 */ 293 public void vpFileDialogResult(int windowId, String fileName) { 294 295 VisualizationPluginWindow window = getWindowById(windowId); 296 297 switch (getWindowExportRequestType(windowId)) { 298 case image: 299 window.exportToImage(fileName); 300 break; 301 302 case csv: 303 window.exportToCsv(fileName); 304 break; 305 306 default: 307 } 308 } 309 310 /** 311 * Returns a plugin window given by its ID. 312 * 313 * @param windowId ID of the window to return. 314 * @return The window object. 315 * 316 * @author Aldert Boerhoop 317 * @author Arend van Beelen 318 * @date 19-03-2007 319 */ 320 public VisualizationPluginWindow getWindowById(int windowId) { 321 return m_openWindows.get(windowId).window; 322 } 323 324 /** 325 * Gets the export request type. 326 * 327 * @param windowId ID of the window to get the export request type of. 328 * @return The export request type of the window. 329 * 330 * TODO: Should be handled through proper export handlers, but the current 331 * architecture doesn't allow this without extensive refactoring. 332 * 333 * @author Arend van Beelen 334 * @date 13-03-2007 335 */ 336 protected requestType getWindowExportRequestType(int windowId) { 337 WindowProperties windowProperties = m_openWindows.get(windowId); 338 339 return windowProperties.exportRequestType; 340 } 341 342 /** 343 * Calls the correct function to handle the user cancel of the file dialog 344 * 345 * @author Aldert Boerhoop 346 * @date 15-3-2007 347 * @param int windowId of the window who requested the export 348 */ 349 public void vpFileDialogCancel(int windowId) { 350 System.out.println("User cancel!! windowId => " + windowId); 351 } 352 353 public void openLocationInEditor(Location loc) { 354 ATerm event = m_studio.getATermFactory().make("vp-link-clicked(<term>)", loc.toTerm()); 355 m_bridge.sendEvent(event); 356 } 357 358 public class WindowProperties { 359 public VisualizationPluginWindow window; 360 public VisualizationPluginController.requestType exportRequestType; 361 } 362 }