0
|
1 |
#
|
|
2 |
# Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
|
|
3 |
# All rights reserved.
|
|
4 |
# This component and the accompanying materials are made available
|
|
5 |
# under the terms of "Eclipse Public License v1.0"
|
|
6 |
# which accompanies this distribution, and is available
|
|
7 |
# at the URL "http://www.eclipse.org/legal/epl-v10.html".
|
|
8 |
#
|
|
9 |
# Initial Contributors:
|
|
10 |
# Nokia Corporation - initial contribution.
|
|
11 |
#
|
|
12 |
# Contributors:
|
|
13 |
#
|
|
14 |
# Description:
|
|
15 |
#
|
|
16 |
'''
|
|
17 |
A plugin implementation for image selection from ConfigurationLayers.
|
|
18 |
'''
|
|
19 |
|
|
20 |
import os
|
|
21 |
import logging
|
3
|
22 |
import pkg_resources
|
0
|
23 |
|
|
24 |
try:
|
|
25 |
from cElementTree import ElementTree
|
|
26 |
except ImportError:
|
|
27 |
try:
|
|
28 |
from elementtree import ElementTree
|
|
29 |
except ImportError:
|
|
30 |
try:
|
|
31 |
from xml.etree import cElementTree as ElementTree
|
|
32 |
except ImportError:
|
|
33 |
from xml.etree import ElementTree
|
|
34 |
|
3
|
35 |
|
0
|
36 |
|
|
37 |
from cone.public import exceptions,plugin,utils,api
|
|
38 |
from imageplugin.generators import OutputGenerator,InputFile,InputDir,InvalidInputFileException
|
|
39 |
|
|
40 |
class ImageImpl(plugin.ImplBase):
|
|
41 |
"""
|
|
42 |
ContentImpl plugin finds all image resources from each layer and copies
|
|
43 |
them to the output correctly. It follows the Configuration project override
|
|
44 |
rules, so that the topmost layer files override files on the previous layers.
|
|
45 |
"""
|
|
46 |
|
|
47 |
IMPL_TYPE_ID = "imageml"
|
|
48 |
|
|
49 |
def __init__(self,ref,configuration):
|
|
50 |
"""
|
|
51 |
Overloading the default constructor
|
|
52 |
"""
|
|
53 |
plugin.ImplBase.__init__(self,ref,configuration)
|
|
54 |
self.include = {}
|
|
55 |
self.exclude = {}
|
|
56 |
self.input = ""
|
|
57 |
self.desc = ""
|
|
58 |
self.output_file = ""
|
|
59 |
self.logger = logging.getLogger('cone.imageml(%s)' % self.ref)
|
|
60 |
self.errors = False
|
|
61 |
|
|
62 |
def get_include_pattern(self):
|
|
63 |
include_pattern = ""
|
|
64 |
if self.include.has_key('pattern'):
|
|
65 |
include_pattern = self.include['pattern'][0]
|
|
66 |
return include_pattern
|
|
67 |
|
|
68 |
def get_exclude_pattern(self):
|
|
69 |
exclude_pattern = ""
|
|
70 |
if self.exclude.has_key('pattern'):
|
|
71 |
exclude_pattern = self.exclude['pattern'][0]
|
|
72 |
return exclude_pattern
|
|
73 |
|
|
74 |
def list_output_files(self):
|
|
75 |
"""
|
|
76 |
Return a list of output files as an array.
|
|
77 |
"""
|
|
78 |
return []
|
|
79 |
|
|
80 |
def generate(self, context=None):
|
|
81 |
"""
|
|
82 |
Generate the given implementation.
|
|
83 |
"""
|
|
84 |
self.logger.info('Generating')
|
|
85 |
ret = True
|
|
86 |
for generator in self.generators:
|
|
87 |
self.logger.info(generator)
|
3
|
88 |
generator.subpath = os.path.join(context.output,self.output)
|
0
|
89 |
try:
|
3
|
90 |
ret = generator.generate(context) and ret
|
|
91 |
outfile = generator.get_outputpath()
|
|
92 |
context.add_file(outfile, implementation=self)
|
0
|
93 |
except InvalidInputFileException, e:
|
|
94 |
self.logger.error(e)
|
|
95 |
return ret
|
|
96 |
|
|
97 |
def generate_layers(self,layers):
|
|
98 |
"""
|
|
99 |
Generate the given Configuration layers.
|
|
100 |
"""
|
|
101 |
return self.generate()
|
|
102 |
|
|
103 |
def get_refs(self):
|
|
104 |
refs = []
|
|
105 |
for generator in self.generators:
|
|
106 |
refs.extend(generator.get_refs())
|
|
107 |
if refs:
|
|
108 |
return utils.distinct_array(refs)
|
|
109 |
else:
|
|
110 |
return None
|
|
111 |
|
|
112 |
|
|
113 |
class ImageImplReader(plugin.ReaderBase):
|
|
114 |
"""
|
|
115 |
Parses a single imageml implml file
|
|
116 |
"""
|
|
117 |
NAMESPACE = 'http://www.s60.com/xml/imageml/1'
|
3
|
118 |
NAMESPACE_ID = 'imageml'
|
|
119 |
ROOT_ELEMENT_NAME = 'imageml'
|
0
|
120 |
FILE_EXTENSIONS = ['imageml']
|
|
121 |
|
|
122 |
INCLUDE_ATTR = ['pattern']
|
|
123 |
EXCLUDE_ATTR = ['pattern']
|
|
124 |
def __init__(self):
|
|
125 |
self.desc = None
|
|
126 |
self.output = None
|
|
127 |
self.input_dir = None
|
|
128 |
self.include = None
|
|
129 |
self.exclude = None
|
|
130 |
self.namespaces = [self.NAMESPACE]
|
|
131 |
|
|
132 |
@classmethod
|
|
133 |
def read_impl(cls, resource_ref, configuration, etree):
|
|
134 |
reader = ImageImplReader()
|
|
135 |
reader.desc = reader.parse_desc(etree)
|
|
136 |
reader.outputgenerators = reader.parse_outputs(etree)
|
|
137 |
|
|
138 |
impl = ImageImpl(resource_ref, configuration)
|
|
139 |
impl.desc = reader.desc
|
|
140 |
impl.generators = reader.outputgenerators
|
|
141 |
for generator in impl.generators:
|
|
142 |
generator.configuration = configuration
|
|
143 |
|
|
144 |
return impl
|
3
|
145 |
|
|
146 |
@classmethod
|
|
147 |
def get_schema_data(cls):
|
|
148 |
return pkg_resources.resource_string('imageplugin', 'xsd/imageml.xsd')
|
|
149 |
|
0
|
150 |
def fromstring(self, xml_as_string):
|
|
151 |
etree = ElementTree.fromstring(xml_as_string)
|
|
152 |
self.desc = self.parse_desc(etree)
|
|
153 |
self.outputgenerators = self.parse_outputs(etree)
|
|
154 |
return
|
|
155 |
|
|
156 |
def parse_desc(self,etree):
|
|
157 |
desc = ""
|
|
158 |
desc_elem = etree.find("{%s}desc" % self.namespaces[0])
|
|
159 |
if desc_elem != None:
|
|
160 |
desc = desc_elem.text
|
|
161 |
return desc
|
|
162 |
|
|
163 |
def parse_input_include(self,etree):
|
|
164 |
include_elem = etree.findall("{%s}include" % self.namespaces[0])
|
|
165 |
include = {}
|
|
166 |
for f in include_elem:
|
|
167 |
for key in self.INCLUDE_ATTR:
|
|
168 |
# Add the attribute if it is found to include dict
|
|
169 |
include[key] = []
|
|
170 |
attr = f.get(key)
|
|
171 |
if attr: include[key].append((attr))
|
|
172 |
return include
|
|
173 |
|
|
174 |
def parse_input_exclude(self,etree):
|
|
175 |
elem = etree.findall("{%s}exclude" % self.namespaces[0])
|
|
176 |
exclude = {}
|
|
177 |
for f in elem:
|
|
178 |
for key in self.EXCLUDE_ATTR:
|
|
179 |
# Add the attribute if it is found
|
|
180 |
exclude[key] = []
|
|
181 |
attr = f.get(key)
|
|
182 |
if attr: exclude[key].append((attr))
|
|
183 |
return exclude
|
|
184 |
|
|
185 |
def parse_inputs(self,etree):
|
|
186 |
inputs = etree.findall("{%s}input" % self.namespaces[0])
|
|
187 |
inputlist = []
|
|
188 |
for input_elem in inputs:
|
|
189 |
if input_elem.get('dir'):
|
|
190 |
inputdir = InputDir(input_elem.get('dir'),**input_elem.attrib)
|
|
191 |
inputdir.include = self.parse_input_include(input_elem)
|
|
192 |
inputdir.exclude = self.parse_input_exclude(input_elem)
|
|
193 |
inputlist.append(inputdir)
|
|
194 |
elif input_elem.get('file'):
|
|
195 |
inputlist.append(InputFile(input_elem.get('file'),**input_elem.attrib))
|
|
196 |
return inputlist
|
|
197 |
|
|
198 |
def parse_outputs(self,etree):
|
|
199 |
outputs = etree.findall("{%s}output" % self.namespaces[0])
|
|
200 |
outputpath = ""
|
|
201 |
outputgenerators = []
|
|
202 |
for output_elem in outputs:
|
|
203 |
if output_elem.get('file'):
|
|
204 |
outputpath = output_elem.get('file')
|
|
205 |
generator = OutputGenerator(outputpath,**output_elem.attrib)
|
|
206 |
generator.inputs = self.parse_inputs(output_elem)
|
|
207 |
outputgenerators.append(generator)
|
|
208 |
return outputgenerators
|
|
209 |
|