public void Add_Watermark_File_Not_Supported()
{
var testFile = TestFiles.Zip;
var options = new WatermarkOptions
{
FileInfo = testFile.ToFileInfo(),
WatermarkDetails = new List <WatermarkDetails>
{
new WatermarkDetails
{
TextWatermarkOptions = new TextWatermarkOptions
{
Text = "Text",
FontFamilyName = "Arial",
FontSize = 18
}
}
},
};
var request = new AddRequest(options);
var ex = Assert.Throws <ApiException>(() => { WatermarkApi.Add(request); });
Assert.AreEqual($"The specified file '{testFile.FullName}' has type which is not currently supported.", ex.Message);
}
public void Add_Watermark_Incorrect_Password()
{
var testFile = TestFiles.PasswordProtected;
var options = new WatermarkOptions
{
FileInfo = new FileInfo
{
FilePath = testFile.FullName,
Password = "******"
},
WatermarkDetails = new List <WatermarkDetails>
{
new WatermarkDetails
{
ImageWatermarkOptions = new ImageWatermarkOptions
{
Image = TestFiles.SampleWatermarkTransparent.ToFileInfo()
}
}
},
};
var request = new AddRequest(options);
var ex = Assert.Throws <ApiException>(() => { WatermarkApi.Add(request); });
Assert.AreEqual($"Password provided for file '{testFile.FullName}' is incorrect.", ex.Message);
}
public NamedWatermark(string name, string virtualPath, WatermarkOptions watermark)
{
Name = name;
VirtualPath = virtualPath;
Watermark = watermark;
serialized = null;
}
public void Add_Watermark_No_Details()
{
var testFile = TestFiles.Docx;
var options = new WatermarkOptions
{
FileInfo = testFile.ToFileInfo(),
WatermarkDetails = new List <WatermarkDetails>()
};
var request = new AddRequest(options);
var ex = Assert.Throws <ApiException>(() => { WatermarkApi.Add(request); });
Assert.AreEqual("Request parameters missing or have incorrect format", ex.Message);
}
public static void Run()
{
var configuration = new Configuration(Common.MyAppSid, Common.MyAppKey);
var apiInstance = new WatermarkApi(configuration);
try
{
var fileInfo = new FileInfo
{
FilePath = "documents/sample.docx",
StorageName = Common.MyStorage
};
var options = new WatermarkOptions()
{
FileInfo = fileInfo,
WatermarkDetails = new List <WatermarkDetails>
{
new WatermarkDetails
{
ImageWatermarkOptions = new ImageWatermarkOptions()
{
Image = new FileInfo {
FilePath = "watermark_images/sample_watermark.png", StorageName = Common.MyStorage
}
}
}
},
ProtectLevel = WatermarkOptions.ProtectLevelEnum.DocumentAndImages
};
var request = new AddRequest(options);
var response = apiInstance.Add(request);
Console.WriteLine("Resultant file path: " + response.Path);
}
catch (Exception e)
{
Console.WriteLine("Exception while calling WatermarkApi: " + e.Message);
}
}
public static void Run()
{
var configuration = new Configuration(Common.MyAppSid, Common.MyAppKey);
var apiInstance = new WatermarkApi(configuration);
try
{
var fileInfo = new FileInfo
{
FilePath = "documents/sample.docx",
StorageName = Common.MyStorage
};
var options = new WatermarkOptions()
{
FileInfo = fileInfo,
WatermarkDetails = new List <WatermarkDetails>
{
new WatermarkDetails
{
TextWatermarkOptions = new TextWatermarkOptions
{
Text = "New watermark text",
FontFamilyName = "Arial",
FontSize = 12d,
}
}
}
};
var request = new AddRequest(options);
var response = apiInstance.Add(request);
Console.WriteLine("Resultant file path: " + response.Path);
}
catch (Exception e)
{
Console.WriteLine("Exception while calling WatermarkApi: " + e.Message);
}
}
public static void Run()
{
try
{
// Create necessary API instances
var apiInstance = new ConvertApi(Constants.GetConfig());
// Prepare convert settings
var watermark = new WatermarkOptions
{
Text = "Sample watermark",
Color = "Red",
Width = 100,
Height = 100,
Background = true
};
var settings = new ConvertSettings
{
StorageName = Constants.MyStorage,
FilePath = "WordProcessing/four-pages.docx",
Format = "pdf",
ConvertOptions = new PdfConvertOptions
{
WatermarkOptions = watermark
},
OutputPath = "converted"
};
// Convert to specified format
var response = apiInstance.ConvertDocument(new ConvertDocumentRequest(settings));
Console.WriteLine("Document converted successfully: " + response[0].Url);
}
catch (Exception e)
{
Console.WriteLine("Exception: " + e.Message);
}
}
public void TestAddImageWatermark()
{
var testFile = TestFiles.Pdf;
var options = new WatermarkOptions()
{
FileInfo = testFile.ToFileInfo(),
WatermarkDetails = new List <WatermarkDetails>
{
new WatermarkDetails
{
ImageWatermarkOptions = new ImageWatermarkOptions()
{
Image = TestFiles.SampleWatermarkTransparent.ToFileInfo()
}
}
},
ProtectLevel = WatermarkOptions.ProtectLevelEnum.DocumentAndImages
};
var request = new AddRequest(options);
var result = WatermarkApi.Add(request);
CheckIfWatermarkExist(result.Path, null, TestFiles.SampleWatermarkTransparent.ToFileInfo());
}
private void button1_Click(object sender, EventArgs e)
{
if (curentVHDLFile != null)
{
inputListBox.Items.Clear();
outputListBox.Items.Clear();
var fileService = new FileService();
vhdlLib = fileService.GetVHDL(@"D:\111\unisim_VCOMP.vhd");
vhdlCode = fileService.GetVHDL(curentVHDLFile);
_document = new VHDLDocument(vhdlCode);
_document.Parse(vhdlLib);
_watermarkOptions = new WatermarkOptions(_document);
Validator validator = new Validator();
var results = validator.Validate(_document);
//TODO Null Checks
if (_document.Entity == null)
{
string message = "You did not enter a server name. Cancel this operation?";
string caption = "There is no entity parsed";
MessageBoxButtons buttons = MessageBoxButtons.OK;
MessageBox.Show(message, caption, buttons);
}
else
{
infoGroupBox.Enabled = true;
_document.Entity.Ports.Where(p => p.PortType == PortTypes.In).ToList().ForEach(x => inputListBox.Items.Add(x));
_document.Entity.Ports.Where(p => p.PortType == PortTypes.Out).ToList().ForEach(x => outputListBox.Items.Add(x));
entityNameLabel.Text = "Entity Name: " + _document.Entity.Name;
freeBitsLabel.Text = "Free Bits for Watermarking: " + _watermarkOptions.WotermarikingDocument.FreeLuts.Count() + " bits";
}
//File.WriteAllText(@"D:\111.vhdl", document.Text);
}
}
public void Add_Watermark_No_Text_And_Image()
{
var testFile = TestFiles.Docx;
var options = new WatermarkOptions
{
FileInfo = testFile.ToFileInfo(),
WatermarkDetails = new List <WatermarkDetails>
{
new WatermarkDetails
{
TextWatermarkOptions = new TextWatermarkOptions
{
FontFamilyName = "Arial",
FontSize = 18
}
}
}
};
var request = new AddRequest(options);
var ex = Assert.Throws <ApiException>(() => { WatermarkApi.Add(request); });
Assert.AreEqual("Request parameters missing or have incorrect format", ex.Message);
}
public void Add_Watermark_File_Not_Found()
{
var testFile = TestFiles.NotExist;
var options = new WatermarkOptions
{
FileInfo = testFile.ToFileInfo(),
WatermarkDetails = new List <WatermarkDetails>
{
new WatermarkDetails
{
ImageWatermarkOptions = new ImageWatermarkOptions
{
Image = TestFiles.SampleWatermarkTransparent.ToFileInfo()
}
}
},
ProtectLevel = WatermarkOptions.ProtectLevelEnum.DocumentAndImages
};
var request = new AddRequest(options);
var ex = Assert.Throws <ApiException>(() => { WatermarkApi.Add(request); });
Assert.AreEqual($"Can't find file located at '{testFile.FullName}'.", ex.Message);
}
public void TestAddTextWatermark()
{
var testFile = TestFiles.Docx;
var options = new WatermarkOptions()
{
FileInfo = testFile.ToFileInfo(),
WatermarkDetails = new List <WatermarkDetails>
{
new WatermarkDetails
{
TextWatermarkOptions = new TextWatermarkOptions
{
Text = "New watermark text",
FontFamilyName = "Arial",
FontSize = 12d,
}
}
}
};
var request = new AddRequest(options);
var result = WatermarkApi.Add(request);
CheckIfWatermarkExist(result.Path, "New watermark text", null);
}
public InputWatermark(IBytesSource source, WatermarkOptions watermark)
{
Source = source;
Watermark = watermark;
}
public InputWatermark(IBytesSource source, int ioId, WatermarkOptions watermark)
{
Source = source;
IoId = ioId;
Watermark = watermark;
}
public abstract int AddVideoWatermark(string watermarkUrl, WatermarkOptions options);
/// <summary>
/// Initializes a new instance of the <see cref="AddRequest"/> class.
/// </summary>
/// <param name="options"></param>
public AddRequest(WatermarkOptions options)
{
this.options = options;
}
public static void WatermarkImage(this Image b, WatermarkOptions options)
{
using (var g = Graphics.FromImage(b))
{
var align = options.WatermarkAlignment;
var opac = options.WatermarkOpacity;
var margin = new SizeF(20, 20);
if (options.WatermarkType == WatermarkType.Text)
{
var text = options.WatermarkText;
var font = options.WatermarkFont;
var tSize = g.MeasureString(text, font);
var tPos = new PointF();
switch (align)
{
case Alignment.Top_Left:
case Alignment.Top_Center:
case Alignment.Top_Right:
tPos.Y = margin.Height;
break;
case Alignment.Middle_Left:
case Alignment.Middle_Center:
case Alignment.Middle_Right:
tPos.Y = (b.Height / 2f) - (tSize.Height / 2f);
break;
case Alignment.Bottom_Left:
case Alignment.Bottom_Center:
case Alignment.Bottom_Right:
tPos.Y = b.Height - margin.Height - tSize.Height;
break;
}
switch (align)
{
case Alignment.Top_Left:
case Alignment.Middle_Left:
case Alignment.Bottom_Left:
tPos.X = margin.Width;
break;
case Alignment.Top_Center:
case Alignment.Middle_Center:
case Alignment.Bottom_Center:
tPos.X = (b.Width / 2f) - (tSize.Width / 2f);
break;
case Alignment.Top_Right:
case Alignment.Middle_Right:
case Alignment.Bottom_Right:
tPos.X = b.Width - margin.Width - tSize.Width;
break;
}
using (var brush = new SolidBrush(Color.FromArgb((int)(255 * opac), Color.White)))
{
g.SmoothingMode = SmoothingMode.HighQuality;
g.TextRenderingHint = TextRenderingHint.AntiAlias;
g.DrawString(text, font, brush, tPos.X, tPos.Y);
brush.Color = Color.FromArgb((int)(255 * opac), Color.Black);
g.DrawString(text, font, brush, tPos.X - (font.SizeInPoints / 24) - 1, tPos.Y - (font.SizeInPoints / 24) - 1);
}
}
else
{
var path = options.WatermarkImagePath;
if (!System.IO.File.Exists(path))
{
return;
}
var grey = options.WatermarkGreyscale;
float tl = 1f, tc = 0f, tr = 0f, ml = 0f, mc = 1f, mr = 0f, bl = 0f, bc = 0f, br = 1f;
const float rwgt = .3086f;
const float gwgt = .6094f;
const float bwgt = .0820f;
if (grey)
{
tl = tc = tr = rwgt;
ml = mc = mr = gwgt;
bl = bc = br = bwgt;
}
float[][] ptsArray =
{
new[] { tl, tc, tr, 0f, 0f }, // RED
new[] { ml, mc, mr, 0f, 0f }, // GREEN
new[] { bl, bc, br, 0f, 0f }, // BLUE
new[] { 0f, 0f, 0f, 1f, 0f }, // Alpha
new[] { 0, 0, 0, 0f, 1f }
};
var imageAttributes = new ImageAttributes();
imageAttributes.ClearColorMatrix();
var colorMatrix = new ColorMatrix(ptsArray)
{
Matrix33 = (float)opac
};
imageAttributes.SetColorMatrix(colorMatrix, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);
var i = Image.FromFile(path);
var tPos = new PointF();
switch (align)
{
case Alignment.Top_Left:
case Alignment.Top_Center:
case Alignment.Top_Right:
tPos.Y = margin.Height;
break;
case Alignment.Middle_Left:
case Alignment.Middle_Center:
case Alignment.Middle_Right:
tPos.Y = (b.Height / 2f) - (i.Height / 2f);
break;
case Alignment.Bottom_Left:
case Alignment.Bottom_Center:
case Alignment.Bottom_Right:
tPos.Y = b.Height - margin.Height - i.Height;
break;
}
switch (align)
{
case Alignment.Top_Left:
case Alignment.Middle_Left:
case Alignment.Bottom_Left:
tPos.X = margin.Width;
break;
case Alignment.Top_Center:
case Alignment.Middle_Center:
case Alignment.Bottom_Center:
tPos.X = (b.Width / 2f) - (i.Width / 2f);
break;
case Alignment.Top_Right:
case Alignment.Middle_Right:
case Alignment.Bottom_Right:
tPos.X = b.Width - margin.Width - i.Width;
break;
}
g.DrawImage(i, new Rectangle((int)tPos.X, (int)tPos.Y, i.Width, i.Height), 0, 0, i.Width, i.Height,
GraphicsUnit.Pixel, imageAttributes);
}
}
}
/// <summary>
/// Sets custom watermark options
/// </summary>
/// <param name="watermark">An instance of the object containing the watermark options</param>
/// <returns>An instance of the widget object</returns>
public AnnotationWidget Watermark(WatermarkOptions watermark)
{
_options.Watermark = watermark;
return(this);
}
public VHDLDocument Watermark(WatermarkOptions options)
{
//-----------------DECODER----------------------------------------
FullSignal isWatermark = new FullSignal
{
Name = "IS_WATERMARK",
ValueType = "STD_LOGIC",
Enumeration = null
};
_document.AddSignal(isWatermark);
Decoder decoder = new Decoder(isWatermark);
decoder.CodedSignals.AddRange(options.WatermarkSettings.Where(x => x.IsUsed).ToList());
//-----------------DECODER----------------------------------------
_document.AddVHDLInBehaviorSection(decoder.ToString());
FullSignal watermarkedSignal = new FullSignal()
{
Name = "WATERMARKED_OUT",
ValueType = StdLogicVector,
};
List <PartialSignal> stSignalBits = new List <PartialSignal>();
int i = 0;
_document.FreeLuts.ForEach(lut =>
{
ChangeLutConstIputs(lut, isWatermark, _document.ConstValueGenerators);
ChangeLutInitVector(lut, true);
var newSignal = watermarkedSignal.CreatePartial(new SimpleIndex(i));
stSignalBits.Add(newSignal);
InjectLutOutput(lut, newSignal);
i++;
});
watermarkedSignal.Enumeration = new ComplexEnumeration(stSignalBits.Sum(x => x.Bits),
EnumerationDirections.Downto);
_document.AddSignal(watermarkedSignal);
i = 0;
options.SignatureOutputSettings.Where(y => y.IsUsed).ToList().ForEach(x =>
{
FullSignal fictionOutSignal = new FullSignal()
{
Name = "FICTION_OUT" + i,
ValueType = x.Port.ValueType,
Enumeration = x.Port.Enumeration
};
_document.AddSignal(fictionOutSignal);
_document.Redirect(x.Port, fictionOutSignal); //TODO
_document.AddMuxAssigment(x.Port, isWatermark + " = '1'", watermarkedSignal.CreatePartial(new ComplexEnumeration(x.Port.Bits, EnumerationDirections.Downto)), fictionOutSignal); //TODO
i++;
});
return(_document);
}
public VHDLDocument Watermark(WatermarkOptions options)
{
var doc = options.WotermarikingDocument.Document;
var IOBuffesLayer = new IOBuffesLayer(_document);
IOBuffesLayer.Parse();
options.WatermarkSettings.ForEach(x => x.Signal = IOBuffesLayer.WhetherEquivalent(x.Signal));
options.SignatureOutputSettings.ForEach(x => x.Signal = IOBuffesLayer.WhetherEquivalent(x.Signal));
List <WatermarkBit> watermarkBits = new List <WatermarkBit>();
options.SignatureOutputSettings.ForEach(ports =>
{
for (int j = 0; j < ports.SignatureCode.Length; j++)
{
if (ports.SignatureCode[j] != '-')
{
var newWB = new WatermarkBit()
{
IsOne = ports.SignatureCode[j] == '1',
Signal =
doc.Router.AssignmentSignal(null, ports.Signal, ports.Signal.Enumeration?.GetBit(j))
};
newWB.Signal.IsSource = false;
watermarkBits.Add(newWB);
}
}
});
//var wbit2 = watermarkBits.FirstOrDefault();
//var routes2 = doc.Router.GetRoutes(wbit2.Signal.Defenition);
//var d = routes2.Signals.Where(signal => signal.IsSource == null).ToList();
//var e = routes2.Signals.Where(signal => signal.IsSource != null && !signal.IsSource.Value).ToList();
//var c = routes2.Signals.Where(signal => signal.IsSource != null && signal.IsSource.Value).ToList();
//-----------------DECODER----------------------------------------
var isWatermark = _document.Router.InserSignalDefenition("IS_WATERMARK", "STD_LOGIC");
var decoder = new Decoder(doc, isWatermark);
var decoderSettings = options.WatermarkSettings.Where(x => x.IsUsed)
.Select(a => new DecoderSignalCode(doc.Router.AssignmentSignal(decoder, a.Signal), a.ActivaionCode))
.ToList();
decoder.CodedSignals.AddRange(decoderSettings);
_document.AddVHDLInBehaviorSection(decoder.ToString());
//-----------------DECODER----------------------------------------
//----------------------Lut work----------------------------------
/**var signatureBus = _document.Router.CreateBus("WATERMARKED_OUT");
* int i = 0;
* options.WotermarikingDocument.FreeLuts.ForEach(lut =>
* {
* ChangeLutConstIputs(lut, isWatermark, options.WotermarikingDocument.ConstValueGenerators);
* ChangeLutInitVector(lut, true);
* var newLutOutput = signatureBus.GetWire(i);
*
* InjectLutOutput(lut, newLutOutput.Defenition);
* i++;
* });
* var watermarkedSignalDefenition = signatureBus.BuildSignal();**/
LUTComponents components = new LUTComponents(doc);
var lutForExtenion = _document.Maps
.Where(map => LUT.IsLUT(map.Entity) && !options.WotermarikingDocument.FreeLuts.Contains(map))
.Select(map => MapLUT.FromMap(map)).ToList();
lutForExtenion.ForEach(lut => lut.ExtendLUT(components)); //Extends lut
var freeInputs = lutForExtenion.Select(x => x.GetFreeInput()).ToList();
List <MapLUT> lutsForInsertion = new List <MapLUT>(lutForExtenion); //Merge all luts
//lutsForInsertion.AddRange(); //AddFreeLut
lutsForInsertion.ForEach(lut =>
{
var watermarkBit = watermarkBits.FirstOrDefault(wb => wb.LUT == null);
if (watermarkBit != null)
{
var port = lut.GetFreeInput(); //TODO
lut.AddLutAssigment(Assignment.Create(lut, port, isWatermark));
lut.ConstValuePort(port, watermarkBit.IsOne);
watermarkBit.LUT = lut;
}
});
//-----------------------------------------------------------------------------------------
watermarkBits.GroupBy(x => x.Signal.Defenition).ToList().ForEach(def =>
{
var ficitonSignal = _document.Router
.InserSignalDefenition(
"FO" + Helper.NewGuidName(),
def.Key.ValueType,
def.Key.Enumeration?.CloneEnumeration());
doc.Router.RedirectAllSources(def.Key, ficitonSignal);
def.ToList().ForEach(wbit =>
{
wbit.RealSignal = doc.Router.GetRoutes(ficitonSignal)
.Signals.FirstOrDefault(x => (x.Enumeration == null && wbit.Signal.Enumeration == null) ||
(x.Enumeration == null && wbit.Signal.Enumeration == null && x.Enumeration.IsSameBus(wbit.Signal.Enumeration)));
Mux mux = new Mux();
mux.To = wbit.Signal;
mux.Condition = doc.Router.AssignmentSignal(mux, isWatermark) + " = '1'";
mux.Else = wbit.RealSignal;
mux.Then = wbit.LUT.GetOutput();
mux.Insert(_document);
});
});
return(_document);
}
