Quelltext /~heha/mb-iwp/Antriebe/Schrittmotorsteuerung/smc.zip/wutils.cpp

/********************************
 * Projekt: Motorsteuerung	*
 * Utility-Sammlung		*
 ********************************/

#include "smc1.h"

/* aus WUTILS.PAS */

TCHAR MBoxTitle[64];

void _fastcall InitStruct(LPVOID p, UINT len) {
 UINT*pu=(UINT*)p;
 *pu=len; len/=sizeof(UINT); len--;
 if (len) do *++pu=0; while (--len);
}

int vMBox(HWND Wnd, UINT id, UINT style, va_list arglist) {
 TCHAR buf1[256],buf2[1024];
 LoadString(ghInstance,id,buf1,elemof(buf1));
 wvsprintf(buf2,buf1,arglist);
 return MessageBox(Wnd,buf2,MBoxTitle,style);
}

int _cdecl MBox(HWND Wnd, UINT id, UINT style,...) {
 return vMBox(Wnd,id,style,(va_list)(&style+1));
}

UINT GetCheckboxGroup(HWND Wnd, UINT u, UINT o) {
 UINT v,m;
 for (v=0,m=1; u<=o; u++,m+=m) if (IsDlgButtonChecked(Wnd,u)==1) v|=m;
 return v;
}

void SetCheckboxGroup(HWND Wnd, UINT u, UINT o, UINT v) {
 for (; u<=o; u++,v>>=1) CheckDlgButton(Wnd,u,v&1);
}

void EnableDlgItem(HWND Wnd, UINT id, BOOL state) {
 Wnd=GetDlgItem(Wnd,id);
 if (Wnd) EnableWindow(Wnd,state);
}

void ShowDlgItem(HWND Wnd, UINT id, int state) {
 Wnd=GetDlgItem(Wnd,id);
 if (Wnd) ShowWindow(Wnd,state);
}

#if 0
/* Editfenster mit Hoch/Runter-Funktion */

static void HandleScroll(HWND Wnd, int dir) {
 HWND Parent=GetParent(Wnd);
 UINT id=GetWindowLong(Wnd,GWL_ID);
 BOOL ok;
 float j,k;
 int nk,curs;
 float i=GetFloat(Wnd,&nk,&curs);
 if (!ok) {
  MessageBeep(MB_ICONEXCLAMATION);
  return;	// keine Zahl
 }
 j=SendMessage(Parent,WM_COMMAND,MAKELONG(id,dir>0?EN_QUERYMAX:EN_QUERYMIN),
   (LPARAM)Wnd);
 k=i;
 i+=dir;
 if (dir>0){
  if (i>j) i=j;	// auf Maximum begrenzen
 }else{
  if (i<j) i=j;	// auf Minimum begrenzen
 }
 if (i==k) {
  MessageBeep(MB_ICONEXCLAMATION);
  return;	// Anschlag erreicht
 }
 SetFloat(Wnd,i,nk,curs);
}

static WNDPROC DefEditProc;

static LRESULT CALLBACK UpDownEditProc(HWND Wnd,UINT Msg,WPARAM wParam,LPARAM lParam) {
 switch (Msg) {
  case WM_VSCROLL: switch (LOWORD(wParam)) {
   case SB_LINEUP:	HandleScroll(Wnd,1); break;
   case SB_LINEDOWN:	HandleScroll(Wnd,-1); break;
   case SB_PAGEUP:	HandleScroll(Wnd,10); break;
   case SB_PAGEDOWN:	HandleScroll(Wnd,-10); break;
  }break;
  case WM_KEYDOWN: switch (wParam) {
   case VK_UP:		HandleScroll(Wnd,1); return 0;	// Taste verschlucken
   case VK_DOWN:	HandleScroll(Wnd,-1); return 0;
   case VK_PRIOR:	HandleScroll(Wnd,10); return 0;
   case VK_NEXT:	HandleScroll(Wnd,-10); return 0;
  }break;
 }
 return CallWindowProc(DefEditProc,Wnd,Msg,wParam,lParam);
}

void SubclassForUpDown(HWND Wnd, int id) {
 DefEditProc=SubclassWindow(GetDlgItem(Wnd,id),UpDownEditProc);
}
#endif

// Sovielwie SetDlgItemText(), jedoch Markierung beibehalten
// id kann -1 sein, dann Wirkung wie SetWindowText()
void SetEditText(HWND Wnd, UINT id, LPTSTR s) {
 DWORD Sel[2];
 if (id!=(UINT)-1) Wnd=GetDlgItem(Wnd,id);
 SendMessage(Wnd,EM_GETSEL,(WPARAM)(Sel+0),(LPARAM)(Sel+1));
 SetWindowText(Wnd,s);
 Edit_SetSel(Wnd,Sel[0],Sel[1]);
}

