private static void Helper(ClipboardFormat format, object data)
{
if (OnClipboardChange != null)
{
OnClipboardChange(format, data);
}
}
private static void ClipboardMonitor_OnClipboardChange(ClipboardFormat format, object data)
{
if (format == ClipboardFormat.Text && !_copied)
{
_stringCopy = data.ToString();
}
}
/// <summary>
///
/// </summary>
/// <param name="iconImage"></param>
/// <param name="newData"></param>
/// <param name="newClipboardFormat"></param>
/// <param name="newDataTime"></param>
public ClipboardEntity(byte[] iconImage, object newData, ClipboardFormat newClipboardFormat, string newDataTime)
{
this.Image = iconImage;
this.Data = newData;
this.ClipboardFormat = newClipboardFormat;
this.DateTime = newDataTime;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="format"></param>
/// <param name="data"></param>
public ClipboardObject(ClipboardFormat format, object data)
{
Format = format;
Data = data;
ClipDateTime = DateTime.Now;
var text = data as string;
if (text != null)
{
Key = $"Text[{text.Length}]";
Checksum = ChecksumMD5.ComputeChecksum(text);
return;
}
var strings = data as string[];
if (strings != null)
{
Key = $"Strings[{strings.LongLength}]";
if (strings.LongLength > 0)
{
Text = $"\"{string.Join("\",\n\"", strings)}\"";
}
Checksum = ChecksumMD5.ComputeChecksum(strings);
return;
}
var bitmap = data as Bitmap;
if (bitmap != null)
{
Key = $"Bitmap[{bitmap.Size.Width}x{bitmap.Size.Height}]";
Checksum = ChecksumMD5.ComputeChecksum(bitmap);
return;
}
}
/// <summary>
///
/// </summary>
/// <param name="iconImage"></param>
/// <param name="newData"></param>
/// <param name="newClipboardFormat"></param>
/// <param name="newDataTime"></param>
public ClipboardEntity(byte[] iconImage, object newData, ClipboardFormat newClipboardFormat, string newDataTime)
{
this.Image = iconImage;
this.Data = newData;
this.ClipboardFormat = newClipboardFormat;
this.DateTime = newDataTime;
}
/// <summary>
///
/// </summary>
/// <param name="format"></param>
/// <param name="data"></param>
private static void ClipboardWatcher_OnClipboardChange(ClipboardFormat format, object data)
{
if (null != OnClipboardChange)
{
OnClipboardChange(format, data);
}
}
private void tsmiClipboardFormat_Click(object sender, EventArgs e)
{
ToolStripMenuItem tsmiClipboardFormat = sender as ToolStripMenuItem;
ClipboardFormat cf = tsmiClipboardFormat.Tag as ClipboardFormat;
uim.CopyCustomFormat(cf.Format);
}
private void CloudClipboardMonitor_OnClipboardChange(ClipboardFormat format, object data)
{
if (format == ClipboardFormat.Html ||
format == ClipboardFormat.SymbolicLink ||
format == ClipboardFormat.Text ||
format == ClipboardFormat.UnicodeText)
{
if (data != null && !string.IsNullOrEmpty(data.ToString().Trim()))
{
if (_dataList.Contains(data.ToString()))
{
_dataList.Remove(data.ToString());
}
_dataList.Add(data.ToString());
var keypair = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("data", data.ToString())
};
var content = new FormUrlEncodedContent(keypair);
var result = _client.PostAsync(_url, content).Result;
if (_dataList.Count > MaxDataCount)
{
_dataList.Remove(_dataList.Last());
}
}
}
}
static void ClipboardMonitor_OnClipboardChange(ClipboardFormat format, object data)
{
switch (format)
{
case ClipboardFormat.Text:
Utility.AddData(new UserData()
{
DisplayName = Utility.GetShortenedName(Utility.GetURLTitle(data.ToString())), Data = data, DataType = "Text"
});
break;
case ClipboardFormat.FileDrop:
string[] files = (string[])data;
for (int i = 0; i < files.Length; i++)
{
FileAttributes attr = File.GetAttributes(files[i]);
bool isFolder = (attr & FileAttributes.Directory) == FileAttributes.Directory;
Utility.AddData(new UserData()
{
DisplayName = Utility.GetShortenedName(new FileInfo(files[i]).Name), Data = files[i], DataType = isFolder ? "Folder" : "File"
});
}
break;
default: break;
}
InitItems();
}
/// <summary>
/// Clipboard has changed - event
/// </summary>
/// <param name="format">Data format</param>
/// <param name="data">Data object</param>
private void ClipboardMonitor_OnClipboardChange(ClipboardFormat format, object data)
{
var clipboardObject = new ClipboardObject(format, data);
if (LastClipboardObject != null && LastClipboardObject.Equals(clipboardObject))
{
return; // Same clipboard as the last one, ignoring!
}
CurrentIndex = 0;
var item = Find(clipboardObject);
if (item != null)
{
ClipboardObjects.Remove(clipboardObject);
ClipboardObjects.Enqueue(clipboardObject);
}
else
{
ClipboardObjects.Enqueue(clipboardObject);
}
OnPropertyChanged(nameof(ClipboardObjects));
LastClipboardObject = clipboardObject;
SessionClips++;
}
private void ClipboardMonitorOnOnClipboardChange(ClipboardFormat format, object data)
{
_throttler.Trigger(new ClipboardContent
{
Format = format,
Data = data
});
}
/// <summary>
/// Show all clipboard format descriptions in the current language
/// </summary>
private void UpdateClipboardFormatDescriptions()
{
foreach (ListViewItem item in listview_clipboardformats.Items)
{
ClipboardFormat cf = (ClipboardFormat)item.Tag;
item.Text = Language.Translate(cf);
}
}
private void AddClipboardFormat(ClipboardFormat cf)
{
ListViewItem lvi = new ListViewItem(cf.Description ?? "");
lvi.Tag = cf;
lvi.SubItems.Add(cf.Format ?? "");
lvClipboardFormats.Items.Add(lvi);
}
internal BitmapImplementation(ClipboardFormat format, ClipboardImplementationFactory factory, ClipboardObject clipboardObject, Stream bmpStream) : base(format, factory, clipboardObject)
{
fileName = DiContainer.SP.GetService <ITempManager>().GetNewFileName("bmp");
//TODO set size
using (var fileStream = new FileStream(fileName, FileMode.Create, FileAccess.Write))
{
bmpStream.CopyTo(fileStream);
}
}
public ClipboardFormatForm(ClipboardFormat cbf)
{
InitializeComponent();
ClipboardFormat = cbf;
txtDescription.Text = cbf.Description ?? "";
txtFormat.Text = cbf.Format ?? "";
NameParser.CreateCodesMenu(txtFormat);
lblExample.Text = "Supported variables: $result, $url, $shorturl, $thumbnailurl, $deletionurl, $filepath, $filename, $filenamenoext, $thumbnailfilename, $thumbnailfilenamenoext, $folderpath, $foldername, $uploadtime and other variables such as %y-%mo-%d etc.";
}
private void ClipboardMonitor_OnClipboardChange(ClipboardFormat format, object data)
{
if (format == ClipboardFormat.Text) {
var st = data.ToString().Split(new string[] { "\r\n" },StringSplitOptions.None);
if (st.Count() == 2) {
vm.ThisTicket.ComplexSubject = st[0];
}
}
}
internal static void Setup(IServiceCollection services)
{
Unicode = new ClipboardFormat(nameof(Unicode), DataFormats.UnicodeText, "T:Unic", DefaultClipboardFormatCategories.Text);
FileDrop = new ClipboardFormat(nameof(FileDrop), DataFormats.FileDrop, "T:FiDr", DefaultClipboardFormatCategories.Path);
Bitmap = new ClipboardFormat(nameof(Bitmap), DataFormats.Bitmap, "T:Bmp", DefaultClipboardFormatCategories.Picture);
services.AddSingleton(Unicode);
services.AddSingleton(FileDrop);
services.AddSingleton(Bitmap);
}
private void btnClipboardFormatRemove_Click(object sender, EventArgs e)
{
if (lvClipboardFormats.SelectedItems.Count > 0)
{
ListViewItem lvi = lvClipboardFormats.SelectedItems[0];
ClipboardFormat cf = lvi.Tag as ClipboardFormat;
Program.Settings.ClipboardContentFormats.Remove(cf);
lvClipboardFormats.Items.Remove(lvi);
}
}
private void ClipboardMonitor_OnClipboardChange(ClipboardFormat format, object data)
{
_currentClipboardContent = data.ToString();
//Process the changed clipboard content in a new thread to prevent new windows signals captured in the ClipboardWatcherfrom interrupting the processing
Thread processclipboardContentThread = new Thread(ProcessClipboardContent);
processclipboardContentThread.SetApartmentState(ApartmentState.STA); // give the [STAThread] attribute
processclipboardContentThread.Start();
}
/// <summary>
/// Set Unicode text in the clipboard under the given format.
/// </summary>
public static void SetClipboardUnicodeText(ReadOnlySpan <char> span, ClipboardFormat format = ClipboardFormat.UnicodeText)
{
using GlobalHandle global = Memory.Memory.GlobalAlloc((ulong)((span.Length + 1) * sizeof(char)), GlobalMemoryFlags.Moveable);
using GlobalLock globalLock = global.Lock;
Span <char> buffer = globalLock.GetSpan <char>();
span.CopyTo(buffer);
buffer[buffer.Length - 1] = '\0';
Imports.SetClipboardData((uint)format, globalLock.Pointer);
}
/// <summary>
/// Set binary data in the clipboard under the given format.
/// </summary>
public static void SetClipboardBinaryData(ReadOnlySpan <byte> span, ClipboardFormat format)
{
using GlobalHandle global = Memory.Memory.GlobalAlloc((ulong)((span.Length + 1)), GlobalMemoryFlags.Moveable);
using GlobalLock globalLock = global.Lock;
Span <byte> buffer = globalLock.GetSpan <byte>();
span.CopyTo(buffer);
buffer[buffer.Length - 1] = 0;
Imports.SetClipboardData((uint)format, globalLock.Pointer);
}
static void ClipboardMonitor_OnClipboardChange(ClipboardFormat format, object data)
{
if (viewer == null)
{
return;
}
if (format.ToString().Equals("Text"))
{
viewer.Search((string)data);
}
}
/// <summary>
///
/// </summary>
/// <param name="format"></param>
/// <param name="data"></param>
private static void ClipboardMonitor_OnClipboardChange(ClipboardFormat format, object data)
{
Log.Debug("ClipboardMonitor_OnClipboardChange()");
Icon icon = null;
int processId;
IntPtr clipboardHandle = ClipboardMonitor.GetClipboardOwner();
if (0 < (int)clipboardHandle)
{
processId = CWinApi.GetProcessIdByHandle(clipboardHandle);
if (0 < processId)
{
try
{
// 32비트 프로그램에서 64비트 프로그램 프로세스 접근이 안되기 때문에
// 이런식으로 Process의 실행 위치를 가져온다.
const string Query = "SELECT ProcessId, ExecutablePath, CommandLine FROM Win32_Process";
var searcher = new ManagementObjectSearcher(Query);
foreach (var item in searcher.Get())
{
object id = item["ProcessID"];
object path = item["ExecutablePath"];
if (path != null && id.ToString() == processId.ToString())
{
icon = Icon.ExtractAssociatedIcon(path.ToString());
break;
}
}
}
catch
{
icon = null;
}
}
}
var ms = new MemoryStream();
if (icon != null)
{
icon.ToBitmap().Save(ms, System.Drawing.Imaging.ImageFormat.Png);
}
_clipboardEntities.Add(
new ClipboardEntity(
ms.ToArray(),
data,
format,
DateTime.Now.ToString()));
}
public ClipboardFormatForm(ClipboardFormat cbf)
{
InitializeComponent();
ClipboardFormat = cbf;
txtDescription.Text = cbf.Description ?? "";
txtFormat.Text = cbf.Format ?? "";
CodeMenu.Create <ReplCodeMenuEntry>(txtFormat);
lblExample.Text = string.Format(Resources.ClipboardFormatForm_ClipboardFormatForm_Supported_variables___0__and_other_variables_such_as__1__etc_,
"$result, $url, $shorturl, $thumbnailurl, $deletionurl, $filepath, $filename, $filenamenoext, $thumbnailfilename, $thumbnailfilenamenoext, $folderpath, $foldername, $uploadtime",
"%y, %mo, %d");
}
/// <summary>
///
/// </summary>
/// <param name="format"></param>
/// <param name="data"></param>
private static void ClipboardMonitor_OnClipboardChange(ClipboardFormat format, object data)
{
Log.Debug("ClipboardMonitor_OnClipboardChange()");
Icon icon = null;
int processId;
IntPtr clipboardHandle = ClipboardMonitor.GetClipboardOwner();
if (0 < (int)clipboardHandle)
{
processId = CWinApi.GetProcessIdByHandle(clipboardHandle);
if (0 < processId)
{
try
{
// 32비트 프로그램에서 64비트 프로그램 프로세스 접근이 안되기 때문에
// 이런식으로 Process의 실행 위치를 가져온다.
const string Query = "SELECT ProcessId, ExecutablePath, CommandLine FROM Win32_Process";
var searcher = new ManagementObjectSearcher(Query);
foreach (var item in searcher.Get())
{
object id = item["ProcessID"];
object path = item["ExecutablePath"];
if (path != null && id.ToString() == processId.ToString())
{
icon = Icon.ExtractAssociatedIcon(path.ToString());
break;
}
}
}
catch
{
icon = null;
}
}
}
var ms = new MemoryStream();
if (icon != null)
{
icon.ToBitmap().Save(ms, System.Drawing.Imaging.ImageFormat.Png);
}
_clipboardEntities.Add(
new ClipboardEntity(
ms.ToArray(),
data,
format,
DateTime.Now.ToString()));
}
private void btnAddClipboardFormat_Click(object sender, EventArgs e)
{
using (ClipboardFormatForm form = new ClipboardFormatForm())
{
if (form.ShowDialog() == DialogResult.OK)
{
ClipboardFormat cf = form.ClipboardFormat;
Program.Settings.ClipboardContentFormats.Add(cf);
AddClipboardFormat(cf);
}
}
}
public ClipboardFormatView(ClipboardFormat cbf)
{
InitializeComponent();
ClipboardFormat = cbf;
txtDescription.Text = cbf.Description ?? "";
txtFormat.Text = cbf.Format ?? "";
// TODO CodeMenu.Create<CodeMenuEntryFilename>(txtFormat);
lblExample.Text = string.Format("Supported variables: {0} and other variables such as {1} etc.",
"$result, $url, $shorturl, $thumbnailurl, $deletionurl, $filepath, $filename, $filenamenoext, $thumbnailfilename, $thumbnailfilenamenoext, $folderpath, $foldername, $uploadtime",
"%y, %mo, %d");
}
private void ClipboardMonitor_OnClipboardChange(ClipboardFormat format, object data)
{
if (format == ClipboardFormat.Text)
{
if (MyRecordModel == null)
{
return;
}
MyRecordModel.AddCopyRecord((String)data);
}
UpdateRecordCounter();
}
public static bool TryGetContent(ClipboardFormat format, out byte[] content)
{
if (IsClipboardFormatAvailable(format))
{
OpenClipboard();
try
{
IntPtr clipboard = GetClipboard(format);
int size = GetClipboardSize(clipboard);
content = new byte[size];
IntPtr contentPointer = LockClipboard(clipboard);
try
{
GCHandle handle = GCHandle.Alloc(content, GCHandleType.Pinned);
try
{
CopyClipboard(contentPointer, handle.AddrOfPinnedObject(), size);
}
finally
{
if (handle.IsAllocated)
{
handle.Free();
}
}
}
finally
{
UnlockClipboard(clipboard);
}
}
finally
{
CloseClipboard();
}
return(true);
}
content = null;
return(false);
}
/// <summary>
/// Set ASCII text in the clipboard under the given format.
/// </summary>
public static unsafe void SetClipboardAsciiText(ReadOnlySpan <char> span, ClipboardFormat format = ClipboardFormat.Text)
{
Encoding ascii = Encoding.ASCII;
fixed(char *c = span)
{
byte[] buffer = ArrayPool <byte> .Shared.Rent(ascii.GetByteCount(c, span.Length));
fixed(byte *b = buffer)
{
int length = ascii.GetBytes(c, span.Length, b, buffer.Length);
SetClipboardBinaryData(buffer.AsSpan(0, length), format);
}
}
}
public void Adding_Formats_With_Not_Registered_Categories_Should_Not_Work()
{
//assert
var category = new ClipboardFormatCategory("FormatsCategory", "T:Cat");
var format1 = new ClipboardFormat("Format1", "Format1", "T:Format1", category);
var format2 = new ClipboardFormat("Format2", "Format2", "T:Format2", category);
var categoriesManager = new Mock <IClipboardFormatCategoriesManager>();
categoriesManager.Setup(x => x.Contains(It.IsAny <ClipboardFormatCategory>())).Returns(false);
//act
Assert.Throws <ArgumentException>(() => new ClipboardFormatsManager(new[] { format1, format2 }, categoriesManager.Object));
}
public ClipboardManagerEditViewModel(ClipboardData clipboardData)
{
Formats = new List <ClipboardFormat>
{
ClipboardFormat.Text,
ClipboardFormat.UnicodeText,
ClipboardFormat.Rtf,
ClipboardFormat.Html,
ClipboardFormat.CommaSeparatedValue,
ClipboardFormat.FileDrop,
ClipboardFormat.Bitmap
};
_selectedClipboardFormat = clipboardData.ClipboardFormat;
_clipboardData = clipboardData;
}
public void Constructor_Should_Work()
{
//assert
var category = new ClipboardFormatCategory("FormatsCategory", "T:Cat");
var format1 = new ClipboardFormat("Format1", "Format1", "T:Format1", category);
var format2 = new ClipboardFormat("Format2", "Format2", "T:Format2", category);
var categoriesManager = new Mock <IClipboardFormatCategoriesManager>();
categoriesManager.Setup(x => x.Contains(category)).Returns(true);
//act
new ClipboardFormatsManager(new[] { format1, format2 }, categoriesManager.Object);
}
public static byte[] GetContent(ClipboardFormat format)
{
if (!IsClipboardFormatAvailable(format))
{
throw new InvalidOperationException($"Clipboard contains no content for specified format ({format}).");
}
OpenClipboard();
try
{
IntPtr clipboard = GetClipboard(format);
int size = GetClipboardSize(clipboard);
var content = new byte[size];
IntPtr contentPointer = LockClipboard(clipboard);
try
{
GCHandle handle = GCHandle.Alloc(content, GCHandleType.Pinned);
try
{
CopyClipboard(contentPointer, handle.AddrOfPinnedObject(), size);
return(content);
}
finally
{
if (handle.IsAllocated)
{
handle.Free();
}
}
}
finally
{
UnlockClipboard(clipboard);
}
}
finally
{
CloseClipboard();
}
}
internal static string FormatToString(ClipboardFormat format)
{
switch (format)
{
case ClipboardFormat.CommaSeparatedValues:
return Forms.DataFormats.CommaSeparatedValue;
case ClipboardFormat.Html:
return Forms.DataFormats.Html;
case ClipboardFormat.RichText:
return Forms.DataFormats.Rtf;
case ClipboardFormat.XmlSpreadsheet:
return "Xml Spreadsheet";
case ClipboardFormat.Text:
default:
return Forms.DataFormats.Text;
}
}
void ClipboardMonitor_OnClipboardChange(ClipboardFormat format, object data)
{
if (format == ClipboardFormat.Html ||
format == ClipboardFormat.SymbolicLink ||
format == ClipboardFormat.Text ||
format == ClipboardFormat.UnicodeText)
{
if (data != null && !string.IsNullOrEmpty(data.ToString()))
{
if (dataList.Contains(data.ToString()))
{
dataList.Remove(data.ToString());
}
dataList.Add(data.ToString());
if (dataList.Count > MaxDataCount)
{
dataList.Remove(dataList.First());
}
}
}
}
/// <summary>
/// The SetClipboardData function places data on the clipboard in a specified clipboard format.
/// The window must be the current clipboard owner, and the application must have called the
/// OpenClipboard function. (When responding to the WindowsMessage.WM_RENDERFORMAT and WindowsMessage.WM_RENDERALLFORMATS messages,
/// the clipboard owner must not call OpenClipboard before calling SetClipboardData.)
/// </summary>
/// <param name="uFormat">Specifies a clipboard format. This parameter can be a registered format or any of the standard clipboard formats.</param>
/// <param name="hMem">Handle to the data in the specified format. This parameter can be null, indicating that the window provides data in the
/// specified clipboard format (renders the format) upon request. If a window delays rendering, it must process the WindowsMessage.WM_RENDERFORMAT and
/// WindowsMessage.WM_RENDERALLFORMATS messages. </param>
/// <returns>If the function succeeds, the return value is the handle to the data. If the function fails, the return value is null
/// </returns>
public static IntPtr SetClipboardData(ClipboardFormat uFormat, [In] IntPtr hMem)
{
return Native.SetClipboardData(uFormat, hMem);
}
/// <summary>
/// Clipboard has changed - event
/// </summary>
/// <param name="format">Data format</param>
/// <param name="data">Data object</param>
private void ClipboardMonitor_OnClipboardChange(ClipboardFormat format, object data)
{
var clipboardObject = new ClipboardObject(format, data);
if (LastClipboardObject != null && LastClipboardObject.Equals(clipboardObject))
return; // Same clipboard as the last one, ignoring!
CurrentIndex = 0;
var item = Find(clipboardObject);
if (item != null)
{
ClipboardObjects.Remove(clipboardObject);
ClipboardObjects.Enqueue(clipboardObject);
}
else
{
ClipboardObjects.Enqueue(clipboardObject);
}
OnPropertyChanged(nameof(ClipboardObjects));
LastClipboardObject = clipboardObject;
SessionClips++;
}
void ClipboardMonitor_OnClipboardChange(ClipboardFormat format, object data)
{
m_log.TraceEvent(LogLevels.Verbose, 76543, "Clipboard changed ... format now: " + format.ToString());
}
/// <summary>
/// The GetClipboardData function retrieves data from the clipboard in a specified format.
/// The clipboard must have been opened previously.
/// </summary>
/// <param name="uFormat">Specifies a clipboard format.</param>
/// <returns>If the function succeeds, the return value is the handle to a clipboard object
/// in the specified format. If the function fails, the return value is null.
/// </returns>
public static IntPtr GetClipboardData(ClipboardFormat uFormat)
{
return Native.GetClipboardData(uFormat);
}
/// <summary>
/// The GetClipboardFormatName function retrieves from the clipboard the name of the specified registered format.
/// The function copies the name to the specified buffer.
/// </summary>
/// <param name="format">Specifies the type of format to be retrieved</param>
/// <param name="lpszFormatName">Buffer that is to receive the format name</param>
/// <param name="cchMaxCount">Specifies the maximum length, in TCHARs, of the string to be copied to the buffer.
/// If the name exceeds this limit, it is truncated. For the ANSI version of the function, this is the number of bytes.
/// For the wide-character (Unicode) version, this is the number of characters.</param>
/// <returns></returns>
public static int GetClipboardFormatName(ClipboardFormat format, [Out] StringBuilder lpszFormatName,
int cchMaxCount)
{
return Environment.OSVersion.Platform >= PlatformID.Win32NT ? Native.GetClipboardFormatNameW(format, lpszFormatName, cchMaxCount) : Native.GetClipboardFormatNameA(format, lpszFormatName, cchMaxCount);
}
public static extern int GetClipboardFormatNameW(ClipboardFormat format,
[Out] [MarshalAs(UnmanagedType.LPWStr)] StringBuilder
lpszFormatName, int cchMaxCount);
public static extern IntPtr SetClipboardData(ClipboardFormat uFormat, IntPtr hMem);
public static extern IntPtr GetClipboardData(ClipboardFormat uFormat);
/// <summary>
/// The IsClipboardFormatAvailable function determines whether
/// the clipboard contains data in the specified format
/// </summary>
/// <param name="format">Specifies a standard or registered clipboard format</param>
/// <returns>If the clipboard format is available, the return value is true, else false</returns>
public static bool IsClipboardFormatAvailable(ClipboardFormat format)
{
return Native.IsClipboardFormatAvailable(format);
}
private void ClipboardMonitor_OnClipboardChange(ClipboardFormat format, object data)
{
// Do Something...
if (format.ToString() == "Text")
{
string[] URLs = data.ToString().Split(new char[0]);
foreach (string _url in URLs)
{
ListViewItem lvItem;
bool blogExists = false;
string str = this.ExtractBlogname_paste(_url);
if (str != null)
{
this.Invoke((Action)delegate
{
foreach (ListViewItem item in this.lvBlog.Items)
{
if (item.Text.Equals(str))
{
blogExists = true;
return;
}
}
});
if (blogExists)
{
}
else
{
lvItem = new ListViewItem();
{
TumblrBlog newBlog = new TumblrBlog
{
_Name = str,
_URL = this.ExtractUrl(_url),
_DateAdded = DateTime.Now,
_DownloadedImages = 0,
_TotalCount = 0,
_LastCrawled = System.DateTime.MinValue,
_finishedCrawl = false
};
lvItem.Text = newBlog._Name;
lvItem.SubItems.Add("");
lvItem.SubItems.Add("");
lvItem.SubItems.Add(newBlog._URL);
lvItem.SubItems.Add("0.00");
lvItem.SubItems.Add(newBlog._DateAdded.ToString());
lvItem.SubItems.Add("Not yet completely crawled!");
//lvItem.SubItems.Add(newBlog._finishedCrawl.ToString());
this.SaveBlog(newBlog);
newBlog = null;
this.Invoke((Action)delegate
{
this.lvBlog.Items.Add(lvItem);
});
}
if (Directory.Exists(Properties.Settings.Default.configDownloadLocation.ToString() + "Index/"))
{
if (Directory.GetFiles(Properties.Settings.Default.configDownloadLocation.ToString() + "Index/", "*.tumblr").Count<string>() > 0)
{
this.Invoke((Action)delegate
{
this.toolShowExplorer.Enabled = true;
this.toolRemoveBlog.Enabled = true;
this.toolCrawl.Enabled = true;
});
}
else
{
this.Invoke((Action)delegate
{
this.toolShowExplorer.Enabled = false;
this.toolRemoveBlog.Enabled = false;
this.toolCrawl.Enabled = false;
});
}
}
}
}
}
}
}
public void TestFormatToString(ClipboardFormat format, string expected)
{
Clipboard.GetDataObjectFormatString(format).Should().Be(expected);
}
public static extern bool IsClipboardFormatAvailable(ClipboardFormat format);
/// <summary>
/// The GetPriorityClipboardFormat function retrieves the first available clipboard format in the specified list
/// </summary>
/// <param name="paFormatPriorityList">Array of clipboard formats, in priority order</param>
/// <param name="cFormats">Specifies the number of entries in the paFormatPriorityList array. This value must
/// not be greater than the number of entries in the list</param>
/// <returns>If the function succeeds, the return value is the first clipboard format in the list for which data
/// is available. If the clipboard is empty, the return value is null. If the clipboard contains data, but not
/// in any of the specified formats, the return value is –1.</returns>
public static int GetPriorityClipboardFormat(ClipboardFormat[] paFormatPriorityList, int cFormats)
{
return Native.GetPriorityClipboardFormat(paFormatPriorityList, cFormats);
}
/// <summary>
///
/// </summary>
/// <param name="format"></param>
/// <param name="data"></param>
private static void ClipboardWatcher_OnClipboardChange(ClipboardFormat format, object data)
{
if (null != OnClipboardChange)
{
OnClipboardChange(format, data);
}
}
