/// <summary>
/// 转换为userProfileSettings用于数据库存储
/// </summary>
public AttachmentSettings AsAttachmentSettings()
{
AttachmentSettings attachmentSettings = DIContainer.Resolve <IAttachmentSettingsManager>().Get();
attachmentSettings.AllowedFileExtensions = AllowedFileExtensions;
attachmentSettings.BatchUploadLimit = BatchUploadLimit;
attachmentSettings.InlinedImageHeight = InlinedImageHeight;
attachmentSettings.InlinedImageWidth = InlinedImageWidth;
attachmentSettings.MaxAttachmentLength = MaxAttachmentLength;
attachmentSettings.MaxImageHeight = MaxImageHeight;
attachmentSettings.MaxImageWidth = MaxImageWidth;
attachmentSettings.TemporaryAttachmentStorageDay = TemporaryAttachmentStorageDay;
WatermarkSettings watermarkSettings = attachmentSettings.WatermarkSettings ?? new WatermarkSettings();
watermarkSettings.WatermarkType = WatermarkType;
if (this.WatermarkType != WatermarkType.None)
{
watermarkSettings.WatermarkImageName = WatermarkImageName;
watermarkSettings.WatermarkLocation = WatermarkLocation;
watermarkSettings.WatermarkMinHeight = WatermarkMinHeight;
watermarkSettings.WatermarkMinWidth = WatermarkMinWidth;
watermarkSettings.WatermarkOpacity = WatermarkOpacity;
watermarkSettings.WatermarkText = WatermarkText;
}
attachmentSettings.WatermarkSettings = watermarkSettings;
return(attachmentSettings);
}
public void Draw(IReadOnlyCollection <string> files, WatermarkSettings settings)
{
foreach (string file in files)
{
DrawTextOnImage(file, settings);
}
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="userProfileSettings">用户资料设置</param>
/// <param name="userSettings">用户设置</param>
/// <param name="inviteFriendSettings">邀请朋友设置</param>
public AttachmentSettingsEditModel(AttachmentSettings attachmentSettings)
{
if (attachmentSettings != null)
{
AllowedFileExtensions = attachmentSettings.AllowedFileExtensions;
BatchUploadLimit = attachmentSettings.BatchUploadLimit;
InlinedImageHeight = attachmentSettings.InlinedImageHeight;
InlinedImageWidth = attachmentSettings.InlinedImageWidth;
MaxAttachmentLength = attachmentSettings.MaxAttachmentLength;
MaxImageHeight = attachmentSettings.MaxImageHeight;
MaxImageWidth = attachmentSettings.MaxImageWidth;
TemporaryAttachmentStorageDay = attachmentSettings.TemporaryAttachmentStorageDay;
WatermarkSettings watermarkSettings = attachmentSettings.WatermarkSettings;
if (watermarkSettings != null)
{
WatermarkImageName = watermarkSettings.WatermarkImageName;
WatermarkLocation = watermarkSettings.WatermarkLocation;
WatermarkMinHeight = watermarkSettings.WatermarkMinHeight;
WatermarkMinWidth = watermarkSettings.WatermarkMinWidth;
WatermarkOpacity = watermarkSettings.WatermarkOpacity;
WatermarkText = watermarkSettings.WatermarkText;
WatermarkType = watermarkSettings.WatermarkType;
}
}
}
private Image MakeImageWatermark(Image sourceImage, int pictureId)
{
WatermarkSettings currentSettings = GetSettings();
bool applyWatermark = IsWaterkmarkRequired(pictureId, currentSettings);
if (applyWatermark &&
((sourceImage.Height > currentSettings.MinimumImageHeightForWatermark) ||
(sourceImage.Width > currentSettings.MinimumImageWidthForWatermark)))
{
Bitmap destBitmap = CreateBitmap(sourceImage);
if (currentSettings.WatermarkTextEnable && !String.IsNullOrEmpty(currentSettings.WatermarkText))
{
PlaceTextWatermark(destBitmap, currentSettings);
}
if (currentSettings.WatermarkPictureEnable && _watermarkBitmap.Value != null)
{
PlaceImageWatermark(destBitmap, _watermarkBitmap.Value, currentSettings);
}
sourceImage.Dispose();
return(destBitmap);
}
return(sourceImage);
}
private Configuration(Configuration copy)
{
this.General = copy.General.Clone();
this.HotKeys = copy.HotKeys.Clone();
this.Mouse = copy.Mouse.Clone();
this.Sound = copy.Sound.Clone();
this.Tracking = copy.Tracking.Clone();
this.Video = copy.Video.Clone();
this.Watermark = copy.Watermark.Clone();
}
private void OnOK(EventArgs e)
{
// General
GeneralSettings general = this.configuration.General;
general.MinimizeOnRecord = this.chkMinimizeOnRecord.Checked;
general.HideFromTaskbar = this.chkHideFromTaskbar.Checked;
general.OutputDirectory = this.txtOutputDirectory.Text;
// Keys
HotKeySettings hotKeys = this.configuration.HotKeys;
hotKeys.Cancel = this.hkCancel.Value;
hotKeys.Global = this.chkGlobalHotKeys.Checked;
hotKeys.Pause = this.hkPause.Value;
hotKeys.Record = this.hkRecord.Value;
hotKeys.Stop = this.hkStop.Value;
// Mouse
MouseSettings mouse = this.configuration.Mouse;
mouse.HighlightCursor = this.chkHighlighCursor.Checked;
mouse.HighlightCursorColor = this.cursorHighlightOptions.Color;
mouse.HighlightCursorRadious = this.cursorHighlightOptions.Radious;
mouse.RecordCursor = this.chkRecordCursor.Checked;
// Sound
SoundSettings sound = this.configuration.Sound;
SoundDevice selectedSoundDevice = this.soundDeviceSelector.SoundDevice;
sound.DeviceId = selectedSoundDevice != null ? selectedSoundDevice.Id : null;
sound.Format = this.cmbSoundFormat.SelectedItem as SoundFormat;
// Tracking
// this.configuration.Tracking = this.trackerSelector.TrackingSettings;
// Video
VideoSettings video = this.configuration.Video;
video.Compressor = (this.cmbCompressor.SelectedItem as Avi.VideoCompressor).FccHandlerString;
video.Fps = this.videoFps;
video.Quality = this.videoQuality;
// Watermark
WatermarkSettings watermark = this.configuration.Watermark;
watermark.Alignment = this.watermarkOptions.WatermarkAlignment;
watermark.Color = this.watermarkOptions.WatermarkColor;
watermark.Display = this.chkWatermark.Checked;
watermark.Font = this.watermarkOptions.WatermarkFont;
watermark.Margin = this.watermarkOptions.WatermarkMargin;
watermark.Outline = this.watermarkOptions.WatermarkOutline;
watermark.OutlineColor = this.watermarkOptions.WatermarkOutlineColor;
watermark.RightToLeft = this.watermarkOptions.WatermarkRightToLeft;
watermark.Text = this.watermarkOptions.WatermarkText;
if (this.OK != null)
{
this.OK(this, e);
}
}
public MainWindow()
{
InitializeComponent();
SettingsSerializer settingsSerializer = new SettingsSerializer();
WatermarkSettings wmSettings = settingsSerializer.RestoreSettings() ?? new WatermarkSettings();
WatermarkDrawer drawer = new WatermarkDrawer();
WatermarkSettingsViewModel viewModel = new WatermarkSettingsViewModel(drawer, wmSettings);
DataContext = viewModel;
Closing += (sender, ea) => settingsSerializer.SaveSettings(wmSettings);
}
private void DrawTextOnImage(string fileName, WatermarkSettings settings)
{
Image img;
using (Image original = Image.FromFile(fileName))
{
img = (Image)original.Clone();
}
EXIFOrientation orientation = GetEXIFOrientation(img);
RotateFlipType rotateFlip = GetRotationForExifOrientation(orientation);
img.RotateFlip(rotateFlip);
FontStyle fontStyle = (FontStyle)settings.FontType;
using (Graphics g = Graphics.FromImage(img))
using (Brush brush = new SolidBrush(settings.Color))
using (Font font = new Font(settings.FontName, settings.TextSize, fontStyle))
{
string text = settings.Text;
Size imgSize = img.Size;
SizeF textSize = g.MeasureString(text, font);
Anchor anchor = settings.Anchor;
SizeF marginSize = new SizeF(settings.HMargin, settings.VMargin);
TextOrientation textOrientation = settings.TextOrientation;
float textRotation = GetTextRotation(textOrientation);
PointF textPosition = GetTextPosition(textOrientation, anchor, imgSize, textSize, marginSize);
g.TranslateTransform(textPosition.X, textPosition.Y);
g.RotateTransform(textRotation);
g.DrawString(text, font, brush, PointF.Empty);
}
if (settings.EraseFiles)
{
File.Delete(fileName);
}
string suffix = !string.IsNullOrEmpty(settings.TransformedFileSuffix) ? settings.TransformedFileSuffix : "_wm";
string saveFileName = fileName.Replace(".", $"{suffix}.");
img.Save(saveFileName);
img.Dispose();
}
public WatermarkSettings RestoreSettings()
{
if (!File.Exists(SettingsPath))
{
return(null);
}
using (XmlReader xmlReader = XmlReader.Create(SettingsPath))
{
object objResult = serializer.Deserialize(xmlReader);
WatermarkSettings settings = (WatermarkSettings)objResult;
return(settings);
}
}
private bool IsWaterkmarkRequired(int pictureId, WatermarkSettings settings)
{
if (settings.ApplyOnProductPictures && _productPictureRepository.Table.Any(product => product.PictureId == pictureId))
{
return(true);
}
if (settings.ApplyOnCategoryPictures && _categoryRepository.Table.Any(category => category.PictureId == pictureId))
{
return(true);
}
if (settings.ApplyOnManufacturerPictures && _manufacturerRepository.Table.Any(manufacturer => manufacturer.PictureId == pictureId))
{
return(true);
}
return(false);
}
private void PlaceTextWatermark(Bitmap sourceBitmap, WatermarkSettings currentSettings)
{
using (Graphics g = Graphics.FromImage(sourceBitmap))
{
g.SmoothingMode = SmoothingMode.AntiAlias;
g.TextRenderingHint = TextRenderingHint.AntiAlias;
string text = currentSettings.WatermarkText;
int textAngle = currentSettings.TextRotatedDegree;
double sizeFactor = (double)currentSettings.TextSettings.Size / 100;
Size maxTextSize = new Size(
(int)(sourceBitmap.Width * sizeFactor),
(int)(sourceBitmap.Height * sizeFactor));
int fontSize = ComputeMaxFontSize(text, textAngle, currentSettings.WatermarkFont, maxTextSize, g);
Font font = new Font(currentSettings.WatermarkFont, (float)fontSize, FontStyle.Bold);
SizeF originalTextSize = g.MeasureString(text, font);
SizeF rotatedTextSize = CalculateRotatedRectSize(originalTextSize, textAngle);
Bitmap textBitmap = new Bitmap((int)rotatedTextSize.Width, (int)rotatedTextSize.Height,
PixelFormat.Format32bppArgb);
using (Graphics textG = Graphics.FromImage(textBitmap))
{
Color color = Color.FromArgb((int)(currentSettings.TextSettings.Opacity * 255), currentSettings.TextColor);
SolidBrush brush = new SolidBrush(color);
textG.TranslateTransform(rotatedTextSize.Width / 2, rotatedTextSize.Height / 2);
textG.RotateTransform((float)textAngle);
textG.DrawString(text, font, brush, -originalTextSize.Width / 2,
-originalTextSize.Height / 2);
textG.ResetTransform();
brush.Dispose();
}
foreach (var position in currentSettings.TextSettings.PositionList)
{
Point textPosition = CalculateWatermarkPosition(position,
sourceBitmap.Size, rotatedTextSize.ToSize());
g.DrawImage(textBitmap, textPosition);
}
textBitmap.Dispose();
font.Dispose();
}
}
public void SaveSettings(WatermarkSettings settings)
{
XmlWriterSettings xmlSettings = new XmlWriterSettings
{
Indent = true,
IndentChars = " ",
NewLineChars = "\r\n",
NewLineHandling = NewLineHandling.Replace
};
Directory.CreateDirectory(AppDataFolderPath);
using (FileStream fs = new FileStream(SettingsPath, FileMode.Create))
using (XmlWriter writer = XmlWriter.Create(fs, xmlSettings))
{
serializer.Serialize(writer, settings);
}
}
private void OnConfigurationChanged()
{
// General
GeneralSettings generalSettings = this.configuration.General;
this.chkMinimizeOnRecord.Checked = generalSettings.MinimizeOnRecord;
this.chkHideFromTaskbar.Checked = generalSettings.HideFromTaskbar;
this.txtOutputDirectory.Text = generalSettings.OutputDirectory;
// Hotkeys
HotKeySettings hotKeys = this.configuration.HotKeys;
this.chkGlobalHotKeys.Checked = hotKeys.Global;
this.hkCancel.Value = hotKeys.Cancel;
this.hkPause.Value = hotKeys.Pause;
this.hkRecord.Value = hotKeys.Record;
this.hkStop.Value = hotKeys.Stop;
// Mouse
MouseSettings mouse = this.configuration.Mouse;
this.chkRecordCursor.Checked = mouse.RecordCursor;
this.chkHighlighCursor.Checked = mouse.HighlightCursor;
this.cursorHighlightOptions.Color = mouse.HighlightCursorColor;
this.cursorHighlightOptions.Radious = mouse.HighlightCursorRadious;
// Sound
SoundSettings sound = this.configuration.Sound;
SoundDevice soundDevice = null;
if (!string.IsNullOrEmpty(sound.DeviceId))
{
soundDevice = new SoundDevice(sound.DeviceId);
}
this.soundDeviceSelector.SoundDevice = soundDevice;
SoundFormat soundFormat = sound.Format;
if (soundFormat != null)
{
this.cmbSoundFormatTag.SelectedItem = soundFormat.Tag;
if (soundFormat != null && !this.cmbSoundFormat.Items.Contains(soundFormat))
{
this.cmbSoundFormat.Items.Add(soundFormat);
}
this.cmbSoundFormat.SelectedItem = soundFormat;
}
// Tracking
// this.trackerSelector.TrackingSettings = this.configuration.Tracking;
// Video
VideoSettings video = this.configuration.Video;
this.cmbSoundFormat.Text = video.Fps.ToString();
this.videoQuality = video.Quality;
this.videoFps = video.Fps;
this.cmbFps.Text = this.videoFps.ToString();
this.tbQuality.Value = this.videoQuality;
// Watermark
WatermarkSettings watermark = this.configuration.Watermark;
this.chkWatermark.Checked = watermark.Display;
this.txtWatermark.Text = watermark.Text;
this.watermarkOptions.WatermarkAlignment = watermark.Alignment;
this.watermarkOptions.WatermarkColor = watermark.Color;
this.watermarkOptions.WatermarkFont = watermark.Font;
this.watermarkOptions.WatermarkMargin = watermark.Margin;
this.watermarkOptions.WatermarkOutline = watermark.Outline;
this.watermarkOptions.WatermarkOutlineColor = watermark.OutlineColor;
this.watermarkOptions.WatermarkRightToLeft = watermark.RightToLeft;
this.watermarkOptions.WatermarkText = watermark.Text;
//
this.UpdateHighlightImage();
this.UpdateVideoQualityControls();
}
private Configuration()
{
var properties = Properties.Settings.Default;
// Read configuration section elements
// General
string outputDir = properties.General_OutputDirectory;
if (string.IsNullOrEmpty(outputDir))
{
string myDocuments = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
try {
outputDir = Path.Combine(myDocuments, outputDirInMyDocs);
}
catch (ArgumentException) {
outputDir = myDocuments;
}
}
GeneralSettings general = new GeneralSettings();
general.MinimizeOnRecord = properties.General_MinimizeOnRecord;
general.HideFromTaskbar = properties.General_HideFromTaskbarIfMinimized;
general.OutputDirectory = outputDir;
// Hot Keys
HotKeySettings hotKeys = new HotKeySettings();
hotKeys.Cancel = properties.HotKeys_Cancel;
hotKeys.Global = properties.HotKeys_Global;
hotKeys.Pause = properties.HotKeys_Pause;
hotKeys.Record = properties.HotKeys_Record;
hotKeys.Stop = properties.HotKeys_Stop;
// Mouse
MouseSettings mouse = new MouseSettings();
mouse.HighlightCursor = properties.Mouse_HighlightCursor;
mouse.HighlightCursorColor = properties.Mouse_HighlightCursorColor;
mouse.HighlightCursorRadious = properties.Mouse_HighlightCursorRadious;
mouse.RecordCursor = properties.Mouse_RecordCursor;
// Sound
SoundSettings sound = new SoundSettings();
sound.DeviceId = properties.Sound_DeviceId;
sound.Format = properties.Sound_Format;
// Tracking
TrackingSettings tracking = new TrackingSettings();
tracking.Bounds = properties.Tracking_Bounds;
tracking.Type = properties.Tracking_Type;
// Video
VideoSettings video = new VideoSettings();
video.Compressor = properties.Video_Compressor;
video.Fps = properties.Video_Fps;
video.Quality = properties.Video_Quality;
// Watermark
WatermarkSettings waterMark = new WatermarkSettings();
waterMark.Alignment = properties.Watermark_Alignment;
waterMark.Color = properties.Watermark_Color;
waterMark.Display = properties.Watermark_Display;
waterMark.Font = properties.Watermark_Font;
waterMark.Margin = properties.Watermark_Margin;
waterMark.Outline = properties.Watermark_Outline;
waterMark.OutlineColor = properties.Watermark_OutlineColor;
waterMark.RightToLeft = properties.Watermark_RightToLeft;
waterMark.Text = properties.Watermark_Text;
// Set properties
this.General = general;
this.HotKeys = hotKeys;
this.Mouse = mouse;
this.Sound = sound;
this.Tracking = tracking;
this.Video = video;
this.Watermark = waterMark;
}
public IActionResult Configure()
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManagePlugins))
{
return(AccessDeniedView());
}
List <string> availableFonts = GetAvailableFontNames();
int activeStoreScope = GetActiveStoreScopeConfiguration(_storeService, _workContext);
WatermarkSettings settings = _settingService.LoadSetting <WatermarkSettings>(activeStoreScope);
var model = new ConfigurationModel
{
WatermarkTextEnable = settings.WatermarkTextEnable,
WatermarkText = settings.WatermarkText,
AvailableFontsList = availableFonts.Select(s => new SelectListItem {
Text = s, Value = s
}).ToList(),
WatermarkFont = settings.WatermarkFont,
TextColor = $"{settings.TextColor.R:X2}{settings.TextColor.G:X2}{settings.TextColor.B:X2}",
TextSettings = new CommonWatermarkSettings
{
Size = settings.TextSettings.Size,
TopLeftCorner = settings.TextSettings.PositionList.Contains(WatermarkPosition.TopLeftCorner),
TopCenter = settings.TextSettings.PositionList.Contains(WatermarkPosition.TopCenter),
TopRightCorner = settings.TextSettings.PositionList.Contains(WatermarkPosition.TopRightCorner),
CenterLeft = settings.TextSettings.PositionList.Contains(WatermarkPosition.CenterLeft),
Center = settings.TextSettings.PositionList.Contains(WatermarkPosition.Center),
CenterRight = settings.TextSettings.PositionList.Contains(WatermarkPosition.CenterRight),
BottomLeftCorner = settings.TextSettings.PositionList.Contains(WatermarkPosition.BottomLeftCorner),
BottomCenter = settings.TextSettings.PositionList.Contains(WatermarkPosition.BottomCenter),
BottomRightCorner = settings.TextSettings.PositionList.Contains(WatermarkPosition.BottomRightCorner),
Opacity = settings.TextSettings.Opacity
},
TextRotatedDegree = settings.TextRotatedDegree,
WatermarkPictureEnable = settings.WatermarkPictureEnable,
PictureId = settings.PictureId,
PictureSettings = new CommonWatermarkSettings
{
Size = settings.PictureSettings.Size,
TopLeftCorner = settings.PictureSettings.PositionList.Contains(WatermarkPosition.TopLeftCorner),
TopCenter = settings.PictureSettings.PositionList.Contains(WatermarkPosition.TopCenter),
TopRightCorner = settings.PictureSettings.PositionList.Contains(WatermarkPosition.TopRightCorner),
CenterLeft = settings.PictureSettings.PositionList.Contains(WatermarkPosition.CenterLeft),
Center = settings.PictureSettings.PositionList.Contains(WatermarkPosition.Center),
CenterRight = settings.PictureSettings.PositionList.Contains(WatermarkPosition.CenterRight),
BottomLeftCorner = settings.PictureSettings.PositionList.Contains(WatermarkPosition.BottomLeftCorner),
BottomCenter = settings.PictureSettings.PositionList.Contains(WatermarkPosition.BottomCenter),
BottomRightCorner = settings.PictureSettings.PositionList.Contains(WatermarkPosition.BottomRightCorner),
Opacity = settings.PictureSettings.Opacity
},
ActiveStoreScopeConfiguration = activeStoreScope,
ApplyOnProductPictures = settings.ApplyOnProductPictures,
ApplyOnCategoryPictures = settings.ApplyOnCategoryPictures,
ApplyOnManufacturerPictures = settings.ApplyOnManufacturerPictures,
MinimumImageWidthForWatermark = settings.MinimumImageWidthForWatermark,
MinimumImageHeightForWatermark = settings.MinimumImageHeightForWatermark
};
if (activeStoreScope > 0)
{
model.WatermarkTextEnable_OverrideForStore =
_settingService.SettingExists(settings, x => x.WatermarkTextEnable, activeStoreScope);
model.Text_OverrideForStore =
_settingService.SettingExists(settings, x => x.WatermarkText, activeStoreScope);
model.WatermarkFont_OverrideForStore =
_settingService.SettingExists(settings, x => x.WatermarkFont, activeStoreScope);
model.TextColor_OverrideForStore =
_settingService.SettingExists(settings, x => x.TextColor, activeStoreScope);
model.TextSettings_OverrideForStore =
_settingService.SettingExists(settings, x => x.TextSettings, activeStoreScope);
model.WatermarkTextRotatedDegree_OverrideForStore =
_settingService.SettingExists(settings, x => x.TextRotatedDegree, activeStoreScope);
model.WatermarkPictureEnable_OverrideForStore =
_settingService.SettingExists(settings, x => x.WatermarkPictureEnable, activeStoreScope);
model.WatermarkPictureId_OverrideForStore =
_settingService.SettingExists(settings, x => x.PictureId, activeStoreScope);
model.PictureSettings_OverrideForStore =
_settingService.SettingExists(settings, x => x.PictureSettings, activeStoreScope);
model.ApplyOnProductPictures_OverrideForStore =
_settingService.SettingExists(settings, x => x.ApplyOnProductPictures, activeStoreScope);
model.ApplyOnCategoryPictures_OverrideForStore =
_settingService.SettingExists(settings, x => x.ApplyOnCategoryPictures, activeStoreScope);
model.ApplyOnManufacturerPictures_OverrideForStore =
_settingService.SettingExists(settings, x => x.ApplyOnManufacturerPictures, activeStoreScope);
model.WatermarkMinimumImageHeightForWatermark_OverrideForStore =
_settingService.SettingExists(settings, x => x.MinimumImageHeightForWatermark, activeStoreScope);
model.WatermarkMinimumImageWidthForWatermark_OverrideForStore =
_settingService.SettingExists(settings, x => x.MinimumImageWidthForWatermark, activeStoreScope);
}
return(View("~/Plugins/Misc.Watermark/Views/MiscWatermark/Configure.cshtml", model));
}
public IActionResult Configure(ConfigurationModel model)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManagePlugins))
{
return(AccessDeniedView());
}
if (!ModelState.IsValid)
{
return(Configure());
}
int activeStoreScope = GetActiveStoreScopeConfiguration(_storeService, _workContext);
WatermarkSettings settings = _settingService.LoadSetting <WatermarkSettings>(activeStoreScope);
settings.WatermarkTextEnable = model.WatermarkTextEnable;
settings.WatermarkText = model.WatermarkText;
settings.WatermarkFont = model.WatermarkFont;
if (model.TextColor != null)
{
settings.TextColor = ColorTranslator.FromHtml("#" + model.TextColor);
}
settings.TextRotatedDegree = model.TextRotatedDegree;
if (model.TextSettings != null)
{
settings.TextSettings.Size = model.TextSettings.Size;
settings.TextSettings.Opacity = model.TextSettings.Opacity;
settings.TextSettings.PositionList = PreparePositionList(model.TextSettings);
}
settings.WatermarkPictureEnable = model.WatermarkPictureEnable;
settings.PictureId = model.PictureId == 0 ? settings.PictureId : model.PictureId;
if (model.PictureSettings != null)
{
settings.PictureSettings.Size = model.PictureSettings.Size;
settings.PictureSettings.Opacity = model.PictureSettings.Opacity;
settings.PictureSettings.PositionList = PreparePositionList(model.PictureSettings);
}
settings.ApplyOnProductPictures = model.ApplyOnProductPictures;
settings.ApplyOnCategoryPictures = model.ApplyOnCategoryPictures;
settings.ApplyOnManufacturerPictures = model.ApplyOnManufacturerPictures;
settings.MinimumImageHeightForWatermark = model.MinimumImageHeightForWatermark;
settings.MinimumImageWidthForWatermark = model.MinimumImageHeightForWatermark;
_settingService.SaveSettingOverridablePerStore(settings,
x => x.WatermarkTextEnable, model.WatermarkTextEnable_OverrideForStore, activeStoreScope, false);
_settingService.SaveSettingOverridablePerStore(settings,
x => x.WatermarkText, model.Text_OverrideForStore, activeStoreScope, false);
_settingService.SaveSettingOverridablePerStore(settings,
x => x.WatermarkFont, model.WatermarkFont_OverrideForStore, activeStoreScope, false);
_settingService.SaveSettingOverridablePerStore(settings,
x => x.TextColor, model.TextColor_OverrideForStore, activeStoreScope, false);
_settingService.SaveSettingOverridablePerStore(settings,
x => x.TextRotatedDegree, model.WatermarkTextRotatedDegree_OverrideForStore, activeStoreScope, false);
_settingService.SaveSettingOverridablePerStore(settings,
x => x.TextSettings, model.TextSettings_OverrideForStore, activeStoreScope, false);
_settingService.SaveSettingOverridablePerStore(settings,
x => x.WatermarkPictureEnable, model.WatermarkPictureEnable_OverrideForStore, activeStoreScope, false);
_settingService.SaveSettingOverridablePerStore(settings,
x => x.PictureId, model.WatermarkPictureId_OverrideForStore, activeStoreScope, false);
_settingService.SaveSettingOverridablePerStore(settings,
x => x.PictureSettings, model.PictureSettings_OverrideForStore, activeStoreScope, false);
_settingService.SaveSettingOverridablePerStore(settings,
x => x.ApplyOnProductPictures, model.ApplyOnProductPictures_OverrideForStore, activeStoreScope, false);
_settingService.SaveSettingOverridablePerStore(settings,
x => x.ApplyOnCategoryPictures, model.ApplyOnCategoryPictures_OverrideForStore, activeStoreScope, false);
_settingService.SaveSettingOverridablePerStore(settings,
x => x.ApplyOnManufacturerPictures, model.ApplyOnManufacturerPictures_OverrideForStore, activeStoreScope, false);
_settingService.SaveSettingOverridablePerStore(settings,
x => x.MinimumImageHeightForWatermark, model.WatermarkMinimumImageHeightForWatermark_OverrideForStore, activeStoreScope, false);
_settingService.SaveSettingOverridablePerStore(settings,
x => x.MinimumImageWidthForWatermark, model.WatermarkMinimumImageWidthForWatermark_OverrideForStore, activeStoreScope, false);
//_settingService.ClearCache();
new ClearCacheTask(EngineContext.Current.Resolve <IStaticCacheManager>()).Execute();
Utils.ClearThumbsDirectory();
SuccessNotification(_localizationService.GetResource("Admin.Plugins.Saved"));
return(Configure());
}
private static void PlaceImageWatermark(Bitmap destBitmap, Bitmap watermarkBitmap, WatermarkSettings currentSettings)
{
using (Graphics g = Graphics.FromImage(destBitmap))
{
double watermarkSizeInPercent = (double)currentSettings.PictureSettings.Size / 100;
Size boundingBoxSize = new Size((int)(destBitmap.Width * watermarkSizeInPercent),
(int)(destBitmap.Height * watermarkSizeInPercent));
Size calculatedWatermarkSize = ScaleRectangleToFitBounds(boundingBoxSize, watermarkBitmap.Size);
if (calculatedWatermarkSize.Width == 0 || calculatedWatermarkSize.Height == 0)
{
return;
}
Bitmap scaledWatermarkBitmap =
new Bitmap(calculatedWatermarkSize.Width, calculatedWatermarkSize.Height);
using (Graphics watermarkGraphics = Graphics.FromImage(scaledWatermarkBitmap))
{
ColorMatrix opacityMatrix = new ColorMatrix
{
Matrix33 = (float)currentSettings.PictureSettings.Opacity
};
ImageAttributes attrs = new ImageAttributes();
attrs.SetColorMatrix(opacityMatrix, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);
watermarkGraphics.DrawImage(watermarkBitmap,
new Rectangle(0, 0, scaledWatermarkBitmap.Width, scaledWatermarkBitmap.Height),
0, 0, watermarkBitmap.Width, watermarkBitmap.Height,
GraphicsUnit.Pixel, attrs);
attrs.Dispose();
}
foreach (var position in currentSettings.PictureSettings.PositionList)
{
Point watermarkPosition = CalculateWatermarkPosition(position,
destBitmap.Size, calculatedWatermarkSize);
g.DrawImage(scaledWatermarkBitmap,
new Rectangle(watermarkPosition, calculatedWatermarkSize),
0, 0, calculatedWatermarkSize.Width, calculatedWatermarkSize.Height, GraphicsUnit.Pixel);
}
scaledWatermarkBitmap.Dispose();
}
}
public WatermarkSettingsViewModel(WatermarkDrawer drawer, WatermarkSettings model)
{
Drawer = drawer ?? throw new ArgumentNullException(nameof(drawer));
Model = model ?? throw new ArgumentNullException(nameof(model));
}
