#------------------------------------------------------------------------------
#
#  Copyright (c) 2005, Enthought, Inc.
#  All rights reserved.
#
#  This software is provided without warranty under the terms of the BSD
#  license included in enthought/LICENSE.txt and may be redistributed only
#  under the conditions described in the aforementioned license.  The license
#  is also available online at http://www.enthought.com/licenses/BSD.txt
#
#  Thanks for using Enthought open source!
#
#  Author: David C. Morrill
#  Date:   12/22/2004
#
#------------------------------------------------------------------------------

""" Trait definition for a wxPython-based font.
"""

#-------------------------------------------------------------------------------
#  Imports:
#-------------------------------------------------------------------------------

import wx

from traits.api \
    import Trait, TraitHandler, TraitError

#-------------------------------------------------------------------------------
#  Convert a string into a valid 'wxFont' object (if possible):
#-------------------------------------------------------------------------------

# Mapping of strings to valid wxFont families
font_families = {
    'default':    wx.DEFAULT,
    'decorative': wx.DECORATIVE,
    'roman':      wx.ROMAN,
    'script':     wx.SCRIPT,
    'swiss':      wx.SWISS,
    'modern':     wx.MODERN
}

# Mapping of strings to wxFont styles
font_styles = {
    'slant':  wx.SLANT,
    'italic': wx.ITALIC
}

# Mapping of strings wxFont weights
font_weights = {
    'light': wx.LIGHT,
    'bold':  wx.BOLD
}

# Strings to ignore in text representations of fonts
font_noise = [ 'pt', 'point', 'family' ]

#-------------------------------------------------------------------------------
#  Converts a wx.Font into a string description of itself:
#-------------------------------------------------------------------------------

def font_to_str ( font ):
    """ Converts a wx.Font into a string description of itself.
    """
    weight = { wx.LIGHT:  ' Light',
               wx.BOLD:   ' Bold'   }.get( font.GetWeight(), '' )
    style  = { wx.SLANT:  ' Slant',
               wx.ITALIC: ' Italic' }.get( font.GetStyle(), '' )
    underline = ''
    if font.GetUnderlined():
        underline = ' underline'
    return '%s point %s%s%s%s' % (
           font.GetPointSize(), font.GetFaceName(), style, weight, underline )

#-------------------------------------------------------------------------------
#  Create a TraitFont object from a string description:
#-------------------------------------------------------------------------------

def create_traitsfont ( value ):
    """ Create a TraitFont object from a string description.
    """
    if isinstance( value, wx.Font ):
        value = font_to_str( value )

    point_size = None
    family     = wx.DEFAULT
    style      = wx.NORMAL
    weight     = wx.NORMAL
    underline  = 0
    facename   = []
    for word in value.split():
        lword = word.lower()
        if lword in font_families:
            family = font_families[ lword ]
        elif lword in font_styles:
            style = font_styles[ lword ]
        elif lword in font_weights:
            weight = font_weights[ lword ]
        elif lword == 'underline':
            underline = 1
        elif lword not in font_noise:
            if point_size is None:
                try:
                    point_size = int( lword )
                    continue
                except:
                    pass
            facename.append( word )
    return TraitsFont( point_size or 10, family, style, weight, underline,
                    ' '.join( facename ) )

#-------------------------------------------------------------------------------
#  'TraitsFont' class:
#-------------------------------------------------------------------------------

class TraitsFont ( wx.Font ):
    """ A Traits-specific wx.Font.
    """
    #---------------------------------------------------------------------------
    #  Returns the pickleable form of a TraitsFont object:
    #---------------------------------------------------------------------------

    def __reduce_ex__ ( self, protocol ):
        """ Returns the pickleable form of a TraitsFont object.
        """
        return ( create_traitsfont, ( font_to_str( self ), ) )

    #---------------------------------------------------------------------------
    #  Returns a printable form of the font:
    #---------------------------------------------------------------------------

    def __str__ ( self ):
        """ Returns a printable form of the font.
        """
        return font_to_str( self )

#-------------------------------------------------------------------------------
#  'TraitWXFont' class'
#-------------------------------------------------------------------------------

class TraitWXFont ( TraitHandler ):
    """ Ensures that values assigned to a trait attribute are valid font
    descriptor strings; the value actually assigned is the corresponding
    TraitsFont.
    """
    #---------------------------------------------------------------------------
    #  Validates that the value is a valid font:
    #---------------------------------------------------------------------------

    def validate ( self, object, name, value ):
        """ Validates that the value is a valid font descriptor string. If so,
        it returns the corresponding TraitsFont; otherwise, it raises a
        TraitError.
        """
        if value is None:
            return None

        try:
            return create_traitsfont( value )
        except:
            pass

        raise TraitError(object, name, 'a font descriptor string',
                         repr(value))

    def info ( self ):
        return ( "a string describing a font (e.g. '12 pt bold italic "
                 "swiss family Arial' or 'default 12')" )

#-------------------------------------------------------------------------------
#  Define a wxPython specific font trait:
#-------------------------------------------------------------------------------

### Note: Declare the editor to be a function which returns the FontEditor
# class from traits ui to avoid circular import issues. For backwards
# compatibility with previous Traits versions, the 'editors' folder in Traits
# project declares 'from api import *' in its __init__.py. The 'api' in turn
# can contain classes that have a Font trait which lead to this file getting
# imported. This leads to a circular import when declaring a Font trait.
def get_font_editor(*args, **traits):
    from .font_editor import ToolkitEditorFactory
    return ToolkitEditorFactory(*args, **traits)

fh     = TraitWXFont()
WxFont = Trait( wx.SystemSettings_GetFont( wx.SYS_DEFAULT_GUI_FONT ), fh, editor = get_font_editor )
