root/trunk/FieldsWidgets.py

# Copyright 2006 by the LeMill Team (see AUTHORS)
#
# This file is part of LeMill.
#
# LeMill is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# LeMill is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with LeMill; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

from AccessControl import ClassSecurityInfo
from Products.Archetypes.config import REFERENCE_CATALOG
from Products.Archetypes.Registry import registerField, registerWidget
from Products.Archetypes.Field import StringField, LinesField, ReferenceField, ObjectField, FileField
from Products.Archetypes.Widget import TextAreaWidget, StringWidget, SelectionWidget, TypesWidget, MultiSelectionWidget, VisualWidget, FileWidget
from Products.Archetypes.ReferenceEngine import Reference
from config import to_unicode
from Products.Archetypes import config
from string import letters, punctuation
from Products.CMFCore.utils import getToolByName
from ZODB.PersistentMapping import PersistentMapping
from Products.Archetypes.utils import shasattr
from Acquisition import aq_base
from mp3tool import get_length
from types import ListType, TupleType, StringType, UnicodeType, InstanceType
from messagefactory_ import i18nme as _
from random import shuffle
from copy import copy
from xml.dom.minidom import parseString as parse_xml
from urlparse import urlparse
from xml.sax.saxutils import unescape
import re, os, shutil

#StringWidget and TextAreaWidget need to update their macro, otherwise they try to use archetypes/skins/widgets -path only
#Unfortunately this can't be done but by making new Widgets: LeStringWidget and LeTextAreaWidget

class LeVisualWidget(VisualWidget):
    _properties = VisualWidget._properties.copy()
    _properties.update({
        'macro' : 'widget_visual',
        'rows'  : 18,      #rows of TextArea if VE is not available
        'cols'  : 80,      #same for cols
        'width' : '507px', #width of VE frame (if VE is avalilable)
        'height': '260px', #same for height
    })
    # material types use versions of chapter_widgets and are not affected by this

    def process_form(self, instance, field, form, empty_marker=None, emptyReturnsMarker=False, validating=True):
        """Basic impl for form processing in a widget"""
        value = form.get(field.getName(), empty_marker)
        if value is empty_marker:
            return empty_marker
        if emptyReturnsMarker and value == '':
            return empty_marker
        return value, {}

registerWidget(LeVisualWidget,
    title='Visual Widget',
    description='Visual Widget'
)   

class LeStringWidget(StringWidget):
    _properties = StringWidget._properties.copy()
    _properties.update({
        'macro' : 'widget_string'
    })

registerWidget(LeStringWidget,
    title='String Widget',
    description='String Widget'
)


class LeTextAreaWidget(TextAreaWidget):
    _properties = TextAreaWidget._properties.copy()
    _properties.update({
        'macro' : 'widget_textarea'
    })

registerWidget(LeTextAreaWidget,
    title='Textarea Widget',
    description='Textarea Widget'
)

class TagsWidget(StringWidget):
    _properties = StringWidget._properties.copy()
    _properties.update({
        'macro' : 'widget_tags',
    })
    
registerWidget(TagsWidget,
    title='Tags Widget',
    description='Tags Widget',
    used_for=('Products.LeMill.TagsField.TagsField',)
)

class HTMLLinkWidget(StringWidget):
    _properties = StringWidget._properties.copy()
    _properties.update({
        'macro' : 'widget_htmllink',
    })

    def getShortLinkName(self, link):
        """Returns the shortened version of the link pointing to the reference's location. This shortened version goes into the content of the <a> tag."""      
        lt = getToolByName(self, 'lemill_tool') 
        return lt.parse_text(link, start_with_p=False) 

    def process_form(self, instance, field, form, empty_marker=None, emptyReturnsMarker=False, validating=True):
        """Basic impl for form processing in a widget"""
        value = form.get(field.getName(), empty_marker)
        if value is empty_marker:
            return empty_marker
        if emptyReturnsMarker and value == '':
            return empty_marker
        if field.getName() == 'home_page':
            if not (value.lower().startswith('http://') or value.lower().startswith('https://')) and value != '':
                value = 'http://' + value
        return value, {}
    
registerWidget(HTMLLinkWidget,
    title='HTML Link Widget',
    description='Generated <a> tag Widget',
    used_for=('Products.LeMill.FieldsWidgets.HTMLLinkWidget',)
)

class AuthorsWidget(StringWidget):
    _properties = StringWidget._properties.copy()
    _properties.update({
        'macro' : 'widget_authors',
    })

    def process_form(self, instance, field, form, empty_marker=None, emptyReturnsMarker=False, validating=True):
        """ Check if the field should use computed values or custom entry. If custom entry, then create the list by replacing
            author names with their ids if possible. 
            
            Since the field cannot store extra info about if its custom or computed, first member of the field is '*!*'
            if the value is customized. This must be removed when displaying field values.  
            
            !!! stop !!! what to do with searches and comparisons, if there is *!* messing things up? 
            
        """ 

        name=field.getName()
        is_computed=form.get(name+'_are_computed','')=='computed'
        computed_authors= instance.recalculateAuthors(set_field=False, force=True)
        if is_computed:
            authors_list=computed_authors 
        else:
            value_string=form.get(name+'_custom','')
            names=value_string.split(',')
            names=[n.strip() for n in names]
            if names:
                utool=getToolByName(instance, 'lemill_usertool')
                # find matching users for names
                authors_list=['*!*']
                for name in names:
                    user_id=utool.getMemberByFullName(name, return_id=True, candidates=computed_authors) or name
                    authors_list.append(user_id)
            else:
                authors_list=instance.recalculateAuthors(set_field=False, force=True) 
        return authors_list, {}                

    def displayString(self, instance, values, as_links=False):
        """ Linearize list of ids to string of user names and omit custom marker """
        if not values:
            return values
        utool=getToolByName(instance, 'lemill_usertool')
        if values[0]=='*!*':
            values=values[1:]  
        names=[utool.linkTo(user_id, disabled=not as_links) for user_id in values] 
        return ", ".join(names)
            
    def getComputedAuthors(self,instance,as_string=True, include_user=False):
        """ Get updated authors list to show as an option when editing authors field """
        authors=instance.recalculateAuthors(set_field=False)
        if include_user:
            utool=getToolByName(instance, 'lemill_usertool')
            user_id=utool.getAuthenticatedId()
            if user_id not in authors:
                authors.append(user_id)            
        if as_string:
            return self.displayString(instance, authors, as_links=False)
        else:
            return authors

           
registerWidget(AuthorsWidget,
    title='Authors Widget',
    description='Authors Widget',
    used_for=('Products.Archetypes.Field.LinesField',)
)




