def register_content_model(model_class, model_fields, register_file):
    model_class.register_templates(*FEINCMS_TEMPLATES['default'])

    ModelRestructuredContent = model_class.create_content_type(RestructuredContent, class_name='RestructuredContent')
    model_class.create_content_type(ImageContent, class_name='ImageContent')
    if register_file: model_class.create_content_type(FileContent, class_name='FileContent')

    register_model(model_class, model_fields)

    class ModelRestructuredContentTranslationOptions(TranslationOptions):
        fields = 'text',

    translator.register(ModelRestructuredContent, ModelRestructuredContentTranslationOptions)

def register_content_model(model_class, model_fields, translate=False, register_text=True, register_html=False):
    model_class.register_regions(('main', _("Main content area")),)
    ModelRestructuredContent = model_class.create_content_type(RestructuredContent, class_name=model_class.__name__ + 'Text') if register_text else None
    ModelHtmlContent = model_class.create_content_type(HtmlContent, class_name=model_class.__name__ + 'Html') if register_html else None
    ModelImageContent = model_class.create_content_type(ImageContent, class_name=model_class.__name__ + 'Image')

    if translate:
        register_model(model_class, model_fields)

        ModelRestructuredContent.feincms_item_editor_inline = TranslatedFeinCMSInline
        ModelHtmlContent.feincms_item_editor_inline = TranslatedFeinCMSInline
        ModelImageContent.feincms_item_editor_inline = TranslatedFeinCMSInline

        if register_text:
            class ModelRestructuredContentTranslationOptions(TranslationOptions):
                fields = 'text',

            translator.register(ModelRestructuredContent, ModelRestructuredContentTranslationOptions)

        if register_html:
            class ModelHtmlContentTranslationOptions(TranslationOptions):
                fields = 'text',

            translator.register(ModelHtmlContent, ModelHtmlContentTranslationOptions)

        class ModelImageContentTranslationOptions(TranslationOptions):
            fields = 'caption',

        translator.register(ModelImageContent, ModelImageContentTranslationOptions)

from modeltranslation.translator import translator, TranslationOptions
from dashboard.models import Project as DashboardProject


#dashboard
class DashboardProjectTranslationOptions(TranslationOptions):
    fields = ('title',
              'description',
              )

translator.register(DashboardProject, DashboardProjectTranslationOptions)

from modeltranslation.translator import translator
from modeltranslation.translator import TranslationOptions


from .models import Block
from .models import SubBlock


class BlockTranslationOptions(TranslationOptions):
	fields = ['title', 'sub_title', 'text']

translator.register(Block, BlockTranslationOptions)


class SubBlockTranslationOptions(TranslationOptions):
	fields = ['title', 'sub_title', 'description']

translator.register(SubBlock, SubBlockTranslationOptions)

from modeltranslation.translator import translator, TranslationOptions
from .models import MediaLibrary, MediaFile
from mezzanine.core.translation import TranslatedRichText

class TranslatedMediaLibrary(TranslatedRichText):
    field = ()

class TranslatedMediaFile(TranslationOptions):
    fields = ('description',)

translator.register(MediaLibrary, TranslatedMediaLibrary)
translator.register(MediaFile, TranslatedMediaFile)

"""
Translation registration for django modeltranslation
"""

from modeltranslation.translator import translator, TranslationOptions

from orb.toolkits import models


class ToolkitTranslation(TranslationOptions):
    fields = ('title', 'description')


translator.register(models.Toolkit, ToolkitTranslation)

# -*- coding: utf-8 -*-

from modeltranslation.translator import translator, TranslationOptions
from . import models


class ChunkOpts(TranslationOptions):
    fields = ('content', )


class ChunkGroupOpts(TranslationOptions):
    fields = ('content', )


class ChunkMediaOpts(TranslationOptions):
    fields = ('title', 'desc', 'media', )


translator.register(models.Media, ChunkMediaOpts)
translator.register(models.Group, ChunkGroupOpts)
translator.register(models.Chunk, ChunkOpts)

from modeltranslation.translator import translator, TranslationOptions
from seoutils.models import Meta

class MetaTranslationOptions(TranslationOptions):
    fields = ('title', 'keywords', 'desc')
translator.register(Meta, MetaTranslationOptions)

from modeltranslation.translator import translator, TranslationOptions
from homepage.models import Section

class SectionTranslationOptions(TranslationOptions):
    fields = ('name', 'description',)

translator.register(Section, SectionTranslationOptions)

from __future__ import unicode_literals

from django.utils.translation import ugettext as _
from django.utils.translation import get_language as _get_language
from modeltranslation.translator import translator, TranslationOptions
from modeltranslation import utils
from nsms.text.models import Text


class TextTranslationOptions(TranslationOptions):
    fields = ('text',)

translator.register(Text, TextTranslationOptions)

# need to translate something for django translations to kick in
_("Something to trigger localizations")


# monkey patch a version of get_language that isn't broken
def get_language():
    lang = _get_language()
    return lang

