Source file: /~heha/ewa/Reluktanzmotor/cdesk-201007.zip/cdesk.cpp

#include "cdesk.h"
#include "simulate.h"
#include "plotxy.h"
#include "staticx.h"
#include "editx.h"
#include <tchar.h>
#include <shlwapi.h>
#include <commctrl.h>
//#include <uxtheme.h>
//#include <vsstyle.h>

HINSTANCE ghInstance;
HWND ghMainWnd,ghDlgWnd;
TCHAR sDecimal[2];
TCHAR sTime[2];
bool iMeasure;
CONFIG config;
static Simulate sim;

void EnableDlgItem(HWND Wnd, UINT id, bool ena) {
  EnableWindow(GetDlgItem(Wnd,id),ena);
}

int FillCombo(HWND Wnd,UINT wnd_id,UINT str_id,int setsel) {
 HWND hCombo=GetDlgItem(Wnd,wnd_id);
 ComboBox_ResetContent(hCombo);
 TCHAR s[256];
 s[LoadString(ghInstance,str_id,s,elemof(s)-1)+1]=0;	// laden und doppelnull-terminieren
 for(const TCHAR*sp=s;*sp;sp+=lstrlen(sp)+1) {
  ComboBox_AddString(hCombo,sp);
 }
 if (setsel>=0) return ComboBox_SetCurSel(hCombo,setsel);
 else return ComboBox_GetCurSel(hCombo);
}

bool CONFIG::load() {
 HKEY key;
 bool ret=false;
 if (!RegOpenKeyEx(HKEY_CURRENT_USER,TEXT("Software\\h#s"),0,KEY_READ,&key)) {
  TCHAR s[MAX_PATH];
  GetModuleFileName(ghInstance,s,elemof(s));
  TCHAR*n=PathFindFileName(s);
  TCHAR*e=PathFindExtension(n); if (e!=n) *e=0;
  HKEY key2;
  if (!RegOpenKeyEx(key,n,0,KEY_READ,&key2)) {
   DWORD siz=sizeof config;
   if (!RegQueryValueEx(key2,TEXT("config"),0,0,(BYTE*)&config,&siz)) {
    ret=true;
   }
   siz=0;
   if (!RegQueryValueEx(key2,TEXT("generate"),0,0,0,&siz)) {
    unsigned el=siz/sizeof(Simulate::GENPARAM);
    sim.genparams.resize(el);
    sim.genstates.resize(el);
    siz=el*sizeof(Simulate::GENPARAM);
    RegQueryValueEx(key2,TEXT("generate"),0,0,(BYTE*)&sim.genparams[0],&siz);
    for (unsigned i=0; i<el; i++) {
     sim.genstates[i].amp=0;
     sim.genstates[i].pha=sim.genparams[i].pha;
    }
   }
   RegCloseKey(key2);
  }
  RegCloseKey(key);
 }
 return ret;
}

// Speichert unter HKCU\Software\h#s\<exename>,
// sodass der Anwender unter verschiedenen EXE-Dateinamen verschiedene Konfigurationen ablegen kann.
// Einerseits kann das durch mehrfache EXE-Dateikopien geschehen,
// unter NTFS eleganter mit symbolischen oder Hardlinks, wie unter Linux üblich
void CONFIG::save() {
 HKEY key;
 if (!RegCreateKeyEx(HKEY_CURRENT_USER,TEXT("Software\\h#s"),0,0,0,KEY_WRITE,0,&key,0)) {
  TCHAR s[MAX_PATH];
  int l=LoadString(ghInstance,108,s,elemof(s));		// "haftmann#software"
  RegSetValueEx(key,0,0,REG_SZ,(BYTE*)s,(l+1)*sizeof(TCHAR));	// Beschreibung für "h#s"
  GetModuleFileName(ghInstance,s,elemof(s));
  TCHAR*n=PathFindFileName(s);
  TCHAR*e=PathFindExtension(n); if (e!=n) *e=0;
  HKEY key2;
  if (!RegCreateKeyEx(key,n,0,0,0,KEY_WRITE,0,&key2,0)) {
   l=GetWindowText(ghMainWnd,s,elemof(s));		// "Steuertafel"
   RegSetValueEx(key2,0,0,REG_SZ,(BYTE*)s,(l+1)*sizeof(TCHAR));	// Beschreibung für <exename>
   RegSetValueEx(key2,TEXT("config"),0,REG_BINARY,(BYTE*)&config,sizeof config);
   RegSetValueEx(key2,TEXT("generate"),0,REG_BINARY,(BYTE*)&sim.genparams[0],DWORD(sim.genparams.size()*sizeof(Simulate::GENPARAM)));
   RegCloseKey(key2);
  }
  RegCloseKey(key);
 }
}

