Markups/src/net/sourceforge/aprog/markups/MarkupsActions.java

   1 /*
   2  *  The MIT License
   3  *
   4  *  Copyright 2010 Codist Monk.
   5  *
   6  *  Permission is hereby granted, free of charge, to any person obtaining a copy
   7  *  of this software and associated documentation files (the "Software"), to deal
   8  *  in the Software without restriction, including without limitation the rights
   9  *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  *  copies of the Software, and to permit persons to whom the Software is
  11  *  furnished to do so, subject to the following conditions:
  12  *
  13  *  The above copyright notice and this permission notice shall be included in
  14  *  all copies or substantial portions of the Software.
  15  *
  16  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  *  THE SOFTWARE.
  23  */
  24
  25 package net.sourceforge.aprog.markups;
  26
  27 import static net.sourceforge.aprog.markups.MarkupsConstants.Variables.*;
  28 import static net.sourceforge.aprog.xml.XMLTools.*;
  29
  30 import java.awt.Component;
  31 import java.io.FileNotFoundException;
  32 import java.util.logging.Level;
  33
  34 import java.io.File;
  35 import java.io.FileOutputStream;
  36 import java.util.List;
  37
  38 import javax.swing.JFileChooser;
  39 import javax.swing.JOptionPane;
  40
  41 import net.sourceforge.aprog.context.Context;
  42 import net.sourceforge.aprog.subtitlesadjuster.SubtitlesAdjusterActions;
  43 import net.sourceforge.aprog.tools.IllegalInstantiationException;
  44 import net.sourceforge.aprog.tools.Tools;
  45 import net.sourceforge.aprog.xml.XMLTools;
  46
  47 import org.w3c.dom.Node;
  48 import org.xml.sax.InputSource;
  49
  50 /**
  51  *
  52  * @author codistmonk (creation 2010-07-03)
  53  */
  54 public final class MarkupsActions {
  55
  56     /**
  57      * @throws IllegalInstantiationException To prevent instantiation
  58      */
  59     private MarkupsActions() {
  60         throw new IllegalInstantiationException();
  61     }
  62
  63     /**
  64      *
  65      * @param context
  66      * <br>Unused
  67      */
  68     public static final void quit(final Context context) {
  69         if (confirm(context)) {
  70             System.exit(0);
  71         }
  72     }
  73
  74     /**
  75      * Returns {@code true} if the file doesn't need saving;
  76      * otherwise, asks the user what to do.
  77      *
  78      * @param context
  79      * <br>Not null
  80      * <br>Input-output
  81      * @return {@code true} if the caller can proceed
  82      */
  83     public static final boolean confirm(final Context context) {
  84         if ((Boolean) context.get(FILE_MODIFIED)) {
  85             switch (JOptionPane.showConfirmDialog(null, "Save?", null, JOptionPane.YES_NO_CANCEL_OPTION)) {
  86                 case JOptionPane.YES_OPTION:
  87                     save(context);
  88                     break;
  89                 case JOptionPane.NO_OPTION:
  90                     break;
  91                 case JOptionPane.CANCEL_OPTION:
  92                     return false;
  93                 default:
  94                     Tools.getLoggerForThisMethod().log(Level.WARNING, "Unhandled option");
  95                     break;
  96             }
  97         }
  98
  99         return true;
 100     }
 101
 102     /**
 103      *
 104      * @param context
 105      * <br>Not null
 106      * <br>Input-output
 107      */
 108     public static final void newFile(final Context context) {
 109         if (confirm(context)) {
 110             context.set(FILE, null);
 111         }
 112     }
 113
 114     /**
 115      *
 116      * @param context
 117      * <br>Not null
 118      * <br>Input-output
 119      */
 120     public static final void open(final Context context) {
 121         if (!confirm(context)) {
 122             return;
 123         }
 124
 125         final JFileChooser fileChooser = new JFileChooser();
 126
 127         if (JFileChooser.APPROVE_OPTION == fileChooser.showOpenDialog((Component) context.get(MAIN_FRAME)) &&
 128                 fileChooser.getSelectedFile() != null) {
 129             open(context, fileChooser.getSelectedFile());
 130         }
 131     }
 132
 133     /**
 134      *
 135      * @param context
 136      * <br>Not null
 137      * <br>Input-output
 138      * @param file
 139      * <br>Not null
 140      * <br>Shared
 141      */
 142     public static final void open(final Context context, final File file) {
 143         context.set(DOM, XMLTools.parse(new InputSource(file.getAbsolutePath())));
 144         context.set(FILE, file);
 145     }
 146
 147     /**
 148      *
 149      * @param context
 150      * <br>Not null
 151      * <br>Input-output
 152      */
 153     public static final void save(final Context context) {
 154         final File file = context.get(FILE);
 155
 156         if (file != null) {
 157             save(context, file);
 158         } else {
 159             saveAs(context);
 160         }
 161     }
 162
 163     /**
 164      *
 165      * @param context
 166      * <br>Not null
 167      * <br>Input-output
 168      */
 169     public static final void saveAs(final Context context) {
 170         final JFileChooser fileChooser = new JFileChooser();
 171
 172         if (JFileChooser.APPROVE_OPTION == fileChooser.showSaveDialog((Component) context.get(MAIN_FRAME)) &&
 173                 fileChooser.getSelectedFile() != null) {
 174             save(context, fileChooser.getSelectedFile());
 175         }
 176     }
 177
 178     /**
 179      *
 180      * @param context
 181      * <br>Not null
 182      * <br>Input-output
 183      * @param file
 184      * <br>Not null
 185      * <br>Shared
 186      */
 187     private static final void save(final Context context, final File file) {
 188         try {
 189             XMLTools.write(
 190                     (Node) context.get(DOM),
 191                     new FileOutputStream(file),
 192                     0);
 193             context.set(FILE, file);
 194             context.set(FILE_MODIFIED, false);
 195         } catch (final FileNotFoundException exception) {
 196             SubtitlesAdjusterActions.showErrorMessage(context, exception);
 197         }
 198     }
 199
 200     /**
 201      *
 202      * @param context
 203      * <br>Not null
 204      */
 205     public static final void undo(final Context context) {
 206         Tools.debugPrint("TODO");
 207
 208         SubtitlesAdjusterActions.showTODOMessage(context);
 209     }
 210
 211     /**
 212      *
 213      * @param context
 214      * <br>Not null
 215      */
 216     public static final void redo(final Context context) {
 217         Tools.debugPrint("TODO");
 218
 219         SubtitlesAdjusterActions.showTODOMessage(context);
 220     }
 221
 222     /**
 223      *
 224      * @param context
 225      * <br>Not null
 226      */
 227     public static final void copy(final Context context) {
 228         Tools.debugPrint("TODO");
 229
 230         SubtitlesAdjusterActions.showTODOMessage(context);
 231     }
 232
 233     /**
 234      *
 235      * @param context
 236      * <br>Not null
 237      */
 238     public static final void cut(final Context context) {
 239         Tools.debugPrint("TODO");
 240
 241         SubtitlesAdjusterActions.showTODOMessage(context);
 242     }
 243
 244     /**
 245      *
 246      * @param context
 247      * <br>Not null
 248      */
 249     public static final void paste(final Context context) {
 250         Tools.debugPrint("TODO");
 251
 252         SubtitlesAdjusterActions.showTODOMessage(context);
 253     }
 254
 255     /**
 256      *
 257      * @param context
 258      * <br>Not null
 259      */
 260     public static final void appendNewNode(final Context context) {
 261         Tools.debugPrint("TODO");
 262
 263         SubtitlesAdjusterActions.showTODOMessage(context);
 264     }
 265
 266     /**
 267      *
 268      * @param context
 269      * <br>Not null
 270      */
 271     public static final void moveUp(final Context context) {
 272         final Node node = context.get(SELECTED_NODE);
 273         final Node parent = getNode(node, "..");
 274
 275         context.set(SELECTED_NODE, null);
 276
 277         {
 278             final List<Node> siblings = MarkupsTools.getAttributeChildren(parent);
 279             final int index = siblings.indexOf(node);
 280
 281             if (index >= 0) {
 282                 Tools.debugPrint("TODO");
 283
 284                 return;
 285             }
 286         }
 287
 288         {
 289             final List<Node> siblings = MarkupsTools.getNonattributeChildren(parent);
 290             final int index = siblings.indexOf(node);
 291
 292             if (index < 0) {
 293                 Tools.debugPrint(siblings);
 294                 throw new IllegalStateException("Orphan node: " + node);
 295             }
 296
 297             if (index > 0) {
 298                 parent.insertBefore(node, siblings.get(index - 1));
 299             }
 300         }
 301
 302         parent.normalize();
 303
 304         context.set(SELECTED_NODE, node);
 305     }
 306
 307     /**
 308      *
 309      * @param context
 310      * <br>Not null
 311      */
 312     public static final void moveDown(final Context context) {
 313         final Node node = context.get(SELECTED_NODE);
 314         final Node parent = getNode(node, "..");
 315
 316         {
 317             final List<Node> siblings = MarkupsTools.getAttributeChildren(parent);
 318             final int index = siblings.indexOf(node);
 319
 320             if (index >= 0) {
 321                 if (index == siblings.size() - 2) {
 322                     parent.getAttributes().removeNamedItem(node.getNodeName());
 323                     parent.getAttributes().setNamedItem(node);
 324                 } else if (index < siblings.size() - 2) {
 325                     Tools.debugPrint("TODO");
 326                 }
 327
 328                 return;
 329             }
 330         }
 331
 332         {
 333             final List<Node> siblings = MarkupsTools.getNonattributeChildren(parent);
 334             final int index = siblings.indexOf(node);
 335
 336             if (index < 0) {
 337                 Tools.debugPrint(siblings);
 338                 throw new IllegalStateException("Orphan node: " + node);
 339             }
 340
 341             if (index == siblings.size() - 2) {
 342                 parent.appendChild(node);
 343             } else {
 344                 parent.insertBefore(node, siblings.get(index + 2));
 345             }
 346         }
 347
 348         parent.normalize();
 349
 350         context.set(SELECTED_NODE, node);
 351     }
 352
 353     /**
 354      *
 355      * @param context
 356      * <br>Not null
 357      * <br>Input-output
 358      */
 359     public static final void evaluateXPathExpression(final Context context) {
 360         final Node node = context.get(SELECTED_NODE);
 361
 362         try {
 363             context.set(XPATH_RESULT, XMLTools.getNodes(node, (String) context.get(XPATH_EXPRESSION)));
 364             context.set(XPATH_ERROR, null);
 365         } catch (final Exception exception) {
 366             context.set(XPATH_RESULT, null);
 367             context.set(XPATH_ERROR, exception);
 368         }
 369     }
 370
 371     /**
 372      *
 373      * @param context
 374      * <br>Not null
 375      * <br>Input-output
 376      */
 377     public static final void evaluateQuasiXPathExpression(final Context context) {
 378         try {
 379             XMLTools.getOrCreateNode((Node) context.get(SELECTED_NODE), (String) context.get(QUASI_XPATH_EXPRESSION));
 380
 381             context.set(QUASI_XPATH_ERROR, null);
 382         } catch (final Exception exception) {
 383             context.set(QUASI_XPATH_ERROR, exception);
 384         }
 385     }
 386
 387 }