class MessengerWidget(TypesWidget):
    _properties = TypesWidget._properties.copy()
    _properties.update({
        'macro' : 'widget_messenger',
    },)

    security = ClassSecurityInfo()

    security.declarePublic('process_form')
    def process_form(self, instance, field, form, empty_marker=None,
                     emptyReturnsMarker=False, validating=True):
        """Concatenates address + messenger type, but if address already contains something like prefix (word:) then removes it. 
        """
        name = field.getName()
        otherName = "%s_other" % name
        value = form.get(name, empty_marker)
        othervalue = form.get(otherName, empty_marker)
        if not value: 
            return '', {}
        if not othervalue == empty_marker:
            value = "%s:%s" % (othervalue,value)
        return value, {}


registerWidget(MessengerWidget,
    title='Messenger Widget',
    description='Messenger Widget',
    used_for=('Products.Archetypes.Field.StringField',)
)


class MobileWidget(StringWidget):
    _properties = StringWidget._properties.copy()
    _properties.update({
        'macro' : 'widget_mobile',
    })

    security = ClassSecurityInfo()

    security.declarePublic('process_form')
    def process_form(self, instance, field, form, empty_marker=None,
                     emptyReturnsMarker=False, validating=True):
        name = field.getName()
        otherName = "%s_checkbox" % name
        value = form.get(name, empty_marker)
        othervalue = form.get(otherName, empty_marker)
        if value == empty_marker and emptyReturnsMarker: 
            return empty_marker
        if othervalue=="1":
            value = "*SMS*%s" % value
        return value, {}

    
registerWidget(MobileWidget,
    title='Mobile Widget',
    description='Mobile Widget',
    used_for=('Products.Archetypes.Field.StringField',)
)


class CopyrightWidget(SelectionWidget):
    _properties = SelectionWidget._properties.copy()
    _properties.update({
        'macro' : 'widget_copyright',
    })
    
registerWidget(CopyrightWidget,
    title='Copyright Widget',
    description='Copyright selection Widget',
    used_for=('Products.LeMill.StringField.StringField',)
)

class TwoColumnMultiSelectionWidget(MultiSelectionWidget):
    _properties = MultiSelectionWidget._properties.copy()
    _properties.update({
        'macro' : 'widget_twocolumn',
    })
    
registerWidget(TwoColumnMultiSelectionWidget,
    title='Two column widget',
    description='Two column multiselection widget',
    used_for=('Products.Archetypes.Field.MultiSelectionField',)
)


class GroupWidget(SelectionWidget):
    _properties = SelectionWidget._properties.copy()
    _properties.update({
        'macro' : 'widget_group',
        'format' : 'checkbox',
    })
    def getGroupVocabulary(self, instance):
        """ this builds vocabulary tuples for groups field:
        [(group Title, group UID, is_checked, is_disabled), ... ]
         """
        lutool = getToolByName(instance, 'lemill_usertool')
        mf = lutool.getMemberFolder() 
        user_groups=[]
        if mf:
            user_groups=mf.getGroups()
        resource_groups=instance.getGroupInfo()       
        resource_uids=[g.UID for g in resource_groups]
        user_uids=[g.UID for g in user_groups]
        disabled=[(g.Title.lower(), g.Title, g.UID, True, True) for g in resource_groups if (g.UID not in user_uids) and isinstance(g.Title, StringType)]
        disabled.sort()
        other=[(g.Title.lower(), g.Title, g.UID, g.UID in resource_uids, False) for g in user_groups if isinstance(g.Title, StringType)]
        other.sort()
        groups=[(g[1],g[2],g[3],g[4]) for g in disabled+other]
        return groups+[('...or create a new group:','__new_group',False,False)]
        
    def process_form(self, instance, field, form, empty_marker=[],
                     emptyReturnsMarker=False, validating=True):
        """Basic impl for form processing in a widget"""
        value = form.get(field.getName(), empty_marker)
        if value is empty_marker:
            return empty_marker
        if emptyReturnsMarker and value == '':
            return empty_marker
        if '__new_group' in value:
            new_group_name = form.get('new_group_name', '')
            if new_group_name:
                # create a new group here
                blog=instance.community.groups.addGroup(new_group_name)
                value.remove('__new_group')
                value.append(blog.UID())
        return value, {}

class TranslationWidget(SelectionWidget):
    _properties = SelectionWidget._properties.copy()
    _properties.update({
        'macro' : 'widget_translation',
    })
    def getTranslationsData(self, instance):
        """ Get {uid, url, title, language, pretty_language} for  translations of this instance """
        pc=getToolByName(instance, 'portal_catalog')
        ltool=getToolByName(instance, 'lemill_tool')
        my_uid=instance.UID()
        md_results=pc(getOther_languages=my_uid, getState=['public','draft'])
        results=[]
        for md in self.fastMetadata(md_results, ['getUID','rid','getNicename','Language']):
            # try
            data={'uid':md[0], 'url':pc.getUrlPath(md[1]), 'title':md[2], 'lang':md[3], 'pretty_lang':ltool.getPrettyLanguage(md[3])}
            results.append(data)
            # except:
            # pass
        results.sort(key=lambda x: x['lang'])
        return results

    def process_form(self, instance, field, form, empty_marker=[],
                     emptyReturnsMarker=False, validating=True):
        """Basic impl for form processing in a widget"""
        value=True
        uids=[]
        index=0
        while value:
            value=form.get('%s_%s' % (field.getName(), index), '')
            if value:
                uids.append(value)
            index+=1
        return value, {}