EXTERN_C char _fltused;
char _fltused;

// mangels Laufzeitbibliothek "longlong"-Routinen nachreichen,
// diese erwartet in EDX:EAX das "longlong" und in CL die Schiebeweite
// "_cdecl" notwendig, schaltet Namensgarnierung zurück auf '_'-Präfix
// Int64ShrlMod32 usw. sind weniger effektiv als diese Routinen!
ULONGLONG _declspec(naked) _cdecl _allshl(ULONGLONG ll, BYTE shift) {
 _asm{
	cmp	cl,32
	jnc	l1
	shld	edx,eax,cl
	shl	eax,cl
	ret
l1:	mov	edx,eax
	xor	eax,eax
	shl	edx,cl
	ret
 }
}
ULONGLONG _declspec(naked) _cdecl _aullshr(ULONGLONG ll, BYTE shift) {
 _asm{
	cmp	cl,32
	jnc	l1
	shrd	eax,edx,cl
	shr	edx,cl
	ret
l1:	mov	eax,edx
	xor	edx,edx
	shr	eax,cl
	ret
 }
}

// hier: Einschränkung, nur für DWORD-Divisor
ULONGLONG _declspec(naked) _cdecl _aulldiv(ULONGLONG z, ULONGLONG n) {
 _asm{
	mov	eax,[esp+8]	;High-Teil Zähler
	mov	ecx,[esp+12]	;Nenner
	xor	edx,edx
	div	ecx		;EAX=Ergebnis, EDX=Rest
	push	eax
	 mov	eax,[esp+8]	;Low-Teil Zähler
	 div	ecx		;EAX=Ergebnis, EDX=Rest
	pop	edx		;Rest durch High-Teil ersetzen
	ret	16
 }
}
// hier: Einschränkung, nur für DWORD-Divisor (und damit Rest)
ULONGLONG _declspec(naked) _cdecl _aullrem(ULONGLONG z, ULONGLONG n) {
 _asm{
	mov	eax,[esp+8]	;High-Teil Zähler
	mov	ecx,[esp+12]	;Nenner
	xor	edx,edx
	div	ecx		;EAX=Ergebnis, EDX=Rest
	mov	eax,[esp+4]	;Low-Teil Zähler
	div	ecx		;EAX=Ergebnis, EDX=Rest
	xor	eax,eax		;Ergebnis löschen
	xchg	edx,eax		;Rest in Low-Teil
	ret	16
 }
}
// MSVC macht aus dieser (Nicht-Windows-)Funktion ein _aullmul: unnötig!
ULONGLONG _declspec(naked) _fastcall UInt32x32To64(DWORD x,DWORD y) {
 _asm{	xchg	ecx,eax
	mul	edx
	ret
 }
}

int sinus(int radius, int sec) {
// Sinustabelle für ganze Sekunden (6°),
// erster Quadrant, 256=1.0
 static const BYTE Sintab[]={
   0,27,53,79,104,128,150,171,190,207,222,234,243,250,255};
 int quadrant=sec/15;
 sec%=15;
 if (quadrant&1) sec=15-sec;
 if (sec!=15) radius=MulDiv(radius,Sintab[sec],256);
 if (quadrant&2) radius=-radius;
 return radius;
}

void _stdcall Line(HDC dc, int x1, int y1, int x2, int y2) {
 Polyline(dc,(const POINT*)&x1,2);
}

// Speicher auf Stack (niemals NULL), len sollte /4 teilbar sein!
// Aufrufer muss Standard-Stapelrahmen (mit EBP) haben!
LPVOID _declspec(naked) _fastcall StackAlloc(DWORD len) {
 _asm{
	pop	edx		// Rückkehradresse -> EDX
	sub	esp,ecx		// Platz auf Stack
	mov	eax,esp		// Zeiger auf Anfang -> EAX
	jmp	edx		// Rücksprung
 }
}

#ifdef _DEBUG
void _cdecl DebugPrintf(LPCSTR s,...) {
 CHAR buf[1024];
 strcpy(buf+_vsnprintf(buf,elemof(buf)-3,s,(va_list)(&s+1)),"\r\n");
 OutputDebugString(buf);
}
#endif

/*
  case 0x31A/*WM_THEMECHANGED* /: {
   HTHEME th=0;
   HANDLE hLib;
   HTHEME (_stdcall*pGetWindowTheme)(HWND);
   hLib=LoadLibraryA("uxtheme.dll");
   if (hLib) {
    (FARPROC)pGetWindowTheme=GetProcAddress(hLib,"GetWindowTheme");
    th=pGetWindowTheme(GetDlgItem(Wnd,16));
    FreeLibrary(hLib);
   }
   di.BrushIndex=th?COLOR_3DHILIGHT:COLOR_3DFACE;
  }break;
*/