Xwork's Blog

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.Text.RegularExpressions;
using System.Threading;

namespace SyntaxHighlighter
{
	public partial class FrmMain : Form
	{
		private enum WordTypes : int
		{
			WType1 = 0,
			WType2,
			WType3,
			NType,
			OpType,
			SType,
			CType,
			OtherType
		}
		#region "Cargar Estilos por default"
		private Color FontColor1 = (Color)Properties.Settings.Default["ColorRW1"];
		private Color FontColor2 = (Color)Properties.Settings.Default["ColorRW2"];
		private Color FontColor3 = (Color)Properties.Settings.Default["ColorRW3"];
		private Color ColorComments = (Color)Properties.Settings.Default["ColorCom"];
		private Color ColorNum = (Color)Properties.Settings.Default["ColorNum"];
		private Color ColorStrings = (Color)Properties.Settings.Default["ColorStrings"];
		private Color ColorOperator = (Color)Properties.Settings.Default["ColorOp"];
		private Color GeneralColor = (Color)Properties.Settings.Default["GeneralFontColor"];
		private Font GeneralFont = (Font)Properties.Settings.Default["GeneralFont"];
		#endregion

	# region "Palabras reservadas"
		private string ReservedWords1 = @"\b(as|base|bool|break|byte|case|catch|char|checked|class|continue|decimal|default|delegate|do|double|else|enum|explicit|false|finally|fixed|float|for|foreach|goto|if|implicit|in|int|interface|is|lock|long|namespace|null|object|operator|out|params|ref|return|sbyte|short|sizeof|stackalloc|string|struct|switch|this|throw|true|try|typeof|uint|ulong|unchecked|ushort|using|var|void|while)\b";
		private string ReservedWords2 = @"\b(public|private|internal|protected|abstract|async|const|event|extern|new|override|partial|readonly|sealed|static|unsafe|virtual|volatile)\b";
		private string Comments = @"((\/\/.+)|(\/\*[\s\S]*?\*\/)|\b(\\\\)\b)";
		private string Numbers = @"((0[xX])(\d|[a-f|A-F])+)|(\b(\d+)\b)";
		private string Strings = "(\".*?\")";
		private string Operators = @"\[|\]|\(|\)|\.|\?|\b(and)\b|(\:\:)|\+|\-|\*|\/|\%|\&|\^|\!|\~|\=|\<|\>|\?\:|\++\|\-\-|\&\&|\<\<|\>\>|\=\=|\!\=|\<\=|\>\=|\+\=|\-\=|\*\=|\/\=|\%\=|\&\=|\=|\^\=|\<\<\=|\>\>\=|\-\>|\?\?|\=\>|";
	#endregion

	#region Delegados
		private delegate void UpadteRTBDelegate(int Start, int End, Color Colores);
		private delegate string GetTextDelegate();
	#endregion

		private void UpdateRTB(int Start, int End, Color Colores)
		{
			if (RTBMain.InvokeRequired)
				RTBMain.Invoke(new UpadteRTBDelegate(UpdateRTB), Start, End, Colores);
			else
			{
				RTBMain.SelectionStart = Start;
				RTBMain.SelectionLength = End;
				RTBMain.SelectionColor = Colores;
			}

		}

		private string GetText()
		{
			if (RTBMain.InvokeRequired)
				return (string)RTBMain.Invoke(new GetTextDelegate(GetText));
			else
				return RTBMain.Text;
		}

		private void DoTheWork()
		{
			Thread DoWork = new Thread(new ThreadStart(() => ColorizeAll()));
			DoWork.Start();
		}

		public FrmMain()
		{
			InitializeComponent();
		}

		private void ColorizeAll()
		{
			Colorize(ReservedWords1, WordTypes.WType1);
			Colorize(ReservedWords2, WordTypes.WType2);
			Colorize(Numbers, WordTypes.NType);
			Colorize(Operators, WordTypes.OpType);
			Colorize(Strings, WordTypes.SType);
			Colorize(Comments, WordTypes.CType);
		}