utils.get_language = get_language

from modeltranslation.translator import translator, TranslationOptions
from openbudget.apps.pages.models import Page


class PageTransOps(TranslationOptions):
    fields = ('title', 'content')


translator.register(Page, PageTransOps)

from modeltranslation.translator import translator, TranslationOptions
from contact_form.models import Subject


class SubjectTranslationOptions(TranslationOptions):
    fields = ('title', 'description')
    fallback_languages = {'default': ('en',)}

translator.register(Subject, SubjectTranslationOptions)

# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
#
#########################################################################

from modeltranslation.translator import translator, TranslationOptions
from geonode.maps.models import Map, MapStory


class MapTranslationOptions(TranslationOptions):
    fields = (
        'title',
        'abstract',
        'purpose',
        'constraints_other',
        'supplemental_information',
        'data_quality_statement',
    )


translator.register(Map, MapTranslationOptions)
translator.register(MapStory)

from modeltranslation.translator import translator, TranslationOptions

from paintings.models import Gallery, Painting


class GalleryTranslationOptions(TranslationOptions):
	fields = ('title',)
	required_languages = ('ru', 'en',)


class PaintingTranslationOptions(TranslationOptions):
	fields = ('title',)
	required_languages = ('ru', 'en',)


translator.register(Gallery, GalleryTranslationOptions)
translator.register(Painting, PaintingTranslationOptions)

# coding: utf-8
from modeltranslation.translator import translator, TranslationOptions
from models import URLLink


class URLLinkTranslationOptions(TranslationOptions):
    fields = ('title', 'description',)

translator.register(URLLink, URLLinkTranslationOptions)

from modeltranslation.translator import translator, TranslationOptions
from page.models import *

class PageTranslationOptions(TranslationOptions):
	fields = ('content',)
	required_languages = ('en','zh-cn')

translator.register(Page,PageTranslationOptions)

from cartridge.shop.models import (Category, Product, ProductOption,
                                   ProductImage, ProductVariation)


class TranslatedProduct(TranslatedDisplayable, TranslatedRichText):
    fields = ()


class TranslatedProductImage(TranslationOptions):
    fields = ('description',)


class TranslatedProductOption(TranslationOptions):
    fields = ('name',)


class TranslatedProductVariation(TranslationOptions):
    fields = tuple(('option%s' % opt[0] for opt in
                    settings.SHOP_OPTION_TYPE_CHOICES))


class TranslatedCategory(TranslatedRichText):
    fields = ()

translator.register(Product, TranslatedProduct)
translator.register(ProductImage, TranslatedProductImage)
translator.register(ProductOption, TranslatedProductOption)
translator.register(ProductVariation, TranslatedProductVariation)
translator.register(Category, TranslatedCategory)

class TagTranslationOptions(TNMTranslationOptions):
    pass


class TechnologyTranslationOptions(TNMTranslationOptions):
    pass


class GroupTranslationOptions(TNMTranslationOptions):
    fields = ('description', 'short_name', )


class AreaMixinTranslationOptions(TNMTranslationOptions):
    fields = ('description', )


translator.register(TranslatableNameMixin, TNMTranslationOptions)
translator.register(Applicant, ApplicantTranslationOptions)
translator.register(ContactDetail, ContactDetailTranslationOptions)
translator.register(Description, DescriptionTranslationOptions)
translator.register(Project, ProjectTranslationOptions)
translator.register(ProjectImage, ProjectImageTranslationOptions)
translator.register(Attachment, AttachmentTranslationOptions)
translator.register(Tag, TagTranslationOptions)
translator.register(Technology, TagTranslationOptions)
translator.register(Group, GroupTranslationOptions)
translator.register(AreaOfInterest, AreaMixinTranslationOptions)
translator.register(AreaOfKnowledge, AreaMixinTranslationOptions)

from modeltranslation.translator import translator, TranslationOptions
from flatblocks.models import FlatBlock
from geonode.maps.models import Layer


class FlatBlockTO(TranslationOptions):
    fields = ('content',)


class LayerTO(TranslationOptions):
    fields = (
             'title',
             'edition',
             'abstract',
             'purpose',
             'constraints_other',
             'distribution_description',
             'data_quality_statement',
             'supplemental_information',
             )


translator.register(FlatBlock, FlatBlockTO)
#translator.register(Layer, LayerTO)

class ItemTO(TranslationOptions):
    fields = 'name', 'description'


class NewsTO(TranslationOptions):
    fields = 'title', 'text'


class CategoryTO(TranslationOptions):
    fields = 'name', 'description'


class GroupTO(TranslationOptions):
    fields = 'name', 'description'


class SiteDescriptionTO(TranslationOptions):
    fields = ['description']


registry = (
        (Item, ItemTO),
        (News, NewsTO),
        (Category, CategoryTO),
        (Group, GroupTO),
        (SiteDescription, SiteDescriptionTO),
        )

for model, to in registry:
    translator.register(model, to)