public bool Upload(ICaptureDetails captureDetails, ISurface surface, out string uploadUrl)
{
SurfaceOutputSettings outputSettings = new SurfaceOutputSettings(_config.UploadFormat, _config.UploadJpegQuality, false);
uploadUrl = null;
try {
string flickrUrl = null;
new PleaseWaitForm().ShowAndWait(Attributes.Name, Language.GetString("flickr", LangKey.communication_wait),
delegate {
string filename = Path.GetFileName(FilenameHelper.GetFilename(_config.UploadFormat, captureDetails));
flickrUrl = FlickrUtils.UploadToFlickr(surface, outputSettings, captureDetails.Title, filename);
}
);
if (flickrUrl == null)
{
return(false);
}
uploadUrl = flickrUrl;
if (_config.AfterUploadLinkToClipBoard)
{
ClipboardHelper.SetClipboardData(flickrUrl);
}
return(true);
} catch (Exception e) {
Log.Error("Error uploading.", e);
MessageBox.Show(Language.GetString("flickr", LangKey.upload_failure) + " " + e.Message);
}
return(false);
}
public void Upload(ICaptureDetails captureDetails, ISurface surface, ExportInformation exportInformation)
{
SurfaceOutputSettings outputSettings = new SurfaceOutputSettings(config.UploadFormat, config.UploadJpegQuality, false);
try {
string flickrUrl = null;
new PleaseWaitForm().ShowAndWait("Flickr plug-in", Language.GetString("flickr", LangKey.communication_wait),
delegate() {
string filename = Path.GetFileName(FilenameHelper.GetFilename(config.UploadFormat, captureDetails));
flickrUrl = FlickrUtils.UploadToFlickr(surface, outputSettings, captureDetails.Title, filename);
}
);
if (flickrUrl == null)
{
exportInformation.ExportMade = false;
return;
}
exportInformation.ExportMade = true;
exportInformation.Uri = flickrUrl;
if (config.AfterUploadLinkToClipBoard)
{
ClipboardHelper.SetClipboardData(flickrUrl);
}
} catch (Exception e) {
MessageBox.Show(Language.GetString("flickr", LangKey.upload_failure) + " " + e.Message);
}
}
public static void LoadHistory()
{
if (config.runtimeFlickrHistory == null)
{
return;
}
if (config.flickrUploadHistory == null)
{
return;
}
if (config.runtimeFlickrHistory.Count == config.flickrUploadHistory.Count)
{
return;
}
// Load the flickr history
List <string> hashes = new List <string>();
foreach (string hash in config.flickrUploadHistory.Keys)
{
hashes.Add(hash);
}
bool saveNeeded = false;
foreach (string hash in hashes)
{
if (config.runtimeFlickrHistory.ContainsKey(hash))
{
// Already loaded
continue;
}
try {
FlickrInfo imgurInfo = FlickrUtils.RetrieveFlickrInfo(hash);
if (imgurInfo != null)
{
FlickrUtils.RetrieveFlickrThumbnail(imgurInfo);
config.runtimeFlickrHistory.Add(hash, imgurInfo);
}
else
{
LOG.DebugFormat("Deleting not found Flickr {0} from config.", hash);
config.flickrUploadHistory.Remove(hash);
saveNeeded = true;
}
} catch (Exception e) {
LOG.Error("Problem loading Flickr history for hash " + hash, e);
}
}
if (saveNeeded)
{
// Save needed changes
IniConfig.Save();
}
}
public SettingsForm(FlickrConfiguration config)
{
//
// The InitializeComponent() call is required for Windows Forms designer support.
//
InitializeComponent();
InitializeTexts();
combobox_uploadimageformat.Items.Clear();
foreach (OutputFormat format in Enum.GetValues(typeof(OutputFormat)))
{
combobox_uploadimageformat.Items.Add(format.ToString());
}
combobox_hiddenFromSearch.Items.Clear();
foreach (FlickrNet.HiddenFromSearch hidden in Enum.GetValues(typeof(FlickrNet.HiddenFromSearch)))
{
combobox_hiddenFromSearch.Items.Add(hidden.ToString());
}
combobox_safetyLevel.Items.Clear();
foreach (FlickrNet.SafetyLevel safetyLevel in Enum.GetValues(typeof(FlickrNet.SafetyLevel)))
{
combobox_safetyLevel.Items.Add(safetyLevel.ToString());
}
comboBox_DefaultSize.Items.Clear();
foreach (PictureDisplaySize displaySize in Enum.GetValues(typeof(PictureDisplaySize)))
{
comboBox_DefaultSize.Items.Add(displaySize.ToString());
}
FlickrUtils.LoadHistory();
if (config.runtimeFlickrHistory.Count > 0)
{
historyButton.Enabled = true;
}
else
{
historyButton.Enabled = false;
}
}
public bool Upload(ICaptureDetails captureDetails, Image image)
{
if (string.IsNullOrEmpty(config.flickrToken))
{
MessageBox.Show(lang.GetString(LangKey.TokenNotSet), string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Information);
return(false);
}
else
{
using (MemoryStream stream = new MemoryStream())
{
BackgroundForm backgroundForm = BackgroundForm.ShowAndWait(Attributes.Name, lang.GetString(LangKey.communication_wait));
host.SaveToStream(image, stream, config.UploadFormat, config.UploadJpegQuality);
byte[] buffer = stream.GetBuffer();
try
{
string filename = Path.GetFileName(host.GetFilename(config.UploadFormat, captureDetails));
FlickrInfo flickrInfo = FlickrUtils.UploadToFlickr(buffer, captureDetails.Title, filename);
if (config.flickrUploadHistory == null)
{
config.flickrUploadHistory = new Dictionary <string, string>();
}
if (flickrInfo.ID != null)
{
LOG.InfoFormat("Storing Flickr upload for id {0}", flickrInfo.ID);
config.flickrUploadHistory.Add(flickrInfo.ID, flickrInfo.ID);
config.runtimeFlickrHistory.Add(flickrInfo.ID, flickrInfo);
}
flickrInfo.Image = FlickrUtils.CreateThumbnail(image, 90, 90);
// Make sure the configuration is save, so we don't lose the deleteHash
IniConfig.Save();
// Make sure the history is loaded, will be done only once
FlickrUtils.LoadHistory();
// Show
if (config.AfterUploadOpenHistory)
{
FlickrHistory.ShowHistory();
}
if (config.AfterUploadLinkToClipBoard)
{
Clipboard.SetText(flickrInfo.LinkUrl(config.PictureDisplaySize));
}
return(true);
}
catch (Exception e)
{
MessageBox.Show(lang.GetString(LangKey.upload_failure) + " " + e.Message);
return(false);
}
finally
{
backgroundForm.CloseDialog();
}
}
}
}
public void HistoryMenuClick(object sender, EventArgs eventArgs)
{
FlickrUtils.LoadHistory();
FlickrHistory.ShowHistory();
}