static Float testdata[]={0,3,2,7,3.5,2};

struct XDATA:public DATA{
// XDATA() {
//  size=elemof(testdata);
//  precis=1;
//  range.a=0;
//  range.e=elemof(testdata)-1;
// }
//  virtual int getCaps() const {return 0;}
  virtual int size() const {return elemof(testdata);}
  virtual Float precis() const {return 1;}
//  virtual Float dt() const {return 1;}
//  virtual __int64 t0() const {FILETIME ft; GetSystemTimeAsFileTime(&ft); return *(__int64*)&ft;}
  virtual void getRange(Range<Float>&r) const {r.a=0; r.e=size()-1;}
  virtual Float get(int i) const {return (Float)i;}
//  virtual void insert(int i, Float)
//  virtual ACTION change(size_t,Float*,ACTION) {return ACTION(query|ins|del);}
  virtual const TCHAR*name() const {return TEXT("Zeit");}
  virtual const TCHAR*unit() const {return TEXT("s");}
};

struct YDATA:public DATA{
// YDATA() {
//  size=elemof(testdata);
//  precis=0.1F;
//  range.a=0;
//  range.e=7;
// }
  virtual int getCaps(int) const {return can_set;}
  virtual int size() const {return elemof(testdata);}
  virtual Float precis() const {return 0.1f;}
  virtual Float get(int i) const {return testdata[i];}
// virtual ACTION change(size_t i,Float*v,ACTION a) {
  virtual void set(int i,Float v) {testdata[i]=v;}	// TODO: Genauigkeit einfließen lassen!
  virtual const TCHAR*name() const {return TEXT("Strom");}
  virtual const TCHAR*unit() const {return TEXT("A");}
};

static XDATA xdata;
static YDATA ydata;

static TRACEATTR myplot={
  &xdata,&ydata,0,0,0,0,TEXT("Erster"),RGB(230,40,30),RGB(90,140,39),0,0,2,PS_DASH,-1,TRACEATTR::EDITABLE,{TEXT("Arial"),-18,0,0}};

static struct Showwave{
  WAVEFORMATEX*wf;
  WAVEHDR*wh;
  struct XDATA:public DATA{
    Showwave*p;
    virtual int size() const {return p->wh->dwBufferLength/p->wf->nBlockAlign;}
    virtual Float get(int i) const {return Float(i)*10/size()/*/p->wf->nSamplesPerSec*/;}
    virtual void getRange(Range<Float>&r) const {r.a=0; r.e=10/*(Float)size()/p->wf->nSamplesPerSec*/;}
    XDATA(Showwave*_p):p(_p) {}
  }xdata;
  struct YDATAL:public DATA{
    Showwave*p;
    virtual int size() const {return p->wh->dwBufferLength/p->wf->nBlockAlign;}
    virtual Float get(int i) const {return ((short*)p->wh->lpData)[i*2]/327.68F;}
    virtual void getRange(Range<Float>&r) const {r.a=-10; r.e=10;}
    YDATAL(Showwave*_p):p(_p) {}
  }ydataL;
  struct YDATAR:public DATA{
    Showwave*p;
    virtual int size() const {return p->wh->dwBufferLength/p->wf->nBlockAlign;}
    virtual Float get(int i) const {return ((short*)p->wh->lpData)[i*2+1]*30518E-9F;}
    virtual void getRange(Range<Float>&r) const {r.a=-10; r.e=10;}
    YDATAR(Showwave*_p):p(_p) {}
  }ydataR;
  Showwave():xdata(this),ydataL(this),ydataR(this) {}
}showwave;

static TRACEATTR wavplotL={
  &showwave.xdata,&showwave.ydataL,0,0,0,0,TEXT("links"),RGB(0,0,255),0,0,0,1,PS_SOLID,-1,0,{TEXT("Arial"),-18,0,0}};
static TRACEATTR wavplotR={
  &showwave.xdata,&showwave.ydataR,0,0,0,0,TEXT("rechts"),RGB(255,0,0),0,0,0,1,PS_SOLID,-1,0,{TEXT("Arial"),-18,0,0}};

