void CLoginDlg::Accept()
{
LoginInfo li;
TCHAR Buffer[256];
GetDlgItemText(IDC_LOGINEDIT, Buffer, 256);
li.Login = WCstringToUtf8(Buffer);
if ( li.Login.empty() ) {
MessageBox(TR("Логин не может быть пустым"),TR("Ошибка"), MB_ICONERROR);
return;
}
std::string serverNameA = WCstringToUtf8(serverProfile_.serverName());
if ( !ignoreExistingAccount_ && createNew_ && Settings.ServersSettings[serverNameA].find(li.Login ) != Settings.ServersSettings[serverNameA].end() ) {
MessageBox(TR("Учетная запись с таким именем уже существует."),TR("Ошибка"), MB_ICONERROR);
return;
}
if ( li.Login != WCstringToUtf8(accountName_) ) {
serverProfile_.clearFolderInfo();
}
accountName_ = Buffer;
serverProfile_.setProfileName(Buffer);
GetDlgItemText(IDC_PASSWORDEDIT, Buffer, 256);
li.Password = WCstringToUtf8(Buffer);
li.DoAuth = SendDlgItemMessage(IDC_DOAUTH, BM_GETCHECK) != FALSE;
serverProfile_.serverSettings().authData = li;
EndDialog(IDOK);
}
LRESULT CServerParamsDlg::OnClickedOK(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
std::map<std::string,std::string>::iterator it;
CString login = GuiTools::GetDlgItemText(m_hWnd, IDC_LOGINEDIT);
serverProfile_.setProfileName(login);
ServerSettingsStruct &serverSettings = serverProfile_.serverSettings();
serverSettings.authData.DoAuth = GuiTools::GetCheck(m_hWnd, IDC_DOAUTH);
serverSettings.authData.Login = WCstringToUtf8( login );
serverSettings.authData.Password = WCstringToUtf8( GuiTools::GetDlgItemText(m_hWnd, IDC_PASSWORDEDIT) );
for(it = m_paramNameList.begin(); it!= m_paramNameList.end(); ++it)
{
CString name = it->first.c_str();
CString humanName = it->second.c_str();
HPROPERTY pr = m_wndParamList.FindProperty(humanName);
CComVariant vValue;
pr->GetValue(&vValue);
serverSettings.params[WCstringToUtf8(name)]= WCstringToUtf8(vValue.bstrVal);
}
EndDialog(wID);
return 0;
}
LRESULT CLoginDlg::OnDeleteAccountClicked(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
std::map <std::string, ServerSettingsStruct>& ss = Settings.ServersSettings[WCstringToUtf8(serverProfile_.serverName())];
ss.erase(WCstringToUtf8(accountName_));
accountName_ = "";
EndDialog(IDOK);
return 0;
}
LRESULT CQuickSetupDlg::OnClickedOK(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) {
int serverComboElementIndex = serverComboBox_.GetCurSel();
if ( serverComboElementIndex > 0 ) {
std::string serverNameA = reinterpret_cast<char*>(serverComboBox_.GetItemData(serverComboElementIndex));
CUploadEngineData * uploadEngineData =( (CUploadEngineList *)_EngineList)->byName( serverNameA );
Settings.imageServer.setServerName(Utf8ToWCstring( uploadEngineData->Name )) ;
bool needAuth = GuiTools::GetCheck( m_hWnd, IDC_DOAUTHCHECKBOX );
if ( needAuth ) {
CString login = GuiTools::GetDlgItemText( m_hWnd, IDC_LOGINEDIT );
Settings.imageServer.setProfileName(login);
CString password = GuiTools::GetDlgItemText( m_hWnd, IDC_PASSWORDEDIT );
if ( login.IsEmpty() ) {
MessageBox(TR("Введите данные учетной записи"), APPNAME, MB_ICONEXCLAMATION);
return 0;
}
LoginInfo& loginInfo = Settings.ServersSettings[WCstringToUtf8((LPCTSTR)Settings.getServerName())][WCstringToUtf8((LPCTSTR)(login))].authData;
loginInfo.DoAuth = true;
loginInfo.Login = WCstringToUtf8( login );
loginInfo.Password = WCstringToUtf8( password );
}
Settings.quickScreenshotServer = Settings.imageServer;
Settings.contextMenuServer = Settings.imageServer;
Settings.fileServer.setServerName("zippyshare.com");
} else {
}
GuiTools::GetCheck(m_hWnd, IDC_AUTOSTARTUPCHECKBOX, Settings.AutoStartup);
Settings.AutoStartup_changed = true;
Settings.ExplorerContextMenu = GuiTools::GetCheck(m_hWnd, IDC_EXPLORERINTEGRATION);
Settings.ExplorerContextMenu_changed = Settings.ExplorerContextMenu;
bool capturePrintScreen = GuiTools::GetCheck( m_hWnd, IDC_CAPTUREPRINTSCREENCHECKBOX );
if ( capturePrintScreen ) {
Settings.Hotkeys.getByFunc( _T("regionscreenshot") ).globalKey.DeSerialize("44"); // PrintScreen
Settings.Hotkeys.getByFunc( _T("windowscreenshot") ).globalKey.DeSerialize("65580"); // Alt + PrintScreen
} else {
Settings.Hotkeys.getByFunc( _T("regionscreenshot") ).Clear();
Settings.Hotkeys.getByFunc( _T("windowscreenshot") ).Clear();
}
if ( Settings.AutoStartup || capturePrintScreen ) {
Settings.ShowTrayIcon = true;
Settings.ShowTrayIcon_changed = true;
}
Settings.SaveSettings();
EndDialog(wID);
return 0;
}
LRESULT CNewFolderDlg::OnClickedOK(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
m_sTitle= GuiTools::GetWindowText(GetDlgItem(IDC_FOLDERTITLEEDIT));
m_folder.title = WCstringToUtf8(m_sTitle);
m_sDescription = GuiTools::GetWindowText(GetDlgItem(IDC_FOLDERDESCREDIT));
m_folder.summary = WCstringToUtf8(m_sDescription);
int nAccessType = SendDlgItemMessage(IDC_ACCESSTYPECOMBO, CB_GETCURSEL);
if(nAccessType >= 0)
m_folder.accessType = nAccessType;
EndDialog(wID);
return 0;
}
bool CSettings::LoadAccounts(SimpleXmlNode root)
{
std::vector<SimpleXmlNode> servers;
root.GetChilds("Server", servers);
for (size_t i = 0; i < servers.size(); i++)
{
std::string server_name = servers[i].Attribute("Name");
std::vector<std::string> attribs;
servers[i].GetAttributes(attribs);
ServerSettingsStruct tempSettings;
for (size_t j = 0; j < attribs.size(); j++)
{
std::string attribName = attribs[j];
if (attribName.empty())
continue;
if ( attribName.substr(0, 1) == "_")
{
std::string value = servers[i].Attribute(attribName);
attribName = attribName.substr(1, attribName.size() - 1);
if (!value.empty())
tempSettings.params[attribName] = value;
}
}
tempSettings.authData.DoAuth = servers[i].AttributeBool("Auth");
#if !defined (IU_CLI) && !defined(IU_SHELLEXT)
std::string encodedLogin = servers[i].Attribute("Login");
CEncodedPassword login;
login.fromEncodedData(encodedLogin.c_str());
tempSettings.authData.Login = WCstringToUtf8(login);
std::string encodedPass = servers[i].Attribute("Password");
CEncodedPassword pass;
pass.fromEncodedData(encodedPass.c_str());
tempSettings.authData.Password = WCstringToUtf8(pass);
#else
tempSettings.authData.Login =servers[i].Attribute("Login");
#endif
tempSettings.defaultFolder.setId( servers[i].Attribute("DefaultFolderId"));
tempSettings.defaultFolder.viewUrl = servers[i].Attribute("DefaultFolderUrl");
tempSettings.defaultFolder.setTitle(servers[i].Attribute("DefaultFolderTitle"));
ServersSettings[server_name][tempSettings.authData.Login] = tempSettings ;
}
return true;
}
bool CSettings::SaveAccounts(SimpleXmlNode root)
{
ServerSettingsMap::iterator it1;
for (it1 = ServersSettings.begin(); it1 != ServersSettings.end(); ++it1)
{
std::map <std::string, ServerSettingsStruct>::iterator it;
for (it = it1->second.begin(); it !=it1->second.end(); ++it)
{
ServerSettingsStruct & sss = it->second;
if ( sss.isEmpty() ) {
continue;
}
SimpleXmlNode serverNode = root.CreateChild("Server");
serverNode.SetAttribute("Name", it1->first);
std::map <std::string, std::string>::iterator param;
for (param = it->second.params.begin(); param != sss.params.end(); ++param)
{
if ( param->first == "FolderID" || param->first == "FolderUrl" || param->first == "FolderTitle") {
continue;
}
serverNode.SetAttribute("_" + param->first, param->second);
}
serverNode.SetAttributeBool("Auth", sss.authData.DoAuth);
#if !defined (IU_CLI) && !defined(IU_SHELLEXT)
CEncodedPassword login(Utf8ToWCstring(sss.authData.Login));
serverNode.SetAttribute("Login", WCstringToUtf8(login.toEncodedData()));
CUploadEngineData* ued = _EngineList->byName(Utf8ToWCstring(it->first));
if ( !ued || ued->NeedPassword ) {
CEncodedPassword pass(Utf8ToWCstring(it->second.authData.Password));
serverNode.SetAttribute("Password", WCstringToUtf8(pass.toEncodedData()));
}
#else
serverNode.SetAttribute("Login", sss.authData.Login);
#endif
if ( !it->second.defaultFolder.getId().empty() ) {
serverNode.SetAttributeString("DefaultFolderId", sss.defaultFolder.getId());
serverNode.SetAttributeString("DefaultFolderUrl", sss.defaultFolder.viewUrl);
serverNode.SetAttributeString("DefaultFolderTitle", sss.defaultFolder.getTitle());
}
}
}
return true;
}
DWORD CLoginDlg::Run()
{
CScriptUploadEngine *plugin_ = 0;
if (!m_UploadEngine->PluginName.empty() ) {
LoginInfo li;
CString login =GuiTools::GetDlgItemText(m_hWnd, IDC_LOGINEDIT);
li.Login = WCstringToUtf8(login);
std::string serverNameA = WCstringToUtf8(serverProfile_.serverName());
if ( !ignoreExistingAccount_ && createNew_ && Settings.ServersSettings[serverNameA].find(li.Login ) != Settings.ServersSettings[serverNameA].end() ) {
MessageBox(TR("Учетная запись с таким именем уже существует."),TR("Ошибка"), MB_ICONERROR);
OnProcessFinished();
}
ignoreExistingAccount_ = true;
if ( li.Login != WCstringToUtf8(accountName_) ) {
serverProfile_.clearFolderInfo();
}
accountName_ = login;
serverProfile_.setProfileName(login);
li.Password = WCstringToUtf8(GuiTools::GetDlgItemText(m_hWnd, IDC_PASSWORDEDIT));
li.DoAuth = SendDlgItemMessage(IDC_DOAUTH, BM_GETCHECK) != FALSE;
ServerSettingsStruct& ss = serverProfile_.serverSettings();
ss.authData = li;
plugin_ = iuPluginManager.getPlugin(m_UploadEngine->Name, m_UploadEngine->PluginName, ss);
if ( !plugin_->supportsBeforehandAuthorization() ) {
OnProcessFinished();
return 0;
}
IU_ConfigureProxy(NetworkClient_);
plugin_->setNetworkClient(&NetworkClient_);
int res = plugin_->doLogin();
if ( res ) {
OnProcessFinished();
MessageBox(TR("Авторизация была выполнена успешно"));
Accept();
return 0;
} else {
doLoginLabel_.SetLabel( TR("Не удалось авторизоваться. Попробовать еще раз."));
}
}
OnProcessFinished();
return 0;
}
LRESULT CServerParamsDlg::OnBrowseServerFolders(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) {
CString login = GuiTools::GetDlgItemText(m_hWnd, IDC_LOGINEDIT);
serverProfile_.setProfileName(login);
ServerSettingsStruct& serverSettings = serverProfile_.serverSettings();
CString password = GuiTools::GetDlgItemText(m_hWnd, IDC_PASSWORDEDIT);
serverSettings.authData.Login = WCstringToUtf8(login);
serverSettings.authData.Password = WCstringToUtf8(password);
serverSettings.authData.DoAuth = GuiTools::GetCheck(m_hWnd, IDC_DOAUTH);
CServerFolderSelect folderSelectDlg(serverProfile_);
folderSelectDlg.m_SelectedFolder.id = serverProfile_.folderId();
if ( folderSelectDlg.DoModal() == IDOK ) {
CFolderItem folder = folderSelectDlg.m_SelectedFolder;
if(!folder.id.empty()){
serverProfile_.setFolderId(folder.getId());
serverProfile_.setFolderTitle(folder.getTitle());
serverProfile_.setFolderUrl(folder.viewUrl);
} else {
serverProfile_.setFolderId("");
serverProfile_.setFolderTitle("");
serverProfile_.setFolderUrl("");
}
SetDlgItemText(IDC_FOLDERNAMELABEL, Utf8ToWCstring( folder.getTitle() ));
};
if(!m_pluginLoader)
{
return 0;
}
m_wndParamList.ResetContent();
m_pluginLoader->getServerParamList(m_paramNameList);
std::map<std::string,std::string>::iterator it;
for( it = m_paramNameList.begin(); it!= m_paramNameList.end(); ++it)
{
CString name = it->first.c_str();
CString humanName = it->second.c_str();
m_wndParamList.AddItem( PropCreateSimple(humanName, Utf8ToWCstring(serverSettings.params[WCstringToUtf8(name)])) );
}
return 0;
}
bool CFileDownloader::getNextJob(DownloadFileListItem& item)
{
bool result = false;
m_CS.Lock();
if (!m_fileList.empty() && !m_NeedStop)
{
item = *m_fileList.begin();
std::string url;
url = item.url;
m_fileList.erase(m_fileList.begin());
std::string ext = IuCoreUtils::ExtractFileExt(url);
std::string fileName = IuCoreUtils::ExtractFileName(url);
CString wFileName =
GetUniqFileName(IuCommonFunctions::IUTempFolder + Utf8ToWstring(fileName.c_str()).c_str());
std::string filePath = WCstringToUtf8(wFileName);
// Creating file
FILE* f = _tfopen(wFileName, L"wb");
if (f)
fclose(f);
item.fileName = filePath;
result = true;
}
m_CS.Unlock();
return result;
}
ServerSettingsStruct& ServerProfile::serverSettings() {
ServerSettingsStruct& res = Settings.ServersSettings[WCstringToUtf8((LPCTSTR)serverName_)][WCstringToUtf8((LPCTSTR)profileName_)];
res.setParam("FolderID", folderId_);
res.setParam("FolderUrl", folderUrl_);
res.setParam("FolderTitle", folderTitle_);
return res;
}
bool CFloatingWindow::OnQueueFinished(CFileQueueUploader*) {
m_bIsUploading = false;
bool usedDirectLink = true;
if ( uploadType_ == utImage ) {
CString url;
if ((Settings.UseDirectLinks || lastUploadedItem_.fileListItem.downloadUrl.empty()) && !lastUploadedItem_.fileListItem.imageUrl.empty() )
url = Utf8ToWstring(lastUploadedItem_.fileListItem.imageUrl).c_str();
else if ((!Settings.UseDirectLinks || lastUploadedItem_.fileListItem.imageUrl.empty()) && !lastUploadedItem_.fileListItem.downloadUrl.empty() ) {
url = Utf8ToWstring(lastUploadedItem_.fileListItem.downloadUrl).c_str();
usedDirectLink = false;
}
if (url.IsEmpty())
{
ShowBaloonTip(TR("Не удалось загрузить снимок :("), _T("Image Uploader"));
return true;
}
CHistoryManager* mgr = ZBase::get()->historyManager();
std_tr::shared_ptr<CHistorySession> session = mgr->newSession();
HistoryItem hi;
hi.localFilePath = source_file_name_;
hi.serverName = server_name_;
hi.directUrl = (lastUploadedItem_.fileListItem.imageUrl);
hi.thumbUrl = (lastUploadedItem_.fileListItem.thumbUrl);
hi.viewUrl = (lastUploadedItem_.fileListItem.downloadUrl);
hi.uploadFileSize = lastUploadedItem_.fileListItem.fileSize; // IuCoreUtils::getFileSize(WCstringToUtf8(ImageFileName));
session->AddItem(hi);
if ( Settings.TrayIconSettings.ShortenLinks ) {
std_tr::shared_ptr<UrlShorteningTask> task(new UrlShorteningTask(WCstringToUtf8(url)));
CUploadEngineData *ue = Settings.urlShorteningServer.uploadEngineData();
if ( !ue ) {
ShowImageUploadedMessage(url);
return false;
}
CAbstractUploadEngine * e = _EngineList->getUploadEngine(ue,Settings.urlShorteningServer.serverSettings());
if ( !e ) {
ShowImageUploadedMessage(url);
return false;
}
e->setUploadData(ue);
ServerSettingsStruct& settings = Settings.urlShorteningServer.serverSettings();
e->setServerSettings(settings);
e->setUploadData(ue);
uploadType_ = utShorteningImageUrl;
UploadTaskUserData* uploadTaskUserData = new UploadTaskUserData;
uploadTaskUserData->linkTypeToShorten = usedDirectLink ? _T("ImageUrl") : _T("DownloadUrl");
m_FileQueueUploader->AddUploadTask(task, reinterpret_cast<UploadTaskUserData*>(uploadTaskUserData), e);
m_FileQueueUploader->start();
} else {
ShowImageUploadedMessage(url);
}
}
return true;
}
bool CSettings::LoadConvertProfile(const CString& name, SimpleXmlNode profileNode)
{
SettingsManager mgr;
ImageConvertingParams params;
std::string saveTo = profileNode.Attribute("Name");
if (!name.IsEmpty())
saveTo = WCstringToUtf8(name);
SettingsNode& image = mgr["Image"];
BindConvertProfile(image, params);
mgr.loadFromXmlNode(profileNode);
ConvertProfiles[Utf8ToWCstring( saveTo)] = params;
return true;
}
void CThumbEditor::SaveParams()
{
if(FrameColor.IsWindowEnabled())
thumb_->setColor("FrameColor", COLORREF2RGB(FrameColor.GetColor()));
if(Color1.IsWindowEnabled())
thumb_->setColor("GradientColor1", COLORREF2RGB(Color1.GetColor()));
if(ThumbTextColor.IsWindowEnabled())
thumb_->setColor("TextColor", COLORREF2RGB(ThumbTextColor.GetColor()));
if(StrokeColor.IsWindowEnabled())
thumb_->setColor("StrokeColor", COLORREF2RGB(StrokeColor.GetColor()));
if(Color2.IsWindowEnabled())
thumb_->setColor("GradientColor2", COLORREF2RGB(Color2.GetColor()));
if(thumb_->existsParam("DrawFrame"))
{
bool DrawFrame = SendDlgItemMessage(IDC_DRAWFRAME, BM_GETCHECK)!=0;
thumb_->setParam("DrawFrame", DrawFrame);
}
if(thumb_->existsParam("FrameWidth"))
thumb_->setParam("FrameWidth", GetDlgItemInt(IDC_FRAMEWIDTH));
CString text = GuiTools::GetWindowText(GetDlgItem(IDC_THUMBTEXT));
bool AddText = SendDlgItemMessage(IDC_ADDFILESIZE, BM_GETCHECK)!=0;
thumb_->setParamString("Text", WCstringToUtf8(text));
if(thumb_->existsParam("DrawText"))
thumb_->setParam("DrawText", AddText);
//if(thumb_->existsParam("Font"))
{
CString res;
FontToString(&ThumbFont, res);
thumb_->setParamString("Font", WCstringToUtf8(res));
}
}
bool CSettings::SaveConvertProfiles(SimpleXmlNode root)
{
std::map<CString, ImageConvertingParams>::iterator it;
for (it = ConvertProfiles.begin(); it != ConvertProfiles.end(); ++it)
{
SimpleXmlNode profile = root.CreateChild("Profile");
ImageConvertingParams& params = it->second;
profile.SetAttribute("Name", WCstringToUtf8(it->first));
SettingsManager mgr;
SettingsNode& image = mgr["Image"];
BindConvertProfile(image, params);
mgr.saveToXmlNode(profile);
}
return true;
}
bool CSettings::SaveServerProfiles(SimpleXmlNode root)
{
for ( ServerProfilesMap::iterator it = ServerProfiles.begin(); it != ServerProfiles.end(); ++it) {
SimpleXmlNode serverProfileNode = root.CreateChild("ServerProfile");
std::string profileName = WCstringToUtf8(it->first);
//ServerProfile sp = ;
SettingsManager mgr;
it->second.bind(mgr.root());
mgr["@ServerProfileId"].bind(profileName);
mgr.saveToXmlNode(serverProfileNode);
}
return true;
}
void CHistoryWindow::LoadHistoryFile(CString fileName)
{
m_delayedFileName = fileName;
if(!m_treeView.isRunning())
{
m_treeView.ResetContent();
delete m_historyReader;
m_historyReader = new CHistoryReader();
m_historyReader->loadFromFile(WCstringToUtf8(historyFolder + fileName));
FillList(m_historyReader);
m_delayedFileName = "";
}
else
{
::EnableWindow(GetDlgItem(IDC_MONTHCOMBO), false);
::EnableWindow(GetDlgItem(IDCANCEL), false);
m_treeView.EnableWindow(false);
m_treeView.abortLoadingThreads();
}
}
LRESULT CFloatingWindow::OnShortenUrlClipboard(WORD wNotifyCode, WORD wID, HWND hWndCtl) {
if ( m_FileQueueUploader && m_FileQueueUploader->IsRunning() ) {
return false;
}
delete m_FileQueueUploader;
m_FileQueueUploader = new CFileQueueUploader;
m_FileQueueUploader->setCallback(this);
CString url;
WinUtils::GetClipboardText(url);
if ( !url.IsEmpty() && !WebUtils::DoesTextLookLikeUrl(url) ) {
return false;
}
std_tr::shared_ptr<UrlShorteningTask> task(new UrlShorteningTask(WCstringToUtf8(url)));
CUploadEngineData *ue = Settings.urlShorteningServer.uploadEngineData();
CAbstractUploadEngine * e = _EngineList->getUploadEngine(ue, Settings.urlShorteningServer.serverSettings());
if ( !e ) {
return false;
}
e->setUploadData(ue);
ServerSettingsStruct& settings = Settings.urlShorteningServer.serverSettings();
e->setServerSettings(settings);
e->setUploadData(ue);
uploadType_ = utUrl;
m_FileQueueUploader->AddUploadTask(task, 0, e);
m_FileQueueUploader->start();
CString msg;
msg.Format(TR("Cокращаю ссылку \"%s\" с помощью %s"), (LPCTSTR)url,
(LPCTSTR)Utf8ToWstring(ue->Name).c_str());
ShowBaloonTip(msg, _T("Image Uploader"));
return 0;
}
LRESULT CHistoryWindow::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
CenterWindow();
DlgResize_Init();
m_treeView.SubclassWindow(GetDlgItem(IDC_HISTORYTREE));
m_treeView.onThreadsFinished.bind(this, &CHistoryWindow::threadsFinished);
m_treeView.onThreadsStarted.bind(this, &CHistoryWindow::threadsStarted);
TRC(IDCANCEL, "Закрыть");
TRC(IDC_SESSIONSCOUNTDESCR, "Всего сессий:");
TRC(IDC_FILESCOUNTDESCR, "Всего файлов:");
TRC(IDC_UPLOADTRAFFICDESCR, "Общий объем:");
SetWindowText(TR("История загрузок"));
TRC(IDC_TIMEPERIODLABEL, "Период времени:");
TRC(IDC_DOWNLOADTHUMBS, "Загружать миниатюры из Интернета");
HWND hWnd = GetDlgItem(IDC_ANIMATIONSTATIC);
if (hWnd)
{
m_wndAnimation.SubclassWindow(hWnd);
if (m_wndAnimation.Load(MAKEINTRESOURCE(IDR_PROGRESSGIF),_T("GIF")))
m_wndAnimation.Draw();
m_wndAnimation.ShowWindow(SW_HIDE);
}
std::string fName = ZBase::get()->historyManager()->makeFileName();
std::vector<CString> files;
historyFolder = IuCoreUtils::Utf8ToWstring(Settings.SettingsFolder).c_str()+CString(_T("\\History\\"));
WinUtils::GetFolderFileList(files, historyFolder , _T("history*.xml"));
pcrepp::Pcre regExp("history_(\\d+)_(\\d+)", "imcu");
for(size_t i=0; i<files.size(); i++)
{
m_HistoryFiles.push_back(files[i]);
CString monthLabel = Utf8ToWCstring( IuCoreUtils::ExtractFileNameNoExt(WCstringToUtf8 (files[i])));
size_t pos = 0;
if ( regExp.search(WCstringToUtf8(monthLabel), pos) ) {
std::string yearStr = regExp[0];
std::string monthStr = regExp[1];
int year = atoi(yearStr.c_str());
int month = atoi(monthStr.c_str());
monthLabel.Format(_T("%d/%02d"), year, month);
} else {
monthLabel.Replace(_T("history_"), _T(""));
monthLabel.Replace(_T("_"), _T("/"));
}
int newItemIndex = SendDlgItemMessage(IDC_MONTHCOMBO, CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)monthLabel);
if ( newItemIndex >=0 ) {
SendDlgItemMessage(IDC_MONTHCOMBO, CB_SETITEMDATA, newItemIndex, (LPARAM)i);
}
}
int selectedIndex = files.size()-1;
SendDlgItemMessage(IDC_MONTHCOMBO, CB_SETCURSEL, selectedIndex, 0);
SendDlgItemMessage(IDC_DOWNLOADTHUMBS, BM_SETCHECK, (WPARAM)Settings.HistorySettings.EnableDownloading);
BOOL bDummy;
OnMonthChanged(0,0, 0,bDummy);
m_treeView.SetFocus();
return 1; // Let the system set the focus
}
bool CSettings::LoadSettings(std::string szDir, std::string fileName, bool LoadFromRegistry ) {
fileName_ = !szDir.empty() ? szDir + ( (!fileName .empty())? fileName : "Settings.xml")
: SettingsFolder + ( !fileName.empty() ? fileName : "Settings.xml");
//std::cout<< fileName_;
//MessageBoxA(0,fileName_.c_str(),0,0);
if ( !IuCoreUtils::FileExists( fileName_) ) {
return true;
}
SimpleXml xml;
xml.LoadFromFile( fileName_ );
mgr_.loadFromXmlNode( xml.getRoot("ImageUploader").GetChild("Settings") );
SimpleXmlNode settingsNode = xml.getRoot( "ImageUploader" ).GetChild( "Settings" );
#if !defined(IU_CLI) && !defined( IU_SHELLEXT) && !defined(IU_SERVERLISTTOOL)
std::string temp;
if ( !settingsNode["Image"]["Format"].IsNull() ) {
// for compatibility with old version configuration file
LoadConvertProfile( "Old profile", settingsNode );
}
if ( CmdLine.IsOption(_T("afterinstall") )) {
if ( CmdLine.IsOption(_T("usenewicon") )) {
UseNewIcon = true;
} else {
UseNewIcon = false;
}
SaveSettings();
}
// Migrating from 1.3.0 to 1.3.1 (added ImageEditor has been addded)
if (settingsNode["ImageEditor"].IsNull() ) {
if ( Settings.TrayIconSettings.TrayScreenshotAction == TRAY_SCREENSHOT_UPLOAD ) {
TrayIconSettings.TrayScreenshotAction = TRAY_SCREENSHOT_OPENINEDITOR;
}
}
LoadConvertProfiles( settingsNode.GetChild("Image").GetChild("Profiles") );
LoadServerProfiles( settingsNode.GetChild("Uploading").GetChild("ServerProfiles") );
#endif
LoadAccounts( xml.getRoot( "ImageUploader" ).GetChild( "Settings" ).GetChild( "ServersParams" ) );
#if !defined(IU_CLI) && !defined( IU_SHELLEXT) && !defined(IU_SERVERLISTTOOL)
// Fixing profies
if ( !imageServer.profileName().IsEmpty() && ServersSettings[WCstringToUtf8(imageServer.serverName())].find(WCstringToUtf8(imageServer.profileName())) == ServersSettings[WCstringToUtf8(imageServer.serverName())].end() ) {
imageServer.setProfileName("");
}
if ( !fileServer.profileName().IsEmpty() && ServersSettings[WCstringToUtf8(fileServer.serverName())].find(WCstringToUtf8(fileServer.profileName())) == ServersSettings[WCstringToUtf8(fileServer.serverName())].end() ) {
fileServer.setProfileName("");
}
if ( !contextMenuServer.profileName().IsEmpty() && ServersSettings[WCstringToUtf8(contextMenuServer.serverName())].find(WCstringToUtf8(contextMenuServer.profileName())) == ServersSettings[WCstringToUtf8(contextMenuServer.serverName())].end() ) {
contextMenuServer.setProfileName("");
}
if ( !quickScreenshotServer.profileName().IsEmpty() && ServersSettings[WCstringToUtf8(quickScreenshotServer.serverName())].find(WCstringToUtf8(quickScreenshotServer.profileName())) == ServersSettings[WCstringToUtf8(quickScreenshotServer.serverName())].end() ) {
quickScreenshotServer.setProfileName("");
}
if ( !urlShorteningServer.profileName().IsEmpty() && ServersSettings[WCstringToUtf8(urlShorteningServer.serverName())].find(WCstringToUtf8(urlShorteningServer.profileName())) == ServersSettings[WCstringToUtf8(urlShorteningServer.serverName())].end() ) {
urlShorteningServer.setProfileName("");
}
if ( UploadBufferSize == 65536) {
UploadBufferSize = 1024 * 1024;
}
#endif
#if !defined(IU_CLI) && !defined(IU_SERVERLISTTOOL)
// Loading some settings from registry
if ( LoadFromRegistry ) {
CRegistry Reg;
Reg.SetRootKey( HKEY_LOCAL_MACHINE );
if ( Reg.SetKey("Software\\Zenden.ws\\Image Uploader", false ) ) {
ExplorerContextMenu = Reg.ReadBool("ExplorerContextMenu", false);
} else {
ExplorerContextMenu = false;
}
}
CRegistry Reg;
Reg.SetRootKey( HKEY_CURRENT_USER );
if ( Reg.SetKey("Software\\Zenden.ws\\Image Uploader", false ) ) {
ExplorerCascadedMenu = Reg.ReadBool( "ExplorerCascadedMenu", true);
ExplorerVideoContextMenu = Reg.ReadBool( "ExplorerVideoContextMenu", true);
}
CRegistry Reg2;
Reg2.SetRootKey(HKEY_CURRENT_USER);
if ( Reg2.SetKey("Software\\Zenden.ws\\Image Uploader", false ) ) {
AutoStartup = Reg2.ReadBool("AutoStartup", false);
}
if ( VideoSettings.Engine != VideoEngineDirectshow && VideoSettings.Engine != VideoEngineFFmpeg && VideoSettings.Engine != VideoEngineAuto ){
VideoSettings.Engine = VideoEngineAuto;
}
if ( !IsFFmpegAvailable() ){
VideoSettings.Engine = VideoEngineDirectshow;
}
#endif
return true;
}
inline std::string myToString(const CHotkeyList& value) {
return WCstringToUtf8(value.toString());
}
inline std::string myToString(const CEncodedPassword& value) {
return WCstringToUtf8(value.toEncodedData());
}
/* LOGFONT serialization support */
inline std::string myToString(const LOGFONT& value) {
CString res;
FontToString( &value, res );
return WCstringToUtf8(res);
}
LRESULT CServerParamsDlg::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
CenterWindow(GetParent());
TRC(IDCANCEL, "Отмена");
TRC(IDOK, "OK");
TRC(IDC_LOGINLABEL, "Логин:");
TRC(IDC_PASSWORDLABEL, "Пароль:");
TRC(IDC_DOAUTH, "Выполнять авторизацию");
TRC(IDC_FOLDERLABEL, "Папка/альбом:");
TRC(IDC_BROWSESERVERFOLDERS, "Выбрать...");
TRC(IDC_PARAMETERSLABEL, "Параметры:");
DlgResize_Init();
CString WindowTitle;
CString serverName = Utf8ToWCstring(m_ue->Name);
WindowTitle.Format(TR("Параметры сервера %s"),(LPCTSTR)serverName);
SetWindowText(WindowTitle);
GuiTools::ShowDialogItem(m_hWnd, IDC_BROWSESERVERFOLDERS, m_ue->SupportsFolders);
GuiTools::ShowDialogItem(m_hWnd, IDC_FOLDERLABEL, m_ue->SupportsFolders);
GuiTools::ShowDialogItem(m_hWnd, IDC_FOLDERNAMELABEL, m_ue->SupportsFolders);
::EnableWindow(GetDlgItem(IDC_BROWSESERVERFOLDERS), m_ue->SupportsFolders);
GuiTools::ShowDialogItem(m_hWnd, IDC_DOAUTH, m_ue->NeedAuthorization == CUploadEngineData::naAvailable );
GuiTools::ShowDialogItem(m_hWnd, IDC_FOLDERLABEL, m_ue->SupportsFolders );
GuiTools::ShowDialogItem(m_hWnd, IDC_FOLDERNAMELABEL, m_ue->SupportsFolders );
GuiTools::ShowDialogItem(m_hWnd, IDC_BROWSESERVERFOLDERS, m_ue->SupportsFolders );
GuiTools::ShowDialogItem(m_hWnd, IDC_FOLDERICON, m_ue->SupportsFolders );
ServerSettingsStruct &serverSettings = serverProfile_.serverSettings();
LoginInfo li = serverSettings.authData;
SetDlgItemText(IDC_LOGINEDIT, Utf8ToWCstring(li.Login));
oldLogin_ = Utf8ToWCstring(li.Login);
SetDlgItemText(IDC_PASSWORDEDIT, Utf8ToWCstring(li.Password));
SendDlgItemMessage(IDC_DOAUTH, BM_SETCHECK, (li.DoAuth ? BST_CHECKED : BST_UNCHECKED));
doAuthChanged();
int result = 1;
if ( focusOnLoginControl_ && m_ue->NeedAuthorization ) {
GuiTools::SetCheck(m_hWnd, IDC_DOAUTH, true);
doAuthChanged();
::SetFocus(GetDlgItem(IDC_LOGINEDIT) );
SendDlgItemMessage(IDC_LOGINEDIT, EM_SETSEL, 0, -1);
result = 0;
}
GuiTools::EnableDialogItem(m_hWnd, IDC_BROWSESERVERFOLDERS, !oldLogin_.IsEmpty());
m_wndParamList.SubclassWindow(GetDlgItem(IDC_PARAMLIST));
m_wndParamList.SetExtendedListStyle(PLS_EX_SHOWSELALWAYS | PLS_EX_SINGLECLICKEDIT);
m_pluginLoader = iuPluginManager.getPlugin(m_ue->Name, m_ue->PluginName,serverSettings);
if(!m_pluginLoader)
{
return 0;
}
m_pluginLoader->getServerParamList(m_paramNameList);
std::map<std::string,std::string>::iterator it;
for( it = m_paramNameList.begin(); it!= m_paramNameList.end(); ++it)
{
CString name = it->first.c_str();
CString humanName = it->second.c_str();
m_wndParamList.AddItem( PropCreateSimple(humanName, Utf8ToWCstring(serverSettings.params[WCstringToUtf8(name)])) );
}
CString folderTitle = Utf8ToWCstring( serverProfile_.folderTitle()) ;
SetDlgItemText(IDC_FOLDERNAMELABEL, folderTitle.IsEmpty() ? (CString("<") + TR("не выбран") + CString(">")) : folderTitle);
return 1; // Let the system set the focus
}
void CFloatingWindow::UploadScreenshot(const CString& realName, const CString& displayName)
{
delete m_FileQueueUploader;
m_FileQueueUploader = 0;
lastUploadedItem_.fileListItem = CFileQueueUploader::FileListItem();
lastUploadedItem_.imageUrlShortened.Empty();
lastUploadedItem_.downloadUrlShortened.Empty();
m_FileQueueUploader = new CFileQueueUploader();
m_FileQueueUploader->setCallback(this);
ServerProfile &serverProfile = Settings.quickScreenshotServer;
CUploadEngineData* engineData = serverProfile.uploadEngineData();
if (!engineData)
engineData = _EngineList->byIndex(_EngineList->getRandomImageServer());
if (!engineData)
return;
CImageConverter imageConverter;
Thumbnail thumb;
CString templateName = Settings.quickScreenshotServer.getImageUploadParams().getThumb().TemplateName;
if ( templateName.IsEmpty() ) {
templateName = _T("default");
}
CString thumbTemplateFileName = IuCommonFunctions::GetDataFolder() + _T("\\Thumbnails\\") + templateName +
_T(".xml");
if (!thumb.LoadFromFile(WCstringToUtf8(thumbTemplateFileName)))
{
WriteLog(logError, _T("CFloatingWindow"), TR("Не могу загрузить файл миниатюры!")+CString(_T("\r\n")) + thumbTemplateFileName);
return;
}
imageConverter.setEnableProcessing(Settings.quickScreenshotServer.getImageUploadParams().ProcessImages);
imageConverter.setImageConvertingParams(Settings.ConvertProfiles[Settings.quickScreenshotServer.getImageUploadParams().ImageProfileName]);
imageConverter.setThumbCreatingParams(Settings.quickScreenshotServer.getImageUploadParams().getThumb());
bool GenThumbs = Settings.quickScreenshotServer.getImageUploadParams().CreateThumbs &&
((!Settings.quickScreenshotServer.getImageUploadParams().UseServerThumbs) || (!engineData->SupportThumbnails));
imageConverter.setThumbnail(&thumb);
imageConverter.setGenerateThumb(GenThumbs);
imageConverter.Convert(realName);
CAbstractUploadEngine* engine = _EngineList->getUploadEngine(engineData, serverProfile.serverSettings());
if (!engine)
return;
m_FileQueueUploader->setUploadSettings(engine);
source_file_name_ = WCstringToUtf8(realName);
server_name_ = engineData->Name;
std::string utf8FileName = WCstringToUtf8(imageConverter.getImageFileName());
lastUploadedItem_.fileListItem.fileSize = IuCoreUtils::getFileSize(utf8FileName);
m_FileQueueUploader->AddFile(utf8FileName, WCstringToUtf8(displayName), 0, engine);
CString thumbFileName = imageConverter.getThumbFileName();
if (!thumbFileName.IsEmpty())
m_FileQueueUploader->AddFile(WCstringToUtf8(thumbFileName), WCstringToUtf8(thumbFileName),
reinterpret_cast<void*>(1), engine);
m_bIsUploading = true;
uploadType_ = utImage;
m_FileQueueUploader->start();
CString msg;
msg.Format(TR("Идет загрузка \"%s\" на сервер %s"), (LPCTSTR) GetOnlyFileName(displayName),
(LPCTSTR)Utf8ToWstring(engineData->Name).c_str());
ShowBaloonTip(msg, TR("Загрузка снимка"));
}
