- Added 'package list' field type

- Some refactoring of the other field types

git-svn-id: svn://svn.code.sf.net/p/magicseteditor/code/trunk@790 0fc631ac-6414-0410-93d0-97cfa31319b6

src/data/action/value.cpp

@@ -14,6 +14,7 @@
 #include <data/field/color.hpp>
 #include <data/field/image.hpp>
 #include <data/field/symbol.hpp>
+#include <data/field/package_choice.hpp>
 #include <util/tagged_string.hpp>
 
 // ----------------------------------------------------------------------------- : ValueAction
@@ -30,6 +31,7 @@ inline void swap_value(ColorValue&          a, ColorValue         ::ValueType& b
 inline void swap_value(ImageValue&          a, ImageValue         ::ValueType& b) { swap(a.filename, b); a.last_update.update(); }
 inline void swap_value(SymbolValue&         a, SymbolValue        ::ValueType& b) { swap(a.filename, b); a.last_update.update(); }
 inline void swap_value(TextValue&           a, TextValue          ::ValueType& b) { swap(a.value,    b); a.last_update.update(); }
+inline void swap_value(PackageChoiceValue&  a, PackageChoiceValue ::ValueType& b) { swap(a.package_name, b); }
 inline void swap_value(MultipleChoiceValue& a, MultipleChoiceValue::ValueType& b) {
 	swap(a.value,       b.value);
 	swap(a.last_change, b.last_change);
@@ -68,6 +70,7 @@ ValueAction* value_action(const Card* card, const ChoiceValueP&         value, c
 ValueAction* value_action(const Card* card, const ColorValueP&          value, const Defaultable<Color>&  new_value) { return new SimpleValueAction<ColorValue,          true> (card, value, new_value); }
 ValueAction* value_action(const Card* card, const ImageValueP&          value, const FileName&            new_value) { return new SimpleValueAction<ImageValue,          false>(card, value, new_value); }
 ValueAction* value_action(const Card* card, const SymbolValueP&         value, const FileName&            new_value) { return new SimpleValueAction<SymbolValue,         false>(card, value, new_value); }
+ValueAction* value_action(const Card* card, const PackageChoiceValueP&  value, const String&              new_value) { return new SimpleValueAction<PackageChoiceValue,  false>(card, value, new_value); }
 ValueAction* value_action(const Card* card, const MultipleChoiceValueP& value, const Defaultable<String>& new_value, const String& last_change) {
 	MultipleChoiceValue::ValueType v = { new_value, last_change };
 	return new SimpleValueAction<MultipleChoiceValue, false>(card, value, v);

src/data/action/value.hpp

@@ -28,6 +28,7 @@ DECLARE_POINTER_TYPE(MultipleChoiceValue);
 DECLARE_POINTER_TYPE(ColorValue);
 DECLARE_POINTER_TYPE(ImageValue);
 DECLARE_POINTER_TYPE(SymbolValue);
+DECLARE_POINTER_TYPE(PackageChoiceValue);
 
 // ----------------------------------------------------------------------------- : ValueAction (based class)
 
@@ -50,6 +51,7 @@ ValueAction* value_action(const Card* card, const MultipleChoiceValueP& value, c
 ValueAction* value_action(const Card* card, const ColorValueP&          value, const Defaultable<Color>&  new_value);
 ValueAction* value_action(const Card* card, const ImageValueP&          value, const FileName&            new_value);
 ValueAction* value_action(const Card* card, const SymbolValueP&         value, const FileName&            new_value);
+ValueAction* value_action(const Card* card, const PackageChoiceValueP&  value, const String&              new_value);
 
 // ----------------------------------------------------------------------------- : Text
 

src/data/field.cpp

@@ -15,6 +15,7 @@
 #include <data/field/symbol.hpp>
 #include <data/field/color.hpp>
 #include <data/field/information.hpp>
+#include <data/field/package_choice.hpp>
 #include <util/error.hpp>
 
 DECLARE_TYPEOF_COLLECTION(StyleListener*);
@@ -80,6 +81,7 @@ intrusive_ptr<Field> read_new<Field>(Reader& reader) {
 	else if (type == _("symbol"))			return new_intrusive<SymbolField>();
 	else if (type == _("color"))			return new_intrusive<ColorField>();
 	else if (type == _("info"))				return new_intrusive<InfoField>();
+	else if (type == _("package choice"))	return new_intrusive<PackageChoiceField>();
 	else if (type.empty()) {
 		reader.warning(_ERROR_1_("expected key", _("type")));
 		throw ParseError(_ERROR_("aborting parsing"));

src/data/field.hpp

@@ -253,7 +253,7 @@ inline String type_name(const Value&) {
 	virtual String typeName() const
 
 // implement newStyle and newValue
-#define IMPLEMENT_FIELD_TYPE(Type)														\
+#define IMPLEMENT_FIELD_TYPE(Type, NAME)												\
 	StyleP Type ## Field::newStyle(const FieldP& thisP) const {							\
 		assert(thisP.get() == this);													\
 		return new_intrusive1<Type ## Style>(static_pointer_cast<Type ## Field>(thisP));\
@@ -267,6 +267,9 @@ inline String type_name(const Value&) {
 	}																					\
 	ValueP Type ## Value::clone() const {												\
 		return new_intrusive1<Type ## Value>(*this);									\
+	}																					\
+	String Type ## Field::typeName() const {											\
+		return _(NAME);																	\
 	}
 
 #define DECLARE_STYLE_TYPE(Type)														\

src/data/field/boolean.cpp

@@ -16,11 +16,7 @@ BooleanField::BooleanField() {
 	choices->initIds();
 }
 
-IMPLEMENT_FIELD_TYPE(Boolean)
-
-String BooleanField::typeName() const {
-	return _("boolean");
-}
+IMPLEMENT_FIELD_TYPE(Boolean, "boolean");
 
 IMPLEMENT_REFLECTION(BooleanField) {
 	REFLECT_BASE(Field); // NOTE: don't reflect as a ChoiceField

src/data/field/choice.cpp

@@ -20,11 +20,7 @@ ChoiceField::ChoiceField()
 	, default_name(_("Default"))
 {}
 
-IMPLEMENT_FIELD_TYPE(Choice)
-
-String ChoiceField::typeName() const {
-	return _("choice");
-}
+IMPLEMENT_FIELD_TYPE(Choice, "choice");
 
 void ChoiceField::initDependencies(Context& ctx, const Dependency& dep) const {
 	Field        ::initDependencies(ctx, dep);

src/data/field/color.cpp

@@ -18,11 +18,7 @@ ColorField::ColorField()
 	, default_name(_("Default"))
 {}
 
-IMPLEMENT_FIELD_TYPE(Color)
-
-String ColorField::typeName() const {
-	return _("color");
-}
+IMPLEMENT_FIELD_TYPE(Color, "color");
 
 void ColorField::initDependencies(Context& ctx, const Dependency& dep) const {
 	Field        ::initDependencies(ctx, dep);

src/data/field/image.cpp

@@ -10,11 +10,7 @@
 
 // ----------------------------------------------------------------------------- : ImageField
 
-IMPLEMENT_FIELD_TYPE(Image)
-
-String ImageField::typeName() const {
-	return _("image");
-}
+IMPLEMENT_FIELD_TYPE(Image, "image");
 
 IMPLEMENT_REFLECTION(ImageField) {
 	REFLECT_BASE(Field);

src/data/field/information.cpp

@@ -11,11 +11,7 @@
 
 // ----------------------------------------------------------------------------- : InfoField
 
-IMPLEMENT_FIELD_TYPE(Info)
-
-String InfoField::typeName() const {
-	return _("info");
-}
+IMPLEMENT_FIELD_TYPE(Info, "info");
 
 void InfoField::initDependencies(Context& ctx, const Dependency& dep) const {
 	Field ::initDependencies(ctx, dep);

src/data/field/multiple_choice.cpp

@@ -15,11 +15,7 @@ MultipleChoiceField::MultipleChoiceField()
 	, maximum_selection(1000000)
 {}
 
-IMPLEMENT_FIELD_TYPE(MultipleChoice)
-
-String MultipleChoiceField::typeName() const {
-	return _("multiple choice");
-}
+IMPLEMENT_FIELD_TYPE(MultipleChoice, "multiple choice");
 
 IMPLEMENT_REFLECTION(MultipleChoiceField) {
 	REFLECT_BASE(ChoiceField);

src/data/field/package_choice.cpp

@@ -0,0 +1,83 @@
+//+----------------------------------------------------------------------------+
+//| Description:  Magic Set Editor - Program to make Magic (tm) cards          |
+//| Copyright:    (C) 2001 - 2007 Twan van Laarhoven                           |
+//| License:      GNU General Public License 2 or later (see file COPYING)     |
+//+----------------------------------------------------------------------------+
+
+// ----------------------------------------------------------------------------- : Includes
+
+#include <data/field/package_choice.hpp>
+#include <util/io/package_manager.hpp>
+
+// ----------------------------------------------------------------------------- : PackageChoiceField
+
+IMPLEMENT_FIELD_TYPE(PackageChoice, "package choice");
+
+void PackageChoiceField::initDependencies(Context& ctx, const Dependency& dep) const {
+	Field ::initDependencies(ctx, dep);
+	script. initDependencies(ctx, dep);
+}
+
+IMPLEMENT_REFLECTION(PackageChoiceField) {
+	REFLECT_BASE(Field);
+	REFLECT(script);
+	REFLECT(match);
+	REFLECT(initial);
+	REFLECT(required);
+}
+
+// ----------------------------------------------------------------------------- : PackageChoiceStyle
+
+PackageChoiceStyle::PackageChoiceStyle(const PackageChoiceFieldP& field)
+	: Style(field)
+{}
+
+int PackageChoiceStyle::update(Context& ctx) {
+	return Style     ::update(ctx)
+	     | font       .update(ctx) * CHANGE_OTHER;
+}
+/*void PackageChoiceStyle::initDependencies(Context& ctx, const Dependency& dep) const {
+	Style     ::initDependencies(ctx, dep);
+//	font       .initDependencies(ctx, dep);
+}*/
+
+IMPLEMENT_REFLECTION(PackageChoiceStyle) {
+	REFLECT_BASE(Style);
+	REFLECT(font);
+}
+
+// ----------------------------------------------------------------------------- : PackageChoiceValue
+
+String PackageChoiceValue::toString() const {
+	PackagedP pack = getPackage();
+	if (pack) return pack->short_name;
+	else      return _("");
+}
+
+PackagedP PackageChoiceValue::getPackage() const {
+	if (package_name.empty()) return nullptr;
+	else return packages.openAny(package_name, true);
+}
+
+bool PackageChoiceValue::update(Context& ctx) {
+	bool change = field().script.invokeOn(ctx, package_name);
+	Value::update(ctx);
+	return change;
+}
+
+void PackageChoiceValue::reflect(Reader& tag) {
+	REFLECT_NAMELESS(package_name);
+}
+void PackageChoiceValue::reflect(Writer& tag) {
+	REFLECT_NAMELESS(package_name);
+}
+void PackageChoiceValue::reflect(GetDefaultMember& tag) {
+	if (!package_name.empty() && package_name != field().initial) {
+		// add a space to the name, to indicate the dependency doesn't have to be marked
+		// see also SymbolFontRef::loadFont
+		REFLECT_NAMELESS(_(" ") +  package_name);
+	} else {
+		REFLECT_NAMELESS(package_name);
+	}
+}
+void PackageChoiceValue::reflect(GetMember& tag) {}

src/data/field/package_choice.hpp

@@ -0,0 +1,69 @@
+//+----------------------------------------------------------------------------+
+//| Description:  Magic Set Editor - Program to make Magic (tm) cards          |
+//| Copyright:    (C) 2001 - 2007 Twan van Laarhoven                           |
+//| License:      GNU General Public License 2 or later (see file COPYING)     |
+//+----------------------------------------------------------------------------+
+
+#ifndef HEADER_DATA_FIELD_PACKAGE_CHOICE
+#define HEADER_DATA_FIELD_PACKAGE_CHOICE
+
+// ----------------------------------------------------------------------------- : Includes
+
+#include <util/prec.hpp>
+#include <data/field.hpp>
+#include <data/font.hpp>
+#include <script/scriptable.hpp>
+
+DECLARE_POINTER_TYPE(Packaged);
+
+// ----------------------------------------------------------------------------- : PackageChoiceField
+
+DECLARE_POINTER_TYPE(PackageChoiceField);
+DECLARE_POINTER_TYPE(PackageChoiceStyle);
+DECLARE_POINTER_TYPE(PackageChoiceValue);
+
+/// A field for PackageChoice values, it contains a list of choices for PackageChoices
+class PackageChoiceField : public Field {
+  public:
+	PackageChoiceField() : required(true) {}
+	DECLARE_FIELD_TYPE(PackageChoice);
+	
+	OptionalScript     script;			///< Script to apply to all values
+	String             match;			///< Package filenames to match
+	String             initial;			///< Initial value
+	bool               required;		///< Is selecting a package required?
+	
+	virtual void initDependencies(Context&, const Dependency&) const;
+};
+
+// ----------------------------------------------------------------------------- : PackageChoiceStyle
+
+/// The Style for a PackageChoiceField
+class PackageChoiceStyle : public Style {
+  public:
+	PackageChoiceStyle(const PackageChoiceFieldP& field);
+	DECLARE_STYLE_TYPE(PackageChoice);
+	
+	Font font;	///< Font to use for the text
+	
+	virtual int update(Context&);
+};
+
+// ----------------------------------------------------------------------------- : PackageChoiceValue
+
+/// The Value in a PackageChoiceField
+class PackageChoiceValue : public Value {
+  public:
+	PackageChoiceValue(const PackageChoiceFieldP& field) : Value(field), package_name(field->initial) {}
+	DECLARE_VALUE_TYPE(PackageChoice, String);
+	
+	ValueType package_name;	///< The selected package
+	
+	/// Get the package (if it is set)
+	PackagedP getPackage() const;
+	
+	virtual bool update(Context&);
+};
+
+// ----------------------------------------------------------------------------- : EOF
+#endif

src/data/field/symbol.cpp

@@ -11,11 +11,7 @@
 
 // ----------------------------------------------------------------------------- : SymbolField
 
-IMPLEMENT_FIELD_TYPE(Symbol)
-
-String SymbolField::typeName() const {
-	return _("symbol");
-}
+IMPLEMENT_FIELD_TYPE(Symbol, "symbol");
 
 IMPLEMENT_REFLECTION(SymbolField) {
 	REFLECT_BASE(Field);

src/data/field/text.cpp

@@ -17,11 +17,7 @@ TextField::TextField()
 	, default_name(_("Default"))
 {}
 
-IMPLEMENT_FIELD_TYPE(Text)
-
-String TextField::typeName() const {
-	return _("text");
-}
+IMPLEMENT_FIELD_TYPE(Text, "text");
 
 void TextField::initDependencies(Context& ctx, const Dependency& dep) const {
 	Field        ::initDependencies(ctx, dep);

src/data/symbol_font.cpp

@@ -45,7 +45,9 @@ String SymbolFont::typeNameStatic() { return _("symbol-font"); }
 String SymbolFont::typeName() const { return _("symbol-font"); }
 
 SymbolFontP SymbolFont::byName(const String& name) {
-	return packages.open<SymbolFont>(name + _(".mse-symbol-font"));
+	return packages.open<SymbolFont>(
+		name.size() > 16 && is_substr(name, name.size() - 16, _(".mse-symbol-font"))
+		? name : name + _(".mse-symbol-font"));
 }
 
 IMPLEMENT_REFLECTION(SymbolFont) {
@@ -588,10 +590,14 @@ void SymbolFontRef::loadFont(Context& ctx) {
 		font = SymbolFontP();
 	} else {
 		font = SymbolFont::byName(name);
-		// ensure the dependency on the font is present in the stylesheet this ref is in
-		// Getting this stylesheet from the context is a bit of a hack
-		StyleSheetP stylesheet = from_script<StyleSheetP>(ctx.getVariable(_("stylesheet")));
-		stylesheet->requireDependency(font.get());
+		if (name().GetChar(0) != _(' ')) {
+			// ensure the dependency on the font is present in the stylesheet this ref is in
+			// Getting this stylesheet from the context is a bit of a hack
+			// If the name starts with a ' ', no dependency is needed;
+			//  this is for packages selected with a PackageChoiceList
+			StyleSheetP stylesheet = from_script<StyleSheetP>(ctx.getVariable(_("stylesheet")));
+			stylesheet->requireDependency(font.get());
+		}
 	}
 }