class ChapterWidget(SelectionWidget):
    _properties = SelectionWidget._properties.copy()
    _properties.update({
        'macro' : 'widget_chapter',
        'collections_only' : False,
        'helper_js' : ('AC_RunActiveContent.js',),
        'show_added' : True,
        'no_label' : True
    }) 
    security = ClassSecurityInfo()

    security.declarePublic('process_form')
    def process_form(self, instance, field, form, empty_marker=None,
            emptyReturnsMarker=False, validating=True):
        """ goes through the form, reorganizes chapters if necessary and delivers results to field writer (as dict). """
        chapter_type=form.get('chapter_type')
        if not chapter_type:
            return {},{}
        changes = {}
        changes['edited']=int(form.get('chapter_last_edited', 0))
        count=int(form.get('chapter_count',0))
        changes['count']=count
        new_order=[]
        reorder=False
        # Orderings and deletions
        
        for index in range(0,count):
            order=int(form.get('chapter_order_%s' % index, 0))
            new_order.append(order)
            if order!=index:
                reorder=True
        if reorder:
            changes['new_order']=new_order
        if form.has_key('delete_chapter'):
            changes['delete_chapter']=int(form.get('delete_chapter'))
        # Changes
        changes['chapter_type']=chapter_type
        if chapter_type=='media_piece':
            changes['uid']=form.get('piece_uid')
            changes['caption']=form.get('caption','')
        elif chapter_type=='text_block':
            changes['text']=form.get('chapter_textarea')
        elif chapter_type=='embed_block':
            changes['text']=''
            changes['embed']=form.get('embed_field','')
            changes['embed_old']=form.get('embed_field_old', '')
        # Save & edit buttons
        if form.get('saveChapter', None):
            form.update({'chapter_edited':-1, 'chapter_anchor':changes['edited'], 'stay':1})        
        elif form.get('editChapter', None):
            form.update({'chapter_anchor':form['chapter_edited'], 'stay':1})        
        # Add-buttons 
        elif form.get('add_text_block', None):
            changes['new_chapters']=[{'text':'','type':'text_block'}]
            form.update({'chapter_edited':count, 'chapter_anchor':count, 'stay':1})
        elif form.get('add_media_piece', None):
            changes['new_chapters']=[{'text':'','type':'media_piece','uid':''}]
            form.update({'chapter_edited':count, 'chapter_anchor':count, 'stay':1})
        elif form.get('add_embed_block', None):
            changes['new_chapters']=[{'text':'','type':'embed_block', 'embed':''}]
            form.update({'chapter_edited':count, 'chapter_anchor':count, 'stay':1})
        return changes, {}

registerWidget(ChapterWidget,
    title='Chapter Widget',
    description='Chapter editor Widget',
    used_for=('Products.LeMill.ChapterField',)
)

class SlideWidget(ChapterWidget):
    _properties = ChapterWidget._properties.copy()
    _properties.update({
        'macro' : 'widget_slides',
        'collections_only' : False,
        'show_added' : True,
        'chapter_count' : 5,
    })

registerWidget(SlideWidget,
    title='Slide Widget',
    description='Slide and caption viewer Widget',
    used_for=('Products.LeMill.ChapterField',)
)

class PilotWidget(ChapterWidget):
    _properties = ChapterWidget._properties.copy()
    _properties.update({
        'macro' : 'widget_pilot',
        'collections_only' : False,
        'helper_js' : ('AC_RunActiveContent.js',),
        'show_added' : True,
        'chapter_count' : 3,
    })
    security = ClassSecurityInfo()

    security.declarePublic('process_form')
    def process_form(self, instance, field, form, empty_marker=None,
            emptyReturnsMarker=False, validating=True):
        """ goes through the form and sends changes forward to field writer """
        changes, empty= ChapterWidget.process_form(self, instance, field, form)
        if not changes:
            return changes,empty
        chapter_type=changes['chapter_type']
        if chapter_type=='pilot_scene':
            audio_file=form.get('audio_file', None)
            if audio_file and hasattr(audio_file, 'filename'):
                changes['audio_file']=audio_file
            else:
                changes['audio_uid']=form.get('audio_uid')
            image_file=form.get('image_file', None)
            if image_file and hasattr(image_file, 'filename'):
                changes['image_file']=image_file
            else:
                changes['image_uid']=form.get('image_uid')
            kws=[]
            for i in range(0, 3):
                kw=form.get('keywords_%s' % i, '')
                if kw:
                    kws.append(kw)
            if kws:
                changes['keywords']=kws
            qs=[]
            for i in range(0, 7):
                q=form.get('question_%s' % i, '')
                if q:
                    qs.append(q)
            if qs:
                changes['questions']=qs
        # Buttons 
        if form.get('add_pilot_section', None):
            changes['new_chapters']={'text':'','type':'pilot_scene','audio_uid':'', 'image_uid':'', 'keywords':[], 'questions':[]},
            form.update({'chapter_edited':count, 'chapter_anchor':count, 'stay':1})
        return changes, {}

registerWidget(PilotWidget,
    title='Pilot Widget',
    description='Scene editor Widget',
    used_for=('Products.LeMill.ChapterField',)
)