		private void SaveColor(WordTypes Tipo, Color Colores)
		{
			switch (Tipo)
			{
				case WordTypes.WType1:
					FontColor1 = Colores;
					Properties.Settings.Default["ColorRW1"] = Colores;
					Properties.Settings.Default.Save();
					break;
				case WordTypes.WType2:
					FontColor2 = Colores;
					Properties.Settings.Default["ColorRW2"] = Colores;
					Properties.Settings.Default.Save();
					break;
				case WordTypes.WType3:
					FontColor3 = Colores;
					Properties.Settings.Default["ColorRW3"] = Colores;
					Properties.Settings.Default.Save();
					break;
				case WordTypes.NType:
					ColorNum = Colores;
					Properties.Settings.Default["ColorNum"] = Colores;
					Properties.Settings.Default.Save();
					break;
				case WordTypes.OpType:
					ColorOperator = Colores;
					Properties.Settings.Default["ColorOp"] = Colores;
					Properties.Settings.Default.Save();
					break;
				case WordTypes.SType:
					ColorStrings = Colores;
					Properties.Settings.Default["ColorStrings"] = Colores;
					Properties.Settings.Default.Save();
					break;
				case WordTypes.CType:
					ColorComments = Colores;
					Properties.Settings.Default["ColorCom"] = Colores;
					Properties.Settings.Default.Save();
					break;
				case WordTypes.OtherType:
					GeneralColor = Colores;
					RTBMain.ForeColor = GeneralColor;
					Properties.Settings.Default["GeneralFontColor"] = Colores;
					Properties.Settings.Default.Save();
					break;
				default:
					break;
			}
		}

		private void Colorize(string Patron, WordTypes Tipo)
		{
			Color CurrentFontColor = GeneralColor;
			switch (Tipo)
			{
				case WordTypes.WType1:
					CurrentFontColor = FontColor1;
					break;
				case WordTypes.WType2:
					CurrentFontColor = FontColor2;
					break;
				case WordTypes.WType3:
					CurrentFontColor = FontColor3;
					break;
				case WordTypes.CType:
					CurrentFontColor = ColorComments;
					break;
				case WordTypes.NType:
					CurrentFontColor = ColorNum;
					break;
				case WordTypes.SType:
					CurrentFontColor = ColorStrings;
					break;
				case WordTypes.OpType:
					CurrentFontColor = ColorOperator;
					break;
				case WordTypes.OtherType:
					CurrentFontColor = GeneralColor;
					break;
			}
			//Si quitas el comentario siguiente y comentas la linea que sigue, puedes ver lo importante de la funcion GetText()
			//MatchCollection wordColl = Regex.Matches(RTBMain.Text, Patron);
			MatchCollection wordColl = Regex.Matches(GetText(), Patron);
			foreach (Match m in wordColl)
			{
				UpdateRTB(m.Index, m.Length, CurrentFontColor);
			}
		}

		private void TSBtnOpen_Click(object sender, EventArgs e)
		{
			OpenFileDialog OpDiag = new OpenFileDialog();
			OpDiag.Filter = "Código fuente C#|*.cs|Arvhivos de texto|*.txt|Todos los archivos|*.*";
			OpDiag.Multiselect = false;
			DialogResult DiagRes = OpDiag.ShowDialog();
			if (DiagRes == DialogResult.OK)
			{
				RTBMain.Clear();
				StreamReader SR = new StreamReader(OpDiag.FileName, Encoding.UTF8);
				RTBMain.AppendText(SR.ReadToEnd());
				DoTheWork();

			}
		}

		private void TSBtnSave_Click(object sender, EventArgs e)
		{
			SaveFileDialog SaveDiag = new SaveFileDialog();
			SaveDiag.Filter = "Texto enriquecido|*.rtf";
			if (SaveDiag.ShowDialog() == DialogResult.OK)
				RTBMain.SaveFile(SaveDiag.FileName);
		}

		private void TSBtnFont_Click(object sender, EventArgs e)
		{
			FontDialog FontDiag = new FontDialog();
			FontDiag.ShowApply = false;
			if (FontDiag.ShowDialog() == DialogResult.OK)
			{
				RTBMain.Font = FontDiag.Font;
				Properties.Settings.Default["GeneralFont"] = FontDiag.Font;
				Properties.Settings.Default.Save();
				DoTheWork();
			}
		}

		private void TSBtnColor_Click(object sender, EventArgs e)
		{
			ColorDialog ColorDiag = new ColorDialog();
			if (ColorDiag.ShowDialog() == DialogResult.OK)
			{
				SaveColor((WordTypes)TSLBWordTypes.SelectedIndex, ColorDiag.Color);
			}

		}

		private void FrmMain_Load(object sender, EventArgs e)
		{
			RTBMain.Font = GeneralFont;
			RTBMain.ForeColor = GeneralColor;
			TSLBWordTypes.SelectedIndex = 7;
		}

		private void TSBtnReDo_Click(object sender, EventArgs e)
		{
			DoTheWork();
		}

		private void TSLBWordTypes_TextChanged(object sender, EventArgs e)
		{

		}
	}
}

• "WType1" - y su valor es 0
• "WType2" - Su valor es 1
• "Wtype3" - Su valor es 2
• "NType" - Su valor es 3
• "OpType" - Su valor es 4
• "SType" - Su valor es 5
• "CType" - Su valor es 6
• "OtherType" - Su valor es 7