static struct Size:public SIZE{
  operator POINT() const {return *(POINT*)this;}
  operator bool() const {return cx||cy;}
  Size&operator=(const SIZE&sz) {return operator=(*(Size*)&sz);}
  Size() {};
  Size(LPARAM lParam) {cx=GET_X_LPARAM(lParam); cy=GET_Y_LPARAM(lParam);}
  Size&Window(HWND w) {Rect rc(w); return operator=(SIZE(rc));}
  Size&Client(HWND w) {Rect rc(w,true); return operator=(SIZE(rc));}
}MinTrackSize,PrevClientSize;

struct NUMSETUP{
 float offsets[3];	// in A
 float winkel[2];	// in °
 float strom;		// in A
 float drehzahl[3];	// in U/min, ?, ?
 DWORD switches;	// 6 Bits benutzt
}numsetup={
 {-0.83F,-0.16F,-0.40F},
 { 0.00F,28.00F},
 12,
 {100,0.4F,0.2F},
 0
};

struct NUMOUT{
 float x[5];
}numout={
 {176.660F,1082.708F,12,0,28}
};

void SetDlgItemFloat(HWND Wnd, int id, float v, int nk) {
 TCHAR buf[16];
 _sntprintf(buf,elemof(buf),TEXT("%.*f"),nk,v);
 TCHAR*p=_tcschr(buf,'.');
 if (p) *p=::sDecimal[0];
 SetDlgItemText(Wnd,id,buf);
}

static const Simulate::GENPARAM gp[]={
 {
  TEXT("CH1"),
  1,		// links
  Simulate::GENPARAM::sine,
  {100,10000},	// 100 Hz, “10000
 },{
  TEXT("CH2"),
  2,		// rechts
  Simulate::GENPARAM::sine,
  {100,10000,0,1./3},	// dito 120°
 },{
  TEXT("CH3"),
  0,		// keine Ausgabe
  Simulate::GENPARAM::sine,
  {100,10000,0,2./3},	// dito 240°
 }
};

static struct Simdata{
// static void cb(char*buf,DWORD len,void*cbd) {Simdata*sd=(Simdata*)cbd; sd->callback(buf,len);}
// void callback(char*buf,DWORD len) {
// TODO:
// Triggerpunkte suchen
// Ins Diagramm überführen
// }
 HWAVEOUT hwo;
 WAVEFORMATEX wf;
 unsigned buflen;
 WAVEHDR wh[4];
 bool run;
 void init() {
  for (unsigned i=0; i<elemof(gp); i++) {
   sim.genparams.push_back(gp[i]);
   Simulate::GENSTATE gs={0,gp[i].pha};	// Startphase rüberkopieren
   sim.genstates.push_back(gs);
  }
 }
 void start() {
  wf.nSamplesPerSec=200000;
  wf.wBitsPerSample=16;
  wf.nChannels=2;
  wf.wFormatTag=WAVE_FORMAT_PCM;
  wf.nBlockAlign=wf.nChannels*((wf.wBitsPerSample+7)>>3);
  wf.nAvgBytesPerSec=wf.nSamplesPerSec*wf.nBlockAlign;
  wf.cbSize=0;
  buflen=sim.blocklen=20000;
  sim.dt=1/double(wf.nSamplesPerSec);

  if (!waveOutOpen(&hwo,WAVE_MAPPER,&wf,LONG_PTR(waveOutProc),(LONG_PTR)this,CALLBACK_FUNCTION)) {
   run=true;
   for (int i=0; i<elemof(wh); i++) {
    WAVEHDR&h=wh[i];
    h.lpData=new char[h.dwBufferLength=buflen*wf.nBlockAlign];
    h.dwFlags=0;
    waveOutPrepareHeader(hwo,&h,sizeof h);
    sim.generate(h.lpData);
    waveOutWrite(hwo,&h,sizeof h);
   }
  }
 }
 void stop() {
  run=false;
  waveOutReset(hwo);
  for (int i=0; i<elemof(wh); i++) {
   WAVEHDR&h=wh[i];
   waveOutUnprepareHeader(hwo,&h,sizeof h);
   delete[] h.lpData;
  }
  waveOutClose(hwo);
 }
 static void CALLBACK waveOutProc(HWAVEOUT hwo,UINT msg,Simdata*self,WAVEHDR&h,void*) {
  if (msg==WOM_DONE && self->run) {	// Nichts 'reinstecken nach waveOutReset()
   sim.generate(h.lpData);
   HWND hPlot=GetDlgItem(ghMainWnd,16);
   PostMessage(hPlot,XY_UPDATETRACE,wavplotL.itrace,0);
   if (self->run) waveOutWrite(hwo,&h,sizeof h);	// naja, eigentlich müsste hier eine Critical Section her
  }
 }
}simdata;