class ExerciseWidget(ChapterWidget):
    _properties = ChapterWidget._properties.copy()
    _properties.update({
        'macro' : 'widget_exercise',
        'collections_only' : False,
        'helper_js' : ('AC_RunActiveContent.js',),
        'show_added' : True,
        'chapter_count' : 1,
    })
    security = ClassSecurityInfo()

    security.declarePublic('process_form')
    def process_form(self, instance, field, form, empty_marker=None,
            emptyReturnsMarker=False, validating=True):
        """ goes through the form and tries to merge all text inputs to lists, find references to pieces and if file objects are uploaded, just send them forward to field. """
        changes, empty= ChapterWidget.process_form(self, instance, field, form)
        if not changes:
            return changes,empty
        chapter_type=changes['chapter_type']                
        if chapter_type=='guidelines': 
            # this should be deprecated, but I keep this still here because I cannot now think if there 
            # are any bad consequences from removing it. Too tired.
            changes['text']=form.get('chapter')
        elif chapter_type=='exercise':
            # exercises are question chapters that don't have yet chosen any specific type for themselves. They should be empty.
            changes['text']=''            
        elif chapter_type in ['choice','multiple_choices','poll']:
            question=form.get('choice_question')
            answers=[]
            answer_count=int(form.get('choice_answer_count',0))
            for i in range(0, answer_count):
                answer={}
                answer['text']=form.get('choice_answer_%s' % i, '')
                answer['is_correct']= chapter_type=='poll' or int(form.get('answer_%s_correct' % i, ''))
                answer['order']=int(form.get('choice_order_%s' % i, 0))
                if answer['text']:  # empty answers are deleted by ignoring them 
                    answers.append(answer)
            answers.sort(cmp=lambda x,y: cmp(x['order'], y['order']))
            changes['question']=question
            changes['answers']=answers or [{'text':'','is_correct':1,'order':0}]
            try:
                max_points=float(form.get('max_points_mc', 1))
            except ValueError:
                max_points=1
            changes['max_points']=max_points
        elif chapter_type=='fill_in_the_blanks':
            changes['text']=form.get('fill_blanks','')
            try:
                max_points=float(form.get('max_points_fib', 1))
            except ValueError:
                max_points=1
            changes['max_points']=max_points
        elif chapter_type=='open_ended':
            changes['text']=form.get('open_field','')
            try:
                max_points=float(form.get('max_points_ff', 1))
            except ValueError:
                max_points=1
            changes['max_points']=max_points

        # Buttons 
        if form.get('add_exercise', None):
            changes['new_chapters']=[{'text':'','type':'exercise'}]
            count=changes['count']
            form.update({'chapter_edited':count, 'chapter_anchor':count, 'stay':1})
        elif form.get('import_potatoes', None):
            file=form.get('import_file', None)
            if file and hasattr(file, 'filename'):
                if file.filename.endswith('jcl'):
                    text=self.importJClozeQuestion(file)
                    changes['chapter_type']='fill_in_the_blanks'
                    changes['text']=text
                    form.update({'chapter_edited':count, 'chapter_anchor':count, 'stay':1})
                elif file.filename.endswith('jcz'):
                    new_chapters=self.importJQuizQuestions(file)
                    if new_chapters:
                        this_chapter= new_chapters.pop(0)
                        changes['chapter_type']=this_chapter['type']
                        changes['answers']=this_chapter['answers']
                        changes['question']=this_chapter['text']
                        if new_chapters:
                            changes['new_chapters']=new_chapters
                            form.update({'chapter_edited':count, 'chapter_anchor':count, 'stay':1})
        return changes, {}
   
    def importJQuizQuestions(self, file):
        """ import hot potatoes questions made with jquiz """        
        dom = parse_xml(file.read())
        questions = dom.getElementsByTagName("question-record")
        result=[]
        for ques in questions:
            questype = int(ques.getElementsByTagName("question-type")[0].childNodes[0].data)
            if not (questype==1 or questype==4):
                return            
            question = ques.getElementsByTagName("question")[0].childNodes[0].data.encode('utf-8')
            # if jquiz question type is multiple choice(1) or multiple correct(4)
            answers = ques.getElementsByTagName("answer")
            # calculate how many correct answers (is it choice or choice_multiple type)
            corrects=0
            made_answers=[]
            for answer in answers:
                correct = int(answer.getElementsByTagName("correct")[0].childNodes[0].data) # 1-correct 0-false
                if correct:
                    corrects+=1
                answertext = answer.getElementsByTagName("text")[0].childNodes[0].data.encode('utf-8')
                if answertext:
                    made_answers.append({'text':answertext, 'is_correct':correct})
            if corrects==len(result):
                qtype='poll'
            elif corrects==1:
                qtype='choice'
            else:
                qtype='multiple_choices'
            result.append({'type':qtype,'text':question,'answers':made_answers})        
        dom.unlink()
        return result
    
    def importJClozeQuestion(self, file):
        """ import hot potatoes question made with JCloze """        
        dom = parse_xml(file.read())
        gap_fill = dom.getElementsByTagName("gap-fill")[0]
        result=[]
        for node in gap_fill.childNodes:
            if node.nodeType==node.TEXT_NODE:
                result.append(node.data)
            else:
                for answer in node.getElementsByTagName("answer"):
                    text_tag=answer.getElementsByTagName("text")[0]
                    text=text_tag.childNodes[0].data
                    result.append('{%s}' % text)
        result=u''.join(result)
        #result=unescape(u''.join(result), {'&#x003C;':'<','&#x003E;':'>'})
        dom.unlink()
        return result

registerWidget(ExerciseWidget,
    title='Exercise Widget',
    description='Exercise editor Widget',
    used_for=('Products.LeMill.ChapterField',)
)

class AudioWidget(FileWidget):
    _properties = FileWidget._properties.copy()
    _properties.update({
    'macro' : 'widget_audio',
    'helper_js' : ('AC_RunActiveContent.js',),
    })

registerWidget(AudioWidget,
    title='Audio Widget',
    description='Widget that uses flashplayer for mp3:s',
    used_for=('Products.LeMill.ChapterField',)
)

class LeMillLinksWidget(LeVisualWidget):
    _properties = LeVisualWidget._properties.copy()
    _properties.update({
            'macro' : 'widget_lemilllinks',
    })
        
    def process_form(self, instance, field, form, empty_marker=None,
                     emptyReturnsMarker=False, validating=True):
        """ Replaces internal links with {uid:UID} and external links with {url} """
        fieldname = field.getName()
        value = form.get(fieldname, empty_marker)
        
        if value.strip() == '':
            return None, {}
            
        portal_url = getToolByName(instance, 'portal_url')
        portal_url = portal_url()
        pc = getToolByName(instance, 'portal_catalog')
        from LargeSectionFolder import DEFAULT_LOCATIONS
        from config import CONTENT_TYPES, ACTIVITY_TYPES, TOOLS_TYPES
        suitable_types = CONTENT_TYPES + ACTIVITY_TYPES + TOOLS_TYPES
        locations = {}
        # Only some locations are needed
        for d in DEFAULT_LOCATIONS.keys():
            if d in suitable_types:
                locations[d] = DEFAULT_LOCATIONS[d]
        # array of inserted data
        rows = value.split('\n')  

        data = ""
        for row in rows:
            r = row
            row = row.strip()
            words = []
            if row != '':
                words = row.split(' ')
            for word in words:
                index = words.index(word)
                # control is it link to LeMill resource
                if (word.lower().startswith(portal_url)):
                    isMaterial = False
                    for location, url in locations.items():
                        if url in word:
                            # Now the type is known, getting the id
                            temp = word.split(url)
                            temp = temp[1]
                            temp = temp.split('/')
                            id = temp[1]
                            # Now to make a catalog search
                            query = {'getId':id,'meta_type':location}
                            results = pc(query)
                            if len(results)>0:
                                words[index] = '{uid:'+results[0].UID+'}'
                                #value = value.replace(word,'{uid:'+results[0].UID+'}')
                                isMaterial = True
                    # if we dont find LeMill resource, then treat this url as any other link            
                    if not isMaterial:
                        words[index] = '{'+word+'}'
                # if it is external link
                elif (word.lower().startswith("http://") or word.lower().startswith("https://")):
                    words[index] = '{'+word+'}'
            if words != []:
                data += ' '.join(words) + '\n'
        return data, {}

registerWidget(LeMillLinksWidget,
    title='LeMill Links Widget',
    description='LeMill Links Widget',
    used_for=('Products.LeMill.FieldsWidgets.LeMillLinksField',)
)


class EmbedWidget(StringWidget):
    _properties = StringWidget._properties.copy()
    _properties.update({
        'macro' : 'widget_embed'
    })

registerWidget(EmbedWidget,
    title='Embed Widget',
    description='Embed Widget, not modifiable by common means, only displays embed code'
)


####                            ####
####            FIELDS          ####
####                            ####