Aquí vemos la importancia de los delgados. Ya los veremos mas adelante ;)

Recuerden, anonimato ante todo!!.

• Palabras clave
• Tipo uno
• Tipo dos
• Tipo tres
• Números
• Operadores
• Cadenas de texto
• Comentarios

• as
• base
• bool
• break
• byte
• case
• catch
• char
• checked
• class
• continue
• decimal
• default
• delegate
• do
• double
• else
• enum
• explicit
• false
• finally
• fixed
• float
• for
• foreach
• goto
• if
• implicit
• in
• int
• interface
• is
• lock
• long
• namespace
• null
• object
• operator
• out
• params
• ref
• return
• sbyte
• short
• sizeof
• stackalloc
• string
• struct
• switch
• this
• throw
• true
• try
• typeof
• uint
• ulong
• unchecked
• ushort
• using
• var
• void
• while
• public
• private
• internal
• protected
• abstract
• async
• const
• event
• extern
• new
• override
• partial
• readonly
• sealed
• static
• unsafe
• virtual
• volatile

\b(as|base|bool)\b

(\b(\d+)\b)

(0[xX])(\d|[a-f|A-F])+)

(\/\/.+)

(\/\*[\s\S]*?\*\/))

(\".*?\")

• []
• ()
• .
• ?
• and
• ::
• +
• -
• *
• /
• %
• &
• ^
• !
• ~
• =
• <
• >
• ?:
• ++
• --
• &&
• <<
• >>
• ==
• !=
• <=
• >=
• +=
• -=
• *=
• /=
• %=
• &=
• =
• ^=
• <<=
• >>=
• ->
• ??
• =>

(\[|\]|\()

/*+----------------------------------------------------------+
| Lista de palabras reservadas                               |
+------------------------------------------------------------+
| as|base|bool|break|byte|case|catch|char|checked|class      |
+------------------------------------------------------------+
| continue|decimal|default|delegate|do|double|else|enum      |
+------------------------------------------------------------+
| explicit|false|finally|fixed|float|for|foreach|goto|if     |
+------------------------------------------------------------+
| implicit|in|int|interface|is|lock|long|namespace|null      |
+------------------------------------------------------------+
| object|operator|out|params|ref|return|sbyte|short|sizeof   |
+------------------------------------------------------------+
| stackalloc|string|struct|switch|this|throw|true|try|typeof |
+------------------------------------------------------------+
| uint|ulong|unchecked|ushort|using|var|void|while           |
+----------------------------------------------------------+*/
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.Text.RegularExpressions;

namespace SyntaxHighlighter
{
	public partial class FrmMain : Form
	{
		private string ReservedWords1 = @"\b(as|base|bool|break|byte|case|catch|char|checked|class|continue|decimal|default|delegate|do|double|else|enum|explicit|false|finally|fixed|float|for|foreach|goto|if|implicit|in|int|interface|is|lock|long|namespace|null|object|operator|out|params|ref|return|sbyte|short|sizeof|stackalloc|string|struct|switch|this|throw|true|try|typeof|uint|ulong|unchecked|ushort|using|var|void|while)\b";
		private string ReservedWords2 = @"\b(public|private|internal|protected|abstract|async|const|event|extern|new|override|partial|readonly|sealed|static|unsafe|virtual|volatile)\b";
		private string Comments = @"((\/\/.+)|(\/\*[\s\S]*?\*\/))";
		private string Numbers = @"((0[xX])(\d|[a-f|A-F])+)|(\b(\d+)\b)";
		private string Strings = "(\".*?\")";
		private string Operators = @"\[|\]|\(|\)|\.|\?|(and)|(\:\:)|\+|\-|\*|\/|\%|\&|\^|\!|\~|\=|\<|\>|\?\:|\++\|\-\-|\&\&|\<\<|\>\>|\=\=|\!\=|\<\=|\>\=|\+\=|\-\=|\*\=|\/\=|\%\=|\&\=|\=|\^\=|\<\<\=|\>\>\=|\-\>|\?\?|\=\>|";
		public FrmMain()
		{
			InitializeComponent();
		}

		private Color FontColor1 = (Color)Properties.Settings.Default["ColorRW1"];
		private Color FontColor2 = (Color)Properties.Settings.Default["ColorRW2"];
		//private Color FontColor3 = (Color)Properties.Settings.Default["ColorRW3"];
		private Color FontComments = (Color)Properties.Settings.Default["ColorCom"];
		private Color FontNum = (Color)Properties.Settings.Default["ColorNum"];
		private Color FontStrings = (Color)Properties.Settings.Default["ColorStrings"];
		private Color FontOperator = (Color)Properties.Settings.Default["ColorOp"];

		private enum WordTypes
		{
			WType1  = 0,
			WType2,
			WType3,
			CType,
			NType,
			SType,
			OpType,
			OtherType
		}

		private void ColorizeAll()
		{
			Colorize(ReservedWords1, WordTypes.WType1);
			Colorize(ReservedWords2, WordTypes.WType2);
			Colorize(Numbers, WordTypes.NType);
			Colorize(Operators, WordTypes.OpType);
			Colorize(Strings, WordTypes.SType);
			Colorize(Comments, WordTypes.CType);
		}

		private void Colorize(string Patron, WordTypes Tipo)
		{
			Color CurrentFontColor = Color.Black;
			switch (Tipo)
			{
				case WordTypes.WType1:
				CurrentFontColor = FontColor1;
				break;
				case WordTypes.WType2:
				 CurrentFontColor = FontColor2;
				break;
				case WordTypes.WType3:
				CurrentFontColor = Color.Black;
				break;
				case WordTypes.CType:
				CurrentFontColor = FontComments;
				break;
				case WordTypes.NType:
				CurrentFontColor = FontNum;
				break;
				case WordTypes.SType:
				CurrentFontColor = FontStrings;
				break;
				case WordTypes.OpType:
				CurrentFontColor = FontOperator;
				break;
				case WordTypes.OtherType:
				CurrentFontColor = Color.Black;
				 break;
			}

				MatchCollection wordColl = Regex.Matches(RTBMain.Text, Patron);
				foreach (Match m in wordColl)
				{
					RTBMain.SelectionStart = m.Index;
					RTBMain.SelectionLength = m.Length;
					RTBMain.SelectionColor = CurrentFontColor;
			}
		}

		private void TSBtnOpen_Click(object sender, EventArgs e)
		{
			OpenFileDialog OpDiag = new OpenFileDialog();
			OpDiag.Filter = "Código fuente C#|*.cs|Archivos de texto|*.txt|Todos los archivos|*.*";
			OpDiag.Multiselect = false;
			DialogResult DiagRes = OpDiag.ShowDialog();
			if (DiagRes == DialogResult.OK)
			{
				RTBMain.Clear();
				StreamReader SR = new StreamReader(OpDiag.FileName, Encoding.UTF8);
				RTBMain.AppendText(SR.ReadToEnd());
				ColorizeAll();
				
			}
		}

		private void TSBtnSave_Click(object sender, EventArgs e)
		{
			SaveFileDialog SaveDiag = new SaveFileDialog();
			SaveDiag.Filter = "Texto enriquecido|*.rtf";
			if (SaveDiag.ShowDialog() == DialogResult.OK)
			RTBMain.SaveFile(SaveDiag.FileName);
		}

		private void TSBtnFont_Click(object sender, EventArgs e)
		{
			FontDialog FontDiag = new FontDialog();
			FontDiag.ShowApply = false;
			if(FontDiag.ShowDialog() == DialogResult.OK)
				RTBMain.Font = FontDiag.Font;
		}

		private void TSBtnColor_Click(object sender, EventArgs e)
		{
			Form FrmOptions = new FrmAjustes();
			DialogResult DiagRes = FrmOptions.ShowDialog();
			if (DiagRes == DialogResult.OK)
			{
			}
		}
	}
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Windows.Forms;
using System.IO;

namespace WordsFinder
{
	public partial class FrmMain : Form
	{
		public FrmMain()
		{
			InitializeComponent();
		}
		
		private Color FontColor = (Color)Properties.Settings.Default["ColorFont"];
		private Color BackGroundColor = (Color)Properties.Settings.Default["ColorBack"];
		
		private void ResetRTB()
		{
			RTBText.SelectAll();
			RTBText.SelectionBackColor = Color.FromName("white");
			RTBText.SelectionColor = Color.FromName("black");
		}

		private void Buscar()
		{
			if(!LBHistory.Items.Contains(TXTRegEx.Text))
				LBHistory.Items.Add(TXTRegEx.Text);
			ResetRTB();
			MatchCollection wordColl = Regex.Matches(RTBText.Text, TXTRegEx.Text);
			foreach (Match m in wordColl)
			{
				RTBText.SelectionStart = m.Index;
				RTBText.SelectionLength = m.Length;
				RTBText.SelectionBackColor  = BackGroundColor;
				RTBText.SelectionColor = FontColor;
			}
			RTBText.ScrollToCaret();
			TSSlblFound.Text = "Se encontraron: " + wordColl.Count.ToString();
		}

		private void BtnSearch_Click(object sender, EventArgs e)
		{
			Buscar();
		}

		private void BtnReset_Click(object sender, EventArgs e)
		{
			ResetRTB();
		}

		private void TSBtnOpen_Click(object sender, EventArgs e)
		{
			OpenFileDialog OpDiag = new OpenFileDialog();
			OpDiag.Filter = "Archivos de texto|*.txt|Todos los archivos|*.*";
			OpDiag.Multiselect = false;
			DialogResult DiagRes = OpDiag.ShowDialog();
			if (DiagRes == DialogResult.OK)
			{
				RTBText.Clear();
				this.Text = "Word Finder - " + OpDiag.FileName;
				StreamReader SR = new StreamReader(OpDiag.FileName, Encoding.UTF8);
				RTBText.AppendText(SR.ReadToEnd());
			}
		}

		private void TSBtnColor_Click(object sender, EventArgs e)
		{
			Form FrmOptions = new FrmAjustes();
			DialogResult DiagRes = FrmOptions.ShowDialog();
			if (DiagRes == DialogResult.OK)
			{
				FontColor = (Color)Properties.Settings.Default["ColorFont"];
				BackGroundColor = (Color)Properties.Settings.Default["ColorBack"];
			}
		}

		private void LBHistory_SelectedIndexChanged(object sender, EventArgs e)
		{
			TXTRegEx.Text = LBHistory.Items[LBHistory.SelectedIndex].ToString();
		}

		private void TXTRegEx_KeyPress(object sender, KeyPressEventArgs e)
		{
			if (e.KeyChar == 13)
				Buscar();
		}
	}
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace WordsFinder
{
	public partial class FrmAjustes : Form
	{
		public FrmAjustes()
		{
			InitializeComponent();
		}

		private void BtnFontColor_Click(object sender, EventArgs e)
		{
			ColorDialog ColorDiag = new ColorDialog();
			DialogResult DiagRes = ColorDiag.ShowDialog();
			if (DiagRes == DialogResult.OK)
			{
				Properties.Settings.Default["ColorFont"] = ColorDiag.Color;
				lblMuestraBig.ForeColor = ColorDiag.Color;
				Properties.Settings.Default.Save();
			}
		}

		private void BtnAccept_Click(object sender, EventArgs e)
		{
			this.DialogResult = DialogResult.OK;
			this.Close();
		}

		private void BtnBackColor_Click(object sender, EventArgs e)
		{
			ColorDialog ColorDiag = new ColorDialog();
			DialogResult DiagRes = ColorDiag.ShowDialog();
			if (DiagRes == DialogResult.OK)
			{
				Properties.Settings.Default["ColorBack"] = ColorDiag.Color;
				lblMuestraBig.BackColor = ColorDiag.Color;
				Properties.Settings.Default.Save();

			}

		}

		private void BtnCancel_Click(object sender, EventArgs e)
		{
			this.DialogResult = DialogResult.Cancel;
			this.Close();
		}

		private void FrmAjustes_Load(object sender, EventArgs e)
		{
			lblMuestraBig.BackColor = (Color)Properties.Settings.Default["ColorBack"];
			lblMuestraBig.ForeColor = (Color)Properties.Settings.Default["ColorFont"];
		}
	}
}

• Aquí no promovemos la piratería.
• Somos respetuosos de las ideas, por lo general tratatremos de crear nuestro propio código/programa.
• Si usamos software de otros, en la medida de lo posible le daremos el crédito al autor.

Si venias por un número de registro estás en el lugar equivocado, ve al sitio de Microsoft, aun es posible registrar estas versiones.

Expresiones regulares

En cómputo teórico y teoría de lenguajes formales una expresión regular, también conocida como regex,​ es una secuencia de caracteres que forma un patrón de búsqueda, principalmente utilizada para la búsqueda de patrones de cadenas de caracteres u operaciones de sustituciones. Por ejemplo, el grupo formado por las cadenas Handel, Händel y Haendel se describe con el patrón "H(a|ä|ae)ndel". La mayoría de las formalizaciones proporcionan los siguientes constructores: una expresión regular es una forma de representar los lenguajes regulares (finitos o infinitos) y se construye utilizando caracteres del alfabeto sobre el cual se define el lenguaje. Wikipedia/expresionRegular.

• Clases de caracteres
• . - Cualquier carácter (menos el de nueva linea).
• \w\d\s - palabra, dígito, espacio en blanco.
• \W\D\S - NO palabra, NO dígito, No espacio en blanco.
• [abc] - cualquier letra dentro del corchete.
• [^abc] - Ninguna de las letras dentro del corchete.
• [a-g] - carácter entre "a" y "g".
• Anclas
• ^abc$ - inicio/ fin de la palabra.
• \b\B - final/NO final.
• Agrupación.
• (abc) - Agrupación.
• \1 - referencia hacia atrás.
• (?:abc) omitir grupo.
• (?=abc) busqueda hacia adelante.
• (?!abc) busqueda haci atras.
• Alternación
• a*a+a? - 0 o mas, 1 o mas, 0 o 1.
• a{5}a{2,} - Exactamente 5,2 o mas.
• a{1,3} - entre uno y tres.
• a+?a{2,}? - Buscar el menor posible.
• ab|cd - busca ab o cd.

Cambiando la localización.

console.log('loaded: localization.js');

var m = ['ENERO','FEBRERO','MARZO','ABRIL','MAYO','JUNIO','JULIO','AGOSTO','SEPTIEMBRE','OCTUBRE','NOVIEMBRE','DICIEMBRE'];
var d = ['DOMINGO','LUNES','MARTES','MIERCOLES','JUEVES','VIERNES','SABADO'];

console.log('loaded: gadget.js');

var font;
var color;
var opacity;
// var negativeVerticalMargin;
// var negativeHorizontalMargin;

var toTime;
var toDate;
var toMonth;
var toDay;

var targetWidth;
var targetHeight;

function init() {
	console.log('[init]');

	System.Gadget.settingsUI = 'settings.html';
	System.Gadget.onSettingsClosed = function() {
		readSettings();
		createTextObjects();
		refresh(false);
	};

	readSettings();
	createTextObjects();
	refresh(true);
}

function readSettings() {
	console.log('[readSettings]');

	font = System.Gadget.Settings.readString('font') || 'Arial';
	color = System.Gadget.Settings.readString('color') || 'white';
	opacity = System.Gadget.Settings.read('opacity') || 30;
	// negativeVerticalMargin = System.Gadget.Settings.read('negativeVerticalMargin') || 0;
	// negativeHorizontalMargin = System.Gadget.Settings.read('negativeHorizontalMargin') || 0;

	console.log('    font: '+font);
	console.log('    color: '+color);
	console.log('    opacity: '+opacity);
}

function createTextObjects() {
	console.log('[createTextObjects]');

	var bg = document.getElementById('bg');
	bg.removeObjects();

	// 0's are dummy chars for initial text object alignment
	toTime = bg.addTextObject('00:00:00', font, 105, color, 0, 0);
	toDate = bg.addTextObject('0', font, 80, color, toTime.left, 90); //(toTime.top+toTime.height)*0.69);
	toMonth = bg.addTextObject('0', font, 45, color, toDate.left+toDate.width, 95);
	toDay = bg.addTextObject('0', font, 30, color, toDate.left+toDate.width, 135);

	//we really don't want to be changing the width of the gadget because of clock time
	//because gadgets are anchored on the desktop by the left side, and the content is right-aligned

	targetWidth = document.getElementsByTagName('body')[0].style.width = toTime.width;
	targetHeight = document.getElementsByTagName('body')[0].style.height = toDay.top + toDay.height;
}

function refresh(autoreload) {
	console.log('[refresh]');

	console.log('    font: '+font);
	console.log('    color: '+color);
	console.log('    opacity: '+opacity);


	var currentTime = System.Time.getLocalTime(System.Time.currentTimeZone);
	var currentDate = new Date(Date.parse(currentTime));

	var hours = currentDate.getHours();

	var minutes = currentDate.getMinutes();
	minutes = ((minutes < 10) ? ':0' : ':') + minutes;
// Comentar las siguientes dos lineas para no mostrar los segundos
	var seconds = currentDate.getSeconds();
	seconds = ((seconds < 10) ? ':0' : ':') + seconds;
//Quitar los comentarios de la siguiente linea y comentar la siguiente para no mostar los segundos
	//toTime.value = hours + minutes + " HR";
	toTime.value = hours + minutes + seconds;
	toTime.font = font;
	toTime.color = color;
	toTime.opacity = opacity;

	toTime.left = targetWidth - toTime.width;
	toTime.top = 0;


	toDate.value = currentDate.getDate();
	toDate.font = font;
	toDate.color = color;
	toDate.opacity = opacity;

	toDate.left = toTime.left;
	toDate.top = 90; // - negativeVerticalMargin;


	toMonth.value = m[currentDate.getMonth()];
	toMonth.font = font;
	toMonth.color = color;
	toMonth.opacity = opacity;

	toMonth.left = toDate.left + toDate.width;
	// goofly little formula here to goose the month riiiigh up to but not touching the time, for most fonts
	toMonth.top = toDate.top + 4 + (toDate.top * 0.05) ; //95;


	toDay.value = d[currentDate.getDay()];
	toDay.font = font;
	toDay.color = color;
	toDay.opacity = opacity;

	toDay.left = toMonth.left;
	toDay.top = toMonth.top + 41; //135;


	console.log('    width: '+toTime.width+', height: '+toDay.top + toDay.height);
	console.log('    toTime: x='+toTime.left+', y='+toTime.top+', h='+toTime.height+', w='+toTime.width);
	

	if (autoreload) {
		//cuando mostramos los segundos hay que actualizar cada segundo, pero si queremos actualizar cada minutos, debemos hacerlo cada 60
		//en lugar de tener 1*1000, debemos cambiar a 60*1000
		setTimeout(function() { refresh(true); }, 1*1000);
	}
}

Que bien se ve. Quien te conoce #windows 10? pic.twitter.com/2HJxtrOvQS

— Hugo G (@Mpm88G) 31 de octubre de 2018

/*
Based on Jonathan Abbott's Flip Calendar gadget
http://vistagadgets.spaces.live.com/
*/

console.log('loaded: font-picker.js');

var fontPicker = {
	supportedFontTypes: ' (truetype) ',
	fontsToSkip: ':Bookshelf Symbol 7:'+':MS Outlook:'+':MS Reference Specialty:'+':MT Extra:'+':Symbol:'+':Webdings:'+':Wingdings:'+':Wingdings 2:'+':Wingdings 3:',

	fillYield: 50,	// Yield back to IE every X ms

	fontSizer: null,
	fonttypeIndex: 0,
	currentFont: System.Gadget.document.parentWindow.font,
	selectingFont: -1,

	init: function() {
		console.log('[init]');

		// System.Gadget.onSettingsClosing = this.settingsClosing;

		divFonttype.style.fontFamily = divFonttype.innerText = this.currentFont;
		divFonttype.style.fontSize = '16px';

		this.fontSizer = document.createElement('<g:background />').addTextObject(this.currentFont, this.currentFont, 16, 'black', 0, 0);

		//remove focus from the 1st checkbox
		document.body.focus();
		
		//read the fonts from the registry and build the table
		this.buildList(this.readFonts());

		// setFont(currentFont, 0);
		// console.log(tdFonts);
		// console.log(this.fonttypeIndex);
		tdFonts.rows(this.fonttypeIndex).className = 'menuItemSelected';
	},

	settingsClosing: function(event) {
		console.log('[settingsClosing]');
		
		if (event.closeAction == event.Action.commit) {
			System.Gadget.Settings.writeString('font', divFonttype.innerText);
		}
		// event.cancel = false;
	},

	readFonts: function() {
		console.log('[readFonts]');

		var HKLM = 2147483649 ;
		var rPath = 'SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts';
	

		// connect to the registry
		var oSwbem = new ActiveXObject('WbemScripting.SwbemLocator');
		var oSvc = oSwbem.ConnectServer(null, 'root\\default');
		var oReg = oSvc.Get('StdRegProv');

		// enumerate the values 
		var oMethod = oReg.Methods_.Item('EnumValues');
		var oInParam = oMethod.InParameters.SpawnInstance_();
		oInParam.hDefKey = HKLM;
		oInParam.sSubKeyName = rPath;
		var oOutParam = oReg.ExecMethod_(oMethod.Name, oInParam);

		// get the values into an array
		var sNames = oOutParam.sNames.toArray();

		// sort it
		sNames.sort();

		return sNames;
	},

	buildList: function(listItems) {
		console.log('[buildList]');

		// try{
			var counter = new Date();

			while (listItems.length > 0 && (new Date())-counter<this.fillYield) {
				// is the font one we can use
				var fontType = ' ' + listItems[0].substring(listItems[0].lastIndexOf('(')).toLowerCase() + ' ';
				var fontName = listItems[0].substring(0, listItems[0].length - fontType.length + 1);

				if(this.supportedFontTypes.indexOf(fontType) > -1 && this.fontsToSkip.indexOf(':' + fontName + ':') == -1) {
					//check the height, to see if it's a font we can use
					this.fontSizer.font = this.fontSizer.value = fontName;
					this.fontSizer.height = 0;

					if (this.fontSizer.height != 0) {
						// console.log('Using font: '+fontName);

						var tRow = tdFonts.insertRow(tdFonts.rows.length);
						tRow.className = 'menuItem';
						
						var tCell = tRow.insertCell(0);
						tCell.innerText = fontName;
						tCell.style.fontFamily = fontName;
						tCell.style.fontSize = divFonttype.style.fontSize;

						if (fontName == this.currentFont) {
							this.fonttypeIndex = tdFonts.rows.length - 1;
							// tRow.className = 'menuItemSelected';
						}

					} else {
						// console.log('Cant use font: '+fontName);
					}
				}
				listItems.shift();
			}

			if (listItems.length > 0) {
				var context = this;
				setTimeout(function() { context.buildList(listItems); }, 20);
			}
		// } catch(err) {
			// console.log('buildList: '+err.name+' - '+err.message);
		// }
	},

	showFontMenu: function(id, x, y) {
		console.log('[showFontMenu]');

		if (id == -1) {
			if (fontMenu.style.display != 'none') {
				id = this.selectingFont;
			} else {
				return;
			}
		}
			
		fontMenu.style.display = (fontMenu.style.display == 'none') ? 'inline' : 'none';

		if (fontMenu.style.display == 'none') {
			console.log('[showFontMenu] hidden');

			switch (this.selectingFont) {
				case 0:
					fontDropPNG.src = 'images/dropmenu.png';
					break;
			}
			this.selectingFont = -1;
		} else {
			console.log('[showFontMenu] displayed');

			fontMenu.style.top = y;
			fontMenu.style.left = x;
			this.selectingFont = id;
			
			// console.log(tdFonts.rows(fonttypeIndex).className);
			// console.log(id);

			switch (id) {
				case 0:
					fontMenu.scrollTop = tdFonts.rows(this.fonttypeIndex).offsetTop - 65;
					tdFonts.rows(this.fonttypeIndex).className = 'menuItemSelected';
					break;
			}

			// console.log(tdFonts.rows(fonttypeIndex).className);
		}
	},

	setFont: function(index, viaKey) {
		console.log('[setFont] '+index+', '+viaKey);

		var sFont = tdFonts.rows(index).cells(0).innerText;

		var selecting = (viaKey != null) ? viaKey : this.selectingFont;
		switch (selecting) {
			case 0:
				divFonttype.style.fontFamily = sFont;
				divFonttype.innerText = sFont;
				tdFonts.rows(this.fonttypeIndex).className = 'menuItem';
				this.fonttypeIndex = index;
				tdFonts.rows(this.fonttypeIndex).className = 'menuItemSelected';
				break;
		}

		// adjust the scrollbar if needed
		if (fontMenu.scrollTop > tdFonts.rows(index).offsetTop) {
			fontMenu.scrollTop = tdFonts.rows(index).offsetTop;
		}

		if (fontMenu.scrollTop < tdFonts.rows(index).offsetTop+tdFonts.rows(index).offsetHeight-150) {
			fontMenu.scrollTop = tdFonts.rows(index).offsetTop+tdFonts.rows(index).offsetHeight-150;
		}
	},

	setFontStyle: function(i) {
		console.log('[setFontStyle]');

		switch (i) {
			case 0:
				divFonttype.style.fontWeight = divFonttypeBold.checked ? 'bold' : '';
				divFonttype.style.fontStyle = divFonttypeItalic.checked ? 'italic' : '';
				break;
		}
	},

	keyPress: function(i) {
		console.log('[keyPress]');

		switch (event.keyCode)
		{
			case 40:	//down arrow
				if (i == 0) {
					if (this.fonttypeIndex < tdFonts.rows.length-1) {
						this.setFont(this.fonttypeIndex+1, i);
					}
				}
				break;
			case 38:	//up arrow
				if (i == 0) {
					if (this.fonttypeIndex > 0) {
						this.setFont(this.fonttypeIndex-1, i);
					}
				}
				break;
			case 36:	//home
				this.setFont(0, i);
				break;
			case 35:	//end
				this.setFont(tdFonts.rows.length - 1, i);
				break;
		}
	},

	mouseOver: function(mouseEntered, id) {
		// console.log('[mouseOver]');

		var selected = (this.selectingFont == 0) ? this.fonttypeIndex : 0;

		if (mouseEntered) {
			id.className = (id.rowIndex == selected) ? 'menuItemHoverSelected' : 'menuItemHover';
		} else {
			id.className = (id.rowIndex == selected) ? 'menuItemSelected' : 'menuItem';
		}
	}
}

• HKEY_CLASSES_ROOT = 2147483648 (0x80000000)
• HKEY_CURRENT_USER = 2147483649 (0x80000001)
• HKEY_LOCAL_MACHINE = 2147483650 (0x80000002)
• HKEY_USERS = 2147483651 (0x80000003)
• HKEY_CURRENT_CONFIG = 2147483653 (0x80000005)
• HKEY_DYN_DATA = 2147483654 (0x80000006)