public PdfDocument(Models.Document documentTemplate, string outputFile)
{
// Create Colors
foreach (Models.Typography.Color bColor in documentTemplate.Colors)
{
Color itextColor = new Color(bColor);
Colors.Add(itextColor);
}
// Create Fonts
foreach (Models.Typography.Font bFont in documentTemplate.Fonts)
{
foreach (Models.Typography.FontStyle bFontStyle in bFont.Styles)
{
FontStyle itextFontStyle =
new FontStyle(bFontStyle);
Fonts.Add(itextFontStyle);
}
}
try
{
CreatePages(documentTemplate, outputFile);
SetDocumentProperties(documentTemplate);
_itextDocument.Close();
_itextPDFWriter.Close();
}
catch (IOException iox)
{
throw;
}
}
public void InitFont(GUIFontConfiguration config)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
if (String.IsNullOrEmpty(config.Tag))
{
throw new ArgumentException("config.Tag must not be null or empty.");
}
if (Fonts.ContainsKey(config.Tag))
{
this.LogWarning("Font was already loaded: {0}", config.Tag);
return;
}
config.ScaleFactor = Owner.ScaleFactor;
IGUIFont font = null;
if (!String.IsNullOrEmpty(config.Path))
{
font = FontManager.CreateFont(config);
if (font == null)
{
this.LogWarning("Failed to load font: {0}", config.Tag);
}
}
// Add even when font is null, which means: loading failed
Fonts.Add(config.Tag, font);
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
_spriteBatch = new SpriteBatch(GraphicsDevice);
// Load the object textures into the textures dictionary
Textures.Add("Spaceship", this.Content.Load <Texture2D>("Spaceship"));
Textures.Add("Bullet", this.Content.Load <Texture2D>("Bullet"));
Textures.Add("Rock1", this.Content.Load <Texture2D>("Rock1"));
Textures.Add("Rock2", this.Content.Load <Texture2D>("Rock2"));
Textures.Add("Rock3", this.Content.Load <Texture2D>("Rock3"));
Textures.Add("Star", this.Content.Load <Texture2D>("Star"));
Textures.Add("SmokeParticle", this.Content.Load <Texture2D>("SmokeParticle"));
// Load fonts
Fonts.Add("Miramonte", this.Content.Load <SpriteFont>("Miramonte"));
// Load sounds
SoundEffects.Add("BulletSound", Content.Load <SoundEffect>("BulletSound"));
SoundEffects.Add("HyperspaceOut", Content.Load <SoundEffect>("HyperspaceOut"));
SoundEffects.Add("HyperspaceIn", Content.Load <SoundEffect>("HyperspaceIn"));
SoundEffects.Add("RockExplosion", Content.Load <SoundEffect>("RockExplosion"));
SoundEffects.Add("SpaceshipExplosion", Content.Load <SoundEffect>("SpaceshipExplosion"));
SoundEffects.Add("Thruster", Content.Load <SoundEffect>("Thruster"));
// Reset the game
ResetGame();
}
internal static void LoadEmbeddedFont()
{
//var auxList = System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceNames();
#if WINDOWS_UWP || WINDOWS_UAP
var assembly = new ColoredString().GetType().GetTypeInfo().Assembly;
#else
var assembly = Assembly.GetExecutingAssembly();
#endif
var resourceNameFont = "SadConsole.Resources.IBM_ext.font";
var resourceNameImage = "SadConsole.Resources.IBM8x16_NoPadding_extended.png";
using (Stream stream = assembly.GetManifestResourceStream(resourceNameFont))
using (StreamReader sr = new StreamReader(stream))
{
Settings.LoadingEmbeddedFont = true;
Global.SerializerPathHint = "";
var masterFont = (FontMaster)Newtonsoft.Json.JsonConvert.DeserializeObject(
sr.ReadToEnd(),
typeof(FontMaster),
new Newtonsoft.Json.JsonSerializerSettings()
{
TypeNameHandling = Newtonsoft.Json.TypeNameHandling.All
});
using (Stream fontStream = assembly.GetManifestResourceStream(resourceNameImage))
masterFont.Image = Texture2D.FromStream(Global.GraphicsDevice, fontStream);
masterFont.ConfigureRects();
Fonts.Add(masterFont.Name, masterFont);
FontDefault = masterFont.GetFont(Font.FontSizes.One);
Settings.LoadingEmbeddedFont = false;
}
}
internal static void LoadEmbeddedAssets()
{
ResourceManager manager = new ResourceManager("Punk.Resources.Embeds", typeof(Engine).Assembly);
var embed = "Punk.Embeds/";
using (MemoryStream stream = new MemoryStream((byte[])manager.GetObject("DefaultFont")))
{
Fonts.Add(embed + "DefaultFont.ttf", new Font(new MemoryStream(stream.ToArray())));
}
var images = new string[]
{
"console_debug",
"console_logo",
"console_output",
"console_pause",
"console_play",
"console_step"
};
foreach (string image in images)
{
using (MemoryStream stream = new MemoryStream())
{
Drawing.Bitmap img = (Drawing.Bitmap)manager.GetObject(image);
img.Save(stream, System.Drawing.Imaging.ImageFormat.Png);
stream.Close();
Textures.Add(embed + image + ".png", new Texture(new MemoryStream(stream.ToArray()))); // wat
}
}
}
public void TryAddFont(Tuple <string, Font> font_data)
{
if (false == Fonts.ContainsKey(font_data.Item1))
{
Fonts.Add(font_data.Item1, font_data.Item2);
}
}
public IAssetPlugin AddFont(IBaseFont font, List <FontTag> fontTags)
{
if (!CanAddFont(font))
{
return(this);
}
//convert the filename so the platform would understand this
ConvertFontFileNameForPlatform(ref font);
Fonts.Add(font.Name, font);
//for each tag, add a font
if (fontTags != null && fontTags.Count > 0)
{
if (FontsTagged != null)
{
if (!FontsTagged.ContainsKey(font.Name))
{
FontsTagged[font.Name] = new List <FontTag>();
}
FontsTagged[font.Name].AddRange(fontTags);
}
}
return(this);
}
/// <summary>
/// Loads a font from a file and adds it to the <see cref="Fonts"/> collection.
/// </summary>
/// <param name="font">The font file to load.</param>
/// <returns>A master font that you can generate a usable font from.</returns>
public static FontMaster LoadFont(string font)
{
//if (!File.Exists(font))
//{
// font = Path.Combine(Path.Combine(Path.GetDirectoryName(Path.GetFullPath(font)), "fonts"), Path.GetFileName(font));
// if (!File.Exists(font))
// throw new Exception($"Font does not exist: {font}");
//}
//FontPathHint = Path.GetDirectoryName(Path.GetFullPath(font));
try
{
var masterFont = SadConsole.Serializer.Load <FontMaster>(font, false);
if (Fonts.ContainsKey(masterFont.Name))
{
Fonts.Remove(masterFont.Name);
}
Fonts.Add(masterFont.Name, masterFont);
return(masterFont);
}
catch (System.Runtime.Serialization.SerializationException e)
{
throw;
}
}
private void AddDefaultStyles()
{
Fonts.Add(new Font("Calibri", size: 11));
Fills.Add(new Fill(new PatternFill(FillPattern.None, null, null), null));
Fills.Add(new Fill(new PatternFill(FillPattern.Gray125, null, null), null));
Borders.Add(new Border());
CellFormats.Add(new CellFormat(null, 0, 0, 0, 0));
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
_spriteBatch = new SpriteBatch(GraphicsDevice);
Fonts.Add("Kootenay", Content.Load <SpriteFont>("Kootenay"));
ResetGame();
}
internal bool LoadFont(string name, string path)
{
if (!Fonts.ContainsKey(name))
{
Fonts.Add(name, Load <SpriteFont>(path));
return(true);
}
return(false);
}
/// <summary>
/// for adding an TMP_FontAsset while it is still in an assetbundle
/// </summary>
/// <param name="fontFile">the assetbundle file</param>
public static void Add(byte[] fontFile)
{
var fonts = UnityEngine.AssetBundle.LoadFromMemory(fontFile).LoadAllAssets <TMPro.TMP_FontAsset>();
foreach (var font in fonts)
{
Fonts.Add(font);
}
}
public void LoadFonts()
{
// total: 1
var i = 1;
Fonts.Add(new ContentData <SpriteFont>(i++, "Fonts/Font_01", _content));
Log.Info("CitySim", $"Fonts: {i}");
}
public DisplayViewModel(IOutputService outputServce)
{
OutputService = outputServce;
foreach (System.Drawing.FontFamily font in System.Drawing.FontFamily.Families)
{
Fonts.Add(font.Name);
}
}
public void LoadFonts()
{
// total: 1
var i = 1;
Fonts.Add(new ContentData <SpriteFont>(i++, "Fonts/Font_01", _content));
Console.WriteLine($"Fonts: {i}");
}
public LettertypeChaos()
{
InitializeComponent();
foreach (FontFamily f in System.Drawing.FontFamily.Families)
{
Fonts.Add(new Font(f.Name, 13));
}
}
private Font GetFont(float size, bool isBold)
{
var font = Fonts.FirstOrDefault(x => x.Size == size && (isBold ? x.Style == FontStyle.Bold : x.Style == FontStyle.Regular));
if (font == null)
{
font = new Font(FontInfo.FontName, size, (isBold ? FontStyle.Bold : FontStyle.Regular));
Fonts.Add(font);
}
return(font);
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
_spriteBatch = new SpriteBatch(GraphicsDevice);
// Load game content
Fonts.Add("WascoSans", Content.Load <SpriteFont>("WascoSans"));
// Reset the game
ResetGame();
}
public PlantxtViewPage()
{
InitializeComponent();
var fonts = Microsoft.Graphics.Canvas.Text.CanvasTextFormat.GetSystemFontFamilies();
// Put the individual fonts in the list
foreach (string font in fonts)
{
Fonts.Add(new Tuple <string, FontFamily>(font, new FontFamily(font)));
}
}
private void AddFont(string fileDirectory, string key = null)
{
if (key == null)
{
Fonts.Add(fileDirectory, _content.Load <SpriteFont>(fileDirectory));
}
else
{
Fonts.Add(key, _content.Load <SpriteFont>(fileDirectory));
}
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
_spriteBatch = new SpriteBatch(GraphicsDevice);
// Load resources
Textures.Add("Crosshair", Content.Load <Texture2D>("Crosshair"));
Fonts.Add("Miramonte", Content.Load <SpriteFont>("Miramonte"));
ResetGame();
}
/* ----------------------------------------------------------------- */
///
/// Converter
///
/// <summary>
/// Initializes a new instance of the Converter class with the
/// specified format.
/// </summary>
///
/// <param name="format">Target format.</param>
/// <param name="io">I/O handler.</param>
/// <param name="supported">Collection of supported formats.</param>
///
/* ----------------------------------------------------------------- */
protected Converter(Format format, IO io, IEnumerable <Format> supported)
{
if (!supported.Contains(format))
{
throw new NotSupportedException(format.ToString());
}
IO = io;
Format = format;
Fonts.Add(Environment.GetFolderPath(Environment.SpecialFolder.Fonts));
}
} // Write string to Str Buffer ( for Tj )
public void FlushStrBuffer()
{
if (StrBuffer.Count == 0)
{
return;
}
if (LastFont != CurFont || LastFontSize != FontSize)
{
if (!Fonts.Contains(CurFont.Obj))
{
Fonts.Add(CurFont.Obj);
}
TSW("/F" + CurFont.Obj + " " + FontSize + " Tf");
LastFont = CurFont;
LastFontSize = FontSize;
}
bool useHex = false;
foreach (byte b in StrBuffer)
{
if (b < 32 || b >= 128)
{
useHex = true; break;
}
}
if (useHex)
{
TS.WriteByte((byte)'<');
foreach (byte b in StrBuffer)
{
int x = b >> 4; x += x < 10 ? 48 : 55; TS.WriteByte((byte)x);
x = b & 15; x += x < 10 ? 48 : 55; TS.WriteByte((byte)x);
}
TSW("> Tj");
}
else
{
TS.WriteByte((byte)'(');
foreach (byte b in StrBuffer)
{
if (b == (byte)'(' || b == (byte)')' || b == (byte)'\\')
{
TS.WriteByte((byte)'\\');
}
TS.WriteByte(b);
}
TSW(") Tj");
}
StrBuffer.Clear();
}
/// <summary>
/// Controls the process of loading the assets from an archive file into memory. This function first determines
/// how many assets there are to load. The way it does this is a little juvenile, so I'm sure I'm going to need
/// a more sophisticated method for doing this. It's accomplished by performing a LINQ query against the entry
/// collection to determine the number of entries that have a file extension. Variable aspects about this are
/// currently not considered, such as the kind of extension or the full path of the asset (this one in particular
/// would require that the structure of the archive be well defined before hand).
///
/// There's another potential caveat here in that numAssetsLoaded is incremented in this method, and is done
/// so directly after a call to an asynchronous operation. The increment of this counter may not accurately reflect
/// the loading efforts done behind the scenes, and may result in future checks that rely on this measurement to be
/// inaccurate. Further testing will need performed to verify that this actually is the case.
///
/// While this method is running, the status of its loading can be monitored by calling methods through the public
/// properties. There may be a better way of doing this, but like other things, it'll require a bit more
/// research.
///
/// When this method completes, each asset bank contained in the AssetManager should be populated with the resources
/// located within the archive that was provided to this method.
/// </summary>
/// <param name="archiveFileName">The path to an archive file that contains assets one wishes to load.</param>
public void LoadAssets(String archiveFileName)
{
try {
ZipArchive archive = ZipFile.OpenRead(archiveFileName);
// I have no idea if this is going to freaking work.
numAssetsToLoad = archive.Entries.SelectMany(s => s.Name).Where(s => s.ToString().Split(new Char[] { '.' }).Length > 1).ToList().Count;
foreach (ZipArchiveEntry entry in archive.Entries)
{
String[] fname = entry.Name.Split(new Char[] { '.' });
if (fname.Length > 1)
{
switch (fname[1])
{
case "png":
case "jpg":
case "jpeg":
Textures.Add(fname[0], (CopyAssetMem <Texture>(entry)).Result);
//numAssetsLoaded++;
break;
case "otf":
Fonts.Add(fname[0], (CopyAssetMem <Font>(entry)).Result);
//numAssetsLoaded++;
break;
case "ogg":
Songs.Add(fname[0], (CopyAssetMem <Music>(entry)).Result);
//numAssetsLoaded++;
break;
case "wav":
SoundEffects.Add(fname[0], (CopyAssetMem <SoundBuffer>(entry)).Result);
//numAssetsLoaded++;
break;
default:
/*
* This could cause a problem where the number of assets to load won't match the expected
* amount, and could result in a false positive sent to the caller. In production code,
* this would be removed since all kinds of assets would be known and contained in the archive.
*/
break;
}
}
}
} catch (Exception e) {
Console.WriteLine(e.Message);
Environment.Exit(-99);
}
}
public void SetFont(MusicFontStyles style, string name, double size, params string[] fontFiles)
{
var fontInfo = new HtmlFontInfo(name, size, fontFiles);
if (!Fonts.ContainsKey(style))
{
Fonts.Add(style, fontInfo);
}
else
{
Fonts[style] = fontInfo;
}
}
/// <summary>
/// Carga una fuente de texto en el ContentManager y la agrega a la lista.
/// </summary>
/// <param name="assetName">Nombre del recurso de la fuente de texto en el Content Project.</param>
/// <returns>Devuelve la instancia de la fuente cargada.</returns>
/// <remarks>Si el recurso que intenta cargar ya existe se omitira su carga y se devolvera la instancia del recurso ya cargado en memoria.</remarks>
public SpriteFont LoadFont(string assetName)
{
if (!Fonts.Keys.Contains(assetName))
{
SpriteFont font = Manager.Content.Load <SpriteFont>(assetName);
Fonts.Add(assetName, font);
return(font);
}
else
{
return(Fonts[assetName]);
}
}
public static void AddFont(string name, string href)
{
if (Fonts.ContainsKey(name))
{
var hrefCurrent = MediaQueries[name];
if (hrefCurrent.Equals(href, StringComparison.InvariantCultureIgnoreCase))
{
return;
}
}
Fonts.Add(name, href);
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
_spriteBatch = new SpriteBatch(GraphicsDevice);
// Load textures
Textures.Add("Marble", Content.Load <Texture2D>("Marble"));
Textures.Add("Balloon", Content.Load <Texture2D>("Balloon"));
// Loat fonts
Fonts.Add("Miramonte", Content.Load <SpriteFont>("Miramonte"));
// Reset the game
ResetGame();
}
/// <summary>
/// Load a font.
/// </summary>
/// <param name="filename">The filename of the font to load.</param>
/// <returns>The loaded font.</returns>
public static Font GetFont(string filename)
{
ValidateFilename(filename);
if (Fonts.ContainsKey(filename))
{
return(Fonts[filename]);
}
Font font = new Font(filename);
Fonts.Add(filename, font);
return(font);
}
/// <summary>
/// Loads the embedded <c>IBM.font</c> files. Sets the <see cref="DefaultFont"/> property.
/// </summary>
/// <param name="defaultFont">An optional font to load and set as the default.</param>
/// <remarks>
/// If <paramref name="defaultFont"/> is <see langword="null"/>, the <see cref="EmbeddedFont"/> or <see cref="EmbeddedFontExtended"/> font is set based on the value of <see cref="Settings.UseDefaultExtendedFont"/>.
/// </remarks>
protected void LoadDefaultFonts(string defaultFont)
{
// Load the embedded fonts.
System.Reflection.Assembly assembly = typeof(SadConsole.SadFont).Assembly;
SadFont LoadFont(string fontName)
{
using Stream stream = assembly.GetManifestResourceStream(fontName);
using StreamReader sr = new StreamReader(stream);
SerializerPathHint = "";
LoadingEmbeddedFont = true;
var masterFont = (SadFont)Newtonsoft.Json.JsonConvert.DeserializeObject(
sr.ReadToEnd(),
typeof(SadFont),
new Newtonsoft.Json.JsonSerializerSettings()
{
TypeNameHandling = Newtonsoft.Json.TypeNameHandling.All,
Converters = null
});
LoadingEmbeddedFont = false;
Fonts.Add(masterFont.Name, masterFont);
return(masterFont);
}
EmbeddedFont = LoadFont("SadConsole.Resources.IBM.font");
EmbeddedFontExtended = LoadFont("SadConsole.Resources.IBM_ext.font");
// Configure default font
if (string.IsNullOrEmpty(defaultFont))
{
if (Settings.UseDefaultExtendedFont)
{
DefaultFont = EmbeddedFontExtended;
}
else
{
DefaultFont = EmbeddedFont;
}
}
else
{
DefaultFont = this.LoadFont(defaultFont);
}
}