class TranslationField(LinesField):
    """ A field that stores tags """
    __implements__ = LinesField.__implements__
    _properties = LinesField._properties.copy()
    _properties.update({
        'widget' : TranslationWidget,
    })

    security = ClassSecurityInfo()

    def setDisabled(self, instance, value, **kwargs):
        value=list(value)
        old_value=list(self.get(instance))
        if value and value==old_value:
            return
        LinesField.set(self, instance, value, **kwargs)
        if kwargs.get('asymmetric', False) or True: # Let's disable this for a moment
            return
        # Make sure that changes here are reflected to other translations too
        uc=getToolByName(instance, 'uid_catalog')
        my_uid=instance.UID()
        # what has been removed?
        removed=set(old_value)-set(value)
        for md in uc(UID=list(removed)):
            obj=md.getObject()
            field=obj.getField(self.getName())
            field.remove(my_uid)
        # what has been added?
        added=set(value)-set(old_value)
        for md in uc(UID=list(added)):
            obj=md.getObject()
            field=obj.getField(self.getName())
            field.add(my_uid)

    def add(self, instance, items):         
        """ local helper method, doesn't traverse to linked objects """
        items=list(items)
        old_value=list(self.get(instance))
        value=list(old_value)      
        for item in items:
            if item not in value:
                value.append(item)
        if value!=old_value:
            LinesField.set(self, instance, value)
        
    def remove(self, instance, items):         
        """ local helper method, doesn't traverse to linked objects """
        items=list(items)
        old_value=list(self.get(instance))
        value=list(old_value)      
        for item in items:
            if item in value:
                value.remove(item)
        if value!=old_value:
            LinesField.set(self, instance, value)

    security.declarePrivate('get')
    def get(self, instance, **kwargs):
        val=LinesField.get(self, instance, **kwargs)
        if callable(val):
            val=val()
        return val

    security.declarePrivate('getRaw')
    def getRaw(self, instance, **kwargs):
        val=LinesField.getRaw(self, instance, **kwargs)
        if val and callable(val):
            val=val()
        return val

                        
registerField(TranslationField,
               title='Translation Field',
               description=('Translation Field'),
               )



class TagsField(LinesField):
    """ A field that stores tags """
    __implements__ = LinesField.__implements__
    _properties = LinesField._properties.copy()
    _properties.update({
        'widget' : TagsWidget,
    })

    security = ClassSecurityInfo()

    def set(self, instance, value, **kwargs):
        if not value:
            value=''
        if isinstance(value,str):
            value = value.lower()
            value = value.split(',')
        if isinstance(value, tuple) or isinstance(value, list):
            value=[t.strip().lower() for t in value] # strip and clean individual tags
            value=list(set(value)) # remove duplicates
            value= '\n'.join(value) # merge back to string
        LinesField.set(self, instance, value, **kwargs)
                        
    def getRaw(self, instance, **kwargs):
        version = None
        try:
            version = instance.REQUEST.get('version',None)
        except AttributeError:
            pass
        if version:
            value = instance.getFieldHistory(self.getName(), version)
            if value and callable(value):
                value=value()
            value = value.split(',')
        else:
            value = LinesField.get(self, instance, **kwargs)
            if value and callable(value):
                value=value()
        return ', '.join(value)

    def get(self, instance, **kwargs):
        version = None
        try:
            version = instance.REQUEST.get('version', None)
        except AttributeError:
            pass
        if version:
            value = instance.getFieldHistory(self.getName(), version) or ''
            if value and callable(value):
                value=value()
            if value:
                value = value.split(',')              
        else:
            value = LinesField.get(self, instance, **kwargs)
            if value and callable(value):
                value=value()
        return value

registerField(TagsField,
               title='Tags Field',
               description=('Tags Field'),
               )

class WYSIWYMField(StringField):
    """A field that stores WYSIWYM strings"""
    _properties = StringField._properties.copy()
    _properties.update({
        'widget' : LeTextAreaWidget,
        'default_output_type' : 'text/x-html-captioned',
        'default_content_type' : 'text/html',
    })    
    
    security = ClassSecurityInfo()
    
    
    def getRaw(self, instance, **kwargs):
        """ Gets raw version for editing """
        version = None
        try:
            version = instance.REQUEST.get('version',None)
        except AttributeError:
            pass
        if version:
            value = instance.getFieldHistory(self.getName(), version)
        else:
            value = StringField.get(self, instance,**kwargs)
        return value
    
    def get(self, instance, **kwargs):
        """ Gets cleaned version for display """
        version = None
        try:
            version = instance.REQUEST.get('version',None)
        except AttributeError:
            pass
        value = self.getRaw(instance, **kwargs)
        cleaned_text = getattr(instance, 'cleaned_%s' % self.getName(), None)
        if cleaned_text and not version:
            return cleaned_text        
        ltool = getToolByName(instance, 'lemill_tool')
        cleaned_text = ltool.parse_text(value)
        if not version:
            setattr(instance, 'cleaned_%s' % self.getName(), cleaned_text)
        return cleaned_text

    def set(self, instance, value, **kwargs):
        """ update the cleaned_text and then call original set """

        # update cleaned text
        ltool = getToolByName(instance, 'lemill_tool')
        cleaned_text = ltool.parse_text(value)
        setattr(instance, 'cleaned_%s' % self.getName(), cleaned_text)

        # set value
        StringField.set(self, instance, value, **kwargs)
        


    # render -method has moved to LeMillTools, because it is needed also outside the wysiwym field.

registerField(WYSIWYMField,
               title='WYSIWYM Field',
               description=('WYSIWYM Field'),
               )


