001    package net.sourceforge.mp3dings;
002    
003    import java.awt.Frame;
004    import java.awt.event.MouseEvent;
005    import java.io.File;
006    import java.util.ArrayList;
007    import java.util.Hashtable;
008    import java.util.List;
009    import java.util.logging.Logger;
010    import javax.swing.JMenuItem;
011    import javax.swing.JOptionPane;
012    import javax.swing.JPopupMenu;
013    import javax.swing.JSeparator;
014    import javax.swing.MenuElement;
015    import javax.swing.SwingUtilities;
016    import javax.swing.event.TableModelEvent;
017    import helliker.id3.APICImage;
018    import helliker.id3.ID3v2Tag;
019    import helliker.id3.ID3v2Tag.CorruptHeaderException;
020    import helliker.id3.MP3File;
021    import net.sourceforge.mp3dings.utils.TimeIntensiveTask;
022    
023    /**
024     * The TableModel for the ID3v1 and ID3v2 tables. It holds the data that can
025     * be written to ID3 tags and provides the methods to do so.
026     */
027    public class ID3TagTableModel extends DependentTableModel {
028        private static final Logger logger = Logger.getLogger(ID3TagTableModel.class.getPackage().getName());
029    
030        public static final int CREATE = 0;
031        public static final int NOCHANGE = 1;
032        public static final int OPEN = 0;
033        public static final int REMOVE = 2;
034        public static final int WRITE = 1;
035        private List data;
036        private Hashtable include = new Hashtable();
037        private int version;
038        private static class RowsAndFiles{
039            public final int[] rows;
040            public final File[] files;
041    
042            public RowsAndFiles(int n){
043                rows = new int[n];
044                files = new File[n];
045            }
046        }
047    
048        /**
049         * Constructor
050         *
051         * @param t DOCUMENT ME!
052         * @param v DOCUMENT ME!
053         */
054        public ID3TagTableModel(DataTableModel t, int v) {
055            version = v - 1;
056            init();
057    
058            String key = "fieldModes";
059            String value = getPrefs().get(key, "");
060            String[] incl = value.split(";",-1);
061            if(incl.length > 1){
062                for (int i = 0; i < incl.length; i++) {
063                    try {
064                        include.put(Field.forName(incl[i]),
065                        Integer.valueOf(incl[++i]));
066                    } catch (Exception ex){
067                        logger.severe("Error reading preferences at:");
068                        logger.severe(getPrefs() + "; Key: " + key);
069                        logger.severe(ex.toString());
070                        logger.severe("Corrupt pref value was " + "\"" + value + "\"");
071                        logger.severe("Replacing with \"\"");
072                        getPrefs().put(key,"");
073                    }
074                }
075            }
076            data = new ArrayList();
077            setMaster(t);
078        }
079    
080        public String toString(){
081            return "ID3v"+(version+1)+"TagTableModel " + super.toString();
082        }
083    
084        /**
085         * DOCUMENT ME!
086         *
087         * @return DOCUMENT ME!
088         */
089        public Field[] getAllowedFields() {
090            switch (version) {
091                case 0:
092                    return new Field[]{
093                        Field.FILENAME, Field.ARTIST, Field.TITLE, Field.ALBUM,
094                        Field.TRACK, Field.YEAR, Field.GENRE, Field.COMMENT,
095                        Field.INCLUDE
096                    };
097                case 1:
098                    return new Field[]{
099                        Field.FILENAME, Field.ARTIST, Field.TITLE, Field.ALBUM,
100                        Field.TRACK, Field.YEAR, Field.GENRE, Field.COMMENT,
101                        Field.INCLUDE, Field.ORIGINAL_ARTIST, Field.LYRICIST,
102                        Field.ORIGINAL_LYRICIST, Field.LYRICS, Field.CONDUCTOR,
103                        Field.REMIXED_BY, Field.SUBTITLE, Field.CONTENT_GROUP,
104                        Field.ORIGINAL_ALBUM, Field.PART_OF_SET,
105                        Field.SET_SUBTITLE, Field.ISRC, Field.COMPOSER,
106                        Field.BPM, Field.ORIGINAL_FILENAME, Field.COPYRIGHT,
107                        Field.ENCODER, Field.MOOD, Field.LANGUAGE,
108                        Field.ORCHESTRA, Field.PUBLISHER, Field.KEY,
109                        Field.COM_INFO_URL,
110                        Field.LEGAL_URL,
111                        Field.OFFICIAL_URL,
112                        Field.ARTIST_URL,
113                        Field.SOURCE_URL,
114                        Field.WEB_RADIO_URL,
115                        Field.PAY_URL,
116                        Field.PUBLISHER_URL,
117                        Field.ATTACHED_PICTURE,
118                        Field.ENCODER_SETTINGS
119                    };
120            }
121            return new Field[]{};
122        }
123    
124        /* methods defined in Mp3dingsSortableTabelModel */
125    
126        /**
127         * DOCUMENT ME!
128         *
129         * @param col DOCUMENT ME!
130         * @return DOCUMENT ME!
131         */
132        public String getColumnName(int col) {
133    
134            String s = " ";
135            if (isWritable(col)) {
136                switch (getInclude(col)) {
137                    case CREATE:
138                        s += "[+]";
139                        break;
140                    case NOCHANGE:
141                        s += "[o]";
142                        break;
143                    case REMOVE:
144                        s += "[-]";
145                        break;
146                }
147            }
148            return super.getColumnName(col) + s;
149        }
150    
151        /**
152         * DOCUMENT ME!
153         *
154         * @return DOCUMENT ME!
155         */
156        public Field[] getDefaultFields() {
157            switch (version) {
158            case 0:
159                return new Field[]{
160                    Field.FILENAME, Field.ARTIST, Field.TITLE, Field.ALBUM,
161                    Field.TRACK, Field.YEAR, Field.GENRE, Field.COMMENT,
162                    Field.INCLUDE
163                };
164            case 1:
165                return new Field[]{
166                    Field.FILENAME, Field.ARTIST, Field.TITLE, Field.ALBUM,
167                    Field.TRACK, Field.YEAR, Field.GENRE, Field.COMMENT,
168                    Field.INCLUDE, Field.ATTACHED_PICTURE
169                };
170            }
171            throw new Error("Illegal version " + version);
172        }
173    
174        /**
175         * DOCUMENT ME!
176         *
177         * @param field DOCUMENT ME!
178         * @return DOCUMENT ME!
179         */
180        public boolean getEditable(Field field) {
181            if (field == Field.FILENAME || field == Field.FULLPATH ||
182                        field == Field.LENGTH || field == Field.SIZE) {
183                return false;
184            } else {
185                return true;
186            }
187        }
188    
189        /**
190         * DOCUMENT ME!
191         *
192         * @param e DOCUMENT ME!
193         * @return DOCUMENT ME!
194         */
195        public JPopupMenu getHeaderPopup(MouseEvent e) {
196            JPopupMenu popup = ID3TagTablePopup.getPopup(e);
197            JPopupMenu imported = super.getHeaderPopup(e);
198            if(popup == null){
199                popup = imported;
200            } else {
201            popup.add(new JSeparator());
202                if(imported != null){
203                    MenuElement[] importedItems = imported.getSubElements();
204                    for(int i=0; i<importedItems.length; i++){
205                        popup.add((JMenuItem) importedItems[i]);
206                    }
207                }
208            }
209            return popup;
210        }
211    
212        /**
213         * Determines what should be done with the data in the file tag
214         * when update is called.
215         * @param col the column whose update mode is changed
216         * @param mode the new update mode, one of CREATE, REMOVE, NOCHANGE
217         * @see #getInclude
218         */
219        public void setInclude(int col, int mode) {
220            include.put(getField(col), new Integer(mode));
221    
222            StringBuffer str = new StringBuffer();
223            final int n = getColumnCount() - 1;
224            Field field;
225            for (int c = 0; c < n; c++) {
226                field = getField(c);
227                str.append(field).append(";").append(getInclude(c)).append(";");
228            }
229            str.append(getField(n)).append(";").append(getInclude(n));
230            getPrefs().put("fieldModes", str.toString());
231            fireTableChanged(new TableModelEvent(this, TableModelEvent.HEADER_ROW));
232    
233            //informs the listening Mp3dingsTable that something has changed
234            //and that it needs to doLayout()
235            //without incrementing attached change counters
236            fireDataChanged(0);
237        }
238    
239        /**
240         * Returns what will be done with data in the file tag when update is called.
241         * @param col the column whose update mode is queried
242         * @return one of CREATE, REMOVE, NOCHANGE
243         * @see #setInclude
244         */
245        public int getInclude(int col) {
246    
247            Integer inc = (Integer) include.get(getField(col));
248            return (inc != null) ? inc.intValue() : CREATE;
249        }
250    
251        /**
252         * DOCUMENT ME!
253         *
254         * @return DOCUMENT ME!
255         */
256        public Field[] getPersistentFields() {
257            return new Field[]{Field.INCLUDE};
258        }
259    
260        /**
261         * DOCUMENT ME!
262         *
263         * @return DOCUMENT ME!
264         */
265        public String getPrefKey() {
266            return "id3v" + (version + 1);
267        }
268    
269        /**
270         * DOCUMENT ME!
271         *
272         * @return DOCUMENT ME!
273         */
274        public int getTagVersion() {
275            return version;
276        }
277    
278        /**
279         * Use Field.isWritable() instead if you can.
280         *
281         * @param col DOCUMENT ME!
282         * @return DOCUMENT ME!
283         */
284        public boolean isWritable(int col) {
285            return getField(col).isWritable();
286        }
287    
288        /**
289         * DOCUMENT ME!
290         *
291         * @param owner DOCUMENT ME!
292         */
293        public void remove(Frame owner) {
294            remove(owner, false);
295        }
296    
297        /**
298         * @param owner DOCUMENT ME!
299         * @param forceMpegOffset even when mpegOffset is larger than the
300         *        calculated tag size remove everything up to mpegOffset
301         */
302        public void remove(Frame owner, boolean forceMpegOffset) {
303            RowsAndFiles entries = getEntries();
304            RemoveTagTask removeTask = new RemoveTagTask(owner, entries.files, entries.rows);
305            removeTask.getMonitor().setProgress(1);
306            removeTask.setForceMpegOffset(forceMpegOffset);
307            removeTask.start();
308        }
309    
310        public void update(Frame owner){
311            update(owner, false);
312        }
313    
314        /**
315         * DOCUMENT ME!
316         *
317         * @param owner DOCUMENT ME!
318         */
319        public void update(Frame owner, boolean forceMpegOffset) {
320    
321            boolean stop = true;
322            for (int c = 0; c < getColumnCount(); c++) {
323                if (isWritable(c)) {
324                    stop = stop && (getInclude(c) == NOCHANGE);
325                }
326            }
327            if (stop) {
328                fireMessageSent(Globals.getString("NOTHING_TO_DO"));
329                return;
330            }
331            RowsAndFiles entries = getEntries();
332            UpdateTagTask updateTask = (version == 0)
333                                           ? (UpdateTagTask) new UpdateV1TagTask(
334                                                         owner, entries.files, entries.rows)
335                                           : (UpdateTagTask) new UpdateV2TagTask(
336                                                         owner, entries.files, entries.rows);
337            updateTask.forceMpegOffset = forceMpegOffset;
338            updateTask.getMonitor().setProgress(1);
339            updateTask.start();
340        }
341    
342        /**
343         * DOCUMENT ME!
344         *
345         * @return DOCUMENT ME!
346         */
347        List getData() {
348            return data;
349        }
350    
351        protected void setData(List v){
352            data = v;
353        }
354    
355        /**
356         * DOCUMENT ME!
357         *
358         * @return DOCUMENT ME!
359         */
360        private RowsAndFiles getEntries() {
361    
362            int nEntries = data.size();
363            int cINCL = getColumn(Field.INCLUDE);
364            int n = 0;
365            File[] f = new File[nEntries];
366            int[] rows = new int[nEntries];
367            for (int entry = 0; entry < nEntries; entry++) {
368                rows[n] = getRows(entry);
369                if (((Boolean) getValueAt(rows[n], cINCL)).booleanValue()) {
370                    f[n] = getFile(rows[n++]);
371                }
372            }
373    
374            RowsAndFiles entries = new RowsAndFiles(n);
375            System.arraycopy(f, 0, entries.files, 0, n);
376            System.arraycopy(rows, 0, entries.rows, 0, n);
377            return entries;
378        }
379    
380        /**
381         * DOCUMENT ME!
382         *
383         * @param f DOCUMENT ME!
384         * @param value DOCUMENT ME!
385         * @param field DOCUMENT ME!
386         * @return DOCUMENT ME!
387         */
388        private boolean setField(MP3File f, Object value, Field field) {
389            if (value == null) {
390                return false;
391            }
392            if ("APIC".equals(field.id3v2Frame())){
393                if(value != null && !"".equals(value)){
394                    f.setAttachedPicture((APICImage) value);
395                }
396                return true;
397            }
398    
399            boolean s = false;
400            String str = String.valueOf(value);
401            if (field == Field.ARTIST){
402                f.setArtist(str);
403                s = true;
404            } else if (field == Field.ALBUM){
405                f.setAlbum(str);
406                s = true;
407            } else if (field == Field.TITLE){
408                f.setTitle(str);
409                s = true;
410            } else if (field == Field.TRACK){
411                if (version == 0) {
412                    if (value == null || str.length() < 1) {
413                        str = "0";
414                    }
415    
416                    int n = 0;
417                    try {
418                        n = Integer.parseInt(str);
419                    } catch (NumberFormatException e) {
420                        return false;
421                    }
422                    f.setTrack(n);
423                } else {
424                    f.setTrack(str);
425                }
426                s = true;
427            } else if (field == Field.YEAR){
428                if (version == 0) {
429                    try {
430    
431                        int n = Integer.parseInt(str);
432                    } catch (NumberFormatException e) {
433                        s = false;
434                        return s;
435                    }
436                }
437                f.setYear(str);
438                s = true;
439            } else if (field == Field.GENRE){
440                f.setGenre(str);
441                s = true;
442            } else if (field == Field.COMMENT){
443                f.setComment(str);
444                s = true;
445            }
446            if (f.getTaggingType() != MP3File.ID3V2_ONLY || s) {
447                return s;
448            }
449    
450            //ID3v2 only
451            if (field.type() != Field.TYPE_OTHER) {
452                f.setTextFrame(field.id3v2Frame(), str);
453                return true;
454            } else {
455                return false;
456            }
457        }
458    
459        /**
460         * DOCUMENT ME!
461         *
462         * @param tag DOCUMENT ME!
463         * @param field DOCUMENT ME!
464         * @return DOCUMENT ME!
465         */
466        private boolean removeV2Frame(MP3File tag, Field field) {
467            tag.getV2Tag().removeFrame(field.id3v2Frame());
468            return true;
469        }
470    
471        private class RemoveTagTask extends TimeIntensiveTask {
472    
473            int[] err = new int[]{0, 0};
474            int fileCount = 0;
475            boolean forceMpegOffset = false;
476            File[] src;
477            int successCount = 0;
478            int[] rows;
479    
480            /**
481             * Creates a new RemoveTagTask object.
482             *
483             * @param owner DOCUMENT ME!
484             * @param src DOCUMENT ME!
485             */
486            public RemoveTagTask(Frame owner, File[] src, int[] rows) {
487                super(owner, Globals.getMessage("ID3_REMOVE_INIT",
488                      new Integer(version + 1)), null);
489                this.src = src;
490                this.rows = rows;
491    
492            }
493    
494            /**
495             * DOCUMENT ME!
496             */
497            public void finished() {
498    
499                String statusOut = Globals.getMessage("ID3_REMOVE_STATUS",
500                                                        new Object[]{
501                    new Integer(successCount), new Integer(src.length)
502                }); // "Removed x tag(s) from y file(s)"
503                int numerrors = err[OPEN] + err[WRITE];
504                if (numerrors > 0) {
505                    statusOut += Globals.getMessage("ID3_UPDATE_ERRORS",
506                                                      new Object[]{
507                        new Integer(numerrors), new Integer(err[OPEN]),
508                        new Integer(err[WRITE])
509                    }); // ", x error(s)     [open failure:y, write failure:z]."
510                } else {
511                    statusOut += ".";
512                }
513                fireMessageSent(statusOut);
514            }
515    
516            /**
517             *
518             *
519             * @param fmo DOCUMENT ME!
520             */
521            public void setForceMpegOffset(boolean fmo) {
522                forceMpegOffset = fmo;
523            }
524    
525            /**
526             *
527             */
528            public void run() {
529                if(src.length == 0){return;}
530                int jd3Tag = (version == 0) ? MP3File.ID3V1_ONLY : MP3File.ID3V2_ONLY;
531                int cINCL = getColumn(Field.INCLUDE);
532                UpdateRunnable notify = new UpdateRunnable(rows[0],rows[0]);
533                getMonitor().setProgress(1);
534                for (fileCount = 0; fileCount < src.length && !getMonitor().isCanceled();
535                        getMonitor().setProgress(1 + (++fileCount) * 99 / src.length)
536                ) {
537                    MP3File filetag = null;
538                    boolean corruptV2 = false;
539                    try {
540                        filetag = new MP3File(src[fileCount], jd3Tag);
541                    } catch (Exception e) {
542                        if(jd3Tag == MP3File.ID3V2_ONLY && forceMpegOffset){
543                            corruptV2 = true;
544                        } else {
545                            err[OPEN]++;
546                            logger.warning("Read error at file " +
547                                    src[fileCount].getName());
548                            logger.warning(e.toString());
549                            continue;
550                        }
551                    }
552                    try {
553                        if(corruptV2){
554                            MP3File.removeLeadingGarbage(src[fileCount]);
555                        } else {
556                            filetag.removeTags(jd3Tag, forceMpegOffset);
557                        }
558                    } catch (Exception e) {
559                        err[WRITE]++;
560                        logger.warning(
561                                    "Write error at file " +
562                                    src[fileCount].getName());
563                        logger.warning(e.toString());
564                        continue;
565                    }
566                    successCount++;
567                    /* setValueAt causes this to hang.
568                     * Probably because events are fired...
569                     */
570                    set(Boolean.FALSE, rows[fileCount], cINCL);
571                    notify.setLastRow(rows[fileCount]);
572                    SwingUtilities.invokeLater(notify);
573                }
574            }
575        }
576    
577        private abstract class UpdateTagTask extends TimeIntensiveTask {
578    
579            int[] err = new int[]{0, 0};
580            int fileCount = 0;
581            boolean forceMpegOffset = false;
582            int frameCount = 0;
583            int nc = getColumnCount();
584            int[] rows;
585            File[] src;
586    
587            /**
588             * Creates a new UpdateTagTask object.
589             *
590             * @param owner DOCUMENT ME!
591             * @param src DOCUMENT ME!
592             */
593            public UpdateTagTask(Frame owner, File[] src, int[] rows) {
594                super(owner, Globals.getMessage("ID3_UPDATE_INIT", version + 1), null);
595                if(rows.length != src.length){
596                    throw new IllegalArgumentException("src and rows must have equal length.");
597                }
598                this.src = src;
599                this.rows = rows;
600            }
601    
602            /**
603             * DOCUMENT ME!
604             *
605             * @param fmo DOCUMENT ME!
606             */
607            public void setForceMpegOffset(boolean fmo) {
608                forceMpegOffset = fmo;
609            }
610    
611            /**
612             * DOCUMENT ME!
613             */
614            public void run() {
615                if(src.length != 0){updateTag();}
616            }
617    
618            /**
619             * DOCUMENT ME!
620             */
621            public abstract void updateTag();
622    
623            /**
624             * DOCUMENT ME!
625             */
626            public void finished() {
627                fireTableDataChanged();
628    
629                String statusOut = Globals.getMessage("ID3_UPDATE_STATUS",
630                                                        new Object[]{
631                    new Integer(frameCount), new Integer(fileCount)
632                }); // "Updated x frame(s) in y file(s)"
633                int numerrors = err[OPEN] + err[WRITE];
634                if (numerrors > 0) {
635                    statusOut += Globals.getMessage("ID3_UPDATE_ERRORS",
636                                                      new Object[]{
637                        new Integer(numerrors), new Integer(err[OPEN]),
638                        new Integer(err[WRITE])
639                    }); // ", x error(s)     [open failure:y, write failure:z]."
640                } else {
641                    statusOut += ".";
642                }
643                fireMessageSent(statusOut);
644            }
645        }
646    
647        private class UpdateV1TagTask extends UpdateTagTask {
648    
649            /**
650             * Creates a new UpdateV1TagTask object.
651             *
652             * @param owner DOCUMENT ME!
653             * @param src DOCUMENT ME!
654             */
655            public UpdateV1TagTask(Frame owner, File[] src, int[] rows) {
656                super(owner, src, rows);
657            }
658    
659            /**
660             * DOCUMENT ME!
661             */
662            public void updateTag() {
663    
664                int cINCL = getColumn(Field.INCLUDE);
665                int framesPerFile = 0;
666                for (int c = 0; c < nc; c++) {
667                    if (isWritable(c)) {
668                        framesPerFile++;
669                    }
670                }
671                UpdateRunnable notify = new UpdateRunnable(rows[0], rows[0]);
672                getMonitor().setProgress(1);
673                for (fileCount = 0;
674                        fileCount < src.length && !getMonitor().isCanceled();
675                        getMonitor().setProgress(1 + (++fileCount) * 99 / src.length)) {
676                    SwingUtilities.invokeLater(notify);
677                    notify.setLastRow(rows[fileCount]);
678    
679                    int frames = 0;
680                    MP3File filetag = null;
681                    try {
682                        filetag = new MP3File(src[fileCount], MP3File.ID3V1_ONLY);
683                        for (int c = 0; c < nc; c++) {
684    
685                            Field field = getField(c);
686                            if (field.isWritable()) {
687                                switch (getInclude(c)) {
688                                    case CREATE:
689                                    if (setField(filetag, getValueAt(rows[fileCount], c),
690                                    field)) {
691                                        frames++;
692                                    }
693                                    break;
694                                    case REMOVE:
695                                    if (setField(filetag, "", field)) {
696                                        frames++;
697                                    }
698                                    break;
699                                }
700                            }
701                        }
702                    } catch (Exception e) {
703                        err[OPEN]++;
704                    }
705                    try {
706                        filetag.writeTags();
707                    } catch (Exception e) {
708                        err[WRITE]++;
709                        logger.warning(
710                                    "Checked exception (write error) at file " +
711                                    src[fileCount].getName());
712                        logger.warning(e.toString());
713                    }
714    
715                    /* setValueAt causes this to hang.
716                     * Probably because events are fired from outside the event thread
717                     */
718                    set(Boolean.FALSE, rows[fileCount], cINCL);
719                    frameCount += frames;
720                }
721            }
722        }
723    
724        private class UpdateV2TagTask extends UpdateTagTask {
725            private Integer corruptHeaderAction = null;
726    
727            /**
728             * Creates a new UpdateV2TagTask object.
729             *
730             * @param owner DOCUMENT ME!
731             * @param src DOCUMENT ME!
732             */
733            public UpdateV2TagTask(Frame owner, File[] src, int[] rows) {
734                super(owner, src, rows);
735            }
736    
737            /**
738             * DOCUMENT ME!
739             */
740            public void updateTag() {
741    
742                int cINCL = getColumn(Field.INCLUDE);
743                int framesPerFile = 0;
744                for (int c = 0; c < nc; c++) {
745                    if (isWritable(c)) {
746                        framesPerFile++;
747                    }
748                }
749                UpdateRunnable notify = new UpdateRunnable(rows[0], rows[0]);
750                getMonitor().setProgress(1);
751                for (fileCount = 0;
752                        fileCount < src.length && !getMonitor().isCanceled();
753                        getMonitor().setProgress(1 + (++fileCount) * 99 / src.length)){
754                    SwingUtilities.invokeLater(notify);
755                    notify.setLastRow(rows[fileCount]);
756    
757                    MP3File filetag;
758                    ID3v2Tag tag;
759                    int frames = 0;
760    
761                    /* get a new ID3v2 tag object for the file*/
762                    try {
763                        filetag = new MP3File(src[fileCount], MP3File.ID3V2_ONLY);
764                    } catch (Exception e) {
765                        err[OPEN]++;
766                        continue;
767                    }
768                    for (int c = 0; c < nc; c++) {
769                        if (isWritable(c)) {
770                            switch (getInclude(c)) {
771    
772                                /* set the field values of the tag from the table */
773                                case CREATE:
774                                    if (setField(filetag, getValueAt(rows[fileCount], c),
775                                                 getField(c))) {
776                                        frames++;
777                                    }
778                                    break;
779    
780                                /* remove frames */
781                                case REMOVE:
782                                    if (removeV2Frame(filetag, getField(c))) {
783                                        frames++;
784                                    }
785                                    break;
786                            }
787                        }
788                    }
789    
790                    /* commit the changes and write them to the file */
791                    try{
792                        try {
793                            filetag.writeTags(forceMpegOffset);
794                        } catch (final CorruptHeaderException chx){
795                            while(corruptHeaderAction == null){
796                                Runnable r = new Runnable(){
797                                    public void run(){
798                                        Object[] options =
799                                        //Globals.getStringArray("COPY_WARNING_OPTIONS");
800                                        new String[]{"Fix", "Fix all", "Skip", "Skip all"};
801                                        // String warning = Globals.getMessage("COPY_WARNING_MESSAGE",
802                                            // new Object[]{
803                                                // currFile,
804                                                // new Integer(src.length),
805                                                // dest.getAbsolutePath(),
806                                                // msg
807                                            // }
808                                            // );
809                                        String warning = chx.getMessage();
810                                        //cpstatus.setStatus(warning);
811                                        corruptHeaderAction = new Integer(
812                                            JOptionPane.showOptionDialog(
813                                                owner,
814                                                warning,
815                                                Globals.getString("WARNING"),
816                                                JOptionPane.DEFAULT_OPTION,
817                                                JOptionPane.WARNING_MESSAGE,
818                                                null, options, null
819                                            )
820                                        );
821                                    }
822                                };
823                                try{
824                                    SwingUtilities.invokeAndWait(r);
825                                } catch (Exception ex){
826                                    throw new Error(ex);
827                                }
828                            }
829                            switch(corruptHeaderAction.intValue()){
830                                case 0: //Fix
831                                    corruptHeaderAction = null; //reset
832                                    filetag.writeTags(true);
833                                    break;
834                                case 1: //Fix all
835                                    forceMpegOffset = true;
836                                    filetag.writeTags(true);
837                                    break;
838                                case 2: //skip
839                                    corruptHeaderAction = null; //reset
840                                    throw chx;
841                                case 3: //skip all
842                                    throw chx;
843                            }
844                        }
845                    } catch (Exception e) {
846                        err[WRITE]++;
847                        logger.warning(
848                            "Checked exception (write error) at file " +
849                            src[fileCount].getName());
850                        logger.warning(e.toString());
851                        continue;
852                    }
853    
854                    /* increase framecount and de-select file */
855                    frameCount += frames;
856    
857                    /* setValueAt causes this to hang.
858                     * Probably because events are fired...
859                     */
860                    set(Boolean.FALSE, rows[fileCount], cINCL);
861                }
862            }
863    
864        }
865    }