VideoConfigDiag::VideoConfigDiag(wxWindow* parent, const std::string& title)
: wxDialog(parent, wxID_ANY, wxString::Format(_("Dolphin %s Graphics Configuration"),
wxGetTranslation(StrToWxStr(title)))),
vconfig(g_Config)
{
vconfig.Load(File::GetUserPath(D_CONFIG_IDX) + "GFX.ini");
Bind(wxEVT_UPDATE_UI, &VideoConfigDiag::OnUpdateUI, this);
wxNotebook* const notebook = new wxNotebook(this, wxID_ANY);
// -- GENERAL --
{
wxPanel* const page_general = new wxPanel(notebook);
notebook->AddPage(page_general, _("General"));
wxBoxSizer* const szr_general = new wxBoxSizer(wxVERTICAL);
// - basic
{
wxFlexGridSizer* const szr_basic = new wxFlexGridSizer(2, 5, 5);
// backend
{
label_backend = new wxStaticText(page_general, wxID_ANY, _("Backend:"));
choice_backend = new wxChoice(page_general, wxID_ANY);
RegisterControl(choice_backend, wxGetTranslation(backend_desc));
for (const auto& backend : g_available_video_backends)
{
choice_backend->AppendString(wxGetTranslation(StrToWxStr(backend->GetDisplayName())));
}
choice_backend->SetStringSelection(
wxGetTranslation(StrToWxStr(g_video_backend->GetDisplayName())));
choice_backend->Bind(wxEVT_CHOICE, &VideoConfigDiag::Event_Backend, this);
szr_basic->Add(label_backend, 1, wxALIGN_CENTER_VERTICAL, 5);
szr_basic->Add(choice_backend, 1, 0, 0);
}
// adapter (D3D only)
if (vconfig.backend_info.Adapters.size())
{
choice_adapter =
CreateChoice(page_general, vconfig.iAdapter, wxGetTranslation(adapter_desc));
for (const std::string& adapter : vconfig.backend_info.Adapters)
{
choice_adapter->AppendString(StrToWxStr(adapter));
}
choice_adapter->Select(vconfig.iAdapter);
label_adapter = new wxStaticText(page_general, wxID_ANY, _("Adapter:"));
szr_basic->Add(label_adapter, 1, wxALIGN_CENTER_VERTICAL, 5);
szr_basic->Add(choice_adapter, 1, 0, 0);
}
// - display
wxFlexGridSizer* const szr_display = new wxFlexGridSizer(2, 5, 5);
{
#if !defined(__APPLE__)
// display resolution
{
wxArrayString res_list = GetListOfResolutions();
if (res_list.empty())
res_list.Add(_("<No resolutions found>"));
label_display_resolution =
new wxStaticText(page_general, wxID_ANY, _("Fullscreen Resolution:"));
choice_display_resolution =
new wxChoice(page_general, wxID_ANY, wxDefaultPosition, wxDefaultSize, res_list);
RegisterControl(choice_display_resolution, wxGetTranslation(display_res_desc));
choice_display_resolution->Bind(wxEVT_CHOICE, &VideoConfigDiag::Event_DisplayResolution,
this);
choice_display_resolution->SetStringSelection(
StrToWxStr(SConfig::GetInstance().strFullscreenResolution));
szr_display->Add(label_display_resolution, 1, wxALIGN_CENTER_VERTICAL, 0);
szr_display->Add(choice_display_resolution);
}
#endif
// aspect-ratio
{
const wxString ar_choices[] = {_("Auto"), _("Force 16:9"), _("Force 4:3"),
_("Stretch to Window")};
szr_display->Add(new wxStaticText(page_general, wxID_ANY, _("Aspect Ratio:")), 1,
wxALIGN_CENTER_VERTICAL, 0);
wxChoice* const choice_aspect =
CreateChoice(page_general, vconfig.iAspectRatio, wxGetTranslation(ar_desc),
sizeof(ar_choices) / sizeof(*ar_choices), ar_choices);
szr_display->Add(choice_aspect, 1, 0, 0);
}
// various other display options
{
szr_display->Add(CreateCheckBox(page_general, _("V-Sync"), wxGetTranslation(vsync_desc),
vconfig.bVSync));
szr_display->Add(CreateCheckBox(page_general, _("Use Fullscreen"),
wxGetTranslation(use_fullscreen_desc),
SConfig::GetInstance().bFullscreen));
}
}
// - other
wxFlexGridSizer* const szr_other = new wxFlexGridSizer(2, 5, 5);
{
szr_other->Add(CreateCheckBox(page_general, _("Show FPS"), wxGetTranslation(show_fps_desc),
vconfig.bShowFPS));
szr_other->Add(CreateCheckBox(page_general, _("Show NetPlay Ping"),
wxGetTranslation(show_netplay_ping_desc),
vconfig.bShowNetPlayPing));
szr_other->Add(CreateCheckBox(page_general, _("Log Render Time to File"),
wxGetTranslation(log_render_time_to_file_desc),
vconfig.bLogRenderTimeToFile));
szr_other->Add(CreateCheckBox(page_general, _("Auto adjust Window Size"),
wxGetTranslation(auto_window_size_desc),
SConfig::GetInstance().bRenderWindowAutoSize));
szr_other->Add(CreateCheckBox(page_general, _("Show NetPlay Messages"),
wxGetTranslation(show_netplay_messages_desc),
vconfig.bShowNetPlayMessages));
szr_other->Add(CreateCheckBox(page_general, _("Keep Window on Top"),
wxGetTranslation(keep_window_on_top_desc),
SConfig::GetInstance().bKeepWindowOnTop));
szr_other->Add(CreateCheckBox(page_general, _("Hide Mouse Cursor"),
wxGetTranslation(hide_mouse_cursor_desc),
SConfig::GetInstance().bHideCursor));
szr_other->Add(render_to_main_checkbox =
CreateCheckBox(page_general, _("Render to Main Window"),
wxGetTranslation(render_to_main_win_desc),
SConfig::GetInstance().bRenderToMain));
}
wxStaticBoxSizer* const group_basic =
new wxStaticBoxSizer(wxVERTICAL, page_general, _("Basic"));
group_basic->Add(szr_basic, 1, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, 5);
szr_general->Add(group_basic, 0, wxEXPAND | wxALL, 5);
wxStaticBoxSizer* const group_display =
new wxStaticBoxSizer(wxVERTICAL, page_general, _("Display"));
group_display->Add(szr_display, 1, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, 5);
szr_general->Add(group_display, 0, wxEXPAND | wxALL, 5);
wxStaticBoxSizer* const group_other =
new wxStaticBoxSizer(wxVERTICAL, page_general, _("Other"));
group_other->Add(szr_other, 1, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, 5);
szr_general->Add(group_other, 0, wxEXPAND | wxALL, 5);
}
szr_general->AddStretchSpacer();
CreateDescriptionArea(page_general, szr_general);
page_general->SetSizerAndFit(szr_general);
}
// -- ENHANCEMENTS --
{
wxPanel* const page_enh = new wxPanel(notebook);
notebook->AddPage(page_enh, _("Enhancements"));
wxBoxSizer* const szr_enh_main = new wxBoxSizer(wxVERTICAL);
// - enhancements
wxFlexGridSizer* const szr_enh = new wxFlexGridSizer(2, 5, 5);
// Internal resolution
{
const wxString efbscale_choices[] = {_("Auto (Window Size)"),
_("Auto (Multiple of 640x528)"),
_("Native (640x528)"),
_("1.5x Native (960x792)"),
_("2x Native (1280x1056) for 720p"),
_("2.5x Native (1600x1320)"),
_("3x Native (1920x1584) for 1080p"),
_("4x Native (2560x2112) for 1440p"),
_("5x Native (3200x2640)"),
_("6x Native (3840x3168) for 4K"),
_("7x Native (4480x3696)"),
_("8x Native (5120x4224) for 5K"),
_("Custom")};
wxChoice* const choice_efbscale = CreateChoice(
page_enh, vconfig.iEFBScale, wxGetTranslation(internal_res_desc),
(vconfig.iEFBScale > 11) ? ArraySize(efbscale_choices) : ArraySize(efbscale_choices) - 1,
efbscale_choices);
if (vconfig.iEFBScale > 11)
choice_efbscale->SetSelection(12);
szr_enh->Add(new wxStaticText(page_enh, wxID_ANY, _("Internal Resolution:")), 1,
wxALIGN_CENTER_VERTICAL, 0);
szr_enh->Add(choice_efbscale);
}
// AA
{
text_aamode = new wxStaticText(page_enh, wxID_ANY, _("Anti-Aliasing:"));
choice_aamode = new wxChoice(page_enh, wxID_ANY);
RegisterControl(choice_aamode, wxGetTranslation(aa_desc));
PopulateAAList();
choice_aamode->Bind(wxEVT_CHOICE, &VideoConfigDiag::OnAAChanged, this);
szr_enh->Add(text_aamode, 1, wxALIGN_CENTER_VERTICAL, 0);
szr_enh->Add(choice_aamode);
}
// AF
{
const wxString af_choices[] = {"1x", "2x", "4x", "8x", "16x"};
szr_enh->Add(new wxStaticText(page_enh, wxID_ANY, _("Anisotropic Filtering:")), 1,
wxALIGN_CENTER_VERTICAL, 0);
szr_enh->Add(
CreateChoice(page_enh, vconfig.iMaxAnisotropy, wxGetTranslation(af_desc), 5, af_choices));
}
// postproc shader
if (vconfig.backend_info.bSupportsPostProcessing)
{
wxFlexGridSizer* const szr_pp = new wxFlexGridSizer(3, 5, 5);
choice_ppshader = new wxChoice(page_enh, wxID_ANY);
RegisterControl(choice_ppshader, wxGetTranslation(ppshader_desc));
button_config_pp = new wxButton(page_enh, wxID_ANY, _("Config"));
PopulatePostProcessingShaders();
choice_ppshader->Bind(wxEVT_CHOICE, &VideoConfigDiag::Event_PPShader, this);
button_config_pp->Bind(wxEVT_BUTTON, &VideoConfigDiag::Event_ConfigurePPShader, this);
szr_enh->Add(new wxStaticText(page_enh, wxID_ANY, _("Post-Processing Effect:")), 1,
wxALIGN_CENTER_VERTICAL, 0);
szr_pp->Add(choice_ppshader);
szr_pp->Add(button_config_pp);
szr_enh->Add(szr_pp);
}
else
{
choice_ppshader = nullptr;
button_config_pp = nullptr;
}
// Scaled copy, PL, Bilinear filter
szr_enh->Add(CreateCheckBox(page_enh, _("Scaled EFB Copy"),
wxGetTranslation(scaled_efb_copy_desc), vconfig.bCopyEFBScaled));
szr_enh->Add(CreateCheckBox(page_enh, _("Per-Pixel Lighting"),
wxGetTranslation(pixel_lighting_desc),
vconfig.bEnablePixelLighting));
szr_enh->Add(CreateCheckBox(page_enh, _("Force Texture Filtering"),
wxGetTranslation(force_filtering_desc), vconfig.bForceFiltering));
szr_enh->Add(CreateCheckBox(page_enh, _("Widescreen Hack"), wxGetTranslation(ws_hack_desc),
vconfig.bWidescreenHack));
szr_enh->Add(CreateCheckBox(page_enh, _("Disable Fog"), wxGetTranslation(disable_fog_desc),
vconfig.bDisableFog));
wxStaticBoxSizer* const group_enh =
new wxStaticBoxSizer(wxVERTICAL, page_enh, _("Enhancements"));
group_enh->Add(szr_enh, 1, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, 5);
szr_enh_main->Add(group_enh, 0, wxEXPAND | wxALL, 5);
// - stereoscopy
if (vconfig.backend_info.bSupportsGeometryShaders)
{
wxFlexGridSizer* const szr_stereo = new wxFlexGridSizer(2, 5, 5);
szr_stereo->Add(new wxStaticText(page_enh, wxID_ANY, _("Stereoscopic 3D Mode:")), 1,
wxALIGN_CENTER_VERTICAL, 0);
const wxString stereo_choices[] = {_("Off"), _("Side-by-Side"), _("Top-and-Bottom"),
_("Anaglyph"), _("Nvidia 3D Vision")};
wxChoice* stereo_choice =
CreateChoice(page_enh, vconfig.iStereoMode, wxGetTranslation(stereo_3d_desc),
vconfig.backend_info.bSupports3DVision ? ArraySize(stereo_choices) :
ArraySize(stereo_choices) - 1,
stereo_choices);
stereo_choice->Bind(wxEVT_CHOICE, &VideoConfigDiag::Event_StereoMode, this);
szr_stereo->Add(stereo_choice);
wxSlider* const sep_slider = new wxSlider(page_enh, wxID_ANY, vconfig.iStereoDepth, 0, 100,
wxDefaultPosition, wxDefaultSize);
sep_slider->Bind(wxEVT_SLIDER, &VideoConfigDiag::Event_StereoDepth, this);
RegisterControl(sep_slider, wxGetTranslation(stereo_depth_desc));
szr_stereo->Add(new wxStaticText(page_enh, wxID_ANY, _("Depth:")), 1, wxALIGN_CENTER_VERTICAL,
0);
szr_stereo->Add(sep_slider, 0, wxEXPAND | wxRIGHT);
conv_slider = new wxSlider(page_enh, wxID_ANY, vconfig.iStereoConvergencePercentage, 0, 200,
wxDefaultPosition, wxDefaultSize, wxSL_AUTOTICKS);
conv_slider->ClearTicks();
conv_slider->SetTick(100);
conv_slider->Bind(wxEVT_SLIDER, &VideoConfigDiag::Event_StereoConvergence, this);
RegisterControl(conv_slider, wxGetTranslation(stereo_convergence_desc));
szr_stereo->Add(new wxStaticText(page_enh, wxID_ANY, _("Convergence:")), 1,
wxALIGN_CENTER_VERTICAL, 0);
szr_stereo->Add(conv_slider, 0, wxEXPAND | wxRIGHT);
szr_stereo->Add(CreateCheckBox(page_enh, _("Swap Eyes"), wxGetTranslation(stereo_swap_desc),
vconfig.bStereoSwapEyes));
wxStaticBoxSizer* const group_stereo =
new wxStaticBoxSizer(wxVERTICAL, page_enh, _("Stereoscopy"));
group_stereo->Add(szr_stereo, 1, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, 5);
szr_enh_main->Add(group_stereo, 0, wxEXPAND | wxALL, 5);
}
szr_enh_main->AddStretchSpacer();
CreateDescriptionArea(page_enh, szr_enh_main);
page_enh->SetSizerAndFit(szr_enh_main);
}
// -- SPEED HACKS --
{
wxPanel* const page_hacks = new wxPanel(notebook);
notebook->AddPage(page_hacks, _("Hacks"));
wxBoxSizer* const szr_hacks = new wxBoxSizer(wxVERTICAL);
// - EFB hacks
wxStaticBoxSizer* const szr_efb =
new wxStaticBoxSizer(wxVERTICAL, page_hacks, _("Embedded Frame Buffer (EFB)"));
szr_efb->Add(CreateCheckBox(page_hacks, _("Skip EFB Access from CPU"),
wxGetTranslation(efb_access_desc), vconfig.bEFBAccessEnable, true),
0, wxBOTTOM | wxLEFT, 5);
szr_efb->Add(CreateCheckBox(page_hacks, _("Ignore Format Changes"),
wxGetTranslation(efb_emulate_format_changes_desc),
vconfig.bEFBEmulateFormatChanges, true),
0, wxBOTTOM | wxLEFT, 5);
szr_efb->Add(CreateCheckBox(page_hacks, _("Store EFB Copies to Texture Only"),
wxGetTranslation(skip_efb_copy_to_ram_desc),
vconfig.bSkipEFBCopyToRam),
0, wxBOTTOM | wxLEFT, 5);
szr_hacks->Add(szr_efb, 0, wxEXPAND | wxALL, 5);
// Texture cache
{
wxStaticBoxSizer* const szr_safetex =
new wxStaticBoxSizer(wxHORIZONTAL, page_hacks, _("Texture Cache"));
// TODO: Use wxSL_MIN_MAX_LABELS or wxSL_VALUE_LABEL with wx 2.9.1
wxSlider* const stc_slider = new wxSlider(page_hacks, wxID_ANY, 0, 0, 2, wxDefaultPosition,
wxDefaultSize, wxSL_HORIZONTAL | wxSL_BOTTOM);
stc_slider->Bind(wxEVT_SLIDER, &VideoConfigDiag::Event_Stc, this);
RegisterControl(stc_slider, wxGetTranslation(stc_desc));
if (vconfig.iSafeTextureCache_ColorSamples == 0)
stc_slider->SetValue(0);
else if (vconfig.iSafeTextureCache_ColorSamples == 512)
stc_slider->SetValue(1);
else if (vconfig.iSafeTextureCache_ColorSamples == 128)
stc_slider->SetValue(2);
else
stc_slider->Disable(); // Using custom number of samples; TODO: Inform the user why this is
// disabled..
szr_safetex->Add(new wxStaticText(page_hacks, wxID_ANY, _("Accuracy:")), 0, wxALL, 5);
szr_safetex->AddStretchSpacer(1);
szr_safetex->Add(new wxStaticText(page_hacks, wxID_ANY, _("Safe")), 0,
wxLEFT | wxTOP | wxBOTTOM, 5);
szr_safetex->Add(stc_slider, 2, wxRIGHT, 0);
szr_safetex->Add(new wxStaticText(page_hacks, wxID_ANY, _("Fast")), 0,
wxRIGHT | wxTOP | wxBOTTOM, 5);
szr_hacks->Add(szr_safetex, 0, wxEXPAND | wxALL, 5);
}
// - XFB
{
wxStaticBoxSizer* const group_xfb =
new wxStaticBoxSizer(wxHORIZONTAL, page_hacks, _("External Frame Buffer (XFB)"));
SettingCheckBox* disable_xfb = CreateCheckBox(
page_hacks, _("Disable"), wxGetTranslation(xfb_desc), vconfig.bUseXFB, true);
virtual_xfb = CreateRadioButton(page_hacks, _("Virtual"), wxGetTranslation(xfb_virtual_desc),
vconfig.bUseRealXFB, true, wxRB_GROUP);
real_xfb = CreateRadioButton(page_hacks, _("Real"), wxGetTranslation(xfb_real_desc),
vconfig.bUseRealXFB);
group_xfb->Add(disable_xfb, 0, wxLEFT | wxRIGHT | wxBOTTOM, 5);
group_xfb->AddStretchSpacer(1);
group_xfb->Add(virtual_xfb, 0, wxRIGHT, 5);
group_xfb->Add(real_xfb, 0, wxRIGHT, 5);
szr_hacks->Add(group_xfb, 0, wxEXPAND | wxALL, 5);
} // xfb
// - other hacks
{
wxGridSizer* const szr_other = new wxGridSizer(2, 5, 5);
szr_other->Add(CreateCheckBox(page_hacks, _("Fast Depth Calculation"),
wxGetTranslation(fast_depth_calc_desc),
vconfig.bFastDepthCalc));
szr_other->Add(CreateCheckBox(page_hacks, _("Disable Bounding Box"),
wxGetTranslation(disable_bbox_desc), vconfig.bBBoxEnable,
true));
wxStaticBoxSizer* const group_other =
new wxStaticBoxSizer(wxVERTICAL, page_hacks, _("Other"));
group_other->Add(szr_other, 1, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, 5);
szr_hacks->Add(group_other, 0, wxEXPAND | wxALL, 5);
}
szr_hacks->AddStretchSpacer();
CreateDescriptionArea(page_hacks, szr_hacks);
page_hacks->SetSizerAndFit(szr_hacks);
}
// -- ADVANCED --
{
wxPanel* const page_advanced = new wxPanel(notebook);
notebook->AddPage(page_advanced, _("Advanced"));
wxBoxSizer* const szr_advanced = new wxBoxSizer(wxVERTICAL);
// - debug
{
wxGridSizer* const szr_debug = new wxGridSizer(2, 5, 5);
szr_debug->Add(CreateCheckBox(page_advanced, _("Enable Wireframe"),
wxGetTranslation(wireframe_desc), vconfig.bWireFrame));
szr_debug->Add(CreateCheckBox(page_advanced, _("Show Statistics"),
wxGetTranslation(show_stats_desc), vconfig.bOverlayStats));
szr_debug->Add(CreateCheckBox(page_advanced, _("Texture Format Overlay"),
wxGetTranslation(texfmt_desc), vconfig.bTexFmtOverlayEnable));
wxStaticBoxSizer* const group_debug =
new wxStaticBoxSizer(wxVERTICAL, page_advanced, _("Debugging"));
szr_advanced->Add(group_debug, 0, wxEXPAND | wxALL, 5);
group_debug->Add(szr_debug, 1, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, 5);
}
// - utility
{
wxGridSizer* const szr_utility = new wxGridSizer(2, 5, 5);
szr_utility->Add(CreateCheckBox(page_advanced, _("Dump Textures"),
wxGetTranslation(dump_textures_desc), vconfig.bDumpTextures));
szr_utility->Add(CreateCheckBox(page_advanced, _("Load Custom Textures"),
wxGetTranslation(load_hires_textures_desc),
vconfig.bHiresTextures));
cache_hires_textures =
CreateCheckBox(page_advanced, _("Prefetch Custom Textures"),
wxGetTranslation(cache_hires_textures_desc), vconfig.bCacheHiresTextures);
szr_utility->Add(cache_hires_textures);
szr_utility->Add(CreateCheckBox(page_advanced, _("Dump EFB Target"),
wxGetTranslation(dump_efb_desc), vconfig.bDumpEFBTarget));
szr_utility->Add(CreateCheckBox(page_advanced, _("Free Look"),
wxGetTranslation(free_look_desc), vconfig.bFreeLook));
#if defined(HAVE_LIBAV) || defined(_WIN32)
szr_utility->Add(CreateCheckBox(page_advanced, _("Frame Dumps use FFV1"),
wxGetTranslation(use_ffv1_desc), vconfig.bUseFFV1));
#endif
wxStaticBoxSizer* const group_utility =
new wxStaticBoxSizer(wxVERTICAL, page_advanced, _("Utility"));
szr_advanced->Add(group_utility, 0, wxEXPAND | wxALL, 5);
group_utility->Add(szr_utility, 1, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, 5);
}
// - misc
{
wxGridSizer* const szr_misc = new wxGridSizer(2, 5, 5);
szr_misc->Add(
CreateCheckBox(page_advanced, _("Crop"), wxGetTranslation(crop_desc), vconfig.bCrop));
// Progressive Scan
{
progressive_scan_checkbox =
new wxCheckBox(page_advanced, wxID_ANY, _("Enable Progressive Scan"));
RegisterControl(progressive_scan_checkbox, wxGetTranslation(prog_scan_desc));
progressive_scan_checkbox->Bind(wxEVT_CHECKBOX, &VideoConfigDiag::Event_ProgressiveScan,
this);
progressive_scan_checkbox->SetValue(SConfig::GetInstance().bProgressive);
// A bit strange behavior, but this needs to stay in sync with the main progressive boolean;
// TODO: Is this still necessary?
SConfig::GetInstance().m_SYSCONF->SetData("IPL.PGS", SConfig::GetInstance().bProgressive);
szr_misc->Add(progressive_scan_checkbox);
}
#if defined WIN32
// Borderless Fullscreen
borderless_fullscreen = CreateCheckBox(page_advanced, _("Borderless Fullscreen"),
wxGetTranslation(borderless_fullscreen_desc),
vconfig.bBorderlessFullscreen);
szr_misc->Add(borderless_fullscreen);
#endif
wxStaticBoxSizer* const group_misc =
new wxStaticBoxSizer(wxVERTICAL, page_advanced, _("Misc"));
szr_advanced->Add(group_misc, 0, wxEXPAND | wxALL, 5);
group_misc->Add(szr_misc, 1, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, 5);
}
szr_advanced->AddStretchSpacer();
CreateDescriptionArea(page_advanced, szr_advanced);
page_advanced->SetSizerAndFit(szr_advanced);
}
wxButton* const btn_close = new wxButton(this, wxID_OK, _("Close"));
btn_close->Bind(wxEVT_BUTTON, &VideoConfigDiag::Event_ClickClose, this);
Bind(wxEVT_CLOSE_WINDOW, &VideoConfigDiag::Event_Close, this);
wxBoxSizer* const szr_main = new wxBoxSizer(wxVERTICAL);
szr_main->Add(notebook, 1, wxEXPAND | wxALL, 5);
szr_main->Add(btn_close, 0, wxALIGN_RIGHT | wxRIGHT | wxBOTTOM, 5);
SetSizerAndFit(szr_main);
Center();
SetFocus();
UpdateWindowUI();
}
WINEXPORT BOOL CALLBACK GrepListProc95( HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam )
{
static char **fileList;
static int fileCount;
HWND list_box;
char tmp[MAX_STR];
WORD cmd;
LVCOLUMN lvc;
LVITEM lvi;
RECT rc;
switch( msg ) {
case WM_INITDIALOG:
list_box = GetDlgItem( dlg, ID_FILE_LIST );
SendMessage( list_box, WM_SETFONT, (WPARAM)FontHandle( dirw_info.text.font ), 0L );
MySprintf( tmp, "Files Containing \"%s\"", sString );
SetWindowText( dlg, tmp );
rc.left = 0;
rc.right = 70;
MapDialogRect( dlg, &rc );
lvc.mask = LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
lvc.cx = rc.right;
lvc.pszText = "File Name";
lvc.iSubItem = 0;
SendMessage( list_box, LVM_INSERTCOLUMN, 0, (LPARAM)&lvc );
lvc.cx = rc.right * 3;
lvc.pszText = "Line";
lvc.iSubItem = 1;
SendMessage( list_box, LVM_INSERTCOLUMN, 1, (LPARAM)&lvc );
fileList = (char **)MemAlloc( sizeof( char * ) * MAX_FILES );
fileCount = initList( list_box, (char *)lparam, fileList );
if( fileCount == 0 ) {
Message1( "String \"%s\" not found", sString );
EndDialog( dlg, DO_NOT_CLEAR_MESSAGE_WINDOW );
} else {
lvi.stateMask = LVIS_SELECTED;
lvi.state = LVIS_SELECTED;
SendMessage( list_box, LVM_SETITEMSTATE, 0, (LPARAM)&lvi );
BringWindowToTop( dlg );
SetFocus( dlg );
}
break;
case WM_COMMAND:
cmd = LOWORD( wparam );
switch( cmd ) {
case ID_EDIT:
case ID_GOTO:
getOneFile( dlg, fileList, &fileCount, cmd == ID_GOTO );
break;
case ID_GETALL:
getAllFiles( dlg, fileList, &fileCount );
break;
case IDCANCEL:
EndDialog( dlg, ERR_NO_ERR );
return( TRUE );
}
break;
case WM_NOTIFY:
if( ((NMHDR *)lparam)->code == NM_DBLCLK ) {
getOneFile( dlg, fileList, &fileCount, TRUE );
}
break;
case WM_DESTROY:
MemFreeList( fileCount, fileList );
break;
}
return( FALSE );
} /* GrepListProc95 */
BOOL WINPROC EXPORT DlgRoomPuzzle (HWND hWnd,UINT wMsg,WPARAM wParam,LPARAM lParam)
{
BOOL bHandled = TRUE;
switch (wMsg)
{
case WM_COMMAND:
switch (wParam)
{
case HS_COVER:
// There is no cover in this room, but this keeps
// DefRoomProc from disabling ShowMe.
break;
case HS_BACKPUZZLE:
case IDCANCEL:
GoRoom (hInstAstral, RM_PUZZLESTART, FALSE);
break;
case HS_PUZZLE_NEWGAME:
ShowAllObjects(hWnd, TRUE);
LoadBackgroundImage(hWnd);
PrepareGuesses(hWnd);
break;
case HS_SHOWME:
case HS_SHOWMEPUZZLE:
bFinished = TRUE;
SetDlgItemText(hWnd, IDC_PUZZLE_NAME, szGuess);
ShowAllObjects(hWnd, FALSE);
break;
default:
bHandled = FALSE;
} // switch (wParam)
break;
case WM_KEYDOWN:
ProcessKey(hWnd, wParam);
break;
case WM_INITDIALOG:
hPuzzleWnd = hWnd;
SetPuzzleFonts(hWnd);
LoadPuzzleImage(hWnd);
LoadBackgroundImage(hWnd);
PrepareGuesses(hWnd);
SetFocus(hWnd);
bHandled = FALSE; // allow DefRoomProc to be called.
break;
case WM_DESTROY:
if (hItalicFont)
DeleteObject(hItalicFont);
if (hNormalFont)
DeleteObject(hNormalFont);
bHandled = FALSE; // allow DefRoomProc to be called
hPuzzleWnd = 0;
break;
default:
bHandled = FALSE;
} // switch (wMsg)
if (!bHandled)
bHandled = DefRoomProc (hWnd,wMsg,wParam,lParam);
// ----------This crap hangs the app-----------
// if (wMsg != WM_KILLFOCUS &&
// wMsg != WM_CLOSE &&
// wMsg != WM_SYSKEYDOWN &&
// wMsg != WM_SYSKEYUP &&
// wMsg != WM_SYSCHAR &&
// wMsg != WM_DESTROY &&
// wMsg != WM_NCDESTROY)
// SetFocus(hWnd);
return bHandled;
}
void SystemClass::InitializeWindows(int& screenWidth, int& screenHeight)
{
WNDCLASSEX wc;
DEVMODE dmScreenSettings;
int posX, posY;
// Get an external pointer to this object.
ApplicationHandle = this;
// Get the instance of this application.
m_hinstance = GetModuleHandle(NULL);
// Give the application a name.
m_applicationName = L"Engine";
// Setup the windows class with default settings.
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = m_hinstance;
wc.hIcon = LoadIcon(0, IDI_WINLOGO);
wc.hIconSm = wc.hIcon;
wc.hCursor = LoadCursor(0, IDC_ARROW);
wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
wc.lpszMenuName = 0;
wc.lpszClassName = m_applicationName;
wc.cbSize = sizeof(WNDCLASSEX);
// Register the window class.
RegisterClassEx(&wc);
// Determine the resolution of the clients desktop screen.
screenWidth = GetSystemMetrics(SM_CXSCREEN);
screenHeight = GetSystemMetrics(SM_CYSCREEN);
// Setup the screen settings depending on whether it is running in full screen or in windowed mode.
if(FULL_SCREEN)
{
// If full screen set the screen to maximum size of the users desktop and 32bit.
memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));
dmScreenSettings.dmSize = sizeof(dmScreenSettings);
dmScreenSettings.dmPelsWidth = (unsigned long)screenWidth;
dmScreenSettings.dmPelsHeight = (unsigned long)screenHeight;
dmScreenSettings.dmBitsPerPel = 32;
dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
// Change the display settings to full screen.
ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN);
// Set the position of the window to the top left corner.
posX = posY = 0;
}
else
{
// If windowed then set it to 800x600 resolution.
//screenWidth = 1680;
//screenHeight = 1050;
// Place the window in the middle of the screen.
posX = (GetSystemMetrics(SM_CXSCREEN) - screenWidth) / 2;
posY = (GetSystemMetrics(SM_CYSCREEN) - screenHeight) / 2;
}
HMENU hmenu;
hmenu = LoadMenu(m_hinstance, MAKEINTRESOURCE(IDR_MENU1));
// Create the window with the screen settings and get the handle to it.
m_hwnd = CreateWindowEx(
WS_EX_APPWINDOW, // Extended Window Style - Forces top-level window on the taskbar when it's visible
m_applicationName, // lpClassName
m_applicationName, // lpWindowName
WS_OVERLAPPEDWINDOW, // dwStyle - Overlapped Window
posX, posY, // Position
screenWidth, screenHeight, // Height and width
NULL, // Window Parent
hmenu, // Handle to a menu
m_hinstance, // hInstance - handle to the module associated with the window
NULL); // lpParam - handle to the value passed to the window through CREATESTRUCT
// Bring the window up on the screen and set it as main focus.
ShowWindow(m_hwnd, SW_MAXIMIZE);
SetForegroundWindow(m_hwnd);
SetFocus(m_hwnd);
// Hide the mouse cursor.
ShowCursor(true);
return;
}// InitializeWindows
void CXTPPropertyGridInplaceList::Create(CXTPPropertyGridItem* pItem, CRect rect)
{
ASSERT(pItem && pItem->GetGrid());
if (!pItem)
return;
CRect rcValue(rect);
rcValue.left = pItem->GetGrid()->GetDividerPos() + 1;
CWnd* pParent = (CWnd*)pItem->GetGrid();
m_pItem = pItem;
DestroyWindow();
if (!m_hWnd)
{
CListBox::CreateEx(WS_EX_TOOLWINDOW | (pParent->GetExStyle() & WS_EX_LAYOUTRTL), _T("LISTBOX"), _T(""),
LBS_NOTIFY | WS_CHILD | WS_VSCROLL | WS_BORDER | LBS_OWNERDRAWFIXED | LBS_HASSTRINGS, CRect(0, 0, 0, 0), pParent, 0);
SetOwner(pParent);
if (m_bShowShadow && XTPSystemVersion()->IsWinXPOrGreater())
SetClassLongPtr(m_hWnd, GCL_STYLE, GetClassLongPtr(m_hWnd, GCL_STYLE) | 0x00020000);
}
SetFont(pParent->GetFont());
ResetContent();
CXTPPropertyGridItemConstraints* pList = pItem->GetConstraints();
int dx = rect.right - rcValue.left;
CWindowDC dc(pParent);
CXTPFontDC font(&dc, pParent->GetFont());
int nHeight = dc.GetTextExtent(_T(" "), 1).cy + 3;
for (int i = 0; i < pList->GetCount(); i++)
{
CXTPPropertyGridItemConstraint* pConstraint = pList->GetConstraintAt(i);
CString str = pConstraint->m_strConstraint;
int nIndex = AddString(str);
SetItemDataPtr(nIndex, pConstraint);
CSize sz = pItem->OnMergeItemConstraint(&dc, pConstraint);
dx = max(dx, sz.cx);
nHeight = max(nHeight, sz.cy);
if (pItem->GetValue() == str)
SetCurSel(nIndex);
}
SetItemHeight(0, nHeight);
rect.top = rect.bottom;
rect.bottom += nHeight * __min(pItem->GetDropDownItemCount(), GetCount()) + 2;
rect.left = rect.right - __min(dx, rect.Width() - XTP_PGI_EXPAND_BORDER);
pParent->ClientToScreen(&rect);
CRect rcWork = XTPMultiMonitor()->GetWorkArea(rect);
if (rect.bottom > rcWork.bottom && rect.top > rcWork.CenterPoint().y)
{
rect.OffsetRect(0, - rect.Height() - rcValue.Height() - 1);
}
if (rect.left < rcWork.left) rect.OffsetRect(rcWork.left - rect.left, 0);
if (rect.right > rcWork.right) rect.OffsetRect(rcWork.right - rect.right, 0);
SetFocus();
SetWindowLongPtr(m_hWnd, GWLP_HWNDPARENT, 0);
ModifyStyle(WS_CHILD, WS_POPUP);
SetWindowLongPtr(m_hWnd, GWLP_HWNDPARENT, (LONG_PTR)pParent->m_hWnd);
SetWindowPos(&CWnd::wndTopMost, rect.left, rect.top, rect.Width(), rect.Height(), SWP_SHOWWINDOW | SWP_NOACTIVATE | SWP_NOOWNERZORDER);
CXTPMouseMonitor::SetupHook(this);
}
BOOL CALLBACK SessDlgProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam ) {
// This is a static method, so we don't know which instantiation we're
// dealing with. But we can get a pseudo-this from the parameter to
// WM_INITDIALOG, which we therafter store with the window and retrieve
// as follows:
/*SessionDialog*_this = helper::SafeGetWindowUserData<SessionDialog>(hwnd);
if (_this!=NULL && notset)
{
selected=_this->m_pOpt->m_selected_screen;
notset=false;
}*/
SessionDialog* _this;
if(uMsg == WM_INITDIALOG){
_this = (SessionDialog*)lParam;
helper::SafeSetWindowUserData(hwnd, lParam);
}
else
_this= (SessionDialog*)helper::SafeGetWindowUserData<SessionDialog>(hwnd);
if (_this!=NULL && notset)
{
selected=_this->m_pOpt->m_selected_screen;
notset=false;
}
switch (uMsg) {
case WM_INITDIALOG:
{
helper::SafeSetWindowUserData(hwnd, lParam);
SessionDialog *l_this = (SessionDialog *) lParam;
//CentreWindow(hwnd);
SetForegroundWindow(hwnd);
l_this->m_pCC->m_hSessionDialog = hwnd;
//List monitors
tempdisplayclass tdc;
tdc.Init();
HWND hcomboscreen = GetDlgItem( hwnd, IDC_SCREEN);
for (int i = 0; i < tdc.nr_monitors+1; i++) {
int pos = SendMessage(hcomboscreen, CB_ADDSTRING, 0, (LPARAM) tdc.monarray[i].buttontext);
}
SendMessage(hcomboscreen, CB_SETCURSEL, selected, 0);
// Set up recently-used list
HWND hcombo = GetDlgItem( hwnd, IDC_HOSTNAME_EDIT);
TCHAR valname[256];
for (int i = 0; i < l_this->m_pMRU->NumItems(); i++) {
l_this->m_pMRU->GetItem(i, valname, 255);
int pos = SendMessage(hcombo, CB_ADDSTRING, 0, (LPARAM) valname);
}
SendMessage(hcombo, CB_SETCURSEL, 0, 0);
// sf@2002 - List available DSM Plugins
HWND hPlugins = GetDlgItem(hwnd, IDC_PLUGINS_COMBO);
int nPlugins = l_this->m_pDSMPlugin->ListPlugins(hPlugins);
if (!nPlugins)
{
SendMessage(hPlugins, CB_ADDSTRING, 0, (LPARAM) sz_F11);
}
else
{
// Use the first detected plugin, so the user doesn't have to check the option
// HWND hUsePlugin = GetDlgItem(hwnd, IDC_PLUGIN_CHECK);
// SendMessage(hUsePlugin, BM_SETCHECK, TRUE, 0);
}
SendMessage(hPlugins, CB_SETCURSEL, 0, 0);
HWND hButton = GetDlgItem(hwnd, IDC_PLUGIN_BUTTON);
EnableWindow(hButton, FALSE); // sf@2009 - Disable plugin config button by default
//AaronP
if( strcmp( l_this->m_pOpt->m_szDSMPluginFilename, "" ) != 0 && l_this->m_pOpt->m_fUseDSMPlugin )
{
int pos = SendMessage(hPlugins, CB_FINDSTRINGEXACT, -1,
(LPARAM)&(l_this->m_pOpt->m_szDSMPluginFilename[0]));
if( pos != CB_ERR )
{
SendMessage(hPlugins, CB_SETCURSEL, pos, 0);
HWND hUsePlugin = GetDlgItem(hwnd, IDC_PLUGIN_CHECK);
SendMessage(hUsePlugin, BM_SETCHECK, TRUE, 0);
EnableWindow(hButton, TRUE); // sf@2009 - Enable plugin config button
}
}
//EndAaronP
TCHAR tmphost[256];
TCHAR tmphost2[256];
_tcscpy(tmphost, l_this->m_pOpt->m_proxyhost);
if (strcmp(tmphost,"")!=NULL)
{
_tcscat(tmphost,":");
_tcscat(tmphost,_itoa(l_this->m_pOpt->m_proxyport,tmphost2,10));
SetDlgItemText(hwnd, IDC_PROXY_EDIT, tmphost);
}
HWND hViewOnly = GetDlgItem(hwnd, IDC_VIEWONLY_CHECK);
SendMessage(hViewOnly, BM_SETCHECK, l_this->m_pOpt->m_ViewOnly, 0);
HWND hAutoScaling = GetDlgItem(hwnd, IDC_AUTOSCALING_CHECK);
SendMessage(hAutoScaling, BM_SETCHECK, l_this->m_pOpt->m_fAutoScaling, 0);
HWND hExitCheck = GetDlgItem(hwnd, IDC_EXIT_CHECK); //PGM @ Advantig
SendMessage(hExitCheck, BM_SETCHECK, l_this->m_pOpt->m_fExitCheck, 0); //PGM @ Advantig
HWND hProxy = GetDlgItem(hwnd, IDC_PROXY_CHECK);
SendMessage(hProxy, BM_SETCHECK, l_this->m_pOpt->m_fUseProxy, 0);
// sf@2005 - Make the save settings optional but always enabled by default (for now)
// (maybe disabled as default is better ?)
HWND hSave = GetDlgItem(hwnd, IDC_SETDEFAULT_CHECK);
//ACT SendMessage(hSave, BM_SETCHECK, true, 0);
// sf@2002 - Select Modem Option as default
l_this->SetQuickOption(l_this, hwnd);
l_this->m_fFromOptions = false;
l_this->m_fFromFile = false;
return TRUE;
}
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDC_DELETE:
{
char optionfile[MAX_PATH];
VNCOptions::GetDefaultOptionsFileName(optionfile);
DeleteFile(optionfile);
}
return TRUE;
case IDOK:
{
TCHAR tmphost[256];
TCHAR display[256];
TCHAR fulldisplay[256];
// sf@2005
HWND hSave = GetDlgItem(hwnd, IDC_SETDEFAULT_CHECK);
_this->m_pCC->saved_set = SendMessage(hSave, BM_GETCHECK, 0, 0) == BST_CHECKED;
_this->m_pOpt->m_selected_screen=SendMessage(GetDlgItem( hwnd, IDC_SCREEN),CB_GETCURSEL,0,0);
GetDlgItemText(hwnd, IDC_HOSTNAME_EDIT, display, 256);
_tcscpy(fulldisplay, display);
if (!ParseDisplay(display, tmphost, 255, &_this->m_port)) {
MessageBox(hwnd,
sz_F8,
sz_F10, MB_OK | MB_ICONEXCLAMATION | MB_SETFOREGROUND | MB_TOPMOST);
} else {
for (size_t i = 0, len = strlen(tmphost); i < len; i++)
{
tmphost[i] = toupper(tmphost[i]);
}
_tcscpy(_this->m_host_dialog, tmphost);
_this->m_pMRU->AddItem(fulldisplay);
// _tcscpy(_this->m_remotehost, fulldisplay);
EndDialog(hwnd, TRUE);
}
_tcscpy(_this->m_proxyhost, "");
GetDlgItemText(hwnd, IDC_PROXY_EDIT, display, 256);
_tcscpy(fulldisplay, display);
//adzm 2010-02-15
if (strlen(display) > 0) {
TCHAR actualProxy[256];
strcpy(actualProxy, display);
if (strncmp(tmphost, "ID", 2) == 0) {
int numericId = _this->m_port;
int numberOfHosts = 1;
for (int i = 0; i < (int)strlen(display); i++) {
if (display[i] == ';') {
numberOfHosts++;
}
}
if (numberOfHosts <= 1) {
// then hostname == actualhostname
} else {
int modulo = numericId % numberOfHosts;
char* szToken = strtok(display, ";");
while (szToken) {
if (modulo == 0) {
strcpy(actualProxy, szToken);
break;
}
modulo--;
szToken = strtok(NULL, ";");
}
}
}
if (!ParseDisplay(actualProxy, tmphost, 255, &_this->m_proxyport)) {
MessageBox(hwnd,
sz_F8,
sz_F10, MB_OK | MB_ICONEXCLAMATION | MB_SETFOREGROUND | MB_TOPMOST);
} else {
_tcscpy(_this->m_proxyhost, tmphost);
EndDialog(hwnd, TRUE);
}
}
HWND hProxy = GetDlgItem(hwnd, IDC_PROXY_CHECK);
if (SendMessage(hProxy, BM_GETCHECK, 0, 0) == BST_CHECKED)
{
_this->m_pOpt->m_fUseProxy = true;
_this->m_fUseProxy = true;
}
else
{
_this->m_pOpt->m_fUseProxy = false;
_this->m_fUseProxy = false;
}
// sf@2002 - DSMPlugin loading
// If Use plugin is checked, load the plugin if necessary
HWND hPlugin = GetDlgItem(hwnd, IDC_PLUGIN_CHECK);
if (SendMessage(hPlugin, BM_GETCHECK, 0, 0) == BST_CHECKED)
{
TCHAR szPlugin[MAX_PATH];
GetDlgItemText(hwnd, IDC_PLUGINS_COMBO, szPlugin, MAX_PATH);
_this->m_pOpt->m_fUseDSMPlugin = true;
strcpy(_this->m_pOpt->m_szDSMPluginFilename, szPlugin);
if (!_this->m_pDSMPlugin->IsLoaded())
{
_this->m_pDSMPlugin->LoadPlugin(szPlugin, _this->m_pOpt->m_listening);
if (_this->m_pDSMPlugin->IsLoaded())
{
if (_this->m_pDSMPlugin->InitPlugin())
{
if (!_this->m_pDSMPlugin->SupportsMultithreaded())
_this->m_pOpt->m_oldplugin=true; //PGM
else //PGM
_this->m_pOpt->m_oldplugin=false;
_this->m_pDSMPlugin->SetEnabled(true);
_this->m_pDSMPlugin->DescribePlugin();
}
else
{
_this->m_pDSMPlugin->SetEnabled(false);
MessageBox(hwnd,
sz_F7,
sz_F6, MB_OK | MB_ICONEXCLAMATION | MB_SETFOREGROUND | MB_TOPMOST);
return TRUE;
}
}
else
{
_this->m_pDSMPlugin->SetEnabled(false);
MessageBox(hwnd,
sz_F5,
sz_F6, MB_OK | MB_ICONEXCLAMATION | MB_SETFOREGROUND | MB_TOPMOST);
return TRUE;
}
}
else
{
// sf@2003 - If the plugin is already loaded here it has been loaded
// by clicking on the config button: we need to init it !
// But we must first check that the loaded plugin is the same that
// the one currently selected...
_this->m_pDSMPlugin->DescribePlugin();
if (_stricmp(_this->m_pDSMPlugin->GetPluginFileName(), szPlugin))
{
// Unload the previous plugin
_this->m_pDSMPlugin->UnloadPlugin();
// Load the new selected one
_this->m_pDSMPlugin->LoadPlugin(szPlugin, _this->m_pOpt->m_listening);
}
if (_this->m_pDSMPlugin->IsLoaded())
{
if (_this->m_pDSMPlugin->InitPlugin())
{
if (!_this->m_pDSMPlugin->SupportsMultithreaded())
_this->m_pOpt->m_oldplugin=true; //PGM
else //PGM
_this->m_pOpt->m_oldplugin=false;
_this->m_pDSMPlugin->SetEnabled(true);
_this->m_pDSMPlugin->DescribePlugin();
}
else
{
_this->m_pDSMPlugin->SetEnabled(false);
MessageBox(hwnd,
sz_F7,
sz_F6, MB_OK | MB_ICONEXCLAMATION | MB_SETFOREGROUND | MB_TOPMOST);
return TRUE;
}
}
else
{
_this->m_pDSMPlugin->SetEnabled(false);
MessageBox(hwnd,
sz_F5,
sz_F6, MB_OK | MB_ICONEXCLAMATION | MB_SETFOREGROUND | MB_TOPMOST);
return TRUE;
}
}
}
else // If Use plugin unchecked but the plugin is loaded, unload it
{
_this->m_pOpt->m_fUseDSMPlugin = false;
if (_this->m_pDSMPlugin->IsEnabled())
{
_this->m_pDSMPlugin->UnloadPlugin();
_this->m_pDSMPlugin->SetEnabled(false);
}
}
if (_this->m_fFromOptions || _this->m_fFromFile)
{
EndDialog(hwnd, TRUE);
return TRUE;
}
// sf@2002 - Quick options handling
_this->ManageQuickOptions(_this, hwnd);
HWND hViewOnly = GetDlgItem(hwnd, IDC_VIEWONLY_CHECK);
_this->m_pOpt->m_ViewOnly = (SendMessage(hViewOnly, BM_GETCHECK, 0, 0) == BST_CHECKED);
HWND hAutoScaling = GetDlgItem(hwnd, IDC_AUTOSCALING_CHECK);
_this->m_pOpt->m_fAutoScaling = (SendMessage(hAutoScaling, BM_GETCHECK, 0, 0) == BST_CHECKED);
HWND hExitCheck = GetDlgItem(hwnd, IDC_EXIT_CHECK); //PGM @ Advantig
_this->m_pOpt->m_fExitCheck = (SendMessage(hExitCheck, BM_GETCHECK, 0, 0) == BST_CHECKED); //PGM @ Advantig
EndDialog(hwnd, TRUE);
return TRUE;
}
case IDCANCEL:
EndDialog(hwnd, FALSE);
return TRUE;
case IDC_OPTIONBUTTON:
{
if (!_this->m_fFromFile)
{
_this->ManageQuickOptions(_this, hwnd);
HWND hViewOnly = GetDlgItem(hwnd, IDC_VIEWONLY_CHECK);
_this->m_pOpt->m_ViewOnly = (SendMessage(hViewOnly, BM_GETCHECK, 0, 0) == BST_CHECKED);
HWND hAutoScaling = GetDlgItem(hwnd, IDC_AUTOSCALING_CHECK);
_this->m_pOpt->m_fAutoScaling = (SendMessage(hAutoScaling, BM_GETCHECK, 0, 0) == BST_CHECKED);
HWND hExitCheck = GetDlgItem(hwnd, IDC_EXIT_CHECK); //PGM @ Advantig
_this->m_pOpt->m_fExitCheck = (SendMessage(hExitCheck, BM_GETCHECK, 0, 0) == BST_CHECKED); //PGM @ Advantig
}
if (_this->m_pOpt->DoDialog())
{
_this->m_fFromOptions = true;
HWND hDyn = GetDlgItem(hwnd, IDC_DYNAMIC);
SendMessage(hDyn, BM_SETCHECK, false, 0);
HWND hLan = GetDlgItem(hwnd, IDC_LAN_RB);
SendMessage(hLan, BM_SETCHECK, false, 0);
HWND hUltraLan = GetDlgItem(hwnd, IDC_ULTRA_LAN_RB);
SendMessage(hUltraLan, BM_SETCHECK, false, 0);
HWND hMedium = GetDlgItem(hwnd, IDC_MEDIUM_RB);
SendMessage(hMedium, BM_SETCHECK, false, 0);
HWND hModem = GetDlgItem(hwnd, IDC_MODEM_RB);
SendMessage(hModem, BM_SETCHECK, false, 0);
HWND hSlow = GetDlgItem(hwnd, IDC_SLOW_RB);
SendMessage(hSlow, BM_SETCHECK, false, 0);
HWND hManual = GetDlgItem(hwnd, IDC_MANUAL);
SendMessage(hManual, BM_SETCHECK, true, 0);
_this->m_pOpt->m_quickoption = 8;
}
return TRUE;
}
// sf@2002
case IDC_PLUGIN_CHECK:
{
HWND hUse = GetDlgItem(hwnd, IDC_PLUGIN_CHECK);
BOOL enable = SendMessage(hUse, BM_GETCHECK, 0, 0) == BST_CHECKED;
HWND hButton = GetDlgItem(hwnd, IDC_PLUGIN_BUTTON);
EnableWindow(hButton, enable);
}
return TRUE;
case IDC_PLUGIN_BUTTON:
{
HWND hPlugin = GetDlgItem(hwnd, IDC_PLUGIN_CHECK);
if (SendMessage(hPlugin, BM_GETCHECK, 0, 0) == BST_CHECKED)
{
TCHAR szPlugin[MAX_PATH];
GetDlgItemText(hwnd, IDC_PLUGINS_COMBO, szPlugin, MAX_PATH);
// sf@2003 - The config button can be clicked several times with
// different selected plugins...
bool fLoadIt = true;
char szParams[64];
strcpy(szParams, sz_F4);
// If a plugin is already loaded, check if it is the same that the one
// we want to load.
if (_this->m_pDSMPlugin->IsLoaded())
{
_this->m_pDSMPlugin->DescribePlugin();
if (!_stricmp(_this->m_pDSMPlugin->GetPluginFileName(), szPlugin))
{
fLoadIt = false;
_this->m_pDSMPlugin->SetPluginParams(hwnd, szParams);
}
else
{
// Unload the previous plugin
_this->m_pDSMPlugin->UnloadPlugin();
fLoadIt = true;
}
}
if (!fLoadIt) return TRUE;
if (_this->m_pDSMPlugin->LoadPlugin(szPlugin, _this->m_pOpt->m_listening))
{
// We don't know the password yet... no matter the plugin requires
// it or not, we will provide it later (at plugin "real" startup)
// Knowing the environnement ("viewer") right now can be usefull or
// even mandatory for the plugin (specific params saving and so on...)
// The plugin receives environnement info but isn't inited at this point
_this->m_pDSMPlugin->SetPluginParams(hwnd, szParams);
}
else
{
MessageBox(hwnd,
sz_F1,
sz_F3, MB_OK | MB_ICONEXCLAMATION | MB_SETFOREGROUND | MB_TOPMOST);
}
}
return TRUE;
}
case IDC_LOADPROFILE_B:
{
TCHAR szFileName[MAX_PATH];
memset(szFileName, '\0', MAX_PATH);
if (_this->m_pCC->LoadConnection(szFileName, true) != -1)
{
TCHAR szHost[250];
if (_this->m_pCC->m_port == 5900)
_tcscpy(szHost, _this->m_pCC->m_host);
else if (_this->m_pCC->m_port > 5900 && _this->m_pCC->m_port <= 5999)
_stprintf(szHost, TEXT("%s:%d"), _this->m_pCC->m_host, _this->m_pCC->m_port - 5900);
else
_stprintf(szHost, TEXT("%s::%d"), _this->m_pCC->m_host, _this->m_pCC->m_port);
SetDlgItemText(hwnd, IDC_HOSTNAME_EDIT, szHost);
//AaronP
HWND hPlugins = GetDlgItem(hwnd, IDC_PLUGINS_COMBO);
if( strcmp( _this->m_pOpt->m_szDSMPluginFilename, "" ) != 0 && _this->m_pOpt->m_fUseDSMPlugin ) {
int pos = SendMessage(hPlugins, CB_FINDSTRINGEXACT, -1,
(LPARAM)&(_this->m_pOpt->m_szDSMPluginFilename[0]));
if( pos != CB_ERR ) {
SendMessage(hPlugins, CB_SETCURSEL, pos, 0);
HWND hUsePlugin = GetDlgItem(hwnd, IDC_PLUGIN_CHECK);
SendMessage(hUsePlugin, BM_SETCHECK, TRUE, 0);
}
}
//EndAaronP
}
SetFocus(GetDlgItem(hwnd, IDC_HOSTNAME_EDIT));
_this->SetQuickOption(_this, hwnd);
HWND hViewOnly = GetDlgItem(hwnd, IDC_VIEWONLY_CHECK);
SendMessage(hViewOnly, BM_SETCHECK, _this->m_pOpt->m_ViewOnly, 0);
HWND hAutoScaling = GetDlgItem(hwnd, IDC_AUTOSCALING_CHECK);
SendMessage(hAutoScaling, BM_SETCHECK, _this->m_pOpt->m_fAutoScaling, 0);
HWND hExitCheck = GetDlgItem(hwnd, IDC_EXIT_CHECK); //PGM @ Advantig
SendMessage(hExitCheck, BM_SETCHECK, _this->m_pOpt->m_fExitCheck, 0); //PGM @ Advantig
_this->m_fFromOptions = true;
_this->m_fFromFile = true;
return TRUE;
}
// [v1.0.2-jp1 fix]
case IDC_HOSTNAME_DEL:
HWND hcombo = GetDlgItem( hwnd, IDC_HOSTNAME_EDIT);
int sel = SendMessage(hcombo, CB_GETCURSEL, 0, 0);
if(sel != CB_ERR){
SendMessage(hcombo, CB_DELETESTRING, sel, 0);
_this->m_pMRU->RemoveItem(sel);
}
return TRUE;
}
break;
case WM_CLOSE:
EndDialog(hwnd, FALSE);
return FALSE;
case WM_DESTROY:
EndDialog(hwnd, FALSE);
return TRUE;
}
return 0;
}
void EDA_DRAW_PANEL::OnMouseEvent( wxMouseEvent& event )
{
int localrealbutt = 0, localbutt = 0;
BASE_SCREEN* screen = GetScreen();
if( !screen )
return;
/* Adjust value to filter mouse displacement before consider the drag
* mouse is really a drag command, not just a movement while click
*/
#define MIN_DRAG_COUNT_FOR_START_BLOCK_COMMAND 5
if( event.Leaving() )
m_canStartBlock = -1;
if( !IsMouseCaptured() ) // No mouse capture in progress.
m_requestAutoPan = false;
if( GetParent()->IsActive() )
SetFocus();
else
return;
if( !event.IsButton() && !event.Moving() && !event.Dragging() )
return;
if( event.RightDown() )
{
OnRightClick( event );
return;
}
if( m_ignoreMouseEvents )
return;
if( event.LeftIsDown() )
localrealbutt |= GR_M_LEFT_DOWN;
if( event.MiddleIsDown() )
localrealbutt |= GR_M_MIDDLE_DOWN;
if( event.LeftDown() )
localbutt = GR_M_LEFT_DOWN;
if( event.ButtonDClick( 1 ) )
localbutt = GR_M_LEFT_DOWN | GR_M_DCLICK;
if( event.MiddleDown() )
localbutt = GR_M_MIDDLE_DOWN;
localrealbutt |= localbutt; // compensation default wxGTK
INSTALL_UNBUFFERED_DC( DC, this );
DC.SetBackground( *wxBLACK_BRUSH );
// Compute the cursor position in drawing (logical) units.
GetParent()->SetMousePosition( event.GetLogicalPosition( DC ) );
int kbstat = 0;
if( event.ShiftDown() )
kbstat |= GR_KB_SHIFT;
if( event.ControlDown() )
kbstat |= GR_KB_CTRL;
if( event.AltDown() )
kbstat |= GR_KB_ALT;
// Calling Double Click and Click functions :
if( localbutt == (int) ( GR_M_LEFT_DOWN | GR_M_DCLICK ) )
{
GetParent()->OnLeftDClick( &DC, GetParent()->RefPos( true ) );
// inhibit a response to the mouse left button release,
// because we have a double click, and we do not want a new
// OnLeftClick command at end of this Double Click
m_ignoreNextLeftButtonRelease = true;
}
else if( event.LeftUp() )
{
// A block command is in progress: a left up is the end of block
// or this is the end of a double click, already seen
// Note also m_ignoreNextLeftButtonRelease can be set by
// the call to OnLeftClick(), so do not change it after calling OnLeftClick
bool ignoreEvt = m_ignoreNextLeftButtonRelease;
m_ignoreNextLeftButtonRelease = false;
if( screen->m_BlockLocate.GetState() == STATE_NO_BLOCK && !ignoreEvt )
GetParent()->OnLeftClick( &DC, GetParent()->RefPos( true ) );
}
else if( !event.LeftIsDown() )
{
/* be sure there is a response to a left button release command
* even when a LeftUp event is not seen. This happens when a
* double click opens a dialog box, and the release mouse button
* is made when the dialog box is opened.
*/
m_ignoreNextLeftButtonRelease = false;
}
if( event.ButtonDown( wxMOUSE_BTN_MIDDLE ) && m_enableMiddleButtonPan )
{
if( m_panScrollbarLimits )
{
int ppux, ppuy;
GetScrollPixelsPerUnit( &ppux, &ppuy );
GetViewStart( &m_PanStartCenter.x, &m_PanStartCenter.y );
m_PanStartCenter.x *= ppux;
m_PanStartCenter.y *= ppuy;
}
else
m_PanStartCenter = GetParent()->GetScrollCenterPosition();
m_PanStartEventPosition = event.GetPosition();
INSTALL_UNBUFFERED_DC( dc, this );
CrossHairOff( &dc );
}
if( event.ButtonUp( wxMOUSE_BTN_MIDDLE ) && m_enableMiddleButtonPan )
{
INSTALL_UNBUFFERED_DC( dc, this );
CrossHairOn( &dc );
}
if( event.MiddleIsDown() && m_enableMiddleButtonPan )
{
wxPoint currentPosition = event.GetPosition();
if( m_panScrollbarLimits )
{
int x, y;
int tmpX, tmpY;
int ppux, ppuy;
int maxX, maxY;
int vsizeX, vsizeY;
int csizeX, csizeY;
GetViewStart( &tmpX, &tmpY );
GetScrollPixelsPerUnit( &ppux, &ppuy );
GetVirtualSize( &vsizeX, &vsizeY );
GetClientSize( &csizeX, &csizeY );
maxX = vsizeX - csizeX;
maxY = vsizeY - csizeY;
x = m_PanStartCenter.x + m_PanStartEventPosition.x - currentPosition.x;
y = m_PanStartCenter.y + m_PanStartEventPosition.y - currentPosition.y;
bool shouldMoveCursor = false;
if( x < 0 )
{
currentPosition.x += x;
x = 0;
shouldMoveCursor = true;
}
if( y < 0 )
{
currentPosition.y += y;
y = 0;
shouldMoveCursor = true;
}
if( x > maxX )
{
currentPosition.x += ( x - maxX );
x = maxX;
shouldMoveCursor = true;
}
if( y > maxY )
{
currentPosition.y += ( y - maxY );
y = maxY;
shouldMoveCursor = true;
}
if ( shouldMoveCursor )
WarpPointer( currentPosition.x, currentPosition.y );
Scroll( x/ppux, y/ppuy );
double scale = GetParent()->GetScreen()->GetScalingFactor();
wxPoint center = GetParent()->GetScrollCenterPosition();
center.x += KiROUND( (double) ( x - tmpX ) / scale ) / ppux;
center.y += KiROUND( (double) ( y - tmpY ) / scale ) / ppuy;
GetParent()->SetScrollCenterPosition( center );
Refresh();
Update();
}
else
{
double scale = GetParent()->GetScreen()->GetScalingFactor();
int x = m_PanStartCenter.x +
KiROUND( (double) ( m_PanStartEventPosition.x - currentPosition.x ) / scale );
int y = m_PanStartCenter.y +
KiROUND( (double) ( m_PanStartEventPosition.y - currentPosition.y ) / scale );
GetParent()->RedrawScreen( wxPoint( x, y ), false );
}
}
if( event.ButtonUp( wxMOUSE_BTN_MIDDLE ) && !m_enableMiddleButtonPan &&
(screen->m_BlockLocate.GetState() == STATE_NO_BLOCK) )
{
// The middle button has been released, with no block command:
// We use it for a zoom center at cursor position command
wxCommandEvent cmd( wxEVT_COMMAND_MENU_SELECTED, ID_POPUP_ZOOM_CENTER );
cmd.SetEventObject( this );
GetEventHandler()->ProcessEvent( cmd );
}
// Calling the general function on mouse changes (and pseudo key commands)
GetParent()->GeneralControl( &DC, event.GetLogicalPosition( DC ), 0 );
/*******************************/
/* Control of block commands : */
/*******************************/
// Command block can't start if mouse is dragging a new panel
static EDA_DRAW_PANEL* lastPanel;
if( lastPanel != this )
{
m_minDragEventCount = 0;
m_canStartBlock = -1;
}
/* A new command block can start after a release buttons
* and if the drag is enough
* This is to avoid a false start block when a dialog box is dismissed,
* or when changing panels in hierarchy navigation
* or when clicking while and moving mouse
*/
if( !event.LeftIsDown() && !event.MiddleIsDown() )
{
m_minDragEventCount = 0;
m_canStartBlock = 0;
/* Remember the last cursor position when a drag mouse starts
* this is the last position ** before ** clicking a button
* this is useful to start a block command from the point where the
* mouse was clicked first
* (a filter creates a delay for the real block command start, and
* we must remember this point)
*/
m_CursorStartPos = GetParent()->GetCrossHairPosition();
}
if( m_enableBlockCommands && !(localbutt & GR_M_DCLICK) )
{
if( !screen->IsBlockActive() )
{
screen->m_BlockLocate.SetOrigin( m_CursorStartPos );
}
if( event.LeftDown() || ( !m_enableMiddleButtonPan && event.MiddleDown() ) )
{
if( screen->m_BlockLocate.GetState() == STATE_BLOCK_MOVE )
{
m_requestAutoPan = false;
GetParent()->HandleBlockPlace( &DC );
m_ignoreNextLeftButtonRelease = true;
}
}
else if( ( m_canStartBlock >= 0 )
&& ( event.LeftIsDown() || ( !m_enableMiddleButtonPan && event.MiddleIsDown() ) )
&& !IsMouseCaptured() )
{
// Mouse is dragging: if no block in progress, start a block command.
if( screen->m_BlockLocate.GetState() == STATE_NO_BLOCK )
{
// Start a block command
int cmd_type = kbstat;
if( !m_enableMiddleButtonPan && event.MiddleIsDown() )
cmd_type |= MOUSE_MIDDLE;
// A block command is started if the drag is enough. A small
// drag is ignored (it is certainly a little mouse move when
// clicking) not really a drag mouse
if( m_minDragEventCount < MIN_DRAG_COUNT_FOR_START_BLOCK_COMMAND )
m_minDragEventCount++;
else
{
if( !GetParent()->HandleBlockBegin( &DC, cmd_type, m_CursorStartPos ) )
{
// should not occur: error
GetParent()->DisplayToolMsg(
wxT( "EDA_DRAW_PANEL::OnMouseEvent() Block Error" ) );
}
else
{
m_requestAutoPan = true;
SetCursor( wxCURSOR_SIZING );
}
}
}
}
if( event.ButtonUp( wxMOUSE_BTN_LEFT ) ||
( !m_enableMiddleButtonPan && event.ButtonUp( wxMOUSE_BTN_MIDDLE ) ) )
{
/* Release the mouse button: end of block.
* The command can finish (DELETE) or have a next command (MOVE,
* COPY). However the block command is canceled if the block
* size is small because a block command filtering is already
* made, this case happens, but only when the on grid cursor has
* not moved.
*/
#define BLOCK_MINSIZE_LIMIT 1
bool BlockIsSmall =
( std::abs( screen->m_BlockLocate.GetWidth() ) < BLOCK_MINSIZE_LIMIT )
&& ( std::abs( screen->m_BlockLocate.GetHeight() ) < BLOCK_MINSIZE_LIMIT );
if( (screen->m_BlockLocate.GetState() != STATE_NO_BLOCK) && BlockIsSmall )
{
if( m_endMouseCaptureCallback )
{
m_endMouseCaptureCallback( this, &DC );
m_requestAutoPan = false;
}
SetCursor( (wxStockCursor) m_currentCursor );
}
else if( screen->m_BlockLocate.GetState() == STATE_BLOCK_END )
{
m_requestAutoPan = false;
GetParent()->HandleBlockEnd( &DC );
SetCursor( (wxStockCursor) m_currentCursor );
if( screen->m_BlockLocate.GetState() == STATE_BLOCK_MOVE )
{
m_requestAutoPan = true;
SetCursor( wxCURSOR_HAND );
}
}
}
}
// End of block command on a double click
// To avoid an unwanted block move command if the mouse is moved while double clicking
if( localbutt == (int) ( GR_M_LEFT_DOWN | GR_M_DCLICK ) )
{
if( !screen->IsBlockActive() && IsMouseCaptured() )
{
m_endMouseCaptureCallback( this, &DC );
}
}
#if 0
wxString msg_debug;
msg_debug.Printf( " block state %d, cmd %d",
screen->m_BlockLocate.GetState(),
screen->m_BlockLocate.GetCommand() );
GetParent()->PrintMsg( msg_debug );
#endif
lastPanel = this;
}
wyInt32
EditorBase::OnContextMenuHelper(LPARAM lParam)
{
wyBool nmenuselect;
LONG lstyle=0;
HMENU hmenu, htrackmenu;
POINT pnt;
wyInt32 pos;
RECT rect;
MDIWindow* wnd = GetActiveWin();
VERIFY(hmenu = GetMenu(pGlobals->m_pcmainwin->m_hwndmain));
//lStyle = GetWindowLongPtr ( m_hwndparent, GWL_STYLE );
lstyle = GetWindowLongPtr(GetParent(m_hwndparent), GWL_STYLE);
if ((lstyle & WS_MAXIMIZE) && wyTheme::IsSysmenuEnabled(GetParent(m_hwndparent)))
VERIFY(htrackmenu = GetSubMenu(hmenu, 2));
else
VERIFY(htrackmenu = GetSubMenu(hmenu, 1));
//If we are pressing the context button,then lParam is -1.
if(lParam == -1)
{
//for getting the current cursor pos.
pos = SendMessage(m_hwnd, SCI_GETCURRENTPOS, 0, 0);
pnt.x = SendMessage(m_hwnd, SCI_POINTXFROMPOSITION, 0, pos) ;
pnt.y = SendMessage(m_hwnd, SCI_POINTYFROMPOSITION, 0, pos);
VERIFY(ClientToScreen(m_hwnd, &pnt));
}
else
{
pnt.x = GET_X_LPARAM(lParam);
pnt.y = GET_Y_LPARAM(lParam);
}
GetClientRect(m_hwnd, &rect);
MapWindowPoints(m_hwnd, NULL, (LPPOINT)&rect, 2);
if(!PtInRect(&rect, pnt))
{
return -1;
}
//VERIFY(ClientToScreen(m_hwnd, &pnt));
SetFocus(m_hwnd);
// Now change the menu item.
ChangeEditMenuItem(htrackmenu);
pGlobals->m_pcmainwin->m_connection->HandleTagsMenu((HMENU)hmenu);
if(wnd)
{
//FrameWindow::RecursiveMenuEnable(htrackmenu, wyFalse, MF_ENABLED);
if(wnd->m_executing == wyTrue || wnd->m_pingexecuting == wyTrue)
{
FrameWindow::RecursiveMenuEnable(htrackmenu, wyFalse, MF_DISABLED);
}
wyTheme::SetMenuItemOwnerDraw(htrackmenu);
nmenuselect = (wyBool)TrackPopupMenu(htrackmenu, TPM_LEFTALIGN | TPM_RIGHTBUTTON, pnt.x, pnt.y, 0, pGlobals->m_pcmainwin->m_hwndmain, NULL);
}
return 1;
}
void SystemClass::InitializeWindows(int& screenWidth, int& screenHeight)
{
WNDCLASSEX wc;
DEVMODE dmScreenSettings;
int posX, posY;
ApplicationHandle = this;
// Get the instance of the application
m_hinstance = GetModuleHandle(NULL);
m_applicationName = L"Engine";
// default settings
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = m_hinstance;
wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
wc.hIconSm = wc.hIcon;
wc.hCursor = LoadCursor(NULL,IDC_ARROW);
wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
wc.lpszMenuName = NULL;
wc.lpszClassName = m_applicationName;
wc.cbSize = sizeof(WNDCLASSEX);
RegisterClassEx(&wc);
screenWidth = GetSystemMetrics(SM_CXSCREEN);
screenHeight = GetSystemMetrics(SM_CYSCREEN);
if(FULL_SCREEN)
{
memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));
dmScreenSettings.dmSize = sizeof(dmScreenSettings);
dmScreenSettings.dmPelsWidth = (unsigned long)screenWidth;
dmScreenSettings.dmPelsHeight = (unsigned long)screenHeight;
dmScreenSettings.dmBitsPerPel = 32;
dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN);
posX = posY = 0;
}
else
{
screenWidth = 800;
screenHeight = 600;
posX = (GetSystemMetrics(SM_CXSCREEN) - screenWidth) / 2;
posY = (GetSystemMetrics(SM_CYSCREEN) - screenHeight) / 2;
}
m_hwnd = CreateWindowEx(WS_EX_APPWINDOW, m_applicationName, m_applicationName,
WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_POPUP,
posX, posY, screenWidth, screenHeight, NULL, NULL, m_hinstance, NULL);
ShowWindow(m_hwnd, SW_SHOW);
SetForegroundWindow(m_hwnd);
SetFocus(m_hwnd);
ShowCursor(false);
return;
}
// todo: akelmore - separate out the init with the command line versus regular init
bool WindowsPlatform::Init(int argc, char** argv)
{
SuperClass::Init(argc, argv);
_instance = GetModuleHandle(nullptr);
LPCWSTR app_name = L"Side Project";
// Setup the windows class with default settings.
_window_class.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
_window_class.lpfnWndProc = WindowsMessageHandler;
_window_class.cbClsExtra = 0;
_window_class.cbWndExtra = 0;
_window_class.hInstance = _instance;
_window_class.hIcon = LoadIcon(nullptr, IDI_WINLOGO);
_window_class.hIconSm = _window_class.hIcon;
_window_class.hCursor = LoadCursor(nullptr, IDC_ARROW);
_window_class.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
_window_class.lpszMenuName = nullptr;
_window_class.lpszClassName = app_name;
_window_class.cbSize = sizeof(WNDCLASSEX);
// Register the window class.
RegisterClassEx(&_window_class);
// do the correct initialization based off of what we're doing (defaulting to OpenGL)
if (_platform_config->Renderer == "directx")
{
DBG_ASSERT_FAIL("I haven't created the DirectX part of the renderer yet.");
}
else
{
_ignore_window_messages = true;
_window = CreateWindowEx(WS_EX_APPWINDOW, app_name, app_name,
WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
200, 200, _platform_config->Width, _platform_config->Height,
nullptr, nullptr, _instance, nullptr);
if (_window == nullptr)
return false;
// hide the window because it's only a temp one
ShowWindow(_window, SW_HIDE);
OpenGLGraphics* opengl_graphics = new OpenGLGraphics();
_graphics_renderer = opengl_graphics;
opengl_graphics->PreInitializeWindowsOpenGL(_window);
// destroy the temp window
DestroyWindow(_window);
_window = nullptr;
_ignore_window_messages = false;
}
DEVMODE dmScreenSettings;
if (_platform_config->Fullscreen)
{
memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));
dmScreenSettings.dmSize = sizeof(dmScreenSettings);
dmScreenSettings.dmPelsWidth = (unsigned long)_platform_config->Width;
dmScreenSettings.dmPelsHeight = (unsigned long)_platform_config->Height;
dmScreenSettings.dmBitsPerPel = 32;
dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN);
}
// create the real window
// 200s are x/y position on screen
_window = CreateWindowEx(WS_EX_APPWINDOW, app_name, app_name,
WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
200, 200, _platform_config->Width, _platform_config->Height,
nullptr, nullptr, _instance, nullptr);
if (_window == nullptr)
return false;
SetScreenDimensions(_platform_config->Width, _platform_config->Height);
if(!_graphics_renderer->Init())
return false;
ShowWindow(_window, SW_SHOW);
SetForegroundWindow(_window);
SetFocus(_window);
return true;
}
static VOID RebarLoadSettings(
VOID
)
{
// Initialize the Toolbar Imagelist.
if (EnableToolBar && !ToolBarImageList)
{
HBITMAP iconBitmap = NULL;
// Create the toolbar imagelist
ToolBarImageList = ImageList_Create(16, 16, ILC_COLOR32 | ILC_MASK, 0, 0);
// Set the number of images
ImageList_SetImageCount(ToolBarImageList, 8);
// Add the images to the imagelist
if (iconBitmap = LoadImageFromResources(16, 16, MAKEINTRESOURCE(IDB_ARROW_REFRESH)))
{
ImageList_Replace(ToolBarImageList, 0, iconBitmap, NULL);
DeleteObject(iconBitmap);
}
else
{
PhSetImageListBitmap(ToolBarImageList, 0, PluginInstance->DllBase, MAKEINTRESOURCE(IDB_ARROW_REFRESH_BMP));
}
if (iconBitmap = LoadImageFromResources(16, 16, MAKEINTRESOURCE(IDB_COG_EDIT)))
{
ImageList_Replace(ToolBarImageList, 1, iconBitmap, NULL);
DeleteObject(iconBitmap);
}
else
{
PhSetImageListBitmap(ToolBarImageList, 1, PluginInstance->DllBase, MAKEINTRESOURCE(IDB_COG_EDIT_BMP));
}
if (iconBitmap = LoadImageFromResources(16, 16, MAKEINTRESOURCE(IDB_FIND)))
{
ImageList_Replace(ToolBarImageList, 2, iconBitmap, NULL);
DeleteObject(iconBitmap);
}
else
{
PhSetImageListBitmap(ToolBarImageList, 2, PluginInstance->DllBase, MAKEINTRESOURCE(IDB_FIND_BMP));
}
if (iconBitmap = LoadImageFromResources(16, 16, MAKEINTRESOURCE(IDB_CHART_LINE)))
{
ImageList_Replace(ToolBarImageList, 3, iconBitmap, NULL);
DeleteObject(iconBitmap);
}
else
{
PhSetImageListBitmap(ToolBarImageList, 3, PluginInstance->DllBase, MAKEINTRESOURCE(IDB_CHART_LINE_BMP));
}
if (iconBitmap = LoadImageFromResources(16, 16, MAKEINTRESOURCE(IDB_APPLICATION)))
{
ImageList_Replace(ToolBarImageList, 4, iconBitmap, NULL);
DeleteObject(iconBitmap);
}
else
{
PhSetImageListBitmap(ToolBarImageList, 4, PluginInstance->DllBase, MAKEINTRESOURCE(IDB_APPLICATION_BMP));
}
if (iconBitmap = LoadImageFromResources(16, 16, MAKEINTRESOURCE(IDB_APPLICATION_GO)))
{
ImageList_Replace(ToolBarImageList, 5, iconBitmap, NULL);
DeleteObject(iconBitmap);
}
else
{
PhSetImageListBitmap(ToolBarImageList, 5, PluginInstance->DllBase, MAKEINTRESOURCE(IDB_APPLICATION_GO_BMP));
}
if (iconBitmap = LoadImageFromResources(16, 16, MAKEINTRESOURCE(IDB_CROSS)))
{
ImageList_Replace(ToolBarImageList, 6, iconBitmap, NULL);
DeleteObject(iconBitmap);
}
else
{
PhSetImageListBitmap(ToolBarImageList, 6, PluginInstance->DllBase, MAKEINTRESOURCE(IDB_CROSS_BMP));
}
if (iconBitmap = LoadImageFromResources(16, 16, MAKEINTRESOURCE(IDB_APPLICATION_GET)))
{
ImageList_Replace(ToolBarImageList, 7, iconBitmap, NULL);
DeleteObject(iconBitmap);
}
else
{
PhSetImageListBitmap(ToolBarImageList, 7, PluginInstance->DllBase, MAKEINTRESOURCE(IDB_APPLICATION_GET_BMP));
}
}
// Initialize the Rebar and Toolbar controls.
if (EnableToolBar && !RebarHandle)
{
REBARINFO rebarInfo = { sizeof(REBARINFO) };
ULONG toolbarButtonSize;
// Create the ReBar window.
RebarHandle = CreateWindowEx(
WS_EX_TOOLWINDOW,
REBARCLASSNAME,
NULL,
WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | CCS_NODIVIDER | CCS_TOP | RBS_VARHEIGHT | RBS_AUTOSIZE, // CCS_NOPARENTALIGN | RBS_FIXEDORDER
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
PhMainWndHandle,
NULL,
NULL,
NULL
);
// Set the toolbar info with no imagelist.
SendMessage(RebarHandle, RB_SETBARINFO, 0, (LPARAM)&rebarInfo);
// Create the ToolBar window.
ToolBarHandle = CreateWindowEx(
0,
TOOLBARCLASSNAME,
NULL,
WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | CCS_NORESIZE | CCS_NOPARENTALIGN | CCS_NODIVIDER | CCS_ADJUSTABLE | TBSTYLE_FLAT | TBSTYLE_LIST | TBSTYLE_TRANSPARENT | TBSTYLE_TOOLTIPS | TBSTYLE_AUTOSIZE, // TBSTYLE_ALTDRAG
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
RebarHandle,
NULL,
NULL,
NULL
);
// Manually add button strings via TB_ADDSTRING.
// NOTE: The Toolbar will sometimes decide to free strings hard-coded via (INT_PTR)L"String"
// in the ToolbarButtons array causing random crashes unless we manually add the strings
// into the Toolbar string pool (this bug only affects 64bit Windows)... WTF???
ToolbarButtons[0].iString = SendMessage(ToolBarHandle, TB_ADDSTRING, 0, (LPARAM)L"Refresh");
ToolbarButtons[1].iString = SendMessage(ToolBarHandle, TB_ADDSTRING, 0, (LPARAM)L"Options");
ToolbarButtons[3].iString = SendMessage(ToolBarHandle, TB_ADDSTRING, 0, (LPARAM)L"Find Handles or DLLs");
ToolbarButtons[4].iString = SendMessage(ToolBarHandle, TB_ADDSTRING, 0, (LPARAM)L"System Information");
ToolbarButtons[6].iString = SendMessage(ToolBarHandle, TB_ADDSTRING, 0, (LPARAM)L"Find Window");
ToolbarButtons[7].iString = SendMessage(ToolBarHandle, TB_ADDSTRING, 0, (LPARAM)L"Find Window and Thread");
ToolbarButtons[8].iString = SendMessage(ToolBarHandle, TB_ADDSTRING, 0, (LPARAM)L"Find Window and Kill");
ToolbarButtons[9].iString = SendMessage(ToolBarHandle, TB_ADDSTRING, 0, (LPARAM)L"Always on Top");
// Set the toolbar struct size.
SendMessage(ToolBarHandle, TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
// Set the toolbar extended toolbar styles.
SendMessage(ToolBarHandle, TB_SETEXTENDEDSTYLE, 0, TBSTYLE_EX_DOUBLEBUFFER | TBSTYLE_EX_MIXEDBUTTONS | TBSTYLE_EX_HIDECLIPPEDBUTTONS);
// Configure the toolbar imagelist.
SendMessage(ToolBarHandle, TB_SETIMAGELIST, 0, (LPARAM)ToolBarImageList);
// Add the buttons to the toolbar (also specifying the default number of items to display).
SendMessage(ToolBarHandle, TB_ADDBUTTONS, MAX_DEFAULT_TOOLBAR_ITEMS, (LPARAM)ToolbarButtons);
// Restore the toolbar settings (Note: This will invoke the TBN_ENDADJUST notification).
SendMessage(ToolBarHandle, TB_SAVERESTORE, FALSE, (LPARAM)&ToolbarSaveParams);
// Query the toolbar button width/height.
toolbarButtonSize = (ULONG)SendMessage(ToolBarHandle, TB_GETBUTTONSIZE, 0, 0);
// Enable theming:
//SendMessage(RebarHandle, RB_SETWINDOWTHEME, 0, (LPARAM)L"Media"); //Media/Communications/BrowserTabBar/Help
//SendMessage(ToolBarHandle, TB_SETWINDOWTHEME, 0, (LPARAM)L"Media"); //Media/Communications/BrowserTabBar/Help
// Inset the toolbar into the rebar control.
RebarBandInsert(BandID_ToolBar, ToolBarHandle, HIWORD(toolbarButtonSize), LOWORD(toolbarButtonSize));
ToolbarInitialized = TRUE;
}
// Initialize the Searchbox and TreeNewFilters.
if (EnableSearchBox && !SearchboxHandle)
{
SearchboxText = PhReferenceEmptyString();
ProcessTreeFilterEntry = PhAddTreeNewFilter(PhGetFilterSupportProcessTreeList(), (PPH_TN_FILTER_FUNCTION)ProcessTreeFilterCallback, NULL);
ServiceTreeFilterEntry = PhAddTreeNewFilter(PhGetFilterSupportServiceTreeList(), (PPH_TN_FILTER_FUNCTION)ServiceTreeFilterCallback, NULL);
NetworkTreeFilterEntry = PhAddTreeNewFilter(PhGetFilterSupportNetworkTreeList(), (PPH_TN_FILTER_FUNCTION)NetworkTreeFilterCallback, NULL);
// Create the Searchbox control.
SearchboxHandle = CreateSearchControl(ID_SEARCH_CLEAR);
}
// Initialize the Statusbar control.
if (EnableStatusBar && !StatusBarHandle)
{
// Create the StatusBar window.
StatusBarHandle = CreateWindowEx(
0,
STATUSCLASSNAME,
NULL,
WS_CHILD | WS_VISIBLE | CCS_BOTTOM | SBARS_SIZEGRIP | SBARS_TOOLTIPS,
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
PhMainWndHandle,
NULL,
NULL,
NULL
);
}
// Hide or show controls (Note: don't unload or remove at runtime).
if (EnableToolBar)
{
if (RebarHandle && !IsWindowVisible(RebarHandle))
ShowWindow(RebarHandle, SW_SHOW);
}
else
{
if (RebarHandle && IsWindowVisible(RebarHandle))
ShowWindow(RebarHandle, SW_HIDE);
}
if (EnableSearchBox)
{
// Add the Searchbox band into the rebar control.
if (!RebarBandExists(BandID_SearchBox))
RebarBandInsert(BandID_SearchBox, SearchboxHandle, 20, 180);
if (SearchboxHandle && !IsWindowVisible(SearchboxHandle))
ShowWindow(SearchboxHandle, SW_SHOW);
}
else
{
// Remove the Searchbox band from the rebar control.
if (RebarBandExists(BandID_SearchBox))
RebarBandRemove(BandID_SearchBox);
if (SearchboxHandle)
{
// Clear search text and reset search filters.
SetFocus(SearchboxHandle);
Static_SetText(SearchboxHandle, L"");
if (IsWindowVisible(SearchboxHandle))
ShowWindow(SearchboxHandle, SW_HIDE);
}
}
// TODO: Fix above code...
if (SearchBoxDisplayMode == SearchBoxDisplayHideInactive)
{
if (RebarBandExists(BandID_SearchBox))
RebarBandRemove(BandID_SearchBox);
}
else
{
if (!RebarBandExists(BandID_SearchBox))
RebarBandInsert(BandID_SearchBox, SearchboxHandle, 20, 180);
}
if (EnableStatusBar)
{
if (StatusBarHandle && !IsWindowVisible(StatusBarHandle))
ShowWindow(StatusBarHandle, SW_SHOW);
}
else
{
if (StatusBarHandle && IsWindowVisible(StatusBarHandle))
ShowWindow(StatusBarHandle, SW_HIDE);
}
}
LRESULT CALLBACK RamWatchProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
RECT r;
RECT r2;
int dx1, dy1, dx2, dy2;
static int watchIndex=0;
switch(uMsg)
{
case WM_MOVE: {
RECT wrect;
GetWindowRect(hDlg,&wrect);
ramw_x = wrect.left;
ramw_y = wrect.top;
break;
};
case WM_INITDIALOG: {
GetWindowRect(hWnd, &r); //Ramwatch window
dx1 = (r.right - r.left) / 2;
dy1 = (r.bottom - r.top) / 2;
GetWindowRect(hDlg, &r2); // TASer window
dx2 = (r2.right - r2.left) / 2;
dy2 = (r2.bottom - r2.top) / 2;
// push it away from the main window if we can
const int width = (r.right-r.left);
const int height = (r.bottom - r.top);
const int width2 = (r2.right-r2.left);
if(r.left+width2 + width < GetSystemMetrics(SM_CXSCREEN))
{
r.right += width;
r.left += width;
}
else if((int)r.left - (int)width2 > 0)
{
r.right -= width2;
r.left -= width2;
}
//-----------------------------------------------------------------------------------
//If user has Save Window Pos selected, override default positioning
if(RWSaveWindowPos)
{
//If ramwindow is for some reason completely off screen, use default instead
if(ramw_x > (-width*2) || ramw_x < (width*2 + GetSystemMetrics(SM_CYSCREEN)) )
r.left = ramw_x; //This also ignores cases of windows -32000 error codes
//If ramwindow is for some reason completely off screen, use default instead
if(ramw_y > (0-height*2) ||ramw_y < (height*2 + GetSystemMetrics(SM_CYSCREEN)) )
r.top = ramw_y; //This also ignores cases of windows -32000 error codes
}
//-------------------------------------------------------------------------------------
SetWindowPos(hDlg, NULL, r.left, r.top, NULL, NULL, SWP_NOSIZE | SWP_NOZORDER | SWP_SHOWWINDOW);
ramwatchmenu=GetMenu(hDlg);
rwrecentmenu=CreateMenu();
UpdateRW_RMenu(rwrecentmenu, RAMMENU_FILE_RECENT, RW_MENU_FIRST_RECENT_FILE);
const char* names[3] = {"Address","Value","Notes"};
int widths[3] = {62,64,64+51+53};
init_list_box(GetDlgItem(hDlg,IDC_WATCHLIST),names,3,widths);
if(!ResultCount)
reset_address_info();
else
signal_new_frame();
ListView_SetItemCount(GetDlgItem(hDlg,IDC_WATCHLIST),WatchCount);
//if(littleEndian) SendDlgItemMessage(hDlg, IDC_ENDIAN, BM_SETCHECK, BST_CHECKED, 0);
RamWatchAccels = LoadAccelerators(hInst, MAKEINTRESOURCE(IDR_ACCELERATOR1));
// due to some bug in windows, the arrow button width from the resource gets ignored, so we have to set it here
SetWindowPos(GetDlgItem(hDlg,ID_WATCHES_UPDOWN), 0,0,0, 30,60, SWP_NOMOVE);
Update_RAM_Watch();
DragAcceptFiles(hDlg, TRUE);
return true;
break;
}
case WM_INITMENU:
CheckMenuItem(ramwatchmenu, RAMMENU_FILE_AUTOLOAD, AutoRWLoad ? MF_CHECKED : MF_UNCHECKED);
CheckMenuItem(ramwatchmenu, RAMMENU_FILE_SAVEWINDOW, RWSaveWindowPos ? MF_CHECKED : MF_UNCHECKED);
break;
case WM_MENUSELECT:
case WM_ENTERSIZEMOVE:
//Clear_Sound_Buffer();
break;
case WM_NOTIFY:
{
LPNMHDR lP = (LPNMHDR) lParam;
switch(lP->code)
{
case LVN_GETDISPINFO:
{
LV_DISPINFO *Item = (LV_DISPINFO *)lParam;
Item->item.mask = LVIF_TEXT;
Item->item.state = 0;
Item->item.iImage = 0;
const unsigned int iNum = Item->item.iItem;
static char num[64];
switch(Item->item.iSubItem)
{
case 0:
sprintf(num,"%08X",rswatches[iNum].Address);
Item->item.pszText = num;
return true;
case 1: {
RSVal rsval = rswatches[iNum].CurValue;
int t = rswatches[iNum].Type;
int size = rswatches[iNum].Size;
rsval.print(num, size, t);
Item->item.pszText = num;
} return true;
case 2:
Item->item.pszText = rswatches[iNum].comment ? rswatches[iNum].comment : "";
return true;
default:
return false;
}
}
case LVN_ODFINDITEM:
{
// disable search by keyboard typing,
// because it interferes with some of the accelerators
// and it isn't very useful here anyway
SetWindowLong(hDlg, DWL_MSGRESULT, ListView_GetSelectionMark(GetDlgItem(hDlg,IDC_WATCHLIST)));
return 1;
}
}
}
break;
case WM_COMMAND:
switch(LOWORD(wParam))
{
case RAMMENU_FILE_SAVE:
QuickSaveWatches();
break;
case RAMMENU_FILE_SAVEAS:
//case IDC_C_SAVE:
return Save_Watches();
case RAMMENU_FILE_OPEN:
return Load_Watches(true);
case RAMMENU_FILE_APPEND:
//case IDC_C_LOAD:
return Load_Watches(false);
case RAMMENU_FILE_NEW:
//case IDC_C_RESET:
ResetWatches();
return true;
case IDC_C_WATCH_REMOVE:
watchIndex = ListView_GetSelectionMark(GetDlgItem(hDlg,IDC_WATCHLIST));
RemoveWatch(watchIndex);
ListView_SetItemCount(GetDlgItem(hDlg,IDC_WATCHLIST),WatchCount);
RWfileChanged=true;
SetFocus(GetDlgItem(hDlg,IDC_WATCHLIST));
return true;
case IDC_C_WATCH_EDIT:
watchIndex = ListView_GetSelectionMark(GetDlgItem(hDlg,IDC_WATCHLIST));
DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_EDITWATCH), hDlg, (DLGPROC) EditWatchProc,(LPARAM) watchIndex);
SetFocus(GetDlgItem(hDlg,IDC_WATCHLIST));
return true;
case IDC_C_WATCH:
rswatches[WatchCount].Address = rswatches[WatchCount].WrongEndian = 0;
rswatches[WatchCount].Size = 'b';
rswatches[WatchCount].Type = 's';
DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_EDITWATCH), hDlg, (DLGPROC) EditWatchProc,(LPARAM) WatchCount);
SetFocus(GetDlgItem(hDlg,IDC_WATCHLIST));
return true;
case IDC_C_WATCH_DUPLICATE:
watchIndex = ListView_GetSelectionMark(GetDlgItem(hDlg,IDC_WATCHLIST));
rswatches[WatchCount].Address = rswatches[watchIndex].Address;
rswatches[WatchCount].WrongEndian = rswatches[watchIndex].WrongEndian;
rswatches[WatchCount].Size = rswatches[watchIndex].Size;
rswatches[WatchCount].Type = rswatches[watchIndex].Type;
DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_EDITWATCH), hDlg, (DLGPROC) EditWatchProc,(LPARAM) WatchCount);
SetFocus(GetDlgItem(hDlg,IDC_WATCHLIST));
return true;
case IDC_C_WATCH_UP:
{
watchIndex = ListView_GetSelectionMark(GetDlgItem(hDlg,IDC_WATCHLIST));
if(watchIndex == 0 || watchIndex == -1)
return true;
void *tmp = malloc(sizeof(AddressWatcher));
memcpy(tmp,&(rswatches[watchIndex]),sizeof(AddressWatcher));
memcpy(&(rswatches[watchIndex]),&(rswatches[watchIndex - 1]),sizeof(AddressWatcher));
memcpy(&(rswatches[watchIndex - 1]),tmp,sizeof(AddressWatcher));
free(tmp);
ListView_SetSelectionMark(GetDlgItem(hDlg,IDC_WATCHLIST),watchIndex-1);
ListView_SetItemState(GetDlgItem(hDlg,IDC_WATCHLIST),watchIndex-1,LVIS_FOCUSED|LVIS_SELECTED,LVIS_FOCUSED|LVIS_SELECTED);
ListView_SetItemCount(GetDlgItem(hDlg,IDC_WATCHLIST),WatchCount);
RWfileChanged=true;
return true;
}
case IDC_C_WATCH_DOWN:
{
watchIndex = ListView_GetSelectionMark(GetDlgItem(hDlg,IDC_WATCHLIST));
if(watchIndex >= WatchCount - 1 || watchIndex == -1)
return true;
void *tmp = malloc(sizeof(AddressWatcher));
memcpy(tmp,&(rswatches[watchIndex]),sizeof(AddressWatcher));
memcpy(&(rswatches[watchIndex]),&(rswatches[watchIndex + 1]),sizeof(AddressWatcher));
memcpy(&(rswatches[watchIndex + 1]),tmp,sizeof(AddressWatcher));
free(tmp);
ListView_SetSelectionMark(GetDlgItem(hDlg,IDC_WATCHLIST),watchIndex+1);
ListView_SetItemState(GetDlgItem(hDlg,IDC_WATCHLIST),watchIndex+1,LVIS_FOCUSED|LVIS_SELECTED,LVIS_FOCUSED|LVIS_SELECTED);
ListView_SetItemCount(GetDlgItem(hDlg,IDC_WATCHLIST),WatchCount);
RWfileChanged=true;
return true;
}
case ID_WATCHES_UPDOWN:
{
int delta = ((LPNMUPDOWN)lParam)->iDelta;
SendMessage(hDlg, WM_COMMAND, delta<0 ? IDC_C_WATCH_UP : IDC_C_WATCH_DOWN,0);
break;
}
case RAMMENU_FILE_AUTOLOAD:
{
AutoRWLoad ^= 1;
CheckMenuItem(ramwatchmenu, RAMMENU_FILE_AUTOLOAD, AutoRWLoad ? MF_CHECKED : MF_UNCHECKED);
break;
}
case RAMMENU_FILE_SAVEWINDOW:
{
RWSaveWindowPos ^=1;
CheckMenuItem(ramwatchmenu, RAMMENU_FILE_SAVEWINDOW, RWSaveWindowPos ? MF_CHECKED : MF_UNCHECKED);
break;
}
case IDC_C_ADDCHEAT:
{
// watchIndex = ListView_GetSelectionMark(GetDlgItem(hDlg,IDC_WATCHLIST)) | (1 << 24);
// DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_EDITCHEAT), hDlg, (DLGPROC) EditCheatProc,(LPARAM) searchIndex);
}
case IDOK:
case IDCANCEL:
RamWatchHWnd = NULL;
DragAcceptFiles(hDlg, FALSE);
EndDialog(hDlg, true);
return true;
default:
if(LOWORD(wParam) >= RW_MENU_FIRST_RECENT_FILE && LOWORD(wParam) < RW_MENU_FIRST_RECENT_FILE+MAX_RECENT_WATCHES)
OpenRWRecentFile(LOWORD(wParam) - RW_MENU_FIRST_RECENT_FILE);
}
break;
case WM_KEYDOWN: // handle accelerator keys
{
SetFocus(GetDlgItem(hDlg,IDC_WATCHLIST));
MSG msg;
msg.hwnd = hDlg;
msg.message = uMsg;
msg.wParam = wParam;
msg.lParam = lParam;
if(RamWatchAccels && TranslateAccelerator(hDlg, RamWatchAccels, &msg))
return true;
} break;
case WM_CLOSE:
RamWatchHWnd = NULL;
DragAcceptFiles(hDlg, FALSE);
EndDialog(hDlg, true);
return true;
case WM_DROPFILES:
{
HDROP hDrop = (HDROP)wParam;
DragQueryFile(hDrop, 0, Str_Tmp_RW, 1024);
DragFinish(hDrop);
return Load_Watches(true, Str_Tmp_RW);
} break;
}
return false;
}
/*
* Window procedure for the dialog box
*/
static BOOL MessageBoxProc( HWND hwnd, UINT message,
WPARAM wParam, LPARAM lParam )
{
int i;
PMSGBOXINFO mbi;
//HELPINFO hi;
//HWND owner;
switch(message) {
case WM_INITDIALOG:
mbi = (PMSGBOXINFO)lParam;
if(!GetProp(hwnd, "ROS_MSGBOX"))
{
SetProp(hwnd, "ROS_MSGBOX", (HANDLE)lParam);
if(mbi->Icon)
SendDlgItemMessage(hwnd, MSGBOX_IDICON, STM_SETICON, (WPARAM)mbi->Icon, 0);
#if 0
SetWindowContextHelpId(hwnd, mbi->ContextHelpId);
#endif
/* set control fonts */
SendDlgItemMessage(hwnd, MSGBOX_IDTEXT, WM_SETFONT, (WPARAM)mbi->Font, 0);
for(i = 0; i < mbi->nButtons; i++)
{
SendDlgItemMessage(hwnd, mbi->Btns[i], WM_SETFONT, (WPARAM)mbi->Font, 0);
}
#if 0
switch(mbi->Style & MB_TYPEMASK)
{
case MB_ABORTRETRYIGNORE:
case MB_YESNO:
RemoveMenu(GetSystemMenu(hwnd, FALSE), SC_CLOSE, MF_BYCOMMAND);
break;
}
#endif
SetFocus(GetDlgItem(hwnd, mbi->DefBtn));
if(mbi->Timeout && (mbi->Timeout != (UINT)-1))
SetTimer(hwnd, 0, mbi->Timeout, NULL);
}
return 0;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDOK:
case IDCANCEL:
case IDABORT:
case IDRETRY:
case IDIGNORE:
case IDYES:
case IDNO:
case IDTRYAGAIN:
case IDCONTINUE:
EndDialog(hwnd, wParam);
return TRUE;
#if 0
case IDHELP:
/* send WM_HELP message to messagebox window */
hi.cbSize = sizeof(HELPINFO);
hi.iContextType = HELPINFO_WINDOW;
hi.iCtrlId = LOWORD(wParam);
hi.hItemHandle = (HANDLE)lParam;
hi.dwContextId = 0;
GetCursorPos(&hi.MousePos);
SendMessageW(hwnd, WM_HELP, 0, (LPARAM)&hi);
return 0;
#endif
}
return 0;
#if 0
case WM_HELP:
mbi = (PMSGBOXINFO)GetProp(hwnd, "ROS_MSGBOX");
if(!mbi)
return 0;
memcpy(&hi, (void *)lParam, sizeof(hi));
hi.dwContextId = GetWindowContextHelpId(hwnd);
if (mbi->Callback)
mbi->Callback(&hi);
else
{
owner = GetWindow(hwnd, GW_OWNER);
if(owner)
SendMessageW(GetWindow(hwnd, GW_OWNER), WM_HELP, 0, (LPARAM)&hi);
}
return 0;
#endif
case WM_CLOSE:
mbi = (PMSGBOXINFO)GetProp(hwnd, "ROS_MSGBOX");
if(!mbi)
return 0;
switch(mbi->Style & MB_TYPEMASK)
{
case MB_ABORTRETRYIGNORE:
case MB_YESNO:
return 1;
}
EndDialog(hwnd, IDCANCEL);
return 1;
case WM_TIMER:
if(wParam == 0)
{
EndDialog(hwnd, 32000);
}
return 0;
}
return 0;
}
BOOL CALLBACK ReplayDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch(uMsg)
{
case WM_INITDIALOG:
{
SendDlgItemMessage(hwndDlg, IDC_CHECK_READONLY, BM_SETCHECK, replayReadOnlySetting?BST_CHECKED:BST_UNCHECKED, 0);
SendDlgItemMessage(hwndDlg, IDC_CHECK_STOPMOVIE,BM_SETCHECK, BST_UNCHECKED, 0);
#define NUM_OF_MOVIEGLOB_PATHS 1
char* findGlob[NUM_OF_MOVIEGLOB_PATHS] = {strdup(FCEU_MakeFName(FCEUMKF_MOVIEGLOB, 0, 0).c_str())};
int items=0;
for(int j = 0;j < NUM_OF_MOVIEGLOB_PATHS; j++)
{
char* temp=0;
do {
temp=strchr(findGlob[j],'/');
if(temp)
*temp = '\\';
} while(temp);
// disabled because... apparently something is case sensitive??
// for(i=1;i<strlen(findGlob[j]);i++)
// findGlob[j][i] = tolower(findGlob[j][i]);
}
for(int j = 0;j < NUM_OF_MOVIEGLOB_PATHS; j++)
{
// if the two directories are the same, only look through one of them to avoid adding everything twice
if(j==1 && !strnicmp(findGlob[0],findGlob[1],MAX(strlen(findGlob[0]),strlen(findGlob[1]))-6))
continue;
char globBase[512];
strcpy(globBase,findGlob[j]);
globBase[strlen(globBase)-5]='\0';
//char szFindPath[512]; //mbg merge 7/17/06 removed
WIN32_FIND_DATA wfd;
HANDLE hFind;
memset(&wfd, 0, sizeof(wfd));
hFind = FindFirstFile(findGlob[j], &wfd);
if(hFind != INVALID_HANDLE_VALUE)
{
do
{
if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
continue;
//TODO - a big copy/pasted block below. factor out extension extractor or use another one
// filter out everything that's not an extension we like (*.fm2 and *.fm3)
// (because FindFirstFile is too dumb to do that)
{
std::string ext = getExtension(wfd.cFileName);
if(ext != "fm2")
if(ext != "fm3")
if(ext != "zip")
if(ext != "rar")
if(ext != "7z")
continue;
}
char filename [512];
sprintf(filename, "%s%s", globBase, wfd.cFileName);
//replay system requires this to stay put.
SetCurrentDirectory(BaseDirectory.c_str());
ArchiveScanRecord asr = FCEUD_ScanArchive(filename);
if(!asr.isArchive())
{
FCEUFILE* fp = FCEU_fopen(filename,0,"rb",0);
if(fp)
{
//fp->stream = fp->stream->memwrap(); - no need to load whole movie to memory! We only need to read movie header!
HandleScan(hwndDlg, fp, items);
delete fp;
}
} else
{
asr.files.FilterByExtension(fm2ext);
for(uint32 i=0;i<asr.files.size();i++)
{
FCEUFILE* fp = FCEU_fopen(filename,0,"rb",0,asr.files[i].index);
if(fp)
{
HandleScan(hwndDlg,fp, items);
delete fp;
}
}
}
} while(FindNextFile(hFind, &wfd));
FindClose(hFind);
}
}
for(int j = 0; j < NUM_OF_MOVIEGLOB_PATHS; j++)
free(findGlob[j]);
if(items>0)
SendDlgItemMessage(hwndDlg, IDC_COMBO_FILENAME, CB_SETCURSEL, items-1, 0);
SendDlgItemMessage(hwndDlg, IDC_COMBO_FILENAME, CB_INSERTSTRING, items++, (LPARAM)"Browse...");
UpdateReplayDialog(hwndDlg);
}
SetFocus(GetDlgItem(hwndDlg, IDC_COMBO_FILENAME));
return FALSE;
case WM_COMMAND:
if (HIWORD(wParam) == EN_CHANGE)
{
if (LOWORD(wParam) == IDC_EDIT_STOPFRAME) // Check if Stop movie at value has changed
{
if (stopframeWasEditedByUser)
{
HWND hwnd1 = GetDlgItem(hwndDlg,IDC_CHECK_STOPMOVIE);
Button_SetCheck(hwnd1,BST_CHECKED);
stopframeWasEditedByUser = true;
}
else
stopframeWasEditedByUser = true;
}
}
if (HIWORD(wParam) == CBN_SELCHANGE)
{
UpdateReplayDialog(hwndDlg);
} else if(HIWORD(wParam) == CBN_CLOSEUP)
{
LONG lCount = SendDlgItemMessage(hwndDlg, IDC_COMBO_FILENAME, CB_GETCOUNT, 0, 0);
LONG lIndex = SendDlgItemMessage(hwndDlg, IDC_COMBO_FILENAME, CB_GETCURSEL, 0, 0);
if (lIndex != CB_ERR && lIndex == lCount-1)
SendMessage(hwndDlg, WM_COMMAND, (WPARAM)IDOK, 0); // send an OK notification to open the file browser
} else
{
int wID = LOWORD(wParam);
switch(wID)
{
case IDC_BUTTON_METADATA:
DialogBoxParam(fceu_hInstance, "IDD_REPLAY_METADATA", hwndDlg, ReplayMetadataDialogProc, (LPARAM)0);
break;
case IDOK:
{
LONG lCount = SendDlgItemMessage(hwndDlg, IDC_COMBO_FILENAME, CB_GETCOUNT, 0, 0);
LONG lIndex = SendDlgItemMessage(hwndDlg, IDC_COMBO_FILENAME, CB_GETCURSEL, 0, 0);
if(lIndex != CB_ERR)
{
if(lIndex == lCount-1)
{
// pop open a file browser...
char *pn=strdup(FCEU_GetPath(FCEUMKF_MOVIE).c_str());
char szFile[MAX_PATH]={0};
OPENFILENAME ofn;
//int nRet; //mbg merge 7/17/06 removed
memset(&ofn, 0, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = hwndDlg;
ofn.lpstrFilter = "FCEUX Movie Files (*.fm2), TAS Editor Projects (*.fm3)\0*.fm2;*.fm3\0FCEUX Movie Files (*.fm2)\0*.fm2\0Archive Files (*.zip,*.rar,*.7z)\0*.zip;*.rar;*.7z\0All Files (*.*)\0*.*\0\0";
ofn.lpstrFile = szFile;
ofn.nMaxFile = sizeof(szFile);
ofn.lpstrInitialDir = pn;
ofn.Flags = OFN_NOCHANGEDIR | OFN_HIDEREADONLY;
ofn.lpstrDefExt = "fm2";
ofn.lpstrTitle = "Play Movie from File";
if(GetOpenFileName(&ofn))
{
char relative[MAX_PATH*2];
AbsoluteToRelative(relative, szFile, BaseDirectory.c_str());
//replay system requires this to stay put.
SetCurrentDirectory(BaseDirectory.c_str());
ArchiveScanRecord asr = FCEUD_ScanArchive(relative);
FCEUFILE* fp = FCEU_fopen(relative,0,"rb",0,-1,fm2ext);
if(!fp)
goto abort;
strcpy(relative,fp->fullFilename.c_str());
delete fp;
LONG lOtherIndex = SendDlgItemMessage(hwndDlg, IDC_COMBO_FILENAME, CB_FINDSTRING, (WPARAM)-1, (LPARAM)relative);
if(lOtherIndex != CB_ERR)
{
// select already existing string
SendDlgItemMessage(hwndDlg, IDC_COMBO_FILENAME, CB_SETCURSEL, lOtherIndex, 0);
UpdateReplayDialog(hwndDlg);
} else
{
SendDlgItemMessage(hwndDlg, IDC_COMBO_FILENAME, CB_INSERTSTRING, lIndex, (LPARAM)relative);
SendDlgItemMessage(hwndDlg, IDC_COMBO_FILENAME, CB_SETCURSEL, lIndex, 0);
//UpdateReplayDialog(hwndDlg); - this call would be redundant, because the update is always triggered by CBN_SELCHANGE message anyway
}
// restore focus to the dialog
SetFocus(GetDlgItem(hwndDlg, IDC_COMBO_FILENAME));
}
abort:
free(pn);
}
else
{
// user had made their choice
// TODO: warn the user when they open a movie made with a different ROM
char* fn=GetReplayPath(hwndDlg);
//char TempArray[16]; //mbg merge 7/17/06 removed
replayReadOnlySetting = (SendDlgItemMessage(hwndDlg, IDC_CHECK_READONLY, BM_GETCHECK, 0, 0) == BST_CHECKED);
char offset1Str[32]={0};
SendDlgItemMessage(hwndDlg, IDC_EDIT_STOPFRAME, WM_GETTEXT, (WPARAM)32, (LPARAM)offset1Str);
replayStopFrameSetting = (SendDlgItemMessage(hwndDlg, IDC_CHECK_STOPMOVIE, BM_GETCHECK,0,0) == BST_CHECKED)? strtol(offset1Str,0,10):0;
EndDialog(hwndDlg, (INT_PTR)fn);
}
}
}
return TRUE;
case IDCANCEL:
EndDialog(hwndDlg, 0);
return TRUE;
}
}
return FALSE;
case WM_CTLCOLORSTATIC:
if ((HWND)lParam == GetDlgItem(hwndDlg, IDC_LABEL_CURRCHECKSUM))
{
// draw the md5 sum in red if it's different from the md5 of the rom used in the replay
HDC hdcStatic = (HDC)wParam;
char szMd5Text[35];
GetDlgItemText(hwndDlg, IDC_LABEL_ROMCHECKSUM, szMd5Text, 35);
if (!strlen(szMd5Text) || !strcmp(szMd5Text, "unknown") || !strcmp(szMd5Text, "00000000000000000000000000000000") || !strcmp(szMd5Text, md5_asciistr(GameInfo->MD5)))
SetTextColor(hdcStatic, RGB(0,0,0)); // use black color for a match (or no comparison)
else
SetTextColor(hdcStatic, RGB(255,0,0)); // use red for a mismatch
SetBkMode((HDC)wParam,TRANSPARENT);
return (BOOL)GetSysColorBrush(COLOR_BTNFACE);
} else if ((HWND)lParam == GetDlgItem(hwndDlg, IDC_LABEL_NEWPPUUSED))
{
HDC hdcStatic = (HDC)wParam;
char szMd5Text[35];
GetDlgItemText(hwndDlg, IDC_LABEL_NEWPPUUSED, szMd5Text, 35);
bool want_newppu = (strcmp(szMd5Text, "Off") != 0);
extern int newppu;
if ((want_newppu && newppu) || (!want_newppu && !newppu))
SetTextColor(hdcStatic, RGB(0,0,0)); // use black color for a match
else
SetTextColor(hdcStatic, RGB(255,0,0)); // use red for a mismatch
SetBkMode((HDC)wParam,TRANSPARENT);
return (BOOL)GetSysColorBrush(COLOR_BTNFACE);
} else
{
return FALSE;
}
}
return FALSE;
};
static VOID
MainWndCommand(PMAIN_WND_INFO Info,
WORD CmdId,
HWND hControl)
{
UNREFERENCED_PARAMETER(hControl);
switch (CmdId)
{
case ID_PROP:
{
if (Info->SelectedItem != NO_ITEM_SELECTED)
{
Info->bDlgOpen = TRUE;
OpenPropSheet(Info);
Info->bDlgOpen = FALSE;
SetMenuAndButtonStates(Info);
}
}
break;
case ID_REFRESH:
{
RefreshServiceList(Info);
Info->SelectedItem = NO_ITEM_SELECTED;
/* disable menus and buttons */
SetMenuAndButtonStates(Info);
/* clear the service in the status bar */
SendMessage(Info->hStatus,
SB_SETTEXT,
1,
_T('\0'));
}
break;
case ID_EXPORT:
{
ExportFile(Info);
SetFocus(Info->hListView);
}
break;
case ID_CREATE:
{
INT ret;
ret = DialogBoxParam(hInstance,
MAKEINTRESOURCE(IDD_DLG_CREATE),
Info->hMainWnd,
CreateDialogProc,
(LPARAM)Info);
if (ret == IDOK)
RefreshServiceList(Info);
SetFocus(Info->hListView);
}
break;
case ID_DELETE:
{
if (Info->pCurrentService->ServiceStatusProcess.dwCurrentState != SERVICE_RUNNING)
{
DialogBoxParam(hInstance,
MAKEINTRESOURCE(IDD_DLG_DELETE),
Info->hMainWnd,
DeleteDialogProc,
(LPARAM)Info);
}
else
{
TCHAR Buf[60];
LoadString(hInstance,
IDS_DELETE_STOP,
Buf,
sizeof(Buf) / sizeof(TCHAR));
DisplayString(Buf);
}
SetFocus(Info->hListView);
}
break;
case ID_START:
{
if (DoStart(Info, NULL))
{
UpdateServiceStatus(Info->pCurrentService);
ChangeListViewText(Info, Info->pCurrentService, LVSTATUS);
SetMenuAndButtonStates(Info);
SetFocus(Info->hListView);
}
}
break;
case ID_STOP:
if (DoStop(Info))
{
UpdateServiceStatus(Info->pCurrentService);
ChangeListViewText(Info, Info->pCurrentService, LVSTATUS);
SetMenuAndButtonStates(Info);
SetFocus(Info->hListView);
}
break;
case ID_PAUSE:
DoPause(Info);
break;
case ID_RESUME:
DoResume(Info);
break;
case ID_RESTART:
if (DoStop(Info))
{
DoStart(Info, NULL);
UpdateServiceStatus(Info->pCurrentService);
ChangeListViewText(Info, Info->pCurrentService, LVSTATUS);
SetMenuAndButtonStates(Info);
SetFocus(Info->hListView);
}
break;
case ID_HELP:
MessageBox(NULL,
_T("Help is not yet implemented\n"),
_T("Note!"),
MB_OK | MB_ICONINFORMATION);
SetFocus(Info->hListView);
break;
case ID_EXIT:
PostMessage(Info->hMainWnd,
WM_CLOSE,
0,
0);
break;
case ID_VIEW_LARGE:
SetListViewStyle(Info->hListView,
LVS_ICON);
CheckMenuRadioItem(GetMenu(Info->hMainWnd),
ID_VIEW_LARGE,
ID_VIEW_DETAILS,
ID_VIEW_LARGE,
MF_BYCOMMAND);
break;
case ID_VIEW_SMALL:
SetListViewStyle(Info->hListView,
LVS_SMALLICON);
CheckMenuRadioItem(GetMenu(Info->hMainWnd),
ID_VIEW_LARGE,
ID_VIEW_DETAILS,
ID_VIEW_SMALL,
MF_BYCOMMAND);
break;
case ID_VIEW_LIST:
SetListViewStyle(Info->hListView,
LVS_LIST);
CheckMenuRadioItem(GetMenu(Info->hMainWnd),
ID_VIEW_LARGE,
ID_VIEW_DETAILS,
ID_VIEW_LIST,
MF_BYCOMMAND);
break;
case ID_VIEW_DETAILS:
SetListViewStyle(Info->hListView,
LVS_REPORT);
CheckMenuRadioItem(GetMenu(Info->hMainWnd),
ID_VIEW_LARGE,
ID_VIEW_DETAILS,
ID_VIEW_DETAILS,
MF_BYCOMMAND);
break;
case ID_VIEW_CUST:
break;
case ID_ABOUT:
DialogBox(hInstance,
MAKEINTRESOURCE(IDD_ABOUTBOX),
Info->hMainWnd,
AboutDialogProc);
SetFocus(Info->hListView);
break;
}
}
// callback function for the splitter window.
LRESULT CALLBACK
TabEditorSplitter::WndProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
{
TabEditorSplitter *ptabsplitter =(TabEditorSplitter*)GetWindowLongPtr(hwnd, GWLP_USERDATA);
HBRUSH hbr;
RECT rc;
switch(message)
{
case WM_NCCREATE:
// Get the initial creation pointer to the window object
ptabsplitter = (TabEditorSplitter *)((CREATESTRUCT *)lparam)->lpCreateParams;
ptabsplitter->m_hwnd = hwnd;
SetWindowLongPtr(hwnd, GWLP_USERDATA,(LONG_PTR)ptabsplitter);
break;
case WM_PAINT:
return ptabsplitter->OnPaint();
case WM_MOUSEMOVE:
ptabsplitter->MouseMove();
return 0;
case WM_MOVE:
//return ptabsplitter->OnPaint();
InvalidateRect(ptabsplitter->m_hwnd, NULL, FALSE); // hav to test it
UpdateWindow(hwnd);
return 0;
case WM_LBUTTONDOWN:
ptabsplitter->m_hwndprevfocus = GetFocus();
ptabsplitter->m_prevstyle = GetWindowLongPtr(ptabsplitter->m_hwndparent, GWL_STYLE);
SetWindowLongPtr(ptabsplitter->m_hwndparent, GWL_STYLE, ptabsplitter->m_prevstyle & ~WS_CLIPCHILDREN);
SetFocus(hwnd);
SetCapture(hwnd);
ptabsplitter->m_isdragged = wyTrue;
ptabsplitter->MouseMove(wyTrue);
break;
case WM_LBUTTONUP:
ReleaseCapture();
break;
case WM_CAPTURECHANGED:
if(ptabsplitter->m_isdragged == wyTrue)
{
ptabsplitter->EndDrag(wyTrue);
SetWindowLongPtr(ptabsplitter->m_hwndparent, GWL_STYLE, ptabsplitter->m_prevstyle);
if(ptabsplitter->m_isdlgsplitter == wyTrue)
PostMessage(GetParent(hwnd), UM_SPLITTERRESIZED, 0, 0);
else
{
ptabsplitter->Resizeall();
InvalidateRect(hwnd, NULL, TRUE);
UpdateWindow(hwnd);
}
ptabsplitter->m_isdragged = wyFalse;
if(ptabsplitter->m_hwndprevfocus)
{
SetFocus(ptabsplitter->m_hwndprevfocus);
ptabsplitter->m_hwndprevfocus = NULL;
}
}
break;
case WM_ERASEBKGND:
if(ptabsplitter->m_isdlgsplitter == wyFalse &&
wyTheme::GetBrush(BRUSH_HSPLITTER, &hbr))
{
GetClientRect(hwnd, &rc);
FillRect((HDC)wparam, &rc, hbr);
return 1;
}
}
return(DefWindowProc(hwnd, message, wparam, lparam));
}
static LRESULT CALLBACK
MainWndProc(HWND hwnd,
UINT msg,
WPARAM wParam,
LPARAM lParam)
{
PMAIN_WND_INFO Info;
LRESULT Ret = 0;
/* Get the window context */
Info = (PMAIN_WND_INFO)GetWindowLongPtr(hwnd,
GWLP_USERDATA);
if (Info == NULL && msg != WM_CREATE)
{
goto HandleDefaultMessage;
}
switch(msg)
{
case WM_CREATE:
{
Info = (PMAIN_WND_INFO)(((LPCREATESTRUCT)lParam)->lpCreateParams);
/* Initialize the main window context */
Info->hMainWnd = hwnd;
Info->SelectedItem = NO_ITEM_SELECTED;
SetWindowLongPtr(hwnd,
GWLP_USERDATA,
(LONG_PTR)Info);
if (!InitMainWnd(Info))
return -1;
/* Fill the list-view before showing the main window */
RefreshServiceList(Info);
/* Show the window */
ShowWindow(hwnd,
Info->nCmdShow);
SetFocus(Info->hListView);
}
break;
case WM_SIZE:
{
MainWndResize(Info,
LOWORD(lParam),
HIWORD(lParam));
}
break;
case WM_NOTIFY:
{
LPNMHDR pnmhdr = (LPNMHDR)lParam;
switch (pnmhdr->code)
{
case NM_DBLCLK:
{
POINT pt;
RECT rect;
GetCursorPos(&pt);
GetWindowRect(Info->hListView, &rect);
if (PtInRect(&rect, pt))
{
SendMessage(hwnd,
WM_COMMAND,
//ID_PROP,
MAKEWPARAM((WORD)ID_PROP, (WORD)0),
0);
}
//OpenPropSheet(Info);
}
break;
case NM_RETURN:
{
SendMessage(hwnd,
WM_COMMAND,
//ID_PROP,
MAKEWPARAM((WORD)ID_PROP, (WORD)0),
0);
}
break;
case LVN_COLUMNCLICK:
{
LPNMLISTVIEW pnmv = (LPNMLISTVIEW) lParam;
(void)ListView_SortItems(Info->hListView,
CompareFunc,
pnmv->iSubItem);
bSortAscending = !bSortAscending;
}
break;
case LVN_ITEMCHANGED:
{
LPNMLISTVIEW pnmv = (LPNMLISTVIEW) lParam;
if (pnmv->uNewState != 0)
{
ListViewSelectionChanged(Info, pnmv);
SetMenuAndButtonStates(Info);
}
}
break;
case TTN_GETDISPINFO:
{
LPTOOLTIPTEXT lpttt;
UINT idButton;
lpttt = (LPTOOLTIPTEXT)lParam;
/* Specify the resource identifier of the descriptive
* text for the given button. */
idButton = (UINT)lpttt->hdr.idFrom;
switch (idButton)
{
case ID_PROP:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_PROP);
break;
case ID_REFRESH:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_REFRESH);
break;
case ID_EXPORT:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_EXPORT);
break;
case ID_CREATE:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_CREATE);
break;
case ID_DELETE:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_DELETE);
break;
case ID_START:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_START);
break;
case ID_STOP:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_STOP);
break;
case ID_PAUSE:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_PAUSE);
break;
case ID_RESTART:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_RESTART);
break;
}
}
break;
}
}
break;
case WM_CONTEXTMENU:
{
POINT pt;
RECT lvRect;
INT xPos = GET_X_LPARAM(lParam);
INT yPos = GET_Y_LPARAM(lParam);
GetCursorPos(&pt);
/* display popup when cursor is in the list view */
GetWindowRect(Info->hListView, &lvRect);
if (PtInRect(&lvRect, pt))
{
TrackPopupMenuEx(GetSubMenu(Info->hShortcutMenu, 0),
TPM_RIGHTBUTTON,
xPos,
yPos,
Info->hMainWnd,
NULL);
}
}
break;
case WM_COMMAND:
{
MainWndCommand(Info,
LOWORD(wParam),
(HWND)lParam);
goto HandleDefaultMessage;
}
case WM_MENUSELECT:
{
if (Info->hStatus != NULL)
{
if (!MainWndMenuHint(Info,
LOWORD(wParam),
MainMenuHintTable,
sizeof(MainMenuHintTable) / sizeof(MainMenuHintTable[0]),
IDS_HINT_BLANK))
{
MainWndMenuHint(Info,
LOWORD(wParam),
SystemMenuHintTable,
sizeof(SystemMenuHintTable) / sizeof(SystemMenuHintTable[0]),
IDS_HINT_BLANK);
}
}
}
break;
case WM_ENTERMENULOOP:
{
Info->bInMenuLoop = TRUE;
UpdateMainStatusBar(Info);
break;
}
case WM_EXITMENULOOP:
{
Info->bInMenuLoop = FALSE;
UpdateMainStatusBar(Info);
break;
}
case WM_CLOSE:
{
HeapFree(ProcessHeap,
0,
Info->pAllServices);
DestroyMenu(Info->hShortcutMenu);
DestroyWindow(hwnd);
}
break;
case WM_DESTROY:
{
HeapFree(ProcessHeap,
0,
Info);
SetWindowLongPtr(hwnd,
GWLP_USERDATA,
0);
PostQuitMessage(0);
}
break;
default:
{
HandleDefaultMessage:
Ret = DefWindowProc(hwnd,
msg,
wParam,
lParam);
}
break;
}
return Ret;
}
void CUIListBox::OnLButtonDown(POINT point)
{
SetFocus();
if (m_ScrollBar.ContainsPoint(point))
{
m_ScrollBar.OnLButtonDown(point);
return;
}
int nClicked = getItemIndexByPoint(point);
if (nClicked!=-1)
{
SetPressed(true);
m_nSelected = nClicked;
//if(!(wParam & MK_SHIFT))??????????????????
// m_nSelStart = m_nSelected;??????????????????
// If this is a multi-selection listbox, update per-item
// selection data.
/**if(m_dwStyle & MULTISELECTION)
{
// Determine behavior based on the state of Shift and Ctrl
UIListBoxItem *pSelItem = m_Items[m_nSelected];
if((wParam & (MK_SHIFT|MK_CONTROL)) == MK_CONTROL)
{
// Control click. Reverse the selection of this item.
pSelItem->bSelected = !pSelItem->bSelected;
}
else if((wParam & (MK_SHIFT|MK_CONTROL)) == MK_SHIFT)
{
// Shift click. Set the selection for all items
// from last selected item to the current item.
// Clear everything else.
int nBegin = __min(m_nSelStart, m_nSelected);
int nEnd = __max(m_nSelStart, m_nSelected);
for(int i = 0; i < nBegin; ++i)
{
UIListBoxItem *pItem = m_Items[i];
pItem->bSelected = false;
}
for(int i = nEnd + 1; i < (int)m_Items.size(); ++i)
{
UIListBoxItem *pItem = m_Items[i];
pItem->bSelected = false;
}
for(int i = nBegin; i <= nEnd; ++i)
{
UIListBoxItem *pItem = m_Items[i];
pItem->bSelected = true;
}
}
else if((wParam & (MK_SHIFT|MK_CONTROL)) == (MK_SHIFT|MK_CONTROL))
{
// Control-Shift-click.
// The behavior is:
// Set all items from m_nSelStart to m_nSelected to
// the same state as m_nSelStart, not including m_nSelected.
// Set m_nSelected to selected.
int nBegin = __min(m_nSelStart, m_nSelected);
int nEnd = __max(m_nSelStart, m_nSelected);
// The two ends do not need to be set here.
bool bLastSelected = m_Items[m_nSelStart]->bSelected;
for(int i = nBegin + 1; i < nEnd; ++i)
{
UIListBoxItem *pItem = m_Items[i];
pItem->bSelected = bLastSelected;
}
pSelItem->bSelected = true;
// Restore m_nSelected to the previous value
// This matches the Windows behavior
m_nSelected = m_nSelStart;
}
else
{
// Simple click. Clear all items and select the clicked
// item.
for(int i = 0; i < (int)m_Items.size(); ++i)
{
UIListBoxItem *pItem = m_Items[i];
pItem->bSelected = false;
}
pSelItem->bSelected = true;
}
}*/ // End of multi-selection case
sendEvent(EVENT_LISTBOX_SELECTION);
}
}
void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
{
if ( event.IsWindowChange() ) {
// change pages
AdvanceSelection(event.GetDirection());
}
else {
// we get this event in 3 cases
//
// a) one of our pages might have generated it because the user TABbed
// out from it in which case we should propagate the event upwards and
// our parent will take care of setting the focus to prev/next sibling
//
// or
//
// b) the parent panel wants to give the focus to us so that we
// forward it to our selected page. We can't deal with this in
// OnSetFocus() because we don't know which direction the focus came
// from in this case and so can't choose between setting the focus to
// first or last panel child
//
// or
//
// c) we ourselves (see MSWTranslateMessage) generated the event
//
wxWindow * const parent = GetParent();
// the wxObject* casts are required to avoid MinGW GCC 2.95.3 ICE
const bool isFromParent = event.GetEventObject() == (wxObject*) parent;
const bool isFromSelf = event.GetEventObject() == (wxObject*) this;
const bool isForward = event.GetDirection();
if ( isFromSelf && !isForward )
{
// focus is currently on notebook tab and should leave
// it backwards (Shift-TAB)
event.SetCurrentFocus(this);
parent->HandleWindowEvent(event);
}
else if ( isFromParent || isFromSelf )
{
// no, it doesn't come from child, case (b) or (c): forward to a
// page but only if entering notebook page (i.e. direction is
// backwards (Shift-TAB) comething from out-of-notebook, or
// direction is forward (TAB) from ourselves),
if ( m_selection != wxNOT_FOUND &&
(!event.GetDirection() || isFromSelf) )
{
// so that the page knows that the event comes from it's parent
// and is being propagated downwards
event.SetEventObject(this);
wxWindow *page = m_pages[m_selection];
if ( !page->HandleWindowEvent(event) )
{
page->SetFocus();
}
//else: page manages focus inside it itself
}
else // otherwise set the focus to the notebook itself
{
SetFocus();
}
}
else
{
// it comes from our child, case (a), pass to the parent, but only
// if the direction is forwards. Otherwise set the focus to the
// notebook itself. The notebook is always the 'first' control of a
// page.
if ( !isForward )
{
SetFocus();
}
else if ( parent )
{
event.SetCurrentFocus(this);
parent->HandleWindowEvent(event);
}
}
}
}
LRESULT CALLBACK CMainWindow::WinMsgHandler(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
case WM_CREATE:
{
m_hwnd = hwnd;
Initialize();
}
break;
case WM_COMMAND:
{
return DoCommand(LOWORD(wParam));
}
break;
case WM_MOUSEWHEEL:
{
if (GET_KEYSTATE_WPARAM(wParam) == MK_SHIFT)
{
// scroll sideways
SendEditor(SCI_LINESCROLL, -GET_WHEEL_DELTA_WPARAM(wParam)/40, 0);
}
else
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
break;
case WM_SIZE:
{
RECT rect;
GetClientRect(*this, &rect);
if (m_bShowFindBar)
{
::SetWindowPos(m_hWndEdit, HWND_TOP,
rect.left, rect.top,
rect.right-rect.left, rect.bottom-rect.top-30,
SWP_SHOWWINDOW);
::SetWindowPos(m_FindBar, HWND_TOP,
rect.left, rect.bottom-30,
rect.right-rect.left, 30,
SWP_SHOWWINDOW);
}
else
{
::SetWindowPos(m_hWndEdit, HWND_TOP,
rect.left, rect.top,
rect.right-rect.left, rect.bottom-rect.top,
SWP_SHOWWINDOW);
::ShowWindow(m_FindBar, SW_HIDE);
}
}
break;
case WM_GETMINMAXINFO:
{
MINMAXINFO * mmi = (MINMAXINFO*)lParam;
mmi->ptMinTrackSize.x = 100;
mmi->ptMinTrackSize.y = 100;
return 0;
}
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
case WM_CLOSE:
{
CRegStdDWORD w = CRegStdDWORD(_T("Software\\TortoiseGit\\UDiffViewerWidth"), (DWORD)CW_USEDEFAULT);
CRegStdDWORD h = CRegStdDWORD(_T("Software\\TortoiseGit\\UDiffViewerHeight"), (DWORD)CW_USEDEFAULT);
CRegStdDWORD p = CRegStdDWORD(_T("Software\\TortoiseGit\\UDiffViewerPos"), 0);
RECT rect;
::GetWindowRect(*this, &rect);
w = rect.right-rect.left;
h = rect.bottom-rect.top;
p = MAKELONG(rect.left, rect.top);
}
::DestroyWindow(m_hwnd);
break;
case WM_SETFOCUS:
SetFocus(m_hWndEdit);
break;
case COMMITMONITOR_FINDMSGNEXT:
{
SendEditor(SCI_CHARRIGHT);
SendEditor(SCI_SEARCHANCHOR);
m_bMatchCase = !!wParam;
m_findtext = (LPCTSTR)lParam;
SendEditor(SCI_SEARCHNEXT, m_bMatchCase ? SCFIND_MATCHCASE : 0, (LPARAM)CUnicodeUtils::StdGetUTF8(m_findtext).c_str());
SendEditor(SCI_SCROLLCARET);
}
break;
case COMMITMONITOR_FINDMSGPREV:
{
SendEditor(SCI_SEARCHANCHOR);
m_bMatchCase = !!wParam;
m_findtext = (LPCTSTR)lParam;
SendEditor(SCI_SEARCHPREV, m_bMatchCase ? SCFIND_MATCHCASE : 0, (LPARAM)CUnicodeUtils::StdGetUTF8(m_findtext).c_str());
SendEditor(SCI_SCROLLCARET);
}
break;
case COMMITMONITOR_FINDEXIT:
{
RECT rect;
GetClientRect(*this, &rect);
m_bShowFindBar = false;
::ShowWindow(m_FindBar, SW_HIDE);
::SetWindowPos(m_hWndEdit, HWND_TOP,
rect.left, rect.top,
rect.right-rect.left, rect.bottom-rect.top,
SWP_SHOWWINDOW);
}
break;
case COMMITMONITOR_FINDRESET:
SendEditor(SCI_SETSELECTIONSTART, 0);
SendEditor(SCI_SETSELECTIONEND, 0);
SendEditor(SCI_SEARCHANCHOR);
break;
default:
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return 0;
};
NOEXPORT LRESULT CALLBACK window_proc(HWND main_window_handle,
UINT message, WPARAM wParam, LPARAM lParam) {
NOTIFYICONDATA nid;
POINT pt;
RECT rect;
SERVICE_OPTIONS *section;
unsigned int section_number;
#if 0
if(message!=WM_CTLCOLORSTATIC && message!=WM_TIMER)
s_log(LOG_DEBUG, "Window message: %d", message);
#endif
switch(message) {
case WM_CREATE:
#ifdef _WIN32_WCE
/* create command bar */
command_bar_handle=CommandBar_Create(ghInst, main_window_handle, 1);
if(!command_bar_handle)
error_box("CommandBar_Create");
if(!CommandBar_InsertMenubar(command_bar_handle, ghInst, IDM_MAINMENU, 0))
error_box("CommandBar_InsertMenubar");
if(!CommandBar_AddAdornments(command_bar_handle, 0, 0))
error_box("CommandBar_AddAdornments");
#endif
/* create child edit window */
edit_handle=CreateWindow(TEXT("EDIT"), NULL,
WS_CHILD|WS_VISIBLE|WS_HSCROLL|WS_VSCROLL|ES_MULTILINE|ES_READONLY,
0, 0, 0, 0, main_window_handle, (HMENU)IDE_EDIT, ghInst, NULL);
#ifndef _WIN32_WCE
SendMessage(edit_handle, WM_SETFONT,
(WPARAM)CreateFont(-12, 0, 0, 0, FW_DONTCARE, FALSE, FALSE, FALSE,
DEFAULT_CHARSET, OUT_RASTER_PRECIS, CLIP_DEFAULT_PRECIS,
PROOF_QUALITY, DEFAULT_PITCH, TEXT("Courier")),
MAKELPARAM(FALSE, 0)); /* no need to redraw right, now */
#endif
/* NOTE: there's no return statement here -> proceeding with resize */
case WM_SIZE:
GetClientRect(main_window_handle, &rect);
#ifdef _WIN32_WCE
MoveWindow(edit_handle, 0, CommandBar_Height(command_bar_handle),
rect.right, rect.bottom-CommandBar_Height(command_bar_handle), TRUE);
#else
MoveWindow(edit_handle, 0, 0, rect.right, rect.bottom, TRUE);
#endif
UpdateWindow(edit_handle);
/* CommandBar_Show(command_bar_handle, TRUE); */
return TRUE;
case WM_SETFOCUS:
SetFocus(edit_handle);
return TRUE;
case WM_TIMER:
if(visible)
update_logs();
return TRUE;
case WM_CLOSE:
ShowWindow(main_window_handle, SW_HIDE);
return TRUE;
case WM_SHOWWINDOW:
visible=wParam; /* setup global variable */
if(tray_menu_handle)
CheckMenuItem(tray_menu_handle, IDM_SHOW_LOG,
visible ? MF_CHECKED : MF_UNCHECKED);
if(visible)
update_logs();
return TRUE;
case WM_DESTROY:
#ifdef _WIN32_WCE
CommandBar_Destroy(command_bar_handle);
#else
if(main_menu_handle)
DestroyMenu(main_menu_handle);
#endif
if(tray_menu_handle)
DestroyMenu(tray_menu_handle);
ZeroMemory(&nid, sizeof nid);
nid.cbSize=sizeof nid;
nid.hWnd=main_window_handle;
nid.uID=1;
nid.uFlags=NIF_TIP; /* not really sure what to put here, but it works */
Shell_NotifyIcon(NIM_DELETE, &nid); /* this removes the icon */
PostQuitMessage(0);
KillTimer(main_window_handle, 0x29a);
return TRUE;
case WM_COMMAND:
if(wParam>=IDM_PEER_MENU && wParam<IDM_PEER_MENU+number_of_sections) {
for(section=service_options.next, section_number=0;
section && wParam!=IDM_PEER_MENU+section_number;
section=section->next, ++section_number)
;
if(!section)
return TRUE;
if(save_text_file(section->file, section->chain))
return TRUE;
#ifndef _WIN32_WCE
if(main_menu_handle)
CheckMenuItem(main_menu_handle, wParam, MF_CHECKED);
#endif
if(tray_menu_handle)
CheckMenuItem(tray_menu_handle, wParam, MF_CHECKED);
message_box(section->help, MB_ICONINFORMATION);
return TRUE;
}
switch(wParam) {
case IDM_ABOUT:
DialogBox(ghInst, TEXT("AboutBox"), main_window_handle,
(DLGPROC)about_proc);
break;
case IDM_SHOW_LOG:
if(visible) {
ShowWindow(main_window_handle, SW_HIDE); /* hide window */
} else {
ShowWindow(main_window_handle, SW_SHOWNORMAL); /* show window */
SetForegroundWindow(main_window_handle); /* bring on top */
}
break;
case IDM_CLOSE:
ShowWindow(main_window_handle, SW_HIDE); /* hide window */
break;
case IDM_EXIT:
if(!error_mode) /* signal_pipe is active */
signal_post(SIGNAL_TERMINATE);
DestroyWindow(main_window_handle);
break;
case IDM_SAVE_LOG:
if(!cmdline.service) /* security */
save_log();
break;
case IDM_EDIT_CONFIG:
#ifndef _WIN32_WCE
if(!cmdline.service) /* security */
edit_config(main_window_handle);
#endif
break;
case IDM_RELOAD_CONFIG:
if(error_mode) /* unlock daemon_thread */
SetEvent(config_ready);
else /* signal_pipe is active */
signal_post(SIGNAL_RELOAD_CONFIG);
break;
case IDM_REOPEN_LOG:
signal_post(SIGNAL_REOPEN_LOG);
break;
case IDM_MANPAGE:
#ifndef _WIN32_WCE
if(!cmdline.service) /* security */
ShellExecute(main_window_handle, TEXT("open"),
TEXT("stunnel.html"), NULL, NULL, SW_SHOWNORMAL);
#endif
break;
case IDM_HOMEPAGE:
#ifndef _WIN32_WCE
if(!cmdline.service) /* security */
ShellExecute(main_window_handle, TEXT("open"),
TEXT("http://www.stunnel.org/"), NULL, NULL, SW_SHOWNORMAL);
#endif
break;
}
return TRUE;
case WM_SYSTRAY: /* a taskbar event */
switch(lParam) {
#ifdef _WIN32_WCE
case WM_LBUTTONDOWN: /* no right mouse button on Windows CE */
GetWindowRect(GetDesktopWindow(), &rect); /* no cursor position */
pt.x=rect.right;
pt.y=rect.bottom-25;
#else
case WM_RBUTTONDOWN:
GetCursorPos(&pt);
#endif
SetForegroundWindow(main_window_handle);
TrackPopupMenuEx(GetSubMenu(tray_menu_handle, 0), TPM_BOTTOMALIGN,
pt.x, pt.y, main_window_handle, NULL);
PostMessage(main_window_handle, WM_NULL, 0, 0);
break;
#ifndef _WIN32_WCE
case WM_LBUTTONDBLCLK: /* switch log window visibility */
if(visible) {
ShowWindow(main_window_handle, SW_HIDE); /* hide window */
} else {
ShowWindow(main_window_handle, SW_SHOWNORMAL); /* show window */
SetForegroundWindow(main_window_handle); /* bring on top */
}
break;
#endif
}
return TRUE;
case WM_VALID_CONFIG:
valid_config();
return TRUE;
case WM_INVALID_CONFIG:
invalid_config();
return TRUE;
case WM_LOG:
win_log((LPSTR)wParam);
return TRUE;
case WM_NEW_CHAIN:
#ifndef _WIN32_WCE
if(main_menu_handle)
EnableMenuItem(main_menu_handle, IDM_PEER_MENU+wParam, MF_ENABLED);
#endif
if(tray_menu_handle)
EnableMenuItem(tray_menu_handle, IDM_PEER_MENU+wParam, MF_ENABLED);
return TRUE;
case WM_CLIENTS:
update_tray_icon((int)wParam);
return TRUE;
}
return DefWindowProc(main_window_handle, message, wParam, lParam);
}
LRESULT CALLBACK ChatView::WndProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam ) {
PAINTSTRUCT ps;
HDC hdc;
ChatView *p=(ChatView *) GetWindowLong(hWnd, GWL_USERDATA);
switch (message) {
case WM_CREATE:
{
p=(ChatView *) (((CREATESTRUCT *)lParam)->lpCreateParams);
SetWindowLong(hWnd, GWL_USERDATA, (LONG) p );
p->msgList=VirtualListView::ref(new VirtualListView(hWnd, std::string("Chat")));
p->msgList->setParent(hWnd);
p->msgList->showWindow(true);
p->msgList->wrapList=false;
p->msgList->colorInterleaving=true;
p->editWnd=DoCreateEditControl(hWnd);
p->calcEditHeight();
p->msgList->bindODRList(p->contact->messageList);
break;
}
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
{
//p->contact->nUnread=0;
RECT rc = {0, 0, 200, tabHeight};
SetBkMode(hdc, TRANSPARENT);
SetTextColor(hdc, p->contact->getColor());
p->contact->draw(hdc, rc);
int iconwidth= skin->getElementWidth();
skin->drawElement(hdc, icons::ICON_CLOSE, p->width-2-iconwidth, 0);
skin->drawElement(hdc, icons::ICON_TRASHCAN_INDEX, p->width-2-iconwidth*2, 0);
/*SetBkMode(hdc, TRANSPARENT);
LPCTSTR t=p->title.c_str();
DrawText(hdc, t, -1, &rc, DT_CALCRECT | DT_LEFT | DT_TOP);
DrawText(hdc, t, -1, &rc, DT_LEFT | DT_TOP);*/
}
EndPaint(hWnd, &ps);
break;
//case WM_KILLFOCUS:
// p->contact->nUnread=0;
// break;
case WM_SIZE:
{
HDWP hdwp;
RECT rc;
int height=GET_Y_LPARAM(lParam);
p->width=GET_X_LPARAM(lParam);
int ySplit=height-p->editHeight;
p->calcEditHeight();
// Calculate the display rectangle, assuming the
// tab control is the size of the client area.
SetRect(&rc, 0, 0,
GET_X_LPARAM(lParam), ySplit );
// Size the tab control to fit the client area.
hdwp = BeginDeferWindowPos(2);
/*DeferWindowPos(hdwp, dropdownWnd, HWND_TOP, 0, 0,
GET_X_LPARAM(lParam), 20,
SWP_NOZORDER
); */
DeferWindowPos(hdwp, p->msgList->getHWnd(), HWND_TOP, 0, tabHeight,
GET_X_LPARAM(lParam), ySplit-tabHeight,
SWP_NOZORDER
);
/*DeferWindowPos(hdwp, rosterWnd, HWND_TOP, 0, tabHeight,
GET_X_LPARAM(lParam), height-tabHeight,
SWP_NOZORDER
);*/
DeferWindowPos(hdwp, p->editWnd, NULL, 0, ySplit+1,
GET_X_LPARAM(lParam), height-ySplit-1,
SWP_NOZORDER
);
EndDeferWindowPos(hdwp);
break;
}
case WM_COMMAND:
{
if (wParam==IDS_SEND) {
p->sendJabberMessage();
}
if (wParam==IDC_COMPLETE) {
p->mucNickComplete();
}
if (wParam==IDC_COMPOSING) {
p->setComposingState(lParam!=0);
}
break;
}
/*case WM_CTLCOLORSTATIC:
case WM_CTLCOLORLISTBOX:
case WM_CTLCOLOREDIT:
{
//HGDIOBJ brush= GetStockObject(GRAY_BRUSH);
//HGDIOBJ pen= GetStockObject(WHITE_PEN);
SetBkColor(hdc, 0x808080);
SetTextColor(hdc, 0xffffff);
//SelectObject((HDC)wParam, brush);
//SelectObject((HDC)wParam, pen);
return (BOOL) GetStockObject(GRAY_BRUSH);
break;
}*/
case WM_LBUTTONDOWN:
SetFocus(hWnd);
if ((GET_Y_LPARAM(lParam))>tabHeight) break;
if (GET_X_LPARAM(lParam) > (p->width)-2-(skin->getElementWidth()) ) {
PostMessage(GetParent(hWnd), WM_COMMAND, TabsCtrl::CLOSETAB, 0);
break;
}
if (GET_X_LPARAM(lParam) > (p->width)-2-(skin->getElementWidth())*2) {
int result=MessageBox(
p->getHWnd(),
L"Are You sure want to clear this chat session?",
L"Clear chat",
MB_YESNO | MB_ICONWARNING);
if (result==IDYES) {
p->contact->messageList->clear();
p->msgList->moveCursorEnd();
}
break;
}
break;
case WM_DESTROY:
//TODO: Destroy all child data associated eith this window
return 0;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
static INT_PTR CALLBACK IPSDlgProc(HWND hDlg, UINT Msg, WPARAM wParam, LPARAM lParam)
{
switch (Msg) {
case WM_INITDIALOG: {
hIpsDlg = hDlg;
hIpsList = GetDlgItem(hIpsDlg, IDC_IPSTREE1);
hWhiteBGBrush = CreateSolidBrush(RGB(0xFF,0xFF,0xFF));
hDefPreview = LoadBitmap(hAppInst, MAKEINTRESOURCE(BMP_PREVIEW));
DWORD dwStyle = (DWORD) GetWindowLongPtr(hIpsList, GWL_STYLE);
dwStyle |= TVS_CHECKBOXES;
SetWindowLongPtr(hIpsList, GWL_STYLE, (LONG_PTR) dwStyle);
patchSettingInit();
initPatchPreviewPos();
wndInMid(hDlg, hScrnWnd);
SetFocus(hDlg); // Enable Esc=close
break;
}
case WM_COMMAND: {
int wID = LOWORD(wParam);
int Notify = HIWORD(wParam);
if (Notify == BN_CLICKED) {
switch (wID) {
case IDOK: {
ipsOkay();
break;
}
case IDCANCEL: {
SendMessage(hDlg, WM_CLOSE, 0, 0);
return 0;
}
case IDC_IPSCLEAR: {
clearPatches();
break;
}
case IDC_IPS_ENFORCE: {
bEnforceDep = !bEnforceDep;
break;
}
}
}
if (wID == IDC_IPS_LANG && Notify == CBN_SELCHANGE) {
nPatchLang = SendDlgItemMessage(hIpsDlg, IDC_IPS_LANG, CB_GETCURSEL, 0, 0);
TreeView_DeleteAllItems(hIpsList);
// rebuild ips list
rebuildIpsList();
return 0;
}
break;
}
case WM_NOTIFY: {
NMHDR* pNmHdr = (NMHDR*)lParam;
if (LOWORD(wParam) == IDC_IPSTREE1 && pNmHdr->code == TVN_SELCHANGED) {
refreshPatch();
return 1;
}
if (LOWORD(wParam) == IDC_IPSTREE1 && pNmHdr->code == NM_DBLCLK) {
// disable double-click node-expand
SetWindowLongPtr(hIpsDlg, DWLP_MSGRESULT, 1);
return 1;
}
if (LOWORD(wParam) == IDC_IPSTREE1 && pNmHdr->code == NM_CLICK) {
POINT cursorPos;
GetCursorPos(&cursorPos);
ScreenToClient(hIpsList, &cursorPos);
TVHITTESTINFO thi;
thi.pt = cursorPos;
TreeView_HitTest(hIpsList, &thi);
if (thi.flags == TVHT_ONITEMSTATEICON) {
TreeView_SelectItem(hIpsList, thi.hItem);
// check state and get patch index
int id = checkPatchState(thi.hItem);
// apply patch relations
applyRelations(id);
}
return 1;
}
SetWindowLongPtr(hIpsDlg, DWLP_MSGRESULT, CDRF_DODEFAULT);
return 1;
}
case WM_CTLCOLORSTATIC:
if ((HWND)lParam == GetDlgItem(hIpsDlg, IDC_TEXTCOMMENT)) {
return (BOOL)hWhiteBGBrush;
}
break;
case WM_CLOSE:
patchSettingExit();
break;
}
return 0;
}
//---------------------------------------------------------------------
// メッセージボックスのプロシージャ
LRESULT CALLBACK MyMessageBoxProc(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp)
{
static LPMSGBOXDATA lpMsgBoxData;
static HICON hIcon;
static BOOL bDrawIcon; // アイコンを貼るかどうか
static RECT textRt; // テキスト描画領域
static SIZE sizeText; // テキスト描画領域のサイズ
static LONG width,height; // ウィンドウ幅、高さ
static HWND hWndBt[3];
static int nResult[3];
static HFONT hFont; // ボタン用フォント
static LONG nButtonNum; // ボタン数
static BOOL bOwnerDraw; // ボタンをオーナードローするか
static UINT uCurFocus; // 現在のフォーカスボタンID
CHAR szBtStr[3][CHR_BUF];
LONG x1,x2,x3,y;
HINSTANCE hInst;
HDC hDC;
LONG nButtonSize;
UINT uIconType,uMskType;
DWORD dwStyle;
COLORREF rgbStr;
WORD i;
switch (msg) {
case WM_INITDIALOG: // ダイアログ初期化
lpMsgBoxData = (LPMSGBOXDATA)lp;
hInst = (HINSTANCE)GetWindowLong(hWnd, GWL_HINSTANCE);
// アイコンロード
uIconType = lpMsgBoxData->uType & MB_ICONMASK;
if(uIconType > 0) bDrawIcon = TRUE;
else bDrawIcon = FALSE;
switch(uIconType){
case MB_ICONQUESTION:
hIcon = LoadIcon(NULL,IDI_QUESTION);
break;
case MB_ICONINFORMATION:
hIcon = LoadIcon(NULL,IDI_INFORMATION);
break;
case MB_ICONEXCLAMATION:
hIcon = LoadIcon(NULL,IDI_EXCLAMATION);
break;
case MB_ICONERROR:
hIcon = LoadIcon(NULL,IDI_ERROR);
}
// テキスト領域の幅と高さ取得
GetTextSize(hWnd,lpMsgBoxData->lpText,&sizeText,MSGBOXTEXTSIZE);
// テキスト描画領域セット
textRt.top = MSGBOXMERGIN + (sizeText.cy > MSGBOXICONHEIGHT? 0 : (MSGBOXICONHEIGHT-sizeText.cy)/2);
textRt.left = MSGBOXICONWIDTH*bDrawIcon+MSGBOXMERGIN;
textRt.right = textRt.left + sizeText.cx;
textRt.bottom = textRt.top + sizeText.cy;
// タイトルセット
SetWindowText(hWnd,lpMsgBoxData->lpCaption);
// ボタン名設定
for(i=0;i<3;i++) nResult[i] = 0;
switch(lpMsgBoxData->uType & MB_TYPEMASK){
default:
nResult[0] = IDOK;
wsprintf(szBtStr[0],"OK");
nButtonNum = 1;
break;
case MB_OKCANCEL:
nResult[0] = IDOK;
wsprintf(szBtStr[0],"OK");
nResult[1] = IDCANCEL;
wsprintf(szBtStr[1],"キャンセル");
nButtonNum = 2;
break;
case MB_YESNOCANCEL:
nResult[0] = IDYES;
wsprintf(szBtStr[0],"はい(&Y)");
nResult[1] = IDNO;
wsprintf(szBtStr[1],"いいえ(&N)");
nResult[2] = IDCANCEL;
wsprintf(szBtStr[2],"キャンセル");
nButtonNum = 3;
break;
case MB_YESNO:
nResult[0] = IDYES;
wsprintf(szBtStr[0],"はい(&Y)");
nResult[1] = IDNO;
wsprintf(szBtStr[1],"いいえ(&N)");
nButtonNum = 2;
}
// ウィンドウリサイズ
nButtonSize =MSGBOXBTWIDTH*nButtonNum+MSGBOXMERGIN*(nButtonNum-1);
width = max(nButtonSize+MSGBOXMERGIN*2,sizeText.cx+MSGBOXMERGIN*2+MSGBOXICONWIDTH*bDrawIcon);
height = max(MSGBOXICONHEIGHT*bDrawIcon,sizeText.cy)+ MSGBOXMERGIN*3+MSGBOXBTHEIGHT;
SetWindowPos(hWnd,NULL,0,0,
width+GetSystemMetrics(SM_CXFIXEDFRAME)*2,
height+GetSystemMetrics(SM_CYCAPTION)+GetSystemMetrics(SM_CYFIXEDFRAME)*2
,SWP_NOMOVE|SWP_NOREPOSITION);
// ボタン作成
x1 = (width - nButtonSize)/2;
x2 = x1 + MSGBOXBTWIDTH+MSGBOXMERGIN;
x3 = x2 + MSGBOXBTWIDTH+MSGBOXMERGIN;
y = height-MSGBOXBTHEIGHT - MSGBOXMERGIN;
uMskType = lpMsgBoxData->uType & MB_DEFMASK;
bOwnerDraw = lpMsgBoxData->bOwnerDraw; // オーナードローか
// ボタン 1
if((nButtonNum >=2 && uMskType == MB_DEFBUTTON2) ||
(nButtonNum == 3 && uMskType == MB_DEFBUTTON3))
dwStyle = WS_CHILD|WS_VISIBLE|BS_PUSHBUTTON|WS_TABSTOP;
else dwStyle = WS_CHILD|WS_VISIBLE|BS_DEFPUSHBUTTON|WS_TABSTOP;
if(bOwnerDraw) dwStyle |= BS_OWNERDRAW;
CreateWindow("BUTTON","bt1",dwStyle,x1,y,MSGBOXBTWIDTH,MSGBOXBTHEIGHT,hWnd,(HMENU)IDC_BT1,hInst,NULL);
// ボタン 2
if(nButtonNum >= 2){
if(uMskType == MB_DEFBUTTON2)
dwStyle = WS_CHILD|WS_VISIBLE|BS_DEFPUSHBUTTON|WS_TABSTOP;
else dwStyle = WS_CHILD|WS_VISIBLE|BS_PUSHBUTTON|WS_TABSTOP;
if(bOwnerDraw) dwStyle |= BS_OWNERDRAW;
CreateWindow("BUTTON","bt2",dwStyle,x2,y,MSGBOXBTWIDTH,MSGBOXBTHEIGHT,hWnd,(HMENU)IDC_BT2,hInst,NULL);
}
// ボタン 3
if(nButtonNum == 3){
if(uMskType == MB_DEFBUTTON3)
dwStyle = WS_CHILD|WS_VISIBLE|BS_DEFPUSHBUTTON|WS_TABSTOP;
else dwStyle = WS_CHILD|WS_VISIBLE|BS_PUSHBUTTON|WS_TABSTOP;
if(bOwnerDraw) dwStyle |= BS_OWNERDRAW;
CreateWindow("BUTTON","bt3",dwStyle,x3,y,MSGBOXBTWIDTH,MSGBOXBTHEIGHT,hWnd,(HMENU)IDC_BT3,hInst,NULL);
}
// ボタン用フォント作成
if(!bOwnerDraw) hFont=CreateFont(10,0,0,0,FW_NORMAL,FALSE,FALSE,FALSE,DEFAULT_CHARSET
,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,DEFAULT_PITCH,"ＭＳ Ｐゴシック");
// ボタンにフォントと文字セット
hWndBt[0] = GetDlgItem(hWnd,IDC_BT1);
hWndBt[1] = GetDlgItem(hWnd,IDC_BT2);
hWndBt[2] = GetDlgItem(hWnd,IDC_BT3);
for(i=0;i<3;i++)
{
// フォントセット
if(!bOwnerDraw) SendMessage(hWndBt[i],WM_SETFONT,(WPARAM)hFont,(LPARAM)MAKELPARAM(TRUE,0));
SetWindowText(hWndBt[i],szBtStr[i]);
}
// フォーカス移動
switch(uMskType){
case MB_DEFBUTTON2:
uCurFocus = IDC_BT2;
SetFocus(hWndBt[1]);
break;
case MB_DEFBUTTON3:
uCurFocus = IDC_BT3;
SetFocus(hWndBt[2]);
break;
default:
uCurFocus = IDC_BT1;
SetFocus(hWndBt[0]);
}
// 中心移動
SetDlgCenter(hWnd);
// forgrand
if(lpMsgBoxData->uType & MB_SETFOREGROUND) SetForegroundWindow(hWnd);
break;
case WM_CTLCOLORDLG: // 背景色を変えたい場合
if(bOwnerDraw){
SetBkMode((HDC)wp,TRANSPARENT);
SetTextColor((HDC)wp,RGB(255,255,255)) ;
return ((BOOL)GetStockObject(GRAY_BRUSH)) ;
}
break;
case WM_DRAWITEM: // ボタンのオーナー描画をする場合
if(bOwnerDraw){
UINT uCtlID,uButtonStat;
LPDRAWITEMSTRUCT lpDrawItem;
uCtlID = (UINT)wp;
lpDrawItem = (LPDRAWITEMSTRUCT)lp;
uButtonStat = MYID_RELEASEBUTTON;
if(lpDrawItem->CtlType == ODT_BUTTON){ // ボタンならば
if(lpDrawItem->itemAction & ODA_SELECT){ // 選択
if(lpDrawItem->itemState & ODS_FOCUS) uButtonStat = MYID_PUSHBUTTON;
}
else if(lpDrawItem->itemAction & ODA_FOCUS){ // フォーカス
// 自前でフォーカスの管理をする
if(lpDrawItem->itemState & ODS_FOCUS) uCurFocus = uCtlID;
}
// ボタン描画
DrawMsgButton(hWnd,uCtlID,lpDrawItem->hDC,lpDrawItem->rcItem,uCurFocus,uButtonStat);
}
}
break;
case WM_PAINT: // 描画
hDC = GetDC(hWnd);
if(bOwnerDraw){
// 枠描画
DrawMyFrame(hDC,MSGBOXMERGIN-2,MSGBOXMERGIN-2,
width - (MSGBOXMERGIN-2)*2,height-MSGBOXBTHEIGHT - MSGBOXMERGIN-(MSGBOXMERGIN-2)*2
,RGB(0,0,0));
rgbStr = RGB(255,255,255);
}
else rgbStr = RGB(0,0,0);
// アイコン
if(bDrawIcon)
DrawIcon(hDC,MSGBOXMERGIN+1,MSGBOXMERGIN+1,hIcon);
// テキスト
DrawMyStringJP(hDC,lpMsgBoxData->lpText,
textRt.left,textRt.top,textRt.right-textRt.left,
textRt.bottom-textRt.top,MSGBOXTEXTSIZE,rgbStr);
ReleaseDC(hWnd,hDC);
break;
case WM_SETTEXT: // ダイアログのタイトル変更
// DefWindowProc に処理してもらう(なんか胡散臭いやり方 (^^; )
return(DefWindowProc(hWnd, msg, wp, lp));
break;
case WM_COMMAND:
// オーナードローの時はコントロール ID をもらえないので
// 自前でフォーカス管理をする
if(bOwnerDraw && HIWORD(wp)== BN_CLICKED) wp = uCurFocus;
switch (LOWORD(wp)) {
case IDC_BT1:
if(!bOwnerDraw) DeleteObject(hFont);
EndDialog(hWnd, nResult[0]);
return TRUE;
case IDC_BT2:
if(!bOwnerDraw) DeleteObject(hFont);
EndDialog(hWnd, nResult[1]);
return TRUE;
case IDC_BT3:
if(!bOwnerDraw) DeleteObject(hFont);
EndDialog(hWnd, nResult[2]);
return TRUE;
case IDCANCEL:
if(!bOwnerDraw) DeleteObject(hFont);
EndDialog(hWnd, IDCANCEL);
return TRUE;
}
break;
default:
break;
}
return FALSE;
}
BOOL CALLBACK TextChat::TextChatDlgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
TextChat* _this = (TextChat *) GetWindowLong(hWnd, GWL_USERDATA);
switch (uMsg)
{
case WM_INITDIALOG:
{
SetWindowLong(hWnd, GWL_USERDATA, lParam);
TextChat *_this = (TextChat *) lParam;
if (_this->m_szLocalText == NULL || _this->m_szRemoteText == NULL)
EndDialog(hWnd, FALSE);
// Window always on top if Fullscreen On
if (_this->m_pCC->InFullScreenMode())
{
RECT Rect;
GetWindowRect(hWnd, &Rect);
SetWindowPos(hWnd,
HWND_TOPMOST,
Rect.left,
Rect.top,
Rect.right - Rect.left,
Rect.bottom - Rect.top,
SWP_SHOWWINDOW);
}
// CentreWindow(hWnd);
_this->m_hWnd = hWnd;
_this->m_hDlg = hWnd;
if (_snprintf(_this->m_szRemoteName,MAXNAMESIZE-1,"%s", _this->m_pCC->m_desktopName) < 0 )
{
_this->m_szRemoteName[MAXNAMESIZE-4]='.';
_this->m_szRemoteName[MAXNAMESIZE-3]='.';
_this->m_szRemoteName[MAXNAMESIZE-2]='.';
_this->m_szRemoteName[MAXNAMESIZE-1]=0x00;
}
const long lTitleBufSize=256;
char szTitle[lTitleBufSize];
_snprintf(szTitle,lTitleBufSize-1," Chat with <%s> - Ultr@VNC",_this->m_szRemoteName);
SetWindowText(hWnd, szTitle);
// Trunc the remote name for display in Chat Area before the first parenthesis, if any.
char *p = strchr(_this->m_szRemoteName, '(');
if (p != NULL) *(p - 1) = '\0';
// Chat area
_this->SetTextFormat(); // Set character formatting and background color
SendDlgItemMessage( hWnd, IDC_CHATAREA_EDIT, EM_SETBKGNDCOLOR, FALSE, 0xFFFFFF );
memset(_this->m_szLocalText, 0, TEXTMAXSIZE);
// if (!_this->m_fPersistentTexts)
{
memset(_this->m_szLastLocalText, 0, TEXTMAXSIZE);
memset(_this->m_szTextBoxBuffer, 0, TEXTMAXSIZE); // Clear Chat area
// Load and display diclaimer message
// sf@2005 - Only if the DSMplugin is used
if (!_this->m_pCC->m_fUsePlugin)
{
if (LoadString(_this->m_pApp->m_instance, IDS_WARNING, _this->m_szRemoteText, TEXTMAXSIZE -1) )
_this->PrintMessage(_this->m_szRemoteText, NULL ,GREY);
}
}
SetDlgItemText(hWnd, IDC_INPUTAREA_EDIT, _this->m_szLocalText);
SetDlgItemText(hWnd, IDC_CHATAREA_EDIT, _this->m_szTextBoxBuffer); // Chat area
// Scroll down the chat window
// The following seems necessary under W9x & Me if we want the Edit to scroll to bottom...
SCROLLINFO si;
ZeroMemory(&si, sizeof(SCROLLINFO));
si.cbSize = sizeof(SCROLLINFO);
si.fMask = SIF_RANGE|SIF_PAGE;
GetScrollInfo(GetDlgItem(hWnd, IDC_CHATAREA_EDIT), SB_VERT, &si);
si.nPos = si.nMax - max(si.nPage - 1, 0);
SendDlgItemMessage(hWnd, IDC_CHATAREA_EDIT, WM_VSCROLL, MAKELONG(SB_THUMBPOSITION, si.nPos), 0L);
// This line does the bottom scrolling correctly under NT4,W2K, XP...
// SendDlgItemMessage(m_hDlg, IDC_CHATAREA_EDIT, WM_VSCROLL, SB_BOTTOM, 0L);
// SendDlgItemMessage(hWnd, IDC_PERSISTENT_CHECK, BM_SETCHECK, _this->m_fPersistentTexts, 0);
// Tell the other side to open the TextChat Window
_this->SendTextChatRequest(CHAT_OPEN);
SetForegroundWindow(hWnd);
return TRUE;
}
// break;
case WM_COMMAND:
switch (LOWORD(wParam))
{
/*
case IDC_PERSISTENT_CHECK:
_this->m_fPersistentTexts = (SendDlgItemMessage(hWnd, IDC_PERSISTENT_CHECK, BM_GETCHECK, 0, 0) == BST_CHECKED);
return TRUE;
*/
case IDOK:
// Server orders to close TextChat
EndDialog(hWnd, FALSE);
return TRUE;
case IDCANCEL:
_this->SendTextChatRequest(CHAT_CLOSE); // Server must close TextChat
EndDialog(hWnd, FALSE);
return TRUE;
case IDC_SEND_B:
{
memset(_this->m_szLocalText,0,TEXTMAXSIZE);
UINT nRes = GetDlgItemText( hWnd, IDC_INPUTAREA_EDIT, _this->m_szLocalText, TEXTMAXSIZE-1);
strcat(_this->m_szLocalText, "\n");
_this->SendLocalText();
SetFocus(GetDlgItem(hWnd, IDC_INPUTAREA_EDIT));
}
return TRUE;
case IDC_HIDE_B:
_this->ShowChatWindow(false);
return TRUE;
case IDC_INPUTAREA_EDIT:
if(HIWORD(wParam) == EN_UPDATE)
{
memset(_this->m_szLocalText,0,TEXTMAXSIZE);
UINT nRes = GetDlgItemText( hWnd, IDC_INPUTAREA_EDIT, _this->m_szLocalText, TEXTMAXSIZE);
if (strstr(_this->m_szLocalText,"\n") >0 )
{
_this->SendLocalText();
}
}
return TRUE;
}
break;
case WM_SYSCOMMAND:
switch (LOWORD(wParam))
{
case SC_RESTORE:
_this->ShowChatWindow(true);
//SetFocus(GetDlgItem(hWnd, IDC_INPUTAREA_EDIT));
return TRUE;
}
break;
case WM_DESTROY:
// _this->SendTextChatRequest(_this, CHAT_FINISHED);
EndDialog(hWnd, FALSE);
return TRUE;
}
return 0;
}
BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
{
GLuint PixelFormat;
WNDCLASS wc;
DWORD dwExStyle;
DWORD dwStyle;
RECT WindowRect;
WindowRect.left=(long)0;
WindowRect.right=(long)width;
WindowRect.top=(long)0;
WindowRect.bottom=(long)height;
fullscreen=fullscreenflag;
Auto = new MilkshapeModel(); // memori untuk menahan/rem model
if ( Auto->loadModelData( ".\\data\\auto.ms3d" ) == false ) // Banyak Model Dan Cek Untuk Kesalahan
{
MessageBox( NULL, "Couldn't load the model Auto.ms3d", "Error", MB_OK | MB_ICONERROR );
return 0; // jika Model gagal Load maka keluar
}
Ruota = new MilkshapeModel(); // memori untuk menahan/rem model
if ( Ruota->loadModelData( ".\\data\\ruota.ms3d" ) == false ) // Banyak Model Dan Cek Untuk Kesalahan
{
MessageBox( NULL, "Couldn't load the model Ruota.ms3d", "Error", MB_OK | MB_ICONERROR );
return 0; // jika Model gagal Load maka keluar
}
hInstance = GetModuleHandle(NULL);
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wc.lpfnWndProc = (WNDPROC) WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = NULL;
wc.lpszMenuName = NULL;
wc.lpszClassName = "OpenGL";
if (!RegisterClass(&wc))
{
MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}
if (fullscreen)
{
DEVMODE dmScreenSettings;
memset(&dmScreenSettings,0,sizeof(dmScreenSettings));
dmScreenSettings.dmSize=sizeof(dmScreenSettings);
dmScreenSettings.dmPelsWidth = width;
dmScreenSettings.dmPelsHeight = height;
dmScreenSettings.dmBitsPerPel = bits;
dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;
if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
{
if (MessageBox(NULL,"The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?","NeHe GL",MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
{
fullscreen=FALSE;
}
else
{
MessageBox(NULL,"Program Will Now Close.","ERROR",MB_OK|MB_ICONSTOP);
return FALSE;
}
}
}
if (fullscreen)
{
dwExStyle=WS_EX_APPWINDOW;
dwStyle=WS_POPUP;
ShowCursor(FALSE);
}
else
{
dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
dwStyle=WS_OVERLAPPEDWINDOW;
}
AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle);
if (!(hWnd=CreateWindowEx( dwExStyle,
"OpenGL",
title,
dwStyle |
WS_CLIPSIBLINGS |
WS_CLIPCHILDREN,
0, 0,
WindowRect.right-WindowRect.left,
WindowRect.bottom-WindowRect.top,
NULL,
NULL,
hInstance,
NULL)))
{
KillGLWindow();
MessageBox(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}
static PIXELFORMATDESCRIPTOR pfd=
{
sizeof(PIXELFORMATDESCRIPTOR),
1,
PFD_DRAW_TO_WINDOW |
PFD_SUPPORT_OPENGL |
PFD_DOUBLEBUFFER,
PFD_TYPE_RGBA,
bits,
0, 0, 0, 0, 0, 0,
0,
0,
0,
0, 0, 0, 0,
16,
0,
0,
PFD_MAIN_PLANE,
0,
0, 0, 0
};
if (!(hDC=GetDC(hWnd)))
{
KillGLWindow();
MessageBox(NULL,"Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}
if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd)))
{
KillGLWindow();
MessageBox(NULL,"Can't Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}
if(!SetPixelFormat(hDC,PixelFormat,&pfd))
{
KillGLWindow();
MessageBox(NULL,"Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}
if (!(hRC=wglCreateContext(hDC)))
{
KillGLWindow();
MessageBox(NULL,"Can't Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}
if(!wglMakeCurrent(hDC,hRC))
{
KillGLWindow();
MessageBox(NULL,"Can't Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}
ShowWindow(hWnd,SW_SHOW);
SetForegroundWindow(hWnd);
SetFocus(hWnd);
ReSizeGLScene(width, height);
if (!InitGL())
{
KillGLWindow();
MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}
return TRUE;
}
BOOL CALLBACK vncConnDialog::vncConnDlgProc(HWND hwnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam) {
// This is a static method, so we don't know which instantiation we're
// dealing with. But we can get a pseudo-this from the parameter to
// WM_INITDIALOG, which we therafter store with the window and retrieve
// as follows:
vncConnDialog *_this = (vncConnDialog *) GetWindowLong(hwnd, GWL_USERDATA);
switch (uMsg) {
// Dialog has just been created
case WM_INITDIALOG:
{
// Save the lParam into our user data so that subsequent calls have
// access to the parent C++ object
SetWindowLong(hwnd, GWL_USERDATA, lParam);
vncConnDialog *_this = (vncConnDialog *) lParam;
// Make the text entry box active
SetFocus(GetDlgItem(hwnd, IDC_HOSTNAME_EDIT));
// Return success!
return TRUE;
}
// Dialog has just received a command
case WM_COMMAND:
switch (LOWORD(wParam)) {
// User clicked OK or pressed return
case IDOK:
{
char viewer[256];
char hostname[256];
VCard display_or_port;
// Get the viewer to connect to
GetDlgItemText(hwnd, IDC_HOSTNAME_EDIT, viewer, 256);
// Process the supplied viewer address
int result = sscanf(viewer, "%255[^:]:%u", hostname, &display_or_port);
if (result == 1) {
display_or_port = 0;
result = 2;
}
if (result == 2) {
// Correct a display number to a port number if required
if (display_or_port < 100) {
display_or_port += INCOMING_PORT_OFFSET;
}
// Attempt to create a new socket
VSocket *tmpsock;
tmpsock = new VSocket;
if (!tmpsock)
return TRUE;
// Connect out to the specified host on the VNCviewer listen port
// To be really good, we should allow a display number here but
// for now we'll just assume we're connecting to display zero
tmpsock->Create();
if (tmpsock->Connect(hostname, display_or_port)) {
// Add the new client to this server
_this->m_server->AddClient(tmpsock, TRUE, TRUE);
// And close the dialog
EndDialog(hwnd, TRUE);
} else {
// Print up an error message
MessageBox(NULL,
"Failed to connect to listening VNC viewer",
"Outgoing Connection",
MB_OK | MB_ICONEXCLAMATION );
delete tmpsock;
}
} else {
// We couldn't process the machine specification
MessageBox(NULL, "Unable to process specified hostname and display/port",
"Outgoing Connection", MB_OK | MB_ICONEXCLAMATION);
}
}
return TRUE;
// Cancel the dialog
case IDCANCEL:
EndDialog(hwnd, FALSE);
return TRUE;
};
break;
case WM_DESTROY:
EndDialog(hwnd, FALSE);
return TRUE;
}
return 0;
}
void RichEdit::LeftDown(Point p, dword flags)
{
useraction = true;
NextUndo();
SetFocus();
selclick = false;
tabmove = GetHotPos(p);
if(tabmove.table && tabmove.column >= -2) {
SaveTableFormat(tabmove.table);
SetCapture();
Move(text.GetCellPos(tabmove.table, 0, max(tabmove.column, 0)).pos);
return;
}
int c = GetHotSpot(p);
if(c >= 0 && objectpos >= 0) {
int pos = objectpos;
RectTracker tracker(*this);
RichObject obj = text.GetRichPos(pos).object;
tracker.MinSize(Size(16, 16))
.MaxSize(GetZoom() * pagesz)
.Animation()
.Dashed()
.KeepRatio(obj.IsKeepRatio());
int tx, ty;
switch(c) {
case 1:
tracker.SetCursorImage(Image::SizeVert());
tx = ALIGN_CENTER; ty = ALIGN_BOTTOM;
break;
case 2:
tracker.SetCursorImage(Image::SizeHorz());
tx = ALIGN_RIGHT; ty = ALIGN_CENTER;
break;
default:
tracker.SetCursorImage(Image::SizeBottomRight());
tx = ALIGN_RIGHT; ty = ALIGN_RIGHT;
break;
}
double zoom = GetZoom().AsDouble();
Size sz = obj.GetSize();
sz.cx = int(zoom * sz.cx + 0.5);
sz.cy = int(zoom * sz.cy + 0.5);
sz = tracker.Track(Rect(objectrect.Offseted(GetTextRect().left, -sb).TopLeft(), sz), tx, ty).Size();
sz.cx = int(sz.cx / zoom + 0.5);
sz.cy = int(sz.cy / zoom + 0.5);
obj.SetSize(sz);
ReplaceObject(obj);
}
else {
c = GetMousePos(p);
if(c >= 0) {
if(InSelection(c)) {
selclick = true;
return;
}
Move(c, flags & K_SHIFT);
mpos = c;
SetCapture();
if(cursorp.object && GetObjectRect(cursor).Offseted(GetTextRect().left, -sb).Contains(p))
SetObjectPos(cursor);
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : hwndDlg -
// uMsg -
// wParam -
// lParam -
// Output : static BOOL CALLBACK ChannelPropertiesDialogProc
//-----------------------------------------------------------------------------
static BOOL CALLBACK ChannelPropertiesDialogProc ( HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
switch(uMsg)
{
case WM_INITDIALOG:
// Insert code here to put the string (to find and replace with)
// into the edit controls.
// ...
{
g_Params.PositionSelf( hwndDlg );
SetDlgItemText( hwndDlg, IDC_CHANNELNAME, g_Params.m_szName );
HWND control = GetDlgItem( hwndDlg, IDC_ACTORCHOICE );
if ( !g_Params.m_bShowActors )
{
// Hide the combo box
if ( control )
{
ShowWindow( control, SW_HIDE );
}
control = GetDlgItem( hwndDlg, IDC_STATIC_ACTOR );
if ( control )
{
ShowWindow( control, SW_HIDE );
}
}
else
{
SendMessage( control, CB_RESETCONTENT, 0, 0 );
if ( g_Params.m_pScene )
{
for ( int i = 0 ; i < g_Params.m_pScene->GetNumActors() ; i++ )
{
CChoreoActor *actor = g_Params.m_pScene->GetActor( i );
if ( actor )
{
// add text to combo box
SendMessage( control, CB_ADDSTRING, 0, (LPARAM)actor->GetName() );
}
}
}
SendMessage( control, CB_SETCURSEL, (WPARAM)0, (LPARAM)0 );
}
SetWindowText( hwndDlg, g_Params.m_szDialogTitle );
SetFocus( GetDlgItem( hwndDlg, IDC_CHANNELNAME ) );
}
return FALSE;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDOK:
g_Params.m_szName[ 0 ] = 0;
GetDlgItemText( hwndDlg, IDC_CHANNELNAME, g_Params.m_szName, 256 );
if ( g_Params.m_bShowActors )
{
HWND control = GetDlgItem( hwndDlg, IDC_ACTORCHOICE );
if ( control )
{
SendMessage( control, WM_GETTEXT, (WPARAM)sizeof( g_Params.m_szSelectedActor ), (LPARAM)g_Params.m_szSelectedActor );
}
}
EndDialog( hwndDlg, 1 );
break;
case IDCANCEL:
EndDialog( hwndDlg, 0 );
break;
}
return TRUE;
}
return FALSE;
}
static LRESULT WINAPI IME_WindowProc(HWND hwnd, UINT msg, WPARAM wParam,
LPARAM lParam)
{
LRESULT rc = 0;
HIMC hIMC;
TRACE("Incoming Message 0x%x (0x%08lx, 0x%08lx)\n", msg, wParam, lParam);
/*
* Each UI window contains the current Input Context.
* This Input Context can be obtained by calling GetWindowLong
* with IMMGWL_IMC when the UI window receives a WM_IME_xxx message.
* The UI window can refer to this Input Context and handles the
* messages.
*/
hIMC = (HIMC)GetWindowLongPtrW(hwnd,IMMGWL_IMC);
if (!hIMC)
hIMC = RealIMC(FROM_X11);
/* if we have no hIMC there are many messages we cannot process */
if (hIMC == NULL)
{
switch (msg) {
case WM_IME_STARTCOMPOSITION:
case WM_IME_ENDCOMPOSITION:
case WM_IME_COMPOSITION:
case WM_IME_NOTIFY:
case WM_IME_CONTROL:
case WM_IME_COMPOSITIONFULL:
case WM_IME_SELECT:
case WM_IME_CHAR:
return 0L;
default:
break;
}
}
switch(msg)
{
case WM_CREATE:
{
LPIMEPRIVATE myPrivate;
LPINPUTCONTEXT lpIMC;
SetWindowTextA(hwnd,"Wine Ime Active");
lpIMC = LockRealIMC(hIMC);
if (lpIMC)
{
myPrivate = ImmLockIMCC(lpIMC->hPrivate);
myPrivate->hwndDefault = hwnd;
ImmUnlockIMCC(lpIMC->hPrivate);
}
UnlockRealIMC(hIMC);
return TRUE;
}
case WM_PAINT:
PaintDefaultIMEWnd(hIMC, hwnd);
return FALSE;
case WM_NCCREATE:
return TRUE;
case WM_SETFOCUS:
if (wParam)
SetFocus((HWND)wParam);
else
FIXME("Received focus, should never have focus\n");
break;
case WM_IME_COMPOSITION:
DefaultIMEComposition(hIMC, hwnd, lParam);
break;
case WM_IME_STARTCOMPOSITION:
DefaultIMEStartComposition(hIMC, hwnd);
break;
case WM_IME_ENDCOMPOSITION:
TRACE("IME message %s, 0x%lx, 0x%lx\n",
"WM_IME_ENDCOMPOSITION", wParam, lParam);
ShowWindow(hwnd,SW_HIDE);
break;
case WM_IME_SELECT:
TRACE("IME message %s, 0x%lx, 0x%lx\n","WM_IME_SELECT", wParam, lParam);
break;
case WM_IME_CONTROL:
TRACE("IME message %s, 0x%lx, 0x%lx\n","WM_IME_CONTROL", wParam, lParam);
rc = 1;
break;
case WM_IME_NOTIFY:
rc = ImeHandleNotify(hIMC,hwnd,msg,wParam,lParam);
break;
default:
TRACE("Non-standard message 0x%x\n",msg);
}
/* check the MSIME messages */
if (msg == WM_MSIME_SERVICE)
{
TRACE("IME message %s, 0x%lx, 0x%lx\n","WM_MSIME_SERVICE", wParam, lParam);
rc = FALSE;
}
else if (msg == WM_MSIME_RECONVERTOPTIONS)
{
TRACE("IME message %s, 0x%lx, 0x%lx\n","WM_MSIME_RECONVERTOPTIONS", wParam, lParam);
}
else if (msg == WM_MSIME_MOUSE)
{
TRACE("IME message %s, 0x%lx, 0x%lx\n","WM_MSIME_MOUSE", wParam, lParam);
}
else if (msg == WM_MSIME_RECONVERTREQUEST)
{
TRACE("IME message %s, 0x%lx, 0x%lx\n","WM_MSIME_RECONVERTREQUEST", wParam, lParam);
}
else if (msg == WM_MSIME_RECONVERT)
{
TRACE("IME message %s, 0x%lx, 0x%lx\n","WM_MSIME_RECONVERT", wParam, lParam);
}
else if (msg == WM_MSIME_QUERYPOSITION)
{
TRACE("IME message %s, 0x%lx, 0x%lx\n","WM_MSIME_QUERYPOSITION", wParam, lParam);
}
else if (msg == WM_MSIME_DOCUMENTFEED)
{
TRACE("IME message %s, 0x%lx, 0x%lx\n","WM_MSIME_DOCUMENTFEED", wParam, lParam);
}
/* DefWndProc if not an IME message */
if (!rc && !((msg >= WM_IME_STARTCOMPOSITION && msg <= WM_IME_KEYLAST) ||
(msg >= WM_IME_SETCONTEXT && msg <= WM_IME_KEYUP)))
rc = DefWindowProcW(hwnd,msg,wParam,lParam);
return rc;
}