INT_PTR CALLBACK MainDlgProc(HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam) {
 switch (Msg) {
  case WM_INITDIALOG: {
   ghMainWnd=Wnd;
   HWND hPlot=GetDlgItem(Wnd,16);
   SendMessage(hPlot,XY_ADDTRACE,0,(LPARAM)&myplot);
   simdata.init();	// 3 Vorgaben einstellen
   showwave.wf=&simdata.wf;
   showwave.wh=simdata.wh;
   SendMessage(hPlot,XY_ADDTRACE,0,(LPARAM)&wavplotL);
   SendMessage(hPlot,XY_ADDTRACE,0,(LPARAM)&wavplotR);
   WINDOWPLACEMENT wp;
   wp.length=sizeof wp;
   GetWindowPlacement(Wnd,&wp);
   Rect&rc=*(Rect*)&wp.rcNormalPosition;
   MinTrackSize=SIZE(rc);
   if (config.load()) {	// ggf. simdata-Vorgaben überschreiben
    config.rcMain=rc;
    PrevClientSize.Client(Wnd);
    SetWindowPlacement(Wnd,&wp);
   }
   for (int i=0; i<9; i++) SetDlgItemFloat(Wnd,17+i,numsetup.offsets[i],2);	// TODO: EditX::setDouble
   for (int j=0; j<5; j++) SetDlgItemFloat(Wnd,40+j,numout.x[j],1);
//   sim=new Simulate(&ip,simdata.cb,&simdata);
//   sim->start();
   simdata.start();
  }return TRUE;

  case WM_DEVICECHANGE: {
   MessageBeep(0);
  }break;

  case WM_SIZE: if (wParam!=SIZE_MINIMIZED) {
   Size ClientSize(lParam);
   if (PrevClientSize.cx||PrevClientSize.cy) {
    POINT delta={ClientSize.cx-PrevClientSize.cx,ClientSize.cy-PrevClientSize.cy};
    HDWP wpi=BeginDeferWindowPos(64);
    for (HWND w=GetFirstChild(Wnd);w;w=GetNextSibling(w)) {
     Rect rc;
     GetWindowRect(w,&rc);
     rc.right-=rc.left;
     rc.bottom-=rc.top;
     ScreenToClient(Wnd,(POINT*)&rc);
     UINT flags=GetWindowID(w)==16?SWP_NOZORDER|SWP_NOMOVE:SWP_NOZORDER|SWP_NOSIZE;
     wpi=DeferWindowPos(wpi,w,0,
       rc.left+delta.x,
       rc.top+delta.y,
       rc.right+delta.x,
       rc.bottom+delta.y,
       flags);
    }
    EndDeferWindowPos(wpi);
   }
   PrevClientSize=ClientSize;
  }break;

  case WM_GETMINMAXINFO: {
   MINMAXINFO*mmi=(MINMAXINFO*)lParam;
   mmi->ptMinTrackSize=MinTrackSize;
  }break;

  case WM_CTLCOLORBTN: {
   switch (GetDlgCtrlID((HWND)lParam)) {
    case 35:
    case 36: {	// Autocheckbox theta_on, theta_off
     DefWindowProc(Wnd,Msg,wParam,lParam);
    }return TRUE;
   }
  }break;
/*
  case WM_NOTIFY: switch (((NMHDR*)lParam)->code) {
   case NM_CUSTOMDRAW: {
    NMCUSTOMDRAW*cd=(NMCUSTOMDRAW*)lParam;
    switch (cd->hdr.idFrom) {
     case 35:
     case 36: switch (cd->dwDrawStage) {	// Autocheckbox theta_on, theta_off
      case CDDS_PREPAINT: {
       SIZE sz;
#if 0
       HTHEME hTheme=OpenThemeData(cd->hdr.hwndFrom,L"BUTTON");
       int stateID=CBS_UNCHECKEDNORMAL;
       GetThemePartSize(hTheme,cd->hdc,BP_CHECKBOX,stateID,0,TS_TRUE,&sz);
       CloseThemeData(hTheme);
#else
       sz.cx=GetSystemMetrics(SM_CXMENUCHECK)+GetSystemMetrics(SM_CXEDGE)-1;
#endif
       TCHAR s[32];
       GetWindowText(cd->hdr.hwndFrom,s,elemof(s));
       Rect rc(*(Rect*)&cd->rc);	// Copy-Konstruktor
       rc.left+=sz.cx;
       hehaDrawText(cd->hdc,s,-1,&rc,DT_SUPERSUB|DT_SINGLELINE|DT_VCENTER);
       bool focus=GetFocus()==cd->hdr.hwndFrom;
       if (focus) {
        hehaDrawText(cd->hdc,s,-1,&rc,DT_SUPERSUB|DT_SINGLELINE|DT_VCENTER|DT_CALCRECT);
	//rc.left-=1; rc.top+=2; rc.right+=1; rc.bottom+=1;	// Korrektur damit's gleich aussieht(!)
        DrawFocusRect(cd->hdc,&rc);
       }
       SetWindowLongPtr(Wnd,DWLP_MSGRESULT,CDRF_SKIPDEFAULT);
      }return TRUE;
     }break;
    }
   }break;
  }break;
*/
  case WM_COMMAND: switch (wParam) {
// Menükommandos
   case 101: {
    DialogBox(ghInstance,MAKEINTRESOURCE(101),Wnd,SettingsDlgProc);
   }break;
   case 102: {
    TCHAR fname[MAX_PATH];
    TCHAR tem[256];
    TCHAR buf[1024];
    LoadString(ghInstance,LOWORD(wParam),tem,sizeof(tem));
    GetModuleFileName(0,fname,sizeof(fname));
    HANDLE f=CreateFile(fname,0,0,0,OPEN_EXISTING,0,0);
    wsprintf(buf,tem,fname,GetFileSize(f,0));
    CloseHandle(f);
    MessageBox(Wnd,buf,TEXT("Meldung"),MB_OK);
   }break;
   case 112: DialogBoxParam(ghInstance,MAKEINTRESOURCE(wParam),Wnd,Simulate::SimulDlgProc,(LPARAM)&sim); break;
   case 113: DialogBox(ghInstance,MAKEINTRESOURCE(wParam),Wnd,DrawTextTestDlg); break;
// Dialogelemente
   case 35:
   case 36: {
     EnableDlgItem(Wnd,UINT(wParam)+20-35,!Button_GetCheck((HWND)lParam));
   }break;
   case 2: {
    simdata.stop(); /*delete sim;*/
    WINDOWPLACEMENT wp;
    wp.length=sizeof wp;
    GetWindowPlacement(Wnd,&wp);
    config.rcMain=wp.rcNormalPosition;
    config.save();
    EndDialog(Wnd,0);
   }break;
  }break;
 }
 return FALSE;
}

