Delete "ghost" old(*) files that have been mysteriously added back during the SVN-to-Git transition.

To check that these changes are correct, checkout in a directory (let's call it "ros_svn") the /trunk/reactos/ of our read-only SVN repo r76032 and in /trunk/reactos/modules/, the rosapps, rostests and wallpapers.
In a second directory (let's call it "ros_git"), clone the corresponding Git-converted ReactOS directory.
Before applying this patch (and the previous one that added back the empty directories), you should see additional files in ros_git that are not in ros_svn, corresponding to these files I'm deleting here (plus some .gitignore files),
and you should also see additional files in ros_svn that do not appear in ros_git: these are the empty directories I've restored in my previous patch.

Now, after the application of both the previous patch that restores the empty directories (and deletes the .gitignore files), and this patch that removes the ghost files, you should only see that the only differences
between ros_git and ros_svn are the extra .keep files in the empty directories, and that's all!

Command-line for the tests:
diff --strip-trailing-cr -r ros_svn ros_git > diff_svn2git.txt

"-r" means recursive, and "--strip-trailing-cr" ignores the CR-LF vs. LF (or CR) EOLs.

(*): by "ghost" old(*) files I understand files that existed previously in the far past, that then were deleted long ago in SVN, and that popped out back during the Git migration.
This commit is contained in:
Hermès Bélusca-Maïto 2017-10-04 03:05:47 +02:00 committed by Hermès BÉLUSCA - MAÏTO
parent acdf04bad2
commit f9b6429468
151 changed files with 0 additions and 43256 deletions

View file

@ -1,62 +0,0 @@
/*
* PROJECT: ReactOS Device Managment
* LICENSE: GPL - See COPYING in the top level directory
* FILE: base/applications/mscutils/devmgmt/about.c
* PURPOSE: About dialog box message handler
* COPYRIGHT: Copyright 2006 Ged Murphy <gedmurphy@gmail.com>
*
*/
#include "precomp.h"
INT_PTR CALLBACK
AboutDialogProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
HWND hLicenseEditWnd;
HICON hIcon = NULL;
TCHAR strLicense[700];
switch (message)
{
case WM_INITDIALOG:
hIcon = (HICON)LoadImage(hInstance,
MAKEINTRESOURCE(IDI_MAIN_ICON),
IMAGE_ICON,
16,
16,
0);
SendMessage(hDlg,
WM_SETICON,
ICON_SMALL,
(LPARAM)hIcon);
hLicenseEditWnd = GetDlgItem(hDlg,
IDC_LICENSE_EDIT);
LoadString(hInstance,
IDS_LICENSE,
strLicense,
sizeof(strLicense) / sizeof(TCHAR));
SetWindowText(hLicenseEditWnd,
strLicense);
return TRUE;
case WM_COMMAND:
if ((LOWORD(wParam) == IDOK) || (LOWORD(wParam) == IDCANCEL))
{
DestroyIcon(hIcon);
EndDialog(hDlg,
LOWORD(wParam));
return TRUE;
}
break;
}
return FALSE;
}

View file

@ -1,688 +0,0 @@
/*
* PROJECT: ReactOS Device Managment
* LICENSE: GPL - See COPYING in the top level directory
* FILE: base/applications/mscutils/devmgmt/enumdevices.c
* PURPOSE: Enumerates all devices on the local machine
* COPYRIGHT: Copyright 2006 Ged Murphy <gedmurphy@gmail.com>
*
*/
#include "precomp.h"
#include <cfgmgr32.h>
#include <dll/devmgr/devmgr.h>
#include <initguid.h>
#include <devguid.h>
static SP_CLASSIMAGELIST_DATA ImageListData;
VOID
FreeDeviceStrings(HWND hTreeView)
{
HTREEITEM hItem;
hItem = TreeView_GetRoot(hTreeView);
if (hItem)
{
hItem = TreeView_GetChild(hTreeView,
hItem);
/* loop the parent items */
while (hItem)
{
hItem = TreeView_GetChild(hTreeView,
hItem);
if (hItem == NULL)
break;
/* loop the child items and free the DeviceID */
while (TRUE)
{
HTREEITEM hOldItem;
TV_ITEM tvItem;
//TCHAR Buf[100];
tvItem.hItem = hItem;
tvItem.mask = TVIF_PARAM;// | TVIF_TEXT;
//tvItem.pszText = Buf;
//tvItem.cchTextMax = 99;
(void)TreeView_GetItem(hTreeView, &tvItem);
//MessageBox(NULL, Buf, NULL, 0);
HeapFree(GetProcessHeap(),
0,
(LPTSTR)tvItem.lParam);
hOldItem = hItem;
hItem = TreeView_GetNextSibling(hTreeView,
hItem);
if (hItem == NULL)
{
hItem = hOldItem;
break;
}
}
hItem = TreeView_GetParent(hTreeView,
hItem);
hItem = TreeView_GetNextSibling(hTreeView,
hItem);
}
}
}
VOID
OpenPropSheet(HWND hTreeView,
HTREEITEM hItem)
{
TV_ITEM tvItem;
tvItem.hItem = hItem;
tvItem.mask = TVIF_PARAM;
if (TreeView_GetItem(hTreeView, &tvItem) &&
(LPTSTR)tvItem.lParam != NULL)
{
DevicePropertiesExW(hTreeView,
NULL,
(LPTSTR)tvItem.lParam,
DPF_EXTENDED,
FALSE);
}
}
static HTREEITEM
InsertIntoTreeView(HWND hTreeView,
HTREEITEM hRoot,
LPTSTR lpLabel,
LPTSTR DeviceID,
INT DevImage,
UINT OverlayImage)
{
TV_ITEM tvi;
TV_INSERTSTRUCT tvins;
ZeroMemory(&tvi, sizeof(tvi));
ZeroMemory(&tvins, sizeof(tvins));
tvi.mask = TVIF_TEXT | TVIF_PARAM | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
tvi.pszText = lpLabel;
tvi.cchTextMax = lstrlen(lpLabel);
tvi.lParam = (LPARAM)DeviceID;
tvi.iImage = DevImage;
tvi.iSelectedImage = DevImage;
if (OverlayImage != 0)
{
tvi.mask |= TVIF_STATE;
tvi.stateMask = TVIS_OVERLAYMASK;
tvi.state = INDEXTOOVERLAYMASK(OverlayImage);
}
tvins.item = tvi;
tvins.hParent = hRoot;
return TreeView_InsertItem(hTreeView, &tvins);
}
static
ULONG
GetClassCount(VOID)
{
ULONG ulClassIndex;
GUID ClassGuid;
CONFIGRET cr;
for (ulClassIndex = 0; ; ulClassIndex++)
{
cr = CM_Enumerate_Classes(ulClassIndex,
&ClassGuid,
0);
if (cr == CR_NO_SUCH_VALUE)
return ulClassIndex;
}
}
static
PDEVCLASS_ENTRY
GetClassFromClassGuid(
PDEVCLASS_ENTRY pClassArray,
ULONG ulClassCount,
GUID *pGuid)
{
PDEVCLASS_ENTRY pClass, pUnknownClass = NULL;
ULONG i;
for (i = 0; i < ulClassCount; i++)
{
pClass = &pClassArray[i];
if (IsEqualGUID(&pClass->ClassGuid, &GUID_DEVCLASS_UNKNOWN))
pUnknownClass = pClass;
if (IsEqualGUID(&pClass->ClassGuid, pGuid))
return pClass;
}
return pUnknownClass;
}
static
VOID
EnumDeviceClasses(
HWND hTreeView,
HTREEITEM hRoot,
PDEVCLASS_ENTRY pClassArray,
ULONG ClassCount)
{
WCHAR ClassName[MAX_DEV_LEN];
WCHAR ClassDesc[MAX_DEV_LEN];
PDEVCLASS_ENTRY pClass;
ULONG ClassIndex;
DWORD dwSize;
LONG lSize;
HKEY hKey;
CONFIGRET cr;
for (ClassIndex = 0; ClassIndex < ClassCount; ClassIndex++)
{
pClass = &pClassArray[ClassIndex];
cr = CM_Enumerate_Classes(ClassIndex,
&pClass->ClassGuid,
0);
if (cr == CR_NO_SUCH_VALUE)
return;
dwSize = MAX_CLASS_NAME_LEN;
if (!SetupDiClassNameFromGuid(&pClass->ClassGuid,
ClassName,
dwSize,
&dwSize))
{
ClassName[0] = _T('\0');
}
if (!SetupDiGetClassImageIndex(&ImageListData,
&pClass->ClassGuid,
&pClass->ClassImage))
{
/* FIXME: can we do this?
* Set the blank icon: IDI_SETUPAPI_BLANK = 41
* it'll be image 24 in the imagelist */
pClass->ClassImage = 24;
}
hKey = SetupDiOpenClassRegKeyEx(&pClass->ClassGuid,
MAXIMUM_ALLOWED,
DIOCR_INSTALLER,
NULL,
0);
if (hKey != INVALID_HANDLE_VALUE)
{
lSize = MAX_DEV_LEN;
if (RegQueryValue(hKey,
NULL,
ClassDesc,
&lSize) != ERROR_SUCCESS)
{
ClassDesc[0] = _T('\0');
}
RegCloseKey(hKey);
}
pClass->hItem = InsertIntoTreeView(hTreeView,
hRoot,
(ClassDesc[0] != _T('\0')) ? ClassDesc : ClassName,
NULL,
pClass->ClassImage,
0);
}
}
static
VOID
EnumDevices(
HWND hTreeView,
PDEVCLASS_ENTRY pClassArray,
ULONG ulClassCount,
BOOL bShowHidden)
{
HDEVINFO hDevInfo = INVALID_HANDLE_VALUE;
SP_DEVINFO_DATA DeviceInfoData;
ULONG Status, Problem;
DWORD DevIdSize;
TCHAR DeviceName[MAX_DEV_LEN];
DWORD DevIndex;
LPTSTR InstanceId;
PDEVCLASS_ENTRY pClass;
UINT OverlayImage;
CONFIGRET cr;
/* Get device info for all devices of a particular class */
hDevInfo = SetupDiGetClassDevs(NULL,
NULL,
NULL,
DIGCF_PRESENT | DIGCF_ALLCLASSES);
if (hDevInfo == INVALID_HANDLE_VALUE)
return;
for (DevIndex = 0; ; DevIndex++)
{
ZeroMemory(&DeviceInfoData, sizeof(SP_DEVINFO_DATA));
DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
InstanceId = NULL;
DeviceName[0] = _T('\0');
OverlayImage = 0;
if (!SetupDiEnumDeviceInfo(hDevInfo,
DevIndex,
&DeviceInfoData))
break;
if (bShowHidden == FALSE &&
(IsEqualGUID(&DeviceInfoData.ClassGuid, &GUID_DEVCLASS_LEGACYDRIVER) ||
IsEqualGUID(&DeviceInfoData.ClassGuid, &GUID_DEVCLASS_VOLUME)))
continue;
pClass = GetClassFromClassGuid(pClassArray,
ulClassCount,
&DeviceInfoData.ClassGuid);
/* get the device ID */
if (!SetupDiGetDeviceInstanceId(hDevInfo,
&DeviceInfoData,
NULL,
0,
&DevIdSize))
{
if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
{
InstanceId = (LPTSTR)HeapAlloc(GetProcessHeap(),
0,
DevIdSize * sizeof(TCHAR));
if (InstanceId != NULL)
{
if (!SetupDiGetDeviceInstanceId(hDevInfo,
&DeviceInfoData,
InstanceId,
DevIdSize,
NULL))
{
HeapFree(GetProcessHeap(),
0,
InstanceId);
InstanceId = NULL;
}
}
}
}
/* Skip the root device */
if (InstanceId != NULL &&
_tcscmp(InstanceId, _T("HTREE\\ROOT\\0")) == 0)
{
HeapFree(GetProcessHeap(),
0,
InstanceId);
InstanceId = NULL;
continue;
}
/* Get the device's friendly name */
if (!SetupDiGetDeviceRegistryProperty(hDevInfo,
&DeviceInfoData,
SPDRP_FRIENDLYNAME,
0,
(BYTE*)DeviceName,
MAX_DEV_LEN,
NULL))
{
/* If the friendly name fails, try the description instead */
SetupDiGetDeviceRegistryProperty(hDevInfo,
&DeviceInfoData,
SPDRP_DEVICEDESC,
0,
(BYTE*)DeviceName,
MAX_DEV_LEN,
NULL);
}
cr = CM_Get_DevNode_Status_Ex(&Status,
&Problem,
DeviceInfoData.DevInst,
0,
NULL);
if ((cr == CR_SUCCESS) &&
(Status & DN_HAS_PROBLEM))
{
if (Problem == CM_PROB_DISABLED ||
Problem == CM_PROB_HARDWARE_DISABLED)
OverlayImage = 2;
else
OverlayImage = 1;
}
InsertIntoTreeView(hTreeView,
pClass->hItem,
DeviceName,
InstanceId,
pClass->ClassImage,
OverlayImage);
if (OverlayImage != 0)
{
/* Expand the class if the device has a problem */
(void)TreeView_Expand(hTreeView,
pClass->hItem,
TVE_EXPAND);
}
pClass->bUsed = TRUE;
}
if (hDevInfo != INVALID_HANDLE_VALUE)
SetupDiDestroyDeviceInfoList(hDevInfo);
}
static
VOID
CleanupDeviceClasses(
HWND hTreeView,
PDEVCLASS_ENTRY pClassArray,
ULONG ulClassCount)
{
PDEVCLASS_ENTRY pClass;
ULONG i;
for (i = 0; i < ulClassCount; i++)
{
pClass = &pClassArray[i];
if (pClass->bUsed == FALSE)
(void)TreeView_DeleteItem(hTreeView,
pClass->hItem);
else
(void)TreeView_SortChildren(hTreeView,
pClass->hItem,
0);
}
}
VOID
ListDevicesByType(HWND hTreeView,
HTREEITEM hRoot,
BOOL bShowHidden)
{
PDEVCLASS_ENTRY pClassArray;
ULONG ulClassCount;
ulClassCount = GetClassCount();
pClassArray = HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
ulClassCount * sizeof(DEVCLASS_ENTRY));
if (pClassArray == NULL)
return;
EnumDeviceClasses(hTreeView,
hRoot,
pClassArray,
ulClassCount);
EnumDevices(hTreeView,
pClassArray,
ulClassCount,
bShowHidden);
CleanupDeviceClasses(hTreeView,
pClassArray,
ulClassCount);
if (pClassArray != NULL)
HeapFree(GetProcessHeap(), 0, pClassArray);
(void)TreeView_Expand(hTreeView,
hRoot,
TVE_EXPAND);
(void)TreeView_SortChildren(hTreeView,
hRoot,
0);
(void)TreeView_SelectItem(hTreeView,
hRoot);
}
static HTREEITEM
AddDeviceToTree(HWND hTreeView,
HTREEITEM hRoot,
DEVINST dnDevInst,
BOOL bShowHidden)
{
TCHAR DevName[MAX_DEV_LEN];
TCHAR FriendlyName[MAX_DEV_LEN];
TCHAR ClassGuidString[MAX_GUID_STRING_LEN];
GUID ClassGuid;
ULONG ulLength;
LPTSTR DeviceID = NULL;
INT ClassImage = 24;
CONFIGRET cr;
ulLength = MAX_GUID_STRING_LEN * sizeof(TCHAR);
cr = CM_Get_DevNode_Registry_Property(dnDevInst,
CM_DRP_CLASSGUID,
NULL,
ClassGuidString,
&ulLength,
0);
if (cr == CR_SUCCESS)
{
pSetupGuidFromString(ClassGuidString, &ClassGuid);
if (bShowHidden == FALSE &&
(IsEqualGUID(&ClassGuid, &GUID_DEVCLASS_LEGACYDRIVER) ||
IsEqualGUID(&ClassGuid, &GUID_DEVCLASS_VOLUME)))
return NULL;
}
else
{
/* It's a device with no driver */
ClassGuid = GUID_DEVCLASS_UNKNOWN;
}
cr = CM_Get_Device_ID(dnDevInst,
DevName,
MAX_DEV_LEN,
0);
if (cr != CR_SUCCESS)
return NULL;
ulLength = MAX_DEV_LEN * sizeof(TCHAR);
cr = CM_Get_DevNode_Registry_Property(dnDevInst,
CM_DRP_FRIENDLYNAME,
NULL,
FriendlyName,
&ulLength,
0);
if (cr != CR_SUCCESS)
{
ulLength = MAX_DEV_LEN * sizeof(TCHAR);
cr = CM_Get_DevNode_Registry_Property(dnDevInst,
CM_DRP_DEVICEDESC,
NULL,
FriendlyName,
&ulLength,
0);
if (cr != CR_SUCCESS)
return NULL;
}
if (!SetupDiGetClassImageIndex(&ImageListData,
&ClassGuid,
&ClassImage))
{
/* FIXME: can we do this?
* Set the blank icon: IDI_SETUPAPI_BLANK = 41
* it'll be image 24 in the imagelist */
ClassImage = 24;
}
if (DevName != NULL)
{
DeviceID = HeapAlloc(GetProcessHeap(),
0,
(lstrlen(DevName) + 1) * sizeof(TCHAR));
if (DeviceID == NULL)
{
return NULL;
}
lstrcpy(DeviceID, DevName);
}
return InsertIntoTreeView(hTreeView,
hRoot,
FriendlyName,
DeviceID,
ClassImage,
0);
}
static VOID
EnumChildDevices(HWND hTreeView,
HTREEITEM hRoot,
DEVINST dnParentDevInst,
BOOL bShowHidden)
{
HTREEITEM hDevItem;
DEVINST dnDevInst;
CONFIGRET cr;
cr = CM_Get_Child(&dnDevInst,
dnParentDevInst,
0);
if (cr != CR_SUCCESS)
return;
hDevItem = AddDeviceToTree(hTreeView,
hRoot,
dnDevInst,
bShowHidden);
if (hDevItem != NULL)
{
EnumChildDevices(hTreeView,
hDevItem,
dnDevInst,
bShowHidden);
}
while (cr == CR_SUCCESS)
{
cr = CM_Get_Sibling(&dnDevInst,
dnDevInst,
0);
if (cr != CR_SUCCESS)
break;
hDevItem = AddDeviceToTree(hTreeView,
hRoot,
dnDevInst,
bShowHidden);
if (hDevItem != NULL)
{
EnumChildDevices(hTreeView,
hDevItem,
dnDevInst,
bShowHidden);
}
}
(void)TreeView_SortChildren(hTreeView,
hRoot,
0);
}
VOID
ListDevicesByConnection(HWND hTreeView,
HTREEITEM hRoot,
BOOL bShowHidden)
{
DEVINST devInst;
CONFIGRET cr;
cr = CM_Locate_DevNode(&devInst,
NULL,
CM_LOCATE_DEVNODE_NORMAL);
if (cr == CR_SUCCESS)
EnumChildDevices(hTreeView,
hRoot,
devInst,
bShowHidden);
(void)TreeView_Expand(hTreeView,
hRoot,
TVE_EXPAND);
(void)TreeView_SelectItem(hTreeView,
hRoot);
}
HTREEITEM
InitTreeView(HWND hTreeView)
{
HTREEITEM hRoot;
TCHAR ComputerName[MAX_PATH];
DWORD dwSize = MAX_PATH;
INT RootImage;
(void)TreeView_DeleteAllItems(hTreeView);
/* Get the device image list */
ImageListData.cbSize = sizeof(ImageListData);
SetupDiGetClassImageList(&ImageListData);
(void)TreeView_SetImageList(hTreeView,
ImageListData.ImageList,
TVSIL_NORMAL);
if (!GetComputerName(ComputerName,
&dwSize))
{
ComputerName[0] = _T('\0');
}
/* Get the image index of the computer class */
SetupDiGetClassImageIndex(&ImageListData,
&GUID_DEVCLASS_COMPUTER,
&RootImage);
/* Insert the root item into the tree */
hRoot = InsertIntoTreeView(hTreeView,
NULL,
ComputerName,
NULL,
RootImage,
0);
return hRoot;
}

View file

@ -1,83 +0,0 @@
LANGUAGE LANG_BULGARIAN, SUBLANG_DEFAULT
IDR_MAINMENU MENU
BEGIN
POPUP "&Файл"
BEGIN
MENUITEM "Из&ход", IDC_EXIT
END
POPUP "Действие"
BEGIN
MENUITEM "Отпечатване", IDC_PRINT, GRAYED
MENUITEM SEPARATOR
MENUITEM "Свойства", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Помощ", IDC_PROGHELP, GRAYED
END
POPUP "Изглед"
BEGIN
MENUITEM "Устройствата според вид", IDC_DEVBYTYPE
MENUITEM "Устройствата според свързването", IDC_DEVBYCONN
MENUITEM "Средствата според вида", IDC_RESBYTYPE, GRAYED
MENUITEM "Средствата според свързването", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "Show hidden devices", IDC_SHOWHIDDEN
END
POPUP "Помощ"
BEGIN
MENUITEM "Помощ", IDC_PROGHELP
MENUITEM "За", IDC_ABOUT
END
END
IDR_POPUP MENU
BEGIN
POPUP "popup"
BEGIN
MENUITEM "Свойства", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Помощ", IDC_PROGHELP
END
END
IDD_ABOUTBOX DIALOGEX 22, 16, 190, 182
CAPTION "За управителя на устройствата"
FONT 8, "MS Shell Dlg", 0, 0
STYLE DS_SHELLFONT | WS_BORDER | WS_DLGFRAME | WS_SYSMENU | DS_MODALFRAME
BEGIN
LTEXT "Device Manager v0.1\nCopyright (C) 2006\nby Ged Murphy (gedmurphy@gmail.com)", IDC_STATIC, 48, 7, 130, 30
PUSHBUTTON "Close", IDOK, 75, 162, 44, 15
ICON IDI_MAIN_ICON, IDC_STATIC, 10, 10, 7, 30
EDITTEXT IDC_LICENSE_EDIT, 8, 44, 174, 107, WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | ES_READONLY | ES_MULTILINE
END
STRINGTABLE
BEGIN
IDS_LICENSE "This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.\r\n\r\nThis program 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 General Public License for more details.\r\n\r\nYou should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA."
END
STRINGTABLE
BEGIN
IDS_TOOLTIP_PROP "Свойства"
IDS_TOOLTIP_REFRESH "Опресняване"
IDS_TOOLTIP_HELP "Помощ"
IDS_TOOLTIP_EXIT "Изход"
END
/* Hints */
STRINGTABLE
BEGIN
IDS_APPNAME "Управител на устройствата на РеактОС"
IDS_HINT_BLANK " "
IDS_HINT_EXIT " Излиза от приложението."
IDS_HINT_REFRESH " Опреснява списъка на услугите."
IDS_HINT_PROP " Отваря лист за свойства за текущия избор."
IDS_HINT_HELP " Показва помощен прозорец."
IDS_HINT_ABOUT " За управителя на устрйствата на РеактОС."
IDS_HINT_SYS_RESTORE " Възстановява прозореца до обичайния му рамер."
IDS_HINT_SYS_MOVE " Премества прозореца."
IDS_HINT_SYS_SIZE " Преоразмерява прозореца."
IDS_HINT_SYS_MINIMIZE " Свива прозореца в значка."
IDS_HINT_SYS_MAXIMIZE " Разгръща прозореца, докато запълни целия екран."
IDS_HINT_SYS_CLOSE " Затваря прозореца."
END

View file

@ -1,83 +0,0 @@
LANGUAGE LANG_CZECH, SUBLANG_DEFAULT
IDR_MAINMENU MENU
BEGIN
POPUP "&Soubor"
BEGIN
MENUITEM "&Konec", IDC_EXIT
END
POPUP "&Akce"
BEGIN
MENUITEM "Tisk", IDC_PRINT, GRAYED
MENUITEM SEPARATOR
MENUITEM "Vlastnosti", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Nápověda", IDC_PROGHELP, GRAYED
END
POPUP "&Zobrazení"
BEGIN
MENUITEM "Zařízení podle typu", IDC_DEVBYTYPE
MENUITEM "Zařízení podle připojení", IDC_DEVBYCONN
MENUITEM "Prostředky podle typu", IDC_RESBYTYPE, GRAYED
MENUITEM "Prostředky podle připojení", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "Zobrazit skrytá zařízení", IDC_SHOWHIDDEN
END
POPUP "Nápověda"
BEGIN
MENUITEM "Nápověda", IDC_PROGHELP
MENUITEM "O programu", IDC_ABOUT
END
END
IDR_POPUP MENU
BEGIN
POPUP "popup"
BEGIN
MENUITEM "Vlastnosti", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Nápověda", IDC_PROGHELP
END
END
IDD_ABOUTBOX DIALOGEX 22, 16, 190, 182
CAPTION "O Správci zařízení"
FONT 8, "MS Shell Dlg", 0, 0
STYLE DS_SHELLFONT | WS_BORDER | WS_DLGFRAME | WS_SYSMENU | DS_MODALFRAME
BEGIN
LTEXT "Správce zařízení v0.1\nCopyright (C) 2006\nby Ged Murphy (gedmurphy@gmail.com)", IDC_STATIC, 48, 7, 130, 30
PUSHBUTTON "Zavřít", IDOK, 75, 162, 44, 15
ICON IDI_MAIN_ICON, IDC_STATIC, 10, 10, 7, 30
EDITTEXT IDC_LICENSE_EDIT, 8, 44, 174, 107, WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | ES_READONLY | ES_MULTILINE
END
STRINGTABLE
BEGIN
IDS_LICENSE "This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.\r\n\r\nThis program 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 General Public License for more details.\r\n\r\nYou should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA."
END
STRINGTABLE
BEGIN
IDS_TOOLTIP_PROP "Vlastnosti"
IDS_TOOLTIP_REFRESH "Obnovit"
IDS_TOOLTIP_HELP "Nápověda"
IDS_TOOLTIP_EXIT "Konec"
END
/* Hints */
STRINGTABLE
BEGIN
IDS_APPNAME "ReactOS Správce zařízení"
IDS_HINT_BLANK " "
IDS_HINT_EXIT " Ukončit pogram."
IDS_HINT_REFRESH " Obnovit seznam zařízení."
IDS_HINT_PROP " Zobrazit kartu vlastností pro vybranou položku."
IDS_HINT_HELP " Zobrazit nápovědu."
IDS_HINT_ABOUT " O ReactOS Správci zařízení."
IDS_HINT_SYS_RESTORE " Obnoví normální velikost okna."
IDS_HINT_SYS_MOVE " Přesune okno."
IDS_HINT_SYS_SIZE " Změní velikost okna."
IDS_HINT_SYS_MINIMIZE " Minimalizuje okno."
IDS_HINT_SYS_MAXIMIZE " Maximalizuje okno."
IDS_HINT_SYS_CLOSE " Zavře toto okno."
END

View file

@ -1,83 +0,0 @@
LANGUAGE LANG_GERMAN, SUBLANG_NEUTRAL
IDR_MAINMENU MENU
BEGIN
POPUP "&Datei"
BEGIN
MENUITEM "&Beenden", IDC_EXIT
END
POPUP "Aktion"
BEGIN
MENUITEM "Drucken", IDC_PRINT, GRAYED
MENUITEM SEPARATOR
MENUITEM "Eigenschaften", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Hilfe", IDC_PROGHELP, GRAYED
END
POPUP "Ansicht"
BEGIN
MENUITEM "Geräte nach Typ", IDC_DEVBYTYPE
MENUITEM "Geräte nach Verbindung", IDC_DEVBYCONN
MENUITEM "Resourcen nach Typ", IDC_RESBYTYPE, GRAYED
MENUITEM "Resourcen nach Verbindung", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "Ausgeblendete Geräte anzeigen", IDC_SHOWHIDDEN
END
POPUP "&?"
BEGIN
MENUITEM "Hilfe", IDC_PROGHELP
MENUITEM "Info", IDC_ABOUT
END
END
IDR_POPUP MENU
BEGIN
POPUP "popup"
BEGIN
MENUITEM "Eigenschaften", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Hilfe", IDC_PROGHELP
END
END
IDD_ABOUTBOX DIALOGEX 22, 16, 190, 182
CAPTION "Über Geräte-Manager"
FONT 8, "MS Shell Dlg", 0, 0
STYLE DS_SHELLFONT | WS_BORDER | WS_DLGFRAME | WS_SYSMENU | DS_MODALFRAME
BEGIN
LTEXT "Geräte-Manager v0.1\nCopyright (C) 2006\nby Ged Murphy (gedmurphy@gmail.com)", IDC_STATIC, 48, 7, 130, 26
PUSHBUTTON "Schließen", IDOK, 75, 162, 44, 15
ICON IDI_MAIN_ICON, IDC_STATIC, 10, 10, 7, 30
EDITTEXT IDC_LICENSE_EDIT, 8, 44, 174, 107, WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | ES_READONLY | ES_MULTILINE
END
STRINGTABLE
BEGIN
IDS_LICENSE "Dieses Programm ist Freie Software: Sie können es unter den Bedingungen der GNU General Public License, wie von der Free Software Foundation, Version 2.1 der Lizenz oder (nach Ihrer Wahl) jeder neueren veröffentlichten Version, weiterverbreiten und/oder modifizieren.\r\n\r\nDieses Programm wird in der Hoffnung, dass es nützlich sein wird, aber OHNE JEDE GEWÄHRLEISTUNG, bereitgestellt; sogar ohne die implizite Gewährleistung der MARKTFÄHIGKEIT oder EIGNUNG FÜR EINEN BESTIMMTEN ZWECK.\r\n\r\nSie sollten eine Kopie der GNU General Public License zusammen mit diesem Programm erhalten haben. Wenn nicht, siehe <http://www.gnu.org/licenses/>."
END
STRINGTABLE
BEGIN
IDS_TOOLTIP_PROP "Eigenschaften"
IDS_TOOLTIP_REFRESH "Aktualisieren"
IDS_TOOLTIP_HELP "Hilfe"
IDS_TOOLTIP_EXIT "Beenden"
END
/* Hints */
STRINGTABLE
BEGIN
IDS_APPNAME "ReactOS Geräte-Manager"
IDS_HINT_BLANK " "
IDS_HINT_EXIT " Das Programm beenden."
IDS_HINT_REFRESH " Die Service-Liste aktualisieren."
IDS_HINT_PROP " Eigenschaften für die aktuelle Auswahl anzeigen."
IDS_HINT_HELP " Hilfe-Fenster anzeigen."
IDS_HINT_ABOUT " Über ReactOS Geräte-Manager."
IDS_HINT_SYS_RESTORE " Dieses Fenster auf normale Größe wiederherstellen."
IDS_HINT_SYS_MOVE " Dieses Fenster verschieben."
IDS_HINT_SYS_SIZE " Größe dieses Fensters ändern."
IDS_HINT_SYS_MINIMIZE " Dieses Fenster zu einem Symbol verkleinern."
IDS_HINT_SYS_MAXIMIZE " Dieses Fenster auf Bildschirmgröße vergrößern."
IDS_HINT_SYS_CLOSE " Dieses Fenster schließen."
END

View file

@ -1,83 +0,0 @@
LANGUAGE LANG_GREEK, SUBLANG_DEFAULT
IDR_MAINMENU MENU
BEGIN
POPUP "&Αρχείο"
BEGIN
MENUITEM "Έ&ξοδος", IDC_EXIT
END
POPUP "Ενέργεια"
BEGIN
MENUITEM "Εκτύπωση", IDC_PRINT, GRAYED
MENUITEM SEPARATOR
MENUITEM "Ιδιότητες", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Βοήθεια", IDC_PROGHELP, GRAYED
END
POPUP "Εμφάνιση"
BEGIN
MENUITEM "Συσκευές ανά τύπο", IDC_DEVBYTYPE
MENUITEM "Συσκευές ανά σύνδεση", IDC_DEVBYCONN
MENUITEM "Πηγές ανά τύπο", IDC_RESBYTYPE, GRAYED
MENUITEM "Πηγές ανά σύνδεση", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "Show hidden devices", IDC_SHOWHIDDEN
END
POPUP "Βοήθεια"
BEGIN
MENUITEM "Βοήθεια", IDC_PROGHELP
MENUITEM "Σχετικά...", IDC_ABOUT
END
END
IDR_POPUP MENU
BEGIN
POPUP "popup"
BEGIN
MENUITEM "Ιδιότητες", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Βοήθεια", IDC_PROGHELP
END
END
IDD_ABOUTBOX DIALOGEX 22, 16, 190, 182
CAPTION "Σχετικά με η διαχείριση συσκεών"
FONT 8, "MS Shell Dlg", 0, 0
STYLE DS_SHELLFONT | WS_BORDER | WS_DLGFRAME | WS_SYSMENU | DS_MODALFRAME
BEGIN
LTEXT "Device Manager v0.1\nCopyright (C) 2006\nby Ged Murphy (gedmurphy@gmail.com)", IDC_STATIC, 48, 7, 130, 26
PUSHBUTTON "Close", IDOK, 75, 162, 44, 15
ICON IDI_MAIN_ICON, IDC_STATIC, 10, 10, 7, 30
EDITTEXT IDC_LICENSE_EDIT, 8, 44, 174, 107, WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | ES_READONLY | ES_MULTILINE
END
STRINGTABLE
BEGIN
IDS_LICENSE "This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.\r\n\r\nThis program 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 General Public License for more details.\r\n\r\nYou should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA."
END
STRINGTABLE
BEGIN
IDS_TOOLTIP_PROP "Ιδιότητες"
IDS_TOOLTIP_REFRESH "Ανανέωση"
IDS_TOOLTIP_HELP "Βοήθεια"
IDS_TOOLTIP_EXIT "Έξοδος"
END
/* Hints */
STRINGTABLE
BEGIN
IDS_APPNAME "Διαχείριση Συσκευών του ReactOS"
IDS_HINT_BLANK " "
IDS_HINT_EXIT " Τερματίζει το πρόγραμμα."
IDS_HINT_REFRESH " Ανανέωση της λίστας διεργασιών."
IDS_HINT_PROP " Άνοιγμα παραθύρου ιδιοτήτων για τη συγκεκριμένη επιλογή."
IDS_HINT_HELP " Εμφάνιση παραθύρου βοήθειας."
IDS_HINT_ABOUT " Σχετικά με τη Διαχείριση Συσκευών του ReactOS."
IDS_HINT_SYS_RESTORE " Επαναφέρει το παράθυρο αυτό στο κανονικο του μέγεθος."
IDS_HINT_SYS_MOVE " Μετακινεί αυτό το παράθυρο."
IDS_HINT_SYS_SIZE " Αλλάζει το μέγεθος αυτού του παραθύρου."
IDS_HINT_SYS_MINIMIZE " Μικραίνει αυτό το παράθυρο σε ένα εικονίδιο."
IDS_HINT_SYS_MAXIMIZE " Προσαρμόζει το μέγεθος του παραθύρου αυτού στην οθόνη."
IDS_HINT_SYS_CLOSE " Κλείνει αυτό το παράθυρο."
END

View file

@ -1,83 +0,0 @@
LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
IDR_MAINMENU MENU
BEGIN
POPUP "&File"
BEGIN
MENUITEM "E&xit", IDC_EXIT
END
POPUP "Action"
BEGIN
MENUITEM "Print", IDC_PRINT, GRAYED
MENUITEM SEPARATOR
MENUITEM "Properties", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Help", IDC_PROGHELP, GRAYED
END
POPUP "View"
BEGIN
MENUITEM "Devices by type", IDC_DEVBYTYPE
MENUITEM "Devices by connection", IDC_DEVBYCONN
MENUITEM "Resources by type", IDC_RESBYTYPE, GRAYED
MENUITEM "Resources by connection", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "Show hidden devices", IDC_SHOWHIDDEN
END
POPUP "Help"
BEGIN
MENUITEM "Help", IDC_PROGHELP
MENUITEM "About", IDC_ABOUT
END
END
IDR_POPUP MENU
BEGIN
POPUP "popup"
BEGIN
MENUITEM "Properties", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Help", IDC_PROGHELP
END
END
IDD_ABOUTBOX DIALOGEX 22, 16, 190, 182
CAPTION "About Device Manager"
FONT 8, "MS Shell Dlg", 0, 0
STYLE DS_SHELLFONT | WS_BORDER | WS_DLGFRAME | WS_SYSMENU | DS_MODALFRAME
BEGIN
LTEXT "Device Manager v0.1\nCopyright (C) 2006\nby Ged Murphy (gedmurphy@gmail.com)", IDC_STATIC, 48, 7, 130, 30
PUSHBUTTON "Close", IDOK, 75, 162, 44, 15
ICON IDI_MAIN_ICON, IDC_STATIC, 10, 10, 7, 30
EDITTEXT IDC_LICENSE_EDIT, 8, 44, 174, 107, WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | ES_READONLY | ES_MULTILINE
END
STRINGTABLE
BEGIN
IDS_LICENSE "This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.\r\n\r\nThis program 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 General Public License for more details.\r\n\r\nYou should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA."
END
STRINGTABLE
BEGIN
IDS_TOOLTIP_PROP "Properties"
IDS_TOOLTIP_REFRESH "Refresh"
IDS_TOOLTIP_HELP "Help"
IDS_TOOLTIP_EXIT "Exit"
END
/* Hints */
STRINGTABLE
BEGIN
IDS_APPNAME "ReactOS Device Manager"
IDS_HINT_BLANK " "
IDS_HINT_EXIT " Exits the program."
IDS_HINT_REFRESH " Refresh the service list."
IDS_HINT_PROP " Open property sheet for the current selection."
IDS_HINT_HELP " Display help window."
IDS_HINT_ABOUT " About ReactOS Device Manager."
IDS_HINT_SYS_RESTORE " Restores this window to normal size."
IDS_HINT_SYS_MOVE " Moves this window."
IDS_HINT_SYS_SIZE " Resizes this window."
IDS_HINT_SYS_MINIMIZE " Collapses this window to an icon."
IDS_HINT_SYS_MAXIMIZE " Expands this window to fill this screen."
IDS_HINT_SYS_CLOSE " Closes this window."
END

View file

@ -1,89 +0,0 @@
/*
* Spanish Language resource file
* Traducido por: Javier Remacha 2007-12-21
* Corregido por: Ismael Ferrera Morezuelas 2014-12-31
*/
LANGUAGE LANG_SPANISH, SUBLANG_NEUTRAL
IDR_MAINMENU MENU
BEGIN
POPUP "&Archivo"
BEGIN
MENUITEM "&Salir", IDC_EXIT
END
POPUP "Acción"
BEGIN
MENUITEM "Imprimir", IDC_PRINT, GRAYED
MENUITEM SEPARATOR
MENUITEM "Propiedades", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Ayuda", IDC_PROGHELP, GRAYED
END
POPUP "Ver"
BEGIN
MENUITEM "Dispositivos por tipo", IDC_DEVBYTYPE
MENUITEM "Dispositivos por conexión", IDC_DEVBYCONN
MENUITEM "Recursos por tipo", IDC_RESBYTYPE, GRAYED
MENUITEM "Recursos por conexión", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "Mostrar dispositivos ocultos", IDC_SHOWHIDDEN
END
POPUP "Ayuda"
BEGIN
MENUITEM "Ayuda", IDC_PROGHELP
MENUITEM "Acerca de", IDC_ABOUT
END
END
IDR_POPUP MENU
BEGIN
POPUP "popup"
BEGIN
MENUITEM "Propiedades", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Ayuda", IDC_PROGHELP
END
END
IDD_ABOUTBOX DIALOGEX 22, 16, 190, 182
CAPTION "Acerca del Administrador de dispositivos"
FONT 8, "MS Shell Dlg", 0, 0
STYLE DS_SHELLFONT | WS_BORDER | WS_DLGFRAME | WS_SYSMENU | DS_MODALFRAME
BEGIN
LTEXT "Administrador de dispositivos v0.1\nCopyright (C) 2006\nCreado por Ged Murphy (gedmurphy@gmail.com)", IDC_STATIC, 48, 7, 130, 26
PUSHBUTTON "Cerrar", IDOK, 75, 162, 44, 15
ICON IDI_MAIN_ICON, IDC_STATIC, 10, 10, 7, 30
EDITTEXT IDC_LICENSE_EDIT, 8, 44, 174, 107, WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | ES_READONLY | ES_MULTILINE
END
STRINGTABLE
BEGIN
IDS_LICENSE "Este programa es software libre; puedes redistribuirlo y/o modificarlo bajo los términos de la GNU General Public License tal y como fueron publicados por la Free Software Foundation; ya sea la versión 2 de la Licencia, o (bajo tu discreción) cualquier versión posterior.\r\n\r\nEste programa se distribuye con el fin de ser útil, pero viene SIN NINGUNA GARANTÍA; sin tan siquiera la garantía implícita de COMERCIALIZACIÓN o la de IDONEIDAD PARA UN PROPÓSITO CONCRETO. Para más información lee la GNU General Public License.\r\n\r\nDeberías de haber recibido una copia de la GNU General Public License con el programa; si no, puedes escribir a la Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 EE.UU."
END
STRINGTABLE
BEGIN
IDS_TOOLTIP_PROP "Propiedades"
IDS_TOOLTIP_REFRESH "Actualizar"
IDS_TOOLTIP_HELP "Ayuda"
IDS_TOOLTIP_EXIT "Salir"
END
/* Hints */
STRINGTABLE
BEGIN
IDS_APPNAME "Administrador de dispositivos de ReactOS"
IDS_HINT_BLANK " "
IDS_HINT_EXIT " Cierra el programa."
IDS_HINT_REFRESH " Actualizar la lista de servicios."
IDS_HINT_PROP " Abre la pestaña de propiedades de la selección actual."
IDS_HINT_HELP " Mostrar la ventana de ayuda."
IDS_HINT_ABOUT " Acerca del Administrador de dispositivos de ReactOS."
IDS_HINT_SYS_RESTORE " Devuelve esta ventana al tamaño normal."
IDS_HINT_SYS_MOVE " Mueve esta ventana."
IDS_HINT_SYS_SIZE " Redimensiona esta ventana."
IDS_HINT_SYS_MINIMIZE " Contrae esta ventana en un icono."
IDS_HINT_SYS_MAXIMIZE " Expande esta ventana hasta ocupar la pantalla."
IDS_HINT_SYS_CLOSE " Cierra esta ventana."
END

View file

@ -1,83 +0,0 @@
LANGUAGE LANG_FRENCH, SUBLANG_NEUTRAL
IDR_MAINMENU MENU
BEGIN
POPUP "&Fichier"
BEGIN
MENUITEM "&Quitter", IDC_EXIT
END
POPUP "Action"
BEGIN
MENUITEM "Imprimer", IDC_PRINT, GRAYED
MENUITEM SEPARATOR
MENUITEM "Propriétés", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Aide", IDC_PROGHELP, GRAYED
END
POPUP "Affichage"
BEGIN
MENUITEM "Périphériques par type", IDC_DEVBYTYPE
MENUITEM "Périphériques par connexion", IDC_DEVBYCONN
MENUITEM "Ressources par type", IDC_RESBYTYPE, GRAYED
MENUITEM "Ressources par connexion", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "Afficher les périphériques cachés", IDC_SHOWHIDDEN
END
POPUP "Aide"
BEGIN
MENUITEM "Aide", IDC_PROGHELP
MENUITEM "À propos", IDC_ABOUT
END
END
IDR_POPUP MENU
BEGIN
POPUP "popup"
BEGIN
MENUITEM "Propriétés", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Aide", IDC_PROGHELP
END
END
IDD_ABOUTBOX DIALOGEX 22, 16, 190, 182
CAPTION "À propos du Gestionnaire de Périphériques"
FONT 8, "MS Shell Dlg", 0, 0
STYLE DS_SHELLFONT | WS_BORDER | WS_DLGFRAME | WS_SYSMENU | DS_MODALFRAME
BEGIN
LTEXT "Gestionnaire de Périphériques v0.1\nCopyright (C) 2006\npar Ged Murphy (gedmurphy@gmail.com)", IDC_STATIC, 48, 7, 130, 26
PUSHBUTTON "Fermer", IDOK, 75, 162, 44, 15
ICON IDI_MAIN_ICON, IDC_STATIC, 10, 10, 7, 30
EDITTEXT IDC_LICENSE_EDIT, 8, 44, 174, 107, WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | ES_READONLY | ES_MULTILINE
END
STRINGTABLE
BEGIN
IDS_LICENSE "Ce programme est un logiciel libre ; vous pouvez le redistribuer et/ou le modifier tout en respectant les termes de la ""GNU General Public License"" publiée par la Free Software Foundation; dans sa version 2 (ou selon votre préférence) toute version ultérieure.\r\n\r\nCe programme est distribué dans l'espoir qu'il sera utile, cependant SANS GARANTIE D'AUCUNE SORTE ; sans même une garantie implicite de COMMERCIABILITÉ ou DE CONFORMITÉ À UNE UTILISATION PARTICULIÈRE. \r\n\r\nVoir la Licence Publique Générale GNU pour plus de détails. Vous devriez avoir reçu un exemplaire de la Licence Publique Générale GNU avec ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA."
END
STRINGTABLE
BEGIN
IDS_TOOLTIP_PROP "Propriétés"
IDS_TOOLTIP_REFRESH "Actualiser"
IDS_TOOLTIP_HELP "Aide"
IDS_TOOLTIP_EXIT "Quitter"
END
/* Hints */
STRINGTABLE
BEGIN
IDS_APPNAME "Gestionnaire de périphériques ReactOS"
IDS_HINT_BLANK " "
IDS_HINT_EXIT " Quitte le programme."
IDS_HINT_REFRESH " Actualise la liste des périphériques."
IDS_HINT_PROP " Ouvre la feuille de propriétés pour la sélection actuelle."
IDS_HINT_HELP " Affiche la fenêtre d'aide."
IDS_HINT_ABOUT " À propos du Gestionnaire de Périphériques de ReactOS."
IDS_HINT_SYS_RESTORE " Restaure cette fenêtre à sa taille normale."
IDS_HINT_SYS_MOVE " Déplace cette fenêtre."
IDS_HINT_SYS_SIZE " Redimensionne cette fenêtre."
IDS_HINT_SYS_MINIMIZE " Réduit cette fenêtre à une icône."
IDS_HINT_SYS_MAXIMIZE " Étend cette fenêtre à l'écran."
IDS_HINT_SYS_CLOSE " Ferme cette fenêtre."
END

View file

@ -1,83 +0,0 @@
LANGUAGE LANG_HEBREW, SUBLANG_DEFAULT
IDR_MAINMENU MENU
BEGIN
POPUP "&קובץ"
BEGIN
MENUITEM "&יציאה", IDC_EXIT
END
POPUP "פעולה"
BEGIN
MENUITEM "הדפס", IDC_PRINT, GRAYED
MENUITEM SEPARATOR
MENUITEM "מאפיינים", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "עזרה", IDC_PROGHELP, GRAYED
END
POPUP "תצוגה"
BEGIN
MENUITEM "התקנים לפי סוג", IDC_DEVBYTYPE
MENUITEM "התקנים לפי חיבור", IDC_DEVBYCONN
MENUITEM "משאבים לפי סוג", IDC_RESBYTYPE, GRAYED
MENUITEM "משאבים לפי חיבור", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "הראה התקנים מוסתרים", IDC_SHOWHIDDEN
END
POPUP "עזרה"
BEGIN
MENUITEM "עזרה", IDC_PROGHELP
MENUITEM "אודות", IDC_ABOUT
END
END
IDR_POPUP MENU
BEGIN
POPUP "popup"
BEGIN
MENUITEM "מאפיינים", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "עזרה", IDC_PROGHELP
END
END
IDD_ABOUTBOX DIALOGEX 22, 16, 190, 182
CAPTION "אודות מנהל ההתקנים"
FONT 8, "MS Shell Dlg", 0, 0
STYLE DS_SHELLFONT | WS_BORDER | WS_DLGFRAME | WS_SYSMENU | DS_MODALFRAME
BEGIN
LTEXT "Device Manager v0.1\nCopyright (C) 2006\nby Ged Murphy (gedmurphy@gmail.com)", IDC_STATIC, 48, 7, 130, 30
PUSHBUTTON "סגור", IDOK, 75, 162, 44, 15
ICON IDI_MAIN_ICON, IDC_STATIC, 10, 10, 7, 30
EDITTEXT IDC_LICENSE_EDIT, 8, 44, 174, 107, WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | ES_READONLY | ES_MULTILINE
END
STRINGTABLE
BEGIN
IDS_LICENSE "This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.\r\n\r\nThis program 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 General Public License for more details.\r\n\r\nYou should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA."
END
STRINGTABLE
BEGIN
IDS_TOOLTIP_PROP "מאפיינים"
IDS_TOOLTIP_REFRESH "רענן"
IDS_TOOLTIP_HELP "עזרה"
IDS_TOOLTIP_EXIT "יציאה"
END
/* Hints */
STRINGTABLE
BEGIN
IDS_APPNAME "מנהל ההתקנים של ReactOS"
IDS_HINT_BLANK " "
IDS_HINT_EXIT " סוגר את התכנית."
IDS_HINT_REFRESH " מרענן את רשימת השירותים."
IDS_HINT_PROP " Open property sheet for the current selection."
IDS_HINT_HELP " מראה חלון עזרה."
IDS_HINT_ABOUT " אודות מנהל ההתקנים של ReactOS"
IDS_HINT_SYS_RESTORE " מחזיר את החלון לגודלו הרגיל"
IDS_HINT_SYS_MOVE " מזיז חלון זה"
IDS_HINT_SYS_SIZE " משנה גודל חלון זה"
IDS_HINT_SYS_MINIMIZE " מוריד חלון זה לסמל"
IDS_HINT_SYS_MAXIMIZE " מרחיב את החלון לכל המסך."
IDS_HINT_SYS_CLOSE " סוגר חלון זה."
END

View file

@ -1,83 +0,0 @@
LANGUAGE LANG_INDONESIAN, SUBLANG_DEFAULT
IDR_MAINMENU MENU
BEGIN
POPUP "&File"
BEGIN
MENUITEM "E&xit", IDC_EXIT
END
POPUP "Aksi"
BEGIN
MENUITEM "Cetak", IDC_PRINT, GRAYED
MENUITEM SEPARATOR
MENUITEM "Properti", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Bantuan", IDC_PROGHELP, GRAYED
END
POPUP "Lihat"
BEGIN
MENUITEM "Device dengan tipe", IDC_DEVBYTYPE
MENUITEM "Device dengan koneksi", IDC_DEVBYCONN
MENUITEM "Resource dengan tipe", IDC_RESBYTYPE, GRAYED
MENUITEM "Resource dengan koneksi", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "Show hidden devices", IDC_SHOWHIDDEN
END
POPUP "Bantuan"
BEGIN
MENUITEM "Bantuan", IDC_PROGHELP
MENUITEM "Tentang", IDC_ABOUT
END
END
IDR_POPUP MENU
BEGIN
POPUP "popup"
BEGIN
MENUITEM "Properti", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Bantuan", IDC_PROGHELP
END
END
IDD_ABOUTBOX DIALOGEX 22, 16, 190, 182
CAPTION "Tentang Manajer Device"
FONT 8, "MS Shell Dlg", 0, 0
STYLE DS_SHELLFONT | WS_BORDER | WS_DLGFRAME | WS_SYSMENU | DS_MODALFRAME
BEGIN
LTEXT "Manajer Device v0.1\nHak Cipta (C) 2006\nby Ged Murphy (gedmurphy@gmail.com)", IDC_STATIC, 48, 7, 130, 26
PUSHBUTTON "Tutup", IDOK, 75, 162, 44, 15
ICON IDI_MAIN_ICON, IDC_STATIC, 10, 10, 7, 30
EDITTEXT IDC_LICENSE_EDIT, 8, 44, 174, 107, WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | ES_READONLY | ES_MULTILINE
END
STRINGTABLE
BEGIN
IDS_LICENSE "Program ini adalah software bebas; anda dapat mendistribusikan dan/atau mengubahnya di bawah term GNU General Public License seperti dipublikasikan oleh Free Software Foundation; baik Lisensi versi 2, atau (menurut opini anda) setiap versi berikutnya.\r\n\r\nProgram ini didistribusikan dengan harapan ia akan berguna, tetapi TANPA JAMINAN APAPUN; bahkan tanpa jaminan berarti dari MERCANTABILITAS atau KECUKUPAN UNTUK KEPERLUAN TERTENTU. Lihat GNU General Public License untuk lebih jelasnya.\r\n\r\nAnda seharusnya menerima duplikat GNU General Public License bersamaan dengan program ini; jika tidak, tulis ke Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA."
END
STRINGTABLE
BEGIN
IDS_TOOLTIP_PROP "Properti"
IDS_TOOLTIP_REFRESH "Segarkan"
IDS_TOOLTIP_HELP "Bantuan"
IDS_TOOLTIP_EXIT "Keluar"
END
/* Hints */
STRINGTABLE
BEGIN
IDS_APPNAME "Manajer Device ReactOS"
IDS_HINT_BLANK " "
IDS_HINT_EXIT " Keluar dari program."
IDS_HINT_REFRESH " Segarkan daftar layanan."
IDS_HINT_PROP " VBuka lembar properti untuk pilihan saat ini."
IDS_HINT_HELP " Menampilkan jendela bantuan."
IDS_HINT_ABOUT " Tentang Manajer Device ReactOS."
IDS_HINT_SYS_RESTORE " Menyimpan kembali jendela ini ke ukuran normal."
IDS_HINT_SYS_MOVE " Memindahkan jendela ini."
IDS_HINT_SYS_SIZE " Mengukur ulang jendela ini."
IDS_HINT_SYS_MINIMIZE " Menyempitkan jendela ini menjadi ikon."
IDS_HINT_SYS_MAXIMIZE " Melebarkan jendela ini untuk memenuhi layar ini."
IDS_HINT_SYS_CLOSE " Menutup jendela ini."
END

View file

@ -1,83 +0,0 @@
LANGUAGE LANG_ITALIAN, SUBLANG_NEUTRAL
IDR_MAINMENU MENU
BEGIN
POPUP "&File"
BEGIN
MENUITEM "E&sci", IDC_EXIT
END
POPUP "Azioni"
BEGIN
MENUITEM "Stampa", IDC_PRINT, GRAYED
MENUITEM SEPARATOR
MENUITEM "Proprietà", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Aiuto", IDC_PROGHELP, GRAYED
END
POPUP "Visualizza"
BEGIN
MENUITEM "Dispositivi per tipo", IDC_DEVBYTYPE
MENUITEM "Dispositivi per connessione", IDC_DEVBYCONN
MENUITEM "Risorse per tipo", IDC_RESBYTYPE, GRAYED
MENUITEM "Risorse per connessione", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "Mostra periferiche nascoste", IDC_SHOWHIDDEN
END
POPUP "Aiuto"
BEGIN
MENUITEM "Aiuto", IDC_PROGHELP
MENUITEM "Informazioni su", IDC_ABOUT
END
END
IDR_POPUP MENU
BEGIN
POPUP "popup"
BEGIN
MENUITEM "Proprietà", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Aiuto", IDC_PROGHELP
END
END
IDD_ABOUTBOX DIALOGEX 22, 16, 190, 182
CAPTION "Informazioni su Gestione Dispositivi"
FONT 8, "MS Shell Dlg", 0, 0
STYLE DS_SHELLFONT | WS_BORDER | WS_DLGFRAME | WS_SYSMENU | DS_MODALFRAME
BEGIN
LTEXT "Gestione dispositivi v0.1\nCopyright (C) 2006\nby Ged Murphy (gedmurphy@gmail.com)", IDC_STATIC, 48, 7, 130, 26
PUSHBUTTON "Chiudi", IDOK, 75, 162, 44, 15
ICON IDI_MAIN_ICON, IDC_STATIC, 10, 10, 7, 30
EDITTEXT IDC_LICENSE_EDIT, 8, 44, 174, 107, WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | ES_READONLY | ES_MULTILINE
END
STRINGTABLE
BEGIN
IDS_LICENSE "Questo programma è software libero; puoi distribuirlo e/o modificarlo nei termini di licenza di 'GNU General Public License' come pubblicata dalla 'Free Software Foundation'; entrambe le versioni 2 della Licenza, o (a vostra scelta) qualunque versione successiva.\r\n\r\nQuesto programma è distribuito con l'augurio che sia utile, ma PRIVO DI OGNI GARANZIA; privo anche della garanzia implicita di COMMERCIABILITÀ o UTILIZZABILITÀ PER UNO SPECIFICO USO. Vedi la 'GNU General Public License' per ulteriori dettagli.\r\n\r\nVoi dovreste aver ricevuto una copia della 'GNU General Public License' assieme a questo programma; se non è cosi' scrivete a 'Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.."
END
STRINGTABLE
BEGIN
IDS_TOOLTIP_PROP "Proprietà"
IDS_TOOLTIP_REFRESH "Aggiorna"
IDS_TOOLTIP_HELP "Aiuto"
IDS_TOOLTIP_EXIT "Esci"
END
/* Hints */
STRINGTABLE
BEGIN
IDS_APPNAME "ReactOS: Gestione Dispositivi"
IDS_HINT_BLANK " "
IDS_HINT_EXIT " Esci dal programma."
IDS_HINT_REFRESH " Aggiorna la lista dei servizi."
IDS_HINT_PROP " Apri le proprietà per la selezione attuale."
IDS_HINT_HELP " Visualizza la finestra di aiuto."
IDS_HINT_ABOUT " Informazioni su Gestione dispositivi di ReactOS."
IDS_HINT_SYS_RESTORE " Ripristina la dimensione normale di questa finestra."
IDS_HINT_SYS_MOVE " Muove questa finestra."
IDS_HINT_SYS_SIZE " Cambia la dimensione di questa finestra."
IDS_HINT_SYS_MINIMIZE " Riduce a icona questa finestra."
IDS_HINT_SYS_MAXIMIZE " Espande questa finestra fino a riempire lo schermo."
IDS_HINT_SYS_CLOSE " Chiude questa finestra."
END

View file

@ -1,83 +0,0 @@
LANGUAGE LANG_JAPANESE, SUBLANG_DEFAULT
IDR_MAINMENU MENU
BEGIN
POPUP "ファイル(&F)"
BEGIN
MENUITEM "終了(&X)", IDC_EXIT
END
POPUP "操作"
BEGIN
MENUITEM "印刷", IDC_PRINT, GRAYED
MENUITEM SEPARATOR
MENUITEM "プロパティ", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "ヘルプ", IDC_PROGHELP, GRAYED
END
POPUP "表示"
BEGIN
MENUITEM "デバイス (種類別)", IDC_DEVBYTYPE
MENUITEM "デバイス (接続別)", IDC_DEVBYCONN
MENUITEM "リソース (種類別)", IDC_RESBYTYPE, GRAYED
MENUITEM "リソース (接続別)", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "Show hidden devices", IDC_SHOWHIDDEN
END
POPUP "ヘルプ"
BEGIN
MENUITEM "ヘルプ", IDC_PROGHELP
MENUITEM "バージョン情報", IDC_ABOUT
END
END
IDR_POPUP MENU
BEGIN
POPUP "popup"
BEGIN
MENUITEM "プロパティ", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "ヘルプ", IDC_PROGHELP
END
END
IDD_ABOUTBOX DIALOGEX 22, 16, 190, 182
CAPTION "デバイス マネージャについて"
FONT 9, "MS UI Gothic", 0, 0
STYLE DS_SHELLFONT | WS_BORDER | WS_DLGFRAME | WS_SYSMENU | DS_MODALFRAME
BEGIN
LTEXT "デバイス マネージャ v0.1\nCopyright (C) 2006\nby Ged Murphy (gedmurphy@gmail.com)", IDC_STATIC, 48, 7, 130, 30
PUSHBUTTON "閉じる", IDOK, 75, 162, 44, 15
ICON IDI_MAIN_ICON, IDC_STATIC, 10, 10, 7, 30
EDITTEXT IDC_LICENSE_EDIT, 8, 44, 174, 107, WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | ES_READONLY | ES_MULTILINE
END
STRINGTABLE
BEGIN
IDS_LICENSE "This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.\r\n\r\nThis program 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 General Public License for more details.\r\n\r\nYou should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA."
END
STRINGTABLE
BEGIN
IDS_TOOLTIP_PROP "プロパティ"
IDS_TOOLTIP_REFRESH "更新"
IDS_TOOLTIP_HELP "ヘルプ"
IDS_TOOLTIP_EXIT "終了"
END
/* Hints */
STRINGTABLE
BEGIN
IDS_APPNAME "ReactOS デバイス マネージャ"
IDS_HINT_BLANK " "
IDS_HINT_EXIT " このプログラムを終了します。"
IDS_HINT_REFRESH " サービスのリストを更新します。"
IDS_HINT_PROP " 現在選択されているシートのプロパティを開きます。"
IDS_HINT_HELP " ヘルプ ウィンドウを表示します。"
IDS_HINT_ABOUT " ReactOS デバイス マネージャについて表示します。"
IDS_HINT_SYS_RESTORE " このウィンドウを通常の大きさに復元します。"
IDS_HINT_SYS_MOVE " このウィンドウを移動します。"
IDS_HINT_SYS_SIZE " このウィンドウの大きさを変更します。"
IDS_HINT_SYS_MINIMIZE " このウィンドウをアイコンに折りたたみます。"
IDS_HINT_SYS_MAXIMIZE " このウィンドウを画面いっぱいに開きます。"
IDS_HINT_SYS_CLOSE " このウィンドウを閉じます。"
END

View file

@ -1,85 +0,0 @@
/* Korean translation by manatails007(www.manatails007.org) */
LANGUAGE LANG_KOREAN, SUBLANG_DEFAULT
IDR_MAINMENU MENU
BEGIN
POPUP "파일(&F)"
BEGIN
MENUITEM "종료(&X)", IDC_EXIT
END
POPUP "액션"
BEGIN
MENUITEM "프린트", IDC_PRINT, GRAYED
MENUITEM SEPARATOR
MENUITEM "속성", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "도움말", IDC_PROGHELP, GRAYED
END
POPUP "보기"
BEGIN
MENUITEM "Devices by type", IDC_DEVBYTYPE
MENUITEM "Devices by connection", IDC_DEVBYCONN
MENUITEM "Resources by type", IDC_RESBYTYPE, GRAYED
MENUITEM "Resources by connection", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "Show hidden devices", IDC_SHOWHIDDEN
END
POPUP "도움말"
BEGIN
MENUITEM "도움말", IDC_PROGHELP
MENUITEM "정보", IDC_ABOUT
END
END
IDR_POPUP MENU
BEGIN
POPUP "팝업"
BEGIN
MENUITEM "속성", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "도움말", IDC_PROGHELP
END
END
IDD_ABOUTBOX DIALOGEX 22, 16, 190, 182
CAPTION "장치 관리자에 대하여"
FONT 9, "MS Shell Dlg", 0, 0
STYLE DS_SHELLFONT | WS_BORDER | WS_DLGFRAME | WS_SYSMENU | DS_MODALFRAME
BEGIN
LTEXT "Device Manager v0.1\nCopyright (C) 2006\nby Ged Murphy (gedmurphy@gmail.com)", IDC_STATIC, 48, 7, 130, 30
PUSHBUTTON "Close", IDOK, 75, 162, 44, 15
ICON IDI_MAIN_ICON, IDC_STATIC, 10, 10, 7, 30
EDITTEXT IDC_LICENSE_EDIT, 8, 44, 174, 107, WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | ES_READONLY | ES_MULTILINE
END
STRINGTABLE
BEGIN
IDS_LICENSE "This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.\r\n\r\nThis program 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 General Public License for more details.\r\n\r\nYou should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA."
END
STRINGTABLE
BEGIN
IDS_TOOLTIP_PROP "속성"
IDS_TOOLTIP_REFRESH "새로 고침"
IDS_TOOLTIP_HELP "도움말"
IDS_TOOLTIP_EXIT "종료"
END
/* Hints */
STRINGTABLE
BEGIN
IDS_APPNAME "ReactOS 장치 관리자"
IDS_HINT_BLANK " "
IDS_HINT_EXIT " 프로그램을 종료합니다."
IDS_HINT_REFRESH " 서비스 리스트를 새로 고칩니다."
IDS_HINT_PROP " 선택한 항목의 속성 창을 엽니다."
IDS_HINT_HELP " 도움말을 엽니다."
IDS_HINT_ABOUT " ReactOS 장치 관리자에 대해."
IDS_HINT_SYS_RESTORE " 이 창을 보통 크기로 맟춤니다."
IDS_HINT_SYS_MOVE " 창을 움직입니다."
IDS_HINT_SYS_SIZE " 창의 크기를 변경합니다."
IDS_HINT_SYS_MINIMIZE " 이 창을 아이콘으로 만듭니다."
IDS_HINT_SYS_MAXIMIZE " 이 창을 최대 크기로 맟춤니다."
IDS_HINT_SYS_CLOSE " 창을 닫습니다."
END

View file

@ -1,83 +0,0 @@
LANGUAGE LANG_NORWEGIAN, SUBLANG_NEUTRAL
IDR_MAINMENU MENU
BEGIN
POPUP "&Fil"
BEGIN
MENUITEM "A&vslutt", IDC_EXIT
END
POPUP "Handling"
BEGIN
MENUITEM "Skriv ut", IDC_PRINT, GRAYED
MENUITEM SEPARATOR
MENUITEM "Egenskaper", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Hjelp", IDC_PROGHELP, GRAYED
END
POPUP "Vis"
BEGIN
MENUITEM "Enheter etter type", IDC_DEVBYTYPE
MENUITEM "Enheter etter tilkobling", IDC_DEVBYCONN
MENUITEM "Ressurser etter type", IDC_RESBYTYPE, GRAYED
MENUITEM "Ressurser etter tilkobling", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "Show hidden devices", IDC_SHOWHIDDEN
END
POPUP "Hjelp"
BEGIN
MENUITEM "Hjelp", IDC_PROGHELP
MENUITEM "Om", IDC_ABOUT
END
END
IDR_POPUP MENU
BEGIN
POPUP "popup"
BEGIN
MENUITEM "Egenskaper", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Hjelp", IDC_PROGHELP
END
END
IDD_ABOUTBOX DIALOGEX 22, 16, 190, 182
CAPTION "Om Enhetsbehandler"
FONT 8, "MS Shell Dlg", 0, 0
STYLE DS_SHELLFONT | WS_BORDER | WS_DLGFRAME | WS_SYSMENU | DS_MODALFRAME
BEGIN
LTEXT "Enhetsbehandler v0.1\nEnerett (C) 2006\nlaget av Ged Murphy (gedmurphy@gmail.com)", IDC_STATIC, 48, 7, 130, 30
PUSHBUTTON "Lukk", IDOK, 75, 162, 44, 15
ICON IDI_MAIN_ICON, IDC_STATIC, 10, 10, 7, 30
EDITTEXT IDC_LICENSE_EDIT, 8, 44, 174, 107, WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | ES_READONLY | ES_MULTILINE
END
STRINGTABLE
BEGIN
IDS_LICENSE "Dette programmet er gratis programvare; du kan distribuere det og/eller endre det under betingelsene av GNU General Public License som er utgitt av Free Software Foundation; version 2 av lisensen, eller (etter din mening) alle senere versjoner.\r\n\r\nDette programmet er utgitt i håp for at det skal kunne brukes, men DET ER INGEN GARANTIER; uten heller forutsatt garantier av SALGBARHET eller SIKKETHET FOR EN ENKELTHET FORMÅL. Se på GNU General Public Lisensen for mere detaljer.\r\n\r\nDu skal ha motatt en kopi av GNU General Public Lisensen sammen med denne programmet; hvis du ikke har motatt det, skriv til Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA."
END
STRINGTABLE
BEGIN
IDS_TOOLTIP_PROP "Egenskaper"
IDS_TOOLTIP_REFRESH "Oppdater"
IDS_TOOLTIP_HELP "Hjelp"
IDS_TOOLTIP_EXIT "Avslutt"
END
/* Hints */
STRINGTABLE
BEGIN
IDS_APPNAME "ReactOS Enhetsbehandler"
IDS_HINT_BLANK " "
IDS_HINT_EXIT " Avslutt programmet."
IDS_HINT_REFRESH " Oppdater tjeneste listen."
IDS_HINT_PROP " Open property sheet for the current selection."
IDS_HINT_HELP " Vis hjelp vinduet."
IDS_HINT_ABOUT " Om ReactOS Enhetsbehandler."
IDS_HINT_SYS_RESTORE " Gjenopprett dette vinduet til vanlig størrelse."
IDS_HINT_SYS_MOVE " Flytt dette vinduet."
IDS_HINT_SYS_SIZE " Endre størrelse på dette vinduet."
IDS_HINT_SYS_MINIMIZE " Gjør om dette vinduet til en ikon."
IDS_HINT_SYS_MAXIMIZE " Gjør om dette vinduet til å fylle hele skjermen."
IDS_HINT_SYS_CLOSE " Lukk dette vinduet."
END

View file

@ -1,90 +0,0 @@
/*
* Translated by xrogers
* xxrogers@users.sourceforge.net
* https://sourceforge.net/projects/reactospl
* UTF-8 conversion by Caemyr (May, 2011)
*/
LANGUAGE LANG_POLISH, SUBLANG_DEFAULT
IDR_MAINMENU MENU
BEGIN
POPUP "&Plik"
BEGIN
MENUITEM "Za&kończ", IDC_EXIT
END
POPUP "&Akcja"
BEGIN
MENUITEM "&Drukuj", IDC_PRINT, GRAYED
MENUITEM SEPARATOR
MENUITEM "&Właściwości", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Pomo&c", IDC_PROGHELP, GRAYED
END
POPUP "&Widok"
BEGIN
MENUITEM "Urządzenia w&edług typu", IDC_DEVBYTYPE
MENUITEM "Ur&ządzenia według połączenia", IDC_DEVBYCONN
MENUITEM "Zaso&by według typu", IDC_RESBYTYPE, GRAYED
MENUITEM "Za&soby według połączenia", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "Pokaż ukryte urządzenia", IDC_SHOWHIDDEN
END
POPUP "Pomo&c"
BEGIN
MENUITEM "&Tematy pomocy", IDC_PROGHELP
MENUITEM "Menedżer urządzeń - i&nformacje", IDC_ABOUT
END
END
IDR_POPUP MENU
BEGIN
POPUP "popup"
BEGIN
MENUITEM "Właściwości", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Pomoc", IDC_PROGHELP
END
END
IDD_ABOUTBOX DIALOGEX 22, 16, 190, 182
CAPTION "Menedżer urządzeń - informacje"
FONT 8, "MS Shell Dlg", 0, 0
STYLE DS_SHELLFONT | WS_BORDER | WS_DLGFRAME | WS_SYSMENU | DS_MODALFRAME
BEGIN
LTEXT "Menedżer urządzeń v0.1\nCopyright (C) 2006\nby Ged Murphy (gedmurphy@gmail.com)", IDC_STATIC, 48, 7, 130, 26
PUSHBUTTON "Zamknij", IDOK, 75, 162, 44, 15
ICON IDI_MAIN_ICON, IDC_STATIC, 10, 10, 7, 30
EDITTEXT IDC_LICENSE_EDIT, 8, 44, 174, 107, WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | ES_READONLY | ES_MULTILINE
END
STRINGTABLE
BEGIN
IDS_LICENSE "Niniejszy program jest wolnym oprogramowaniem; możesz go rozprowadzać dalej i/lub modyfikować na warunkach Powszechnej Licencji Publicznej GNU, wydanej przez Fundację Wolnego Oprogramowania - według wersji 2 tej Licencji lub (według twojego wyboru) którejś z późniejszych wersji.\r\n\r\nNiniejszy program rozpowszechniany jest z nadzieją, iż będzie on użyteczny - jednak BEZ JAKIEJKOLWIEK GWARANCJI, nawet domyślnej gwarancji PRZYDATNOŚCI HANDLOWEJ albo PRZYDATNOŚCI DO OKREŚLONYCH ZASTOSOWAŃ. W celu uzyskania bliższych informacji sięgnij do Powszechnej Licencji Publicznej GNU.\r\n\r\nZ pewnością wraz z niniejszym programem otrzymałeś też egzemplarz Powszechnej Licencji Publicznej GNU (GNU General Public License); jeśli nie - napisz do Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA."
END
STRINGTABLE
BEGIN
IDS_TOOLTIP_PROP "Właściwości"
IDS_TOOLTIP_REFRESH "Odśwież"
IDS_TOOLTIP_HELP "Pomoc"
IDS_TOOLTIP_EXIT "Wyjście"
END
/* Hints */
STRINGTABLE
BEGIN
IDS_APPNAME "Menedżer urządzeń ReactOS"
IDS_HINT_BLANK " "
IDS_HINT_EXIT " Zamyka program."
IDS_HINT_REFRESH " Odśwież listę serwisów."
IDS_HINT_PROP " Otwiera arkusz właściwości dla bieżącego zaznaczenia."
IDS_HINT_HELP " Otwiera pomoc."
IDS_HINT_ABOUT " Informacje o Menedżerze urządzeń ReactOS."
IDS_HINT_SYS_RESTORE " Przywraca okno do normalnych rozmiarów."
IDS_HINT_SYS_MOVE " Przesuwa to okno."
IDS_HINT_SYS_SIZE " Zmienia rozmiar tego okna."
IDS_HINT_SYS_MINIMIZE " Minimalizuje to okno do ikony."
IDS_HINT_SYS_MAXIMIZE " Rozszerza to okno do rozmiarów ekranu."
IDS_HINT_SYS_CLOSE " Zamyka okno."
END

View file

@ -1,85 +0,0 @@
/* Translation and UTF-8 Conversion by mkbu95 <mkbu95@gmail.com> (May, 2012) */
LANGUAGE LANG_PORTUGUESE, SUBLANG_NEUTRAL
IDR_MAINMENU MENU
BEGIN
POPUP "&Arquivo"
BEGIN
MENUITEM "&Sair", IDC_EXIT
END
POPUP "Ação"
BEGIN
MENUITEM "Imprimir", IDC_PRINT, GRAYED
MENUITEM SEPARATOR
MENUITEM "Propriedades", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Ajuda", IDC_PROGHELP, GRAYED
END
POPUP "Visualizar"
BEGIN
MENUITEM "Dispositivos por tipo", IDC_DEVBYTYPE
MENUITEM "Dispositivos por conexão", IDC_DEVBYCONN
MENUITEM "Recursos por tipo", IDC_RESBYTYPE, GRAYED
MENUITEM "Recursos por conexão", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "Exibir dispositivos ocultos", IDC_SHOWHIDDEN
END
POPUP "Ajuda"
BEGIN
MENUITEM "Ajuda", IDC_PROGHELP
MENUITEM "Sobre", IDC_ABOUT
END
END
IDR_POPUP MENU
BEGIN
POPUP "popup"
BEGIN
MENUITEM "Propriedades", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Ajuda", IDC_PROGHELP
END
END
IDD_ABOUTBOX DIALOGEX 22, 16, 190, 182
CAPTION "Sobre Gerenciador de Dispositivos"
FONT 8, "MS Shell Dlg", 0, 0
STYLE DS_SHELLFONT | WS_BORDER | WS_DLGFRAME | WS_SYSMENU | DS_MODALFRAME
BEGIN
LTEXT "Gerenciador de Dispositivos v0.1\nCopyright (C) 2006\nby Ged Murphy (gedmurphy@gmail.com)", IDC_STATIC, 48, 7, 130, 30
PUSHBUTTON "Fechar", IDOK, 75, 162, 44, 15
ICON IDI_MAIN_ICON, IDC_STATIC, 10, 10, 7, 30
EDITTEXT IDC_LICENSE_EDIT, 8, 44, 174, 107, WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | ES_READONLY | ES_MULTILINE
END
STRINGTABLE
BEGIN
IDS_LICENSE "This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.\r\n\r\nThis program 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 General Public License for more details.\r\n\r\nYou should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA."
END
STRINGTABLE
BEGIN
IDS_TOOLTIP_PROP "Propriedades"
IDS_TOOLTIP_REFRESH "Atualizar"
IDS_TOOLTIP_HELP "Ajuda"
IDS_TOOLTIP_EXIT "Sair"
END
/* Hints */
STRINGTABLE
BEGIN
IDS_APPNAME "Gerenciador de Dispositivos ReactOS"
IDS_HINT_BLANK " "
IDS_HINT_EXIT " Fecha o programa."
IDS_HINT_REFRESH " Atualiza a lista de serviço."
IDS_HINT_PROP " Abre uma folha de propriedades para a seleção atual."
IDS_HINT_HELP " Exibe tela de ajuda."
IDS_HINT_ABOUT " Sobre Gerenciador de Dispositivos ReactOS."
IDS_HINT_SYS_RESTORE " Restaura esta janela ao tamanho normal."
IDS_HINT_SYS_MOVE " Move esta janela."
IDS_HINT_SYS_SIZE " Redimensiona esta janela."
IDS_HINT_SYS_MINIMIZE " Reduz esta janela a um ícone."
IDS_HINT_SYS_MAXIMIZE " Expande esta janela ao tamanho da tela."
IDS_HINT_SYS_CLOSE " Fecha esta janela."
END

View file

@ -1,88 +0,0 @@
/*
* Translators: Petru Dimitriu (petrimetri at gmail dot com)
* Ștefan Fulea (stefan dot fulea at mail dot md)
*/
LANGUAGE LANG_ROMANIAN, SUBLANG_NEUTRAL
IDR_MAINMENU MENU
BEGIN
POPUP "&Fișier"
BEGIN
MENUITEM "I&eșire", IDC_EXIT
END
POPUP "A&cțiune"
BEGIN
MENUITEM "I&mprimare", IDC_PRINT, GRAYED
MENUITEM SEPARATOR
MENUITEM "P&roprietăți", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Aj&utor", IDC_PROGHELP, GRAYED
END
POPUP "&Afișare"
BEGIN
MENUITEM "Dispozitive după &tip", IDC_DEVBYTYPE
MENUITEM "Dispozitive după &conexiune", IDC_DEVBYCONN
MENUITEM "Resurse după t&ip", IDC_RESBYTYPE, GRAYED
MENUITEM "Resurse după c&onexiune", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "Afișea&ză dispozitive ascunse", IDC_SHOWHIDDEN
END
POPUP "Aj&utor"
BEGIN
MENUITEM "&Manual…", IDC_PROGHELP
MENUITEM "Despre…", IDC_ABOUT
END
END
IDR_POPUP MENU
BEGIN
POPUP "popup"
BEGIN
MENUITEM "&Proprietăți", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "&Manual…", IDC_PROGHELP
END
END
IDD_ABOUTBOX DIALOGEX 22, 16, 190, 182
CAPTION "Despre Gestionarul de dispozitive"
FONT 8, "MS Shell Dlg", 0, 0
STYLE DS_SHELLFONT | WS_BORDER | WS_DLGFRAME | WS_SYSMENU | DS_MODALFRAME
BEGIN
LTEXT "Gestionar de dispozitive v0.1\nDrept de autor (C) 2006\nde Ged Murphy (gedmurphy@gmail.com)\nTraducere de Petru Dimitriu", IDC_STATIC, 48, 7, 130, 35
PUSHBUTTON "Î&nchide", IDOK, 75, 162, 44, 15
ICON IDI_MAIN_ICON, IDC_STATIC, 10, 10, 7, 30
EDITTEXT IDC_LICENSE_EDIT, 8, 47, 174, 107, WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | ES_READONLY | ES_MULTILINE
END
STRINGTABLE
BEGIN
IDS_LICENSE "Această aplicație este publică; fiind permisă modificarea și/sau (re)distribuția sa în termenii Licenței Publice Generale GNU publicată de Free Software Foundation; sau versiunea 2 a Licenței, sau (la alegere) a oricărei versiuni ulterioare.\r\n\r\nAceastă aplicație este distribuită doar în speranța de a fi utilă, FĂRĂ însă NICI O GARANȚIE; nici măcar cu garanția implicită a VANDABILITĂȚII sau a UTILITĂȚII ÎNTR-UN SCOP ANUME. Pentru mai multe detalii consultați Licența Publică Generală GNU.\r\n\r\nPuteți vedea această licență aici:\r\nhttp://www.gnu.org/licenses/gpl.html\r\n\r\nDe asemenea puteți consulta traduceri neoficiale ale acestei licențe aici:\r\nhttp://www.gnu.org/licenses/translations.html"
END
STRINGTABLE
BEGIN
IDS_TOOLTIP_PROP "Proprietăți"
IDS_TOOLTIP_REFRESH "Împrospătare"
IDS_TOOLTIP_HELP "Manual de utilizare"
IDS_TOOLTIP_EXIT "Ieșire"
END
/* Hints */
STRINGTABLE
BEGIN
IDS_APPNAME "Gestionar de dispozitive ReactOS"
IDS_HINT_BLANK " "
IDS_HINT_EXIT " Părăsește programul."
IDS_HINT_REFRESH " Împrospătează lista de servicii."
IDS_HINT_PROP " Afișează tabel cu proprietăți pentru selecția curentă."
IDS_HINT_HELP " Afișează manualul de utilizare."
IDS_HINT_ABOUT " Despre Gestionarul de dispozitive."
IDS_HINT_SYS_RESTORE " Aduce fereastra la mărime normală."
IDS_HINT_SYS_MOVE " Mută fereastra."
IDS_HINT_SYS_SIZE " Redimensionează fereastra."
IDS_HINT_SYS_MINIMIZE " Reduce fereastra la minim."
IDS_HINT_SYS_MAXIMIZE " Mărește fereastra la maxim."
IDS_HINT_SYS_CLOSE " Închide fereastra."
END

View file

@ -1,85 +0,0 @@
/* Russian language resource file (Dmitry Chapyshev, 2007-06-10) */
LANGUAGE LANG_RUSSIAN, SUBLANG_DEFAULT
IDR_MAINMENU MENU
BEGIN
POPUP "&Файл"
BEGIN
MENUITEM "&Выход", IDC_EXIT
END
POPUP "Действие"
BEGIN
MENUITEM "Печать", IDC_PRINT, GRAYED
MENUITEM SEPARATOR
MENUITEM "Свойства", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Справка", IDC_PROGHELP, GRAYED
END
POPUP "Вид"
BEGIN
MENUITEM "Устройства по типу", IDC_DEVBYTYPE
MENUITEM "Устройства по подключению", IDC_DEVBYCONN
MENUITEM "Ресурсы по типу", IDC_RESBYTYPE, GRAYED
MENUITEM "Ресурсы по подключению", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "Показать скрытые устройства", IDC_SHOWHIDDEN
END
POPUP "Справка"
BEGIN
MENUITEM "Помощь", IDC_PROGHELP
MENUITEM "О программе", IDC_ABOUT
END
END
IDR_POPUP MENU
BEGIN
POPUP "popup"
BEGIN
MENUITEM "Свойства", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Помощь", IDC_PROGHELP
END
END
IDD_ABOUTBOX DIALOGEX 22, 16, 190, 182
CAPTION "О Диспетчере устройств"
FONT 8, "MS Shell Dlg", 0, 0
STYLE DS_SHELLFONT | WS_BORDER | WS_DLGFRAME | WS_SYSMENU | DS_MODALFRAME
BEGIN
LTEXT "Диспетчер устройств v0.1\nCopyright (C) 2006\nот Ged Murphy (gedmurphy@gmail.com)", IDC_STATIC, 48, 7, 130, 30
PUSHBUTTON "Закрыть", IDOK, 75, 162, 44, 15
ICON IDI_MAIN_ICON, IDC_STATIC, 10, 10, 7, 30
EDITTEXT IDC_LICENSE_EDIT, 8, 44, 174, 107, WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | ES_READONLY | ES_MULTILINE
END
STRINGTABLE
BEGIN
IDS_LICENSE "Эта программа является свободно распространяемой; Вы можете распространять ее повторно и (или) изменять, соблюдая условия Открытого лицензионного соглашения GNU, опубликованного Фондом свободно распространяемого программного обеспечения; либо редакции 2 Соглашения, либо (на ваше усмотрение) любой редакции, выпущенной позже.\r\n\r\nЭта программа распространяется в надежде на то, что она окажется полезной, но БЕЗ КАКИХ-ЛИБО ГАРАНТИЙ, включая подразумеваемую гарантию КАЧЕСТВА либо ПРИГОДНОСТИ ДЛЯ ОПРЕДЕЛЕННЫХ ЦЕЛЕЙ. Подробности содержатся в Открытом лицензионном соглашении GNU.\r\n\r\nВместе с этой программой должен распространяться экземпляр Открытого лицензионного соглашения GNU, если он отсутствует, сообщите об этом в Фонд свободно распространяемого программного обеспечения (Free Software Foundation, Inc.), 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA."
END
STRINGTABLE
BEGIN
IDS_TOOLTIP_PROP "Свойства"
IDS_TOOLTIP_REFRESH "Обновить"
IDS_TOOLTIP_HELP "Помощь"
IDS_TOOLTIP_EXIT "Выход"
END
/* Hints */
STRINGTABLE
BEGIN
IDS_APPNAME "Диспетчер устройств ReactOS"
IDS_HINT_BLANK " "
IDS_HINT_EXIT " Выход из программы."
IDS_HINT_REFRESH " Обновить список."
IDS_HINT_PROP " Открыть свойства для выбранного элемента."
IDS_HINT_HELP " Показать окно справки."
IDS_HINT_ABOUT " О Диспетчере устройств ReactOS."
IDS_HINT_SYS_RESTORE " Восстановить нормальный размер этого окна."
IDS_HINT_SYS_MOVE " Переместить это окно."
IDS_HINT_SYS_SIZE " Изменить размер этого окна."
IDS_HINT_SYS_MINIMIZE " Свернуть это окно в значок."
IDS_HINT_SYS_MAXIMIZE " Развернуть это окно на полный экран."
IDS_HINT_SYS_CLOSE " Закрыть это окно."
END

View file

@ -1,88 +0,0 @@
/* TRANSLATOR: Mário Kačmár /Mario Kacmar/ aka Kario (kario@szm.sk)
* DATE OF TR.: 14-02-2008
* LAST CHANGE: 29-08-2008
*/
LANGUAGE LANG_SLOVAK, SUBLANG_DEFAULT
IDR_MAINMENU MENU
BEGIN
POPUP "&Súbor"
BEGIN
MENUITEM "&Skončiť", IDC_EXIT
END
POPUP "Akcia"
BEGIN
MENUITEM "Tlačiť", IDC_PRINT, GRAYED
MENUITEM SEPARATOR
MENUITEM "Vlastnosti", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Pomocník", IDC_PROGHELP, GRAYED
END
POPUP "Zobraziť"
BEGIN
MENUITEM "Zariadenia podľa typu", IDC_DEVBYTYPE
MENUITEM "Zariadenia podľa pripojenia", IDC_DEVBYCONN
MENUITEM "Prostriedky podľa typu", IDC_RESBYTYPE, GRAYED
MENUITEM "Prostriedky podľa pripojenia", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "Show hidden devices", IDC_SHOWHIDDEN
END
POPUP "Pomocník"
BEGIN
MENUITEM "Pomocník", IDC_PROGHELP
MENUITEM "Čo je ...", IDC_ABOUT
END
END
IDR_POPUP MENU
BEGIN
POPUP "popup"
BEGIN
MENUITEM "Vlastnosti", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Pomocník", IDC_PROGHELP
END
END
IDD_ABOUTBOX DIALOGEX 22, 16, 190, 182
CAPTION "Čo je Správca zariadení"
FONT 8, "MS Shell Dlg", 0, 0
STYLE DS_SHELLFONT | WS_BORDER | WS_DLGFRAME | WS_SYSMENU | DS_MODALFRAME
BEGIN
LTEXT "Správca zariadení v0.1\nCopyright (C) 2006\nod Ged Murphy (gedmurphy@gmail.com)", IDC_STATIC, 48, 7, 130, 30
PUSHBUTTON "Zavrieť", IDOK, 75, 162, 44, 15
ICON IDI_MAIN_ICON, IDC_STATIC, 10, 10, 7, 30
EDITTEXT IDC_LICENSE_EDIT, 8, 44, 174, 107, WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | ES_READONLY | ES_MULTILINE
END
STRINGTABLE
BEGIN
IDS_LICENSE "Tento program je voľný softvér; môžete ho šíriť a/alebo modifikovať podľa podmienok GNU Všeobecnej verejnej licencie (GNU General Public License) ako bola zverejnená nadáciou Free Software Foundation; buď verzie 2 tejto licencie, alebo (podľa Vášho uváženia) niektorej neskoršej verzie.\r\n\r\nTento program je distribuovaný v nádeji, že bude užitočný, avšak BEZ AKEJKOĽVEK ZÁRUKY; rovnako bez záruky PREDAJNOSTI alebo VHODNOSTI PRE URČITÝ ÚČEL. Pre viac detailov si pozrite GNU Všeobecnú verejnú licenciu (GNU General Public License).\r\n\r\nKópiu Všeobecnej verejnej licencie GNU ste mali dostať spolu s týmto programom; ak nie, napíšte si o ňu na Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA."
END
STRINGTABLE
BEGIN
IDS_TOOLTIP_PROP "Vlastnosti"
IDS_TOOLTIP_REFRESH "Obnoviť"
IDS_TOOLTIP_HELP "Pomocník"
IDS_TOOLTIP_EXIT "Skončiť"
END
/* Hints */
STRINGTABLE
BEGIN
IDS_APPNAME "Správca zariadení systému ReactOS"
IDS_HINT_BLANK " "
IDS_HINT_EXIT " Skončí program."
IDS_HINT_REFRESH " Obnoví zoznam služieb."
IDS_HINT_PROP " Otvorí okno s vlastnosťami pre aktuálny výber."
IDS_HINT_HELP " Zobrazí okno pomocníka."
IDS_HINT_ABOUT " Čo je Správca zariadení systému ReactOS."
IDS_HINT_SYS_RESTORE " Obnoví okno na normálnu veľkosť."
IDS_HINT_SYS_MOVE " Premiestni okno."
IDS_HINT_SYS_SIZE " Zmení veľkosť okna."
IDS_HINT_SYS_MINIMIZE " Zbalí okno na ikonu."
IDS_HINT_SYS_MAXIMIZE " Zväčší okno tak, aby zaplnilo celú obrazovku."
IDS_HINT_SYS_CLOSE " Zatvorí okno."
END

View file

@ -1,87 +0,0 @@
/* TRANSLATOR : Ardit Dani (Ard1t) (ardit.dani@gmail.com)
* DATE OF TR: 29-11-2013
*/
LANGUAGE LANG_ALBANIAN, SUBLANG_NEUTRAL
IDR_MAINMENU MENU
BEGIN
POPUP "&File"
BEGIN
MENUITEM "Dil", IDC_EXIT
END
POPUP "Veprim"
BEGIN
MENUITEM "Printo", IDC_PRINT, GRAYED
MENUITEM SEPARATOR
MENUITEM "Tipar", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Ndihmë", IDC_PROGHELP, GRAYED
END
POPUP "Vëzhgo"
BEGIN
MENUITEM "Pajisje nga tipi", IDC_DEVBYTYPE
MENUITEM "Pajisje nga lidhja", IDC_DEVBYCONN
MENUITEM "Burime nga tipi", IDC_RESBYTYPE, GRAYED
MENUITEM "Burime nga lidhja", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "Shfaq pajisje te fshehura", IDC_SHOWHIDDEN
END
POPUP "Ndihmë"
BEGIN
MENUITEM "Ndihmë", IDC_PROGHELP
MENUITEM "Rreth", IDC_ABOUT
END
END
IDR_POPUP MENU
BEGIN
POPUP "popup"
BEGIN
MENUITEM "Tipar", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Ndihmë", IDC_PROGHELP
END
END
IDD_ABOUTBOX DIALOGEX 22, 16, 190, 182
CAPTION "Rreth Menaxhimit të pajisjeve"
FONT 8, "MS Shell Dlg", 0, 0
STYLE DS_SHELLFONT | WS_BORDER | WS_DLGFRAME | WS_SYSMENU | DS_MODALFRAME
BEGIN
LTEXT "Menaxhues pajisjesh v0.1\nCopyright (C) 2006\nby Ged Murphy (gedmurphy@gmail.com)", IDC_STATIC, 48, 7, 130, 30
PUSHBUTTON "Close", IDOK, 75, 162, 44, 15
ICON IDI_MAIN_ICON, IDC_STATIC, 10, 10, 7, 30
EDITTEXT IDC_LICENSE_EDIT, 8, 44, 174, 107, WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | ES_READONLY | ES_MULTILINE
END
STRINGTABLE
BEGIN
IDS_LICENSE "Ky program është software falas; ju mund ta shpërndani dhe / ose modifikoni sipas kushteve të GNU General Public License publikuar nga Free Software Foundation; sipas versionit 2 të Liçencës, ose (sipas opinionit tuaj) çdo versioni të mëvonshëm.\r\n\r\nKy program shpërndahet me shpresën që do t'ju jetë i dobishëm, por PA ASNJË GARANCI; madje edhe pa garancinë e shprehur të TREGTUESHMËRISË ose PËRSHTATJES PËR NJË QËLLIM TË CAKTUAR. Shiko Liçencën Publike të Përgjithshme GNU për më shumë detaje.\r\n\r\nJu duhet të keni marrë një kopje të Liçensës së Përgjithshme Publike GNU së bashku me këtë program, e nëse jo, shkruani në Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.."
END
STRINGTABLE
BEGIN
IDS_TOOLTIP_PROP "Tipar"
IDS_TOOLTIP_REFRESH "Rifresko"
IDS_TOOLTIP_HELP "Ndihmë"
IDS_TOOLTIP_EXIT "Dil"
END
/* Hints */
STRINGTABLE
BEGIN
IDS_APPNAME "Menaxhuesi i pajisjeve ReactOS"
IDS_HINT_BLANK " "
IDS_HINT_EXIT " Dil nga programi."
IDS_HINT_REFRESH " Rifresko listen e sherbimeve."
IDS_HINT_PROP " Hap tiparet e fletes për perzgjedhjen aktuale."
IDS_HINT_HELP " Shfaq dritaren e ndihmës."
IDS_HINT_ABOUT " Rreth menaxhusit të pajisjeve të ReactOS."
IDS_HINT_SYS_RESTORE " Kthe kete dritare ne mase normale."
IDS_HINT_SYS_MOVE " Leviz kete dritare."
IDS_HINT_SYS_SIZE " Ndryshon permasat e dritares."
IDS_HINT_SYS_MINIMIZE " Kthen kete dritare ne ikone."
IDS_HINT_SYS_MAXIMIZE " Zmadhon kete dritare ne permasa te ekranit."
IDS_HINT_SYS_CLOSE " Mbyll kete dritare."
END

View file

@ -1,90 +0,0 @@
/*
* PROJECT: ReactOS MSCUTILS
* FILE: base/applications/mscutils/devmgmt/lang/sv-SE.rc
* PURPOSE: Swedish resource file
* TRANSLATOR: Jaix Bly
*/
LANGUAGE LANG_SWEDISH, SUBLANG_NEUTRAL
IDR_MAINMENU MENU
BEGIN
POPUP "&Arkiv"
BEGIN
MENUITEM "A&vsluta", IDC_EXIT
END
POPUP "Åtgärd"
BEGIN
MENUITEM "Skriv ut", IDC_PRINT, GRAYED
MENUITEM SEPARATOR
MENUITEM "Egenskaper", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Hjälp", IDC_PROGHELP, GRAYED
END
POPUP "Visa"
BEGIN
MENUITEM "Enheter efter typ", IDC_DEVBYTYPE
MENUITEM "Enheter efter koppling", IDC_DEVBYCONN
MENUITEM "Resurcer efter typ", IDC_RESBYTYPE, GRAYED
MENUITEM "Resurcer efter koppling", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "Show hidden devices", IDC_SHOWHIDDEN
END
POPUP "Hjälp"
BEGIN
MENUITEM "Hjälp", IDC_PROGHELP
MENUITEM "Om", IDC_ABOUT
END
END
IDR_POPUP MENU
BEGIN
POPUP "popup"
BEGIN
MENUITEM "Egenskaper", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Hjälp", IDC_PROGHELP
END
END
IDD_ABOUTBOX DIALOGEX 22, 16, 190, 182
CAPTION "Om Enhetshanteraren"
FONT 8, "MS Shell Dlg", 0, 0
STYLE DS_SHELLFONT | WS_BORDER | WS_DLGFRAME | WS_SYSMENU | DS_MODALFRAME
BEGIN
LTEXT "Enhetshanteraren v0.1\nCopyright (C) 2006\nby Ged Murphy (gedmurphy@gmail.com)", IDC_STATIC, 48, 7, 130, 30
PUSHBUTTON "Stäng", IDOK, 75, 162, 44, 15
ICON IDI_MAIN_ICON, IDC_STATIC, 10, 10, 7, 30
EDITTEXT IDC_LICENSE_EDIT, 8, 44, 174, 107, WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | ES_READONLY | ES_MULTILINE
END
STRINGTABLE
BEGIN
IDS_LICENSE "Detta programmet är fri programvara; du kan distribuera det och/eller ändra det under villkoren enligt GNU General Public License som är utgivet av Free Software Foundation; version 2, eller (om du så önskar) alla senare versioner.\r\n\r\nDette programmet er utgivet i hopp om att det skall kunne användas, men DET FINNS INGA GARANTIER; även utan underförstådd garanti om SÄLJBARHET eller LÄMPLIGHET FÖR ETT VISST ÄNDAMÅL. Se på GNU General Public Licensen för mer detaljer.\r\n\r\nDu skall ha motagit en kopia av GNU General Public Licensen tillsammans med detta programmet; om du inte har fått det, skriv til Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA."
END
STRINGTABLE
BEGIN
IDS_TOOLTIP_PROP "Egenskaper"
IDS_TOOLTIP_REFRESH "Uppdater"
IDS_TOOLTIP_HELP "Hjälp"
IDS_TOOLTIP_EXIT "Avsluta"
END
/* Hints */
STRINGTABLE
BEGIN
IDS_APPNAME "ReactOS Enhetshanterare"
IDS_HINT_BLANK " "
IDS_HINT_EXIT " Avsluta programmet."
IDS_HINT_REFRESH " Uppdatera tjänstelistan."
IDS_HINT_PROP " Öppna egenskaper för markerat val."
IDS_HINT_HELP " Visa hjälpfönstret."
IDS_HINT_ABOUT " Om ReactOS Enhetshanterare."
IDS_HINT_SYS_RESTORE " Återställ detta fönstret till normal storlek."
IDS_HINT_SYS_MOVE " Flytta detta fönstret."
IDS_HINT_SYS_SIZE " Ändra storleken på detta fönstret."
IDS_HINT_SYS_MINIMIZE " Minimera detta fönstret till en ikon."
IDS_HINT_SYS_MAXIMIZE " Maximera dette fönstret så det fyller hela skärmen."
IDS_HINT_SYS_CLOSE " Stäng detta fönstret."
END

View file

@ -1,91 +0,0 @@
/*
* PROJECT: ReactOS Device Management
* LICENSE: GPL - See COPYING in the top level directory
* FILE: base/applications/mscutils/devmgmt/lang/th-TH.rc
* PURPOSE: Thai translation
* COPYRIGHT: Copyright 2007 Sumath Aowsakulsutthi
*/
LANGUAGE LANG_THAI, SUBLANG_DEFAULT
IDR_MAINMENU MENU
BEGIN
POPUP "แ&ฟ้ม"
BEGIN
MENUITEM "&ออก", IDC_EXIT
END
POPUP "เริ่มทำ"
BEGIN
MENUITEM "พิมพ์", IDC_PRINT, GRAYED
MENUITEM SEPARATOR
MENUITEM "คุณสมบัติ", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "ช่วยเหลือ", IDC_PROGHELP, GRAYED
END
POPUP "มุมมอง"
BEGIN
MENUITEM "อุปกรณ์แบ่งตามประเภท", IDC_DEVBYTYPE
MENUITEM "อุปกรณ์แบ่งตามการเชื่อมต่อ", IDC_DEVBYCONN
MENUITEM "แหล่งข้อมูลตามประเภท", IDC_RESBYTYPE, GRAYED
MENUITEM "แหล่งข้อมูลตามการเชื่อมต่อ", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "Show hidden devices", IDC_SHOWHIDDEN
END
POPUP "ช่วยเหลือ"
BEGIN
MENUITEM "ช่วยเหลือ", IDC_PROGHELP
MENUITEM "เกี่ยวกับ", IDC_ABOUT
END
END
IDR_POPUP MENU
BEGIN
POPUP "หน้าต่างปัจจุบัน"
BEGIN
MENUITEM "คุณสมบัติ", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "ช่วยเหลือ", IDC_PROGHELP
END
END
IDD_ABOUTBOX DIALOGEX 22, 16, 190, 182
CAPTION "เกี่ยวกับการจัดการอุปกรณ์"
FONT 8, "MS Shell Dlg", 0, 0
STYLE DS_SHELLFONT | WS_BORDER | WS_DLGFRAME | WS_SYSMENU | DS_MODALFRAME
BEGIN
LTEXT "Device Manager v0.1\nCopyright (C) 2006\nby Ged Murphy (gedmurphy@gmail.com)", IDC_STATIC, 48, 7, 130, 26
PUSHBUTTON "Close", IDOK, 75, 162, 44, 15
ICON IDI_MAIN_ICON, IDC_STATIC, 10, 10, 7, 30
EDITTEXT IDC_LICENSE_EDIT, 8, 44, 174, 107, WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | ES_READONLY | ES_MULTILINE
END
STRINGTABLE
BEGIN
IDS_LICENSE "This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.\r\n\r\nThis program 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 General Public License for more details.\r\n\r\nYou should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA."
END
STRINGTABLE
BEGIN
IDS_TOOLTIP_PROP "คุณสมบัติ"
IDS_TOOLTIP_REFRESH "ฟื้นฟู"
IDS_TOOLTIP_HELP "ช่วยเหลือ"
IDS_TOOLTIP_EXIT "ออกจากโปรแกรม"
END
/* Hints */
STRINGTABLE
BEGIN
IDS_APPNAME "การจัดการอุปกรณ์ของ ReactOS"
IDS_HINT_BLANK " "
IDS_HINT_EXIT " ออกจากโปรแกรม"
IDS_HINT_REFRESH " ฟื้นฟูรายการบริการ"
IDS_HINT_PROP " เปิดคุณสมบัติของแผ่นงานตามการเลือกในปัจจุบัน"
IDS_HINT_HELP " แสดงหน้าต่างช่วยเหลือ"
IDS_HINT_ABOUT " เกี่ยวกับการจัดการอุปกรณ์ของ ReactOS"
IDS_HINT_SYS_RESTORE " คืนสภาพของหน้าต่างนี้สู่ขนาดปกติ"
IDS_HINT_SYS_MOVE " ย้ายหน้าต่างนี้"
IDS_HINT_SYS_SIZE " เปลี่ยนขนาดหน้าต่างนี้"
IDS_HINT_SYS_MINIMIZE " ย่อหน้าต่างนี้ให้เป็นสัญรูป"
IDS_HINT_SYS_MAXIMIZE " ขยายหน้าต่างนี้จนเต็มหน้าจอ"
IDS_HINT_SYS_CLOSE " ปิดหน้าต่างนี้"
END

View file

@ -1,85 +0,0 @@
/* TRANSLATOR: 2013, 2014 Erdem Ersoy (eersoy93) (erdemersoy@live.com) */
LANGUAGE LANG_TURKISH, SUBLANG_DEFAULT
IDR_MAINMENU MENU
BEGIN
POPUP "&Kütük"
BEGIN
MENUITEM "&Çıkış", IDC_EXIT
END
POPUP "&Eylem"
BEGIN
MENUITEM "&Yazdır", IDC_PRINT, GRAYED
MENUITEM SEPARATOR
MENUITEM "&Husûsiyetler", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Y&ardım", IDC_PROGHELP, GRAYED
END
POPUP "&Görünüm"
BEGIN
MENUITEM "&Türe Göre Aygıtlar", IDC_DEVBYTYPE
MENUITEM "&Bağlantıya Göre Aygıtlar", IDC_DEVBYCONN
MENUITEM "T&üre Göre Kaynaklar", IDC_RESBYTYPE, GRAYED
MENUITEM "B&ağlantıya Göre Kaynaklar", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "&Gizli Aygıtları Göster", IDC_SHOWHIDDEN
END
POPUP "&Yardım"
BEGIN
MENUITEM "&Yardım", IDC_PROGHELP
MENUITEM "&Üzerine...", IDC_ABOUT
END
END
IDR_POPUP MENU
BEGIN
POPUP "popup"
BEGIN
MENUITEM "&Husûsiyetler", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "&Yardım", IDC_PROGHELP
END
END
IDD_ABOUTBOX DIALOGEX 22,16,190,182
CAPTION "Aygıt Yöneticisi Üzerine"
FONT 8,"MS Shell Dlg",0,0
STYLE DS_SHELLFONT | WS_BORDER | WS_DLGFRAME | WS_SYSMENU | DS_MODALFRAME
BEGIN
LTEXT "Aygıt Yöneticisi - Sürüm: 0.1\nTelif Hakkı: 2006\nGed Murphy (gedmurphy@gmail.com) ile.", IDC_STATIC, 48, 7, 130, 30
PUSHBUTTON "Tamam", IDOK, 75, 162, 44, 15
ICON IDI_MAIN_ICON, IDC_STATIC, 10, 10, 7, 30
EDITTEXT IDC_LICENSE_EDIT, 8, 44, 174, 107, WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | ES_READONLY | ES_MULTILINE
END
STRINGTABLE
BEGIN
IDS_LICENSE "ÖNEMLİ: Aşağıdaki metin, özgün metnin resmî olmayan çevirisidir. Çeviri metniyle özgün metin arasında ayrım olabilir. Özgün metin, çeviri metninin altındadır.\r\n\r\n***\r\n\r\nBu izlence özgür yazılımdır; bunu, Özgür Yazılım Vakfı'nın yayımladığı GNU Umûmî Kamu Ruhsatı'nın, 2. sürümünün ya da daha sonraki bir sürümünün (Orası size bağlı.) şartları altında yeniden dağıtabilir veyâ değiştirebilirsiniz.\r\n\r\nBu izlence, kullanışlı olabileceği beklentisiyle dağıtılmıştır ancak bu izlencenin HİÇBİR GÜVENCESİ YOKTUR, SATILABİLİRLİĞİN ve BELİRLİ BİR AMACA UYGUNLUĞUN demek istenilen güvencesi bile. Daha çok bilgi için GNU Umûmî Kamu Ruhsatı'na bakınız.\r\n\r\nBu izlenceyle birlikte GNU Umûmî Kamu Ruhsatı'nın bir kopyasını almış olmalısınız, eğer yoksa Özgür Yazılım Vakfı AŞ'ye (51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 ABD) yazınız.\r\n\r\n***\r\n\r\nThis program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.\r\n\r\nThis program 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 General Public License for more details.\r\n\r\nYou should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA."
END
STRINGTABLE
BEGIN
IDS_TOOLTIP_PROP "Husûsiyetler"
IDS_TOOLTIP_REFRESH "Yenile"
IDS_TOOLTIP_HELP "Yardım"
IDS_TOOLTIP_EXIT "Çıkış"
END
/* Hints */
STRINGTABLE
BEGIN
IDS_APPNAME "Aygıt Yöneticisi"
IDS_HINT_BLANK " "
IDS_HINT_EXIT " İzlenceden çıkar."
IDS_HINT_REFRESH " Hizmet dizelgesini yeniler."
IDS_HINT_PROP " Şimdiki seçilen için husûsiyet penceresini açar."
IDS_HINT_HELP " Yardım penceresini görüntüler."
IDS_HINT_ABOUT " Aygıt Yöneticisi üzerine."
IDS_HINT_SYS_RESTORE " Bu pencereyi düzgülük boyutlarına döndürür."
IDS_HINT_SYS_MOVE " Bu pencereyi devindirir."
IDS_HINT_SYS_SIZE " Bu pencereyi yeniden boyutlandırır."
IDS_HINT_SYS_MINIMIZE " Bu pencereyi bir simgeye küçültür."
IDS_HINT_SYS_MAXIMIZE " Bu pencereyi, bu görüntülüğü kaplatana dek genişletir."
IDS_HINT_SYS_CLOSE " Bu pencereyi kapatır."
END

View file

@ -1,91 +0,0 @@
/*
* PROJECT: ReactOS Device Management
* LICENSE: GPL - See COPYING in the top level directory
* FILE: base/applications/mscutils/devmgmt/lang/uk-UA.rc
* PURPOSE: Ukraianian Language File for devmgmt
* TRANSLATOR: Artem Reznikov
*/
LANGUAGE LANG_UKRAINIAN, SUBLANG_DEFAULT
IDR_MAINMENU MENU
BEGIN
POPUP "&Файл"
BEGIN
MENUITEM "В&ихід", IDC_EXIT
END
POPUP "Дія"
BEGIN
MENUITEM "Друк", IDC_PRINT, GRAYED
MENUITEM SEPARATOR
MENUITEM "Властивості", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Довідка", IDC_PROGHELP, GRAYED
END
POPUP "Вигляд"
BEGIN
MENUITEM "Пристрої за типом", IDC_DEVBYTYPE
MENUITEM "Пристрої за підключенням", IDC_DEVBYCONN
MENUITEM "Ресурси за типом", IDC_RESBYTYPE, GRAYED
MENUITEM "Ресурси за підключенням", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "Show hidden devices", IDC_SHOWHIDDEN
END
POPUP "Довідка"
BEGIN
MENUITEM "Довідка", IDC_PROGHELP
MENUITEM "Про програму", IDC_ABOUT
END
END
IDR_POPUP MENU
BEGIN
POPUP "popup"
BEGIN
MENUITEM "Властивості", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "Довідка", IDC_PROGHELP
END
END
IDD_ABOUTBOX DIALOGEX 22, 16, 190, 182
CAPTION "Про програму Диспетчер пристроїв"
FONT 8, "MS Shell Dlg", 0, 0
STYLE DS_SHELLFONT | WS_BORDER | WS_DLGFRAME | WS_SYSMENU | DS_MODALFRAME
BEGIN
LTEXT "Диспетчер пристроїв v0.1\nCopyright (C) 2006\nby Ged Murphy (gedmurphy@gmail.com)", IDC_STATIC, 48, 7, 130, 26
PUSHBUTTON "Закрити", IDOK, 75, 162, 44, 15
ICON IDI_MAIN_ICON, IDC_STATIC, 10, 10, 7, 30
EDITTEXT IDC_LICENSE_EDIT, 8, 44, 174, 107, WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | ES_READONLY | ES_MULTILINE
END
STRINGTABLE
BEGIN
IDS_LICENSE "Це вільне програмне забезпечення; Ви можете розповсюджувати її та змінювати, дотримуючись умови Відкритої ліцензійної угоди GNU, опублікованої Фондом вільного програмного забезпечення; або редакції 2 Угоди, або будь-якої редакції, випущеної пізніше.\r\n\r\nЦя програма розповсюджується в надії на те, що вона виявиться корисною, але БЕЗ БУДЬ-ЯКИХ ГАРАНТІЙ, включаючи УЯВНОЮ ГАРАНТІЄЮ ЯКОСТІ або ПРИДАТНОСТІ для певних цілей. Подробиці містяться у Відкритій ліцензійній угоді GNU.\r\n\r\nРазом з цією програмою повинен поширюватися примірник Відкритої ліцензійної угоди GNU. Якщо він відсутній, повідомте про це в Фонд вільного програмного забезпечення (Free Software Foundation, Inc.), 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA."
END
STRINGTABLE
BEGIN
IDS_TOOLTIP_PROP "Властивості"
IDS_TOOLTIP_REFRESH "Оновити"
IDS_TOOLTIP_HELP "Довідка"
IDS_TOOLTIP_EXIT "Вихід"
END
/* Hints */
STRINGTABLE
BEGIN
IDS_APPNAME "Диспетчер пристроїв ReactOS"
IDS_HINT_BLANK " "
IDS_HINT_EXIT " Вийти з програми."
IDS_HINT_REFRESH " Оновити список."
IDS_HINT_PROP " Відкрити властивості для вибраного елементу."
IDS_HINT_HELP " Показати вікно довідки."
IDS_HINT_ABOUT " Про Диспетчер пристроїв ReactOS."
IDS_HINT_SYS_RESTORE " Відновити вихідний розмір вікна."
IDS_HINT_SYS_MOVE " Змінити розташування вікна."
IDS_HINT_SYS_SIZE " Змінити розмір вікна."
IDS_HINT_SYS_MINIMIZE " Згорнути вікно у значок."
IDS_HINT_SYS_MAXIMIZE " Розгорнути вікно на весь екран."
IDS_HINT_SYS_CLOSE " Закрити вікно."
END

View file

@ -1,85 +0,0 @@
/* Translated by Song Fuchang (0xfc) <sfc_0@yahoo.com.cn> */
LANGUAGE LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED
IDR_MAINMENU MENU
BEGIN
POPUP "文件(&F)"
BEGIN
MENUITEM "退出(&X)", IDC_EXIT
END
POPUP "动作"
BEGIN
MENUITEM "打印", IDC_PRINT, GRAYED
MENUITEM SEPARATOR
MENUITEM "属性", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "帮助", IDC_PROGHELP, GRAYED
END
POPUP "查看"
BEGIN
MENUITEM "设备,按类型", IDC_DEVBYTYPE
MENUITEM "设备,按连接", IDC_DEVBYCONN
MENUITEM "资源,按类型", IDC_RESBYTYPE, GRAYED
MENUITEM "资源,按连接", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "显示隐藏的设备", IDC_SHOWHIDDEN
END
POPUP "帮助"
BEGIN
MENUITEM "帮助内容", IDC_PROGHELP
MENUITEM "关于", IDC_ABOUT
END
END
IDR_POPUP MENU
BEGIN
POPUP "popup"
BEGIN
MENUITEM "属性", IDC_PROP, GRAYED
MENUITEM SEPARATOR
MENUITEM "帮助", IDC_PROGHELP
END
END
IDD_ABOUTBOX DIALOGEX 22, 16, 190, 182
CAPTION "关于设备管理器"
FONT 9, "MS Shell Dlg", 0, 0
STYLE DS_SHELLFONT | WS_BORDER | WS_DLGFRAME | WS_SYSMENU | DS_MODALFRAME
BEGIN
LTEXT "设备管理器 v0.1 版权所有 (C) 2006\n作者 Ged Murphy (gedmurphy@gmail.com)", IDC_STATIC, 48, 7, 130, 30
PUSHBUTTON "关闭", IDOK, 75, 162, 44, 15
ICON IDI_MAIN_ICON, IDC_STATIC, 10, 10, 7, 30
EDITTEXT IDC_LICENSE_EDIT, 8, 44, 174, 107, WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | ES_READONLY | ES_MULTILINE
END
STRINGTABLE
BEGIN
IDS_LICENSE "This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.\r\n\r\nThis program 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 General Public License for more details.\r\n\r\nYou should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA."
END
STRINGTABLE
BEGIN
IDS_TOOLTIP_PROP "属性"
IDS_TOOLTIP_REFRESH "刷新"
IDS_TOOLTIP_HELP "帮助"
IDS_TOOLTIP_EXIT "退出"
END
/* Hints */
STRINGTABLE
BEGIN
IDS_APPNAME "ReactOS 设备管理器"
IDS_HINT_BLANK " "
IDS_HINT_EXIT " 退出这个程序。"
IDS_HINT_REFRESH " 刷新设备列表。"
IDS_HINT_PROP " 为当前选择项打开属性页。"
IDS_HINT_HELP " 显示帮助窗口。"
IDS_HINT_ABOUT " 关于 ReactOS 设备管理器。"
IDS_HINT_SYS_RESTORE " 将窗口恢复到默认大小。"
IDS_HINT_SYS_MOVE " 移动这个窗口。"
IDS_HINT_SYS_SIZE " 更改这个窗口的大小。"
IDS_HINT_SYS_MINIMIZE " 将这个窗口折叠为一个图标。"
IDS_HINT_SYS_MAXIMIZE " 将这个窗口扩展到整个屏幕。"
IDS_HINT_SYS_CLOSE " 关闭这个窗口。"
END

View file

@ -1,890 +0,0 @@
/*
* PROJECT: ReactOS Device Managment
* LICENSE: GPL - See COPYING in the top level directory
* FILE: base/applications/mscutils/devmgmt/mainwnd.c
* PURPOSE: Main window message handler
* COPYRIGHT: Copyright 2006 Ged Murphy <gedmurphy@gmail.com>
*
*/
#include "precomp.h"
#include <windowsx.h>
static BOOL pCreateToolbar(PMAIN_WND_INFO Info);
static const TCHAR szMainWndClass[] = TEXT("DevMgmtWndClass");
/* Toolbar buttons */
TBBUTTON Buttons [] =
{ /* iBitmap, idCommand, fsState, fsStyle, bReserved[2], dwData, iString */
{TBICON_PROP, IDC_PROP, TBSTATE_INDETERMINATE, BTNS_BUTTON, {0}, 0, 0}, /* properties */
{TBICON_REFRESH, IDC_REFRESH, TBSTATE_ENABLED, BTNS_BUTTON, {0}, 0, 0}, /* refresh */
/* Note: First item for a seperator is its width in pixels */
{15, 0, TBSTATE_ENABLED, BTNS_SEP, {0}, 0, 0}, /* separator */
{TBICON_HELP, IDC_PROGHELP,TBSTATE_ENABLED, BTNS_BUTTON, {0}, 0, 0 }, /* help */
{TBICON_EXIT, IDC_EXIT, TBSTATE_ENABLED, BTNS_BUTTON, {0}, 0, 0 }, /* exit */
};
/* menu hints */
static const MENU_HINT MainMenuHintTable[] = {
/* File Menu */
{IDC_EXIT, IDS_HINT_EXIT},
/* Action Menu */
{IDC_REFRESH, IDS_HINT_REFRESH},
{IDC_PROP, IDS_HINT_PROP},
/* Help Menu */
{IDC_PROGHELP, IDS_HINT_HELP},
{IDC_ABOUT, IDS_HINT_ABOUT}
};
/* system menu hints */
static const MENU_HINT SystemMenuHintTable[] = {
{SC_RESTORE, IDS_HINT_SYS_RESTORE},
{SC_MOVE, IDS_HINT_SYS_MOVE},
{SC_SIZE, IDS_HINT_SYS_SIZE},
{SC_MINIMIZE, IDS_HINT_SYS_MINIMIZE},
{SC_MAXIMIZE, IDS_HINT_SYS_MAXIMIZE},
{SC_CLOSE, IDS_HINT_SYS_CLOSE},
};
static BOOL
MainWndMenuHint(PMAIN_WND_INFO Info,
WORD CmdId,
const MENU_HINT *HintArray,
DWORD HintsCount,
UINT DefHintId)
{
BOOL Found = FALSE;
const MENU_HINT *LastHint;
UINT HintId = DefHintId;
LastHint = HintArray + HintsCount;
while (HintArray != LastHint)
{
if (HintArray->CmdId == CmdId)
{
HintId = HintArray->HintId;
Found = TRUE;
break;
}
HintArray++;
}
StatusBarLoadString(Info->hStatus,
SB_SIMPLEID,
hInstance,
HintId);
return Found;
}
static VOID
UpdateMainStatusBar(PMAIN_WND_INFO Info)
{
if (Info->hStatus != NULL)
{
SendMessage(Info->hStatus,
SB_SIMPLE,
(WPARAM)Info->InMenuLoop,
0);
}
}
static BOOL
pCreateToolbar(PMAIN_WND_INFO Info)
{
INT NumButtons = sizeof(Buttons) / sizeof(Buttons[0]);
Info->hTool = CreateWindowEx(0,
TOOLBARCLASSNAME,
NULL,
WS_CHILD | WS_VISIBLE | TBSTYLE_FLAT | TBSTYLE_TOOLTIPS,
0, 0, 0, 0,
Info->hMainWnd,
(HMENU)IDC_TOOLBAR,
hInstance,
NULL);
if(Info->hTool != NULL)
{
HIMAGELIST hImageList;
SendMessage(Info->hTool,
TB_SETEXTENDEDSTYLE,
0,
TBSTYLE_EX_HIDECLIPPEDBUTTONS);
SendMessage(Info->hTool,
TB_BUTTONSTRUCTSIZE,
sizeof(Buttons[0]),
0);
hImageList = InitImageList(IDB_PROP,
IDB_EXIT,
16,
16);
if (hImageList == NULL)
return FALSE;
ImageList_Destroy((HIMAGELIST)SendMessage(Info->hTool,
TB_SETIMAGELIST,
0,
(LPARAM)hImageList));
SendMessage(Info->hTool,
TB_ADDBUTTONS,
NumButtons,
(LPARAM)Buttons);
return TRUE;
}
return FALSE;
}
static BOOL
CreateTreeView(PMAIN_WND_INFO Info)
{
Info->hTreeView = CreateWindowEx(WS_EX_CLIENTEDGE,
WC_TREEVIEW,
NULL,
WS_CHILD | WS_VISIBLE | WS_BORDER | TVS_HASLINES |
TVS_HASBUTTONS | TVS_SHOWSELALWAYS | TVS_LINESATROOT,
0, 0, 0, 0,
Info->hMainWnd,
(HMENU)IDC_TREEVIEW,
hInstance,
NULL);
if (Info->hTreeView == NULL)
{
DisplayString(_T("Could not create TreeView."));
return FALSE;
}
return TRUE;
}
static BOOL
CreateStatusBar(PMAIN_WND_INFO Info)
{
INT StatWidths[] = {110, -1}; /* widths of status bar */
Info->hStatus = CreateWindowEx(0,
STATUSCLASSNAME,
NULL,
WS_CHILD | WS_VISIBLE | SBARS_SIZEGRIP,
0, 0, 0, 0,
Info->hMainWnd,
(HMENU)IDC_STATUSBAR,
hInstance,
NULL);
if(Info->hStatus == NULL)
return FALSE;
SendMessage(Info->hStatus,
SB_SETPARTS,
sizeof(StatWidths) / sizeof(INT),
(LPARAM)StatWidths);
return TRUE;
}
static DWORD WINAPI
DeviceEnumThread(LPVOID lpParameter)
{
PMAIN_WND_INFO Info;
HTREEITEM hRoot;
Info = (PMAIN_WND_INFO)lpParameter;
if (Info->hTreeView)
FreeDeviceStrings(Info->hTreeView);
hRoot = InitTreeView(Info->hTreeView);
if (hRoot)
{
switch (Info->Display)
{
case DevicesByType:
ListDevicesByType(Info->hTreeView, hRoot, Info->bShowHidden);
break;
case DevicesByConnection:
ListDevicesByConnection(Info->hTreeView, hRoot, Info->bShowHidden);
break;
default:
break;
}
return 0;
}
return -1;
}
static VOID
UpdateViewMenu(PMAIN_WND_INFO Info)
{
UINT id = IDC_DEVBYTYPE;
HMENU hMenu;
hMenu = GetMenu(Info->hMainWnd);
switch (Info->Display)
{
case DevicesByType:
id = IDC_DEVBYTYPE;
break;
case DevicesByConnection:
id = IDC_DEVBYCONN;
break;
case RessourcesByType:
id = IDC_RESBYTYPE;
break;
case RessourcesByConnection:
id = IDC_RESBYCONN;
break;
}
CheckMenuRadioItem(hMenu,
IDC_DEVBYTYPE,
IDC_RESBYCONN,
id,
MF_BYCOMMAND);
CheckMenuItem(hMenu,
IDC_SHOWHIDDEN,
MF_BYCOMMAND | (Info->bShowHidden ? MF_CHECKED : MF_UNCHECKED));
}
static BOOL
InitMainWnd(PMAIN_WND_INFO Info)
{
HANDLE DevEnumThread;
HMENU hMenu;
if (!pCreateToolbar(Info))
DisplayString(_T("error creating toolbar"));
if (!CreateTreeView(Info))
{
DisplayString(_T("error creating list view"));
return FALSE;
}
if (!CreateStatusBar(Info))
DisplayString(_T("error creating status bar"));
UpdateViewMenu(Info);
/* make 'properties' bold */
hMenu = GetMenu(Info->hMainWnd);
hMenu = GetSubMenu(hMenu, 1);
SetMenuDefaultItem(hMenu, IDC_PROP, FALSE);
/* Create Popup Menu */
Info->hShortcutMenu = LoadMenu(hInstance,
MAKEINTRESOURCE(IDR_POPUP));
Info->hShortcutMenu = GetSubMenu(Info->hShortcutMenu,
0);
SetMenuDefaultItem(Info->hShortcutMenu, IDC_PROP, FALSE);
/* create separate thread to emum devices */
DevEnumThread = CreateThread(NULL,
0,
DeviceEnumThread,
Info,
0,
NULL);
if (!DevEnumThread)
{
DisplayString(_T("Failed to enumerate devices"));
return FALSE;
}
CloseHandle(DevEnumThread);
return TRUE;
}
static VOID
OnContext(PMAIN_WND_INFO Info,
LPARAM lParam)
{
HTREEITEM hSelected;
POINT pt;
RECT rc;
INT xPos = GET_X_LPARAM(lParam);
INT yPos = GET_Y_LPARAM(lParam);
hSelected = TreeView_GetSelection(Info->hTreeView);
if (TreeView_GetItemRect(Info->hTreeView,
hSelected,
&rc,
TRUE))
{
if (GetCursorPos(&pt) &&
ScreenToClient(Info->hTreeView, &pt) &&
PtInRect(&rc, pt))
{
TrackPopupMenuEx(Info->hShortcutMenu,
TPM_RIGHTBUTTON,
xPos,
yPos,
Info->hMainWnd,
NULL);
}
}
}
static LRESULT
OnNotify(PMAIN_WND_INFO Info,
LPARAM lParam)
{
LPNMHDR pnmhdr = (LPNMHDR)lParam;
LRESULT ret = 0;
switch (pnmhdr->code)
{
case TVN_SELCHANGED:
{
LPNM_TREEVIEW pnmtv = (LPNM_TREEVIEW)lParam;
if (Info->Display == DevicesByType)
{
if (!TreeView_GetChild(Info->hTreeView,
pnmtv->itemNew.hItem))
{
SendMessage(Info->hTool,
TB_SETSTATE,
IDC_PROP,
(LPARAM)MAKELONG(TBSTATE_ENABLED, 0));
EnableMenuItem(GetMenu(Info->hMainWnd), IDC_PROP, MF_ENABLED);
EnableMenuItem(Info->hShortcutMenu, IDC_PROP, MF_ENABLED);
}
else
{
SendMessage(Info->hTool,
TB_SETSTATE,
IDC_PROP,
(LPARAM)MAKELONG(TBSTATE_INDETERMINATE, 0));
EnableMenuItem(GetMenu(Info->hMainWnd), IDC_PROP, MF_GRAYED);
EnableMenuItem(Info->hShortcutMenu, IDC_PROP, MF_GRAYED);
}
}
else if (Info->Display == DevicesByConnection)
{
if (pnmtv->itemNew.hItem == TreeView_GetRoot(Info->hTreeView))
{
SendMessage(Info->hTool,
TB_SETSTATE,
IDC_PROP,
(LPARAM)MAKELONG(TBSTATE_INDETERMINATE, 0));
EnableMenuItem(GetMenu(Info->hMainWnd), IDC_PROP, MF_GRAYED);
EnableMenuItem(Info->hShortcutMenu, IDC_PROP, MF_GRAYED);
}
else
{
SendMessage(Info->hTool,
TB_SETSTATE,
IDC_PROP,
(LPARAM)MAKELONG(TBSTATE_ENABLED, 0));
EnableMenuItem(GetMenu(Info->hMainWnd), IDC_PROP, MF_ENABLED);
EnableMenuItem(Info->hShortcutMenu, IDC_PROP, MF_ENABLED);
}
}
}
break;
case NM_RETURN:
{
HTREEITEM hSelected = TreeView_GetSelection(Info->hTreeView);
if (Info->Display == DevicesByType)
{
OpenPropSheet(Info->hTreeView, hSelected);
}
else if (Info->Display == DevicesByConnection)
{
if (hSelected != TreeView_GetRoot(Info->hTreeView))
{
OpenPropSheet(Info->hTreeView, hSelected);
}
}
}
break;
case NM_DBLCLK:
{
HTREEITEM hSelected = TreeView_GetSelection(Info->hTreeView);
TV_HITTESTINFO HitTest;
if (Info->Display == DevicesByType)
{
if (!TreeView_GetChild(Info->hTreeView,
hSelected))
{
if (GetCursorPos(&HitTest.pt) &&
ScreenToClient(Info->hTreeView, &HitTest.pt))
{
if (TreeView_HitTest(Info->hTreeView, &HitTest))
{
if (HitTest.hItem == hSelected)
{
OpenPropSheet(Info->hTreeView,
hSelected);
ret = TRUE;
}
}
}
}
}
else if (Info->Display == DevicesByConnection)
{
if (hSelected != TreeView_GetRoot(Info->hTreeView))
{
if (GetCursorPos(&HitTest.pt) &&
ScreenToClient(Info->hTreeView, &HitTest.pt))
{
if (TreeView_HitTest(Info->hTreeView, &HitTest))
{
if (HitTest.hItem == hSelected)
{
OpenPropSheet(Info->hTreeView,
hSelected);
ret = TRUE;
}
}
}
}
}
}
break;
case NM_RCLICK:
{
TV_HITTESTINFO HitTest;
if (GetCursorPos(&HitTest.pt) &&
ScreenToClient(Info->hTreeView, &HitTest.pt))
{
if (TreeView_HitTest(Info->hTreeView, &HitTest))
(void)TreeView_SelectItem(Info->hTreeView, HitTest.hItem);
}
}
break;
case TTN_GETDISPINFO:
{
LPTOOLTIPTEXT lpttt;
UINT idButton;
lpttt = (LPTOOLTIPTEXT)lParam;
idButton = (UINT)lpttt->hdr.idFrom;
switch (idButton)
{
case IDC_PROP:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_PROP);
break;
case IDC_REFRESH:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_REFRESH);
break;
case IDC_PROGHELP:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_HELP);
break;
case IDC_EXIT:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_EXIT);
break;
}
}
break;
}
return ret;
}
static VOID
OnRefresh(PMAIN_WND_INFO Info)
{
HANDLE DevEnumThread;
SendMessage(Info->hTool,
TB_SETSTATE,
IDC_PROP,
(LPARAM)MAKELONG(TBSTATE_INDETERMINATE, 0));
EnableMenuItem(GetMenu(Info->hMainWnd), IDC_PROP, MF_GRAYED);
EnableMenuItem(Info->hShortcutMenu, IDC_PROP, MF_GRAYED);
/* create seperate thread to emum devices */
DevEnumThread = CreateThread(NULL,
0,
DeviceEnumThread,
Info,
0,
NULL);
if (!DevEnumThread)
{
DisplayString(_T("Failed to enumerate devices"));
return;
}
CloseHandle(DevEnumThread);
}
static VOID
MainWndCommand(PMAIN_WND_INFO Info,
WORD CmdId,
HWND hControl)
{
UNREFERENCED_PARAMETER(hControl);
switch (CmdId)
{
case IDC_PROP:
{
HTREEITEM hSelected = TreeView_GetSelection(Info->hTreeView);
OpenPropSheet(Info->hTreeView,
hSelected);
}
break;
case IDC_REFRESH:
{
OnRefresh(Info);
}
break;
case IDC_PROGHELP:
{
DisplayString(_T("Help is not yet implemented\n"));
SetFocus(Info->hTreeView);
}
break;
case IDC_EXIT:
{
PostMessage(Info->hMainWnd,
WM_CLOSE,
0,
0);
}
break;
case IDC_ABOUT:
{
DialogBox(hInstance,
MAKEINTRESOURCE(IDD_ABOUTBOX),
Info->hMainWnd,
AboutDialogProc);
SetFocus(Info->hTreeView);
}
break;
case IDC_DEVBYTYPE:
{
Info->Display = DevicesByType;
UpdateViewMenu(Info);
OnRefresh(Info);
}
break;
case IDC_DEVBYCONN:
{
Info->Display = DevicesByConnection;
UpdateViewMenu(Info);
OnRefresh(Info);
}
break;
case IDC_SHOWHIDDEN:
{
Info->bShowHidden = !Info->bShowHidden;
UpdateViewMenu(Info);
OnRefresh(Info);
}
break;
}
}
static VOID CALLBACK
MainWndResize(PMAIN_WND_INFO Info,
WORD cx,
WORD cy)
{
RECT rcClient, rcTool, rcStatus;
int lvHeight, iToolHeight, iStatusHeight;
/* Size toolbar and get height */
SendMessage(Info->hTool, TB_AUTOSIZE, 0, 0);
GetWindowRect(Info->hTool, &rcTool);
iToolHeight = rcTool.bottom - rcTool.top;
/* Size status bar and get height */
SendMessage(Info->hStatus, WM_SIZE, 0, 0);
GetWindowRect(Info->hStatus, &rcStatus);
iStatusHeight = rcStatus.bottom - rcStatus.top;
/* Calculate remaining height and size list view */
GetClientRect(Info->hMainWnd, &rcClient);
lvHeight = rcClient.bottom - iToolHeight - iStatusHeight;
SetWindowPos(Info->hTreeView,
NULL,
0,
iToolHeight,
rcClient.right,
lvHeight,
SWP_NOZORDER);
}
static LRESULT CALLBACK
MainWndProc(HWND hwnd,
UINT msg,
WPARAM wParam,
LPARAM lParam)
{
PMAIN_WND_INFO Info;
LRESULT Ret = 0;
/* Get the window context */
Info = (PMAIN_WND_INFO)GetWindowLongPtr(hwnd,
GWLP_USERDATA);
if (Info == NULL && msg != WM_CREATE)
{
goto HandleDefaultMessage;
}
switch(msg)
{
case WM_CREATE:
{
Info = (PMAIN_WND_INFO)(((LPCREATESTRUCT)lParam)->lpCreateParams);
/* Initialize the main window context */
Info->hMainWnd = hwnd;
SetWindowLongPtr(hwnd,
GWLP_USERDATA,
(LONG_PTR)Info);
if (!InitMainWnd(Info))
SendMessage(hwnd, WM_CLOSE, 0, 0);
/* Show the window */
ShowWindow(hwnd,
Info->nCmdShow);
}
break;
case WM_SETFOCUS:
{
if (Info->hTreeView != NULL)
SetFocus(Info->hTreeView);
}
break;
case WM_SIZE:
{
MainWndResize(Info,
LOWORD(lParam),
HIWORD(lParam));
}
break;
case WM_NOTIFY:
{
Ret = OnNotify(Info, lParam);
}
break;
case WM_CONTEXTMENU:
{
OnContext(Info, lParam);
}
break;
case WM_COMMAND:
{
MainWndCommand(Info,
LOWORD(wParam),
(HWND)lParam);
goto HandleDefaultMessage;
}
case WM_MENUSELECT:
{
if (Info->hStatus != NULL)
{
if (!MainWndMenuHint(Info,
LOWORD(wParam),
MainMenuHintTable,
sizeof(MainMenuHintTable) / sizeof(MainMenuHintTable[0]),
IDS_HINT_BLANK))
{
MainWndMenuHint(Info,
LOWORD(wParam),
SystemMenuHintTable,
sizeof(SystemMenuHintTable) / sizeof(SystemMenuHintTable[0]),
IDS_HINT_BLANK);
}
}
}
break;
case WM_ENTERMENULOOP:
{
Info->InMenuLoop = TRUE;
UpdateMainStatusBar(Info);
break;
}
case WM_EXITMENULOOP:
{
Info->InMenuLoop = FALSE;
UpdateMainStatusBar(Info);
break;
}
case WM_CLOSE:
{
FreeDeviceStrings(Info->hTreeView);
DestroyMenu(Info->hShortcutMenu);
DestroyWindow(hwnd);
}
break;
case WM_DESTROY:
{
HeapFree(ProcessHeap,
0,
Info);
SetWindowLongPtr(hwnd,
GWLP_USERDATA,
0);
/* Break the message queue loop */
PostQuitMessage(0);
}
break;
default:
{
HandleDefaultMessage:
Ret = DefWindowProc(hwnd,
msg,
wParam,
lParam);
}
break;
}
return Ret;
}
HWND
CreateMainWindow(LPCTSTR lpCaption,
int nCmdShow)
{
PMAIN_WND_INFO Info;
HWND hMainWnd = NULL;
Info = (PMAIN_WND_INFO)HeapAlloc(ProcessHeap,
HEAP_ZERO_MEMORY,
sizeof(MAIN_WND_INFO));
if (Info != NULL)
{
Info->nCmdShow = nCmdShow;
Info->Display = DevicesByType;
Info->bShowHidden = TRUE;
hMainWnd = CreateWindowEx(WS_EX_WINDOWEDGE,
szMainWndClass,
lpCaption,
WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
CW_USEDEFAULT,
CW_USEDEFAULT,
600,
450,
NULL,
NULL,
hInstance,
Info);
if (hMainWnd == NULL)
{
GetError();
HeapFree(ProcessHeap,
0,
Info);
}
}
return hMainWnd;
}
BOOL
InitMainWindowImpl(VOID)
{
WNDCLASSEX wc = {0};
wc.cbSize = sizeof(WNDCLASSEX);
wc.lpfnWndProc = MainWndProc;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon(hInstance,
MAKEINTRESOURCE(IDI_MAIN_ICON));
wc.hCursor = LoadCursor(NULL,
IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
wc.lpszMenuName = MAKEINTRESOURCE(IDR_MAINMENU);
wc.lpszClassName = szMainWndClass;
wc.hIconSm = (HICON)LoadImage(hInstance,
MAKEINTRESOURCE(IDI_MAIN_ICON),
IMAGE_ICON,
16,
16,
LR_SHARED);
return RegisterClassEx(&wc) != (ATOM)0;
}
VOID
UninitMainWindowImpl(VOID)
{
UnregisterClass(szMainWndClass,
hInstance);
}

View file

@ -1,260 +0,0 @@
/*
* PROJECT: ReactOS Device Managment
* LICENSE: GPL - See COPYING in the top level directory
* FILE: base/applications/mscutils/devmgmt/misc.c
* PURPOSE: miscallanous functions
* COPYRIGHT: Copyright 2006 Ged Murphy <gedmurphy@gmail.com>
*
*/
#include "precomp.h"
static INT
LengthOfStrResource(IN HINSTANCE hInst,
IN UINT uID)
{
HRSRC hrSrc;
HGLOBAL hRes;
LPWSTR lpName, lpStr;
if (hInst == NULL)
{
return -1;
}
/* There are always blocks of 16 strings */
lpName = (LPWSTR)MAKEINTRESOURCE((uID >> 4) + 1);
/* Find the string table block */
if ((hrSrc = FindResourceW(hInst, lpName, (LPWSTR)RT_STRING)) &&
(hRes = LoadResource(hInst, hrSrc)) &&
(lpStr = (LPWSTR)LockResource(hRes)))
{
UINT x;
/* Find the string we're looking for */
uID &= 0xF; /* position in the block, same as % 16 */
for (x = 0; x < uID; x++)
{
lpStr += (*lpStr) + 1;
}
/* Found the string */
return (int)(*lpStr);
}
return -1;
}
INT
AllocAndLoadString(OUT LPTSTR *lpTarget,
IN HINSTANCE hInst,
IN UINT uID)
{
INT ln;
ln = LengthOfStrResource(hInst,
uID);
if (ln++ > 0)
{
(*lpTarget) = (LPTSTR)LocalAlloc(LMEM_FIXED,
ln * sizeof(TCHAR));
if ((*lpTarget) != NULL)
{
INT Ret;
if (!(Ret = LoadString(hInst, uID, *lpTarget, ln)))
{
LocalFree((HLOCAL)(*lpTarget));
}
return Ret;
}
}
return 0;
}
DWORD
LoadAndFormatString(IN HINSTANCE hInstance,
IN UINT uID,
OUT LPTSTR *lpTarget,
...)
{
DWORD Ret = 0;
LPTSTR lpFormat;
va_list lArgs;
if (AllocAndLoadString(&lpFormat,
hInstance,
uID) > 0)
{
va_start(lArgs, lpTarget);
/* let's use FormatMessage to format it because it has the ability to allocate
memory automatically */
Ret = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
lpFormat,
0,
0,
(LPTSTR)lpTarget,
0,
&lArgs);
va_end(lArgs);
LocalFree((HLOCAL)lpFormat);
}
return Ret;
}
BOOL
StatusBarLoadAndFormatString(IN HWND hStatusBar,
IN INT PartId,
IN HINSTANCE hInstance,
IN UINT uID,
...)
{
BOOL Ret = FALSE;
LPTSTR lpFormat, lpStr;
va_list lArgs;
if (AllocAndLoadString(&lpFormat,
hInstance,
uID) > 0)
{
va_start(lArgs, uID);
/* let's use FormatMessage to format it because it has the ability to allocate
memory automatically */
Ret = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
lpFormat,
0,
0,
(LPTSTR)&lpStr,
0,
&lArgs);
va_end(lArgs);
if (lpStr != NULL)
{
Ret = (BOOL)SendMessage(hStatusBar,
SB_SETTEXT,
(WPARAM)PartId,
(LPARAM)lpStr);
LocalFree((HLOCAL)lpStr);
}
LocalFree((HLOCAL)lpFormat);
}
return Ret;
}
BOOL
StatusBarLoadString(IN HWND hStatusBar,
IN INT PartId,
IN HINSTANCE hInstance,
IN UINT uID)
{
BOOL Ret = FALSE;
LPTSTR lpStr;
if (AllocAndLoadString(&lpStr,
hInstance,
uID) > 0)
{
Ret = (BOOL)SendMessage(hStatusBar,
SB_SETTEXT,
(WPARAM)PartId,
(LPARAM)lpStr);
LocalFree((HLOCAL)lpStr);
}
return Ret;
}
INT
GetTextFromEdit(OUT LPTSTR lpString,
IN HWND hDlg,
IN UINT Res)
{
INT len = GetWindowTextLength(GetDlgItem(hDlg, Res));
if(len > 0)
{
GetDlgItemText(hDlg,
Res,
lpString,
len + 1);
}
else
lpString = NULL;
return len;
}
HIMAGELIST
InitImageList(UINT StartResource,
UINT EndResource,
UINT Width,
UINT Height)
{
HBITMAP hBitmap;
HIMAGELIST hImageList;
UINT i;
INT Ret;
/* Create the toolbar icon image list */
hImageList = ImageList_Create(Width,
Height,
ILC_MASK | ILC_COLOR24,
EndResource - StartResource,
0);
if (hImageList == NULL)
return NULL;
/* Add all icons to the image list */
for (i = StartResource; i <= EndResource; i++)
{
hBitmap = (HBITMAP)LoadImage(hInstance,
MAKEINTRESOURCE(i),
IMAGE_BITMAP,
Width,
Height,
LR_LOADTRANSPARENT);
if (hBitmap == NULL)
return NULL;
Ret = ImageList_AddMasked(hImageList,
hBitmap,
RGB(255, 0, 128));
if (Ret == -1)
return NULL;
DeleteObject(hBitmap);
}
return hImageList;
}
VOID GetError(VOID)
{
LPVOID lpMsgBuf;
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &lpMsgBuf,
0,
NULL );
MessageBox(NULL, lpMsgBuf, _T("Error!"), MB_OK | MB_ICONERROR);
LocalFree(lpMsgBuf);
}
VOID DisplayString(LPTSTR Msg)
{
MessageBox(NULL, Msg, _T("Note!"), MB_ICONEXCLAMATION|MB_OK);
}

View file

@ -1,119 +0,0 @@
#ifndef __DEVMGMT_PRECOMP_H
#define __DEVMGMT_PRECOMP_H
#include <stdarg.h>
#include <windef.h>
#include <winbase.h>
#include <winuser.h>
#include <winreg.h>
#include <wingdi.h>
#include <tchar.h>
#include <setupapi.h>
#include "resource.h"
#ifdef _MSC_VER
#pragma warning(disable : 4100)
#endif
#define MAX_DEV_LEN 256
typedef enum
{
DevicesByType,
DevicesByConnection,
RessourcesByType,
RessourcesByConnection
} DISPLAY_TYPE;
typedef struct _MAIN_WND_INFO
{
HWND hMainWnd;
HWND hTreeView;
HWND hStatus;
HWND hTool;
HWND hProgDlg;
HMENU hShortcutMenu;
int nCmdShow;
DISPLAY_TYPE Display;
BOOL bShowHidden;
/* status flags */
UINT InMenuLoop : 1;
} MAIN_WND_INFO, *PMAIN_WND_INFO;
typedef struct _DEVCLASS_ENTRY
{
GUID ClassGuid;
INT ClassImage;
BOOL bUsed;
HTREEITEM hItem;
} DEVCLASS_ENTRY, *PDEVCLASS_ENTRY;
INT_PTR CALLBACK AboutDialogProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
/* devmgmt.c */
extern HINSTANCE hInstance;
extern HANDLE ProcessHeap;
/* mainwnd.c */
typedef struct _MENU_HINT
{
WORD CmdId;
UINT HintId;
} MENU_HINT, *PMENU_HINT;
BOOL InitMainWindowImpl(VOID);
VOID UninitMainWindowImpl(VOID);
HWND CreateMainWindow(LPCTSTR lpCaption, int nCmdShow);
/* enumdevices.c */
VOID FreeDeviceStrings(HWND hTreeView);
VOID OpenPropSheet(HWND hTreeView, HTREEITEM hItem);
HTREEITEM InitTreeView(HWND hTreeView);
VOID ListDevicesByType(HWND hTreeView, HTREEITEM hRoot, BOOL bShowHidden);
VOID ListDevicesByConnection(HWND hTreeView, HTREEITEM hRoot, BOOL bShowHidden);
/* misc.c */
INT AllocAndLoadString(OUT LPTSTR *lpTarget,
IN HINSTANCE hInst,
IN UINT uID);
DWORD LoadAndFormatString(IN HINSTANCE hInstance,
IN UINT uID,
OUT LPTSTR *lpTarget,
...);
BOOL StatusBarLoadAndFormatString(IN HWND hStatusBar,
IN INT PartId,
IN HINSTANCE hInstance,
IN UINT uID,
...);
BOOL StatusBarLoadString(IN HWND hStatusBar,
IN INT PartId,
IN HINSTANCE hInstance,
IN UINT uID);
INT GetTextFromEdit(OUT LPTSTR lpString,
IN HWND hDlg,
IN UINT Res);
HIMAGELIST InitImageList(UINT NumButtons,
UINT StartResource,
UINT Width,
UINT Height);
VOID GetError(VOID);
VOID DisplayString(LPTSTR);
#endif /* __DEVMGMT_PRECOMP_H */

Binary file not shown.

Before

Width:  |  Height:  |  Size: 39 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 822 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 822 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 822 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 822 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 822 B

View file

@ -1,69 +0,0 @@
#pragma once
#define IDC_STATIC -1
#define IDI_MAIN_ICON 50
#define IDB_ROOT_IMAGE 51
/* windows */
#define IDC_TREEVIEW 1000
#define IDC_TOOLBAR 1001
#define IDC_STATUSBAR 1002
/* commands */
#define IDC_PROP 2000
#define IDC_REFRESH 2001
#define IDC_PRINT 2002
#define IDC_PROGHELP 2003
#define IDC_EXIT 2004
#define IDC_ABOUT 4031
/* menus */
#define IDR_MAINMENU 102
#define IDR_POPUP 103
#define IDC_DEVBYTYPE 104
#define IDC_DEVBYCONN 105
#define IDC_RESBYTYPE 106
#define IDC_RESBYCONN 107
#define IDC_SHOWHIDDEN 108
/* tooltips */
#define IDS_TOOLTIP_PROP 6000
#define IDS_TOOLTIP_REFRESH 6001
#define IDS_TOOLTIP_HELP 6002
#define IDS_TOOLTIP_EXIT 6003
/* button bitmaps */
#define IDB_PROP 10000
#define IDB_REFRESH 10001
#define IDB_HELP 10002
#define IDB_EXIT 10003
/* toolbar buttons */
#define TBICON_PROP 0
#define TBICON_REFRESH 1
#define TBICON_HELP 2
#define TBICON_EXIT 3
/* about box info */
#define IDD_ABOUTBOX 200
#define IDC_LICENSE_EDIT 201
#define IDS_APPNAME 202
#define IDS_LICENSE 203
/* menu hints */
#define IDS_HINT_BLANK 20000
#define IDS_HINT_REFRESH 20002
#define IDS_HINT_PROP 20003
#define IDS_HINT_HELP 20004
#define IDS_HINT_ABOUT 20005
#define IDS_HINT_EXIT 20006
/* system menu hints */
#define IDS_HINT_SYS_RESTORE 21001
#define IDS_HINT_SYS_MOVE 21002
#define IDS_HINT_SYS_SIZE 21003
#define IDS_HINT_SYS_MINIMIZE 21004
#define IDS_HINT_SYS_MAXIMIZE 21005
#define IDS_HINT_SYS_CLOSE 21006

View file

@ -1,39 +0,0 @@
/*
* PROJECT: ReactOS Applications Manager
* LICENSE: GPL - See COPYING in the top level directory
* FILE: base/applications/rapps/aboutdlg.c
* PURPOSE: About Dialog
* PROGRAMMERS: Dmitry Chapyshev (dmitry@reactos.org)
*/
#include "rapps.h"
static
INT_PTR CALLBACK
AboutDlgProc(HWND hDlg, UINT Msg, WPARAM wParam, LPARAM lParam)
{
switch (Msg)
{
case WM_COMMAND:
{
switch (LOWORD(wParam))
{
case IDOK:
EndDialog(hDlg, LOWORD(wParam));
break;
}
}
break;
}
return FALSE;
}
VOID
ShowAboutDialog(VOID)
{
DialogBox(hInst,
MAKEINTRESOURCE(IDD_ABOUT_DIALOG),
hMainWnd,
AboutDlgProc);
}

View file

@ -1,292 +0,0 @@
/*
* PROJECT: ReactOS Applications Manager
* LICENSE: GPL - See COPYING in the top level directory
* FILE: base/applications/rapps/available.c
* PURPOSE: Functions for working with available applications
* PROGRAMMERS: Dmitry Chapyshev (dmitry@reactos.org)
* Ismael Ferreras Morezuelas (swyterzone+ros@gmail.com)
*/
#include "rapps.h"
#define ADD_TEXT(a, b, c, d) \
if (b[0] != '\0') \
{ \
LoadStringW(hInst, a, szText, _countof(szText)); \
InsertRichEditText(szText, c); \
InsertRichEditText(b, d); \
} \
#define GET_STRING1(a, b) \
if (!ParserGetString(a, b, MAX_PATH, FindFileData.cFileName)) \
continue;
#define GET_STRING2(a, b) \
if (!ParserGetString(a, b, MAX_PATH, FindFileData.cFileName)) \
b[0] = '\0';
LIST_ENTRY CachedEntriesHead = { &CachedEntriesHead, &CachedEntriesHead };
PLIST_ENTRY pCachedEntry = &CachedEntriesHead;
BOOL
ShowAvailableAppInfo(INT Index)
{
PAPPLICATION_INFO Info = (PAPPLICATION_INFO) ListViewGetlParam(Index);
WCHAR szText[MAX_STR_LEN];
if (!Info) return FALSE;
NewRichEditText(Info->szName, CFE_BOLD);
InsertRichEditText(L"\n", 0);
ADD_TEXT(IDS_AINFO_VERSION, Info->szVersion, CFE_BOLD, 0);
ADD_TEXT(IDS_AINFO_LICENSE, Info->szLicense, CFE_BOLD, 0);
ADD_TEXT(IDS_AINFO_SIZE, Info->szSize, CFE_BOLD, 0);
ADD_TEXT(IDS_AINFO_URLSITE, Info->szUrlSite, CFE_BOLD, CFE_LINK);
ADD_TEXT(IDS_AINFO_DESCRIPTION, Info->szDesc, CFE_BOLD, 0);
return TRUE;
}
static BOOL
DeleteCurrentAppsDB(VOID)
{
HANDLE hFind = INVALID_HANDLE_VALUE;
WIN32_FIND_DATAW FindFileData;
WCHAR szCabPath[MAX_PATH];
WCHAR szSearchPath[MAX_PATH];
WCHAR szPath[MAX_PATH];
WCHAR szTmp[MAX_PATH];
HRESULT hr;
BOOL result = TRUE;
if (!GetStorageDirectory(szPath, _countof(szPath)))
return FALSE;
hr = StringCbPrintfW(szCabPath, sizeof(szCabPath),
L"%ls\\rappmgr.cab",
szPath);
if (FAILED(hr))
return FALSE;
result = result && DeleteFileW(szCabPath);
hr = StringCbCatW(szPath, sizeof(szPath), L"\\rapps\\");
if (FAILED(hr))
return FALSE;
hr = StringCbPrintfW(szSearchPath, sizeof(szSearchPath),
L"%ls*.txt",
szPath);
if (FAILED(hr))
return FALSE;
hFind = FindFirstFileW(szSearchPath, &FindFileData);
if (hFind == INVALID_HANDLE_VALUE)
return result;
do
{
hr = StringCbPrintfW(szTmp, sizeof(szTmp),
L"%ls%ls",
szPath, FindFileData.cFileName);
if (FAILED(hr))
continue;
result = result && DeleteFileW(szTmp);
} while (FindNextFileW(hFind, &FindFileData) != 0);
FindClose(hFind);
return result;
}
BOOL
UpdateAppsDB(VOID)
{
WCHAR szPath[MAX_PATH];
WCHAR szAppsPath[MAX_PATH];
WCHAR szCabPath[MAX_PATH];
if (!DeleteCurrentAppsDB())
return FALSE;
DownloadApplicationsDB(APPLICATION_DATABASE_URL);
if (!GetStorageDirectory(szPath, _countof(szPath)))
return FALSE;
if (FAILED(StringCbPrintfW(szCabPath, sizeof(szCabPath),
L"%ls\\rappmgr.cab",
szPath)))
{
return FALSE;
}
if (FAILED(StringCbPrintfW(szAppsPath, sizeof(szAppsPath),
L"%ls\\rapps\\",
szPath)))
{
return FALSE;
}
ExtractFilesFromCab(szCabPath, szAppsPath);
return TRUE;
}
BOOL
EnumAvailableApplications(INT EnumType, AVAILENUMPROC lpEnumProc)
{
HANDLE hFind = INVALID_HANDLE_VALUE;
WIN32_FIND_DATAW FindFileData;
WCHAR szPath[MAX_PATH];
WCHAR szAppsPath[MAX_PATH];
WCHAR szCabPath[MAX_PATH];
PAPPLICATION_INFO Info;
HRESULT hr;
if (!GetStorageDirectory(szPath, _countof(szPath)))
return FALSE;
hr = StringCbPrintfW(szCabPath, sizeof(szCabPath),
L"%ls\\rappmgr.cab",
szPath);
if (FAILED(hr))
return FALSE;
hr = StringCbCatW(szPath, sizeof(szPath), L"\\rapps\\");
if (FAILED(hr))
return FALSE;
hr = StringCbCopyW(szAppsPath, sizeof(szAppsPath), szPath);
if (FAILED(hr))
return FALSE;
if (!CreateDirectory(szPath, NULL) &&
GetLastError() != ERROR_ALREADY_EXISTS)
{
return FALSE;
}
hr = StringCbCatW(szPath, sizeof(szPath), L"*.txt");
if (FAILED(hr))
return FALSE;
hFind = FindFirstFileW(szPath, &FindFileData);
if (hFind == INVALID_HANDLE_VALUE)
{
if (GetFileAttributesW(szCabPath) == INVALID_FILE_ATTRIBUTES)
DownloadApplicationsDB(APPLICATION_DATABASE_URL);
ExtractFilesFromCab(szCabPath, szAppsPath);
hFind = FindFirstFileW(szPath, &FindFileData);
if (hFind == INVALID_HANDLE_VALUE)
return FALSE;
}
do
{
/* loop for all the cached entries */
for (pCachedEntry = CachedEntriesHead.Flink; pCachedEntry != &CachedEntriesHead; pCachedEntry = pCachedEntry->Flink)
{
Info = CONTAINING_RECORD(pCachedEntry, APPLICATION_INFO, List);
/* do we already have this entry in cache? */
if(_wcsicmp(FindFileData.cFileName, Info->cFileName) == 0)
{
/* is it current enough, or the file has been modified since our last time here? */
if (CompareFileTime(&FindFileData.ftLastWriteTime, &Info->ftCacheStamp) == 1)
{
/* recreate our cache, this is the slow path */
RemoveEntryList(&Info->List);
HeapFree(GetProcessHeap(), 0, Info);
}
else
{
/* speedy path, compare directly, we already have the data */
goto skip_if_cached;
}
break;
}
}
/* create a new entry */
Info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(APPLICATION_INFO));
if(!Info)
break;
Info->Category = ParserGetInt(L"Category", FindFileData.cFileName);
/* copy the cache-related fields for the next time */
RtlCopyMemory(&Info->cFileName, &FindFileData.cFileName, MAX_PATH);
RtlCopyMemory(&Info->ftCacheStamp, &FindFileData.ftLastWriteTime, sizeof(FILETIME));
/* add our cached entry to the cached list */
InsertTailList(&CachedEntriesHead, &Info->List);
skip_if_cached:
if (Info->Category == FALSE)
continue;
if (EnumType != Info->Category && EnumType != ENUM_ALL_AVAILABLE)
continue;
/* if our cache hit was only partial, we need to parse
and lazily fill the rest of fields only when needed */
if (Info->szUrlDownload[0] == 0)
{
GET_STRING1(L"Name", Info->szName);
GET_STRING1(L"URLDownload", Info->szUrlDownload);
GET_STRING2(L"RegName", Info->szRegName);
GET_STRING2(L"Version", Info->szVersion);
GET_STRING2(L"License", Info->szLicense);
GET_STRING2(L"Description", Info->szDesc);
GET_STRING2(L"Size", Info->szSize);
GET_STRING2(L"URLSite", Info->szUrlSite);
GET_STRING2(L"CDPath", Info->szCDPath);
GET_STRING2(L"SHA1", Info->szSHA1);
}
if (!lpEnumProc(Info))
break;
} while (FindNextFileW(hFind, &FindFileData) != 0);
FindClose(hFind);
return TRUE;
}
VOID FreeCachedAvailableEntries(VOID)
{
PAPPLICATION_INFO Info;
/* loop and deallocate all the cached app infos in the list */
for (pCachedEntry = CachedEntriesHead.Flink; pCachedEntry != &CachedEntriesHead;)
{
Info = CONTAINING_RECORD(pCachedEntry, APPLICATION_INFO, List);
/* grab a reference to the next linked entry before getting rid of the current one */
pCachedEntry = pCachedEntry->Flink;
/* flush them down the toilet :D */
RemoveEntryList(&Info->List);
HeapFree(GetProcessHeap(), 0, Info);
}
}

View file

@ -1,56 +0,0 @@
/*
* PROJECT: ReactOS Applications Manager
* LICENSE: GPL - See COPYING in the top level directory
* FILE: base/applications/rapps/installdlg.c
* PURPOSE: "Download and Install" Dialog
* PROGRAMMERS: Dmitry Chapyshev (dmitry@reactos.org)
*/
#include "rapps.h"
static PAPPLICATION_INFO AppInfo;
static
INT_PTR CALLBACK
InstallDlgProc(HWND hDlg, UINT Msg, WPARAM wParam, LPARAM lParam)
{
switch (Msg)
{
case WM_INITDIALOG:
{
}
break;
case WM_COMMAND:
{
switch (LOWORD(wParam))
{
case IDOK:
case IDCANCEL:
EndDialog(hDlg, LOWORD(wParam));
break;
}
}
break;
}
return FALSE;
}
BOOL
InstallApplication(INT Index)
{
if (!IS_AVAILABLE_ENUM(SelectedEnumType))
return FALSE;
AppInfo = (PAPPLICATION_INFO) ListViewGetlParam(Index);
if (!AppInfo) return FALSE;
DialogBox(hInst,
MAKEINTRESOURCE(IDD_INSTALL_DIALOG),
hMainWnd,
InstallDlgProc);
return TRUE;
}

View file

@ -1,308 +0,0 @@
/*
* PROJECT: ReactOS Applications Manager
* LICENSE: GPL - See COPYING in the top level directory
* FILE: base/applications/rapps/installed.c
* PURPOSE: Functions for working with installed applications
* PROGRAMMERS: Dmitry Chapyshev (dmitry@reactos.org)
*/
#include "rapps.h"
BOOL
GetApplicationString(HKEY hKey, LPWSTR lpKeyName, LPWSTR lpString)
{
DWORD dwSize = MAX_PATH * sizeof(WCHAR);
if (RegQueryValueExW(hKey,
lpKeyName,
NULL,
NULL,
(LPBYTE)lpString,
&dwSize) == ERROR_SUCCESS)
{
return TRUE;
}
(VOID)StringCchCopyW(lpString, MAX_PATH, L"---");
return FALSE;
}
BOOL
IsInstalledApplication(LPWSTR lpRegName, BOOL IsUserKey)
{
DWORD dwSize = MAX_PATH, dwType;
WCHAR szName[MAX_PATH];
WCHAR szDisplayName[MAX_PATH];
HKEY hKey, hSubKey;
INT ItemIndex = 0;
if (RegOpenKeyW(IsUserKey ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE,
L"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall",
&hKey) != ERROR_SUCCESS)
{
return FALSE;
}
while (RegEnumKeyExW(hKey, ItemIndex, szName, &dwSize, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
{
if (RegOpenKeyW(hKey, szName, &hSubKey) == ERROR_SUCCESS)
{
dwType = REG_SZ;
dwSize = sizeof(szDisplayName);
if (RegQueryValueExW(hSubKey,
L"DisplayName",
NULL,
&dwType,
(LPBYTE)szDisplayName,
&dwSize) == ERROR_SUCCESS)
{
if (wcscmp(szDisplayName, lpRegName) == 0)
{
RegCloseKey(hSubKey);
RegCloseKey(hKey);
return TRUE;
}
}
}
RegCloseKey(hSubKey);
dwSize = MAX_PATH;
ItemIndex++;
}
RegCloseKey(hKey);
return FALSE;
}
BOOL
UninstallApplication(INT Index, BOOL bModify)
{
WCHAR szModify[] = L"ModifyPath";
WCHAR szUninstall[] = L"UninstallString";
WCHAR szPath[MAX_PATH];
WCHAR szAppName[MAX_STR_LEN];
DWORD dwType, dwSize;
INT ItemIndex;
LVITEM Item;
HKEY hKey;
PINSTALLED_INFO ItemInfo;
if (!IS_INSTALLED_ENUM(SelectedEnumType))
return FALSE;
if (Index == -1)
{
ItemIndex = (INT) SendMessageW(hListView, LVM_GETNEXTITEM, -1, LVNI_FOCUSED);
if (ItemIndex == -1)
return FALSE;
}
else
{
ItemIndex = Index;
}
ListView_GetItemText(hListView, ItemIndex, 0, szAppName, _countof(szAppName));
WriteLogMessage(EVENTLOG_SUCCESS, MSG_SUCCESS_REMOVE, szAppName);
ZeroMemory(&Item, sizeof(Item));
Item.mask = LVIF_PARAM;
Item.iItem = ItemIndex;
if (!ListView_GetItem(hListView, &Item))
return FALSE;
ItemInfo = (PINSTALLED_INFO)Item.lParam;
hKey = ItemInfo->hSubKey;
dwType = REG_SZ;
dwSize = sizeof(szPath);
if (RegQueryValueExW(hKey,
bModify ? szModify : szUninstall,
NULL,
&dwType,
(LPBYTE)szPath,
&dwSize) != ERROR_SUCCESS)
{
return FALSE;
}
return StartProcess(szPath, TRUE);
}
BOOL
ShowInstalledAppInfo(INT Index)
{
WCHAR szText[MAX_PATH], szInfo[MAX_PATH];
PINSTALLED_INFO Info = ListViewGetlParam(Index);
if (!Info || !Info->hSubKey) return FALSE;
GetApplicationString(Info->hSubKey, L"DisplayName", szText);
NewRichEditText(szText, CFE_BOLD);
InsertRichEditText(L"\n", 0);
#define GET_INFO(a, b, c, d) \
if (GetApplicationString(Info->hSubKey, a, szInfo)) \
{ \
LoadStringW(hInst, b, szText, _countof(szText)); \
InsertRichEditText(szText, c); \
InsertRichEditText(szInfo, d); \
} \
GET_INFO(L"DisplayVersion", IDS_INFO_VERSION, CFE_BOLD, 0);
GET_INFO(L"Publisher", IDS_INFO_PUBLISHER, CFE_BOLD, 0);
GET_INFO(L"RegOwner", IDS_INFO_REGOWNER, CFE_BOLD, 0);
GET_INFO(L"ProductID", IDS_INFO_PRODUCTID, CFE_BOLD, 0);
GET_INFO(L"HelpLink", IDS_INFO_HELPLINK, CFE_BOLD, CFM_LINK);
GET_INFO(L"HelpTelephone", IDS_INFO_HELPPHONE, CFE_BOLD, 0);
GET_INFO(L"Readme", IDS_INFO_README, CFE_BOLD, 0);
GET_INFO(L"Contact", IDS_INFO_CONTACT, CFE_BOLD, 0);
GET_INFO(L"URLUpdateInfo", IDS_INFO_UPDATEINFO, CFE_BOLD, CFM_LINK);
GET_INFO(L"URLInfoAbout", IDS_INFO_INFOABOUT, CFE_BOLD, CFM_LINK);
GET_INFO(L"Comments", IDS_INFO_COMMENTS, CFE_BOLD, 0);
GET_INFO(L"InstallDate", IDS_INFO_INSTALLDATE, CFE_BOLD, 0);
GET_INFO(L"InstallLocation", IDS_INFO_INSTLOCATION, CFE_BOLD, 0);
GET_INFO(L"InstallSource", IDS_INFO_INSTALLSRC, CFE_BOLD, 0);
GET_INFO(L"UninstallString", IDS_INFO_UNINSTALLSTR, CFE_BOLD, 0);
GET_INFO(L"InstallSource", IDS_INFO_INSTALLSRC, CFE_BOLD, 0);
GET_INFO(L"ModifyPath", IDS_INFO_MODIFYPATH, CFE_BOLD, 0);
return TRUE;
}
VOID
RemoveAppFromRegistry(INT Index)
{
PINSTALLED_INFO Info;
WCHAR szFullName[MAX_PATH] = L"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\";
WCHAR szMsgText[MAX_STR_LEN], szMsgTitle[MAX_STR_LEN];
INT ItemIndex = SendMessage(hListView, LVM_GETNEXTITEM, -1, LVNI_FOCUSED);
if (!IS_INSTALLED_ENUM(SelectedEnumType))
return;
Info = ListViewGetlParam(Index);
if (!Info || !Info->hSubKey || (ItemIndex == -1)) return;
if (!LoadStringW(hInst, IDS_APP_REG_REMOVE, szMsgText, _countof(szMsgText)) ||
!LoadStringW(hInst, IDS_INFORMATION, szMsgTitle, _countof(szMsgTitle)))
return;
if (MessageBoxW(hMainWnd, szMsgText, szMsgTitle, MB_YESNO | MB_ICONQUESTION) == IDYES)
{
wcsncat(szFullName, Info->szKeyName, MAX_PATH - wcslen(szFullName));
if (RegDeleteKeyW(Info->hRootKey, szFullName) == ERROR_SUCCESS)
{
(VOID) ListView_DeleteItem(hListView, ItemIndex);
return;
}
if (!LoadStringW(hInst, IDS_UNABLE_TO_REMOVE, szMsgText, _countof(szMsgText)))
return;
MessageBoxW(hMainWnd, szMsgText, NULL, MB_OK | MB_ICONERROR);
}
}
BOOL
EnumInstalledApplications(INT EnumType, BOOL IsUserKey, APPENUMPROC lpEnumProc)
{
DWORD dwSize = MAX_PATH, dwType, dwValue;
BOOL bIsSystemComponent, bIsUpdate;
WCHAR pszParentKeyName[MAX_PATH];
WCHAR pszDisplayName[MAX_PATH];
INSTALLED_INFO Info;
HKEY hKey;
LONG ItemIndex = 0;
Info.hRootKey = IsUserKey ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE;
if (RegOpenKeyW(Info.hRootKey,
L"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall",
&hKey) != ERROR_SUCCESS)
{
return FALSE;
}
while (RegEnumKeyExW(hKey, ItemIndex, Info.szKeyName, &dwSize, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
{
if (RegOpenKeyW(hKey, Info.szKeyName, &Info.hSubKey) == ERROR_SUCCESS)
{
dwType = REG_DWORD;
dwSize = sizeof(DWORD);
if (RegQueryValueExW(Info.hSubKey,
L"SystemComponent",
NULL,
&dwType,
(LPBYTE)&dwValue,
&dwSize) == ERROR_SUCCESS)
{
bIsSystemComponent = (dwValue == 0x1);
}
else
{
bIsSystemComponent = FALSE;
}
dwType = REG_SZ;
dwSize = sizeof(pszParentKeyName);
bIsUpdate = (RegQueryValueExW(Info.hSubKey,
L"ParentKeyName",
NULL,
&dwType,
(LPBYTE)pszParentKeyName,
&dwSize) == ERROR_SUCCESS);
dwSize = sizeof(pszDisplayName);
if (RegQueryValueExW(Info.hSubKey,
L"DisplayName",
NULL,
&dwType,
(LPBYTE)pszDisplayName,
&dwSize) == ERROR_SUCCESS)
{
if (EnumType < ENUM_ALL_COMPONENTS || EnumType > ENUM_UPDATES)
EnumType = ENUM_ALL_COMPONENTS;
if (!bIsSystemComponent)
{
if ((EnumType == ENUM_ALL_COMPONENTS) || /* All components */
((EnumType == ENUM_APPLICATIONS) && (!bIsUpdate)) || /* Applications only */
((EnumType == ENUM_UPDATES) && (bIsUpdate))) /* Updates only */
{
if (!lpEnumProc(ItemIndex, pszDisplayName, &Info))
break;
}
else
{
RegCloseKey(Info.hSubKey);
}
}
else
{
RegCloseKey(Info.hSubKey);
}
}
else
{
RegCloseKey(Info.hSubKey);
}
}
dwSize = MAX_PATH;
ItemIndex++;
}
RegCloseKey(hKey);
return TRUE;
}

View file

@ -1,121 +0,0 @@
/*
* PROJECT: ReactOS Applications Manager
* LICENSE: GPL - See COPYING in the top level directory
* FILE: base/applications/rapps/listview.c
* PURPOSE: ListView functions
* PROGRAMMERS: Dmitry Chapyshev (dmitry@reactos.org)
*/
#include "rapps.h"
HWND hListView;
BOOL bAscending = TRUE;
PVOID
ListViewGetlParam(INT Index)
{
INT ItemIndex;
LVITEM Item;
if (Index == -1)
{
ItemIndex = (INT) SendMessage(hListView, LVM_GETNEXTITEM, -1, LVNI_FOCUSED);
if (ItemIndex == -1)
return NULL;
}
else
{
ItemIndex = Index;
}
ZeroMemory(&Item, sizeof(Item));
Item.mask = LVIF_PARAM;
Item.iItem = ItemIndex;
if (!ListView_GetItem(hListView, &Item))
return NULL;
return (PVOID)Item.lParam;
}
BOOL
ListViewAddColumn(INT Index, LPWSTR lpText, INT Width, INT Format)
{
LV_COLUMN Column;
ZeroMemory(&Column, sizeof(Column));
Column.mask = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
Column.iSubItem = Index;
Column.pszText = (LPTSTR)lpText;
Column.cx = Width;
Column.fmt = Format;
return (ListView_InsertColumn(hListView, Index, &Column) == -1) ? FALSE : TRUE;
}
INT
ListViewAddItem(INT ItemIndex, INT IconIndex, LPWSTR lpText, LPARAM lParam)
{
LV_ITEMW Item;
ZeroMemory(&Item, sizeof(Item));
Item.mask = LVIF_TEXT | LVIF_PARAM | LVIF_STATE | LVIF_IMAGE;
Item.pszText = lpText;
Item.lParam = lParam;
Item.iItem = ItemIndex;
Item.iImage = IconIndex;
return ListView_InsertItem(hListView, &Item);
}
INT
CALLBACK
ListViewCompareFunc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
{
WCHAR Item1[MAX_STR_LEN], Item2[MAX_STR_LEN];
LVFINDINFO IndexInfo;
INT Index;
IndexInfo.flags = LVFI_PARAM;
IndexInfo.lParam = lParam1;
Index = ListView_FindItem(hListView, -1, &IndexInfo);
ListView_GetItemText(hListView, Index, (INT)lParamSort, Item1, _countof(Item1));
IndexInfo.lParam = lParam2;
Index = ListView_FindItem(hListView, -1, &IndexInfo);
ListView_GetItemText(hListView, Index, (INT)lParamSort, Item2, _countof(Item2));
if (bAscending)
return wcscmp(Item2, Item1);
else
return wcscmp(Item1, Item2);
return 0;
}
BOOL
CreateListView(HWND hwnd)
{
hListView = CreateWindowExW(WS_EX_CLIENTEDGE,
WC_LISTVIEWW,
L"",
WS_CHILD | WS_VISIBLE | LVS_SORTASCENDING | LVS_REPORT | LVS_SINGLESEL | LVS_SHOWSELALWAYS,
205, 28, 465, 250,
hwnd,
GetSubMenu(LoadMenuW(hInst, MAKEINTRESOURCEW(IDR_APPLICATIONMENU)), 0),
hInst,
NULL);
if (!hListView)
{
/* TODO: Show error message */
return FALSE;
}
(VOID) ListView_SetExtendedListViewStyle(hListView, LVS_EX_FULLROWSELECT);
return TRUE;
}

View file

@ -1,723 +0,0 @@
/* PROJECT: ReactOS Applications Manager
* LICENSE: GPL - See COPYING in the top level directory
* FILE: base/applications/rapps/loaddlg.c
* PURPOSE: Displaying a download dialog
* COPYRIGHT: Copyright 2001 John R. Sheets (for CodeWeavers)
* Copyright 2004 Mike McCormack (for CodeWeavers)
* Copyright 2005 Ge van Geldorp (gvg@reactos.org)
* Copyright 2009 Dmitry Chapyshev (dmitry@reactos.org)
* Copyright 2015 Ismael Ferreras Morezuelas (swyterzone+ros@gmail.com)
*/
/*
* Based on Wine dlls/shdocvw/shdocvw_main.c
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "rapps.h"
#include <wininet.h>
#include <shellapi.h>
#include <windowsx.h>
static PAPPLICATION_INFO AppInfo;
typedef struct _IBindStatusCallbackImpl
{
const IBindStatusCallbackVtbl *vtbl;
LONG ref;
HWND hDialog;
BOOL *pbCancelled;
BOOL UrlHasBeenCopied;
WCHAR ProgressText[MAX_PATH];
} IBindStatusCallbackImpl;
static
HRESULT WINAPI
dlQueryInterface(IBindStatusCallback* This, REFIID riid, void** ppvObject)
{
if (!ppvObject) return E_POINTER;
if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IBindStatusCallback))
{
IBindStatusCallback_AddRef(This);
*ppvObject = This;
return S_OK;
}
return E_NOINTERFACE;
}
static
ULONG WINAPI
dlAddRef(IBindStatusCallback* iface)
{
IBindStatusCallbackImpl *This = (IBindStatusCallbackImpl*) iface;
return InterlockedIncrement(&This->ref);
}
static
ULONG WINAPI
dlRelease(IBindStatusCallback* iface)
{
IBindStatusCallbackImpl *This = (IBindStatusCallbackImpl*) iface;
DWORD ref = InterlockedDecrement(&This->ref);
if (!ref)
{
DestroyWindow(This->hDialog);
HeapFree(GetProcessHeap(), 0, This);
}
return ref;
}
static
HRESULT WINAPI
dlOnStartBinding(IBindStatusCallback* iface, DWORD dwReserved, IBinding* pib)
{
return S_OK;
}
static
HRESULT WINAPI
dlGetPriority(IBindStatusCallback* iface, LONG* pnPriority)
{
return S_OK;
}
static
HRESULT WINAPI
dlOnLowResource( IBindStatusCallback* iface, DWORD reserved)
{
return S_OK;
}
static
HRESULT WINAPI
dlOnProgress(IBindStatusCallback* iface,
ULONG ulProgress,
ULONG ulProgressMax,
ULONG ulStatusCode,
LPCWSTR szStatusText)
{
IBindStatusCallbackImpl *This = (IBindStatusCallbackImpl *) iface;
HWND Item;
LONG r;
Item = GetDlgItem(This->hDialog, IDC_DOWNLOAD_PROGRESS);
if (Item && ulProgressMax)
{
WCHAR szProgress[100];
WCHAR szProgressMax[100];
UINT uiPercentage = ((ULONGLONG)ulProgress * 100) / ulProgressMax;
/* send the current progress to the progress bar */
SendMessageW(Item, PBM_SETPOS, uiPercentage, 0);
/* format the bits and bytes into pretty and accessible units... */
StrFormatByteSizeW(ulProgress, szProgress, _countof(szProgress));
StrFormatByteSizeW(ulProgressMax, szProgressMax, _countof(szProgressMax));
/* ...and post all of it to our subclassed progress bar text subroutine */
StringCbPrintfW(This->ProgressText,
sizeof(This->ProgressText),
L"%u%% \x2014 %ls / %ls",
uiPercentage,
szProgress,
szProgressMax);
SendMessageW(Item, WM_SETTEXT, 0, (LPARAM)This->ProgressText);
}
Item = GetDlgItem(This->hDialog, IDC_DOWNLOAD_STATUS);
if (Item && szStatusText && wcslen(szStatusText) > 0 && This->UrlHasBeenCopied == FALSE)
{
DWORD len = wcslen(szStatusText) + 1;
PWSTR buf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len * sizeof(WCHAR));
if (buf)
{
/* beautify our url for display purposes */
InternetCanonicalizeUrl(szStatusText, buf, &len, ICU_DECODE | ICU_NO_ENCODE);
}
else
{
/* just use the original */
buf = (PWSTR)szStatusText;
}
/* paste it into our dialog and don't do it again in this instance */
SendMessageW(Item, WM_SETTEXT, 0, (LPARAM)buf);
This->UrlHasBeenCopied = TRUE;
if (buf != szStatusText)
{
HeapFree(GetProcessHeap(), 0, buf);
}
}
SetLastError(0);
r = GetWindowLongPtrW(This->hDialog, GWLP_USERDATA);
if (0 != r || 0 != GetLastError())
{
*This->pbCancelled = TRUE;
return E_ABORT;
}
return S_OK;
}
static
HRESULT WINAPI
dlOnStopBinding(IBindStatusCallback* iface, HRESULT hresult, LPCWSTR szError)
{
return S_OK;
}
static
HRESULT WINAPI
dlGetBindInfo(IBindStatusCallback* iface, DWORD* grfBINDF, BINDINFO* pbindinfo)
{
return S_OK;
}
static
HRESULT WINAPI
dlOnDataAvailable(IBindStatusCallback* iface, DWORD grfBSCF,
DWORD dwSize, FORMATETC* pformatetc, STGMEDIUM* pstgmed)
{
return S_OK;
}
static
HRESULT WINAPI
dlOnObjectAvailable(IBindStatusCallback* iface, REFIID riid, IUnknown* punk)
{
return S_OK;
}
static const IBindStatusCallbackVtbl dlVtbl =
{
dlQueryInterface,
dlAddRef,
dlRelease,
dlOnStartBinding,
dlGetPriority,
dlOnLowResource,
dlOnProgress,
dlOnStopBinding,
dlGetBindInfo,
dlOnDataAvailable,
dlOnObjectAvailable
};
static IBindStatusCallback*
CreateDl(HWND Dlg, BOOL *pbCancelled)
{
IBindStatusCallbackImpl *This;
This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IBindStatusCallbackImpl));
if (!This)
return NULL;
This->vtbl = &dlVtbl;
This->ref = 1;
This->hDialog = Dlg;
This->pbCancelled = pbCancelled;
return (IBindStatusCallback*) This;
}
#ifdef USE_CERT_PINNING
static BOOL CertIsValid(HINTERNET hInternet, LPWSTR lpszHostName)
{
HINTERNET hConnect;
HINTERNET hRequest;
DWORD certInfoLength;
BOOL Ret = FALSE;
INTERNET_CERTIFICATE_INFOW certInfo;
hConnect = InternetConnectW(hInternet, lpszHostName, INTERNET_DEFAULT_HTTPS_PORT, NULL, NULL, INTERNET_SERVICE_HTTP, INTERNET_FLAG_SECURE, 0);
if (hConnect)
{
hRequest = HttpOpenRequestW(hConnect, L"HEAD", NULL, NULL, NULL, NULL, INTERNET_FLAG_SECURE, 0);
if (hRequest != NULL)
{
Ret = HttpSendRequestW(hRequest, L"", 0, NULL, 0);
if (Ret)
{
certInfoLength = sizeof(certInfo);
Ret = InternetQueryOptionW(hRequest,
INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT,
&certInfo,
&certInfoLength);
if (Ret)
{
if (certInfo.lpszEncryptionAlgName)
LocalFree(certInfo.lpszEncryptionAlgName);
if (certInfo.lpszIssuerInfo)
{
if (strcmp((LPSTR)certInfo.lpszIssuerInfo, CERT_ISSUER_INFO) != 0)
Ret = FALSE;
LocalFree(certInfo.lpszIssuerInfo);
}
if (certInfo.lpszProtocolName)
LocalFree(certInfo.lpszProtocolName);
if (certInfo.lpszSignatureAlgName)
LocalFree(certInfo.lpszSignatureAlgName);
if (certInfo.lpszSubjectInfo)
{
if (strcmp((LPSTR)certInfo.lpszSubjectInfo, CERT_SUBJECT_INFO) != 0)
Ret = FALSE;
LocalFree(certInfo.lpszSubjectInfo);
}
}
}
InternetCloseHandle(hRequest);
}
InternetCloseHandle(hConnect);
}
return Ret;
}
#endif
static
DWORD WINAPI
ThreadFunc(LPVOID Context)
{
IBindStatusCallback *dl = NULL;
WCHAR path[MAX_PATH];
PWSTR p, q;
HWND Dlg = (HWND) Context;
DWORD dwContentLen, dwBytesWritten, dwBytesRead, dwStatus;
DWORD dwCurrentBytesRead = 0;
DWORD dwStatusLen = sizeof(dwStatus);
BOOL bCancelled = FALSE;
BOOL bTempfile = FALSE;
BOOL bCab = FALSE;
HINTERNET hOpen = NULL;
HINTERNET hFile = NULL;
HANDLE hOut = INVALID_HANDLE_VALUE;
unsigned char lpBuffer[4096];
const LPWSTR lpszAgent = L"RApps/1.0";
URL_COMPONENTS urlComponents;
size_t urlLength, filenameLength;
/* build the path for the download */
p = wcsrchr(AppInfo->szUrlDownload, L'/');
q = wcsrchr(AppInfo->szUrlDownload, L'?');
/* do we have a final slash separator? */
if (!p)
goto end;
/* prepare the tentative length of the filename, maybe we've to remove part of it later on */
filenameLength = wcslen(p) * sizeof(WCHAR);
/* do we have query arguments in the target URL after the filename? account for them
(e.g. https://example.org/myfile.exe?no_adware_plz) */
if (q && q > p && (q - p) > 0)
filenameLength -= wcslen(q - 1) * sizeof(WCHAR);
/* is this URL an update package for RAPPS? if so store it in a different place */
if (wcscmp(AppInfo->szUrlDownload, APPLICATION_DATABASE_URL) == 0)
{
bCab = TRUE;
if (!GetStorageDirectory(path, _countof(path)))
goto end;
}
else
{
if (FAILED(StringCbCopyW(path, sizeof(path), SettingsInfo.szDownloadDir)))
goto end;
}
/* is the path valid? can we access it? */
if (GetFileAttributesW(path) == INVALID_FILE_ATTRIBUTES)
{
if (!CreateDirectoryW(path, NULL))
goto end;
}
/* append a \ to the provided file system path, and the filename portion from the URL after that */
if (FAILED(StringCbCatW(path, sizeof(path), L"\\")))
goto end;
if (FAILED(StringCbCatNW(path, sizeof(path), p + 1, filenameLength)))
goto end;
/* is the file already there? let's avoid having to download it */
if (!bCab && AppInfo->szSHA1[0] != 0 && GetFileAttributesW(path) != INVALID_FILE_ATTRIBUTES)
{
/* only open it in case of total correctness */
if (VerifyInteg(AppInfo->szSHA1, path))
goto run;
}
/* create an async download context for it */
bTempfile = TRUE;
dl = CreateDl(Context, &bCancelled);
if (dl == NULL)
goto end;
/* FIXME: this should just be using the system-wide proxy settings */
switch(SettingsInfo.Proxy)
{
case 0: /* preconfig */
hOpen = InternetOpenW(lpszAgent, INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
break;
case 1: /* direct (no proxy) */
hOpen = InternetOpenW(lpszAgent, INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
break;
case 2: /* use proxy */
hOpen = InternetOpenW(lpszAgent, INTERNET_OPEN_TYPE_PROXY, SettingsInfo.szProxyServer, SettingsInfo.szNoProxyFor, 0);
break;
default: /* preconfig */
hOpen = InternetOpenW(lpszAgent, INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
break;
}
if (!hOpen)
goto end;
hFile = InternetOpenUrlW(hOpen, AppInfo->szUrlDownload, NULL, 0, INTERNET_FLAG_PRAGMA_NOCACHE | INTERNET_FLAG_KEEP_CONNECTION, 0);
if (!hFile)
goto end;
if (!HttpQueryInfoW(hFile, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &dwStatus, &dwStatusLen, NULL))
goto end;
if(dwStatus != HTTP_STATUS_OK)
{
WCHAR szMsgText[MAX_STR_LEN];
if (!LoadStringW(hInst, IDS_UNABLE_TO_DOWNLOAD, szMsgText, _countof(szMsgText)))
goto end;
MessageBoxW(hMainWnd, szMsgText, NULL, MB_OK | MB_ICONERROR);
goto end;
}
dwStatusLen = sizeof(dwStatus);
memset(&urlComponents, 0, sizeof(urlComponents));
urlComponents.dwStructSize = sizeof(urlComponents);
if(FAILED(StringCbLengthW(AppInfo->szUrlDownload, sizeof(AppInfo->szUrlDownload), &urlLength)))
goto end;
urlLength /= sizeof(WCHAR);
urlComponents.dwSchemeLength = urlLength + 1;
urlComponents.lpszScheme = malloc(urlComponents.dwSchemeLength * sizeof(WCHAR));
urlComponents.dwHostNameLength = urlLength + 1;
urlComponents.lpszHostName = malloc(urlComponents.dwHostNameLength * sizeof(WCHAR));
if(!InternetCrackUrlW(AppInfo->szUrlDownload, urlLength+1, ICU_DECODE | ICU_ESCAPE, &urlComponents))
goto end;
if(urlComponents.nScheme == INTERNET_SCHEME_HTTP || urlComponents.nScheme == INTERNET_SCHEME_HTTPS)
HttpQueryInfo(hFile, HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER, &dwContentLen, &dwStatus, 0);
if(urlComponents.nScheme == INTERNET_SCHEME_FTP)
dwContentLen = FtpGetFileSize(hFile, &dwStatus);
#ifdef USE_CERT_PINNING
/* are we using HTTPS to download the RAPPS update package? check if the certificate is original */
if ((urlComponents.nScheme == INTERNET_SCHEME_HTTPS) &&
(wcscmp(AppInfo->szUrlDownload, APPLICATION_DATABASE_URL) == 0) &&
(!CertIsValid(hOpen, urlComponents.lpszHostName)))
{
WCHAR szMsgText[MAX_STR_LEN];
if (!LoadStringW(hInst, IDS_CERT_DOES_NOT_MATCH, szMsgText, _countof(szMsgText)))
goto end;
MessageBoxW(Dlg, szMsgText, NULL, MB_OK | MB_ICONERROR);
goto end;
}
#endif
free(urlComponents.lpszScheme);
free(urlComponents.lpszHostName);
hOut = CreateFileW(path, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, NULL);
if (hOut == INVALID_HANDLE_VALUE)
goto end;
do
{
if (!InternetReadFile(hFile, lpBuffer, _countof(lpBuffer), &dwBytesRead))
{
WCHAR szMsgText[MAX_STR_LEN];
if (!LoadStringW(hInst, IDS_INTERRUPTED_DOWNLOAD, szMsgText, _countof(szMsgText)))
goto end;
MessageBoxW(hMainWnd, szMsgText, NULL, MB_OK | MB_ICONERROR);
goto end;
}
if (!WriteFile(hOut, &lpBuffer[0], dwBytesRead, &dwBytesWritten, NULL))
{
WCHAR szMsgText[MAX_STR_LEN];
if (!LoadStringW(hInst, IDS_UNABLE_TO_WRITE, szMsgText, _countof(szMsgText)))
goto end;
MessageBoxW(hMainWnd, szMsgText, NULL, MB_OK | MB_ICONERROR);
goto end;
}
dwCurrentBytesRead += dwBytesRead;
IBindStatusCallback_OnProgress(dl, dwCurrentBytesRead, dwContentLen, 0, AppInfo->szUrlDownload);
}
while (dwBytesRead && !bCancelled);
CloseHandle(hOut);
hOut = INVALID_HANDLE_VALUE;
if (bCancelled)
goto end;
/* if this thing isn't a RAPPS update and it has a SHA-1 checksum
verify its integrity by using the native advapi32.A_SHA1 functions */
if (!bCab && AppInfo->szSHA1[0] != 0)
{
WCHAR szMsgText[MAX_STR_LEN];
/* change a few strings in the download dialog to reflect the verification process */
LoadStringW(hInst, IDS_INTEG_CHECK_TITLE, szMsgText, _countof(szMsgText));
SetWindowText(Dlg, szMsgText);
SendMessageW(GetDlgItem(Dlg, IDC_DOWNLOAD_STATUS), WM_SETTEXT, 0, (LPARAM)path);
/* this may take a while, depending on the file size */
if (!VerifyInteg(AppInfo->szSHA1, path))
{
if (!LoadStringW(hInst, IDS_INTEG_CHECK_FAIL, szMsgText, _countof(szMsgText)))
goto end;
MessageBoxW(Dlg, szMsgText, NULL, MB_OK | MB_ICONERROR);
goto end;
}
}
ShowWindow(Dlg, SW_HIDE);
run:
/* run it */
if (!bCab)
ShellExecuteW( NULL, L"open", path, NULL, NULL, SW_SHOWNORMAL );
end:
if (hOut != INVALID_HANDLE_VALUE)
CloseHandle(hOut);
InternetCloseHandle(hFile);
InternetCloseHandle(hOpen);
if (dl)
IBindStatusCallback_Release(dl);
if (bTempfile)
{
if (bCancelled || (SettingsInfo.bDelInstaller && !bCab))
DeleteFileW(path);
}
EndDialog(Dlg, 0);
return 0;
}
LRESULT CALLBACK
DownloadProgressProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
{
static WCHAR szProgressText[MAX_STR_LEN] = {0};
switch (uMsg)
{
case WM_SETTEXT:
{
if (lParam)
{
StringCbCopyW(szProgressText,
sizeof(szProgressText),
(PCWSTR)lParam);
}
return TRUE;
}
case WM_ERASEBKGND:
case WM_PAINT:
{
PAINTSTRUCT ps;
HDC hDC = BeginPaint(hWnd, &ps), hdcMem;
HBITMAP hbmMem;
HANDLE hOld;
RECT myRect;
UINT win_width, win_height;
GetClientRect(hWnd, &myRect);
/* grab the progress bar rect size */
win_width = myRect.right - myRect.left;
win_height = myRect.bottom - myRect.top;
/* create an off-screen DC for double-buffering */
hdcMem = CreateCompatibleDC(hDC);
hbmMem = CreateCompatibleBitmap(hDC, win_width, win_height);
hOld = SelectObject(hdcMem, hbmMem);
/* call the original draw code and redirect it to our memory buffer */
DefSubclassProc(hWnd, uMsg, (WPARAM)hdcMem, lParam);
/* draw our nifty progress text over it */
SelectFont(hdcMem, GetStockFont(DEFAULT_GUI_FONT));
DrawShadowText(hdcMem, szProgressText, wcslen(szProgressText),
&myRect,
DT_CENTER | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE,
GetSysColor(COLOR_CAPTIONTEXT),
GetSysColor(COLOR_3DSHADOW),
1, 1);
/* transfer the off-screen DC to the screen */
BitBlt(hDC, 0, 0, win_width, win_height, hdcMem, 0, 0, SRCCOPY);
/* free the off-screen DC */
SelectObject(hdcMem, hOld);
DeleteObject(hbmMem);
DeleteDC(hdcMem);
EndPaint(hWnd, &ps);
return 0;
}
/* Raymond Chen says that we should safely unsubclass all the things!
(http://blogs.msdn.com/b/oldnewthing/archive/2003/11/11/55653.aspx) */
case WM_NCDESTROY:
{
ZeroMemory(szProgressText, sizeof(szProgressText));
RemoveWindowSubclass(hWnd, DownloadProgressProc, uIdSubclass);
}
/* Fall-through */
default:
return DefSubclassProc(hWnd, uMsg, wParam, lParam);
}
}
static
INT_PTR CALLBACK
DownloadDlgProc(HWND Dlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
HANDLE Thread;
DWORD ThreadId;
HWND Item;
switch (uMsg)
{
case WM_INITDIALOG:
{
HICON hIconSm = NULL, hIconBg = NULL;
hIconBg = (HICON)GetClassLongPtr(hMainWnd, GCLP_HICON);
hIconSm = (HICON)GetClassLongPtr(hMainWnd, GCLP_HICONSM);
if (hIconBg && hIconSm)
{
SendMessageW(Dlg, WM_SETICON, ICON_BIG, (LPARAM) hIconBg);
SendMessageW(Dlg, WM_SETICON, ICON_SMALL, (LPARAM) hIconSm);
}
SetWindowLongPtrW(Dlg, GWLP_USERDATA, 0);
Item = GetDlgItem(Dlg, IDC_DOWNLOAD_PROGRESS);
if (Item)
{
/* initialize the default values for our nifty progress bar
and subclass it so that it learns to print a status text */
SendMessageW(Item, PBM_SETRANGE, 0, MAKELPARAM(0, 100));
SendMessageW(Item, PBM_SETPOS, 0, 0);
SetWindowSubclass(Item, DownloadProgressProc, 0, 0);
}
/* add a neat placeholder until the download URL is retrieved */
Item = GetDlgItem(Dlg, IDC_DOWNLOAD_STATUS);
SendMessageW(Item, WM_SETTEXT, 0, (LPARAM)L"\x2022 \x2022 \x2022");
Thread = CreateThread(NULL, 0, ThreadFunc, Dlg, 0, &ThreadId);
if (!Thread)
return FALSE;
CloseHandle(Thread);
return TRUE;
}
case WM_COMMAND:
if (wParam == IDCANCEL)
{
SetWindowLongPtrW(Dlg, GWLP_USERDATA, 1);
PostMessageW(Dlg, WM_CLOSE, 0, 0);
}
return FALSE;
case WM_CLOSE:
EndDialog(Dlg, 0);
return TRUE;
default:
return FALSE;
}
}
BOOL
DownloadApplication(INT Index)
{
if (!IS_AVAILABLE_ENUM(SelectedEnumType))
return FALSE;
AppInfo = (PAPPLICATION_INFO) ListViewGetlParam(Index);
if (!AppInfo) return FALSE;
WriteLogMessage(EVENTLOG_SUCCESS, MSG_SUCCESS_INSTALL, AppInfo->szName);
DialogBoxW(hInst,
MAKEINTRESOURCEW(IDD_DOWNLOAD_DIALOG),
hMainWnd,
DownloadDlgProc);
return TRUE;
}
VOID
DownloadApplicationsDB(LPWSTR lpUrl)
{
APPLICATION_INFO IntInfo;
ZeroMemory(&IntInfo, sizeof(IntInfo));
if (FAILED(StringCbCopyW(IntInfo.szUrlDownload,
sizeof(IntInfo.szUrlDownload),
lpUrl)))
{
return;
}
AppInfo = &IntInfo;
DialogBoxW(hInst,
MAKEINTRESOURCEW(IDD_DOWNLOAD_DIALOG),
hMainWnd,
DownloadDlgProc);
}

View file

@ -1,557 +0,0 @@
/*
* PROJECT: ReactOS Applications Manager
* LICENSE: GPL - See COPYING in the top level directory
* FILE: base/applications/rapps/misc.c
* PURPOSE: Misc functions
* PROGRAMMERS: Dmitry Chapyshev (dmitry@reactos.org)
* Ismael Ferreras Morezuelas (swyterzone+ros@gmail.com)
*/
#include "rapps.h"
#include <sha1.h>
/* SESSION Operation */
#define EXTRACT_FILLFILELIST 0x00000001
#define EXTRACT_EXTRACTFILES 0x00000002
static HANDLE hLog = NULL;
WCHAR szCachedINISectionLocale[MAX_PATH] = L"Section.";
WCHAR szCachedINISectionLocaleNeutral[MAX_PATH] = {0};
BYTE bCachedSectionStatus = FALSE;
typedef struct
{
int erfOper;
int erfType;
BOOL fError;
} ERF, *PERF;
struct FILELIST
{
LPSTR FileName;
struct FILELIST *next;
BOOL DoExtract;
};
typedef struct
{
INT FileSize;
ERF Error;
struct FILELIST *FileList;
INT FileCount;
INT Operation;
CHAR Destination[MAX_PATH];
CHAR CurrentFile[MAX_PATH];
CHAR Reserved[MAX_PATH];
struct FILELIST *FilterList;
} SESSION;
HRESULT (WINAPI *pfnExtract)(SESSION *dest, LPCSTR szCabName);
INT
GetSystemColorDepth(VOID)
{
DEVMODE pDevMode;
INT ColorDepth;
pDevMode.dmSize = sizeof(pDevMode);
pDevMode.dmDriverExtra = 0;
if (!EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &pDevMode))
{
/* TODO: Error message */
return ILC_COLOR;
}
switch (pDevMode.dmBitsPerPel)
{
case 32: ColorDepth = ILC_COLOR32; break;
case 24: ColorDepth = ILC_COLOR24; break;
case 16: ColorDepth = ILC_COLOR16; break;
case 8: ColorDepth = ILC_COLOR8; break;
case 4: ColorDepth = ILC_COLOR4; break;
default: ColorDepth = ILC_COLOR; break;
}
return ColorDepth;
}
int
GetWindowWidth(HWND hwnd)
{
RECT Rect;
GetWindowRect(hwnd, &Rect);
return (Rect.right - Rect.left);
}
int
GetWindowHeight(HWND hwnd)
{
RECT Rect;
GetWindowRect(hwnd, &Rect);
return (Rect.bottom - Rect.top);
}
int
GetClientWindowWidth(HWND hwnd)
{
RECT Rect;
GetClientRect(hwnd, &Rect);
return (Rect.right - Rect.left);
}
int
GetClientWindowHeight(HWND hwnd)
{
RECT Rect;
GetClientRect(hwnd, &Rect);
return (Rect.bottom - Rect.top);
}
VOID
CopyTextToClipboard(LPCWSTR lpszText)
{
HRESULT hr;
if (OpenClipboard(NULL))
{
HGLOBAL ClipBuffer;
WCHAR *Buffer;
DWORD cchBuffer;
EmptyClipboard();
cchBuffer = wcslen(lpszText) + 1;
ClipBuffer = GlobalAlloc(GMEM_DDESHARE, cchBuffer * sizeof(WCHAR));
Buffer = GlobalLock(ClipBuffer);
hr = StringCchCopyW(Buffer, cchBuffer, lpszText);
GlobalUnlock(ClipBuffer);
if (SUCCEEDED(hr))
SetClipboardData(CF_UNICODETEXT, ClipBuffer);
CloseClipboard();
}
}
VOID
SetWelcomeText(VOID)
{
WCHAR szText[MAX_STR_LEN*3];
LoadStringW(hInst, IDS_WELCOME_TITLE, szText, _countof(szText));
NewRichEditText(szText, CFE_BOLD);
LoadStringW(hInst, IDS_WELCOME_TEXT, szText, _countof(szText));
InsertRichEditText(szText, 0);
LoadStringW(hInst, IDS_WELCOME_URL, szText, _countof(szText));
InsertRichEditText(szText, CFM_LINK);
}
VOID
ShowPopupMenu(HWND hwnd, UINT MenuID, UINT DefaultItem)
{
HMENU hMenu = NULL;
HMENU hPopupMenu;
MENUITEMINFO mii;
POINT pt;
if (MenuID)
{
hMenu = LoadMenuW(hInst, MAKEINTRESOURCEW(MenuID));
hPopupMenu = GetSubMenu(hMenu, 0);
}
else
hPopupMenu = GetMenu(hwnd);
ZeroMemory(&mii, sizeof(mii));
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_STATE;
GetMenuItemInfo(hPopupMenu, DefaultItem, FALSE, &mii);
if (!(mii.fState & MFS_GRAYED))
SetMenuDefaultItem(hPopupMenu, DefaultItem, FALSE);
GetCursorPos(&pt);
SetForegroundWindow(hwnd);
TrackPopupMenu(hPopupMenu, 0, pt.x, pt.y, 0, hMainWnd, NULL);
if (hMenu)
DestroyMenu(hMenu);
}
BOOL
StartProcess(LPWSTR lpPath, BOOL Wait)
{
PROCESS_INFORMATION pi;
STARTUPINFOW si;
DWORD dwRet;
MSG msg;
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
si.dwFlags = STARTF_USESHOWWINDOW;
si.wShowWindow = SW_SHOW;
if (!CreateProcessW(NULL, lpPath, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
{
return FALSE;
}
CloseHandle(pi.hThread);
if (Wait) EnableWindow(hMainWnd, FALSE);
while (Wait)
{
dwRet = MsgWaitForMultipleObjects(1, &pi.hProcess, FALSE, INFINITE, QS_ALLEVENTS);
if (dwRet == WAIT_OBJECT_0 + 1)
{
while (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
else
{
if (dwRet == WAIT_OBJECT_0 || dwRet == WAIT_FAILED)
break;
}
}
CloseHandle(pi.hProcess);
if (Wait)
{
EnableWindow(hMainWnd, TRUE);
SetForegroundWindow(hMainWnd);
SetFocus(hMainWnd);
}
return TRUE;
}
BOOL
GetStorageDirectory(PWCHAR lpDirectory, DWORD cch)
{
if (cch < MAX_PATH)
return FALSE;
if (!SHGetSpecialFolderPathW(NULL, lpDirectory, CSIDL_LOCAL_APPDATA, TRUE))
return FALSE;
if (FAILED(StringCchCatW(lpDirectory, cch, L"\\rapps")))
return FALSE;
if (!CreateDirectoryW(lpDirectory, NULL) &&
GetLastError() != ERROR_ALREADY_EXISTS)
{
return FALSE;
}
return TRUE;
}
BOOL
ExtractFilesFromCab(LPWSTR lpCabName, LPWSTR lpOutputPath)
{
HINSTANCE hCabinetDll;
CHAR szCabName[MAX_PATH];
SESSION Dest;
HRESULT Result;
hCabinetDll = LoadLibraryW(L"cabinet.dll");
if (hCabinetDll)
{
pfnExtract = (void *) GetProcAddress(hCabinetDll, "Extract");
if (pfnExtract)
{
ZeroMemory(&Dest, sizeof(Dest));
WideCharToMultiByte(CP_ACP, 0, lpOutputPath, -1, Dest.Destination, MAX_PATH, NULL, NULL);
WideCharToMultiByte(CP_ACP, 0, lpCabName, -1, szCabName, MAX_PATH, NULL, NULL);
Dest.Operation = EXTRACT_FILLFILELIST;
Result = pfnExtract(&Dest, szCabName);
if (Result == S_OK)
{
Dest.Operation = EXTRACT_EXTRACTFILES;
Result = pfnExtract(&Dest, szCabName);
if (Result == S_OK)
{
FreeLibrary(hCabinetDll);
return TRUE;
}
}
}
FreeLibrary(hCabinetDll);
}
return FALSE;
}
VOID
InitLogs(VOID)
{
WCHAR szBuf[MAX_PATH] = L"SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\ReactOS Application Manager";
WCHAR szPath[MAX_PATH];
DWORD dwCategoryNum = 1;
DWORD dwDisp, dwData;
HKEY hKey;
if (!SettingsInfo.bLogEnabled) return;
if (RegCreateKeyExW(HKEY_LOCAL_MACHINE,
szBuf, 0, NULL,
REG_OPTION_NON_VOLATILE,
KEY_WRITE, NULL, &hKey, &dwDisp) != ERROR_SUCCESS)
{
return;
}
if (!GetModuleFileNameW(NULL, szPath, _countof(szPath)))
return;
if (RegSetValueExW(hKey,
L"EventMessageFile",
0,
REG_EXPAND_SZ,
(LPBYTE)szPath,
(DWORD)(wcslen(szPath) + 1) * sizeof(WCHAR)) != ERROR_SUCCESS)
{
RegCloseKey(hKey);
return;
}
dwData = EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE |
EVENTLOG_INFORMATION_TYPE;
if (RegSetValueExW(hKey,
L"TypesSupported",
0,
REG_DWORD,
(LPBYTE)&dwData,
sizeof(DWORD)) != ERROR_SUCCESS)
{
RegCloseKey(hKey);
return;
}
if (RegSetValueExW(hKey,
L"CategoryMessageFile",
0,
REG_EXPAND_SZ,
(LPBYTE)szPath,
(DWORD)(wcslen(szPath) + 1) * sizeof(WCHAR)) != ERROR_SUCCESS)
{
RegCloseKey(hKey);
return;
}
if (RegSetValueExW(hKey,
L"CategoryCount",
0,
REG_DWORD,
(LPBYTE)&dwCategoryNum,
sizeof(DWORD)) != ERROR_SUCCESS)
{
RegCloseKey(hKey);
return;
}
RegCloseKey(hKey);
hLog = RegisterEventSourceW(NULL, L"ReactOS Application Manager");
}
VOID
FreeLogs(VOID)
{
if (hLog) DeregisterEventSource(hLog);
}
BOOL
WriteLogMessage(WORD wType, DWORD dwEventID, LPWSTR lpMsg)
{
if (!SettingsInfo.bLogEnabled) return TRUE;
if (!ReportEventW(hLog,
wType,
0,
dwEventID,
NULL,
1,
0,
(LPCWSTR*)&lpMsg,
NULL))
{
return FALSE;
}
return TRUE;
}
LPWSTR GetINIFullPath(LPCWSTR lpFileName)
{
WCHAR szDir[MAX_PATH];
static WCHAR szBuffer[MAX_PATH];
GetStorageDirectory(szDir, _countof(szDir));
StringCbPrintfW(szBuffer, sizeof(szBuffer), L"%ls\\rapps\\%ls", szDir, lpFileName);
return szBuffer;
}
UINT ParserGetString(LPCWSTR lpKeyName, LPWSTR lpReturnedString, UINT nSize, LPCWSTR lpFileName)
{
PWSTR lpFullFileName = GetINIFullPath(lpFileName);
DWORD dwResult;
/* we don't have cached section strings for the current system language, create them */
if(bCachedSectionStatus == FALSE)
{
WCHAR szLocale[4 + 1];
DWORD len;
/* find out what is the current system lang code (e.g. "0a") and append it to SectionLocale */
GetLocaleInfoW(GetUserDefaultLCID(), LOCALE_ILANGUAGE,
szLocale, _countof(szLocale));
StringCbCatW(szCachedINISectionLocale, sizeof(szCachedINISectionLocale), szLocale);
/* copy the locale-dependent string into the buffer of the future neutral one */
StringCbCopyW(szCachedINISectionLocaleNeutral,
sizeof(szCachedINISectionLocaleNeutral),
szCachedINISectionLocale);
/* turn "Section.0c0a" into "Section.0a", keeping just the neutral lang part */
len = wcslen(szCachedINISectionLocale);
memmove((szCachedINISectionLocaleNeutral + len) - 4,
(szCachedINISectionLocaleNeutral + len) - 2,
(2 * sizeof(WCHAR)) + sizeof(UNICODE_NULL));
/* finally, mark us as cache-friendly for the next time */
bCachedSectionStatus = TRUE;
}
/* 1st - find localized strings (e.g. "Section.0c0a") */
dwResult = GetPrivateProfileStringW(szCachedINISectionLocale,
lpKeyName,
NULL,
lpReturnedString,
nSize,
lpFullFileName);
if (dwResult != 0)
return TRUE;
/* 2nd - if they weren't present check for neutral sub-langs/ generic translations (e.g. "Section.0a") */
dwResult = GetPrivateProfileStringW(szCachedINISectionLocaleNeutral,
lpKeyName,
NULL,
lpReturnedString,
nSize,
lpFullFileName);
if (dwResult != 0)
return TRUE;
/* 3rd - if they weren't present fallback to standard english strings (just "Section") */
dwResult = GetPrivateProfileStringW(L"Section",
lpKeyName,
NULL,
lpReturnedString,
nSize,
lpFullFileName);
return (dwResult != 0 ? TRUE : FALSE);
}
UINT ParserGetInt(LPCWSTR lpKeyName, LPCWSTR lpFileName)
{
WCHAR Buffer[30];
UNICODE_STRING BufferW;
ULONG Result;
/* grab the text version of our entry */
if (!ParserGetString(lpKeyName, Buffer, _countof(Buffer), lpFileName))
return FALSE;
if (!Buffer[0])
return FALSE;
/* convert it to an actual integer */
RtlInitUnicodeString(&BufferW, Buffer);
RtlUnicodeStringToInteger(&BufferW, 0, &Result);
return Result;
}
BOOL VerifyInteg(LPCWSTR lpSHA1Hash, LPCWSTR lpFileName)
{
BOOL ret = FALSE;
const unsigned char *file_map;
HANDLE file, map;
ULONG sha[5];
WCHAR buf[40 + 1];
SHA_CTX ctx;
LARGE_INTEGER size;
UINT i;
/* first off, does it exist at all? */
file = CreateFileW(lpFileName, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);
if (file == INVALID_HANDLE_VALUE)
return FALSE;
/* let's grab the actual file size to organize the mmap'ing rounds */
GetFileSizeEx(file, &size);
/* retrieve a handle to map the file contents to memory */
map = CreateFileMappingW(file, NULL, PAGE_READONLY, 0, 0, NULL);
if (!map)
goto cleanup;
/* initialize the SHA-1 context */
A_SHAInit(&ctx);
/* map that thing in address space */
file_map = MapViewOfFile(map, FILE_MAP_READ, 0, 0, 0);
if (!file_map)
goto cleanup;
/* feed the data to the cookie monster */
A_SHAUpdate(&ctx, file_map, size.LowPart);
/* cool, we don't need this anymore */
UnmapViewOfFile(file_map);
/* we're done, compute the final hash */
A_SHAFinal(&ctx, sha);
for (i = 0; i < sizeof(sha); i++)
swprintf(buf + 2 * i, L"%02x", ((unsigned char *)sha)[i]);
/* does the resulting SHA1 match with the provided one? */
if (!_wcsicmp(buf, lpSHA1Hash))
ret = TRUE;
cleanup:
CloseHandle(map);
CloseHandle(file);
return ret;
}

View file

@ -1,136 +0,0 @@
/*
* PROJECT: ReactOS Applications Manager
* LICENSE: GPL - See COPYING in the top level directory
* FILE: base/applications/rapps/richedit.c
* PURPOSE: RichEdit functions
* PROGRAMMERS: Dmitry Chapyshev (dmitry@reactos.org)
*/
#include "rapps.h"
#include <shlwapi.h>
HWND hRichEdit;
PWSTR pLink = NULL;
VOID
RichEditOnLink(HWND hwnd, ENLINK *Link)
{
switch (Link->msg)
{
case WM_LBUTTONUP:
case WM_RBUTTONUP:
{
if (pLink) HeapFree(GetProcessHeap(), 0, pLink);
pLink = HeapAlloc(GetProcessHeap(),
0,
(max(Link->chrg.cpMin, Link->chrg.cpMax) -
min(Link->chrg.cpMin, Link->chrg.cpMax) + 1) * sizeof(WCHAR));
if (!pLink)
{
/* TODO: Error message */
return;
}
SendMessageW(hRichEdit, EM_SETSEL, Link->chrg.cpMin, Link->chrg.cpMax);
SendMessageW(hRichEdit, EM_GETSELTEXT, 0, (LPARAM)pLink);
ShowPopupMenu(hwnd, IDR_LINKMENU, -1);
}
break;
}
}
static VOID
SetRangeFormatting(LONG Start, LONG End, DWORD dwEffects)
{
CHARFORMAT2 CharFormat;
SendMessageW(hRichEdit, EM_SETSEL, Start, End);
ZeroMemory(&CharFormat, sizeof(CharFormat));
CharFormat.cbSize = sizeof(CharFormat);
CharFormat.dwMask = dwEffects;
CharFormat.dwEffects = dwEffects;
SendMessageW(hRichEdit, EM_SETCHARFORMAT, SCF_WORD | SCF_SELECTION, (LPARAM)&CharFormat);
SendMessageW(hRichEdit, EM_SETSEL, End, End + 1);
}
static LONG
GetRichEditTextLen(VOID)
{
GETTEXTLENGTHEX TxtLenStruct;
TxtLenStruct.flags = GTL_NUMCHARS;
TxtLenStruct.codepage = 1200;
return (LONG) SendMessageW(hRichEdit, EM_GETTEXTLENGTHEX, (WPARAM)&TxtLenStruct, 0);
}
/*
* Insert text (without cleaning old text)
* Supported effects:
* - CFM_BOLD
* - CFM_ITALIC
* - CFM_UNDERLINE
* - CFM_LINK
*/
VOID
InsertRichEditText(LPCWSTR lpszText, DWORD dwEffects)
{
SETTEXTEX SetText;
LONG Len = GetRichEditTextLen();
/* Insert new text */
SetText.flags = ST_SELECTION;
SetText.codepage = 1200;
SendMessageW(hRichEdit, EM_SETTEXTEX, (WPARAM)&SetText, (LPARAM)lpszText);
SetRangeFormatting(Len, Len + wcslen(lpszText),
(dwEffects == CFM_LINK) ? (PathIsURLW(lpszText) ? dwEffects : 0) : dwEffects);
}
/*
* Clear old text and add new
*/
VOID
NewRichEditText(LPCWSTR lpszText, DWORD dwEffects)
{
SetWindowTextW(hRichEdit, L"");
InsertRichEditText(lpszText, dwEffects);
}
BOOL
CreateRichEdit(HWND hwnd)
{
LoadLibraryW(L"riched20.dll");
hRichEdit = CreateWindowExW(0,
L"RichEdit20W",
NULL,
WS_CHILD | WS_VISIBLE | ES_MULTILINE |
ES_LEFT | ES_READONLY,
205, 28, 465, 100,
hwnd,
NULL,
hInst,
NULL);
if (!hRichEdit)
{
/* TODO: Show error message */
return FALSE;
}
SendMessageW(hRichEdit, EM_SETBKGNDCOLOR, 0, GetSysColor(COLOR_BTNFACE));
SendMessageW(hRichEdit, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0);
SendMessageW(hRichEdit, EM_SETEVENTMASK, 0, ENM_LINK | ENM_MOUSEEVENTS);
SendMessageW(hRichEdit, EM_SHOWSCROLLBAR, SB_VERT, TRUE);
return TRUE;
}

View file

@ -1,205 +0,0 @@
/*
* PROJECT: ReactOS Applications Manager
* LICENSE: GPL - See COPYING in the top level directory
* FILE: base/applications/rapps/settingsdlg.c
* PURPOSE: Settings Dialog
* PROGRAMMERS: Dmitry Chapyshev (dmitry@reactos.org)
*/
#include "rapps.h"
SETTINGS_INFO NewSettingsInfo;
#define IS_CHECKED(a, b) \
a = (SendDlgItemMessage(hDlg, b, BM_GETCHECK, 0, 0) == BST_CHECKED) ? TRUE : FALSE
BOOL
ChooseFolder(HWND hwnd)
{
BOOL bRet = FALSE;
BROWSEINFO bi;
WCHAR szPath[MAX_PATH], szBuf[MAX_STR_LEN];
LoadStringW(hInst, IDS_CHOOSE_FOLDER_TEXT, szBuf, _countof(szBuf));
ZeroMemory(&bi, sizeof(bi));
bi.hwndOwner = hwnd;
bi.pidlRoot = NULL;
bi.lpszTitle = szBuf;
bi.ulFlags = BIF_USENEWUI | BIF_DONTGOBELOWDOMAIN | BIF_RETURNONLYFSDIRS | /* BIF_BROWSEFILEJUNCTIONS | */ BIF_VALIDATE;
if (SUCCEEDED(CoInitializeEx(NULL, COINIT_APARTMENTTHREADED)))
{
LPITEMIDLIST lpItemList = SHBrowseForFolder(&bi);
if (lpItemList && SHGetPathFromIDList(lpItemList, szPath))
{
if (szPath[0] != 0)
{
SetDlgItemTextW(hwnd, IDC_DOWNLOAD_DIR_EDIT, szPath);
bRet = TRUE;
}
}
CoTaskMemFree(lpItemList);
CoUninitialize();
}
return bRet;
}
static VOID
InitSettingsControls(HWND hDlg, PSETTINGS_INFO Info)
{
SendDlgItemMessage(hDlg, IDC_SAVE_WINDOW_POS, BM_SETCHECK, Info->bSaveWndPos, 0);
SendDlgItemMessage(hDlg, IDC_UPDATE_AVLIST, BM_SETCHECK, Info->bUpdateAtStart, 0);
SendDlgItemMessage(hDlg, IDC_LOG_ENABLED, BM_SETCHECK, Info->bLogEnabled, 0);
SendDlgItemMessage(hDlg, IDC_DEL_AFTER_INSTALL, BM_SETCHECK, Info->bDelInstaller, 0);
SetWindowTextW(GetDlgItem(hDlg, IDC_DOWNLOAD_DIR_EDIT),
Info->szDownloadDir);
CheckRadioButton(hDlg, IDC_PROXY_DEFAULT, IDC_USE_PROXY, IDC_PROXY_DEFAULT+Info->Proxy);
if(IDC_PROXY_DEFAULT + Info->Proxy == IDC_USE_PROXY)
{
EnableWindow(GetDlgItem(hDlg, IDC_PROXY_SERVER), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_NO_PROXY_FOR), TRUE);
}
SetWindowTextW(GetDlgItem(hDlg, IDC_PROXY_SERVER), Info->szProxyServer);
SetWindowTextW(GetDlgItem(hDlg, IDC_NO_PROXY_FOR), Info->szNoProxyFor);
}
static
INT_PTR CALLBACK
SettingsDlgProc(HWND hDlg, UINT Msg, WPARAM wParam, LPARAM lParam)
{
switch (Msg)
{
case WM_INITDIALOG:
{
NewSettingsInfo = SettingsInfo;
InitSettingsControls(hDlg, &SettingsInfo);
}
break;
case WM_COMMAND:
{
switch (LOWORD(wParam))
{
case IDC_CHOOSE:
ChooseFolder(hDlg);
break;
case IDC_SAVE_WINDOW_POS:
IS_CHECKED(NewSettingsInfo.bSaveWndPos, IDC_SAVE_WINDOW_POS);
break;
case IDC_UPDATE_AVLIST:
IS_CHECKED(NewSettingsInfo.bUpdateAtStart, IDC_UPDATE_AVLIST);
break;
case IDC_LOG_ENABLED:
IS_CHECKED(NewSettingsInfo.bLogEnabled, IDC_LOG_ENABLED);
break;
case IDC_DEL_AFTER_INSTALL:
IS_CHECKED(NewSettingsInfo.bDelInstaller, IDC_DEL_AFTER_INSTALL);
break;
case IDC_PROXY_DEFAULT:
NewSettingsInfo.Proxy = 0;
EnableWindow(GetDlgItem(hDlg, IDC_PROXY_SERVER), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_NO_PROXY_FOR), FALSE);
break;
case IDC_NO_PROXY:
NewSettingsInfo.Proxy = 1;
EnableWindow(GetDlgItem(hDlg, IDC_PROXY_SERVER), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_NO_PROXY_FOR), FALSE);
break;
case IDC_USE_PROXY:
NewSettingsInfo.Proxy = 2;
EnableWindow(GetDlgItem(hDlg, IDC_PROXY_SERVER), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_NO_PROXY_FOR), TRUE);
break;
case IDC_DEFAULT_SETTINGS:
FillDefaultSettings(&NewSettingsInfo);
InitSettingsControls(hDlg, &NewSettingsInfo);
break;
case IDOK:
{
WCHAR szDir[MAX_PATH];
WCHAR szProxy[MAX_PATH];
WCHAR szNoProxy[MAX_PATH];
DWORD dwAttr;
GetWindowTextW(GetDlgItem(hDlg, IDC_DOWNLOAD_DIR_EDIT),
szDir, MAX_PATH);
GetWindowTextW(GetDlgItem(hDlg, IDC_PROXY_SERVER),
szProxy, MAX_PATH);
StringCbCopyW(NewSettingsInfo.szProxyServer, sizeof(NewSettingsInfo.szProxyServer), szProxy);
GetWindowTextW(GetDlgItem(hDlg, IDC_NO_PROXY_FOR),
szNoProxy, MAX_PATH);
StringCbCopyW(NewSettingsInfo.szNoProxyFor, sizeof(NewSettingsInfo.szNoProxyFor), szNoProxy);
dwAttr = GetFileAttributesW(szDir);
if (dwAttr != INVALID_FILE_ATTRIBUTES &&
(dwAttr & FILE_ATTRIBUTE_DIRECTORY))
{
StringCbCopyW(NewSettingsInfo.szDownloadDir,
sizeof(NewSettingsInfo.szDownloadDir),
szDir);
}
else
{
WCHAR szMsgText[MAX_STR_LEN];
LoadStringW(hInst,
IDS_CHOOSE_FOLDER_ERROR,
szMsgText, _countof(szMsgText));
if (MessageBoxW(hDlg, szMsgText, NULL, MB_YESNO) == IDYES)
{
if (CreateDirectoryW(szDir, NULL))
{
EndDialog(hDlg, LOWORD(wParam));
}
}
else
{
SetFocus(GetDlgItem(hDlg, IDC_DOWNLOAD_DIR_EDIT));
break;
}
}
SettingsInfo = NewSettingsInfo;
SaveSettings(GetParent(hDlg));
EndDialog(hDlg, LOWORD(wParam));
}
break;
case IDCANCEL:
EndDialog(hDlg, LOWORD(wParam));
break;
}
}
break;
}
return FALSE;
}
VOID
CreateSettingsDlg(HWND hwnd)
{
DialogBoxW(hInst,
MAKEINTRESOURCEW(IDD_SETTINGS_DIALOG),
hwnd,
SettingsDlgProc);
}

View file

@ -1,302 +0,0 @@
/*
* PROJECT: ReactOS Applications Manager
* LICENSE: GPL - See COPYING in the top level directory
* FILE: base/applications/rapps/splitter.c
* PURPOSE: SplitterBar functions
* PROGRAMMERS: Dmitry Chapyshev (dmitry@reactos.org)
*/
#include "rapps.h"
HWND hVSplitter = NULL;
HWND hHSplitter = NULL;
static int HSplitterPos = 0;
int
GetHSplitterPos(VOID)
{
return HSplitterPos;
}
VOID
SetHSplitterPos(int Pos)
{
HSplitterPos = Pos;
}
/* Callback for horizontal splitter bar */
LRESULT CALLBACK
HSplitterWindowProc(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
switch (Msg)
{
case WM_CREATE:
{
SetHSplitterPos(GetWindowHeight(hListView));
}
break;
case WM_LBUTTONDOWN:
{
SetCapture(hwnd);
}
break;
case WM_LBUTTONUP:
case WM_RBUTTONDOWN:
if (GetCapture() == hwnd)
{
ReleaseCapture();
}
break;
case WM_MOUSEMOVE:
if (GetCapture() == hwnd)
{
int Width = GetClientWindowWidth(hMainWnd) - GetWindowWidth(hTreeView) - SPLIT_WIDTH;
int NewPos;
HDWP hdwp;
POINT Point;
GetCursorPos(&Point);
ScreenToClient(hMainWnd, &Point);
NewPos = Point.y;
if ((GetClientWindowHeight(hMainWnd) - GetWindowHeight(hStatusBar) - SPLIT_WIDTH) < NewPos)
break;
if ((GetWindowHeight(hToolBar) + SPLIT_WIDTH) > NewPos)
break;
SetHSplitterPos(NewPos);
hdwp = BeginDeferWindowPos(3);
/* Size HSplitBar */
if (hdwp)
hdwp = DeferWindowPos(hdwp,
hHSplitter,
0,
GetWindowWidth(hTreeView) + SPLIT_WIDTH,
Point.y,
Width,
SPLIT_WIDTH,
SWP_NOZORDER|SWP_NOACTIVATE);
/* Size ListView */
if (hdwp)
hdwp = DeferWindowPos(hdwp,
hListView,
0,
GetWindowWidth(hTreeView) + SPLIT_WIDTH,
GetWindowHeight(hToolBar),
Width,
Point.y - GetWindowHeight(hToolBar),
SWP_NOZORDER|SWP_NOACTIVATE);
/* Size RichEdit */
if (hdwp)
hdwp = DeferWindowPos(hdwp,
hRichEdit,
0,
GetWindowWidth(hTreeView) + SPLIT_WIDTH,
Point.y + SPLIT_WIDTH,
Width,
GetClientWindowHeight(hMainWnd) - (Point.y + SPLIT_WIDTH + GetWindowHeight(hStatusBar)),
SWP_NOZORDER|SWP_NOACTIVATE);
if (hdwp)
EndDeferWindowPos(hdwp);
}
break;
}
return DefWindowProc(hwnd, Msg, wParam, lParam);
}
/* Create horizontal splitter bar */
BOOL
CreateHSplitBar(HWND hwnd)
{
WCHAR szWindowClass[] = L"HSplitterWindowClass";
WNDCLASSEXW WndClass = {0};
WndClass.cbSize = sizeof(WndClass);
WndClass.lpszClassName = szWindowClass;
WndClass.lpfnWndProc = HSplitterWindowProc;
WndClass.hInstance = hInst;
WndClass.style = CS_HREDRAW | CS_VREDRAW;
WndClass.hCursor = LoadCursor(0, IDC_SIZENS);
WndClass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
if (RegisterClassExW(&WndClass) == (ATOM) 0)
{
/* TODO: Show error message */
return FALSE;
}
hHSplitter = CreateWindowExW(WS_EX_TRANSPARENT,
szWindowClass,
NULL,
WS_CHILD | WS_VISIBLE,
205, 180, 465, SPLIT_WIDTH,
hwnd,
NULL,
hInst,
NULL);
if (hHSplitter == NULL)
{
/* TODO: Show error message */
return FALSE;
}
ShowWindow(hHSplitter, SW_SHOW);
UpdateWindow(hHSplitter);
return TRUE;
}
/* Callback for vertical splitter bar */
LRESULT CALLBACK
VSplitterWindowProc(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
switch (Msg)
{
case WM_LBUTTONDOWN:
SetCapture(hwnd);
break;
case WM_LBUTTONUP:
case WM_RBUTTONDOWN:
if (GetCapture() == hwnd)
{
ReleaseCapture();
}
break;
case WM_MOUSEMOVE:
if (GetCapture() == hwnd)
{
HDWP hdwp;
POINT Point;
GetCursorPos(&Point);
ScreenToClient(hMainWnd, &Point);
if ((GetClientWindowWidth(hMainWnd) - SPLIT_WIDTH) < Point.x)
break;
if (SPLIT_WIDTH > Point.x)
break;
hdwp = BeginDeferWindowPos(5);
/* Size VSplitBar */
if (hdwp)
hdwp = DeferWindowPos(hdwp,
hwnd,
0,
Point.x,
GetWindowHeight(hToolBar),
SPLIT_WIDTH,
GetClientWindowHeight(hMainWnd) - GetWindowHeight(hToolBar) - GetWindowHeight(hStatusBar),
SWP_NOZORDER|SWP_NOACTIVATE);
/* Size TreeView */
if (hdwp)
hdwp = DeferWindowPos(hdwp,
hTreeView,
0,
0,
GetWindowHeight(hToolBar),
Point.x,
GetClientWindowHeight(hMainWnd) - GetWindowHeight(hToolBar) - GetWindowHeight(hStatusBar),
SWP_NOZORDER|SWP_NOACTIVATE);
/* Size ListView */
if (hdwp)
hdwp = DeferWindowPos(hdwp,
hListView,
0,
Point.x + SPLIT_WIDTH,
GetWindowHeight(hToolBar),
GetClientWindowWidth(hMainWnd) - (Point.x + SPLIT_WIDTH),
GetHSplitterPos() - GetWindowHeight(hToolBar),
SWP_NOZORDER|SWP_NOACTIVATE);
if (hdwp)
hdwp = DeferWindowPos(hdwp,
hRichEdit,
0,
Point.x + SPLIT_WIDTH,
GetHSplitterPos() + SPLIT_WIDTH,
GetClientWindowWidth(hMainWnd) - (Point.x + SPLIT_WIDTH),
GetClientWindowHeight(hMainWnd) - (GetHSplitterPos() + SPLIT_WIDTH + GetWindowHeight(hStatusBar)),
SWP_NOZORDER|SWP_NOACTIVATE);
if (hdwp)
hdwp = DeferWindowPos(hdwp,
hHSplitter,
0,
Point.x + SPLIT_WIDTH,
GetHSplitterPos(),
GetClientWindowWidth(hMainWnd) - (Point.x + SPLIT_WIDTH),
SPLIT_WIDTH,
SWP_NOZORDER|SWP_NOACTIVATE);
if (hdwp)
EndDeferWindowPos(hdwp);
}
break;
}
return DefWindowProc(hwnd, Msg, wParam, lParam);
}
/* Create vertical splitter bar */
BOOL
CreateVSplitBar(HWND hwnd)
{
WCHAR szWindowClass[] = L"VSplitterWindowClass";
WNDCLASSEXW WndClass = {0};
WndClass.cbSize = sizeof(WndClass);
WndClass.lpszClassName = szWindowClass;
WndClass.lpfnWndProc = VSplitterWindowProc;
WndClass.hInstance = hInst;
WndClass.style = CS_HREDRAW | CS_VREDRAW;
WndClass.hCursor = LoadCursor(0, IDC_SIZEWE);
WndClass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
if (RegisterClassExW(&WndClass) == (ATOM) 0)
{
/* TODO: Show error message */
return FALSE;
}
hVSplitter = CreateWindowExW(WS_EX_TRANSPARENT,
szWindowClass,
NULL,
WS_CHILD | WS_VISIBLE,
201, 28, SPLIT_WIDTH, 350,
hwnd,
NULL,
hInst,
NULL);
if (!hVSplitter)
{
/* TODO: Show error message */
return FALSE;
}
ShowWindow(hVSplitter, SW_SHOW);
UpdateWindow(hVSplitter);
return TRUE;
}

View file

@ -1,42 +0,0 @@
/*
* PROJECT: ReactOS Applications Manager
* LICENSE: GPL - See COPYING in the top level directory
* FILE: base/applications/rapps/statusbar.c
* PURPOSE: StatusBar functions
* PROGRAMMERS: Dmitry Chapyshev (dmitry@reactos.org)
*/
#include "rapps.h"
HWND hStatusBar;
BOOL
CreateStatusBar(HWND hwnd)
{
hStatusBar = CreateWindowExW(0,
STATUSCLASSNAMEW,
NULL,
WS_CHILD | WS_VISIBLE | SBARS_SIZEGRIP,
0, 0, 0, 0,
hwnd,
(HMENU)IDC_STATUSBAR,
hInst,
NULL);
if (!hStatusBar)
{
/* TODO: Show error message */
return FALSE;
}
return TRUE;
}
VOID
SetStatusBarText(LPCWSTR lpszText)
{
if (hStatusBar)
{
SendMessageW(hStatusBar, SB_SETTEXT, SBT_NOBORDERS, (LPARAM)lpszText);
}
}

View file

@ -1,195 +0,0 @@
/*
* PROJECT: ReactOS Applications Manager
* LICENSE: GPL - See COPYING in the top level directory
* FILE: base/applications/rapps/toolbar.c
* PURPOSE: ToolBar functions
* PROGRAMMERS: Dmitry Chapyshev (dmitry@reactos.org)
*/
#include "rapps.h"
#define TOOLBAR_HEIGHT 24
HWND hToolBar;
HWND hSearchBar;
static WCHAR szInstallBtn[MAX_STR_LEN];
static WCHAR szUninstallBtn[MAX_STR_LEN];
static WCHAR szModifyBtn[MAX_STR_LEN];
/* Toolbar buttons */
static const TBBUTTON Buttons[] =
{ /* iBitmap, idCommand, fsState, fsStyle, bReserved[2], dwData, iString */
{ 0, ID_INSTALL, TBSTATE_ENABLED, BTNS_BUTTON | BTNS_AUTOSIZE, {0}, 0, (INT_PTR)szInstallBtn},
{ 1, ID_UNINSTALL, TBSTATE_ENABLED, BTNS_BUTTON | BTNS_AUTOSIZE, {0}, 0, (INT_PTR)szUninstallBtn},
{ 2, ID_MODIFY, TBSTATE_ENABLED, BTNS_BUTTON | BTNS_AUTOSIZE, {0}, 0, (INT_PTR)szModifyBtn},
{ 5, 0, TBSTATE_ENABLED, BTNS_SEP, {0}, 0, 0},
{ 3, ID_REFRESH, TBSTATE_ENABLED, BTNS_BUTTON | BTNS_AUTOSIZE, {0}, 0, 0},
{ 4, ID_RESETDB, TBSTATE_ENABLED, BTNS_BUTTON | BTNS_AUTOSIZE, {0}, 0, 0},
{ 5, 0, TBSTATE_ENABLED, BTNS_SEP, {0}, 0, 0},
{ 5, ID_SETTINGS, TBSTATE_ENABLED, BTNS_BUTTON | BTNS_AUTOSIZE, {0}, 0, 0},
{ 6, ID_EXIT, TBSTATE_ENABLED, BTNS_BUTTON | BTNS_AUTOSIZE, {0}, 0, 0}
};
VOID
ToolBarOnGetDispInfo(LPTOOLTIPTEXT lpttt)
{
UINT idButton = (UINT)lpttt->hdr.idFrom;
switch (idButton)
{
case ID_EXIT:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_EXIT);
break;
case ID_INSTALL:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_INSTALL);
break;
case ID_UNINSTALL:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_UNINSTALL);
break;
case ID_MODIFY:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_MODIFY);
break;
case ID_SETTINGS:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_SETTINGS);
break;
case ID_REFRESH:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_REFRESH);
break;
case ID_RESETDB:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_UPDATE_DB);
break;
}
}
VOID
AddImageToImageList(HIMAGELIST hImageList, UINT ImageIndex)
{
HANDLE hImage;
if (!(hImage = LoadImage(hInst,
MAKEINTRESOURCE(ImageIndex),
IMAGE_ICON,
TOOLBAR_HEIGHT,
TOOLBAR_HEIGHT,
0)))
{
/* TODO: Error message */
}
ImageList_AddIcon(hImageList, hImage);
DeleteObject(hImage);
}
HIMAGELIST
InitImageList(VOID)
{
HIMAGELIST hImageList;
/* Create the toolbar icon image list */
hImageList = ImageList_Create(TOOLBAR_HEIGHT,//GetSystemMetrics(SM_CXSMICON),
TOOLBAR_HEIGHT,//GetSystemMetrics(SM_CYSMICON),
ILC_MASK | GetSystemColorDepth(),
1,
1);
if (!hImageList)
{
/* TODO: Error message */
return NULL;
}
AddImageToImageList(hImageList, IDI_INSTALL);
AddImageToImageList(hImageList, IDI_UNINSTALL);
AddImageToImageList(hImageList, IDI_MODIFY);
AddImageToImageList(hImageList, IDI_REFRESH);
AddImageToImageList(hImageList, IDI_UPDATE_DB);
AddImageToImageList(hImageList, IDI_SETTINGS);
AddImageToImageList(hImageList, IDI_EXIT);
return hImageList;
}
static
BOOL
CreateSearchBar(VOID)
{
WCHAR szBuf[MAX_STR_LEN];
hSearchBar = CreateWindowExW(WS_EX_CLIENTEDGE,
L"Edit",
NULL,
WS_CHILD | WS_VISIBLE | ES_LEFT | ES_AUTOHSCROLL,
0,
5,
200,
22,
hToolBar,
(HMENU)0,
hInst,
0);
SendMessageW(hSearchBar, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0);
LoadStringW(hInst, IDS_SEARCH_TEXT, szBuf, _countof(szBuf));
SetWindowTextW(hSearchBar, szBuf);
SetParent(hSearchBar, hToolBar);
return TRUE;
}
BOOL
CreateToolBar(HWND hwnd)
{
INT NumButtons = _countof(Buttons);
HIMAGELIST hImageList;
LoadStringW(hInst, IDS_INSTALL, szInstallBtn, _countof(szInstallBtn));
LoadStringW(hInst, IDS_UNINSTALL, szUninstallBtn, _countof(szUninstallBtn));
LoadStringW(hInst, IDS_MODIFY, szModifyBtn, _countof(szModifyBtn));
hToolBar = CreateWindowExW(0,
TOOLBARCLASSNAMEW,
NULL,
WS_CHILD | WS_VISIBLE | TBSTYLE_FLAT | TBSTYLE_TOOLTIPS | TBSTYLE_LIST,
0, 0, 0, 0,
hwnd,
0,
hInst,
NULL);
if (!hToolBar)
{
/* TODO: Show error message */
return FALSE;
}
SendMessageW(hToolBar, TB_SETEXTENDEDSTYLE, 0, TBSTYLE_EX_HIDECLIPPEDBUTTONS);
SendMessageW(hToolBar, TB_BUTTONSTRUCTSIZE, sizeof(Buttons[0]), 0);
hImageList = InitImageList();
if (!hImageList)
{
/* TODO: Show error message */
return FALSE;
}
ImageList_Destroy((HIMAGELIST)SendMessageW(hToolBar,
TB_SETIMAGELIST,
0,
(LPARAM)hImageList));
SendMessageW(hToolBar, TB_ADDBUTTONS, NumButtons, (LPARAM)Buttons);
CreateSearchBar();
return TRUE;
}

View file

@ -1,53 +0,0 @@
/*
* PROJECT: ReactOS Applications Manager
* LICENSE: GPL - See COPYING in the top level directory
* FILE: base/applications/rapps/treeview.c
* PURPOSE: TreeView functions
* PROGRAMMERS: Dmitry Chapyshev (dmitry@reactos.org)
*/
#include "rapps.h"
HWND hTreeView;
HTREEITEM
TreeViewAddItem(HTREEITEM hParent, LPWSTR lpText, INT Image, INT SelectedImage, LPARAM lParam)
{
TV_INSERTSTRUCTW Insert;
ZeroMemory(&Insert, sizeof(Insert));
Insert.item.mask = TVIF_TEXT | TVIF_PARAM | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
Insert.hInsertAfter = TVI_LAST;
Insert.hParent = hParent;
Insert.item.iSelectedImage = SelectedImage;
Insert.item.iImage = Image;
Insert.item.lParam = lParam;
Insert.item.pszText = lpText;
return TreeView_InsertItem(hTreeView, &Insert);
}
BOOL
CreateTreeView(HWND hwnd)
{
hTreeView = CreateWindowExW(WS_EX_CLIENTEDGE,
WC_TREEVIEWW,
L"",
WS_CHILD | WS_VISIBLE | TVS_HASLINES | TVS_SHOWSELALWAYS,
0, 28, 200, 350,
hwnd,
NULL,
hInst,
NULL);
if (!hListView)
{
/* TODO: Show error message */
return FALSE;
}
SetFocus(hTreeView);
return TRUE;
}

View file

@ -1,999 +0,0 @@
/*
* PROJECT: ReactOS Applications Manager
* LICENSE: GPL - See COPYING in the top level directory
* FILE: base/applications/rapps/winmain.c
* PURPOSE: Main program
* PROGRAMMERS: Dmitry Chapyshev (dmitry@reactos.org)
* Ismael Ferreras Morezuelas (swyterzone+ros@gmail.com)
*/
#include "rapps.h"
#include <shellapi.h>
#define SEARCH_TIMER_ID 'SR'
HWND hMainWnd;
HINSTANCE hInst;
HIMAGELIST hImageTreeView = NULL;
INT SelectedEnumType = ENUM_ALL_COMPONENTS;
SETTINGS_INFO SettingsInfo;
WCHAR szSearchPattern[MAX_STR_LEN] = L"";
BOOL SearchEnabled = TRUE;
BOOL
SearchPatternMatch(PCWSTR szHaystack, PCWSTR szNeedle)
{
if (!*szNeedle)
return TRUE;
/* TODO: Improve pattern search beyond a simple case-insensitive substring search. */
return StrStrIW(szHaystack, szNeedle) != NULL;
}
VOID
FillDefaultSettings(PSETTINGS_INFO pSettingsInfo)
{
pSettingsInfo->bSaveWndPos = TRUE;
pSettingsInfo->bUpdateAtStart = FALSE;
pSettingsInfo->bLogEnabled = TRUE;
StringCbCopyW(pSettingsInfo->szDownloadDir,
sizeof(pSettingsInfo->szDownloadDir),
L"C:\\Downloads");
pSettingsInfo->bDelInstaller = FALSE;
pSettingsInfo->Maximized = FALSE;
pSettingsInfo->Left = CW_USEDEFAULT;
pSettingsInfo->Top = CW_USEDEFAULT;
pSettingsInfo->Width = 680;
pSettingsInfo->Height = 450;
pSettingsInfo->Proxy = 0;
StringCbCopyW(pSettingsInfo->szProxyServer, sizeof(pSettingsInfo->szProxyServer), L"");
StringCbCopyW(pSettingsInfo->szNoProxyFor, sizeof(pSettingsInfo->szNoProxyFor), L"");
}
static BOOL
LoadSettings(VOID)
{
HKEY hKey;
DWORD dwSize;
if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\ReactOS\\rapps", 0, KEY_READ, &hKey) == ERROR_SUCCESS)
{
dwSize = sizeof(SettingsInfo);
if (RegQueryValueExW(hKey, L"Settings", NULL, NULL, (LPBYTE)&SettingsInfo, &dwSize) == ERROR_SUCCESS)
{
RegCloseKey(hKey);
return TRUE;
}
RegCloseKey(hKey);
}
return FALSE;
}
VOID
SaveSettings(HWND hwnd)
{
WINDOWPLACEMENT wp;
HKEY hKey;
if (SettingsInfo.bSaveWndPos)
{
wp.length = sizeof(wp);
GetWindowPlacement(hwnd, &wp);
SettingsInfo.Left = wp.rcNormalPosition.left;
SettingsInfo.Top = wp.rcNormalPosition.top;
SettingsInfo.Width = wp.rcNormalPosition.right - wp.rcNormalPosition.left;
SettingsInfo.Height = wp.rcNormalPosition.bottom - wp.rcNormalPosition.top;
SettingsInfo.Maximized = (wp.showCmd == SW_MAXIMIZE || (wp.showCmd == SW_SHOWMINIMIZED && (wp.flags & WPF_RESTORETOMAXIMIZED)));
}
if (RegCreateKeyExW(HKEY_CURRENT_USER, L"Software\\ReactOS\\rapps", 0, NULL,
REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, NULL) == ERROR_SUCCESS)
{
RegSetValueExW(hKey, L"Settings", 0, REG_BINARY, (LPBYTE)&SettingsInfo, sizeof(SettingsInfo));
RegCloseKey(hKey);
}
}
VOID
FreeInstalledAppList(VOID)
{
INT Count = ListView_GetItemCount(hListView) - 1;
PINSTALLED_INFO Info;
while (Count >= 0)
{
Info = ListViewGetlParam(Count);
if (Info)
{
RegCloseKey(Info->hSubKey);
HeapFree(GetProcessHeap(), 0, Info);
}
Count--;
}
}
BOOL
CALLBACK
EnumInstalledAppProc(INT ItemIndex, LPWSTR lpName, PINSTALLED_INFO Info)
{
PINSTALLED_INFO ItemInfo;
WCHAR szText[MAX_PATH];
INT Index;
if (!SearchPatternMatch(lpName, szSearchPattern))
{
RegCloseKey(Info->hSubKey);
return TRUE;
}
ItemInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(INSTALLED_INFO));
if (!ItemInfo)
{
RegCloseKey(Info->hSubKey);
return FALSE;
}
RtlCopyMemory(ItemInfo, Info, sizeof(INSTALLED_INFO));
Index = ListViewAddItem(ItemIndex, 0, lpName, (LPARAM)ItemInfo);
/* Get version info */
GetApplicationString(ItemInfo->hSubKey, L"DisplayVersion", szText);
ListView_SetItemText(hListView, Index, 1, szText);
/* Get comments */
GetApplicationString(ItemInfo->hSubKey, L"Comments", szText);
ListView_SetItemText(hListView, Index, 2, szText);
return TRUE;
}
BOOL
CALLBACK
EnumAvailableAppProc(PAPPLICATION_INFO Info)
{
INT Index;
if (!SearchPatternMatch(Info->szName, szSearchPattern) &&
!SearchPatternMatch(Info->szDesc, szSearchPattern))
{
return TRUE;
}
/* Only add a ListView entry if...
- no RegName was supplied (so we cannot determine whether the application is installed or not) or
- a RegName was supplied and the application is not installed
*/
if (!*Info->szRegName || (!IsInstalledApplication(Info->szRegName, FALSE) && !IsInstalledApplication(Info->szRegName, TRUE)))
{
Index = ListViewAddItem(Info->Category, 0, Info->szName, (LPARAM)Info);
ListView_SetItemText(hListView, Index, 1, Info->szVersion);
ListView_SetItemText(hListView, Index, 2, Info->szDesc);
}
return TRUE;
}
VOID
UpdateApplicationsList(INT EnumType)
{
WCHAR szBuffer1[MAX_STR_LEN], szBuffer2[MAX_STR_LEN];
HICON hIcon;
HIMAGELIST hImageListView;
SendMessage(hListView, WM_SETREDRAW, FALSE, 0);
if (EnumType == -1) EnumType = SelectedEnumType;
if (IS_INSTALLED_ENUM(SelectedEnumType))
FreeInstalledAppList();
(VOID) ListView_DeleteAllItems(hListView);
/* Create image list */
hImageListView = ImageList_Create(LISTVIEW_ICON_SIZE,
LISTVIEW_ICON_SIZE,
GetSystemColorDepth() | ILC_MASK,
0, 1);
hIcon = LoadImage(hInst,
MAKEINTRESOURCE(IDI_MAIN),
IMAGE_ICON,
LISTVIEW_ICON_SIZE,
LISTVIEW_ICON_SIZE,
LR_CREATEDIBSECTION);
ImageList_AddIcon(hImageListView, hIcon);
DestroyIcon(hIcon);
if (IS_INSTALLED_ENUM(EnumType))
{
/* Enum installed applications and updates */
EnumInstalledApplications(EnumType, TRUE, EnumInstalledAppProc);
EnumInstalledApplications(EnumType, FALSE, EnumInstalledAppProc);
}
else if (IS_AVAILABLE_ENUM(EnumType))
{
/* Enum available applications */
EnumAvailableApplications(EnumType, EnumAvailableAppProc);
}
/* Set image list for ListView */
hImageListView = ListView_SetImageList(hListView, hImageListView, LVSIL_SMALL);
/* Destroy old image list */
if (hImageListView)
ImageList_Destroy(hImageListView);
SelectedEnumType = EnumType;
LoadStringW(hInst, IDS_APPS_COUNT, szBuffer2, _countof(szBuffer2));
StringCbPrintfW(szBuffer1, sizeof(szBuffer1),
szBuffer2,
ListView_GetItemCount(hListView));
SetStatusBarText(szBuffer1);
SetWelcomeText();
/* set automatic column width for program names if the list is not empty */
if (ListView_GetItemCount(hListView) > 0)
ListView_SetColumnWidth(hListView, 0, LVSCW_AUTOSIZE);
SendMessage(hListView, WM_SETREDRAW, TRUE, 0);
}
VOID
InitApplicationsList(VOID)
{
WCHAR szText[MAX_STR_LEN];
/* Add columns to ListView */
LoadStringW(hInst, IDS_APP_NAME, szText, _countof(szText));
ListViewAddColumn(0, szText, 200, LVCFMT_LEFT);
LoadStringW(hInst, IDS_APP_INST_VERSION, szText, _countof(szText));
ListViewAddColumn(1, szText, 90, LVCFMT_RIGHT);
LoadStringW(hInst, IDS_APP_DESCRIPTION, szText, _countof(szText));
ListViewAddColumn(3, szText, 250, LVCFMT_LEFT);
UpdateApplicationsList(ENUM_ALL_COMPONENTS);
}
HTREEITEM
AddCategory(HTREEITEM hRootItem, UINT TextIndex, UINT IconIndex)
{
WCHAR szText[MAX_STR_LEN];
INT Index;
HICON hIcon;
hIcon = LoadImage(hInst,
MAKEINTRESOURCE(IconIndex),
IMAGE_ICON,
TREEVIEW_ICON_SIZE,
TREEVIEW_ICON_SIZE,
LR_CREATEDIBSECTION);
Index = ImageList_AddIcon(hImageTreeView, hIcon);
DestroyIcon(hIcon);
LoadStringW(hInst, TextIndex, szText, _countof(szText));
return TreeViewAddItem(hRootItem, szText, Index, Index, TextIndex);
}
VOID
InitCategoriesList(VOID)
{
HTREEITEM hRootItem1, hRootItem2;
/* Create image list */
hImageTreeView = ImageList_Create(TREEVIEW_ICON_SIZE,
TREEVIEW_ICON_SIZE,
GetSystemColorDepth() | ILC_MASK,
0, 1);
hRootItem1 = AddCategory(TVI_ROOT, IDS_INSTALLED, IDI_CATEGORY);
AddCategory(hRootItem1, IDS_APPLICATIONS, IDI_APPS);
AddCategory(hRootItem1, IDS_UPDATES, IDI_APPUPD);
hRootItem2 = AddCategory(TVI_ROOT, IDS_AVAILABLEFORINST, IDI_CATEGORY);
AddCategory(hRootItem2, IDS_CAT_AUDIO, IDI_CAT_AUDIO);
AddCategory(hRootItem2, IDS_CAT_VIDEO, IDI_CAT_VIDEO);
AddCategory(hRootItem2, IDS_CAT_GRAPHICS, IDI_CAT_GRAPHICS);
AddCategory(hRootItem2, IDS_CAT_GAMES, IDI_CAT_GAMES);
AddCategory(hRootItem2, IDS_CAT_INTERNET, IDI_CAT_INTERNET);
AddCategory(hRootItem2, IDS_CAT_OFFICE, IDI_CAT_OFFICE);
AddCategory(hRootItem2, IDS_CAT_DEVEL, IDI_CAT_DEVEL);
AddCategory(hRootItem2, IDS_CAT_EDU, IDI_CAT_EDU);
AddCategory(hRootItem2, IDS_CAT_ENGINEER, IDI_CAT_ENGINEER);
AddCategory(hRootItem2, IDS_CAT_FINANCE, IDI_CAT_FINANCE);
AddCategory(hRootItem2, IDS_CAT_SCIENCE, IDI_CAT_SCIENCE);
AddCategory(hRootItem2, IDS_CAT_TOOLS, IDI_CAT_TOOLS);
AddCategory(hRootItem2, IDS_CAT_DRIVERS, IDI_CAT_DRIVERS);
AddCategory(hRootItem2, IDS_CAT_LIBS, IDI_CAT_LIBS);
AddCategory(hRootItem2, IDS_CAT_OTHER, IDI_CAT_OTHER);
(VOID) TreeView_SetImageList(hTreeView, hImageTreeView, TVSIL_NORMAL);
(VOID) TreeView_Expand(hTreeView, hRootItem2, TVE_EXPAND);
(VOID) TreeView_Expand(hTreeView, hRootItem1, TVE_EXPAND);
(VOID) TreeView_SelectItem(hTreeView, hRootItem1);
}
BOOL
InitControls(HWND hwnd)
{
if (CreateStatusBar(hwnd) &&
CreateToolBar(hwnd) &&
CreateListView(hwnd) &&
CreateTreeView(hwnd) &&
CreateRichEdit(hwnd) &&
CreateVSplitBar(hwnd) &&
CreateHSplitBar(hwnd))
{
WCHAR szBuffer1[MAX_STR_LEN], szBuffer2[MAX_STR_LEN];
InitApplicationsList();
InitCategoriesList();
LoadStringW(hInst, IDS_APPS_COUNT, szBuffer2, _countof(szBuffer2));
StringCbPrintfW(szBuffer1, sizeof(szBuffer1),
szBuffer2,
ListView_GetItemCount(hListView));
SetStatusBarText(szBuffer1);
return TRUE;
}
return FALSE;
}
VOID CALLBACK
SearchTimerProc(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
{
KillTimer(hwnd, SEARCH_TIMER_ID);
UpdateApplicationsList(-1);
}
VOID
MainWndOnCommand(HWND hwnd, WPARAM wParam, LPARAM lParam)
{
WORD wCommand = LOWORD(wParam);
if (lParam == (LPARAM)hSearchBar)
{
WCHAR szBuf[MAX_STR_LEN];
switch (HIWORD(wParam))
{
case EN_SETFOCUS:
{
WCHAR szWndText[MAX_STR_LEN];
LoadStringW(hInst, IDS_SEARCH_TEXT, szBuf, _countof(szBuf));
GetWindowTextW(hSearchBar, szWndText, MAX_STR_LEN);
if (wcscmp(szBuf, szWndText) == 0)
{
SearchEnabled = FALSE;
SetWindowTextW(hSearchBar, L"");
}
}
break;
case EN_KILLFOCUS:
{
GetWindowTextW(hSearchBar, szBuf, MAX_STR_LEN);
if (wcslen(szBuf) < 1)
{
LoadStringW(hInst, IDS_SEARCH_TEXT, szBuf, _countof(szBuf));
SearchEnabled = FALSE;
SetWindowTextW(hSearchBar, szBuf);
}
}
break;
case EN_CHANGE:
{
WCHAR szWndText[MAX_STR_LEN];
if (!SearchEnabled)
{
SearchEnabled = TRUE;
break;
}
LoadStringW(hInst, IDS_SEARCH_TEXT, szBuf, _countof(szBuf));
GetWindowTextW(hSearchBar, szWndText, MAX_STR_LEN);
if (wcscmp(szBuf, szWndText) != 0)
{
StringCbCopy(szSearchPattern, sizeof(szSearchPattern),
szWndText);
}
else
{
szSearchPattern[0] = UNICODE_NULL;
}
SetTimer(hwnd, SEARCH_TIMER_ID, 250, SearchTimerProc);
}
break;
}
return;
}
switch (wCommand)
{
case ID_OPEN_LINK:
ShellExecuteW(hwnd, L"open", pLink, NULL, NULL, SW_SHOWNOACTIVATE);
HeapFree(GetProcessHeap(), 0, pLink);
break;
case ID_COPY_LINK:
CopyTextToClipboard(pLink);
HeapFree(GetProcessHeap(), 0, pLink);
break;
case ID_SETTINGS:
CreateSettingsDlg(hwnd);
break;
case ID_EXIT:
PostMessageW(hwnd, WM_CLOSE, 0, 0);
break;
case ID_INSTALL:
if (DownloadApplication(-1))
/* TODO: Implement install dialog
* if (InstallApplication(-1))
*/
UpdateApplicationsList(-1);
break;
case ID_UNINSTALL:
if (UninstallApplication(-1, FALSE))
UpdateApplicationsList(-1);
break;
case ID_MODIFY:
if (UninstallApplication(-1, TRUE))
UpdateApplicationsList(-1);
break;
case ID_REGREMOVE:
RemoveAppFromRegistry(-1);
break;
case ID_REFRESH:
UpdateApplicationsList(-1);
break;
case ID_RESETDB:
UpdateAppsDB();
UpdateApplicationsList(-1);
break;
case ID_HELP:
MessageBoxW(hwnd, L"Help not implemented yet", NULL, MB_OK);
break;
case ID_ABOUT:
ShowAboutDialog();
break;
}
}
VOID
MainWndOnSize(HWND hwnd, WPARAM wParam, LPARAM lParam)
{
HDWP hdwp = BeginDeferWindowPos(5);
INT SearchBarWidth = GetWindowWidth(hSearchBar);
INT RichPos = GetWindowHeight(hRichEdit);
INT NewPos = HIWORD(lParam) - (RichPos + SPLIT_WIDTH + GetWindowHeight(hStatusBar));
INT VSplitterPos;
/* Size status bar */
SendMessage(hStatusBar, WM_SIZE, 0, 0);
/* Size tool bar */
SendMessage(hToolBar, TB_AUTOSIZE, 0, 0);
/* Size SearchBar */
MoveWindow(hSearchBar, LOWORD(lParam) - SearchBarWidth - 4, 5, SearchBarWidth, 22, TRUE);
/*
* HIWORD(lParam) - Height of main window
* LOWORD(lParam) - Width of main window
*/
/* Size vertical splitter bar */
if (hdwp)
hdwp = DeferWindowPos(hdwp,
hVSplitter,
0,
(VSplitterPos = GetWindowWidth(hTreeView)),
GetWindowHeight(hToolBar),
SPLIT_WIDTH,
HIWORD(lParam) - GetWindowHeight(hToolBar) - GetWindowHeight(hStatusBar),
SWP_NOZORDER|SWP_NOACTIVATE);
/* Size TreeView */
if (hdwp)
hdwp = DeferWindowPos(hdwp,
hTreeView,
0,
0,
GetWindowHeight(hToolBar),
VSplitterPos,
HIWORD(lParam) - GetWindowHeight(hToolBar) - GetWindowHeight(hStatusBar),
SWP_NOZORDER|SWP_NOACTIVATE);
if(wParam != SIZE_MINIMIZED)
{
while (NewPos < SPLIT_WIDTH + GetWindowHeight(hToolBar))
{
RichPos--;
NewPos = HIWORD(lParam) - (RichPos +
SPLIT_WIDTH + GetWindowHeight(hStatusBar));
}
}
SetHSplitterPos(NewPos);
/* Size ListView */
if (hdwp)
hdwp = DeferWindowPos(hdwp,
hListView,
0,
VSplitterPos + SPLIT_WIDTH,
GetWindowHeight(hToolBar),
LOWORD(lParam) - (VSplitterPos + SPLIT_WIDTH),
GetHSplitterPos() - GetWindowHeight(hToolBar),
SWP_NOZORDER|SWP_NOACTIVATE);
/* Size RichEdit */
if (hdwp)
hdwp = DeferWindowPos(hdwp,
hRichEdit,
0,
VSplitterPos + SPLIT_WIDTH,
GetHSplitterPos() + SPLIT_WIDTH,
LOWORD(lParam) - (VSplitterPos + SPLIT_WIDTH),
RichPos,
SWP_NOZORDER|SWP_NOACTIVATE);
/* Size horizontal splitter bar */
if (hdwp)
hdwp = DeferWindowPos(hdwp,
hHSplitter,
0,
VSplitterPos + SPLIT_WIDTH,
GetHSplitterPos(),
LOWORD(lParam) - (VSplitterPos + SPLIT_WIDTH),
SPLIT_WIDTH,
SWP_NOZORDER|SWP_NOACTIVATE);
if (hdwp)
EndDeferWindowPos(hdwp);
}
BOOL IsSelectedNodeInstalled(void)
{
HTREEITEM hSelectedItem = TreeView_GetSelection(hTreeView);
TV_ITEM tItem;
tItem.mask = TVIF_PARAM | TVIF_HANDLE;
tItem.hItem = hSelectedItem;
TreeView_GetItem(hTreeView, &tItem);
switch (tItem.lParam)
{
case IDS_INSTALLED:
case IDS_APPLICATIONS:
case IDS_UPDATES:
return TRUE;
default:
return FALSE;
}
}
LRESULT CALLBACK
MainWindowProc(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
switch (Msg)
{
case WM_CREATE:
if (!InitControls(hwnd))
PostMessage(hwnd, WM_CLOSE, 0, 0);
break;
case WM_COMMAND:
MainWndOnCommand(hwnd, wParam, lParam);
break;
case WM_NOTIFY:
{
LPNMHDR data = (LPNMHDR)lParam;
switch (data->code)
{
case TVN_SELCHANGED:
{
if (data->hwndFrom == hTreeView)
{
switch (((LPNMTREEVIEW)lParam)->itemNew.lParam)
{
case IDS_INSTALLED:
UpdateApplicationsList(ENUM_ALL_COMPONENTS);
break;
case IDS_APPLICATIONS:
UpdateApplicationsList(ENUM_APPLICATIONS);
break;
case IDS_UPDATES:
UpdateApplicationsList(ENUM_UPDATES);
break;
case IDS_AVAILABLEFORINST:
UpdateApplicationsList(ENUM_ALL_AVAILABLE);
break;
case IDS_CAT_AUDIO:
UpdateApplicationsList(ENUM_CAT_AUDIO);
break;
case IDS_CAT_DEVEL:
UpdateApplicationsList(ENUM_CAT_DEVEL);
break;
case IDS_CAT_DRIVERS:
UpdateApplicationsList(ENUM_CAT_DRIVERS);
break;
case IDS_CAT_EDU:
UpdateApplicationsList(ENUM_CAT_EDU);
break;
case IDS_CAT_ENGINEER:
UpdateApplicationsList(ENUM_CAT_ENGINEER);
break;
case IDS_CAT_FINANCE:
UpdateApplicationsList(ENUM_CAT_FINANCE);
break;
case IDS_CAT_GAMES:
UpdateApplicationsList(ENUM_CAT_GAMES);
break;
case IDS_CAT_GRAPHICS:
UpdateApplicationsList(ENUM_CAT_GRAPHICS);
break;
case IDS_CAT_INTERNET:
UpdateApplicationsList(ENUM_CAT_INTERNET);
break;
case IDS_CAT_LIBS:
UpdateApplicationsList(ENUM_CAT_LIBS);
break;
case IDS_CAT_OFFICE:
UpdateApplicationsList(ENUM_CAT_OFFICE);
break;
case IDS_CAT_OTHER:
UpdateApplicationsList(ENUM_CAT_OTHER);
break;
case IDS_CAT_SCIENCE:
UpdateApplicationsList(ENUM_CAT_SCIENCE);
break;
case IDS_CAT_TOOLS:
UpdateApplicationsList(ENUM_CAT_TOOLS);
break;
case IDS_CAT_VIDEO:
UpdateApplicationsList(ENUM_CAT_VIDEO);
break;
}
}
/* Disable/enable items based on treeview selection */
if (IsSelectedNodeInstalled())
{
EnableMenuItem(GetMenu(hwnd), ID_REGREMOVE, MF_ENABLED);
EnableMenuItem(GetMenu(hwnd), ID_INSTALL, MF_GRAYED);
EnableMenuItem(GetMenu(hwnd), ID_UNINSTALL, MF_ENABLED);
EnableMenuItem(GetMenu(hwnd), ID_MODIFY, MF_ENABLED);
EnableMenuItem(GetMenu(hListView), ID_REGREMOVE, MF_ENABLED);
EnableMenuItem(GetMenu(hListView), ID_INSTALL, MF_GRAYED);
EnableMenuItem(GetMenu(hListView), ID_UNINSTALL, MF_ENABLED);
EnableMenuItem(GetMenu(hListView), ID_MODIFY, MF_ENABLED);
SendMessage(hToolBar, TB_ENABLEBUTTON, ID_REGREMOVE, TRUE);
SendMessage(hToolBar, TB_ENABLEBUTTON, ID_INSTALL, FALSE);
SendMessage(hToolBar, TB_ENABLEBUTTON, ID_UNINSTALL, TRUE);
SendMessage(hToolBar, TB_ENABLEBUTTON, ID_MODIFY, TRUE);
}
else
{
EnableMenuItem(GetMenu(hwnd), ID_REGREMOVE, MF_GRAYED);
EnableMenuItem(GetMenu(hwnd), ID_INSTALL, MF_ENABLED);
EnableMenuItem(GetMenu(hwnd), ID_UNINSTALL, MF_GRAYED);
EnableMenuItem(GetMenu(hwnd), ID_MODIFY, MF_GRAYED);
EnableMenuItem(GetMenu(hListView), ID_REGREMOVE, MF_GRAYED);
EnableMenuItem(GetMenu(hListView), ID_INSTALL, MF_ENABLED);
EnableMenuItem(GetMenu(hListView), ID_UNINSTALL, MF_GRAYED);
EnableMenuItem(GetMenu(hListView), ID_MODIFY, MF_GRAYED);
SendMessage(hToolBar, TB_ENABLEBUTTON, ID_REGREMOVE, FALSE);
SendMessage(hToolBar, TB_ENABLEBUTTON, ID_INSTALL, TRUE);
SendMessage(hToolBar, TB_ENABLEBUTTON, ID_UNINSTALL, FALSE);
SendMessage(hToolBar, TB_ENABLEBUTTON, ID_MODIFY, FALSE);
}
}
break;
case LVN_ITEMCHANGED:
{
LPNMLISTVIEW pnic = (LPNMLISTVIEW) lParam;
if (pnic->hdr.hwndFrom == hListView)
{
/* Check if this is a valid item
* (technically, it can be also an unselect) */
INT ItemIndex = pnic->iItem;
if (ItemIndex == -1 ||
ItemIndex >= ListView_GetItemCount(pnic->hdr.hwndFrom))
{
break;
}
/* Check if the focus has been moved to another item */
if ((pnic->uChanged & LVIF_STATE) &&
(pnic->uNewState & LVIS_FOCUSED) &&
!(pnic->uOldState & LVIS_FOCUSED))
{
if (IS_INSTALLED_ENUM(SelectedEnumType))
ShowInstalledAppInfo(ItemIndex);
if (IS_AVAILABLE_ENUM(SelectedEnumType))
ShowAvailableAppInfo(ItemIndex);
}
}
}
break;
case LVN_COLUMNCLICK:
{
LPNMLISTVIEW pnmv = (LPNMLISTVIEW) lParam;
(VOID) ListView_SortItems(hListView, ListViewCompareFunc, pnmv->iSubItem);
bAscending = !bAscending;
}
break;
case NM_CLICK:
{
if (data->hwndFrom == hListView && ((LPNMLISTVIEW)lParam)->iItem != -1)
{
if (IS_INSTALLED_ENUM(SelectedEnumType))
ShowInstalledAppInfo(-1);
if (IS_AVAILABLE_ENUM(SelectedEnumType))
ShowAvailableAppInfo(-1);
}
}
break;
case NM_DBLCLK:
{
if (data->hwndFrom == hListView && ((LPNMLISTVIEW)lParam)->iItem != -1)
{
/* this won't do anything if the program is already installed */
SendMessage(hwnd, WM_COMMAND, ID_INSTALL, 0);
}
}
break;
case NM_RCLICK:
{
if (data->hwndFrom == hListView && ((LPNMLISTVIEW)lParam)->iItem != -1)
{
ShowPopupMenu(hListView, 0, ID_INSTALL);
}
}
break;
case EN_LINK:
RichEditOnLink(hwnd, (ENLINK*)lParam);
break;
case TTN_GETDISPINFO:
ToolBarOnGetDispInfo((LPTOOLTIPTEXT)lParam);
break;
}
}
break;
case WM_PAINT:
break;
case WM_SIZE:
{
if ((GetClientWindowHeight(hMainWnd) - GetWindowHeight(hStatusBar) - SPLIT_WIDTH) < GetHSplitterPos())
{
INT NewSplitPos = GetClientWindowHeight(hwnd) - 100 - GetWindowHeight(hStatusBar) - SPLIT_WIDTH;
if (NewSplitPos > GetWindowHeight(hToolBar) + SPLIT_WIDTH)
SetHSplitterPos(NewSplitPos);
}
MainWndOnSize(hwnd, wParam, lParam);
}
break;
case WM_SIZING:
{
int RichEditHeight = GetWindowHeight(hRichEdit);
LPRECT pRect = (LPRECT)lParam;
while (RichEditHeight <= 100)
{
if (GetHSplitterPos() - 1 < GetWindowHeight(hToolBar) + GetWindowHeight(hListView) + SPLIT_WIDTH)
break;
SetHSplitterPos(GetHSplitterPos() - 1);
RichEditHeight++;
}
if (pRect->right-pRect->left < 565)
pRect->right = pRect->left + 565;
if (pRect->bottom-pRect->top < 300)
pRect->bottom = pRect->top + 300;
return TRUE;
}
case WM_SYSCOLORCHANGE:
{
/* Forward WM_SYSCOLORCHANGE to common controls */
SendMessage(hListView, WM_SYSCOLORCHANGE, 0, 0);
SendMessage(hTreeView, WM_SYSCOLORCHANGE, 0, 0);
SendMessage(hToolBar, WM_SYSCOLORCHANGE, 0, 0);
SendMessageW(hRichEdit, EM_SETBKGNDCOLOR, 0, GetSysColor(COLOR_BTNFACE));
}
break;
case WM_DESTROY:
{
ShowWindow(hwnd, SW_HIDE);
SaveSettings(hwnd);
FreeLogs();
FreeCachedAvailableEntries();
if (IS_INSTALLED_ENUM(SelectedEnumType))
FreeInstalledAppList();
if (hImageTreeView)
ImageList_Destroy(hImageTreeView);
PostQuitMessage(0);
return 0;
}
break;
}
return DefWindowProc(hwnd, Msg, wParam, lParam);
}
int WINAPI
wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nShowCmd)
{
WNDCLASSEXW WndClass = {0};
WCHAR szWindowClass[] = L"ROSAPPMGR";
WCHAR szWindowName[MAX_STR_LEN];
HANDLE hMutex = NULL;
HACCEL KeyBrd;
MSG Msg;
switch (GetUserDefaultUILanguage())
{
case MAKELANGID(LANG_HEBREW, SUBLANG_DEFAULT):
SetProcessDefaultLayout(LAYOUT_RTL);
break;
default:
break;
}
hInst = hInstance;
hMutex = CreateMutexW(NULL, FALSE, szWindowClass);
if ((!hMutex) || (GetLastError() == ERROR_ALREADY_EXISTS))
{
/* If already started, it is found its window */
HWND hWindow = FindWindowW(szWindowClass, NULL);
/* Activate window */
ShowWindow(hWindow, SW_SHOWNORMAL);
SetForegroundWindow(hWindow);
return 1;
}
if (!LoadSettings())
{
FillDefaultSettings(&SettingsInfo);
}
InitLogs();
InitCommonControls();
/* Create the window */
WndClass.cbSize = sizeof(WndClass);
WndClass.lpszClassName = szWindowClass;
WndClass.lpfnWndProc = MainWindowProc;
WndClass.hInstance = hInstance;
WndClass.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_MAIN));
WndClass.hCursor = LoadCursor(NULL, IDC_ARROW);
WndClass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
WndClass.lpszMenuName = MAKEINTRESOURCEW(IDR_MAINMENU);
if (RegisterClassExW(&WndClass) == (ATOM)0) goto Exit;
LoadStringW(hInst, IDS_APPTITLE, szWindowName, _countof(szWindowName));
hMainWnd = CreateWindowExW(WS_EX_WINDOWEDGE,
szWindowClass,
szWindowName,
WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
(SettingsInfo.bSaveWndPos ? SettingsInfo.Left : CW_USEDEFAULT),
(SettingsInfo.bSaveWndPos ? SettingsInfo.Top : CW_USEDEFAULT),
(SettingsInfo.bSaveWndPos ? SettingsInfo.Width : 680),
(SettingsInfo.bSaveWndPos ? SettingsInfo.Height : 450),
NULL,
NULL,
hInstance,
NULL);
if (!hMainWnd) goto Exit;
/* Maximize it if we must */
ShowWindow(hMainWnd, (SettingsInfo.bSaveWndPos && SettingsInfo.Maximized ? SW_MAXIMIZE : nShowCmd));
UpdateWindow(hMainWnd);
if (SettingsInfo.bUpdateAtStart)
UpdateAppsDB();
/* Load the menu hotkeys */
KeyBrd = LoadAccelerators(NULL, MAKEINTRESOURCE(HOTKEYS));
/* Message Loop */
while (GetMessage(&Msg, NULL, 0, 0))
{
if (!TranslateAccelerator(hMainWnd, KeyBrd, &Msg))
{
TranslateMessage(&Msg);
DispatchMessage(&Msg);
}
}
Exit:
if (hMutex)
CloseHandle(hMutex);
return 0;
}

View file

@ -1,565 +0,0 @@
/* Window-specific OpenGL functions implementation.
*
* Copyright (c) 1999 Lionel Ulmer
* Copyright (c) 2005 Raphael Junqueira
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <stdarg.h>
#include <math.h>
#include <GL/gl.h>
#include <windef.h>
#include <winbase.h>
#include <wingdi.h>
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(wgl);
/***********************************************************************
* wglUseFontBitmaps_common
*/
static BOOL wglUseFontBitmaps_common( HDC hdc, DWORD first, DWORD count, DWORD listBase, BOOL unicode )
{
GLYPHMETRICS gm;
unsigned int glyph, size = 0;
void *bitmap = NULL, *gl_bitmap = NULL;
int org_alignment;
BOOL ret = TRUE;
glGetIntegerv(GL_UNPACK_ALIGNMENT, &org_alignment);
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
for (glyph = first; glyph < first + count; glyph++) {
static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
unsigned int needed_size, height, width, width_int;
if (unicode)
needed_size = GetGlyphOutlineW(hdc, glyph, GGO_BITMAP, &gm, 0, NULL, &identity);
else
needed_size = GetGlyphOutlineA(hdc, glyph, GGO_BITMAP, &gm, 0, NULL, &identity);
TRACE("Glyph: %3d / List: %d size %d\n", glyph, listBase, needed_size);
if (needed_size == GDI_ERROR) {
ret = FALSE;
break;
}
if (needed_size > size) {
size = needed_size;
HeapFree(GetProcessHeap(), 0, bitmap);
HeapFree(GetProcessHeap(), 0, gl_bitmap);
bitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
gl_bitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
}
if (unicode)
ret = (GetGlyphOutlineW(hdc, glyph, GGO_BITMAP, &gm, size, bitmap, &identity) != GDI_ERROR);
else
ret = (GetGlyphOutlineA(hdc, glyph, GGO_BITMAP, &gm, size, bitmap, &identity) != GDI_ERROR);
if (!ret) break;
if (TRACE_ON(wgl)) {
unsigned int bitmask;
unsigned char *bitmap_ = bitmap;
TRACE(" - bbox: %d x %d\n", gm.gmBlackBoxX, gm.gmBlackBoxY);
TRACE(" - origin: (%d, %d)\n", gm.gmptGlyphOrigin.x, gm.gmptGlyphOrigin.y);
TRACE(" - increment: %d - %d\n", gm.gmCellIncX, gm.gmCellIncY);
if (needed_size != 0) {
TRACE(" - bitmap:\n");
for (height = 0; height < gm.gmBlackBoxY; height++) {
TRACE(" ");
for (width = 0, bitmask = 0x80; width < gm.gmBlackBoxX; width++, bitmask >>= 1) {
if (bitmask == 0) {
bitmap_ += 1;
bitmask = 0x80;
}
if (*bitmap_ & bitmask)
TRACE("*");
else
TRACE(" ");
}
bitmap_ += (4 - ((UINT_PTR)bitmap_ & 0x03));
TRACE("\n");
}
}
}
/* In OpenGL, the bitmap is drawn from the bottom to the top... So we need to invert the
* glyph for it to be drawn properly.
*/
if (needed_size != 0) {
width_int = (gm.gmBlackBoxX + 31) / 32;
for (height = 0; height < gm.gmBlackBoxY; height++) {
for (width = 0; width < width_int; width++) {
((int *) gl_bitmap)[(gm.gmBlackBoxY - height - 1) * width_int + width] =
((int *) bitmap)[height * width_int + width];
}
}
}
glNewList(listBase++, GL_COMPILE);
if (needed_size != 0) {
glBitmap(gm.gmBlackBoxX, gm.gmBlackBoxY,
0 - gm.gmptGlyphOrigin.x, (int) gm.gmBlackBoxY - gm.gmptGlyphOrigin.y,
gm.gmCellIncX, gm.gmCellIncY,
gl_bitmap);
} else {
/* This is the case of 'empty' glyphs like the space character */
glBitmap(0, 0, 0, 0, gm.gmCellIncX, gm.gmCellIncY, NULL);
}
glEndList();
}
glPixelStorei(GL_UNPACK_ALIGNMENT, org_alignment);
HeapFree(GetProcessHeap(), 0, bitmap);
HeapFree(GetProcessHeap(), 0, gl_bitmap);
return ret;
}
/***********************************************************************
* wglUseFontBitmapsA (OPENGL32.@)
*/
BOOL WINAPI wglUseFontBitmapsA(HDC hdc, DWORD first, DWORD count, DWORD listBase)
{
return wglUseFontBitmaps_common( hdc, first, count, listBase, FALSE );
}
/***********************************************************************
* wglUseFontBitmapsW (OPENGL32.@)
*/
BOOL WINAPI wglUseFontBitmapsW(HDC hdc, DWORD first, DWORD count, DWORD listBase)
{
return wglUseFontBitmaps_common( hdc, first, count, listBase, TRUE );
}
/* FIXME: should probably have a glu.h header */
typedef struct GLUtesselator GLUtesselator;
typedef void (WINAPI *_GLUfuncptr)(void);
#define GLU_TESS_BEGIN 100100
#define GLU_TESS_VERTEX 100101
#define GLU_TESS_END 100102
static GLUtesselator * (WINAPI *pgluNewTess)(void);
static void (WINAPI *pgluDeleteTess)(GLUtesselator *tess);
static void (WINAPI *pgluTessNormal)(GLUtesselator *tess, GLdouble x, GLdouble y, GLdouble z);
static void (WINAPI *pgluTessBeginPolygon)(GLUtesselator *tess, void *polygon_data);
static void (WINAPI *pgluTessEndPolygon)(GLUtesselator *tess);
static void (WINAPI *pgluTessCallback)(GLUtesselator *tess, GLenum which, _GLUfuncptr fn);
static void (WINAPI *pgluTessBeginContour)(GLUtesselator *tess);
static void (WINAPI *pgluTessEndContour)(GLUtesselator *tess);
static void (WINAPI *pgluTessVertex)(GLUtesselator *tess, GLdouble *location, GLvoid* data);
static HMODULE load_libglu(void)
{
static const WCHAR glu32W[] = {'g','l','u','3','2','.','d','l','l',0};
static int already_loaded;
static HMODULE module;
if (already_loaded) return module;
already_loaded = 1;
TRACE("Trying to load GLU library\n");
module = LoadLibraryW( glu32W );
if (!module)
{
WARN("Failed to load glu32\n");
return NULL;
}
#define LOAD_FUNCPTR(f) p##f = (void *)GetProcAddress( module, #f )
LOAD_FUNCPTR(gluNewTess);
LOAD_FUNCPTR(gluDeleteTess);
LOAD_FUNCPTR(gluTessBeginContour);
LOAD_FUNCPTR(gluTessNormal);
LOAD_FUNCPTR(gluTessBeginPolygon);
LOAD_FUNCPTR(gluTessCallback);
LOAD_FUNCPTR(gluTessEndContour);
LOAD_FUNCPTR(gluTessEndPolygon);
LOAD_FUNCPTR(gluTessVertex);
#undef LOAD_FUNCPTR
return module;
}
static void fixed_to_double(POINTFX fixed, UINT em_size, GLdouble vertex[3])
{
vertex[0] = (fixed.x.value + (GLdouble)fixed.x.fract / (1 << 16)) / em_size;
vertex[1] = (fixed.y.value + (GLdouble)fixed.y.fract / (1 << 16)) / em_size;
vertex[2] = 0.0;
}
static void WINAPI tess_callback_vertex(GLvoid *vertex)
{
GLdouble *dbl = vertex;
TRACE("%f, %f, %f\n", dbl[0], dbl[1], dbl[2]);
glVertex3dv(vertex);
}
static void WINAPI tess_callback_begin(GLenum which)
{
TRACE("%d\n", which);
glBegin(which);
}
static void WINAPI tess_callback_end(void)
{
TRACE("\n");
glEnd();
}
typedef struct _bezier_vector {
GLdouble x;
GLdouble y;
} bezier_vector;
static double bezier_deviation_squared(const bezier_vector *p)
{
bezier_vector deviation;
bezier_vector vertex;
bezier_vector base;
double base_length;
double dot;
vertex.x = (p[0].x + p[1].x*2 + p[2].x)/4 - p[0].x;
vertex.y = (p[0].y + p[1].y*2 + p[2].y)/4 - p[0].y;
base.x = p[2].x - p[0].x;
base.y = p[2].y - p[0].y;
base_length = sqrt(base.x*base.x + base.y*base.y);
base.x /= base_length;
base.y /= base_length;
dot = base.x*vertex.x + base.y*vertex.y;
dot = min(max(dot, 0.0), base_length);
base.x *= dot;
base.y *= dot;
deviation.x = vertex.x-base.x;
deviation.y = vertex.y-base.y;
return deviation.x*deviation.x + deviation.y*deviation.y;
}
static int bezier_approximate(const bezier_vector *p, bezier_vector *points, FLOAT deviation)
{
bezier_vector first_curve[3];
bezier_vector second_curve[3];
bezier_vector vertex;
int total_vertices;
if(bezier_deviation_squared(p) <= deviation*deviation)
{
if(points)
*points = p[2];
return 1;
}
vertex.x = (p[0].x + p[1].x*2 + p[2].x)/4;
vertex.y = (p[0].y + p[1].y*2 + p[2].y)/4;
first_curve[0] = p[0];
first_curve[1].x = (p[0].x + p[1].x)/2;
first_curve[1].y = (p[0].y + p[1].y)/2;
first_curve[2] = vertex;
second_curve[0] = vertex;
second_curve[1].x = (p[2].x + p[1].x)/2;
second_curve[1].y = (p[2].y + p[1].y)/2;
second_curve[2] = p[2];
total_vertices = bezier_approximate(first_curve, points, deviation);
if(points)
points += total_vertices;
total_vertices += bezier_approximate(second_curve, points, deviation);
return total_vertices;
}
/***********************************************************************
* wglUseFontOutlines_common
*/
static BOOL wglUseFontOutlines_common(HDC hdc,
DWORD first,
DWORD count,
DWORD listBase,
FLOAT deviation,
FLOAT extrusion,
int format,
LPGLYPHMETRICSFLOAT lpgmf,
BOOL unicode)
{
UINT glyph;
const MAT2 identity = {{0,1},{0,0},{0,0},{0,1}};
GLUtesselator *tess = NULL;
LOGFONTW lf;
HFONT old_font, unscaled_font;
UINT em_size = 1024;
RECT rc;
TRACE("(%p, %d, %d, %d, %f, %f, %d, %p, %s)\n", hdc, first, count,
listBase, deviation, extrusion, format, lpgmf, unicode ? "W" : "A");
if(deviation <= 0.0)
deviation = 1.0/em_size;
if(format == WGL_FONT_POLYGONS)
{
if (!load_libglu())
{
ERR("glu32 is required for this function but isn't available\n");
return FALSE;
}
tess = pgluNewTess();
if(!tess) return FALSE;
pgluTessCallback(tess, GLU_TESS_VERTEX, (_GLUfuncptr)tess_callback_vertex);
pgluTessCallback(tess, GLU_TESS_BEGIN, (_GLUfuncptr)tess_callback_begin);
pgluTessCallback(tess, GLU_TESS_END, tess_callback_end);
}
GetObjectW(GetCurrentObject(hdc, OBJ_FONT), sizeof(lf), &lf);
rc.left = rc.right = rc.bottom = 0;
rc.top = em_size;
DPtoLP(hdc, (POINT*)&rc, 2);
lf.lfHeight = -abs(rc.top - rc.bottom);
lf.lfOrientation = lf.lfEscapement = 0;
unscaled_font = CreateFontIndirectW(&lf);
old_font = SelectObject(hdc, unscaled_font);
for (glyph = first; glyph < first + count; glyph++)
{
DWORD needed;
GLYPHMETRICS gm;
BYTE *buf;
TTPOLYGONHEADER *pph;
TTPOLYCURVE *ppc;
GLdouble *vertices = NULL;
int vertex_total = -1;
if(unicode)
needed = GetGlyphOutlineW(hdc, glyph, GGO_NATIVE, &gm, 0, NULL, &identity);
else
needed = GetGlyphOutlineA(hdc, glyph, GGO_NATIVE, &gm, 0, NULL, &identity);
if(needed == GDI_ERROR)
goto error;
buf = HeapAlloc(GetProcessHeap(), 0, needed);
if(unicode)
GetGlyphOutlineW(hdc, glyph, GGO_NATIVE, &gm, needed, buf, &identity);
else
GetGlyphOutlineA(hdc, glyph, GGO_NATIVE, &gm, needed, buf, &identity);
TRACE("glyph %d\n", glyph);
if(lpgmf)
{
lpgmf->gmfBlackBoxX = (float)gm.gmBlackBoxX / em_size;
lpgmf->gmfBlackBoxY = (float)gm.gmBlackBoxY / em_size;
lpgmf->gmfptGlyphOrigin.x = (float)gm.gmptGlyphOrigin.x / em_size;
lpgmf->gmfptGlyphOrigin.y = (float)gm.gmptGlyphOrigin.y / em_size;
lpgmf->gmfCellIncX = (float)gm.gmCellIncX / em_size;
lpgmf->gmfCellIncY = (float)gm.gmCellIncY / em_size;
TRACE("%fx%f at %f,%f inc %f,%f\n", lpgmf->gmfBlackBoxX, lpgmf->gmfBlackBoxY,
lpgmf->gmfptGlyphOrigin.x, lpgmf->gmfptGlyphOrigin.y, lpgmf->gmfCellIncX, lpgmf->gmfCellIncY);
lpgmf++;
}
glNewList(listBase++, GL_COMPILE);
glFrontFace(GL_CCW);
if(format == WGL_FONT_POLYGONS)
{
glNormal3d(0.0, 0.0, 1.0);
pgluTessNormal(tess, 0, 0, 1);
pgluTessBeginPolygon(tess, NULL);
}
while(!vertices)
{
if(vertex_total != -1)
vertices = HeapAlloc(GetProcessHeap(), 0, vertex_total * 3 * sizeof(GLdouble));
vertex_total = 0;
pph = (TTPOLYGONHEADER*)buf;
while((BYTE*)pph < buf + needed)
{
GLdouble previous[3];
fixed_to_double(pph->pfxStart, em_size, previous);
if(vertices)
TRACE("\tstart %d, %d\n", pph->pfxStart.x.value, pph->pfxStart.y.value);
if(format == WGL_FONT_POLYGONS)
pgluTessBeginContour(tess);
else
glBegin(GL_LINE_LOOP);
if(vertices)
{
fixed_to_double(pph->pfxStart, em_size, vertices);
if(format == WGL_FONT_POLYGONS)
pgluTessVertex(tess, vertices, vertices);
else
glVertex3d(vertices[0], vertices[1], vertices[2]);
vertices += 3;
}
vertex_total++;
ppc = (TTPOLYCURVE*)((char*)pph + sizeof(*pph));
while((char*)ppc < (char*)pph + pph->cb)
{
int i, j;
int num;
switch(ppc->wType) {
case TT_PRIM_LINE:
for(i = 0; i < ppc->cpfx; i++)
{
if(vertices)
{
TRACE("\t\tline to %d, %d\n",
ppc->apfx[i].x.value, ppc->apfx[i].y.value);
fixed_to_double(ppc->apfx[i], em_size, vertices);
if(format == WGL_FONT_POLYGONS)
pgluTessVertex(tess, vertices, vertices);
else
glVertex3d(vertices[0], vertices[1], vertices[2]);
vertices += 3;
}
fixed_to_double(ppc->apfx[i], em_size, previous);
vertex_total++;
}
break;
case TT_PRIM_QSPLINE:
for(i = 0; i < ppc->cpfx-1; i++)
{
bezier_vector curve[3];
bezier_vector *points;
GLdouble curve_vertex[3];
if(vertices)
TRACE("\t\tcurve %d,%d %d,%d\n",
ppc->apfx[i].x.value, ppc->apfx[i].y.value,
ppc->apfx[i + 1].x.value, ppc->apfx[i + 1].y.value);
curve[0].x = previous[0];
curve[0].y = previous[1];
fixed_to_double(ppc->apfx[i], em_size, curve_vertex);
curve[1].x = curve_vertex[0];
curve[1].y = curve_vertex[1];
fixed_to_double(ppc->apfx[i + 1], em_size, curve_vertex);
curve[2].x = curve_vertex[0];
curve[2].y = curve_vertex[1];
if(i < ppc->cpfx-2)
{
curve[2].x = (curve[1].x + curve[2].x)/2;
curve[2].y = (curve[1].y + curve[2].y)/2;
}
num = bezier_approximate(curve, NULL, deviation);
points = HeapAlloc(GetProcessHeap(), 0, num*sizeof(bezier_vector));
num = bezier_approximate(curve, points, deviation);
vertex_total += num;
if(vertices)
{
for(j=0; j<num; j++)
{
TRACE("\t\t\tvertex at %f,%f\n", points[j].x, points[j].y);
vertices[0] = points[j].x;
vertices[1] = points[j].y;
vertices[2] = 0.0;
if(format == WGL_FONT_POLYGONS)
pgluTessVertex(tess, vertices, vertices);
else
glVertex3d(vertices[0], vertices[1], vertices[2]);
vertices += 3;
}
}
HeapFree(GetProcessHeap(), 0, points);
previous[0] = curve[2].x;
previous[1] = curve[2].y;
}
break;
default:
ERR("\t\tcurve type = %d\n", ppc->wType);
if(format == WGL_FONT_POLYGONS)
pgluTessEndContour(tess);
else
glEnd();
goto error_in_list;
}
ppc = (TTPOLYCURVE*)((char*)ppc + sizeof(*ppc) +
(ppc->cpfx - 1) * sizeof(POINTFX));
}
if(format == WGL_FONT_POLYGONS)
pgluTessEndContour(tess);
else
glEnd();
pph = (TTPOLYGONHEADER*)((char*)pph + pph->cb);
}
}
error_in_list:
if(format == WGL_FONT_POLYGONS)
pgluTessEndPolygon(tess);
glTranslated((GLdouble)gm.gmCellIncX / em_size, (GLdouble)gm.gmCellIncY / em_size, 0.0);
glEndList();
HeapFree(GetProcessHeap(), 0, buf);
HeapFree(GetProcessHeap(), 0, vertices);
}
error:
DeleteObject(SelectObject(hdc, old_font));
if(format == WGL_FONT_POLYGONS)
pgluDeleteTess(tess);
return TRUE;
}
/***********************************************************************
* wglUseFontOutlinesA (OPENGL32.@)
*/
BOOL WINAPI wglUseFontOutlinesA(HDC hdc,
DWORD first,
DWORD count,
DWORD listBase,
FLOAT deviation,
FLOAT extrusion,
int format,
LPGLYPHMETRICSFLOAT lpgmf)
{
return wglUseFontOutlines_common(hdc, first, count, listBase, deviation, extrusion, format, lpgmf, FALSE);
}
/***********************************************************************
* wglUseFontOutlinesW (OPENGL32.@)
*/
BOOL WINAPI wglUseFontOutlinesW(HDC hdc,
DWORD first,
DWORD count,
DWORD listBase,
FLOAT deviation,
FLOAT extrusion,
int format,
LPGLYPHMETRICSFLOAT lpgmf)
{
return wglUseFontOutlines_common(hdc, first, count, listBase, deviation, extrusion, format, lpgmf, TRUE);
}

View file

@ -1,134 +0,0 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: lib/opengl32/gl.c
* PURPOSE: OpenGL32 lib, glXXX functions
* PROGRAMMER: Anich Gregor (blight)
* UPDATE HISTORY:
* Feb 2, 2004: Created
*/
/* On a x86 we call the ICD functions in a special-way:
*
* For every glXXX function we export a glXXX entry-point which loads the
* matching "real" function pointer from the NtCurrentTeb()->glDispatchTable
* for gl functions in teblist.h and for others it gets the pointer from
* NtCurrentTeb()->glTable and jmps to the address, leaving the stack alone and
* letting the "real" function return for us.
* Royce has implemented this in NASM =D
*
* On other machines we use C to forward the calls (slow...)
*/
#include "opengl32.h"
#if defined(_M_IX86)
C_ASSERT(FIELD_OFFSET(TEB, glTable) == 0xbe8);
#endif
int WINAPI glEmptyFunc0( void ) { return 0; }
int WINAPI glEmptyFunc4( long l1 ) { return 0; }
int WINAPI glEmptyFunc8( long l1, long l2 ) { return 0; }
int WINAPI glEmptyFunc12( long l1, long l2, long l3 ) { return 0; }
int WINAPI glEmptyFunc16( long l1, long l2, long l3, long l4 ) { return 0; }
int WINAPI glEmptyFunc20( long l1, long l2, long l3, long l4, long l5 )
{ return 0; }
int WINAPI glEmptyFunc24( long l1, long l2, long l3, long l4, long l5,
long l6 ) { return 0; }
int WINAPI glEmptyFunc28( long l1, long l2, long l3, long l4, long l5,
long l6, long l7 ) { return 0; }
int WINAPI glEmptyFunc32( long l1, long l2, long l3, long l4, long l5,
long l6, long l7, long l8 ) { return 0; }
int WINAPI glEmptyFunc36( long l1, long l2, long l3, long l4, long l5,
long l6, long l7, long l8, long l9 ) { return 0; }
int WINAPI glEmptyFunc40( long l1, long l2, long l3, long l4, long l5,
long l6, long l7, long l8, long l9, long l10 )
{ return 0; }
int WINAPI glEmptyFunc44( long l1, long l2, long l3, long l4, long l5,
long l6, long l7, long l8, long l9, long l10,
long l11 ) { return 0; }
int WINAPI glEmptyFunc48( long l1, long l2, long l3, long l4, long l5,
long l6, long l7, long l8, long l9, long l10,
long l11, long l12 ) { return 0; }
int WINAPI glEmptyFunc52( long l1, long l2, long l3, long l4, long l5,
long l6, long l7, long l8, long l9, long l10,
long l11, long l12, long l13 ) { return 0; }
int WINAPI glEmptyFunc56( long l1, long l2, long l3, long l4, long l5,
long l6, long l7, long l8, long l9, long l10,
long l11, long l12, long l13, long l14 )
{ return 0; }
#if defined(_M_IX86)
# define FOO(x) #x
#ifdef __GNUC__
# define X(func, ret, typeargs, args, icdidx, tebidx, stack) \
__asm__(".align 4" "\n\t" \
".globl _"#func"@"#stack "\n\t" \
"_"#func"@"#stack":" "\n\t" \
" movl %fs:0x18, %eax" "\n\t" \
" movl 0xbe8(%eax), %eax" "\n\t" \
" jmp *"FOO((icdidx*4))"(%eax)" "\n\t");
#elif defined(_MSC_VER)
# define X(func, ret, typeargs, args, icdidx, tebidx, stack) \
__declspec(naked) ret WINAPI func typeargs \
{ \
__asm { mov eax, dword ptr fs:[18h] }; \
__asm { mov eax, dword ptr [eax+0be8h] }; \
__asm { jmp dword ptr [eax+icdidx*4] }; \
}
#else
# define X(func, ret, typeargs, args, icdidx, tebidx, stack) \
ret WINAPI func typeargs \
{ \
PROC *table; \
PROC fn; \
if (tebidx >= 0 && 0) \
{ \
table = (PROC *)NtCurrentTeb()->glDispatchTable; \
fn = table[tebidx]; \
} \
else \
{ \
table = (PROC *)NtCurrentTeb()->glTable; \
fn = table[icdidx]; \
} \
return (ret)((ret(*)typeargs)fn)args; \
}
#endif
GLFUNCS_MACRO
# undef FOO
# undef X
#else /* defined(_M_IX86) */
# define X(func, ret, typeargs, args, icdidx, tebidx, stack) \
ret WINAPI func typeargs \
{ \
PROC *table; \
PROC fn; \
if (tebidx >= 0 && 0) \
{ \
table = (PROC *)NtCurrentTeb()->glDispatchTable; \
fn = table[tebidx]; \
} \
else \
{ \
table = (PROC *)NtCurrentTeb()->glTable; \
fn = table[icdidx]; \
} \
return (ret)((ret(*)typeargs)fn)args; \
}
GLFUNCS_MACRO
# undef X
#endif /* !defined(_M_IX86) */
/* Unknown debugging function */
GLint WINAPI glDebugEntry( GLint unknown1, GLint unknown2 )
{
return 0;
}
/* EOF */

View file

@ -1,336 +0,0 @@
ICD_ENTRY(glNewList) //0
ICD_ENTRY(glEndList) //1
ICD_ENTRY(glCallList) //2
ICD_ENTRY(glCallLists) //3
ICD_ENTRY(glDeleteLists) //4
ICD_ENTRY(glGenLists) //5
ICD_ENTRY(glListBase) //6
ICD_ENTRY(glBegin) //7
ICD_ENTRY(glBitmap) //8
ICD_ENTRY(glColor3b) //9
ICD_ENTRY(glColor3bv) //10
ICD_ENTRY(glColor3d) //11
ICD_ENTRY(glColor3dv) //12
ICD_ENTRY(glColor3f) //13
ICD_ENTRY(glColor3fv) //14
ICD_ENTRY(glColor3i) //15
ICD_ENTRY(glColor3iv) //16
ICD_ENTRY(glColor3s) //17
ICD_ENTRY(glColor3sv) //18
ICD_ENTRY(glColor3ub) //19
ICD_ENTRY(glColor3ubv) //20
ICD_ENTRY(glColor3ui) //21
ICD_ENTRY(glColor3uiv) //22
ICD_ENTRY(glColor3us) //23
ICD_ENTRY(glColor3usv) //24
ICD_ENTRY(glColor4b) //25
ICD_ENTRY(glColor4bv) //26
ICD_ENTRY(glColor4d) //27
ICD_ENTRY(glColor4dv) //28
ICD_ENTRY(glColor4f) //29
ICD_ENTRY(glColor4fv) //30
ICD_ENTRY(glColor4i) //31
ICD_ENTRY(glColor4iv) //32
ICD_ENTRY(glColor4s) //33
ICD_ENTRY(glColor4sv) //34
ICD_ENTRY(glColor4ub) //35
ICD_ENTRY(glColor4ubv) //36
ICD_ENTRY(glColor4ui) //37
ICD_ENTRY(glColor4uiv) //38
ICD_ENTRY(glColor4us) //39
ICD_ENTRY(glColor4usv) //40
ICD_ENTRY(glEdgeFlag) //41
ICD_ENTRY(glEdgeFlagv) //42
ICD_ENTRY(glEnd) //43
ICD_ENTRY(glIndexd) //44
ICD_ENTRY(glIndexdv) //45
ICD_ENTRY(glIndexf) //46
ICD_ENTRY(glIndexfv) //47
ICD_ENTRY(glIndexi) //48
ICD_ENTRY(glIndexiv) //49
ICD_ENTRY(glIndexs) //50
ICD_ENTRY(glIndexsv) //51
ICD_ENTRY(glNormal3b) //52
ICD_ENTRY(glNormal3bv) //53
ICD_ENTRY(glNormal3d) //54
ICD_ENTRY(glNormal3dv) //55
ICD_ENTRY(glNormal3f) //56
ICD_ENTRY(glNormal3fv) //57
ICD_ENTRY(glNormal3i) //58
ICD_ENTRY(glNormal3iv) //59
ICD_ENTRY(glNormal3s) //60
ICD_ENTRY(glNormal3sv) //61
ICD_ENTRY(glRasterPos2d) //62
ICD_ENTRY(glRasterPos2dv) //63
ICD_ENTRY(glRasterPos2f) //64
ICD_ENTRY(glRasterPos2fv) //65
ICD_ENTRY(glRasterPos2i) //66
ICD_ENTRY(glRasterPos2iv) //67
ICD_ENTRY(glRasterPos2s) //68
ICD_ENTRY(glRasterPos2sv) //69
ICD_ENTRY(glRasterPos3d) //70
ICD_ENTRY(glRasterPos3dv) //71
ICD_ENTRY(glRasterPos3f) //72
ICD_ENTRY(glRasterPos3fv) //73
ICD_ENTRY(glRasterPos3i) //74
ICD_ENTRY(glRasterPos3iv) //75
ICD_ENTRY(glRasterPos3s) //76
ICD_ENTRY(glRasterPos3sv) //77
ICD_ENTRY(glRasterPos4d) //78
ICD_ENTRY(glRasterPos4dv) //79
ICD_ENTRY(glRasterPos4f) //80
ICD_ENTRY(glRasterPos4fv) //81
ICD_ENTRY(glRasterPos4i) //82
ICD_ENTRY(glRasterPos4iv) //83
ICD_ENTRY(glRasterPos4s) //84
ICD_ENTRY(glRasterPos4sv) //85
ICD_ENTRY(glRectd) //86
ICD_ENTRY(glRectdv) //87
ICD_ENTRY(glRectf) //88
ICD_ENTRY(glRectfv) //89
ICD_ENTRY(glRecti) //90
ICD_ENTRY(glRectiv) //91
ICD_ENTRY(glRects) //92
ICD_ENTRY(glRectsv) //93
ICD_ENTRY(glTexCoord1d) //94
ICD_ENTRY(glTexCoord1dv) //95
ICD_ENTRY(glTexCoord1f) //96
ICD_ENTRY(glTexCoord1fv) //97
ICD_ENTRY(glTexCoord1i) //98
ICD_ENTRY(glTexCoord1iv) //99
ICD_ENTRY(glTexCoord1s) //100
ICD_ENTRY(glTexCoord1sv) //101
ICD_ENTRY(glTexCoord2d) //102
ICD_ENTRY(glTexCoord2dv) //103
ICD_ENTRY(glTexCoord2f) //104
ICD_ENTRY(glTexCoord2fv) //105
ICD_ENTRY(glTexCoord2i) //106
ICD_ENTRY(glTexCoord2iv) //107
ICD_ENTRY(glTexCoord2s) //108
ICD_ENTRY(glTexCoord2sv) //109
ICD_ENTRY(glTexCoord3d) //110
ICD_ENTRY(glTexCoord3dv) //111
ICD_ENTRY(glTexCoord3f) //112
ICD_ENTRY(glTexCoord3fv) //113
ICD_ENTRY(glTexCoord3i) //114
ICD_ENTRY(glTexCoord3iv) //115
ICD_ENTRY(glTexCoord3s) //116
ICD_ENTRY(glTexCoord3sv) //117
ICD_ENTRY(glTexCoord4d) //118
ICD_ENTRY(glTexCoord4dv) //119
ICD_ENTRY(glTexCoord4f) //120
ICD_ENTRY(glTexCoord4fv) //121
ICD_ENTRY(glTexCoord4i) //122
ICD_ENTRY(glTexCoord4iv) //123
ICD_ENTRY(glTexCoord4s) //124
ICD_ENTRY(glTexCoord4sv) //125
ICD_ENTRY(glVertex2d) //126
ICD_ENTRY(glVertex2dv) //127
ICD_ENTRY(glVertex2f) //128
ICD_ENTRY(glVertex2fv) //129
ICD_ENTRY(glVertex2i) //130
ICD_ENTRY(glVertex2iv) //131
ICD_ENTRY(glVertex2s) //132
ICD_ENTRY(glVertex2sv) //133
ICD_ENTRY(glVertex3d) //134
ICD_ENTRY(glVertex3dv) //135
ICD_ENTRY(glVertex3f) //136
ICD_ENTRY(glVertex3fv) //137
ICD_ENTRY(glVertex3i) //138
ICD_ENTRY(glVertex3iv) //139
ICD_ENTRY(glVertex3s) //140
ICD_ENTRY(glVertex3sv) //141
ICD_ENTRY(glVertex4d) //142
ICD_ENTRY(glVertex4dv) //143
ICD_ENTRY(glVertex4f) //144
ICD_ENTRY(glVertex4fv) //145
ICD_ENTRY(glVertex4i) //146
ICD_ENTRY(glVertex4iv) //147
ICD_ENTRY(glVertex4s) //148
ICD_ENTRY(glVertex4sv) //149
ICD_ENTRY(glClipPlane) //150
ICD_ENTRY(glColorMaterial) //151
ICD_ENTRY(glCullFace) //152
ICD_ENTRY(glFogf) //153
ICD_ENTRY(glFogfv) //154
ICD_ENTRY(glFogi) //155
ICD_ENTRY(glFogiv) //156
ICD_ENTRY(glFrontFace) //157
ICD_ENTRY(glHint) //158
ICD_ENTRY(glLightf) //159
ICD_ENTRY(glLightfv) //160
ICD_ENTRY(glLighti) //161
ICD_ENTRY(glLightiv) //162
ICD_ENTRY(glLightModelf) //163
ICD_ENTRY(glLightModelfv) //164
ICD_ENTRY(glLightModeli) //165
ICD_ENTRY(glLightModeliv) //166
ICD_ENTRY(glLineStipple) //167
ICD_ENTRY(glLineWidth) //168
ICD_ENTRY(glMaterialf) //169
ICD_ENTRY(glMaterialfv) //170
ICD_ENTRY(glMateriali) //171
ICD_ENTRY(glMaterialiv) //172
ICD_ENTRY(glPointSize) //173
ICD_ENTRY(glPolygonMode) //174
ICD_ENTRY(glPolygonStipple) //175
ICD_ENTRY(glScissor) //176
ICD_ENTRY(glShadeModel) //177
ICD_ENTRY(glTexParameterf) //178
ICD_ENTRY(glTexParameterfv) //179
ICD_ENTRY(glTexParameteri) //180
ICD_ENTRY(glTexParameteriv) //181
ICD_ENTRY(glTexImage1D) //182
ICD_ENTRY(glTexImage2D) //183
ICD_ENTRY(glTexEnvf) //184
ICD_ENTRY(glTexEnvfv) //185
ICD_ENTRY(glTexEnvi) //186
ICD_ENTRY(glTexEnviv) //187
ICD_ENTRY(glTexGend) //188
ICD_ENTRY(glTexGendv) //189
ICD_ENTRY(glTexGenf) //190
ICD_ENTRY(glTexGenfv) //191
ICD_ENTRY(glTexGeni) //192
ICD_ENTRY(glTexGeniv) //193
ICD_ENTRY(glFeedbackBuffer) //194
ICD_ENTRY(glSelectBuffer) //195
ICD_ENTRY(glRenderMode) //196
ICD_ENTRY(glInitNames) //197
ICD_ENTRY(glLoadName) //198
ICD_ENTRY(glPassThrough) //199
ICD_ENTRY(glPopName) //200
ICD_ENTRY(glPushName) //201
ICD_ENTRY(glDrawBuffer) //202
ICD_ENTRY(glClear) //203
ICD_ENTRY(glClearAccum) //204
ICD_ENTRY(glClearIndex) //205
ICD_ENTRY(glClearColor) //206
ICD_ENTRY(glClearStencil) //207
ICD_ENTRY(glClearDepth) //208
ICD_ENTRY(glStencilMask) //209
ICD_ENTRY(glColorMask) //210
ICD_ENTRY(glDepthMask) //211
ICD_ENTRY(glIndexMask) //212
ICD_ENTRY(glAccum) //213
ICD_ENTRY(glDisable) //214
ICD_ENTRY(glEnable) //215
ICD_ENTRY(glFinish) //216
ICD_ENTRY(glFlush) //217
ICD_ENTRY(glPopAttrib) //218
ICD_ENTRY(glPushAttrib) //219
ICD_ENTRY(glMap1d) //220
ICD_ENTRY(glMap1f) //221
ICD_ENTRY(glMap2d) //222
ICD_ENTRY(glMap2f) //223
ICD_ENTRY(glMapGrid1d) //224
ICD_ENTRY(glMapGrid1f) //225
ICD_ENTRY(glMapGrid2d) //226
ICD_ENTRY(glMapGrid2f) //227
ICD_ENTRY(glEvalCoord1d) //228
ICD_ENTRY(glEvalCoord1dv) //229
ICD_ENTRY(glEvalCoord1f) //230
ICD_ENTRY(glEvalCoord1fv) //231
ICD_ENTRY(glEvalCoord2d) //232
ICD_ENTRY(glEvalCoord2dv) //233
ICD_ENTRY(glEvalCoord2f) //234
ICD_ENTRY(glEvalCoord2fv) //235
ICD_ENTRY(glEvalMesh1) //236
ICD_ENTRY(glEvalPoint1) //237
ICD_ENTRY(glEvalMesh2) //238
ICD_ENTRY(glEvalPoint2) //239
ICD_ENTRY(glAlphaFunc) //240
ICD_ENTRY(glBlendFunc) //241
ICD_ENTRY(glLogicOp) //242
ICD_ENTRY(glStencilFunc) //243
ICD_ENTRY(glStencilOp) //244
ICD_ENTRY(glDepthFunc) //245
ICD_ENTRY(glPixelZoom) //246
ICD_ENTRY(glPixelTransferf) //247
ICD_ENTRY(glPixelTransferi) //248
ICD_ENTRY(glPixelStoref) //249
ICD_ENTRY(glPixelStorei) //250
ICD_ENTRY(glPixelMapfv) //251
ICD_ENTRY(glPixelMapuiv) //252
ICD_ENTRY(glPixelMapusv) //253
ICD_ENTRY(glReadBuffer) //254
ICD_ENTRY(glCopyPixels) //255
ICD_ENTRY(glReadPixels) //256
ICD_ENTRY(glDrawPixels) //257
ICD_ENTRY(glGetBooleanv) //258
ICD_ENTRY(glGetClipPlane) //259
ICD_ENTRY(glGetDoublev) //260
ICD_ENTRY(glGetError) //261
ICD_ENTRY(glGetFloatv) //262
ICD_ENTRY(glGetIntegerv) //263
ICD_ENTRY(glGetLightfv) //264
ICD_ENTRY(glGetLightiv) //265
ICD_ENTRY(glGetMapdv) //266
ICD_ENTRY(glGetMapfv) //267
ICD_ENTRY(glGetMapiv) //268
ICD_ENTRY(glGetMaterialfv) //269
ICD_ENTRY(glGetMaterialiv) //270
ICD_ENTRY(glGetPixelMapfv) //271
ICD_ENTRY(glGetPixelMapuiv) //272
ICD_ENTRY(glGetPixelMapusv) //273
ICD_ENTRY(glGetPolygonStipple) //274
ICD_ENTRY(glGetString) //275
ICD_ENTRY(glGetTexEnvfv) //276
ICD_ENTRY(glGetTexEnviv) //277
ICD_ENTRY(glGetTexGendv) //278
ICD_ENTRY(glGetTexGenfv) //279
ICD_ENTRY(glGetTexGeniv) //280
ICD_ENTRY(glGetTexImage) //281
ICD_ENTRY(glGetTexParameterfv) //282
ICD_ENTRY(glGetTexParameteriv) //283
ICD_ENTRY(glGetTexLevelParameterfv) //284
ICD_ENTRY(glGetTexLevelParameteriv) //285
ICD_ENTRY(glIsEnabled) //286
ICD_ENTRY(glIsList) //287
ICD_ENTRY(glDepthRange) //288
ICD_ENTRY(glFrustum) //289
ICD_ENTRY(glLoadIdentity) //290
ICD_ENTRY(glLoadMatrixf) //291
ICD_ENTRY(glLoadMatrixd) //292
ICD_ENTRY(glMatrixMode) //293
ICD_ENTRY(glMultMatrixf) //294
ICD_ENTRY(glMultMatrixd) //295
ICD_ENTRY(glOrtho) //296
ICD_ENTRY(glPopMatrix) //297
ICD_ENTRY(glPushMatrix) //298
ICD_ENTRY(glRotated) //299
ICD_ENTRY(glRotatef) //300
ICD_ENTRY(glScaled) //301
ICD_ENTRY(glScalef) //302
ICD_ENTRY(glTranslated) //303
ICD_ENTRY(glTranslatef) //304
ICD_ENTRY(glViewport) //305
ICD_ENTRY(glArrayElement) //306
ICD_ENTRY(glBindTexture) //307
ICD_ENTRY(glColorPointer) //308
ICD_ENTRY(glDisableClientState) //309
ICD_ENTRY(glDrawArrays) //310
ICD_ENTRY(glDrawElements) //311
ICD_ENTRY(glEdgeFlagPointer) //312
ICD_ENTRY(glEnableClientState) //313
ICD_ENTRY(glIndexPointer) //314
ICD_ENTRY(glIndexub) //315
ICD_ENTRY(glIndexubv) //316
ICD_ENTRY(glInterleavedArrays) //317
ICD_ENTRY(glNormalPointer) //318
ICD_ENTRY(glPolygonOffset) //319
ICD_ENTRY(glTexCoordPointer) //320
ICD_ENTRY(glVertexPointer) //321
ICD_ENTRY(glAreTexturesResident) //322
ICD_ENTRY(glCopyTexImage1D) //323
ICD_ENTRY(glCopyTexImage2D) //324
ICD_ENTRY(glCopyTexSubImage1D) //325
ICD_ENTRY(glCopyTexSubImage2D) //326
ICD_ENTRY(glDeleteTextures) //327
ICD_ENTRY(glGenTextures) //328
ICD_ENTRY(glGetPointerv) //329
ICD_ENTRY(glIsTexture) //330
ICD_ENTRY(glPrioritizeTextures) //331
ICD_ENTRY(glTexSubImage1D) //332
ICD_ENTRY(glTexSubImage2D) //333
ICD_ENTRY(glPopClientAttrib) //334
ICD_ENTRY(glPushClientAttrib) //335

View file

@ -1,25 +0,0 @@
/* icdtable.h */
#ifndef OPENGL32_PRIVATE_ICDTABLE_H
#define OPENGL32_PRIVATE_ICDTABLE_H
enum icdoffsets_e
{
ICDIDX_INVALID = -1,
#define ICD_ENTRY(x) ICDIDX_##x,
#include "icdlist.h"
#undef ICD_ENTRY
ICDIDX_COUNT
};
typedef struct tagICDTable
{
DWORD num_funcs; /*!< Normally 336 (0x150) -- the number of functions in OpenGL 1.1 */
PROC dispatch_table[812]; /*!< Table containing \a num_funcs pointers to OpenGL functions */
} ICDTable, *PICDTable;
#define DISPATCH_TABLE_SIZE 812*sizeof(PROC)
#endif /* OPENGL32_PRIVATE_ICDTABLE_H */
/* EOF */

View file

@ -1,625 +0,0 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: lib/opengl32/opengl32.c
* PURPOSE: OpenGL32 lib
* PROGRAMMER: Anich Gregor (blight), Royce Mitchell III
* UPDATE HISTORY:
* Feb 1, 2004: Created
*/
#include "opengl32.h"
/* function prototypes */
static void OPENGL32_AppendICD( GLDRIVERDATA *icd );
static void OPENGL32_RemoveICD( GLDRIVERDATA *icd );
static GLDRIVERDATA *OPENGL32_LoadDriver( LPCWSTR regKey );
static DWORD OPENGL32_InitializeDriver( GLDRIVERDATA *icd );
static BOOL OPENGL32_UnloadDriver( GLDRIVERDATA *icd );
static DWORD OPENGL32_RegGetDriverInfo( LPCWSTR driver, GLDRIVERDATA *icd );
/* global vars */
GLPROCESSDATA OPENGL32_processdata;
static BOOL
OPENGL32_ThreadAttach( void )
{
PROC *dispatchTable = NULL;
TEB *teb = NULL;
dispatchTable = (PROC*)HeapAlloc( GetProcessHeap(),
HEAP_GENERATE_EXCEPTIONS | HEAP_ZERO_MEMORY,
DISPATCH_TABLE_SIZE );
if (dispatchTable == NULL)
{
DBGPRINT( "Error: Couldn't allocate GL dispatch table" );
return FALSE;
}
teb = NtCurrentTeb();
/* initialize dispatch table with empty functions */
#define X(func, ret, typeargs, args, icdidx, tebidx, stack) \
dispatchTable[icdidx] = (PROC)glEmptyFunc##stack; \
if (tebidx >= 0) \
teb->glDispatchTable[tebidx] = (PVOID)glEmptyFunc##stack;
GLFUNCS_MACRO
#undef X
teb->glTable = dispatchTable;
/* At first we have no context */
teb->glCurrentRC = NULL;
return TRUE;
}
static void
OPENGL32_ThreadDetach( void )
{
TEB* teb = NtCurrentTeb();
rosglMakeCurrent( NULL, NULL );
if (teb->glTable != NULL)
{
if (!HeapFree( GetProcessHeap(), 0, teb->glTable ))
{
DBGPRINT( "Warning: HeapFree() on dispatch table failed (%d)",
GetLastError() );
}
/* NULL-ify it. Even if something went wrong, it's not a good idea to keep it non NULL */
teb->glTable = NULL;
}
}
static BOOL
OPENGL32_ProcessAttach( void )
{
SECURITY_ATTRIBUTES attrib = { sizeof (SECURITY_ATTRIBUTES), /* nLength */
NULL, /* lpSecurityDescriptor */
TRUE /* bInheritHandle */ };
memset( &OPENGL32_processdata, 0, sizeof (OPENGL32_processdata) );
/* create driver, glrc & dcdata list mutex */
OPENGL32_processdata.driver_mutex = CreateMutex( &attrib, FALSE, NULL );
if (OPENGL32_processdata.driver_mutex == NULL)
{
DBGPRINT( "Error: Couldn't create driver_list mutex (%d)",
GetLastError() );
return FALSE;
}
OPENGL32_processdata.glrc_mutex = CreateMutex( &attrib, FALSE, NULL );
if (OPENGL32_processdata.glrc_mutex == NULL)
{
DBGPRINT( "Error: Couldn't create glrc_list mutex (%d)",
GetLastError() );
return FALSE;
}
OPENGL32_processdata.dcdata_mutex = CreateMutex( &attrib, FALSE, NULL );
if (OPENGL32_processdata.dcdata_mutex == NULL)
{
DBGPRINT( "Error: Couldn't create dcdata_list mutex (%d)",
GetLastError() );
return FALSE;
}
return TRUE;
}
static void
OPENGL32_ProcessDetach( void )
{
GLDRIVERDATA *icd, *icd2;
GLDCDATA *dcdata, *dcdata2;
GLRC *glrc, *glrc2;
/* free lists */
for (dcdata = OPENGL32_processdata.dcdata_list; dcdata != NULL;)
{
dcdata2 = dcdata;
dcdata = dcdata->next;
if (!HeapFree( GetProcessHeap(), 0, dcdata2 ))
DBGPRINT( "Warning: HeapFree() on DCDATA 0x%08x failed (%d)",
dcdata2, GetLastError() );
}
for (glrc = OPENGL32_processdata.glrc_list; glrc != NULL;)
{
glrc2 = glrc;
glrc = glrc->next;
if (!HeapFree( GetProcessHeap(), 0, glrc2 ))
DBGPRINT( "Warning: HeapFree() on GLRC 0x%08x failed (%d)",
glrc2, GetLastError() );
}
for (icd = OPENGL32_processdata.driver_list; icd != NULL;)
{
icd2 = icd;
icd = icd->next;
if (!HeapFree( GetProcessHeap(), 0, icd2 ))
DBGPRINT( "Warning: HeapFree() on DRIVERDATA 0x%08x failed (%d)",
icd2, GetLastError() );
}
/* free mutexes */
if (OPENGL32_processdata.driver_mutex != NULL)
CloseHandle( OPENGL32_processdata.driver_mutex );
if (OPENGL32_processdata.glrc_mutex != NULL)
CloseHandle( OPENGL32_processdata.glrc_mutex );
if (OPENGL32_processdata.dcdata_mutex != NULL)
CloseHandle( OPENGL32_processdata.dcdata_mutex );
}
BOOL WINAPI
DllMain(HINSTANCE hInstance, DWORD Reason, LPVOID Reserved)
{
DBGPRINT( "Info: Called!" );
switch ( Reason )
{
/* The DLL is loading due to process
* initialization or a call to LoadLibrary.
*/
case DLL_PROCESS_ATTACH:
DBGTRACE( "Process attach" );
if (!OPENGL32_ProcessAttach())
return FALSE;
/* No break: Initialize the index for first thread. */
/* The attached process creates a new thread. */
case DLL_THREAD_ATTACH:
DBGTRACE( "Thread attach" );
if (!OPENGL32_ThreadAttach())
return FALSE;
break;
/* The thread of the attached process terminates. */
case DLL_THREAD_DETACH:
DBGTRACE( "Thread detach" );
/* Release the allocated memory for this thread.*/
OPENGL32_ThreadDetach();
break;
/* DLL unload due to process termination or FreeLibrary. */
case DLL_PROCESS_DETACH:
DBGTRACE( "Process detach" );
OPENGL32_ThreadDetach();
OPENGL32_ProcessDetach();
break;
}
return TRUE;
}
/*! \brief Append ICD to linked list.
*
* \param icd GLDRIVERDATA to append to list
*
* \note Only call this when you hold the driver_mutex.
*/
static void
OPENGL32_AppendICD( GLDRIVERDATA *icd )
{
if (OPENGL32_processdata.driver_list == NULL)
OPENGL32_processdata.driver_list = icd;
else
{
GLDRIVERDATA *p = OPENGL32_processdata.driver_list;
while (p->next != NULL)
p = p->next;
p->next = icd;
}
}
/*! \brief Remove ICD from linked list.
*
* \param icd GLDRIVERDATA to remove from list
*
* \note Only call this when you hold the driver_mutex.
*/
static void
OPENGL32_RemoveICD( GLDRIVERDATA *icd )
{
if (icd == OPENGL32_processdata.driver_list)
OPENGL32_processdata.driver_list = icd->next;
else
{
GLDRIVERDATA *p = OPENGL32_processdata.driver_list;
while (p != NULL)
{
if (p->next == icd)
{
p->next = icd->next;
return;
}
p = p->next;
}
DBGPRINT( "Error: ICD 0x%08x not found in list!", icd );
}
}
/*! \brief Load an ICD.
*
* \param driver Name of installable client driver.
*
* \return Pointer to an allocated GLDRIVERDATA struct.
* \retval NULL Failure.
*
* \todo Call SetLastError() where appropriate.
*/
static GLDRIVERDATA *
OPENGL32_LoadDriver( LPCWSTR driver )
{
LONG ret;
GLDRIVERDATA *icd;
DBGPRINT( "Info: Loading driver %ws...", driver );
/* allocate driver data */
icd = (GLDRIVERDATA*)HeapAlloc( GetProcessHeap(),
HEAP_GENERATE_EXCEPTIONS | HEAP_ZERO_MEMORY,
sizeof (GLDRIVERDATA) );
if (icd == NULL)
{
DBGPRINT( "Error: Couldn't allocate GLDRIVERDATA! (%d)", GetLastError() );
return NULL;
}
ret = OPENGL32_RegGetDriverInfo( driver, icd );
if (ret != ERROR_SUCCESS)
{
DBGPRINT( "Error: Couldn't query driver information (%d)", ret );
if (!HeapFree( GetProcessHeap(), 0, icd ))
DBGPRINT( "Error: HeapFree() returned false, error code = %d",
GetLastError() );
return NULL;
}
DBGPRINT( "Info: Dll = %ws", icd->dll );
DBGPRINT( "Info: Version = 0x%08x", icd->version );
DBGPRINT( "Info: DriverVersion = 0x%08x", icd->driver_version );
DBGPRINT( "Info: Flags = 0x%08x", icd->flags );
/* load/initialize ICD */
ret = OPENGL32_InitializeDriver( icd );
if (ret != ERROR_SUCCESS)
{
DBGPRINT( "Error: Couldnt initialize ICD!" );
if (!HeapFree( GetProcessHeap(), 0, icd ))
DBGPRINT( "Error: HeapFree() returned false, error code = %d",
GetLastError() );
return NULL;
}
/* append ICD to list */
OPENGL32_AppendICD( icd );
DBGPRINT( "Info: ICD loaded." );
return icd;
}
/*! \brief Initialize a driver (Load DLL and DrvXxx procs)
*
* \param icd ICD to initialize with the dll, version, driverVersion
* and flags already filled.
* \return Error code.
* \retval ERROR_SUCCESS Success
*/
#define LOAD_DRV_PROC( icd, proc, required ) \
*(char**)&icd->proc = (char*)GetProcAddress( icd->handle, #proc ); \
if (required && icd->proc == NULL) { \
DBGPRINT( "Error: GetProcAddress(\"%s\") failed!", #proc ); \
FreeLibrary( icd->handle ); \
return GetLastError(); \
}
static DWORD
OPENGL32_InitializeDriver( GLDRIVERDATA *icd )
{
/* check version */
if (icd->version > 2)
DBGPRINT( "Warning: ICD version > 2 (%d)", icd->version );
/* load dll */
icd->handle = LoadLibraryW( icd->dll );
if (icd->handle == NULL)
{
DWORD err = GetLastError();
DBGPRINT( "Error: Couldn't load DLL! (%d)", err );
return err;
}
/* validate version */
if (icd->driver_version > 1)
{
LOAD_DRV_PROC(icd, DrvValidateVersion, FALSE);
if (icd->DrvValidateVersion != NULL)
{
if (!icd->DrvValidateVersion( icd->driver_version ))
{
DBGPRINT( "Error: DrvValidateVersion failed!" );
DBGBREAK();
FreeLibrary( icd->handle );
return ERROR_INVALID_FUNCTION; /* FIXME: use better error code */
}
}
else
DBGPRINT( "Info: DrvValidateVersion not exported by ICD" );
}
/* load DrvXXX procs */
LOAD_DRV_PROC(icd, DrvCopyContext, TRUE);
LOAD_DRV_PROC(icd, DrvCreateContext, FALSE);
LOAD_DRV_PROC(icd, DrvCreateLayerContext, FALSE);
LOAD_DRV_PROC(icd, DrvDeleteContext, TRUE);
LOAD_DRV_PROC(icd, DrvDescribeLayerPlane, TRUE);
LOAD_DRV_PROC(icd, DrvDescribePixelFormat, TRUE);
LOAD_DRV_PROC(icd, DrvGetLayerPaletteEntries, TRUE);
LOAD_DRV_PROC(icd, DrvGetProcAddress, TRUE);
LOAD_DRV_PROC(icd, DrvReleaseContext, TRUE);
LOAD_DRV_PROC(icd, DrvRealizeLayerPalette, TRUE);
LOAD_DRV_PROC(icd, DrvSetContext, TRUE);
LOAD_DRV_PROC(icd, DrvSetLayerPaletteEntries, TRUE);
LOAD_DRV_PROC(icd, DrvSetPixelFormat, TRUE);
LOAD_DRV_PROC(icd, DrvShareLists, TRUE);
LOAD_DRV_PROC(icd, DrvSwapBuffers, TRUE);
LOAD_DRV_PROC(icd, DrvSwapLayerBuffers, TRUE);
/* we require at least one of DrvCreateContext and DrvCreateLayerContext */
if (icd->DrvCreateContext == NULL && icd->DrvCreateLayerContext == NULL)
{
DBGPRINT( "Error: One of DrvCreateContext/DrvCreateLayerContext is required!" );
FreeLibrary( icd->handle );
return ERROR_INVALID_FUNCTION; /* FIXME: use better error code... */
}
return ERROR_SUCCESS;
}
/*! \brief Unload ICD.
*
* \retval TRUE Success.
* \retval FALSE Failure.
*/
static BOOL
OPENGL32_UnloadDriver( GLDRIVERDATA *icd )
{
BOOL allOk = TRUE;
DBGPRINT( "Info: Unloading driver %ws...", icd->driver_name );
if (icd->refcount != 0)
DBGPRINT( "Warning: ICD refcount = %d (should be 0)", icd->refcount );
/* unload dll */
if (!FreeLibrary( icd->handle ))
{
allOk = FALSE;
DBGPRINT( "Warning: FreeLibrary on ICD %ws failed! (%d)", icd->dll,
GetLastError() );
}
/* free resources */
OPENGL32_RemoveICD( icd );
if (!HeapFree( GetProcessHeap(), 0, icd ))
{
allOk = FALSE;
DBGPRINT( "Warning: HeapFree() returned FALSE, error code = %d",
GetLastError() );
}
return allOk;
}
/*! \brief Load ICD (shared ICD data)
*
* \return Pointer to an allocated GLDRIVERDATA on success.
* \retval NULL Failure.
*/
GLDRIVERDATA *
OPENGL32_LoadICD( LPCWSTR driver )
{
GLDRIVERDATA *icd;
/* synchronize */
if (WaitForSingleObject( OPENGL32_processdata.driver_mutex, INFINITE ) ==
WAIT_FAILED)
{
DBGPRINT( "Error: WaitForSingleObject() failed (%d)", GetLastError() );
return NULL; /* FIXME: do we have to expect such an error and handle it? */
}
/* look if ICD is already loaded */
for (icd = OPENGL32_processdata.driver_list; icd; icd = icd->next)
{
if (!_wcsicmp( driver, icd->driver_name )) /* found */
{
/* release mutex */
if (!ReleaseMutex( OPENGL32_processdata.driver_mutex ))
DBGPRINT( "Error: ReleaseMutex() failed (%d)", GetLastError() );
return icd;
}
}
/* not found - try to load */
icd = OPENGL32_LoadDriver( driver );
/* release mutex */
if (!ReleaseMutex( OPENGL32_processdata.driver_mutex ))
DBGPRINT( "Error: ReleaseMutex() failed (%d)", GetLastError() );
return icd;
}
/*! \brief Unload ICD (shared ICD data)
*
* \retval TRUE Success.
* \retval FALSE Failure.
*/
BOOL
OPENGL32_UnloadICD( GLDRIVERDATA *icd )
{
BOOL ret = TRUE;
/* synchronize */
if (WaitForSingleObject( OPENGL32_processdata.driver_mutex, INFINITE ) ==
WAIT_FAILED)
{
DBGPRINT( "Error: WaitForSingleObject() failed (%d)", GetLastError() );
return FALSE; /* FIXME: do we have to expect such an error and handle it? */
}
if (icd->refcount == 0)
ret = OPENGL32_UnloadDriver( icd );
/* release mutex */
if (!ReleaseMutex( OPENGL32_processdata.driver_mutex ))
DBGPRINT( "Error: ReleaseMutex() failed (%d)", GetLastError() );
return ret;
}
/*! \brief Enumerate OpenGLDrivers (from registry)
*
* \param idx Index of the driver to get information about.
* \param name Pointer to an array of WCHARs (can be NULL)
* \param cName Pointer to a DWORD. Input is len of name array.
* Output is length of the drivername.
* Can be NULL if name is NULL.
*
* \return Error code
* \retval ERROR_NO_MORE_ITEMS End of driver list.
* \retval ERROR_SUCCESS Success.
*/
#if 0 /* unused */
DWORD
OPENGL32_RegEnumDrivers( DWORD idx, LPWSTR name, LPDWORD cName )
{
HKEY hKey;
LPCWSTR subKey = OPENGL_DRIVERS_SUBKEY;
LONG ret;
DWORD size;
WCHAR driver[256];
if (name == NULL)
return ERROR_SUCCESS; /* nothing to do */
if (cName == NULL)
return ERROR_INVALID_FUNCTION; /* we need cName when name is given */
/* open OpenGLDrivers registry key */
ret = RegOpenKeyExW( HKEY_LOCAL_MACHINE, subKey, 0, KEY_READ, &hKey );
if (ret != ERROR_SUCCESS)
{
DBGPRINT( "Error: Couldn't open registry key '%ws'", subKey );
return ret;
}
/* get subkey name */
size = sizeof (driver) / sizeof (driver[0]);
ret = RegEnumKeyW( hKey, idx, name, *cName );
if (ret != ERROR_SUCCESS)
{
DBGPRINT( "Error: Couldn't get OpenGLDrivers subkey name (%d)", ret );
RegCloseKey( hKey );
return ret;
}
*cName = wcslen( name );
/* close key */
RegCloseKey( hKey );
return ERROR_SUCCESS;
}
#endif /* 0 -- unused */
/*! \brief Get registry values for a driver given a name.
*
* \param driver Name of the driver to get information about.
* \param icd Pointer to GLDRIVERDATA.
*
* \return Error code.
* \retval ERROR_SUCCESS Success.
*
* \note On success the following fields of \a icd are filled: \a driver_name,
* \a dll, \a version, \a driver_version and \a flags.
*/
static DWORD
OPENGL32_RegGetDriverInfo( LPCWSTR driver, GLDRIVERDATA *icd )
{
HKEY hKey;
WCHAR subKey[1024] = OPENGL_DRIVERS_SUBKEY2;
LONG ret;
DWORD type, size;
/* drivers registry values */
DWORD version = 1, driverVersion = 0, flags = 0;
WCHAR dll[256];
/* open driver registry key */
wcsncat( subKey, driver, 1024 );
ret = RegOpenKeyExW( HKEY_LOCAL_MACHINE, subKey, 0, KEY_READ, &hKey );
if (ret != ERROR_SUCCESS)
{
DBGPRINT( "Error: Couldn't open registry key '%ws'", subKey );
return ret;
}
/* query values */
size = sizeof (dll);
ret = RegQueryValueExW( hKey, L"Dll", 0, &type, (LPBYTE)dll, &size );
if (ret != ERROR_SUCCESS || type != REG_SZ)
{
DBGPRINT( "Error: Couldn't query Dll value or not a string" );
RegCloseKey( hKey );
return ret;
}
size = sizeof (DWORD);
ret = RegQueryValueExW( hKey, L"Version", 0, &type, (LPBYTE)&version, &size );
if (ret != ERROR_SUCCESS || type != REG_DWORD)
DBGPRINT( "Warning: Couldn't query Version value or not a DWORD" );
size = sizeof (DWORD);
ret = RegQueryValueExW( hKey, L"DriverVersion", 0, &type,
(LPBYTE)&driverVersion, &size );
if (ret != ERROR_SUCCESS || type != REG_DWORD)
DBGPRINT( "Warning: Couldn't query DriverVersion value or not a DWORD" );
size = sizeof (DWORD);
ret = RegQueryValueExW( hKey, L"Flags", 0, &type, (LPBYTE)&flags, &size );
if (ret != ERROR_SUCCESS || type != REG_DWORD)
DBGPRINT( "Warning: Couldn't query Flags value or not a DWORD" );
/* close key */
RegCloseKey( hKey );
/* output data */
/* FIXME: NUL-terminate strings? */
wcsncpy( icd->driver_name, driver,
sizeof (icd->driver_name) / sizeof (icd->driver_name[0]) - 1 );
wcsncpy( icd->dll, dll,
sizeof (icd->dll) / sizeof (icd->dll[0]) );
icd->version = version;
icd->driver_version = driverVersion;
icd->flags = flags;
return ERROR_SUCCESS;
}
/* EOF */

View file

@ -1,181 +0,0 @@
# Microsoft Developer Studio Project File - Name="opengl32" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
CFG=opengl32 - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "opengl32.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "opengl32.mak" CFG="opengl32 - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "opengl32 - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE "opengl32 - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
MTL=midl.exe
RSC=rc.exe
!IF "$(CFG)" == "opengl32 - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "OPENGL32_EXPORTS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "OPENGL32_EXPORTS" /YX /FD /c
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x409 /d "NDEBUG"
# ADD RSC /l 0x409 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
!ELSEIF "$(CFG)" == "opengl32 - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "Debug"
# PROP Intermediate_Dir "Debug"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "OPENGL32_EXPORTS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "OPENGL32_EXPORTS" /YX /FD /TP /GZ /c
# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
# ADD BASE RSC /l 0x409 /d "_DEBUG"
# ADD RSC /l 0x409 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
# ADD LINK32 gdi32.lib advapi32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
!ENDIF
# Begin Target
# Name "opengl32 - Win32 Release"
# Name "opengl32 - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=.\gl.c
# End Source File
# Begin Source File
SOURCE=.\opengl32.c
# End Source File
# Begin Source File
SOURCE=.\tebimports.asm
!IF "$(CFG)" == "opengl32 - Win32 Release"
# Begin Custom Build - Compiling $(InputPath)
IntDir=.\Release
InputPath=.\tebimports.asm
InputName=tebimports
"$(IntDir)/$(InputName).obj" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
nasmw.exe -f win32 $(InputPath) -o "$(IntDir)/$(InputName).obj"
# End Custom Build
!ELSEIF "$(CFG)" == "opengl32 - Win32 Debug"
# Begin Custom Build - Compiling $(InputPath)
IntDir=.\Debug
InputPath=.\tebimports.asm
InputName=tebimports
"$(IntDir)/$(InputName).obj" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
nasmw.exe -f win32 -d win32 $(InputPath) -o "$(IntDir)/$(InputName).obj"
# End Custom Build
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\wgl.c
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# Begin Source File
SOURCE=.\glfuncs.h
# End Source File
# Begin Source File
SOURCE=.\icdlist.h
# End Source File
# Begin Source File
SOURCE=.\icdtable.h
# End Source File
# Begin Source File
SOURCE=.\opengl32.def
# End Source File
# Begin Source File
SOURCE=.\opengl32.h
# End Source File
# Begin Source File
SOURCE=.\slowlist.h
# End Source File
# Begin Source File
SOURCE=.\teb.h
# End Source File
# Begin Source File
SOURCE=.\teblist.h
# End Source File
# Begin Source File
SOURCE=.\teblist.mac
# End Source File
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

View file

@ -1,29 +0,0 @@
Microsoft Developer Studio Workspace File, Format Version 6.00
# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
###############################################################################
Project: "opengl32"=.\opengl32.dsp - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
}}}
###############################################################################
Global:
Package=<5>
{{{
}}}
Package=<3>
{{{
}}}
###############################################################################

File diff suppressed because it is too large Load diff

View file

@ -1,84 +0,0 @@
#define IDC_STATIC -1
#define IDS_APPNAME 10
#define IDI_MAIN_ICON 20
#define IDB_ROOT_IMAGE 21
#define IDB_TOOLBAR 22
/* windows */
#define IDC_TREEVIEW 50
#define IDC_TOOLBAR 51
#define IDC_STATUSBAR 52
#define IDR_MAINMENU 53
#define IDR_POPUP 54
/* Actions */
#define IDC_PROPERTIES 100
#define IDC_SCAN_HARDWARE 101
#define IDC_ENABLE_DRV 102
#define IDC_DISABLE_DRV 103
#define IDC_UPDATE_DRV 104
#define IDC_UNINSTALL_DRV 105
#define IDC_ADD_HARDWARE 106
/* Menu items */
#define IDC_ACTIONMENU 150
#define IDC_ABOUT 151
#define IDC_EXIT 152
/* view menu */
#define IDC_DEVBYTYPE 200
#define IDC_DEVBYCONN 201
#define IDC_RESBYTYPE 202
#define IDC_RESBYCONN 203
#define IDC_SHOWHIDDEN 204
/* tooltips */
#define IDS_TOOLTIP_PROPERTIES 300
#define IDS_TOOLTIP_SCAN 301
#define IDS_TOOLTIP_ENABLE 302
#define IDS_TOOLTIP_DISABLE 303
#define IDS_TOOLTIP_UPDATE 304
#define IDS_TOOLTIP_UNINSTALL 305
/* General strings */
#define IDS_CONFIRM_DISABLE 400
/* Menu strings */
#define IDS_MENU_UPDATE 500
#define IDS_MENU_ENABLE 501
#define IDS_MENU_DISABLE 502
#define IDS_MENU_UNINSTALL 503
#define IDS_MENU_SCAN 504
#define IDS_MENU_ADD 505
#define IDS_MENU_PROPERTIES 506
/* menu hints */
#define IDS_HINT_BLANK 1000
#define IDS_HINT_PROPERTIES 1001
#define IDS_HINT_SCAN 1002
#define IDS_HINT_ENABLE 1003
#define IDS_HINT_DISABLE 1004
#define IDS_HINT_UPDATE 1005
#define IDS_HINT_UNINSTALL 1006
#define IDS_HINT_ADD 1007
#define IDS_HINT_ABOUT 20008
#define IDS_HINT_EXIT 20009
#define IDS_HINT_DEV_BY_TYPE 20020
#define IDS_HINT_DEV_BY_CONN 20021
#define IDS_HINT_RES_BY_TYPE 20022
#define IDS_HINT_RES_BY_CONN 20023
#define IDS_HINT_SHOW_HIDDEN 20024
/* system menu hints */
#define IDS_HINT_SYS_RESTORE 21001
#define IDS_HINT_SYS_MOVE 21002
#define IDS_HINT_SYS_SIZE 21003
#define IDS_HINT_SYS_MINIMIZE 21004
#define IDS_HINT_SYS_MAXIMIZE 21005
#define IDS_HINT_SYS_CLOSE 21006

View file

@ -1,78 +0,0 @@
LANGUAGE LANG_GERMAN, SUBLANG_NEUTRAL
IDR_MAINMENU MENU
BEGIN
POPUP "&Datei"
BEGIN
MENUITEM "&Beenden", IDC_EXIT
END
MENUITEM "Ak&tion" IDC_ACTIONMENU
POPUP "&Ansicht"
BEGIN
MENUITEM "Geräte nach &Typ", IDC_DEVBYTYPE
MENUITEM "Geräte nach &Verbindung", IDC_DEVBYCONN
MENUITEM "Ressourcen nac&h Typ", IDC_RESBYTYPE, GRAYED
MENUITEM "Ressourcen nach V&erbindung", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "Ausgeblendete &Geräte anzeigen", IDC_SHOWHIDDEN
END
POPUP "&Hilfe"
BEGIN
MENUITEM "&Über", IDC_ABOUT
END
END
STRINGTABLE DISCARDABLE
BEGIN
IDS_CONFIRM_DISABLE "Wenn Sie dieses Gerät deaktivieren, funktioniert es nicht mehr.\r\nSoll das Gerät deaktiviert werden?"
END
STRINGTABLE DISCARDABLE
BEGIN
IDS_MENU_UPDATE "Treiber aktualisieren"
IDS_MENU_ENABLE "Aktivieren"
IDS_MENU_DISABLE "Deaktivieren"
IDS_MENU_UNINSTALL "Deinstallieren"
IDS_MENU_SCAN "Nach geänderter Hardware suchen"
IDS_MENU_ADD "Hardware hinzufügen"
IDS_MENU_PROPERTIES "Eigenschaften"
END
STRINGTABLE DISCARDABLE
BEGIN
IDS_TOOLTIP_PROPERTIES "Eigenschaften"
IDS_TOOLTIP_SCAN "Nach geänderter Hardware suchen"
IDS_TOOLTIP_ENABLE "Aktivieren"
IDS_TOOLTIP_DISABLE "Deaktivieren"
IDS_TOOLTIP_UPDATE "Treiber aktualisieren"
IDS_TOOLTIP_UNINSTALL "Deinstallieren"
END
/* Hints */
STRINGTABLE DISCARDABLE
BEGIN
IDS_APPNAME "ReactOS Gerätemanager"
IDS_HINT_BLANK " "
IDS_HINT_PROPERTIES " Öffnet die Eigenschaften des aktuellen Objekts."
IDS_HINT_SCAN " Nach geänderten oder neuen Plug & Play-Geräten suchen."
IDS_HINT_ENABLE " Aktiviert das ausgewählte Gerät."
IDS_HINT_DISABLE " Deaktiviert das ausgewählte Gerät."
IDS_HINT_UPDATE " Startet den Hardwareupdate-Assistent für das ausgewählte Gerät."
IDS_HINT_UNINSTALL " Deinstalliert den Treiber des ausgewählten Geräts."
IDS_HINT_ADD " Fügt ein älteres (nicht Plug and Play) Gerät dem Computer hinzu."
IDS_HINT_ABOUT " Über ReactOS Gerätemanager."
IDS_HINT_EXIT " Schließt dieses Programm."
IDS_HINT_DEV_BY_TYPE " Geräte werden nach Hardwaretyp angezeigt."
IDS_HINT_DEV_BY_CONN " Geräte werden nach Verbindung angezeigt."
IDS_HINT_RES_BY_TYPE " Ressourcen werden nach Typ angezeigt."
IDS_HINT_RES_BY_CONN " Ressourcen werden nach Verbindung angezeigt."
IDS_HINT_SHOW_HIDDEN " Ältere Geräte und bereits nicht mehr installierte Geräte werden angezeigt."
IDS_HINT_SYS_RESTORE " Stellt die normale Größe des Fensters wieder her."
IDS_HINT_SYS_MOVE " Bewegt dieses Fenster."
IDS_HINT_SYS_SIZE " Ändert die Größe dieses Fensters."
IDS_HINT_SYS_MINIMIZE " Mimimiert dieses Fenster zu einem Symbol."
IDS_HINT_SYS_MAXIMIZE " Erweitert dieses Fenster, um den Bildschirm zu füllen."
IDS_HINT_SYS_CLOSE " Schließt dieses Fenster."
END

View file

@ -1,78 +0,0 @@
LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
IDR_MAINMENU MENU
BEGIN
POPUP "&File"
BEGIN
MENUITEM "E&xit", IDC_EXIT
END
MENUITEM "Action" IDC_ACTIONMENU
POPUP "View"
BEGIN
MENUITEM "Devices by type", IDC_DEVBYTYPE
MENUITEM "Devices by connection", IDC_DEVBYCONN
MENUITEM "Resources by type", IDC_RESBYTYPE, GRAYED
MENUITEM "Resources by connection", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "Show hidden devices", IDC_SHOWHIDDEN
END
POPUP "Help"
BEGIN
MENUITEM "About", IDC_ABOUT
END
END
STRINGTABLE DISCARDABLE
BEGIN
IDS_CONFIRM_DISABLE "Disabling this device will cause it to stop functioning.\r\nDo you really want to disable it?"
END
STRINGTABLE DISCARDABLE
BEGIN
IDS_MENU_UPDATE "Update driver software..."
IDS_MENU_ENABLE "Enable"
IDS_MENU_DISABLE "Disable"
IDS_MENU_UNINSTALL "Uninstall"
IDS_MENU_SCAN "Scan for hardware changes"
IDS_MENU_ADD "Add hardware"
IDS_MENU_PROPERTIES "Properties"
END
STRINGTABLE DISCARDABLE
BEGIN
IDS_TOOLTIP_PROPERTIES "Properties"
IDS_TOOLTIP_SCAN "Scan for hardware changes"
IDS_TOOLTIP_ENABLE "Enable"
IDS_TOOLTIP_DISABLE "Disable"
IDS_TOOLTIP_UPDATE "Update Driver Software"
IDS_TOOLTIP_UNINSTALL "Uninstall"
END
/* Hints */
STRINGTABLE DISCARDABLE
BEGIN
IDS_APPNAME "ReactOS Device Manager"
IDS_HINT_BLANK " "
IDS_HINT_PROPERTIES " Open property dialog for the current selection."
IDS_HINT_SCAN " Scan for changed or new plug and play devices."
IDS_HINT_ENABLE " Enables the selected device."
IDS_HINT_DISABLE " Disables the selected device."
IDS_HINT_UPDATE " Launches the Update Driver Software wizard for the selected device."
IDS_HINT_UNINSTALL " Uninstalls the driver for the selected device."
IDS_HINT_ADD " Adds a legacy (non-Plug and Play) device to the computer."
IDS_HINT_ABOUT " About ReactOS Device Manager."
IDS_HINT_EXIT " Exits the program."
IDS_HINT_DEV_BY_TYPE " Displays devices by hardware type."
IDS_HINT_DEV_BY_CONN " Displays devices by connection."
IDS_HINT_RES_BY_TYPE " Displays resources by type."
IDS_HINT_RES_BY_CONN " Displays resources by connection type."
IDS_HINT_SHOW_HIDDEN " Displays legacy devices and devices that are no longer installed."
IDS_HINT_SYS_RESTORE " Restores this window to normal size."
IDS_HINT_SYS_MOVE " Moves this window."
IDS_HINT_SYS_SIZE " Resizes this window."
IDS_HINT_SYS_MINIMIZE " Collapses this window to an icon."
IDS_HINT_SYS_MAXIMIZE " Expands this window to fill this screen."
IDS_HINT_SYS_CLOSE " Closes this window."
END

View file

@ -1,98 +0,0 @@
/* Russian language resource file by Kudratov Olimjon (olim98@bk.ru) */
LANGUAGE LANG_RUSSIAN, SUBLANG_DEFAULT
IDR_MAINMENU MENU
BEGIN
POPUP "&Файл"
BEGIN
MENUITEM "В&ыход", IDC_EXIT
END
POPUP "&Действие"
BEGIN
MENUITEM "Обнов&ить драйвера...", IDC_UPDATE_DRV
MENUITEM "&Включить устройство", IDC_ENABLE_DRV
MENUITEM "&Отключить устройство", IDC_DISABLE_DRV
MENUITEM "&Удалить драйвера", IDC_UNINSTALL_DRV
MENUITEM SEPARATOR
MENUITEM "О&бновить конфигурацию оборудования", IDC_SCAN_HARDWARE
MENUITEM "Добавить &устройство", IDC_ADD_HARDWARE, GRAYED
MENUITEM SEPARATOR
MENUITEM "Сво&йства", IDC_PROPERTIES
END
POPUP "&Вид"
BEGIN
MENUITEM "&Устройства по типу", IDC_DEVBYTYPE
MENUITEM "Устройства по под&ключению", IDC_DEVBYCONN
MENUITEM "&Ресурсы по типу", IDC_RESBYTYPE, GRAYED
MENUITEM "Ресурсы по подк&лючению", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "Показать &скрытые устройства", IDC_SHOWHIDDEN
END
POPUP "&Справка"
BEGIN
MENUITEM "О &программе", IDC_ABOUT
END
END
IDR_POPUP MENU
BEGIN
POPUP "popup"
BEGIN
MENUITEM "Обнов&ить драйвера...", IDC_UPDATE_DRV
MENUITEM "&Включить устройство", IDC_ENABLE_DRV
MENUITEM "&Отключить устройство", IDC_DISABLE_DRV
MENUITEM "&Удалить драйвера", IDC_UNINSTALL_DRV
MENUITEM SEPARATOR
MENUITEM "О&бновить конфигурацию оборудования", IDC_SCAN_HARDWARE
MENUITEM "Добавить &устройство", IDC_ADD_HARDWARE, GRAYED
MENUITEM SEPARATOR
MENUITEM "Сво&йства", IDC_PROPERTIES
END
END
STRINGTABLE DISCARDABLE
BEGIN
IDS_CONFIRM_DISABLE "Disabling this device will cause it to stop functioning.\r\nDo you really want to disable it?"
END
STRINGTABLE DISCARDABLE
BEGIN
IDS_TOOLTIP_PROPERTIES "Свойства"
IDS_TOOLTIP_SCAN "Обновить конфигурацию оборудования"
IDS_TOOLTIP_ENABLE "Включить"
IDS_TOOLTIP_DISABLE "Отключить"
IDS_TOOLTIP_UPDATE "Обновить драйвера"
IDS_TOOLTIP_UNINSTALL "Удалить"
END
/* Hints */
STRINGTABLE DISCARDABLE
BEGIN
IDS_APPNAME "Диспетчер устройств ReactOS"
IDS_HINT_BLANK " "
IDS_HINT_PROPERTIES " Открытие страницы свойств для выделенного объекта."
IDS_HINT_SCAN " Scan for changed or new plug and play devices."
IDS_HINT_ENABLE " Включение выбранного устройства."
IDS_HINT_DISABLE " Отключение выбранного устройства."
IDS_HINT_UPDATE " Launches the Update Driver Software wizard for the selected device."
IDS_HINT_UNINSTALL " Удаление драйвера для выбранного устройства."
IDS_HINT_ADD " Добавить старое (не Plug-and-Play) устройство на этот компьютер."
IDS_HINT_ABOUT " About ReactOS Device Manager."
IDS_HINT_EXIT " Exits the program."
IDS_HINT_DEV_BY_TYPE " Показывает устройства, отсортированные по типу оборудования."
IDS_HINT_DEV_BY_CONN " Показывает устройства, отсортированные по подключению."
IDS_HINT_RES_BY_TYPE " Показывает ресурсы, отсортированные по типу."
IDS_HINT_RES_BY_CONN " Показывает ресурсы, отсортированные по подключению."
IDS_HINT_SHOW_HIDDEN " Показывает удаленные из системы и устаревшие устройства."
IDS_HINT_SYS_RESTORE " Restores this window to normal size."
IDS_HINT_SYS_MOVE " Moves this window."
IDS_HINT_SYS_SIZE " Resizes this window."
IDS_HINT_SYS_MINIMIZE " Collapses this window to an icon."
IDS_HINT_SYS_MAXIMIZE " Expands this window to fill this screen."
IDS_HINT_SYS_CLOSE " Closes this window."
END

View file

@ -1,80 +0,0 @@
/* TRANSLATOR: 2015 Erdem Ersoy (eersoy93) (erdemersoy@live.com) */
LANGUAGE LANG_TURKISH, SUBLANG_DEFAULT
IDR_MAINMENU MENU
BEGIN
POPUP "&Kütük"
BEGIN
MENUITEM "&Çıkış", IDC_EXIT
END
MENUITEM "&Eylem"
POPUP "&Görünüm"
BEGIN
MENUITEM "&Türe Göre Aygıtlar", IDC_DEVBYTYPE
MENUITEM "&Bağlantıya Göre Aygıtlar", IDC_DEVBYCONN
MENUITEM "T&üre Göre Kaynaklar", IDC_RESBYTYPE, GRAYED
MENUITEM "B&ağlantıya Göre Kaynaklar", IDC_RESBYCONN, GRAYED
MENUITEM SEPARATOR
MENUITEM "&Gizli Aygıtları Göster", IDC_SHOWHIDDEN
END
POPUP "&Yardım"
BEGIN
MENUITEM "&Üzerine", IDC_ABOUT
END
END
STRINGTABLE DISCARDABLE
BEGIN
IDS_CONFIRM_DISABLE "Bu aygıtı edilginleştirme onun işleyişinin durmasına neden olacak.\r\nOnu edilginleştirmeyi gerçekten istiyor musunuz?"
END
STRINGTABLE DISCARDABLE
BEGIN
IDS_MENU_UPDATE "Sürücü Yazılımını Şimdikileştir..."
IDS_MENU_ENABLE "Etkin"
IDS_MENU_DISABLE "Edilgin"
IDS_MENU_UNINSTALL "Kaldır"
IDS_MENU_SCAN "Donanım Değişiklikleri İçin Tara"
IDS_MENU_ADD "Donanım Ekle"
IDS_MENU_PROPERTIES "Husûsiyetler"
END
STRINGTABLE DISCARDABLE
BEGIN
IDS_TOOLTIP_PROPERTIES "Husûsiyetler"
IDS_TOOLTIP_SCAN "Donanım Değişiklikleri İçin Tara"
IDS_TOOLTIP_ENABLE "Etkinleştir"
IDS_TOOLTIP_DISABLE "Edilginleştir"
IDS_TOOLTIP_UPDATE "Sürücü Yazılmını Şimdikileştir"
IDS_TOOLTIP_UNINSTALL "Kaldır"
END
/* Hints */
STRINGTABLE DISCARDABLE
BEGIN
IDS_APPNAME "Aygıt Yöneticisi"
IDS_HINT_BLANK " "
IDS_HINT_PROPERTIES " Şimdiki seçilen için husûsiyet penceresini açar."
IDS_HINT_SCAN " Yeni ya da değiştirilmiş tak ve çalıştır aygıtları için tarar."
IDS_HINT_ENABLE " Seçili aygıtı etkinleştirir."
IDS_HINT_DISABLE " Seçili aygıtı edilginleştirir."
IDS_HINT_UPDATE " Seçili aygıt için Sürücü Yazılımını Şimdikileştir yardımcısını başlatır."
IDS_HINT_UNINSTALL " Seçili aygıt için sürücüyü kaldırır."
IDS_HINT_ADD " Bilgisayara eski (Tak ve Çalıştır olmayan) bir aygıt ekler."
IDS_HINT_ABOUT " Aygıt Yöneticisi üzerine."
IDS_HINT_EXIT " İzlenceden çıkar."
IDS_HINT_DEV_BY_TYPE " Donanım türüne göre aygıtları görüntüler."
IDS_HINT_DEV_BY_CONN " Bağlantıya göre aygıtları görüntüler."
IDS_HINT_RES_BY_TYPE " Türe göre kaynakları görüntüler."
IDS_HINT_RES_BY_CONN " Bağlantı türüne göre kaynakları görüntüler."
IDS_HINT_SHOW_HIDDEN " Eski aygıtları ve artık kurulu olmayacak aygıtları görüntüler."
IDS_HINT_SYS_RESTORE " Bu pencereyi düzgülük boyutlarına döndürür."
IDS_HINT_SYS_MOVE " Bu pencereyi devindirir."
IDS_HINT_SYS_SIZE " Bu pencereyi yeniden boyutlandırır."
IDS_HINT_SYS_MINIMIZE " Bu pencereyi bir simgeye küçültür."
IDS_HINT_SYS_MAXIMIZE " Bu pencereyi, bu görüntülüğü kaplatana dek genişletir."
IDS_HINT_SYS_CLOSE " Bu pencereyi kapatır."
END

Binary file not shown.

Before

Width:  |  Height:  |  Size: 39 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 822 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 6.1 KiB

View file

@ -1,80 +0,0 @@
#include <windows.h>
#include "resource.h"
LANGUAGE LANG_NEUTRAL, SUBLANG_NEUTRAL
IDI_MAIN_ICON ICON "res/computer.ico"
IDB_ROOT_IMAGE BITMAP "res/root.bmp"
/* main toolbar icons */
IDB_TOOLBAR BITMAP DISCARDABLE "res/toolbar.bmp"
// UTF-8
#pragma code_page(65001)
#ifdef LANGUAGE_BG_BG
#include "lang/bg-BG.rc"
#endif
#ifdef LANGUAGE_DE_DE
#include "lang/de-DE.rc"
#endif
#ifdef LANGUAGE_EL_GR
#include "lang/el-GR.rc"
#endif
#ifdef LANGUAGE_EN_US
#include "lang/en-US.rc"
#endif
#ifdef LANGUAGE_ES_ES
#include "lang/es-ES.rc"
#endif
#ifdef LANGUAGE_FR_FR
#include "lang/fr-FR.rc"
#endif
#ifdef LANGUAGE_HE_IL
#include "lang/he-IL.rc"
#endif
#ifdef LANGUAGE_ID_ID
#include "lang/id-ID.rc"
#endif
#ifdef LANGUAGE_IT_IT
#include "lang/it-IT.rc"
#endif
#ifdef LANGUAGE_JA_JP
#include "lang/ja-JP.rc"
#endif
#ifdef LANGUAGE_KO_KR
#include "lang/ko-KR.rc"
#endif
#ifdef LANGUAGE_NB_NO
#include "lang/no-NO.rc"
#endif
#ifdef LANGUAGE_PL_PL
#include "lang/pl-PL.rc"
#endif
#ifdef LANGUAGE_PT_BR
#include "lang/pt-BR.rc"
#endif
#ifdef LANGUAGE_RO_RO
#include "lang/ro-RO.rc"
#endif
#ifdef LANGUAGE_RU_RU
#include "lang/ru-RU.rc"
#endif
#ifdef LANGUAGE_SK_SK
#include "lang/sk-SK.rc"
#endif
#ifdef LANGUAGE_SV_SE
#include "lang/sv-SE.rc"
#endif
#ifdef LANGUAGE_TH_TH
#include "lang/th-TH.rc"
#endif
#ifdef LANGUAGE_TR_TR
#include "lang/tr-TR.rc"
#endif
#ifdef LANGUAGE_UK_UA
#include "lang/uk-UA.rc"
#endif
#ifdef LANGUAGE_ZH_CN
#include "lang/zh-CN.rc"
#endif

View file

@ -1,53 +0,0 @@
#pragma once
#ifndef __REACTOS__
#define WIN32_LEAN_AND_MEAN
#include <Windows.h>
#include <windowsx.h>
#include <setupapi.h>
#include <cfgmgr32.h>
#include <commctrl.h>
#include <Uxtheme.h>
#include <Cfgmgr32.h>
#include <devguid.h>
#include <process.h>
#define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS // some CString constructors will be explicit
#include <tchar.h>
#include <atlbase.h>
#include <atlstr.h>
#include <atlcoll.h>
#include <strsafe.h>
#else
#include <string.h>
#include <wchar.h>
#include <tchar.h>
#include <windef.h>
#include <winbase.h>
#include <winreg.h>
#include <wingdi.h>
#include <winnls.h>
#include <wincon.h>
#include <shlobj.h>
#include <shlwapi.h>
#include <strsafe.h>
#include <process.h>
#include <WindowsX.h>
#include <strsafe.h>
#include <setupapi.h>
#include <commctrl.h>
#include <cfgmgr32.h>
#include <Uxtheme.h>
#include <devguid.h>
#include <atlbase.h>
#include <atlstr.h>
#include <atlcoll.h>
#endif

View file

@ -1,614 +0,0 @@
/*
* ReactOS Device Manager Applet
* Copyright (C) 2004 - 2005 ReactOS Team
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/*
* PROJECT: ReactOS devmgr.dll
* FILE: lib/devmgr/devprblm.c
* PURPOSE: ReactOS Device Manager
* PROGRAMMER: Thomas Weidenmueller <w3seek@reactos.com>
* UPDATE HISTORY:
* 04-04-2004 Created
*/
#include "precomp.h"
BOOL
ShowDeviceProblemWizard(IN HWND hWndParent OPTIONAL,
IN HDEVINFO hDevInfo,
IN PSP_DEVINFO_DATA DevInfoData,
IN HMACHINE hMachine OPTIONAL)
{
WCHAR szDeviceInstanceId[256];
CONFIGRET cr;
ULONG Status, ProblemNumber;
DWORD dwReboot;
BOOL Ret = FALSE;
/* Get the device instance id */
if (!SetupDiGetDeviceInstanceId(hDevInfo,
DevInfoData,
szDeviceInstanceId,
256,
NULL))
return FALSE;
cr = CM_Get_DevNode_Status_Ex(&Status,
&ProblemNumber,
DevInfoData->DevInst,
0,
hMachine);
if (cr == CR_SUCCESS && (Status & DN_HAS_PROBLEM))
{
switch (ProblemNumber)
{
case CM_PROB_DEVLOADER_FAILED:
{
/* FIXME - only if it's not a root bus devloader */
/* FIXME - display the update driver wizard */
break;
}
case CM_PROB_OUT_OF_MEMORY:
case CM_PROB_ENTRY_IS_WRONG_TYPE:
case CM_PROB_LACKED_ARBITRATOR:
case CM_PROB_FAILED_START:
case CM_PROB_LIAR:
case CM_PROB_UNKNOWN_RESOURCE:
{
/* FIXME - display the update driver wizard */
InstallDevInst(hWndParent, szDeviceInstanceId, TRUE, &dwReboot);
break;
}
case CM_PROB_BOOT_CONFIG_CONFLICT:
case CM_PROB_NORMAL_CONFLICT:
case CM_PROB_REENUMERATION:
{
/* FIXME - display the conflict wizard */
break;
}
case CM_PROB_FAILED_FILTER:
case CM_PROB_REINSTALL:
case CM_PROB_FAILED_INSTALL:
{
/* FIXME - display the driver (re)installation wizard */
InstallDevInst(hWndParent, szDeviceInstanceId, TRUE, &dwReboot);
break;
}
case CM_PROB_DEVLOADER_NOT_FOUND:
{
/* FIXME - 4 cases:
1) if it's a missing system devloader:
- fail
2) if it's not a system devloader but still missing:
- display the driver reinstallation wizard
3) if it's not a system devloader but the file can be found:
- display the update driver wizard
4) if it's a missing or empty software key
- display the update driver wizard
*/
break;
}
case CM_PROB_INVALID_DATA:
case CM_PROB_PARTIAL_LOG_CONF:
case CM_PROB_NO_VALID_LOG_CONF:
case CM_PROB_HARDWARE_DISABLED:
case CM_PROB_CANT_SHARE_IRQ:
case CM_PROB_TRANSLATION_FAILED:
case CM_PROB_SYSTEM_SHUTDOWN:
case CM_PROB_PHANTOM:
/* FIXME - do nothing */
break;
case CM_PROB_NOT_VERIFIED:
case CM_PROB_DEVICE_NOT_THERE:
/* FIXME - display search hardware wizard */
break;
case CM_PROB_NEED_RESTART:
case CM_PROB_WILL_BE_REMOVED:
case CM_PROB_MOVED:
case CM_PROB_TOO_EARLY:
case CM_PROB_DISABLED_SERVICE:
/* FIXME - reboot computer */
break;
case CM_PROB_REGISTRY:
/* FIXME - check registry */
break;
case CM_PROB_DISABLED:
{
/* FIXME - if device was disabled by user display the "Enable Device" wizard,
otherwise Troubleshoot because the device was disabled by the system */
break;
}
case CM_PROB_DEVLOADER_NOT_READY:
{
/* FIXME - if it's a graphics adapter:
- if it's a a secondary adapter and the main adapter
couldn't be found
- do nothing or default action
- else
- display the Properties
- else
- Update driver
*/
break;
}
case CM_PROB_FAILED_ADD:
{
/* FIXME - display the properties of the sub-device */
break;
}
case CM_PROB_NO_SOFTCONFIG:
case CM_PROB_IRQ_TRANSLATION_FAILED:
case CM_PROB_FAILED_DRIVER_ENTRY:
case CM_PROB_DRIVER_FAILED_PRIOR_UNLOAD:
case CM_PROB_DRIVER_FAILED_LOAD:
case CM_PROB_DRIVER_SERVICE_KEY_INVALID:
case CM_PROB_LEGACY_SERVICE_NO_DEVICES:
case CM_PROB_DUPLICATE_DEVICE:
case CM_PROB_FAILED_POST_START:
case CM_PROB_HALTED:
case CM_PROB_HELD_FOR_EJECT:
case CM_PROB_DRIVER_BLOCKED:
case CM_PROB_REGISTRY_TOO_LARGE:
default:
{
/* FIXME - troubleshoot the device */
break;
}
}
}
return Ret;
}
/***************************************************************************
* NAME EXPORTED
* DeviceProblemWizardA
*
* DESCRIPTION
* Calls the device problem wizard
*
* ARGUMENTS
* hWndParent: Handle to the parent window
* lpMachineName: Machine Name, NULL is the local machine
* lpDeviceID: Specifies the device, also see NOTEs
*
* RETURN VALUE
* TRUE: if no errors occured
* FALSE: if errors occured
*
* @implemented
*/
BOOL
WINAPI
DeviceProblemWizardA(IN HWND hWndParent OPTIONAL,
IN LPCSTR lpMachineName OPTIONAL,
IN LPCSTR lpDeviceID)
{
LPWSTR lpMachineNameW = NULL;
LPWSTR lpDeviceIDW = NULL;
BOOL Ret = FALSE;
if (lpMachineName != NULL)
{
if (!(lpMachineNameW = ConvertMultiByteToUnicode(lpMachineName,
CP_ACP)))
{
goto Cleanup;
}
}
if (lpDeviceID != NULL)
{
if (!(lpDeviceIDW = ConvertMultiByteToUnicode(lpDeviceID,
CP_ACP)))
{
goto Cleanup;
}
}
Ret = DeviceProblemWizardW(hWndParent,
lpMachineNameW,
lpDeviceIDW);
Cleanup:
if (lpMachineNameW != NULL)
{
HeapFree(GetProcessHeap(),
0,
lpMachineNameW);
}
if (lpDeviceIDW != NULL)
{
HeapFree(GetProcessHeap(),
0,
lpDeviceIDW);
}
return Ret;
}
/***************************************************************************
* NAME EXPORTED
* DeviceProblemWizardW
*
* DESCRIPTION
* Calls the device problem wizard
*
* ARGUMENTS
* hWndParent: Handle to the parent window
* lpMachineName: Machine Name, NULL is the local machine
* lpDeviceID: Specifies the device, also see NOTEs
*
* RETURN VALUE
* TRUE: if no errors occured
* FALSE: if errors occured
*
* @unimplemented
*/
BOOL
WINAPI
DeviceProblemWizardW(IN HWND hWndParent OPTIONAL,
IN LPCWSTR lpMachineName OPTIONAL,
IN LPCWSTR lpDeviceID)
{
HDEVINFO hDevInfo;
SP_DEVINFO_DATA DevInfoData;
HINSTANCE hComCtl32;
CONFIGRET cr;
HMACHINE hMachine;
BOOL Ret = FALSE;
if (lpDeviceID == NULL)
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
/* dynamically load comctl32 */
hComCtl32 = LoadAndInitComctl32();
if (hComCtl32 != NULL)
{
hDevInfo = SetupDiCreateDeviceInfoListEx(NULL,
hWndParent,
lpMachineName,
NULL);
if (hDevInfo != INVALID_HANDLE_VALUE)
{
cr = CM_Connect_Machine(lpMachineName,
&hMachine);
if (cr == CR_SUCCESS)
{
DevInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
if (SetupDiOpenDeviceInfo(hDevInfo,
lpDeviceID,
hWndParent,
0,
&DevInfoData))
{
Ret = ShowDeviceProblemWizard(hWndParent,
hDevInfo,
&DevInfoData,
hMachine);
}
CM_Disconnect_Machine(hMachine);
}
SetupDiDestroyDeviceInfoList(hDevInfo);
}
FreeLibrary(hComCtl32);
}
return Ret;
}
static const UINT ProblemStringId[NUM_CM_PROB] =
{
IDS_DEV_NO_PROBLEM,
IDS_DEV_DEVLOADER_FAILED,
IDS_DEV_NOT_CONFIGURED,
IDS_DEV_OUT_OF_MEMORY,
IDS_DEV_ENTRY_IS_WRONG_TYPE,
IDS_DEV_LACKED_ARBITRATOR,
IDS_DEV_BOOT_CONFIG_CONFLICT,
IDS_DEV_FAILED_FILTER,
IDS_DEV_DEVLOADER_NOT_FOUND,
IDS_DEV_INVALID_DATA,
IDS_DEV_FAILED_START,
IDS_DEV_LIAR,
IDS_DEV_NORMAL_CONFLICT,
IDS_DEV_NOT_VERIFIED,
IDS_DEV_NEED_RESTART,
IDS_DEV_REENUMERATION,
IDS_DEV_PARTIAL_LOG_CONF,
IDS_DEV_UNKNOWN_RESOURCE,
IDS_DEV_REINSTALL,
IDS_DEV_REGISTRY,
IDS_UNKNOWN, /* CM_PROB_VXDLDR, not used on NT */
IDS_DEV_WILL_BE_REMOVED,
IDS_DEV_DISABLED,
IDS_DEV_DEVLOADER_NOT_READY,
IDS_DEV_DEVICE_NOT_THERE,
IDS_DEV_MOVED,
IDS_DEV_TOO_EARLY,
IDS_DEV_NO_VALID_LOG_CONF,
IDS_DEV_FAILED_INSTALL,
IDS_DEV_HARDWARE_DISABLED,
IDS_DEV_CANT_SHARE_IRQ,
IDS_DEV_FAILED_ADD,
IDS_DEV_DISABLED_SERVICE,
IDS_DEV_TRANSLATION_FAILED,
IDS_DEV_NO_SOFTCONFIG,
IDS_DEV_BIOS_TABLE,
IDS_DEV_IRQ_TRANSLATION_FAILED,
IDS_DEV_FAILED_DRIVER_ENTRY,
IDS_DEV_DRIVER_FAILED_PRIOR_UNLOAD,
IDS_DEV_DRIVER_FAILED_LOAD,
IDS_DEV_DRIVER_SERVICE_KEY_INVALID,
IDS_DEV_LEGACY_SERVICE_NO_DEVICES,
IDS_DEV_DUPLICATE_DEVICE,
IDS_DEV_FAILED_POST_START,
IDS_DEV_HALTED,
IDS_DEV_PHANTOM,
IDS_DEV_SYSTEM_SHUTDOWN,
IDS_DEV_HELD_FOR_EJECT,
IDS_DEV_DRIVER_BLOCKED,
IDS_DEV_REGISTRY_TOO_LARGE,
IDS_DEV_SETPROPERTIES_FAILED
};
/***************************************************************************
* NAME EXPORTED
* DeviceProblemTextA
*
* DESCRIPTION
* Gets the problem text from a problem number displayed in the properties dialog
*
* ARGUMENTS
* hMachine: Machine handle or NULL for the local machine
* DevInst: Device instance handle
* uProblemId: Specifies the problem ID
* lpString: Pointer to a buffer where the string is to be copied to. If the buffer
* is too small, the return value is the required string length in characters,
* excluding the NULL-termination.
* uMaxString: Size of the buffer in characters
*
* RETURN VALUE
* The return value is the length of the string in characters.
* It returns 0 if an error occured.
*
* @implemented
*/
UINT
WINAPI
DeviceProblemTextA(IN HMACHINE hMachine OPTIONAL,
IN DEVINST dnDevInst,
IN ULONG uProblemId,
OUT LPSTR lpString,
IN UINT uMaxString)
{
LPWSTR lpBuffer = NULL;
UINT Ret = 0;
if (uMaxString != 0)
{
lpBuffer = HeapAlloc(GetProcessHeap(),
0,
(uMaxString + 1) * sizeof(WCHAR));
if (lpBuffer == NULL)
{
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return 0;
}
}
Ret = DeviceProblemTextW(hMachine,
dnDevInst,
uProblemId,
lpBuffer,
uMaxString);
if (lpBuffer != NULL)
{
if (Ret)
{
WideCharToMultiByte(CP_ACP,
0,
lpBuffer,
(int)Ret,
lpString,
(int)uMaxString,
NULL,
NULL);
}
HeapFree(GetProcessHeap(),
0,
lpBuffer);
}
return Ret;
}
/***************************************************************************
* NAME EXPORTED
* DeviceProblemTextW
*
* DESCRIPTION
* Gets the problem text from a problem number displayed in the properties dialog
*
* ARGUMENTS
* hMachine: Machine handle or NULL for the local machine
* DevInst: Device instance handle
* uProblemId: Specifies the problem ID
* lpString: Pointer to a buffer where the string is to be copied to. If the buffer
* is too small, the return value is the required string length in characters,
* excluding the NULL-termination.
* uMaxString: Size of the buffer in characters
*
* RETURN VALUE
* The return value is the length of the string in characters.
* It returns 0 if an error occured.
*
* @implemented
*/
UINT
WINAPI
DeviceProblemTextW(IN HMACHINE hMachine OPTIONAL,
IN DEVINST dnDevInst,
IN ULONG uProblemId,
OUT LPWSTR lpString,
IN UINT uMaxString)
{
UINT MessageId = IDS_UNKNOWN;
UINT Ret = 0;
if (uProblemId < sizeof(ProblemStringId) / sizeof(ProblemStringId[0]))
MessageId = ProblemStringId[uProblemId];
if (uProblemId == 0)
{
if (uMaxString != 0)
{
Ret = LoadString(hDllInstance,
MessageId,
lpString,
(int)uMaxString);
}
else
{
Ret = (UINT)LengthOfStrResource(hDllInstance,
MessageId);
}
}
else
{
LPWSTR szProblem, szInfo = L"FIXME";
DWORD dwRet;
BOOL AdvFormat = FALSE;
UINT StringIDs[] =
{
MessageId,
IDS_DEVCODE,
};
switch (uProblemId)
{
case CM_PROB_DEVLOADER_FAILED:
{
/* FIXME - if not a root bus devloader then use IDS_DEV_DEVLOADER_FAILED2 */
/* FIXME - get the type string (ie. ISAPNP, PCI or BIOS for root bus devloaders,
or FLOP, ESDI, SCSI, etc for others */
AdvFormat = TRUE;
break;
}
case CM_PROB_DEVLOADER_NOT_FOUND:
{
/* FIXME - 4 cases:
1) if it's a missing system devloader:
- get the system devloader name
2) if it's not a system devloader but still missing:
- get the devloader name (file name?)
3) if it's not a system devloader but the file can be found:
- use IDS_DEV_DEVLOADER_NOT_FOUND2
4) if it's a missing or empty software key
- use IDS_DEV_DEVLOADER_NOT_FOUND3
- AdvFormat = FALSE!
*/
AdvFormat = TRUE;
break;
}
case CM_PROB_INVALID_DATA:
/* FIXME - if the device isn't enumerated by the BIOS/ACPI use IDS_DEV_INVALID_DATA2 */
AdvFormat = FALSE;
break;
case CM_PROB_NORMAL_CONFLICT:
/* FIXME - get resource type (IRQ, DMA, Memory or I/O) */
AdvFormat = TRUE;
break;
case CM_PROB_UNKNOWN_RESOURCE:
/* FIXME - get the .inf file name */
AdvFormat = TRUE;
break;
case CM_PROB_DISABLED:
/* FIXME - if the device was disabled by the system use IDS_DEV_DISABLED2 */
break;
case CM_PROB_FAILED_ADD:
/* FIXME - get the name of the sub-device with the error */
AdvFormat = TRUE;
break;
}
if (AdvFormat)
{
StringIDs[1] = IDS_DEVCODE2;
dwRet = LoadAndFormatStringsCat(hDllInstance,
StringIDs,
sizeof(StringIDs) / sizeof(StringIDs[0]),
&szProblem,
szInfo,
uProblemId);
}
else
{
dwRet = LoadAndFormatStringsCat(hDllInstance,
StringIDs,
sizeof(StringIDs) / sizeof(StringIDs[0]),
&szProblem,
uProblemId);
}
if (dwRet != 0)
{
if (uMaxString != 0 && uMaxString >= dwRet)
{
wcscpy(lpString,
szProblem);
}
LocalFree((HLOCAL)szProblem);
Ret = dwRet;
}
}
return Ret;
}

File diff suppressed because it is too large Load diff

View file

@ -1,381 +0,0 @@
/*
* PROJECT: ReactOS devmgr.dll
* FILE: dll/win32/devmgr/hwresource.c
* PURPOSE: ReactOS Device Manager
* PROGRAMMER: Johannes Anderwald <johannes.anderwald@reactos.org>
* UPDATE HISTORY:
* 2005/11/24 Created
*/
#include "precomp.h"
typedef struct
{
HWND hWnd;
HWND hWndDevList;
}HARDWARE_RESOURCE_DATA, *PHARDWARE_RESOURCE_DATA;
/* Physical Addresses are always treated as 64-bit wide */
typedef LARGE_INTEGER PHYSICAL_ADDRESS, *PPHYSICAL_ADDRESS;
#include <pshpack4.h>
typedef struct _CM_PARTIAL_RESOURCE_DESCRIPTOR {
UCHAR Type;
UCHAR ShareDisposition;
USHORT Flags;
union {
struct {
PHYSICAL_ADDRESS Start;
ULONG Length;
} Generic;
struct {
PHYSICAL_ADDRESS Start;
ULONG Length;
} Port;
struct {
#if defined(NT_PROCESSOR_GROUPS)
USHORT Level;
USHORT Group;
#else
ULONG Level;
#endif
ULONG Vector;
KAFFINITY Affinity;
} Interrupt;
#if (NTDDI_VERSION >= NTDDI_LONGHORN)
struct {
_ANONYMOUS_UNION union {
struct {
#if defined(NT_PROCESSOR_GROUPS)
USHORT Group;
#else
USHORT Reserved;
#endif
USHORT MessageCount;
ULONG Vector;
KAFFINITY Affinity;
} Raw;
struct {
#if defined(NT_PROCESSOR_GROUPS)
USHORT Level;
USHORT Group;
#else
ULONG Level;
#endif
ULONG Vector;
KAFFINITY Affinity;
} Translated;
} DUMMYUNIONNAME;
} MessageInterrupt;
#endif
struct {
PHYSICAL_ADDRESS Start;
ULONG Length;
} Memory;
struct {
ULONG Channel;
ULONG Port;
ULONG Reserved1;
} Dma;
struct {
ULONG Data[3];
} DevicePrivate;
struct {
ULONG Start;
ULONG Length;
ULONG Reserved;
} BusNumber;
struct {
ULONG DataSize;
ULONG Reserved1;
ULONG Reserved2;
} DeviceSpecificData;
#if (NTDDI_VERSION >= NTDDI_LONGHORN)
struct {
PHYSICAL_ADDRESS Start;
ULONG Length40;
} Memory40;
struct {
PHYSICAL_ADDRESS Start;
ULONG Length48;
} Memory48;
struct {
PHYSICAL_ADDRESS Start;
ULONG Length64;
} Memory64;
#endif
} u;
} CM_PARTIAL_RESOURCE_DESCRIPTOR, *PCM_PARTIAL_RESOURCE_DESCRIPTOR;
#include <poppack.h>
typedef struct _CM_PARTIAL_RESOURCE_LIST {
USHORT Version;
USHORT Revision;
ULONG Count;
CM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptors[1];
} CM_PARTIAL_RESOURCE_LIST, *PCM_PARTIAL_RESOURCE_LIST;
#define CmResourceTypeNull 0
#define CmResourceTypePort 1
#define CmResourceTypeInterrupt 2
#define CmResourceTypeMemory 3
#define CmResourceTypeDma 4
#define CmResourceTypeDeviceSpecific 5
#define CmResourceTypeBusNumber 6
#define CmResourceTypeNonArbitrated 128
#define CmResourceTypeConfigData 128
#define CmResourceTypeDevicePrivate 129
#define CmResourceTypePcCardConfig 130
#define CmResourceTypeMfCardConfig 131
typedef enum _INTERFACE_TYPE {
InterfaceTypeUndefined = -1,
Internal,
Isa,
Eisa,
MicroChannel,
TurboChannel,
PCIBus,
VMEBus,
NuBus,
PCMCIABus,
CBus,
MPIBus,
MPSABus,
ProcessorInternal,
InternalPowerBus,
PNPISABus,
PNPBus,
Vmcs,
MaximumInterfaceType
} INTERFACE_TYPE, *PINTERFACE_TYPE;
typedef struct _CM_FULL_RESOURCE_DESCRIPTOR {
INTERFACE_TYPE InterfaceType;
ULONG BusNumber;
CM_PARTIAL_RESOURCE_LIST PartialResourceList;
} CM_FULL_RESOURCE_DESCRIPTOR, *PCM_FULL_RESOURCE_DESCRIPTOR;
typedef struct _CM_RESOURCE_LIST {
ULONG Count;
CM_FULL_RESOURCE_DESCRIPTOR List[1];
} CM_RESOURCE_LIST, *PCM_RESOURCE_LIST;
#define CX_TYPECOLUMN_WIDTH 120
static VOID
InitializeDevicesList(
IN HWND hWndDevList)
{
LVCOLUMN lvc;
RECT rcClient;
WCHAR szColName[255];
int iCol = 0;
/* set the list view style */
(void)ListView_SetExtendedListViewStyle(hWndDevList,
LVS_EX_FULLROWSELECT);
GetClientRect(hWndDevList,
&rcClient);
/* add the list view columns */
lvc.mask = LVCF_TEXT | LVCF_WIDTH;
lvc.fmt = LVCFMT_LEFT;
lvc.pszText = szColName;
if (LoadString(hDllInstance,
IDS_RESOURCE_COLUMN,
szColName,
sizeof(szColName) / sizeof(szColName[0])))
{
lvc.cx = CX_TYPECOLUMN_WIDTH;
(void)ListView_InsertColumn(hWndDevList,
iCol++,
&lvc);
}
if (LoadString(hDllInstance,
IDS_SETTING_COLUMN,
szColName,
sizeof(szColName) / sizeof(szColName[0])))
{
lvc.cx = rcClient.right - CX_TYPECOLUMN_WIDTH -
GetSystemMetrics(SM_CXVSCROLL);
(void)ListView_InsertColumn(hWndDevList,
iCol++,
&lvc);
}
}
VOID
InsertListItem(
IN HWND hWndDevList,
IN INT ItemCount,
IN LPWSTR ResourceType,
IN LPWSTR ResourceDescription)
{
INT iItem;
LVITEM li = {0};
li.mask = LVIF_STATE | LVIF_TEXT;
li.iItem = ItemCount;
li.pszText = ResourceType;
//li.iImage = ClassDevInfo->ImageIndex;
iItem = ListView_InsertItem(hWndDevList, &li);
if (iItem != -1)
{
li.mask = LVIF_TEXT;
li.iItem = iItem;
li.iSubItem = 1;
li.pszText = ResourceDescription;
(void)ListView_SetItem(hWndDevList, &li);
}
}
VOID
AddResourceItems(
IN PDEVADVPROP_INFO dap,
IN HWND hWndDevList)
{
HKEY hKey;
WCHAR szBuffer[100];
WCHAR szDetail[100];
BYTE szData[512];
DWORD dwSize;
PCM_RESOURCE_LIST ResourceList;
LONG Result;
ULONG ItemCount = 0, Index;
wsprintf(szBuffer, L"SYSTEM\\CurrentControlSet\\Enum\\%s\\LogConf", dap->szDeviceID);
Result = RegOpenKeyExW(HKEY_LOCAL_MACHINE, szBuffer, 0, KEY_READ, &hKey);
if (Result != ERROR_SUCCESS)
{
/* failed to open device instance log conf dir */
return;
}
dwSize = sizeof(szData);
Result = RegQueryValueExW(hKey, L"BootConfig", NULL, NULL, szData, &dwSize);
RegCloseKey(hKey);
if (Result != ERROR_SUCCESS)
{
/* failed to query resources */
return;
}
ResourceList = (PCM_RESOURCE_LIST)szData;
for (Index = 0; Index < ResourceList->List[0].PartialResourceList.Count; Index++)
{
PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor = &ResourceList->List[0].PartialResourceList.PartialDescriptors[Index];
if (Descriptor->Type == CmResourceTypeInterrupt)
{
if (LoadString(hDllInstance, IDS_RESOURCE_INTERRUPT, szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0])))
{
wsprintf(szDetail, L"0x%08x (%d)", Descriptor->u.Interrupt.Level, Descriptor->u.Interrupt.Vector);
InsertListItem(hWndDevList, ItemCount, szBuffer, szDetail);
ItemCount++;
}
}
else if (Descriptor->Type == CmResourceTypePort)
{
if (LoadString(hDllInstance, IDS_RESOURCE_PORT, szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0])))
{
wsprintf(szDetail, L"%08lx - %08lx", Descriptor->u.Port.Start.LowPart, Descriptor->u.Port.Start.LowPart + Descriptor->u.Port.Length - 1);
InsertListItem(hWndDevList, ItemCount, szBuffer, szDetail);
ItemCount++;
}
}
else if (Descriptor->Type == CmResourceTypeMemory)
{
if (LoadString(hDllInstance, IDS_RESOURCE_MEMORY_RANGE, szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0])))
{
wsprintf(szDetail, L"%08I64x - %08I64x", Descriptor->u.Memory.Start.QuadPart, Descriptor->u.Memory.Start.QuadPart + Descriptor->u.Memory.Length - 1);
InsertListItem(hWndDevList, ItemCount, szBuffer, szDetail);
ItemCount++;
}
}
else if (Descriptor->Type == CmResourceTypeDma)
{
if (LoadString(hDllInstance, IDS_RESOURCE_DMA, szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0])))
{
wsprintf(szDetail, L"%08ld", Descriptor->u.Dma.Channel);
InsertListItem(hWndDevList, ItemCount, szBuffer, szDetail);
ItemCount++;
}
}
}
}
static VOID
UpdateDriverResourceDlg(IN HWND hwndDlg,
IN PDEVADVPROP_INFO dap)
{
/* set the device image */
SendDlgItemMessage(hwndDlg,
IDC_DEVICON,
STM_SETICON,
(WPARAM)dap->hDevIcon,
0);
/* set the device name edit control text */
SetDlgItemText(hwndDlg,
IDC_DEVNAME,
dap->szDevName);
}
INT_PTR
CALLBACK
ResourcesProcDriverDlgProc(IN HWND hwndDlg,
IN UINT uMsg,
IN WPARAM wParam,
IN LPARAM lParam)
{
PDEVADVPROP_INFO hpd;
HWND hWndDevList;
INT_PTR Ret = FALSE;
hpd = (PDEVADVPROP_INFO)GetWindowLongPtr(hwndDlg,
DWL_USER);
if (hpd != NULL || uMsg == WM_INITDIALOG)
{
switch (uMsg)
{
case WM_INITDIALOG:
{
/* init list */
hWndDevList = GetDlgItem(hwndDlg, IDC_DRIVERRESOURCES);
InitializeDevicesList(hWndDevList);
hpd = (PDEVADVPROP_INFO)((LPPROPSHEETPAGE)lParam)->lParam;
if (hpd != NULL)
{
SetWindowLongPtr(hwndDlg,
DWL_USER,
(DWORD_PTR)hpd);
SetWindowLongPtr(hwndDlg,
DWL_USER,
(DWORD_PTR)hpd);
UpdateDriverResourceDlg(hwndDlg, hpd);
AddResourceItems(hpd, hWndDevList);
}
Ret = TRUE;
break;
}
}
}
return Ret;
}

File diff suppressed because it is too large Load diff

Binary file not shown.

Before

Width:  |  Height:  |  Size: 7.8 KiB

View file

@ -1,257 +0,0 @@
/*
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS devmgr.dll
* FILE: lib/devmgr/stubs.c
* PURPOSE: devmgr.dll stubs
* PROGRAMMER: Thomas Weidenmueller (w3seek@users.sourceforge.net)
* NOTES: If you implement a function, remove it from this file
*
* Some helpful resources:
* http://support.microsoft.com/default.aspx?scid=kb;%5BLN%5D;815320
* http://www.jsiinc.com/SUBO/tip7400/rh7482.htm
* http://www.jsiinc.com/SUBM/tip6400/rh6490.htm
*
* UPDATE HISTORY:
* 04-04-2004 Created
*/
#include "precomp.h"
/***************************************************************************
* NAME EXPORTED
* DeviceManager_ExecuteA
*
* DESCRIPTION
* Starts the Device Manager
*
* ARGUMENTS
* hWndParent: Handle to the parent window
* hInst: Handle to the application instance
* lpMachineName: Machine Name, NULL is the local machine
* nCmdShow: Specifies how the window should be shown
*
* RETURN VALUE
* TRUE: if no errors occured
* FALSE: if the device manager could not be executed
*
* REVISIONS
*
* NOTE
* - Win runs the device manager in a separate process, so hWndParent is somehow
* obsolete.
*
* @unimplemented
*/
BOOL
WINAPI
DeviceManager_ExecuteA(HWND hWndParent,
HINSTANCE hInst,
LPCSTR lpMachineName,
int nCmdShow)
{
UNIMPLEMENTED;
return FALSE;
}
/***************************************************************************
* NAME EXPORTED
* DeviceManager_ExecuteW
*
* DESCRIPTION
* Starts the Device Manager
*
* ARGUMENTS
* hWndParent: Handle to the parent window
* hInst: Handle to the application instance
* lpMachineName: Machine Name, NULL is the local machine
* nCmdShow: Specifies how the window should be shown
*
* RETURN VALUE
* TRUE: if no errors occured
* FALSE: if the device manager could not be executed
*
* REVISIONS
*
* NOTE
* - Win runs the device manager in a separate process, so hWndParent is somehow
* obsolete.
*
* @unimplemented
*/
BOOL
WINAPI
DeviceManager_ExecuteW(HWND hWndParent,
HINSTANCE hInst,
LPCWSTR lpMachineName,
int nCmdShow)
{
UNIMPLEMENTED;
return FALSE;
}
/***************************************************************************
* NAME EXPORTED
* DeviceProblemWizard_RunDLLA
*
* DESCRIPTION
* Calls the device problem wizard
*
* ARGUMENTS
* hWndParent: Handle to the parent window
* hInst: Handle to the application instance
* lpDeviceCmd: A command that includes the DeviceID of the properties to be shown,
* also see NOTEs
* nCmdShow: Specifies how the window should be shown
*
* RETURN VALUE
*
* REVISIONS
*
* NOTE
* - Win XP exports this function as DeviceProblenWizard_RunDLLA, apparently it's
* a typo so we additionally export an alias function
* - lpDeviceCmd is a string in the form of "/MachineName MACHINE /DeviceID DEVICEPATH"
* (/MachineName is optional). This function only parses this string and eventually
* calls DeviceProperties().
*
* @unimplemented
*/
VOID
WINAPI
DeviceProblemWizard_RunDLLA(HWND hWndParent,
HINSTANCE hInst,
LPCSTR lpDeviceCmd,
int nCmdShow)
{
UNIMPLEMENTED;
}
/***************************************************************************
* NAME EXPORTED
* DeviceProblemWizard_RunDLLW
*
* DESCRIPTION
* Calls the device problem wizard
*
* ARGUMENTS
* hWndParent: Handle to the parent window
* hInst: Handle to the application instance
* lpDeviceCmd: A command that includes the DeviceID of the properties to be shown,
* also see NOTEs
* nCmdShow: Specifies how the window should be shown
*
* RETURN VALUE
*
* REVISIONS
*
* NOTE
* - Win XP exports this function as DeviceProblenWizard_RunDLLA, apparently it's
* a typo so we additionally export an alias function
* - lpDeviceCmd is a string in the form of "/MachineName MACHINE /DeviceID DEVICEPATH"
* (/MachineName is optional). This function only parses this string and eventually
* calls DeviceProperties().
*
* @unimplemented
*/
VOID
WINAPI
DeviceProblemWizard_RunDLLW(HWND hWndParent,
HINSTANCE hInst,
LPCWSTR lpDeviceCmd,
int nCmdShow)
{
UNIMPLEMENTED;
}
/***************************************************************************
* NAME EXPORTED
* DeviceManagerPrintA
*
* DESCRIPTION
* Calls the device problem wizard
*
* ARGUMENTS
* lpMachineName: Machine Name, NULL is the local machine
* lpPrinter: Filename of the printer where it should be printed on
* nPrintMode: Specifies what kind of information is to be printed
* DEV_PRINT_ABSTRACT: Prints an abstract of system information, the parameters
* uNumberOfGuids, Guids are ignored
* DEV_PRINT_SELECTED: Prints information about the devices listed in Guids
* DEV_PRINT_ALL: Prints an abstract of system information and all
* system devices
* uNumberOfGuids: Numbers of guids in the Guids array, this parameter is ignored unless
* nPrintMode is DEV_PRINT_SELECTED
* lpGuids: Array of device guids, this parameter is ignored unless
* nPrintMode is DEV_PRINT_SELECTED
*
* RETURN VALUE
* TRUE: if no errors occured
* FALSE: if errors occured
*
* REVISIONS
*
* NOTE
*
* @unimplemented
*/
BOOL
WINAPI
DeviceManagerPrintA(LPCSTR lpMachineName,
LPCSTR lpPrinter,
int nPrintMode,
UINT uNumberOfGuids,
LPGUID lpGuids)
{
UNIMPLEMENTED;
return FALSE;
}
/***************************************************************************
* NAME EXPORTED
* DeviceManagerPrintW
*
* DESCRIPTION
* Calls the device problem wizard
*
* ARGUMENTS
* lpMachineName: Machine Name, NULL is the local machine
* lpPrinter: Filename of the printer where it should be printed on
* nPrintMode: Specifies what kind of information is to be printed
* DEV_PRINT_ABSTRACT: Prints an abstract of system information, the parameters
* uNumberOfGuids, Guids are ignored
* DEV_PRINT_SELECTED: Prints information about the devices listed in Guids
* DEV_PRINT_ALL: Prints an abstract of system information and all
* system devices
* uNumberOfGuids: Numbers of guids in the Guids array, this parameter is ignored unless
* nPrintMode is DEV_PRINT_SELECTED
* lpGuids: Array of device guids, this parameter is ignored unless
* nPrintMode is DEV_PRINT_SELECTED
*
* RETURN VALUE
* TRUE: if no errors occured
* FALSE: if errors occured
*
* REVISIONS
*
* NOTE
*
* @unimplemented
*/
BOOL
WINAPI
DeviceManagerPrintW(LPCWSTR lpMachineName,
LPCWSTR lpPrinter,
int nPrintMode,
UINT uNumberOfGuids,
LPGUID lpGuids)
{
UNIMPLEMENTED;
return FALSE;
}

View file

@ -1,57 +0,0 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS WinSock 2 DLL
* FILE: dll/win32/ws2_32/include/catalog.h
* PURPOSE: Service Provider Catalog definitions
*/
#ifndef __CATALOG_H
#define __CATALOG_H
typedef struct _CATALOG_ENTRY
{
LIST_ENTRY ListEntry;
ULONG ReferenceCount;
CRITICAL_SECTION Lock;
UNICODE_STRING LibraryName;
HMODULE hModule;
WSAPROTOCOL_INFOW ProtocolInfo;
PWINSOCK_MAPPING Mapping;
LPWSPSTARTUP WSPStartup;
WSPDATA WSPData;
WSPPROC_TABLE ProcTable;
} CATALOG_ENTRY, *PCATALOG_ENTRY;
extern LIST_ENTRY Catalog;
VOID ReferenceProviderByPointer(
PCATALOG_ENTRY Provider);
VOID DereferenceProviderByPointer(
PCATALOG_ENTRY Provider);
PCATALOG_ENTRY CreateCatalogEntry(
LPWSTR LibraryName);
INT DestroyCatalogEntry(
PCATALOG_ENTRY Provider);
PCATALOG_ENTRY LocateProvider(
LPWSAPROTOCOL_INFOW lpProtocolInfo);
PCATALOG_ENTRY LocateProviderById(
DWORD CatalogEntryId);
INT LoadProvider(
PCATALOG_ENTRY Provider,
LPWSAPROTOCOL_INFOW lpProtocolInfo);
INT UnloadProvider(
PCATALOG_ENTRY Provider);
VOID CreateCatalog(VOID);
VOID DestroyCatalog(VOID);
#endif /* __CATALOG_H */

View file

@ -1,66 +0,0 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS WinSock 2 DLL
* FILE: dll/win32/ws2_32/include/debug.h
* PURPOSE: Debugging support macros
* DEFINES: DBG - Enable debug output
* NASSERT - Disable assertions
*/
#ifndef __DEBUG_H
#define __DEBUG_H
#define NORMAL_MASK 0x000000FF
#define SPECIAL_MASK 0xFFFFFF00
#define MIN_TRACE 0x00000001
#define MID_TRACE 0x00000002
#define MAX_TRACE 0x00000003
#define DEBUG_CHECK 0x00000100
#define DEBUG_ULTRA 0xFFFFFFFF
#ifdef ASSERT
#undef ASSERT
#endif
#if DBG
extern DWORD DebugTraceLevel;
#define WS_DbgPrint(_t_, _x_) \
if ((_t_ > NORMAL_MASK) \
? (DebugTraceLevel & _t_) > NORMAL_MASK \
: (DebugTraceLevel & NORMAL_MASK) >= _t_) { \
DbgPrint("(%hS:%d)(%hS) ", __FILE__, __LINE__, __FUNCTION__); \
DbgPrint _x_; \
}
#ifdef NASSERT
#define ASSERT(x)
#else /* NASSERT */
#define ASSERT(x) if (!(x)) { WS_DbgPrint(MIN_TRACE, ("Assertion "#x" failed at %s:%d\n", __FILE__, __LINE__)); ExitProcess(0); }
#endif /* NASSERT */
#else /* DBG */
#define WS_DbgPrint(_t_, _x_)
#define ASSERT_IRQL(x)
#define ASSERT(x)
#endif /* DBG */
#define assert(x) ASSERT(x)
#define assert_irql(x) ASSERT_IRQL(x)
#define UNIMPLEMENTED \
WS_DbgPrint(MIN_TRACE, ("is unimplemented, please try again later.\n"));
#define CHECKPOINT \
WS_DbgPrint(DEBUG_CHECK, ("\n"));
#define CP CHECKPOINT
#endif /* __DEBUG_H */

View file

@ -1,45 +0,0 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS WinSock 2 DLL
* FILE: dll/win32/ws2_32/include/handle.h
* PURPOSE: Provider handle definitions
*/
#ifndef __HANDLE_H
#define __HANDLE_H
typedef struct _PROVIDER_HANDLE
{
HANDLE Handle;
PCATALOG_ENTRY Provider;
} PROVIDER_HANDLE, *PPROVIDER_HANDLE;
#define HANDLE_BLOCK_ENTRIES ((1024-sizeof(LIST_ENTRY))/sizeof(PROVIDER_HANDLE))
typedef struct _PROVIDER_HANDLE_BLOCK
{
LIST_ENTRY Entry;
PROVIDER_HANDLE Handles[HANDLE_BLOCK_ENTRIES];
} PROVIDER_HANDLE_BLOCK, *PPROVIDER_HANDLE_BLOCK;
extern PPROVIDER_HANDLE_BLOCK ProviderHandleTable;
HANDLE
CreateProviderHandle(HANDLE Handle,
PCATALOG_ENTRY Provider);
BOOL
ReferenceProviderByHandle(HANDLE Handle,
PCATALOG_ENTRY* Provider);
BOOL
CloseProviderHandle(HANDLE Handle);
BOOL
InitProviderHandleTable(VOID);
VOID
FreeProviderHandleTable(VOID);
#endif /* __HANDLE_H */

View file

@ -1,103 +0,0 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS WinSock 2 DLL
* FILE: dll/win32/ws2_32/include/upcall.h
* PURPOSE: Upcall function defintions
*/
#ifndef __UPCALL_H
#define __UPCALL_H
BOOL
WSPAPI
WPUCloseEvent(
IN WSAEVENT hEvent,
OUT LPINT lpErrno);
INT
WSPAPI
WPUCloseSocketHandle(
IN SOCKET s,
OUT LPINT lpErrno);
INT
WSPAPI
WPUCloseThread(
IN LPWSATHREADID lpThreadId,
OUT LPINT lpErrno);
WSAEVENT
WSPAPI
WPUCreateEvent(
OUT LPINT lpErrno);
SOCKET
WSPAPI
WPUCreateSocketHandle(
IN DWORD dwCatalogEntryId,
IN DWORD_PTR dwContext,
OUT LPINT lpErrno);
int
WSPAPI
WPUFDIsSet(
IN SOCKET s,
IN LPFD_SET set);
INT
WSPAPI
WPUGetProviderPath(
IN LPGUID lpProviderId,
OUT LPWSTR lpszProviderDllPath,
IN OUT LPINT lpProviderDllPathLen,
OUT LPINT lpErrno);
SOCKET
WSPAPI
WPUModifyIFSHandle(
IN DWORD dwCatalogEntryId,
IN SOCKET ProposedHandle,
OUT LPINT lpErrno);
INT
WSPAPI
WPUOpenCurrentThread(
OUT LPWSATHREADID lpThreadId,
OUT LPINT lpErrno);
INT
WSPAPI
WPUQueryBlockingCallback(
IN DWORD dwCatalogEntryId,
OUT LPBLOCKINGCALLBACK FAR* lplpfnCallback,
OUT PDWORD_PTR lpdwContext,
OUT LPINT lpErrno);
INT
WSPAPI
WPUQuerySocketHandleContext(
IN SOCKET s,
OUT PDWORD_PTR lpContext,
OUT LPINT lpErrno);
INT
WSPAPI
WPUQueueApc(
IN LPWSATHREADID lpThreadId,
IN LPWSAUSERAPC lpfnUserApc,
IN DWORD_PTR dwContext,
OUT LPINT lpErrno);
BOOL
WSPAPI
WPUResetEvent(
IN WSAEVENT hEvent,
OUT LPINT lpErrno);
BOOL
WSPAPI
WPUSetEvent(
IN WSAEVENT hEvent,
OUT LPINT lpErrno);
#endif /* __UPCALL_H */

View file

@ -1,130 +0,0 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS WinSock 2 DLL
* FILE: dll/win32/ws2_32/include/ws2_32.h
* PURPOSE: WinSock 2 DLL header
*/
#ifndef __WS2_32_H
#define __WS2_32_H
#include <stdarg.h>
#define WIN32_NO_STATUS
#define _INC_WINDOWS
#define COM_NO_WINDOWS_H
#include <windef.h>
#include <winbase.h>
#include <winnls.h>
#include <winuser.h>
#include <ws2spi.h>
#define NTOS_MODE_USER
#include <ndk/rtlfuncs.h>
#include <pseh/pseh2.h>
#include <wsahelp.h>
#undef assert
#include <debug.h>
#include <windns.h> // DNS_A_DATA
#include "catalog.h"
#include "handle.h"
#define EXPORT WINAPI
extern HINSTANCE g_hInstDll;
extern HANDLE GlobalHeap;
extern BOOL WsaInitialized; /* TRUE if WSAStartup() has been successfully called */
extern WSPUPCALLTABLE UpcallTable;
#define WS2_INTERNAL_MAX_ALIAS 16
typedef struct _WINSOCK_GETSERVBYNAME_CACHE
{
UINT Size;
SERVENT ServerEntry;
PCHAR Aliases[WS2_INTERNAL_MAX_ALIAS];
CHAR Data[1];
} WINSOCK_GETSERVBYNAME_CACHE, *PWINSOCK_GETSERVBYNAME_CACHE;
typedef struct _WINSOCK_GETSERVBYPORT_CACHE
{
UINT Size;
SERVENT ServerEntry;
PCHAR Aliases[WS2_INTERNAL_MAX_ALIAS];
CHAR Data[1];
} WINSOCK_GETSERVBYPORT_CACHE, *PWINSOCK_GETSERVBYPORT_CACHE;
typedef struct _WINSOCK_THREAD_BLOCK
{
INT LastErrorValue; /* Error value from last function that failed */
CHAR Intoa[16]; /* Buffer for inet_ntoa() */
PWINSOCK_GETSERVBYNAME_CACHE
Getservbyname; /* Buffer used by getservbyname */
PWINSOCK_GETSERVBYPORT_CACHE
Getservbyport; /* Buffer used by getservbyname */
struct hostent* Hostent;
} WINSOCK_THREAD_BLOCK, *PWINSOCK_THREAD_BLOCK;
/* Macros */
#define WSAINITIALIZED (WsaInitialized)
#define WSASETINITIALIZED (WsaInitialized = TRUE)
/* ws2_32 internal Functions */
void check_hostent(struct hostent **he);
void populate_hostent(struct hostent *he, char* name, IP4_ADDRESS addr);
void free_hostent(struct hostent *he);
void free_servent(struct servent* s);
#ifdef LE
/* DWORD network to host byte order conversion for little endian machines */
#define DN2H(dw) \
((((dw) & 0xFF000000L) >> 24) | \
(((dw) & 0x00FF0000L) >> 8) | \
(((dw) & 0x0000FF00L) << 8) | \
(((dw) & 0x000000FFL) << 24))
/* DWORD host to network byte order conversion for little endian machines */
#define DH2N(dw) \
((((dw) & 0xFF000000L) >> 24) | \
(((dw) & 0x00FF0000L) >> 8) | \
(((dw) & 0x0000FF00L) << 8) | \
(((dw) & 0x000000FFL) << 24))
/* WORD network to host order conversion for little endian machines */
#define WN2H(w) \
((((w) & 0xFF00) >> 8) | \
(((w) & 0x00FF) << 8))
/* WORD host to network byte order conversion for little endian machines */
#define WH2N(w) \
((((w) & 0xFF00) >> 8) | \
(((w) & 0x00FF) << 8))
#else /* LE */
/* DWORD network to host byte order conversion for big endian machines */
#define DN2H(dw) \
(dw)
/* DWORD host to network byte order conversion big endian machines */
#define DH2N(dw) \
(dw)
/* WORD network to host order conversion for big endian machines */
#define WN2H(w) \
(w)
/* WORD host to network byte order conversion for big endian machines */
#define WH2N(w) \
(w)
#endif /* LE */
#endif /* __WS2_32_H */

View file

@ -1,56 +0,0 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS WinSock 2 DLL
* FILE: dll/win32/ws2_32/misc/bsd.c
* PURPOSE: Legacy BSD sockets APIs
* PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
* REVISIONS:
* CSH 15/06-2001 Created
*/
#include "ws2_32.h"
/*
* @implemented
*/
ULONG
EXPORT
htonl(IN ULONG hostlong)
{
return DH2N(hostlong);
}
/*
* @implemented
*/
USHORT
EXPORT
htons(IN USHORT hostshort)
{
return WH2N(hostshort);
}
/*
* @implemented
*/
ULONG
EXPORT
ntohl(IN ULONG netlong)
{
return DN2H(netlong);
}
/*
* @implemented
*/
USHORT
EXPORT
ntohs(IN USHORT netshort)
{
return WN2H(netshort);
}
/* EOF */

View file

@ -1,355 +0,0 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS WinSock 2 DLL
* FILE: dll/win32/ws2_32/misc/catalog.c
* PURPOSE: Service Provider Catalog
* PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
* REVISIONS:
* CSH 01/09-2000 Created
*/
#include "ws2_32.h"
LIST_ENTRY CatalogListHead;
CRITICAL_SECTION CatalogLock;
VOID
ReferenceProviderByPointer(PCATALOG_ENTRY Provider)
{
WS_DbgPrint(MAX_TRACE, ("Provider (0x%X).\n", Provider));
//EnterCriticalSection(&Provider->Lock);
Provider->ReferenceCount++;
//LeaveCriticalSection(&Provider->Lock);
WS_DbgPrint(MAX_TRACE, ("Leaving\n"));
}
VOID
DereferenceProviderByPointer(PCATALOG_ENTRY Provider)
{
WS_DbgPrint(MAX_TRACE, ("Provider (0x%X).\n", Provider));
#if DBG
if (Provider->ReferenceCount <= 0)
{
WS_DbgPrint(MIN_TRACE, ("Provider at 0x%X has invalid reference count (%ld).\n",
Provider, Provider->ReferenceCount));
}
#endif
//EnterCriticalSection(&Provider->Lock);
Provider->ReferenceCount--;
//LeaveCriticalSection(&Provider->Lock);
if (Provider->ReferenceCount == 0)
{
WS_DbgPrint(MAX_TRACE, ("Provider at 0x%X has reference count 0 (unloading).\n",
Provider));
DestroyCatalogEntry(Provider);
}
}
PCATALOG_ENTRY
CreateCatalogEntry(LPWSTR LibraryName)
{
PCATALOG_ENTRY Provider;
WS_DbgPrint(MAX_TRACE, ("LibraryName (%S).\n", LibraryName));
Provider = HeapAlloc(GlobalHeap, 0, sizeof(CATALOG_ENTRY));
if (!Provider)
return NULL;
ZeroMemory(Provider, sizeof(CATALOG_ENTRY));
if (!RtlCreateUnicodeString(&Provider->LibraryName, LibraryName))
{
HeapFree(GlobalHeap, 0, Provider);
return NULL;
}
Provider->ReferenceCount = 1;
InitializeCriticalSection(&Provider->Lock);
Provider->hModule = NULL;
Provider->Mapping = NULL;
//EnterCriticalSection(&CatalogLock);
InsertTailList(&CatalogListHead, &Provider->ListEntry);
//LeaveCriticalSection(&CatalogLock);
return Provider;
}
INT
DestroyCatalogEntry(PCATALOG_ENTRY Provider)
{
INT Status;
WS_DbgPrint(MAX_TRACE, ("Provider (0x%X).\n", Provider));
//EnterCriticalSection(&CatalogLock);
RemoveEntryList(&Provider->ListEntry);
//LeaveCriticalSection(&CatalogLock);
HeapFree(GlobalHeap, 0, Provider->Mapping);
if (NULL != Provider->hModule)
{
Status = UnloadProvider(Provider);
}
else
{
Status = NO_ERROR;
}
//DeleteCriticalSection(&Provider->Lock);
HeapFree(GlobalHeap, 0, Provider);
return Status;
}
PCATALOG_ENTRY
LocateProvider(LPWSAPROTOCOL_INFOW lpProtocolInfo)
{
PLIST_ENTRY CurrentEntry;
PCATALOG_ENTRY Provider;
UINT i;
WS_DbgPrint(MAX_TRACE, ("lpProtocolInfo (0x%X).\n", lpProtocolInfo));
//EnterCriticalSection(&CatalogLock);
CurrentEntry = CatalogListHead.Flink;
while (CurrentEntry != &CatalogListHead)
{
Provider = CONTAINING_RECORD(CurrentEntry,
CATALOG_ENTRY,
ListEntry);
for (i = 0; i < Provider->Mapping->Rows; i++)
{
if ((lpProtocolInfo->iAddressFamily == (INT) Provider->Mapping->Mapping[i].AddressFamily) &&
(lpProtocolInfo->iSocketType == (INT) Provider->Mapping->Mapping[i].SocketType) &&
((lpProtocolInfo->iProtocol == (INT) Provider->Mapping->Mapping[i].Protocol) ||
(lpProtocolInfo->iSocketType == SOCK_RAW)))
{
//LeaveCriticalSection(&CatalogLock);
lpProtocolInfo->dwCatalogEntryId = Provider->ProtocolInfo.dwCatalogEntryId;
WS_DbgPrint(MID_TRACE, ("Returning provider at (0x%X).\n", Provider));
return Provider;
}
}
CurrentEntry = CurrentEntry->Flink;
}
//LeaveCriticalSection(&CatalogLock);
return NULL;
}
PCATALOG_ENTRY
LocateProviderById(DWORD CatalogEntryId)
{
PLIST_ENTRY CurrentEntry;
PCATALOG_ENTRY Provider;
WS_DbgPrint(MAX_TRACE, ("CatalogEntryId (%d).\n", CatalogEntryId));
//EnterCriticalSection(&CatalogLock);
CurrentEntry = CatalogListHead.Flink;
while (CurrentEntry != &CatalogListHead)
{
Provider = CONTAINING_RECORD(CurrentEntry,
CATALOG_ENTRY,
ListEntry);
if (Provider->ProtocolInfo.dwCatalogEntryId == CatalogEntryId)
{
//LeaveCriticalSection(&CatalogLock);
WS_DbgPrint(MID_TRACE, ("Returning provider at (0x%X) Name (%wZ).\n",
Provider, &Provider->LibraryName));
return Provider;
}
CurrentEntry = CurrentEntry->Flink;
}
//LeaveCriticalSection(&CatalogLock);
WS_DbgPrint(MID_TRACE, ("Provider was not found.\n"));
return NULL;
}
INT
LoadProvider(PCATALOG_ENTRY Provider,
LPWSAPROTOCOL_INFOW lpProtocolInfo)
{
INT Status;
WS_DbgPrint(MID_TRACE, ("Loading provider at (0x%X) Name (%wZ).\n",
Provider, &Provider->LibraryName));
if (NULL == Provider->hModule)
{
/* DLL is not loaded so load it now
* UNICODE_STRING objects are not null-terminated, but LoadLibraryW
* expects a null-terminated string
*/
Provider->LibraryName.Buffer[Provider->LibraryName.Length / sizeof(WCHAR)] = L'\0';
Provider->hModule = LoadLibraryW(Provider->LibraryName.Buffer);
if (NULL != Provider->hModule)
{
Provider->WSPStartup = (LPWSPSTARTUP)GetProcAddress(Provider->hModule,
"WSPStartup");
if (Provider->WSPStartup)
{
WS_DbgPrint(MAX_TRACE, ("Calling WSPStartup at (0x%X).\n",
Provider->WSPStartup));
Status = Provider->WSPStartup(MAKEWORD(2, 2),
&Provider->WSPData,
lpProtocolInfo,
UpcallTable,
&Provider->ProcTable);
/* FIXME: Validate the procedure table */
}
else
Status = ERROR_BAD_PROVIDER;
}
else
Status = ERROR_DLL_NOT_FOUND;
}
else
Status = NO_ERROR;
WS_DbgPrint(MID_TRACE, ("Status (%d).\n", Status));
return Status;
}
INT
UnloadProvider(PCATALOG_ENTRY Provider)
{
INT Status = NO_ERROR;
WS_DbgPrint(MAX_TRACE, ("Unloading provider at (0x%X)\n", Provider));
if (NULL != Provider->hModule)
{
WS_DbgPrint(MAX_TRACE, ("Calling WSPCleanup at (0x%X).\n",
Provider->ProcTable.lpWSPCleanup));
Provider->ProcTable.lpWSPCleanup(&Status);
WS_DbgPrint(MAX_TRACE, ("Calling FreeLibrary(0x%X).\n", Provider->hModule));
if (!FreeLibrary(Provider->hModule))
{
WS_DbgPrint(MIN_TRACE, ("Could not free library at (0x%X).\n", Provider->hModule));
Status = GetLastError();
}
Provider->hModule = NULL;
}
WS_DbgPrint(MAX_TRACE, ("Status (%d).\n", Status));
return Status;
}
VOID
CreateCatalog(VOID)
{
PCATALOG_ENTRY Provider;
InitializeCriticalSection(&CatalogLock);
InitializeListHead(&CatalogListHead);
/* FIXME: Read service provider catalog from registry
Catalog info is saved somewhere under
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\WinSock2
*/
#if 1
Provider = CreateCatalogEntry(L"msafd.dll");
if (!Provider)
{
WS_DbgPrint(MIN_TRACE, ("Could not create catalog entry.\n"));
return;
}
/* Assume one Service Provider with id 1 */
Provider->ProtocolInfo.dwCatalogEntryId = 1;
Provider->Mapping = HeapAlloc(GlobalHeap,
0,
6 * sizeof(WINSOCK_MAPPING) + 3 * sizeof(DWORD));
if (!Provider->Mapping)
return;
Provider->Mapping->Rows = 6;
Provider->Mapping->Columns = 3;
Provider->Mapping->Mapping[0].AddressFamily = AF_INET;
Provider->Mapping->Mapping[0].SocketType = SOCK_STREAM;
Provider->Mapping->Mapping[0].Protocol = 0;
Provider->Mapping->Mapping[1].AddressFamily = AF_INET;
Provider->Mapping->Mapping[1].SocketType = SOCK_STREAM;
Provider->Mapping->Mapping[1].Protocol = IPPROTO_TCP;
Provider->Mapping->Mapping[2].AddressFamily = AF_INET;
Provider->Mapping->Mapping[2].SocketType = SOCK_DGRAM;
Provider->Mapping->Mapping[2].Protocol = 0;
Provider->Mapping->Mapping[3].AddressFamily = AF_INET;
Provider->Mapping->Mapping[3].SocketType = SOCK_DGRAM;
Provider->Mapping->Mapping[3].Protocol = IPPROTO_UDP;
Provider->Mapping->Mapping[4].AddressFamily = AF_INET;
Provider->Mapping->Mapping[4].SocketType = SOCK_RAW;
Provider->Mapping->Mapping[4].Protocol = IPPROTO_ICMP;
Provider->Mapping->Mapping[5].AddressFamily = AF_INET;
Provider->Mapping->Mapping[5].SocketType = SOCK_RAW;
Provider->Mapping->Mapping[5].Protocol = 0;
#endif
}
VOID DestroyCatalog(VOID)
{
PLIST_ENTRY CurrentEntry;
PLIST_ENTRY NextEntry;
PCATALOG_ENTRY Provider;
CurrentEntry = CatalogListHead.Flink;
while (CurrentEntry != &CatalogListHead)
{
NextEntry = CurrentEntry->Flink;
Provider = CONTAINING_RECORD(CurrentEntry,
CATALOG_ENTRY,
ListEntry);
DestroyCatalogEntry(Provider);
CurrentEntry = NextEntry;
}
//DeleteCriticalSection(&CatalogLock);
}
/* EOF */

View file

@ -1,913 +0,0 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS WinSock 2 DLL
* FILE: dll/win32/ws2_32/misc/dllmain.c
* PURPOSE: DLL entry point
* PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
* REVISIONS:
* CSH 01/09-2000 Created
*/
#include "ws2_32.h"
#if DBG
/* See debug.h for debug/trace constants */
//DWORD DebugTraceLevel = MIN_TRACE;
//DWORD DebugTraceLevel = MAX_TRACE;
//DWORD DebugTraceLevel = DEBUG_ULTRA;
DWORD DebugTraceLevel = 0;
#endif /* DBG */
HINSTANCE g_hInstDll;
HANDLE GlobalHeap;
BOOL WsaInitialized = FALSE; /* TRUE if WSAStartup() has been successfully called */
WSPUPCALLTABLE UpcallTable;
/*
* @implemented
*/
INT
EXPORT
WSAGetLastError(VOID)
{
return GetLastError();
}
/*
* @implemented
*/
VOID
EXPORT
WSASetLastError(IN INT iError)
{
SetLastError(iError);
}
/*
* @implemented
*/
INT
EXPORT
WSAStartup(IN WORD wVersionRequested,
OUT LPWSADATA lpWSAData)
{
WORD VersionReturned = 0;
DWORD ErrorCode = ERROR_SUCCESS;
WS_DbgPrint(MAX_TRACE, ("WSAStartup of ws2_32.dll\n"));
if (!g_hInstDll)
return WSASYSNOTREADY;
if (lpWSAData == NULL)
return WSAEFAULT;
/* Check which version is being requested */
switch (LOBYTE(wVersionRequested))
{
case 0:
/* We don't support this unknown version */
ErrorCode = WSAVERNOTSUPPORTED;
break;
case 1:
/* We support only 1.0 and 1.1 */
if (HIBYTE(wVersionRequested) == 0)
{
/* Caller wants 1.0, return it */
VersionReturned = wVersionRequested;
}
else
{
/* The only other version we support is 1.1 */
VersionReturned = MAKEWORD(1, 1);
}
break;
case 2:
/* We support only 2.0, 2.1 and 2.2 */
if (HIBYTE(wVersionRequested) <= 2)
{
/* Caller wants 2.0-2.2, return it */
VersionReturned = MAKEWORD(2, HIBYTE(wVersionRequested));
}
else
{
/* The highest version we support is 2.2 */
VersionReturned = MAKEWORD(2, 2);
}
break;
default:
/* Return 2.2 */
VersionReturned = MAKEWORD(2, 2);
break;
}
/* Return the Version Requested, unless error */
lpWSAData->wVersion = VersionReturned;
lpWSAData->wHighVersion = MAKEWORD(2,2);
lstrcpyA(lpWSAData->szDescription, "WinSock 2.0");
lstrcpyA(lpWSAData->szSystemStatus, "Running");
if (LOBYTE(wVersionRequested) == 1)
{
lpWSAData->iMaxSockets = 32767;
lpWSAData->iMaxUdpDg = 65467;
}
else
{
lpWSAData->iMaxSockets = 0;
lpWSAData->iMaxUdpDg = 0;
}
/*FIXME: increment internal counter */
if (ErrorCode == ERROR_SUCCESS)
WSASETINITIALIZED;
return ErrorCode;
}
/*
* @implemented
*/
INT
EXPORT
WSACleanup(VOID)
{
WS_DbgPrint(MAX_TRACE, ("WSACleanup of ws2_32.dll\n"));
if (!WSAINITIALIZED)
{
WSASetLastError(WSANOTINITIALISED);
return WSANOTINITIALISED;
}
return NO_ERROR;
}
/*
* @implemented
*/
SOCKET
EXPORT
socket(IN INT af,
IN INT type,
IN INT protocol)
{
return WSASocketW(af,
type,
protocol,
NULL,
0,
0);
}
/*
* @implemented
*/
SOCKET
EXPORT
WSASocketA(IN INT af,
IN INT type,
IN INT protocol,
IN LPWSAPROTOCOL_INFOA lpProtocolInfo,
IN GROUP g,
IN DWORD dwFlags)
/*
* FUNCTION: Creates a new socket
*/
{
WSAPROTOCOL_INFOW ProtocolInfoW;
LPWSAPROTOCOL_INFOW p;
UNICODE_STRING StringU;
ANSI_STRING StringA;
WS_DbgPrint(MAX_TRACE, ("af (%d) type (%d) protocol (%d).\n",
af, type, protocol));
if (lpProtocolInfo)
{
memcpy(&ProtocolInfoW,
lpProtocolInfo,
sizeof(WSAPROTOCOL_INFOA) - sizeof(CHAR) * (WSAPROTOCOL_LEN + 1));
RtlInitAnsiString(&StringA, (LPSTR)lpProtocolInfo->szProtocol);
RtlInitUnicodeString(&StringU, (LPWSTR)&ProtocolInfoW.szProtocol);
RtlAnsiStringToUnicodeString(&StringU, &StringA, FALSE);
p = &ProtocolInfoW;
}
else
{
p = NULL;
}
return WSASocketW(af,
type,
protocol,
p,
g,
dwFlags);
}
/*
* @implemented
*/
SOCKET
EXPORT
WSASocketW(IN INT af,
IN INT type,
IN INT protocol,
IN LPWSAPROTOCOL_INFOW lpProtocolInfo,
IN GROUP g,
IN DWORD dwFlags)
/*
* FUNCTION: Creates a new socket descriptor
* ARGUMENTS:
* af = Address family
* type = Socket type
* protocol = Protocol type
* lpProtocolInfo = Pointer to protocol information
* g = Reserved
* dwFlags = Socket flags
* RETURNS:
* Created socket descriptor, or INVALID_SOCKET if it could not be created
*/
{
INT Status;
SOCKET Socket;
PCATALOG_ENTRY Provider;
WSAPROTOCOL_INFOW ProtocolInfo;
WS_DbgPrint(MAX_TRACE, ("af (%d) type (%d) protocol (%d).\n",
af, type, protocol));
if (!WSAINITIALIZED)
{
WS_DbgPrint(MAX_TRACE, ("af (%d) type (%d) protocol (%d) = WSANOTINITIALISED.\n",
af, type, protocol));
WSASetLastError(WSANOTINITIALISED);
return INVALID_SOCKET;
}
if (!lpProtocolInfo)
{
lpProtocolInfo = &ProtocolInfo;
ZeroMemory(&ProtocolInfo, sizeof(WSAPROTOCOL_INFOW));
ProtocolInfo.iAddressFamily = af;
ProtocolInfo.iSocketType = type;
ProtocolInfo.iProtocol = protocol;
}
Provider = LocateProvider(lpProtocolInfo);
if (!Provider)
{
WS_DbgPrint(MAX_TRACE, ("af (%d) type (%d) protocol (%d) = WSAEAFNOSUPPORT.\n",
af, type, protocol));
WSASetLastError(WSAEAFNOSUPPORT);
return INVALID_SOCKET;
}
Status = LoadProvider(Provider, lpProtocolInfo);
if (Status != NO_ERROR)
{
WS_DbgPrint(MAX_TRACE, ("af (%d) type (%d) protocol (%d) = %d.\n",
af, type, protocol, Status));
WSASetLastError(Status);
return INVALID_SOCKET;
}
WS_DbgPrint(MAX_TRACE, ("Calling WSPSocket at (0x%X).\n",
Provider->ProcTable.lpWSPSocket));
assert(Provider->ProcTable.lpWSPSocket);
WS_DbgPrint(MAX_TRACE,("About to call provider socket fn\n"));
Socket = Provider->ProcTable.lpWSPSocket(af,
type,
protocol,
lpProtocolInfo,
g,
dwFlags,
&Status);
WS_DbgPrint(MAX_TRACE,("Socket: %x, Status: %x\n", Socket, Status));
if (Status != NO_ERROR)
{
WSASetLastError(Status);
return INVALID_SOCKET;
}
WS_DbgPrint(MAX_TRACE,("Status: %x\n", Status));
return Socket;
}
/*
* @implemented
*/
INT
EXPORT
closesocket(IN SOCKET s)
/*
* FUNCTION: Closes a socket descriptor
* ARGUMENTS:
* s = Socket descriptor
* RETURNS:
* 0, or SOCKET_ERROR if an error ocurred
*/
{
PCATALOG_ENTRY Provider;
INT Status;
INT Errno;
WS_DbgPrint(MAX_TRACE, ("s (0x%X).\n", s));
if (!WSAINITIALIZED)
{
WSASetLastError(WSANOTINITIALISED);
return SOCKET_ERROR;
}
if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
{
WSASetLastError(WSAENOTSOCK);
return SOCKET_ERROR;
}
CloseProviderHandle((HANDLE)s);
WS_DbgPrint(MAX_TRACE,("DereferenceProviderByHandle\n"));
DereferenceProviderByPointer(Provider);
WS_DbgPrint(MAX_TRACE,("DereferenceProviderByHandle Done\n"));
Status = Provider->ProcTable.lpWSPCloseSocket(s, &Errno);
WS_DbgPrint(MAX_TRACE,("Provider Close Done\n"));
if (Status == SOCKET_ERROR)
WSASetLastError(Errno);
WS_DbgPrint(MAX_TRACE,("Returning success\n"));
return 0;
}
/*
* @implemented
*/
INT
EXPORT
select(IN INT nfds,
IN OUT LPFD_SET readfds,
IN OUT LPFD_SET writefds,
IN OUT LPFD_SET exceptfds,
IN CONST struct timeval *timeout)
/*
* FUNCTION: Returns status of one or more sockets
* ARGUMENTS:
* nfds = Always ignored
* readfds = Pointer to socket set to be checked for readability (optional)
* writefds = Pointer to socket set to be checked for writability (optional)
* exceptfds = Pointer to socket set to be checked for errors (optional)
* timeout = Pointer to a TIMEVAL structure indicating maximum wait time
* (NULL means wait forever)
* RETURNS:
* Number of ready socket descriptors, or SOCKET_ERROR if an error ocurred
*/
{
PCATALOG_ENTRY Provider = NULL;
INT Count;
INT Errno;
WS_DbgPrint(MAX_TRACE, ("readfds (0x%X) writefds (0x%X) exceptfds (0x%X).\n",
readfds, writefds, exceptfds));
if (!WSAINITIALIZED)
{
WSASetLastError(WSANOTINITIALISED);
WS_DbgPrint(MID_TRACE,("Not initialized\n"));
return SOCKET_ERROR;
}
/* FIXME: Sockets in FD_SETs should be sorted by their provider */
/* FIXME: For now, assume only one service provider */
if ((readfds != NULL) && (readfds->fd_count > 0))
{
if (!ReferenceProviderByHandle((HANDLE)readfds->fd_array[0],
&Provider))
{
WSASetLastError(WSAENOTSOCK);
WS_DbgPrint(MID_TRACE,("No provider (read)\n"));
return SOCKET_ERROR;
}
}
else if ((writefds != NULL) && (writefds->fd_count > 0))
{
if (!ReferenceProviderByHandle((HANDLE)writefds->fd_array[0],
&Provider))
{
WSASetLastError(WSAENOTSOCK);
WS_DbgPrint(MID_TRACE,("No provider (write)\n"));
return SOCKET_ERROR;
}
}
else if ((exceptfds != NULL) && (exceptfds->fd_count > 0))
{
if (!ReferenceProviderByHandle((HANDLE)exceptfds->fd_array[0], &Provider))
{
WSASetLastError(WSAENOTSOCK);
WS_DbgPrint(MID_TRACE,("No provider (err)\n"));
return SOCKET_ERROR;
}
#if 0 /* XXX empty select is not an error */
}
else
{
WSASetLastError(WSAEINVAL);
return SOCKET_ERROR;
#endif
}
if ( !Provider )
{
if ( timeout )
{
WS_DbgPrint(MID_TRACE,("Select: used as timer\n"));
Sleep( timeout->tv_sec * 1000 + (timeout->tv_usec / 1000) );
}
return 0;
}
else if (Provider->ProcTable.lpWSPSelect)
{
WS_DbgPrint(MID_TRACE,("Calling WSPSelect:%x\n", Provider->ProcTable.lpWSPSelect));
Count = Provider->ProcTable.lpWSPSelect(nfds,
readfds,
writefds,
exceptfds,
(LPTIMEVAL)timeout,
&Errno);
WS_DbgPrint(MAX_TRACE, ("[%x] Select: Count %d Errno %x\n",
Provider, Count, Errno));
DereferenceProviderByPointer(Provider);
if (Count == SOCKET_ERROR)
{
WSASetLastError(Errno);
return SOCKET_ERROR;
}
}
else
{
WSASetLastError(WSAEINVAL);
return SOCKET_ERROR;
}
return Count;
}
/*
* @implemented
*/
INT
EXPORT
bind(IN SOCKET s,
IN CONST struct sockaddr *name,
IN INT namelen)
{
PCATALOG_ENTRY Provider;
INT Status;
INT Errno;
if (!WSAINITIALIZED)
{
WSASetLastError(WSANOTINITIALISED);
return SOCKET_ERROR;
}
if (!ReferenceProviderByHandle((HANDLE)s,
&Provider))
{
WSASetLastError(WSAENOTSOCK);
return SOCKET_ERROR;
}
#if (__W32API_MAJOR_VERSION < 2 || __W32API_MINOR_VERSION < 5)
Status = Provider->ProcTable.lpWSPBind(s,
(CONST LPSOCKADDR)name,
namelen,
&Errno);
#else
Status = Provider->ProcTable.lpWSPBind(s,
name,
namelen,
&Errno);
#endif /* __W32API_MAJOR_VERSION < 2 || __W32API_MINOR_VERSION < 5 */
DereferenceProviderByPointer(Provider);
if (Status == SOCKET_ERROR)
WSASetLastError(Errno);
return Status;
}
/*
* @implemented
*/
INT
EXPORT
listen(IN SOCKET s,
IN INT backlog)
{
PCATALOG_ENTRY Provider;
INT Status;
INT Errno;
if (!WSAINITIALIZED)
{
WSASetLastError(WSANOTINITIALISED);
return SOCKET_ERROR;
}
if (!ReferenceProviderByHandle((HANDLE)s,
&Provider))
{
WSASetLastError(WSAENOTSOCK);
return SOCKET_ERROR;
}
Status = Provider->ProcTable.lpWSPListen(s,
backlog,
&Errno);
DereferenceProviderByPointer(Provider);
if (Status == SOCKET_ERROR)
WSASetLastError(Errno);
return Status;
}
/*
* @implemented
*/
SOCKET
EXPORT
accept(IN SOCKET s,
OUT LPSOCKADDR addr,
OUT INT FAR* addrlen)
{
return WSAAccept(s,
addr,
addrlen,
NULL,
0);
}
/*
* @implemented
*/
INT
EXPORT
ioctlsocket(IN SOCKET s,
IN LONG cmd,
IN OUT ULONG FAR* argp)
{
ULONG tmp;
return WSAIoctl(s,
cmd,
argp,
sizeof(ULONG),
argp,
sizeof(ULONG),
&tmp,
0,
0);
}
/*
* @implemented
*/
SOCKET
EXPORT
WSAAccept(IN SOCKET s,
OUT LPSOCKADDR addr,
IN OUT LPINT addrlen,
IN LPCONDITIONPROC lpfnCondition,
IN DWORD_PTR dwCallbackData)
{
PCATALOG_ENTRY Provider;
SOCKET Socket;
INT Errno;
if (!WSAINITIALIZED)
{
WSASetLastError(WSANOTINITIALISED);
return SOCKET_ERROR;
}
if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
{
WSASetLastError(WSAENOTSOCK);
return SOCKET_ERROR;
}
WS_DbgPrint(MAX_TRACE,("Calling provider accept\n"));
Socket = Provider->ProcTable.lpWSPAccept(s,
addr,
addrlen,
lpfnCondition,
dwCallbackData,
&Errno);
WS_DbgPrint(MAX_TRACE,("Calling provider accept -> Socket %x, Errno %x\n",
Socket, Errno));
DereferenceProviderByPointer(Provider);
if (Socket == INVALID_SOCKET)
WSASetLastError(Errno);
if ( addr && addrlen )
{
#if DBG
LPSOCKADDR_IN sa = (LPSOCKADDR_IN)addr;
WS_DbgPrint(MAX_TRACE,("Returned address: %d %s:%d (len %d)\n",
sa->sin_family,
inet_ntoa(sa->sin_addr),
ntohs(sa->sin_port),
*addrlen));
#endif
}
return Socket;
}
/*
* @implemented
*/
INT
EXPORT
connect(IN SOCKET s,
IN CONST struct sockaddr *name,
IN INT namelen)
{
return WSAConnect(s,
name,
namelen,
NULL,
NULL,
NULL,
NULL);
}
/*
* @implemented
*/
INT
EXPORT
WSAConnect(IN SOCKET s,
IN CONST struct sockaddr *name,
IN INT namelen,
IN LPWSABUF lpCallerData,
OUT LPWSABUF lpCalleeData,
IN LPQOS lpSQOS,
IN LPQOS lpGQOS)
{
PCATALOG_ENTRY Provider;
INT Status;
INT Errno;
if (!WSAINITIALIZED)
{
WSASetLastError(WSANOTINITIALISED);
return SOCKET_ERROR;
}
if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
{
WSASetLastError(WSAENOTSOCK);
return SOCKET_ERROR;
}
#if (__W32API_MAJOR_VERSION < 2 || __W32API_MINOR_VERSION < 5)
Status = Provider->ProcTable.lpWSPConnect(s,
(CONST LPSOCKADDR)name,
namelen,
lpCallerData,
lpCalleeData,
lpSQOS,
lpGQOS,
&Errno);
#else
Status = Provider->ProcTable.lpWSPConnect(s,
name,
namelen,
lpCallerData,
lpCalleeData,
lpSQOS,
lpGQOS,
&Errno);
#endif
DereferenceProviderByPointer(Provider);
if (Status == SOCKET_ERROR)
WSASetLastError(Errno);
return Status;
}
/*
* @implemented
*/
INT
EXPORT
WSAIoctl(IN SOCKET s,
IN DWORD dwIoControlCode,
IN LPVOID lpvInBuffer,
IN DWORD cbInBuffer,
OUT LPVOID lpvOutBuffer,
IN DWORD cbOutBuffer,
OUT LPDWORD lpcbBytesReturned,
IN LPWSAOVERLAPPED lpOverlapped,
IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
{
PCATALOG_ENTRY Provider;
INT Status;
INT Errno;
if (!WSAINITIALIZED)
{
WSASetLastError(WSANOTINITIALISED);
return SOCKET_ERROR;
}
if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
{
WSASetLastError(WSAENOTSOCK);
return SOCKET_ERROR;
}
Status = Provider->ProcTable.lpWSPIoctl(s,
dwIoControlCode,
lpvInBuffer,
cbInBuffer,
lpvOutBuffer,
cbOutBuffer,
lpcbBytesReturned,
lpOverlapped,
lpCompletionRoutine,
NULL /* lpThreadId */,
&Errno);
DereferenceProviderByPointer(Provider);
if (Status == SOCKET_ERROR)
WSASetLastError(Errno);
return Status;
}
/*
* @implemented
*/
INT
EXPORT
__WSAFDIsSet(SOCKET s, LPFD_SET set)
{
unsigned int i;
for ( i = 0; i < set->fd_count; i++ )
if ( set->fd_array[i] == s ) return TRUE;
return FALSE;
}
void free_winsock_thread_block(PWINSOCK_THREAD_BLOCK p)
{
if (p)
{
if (p->Hostent) { free_hostent(p->Hostent); p->Hostent = 0; }
if (p->Getservbyname){}
if (p->Getservbyport) {}
}
}
BOOL
WINAPI
DllMain(HANDLE hInstDll,
ULONG dwReason,
LPVOID lpReserved)
{
PWINSOCK_THREAD_BLOCK p;
WS_DbgPrint(MAX_TRACE, ("DllMain of ws2_32.dll.\n"));
switch (dwReason)
{
case DLL_PROCESS_ATTACH:
{
GlobalHeap = GetProcessHeap();
g_hInstDll = hInstDll;
CreateCatalog();
InitProviderHandleTable();
UpcallTable.lpWPUCloseEvent = WPUCloseEvent;
UpcallTable.lpWPUCloseSocketHandle = WPUCloseSocketHandle;
UpcallTable.lpWPUCreateEvent = WPUCreateEvent;
UpcallTable.lpWPUCreateSocketHandle = WPUCreateSocketHandle;
UpcallTable.lpWPUFDIsSet = WPUFDIsSet;
UpcallTable.lpWPUGetProviderPath = WPUGetProviderPath;
UpcallTable.lpWPUModifyIFSHandle = WPUModifyIFSHandle;
UpcallTable.lpWPUPostMessage = PostMessageW;
UpcallTable.lpWPUQueryBlockingCallback = WPUQueryBlockingCallback;
UpcallTable.lpWPUQuerySocketHandleContext = WPUQuerySocketHandleContext;
UpcallTable.lpWPUQueueApc = WPUQueueApc;
UpcallTable.lpWPUResetEvent = WPUResetEvent;
UpcallTable.lpWPUSetEvent = WPUSetEvent;
UpcallTable.lpWPUOpenCurrentThread = WPUOpenCurrentThread;
UpcallTable.lpWPUCloseThread = WPUCloseThread;
/* Fall through to thread attachment handler */
}
case DLL_THREAD_ATTACH:
{
p = HeapAlloc(GlobalHeap, 0, sizeof(WINSOCK_THREAD_BLOCK));
WS_DbgPrint(MAX_TRACE, ("Thread block at 0x%X.\n", p));
if (!p) {
return FALSE;
}
p->Hostent = NULL;
p->LastErrorValue = NO_ERROR;
p->Getservbyname = NULL;
p->Getservbyport = NULL;
NtCurrentTeb()->WinSockData = p;
}
break;
case DLL_PROCESS_DETACH:
{
if (!lpReserved)
{
FreeProviderHandleTable();
DestroyCatalog();
}
}
break;
case DLL_THREAD_DETACH:
{
p = NtCurrentTeb()->WinSockData;
if (p)
HeapFree(GlobalHeap, 0, p);
}
break;
}
WS_DbgPrint(MAX_TRACE, ("DllMain of ws2_32.dll. Leaving.\n"));
return TRUE;
}
/* EOF */

View file

@ -1,243 +0,0 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS WinSock 2 DLL
* FILE: dll/win32/ws2_32/misc/event.c
* PURPOSE: Event handling
* PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
* REVISIONS:
* CSH 01/09-2000 Created
*/
#include "ws2_32.h"
/*
* @implemented
*/
BOOL
EXPORT
WSACloseEvent(IN WSAEVENT hEvent)
{
BOOL Success;
if (!WSAINITIALIZED)
{
WSASetLastError(WSANOTINITIALISED);
return FALSE;
}
Success = CloseHandle((HANDLE)hEvent);
if (!Success)
WSASetLastError(WSA_INVALID_HANDLE);
return Success;
}
/*
* @implemented
*/
WSAEVENT
EXPORT
WSACreateEvent(VOID)
{
HANDLE Event;
if (!WSAINITIALIZED)
{
WSASetLastError(WSANOTINITIALISED);
return FALSE;
}
Event = CreateEventW(NULL, TRUE, FALSE, NULL);
if (Event == INVALID_HANDLE_VALUE)
WSASetLastError(WSA_INVALID_HANDLE);
return (WSAEVENT)Event;
}
/*
* @implemented
*/
BOOL
EXPORT
WSAResetEvent(IN WSAEVENT hEvent)
{
BOOL Success;
if (!WSAINITIALIZED)
{
WSASetLastError(WSANOTINITIALISED);
return FALSE;
}
Success = ResetEvent((HANDLE)hEvent);
if (!Success)
WSASetLastError(WSA_INVALID_HANDLE);
return Success;
}
/*
* @implemented
*/
BOOL
EXPORT
WSASetEvent(IN WSAEVENT hEvent)
{
BOOL Success;
if (!WSAINITIALIZED)
{
WSASetLastError(WSANOTINITIALISED);
return FALSE;
}
Success = SetEvent((HANDLE)hEvent);
if (!Success)
WSASetLastError(WSA_INVALID_HANDLE);
return Success;
}
/*
* @implemented
*/
DWORD
EXPORT
WSAWaitForMultipleEvents(IN DWORD cEvents,
IN CONST WSAEVENT FAR* lphEvents,
IN BOOL fWaitAll,
IN DWORD dwTimeout,
IN BOOL fAlertable)
{
DWORD Status;
if (!WSAINITIALIZED)
{
WSASetLastError(WSANOTINITIALISED);
return FALSE;
}
Status = WaitForMultipleObjectsEx(cEvents,
lphEvents,
fWaitAll,
dwTimeout,
fAlertable);
if (Status == WAIT_FAILED)
{
Status = GetLastError();
if (Status == ERROR_NOT_ENOUGH_MEMORY)
WSASetLastError(WSA_NOT_ENOUGH_MEMORY);
else if (Status == ERROR_INVALID_HANDLE)
WSASetLastError(WSA_INVALID_HANDLE);
else
WSASetLastError(WSA_INVALID_PARAMETER);
return WSA_WAIT_FAILED;
}
return Status;
}
/*
* @implemented
*/
INT
EXPORT
WSAEnumNetworkEvents(IN SOCKET s,
IN WSAEVENT hEventObject,
OUT LPWSANETWORKEVENTS lpNetworkEvents)
{
PCATALOG_ENTRY Provider;
INT Status;
INT Errno;
WS_DbgPrint(MID_TRACE,("Called (Socket %x, hEventObject %x, "
"lpNetworkEvents %x)\n",
s,
hEventObject,
lpNetworkEvents));
if (!lpNetworkEvents)
{
WSASetLastError(WSAEINVAL);
return SOCKET_ERROR;
}
if (!WSAINITIALIZED)
{
WSASetLastError(WSANOTINITIALISED);
return SOCKET_ERROR;
}
if (!ReferenceProviderByHandle((HANDLE)s,
&Provider))
{
WSASetLastError(WSAENOTSOCK);
return SOCKET_ERROR;
}
Status = Provider->ProcTable.lpWSPEnumNetworkEvents(s,
hEventObject,
lpNetworkEvents,
&Errno);
DereferenceProviderByPointer(Provider);
if (Status == SOCKET_ERROR)
WSASetLastError(Errno);
WS_DbgPrint(MID_TRACE,("Leaving %x\n", Status));
return Status;
}
/*
* @implemented
*/
INT
EXPORT
WSAEventSelect(IN SOCKET s,
IN WSAEVENT hEventObject,
IN LONG lNetworkEvents)
{
PCATALOG_ENTRY Provider;
INT Status;
INT Errno;
if (!WSAINITIALIZED)
{
WSASetLastError(WSANOTINITIALISED);
return SOCKET_ERROR;
}
if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
{
WSASetLastError(WSAENOTSOCK);
return SOCKET_ERROR;
}
Status = Provider->ProcTable.lpWSPEventSelect(s,
hEventObject,
lNetworkEvents,
&Errno);
DereferenceProviderByPointer(Provider);
if (Status == SOCKET_ERROR)
WSASetLastError(Errno);
return Status;
}
/* EOF */

View file

@ -1,297 +0,0 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS WinSock 2 DLL
* FILE: dll/win32/ws2_32/misc/handle.c
* PURPOSE: Provider handle management
* PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
* REVISIONS:
* CSH 01/09-2000 Created
*/
#include "ws2_32.h"
PPROVIDER_HANDLE_BLOCK ProviderHandleTable;
CRITICAL_SECTION ProviderHandleTableLock;
PPROVIDER_HANDLE
GetProviderByHandle(PPROVIDER_HANDLE_BLOCK HandleTable,
HANDLE Handle)
/*
* FUNCTION: Get the data structure for a handle
* ARGUMENTS:
* HandleTable = Pointer to handle table
* Handle = Handle to get data structure for
* RETURNS:
* Pointer to the data structure identified by the handle on success,
* NULL on failure
*/
{
PPROVIDER_HANDLE_BLOCK Current;
PLIST_ENTRY CurrentEntry;
ULONG i;
WS_DbgPrint(MAX_TRACE, ("HandleTable (0x%X) Handle (0x%X).\n", HandleTable, Handle));
CurrentEntry = HandleTable->Entry.Flink;
while (CurrentEntry != &HandleTable->Entry)
{
Current = CONTAINING_RECORD(CurrentEntry, PROVIDER_HANDLE_BLOCK, Entry);
for (i = 0; i < HANDLE_BLOCK_ENTRIES; i++)
{
if ((Current->Handles[i].Provider != NULL) &&
(Current->Handles[i].Handle == Handle))
{
return &Current->Handles[i];
}
}
CurrentEntry = CurrentEntry->Flink;
}
return NULL;
}
VOID
CloseAllHandles(PPROVIDER_HANDLE_BLOCK HandleTable)
{
PPROVIDER_HANDLE_BLOCK Current;
PLIST_ENTRY CurrentEntry;
PCATALOG_ENTRY Provider;
ULONG i;
WS_DbgPrint(MAX_TRACE, ("HandleTable (0x%X).\n", HandleTable));
CurrentEntry = HandleTable->Entry.Flink;
while (CurrentEntry != &HandleTable->Entry)
{
Current = CONTAINING_RECORD(CurrentEntry, PROVIDER_HANDLE_BLOCK, Entry);
for (i = 0; i < HANDLE_BLOCK_ENTRIES; i++)
{
Provider = Current->Handles[i].Provider;
if (Provider != NULL)
{
DereferenceProviderByPointer(Provider);
Current->Handles[i].Handle = (HANDLE)0;
Current->Handles[i].Provider = NULL;
}
}
CurrentEntry = CurrentEntry->Flink;
}
}
VOID
DeleteHandleTable(PPROVIDER_HANDLE_BLOCK HandleTable)
{
PPROVIDER_HANDLE_BLOCK Current;
PLIST_ENTRY CurrentEntry;
CloseAllHandles(HandleTable);
CurrentEntry = RemoveHeadList(&HandleTable->Entry);
while (CurrentEntry != &HandleTable->Entry)
{
Current = CONTAINING_RECORD(CurrentEntry,
PROVIDER_HANDLE_BLOCK,
Entry);
HeapFree(GlobalHeap, 0, Current);
CurrentEntry = RemoveHeadList(&HandleTable->Entry);
}
}
PCATALOG_ENTRY
DeleteProviderHandle(PPROVIDER_HANDLE_BLOCK HandleTable,
HANDLE Handle)
{
PPROVIDER_HANDLE Entry;
PCATALOG_ENTRY Provider;
WS_DbgPrint(MAX_TRACE, ("HandleTable (0x%X) Handle (0x%X).\n", HandleTable, Handle));
Entry = GetProviderByHandle(HandleTable, Handle);
if (!Entry)
return NULL;
Provider = Entry->Provider;
Entry->Handle = (HANDLE)0;
Entry->Provider = NULL;
return Provider;
}
HANDLE
CreateProviderHandleTable(PPROVIDER_HANDLE_BLOCK HandleTable,
HANDLE Handle,
PCATALOG_ENTRY Provider)
{
PPROVIDER_HANDLE_BLOCK NewBlock;
PLIST_ENTRY CurrentEntry;
ULONG i;
WS_DbgPrint(MAX_TRACE, ("HandleTable (0x%X) Handle (0x%X) Provider (0x%X).\n",
HandleTable, Handle, Provider));
/* Scan through the currently allocated handle blocks looking for a free slot */
CurrentEntry = HandleTable->Entry.Flink;
while (CurrentEntry != &HandleTable->Entry)
{
PPROVIDER_HANDLE_BLOCK Block = CONTAINING_RECORD(CurrentEntry,
PROVIDER_HANDLE_BLOCK,
Entry);
for (i = 0; i < HANDLE_BLOCK_ENTRIES; i++)
{
WS_DbgPrint(MAX_TRACE, ("Considering slot %ld containing 0x%X.\n",
i,
Block->Handles[i].Provider));
if (Block->Handles[i].Provider == NULL)
{
Block->Handles[i].Handle = Handle;
Block->Handles[i].Provider = Provider;
return Handle;
}
}
CurrentEntry = CurrentEntry->Flink;
}
/* Add a new handle block to the end of the list */
NewBlock = (PPROVIDER_HANDLE_BLOCK)HeapAlloc(GlobalHeap,
0,
sizeof(PROVIDER_HANDLE_BLOCK));
WS_DbgPrint(MID_TRACE,("using table entry %x\n", NewBlock));
if (!NewBlock)
return (HANDLE)0;
ZeroMemory(NewBlock, sizeof(PROVIDER_HANDLE_BLOCK));
InsertTailList(&HandleTable->Entry,
&NewBlock->Entry);
NewBlock->Handles[0].Handle = Handle;
NewBlock->Handles[0].Provider = Provider;
return Handle;
}
HANDLE
CreateProviderHandle(HANDLE Handle,
PCATALOG_ENTRY Provider)
{
HANDLE h;
EnterCriticalSection(&ProviderHandleTableLock);
h = CreateProviderHandleTable(ProviderHandleTable,
Handle,
Provider);
LeaveCriticalSection(&ProviderHandleTableLock);
if (h != NULL)
ReferenceProviderByPointer(Provider);
return h;
}
BOOL
ReferenceProviderByHandle(HANDLE Handle,
PCATALOG_ENTRY* Provider)
/*
* FUNCTION: Increments the reference count for a provider and returns a pointer to it
* ARGUMENTS:
* Handle = Handle for the provider
* Provider = Address of buffer to place pointer to provider
* RETURNS:
* TRUE if handle was valid, FALSE if not
*/
{
PPROVIDER_HANDLE ProviderHandle;
WS_DbgPrint(MID_TRACE, ("Handle (0x%X) Provider (0x%X).\n", Handle, Provider));
EnterCriticalSection(&ProviderHandleTableLock);
ProviderHandle = GetProviderByHandle(ProviderHandleTable,
Handle);
WS_DbgPrint(MID_TRACE, ("ProviderHandle is %x\n", ProviderHandle));
LeaveCriticalSection(&ProviderHandleTableLock);
if (ProviderHandle)
{
ReferenceProviderByPointer(ProviderHandle->Provider);
*Provider = ProviderHandle->Provider;
}
return (ProviderHandle != NULL);
}
BOOL
CloseProviderHandle(HANDLE Handle)
{
PCATALOG_ENTRY Provider;
WS_DbgPrint(MAX_TRACE, ("Handle (0x%X).\n", Handle));
EnterCriticalSection(&ProviderHandleTableLock);
Provider = DeleteProviderHandle(ProviderHandleTable,
Handle);
LeaveCriticalSection(&ProviderHandleTableLock);
if (!Provider)
return FALSE;
DereferenceProviderByPointer(Provider);
return TRUE;
}
BOOL
InitProviderHandleTable(VOID)
{
ProviderHandleTable =
(PPROVIDER_HANDLE_BLOCK)HeapAlloc(GlobalHeap,
0,
sizeof(PROVIDER_HANDLE_BLOCK));
if (!ProviderHandleTable)
return FALSE;
WS_DbgPrint(MID_TRACE,("Called\n"));
ZeroMemory(ProviderHandleTable,
sizeof(PROVIDER_HANDLE_BLOCK));
InitializeListHead(&ProviderHandleTable->Entry);
InitializeCriticalSection(&ProviderHandleTableLock);
return TRUE;
}
VOID
FreeProviderHandleTable(VOID)
{
DeleteHandleTable(ProviderHandleTable);
DeleteCriticalSection(&ProviderHandleTableLock);
}
/* EOF */

File diff suppressed because it is too large Load diff

View file

@ -1,415 +0,0 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS WinSock 2 DLL
* FILE: dll/win32/ws2_32/misc/sndrcv.c
* PURPOSE: Send/receive functions
* PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
* REVISIONS:
* CSH 01/09-2000 Created
*/
#include "ws2_32.h"
/*
* @implemented
*/
INT
EXPORT
recv(IN SOCKET s,
OUT CHAR FAR* buf,
IN INT len,
IN INT flags)
{
DWORD Error;
DWORD BytesReceived;
WSABUF WSABuf;
WS_DbgPrint(MAX_TRACE, ("s (0x%X) buf (0x%X) len (0x%X) flags (0x%X).\n",
s,
buf,
len,
flags));
WSABuf.len = len;
WSABuf.buf = (CHAR FAR*)buf;
Error = WSARecv(s,
&WSABuf,
1,
&BytesReceived,
(LPDWORD)&flags,
NULL,
NULL);
if( Error )
return -1;
else
return BytesReceived;
}
/*
* @implemented
*/
INT
EXPORT
recvfrom(IN SOCKET s,
OUT CHAR FAR* buf,
IN INT len,
IN INT flags,
OUT LPSOCKADDR from,
IN OUT INT FAR* fromlen)
{
DWORD Error;
DWORD BytesReceived;
WSABUF WSABuf;
WS_DbgPrint(MAX_TRACE, ("s (0x%X) buf (0x%X) len (0x%X) flags (0x%X).\n",
s,
buf,
len,
flags));
WSABuf.len = len;
WSABuf.buf = (CHAR FAR*)buf;
Error = WSARecvFrom(s,
&WSABuf,
1,
&BytesReceived,
(LPDWORD)&flags,
from,
fromlen,
NULL,
NULL);
if( Error )
return -1;
else
return BytesReceived;
}
/*
* @implemented
*/
INT
EXPORT
send(IN SOCKET s,
IN CONST CHAR FAR* buf,
IN INT len,
IN INT flags)
{
DWORD BytesSent;
DWORD Error;
WSABUF WSABuf;
WS_DbgPrint(MAX_TRACE, ("s (0x%X) buf (0x%X) len (0x%X) flags (0x%X).\n",
s,
buf,
len,
flags));
WSABuf.len = len;
WSABuf.buf = (CHAR FAR*)buf;
Error = WSASend(s,
&WSABuf,
1,
&BytesSent,
flags,
NULL,
NULL);
if( Error )
{
WS_DbgPrint(MAX_TRACE,("Reporting error %d\n", Error));
return -1;
}
else
{
WS_DbgPrint(MAX_TRACE,("Read %d bytes\n", BytesSent));
return BytesSent;
}
}
/*
* @implemented
*/
INT
EXPORT
sendto(IN SOCKET s,
IN CONST CHAR FAR* buf,
IN INT len,
IN INT flags,
IN CONST struct sockaddr *to,
IN INT tolen)
{
DWORD Error;
DWORD BytesSent;
WSABUF WSABuf;
WS_DbgPrint(MAX_TRACE, ("s (0x%X) buf (0x%X) len (0x%X) flags (0x%X).\n",
s,
buf,
len,
flags));
WSABuf.len = len;
WSABuf.buf = (CHAR FAR*)buf;
Error = WSASendTo(s,
&WSABuf,
1,
&BytesSent,
flags,
to,
tolen,
NULL,
NULL);
if( Error )
return -1;
else
return BytesSent;
}
/*
* @implemented
*/
INT
EXPORT
WSARecv(IN SOCKET s,
IN OUT LPWSABUF lpBuffers,
IN DWORD dwBufferCount,
OUT LPDWORD lpNumberOfBytesRecvd,
IN OUT LPDWORD lpFlags,
IN LPWSAOVERLAPPED lpOverlapped,
IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
{
PCATALOG_ENTRY Provider;
INT Errno;
INT Code;
WS_DbgPrint(MAX_TRACE, ("Called.\n"));
if (!ReferenceProviderByHandle((HANDLE)s,
&Provider))
{
WSASetLastError(WSAENOTSOCK);
return SOCKET_ERROR;
}
assert(Provider->ProcTable.lpWSPRecv);
Code = Provider->ProcTable.lpWSPRecv(s,
lpBuffers,
dwBufferCount,
lpNumberOfBytesRecvd,
lpFlags,
lpOverlapped,
lpCompletionRoutine,
NULL /* lpThreadId */,
&Errno);
DereferenceProviderByPointer(Provider);
if (Code == SOCKET_ERROR)
WSASetLastError(Errno);
return Code;
}
/*
* @unimplemented
*/
INT
EXPORT
WSARecvDisconnect(IN SOCKET s,
OUT LPWSABUF lpInboundDisconnectData)
{
UNIMPLEMENTED
return 0;
}
/*
* @implemented
*/
INT
EXPORT
WSARecvFrom(IN SOCKET s,
IN OUT LPWSABUF lpBuffers,
IN DWORD dwBufferCount,
OUT LPDWORD lpNumberOfBytesRecvd,
IN OUT LPDWORD lpFlags,
OUT LPSOCKADDR lpFrom,
IN OUT LPINT lpFromlen,
IN LPWSAOVERLAPPED lpOverlapped,
IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
{
PCATALOG_ENTRY Provider;
INT Errno;
INT Code;
WS_DbgPrint(MAX_TRACE, ("Called.\n"));
if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
{
WSASetLastError(WSAENOTSOCK);
return SOCKET_ERROR;
}
assert(Provider->ProcTable.lpWSPRecvFrom);
Code = Provider->ProcTable.lpWSPRecvFrom(s,
lpBuffers,
dwBufferCount,
lpNumberOfBytesRecvd,
lpFlags,
lpFrom,
lpFromlen,
lpOverlapped,
lpCompletionRoutine,
NULL /* lpThreadId */,
&Errno);
DereferenceProviderByPointer(Provider);
if (Code == SOCKET_ERROR)
WSASetLastError(Errno);
return Code;
}
/*
* @implemented
*/
INT
EXPORT
WSASend(IN SOCKET s,
IN LPWSABUF lpBuffers,
IN DWORD dwBufferCount,
OUT LPDWORD lpNumberOfBytesSent,
IN DWORD dwFlags,
IN LPWSAOVERLAPPED lpOverlapped,
IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
{
PCATALOG_ENTRY Provider;
INT Errno;
INT Code;
WS_DbgPrint(MAX_TRACE, ("Called.\n"));
if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
{
WSASetLastError(WSAENOTSOCK);
return SOCKET_ERROR;
}
assert(Provider->ProcTable.lpWSPSend);
Code = Provider->ProcTable.lpWSPSend(s,
lpBuffers,
dwBufferCount,
lpNumberOfBytesSent,
dwFlags,
lpOverlapped,
lpCompletionRoutine,
NULL /* lpThreadId */,
&Errno);
DereferenceProviderByPointer(Provider);
if (Code == SOCKET_ERROR)
WSASetLastError(Errno);
return Code;
}
/*
* @unimplemented
*/
INT
EXPORT
WSASendDisconnect(IN SOCKET s,
IN LPWSABUF lpOutboundDisconnectData)
{
UNIMPLEMENTED
return 0;
}
/*
* @implemented
*/
INT
EXPORT
WSASendTo(IN SOCKET s,
IN LPWSABUF lpBuffers,
IN DWORD dwBufferCount,
OUT LPDWORD lpNumberOfBytesSent,
IN DWORD dwFlags,
IN CONST struct sockaddr *lpTo,
IN INT iToLen,
IN LPWSAOVERLAPPED lpOverlapped,
IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
{
PCATALOG_ENTRY Provider;
INT Errno;
INT Code;
WS_DbgPrint(MAX_TRACE, ("Called.\n"));
if (!ReferenceProviderByHandle((HANDLE)s, &Provider))
{
WSASetLastError(WSAENOTSOCK);
return SOCKET_ERROR;
}
assert(Provider->ProcTable.lpWSPSendTo);
#if (__W32API_MAJOR_VERSION < 2 || __W32API_MINOR_VERSION < 5)
Code = Provider->ProcTable.lpWSPSendTo(s,
lpBuffers,
dwBufferCount,
lpNumberOfBytesSent,
dwFlags,
(CONST LPSOCKADDR)lpTo,
iToLen,
lpOverlapped,
lpCompletionRoutine,
NULL /* lpThreadId */,
&Errno);
#else
Code = Provider->ProcTable.lpWSPSendTo(s,
lpBuffers,
dwBufferCount,
lpNumberOfBytesSent,
dwFlags,
lpTo,
iToLen,
lpOverlapped,
lpCompletionRoutine,
NULL /* lpThreadId */,
&Errno);
#endif /* __W32API_MAJOR_VERSION < 2 || __W32API_MINOR_VERSION < 5 */
DereferenceProviderByPointer(Provider);
if (Code == SOCKET_ERROR)
WSASetLastError(Errno);
else
WSASetLastError(0);
return Code;
}
/* EOF */

File diff suppressed because it is too large Load diff

View file

@ -1,236 +0,0 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS WinSock 2 DLL
* FILE: dll/win32/ws2_32/misc/upcall.c
* PURPOSE: Upcall functions
* PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
* REVISIONS:
* CSH 01/09-2000 Created
*/
#include "ws2_32.h"
/*
* @implemented
*/
BOOL
WSPAPI
WPUCloseEvent(IN WSAEVENT hEvent,
OUT LPINT lpErrno)
{
UNIMPLEMENTED
return FALSE;
}
/*
* @unimplemented
*/
INT
WSPAPI
WPUCloseSocketHandle(IN SOCKET s,
OUT LPINT lpErrno)
{
UNIMPLEMENTED
return 0;
}
/*
* @unimplemented
*/
INT
WSPAPI
WPUCloseThread(IN LPWSATHREADID lpThreadId,
OUT LPINT lpErrno)
{
UNIMPLEMENTED
return 0;
}
/*
* @unimplemented
*/
WSAEVENT
WSPAPI
WPUCreateEvent(OUT LPINT lpErrno)
{
UNIMPLEMENTED
return (WSAEVENT)0;
}
/*
* @unimplemented
*/
SOCKET
WSPAPI
WPUCreateSocketHandle(IN DWORD dwCatalogEntryId,
IN DWORD_PTR dwContext,
OUT LPINT lpErrno)
{
UNIMPLEMENTED
return (SOCKET)0;
}
/*
* @unimplemented
*/
int
WSPAPI
WPUFDIsSet(IN SOCKET s,
IN LPFD_SET set)
{
UNIMPLEMENTED
return (SOCKET)0;
}
/*
* @unimplemented
*/
INT
WSPAPI
WPUGetProviderPath(IN LPGUID lpProviderId,
OUT LPWSTR lpszProviderDllPath,
IN OUT LPINT lpProviderDllPathLen,
OUT LPINT lpErrno)
{
UNIMPLEMENTED
return 0;
}
/*
* @implemented
*/
SOCKET
WSPAPI
WPUModifyIFSHandle(IN DWORD dwCatalogEntryId,
IN SOCKET ProposedHandle,
OUT LPINT lpErrno)
{
PCATALOG_ENTRY Provider;
SOCKET Socket;
WS_DbgPrint(MID_TRACE, ("dwCatalogEntryId (%d) ProposedHandle (0x%X).\n",
dwCatalogEntryId, ProposedHandle));
Provider = LocateProviderById(dwCatalogEntryId);
if (!Provider)
{
WS_DbgPrint(MIN_TRACE, ("Provider with catalog entry id (%d) was not found.\n",
dwCatalogEntryId));
if( lpErrno ) *lpErrno = WSAEINVAL;
WS_DbgPrint(MID_TRACE, ("Returning invalid socket\n"));
return INVALID_SOCKET;
}
Socket = (SOCKET)CreateProviderHandle((HANDLE)ProposedHandle,
Provider);
if( lpErrno ) *lpErrno = NO_ERROR;
WS_DbgPrint(MID_TRACE, ("Socket: %x\n", Socket));
return Socket;
}
/*
* @unimplemented
*/
INT
WSPAPI
WPUOpenCurrentThread(OUT LPWSATHREADID lpThreadId,
OUT LPINT lpErrno)
{
UNIMPLEMENTED
return 0;
}
/*
* @unimplemented
*/
INT
WSPAPI
WPUQueryBlockingCallback(IN DWORD dwCatalogEntryId,
OUT LPBLOCKINGCALLBACK FAR* lplpfnCallback,
OUT PDWORD_PTR lpdwContext,
OUT LPINT lpErrno)
{
UNIMPLEMENTED
return 0;
}
/*
* @unimplemented
*/
INT
WSPAPI
WPUQuerySocketHandleContext(IN SOCKET s,
OUT PDWORD_PTR lpContext,
OUT LPINT lpErrno)
{
UNIMPLEMENTED
return 0;
}
/*
* @unimplemented
*/
INT
WSPAPI
WPUQueueApc(IN LPWSATHREADID lpThreadId,
IN LPWSAUSERAPC lpfnUserApc,
IN DWORD_PTR dwContext,
OUT LPINT lpErrno)
{
UNIMPLEMENTED
return 0;
}
/*
* @unimplemented
*/
BOOL
WSPAPI
WPUResetEvent(IN WSAEVENT hEvent,
OUT LPINT lpErrno)
{
UNIMPLEMENTED
return FALSE;
}
/*
* @unimplemented
*/
BOOL
WSPAPI
WPUSetEvent(IN WSAEVENT hEvent,
OUT LPINT lpErrno)
{
UNIMPLEMENTED
return FALSE;
}
/* EOF */

View file

@ -1,13 +0,0 @@
#include <windows.h>
#include "regtests.h"
extern BOOL
WINAPI
DllMain(HANDLE hInstDll,
ULONG dwReason,
LPVOID lpReserved);
_SetupOnce()
{
DllMain(NULL, DLL_PROCESS_ATTACH, NULL);
}

View file

@ -1,19 +0,0 @@
kernel32.dll CreateEventW@16
kernel32.dll InitializeCriticalSection@4
kernel32.dll DeleteCriticalSection@4
kernel32.dll EnterCriticalSection@4
kernel32.dll ExitProcess@4
kernel32.dll FreeLibrary@4
kernel32.dll GetLastError@0
kernel32.dll GetProcAddress@8
kernel32.dll GetProcessHeap@0
ntdll.dll HeapAlloc@12=RtlAllocateHeap
ntdll.dll HeapFree@12=RtlFreeHeap
kernel32.dll LeaveCriticalSection@4
kernel32.dll LoadLibraryW@4
kernel32.dll lstrcpyA@8
ntdll.dll ResetEvent@4
ntdll.dll SetEvent@4
kernel32.dll Sleep@4
ntdll.dll WaitForMultipleObjectsEx@20
kernel32.dll CloseHandle@4

View file

@ -1,83 +0,0 @@
#include <windows.h>
#include <winsock2.h>
#include "regtests.h"
#define TestHandle (HANDLE) 1
static BOOL CloseHandleSuccessCalled = FALSE;
static BOOL WINAPI
MockCloseHandleSuccess(HANDLE hObject)
{
CloseHandleSuccessCalled = TRUE;
_AssertEqualValue(TestHandle, hObject);
return TRUE;
}
static HOOK HooksSuccess[] =
{
{"CloseHandle", MockCloseHandleSuccess},
{NULL, NULL}
};
static void
TestWSACloseEventSuccess()
{
BOOL result;
_SetHooks(HooksSuccess);
result = WSACloseEvent(TestHandle);
_AssertTrue(result);
_AssertEqualValue(NO_ERROR, WSAGetLastError());
_AssertTrue(CloseHandleSuccessCalled);
_UnsetAllHooks();
}
static BOOL CloseHandleFailureCalled = FALSE;
static BOOL WINAPI
MockCloseHandleFailure(HANDLE hObject)
{
CloseHandleFailureCalled = TRUE;
return FALSE;
}
static HOOK HooksFailure[] =
{
{"CloseHandle", MockCloseHandleFailure},
{NULL, NULL}
};
static void
TestWSACloseEventFailure()
{
BOOL result;
_SetHooks(HooksFailure);
result = WSACloseEvent(TestHandle);
_AssertFalse(result);
_AssertEqualValue(WSA_INVALID_HANDLE, WSAGetLastError());
_AssertTrue(CloseHandleFailureCalled);
_UnsetAllHooks();
}
static void
TestWSACloseEvent()
{
TestWSACloseEventSuccess();
TestWSACloseEventFailure();
}
static void
RunTest()
{
WSADATA WSAData;
WSAStartup(MAKEWORD(2, 0), &WSAData);
TestWSACloseEvent();
WSACleanup();
}
_Dispatcher(WinsockeventTest, "Winsock 2 event")

View file

@ -1,440 +0,0 @@
/* Async WINSOCK DNS services
*
* Copyright (C) 1993,1994,1996,1997 John Brezak, Erik Bos, Alex Korobka.
* Copyright (C) 1999 Marcus Meissner
* Copyright (C) 2009 Alexandre Julliard
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*
* NOTE: If you make any changes to fix a particular app, make sure
* they don't break something else like Netscape or telnet and ftp
* clients and servers (www.winsite.com got a lot of those).
*
* FIXME:
* - Add WSACancel* and correct handle management. (works rather well for
* now without it.)
* - Verify & Check all calls for correctness
* (currently only WSAGetHostByName*, WSAGetServByPort* calls)
* - Check error returns.
* - mirc/mirc32 Finger @linux.kernel.org sometimes fails in threaded mode.
* (not sure why)
* - This implementation did ignore the "NOTE:" section above (since the
* whole stuff did not work anyway to other changes).
*/
#define WIN32_NO_STATUS
#define _INC_WINDOWS
#define COM_NO_WINDOWS_H
#include <wine/config.h>
#include <stdarg.h>
#include <windef.h>
#include <winbase.h>
#include <winuser.h>
#include <winsock2.h>
#include <wine/debug.h>
WINE_DEFAULT_DEBUG_CHANNEL(winsock);
struct async_query_header
{
HWND hWnd;
UINT uMsg;
void *sbuf;
INT sbuflen;
HANDLE handle;
};
struct async_query_gethostbyname
{
struct async_query_header query;
char *host_name;
};
struct async_query_gethostbyaddr
{
struct async_query_header query;
char *host_addr;
int host_len;
int host_type;
};
struct async_query_getprotobyname
{
struct async_query_header query;
char *proto_name;
};
struct async_query_getprotobynumber
{
struct async_query_header query;
int proto_number;
};
struct async_query_getservbyname
{
struct async_query_header query;
char *serv_name;
char *serv_proto;
};
struct async_query_getservbyport
{
struct async_query_header query;
char *serv_proto;
int serv_port;
};
/* ----------------------------------- helper functions - */
static int list_size(char** l, int item_size)
{
int i,j = 0;
if(l)
{ for(i=0;l[i];i++)
j += (item_size) ? item_size : strlen(l[i]) + 1;
j += (i + 1) * sizeof(char*); }
return j;
}
static int list_dup(char** l_src, char* ref, int item_size)
{
char* p = ref;
char** l_to = (char**)ref;
int i,j,k;
for(j=0;l_src[j];j++) ;
p += (j + 1) * sizeof(char*);
for(i=0;i<j;i++)
{ l_to[i] = p;
k = ( item_size ) ? item_size : strlen(l_src[i]) + 1;
memcpy(p, l_src[i], k); p += k; }
l_to[i] = NULL;
return (p - ref);
}
static DWORD finish_query( struct async_query_header *query, LPARAM lparam )
{
PostMessageW( query->hWnd, query->uMsg, (WPARAM)query->handle, lparam );
HeapFree( GetProcessHeap(), 0, query );
return 0;
}
/* ----- hostent */
static LPARAM copy_he(void *base, int size, const struct hostent *he)
{
char *p;
int needed;
struct hostent *to = base;
if (!he) return MAKELPARAM( 0, GetLastError() );
needed = sizeof(struct hostent) + strlen(he->h_name) + 1 +
list_size(he->h_aliases, 0) +
list_size(he->h_addr_list, he->h_length );
if (size < needed) return MAKELPARAM( needed, WSAENOBUFS );
to->h_addrtype = he->h_addrtype;
to->h_length = he->h_length;
p = (char *)(to + 1);
to->h_name = p;
strcpy(p, he->h_name); p += strlen(p) + 1;
to->h_aliases = (char **)p;
p += list_dup(he->h_aliases, p, 0);
to->h_addr_list = (char **)p;
list_dup(he->h_addr_list, p, he->h_length);
return MAKELPARAM( needed, 0 );
}
static DWORD WINAPI async_gethostbyname(LPVOID arg)
{
struct async_query_gethostbyname *aq = arg;
struct hostent *he = gethostbyname( aq->host_name );
return finish_query( &aq->query, copy_he( aq->query.sbuf, aq->query.sbuflen, he ));
}
static DWORD WINAPI async_gethostbyaddr(LPVOID arg)
{
struct async_query_gethostbyaddr *aq = arg;
struct hostent *he = gethostbyaddr( aq->host_addr, aq->host_len, aq->host_type );
return finish_query( &aq->query, copy_he( aq->query.sbuf, aq->query.sbuflen, he ));
}
/* ----- protoent */
static LPARAM copy_pe(void *base, int size, const struct protoent* pe)
{
char *p;
int needed;
struct protoent *to = base;
if (!pe) return MAKELPARAM( 0, GetLastError() );
needed = sizeof(struct protoent) + strlen(pe->p_name) + 1 + list_size(pe->p_aliases, 0);
if (size < needed) return MAKELPARAM( needed, WSAENOBUFS );
to->p_proto = pe->p_proto;
p = (char *)(to + 1);
to->p_name = p;
strcpy(p, pe->p_name); p += strlen(p) + 1;
to->p_aliases = (char **)p;
list_dup(pe->p_aliases, p, 0);
return MAKELPARAM( needed, 0 );
}
static DWORD WINAPI async_getprotobyname(LPVOID arg)
{
struct async_query_getprotobyname *aq = arg;
struct protoent *pe = getprotobyname( aq->proto_name );
return finish_query( &aq->query, copy_pe( aq->query.sbuf, aq->query.sbuflen, pe ));
}
static DWORD WINAPI async_getprotobynumber(LPVOID arg)
{
struct async_query_getprotobynumber *aq = arg;
struct protoent *pe = getprotobynumber( aq->proto_number );
return finish_query( &aq->query, copy_pe( aq->query.sbuf, aq->query.sbuflen, pe ));
}
/* ----- servent */
static LPARAM copy_se(void *base, int size, const struct servent* se)
{
char *p;
int needed;
struct servent *to = base;
if (!se) return MAKELPARAM( 0, GetLastError() );
needed = sizeof(struct servent) + strlen(se->s_proto) + strlen(se->s_name) + 2 + list_size(se->s_aliases, 0);
if (size < needed) return MAKELPARAM( needed, WSAENOBUFS );
to->s_port = se->s_port;
p = (char *)(to + 1);
to->s_name = p;
strcpy(p, se->s_name); p += strlen(p) + 1;
to->s_proto = p;
strcpy(p, se->s_proto); p += strlen(p) + 1;
to->s_aliases = (char **)p;
list_dup(se->s_aliases, p, 0);
return MAKELPARAM( needed, 0 );
}
static DWORD WINAPI async_getservbyname(LPVOID arg)
{
struct async_query_getservbyname *aq = arg;
struct servent *se = getservbyname( aq->serv_name, aq->serv_proto );
return finish_query( &aq->query, copy_se( aq->query.sbuf, aq->query.sbuflen, se ));
}
static DWORD WINAPI async_getservbyport(LPVOID arg)
{
struct async_query_getservbyport *aq = arg;
struct servent *se = getservbyport( aq->serv_port, aq->serv_proto );
return finish_query( &aq->query, copy_se( aq->query.sbuf, aq->query.sbuflen, se ));
}
/****************************************************************************
* The main async help function.
*
* It either starts a thread or just calls the function directly for platforms
* with no thread support. This relies on the fact that PostMessage() does
* not actually call the windowproc before the function returns.
*/
static HANDLE run_query( HWND hWnd, UINT uMsg, LPTHREAD_START_ROUTINE func,
struct async_query_header *query, void *sbuf, INT sbuflen )
{
static LONG next_handle = 0xdead;
HANDLE thread;
ULONG handle;
do
handle = LOWORD( InterlockedIncrement( &next_handle ));
while (!handle); /* avoid handle 0 */
query->hWnd = hWnd;
query->uMsg = uMsg;
query->handle = UlongToHandle( handle );
query->sbuf = sbuf;
query->sbuflen = sbuflen;
thread = CreateThread( NULL, 0, func, query, 0, NULL );
if (!thread)
{
SetLastError( WSAEWOULDBLOCK );
HeapFree( GetProcessHeap(), 0, query );
return 0;
}
CloseHandle( thread );
return UlongToHandle( handle );
}
/***********************************************************************
* WSAAsyncGetHostByAddr (WS2_32.102)
*/
HANDLE WINAPI WSAAsyncGetHostByAddr(HWND hWnd, UINT uMsg, LPCSTR addr,
INT len, INT type, LPSTR sbuf, INT buflen)
{
struct async_query_gethostbyaddr *aq;
TRACE("hwnd %p, msg %04x, addr %p[%i]\n", hWnd, uMsg, addr, len );
if (!(aq = HeapAlloc( GetProcessHeap(), 0, sizeof(*aq) + len )))
{
SetLastError( WSAEWOULDBLOCK );
return 0;
}
aq->host_addr = (char *)(aq + 1);
aq->host_len = len;
aq->host_type = type;
memcpy( aq->host_addr, addr, len );
return run_query( hWnd, uMsg, async_gethostbyaddr, &aq->query, sbuf, buflen );
}
/***********************************************************************
* WSAAsyncGetHostByName (WS2_32.103)
*/
HANDLE WINAPI WSAAsyncGetHostByName(HWND hWnd, UINT uMsg, LPCSTR name,
LPSTR sbuf, INT buflen)
{
struct async_query_gethostbyname *aq;
unsigned int len = strlen(name) + 1;
TRACE("hwnd %p, msg %04x, host %s, buffer %i\n", hWnd, uMsg, debugstr_a(name), buflen );
if (!(aq = HeapAlloc( GetProcessHeap(), 0, sizeof(*aq) + len )))
{
SetLastError( WSAEWOULDBLOCK );
return 0;
}
aq->host_name = (char *)(aq + 1);
strcpy( aq->host_name, name );
return run_query( hWnd, uMsg, async_gethostbyname, &aq->query, sbuf, buflen );
}
/***********************************************************************
* WSAAsyncGetProtoByName (WS2_32.105)
*/
HANDLE WINAPI WSAAsyncGetProtoByName(HWND hWnd, UINT uMsg, LPCSTR name,
LPSTR sbuf, INT buflen)
{
struct async_query_getprotobyname *aq;
unsigned int len = strlen(name) + 1;
TRACE("hwnd %p, msg %04x, proto %s, buffer %i\n", hWnd, uMsg, debugstr_a(name), buflen );
if (!(aq = HeapAlloc( GetProcessHeap(), 0, sizeof(*aq) + len )))
{
SetLastError( WSAEWOULDBLOCK );
return 0;
}
aq->proto_name = (char *)(aq + 1);
strcpy( aq->proto_name, name );
return run_query( hWnd, uMsg, async_getprotobyname, &aq->query, sbuf, buflen );
}
/***********************************************************************
* WSAAsyncGetProtoByNumber (WS2_32.104)
*/
HANDLE WINAPI WSAAsyncGetProtoByNumber(HWND hWnd, UINT uMsg, INT number,
LPSTR sbuf, INT buflen)
{
struct async_query_getprotobynumber *aq;
TRACE("hwnd %p, msg %04x, num %i\n", hWnd, uMsg, number );
if (!(aq = HeapAlloc( GetProcessHeap(), 0, sizeof(*aq) )))
{
SetLastError( WSAEWOULDBLOCK );
return 0;
}
aq->proto_number = number;
return run_query( hWnd, uMsg, async_getprotobynumber, &aq->query, sbuf, buflen );
}
/***********************************************************************
* WSAAsyncGetServByName (WS2_32.107)
*/
HANDLE WINAPI WSAAsyncGetServByName(HWND hWnd, UINT uMsg, LPCSTR name,
LPCSTR proto, LPSTR sbuf, INT buflen)
{
struct async_query_getservbyname *aq;
unsigned int len1 = strlen(name) + 1;
unsigned int len2 = proto ? strlen(proto) + 1 : 0;
TRACE("hwnd %p, msg %04x, name %s, proto %s\n", hWnd, uMsg, debugstr_a(name), debugstr_a(proto));
if (!(aq = HeapAlloc( GetProcessHeap(), 0, sizeof(*aq) + len1 + len2 )))
{
SetLastError( WSAEWOULDBLOCK );
return 0;
}
aq->serv_name = (char *)(aq + 1);
strcpy( aq->serv_name, name );
if (proto)
{
aq->serv_proto = aq->serv_name + len1;
strcpy( aq->serv_proto, proto );
}
else
aq->serv_proto = NULL;
return run_query( hWnd, uMsg, async_getservbyname, &aq->query, sbuf, buflen );
}
/***********************************************************************
* WSAAsyncGetServByPort (WS2_32.106)
*/
HANDLE WINAPI WSAAsyncGetServByPort(HWND hWnd, UINT uMsg, INT port,
LPCSTR proto, LPSTR sbuf, INT buflen)
{
struct async_query_getservbyport *aq;
unsigned int len = proto ? strlen(proto) + 1 : 0;
TRACE("hwnd %p, msg %04x, port %i, proto %s\n", hWnd, uMsg, port, debugstr_a(proto));
if (!(aq = HeapAlloc( GetProcessHeap(), 0, sizeof(*aq) + len )))
{
SetLastError( WSAEWOULDBLOCK );
return 0;
}
if (proto)
{
aq->serv_proto = (char *)(aq + 1);
strcpy( aq->serv_proto, proto );
}
else
aq->serv_proto = NULL;
aq->serv_port = port;
return run_query( hWnd, uMsg, async_getservbyport, &aq->query, sbuf, buflen );
}

View file

@ -1,198 +0,0 @@
/*
* based on Windows Sockets 1.1 specs
*
* Copyright (C) 1993,1994,1996,1997 John Brezak, Erik Bos, Alex Korobka.
* Copyright (C) 2001 Stefan Leichter
* Copyright (C) 2004 Hans Leidekker
* Copyright (C) 2005 Marcus Meissner
* Copyright (C) 2006-2008 Kai Blin
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*
* NOTE: If you make any changes to fix a particular app, make sure
* they don't break something else like Netscape or telnet and ftp
* clients and servers (www.winsite.com got a lot of those).
*/
#define WIN32_NO_STATUS
#define _INC_WINDOWS
#define COM_NO_WINDOWS_H
#include <windef.h>
#include <winbase.h>
#include <winnls.h>
#include <ws2tcpip.h>
static inline void FreeAddrInfoW_(struct addrinfoW *pAddrInfo)
{
freeaddrinfo((struct addrinfo *)pAddrInfo);
}
#define FreeAddrInfoW FreeAddrInfoW_
static struct addrinfoW *addrinfo_AtoW(const struct addrinfo *ai)
{
struct addrinfoW *ret;
if (!(ret = HeapAlloc(GetProcessHeap(), 0, sizeof(struct addrinfoW)))) return NULL;
ret->ai_flags = ai->ai_flags;
ret->ai_family = ai->ai_family;
ret->ai_socktype = ai->ai_socktype;
ret->ai_protocol = ai->ai_protocol;
ret->ai_addrlen = ai->ai_addrlen;
ret->ai_canonname = NULL;
ret->ai_addr = NULL;
ret->ai_next = NULL;
if (ai->ai_canonname)
{
int len = MultiByteToWideChar(CP_ACP, 0, ai->ai_canonname, -1, NULL, 0);
if (!(ret->ai_canonname = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR))))
{
HeapFree(GetProcessHeap(), 0, ret);
return NULL;
}
MultiByteToWideChar(CP_ACP, 0, ai->ai_canonname, -1, ret->ai_canonname, len);
}
if (ai->ai_addr)
{
if (!(ret->ai_addr = HeapAlloc(GetProcessHeap(), 0, ai->ai_addrlen)))
{
HeapFree(GetProcessHeap(), 0, ret->ai_canonname);
HeapFree(GetProcessHeap(), 0, ret);
return NULL;
}
memcpy(ret->ai_addr, ai->ai_addr, ai->ai_addrlen);
}
return ret;
}
static struct addrinfoW *addrinfo_list_AtoW(const struct addrinfo *info)
{
struct addrinfoW *ret, *infoW;
if (!(ret = infoW = addrinfo_AtoW(info))) return NULL;
while (info->ai_next)
{
if (!(infoW->ai_next = addrinfo_AtoW(info->ai_next)))
{
FreeAddrInfoW(ret);
return NULL;
}
infoW = infoW->ai_next;
info = info->ai_next;
}
return ret;
}
static struct addrinfo *addrinfo_WtoA(const struct addrinfoW *ai)
{
struct addrinfo *ret;
if (!(ret = HeapAlloc(GetProcessHeap(), 0, sizeof(struct addrinfo)))) return NULL;
ret->ai_flags = ai->ai_flags;
ret->ai_family = ai->ai_family;
ret->ai_socktype = ai->ai_socktype;
ret->ai_protocol = ai->ai_protocol;
ret->ai_addrlen = ai->ai_addrlen;
ret->ai_canonname = NULL;
ret->ai_addr = NULL;
ret->ai_next = NULL;
if (ai->ai_canonname)
{
int len = WideCharToMultiByte(CP_ACP, 0, ai->ai_canonname, -1, NULL, 0, NULL, NULL);
if (!(ret->ai_canonname = HeapAlloc(GetProcessHeap(), 0, len)))
{
HeapFree(GetProcessHeap(), 0, ret);
return NULL;
}
WideCharToMultiByte(CP_ACP, 0, ai->ai_canonname, -1, ret->ai_canonname, len, NULL, NULL);
}
if (ai->ai_addr)
{
if (!(ret->ai_addr = HeapAlloc(GetProcessHeap(), 0, sizeof(struct sockaddr))))
{
HeapFree(GetProcessHeap(), 0, ret->ai_canonname);
HeapFree(GetProcessHeap(), 0, ret);
return NULL;
}
memcpy(ret->ai_addr, ai->ai_addr, sizeof(struct sockaddr));
}
return ret;
}
/***********************************************************************
* GetAddrInfoW (WS2_32.@)
*/
int WINAPI GetAddrInfoW(LPCWSTR nodename, LPCWSTR servname, const ADDRINFOW *hints, PADDRINFOW *res)
{
int ret, len;
char *nodenameA = NULL, *servnameA = NULL;
struct addrinfo *resA, *hintsA = NULL;
*res = NULL;
if (nodename)
{
len = WideCharToMultiByte(CP_ACP, 0, nodename, -1, NULL, 0, NULL, NULL);
if (!(nodenameA = HeapAlloc(GetProcessHeap(), 0, len))) return EAI_MEMORY;
WideCharToMultiByte(CP_ACP, 0, nodename, -1, nodenameA, len, NULL, NULL);
}
if (servname)
{
len = WideCharToMultiByte(CP_ACP, 0, servname, -1, NULL, 0, NULL, NULL);
if (!(servnameA = HeapAlloc(GetProcessHeap(), 0, len)))
{
HeapFree(GetProcessHeap(), 0, nodenameA);
return EAI_MEMORY;
}
WideCharToMultiByte(CP_ACP, 0, servname, -1, servnameA, len, NULL, NULL);
}
if (hints) hintsA = addrinfo_WtoA(hints);
ret = getaddrinfo(nodenameA, servnameA, hintsA, &resA);
freeaddrinfo(hintsA);
if (!ret)
{
*res = addrinfo_list_AtoW(resA);
freeaddrinfo(resA);
}
HeapFree(GetProcessHeap(), 0, nodenameA);
HeapFree(GetProcessHeap(), 0, servnameA);
return ret;
}
int WINAPI GetNameInfoW(const SOCKADDR *sa, socklen_t salen, PWCHAR host,
DWORD hostlen, PWCHAR serv, DWORD servlen, INT flags)
{
int ret;
char *hostA = NULL, *servA = NULL;
if (host && (!(hostA = HeapAlloc(GetProcessHeap(), 0, hostlen)))) return EAI_MEMORY;
if (serv && (!(servA = HeapAlloc(GetProcessHeap(), 0, servlen))))
{
HeapFree(GetProcessHeap(), 0, hostA);
return EAI_MEMORY;
}
ret = getnameinfo(sa, salen, hostA, hostlen, servA, servlen, flags);
if (!ret)
{
if (host) MultiByteToWideChar(CP_ACP, 0, hostA, -1, host, hostlen);
if (serv) MultiByteToWideChar(CP_ACP, 0, servA, -1, serv, servlen);
}
HeapFree(GetProcessHeap(), 0, hostA);
HeapFree(GetProcessHeap(), 0, servA);
return ret;
}

View file

@ -1,267 +0,0 @@
/*
* PROJECT: ReactOS Kernel
* LICENSE: BSD - See COPYING.ARM in the top level directory
* FILE: drivers/base/kdcom/arm/kdbg.c
* PURPOSE: Serial Port Kernel Debugging Transport Library
* PROGRAMMERS: ReactOS Portable Systems Group
*/
/* INCLUDES *******************************************************************/
#define NOEXTAPI
#include <ntifs.h>
#define NDEBUG
#include <halfuncs.h>
#include <stdio.h>
#include <debug.h>
#include "arc/arc.h"
#include "windbgkd.h"
#include <kddll.h>
#include <ioaccess.h>
#include <arm/peripherals/pl011.h>
/* GLOBALS ********************************************************************/
typedef struct _KD_PORT_INFORMATION
{
ULONG ComPort;
ULONG BaudRate;
ULONG BaseAddress;
} KD_PORT_INFORMATION, *PKD_PORT_INFORMATION;
KD_PORT_INFORMATION DefaultPort = {0, 0, 0};
//
// We need to build this in the configuration root and use KeFindConfigurationEntry
// to recover it later.
//
#define HACK 24000000
/* REACTOS FUNCTIONS **********************************************************/
BOOLEAN
NTAPI
KdPortInitializeEx(IN PKD_PORT_INFORMATION PortInformation,
IN ULONG Unknown1,
IN ULONG Unknown2)
{
ULONG Divider, Remainder, Fraction;
ULONG Baudrate = PortInformation->BaudRate;
//
// Calculate baudrate clock divider and remainder
//
Divider = HACK / (16 * Baudrate);
Remainder = HACK % (16 * Baudrate);
//
// Calculate the fractional part
//
Fraction = (8 * Remainder / Baudrate) >> 1;
Fraction += (8 * Remainder / Baudrate) & 1;
//
// Disable interrupts
//
WRITE_REGISTER_ULONG(UART_PL011_CR, 0);
//
// Set the baud rate
//
WRITE_REGISTER_ULONG(UART_PL011_IBRD, Divider);
WRITE_REGISTER_ULONG(UART_PL011_FBRD, Fraction);
//
// Set 8 bits for data, 1 stop bit, no parity, FIFO enabled
//
WRITE_REGISTER_ULONG(UART_PL011_LCRH,
UART_PL011_LCRH_WLEN_8 | UART_PL011_LCRH_FEN);
//
// Clear and enable FIFO
//
WRITE_REGISTER_ULONG(UART_PL011_CR,
UART_PL011_CR_UARTEN |
UART_PL011_CR_TXE |
UART_PL011_CR_RXE);
//
// Done
//
return TRUE;
}
BOOLEAN
NTAPI
KdPortInitialize(IN PKD_PORT_INFORMATION PortInformation,
IN ULONG Unknown1,
IN ULONG Unknown2)
{
//
// Call the extended version
//
return KdPortInitializeEx(PortInformation, Unknown1, Unknown2);
}
BOOLEAN
NTAPI
KdPortGetByteEx(IN PKD_PORT_INFORMATION PortInformation,
OUT PUCHAR ByteReceived)
{
UNIMPLEMENTED;
while (TRUE);
return FALSE;
}
BOOLEAN
NTAPI
KdPortGetByte(OUT PUCHAR ByteReceived)
{
//
// Call the extended version
//
return KdPortGetByteEx(&DefaultPort, ByteReceived);
}
BOOLEAN
NTAPI
KdPortPollByteEx(IN PKD_PORT_INFORMATION PortInformation,
OUT PUCHAR ByteReceived)
{
UNIMPLEMENTED;
while (TRUE);
return TRUE;
}
BOOLEAN
NTAPI
KdPortPollByte(OUT PUCHAR ByteReceived)
{
//
// Call the extended version
//
return KdPortPollByteEx(&DefaultPort, ByteReceived);
}
VOID
NTAPI
KdPortPutByteEx(IN PKD_PORT_INFORMATION PortInformation,
IN UCHAR ByteToSend)
{
//
// Wait for ready
//
while ((READ_REGISTER_ULONG(UART_PL01x_FR) & UART_PL01x_FR_TXFF) != 0);
//
// Send the character
//
WRITE_REGISTER_ULONG(UART_PL01x_DR, ByteToSend);
}
VOID
NTAPI
KdPortPutByte(IN UCHAR ByteToSend)
{
//
// Call the extended version
//
KdPortPutByteEx(&DefaultPort, ByteToSend);
}
VOID
NTAPI
KdPortRestore(VOID)
{
UNIMPLEMENTED;
while (TRUE);
}
VOID
NTAPI
KdPortSave(VOID)
{
UNIMPLEMENTED;
while (TRUE);
}
BOOLEAN
NTAPI
KdPortDisableInterrupts(VOID)
{
UNIMPLEMENTED;
while (TRUE);
return TRUE;
}
BOOLEAN
NTAPI
KdPortEnableInterrupts(VOID)
{
UNIMPLEMENTED;
while (TRUE);
return TRUE;
}
/* WINDOWS FUNCTIONS **********************************************************/
NTSTATUS
NTAPI
KdDebuggerInitialize0(IN PLOADER_PARAMETER_BLOCK LoaderBlock OPTIONAL)
{
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
NTSTATUS
NTAPI
KdDebuggerInitialize1(IN PLOADER_PARAMETER_BLOCK LoaderBlock OPTIONAL)
{
UNIMPLEMENTED;
return STATUS_NOT_IMPLEMENTED;
}
NTSTATUS
NTAPI
KdSave(IN BOOLEAN SleepTransition)
{
UNIMPLEMENTED;
while (TRUE);
return STATUS_SUCCESS;
}
NTSTATUS
NTAPI
KdRestore(IN BOOLEAN SleepTransition)
{
UNIMPLEMENTED;
while (TRUE);
return STATUS_SUCCESS;
}
VOID
NTAPI
KdSendPacket(IN ULONG PacketType,
IN PSTRING MessageHeader,
IN PSTRING MessageData,
IN OUT PKD_CONTEXT Context)
{
UNIMPLEMENTED;
while (TRUE);
return;
}
KDSTATUS
NTAPI
KdReceivePacket(IN ULONG PacketType,
OUT PSTRING MessageHeader,
OUT PSTRING MessageData,
OUT PULONG DataLength,
IN OUT PKD_CONTEXT Context)
{
UNIMPLEMENTED;
while (TRUE);
return 0;
}
/* EOF */

View file

@ -1,499 +0,0 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: drivers/base/kdcom/kdbg.c
* PURPOSE: Serial i/o functions for the kernel debugger.
* PROGRAMMER: Alex Ionescu
* Hervé Poussineau
*/
/* INCLUDES *****************************************************************/
#define NOEXTAPI
#include <ntifs.h>
#include <halfuncs.h>
#include <stdio.h>
#include "arc/arc.h"
#include "windbgkd.h"
#include <kddll.h>
#include <ioaccess.h> /* port intrinsics */
#include <cportlib/cportlib.h>
#define NDEBUG
#include <debug.h>
typedef struct _KD_PORT_INFORMATION
{
ULONG ComPort;
ULONG BaudRate;
ULONG BaseAddress;
} KD_PORT_INFORMATION, *PKD_PORT_INFORMATION;
BOOLEAN
NTAPI
KdPortInitializeEx(
IN PKD_PORT_INFORMATION PortInformation,
IN ULONG Unknown1,
IN ULONG Unknown2);
BOOLEAN
NTAPI
KdPortGetByteEx(
IN PKD_PORT_INFORMATION PortInformation,
OUT PUCHAR ByteReceived);
BOOLEAN
NTAPI
KdPortPollByteEx(
IN PKD_PORT_INFORMATION PortInformation,
OUT PUCHAR ByteReceived);
VOID
NTAPI
KdPortPutByteEx(
IN PKD_PORT_INFORMATION PortInformation,
IN UCHAR ByteToSend);
#define DEFAULT_BAUD_RATE 19200
#if defined(_M_IX86) || defined(_M_AMD64)
const ULONG BaseArray[] = {0, 0x3F8, 0x2F8, 0x3E8, 0x2E8};
#elif defined(_M_PPC)
const ULONG BaseArray[] = {0, 0x800003F8};
#elif defined(_M_MIPS)
const ULONG BaseArray[] = {0, 0x80006000, 0x80007000};
#elif defined(_M_ARM)
const ULONG BaseArray[] = {0, 0xF1012000};
#else
#error Unknown architecture
#endif
/* MACROS *******************************************************************/
#define SER_RBR(x) ((PUCHAR)(x)+0)
#define SER_THR(x) ((PUCHAR)(x)+0)
#define SER_DLL(x) ((PUCHAR)(x)+0)
#define SER_IER(x) ((PUCHAR)(x)+1)
#define SR_IER_ERDA 0x01
#define SR_IER_ETHRE 0x02
#define SR_IER_ERLSI 0x04
#define SR_IER_EMS 0x08
#define SR_IER_ALL 0x0F
#define SER_DLM(x) ((PUCHAR)(x)+1)
#define SER_IIR(x) ((PUCHAR)(x)+2)
#define SER_FCR(x) ((PUCHAR)(x)+2)
#define SR_FCR_ENABLE_FIFO 0x01
#define SR_FCR_CLEAR_RCVR 0x02
#define SR_FCR_CLEAR_XMIT 0x04
#define SER_LCR(x) ((PUCHAR)(x)+3)
#define SR_LCR_CS5 0x00
#define SR_LCR_CS6 0x01
#define SR_LCR_CS7 0x02
#define SR_LCR_CS8 0x03
#define SR_LCR_ST1 0x00
#define SR_LCR_ST2 0x04
#define SR_LCR_PNO 0x00
#define SR_LCR_POD 0x08
#define SR_LCR_PEV 0x18
#define SR_LCR_PMK 0x28
#define SR_LCR_PSP 0x38
#define SR_LCR_BRK 0x40
#define SR_LCR_DLAB 0x80
#define SER_MCR(x) ((PUCHAR)(x)+4)
#define SR_MCR_DTR 0x01
#define SR_MCR_RTS 0x02
#define SR_MCR_OUT1 0x04
#define SR_MCR_OUT2 0x08
#define SR_MCR_LOOP 0x10
#define SER_LSR(x) ((PUCHAR)(x)+5)
#define SR_LSR_DR 0x01
#define SR_LSR_TBE 0x20
#define SER_MSR(x) ((PUCHAR)(x)+6)
#define SR_MSR_CTS 0x10
#define SR_MSR_DSR 0x20
#define SER_SCR(x) ((PUCHAR)(x)+7)
/* GLOBAL VARIABLES *********************************************************/
/* STATIC VARIABLES *********************************************************/
static KD_PORT_INFORMATION DefaultPort = { 0, 0, 0 };
/* The com port must only be initialized once! */
static BOOLEAN PortInitialized = FALSE;
/* FUNCTIONS ****************************************************************/
/* HAL.KdPortInitialize */
BOOLEAN
NTAPI
KdPortInitialize(
IN PKD_PORT_INFORMATION PortInformation,
IN ULONG Unknown1,
IN ULONG Unknown2)
{
SIZE_T i;
CHAR buffer[80];
if (!PortInitialized)
{
DefaultPort.BaudRate = PortInformation->BaudRate;
if (PortInformation->ComPort == 0)
{
/*
* Start enumerating COM ports from the last one to the first one,
* and break when we find a valid port.
* If we reach the first element of the list, the invalid COM port,
* then it means that no valid port was found.
*/
for (i = sizeof(BaseArray) / sizeof(BaseArray[0]) - 1; i > 0; i--)
{
if (CpDoesPortExist(UlongToPtr(BaseArray[i])))
{
PortInformation->BaseAddress = DefaultPort.BaseAddress = BaseArray[i];
PortInformation->ComPort = DefaultPort.ComPort = i;
break;
}
}
if (i == 0)
{
sprintf(buffer,
"\nKernel Debugger: No COM port found!\n\n");
HalDisplayString(buffer);
return FALSE;
}
}
PortInitialized = TRUE;
}
/* initialize port */
if (!KdPortInitializeEx(&DefaultPort, Unknown1, Unknown2))
return FALSE;
/* set global info */
KdComPortInUse = (PUCHAR)DefaultPort.BaseAddress;
return TRUE;
}
/* HAL.KdPortInitializeEx ; ReactOS-specific */
BOOLEAN
NTAPI
KdPortInitializeEx(
IN PKD_PORT_INFORMATION PortInformation,
IN ULONG Unknown1,
IN ULONG Unknown2)
{
ULONG ComPortBase;
CHAR buffer[80];
ULONG divisor;
UCHAR lcr;
#ifdef _ARM_
UNIMPLEMENTED;
return FALSE;
#endif
if (PortInformation->BaudRate == 0)
PortInformation->BaudRate = DEFAULT_BAUD_RATE;
if (PortInformation->ComPort != 0)
{
if (!CpDoesPortExist(UlongToPtr(BaseArray[PortInformation->ComPort])))
{
sprintf(buffer,
"\nKernel Debugger: Serial port not found!\n\n");
HalDisplayString(buffer);
return FALSE;
}
ComPortBase = BaseArray[PortInformation->ComPort];
PortInformation->BaseAddress = ComPortBase;
}
else
{
ComPortBase = PortInformation->BaseAddress;
}
if (ComPortBase == 0)
return FALSE;
#ifndef NDEBUG
sprintf(buffer,
"\nSerial port COM%ld found at 0x%lx\n",
PortInformation->ComPort,
ComPortBase);
HalDisplayString(buffer);
#endif /* NDEBUG */
/* set baud rate and data format (8N1) */
/* turn on DTR and RTS */
WRITE_PORT_UCHAR(SER_MCR(ComPortBase), SR_MCR_DTR | SR_MCR_RTS);
/* set DLAB */
lcr = READ_PORT_UCHAR(SER_LCR(ComPortBase)) | SR_LCR_DLAB;
WRITE_PORT_UCHAR(SER_LCR(ComPortBase), lcr);
/* set baud rate */
divisor = 115200 / PortInformation->BaudRate;
WRITE_PORT_UCHAR(SER_DLL(ComPortBase), (UCHAR)(divisor & 0xff));
WRITE_PORT_UCHAR(SER_DLM(ComPortBase), (UCHAR)((divisor >> 8) & 0xff));
/* reset DLAB and set 8N1 format */
WRITE_PORT_UCHAR(SER_LCR(ComPortBase),
SR_LCR_CS8 | SR_LCR_ST1 | SR_LCR_PNO);
/* read junk out of the RBR */
lcr = READ_PORT_UCHAR(SER_RBR(ComPortBase));
#ifndef NDEBUG
/* print message to blue screen */
sprintf(buffer,
"\nKernel Debugger: COM%ld (Port 0x%lx) BaudRate %ld\n\n",
PortInformation->ComPort,
ComPortBase,
PortInformation->BaudRate);
HalDisplayString(buffer);
#endif /* NDEBUG */
return TRUE;
}
/* HAL.KdPortGetByte */
BOOLEAN
NTAPI
KdPortGetByte(
OUT PUCHAR ByteReceived)
{
if (!PortInitialized)
return FALSE;
return KdPortGetByteEx(&DefaultPort, ByteReceived);
}
/* HAL.KdPortGetByteEx ; ReactOS-specific */
BOOLEAN
NTAPI
KdPortGetByteEx(
IN PKD_PORT_INFORMATION PortInformation,
OUT PUCHAR ByteReceived)
{
PUCHAR ComPortBase = (PUCHAR)PortInformation->BaseAddress;
if ((READ_PORT_UCHAR(SER_LSR(ComPortBase)) & SR_LSR_DR))
{
*ByteReceived = READ_PORT_UCHAR(SER_RBR(ComPortBase));
return TRUE;
}
return FALSE;
}
/* HAL.KdPortPollByte */
BOOLEAN
NTAPI
KdPortPollByte(
OUT PUCHAR ByteReceived)
{
if (!PortInitialized)
return FALSE;
return KdPortPollByteEx(&DefaultPort, ByteReceived);
}
/* HAL.KdPortPollByteEx ; ReactOS-specific */
BOOLEAN
NTAPI
KdPortPollByteEx(
IN PKD_PORT_INFORMATION PortInformation,
OUT PUCHAR ByteReceived)
{
PUCHAR ComPortBase = (PUCHAR)PortInformation->BaseAddress;
while ((READ_PORT_UCHAR(SER_LSR(ComPortBase)) & SR_LSR_DR) == 0)
;
*ByteReceived = READ_PORT_UCHAR(SER_RBR(ComPortBase));
return TRUE;
}
/* HAL.KdPortPutByte */
VOID
NTAPI
KdPortPutByte(
IN UCHAR ByteToSend)
{
if (!PortInitialized)
return;
KdPortPutByteEx(&DefaultPort, ByteToSend);
}
/* HAL.KdPortPutByteEx ; ReactOS-specific */
VOID
NTAPI
KdPortPutByteEx(
IN PKD_PORT_INFORMATION PortInformation,
IN UCHAR ByteToSend)
{
PUCHAR ComPortBase = (PUCHAR)PortInformation->BaseAddress;
while ((READ_PORT_UCHAR(SER_LSR(ComPortBase)) & SR_LSR_TBE) == 0)
;
WRITE_PORT_UCHAR(SER_THR(ComPortBase), ByteToSend);
}
/* HAL.KdPortRestore */
VOID
NTAPI
KdPortRestore(VOID)
{
UNIMPLEMENTED;
}
/* HAL.KdPortSave */
VOID
NTAPI
KdPortSave(VOID)
{
UNIMPLEMENTED;
}
/* HAL.KdPortDisableInterrupts */
BOOLEAN
NTAPI
KdPortDisableInterrupts(VOID)
{
UCHAR ch;
if (!PortInitialized)
return FALSE;
ch = READ_PORT_UCHAR(SER_MCR(DefaultPort.BaseAddress));
ch &= (~(SR_MCR_OUT1 | SR_MCR_OUT2));
WRITE_PORT_UCHAR(SER_MCR(DefaultPort.BaseAddress), ch);
ch = READ_PORT_UCHAR(SER_IER(DefaultPort.BaseAddress));
ch &= (~SR_IER_ALL);
WRITE_PORT_UCHAR(SER_IER(DefaultPort.BaseAddress), ch);
return TRUE;
}
/* HAL.KdPortEnableInterrupts */
BOOLEAN
NTAPI
KdPortEnableInterrupts(VOID)
{
UCHAR ch;
if (PortInitialized == FALSE)
return FALSE;
ch = READ_PORT_UCHAR(SER_IER(DefaultPort.BaseAddress));
ch &= (~SR_IER_ALL);
ch |= SR_IER_ERDA;
WRITE_PORT_UCHAR(SER_IER(DefaultPort.BaseAddress), ch);
ch = READ_PORT_UCHAR(SER_MCR(DefaultPort.BaseAddress));
ch &= (~SR_MCR_LOOP);
ch |= (SR_MCR_OUT1 | SR_MCR_OUT2);
WRITE_PORT_UCHAR(SER_MCR(DefaultPort.BaseAddress), ch);
return TRUE;
}
/*
* @unimplemented
*/
NTSTATUS
NTAPI
KdDebuggerInitialize0(
IN PLOADER_PARAMETER_BLOCK LoaderBlock OPTIONAL)
{
return STATUS_NOT_IMPLEMENTED;
}
/*
* @unimplemented
*/
NTSTATUS
NTAPI
KdDebuggerInitialize1(
IN PLOADER_PARAMETER_BLOCK LoaderBlock OPTIONAL)
{
return STATUS_NOT_IMPLEMENTED;
}
/*
* @implemented
*/
NTSTATUS
NTAPI
KdSave(
IN BOOLEAN SleepTransition)
{
/* Nothing to do on COM ports */
return STATUS_SUCCESS;
}
/*
* @implemented
*/
NTSTATUS
NTAPI
KdRestore(
IN BOOLEAN SleepTransition)
{
/* Nothing to do on COM ports */
return STATUS_SUCCESS;
}
/*
* @unimplemented
*/
VOID
NTAPI
KdSendPacket(
IN ULONG PacketType,
IN PSTRING MessageHeader,
IN PSTRING MessageData,
IN OUT PKD_CONTEXT Context)
{
UNIMPLEMENTED;
return;
}
/*
* @unimplemented
*/
KDSTATUS
NTAPI
KdReceivePacket(
IN ULONG PacketType,
OUT PSTRING MessageHeader,
OUT PSTRING MessageData,
OUT PULONG DataLength,
IN OUT PKD_CONTEXT Context)
{
UNIMPLEMENTED;
return 0;
}
/* EOF */

View file

@ -1,68 +0,0 @@
/*************************************************************************
*
* File: errmsg.msg
*
* Product: Ext2 FSD
*
* Module: Ext2 FSD Event Log Messages
*
* Description:
* Contains error strings in a format understandable to the message compiler.
* Please compile (using mc) with the -c option which will set the
* "Customer" bit in all errors.
* Use values beginning at 0xA000 (e.g. 0xA001) for the Ext2 FSD
* errors.
* Do NOT use %1 for insertion strings. The I/O manager assumes that
* the first insertion string is the name of the driver/device.
*
*
*************************************************************************/
//
// Values are 32 bit values layed out as follows:
//
// 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
// +---+-+-+-----------------------+-------------------------------+
// |Sev|C|R| Facility | Code |
// +---+-+-+-----------------------+-------------------------------+
//
// where
//
// Sev - is the severity code
//
// 00 - Success
// 01 - Informational
// 10 - Warning
// 11 - Error
//
// C - is the Customer code flag
//
// R - is a reserved bit
//
// Facility - is the facility code
//
// Code - is the facility's status code
//
//
// Define the facility codes
//
//
// Define the severity codes
//
#define STATUS_SEVERITY_WARNING 0x2
#define STATUS_SEVERITY_SUCCESS 0x0
#define STATUS_SEVERITY_INFORMATIONAL 0x1
#define STATUS_SEVERITY_ERROR 0x3
//
// MessageId: EXT2_ERROR_INTERNAL_ERROR
//
// MessageText:
//
// The Ext2 FSD encountered an internal error. Please check log data information.
//
#define EXT2_ERROR_INTERNAL_ERROR ((ULONG)0xE004A001L)

View file

@ -1,615 +0,0 @@
/*
* linux/include/linux/ext2_fs.h
*
* Copyright (C) 1992, 1993, 1994, 1995
* Remy Card (card@masi.ibp.fr)
* Laboratoire MASI - Institut Blaise Pascal
* Universite Pierre et Marie Curie (Paris VI)
*
* from
*
* linux/include/linux/minix_fs.h
*
* Copyright (C) 1991, 1992 Linus Torvalds
*/
#ifndef _LINUX_EXT2_FS_H
#define _LINUX_EXT2_FS_H
// #include <linux/types.h>
/*
* The second extended filesystem constants/structures
*/
/*
* Define EXT2_PREALLOCATE to preallocate data blocks for expanding files
*/
#define EXT2_PREALLOCATE
#define EXT2_DEFAULT_PREALLOC_BLOCKS 8
/*
* The second extended file system version
*/
#define EXT2FS_DATE "95/08/09"
#define EXT2FS_VERSION "0.5b"
/*
* Debug code
*/
/*
* Special inodes numbers
*/
#define EXT2_BAD_INO 1 /* Bad blocks inode */
#define EXT2_ROOT_INO 2 /* Root inode */
#define EXT2_ACL_IDX_INO 3 /* ACL inode */
#define EXT2_ACL_DATA_INO 4 /* ACL inode */
#define EXT2_BOOT_LOADER_INO 5 /* Boot loader inode */
#define EXT2_UNDEL_DIR_INO 6 /* Undelete directory inode */
/* First non-reserved inode for old ext2 filesystems */
#define EXT2_GOOD_OLD_FIRST_INO 11
/*
* The second extended file system magic number
*/
#define EXT2_SUPER_MAGIC 0xEF53
/*
* Maximal count of links to a file
*/
#define EXT2_LINK_MAX 32000
/*
* Macro-instructions used to manage several block sizes
*/
#define EXT2_MIN_BLOCK_SIZE 1024
#define EXT2_MAX_BLOCK_SIZE 4096
#define EXT2_MIN_BLOCK_LOG_SIZE 10
#ifdef __KERNEL__
# define EXT2_BLOCK_SIZE(s) ((s)->s_blocksize)
#else
# define EXT2_BLOCK_SIZE(s) (EXT2_MIN_BLOCK_SIZE << (s)->s_log_block_size)
#endif
#define EXT2_ACLE_PER_BLOCK(s) (EXT2_BLOCK_SIZE(s) / sizeof (struct ext2_acl_entry))
#define EXT2_ADDR_PER_BLOCK(s) (EXT2_BLOCK_SIZE(s) / sizeof (__u32))
#ifdef __KERNEL__
# define EXT2_BLOCK_SIZE_BITS(s) ((s)->s_blocksize_bits)
#else
# define EXT2_BLOCK_SIZE_BITS(s) ((s)->s_log_block_size + 10)
#endif
#ifdef __KERNEL__
#define EXT2_ADDR_PER_BLOCK_BITS(s) ((s)->u.ext2_sb.s_addr_per_block_bits)
#define EXT2_INODE_SIZE(s) ((s)->u.ext2_sb.s_inode_size)
#define EXT2_FIRST_INO(s) ((s)->u.ext2_sb.s_first_ino)
#else
#define EXT2_INODE_SIZE(s) (((s)->s_rev_level == EXT2_GOOD_OLD_REV) ? \
EXT2_GOOD_OLD_INODE_SIZE : \
(s)->s_inode_size)
#define EXT2_FIRST_INO(s) (((s)->s_rev_level == EXT2_GOOD_OLD_REV) ? \
EXT2_GOOD_OLD_FIRST_INO : \
(s)->s_first_ino)
#endif
/*
* Macro-instructions used to manage fragments
*/
#define EXT2_MIN_FRAG_SIZE 1024
#define EXT2_MAX_FRAG_SIZE 4096
#define EXT2_MIN_FRAG_LOG_SIZE 10
#ifdef __KERNEL__
# define EXT2_FRAG_SIZE(s) ((s)->u.ext2_sb.s_frag_size)
# define EXT2_FRAGS_PER_BLOCK(s) ((s)->u.ext2_sb.s_frags_per_block)
#else
# define EXT2_FRAG_SIZE(s) (EXT2_MIN_FRAG_SIZE << (s)->s_log_frag_size)
# define EXT2_FRAGS_PER_BLOCK(s) (EXT2_BLOCK_SIZE(s) / EXT2_FRAG_SIZE(s))
#endif
/*
* ACL structures
*/
struct ext2_acl_header /* Header of Access Control Lists */
{
__u32 aclh_size;
__u32 aclh_file_count;
__u32 aclh_acle_count;
__u32 aclh_first_acle;
};
struct ext2_acl_entry /* Access Control List Entry */
{
__u32 acle_size;
__u16 acle_perms; /* Access permissions */
__u16 acle_type; /* Type of entry */
__u16 acle_tag; /* User or group identity */
__u16 acle_pad1;
__u32 acle_next; /* Pointer on next entry for the */
/* same inode or on next free entry */
};
/*
* Structure of a blocks group descriptor
*/
struct ext2_group_desc
{
__u32 bg_block_bitmap; /* Blocks bitmap block */
__u32 bg_inode_bitmap; /* Inodes bitmap block */
__u32 bg_inode_table; /* Inodes table block */
__u16 bg_free_blocks_count; /* Free blocks count */
__u16 bg_free_inodes_count; /* Free inodes count */
__u16 bg_used_dirs_count; /* Directories count */
__u16 bg_pad;
__u32 bg_reserved[3];
};
/*
* Macro-instructions used to manage group descriptors
*/
#ifdef __KERNEL__
# define EXT2_BLOCKS_PER_GROUP(s) ((s)->u.ext2_sb.s_blocks_per_group)
# define EXT2_DESC_PER_BLOCK(s) ((s)->u.ext2_sb.s_desc_per_block)
# define EXT2_INODES_PER_GROUP(s) ((s)->u.ext2_sb.s_inodes_per_group)
# define EXT2_DESC_PER_BLOCK_BITS(s) ((s)->u.ext2_sb.s_desc_per_block_bits)
#else
# define EXT2_BLOCKS_PER_GROUP(s) ((s)->s_blocks_per_group)
# define EXT2_DESC_PER_BLOCK(s) (EXT2_BLOCK_SIZE(s) / sizeof (struct ext2_group_desc))
# define EXT2_INODES_PER_GROUP(s) ((s)->s_inodes_per_group)
#endif
/*
* Constants relative to the data blocks
*/
#define EXT2_NDIR_BLOCKS 12
#define EXT2_IND_BLOCK EXT2_NDIR_BLOCKS
#define EXT2_DIND_BLOCK (EXT2_IND_BLOCK + 1)
#define EXT2_TIND_BLOCK (EXT2_DIND_BLOCK + 1)
#define EXT2_N_BLOCKS (EXT2_TIND_BLOCK + 1)
/*
* Inode flags
*/
#define EXT2_SECRM_FL 0x00000001 /* Secure deletion */
#define EXT2_UNRM_FL 0x00000002 /* Undelete */
#define EXT2_COMPR_FL 0x00000004 /* Compress file */
#define EXT2_SYNC_FL 0x00000008 /* Synchronous updates */
#define EXT2_IMMUTABLE_FL 0x00000010 /* Immutable file */
#define EXT2_APPEND_FL 0x00000020 /* writes to file may only append */
#define EXT2_NODUMP_FL 0x00000040 /* do not dump file */
#define EXT2_NOATIME_FL 0x00000080 /* do not update atime */
/* Reserved for compression usage... */
#define EXT2_DIRTY_FL 0x00000100
#define EXT2_COMPRBLK_FL 0x00000200 /* One or more compressed clusters */
#define EXT2_NOCOMP_FL 0x00000400 /* Don't compress */
#define EXT2_ECOMPR_FL 0x00000800 /* Compression error */
/* End compression flags --- maybe not all used */
#define EXT2_BTREE_FL 0x00001000 /* btree format dir */
#define EXT2_RESERVED_FL 0x80000000 /* reserved for ext2 lib */
#define EXT2_FL_USER_VISIBLE 0x00001FFF /* User visible flags */
#define EXT2_FL_USER_MODIFIABLE 0x000000FF /* User modifiable flags */
/*
* ioctl commands
*/
#define EXT2_IOC_GETFLAGS _IOR('f', 1, long)
#define EXT2_IOC_SETFLAGS _IOW('f', 2, long)
#define EXT2_IOC_GETVERSION _IOR('v', 1, long)
#define EXT2_IOC_SETVERSION _IOW('v', 2, long)
/*
* Structure of an inode on the disk
*/
struct ext2_inode {
__u16 i_mode; /* File mode */
__u16 i_uid; /* Low 16 bits of Owner Uid */
__u32 i_size; /* Size in bytes */
__u32 i_atime; /* Access time */
__u32 i_ctime; /* Creation time */
__u32 i_mtime; /* Modification time */
__u32 i_dtime; /* Deletion Time */
__u16 i_gid; /* Low 16 bits of Group Id */
__u16 i_links_count; /* Links count */
__u32 i_blocks; /* Blocks count */
__u32 i_flags; /* File flags */
union {
struct {
__u32 l_i_reserved1;
} linux1;
struct {
__u32 h_i_translator;
} hurd1;
struct {
__u32 m_i_reserved1;
} masix1;
} osd1; /* OS dependent 1 */
__u32 i_block[EXT2_N_BLOCKS];/* Pointers to blocks */
__u32 i_generation; /* File version (for NFS) */
__u32 i_file_acl; /* File ACL */
__u32 i_dir_acl; /* Directory ACL */
__u32 i_faddr; /* Fragment address */
union {
struct {
__u8 l_i_frag; /* Fragment number */
__u8 l_i_fsize; /* Fragment size */
__u16 i_pad1;
__u16 l_i_uid_high; /* these 2 fields */
__u16 l_i_gid_high; /* were reserved2[0] */
__u32 l_i_reserved2;
} linux2;
struct {
__u8 h_i_frag; /* Fragment number */
__u8 h_i_fsize; /* Fragment size */
__u16 h_i_mode_high;
__u16 h_i_uid_high;
__u16 h_i_gid_high;
__u32 h_i_author;
} hurd2;
struct {
__u8 m_i_frag; /* Fragment number */
__u8 m_i_fsize; /* Fragment size */
__u16 m_pad1;
__u32 m_i_reserved2[2];
} masix2;
} osd2; /* OS dependent 2 */
};
#define i_size_high i_dir_acl
#if defined(__KERNEL__) || defined(__linux__)
#define i_reserved1 osd1.linux1.l_i_reserved1
#define i_frag osd2.linux2.l_i_frag
#define i_fsize osd2.linux2.l_i_fsize
#define i_uid_low i_uid
#define i_gid_low i_gid
#define i_uid_high osd2.linux2.l_i_uid_high
#define i_gid_high osd2.linux2.l_i_gid_high
#define i_reserved2 osd2.linux2.l_i_reserved2
#endif
#ifdef __hurd__
#define i_translator osd1.hurd1.h_i_translator
#define i_frag osd2.hurd2.h_i_frag;
#define i_fsize osd2.hurd2.h_i_fsize;
#define i_uid_high osd2.hurd2.h_i_uid_high
#define i_gid_high osd2.hurd2.h_i_gid_high
#define i_author osd2.hurd2.h_i_author
#endif
#ifdef __masix__
#define i_reserved1 osd1.masix1.m_i_reserved1
#define i_frag osd2.masix2.m_i_frag
#define i_fsize osd2.masix2.m_i_fsize
#define i_reserved2 osd2.masix2.m_i_reserved2
#endif
/*
* File system states
*/
#define EXT2_VALID_FS 0x0001 /* Unmounted cleanly */
#define EXT2_ERROR_FS 0x0002 /* Errors detected */
/*
* Mount flags
*/
#define EXT2_MOUNT_CHECK 0x0001 /* Do mount-time checks */
#define EXT2_MOUNT_GRPID 0x0004 /* Create files with directory's group */
#define EXT2_MOUNT_DEBUG 0x0008 /* Some debugging messages */
#define EXT2_MOUNT_ERRORS_CONT 0x0010 /* Continue on errors */
#define EXT2_MOUNT_ERRORS_RO 0x0020 /* Remount fs ro on errors */
#define EXT2_MOUNT_ERRORS_PANIC 0x0040 /* Panic on errors */
#define EXT2_MOUNT_MINIX_DF 0x0080 /* Mimics the Minix statfs */
#define EXT2_MOUNT_NO_UID32 0x0200 /* Disable 32-bit UIDs */
#define clear_opt(o, opt) o &= ~EXT2_MOUNT_##opt
#define set_opt(o, opt) o |= EXT2_MOUNT_##opt
#define test_opt(sb, opt) ((sb)->u.ext2_sb.s_mount_opt & \
EXT2_MOUNT_##opt)
/*
* Maximal mount counts between two filesystem checks
*/
#define EXT2_DFL_MAX_MNT_COUNT 20 /* Allow 20 mounts */
#define EXT2_DFL_CHECKINTERVAL 0 /* Don't use interval check */
/*
* Behaviour when detecting errors
*/
#define EXT2_ERRORS_CONTINUE 1 /* Continue execution */
#define EXT2_ERRORS_RO 2 /* Remount fs read-only */
#define EXT2_ERRORS_PANIC 3 /* Panic */
#define EXT2_ERRORS_DEFAULT EXT2_ERRORS_CONTINUE
/*
* Structure of the super block
*/
struct ext2_super_block {
__u32 s_inodes_count; /* Inodes count */
__u32 s_blocks_count; /* Blocks count */
__u32 s_r_blocks_count; /* Reserved blocks count */
__u32 s_free_blocks_count; /* Free blocks count */
__u32 s_free_inodes_count; /* Free inodes count */
__u32 s_first_data_block; /* First Data Block */
__u32 s_log_block_size; /* Block size */
__s32 s_log_frag_size; /* Fragment size */
__u32 s_blocks_per_group; /* # Blocks per group */
__u32 s_frags_per_group; /* # Fragments per group */
__u32 s_inodes_per_group; /* # Inodes per group */
__u32 s_mtime; /* Mount time */
__u32 s_wtime; /* Write time */
__u16 s_mnt_count; /* Mount count */
__s16 s_max_mnt_count; /* Maximal mount count */
__u16 s_magic; /* Magic signature */
__u16 s_state; /* File system state */
__u16 s_errors; /* Behaviour when detecting errors */
__u16 s_minor_rev_level; /* minor revision level */
__u32 s_lastcheck; /* time of last check */
__u32 s_checkinterval; /* max. time between checks */
__u32 s_creator_os; /* OS */
__u32 s_rev_level; /* Revision level */
__u16 s_def_resuid; /* Default uid for reserved blocks */
__u16 s_def_resgid; /* Default gid for reserved blocks */
/*
* These fields are for EXT2_DYNAMIC_REV superblocks only.
*
* Note: the difference between the compatible feature set and
* the incompatible feature set is that if there is a bit set
* in the incompatible feature set that the kernel doesn't
* know about, it should refuse to mount the filesystem.
*
* e2fsck's requirements are more strict; if it doesn't know
* about a feature in either the compatible or incompatible
* feature set, it must abort and not try to meddle with
* things it doesn't understand...
*/
__u32 s_first_ino; /* First non-reserved inode */
__u16 s_inode_size; /* size of inode structure */
__u16 s_block_group_nr; /* block group # of this superblock */
__u32 s_feature_compat; /* compatible feature set */
__u32 s_feature_incompat; /* incompatible feature set */
__u32 s_feature_ro_compat; /* readonly-compatible feature set */
__u8 s_uuid[16]; /* 128-bit uuid for volume */
char s_volume_name[16]; /* volume name */
char s_last_mounted[64]; /* directory where last mounted */
__u32 s_algorithm_usage_bitmap; /* For compression */
/*
* Performance hints. Directory preallocation should only
* happen if the EXT2_COMPAT_PREALLOC flag is on.
*/
__u8 s_prealloc_blocks; /* Nr of blocks to try to preallocate*/
__u8 s_prealloc_dir_blocks; /* Nr to preallocate for dirs */
__u16 s_padding1;
__u32 s_reserved[204]; /* Padding to the end of the block */
};
#ifdef __KERNEL__
#define EXT2_SB(sb) (&((sb)->u.ext2_sb))
#else
/* Assume that user mode programs are passing in an ext2fs superblock, not
* a kernel struct super_block. This will allow us to call the feature-test
* macros from user land. */
#define EXT2_SB(sb) (sb)
#endif
/*
* Codes for operating systems
*/
#define EXT2_OS_LINUX 0
#define EXT2_OS_HURD 1
#define EXT2_OS_MASIX 2
#define EXT2_OS_FREEBSD 3
#define EXT2_OS_LITES 4
/*
* Revision levels
*/
#define EXT2_GOOD_OLD_REV 0 /* The good old (original) format */
#define EXT2_DYNAMIC_REV 1 /* V2 format w/ dynamic inode sizes */
#define EXT2_CURRENT_REV EXT2_GOOD_OLD_REV
#define EXT2_MAX_SUPP_REV EXT2_DYNAMIC_REV
#define EXT2_GOOD_OLD_INODE_SIZE 128
/*
* Feature set definitions
*/
#define EXT2_HAS_COMPAT_FEATURE(sb,mask) \
( EXT2_SB(sb)->s_es->s_feature_compat & cpu_to_le32(mask) )
#define EXT2_HAS_RO_COMPAT_FEATURE(sb,mask) \
( EXT2_SB(sb)->s_es->s_feature_ro_compat & cpu_to_le32(mask) )
#define EXT2_HAS_INCOMPAT_FEATURE(sb,mask) \
( EXT2_SB(sb)->s_es->s_feature_incompat & cpu_to_le32(mask) )
#define EXT2_SET_COMPAT_FEATURE(sb,mask) \
EXT2_SB(sb)->s_es->s_feature_compat |= cpu_to_le32(mask)
#define EXT2_SET_RO_COMPAT_FEATURE(sb,mask) \
EXT2_SB(sb)->s_es->s_feature_ro_compat |= cpu_to_le32(mask)
#define EXT2_SET_INCOMPAT_FEATURE(sb,mask) \
EXT2_SB(sb)->s_es->s_feature_incompat |= cpu_to_le32(mask)
#define EXT2_CLEAR_COMPAT_FEATURE(sb,mask) \
EXT2_SB(sb)->s_es->s_feature_compat &= ~cpu_to_le32(mask)
#define EXT2_CLEAR_RO_COMPAT_FEATURE(sb,mask) \
EXT2_SB(sb)->s_es->s_feature_ro_compat &= ~cpu_to_le32(mask)
#define EXT2_CLEAR_INCOMPAT_FEATURE(sb,mask) \
EXT2_SB(sb)->s_es->s_feature_incompat &= ~cpu_to_le32(mask)
#define EXT2_FEATURE_COMPAT_DIR_PREALLOC 0x0001
#define EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER 0x0001
#define EXT2_FEATURE_RO_COMPAT_LARGE_FILE 0x0002
#define EXT2_FEATURE_RO_COMPAT_BTREE_DIR 0x0004
#define EXT2_FEATURE_INCOMPAT_COMPRESSION 0x0001
#define EXT2_FEATURE_INCOMPAT_FILETYPE 0x0002
#define EXT2_FEATURE_COMPAT_SUPP 0
#define EXT2_FEATURE_INCOMPAT_SUPP EXT2_FEATURE_INCOMPAT_FILETYPE
#define EXT2_FEATURE_RO_COMPAT_SUPP (EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER| \
EXT2_FEATURE_RO_COMPAT_LARGE_FILE| \
EXT2_FEATURE_RO_COMPAT_BTREE_DIR)
/*
* Default values for user and/or group using reserved blocks
*/
#define EXT2_DEF_RESUID 0
#define EXT2_DEF_RESGID 0
/*
* Structure of a directory entry
*/
#define EXT2_NAME_LEN 255
struct ext2_dir_entry {
__u32 inode; /* Inode number */
__u16 rec_len; /* Directory entry length */
__u16 name_len; /* Name length */
char name[EXT2_NAME_LEN]; /* File name */
};
/*
* The new version of the directory entry. Since EXT2 structures are
* stored in intel byte order, and the name_len field could never be
* bigger than 255 chars, it's safe to reclaim the extra byte for the
* file_type field.
*/
struct ext2_dir_entry_2 {
__u32 inode; /* Inode number */
__u16 rec_len; /* Directory entry length */
__u8 name_len; /* Name length */
__u8 file_type;
char name[EXT2_NAME_LEN]; /* File name */
};
/*
* Ext2 directory file types. Only the low 3 bits are used. The
* other bits are reserved for now.
*/
#define EXT2_FT_UNKNOWN 0
#define EXT2_FT_REG_FILE 1
#define EXT2_FT_DIR 2
#define EXT2_FT_CHRDEV 3
#define EXT2_FT_BLKDEV 4
#define EXT2_FT_FIFO 5
#define EXT2_FT_SOCK 6
#define EXT2_FT_SYMLINK 7
#define EXT2_FT_MAX 8
/*
* EXT2_DIR_PAD defines the directory entries boundaries
*
* NOTE: It must be a multiple of 4
*/
#define EXT2_DIR_PAD 4
#define EXT2_DIR_ROUND (EXT2_DIR_PAD - 1)
#define EXT2_DIR_REC_LEN(name_len) (((name_len) + 8 + EXT2_DIR_ROUND) & \
~EXT2_DIR_ROUND)
#ifdef __KERNEL__
/*
* Function prototypes
*/
/*
* Ok, these declarations are also in <linux/kernel.h> but none of the
* ext2 source programs needs to include it so they are duplicated here.
*/
# define NORET_TYPE /**/
# define ATTRIB_NORET __attribute__((noreturn))
# define NORET_AND noreturn,
/* acl.c */
extern int ext2_permission (struct inode *, int);
/* balloc.c */
extern int ext2_bg_has_super(struct super_block *sb, int group);
extern unsigned long ext2_bg_num_gdb(struct super_block *sb, int group);
extern int ext2_new_block (struct inode *, unsigned long,
__u32 *, __u32 *, int *);
extern void ext2_free_blocks (struct inode *, unsigned long,
unsigned long);
extern unsigned long ext2_count_free_blocks (struct super_block *);
extern void ext2_check_blocks_bitmap (struct super_block *);
extern struct ext2_group_desc * ext2_get_group_desc(struct super_block * sb,
unsigned int block_group,
struct buffer_head ** bh);
/* bitmap.c */
extern unsigned long ext2_count_free (struct buffer_head *, unsigned);
/* dir.c */
extern int ext2_check_dir_entry (const char *, struct inode *,
struct ext2_dir_entry_2 *, struct buffer_head *,
unsigned long);
/* file.c */
extern int ext2_read (struct inode *, struct file *, char *, int);
extern int ext2_write (struct inode *, struct file *, char *, int);
/* fsync.c */
extern int ext2_sync_file (struct file *, struct dentry *, int);
extern int ext2_fsync_inode (struct inode *, int);
/* ialloc.c */
extern struct inode * ext2_new_inode (const struct inode *, int);
extern void ext2_free_inode (struct inode *);
extern unsigned long ext2_count_free_inodes (struct super_block *);
extern void ext2_check_inodes_bitmap (struct super_block *);
/* inode.c */
extern struct buffer_head * ext2_getblk (struct inode *, long, int, int *);
extern struct buffer_head * ext2_bread (struct inode *, int, int, int *);
extern void ext2_read_inode (struct inode *);
extern void ext2_write_inode (struct inode *, int);
extern void ext2_put_inode (struct inode *);
extern void ext2_delete_inode (struct inode *);
extern int ext2_sync_inode (struct inode *);
extern void ext2_discard_prealloc (struct inode *);
/* ioctl.c */
extern int ext2_ioctl (struct inode *, struct file *, unsigned int,
unsigned long);
/* namei.c */
extern struct inode_operations ext2_dir_inode_operations;
/* super.c */
extern void ext2_error (struct super_block *, const char *, const char *, ...)
__attribute__ ((format (printf, 3, 4)));
extern NORET_TYPE void ext2_panic (struct super_block *, const char *,
const char *, ...)
__attribute__ ((NORET_AND format (printf, 3, 4)));
extern void ext2_warning (struct super_block *, const char *, const char *, ...)
__attribute__ ((format (printf, 3, 4)));
extern void ext2_update_dynamic_rev (struct super_block *sb);
extern void ext2_put_super (struct super_block *);
extern void ext2_write_super (struct super_block *);
extern int ext2_remount (struct super_block *, int *, char *);
extern struct super_block * ext2_read_super (struct super_block *,void *,int);
extern int ext2_statfs (struct super_block *, struct statfs *);
/* truncate.c */
extern void ext2_truncate (struct inode *);
/*
* Inodes and files operations
*/
/* dir.c */
extern struct file_operations ext2_dir_operations;
/* file.c */
extern struct inode_operations ext2_file_inode_operations;
extern struct file_operations ext2_file_operations;
/* symlink.c */
extern struct inode_operations ext2_fast_symlink_inode_operations;
extern struct address_space_operations ext2_aops;
#endif /* __KERNEL__ */
#endif /* _LINUX_EXT2_FS_H */

View file

@ -1,238 +0,0 @@
/*************************************************************************
*
* File: ext2fsd.h
*
* Module: Ext2 File System Driver (Kernel mode execution only)
*
* Description:
* The main include file for the Ext2 file system driver.
*
* Author: Manoj Paul Joseph
*
*
*************************************************************************/
#ifndef _EXT2_FSD_H_
#define _EXT2_FSD_H_
#define EXT2_POOL_WITH_TAG
// some constant definitions
#define EXT2_PANIC_IDENTIFIER (0x86427531)
// any directory information EXT2 obtains from the local file system
// will use a buffer of the following size ... (in KB)
#define EXT2_READ_DIR_BUFFER_LENGTH (512)
#define EXT2_MAXCLOSABLE_FCBS_UL 20
#define EXT2_MAXCLOSABLE_FCBS_LL 10
// Some type definitions...
// These are used later...
typedef unsigned int UINT;
typedef unsigned char BYTE;
// Common include files - should be in the include dir of the MS supplied IFS Kit
#include <ntifs.h>
#include <ntdddisk.h>
/* REACTOS FIXME */
#undef DeleteFile
/* This is deprecated and should be changed in the EXT2FS driver. */
/* FIXME : Those two definitions already exist in wdm.h
#define RtlLargeIntegerLessThan(a, b) (a).QuadPart < (b).QuadPart
#define RtlLargeIntegerGreaterThan(a, b) (a).QuadPart > (b).QuadPart
*/
// the following include files should be in the inc sub-dir associated with this driver
#include "ext2metadata.h"
#include "struct.h"
#include "protos.h"
#include "errmsg.h"
// global variables - minimize these
extern Ext2Data Ext2GlobalData;
// try-finally simulation
#define try_return(...) { __VA_ARGS__; goto try_exit; }
#define try_return1(S) { S; goto try_exit1; }
#define try_return2(S) { S; goto try_exit2; }
// some global (helpful) macros
#define Ext2IsFlagOn(Flags,SingleFlag) ((BOOLEAN)((((Flags) & (SingleFlag)) != 0)))
#define Ext2SetFlag(Flag, Value) ((Flag) |= (Value))
#define Ext2ClearFlag(Flag, Value) ((Flag) &= ~(Value))
#define Ext2QuadAlign(Value) ((((uint32)(Value)) + 7) & 0xfffffff8)
// to perform a bug-check (panic), the following macro is used
#define Ext2Panic(arg1, arg2, arg3) \
(KeBugCheckEx(EXT2_PANIC_IDENTIFIER, EXT2_BUG_CHECK_ID | __LINE__, (uint32)(arg1), (uint32)(arg2), (uint32)(arg3)))
// a convenient macro (must be invoked in the context of the thread that acquired the resource)
#define Ext2ReleaseResource(Resource) \
(ExReleaseResourceForThreadLite((Resource), ExGetCurrentResourceThread()))
// each file has a unique bug-check identifier associated with it.
// Here is a list of constant definitions for these identifiers
#define EXT2_FILE_INIT (0x00000001)
#define EXT2_FILE_REGISTRY (0x00000002)
#define EXT2_FILE_CREATE (0x00000003)
#define EXT2_FILE_CLEANUP (0x00000004)
#define EXT2_FILE_CLOSE (0x00000005)
#define EXT2_FILE_READ (0x00000006)
#define EXT2_FILE_WRITE (0x00000007)
#define EXT2_FILE_INFORMATION (0x00000008)
#define EXT2_FILE_FLUSH (0x00000009)
#define EXT2_FILE_VOL_INFORMATION (0x0000000A)
#define EXT2_FILE_DIR_CONTROL (0x0000000B)
#define EXT2_FILE_FILE_CONTROL (0x0000000C)
#define EXT2_FILE_DEVICE_CONTROL (0x0000000D)
#define EXT2_FILE_SHUTDOWN (0x0000000E)
#define EXT2_FILE_LOCK_CONTROL (0x0000000F)
#define EXT2_FILE_SECURITY (0x00000010)
#define EXT2_FILE_EXT_ATTR (0x00000011)
#define EXT2_FILE_MISC (0x00000012)
#define EXT2_FILE_FAST_IO (0x00000013)
#define EXT2_FILE_IO (0x00000014)
#define EXT2_FILE_METADATA_IO (0x00000015)
#if DBG
#define Ext2BreakPoint() DbgBreakPoint()
#else
#define Ext2BreakPoint()
#endif
#define Ext2RaiseStatus(IRPCONTEXT,STATUS) \
{ \
(IRPCONTEXT)->ExceptionStatus = (STATUS); \
ExRaiseStatus( (STATUS) ); \
}
#ifdef EXT2_POOL_WITH_TAG
#define Ext2AllocatePool(PoolType,NumberOfBytes) \
ExAllocatePoolWithTag( PoolType, NumberOfBytes, '2txE' )
#else
#define Ext2AllocatePool(PoolType,NumberOfBytes) \
ExAllocatePool( PoolType, NumberOfBytes )
#endif
#if DBG
//
// Trace types...
// Any number of these may be enabled...
//
#define DEBUG_TRACE_IRQL (0x00000001)
#define DEBUG_TRACE_IRP_ENTRY (0x00000002)
#define DEBUG_TRACE_RESOURCE_ACQUIRE (0x00000004)
#define DEBUG_TRACE_RESOURCE_RELEASE (0x00000008)
#define DEBUG_TRACE_RESOURCE_RETRY (0x00000010)
#define DEBUG_TRACE_ASYNC (0x00000020)
#define DEBUG_TRACE_MOUNT (0x00000040)
#define DEBUG_TRACE_RESOURCE_STATE (0x00000080)
#define DEBUG_TRACE_MISC (0x00000100)
#define DEBUG_TRACE_FILE_OBJ (0x00000200)
#define DEBUG_TRACE_FILE_NAME (0x00000400)
#define DEBUG_TRACE_SPECIAL (0x00000800)
#define DEBUG_TRACE_ERROR (0x00001000)
#define DEBUG_TRACE_READ_DETAILS (0x00002000)
#define DEBUG_TRACE_WRITE_DETAILS (0x00004000)
#define DEBUG_TRACE_FILEINFO (0x00008000)
#define DEBUG_TRACE_DIRINFO (0x00010000)
#define DEBUG_TRACE_REFERENCE (0x00020000)
#define DEBUG_TRACE_FSCTRL (0x00040000)
#define DEBUG_TRACE_FREE (0x00080000)
#define DEBUG_TRACE_LINENO (0x00100000)
#define DEBUG_TRACE_TRIPLE (0x00200000)
#define DEBUG_TRACE_ALL (0xffffffff)
#define DEBUG_TRACE_NONE 0
//
// The permitted DebugTrace types...
//
#define PERMITTED_DEBUG_TRACE_TYPES DEBUG_TRACE_NONE
/*
#define PERMITTED_DEBUG_TRACE_TYPES DEBUG_TRACE_ERROR | DEBUG_TRACE_IRP_ENTRY | \
DEBUG_TRACE_FILE_NAME | DEBUG_TRACE_SPECIAL | \
DEBUG_TRACE_ASYNC
*/
#define DebugTrace( TYPE, X, Y ) \
{ \
if( ( TYPE ) & ( PERMITTED_DEBUG_TRACE_TYPES ) ) \
{ \
if( ( DEBUG_TRACE_LINENO ) & ( PERMITTED_DEBUG_TRACE_TYPES ) ) \
{ \
DbgPrint("(%s:%ld) ", __FILE__, __LINE__ ); \
} \
DbgPrint(X,Y); \
if( ( DEBUG_TRACE_IRQL ) & ( PERMITTED_DEBUG_TRACE_TYPES ) ) \
{ \
DbgPrint( ",IRQL = %d ", KeGetCurrentIrql( ) ); \
} \
DbgPrint("\n"); \
} \
}
#define DebugTraceState( STR, X1, X2, X3) \
{ \
if( ( DEBUG_TRACE_RESOURCE_STATE ) & ( PERMITTED_DEBUG_TRACE_TYPES ) ) \
{ \
DbgPrint("\nState: "); \
DbgPrint( STR, X1, X2, X3 ); \
if( ( DEBUG_TRACE_IRQL ) & ( PERMITTED_DEBUG_TRACE_TYPES ) ) \
{ \
DbgPrint( " IRQL = %d ", KeGetCurrentIrql( ) ); \
} \
} \
}
#define AssertFCB( PtrFCB ) \
{ \
if( !(PtrFCB) || (PtrFCB)->NodeIdentifier.NodeType != EXT2_NODE_TYPE_FCB ) \
{ \
Ext2BreakPoint(); \
} \
}
#define AssertVCB( PtrVCB ) \
{ \
if( !(PtrVCB) || (PtrVCB)->NodeIdentifier.NodeType != EXT2_NODE_TYPE_VCB ) \
{ \
Ext2BreakPoint(); \
} \
}
#define AssertFCBorVCB( PtrVCBorFCB ) \
{ \
if( !(PtrVCBorFCB) || \
( (PtrVCBorFCB)->NodeIdentifier.NodeType != EXT2_NODE_TYPE_VCB && \
(PtrVCBorFCB)->NodeIdentifier.NodeType != EXT2_NODE_TYPE_FCB ) ) \
{ \
Ext2BreakPoint(); \
} \
}
#else
#define DebugTrace( TYPE, X, Y )
#define DebugTraceState( STR, X1, X2, X3 )
#define AssertFCB( PtrFCB )
#define AssertVCB( PtrVCB )
#define AssertFCBorVCB( PtrVCBorFCB )
#endif
#endif // _EXT2_FSD_H_

View file

@ -1,115 +0,0 @@
/*************************************************************************
*
* File: ext2metadata.h
*
* Module: Ext2 File System Driver (Kernel mode execution only)
*
* Description:
* Contains the definitions for the Ext2 Metadata structures.
*
* Author: Manoj Paul Joseph
*
*
*************************************************************************/
#ifndef EXT2_METADATA_STRUCTURES
#define EXT2_METADATA_STRUCTURES
//
// Some type definitions...
// These are used in the ext2_fs.h header file
//
typedef unsigned int __u32 ;
typedef signed int __s32 ;
typedef unsigned short int __u16 ;
typedef signed short int __s16 ;
typedef unsigned char __u8 ;
//
//******************************************************
//
// Using Remy Card's (slightly modified) Ext2 header...
//
#include "ext2_fs.h"
//
//******************************************************
//
typedef struct ext2_super_block EXT2_SUPER_BLOCK;
typedef EXT2_SUPER_BLOCK * PEXT2_SUPER_BLOCK;
typedef struct ext2_inode EXT2_INODE;
typedef EXT2_INODE * PEXT2_INODE;
typedef struct ext2_group_desc EXT2_GROUP_DESCRIPTOR;
typedef EXT2_GROUP_DESCRIPTOR * PEXT2_GROUP_DESCRIPTOR;
typedef struct ext2_dir_entry_2 EXT2_DIR_ENTRY;
typedef EXT2_DIR_ENTRY * PEXT2_DIR_ENTRY;
//
// Ext2 Supported File Types...
//
#define IMODE_FIFO 0x01
#define IMODE_CHARDEV 0x02
#define IMODE_DIR 0x04
#define IMODE_BLOCKDEV 0x06
#define IMODE_FILE 0x08
#define IMODE_SLINK 0x0A
#define IMODE_SOCKET 0x0C
#define _MKMODE(m) ( ( (m) >> 12 ) & 0x000F)
#define Ext2IsModeRegularFile(m) ( _MKMODE(m) == IMODE_FILE )
#define Ext2IsModeDirectory(m) ( _MKMODE(m) == IMODE_DIR )
#define Ext2IsModeSymbolicLink(m) ( _MKMODE(m) == IMODE_SLINK )
#define Ext2IsModePipe(m) ( _MKMODE(m) == IMODE_FIFO )
#define Ext2IsModeCharacterDevice(m) ( _MKMODE(m) == IMODE_CHARDEV )
#define Ext2IsModeBlockDevice(m) ( _MKMODE(m) == IMODE_BLOCKDEV )
#define Ext2IsModeSocket(m) ( _MKMODE(m) == IMODE_SOCKET )
#define Ext2IsModeHidden(m) ( (m & 0x124) == 0) // No Read Permission
#define Ext2IsModeReadOnly(m) ( (m & 0x92) == 0) // No write Permission
#define Ext2SetModeHidden(m) m = (m & (~0x124)); // Turn off Read Permission
#define Ext2SetModeReadOnly(m) m = (m & (~0x92)); // Turn off write Permission
#define Ext2SetModeReadWrite(m) m = (m & 0x1ff); // Set read/write Permission
//
// Define the Packed and Unpacked BIOS Parameter Block
//
typedef struct _PACKED_BIOS_PARAMETER_BLOCK {
UCHAR BytesPerSector[2]; // offset = 0x000 0
UCHAR SectorsPerCluster[1]; // offset = 0x002 2
UCHAR ReservedSectors[2]; // offset = 0x003 3
UCHAR Fats[1]; // offset = 0x005 5
UCHAR RootEntries[2]; // offset = 0x006 6
UCHAR Sectors[2]; // offset = 0x008 8
UCHAR Media[1]; // offset = 0x00A 10
UCHAR SectorsPerFat[2]; // offset = 0x00B 11
UCHAR SectorsPerTrack[2]; // offset = 0x00D 13
UCHAR Heads[2]; // offset = 0x00F 15
UCHAR HiddenSectors[4]; // offset = 0x011 17
UCHAR LargeSectors[4]; // offset = 0x015 21
} PACKED_BIOS_PARAMETER_BLOCK; // sizeof = 0x019 25
typedef PACKED_BIOS_PARAMETER_BLOCK *PPACKED_BIOS_PARAMETER_BLOCK;
//
// Define the boot sector
//
typedef struct _PACKED_BOOT_SECTOR {
UCHAR Jump[3]; // offset = 0x000 0
UCHAR Oem[8]; // offset = 0x003 3
PACKED_BIOS_PARAMETER_BLOCK PackedBpb; // offset = 0x00B 11
UCHAR PhysicalDriveNumber; // offset = 0x024 36
UCHAR CurrentHead; // offset = 0x025 37
UCHAR Signature; // offset = 0x026 38
UCHAR Id[4]; // offset = 0x027 39
UCHAR VolumeLabel[11]; // offset = 0x02B 43
UCHAR SystemId[8]; // offset = 0x036 54
} PACKED_BOOT_SECTOR; // sizeof = 0x03E 62
typedef PACKED_BOOT_SECTOR *PPACKED_BOOT_SECTOR;
#endif

View file

@ -1,782 +0,0 @@
/*************************************************************************
*
* File: protos.h
*
* Module: Ext2 File System Driver (Kernel mode execution only)
*
* Description:
* Contains the prototypes for functions in this sample FSD.
*
* Author: Manoj Paul Joseph
*
*
*************************************************************************/
#ifndef _EXT2_PROTOS_H_
#define _EXT2_PROTOS_H_
#ifdef __REACTOS__
typedef PIO_STACK_LOCATION PEXTENDED_IO_STACK_LOCATION;
#endif
/*************************************************************************
* Prototypes for the file sfsdinit.c
*************************************************************************/
extern NTSTATUS NTAPI DriverEntry(
PDRIVER_OBJECT DriverObject, // created by the I/O sub-system
PUNICODE_STRING RegistryPath); // path to the registry key
extern void NTAPI Ext2FsdInitializeFunctionPointers(
PDRIVER_OBJECT DriverObject); // created by the I/O sub-system
extern VOID NTAPI Ext2QueueHandlerThread(
IN PVOID StartContext);
/*************************************************************************
* Prototypes for the file fsctrl.c
*************************************************************************/
extern NTSTATUS NTAPI Ext2FileSystemControl(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
);
extern NTSTATUS NTAPI Ext2VerifyVolume (
IN PIRP Irp,
IN PIO_STACK_LOCATION IrpSp );
/*************************************************************************
* Prototypes for the file create.c
*************************************************************************/
extern NTSTATUS NTAPI Ext2Create(
PDEVICE_OBJECT DeviceObject, // the logical volume device object
PIRP Irp); // I/O Request Packet
extern NTSTATUS NTAPI Ext2CommonCreate(
PtrExt2IrpContext PtrIrpContext,
PIRP PtrIrp,
BOOLEAN FirstAttempt );
extern NTSTATUS NTAPI Ext2OpenVolume(
PtrExt2VCB PtrVCB, // volume to be opened
PtrExt2IrpContext PtrIrpContext, // IRP context
PIRP PtrIrp, // original/user IRP
unsigned short ShareAccess, // share access
PIO_SECURITY_CONTEXT PtrSecurityContext, // caller's context (incl access)
PFILE_OBJECT PtrNewFileObject); // I/O Mgr. created file object
extern NTSTATUS NTAPI Ext2OpenRootDirectory(
PtrExt2VCB PtrVCB, // volume to be opened
PtrExt2IrpContext PtrIrpContext, // IRP context
PIRP PtrIrp, // original/user IRP
unsigned short ShareAccess, // share access
PIO_SECURITY_CONTEXT PtrSecurityContext, // caller's context (incl access)
PFILE_OBJECT PtrNewFileObject); // I/O Mgr. created file object
extern void NTAPI Ext2InitializeFCB(
PtrExt2FCB PtrNewFCB, // FCB structure to be initialized
PtrExt2VCB PtrVCB, // logical volume (VCB) pointer
PtrExt2ObjectName PtrObjectName, // name of the object
uint32 Flags, // is this a file/directory, etc.
PFILE_OBJECT PtrFileObject);// optional file object to be initialized
extern PtrExt2FCB NTAPI Ext2LocateChildFCBInCore(
PtrExt2VCB PtrVCB,
PUNICODE_STRING PtrName,
ULONG ParentInodeNo );
extern PtrExt2FCB NTAPI Ext2LocateFCBInCore(
PtrExt2VCB PtrVCB,
ULONG InodeNo );
extern ULONG NTAPI Ext2LocateFileInDisk(
PtrExt2VCB PtrVCB,
PUNICODE_STRING PtrCurrentName,
PtrExt2FCB PtrParentFCB,
ULONG *Type );
extern ULONG NTAPI Ext2CreateFile(
PtrExt2IrpContext PtrIrpContext,
PtrExt2VCB PtrVCB,
PUNICODE_STRING PtrName,
PtrExt2FCB PtrParentFCB,
ULONG Type);
extern BOOLEAN NTAPI Ext2OverwriteFile(
PtrExt2FCB PtrFCB,
PtrExt2IrpContext PtrIrpContext);
extern BOOLEAN NTAPI Ext2SupersedeFile(
PtrExt2FCB PtrFCB,
PtrExt2IrpContext PtrIrpContext);
/*************************************************************************
* Prototypes for the file misc.c
*************************************************************************/
extern NTSTATUS NTAPI Ext2InitializeZones(
void);
extern void NTAPI Ext2DestroyZones(
void);
extern BOOLEAN NTAPI Ext2IsIrpTopLevel(
PIRP Irp); // the IRP sent to our dispatch routine
extern long NTAPI Ext2ExceptionFilter(
PtrExt2IrpContext PtrIrpContext,
PEXCEPTION_POINTERS PtrExceptionPointers);
extern NTSTATUS NTAPI Ext2ExceptionHandler(
PtrExt2IrpContext PtrIrpContext,
PIRP Irp);
extern void NTAPI Ext2LogEvent(
NTSTATUS Ext2EventLogId, // the Ext2 private message id
NTSTATUS RC); // any NT error code we wish to log ...
extern PtrExt2ObjectName NTAPI Ext2AllocateObjectName(
void);
extern void NTAPI Ext2ReleaseObjectName(
PtrExt2ObjectName PtrObjectName);
extern PtrExt2CCB NTAPI Ext2AllocateCCB(
void );
extern PtrExt2FCB NTAPI Ext2GetUsedFCB(
PtrExt2VCB PtrVCB );
extern BOOLEAN NTAPI Ext2CloseClosableFCB(
PtrExt2FCB PtrFCB );
extern void NTAPI Ext2ReleaseCCB(
PtrExt2CCB PtrCCB);
extern PtrExt2FCB NTAPI Ext2AllocateFCB(
void);
extern NTSTATUS NTAPI Ext2CreateNewFCB(
PtrExt2FCB *ReturnedFCB,
LARGE_INTEGER AllocationSize,
LARGE_INTEGER EndOfFile,
PFILE_OBJECT PtrFileObject,
PtrExt2VCB PtrVCB,
PtrExt2ObjectName PtrObjectName);
extern NTSTATUS NTAPI Ext2CreateNewCCB(
PtrExt2CCB *ReturnedCCB,
PtrExt2FCB PtrFCB,
PFILE_OBJECT PtrFileObject);
extern void NTAPI Ext2ReleaseFCB(
PtrExt2FCB PtrFCB);
extern PtrExt2FileLockInfo NTAPI Ext2AllocateByteLocks(
void);
extern void NTAPI Ext2ReleaseByteLocks(
PtrExt2FileLockInfo PtrByteLocks);
extern PtrExt2IrpContext NTAPI Ext2AllocateIrpContext(
PIRP Irp,
PDEVICE_OBJECT PtrTargetDeviceObject);
extern void NTAPI Ext2ReleaseIrpContext(
PtrExt2IrpContext PtrIrpContext);
extern NTSTATUS NTAPI Ext2PostRequest(
PtrExt2IrpContext PtrIrpContext,
PIRP PtrIrp);
extern void NTAPI Ext2CommonDispatch(
void *Context); // actually an IRPContext structure
extern void NTAPI Ext2InitializeVCB(
PDEVICE_OBJECT PtrVolumeDeviceObject,
PDEVICE_OBJECT PtrTargetDeviceObject,
PVPB PtrVPB,
PLARGE_INTEGER AllocationSize);
extern void NTAPI Ext2CompleteRequest(
IN PIRP Irp OPTIONAL,
IN NTSTATUS Status
);
extern NTSTATUS NTAPI Ext2DenyAccess(
IN PIRP Irp
);
extern NTSTATUS NTAPI Ext2GetFCB_CCB_VCB_FromFileObject(
IN PFILE_OBJECT PtrFileObject,
OUT PtrExt2FCB *PPtrFCB,
OUT PtrExt2CCB *PPtrCCB,
OUT PtrExt2VCB *PPtrVCB );
extern void NTAPI Ext2CopyUnicodeString(
IN OUT PUNICODE_STRING PtrDestinationString,
IN PUNICODE_STRING PtrSourceString );
extern void NTAPI Ext2CopyWideCharToUnicodeString(
IN OUT PUNICODE_STRING PtrDestinationString,
IN PCWSTR PtrSourceString );
extern void NTAPI Ext2CopyCharToUnicodeString(
IN OUT PUNICODE_STRING PtrDestinationString,
IN PCSTR PtrSourceString,
IN USHORT SourceStringLength );
extern void NTAPI Ext2CopyZCharToUnicodeString(
IN OUT PUNICODE_STRING PtrDestinationString,
IN PCSTR PtrSourceString );
extern void NTAPI Ext2DeallocateUnicodeString(
PUNICODE_STRING PtrUnicodeString );
extern void NTAPI Ext2ZerooutUnicodeString(
PUNICODE_STRING PtrUnicodeString );
extern BOOLEAN NTAPI Ext2SaveBCB(
PtrExt2IrpContext PtrIrpContext,
PBCB PtrBCB,
PFILE_OBJECT PtrFileObject);
extern BOOLEAN NTAPI Ext2FlushSavedBCBs(
PtrExt2IrpContext PtrIrpContext);
extern BOOLEAN NTAPI AssertBCB(
PBCB PtrBCB);
extern ULONG NTAPI Ext2Align(
ULONG NumberToBeAligned,
ULONG Alignment);
extern LONGLONG NTAPI Ext2Align64(
LONGLONG NumberToBeAligned,
LONGLONG Alignment);
extern ULONG NTAPI Ext2GetCurrentTime(VOID);
/*************************************************************************
* Prototypes for the file cleanup.c
*************************************************************************/
extern NTSTATUS NTAPI Ext2Cleanup(
PDEVICE_OBJECT DeviceObject, // the logical volume device object
PIRP Irp); // I/O Request Packet
extern NTSTATUS NTAPI Ext2CommonCleanup(
PtrExt2IrpContext PtrIrpContext,
PIRP PtrIrp,
BOOLEAN FirstAttempt );
/*************************************************************************
* Prototypes for the file close.c
*************************************************************************/
extern NTSTATUS NTAPI Ext2Close(
PDEVICE_OBJECT DeviceObject, // the logical volume device object
PIRP Irp); // I/O Request Packet
extern NTSTATUS NTAPI Ext2CommonClose(
PtrExt2IrpContext PtrIrpContext,
PIRP PtrIrp,
BOOLEAN FirstAttempt );
/*************************************************************************
* Prototypes for the file read.c
*************************************************************************/
extern NTSTATUS NTAPI Ext2Read(
PDEVICE_OBJECT DeviceObject, // the logical volume device object
PIRP Irp); // I/O Request Packet
extern NTSTATUS NTAPI Ext2CommonRead(
PtrExt2IrpContext PtrIrpContext,
PIRP PtrIrp,
BOOLEAN FirstAttempt );
extern void * NTAPI Ext2GetCallersBuffer(
PIRP PtrIrp);
extern NTSTATUS NTAPI Ext2LockCallersBuffer(
PIRP PtrIrp,
BOOLEAN IsReadOperation,
uint32 Length);
extern void NTAPI Ext2MdlComplete(
PtrExt2IrpContext PtrIrpContext,
PIRP PtrIrp,
PIO_STACK_LOCATION PtrIoStackLocation,
BOOLEAN ReadCompletion);
/*************************************************************************
* Prototypes for the file write.c
*************************************************************************/
extern NTSTATUS NTAPI Ext2Write(
PDEVICE_OBJECT DeviceObject, // the logical volume device object
PIRP Irp); // I/O Request Packet
extern NTSTATUS NTAPI Ext2CommonWrite(
PtrExt2IrpContext PtrIrpContext,
PIRP PtrIrp);
extern void NTAPI Ext2DeferredWriteCallBack (
void *Context1, // Should be PtrIrpContext
void *Context2); // Should be PtrIrp
/*************************************************************************
* Prototypes for the file fileinfo.c
*************************************************************************/
extern NTSTATUS NTAPI Ext2FileInfo(
PDEVICE_OBJECT DeviceObject, // the logical volume device object
PIRP Irp); // I/O Request Packet
extern NTSTATUS NTAPI Ext2CommonFileInfo(
PtrExt2IrpContext PtrIrpContext,
PIRP PtrIrp);
extern NTSTATUS NTAPI Ext2GetBasicInformation(
PtrExt2FCB PtrFCB,
PFILE_BASIC_INFORMATION PtrBuffer,
long *PtrReturnedLength);
extern NTSTATUS NTAPI Ext2GetStandardInformation(
PtrExt2FCB PtrFCB,
PFILE_STANDARD_INFORMATION PtrStdInformation,
long *PtrReturnedLength);
extern NTSTATUS NTAPI Ext2GetNetworkOpenInformation(
PtrExt2FCB PtrFCB,
PFILE_NETWORK_OPEN_INFORMATION PtrNetworkOpenInformation,
long *PtrReturnedLength );
extern NTSTATUS NTAPI Ext2GetFullNameInformation(
PtrExt2FCB PtrFCB,
PtrExt2CCB PtrCCB,
PFILE_NAME_INFORMATION PtrNameInformation,
long *PtrReturnedLength);
extern NTSTATUS NTAPI Ext2SetBasicInformation(
PtrExt2IrpContext PtrIrpContext,
PtrExt2FCB PtrFCB,
PFILE_OBJECT PtrFileObject,
PFILE_BASIC_INFORMATION PtrFileInformation );
extern NTSTATUS NTAPI Ext2SetDispositionInformation(
PtrExt2FCB PtrFCB,
PtrExt2CCB PtrCCB,
PtrExt2VCB PtrVCB,
PFILE_OBJECT PtrFileObject,
PtrExt2IrpContext PtrIrpContext,
PIRP PtrIrp,
PFILE_DISPOSITION_INFORMATION PtrBuffer);
extern NTSTATUS NTAPI Ext2SetAllocationInformation(
PtrExt2FCB PtrFCB,
PtrExt2CCB PtrCCB,
PtrExt2VCB PtrVCB,
PFILE_OBJECT PtrFileObject,
PtrExt2IrpContext PtrIrpContext,
PIRP PtrIrp,
PFILE_ALLOCATION_INFORMATION PtrBuffer);
/*************************************************************************
* Prototypes for the file flush.c
*************************************************************************/
extern NTSTATUS NTAPI Ext2Flush(
PDEVICE_OBJECT DeviceObject, // the logical volume device object
PIRP Irp); // I/O Request Packet
extern NTSTATUS NTAPI Ext2CommonFlush(
PtrExt2IrpContext PtrIrpContext,
PIRP PtrIrp);
extern void NTAPI Ext2FlushAFile(
PtrExt2NTRequiredFCB PtrReqdFCB,
PIO_STATUS_BLOCK PtrIoStatus);
extern void NTAPI Ext2FlushLogicalVolume(
PtrExt2IrpContext PtrIrpContext,
PIRP PtrIrp,
PtrExt2VCB PtrVCB);
extern NTSTATUS NTAPI Ext2FlushCompletion(
PDEVICE_OBJECT PtrDeviceObject,
PIRP PtrIrp,
PVOID Context);
/*************************************************************************
* Prototypes for the file dircntrl.c
*************************************************************************/
extern NTSTATUS NTAPI Ext2DirControl(
PDEVICE_OBJECT DeviceObject, // the logical volume device object
PIRP Irp); // I/O Request Packet
extern NTSTATUS NTAPI Ext2CommonDirControl(
PtrExt2IrpContext PtrIrpContext,
PIRP PtrIrp);
extern NTSTATUS NTAPI Ext2QueryDirectory(
PtrExt2IrpContext PtrIrpContext,
PIRP PtrIrp,
PEXTENDED_IO_STACK_LOCATION PtrIoStackLocation,
PFILE_OBJECT PtrFileObject,
PtrExt2FCB PtrFCB,
PtrExt2CCB PtrCCB);
extern NTSTATUS NTAPI Ext2NotifyChangeDirectory(
PtrExt2IrpContext PtrIrpContext,
PIRP PtrIrp,
PEXTENDED_IO_STACK_LOCATION PtrIoStackLocation,
PFILE_OBJECT PtrFileObject,
PtrExt2FCB PtrFCB,
PtrExt2CCB PtrCCB);
/*************************************************************************
* Prototypes for the file devcntrl.c
*************************************************************************/
extern NTSTATUS NTAPI Ext2DeviceControl(
PDEVICE_OBJECT DeviceObject, // the logical volume device object
PIRP Irp); // I/O Request Packet
extern NTSTATUS NTAPI Ext2CommonDeviceControl(
PtrExt2IrpContext PtrIrpContext,
PIRP PtrIrp);
extern NTSTATUS NTAPI Ext2DevIoctlCompletion(
PDEVICE_OBJECT PtrDeviceObject,
PIRP PtrIrp,
void *Context);
extern NTSTATUS NTAPI Ext2HandleQueryPath(
void *BufferPointer);
/*************************************************************************
* Prototypes for the file shutdown.c
*************************************************************************/
extern NTSTATUS NTAPI Ext2Shutdown(
PDEVICE_OBJECT DeviceObject, // the logical volume device object
PIRP Irp); // I/O Request Packet
extern NTSTATUS NTAPI Ext2CommonShutdown(
PtrExt2IrpContext PtrIrpContext,
PIRP PtrIrp);
/*************************************************************************
* Prototypes for the file volinfo.c
*************************************************************************/
extern NTSTATUS NTAPI Ext2QueryVolInfo(
PDEVICE_OBJECT DeviceObject, // the logical volume device object
PIRP Irp); // I/O Request Packet
NTSTATUS NTAPI Ext2SetVolInfo(
IN PDEVICE_OBJECT DeviceObject, // the logical volume device object
IN PIRP Irp); // I/O Request Packet
/*************************************************************************
* Prototypes for the file fastio.c
*************************************************************************/
extern BOOLEAN NTAPI Ext2FastIoCheckIfPossible(
IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset,
IN ULONG Length,
IN BOOLEAN Wait,
IN ULONG LockKey,
IN BOOLEAN CheckForReadOperation,
OUT PIO_STATUS_BLOCK IoStatus,
IN PDEVICE_OBJECT DeviceObject);
extern BOOLEAN NTAPI Ext2FastIoRead(
IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset,
IN ULONG Length,
IN BOOLEAN Wait,
IN ULONG LockKey,
OUT PVOID Buffer,
OUT PIO_STATUS_BLOCK IoStatus,
IN PDEVICE_OBJECT DeviceObject);
extern BOOLEAN NTAPI Ext2FastIoWrite(
IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset,
IN ULONG Length,
IN BOOLEAN Wait,
IN ULONG LockKey,
OUT PVOID Buffer,
OUT PIO_STATUS_BLOCK IoStatus,
IN PDEVICE_OBJECT DeviceObject);
extern BOOLEAN NTAPI Ext2FastIoQueryBasicInfo(
IN PFILE_OBJECT FileObject,
IN BOOLEAN Wait,
OUT PFILE_BASIC_INFORMATION Buffer,
OUT PIO_STATUS_BLOCK IoStatus,
IN PDEVICE_OBJECT DeviceObject);
extern BOOLEAN NTAPI Ext2FastIoQueryStdInfo(
IN PFILE_OBJECT FileObject,
IN BOOLEAN Wait,
OUT PFILE_STANDARD_INFORMATION Buffer,
OUT PIO_STATUS_BLOCK IoStatus,
IN PDEVICE_OBJECT DeviceObject);
extern BOOLEAN NTAPI Ext2FastIoLock(
IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset,
IN PLARGE_INTEGER Length,
PEPROCESS ProcessId,
ULONG Key,
BOOLEAN FailImmediately,
BOOLEAN ExclusiveLock,
OUT PIO_STATUS_BLOCK IoStatus,
IN PDEVICE_OBJECT DeviceObject);
extern BOOLEAN NTAPI Ext2FastIoUnlockSingle(
IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset,
IN PLARGE_INTEGER Length,
PEPROCESS ProcessId,
ULONG Key,
OUT PIO_STATUS_BLOCK IoStatus,
IN PDEVICE_OBJECT DeviceObject);
extern BOOLEAN NTAPI Ext2FastIoUnlockAll(
IN PFILE_OBJECT FileObject,
PEPROCESS ProcessId,
OUT PIO_STATUS_BLOCK IoStatus,
IN PDEVICE_OBJECT DeviceObject);
extern BOOLEAN NTAPI Ext2FastIoUnlockAllByKey(
IN PFILE_OBJECT FileObject,
PVOID ProcessId,
ULONG Key,
OUT PIO_STATUS_BLOCK IoStatus,
IN PDEVICE_OBJECT DeviceObject);
extern void NTAPI Ext2FastIoAcqCreateSec(
IN PFILE_OBJECT FileObject);
extern void NTAPI Ext2FastIoRelCreateSec(
IN PFILE_OBJECT FileObject);
extern BOOLEAN NTAPI Ext2AcqLazyWrite(
IN PVOID Context,
IN BOOLEAN Wait);
extern void NTAPI Ext2RelLazyWrite(
IN PVOID Context);
extern BOOLEAN NTAPI Ext2AcqReadAhead(
IN PVOID Context,
IN BOOLEAN Wait);
extern void NTAPI Ext2RelReadAhead(
IN PVOID Context);
// the remaining are only valid under NT Version 4.0 and later
#if(_WIN32_WINNT >= 0x0400)
extern BOOLEAN NTAPI Ext2FastIoQueryNetInfo(
IN PFILE_OBJECT FileObject,
IN BOOLEAN Wait,
OUT PFILE_NETWORK_OPEN_INFORMATION Buffer,
OUT PIO_STATUS_BLOCK IoStatus,
IN PDEVICE_OBJECT DeviceObject);
extern BOOLEAN NTAPI Ext2FastIoMdlRead(
IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset,
IN ULONG Length,
IN ULONG LockKey,
OUT PMDL *MdlChain,
OUT PIO_STATUS_BLOCK IoStatus,
IN PDEVICE_OBJECT DeviceObject);
extern BOOLEAN NTAPI Ext2FastIoMdlReadComplete(
IN PFILE_OBJECT FileObject,
OUT PMDL MdlChain,
IN PDEVICE_OBJECT DeviceObject);
extern BOOLEAN NTAPI Ext2FastIoPrepareMdlWrite(
IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset,
IN ULONG Length,
IN ULONG LockKey,
OUT PMDL *MdlChain,
OUT PIO_STATUS_BLOCK IoStatus,
IN PDEVICE_OBJECT DeviceObject);
extern BOOLEAN NTAPI Ext2FastIoMdlWriteComplete(
IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER FileOffset,
OUT PMDL MdlChain,
IN PDEVICE_OBJECT DeviceObject);
extern NTSTATUS NTAPI Ext2FastIoAcqModWrite(
IN PFILE_OBJECT FileObject,
IN PLARGE_INTEGER EndingOffset,
OUT PERESOURCE *ResourceToRelease,
IN PDEVICE_OBJECT DeviceObject);
extern NTSTATUS NTAPI Ext2FastIoRelModWrite(
IN PFILE_OBJECT FileObject,
IN PERESOURCE ResourceToRelease,
IN PDEVICE_OBJECT DeviceObject);
extern NTSTATUS NTAPI Ext2FastIoAcqCcFlush(
IN PFILE_OBJECT FileObject,
IN PDEVICE_OBJECT DeviceObject);
extern NTSTATUS NTAPI Ext2FastIoRelCcFlush(
IN PFILE_OBJECT FileObject,
IN PDEVICE_OBJECT DeviceObject);
#endif // (_WIN32_WINNT >= 0x0400)
/*************************************************************************
* Prototypes for the file DiskIO.c
*************************************************************************/
extern NTSTATUS NTAPI Ext2ReadLogicalBlocks(
PDEVICE_OBJECT PtrTargetDeviceObject, // the Target Device Object
VOID *Buffer, // The Buffer that takes the data read in
LARGE_INTEGER StartLogicalBlock, // The logical block from which reading is to start
unsigned int NoOfLogicalBlocks); // The no. of logical blocks to be read
extern NTSTATUS NTAPI Ext2ReadPhysicalBlocks(
PDEVICE_OBJECT PtrTargetDeviceObject, // the Target Device Object
VOID *Buffer, // The Buffer that takes the data read in
LARGE_INTEGER StartBlock, // The Physical block from which reading is to start
unsigned int NoOfBlocks); // The no. of Physical blocks to be read
/*************************************************************************
* Prototypes for the file metadata.c
*************************************************************************/
extern void NTAPI Ext2InitializeFCBInodeInfo (
PtrExt2FCB PtrFCB );
extern NTSTATUS NTAPI Ext2ReadInode(
PtrExt2VCB PtrVcb, // the Volume Control Block
uint32 InodeNo, // The Inode no
PEXT2_INODE PtrInode ); // The Inode Buffer
extern NTSTATUS NTAPI Ext2WriteInode(
PtrExt2IrpContext PtrIrpContext,
PtrExt2VCB PtrVcb, // the Volume Control Block
uint32 InodeNo, // The Inode no
PEXT2_INODE PtrInode // The Inode Buffer
);
extern ULONG NTAPI Ext2AllocInode(
PtrExt2IrpContext PtrIrpContext,
PtrExt2VCB PtrVCB,
ULONG ParentINodeNo );
extern BOOLEAN NTAPI Ext2DeallocInode(
PtrExt2IrpContext PtrIrpContext,
PtrExt2VCB PtrVCB,
ULONG INodeNo );
extern BOOLEAN NTAPI Ext2MakeNewDirectoryEntry(
PtrExt2IrpContext PtrIrpContext, // The Irp context
PtrExt2FCB PtrParentFCB, // Parent Folder FCB
PFILE_OBJECT PtrFileObject, // Parent Folder Object
PUNICODE_STRING PtrName, // New entry's name
ULONG Type, // The type of the new entry
ULONG NewInodeNo); // The inode no of the new entry...
extern BOOLEAN NTAPI Ext2FreeDirectoryEntry(
PtrExt2IrpContext PtrIrpContext,
PtrExt2FCB PtrParentFCB,
PUNICODE_STRING PtrName);
extern BOOLEAN NTAPI Ext2AddBlockToFile(
PtrExt2IrpContext PtrIrpContext,
PtrExt2VCB PtrVCB,
PtrExt2FCB PtrFCB,
PFILE_OBJECT PtrFileObject,
BOOLEAN UpdateFileSize);
extern BOOLEAN NTAPI Ext2ReleaseDataBlocks(
PtrExt2FCB PtrFCB,
PtrExt2IrpContext PtrIrpContext);
extern BOOLEAN NTAPI Ext2TruncateFileAllocationSize(
PtrExt2IrpContext PtrIrpContext,
PtrExt2FCB PtrFCB,
PFILE_OBJECT PtrFileObject,
PLARGE_INTEGER PtrAllocationSize );
extern ULONG NTAPI Ext2AllocBlock(
PtrExt2IrpContext PtrIrpContext,
PtrExt2VCB PtrVCB,
ULONG Count);
extern BOOLEAN NTAPI Ext2DeallocBlock(
PtrExt2IrpContext PtrIrpContext,
PtrExt2VCB PtrVCB,
ULONG BlockNo);
extern BOOLEAN NTAPI Ext2UpdateFileSize(
PtrExt2IrpContext PtrIrpContext,
PFILE_OBJECT PtrFileObject,
PtrExt2FCB PtrFCB);
extern BOOLEAN NTAPI Ext2DeleteFile(
PtrExt2FCB PtrFCB,
PtrExt2IrpContext PtrIrpContext);
extern BOOLEAN NTAPI Ext2IsDirectoryEmpty(
PtrExt2FCB PtrFCB,
PtrExt2CCB PtrCCB,
PtrExt2IrpContext PtrIrpContext);
extern NTSTATUS NTAPI Ext2RenameOrLinkFile(
PtrExt2FCB PtrSourceFCB,
PFILE_OBJECT PtrSourceFileObject,
PtrExt2IrpContext PtrIrpContext,
PIRP PtrIrp,
PFILE_RENAME_INFORMATION PtrRenameInfo);
/*************************************************************************
* Prototypes for the file io.c
*************************************************************************/
extern NTSTATUS NTAPI Ext2PassDownSingleReadWriteIRP(
PtrExt2IrpContext PtrIrpContext,
PIRP PtrIrp,
PtrExt2VCB PtrVCB,
LARGE_INTEGER ByteOffset,
uint32 ReadWriteLength,
BOOLEAN SynchronousIo);
extern NTSTATUS NTAPI Ext2PassDownMultiReadWriteIRP(
PEXT2_IO_RUN PtrIoRuns,
UINT Count,
ULONG TotalReadWriteLength,
PtrExt2IrpContext PtrIrpContext,
PtrExt2FCB PtrFCB,
BOOLEAN SynchronousIo);
extern NTSTATUS NTAPI Ext2SingleSyncCompletionRoutine(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PVOID Contxt
);
extern NTSTATUS NTAPI Ext2SingleAsyncCompletionRoutine (
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PVOID Contxt
);
extern NTSTATUS NTAPI Ext2MultiSyncCompletionRoutine(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PVOID Contxt);
extern NTSTATUS NTAPI Ext2MultiAsyncCompletionRoutine(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PVOID Contxt);
#endif // _EXT2_PROTOS_H_

Some files were not shown because too many files have changed in this diff Show more