// Initialize plugin - will be called when setInfo(), after nppData is available
void PluginInit() {
LoadConfig();
CreateMessageWindow();
AddNppSubclass();
InitCommandMenu();
}
//-----------------------------------------------------------------------------
// Pre-init
//-----------------------------------------------------------------------------
bool CVConfigApp::PreInit()
{
if ( !BaseClass::PreInit() )
return false;
// Create a window to capture messages
CreateMessageWindow();
// Make sure we're using the proper environment variable
ConvertObsoleteVConfigRegistrySetting( GAMEDIR_TOKEN );
FileSystem_SetErrorMode( FS_ERRORMODE_AUTO );
// We only want to use the gameinfo.txt that is in the bin\vconfig directory.
char dirName[MAX_PATH];
Q_strncpy( dirName, GetBaseDirectory(), sizeof( dirName ) );
Q_AppendSlash( dirName, sizeof( dirName ) );
Q_strncat( dirName, "vconfig", sizeof( dirName ), COPY_ALL_CHARACTERS );
if ( !SetupSearchPaths( dirName, true, true ) )
{
::MessageBox( NULL, "Error", "Unable to initialize file system\n", MB_OK );
return false;
}
// Load our configs
if ( g_ConfigManager.LoadConfigs() == false )
{
::MessageBox( NULL, "Error", "Unable to load configuration file\n", MB_OK );
return false;
}
// Parse them for internal use
if ( ParseConfigs() == false )
{
::MessageBox( NULL, "Error", "Unable to parse configuration file\n", MB_OK );
return false;
}
// Start looking for file updates
UpdateConfigsStatus_Init();
// the "base dir" so we can scan mod name
g_pFullFileSystem->AddSearchPath( GetBaseDirectory(), VCONFIG_MAIN_PATH_ID );
// the main platform dir
g_pFullFileSystem->AddSearchPath( "platform","PLATFORM", PATH_ADD_TO_HEAD );
return true;
}
DWORD CBaseTrayIcon::TrayMessageThread()
{
HRESULT hr;
MSG msg;
// Create the Window Class if it doesn't exist yet
hr = RegisterWindowClass();
if (FAILED(hr)) {
DbgLog((LOG_TRACE, 10, L"CBaseTrayIcon::ThreadProc(): Failed to register window class"));
}
// And the Window we use for messages
hr = CreateMessageWindow();
if (FAILED(hr)) {
DbgLog((LOG_TRACE, 10, L"CBaseTrayIcon::ThreadProc(): Failed to create message window"));
m_evSetupFinished.Set();
UnregisterClass(m_wszClassName, g_hInst);
return 1;
}
ASSERT(m_hWnd);
CreateTrayIconData();
Shell_NotifyIcon(NIM_ADD, &m_NotifyIconData);
Shell_NotifyIcon(NIM_SETVERSION, &m_NotifyIconData);
m_evSetupFinished.Set();
// Message loop
while (GetMessage(&msg, NULL, 0, 0) > 0) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
Shell_NotifyIcon(NIM_DELETE, &m_NotifyIconData);
// Free icon resources
if (m_NotifyIconData.hIcon) {
DestroyIcon(m_NotifyIconData.hIcon);
m_NotifyIconData.hIcon = NULL;
}
// Unregister the window class we used
UnregisterClass(m_wszClassName, g_hInst);
return 0;
}
UINT DexpotMeasure::Initialize(LPCTSTR iniFile, LPCTSTR section)
{
if (InstanceCount == 0)
{
hWndRainmeterControl = FindWindow(_T("DummyRainWClass"), _T("Rainmeter control window"));
hWndMessageWindow = CreateMessageWindow();
}
InstanceCount++;
if (!PluginRegistered && FindDexpotWindow())
{
SendNotifyMessage(hWndDexpot, DEX_REGISTERPLUGIN, 0, (LPARAM) hWndMessageWindow);
CurrentDesktop = (int) SendMessage(hWndDexpot, DEX_GETCURRENTDESKTOP, 0, 0);
PluginRegistered = TRUE;
}
InitializeData();
DexpotMeasures.insert(this);
return 0;
}
void* ClassicUICreate(FcitxInstance* instance)
{
FcitxAddon* classicuiaddon = FcitxAddonsGetAddonByName(FcitxInstanceGetAddons(instance), FCITX_CLASSIC_UI_NAME);
FcitxModuleFunctionArg arg;
FcitxClassicUI* classicui = fcitx_utils_malloc0(sizeof(FcitxClassicUI));
classicui->owner = instance;
if (!LoadClassicUIConfig(classicui)) {
free(classicui);
return NULL;
}
if (GetSkinDesc() == NULL) {
free(classicui);
return NULL;
}
classicui->dpy = InvokeFunction(instance, FCITX_X11, GETDISPLAY, arg);
if (classicui->dpy == NULL) {
free(classicui);
return NULL;
}
if (LoadSkinConfig(&classicui->skin, &classicui->skinType)) {
free(classicui);
return NULL;
}
classicui->isfallback = FcitxUIIsFallback(instance, classicuiaddon);
classicui->iScreen = DefaultScreen(classicui->dpy);
classicui->protocolAtom = XInternAtom(classicui->dpy, "WM_PROTOCOLS", False);
classicui->killAtom = XInternAtom(classicui->dpy, "WM_DELETE_WINDOW", False);
InitSkinMenu(classicui);
FcitxUIRegisterMenu(instance, &classicui->skinMenu);
/* Main Menu Initial */
FcitxMenuInit(&classicui->mainMenu);
FcitxMenuAddMenuItem(&classicui->mainMenu, _("About Fcitx"), MENUTYPE_SIMPLE, NULL);
FcitxMenuAddMenuItem(&classicui->mainMenu, _("Online Help"), MENUTYPE_SIMPLE, NULL);
FcitxMenuAddMenuItem(&classicui->mainMenu, NULL, MENUTYPE_DIVLINE, NULL);
FcitxUIMenu **menupp;
UT_array* uimenus = FcitxInstanceGetUIMenus(instance);
for (menupp = (FcitxUIMenu **) utarray_front(uimenus);
menupp != NULL;
menupp = (FcitxUIMenu **) utarray_next(uimenus, menupp)
) {
FcitxUIMenu * menup = *menupp;
if (!menup->isSubMenu)
FcitxMenuAddMenuItem(&classicui->mainMenu, menup->name, MENUTYPE_SUBMENU, menup);
}
FcitxMenuAddMenuItem(&classicui->mainMenu, NULL, MENUTYPE_DIVLINE, NULL);
FcitxMenuAddMenuItem(&classicui->mainMenu, _("Configure"), MENUTYPE_SIMPLE, NULL);
FcitxMenuAddMenuItem(&classicui->mainMenu, _("Exit"), MENUTYPE_SIMPLE, NULL);
classicui->mainMenu.MenuAction = MainMenuAction;
classicui->mainMenu.priv = classicui;
classicui->mainMenu.mark = -1;
classicui->inputWindow = CreateInputWindow(classicui);
classicui->mainWindow = CreateMainWindow(classicui);
classicui->trayWindow = CreateTrayWindow(classicui);
classicui->aboutWindow = CreateAboutWindow(classicui);
classicui->messageWindow = CreateMessageWindow(classicui);
classicui->mainMenuWindow = CreateMainMenuWindow(classicui);
FcitxIMEventHook resethk;
resethk.arg = classicui;
resethk.func = ClassicUIInputReset;
FcitxInstanceRegisterResetInputHook(instance, resethk);
DisplaySkin(classicui, classicui->skinType);
/* ensure order ! */
AddFunction(classicuiaddon, ClassicUILoadImage);
AddFunction(classicuiaddon, ClassicUIGetKeyBoardFontColor);
AddFunction(classicuiaddon, ClassicUIGetFont);
return classicui;
}
// Program entry point function.
int APIENTRY wWinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPTSTR lpCmdLine,
int nCmdShow) {
UNREFERENCED_PARAMETER(hPrevInstance);
UNREFERENCED_PARAMETER(lpCmdLine);
void* sandbox_info = NULL;
#if CEF_ENABLE_SANDBOX
// Manage the life span of the sandbox information object. This is necessary
// for sandbox support on Windows. See cef_sandbox_win.h for complete details.
CefScopedSandboxInfo scoped_sandbox;
sandbox_info = scoped_sandbox.sandbox_info();
#endif
CefMainArgs main_args(hInstance);
CefRefPtr<ClientApp> app(new ClientApp);
// Execute the secondary process, if any.
int exit_code = CefExecuteProcess(main_args, app.get(), sandbox_info);
if (exit_code >= 0)
return exit_code;
// Retrieve the current working directory.
if (_getcwd(szWorkingDir, MAX_PATH) == NULL)
szWorkingDir[0] = 0;
// Parse command line arguments. The passed in values are ignored on Windows.
AppInitCommandLine(0, NULL);
CefSettings settings;
#if !CEF_ENABLE_SANDBOX
settings.no_sandbox = true;
#endif
// Populate the settings based on command line arguments.
AppGetSettings(settings);
// Initialize CEF.
CefInitialize(main_args, settings, app.get(), sandbox_info);
// Register the scheme handler.
scheme_test::InitTest();
HACCEL hAccelTable;
// Initialize global strings
LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
LoadString(hInstance, IDC_CEFCLIENT, szWindowClass, MAX_LOADSTRING);
LoadString(hInstance, IDS_OSR_WIDGET_CLASS, szOSRWindowClass, MAX_LOADSTRING);
MyRegisterClass(hInstance);
// Perform application initialization
if (!InitInstance (hInstance, nCmdShow))
return FALSE;
hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_CEFCLIENT));
// Register the find event message.
uFindMsg = RegisterWindowMessage(FINDMSGSTRING);
int result = 0;
if (!settings.multi_threaded_message_loop) {
// Run the CEF message loop. This function will block until the application
// recieves a WM_QUIT message.
CefRunMessageLoop();
} else {
// Create a hidden window for message processing.
hMessageWnd = CreateMessageWindow(hInstance);
ASSERT(hMessageWnd);
MSG msg;
// Run the application message loop.
while (GetMessage(&msg, NULL, 0, 0)) {
// Allow processing of find dialog messages.
if (hFindDlg && IsDialogMessage(hFindDlg, &msg))
continue;
if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
DestroyWindow(hMessageWnd);
hMessageWnd = NULL;
result = static_cast<int>(msg.wParam);
}
// Shut down CEF.
CefShutdown();
return result;
}
int CreateMainWindow()
{
// initialize title bar text and the main window class name
TCHAR szTitle[MAX_LOADSTRING];
TCHAR szWindowClass[MAX_LOADSTRING];
LoadString(g_hInst, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
LoadString(g_hInst, IDC_CEFCLIENT, szWindowClass, MAX_LOADSTRING);
MyRegisterClass(g_hInst, szWindowClass);
// create the main window
Rect rectWindow;
LoadWindowPlacement(&rectWindow, &g_nCmdShow);
HWND hWndMain = CreateWindow(
szWindowClass, szTitle, WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
rectWindow.x, rectWindow.y, rectWindow.w, rectWindow.h,
NULL, NULL, g_hInst, NULL
);
if (hWndMain == NULL)
{
App::ShowErrorMessage();
return FALSE;
}
HACCEL hAccelTable = LoadAccelerators(g_hInst, MAKEINTRESOURCE(IDC_CEFCLIENT));
g_handler->SetAccelTable(hAccelTable);
g_isMessageLoopRunning = true;
int result = 0;
if (!g_isMultithreadedMessageLoop)
{
// run the CEF message loop
// this function will block until the application recieves a WM_QUIT message
CefRunMessageLoop();
}
else
{
// create a hidden window for message processing
g_hMessageWnd = CreateMessageWindow(g_hInst);
ASSERT(g_hMessageWnd);
MSG msg;
// run the application message loop
while (GetMessage(&msg, NULL, 0, 0))
{
if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
DestroyWindow(g_hMessageWnd);
g_hMessageWnd = NULL;
result = static_cast<int>(msg.wParam);
}
g_isMessageLoopRunning = false;
g_handler->ReleaseCefObjects();
FreeResources();
return result;
}
MessageWindow::MessageWindow(const vt_utils::ustring& message, float x, float y, float w, float h)
{
CreateMessageWindow(x, y, w, h);
_textbox.SetDisplayText(message);
}
/******************************************************************
WixWaitForEvent - entry point for WixWaitForEvent custom action
which waits for either the WixWaitForEventFail or
WixWaitForEventSucceed named auto reset events. Signaling the
WixWaitForEventFail event will return ERROR_INSTALL_FAILURE or
signaling the WixWaitForEventSucceed event will return
ERROR_SUCCESS. Both events are declared in the Global\ namespace.
********************************************************************/
extern "C" UINT __stdcall WixWaitForEvent(
__in MSIHANDLE hInstall
)
{
HRESULT hr = S_OK;
UINT er = ERROR_SUCCESS;
HWND hMessageWindow = NULL;
LPCWSTR wzSDDL = L"D:(A;;GA;;;WD)";
OS_VERSION version = OS_VERSION_UNKNOWN;
DWORD dwServicePack = 0;
PSECURITY_DESCRIPTOR pSD = NULL;
SECURITY_ATTRIBUTES sa = { };
HANDLE rghEvents[2];
hr = WcaInitialize(hInstall, "WixWaitForEvent");
ExitOnFailure(hr, "Failed to initialize.");
// Create a window to prevent shutdown requests.
hr = CreateMessageWindow(&hMessageWindow);
ExitOnFailure(hr, "Failed to create message window.");
// If running on Vista/2008 or newer use integrity enhancements.
OsGetVersion(&version, &dwServicePack);
if (OS_VERSION_VISTA <= version)
{
// Add SACL to allow Everyone to signal from a medium integrity level.
wzSDDL = L"D:(A;;GA;;;WD)S:(ML;;NW;;;ME)";
}
// Create the security descriptor and attributes for the events.
if (!::ConvertStringSecurityDescriptorToSecurityDescriptorW(wzSDDL, SDDL_REVISION_1, &pSD, NULL))
{
ExitWithLastError(hr, "Failed to create the security descriptor for the events.");
}
sa.nLength = sizeof(sa);
sa.lpSecurityDescriptor = pSD;
sa.bInheritHandle = FALSE;
rghEvents[0] = ::CreateEventW(&sa, FALSE, FALSE, L"Global\\WixWaitForEventFail");
ExitOnNullWithLastError(rghEvents[0], hr, "Failed to create the Global\\WixWaitForEventFail event.");
rghEvents[1] = ::CreateEventW(&sa, FALSE, FALSE, L"Global\\WixWaitForEventSucceed");
ExitOnNullWithLastError(rghEvents[1], hr, "Failed to create the Global\\WixWaitForEventSucceed event.");
// Wait for either of the events to be signaled and handle accordingly.
er = ::WaitForMultipleObjects(countof(rghEvents), rghEvents, FALSE, INFINITE);
switch (er)
{
case WAIT_OBJECT_0 + 0:
er = ERROR_INSTALL_FAILURE;
break;
case WAIT_OBJECT_0 + 1:
er = ERROR_SUCCESS;
break;
default:
ExitOnWin32Error(er, hr, "Unexpected failure.");
}
LExit:
ReleaseHandle(rghEvents[1]);
ReleaseHandle(rghEvents[0]);
if (pSD)
{
::LocalFree(pSD);
}
if (hMessageWindow)
{
CloseMessageWindow(hMessageWindow);
}
if (FAILED(hr))
{
er = ERROR_INSTALL_FAILURE;
}
return WcaFinalize(er);
}
void* ClassicUICreate(FcitxInstance* instance)
{
FcitxAddon* classicuiaddon = FcitxAddonsGetAddonByName(FcitxInstanceGetAddons(instance), FCITX_CLASSIC_UI_NAME);
FcitxClassicUI* classicui = fcitx_utils_malloc0(sizeof(FcitxClassicUI));
classicui->owner = instance;
if (!LoadClassicUIConfig(classicui)) {
free(classicui);
return NULL;
}
if (GetSkinDesc() == NULL) {
free(classicui);
return NULL;
}
classicui->dpy = FcitxX11GetDisplay(instance);
if (classicui->dpy == NULL) {
free(classicui);
return NULL;
}
FcitxX11GetDPI(instance, &classicui->dpi, NULL);
if (classicui->dpi <= 0)
classicui->dpi = 96;
if (LoadSkinConfig(&classicui->skin, &classicui->skinType)) {
free(classicui);
return NULL;
}
classicui->isfallback = FcitxUIIsFallback(instance, classicuiaddon);
classicui->iScreen = DefaultScreen(classicui->dpy);
classicui->protocolAtom = XInternAtom(classicui->dpy, "WM_PROTOCOLS", False);
classicui->killAtom = XInternAtom(classicui->dpy, "WM_DELETE_WINDOW", False);
InitSkinMenu(classicui);
FcitxUIRegisterMenu(instance, &classicui->skinMenu);
/* Main Menu Initial */
FcitxMenuInit(&classicui->mainMenu);
classicui->mainMenu.UpdateMenu = UpdateMainMenu;
classicui->mainMenu.MenuAction = MainMenuAction;
classicui->mainMenu.priv = classicui;
classicui->mainMenu.mark = -1;
classicui->inputWindow = CreateInputWindow(classicui);
classicui->mainWindow = CreateMainWindow(classicui);
classicui->trayWindow = CreateTrayWindow(classicui);
classicui->messageWindow = CreateMessageWindow(classicui);
classicui->mainMenuWindow = CreateMainMenuWindow(classicui);
FcitxIMEventHook resethk;
resethk.arg = classicui;
resethk.func = ClassicUIInputReset;
FcitxInstanceRegisterResetInputHook(instance, resethk);
DisplaySkin(classicui, classicui->skinType);
/* ensure order ! */
FcitxModuleAddFunction(classicuiaddon, ClassicUILoadImage);
FcitxModuleAddFunction(classicuiaddon, ClassicUIGetKeyBoardFontColor);
FcitxModuleAddFunction(classicuiaddon, ClassicUIGetFont);
return classicui;
}
