File indexing completed on 2024-04-14 14:20:16

 /*
    This file is part of the KDE libraries
    Copyright (C) 2004-2008 Jarosław Staniek <staniek@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include <QApplication>
 #include <klocale.h>
 #include <kwindowsystem.h>
 
 #include <QTranslator>
 #include <QLocale>
 #include <QLibraryInfo>
 #include <QLibrary>
 
 #include <stdio.h>
 
 /**
  * MS Windows-related actions for KApplication startup.
  *
  * - Use Qt translation which will be usable for QFileDialog
  *    and other Qt-only GUIs. The "qt_<language>.qm" file should be stored
  *    in the same place as .po files for a given language.
  *
  * - Increase the default open file limit with the stdio API from 512 to 2048
  *   (2048 is the hard limit on Windows)
  * @internal
 */
 void KApplication_init_windows()
 {
     //QString qt_transl_file = ::locate( "locale", KLocale::global()->language()
     //  + "/LC_MESSAGES/qt_" + KLocale::global()->language() + ".qm" );
 
     QString qt_transl_file = QString("qt_") + QLocale::system().name();
     qt_transl_file.truncate(5);
     QTranslator *qt_transl = new QTranslator();
     if (qt_transl->load(qt_transl_file,
                         QLibraryInfo::location(QLibraryInfo::TranslationsPath))) {
         qApp->installTranslator(qt_transl);
     } else {
         delete qt_transl;
     }
 
     // For apps like KMail which have lots of open files, the default is too low
     // so increase it to the maximum.
 #ifndef _WIN32_WCE
     _setmaxstdio(2048);
 #endif
 
 }
 
 // <copy of kdepim/libkdepim/utils.cpp, TODO: move to a shared helper library>
 
 #include <windows.h>
 #include <winperf.h>
 #include <psapi.h>
 #include <signal.h>
 #include <unistd.h>
 
 #include <QList>
 #include <QtDebug>
 
 static PPERF_OBJECT_TYPE FirstObject(PPERF_DATA_BLOCK PerfData)
 {
     return (PPERF_OBJECT_TYPE)((PBYTE)PerfData + PerfData->HeaderLength);
 }
 
 static PPERF_INSTANCE_DEFINITION FirstInstance(PPERF_OBJECT_TYPE PerfObj)
 {
     return (PPERF_INSTANCE_DEFINITION)((PBYTE)PerfObj + PerfObj->DefinitionLength);
 }
 
 static PPERF_OBJECT_TYPE NextObject(PPERF_OBJECT_TYPE PerfObj)
 {
     return (PPERF_OBJECT_TYPE)((PBYTE)PerfObj + PerfObj->TotalByteLength);
 }
 
 static PPERF_COUNTER_DEFINITION FirstCounter(PPERF_OBJECT_TYPE PerfObj)
 {
     return (PPERF_COUNTER_DEFINITION)((PBYTE)PerfObj + PerfObj->HeaderLength);
 }
 
 static PPERF_INSTANCE_DEFINITION NextInstance(PPERF_INSTANCE_DEFINITION PerfInst)
 {
     PPERF_COUNTER_BLOCK PerfCntrBlk
         = (PPERF_COUNTER_BLOCK)((PBYTE)PerfInst + PerfInst->ByteLength);
     return (PPERF_INSTANCE_DEFINITION)((PBYTE)PerfCntrBlk + PerfCntrBlk->ByteLength);
 }
 
 static PPERF_COUNTER_DEFINITION NextCounter(PPERF_COUNTER_DEFINITION PerfCntr)
 {
     return (PPERF_COUNTER_DEFINITION)((PBYTE)PerfCntr + PerfCntr->ByteLength);
 }
 
 static PPERF_COUNTER_BLOCK CounterBlock(PPERF_INSTANCE_DEFINITION PerfInst)
 {
     return (PPERF_COUNTER_BLOCK)((LPBYTE) PerfInst + PerfInst->ByteLength);
 }
 
 #define GETPID_TOTAL 64 * 1024
 #define GETPID_BYTEINCREMENT 1024
 #define GETPID_PROCESS_OBJECT_INDEX 230
 #define GETPID_PROC_ID_COUNTER 784
 
 QString fromWChar(const wchar_t *string, int size = -1)
 {
     return (sizeof(wchar_t) == sizeof(QChar)) ? QString::fromUtf16((ushort *)string, size)
            : QString::fromUcs4((uint *)string, size);
 }
 
 #ifndef _WIN32_WCE
 void KApplication_getProcessesIdForName(const QString &processName, QList<int> &pids)
 {
     qDebug() << "KApplication_getProcessesIdForName" << processName;
     PPERF_OBJECT_TYPE perfObject;
     PPERF_INSTANCE_DEFINITION perfInstance;
     PPERF_COUNTER_DEFINITION perfCounter, curCounter;
     PPERF_COUNTER_BLOCK counterPtr;
     DWORD bufSize = GETPID_TOTAL;
     PPERF_DATA_BLOCK perfData = (PPERF_DATA_BLOCK) malloc(bufSize);
 
     char key[64];
     sprintf(key, "%d %d", GETPID_PROCESS_OBJECT_INDEX, GETPID_PROC_ID_COUNTER);
     LONG lRes;
     while ((lRes = RegQueryValueExA(HKEY_PERFORMANCE_DATA,
                                     key,
                                     NULL,
                                     NULL,
                                     (LPBYTE) perfData,
                                     &bufSize)) == ERROR_MORE_DATA) {
         // get a buffer that is big enough
         bufSize += GETPID_BYTEINCREMENT;
         perfData = (PPERF_DATA_BLOCK) realloc(perfData, bufSize);
     }
 
     // Get the first object type.
     perfObject = FirstObject(perfData);
 
     // Process all objects.
     for (uint i = 0; i < perfData->NumObjectTypes; i++) {
         if (perfObject->ObjectNameTitleIndex != GETPID_PROCESS_OBJECT_INDEX) {
             perfObject = NextObject(perfObject);
             continue;
         }
         pids.clear();
         perfCounter = FirstCounter(perfObject);
         perfInstance = FirstInstance(perfObject);
         // retrieve the instances
         qDebug() << "INSTANCES: " << perfObject->NumInstances;
         for (int instance = 0; instance < perfObject->NumInstances; instance++) {
             curCounter = perfCounter;
             const QString foundProcessName(
                 fromWChar((wchar_t *)((PBYTE)perfInstance + perfInstance->NameOffset)));
             qDebug() << "foundProcessName: " << foundProcessName;
             if (foundProcessName == processName) {
                 // retrieve the counters
                 for (uint counter = 0; counter < perfObject->NumCounters; counter++) {
                     if (curCounter->CounterNameTitleIndex == GETPID_PROC_ID_COUNTER) {
                         counterPtr = CounterBlock(perfInstance);
                         DWORD *value = (DWORD *)((LPBYTE) counterPtr + curCounter->CounterOffset);
                         pids.append(int(*value));
                         qDebug() << "found PID: " << int(*value);
                         break;
                     }
                     curCounter = NextCounter(curCounter);
                 }
             }
             perfInstance = NextInstance(perfInstance);
         }
     }
     free(perfData);
     RegCloseKey(HKEY_PERFORMANCE_DATA);
 }
 
 bool KApplication_otherProcessesExist(const QString &processName)
 {
     QList<int> pids;
     KApplication_getProcessesIdForName(processName, pids);
     int myPid = getpid();
     foreach (int pid, pids) {
         if (myPid != pid) {
 //      kDebug() << "Process ID is " << pid;
             return true;
         }
     }
     return false;
 }
 
 bool KApplication_killProcesses(const QString &processName)
 {
     QList<int> pids;
     KApplication_getProcessesIdForName(processName, pids);
     if (pids.empty()) {
         return true;
     }
     qWarning() << "Killing process \"" << processName << " (pid=" << pids[0] << ")..";
     int overallResult = 0;
     foreach (int pid, pids) {
         int result = kill(pid, SIGTERM);
         if (result == 0) {
             continue;
         }
         result = kill(pid, SIGKILL);
         if (result != 0) {
             overallResult = result;
         }
     }
     return overallResult == 0;
 }
 
 struct EnumWindowsStruct {
     EnumWindowsStruct() : windowId(0) {}
     int pid;
     HWND windowId;
 };
 
 BOOL CALLBACK EnumWindowsProc(HWND hwnd, LPARAM lParam)
 {
     if (GetWindowLong(hwnd, GWL_STYLE) & WS_VISIBLE) {
         DWORD pidwin;
         GetWindowThreadProcessId(hwnd, &pidwin);
         if (pidwin == ((EnumWindowsStruct *)lParam)->pid) {
             ((EnumWindowsStruct *)lParam)->windowId = hwnd;
             return false;
         }
     }
     return true;
 }
 
 void KApplication_activateWindowForProcess(const QString &executableName)
 {
     QList<int> pids;
     KApplication_getProcessesIdForName(executableName, pids);
     int myPid = getpid();
     int foundPid = 0;
     foreach (int pid, pids) {
         if (myPid != pid) {
             qDebug() << "activateWindowForProcess(): PID to activate:" << pid;
             foundPid = pid;
             break;
         }
     }
     if (foundPid == 0) {
         return;
     }
     EnumWindowsStruct winStruct;
     winStruct.pid = foundPid;
     EnumWindows(EnumWindowsProc, (LPARAM)&winStruct);
     if (winStruct.windowId == NULL) {
         return;
     }
     KWindowSystem::forceActiveWindow((WId)winStruct.windowId, 0);
 }
 #endif
 
 // </copy>