#define WIN32_LEAN_AND_MEAN
#include "wutils.h"
#ifdef WIN32
HINSTANCE HInstance;	// Diese Programm-Datensegment (_DS bei Win16)
#endif
PTSTR MBoxTitle;

/******************************************************************
 ** Die langweilige Routinensammlung ("Alles was Windows fehlt") **
 ** aus WUTILS.PAS bzw. mittlerweile dem SENSOKOM-Projekt	 **
 ******************************************************************/
int  _defentry_ Limit(int x, int u, int o) {
 return x<u?u:x>o?o:x;
}

#ifdef _M_IX86
_declspec(naked)
#endif
void _cdecl _fltused() {}

#ifdef WIN32	// da braucht man gelegentlich dies:
bool ScreenToClientS(HWND w,POINTS*ps) {
 POINT p;
 p.x=ps->x;
 p.y=ps->y;
 if (!ScreenToClient(w,&p)) return false;
 ps->x=(short)p.x; ps->y=(short)p.y; return true;
}
bool ClientToScreenS(HWND w,POINTS*ps) {
 POINT p;
 p.x=ps->x;
 p.y=ps->y;
 if (!ClientToScreen(w,&p)) return false;
 ps->x=(short)p.x; ps->y=(short)p.y; return true;
}
bool PtInRectS(PCRECT r, POINTS ps) {
 POINT p;
 p.x=ps.x;
 p.y=ps.y;
 return PtInRect(r,p);
}
#else		// dafür braucht man jene Extrawurst:
long _defentry_ LimitL(long x, long u, long o) {
 return x<u?u:x>o?o:x;
}
#endif

UINT _defentry_ InitStruct(void*buf, unsigned len) {
 ZeroMemory(buf,len);
 *(unsigned*)buf=len;
 return 0;
}

int  _defentry_ vMBox(HWND Wnd, UINT id, UINT style, va_list arglist) {
 TCHAR buf1[256],buf2[256];
 LoadString(HInstance,id,buf1,elemof(buf1));
 wvnsprintf(buf2,elemof(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));
}

void _defentry_ SetEditFocus(HWND Wnd, UINT id) {
 Wnd=GetDlgItem(Wnd,id);
 SetFocus(Wnd);
 Edit_SetSel(Wnd,0,(UINT)-1);   // Message Cracker macht den Rest
}

PTSTR _defentry_ GetFileNamePtr(PTSTR s) {
 PTSTR r;
 TCHAR c;
 for (r=s;;) {
  c=*s; s=(PTSTR)CharNext(s);
  switch (c) {
   case ':':
   case '\\':
   case '/': r=s; break;
   case 0: return r;
  }
 }
}

static BYTE ShiftRect(PINT r, const int *r2) {
// Hilfsfunktion, schiebt horizontal bzw. vertikal
 int ax,dx;             // jaja, Assembler
 ax=r2[0]-r[0];         // Differenz links bzw. oben
 if (!ax) return 0;
 if (ax<0) {
  dx=r2[2]-r[2];        // Differenz rechts bzw. unten
  if (dx>=0) return 0;
  if (ax<dx) ax=dx;     // die kleinere Zahl
 }
 r[0]+=ax;
 r[2]+=ax;
 return ax<0?(BYTE)4:(BYTE)1;	// rechts=4, links=1
}

BYTE _defentry_ MoveRectIntoRect(PRECT R, PCRECT R2) {
// Falls R in R2 teilweise oder vollständig außerhalb liegt,
// wird R verschoben und TRUE zurückgeliefert, um maximale Sichtbarkeit
// zu realisieren.
// Dient zum Hineinholen von außerhalb liegenden Fenstern in den Desktop.
 return (BYTE)(ShiftRect((PINT)&R->left,(PINT)&R2->left)
       +(ShiftRect((PINT)&R->top, (PINT)&R2->top)<<1));
}

void _defentry_ GetFullScreenRect(PRECT R) {
// Ermittelt das Rechteck für maximierte Fenster, d.h. die Startleiste
// von Win9x bereits abgezogen, ideal für R2 in MoveRectIntoRect
 R->left=R->top=0;
 R->right=GetSystemMetrics(SM_CXFULLSCREEN);
 R->bottom=GetSystemMetrics(SM_CYFULLSCREEN)+GetSystemMetrics(SM_CYCAPTION);
}

