void enum_csv_dictionaries(const char *path,
std::vector<std::string> *dics) {
dics->clear();
#if defined(_WIN32) && !defined(__CYGWIN__)
WIN32_FIND_DATAW wfd;
HANDLE hFind;
const std::wstring pat = Utf8ToWide(create_filename(path, "*.csv"));
hFind = ::FindFirstFileW(pat.c_str(), &wfd);
CHECK_DIE(hFind != INVALID_HANDLE_VALUE)
<< "Invalid File Handle. Get Last Error reports";
do {
std::string tmp = create_filename(path, WideToUtf8(wfd.cFileName));
dics->push_back(tmp);
} while (::FindNextFileW(hFind, &wfd));
::FindClose(hFind);
#else
DIR *dir = opendir(path);
CHECK_DIE(dir) << "no such directory: " << path;
for (struct dirent *dp = readdir(dir);
dp;
dp = readdir(dir)) {
const std::string tmp = dp->d_name;
if (tmp.size() >= 5) {
std::string ext = tmp.substr(tmp.size() - 4, 4);
toLower(&ext);
if (ext == ".csv") {
dics->push_back(create_filename(path, tmp));
}
}
}
closedir(dir);
#endif
}
int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPTSTR lpstrCmdLine, int nCmdShow) {
g_hInstance = hInstance;
json_value* appSettings = GetApplicationSettings();
if (GetApplicationSettingsError().length()) {
std::string error = GetApplicationSettingsError();
error.append("\nApplication will terminate immediately. ");
FatalError(NULL, error);
}
// Debugging options.
bool show_console = (*appSettings)["debugging"]["show_console"];
bool subprocess_show_console = (*appSettings)["debugging"]["subprocess_show_console"];
std::string log_level = (*appSettings)["debugging"]["log_level"];
std::string log_file = (*appSettings)["debugging"]["log_file"];
log_file = GetAbsolutePath(log_file);
// Initialize logging.
if (std::wstring(lpstrCmdLine).find(L"--type=") != std::string::npos) {
// This is a subprocess.
InitializeLogging(subprocess_show_console, log_level, log_file);
} else {
// Main browser process.
InitializeLogging(show_console, log_level, log_file);
}
// Command line arguments
LPWSTR *argv;
int argc;
argv = CommandLineToArgvW(GetCommandLineW(), &argc);
if (argv) {
for (int i = 0; i < argc; i++) {
std::string argument = WideToUtf8(std::wstring(argv[i]));
size_t pos = argument.find("=");
if (pos != std::string::npos) {
std::string name = argument.substr(0, pos);
std::string value = argument.substr(pos+1, std::string::npos);
if (name == "--cgi-environment" && value.length()) {
g_cgiEnvironmentFromArgv.assign(value);
}
}
}
} else {
LOG_WARNING << "CommandLineToArgvW() failed";
}
// CEF subprocesses.
CefMainArgs main_args(hInstance);
CefRefPtr<App> app(new App);
int exit_code = CefExecuteProcess(main_args, app.get(), NULL);
if (exit_code >= 0) {
ShutdownLogging();
return exit_code;
}
LOG_INFO << "--------------------------------------------------------";
LOG_INFO << "Started application";
if (log_file.length())
LOG_INFO << "Logging to: " << log_file;
else
LOG_INFO << "No logging file set";
LOG_INFO << "Log level = "
<< FILELog::ToString(FILELog::ReportingLevel());
// Main window title option.
std::string main_window_title = (*appSettings)["main_window"]["title"];
if (main_window_title.empty())
main_window_title = GetExecutableName();
// Single instance guid option.
const char* single_instance_guid =
(*appSettings)["application"]["single_instance_guid"];
if (single_instance_guid && single_instance_guid[0] != 0) {
int guidSize = strlen(single_instance_guid) + 1;
g_singleInstanceApplicationGuid = new wchar_t[guidSize];
Utf8ToWide(single_instance_guid, g_singleInstanceApplicationGuid,
guidSize);
}
if (g_singleInstanceApplicationGuid
&& g_singleInstanceApplicationGuid[0] != 0) {
g_singleInstanceApplication.Initialize(
g_singleInstanceApplicationGuid);
if (g_singleInstanceApplication.IsRunning()) {
HWND hwnd = FindWindow(g_singleInstanceApplicationGuid, NULL);
if (hwnd) {
if (IsIconic(hwnd))
ShowWindow(hwnd, SW_RESTORE);
SetForegroundWindow(hwnd);
return 0;
}
}
}
// Window class name.
if (g_singleInstanceApplicationGuid) {
swprintf_s(g_windowClassName, _countof(g_windowClassName), L"%s",
g_singleInstanceApplicationGuid);
} else {
swprintf_s(g_windowClassName, _countof(g_windowClassName), L"%s",
Utf8ToWide(GetExecutableName()).c_str());
}
if (!StartWebServer()) {
FatalError(NULL, "Error while starting an internal local server.\n"
"Application will terminate immediately.");
}
CefSettings cef_settings;
// log_file
std::string chrome_log_file = (*appSettings)["chrome"]["log_file"];
chrome_log_file = GetAbsolutePath(chrome_log_file);
CefString(&cef_settings.log_file) = chrome_log_file;
// log_severity
std::string chrome_log_severity = (*appSettings)["chrome"]["log_severity"];
cef_log_severity_t log_severity = LOGSEVERITY_DEFAULT;
if (chrome_log_severity == "verbose") {
log_severity = LOGSEVERITY_VERBOSE;
} else if (chrome_log_severity == "info") {
log_severity = LOGSEVERITY_INFO;
} else if (chrome_log_severity == "warning") {
log_severity = LOGSEVERITY_WARNING;
} else if (chrome_log_severity == "error") {
log_severity = LOGSEVERITY_ERROR;
} else if (chrome_log_severity == "error-report") {
log_severity = LOGSEVERITY_ERROR_REPORT;
} else if (chrome_log_severity == "disable") {
log_severity = LOGSEVERITY_DISABLE;
}
cef_settings.log_severity = log_severity;
// cache_path
std::string cache_path = (*appSettings)["chrome"]["cache_path"];
cache_path = GetAbsolutePath(cache_path);
CefString(&cef_settings.cache_path) = cache_path;
// remote_debugging_port
// A value of -1 will disable remote debugging.
int remote_debugging_port = static_cast<long>(
(*appSettings)["chrome"]["remote_debugging_port"]);
if (remote_debugging_port == 0) {
remote_debugging_port = random(49152, 65535+1);
int i = 100;
while (((i--) > 0) && remote_debugging_port == GetWebServerPort()) {
remote_debugging_port = random(49152, 65535+1);
}
}
if (remote_debugging_port > 0) {
LOG_INFO << "remote_debugging_port = " << remote_debugging_port;
cef_settings.remote_debugging_port = remote_debugging_port;
}
// Sandbox support
cef_settings.no_sandbox = true;
CefInitialize(main_args, cef_settings, app.get(), NULL);
CreateMainWindow(hInstance, nCmdShow, main_window_title);
CefRunMessageLoop();
CefShutdown();
LOG_INFO << "Ended application";
LOG_INFO << "--------------------------------------------------------";
ShutdownLogging();
return 0;
}
std::string GetRealPath(std::string path) {
wchar_t realPath[MAX_PATH];
GetFullPathName(Utf8ToWide(path).c_str(), _countof(realPath), realPath,
NULL);
return WideToUtf8(realPath);
}
void SendSkypeMsgToIRC(const CReceivedSkypeMsg *a_msg)
{
CString l_msgBuffer;
if(a_msg->timestamp < time(0) - 120 && !a_msg->edited)
{
char l_timeBuf[100];
strftime(l_timeBuf, 100, "[%a %H:%M:%S] ", localtime(&a_msg->timestamp));
l_msgBuffer = l_timeBuf;
}
if(!a_msg->edited)
{
if(a_msg->type == "EMOTED")
{
l_msgBuffer += a_msg->fromDispname + " ";
}
else
{
l_msgBuffer += "<" + a_msg->fromDispname + "> ";
}
l_msgBuffer += a_msg->body;
}
else
{
char l_timeBuf[100];
strftime(l_timeBuf, 100, "%H:%M:%S", localtime(&a_msg->timestamp));
if(a_msg->body == "[deleted]")
{
l_msgBuffer += "(" + a_msg->fromDispname + " deleted their message from " + CString(l_timeBuf) + ")";
}
else
{
l_msgBuffer += a_msg->fromDispname + " edited their message from " + CString(l_timeBuf) + ": " + a_msg->body;
}
}
l_msgBuffer.Replace("\r", "");
l_msgBuffer.Replace("\n", " ");
for(MCString::iterator it = m_chanNameMap.begin(); it != m_chanNameMap.end(); it++)
{
if(it->second.Equals(a_msg->chatName))
{
std::wstring l_buffer = Utf8ToWide(l_msgBuffer);
std::wstring l_line;
CString l_utfLine;
do
{
l_line = l_buffer.substr(0, 400);
l_buffer.erase(0, 400);
if(!l_buffer.empty())
{
l_line += L"...";
l_buffer = L"..." + l_buffer;
}
l_utfLine = WideToUtf8(l_line);
PutIRC("PRIVMSG " + it->first + " :" + l_utfLine);
PutUser(":" + m_pUser->GetIRCNick().GetNick() + "!x@y PRIVMSG " + it->first + " :" + l_utfLine);
} while(!l_buffer.empty());
return;
}
}
PutModule("WARNING: Group chat " + a_msg->chatName + " not mapped to any channel. A message has been lost.");
}
bool load_dictionary_resource(Param *param) {
//debug
std::cout << "[" << __FILE__ << ":" << __LINE__ << "]: "
<< "load_dictionary_resource(Param *param)" << std::endl;
///
std::string rcfile = param->get<std::string>("rcfile");
#ifdef HAVE_GETENV
if (rcfile.empty()) {
//debug
std::cout << "[" << __FILE__ << ":" << __LINE__ << "]: "
<< "rcfile.empty()" << std::endl;
///
const char *homedir = getenv("HOME");
if (homedir) {
const std::string s = MeCab::create_filename(std::string(homedir),
".mecabrc");
std::ifstream ifs(WPATH(s.c_str()));
if (ifs) {
rcfile = s;
}
}
}
if (rcfile.empty()) {
const char *rcenv = getenv("MECABRC");
if (rcenv) {
rcfile = rcenv;
}
}
#endif
#if defined (HAVE_GETENV) && defined(_WIN32) && !defined(__CYGWIN__)
if (rcfile.empty()) {
scoped_fixed_array<wchar_t, BUF_SIZE> buf;
const DWORD len = ::GetEnvironmentVariableW(L"MECABRC",
buf.get(),
buf.size());
if (len < buf.size() && len > 0) {
rcfile = WideToUtf8(buf.get());
}
}
#endif
#if defined(_WIN32) && !defined(__CYGWIN__)
HKEY hKey;
scoped_fixed_array<wchar_t, BUF_SIZE> v;
DWORD vt;
DWORD size = v.size() * sizeof(v[0]);
if (rcfile.empty()) {
::RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"software\\mecab", 0, KEY_READ, &hKey);
::RegQueryValueExW(hKey, L"mecabrc", 0, &vt,
reinterpret_cast<BYTE *>(v.get()), &size);
::RegCloseKey(hKey);
if (vt == REG_SZ) {
rcfile = WideToUtf8(v.get());
}
}
if (rcfile.empty()) {
::RegOpenKeyExW(HKEY_CURRENT_USER, L"software\\mecab", 0, KEY_READ, &hKey);
::RegQueryValueExW(hKey, L"mecabrc", 0, &vt,
reinterpret_cast<BYTE *>(v.get()), &size);
::RegCloseKey(hKey);
if (vt == REG_SZ) {
rcfile = WideToUtf8(v.get());
}
}
if (rcfile.empty()) {
vt = ::GetModuleFileNameW(DllInstance, v.get(), size);
if (vt != 0) {
scoped_fixed_array<wchar_t, _MAX_DRIVE> drive;
scoped_fixed_array<wchar_t, _MAX_DRIVE> dir;
_wsplitpath(v.get(), drive.get(), dir.get(), NULL, NULL);
const std::wstring path =
std::wstring(drive.get()) + std::wstring(dir.get()) + L"mecabrc";
if (::GetFileAttributesW(path.c_str()) != -1) {
rcfile = WideToUtf8(path);
}
}
}
#endif
if (rcfile.empty()) {
rcfile = MECAB_DEFAULT_RC;
}
if (!param->load(rcfile.c_str())) {
return false;
}
std::string dicdir = param->get<std::string>("dicdir");
if (dicdir.empty()) {
dicdir = "."; // current
}
remove_filename(&rcfile);
replace_string(&dicdir, "$(rcpath)", rcfile);
param->set<std::string>("dicdir", dicdir, true);
dicdir = create_filename(dicdir, DICRC);
if (!param->load(dicdir.c_str())) {
return false;
}
return true;
}
inline std::string NarrowToUtf8(const char* narrow_sz)
{
return WideToUtf8(NarrowToWide(narrow_sz));
}
inline std::string WideToUtf8(const std::wstring& wide_str)
{
return WideToUtf8(wide_str.c_str());
}
