开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > OpenGL > 查看源码
winmain.cpp
资源名称：celestia-1.6.0.tar.gz　[点击查看]
上传用户：center1979
上传日期：2022-07-26
资源大小：50633k
文件大小：138k
源码类别：

OpenGL

开发平台：

Visual C++

winmain.cpp：源码内容
  1. // winmain.cpp
  2. //
  3. // Copyright (C) 2001-2007, Chris Laurel <claurel@shatters.net>
  4. //
  5. // Windows front end for Celestia.
  6. //
  7. // This program is free software; you can redistribute it and/or
  8. // modify it under the terms of the GNU General Public License
  9. // as published by the Free Software Foundation; either version 2
  10. // of the License, or (at your option) any later version.
  12. #include <iostream>
  13. #include <fstream>
  14. #include <sstream>
  15. #include <algorithm>
  16. #include <set>
  17. #include <cstdlib>
  18. #include <cctype>
  19. #include <cstring>
  20. #include <cassert>
  21. #include <process.h>
  22. #include <time.h>
  23. #include <windows.h>
  24. #include <commctrl.h>
  25. #include <mmsystem.h>
  27. #include <celmath/vecmath.h>
  28. #include <celmath/quaternion.h>
  29. #include <celmath/mathlib.h>
  30. #include <celutil/debug.h>
  31. #include <celutil/util.h>
  32. #include <celutil/winutil.h>
  33. #include <celutil/filetype.h>
  34. #include <celengine/celestia.h>
  35. #include <celengine/astro.h>
  36. #include <celengine/cmdparser.h>
  37. #include <celengine/axisarrow.h>
  38. #include <celengine/planetgrid.h>
  40. #include "../celengine/gl.h"
  41. #include "../celengine/glext.h"
  42. #include "celestiacore.h"
  43. #include "imagecapture.h"
  44. #include "avicapture.h"
  45. #include "url.h"
  46. #include "winstarbrowser.h"
  47. #include "winssbrowser.h"
  48. #include "wintourguide.h"
  49. #include "wingotodlg.h"
  50. #include "winviewoptsdlg.h"
  51. #include "winlocations.h"
  52. #include "winbookmarks.h"
  53. #include "wineclipses.h"
  54. #include "winhyperlinks.h"
  55. #include "wintime.h"
  56. #include "winsplash.h"
  57. #include "odmenu.h"
  58. #include "scriptmenu.h"
  60. #include "res/resource.h"
  61. #include "wglext.h"
  63. #include <locale.h>
  65. using namespace std;
  67. typedef pair<int,string> IntStrPair;
  68. typedef vector<IntStrPair> IntStrPairVec;
  70. char AppName[] = "Celestia";
  72. static CelestiaCore* appCore = NULL;
  74. // Display modes for full screen operation
  75. static vector<DEVMODE>* displayModes = NULL;
  77. // Display mode indices
  78. static int currentScreenMode = 0;
  79. static int newScreenMode = 0;
  81. // The last fullscreen mode set; saved and restored from the registry
  82. static int lastFullScreenMode = 0;
  83. // A fullscreen mode guaranteed to work
  84. static int fallbackFullScreenMode = 0;
  85. static RECT windowRect;
  87. static HGLRC glContext;
  88. static HDC deviceContext;
  90. static bool bReady = false;
  92. static LPTSTR CelestiaRegKey = "Software\Shatters.net\Celestia";
  94. HINSTANCE appInstance;
  95. HMODULE hRes;
  96. HWND mainWindow = 0;
  98. static SolarSystemBrowser* solarSystemBrowser = NULL;
  99. static StarBrowser* starBrowser = NULL;
  100. static TourGuide* tourGuide = NULL;
  101. static GotoObjectDialog* gotoObjectDlg = NULL;
  102. static ViewOptionsDialog* viewOptionsDlg = NULL;
  103. static EclipseFinderDialog* eclipseFinder = NULL;
  104. static LocationsDialog* locationsDlg = NULL;
  105. static SplashWindow* s_splash = NULL;
  107. static HMENU menuBar = 0;
  108. ODMenu odAppMenu;
  109. static HACCEL acceleratorTable = 0;
  110. static bool hideMenuBar = false;
  112. // Joystick info
  113. static bool useJoystick = false;
  114. static bool joystickAvailable = false;
  115. static JOYCAPS joystickCaps;
  117. static HCURSOR hDefaultCursor = 0;
  118. bool cursorVisible = true;
  119. static POINT saveCursorPos;
  120. static POINT lastMouseMove;
  121. class WinCursorHandler;
  122. WinCursorHandler* cursorHandler = NULL;
  124. static int MovieSizes[8][2] = {
  125.                                 { 160, 120 },
  126.                                 { 320, 240 },
  127.                                 { 640, 480 },
  128.                                 { 720, 480 },
  129.                                 { 720, 576 },
  130.                                 { 1024, 768 },
  131.                                 { 1280, 720 },
  132.                                 { 1920, 1080 }
  133.                               };
  135. static float MovieFramerates[5] = { 15.0f, 24.0f, 25.0f, 29.97f, 30.0f };
  137. static int movieSize = 1;
  138. static int movieFramerate = 1;
  141. astro::Date newTime(0.0);
  143. #define REFMARKS 1
  145. #define INFINITE_MOUSE
  146. static int lastX = 0;
  147. static int lastY = 0;
  148. static bool ignoreNextMoveEvent = false;
  150. static const WPARAM ID_GOTO_URL = 62000;
  152. HWND hBookmarkTree;
  153. char bookmarkName[33];
  155. static const string ScriptsDirectory = "scripts";
  156. static vector<ScriptMenuItem>* ScriptMenuItems = NULL;
  159. static LRESULT CALLBACK MainWindowProc(HWND hWnd,
  160.                                        UINT uMsg,
  161.                                        WPARAM wParam, LPARAM lParam);
  164. #define MENU_CHOOSE_PLANET   32000
  165. #define MENU_CHOOSE_SURFACE  31000
  168. struct AppPreferences
  169. {
  170.     int winWidth;
  171.     int winHeight;
  172.     int winX;
  173.     int winY;
  174.     int renderFlags;
  175.     int labelMode;
  176.     int orbitMask;
  177.     float visualMagnitude;
  178.     float ambientLight;
  179.     float galaxyLightGain;
  180.     int showLocalTime;
  181.     int dateFormat;
  182.     int hudDetail;
  183.     int fullScreenMode;
  184.     uint32 lastVersion;
  185.     string altSurfaceName;
  186.     uint32 textureResolution;
  187.     Renderer::StarStyle starStyle;
  188.     GLContext::GLRenderPath renderPath;
  189.     bool renderPathSet;
  190. };
  192. void ChangeDisplayMode()
  193. {
  194.     DEVMODE device_mode;
  196.     memset(&device_mode, 0, sizeof(DEVMODE));
  198.     device_mode.dmSize = sizeof(DEVMODE);
  200.     device_mode.dmPelsWidth  = 800;
  201.     device_mode.dmPelsHeight = 600;
  202.     device_mode.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
  204.     ChangeDisplaySettings(&device_mode, CDS_FULLSCREEN);
  205. }
  207. void RestoreDisplayMode()
  208. {
  209.     ChangeDisplaySettings(0, 0);
  210. }
  212. //
  213. // A very minimal IDropTarget interface implementation
  214. //
  216. class CelestiaDropTarget : public IDropTarget
  217. {
  218. public:
  219.     CelestiaDropTarget();
  220.     ~CelestiaDropTarget();
  222.     STDMETHOD  (QueryInterface)(REFIID idd, void** ppvObject);
  223.     STDMETHOD_ (ULONG, AddRef) (void);
  224.     STDMETHOD_ (ULONG, Release) (void);
  226.     // IDropTarget methods
  227.     STDMETHOD (DragEnter)(LPDATAOBJECT pDataObj, DWORD grfKeyState, POINTL pt, LPDWORD pdwEffect);
  228.     STDMETHOD (DragOver) (DWORD grfKeyState, POINTL pt, LPDWORD pdwEffect);
  229.     STDMETHOD (DragLeave)(void);
  230.     STDMETHOD (Drop)     (LPDATAOBJECT pDataObj, DWORD grfKeyState, POINTL pt, LPDWORD pdwEffect);
  232. private:
  233.     ULONG refCount;
  234. };
  236. static CelestiaDropTarget* dropTarget = NULL;
  238. CelestiaDropTarget::CelestiaDropTarget() :
  239.     refCount(0)
  240. {
  241. }
  243. CelestiaDropTarget::~CelestiaDropTarget()
  244. {
  245. }
  247. HRESULT CelestiaDropTarget::QueryInterface(REFIID iid, void** ppvObject)
  248. {
  249.     if (iid == IID_IUnknown || iid == IID_IDropTarget)
  250.     {
  251.         *ppvObject = this;
  252.         AddRef();
  253.         return ResultFromScode(S_OK);
  254.     }
  255.     else
  256.     {
  257.         *ppvObject = NULL;
  258.         return ResultFromScode(E_NOINTERFACE);
  259.     }
  260. }
  262. ULONG CelestiaDropTarget::AddRef(void)
  263. {
  264.     return ++refCount;
  265. }
  267. ULONG CelestiaDropTarget::Release(void)
  268. {
  269.     if (--refCount == 0)
  270.     {
  271.         delete this;
  272.         return 0;
  273.     }
  275.     return refCount;
  276. }
  278. STDMETHODIMP
  279. CelestiaDropTarget::DragEnter(IDataObject* pDataObject,
  280.                               DWORD grfKeyState,
  281.                               POINTL pt,
  282.                               DWORD* pdwEffect)
  283. {
  284.     return S_OK;
  285. }
  287. STDMETHODIMP
  288. CelestiaDropTarget::DragOver(DWORD grfKeyState,
  289.                              POINTL pt,
  290.                              DWORD* pdwEffect)
  291. {
  292.     return S_OK;
  293. }
  295. STDMETHODIMP
  296. CelestiaDropTarget::DragLeave(void)
  297. {
  298.     return S_OK;
  299. }
  302. STDMETHODIMP
  303. CelestiaDropTarget::Drop(IDataObject* pDataObject,
  304.                          DWORD grfKeyState,
  305.                          POINTL pt,
  306.                          DWORD* pdwEffect)
  307. {
  309.     IEnumFORMATETC* enumFormat = NULL;
  310.     HRESULT hr = pDataObject->EnumFormatEtc(DATADIR_GET, &enumFormat);
  311.     if (FAILED(hr) || enumFormat == NULL)
  312.         return E_FAIL;
  314.     FORMATETC format;
  315.     ULONG nFetched;
  316.     while (enumFormat->Next(1, &format, &nFetched) == S_OK)
  317.     {
  318.         char buf[512];
  319.         if (GetClipboardFormatName(format.cfFormat, buf, 511) != 0 &&
  320.             !strcmp(buf, "UniformResourceLocator"))
  321.         {
  322.             STGMEDIUM medium;
  323.             if (pDataObject->GetData(&format, &medium) == S_OK)
  324.             {
  325.                 if (medium.tymed == TYMED_HGLOBAL && medium.hGlobal != 0)
  326.                 {
  327.                     char* s = (char*) GlobalLock(medium.hGlobal);
  328. appCore->goToUrl(s);
  329.                     GlobalUnlock(medium.hGlobal);
  330.                     break;
  331.                 }
  332.             }
  333.         }
  334.     }
  336.     enumFormat->Release();
  338.     return E_FAIL;
  339. }
  342. // Cursor handler callback class for Windows.  We pass an instance to
  343. // the app core which the calls the setCursorShape method to change
  344. // the cursor icon.
  345. class WinCursorHandler : public CelestiaCore::CursorHandler
  346. {
  347. public:
  348.     WinCursorHandler(HCURSOR _defaultCursor);
  349.     virtual ~WinCursorHandler();
  350.     virtual void setCursorShape(CelestiaCore::CursorShape);
  351.     virtual CelestiaCore::CursorShape getCursorShape() const;
  353. private:
  354.     CelestiaCore::CursorShape shape;
  355.     HCURSOR defaultCursor;
  356.     HCURSOR sizeVertical;
  357.     HCURSOR sizeHorizontal;
  358. };
  361. WinCursorHandler::WinCursorHandler(HCURSOR _defaultCursor) :
  362.     shape(CelestiaCore::ArrowCursor),
  363.     defaultCursor(_defaultCursor)
  364. {
  365.     sizeVertical   = LoadCursor(NULL, IDC_SIZENS);
  366.     sizeHorizontal = LoadCursor(NULL, IDC_SIZEWE);
  367. }
  370. WinCursorHandler::~WinCursorHandler()
  371. {
  372. }
  375. void WinCursorHandler::setCursorShape(CelestiaCore::CursorShape _shape)
  376. {
  377.     shape = _shape;
  378.     switch (shape)
  379.     {
  380.     case CelestiaCore::SizeVerCursor:
  381.         SetCursor(sizeVertical);
  382.         break;
  383.     case CelestiaCore::SizeHorCursor:
  384.         SetCursor(sizeHorizontal);
  385.         break;
  386.     default:
  387.         SetCursor(defaultCursor);
  388.         break;
  389.     }
  390. }
  393. CelestiaCore::CursorShape WinCursorHandler::getCursorShape() const
  394. {
  395.     return shape;
  396. }
  398. // end WinCursorHandler methods
  400. static void ShowUniversalTime(CelestiaCore* appCore)
  401. {
  402.     appCore->setTimeZoneBias(0);
  403.     appCore->setTimeZoneName("UTC");
  404. }
  407. static void ShowLocalTime(CelestiaCore* appCore)
  408. {
  409.     TIME_ZONE_INFORMATION tzi;
  410.     DWORD dst = GetTimeZoneInformation(&tzi);
  411.     if (dst != TIME_ZONE_ID_INVALID)
  412.     {
  413.         LONG dstBias = 0;
  414.         WCHAR* tzName = NULL;
  416.         if (dst == TIME_ZONE_ID_STANDARD)
  417.         {
  418.             dstBias = tzi.StandardBias;
  419.             tzName = tzi.StandardName;
  420.         }
  421.         else if (dst == TIME_ZONE_ID_DAYLIGHT)
  422.         {
  423.             dstBias = tzi.DaylightBias;
  424.             tzName = tzi.DaylightName;
  425.         }
  427.         appCore->setTimeZoneName("   ");
  428.         appCore->setTimeZoneBias((tzi.Bias + dstBias) * -60);
  429.     }
  430. }
  433. static bool BeginMovieCapture(const std::string& filename,
  434.                               int width, int height,
  435.                               float framerate)
  436. {
  437.     MovieCapture* movieCapture = new AVICapture();
  439.     bool success = movieCapture->start(filename, width, height, framerate);
  440.     if (success)
  441.         appCore->initMovieCapture(movieCapture);
  442.     else
  443.         delete movieCapture;
  445.     return success;
  446. }
  449. static bool CopyStateURLToClipboard()
  450. {
  451.     BOOL b;
  452.     b = OpenClipboard(mainWindow);
  453.     if (!b)
  454.         return false;
  456.     CelestiaState appState;
  457.     appState.captureState(appCore);
  458.     
  459.     Url url(appState, Url::CurrentVersion);
  460.     string urlString = url.getAsString();
  462.     char* s = const_cast<char*>(urlString.c_str());
  463.     HGLOBAL clipboardDataHandle = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE,
  464.                                               strlen(s) + 1);
  465.     char* clipboardData = (char*) GlobalLock(clipboardDataHandle);
  466.     if (clipboardData != NULL)
  467.     {
  468.         strcpy(clipboardData, s);
  469.         GlobalUnlock(clipboardDataHandle);
  470.         EmptyClipboard();
  471.         HANDLE h = SetClipboardData(CF_TEXT, clipboardDataHandle);
  472.         CloseClipboard();
  473.         return h != NULL;
  474.     }
  475.     else
  476.     {
  477.         CloseClipboard();
  478.         return false;
  479.     }
  480. }
  483. static bool ToggleMenuItem(HMENU menu, int id)
  484. {
  485.     MENUITEMINFO menuInfo;
  486.     menuInfo.cbSize = sizeof(MENUITEMINFO);
  487.     menuInfo.fMask = MIIM_STATE;
  488.     if (GetMenuItemInfo(menu, id, FALSE, &menuInfo))
  489.     {
  490.         bool isChecked = ((menuInfo.fState & MFS_CHECKED) != 0);
  491.         CheckMenuItem(menu, id, isChecked ? MF_UNCHECKED : MF_CHECKED);
  492.         return !isChecked;
  493.     }
  494.     return false;
  495. }
  497. bool LoadItemTextFromFile(HWND hWnd,
  498.                           int item,
  499.                           char* filename)
  500. {
  501.     // ifstream textFile(filename, ios::in | ios::binary);
  502.     ifstream textFile(filename, ios::in);
  503.     string s;
  505.     if (!textFile.good())
  506.     {
  507.         SetDlgItemText(hWnd, item, "License file missing!rrnSee http://www.gnu.org/copyleft/gpl.html");
  508.         return true;
  509.     }
  511.     char c;
  512.     while (textFile.get(c))
  513.     {
  514.         if (c == 'n')
  515.             s += "rrn";
  516.         else
  517.             s += c;
  518.     }
  520.     SetDlgItemText(hWnd, item, UTF8ToCurrentCP(s).c_str());
  522.     return true;
  523. }
  526. BOOL APIENTRY AboutProc(HWND hDlg,
  527.                         UINT message,
  528.                         UINT wParam,
  529.                         LONG lParam)
  530. {
  531.     switch (message)
  532.     {
  533.     case WM_INITDIALOG:
  534.         MakeHyperlinkFromStaticCtrl(hDlg, IDC_CELESTIALINK);
  535.         return(TRUE);
  537.     case WM_COMMAND:
  538.         if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
  539.         {
  540.             EndDialog(hDlg, 0);
  541.             return TRUE;
  542.         }
  543.         else if (LOWORD(wParam) == IDC_CELESTIALINK)
  544.         {
  545.             char urlBuf[256];
  546.             HWND hCtrl = GetDlgItem(hDlg, IDC_CELESTIALINK);
  547.             if (hCtrl)
  548.             {
  549.                 if (GetWindowText(hCtrl, urlBuf, sizeof(urlBuf)) > 0)
  550.                 {
  551.                     ShellExecute(hDlg, "open", urlBuf, NULL, NULL, SW_SHOWNORMAL);
  552.                     return TRUE;
  553.                 }
  554.             }
  555.         }
  556.         break;
  557.     }
  559.     return FALSE;
  560. }
  563. BOOL APIENTRY ControlsHelpProc(HWND hDlg,
  564.                               UINT message,
  565.                               UINT wParam,
  566.                               LONG lParam)
  567. {
  568.     switch (message)
  569.     {
  570.     case WM_INITDIALOG:
  571.         LoadItemTextFromFile(hDlg, IDC_TEXT_CONTROLSHELP, const_cast<char*>(LocaleFilename("controls.txt").c_str()));
  572.         return(TRUE);
  574.     case WM_COMMAND:
  575.         if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
  576.         {
  577.             EndDialog(hDlg, 0);
  578.             return TRUE;
  579.         }
  580.         break;
  581.     }
  583.     return FALSE;
  584. }
  587. BOOL APIENTRY LicenseProc(HWND hDlg,
  588.                           UINT message,
  589.                           UINT wParam,
  590.                           LONG lParam)
  591. {
  592.     switch (message)
  593.     {
  594.     case WM_INITDIALOG:
  595.         LoadItemTextFromFile(hDlg, IDC_LICENSE_TEXT, const_cast<char*>(LocaleFilename("COPYING").c_str()));
  596.         return(TRUE);
  598.     case WM_COMMAND:
  599.         if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
  600.         {
  601.             EndDialog(hDlg, 0);
  602.             return TRUE;
  603.         }
  604.         break;
  605.     }
  607.     return FALSE;
  608. }
  611. BOOL APIENTRY GLInfoProc(HWND hDlg,
  612.                          UINT message,
  613.                          UINT wParam,
  614.                          LONG lParam)
  615. {
  616.     switch (message)
  617.     {
  618.     case WM_INITDIALOG:
  619.         {
  620.             const char* vendor = (char*) glGetString(GL_VENDOR);
  621.             const char* render = (char*) glGetString(GL_RENDERER);
  622.             const char* version = (char*) glGetString(GL_VERSION);
  623.             const char* ext = (char*) glGetString(GL_EXTENSIONS);
  624.             string s;
  625.             s += UTF8ToCurrentCP(_("Vendor: "));
  626.             if (vendor != NULL)
  627.                 s += vendor;
  628.             s += "rrn";
  630.             s += UTF8ToCurrentCP(_("Renderer: "));
  631.             if (render != NULL)
  632.                 s += render;
  633.             s += "rrn";
  635.             s += UTF8ToCurrentCP(_("Version: "));
  636.             if (version != NULL)
  637.                 s += version;
  638.             s += "rrn";
  640.             if (ExtensionSupported("GL_ARB_shading_language_100"))
  641.             {
  642.                 const char* versionString = (const char*) glGetString(GL_SHADING_LANGUAGE_VERSION_ARB);
  643.                 if (versionString != NULL)
  644.                 {
  645.                     s += UTF8ToCurrentCP(_("GLSL version: "));
  646.                     s += versionString;
  647.                     s += "rrn";
  648.                 }
  649.             }
  651.             char buf[1024];
  652.             GLint simTextures = 1;
  653.             if (ExtensionSupported("GL_ARB_multitexture"))
  654.                 glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &simTextures);
  655.             sprintf(buf, "%s%drrn",
  656.                     UTF8ToCurrentCP(_("Max simultaneous textures: ")).c_str(),
  657.                     simTextures);
  658.             s += buf;
  660.             GLint maxTextureSize = 0;
  661.             glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
  662.             sprintf(buf, "%s%drrn",
  663.                     UTF8ToCurrentCP(_("Max texture size: ")).c_str(),
  664.                     maxTextureSize);
  665.             s += buf;
  667.             if (ExtensionSupported("GL_EXT_texture_cube_map"))
  668.             {
  669.                 GLint maxCubeMapSize = 0;
  670.                 glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, &maxCubeMapSize);
  671.                 sprintf(buf, "%s%drrn",
  672.                         UTF8ToCurrentCP(_("Max cube map size: ")).c_str(),
  673.                         maxTextureSize);
  674.                 s += buf;
  675.             }
  677.             GLfloat pointSizeRange[2];
  678.             glGetFloatv(GL_POINT_SIZE_RANGE, pointSizeRange);
  679.             sprintf(buf, "%s%f - %frrn",
  680.                     UTF8ToCurrentCP(_("Point size range: ")).c_str(),
  681.                     pointSizeRange[0], pointSizeRange[1]);
  682.             s += buf;
  684.             s += "rrn";
  685.             s += UTF8ToCurrentCP(_("Supported Extensions:")).c_str();
  686.             s += "rrn";
  688.             if (ext != NULL)
  689.             {
  690.                 string extString(ext);
  691.                 int pos = extString.find(' ', 0);
  692.                 while (pos != string::npos)
  693.                 {
  694.                     extString.replace(pos, 1, "rrn");
  695.                     pos = extString.find(' ', pos);
  696.                 }
  697.                 s += extString;
  698.             }
  700.             SetDlgItemText(hDlg, IDC_GLINFO_TEXT, s.c_str());
  701.         }
  702.         return(TRUE);
  704.     case WM_COMMAND:
  705.         if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
  706.         {
  707.             EndDialog(hDlg, 0);
  708.             return TRUE;
  709.         }
  710.         break;
  711.     }
  713.     return FALSE;
  714. }
  717. UINT CALLBACK ChooseMovieParamsProc(HWND hDlg, UINT message,
  718.                                     WPARAM wParam, LPARAM lParam)
  719. {
  720.     switch (message)
  721.     {
  722.     case WM_INITDIALOG:
  723.         {
  724.             char buf[100];
  725.             HWND hwnd = GetDlgItem(hDlg, IDC_COMBO_MOVIE_SIZE);
  726.             int nSizes = sizeof MovieSizes / sizeof MovieSizes[0];
  728.             int i;
  729.             for (i = 0; i < nSizes; i++)
  730.             {
  731.                 sprintf(buf, "%d x %d", MovieSizes[i][0], MovieSizes[i][1]);
  732.                 SendMessage(hwnd, CB_INSERTSTRING, -1,
  733.                             reinterpret_cast<LPARAM>(buf));
  735.             }
  736.             SendMessage(hwnd, CB_SETCURSEL, movieSize, 0);
  738.             hwnd = GetDlgItem(hDlg, IDC_COMBO_MOVIE_FRAMERATE);
  739.             int nFramerates = sizeof MovieFramerates / sizeof MovieFramerates[0];
  740.             for (i = 0; i < nFramerates; i++)
  741.             {
  742.                 sprintf(buf, "%.2f", MovieFramerates[i]);
  743.                 SendMessage(hwnd, CB_INSERTSTRING, -1,
  744.                             reinterpret_cast<LPARAM>(buf));
  745.             }
  746.             SendMessage(hwnd, CB_SETCURSEL, movieFramerate, 0);
  747.         }
  748.         return TRUE;
  750.     case WM_COMMAND:
  751.         if (LOWORD(wParam) == IDC_COMBO_MOVIE_SIZE)
  752.         {
  753.             if (HIWORD(wParam) == CBN_SELCHANGE)
  754.             {
  755.                 HWND hwnd = reinterpret_cast<HWND>(lParam);
  756.                 int item = SendMessage(hwnd, CB_GETCURSEL, 0, 0);
  757.                 if (item != CB_ERR)
  758.                     movieSize = item;
  759.             }
  760.             return TRUE;
  761.         }
  762.         else if (LOWORD(wParam) == IDC_COMBO_MOVIE_FRAMERATE)
  763.         {
  764.             if (HIWORD(wParam) == CBN_SELCHANGE)
  765.             {
  766.                 HWND hwnd = reinterpret_cast<HWND>(lParam);
  767.                 int item = SendMessage(hwnd, CB_GETCURSEL, 0, 0);
  768.                 if (item != CB_ERR)
  769.                     movieFramerate = item;
  770.             }
  771.             return TRUE;
  772.         }
  773.     }
  775.     return FALSE;
  776. }
  779. BOOL APIENTRY FindObjectProc(HWND hDlg,
  780.                              UINT message,
  781.                              UINT wParam,
  782.                              LONG lParam)
  783. {
  784.     switch (message)
  785.     {
  786.     case WM_INITDIALOG:
  787.         return(TRUE);
  789.     case WM_COMMAND:
  790.         if (LOWORD(wParam) == IDOK)
  791.         {
  792.             char buf[1024], out[1024];
  793.             wchar_t wbuff[1024];
  794.             int len = GetDlgItemText(hDlg, IDC_FINDOBJECT_EDIT, buf, sizeof(buf));
  795.             if (len > 0)
  796.             {
  797.                 int wlen = MultiByteToWideChar(CP_ACP, 0, buf, -1, wbuff, sizeof(wbuff));
  798.                 WideCharToMultiByte(CP_UTF8, 0, wbuff, wlen, out, sizeof(out), NULL, NULL);
  799.                 Selection sel = appCore->getSimulation()->findObject(string(out), true);
  800.                 if (!sel.empty())
  801.                     appCore->getSimulation()->setSelection(sel);
  802.             }
  803.             EndDialog(hDlg, 0);
  804.             return TRUE;
  805.         }
  806.         else if (LOWORD(wParam) == IDCANCEL)
  807.         {
  808.             EndDialog(hDlg, 0);
  809.             return FALSE;
  810.         }
  811.         break;
  812.     }
  814.     return FALSE;
  815. }
  818. BOOL APIENTRY AddBookmarkFolderProc(HWND hDlg,
  819.                                     UINT message,
  820.                                     UINT wParam,
  821.                                     LONG lParam)
  822. {
  823.     switch (message)
  824.     {
  825.     case WM_INITDIALOG:
  826.         {
  827.             // Center dialog directly over parent
  828.             HWND hParent = GetParent(hDlg);
  829.             CenterWindow(hParent, hDlg);
  831.             // Limit text of folder name to 32 chars
  832.             HWND hEdit = GetDlgItem(hDlg, IDC_BOOKMARKFOLDER);
  833.             SendMessage(hEdit, EM_LIMITTEXT, 32, 0);
  835.             // Set initial button states
  836.             HWND hOK = GetDlgItem(hDlg, IDOK);
  837.             HWND hCancel = GetDlgItem(hDlg, IDCANCEL);
  838.             EnableWindow(hOK, FALSE);
  839.             RemoveButtonDefaultStyle(hOK);
  840.             AddButtonDefaultStyle(hCancel);
  841.         }
  842.         return TRUE;
  844.     case WM_COMMAND:
  845.         {
  846.             if (HIWORD(wParam) == EN_CHANGE)
  847.             {
  848.                 HWND hOK = GetDlgItem(hDlg, IDOK);
  849.                 HWND hCancel = GetDlgItem(hDlg, IDCANCEL);
  851.                 if (hOK && hCancel)
  852.                 {
  853.                     // If edit control contains text, enable OK button
  854.                     char name[33];
  855.                     GetWindowText((HWND)lParam, name, sizeof(name));
  856.                     if (name[0])
  857.                     {
  858.                         // Remove Cancel button default style
  859.                         RemoveButtonDefaultStyle(hCancel);
  861.                         // Enable OK button
  862.                         EnableWindow(hOK, TRUE);
  864.                         // Make OK button default
  865.                         AddButtonDefaultStyle(hOK);
  866.                     }
  867.                     else
  868.                     {
  869.                         // Disable OK button
  870.                         EnableWindow(hOK, FALSE);
  872.                         // Remove OK button default style
  873.                         RemoveButtonDefaultStyle(hOK);
  875.                         // Make Cancel button default
  876.                         AddButtonDefaultStyle(hCancel);
  877.                     }
  878.                 }
  879.             }
  880.         }
  882.         if (LOWORD(wParam) == IDOK)
  883.         {
  884.             // Get text entered in Folder Name Edit box
  885.             char name[33];
  886.             HWND hEdit = GetDlgItem(hDlg, IDC_BOOKMARKFOLDER);
  887.             if (hEdit)
  888.             {
  889.                 if (GetWindowText(hEdit, name, sizeof(name)))
  890.                 {
  891.                     // Create new folder in parent dialog tree control.
  892.                     AddNewBookmarkFolderInTree(hBookmarkTree, appCore, name);
  893.                 }
  894.             }
  896.             EndDialog(hDlg, 0);
  897.             return TRUE;
  898.         }
  899.         else if (LOWORD(wParam) == IDCANCEL)
  900.         {
  901.             EndDialog(hDlg, 0);
  902.             return FALSE;
  903.         }
  904.     }
  906.     return FALSE;
  907. }
  909. BOOL APIENTRY AddBookmarkProc(HWND hDlg,
  910.                               UINT message,
  911.                               UINT wParam,
  912.                               LONG lParam)
  913. {
  914.     switch (message)
  915.     {
  916.     case WM_INITDIALOG:
  917.         {
  918.         RECT dlgRect, treeRect;
  919.         HWND hCtrl;
  920.         if (GetWindowRect(hDlg, &dlgRect))
  921.         {
  922.             if (hCtrl = GetDlgItem(hDlg, IDC_BOOKMARK_FOLDERTREE))
  923.             {
  924.                 if (GetWindowRect(hCtrl, &treeRect))
  925.                 {
  926.                     int width = dlgRect.right - dlgRect.left;
  927.                     int height = treeRect.top - dlgRect.top;
  928.                     SetWindowPos(hDlg, HWND_TOP, 0, 0, width, height,
  929.                                  SWP_NOMOVE | SWP_NOZORDER);
  930.                 }
  932.                 HTREEITEM hParent;
  933.                 if (hParent = PopulateBookmarkFolders(hCtrl, appCore, appInstance))
  934.                 {
  935.                     //Expand bookmarks item
  936.                     TreeView_Expand(hCtrl, hParent, TVE_EXPAND);
  937.                 }
  938.             }
  939.         }
  941.         //Set initial button states
  942.         HWND hOK = GetDlgItem(hDlg, IDOK);
  943.         HWND hCancel = GetDlgItem(hDlg, IDCANCEL);
  944.         EnableWindow(hOK, FALSE);
  945.         RemoveButtonDefaultStyle(hOK);
  946.         AddButtonDefaultStyle(hCancel);
  948.         // Set bookmark text to selection text
  949.         if (hCtrl = GetDlgItem(hDlg, IDC_BOOKMARK_EDIT))
  950.         {
  951.             //If this is a body, set the text.
  952.             Selection sel = appCore->getSimulation()->getSelection();
  953.             switch (sel.getType())
  954.             {
  955.             case Selection::Type_Body:
  956.                 {
  957.                     string name = UTF8ToCurrentCP(sel.body()->getName(true));
  958.                     SetWindowText(hCtrl, (char*)name.c_str());
  959.                 }
  960.                 break;
  962.             default:
  963.                 break;
  964.             }
  965.         }
  967.         return(TRUE);
  968.         }
  970.     case WM_COMMAND:
  971.         {
  972.         if (HIWORD(wParam) == EN_CHANGE)
  973.         {
  974.             HWND hOK = GetDlgItem(hDlg, IDOK);
  975.             HWND hCancel = GetDlgItem(hDlg, IDCANCEL);
  977.             if (hOK && hCancel)
  978.             {
  979.                 //If edit control contains text, enable OK button
  980.                 char name[33];
  981.                 GetWindowText((HWND)lParam, name, sizeof(name));
  982.                 if (name[0])
  983.                 {
  984.                     //Remove Cancel button default style
  985.                     RemoveButtonDefaultStyle(hCancel);
  987.                     //Enable OK button
  988.                     EnableWindow(hOK, TRUE);
  990.                     //Make OK button default
  991.                     AddButtonDefaultStyle(hOK);
  992.                 }
  993.                 else
  994.                 {
  995.                     //Disable OK button
  996.                     EnableWindow(hOK, FALSE);
  998.                     //Remove OK button default style
  999.                     RemoveButtonDefaultStyle(hOK);
  1001.                     //Make Cancel button default
  1002.                     AddButtonDefaultStyle(hCancel);
  1003.                 }
  1004.             }
  1005.         }
  1006.         if (LOWORD(wParam) == IDOK)
  1007.         {
  1008.             char name[33];
  1009.             int len = GetDlgItemText(hDlg, IDC_BOOKMARK_EDIT, name, sizeof(name));
  1010.             if (len > 0)
  1011.             {
  1012.                 HWND hTree;
  1013.                 if(hTree = GetDlgItem(hDlg, IDC_BOOKMARK_FOLDERTREE))
  1014.                 {
  1015.                     InsertBookmarkInFavorites(hTree, name, appCore);
  1017.                     appCore->writeFavoritesFile();
  1019.                     // Rebuild bookmarks menu.
  1020.                     BuildFavoritesMenu(menuBar, appCore, appInstance, &odAppMenu);
  1021.                 }
  1022.             }
  1023.             EndDialog(hDlg, 0);
  1024.             return TRUE;
  1025.         }
  1026.         else if (LOWORD(wParam) == IDCANCEL)
  1027.         {
  1028.             EndDialog(hDlg, 0);
  1029.             return FALSE;
  1030.         }
  1031.         else if (LOWORD(wParam) == IDC_BOOKMARK_CREATEIN)
  1032.         {
  1033.             HWND button;
  1034.             RECT dlgRect, treeRect;
  1035.             HWND hTree;
  1036.             char text[16];
  1037.             if (GetWindowRect(hDlg, &dlgRect))
  1038.             {
  1039.                 if (hTree = GetDlgItem(hDlg, IDC_BOOKMARK_FOLDERTREE))
  1040.                 {
  1041.                     if (GetWindowRect(hTree, &treeRect))
  1042.                     {
  1043.                         if (button = GetDlgItem(hDlg, IDC_BOOKMARK_CREATEIN))
  1044.                         {
  1045.                             if (GetWindowText(button, text, sizeof(text)))
  1046.                             {
  1047.                                 int width = dlgRect.right - dlgRect.left;
  1048.                                 if (strstr(text, ">>"))
  1049.                                 {
  1050.                                     //Increase size of dialog
  1051.                                     int height = treeRect.bottom - dlgRect.top + 12;
  1052.                                     SetWindowPos(hDlg, HWND_TOP, 0, 0, width, height,
  1053.                                                  SWP_NOMOVE | SWP_NOZORDER);
  1054.                                     //Change text in button
  1055.                                     strcpy(text + strlen(text) - 2, "<<");
  1056.                                     SetWindowText(button, text);
  1057.                                 }
  1058.                                 else
  1059.                                 {
  1060.                                     //Decrease size of dialog
  1061.                                     int height = treeRect.top - dlgRect.top;
  1062.                                     SetWindowPos(hDlg, HWND_TOP, 0, 0, width, height,
  1063.                                                  SWP_NOMOVE | SWP_NOZORDER);
  1064.                                     //Change text in button
  1065.                                     strcpy(text + strlen(text) - 2, ">>");
  1066.                                     SetWindowText(button, text);
  1067.                                 }
  1068.                             }
  1069.                         }
  1070.                     }
  1071.                 }
  1072.             }
  1073.         }
  1074.         else if (LOWORD(wParam) == IDC_BOOKMARK_NEWFOLDER)
  1075.         {
  1076.             if(hBookmarkTree = GetDlgItem(hDlg, IDC_BOOKMARK_FOLDERTREE))
  1077.             {
  1078.                 DialogBox(hRes, MAKEINTRESOURCE(IDD_ADDBOOKMARK_FOLDER),
  1079.                           hDlg, AddBookmarkFolderProc);
  1080.             }
  1081.         }
  1082.         break;
  1083.         }
  1084.     }
  1086.     return FALSE;
  1087. }
  1089. BOOL APIENTRY RenameBookmarkProc(HWND hDlg,
  1090.                                  UINT message,
  1091.                                  UINT wParam,
  1092.                                  LONG lParam)
  1093. {
  1094.     switch (message)
  1095.     {
  1096.     case WM_INITDIALOG:
  1097.         {
  1098.         //Center dialog directly over parent
  1099.         HWND hParent = GetParent(hDlg);
  1100.         CenterWindow(hParent, hDlg);
  1102.         //Limit text of folder name to 32 chars
  1103.         HWND hEdit = GetDlgItem(hDlg, IDC_NEWBOOKMARK);
  1104.         SendMessage(hEdit, EM_LIMITTEXT, 32, 0);
  1106.         //Set text in edit control to current bookmark name
  1107.         SetWindowText(hEdit, bookmarkName);
  1109.         return(TRUE);
  1110.         }
  1112.     case WM_COMMAND:
  1113.         {
  1114.         if (HIWORD(wParam) == EN_CHANGE)
  1115.         {
  1116.             HWND hOK = GetDlgItem(hDlg, IDOK);
  1117.             HWND hCancel = GetDlgItem(hDlg, IDCANCEL);
  1119.             if (hOK && hCancel)
  1120.             {
  1121.                 //If edit control contains text, enable OK button
  1122.                 char name[33];
  1123.                 GetWindowText((HWND)lParam, name, sizeof(name));
  1124.                 if (name[0])
  1125.                 {
  1126.                     //Remove Cancel button default style
  1127.                     RemoveButtonDefaultStyle(hCancel);
  1129.                     //Enable OK button
  1130.                     EnableWindow(hOK, TRUE);
  1132.                     //Make OK button default
  1133.                     AddButtonDefaultStyle(hOK);
  1134.                 }
  1135.                 else
  1136.                 {
  1137.                     //Disable OK button
  1138.                     EnableWindow(hOK, FALSE);
  1140.                     //Remove OK button default style
  1141.                     RemoveButtonDefaultStyle(hOK);
  1143.                     //Make Cancel button default
  1144.                     AddButtonDefaultStyle(hCancel);
  1145.                 }
  1146.             }
  1147.         }
  1148.         if (LOWORD(wParam) == IDOK)
  1149.         {
  1150.             //Get text entered in Folder Name Edit box
  1151.             char name[33];
  1152.             HWND hEdit = GetDlgItem(hDlg, IDC_NEWBOOKMARK);
  1153.             if (hEdit)
  1154.             {
  1155.                 if (GetWindowText(hEdit, name, sizeof(name)))
  1156.                     RenameBookmarkInFavorites(hBookmarkTree, name, appCore);
  1157.             }
  1159.             EndDialog(hDlg, 0);
  1160.             return TRUE;
  1161.         }
  1162.         else if (LOWORD(wParam) == IDCANCEL)
  1163.         {
  1164.             EndDialog(hDlg, 0);
  1165.             return FALSE;
  1166.         }
  1167.         }
  1168.     }
  1170.     return FALSE;
  1171. }
  1173. BOOL APIENTRY OrganizeBookmarksProc(HWND hDlg,
  1174.                                     UINT message,
  1175.                                     UINT wParam,
  1176.                                     LONG lParam)
  1177. {
  1178.     static UINT_PTR dragDropTimer;
  1179.     switch (message)
  1180.     {
  1181.     case WM_INITDIALOG:
  1182.         {
  1183.         HWND hCtrl;
  1184.         if (hCtrl = GetDlgItem(hDlg, IDC_ORGANIZE_BOOKMARK_TREE))
  1185.         {
  1186.             HTREEITEM hParent;
  1187.             if (hParent = PopulateBookmarksTree(hCtrl, appCore, hRes))
  1188.             {
  1189.                 // Expand bookmarks item
  1190.                 TreeView_Expand(hCtrl, hParent, TVE_EXPAND);
  1191.             }
  1192.         }
  1193.         if (hCtrl = GetDlgItem(hDlg, IDC_ORGANIZE_BOOKMARKS_DELETE))
  1194.             EnableWindow(hCtrl, FALSE);
  1195.         if (hCtrl = GetDlgItem(hDlg, IDC_ORGANIZE_BOOKMARKS_RENAME))
  1196.             EnableWindow(hCtrl, FALSE);
  1198.         return(TRUE);
  1199.         }
  1201.     case WM_COMMAND:
  1202.         {
  1203.         if (LOWORD(wParam) == IDOK)
  1204.         {
  1205. #if 0
  1206.             HWND hTree;
  1207.             if (hTree = GetDlgItem(hDlg, IDC_ORGANIZE_BOOKMARK_TREE))
  1208.                 SyncTreeFoldersWithFavoriteFolders(hTree, appCore);
  1209. #endif
  1211.             // Write any change to bookmarks
  1212.             appCore->writeFavoritesFile();
  1214.             // Rebuild bookmarks menu
  1215.             BuildFavoritesMenu(menuBar, appCore, hRes, &odAppMenu);
  1217.             EndDialog(hDlg, 0);
  1218.             return TRUE;
  1219.         }
  1220.         else if (LOWORD(wParam) == IDCANCEL)
  1221.         {
  1222.             //Refresh from file
  1223.             appCore->readFavoritesFile();
  1225.             EndDialog(hDlg, 0);
  1226.             return FALSE;
  1227.         }
  1228.         else if (LOWORD(wParam) == IDC_ORGANIZE_BOOKMARKS_NEWFOLDER)
  1229.         {
  1230.             if (hBookmarkTree = GetDlgItem(hDlg, IDC_ORGANIZE_BOOKMARK_TREE))
  1231.             {
  1232.                 DialogBox(hRes, MAKEINTRESOURCE(IDD_ADDBOOKMARK_FOLDER), hDlg, AddBookmarkFolderProc);
  1233.             }
  1234.         }
  1235.         else if (LOWORD(wParam) == IDC_ORGANIZE_BOOKMARKS_RENAME)
  1236.         {
  1237.             if (hBookmarkTree = GetDlgItem(hDlg, IDC_ORGANIZE_BOOKMARK_TREE))
  1238.             {
  1239.                 HTREEITEM hItem;
  1240.                 TVITEM tvItem;
  1241.                 if (hItem = TreeView_GetSelection(hBookmarkTree))
  1242.                 {
  1243.                     tvItem.hItem = hItem;
  1244.                     tvItem.mask = TVIF_TEXT | TVIF_HANDLE;
  1245.                     tvItem.pszText = bookmarkName;
  1246.                     tvItem.cchTextMax = sizeof(bookmarkName);
  1247.                     if (TreeView_GetItem(hBookmarkTree, &tvItem))
  1248.                     {
  1249.                         DialogBox(hRes,
  1250.                                   MAKEINTRESOURCE(IDD_RENAME_BOOKMARK),
  1251.                                   hDlg, RenameBookmarkProc);
  1252.                     }
  1253.                 }
  1254.             }
  1255.         }
  1256.         else if (LOWORD(wParam) == IDC_ORGANIZE_BOOKMARKS_DELETE)
  1257.         {
  1258.             HWND hTree;
  1259.             if (hTree = GetDlgItem(hDlg, IDC_ORGANIZE_BOOKMARK_TREE))
  1260.                 DeleteBookmarkFromFavorites(hTree, appCore);
  1261.         }
  1262.         break;
  1263.         }
  1264.     case WM_NOTIFY:
  1265.         {
  1266.             if (((LPNMHDR)lParam)->code == TVN_SELCHANGED)
  1267.             {
  1268.                 HWND hTree;
  1269.                 if (hTree = GetDlgItem(hDlg, IDC_ORGANIZE_BOOKMARK_TREE))
  1270.                 {
  1271.                     //Enable buttons as necessary
  1272.                     HTREEITEM hItem;
  1273.                     if (hItem = TreeView_GetSelection(hTree))
  1274.                     {
  1275.                         HWND hDelete, hRename;
  1276.                         hDelete = GetDlgItem(hDlg, IDC_ORGANIZE_BOOKMARKS_DELETE);
  1277.                         hRename = GetDlgItem(hDlg, IDC_ORGANIZE_BOOKMARKS_RENAME);
  1278.                         if (hDelete && hRename)
  1279.                         {
  1280.                             if (TreeView_GetParent(hTree, hItem))
  1281.                             {
  1282.                                 EnableWindow(hDelete, TRUE);
  1283.                                 EnableWindow(hRename, TRUE);
  1284.                             }
  1285.                             else
  1286.                             {
  1287.                                 EnableWindow(hDelete, FALSE);
  1288.                                 EnableWindow(hRename, FALSE);
  1289.                             }
  1290.                         }
  1291.                     }
  1292.                 }
  1293.             }
  1294.             else if(((LPNMHDR)lParam)->code == TVN_BEGINDRAG)
  1295.             {
  1296.                 //Do not allow folders to be dragged
  1297.                 HWND hTree;
  1298.                 TVITEM tvItem;
  1299.                 LPNMTREEVIEW nm = (LPNMTREEVIEW)lParam;
  1300.                 HTREEITEM hItem = nm->itemNew.hItem;
  1302.                 if (hTree = GetDlgItem(hDlg, IDC_ORGANIZE_BOOKMARK_TREE))
  1303.                 {
  1304.                     tvItem.hItem = hItem;
  1305.                     tvItem.mask = TVIF_PARAM | TVIF_HANDLE;
  1306.                     if (TreeView_GetItem(hTree, &tvItem))
  1307.                     {
  1308.                         if(tvItem.lParam != 1)
  1309.                         {
  1310.                             //Start a timer to handle auto-scrolling
  1311.                             dragDropTimer = SetTimer(hDlg, 1, 100, NULL);
  1312.                             OrganizeBookmarksOnBeginDrag(hTree, (LPNMTREEVIEW)lParam);
  1313.                         }
  1314.                     }
  1315.                 }
  1316.             }
  1317.         }
  1318.         break;
  1319.     case WM_MOUSEMOVE:
  1320.         {
  1321.             if(isOrganizeBookmarksDragDropActive())
  1322.             {
  1323.                 HWND hTree;
  1324.                 if (hTree = GetDlgItem(hDlg, IDC_ORGANIZE_BOOKMARK_TREE))
  1325.                 {
  1326.                     OrganizeBookmarksOnMouseMove(hTree, GET_X_LPARAM(lParam),
  1327.                         GET_Y_LPARAM(lParam));
  1328.                 }
  1329.             }
  1330.         }
  1331.         break;
  1332.     case WM_LBUTTONUP:
  1333.         {
  1334.             if(isOrganizeBookmarksDragDropActive())
  1335.             {
  1336.                 HWND hTree;
  1337.                 if (hTree = GetDlgItem(hDlg, IDC_ORGANIZE_BOOKMARK_TREE))
  1338.                 {
  1339.                     //Kill the auto-scroll timer
  1340.                     KillTimer(hDlg, dragDropTimer);
  1342.                     OrganizeBookmarksOnLButtonUp(hTree);
  1343.                     MoveBookmarkInFavorites(hTree, appCore);
  1344.                 }
  1345.             }
  1346.         }
  1347.         break;
  1348.     case WM_TIMER:
  1349.         {
  1350.             if(isOrganizeBookmarksDragDropActive())
  1351.             {
  1352.                 if(wParam == 1)
  1353.                 {
  1354.                     //Handle
  1355.                     HWND hTree;
  1356.                     if (hTree = GetDlgItem(hDlg, IDC_ORGANIZE_BOOKMARK_TREE))
  1357.                     {
  1358.                         DragDropAutoScroll(hTree);
  1359.                     }
  1360.                 }
  1361.             }
  1362.         }
  1363.         break;
  1364.     }
  1366.     return FALSE;
  1367. }
  1370. int selectedScreenMode = 0;
  1371. BOOL APIENTRY SelectDisplayModeProc(HWND hDlg,
  1372.                                     UINT message,
  1373.                                     UINT wParam,
  1374.                                     LONG lParam)
  1375. {
  1376.     switch (message)
  1377.     {
  1378.     case WM_INITDIALOG:
  1379.         {
  1380.             char buf[100];
  1381.             HWND hwnd = GetDlgItem(hDlg, IDC_COMBO_RESOLUTION);
  1383.             // Add windowed mode as the first item on the menu
  1384.             bind_textdomain_codeset("celestia", CurrentCP());
  1385.             SendMessage(hwnd, CB_INSERTSTRING, -1,
  1386.                         reinterpret_cast<LPARAM>(_("Windowed Mode")));
  1387.             bind_textdomain_codeset("celestia", "UTF8");
  1389.             for (vector<DEVMODE>::const_iterator iter= displayModes->begin();
  1390.                  iter != displayModes->end(); iter++)
  1391.             {
  1392.                 sprintf(buf, "%d x %d x %d",
  1393.                         iter->dmPelsWidth, iter->dmPelsHeight,
  1394.                         iter->dmBitsPerPel);
  1395.                 SendMessage(hwnd, CB_INSERTSTRING, -1,
  1396.                             reinterpret_cast<LPARAM>(buf));
  1397.             }
  1398.             SendMessage(hwnd, CB_SETCURSEL, currentScreenMode, 0);
  1399.         }
  1400.         return TRUE;
  1402.     case WM_COMMAND:
  1403.         if (LOWORD(wParam) == IDOK)
  1404.         {
  1405.             newScreenMode = selectedScreenMode;
  1406.             EndDialog(hDlg, 0);
  1407.             return TRUE;
  1408.         }
  1409.         else if (LOWORD(wParam) == IDCANCEL)
  1410.         {
  1411.             EndDialog(hDlg, 0);
  1412.             return TRUE;
  1413.         }
  1414.         else if (LOWORD(wParam) == IDC_COMBO_RESOLUTION)
  1415.         {
  1416.             if (HIWORD(wParam) == CBN_SELCHANGE)
  1417.             {
  1418.                 HWND hwnd = reinterpret_cast<HWND>(lParam);
  1419.                 int item = SendMessage(hwnd, CB_GETCURSEL, 0, 0);
  1420.                 if (item != CB_ERR)
  1421.                     selectedScreenMode = item;
  1422.             }
  1423.             return TRUE;
  1424.         }
  1425.     }
  1427.     return FALSE;
  1428. }
  1431. HMENU CreateMenuBar()
  1432. {
  1433.     return LoadMenu(hRes, MAKEINTRESOURCE(IDR_MAIN_MENU));
  1434. }
  1436. static void setMenuItemCheck(int menuItem, bool checked)
  1437. {
  1438.     CheckMenuItem(menuBar, menuItem, checked ? MF_CHECKED : MF_UNCHECKED);
  1439. }
  1441. struct IntStrPairComparePredicate
  1442. {
  1443.     IntStrPairComparePredicate() : dummy(0)
  1444.     {
  1445.     }
  1447.     bool operator()(const IntStrPair pair1, const IntStrPair pair2) const
  1448.     {
  1449.         return (pair1.second.compare(pair2.second) < 0);
  1450.     }
  1452.     int dummy;
  1453. };
  1455. static HMENU CreatePlanetarySystemMenu(string parentName, const PlanetarySystem* psys)
  1456. {
  1457.     // Use some vectors to categorize and sort the bodies within this PlanetarySystem.
  1458.     // In order to generate sorted menus, we must carry the name and menu index as a
  1459.     // single unit in the sort. One obvous way is to create a vector<pair<int,string>>
  1460.     // and then use a comparison predicate to sort.the vector based on the string in
  1461.     // each pair.
  1463.     // Declare vector<pair<int,string>> objects for each classification of body
  1464.     vector<IntStrPair> asteroids;
  1465.     vector<IntStrPair> comets;
  1466.     vector<IntStrPair> invisibles;
  1467.     vector<IntStrPair> moons;
  1468.     vector<IntStrPair> planets;
  1469.     vector<IntStrPair> spacecraft;
  1471.     // We will use these objects to iterate over all the above vectors
  1472.     vector<IntStrPairVec> objects;
  1473.     vector<string> menuNames;
  1475.     // Place each body in the correct vector based on classification
  1476.     HMENU menu = CreatePopupMenu();
  1477.     for (int i = 0; i < psys->getSystemSize(); i++)
  1478.     {
  1479.         Body* body = psys->getBody(i);
  1480.         if (!body->getName().empty())
  1481.         {
  1482.             switch(body->getClassification())
  1483.             {
  1484.             case Body::Asteroid:
  1485.                 asteroids.push_back(make_pair(i, UTF8ToCurrentCP(body->getName(true))));
  1486.                 break;
  1487.             case Body::Comet:
  1488.                 comets.push_back(make_pair(i, UTF8ToCurrentCP(body->getName(true))));
  1489.                 break;
  1490.             case Body::Invisible:
  1491.                 invisibles.push_back(make_pair(i, UTF8ToCurrentCP(body->getName(true))));
  1492.                 break;
  1493.             case Body::Moon:
  1494.                 moons.push_back(make_pair(i, UTF8ToCurrentCP(body->getName(true))));
  1495.                 break;
  1496.             case Body::Planet:
  1497.                 planets.push_back(make_pair(i, UTF8ToCurrentCP(body->getName(true))));
  1498.                 break;
  1499.             case Body::Spacecraft:
  1500.                 spacecraft.push_back(make_pair(i, UTF8ToCurrentCP(body->getName(true))));
  1501.                 break;
  1502.             }
  1503.         }
  1504.     }
  1506.     // Add each vector of PlanetarySystem bodies to a vector to iterate over
  1507.     objects.push_back(asteroids);
  1508.     menuNames.push_back(UTF8ToCurrentCP(_("Asteroids")));
  1509.     objects.push_back(comets);
  1510.     menuNames.push_back(UTF8ToCurrentCP(_("Comets")));
  1511.     objects.push_back(invisibles);
  1512.     menuNames.push_back(UTF8ToCurrentCP(_("Invisibles")));
  1513.     objects.push_back(moons);
  1514.     menuNames.push_back(UTF8ToCurrentCP(_("Moons")));
  1515.     objects.push_back(planets);
  1516.     menuNames.push_back(UTF8ToCurrentCP(_("Planets")));
  1517.     objects.push_back(spacecraft);
  1518.     menuNames.push_back(UTF8ToCurrentCP(_("Spacecraft")));
  1520.     // Now sort each vector and generate submenus
  1521.     IntStrPairComparePredicate pred;
  1522.     vector<IntStrPairVec>::iterator obj;
  1523.     vector<IntStrPair>::iterator it;
  1524.     vector<string>::iterator menuName;
  1525.     HMENU hSubMenu;
  1526.     int numSubMenus;
  1528.     // Count how many submenus we need to create
  1529.     numSubMenus = 0;
  1530.     for (obj=objects.begin(); obj != objects.end(); obj++)
  1531.     {
  1532.         if (obj->size() > 0)
  1533.             numSubMenus++;
  1534.     }
  1536.     menuName = menuNames.begin();
  1537.     for (obj=objects.begin(); obj != objects.end(); obj++)
  1538.     {
  1539.         // Only generate a submenu if the vector is not empty
  1540.         if (obj->size() > 0)
  1541.         {
  1542.             // Don't create a submenu for a single item
  1543.             if (obj->size() == 1)
  1544.             {
  1545.                 it=obj->begin();
  1546.                 AppendMenu(menu, MF_STRING, MENU_CHOOSE_PLANET + it->first, it->second.c_str());
  1547.             }
  1548.             else
  1549.             {
  1550.                 // Skip sorting if we are dealing with the planets in our own Solar System.
  1551.                 if (parentName != "Sol" || *menuName != UTF8ToCurrentCP(_("Planets")))
  1552.                     sort(obj->begin(), obj->end(), pred);
  1554.                 if (numSubMenus > 1)
  1555.                 {
  1556.                     // Add items to submenu
  1557.                     hSubMenu = CreatePopupMenu();
  1558.                     for(it=obj->begin(); it != obj->end(); it++)
  1559.                         AppendMenu(hSubMenu, MF_STRING, MENU_CHOOSE_PLANET + it->first, it->second.c_str());
  1561.                     AppendMenu(menu, MF_POPUP | MF_STRING, (DWORD)hSubMenu, menuName->c_str());
  1562.                 }
  1563.                 else
  1564.                 {
  1565.                     // Just add items to the popup
  1566.                     for(it=obj->begin(); it != obj->end(); it++)
  1567.                         AppendMenu(menu, MF_STRING, MENU_CHOOSE_PLANET + it->first, it->second.c_str());
  1568.                 }
  1569.             }
  1570.         }
  1571.         menuName++;
  1572.     }
  1574.     return menu;
  1575. }
  1578. static HMENU CreateAlternateSurfaceMenu(const vector<string>& surfaces)
  1579. {
  1580.     HMENU menu = CreatePopupMenu();
  1582.     AppendMenu(menu, MF_STRING, MENU_CHOOSE_SURFACE, "Normal");
  1583.     for (unsigned int i = 0; i < surfaces.size(); i++)
  1584.     {
  1585.         AppendMenu(menu, MF_STRING, MENU_CHOOSE_SURFACE + i + 1,
  1586.                    surfaces[i].c_str());
  1587.     }
  1589.     return menu;
  1590. }
  1593. VOID APIENTRY handlePopupMenu(HWND hwnd,
  1594.                               float x, float y,
  1595.                               const Selection& sel)
  1596. {
  1597.     HMENU hMenu;
  1598.     string name;
  1600.     hMenu = CreatePopupMenu();
  1601.     switch (sel.getType())
  1602.     {
  1603.     case Selection::Type_Body:
  1604.         {
  1605.             name = sel.body()->getName(true);
  1606.             AppendMenu(hMenu, MF_STRING, ID_NAVIGATION_CENTER, UTF8ToCurrentCP(name).c_str());
  1607.             AppendMenu(hMenu, MF_SEPARATOR, 0, 0);
  1608.             AppendMenu(hMenu, MF_STRING, ID_NAVIGATION_GOTO, UTF8ToCurrentCP(_("&Goto")).c_str());
  1609.             AppendMenu(hMenu, MF_STRING, ID_NAVIGATION_FOLLOW, UTF8ToCurrentCP(_("&Follow")).c_str());
  1610.             AppendMenu(hMenu, MF_STRING, ID_NAVIGATION_SYNCORBIT, UTF8ToCurrentCP(_("S&ync Orbit")).c_str());
  1611.             AppendMenu(hMenu, MF_STRING, ID_INFO, UTF8ToCurrentCP(_("&Info")).c_str());
  1612.             HMENU refVectorMenu = CreatePopupMenu();
  1613.             AppendMenu(hMenu, MF_POPUP | MF_STRING, (DWORD) refVectorMenu, UTF8ToCurrentCP(_("&Reference Vectors")).c_str());
  1614.             AppendMenu(refVectorMenu, MF_STRING, ID_RENDER_BODY_AXES, UTF8ToCurrentCP(_("Show Body Axes")).c_str());
  1615.             AppendMenu(refVectorMenu, MF_STRING, ID_RENDER_FRAME_AXES, UTF8ToCurrentCP(_("Show Frame Axes")).c_str());
  1616.             AppendMenu(refVectorMenu, MF_STRING, ID_RENDER_SUN_DIRECTION, UTF8ToCurrentCP(_("Show Sun Direction")).c_str());
  1617.             AppendMenu(refVectorMenu, MF_STRING, ID_RENDER_VELOCITY_VECTOR, UTF8ToCurrentCP(_("Show Velocity Vector")).c_str());
  1618.             AppendMenu(refVectorMenu, MF_STRING, ID_RENDER_PLANETOGRAPHIC_GRID, UTF8ToCurrentCP(_("Show Planetographic Grid")).c_str());
  1619.             AppendMenu(refVectorMenu, MF_STRING, ID_RENDER_TERMINATOR, UTF8ToCurrentCP(_("Show Terminator")).c_str());
  1621.             CheckMenuItem(refVectorMenu, ID_RENDER_BODY_AXES,   sel.body()->findReferenceMark("body axes") ? MF_CHECKED : MF_UNCHECKED);
  1622.             CheckMenuItem(refVectorMenu, ID_RENDER_FRAME_AXES,  sel.body()->findReferenceMark("frame axes") ? MF_CHECKED : MF_UNCHECKED);
  1623.             CheckMenuItem(refVectorMenu, ID_RENDER_SUN_DIRECTION,  sel.body()->findReferenceMark("sun direction") ? MF_CHECKED : MF_UNCHECKED);
  1624.             CheckMenuItem(refVectorMenu, ID_RENDER_VELOCITY_VECTOR,  sel.body()->findReferenceMark("velocity vector") ? MF_CHECKED : MF_UNCHECKED);
  1625.             CheckMenuItem(refVectorMenu, ID_RENDER_PLANETOGRAPHIC_GRID, sel.body()->findReferenceMark("planetographic grid") ? MF_CHECKED : MF_UNCHECKED);
  1626.             CheckMenuItem(refVectorMenu, ID_RENDER_TERMINATOR, sel.body()->findReferenceMark("terminator") ? MF_CHECKED : MF_UNCHECKED);
  1628.             const PlanetarySystem* satellites = sel.body()->getSatellites();
  1629.             if (satellites != NULL && satellites->getSystemSize() != 0)
  1630.             {
  1631.                 HMENU satMenu = CreatePlanetarySystemMenu(name, satellites);
  1632.                 AppendMenu(hMenu, MF_POPUP | MF_STRING, (DWORD) satMenu,
  1633.                            UTF8ToCurrentCP(_("&Satellites")).c_str());
  1634.             }
  1636.             vector<string>* altSurfaces = sel.body()->getAlternateSurfaceNames();
  1637.             if (altSurfaces != NULL)
  1638.             {
  1639.                 if (altSurfaces->size() != NULL)
  1640.                 {
  1641.                     HMENU surfMenu = CreateAlternateSurfaceMenu(*altSurfaces);
  1642.                     AppendMenu(hMenu, MF_POPUP | MF_STRING, (DWORD) surfMenu,
  1643.                                UTF8ToCurrentCP(_("&Alternate Surfaces")).c_str());
  1644.                 }
  1645.                 delete altSurfaces;
  1646.             }
  1647.         }
  1648.         break;
  1650.     case Selection::Type_Star:
  1651.         {
  1652.             Simulation* sim = appCore->getSimulation();
  1653.             name = sim->getUniverse()->getStarCatalog()->getStarName(*(sel.star()));
  1654.             AppendMenu(hMenu, MF_STRING, ID_NAVIGATION_CENTER, UTF8ToCurrentCP(name).c_str());
  1655.             AppendMenu(hMenu, MF_SEPARATOR, 0, 0);
  1656.             AppendMenu(hMenu, MF_STRING, ID_NAVIGATION_GOTO, UTF8ToCurrentCP(_("&Goto")).c_str());
  1657.             AppendMenu(hMenu, MF_STRING, ID_INFO, UTF8ToCurrentCP(_("&Info")).c_str());
  1659.             SolarSystemCatalog* solarSystemCatalog = sim->getUniverse()->getSolarSystemCatalog();
  1660.             SolarSystemCatalog::iterator iter = solarSystemCatalog->find(sel.star()->getCatalogNumber());
  1661.             if (iter != solarSystemCatalog->end())
  1662.             {
  1663.                 SolarSystem* solarSys = iter->second;
  1664.                 HMENU planetsMenu = CreatePlanetarySystemMenu(name, solarSys->getPlanets());
  1665.                 if (name == "Sol")
  1666.                     AppendMenu(hMenu, MF_POPUP | MF_STRING, (DWORD) planetsMenu, UTF8ToCurrentCP(_("Orbiting Bodies")).c_str());
  1667.                 else
  1668.                     AppendMenu(hMenu, MF_POPUP | MF_STRING, (DWORD) planetsMenu, UTF8ToCurrentCP(_("Planets")).c_str());
  1669.             }
  1670.         }
  1671.         break;
  1673.     case Selection::Type_DeepSky:
  1674.         {
  1675.             Simulation* sim = appCore->getSimulation();
  1676.             name = sim->getUniverse()->getDSOCatalog()->getDSOName(sel.deepsky());
  1677.             AppendMenu(hMenu, MF_STRING, ID_NAVIGATION_CENTER, UTF8ToCurrentCP(name).c_str());
  1678.             AppendMenu(hMenu, MF_SEPARATOR, 0, 0);
  1679.             AppendMenu(hMenu, MF_STRING, ID_NAVIGATION_GOTO, UTF8ToCurrentCP(_("&Goto")).c_str());
  1680.             AppendMenu(hMenu, MF_STRING, ID_NAVIGATION_FOLLOW, UTF8ToCurrentCP(_("&Follow")).c_str());
  1681.             AppendMenu(hMenu, MF_STRING, ID_INFO, UTF8ToCurrentCP(_("&Info")).c_str());
  1682.         }
  1683.         break;
  1685.     case Selection::Type_Location:
  1686.         break;
  1688.     default:
  1689.         break;
  1690.     }
  1692.     if (appCore->getSimulation()->getUniverse()->isMarked(sel, 1))
  1693.         AppendMenu(hMenu, MF_STRING, ID_TOOLS_UNMARK, UTF8ToCurrentCP(_("&Unmark")).c_str());
  1694.     else
  1695.         AppendMenu(hMenu, MF_STRING, ID_TOOLS_MARK, UTF8ToCurrentCP(_("&Mark")).c_str());
  1697.     POINT point;
  1698.     point.x = (int) x;
  1699.     point.y = (int) y;
  1702.     if (currentScreenMode == 0)
  1703.         ClientToScreen(hwnd, (LPPOINT) &point);
  1705.     appCore->getSimulation()->setSelection(sel);
  1706.     TrackPopupMenu(hMenu, 0, point.x, point.y, 0, hwnd, NULL);
  1708.     // TODO: Do we need to explicitly destroy submenus or does DestroyMenu
  1709.     // work recursively?
  1710.     // According to the MSDN documentation, DestroyMenu() IS recursive. Clint 11/01.
  1711.     DestroyMenu(hMenu);
  1713. #ifdef INFINITE_MOUSE
  1714.     ignoreNextMoveEvent = true;
  1715. #endif // INFINITE_MOUSE
  1716. }
  1719. // TODO: get rid of fixed urls
  1720. void ShowWWWInfo(const Selection& sel)
  1721. {
  1722.     string url;
  1723.     switch (sel.getType())
  1724.     {
  1725.     case Selection::Type_Body:
  1726.         {
  1727.             url = sel.body()->getInfoURL();
  1728.             if (url.empty())
  1729.             {
  1730.                 string name = sel.body()->getName();
  1731.                 for (unsigned int i = 0; i < name.size(); i++)
  1732.                     name[i] = tolower(name[i]);
  1734.                 url = string("http://www.nineplanets.org/") + name + ".html";
  1735.             }
  1736.         }
  1737.         break;
  1739.     case Selection::Type_Star:
  1740.         {
  1741.             url = sel.star()->getInfoURL();
  1742.             if (url.empty())
  1743.             {
  1744.                 char name[32];
  1745.                 sprintf(name, "HIP%d", sel.star()->getCatalogNumber() & ~0xf0000000);
  1746.                 url = string("http://simbad.u-strasbg.fr/sim-id.pl?protocol=html&Ident=") + name;
  1747.             }
  1748.         }
  1749.         break;
  1751.     case Selection::Type_DeepSky:
  1752.         url = sel.deepsky()->getInfoURL();
  1753.         break;
  1755.     case Selection::Type_Location:
  1756.         break;
  1758.     default:
  1759.         break;
  1760.     }
  1762.     ShellExecute(mainWindow,
  1763.                  "open",
  1764.                  url.c_str(),
  1765.                  NULL,
  1766.                  NULL,
  1767.                  0);
  1768. }
  1771. void ContextMenu(float x, float y, Selection sel)
  1772. {
  1773.     handlePopupMenu(mainWindow, x, y, sel);
  1774. }
  1777. bool EnableFullScreen(const DEVMODE& dm)
  1778. {
  1779.     DEVMODE devMode;
  1781.     ZeroMemory(&devMode, sizeof devMode);
  1782.     devMode.dmSize = sizeof devMode;
  1783.     devMode.dmPelsWidth  = dm.dmPelsWidth;
  1784.     devMode.dmPelsHeight = dm.dmPelsHeight;
  1785.     devMode.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT;
  1787.     if (ChangeDisplaySettings(&devMode, CDS_FULLSCREEN) !=
  1788.         DISP_CHANGE_SUCCESSFUL)
  1789.     {
  1790. MessageBox(NULL,
  1791.                    "Unable to switch to full screen mode; running in window mode",
  1792.                    "Error",
  1793.                    MB_OK | MB_ICONERROR);
  1794.         return false;
  1795.     }
  1797.     return true;
  1798. }
  1801. void DisableFullScreen()
  1802. {
  1803.     ChangeDisplaySettings(0, 0);
  1804. }
  1807. unsigned int
  1808. ChooseBestMSAAPixelFormat(HDC hdc, int *formats, unsigned int numFormats,
  1809.                           int samplesRequested)
  1810. {
  1811.     int idealFormat = 0;
  1812.     int bestFormat  = 0;
  1813.     int bestSamples = 0;
  1815.     for (unsigned int i = 0; i < numFormats; i++)
  1816.     {
  1817.         int query = WGL_SAMPLES_ARB;
  1818.      int result = 0;
  1819.         bool isFloatFormat = false;
  1821.         query = WGL_SAMPLES_ARB;
  1822.         wglGetPixelFormatAttribivARB(hdc, formats[i], 0, 1, &query, &result);
  1824.         if (result <= samplesRequested && result >= bestSamples)
  1825.         {
  1826.             bestSamples = result;
  1827.             bestFormat = formats[i];
  1828.         }
  1830.         if (result == samplesRequested)
  1831.             idealFormat = formats[i];
  1832.     }
  1834.     if (idealFormat != 0)
  1835.         return idealFormat;
  1837.     return bestFormat;
  1838. }
  1841. // Select the pixel format for a given device context
  1842. bool SetDCPixelFormat(HDC hDC)
  1843. {
  1844.     bool msaa = false;
  1845.     if (appCore->getConfig()->aaSamples > 1 &&
  1846.         WGLExtensionSupported("WGL_ARB_pixel_format") &&
  1847.         WGLExtensionSupported("WGL_ARB_multisample"))
  1848.     {
  1849.         msaa = true;
  1850.     }
  1851.         
  1852.     if (!msaa)
  1853.     {
  1854.         static PIXELFORMATDESCRIPTOR pfd = {
  1855.             sizeof(PIXELFORMATDESCRIPTOR), // Size of this structure
  1856.             1, // Version of this structure
  1857.             PFD_DRAW_TO_WINDOW | // Draw to Window (not to bitmap)
  1858.             PFD_SUPPORT_OPENGL | // Support OpenGL calls in window
  1859.             PFD_DOUBLEBUFFER, // Double buffered mode
  1860.             PFD_TYPE_RGBA, // RGBA Color mode
  1861.             GetDeviceCaps(hDC, BITSPIXEL),// Want the display bit depth
  1862.             0,0,0,0,0,0,   // Not used to select mode
  1863.             0,0, // Not used to select mode
  1864.             0,0,0,0,0, // Not used to select mode
  1865.             24, // Size of depth buffer
  1866.             0, // Not used to select mode
  1867.             0, // Not used to select mode
  1868.             PFD_MAIN_PLANE,             // Draw in main plane
  1869.             0,                          // Not used to select mode
  1870.             0,0,0                       // Not used to select mode
  1871.         };
  1873.         // Choose a pixel format that best matches that described in pfd
  1874.         int nPixelFormat = ChoosePixelFormat(hDC, &pfd);
  1875.         if (nPixelFormat == 0)
  1876.         {
  1877.             // Uh oh . . . looks like we can't handle OpenGL on this device.
  1878.             return false;
  1879.         }
  1880.         else
  1881.         {
  1882.             // Set the pixel format for the device context
  1883.             SetPixelFormat(hDC, nPixelFormat, &pfd);
  1884.             return true;
  1885.         }
  1886.     }
  1887.     else
  1888.     {
  1889.         PIXELFORMATDESCRIPTOR pfd;
  1891.         int ifmtList[] = {
  1892.             WGL_DRAW_TO_WINDOW_ARB,        TRUE,
  1893.             WGL_SUPPORT_OPENGL_ARB,        TRUE,
  1894.             WGL_DOUBLE_BUFFER_ARB,         TRUE,
  1895.             WGL_PIXEL_TYPE_ARB,            WGL_TYPE_RGBA_ARB,
  1896.             WGL_DEPTH_BITS_ARB,            24,
  1897.             WGL_COLOR_BITS_ARB,            24,
  1898.             WGL_RED_BITS_ARB,               8,
  1899.             WGL_GREEN_BITS_ARB,             8,
  1900.             WGL_BLUE_BITS_ARB,              8,
  1901.             WGL_ALPHA_BITS_ARB,             0,
  1902.             WGL_ACCUM_BITS_ARB,             0,
  1903.             WGL_STENCIL_BITS_ARB,           0,
  1904.             WGL_SAMPLE_BUFFERS_ARB,         appCore->getConfig()->aaSamples > 1,
  1905.             0
  1906.         };
  1908.         int             pixelFormatIndex;
  1909.         int             pixFormats[256];
  1910.         unsigned int    numFormats;
  1912.         wglChoosePixelFormatARB(hDC, ifmtList, NULL, 256, pixFormats, &numFormats);
  1914.         pixelFormatIndex = ChooseBestMSAAPixelFormat(hDC, pixFormats,
  1915.                                                      numFormats,
  1916.                                                      appCore->getConfig()->aaSamples);
  1918.         DescribePixelFormat(hDC, pixelFormatIndex,
  1919.                             sizeof(PIXELFORMATDESCRIPTOR), &pfd);
  1920.         if (!SetPixelFormat(hDC, pixelFormatIndex, &pfd))
  1921.             return false;
  1923.         return true;
  1924.     }
  1925. }
  1928. HWND CreateOpenGLWindow(int x, int y, int width, int height,
  1929.                         int mode, int& newMode)
  1930. {
  1931.     assert(mode >= 0 && mode <= displayModes->size());
  1932.     if (mode != 0)
  1933.     {
  1934.         x = 0;
  1935.         y = 0;
  1936.         width = displayModes->at(mode - 1).dmPelsWidth;
  1937.         height = displayModes->at(mode - 1).dmPelsHeight;
  1938.     }
  1940.     // Set up and register the window class
  1941.     WNDCLASS wc;
  1942.     wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
  1943.     wc.lpfnWndProc = (WNDPROC) MainWindowProc;
  1944.     wc.cbClsExtra = 0;
  1945.     wc.cbWndExtra = 0;
  1946.     wc.hInstance = appInstance;
  1947.     wc.hIcon = LoadIcon(hRes, MAKEINTRESOURCE(IDI_CELESTIA_ICON));
  1948.     wc.hCursor = hDefaultCursor;
  1949.     wc.hbrBackground = NULL;
  1950.     wc.lpszMenuName = NULL;
  1951.     wc.lpszClassName = AppName;
  1952.     if (RegisterClass(&wc) == 0)
  1953.     {
  1954.         MessageBox(NULL,
  1955.                    "Failed to register the window class.", "Fatal Error",
  1956.                    MB_OK | MB_ICONERROR);
  1957.     return NULL;
  1958.     }
  1960.     newMode = currentScreenMode;
  1961.     if (mode != 0)
  1962.     {
  1963.         if (EnableFullScreen(displayModes->at(mode - 1)))
  1964.             newMode = mode;
  1965.     }
  1966.     else
  1967.     {
  1968.         DisableFullScreen();
  1969.         newMode = 0;
  1970.     }
  1972.     // Determine the proper window style to use
  1973.     DWORD dwStyle;
  1974.     if (newMode != 0)
  1975.     {
  1976.         dwStyle = WS_POPUP;
  1977.     }
  1978.     else
  1979.     {
  1980.         dwStyle = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
  1981.     }
  1983.     // Create the window
  1984.     HWND hwnd = CreateWindow(AppName,
  1985.                              AppName,
  1986.                              dwStyle,
  1987.                              x, y,
  1988.                              width, height,
  1989.                              NULL,
  1990.                              NULL,
  1991.                              appInstance,
  1992.                              NULL);
  1994.     if (hwnd == NULL)
  1995.         return NULL;
  1997.     ShowWindow(hwnd, SW_SHOW);
  1998.     SetForegroundWindow(hwnd);
  1999.     SetFocus(hwnd);
  2001.     deviceContext = GetDC(hwnd);
  2002.     if (!SetDCPixelFormat(deviceContext))
  2003.     {
  2004.         MessageBox(NULL,
  2005.                    "Could not get appropriate pixel format for OpenGL rendering.", "Fatal Error",
  2006.                    MB_OK | MB_ICONERROR);
  2007.     return NULL;
  2008.     }
  2010.     if (glContext == NULL)
  2011.         glContext = wglCreateContext(deviceContext);
  2012.     wglMakeCurrent(deviceContext, glContext);
  2014.     if (newMode == 0)
  2015.         SetMenu(hwnd, menuBar);
  2016.     else
  2017.         hideMenuBar = true;
  2019.     return hwnd;
  2020. }
  2023. void DestroyOpenGLWindow()
  2024. {
  2025. #if 0
  2026.     if (glContext != NULL)
  2027.     {
  2028.         wglMakeCurrent(NULL, NULL);
  2029.         if (!wglDeleteContext(glContext))
  2030.         {
  2031.             MessageBox(NULL,
  2032.                        "Releasing GL context failed.", "Error",
  2033.                        MB_OK | MB_ICONERROR);
  2034.         }
  2035.         glContext = NULL;
  2036.     }
  2037. #endif
  2039.     if (deviceContext != NULL)
  2040.     {
  2041.         if (!ReleaseDC(mainWindow, deviceContext))
  2042.         {
  2043.             MessageBox(NULL,
  2044.                        "Releasing device context failed.", "Error",
  2045.                        MB_OK | MB_ICONERROR);
  2046.         }
  2047.         deviceContext = NULL;
  2048.     }
  2050.     if (mainWindow != NULL)
  2051.     {
  2052.         SetMenu(mainWindow, NULL);
  2053.         DestroyWindow(mainWindow);
  2054.         mainWindow = NULL;
  2055.     }
  2057.     UnregisterClass(AppName, appInstance);
  2058. }
  2061. void handleKey(WPARAM key, bool down)
  2062. {
  2063.     int k = -1;
  2064.     int modifiers = 0;
  2066.     if (GetKeyState(VK_SHIFT) & 0x8000)
  2067.         modifiers |= CelestiaCore::ShiftKey;
  2068.     if (GetKeyState(VK_CONTROL) & 0x8000)
  2069.         modifiers |= CelestiaCore::ControlKey;
  2071.     switch (key)
  2072.     {
  2073.     case VK_UP:
  2074.         k = CelestiaCore::Key_Up;
  2075.         break;
  2076.     case VK_DOWN:
  2077.         k = CelestiaCore::Key_Down;
  2078.         break;
  2079.     case VK_LEFT:
  2080.         k = CelestiaCore::Key_Left;
  2081.         break;
  2082.     case VK_RIGHT:
  2083.         k = CelestiaCore::Key_Right;
  2084.         break;
  2085.     case VK_HOME:
  2086.         k = CelestiaCore::Key_Home;
  2087.         break;
  2088.     case VK_END:
  2089.         k = CelestiaCore::Key_End;
  2090.         break;
  2091.     case VK_PRIOR:
  2092.         k = CelestiaCore::Key_PageUp;
  2093.         break;
  2094.     case VK_NEXT:
  2095.         k = CelestiaCore::Key_PageDown;
  2096.         break;
  2097.     case VK_F1:
  2098.         k = CelestiaCore::Key_F1;
  2099.         break;
  2100.     case VK_F2:
  2101.         k = CelestiaCore::Key_F2;
  2102.         break;
  2103.     case VK_F3:
  2104.         k = CelestiaCore::Key_F3;
  2105.         break;
  2106.     case VK_F4:
  2107.         k = CelestiaCore::Key_F4;
  2108.         break;
  2109.     case VK_F5:
  2110.         k = CelestiaCore::Key_F5;
  2111.         break;
  2112.     case VK_F6:
  2113.         k = CelestiaCore::Key_F6;
  2114.         break;
  2115.     case VK_F7:
  2116.         k = CelestiaCore::Key_F7;
  2117.         break;
  2118.     case VK_F8:
  2119.         if (joystickAvailable && down)
  2120.         {
  2121.             appCore->joystickAxis(CelestiaCore::Joy_XAxis, 0);
  2122.             appCore->joystickAxis(CelestiaCore::Joy_YAxis, 0);
  2123.             appCore->joystickAxis(CelestiaCore::Joy_ZAxis, 0);
  2124.             useJoystick = !useJoystick;
  2125.         }
  2126.         break;
  2127.     case VK_F11:
  2128.         k = CelestiaCore::Key_F11;
  2129.         break;
  2130.     case VK_F12:
  2131.         k = CelestiaCore::Key_F12;
  2132.         break;
  2134.     case VK_NUMPAD2:
  2135.         k = CelestiaCore::Key_NumPad2;
  2136.         break;
  2137.     case VK_NUMPAD4:
  2138.         k = CelestiaCore::Key_NumPad4;
  2139.         break;
  2140.     case VK_NUMPAD5:
  2141.         k = CelestiaCore::Key_NumPad5;
  2142.         break;
  2143.     case VK_NUMPAD6:
  2144.         k = CelestiaCore::Key_NumPad6;
  2145.         break;
  2146.     case VK_NUMPAD7:
  2147.         k = CelestiaCore::Key_NumPad7;
  2148.         break;
  2149.     case VK_NUMPAD8:
  2150.         k = CelestiaCore::Key_NumPad8;
  2151.         break;
  2152.     case VK_NUMPAD9:
  2153.         k = CelestiaCore::Key_NumPad9;
  2154.         break;
  2155.     case VK_DELETE:
  2156.         if (!down)
  2157.             appCore->charEntered('177');
  2158.         break;
  2160.     case '0':
  2161.     case '1':
  2162.     case '2':
  2163.     case '3':
  2164.     case '4':
  2165.     case '5':
  2166.     case '6':
  2167.     case '7':
  2168.     case '8':
  2169.     case '9':
  2170.         // Special handling required to send Ctrl+number keys to
  2171.         // Celestia keyboard handler.
  2172.         if (!down && (modifiers & CelestiaCore::ControlKey))
  2173.             appCore->charEntered((char) key, modifiers);
  2174.         break;
  2176.     case 'A':
  2177.     case 'Z':
  2178.         if ((GetKeyState(VK_CONTROL) & 0x8000) == 0)
  2179.             k = key;
  2180.         break;
  2181.     }
  2183.     if (k >= 0)
  2184.     {
  2185.         if (down)
  2186.             appCore->keyDown(k, modifiers);
  2187.         else
  2188.             appCore->keyUp(k, modifiers);
  2189.     }
  2190. }
  2193. static void BuildScriptsMenu(HMENU menuBar, const string& scriptsDir)
  2194. {
  2195.     HMENU fileMenu = GetSubMenu(menuBar, 0);
  2197.     if (ScriptMenuItems != NULL)
  2198.         delete ScriptMenuItems;
  2200.     ScriptMenuItems = ScanScriptsDirectory(scriptsDir, false);
  2201.     if (ScriptMenuItems == NULL || ScriptMenuItems->size() == 0)
  2202.     {
  2203.         EnableMenuItem(fileMenu, ID_FILE_SCRIPTS, MF_GRAYED);
  2204.         return;
  2205.     }