October 12, 2008 02:10pm pdt

1. jaime_oliv... 579,834
2. TheLearn... 369,380
3. Fernando... 254,459
4. jandromeda 242,713
5. JimBrandley 210,643
6. p_davis 202,029
7. angelIII 181,503
8. Dhaest 167,112
9. anarki_ji... 161,837
10. burakiewicz 155,613
11. naspinski 131,011
12. ShazbotOK 121,260
13. philipjonat... 121,174
14. ZachSmith 118,878
15. CyrexCor... 111,630
16. ragi0017 107,796
17. jcoehoorn 96,635
18. REA_AN... 90,770
19. junges 87,600
20. josgood 87,008
21. GreenGho... 83,410
22. emoreau 82,186
23. raterus 81,965
24. gauthampj 81,948
25. elimesika 81,500

1. TheLearn... 2,271,112
2. gregoryyo... 1,397,367
3. jaime_oliv... 1,078,620
4. AlexFM 994,109
5. Fernando... 718,366
6. dstanley9 713,657
7. TheAvenger 653,871
8. Idle_Mind 637,602
9. gauthampj 630,915
10. JimBrandley 592,414
11. angelIII 528,646
12. Zephyr__ 442,269
13. emoreau 363,918
14. REA_AN... 363,019
15. surajguptha 359,057
16. Desp 351,128
17. anarki_ji... 336,350
18. carl_tawn 329,275
19. sumix 327,243
20. _TAD_ 318,360
21. dungla 297,764
22. mnasman 292,791
23. testn 290,465
24. Dhaest 281,769
25. Yurich 279,264

02.19.2008 at 01:33PM PST, ID: 23175771

	[x] Attachment Details

[x]

The Solution Rating System

With so many solutions, how can you tell which solutions are most likely to help you and which ones are not? To provide you with a tool to use, we rate our solutions based on various elements that most accurately determine if a solution is a quality solution. To explain what factors affect the solution rating, here are the elements we take into consideration when formulating our solution rating.

The Grade of the Solution
The Zone Rank of the Expert Providing the Solution
The Number of Author and Expert Comments
The Number of Experts Contributing
The Feedback of the Community

Your Input Matters
Because of the way the system is set up, the most important variable in this equation is you. As a member of Experts Exchange, you are able to cast your vote on the quality of the solutions in regard to how complete, accurate, helpful and easy to understand each solution is. When you provide your feedback, each rating is adjusted accordingly. So, if you see a solution that has a poor rating that you think is a good solution, let us know by rating it. As you do, the rating will be adjusted and will become more accurate for other members of our site.

If you have any suggestions that you would like to make for our rating system, please ask a question in the Suggestions Zone of Community Support.

Thank you!

8.2

C# how to create enum of system fonts at compile time?

Asked by sapbucket in C# Programming Language, .NET

Ok, ok so the title grabbed your attention. You must be thinking, "What?! Another programmer trying to create an enum at runtime??" But trust me, I do have a good example of why someone might want to do this. Tough to believe? Maybe so!

Here is something that would be great to have: an Enum of Fonts installed on the system. But how come this doesn't exist in the .Net library already? Well, because each system has a different set of installed fonts, maybe even weird custom ones nobody has heard about. This means the fonts are dynamic (different from system to system). And we all know enums are static (meaning they should be system independent, and fixed at code writing time). So I agree, this is not ideal: I am asking to fit a square peg in a round hole.

None-the-less I built a custom ListBox user control for a client and now my client is complaining that it is too hard for them to instance a font type. I tried leaving a /// <summary> comment so the intellisense would help them:

/// <summary>
/// To instance a font you need FontFamily and size parameters. To obtain font familes enumerate (use a foreach) over InstalledFontCollection families = new InstalledFontCollection(). Size is simply an int (12 is "12 point font").
/// </summary>

My client couldn't make head-or-tails of this. "What is InstalledFontCollection?" they ask. "Enum-a-whatty?" they ask. You mean I have to KNOW the name of the font?? they complain.

Sometimes you can't teach an old dog new tricks, or get a middle-aged dog to shut-up. (I made up that last expression).

Ah but I digress. Ill get back on track: attached is the code for the client class I created, called FormattedListBox. Notice that the Add() method requires a Font parameter. This is where my client balks: how do I know what the font name is?.

Anyone know how this can be done using an enum?

Without even thinking I wrote the following code:

public List<FontFamily> FontList
{
get
{
List<FontFamily> fontList = new List<FontFamily>();

InstalledFontCollection families = new InstalledFontCollection();

foreach (FontFamily family in families.Families)
fontList.Add(family);

return fontList;
}
}

But that doesnt help at all. Sure, it gives the fontList, which the user can then, say, print out and reference, but it doesnt help at all when they are writing their code. For that, they would need an enum.

Ideal would be:

enum Fonts {
      Tahoma,
      Calibri,
      Times New Roman,
      blah,
      blah,
      blah
}

Now, Ive read about something called pre-building that might be able to handle this. Im not so sure, Ive never seen an example.

Does anyone know a better way?

Much thanks,
sapbucket

Start Free Trial

         
           
             1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:

           
           
             using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Text;
using System.Windows.Forms;
 
namespace TH.CustomControls
{
    public partial class FormattedListBox : ListBox
    {
        public FormattedListBox()
        {
            InitializeComponent();
 
            base.DrawMode = DrawMode.OwnerDrawVariable;
            MeasureItem += onMeasureItem;
            DrawItem += onDrawItem;
        }
 
        /// <summary>
        /// To instance a font you need FontFamily and size parameters. To obtain font familes enumerate (use a foreach) over InstalledFontCollection families = new InstalledFontCollection(). Size is simply an int (12 is "12 point font").
        /// </summary>
        public void Add(object item, Font font, Color foreColor, Color backColor)
        {
            FormattedListBoxItemWrapper formattedItem = new FormattedListBoxItemWrapper(item);
            formattedItem.Font = font;
            formattedItem.BackColor = backColor;
            formattedItem.ForeColor = foreColor;
 
            Items.Add(formattedItem);
        }
 
        public void Add(object item)
        {
            FormattedListBoxItemWrapper formattedItem = new FormattedListBoxItemWrapper(item);
            formattedItem.Font = Font;
            formattedItem.BackColor = BackColor;
            formattedItem.ForeColor = ForeColor;
 
            Items.Add(formattedItem);
        }
 
        public List<FontFamily> FontList
        {
            get
            {
                List<FontFamily> fontList = new List<FontFamily>();
 
                InstalledFontCollection families = new InstalledFontCollection();
 
                foreach (FontFamily family in families.Families)
                    fontList.Add(family);
 
                
                return fontList;
            }
        }
 
        private void onDrawItem(object sender, DrawItemEventArgs e)
        {
            if (e.Index == 0)
                return;
 
            ListBox listBox = (ListBox) sender;
 
            FormattedListBoxItemWrapper item = listBox.Items[e.Index] as FormattedListBoxItemWrapper;
 
            if (item != null)
            {
                Font font = null;
                Color foreColor = Color.Empty;
                Color backColor = Color.Empty;
 
                font = item.Font;
                foreColor = item.ForeColor;
                backColor = item.BackColor;
 
                if (font == null)
                    font = listBox.Font;
 
                Brush brush;
                if (foreColor == Color.Empty)
                    brush = Brushes.Black;
                else
                    brush = new SolidBrush(item.ForeColor);
 
                if ((e.State & DrawItemState.Selected) == DrawItemState.Selected)
                    brush = Brushes.White;
 
                if (backColor == Color.Empty)
                    e.DrawBackground();
                else
                {
                    Brush backgroundBrush = new SolidBrush(item.BackColor);
                    e.Graphics.FillRectangle(backgroundBrush, e.Bounds);
                }
 
                string text = listBox.Items[e.Index].ToString();
                e.Graphics.DrawString(text, font, brush, e.Bounds.X, e.Bounds.Y);
            }
        }
 
        private void onMeasureItem(object sender, MeasureItemEventArgs e)
        {
            ListBox listBox = (ListBox) sender;
 
            if (e.Index != 0)
            {
                FormattedListBoxItemWrapper item = listBox.Items[e.Index] as FormattedListBoxItemWrapper;
 
                if (item == null || item.Font == null)
                    e.ItemHeight = 15;
                else
                {
                    Font font = item.Font;
                    e.ItemHeight = font.Height;
                }
            }
        }
 
        private class FormattedListBoxItemWrapper
        {
            private object _item;
            private Color _foreColor;
            private Color _backColor;
            private Font _font;
 
            public FormattedListBoxItemWrapper(object item)
            {
                Item = item;
            }
 
            public object Item
            {
                set { _item = value; }
            }
 
            public Color ForeColor
            {
                get { return _foreColor; }
                set { _foreColor = value; }
            }
 
            public Color BackColor
            {
                get { return _backColor; }
                set { _backColor = value; }
            }
 
            public Font Font
            {
                get { return _font; }
                set { _font = value; }
            }
 
            public override string ToString()
            {
                if (_item == null)
                    return string.Empty;
                else
                    return _item.ToString();
            }
        }
    }
}
           
         

Keywords: C# how to create enum of system fon…

	Title
1	Font properties in a userform
2	How to decrease font size
3	Font registration
4	need Helvetica fonts
5	What report font do you use?
6	Need help to identify this font :-)

Loading Advertisement...

20080716-EE-VQP-32 / EE_QW_2_20070628

C# how to create enum of system fonts at compile time?

Asked by sapbucket in C# Programming Language, .NET

About this solution