} //ToString
/// <summary>
/// Compares two Html Fonts for equality
/// Equality opertors not defined (Design Time issue with override of Equals)
/// </summary>
public static bool IsEqual(HtmlFontProperty font1, HtmlFontProperty font2)
{
// assume not equal
bool equals = false;
// perform the comparsion
if (HtmlFontProperty.IsNotNull(font1) && HtmlFontProperty.IsNotNull(font2))
{
if (font1.Name == font2.Name &&
font1.Size == font2.Size &&
font1.SizeInEms == font2.SizeInEms &&
font1.Bold == font2.Bold &&
font1.Italic == font2.Italic &&
font1.Underline == font2.Underline &&
font1.Strikeout == font2.Strikeout &&
font1.Subscript == font2.Subscript &&
font1.Superscript == font2.Superscript)
{
equals = true;
}
}
// return the calculated value
return(equals);
} //IsEquals
} //CanConvertFrom
/// <summary>
/// Performs the conversion from string to a HtmlFontProperty (only)
/// </summary>
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
if (value is string)
{
// define a new font property
string fontString = (string)value;
HtmlFontProperty font = new HtmlFontProperty(string.Empty);;
try
{
// parse the contents of the given string using a regex
string fontName = string.Empty;
string fontSize = string.Empty;
Regex expression = new Regex(FONT_PARSE_EXPRESSION, RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.ExplicitCapture);
Match match = expression.Match(fontString);
// see if a match was found
if (match.Success)
{
// extract the content type elements
fontName = match.Result(FONT_PARSE_NAME);
fontSize = match.Result(FONT_PARSE_SIZE);
// set the fontname
TextInfo text = Thread.CurrentThread.CurrentCulture.TextInfo;
font.Name = text.ToTitleCase(fontName);
// determine size from given string using Small if blank
if (fontSize == string.Empty)
{
fontSize = "Small";
}
font.Size = (HtmlFontSize)Enum.Parse(typeof(HtmlFontSize), fontSize, true);
}
}
catch (Exception)
{
// do nothing but ensure font is a null font
font.Name = string.Empty;
}
if (HtmlFontProperty.IsNull(font))
{
// error performing the string conversion so throw exception given possible format
string error = string.Format(@"Cannot convert '{0}' to Type HtmlFontProperty. Format: 'FontName, HtmlSize', Font Size values: {1}", fontString, string.Join(", ", Enum.GetNames(typeof(HtmlFontSize))));
throw new ArgumentException(error);
}
else
{
// return the font
return(font);
}
}
else
{
return(base.ConvertFrom(context, culture, value));
}
} //ConvertFrom
} //CanConvertTo
/// <summary>
/// Performs the conversion from HtmlFontProperty to a string (only)
/// </summary>
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
// ensure working with the intented type HtmlFontProperty
if (value is HtmlFontProperty)
{
HtmlFontProperty font = (HtmlFontProperty)value;
if (destinationType == typeof(string))
{
return(font.ToString());
}
if (destinationType == typeof(InstanceDescriptor))
{
// define array to hold the properties and values
Object[] properties = new Object[8];
Type[] types = new Type[8];
// Name property
properties[0] = font.Name;
types[0] = typeof(string);
// Size property
properties[1] = font.Size;
types[1] = typeof(HtmlFontSize);
// Bold property
properties[2] = font.Bold;
types[2] = typeof(bool);
// Italic property
properties[3] = font.Italic;
types[3] = typeof(bool);
// Underline property
properties[4] = font.Underline;
types[4] = typeof(bool);
// Strikeout property
properties[5] = font.Strikeout;
types[5] = typeof(bool);
// Subscript property
properties[6] = font.Subscript;
types[6] = typeof(bool);
// Superscript property
properties[7] = font.Superscript;
types[7] = typeof(bool);
// create the instance constructor to return
ConstructorInfo ci = typeof(HtmlFontProperty).GetConstructor(types);
return(new InstanceDescriptor(ci, properties));
}
}
// have something other than InstanceDescriptor or sting
return(base.ConvertTo(context, culture, value, destinationType));
} //ConvertTo
} //IsNull
/// <summary>
/// Based on a font name being null the font can be assumed to be null
/// Default constructor will give a null object
/// </summary>
public static bool IsNotNull(HtmlFontProperty font)
{
return(!HtmlFontProperty.IsNull(font));
} //IsNull
} //IsNotEqual
/// <summary>
/// Based on a font name being null the font can be assumed to be null
/// Default constructor will give a null object
/// </summary>
public static bool IsNull(HtmlFontProperty font)
{
return(font.Name == null || font.Name.Trim() == string.Empty);
} //IsNull
} //IsEquals
/// <summary>
/// Compares two Html Fonts for equality
/// Equality opertors not defined (Design Time issue with override of Equals)
/// </summary>
public static bool IsNotEqual(HtmlFontProperty font1, HtmlFontProperty font2)
{
return(!HtmlFontProperty.IsEqual(font1, font2));
} //IsNotEqual
/// <summary>
/// Private control constructor defining all default values
/// </summary>
public HtmlEditorControl()
{
// This call is required by the Windows.Forms Form Designer.
InitializeComponent();
// define the default values
// browser constants and commands
EMPTY_PARAMETER = System.Reflection.Missing.Value;
// default values used to reset values
_defaultBodyBackColor = Color.White;
_defaultBodyForeColor = Color.Black;
_defaultBackColor = SystemColors.ControlLight;
_defaultFont = new HtmlFontProperty(this.Font);
// define the default values of the properties
_readOnly = false;
_toolbarVisible = true;
_toolbarDock = DockStyle.Bottom;
_bodyText = DEFAULT_HTML_TEXT;
_bodyHtml = DEFAULT_HTML_TEXT;
_bodyBackColor = _defaultBodyBackColor;
_bodyForeColor = _defaultBodyForeColor;
_bodyFont = _defaultFont;
_scrollBars = DisplayScrollBarOption.Auto;
_imageDirectory = string.Empty;
_htmlDirectory = string.Empty;
_navigateWindow = NavigateActionOption.Default;
_baseHref = string.Empty;
_autoWordWrap = true;
_borderSize = DEFAULT_BORDER_SIZE;
stylesheet = null;
script = null;
// define context menu state and size
this.BackColor = _defaultBackColor;
this.contextDocumentToolbar.Checked = true;
this.contextDocumentScrollbar.Checked = true;
this.contextDocumentWordwrap.Checked = true;
SetBrowserPanelSize();
// load the blank Html page to load the MsHtml object model
BrowserCodeNavigate(BLANK_HTML_PAGE);
// after load ensure document marked as editable
this.ReadOnly = _readOnly;
this.ScrollBars = _scrollBars;
}
/// <summary>
/// Method using the exec command that defines the font properties for the selected text
/// </summary>
public void FormatFontAttributes(HtmlFontProperty font)
{
// obtain the selected range object
mshtmlTextRange range = GetTextRange();
if (range != null && HtmlFontProperty.IsNotNull(font))
{
// Use the FONT object to set the properties
// FontName, FontSize, Bold, Italic, Underline, Strikeout
ExecuteCommandRange(range, HTML_COMMAND_FONT_NAME, font.Name);
// set the font size provide set to a value
if (font.Size != HtmlFontSize.Default) ExecuteCommandRange(range, HTML_COMMAND_FONT_SIZE, (int)font.Size);
// determine the BOLD property and correct as neccessary
object currentBold = QueryCommandRange(range, HTML_COMMAND_BOLD);
bool fontBold = (currentBold is System.Boolean)? fontBold = (bool)currentBold : false;
if (font.Bold != fontBold) ExecuteCommandRange(HTML_COMMAND_BOLD, null);
// determine the UNDERLINE property and correct as neccessary
object currentUnderline = QueryCommandRange(range, HTML_COMMAND_UNDERLINE);
bool fontUnderline = (currentUnderline is System.Boolean) ? fontUnderline = (bool)currentUnderline : false;
if (font.Underline != fontUnderline) ExecuteCommandRange(HTML_COMMAND_UNDERLINE, null);
// determine the ITALIC property and correct as neccessary
object currentItalic = QueryCommandRange(range, HTML_COMMAND_ITALIC);
bool fontItalic = (currentItalic is System.Boolean) ? fontItalic = (bool)currentItalic : false;
if (font.Italic != fontItalic) ExecuteCommandRange(HTML_COMMAND_ITALIC, null);
// determine the STRIKEOUT property and correct as neccessary
object currentStrikeout = QueryCommandRange(range, HTML_COMMAND_STRIKE_THROUGH);
bool fontStrikeout = (currentStrikeout is System.Boolean) ? fontStrikeout = (bool)currentStrikeout : false;
if (font.Strikeout != fontStrikeout) ExecuteCommandRange(HTML_COMMAND_STRIKE_THROUGH, null);
// determine the SUPERSCRIPT property and correct as neccessary
object currentSuperscript = QueryCommandRange(range, HTML_COMMAND_SUPERSCRIPT);
bool fontSuperscript = (currentSuperscript is System.Boolean) ? fontSuperscript = (bool)currentSuperscript : false;
if (font.Superscript != fontSuperscript) ExecuteCommandRange(HTML_COMMAND_SUPERSCRIPT, null);
// determine the SUBSCRIPT property and correct as neccessary
object currentSubscript = QueryCommandRange(range, HTML_COMMAND_SUBSCRIPT);
bool fontSubscript = (currentSubscript is System.Boolean) ? fontSubscript = (bool)currentSubscript : false;
if (font.Subscript != fontSubscript) ExecuteCommandRange(HTML_COMMAND_SUBSCRIPT, null);
}
else
{
// do not have text selected or a valid font class
throw new HtmlEditorException("Invalid Text selection made or Invalid Font selection.", "FormatFont");
}
}
/// <summary>
/// Defines all the body attributes once a document has been loaded
/// </summary>
private void DefineBodyAttributes()
{
// define the body colors based on the new body html
if (body.bgColor == null)
{
_bodyBackColor = _defaultBodyBackColor;
}
else
{
_bodyBackColor = ColorTranslator.FromHtml((string)body.bgColor);
}
if (body.text == null)
{
_bodyForeColor = _defaultBodyForeColor;
}
else
{
_bodyForeColor = ColorTranslator.FromHtml((string)body.text);
}
// define the font object based on current font of new document
// deafult used unless a style on the body modifies the value
mshtmlStyle bodyStyle = body.style;
if (bodyStyle != null)
{
string fontName = _bodyFont.Name;
HtmlFontSize fontSize = _bodyFont.Size;
bool fontBold = _bodyFont.Bold;
bool fontItalic = _bodyFont.Italic;
bool fontUnderline = _bodyFont.Underline;
// define the font name if defined in the style
if (bodyStyle.fontFamily != null) fontName = bodyStyle.fontFamily;
if (bodyStyle.fontSize != null) fontSize = HtmlFontConversion.StyleSizeToHtml(bodyStyle.fontSize.ToString());
if (bodyStyle.fontWeight != null) fontBold = HtmlFontConversion.IsStyleBold(bodyStyle.fontWeight);
if (bodyStyle.fontStyle != null) fontItalic = HtmlFontConversion.IsStyleItalic(bodyStyle.fontStyle);
fontUnderline = bodyStyle.textDecorationUnderline;
// define the new font object and set the property
_bodyFont = new HtmlFontProperty(fontName, fontSize, fontBold, fontItalic, fontUnderline);
this.BodyFont = _bodyFont;
}
// define the content based on the current value
this.ReadOnly = _readOnly;
this.ScrollBars = _scrollBars;
this.AutoWordWrap = _autoWordWrap;
}
} //CanConvertFrom
/// <summary>
/// Performs the conversion from string to a HtmlFontProperty (only)
/// </summary>
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
if (value is string)
{
// define a new font property
string fontString = (string)value;
HtmlFontProperty font = new HtmlFontProperty(string.Empty);;
try
{
// parse the contents of the given string using a regex
string fontName = string.Empty;
string fontSize = string.Empty;
Regex expression = new Regex(FONT_PARSE_EXPRESSION, RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.ExplicitCapture);
Match match = expression.Match(fontString);
// see if a match was found
if (match.Success)
{
// extract the content type elements
fontName = match.Result(FONT_PARSE_NAME);
fontSize = match.Result(FONT_PARSE_SIZE);
// set the fontname
TextInfo text = Thread.CurrentThread.CurrentCulture.TextInfo;
font.Name = text.ToTitleCase(fontName);
// determine size from given string using Small if blank
if (fontSize == string.Empty) fontSize = "Small";
font.Size = (HtmlFontSize)Enum.Parse(typeof(HtmlFontSize), fontSize, true);
}
}
catch (Exception)
{
// do nothing but ensure font is a null font
font.Name = string.Empty;
}
if (HtmlFontProperty.IsNull(font))
{
// error performing the string conversion so throw exception given possible format
string error = string.Format(@"Cannot convert '{0}' to Type HtmlFontProperty. Format: 'FontName, HtmlSize', Font Size values: {1}", fontString, string.Join(", ", Enum.GetNames(typeof(HtmlFontSize))));
throw new ArgumentException(error);
}
else
{
// return the font
return font;
}
}
else
{
return base.ConvertFrom(context, culture, value);
}
} //ConvertFrom
} //IsNull
/// <summary>
/// Based on a font name being null the font can be assumed to be null
/// Default constructor will give a null object
/// </summary>
public static bool IsNotNull(HtmlFontProperty font)
{
return (!HtmlFontProperty.IsNull(font));
} //IsNull
} //IsNotEqual
/// <summary>
/// Based on a font name being null the font can be assumed to be null
/// Default constructor will give a null object
/// </summary>
public static bool IsNull(HtmlFontProperty font)
{
return (font.Name == null || font.Name.Trim() == string.Empty);
} //IsNull
} //IsEquals
/// <summary>
/// Compares two Html Fonts for equality
/// Equality opertors not defined (Design Time issue with override of Equals)
/// </summary>
public static bool IsNotEqual(HtmlFontProperty font1, HtmlFontProperty font2)
{
return (!HtmlFontProperty.IsEqual(font1, font2));
} //IsNotEqual
} //ToString
/// <summary>
/// Compares two Html Fonts for equality
/// Equality opertors not defined (Design Time issue with override of Equals)
/// </summary>
public static bool IsEqual(HtmlFontProperty font1, HtmlFontProperty font2)
{
// assume not equal
bool equals = false;
// perform the comparsion
if (HtmlFontProperty.IsNotNull(font1) && HtmlFontProperty.IsNotNull(font2))
{
if (font1.Name == font2.Name &&
font1.Size == font2.Size &&
font1.Bold == font2.Bold &&
font1.Italic == font2.Italic &&
font1.Underline == font2.Underline &&
font1.Strikeout == font2.Strikeout &&
font1.Subscript == font2.Subscript &&
font1.Superscript == font2.Superscript)
{
equals = true;
}
}
// return the calculated value
return equals;
} //IsEquals