Any extra data that cannot be parsed by the rules above will be
* consumed as "unparseable" extra data and treated differently by the
* methods of this class. Versions prior to Apache Commons Compress
* 1.1 would have thrown an exception if any attempt was made to read
* or write extra data not conforming to the recommendation.
*
*/
@SuppressWarnings({"unchecked", "rawtypes"})
public class ZipEntry extends java.util.zip.ZipEntry implements Cloneable {
public static final int PLATFORM_UNIX = 3;
public static final int PLATFORM_FAT = 0;
private static final int SHORT_MASK = 0xFFFF;
private static final int SHORT_SHIFT = 16;
private int internalAttributes = 0;
private int platform = PLATFORM_FAT;
private long externalAttributes = 0;
private LinkedHashMap/**/ extraFields = null;
private UnparseableExtraFieldData unparseableExtra = null;
private String name = null;
/**
* Creates a new zip entry with the specified name.
* @param name the name of the entry
* @since 1.1
*/
public ZipEntry(String name) {
super(name);
}
/**
* Creates a new zip entry with fields taken from the specified zip entry.
* @param entry the entry to get fields from
* @since 1.1
* @throws ZipException on error
*/
public ZipEntry(java.util.zip.ZipEntry entry) throws ZipException {
super(entry);
byte[] extra = entry.getExtra();
if (extra != null) {
setExtraFields(ExtraFieldUtils.parse(extra, true,
ExtraFieldUtils
.UnparseableExtraField.READ));
} else {
// initializes extra data to an empty byte array
setExtra();
}
}
/**
* Creates a new zip entry with fields taken from the specified zip entry.
* @param entry the entry to get fields from
* @throws ZipException on error
* @since 1.1
*/
public ZipEntry(ZipEntry entry) throws ZipException {
this((java.util.zip.ZipEntry) entry);
setInternalAttributes(entry.getInternalAttributes());
setExternalAttributes(entry.getExternalAttributes());
setExtraFields(entry.getExtraFields(true));
}
/**
* @since 1.9
*/
protected ZipEntry() {
super("");
}
/**
* Overwrite clone.
* @return a cloned copy of this ZipEntry
* @since 1.1
*/
public Object clone() {
ZipEntry e = (ZipEntry) super.clone();
e.setInternalAttributes(getInternalAttributes());
e.setExternalAttributes(getExternalAttributes());
e.setExtraFields(getExtraFields(true));
return e;
}
/**
* Retrieves the internal file attributes.
*
* @return the internal file attributes
* @since 1.1
*/
public int getInternalAttributes() {
return internalAttributes;
}
/**
* Sets the internal file attributes.
* @param value an int value
* @since 1.1
*/
public void setInternalAttributes(int value) {
internalAttributes = value;
}
/**
* Retrieves the external file attributes.
* @return the external file attributes
* @since 1.1
*/
public long getExternalAttributes() {
return externalAttributes;
}
/**
* Sets the external file attributes.
* @param value an long value
* @since 1.1
*/
public void setExternalAttributes(long value) {
externalAttributes = value;
}
/**
* Sets Unix permissions in a way that is understood by Info-Zip's
* unzip command.
* @param mode an int value
* @since Ant 1.5.2
*/
public void setUnixMode(int mode) {
// CheckStyle:MagicNumberCheck OFF - no point
setExternalAttributes((mode << SHORT_SHIFT)
// MS-DOS read-only attribute
| ((mode & 0200) == 0 ? 1 : 0)
// MS-DOS directory flag
| (isDirectory() ? 0x10 : 0));
// CheckStyle:MagicNumberCheck ON
platform = PLATFORM_UNIX;
}
/**
* Unix permission.
* @return the unix permissions
* @since Ant 1.6
*/
public int getUnixMode() {
return platform != PLATFORM_UNIX ? 0 :
(int) ((getExternalAttributes() >> SHORT_SHIFT) & SHORT_MASK);
}
/**
* Platform specification to put into the "version made
* by" part of the central file header.
*
* @return PLATFORM_FAT unless {@link #setUnixMode setUnixMode}
* has been called, in which case PLATORM_UNIX will be returned.
*
* @since Ant 1.5.2
*/
public int getPlatform() {
return platform;
}
/**
* Set the platform (UNIX or FAT).
* @param platform an int value - 0 is FAT, 3 is UNIX
* @since 1.9
*/
protected void setPlatform(int platform) {
this.platform = platform;
}
/**
* Replaces all currently attached extra fields with the new array.
* @param fields an array of extra fields
* @since 1.1
*/
public void setExtraFields(ZipExtraField[] fields) {
extraFields = new LinkedHashMap();
for (int i = 0; i < fields.length; i++) {
if (fields[i] instanceof UnparseableExtraFieldData) {
unparseableExtra = (UnparseableExtraFieldData) fields[i];
} else {
extraFields.put(fields[i].getHeaderId(), fields[i]);
}
}
setExtra();
}
/**
* Retrieves all extra fields that have been parsed successfully.
* @return an array of the extra fields
*/
public ZipExtraField[] getExtraFields() {
return getExtraFields(false);
}
/**
* Retrieves extra fields.
* @param includeUnparseable whether to also return unparseable
* extra fields as {@link UnparseableExtraFieldData} if such data
* exists.
* @return an array of the extra fields
* @since 1.1
*/
public ZipExtraField[] getExtraFields(boolean includeUnparseable) {
if (extraFields == null) {
return !includeUnparseable || unparseableExtra == null
? new ZipExtraField[0]
: new ZipExtraField[] { unparseableExtra };
}
List result = new ArrayList(extraFields.values());
if (includeUnparseable && unparseableExtra != null) {
result.add(unparseableExtra);
}
return (ZipExtraField[]) result.toArray(new ZipExtraField[0]);
}
/**
* Adds an extra field - replacing an already present extra field
* of the same type.
*
* If no extra field of the same type exists, the field will be
* added as last field.
* @param ze an extra field
* @since 1.1
*/
public void addExtraField(ZipExtraField ze) {
if (ze instanceof UnparseableExtraFieldData) {
unparseableExtra = (UnparseableExtraFieldData) ze;
} else {
if (extraFields == null) {
extraFields = new LinkedHashMap();
}
extraFields.put(ze.getHeaderId(), ze);
}
setExtra();
}
/**
* Adds an extra field - replacing an already present extra field
* of the same type.
*
* The new extra field will be the first one.
* @param ze an extra field
* @since 1.1
*/
public void addAsFirstExtraField(ZipExtraField ze) {
if (ze instanceof UnparseableExtraFieldData) {
unparseableExtra = (UnparseableExtraFieldData) ze;
} else {
LinkedHashMap copy = extraFields;
extraFields = new LinkedHashMap();
extraFields.put(ze.getHeaderId(), ze);
if (copy != null) {
copy.remove(ze.getHeaderId());
extraFields.putAll(copy);
}
}
setExtra();
}
/**
* Remove an extra field.
* @param type the type of extra field to remove
* @since 1.1
*/
public void removeExtraField(ZipShort type) {
if (extraFields == null) {
throw new java.util.NoSuchElementException();
}
if (extraFields.remove(type) == null) {
throw new java.util.NoSuchElementException();
}
setExtra();
}
/**
* Removes unparseable extra field data.
*/
public void removeUnparseableExtraFieldData() {
if (unparseableExtra == null) {
throw new java.util.NoSuchElementException();
}
unparseableExtra = null;
setExtra();
}
/**
* Looks up an extra field by its header id.
*
* @return null if no such field exists.
*/
public ZipExtraField getExtraField(ZipShort type) {
if (extraFields != null) {
return (ZipExtraField) extraFields.get(type);
}
return null;
}
/**
* Looks up extra field data that couldn't be parsed correctly.
*
* @return null if no such field exists.
*/
public UnparseableExtraFieldData getUnparseableExtraFieldData() {
return unparseableExtra;
}
/**
* Parses the given bytes as extra field data and consumes any
* unparseable data as an {@link UnparseableExtraFieldData}
* instance.
* @param extra an array of bytes to be parsed into extra fields
* @throws RuntimeException if the bytes cannot be parsed
* @since 1.1
* @throws RuntimeException on error
*/
public void setExtra(byte[] extra) throws RuntimeException {
try {
ZipExtraField[] local =
ExtraFieldUtils.parse(extra, true,
ExtraFieldUtils.UnparseableExtraField.READ);
mergeExtraFields(local, true);
} catch (Exception e) {
// actually this is not be possible as of Ant 1.8.1
throw new RuntimeException("Error parsing extra fields for entry: "
+ getName() + " - " + e.getMessage(), e);
}
}
/**
* Unfortunately {@link java.util.zip.ZipOutputStream
* java.util.zip.ZipOutputStream} seems to access the extra data
* directly, so overriding getExtra doesn't help - we need to
* modify super's data directly.
*
* @since 1.1
*/
protected void setExtra() {
super.setExtra(ExtraFieldUtils.mergeLocalFileDataData(getExtraFields(true)));
}
/**
* Sets the central directory part of extra fields.
*/
public void setCentralDirectoryExtra(byte[] b) {
try {
ZipExtraField[] central =
ExtraFieldUtils.parse(b, false,
ExtraFieldUtils.UnparseableExtraField.READ);
mergeExtraFields(central, false);
} catch (Exception e) {
throw new RuntimeException(e.getMessage(), e);
}
}
/**
* Retrieves the extra data for the local file data.
* @return the extra data for local file
* @since 1.1
*/
public byte[] getLocalFileDataExtra() {
byte[] extra = getExtra();
return extra != null ? extra : new byte[0];
}
/**
* Retrieves the extra data for the central directory.
* @return the central directory extra data
* @since 1.1
*/
public byte[] getCentralDirectoryExtra() {
return ExtraFieldUtils.mergeCentralDirectoryData(getExtraFields(true));
}
/**
* Make this class work in JDK 1.1 like a 1.2 class.
*
* This either stores the size for later usage or invokes
* setCompressedSize via reflection.
* @param size the size to use
* @deprecated since 1.7.
* Use setCompressedSize directly.
* @since 1.2
*/
public void setComprSize(long size) {
setCompressedSize(size);
}
/**
* Get the name of the entry.
* @return the entry name
* @since 1.9
*/
public String getName() {
return name == null ? super.getName() : name;
}
/**
* Is this entry a directory?
* @return true if the entry is a directory
* @since 1.10
*/
public boolean isDirectory() {
return getName().endsWith("/");
}
/**
* Set the name of the entry.
* @param name the name to use
*/
protected void setName(String name) {
this.name = name;
}
/**
* Get the hashCode of the entry.
* This uses the name as the hashcode.
* @return a hashcode.
* @since Ant 1.7
*/
public int hashCode() {
// this method has severe consequences on performance. We cannot rely
// on the super.hashCode() method since super.getName() always return
// the empty string in the current implemention (there's no setter)
// so it is basically draining the performance of a hashmap lookup
return getName().hashCode();
}
/**
* The equality method. In this case, the implementation returns 'this == o'
* which is basically the equals method of the Object class.
* @param o the object to compare to
* @return true if this object is the same as o
* @since Ant 1.7
*/
public boolean equals(Object o) {
return (this == o);
}
/**
* If there are no extra fields, use the given fields as new extra
* data - otherwise merge the fields assuming the existing fields
* and the new fields stem from different locations inside the
* archive.
* @param f the extra fields to merge
* @param local whether the new fields originate from local data
*/
private void mergeExtraFields(ZipExtraField[] f, boolean local)
throws ZipException {
if (extraFields == null) {
setExtraFields(f);
} else {
for (int i = 0; i < f.length; i++) {
ZipExtraField existing;
if (f[i] instanceof UnparseableExtraFieldData) {
existing = unparseableExtra;
} else {
existing = getExtraField(f[i].getHeaderId());
}
if (existing == null) {
addExtraField(f[i]);
} else {
if (local
|| !(existing
instanceof CentralDirectoryParsingZipExtraField)) {
byte[] b = f[i].getLocalFileDataData();
existing.parseFromLocalFileData(b, 0, b.length);
} else {
byte[] b = f[i].getCentralDirectoryData();
((CentralDirectoryParsingZipExtraField) existing)
.parseFromCentralDirectoryData(b, 0, b.length);
}
}
}
setExtra();
}
}
}
charactermanaj/src/org/apache/tools/zip/UnicodePathExtraField.java 0000644 0001750 0001750 00000005271 11767047544 025534 0 ustar paulliu paulliu /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*
*/
package org.apache.tools.zip;
/**
* Info-ZIP Unicode Path Extra Field (0x7075):
*
* Stores the UTF-8 version of the file name field as stored in the
* local header and central directory header.
*
*
* Value Size Description
* ----- ---- -----------
* (UPath) 0x7075 Short tag for this extra block type ("up")
* TSize Short total data size for this block
* Version 1 byte version of this extra field, currently 1
* NameCRC32 4 bytes File Name Field CRC32 Checksum
* UnicodeName Variable UTF-8 version of the entry File Name
*
*/
public class UnicodePathExtraField extends AbstractUnicodeExtraField {
public static final ZipShort UPATH_ID = new ZipShort(0x7075);
public UnicodePathExtraField () {
}
/**
* Assemble as unicode path extension from the name given as
* text as well as the encoded bytes actually written to the archive.
*
* @param text The file name
* @param bytes the bytes actually written to the archive
* @param off The offset of the encoded filename in bytes.
* @param len The length of the encoded filename or comment in
* bytes.
*/
public UnicodePathExtraField(String text, byte[] bytes, int off, int len) {
super(text, bytes, off, len);
}
/**
* Assemble as unicode path extension from the name given as
* text as well as the encoded bytes actually written to the archive.
*
* @param name The file name
* @param bytes the bytes actually written to the archive
*/
public UnicodePathExtraField(String name, byte[] bytes) {
super(name, bytes);
}
public ZipShort getHeaderId() {
return UPATH_ID;
}
}
charactermanaj/src/org/apache/tools/zip/ZipUtil.java 0000644 0001750 0001750 00000002501 11767047544 022752 0 ustar paulliu paulliu /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*
*/
package org.apache.tools.zip;
/**
* Utility class for handling DOS and Java time conversions.
* @since Ant 1.8.1
*/
public abstract class ZipUtil {
/**
* Create a copy of the given array - or return null if the
* argument is null.
*/
static byte[] copy(byte[] from) {
if (from != null) {
byte[] to = new byte[from.length];
System.arraycopy(from, 0, to, 0, to.length);
return to;
}
return null;
}
}
charactermanaj/src/org/apache/tools/zip/ZipShort.java 0000644 0001750 0001750 00000010605 11767047544 023140 0 ustar paulliu paulliu /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*
*/
package org.apache.tools.zip;
/**
* Utility class that represents a two byte integer with conversion
* rules for the big endian byte order of ZIP files.
*
*/
public final class ZipShort implements Cloneable {
private static final int BYTE_MASK = 0xFF;
private static final int BYTE_1_MASK = 0xFF00;
private static final int BYTE_1_SHIFT = 8;
private int value;
/**
* Create instance from a number.
* @param value the int to store as a ZipShort
* @since 1.1
*/
public ZipShort (int value) {
this.value = value;
}
/**
* Create instance from bytes.
* @param bytes the bytes to store as a ZipShort
* @since 1.1
*/
public ZipShort (byte[] bytes) {
this(bytes, 0);
}
/**
* Create instance from the two bytes starting at offset.
* @param bytes the bytes to store as a ZipShort
* @param offset the offset to start
* @since 1.1
*/
public ZipShort (byte[] bytes, int offset) {
value = ZipShort.getValue(bytes, offset);
}
/**
* Get value as two bytes in big endian byte order.
* @return the value as a a two byte array in big endian byte order
* @since 1.1
*/
public byte[] getBytes() {
byte[] result = new byte[2];
result[0] = (byte) (value & BYTE_MASK);
result[1] = (byte) ((value & BYTE_1_MASK) >> BYTE_1_SHIFT);
return result;
}
/**
* Get value as Java int.
* @return value as a Java int
* @since 1.1
*/
public int getValue() {
return value;
}
/**
* Get value as two bytes in big endian byte order.
* @param value the Java int to convert to bytes
* @return the converted int as a byte array in big endian byte order
*/
public static byte[] getBytes(int value) {
byte[] result = new byte[2];
result[0] = (byte) (value & BYTE_MASK);
result[1] = (byte) ((value & BYTE_1_MASK) >> BYTE_1_SHIFT);
return result;
}
/**
* Helper method to get the value as a java int from two bytes starting at given array offset
* @param bytes the array of bytes
* @param offset the offset to start
* @return the correspondanding java int value
*/
public static int getValue(byte[] bytes, int offset) {
int value = (bytes[offset + 1] << BYTE_1_SHIFT) & BYTE_1_MASK;
value += (bytes[offset] & BYTE_MASK);
return value;
}
/**
* Helper method to get the value as a java int from a two-byte array
* @param bytes the array of bytes
* @return the correspondanding java int value
*/
public static int getValue(byte[] bytes) {
return getValue(bytes, 0);
}
/**
* Override to make two instances with same value equal.
* @param o an object to compare
* @return true if the objects are equal
* @since 1.1
*/
public boolean equals(Object o) {
if (o == null || !(o instanceof ZipShort)) {
return false;
}
return value == ((ZipShort) o).getValue();
}
/**
* Override to make two instances with same value equal.
* @return the value stored in the ZipShort
* @since 1.1
*/
public int hashCode() {
return value;
}
public Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException cnfe) {
// impossible
throw new RuntimeException(cnfe);
}
}
}
charactermanaj/src/org/apache/tools/zip/ZipLong.java 0000644 0001750 0001750 00000011702 11767047544 022737 0 ustar paulliu paulliu /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*
*/
package org.apache.tools.zip;
/**
* Utility class that represents a four byte integer with conversion
* rules for the big endian byte order of ZIP files.
*
*/
public final class ZipLong implements Cloneable {
private static final int WORD = 4;
// private static final int BYTE_BIT_SIZE = 8;
private static final int BYTE_MASK = 0xFF;
private static final int BYTE_1 = 1;
private static final int BYTE_1_MASK = 0xFF00;
private static final int BYTE_1_SHIFT = 8;
private static final int BYTE_2 = 2;
private static final int BYTE_2_MASK = 0xFF0000;
private static final int BYTE_2_SHIFT = 16;
private static final int BYTE_3 = 3;
private static final long BYTE_3_MASK = 0xFF000000L;
private static final int BYTE_3_SHIFT = 24;
private long value;
/**
* Create instance from a number.
* @param value the long to store as a ZipLong
* @since 1.1
*/
public ZipLong(long value) {
this.value = value;
}
/**
* Create instance from bytes.
* @param bytes the bytes to store as a ZipLong
* @since 1.1
*/
public ZipLong (byte[] bytes) {
this(bytes, 0);
}
/**
* Create instance from the four bytes starting at offset.
* @param bytes the bytes to store as a ZipLong
* @param offset the offset to start
* @since 1.1
*/
public ZipLong (byte[] bytes, int offset) {
value = ZipLong.getValue(bytes, offset);
}
/**
* Get value as four bytes in big endian byte order.
* @since 1.1
* @return value as four bytes in big endian order
*/
public byte[] getBytes() {
return ZipLong.getBytes(value);
}
/**
* Get value as Java long.
* @since 1.1
* @return value as a long
*/
public long getValue() {
return value;
}
/**
* Get value as four bytes in big endian byte order.
* @param value the value to convert
* @return value as four bytes in big endian byte order
*/
public static byte[] getBytes(long value) {
byte[] result = new byte[WORD];
result[0] = (byte) ((value & BYTE_MASK));
result[BYTE_1] = (byte) ((value & BYTE_1_MASK) >> BYTE_1_SHIFT);
result[BYTE_2] = (byte) ((value & BYTE_2_MASK) >> BYTE_2_SHIFT);
result[BYTE_3] = (byte) ((value & BYTE_3_MASK) >> BYTE_3_SHIFT);
return result;
}
/**
* Helper method to get the value as a Java long from four bytes starting at given array offset
* @param bytes the array of bytes
* @param offset the offset to start
* @return the correspondanding Java long value
*/
public static long getValue(byte[] bytes, int offset) {
long value = (bytes[offset + BYTE_3] << BYTE_3_SHIFT) & BYTE_3_MASK;
value += (bytes[offset + BYTE_2] << BYTE_2_SHIFT) & BYTE_2_MASK;
value += (bytes[offset + BYTE_1] << BYTE_1_SHIFT) & BYTE_1_MASK;
value += (bytes[offset] & BYTE_MASK);
return value;
}
/**
* Helper method to get the value as a Java long from a four-byte array
* @param bytes the array of bytes
* @return the correspondanding Java long value
*/
public static long getValue(byte[] bytes) {
return getValue(bytes, 0);
}
/**
* Override to make two instances with same value equal.
* @param o an object to compare
* @return true if the objects are equal
* @since 1.1
*/
public boolean equals(Object o) {
if (o == null || !(o instanceof ZipLong)) {
return false;
}
return value == ((ZipLong) o).getValue();
}
/**
* Override to make two instances with same value equal.
* @return the value stored in the ZipLong
* @since 1.1
*/
public int hashCode() {
return (int) value;
}
public Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException cnfe) {
// impossible
throw new RuntimeException(cnfe);
}
}
}
charactermanaj/src/org/apache/tools/zip/ZipFile.java 0000644 0001750 0001750 00000065004 11767047544 022723 0 ustar paulliu paulliu /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*
*/
package org.apache.tools.zip;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.zip.CRC32;
import java.util.zip.Inflater;
import java.util.zip.InflaterInputStream;
import java.util.zip.ZipException;
/**
* Replacement for java.util.ZipFile.
*
* This class adds support for file name encodings other than UTF-8
* (which is required to work on ZIP files created by native zip tools
* and is able to skip a preamble like the one found in self
* extracting archives. Furthermore it returns instances of
* org.apache.tools.zip.ZipEntry instead of
* java.util.zip.ZipEntry.
*
* It doesn't extend java.util.zip.ZipFile as it would
* have to reimplement all methods anyway. Like
* java.util.ZipFile, it uses RandomAccessFile under the
* covers and supports compressed and uncompressed entries.
*
* The method signatures mimic the ones of
* java.util.zip.ZipFile, with a couple of exceptions:
*
*
* - There is no getName method.
* - entries has been renamed to getEntries.
* - getEntries and getEntry return
*
org.apache.tools.zip.ZipEntry instances.
* - close is allowed to throw IOException.
*
*
*/
@SuppressWarnings({"unchecked", "rawtypes"})
public class ZipFile {
private static final Logger logger = Logger.getLogger(ZipFile.class.getName());
private static final int HASH_SIZE = 509;
private static final int SHORT = 2;
private static final int WORD = 4;
private static final int NIBLET_MASK = 0x0f;
private static final int BYTE_SHIFT = 8;
private static final int POS_0 = 0;
private static final int POS_1 = 1;
private static final int POS_2 = 2;
private static final int POS_3 = 3;
/**
* Maps ZipEntrys to Longs, recording the offsets of the local
* file headers.
*/
private final Map entries = new HashMap(HASH_SIZE);
/**
* Maps String to ZipEntrys, name -> actual entry.
*/
private final Map nameMap = new HashMap(HASH_SIZE);
private static final class OffsetEntry {
private long headerOffset = -1;
private long dataOffset = -1;
}
/**
* The encoding to use for filenames and the file comment.
*
* For a list of possible values see http://java.sun.com/j2se/1.5.0/docs/guide/intl/encoding.doc.html.
* Defaults to the platform's default character encoding.
*/
private String encoding = null;
/**
* The zip encoding to use for filenames and the file comment.
*/
private final ZipEncoding zipEncoding;
/**
* The actual data source.
*/
private RandomAccessFile archive;
/**
* Whether to look for and use Unicode extra fields.
*/
private final boolean useUnicodeExtraFields;
/**
* Opens the given file for reading, assuming the platform's
* native encoding for file names.
*
* @param f the archive.
*
* @throws IOException if an error occurs while reading the file.
*/
public ZipFile(File f) throws IOException {
this(f, null);
}
/**
* Opens the given file for reading, assuming the platform's
* native encoding for file names.
*
* @param name name of the archive.
*
* @throws IOException if an error occurs while reading the file.
*/
public ZipFile(String name) throws IOException {
this(new File(name), null);
}
/**
* Opens the given file for reading, assuming the specified
* encoding for file names, scanning unicode extra fields.
*
* @param name name of the archive.
* @param encoding the encoding to use for file names
*
* @throws IOException if an error occurs while reading the file.
*/
public ZipFile(String name, String encoding) throws IOException {
this(new File(name), encoding, true);
}
/**
* Opens the given file for reading, assuming the specified
* encoding for file names and scanning for unicode extra fields.
*
* @param f the archive.
* @param encoding the encoding to use for file names, use null
* for the platform's default encoding
*
* @throws IOException if an error occurs while reading the file.
*/
public ZipFile(File f, String encoding) throws IOException {
this(f, encoding, true);
}
/**
* Opens the given file for reading, assuming the specified
* encoding for file names.
*
* @param f the archive.
* @param encoding the encoding to use for file names, use null
* for the platform's default encoding
* @param useUnicodeExtraFields whether to use InfoZIP Unicode
* Extra Fields (if present) to set the file names.
*
* @throws IOException if an error occurs while reading the file.
*/
public ZipFile(File f, String encoding, boolean useUnicodeExtraFields)
throws IOException {
this.encoding = encoding;
this.zipEncoding = ZipEncodingHelper.getZipEncoding(encoding);
this.useUnicodeExtraFields = useUnicodeExtraFields;
archive = new RandomAccessFile(f, "r");
boolean success = false;
try {
Map entriesWithoutUTF8Flag = populateFromCentralDirectory();
resolveLocalFileHeaderData(entriesWithoutUTF8Flag);
success = true;
} finally {
if (!success) {
try {
archive.close();
} catch (IOException e2) {
// swallow, throw the original exception instead
}
}
}
}
/**
* The encoding to use for filenames and the file comment.
*
* @return null if using the platform's default character encoding.
*/
public String getEncoding() {
return encoding;
}
/**
* Closes the archive.
* @throws IOException if an error occurs closing the archive.
*/
public void close() throws IOException {
archive.close();
}
/**
* close a zipfile quietly; throw no io fault, do nothing
* on a null parameter
* @param zipfile file to close, can be null
*/
public static void closeQuietly(ZipFile zipfile) {
if (zipfile != null) {
try {
zipfile.close();
} catch (IOException e) {
//ignore
}
}
}
/**
* Returns all entries.
* @return all entries as {@link ZipEntry} instances
*/
public Enumeration getEntries() {
return Collections.enumeration(entries.keySet());
}
/**
* Returns a named entry - or null if no entry by
* that name exists.
* @param name name of the entry.
* @return the ZipEntry corresponding to the given name - or
* null if not present.
*/
public ZipEntry getEntry(String name) {
return (ZipEntry) nameMap.get(name);
}
/**
* Returns an InputStream for reading the contents of the given entry.
* @param ze the entry to get the stream for.
* @return a stream to read the entry from.
* @throws IOException if unable to create an input stream from the zipenty
* @throws ZipException if the zipentry has an unsupported
* compression method
*/
public InputStream getInputStream(ZipEntry ze)
throws IOException, ZipException {
OffsetEntry offsetEntry = (OffsetEntry) entries.get(ze);
if (offsetEntry == null) {
return null;
}
long start = offsetEntry.dataOffset;
BoundedInputStream bis =
new BoundedInputStream(start, ze.getCompressedSize());
switch (ze.getMethod()) {
case ZipEntry.STORED:
return bis;
case ZipEntry.DEFLATED:
bis.addDummy();
return new InflaterInputStream(bis, new Inflater(true));
default:
throw new ZipException("Found unsupported compression method "
+ ze.getMethod());
}
}
private static final int CFH_LEN =
/* version made by */ SHORT
/* version needed to extract */ + SHORT
/* general purpose bit flag */ + SHORT
/* compression method */ + SHORT
/* last mod file time */ + SHORT
/* last mod file date */ + SHORT
/* crc-32 */ + WORD
/* compressed size */ + WORD
/* uncompressed size */ + WORD
/* filename length */ + SHORT
/* extra field length */ + SHORT
/* file comment length */ + SHORT
/* disk number start */ + SHORT
/* internal file attributes */ + SHORT
/* external file attributes */ + WORD
/* relative offset of local header */ + WORD;
/**
* Reads the central directory of the given archive and populates
* the internal tables with ZipEntry instances.
*
* The ZipEntrys will know all data that can be obtained from
* the central directory alone, but not the data that requires the
* local file header or additional data to be read.
*
* @return a Map<ZipEntry, NameAndComment>> of
* zipentries that didn't have the language encoding flag set when
* read.
*/
private Map populateFromCentralDirectory()
throws IOException {
HashMap noUTF8Flag = new HashMap();
positionAtCentralDirectory();
byte[] cfh = new byte[CFH_LEN];
byte[] signatureBytes = new byte[WORD];
archive.readFully(signatureBytes);
long sig = ZipLong.getValue(signatureBytes);
final long cfhSig = ZipLong.getValue(ZipOutputStream.CFH_SIG);
if (sig != cfhSig && startsWithLocalFileHeader()) {
throw new IOException("central directory is empty, can't expand"
+ " corrupt archive.");
}
while (sig == cfhSig) {
archive.readFully(cfh);
int off = 0;
ZipEntry ze = new ZipEntry();
int versionMadeBy = ZipShort.getValue(cfh, off);
off += SHORT;
ze.setPlatform((versionMadeBy >> BYTE_SHIFT) & NIBLET_MASK);
off += SHORT; // skip version info
final int generalPurposeFlag = ZipShort.getValue(cfh, off);
final boolean hasUTF8Flag =
(generalPurposeFlag & ZipOutputStream.UFT8_NAMES_FLAG) != 0;
final ZipEncoding entryEncoding =
hasUTF8Flag ? ZipEncodingHelper.UTF8_ZIP_ENCODING : zipEncoding;
off += SHORT;
ze.setMethod(ZipShort.getValue(cfh, off));
off += SHORT;
// FIXME this is actually not very cpu cycles friendly as we are converting from
// dos to java while the underlying Sun implementation will convert
// from java to dos time for internal storage...
long time = dosToJavaTime(ZipLong.getValue(cfh, off));
ze.setTime(time);
off += WORD;
ze.setCrc(ZipLong.getValue(cfh, off));
off += WORD;
ze.setCompressedSize(ZipLong.getValue(cfh, off));
off += WORD;
ze.setSize(ZipLong.getValue(cfh, off));
off += WORD;
int fileNameLen = ZipShort.getValue(cfh, off);
off += SHORT;
int extraLen = ZipShort.getValue(cfh, off);
off += SHORT;
int commentLen = ZipShort.getValue(cfh, off);
off += SHORT;
off += SHORT; // disk number
ze.setInternalAttributes(ZipShort.getValue(cfh, off));
off += SHORT;
ze.setExternalAttributes(ZipLong.getValue(cfh, off));
off += WORD;
byte[] fileName = new byte[fileNameLen];
archive.readFully(fileName);
ze.setName(entryEncoding.decode(fileName));
// LFH offset,
OffsetEntry offset = new OffsetEntry();
offset.headerOffset = ZipLong.getValue(cfh, off);
// data offset will be filled later
entries.put(ze, offset);
nameMap.put(ze.getName(), ze);
byte[] cdExtraData = new byte[extraLen];
archive.readFully(cdExtraData);
ze.setCentralDirectoryExtra(cdExtraData);
byte[] comment = new byte[commentLen];
archive.readFully(comment);
ze.setComment(entryEncoding.decode(comment));
archive.readFully(signatureBytes);
sig = ZipLong.getValue(signatureBytes);
if (!hasUTF8Flag && useUnicodeExtraFields) {
noUTF8Flag.put(ze, new NameAndComment(fileName, comment));
}
}
return noUTF8Flag;
}
private static final int MIN_EOCD_SIZE =
/* end of central dir signature */ WORD
/* number of this disk */ + SHORT
/* number of the disk with the */
/* start of the central directory */ + SHORT
/* total number of entries in */
/* the central dir on this disk */ + SHORT
/* total number of entries in */
/* the central dir */ + SHORT
/* size of the central directory */ + WORD
/* offset of start of central */
/* directory with respect to */
/* the starting disk number */ + WORD
/* zipfile comment length */ + SHORT;
private static final int MAX_EOCD_SIZE = MIN_EOCD_SIZE
/* maximum length of zipfile comment */ + 0xFFFF;
private static final int CFD_LOCATOR_OFFSET =
/* end of central dir signature */ WORD
/* number of this disk */ + SHORT
/* number of the disk with the */
/* start of the central directory */ + SHORT
/* total number of entries in */
/* the central dir on this disk */ + SHORT
/* total number of entries in */
/* the central dir */ + SHORT
/* size of the central directory */ + WORD;
/**
* Searches for the "End of central dir record", parses
* it and positions the stream at the first central directory
* record.
*/
private void positionAtCentralDirectory()
throws IOException {
boolean found = false;
long off = archive.length() - MIN_EOCD_SIZE;
long stopSearching = Math.max(0L, archive.length() - MAX_EOCD_SIZE);
if (off >= 0) {
archive.seek(off);
byte[] sig = ZipOutputStream.EOCD_SIG;
int curr = archive.read();
while (off >= stopSearching && curr != -1) {
if (curr == sig[POS_0]) {
curr = archive.read();
if (curr == sig[POS_1]) {
curr = archive.read();
if (curr == sig[POS_2]) {
curr = archive.read();
if (curr == sig[POS_3]) {
found = true;
break;
}
}
}
}
archive.seek(--off);
curr = archive.read();
}
}
if (!found) {
throw new ZipException("archive is not a ZIP archive");
}
archive.seek(off + CFD_LOCATOR_OFFSET);
byte[] cfdOffset = new byte[WORD];
archive.readFully(cfdOffset);
archive.seek(ZipLong.getValue(cfdOffset));
}
/**
* Number of bytes in local file header up to the "length of
* filename" entry.
*/
private static final long LFH_OFFSET_FOR_FILENAME_LENGTH =
/* local file header signature */ WORD
/* version needed to extract */ + SHORT
/* general purpose bit flag */ + SHORT
/* compression method */ + SHORT
/* last mod file time */ + SHORT
/* last mod file date */ + SHORT
/* crc-32 */ + WORD
/* compressed size */ + WORD
/* uncompressed size */ + WORD;
/**
* Walks through all recorded entries and adds the data available
* from the local file header.
*
* Also records the offsets for the data to read from the
* entries.
*/
private void resolveLocalFileHeaderData(Map entriesWithoutUTF8Flag)
throws IOException {
Enumeration e = getEntries();
while (e.hasMoreElements()) {
ZipEntry ze = (ZipEntry) e.nextElement();
OffsetEntry offsetEntry = (OffsetEntry) entries.get(ze);
long offset = offsetEntry.headerOffset;
archive.seek(offset + LFH_OFFSET_FOR_FILENAME_LENGTH);
byte[] b = new byte[SHORT];
archive.readFully(b);
int fileNameLen = ZipShort.getValue(b);
archive.readFully(b);
int extraFieldLen = ZipShort.getValue(b);
int lenToSkip = fileNameLen;
while (lenToSkip > 0) {
int skipped = archive.skipBytes(lenToSkip);
if (skipped <= 0) {
throw new RuntimeException("failed to skip file name in"
+ " local file header");
}
lenToSkip -= skipped;
}
byte[] localExtraData = new byte[extraFieldLen];
archive.readFully(localExtraData);
ze.setExtra(localExtraData);
/*dataOffsets.put(ze,
new Long(offset + LFH_OFFSET_FOR_FILENAME_LENGTH
+ SHORT + SHORT + fileNameLen + extraFieldLen));
*/
offsetEntry.dataOffset = offset + LFH_OFFSET_FOR_FILENAME_LENGTH
+ SHORT + SHORT + fileNameLen + extraFieldLen;
if (entriesWithoutUTF8Flag.containsKey(ze)) {
setNameAndCommentFromExtraFields(ze,
(NameAndComment)
entriesWithoutUTF8Flag.get(ze));
}
}
}
/**
* Convert a DOS date/time field to a Date object.
*
* @param zipDosTime contains the stored DOS time.
* @return a Date instance corresponding to the given time.
*/
protected static Date fromDosTime(ZipLong zipDosTime) {
long dosTime = zipDosTime.getValue();
return new Date(dosToJavaTime(dosTime));
}
/*
* Converts DOS time to Java time (number of milliseconds since epoch).
*/
private static long dosToJavaTime(long dosTime) {
Calendar cal = Calendar.getInstance();
// CheckStyle:MagicNumberCheck OFF - no point
cal.set(Calendar.YEAR, (int) ((dosTime >> 25) & 0x7f) + 1980);
cal.set(Calendar.MONTH, (int) ((dosTime >> 21) & 0x0f) - 1);
cal.set(Calendar.DATE, (int) (dosTime >> 16) & 0x1f);
cal.set(Calendar.HOUR_OF_DAY, (int) (dosTime >> 11) & 0x1f);
cal.set(Calendar.MINUTE, (int) (dosTime >> 5) & 0x3f);
cal.set(Calendar.SECOND, (int) (dosTime << 1) & 0x3e);
// CheckStyle:MagicNumberCheck ON
return cal.getTime().getTime();
}
/**
* Retrieve a String from the given bytes using the encoding set
* for this ZipFile.
*
* @param bytes the byte array to transform
* @return String obtained by using the given encoding
* @throws ZipException if the encoding cannot be recognized.
*/
protected String getString(byte[] bytes) throws ZipException {
try {
return ZipEncodingHelper.getZipEncoding(encoding).decode(bytes);
} catch (IOException ex) {
throw new ZipException("Failed to decode name: " + ex.getMessage());
}
}
/**
* Checks whether the archive starts with a LFH. If it doesn't,
* it may be an empty archive.
*/
private boolean startsWithLocalFileHeader() throws IOException {
archive.seek(0);
final byte[] start = new byte[WORD];
archive.readFully(start);
for (int i = 0; i < start.length; i++) {
if (start[i] != ZipOutputStream.LFH_SIG[i]) {
return false;
}
}
return true;
}
/**
* If the entry has Unicode*ExtraFields and the CRCs of the
* names/comments match those of the extra fields, transfer the
* known Unicode values from the extra field.
*/
private void setNameAndCommentFromExtraFields(ZipEntry ze,
NameAndComment nc) {
UnicodePathExtraField name = (UnicodePathExtraField)
ze.getExtraField(UnicodePathExtraField.UPATH_ID);
String originalName = ze.getName();
String newName = getUnicodeStringIfOriginalMatches(name, nc.name);
if (newName != null && !originalName.equals(newName)) {
ze.setName(newName);
nameMap.remove(originalName);
nameMap.put(newName, ze);
}
if (nc.comment != null && nc.comment.length > 0) {
UnicodeCommentExtraField cmt = (UnicodeCommentExtraField)
ze.getExtraField(UnicodeCommentExtraField.UCOM_ID);
String newComment =
getUnicodeStringIfOriginalMatches(cmt, nc.comment);
if (newComment != null) {
ze.setComment(newComment);
}
}
}
/**
* If the stored CRC matches the one of the given name, return the
* Unicode name of the given field.
*
* If the field is null or the CRCs don't match, return null
* instead.
*/
private String getUnicodeStringIfOriginalMatches(AbstractUnicodeExtraField f,
byte[] orig) {
if (f != null) {
CRC32 crc32 = new CRC32();
crc32.update(orig);
long origCRC32 = crc32.getValue();
if (origCRC32 == f.getNameCRC32()) {
try {
return ZipEncodingHelper
.UTF8_ZIP_ENCODING.decode(f.getUnicodeName());
} catch (IOException ex) {
// UTF-8 unsupported? should be impossible the
// Unicode*ExtraField must contain some bad bytes
logger.log(Level.WARNING, "ZipFile: UTF-8 unsupported."
+ " should be impossible the Unicode*ExtraField must contain some bad bytes.", ex);
return null;
}
}
}
return null;
}
/**
* InputStream that delegates requests to the underlying
* RandomAccessFile, making sure that only bytes from a certain
* range can be read.
*/
private class BoundedInputStream extends InputStream {
private long remaining;
private long loc;
private boolean addDummyByte = false;
BoundedInputStream(long start, long remaining) {
this.remaining = remaining;
loc = start;
}
public int read() throws IOException {
if (remaining-- <= 0) {
if (addDummyByte) {
addDummyByte = false;
return 0;
}
return -1;
}
synchronized (archive) {
archive.seek(loc++);
return archive.read();
}
}
public int read(byte[] b, int off, int len) throws IOException {
if (remaining <= 0) {
if (addDummyByte) {
addDummyByte = false;
b[off] = 0;
return 1;
}
return -1;
}
if (len <= 0) {
return 0;
}
if (len > remaining) {
len = (int) remaining;
}
int ret = -1;
synchronized (archive) {
archive.seek(loc);
ret = archive.read(b, off, len);
}
if (ret > 0) {
loc += ret;
remaining -= ret;
}
return ret;
}
/**
* Inflater needs an extra dummy byte for nowrap - see
* Inflater's javadocs.
*/
void addDummy() {
addDummyByte = true;
}
}
private static final class NameAndComment {
private final byte[] name;
private final byte[] comment;
private NameAndComment(byte[] name, byte[] comment) {
this.name = name;
this.comment = comment;
}
}
}
charactermanaj/src/org/apache/tools/zip/ZipOutputStream.java 0000644 0001750 0001750 00000103272 11767047544 024520 0 ustar paulliu paulliu /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*
*/
package org.apache.tools.zip;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.zip.CRC32;
import java.util.zip.Deflater;
import java.util.zip.ZipException;
/**
* Reimplementation of {@link java.util.zip.ZipOutputStream
* java.util.zip.ZipOutputStream} that does handle the extended
* functionality of this package, especially internal/external file
* attributes and extra fields with different layouts for local file
* data and central directory entries.
*
* This class will try to use {@link java.io.RandomAccessFile
* RandomAccessFile} when you know that the output is going to go to a
* file.
*
* If RandomAccessFile cannot be used, this implementation will use
* a Data Descriptor to store size and CRC information for {@link
* #DEFLATED DEFLATED} entries, this means, you don't need to
* calculate them yourself. Unfortunately this is not possible for
* the {@link #STORED STORED} method, here setting the CRC and
* uncompressed size information is required before {@link
* #putNextEntry putNextEntry} can be called.
*
*/
@SuppressWarnings({"unchecked", "rawtypes"})
public class ZipOutputStream extends FilterOutputStream {
private static final int BYTE_MASK = 0xFF;
private static final int SHORT = 2;
private static final int WORD = 4;
private static final int BUFFER_SIZE = 512;
/*
* Apparently Deflater.setInput gets slowed down a lot on Sun JVMs
* when it gets handed a really big buffer. See
* https://issues.apache.org/bugzilla/show_bug.cgi?id=45396
*
* Using a buffer size of 8 kB proved to be a good compromise
*/
private static final int DEFLATER_BLOCK_SIZE = 8192;
/**
* Compression method for deflated entries.
*
* @since 1.1
*/
public static final int DEFLATED = java.util.zip.ZipEntry.DEFLATED;
/**
* Default compression level for deflated entries.
*
* @since Ant 1.7
*/
public static final int DEFAULT_COMPRESSION = Deflater.DEFAULT_COMPRESSION;
/**
* Compression method for stored entries.
*
* @since 1.1
*/
public static final int STORED = java.util.zip.ZipEntry.STORED;
/**
* default encoding for file names and comment.
*/
static final String DEFAULT_ENCODING = null;
/**
* General purpose flag, which indicates that filenames are
* written in utf-8.
*/
public static final int UFT8_NAMES_FLAG = 1 << 11;
/**
* General purpose flag, which indicates that filenames are
* written in utf-8.
* @deprecated use {@link #UFT8_NAMES_FLAG} instead
*/
public static final int EFS_FLAG = UFT8_NAMES_FLAG;
/**
* Current entry.
*
* @since 1.1
*/
private ZipEntry entry;
/**
* The file comment.
*
* @since 1.1
*/
private String comment = "";
/**
* Compression level for next entry.
*
* @since 1.1
*/
private int level = DEFAULT_COMPRESSION;
/**
* Has the compression level changed when compared to the last
* entry?
*
* @since 1.5
*/
private boolean hasCompressionLevelChanged = false;
/**
* Default compression method for next entry.
*
* @since 1.1
*/
private int method = java.util.zip.ZipEntry.DEFLATED;
/**
* List of ZipEntries written so far.
*
* @since 1.1
*/
private final List entries = new LinkedList();
/**
* CRC instance to avoid parsing DEFLATED data twice.
*
* @since 1.1
*/
private final CRC32 crc = new CRC32();
/**
* Count the bytes written to out.
*
* @since 1.1
*/
private long written = 0;
/**
* Data for local header data
*
* @since 1.1
*/
private long dataStart = 0;
/**
* Offset for CRC entry in the local file header data for the
* current entry starts here.
*
* @since 1.15
*/
private long localDataStart = 0;
/**
* Start of central directory.
*
* @since 1.1
*/
private long cdOffset = 0;
/**
* Length of central directory.
*
* @since 1.1
*/
private long cdLength = 0;
/**
* Helper, a 0 as ZipShort.
*
* @since 1.1
*/
private static final byte[] ZERO = {0, 0};
/**
* Helper, a 0 as ZipLong.
*
* @since 1.1
*/
private static final byte[] LZERO = {0, 0, 0, 0};
/**
* Holds the offsets of the LFH starts for each entry.
*
* @since 1.1
*/
private final Map offsets = new HashMap();
/**
* The encoding to use for filenames and the file comment.
*
* For a list of possible values see http://java.sun.com/j2se/1.5.0/docs/guide/intl/encoding.doc.html.
* Defaults to the platform's default character encoding.
*
* @since 1.3
*/
private String encoding = null;
/**
* The zip encoding to use for filenames and the file comment.
*
* This field is of internal use and will be set in {@link
* #setEncoding(String)}.
*/
private ZipEncoding zipEncoding =
ZipEncodingHelper.getZipEncoding(DEFAULT_ENCODING);
// CheckStyle:VisibilityModifier OFF - bc
/**
* This Deflater object is used for output.
*
* This attribute is only protected to provide a level of API
* backwards compatibility. This class used to extend {@link
* java.util.zip.DeflaterOutputStream DeflaterOutputStream} up to
* Revision 1.13.
*
* @since 1.14
*/
protected Deflater def = new Deflater(level, true);
/**
* This buffer servers as a Deflater.
*
* This attribute is only protected to provide a level of API
* backwards compatibility. This class used to extend {@link
* java.util.zip.DeflaterOutputStream DeflaterOutputStream} up to
* Revision 1.13.
*
* @since 1.14
*/
protected byte[] buf = new byte[BUFFER_SIZE];
// CheckStyle:VisibilityModifier ON
/**
* Optional random access output.
*
* @since 1.14
*/
private RandomAccessFile raf = null;
/**
* whether to use the general purpose bit flag when writing UTF-8
* filenames or not.
*/
private boolean useUTF8Flag = true;
/**
* Whether to encode non-encodable file names as UTF-8.
*/
private boolean fallbackToUTF8 = false;
/**
* whether to create UnicodePathExtraField-s for each entry.
*/
private UnicodeExtraFieldPolicy createUnicodeExtraFields =
UnicodeExtraFieldPolicy.NEVER;
/**
* Creates a new ZIP OutputStream filtering the underlying stream.
* @param out the outputstream to zip
* @since 1.1
*/
public ZipOutputStream(OutputStream out) {
super(out);
}
/**
* Creates a new ZIP OutputStream writing to a File. Will use
* random access if possible.
* @param file the file to zip to
* @since 1.14
* @throws IOException on error
*/
public ZipOutputStream(File file) throws IOException {
super(null);
try {
raf = new RandomAccessFile(file, "rw");
raf.setLength(0);
} catch (IOException e) {
if (raf != null) {
try {
raf.close();
} catch (IOException inner) {
// ignore
}
raf = null;
}
out = new FileOutputStream(file);
}
}
/**
* This method indicates whether this archive is writing to a
* seekable stream (i.e., to a random access file).
*
* For seekable streams, you don't need to calculate the CRC or
* uncompressed size for {@link #STORED} entries before
* invoking {@link #putNextEntry}.
* @return true if seekable
* @since 1.17
*/
public boolean isSeekable() {
return raf != null;
}
/**
* The encoding to use for filenames and the file comment.
*
*
For a list of possible values see http://java.sun.com/j2se/1.5.0/docs/guide/intl/encoding.doc.html.
* Defaults to the platform's default character encoding.
* @param encoding the encoding value
* @since 1.3
*/
public void setEncoding(final String encoding) {
this.encoding = encoding;
this.zipEncoding = ZipEncodingHelper.getZipEncoding(encoding);
useUTF8Flag &= ZipEncodingHelper.isUTF8(encoding);
}
/**
* The encoding to use for filenames and the file comment.
*
* @return null if using the platform's default character encoding.
*
* @since 1.3
*/
public String getEncoding() {
return encoding;
}
/**
* Whether to set the language encoding flag if the file name
* encoding is UTF-8.
*
* Defaults to true.
*/
public void setUseLanguageEncodingFlag(boolean b) {
useUTF8Flag = b && ZipEncodingHelper.isUTF8(encoding);
}
/**
* Whether to create Unicode Extra Fields.
*
* Defaults to NEVER.
*/
public void setCreateUnicodeExtraFields(UnicodeExtraFieldPolicy b) {
createUnicodeExtraFields = b;
}
/**
* Whether to fall back to UTF and the language encoding flag if
* the file name cannot be encoded using the specified encoding.
*
* Defaults to false.
*/
public void setFallbackToUTF8(boolean b) {
fallbackToUTF8 = b;
}
/**
* Finishs writing the contents and closes this as well as the
* underlying stream.
*
* @since 1.1
* @throws IOException on error
*/
public void finish() throws IOException {
closeEntry();
cdOffset = written;
for (Iterator i = entries.iterator(); i.hasNext(); ) {
writeCentralFileHeader((ZipEntry) i.next());
}
cdLength = written - cdOffset;
writeCentralDirectoryEnd();
offsets.clear();
entries.clear();
}
/**
* Writes all necessary data for this entry.
*
* @since 1.1
* @throws IOException on error
*/
public void closeEntry() throws IOException {
if (entry == null) {
return;
}
long realCrc = crc.getValue();
crc.reset();
if (entry.getMethod() == DEFLATED) {
def.finish();
while (!def.finished()) {
deflate();
}
entry.setSize(adjustToLong(def.getTotalIn()));
entry.setCompressedSize(adjustToLong(def.getTotalOut()));
entry.setCrc(realCrc);
def.reset();
written += entry.getCompressedSize();
} else if (raf == null) {
if (entry.getCrc() != realCrc) {
throw new ZipException("bad CRC checksum for entry "
+ entry.getName() + ": "
+ Long.toHexString(entry.getCrc())
+ " instead of "
+ Long.toHexString(realCrc));
}
if (entry.getSize() != written - dataStart) {
throw new ZipException("bad size for entry "
+ entry.getName() + ": "
+ entry.getSize()
+ " instead of "
+ (written - dataStart));
}
} else { /* method is STORED and we used RandomAccessFile */
long size = written - dataStart;
entry.setSize(size);
entry.setCompressedSize(size);
entry.setCrc(realCrc);
}
// If random access output, write the local file header containing
// the correct CRC and compressed/uncompressed sizes
if (raf != null) {
long save = raf.getFilePointer();
raf.seek(localDataStart);
writeOut(ZipLong.getBytes(entry.getCrc()));
writeOut(ZipLong.getBytes(entry.getCompressedSize()));
writeOut(ZipLong.getBytes(entry.getSize()));
raf.seek(save);
}
writeDataDescriptor(entry);
entry = null;
}
/**
* Begin writing next entry.
* @param ze the entry to write
* @since 1.1
* @throws IOException on error
*/
public void putNextEntry(ZipEntry ze) throws IOException {
closeEntry();
entry = ze;
entries.add(entry);
if (entry.getMethod() == -1) { // not specified
entry.setMethod(method);
}
if (entry.getTime() == -1) { // not specified
entry.setTime(System.currentTimeMillis());
}
// Size/CRC not required if RandomAccessFile is used
if (entry.getMethod() == STORED && raf == null) {
if (entry.getSize() == -1) {
throw new ZipException("uncompressed size is required for"
+ " STORED method when not writing to a"
+ " file");
}
if (entry.getCrc() == -1) {
throw new ZipException("crc checksum is required for STORED"
+ " method when not writing to a file");
}
entry.setCompressedSize(entry.getSize());
}
if (entry.getMethod() == DEFLATED && hasCompressionLevelChanged) {
def.setLevel(level);
hasCompressionLevelChanged = false;
}
writeLocalFileHeader(entry);
}
/**
* Set the file comment.
* @param comment the comment
* @since 1.1
*/
public void setComment(String comment) {
this.comment = comment;
}
/**
* Sets the compression level for subsequent entries.
*
* Default is Deflater.DEFAULT_COMPRESSION.
* @param level the compression level.
* @throws IllegalArgumentException if an invalid compression
* level is specified.
* @since 1.1
*/
public void setLevel(int level) {
if (level < Deflater.DEFAULT_COMPRESSION
|| level > Deflater.BEST_COMPRESSION) {
throw new IllegalArgumentException("Invalid compression level: "
+ level);
}
hasCompressionLevelChanged = (this.level != level);
this.level = level;
}
/**
* Sets the default compression method for subsequent entries.
*
* Default is DEFLATED.
* @param method an int from java.util.zip.ZipEntry
* @since 1.1
*/
public void setMethod(int method) {
this.method = method;
}
/**
* Writes bytes to ZIP entry.
* @param b the byte array to write
* @param offset the start position to write from
* @param length the number of bytes to write
* @throws IOException on error
*/
public void write(byte[] b, int offset, int length) throws IOException {
if (entry.getMethod() == DEFLATED) {
if (length > 0) {
if (!def.finished()) {
if (length <= DEFLATER_BLOCK_SIZE) {
def.setInput(b, offset, length);
deflateUntilInputIsNeeded();
} else {
final int fullblocks = length / DEFLATER_BLOCK_SIZE;
for (int i = 0; i < fullblocks; i++) {
def.setInput(b, offset + i * DEFLATER_BLOCK_SIZE,
DEFLATER_BLOCK_SIZE);
deflateUntilInputIsNeeded();
}
final int done = fullblocks * DEFLATER_BLOCK_SIZE;
if (done < length) {
def.setInput(b, offset + done, length - done);
deflateUntilInputIsNeeded();
}
}
}
}
} else {
writeOut(b, offset, length);
written += length;
}
crc.update(b, offset, length);
}
/**
* Writes a single byte to ZIP entry.
*
* Delegates to the three arg method.
* @param b the byte to write
* @since 1.14
* @throws IOException on error
*/
public void write(int b) throws IOException {
byte[] buff = new byte[1];
buff[0] = (byte) (b & BYTE_MASK);
write(buff, 0, 1);
}
/**
* Closes this output stream and releases any system resources
* associated with the stream.
*
* @exception IOException if an I/O error occurs.
* @since 1.14
*/
public void close() throws IOException {
finish();
if (raf != null) {
raf.close();
}
if (out != null) {
out.close();
}
}
/**
* Flushes this output stream and forces any buffered output bytes
* to be written out to the stream.
*
* @exception IOException if an I/O error occurs.
* @since 1.14
*/
public void flush() throws IOException {
if (out != null) {
out.flush();
}
}
/*
* Various ZIP constants
*/
/**
* local file header signature
*
* @since 1.1
*/
protected static final byte[] LFH_SIG = ZipLong.getBytes(0X04034B50L);
/**
* data descriptor signature
*
* @since 1.1
*/
protected static final byte[] DD_SIG = ZipLong.getBytes(0X08074B50L);
/**
* central file header signature
*
* @since 1.1
*/
protected static final byte[] CFH_SIG = ZipLong.getBytes(0X02014B50L);
/**
* end of central dir signature
*
* @since 1.1
*/
protected static final byte[] EOCD_SIG = ZipLong.getBytes(0X06054B50L);
/**
* Writes next block of compressed data to the output stream.
* @throws IOException on error
*
* @since 1.14
*/
protected final void deflate() throws IOException {
int len = def.deflate(buf, 0, buf.length);
if (len > 0) {
writeOut(buf, 0, len);
}
}
/**
* Writes the local file header entry
* @param ze the entry to write
* @throws IOException on error
*
* @since 1.1
*/
protected void writeLocalFileHeader(ZipEntry ze) throws IOException {
boolean encodable = zipEncoding.canEncode(ze.getName());
final ZipEncoding entryEncoding;
if (!encodable && fallbackToUTF8) {
entryEncoding = ZipEncodingHelper.UTF8_ZIP_ENCODING;
} else {
entryEncoding = zipEncoding;
}
ByteBuffer name = entryEncoding.encode(ze.getName());
if (createUnicodeExtraFields != UnicodeExtraFieldPolicy.NEVER) {
if (createUnicodeExtraFields == UnicodeExtraFieldPolicy.ALWAYS
|| !encodable) {
ze.addExtraField(new UnicodePathExtraField(ze.getName(),
name.array(),
name.arrayOffset(),
name.limit()));
}
String comm = ze.getComment();
if (comm != null && !"".equals(comm)) {
boolean commentEncodable = this.zipEncoding.canEncode(comm);
if (createUnicodeExtraFields == UnicodeExtraFieldPolicy.ALWAYS
|| !commentEncodable) {
ByteBuffer commentB = entryEncoding.encode(comm);
ze.addExtraField(new UnicodeCommentExtraField(comm,
commentB.array(),
commentB.arrayOffset(),
commentB.limit())
);
}
}
}
offsets.put(ze, ZipLong.getBytes(written));
writeOut(LFH_SIG);
written += WORD;
//store method in local variable to prevent multiple method calls
final int zipMethod = ze.getMethod();
writeVersionNeededToExtractAndGeneralPurposeBits(zipMethod,
!encodable
&& fallbackToUTF8);
written += WORD;
// compression method
writeOut(ZipShort.getBytes(zipMethod));
written += SHORT;
// last mod. time and date
writeOut(toDosTime(ze.getTime()));
written += WORD;
// CRC
// compressed length
// uncompressed length
localDataStart = written;
if (zipMethod == DEFLATED || raf != null) {
writeOut(LZERO);
writeOut(LZERO);
writeOut(LZERO);
} else {
writeOut(ZipLong.getBytes(ze.getCrc()));
writeOut(ZipLong.getBytes(ze.getSize()));
writeOut(ZipLong.getBytes(ze.getSize()));
}
// CheckStyle:MagicNumber OFF
written += 12;
// CheckStyle:MagicNumber ON
// file name length
writeOut(ZipShort.getBytes(name.limit()));
written += SHORT;
// extra field length
byte[] extra = ze.getLocalFileDataExtra();
writeOut(ZipShort.getBytes(extra.length));
written += SHORT;
// file name
writeOut(name.array(), name.arrayOffset(), name.limit());
written += name.limit();
// extra field
writeOut(extra);
written += extra.length;
dataStart = written;
}
/**
* Writes the data descriptor entry.
* @param ze the entry to write
* @throws IOException on error
*
* @since 1.1
*/
protected void writeDataDescriptor(ZipEntry ze) throws IOException {
if (ze.getMethod() != DEFLATED || raf != null) {
return;
}
writeOut(DD_SIG);
writeOut(ZipLong.getBytes(entry.getCrc()));
writeOut(ZipLong.getBytes(entry.getCompressedSize()));
writeOut(ZipLong.getBytes(entry.getSize()));
// CheckStyle:MagicNumber OFF
written += 16;
// CheckStyle:MagicNumber ON
}
/**
* Writes the central file header entry.
* @param ze the entry to write
* @throws IOException on error
*
* @since 1.1
*/
protected void writeCentralFileHeader(ZipEntry ze) throws IOException {
writeOut(CFH_SIG);
written += WORD;
// version made by
// CheckStyle:MagicNumber OFF
writeOut(ZipShort.getBytes((ze.getPlatform() << 8) | 20));
written += SHORT;
final int zipMethod = ze.getMethod();
final boolean encodable = zipEncoding.canEncode(ze.getName());
writeVersionNeededToExtractAndGeneralPurposeBits(zipMethod,
!encodable
&& fallbackToUTF8);
written += WORD;
// compression method
writeOut(ZipShort.getBytes(zipMethod));
written += SHORT;
// last mod. time and date
writeOut(toDosTime(ze.getTime()));
written += WORD;
// CRC
// compressed length
// uncompressed length
writeOut(ZipLong.getBytes(ze.getCrc()));
writeOut(ZipLong.getBytes(ze.getCompressedSize()));
writeOut(ZipLong.getBytes(ze.getSize()));
// CheckStyle:MagicNumber OFF
written += 12;
// CheckStyle:MagicNumber ON
// file name length
final ZipEncoding entryEncoding;
if (!encodable && fallbackToUTF8) {
entryEncoding = ZipEncodingHelper.UTF8_ZIP_ENCODING;
} else {
entryEncoding = zipEncoding;
}
ByteBuffer name = entryEncoding.encode(ze.getName());
writeOut(ZipShort.getBytes(name.limit()));
written += SHORT;
// extra field length
byte[] extra = ze.getCentralDirectoryExtra();
writeOut(ZipShort.getBytes(extra.length));
written += SHORT;
// file comment length
String comm = ze.getComment();
if (comm == null) {
comm = "";
}
ByteBuffer commentB = entryEncoding.encode(comm);
writeOut(ZipShort.getBytes(commentB.limit()));
written += SHORT;
// disk number start
writeOut(ZERO);
written += SHORT;
// internal file attributes
writeOut(ZipShort.getBytes(ze.getInternalAttributes()));
written += SHORT;
// external file attributes
writeOut(ZipLong.getBytes(ze.getExternalAttributes()));
written += WORD;
// relative offset of LFH
writeOut((byte[]) offsets.get(ze));
written += WORD;
// file name
writeOut(name.array(), name.arrayOffset(), name.limit());
written += name.limit();
// extra field
writeOut(extra);
written += extra.length;
// file comment
writeOut(commentB.array(), commentB.arrayOffset(), commentB.limit());
written += commentB.limit();
}
/**
* Writes the "End of central dir record".
* @throws IOException on error
*
* @since 1.1
*/
protected void writeCentralDirectoryEnd() throws IOException {
writeOut(EOCD_SIG);
// disk numbers
writeOut(ZERO);
writeOut(ZERO);
// number of entries
byte[] num = ZipShort.getBytes(entries.size());
writeOut(num);
writeOut(num);
// length and location of CD
writeOut(ZipLong.getBytes(cdLength));
writeOut(ZipLong.getBytes(cdOffset));
// ZIP file comment
ByteBuffer data = this.zipEncoding.encode(comment);
writeOut(ZipShort.getBytes(data.limit()));
writeOut(data.array(), data.arrayOffset(), data.limit());
}
/**
* Smallest date/time ZIP can handle.
*
* @since 1.1
*/
private static final byte[] DOS_TIME_MIN = ZipLong.getBytes(0x00002100L);
/**
* Convert a Date object to a DOS date/time field.
* @param time the Date to convert
* @return the date as a ZipLong
* @since 1.1
*/
protected static ZipLong toDosTime(Date time) {
return new ZipLong(toDosTime(time.getTime()));
}
/**
* Convert a Date object to a DOS date/time field.
*
* Stolen from InfoZip's fileio.c
* @param t number of milliseconds since the epoch
* @return the date as a byte array
* @since 1.26
*/
@SuppressWarnings("deprecation")
protected static byte[] toDosTime(long t) {
Date time = new Date(t);
// CheckStyle:MagicNumberCheck OFF - I do not think that using constants
// here will improve the readablity
int year = time.getYear() + 1900;
if (year < 1980) {
return DOS_TIME_MIN;
}
int month = time.getMonth() + 1;
long value = ((year - 1980) << 25)
| (month << 21)
| (time.getDate() << 16)
| (time.getHours() << 11)
| (time.getMinutes() << 5)
| (time.getSeconds() >> 1);
return ZipLong.getBytes(value);
// CheckStyle:MagicNumberCheck ON
}
/**
* Retrieve the bytes for the given String in the encoding set for
* this Stream.
* @param name the string to get bytes from
* @return the bytes as a byte array
* @throws ZipException on error
*
* @since 1.3
*/
protected byte[] getBytes(String name) throws ZipException {
try {
ByteBuffer b =
ZipEncodingHelper.getZipEncoding(encoding).encode(name);
byte[] result = new byte[b.limit()];
System.arraycopy(b.array(), b.arrayOffset(), result, 0,
result.length);
return result;
} catch (IOException ex) {
throw new ZipException("Failed to encode name: " + ex.getMessage());
}
}
/**
* Write bytes to output or random access file.
* @param data the byte array to write
* @throws IOException on error
*
* @since 1.14
*/
protected final void writeOut(byte[] data) throws IOException {
writeOut(data, 0, data.length);
}
/**
* Write bytes to output or random access file.
* @param data the byte array to write
* @param offset the start position to write from
* @param length the number of bytes to write
* @throws IOException on error
*
* @since 1.14
*/
protected final void writeOut(byte[] data, int offset, int length)
throws IOException {
if (raf != null) {
raf.write(data, offset, length);
} else {
out.write(data, offset, length);
}
}
/**
* Assumes a negative integer really is a positive integer that
* has wrapped around and re-creates the original value.
* @param i the value to treat as unsigned int.
* @return the unsigned int as a long.
* @since 1.34
*/
protected static long adjustToLong(int i) {
if (i < 0) {
return 2 * ((long) Integer.MAX_VALUE) + 2 + i;
} else {
return i;
}
}
private void deflateUntilInputIsNeeded() throws IOException {
while (!def.needsInput()) {
deflate();
}
}
private void writeVersionNeededToExtractAndGeneralPurposeBits(final int
zipMethod,
final boolean
utfFallback)
throws IOException {
// CheckStyle:MagicNumber OFF
int versionNeededToExtract = 10;
int generalPurposeFlag = (useUTF8Flag || utfFallback) ? UFT8_NAMES_FLAG : 0;
if (zipMethod == DEFLATED && raf == null) {
// requires version 2 as we are going to store length info
// in the data descriptor
versionNeededToExtract = 20;
// bit3 set to signal, we use a data descriptor
generalPurposeFlag |= 8;
}
// CheckStyle:MagicNumber ON
// version needed to extract
writeOut(ZipShort.getBytes(versionNeededToExtract));
// general purpose bit flag
writeOut(ZipShort.getBytes(generalPurposeFlag));
}
/**
* enum that represents the possible policies for creating Unicode
* extra fields.
*/
public static final class UnicodeExtraFieldPolicy {
/**
* Always create Unicode extra fields.
*/
public static final UnicodeExtraFieldPolicy ALWAYS =
new UnicodeExtraFieldPolicy("always");
/**
* Never create Unicode extra fields.
*/
public static final UnicodeExtraFieldPolicy NEVER =
new UnicodeExtraFieldPolicy("never");
/**
* Create Unicode extra fields for filenames that cannot be
* encoded using the specified encoding.
*/
public static final UnicodeExtraFieldPolicy NOT_ENCODEABLE =
new UnicodeExtraFieldPolicy("not encodeable");
private final String name;
private UnicodeExtraFieldPolicy(String n) {
name = n;
}
public String toString() {
return name;
}
}
}
charactermanaj/src/org/apache/tools/zip/FallbackZipEncoding.java 0000644 0001750 0001750 00000005702 11767047544 025211 0 ustar paulliu paulliu /*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
package org.apache.tools.zip;
import java.io.IOException;
import java.nio.ByteBuffer;
/**
* A fallback ZipEncoding, which uses a java.io means to encode names.
*
* This implementation is not favorable for encodings other than
* utf-8, because java.io encodes unmappable character as question
* marks leading to unreadable ZIP entries on some operating
* systems.
*
* Furthermore this implementation is unable to tell, whether a
* given name can be safely encoded or not.
*
* This implementation acts as a last resort implementation, when
* neither {@link Simple8BitZipEnoding} nor {@link NioZipEncoding} is
* available.
*
* The methods of this class are reentrant.
*/
class FallbackZipEncoding implements ZipEncoding {
private final String charset;
/**
* Construct a fallback zip encoding, which uses the platform's
* default charset.
*/
public FallbackZipEncoding() {
this.charset = null;
}
/**
* Construct a fallback zip encoding, which uses the given charset.
*
* @param charset The name of the charset or null for
* the platform's default character set.
*/
public FallbackZipEncoding(String charset) {
this.charset = charset;
}
/**
* @see
* org.apache.tools.zip.ZipEncoding#canEncode(java.lang.String)
*/
public boolean canEncode(String name) {
return true;
}
/**
* @see
* org.apache.tools.zip.ZipEncoding#encode(java.lang.String)
*/
public ByteBuffer encode(String name) throws IOException {
if (this.charset == null) {
return ByteBuffer.wrap(name.getBytes());
} else {
return ByteBuffer.wrap(name.getBytes(this.charset));
}
}
/**
* @see
* org.apache.tools.zip.ZipEncoding#decode(byte[])
*/
public String decode(byte[] data) throws IOException {
if (this.charset == null) {
return new String(data);
} else {
return new String(data,this.charset);
}
}
}
charactermanaj/src/org/apache/tools/zip/ZipEncoding.java 0000644 0001750 0001750 00000006332 11767047544 023571 0 ustar paulliu paulliu /*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
package org.apache.tools.zip;
import java.io.IOException;
import java.nio.ByteBuffer;
/**
* An interface for encoders that do a pretty encoding of ZIP
* filenames.
*
* There are mostly two implementations, one that uses java.nio
* {@link java.nio.charset.Charset Charset} and one implementation,
* which copes with simple 8 bit charsets, because java-1.4 did not
* support Cp437 in java.nio.
*
* The main reason for defining an own encoding layer comes from
* the problems with {@link java.lang.String#getBytes(String)
* String.getBytes}, which encodes unknown characters as ASCII
* quotation marks ('?'). Quotation marks are per definition an
* invalid filename on some operating systems like Windows, which
* leads to ignored ZIP entries.
*
* All implementations should implement this interface in a
* reentrant way.
*/
interface ZipEncoding {
/**
* Check, whether the given string may be losslessly encoded using this
* encoding.
*
* @param name A filename or ZIP comment.
* @return Whether the given name may be encoded with out any losses.
*/
boolean canEncode(String name);
/**
* Encode a filename or a comment to a byte array suitable for
* storing it to a serialized zip entry.
*
* Examples for CP 437 (in pseudo-notation, right hand side is
* C-style notation):
*
* encode("\u20AC_for_Dollar.txt") = "%U20AC_for_Dollar.txt"
* encode("\u00D6lf\u00E4sser.txt") = "\231lf\204sser.txt"
*
*
* @param name A filename or ZIP comment.
* @return A byte buffer with a backing array containing the
* encoded name. Unmappable characters or malformed
* character sequences are mapped to a sequence of utf-16
* words encoded in the format %Uxxxx. It is
* assumed, that the byte buffer is positioned at the
* beinning of the encoded result, the byte buffer has a
* backing array and the limit of the byte buffer points
* to the end of the encoded result.
* @throws IOException
*/
ByteBuffer encode(String name) throws IOException;
/**
* @param data The byte values to decode.
* @return The decoded string.
* @throws IOException
*/
String decode(byte [] data) throws IOException;
}
charactermanaj/src/org/apache/tools/zip/ExtraFieldUtils.java 0000644 0001750 0001750 00000030073 11767047544 024427 0 ustar paulliu paulliu /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*
*/
package org.apache.tools.zip;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.zip.ZipException;
/**
* ZipExtraField related methods
*
*/
// CheckStyle:HideUtilityClassConstructorCheck OFF (bc)
@SuppressWarnings({"unchecked", "rawtypes"})
public class ExtraFieldUtils {
private static final int WORD = 4;
/**
* Static registry of known extra fields.
*
* @since 1.1
*/
private static final Map implementations;
static {
implementations = new HashMap();
register(AsiExtraField.class);
register(JarMarker.class);
register(UnicodePathExtraField.class);
register(UnicodeCommentExtraField.class);
}
/**
* Register a ZipExtraField implementation.
*
* The given class must have a no-arg constructor and implement
* the {@link ZipExtraField ZipExtraField interface}.
* @param c the class to register
*
* @since 1.1
*/
public static void register(Class c) {
try {
ZipExtraField ze = (ZipExtraField) c.newInstance();
implementations.put(ze.getHeaderId(), c);
} catch (ClassCastException cc) {
throw new RuntimeException(c + " doesn\'t implement ZipExtraField");
} catch (InstantiationException ie) {
throw new RuntimeException(c + " is not a concrete class");
} catch (IllegalAccessException ie) {
throw new RuntimeException(c + "\'s no-arg constructor is not public");
}
}
/**
* Create an instance of the approriate ExtraField, falls back to
* {@link UnrecognizedExtraField UnrecognizedExtraField}.
* @param headerId the header identifier
* @return an instance of the appropiate ExtraField
* @exception InstantiationException if unable to instantiate the class
* @exception IllegalAccessException if not allowed to instatiate the class
* @since 1.1
*/
public static ZipExtraField createExtraField(ZipShort headerId)
throws InstantiationException, IllegalAccessException {
Class c = (Class) implementations.get(headerId);
if (c != null) {
return (ZipExtraField) c.newInstance();
}
UnrecognizedExtraField u = new UnrecognizedExtraField();
u.setHeaderId(headerId);
return u;
}
/**
* Split the array into ExtraFields and populate them with the
* given data as local file data, throwing an exception if the
* data cannot be parsed.
* @param data an array of bytes as it appears in local file data
* @return an array of ExtraFields
* @throws ZipException on error
*/
public static ZipExtraField[] parse(byte[] data) throws ZipException {
return parse(data, true, UnparseableExtraField.THROW);
}
/**
* Split the array into ExtraFields and populate them with the
* given data, throwing an exception if the data cannot be parsed.
* @param data an array of bytes
* @param local whether data originates from the local file data
* or the central directory
* @return an array of ExtraFields
* @since 1.1
* @throws ZipException on error
*/
public static ZipExtraField[] parse(byte[] data, boolean local)
throws ZipException {
return parse(data, local, UnparseableExtraField.THROW);
}
/**
* Split the array into ExtraFields and populate them with the
* given data.
* @param data an array of bytes
* @param local whether data originates from the local file data
* or the central directory
* @param onUnparseableData what to do if the extra field data
* cannot be parsed.
* @return an array of ExtraFields
* @throws ZipException on error
* @since Ant 1.8.1
*/
public static ZipExtraField[] parse(byte[] data, boolean local,
UnparseableExtraField onUnparseableData)
throws ZipException {
List v = new ArrayList();
int start = 0;
LOOP:
while (start <= data.length - WORD) {
ZipShort headerId = new ZipShort(data, start);
int length = (new ZipShort(data, start + 2)).getValue();
if (start + WORD + length > data.length) {
switch(onUnparseableData.getKey()) {
case UnparseableExtraField.THROW_KEY:
throw new ZipException("bad extra field starting at "
+ start + ". Block length of "
+ length + " bytes exceeds remaining"
+ " data of "
+ (data.length - start - WORD)
+ " bytes.");
case UnparseableExtraField.READ_KEY:
UnparseableExtraFieldData field =
new UnparseableExtraFieldData();
if (local) {
field.parseFromLocalFileData(data, start,
data.length - start);
} else {
field.parseFromCentralDirectoryData(data, start,
data.length - start);
}
v.add(field);
/*FALLTHROUGH*/
case UnparseableExtraField.SKIP_KEY:
// since we cannot parse the data we must assume
// the extra field consumes the whole rest of the
// available data
break LOOP;
default:
throw new ZipException("unknown UnparseableExtraField key: "
+ onUnparseableData.getKey());
}
}
try {
ZipExtraField ze = createExtraField(headerId);
if (local
|| !(ze instanceof CentralDirectoryParsingZipExtraField)) {
ze.parseFromLocalFileData(data, start + WORD, length);
} else {
((CentralDirectoryParsingZipExtraField) ze)
.parseFromCentralDirectoryData(data, start + WORD,
length);
}
v.add(ze);
} catch (InstantiationException ie) {
throw new ZipException(ie.getMessage());
} catch (IllegalAccessException iae) {
throw new ZipException(iae.getMessage());
}
start += (length + WORD);
}
ZipExtraField[] result = new ZipExtraField[v.size()];
return (ZipExtraField[]) v.toArray(result);
}
/**
* Merges the local file data fields of the given ZipExtraFields.
* @param data an array of ExtraFiles
* @return an array of bytes
* @since 1.1
*/
public static byte[] mergeLocalFileDataData(ZipExtraField[] data) {
final boolean lastIsUnparseableHolder = data.length > 0
&& data[data.length - 1] instanceof UnparseableExtraFieldData;
int regularExtraFieldCount =
lastIsUnparseableHolder ? data.length - 1 : data.length;
int sum = WORD * regularExtraFieldCount;
for (int i = 0; i < data.length; i++) {
sum += data[i].getLocalFileDataLength().getValue();
}
byte[] result = new byte[sum];
int start = 0;
for (int i = 0; i < regularExtraFieldCount; i++) {
System.arraycopy(data[i].getHeaderId().getBytes(),
0, result, start, 2);
System.arraycopy(data[i].getLocalFileDataLength().getBytes(),
0, result, start + 2, 2);
byte[] local = data[i].getLocalFileDataData();
System.arraycopy(local, 0, result, start + WORD, local.length);
start += (local.length + WORD);
}
if (lastIsUnparseableHolder) {
byte[] local = data[data.length - 1].getLocalFileDataData();
System.arraycopy(local, 0, result, start, local.length);
}
return result;
}
/**
* Merges the central directory fields of the given ZipExtraFields.
* @param data an array of ExtraFields
* @return an array of bytes
* @since 1.1
*/
public static byte[] mergeCentralDirectoryData(ZipExtraField[] data) {
final boolean lastIsUnparseableHolder = data.length > 0
&& data[data.length - 1] instanceof UnparseableExtraFieldData;
int regularExtraFieldCount =
lastIsUnparseableHolder ? data.length - 1 : data.length;
int sum = WORD * regularExtraFieldCount;
for (int i = 0; i < data.length; i++) {
sum += data[i].getCentralDirectoryLength().getValue();
}
byte[] result = new byte[sum];
int start = 0;
for (int i = 0; i < regularExtraFieldCount; i++) {
System.arraycopy(data[i].getHeaderId().getBytes(),
0, result, start, 2);
System.arraycopy(data[i].getCentralDirectoryLength().getBytes(),
0, result, start + 2, 2);
byte[] local = data[i].getCentralDirectoryData();
System.arraycopy(local, 0, result, start + WORD, local.length);
start += (local.length + WORD);
}
if (lastIsUnparseableHolder) {
byte[] local = data[data.length - 1].getCentralDirectoryData();
System.arraycopy(local, 0, result, start, local.length);
}
return result;
}
/**
* "enum" for the possible actions to take if the extra field
* cannot be parsed.
*/
public static final class UnparseableExtraField {
/**
* Key for "throw an exception" action.
*/
public static final int THROW_KEY = 0;
/**
* Key for "skip" action.
*/
public static final int SKIP_KEY = 1;
/**
* Key for "read" action.
*/
public static final int READ_KEY = 2;
/**
* Throw an exception if field cannot be parsed.
*/
public static final UnparseableExtraField THROW
= new UnparseableExtraField(THROW_KEY);
/**
* Skip the extra field entirely and don't make its data
* available - effectively removing the extra field data.
*/
public static final UnparseableExtraField SKIP
= new UnparseableExtraField(SKIP_KEY);
/**
* Read the extra field data into an instance of {@link
* UnparseableExtraFieldData UnparseableExtraFieldData}.
*/
public static final UnparseableExtraField READ
= new UnparseableExtraField(READ_KEY);
private final int key;
private UnparseableExtraField(int k) {
key = k;
}
/**
* Key of the action to take.
*/
public int getKey() { return key; }
}
}
charactermanaj/src/org/apache/tools/zip/UnixStat.java 0000644 0001750 0001750 00000004105 11767047544 023133 0 ustar paulliu paulliu /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*
*/
package org.apache.tools.zip;
/**
* Constants from stat.h on Unix systems.
*
*/
// CheckStyle:InterfaceIsTypeCheck OFF - backward compatible
public interface UnixStat {
/**
* Bits used for permissions (and sticky bit)
*
* @since 1.1
*/
int PERM_MASK = 07777;
/**
* Indicates symbolic links.
*
* @since 1.1
*/
int LINK_FLAG = 0120000;
/**
* Indicates plain files.
*
* @since 1.1
*/
int FILE_FLAG = 0100000;
/**
* Indicates directories.
*
* @since 1.1
*/
int DIR_FLAG = 040000;
// ----------------------------------------------------------
// somewhat arbitrary choices that are quite common for shared
// installations
// -----------------------------------------------------------
/**
* Default permissions for symbolic links.
*
* @since 1.1
*/
int DEFAULT_LINK_PERM = 0777;
/**
* Default permissions for directories.
*
* @since 1.1
*/
int DEFAULT_DIR_PERM = 0755;
/**
* Default permissions for plain files.
*
* @since 1.1
*/
int DEFAULT_FILE_PERM = 0644;
}
charactermanaj/src/org/apache/tools/zip/UnrecognizedExtraField.java 0000644 0001750 0001750 00000010662 11767047544 025765 0 ustar paulliu paulliu /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*
*/
package org.apache.tools.zip;
/**
* Simple placeholder for all those extra fields we don't want to deal
* with.
*
* Assumes local file data and central directory entries are
* identical - unless told the opposite.
*
*/
public class UnrecognizedExtraField
implements CentralDirectoryParsingZipExtraField {
/**
* The Header-ID.
*
* @since 1.1
*/
private ZipShort headerId;
/**
* Set the header id.
* @param headerId the header id to use
*/
public void setHeaderId(ZipShort headerId) {
this.headerId = headerId;
}
/**
* Get the header id.
* @return the header id
*/
public ZipShort getHeaderId() {
return headerId;
}
/**
* Extra field data in local file data - without
* Header-ID or length specifier.
*
* @since 1.1
*/
private byte[] localData;
/**
* Set the extra field data in the local file data -
* without Header-ID or length specifier.
* @param data the field data to use
*/
public void setLocalFileDataData(byte[] data) {
localData = ZipUtil.copy(data);
}
/**
* Get the length of the local data.
* @return the length of the local data
*/
public ZipShort getLocalFileDataLength() {
return new ZipShort(localData.length);
}
/**
* Get the local data.
* @return the local data
*/
public byte[] getLocalFileDataData() {
return ZipUtil.copy(localData);
}
/**
* Extra field data in central directory - without
* Header-ID or length specifier.
*
* @since 1.1
*/
private byte[] centralData;
/**
* Set the extra field data in central directory.
* @param data the data to use
*/
public void setCentralDirectoryData(byte[] data) {
centralData = ZipUtil.copy(data);
}
/**
* Get the central data length.
* If there is no central data, get the local file data length.
* @return the central data length
*/
public ZipShort getCentralDirectoryLength() {
if (centralData != null) {
return new ZipShort(centralData.length);
}
return getLocalFileDataLength();
}
/**
* Get the central data.
* @return the central data if present, else return the local file data
*/
public byte[] getCentralDirectoryData() {
if (centralData != null) {
return ZipUtil.copy(centralData);
}
return getLocalFileDataData();
}
/**
* @param data the array of bytes.
* @param offset the source location in the data array.
* @param length the number of bytes to use in the data array.
* @see ZipExtraField#parseFromLocalFileData(byte[], int, int)
*/
public void parseFromLocalFileData(byte[] data, int offset, int length) {
byte[] tmp = new byte[length];
System.arraycopy(data, offset, tmp, 0, length);
setLocalFileDataData(tmp);
}
/**
* @param data the array of bytes.
* @param offset the source location in the data array.
* @param length the number of bytes to use in the data array.
*/
public void parseFromCentralDirectoryData(byte[] data, int offset,
int length) {
byte[] tmp = new byte[length];
System.arraycopy(data, offset, tmp, 0, length);
setCentralDirectoryData(tmp);
if (localData == null) {
setLocalFileDataData(tmp);
}
}
}
charactermanaj/src/org/apache/tools/zip/JarMarker.java 0000644 0001750 0001750 00000006234 11767047544 023237 0 ustar paulliu paulliu /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*
*/
package org.apache.tools.zip;
import java.util.zip.ZipException;
/**
* If this extra field is added as the very first extra field of the
* archive, Solaris will consider it an executable jar file.
*
* @since Ant 1.6.3
*/
public final class JarMarker implements ZipExtraField {
private static final ZipShort ID = new ZipShort(0xCAFE);
private static final ZipShort NULL = new ZipShort(0);
private static final byte[] NO_BYTES = new byte[0];
private static final JarMarker DEFAULT = new JarMarker();
/** No-arg constructor */
public JarMarker() {
// empty
}
/**
* Since JarMarker is stateless we can always use the same instance.
* @return the DEFAULT jarmaker.
*/
public static JarMarker getInstance() {
return DEFAULT;
}
/**
* The Header-ID.
* @return the header id
*/
public ZipShort getHeaderId() {
return ID;
}
/**
* Length of the extra field in the local file data - without
* Header-ID or length specifier.
* @return 0
*/
public ZipShort getLocalFileDataLength() {
return NULL;
}
/**
* Length of the extra field in the central directory - without
* Header-ID or length specifier.
* @return 0
*/
public ZipShort getCentralDirectoryLength() {
return NULL;
}
/**
* The actual data to put into local file data - without Header-ID
* or length specifier.
* @return the data
* @since 1.1
*/
public byte[] getLocalFileDataData() {
return NO_BYTES;
}
/**
* The actual data to put central directory - without Header-ID or
* length specifier.
* @return the data
*/
public byte[] getCentralDirectoryData() {
return NO_BYTES;
}
/**
* Populate data from this array as if it was in local file data.
* @param data an array of bytes
* @param offset the start offset
* @param length the number of bytes in the array from offset
*
* @throws ZipException on error
*/
public void parseFromLocalFileData(byte[] data, int offset, int length)
throws ZipException {
if (length != 0) {
throw new ZipException("JarMarker doesn't expect any data");
}
}
}
charactermanaj/src/org/apache/tools/zip/ZipExtraField.java 0000644 0001750 0001750 00000005265 11767047544 024076 0 ustar paulliu paulliu /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*
*/
package org.apache.tools.zip;
import java.util.zip.ZipException;
/**
* General format of extra field data.
*
* Extra fields usually appear twice per file, once in the local
* file data and once in the central directory. Usually they are the
* same, but they don't have to be. {@link
* java.util.zip.ZipOutputStream java.util.zip.ZipOutputStream} will
* only use the local file data in both places.
*
*/
public interface ZipExtraField {
/**
* The Header-ID.
* @return the header id
* @since 1.1
*/
ZipShort getHeaderId();
/**
* Length of the extra field in the local file data - without
* Header-ID or length specifier.
* @return the length of the field in the local file data
* @since 1.1
*/
ZipShort getLocalFileDataLength();
/**
* Length of the extra field in the central directory - without
* Header-ID or length specifier.
* @return the length of the field in the central directory
* @since 1.1
*/
ZipShort getCentralDirectoryLength();
/**
* The actual data to put into local file data - without Header-ID
* or length specifier.
* @return the data
* @since 1.1
*/
byte[] getLocalFileDataData();
/**
* The actual data to put into central directory - without Header-ID or
* length specifier.
* @return the data
* @since 1.1
*/
byte[] getCentralDirectoryData();
/**
* Populate data from this array as if it was in local file data.
* @param data an array of bytes
* @param offset the start offset
* @param length the number of bytes in the array from offset
*
* @since 1.1
* @throws ZipException on error
*/
void parseFromLocalFileData(byte[] data, int offset, int length)
throws ZipException;
}
charactermanaj/src/org/apache/tools/zip/UnicodeCommentExtraField.java 0000644 0001750 0001750 00000005337 11767047544 026245 0 ustar paulliu paulliu /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*
*/
package org.apache.tools.zip;
/**
* Info-ZIP Unicode Comment Extra Field (0x6375):
*
* Stores the UTF-8 version of the file comment as stored in the
* central directory header.
*
*
* Value Size Description
* ----- ---- -----------
* (UCom) 0x6375 Short tag for this extra block type ("uc")
* TSize Short total data size for this block
* Version 1 byte version of this extra field, currently 1
* ComCRC32 4 bytes Comment Field CRC32 Checksum
* UnicodeCom Variable UTF-8 version of the entry comment
*
*/
public class UnicodeCommentExtraField extends AbstractUnicodeExtraField {
public static final ZipShort UCOM_ID = new ZipShort(0x6375);
public UnicodeCommentExtraField () {
}
/**
* Assemble as unicode comment extension from the name given as
* text as well as the encoded bytes actually written to the archive.
*
* @param text The file name
* @param bytes the bytes actually written to the archive
* @param off The offset of the encoded comment in bytes.
* @param len The length of the encoded comment or comment in
* bytes.
*/
public UnicodeCommentExtraField(String text, byte[] bytes, int off,
int len) {
super(text, bytes, off, len);
}
/**
* Assemble as unicode comment extension from the comment given as
* text as well as the bytes actually written to the archive.
*
* @param comment The file comment
* @param bytes the bytes actually written to the archive
*/
public UnicodeCommentExtraField(String comment, byte[] bytes) {
super(comment, bytes);
}
public ZipShort getHeaderId() {
return UCOM_ID;
}
}
charactermanaj/src/org/apache/tools/zip/NioZipEncoding.java 0000644 0001750 0001750 00000007727 11767047544 024250 0 ustar paulliu paulliu /*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
package org.apache.tools.zip;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.CoderResult;
import java.nio.charset.CodingErrorAction;
/**
* A ZipEncoding, which uses a java.nio {@link
* java.nio.charset.Charset Charset} to encode names.
*
* This implementation works for all cases under java-1.5 or
* later. However, in java-1.4, some charsets don't have a java.nio
* implementation, most notably the default ZIP encoding Cp437.
*
* The methods of this class are reentrant.
*/
class NioZipEncoding implements ZipEncoding {
private final Charset charset;
/**
* Construct an NIO based zip encoding, which wraps the given
* charset.
*
* @param charset The NIO charset to wrap.
*/
public NioZipEncoding(Charset charset) {
this.charset = charset;
}
/**
* @see
* org.apache.tools.zip.ZipEncoding#canEncode(java.lang.String)
*/
public boolean canEncode(String name) {
CharsetEncoder enc = this.charset.newEncoder();
enc.onMalformedInput(CodingErrorAction.REPORT);
enc.onUnmappableCharacter(CodingErrorAction.REPORT);
return enc.canEncode(name);
}
/**
* @see
* org.apache.tools.zip.ZipEncoding#encode(java.lang.String)
*/
public ByteBuffer encode(String name) {
CharsetEncoder enc = this.charset.newEncoder();
enc.onMalformedInput(CodingErrorAction.REPORT);
enc.onUnmappableCharacter(CodingErrorAction.REPORT);
CharBuffer cb = CharBuffer.wrap(name);
ByteBuffer out = ByteBuffer.allocate(name.length()
+ (name.length() + 1) / 2);
while (cb.remaining() > 0) {
CoderResult res = enc.encode(cb, out,true);
if (res.isUnmappable() || res.isMalformed()) {
// write the unmappable characters in utf-16
// pseudo-URL encoding style to ByteBuffer.
if (res.length() * 6 > out.remaining()) {
out = ZipEncodingHelper.growBuffer(out, out.position()
+ res.length() * 6);
}
for (int i=0; ir with
* r.capacity() = max(b.capacity()*2,newCapacity) and
* all the data contained in b copied to the beginning
* of r.
*
*/
static ByteBuffer growBuffer(ByteBuffer b, int newCapacity) {
b.limit(b.position());
b.rewind();
int c2 = b.capacity() * 2;
ByteBuffer on = ByteBuffer.allocate(c2 < newCapacity ? newCapacity : c2);
on.put(b);
return on;
}
/**
* The hexadecimal digits 0,...,9,A,...,F encoded as
* ASCII bytes.
*/
private static final byte[] HEX_DIGITS =
new byte [] {
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41,
0x42, 0x43, 0x44, 0x45, 0x46
};
/**
* Append %Uxxxx to the given byte buffer.
* The caller must assure, that bb.remaining()>=6.
*
* @param bb The byte buffer to write to.
* @param c The character to write.
*/
static void appendSurrogate(ByteBuffer bb, char c) {
bb.put((byte) '%');
bb.put((byte) 'U');
bb.put(HEX_DIGITS[(c >> 12)&0x0f]);
bb.put(HEX_DIGITS[(c >> 8)&0x0f]);
bb.put(HEX_DIGITS[(c >> 4)&0x0f]);
bb.put(HEX_DIGITS[c & 0x0f]);
}
/**
* name of the encoding UTF-8
*/
static final String UTF8 = "UTF8";
/**
* variant name of the encoding UTF-8 used for comparisions.
*/
private static final String UTF_DASH_8 = "utf-8";
/**
* name of the encoding UTF-8
*/
static final ZipEncoding UTF8_ZIP_ENCODING = new FallbackZipEncoding(UTF8);
/**
* Instantiates a zip encoding.
*
* @param name The name of the zip encoding. Specify null for
* the platform's default encoding.
* @return A zip encoding for the given encoding name.
*/
static ZipEncoding getZipEncoding(String name) {
// fallback encoding is good enough for utf-8.
if (isUTF8(name)) {
return UTF8_ZIP_ENCODING;
}
if (name == null) {
return new FallbackZipEncoding();
}
SimpleEncodingHolder h =
(SimpleEncodingHolder) simpleEncodings.get(name);
if (h!=null) {
return h.getEncoding();
}
try {
Charset cs = Charset.forName(name);
return new NioZipEncoding(cs);
} catch (UnsupportedCharsetException e) {
return new FallbackZipEncoding(name);
}
}
/**
* Whether a given encoding - or the platform's default encoding
* if the parameter is null - is UTF-8.
*/
static boolean isUTF8(String encoding) {
if (encoding == null) {
// check platform's default encoding
encoding = System.getProperty("file.encoding");
}
return UTF8.equalsIgnoreCase(encoding)
|| UTF_DASH_8.equalsIgnoreCase(encoding);
}
}
charactermanaj/src/org/apache/tools/zip/AsiExtraField.java 0000644 0001750 0001750 00000023637 11767047544 024053 0 ustar paulliu paulliu /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*
*/
package org.apache.tools.zip;
import java.util.zip.CRC32;
import java.util.zip.ZipException;
/**
* Adds Unix file permission and UID/GID fields as well as symbolic
* link handling.
*
* This class uses the ASi extra field in the format:
*
* Value Size Description
* ----- ---- -----------
* (Unix3) 0x756e Short tag for this extra block type
* TSize Short total data size for this block
* CRC Long CRC-32 of the remaining data
* Mode Short file permissions
* SizDev Long symlink'd size OR major/minor dev num
* UID Short user ID
* GID Short group ID
* (var.) variable symbolic link filename
*
* taken from appnote.iz (Info-ZIP note, 981119) found at ftp://ftp.uu.net/pub/archiving/zip/doc/
*
* Short is two bytes and Long is four bytes in big endian byte and
* word order, device numbers are currently not supported.
*
*/
public class AsiExtraField implements ZipExtraField, UnixStat, Cloneable {
private static final ZipShort HEADER_ID = new ZipShort(0x756E);
private static final int WORD = 4;
/**
* Standard Unix stat(2) file mode.
*
* @since 1.1
*/
private int mode = 0;
/**
* User ID.
*
* @since 1.1
*/
private int uid = 0;
/**
* Group ID.
*
* @since 1.1
*/
private int gid = 0;
/**
* File this entry points to, if it is a symbolic link.
*
* empty string - if entry is not a symbolic link.
*
* @since 1.1
*/
private String link = "";
/**
* Is this an entry for a directory?
*
* @since 1.1
*/
private boolean dirFlag = false;
/**
* Instance used to calculate checksums.
*
* @since 1.1
*/
private CRC32 crc = new CRC32();
/** Constructor for AsiExtraField. */
public AsiExtraField() {
}
/**
* The Header-ID.
* @return the value for the header id for this extrafield
* @since 1.1
*/
public ZipShort getHeaderId() {
return HEADER_ID;
}
/**
* Length of the extra field in the local file data - without
* Header-ID or length specifier.
* @return a ZipShort for the length of the data of this extra field
* @since 1.1
*/
public ZipShort getLocalFileDataLength() {
return new ZipShort(WORD // CRC
+ 2 // Mode
+ WORD // SizDev
+ 2 // UID
+ 2 // GID
+ getLinkedFile().getBytes().length);
}
/**
* Delegate to local file data.
* @return the centralDirectory length
* @since 1.1
*/
public ZipShort getCentralDirectoryLength() {
return getLocalFileDataLength();
}
/**
* The actual data to put into local file data - without Header-ID
* or length specifier.
* @return get the data
* @since 1.1
*/
public byte[] getLocalFileDataData() {
// CRC will be added later
byte[] data = new byte[getLocalFileDataLength().getValue() - WORD];
System.arraycopy(ZipShort.getBytes(getMode()), 0, data, 0, 2);
byte[] linkArray = getLinkedFile().getBytes();
// CheckStyle:MagicNumber OFF
System.arraycopy(ZipLong.getBytes(linkArray.length),
0, data, 2, WORD);
System.arraycopy(ZipShort.getBytes(getUserId()),
0, data, 6, 2);
System.arraycopy(ZipShort.getBytes(getGroupId()),
0, data, 8, 2);
System.arraycopy(linkArray, 0, data, 10, linkArray.length);
// CheckStyle:MagicNumber ON
crc.reset();
crc.update(data);
long checksum = crc.getValue();
byte[] result = new byte[data.length + WORD];
System.arraycopy(ZipLong.getBytes(checksum), 0, result, 0, WORD);
System.arraycopy(data, 0, result, WORD, data.length);
return result;
}
/**
* Delegate to local file data.
* @return the local file data
* @since 1.1
*/
public byte[] getCentralDirectoryData() {
return getLocalFileDataData();
}
/**
* Set the user id.
* @param uid the user id
* @since 1.1
*/
public void setUserId(int uid) {
this.uid = uid;
}
/**
* Get the user id.
* @return the user id
* @since 1.1
*/
public int getUserId() {
return uid;
}
/**
* Set the group id.
* @param gid the group id
* @since 1.1
*/
public void setGroupId(int gid) {
this.gid = gid;
}
/**
* Get the group id.
* @return the group id
* @since 1.1
*/
public int getGroupId() {
return gid;
}
/**
* Indicate that this entry is a symbolic link to the given filename.
*
* @param name Name of the file this entry links to, empty String
* if it is not a symbolic link.
*
* @since 1.1
*/
public void setLinkedFile(String name) {
link = name;
mode = getMode(mode);
}
/**
* Name of linked file
*
* @return name of the file this entry links to if it is a
* symbolic link, the empty string otherwise.
*
* @since 1.1
*/
public String getLinkedFile() {
return link;
}
/**
* Is this entry a symbolic link?
* @return true if this is a symbolic link
* @since 1.1
*/
public boolean isLink() {
return getLinkedFile().length() != 0;
}
/**
* File mode of this file.
* @param mode the file mode
* @since 1.1
*/
public void setMode(int mode) {
this.mode = getMode(mode);
}
/**
* File mode of this file.
* @return the file mode
* @since 1.1
*/
public int getMode() {
return mode;
}
/**
* Indicate whether this entry is a directory.
* @param dirFlag if true, this entry is a directory
* @since 1.1
*/
public void setDirectory(boolean dirFlag) {
this.dirFlag = dirFlag;
mode = getMode(mode);
}
/**
* Is this entry a directory?
* @return true if this entry is a directory
* @since 1.1
*/
public boolean isDirectory() {
return dirFlag && !isLink();
}
/**
* Populate data from this array as if it was in local file data.
* @param data an array of bytes
* @param offset the start offset
* @param length the number of bytes in the array from offset
* @since 1.1
* @throws ZipException on error
*/
public void parseFromLocalFileData(byte[] data, int offset, int length)
throws ZipException {
long givenChecksum = ZipLong.getValue(data, offset);
byte[] tmp = new byte[length - WORD];
System.arraycopy(data, offset + WORD, tmp, 0, length - WORD);
crc.reset();
crc.update(tmp);
long realChecksum = crc.getValue();
if (givenChecksum != realChecksum) {
throw new ZipException("bad CRC checksum "
+ Long.toHexString(givenChecksum)
+ " instead of "
+ Long.toHexString(realChecksum));
}
int newMode = ZipShort.getValue(tmp, 0);
// CheckStyle:MagicNumber OFF
byte[] linkArray = new byte[(int) ZipLong.getValue(tmp, 2)];
uid = ZipShort.getValue(tmp, 6);
gid = ZipShort.getValue(tmp, 8);
if (linkArray.length == 0) {
link = "";
} else {
System.arraycopy(tmp, 10, linkArray, 0, linkArray.length);
link = new String(linkArray);
}
// CheckStyle:MagicNumber ON
setDirectory((newMode & DIR_FLAG) != 0);
setMode(newMode);
}
/**
* Get the file mode for given permissions with the correct file type.
* @param mode the mode
* @return the type with the mode
* @since 1.1
*/
protected int getMode(int mode) {
int type = FILE_FLAG;
if (isLink()) {
type = LINK_FLAG;
} else if (isDirectory()) {
type = DIR_FLAG;
}
return type | (mode & PERM_MASK);
}
public Object clone() {
try {
AsiExtraField cloned = (AsiExtraField) super.clone();
cloned.crc = new CRC32();
return cloned;
} catch (CloneNotSupportedException cnfe) {
// impossible
throw new RuntimeException(cnfe);
}
}
}
charactermanaj/src/org/apache/tools/zip/AbstractUnicodeExtraField.java 0000644 0001750 0001750 00000011707 11767047544 026404 0 ustar paulliu paulliu /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*
*/
package org.apache.tools.zip;
import java.io.UnsupportedEncodingException;
import java.util.zip.CRC32;
import java.util.zip.ZipException;
/**
* A common base class for Unicode extra information extra fields.
*/
public abstract class AbstractUnicodeExtraField implements ZipExtraField {
private long nameCRC32;
private byte[] unicodeName;
private byte[] data;
protected AbstractUnicodeExtraField() {
}
/**
* Assemble as unicode extension from the name/comment and
* encoding of the orginal zip entry.
*
* @param text The file name or comment.
* @param bytes The encoded of the filename or comment in the zip
* file.
* @param off The offset of the encoded filename or comment in
* bytes.
* @param len The length of the encoded filename or commentin
* bytes.
*/
protected AbstractUnicodeExtraField(String text, byte[] bytes, int off,
int len) {
CRC32 crc32 = new CRC32();
crc32.update(bytes, off, len);
nameCRC32 = crc32.getValue();
try {
unicodeName = text.getBytes("UTF-8");
} catch (UnsupportedEncodingException e) {
throw new RuntimeException("FATAL: UTF-8 encoding not supported.",
e);
}
}
/**
* Assemble as unicode extension from the name/comment and
* encoding of the orginal zip entry.
*
* @param text The file name or comment.
* @param bytes The encoded of the filename or comment in the zip
* file.
*/
protected AbstractUnicodeExtraField(String text, byte[] bytes) {
this(text, bytes, 0, bytes.length);
}
private void assembleData() {
if (unicodeName == null) {
return;
}
data = new byte[5 + unicodeName.length];
// version 1
data[0] = 0x01;
System.arraycopy(ZipLong.getBytes(nameCRC32), 0, data, 1, 4);
System.arraycopy(unicodeName, 0, data, 5, unicodeName.length);
}
/**
* @return The CRC32 checksum of the filename or comment as
* encoded in the central directory of the zip file.
*/
public long getNameCRC32() {
return nameCRC32;
}
/**
* @param nameCRC32 The CRC32 checksum of the filename as encoded
* in the central directory of the zip file to set.
*/
public void setNameCRC32(long nameCRC32) {
this.nameCRC32 = nameCRC32;
data = null;
}
/**
* @return The utf-8 encoded name.
*/
public byte[] getUnicodeName() {
return unicodeName;
}
/**
* @param unicodeName The utf-8 encoded name to set.
*/
public void setUnicodeName(byte[] unicodeName) {
this.unicodeName = unicodeName;
data = null;
}
public byte[] getCentralDirectoryData() {
if (data == null) {
this.assembleData();
}
return data;
}
public ZipShort getCentralDirectoryLength() {
if (data == null) {
assembleData();
}
return new ZipShort(data.length);
}
public byte[] getLocalFileDataData() {
return getCentralDirectoryData();
}
public ZipShort getLocalFileDataLength() {
return getCentralDirectoryLength();
}
public void parseFromLocalFileData(byte[] buffer, int offset, int length)
throws ZipException {
if (length < 5) {
throw new ZipException("UniCode path extra data must have at least"
+ " 5 bytes.");
}
int version = buffer[offset];
if (version != 0x01) {
throw new ZipException("Unsupported version [" + version
+ "] for UniCode path extra data.");
}
nameCRC32 = ZipLong.getValue(buffer, offset + 1);
unicodeName = new byte[length - 5];
System.arraycopy(buffer, offset + 5, unicodeName, 0, length - 5);
data = null;
}
}
charactermanaj/src/charactermanaj/ 0000755 0001750 0001750 00000000000 11767047543 017501 5 ustar paulliu paulliu charactermanaj/src/charactermanaj/clipboardSupport/ 0000755 0001750 0001750 00000000000 11767047535 023036 5 ustar paulliu paulliu charactermanaj/src/charactermanaj/clipboardSupport/ClipboardUtil.java 0000644 0001750 0001750 00000003541 11767047535 026441 0 ustar paulliu paulliu package charactermanaj.clipboardSupport;
import java.awt.Color;
import java.awt.Toolkit;
import java.awt.datatransfer.Clipboard;
import java.awt.image.BufferedImage;
import java.io.IOException;
/**
* クリップボード用ユーテリティクラス.
* @author seraphy
*/
public final class ClipboardUtil {
private ClipboardUtil() {
super();
}
/**
* クリップボードにイメージを設定する.
* JDKのクリップボード経由の画像転送では透過色を表現できないので、背景色を指定する必要がある.
* (ただし、このアプリケーション内であれば透過色を維持したままコピー可能.)
* @param img イメージ
* @param bgColor 背景色
*/
public static void setImage(BufferedImage img, Color bgColor) {
if (img == null || bgColor == null) {
throw new IllegalArgumentException();
}
Toolkit tk = Toolkit.getDefaultToolkit();
Clipboard cb = tk.getSystemClipboard();
ImageSelection imageSelection = new ImageSelection(img, bgColor);
cb.setContents(imageSelection, null);
}
/**
* クリップボード内にイメージがあるか?
* @return イメージがあればtrue
*/
public static boolean hasImage() {
Toolkit tk = Toolkit.getDefaultToolkit();
Clipboard cb = tk.getSystemClipboard();
return ImageSelection.isSupprotedFlavorAvailable(cb);
}
/**
* クリップボードからイメージを取得する.
* 取得できる形式がない場合はnullを返す.
* @return 画像、もしくはnull
* @throws IOException 読み取り中に例外が発生した場合
*/
public static BufferedImage getImage() throws IOException {
Toolkit tk = Toolkit.getDefaultToolkit();
Clipboard cb = tk.getSystemClipboard();
return ImageSelection.getImage(cb);
}
}
charactermanaj/src/charactermanaj/clipboardSupport/ImageSelection.java 0000644 0001750 0001750 00000020351 11767047535 026572 0 ustar paulliu paulliu package charactermanaj.clipboardSupport;
import java.awt.Color;
import java.awt.datatransfer.Clipboard;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.FlavorMap;
import java.awt.datatransfer.SystemFlavorMap;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.imageio.ImageIO;
import charactermanaj.graphics.io.ImageSaveHelper;
import charactermanaj.model.AppConfig;
/**
* クリップボードに画像をコピーするためのセレクション.
* @author seraphy
*/
public class ImageSelection implements Transferable {
/**
* ロガー
*/
private static final Logger logger = Logger.getLogger(ImageSelection.class.getName());
/**
* 実行環境がWindowsであるか?
*/
private static final boolean platformWindows;
/**
* 対象となるイメージ
*/
private BufferedImage img;
/**
* 背景色(jpeg画像変換時)
*/
private Color bgColor;
/**
* MIME汎用(PNG).
*/
private static final DataFlavor PNG_FLAVOR = new DataFlavor("image/png", "image/png");
/**
* MIME汎用(JPEG).
*/
private static final DataFlavor JPEG_FLAVOR = new DataFlavor("image/jpeg", "image/jpeg");
/**
* MIME汎用(BMP).
*/
private static final DataFlavor BMP_FLAVOR = new DataFlavor("image/bmp", "image/bmp");
/**
* サポートされている形式.
* 順序は優先順.
*/
private static final List SUPPORTED_FLAVORS;
/**
* クラスイニシャライザ
*/
static {
String lcOS = System.getProperty("os.name").toLowerCase();
platformWindows = lcOS.indexOf("windows") >= 0;
if (platformWindows) {
// Windowsの場合
SUPPORTED_FLAVORS = Arrays.asList(new DataFlavor[] {
PNG_FLAVOR,
DataFlavor.imageFlavor,
});
} else {
// Linux, Mac OS Xの場合を想定
SUPPORTED_FLAVORS = Arrays.asList(new DataFlavor[] {
PNG_FLAVOR,
JPEG_FLAVOR,
BMP_FLAVOR,
DataFlavor.imageFlavor,
});
}
}
/**
* システムのフレーバーマップを設定する.
* @return 正常にセットアップできた場合はtrue、そうでなければfalse
*/
public static boolean setupSystemFlavorMap() {
try {
AppConfig appConfig = AppConfig.getInstance();
if (appConfig.isEnablePNGSupportForWindows()) {
// "PNG"へのマップを明示的に設定する.
// (Windowsの場合、デフォルトでは、画像はDBI転送となり透過情報を持つことができないため.)
FlavorMap defFlavorMap = SystemFlavorMap.getDefaultFlavorMap();
if (defFlavorMap instanceof SystemFlavorMap) {
SystemFlavorMap sysFlavorMap = (SystemFlavorMap) defFlavorMap;
sysFlavorMap.setNativesForFlavor(PNG_FLAVOR, new String[] {"PNG"});
sysFlavorMap.setNativesForFlavor(JPEG_FLAVOR, new String[] {"JFIF"});
}
}
return true;
} catch (Exception ex) {
logger.log(Level.SEVERE, "systemFlavorMap setup failed.", ex);
}
return false;
}
/**
* セレクションを構築する.
* @param img 対象となるイメージ
*/
public ImageSelection(BufferedImage img, Color bgColor) {
if (img == null) {
throw new IllegalArgumentException();
}
this.img = img;
this.bgColor = (bgColor == null) ? Color.white : bgColor;
}
public Object getTransferData(DataFlavor flavor)
throws UnsupportedFlavorException, IOException {
if (flavor != null) {
logger.log(Level.FINE, "getTransferData flavor=" + flavor);
try {
ImageSaveHelper imageSaveHelper = new ImageSaveHelper();
if (flavor.equals(PNG_FLAVOR) || flavor.equals(JPEG_FLAVOR) || flavor.equals(BMP_FLAVOR)) {
// image/png, image/jpeg, image/bmpの場合は、
// そのファイル形式のデータを生成して、それを返す.
ByteArrayOutputStream bos = new ByteArrayOutputStream();
try {
imageSaveHelper.savePicture(img, bgColor, bos, flavor.getMimeType(), null);
} finally {
bos.close();
}
return new ByteArrayInputStream(bos.toByteArray());
}
if (flavor.equals(DataFlavor.imageFlavor)) {
// "image/x-java-image"の場合
AppConfig appConfig = AppConfig.getInstance();
if (platformWindows || !appConfig.isEnablePNGSupportForWindows()) {
// Windowsの場合は、背景色で塗りつぶしたBMP画像に変換して返す.
// JDK5/6のシステムクリップボードへのコピーでは透過画像をサポートしておらず透過部分が黒色になるため.
// ネイティブPNGとのマッピングが有効であれば、Windowsでは、そちらで対応する.
return imageSaveHelper.createBMPFormatPicture(img, bgColor);
} else {
// Windows以外、且つ、透過サポートが有効の場合
return img;
}
}
} catch (RuntimeException ex) {
logger.log(Level.WARNING, "The exception occurred during the data transfer of a clipboard.", ex);
throw ex;
} catch (IOException ex) {
logger.log(Level.WARNING, "The exception occurred during the data transfer of a clipboard.", ex);
throw ex;
}
}
throw new UnsupportedFlavorException(flavor);
}
public DataFlavor[] getTransferDataFlavors() {
return SUPPORTED_FLAVORS.toArray(new DataFlavor[SUPPORTED_FLAVORS.size()]);
}
public boolean isDataFlavorSupported(DataFlavor flavor) {
return flavor != null && SUPPORTED_FLAVORS.contains(flavor);
}
public static boolean isSupprotedFlavorAvailable(Clipboard cb) {
if (cb != null) {
for (DataFlavor flavor : SUPPORTED_FLAVORS) {
if (cb.isDataFlavorAvailable(flavor)) {
return true;
}
}
}
return false;
}
public static BufferedImage getImage(Clipboard cb) throws IOException {
if (cb == null) {
return null;
}
try {
// サポートされている形式をチェックする.
for (DataFlavor flavor : cb.getAvailableDataFlavors()) {
logger.log(Level.FINE, "dataFlavor(in Clipboard)=" + flavor);
}
DataFlavor availableFlavor = null;
for (DataFlavor flavor : SUPPORTED_FLAVORS) {
// 優先順にチェックし最初に見つかったサポートされている形式を採用する.
if (cb.isDataFlavorAvailable(flavor)) {
availableFlavor = flavor;
break;
}
}
logger.log(Level.FINE, "selected flavor=" + availableFlavor);
if (availableFlavor != null) {
if (availableFlavor.equals(DataFlavor.imageFlavor)) {
// 汎用の画像形式で取得を試みる。
// 透過画像は使えないため、ここで取得されるものは非透過画像である。
return (BufferedImage) cb.getData(DataFlavor.imageFlavor);
}
if (availableFlavor.equals(PNG_FLAVOR)
|| availableFlavor.equals(JPEG_FLAVOR)
|| availableFlavor.equals(BMP_FLAVOR)) {
// image/png, image/bmp, image/jpegのいずれか
InputStream is = (InputStream) cb.getData(availableFlavor);
if (is != null) {
BufferedImage img;
try {
img = ImageIO.read(is);
} finally {
is.close();
}
return img;
}
}
}
} catch (IOException ex) {
logger.log(Level.WARNING, "The exception occurred in access to a clipboard.", ex);
throw ex;
} catch (UnsupportedFlavorException ex) {
// 直前にisDataFlavorAvailableで確認しているので、
// よほどタイミングが悪くなければエラーは発生しないはず。
logger.log(Level.WARNING, "The exception occurred in access to a clipboard.", ex);
throw new IOException(ex.getMessage());
}
// サポートしているものが無い場合.
return null;
}
}
charactermanaj/src/charactermanaj/Main.java 0000644 0001750 0001750 00000016767 11767047543 021251 0 ustar paulliu paulliu package charactermanaj;
import java.awt.Font;
import java.io.File;
import java.lang.reflect.Method;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.SwingUtilities;
import javax.swing.UIDefaults;
import javax.swing.UIManager;
import charactermanaj.clipboardSupport.ImageSelection;
import charactermanaj.model.AppConfig;
import charactermanaj.model.util.StartupSupport;
import charactermanaj.ui.MainFrame;
import charactermanaj.ui.ProfileListManager;
import charactermanaj.ui.SelectCharatersDirDialog;
import charactermanaj.util.AWTExceptionLoggingHandler;
import charactermanaj.util.ConfigurationDirUtilities;
import charactermanaj.util.DirectoryConfig;
import charactermanaj.util.ErrorMessageHelper;
import charactermanaj.util.ApplicationLoggerConfigurator;
/**
* エントリポイント用クラス
* @author seraphy
*/
public final class Main implements Runnable {
/**
* ロガー.
*/
private static final Logger logger = Logger.getLogger(Main.class.getName());
/**
* Mac OS Xであるか?
*/
private static final boolean isMacOSX;
/**
* Linuxであるか?
*/
private static final boolean isLinux;
/**
* クラスイニシャライザ.
* 実行環境に関する定数を取得・設定する.
*/
static {
// Mac OS Xでの実行判定
// システムプロパティos.nameは、すべてのJVM実装に存在する.
// 基本ディレクトリの位置の決定に使うため、
// なによりも、まず、これを判定しないとダメ.(順序が重要)
String lcOS = System.getProperty("os.name").toLowerCase();
isMacOSX = lcOS.startsWith("mac os x");
isLinux = lcOS.indexOf("linux") >= 0;
}
/**
* ロガーの初期化.
* 失敗しても継続する.
*/
private static void initLogger() {
try {
// ロガーの準備
// ローカルファイルシステム上のユーザ定義ディレクトリから
// ログの設定を読み取る.(OSにより、設定ファイルの位置が異なることに注意)
ApplicationLoggerConfigurator.configure();
// SwingのEDT内の例外ハンドラの設定 (ロギングするだけ)
System.setProperty("sun.awt.exception.handler",
AWTExceptionLoggingHandler.class.getName());
} catch (Throwable ex) {
// ロガーの準備に失敗した場合はロガーがないかもなので
// コンソールに出力する.
ex.printStackTrace();
logger.log(Level.SEVERE, "logger initiation failed. " + ex, ex);
}
}
/**
* UIをセットアップする.
* @throws Exception いろいろな失敗
*/
private static void setupUIManager() throws Exception {
//System.setProperty("swing.aatext", "true");
//System.setProperty("awt.useSystemAAFontSettings", "on");
// MacOSXであれば、スクリーンメニューを有効化
if (isMacOSX()) {
System.setProperty("apple.laf.useScreenMenuBar", "true");
System.setProperty(
"com.apple.mrj.application.apple.menu.about.name",
"CharacterManaJ");
}
// 実行プラットフォームのネイティブな外観にする.
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
// JSpliderのvalueを非表示 (GTKではデフォルトで有効のため)
UIManager.put("Slider.paintValue", Boolean.FALSE);
// JTextAreaの既定フォントを固定幅から、標準テキストと同じフォントに変更.
// (Linuxなどで固定幅フォントでは日本語フォントを持っていないため。)
Object textFieldFontUI = UIManager.get("TextField.font");
if (textFieldFontUI == null) {
// もし無ければダイアログUIフォントを使う.(これは日本語をサポートするであろう。)
textFieldFontUI = new UIDefaults.ProxyLazyValue(
"javax.swing.plaf.FontUIResource", null, new Object[] {
"dialog", Integer.valueOf(Font.PLAIN), Integer.valueOf(12)});
}
UIManager.put("TextArea.font", textFieldFontUI);
}
/**
* 初期処理およびメインフレームを構築する.
* SwingのUIスレッドで実行される.
*/
public void run() {
try {
// UIManagerのセットアップ.
try {
setupUIManager();
} catch (Exception ex) {
// UIManagerの設定に失敗した場合はログに書いて継続する.
ex.printStackTrace();
logger.log(Level.WARNING, "UIManager setup failed.", ex);
}
// アプリケーション設定の読み込み
AppConfig appConfig = AppConfig.getInstance();
appConfig.loadConfig();
// クリップボードサポートの設定
if ( !ImageSelection.setupSystemFlavorMap()) {
logger.log(Level.WARNING, "failed to set the clipboard-support.");
}
// キャラクターセットディレクトリの選択
File defaultCharacterDir = ConfigurationDirUtilities.getDefaultCharactersDir();
File currentCharacterDir = SelectCharatersDirDialog.getCharacterDir(defaultCharacterDir);
if (currentCharacterDir == null) {
// キャンセルされたので終了する.
logger.info("luncher canceled.");
return;
}
DirectoryConfig.getInstance().setCharactersDir(currentCharacterDir);
// スタートアップ時の初期化
StartupSupport.getInstance().doStartup();
// デフォルトのプロファイルを開く.
// (最後に使ったプロファイルがあれば、それが開かれる.)
MainFrame mainFrame = ProfileListManager.openDefaultProfile();
if (isMacOSX()) {
try {
// MacOSXであればスクリーンメニューからのイベントをハンドルできるようにする.
// OSXにしか存在しないクラスを利用するためリフレクションとしている.
// ただしJDKによっては、Apple Java Extensionsがないことも予想されるので、
// その場合はエラーにしない。
Class clz = Class.forName("charactermanaj.ui.MainFramePartialForMacOSX");
Method mtd = clz.getMethod("setupScreenMenu", MainFrame.class);
mtd.invoke(null, mainFrame);
} catch (Throwable ex) {
logger.log(Level.CONFIG, "The Apple Java Extensions is not found.", ex);
}
}
// 表示(および位置あわせ)
mainFrame.showMainFrame();
} catch (Throwable ex) {
// なんらかの致命的な初期化エラーがあった場合、ログとコンソールに表示
// ダイアログが表示されるかどうかは状況次第.
ex.printStackTrace();
logger.log(Level.SEVERE, "Application initiation failed.", ex);
ErrorMessageHelper.showErrorDialog(null, ex);
// メインフレームを破棄します.
MainFrame.closeAllProfiles();
}
}
/**
* エントリポイント.
* 最初のメインフレームを開いたときにMac OS Xであればスクリーンメニューの登録も行う.
* @param args 引数(未使用)
*/
public static void main(String[] args) {
// ロガー等の初期化
initLogger();
// フレームの生成等は、SwingのEDTで実行する.
SwingUtilities.invokeLater(new Main());
}
/**
* Mac OS Xで動作しているか?
* @return Max OS X上であればtrue
*/
public static boolean isMacOSX() {
return isMacOSX;
}
/**
* Mac OS X、もしくはlinuxで動作しているか?
* @return Mac OS X、もしくはlinuxで動作していればtrue
*/
public static boolean isLinuxOrMacOSX() {
return isLinux || isMacOSX;
}
}
charactermanaj/src/charactermanaj/util/ 0000755 0001750 0001750 00000000000 11767047543 020456 5 ustar paulliu paulliu charactermanaj/src/charactermanaj/util/ResourceNames.java 0000644 0001750 0001750 00000002022 11767047543 024070 0 ustar paulliu paulliu package charactermanaj.util;
import java.util.AbstractList;
import java.util.Arrays;
/**
* 関連もしくは類似するリソースをまとめて取り扱うためにグループ化するためのクラス.
* @author seraphy
*/
final class ResourceNames extends AbstractList {
private final String[] resourceNames;
ResourceNames(String[] resourceNames) {
if (resourceNames == null) {
throw new IllegalArgumentException();
}
this.resourceNames = resourceNames;
}
@Override
public int hashCode() {
return Arrays.hashCode(resourceNames);
}
@Override
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (obj != null && obj instanceof ResourceNames) {
ResourceNames o = (ResourceNames) obj;
return Arrays.equals(resourceNames, o.resourceNames);
}
return false;
}
@Override
public int size() {
return resourceNames.length;
}
@Override
public String get(int index) {
return resourceNames[index];
}
}
charactermanaj/src/charactermanaj/util/ApplicationLoggerConfigurator.java 0000644 0001750 0001750 00000007043 11767047543 027313 0 ustar paulliu paulliu package charactermanaj.util;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.util.logging.ConsoleHandler;
import java.util.logging.Level;
import java.util.logging.LogManager;
import java.util.logging.Logger;
public final class ApplicationLoggerConfigurator {
private static final String LOGGING_PROPERTIES = "logging.properties";
private ApplicationLoggerConfigurator() {
super();
}
public static void configure() {
// ログマネージャ.
// 初期時にJRE等にある初期設定がなされている.
LogManager logManager = LogManager.getLogManager();
// 設定を一旦クリアする.
// ルートロガーがInfoになり、ハンドラはすべてリセット。ルートロガー以外の設定は空にされる.
logManager.reset();
Exception configurationError = null;
try {
// ユーザーごとのアプリケーション設定ディレクトリ上の設定ファイルを取得する.
File appDataDir = ConfigurationDirUtilities.getUserDataDir();
File logConfig = new File(appDataDir, LOGGING_PROPERTIES);
if ( !logConfig.exists()) {
// ユーザ指定のロギングプロパティがない場合、リソースからコピーする
copyDefaultLogProperty(logConfig);
}
InputStream is = null;
if (logConfig.exists()) {
// ユーザー指定のロギングプロパティがある場合
is = new FileInputStream(logConfig);
} else {
// リソース上のロギングプロパティ
is = ApplicationLoggerConfigurator.class.getResourceAsStream("/" + LOGGING_PROPERTIES);
}
if (is != null) {
try {
// ログを再設定する.
logManager.readConfiguration(is);
} finally {
is.close();
}
}
} catch (Exception ex) {
// 初期化に失敗した場合はログに記録するために例外を保存するが、
// 処理は継続する.
configurationError = ex;
}
// ロガーを取得
Logger logger = Logger.getLogger(ApplicationLoggerConfigurator.class.getName());
// 初期化時に失敗した場合、デフォルトのコンソールハンドラを設定し、ログに出力する.
if (configurationError != null) {
logger.addHandler(new ConsoleHandler());
logger.addHandler(new ApplicationLogHandler());
logger.log(Level.WARNING, "LogConfigurationFailed", configurationError);
}
// 初期化時のログ
logger.info("open logger.");
logger.info("application configuration: baseDir="
+ ConfigurationDirUtilities.getApplicationBaseDir() + " appData="
+ ConfigurationDirUtilities.getUserDataDir());
}
/**
* デフォルトのログプロパティをユーザディレクトリにコピーする.
* @param logConfig ユーザディレクトリ上のログプロパティファイル位置
*/
private static void copyDefaultLogProperty(File logConfig) {
try {
InputStream is = ApplicationLoggerConfigurator.class
.getResourceAsStream("/" + LOGGING_PROPERTIES);
if (is != null) {
try {
FileOutputStream fos = new FileOutputStream(logConfig);
try {
byte buf[] = new byte[4096];
for (;;) {
int rd = is.read(buf);
if (rd <= 0) {
break;
}
fos.write(buf, 0, rd);
}
} finally {
fos.close();
}
} finally {
is.close();
}
}
} catch (Exception ex) {
ex.printStackTrace();
// 失敗しても継続する
}
}
}
charactermanaj/src/charactermanaj/util/FileMappedProperties.java 0000644 0001750 0001750 00000015064 11767047543 025412 0 ustar paulliu paulliu package charactermanaj.util;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.sql.Timestamp;
import java.util.AbstractMap;
import java.util.AbstractSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
/**
* ファイルに保存されるPropertiesアクセスの実装.
* ファイルの読み込みまたは書き込みがあると、それ以降、排他制御される.
* ファイルを閉じた後は読み込み・書き込みはできず、プロパティの更新もできなく、IllegalStateException例外となります.
* ただし、閉じた後でもプロパティの取得は可能です.
* @author seraphy
*/
public class FileMappedProperties extends AbstractMap {
/**
* データベースファイル
*/
private File file;
/**
* データベースファイルへのランダムアクセス
*/
private RandomAccessFile accessFile;
/**
* ランダムアクセスファイルへのファイルチャネル(排他制御のため)
*/
private FileChannel channel;
/**
* プロパティ実体
*/
private Properties props = new Properties();
/**
* 変更フラグ
*/
private boolean modified;
/**
* データベースとなるファイルを指定してプロパティを構築する.
* 呼び出された時点でファイルがなければ作成される.
* @param file ファイル
* @throws IOException 失敗
*/
public FileMappedProperties(File file) throws IOException {
if (file == null) {
throw new IllegalArgumentException();
}
this.file = file;
this.accessFile = new RandomAccessFile(file, "rw");
}
/**
* データベースとなるファイル
* @return データベースとなるファイル
*/
public File getFile() {
return file;
}
/**
* 変更されているか?
* putまたはremoveによって設定される.
* save、load、clearのいずれかによりリセットされる.
* @return 変更されている場合はtrue
*/
public boolean isModified() {
return modified;
}
/**
* データベースとなるファイルからプロパティを読み取り排他制御をかける.
* 以降、closeされるまで、ファイルはロックされます.
* すでに読み込まれている場合は何もしません。(ロックされているので自身以外の書き込みは想定しないため).
* @throws IOException 失敗
*/
public void load() throws IOException {
checkOpen();
if (channel != null) {
// すでにロード済みと見なす.
return;
}
props.clear();
channel = accessFile.getChannel();
channel.lock(); // 全域に排他ロック
int siz = (int) channel.size();
if (siz == 0) {
// 空なので読み込まない.
return;
}
byte[] data = new byte[siz];
ByteBuffer buf = ByteBuffer.wrap(data);
channel.read(buf);
InputStream bis = new ByteArrayInputStream(data);
try {
props.loadFromXML(bis);
} finally {
bis.close();
}
}
@Override
public void clear() {
super.clear();
modified = false;
}
/**
* 現在のプロパティの内容をファイルに書き戻します.
* ファイルがロックされていない場合はロックされ、以降、closeされるまでロックを維持します.
* 呼び出される都度、ファイルを一括更新します.
* @throws IOException 失敗
*/
public void save() throws IOException {
checkOpen();
if (channel == null) {
channel = accessFile.getChannel();
channel.lock(); // 全域に排他ロック
}
channel.position(0); // 先頭に戻す.
ByteArrayOutputStream bos = new ByteArrayOutputStream();
try {
String comment = file.getName().toString() + " "
+ new Timestamp(System.currentTimeMillis());
props.storeToXML(bos, comment);
} finally {
bos.close();
}
byte[] data = bos.toByteArray();
ByteBuffer buf = ByteBuffer.wrap(data);
channel.write(buf);
channel.truncate(data.length);
modified = false;
}
/**
* ファイルを閉じます.
* ロックされている場合はロックが解除されます.
* 未保存のプロパティは保存されません.
* @throws IOException 失敗
*/
public void close() throws IOException {
if (channel != null) {
channel.close();
channel = null;
}
if (accessFile != null) {
accessFile.close();
accessFile = null;
}
}
@Override
protected void finalize() throws Throwable {
close(); // 念のため
}
@Override
public String put(String key, String value) {
checkOpen();
String oldValue = (String) props.setProperty(key, value);
// 変更チェック
if (value != oldValue) {
if (value == null || oldValue == null || !value.equals(oldValue)) {
// 双方がnullでなく、いずれか一方がnullであるか、equalsが一致しない場合は変更あり.
modified = true;
}
}
return oldValue;
}
@Override
public Set> entrySet() {
final Set> entrySet = props.entrySet();
return new AbstractSet>() {
@Override
public Iterator> iterator() {
final Iterator> ite = entrySet.iterator();
return new Iterator>() {
public boolean hasNext() {
return ite.hasNext();
}
public Map.Entry next() {
final Entry entry = ite.next();
return new Map.Entry() {
public String getKey() {
return (String) entry.getKey();
}
public String getValue() {
return (String) entry.getValue();
}
public String setValue(String value) {
checkOpen();
return (String) entry.setValue(value);
}
};
}
public void remove() {
checkOpen();
modified = true;
ite.remove();
}
};
}
@Override
public int size() {
return entrySet.size();
}
};
}
protected void checkOpen() {
if (accessFile == null) {
throw new IllegalStateException("file is already closed." + file);
}
}
}
charactermanaj/src/charactermanaj/util/LocalizedResourceTextLoader.java 0000644 0001750 0001750 00000006033 11767047543 026735 0 ustar paulliu paulliu package charactermanaj.util;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.nio.charset.Charset;
import java.util.Locale;
/**
* リソースからローカライズされたテキストを取得する.
* @author seraphy
*
*/
public class LocalizedResourceTextLoader extends ResourceLoader {
private static final LocalizedResourceTextLoader inst = new LocalizedResourceTextLoader();
private LocalizedResourceTextLoader() {
super();
}
public static LocalizedResourceTextLoader getInstance() {
return inst;
}
/**
* リソース名を指定して、テキストファイルを読み込んで、その文字列を返す.
* リソースは現在のデフォルトロケールを優先で検索されます.
* ファイルエンコーディングを引数csで指定する.
* @param name リソース名
* @param cs ファイルのエンコーディング
* @return ファイルの内容(テキスト)
*/
public String getText(String name, Charset cs) {
return getText(name, cs, Locale.getDefault());
}
public String getText(String name, Charset cs, Locale locale) {
if (name == null || name.length() == 0 || cs == null || locale == null) {
throw new IllegalArgumentException();
}
String language = locale.getLanguage();
String country = locale.getCountry();
String variant = locale.getVariant();
int extpos = name.lastIndexOf(".");
int folderpos = name.lastIndexOf("/");
String basename;
String ext;
if (folderpos > extpos) {
basename = name;
ext = "";
} else {
basename = name.substring(0, extpos);
ext = name.substring(extpos);
}
String[] resourceNamesStr = {
basename + "_" + language + "_" + country + "_" + variant + ext,
basename + "_" + language + "_" + country + ext,
basename + "_" + language + ext,
basename + ext,
};
ResourceNames resourceNames = new ResourceNames(resourceNamesStr);
String text = loadText(resourceNames, cs);
if (text == null) {
throw new RuntimeException("resource not found: " + resourceNames);
}
return text;
}
protected String loadText(ResourceNames resourceNames, Charset cs) {
if (resourceNames == null || cs == null) {
throw new IllegalArgumentException();
}
for (String resourceName : resourceNames) {
URL url = getResource(resourceName);
if (url == null) {
continue;
}
StringBuilder buf = new StringBuilder();
try {
InputStream is = url.openStream();
try {
BufferedReader rd = new BufferedReader(new InputStreamReader(is, cs));
try {
int ch;
while ((ch = rd.read()) != -1) {
buf.append((char) ch);
}
} finally {
rd.close();
}
} finally {
is.close();
}
} catch (IOException ex) {
throw new RuntimeException("resource loading error: " + ex, ex);
}
return buf.toString();
}
return null;
}
}
charactermanaj/src/charactermanaj/util/LocalizedResourcePropertyLoader.java 0000644 0001750 0001750 00000012447 11767047543 027643 0 ustar paulliu paulliu package charactermanaj.util;
import java.io.InputStream;
import java.net.URL;
import java.util.HashMap;
import java.util.Locale;
import java.util.Properties;
/**
* xml形式のリソース上のプロパティファイルのローカライズされた読み込みを行うためのクラス.
* リソースは、単純名、言語名を末尾に付与したもの、言語名と国を末尾に付与したもの、言語名と国とバリアントを末尾に付与したもの、の順で読み取られる.
* 順番に読み込んで重ね合わせる.
* 一度読み込んだものはキャッシュされ次回以降は読み取られない.
*/
public class LocalizedResourcePropertyLoader extends ResourceLoader {
/**
* プロパティファイル群と、それに対するキャッシュ
*/
private HashMap propCache = new HashMap();
/**
* シングルトンインスタンス
*/
private static final LocalizedResourcePropertyLoader inst = new LocalizedResourcePropertyLoader();
/**
* プライベートコンストラクタ
*/
private LocalizedResourcePropertyLoader() {
super();
}
/**
* インスタンスを取得する
* @return インスタンス
*/
public static LocalizedResourcePropertyLoader getInstance() {
return inst;
}
/**
* リソース名を指定してデフォルトのロケールでローカライズされたリソースプロパティを読み込む.
* リソースはxml形式である。リソース名には.xmlを付与しない.(自動的に内部で付与される.)
* @param name リソース名
* @return プロパティ
*/
public Properties getLocalizedProperties(String name) {
return getLocalizedProperties(name, null);
}
/**
* リソース名を指定して指定したロケールでローカライズされたリソースプロパティを読み込む.
* リソースはxml形式である。リソース名には.xmlを付与しない.(自動的に内部で付与される.)
* @param name リソース名
* @param locale ロケール、nullの場合はデフォルトのロケール
* @return プロパティ
*/
public Properties getLocalizedProperties(String name, Locale locale) {
if (name == null || name.length() == 0) {
throw new IllegalArgumentException();
}
if (locale == null) {
locale = Locale.getDefault();
}
String language = locale.getLanguage();
String country = locale.getCountry();
String variant = locale.getVariant();
String[] resourceNames = {
name + ".xml",
name + "_" + language + ".xml",
name + "_" + language + "_" + country + ".xml",
name + "_" + language + "_" + country + "_" + variant + ".xml",
};
return getProperties(new ResourceNames(resourceNames));
}
/**
* リソース名群をもとにキャッシュもしくはプロパティをロードして返す.
* キャッシュされていない場合はプロパティをロードして、それをキャッシュに格納する.
* リソースが一つも存在しない場合は実行時例外を発生させる.
* @param resourceNames リソース名群
* @return プロパティ
*/
protected Properties getProperties(ResourceNames resourceNames) {
if (resourceNames == null) {
throw new IllegalArgumentException();
}
Properties prop;
synchronized (propCache) {
prop = propCache.get(resourceNames);
if (prop == null) {
prop = loadProperties(resourceNames);
propCache.put(resourceNames, prop);
}
}
if (prop == null) {
throw new RuntimeException("missing resource: " + resourceNames);
}
return prop;
}
/**
* リソース名群からリソースプロパティをロードして返す.
* 一つも存在しない場合はnullを返す.
* @param resourceNames リソース群名
* @return プロパティ
*/
protected Properties loadProperties(ResourceNames resourceNames) {
if (resourceNames == null) {
throw new IllegalArgumentException();
}
// システム埋め込みリソースでプロパティを取得したのちに、ユーザ指定のプロパティの内容で上書きする.
// バージョンアップによりキーが増えて、既存のローカルファイル上のプロパティファイルにキーが存在しない場合でも
// 安全なようにするためのもの。
ClassLoader[] loaders = new ClassLoader[] {
getDefaultClassLoader(),
getLocalizedClassLoader(null),
};
boolean foundResource = false;
Properties props = new Properties();
for (ClassLoader loader : loaders) {
if (loader == null) {
continue;
}
for (String resourceName : resourceNames) {
URL resource = loader.getResource(resourceName);
if (resource != null) {
Properties org = new Properties();
try {
InputStream is = resource.openStream();
try {
org.loadFromXML(is);
} finally {
is.close();
}
} catch (Exception ex) {
throw new RuntimeException("resource loading error." + resource, ex);
}
foundResource = true;
props.putAll(org);
}
}
}
if (foundResource) {
return props;
}
return null;
}
}
charactermanaj/src/charactermanaj/util/BeanPropertiesUtilities.java 0000644 0001750 0001750 00000015104 11767047543 026140 0 ustar paulliu paulliu package charactermanaj.util;
import java.awt.Color;
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.HashSet;
import java.util.Properties;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* Setter/Getterのペアをもつビーンのプロパティを文字列化してプロパティに設定するか、
* プロパティからビーンに値を設定するためのユーテリティクラス.
* @author seraphy
*/
public final class BeanPropertiesUtilities {
private static final Logger logger = Logger.getLogger(BeanPropertiesUtilities.class.getName());
private BeanPropertiesUtilities() {
throw new RuntimeException("utilities class.");
}
/**
* ビーンのSetter/Getterのペアをもつプロパティに対して、Propertiesより該当するプロパティの値を
* 読み取り、プロパティに設定します.
* Propertiesに該当するプロパティ名が設定されていなければスキップされます.
* Propertiesにビーンにないプロパティ名があった場合、それは単に無視されます.
* Propertyの値が空文字の場合、Beanのプロパティの型が文字列以外であればnullが設定されます.
* (文字列の場合、空文字のまま設定されます.書き込み時、nullは空文字にされるため、文字列についてはnullを表現することはできません。)
* @param bean 設定されるビーン
* @param props プロパティソース
* @return 値の設定を拒否されたプロパティの名前、エラーがなければ空
*/
public static Set loadFromProperties(Object bean, Properties props) {
if (bean == null || props == null) {
throw new IllegalArgumentException();
}
HashSet rejectNames = new HashSet();
try {
BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
for (PropertyDescriptor propDesc : beanInfo
.getPropertyDescriptors()) {
Class typ = propDesc.getPropertyType();
Method mtdReader = propDesc.getReadMethod();
Method mtdWriter = propDesc.getWriteMethod();
if (mtdReader != null && mtdWriter != null) {
// 読み書き双方が可能なもののみ対象とする.
String name = propDesc.getName();
String strVal = props.getProperty(name);
if (strVal == null) {
// 設定がないのでスキップ
continue;
}
Object val;
Throwable reject = null;
try {
if (String.class.equals(typ)) {
val = strVal;
} else if (strVal.length() == 0) {
val = null;
} else {
if (Boolean.class.equals(typ) || boolean.class.equals(typ)) {
val = Boolean.valueOf(strVal);
} else if (Integer.class.equals(typ) || int.class.equals(typ)) {
val = Integer.valueOf(strVal);
} else if (Long.class.equals(typ) || long.class.equals(typ)) {
val = Long.valueOf(strVal);
} else if (Float.class.equals(typ) || float.class.equals(typ)) {
val = Float.valueOf(strVal);
} else if (Double.class.equals(typ) || double.class.equals(typ)) {
val = Double.valueOf(strVal);
} else if (BigInteger.class.equals(typ)) {
val = new BigInteger(strVal);
} else if (BigDecimal.class.equals(typ)) {
val = new BigDecimal(strVal);
} else if (Color.class.equals(typ)) {
val = Color.decode(strVal);
} else {
rejectNames.add(name);
logger.log(Level.WARNING,
"unsupported propery type: " + typ
+ "/beanClass=" + bean.getClass() + " #" + name);
continue;
}
}
mtdWriter.invoke(bean, val);
reject = null;
} catch (InvocationTargetException ex) {
reject = ex;
} catch (IllegalAccessException ex) {
reject = ex;
} catch (RuntimeException ex) {
reject = ex;
}
if (reject != null) {
rejectNames.add(name);
logger.log(Level.WARNING, "invalid propery: "
+ typ + "/beanClass="
+ bean.getClass() + " #" + name + " /val=" + strVal
, reject);
}
}
}
} catch (IntrospectionException ex) {
throw new RuntimeException("bean intorospector failed. :" + bean.getClass(), ex);
}
return rejectNames;
}
/**
* ビーンのSetter/Getterのペアをもつプロパティの各値をPropertiesに文字列として登録します.
* nullの場合は空文字が設定されます.
* @param bean プロパティに転送する元情報となるビーン
* @param props 設定されるプロパティ
*/
public static void saveToProperties(Object bean, Properties props) {
if (bean == null || props == null) {
throw new IllegalArgumentException();
}
try {
BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
for (PropertyDescriptor propDesc : beanInfo.getPropertyDescriptors()) {
Method mtdReader = propDesc.getReadMethod();
Method mtdWriter = propDesc.getWriteMethod();
if (mtdReader != null && mtdWriter != null) {
// 読み書き双方が可能なもののみ対象とする.
String name = propDesc.getName();
Object val = mtdReader.invoke(bean);
String strVal;
if (val == null) {
strVal = "";
} else if (val instanceof String) {
strVal = (String) val;
} else if (val instanceof Number) {
strVal = ((Number) val).toString();
} else if (val instanceof Boolean) {
strVal = ((Boolean) val).booleanValue() ? "true" : "false";
} else if (val instanceof Color) {
strVal = "#" + Integer.toHexString(((Color) val).getRGB() & 0xffffff);
} else {
logger.log(Level.WARNING, "unsupported propery type: "
+ val.getClass() + "/beanClass="
+ bean.getClass() + " #" + name);
continue;
}
props.setProperty(name, strVal);
}
}
} catch (IllegalAccessException ex) {
throw new RuntimeException("bean property read failed. :" + bean.getClass(), ex);
} catch (InvocationTargetException ex) {
throw new RuntimeException("bean property read failed. :" + bean.getClass(), ex);
} catch (IntrospectionException ex) {
throw new RuntimeException("bean intorospector failed. :" + bean.getClass(), ex);
}
}
}
charactermanaj/src/charactermanaj/util/LocalizedMessageAware.java 0000644 0001750 0001750 00000000653 11767047543 025520 0 ustar paulliu paulliu package charactermanaj.util;
/**
* ローカライズリソースを持っていることを示すインターフェイス.
* @author seraphy
*/
public interface LocalizedMessageAware {
/**
* ローカライズリソースのIDを取得する.
* 設定されていない場合はnullが返される.
* @return リソースID、もしくはnull
*/
String getLocalizedResourceId();
}
charactermanaj/src/charactermanaj/util/AWTExceptionLoggingHandler.java 0000644 0001750 0001750 00000002333 11767047543 026441 0 ustar paulliu paulliu package charactermanaj.util;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
import charactermanaj.ui.MainFrame;
/**
* SwingのEDT内での例外をロギングするためのハンドラ.
* @author seraphy
*/
public class AWTExceptionLoggingHandler {
/**
* ロガー
*/
private static final Logger logger = Logger.getLogger(AWTExceptionLoggingHandler.class.getName());
/**
* 例外のハンドル.
* @param ex 例外
*/
public void handle(final Throwable ex) {
// まずはロギング
logger.log(Level.SEVERE, "exception occurred on the event dispatch thread. " + ex, ex);
// エラーダイアログを表示する.(非同期)
SwingUtilities.invokeLater(new Runnable() {
public void run() {
JFrame currentFrame = MainFrame.getActivedMainFrame();
if (currentFrame == null ||
!currentFrame.isDisplayable() || !currentFrame.isVisible()) {
// メインフレームがまだ無いか、表示されていないか破棄済みであれば無いとみなす.
currentFrame = null;
}
ErrorMessageHelper.showErrorDialog(currentFrame, ex);
}
});
}
}
charactermanaj/src/charactermanaj/util/FileUserData.java 0000644 0001750 0001750 00000004435 11767047543 023637 0 ustar paulliu paulliu package charactermanaj.util;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* ファイルベースのユーザーデータの保存先の実装
* @author seraphy
*/
public class FileUserData implements UserData {
/**
* ロガー
*/
private static final Logger logger = Logger.getLogger(FileUserData.class.getName());
/**
* 保存先ファイル
*/
private File file;
public FileUserData(File file) {
if (file == null) {
throw new IllegalArgumentException();
}
this.file = file;
}
public boolean exists() {
return file.exists() && file.isFile();
}
public long lastModified() {
return file.lastModified();
}
public InputStream openStream() throws IOException {
return new BufferedInputStream(new FileInputStream(file));
}
public OutputStream getOutputStream() throws IOException {
return new BufferedOutputStream(new FileOutputStream(file));
}
public boolean delete() {
try {
return file.delete();
} catch (Exception ex) {
// セキュリティ例外ぐらい.
logger.log(Level.WARNING, "file removing failed." + file, ex);
return false;
}
}
public void save(Object userData) throws IOException {
ObjectOutputStream oos = new ObjectOutputStream(getOutputStream());
try {
oos.writeObject(userData);
oos.close();
} finally {
oos.close();
}
}
public Object load() throws IOException {
ObjectInputStream ois = new ObjectInputStream(openStream());
try {
try {
return ois.readObject();
} catch (ClassNotFoundException ex) {
// 復元先クラスがみつからないということは、このアプリケーションの保存した形式としておかしい
IOException ex2 = new IOException("invalid format.");
ex2.initCause(ex2);
throw ex2;
}
} finally {
ois.close();
}
}
@Override
public String toString() {
return "FileUserData{file:" + file + "}";
}
} charactermanaj/src/charactermanaj/util/DesktopUtilities.java 0000644 0001750 0001750 00000014274 11767047543 024636 0 ustar paulliu paulliu package charactermanaj.util;
import java.awt.Component;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URI;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.BoxLayout;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextField;
/**
* デスクトップへのアクセスを提供するユーテリティ.
* JDK6の機能を使うため、JDK5以前では何もしない.(エラーにはならない)
* @author seraphy
*/
public class DesktopUtilities {
/**
* ロガー
*/
private static final Logger logger = Logger.getLogger(DesktopUtilities.class.getName());
/**
* デスクトップオブジェクト。JDK6以降でなければ、もしくはデスクトップをサポートしていなければnull
*/
private static Object desktopObj;
/**
* ブラウズメソッド
*/
private static Method methodBrowse;
/**
* 編集メソッド
*/
private static Method methodEdit;
/**
* 開くメソッド
*/
private static Method methodOpen;
static {
try {
Class clz = Class.forName("java.awt.Desktop");
Method mtdGetDesktop = clz.getMethod("getDesktop");
methodBrowse = clz.getMethod("browse", URI.class);
methodEdit = clz.getMethod("edit", File.class);
methodOpen = clz.getMethod("open", File.class);
desktopObj = mtdGetDesktop.invoke(null);
} catch (ClassNotFoundException ex) {
// JDK6以降でない場合
logger.log(Level.CONFIG, "AWT Desktop is not suuported.");
desktopObj = null;
} catch (Exception ex) {
// その他の例外は基本的に発生しないが、発生したとしても
// 単にサポートしていないと見なして継続する.
logger.log(Level.SEVERE, "AWT Desktop failed.", ex);
desktopObj = null;
}
}
private DesktopUtilities() {
throw new RuntimeException("utilities class.");
}
public static boolean isSupported() {
return desktopObj != null;
}
protected static boolean callMethod(Method method, Object arg) throws IOException {
if (desktopObj == null) {
return false;
}
try {
if (logger.isLoggable(Level.FINER)) {
logger.log(Level.FINER, "invoke: " + method + "/arg=" + arg);
}
method.invoke(desktopObj, arg);
return true;
} catch (InvocationTargetException ex) {
Throwable iex = ex.getCause();
if (iex != null && iex instanceof IOException) {
throw (IOException) iex;
}
throw new RuntimeException(ex.getMessage(), ex);
} catch (IllegalAccessException ex) {
throw new RuntimeException(ex.getMessage(), ex);
}
}
/**
* ファイルを開く.
* @param uri ファイル
* @return サポートしていない場合はfalse、実行できればtrue。
* @throws IOException 実行できなかった場合
*/
public static boolean browse(URI uri) throws IOException {
return callMethod(methodBrowse, uri);
}
/**
* 指定したdocBaseの親ディレクトリを開く.
* @param docBase
* @return サポートしていない場合はfalse、実行できればtrue。
* @throws IOException 実行できなかった場合
*/
public static boolean browseBaseDir(URI docBase) throws IOException {
File baseDir = null;
try {
if (docBase != null) {
baseDir = new File(docBase).getParentFile();
}
} catch (Exception ex) {
baseDir = null;
}
if (baseDir == null) {
Toolkit tk = Toolkit.getDefaultToolkit();
tk.beep();
return false;
}
return DesktopUtilities.open(baseDir);
}
/**
* ファイルを編集する.
* @param file ファイル
* @return サポートしていない場合はfalse、実行できればtrue。
* @throws IOException 実行できなかった場合
*/
public static boolean edit(File file) throws IOException {
return callMethod(methodEdit, file);
}
/**
* ファイルを編集する.
* @param file ファイル
* @return サポートしていない場合はfalse、実行できればtrue。
* @throws IOException 実行できなかった場合
*/
public static boolean open(File file) throws IOException {
return callMethod(methodOpen, file);
}
/**
* ブラウザでURLを開きます.
* JDK1.6未満の場合はブラウザを開く代わりにURLと、それを説明するメッセージボックスが表示されます.
* @param parent 親フレーム、またはダイアログ
* @param url URL
* @param description ブラウズがサポートされていない場合に表示するダイアログでのURLの説明文
*/
public static void browse(final Component parent, final String url, final String description) {
try {
URI helpURI = new URI(url);
if (!DesktopUtilities.browse(helpURI) ){
// JDK5で実行中の場合
JPanel panel = new JPanel();
BoxLayout layout = new BoxLayout(panel, BoxLayout.Y_AXIS);
panel.setLayout(layout);
panel.add(new JLabel(description));
JTextField txtURL = new JTextField(url);
panel.add(txtURL);
JOptionPane.showMessageDialog(parent, panel);
}
} catch (Exception ex) {
ErrorMessageHelper.showErrorDialog(parent, ex);
}
}
/**
* ブラウザでURLを開くアクションの生成.
* エラー時はエラーダイアログが開かれる.
* 返されるアクションがとるアクションイベントは無視されるため、nullを渡しても問題ありません.
* @param parent 親フレーム、またはダイアログ
* @param url URLの文字列
* @param description ブラウズがサポートされていない場合に表示するダイアログでのURLの説明文
* @return アクション
*/
public static ActionListener createBrowseAction(final Component parent, final String url, final String description) {
return new ActionListener() {
public void actionPerformed(ActionEvent e) {
browse(parent, url, description);
}
};
}
}
charactermanaj/src/charactermanaj/util/SetupLocalization.java 0000644 0001750 0001750 00000010160 11767047543 024770 0 ustar paulliu paulliu package charactermanaj.util;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.logging.Level;
import java.util.logging.Logger;
import charactermanaj.Main;
/**
* 言語リソースを管理する.
* @author seraphy
*/
public class SetupLocalization extends ResourceLoader {
private final Logger logger = Logger.getLogger(getClass().getName());
public static final String DIRNAME_RESOURCES = "resources";
public static final String CATALOG_NAME = "/resource_list.txt";
private File baseDir;
/**
* アプリケーションデータ用ディレクトリを指定して構築する.
* @param baseDir データディレクトリ
*/
public SetupLocalization(File baseDir) {
if (baseDir == null || !baseDir.isDirectory()) {
throw new IllegalArgumentException();
}
this.baseDir = baseDir;
}
/**
* リソース一覧を取得する.
* クラスパス上の一覧を取得する汎用的な方法はないため、カタログファイルを使用する.
* {@link #CATALOG_NAME}で示されるリソース上のファイルにリソース一覧が記録されているものとする.
* @return リソース一覧(言語関連リソースのみ)
* @throws IOException 失敗
*/
protected Collection getResourceList() throws IOException {
ArrayList resources = new ArrayList();
URL listURL = Main.class.getResource(CATALOG_NAME);
InputStream is = listURL.openStream();
try {
BufferedReader rd = new BufferedReader(new InputStreamReader(is));
try {
String line;
while ((line = rd.readLine()) != null) {
line = line.trim();
if (line.startsWith("#")) {
continue;
}
resources.add(line);
}
} finally {
rd.close();
}
} finally {
is.close();
}
logger.log(Level.FINE, "resource list: " +resources);
return resources;
}
/**
* リソースをファイルにコピーする.
* @param fromURL
* @param toFile
* @throws IOException
*/
protected void copyResource(URL fromURL, File toFile) throws IOException {
logger.log(Level.INFO, "copy resource '" + fromURL + "' to '" + toFile + "'");
File dir = toFile.getParentFile();
if ( !dir.exists()) {
if ( !dir.mkdirs()) {
throw new IOException("can't create directory. " + dir);
}
}
URLConnection conn = fromURL.openConnection();
conn.setDoInput(true);
InputStream is = conn.getInputStream();
try {
long lastModified = conn.getLastModified();
OutputStream os = new FileOutputStream(toFile);
try {
byte[] buf = new byte[4096];
for (;;) {
int rd = is.read(buf);
if (rd <= 0) {
break;
}
os.write(buf, 0, rd);
}
} finally {
os.close();
}
boolean result = toFile.setLastModified(lastModified);
logger.log(Level.FINE, "setLastModified(" + toFile+ ") succeeded=" + result);
} finally {
is.close();
}
}
/**
* リソースディレクトリを返す.
* @return リソースディレクトリ
*/
public File getResourceDir() {
try {
return new File(baseDir, DIRNAME_RESOURCES).getCanonicalFile();
} catch (Exception ex) {
throw new RuntimeException(ex);
}
}
/**
* ローカルシステム上のアプリケーションデータディレクトリに言語リソースをコピーする.
* @throws IOException 失敗
*/
public void setupToLocal() throws IOException {
File toDir = getResourceDir();
ClassLoader cl = getDefaultClassLoader();
for (String resourceName : getResourceList()) {
URL url = cl.getResource(resourceName);
if (url != null) {
File toFile = new File(toDir, resourceName).getCanonicalFile();
copyResource(url, toFile);
} else {
logger.log(Level.WARNING, "missing resource: " + resourceName);
}
}
}
}
charactermanaj/src/charactermanaj/util/SystemUtil.java 0000644 0001750 0001750 00000003725 11767047543 023452 0 ustar paulliu paulliu package charactermanaj.util;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* システムクラスのためのユーテリティ.
* Findbugsの警告がうっとおしいのでリフレクションで隠す.
*
* @author seraphy
*/
public final class SystemUtil {
private static final Class clsSystem;
private static final Method garbageCollection;
private static final Method exit;
private static final int gcLoop = 3;
private static final long sleepTime = 100;
static {
try {
clsSystem = System.class;
garbageCollection = clsSystem.getMethod("gc");
exit = clsSystem.getMethod("exit", int.class);
} catch (NoSuchMethodException ex) {
throw new RuntimeException(ex.getMessage(), ex);
} catch (SecurityException ex) {
throw new RuntimeException(ex.getMessage(), ex);
}
}
private SystemUtil() {
super();
}
/**
* 数回ガベージコレクションをかける.
*/
public static void gc() {
try {
for (int i = 0; i < gcLoop; i++) {
if (i != 0) {
Thread.sleep(sleepTime);
}
garbageCollection.invoke(null);
}
} catch (InterruptedException ex) {
// 無視する.
} catch (InvocationTargetException ex) {
Throwable iex = ex.getCause();
if (iex == null) {
iex = ex;
}
throw new RuntimeException(iex.getMessage(), iex);
} catch (IllegalAccessException ex) {
throw new RuntimeException(ex.getMessage(), ex);
}
}
/**
* JVMを終了する.
* @param exitCode 終了コード
*/
public static void exit(int exitCode) {
try {
exit.invoke(null, exitCode);
} catch (InvocationTargetException ex) {
Throwable iex = ex.getCause();
if (iex == null) {
iex = ex;
}
throw new RuntimeException(iex.getMessage(), iex);
} catch (IllegalAccessException ex) {
throw new RuntimeException(ex.getMessage(), ex);
}
}
}
charactermanaj/src/charactermanaj/util/ResourceLoader.java 0000644 0001750 0001750 00000007147 11767047543 024250 0 ustar paulliu paulliu package charactermanaj.util;
import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.security.PrivilegedExceptionAction;
/**
* リソースをロードするための抽象基底クラス.
* @author seraphy
*/
public abstract class ResourceLoader {
/**
* クラスローダを取得する.
* まずローカルファイル上のリソースディレクトリがあれば、それを検索する.
* つぎにスレッドに関連づけられているコンテキストクラスローダか、もしなければ、このクラスをロードしたクラスローダを用いて検索する.
* @return クラスローダ
*/
protected ClassLoader getClassLoader() {
return getLocalizedClassLoader(getDefaultClassLoader());
}
/**
* クラスローダを取得する.
* スレッドに関連づけられているコンテキストクラスローダか、もしなければ、このクラスをロードしたクラスローダを返す.
* @return クラスローダ
*/
protected ClassLoader getDefaultClassLoader() {
return AccessController.doPrivileged(new PrivilegedAction() {
public ClassLoader run() {
ClassLoader cl = Thread.currentThread().getContextClassLoader();
if (cl == null) {
cl = ResourceLoader.class.getClassLoader();
}
return cl;
}
});
}
/**
* ローカルファイル上のリソースディレクトリにアクセスするクラスローダ取得する.
* 作成されていなければparentをそのまま返す.
* リソースはローカルファイル上のパスで検索されたのちにparentで検索されます.(標準のURLClassLoaderとは違う探索方法)
* @param parent 親クラスローダ、nullの場合は親の探索をしない.
* @return ローカルシステム上のリソースディレクトリにアクセスするクラスローダ、なければparentのまま
*/
protected ClassLoader getLocalizedClassLoader(final ClassLoader parent) {
try {
File baseDir = ConfigurationDirUtilities.getUserDataDir();
SetupLocalization localize = new SetupLocalization(baseDir);
final File resourceDir = localize.getResourceDir();
if (!resourceDir.exists() || !resourceDir.isDirectory()) {
return parent;
}
URLClassLoader cl = AccessController.doPrivileged(new PrivilegedExceptionAction() {
public URLClassLoader run() throws MalformedURLException {
URL[] urls = new URL[] { resourceDir.toURI().toURL() };
return new URLClassLoader(urls, parent) {
@Override
public URL getResource(String name) {
URL url = findResource(name); // 子が優先 (標準と逆)
if (url == null) {
ClassLoader parent = getParent();
if (parent != null) {
url = parent.getResource(name);
}
}
return url;
}
};
}
});
return cl;
} catch (Exception ex) {
ex.printStackTrace();
return null;
}
}
/**
* クラスローダによりリソースをロードする.
* 該当するリソースが存在しない場合はnullを返す.
* リソース名がnullの場合もnullを返す.
* @param name リソース名またはnull
* @return リソースがあれば、そのURL。なければnull
*/
protected URL getResource(String name) {
if (name == null) {
return null;
}
return getClassLoader().getResource(name);
}
}
charactermanaj/src/charactermanaj/util/ApplicationLogHandler.java 0000644 0001750 0001750 00000010422 11767047543 025523 0 ustar paulliu paulliu package charactermanaj.util;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import charactermanaj.model.AppConfig;
/**
* このアプリケーションの活動を記録するログハンドラ.
* アプリケーション用のディレクトリのlogsフォルダ下に開始日時のファイル名をもつログファイルを作成し、ログを記録する.
* ただし、終了時、警告以上のログが一度も書き込まれなかった場合はログファィルは自動的に削除される.
*
* @author seraphy
*/
public class ApplicationLogHandler extends Handler {
private static final String LOGS_DIR = "logs";
private final Object lock = new Object();
private final File logFile;
private PrintWriter pw;
private boolean notRemove;
public ApplicationLogHandler() {
File appDir = ConfigurationDirUtilities.getUserDataDir();
File logsDir = new File(appDir, LOGS_DIR);
if (!logsDir.exists()) {
if (!logsDir.mkdirs()) {
// ログ記録場所が作成できていないのでコンソールに出すしかない.
System.err.println("can't create the log directory. " + logsDir);
}
}
String fname = getCurrentTimeForFileName() + ".log";
logFile = new File(logsDir, fname);
PrintWriter tmp;
try {
tmp = new PrintWriter(new OutputStreamWriter(new FileOutputStream(logFile)));
} catch (Exception ex) {
ex.printStackTrace(); // ロガーが失敗しているので、この失敗はコンソールに出すしかない。
tmp = null;
}
this.pw = tmp;
}
@Override
public void close() throws SecurityException {
synchronized (lock) {
// 終了時にAppConfigにアクセスする.
// (アプリケーションの終了時にアクセスすることで初期化タイミングの問題を避ける.)
try {
AppConfig appConfig = AppConfig.getInstance();
if (appConfig.isNoRemoveLog()) {
notRemove = true;
}
} catch (Exception ex) {
// なんらかのアクセスに失敗した場合でも継続できるようにする.
// ロガーが閉じられようとしているので、pwに直接出力する
notRemove = true;
try {
if (pw != null) {
ex.printStackTrace(pw);
}
} catch (Exception iex) {
iex.printStackTrace(); // コンソールに出す他ない
}
}
if (pw != null) {
pw.close();
pw = null;
}
if (logFile != null && !notRemove) {
// 警告未満のログしかない場合はログファイルは毎回削除する.
if (!logFile.delete()) {
System.err.println("can't delete file. " + logFile);
}
}
}
}
@Override
public void flush() {
synchronized (lock) {
if (pw != null) {
pw.flush();
}
}
}
@Override
public void publish(LogRecord record) {
if (record == null) {
return;
}
// メッセージの記録
synchronized (lock) {
if (pw == null) {
return;
}
Level lv = record.getLevel();
String name = record.getLoggerName();
pw.println("#" + getCurrentTime() + " " + name + " "
+ lv.getLocalizedName() + " " + record.getMessage());
// 例外があれば、例外の記録
Throwable tw = record.getThrown();
if (tw != null) {
tw.printStackTrace(pw); // 例外のコールスタックをロガーに出力
}
// フラッシュする.(随時、ファイルの中身を見ることができるように.)
pw.flush();
// 警告以上であれば終了時にファイルを消さない
if (lv.intValue() >= Level.WARNING.intValue()) {
notRemove = true;
}
}
}
public String getCurrentTime() {
Timestamp tm = new Timestamp(System.currentTimeMillis());
SimpleDateFormat dt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
return dt.format(tm);
}
public String getCurrentTimeForFileName() {
Timestamp tm = new Timestamp(System.currentTimeMillis());
SimpleDateFormat dt = new SimpleDateFormat("yyyy-MM-dd_HHmmssSSS");
return dt.format(tm);
}
}
charactermanaj/src/charactermanaj/util/ConfigurationDirUtilities.java 0000644 0001750 0001750 00000013515 11767047543 026470 0 ustar paulliu paulliu package charactermanaj.util;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.security.CodeSource;
import java.security.ProtectionDomain;
import java.util.logging.Level;
import java.util.logging.Logger;
import charactermanaj.Main;
/**
* アプリケーションの設定ファイル等の位置を取得するユーテリティクラス.
* Mainクラスのロード時に最も早くロードされるであろうクラスの一つである.
* @author seraphy
*/
public final class ConfigurationDirUtilities {
public static final String CONFIGURATION_DIR_NAME = "CharacterManaJ";
private static File userDataDir;
private static File applicationBaseDir;
private ConfigurationDirUtilities() {
throw new RuntimeException("utilities class.");
}
/**
* ユーザーごとのアプリケーションデータ保存先を取得する.
* 環境変数「APPDATA」もしくはシステムプロパティ「appdata.dir」からベース位置を取得する.
* いずれも設定されておらず、Mac OS Xであれば「~/Library」をベース位置とする。
* Mac OS Xでなければ「~/」をベース位置とする.
* これに対してシステムプロパティ「characterdata.dirname」(デフォルトは「CharacterManaJ」)という
* フォルダをユーザー毎のアプリケーションデータの保存先ディレクトリとする.
*/
public synchronized static File getUserDataDir() {
if (userDataDir == null) {
String appData = null;
// システムプロパティ「appdata.dir」を探す
appData = System.getProperty("appdata.dir");
if (appData == null) {
// なければ環境変数APPDATAを探す
// Windows2000/XP/Vista/Windows7には存在する.
appData = System.getenv("APPDATA");
}
if (appData == null && Main.isMacOSX()) {
// システムプロパティも環境変数にも設定がなく、実行環境がMac OS Xであれば
// ~/Libraryをベースにする.(Mac OS Xならば必ずある。)
appData = new File(System.getProperty("user.home"), "Library").getPath();
}
if (appData == null) {
// なければシステムプロパティ「user.home」を使う
// このプロパティは必ず存在する.
appData = System.getProperty("user.home");
}
// システムプロパティ「characterdata.dirname」のディレクトリ名、なければ「CharacterManaJ」を設定する.
String characterDirName = System.getProperty("characterdata.dirname", CONFIGURATION_DIR_NAME);
userDataDir = new File(appData, characterDirName).getAbsoluteFile();
// ディレクトリを準備する.
if (!userDataDir.exists()) {
if (!userDataDir.mkdirs()) {
// ログ保管場所も設定されていないのでコンソールに出すしかない.
System.err.println("can't create the user data directory. " + userDataDir);
}
}
}
return userDataDir;
}
/**
* アプリケーションディレクトリを取得する.
* このクラスをコードソースから、ベースとなる位置を割り出す.
* クラスが格納されているクラスパスのフォルダか、JARに固められている場合は、そのJARファイルの、その親ディレクトリを指し示す.
* このクラスのプロテクションドメインのコードソースがnullでコードの位置が取得できないか、
* コードの位置を示すURLがファイルプロトコルでない場合は実行時例外が返される.
* ただし、システムプロパティ「appbase.dir」が明示的に設定されていれば、それが優先される.
*/
public synchronized static File getApplicationBaseDir() {
if (applicationBaseDir == null) {
String appbaseDir = System.getProperty("appbase.dir");
if (appbaseDir != null && appbaseDir.length() > 0) {
// 明示的にアプリケーションベースディレクトリが指定されている場合.
try {
applicationBaseDir = new File(appbaseDir).getCanonicalFile();
} catch (IOException ex) {
ex.printStackTrace();
// 継続する.まだログの準備ができていない可能性が高いので標準エラー出力へ.
}
}
if (applicationBaseDir == null) {
// 明示的に指定されていない場合はコードの実行位置から割り出す.
ProtectionDomain pdomain = ConfigurationDirUtilities.class.getProtectionDomain();
CodeSource codeSource = pdomain.getCodeSource();
if (codeSource == null) {
throw new RuntimeException("codeSource is null: domain=" + pdomain);
}
URL codeBaseUrl = codeSource.getLocation();
if (!codeBaseUrl.getProtocol().equals("file")) {
throw new RuntimeException("codeLocation is not file protocol.: " + codeBaseUrl);
}
// クラスパスフォルダ、またはJARファイルの、その親
applicationBaseDir = new File(codeBaseUrl.getPath()).getParentFile();
}
}
return applicationBaseDir;
}
/**
* デフォルトのユーザー固有のキャラクターデータディレクトリを取得する.
* ユーザー固有のキャラクターディレクトリがまだ存在しない場合は作成される.
* @return ユーザー固有のキャラクターデータディレクトリ
*/
public static File getDefaultCharactersDir() {
Logger logger = Logger.getLogger(ConfigurationDirUtilities.class.getName());
File characterBaseDir = new File(ConfigurationDirUtilities.getUserDataDir(), "characters");
if (!characterBaseDir.exists()) {
if (!characterBaseDir.mkdirs()) {
logger.log(Level.WARNING, "can't create the charatcer base directory. " + characterBaseDir);
}
}
return characterBaseDir;
}
}
charactermanaj/src/charactermanaj/util/UserData.java 0000644 0001750 0001750 00000002566 11767047543 023042 0 ustar paulliu paulliu package charactermanaj.util;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
* ユーザーデータの保存先
* @author seraphy
*/
public interface UserData {
/**
* データを開く
* @return 入力ストリーム
* @throws IOException 開けなかった場合
*/
InputStream openStream() throws IOException;
/**
* データを書き込む
* @return 出力ストリーム
* @throws IOException 開けなかった場合
*/
OutputStream getOutputStream() throws IOException;
/**
* 更新日時(エポックタイム)、まだ存在しない場合は0
* @return 更新日時
*/
long lastModified();
/**
* 存在するか?
* @return 存在すればtrue
*/
boolean exists();
/**
* 削除する.
* すでに存在しない場合は何もしない.
* @return 削除された場合はtrue
*/
boolean delete();
/**
* 引数に指定したオブジェクトをシリアライズします.
* @param obj オブジェクト
* @throws IOException 保存できなかった場合
*/
void save(Object obj) throws IOException;
/**
* オブジェクトをデシリアライズして返します.
* @return オブジェクト
* @throws IOException 取得できなかった場合
*/
Object load() throws IOException;
}
charactermanaj/src/charactermanaj/util/UIHelper.java 0000644 0001750 0001750 00000013512 11767047543 023000 0 ustar paulliu paulliu package charactermanaj.util;
import java.awt.Component;
import java.awt.Container;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import javax.imageio.ImageIO;
import javax.swing.AbstractButton;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JMenu;
public final class UIHelper extends ResourceLoader {
private static final UIHelper singleton = new UIHelper();
private UIHelper() {
super();
}
public static final UIHelper getInstance() {
return singleton;
}
/**
* 指定したコンテナに含まれる指定したコンポーネント型のすべてのコンポーネントを返す.
* 一つも該当するものがなければ空を返す
* @param 対象のコンポーネントのクラス型
* @param clz クラス
* @param container 対象のコンテナ
* @return コンポーネントのコレクション、もしくは空
*/
@SuppressWarnings("unchecked")
public Collection getDescendantOfClass(Class clz, Container container) {
if (container == null || clz == null) {
throw new IllegalArgumentException();
}
Collection components = new ArrayList();
getDescendantOfClass(clz, container, components);
return (Collection) components;
}
private void getDescendantOfClass(Class clz, Container container, Collection results) {
if (container == null) {
return;
}
Component[] children = (container instanceof JMenu) ?
((JMenu) container).getMenuComponents() : container.getComponents();
int mx = children.length;
for (int idx = 0; idx < mx; idx++) {
Component comp = children[idx];
if (clz.isInstance(comp)) {
results.add(comp);
} else if (comp instanceof Container) {
getDescendantOfClass(clz, (Container) comp, results);
}
}
}
/**
* 2つのステートをもつアイコンを作成します.
* このアイコンは、使用するコンポーネントがAbstractButton派生クラスであれば、isSelectedの結果が
* trueである場合は2番目のアイコンイメージを表示します.
* isSelectedの結果がfalseであるか、もしくはAbstractButton派生クラスでなければ
* 最初のアイコンイメージを表示します.
* @param iconName1 アイコン1
* @param iconName2 アイコン2
* @return アイコン
*/
public Icon createTwoStateIcon(String iconName1, String iconName2) {
if (iconName1 == null || iconName2 == null || iconName1.length() == 0
|| iconName2.length() == 0) {
throw new IllegalArgumentException();
}
final BufferedImage pinIcon1 = getImage(iconName1);
final BufferedImage pinIcon2 = getImage(iconName2);
Icon icon = new Icon() {
public void paintIcon(Component c, Graphics g, int x, int y) {
boolean selected = false;
if (c instanceof AbstractButton) {
AbstractButton btn = (AbstractButton) c;
selected = btn.isSelected();
}
BufferedImage iconImage;
if ( !selected) {
iconImage = pinIcon1;
} else {
iconImage = pinIcon2;
}
int w = iconImage.getWidth();
int h = iconImage.getHeight();
g.drawImage(iconImage, x, y, w, h, 0, 0, w, h, null);
}
public int getIconHeight() {
return pinIcon1.getHeight();
}
public int getIconWidth() {
return pinIcon1.getWidth();
}
};
return icon;
}
/**
* アイコンボタン(非透過)を作成して返す.
* リソースが取得できない場合は実行時例外が返される.
* @param iconName 画像リソース名
* @return アイコンボタン
*/
public JButton createIconButton(String iconName) {
if (iconName == null || iconName.length() == 0) {
throw new IllegalArgumentException();
}
JButton btn = new JButton();
btn.setIcon(new ImageIcon(getImage(iconName)));
return btn;
}
/**
* 通常時の画像のみをもつ透過ボタンを作成して返す.
* リソースが取得できない場合は実行時例外が返される.
* @param normal 通常時の画像リソース
* @return 透過ボタン
*/
public JButton createTransparentButton(String normal) {
return createTransparentButton(normal, null);
}
/**
* リソースから通常とホバー時の画像をもつ透過ボタンを作成して返す.
* リソースが取得できない場合は実行時例外が返される.
* @param normal 通常時の画像リソース
* @param rollover ホバー時の画像リソース
* @return 透過ボタン
*/
public JButton createTransparentButton(String normal, String rollover) {
if (normal == null || normal.length() == 0) {
throw new IllegalArgumentException();
}
ImageIcon normIcon = new ImageIcon(getImage(normal));
JButton btn = new JButton(normIcon);
if (rollover != null && rollover.length() != 0) {
ImageIcon rolloverIcon = new ImageIcon(getImage(rollover));
btn.setRolloverEnabled(true);
btn.setRolloverIcon(rolloverIcon);
btn.setPressedIcon(rolloverIcon);
}
btn.setOpaque(false);
btn.setBorderPainted(false);
btn.setContentAreaFilled(false);
return btn;
}
/**
* リソースから画像を取得する.
* 画像が取得できない場合は実行時例外を返す.
* @param name リソース
* @return 画像
*/
public BufferedImage getImage(String name) {
URL url = getResource(name);
if (url == null) {
throw new RuntimeException("resource not found. " + name);
}
try {
return ImageIO.read(url);
} catch (IOException ex) {
throw new RuntimeException("image load error." + ex.getMessage(), ex);
}
}
}
charactermanaj/src/charactermanaj/util/ErrorMessageHelper.java 0000644 0001750 0001750 00000003556 11767047543 025070 0 ustar paulliu paulliu package charactermanaj.util;
import java.awt.Component;
import java.awt.Dimension;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
/**
* 例外を表示するダイアログ.
* ログにも記録される.
* @author seraphy
*/
public final class ErrorMessageHelper {
/**
* ロガー
*/
private static final Logger logger = Logger.getLogger(ErrorMessageHelper.class.getName());
private ErrorMessageHelper() {
super();
}
/**
* 例外が発生したことを示すダイアログを表示し、ログに記録する.
* @param parent ダイアログを表示する親、null可
* @param ex 例外、nullの場合はなにもせずに戻る.
*/
public static void showErrorDialog(Component parent, Throwable ex) {
if (ex == null) {
return;
}
// ログに記録する.
logger.log(Level.SEVERE, ex.getLocalizedMessage(), ex);
// 例外を表示するパネルの生成
JTextArea textArea = new JTextArea();
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
ex.printStackTrace(pw); // 例外のコールスタックをパネルに表示できるように出力
pw.close();
textArea.setText(sw.toString());
textArea.setSelectionStart(0);
textArea.setSelectionEnd(0);
textArea.setEditable(false);
JScrollPane scr = new JScrollPane(textArea);
scr.setPreferredSize(new Dimension(400, 150));
scr.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
scr.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
// ダイアログの表示
JOptionPane.showMessageDialog(parent, scr, "ERROR", JOptionPane.ERROR_MESSAGE);
}
}
charactermanaj/src/charactermanaj/util/LocalizedMessageComboBoxRender.java 0000644 0001750 0001750 00000003610 11767047543 027325 0 ustar paulliu paulliu package charactermanaj.util;
import java.awt.Component;
import java.util.Properties;
import javax.swing.JList;
import javax.swing.plaf.basic.BasicComboBoxRenderer;
/**
* ローカライズリソースをサポートするオブジェクトをコンボボックスに表示するコンボボックスレンダー
*/
public class LocalizedMessageComboBoxRender extends BasicComboBoxRenderer {
/**
* シリアライズバージョンID
*/
private static final long serialVersionUID = 2148264299941543651L;
/**
* リソースホルダ
*/
private Properties strings;
public LocalizedMessageComboBoxRender(Properties strings) {
if (strings == null) {
throw new IllegalArgumentException();
}
this.strings = strings;
}
@Override
public Component getListCellRendererComponent(JList list, Object value,
int index, boolean isSelected, boolean cellHasFocus) {
Object localizedString = getLocalizedString(value);
return super.getListCellRendererComponent(list, localizedString, index, isSelected,
cellHasFocus);
}
/**
* ローカライズリソースIDを取得する.
* サポートしていないか、該当がなければ、toString()の結果を返す.
* @param value オブジェクト
* @return ローカライズされた文字列、もしくは通常の文字列
*/
protected String getLocalizedString(Object value) {
if (value == null) {
return "(null)";
}
if (value instanceof LocalizedMessageAware) {
LocalizedMessageAware o = (LocalizedMessageAware) value;
String id = o.getLocalizedResourceId();
String localizedString = null;
if (id != null) {
localizedString = strings.getProperty(id);
if (localizedString == null) {
return id;
}
}
if (localizedString != null) {
return localizedString;
}
}
return value.toString();
}
}
charactermanaj/src/charactermanaj/util/DirectoryConfig.java 0000644 0001750 0001750 00000001165 11767047543 024416 0 ustar paulliu paulliu package charactermanaj.util;
import java.io.File;
public class DirectoryConfig {
private static final DirectoryConfig inst = new DirectoryConfig();
private File charactersDir;
private DirectoryConfig() {
super();
}
public File getCharactersDir() {
if (charactersDir == null) {
throw new IllegalStateException("キャラクターディレクトリが設定されていません.");
}
return charactersDir;
}
public void setCharactersDir(File charactersDir) {
this.charactersDir = charactersDir;
}
public static DirectoryConfig getInstance() {
return inst;
}
}
charactermanaj/src/charactermanaj/util/UserDataFactory.java 0000644 0001750 0001750 00000033744 11767047543 024374 0 ustar paulliu paulliu package charactermanaj.util;
import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* ユーザーデータの保存先を生成するファクトリ
* @author seraphy
*/
public class UserDataFactory {
/**
* ロガー
*/
private static final Logger logger = Logger.getLogger(UserDataFactory.class.getName());
/**
* MANGLED管理ファイル名
*/
private static final String META_FILE = "mangled_info.xml";
/**
* シングルトン
*/
private static UserDataFactory inst = new UserDataFactory();
/**
* MangledNameのキャッシュ
*/
private HashMap mangledNameMap = new HashMap();
/**
* インスタンスを取得する.
* @return インスタンス
*/
public static UserDataFactory getInstance() {
return inst;
}
/**
* プライベートコンストラクタ
*/
private UserDataFactory() {
super();
}
/**
* 拡張子を含むファイル名を指定し、そのファイルが保存されるべきユーザディレクトリを判定して返す.
* nullまたは空の場合、もしくは拡張子がない場合はユーザディレクトリのルートを返します.
* フォルダがなければ作成されます.
* @param name ファイル名、もしくはnull
* @return ファィルの拡張子に対応したデータ保存先フォルダ
*/
public File getSpecialDataDir(String name) {
File userDataDir = ConfigurationDirUtilities.getUserDataDir();
if (name != null && name.length() > 0) {
int pos = name.lastIndexOf('.');
if (pos >= 0) {
String ext = name.substring(pos + 1);
if (ext.length() > 0) {
if ("ser".equals(ext)) {
userDataDir = new File(userDataDir, "caches");
} else {
userDataDir = new File(userDataDir, ext + "s");
}
}
}
}
// フォルダがなければ作成する.
if (!userDataDir.exists()) {
boolean result = userDataDir.mkdirs();
logger.log(Level.INFO, "makeDir: " + userDataDir + " /succeeded=" + result);
}
return userDataDir;
}
/**
* 指定した名前のユーザーデータ保存先を作成する.
* @param name ファイル名
* @return 保存先
*/
public UserData getUserData(String name) {
if (name == null || name.trim().length() == 0) {
throw new IllegalArgumentException();
}
return new FileUserData(new File(getSpecialDataDir(name), name));
}
/**
* docBaseごとにのハッシュ値を文字列表現化したプレフィックスをもつユーザーデータ保存先を作成する.
* docBaseのURIの圧縮を目的としており、等しいdocBaseは等しいプレフィックスによるようにしている.(暗号化が目的ではない).
* ハッシュ値はmd5の5バイトで生成されるため、既存のものと衝突した場合は末尾に数値が付与される.
* @param docBase URI、null可
* @param name ファイル名
* @return 保存先
*/
public UserData getMangledNamedUserData(URI docBase, String name) {
String mangledName = mangledNameMap.get(docBase);
if (mangledName == null) {
File storeDir = getSpecialDataDir(name);
mangledName = registerMangledName(docBase, storeDir);
mangledNameMap.put(docBase, mangledName);
}
return getUserData(mangledName + "-" + name);
}
/**
* ハッシュ化文字列のデータベースファイルをオープンし、現在の登録をすべて読み込む.
* クローズされるまでデータベースはロックされた状態となる.
* @param storeDir データベースファイルの格納フォルダ
* @return ハッシュ化文字列データベース
* @throws IOException 失敗
*/
protected FileMappedProperties openMetaFile(File storeDir) throws IOException {
File metaFile = new File(storeDir, META_FILE);
FileMappedProperties mangledProps = new FileMappedProperties(metaFile);
// ロードされていなければロードする.
// (ロードに失敗した場合は空の状態とみなして継続する.)
try {
mangledProps.load();
} catch (Exception ex) {
logger.log(Level.WARNING, "mangled database is broken."
+ mangledProps.getFile(), ex);
}
return mangledProps;
}
private static final String URI_KEY_PREFIX = "uri.";
private static final String MANGLED_NAME_PREFIX = "mangled.";
/**
* DocBaseのURIを辞書に登録し、そのハッシュ化文字列を返す.
* ハッシュの衝突を回避するための辞書ファイル「mangled_info.xml」を使用して、
* 衝突した場合は末尾に連番をふることで補正を行う.
* すでに登録済みの同じuriの場合は同じハッシュ化文字列を返す.
* @param docBase URI
* @param mangledProps 辞書ファイル
* @return ハッシュ化文字列(衝突した場合は連番が振られる)
*/
protected String registerMangledName(URI docBase, FileMappedProperties mangledProps) {
final String noAdjustedMangledName = getNoAdjustedMangledName(docBase);
String adjustedMangledName = noAdjustedMangledName;
// ハッシュ化文字列に対応するURIのリストを取得する.
// (通常は一個、まれにハッシュが衝突した場合に複数になる.)
final String mangledLookupKey = "mangled_base." + noAdjustedMangledName;
String sameMangledURIList = mangledProps.get(mangledLookupKey);
List uris;
if (sameMangledURIList != null && sameMangledURIList.length() > 0) {
// ハッシュ化文字列に対するURIのリストは空白区切りであるとみなしてリストに変換する.
uris = Arrays.asList(sameMangledURIList.split("\\s+"));
} else {
// 新規のハッシュ化文字列になる場合は空のリストとする.
uris = Collections.emptyList();
sameMangledURIList = "";
}
final String uri = docBase.toASCIIString();
final String registeredMangledName = mangledProps.get(URI_KEY_PREFIX + uri);
if (!uris.contains(uri) || registeredMangledName == null || registeredMangledName.length() == 0) {
// まだハッシュ化文字列に、そのURIが未登録の場合、
// もしくは、そのURIに対するハッシュ化文字列の索引がない場合
int pos = uris.indexOf(uri);
if (pos < 0) {
if (!uris.isEmpty()) {
// まだ未登録である場合、同じUUIDであれば末尾に数値をつける.
// (同一のUUIDがなければ末尾は付与しない)
adjustedMangledName += "_" + uris.size();
}
// 登録済みUUIDリストに追加する.
if (sameMangledURIList.length() > 0) {
sameMangledURIList += " "; // 空白区切り (URIの文字列表現では空白は含まれないため問題なし)
}
sameMangledURIList += uri;
} else {
// すでに登録済みであれば、再度、そのインデックスを使用する.
if (pos > 0) {
adjustedMangledName += "_" + pos;
}
}
// 登録
mangledProps.put(MANGLED_NAME_PREFIX + adjustedMangledName, uri); // 補正後UUIDからURIへの索引
mangledProps.put(URI_KEY_PREFIX + uri, adjustedMangledName); // URIから補正語UUIDへの索引
mangledProps.put(mangledLookupKey, sameMangledURIList); // 補正前UUIDを使用するURIリスト
} else {
// 登録済みの場合
adjustedMangledName = registeredMangledName;
}
return adjustedMangledName;
}
/**
* DocBaseのURIを辞書に登録し、そのハッシュ化文字列を返す.
* ハッシュの衝突を回避するための辞書ファイル「mangled_info.xml」を使用して、
* 衝突した場合は末尾に連番をふることで補正を行う.
* @param docBase URI
* @param storeDir 格納先ディレクトリ(格納先単位で辞書ファイルが作成される)
* @return ハッシュ化文字列(衝突した場合は連番が振られる)
*/
protected String registerMangledName(URI docBase, File storeDir) {
final String noAdjustedMangledName = getNoAdjustedMangledName(docBase);
String adjustedMangledName = noAdjustedMangledName;
FileMappedProperties mangledProps = null;
try {
mangledProps = openMetaFile(storeDir);
try {
// 名前を登録する.
adjustedMangledName = registerMangledName(docBase, mangledProps);
// 追加・変更されていたら保存する.
if (mangledProps.isModified()) {
mangledProps.save();
}
} finally {
mangledProps.close();
}
} catch (Exception ex) {
logger.log(
Level.WARNING,
"mangled database is broken." + ((mangledProps == null) ? storeDir
: mangledProps.getFile()), ex);
}
return adjustedMangledName;
}
/**
* 登録されている、すべてのハッシュ化文字列に対するURIを取得する.
* @param mangledNames ハッシュ化文字列のコレクション
* @param storeDir 格納先ディレクトリ(格納先単位で辞書ファイルが作成される)
* @param ope ハッシュ化文字列に対応するURIが発見された場合のオペレーション
*/
public Map getMangledNameMap(File storeDir) {
if (storeDir == null) {
throw new IllegalArgumentException();
}
HashMap uris = new HashMap();
FileMappedProperties mangledProps = null;
try {
mangledProps = openMetaFile(storeDir);
try {
for (Map.Entry propsEntry : mangledProps.entrySet()) {
String key = propsEntry.getKey();
String value = propsEntry.getValue();
if (key.startsWith("mangled.")) {
try {
String mangledName = key.substring(8);
URI uri = new URI(value);
if (logger.isLoggable(Level.FINEST)) {
logger.log(Level.FINEST, "registered mangled name: " + mangledName + "=" + uri);
}
uris.put(mangledName, uri);
// 現在のすべての登録をキャッシュにも格納する.
// (ただし変換できない場合は無視する)
try {
// URIはASCII変換されているため、一旦、ファイル位置に変換する.
URI docBase = new File(uri).toURI();
mangledNameMap.put(docBase, mangledName);
if (logger.isLoggable(Level.FINE)) {
logger.log(Level.FINE, "mangled-name cached. " + docBase + "=" + mangledName);
}
} catch (Exception ex) {
logger.log(Level.FINE, "mangled-name decode error." + uri, ex);
}
} catch (Exception ex) {
logger.log(Level.WARNING,
"mangled database is broken."
+ mangledProps.getFile(), ex);
}
}
}
} finally {
mangledProps.close();
}
} catch (IOException ex) {
logger.log(
Level.WARNING,
"mangled database is broken." + ((mangledProps == null) ? storeDir
: mangledProps.getFile()), ex);
} catch (RuntimeException ex) {
logger.log(
Level.WARNING,
"mangled database is broken." + ((mangledProps == null) ? storeDir
: mangledProps.getFile()), ex);
}
return uris;
}
/**
* URIのコレクションを指定して、それぞれの登録済みのハッシュ化文字列をマップとして返す.
* 登録フラグがfalseの場合、まだ登録されていないものはnullとなる.
* そうでない場合は新規に登録され、その値が設定される.
* @param uris URIのコレクション
* @param storeDir 格納先ディレクトリ(格納先単位で辞書ファイルが作成される)
* @param register 検索時に存在しなければ登録する場合はtrue
* @return URIをキーとし、ハッシュ化文字列を値とするマップ。登録されていないURIはnullが値となる.
*/
public Map getMangledNameMap(Collection uris, File storeDir, boolean register) {
if (storeDir == null) {
throw new IllegalArgumentException();
}
if (uris == null || uris.isEmpty()) {
// nullまたは空の場合は空を返す.
return Collections.emptyMap();
}
HashMap results = new HashMap();
FileMappedProperties mangledProps = null;
try {
mangledProps = openMetaFile(storeDir);
try {
for (URI uri : uris) {
if (uri == null) {
continue; // 不正uri
}
String mangledName = mangledProps.get(uri.toASCIIString());
if (mangledName == null) {
// 未登録の場合
if (register && uri != null) {
// 登録する場合
mangledName = registerMangledName(uri, mangledProps);
}
}
results.put(uri, mangledName);
}
// 登録する場合で変更があれば保存する.
if (register && mangledProps.isModified()) {
mangledProps.save();
}
} finally {
mangledProps.close();
}
} catch (Exception ex) {
logger.log(
Level.WARNING,
"mangled database is broken." + ((mangledProps == null) ? storeDir
: mangledProps.getFile()), ex);
}
return results;
}
/**
* docBaseをハッシュ値化文字列にした、補正前の文字列を返す.
* docBaseがnullの場合は空文字とみなして変換する.
* @param docBase URI、null可
* @return ハッシュ値の文字列表現
*/
private String getNoAdjustedMangledName(URI docBase) {
String docBaseStr;
if (docBase == null) {
docBaseStr = "";
} else {
docBaseStr = docBase.toString();
}
String mangledName = UUID.nameUUIDFromBytes(docBaseStr.getBytes()).toString();
if (logger.isLoggable(Level.FINEST)) {
logger.log(Level.FINEST, "mangledName " + docBase + "=" + mangledName);
}
return mangledName;
}
}
charactermanaj/src/charactermanaj/model/ 0000755 0001750 0001750 00000000000 11767047535 020602 5 ustar paulliu paulliu charactermanaj/src/charactermanaj/model/PartsColorInfo.java 0000644 0001750 0001750 00000012240 11767047535 024350 0 ustar paulliu paulliu package charactermanaj.model;
import java.io.Serializable;
import java.util.AbstractMap;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import charactermanaj.graphics.filters.ColorConvertParameter;
/**
* パーツ単位のカラーグループを含む色情報のコレクション.
* パーツは複数のレイヤーから構成されるため、レイヤーごとのカラーグループを含む色情報の集合を意味する.
* キーのセットはカテゴリに属するレイヤーに固定されており、追加・削除することはできない.
* @author seraphy
*/
public final class PartsColorInfo extends AbstractMap implements Serializable, Cloneable {
/**
* ロガー
*/
private static final Logger logger = Logger.getLogger(PartsColorInfo.class.getName());
private static final long serialVersionUID = -8639109147043912257L;
/**
* パーツが属するカテゴリのレイヤー構成に対する色情報のマップ.
*/
private HashMap colorInfoMap = new HashMap();
/**
* カテゴリ
*/
private final PartsCategory partsCategory;
/**
* カテゴリを指定して色情報が未設定のインスタンスを構築する.
* カテゴリに属するレイヤーが初期化されている.
* @param partsCategory カテゴリ
*/
public PartsColorInfo(PartsCategory partsCategory) {
if (partsCategory == null) {
throw new IllegalArgumentException();
}
this.partsCategory = partsCategory;
init();
}
@Override
public PartsColorInfo clone() {
try {
PartsColorInfo inst = (PartsColorInfo) super.clone();
inst.colorInfoMap = new HashMap();
for (Map.Entry entry : colorInfoMap.entrySet()) {
Layer layer = entry.getKey();
ColorInfo colorInfo = entry.getValue();
inst.colorInfoMap.put(layer, colorInfo.clone());
}
return inst;
} catch (CloneNotSupportedException ex) {
throw new RuntimeException(ex);
}
}
/**
* パーツカラー情報を指定したパーツカテゴリに存在するレイヤーに正規化して返す.
* カテゴリに存在しないレイヤーの情報は破棄され、結果は有効なレイヤーのみの色情報となる.
* @param partsCategory パーツカテゴリ
* @return 正規化されたパーツカラー情報
*/
public PartsColorInfo createCompatible(PartsCategory partsCategory) {
if (partsCategory == null) {
throw new IllegalArgumentException();
}
PartsColorInfo newInfo = new PartsColorInfo(partsCategory);
newInfo.init();
for (Map.Entry entry : colorInfoMap.entrySet()) {
Layer layer = entry.getKey();
ColorInfo colorInfo = entry.getValue();
if (partsCategory.hasLayer(layer)) {
newInfo.put(layer, colorInfo.clone());
} else {
logger.log(Level.INFO, "missing layer '" + layer + "' in " + partsCategory);
}
}
return newInfo;
}
/**
* 2つのパーツカラー情報が同じであるか判定する.
* 双方がnullである場合はtrueとなります.
* いずれか一方がnullである場合はfalseとなります.
* @param a 対象1、null可
* @param b 対象2, null可
* @return 同一であればtrue、そうでなければfalse
*/
public static boolean equals(PartsColorInfo a, PartsColorInfo b) {
if (a == b) {
return true;
}
if (a == null || b == null) {
return false;
}
return a.equals(b);
}
private void init() {
for (Layer layer : partsCategory.getLayers()) {
colorInfoMap.put(layer, createColorInfo(layer));
}
}
protected ColorInfo createColorInfo(Layer layer) {
ColorInfo colorInfo = new ColorInfo();
colorInfo.setColorGroup(layer.getColorGroup());
colorInfo.setSyncColorGroup(layer.getColorGroup().isEnabled());
colorInfo.setColorParameter(new ColorConvertParameter());
return colorInfo;
}
public PartsCategory getPartsCategory() {
return partsCategory;
}
@Override
public Set> entrySet() {
return Collections.unmodifiableSet(colorInfoMap.entrySet());
}
/**
* カテゴリに属するレイヤーの色情報を設定する.
* カテゴリに該当しないレイヤーを指定した場合はIllegalArgumentException例外となる.
* @param key レイヤー
* @param value 色情報
*/
@Override
public ColorInfo put(Layer key, ColorInfo value) {
if (key == null || value == null) {
throw new IllegalArgumentException();
}
if (!colorInfoMap.containsKey(key)) {
throw new IllegalArgumentException("invalid layer: " + key);
}
return colorInfoMap.put(key, value);
}
@Override
public String toString() {
StringBuilder buf = new StringBuilder();
buf.append(getClass().getSimpleName() + "@" + Integer.toHexString(System.identityHashCode(this)));
buf.append("(");
buf.append(colorInfoMap.toString());
buf.append(")");
return buf.toString();
}
}
charactermanaj/src/charactermanaj/model/PartsManageDataConverter.java 0000644 0001750 0001750 00000004252 11767047535 026334 0 ustar paulliu paulliu package charactermanaj.model;
/**
* パーツ設定情報から、パーツ管理情報に変換する.
* @author seraphy
*
*/
public class PartsManageDataConverter {
private PartsManageData partsManageData;
/**
* パーツ管理情報は自動作成される.
* @param partsSpecResolver
*/
public PartsManageDataConverter() {
this(null);
}
/**
* 書き込み先となるパーツ管理情報を指定して構築する.
* パーツ管理情報がnullの場合は自動作成される.
* @param partsManageData パーツ管理情報(書き込み先)
*/
public PartsManageDataConverter(PartsManageData partsManageData) {
if (partsManageData == null) {
this.partsManageData = new PartsManageData();
} else {
this.partsManageData = partsManageData;
}
}
/**
* パーツ管理情報を取得する.
* @return パーツ管理情報
*/
public PartsManageData getPartsManageData() {
return partsManageData;
}
/**
* パーツ識別子とパーツ設定情報を指定して、パーツ管理情報に変換して登録する.
* @param partsIdentifier パーツ識別子
* @param partsSpec パーツ設定情報(null可)
*/
public void convert(PartsIdentifier partsIdentifier, PartsSpec partsSpec) {
if (partsIdentifier == null) {
throw new IllegalArgumentException();
}
String localizedName = partsIdentifier.getLocalizedPartsName();
double version;
String downloadURL;
if (partsSpec != null) {
version = partsSpec.getVersion();
downloadURL = partsSpec.getDownloadURL();
} else {
version = 0;
downloadURL = null;
}
PartsAuthorInfo partsAuthorInfo;
if (partsSpec != null) {
partsAuthorInfo = partsSpec.getAuthorInfo();
} else {
partsAuthorInfo = null;
}
PartsManageData.PartsVersionInfo versionInfo = new PartsManageData.PartsVersionInfo();
versionInfo.setDownloadURL(downloadURL);
versionInfo.setVersion(version);
PartsManageData.PartsKey partsKey = new PartsManageData.PartsKey(partsIdentifier);
partsManageData.putPartsInfo(partsKey, localizedName, partsAuthorInfo, versionInfo);
}
}
charactermanaj/src/charactermanaj/model/PartsAuthorInfo.java 0000644 0001750 0001750 00000001106 11767047535 024533 0 ustar paulliu paulliu package charactermanaj.model;
import java.io.Serializable;
/**
* パーツの作者情報
* @author seraphy
*/
public class PartsAuthorInfo implements Serializable {
private static final long serialVersionUID = -5308326806956816225L;
private String author;
private String homePage;
public String getAuthor() {
return author;
}
public String getHomePage() {
return homePage;
}
public void setAuthor(String author) {
this.author = author;
}
public void setHomePage(String homePage) {
this.homePage = homePage;
}
}
charactermanaj/src/charactermanaj/model/Layer.java 0000644 0001750 0001750 00000010201 11767047535 022513 0 ustar paulliu paulliu package charactermanaj.model;
import java.io.File;
import java.io.Serializable;
/**
* レイヤー情報.
* 重ね合わせ順による比較が可能.
* immutableなクラスであり、構築された後に変更されることはない.
* 同値であるかは、ID、順序、Dirのみで判断され、それ以外の情報は無視される.
* @author seraphy
*/
public final class Layer implements Comparable, Serializable {
private static final long serialVersionUID = -6437516046486547811L;
/**
* 重ね合わせ順
*/
private final int order;
/**
* レイヤー識別名
*/
private final String id;
/**
* レイヤー表示名
*/
private final String localizedName;
/**
* カラーグループ
*/
private final ColorGroup colorGroup;
/**
* カラーグループ同期(初期)
*/
private final boolean initSync;
/**
* 対象ディレクトリ
*/
private final String dir;
/**
* レイヤー情報を構築する
* @param id レイヤー識別名
* @param order 重ね合わせ順
* @param dir 対象ディレクトリ
*/
public Layer(String id, String localizedName, int order, ColorGroup colorGroup, boolean initSync, String dir) {
if (id == null || id.length() == 0 || order < 0 || dir == null) {
throw new IllegalArgumentException();
}
if (localizedName == null || localizedName.length() == 0) {
localizedName = id;
}
if (colorGroup == null) {
colorGroup = ColorGroup.NA;
}
this.id = id;
this.localizedName = localizedName;
this.order = order;
this.colorGroup = colorGroup;
this.initSync = initSync;
this.dir = dir;
}
/**
* 重ね合わせ順に比較する.
* 同順位の場合は名前・ディレクトリから順序を決める.
*/
public int compareTo(Layer o) {
int ret = order - o.order;
if (ret == 0) {
ret = id.compareTo(o.id);
}
if (ret == 0) {
File d1 = new File(dir);
File d2 = new File(o.dir);
ret = d1.compareTo(d2);
}
return ret;
}
/**
* レイヤー識別名を取得する
* @return レイヤー識別名
*/
public String getId() {
return id;
}
/**
* レイヤー表示名を取得する
* @return レイヤー表示名
*/
public String getLocalizedName() {
return localizedName;
}
/**
* 重ね合わせ順を取得する.
* @return 重ね合わせ順
*/
public int getOrder() {
return order;
}
/**
* カラーグループを取得する.
* @return カラーグループ
*/
public ColorGroup getColorGroup() {
return colorGroup;
}
/**
* カラーグループの同期フラグ(初期)を取得する.
* @return 同期フラグ
*/
public boolean isInitSync() {
return initSync;
}
/**
* 対象ディレクトリを取得する.
* @return 対象ディレクトリ
*/
public String getDir() {
return dir;
}
/**
* 同一レイヤーであるか判断する.
* ID、順序、Dirで判断する.
* (カラーグループ、カラーグループ同期、表示名、は無視される.)
*/
@Override
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (obj != null && obj instanceof Layer) {
Layer o = (Layer) obj;
File d1 = new File(dir);
File d2 = new File(o.dir);
return id.equals(o.id) && order == o.order && d1.equals(d2);
}
return false;
}
/**
* 同一レイヤーであるか判断する.
* IDのみで判断する.
* (カラーグループ、カラーグループ同期、表示名、順序、Dirは無視される.)
* @param a 比較1
* @param b 比較2
* @return 等しければtrue、そうでなければfalse
*/
public static boolean equals(Layer a, Layer b) {
if (a == b) {
return true;
}
if (a == null || b == null) {
return false;
}
return a.equals(b);
}
@Override
public int hashCode() {
return id.hashCode();
}
@Override
public String toString() {
return "Layer(id=" + id + ", name=" + localizedName + ", order=" + order + ")";
}
}
charactermanaj/src/charactermanaj/model/PartsCategory.java 0000644 0001750 0001750 00000013542 11767047535 024241 0 ustar paulliu paulliu package charactermanaj.model;
import java.io.Serializable;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
/**
* パーツカテゴリ.
* 同値であるかはカテゴリIDが一致するかによってのみ判定します.
* それ以外の情報は無視されます.
* @author seraphy
*/
public final class PartsCategory implements Comparable, Serializable {
/**
* シリアライズバージョンID.
*/
private static final long serialVersionUID = -8652242530280056201L;
/**
* 順序
*/
private final int order;
/**
* カテゴリ識別名
*/
private final String categoryId;
/**
* カテゴリ表示名
*/
private final String localizedCategoryName;
/**
* 複数選択可能?
*/
private final boolean multipleSelectable;
/**
* 表示行数
*/
private final int visibleRows;
/**
* レイヤー情報
*/
private final List layers;
/**
* カテゴリを構築する.
* @param order 順序
* @param categoryId カテゴリ識別名
* @param localizedCategoryName カテゴリ表示名
* @param multipleSelectable 複数選択可能?
* @param visibleRows 表示行数
* @param layers レイヤー情報の配列、nullの場合は空とみなす
*/
public PartsCategory(final int order, final String categoryId, String localizedCategoryName,
boolean multipleSelectable, int visibleRows, Layer[] layers) {
if (categoryId == null || categoryId.trim().length() == 0) {
throw new IllegalArgumentException();
}
if (layers == null) {
layers = new Layer[0];
}
if (localizedCategoryName == null || localizedCategoryName.trim().length() == 0) {
localizedCategoryName = categoryId;
}
this.order = order;
this.categoryId = categoryId.trim();
this.localizedCategoryName = localizedCategoryName.trim();
this.multipleSelectable = multipleSelectable;
this.layers = Collections.unmodifiableList(Arrays.asList(layers.clone()));
this.visibleRows = visibleRows;
}
/**
* カテゴリの順序を比較して返す.
* 順序で比較し、同一順序であれば表示名で比較し、それでも同一であれば識別子で比較します.
* @param o 比較対象.
* @return 順序
*/
public int compareTo(PartsCategory o) {
if (o == this) {
return 0;
}
int ret = order - o.order;
if (ret == 0) {
ret = localizedCategoryName.compareTo(o.localizedCategoryName);
}
if (ret == 0) {
ret = categoryId.compareTo(o.categoryId);
}
return ret;
}
@Override
public int hashCode() {
return this.categoryId.hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (obj != null && obj instanceof PartsCategory) {
// IDが等しいか?
PartsCategory o = (PartsCategory) obj;
if (categoryId.equals(o.getCategoryId())) {
// それ以外の情報も等しいか?
// (用法的に、異なるインスタンスで同じIDをもつことは希であり、
// その上、IDが同一で、それ以外の内容が一致しないことは更に希である。)
if (order == o.order
&& localizedCategoryName
.equals(o.localizedCategoryName)
&& multipleSelectable == o.multipleSelectable
&& visibleRows == o.visibleRows
&& layers.equals(o.layers)) {
return true;
}
}
}
return false;
}
/**
* 同一カテゴリであるか判定します.
* nullの場合は常にfalseを返します.
* @param obj パーツカテゴリ、またはnull
* @return 同一のパーツカテゴリIDであればtrue、そうでなければfalse
*/
public boolean isSameCategoryID(PartsCategory obj) {
if (obj == this) {
return true;
}
if (obj != null) {
return categoryId.equals(obj.categoryId);
}
return false;
}
public static boolean equals(PartsCategory o1, PartsCategory o2) {
if (o1 == o2) {
return true;
}
if (o1 == null || o2 == null) {
return false;
}
return o1.equals(o2);
}
/**
* 定義順を取得する
* @return 定義順
*/
public int getOrder() {
return order;
}
/**
* 複数選択可能であるか?
* @return 複数選択可能であるか?
*/
public boolean isMultipleSelectable() {
return multipleSelectable;
}
/**
* 表示行数を取得する.
* @return 表示行数
*/
public int getVisibleRows() {
return visibleRows;
}
/**
* このカテゴリに指定したレイヤーが含まれるか検証する.
* @param layer レイヤー
* @return 含まれる場合はtrue、含まれない場合はfalse
*/
public boolean hasLayer(Layer layer) {
if (layer == null) {
return false;
}
for (Layer memberLayer : layers) {
if (Layer.equals(memberLayer, layer)) {
return true;
}
}
return false;
}
/**
* レイヤー情報
* @return レイヤー情報
*/
public List getLayers() {
return layers;
}
/**
* レイヤーを取得する.
* 該当するレイヤーがなければnull
* @param layerId レイヤー名
* @return レイヤーもしくはnull
*/
public Layer getLayer(String layerId) {
if (layerId == null) {
return null;
}
for (Layer layer : layers) {
if (layer.getId().equals(layerId)) {
return layer;
}
}
return null;
}
/**
* カテゴリ識別名を取得する.
* @return カテゴリ識別名
*/
public String getCategoryId() {
return categoryId;
}
/**
* カテゴリ表示名を取得する.
* @return カテゴリ表示名
*/
public String getLocalizedCategoryName() {
return this.localizedCategoryName;
}
@Override
public String toString() {
return getLocalizedCategoryName();
}
}
charactermanaj/src/charactermanaj/model/PartsSpecResolver.java 0000644 0001750 0001750 00000002045 11767047535 025074 0 ustar paulliu paulliu package charactermanaj.model;
import java.awt.Dimension;
import java.util.Map;
/**
* パーツ設定を取得するためのインターフェイス
* @author seraphy
*/
public interface PartsSpecResolver extends PartsCategoryResolver {
/**
* イメージのサイズを取得する
* @return イメージサイズ、設定がなければnull
*/
Dimension getImageSize();
/**
* 指定したパーツ識別子に対するパーツ設定を取得する.
* なければnull
* @param partsIdentifier パーツ識別子
* @return パーツ設定、なければnull
*/
PartsSpec getPartsSpec(PartsIdentifier partsIdentifier);
/**
* 指定したカテゴリに該当するパーツ識別子とパーツ設定のマップを取得する.
* 該当するカテゴリがなければ空のマップを返す.
* @param category パーツカテゴリ
* @return パーツ設定のマップ、なければ空
*/
Map getPartsSpecMap(PartsCategory category);
}
charactermanaj/src/charactermanaj/model/PartsCategoryResolver.java 0000644 0001750 0001750 00000001016 11767047535 025754 0 ustar paulliu paulliu package charactermanaj.model;
import java.util.List;
public interface PartsCategoryResolver {
/**
* パーツカテゴリの一覧を取得する.
* @return パーツカテゴリの一覧。(表示順)
*/
List getPartsCategories();
/**
* パーツカテゴリのIDを指定して該当のインスタンスを取得します.
* @param id パーツカテゴリID
* @return インスタンス、なければnull
*/
PartsCategory getPartsCategory(String id);
}
charactermanaj/src/charactermanaj/model/AppConfig.java 0000644 0001750 0001750 00000061436 11767047535 023325 0 ustar paulliu paulliu package charactermanaj.model;
import java.awt.Color;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URI;
import java.net.URL;
import java.nio.charset.Charset;
import java.util.Properties;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Pattern;
import charactermanaj.util.ApplicationLogHandler;
import charactermanaj.util.BeanPropertiesUtilities;
import charactermanaj.util.ConfigurationDirUtilities;
/**
* アプリケーションの全域にわたる設定.
* アプリケーション設定は、クラスパス上のリソース、コートベース直下のappConfig.xml、ユーザーごとのappConfig.xmlの順に読み込まれます.
* @author seraphy
*/
public final class AppConfig {
/**
* アプリケーション設定ファイルの名前
*/
private static final String CONFIG_NAME = "appConfig.xml";
/**
* 全ユーザー用キャラクターディレクトリのシステムプロパティのキー名.
*/
public static final String COMMON_CHARACTER_DIR_PROPERTY_NAME = "character.dir";
/**
* 開発用仕様バージョン番号
*/
private static final String DEFAULT_SPECIFICATION_VERSION = "1.0";
/**
* ロガー
*/
private static final Logger logger = Logger.getLogger(AppConfig.class.getName());
/**
* シングルトンインスタンス
*/
private static final AppConfig singleton = new AppConfig();
/**
* インスタンスを取得する.
* @return インスタンス
*/
public static AppConfig getInstance() {
return singleton;
}
/**
* プライベートコンストラクタ
*/
private AppConfig() {
loadAppVersions();
}
private String implementationVersion;
private String specificationVersion;
/**
* 実装バージョンを取得する.
* ビルドされたjarパッケージからバージョン情報を取得する.
* クラスパスの実行からのバージョンは常に「develop」となる.
* @return 実装バージョン
*/
public String getImplementationVersion() {
return implementationVersion;
}
/**
* 仕様バージョンを取得する.
* ビルドされたjarパッケージからバージョン情報を取得する.
* クラスパスの実行からのバージョンは常に「develop」となる.
* @return 仕様バージョン
*/
public String getSpecificationVersion() {
return specificationVersion;
}
/**
* ビルドされたjarパッケージからバージョン情報を取得する.
* クラスパスの実行からのバージョンは常に「develop」となる.
*/
private void loadAppVersions() {
Package pak = this.getClass().getPackage();
String implementationVersion = "develop";
String specificationVersion = DEFAULT_SPECIFICATION_VERSION;
if (pak != null) {
String vInfo = pak.getImplementationVersion();
if (vInfo != null && implementationVersion.trim().length() > 0) {
implementationVersion = vInfo.trim();
}
String specVInfo = pak.getSpecificationVersion();
if (specVInfo != null && specVInfo.trim().length() > 0) {
specificationVersion = specVInfo.trim();
}
}
this.implementationVersion = implementationVersion;
this.specificationVersion = specificationVersion;
}
/**
* プロパティをロードする.
* リソース上の/appConfig.xml、コードベース下のappConfig.xml、アプリケーションデータ保存先のappConfig.xmlの順に読み取る.
* 存在しないか、読み取りに失敗した場合は、該当ファイルはスキップされる.
*/
public void loadConfig() {
Properties config = new Properties();
try {
File codeBase = ConfigurationDirUtilities.getApplicationBaseDir();
File userDataDir = ConfigurationDirUtilities.getUserDataDir();
URI[] uris = {
new File(getClass().getResource("/" + CONFIG_NAME).getPath()).toURI(),
new File(codeBase, CONFIG_NAME).getCanonicalFile().toURI(),
new File(userDataDir, CONFIG_NAME).toURI(),
};
for (URI uri : uris) {
if (uri == null) {
continue; // リソースがない場合はnullになる
}
// ファイルの実在チェック (チェックできる場合のみ)
if ("file".equals(uri.getScheme())) {
File file = new File(uri);
if (!file.exists()) {
logger.log(Level.CONFIG, "appConfig.xml is not found.:" + file);
continue;
}
}
// appConfig.xmlの読み込みを行う.
// Properties#loadFromXML() はXMLからキーを読み取り、既存のキーに対して上書きする.
// XMLに存在しないキーは読み込み前のままなので、繰り返し呼び出すことで「重ね合わせ」することができる.
try {
URL resourceURL = uri.toURL();
InputStream is = resourceURL.openStream();
try {
config.loadFromXML(is);
logger.log(Level.CONFIG, "appConfig.xml is loaded.:" + uri);
} finally {
is.close();
}
} catch (FileNotFoundException ex) {
logger.log(Level.CONFIG, "appConfig.xml is not found.: " + uri, ex);
// 無視する (無い場合は十分にありえるので「情報」レベルでログ。)
} catch (Exception ex) {
logger.log(Level.WARNING, "appConfig.xml loading failed.: " + uri, ex);
// 無視する
}
}
} catch (IOException ex) {
throw new RuntimeException("appConfig.xml loading failed.", ex);
} catch (RuntimeException ex) {
throw new RuntimeException("appConfig.xml loading failed.", ex);
}
BeanPropertiesUtilities.loadFromProperties(this, config);
}
/**
* プロパティをアプリケーションデータの保存先に保存する.
* @throws IOException 保存に失敗した場合
*/
public void saveConfig() throws IOException {
Properties config = getProperties();
File userDataDir = ConfigurationDirUtilities.getUserDataDir();
File configStore = new File(userDataDir, CONFIG_NAME);
OutputStream os = new BufferedOutputStream(new FileOutputStream(configStore));
try {
config.storeToXML(os, CONFIG_NAME, "UTF-8");
} finally {
os.close();
}
}
/**
* Propertiesの値を設定した場合に設定できない項目があるかチェックする.
* このメソッドを呼び出しても、アプリケーション設定自身は何も影響されない.
* @param props 適用するプロパティ
* @return 設定できなかったプロパティキーのコレクション、問題なければ空が返される.
*/
public static Set checkProperties(Properties props) {
if (props == null) {
throw new IllegalArgumentException();
}
AppConfig dummy = new AppConfig(); // アプリケーションから参照されないダミーのインスタンスを作成する.
return BeanPropertiesUtilities.loadFromProperties(dummy, props);
}
/**
* Propertiesの値で設定を更新する.
* @param props 適用するプロパティ
* @return 設定できなかったプロパティキーのコレクション、問題なければ空が返される.
*/
public Set update(Properties props) {
if (props == null) {
throw new IllegalArgumentException();
}
return BeanPropertiesUtilities.loadFromProperties(this, props);
}
/**
* このアプリケーション設定をプロパティに書き出して返します.
* @return プロパティ
*/
public Properties getProperties() {
Properties config = new Properties();
BeanPropertiesUtilities.saveToProperties(this, config);
return config;
}
/**
* プロファイル選択ダイアログのプロファイルのサンプルイメージの背景色
* @return サンプルイメージの背景色
*/
public Color getSampleImageBgColor() {
return sampleImageBgColor;
}
public void setSampleImageBgColor(Color sampleImageBgColor) {
if (sampleImageBgColor == null) {
throw new IllegalArgumentException();
}
this.sampleImageBgColor = sampleImageBgColor;
}
private Color sampleImageBgColor = Color.white;
/**
* デフォルトのイメージ背景色を取得する.
* @return デフォルトのイメージ背景色
*/
public Color getDefaultImageBgColor() {
return defaultImageBgColor;
}
public void setDefaultImageBgColor(Color defaultImageBgColor) {
if (defaultImageBgColor == null) {
throw new IllegalArgumentException();
}
this.defaultImageBgColor = defaultImageBgColor;
}
private Color defaultImageBgColor = Color.white;
/**
* 使用中アイテムの背景色を取得する.
* @return 使用中アイテムの背景色
*/
public Color getCheckedItemBgColor() {
return checkedItemBgColor;
}
public void setCheckedItemBgColor(Color checkedItemBgColor) {
if (checkedItemBgColor == null) {
throw new IllegalArgumentException();
}
this.checkedItemBgColor = checkedItemBgColor;
}
private Color checkedItemBgColor = Color.cyan.brighter();
/**
* 選択アイテムの背景色を取得する
* @return 選択アイテムの背景色
*/
public Color getSelectedItemBgColor() {
return selectedItemBgColor;
}
public void setSelectedItemBgColor(Color selectedItemBgColor) {
this.selectedItemBgColor = selectedItemBgColor;
}
private Color selectedItemBgColor = Color.orange;
/**
* 不備のあるデータ行の背景色を取得する.
* @return 不備のあるデータ行の背景色
*/
public Color getInvalidBgColor() {
return invalidBgColor;
}
public void setInvalidBgColor(Color invalidBgColor) {
if (invalidBgColor == null) {
throw new IllegalArgumentException();
}
this.invalidBgColor = invalidBgColor;
}
private Color invalidBgColor = Color.red.brighter().brighter();
/**
* JPEG画像変換時の圧縮率を取得する.
* @return 圧縮率
*/
public float getCompressionQuality() {
return compressionQuality;
}
public void setCompressionQuality(float compressionQuality) {
if (compressionQuality < .1f || compressionQuality > 1f) {
throw new IllegalArgumentException();
}
this.compressionQuality = compressionQuality;
}
private float compressionQuality = .8f;
/**
* エクスポートウィザードのプリセットにパーツ不足時の警告色(前景色)を取得する.
* @return エクスポートウィザードのプリセットにパーツ不足時の警告色(前景色)
*/
public Color getExportPresetWarningsForegroundColor() {
return exportPresetWarningsForegroundColor;
}
public void setExportPresetWarningsForegroundColor(
Color exportPresetWarningsForegroundColor) {
this.exportPresetWarningsForegroundColor = exportPresetWarningsForegroundColor;
}
private Color exportPresetWarningsForegroundColor = Color.red;
/**
* JARファイル転送用バッファサイズ.
* @return JARファイル転送用バッファサイズ.
*/
public int getJarTransferBufferSize() {
return jarTransferBufferSize;
}
public void setJarTransferBufferSize(int jarTransferBufferSize) {
if (jarTransferBufferSize <= 0) {
throw new IllegalArgumentException();
}
this.jarTransferBufferSize = jarTransferBufferSize;
}
private int jarTransferBufferSize = 4096;
/**
* ZIPファイル名のエンコーディング.
* @return ZIPファイル名のエンコーディング.
*/
public String getZipNameEncoding() {
return zipNameEncoding;
}
public void setZipNameEncoding(String zipNameEncoding) {
if (zipNameEncoding == null) {
throw new IllegalArgumentException();
}
try {
Charset.forName(zipNameEncoding);
} catch (Exception ex) {
throw new RuntimeException("unsupported charset: " + zipNameEncoding);
}
this.zipNameEncoding = zipNameEncoding;
}
private String zipNameEncoding = "csWindows31J";
/**
* ディセーブルなテーブルのセルのフォアグラウンドカラーを取得する.
* @return ディセーブルなテーブルのセルのフォアグラウンドカラー
*/
public Color getDisabledCellForgroundColor() {
return disabledCellForegroundColor;
}
public void setDisabledCellForegroundColor(Color disabledCellForegroundColor) {
if (disabledCellForegroundColor == null) {
throw new IllegalArgumentException();
}
this.disabledCellForegroundColor = disabledCellForegroundColor;
}
private Color disabledCellForegroundColor = Color.gray;
/**
* ディレクトリを監視する間隔(mSec)を取得する.
* @return ディレクトリを監視する間隔(mSec)
*/
public int getDirWatchInterval() {
return dirWatchInterval;
}
public void setDirWatchInterval(int dirWatchInterval) {
if (dirWatchInterval <= 0) {
throw new IllegalArgumentException();
}
this.dirWatchInterval = dirWatchInterval;
}
private int dirWatchInterval = 7 * 1000;
/**
* ディレクトリの監視を有効にするか?
* @return ディレクトリの監視を有効にする場合はtrue
*/
public boolean isEnableDirWatch() {
return enableDirWatch;
}
public void setEnableDirWatch(boolean enableDirWatch) {
this.enableDirWatch = enableDirWatch;
}
private boolean enableDirWatch = true;
/**
* ファイル転送に使うバッファサイズ.
* @return バッファサイズ
*/
public int getFileTransferBufferSize() {
return fileTransferBufferSize;
}
public void setFileTransferBufferSize(int fileTransferBufferSize) {
if (fileTransferBufferSize <= 0) {
throw new IllegalArgumentException();
}
this.fileTransferBufferSize = fileTransferBufferSize;
}
private int fileTransferBufferSize = 4096;
/**
* プレビューのインジケータを表示するまでのディレイ(mSec)を取得する.
* @return プレビューのインジケータを表示するまでのディレイ(mSec)
*/
public long getPreviewIndicatorDelay() {
return previewIndeicatorDelay;
}
public void setPreviewIndeicatorDelay(long previewIndeicatorDelay) {
if (previewIndeicatorDelay < 0) {
throw new IllegalArgumentException();
}
this.previewIndeicatorDelay = previewIndeicatorDelay;
}
private long previewIndeicatorDelay = 300;
/**
* 情報ダイアログの編集ボタンを「開く」アクションにする場合はtrue、「編集」アクションにする場合はfalse
* @return trueならばOpen、falseならばEdit
*/
public boolean isInformationDialogOpenMethod() {
return informationDialogOpenMethod;
}
public void setInformationDialogOpenMethod(
boolean informationDialogOpenMethod) {
this.informationDialogOpenMethod = informationDialogOpenMethod;
}
private boolean informationDialogOpenMethod = true;
/**
* ログを常に残すか?
* falseの場合は{@link ApplicationLogHandler}の実装に従って終了時に
* 必要なければログは削除される.
* @return 常に残す場合はtrue、そうでなければfalse
*/
public boolean isNoRemoveLog() {
return noRemoveLog;
}
public void setNoRemoveLog(boolean noRemoveLog) {
this.noRemoveLog = noRemoveLog;
}
private boolean noRemoveLog = false;
/**
* テーブルのグリッド色.
* @return テーブルのグリッド色
*/
public Color getGridColor() {
return gridColor;
}
public void setGridColor(Color gridColor) {
if (gridColor == null) {
throw new IllegalArgumentException();
}
this.gridColor = gridColor;
}
private Color gridColor = Color.gray;
/**
* カラーダイアログの値が変更されたら、自動的にプレビューを更新するか?
* @return カラーダイアログの値が変更されたら、自動的にプレビューを更新する場合はtrue (デフォルトはtrue)
*/
public boolean isEnableAutoColorChange() {
return enableAutoColorChange;
}
public void setEnableAutoColorChange(boolean enableAutoColorChange) {
this.enableAutoColorChange = enableAutoColorChange;
}
private boolean enableAutoColorChange = true;
public void setAuthorEditConflictBgColor(Color authorEditConflictBgColor) {
if (authorEditConflictBgColor == null) {
throw new IllegalArgumentException();
}
this.authorEditConflictBgColor = authorEditConflictBgColor;
}
/**
* パーツの作者編集時に複数作者を選択した場合のに入力ボックスの背景色
* @return 背景色
*/
public Color getAuthorEditConflictBgColor() {
return authorEditConflictBgColor;
}
Color authorEditConflictBgColor = Color.yellow;
public void setMainFrameMaxWidth(int width) {
this.mainFrameMaxWidth = width;
}
/**
* メインフレームの初期表示時の最大幅
* @return メインフレームの初期表示時の最大幅
*/
public int getMainFrameMaxWidth() {
return mainFrameMaxWidth;
}
private int mainFrameMaxWidth = 800;
public void setMainFrameMaxHeight(int height) {
this.mainFrameMaxHeight = height;
}
/**
* メインフレームの初期表示時の最大高さ
* @return メインフレームの初期表示時の最大高さ
*/
public int getMainFrameMaxHeight() {
return mainFrameMaxHeight;
}
private int mainFrameMaxHeight = 600;
/**
* カラーダイアログで存在しないレイヤーをディセーブルにしない.
* @return ディセーブルにしない場合はtrue
*/
public boolean isNotDisableLayerTab() {
return notDisableLayerTab;
}
public void setNotDisableLayerTab(boolean notDisableLayerTab) {
this.notDisableLayerTab = notDisableLayerTab;
}
private boolean notDisableLayerTab;
/**
* ログを消去する日数.
* この指定日を経過した古いログは削除される.
* 0の場合は削除されない.
* @return
*/
public long getPurgeLogDays() {
return purgeLogDays;
}
public void setPurgeLogDays(long purgeLogDays) {
this.purgeLogDays = purgeLogDays;
}
private long purgeLogDays = 10;
public String getPartsColorGroupPattern() {
return partsColorGroupPattern;
}
public void setPartsColorGroupPattern(String pattern) {
if (pattern != null && pattern.trim().length() > 0) {
Pattern.compile(pattern);
}
partsColorGroupPattern = pattern;
}
private String partsColorGroupPattern = "^.*\\(@\\).*$";
private Color selectPanelTitleColor = Color.BLUE;
public Color getSelectPanelTitleColor() {
return selectPanelTitleColor;
}
public void setSelectPanelTitleColor(Color color) {
if (color == null) {
throw new IllegalArgumentException();
}
selectPanelTitleColor = color;
}
private boolean enableAutoShrinkPanel;
public boolean isEnableAutoShrinkPanel() {
return enableAutoShrinkPanel;
}
public void setEnableAutoShrinkPanel(boolean enableAutoShrinkPanel) {
this.enableAutoShrinkPanel = enableAutoShrinkPanel;
}
public boolean isDisableWatchDirIfNotWritable() {
return disableWatchDirIfNotWritable;
}
public void setDisableWatchDirIfNotWritable(boolean disableWatchDirIfNotWritable) {
this.disableWatchDirIfNotWritable = disableWatchDirIfNotWritable;
}
private boolean disableWatchDirIfNotWritable = true;
public void setEnablePNGSupportForWindows(boolean enablePNGSupportForWindows) {
this.enablePNGSupportForWindows = enablePNGSupportForWindows;
}
public boolean isEnablePNGSupportForWindows() {
return enablePNGSupportForWindows;
}
private boolean enablePNGSupportForWindows = true;
/**
* 画像表示(通常モード)でオプティマイズを有効にする最大倍率.
*/
private double renderingOptimizeThresholdForNormal = 2.;
public void setRenderingOptimizeThresholdForNormal(
double renderingOptimizeThresholdForNormal) {
this.renderingOptimizeThresholdForNormal = renderingOptimizeThresholdForNormal;
}
public double getRenderingOptimizeThresholdForNormal() {
return renderingOptimizeThresholdForNormal;
}
/**
* 画像表示(チェックモード)でオプティマイズを有効にする最大倍率.
*/
private double renderingOptimizeThresholdForCheck = 0.;
public void setRenderingOptimizeThresholdForCheck(
double renderingOptimizeThresholdForCheck) {
this.renderingOptimizeThresholdForCheck = renderingOptimizeThresholdForCheck;
}
public double getRenderingOptimizeThresholdForCheck() {
return renderingOptimizeThresholdForCheck;
}
/**
* バイキュービックをサポートする場合
*/
private boolean enableInterpolationBicubic = true;
public void setEnableInterpolationBicubic(boolean enableInterpolationBicubic) {
this.enableInterpolationBicubic = enableInterpolationBicubic;
}
public boolean isEnableInterpolationBicubic() {
return enableInterpolationBicubic;
}
/**
* 事前定義済みの倍率候補.
*/
private String predefinedZoomRanges = "20, 50, 80, 100, 120, 150, 200, 300, 400, 800";
public String getPredefinedZoomRanges() {
return predefinedZoomRanges;
}
public void setPredefinedZoomRanges(String predefinedZoomRanges) {
this.predefinedZoomRanges = predefinedZoomRanges;
}
/**
* ズームパネルを初期状態で表示するか?
*/
private boolean enableZoomPanel = true;
public boolean isEnableZoomPanel() {
return enableZoomPanel;
}
public void setEnableZoomPanel(boolean enableZoomPanel) {
this.enableZoomPanel = enableZoomPanel;
}
/**
* ズームパネルをアクティブにする下部範囲
*/
private int zoomPanelActivationArea = 30;
public int getZoomPanelActivationArea() {
return zoomPanelActivationArea;
}
public void setZoomPanelActivationArea(int zoomPanelActivationArea) {
this.zoomPanelActivationArea = zoomPanelActivationArea;
}
/**
* レンダリングヒントを使用するか?
*/
private boolean enableRenderingHints = true;
public void setEnableRenderingHints(boolean enableRenderingHints) {
this.enableRenderingHints = enableRenderingHints;
}
public boolean isEnableRenderingHints() {
return enableRenderingHints;
}
/**
* グリッド描画とマスク
*/
private int drawGridMask = 2;
public int getDrawGridMask() {
return drawGridMask;
}
public void setDrawGridMask(int drawGridMask) {
this.drawGridMask = drawGridMask & 0x03;
}
private int previewGridColor = 0x7f7f0000;
public int getPreviewGridColor() {
return previewGridColor;
}
public void setPreviewGridColor(int previewGridColor) {
this.previewGridColor = previewGridColor;
}
private int previewGridSize = 20;
public int getPreviewGridSize() {
return previewGridSize;
}
public void setPreviewGridSize(int previewGridSize) {
this.previewGridSize = previewGridSize;
}
/**
* チェックモード時の余白サイズ(片側)
*/
private int previewUnfilledSpaceForCheckMode = 0;
public int getPreviewUnfilledSpaceForCheckMode() {
return previewUnfilledSpaceForCheckMode;
}
public void setPreviewUnfilledSpaceForCheckMode(
int previewUnfilledSpaceForCheckMode) {
this.previewUnfilledSpaceForCheckMode = previewUnfilledSpaceForCheckMode;
}
/**
* チェックモードでツールチップを表示するか?
*/
private boolean enableCheckInfoTooltip = true;
public boolean isEnableCheckInfoTooltip() {
return enableCheckInfoTooltip;
}
public void setEnableCheckInfoTooltip(boolean enableCheckInfoTooltip) {
this.enableCheckInfoTooltip = enableCheckInfoTooltip;
}
/**
* ホイールによるスクロールの単位.
*/
private int wheelScrollUnit = 10;
public int getWheelScrollUnit() {
return wheelScrollUnit;
}
public void setWheelScrollUnit(int wheelScrollUnit) {
this.wheelScrollUnit = wheelScrollUnit;
}
/**
* 壁紙にオフスクリーン描画を使用するか?.
* (あまり劇的なパフォーマンス効果はない.)
*/
private boolean enableOffscreenWallpaper = false;
public boolean isEnableOffscreenWallpaper() {
return enableOffscreenWallpaper;
}
public void setEnableOffscreenWallpaper(boolean enableOffscreenWallpaper) {
this.enableOffscreenWallpaper = enableOffscreenWallpaper;
}
/**
* 壁紙のオフスクリーンの既定サイズ.
*/
private int offscreenWallpaperSize = 300;
public int getOffscreenWallpaperSize() {
return offscreenWallpaperSize;
}
public void setOffscreenWallpaperSize(int offscreenWallpaperSize) {
this.offscreenWallpaperSize = offscreenWallpaperSize;
}
}
charactermanaj/src/charactermanaj/model/PartsSet.java 0000644 0001750 0001750 00000040634 11767047535 023221 0 ustar paulliu paulliu package charactermanaj.model;
import java.awt.Color;
import java.io.Serializable;
import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* パーツセット.
* 各カテゴリの選択パーツと、そのパーツの色情報、および背景色をセットにしたもの.
* 保存する必要がなければIDおよび表示名は使用されないため、nullとなりえる.
* @author seraphy
*
*/
public final class PartsSet extends AbstractMap> implements Serializable, Cloneable {
/**
* シリアライズバージョンID.
*/
private static final long serialVersionUID = 5972528889825451761L;
/**
* パーツセットID.
* 一時的な名前なしのパーツセットとして使われる場合はnull
*/
private String partsSetId;
/**
* パーツセットの表示名.
* 一時的な名前なしのパーツセットとして使われる場合はnull
*/
private String localizedName;
/**
* プリセットパーツフラグ
*/
private boolean presetParts;
/**
* パーツセットとともに使われる背景色.
*/
private Color bgColor;
/**
* アフィン変換用パラメータ.
* 変換しない場合はnull.
*/
private double[] affineTransformParameter;
/**
* パーツリスト
*/
private HashMap> parts = new HashMap>();
/**
* パーツに対するカラー情報.
* かならずしも、パーツに対してカラー情報を設定する必要はない.
* カラー情報がない場合は空.
*/
private HashMap partsColorInfoMap = new HashMap();
/**
* 無名、空のパーツセットを作成する.
*/
public PartsSet() {
this(null, null, false);
}
/**
* 名前つきパーツセットを作成する.
* @param partsSetId パーツセットID
* @param localizedName 表示名
* @param presetParts プリセットフラグ
*/
public PartsSet(String partsSetId, String localizedName, boolean presetParts) {
this.partsSetId = partsSetId;
this.localizedName = localizedName;
this.presetParts = presetParts;
}
/**
* パーツセットをディープコピーする.
* 現在のキャラクターデータのカテゴリインスタンスに関連づけて再生させる場合は、
* resolverに現在のキャラクターデータのカテゴリリゾルバを指定します.
* @param org 元オブジェクト
* @param resolver パーツセットのカテゴリを再生するためのリゾルバ、再生する必要がなければnull可
*/
protected PartsSet(PartsSet org, PartsCategoryResolver resolver) {
if (org == null) {
throw new IllegalArgumentException();
}
this.partsSetId = org.partsSetId;
this.localizedName = org.localizedName;
this.presetParts = org.presetParts;
this.bgColor = org.bgColor;
this.affineTransformParameter = org.affineTransformParameter == null ? null : org.affineTransformParameter.clone();
// ColorInfoMapの正規化
for (Map.Entry partsColorInfoEntry : org.partsColorInfoMap.entrySet()) {
PartsIdentifier partsIdentifier = partsColorInfoEntry.getKey();
if (resolver != null) {
PartsCategory orgPartsCategory = partsIdentifier.getPartsCategory();
PartsCategory repPartsCategory = resolver.getPartsCategory(orgPartsCategory.getCategoryId());
if (repPartsCategory == null) {
// 同一IDのカテゴリがリゾルバになければ、このパーツは無かったことにする.
continue;
}
if (orgPartsCategory != repPartsCategory) {
// インスタンスが一致しなければリゾルバ側の結果を優先する.
partsIdentifier = new PartsIdentifier(
repPartsCategory,
partsIdentifier.getPartsName(),
partsIdentifier.getLocalizedPartsName());
}
}
PartsCategory repPartsCategory = partsIdentifier.getPartsCategory();
PartsColorInfo copiedPartsColorInfo = partsColorInfoEntry
.getValue().createCompatible(repPartsCategory);
partsColorInfoMap.put(partsIdentifier, copiedPartsColorInfo);
}
// PartsIdentifierの正規化
for (Map.Entry> partsEntry : org.parts.entrySet()) {
PartsCategory orgPartsCategory = partsEntry.getKey();
PartsCategory partsCategory = orgPartsCategory;
if (resolver != null) {
PartsCategory repPartsCategory = resolver.getPartsCategory(orgPartsCategory.getCategoryId());
if (repPartsCategory == null) {
// 同一IDのカテゴリがリゾルバになければ、このカテゴリはなかったことにする.
continue;
}
if (repPartsCategory != orgPartsCategory) {
// インスタンスが一致しなければリゾルバ側の結果を優先する.
partsCategory = repPartsCategory;
}
}
ArrayList partsIdentifiers = new ArrayList(partsEntry.getValue());
parts.put(partsCategory, partsIdentifiers);
}
}
/**
* リゾルバを使用してパーツカテゴリ(パーツ識別子のカテゴリも含む)のインスタンスを入れ替えます.
* パーツセットはキャラクターデータとは独立してロード・セーブされることがあるため、同じ情報でも異なるインスタンスとなる場合があり、
* これを是正するために、このメソッドを使用します.
* リゾルバから取得できないパーツカテゴリは除去されます.
* @param resolver リゾルバ
* @return 互換性のあるパーツセット
*/
public PartsSet createCompatible(PartsCategoryResolver resolver) {
if (resolver == null) {
throw new IllegalArgumentException();
}
// XXX: 本当は、こんなことはしたくない。
return new PartsSet(this, resolver);
}
/**
* パーツセットをディープコピーする.
* @return コピーされたパーツセット
*/
@Override
public PartsSet clone() {
return new PartsSet(this, null);
}
@Override
public int hashCode() {
return super.hashCode() ^ (partsSetId == null ? 0 : partsSetId.hashCode());
}
@Override
public boolean equals(Object o) {
if (o == this) {
return true;
}
if (o != null && o instanceof PartsSet) {
PartsSet obj = (PartsSet) o;
// 双方のIDがnullもしくは、同一インスタンスであるか、ID文字列が等値である場合
if (partsSetId == obj.partsSetId || (partsSetId != null && partsSetId.equals(obj.partsSetId))) {
// AbstractMapのequalsでパーツの構成物を比較する.
if (super.equals(obj)) {
// カラー定義が等しいか比較する.
if (partsColorInfoMap.equals(obj.partsColorInfoMap)) {
// 背景色がともにnullもしくは同一インスタンスであるか、背景色が等値である場合
if (bgColor == obj.bgColor || (bgColor != null && bgColor.equals(obj.bgColor))) {
// アフィン変換パラメータがともにnullもしくは同一インスタンスであるか、同値である場合.
if (affineTransformParameter == obj.affineTransformParameter
|| (affineTransformParameter != null
&& Arrays.equals(affineTransformParameter, obj.affineTransformParameter))) {
return true;
}
}
}
}
}
}
return false;
}
public void setPresetParts(boolean presetParts) {
this.presetParts = presetParts;
}
/**
* プリセット用パーツセットであるか?
* これがfalseの場合は一時的なパーツセットか、もしくはお気に入り用である.
* @return プリセット用パーツセットである場合
*/
public boolean isPresetParts() {
return presetParts;
}
public void setBgColor(Color bgColor) {
this.bgColor = bgColor;
}
/**
* バックグラウンドカラーを取得する.
* 設定されていなければnull.
* @return バックグラウンドカラー、もしくはnull
*/
public Color getBgColor() {
return bgColor;
}
/**
* アフィン変換用パラメータを指定する.
* 配列は4または6でなければならない.
* アフィン変換しない場合はnull
* @param affineTransformParameter 変換パラメータ(4または6個の要素)、もしくはnull
*/
public void setAffineTransformParameter(double[] affineTransformParameter) {
if (affineTransformParameter != null && !(affineTransformParameter.length == 4 || affineTransformParameter.length == 6)) {
throw new IllegalArgumentException("affineTransformParameter invalid length.");
}
this.affineTransformParameter = affineTransformParameter == null ? null : affineTransformParameter.clone();
}
/**
* アフィン変換用のパラメータを取得する.
* 変換しない場合はnull.
* @return アフィン変換用のパラメータ、またはnull
*/
public double[] getAffineTransformParameter() {
return affineTransformParameter == null ? null : affineTransformParameter.clone();
}
public void setPartsSetId(String partsSetId) {
this.partsSetId = partsSetId;
}
public void setLocalizedName(String localizedName) {
this.localizedName = localizedName;
}
/**
* プリセットIDを取得する.
* 一時的なパーツセットである場合はnull
* @return プリセットID、またはnull
*/
public String getPartsSetId() {
return partsSetId;
}
/**
* プリセット名を取得する.
* 一時的なパーツセットである場合はnull
* @return プリセット名、またはnull
*/
public String getLocalizedName() {
return localizedName;
}
/**
* パーツセットのエントリセットを取得する.
*/
@Override
public Set>> entrySet() {
return parts.entrySet();
}
/**
* パーツカラー情報を取得する.
* カラー情報が関連づけられていない場合はnullが返される.
* @param partsIdentifier パーツ識別子
* @return カラー情報、もしくはnull
*/
public PartsColorInfo getColorInfo(PartsIdentifier partsIdentifier) {
PartsColorInfo partsColorInfo = partsColorInfoMap.get(partsIdentifier);
return partsColorInfo == null ? null : partsColorInfo.clone();
}
/**
* カテゴリ別にパーツを登録する.
* partsNameがnullまたは空文字の場合はカテゴリのみ登録する.
* これにより、そのカテゴリに選択がないことを示す.
* 複数選択可能なカテゴリの場合、複数回の呼び出しで登録する.(登録順)
* @param category カテゴリ
* @param partsIdentifier パーツ識別子、またはnull
* @param partsColorInfo パーツの色情報、なければnull可
*/
public void appendParts(PartsCategory category, PartsIdentifier partsIdentifier, PartsColorInfo partsColorInfo) {
if (category == null) {
throw new IllegalArgumentException();
}
List partsIdentifiers = parts.get(category);
if (partsIdentifiers == null) {
partsIdentifiers = new ArrayList();
parts.put(category, partsIdentifiers);
}
if (partsIdentifier != null) {
partsIdentifiers.add(partsIdentifier);
if (partsColorInfo != null) {
partsColorInfoMap.put(partsIdentifier, partsColorInfo.clone());
}
}
}
/**
* すべてのパーツのカラー情報を除去する.
*/
public void removeColorInfo() {
partsColorInfoMap.clear();
}
/**
* パーツセットが構造的に一致するか検証します.
* nullの場合は常にfalseとなります.
* @param other 比較対象、null可
* @return パーツ構成が一致すればtrue、そうでなければfalse
*/
public boolean isSameStructure(PartsSet other) {
if (other != null && other.size() == this.size()) {
// カテゴリが一致し、各カテゴリに登録されているパーツ識別子のリストも順序を含めて一致する場合、
// 構造的に一致すると判定する.
for (Map.Entry> entry : entrySet()) {
PartsCategory category = entry.getKey();
List ownList = entry.getValue();
List otherList = other.get(category);
if (ownList == null || otherList == null || !ownList.equals(otherList)) {
return false;
}
}
return true;
}
return false;
}
/**
* 2つのパーツセットが構造的に一致するか検証します.
* いずれか一方がnullであればfalseを返します.双方がnullであればtrueを返します.
* 双方がnullでなければ{@link #isSameStructure(PartsSet)}で判定されます.
* @param a 比較対象1、null可
* @param b 比較対象2、null可
* @return パーツ構成が一致すればtrue、そうでなければfalse
*/
public static boolean isSameStructure(PartsSet a, PartsSet b) {
if (a == b) {
return true;
}
if (a == null || b == null) {
return false;
}
return a.isSameStructure(b);
}
/**
* 保持しているパーツ識別子のカラー情報と同一のカラー情報をもっているか判定します.
* 相手側はカテゴリや順序を問わず、少なくとも自分と同じパーツ識別子をもっていれば足りるため、
* パーツ構成が同一であるかの判定は行いません.
* パーツ構造を含めて判定を行う場合は事前に{@link #isSameStructure(PartsSet)}を呼び出します.
* nullの場合は常にfalseとなります.
* @param other 判定先、null可
* @return 同一であればtrue、そうでなければfalse
*/
public boolean isSameColor(PartsSet other) {
if (other != null && other.size() == size()) {
for (List partsIdentifiers : values()) {
for (PartsIdentifier partsIdentifier : partsIdentifiers) {
PartsColorInfo ownColorInfo = getColorInfo(partsIdentifier);
PartsColorInfo otherColorInfo = other.getColorInfo(partsIdentifier);
if ( !PartsColorInfo.equals(ownColorInfo, otherColorInfo)) {
return false;
}
}
}
return true;
}
return false;
}
/**
* 引数aが保持しているパーツ識別子のカラー情報と同一のカラー情報を引数bがもっているか判定します.
* 引数b側はカテゴリや順序を問わず、少なくとも引数aと同じパーツ識別子をもっていれば足りるため、
* パーツ構成が同一であるかの判定は行いません.
* パーツ構造を含めて判定を行う場合は事前に{@link #isSameStructure(PartsSet, PartsSet)}を呼び出します.
* 双方がnullであればtrueとなります.
* いずれか一方がnullの場合はfalseとなります.
* @param a 対象1、null可
* @param b 対象2、null可
* @return 同一であればtrue、そうでなければfalse
*/
public static boolean isSameColor(PartsSet a, PartsSet b) {
if (a == b) {
return true;
}
if (a == null || b == null) {
return false;
}
return a.isSameColor(b);
}
/**
* このパーツセットが名前をもっているか?
* @return 名前がある場合はtrue、設定されていないか空文字の場合はfalse
*/
public boolean hasName() {
return localizedName != null && localizedName.length() > 0;
}
@Override
public String toString() {
StringBuilder buf = new StringBuilder();
buf.append(getClass().getSimpleName() + "@" + Integer.toHexString(System.identityHashCode(this)));
buf.append("(");
buf.append("partsSetId: " + partsSetId + ", ");
buf.append("localizedName: " + localizedName + ", ");
buf.append("presetFlg: " + presetParts + ", ");
buf.append("background-color: " + bgColor + ", ");
buf.append("affin-trans-param: " + Arrays.toString(affineTransformParameter) + ", ");
buf.append("parts: " + parts + ", ");
buf.append("partsColorMap: " + partsColorInfoMap);
buf.append(")");
return buf.toString();
}
}
charactermanaj/src/charactermanaj/model/PartsSpecDecorater.java 0000644 0001750 0001750 00000000237 11767047535 025204 0 ustar paulliu paulliu package charactermanaj.model;
public interface PartsSpecDecorater {
void decoratePartsSpec(PartsIdentifier partsIdentifier, PartsSpec partsSpec);
}
charactermanaj/src/charactermanaj/model/RecommendationURL.java 0000644 0001750 0001750 00000002551 11767047535 024777 0 ustar paulliu paulliu package charactermanaj.model;
import java.io.Serializable;
/**
* お勧めリンク
* @author seraphy
*/
public class RecommendationURL implements Serializable, Cloneable {
private static final long serialVersionUID = 3568122645473390201L;
private String displayName;
private String url;
@Override
public RecommendationURL clone() {
try {
return (RecommendationURL) super.clone();
} catch (CloneNotSupportedException ex) {
throw new RuntimeException(ex);
}
}
@Override
public int hashCode() {
if (url == null) {
return 0;
}
return url.hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (obj != null && obj instanceof RecommendationURL) {
RecommendationURL o = (RecommendationURL) obj;
return (displayName == null ? (o.displayName == null) : displayName.equals(o.displayName))
&& (url == null ? (o.url == null) : url.equals(o.url));
}
return false;
}
public String getDisplayName() {
return displayName;
}
public void setDisplayName(String displayName) {
this.displayName = displayName;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
@Override
public String toString() {
return "displayName=" + displayName + "/url=" + url;
}
}
charactermanaj/src/charactermanaj/model/RecentData.java 0000644 0001750 0001750 00000004036 11767047535 023462 0 ustar paulliu paulliu package charactermanaj.model;
import java.io.File;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectInputStream.GetField;
import java.io.ObjectStreamClass;
import java.io.Serializable;
import java.net.URI;
import java.net.URL;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* 最後に使用したデータの使用状況
* @author seraphy
*/
public class RecentData implements Serializable {
/**
* ロガー
*/
private static final Logger logger = Logger.getLogger(RecentData.class.getName());
private static final long serialVersionUID = 7232012934972862661L;
private String appVersion;
private URI docBase;
/**
* デシリアライズ
* @param inp オブジェクトの復元ストリーム
* @throws IOException 例外
* @throws ClassNotFoundException 例外
*/
private void readObject(ObjectInputStream inp) throws IOException,
ClassNotFoundException {
GetField fields = inp.readFields();
ObjectStreamClass sig = fields.getObjectStreamClass();
if (logger.isLoggable(Level.FINE)) {
logger.log(Level.FINE, "RecentDataのデシリアライズ name=" + sig.getName()
+ "/sid=" + sig.getSerialVersionUID());
}
appVersion = (String) fields.get("appVersion", null);
Object anyDocBase = fields.get("docBase", null);
if (anyDocBase != null && anyDocBase instanceof URL) {
// 旧形式のURLの場合はURIに変換.
File file = new File(((URL) anyDocBase).getPath());
anyDocBase = file.toURI();
}
docBase = (URI) anyDocBase;
}
public String getAppVersion() {
return appVersion;
}
public void setAppVersion(String appVersion) {
this.appVersion = appVersion;
}
public URI getDocBase() {
return docBase;
}
public void setDocBase(URI docBase) {
this.docBase = docBase;
}
@Override
public String toString() {
StringBuilder buf = new StringBuilder();
buf.append("appVersion=" + appVersion + "/docBase=" + docBase);
return buf.toString();
}
}
charactermanaj/src/charactermanaj/model/WorkingSet.java 0000644 0001750 0001750 00000011525 11767047535 023545 0 ustar paulliu paulliu package charactermanaj.model;
import java.io.File;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectStreamClass;
import java.io.Serializable;
import java.io.ObjectInputStream.GetField;
import java.net.URI;
import java.net.URL;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import charactermanaj.ui.model.WallpaperInfo;
public class WorkingSet implements Serializable {
/**
* ロガー
*/
private static final Logger logger = Logger.getLogger(WorkingSet.class.getName());
private static final long serialVersionUID = -4728766140876842242L;
private Map partsColorInfoMap;
private String characterDataRev;
private PartsSet partsSet;
private URI characterDocBase;
private File lastUsedSaveDir;
private File lastUsedExportDir;
// ver0.92
private PartsSet lastUsePresetParts;
// ver0.94
private CharacterData characterData;
// ver0.97
private WallpaperInfo wallpaperInfo;
/**
* デシリアライズ
* @param inp オブジェクトの復元ストリーム
* @throws IOException 例外
* @throws ClassNotFoundException 例外
*/
@SuppressWarnings("unchecked")
private void readObject(ObjectInputStream inp) throws IOException,
ClassNotFoundException {
GetField fields = inp.readFields();
ObjectStreamClass sig = fields.getObjectStreamClass();
if (logger.isLoggable(Level.FINE)) {
logger.log(Level.FINE, "WorkingSetのデシリアライズ name=" + sig.getName()
+ "/sid=" + sig.getSerialVersionUID());
}
partsColorInfoMap = (Map) fields.get("partsColorInfoMap", null);
characterDataRev = (String) fields.get("characterDataRev", null);
partsSet = (PartsSet) fields.get("partsSet", null);
Object anyDocBase = fields.get("characterDocBase", null);
if (anyDocBase != null && anyDocBase instanceof URL) {
File file = new File(((URL) anyDocBase).getPath());
anyDocBase = file.toURI();
}
// ver0.95からURI, それ以前はURL
characterDocBase = (URI) anyDocBase;
lastUsedSaveDir = (File) fields.get("lastUsedSaveDir", null);
lastUsedExportDir = (File) fields.get("lastUsedExportDir", null);
// ver0.92
lastUsePresetParts = (PartsSet) fields.get("lastUsePresetParts", null);
// ver0.94
characterData = (CharacterData) fields.get("characterData", null);
// ver0.97
wallpaperInfo = (WallpaperInfo) fields.get("wallpaperInfo", null);
}
public void setCharacterDataRev(String characterDataRev) {
this.characterDataRev = characterDataRev;
}
public String getCharacterDataRev() {
return characterDataRev;
}
public Map getPartsColorInfoMap() {
return partsColorInfoMap;
}
public void setPartsColorInfoMap(
Map partsColorInfoMap) {
this.partsColorInfoMap = partsColorInfoMap;
}
public void setCharacterDocBase(URI characterDocBase) {
this.characterDocBase = characterDocBase;
}
public void setPartsSet(PartsSet partsSet) {
this.partsSet = partsSet;
}
public URI getCharacterDocBase() {
return characterDocBase;
}
public PartsSet getPartsSet() {
return partsSet;
}
public void setLastUsedSaveDir(File lastUsedSaveDir) {
this.lastUsedSaveDir = lastUsedSaveDir;
}
public void setLastUsedExportDir(File lastUsedExportDir) {
this.lastUsedExportDir = lastUsedExportDir;
}
public File getLastUsedSaveDir() {
return lastUsedSaveDir;
}
public File getLastUsedExportDir() {
return lastUsedExportDir;
}
/**
* 最後に使用したお気に入りの情報.
* ver0.94以前には存在しなかったため、nullになりえます。
* @return
*/
public PartsSet getLastUsePresetParts() {
return lastUsePresetParts;
}
public void setLastUsePresetParts(PartsSet lastUsePresetParts) {
this.lastUsePresetParts = lastUsePresetParts;
}
public void setCharacterData(CharacterData characterData) {
this.characterData = characterData;
}
/**
* 使用していたキャラクター定義を取得します.
* ver0.95よりも以前には存在しないため、nullとなりえます.
* @return キャラクターデータ
*/
public CharacterData getCharacterData() {
return characterData;
}
/**
* 壁紙情報を取得します.
* ver0.97よりも以前には存在しないため、nullとなりえます.
* @return 壁紙情報
*/
public WallpaperInfo getWallpaperInfo() {
return wallpaperInfo;
}
public void setWallpaperInfo(WallpaperInfo wallpaperInfo) {
this.wallpaperInfo = wallpaperInfo;
}
@Override
public String toString() {
return "docBase:" + characterDocBase + "/rev:" + characterDataRev;
}
}
charactermanaj/src/charactermanaj/model/PartsSpec.java 0000644 0001750 0001750 00000003517 11767047535 023357 0 ustar paulliu paulliu package charactermanaj.model;
import java.io.Serializable;
/**
* パーツの構成情報.
* @author seraphy
*/
public class PartsSpec implements Serializable {
private static final long serialVersionUID = -5275967668710789314L;
private PartsIdentifier partsIdentifier;
private ColorGroup colorGroup = ColorGroup.NA;
private PartsFiles partsFiles;
/**
* パーツの作者情報、指定がなければnull
*/
private PartsAuthorInfo authorInfo;
/**
* パーツのバージョン、指定がなければ0
*/
private double version;
/**
* ダウンロードURL
*/
private String downloadURL;
public PartsSpec(PartsIdentifier partsIdentifier) {
if (partsIdentifier == null) {
throw new IllegalArgumentException();
}
this.partsIdentifier = partsIdentifier;
this.partsFiles = new PartsFiles(partsIdentifier);
}
public PartsIdentifier getPartsIdentifier() {
return partsIdentifier;
}
public PartsFiles getPartsFiles() {
return partsFiles;
}
public void setAuthorInfo(PartsAuthorInfo authorInfo) {
this.authorInfo = authorInfo;
}
public PartsAuthorInfo getAuthorInfo() {
return authorInfo;
}
public String getAuthor() {
if (authorInfo != null) {
return authorInfo.getAuthor();
}
return null;
}
public void setVersion(double version) {
this.version = version;
}
public double getVersion() {
return version;
}
public String getDownloadURL() {
return downloadURL;
}
public void setDownloadURL(String downloadURL) {
this.downloadURL = downloadURL;
}
public void setColorGroup(ColorGroup colorGroup) {
if (colorGroup == null) {
colorGroup = ColorGroup.NA;
}
this.colorGroup = colorGroup;
}
public ColorGroup getColorGroup() {
return colorGroup;
}
}
charactermanaj/src/charactermanaj/model/PartsIdentifier.java 0000644 0001750 0001750 00000005716 11767047535 024552 0 ustar paulliu paulliu package charactermanaj.model;
import java.io.Serializable;
/**
* パーツ識別子.
* パーツ識別子の同値性は同一カテゴリID、且つ、同一のパーツ名(ID)であることによってのみ判定される.
* 表示名については不問.
* カテゴリIDのみ判定され、カテゴリの同値性についても問わない.
* @author seraphy
*
*/
public final class PartsIdentifier implements Serializable, Comparable {
private static final long serialVersionUID = 8943101890389091718L;
private final PartsCategory partsCategory;
private final String partsName;
private final String localizedName;
public PartsIdentifier(final PartsCategory partsCategory, final String partsName, final String localizedName) {
if (partsName == null || partsCategory == null) {
throw new IllegalArgumentException();
}
this.partsCategory = partsCategory;
this.partsName = partsName;
this.localizedName = (localizedName == null || localizedName.trim().length() == 0) ? partsName : localizedName;
}
public PartsCategory getPartsCategory() {
return partsCategory;
}
public boolean hasLayer(Layer layer) {
return partsCategory.hasLayer(layer);
}
@Override
public int hashCode() {
return partsName.hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (obj != null && obj instanceof PartsIdentifier) {
return partsName.equals(((PartsIdentifier) obj).partsName)
&& partsCategory.isSameCategoryID(((PartsIdentifier) obj).getPartsCategory());
}
return false;
}
public static boolean equals(PartsIdentifier a, PartsIdentifier b) {
if (a == b) {
return true;
}
if (a == null || b == null) {
return false;
}
return a.equals(b);
}
public int compareTo(PartsIdentifier o) {
if (o == this) {
return 0;
}
int ret = partsCategory.compareTo(o.partsCategory);
if (ret == 0) {
ret = localizedName.compareTo(o.localizedName);
}
if (ret == 0) {
ret = partsName.compareTo(o.partsName);
}
return ret;
}
public String getPartsName() {
return partsName;
}
public String getLocalizedPartsName() {
return localizedName;
}
/**
* ローカライズされた名前を変更する.
* [注意] このクラスは不変クラスなので、インスタンスを変更するのではなく、変更された状態の
* 新しいインスタンスを返します.
* @param localizedName ローカライズされた名前
* @return 新しいインスタンス
*/
public PartsIdentifier setLocalizedPartsName(String localizedName) {
if (localizedName == null || localizedName.trim().length() == 0) {
throw new IllegalArgumentException();
}
return new PartsIdentifier(partsCategory, partsName, localizedName);
}
@Override
public String toString() {
return getLocalizedPartsName();
}
}
charactermanaj/src/charactermanaj/model/CharacterData.java 0000644 0001750 0001750 00000071124 11767047535 024140 0 ustar paulliu paulliu package charactermanaj.model;
import java.awt.Dimension;
import java.io.File;
import java.io.IOException;
import java.io.Serializable;
import java.net.URI;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.logging.Level;
import java.util.logging.Logger;
import charactermanaj.model.io.PartsDataLoader;
/**
* キャラクターデータ
* @author seraphy
*/
public class CharacterData implements Serializable, PartsSpecResolver {
/**
* シリアライズバージョン
*/
private static final long serialVersionUID = -381763373314240953L;
/**
* ロガー
*/
private static final Logger logger = Logger.getLogger(CharacterData.class.getName());
/**
* キャラクターデータを表示名順にソートするための比較器.
*/
public static final Comparator SORT_DISPLAYNAME = new Comparator() {
public int compare(CharacterData o1, CharacterData o2) {
if (!o1.isValid() || !o2.isValid()) {
return o1.isValid() == o2.isValid() ? 0 : o1.isValid() ? 1 : -1;
}
int ret = o1.getName().compareTo(o2.getName());
if (ret == 0) {
ret = o1.getId().compareTo(o2.getId());
}
if (ret == 0) {
ret = o1.getDocBase().toString().compareTo(o2.getDocBase().toString());
}
return ret;
}
};
/**
* キャラクターデータを定義しているXMLの位置.
* docBase自身はxml定義には含まれず、xmlをロードした位置を記憶するためにPersistentクラスによって設定される.
*/
private URI docBase;
/**
* キャラクターデータの内部用ID.
* キャラクターデータの構造を判定するために用いる.
*/
private String id;
/**
* キャラクターデータの更新番号.
* キャラクターデータの構造が変更されたことを識別するために用いる.
*/
private String rev;
/**
* 表示用名
*/
private String localizedName;
/**
* 作成者
*/
private String author;
/**
* 説明
*/
private String description;
/**
* イメージサイズ
*/
private Dimension imageSize;
/**
* カテゴリ(定義順)
*/
private OrderedMap partsCategories = OrderedMap.emptyMap();
/**
* 雑多なプロパティ.
*/
private Properties properties = new Properties();
/**
* プリセットのマップ.
* キーはプリセット自身のID、値はプリセット自身.
*/
private HashMap presets = new HashMap();
/**
* デフォルトのプリセットのID
*/
private String defaultPartsSetId;
/**
* カラーグループの定義.
*/
private OrderedMap colorGroups = OrderedMap.emptyMap();
/**
* お勧めリンクリスト.
* Ver0.96以前には存在しないのでnullになり得る.
*/
private List recommendationURLList;
/**
* パーツカラーマネージャ.
* (非シリアライズデータ、デシリアライズ時には新規インスタンスが作成される).
*/
private transient PartsColorManager partsColorMrg = new PartsColorManager(this);
/**
* パーツデータローダー.
* パーツをロードしたときに設定され、リロードするときに使用する.
* パーツを一度もロードしていない場合はnull.
* (非シリアライズデータ、デシリアライズ時はnullのまま).
*/
private transient PartsDataLoader partsDataLoader;
/**
* パーツイメージのセット.
* (キャラクターセットはパーツイメージをもったままシリアライズされることは想定していないが、可能ではある。)
*/
private Map> images
= new HashMap>();
/**
* シリアライズする
* @param stream 出力先
* @throws IOException 失敗
*/
private void writeObject(java.io.ObjectOutputStream stream) throws IOException {
stream.defaultWriteObject();
}
/**
* 基本情報のみをコピーして返します.
* DocBase, ID, REV, Name, Author, Description, ImageSize、および, PartsCategory, ColorGroup, PartSetのコレクションがコピーされます.
* それ以外のものはコピーされません.
* @return 基本情報をコピーした新しいインスタンス
*/
public CharacterData duplicateBasicInfo() {
return duplicateBasicInfo(true);
}
/**
* 基本情報のみをコピーして返します.
* DocBase, ID, REV, Name, Author, Description, ImageSize、および, PartsCategory, ColorGroupがコピーされます.
* 引数のneedPartsSetがtrueの場合は,PartSetのコレクションもコピーされます.
* ディレクトリの監視状態、お勧めリンクもコピーされます.
* それ以外のものはコピーされません.
* @param needPartsSets パーツセットもコピーする場合、falseの場合はパーツセットは空となります.
* @return 基本情報をコピーした新しいインスタンス
*/
public CharacterData duplicateBasicInfo(boolean needPartsSets) {
CharacterData cd = new CharacterData();
cd.setId(this.id);
cd.setRev(this.rev);
cd.setDocBase(this.docBase);
cd.setName(this.localizedName);
cd.setAuthor(this.author);
cd.setDescription(this.description);
cd.setImageSize((Dimension)(this.imageSize == null ? null : this.imageSize.clone()));
cd.setWatchDirectory(this.isWatchDirectory());
ArrayList recommendationURLList = null;
if (this.recommendationURLList != null) {
recommendationURLList = new ArrayList();
for (RecommendationURL recommendationUrl : this.recommendationURLList) {
recommendationURLList.add(recommendationUrl.clone());
}
}
cd.setRecommendationURLList(recommendationURLList);
ArrayList partsCategories = new ArrayList();
partsCategories.addAll(this.getPartsCategories());
cd.setPartsCategories(partsCategories.toArray(new PartsCategory[partsCategories.size()]));
ArrayList colorGroups = new ArrayList();
colorGroups.addAll(this.getColorGroups());
cd.setColorGroups(colorGroups);
if (needPartsSets) {
for (PartsSet partsSet : this.getPartsSets().values()) {
cd.addPartsSet(partsSet.clone());
}
cd.setDefaultPartsSetId(this.defaultPartsSetId);
}
return cd;
}
/**
* キャラクターデータが同じ構造であるか?
* カラーグループ、カテゴリ、レイヤーの各情報が等しければtrue、それ以外はfalse.
* 上記以外の項目(コメントや作者、プリセット等)については判定しない.
* サイズ、カラーグループの表示名や順序、カテゴリの順序や表示名、
* 複数アイテム可などの違いは構造の変更とみなさない.
* レイヤーはレイヤーID、重ね合わせ順、対象ディレクトリの3点が変更されている場合は構造の変更とみなす.
* いずれも個数そのものが変わっている場合は変更とみなす.
* 自分または相手がValidでなければ常にfalseを返す.
* @param other 比較対象, null可
* @return 同じ構造であればtrue、そうでなければfalse
*/
public boolean isSameStructure(CharacterData other) {
if (!this.isValid() || other == null || !other.isValid()) {
// 自分または相手がinvalidであれば構造的には常に不一致と見なす.
return false;
}
// カラーグループが等しいか? (順序は問わない)
// IDのみによって判定する
ArrayList colorGroup1 = new ArrayList(getColorGroups());
ArrayList colorGroup2 = new ArrayList(other.getColorGroups());
if (colorGroup1.size() != colorGroup2.size()) {
return false;
}
if (!colorGroup1.containsAll(colorGroup2)) {
return false;
}
// カテゴリが等しいか? (順序は問わない)
// IDによってのみ判定する.
ArrayList categories1 = new ArrayList(getPartsCategories());
ArrayList categories2 = new ArrayList(other.getPartsCategories());
Comparator sortCategoryId = new Comparator() {
public int compare(PartsCategory o1, PartsCategory o2) {
int ret = o1.getCategoryId().compareTo(o2.getCategoryId());
if (ret == 0) {
ret = o1.getOrder() - o2.getOrder();
}
return ret;
}
};
// カテゴリID順に並び替えて, IDのみを比較する.
Collections.sort(categories1, sortCategoryId);
Collections.sort(categories2, sortCategoryId);
int numOfCategories = categories1.size();
if (numOfCategories != categories2.size()) {
// カテゴリ数不一致
return false;
}
for (int idx = 0; idx < numOfCategories; idx++) {
PartsCategory category1 = categories1.get(idx);
PartsCategory category2 = categories2.get(idx);
String categoryId1 = category1.getCategoryId();
String categoryId2 = category2.getCategoryId();
if ( !categoryId1.equals(categoryId2)) {
// カテゴリID不一致
return false;
}
}
// レイヤーが等しいか?
// ID、重ね順序、dirによってのみ判定する.
int mx = categories1.size();
for (int idx = 0; idx < mx; idx++) {
PartsCategory category1 = categories1.get(idx);
PartsCategory category2 = categories2.get(idx);
ArrayList layers1 = new ArrayList(category1.getLayers());
ArrayList layers2 = new ArrayList(category2.getLayers());
Comparator sortLayerId = new Comparator() {
public int compare(Layer o1, Layer o2) {
int ret = o1.getId().compareTo(o2.getId());
if (ret == 0) {
ret = o1.getOrder() - o2.getOrder();
}
return ret;
}
};
Collections.sort(layers1, sortLayerId);
Collections.sort(layers2, sortLayerId);
// ID、順序、Dirで判断する.(それ以外のレイヤー情報はequalsでは比較されない)
if ( !layers1.equals(layers2)) {
// レイヤー不一致
return false;
}
}
return true;
}
/**
* 引数で指定したキャラクター定義とアッパーコンパチブルであるか?
* 構造が同一であるか、サイズ違い、もしくはレイヤーの順序、カテゴリの順序、
* もしくはレイヤーまたはカテゴリが増えている場合で、減っていない場合はtrueとなる.
* 引数がnullの場合は常にfalseとなる.
* @param other 前の状態のキャラクター定義、null可
* @return アッパーコンパチブルであればtrue、そうでなければfalse
*/
public boolean isUpperCompatibleStructure(CharacterData other) {
if (!this.isValid() || other == null || !other.isValid()) {
// 自分または相手がinvalidであれば構造的には常に互換性なしと見なす.
return false;
}
// カラーグループが等しいか? (順序は問わない)
// IDのみによって判定する
ArrayList colorGroupNew = new ArrayList(getColorGroups());
ArrayList colorGroupOld = new ArrayList(other.getColorGroups());
if (!colorGroupNew.containsAll(colorGroupOld)) {
// 自分が相手分のすべてのものを持っていなければ互換性なし.
return false;
}
// カテゴリをすべて含むか? (順序は問わない)
// IDによってのみ判定する.
Map categoriesNew = new HashMap();
for (PartsCategory category : getPartsCategories()) {
categoriesNew.put(category.getCategoryId(), category);
}
Map categoriesOld = new HashMap();
for (PartsCategory category : other.getPartsCategories()) {
categoriesOld.put(category.getCategoryId(), category);
}
if ( !categoriesNew.keySet().containsAll(categoriesOld.keySet())) {
// 自分が相手のすべてのカテゴリを持っていなければ互換性なし.
return false;
}
// レイヤーをすべて含むか?
// ID、Dirによってのみ判定する.
for (Map.Entry categoryOldEntry : categoriesOld.entrySet()) {
String categoryId = categoryOldEntry.getKey();
PartsCategory categoryOld = categoryOldEntry.getValue();
PartsCategory categoryNew = categoriesNew.get(categoryId);
if (categoryNew == null) {
return false;
}
Map layersNew = new HashMap();
for (Layer layer : categoryNew.getLayers()) {
layersNew.put(layer.getId(), layer);
}
Map layersOld = new HashMap();
for (Layer layer : categoryOld.getLayers()) {
layersOld.put(layer.getId(), layer);
}
if ( !layersNew.keySet().containsAll(layersOld.keySet())) {
// 自分が相手のすべてのレイヤー(ID)を持っていなければ互換性なし.
return false;
}
for (Map.Entry layerOldEntry : layersOld.entrySet()) {
String layerId = layerOldEntry.getKey();
Layer layerOld = layerOldEntry.getValue();
Layer layerNew = layersNew.get(layerId);
if (layerNew == null) {
return false;
}
File dirOld = new File(layerOld.getDir());
File dirNew = new File(layerNew.getDir());
if ( !dirOld.equals(dirNew)) {
// ディレクトリが一致しなければ互換性なし.
return false;
}
}
}
return true;
}
/**
* デシリアライズする.
* @param stream 入力もと
* @throws IOException 失敗
* @throws ClassNotFoundException 失敗
*/
private void readObject(java.io.ObjectInputStream stream) throws IOException, ClassNotFoundException {
stream.defaultReadObject();
partsColorMrg = new PartsColorManager(this);
}
/**
* お勧めリンクのリストを取得する.
* 古いキャラクターデータで、お勧めリストノードが存在しない場合はnullとなる.
* @return お気に入りリンクのリスト、もしくはnull
*/
public List getRecommendationURLList() {
return recommendationURLList;
}
/**
* お勧めリンクリストを設定する.
* @param recommendationURLList、null可
*/
public void setRecommendationURLList(
List recommendationURLList) {
this.recommendationURLList = recommendationURLList;
}
/**
* 作者を設定する.
* @param author 作者
*/
public void setAuthor(String author) {
this.author = author;
}
/**
* 説明を設定する.
* 説明の改行コードはプラットフォーム固有の改行コードに変換される.
* @param description
*/
public void setDescription(String description) {
if (description != null) {
description = description.replace("\r\n", "\n");
description = description.replace("\r", "\n");
description = description.replace("\n", System.getProperty("line.separator"));
}
this.description = description;
}
public String getAuthor() {
return author;
}
/**
* 説明を取得する.
* 説明の改行コードはプラットフォーム固有の改行コードとなる.
* @return 説明
*/
public String getDescription() {
return description;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getRev() {
return rev;
}
public void setRev(String rev) {
this.rev = rev;
}
public void setDocBase(URI docBase) {
this.docBase = docBase;
}
public URI getDocBase() {
return docBase;
}
/**
* ディレクトリを監視するか? (デフォルトは監視する)
* @return ディレクトリを監視する場合はtrue
*/
public boolean isWatchDirectory() {
try {
String value = properties.getProperty("watch-dir");
if (value != null) {
return Boolean.parseBoolean(value);
}
} catch (RuntimeException ex) {
logger.log(Level.WARNING, "watch-dir property is invalid.", ex);
}
// デフォルトは監視する.
return true;
}
/**
* ディレクトリを監視するか指定する.
* @param watchDir 監視する場合はtrue、しない場合はfalse
*/
public void setWatchDirectory(boolean watchDir) {
properties.setProperty("watch-dir", Boolean.toString(watchDir));
}
public String getProperty(String key) {
if (key == null || key.trim().length() == 0) {
throw new IllegalArgumentException();
}
return properties.getProperty(key.trim());
}
public void setProperty(String key, String value) {
if (key == null || key.trim().length() == 0) {
throw new IllegalArgumentException();
}
properties.setProperty(key.trim(), value);
}
public Collection getPropertyNames() {
ArrayList names = new ArrayList();
for (Object key : properties.keySet()) {
names.add(key.toString());
}
return names;
}
/**
* 有効なキャラクターデータであるか?
* ID, Name, DocBaseが存在するものが有効なキャラクターデータである.
* @return 有効であればtrue
*/
public boolean isValid() {
return id != null && id.length() > 0 && localizedName != null
&& localizedName.length() > 0 && docBase != null;
}
/**
* 編集可能か?
* まだdocbaseが指定されていない新しいインスタンスであるか、
* もしくはdocbaseが実在しファイルであり且つ読み込み可能であるか、
* もしくはdocbaseがまだ存在しない場合は、その親ディレクトリが読み書き可能であるか?
* @return 編集可能であればtrue
*/
public boolean canWrite() {
try {
checkWritable();
return true;
} catch (IOException ex) {
return false;
}
}
/**
* 編集可能か?
* まだdocbaseが指定されていない新しいインスタンスであるか、
* もしくはdocbaseが実在しファイルであり且つ読み込み可能であるか、
* もしくはdocbaseがまだ存在しない場合は、その親ディレクトリが読み書き可能であるか?
* @throws IOException 編集可能でなければIOException例外が発生する.
*/
public void checkWritable() throws IOException {
if (docBase == null) {
throw new IOException("invalid profile: " + this);
}
if ( !"file".equals(docBase.getScheme())) {
throw new IOException("ファイルプロトコルではないため書き込みはできません。:" + docBase);
}
File xmlFile = new File(docBase);
if (xmlFile.exists()) {
// character.xmlファイルがある場合
if ( !xmlFile.canWrite() || !xmlFile.canRead()) {
throw new IOException("書き込み、もしくは読み込みが禁止されているプロファイルです。" + docBase);
}
} else {
// character.xmlファイルが、まだ存在していない場合
File parent = xmlFile.getParentFile();
if ( !parent.exists()) {
throw new IOException("親ディレクトリがありません。" + docBase);
}
if ( !parent.canWrite() || !parent.canRead()) {
throw new IOException("親ディレクトリは書き込み、もしくは読み込みが禁止されています。" + docBase);
}
}
}
/**
* キャラクター名を設定する.
* @param name
*/
public void setName(String name) {
this.localizedName = name;
}
/**
* キャラクター名を取得する.
* @return
*/
public String getName() {
return localizedName;
}
public void setImageSize(Dimension imageSize) {
if (imageSize != null) {
imageSize = (Dimension) imageSize.clone();
}
this.imageSize = imageSize;
}
public Dimension getImageSize() {
return imageSize != null ? (Dimension) imageSize.clone() : null;
}
public void setColorGroups(Collection colorGroups) {
if (colorGroups == null) {
throw new IllegalArgumentException();
}
ArrayList colorGroupWithNA = new ArrayList();
colorGroupWithNA.add(ColorGroup.NA);
for (ColorGroup colorGroup : colorGroups) {
if (colorGroup.isEnabled()) {
colorGroupWithNA.add(colorGroup);
}
}
OrderedMap ret = new OrderedMap(
colorGroupWithNA,
new OrderedMap.KeyDetector() {
public String getKey(ColorGroup data) {
return data.getId();
}
});
this.colorGroups = ret;
}
/**
* カラーグループIDからカラーグループを取得する.
* 存在しない場合はN/Aを返す.
* @param colorGroupId カラーグループID
* @return カラーグループ
*/
public ColorGroup getColorGroup(String colorGroupId) {
ColorGroup cg = colorGroups.get(colorGroupId);
if (cg != null) {
return cg;
}
return ColorGroup.NA;
}
public Collection getColorGroups() {
return colorGroups.values();
}
public PartsCategory getPartsCategory(String categoryId) {
if (partsCategories == null) {
return null;
}
return partsCategories.get(categoryId);
}
public void setPartsCategories(PartsCategory[] partsCategories) {
if (partsCategories == null) {
partsCategories = new PartsCategory[0];
}
this.partsCategories = new OrderedMap(
Arrays.asList(partsCategories),
new OrderedMap.KeyDetector() {
public String getKey(PartsCategory data) {
return data.getCategoryId();
}
});
}
public List getPartsCategories() {
return partsCategories.asList();
}
/**
* パーツデータがロード済みであるか?
* 少なくとも{@link #loadPartsData(PartsDataLoader)}が一度呼び出されていればtrueとなる.
* falseの場合はパーツローダが設定されていないことを示す.
* @return パーツデータがロード済みであればtrue、そうでなければfalse
*/
public boolean isPartsLoaded() {
return partsDataLoader != null;
}
/**
* パーツデータをロードする.
* パーツローダを指定し、このローダはパーツの再ロード時に使用するため保持される.
* @param partsDataLoader ローダー
*/
public void loadPartsData(PartsDataLoader partsDataLoader) {
if (partsDataLoader == null) {
throw new IllegalArgumentException();
}
this.partsDataLoader = partsDataLoader;
reloadPartsData();
}
/**
* パーツデータをリロードする.
* ロード時に使用したローダーを使ってパーツを再ロードします.
* まだ一度もロードしていない場合はIllegalStateException例外が発生します.
* @return 変更があった場合はtrue、ない場合はfalse
*/
public boolean reloadPartsData() {
if (partsDataLoader == null) {
throw new IllegalStateException("partsDataLoader is not set.");
}
// パーツデータのロード
images.clear();
for (PartsCategory category : partsCategories.asList()) {
images.put(category, partsDataLoader.load(category));
}
// NOTE: とりあえずパーツの変更を検査せず、常に変更ありにしておく。とりあえず実害ない。
return true;
}
/**
* {@inheritDoc}
*/
public PartsSpec getPartsSpec(PartsIdentifier partsIdentifier) {
if (partsIdentifier == null) {
throw new IllegalArgumentException();
}
PartsCategory partsCategory = partsIdentifier.getPartsCategory();
Map partsSpecMap = images.get(partsCategory);
if (partsSpecMap != null) {
PartsSpec partsSpec = partsSpecMap.get(partsIdentifier);
if (partsSpec != null) {
return partsSpec;
}
}
return null;
}
/**
* {@inheritDoc}
*/
public Map getPartsSpecMap(PartsCategory category) {
Map partsImageMap = images.get(category);
if (partsImageMap == null) {
return Collections.emptyMap();
}
return partsImageMap;
}
public PartsColorManager getPartsColorManager() {
return this.partsColorMrg;
}
/**
* パーツセットを登録します.
* お気に入りとプリセットの両方の共用です.
* IDおよび名前がないものは登録されず、falseを返します.
* パーツセットは、このキャラクター定義に定義されているカテゴリに正規化されます.
* 正規化された結果カテゴリが一つもなくなった場合は何も登録されず、falseを返します.
* 登録された場合はtrueを返します.
* 同一のIDは上書きされます.
* @param partsSet
* @return 登録された場合はtrue、登録できない場合はfalse
*/
public boolean addPartsSet(PartsSet partsSet) {
if (partsSet == null) {
throw new IllegalArgumentException();
}
if (partsSet.getPartsSetId() == null
|| partsSet.getPartsSetId().length() == 0
|| partsSet.getLocalizedName() == null
|| partsSet.getLocalizedName().length() == 0) {
return false;
}
PartsSet compatiblePartsSet = partsSet.createCompatible(this);
if (compatiblePartsSet.isEmpty()) {
return false;
}
presets.put(compatiblePartsSet.getPartsSetId(), compatiblePartsSet);
return true;
}
/**
* プリセットパーツおよびパーツセット(Favorites)のコレクション.
* @return パーツセットのコレクション
*/
public Map getPartsSets() {
return presets;
}
/**
* プリセットパーツおよびパーツセットをリセットします.
* @param noRemovePreset プリセットは削除せず残し、プリセット以外のパーツセットをクリアする場合はtrue、falseの場合は全て削除される.
*/
public void clearPartsSets(boolean noRemovePreset) {
if (!noRemovePreset) {
// 全部消す
presets.clear();
defaultPartsSetId = null;
} else {
// プリセット以外を消す
Iterator> ite = presets.entrySet().iterator();
while (ite.hasNext()) {
Map.Entry entry = ite.next();
if (!entry.getValue().isPresetParts()) {
// デフォルトパーツセットであれば、デフォルトパーツセットもnullにする.
// (ただし、デフォルトパーツセットはプリセットであることを想定しているので、この処理は安全策用。)
if (entry.getKey().equals(defaultPartsSetId)) {
defaultPartsSetId = null;
}
ite.remove();
}
}
}
}
/**
* デフォルトのパーツセットを取得する.
* そのパーツセットIDが実在するか、あるいは、それがプリセットであるか、などは一切関知しない.
* 呼び出しもとで必要に応じてチェックすること.
* @return デフォルトとして指定されているパーツセットのID、なければnull
*/
public String getDefaultPartsSetId() {
return defaultPartsSetId;
}
/**
* デフォルトのパーツセットIDを指定する.
* nullの場合はデフォルトのパーツセットがないことを示す.
* パーツセットはプリセットであることが想定されるが、
* 実際に、その名前のパーツセットが存在するか、あるいは、そのパーツセットがプリセットであるか、などの判定は一切行わない.
* @param defaultPartsSetId パーツセットID、もしくはnull
*/
public void setDefaultPartsSetId(String defaultPartsSetId) {
this.defaultPartsSetId = defaultPartsSetId;
}
@Override
public String toString() {
StringBuilder buf = new StringBuilder();
buf.append("character-id: " + id);
buf.append("/rev:" + rev);
buf.append("/name:" + localizedName);
buf.append("/image-size:" + imageSize.width + "x" + imageSize.height);
buf.append("/docBase:" + docBase);
return buf.toString();
}
}
charactermanaj/src/charactermanaj/model/ColorInfo.java 0000644 0001750 0001750 00000004633 11767047535 023345 0 ustar paulliu paulliu package charactermanaj.model;
import java.io.Serializable;
import charactermanaj.graphics.filters.ColorConvertParameter;
/**
* カラーグループおよび連動フラグを含む色情報.
* @author seraphy
*/
public class ColorInfo implements Serializable, Cloneable {
private static final long serialVersionUID = 2448550538711608223L;
private ColorConvertParameter colorParameter = new ColorConvertParameter();
private boolean syncColorGroup = false;
private ColorGroup colorGroup = ColorGroup.NA;
@Override
public ColorInfo clone() {
ColorInfo colorInfo;
try {
colorInfo = (ColorInfo) super.clone();
} catch (CloneNotSupportedException ex) {
throw new RuntimeException(ex.getMessage(), ex);
}
colorInfo.colorParameter = (ColorConvertParameter) this.colorParameter.clone();
return colorInfo;
}
@Override
public int hashCode() {
return colorParameter.hashCode() ^ colorGroup.hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (obj != null && obj instanceof ColorInfo) {
ColorInfo o = (ColorInfo) obj;
return colorGroup.equals(o.colorGroup)
&& syncColorGroup == o.syncColorGroup
&& colorParameter.equals(o.colorParameter);
}
return false;
}
public ColorConvertParameter getColorParameter() {
return colorParameter;
}
public void setColorParameter(ColorConvertParameter colorParameter) {
if (colorParameter == null) {
this.colorParameter = new ColorConvertParameter();
} else {
this.colorParameter = colorParameter;
}
}
public boolean isSyncColorGroup() {
return syncColorGroup;
}
public void setSyncColorGroup(boolean syncColorGroup) {
this.syncColorGroup = syncColorGroup;
}
public ColorGroup getColorGroup() {
return colorGroup;
}
public void setColorGroup(ColorGroup colorGroup) {
if (colorGroup == null) {
this.colorGroup = ColorGroup.NA;
} else {
this.colorGroup = colorGroup;
}
}
@Override
public String toString() {
StringBuilder buf = new StringBuilder();
buf.append(getClass().getSimpleName() + "@" + Integer.toHexString(System.identityHashCode(this)));
buf.append("(");
buf.append("(colorGroup: " + colorGroup + "(sync: " + syncColorGroup + ")), ");
buf.append("(colorParameter: " + colorParameter + ")");
buf.append(")");
return buf.toString();
}
}
charactermanaj/src/charactermanaj/model/io/ 0000755 0001750 0001750 00000000000 11767047535 021211 5 ustar paulliu paulliu charactermanaj/src/charactermanaj/model/io/PartsImageDirectoryWatchEvent.java 0000644 0001750 0001750 00000000701 11767047535 027764 0 ustar paulliu paulliu package charactermanaj.model.io;
import java.util.EventObject;
import charactermanaj.model.CharacterData;
public class PartsImageDirectoryWatchEvent extends EventObject {
private static final long serialVersionUID = 8090309437115158185L;
public PartsImageDirectoryWatchEvent(CharacterData characterData) {
super(characterData);
}
public CharacterData getCharacterData() {
return (CharacterData) getSource();
}
}
charactermanaj/src/charactermanaj/model/io/RecentDataPersistent.java 0000644 0001750 0001750 00000013774 11767047535 026163 0 ustar paulliu paulliu package charactermanaj.model.io;
import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import charactermanaj.model.AppConfig;
import charactermanaj.model.CharacterData;
import charactermanaj.model.RecentData;
import charactermanaj.util.DirectoryConfig;
import charactermanaj.util.UserData;
import charactermanaj.util.UserDataFactory;
/**
* 最後に使用したデータの使用状況を保存・復元するためのクラス
* @author seraphy
*/
public final class RecentDataPersistent {
/**
* ロガー
*/
private static final Logger logger = Logger.getLogger(RecentDataPersistent.class.getName());
/**
* シングルトン
*/
private static final RecentDataPersistent inst = new RecentDataPersistent();
/**
* 最後に使用したプロファイルのコートベースを保存するファイル名
*/
private static final String RECENT_CHARACTER_SER = "recent-character.ser";
/**
* プライベートコンストラクタ
*/
private RecentDataPersistent() {
super();
}
/**
* インスタンスを取得する
* @return インスタンス
*/
public static RecentDataPersistent getInstance() {
return inst;
}
/**
* 最後に使用したキャラクターデータとして記録する.
* @param characterData
* @throws IOException 保存できなった場合
*/
public void saveRecent(CharacterData characterData) throws IOException {
if (characterData == null) {
throw new IllegalArgumentException();
}
if (!characterData.isValid()) {
return;
}
AppConfig appConfig = AppConfig.getInstance();
RecentData recentData = new RecentData();
recentData.setAppVersion(appConfig.getSpecificationVersion());
recentData.setDocBase(characterData.getDocBase());
UserData recentCharacterStore = getRecentCharacterStore();
// 他のキャラクターディレクトリ上のデータを取得しマージする.
Map recentDataMap = new HashMap();
try {
if (recentCharacterStore.exists()) {
Object rawRecentData = recentCharacterStore.load();
if (rawRecentData instanceof Map) {
@SuppressWarnings("unchecked")
Map prevRecentDataMap = (Map) rawRecentData;
for (Map.Entry entry : prevRecentDataMap.entrySet()) {
File dir = entry.getKey();
if (dir.exists() && dir.isDirectory()) {
// 現在も有効なものだけを保存する.
// (すでに存在しなくなっているものは除外する.)
RecentData prevRecentData = entry.getValue();
recentDataMap.put(dir, prevRecentData);
}
}
}
}
} catch (Exception ex) {
logger.log(Level.WARNING, "old recentDataFile load failed.", ex);
// 古い情報が取得できない場合でも最新のものだけは保存できるようにしておく。
}
// 保存する.
File currentCharactersDir = DirectoryConfig.getInstance().getCharactersDir();
recentDataMap.put(currentCharactersDir, recentData);
recentCharacterStore.save(recentDataMap);
}
/**
* 最後に使用したキャラクターデータを取得する.
* @return キャラクターデータ。最後に使用したデータが存在しない場合はnull
* @throws IOException 読み込みに失敗した場合
*/
public CharacterData loadRecent() throws IOException {
UserData recentCharacterStore = getRecentCharacterStore();
if (!recentCharacterStore.exists()) {
return null;
}
RecentData recentData;
try {
File currentCharactersDir = DirectoryConfig.getInstance().getCharactersDir();
Object rawRecentData = recentCharacterStore.load();
if (rawRecentData instanceof RecentData) {
// 旧形式 (単一)
recentData = (RecentData) rawRecentData;
logger.log(Level.INFO, "old-recentdata-type: " + recentData);
// 旧形式で保存されているURIが、現在選択しているキャラクターデータと同じ親ディレクトリ
// でなければ復元しない.
URI uri = recentData.getDocBase();
File parentDir = new File(uri).getParentFile().getParentFile(); // 2段上
if (!currentCharactersDir.equals(parentDir)) {
logger.log(Level.INFO,
"unmatched characters-dir. current="
+ currentCharactersDir + "/recent="
+ parentDir);
recentData = null;
}
} else if (rawRecentData instanceof Map) {
// 新形式 (複数のキャラクターディレクトリに対応)
@SuppressWarnings("unchecked")
Map recentDataMap = (Map) rawRecentData;
recentData = recentDataMap.get(currentCharactersDir);
logger.log(Level.FINE, "recent-data: " + currentCharactersDir + "=" + recentData);
} else {
// 不明な形式
logger.log(Level.SEVERE,
"invalid file format. " + recentCharacterStore
+ "/class=" + rawRecentData.getClass());
recentData = null;
}
} catch (Exception ex) {
// RecentData情報の復元に失敗した場合は最後に使用したデータが存在しないものとみなす.
logger.log(Level.WARNING, "recent data loading failed. " + recentCharacterStore, ex);
recentData = null;
}
if (recentData != null) {
CharacterDataPersistent persist = CharacterDataPersistent.getInstance();
return persist.loadProfile(recentData.getDocBase());
}
// 履歴がない場合、もしくは読み取れなかった場合はnullを返す.
return null;
}
/**
* 最後に使用したキャラクタデータの保存先を取得する
* @return 保存先
*/
protected UserData getRecentCharacterStore() {
UserDataFactory userDataFactory = UserDataFactory.getInstance();
UserData recentCharacterStore = userDataFactory.getUserData(RECENT_CHARACTER_SER);
return recentCharacterStore;
}
}
charactermanaj/src/charactermanaj/model/io/CharacterDataZipFileWriter.java 0000644 0001750 0001750 00000007273 11767047535 027233 0 ustar paulliu paulliu package charactermanaj.model.io;
import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.CodingErrorAction;
import org.apache.tools.zip.ZipEntry;
import org.apache.tools.zip.ZipOutputStream;
import charactermanaj.model.AppConfig;
public class CharacterDataZipFileWriter extends AbstractCharacterDataArchivedFileWriter {
/**
* Zipストリーム
*/
protected ZipOutputStream zipOutStm;
/**
* ファイル名のエンコーディング
*/
protected CharsetEncoder enc;
/**
* ルートコンテンツへのプレフィックス
*/
protected String rootPrefix = "";
public CharacterDataZipFileWriter(File outFile) throws IOException {
super(outFile);
AppConfig appConfig = AppConfig.getInstance();
String zipNameEncoding = appConfig.getZipNameEncoding();
// コンストラクタにストリームではなくファイル名を指定することで、
// 内部でランダムアクセスファイルを使うようになるためヘッダのCRCチェックの書き込み等で有利
this.zipOutStm = new ZipOutputStream(tmpFile);
// ファイル名の文字コードを設定する.
// (JDKの標準のZipOutputStreamはUTF-8になるが、一般的にはMS932が多いため、Apache Antのものを借用し指定する.)
this.enc = Charset.forName(zipNameEncoding).newEncoder();
zipOutStm.setEncoding(zipNameEncoding);
enc.onUnmappableCharacter(CodingErrorAction.REPORT);
// zipの場合、根本に1つフォルダをたてておく.
// 一般的なフォルダ圧縮したものと体裁をそろえるため.
String fname = outFile.getName();
int extpos = fname.lastIndexOf('.');
if (extpos > 0) { // ドットで始まる名前の場合は無視
fname = fname.substring(0, extpos);
}
setRootPrefix(fname);
}
public void setRootPrefix(String rootPrefix) {
if (rootPrefix == null || rootPrefix.trim().equals("/")) {
rootPrefix = "";
}
if (rootPrefix.length() > 0 && !rootPrefix.endsWith("/")) {
rootPrefix += "/";
}
this.rootPrefix = rootPrefix.trim();
}
public String getRootPrefix() {
return rootPrefix;
}
@Override
protected void closeEntry() throws IOException {
zipOutStm.closeEntry();
}
@Override
protected OutputStream getOutputStream() throws IOException {
return zipOutStm;
}
@Override
protected void putNextEntry(String name, long lastModified)
throws IOException {
// ルートプレフィックスをすべてのエントリの登録時に付与する.
String fname = rootPrefix + name;
// ファイル名がキャラクターセットに合致するか?
checkName(fname);
// Zipエントリの登録
ZipEntry entry = new ZipEntry(fname);
if (lastModified > 0) {
entry.setTime(lastModified);
}
zipOutStm.putNextEntry(entry);
}
protected void internalClose() throws IOException {
zipOutStm.close();
}
/**
* ファイル名がエンコーディング可能であるかチェックする.
* @param name チェックする名前
* @throws IOException ファイル名が不正である場合
* @throws UnsupportedEncodingException ファイル名がエンコーディングできない場合
*/
protected void checkName(String name) throws UnsupportedEncodingException, IOException {
if (name == null || name.length() == 0) {
throw new IOException("missing entry name");
}
if (!enc.canEncode(name)) {
throw new UnsupportedEncodingException("file name encoding error.: " + name);
}
}
}
charactermanaj/src/charactermanaj/model/io/CharacterDataDirectoryFile.java 0000644 0001750 0001750 00000010314 11767047535 027226 0 ustar paulliu paulliu package charactermanaj.model.io;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.util.Collection;
import java.util.Collections;
import java.util.logging.Level;
import java.util.logging.Logger;
import charactermanaj.model.CharacterData;
/**
* ディレクトリをアーカイブと見立てる
* @author seraphy
*/
public class CharacterDataDirectoryFile extends AbstractCharacterDataArchiveFile {
/**
* ロガー
*/
private static final Logger logger = Logger.getLogger(CharacterDataDirectoryFile.class.getName());
/**
* 対象ディレクトリ
*/
protected File baseDir;
/**
* ディレクトリ上のファイルコンテンツ
*
* @author seraphy
*/
protected static class DirFileContent implements FileContent {
/**
* ディレクトリ名 + ファイル名からなるエントリ名.
* エントリ名の区切り文字は常に「/」とする.
*/
private String entryName;
/**
* 実際のファイルへのパス
*/
private File entry;
protected DirFileContent(File entry, String entryName) {
this.entry = entry;
this.entryName = entryName;
}
public String getEntryName() {
return entryName;
}
public long lastModified() {
return entry.lastModified();
}
public InputStream openStream() throws IOException {
return new FileInputStream(entry);
}
}
/**
* アーカイブファイルをベースとしたURIを返す.
* @param name コンテンツ名
* @return URI
* @throws IOException URIを生成できない場合
*/
protected URI getContentURI(String name) throws IOException {
return new File(baseDir, name).toURI();
}
@Override
public Collection getPartsImageContents(
CharacterData characterData, boolean newly) {
if (!newly && isOverlapped(characterData)) {
// 既存のプロファイルへのインポートで指定されたインポートもととなるディレクトリが
// 既存のプロファイルのディレクトリと重なっていれば自分自身のインポートであるとして
// 空のパーツリストを返す.
return Collections.emptyList();
}
return super.getPartsImageContents(characterData, newly);
}
/**
* このディレクトリに対してターゲットプロファイルのディレクトリがかぶっているか?
* つまり、ターゲット自身のディレクトリをソースとしていないか?
* @param characterData ソースプロファイル
* @return 被っている場合はtrue、被っていない場合はfalse
*/
protected boolean isOverlapped(CharacterData characterData) {
if (characterData == null) {
return false;
}
URI docBase = characterData.getDocBase();
if (docBase == null || !"file".equals(docBase.getScheme())) {
return false;
}
String folderPlace = File.separator;
String basePath = new File(docBase).getParent() + folderPlace;
String sourcePath = baseDir.getPath() + folderPlace;
// インポートもとディレクトリがインポート先のキャラクター定義のディレクトリを含むか?
boolean result = basePath.contains(sourcePath);
logger.log(Level.FINE, "checkOverlapped: " + basePath + " * " + sourcePath + " :" + result);
return result;
}
public void close() throws IOException {
// ディレクトリなのでクローズ処理は必要ない.
}
public CharacterDataDirectoryFile(File file) throws IOException {
super(file);
baseDir = file;
load(baseDir, "");
searchRootPrefix();
}
private void load(File dir, String prefix) {
if (!dir.exists() || !dir.isDirectory()) {
// ディレクトリでなければ何もせず戻る
return;
}
for (File file : dir.listFiles()) {
String name = file.getName();
String entryName = prefix + name;
if (file.isDirectory()) {
// エントリ名の区切り文字は常に「/」とする. (ZIP/JARのentry互換のため)
load(file, entryName + "/");
} else {
addEntry(new DirFileContent(file, entryName));
}
}
}
}
charactermanaj/src/charactermanaj/model/io/ExportInfoKeys.java 0000644 0001750 0001750 00000000540 11767047535 025004 0 ustar paulliu paulliu package charactermanaj.model.io;
public interface ExportInfoKeys {
String EXPORT_PRESETS = "EXPORT_PRESETS";
String EXPORT_SAMPLE_PICTURE = "EXPORT_SAMPLE_PICTURE";
String EXPORT_CHARACTER_DATA = "EXPORT_CHARACTER_DATA";
String EXPORT_PARTS_IMAGES = "EXPORT_PARTS_IMAGES";
String EXPORT_TIMESTAMP = "EXPORT_TIMESTAMP";
}
charactermanaj/src/charactermanaj/model/io/CharacterDataJarArchiveFile.java 0000644 0001750 0001750 00000002243 11767047535 027302 0 ustar paulliu paulliu package charactermanaj.model.io;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
public class CharacterDataJarArchiveFile extends AbstractCharacterDataArchiveFile {
protected JarFile jarFile;
protected class JarFileContent implements FileContent {
private JarEntry entry;
protected JarFileContent(JarEntry entry) {
this.entry = entry;
}
public String getEntryName() {
return entry.getName();
}
public long lastModified() {
return entry.getTime();
}
public InputStream openStream() throws IOException {
return jarFile.getInputStream(entry);
}
}
public void close() throws IOException {
jarFile.close();
}
public CharacterDataJarArchiveFile(File file) throws IOException {
super(file);
jarFile = new JarFile(file);
load();
}
private void load() {
Enumeration enm = jarFile.entries();
while (enm.hasMoreElements()) {
JarEntry entry = enm.nextElement();
addEntry(new JarFileContent(entry));
}
searchRootPrefix();
}
}
charactermanaj/src/charactermanaj/model/io/FilePartsDataLoader.java 0000644 0001750 0001750 00000004427 11767047535 025675 0 ustar paulliu paulliu package charactermanaj.model.io;
import java.io.File;
import java.io.FileFilter;
import java.util.HashMap;
import java.util.Map;
import charactermanaj.graphics.io.FileImageResource;
import charactermanaj.model.Layer;
import charactermanaj.model.PartsCategory;
import charactermanaj.model.PartsFiles;
import charactermanaj.model.PartsIdentifier;
import charactermanaj.model.PartsSpec;
/**
* ディレクトリを指定して、そこからキャラクターのパーツデータをロードするローダー.
* @author seraphy
*
*/
public class FilePartsDataLoader implements PartsDataLoader {
/**
* ベースディレクトリ
*/
private File baseDir;
public FilePartsDataLoader(File baseDir) {
if (baseDir == null) {
throw new IllegalArgumentException();
}
this.baseDir = baseDir;
}
public File getBaseDir() {
return baseDir;
}
public Map load(PartsCategory category) {
if (category == null) {
throw new IllegalArgumentException();
}
final Map images = new HashMap();
for (Layer layer : category.getLayers()) {
File searchDir = new File(baseDir, layer.getDir());
if (!searchDir.exists() || !searchDir.isDirectory()) {
continue;
}
for (File imgFile : searchDir.listFiles(new FileFilter() {
public boolean accept(File pathname) {
if (pathname.isFile()) {
String lcfname = pathname.getPath().toLowerCase();
return lcfname.endsWith(".png");
}
return false;
}
})) {
String partsName = imgFile.getName();
int extpos = partsName.lastIndexOf(".");
if (extpos > 0) {
partsName = partsName.substring(0, extpos);
}
PartsIdentifier partsIdentifier = new PartsIdentifier(category, partsName, partsName);
PartsSpec partsSpec = images.get(partsIdentifier);
if (partsSpec == null) {
partsSpec = createPartsSpec(partsIdentifier);
images.put(partsIdentifier, partsSpec);
}
PartsFiles parts = partsSpec.getPartsFiles();
parts.put(layer, new FileImageResource(imgFile));
}
}
return images;
}
protected PartsSpec createPartsSpec(PartsIdentifier partsIdentifier) {
return new PartsSpec(partsIdentifier);
}
}
charactermanaj/src/charactermanaj/model/io/PartsDataLoaderFactory.java 0000644 0001750 0001750 00000002432 11767047535 026417 0 ustar paulliu paulliu package charactermanaj.model.io;
import java.io.File;
import java.io.IOException;
import java.net.URI;
/**
* パーツデータのローダーファクトリ.
* @author seraphy
*
*/
public class PartsDataLoaderFactory {
private static final PartsDataLoaderFactory singleton = new PartsDataLoaderFactory();
private PartsDataLoaderFactory() {
super();
}
public static PartsDataLoaderFactory getInstance() {
return singleton;
}
/**
* 設定ファイル(character.xml)のDocBaseをもとに、キャラクターデータのローダーを作成する.
* 現在のところ、fileプロトコルのみサポートする.
* @param docBase 設定ファイルのURI
* @return ローダー
* @throws IOException URIに対応するローダーが存在しないか、構築できない場合
*/
public PartsDataLoader createPartsLoader(URI docBase) throws IOException {
if (docBase == null) {
throw new IllegalArgumentException();
}
if (!"file".equals(docBase.getScheme())) {
throw new IOException("ファイル以外はサポートしていません。:" + docBase);
}
File docbaseFile = new File(docBase);
File baseDir = docbaseFile.getParentFile();
return new FilePartsDataLoader(baseDir);
}
}
charactermanaj/src/charactermanaj/model/io/PartsSpecDecorateLoader.java 0000644 0001750 0001750 00000005452 11767047535 026564 0 ustar paulliu paulliu package charactermanaj.model.io;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import charactermanaj.model.AppConfig;
import charactermanaj.model.ColorGroup;
import charactermanaj.model.PartsCategory;
import charactermanaj.model.PartsIdentifier;
import charactermanaj.model.PartsSpec;
/**
* パーツ名の末尾が、カラーグループの表記を括弧でくくったものと同じであれば、
* そのパーツ固有のカラーグループとして設定するためのデコレータ.
* このクラス自身はパーツのロードは行わず、コンストラクタで指定したローダーによりロードを行い、
* その結果に対してカラーグループの設定を行う.
*
* @author seraphy
*
*/
public class PartsSpecDecorateLoader implements PartsDataLoader {
private PartsDataLoader parent;
private Collection colorGroups;
/**
* パーツローダとカラーグループを指定して構築する.
* @param parent 元パーツローダー
* @param colorGroups カラーグループのコレクション、nullの場合は空とみなす.
*/
public PartsSpecDecorateLoader(PartsDataLoader parent, Collection colorGroups) {
if (parent == null) {
throw new IllegalArgumentException();
}
if (colorGroups == null) {
colorGroups = Collections.emptyList();
}
this.parent = parent;
this.colorGroups = colorGroups;
}
public Map load(PartsCategory category) {
Map partsSpecs = parent.load(category);
decolatePartsSpec(partsSpecs);
return partsSpecs;
}
/**
* パーツ識別子の表示名に、カラーグループの表示名により判定されるパターンに合致する場合、
* パーツ設定のカラーグループを、そのカラーグループとして設定する.
* @param partsSpecs パーツマップ
*/
protected void decolatePartsSpec(Map partsSpecs) {
String templ = AppConfig.getInstance().getPartsColorGroupPattern();
if (templ == null || templ.trim().length() == 0) {
// パターンが設定されていない場合は無視する.
return;
}
// パーツ名にカラーグループが含まれる場合、それを登録する.
for (ColorGroup colorGroup : colorGroups) {
String pattern = templ.replace("@", colorGroup.getLocalizedName());
Pattern pat = Pattern.compile(pattern);
for (PartsSpec partsSpec : partsSpecs.values()) {
Matcher mat = pat.matcher(partsSpec.getPartsIdentifier()
.getLocalizedPartsName());
if (mat.matches()) {
partsSpec.setColorGroup(colorGroup);
}
}
}
}
}
charactermanaj/src/charactermanaj/model/io/AbstractCharacterDataArchivedFileWriter.java 0000644 0001750 0001750 00000017306 11767047535 031700 0 ustar paulliu paulliu package charactermanaj.model.io;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.nio.charset.Charset;
import java.sql.Timestamp;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import charactermanaj.graphics.io.ImageResource;
import charactermanaj.graphics.io.ImageSaveHelper;
import charactermanaj.model.AppConfig;
import charactermanaj.model.CharacterData;
import charactermanaj.model.Layer;
import charactermanaj.model.PartsCategory;
import charactermanaj.model.PartsFiles;
import charactermanaj.model.PartsIdentifier;
import charactermanaj.model.PartsManageData;
import charactermanaj.model.PartsManageDataConverter;
import charactermanaj.model.PartsSet;
import charactermanaj.model.PartsSpec;
public abstract class AbstractCharacterDataArchivedFileWriter extends AbstractCharacterDataFileWriter {
protected AbstractCharacterDataArchivedFileWriter(File outFile) throws IOException {
super(outFile);
}
protected abstract OutputStream getOutputStream() throws IOException;
protected abstract void putNextEntry(String name, long lastModified) throws IOException;
protected abstract void closeEntry() throws IOException;
@Override
protected void internalWriteExportProp(Properties prop) throws IOException {
// export prop
putNextEntry("export-info.xml", 0);
prop.storeToXML(getOutputStream(), "exportProp");
}
@Override
protected void internalWriteCharacterData(CharacterData characterData)
throws IOException {
CharacterDataPersistent persist = CharacterDataPersistent.getInstance();
// character.xmlの出力
putNextEntry(CharacterDataPersistent.CONFIG_FILE, 0);
persist.writeXMLCharacterData(characterData, getOutputStream());
closeEntry();
// character.iniの出力
internalWriteCharacterIni(characterData);
}
/**
* character.iniを出力します.
* @param characterData キャラクターデータ
* @throws IOException 出力に失敗した場合
*/
protected void internalWriteCharacterIni(CharacterData characterData) throws IOException {
StringBuilder buf = new StringBuilder();
buf.append("; created by charactermanaj "
+ new Timestamp(System.currentTimeMillis()) + "\r\n");
buf.append("[Size]\r\n");
Dimension dim = characterData.getImageSize();
if (dim == null) {
dim = new Dimension(300, 400);
}
buf.append("size_x=" + dim.width + "\r\n");
buf.append("size_y=" + dim.height + "\r\n");
buf.append("\r\n");
buf.append("[Parts]\r\n");
Map partsMap = new HashMap();
for (PartsCategory partsCategory : characterData.getPartsCategories()) {
String categoryId = partsCategory.getCategoryId();
partsMap.put(categoryId, "");
}
Map partsSets = characterData.getPartsSets();
PartsSet partsSet = partsSets.get(characterData.getDefaultPartsSetId());
if (partsSet == null && !partsSets.isEmpty()) {
// デフォルトのパーツセットが指定されていない場合は、どれか1つを選択する.
partsSet = partsSets.values().iterator().next();
}
if (partsSet != null) {
for (Map.Entry> entry : partsSet
.entrySet()) {
PartsCategory partsCategory = entry.getKey();
StringBuilder partsNames = new StringBuilder();
for (PartsIdentifier partsIdentifier : entry.getValue()) {
if (partsNames.length() > 0) {
partsNames.append(",");
}
partsNames.append(partsIdentifier.getPartsName());
}
String categoryId = partsCategory.getCategoryId();
partsMap.put(categoryId, partsNames.toString());
}
}
for (PartsCategory partsCategory : characterData.getPartsCategories()) {
String categoryId = partsCategory.getCategoryId();
String partsNames = partsMap.get(categoryId);
buf.append(categoryId + "=" + partsNames + "\r\n");
}
// 色情報はすべてダミー(character.iniは色情報を省略しても問題ないようだが、一応)
buf.append("\r\n");
buf.append("[Color]\r\n");
buf.append("hair_rgb=0\r\n");
buf.append("hair_gray=0\r\n");
buf.append("eye_rgb=0\r\n");
buf.append("eye_gray=0\r\n");
buf.append("skin_rgb=0\r\n");
buf.append("skin_gray=0\r\n");
buf.append("body_rgb=0\r\n");
buf.append("body_gray=0\r\n");
// UTF16LEで出力する.
internalWriteTextUTF16LE(CharacterDataPersistent.COMPATIBLE_CONFIG_NAME, buf.toString());
}
@Override
protected void internalWriteTextUTF16LE(String name, String contents) throws IOException {
if (contents == null) {
contents = "";
}
// LFまたはCR改行であればCR/LF改行に変換.
contents = contents.replace("\r\n", "\n");
contents = contents.replace("\r", "\n");
contents = contents.replace("\n", "\r\n");
putNextEntry(name, 0);
OutputStream os = getOutputStream();
os.write((byte) 0xff);
os.write((byte) 0xfe);
os.flush();
Writer wr = new OutputStreamWriter(os, Charset.forName("UTF-16LE")) {
@Override
public void close() throws IOException {
// ZipのOutputStreamをクローズしてはならないため
// OutputStreamWriter自身はクローズは呼び出さない.
flush();
closeEntry();
}
};
try {
wr.append(contents);
wr.flush();
} finally {
wr.close();
}
}
@Override
protected void internalWriteSamplePicture(BufferedImage samplePicture)
throws IOException {
putNextEntry("preview.png", 0);
ImageSaveHelper imageSaveHelper = new ImageSaveHelper();
imageSaveHelper.savePicture(samplePicture, Color.white, getOutputStream(), "image/png", null);
closeEntry();
}
@Override
protected void internalWritePartsImages(
Map partsImages) throws IOException {
AppConfig appConfig = AppConfig.getInstance();
byte[] buf = new byte[appConfig.getJarTransferBufferSize()];
for (Map.Entry entry : partsImages.entrySet()) {
PartsIdentifier partsIdentifier = entry.getKey();
PartsSpec partsSpec = entry.getValue();
PartsFiles partsFiles = partsSpec.getPartsFiles();
for (Map.Entry imageEntry : partsFiles.entrySet()) {
Layer layer = imageEntry.getKey();
ImageResource imageResource = imageEntry.getValue();
String name = layer.getDir() + "/" + partsIdentifier.getPartsName() + ".png";
name = name.replace("//", "/");
putNextEntry(name, imageResource.lastModified());
OutputStream os = getOutputStream();
InputStream is = imageResource.openStream();
try {
int rd;
while ((rd = is.read(buf)) >= 0) {
os.write(buf, 0, rd);
}
} finally {
is.close();
}
closeEntry();
}
}
}
@Override
protected void internalWritePartsManageData(
Map partsImages) throws IOException {
PartsManageDataConverter partsManageDataConverter = new PartsManageDataConverter();
for (Map.Entry entry : partsImages.entrySet()) {
PartsIdentifier partsIdentifier = entry.getKey();
PartsSpec partsSpec = entry.getValue();
partsManageDataConverter.convert(partsIdentifier, partsSpec);
}
PartsManageData partsManageData = partsManageDataConverter.getPartsManageData();
CharacterDataPersistent persist = CharacterDataPersistent.getInstance();
putNextEntry("parts-info.xml", 0);
persist.savePartsManageData(partsManageData, getOutputStream());
closeEntry();
}
}
charactermanaj/src/charactermanaj/model/io/PartsImageDirectoryWatchAgentThread.java 0000644 0001750 0001750 00000025225 11767047535 031101 0 ustar paulliu paulliu package charactermanaj.model.io;
import java.io.File;
import java.io.FileFilter;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
import java.util.IdentityHashMap;
import java.util.LinkedList;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.zip.CRC32;
import charactermanaj.model.AppConfig;
import charactermanaj.model.CharacterData;
import charactermanaj.model.Layer;
import charactermanaj.model.PartsCategory;
public class PartsImageDirectoryWatchAgentThread implements Runnable {
/**
* ロガー
*/
private static final Logger logger = Logger.getLogger(PartsImageDirectoryWatchAgent.class.getName());
private final CharacterData characterData;
private final File baseDir;
/**
* リスナーとサスペンド要求マップのロックオブジェクト
*/
private final Object lockListeners = new Object();
/**
* 監視を通知されるリスナー.
*/
private LinkedList listeners
= new LinkedList();
/**
* サスペンド要求のマップ.
*/
private IdentityHashMap suspendStateMap
= new IdentityHashMap();
/**
* ロックオブジェクト
*/
private final Object lock = new Object();
/**
* 停止フラグ
*/
private volatile boolean stopFlag;
/**
* 監視インターバル
*/
private int dirWatchInterval;
/**
* スレッド、生成されていなければnull
*/
private Thread thread;
/**
* 監視結果1、まだ監視されていなければnull
*/
private volatile Long signature;
/**
* 監視結果2、検出されたアイテムの個数
*/
private volatile int itemCount;
/**
* 監視結果3、検出されたアイテムの最終更新日。ただし未来の日付は除外する。
*/
private volatile long maxLastModified;
public PartsImageDirectoryWatchAgentThread(CharacterData characterData) {
if (characterData == null) {
throw new IllegalArgumentException();
}
URI docBase = characterData.getDocBase();
File baseDir = null;
if (docBase != null && "file".equals(docBase.getScheme())) {
baseDir = new File(docBase).getParentFile();
}
this.characterData = characterData;
this.baseDir = baseDir;
this.dirWatchInterval = AppConfig.getInstance().getDirWatchInterval();
}
public CharacterData getCharcterData() {
return characterData;
}
/**
* 監視を開始する.
* 一定時間待機後、フォルダを監視し、前回監視結果と比較して変更があれば通知を行う.
* その処理をstop指示が来るまで繰り返す.
* 開始しても、まず指定時間待機するため、すぐにはディレクトリの走査は行わない.
* 且つ、初回監視結果は変更通知されないため、二回以上走査しないかぎり通知は発生しない.
* これは意図したものである.
* 明示的に初回監視を行うには明示的に{@link #reset()}を呼び出す.
*/
private void start() {
logger.log(Level.FINE, "watchAgent request start. " + this);
synchronized (lock) {
if (thread != null && thread.isAlive()) {
// すでに開始済みであれば何もしない.
return;
}
// 書き込み禁止キャラクター定義に対する監視を無効とするか?
AppConfig appConfig = AppConfig.getInstance();
if (appConfig.isDisableWatchDirIfNotWritable()) {
try {
if (baseDir == null || !baseDir.exists()
|| !baseDir.isDirectory() || !baseDir.canWrite()) {
logger.log(Level.INFO, "does not monitor the directory because it is not writable." + baseDir);
return;
}
URI docBase = characterData.getDocBase();
if (docBase != null) {
File docBaseFile = new File(docBase);
if (!docBaseFile.exists() || !docBaseFile.canWrite()) {
logger.log(Level.INFO,
"does not monitor the directory because the character.xml is not writable."
+ characterData);
return;
}
}
} catch (Exception ex) {
logger.log(Level.WARNING, "watch-dir start failed. " + characterData, ex);
return;
}
}
// スレッドを開始する.
stopFlag = false;
thread = new Thread(this);
thread.setDaemon(true);
thread.start();
}
}
/**
* 監視を停止する.
* @return 停止した場合はtrue、すでに停止していたか開始されていない場合はfalse
*/
private boolean stop() {
logger.log(Level.FINE, "watchAgent request stop. " + this);
boolean stopped = false;
synchronized (lock) {
// スレッドが生きていれば停止する.
if (thread != null && thread.isAlive()) {
stopFlag = true;
thread.interrupt();
try {
thread.join(10000); // 10Secs
} catch (InterruptedException ex) {
logger.log(Level.FINE, "stop request interrupted.", ex);
// 抜ける
}
stopped = true;
}
// スレッドは停止されていると見なす.
thread = null;
}
return stopped;
}
/**
* スレッドの停止フラグがたてられるまで、一定時間待機と監視とを永久に繰り返す.
* ただし、スレッド自身はデーモンとして動作させているので他の非デーモンスレッドが存在しなくなれば停止する.
*/
public void run() {
logger.log(Level.FINE, "watch-dir thead started. " + this);
// 初回スキャンは無視するためリセット状態とする.
this.signature = null;
// スキャンループ
while (!stopFlag) {
try {
Thread.sleep(dirWatchInterval);
watch(new Runnable() {
public void run() {
fireWatchEvent();
}
});
} catch (InterruptedException ex) {
logger.log(Level.FINE, "watch-dir thead interrupted.");
// 何もしない
} catch (Exception ex) {
logger.log(Level.SEVERE, "PartsImageDirectoryWatchAgent failed.", ex);
// 何もしない.
}
}
logger.log(Level.FINE, "watch-dir thead stopped. " + this);
}
/**
* 監視を行う.
* 停止フラグが設定されるか、割り込みされた場合は処理を中断してInterruptedException例外を返して終了する.
* @param notifier 通知するためのオブジェクト
* @throws InterruptedException 割り込みされた場合
*/
protected void watch(Runnable notifier) throws InterruptedException {
if (baseDir == null || !baseDir.exists() || !baseDir.isDirectory()) {
return;
}
int itemCount = 0;
long maxLastModified = 0;
long now = System.currentTimeMillis() + dirWatchInterval;
CRC32 crc = new CRC32();
for (PartsCategory partsCategory : characterData.getPartsCategories()) {
for (Layer layer : partsCategory.getLayers()) {
File watchDir = new File(baseDir, layer.getDir());
ArrayList files = new ArrayList();
if (watchDir.exists() && watchDir.isDirectory()) {
for (File file : watchDir.listFiles(new FileFilter() {
public boolean accept(File pathname) {
return pathname.isFile() && pathname.getName().toLowerCase().endsWith(".png");
}
})) {
if (Thread.interrupted() || stopFlag) {
throw new InterruptedException();
}
itemCount++;
long lastModified = file.lastModified();
if (lastModified <= now) {
// 未来の日付は除外する.
// 未来の日付のファイルが一つでもあると他のファイルが実際に更新されても判定できなくなるため。
maxLastModified = Math.max(maxLastModified, lastModified);
}
files.add(file.getName() + ":" + lastModified);
};
Collections.sort(files);
}
for (String file : files) {
crc.update(file.getBytes());
}
}
}
long signature = crc.getValue();
if (this.signature != null) {
// 初回は無視される.
if (this.signature.longValue() != signature
|| this.itemCount != itemCount
|| this.maxLastModified != maxLastModified) {
// ハッシュ値が異なるか、アイテム数が異なるか、最大の最終更新日が異なる場合、変更されたとみなす.
if (notifier != null) {
notifier.run();
}
}
}
this.signature = Long.valueOf(signature);
this.maxLastModified = maxLastModified;
this.itemCount = itemCount;
}
/**
* イベントリスナを登録する
* @param l リスナ
*/
public void addPartsImageDirectoryWatchListener(PartsImageDirectoryWatchListener l) {
if (l != null) {
synchronized (lockListeners) {
listeners.add(l);
}
changeSuspendState();
}
}
/**
* イベントリスナを登録解除する
* @param l リスナ
*/
public void removePartsImageDirectoryWatchListener(PartsImageDirectoryWatchListener l) {
if (l != null) {
synchronized (lockListeners) {
listeners.remove(l);
suspendStateMap.remove(l);
}
changeSuspendState();
}
}
public void suspend(PartsImageDirectoryWatchListener l) {
if (l != null) {
synchronized (lockListeners) {
Integer cnt = suspendStateMap.get(l);
if (cnt == null) {
cnt = Integer.valueOf(1);
} else {
cnt = cnt + 1;
}
suspendStateMap.put(l, cnt);
}
changeSuspendState();
}
}
public void resume(PartsImageDirectoryWatchListener l) {
if (l != null) {
synchronized (lockListeners) {
Integer cnt = suspendStateMap.get(l);
if (cnt != null) {
cnt = cnt - 1;
if (cnt > 0) {
suspendStateMap.put(l, cnt);
} else {
suspendStateMap.remove(l);
}
}
}
changeSuspendState();
}
}
protected void changeSuspendState() {
boolean active;
synchronized (lockListeners) {
// リスナが接続されており、且つ、サスペンド要求が一つもない場合はスレッド実行可
active = !listeners.isEmpty() && suspendStateMap.isEmpty();
}
if (active) {
start();
} else {
stop();
}
}
/**
* イベントを通知する.
*/
protected void fireWatchEvent() {
PartsImageDirectoryWatchListener[] listeners;
synchronized (this.listeners) {
listeners = this.listeners.toArray(new PartsImageDirectoryWatchListener[this.listeners.size()]);
}
PartsImageDirectoryWatchEvent e = new PartsImageDirectoryWatchEvent(characterData);
for (PartsImageDirectoryWatchListener listener : listeners) {
listener.detectPartsImageChange(e);
}
}
}
charactermanaj/src/charactermanaj/model/io/PartsImageDirectoryWatchAgent.java 0000644 0001750 0001750 00000002344 11767047535 027746 0 ustar paulliu paulliu package charactermanaj.model.io;
import charactermanaj.model.CharacterData;
/**
* パーツファイルのディレクトリの監視を行うエージェント.
* @author seraphy
*/
public interface PartsImageDirectoryWatchAgent {
/**
* 監視対象としているキャラクター定義を取得する.
* @return キャラクター定義
*/
CharacterData getCharcterData();
/**
* 監視を接続する.
* 接続されるまでディレクトリの監視状態は通知されない.
*/
void connect();
/**
* 監視を切断する.
* 接続されるまでディレクトリの監視状態は通知されない.
*/
void disconnect();
/**
* 監視対象ディレクトリの監視を停止する.
*/
void suspend();
/**
* 監視対象ディレクトリの監視再開を許可する.
*/
void resume();
/**
* イベントリスナを登録する
* @param l リスナ
*/
void addPartsImageDirectoryWatchListener(PartsImageDirectoryWatchListener l);
/**
* イベントリスナを登録解除する
* @param l リスナ
*/
void removePartsImageDirectoryWatchListener(PartsImageDirectoryWatchListener l);
}
charactermanaj/src/charactermanaj/model/io/PartsImageDirectoryWatchListener.java 0000644 0001750 0001750 00000000241 11767047535 030467 0 ustar paulliu paulliu package charactermanaj.model.io;
public interface PartsImageDirectoryWatchListener {
void detectPartsImageChange(PartsImageDirectoryWatchEvent e);
}
charactermanaj/src/charactermanaj/model/io/ImportModel.java 0000644 0001750 0001750 00000025676 11767047535 024327 0 ustar paulliu paulliu package charactermanaj.model.io;
import java.awt.image.BufferedImage;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URI;
import java.util.Collection;
import java.util.logging.Level;
import java.util.logging.Logger;
import charactermanaj.model.AppConfig;
import charactermanaj.model.CharacterData;
import charactermanaj.model.PartsAuthorInfo;
import charactermanaj.model.PartsCategory;
import charactermanaj.model.PartsManageData;
import charactermanaj.model.io.AbstractCharacterDataArchiveFile.CategoryLayerPair;
import charactermanaj.model.io.AbstractCharacterDataArchiveFile.PartsImageContent;
import charactermanaj.ui.progress.ProgressHandle;
public class ImportModel {
/**
* ロガー.
*/
private static final Logger logger = Logger.getLogger(ImportModel.class.getName());
/**
* インポートもとファイル
*/
private URI importSource;
/**
* プロファイル先のキャラクター定義、新規の場合はnull
*/
private CharacterData currentCharacterData;
/**
* インポートもとアーカイブ.
* ロードされた場合に非nullとなる.
*/
private CharacterDataArchiveFile archiveFile;
/**
* インポートされたキャラクター定義、なければnull
*/
private CharacterData sourceCharacterData;
/**
* インポートされたサンプルピクチャ、なければnull
*/
private BufferedImage samplePicture;
/**
* インポートされたreadme
*/
private String readme;
/**
* インポート先のキャラクター定義、もしくは現在のキャラクター定義のディレクトリ構成から
* 読み取ることのできるパーツのコレクション、なければ空.
*/
private Collection partsImageContentsMap;
/**
* パーツ管理データ、なければ空
*/
private PartsManageData partsManageData;
public void openImportSource(URI importSource, CharacterData currentCharacterData) throws IOException {
if (archiveFile != null || importSource == null) {
throw new IllegalStateException("既にアーカイブがオープンされています。");
}
this.importSource = importSource;
this.currentCharacterData = currentCharacterData;
}
public void closeImportSource() throws IOException {
if (archiveFile != null) {
try {
archiveFile.close();
} finally {
// クローズに失敗しても閉じたことにする.
reset();
}
}
}
public void loadContents(ProgressHandle progressHandle) throws IOException {
if (archiveFile != null) {
throw new IllegalStateException("既にアーカイブがオープンされています。");
}
if (importSource == null) {
throw new IllegalStateException("インポートファィルが指定されていません。");
}
CharacterDataFileReaderWriterFactory factory = CharacterDataFileReaderWriterFactory.getInstance();
progressHandle.setCaption("open archive...");
archiveFile = factory.openArchive(importSource);
readme = archiveFile.readReadMe();
progressHandle.setCaption("search the character definition...");
sourceCharacterData = archiveFile.readCharacterData();
if (sourceCharacterData == null) {
// character.xmlがない場合は、character.iniで試行する.
sourceCharacterData = archiveFile.readCharacterINI();
if (sourceCharacterData != null) {
// readmeがあれば、それを説明として登録しておく
if (readme != null && readme.trim().length() > 0) {
sourceCharacterData.setDescription(readme);
}
}
} else {
// character.xmlがあった場合、favorites.xmlもあれば読み込む.
archiveFile.readFavorites(sourceCharacterData);
}
// サンプルピクチャの読み込み、なければnull
progressHandle.setCaption("load sample picture...");
samplePicture = archiveFile.readSamplePicture();
// パーツセットの読み込み、なければ空
progressHandle.setCaption("load partssets...");
if (currentCharacterData != null) {
// 既存のキャラクターセットの定義をもとにパーツディレクトリを探索する場合
// (インポートもと・インポート先が同一であればパーツは除外される.)
partsImageContentsMap = archiveFile.getPartsImageContents(currentCharacterData, false);
} else {
// インポート元にあるキャラクター定義をもとにパーツディレクトリを探索する場合
partsImageContentsMap = archiveFile.getPartsImageContents(sourceCharacterData, true);
}
// パーツ管理データの読み込み
progressHandle.setCaption("load parts definitions...");
partsManageData = archiveFile.getPartsManageData();
}
protected void reset() {
importSource = null;
archiveFile = null;
sourceCharacterData = null;
samplePicture = null;
readme = null;
partsImageContentsMap = null;
partsManageData = null;
}
public URI getImportSource() {
return importSource;
}
protected void checkArchiveOpened() {
if (archiveFile == null) {
throw new IllegalStateException("アーカイブはオープンされていません。");
}
}
public CharacterData getCharacterData() {
checkArchiveOpened();
return sourceCharacterData;
}
public BufferedImage getSamplePicture() {
checkArchiveOpened();
return samplePicture;
}
public String getReadme() {
checkArchiveOpened();
return readme;
}
public Collection getPartsImageContents() {
checkArchiveOpened();
return partsImageContentsMap;
}
public PartsManageData getPartsManageData() {
checkArchiveOpened();
return partsManageData;
}
/**
* パーツデータをプロファイルの画像ディレクトリに一括コピーする.
* @param partsImageContents コピー対象のパーツデータ
* @param cd コピー先のプロファイル
* @throws IOException 失敗
*/
public void copyPartsImageContents(
Collection partsImageContents, CharacterData cd)
throws IOException {
if (cd == null || cd.getDocBase() == null) {
throw new IllegalArgumentException("invalid character data");
}
// コピー先ディレクトリの確定
URI docbase = cd.getDocBase();
if ( !"file".equals(docbase.getScheme())) {
throw new IOException("ファイル以外はサポートしていません: " + docbase);
}
File configFile = new File(docbase);
File baseDir = configFile.getParentFile();
if (baseDir == null || !baseDir.isDirectory()) {
throw new IOException("親フォルダがディレクトリではありません: " + baseDir);
}
AppConfig appConfig = AppConfig.getInstance();
byte[] stmbuf = new byte[appConfig.getFileTransferBufferSize()];
// ファイルコピー
for (PartsImageContent content : partsImageContents) {
InputStream is = new BufferedInputStream(content.openStream());
try {
File outDir = new File(baseDir, content.getDirName());
if (!outDir.exists()) {
if (!outDir.mkdirs()) {
logger.log(Level.WARNING, "can't create the directory. " + outDir);
}
}
File outFile = new File(outDir, content.getFileName());
OutputStream os = new BufferedOutputStream(new FileOutputStream(outFile));
try {
for (;;) {
int rd = is.read(stmbuf);
if (rd < 0) {
break;
}
os.write(stmbuf, 0, rd);
}
} finally {
os.close();
}
if (!outFile.setLastModified(content.lastModified())) {
logger.log(Level.WARNING, "can't change the modified-date: " + outFile);
}
} finally {
is.close();
}
}
}
/**
* パーツ管理情報を更新または作成する.
* パーツ管理情報がnullまたは空であれば何もしない.
* そうでなければインポートするパーツに該当するパーツ管理情報を、現在のプロファイルのパーツ管理情報に追記・更新し、
* それを書き出す.
* インポートもとにパーツ管理情報がなく、既存にある場合、インポートしても管理情報は削除されません.(上書きセマンティクスのため)
* @param partsImageContents インポートするパーツ
* @param partsManageData パーツ管理データ
* @param current 現在のパーツ管理データを保持しているプロファイル、新規の場合はnull
* @param target 書き込み先のプロファイル
* @throws IOException 書き込みに失敗した場合
*/
public void updatePartsManageData(
Collection partsImageContents,
PartsManageData partsManageData, CharacterData current,
CharacterData target) throws IOException {
if (target == null || !target.isValid()) {
throw new IllegalArgumentException();
}
if (partsImageContents == null || partsImageContents.isEmpty()
|| partsManageData == null || partsManageData.isEmpty()) {
// インポートするパーツが存在しないか、管理情報がない場合は更新しようがないので何もしないで戻る.
return;
}
CharacterDataPersistent persist = CharacterDataPersistent.getInstance();
PartsManageData mergedPartsManagedData;
if (current != null && current.isValid()) {
// 現在のプロファイルからパーツ管理情報を取得する.
mergedPartsManagedData = persist.loadPartsManageData(current.getDocBase());
} else {
// 新規の場合は空
mergedPartsManagedData = new PartsManageData();
}
// インポート対象のパーツに該当するパーツ管理情報のみを取り出して追記する.
for (PartsImageContent partsImageContent : partsImageContents) {
String partsName = partsImageContent.getPartsName();
for (CategoryLayerPair catLayerPair : partsImageContent.getCategoryLayerPairs()) {
PartsCategory partsCategory = catLayerPair.getPartsCategory();
String categoryId = partsCategory.getCategoryId();
PartsManageData.PartsKey partsKey = new PartsManageData.PartsKey(partsName, categoryId);
PartsAuthorInfo partsAuthorInfo = partsManageData.getPartsAuthorInfo(partsKey);
PartsManageData.PartsVersionInfo versionInfo = partsManageData.getVersion(partsKey);
String localizedName = partsManageData.getLocalizedName(partsKey);
if (partsAuthorInfo != null || versionInfo != null || localizedName != null) {
// いずれかの情報の登録がある場合、パーツ管理情報として追記する.
mergedPartsManagedData.putPartsInfo(partsKey, localizedName, partsAuthorInfo, versionInfo);
}
}
}
// パーツ管理情報を更新する.
persist.savePartsManageData(target.getDocBase(), mergedPartsManagedData);
}
}
charactermanaj/src/charactermanaj/model/io/AbstractCharacterDataFileWriter.java 0000644 0001750 0001750 00000012130 11767047535 030220 0 ustar paulliu paulliu package charactermanaj.model.io;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.Map;
import java.util.Properties;
import java.util.logging.Level;
import java.util.logging.Logger;
import charactermanaj.model.CharacterData;
import charactermanaj.model.PartsIdentifier;
import charactermanaj.model.PartsSpec;
public abstract class AbstractCharacterDataFileWriter implements CharacterDataWriter {
/**
* ロガー
*/
private static final Logger logger = Logger.getLogger(AbstractCharacterDataFileWriter.class.getName());
protected File outFile;
protected File tmpFile;
protected Exception occureException;
protected AbstractCharacterDataFileWriter(File outFile) throws IOException {
if (outFile == null) {
throw new IllegalArgumentException();
}
if (outFile.exists()) {
if (!outFile.canWrite()) {
throw new IOException("not writable: " + outFile);
}
}
File tmpFile = new File(outFile.getPath() + ".tmp");
this.tmpFile = tmpFile;
this.outFile = outFile;
}
public void writeExportProp(Properties prop) throws IOException {
if (prop == null) {
throw new IllegalArgumentException();
}
try {
internalWriteExportProp(prop);
} catch (IOException ex) {
occureException = ex;
throw ex;
} catch (Exception ex) {
occureException = ex;
IOException ex2 = new IOException("write characterdata failed.");
ex2.initCause(ex);
throw ex2;
}
}
protected abstract void internalWriteExportProp(Properties prop) throws IOException;
public void writeCharacterData(CharacterData characterData) throws IOException {
if (characterData == null) {
throw new IllegalArgumentException();
}
try {
internalWriteCharacterData(characterData);
} catch (IOException ex) {
occureException = ex;
throw ex;
} catch (Exception ex) {
occureException = ex;
IOException ex2 = new IOException("write characterdata failed.");
ex2.initCause(ex);
throw ex2;
}
}
protected abstract void internalWriteCharacterData(CharacterData characterData) throws IOException;
public void writeTextUTF16LE(String name, String contents) throws IOException {
if (name == null) {
throw new IllegalArgumentException();
}
try {
internalWriteTextUTF16LE(name, contents);
} catch (IOException ex) {
occureException = ex;
throw ex;
} catch (Exception ex) {
occureException = ex;
IOException ex2 = new IOException("internalWriteTextUTF16 failed.");
ex2.initCause(ex);
throw ex2;
}
}
protected abstract void internalWriteTextUTF16LE(String name, String contents) throws IOException;
public void writeSamplePicture(BufferedImage samplePicture) throws IOException {
if (samplePicture == null) {
throw new IllegalArgumentException();
}
try {
internalWriteSamplePicture(samplePicture);
} catch (IOException ex) {
occureException = ex;
throw ex;
} catch (Exception ex) {
occureException = ex;
IOException ex2 = new IOException("write sample picture failed.");
ex2.initCause(ex);
throw ex2;
}
}
protected abstract void internalWriteSamplePicture(BufferedImage samplePicture) throws IOException;
public void writePartsImages(Map partsImages) throws IOException {
if (partsImages == null) {
throw new IllegalArgumentException();
}
try {
internalWritePartsImages(partsImages);
} catch (IOException ex) {
occureException = ex;
throw ex;
} catch (Exception ex) {
occureException = ex;
IOException ex2 = new IOException("write parts images failed.");
ex2.initCause(ex);
throw ex2;
}
}
protected abstract void internalWritePartsImages(Map partsImages) throws IOException;
public void writePartsManageData(Map partsImages) throws IOException {
if (partsImages == null) {
throw new IllegalArgumentException();
}
try {
internalWritePartsManageData(partsImages);
} catch (IOException ex) {
occureException = ex;
throw ex;
} catch (Exception ex) {
occureException = ex;
IOException ex2 = new IOException("write parts images failed.");
ex2.initCause(ex);
throw ex2;
}
}
protected abstract void internalWritePartsManageData(Map partsImages) throws IOException;
public void close() throws IOException {
try {
internalClose();
if (outFile.exists()) {
if (!outFile.delete()) {
throw new IOException("old file can't delete. " + outFile);
}
}
} catch (Exception ex) {
if (occureException == null) {
occureException = ex;
}
}
if (occureException != null) {
if (!tmpFile.delete()) {
logger.log(Level.WARNING, "temporary file can't delete. " + tmpFile);
}
return;
}
if (!tmpFile.renameTo(outFile)) {
throw new IOException("rename failed. " + tmpFile);
}
}
protected abstract void internalClose() throws IOException;
}
charactermanaj/src/charactermanaj/model/io/CharacterDataArchiveFile.java 0000644 0001750 0001750 00000011034 11767047535 026643 0 ustar paulliu paulliu package charactermanaj.model.io;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.Collection;
import charactermanaj.model.CharacterData;
import charactermanaj.model.PartsManageData;
import charactermanaj.model.io.AbstractCharacterDataArchiveFile.PartsImageContent;
/**
* アーカイブ形式のファイルを読み取るためのインターフェイス.
* @author seraphy
*/
public interface CharacterDataArchiveFile {
/**
* クローズする.
* @throws IOException
*/
void close() throws IOException;
/**
* コンテンツルートへのプレフィックスを取得する.
* アーカイブの実際のルートに単一のフォルダしかない場合、そのフォルダがルートプレフィックスとなる.
* アーカイブの実際のルートに複数のフォルダがあるか、ファイルがある場合、ルートプレフィックスは空文字である.
* @return コンテンツルートへのプレフィックス
*/
String getRootPrefix();
/**
* 指定したコンテンツが存在するか?
* @param name コンテンツ名
* @return 存在すればtrue、存在しなければfalse
*/
boolean hasContent(String name);
/**
* キャラクター定義を読み込む.
* アーカイブに存在しなければnull
* @return キャラクター定義、もしくはnull
* @throws IOException 読み取りに失敗した場合
*/
CharacterData readCharacterData() throws IOException;
/**
* お気に入りを読み込みキャラクター定義に追加する.
* アーカイブにお気に入りが存在しなければ何もしない.
* @param characterData キャラクター定義(お気に入りが追加される)
* @throws IOException 読み取りに失敗した場合
*/
void readFavorites(CharacterData characterData) throws IOException;
/**
* キャラクター定義をINIファイルより読み取る.
* character.iniが存在しなければnull.
* 「キャラクターなんとか機」の設定ファイルを想定している.
* @return キャラクター定義、もしくはnull
* @throws IOException 読み取りに失敗した場合
*/
CharacterData readCharacterINI() throws IOException;
/**
* サンプルピクチャを読み込む.
* アーカイブに存在しなければnull.
* @return サンプルピクチャ、もしくはnull
* @throws IOException 読み取りに失敗した場合
*/
BufferedImage readSamplePicture() throws IOException;
/**
* アーカイブにある「readme.txt」、もしくは「readme」というファイルをテキストファイルとして読み込む.
* readme.txtが優先される。ともに存在しない場合はnull.
* @return テキスト、もしくはnull
* @throws 読み込みに失敗した場合
*/
String readReadMe() throws IOException;
/**
* ファイルをテキストとして読み取り、返す.
* UTF-16LE/BE/UTF-8についてはBOMにより判定する.
* BOMがない場合はUTF-16/8ともに判定できない.
* BOMがなければMS932もしくはEUC_JPであると仮定して読み込む.
* @param name コンテンツ名
* @return テキスト、コンテンツが存在しない場合はnull
* @throws IOException 読み込みに失敗した場合
*/
String readTextFile(String name) throws IOException;
/**
* アーカイブに含まれる、キャラクター定義と同じフォルダをもつpngファイルからパーツイメージを取得する.
* パーツの探索は引数で指定したキャラクター定義によって行われます.
* @param characterData インポート先のキャラクターデータ、フォルダ名などを判別するため。nullの場合は空のマップを返す.
* @param newly 新規インポート用であるか?(新規でない場合は引数で指定したキャラクターセットと同じパーツは読み込まれない)
* @return パーツイメージコンテンツのコレクション、なければ空
*/
Collection getPartsImageContents(CharacterData characterData, boolean newly);
/**
* アーカイブに含まれるparts-info.xmlを読み込み返す.
* 存在しなければ空のインスタンスを返す.
* @return パーツ管理データ
* @throws IOException
*/
PartsManageData getPartsManageData() throws IOException;
}
charactermanaj/src/charactermanaj/model/io/CharacterDataZipArchiveFile.java 0000644 0001750 0001750 00000002573 11767047535 027336 0 ustar paulliu paulliu package charactermanaj.model.io;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import org.apache.tools.zip.ZipEntry;
import org.apache.tools.zip.ZipFile;
import charactermanaj.model.AppConfig;
public class CharacterDataZipArchiveFile extends AbstractCharacterDataArchiveFile {
protected ZipFile zipFile;
protected class ZipFileContent implements FileContent {
private ZipEntry entry;
protected ZipFileContent(ZipEntry entry) {
this.entry = entry;
}
public String getEntryName() {
return entry.getName();
}
public long lastModified() {
return entry.getTime();
}
public InputStream openStream() throws IOException {
return zipFile.getInputStream(entry);
}
}
public void close() throws IOException {
zipFile.close();
}
public CharacterDataZipArchiveFile(File file) throws IOException {
super(file);
AppConfig appConfig = AppConfig.getInstance();
String encoding = appConfig.getZipNameEncoding();
zipFile = new ZipFile(file, encoding);
load();
}
private void load() {
@SuppressWarnings("unchecked")
Enumeration enm = zipFile.getEntries();
while (enm.hasMoreElements()) {
ZipEntry entry = enm.nextElement();
addEntry(new ZipFileContent(entry));
}
searchRootPrefix();
}
}
charactermanaj/src/charactermanaj/model/io/PartsImageDirectoryWatchAgentFactory.java 0000644 0001750 0001750 00000014224 11767047535 031276 0 ustar paulliu paulliu package charactermanaj.model.io;
import java.net.URI;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.logging.Level;
import java.util.logging.Logger;
import charactermanaj.model.CharacterData;
/**
* ディレクトリ監視エージェントのファクトリ.
* このファクトリ単位でディレクト利監視エージェントは保持されます.
* このファクトリ上に、すでに同一のキャラクターデータを監視するエージェントがいる場合、それらのエージェントの実体は
* ハンドルによって共有されます.
* @author seraphy
*/
public final class PartsImageDirectoryWatchAgentFactory {
private final Logger logger = Logger.getLogger(getClass().getName());
private static PartsImageDirectoryWatchAgentFactory inst = new PartsImageDirectoryWatchAgentFactory();
private HashMap agents = new HashMap();
private final Object lock = new Object();
private PartsImageDirectoryWatchAgentFactory() {
super();
}
public static PartsImageDirectoryWatchAgentFactory getFactory() {
return inst;
}
/**
* キャラクターデータを指定して、そのキャラクターデータに対する監視エージェントを作成し、そのハンドルを返します.
* すでに、そのキャラクターデータに対するエージェントが存在する場合は、そのハンドルを返します.
* 無効なキャラクターデータ、もしくはnullを指定した場合は、エージェントの実体を持たないダミーのハンドルが返されます.
* @param characterData キャラクターデータ
* @return 作成された、もしくは既に作成されている監視エージェントのハンドル
*/
public PartsImageDirectoryWatchAgent getAgent(CharacterData characterData) {
if (characterData == null || !characterData.isValid()) {
// キャラクターデータがnullまたは無効である場合は、
// 何もしないダミーのディレクトリハンドルを返す.
return new NullWatchAgentHandle(characterData);
}
URI docBase = characterData.getDocBase();
PartsImageDirectoryWatchAgentThread agentImpl;
synchronized (lock) {
if (agents.containsKey(docBase)) {
agentImpl = agents.get(docBase);
} else {
agentImpl = new PartsImageDirectoryWatchAgentThread(characterData);
agents.put(docBase, agentImpl);
logger.log(Level.FINE, "watch agent is cached. " + agentImpl);
}
}
return new PartsImageDirectoryWatchAgentHandle(agentImpl);
}
}
/**
* 監視スレッドの実体がない、何もしないハンドル.
* @author seraphy
*/
class NullWatchAgentHandle implements PartsImageDirectoryWatchAgent, PartsImageDirectoryWatchListener {
private CharacterData characterData;
public NullWatchAgentHandle(CharacterData characterData) {
this.characterData = characterData;
}
public void addPartsImageDirectoryWatchListener(
PartsImageDirectoryWatchListener l) {
}
// なにもしない.
public void connect() {
// なにもしない.
}
public void detectPartsImageChange(PartsImageDirectoryWatchEvent e) {
// なにもしない.
}
public void disconnect() {
// なにもしない.
}
public CharacterData getCharcterData() {
return characterData;
}
public void removePartsImageDirectoryWatchListener(
PartsImageDirectoryWatchListener l) {
// なにもしない.
}
public void resume() {
// なにもしない.
}
public void suspend() {
// なにもしない.
}
}
/**
* 監視ディレクトリに対する監視スレッドの実体を複数のメインフレームで共有するための、個々のフレーム用のハンドル.
* @author seraphy
*/
class PartsImageDirectoryWatchAgentHandle implements PartsImageDirectoryWatchAgent, PartsImageDirectoryWatchListener {
/**
* ロガー
*/
private final Logger logger = Logger.getLogger(getClass().getName());
/**
* 監視スレッドの実体
*/
private final PartsImageDirectoryWatchAgentThread agent;
/**
* 監視を通知されるリスナー
*/
private final LinkedList listeners
= new LinkedList();
/**
* このハンドルで開始要求されているか示すフラグ.
*/
private boolean connected;
protected PartsImageDirectoryWatchAgentHandle(PartsImageDirectoryWatchAgentThread agent) {
this.agent = agent;
}
public CharacterData getCharcterData() {
return agent.getCharcterData();
}
public void connect() {
logger.log(Level.FINE, "agent connect request. " + this);
if ( !connected) {
agent.addPartsImageDirectoryWatchListener(this);
connected = true;
}
}
public void disconnect() {
logger.log(Level.FINE, "agent disconnect request. " + this);
if (connected) {
connected = false;
agent.removePartsImageDirectoryWatchListener(this);
}
}
public void suspend() {
logger.log(Level.FINE, "agent stop request. " + this);
agent.suspend(this);
}
public void resume() {
logger.log(Level.FINE, "agent resume request. " + this);
agent.resume(this);
}
public void addPartsImageDirectoryWatchListener(
PartsImageDirectoryWatchListener l) {
if (l != null) {
synchronized (listeners) {
listeners.add(l);
}
}
}
public void removePartsImageDirectoryWatchListener(
PartsImageDirectoryWatchListener l) {
if (l != null) {
synchronized (listeners) {
listeners.remove(l);
}
}
}
public void detectPartsImageChange(PartsImageDirectoryWatchEvent e) {
if (!connected) {
logger.log(Level.FINE, "skip agent event. " + this);
return;
}
logger.log(Level.FINE, "agent event occured. " + this);
PartsImageDirectoryWatchListener[] ls;
synchronized (listeners) {
ls = listeners.toArray(new PartsImageDirectoryWatchListener[listeners.size()]);
}
for (PartsImageDirectoryWatchListener l : ls) {
l.detectPartsImageChange(e);
}
}
}
charactermanaj/src/charactermanaj/model/io/CharacterDataJarFileWriter.java 0000644 0001750 0001750 00000002150 11767047535 027172 0 ustar paulliu paulliu package charactermanaj.model.io;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.jar.JarEntry;
import java.util.jar.JarOutputStream;
public class CharacterDataJarFileWriter extends AbstractCharacterDataArchivedFileWriter {
protected JarOutputStream jarOutStm;
public CharacterDataJarFileWriter(File outFile) throws IOException {
super(outFile);
this.jarOutStm = new JarOutputStream(
new BufferedOutputStream(new FileOutputStream(tmpFile)));
}
@Override
protected void closeEntry() throws IOException {
jarOutStm.closeEntry();
}
@Override
protected OutputStream getOutputStream() throws IOException {
return jarOutStm;
}
@Override
protected void putNextEntry(String name, long lastModified)
throws IOException {
JarEntry entry = new JarEntry(name);
if (lastModified > 0) {
entry.setTime(lastModified);
}
jarOutStm.putNextEntry(entry);
}
protected void internalClose() throws IOException {
jarOutStm.close();
}
}
charactermanaj/src/charactermanaj/model/io/CharacterDataFileReaderWriterFactory.java 0000644 0001750 0001750 00000004755 11767047535 031225 0 ustar paulliu paulliu package charactermanaj.model.io;
import java.io.File;
import java.io.IOException;
import java.net.URI;
public class CharacterDataFileReaderWriterFactory {
private static final CharacterDataFileReaderWriterFactory singleton = new CharacterDataFileReaderWriterFactory();
private CharacterDataFileReaderWriterFactory() {
super();
}
public static CharacterDataFileReaderWriterFactory getInstance() {
return singleton;
}
/**
* ファイルの拡張子に応じてzip/cmj形式でのライターを構築して帰します.
* 拡張子がjarとcmjは同じ意味で、ともにjarファイル形式となります.
* zip/cmj/jar以外の拡張子はIOExceptionとなります.
* @param outfile 出力先ファイル名
* @return ライター
* @throws IOException 該当するライターがみつからない場合
*/
public CharacterDataWriter createWriter(File outfile) throws IOException {
if (outfile == null) {
throw new IllegalArgumentException();
}
String name = outfile.getName().toLowerCase();
if (name.endsWith(".jar") || name.endsWith(".cmj")) {
return new CharacterDataJarFileWriter(outfile);
} else if (name.endsWith(".zip")) {
return new CharacterDataZipFileWriter(outfile);
}
throw new IOException("unsupported file type: " + name);
}
public CharacterDataArchiveFile openArchive(URI archiveFile) throws IOException {
if (archiveFile == null) {
throw new IllegalArgumentException();
}
if ("file".equals(archiveFile.getScheme())) {
// ファイルまたはディレクトリの場合
File file = new File(archiveFile);
return openArchive(file);
}
// file以外は現在のところサポートしない。
throw new UnsupportedOperationException();
}
public CharacterDataArchiveFile openArchive(File archiveFile) throws IOException {
if (archiveFile == null) {
throw new IllegalArgumentException();
}
if (archiveFile.exists() && archiveFile.isDirectory()) {
// ディレクトリの場合
return new CharacterDataDirectoryFile(archiveFile);
}
// zipまたはcmjファイルの場合
String name = archiveFile.getName().toLowerCase();
if (name.endsWith(".jar") || name.endsWith(".cmj")) {
return new CharacterDataJarArchiveFile(archiveFile);
} else if (name.endsWith(".zip")) {
return new CharacterDataZipArchiveFile(archiveFile);
}
throw new IOException("unsupported file type: " + name);
}
}
charactermanaj/src/charactermanaj/model/io/PartsManageDataDecorateLoader.java 0000644 0001750 0001750 00000007673 11767047535 027663 0 ustar paulliu paulliu package charactermanaj.model.io;
import java.util.HashMap;
import java.util.Map;
import charactermanaj.model.PartsAuthorInfo;
import charactermanaj.model.PartsCategory;
import charactermanaj.model.PartsIdentifier;
import charactermanaj.model.PartsManageData;
import charactermanaj.model.PartsSpec;
/**
* パーツ管理情報をパーツデータに補填するデコレータ・ローダー.
* ローダから読み込まれたパーツデータに対して、それに該当する管理情報があれば、その管理情報で更新し、
* 更新した結果を返す.
* @author seraphy
*/
public class PartsManageDataDecorateLoader implements PartsDataLoader {
/**
* パーツ管理情報を構築するファクトリ.
* ローダーが呼び出された段階で、最新のパーツ管理情報をロードするためのもの.
* @author seraphy
*
*/
public interface PartsManageDataFactory {
/**
* パーツ管理情報をロードする.
* パーツ管理情報が存在しない場合、もしくは読み取りできなった場合は管理情報はないものとして空のインスタンスを返す.
* @return バーツ管理情報、存在しない場合は空を返す.
*/
PartsManageData createPartsManageData();
}
private PartsDataLoader parent;
private PartsManageDataFactory partsManageDataFactory;
public PartsManageDataDecorateLoader(PartsDataLoader parent, PartsManageDataFactory partsManageDataFactory) {
if (parent == null || partsManageDataFactory == null) {
throw new IllegalArgumentException();
}
this.parent = parent;
this.partsManageDataFactory = partsManageDataFactory;
}
public Map load(PartsCategory category) {
// 親よりパーツデータをロードする.
Map