class ChapterField(ObjectField):
    """ chapters are stored as lists, where chapter can either be a string or UID. If UID, view widget should fetch the object. """
    _properties = ObjectField._properties.copy()
    _properties.update({
        'widget' : ChapterWidget,
        'relationship' : 'uses', # required
        'referenceClass' : Reference,
        'referenceReferences' : False,
        'index_method':'indexValue'})
    
    security = ClassSecurityInfo()
    chapter_names={'text_block':_('text chapter'), 'media_piece':_('media piece'), 'embed_block':_('embedded content'), 'multiple_choices':_('multiple choices'), 'choices':_('choices'), 'fill_in_the_blanks':_('fill in the blanks'), 'open_ended':_('open ended question'), 'exercise':_('new exercise'), 'guidelines':_('text chapter')}

    def getChapterNames(self):
        """ Return readable versions of different chapter types """        
        return ChapterField.chapter_names 


    def getRaw(self, instance, version=None, **kwargs):
        """ Gets raw version for editing, as list """
        if version:
            value = instance.getFieldHistory(self.getName(), version) or []
        elif '_initializing_' in kwargs:
            value = self.getDefault(instance) or []    
        else:
            value = ObjectField.get(self, instance, **kwargs) or []
        if not isinstance(value, list):
            value = []
        if value and callable(value):
            value=value()
        for chapter in value:
            if isinstance(chapter, tuple):
                value = self.updateChapterList(value)
                break
            elif isinstance(chapter, dict) and chapter.get('type','')=='choice' and isinstance(chapter.get('text',[]), list):
                value=self.fixBrokenChoice(value)
                break
        return value

    def get(self, instance, **kwargs):
        """ Get a cleaned version for display """
        REQUEST=getattr(instance,'REQUEST',None)
        if REQUEST:
            version=REQUEST.get('version',None)
            translation=REQUEST.get('translation',None)
        else:
            version=None
            translation=None

        fix_choice=False
        convert=False
        if version or translation: # don't cache cleaned version
            value = self.getRaw(instance, version=version, **kwargs)
            value=self.cleanChapters(instance, value)
            if translation:
                value=self.mergeTranslationSource(instance,value)
            return value
        cleaned_value = getattr(instance, 'cleaned_%s' % self.getName(), None) 
        if cleaned_value:
            for chapter in cleaned_value:
                if isinstance(chapter, tuple):
                    convert=True
                    break
                elif isinstance(chapter, dict) and 'type' in chapter and chapter['type']=='choice' and isinstance(chapter['text'], list):
                    fix_choice=True
                    break
            if convert:
                cleaned_value=self.updateChapterList(cleaned_value)
                cleaned_value=self.updateCleanedChapters(instance, cleaned_value)
                return cleaned_value
            if fix_choice:
                cleaned_value=self.fixBrokenChoice(cleaned_value)
                cleaned_value=self.updateCleanedChapters(instance, cleaned_value)
                return cleaned_value
            else:
                return cleaned_value
        value=self.getRaw(instance, **kwargs)
        cleaned_value=self.updateCleanedChapters(instance, value)
        return cleaned_value


    def textOnly(self, instance, **kwargs):
        chapters=self.get(instance)
        if chapters and isinstance(chapters, list):
            res=[]
            for ch in chapters:
                if ch:
                    try:
                        res.append(to_unicode(ch['text']))
                    except UnicodeDecodeError:
                        pass
            return u'\n'.join(res)
        elif chapters:
            return str(chapters)        
        else:
            return ''

    def mergeTranslationSource(self, instance, chapter_list):
        """ Adds original source texts to translated chapters, under key 'original' """
        return chapter_list
        #trans_source=instance.get
        #for chapter in chapter_list:
        

    def cleanChapters(self, instance, chapters):
        ltool = getToolByName(instance, 'lemill_tool')
        cleaned_chapters=[]
        parsed_fields=['text','keywords','questions','answers']
        for chapter in chapters:
            new_chapter={}
            new_chapter=copy(chapter)
            for key, value in chapter.items():
                if key in parsed_fields:
                    new_chapter[key]=ltool.parse_text(value, start_with_p=False)
            cleaned_chapters.append(new_chapter) 
        return cleaned_chapters


    def updateCleanedChapters(self, instance, chapters):
        cleaned_chapters=self.cleanChapters(instance, chapters)
        setattr(instance, 'cleaned_%s' % self.getName(), cleaned_chapters)
        return cleaned_chapters
        

    def _updatePilot(self, old_values):
        """ in new dictionary based chapters it makes sense to use one chapter per slide, instead of three chapters 
        this method converts old chapter lists into new format """        
        new_scene=True
        updated_values=[]
        for cvalue, ctype in old_values:
            if new_scene:
                scene={'text':'', 'image_uid':'', 'audio_uid':'', 'keywords':[], 'questions':[], 'type':'pilot_scene'}
                new_scene=False
            if ctype=='audio_piece':
                scene['audio_uid']=cvalue
            elif ctype=='image_piece':
                scene['image_uid']=cvalue
            elif ctype=='pilot_keywords':
                scene['keywords']=cvalue
                updated_values.append(scene)
                new_scene=True
            elif ctype=='pilot_questions':
                scene['questions']=cvalue
                updated_values.append(scene)
                new_scene=True
        return updated_values            
        
    def fixBrokenChoice(self, old_values):
        new_values=[]
        for vald in old_values:
            if vald['type']=='choice' and isinstance(vald['text'], list):
                 # [text, [correct_answers], [wrong_answers]]
                 print vald
                 text_list=vald['text']
                 vald['text']=text_list[0]
                 correct_choices=text_list[1]
                 if not isinstance(correct_choices, list):
                    correct_choices=[correct_choices]
                 wrong_choices=text_list[2]
                 if not isinstance(wrong_choices, list):
                    wrong_choices=[wrong_choices]
                 choices=[]
                 for item in correct_choices:
                    choices.append((item, 1))
                 for item in wrong_choices:
                    choices.append((item, 0))                                
                 vald['choices']=choices
                 vald['type']='multiple_choices'
            new_values.append(vald)
        return new_values


    def updateChapterList(self, old_values):
        """ Backward compatibility: 
            Converts a chapterlist to use dicts instead of tuples. Returns updated list """
        updated_values=[]
        if 'pilot_keywords' in [ct for cv, ct in old_values]: # Pilots need little more work
            return self._updatePilot(old_values)
        for cvalue, ctype in old_values:
            if ctype in ['multiple_choices','poll','choices', 'choice']:
                q,correct,wrong=cvalue
                if ctype=='multiple_choices':
                    choices=[(c, 1) for c in correct]
                    choices+=[(w, 0) for w in wrong]
                    shuffle(choices)
                elif ctype=='choices' or ctype=='choice':
                    if correct and isinstance(correct, list):
                        correct=correct[0]
                    choices=[(correct,1)]
                    choices+=[(w, 0) for w in wrong]
                    shuffle(choices)
                    ctype='multiple_choices'
                elif ctype=='poll':
                    choices=[(c,1) for c in correct+wrong]
                    ctype='multiple_choices'
                new_chapter={'text':q, 'type':ctype, 'choices':choices, 'max_points':1.0}
            elif ctype in ['fill_in_the_blanks', 'open_ended']:
                new_chapter={'text':cvalue, 'type':ctype, 'max_points':1.0}
            elif ctype in ['image_piece','audio_piece','media_piece']:
                new_chapter={'text':'', 'type':ctype, 'uid':cvalue}
            elif ctype=='embed_block':
                new_chapter={'text':'', 'type':'embed_block', 'embed':cvalue}
            elif ctype=='guidelines':
                new_chapter={'text':cvalue, 'type':'text_block'}
            else:
                new_chapter={'text':cvalue, 'type':ctype}
            changed=True
            updated_values.append(new_chapter)
        return updated_values

    def set(self, instance, value, **kwargs):
        if not value:
            return
        lt = getToolByName(instance, 'lemill_tool')
        changed=False
        if kwargs.get('_initializing_', False):
            old_values=self.getDefault(instance)
            changed=True
        else:
            old_values=self.getRaw(instance, **kwargs)
        references_to_add=[]
        references_to_remove=[]        
        ### The normal case: widget gives a dictionary ###    
        if isinstance(value, dict):  
            edited=value['edited']
            new_values=copy(old_values)

            if edited!=-1: # one chapter has been edited
                ctype=value['chapter_type']
                old_chapter=old_values[edited]            
                # build _one_ chapter based on input
                new_chapter={'type':ctype}
                if ctype in ['multiple_choices','choices','poll']:
                    new_chapter['text']=value['question']
                    choices=[]
                    for answer in value['answers']:
                        choices.append((answer['order'], answer['text'], answer['is_correct']))
                    choices.sort()
                    choices=[(y,z) for (x,y,z) in choices]
                    new_chapter['choices']=choices
                    new_chapter['max_points']=value.get('max_points',1.0)
                elif ctype=='pilot_scene':
                    new_chapter['text']=u'\n'.join(value['keywords'] or value['questions'])
                    if value['audio_file']:
                        new_piece = lt.createPieceFromFile(value['audio_file'], instance)
                        uid=new_piece.UID()
                    else:
                        uid=value['audio_uid']
                    old_uid=old_chapter.get('audio_uid','')
                    if old_uid:
                        if old_uid!=uid:
                            references_to_remove.append(old_uid)
                            references_to_add.append(uid)
                    else:
                        references_to_add.append(uid)
                    new_chapter['audio_uid']=uid                
                    if value['image_file']:
                        new_piece = lt.createPieceFromFile(value['image_file'], instance)
                        uid=new_piece.UID()
                    else:
                        uid=value['image_uid']
                    old_uid=old_chapter.get('image_uid','')
                    if old_uid:
                        if old_uid!=uid:
                            references_to_remove.append(old_uid)
                            references_to_add.append(uid)
                    else:
                        references_to_add.append(uid)
                    new_chapter['image_uid']=uid
                    new_chapter['questions']=value['questions']
                    new_chapter['keywords']=value['keywords']
                elif ctype in ['image_piece','audio_piece','media_piece']:
                    #new_chapter['text']=''
                    uid=value['uid']
                    old_uid=old_chapter.get('uid','')
                    if old_uid:
                        if old_uid!=uid:
                            references_to_remove.append(old_uid)
                            if uid:
                                references_to_add.append(uid)
                    elif uid:
                        references_to_add.append(uid)
                    new_chapter['uid']=uid
                    new_chapter['text']=value.get('caption','')
                elif ctype == 'embed_block':
                    new_chapter['text']=''
                    if 'embed_old' in value and value['embed_old'] and not value['embed']:
                        new_chapter['embed']=value['embed_old']
                    else:
                        new_chapter['embed']=value['embed']
                elif ctype in ['fill_in_the_blanks', 'open_ended']:
                    new_chapter['text']=value['text']
                    new_chapter['max_points']=value.get('max_points',1.0)
                else:            
                    new_chapter['text']=value['text']
                if new_chapter!=old_chapter:
                    changed=True
                new_values[edited]=new_chapter
            ## Deleting ##
            delete=value.has_key('delete_chapter')
            n_o=value.get('new_order',[])
            if delete:
                del_i=value['delete_chapter']
                if del_i<len(new_values):
                    removed=new_values.pop(del_i)
                    if removed.get('uid',''):
                        references_to_remove.append(removed['uid'])
                    changed=True
                if n_o and del_i in n_o:
                    n_o.pop(n_o.index(del_i))
                    changed=True
            ## Sorting ##
            if n_o:
                sortable=zip(n_o, new_values)
                sortable.sort()
                new_values=[val for o, val in sortable]
                changed=True                       
            ## Adding new chapters ##
            new_chapters=value.get('new_chapters',[])
            if new_chapters:
                new_values+=new_chapters
                changed=True
        ### The case where field's get-method feeds field's set-method (archetype update, copying) 
        elif isinstance(value, list):
            references_new=[]
            for chapter in value:
                uid=chapter.get('uid','')
                if uid:
                    references_new.append(uid)
            references_old=[]
            for chapter in old_values:
                uid=chapter.get('uid','')
                if uid:
                    references_old.append(uid)
            references_to_add=[uid for uid in references_new if uid not in references_old]
            references_to_remove=[uid for uid in references_old if uid not in references_new]
            if value!=old_values:
                changed=True
            new_values=value
        ### update references if necessary
        if references_to_add or references_to_remove:
            tool = instance.reference_catalog
            for uid in references_to_add:
                tool.addReference(instance, uid, self.relationship)
            for uid in references_to_remove:
                tool.deleteReference(instance, uid, self.relationship)
        if changed:
            # update cleaned text
            self.updateCleanedChapters(instance, new_values)        
            # set new value
            ObjectField.set(self, instance, new_values, **kwargs)

    def getObjectByUID(self, instance, uid, catalog_only=False):
        """ Helper method for fetching mediapieces from references """ 
        uid_catalog = getToolByName(instance, 'uid_catalog') 
        if not uid: 
            return None # this is just a newly created placeholder
        results=uid_catalog(UID=uid)
        try:
            return results[0].getObject()
        except IndexError:
            return None


    def isOEmbedChapter(self, chapter):
        """ Check if this chapter should use oembed query or just paste embed code """
        if not ('type' in chapter and chapter['type']=='embed_block'):
            return False
        code=chapter['embed']
        try:
            parsetuple=urlparse(code)
            return parsetuple[0]=='http' or parsetuple[0]=='https'
        except TypeError:
            return False
        return False

    def isGoogleDocs(self, chapter):
        """ OEmbed doesn't recognize google docs, but we can fill them in manually """
        def _getParam(query, key):
            query_list=query.split('&')
            for pair in query_list:
                k,v = pair.split('=')
                if k==key:
                    return v
            return ''
        code=chapter['embed']
        try:
            adscheme, network, path, params, query, frag = urlparse(code)
        except TypeError:
            return ''
        if network=='docs.google.com' or (network.startswith('docs') and network.endswith('.google.com')): 
            try:
                docid=''
                path_list=path.split('/')
                if 'present' in path_list: # https://docs.google.com/present/view?id=d-----------n
                    docid=_getParam(query,'id')                    
                    if docid:
                        return '<iframe src="https://docs.google.com/present/embed?id=%s" frameborder="0" width="700" height="559"></iframe>' % docid                   
                elif 'drawings' in path_list: # https://docs.google.com/drawings/pub?id=12---------------------Z6U&w=960&h=720
                    docid=_getParam(query,'id')
                    try:
                        w=int(_getParam(query, 'w') or 960)
                        h=int(_getParam(query, 'h') or 720)
                    except ValueError:
                        w=960
                        h=720                                                                
                    if docid:                        
                        return '<img src="https://docs.google.com/drawings/pub?id=%s&amp;w=%s&amp;h=%s">' % (docid, w,h)                   
                elif 'Doc' in path_list: # https://docs.google.com/Doc?docid=0Acv---------------------mZA&hl=en
                    docid=_getParam(query,'docid')
                elif 'd' in path_list: # https://docs.google.com/document/d/1k----------------2ttA0AnSurA/edit?hl=en&authkey=CJ----D
                    docid=path_list[2]
                elif 'pub' in path_list: # https://docs.google.com/document/pub?id=1k---------------------------SurA
                    docid=_getParam(query,'id')                    
            except IndexError:
                return ''
            if docid:
                return '<iframe src="https://docs.google.com/document/pub?id=%s&amp;embedded=true" width="760" height="564"></iframe>' % docid
        elif network=='spreadsheets.google.com' or (network.startswith('spreadsheets') and network.endswith('.google.com')):
            path_list=path.split('/')
            if 'viewform' in path_list:
                docid=_getParam(query, 'formkey')     
                return '<iframe src="https://spreadsheets.google.com/embeddedform?formkey=%s" width="760" height="564" frameborder="0" marginheight="0" marginwidth="0">Loading...</iframe>' % docid
            elif 'gform' in path_list:
                docid=_getParam(query, 'key')     
                return '<iframe src="https://spreadsheets.google.com/embeddedform?formkey=%s" width="760" height="564" frameborder="0" marginheight="0" marginwidth="0">Loading...</iframe>' % docid                
            else:
                docid=_getParam(query, 'key')     
                return "<iframe width='760' height='564' frameborder='0' src='https://spreadsheets.google.com/pub?key=%s&amp;output=html&amp;widget=true'></iframe>" % docid
        return ''

    def getLength(self, piece):
        as_time=piece.getLength()
        return {'hour':as_time/3600,'minute':(as_time % 3600)/60,'second':as_time % 60}           

    def hasOneCorrectChoice(self, chapter):
        """ Check if this exercise is multiple choice (-> use checkboxes) or has only one correct answer (-> use radio buttons) """
        corrects=0
        for q,c in chapter['choices']:
            if c:
                corrects+=1
        return corrects==1
                