// Statische Konstruktoren aufrufbar machen
#pragma data_seg(".CRT$AAA")
int ctor_start=0;	// Eine Null vor allen Konstruktorzeigern (eigentlich würde die Segmentadresse reichen, aber die ist in C/C++ nicht zu bekommen)
// Konstruktorzeiger landen in ".CRT$xxx" (xxx beliebig), wobei der Linker die Segmente alphabetisch sortiert
// und wegen Segmentausrichtung (bspw. 8 Byte) Nullen einfügt.
#pragma data_seg(".CRT$ZZZ")
int ctor_end=0;		// Eine Null nach allen Konstruktorzeigern
#pragma data_seg()	// Standardverhalten reaktivieren
// _initterm(a,e) ruft alle Zeiger zwischen <a> und <e> auf, die nicht Null sind.
// Die Konstruktorfunktionen legen ggf. Destruktorkode für atexit() ab,
// daher gibt es kein Pendant für statische Destruktoren.
extern "C" void _cdecl _initterm(void*a,void*e);

extern "C" void _cdecl _fltused() {};
void WinMainCRTStartup() {
  _initterm(&ctor_start,&ctor_end);	// Alle statischen Konstruktorzeiger zwischen ctor_start und ctor_end aufrufen
  WNDCLASSEX wc;
  wc.cbSize=sizeof wc;
  GetClassInfoEx(0,WC_DIALOG,&wc);
// wc.lpfnWndProc=DefDlgProc;
  wc.lpszClassName=MAKEINTATOM(100);
  RegisterClassEx(&wc);

  StaticX::init();
  EditX::init();
  PlotXY::init();

  ExitProcess(UINT(DialogBox(0,MAKEINTRESOURCE(100),0,MainDlgProc)));
}

// VS2019-64-Bit-Compiler bei /NODEFAULTLIB glücklich machen
void _cdecl operator delete(void*a,size_t) {free(a);}

//_declspec(dllimport) float std::numeric_limits<float>::infinity() {return 0;}
Detected encoding: UTF-80