diff --git a/Contrib/System/Resource.dll b/Contrib/System/Resource.dll new file mode 100644 index 00000000..4ef1f834 Binary files /dev/null and b/Contrib/System/Resource.dll differ diff --git a/Contrib/System/SysFunc.nsh b/Contrib/System/SysFunc.nsh new file mode 100644 index 00000000..f699a139 --- /dev/null +++ b/Contrib/System/SysFunc.nsh @@ -0,0 +1,354 @@ +; Some useful functions based on System plugin +; +; (c) brainsucker, 2002 +; (r) BSForce + +; Check for double includes +!ifndef SysFunc.NSH.Included +!define SysFunc.NSH.Included + +!include "${NSISDIR}\Contrib\System\Additionals\System.nsh" + +!verbose 3 ; For WinMessages especially +!include "${NSISDIR}\Examples\WinMessages.nsh" +!verbose 3 + +; ================= systemGetFileSysTime implementation ================= + +!macro smGetFileSysTime FILENAME + Push ${FILENAME} + Call systemGetFileSysTime + Pop $R0 +!macroend + +; ----------------------------------------------------------------- +; systemGetFileSysTime (params on stack): +; FILENAME - name of file to get file time +; returns to stack (SYSTEMTIME struct addr) +; ----------------------------------------------------------------- + +; uses original method from NSIS +Function systemGetFileSysTime + System::Store "s r1" + + StrCpy $R0 0 + + ; create WIN32_FIND_DATA struct + System::Call '*${stWIN32_FIND_DATA} .r2' + + ; Find file info + System::Call '${sysFindFirstFile}(r1, r2) .r3' + + ; ok? + IntCmp $3 ${INVALID_HANDLE_VALUE} sgfst_exit + + ; close file search + System::Call '${sysFindClose}(r3)' + + ; Create systemtime struct for system time + System::Call '*${stSYSTEMTIME} .R1' + ; Create systemtime struct for local time + System::Call '*${stSYSTEMTIME} .R0' + + ; Get File time + System::Call '*$2${stWIN32_FIND_DATA} (,,, .r3)' + + ; Convert file time to system time + System::Call '${sysFileTimeToSystemTime}(r3, R1)' + + ; Convert system time to local time + System::Call '${sysSystemTimeToTzSpecificLocalTime}(0, R1, R0)' + + ; that's all, just clear used memory + System::Free $R1 + +sgfst_exit: + ; free used memory for WIN32_FIND_DATA struct + System::Free $2 + + System::Store "P0 l" +FunctionEnd + +; ================= systemMessageBox implementation ================= + +; return to $R0 +!macro smMessageBox MODULE MSG CAPTION STYLE ICON + Push "${ICON}" + Push "${STYLE}" + Push "${CAPTION}" + Push "${MSG}" + Push "${MODULE}" + Call systemMessageBox + Pop $R0 +!macroend + +; ----------------------------------------------------------------- +; systemMessageBox (params on stack): +; Module: either handle ("i HANDLE", HANDLE could be 0) or "modulename" +; Msg: text of message +; Caption: caption of message box window +; Style: style, buttons etc +; Icon: either icon handle ("i HANDLE") or resource name +; returns to stack +; ----------------------------------------------------------------- +Function systemMessageBox + System::Store "s r2r3r4r5r6" + + ; may be Module is module handle? + StrCpy $1 $2 + IntCmp $1 0 "0" smbnext smbnext + + ; Get module handle + System::Call '${sysGetModuleHandle}($2) .r1' + IntCmp $1 0 "0" smbnext smbnext + + ; Load module and get handle + System::Call '${sysLoadLibrary}($2) .r1' +smbnext: + + ; Create MSGBOXPARAMS structure + System::Call '*${stMSGBOXPARAMS}(, $HWNDPARENT, r1, r3, r4, "$5|${MB_USERICON}", $6, _) .r0' + ; call MessageBoxIndirect + System::Call '${sysMessageBoxIndirect}(r0) .R0' + ; free MSGBOXPARAMS structure + System::Free $0 + + System::Store "P0 l" +FunctionEnd + +; ================= systemSplash implementation ================= + +; returns to $R0 +!macro smSystemSplash DELAY FILE + Push ${FILE} + Push ${DELAY} + call systemSplash + Pop $R0 +!macroend + +; ----------------------------------------------------------------- +; systemSplash (params on stack): +; Delay - time in ms to show the splash +; File - bitmap (& audio) file name (without extension) +; returns to stack +; ----------------------------------------------------------------- + +Function _systemSplashWndCB + ; Callback receives 4 values + System::Store "s r2r5r7r9" + + ; Message branching + IntCmp $5 ${WM_CLOSE} m_Close + IntCmp $5 ${WM_TIMER} m_Timer + IntCmp $5 ${WM_LBUTTONDOWN} m_Lbtn + IntCmp $5 ${WM_CREATE} m_Create + IntCmp $5 ${WM_PAINT} m_Paint + goto default + +m_Create: + + ; Create structures + System::Call "*${stRECT} (_) .R8" + System::Call "*${stBITMAP} (_, &l0 .R7) .R9" + + ; Get bitmap info + System::Call "${sysGetObject} (r6, R7, R9)" + + ; Get desktop info + System::Call "${sysSystemParametersInfo} (${SPI_GETWORKAREA}, 0, R8, 0)" + + ; Style (callbacked) + System::Call "${sysSetWindowLong} (r2, ${GWL_STYLE}, 0) .s" + !insertmacro SINGLE_CALLBACK 5 $R7 1 _systemSplashWndCB + + ; Calculate and set window pos + + ; Get bmWidth(R2) and bmHeight(R3) + System::Call "*$R9${stBITMAP} (,.R2,.R3)" + ; Get left(R4), top(R5), right(R6), bottom(R7) + System::Call "*$R8${stRECT} (.R4,.R5,.R6,.R7)" + + ; Left pos + IntOp $R0 $R6 - $R4 + IntOp $R0 $R0 - $R2 + IntOp $R0 $R0 / 2 + IntOp $R0 $R0 + $R4 + + ; Top pos + IntOp $R1 $R7 - $R5 + IntOp $R1 $R1 - $R3 + IntOp $R1 $R1 / 2 + IntOp $R1 $R1 + $R5 + + System::Call "${sysSetWindowPos} (r2, 0, R0, R1, R2, R3, ${SWP_NOZORDER}) .s" + !insertmacro SINGLE_CALLBACK 6 $R7 1 _systemSplashWndCB + + ; Show window + System::Call "${sysShowWindow} (r2, ${SW_SHOW}) .s" + !insertmacro SINGLE_CALLBACK 7 $R7 1 _systemSplashWndCB + + ; Set Timer + System::Call "${sysSetTimer} (r2, 1, r8,)" + + ; Free used memory + System::Free $R8 + System::Free $R9 + + StrCpy $R0 0 + goto exit + +m_Paint: + + ; Create structures + System::Call "*${stRECT} (_) .R8" + System::Call "*${stPAINTSTRUCT} (_) .R9" + + ; Begin Paint + System::Call "${sysBeginPaint} (r2, R9) .R7" + + ; CreateCompatibleDC + System::Call "${sysCreateCompatibleDC} (R7) .R6" + + ; GetClientRect + System::Call "${sysGetClientRect} (r2, R8)" + + ; Select new bitmap + System::Call "${sysSelectObject} (R6, r6) .R5" + + ; Get left(R0), top(R1), right(R2), bottom(R3) + System::Call "*$R8${stRECT} (.R0,.R1,.R2,.R3)" + + ; width=right-left + IntOp $R2 $R2 - $R0 + ; height=bottom-top + IntOp $R3 $R3 - $R1 + + System::Call "${sysBitBlt} (R7, R0, R1, R2, R3, R6, 0, 0, ${SRCCOPY})" + + ; Select old bitmap + System::Call "${sysSelectObject} (R6, R5)" + + ; Delete compatible DC + System::Call "${sysDeleteDC} (R6)" + + ; End Paint + System::Call "${sysEndPaint} (r2, R9)" + + ; Free used memory + System::Free $R8 + System::Free $R9 + + StrCpy $R0 0 + goto exit + +m_Timer: +m_Lbtn: + StrCpy $4 0 + IntCmp $5 ${WM_TIMER} destroy + StrCpy $4 1 + +destroy: + System::Call "${sysDestroyWindow} (r2) .s" + !insertmacro SINGLE_CALLBACK 12 $R4 1 _systemSplashWndCB + +default: + ; Default + System::Call "${sysDefWindowProc} (r2, r5, r7, r9) .s" + !insertmacro SINGLE_CALLBACK 14 $R0 1 _systemSplashWndCB + goto exit + +m_Close: + StrCpy $R0 0 + goto exit + +exit: + ; Restore + System::Store "p4P0 l R0r4" + + ; Return from callback + System::Call "$3" $R0 +FunctionEnd + +Function systemSplash + + ; Save registers and get input + System::Store "s r8r9" + + ; Get module instance + System::Call "${sysGetModuleHandle} (i) .r7" + + ; Get arrow cursor + System::Call "${sysLoadCursor} (0, i ${IDC_ARROW}) .R9" + + ; Get callback + System::Get "${sysWNDPROC}" + Pop $3 + + ; Create window class + System::Call "*${stWNDCLASS} (,r3,,,r7,,R9,,,s) .R9" "_sp" + + ; Register window class + System::Call "${sysRegisterClass} (R9) .R9" + IntCmp $R9 0 errorexit ; Class registered ok? + + ; Load Image (LR_CREATEDIBSECTION|LR_LOADFROMFILE = 0x2010) + System::Call '${sysLoadImage} (, s, ${IMAGE_BITMAP}, 0, 0, ${LR_CREATEDIBSECTION}|${LR_LOADFROMFILE}) .r6' "$9.bmp" + IntCmp $6 0 errorexit ; Image loaded ok? + + ; Start the sound (SND_ASYNC|SND_FILENAME|SND_NODEFAULT = 0x20003) + System::Call "${sysPlaySound} (s,,${SND_ASYNC}|${SND_FILENAME}|${SND_NODEFAULT})" "$9.wav" + + ; Create window + System::Call "${sysCreateWindowEx} (${WS_EX_TOOLWINDOW}, s, s,,,,,, $HWNDPARENT,,r7,) .s" "_sp" "_sp" + !insertmacro SINGLE_CALLBACK 1 $5 1 _systemSplashWndCB + + ; Create MSG struct + System::Call "*${stMSG} (_) i.R9" + + ; ------------------------- +repeat: + ; Check for window + System::Call "${sysIsWindow} (r5) .s" + !insertmacro SINGLE_CALLBACK 2 $R8 1 _systemSplashWndCB + IntCmp $R8 0 finish + + ; Get message + System::Call "${sysGetMessage} (R9, r5,_) .s" + !insertmacro SINGLE_CALLBACK 3 $R8 1 _systemSplashWndCB + IntCmp $R8 0 finish + + ; Dispatch message + System::Call "${sysDispatchMessage} (R9) .s" + !insertmacro SINGLE_CALLBACK 4 $R8 1 _systemSplashWndCB + + ; Repeat dispatch cycle + goto repeat + ; ------------------------- + +finish: + ; Stop the sound + System::Call "${sysPlaySound}" + + ; Delete bitmap object + System::Call "${sysDeleteObject} (r6)" + + ; Delete the callback queue + System::Free $3 + + ; Dialog return + StrCpy $R0 $4 + goto exit + +; Exit in case of error +errorexit: + StrCpy $R0 -1 + goto exit + +exit: + ; Restore register and put output + System::Store "P0 l" +FunctionEnd + +!verbose 4 + +!endif \ No newline at end of file diff --git a/Contrib/System/System.nsh b/Contrib/System/System.nsh new file mode 100644 index 00000000..439aa03d --- /dev/null +++ b/Contrib/System/System.nsh @@ -0,0 +1,476 @@ +; Some useful functions, structures, constants +; +; (c) brainsucker, 2002 +; (r) BSForce + +; Check for double includes +!ifndef System.NSH.Included +!define System.NSH.Included + +!verbose 3 + +; ------------- Functions -------------- + +; LRESULT CALLBACK WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam); +!define sysWNDPROC "(i.s, i.s, i.s, i.s) iss" + +; LRESULT DefWindowProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam); +!define sysDefWindowProc "user32::DefWindowProcA(i, i, i, i) i" + +!define sysMessageBox "user32::MessageBoxA(i, t, t, i) i" + +!define sysMessageBoxIndirect 'user32::MessageBoxIndirectA(i) i' + +; HMODULE GetModuleHandle(LPCTSTR lpModuleName); +!define sysGetModuleHandle "kernel32::GetModuleHandleA(t) i" + +; HMODULE LoadLibrary(LPCTSTR lpFileName); +!define sysLoadLibrary "kernel32::LoadLibraryA(t) i" + +; HCURSOR LoadCursor(HINSTANCE hInstance, LPCTSTR lpCursorName); +!define sysLoadCursor "user32::LoadCursorA(i, t) i" + +; ATOM RegisterClass(CONST WNDCLASS *lpWndClass); +!define sysRegisterClass "user32::RegisterClassA(i) i" + +; HANDLE LoadImage(HINSTANCE hinst, LPCTSTR lpszName, UINT uType, +; int cxDesired, int cyDesired, UINT fuLoad); +!define sysLoadImage "user32::LoadImageA(i, t, i, i, i, i) i" + +; BOOL PlaySound(LPCSTR pszSound, HMODULE hmod, DWORD fdwSound); +!define sysPlaySound "winmm.dll::PlaySoundA(t, i, i) i" + +; HWND CreateWindowEx(DWORD dwExStyle, LPCTSTR lpClassName, LPCTSTR lpWindowName, +; DWORD dwStyle, int x, int y, int nWidth, int nHeight, HWND hWndParent, +; HMENU hMenu, HINSTANCE hInstance, LPVOID lpParam); +!define sysCreateWindowEx "user32::CreateWindowExA(i, t, t, i, i, i, i, i, i, i, i, i) i" + +; BOOL IsWindow(HWND hWnd); +!define sysIsWindow "user32::IsWindow(i) i" + +; LONG SetWindowLong(HWND hWnd, int nIndex, LONG dwNewLong); +!define sysSetWindowLong "user32::SetWindowLongA(i, i, i) i" + +; BOOL SetWindowPos(HWND hWnd, HWND hWndInsertAfter, int X, int Y, int cx, int cy, UINT uFlags); +!define sysSetWindowPos "user32::SetWindowPos(i, i, i, i, i, i, i) i" + +; BOOL ShowWindow(HWND hWnd, int nCmdShow); +!define sysShowWindow "user32::ShowWindow(i, i) i" + +; BOOL DestroyWindow(HWND hWnd); +!define sysDestroyWindow "user32::DestroyWindow(i) i" + +; BOOL GetClientRect(HWND hWnd, LPRECT lpRect); +!define sysGetClientRect "user32::GetClientRect(i, i) i" + +; BOOL GetMessage(LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax); +!define sysGetMessage "user32::GetMessageA(i, i, i, i) i" + +; LRESULT DispatchMessage(CONST MSG *lpmsg); +!define sysDispatchMessage "user32::DispatchMessageA(i) i" + +; BOOL DeleteObject(HGDIOBJ hObject); +!define sysDeleteObject "gdi32::DeleteObject(i) i" + +; int GetObject(HGDIOBJ hgdiobj, int cbBuffer, LPVOID lpvObject); +!define sysGetObject "gdi32::GetObjectA(i, i, i) i" + +; HGDIOBJ SelectObject(HDC hdc, HGDIOBJ hgdiobj); +!define sysSelectObject "gdi32::SelectObject(i, i) i" + +; HDC CreateCompatibleDC(HDC hdc); +!define sysCreateCompatibleDC "gdi32::CreateCompatibleDC(i) i" + +; BOOL DeleteDC(HDC hdc); +!define sysDeleteDC "gdi32::DeleteDC(i) i" + +; BOOL BitBlt(HDC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, +; HDC hdcSrc, int nXSrc, int nYSrc, DWORD dwRop); +!define sysBitBlt "gdi32::BitBlt(i, i, i, i, i, i, i, i, i) i" + +; HDC BeginPaint(HWND hwnd, LPPAINTSTRUCT lpPaint); +!define sysBeginPaint "user32::BeginPaint(i, i) i" + +; BOOL EndPaint(HWND hWnd, CONST PAINTSTRUCT *lpPaint); +!define sysEndPaint "user32::EndPaint(i, i) i" + +; BOOL SystemParametersInfo(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni); +!define sysSystemParametersInfo "user32::SystemParametersInfoA(i, i, i, i) i" + +; UINT_PTR SetTimer(HWND hWnd, UINT_PTR nIDEvent, UINT uElapse, TIMERPROC lpTimerFunc); +!define sysSetTimer "user32::SetTimer(i, i, i, k) i" + +!define sysGetLogicalDriveStrings 'kernel32::GetLogicalDriveStringsA(i, i) i' + +!define sysGetDiskFreeSpaceEx 'kernel32::GetDiskFreeSpaceExA(t, *l, *l, *l) i' + +; UINT GetDriveType(LPCTSTR lpRootPathName); +!define sysGetDriveType 'kernel32::GetDriveTypeA(t) i' + +; HANDLE FindFirstFile(LPCTSTR lpFileName,LPWIN32_FIND_DATA lpFindFileData); +!define sysFindFirstFile 'kernel32::FindFirstFileA(t, i) i' + +; BOOL FindClose(HANDLE hFindFile); +!define sysFindClose 'kernel32::FindClose(i) i' + +; BOOL FileTimeToSystemTime(CONST FILETIME *lpFileTime, +; LPSYSTEMTIME lpSystemTime); +!define sysFileTimeToSystemTime 'kernel32::FileTimeToSystemTime(*l, i) i' + +; BOOL SystemTimeToTzSpecificLocalTime(LPTIME_ZONE_INFORMATION lpTimeZone, +; LPSYSTEMTIME lpUniversalTime, LPSYSTEMTIME lpLocalTime); +!define sysSystemTimeToTzSpecificLocalTime 'kernel32::SystemTimeToTzSpecificLocalTime(i, i, i) i' + +!define syslstrlen 'kernel32::lstrlenA(t) i' + +; int wsprintf(LPTSTR lpOut, LPCTSTR lpFmt, ...); +!define syswsprintf "user32::wsprintfA(t, t) i ? c" + +; ------------- Structures -------------- + +; typedef struct _WNDCLASS { +; UINT style; +; WNDPROC lpfnWndProc; +; int cbClsExtra; +; int cbWndExtra; +; HINSTANCE hInstance; +; HICON hIcon; +; HCURSOR hCursor; +; HBRUSH hbrBackground; +; LPCTSTR lpszMenuName; +; LPCTSTR lpszClassName; +; } WNDCLASS, *PWNDCLASS; +!define stWNDCLASS "(i, k, i, i, i, i, i, i, t, t) i" + +; typedef struct tagMSG { +; HWND hwnd; +; UINT message; +; WPARAM wParam; +; LPARAM lParam; +; DWORD time; +; POINT pt; -> will be presented as two separate px and py +; } MSG, *PMSG; +!define stMSG "(i, i, i, i, i, i, i) i" + +; typedef struct tagBITMAP { +; LONG bmType; +; LONG bmWidth; +; LONG bmHeight; +; LONG bmWidthBytes; +; WORD bmPlanes; +; WORD bmBitsPixel; +; LPVOID bmBits; +; } BITMAP, *PBITMAP; +!define stBITMAP "(i, i, i, i, i, i, i) i" + +; typedef struct _RECT { +; LONG left; +; LONG top; +; LONG right; +; LONG bottom; +; } RECT, *PRECT; +!define stRECT "(i, i, i, i) i" + +; typedef struct tagPAINTSTRUCT { +; HDC hdc; +; BOOL fErase; +; RECT rcPaint; (rcl, rct, rcr, rcb) +; BOOL fRestore; +; BOOL fIncUpdate; +; BYTE rgbReserved[32]; +; } PAINTSTRUCT, *PPAINTSTRUCT; +!define stPAINTSTRUCT "(i, i, i, i, i, i, i, i, &v32) i" + +; typedef struct { +; UINT cbSize; +; HWND hwndOwner; +; HINSTANCE hInstance; +; LPCTSTR lpszText; +; LPCTSTR lpszCaption; +; DWORD dwStyle; +; LPCTSTR lpszIcon; +; DWORD_PTR dwContextHelpId; +; MSGBOXCALLBACK lpfnMsgBoxCallback; +; DWORD dwLanguageId; +; } MSGBOXPARAMS, *PMSGBOXPARAMS; +!define stMSGBOXPARAMS '(&l4, i, i, t, t, i, t, i, k, i) i' + +; typedef struct _SYSTEMTIME { +; WORD wYear; +; WORD wMonth; +; WORD wDayOfWeek; +; WORD wDay; +; WORD wHour; +; WORD wMinute; +; WORD wSecond; +; WORD wMilliseconds; +; } SYSTEMTIME, *PSYSTEMTIME; +!define stSYSTEMTIME '(&i2, &i2, &i2, &i2, &i2, &i2, &i2, &i2) i' + +; Maximal windows path +!define MAX_PATH 260 + +; typedef struct _WIN32_FIND_DATA { +; DWORD dwFileAttributes; +; FILETIME ftCreationTime; +; FILETIME ftLastAccessTime; +; FILETIME ftLastWriteTime; +; DWORD nFileSizeHigh; +; DWORD nFileSizeLow; +; DWORD dwReserved0; +; DWORD dwReserved1; +; TCHAR cFileName[ MAX_PATH ]; +; TCHAR cAlternateFileName[ 14 ]; +; } WIN32_FIND_DATA, *PWIN32_FIND_DATA; +!define stWIN32_FIND_DATA '(i, l, l, l, i, i, i, i, &t${MAX_PATH}, &t14) i' + +; ------------- Constants -------------- + +; == Other == +!define INVALID_HANDLE_VALUE -1 + +; == Cursors == + +!define IDC_ARROW 32512 +!define IDC_IBEAM 32513 +!define IDC_WAIT 32514 +!define IDC_CROSS 32515 +!define IDC_UPARROW 32516 +!define IDC_SIZE 32640 +!define IDC_ICON 32641 +!define IDC_SIZENWSE 32642 +!define IDC_SIZENESW 32643 +!define IDC_SIZEWE 32644 +!define IDC_SIZENS 32645 +!define IDC_SIZEALL 32646 +!define IDC_NO 32648 +!define IDC_HAND 32649 +!define IDC_APPSTARTING 32650 +!define IDC_HELP 32651 + +; == Images == + +!define IMAGE_BITMAP 0 +!define IMAGE_ICON 1 +!define IMAGE_CURSOR 2 +!define IMAGE_ENHMETAFILE 3 + +!define LR_DEFAULTCOLOR 0x0000 +!define LR_MONOCHROME 0x0001 +!define LR_COLOR 0x0002 +!define LR_COPYRETURNORG 0x0004 +!define LR_COPYDELETEORG 0x0008 +!define LR_LOADFROMFILE 0x0010 +!define LR_LOADTRANSPARENT 0x0020 +!define LR_DEFAULTSIZE 0x0040 +!define LR_VGACOLOR 0x0080 +!define LR_LOADMAP3DCOLORS 0x1000 +!define LR_CREATEDIBSECTION 0x2000 +!define LR_COPYFROMRESOURCE 0x4000 +!define LR_SHARED 0x8000 + +; == Sounds == + +!define SND_SYNC 0x0000 +!define SND_ASYNC 0x0001 +!define SND_NODEFAULT 0x0002 +!define SND_MEMORY 0x0004 +!define SND_LOOP 0x0008 +!define SND_NOSTOP 0x0010 + +!define SND_NOWAIT 0x00002000 +!define SND_ALIAS 0x00010000 +!define SND_ALIAS_ID 0x00110000 +!define SND_FILENAME 0x00020000 +!define SND_RESOURCE 0x00040004 +!define SND_PURGE 0x0040 +!define SND_APPLICATION 0x0080 + +; == Windows == + +!define WS_OVERLAPPED 0x00000000 +!define WS_POPUP 0x80000000 +!define WS_CHILD 0x40000000 +!define WS_MINIMIZE 0x20000000 +!define WS_VISIBLE 0x10000000 +!define WS_DISABLED 0x08000000 +!define WS_CLIPSIBLINGS 0x04000000 +!define WS_CLIPCHILDREN 0x02000000 +!define WS_MAXIMIZE 0x01000000 +!define WS_CAPTION 0x00C00000 +!define WS_BORDER 0x00800000 +!define WS_DLGFRAME 0x00400000 +!define WS_VSCROLL 0x00200000 +!define WS_HSCROLL 0x00100000 +!define WS_SYSMENU 0x00080000 +!define WS_THICKFRAME 0x00040000 +!define WS_GROUP 0x00020000 +!define WS_TABSTOP 0x00010000 +!define WS_MINIMIZEBOX 0x00020000 +!define WS_MAXIMIZEBOX 0x00010000 +!define WS_TILED ${WS_OVERLAPPED} +!define WS_ICONIC ${WS_MINIMIZE} +!define WS_SIZEBOX ${WS_THICKFRAME} +!define WS_OVERLAPPEDWINDOW 0x00CF0000 +!define WS_TILEDWINDOW ${WS_OVERLAPPEDWINDOW} +!define WS_POPUPWINDOW 0x80880000 +!define WS_CHILDWINDOW ${WS_CHILD} +!define WS_EX_DLGMODALFRAME 0x00000001 +!define WS_EX_NOPARENTNOTIFY 0x00000004 +!define WS_EX_TOPMOST 0x00000008 +!define WS_EX_ACCEPTFILES 0x00000010 +!define WS_EX_TRANSPARENT 0x00000020 +!define WS_EX_MDICHILD 0x00000040 +!define WS_EX_TOOLWINDOW 0x00000080 +!define WS_EX_WINDOWEDGE 0x00000100 +!define WS_EX_CLIENTEDGE 0x00000200 +!define WS_EX_CONTEXTHELP 0x00000400 +!define WS_EX_RIGHT 0x00001000 +!define WS_EX_LEFT 0x00000000 +!define WS_EX_RTLREADING 0x00002000 +!define WS_EX_LTRREADING 0x00000000 +!define WS_EX_LEFTSCROLLBAR 0x00004000 +!define WS_EX_RIGHTSCROLLBAR 0x00000000 +!define WS_EX_CONTROLPARENT 0x00010000 +!define WS_EX_STATICEDGE 0x00020000 +!define WS_EX_APPWINDOW 0x00040000 +!define WS_EX_OVERLAPPEDWINDOW 0x00000300 +!define WS_EX_PALETTEWINDOW 0x00000188 +!define WS_EX_LAYERED 0x00080000 +!define WS_EX_NOINHERITLAYOUT 0x00100000 +!define WS_EX_LAYOUTRTL 0x00400000 +!define WS_EX_COMPOSITED 0x02000000 +!define WS_EX_NOACTIVATE 0x08000000 + + +; == System Parameters Info == + +!define SPI_GETWORKAREA 0x0030 + +; == Window Long Offsets == + +!define GWL_WNDPROC -4 +!define GWL_HINSTANCE -6 +!define GWL_HWNDPARENT -8 +!define GWL_STYLE -16 +!define GWL_EXSTYLE -20 +!define GWL_USERDATA -21 +!define GWL_ID -12 + +; == Show Window == + +!define SW_HIDE 0 +!define SW_SHOWNORMAL 1 +!define SW_NORMAL 1 +!define SW_SHOWMINIMIZED 2 +!define SW_SHOWMAXIMIZED 3 +!define SW_MAXIMIZE 3 +!define SW_SHOWNOACTIVATE 4 +!define SW_SHOW 5 +!define SW_MINIMIZE 6 +!define SW_SHOWMINNOACTIVE 7 +!define SW_SHOWNA 8 +!define SW_RESTORE 9 +!define SW_SHOWDEFAULT 10 +!define SW_FORCEMINIMIZE 11 +!define SW_MAX 11 + +; == Window swap == + +!define SWP_NOSIZE 0x0001 +!define SWP_NOMOVE 0x0002 +!define SWP_NOZORDER 0x0004 +!define SWP_NOREDRAW 0x0008 +!define SWP_NOACTIVATE 0x0010 +!define SWP_FRAMECHANGED 0x0020 +!define SWP_SHOWWINDOW 0x0040 +!define SWP_HIDEWINDOW 0x0080 +!define SWP_NOCOPYBITS 0x0100 +!define SWP_NOOWNERZORDER 0x0200 +!define SWP_NOSENDCHANGING 0x0400 + +!define SWP_DRAWFRAME ${SWP_FRAMECHANGED} +!define SWP_NOREPOSITION ${SWP_NOOWNERZORDER} +!define SWP_DEFERERASE 0x2000 +!define SWP_ASYNCWINDOWPOS 0x4000 + +; == Bit Copy == + +!define SRCCOPY 0x00CC0020 +!define SRCPAINT 0x00EE0086 +!define SRCAND 0x008800C6 +!define SRCINVERT 0x00660046 +!define SRCERASE 0x00440328 +!define NOTSRCCOPY 0x00330008 +!define NOTSRCERASE 0x001100A6 +!define MERGECOPY 0x00C000CA +!define MERGEPAINT 0x00BB0226 +!define PATCOPY 0x00F00021 +!define PATPAINT 0x00FB0A09 +!define PATINVERT 0x005A0049 +!define DSTINVERT 0x00550009 +!define BLACKNESS 0x00000042 +!define WHITENESS 0x00FF0062 + +; == Message Box == + +!define MB_OK 0x00000000 +!define MB_OKCANCEL 0x00000001 +!define MB_ABORTRETRYIGNORE 0x00000002 +!define MB_YESNOCANCEL 0x00000003 +!define MB_YESNO 0x00000004 +!define MB_RETRYCANCEL 0x00000005 +!define MB_CANCELTRYCONTINUE 0x00000006 +!define MB_ICONHAND 0x00000010 +!define MB_ICONQUESTION 0x00000020 +!define MB_ICONEXCLAMATION 0x00000030 +!define MB_ICONASTERISK 0x00000040 +!define MB_USERICON 0x00000080 +!define MB_ICONWARNING ${MB_ICONEXCLAMATION} +!define MB_ICONERROR ${MB_ICONHAND} + +!define MB_ICONINFORMATION ${MB_ICONASTERISK} +!define MB_ICONSTOP ${MB_ICONHAND} + +!define MB_DEFBUTTON1 0x00000000 +!define MB_DEFBUTTON2 0x00000100 +!define MB_DEFBUTTON3 0x00000200 +!define MB_DEFBUTTON4 0x00000300 + +!define MB_APPLMODAL 0x00000000 +!define MB_SYSTEMMODAL 0x00001000 +!define MB_TASKMODAL 0x00002000 +!define MB_HELP 0x00004000 + +!define MB_NOFOCUS 0x00008000 +!define MB_SETFOREGROUND 0x00010000 +!define MB_DEFAULT_DESKTOP_ONLY 0x00020000 + +!define MB_TOPMOST 0x00040000 +!define MB_RIGHT 0x00080000 +!define MB_RTLREADING 0x00100000 + +; == Drive type constants == + +!define DRIVE_UNKNOWN 0 +!define DRIVE_NO_ROOT_DIR 1 +!define DRIVE_REMOVABLE 2 +!define DRIVE_FIXED 3 +!define DRIVE_REMOTE 4 +!define DRIVE_CDROM 5 +!define DRIVE_RAMDISK 6 + +; == Callbacks == + +!macro SINGLE_CALLBACK CHKN RES INDEX FUNC +CheckCB_${CHKN}: + Pop ${RES} + StrCmp ${RES} "callback${INDEX}" 0 ExitCB_${CHKN} + Call ${FUNC} + Goto CheckCB_${CHKN} +ExitCB_${CHKN}: +!macroend + +!verbose 4 + +!endif \ No newline at end of file diff --git a/Contrib/System/System.nsi b/Contrib/System/System.nsi new file mode 100644 index 00000000..0f2659a6 --- /dev/null +++ b/Contrib/System/System.nsi @@ -0,0 +1,128 @@ +; This is just an example of System Plugin +; +; (c) brainsucker, 2002 +; (r) BSForce + +Name "System Plugin Example" +OutFile "System.exe" +SetPluginUnload alwaysoff + +!include "${NSISDIR}\Contrib\System\Additionals\sysfunc.nsh" + +Section "ThisNameIsIgnoredSoWhyBother?" + SetOutPath $TEMP + + ; ----- Sample 1 ----- Message box with custom icon ----- + + !insertmacro smMessageBox "i 0" "Message box with custom icon!" "System Example 1a" ${MB_OK} "i 103" + ; i 0 - installer exe as module + ; i 103 - icon ID + + ; The same example but using icon from resource.dll. + ; You could use this dll for storing your resources, just replace FAR icon + ; with something you really need. + File "${NSISDIR}\Contrib\System\Additionals\Resource.dll" + !insertmacro smMessageBox "`$TEMP\resource.dll`" "Message box with custom icon from resource.dll!" "System Example 1b" ${MB_OK} "i 103" + Delete $TEMP\resource.dll + + ; ----- Sample 2 ----- Fixed disks size/space ----- + + StrCpy $7 ' Disk, Size, Free, Free for user:$\n$\n' + + ; Memory for paths + System::Alloc 1024 + Pop $1 + ; Get drives + System::Call '${sysGetLogicalDriveStrings}(1024, r1)' +enumok: + ; One more drive? + System::Call '${syslstrlen}(i r1) .r2' + IntCmp $2 0 enumex + + ; Is it DRIVE_FIXED? + System::Call '${sysGetDriveType} (i r1) .r3' + IntCmp $3 ${DRIVE_FIXED} 0 enumnext + + ; Drive space + System::Call '${sysGetDiskFreeSpaceEx}(i r1, .r3, .r4, .r5)' + + ; Pretty KBs will be saved on stack + System::Int64Op $3 / 1048576 + System::Int64Op $5 / 1048576 + System::Int64Op $4 / 1048576 + + ; Get pretty drive path string + System::Call '*$1(&t1024 .r6)' + System::Call '${syswsprintf} (.r7, "%s%20s %20s mb %20s mb %20s mb$\n", tr7, tr6, ts, ts, ts)' + +enumnext: + ; Next drive path + IntOp $1 $1 + $2 + IntOp $1 $1 + 1 + goto enumok +enumex: ; End of drives or user cancel + ; Free memory for paths + System::Free $1 + + ; Message box + System::Call '${sysMessageBox}($HWNDPARENT, s, "System Example 2", 33)' "$7" + + ; ----- Sample 3 ----- Direct proc defenition ----- + + ; Direct specification demo + System::Call 'user32::MessageBoxA(i $HWNDPARENT, t "Just direct MessageBoxA specification demo ;)", t "System Example 3", i 33) i.s' + Pop $0 + + ; ----- Sample 4 ----- Int64, mixed definition demo ----- + + ; Long int demo + StrCpy $2 "12312312" + StrCpy $3 "12345678903" + System::Int64Op $2 "*" $3 + Pop $4 + + ; Cdecl demo (uses 3 defenitions (simple example)) + System::Call "${syswsprintf}(.R1, s,,, t, ir0) .R0 (,,tr2,tr3,$4_)" "Int64 ops and strange defenition demo, %s x %s == %s, and previous msgbox result = %d" + MessageBox MB_OK "Cool: '$R1'" + + ; ----- Sample 5 ----- Small structure example ----- + + ; Create & Fill structure + System::Call "*(i 123123123, &t10 'Hello', &i1 0x123dd, &i2 0xffeeddccaa) i.s" + Pop $1 + ; Read data from structure + System::Call "*$1(i .r2, &t10 .r3, &i1 .r4, &i2 .r5, &l0 .r6)" + ; Show data and delete structure + MessageBox MB_OK "Structure example: $\nint == $2 $\nstring == $3 $\nbyte == $4 $\nshort == $5 $\nsize == $6" + System::Free $1 + + ; ----- Sample 6 ----- systemGetFileSysTime demo ----- + + !insertmacro smGetFileSysTime $CMDLINE + System::Call '*$R0${stSYSTEMTIME}(.r1, .r2, .r3, .r4, .r5, .r6, .r7, .r8)' + + MessageBox MB_OK "GetFileSysTime example: file '$CMDLINE', year $1, month $2, dow $3, day $4, hour $5, min $6, sec $7, ms $8" + + ; free memory from SYSTEMTIME + System::Free $R0 + + ; ----- Sample 7 ----- systemSplash -> Callbacks demonstration ----- + + ; Logo + File /oname=spltmp.bmp "${NSISDIR}\Contrib\Makensisw\logo.bmp" + + ; I. systemSplash variant + !insertmacro smSystemSplash 2000 "$TEMP\spltmp" + + ; II. Splash Plugin variant +; splash::show 2000 $TEMP\spltmp +; Pop $R0 ; $R0 has '1' if the user closed the splash screen early, + + ; remove logo + Delete $TEMP\spltmp.bmp + + ; Display splash result + MessageBox MB_OK "Splash (callbacks) demo result $R0" +SectionEnd + +; eof diff --git a/Contrib/System/System.txt b/Contrib/System/System.txt new file mode 100644 index 00000000..62daedf4 --- /dev/null +++ b/Contrib/System/System.txt @@ -0,0 +1,171 @@ +NSIS System Plugin +(c) brainsucker (Nik Medved), 2002 + + The whole system plugin and this documentation as a part could be a hard +barrier for non Win32 programmers, in this case you could come to NSIS forum +(http://forums.winamp.com/forumdisplay.php?forumid=65) and ask some questions +to the people living there, they'll always help you. + + By the way, any help in writing complete and easy-to-go System plugin +documentation will be appreciated. + + Note: it will be best to turn plugin onload off in case of using System +plugin (SetPluginUnload alwaysoff). + +============== Main functions ============== + +RESULT/PROC System::Get "Proc" +RESULT/RETURN System::Call "Proc" StackArgs... + +These functions return error RESULTs or PROC/RETURN in OK case. +Error result is "error" and callback results are "callbackN", where N is +callback index. + +============== Additional functions ============== + +---------------------------------- +System::Int64Op ARG1 OP1 +System::Int64Op ARG1 OP2 ARG2 +---------------------------------- + Performs operation on ARG1 and ARG2 (or on ARG1 only at single argument +operator cases) and returns result on stack. Here are the OP2s: +, -, *, / DIV, +% MOD, | OR, & AND, ^ XOR, || LOGIC-OR, && LOGIC-AND, < BELOW, > ABOVE, = EQUAL. +There are only 2 OP1s: ~ (BITWISE-NOT) and ! (LOGIC-NOT). + +---------------------------------- +System::Alloc SIZE +---------------------------------- + Allocates SIZE bytes and returns the pointer on stack. + +---------------------------------- +System::Copy 0 SOURCE +System::Copy DESTINATION SOURCE +System::Copy /SIZE 0 SOURCE +System::Copy /SIZE DESTINATION SOURCE +---------------------------------- + Copys data from source to destination, if /SIZE option and SIZE itself +are undefined uses GlobalSize to determine source size. If destination is equal +to 0, allocates the new memory block. + +---------------------------------- +System::Free ADDR +---------------------------------- + Frees memory used by object at ADDR (callbacks too). + +---------------------------------- +System::Store COMMAND +---------------------------------- + Store operations, allows to save/restore registers, pop/push values on +stack. COMMAND is string consisting of following ops: + s, S - push the whole registers range (to separate stack) + l, L - pop the whole registers range (from separate stack) + pN - push $N register to general nsis stack + PN - push $RN register to general nsis stack + rN - pop $N register from general nsis stack + RN - pop $RN register from general nsis stack + +============== Get/Call syntaxis ============== + +---------------------------------- +Syntax: +---------------------------------- + "Proc(Params)Return?Options#Proc(Params)Return?Options..." + +---------------------------------- +Proc: +---------------------------------- + dll::proc -> Proc from DLL + ::addr -> Handle to system proc (memory address) + *addr -> Structure + * -> New structure + nothing -> Dup proc, usually callback or for future defenition + + proc -> Ready proc specification for use or redefinition + + + If in System::Call proc specification points to already existing proc, +the existing proc will be adapted and executed, otherwise the new proc will be +created, executed and deleted. + +---------------------------------- +Params syntax: +---------------------------------- + (Param1, Param2, Param3...), the number of params of proc is set +to number of params at last Params section (so params cutting may ocur). If you +need to save previous Param defenition use '_' after last param at Params +section - no param cutting will ocur for it (section). +Syntax of single param: "Type Source Destination", type can be omitted (previous +or void will be used), each of Source and Destination can be replaced with +'.' placeholder. Any parameter can be omitted at all - previous or default +values will be used (example: "(i1,,i2)", 2nd arg omitted). + + Return section is like single param defenition, but the Source defenition is +never used, beside callback cases. + +---------------------------------- +Params & Return - Type: +---------------------------------- + v - void (generaly for return) + i - int (includes char, byte, short, handles, pointers and so on) + l - long & large integer (know as int64) + t - text, string (LPCSTR, pointer to first character) + b - boolean (needs/returns 'true':'false') - by the fact this type is + senseless -> usual integer can be used ('0':'1') + k - callback. See Callback section. + + * - pointer specifier -> the proc needs the pointer to type, affects + next char (parameter) [ex: '*i' - pointer to int] + +---------------------------------- +For structures: + & - additional meaning specificator. +---------------------------------- + &v - padding, &vN - pad for N bytes + &i - smaller types: &i4, &i2 (short), &i1 (byte) + &l - cumbersome, but &lN means the structure size (N bytes value), + calculated automaticaly, outputed always as int (N could be 0). + &t - structure contains plain text, &tN - lenght == N bytes. + +---------------------------------- +Params & Return - Source / Destination: +---------------------------------- + . - makes no change to source + 0..9 - starts numeric inline input (accepts 0..9, x, |) + " / ' / ` - starts / ends string inline input + Registers $0-$9 -> r(0..9) + Registers $R0-$R9 -> 'r(10..19)' or 'R(0..9)' + Additional regs -> c(Cmdline) d(instDir) o(Outdir) e(Exedir) a(lAng) + Stack -> s (you could pass arguments from Call line, see examples) + None -> n (0 (null) for input / specifies no output is required) + +Note: If you are using inline input syntax, you shouldn't use the same quotes for +quoting inlines and the whole defenition. If you need to place the +same quotes into input as you used for separation of input expression just use +these characters in doubled way. For example (t "just an ""Example""!"). + +---------------------------------- +Options: + (any option can be turned off (returned to default value) by specifing + '!' where needed, for example _stdcall cc can be turned on by '!c'): +---------------------------------- + c - _cdecl calling convention (the stack restored by caller). By default +stdcall calling convention is used (the stack restored by callee). + r - always return (for GET means you should pop result and proc, +for CALL means you should pop result (at least)). By default result is returned +for errors only (for GET you will pop either error result or right +proc, and for CALL you will get either your return or result at defined +return place. + n - no redefine. Whenever this proc will be used it will never be +redefined either by GET or CALL. This options is never inherited to childs. + s - use general Stack. Whenever the first callback defined the system +starts using the temporary stacks for function calls. + +---------------------------------- +Callback: +---------------------------------- +You should check for callbacked return after every function call which can use +your callback. General scheme is: + 1. Check result for callback or normal return + 2. Input arguments defined for callback are at places. + 3. Place output and return arguments + 4. Call System::Call using callback proc handle \ No newline at end of file diff --git a/Contrib/System/WhatsNew.txt b/Contrib/System/WhatsNew.txt deleted file mode 100644 index cd6cf00d..00000000 --- a/Contrib/System/WhatsNew.txt +++ /dev/null @@ -1,6 +0,0 @@ -1. Syntax, with inline input -2. Int64 full support (conversion/operations/comparison) -3. Structures support -4. Callbacks support, including multilevel callbacks -5. Some useful rountines (Alloc, Free, Copy) -6. CDecl and StdCall calling conventions