Miroirs/leocad
1
0
Fork 0
mirror of https://github.com/leozide/leocad synced 2024-12-27 21:58:37 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
leocad/win/System.cpp
leo f11c97777a Merged qtest branch into trunk.
2013-08-09 04:57:18 +00:00

1440 lines
37 KiB
C++
Raw Blame History

#include "lc_global.h"
#include <dlgs.h>
#include <direct.h>
#include "leocad.h"
#include "system.h"
#include "camera.h"
#include "tools.h"
#include "lc_file.h"
#include "image.h"
#include "PieceBar.h"
#include "PropsSht.h"
#include "PrefSht.h"
#include "arraydlg.h"
#include "imagedlg.h"
#include "groupdlg.h"
#include "figdlg.h"
#include "seldlg.h"
#include "htmldlg.h"
#include "stepdlg.h"
#include "povdlg.h"
#include "terrdlg.h"
#include "LibDlg.h"
#include "EdGrpDlg.h"
#include "AboutDlg.h"
#include "categdlg.h"
#include "cadbar.h"
#include "mainfrm.h"
#include "project.h"
#include "globals.h"
#include "lc_application.h"
#include "piece.h"
#include "pieceinf.h"
// Display a message box when an assert happens.
bool lcAssert(const char* FileName, int Line, const char* Expression, const char* Description)
{
char buf[1024];
sprintf(buf, "Assertion failed on line %d of file %s.\n%s\nDo you want to debug this?", Line, FileName, Description);
int ret = AfxMessageBox(buf, MB_YESNOCANCEL|MB_ICONERROR);
if (ret == IDYES)
DebugBreak();
else if (ret == IDCANCEL)
return true; // Disable this assert.
return false;
}
static CStepDlg* StepModeless = NULL;
static UINT ClipboardFormat = 0;
/////////////////////////////////////////////////////////////////////////////
// Static functions
static void ShowLastError()
{
LPVOID lpMsgBuf;
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &lpMsgBuf, 0, NULL);
MessageBox( NULL, (char*)lpMsgBuf, "GetLastError", MB_OK|MB_ICONINFORMATION );
LocalFree( lpMsgBuf );
}
static CMenu* GetMainMenu(int nIndex)
{
CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
if (pFrame == NULL)
return NULL;
CMenu* pMenu = CMenu::FromHandle(pFrame->m_wndMenuBar.GetHMenu());
if (pMenu == NULL)
return NULL;
return pMenu->GetSubMenu(nIndex);
}
UINT APIENTRY OFNOpenHookProc(HWND hdlg, UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
switch (uiMsg)
{
/*
case WM_HELP:
{
LPHELPINFO lphi = (LPHELPINFO)lParam;
if (lphi->iContextType == HELPINFO_WINDOW) // must be for a control
WinHelp ((HWND)lphi->hItemHandle, AfxGetApp()->m_pszHelpFilePath, HELP_WM_HELP, (DWORD)(LPVOID)HelpIDs);
return TRUE;
} break;
case WM_CONTEXTMENU:
{
WinHelp ((HWND)wParam, AfxGetApp()->m_pszHelpFilePath, HELP_CONTEXTMENU, (DWORD)(LPVOID)HelpIDs);
return TRUE;
} break;
*/
case WM_INITDIALOG:
{
RECT rc1, rc2;
HWND h = GetParent(hdlg);
GetWindowRect(GetDlgItem(h, lst1), &rc1);
ScreenToClient(h, (LPPOINT)&rc1);
ScreenToClient(h, ((LPPOINT)&rc1)+1);
GetWindowRect(hdlg, &rc2);
SetWindowPos(hdlg, NULL, 0, 0, 122 + rc1.left, rc2.bottom - rc2.top, SWP_NOMOVE);
HBITMAP hbm = CreateColorBitmap(120, 100, GetSysColor(COLOR_BTNFACE));
SendDlgItemMessage(hdlg, IDC_OPENDLG_PREVIEW, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)hbm);
GetWindowRect(GetDlgItem(hdlg, IDC_OPENDLG_PREVIEW), &rc1);
GetWindowRect(GetDlgItem(hdlg, IDC_OPENDLG_TEXT), &rc2);
SetWindowPos(GetDlgItem(hdlg, IDC_OPENDLG_TEXT), NULL, 0, 0, rc1.right - rc1.left, rc2.bottom - rc2.top, SWP_NOMOVE);
} break;
case WM_NOTIFY:
{
LPNMHDR pnmh = (LPNMHDR) lParam;
if (pnmh->code == CDN_FILEOK)
{
// HBITMAP hbmold = (HBITMAP)SendDlgItemMessage(hdlg, IDC_OPENDLG_BITMAP, STM_GETIMAGE, IMAGE_BITMAP, 0);
// if (hbmold)
// DeleteObject(hbmold);
// This avoids an assert
_AFX_THREAD_STATE* pThreadState = AfxGetThreadState();
pThreadState->m_pAlternateWndInit = NULL;
return FALSE;
}
if (pnmh->code == CDN_SELCHANGE)
{
char filename[_MAX_PATH];
SendMessage(GetParent(hdlg), CDM_GETFILEPATH, _MAX_PATH, (LPARAM)filename);
HBITMAP hbm = NULL;
char *p = strrchr(filename, '.');
if ((p && (_stricmp (p+1, "lcd"))) ||
((GetFileAttributes(filename) & FILE_ATTRIBUTE_DIRECTORY)))
{
hbm = CreateColorBitmap (120, 100, GetSysColor (COLOR_BTNFACE));
HBITMAP hbmold = (HBITMAP)SendDlgItemMessage(hdlg, IDC_OPENDLG_PREVIEW, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)hbm);
if (hbmold)
DeleteObject(hbmold);
return FALSE;
}
float fv;
char id[32];
lcDiskFile file;
file.Open(filename, "rb");
file.ReadBuffer(id, 32);
sscanf(strchr(id, ' '), "%f", &fv);
if (fv > 0.4f)
{
file.ReadFloats(&fv, 1);
if (fv > 0.7f)
{
lcuint32 dwPosition;
file.Seek(-4, SEEK_END);
file.ReadU32(&dwPosition, 1);
file.Seek(dwPosition, SEEK_SET);
if (dwPosition != 0)
{
if (fv < 1.0f)
{
BITMAPFILEHEADER bmfHeader;
file.ReadBuffer((LPSTR)&bmfHeader, sizeof(bmfHeader));
DWORD nPackedDIBLen = sizeof(BITMAPINFOHEADER) + 36000;
HGLOBAL hDIB = ::GlobalAlloc(GMEM_FIXED, nPackedDIBLen);
file.ReadBuffer((LPSTR)hDIB, nPackedDIBLen);
BITMAPINFOHEADER &bmiHeader = *(LPBITMAPINFOHEADER)hDIB;
BITMAPINFO &bmInfo = *(LPBITMAPINFO)hDIB;
int nColors = bmiHeader.biClrUsed ? bmiHeader.biClrUsed : 1 << bmiHeader.biBitCount;
LPVOID lpDIBBits;
if (bmInfo.bmiHeader.biBitCount > 8)
lpDIBBits = (LPVOID)((LPDWORD)(bmInfo.bmiColors + bmInfo.bmiHeader.biClrUsed) +
((bmInfo.bmiHeader.biCompression == BI_BITFIELDS) ? 3 : 0));
else
lpDIBBits = (LPVOID)(bmInfo.bmiColors + nColors);
CClientDC dc(NULL);
hbm = CreateDIBitmap(dc.m_hDC, &bmiHeader, CBM_INIT, lpDIBBits, &bmInfo, DIB_RGB_COLORS);
::GlobalFree(hDIB);
}
else
{
Image image;
if (image.FileLoad (file))
{
HWND hwndDesktop = GetDesktopWindow();
HDC hdcDesktop = GetDC(hwndDesktop);
HDC hdcMem = CreateCompatibleDC(hdcDesktop);
hbm = CreateCompatibleBitmap(hdcDesktop, 120, 100);
HBITMAP hbmOld = (HBITMAP)SelectObject(hdcMem, hbm);
for (int y = 0; y < 100; y++)
for (int x = 0; x < 120; x++)
{
unsigned char* b = image.GetData () + (y*120+x)*3;
SetPixelV(hdcMem, x, y, RGB(b[0], b[1], b[2]));
}
// Clean up
SelectObject(hdcMem, hbmOld);
DeleteDC(hdcMem);
ReleaseDC(hwndDesktop, hdcDesktop);
}
}
}
}
}
if (!hbm)
hbm = CreateColorBitmap (120, 100, GetSysColor(COLOR_BTNFACE));
HBITMAP hbmold = (HBITMAP)SendDlgItemMessage(hdlg, IDC_OPENDLG_PREVIEW, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)hbm);
if (hbmold)
DeleteObject(hbmold);
InvalidateRect(GetDlgItem(hdlg, IDC_OPENDLG_PREVIEW), NULL, TRUE);
}
} break;
case WM_DESTROY:
{
HBITMAP hbmold = (HBITMAP)SendDlgItemMessage(hdlg, IDC_OPENDLG_PREVIEW, STM_GETIMAGE, IMAGE_BITMAP, 0);
if (hbmold)
DeleteObject(hbmold);
} break;
}
return FALSE;
}
static UINT APIENTRY OFNSaveHookProc(HWND hdlg, UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
switch (uiMsg)
{
case WM_INITDIALOG:
{
int i = theApp.GetProfileInt ("Default", "Save Preview", 0);
if (i != 0)
CheckDlgButton(hdlg, IDC_SAVEDLG_PREVIEW, BST_CHECKED);
}
case WM_NOTIFY:
{
LPNMHDR pnmh = (LPNMHDR) lParam;
if (pnmh->code == CDN_FILEOK)
{
int i = 0;
if (IsDlgButtonChecked(hdlg, IDC_SAVEDLG_PREVIEW))
i = 1;
theApp.WriteProfileInt ("Default", "Save Preview", i);
// This avoids an assert
_AFX_THREAD_STATE* pThreadState = AfxGetThreadState();
pThreadState->m_pAlternateWndInit = NULL;
return FALSE;
}
}
}
return 0;
}
/////////////////////////////////////////////////////////////////////////////
// Profile Access
// returns the store value or default
int Sys_ProfileLoadInt(const char* section, const char* entry, const int defaultvalue)
{
return theApp.GetProfileInt(section, entry, defaultvalue);
}
// returns true if successful
bool Sys_ProfileSaveInt(const char* section, const char* entry, const int value)
{
return theApp.WriteProfileInt(section, entry, value) ? true : false;
}
char* Sys_ProfileLoadString(const char* section, const char* entry, const char* defaultvalue)
{
static CString str;
str = theApp.GetProfileString(section, entry, defaultvalue);
return (char*)(LPCSTR)str;
}
bool Sys_ProfileSaveString(const char* section, const char* entry, const char* value)
{
return theApp.WriteProfileString(section, entry, value) ? true : false;
}
/////////////////////////////////////////////////////////////////////////////
// User Interface
void SystemFinish()
{
}
void SystemInit()
{
ClipboardFormat = RegisterClipboardFormat(_T("LeoCAD_Data"));
}
static void CheckToolBarButton(CMFCToolBar& ToolBar, int ID, bool Check)
{
int Index = ToolBar.CommandToIndex(ID);
UINT NewStyle = ToolBar.GetButtonStyle(Index) & ~(TBBS_CHECKED | TBBS_INDETERMINATE);
if (Check)
NewStyle |= TBBS_CHECKED;
ToolBar.SetButtonStyle(Index, NewStyle | TBBS_CHECKBOX);
}
static void EnableToolBarButton(CMFCToolBar& ToolBar, int ID, bool Enable)
{
int Index = ToolBar.CommandToIndex(ID);
UINT NewStyle = ToolBar.GetButtonStyle(Index) & ~TBBS_DISABLED;
if (!Enable)
NewStyle |= TBBS_DISABLED;
ToolBar.SetButtonStyle(Index, NewStyle);
}
// Action toolbar, popup menu and cursor.
void SystemUpdateAction(int nNew, int nOld)
{
CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
if (!pFrame)
return;
// CheckToolBarButton(pFrame->m_wndToolsBar, ID_ACTION_SELECT+nOld, FALSE);
// CheckToolBarButton(pFrame->m_wndToolsBar, ID_ACTION_SELECT+nNew, TRUE);
// TODO: make sure this works if loading a file from the cmd line.
CView* pView = pFrame->GetActiveView();
if (pView)
pView->SendMessage(WM_LC_SET_CURSOR, nNew);
// TODO: update popup context menu
// TODO: disable lights if count > 8
}
// Current color in the listbox;
void SystemUpdateColorList(int nNew)
{
CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
if (!pFrame)
return;
pFrame->PostMessage (WM_LC_UPDATE_LIST, 0, nNew+1);
}
void SystemUpdateUndoRedo(char* undo, char* redo)
{
CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
if (!pFrame)
return;
EnableToolBarButton(pFrame->m_wndStandardBar, ID_EDIT_UNDO, undo != NULL);
EnableToolBarButton(pFrame->m_wndStandardBar, ID_EDIT_REDO, redo != NULL);
CMFCMenuBar& MenuBar = pFrame->m_wndMenuBar;
CMFCToolBarButton* pEditButton = MenuBar.GetButton(1);
CMFCToolBarMenuButton* pEditMenuButton = DYNAMIC_DOWNCAST(CMFCToolBarMenuButton, pEditButton);
const CObList& editCommands = pEditMenuButton->GetCommands();
for (POSITION pos = editCommands.GetHeadPosition (); pos != NULL;)
{
CMFCToolBarButton* pSubButton = (CMFCToolBarButton*)editCommands.GetNext(pos);
ASSERT_VALID(pSubButton);
UINT Style = pSubButton->m_nStyle;
switch (pSubButton->m_nID)
{
case ID_EDIT_UNDO:
if (undo)
{
pSubButton->SetStyle(Style & ~TBBS_DISABLED);
pSubButton->m_strText = "Undo " + CString(undo);
}
else
{
pSubButton->SetStyle(Style | TBBS_DISABLED);
pSubButton->m_strText = "Undo";
}
break;
case ID_EDIT_REDO:
if (redo)
{
pSubButton->SetStyle(Style & ~TBBS_DISABLED);
pSubButton->m_strText = "Redo " + CString(redo);
}
else
{
pSubButton->SetStyle(Style | TBBS_DISABLED);
pSubButton->m_strText = "Redo";
}
break;
}
}
}
void SystemUpdateSnap(const unsigned long nSnap)
{
CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
if (!pFrame)
return;
CheckToolBarButton(pFrame->m_wndStandardBar, ID_SNAP_ANGLE, (nSnap & LC_DRAW_SNAP_A) != 0);
}
void SystemUpdateSelected(unsigned long flags, int SelectedCount, Object* Focus)
{
CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
if (!pFrame)
return;
CMFCMenuBar& MenuBar = pFrame->m_wndMenuBar;
CMFCToolBarButton* pEditButton = MenuBar.GetButton(1);
CMFCToolBarMenuButton* pEditMenuButton = DYNAMIC_DOWNCAST(CMFCToolBarMenuButton, pEditButton);
const CObList& editCommands = pEditMenuButton->GetCommands();
for (POSITION pos = editCommands.GetHeadPosition (); pos != NULL;)
{
CMFCToolBarButton* pSubButton = (CMFCToolBarButton*)editCommands.GetNext(pos);
ASSERT_VALID(pSubButton);
UINT Style = pSubButton->m_nStyle;
switch (pSubButton->m_nID)
{
case ID_EDIT_CUT:
case ID_EDIT_COPY:
if (flags & (LC_SEL_PIECE|LC_SEL_CAMERA|LC_SEL_LIGHT))
pSubButton->SetStyle(Style & ~TBBS_DISABLED);
else
pSubButton->SetStyle(Style | TBBS_DISABLED);
break;
case ID_EDIT_SELECTINVERT:
case ID_EDIT_SELECTBYNAME:
if (flags & LC_SEL_NO_PIECES)
pSubButton->SetStyle(Style | TBBS_DISABLED);
else
pSubButton->SetStyle(Style & ~TBBS_DISABLED);
break;
case ID_EDIT_SELECTNONE:
if (flags & (LC_SEL_PIECE|LC_SEL_CAMERA|LC_SEL_LIGHT))
pSubButton->SetStyle(Style & ~TBBS_DISABLED);
else
pSubButton->SetStyle(Style | TBBS_DISABLED);
break;
case ID_EDIT_SELECTALL:
if (flags & LC_SEL_UNSELECTED)
pSubButton->SetStyle(Style & ~TBBS_DISABLED);
else
pSubButton->SetStyle(Style | TBBS_DISABLED);
break;
};
}
EnableToolBarButton(pFrame->m_wndStandardBar, ID_EDIT_CUT, flags & (LC_SEL_PIECE|LC_SEL_CAMERA|LC_SEL_LIGHT) ? TRUE : FALSE);
EnableToolBarButton(pFrame->m_wndStandardBar, ID_EDIT_COPY, flags & (LC_SEL_PIECE|LC_SEL_CAMERA|LC_SEL_LIGHT) ? TRUE : FALSE);
CMFCToolBarButton* pPieceButton = MenuBar.GetButton(3);
CMFCToolBarMenuButton* pPieceMenuButton = DYNAMIC_DOWNCAST(CMFCToolBarMenuButton, pPieceButton);
const CObList& pieceCommands = pPieceMenuButton->GetCommands();
for (POSITION pos = pieceCommands.GetHeadPosition (); pos != NULL;)
{
CMFCToolBarButton* pSubButton = (CMFCToolBarButton*)pieceCommands.GetNext(pos);
ASSERT_VALID(pSubButton);
UINT Style = pSubButton->m_nStyle;
switch (pSubButton->m_nID)
{
case ID_PIECE_DELETE:
case ID_PIECE_COPYKEYS:
if (flags & (LC_SEL_PIECE|LC_SEL_CAMERA|LC_SEL_LIGHT))
pSubButton->SetStyle(Style & ~TBBS_DISABLED);
else
pSubButton->SetStyle(Style | TBBS_DISABLED);
break;
case ID_PIECE_ARRAY:
case ID_PIECE_MIRROR:
case ID_PIECE_HIDESELECTED:
if (flags & LC_SEL_PIECE)
pSubButton->SetStyle(Style & ~TBBS_DISABLED);
else
pSubButton->SetStyle(Style | TBBS_DISABLED);
break;
case ID_PIECE_UNHIDEALL:
if (flags & LC_SEL_HIDDEN)
pSubButton->SetStyle(Style & ~TBBS_DISABLED);
else
pSubButton->SetStyle(Style | TBBS_DISABLED);
break;
case ID_PIECE_HIDEUNSELECTED:
if (flags & LC_SEL_UNSELECTED)
pSubButton->SetStyle(Style & ~TBBS_DISABLED);
else
pSubButton->SetStyle(Style | TBBS_DISABLED);
break;
case ID_PIECE_GROUP:
if (flags & LC_SEL_CANGROUP)
pSubButton->SetStyle(Style & ~TBBS_DISABLED);
else
pSubButton->SetStyle(Style | TBBS_DISABLED);
break;
case ID_PIECE_UNGROUP:
if (flags & LC_SEL_GROUP)
pSubButton->SetStyle(Style & ~TBBS_DISABLED);
else
pSubButton->SetStyle(Style | TBBS_DISABLED);
break;
case ID_PIECE_ATTACH:
if ((flags & (LC_SEL_GROUP|LC_SEL_FOCUSGROUP)) == LC_SEL_GROUP)
pSubButton->SetStyle(Style & ~TBBS_DISABLED);
else
pSubButton->SetStyle(Style | TBBS_DISABLED);
break;
case ID_PIECE_DETACH:
if (flags & LC_SEL_UNSELECTED)
pSubButton->SetStyle(Style & ~TBBS_DISABLED);
else
pSubButton->SetStyle(Style | TBBS_DISABLED);
break;
case ID_PIECE_EDITGROUPS:
if (flags & LC_SEL_NO_PIECES)
pSubButton->SetStyle(Style | TBBS_DISABLED);
else
pSubButton->SetStyle(Style & ~TBBS_DISABLED);
break;
}
}
EnableToolBarButton(pFrame->m_wndToolsBar, ID_PIECE_PREVIOUS, flags & LC_SEL_PIECE ? TRUE : FALSE); // FIXME: disable if current step is 1
EnableToolBarButton(pFrame->m_wndToolsBar, ID_PIECE_NEXT, flags & LC_SEL_PIECE ? TRUE : FALSE);
// Status bar text.
if (SelectedCount == 0)
{
pFrame->SetStatusBarMessage("");
pFrame->SetMessageText(AFX_IDS_IDLEMESSAGE);
}
else if ((SelectedCount == 1) && (Focus != NULL))
{
char Message[256];
if (Focus->IsPiece())
sprintf(Message, "%s (ID: %s)", Focus->GetName(), ((Piece*)Focus)->mPieceInfo->m_strName);
else
strcpy(Message, Focus->GetName());
pFrame->SetStatusBarMessage(Message);
pFrame->SetMessageText(Message);
}
else
{
char Message[256];
if (SelectedCount == 1)
strcpy(Message, "1 Object selected.");
else
sprintf(Message, "%d Objects selected.", SelectedCount);
pFrame->SetStatusBarMessage(Message);
pFrame->SetMessageText(Message);
}
}
// Changed current step/frame
void SystemUpdateTime(bool bAnimation, int nTime, int nTotal)
{
CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
if (!pFrame)
return;
// Status bar
char szStep[11];
if (bAnimation)
sprintf(szStep, "%i/%i", nTime, nTotal);
else
sprintf(szStep, " Step %i ", nTime);
pFrame->m_wndStatusBar.SetPaneText(pFrame->m_wndStatusBar.CommandToIndex(ID_INDICATOR_STEP), LPCSTR(szStep));
// Choose step dialog
if (StepModeless != NULL)
StepModeless->UpdateRange(nTime, nTotal);
}
void SystemUpdateSnap(unsigned short MoveSnap, unsigned short RotateSnap)
{
char Text[256], xy[32], z[32];
lcGetActiveProject()->GetSnapDistanceText(xy, z);
sprintf(Text, " M: %s %s R: %d ", xy, z, RotateSnap);
if (AfxGetMainWnd())
((CMainFrame*)AfxGetMainWnd())->SetStatusBarPane(ID_INDICATOR_SNAP, Text);
}
void SystemUpdatePaste(bool enable)
{
CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
if (!pFrame)
return;
CMFCMenuBar& MenuBar = pFrame->m_wndMenuBar;
CMFCToolBarButton* pEditButton = MenuBar.GetButton(1);
CMFCToolBarMenuButton* pEditMenuButton = DYNAMIC_DOWNCAST(CMFCToolBarMenuButton, pEditButton);
const CObList& editCommands = pEditMenuButton->GetCommands();
for (POSITION pos = editCommands.GetHeadPosition (); pos != NULL;)
{
CMFCToolBarButton* pSubButton = (CMFCToolBarButton*)editCommands.GetNext(pos);
ASSERT_VALID(pSubButton);
UINT Style = pSubButton->m_nStyle;
switch (pSubButton->m_nID)
{
case ID_EDIT_PASTE:
if (enable)
pSubButton->SetStyle(Style & ~TBBS_DISABLED);
else
pSubButton->SetStyle(Style | TBBS_DISABLED);
break;
}
}
EnableToolBarButton(pFrame->m_wndStandardBar, ID_EDIT_PASTE, enable ? TRUE : FALSE);
}
void SystemUpdatePlay(bool play, bool stop)
{
CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
EnableToolBarButton(pFrame->m_wndAnimationBar, ID_ANIMATOR_PLAY, play ? TRUE : FALSE);
EnableToolBarButton(pFrame->m_wndAnimationBar, ID_ANIMATOR_STOP, stop ? TRUE : FALSE);
}
void SystemUpdateAnimation(bool bAnimation, bool bAddKeys)
{
// Toolbar
CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
if (!pFrame)
return;
CheckToolBarButton(pFrame->m_wndAnimationBar, ID_ANIMATOR_TOGGLE, bAnimation ? TRUE : FALSE);
CheckToolBarButton(pFrame->m_wndAnimationBar, ID_ANIMATOR_KEY, bAddKeys ? TRUE : FALSE);
EnableToolBarButton(pFrame->m_wndAnimationBar, ID_ANIMATOR_PLAY, bAnimation ? TRUE : FALSE);
EnableToolBarButton(pFrame->m_wndAnimationBar, ID_ANIMATOR_STOP, FALSE);
// Menu
char* txt;
CMenu* pMenu = GetMainMenu(3);
if (!pMenu)
return;
UINT nState = pMenu->GetMenuState(ID_PIECE_COPYKEYS, MF_BYCOMMAND);
nState &= ~(MF_BITMAP|MF_OWNERDRAW|MF_SEPARATOR);
if (bAnimation)
txt = "Copy Keys from Instructions";
else
txt = "Copy Keys from Animation";
pMenu->ModifyMenu(ID_PIECE_COPYKEYS, MF_BYCOMMAND | MF_STRING | nState, ID_PIECE_COPYKEYS, txt);
}
void SystemUpdateCurrentCamera(Camera* pOld, Camera* pNew, const PtrArray<Camera>& Cameras)
{
}
void SystemUpdateCameraMenu(const PtrArray<Camera>& Cameras)
{
}
void SystemUpdateCategories(bool SearchOnly)
{
CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
if (!pFrame)
return;
pFrame->m_wndPiecesBar.UpdatePiecesTree(SearchOnly);
}
void SystemUpdateRecentMenu(char names[4][MAX_PATH])
{
theApp.UpdateMRU(names);
}
// if x = -1, get cursor pos
void SystemDoPopupMenu(int nMenu, int x, int y)
{
CMenu PopupMenus;
PopupMenus.LoadMenu(IDR_POPUPS);
POINT pt;
if (x != -1)
{
pt.x = x;
pt.y = y;
}
else
GetCursorPos(&pt);
CMFCPopupMenu* Popup = new CMFCPopupMenu();
Popup->Create(AfxGetMainWnd(), pt.x, pt.y, PopupMenus.GetSubMenu(nMenu)->Detach());
}
// Private MFC function only sets the title if it's different
extern void AFXAPI AfxSetWindowText(HWND, LPCTSTR);
void SystemSetWindowCaption(char* caption)
{
if (!AfxGetMainWnd())
return;
AfxSetWindowText(AfxGetMainWnd()->m_hWnd, caption);
}
int SystemDoMessageBox(const char* prompt, int nMode)
{
return AfxMessageBox(prompt, nMode);
}
int Sys_MessageBox (const char* text, const char* caption, int type)
{
return AfxMessageBox(text, type);
}
extern BOOL AFXAPI AfxFullPath(LPTSTR lpszPathOut, LPCTSTR lpszFileIn);
bool SystemDoDialog(int nMode, void* param)
{
switch (nMode)
{
case LC_DLG_FILE_OPEN_PROJECT:
{
CFileDialog dlg(TRUE, "*.lcd", NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
"Supported Formats (*.lcd;*.dat;*.ldr;*.mpd)|*.lcd;*.dat;*.ldr;*.mpd|LeoCAD Projects (*.lcd)|*.lcd|LDraw Files (*.dat;*.ldr;*.mpd)|*.dat;*.ldr;*.mpd|All Files (*.*)|*.*||", AfxGetMainWnd());
dlg.m_ofn.Flags |= (OFN_ENABLETEMPLATE|OFN_HIDEREADONLY|OFN_FILEMUSTEXIST|OFN_ENABLEHOOK|OFN_EXPLORER);
dlg.m_ofn.hInstance = AfxGetInstanceHandle();
dlg.m_ofn.lpfnHook = OFNOpenHookProc;
dlg.m_ofn.lpTemplateName = MAKEINTRESOURCE(IDD_OPENDLG_TEMPLATE);
char *defdir = (char*)param;
if (strlen(defdir))
dlg.m_ofn.lpstrInitialDir = defdir;
if (dlg.DoModal() == IDOK)
{
char szFullPath[LC_MAXPATH];
AfxFullPath(szFullPath, dlg.GetPathName());
strcpy((char*)param, szFullPath);
return true;
}
} break;
case LC_DLG_FILE_SAVE_PROJECT:
{
CFileDialog dlg(FALSE, "*.lcd", (char*)param, OFN_HIDEREADONLY|OFN_PATHMUSTEXIST|OFN_OVERWRITEPROMPT|OFN_ENABLEHOOK|OFN_ENABLETEMPLATE,
"LeoCAD Projects (*.lcd)|*.lcd|LDraw Files (*.dat;*.ldr)|*.dat;*.ldr|All Files (*.*)|*.*||");
dlg.m_ofn.lpfnHook = OFNSaveHookProc;
dlg.m_ofn.hInstance = AfxGetInstanceHandle();
dlg.m_ofn.lpTemplateName = MAKEINTRESOURCE(IDD_SAVEDLG_TEMPLATE);
if (dlg.DoModal() == IDOK)
{
char szFullPath[LC_MAXPATH];
AfxFullPath(szFullPath, dlg.GetPathName());
strcpy((char*)param, szFullPath);
return true;
}
} break;
case LC_DLG_FILE_MERGE_PROJECT:
{
CFileDialog dlg(TRUE, "*.lcd", NULL, OFN_HIDEREADONLY|OFN_ENABLETEMPLATE|OFN_FILEMUSTEXIST|OFN_ENABLEHOOK|OFN_EXPLORER,
"LeoCAD Projects (*.lcd)|*.lcd|All Files (*.*)|*.*||", AfxGetMainWnd());
dlg.m_ofn.hInstance = AfxGetInstanceHandle();
dlg.m_ofn.lpfnHook = OFNOpenHookProc;
dlg.m_ofn.lpTemplateName = MAKEINTRESOURCE(IDD_OPENDLG_TEMPLATE);
dlg.m_ofn.lpstrTitle = "Merge";
char *defdir = (char*)param;
if (strlen(defdir))
dlg.m_ofn.lpstrInitialDir = defdir;
if (dlg.DoModal() == IDOK)
{
strcpy((char*)param, dlg.GetPathName());
return true;
}
} break;
case LC_DLG_FILE_OPEN:
{
LC_FILEOPENDLG_OPTS* opts = (LC_FILEOPENDLG_OPTS*)param;
if (opts->type == LC_FILEOPENDLG_LCF)
{
const char *ext, *filter;
ext = ".lcf";
filter = "LeoCAD Category Files (*.lcf)|*.lcf|All Files (*.*)|*.*||";
CFileDialog dlg(TRUE, ext, NULL,OFN_FILEMUSTEXIST | OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, filter, NULL);
if (dlg.DoModal() == IDOK)
{
opts->numfiles = 1;
opts->filenames = (char**)malloc(LC_MAXPATH);
strcpy((char*)opts->filenames, dlg.GetPathName ());
// Get the file path.
strcpy(opts->path, (char*)opts->filenames);
if (strlen (opts->path) > 0)
{
char* ptr = strrchr(opts->path, '/');
if (ptr == NULL)
ptr = strrchr(opts->path, '\\');
if (ptr)
{
ptr++;
*ptr = 0;
}
}
return true;
}
return false;
}
} break;
case LC_DLG_FILE_SAVE:
{
LC_FILESAVEDLG_OPTS* opts = (LC_FILESAVEDLG_OPTS*)param;
if (opts->type == LC_FILESAVEDLG_LCF)
{
CFileDialog dlg(FALSE, ".lcf", NULL, OFN_PATHMUSTEXIST | OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
"LeoCAD Category Files (*.lcf)|*.lcf|All Files (*.*)|*.*||", NULL);
if (dlg.DoModal() == IDOK)
{
strcpy(opts->path, dlg.GetPathName ());
return true;
}
}
return false;
} break;
case LC_DLG_PICTURE_SAVE:
{
LC_IMAGEDLG_OPTS* opts = (LC_IMAGEDLG_OPTS*)param;
CImageDlg dlg(FALSE, param);
if (dlg.DoModal() == IDOK)
return true;
} break;
case LC_DLG_DIRECTORY_BROWSE:
{
LC_DLG_DIRECTORY_BROWSE_OPTS* Opts = (LC_DLG_DIRECTORY_BROWSE_OPTS*)param;
strcpy(Opts->Path, "");
LPMALLOC ShellMalloc;
if (SHGetMalloc(&ShellMalloc) == NOERROR)
{
BROWSEINFO bi;
LPITEMIDLIST pidl;
if (AfxGetMainWnd())
bi.hwndOwner = AfxGetMainWnd()->GetSafeHwnd();
else
bi.hwndOwner = ::GetDesktopWindow();
bi.pidlRoot = NULL;
bi.pszDisplayName = Opts->Path;
bi.lpszTitle = Opts->Title;
bi.ulFlags = BIF_RETURNFSANCESTORS | BIF_RETURNONLYFSDIRS;
bi.lpfn = NULL;
bi.lParam = 0;
pidl = SHBrowseForFolder(&bi);
if (pidl != NULL)
{
if (SHGetPathFromIDList(pidl, Opts->Path))
{
if (Opts->Path[strlen(Opts->Path)-1] != '\\')
strcat(Opts->Path, "\\");
return true;
}
ShellMalloc->Free(pidl);
}
ShellMalloc->Release();
}
return false;
} break;
case LC_DLG_HTML:
{
LC_HTMLDLG_OPTS* opts = (LC_HTMLDLG_OPTS*)param;
CHTMLDlg dlg(&opts->imdlg);
dlg.m_nLayout = opts->singlepage ? 0 : 1;
dlg.m_bIndex = opts->index;
dlg.m_bImages = opts->images;
dlg.m_bID = opts->id;
dlg.mColorIndex = opts->color;
dlg.m_bListEnd = opts->listend;
dlg.m_bListStep = opts->liststep;
dlg.m_bHighlight = opts->highlight;
if (dlg.DoModal() == IDOK)
{
strcpy(opts->path, dlg.m_strFolder);
opts->singlepage = (dlg.m_nLayout == 0);
opts->index = dlg.m_bIndex == TRUE;
opts->images = dlg.m_bImages == TRUE;
opts->id = dlg.m_bID == TRUE;
opts->color = dlg.mColorIndex;
opts->listend = dlg.m_bListEnd == TRUE;
opts->liststep = dlg.m_bListStep == TRUE;
opts->highlight = dlg.m_bHighlight == TRUE;
return true;
}
} break;
case LC_DLG_BRICKLINK:
{
CFileDialog dlg(FALSE, "*.xml", NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
"XML Files (*.xml)|*.xml|All Files (*.*)|*.*||", AfxGetMainWnd());
if (dlg.DoModal() == IDOK)
{
strcpy((char*)param, dlg.GetPathName());
return true;
}
} break;
case LC_DLG_POVRAY:
{
CPOVDlg dlg;
if (dlg.DoModal() == IDOK)
{
LC_POVRAYDLG_OPTS* opts = (LC_POVRAYDLG_OPTS*)param;
opts->render = dlg.m_bRender != 0;
strcpy(opts->povpath, dlg.m_strPOV);
strcpy(opts->outpath, dlg.m_strOut);
strcpy(opts->libpath, dlg.m_strLGEO);
return true;
}
} break;
case LC_DLG_WAVEFRONT:
{
CFileDialog dlg(FALSE, "*.obj", NULL, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
"Wavefront Files (*.obj)|*.obj|All Files (*.*)|*.*||", AfxGetMainWnd());
if (dlg.DoModal() == IDOK)
{
strcpy((char*)param, dlg.GetPathName());
return true;
}
} break;
case LC_DLG_MINIFIG:
{
CMinifigDlg dlg(param);
if (dlg.DoModal() == IDOK)
return true;
} break;
case LC_DLG_ARRAY:
{
CArrayDlg dlg;
if (dlg.DoModal() == IDOK)
{
LC_ARRAYDLG_OPTS* opts = (LC_ARRAYDLG_OPTS*)param;
opts->n1DCount = dlg.m_n1DCount;
opts->n2DCount = dlg.m_n2DCount;
opts->n3DCount = dlg.m_n3DCount;
opts->f2D[0] = dlg.m_f2DX;
opts->f2D[1] = dlg.m_f2DY;
opts->f2D[2] = dlg.m_f2DZ;
opts->f3D[0] = dlg.m_f3DX;
opts->f3D[1] = dlg.m_f3DY;
opts->f3D[2] = dlg.m_f3DZ;
opts->fMove[0] = dlg.m_fMoveX;
opts->fMove[1] = dlg.m_fMoveY;
opts->fMove[2] = dlg.m_fMoveZ;
opts->fRotate[0] = dlg.m_fRotateX;
opts->fRotate[1] = dlg.m_fRotateY;
opts->fRotate[2] = dlg.m_fRotateZ;
opts->nArrayDimension = dlg.m_nArrayDimension;
return true;
}
} break;
case LC_DLG_PREFERENCES:
{
CPreferencesSheet ps;
LC_PREFERENCESDLG_OPTS* opts = (LC_PREFERENCESDLG_OPTS*)param;
ps.m_PageGeneral.SetOptions(opts->nSaveInterval, opts->nMouse, opts->strPath, opts->strUser);
ps.m_PageDetail.SetOptions(opts->nDetail, opts->fLineWidth, opts->AASamples);
ps.m_PageDrawing.SetOptions(opts->nSnap, opts->nAngleSnap, opts->nGridSize);
ps.m_PageScene.SetOptions(opts->nScene, opts->fDensity, opts->strBackground, opts->fBackground, opts->fFog, opts->fAmbient, opts->fGrad1, opts->fGrad2);
ps.m_PagePrint.SetOptions(opts->strHeader, opts->strFooter);
ps.m_PageKeyboard.SetOptions();
if (ps.DoModal() == IDOK)
{
ps.m_PageGeneral.GetOptions(&opts->nSaveInterval, &opts->nMouse, opts->strPath, opts->strUser);
ps.m_PageDetail.GetOptions(&opts->nDetail, &opts->fLineWidth, &opts->AASamples);
ps.m_PageDrawing.GetOptions(&opts->nSnap, &opts->nAngleSnap, &opts->nGridSize);
ps.m_PageScene.GetOptions(&opts->nScene, &opts->fDensity, opts->strBackground, opts->fBackground, opts->fFog, opts->fAmbient, opts->fGrad1, opts->fGrad2);
ps.m_PagePrint.GetOptions(opts->strHeader, opts->strFooter);
ps.m_PageKeyboard.GetOptions();
AfxGetMainWnd()->PostMessage(WM_LC_UPDATE_SETTINGS);
AfxGetApp()->WriteProfileInt("Settings", "Autosave", opts->nSaveInterval);
AfxGetApp()->WriteProfileInt("Default", "Mouse", opts->nMouse);
AfxGetApp()->WriteProfileString("Default", "Projects", opts->strPath);
if (opts->AASamples != Sys_ProfileLoadInt("Default", "AASamples", 1))
{
AfxGetApp()->WriteProfileInt("Default", "AASamples", opts->AASamples);
AfxMessageBox("Anti-aliasing changes will only take effect next time you start LeoCAD.", MB_OK);
}
return true;
}
} break;
case LC_DLG_PROPERTIES:
{
CPropertiesSheet ps;
LC_PROPERTIESDLG_OPTS* opts = (LC_PROPERTIESDLG_OPTS*)param;
ps.SetTitle(opts->strTitle, PSH_PROPTITLE);
ps.m_PageSummary.m_strAuthor = opts->strAuthor;
ps.m_PageSummary.m_strDescription = opts->strDescription;
ps.m_PageSummary.m_strComments = opts->strComments;
ps.m_PageGeneral.m_strFilename = opts->strFilename;
ps.m_PagePieces.mPieceNames = opts->PieceNames;
ps.m_PagePieces.mNumPieces = opts->NumPieces;
ps.m_PagePieces.mPieceColorCount = opts->PieceColorCount;
ps.m_PagePieces.mNumColors = opts->NumColors;
if (ps.DoModal() == IDOK)
{
strcpy(opts->strAuthor, ps.m_PageSummary.m_strAuthor);
strcpy(opts->strDescription, ps.m_PageSummary.m_strDescription);
strcpy(opts->strComments, ps.m_PageSummary.m_strComments);
return true;
}
} break;
case LC_DLG_TERRAIN:
{
CTerrainDlg dlg((Terrain*)param, false);
if (dlg.DoModal() == IDOK)
return true;
} break;
case LC_DLG_LIBRARY:
{
CLibraryDlg dlg;
dlg.DoModal();
CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
pFrame->m_wndPiecesBar.UpdatePiecesTree(false);
return true;
} break;
case LC_DLG_SELECTBYNAME:
{
CSelectDlg dlg(param);
if (dlg.DoModal() == IDOK)
return true;
} break;
case LC_DLG_STEPCHOOSE:
{
if (StepModeless == NULL)
{
CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
CView* pView = pFrame->GetActiveView();
StepModeless = new CStepDlg(&StepModeless, pView);
StepModeless->Create(IDD_STEP, pView);
int t, l;
char buf[30];
strcpy (buf, theApp.GetProfileString("Settings", "Step Dialog"));
if (sscanf(buf, "%d, %d", &t, &l) == 2)
{
CRect rc;
StepModeless->GetWindowRect(&rc);
StepModeless->SetWindowPos(NULL,
min(l, GetSystemMetrics(SM_CXSCREEN)-rc.Width()),
min(t, GetSystemMetrics(SM_CYSCREEN)-rc.Height()),
0, 0, SWP_NOZORDER|SWP_NOSIZE);
}
StepModeless->ShowWindow(SW_SHOW);
}
else
StepModeless->SetActiveWindow();
} break;
case LC_DLG_EDITGROUPS:
{
CEditGroupsDlg dlg((LC_GROUPEDITDLG_OPTS*)param);
if (dlg.DoModal() == IDOK)
return true;
} break;
case LC_DLG_GROUP:
{
CGroupDlg dlg;
dlg.m_strName = (char*)param;
if (dlg.DoModal() == IDOK)
{
strcpy((char*)param, dlg.m_strName);
return true;
}
} break;
case LC_DLG_EDITCATEGORY:
{
CCategoryDlg Dlg;
LC_CATEGORYDLG_OPTS* Opts = (LC_CATEGORYDLG_OPTS*)param;
Dlg.m_Keywords = Opts->Keywords;
Dlg.m_Name = Opts->Name;
if (Dlg.DoModal() == IDOK)
{
Opts->Keywords = Dlg.m_Keywords;
Opts->Name = Dlg.m_Name;
return true;
}
} break;
case LC_DLG_ABOUT:
{
CAboutDlg dlg;
dlg.m_hViewDC = wglGetCurrentDC();
dlg.DoModal();
} break;
}
return false;
}
/////////////////////////////////////////////////////////////////////////////
// Memory rendering functions
typedef struct
{
HDC hdc;
HDC oldhdc;
HGLRC hrc;
HGLRC oldhrc;
HBITMAP hbm;
HBITMAP oldhbm;
} LC_RENDER;
void* Sys_StartMemoryRender(int width, int height)
{
LC_RENDER* render = (LC_RENDER*)malloc(sizeof(LC_RENDER));
CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
CView* pView = pFrame->GetActiveView();
CDC* pDC = pView->GetDC();
render->oldhdc = wglGetCurrentDC();
render->oldhrc = wglGetCurrentContext();
render->hdc = CreateCompatibleDC(pDC->m_hDC);
// Preparing bitmap header for DIB section
BITMAPINFO bi;
ZeroMemory(&bi, sizeof(BITMAPINFO));
bi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bi.bmiHeader.biWidth = width;
bi.bmiHeader.biHeight = height;
bi.bmiHeader.biPlanes = 1;
bi.bmiHeader.biBitCount = 24;
bi.bmiHeader.biCompression = BI_RGB;
bi.bmiHeader.biSizeImage = width * height * 3;
bi.bmiHeader.biXPelsPerMeter = 2925;
bi.bmiHeader.biYPelsPerMeter = 2925;
// Creating a DIB surface
LPVOID lpBits;
render->hbm = CreateDIBSection(pDC->GetSafeHdc(), &bi, DIB_RGB_COLORS, (void**)&lpBits, NULL, (DWORD)0);
render->oldhbm = (HBITMAP)::SelectObject(render->hdc, render->hbm);
PIXELFORMATDESCRIPTOR pfd = {
sizeof(PIXELFORMATDESCRIPTOR), 1, PFD_DRAW_TO_BITMAP|PFD_SUPPORT_OPENGL,
PFD_TYPE_RGBA, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16,
0, 0, PFD_MAIN_PLANE, 0, 0, 0, 0 };
int pixelformat = ChoosePixelFormat(render->hdc, &pfd);
DescribePixelFormat(render->hdc, pixelformat, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
SetPixelFormat(render->hdc, pixelformat, &pfd);
render->hrc = wglCreateContext(render->hdc);
wglMakeCurrent(render->hdc, render->hrc);
GL_DisableVertexBufferObject();
return render;
}
void Sys_FinishMemoryRender(void* param)
{
LC_RENDER* render = (LC_RENDER*)param;
GL_EnableVertexBufferObject();
wglMakeCurrent (render->oldhdc, render->oldhrc);
wglDeleteContext(render->hrc);
SelectObject(render->hdc, render->oldhbm);
DeleteObject(render->hbm);
DeleteDC(render->hdc);
free(render);
}
/////////////////////////////////////////////////////////////////////////////
// Main window functions
void SystemPieceComboAdd(char* name)
{
CWnd* pWnd = AfxGetMainWnd();
if (pWnd != NULL)
pWnd->PostMessage(WM_LC_ADD_COMBO_STRING, (LPARAM)name);
}
void SystemCaptureMouse()
{
CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
CView* pView = pFrame->GetActiveView();
pView->SetCapture();
}
void SystemReleaseMouse()
{
ReleaseCapture();
}
void SystemExportClipboard(lcFile* clip)
{
if (clip == NULL)
return;
HGLOBAL hData = GlobalAlloc(GMEM_DDESHARE|GMEM_MOVEABLE, clip->GetLength());
void* lpBuffer = GlobalLock(hData);
clip->Seek(0, SEEK_SET);
clip->ReadBuffer(lpBuffer, clip->GetLength());
GlobalUnlock(hData);
if (OpenClipboard(NULL))
{
SetClipboardData(ClipboardFormat, hData);
CloseClipboard();
}
// else
// AfxMessageBox(IDS_CANNOT_OPEN_CLIPBOARD);
}
lcFile* SystemImportClipboard()
{
lcFile* clip = NULL;
if (ClipboardFormat != 0)
if (OpenClipboard(NULL))
{
HANDLE hData = ::GetClipboardData(ClipboardFormat);
if (hData != NULL)
{
clip = new lcMemFile();
BYTE* lpBuffer = (BYTE*)::GlobalLock(hData);
long nBufferSize = ::GlobalSize(hData);
clip->WriteBuffer(lpBuffer, nBufferSize);
GlobalUnlock(hData);
}
// else
// AfxMessageBox(IDS_CANNOT_GET_CLIPBOARD_DATA);
CloseClipboard();
}
// else
// AfxMessageBox(IDS_CANNOT_OPEN_CLIPBOARD);
return clip;
}
bool Sys_KeyDown(int key)
{
return GetKeyState(key) < 0;
}
void Sys_GetFileList(const char* Path, ObjArray<String>& FileList)
{
FileList.RemoveAll();
WIN32_FIND_DATA FindData;
HANDLE Find = INVALID_HANDLE_VALUE;
char Dir[MAX_PATH], FindPath[MAX_PATH];
strcpy(Dir, Path);
int Len = strlen(Dir);
if (Dir[Len-1] != '\\' && Dir[Len-1] != '/')
strcat(Dir, "\\");
strcpy(FindPath, Dir);
strcat(FindPath, "*");
Find = FindFirstFile(FindPath, &FindData);
if (Find == INVALID_HANDLE_VALUE)
return;
do
{
if (FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
continue;
char File[MAX_PATH];
strcpy(File, Dir);
strcat(File, FindData.cFileName);
FileList.Add(File);
}
while (FindNextFile(Find, &FindData) != 0);
FindClose(Find);
}
void SystemPumpMessages()
{
MSG msg;
while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
long SystemGetTicks()
{
return GetTickCount();
}
void SystemStartProgressBar(int nLower, int nUpper, int nStep, const char* Text)
{
CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
if (!pFrame)
return;
CCADStatusBar* pStatusBar = &pFrame->m_wndStatusBar;
pStatusBar->ShowProgressBar(TRUE);
pStatusBar->SetProgressBarRange(nLower, nUpper);
pStatusBar->SetProgressBarStep(nStep);
pStatusBar->SetProgressBarPos(0);
pFrame->SetStatusBarMessage(Text);
pFrame->SetMessageText(Text);
}
void SytemEndProgressBar()
{
CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
if (!pFrame)
return;
pFrame->m_wndStatusBar.ShowProgressBar(FALSE);
pFrame->SetStatusBarMessage("");
pFrame->SetMessageText(AFX_IDS_IDLEMESSAGE);
}
void SytemStepProgressBar()
{
CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
if (!pFrame)
return;
pFrame->m_wndStatusBar.StepProgressBar();
}
Reference in a new issue View git blame Copy permalink