registerField(ChapterField,
    title='Chapter field',
    description=('Chapter field'),
)

class AudioField(FileField):
    """ field for mp3:s """
    _properties = FileField._properties.copy()
    _properties.update({
        'widget' : AudioWidget,
    })

    def getLength(self, instance):
        i = aq_base(instance)
        file = AudioField.get(self,instance)
        if not shasattr(i, '_mp3length'):
            instance._mp3length=get_length(str(file))
        if instance._mp3length==0:
            instance._mp3length=get_length(str(file))
        return {'hour':instance._mp3length/3600,'minute':(instance._mp3length % 3600)/60,'second':instance._mp3length % 60}

    def set(self, instance, value, **kwargs):
        """ allow only audio here """
        FileField.set(self, instance, value, **kwargs)
        file=self.get(instance)
        if self.getContentType(instance).startswith('audio/'):
            instance._mp3length=get_length(str(file))
        elif str(file)!='':
            FileField.set(self, instance, "DELETE_FILE", **kwargs)

registerField(AudioField,
    title='Audio field',
    description=('Field that accepts only mp3:s'),
)

class LeMillLinksField(ObjectField):
    """ A field that stores LeMill internal links """
    __implements__ = ObjectField.__implements__
    _properties = ObjectField._properties.copy()
    _properties.update({
        'widget' : LeMillLinksWidget,
    })

    security = ClassSecurityInfo()

    def set(self, instance, value, **kwargs):
        ObjectField.set(self, instance, value, **kwargs)

    def getRaw(self, instance, **kwargs):
        version = None
        try:
            version = instance.REQUEST.get('version', None)
        except AttributeError:
            pass
        if version:
            value = instance.getFieldHistory(self.getName(), version)
        else:
            value = ObjectField.get(self, instance, **kwargs)
        if value and callable(value):
            value=value()
        return value

    def getRawEdit(self, instance, **kwargs):
        """ Returns a text for editing """
        pc = getToolByName(instance, 'portal_catalog')
        field_data = ObjectField.get(self, instance, **kwargs)#XXX See if any version control is needed here
        if field_data == None:
            return ""
        # find uids and links - replace them with urls
        links = re.findall('\{.*?\}', field_data)
        for link in links:
            linktext = link[1:-1]
            if linktext.lower().startswith('http://') or linktext.lower().startswith('https://'):
                field_data = field_data.replace(link, linktext)
            elif linktext.lower().startswith('uid:'):
                uid = linktext[4:]
                results = pc({'UID':uid})
                if len(results)>0:
                    field_data = field_data.replace(link, results[0].getURL())
                else:
                    field_data = field_data.replace(link, '')
        return field_data

    def get(self, instance, **kwargs):
        pc = getToolByName(instance, 'portal_catalog')
        letool = getToolByName(instance,'lemill_tool')
        version = None
        try:
            version = instance.REQUEST.get('version',None)
        except AttributeError:
            pass
        if version:
            field_data = instance.getFieldHistory(self.getName(), version)
        else:
            field_data = ObjectField.get(self, instance, **kwargs)
        if not field_data:
            return ""
        if callable(field_data):
            field_data=field_data()
        links = re.findall('\{.*?\}', field_data)
        for link in links:
            linktext = link[1:-1]
            if linktext.lower().startswith('http://') or linktext.lower().startswith('https://'):
                repl='<a href="%s">%s</a>' % (linktext, letool.shorten_url(linktext))
                field_data = field_data.replace(link, repl)
            elif linktext.lower().startswith('uid:'):
                uid = linktext[4:]
                results = pc({'UID':uid})
                repl=''
                if results:
                    repl='<a href="%s">%s</a>' % (results[0].getURL(), results[0].Title)
                field_data = field_data.replace(link, repl)
        field_data = field_data.strip()
        value = field_data.split('\n')
        return value

registerField(LeMillLinksField,
    title='LeMill Links Field',
    description=('LeMill Links Field'),
)