/// <summary>Searches for the most suitable index for the given character code.</summary>
        /// <param name="code">The charcode to look for.</param>
        /// <returns>The index in provider that charcode can be found in.</returns>
        public static int SearchFor(int code)
        {
            if (Providers == null)
            {
                // No providers anyway.
                return(-1);
            }

            int size = Providers.Count;

            // A straight search is faster than binary searching - it's only a small set.

            // For each provider..
            for (int i = 0; i < size; i++)
            {
                CharacterProvider provider = Providers[i];

                // Is the code within it's range?
                if (code >= provider.MinimumID && code <= provider.MaximumID)
                {
                    // Yes - right here.
                    return(i);
                }
            }

            // Not found.
            return(-1);
        }
Exemplo n.º 2
0
        /// <summary>Attempts to find and apply an image to the given character.</summary>
        /// <param name="character">The on screen character to attempt to find an image for.</param>
        public static void FindInto(Glyph loadInto, int charcode)
        {
            CharacterProvider provider = FindFor(charcode);

            if (provider == null)
            {
                return;
            }

            // The provider is likely able to supply us with the character.
            // If it does then we simply return it.

            // Load into the glyph now:
            provider.Load(loadInto, charcode);
        }
        /// <summary>Adds the given character provider to the set of Providers.</summary>
        /// <param name="provider">The provider to add.</param>
        public static void Add(CharacterProvider provider)
        {
            if (Providers == null)
            {
                Providers = new List <CharacterProvider>(1);
                Providers.Add(provider);
            }
            else
            {
                // Sorted set, so where should it go?

                // Insert at this index:
                int index = InsertIndex(provider);

                // Insert at the given index:
                Providers.Insert(index, provider);
            }
        }
        /// <summary>Attempts to find and apply an image to the given character.</summary>
        /// <param name="character">The on screen character to attempt to find an image for.</param>
        public static Glyph Find(int charcode)
        {
            CharacterProvider provider = FindFor(charcode);

            if (provider == null)
            {
                return(null);
            }

            // The provider is likely able to supply us with the character.
            // If it can't, we can just assume nobody else can.
            Glyph glyph = new Glyph();

            // Update the charcode:
            glyph.RawCharcode = charcode;

            // Load into the glyph now:
            provider.Load(glyph, charcode);

            return(glyph);
        }
        /// <summary>Finds the index where the given provider should be inserted at.</summary>
        /// <param name="provider">The provider to add.</param>
        /// <returns>The index to add it at.</returns>
        public static int InsertIndex(CharacterProvider provider)
        {
            // Ignore that it's a range and just essentially sort by minimum ID.
            // Go up the set of all providers (it's only tiny, so this will be faster than bin search)
            // When you hit a minimum that is bigger than the new minimum, then that's the spot it should go at.

            int newMinimum = provider.MinimumID;
            int size       = Providers.Count;

            for (int i = 0; i < size; i++)
            {
                // Is the new providers minimum bigger than the new minimum?
                if (Providers[i].MinimumID >= newMinimum)
                {
                    // Yes it is - it can go here.
                    return(i);
                }
            }

            // Must go at the end:
            return(size);
        }
        /// <summary>Attempts to find the character provider for a character of the given charcode.</summary>
        /// <param name="code">The charcode of the character to look for.</param>
        /// <returns>A provider for the character, if found.</returns>
        public static CharacterProvider FindFor(int code)
        {
            if (Providers == null)
            {
                return(null);
            }

            int index = SearchFor(code);

            if (index == -1)
            {
                return(null);
            }

            CharacterProvider provider = Providers[index];

            if (provider.MaximumID >= code)
            {
                return(provider);
            }

            return(null);
        }
Exemplo n.º 7
0
        /// <summary>Attempts to find and apply an image to the given character.</summary>
        /// <param name="character">The on screen character to attempt to find an image for.</param>
        public static Glyph Find(int charcode)
        {
            Glyph glyph;

            if (CachedCharacters != null && CachedCharacters.TryGetValue(charcode, out glyph))
            {
                return(glyph);
            }

            CharacterProvider provider = FindFor(charcode);

            if (provider == null)
            {
                return(null);
            }

            // The provider is likely able to supply us with the character.
            // If it can't, we can just assume nobody else can.
            glyph = new Glyph();

            // Update the charcode:
            glyph.RawCharcode = charcode;

            // Load into the glyph now:
            provider.Load(glyph, charcode);

            // Cache it next:
            if (CachedCharacters == null)
            {
                CachedCharacters = new Dictionary <int, Glyph>();
            }

            CachedCharacters[charcode] = glyph;

            return(glyph);
        }
//--------------------------------------