BYTE _defentry_ MoveRectIntoFullScreen(PRECT R) {
// die logische Kombination beider o.g. Routinen
 RECT R2;
 GetFullScreenRect(&R2);
 return MoveRectIntoRect(R,&R2);
}

static int GetMoveR(int ra,int re,int va,int ve,int ba,int be) {
// Interne Routine für MoveRectNoIntersect()
 re-=ra;	
 if (be-ve>=re) return ve-ra;	// Verschiebung nach unten/rechts
 if (va-ba>=re) return va-re-ra;// Verschiebung nach oben/links
 return 0;
}

int _defentry_ MoveRectNoIntersect(PRECT R, PCRECT vis, PCRECT border) {
 int x;
 RECT RR;
 if (!IntersectRect(&RR,R,vis)) return 0;
 x=GetMoveR(R->top,R->bottom,vis->top,vis->bottom,border->top,border->bottom);
 if (x) {R->top+=x; R->bottom+=x; return x;}
			// Erst in zweiter Instanz nach links/rechts schieben
 x=GetMoveR(R->left,R->right,vis->left,vis->right,border->left,border->right);
 if (x) {R->left+=x, R->right+=x;} return x;
}

BOOL _defentry_ EnableDlgItem(HWND Wnd, UINT id, BOOL state) {
 return EnableWindow(GetDlgItem(Wnd,id),state);
}

int _defentry_ GetRadioCheck(HWND Wnd, UINT u, UINT o) {
 UINT i;
 for (i=u; i<=o; i++) if (IsDlgButtonChecked(Wnd,i)==1) return i-u;
 return -1;	// Nicht gefunden
}

UINT _defentry_ 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 _defentry_ SetCheckboxGroup(HWND Wnd, UINT u, UINT o, UINT v) {
 for (; u<=o; u++,v>>=1) CheckDlgButton(Wnd,u,v&1);
}

void _defentry_ EnableMenuGroup(HMENU m,UINT u, UINT o, UINT mask, UINT flags) {
 for(;u<=o; u++,mask>>=1) EnableMenuItem(m,u,flags|(mask&1?MF_ENABLED:MF_GRAYED));
}

BOOL _defentry_ GetModifiedEditText(HWND w, PTSTR buf, UINT buflen) {
 if (!Edit_GetModify(w)) return FALSE;
 GetWindowText(w,buf,buflen);
 Edit_SetModify(w,FALSE);
 return TRUE;
}

BOOL _defentry_ GetModifiedEditItemText(HWND w, UINT id, PTSTR buf, UINT buflen) {
 return GetModifiedEditText(GetDlgItem(w,id),buf,buflen);
}

void _defentry_ StripAmp(PTSTR s) {	// Kaufmanns-Und wegschneiden
 PTSTR d=s;
 for (;;) {
  TCHAR c=*s++;		// lodsb
  if (c==T('&')) c=*s++;
  *d++=c;		// stosb
  if (!c) return;
 }
}

void _defentry_ InsertAmp(PTSTR s, size_t bufsize, int pos) {	// Kaufmanns-Und einfügen
// Bei negativem "pos" ausgehend vom Ende, sonst vom Anfang einfügen
// Nicht für DBCS geeignet! (pos darf nicht auf ein Trail-Byte verweisen)
 int l=lstrlen(s);
 if ((size_t)l>=bufsize-1) return;	// kein Platz
 if (pos<0) pos+=l;
 if ((unsigned)pos>=(unsigned)l) return;	// zu weit vorn oder hinten
 s+=pos;
 MoveMemory(s+1,s,(l-pos+1)*sizeof(TCHAR));	// Platz machen, Null-Terminierung mitbewegen
 *s=T('&');
}

int _defentry_ iitrafo(int x, int a, int e, int A, int E) {
//Transformation von INT zu INT (mit Rundung), kein Problem bei a=e
 e-=a;
 if (!e) return 0;
 return MulDiv(x-a,E-A,e)+A;
}

int _defentry_ bsf(UINT w) {	// Niederwertigstes Bit suchen
 register int i;
 if (!w) return -1;
 for (i=0; w&1; i++) w>>=1;
 return i;
}

int _defentry_ bsr(UINT w) {	// Höchstwertigstes Bit suchen, -1 bei w=0
 register int i;
 for (i=-1; w; i++) w>>=1;
 return i;
}

BOOL _defentry_ IsClassName(HWND w, LPCTSTR s) {
 TCHAR n[32];
 GetClassName(w,n,elemof(n));
 return !lstrcmpi(n,s);
}