{

public:

DDEServer(MainFrame* frame) : m_Frame(frame) { ; }

wxConnectionBase *OnAcceptConnection(const wxString& topic);

MainFrame* GetFrame() { return m_Frame; }

void SetFrame(MainFrame* frame) { m_Frame = frame; }

private:

MainFrame* m_Frame;

{

public:

DDEConnection(MainFrame* frame) : m_Frame(frame) { ; }

#if wxCHECK_VERSION(2, 9, 5)

bool OnExecute(const wxString& topic, const void *data, size_t size, wxIPCFormat format);

#else

bool OnExecute(const wxString& topic, wxChar *data, int size, wxIPCFormat format);

#endif

bool OnDisconnect();

private:

MainFrame* m_Frame;

#endif

{

wxString strData((wxChar*)data);

if (strData.StartsWith(_T("[IfExec_Open(\"")))

return false; // let Shell Open handle the request as we *know* that we have registered the Shell Open command, too

if (strData.StartsWith(_T("[Open(\"")))

{

wxRegEx reCmd(_T("\"(.*)\""));

if (reCmd.Matches(strData))

{

const wxString file = reCmd.GetMatch(strData, 1);

// always put files in the delayed queue, the will either be loaded in OnDisconnect, or after creating of MainFrame

// if we open the files directly it can lead to an applicaton hang (at least when opening C::B's project-file on linux)

CodeBlocksApp* cb = (CodeBlocksApp*)wxTheApp;

if (cb)

cb->AddFileToOpenDelayed(file);

}

return true;

}

else if (strData.StartsWith(_T("[OpenLine(\"")))

{

wxRegEx reCmd(_T("\"(.*)\""));

if (reCmd.Matches(strData))

{

wxString file = reCmd.GetMatch(strData, 1);

CodeBlocksApp* cb = (CodeBlocksApp*)wxTheApp;

cb->SetAutoFile(file);

}

return true;

}

else if (strData.StartsWith(_T("[Raise]")))

{

if (m_Frame)

{

if (m_Frame->IsIconized())

m_Frame->Iconize(false);

m_Frame->Raise();

}

return true;

}

else if (strData.StartsWith(_T("[CmdLine({")))

{

int pos = strData.Find(_T("})]"));

if (pos!=wxNOT_FOUND)

{

wxString line = strData.Mid(10, pos-10);

line.Replace(_T("\\)"), _T(")"));

line.Replace(_T("\\("), _T("("));

CodeBlocksApp* cb = (CodeBlocksApp*)wxTheApp;

if (m_Frame && !line.empty())

{

// Manager::Get()->GetLogManager()->Log(wxString::Format(_T("DDEConnection::OnExecute line = ") + line));

cb->ParseCmdLine(m_Frame, line);

CodeBlocksEvent event(cbEVT_APP_CMDLINE);

Manager::Get()->ProcessEvent(event);

}

}

return true;

}

wxSafeShowMessage(wxT("Warning"),wxString::Format(wxT("DDE topic %s not handled."),strData.wx_str()));

return false;

{

// delayed files will be loaded automatically if MainFrame already exists,

// otherwise it happens automatically in OnInit after MainFrame is created

if (!s_Loading && m_Frame)

{

CodeBlocksApp* cb = (CodeBlocksApp*)wxTheApp;

cb->LoadDelayedFiles(m_Frame);

}

return true;

public:

DDEClient(void) {}

wxConnectionBase *OnMakeConnection(void) { return new DDEConnection(nullptr); }

{

public:

Splash(const bool show) : m_pSplash(nullptr)

{

if (show)

{

wxBitmap bmp = cbLoadBitmap(ConfigManager::ReadDataPath() + _T("/images/splash_1312.png"));

m_pSplash = new cbSplashScreen(bmp, -1, nullptr, -1, wxNO_BORDER | wxFRAME_NO_TASKBAR | wxFRAME_SHAPED);

Manager::Yield();

}

}

~Splash()

{

Hide();

}

void Hide()

{

if (m_pSplash)

{

m_pSplash->Destroy();

m_pSplash = nullptr;

}

}

private:

cbSplashScreen* m_pSplash;

{

#if wxCHECK_VERSION(3,0,0)

virtual void Output(const wxString &str);

#else

#ifdef WX_ATTRIBUTE_PRINTF

virtual void Printf(const wxChar* format, ...) WX_ATTRIBUTE_PRINTF_2;

#else

virtual void Printf(const wxChar* format, ...) ATTRIBUTE_PRINTF_2;

#endif

#endif // wxCHECK_VERSION

{

CFURLRef resourcesURL = CFBundleCopyResourcesDirectoryURL(CFBundleGetMainBundle());

CFURLRef absoluteURL = CFURLCopyAbsoluteURL(resourcesURL); // relative -> absolute

CFRelease(resourcesURL);

CFStringRef cfStrPath = CFURLCopyFileSystemPath(absoluteURL,kCFURLPOSIXPathStyle);

CFRelease(absoluteURL);

#if wxCHECK_VERSION(2,9,0)

return wxCFStringRef(cfStrPath).AsString(wxLocale::GetSystemEncoding());

#else

return wxMacCFStringHolder(cfStrPath).AsString(wxLocale::GetSystemEncoding());

#endif

{

if (m_UserDataDir!=wxEmptyString)

{

// if --user-data-dir=path was specified we tell

//ConfigManager (and CfgMgrBldr) about it, which will propagate

//it through the app and plugins

if ( !ConfigManager::SetUserDataFolder(m_UserDataDir) )

return false;

}

ConfigManager *cfg = Manager::Get()->GetConfigManager(_T("app"));

wxString data(wxT(APP_PREFIX));

if (platform::windows)

data.assign(GetAppPath());

else if (platform::macosx)

{

data.assign(GetResourcesDir()); // CodeBlocks.app/Contents/Resources

if (!data.Contains(wxString(_T("/Resources")))) // not a bundle, use relative path

data = GetAppPath() + _T("/..");

}

if (data.IsEmpty())

{

data.assign(GetAppPath()); // fallback

data.Replace(_T("/bin"),_T(""));

}

if (!m_Prefix.IsEmpty()) // --prefix command line switch overrides builtin value

data = m_Prefix;

else // also, check for environment

{

wxString env;

wxGetEnv(_T("CODEBLOCKS_DATA_DIR"), &env);

if (!env.IsEmpty())

data = env;

}

data.append(_T("/share/codeblocks"));

cfg->Write(_T("data_path"), data);

//m_HasDebugLog = Manager::Get()->GetConfigManager(_T("message_manager"))->ReadBool(_T("/has_debug_log"), false) || m_HasDebugLog;

//Manager::Get()->GetConfigManager(_T("message_manager"))->Write(_T("/has_debug_log"), m_HasDebugLog);

return true;

{

#ifdef __WXMSW__

ConfigManager *cfg = Manager::Get()->GetConfigManager(_T("app"));

if (m_Assocs && cfg->ReadBool(_T("/environment/check_associations"), true))

{

if (!Associations::Check())

{

AskAssocDialog dlg(Manager::Get()->GetAppWindow());

PlaceWindow(&dlg);

switch(dlg.ShowModal())

{

case ASC_ASSOC_DLG_NO_DONT_ASK:

cfg->Write(_T("/environment/check_associations"), false);

break;

case ASC_ASSOC_DLG_NO_ONLY_NOW:

break;

case ASC_ASSOC_DLG_YES_C_FILES:

Associations::SetCore();

break;

case ASC_ASSOC_DLG_YES_ALL_FILES:

Associations::SetAll();

break;

default:

break;

};

}

}

#endif

{

#ifdef __WXMSW__

#ifdef __CBDEBUG__

// Remember to compile as a console application!

AllocConsole();

HANDLE myhandle = GetStdHandle(STD_OUTPUT_HANDLE);

COORD co = {80,2000};

SetConsoleScreenBufferSize(myhandle, co);

fprintf(stdout,"CONSOLE DEBUG ACTIVATED\n");

// wxLogWindow *myerr = new wxLogWindow(NULL,"debug");

#endif

#endif

{

#ifdef __WXMSW__

m_ExceptionHandlerLib = LoadLibrary(_T("exchndl.dll"));

#endif

{

if ( !Manager::LoadResource(_T("resources.zip")) )

{

wxString msg;

msg.Printf(_T("Cannot find resources...\n"

"%s was configured to be installed in '%s'.\n"

"Please use the command-line switch '--prefix' or "

"set the CODEBLOCKS_DATA_DIR environment variable "

"to point where %s is installed,\n"

"or try re-installing the application..."),

appglobals::AppName.wx_str(),

ConfigManager::ReadDataPath().wx_str(),

appglobals::AppName.wx_str());

cbMessageBox(msg);

return false;

}

return true;

{

// This is a remnant from early 2006 (Windows only), but keep the revision tag for possible future use

ConfigManager *cfg = Manager::Get()->GetConfigManager(_T("app"));

if (cfg->Read(_T("version")) != appglobals::AppActualVersion)

cfg->Write(_T("version"), appglobals::AppActualVersion);

{

ConfigManager* cfg = Manager::Get()->GetConfigManager(_T("app"));

wxString path(ConfigManager::GetDataFolder() + _T("/locale"));

if (cfg->ReadBool(_T("/locale/enable"), false) == false)

return;

wxString lang(cfg->Read(_T("/locale/language")));

wxLocale::AddCatalogLookupPathPrefix(path);

const wxLanguageInfo *info;

if (!lang.IsEmpty()) // Note: You can also write this line of code as !(!lang) from wx-2.9 onwards

info = wxLocale::FindLanguageInfo(lang);

else

info = wxLocale::GetLanguageInfo(wxLANGUAGE_DEFAULT);

if (info == nullptr) // should never happen, but who knows...

return;

m_locale.Init(info->Language);

path.Alloc(path.length() + 10);

path.Append(_T('/'));

path.Append(info->CanonicalName);

if ( !wxDirExists(path) )

return;

wxDir dir(path);

if (!dir.IsOpened())

return;

wxString moName;

if (dir.GetFirst(&moName, _T("*.mo"), wxDIR_FILES))

{

do

{

m_locale.AddCatalog(moName);

} while (dir.GetNext(&moName));

}

{

#ifdef __WXMSW__

InitCommonControls();

#endif

wxLog::EnableLogging(true);

SetAppName(_T("codeblocks"));

s_Loading = true;

m_pBatchBuildDialog = nullptr;

m_BatchExitCode = 0;

m_Batch = false;

m_BatchNotify = false;

m_Build = false;

m_ReBuild = false;

m_Clean = false;

m_HasProject = false;

m_HasWorkSpace = false;

m_SafeMode = false;

m_BatchWindowAutoClose = true;

wxTheClipboard->Flush();

wxCmdLineParser& parser = *Manager::GetCmdLineParser();

parser.SetDesc(cmdLineDesc);

// NOTE: crash handler explicitly disabled because it causes problems

// with plugins loading/unloading...

//

// static CrashHandler crash_handler(!m_CrashHandler);

// we'll do this once and for all at startup

wxFileSystem::AddHandler(new wxZipFSHandler);

wxFileSystem::AddHandler(new wxMemoryFSHandler);

wxXmlResource::Get()->InsertHandler(new wxToolBarAddOnXmlHandler);

wxXmlResource::Get()->InsertHandler(new wxScrollingDialogXmlHandler);

wxInitAllImageHandlers();

wxXmlResource::Get()->InitAllHandlers();

Manager::Get()->GetLogManager()->Log(F(wxT("Starting ") + appglobals::AppName + wxT(" ") +

appglobals::AppActualVersionVerb + wxT(" ") +

appglobals::AppBuildTimestamp));

try

{

#if (wxUSE_ON_FATAL_EXCEPTION == 1)

wxHandleFatalExceptions(true);

#endif

InitExceptionHandler();

delete wxMessageOutput::Set(new cbMessageOutputNull); // No output. (suppress warnings about unknown options from plugins)

if (ParseCmdLine(nullptr) == -1) // only abort if '--help' was passed in the command line

{

delete wxMessageOutput::Set(new wxMessageOutputMessageBox);

parser.Usage();

return false;

}

if ( !LoadConfig() )

return false;

// set safe-mode appropriately

PluginManager::SetSafeMode(m_SafeMode);

// If not in batch mode, and no startup-script defined, initialise XRC

if(!m_Batch && m_Script.IsEmpty() && !InitXRCStuff())

return false;

InitLocale();

if (m_DDE && !m_Batch && Manager::Get()->GetConfigManager(_T("app"))->ReadBool(_T("/environment/use_ipc"), true))

{

// Create a new client

DDEClient *client = new DDEClient;

DDEConnection* connection = nullptr;

wxLogNull ln; // own error checking implemented -> avoid debug warnings

connection = (DDEConnection *)client->MakeConnection(_T("localhost"), F(DDE_SERVICE, wxGetUserId().wx_str()), DDE_TOPIC);

if (connection)

{

// don't eval here just forward the whole command line to the other instance

wxString cmdLine;

for (int i = 1 ; i < argc; ++i)

cmdLine += wxString(argv[i]) + _T(' ');

if ( !cmdLine.IsEmpty() )

{

// escape openings and closings so it is easily possible to find the end on the rx side

cmdLine.Replace(_T("("), _T("\\("));

cmdLine.Replace(_T(")"), _T("\\)"));

connection->Execute(_T("[CmdLine({") + cmdLine + _T("})]"));

}

// On Linux, C::B has to be raised explicitely if it's wanted

if (Manager::Get()->GetConfigManager(_T("app"))->ReadBool(_T("/environment/raise_via_ipc"), true))

connection->Execute(_T("[Raise]"));

connection->Disconnect();

delete connection;

delete client;

// return false to end the application

return false;

}

// free memory DDE-/IPC-clients, if we are here connection could not be established and there is no need to free it

delete client;

}

// Now we can start the DDE-/IPC-Server, if we did it earlier we would connect to ourselves

if (m_DDE && !m_Batch)

{

g_DDEServer = new DDEServer(nullptr);

g_DDEServer->Create(F(DDE_SERVICE, wxGetUserId().wx_str()));

}

m_pSingleInstance = nullptr;

if ( Manager::Get()->GetConfigManager(_T("app"))->ReadBool(_T("/environment/single_instance"), true)

&& !parser.Found(_T("multiple-instance")) )

{

const wxString name = wxString::Format(_T("Code::Blocks-%s"), wxGetUserId().wx_str());

m_pSingleInstance = new wxSingleInstanceChecker(name, ConfigManager::GetTempFolder());

if (m_pSingleInstance->IsAnotherRunning())

{

/* NOTE: Due to a recent change in logging code, this visual warning got disabled.

cbMessageBox(_("Another program instance is already running.\nCode::Blocks is currently configured to only allow one running instance.\n\nYou can access this Setting under the menu item 'Environment'."),

_T("Code::Blocks"), wxOK | wxICON_ERROR);

return false;

}

}

// Splash screen moved to this place, otherwise it would be short visible, even if we only pass filenames via DDE/IPC

// we also don't need it, if only a single instance is allowed

Splash splash(!m_Batch && m_Script.IsEmpty() && m_Splash &&

Manager::Get()->GetConfigManager(_T("app"))->ReadBool(_T("/environment/show_splash"), true));

InitDebugConsole();

Manager::SetBatchBuild(m_Batch || !m_Script.IsEmpty());

Manager::Get()->GetScriptingManager();

MainFrame* frame = nullptr;

frame = InitFrame();

m_Frame = frame;

// plugins loaded -> check command line arguments again

delete wxMessageOutput::Set(new wxMessageOutputBest); // warn about unknown options

if ( ParseCmdLine(m_Frame) == 0 )

{

if (Manager::Get()->GetConfigManager(_T("app"))->ReadBool(_T("/environment/blank_workspace"), true) == false)

Manager::Get()->GetProjectManager()->LoadWorkspace();

}

if (m_SafeMode) wxLog::EnableLogging(true); // re-enable logging in safe-mode

if (m_Batch)

{

Manager::SetAppStartedUp(true);

// the compiler plugin might be waiting for this

CodeBlocksEvent event(cbEVT_APP_STARTUP_DONE);

Manager::Get()->ProcessEvent(event);

Manager::Get()->RegisterEventSink(cbEVT_COMPILER_FINISHED, new cbEventFunctor<CodeBlocksApp, CodeBlocksEvent>(this, &CodeBlocksApp::OnBatchBuildDone));

s_Loading = false;

LoadDelayedFiles(frame);

BatchJob();

frame->Close();

return true;

}

if (!m_Script.IsEmpty())

{

s_Loading = false;

LoaderBase* loader = Manager::Get()->GetFileManager()->Load(m_Script);

if (loader->GetData())

Manager::Get()->GetScriptingManager()->LoadBuffer(cbC2U(loader->GetData()));

delete loader;

frame->Close();

return true;

}

CheckVersion();

// run startup script

try

{

wxString startup = ConfigManager::LocateDataFile(_T("startup.script"), sdScriptsUser | sdScriptsGlobal);

if (!startup.IsEmpty())

Manager::Get()->GetScriptingManager()->LoadScript(startup);

}

catch (SquirrelError& exception)

{

Manager::Get()->GetScriptingManager()->DisplayErrors(&exception);

}

Manager::ProcessPendingEvents();

// finally, show the app

splash.Hide();

SetTopWindow(frame);

frame->Show();

frame->StartupDone();

frame->ShowTips(); // this func checks if the user wants tips, so no need to check here

if (platform::windows)

InitAssociations();

s_Loading = false;

LoadDelayedFiles(frame);

Manager::Get()->GetProjectManager()->WorkspaceChanged();

// all done

Manager::SetAppStartedUp(true);

CodeBlocksEvent event(cbEVT_APP_STARTUP_DONE);

Manager::Get()->ProcessEvent(event);

return true;

}

catch (cbException& exception)

{

exception.ShowErrorMessage();

}

catch (SquirrelError& exception)

{

Manager::Get()->GetScriptingManager()->DisplayErrors(&exception);

}

catch (const char* message)

{

wxSafeShowMessage(_T("Exception"), cbC2U(message));

}

catch (...)

{

wxSafeShowMessage(_T("Exception"), _T("Unknown exception was raised. The application will terminate immediately..."));

}

// if we reached here, return error

return false;

{

wxTheClipboard->Flush();

if (g_DDEServer) delete g_DDEServer;

#ifdef __WXMSW__

if (m_ExceptionHandlerLib)

FreeLibrary(m_ExceptionHandlerLib);

#endif

if (m_pSingleInstance)

delete m_pSingleInstance;

// ultimate shutdown...

Manager::Free();

// WX docs say that this function's return value is ignored,

// but we return our value anyway. It might not be ignored at some point...

return m_Batch ? m_BatchExitCode : 0;

{

typedef BOOL (WINAPI *HeapSetInformation_t)(HANDLE, HEAP_INFORMATION_CLASS, PVOID, SIZE_T);

typedef DWORD (WINAPI *GetProcessHeaps_t)(DWORD, PHANDLE);

HINSTANCE kh = GetModuleHandle(TEXT("kernel32.dll"));

HeapSetInformation_t HeapSetInformation_func = (HeapSetInformation_t) GetProcAddress(kh, "HeapSetInformation");

GetProcessHeaps_t GetProcessHeaps_func = (GetProcessHeaps_t) GetProcAddress(kh, "GetProcessHeaps");

if (GetProcessHeaps_func && HeapSetInformation_func)

{

ULONG HeapFragValue = 2;

int n = GetProcessHeaps_func(0, 0);

HANDLE *h = new HANDLE[n];

GetProcessHeaps_func(n, h);

for (int i = 0; i < n; ++i)

HeapSetInformation_func(h[i], HeapCompatibilityInformation, &HeapFragValue, sizeof(HeapFragValue));

delete[] h;

}

{

EnableLFH();

try

{

int retval = wxApp::OnRun();

// wx 2.6.3 docs says that OnRun() function's return value is used as exit code

return m_Batch ? m_BatchExitCode : retval;

}

catch (cbException& exception)

{

exception.ShowErrorMessage();

}

catch (SquirrelError& exception)

{

Manager::Get()->GetScriptingManager()->DisplayErrors(&exception);

}

catch (const char* message)

{

wxSafeShowMessage(_("Exception"), cbC2U(message));

}

catch (...)

{

wxSafeShowMessage(_("Exception"), _("Unknown exception was raised. The application will terminate immediately..."));

}

// if we reached here, return error

return -1;

{

#if wxUSE_DEBUGREPORT && wxUSE_XML && wxUSE_ON_FATAL_EXCEPTION

wxDebugReport report;

wxDebugReportPreviewStd preview;

report.AddAll();

if ( preview.Show(report) )

report.Process();

#else

cbMessageBox(wxString::Format(_("Something has gone wrong inside %s and it will terminate immediately.\n"

"We are sorry for the inconvenience..."), appglobals::AppName.wx_str()));

#endif

{

event.Skip();

// the event comes more than once. deal with it...

static bool one_time_only = false;