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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
win_win32.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：68k
源码类别：

Windows CE

开发平台：

C/C++

win_win32.c：源码内容
  1. /*****************************************************************************
  2.  *
  3.  * This program is free software ; you can redistribute it and/or modify
  4.  * it under the terms of the GNU General Public License as published by
  5.  * the Free Software Foundation; either version 2 of the License, or
  6.  * (at your option) any later version.
  7.  *
  8.  * This program is distributed in the hope that it will be useful,
  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11.  * GNU General Public License for more details.
  12.  *
  13.  * You should have received a copy of the GNU General Public License
  14.  * along with this program; if not, write to the Free Software
  15.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16.  *
  17.  * $Id: win_win32.c 623 2006-02-01 13:19:15Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "../../common/common.h"
  25. #include "../win.h"
  26. #include "widcommaudio.h"
  27. #include "querykey_win32.h"
  28. #include "openfile_win32.h"
  29. #include "playlst.h"
  30. #include "interface.h"
  32. #if defined(TARGET_WINCE) || defined(TARGET_WIN32)
  34. #define WIN32_LEAN_AND_MEAN
  35. #ifndef STRICT
  36. #define STRICT
  37. #endif
  38. #include <windows.h>
  39. #if _MSC_VER > 1000
  40. #pragma warning(disable : 4201)
  41. #endif
  42. #include <commctrl.h>
  43. #include <shellapi.h>
  45. #include "resource.h"
  47. #define MAXFONTSIZE 64
  49. static HFONT FontCache[MAXFONTSIZE][2];
  50. static WNDCLASS WinClass;
  51. static WNDCLASS DialogClass;
  52. static tchar_t WinClassName[64];
  53. static win* Main = NULL;
  55. #ifndef GCL_HMODULE         
  56. #define GCL_HMODULE         (-16)
  57. #endif
  59. #ifndef UDS_EXPANDABLE
  60. #define UDS_EXPANDABLE  0x0200
  61. #endif
  63. #if defined(TARGET_WINCE)
  64. #define DIALOG_COLOR COLOR_STATIC
  65. #else
  66. #define DIALOG_COLOR COLOR_BTNFACE
  67. #define MOD_KEYUP 0
  68. #endif
  70. #define VALIDCONTROL(i) ((int)(i) & ~0xFFFF)
  72. #define TRACKMAX 30000
  73. #define TRACKTHUMB 9
  75. static BOOL (WINAPI* FuncUnregisterFunc1)( int Flags,int HoyKey ) = NULL;
  76. static BOOL (WINAPI* FuncAllKeys)( int State ) = NULL;
  78. #define TOOLBAR_ID 1000
  80. #if !defined(TARGET_WINCE)
  81. #define TBSTYLE_EX_MIXEDBUTTONS         0x00000008
  82. #ifndef BTNS_SHOWTEXT
  83. #define BTNS_SHOWTEXT 0x40
  84. #endif
  85. #else
  86. #define BTNS_SHOWTEXT 0
  87. #endif
  89. static const menudef* MenuDef(win* Win,const menudef* p,bool_t Popup,void** Menu)
  90. {
  91. int Level = p->Level;
  92. if (!*Menu)
  93. *Menu = Popup ? CreatePopupMenu() : CreateMenu();
  95. while (p->Level==Level && Level>=0)
  96. {
  97. bool_t Skip = 0;
  98. if (p->Id==-1)
  99. {
  100. if (!Win->MenuSmall && !Skip)
  101. AppendMenu(*Menu,MF_SEPARATOR,0,NULL);
  102. ++p;
  103. }
  104. else
  105. {
  106. tchar_t s[256];
  107. int Flags = MF_STRING;
  108. int Id = p->Id;
  110. tcscpy_s(s,TSIZEOF(s),LangStr(p->Class,p->Id));
  112. if (p->Class == PLATFORM_ID)
  113. {
  114. if (p->Level==0 && p->Id == PLATFORM_CANCEL && Win->TitleCancel)
  115. {
  116. ++p;
  117. continue;
  118. }
  119. if (p->Id == PLATFORM_OK)
  120. {
  121. Win->NeedOK = 1;
  122. if (Win->TitleOK)
  123. {
  124. ++p;
  125. continue;
  126. }
  127. }
  128. if (p->Id == PLATFORM_DONE)
  129. {
  130. Win->NeedOK = 1;
  131. if (Win->TitleDone)
  132. {
  133. ++p;
  134. continue;
  135. }
  136. }
  137. }
  139. ++p;
  140. if (p->Level > Level)
  141. {
  142. if (((p[-1].Flags & MENU_SMALL) && !Win->MenuSmall) ||
  143. ((p[-1].Flags & MENU_NOTSMALL) && Win->MenuSmall))
  144. {
  145. if (p[-1].Flags & MENU_GRAYED)
  146. {
  147. AppendMenu(*Menu,Flags,Id,s);
  148. EnableMenuItem(*Menu,Id,MF_GRAYED|MF_BYCOMMAND);
  149. }
  151. // skip
  152. p = MenuDef(Win,p,1,Menu);
  153. continue;
  154. }
  155. else
  156. if (p[-1].Flags & MENU_GRAYED)
  157. { 
  158. int i = tcslen(s);
  159. if (i && s[i-1]==':')
  160. s[i-1] = 0;
  161. }
  163. Id = 0;
  164. p = MenuDef(Win,p,1,(HMENU*)&Id);
  165. Flags |= MF_POPUP;
  166. }
  168. if (!Skip)
  169. {
  170. AppendMenu(*Menu,Flags,Id,s);
  172. if (!(Flags & MF_POPUP) && (p[-1].Flags & MENU_GRAYED))
  173. EnableMenuItem(*Menu,Id,MF_GRAYED|MF_BYCOMMAND);
  174. }
  175. else
  176. {
  177. if (Flags & MF_POPUP)
  178. DestroyMenu((HMENU)Id);
  179. }
  180. }
  181. }
  182. return p;
  183. }
  185. #if defined(TARGET_WINCE)
  187. #define SIPF_OFF 0x00000000
  188. #define SIPF_ON  0x00000001
  190. typedef struct SHACTIVATEINFO
  191. {
  192. DWORD cbSize;
  193. HWND hwndLastFocus;
  194. UINT fSipUp:1;
  195. UINT fSipOnDeactivation:1;
  196. UINT fActive:1;
  197. UINT fReserved:29;
  198. } SHACTIVATEINFO;
  200. #define SHMBOF_NODEFAULT    0x00000001
  201. #define SHMBOF_NOTIFY       0x00000002
  203. #define SHCMBM_GETSUBMENU (WM_USER + 401)
  204. #define SHCMBM_GETMENU      (WM_USER + 402)
  205. #define SHCMBM_OVERRIDEKEY  (WM_USER + 403)
  207. #define SHCMBF_EMPTYBAR      0x0001
  208. #define SHCMBF_HIDDEN        0x0002
  209. #define SHCMBF_HIDESIPBUTTON 0x0004
  210. #define SHCMBF_COLORBK       0x0008
  211. #define SHCMBF_HMENU         0x0010
  213. typedef struct SHMENUBARINFO
  214. {
  215.     DWORD cbSize;
  216. HWND hwndParent;
  217.     DWORD dwFlags;
  218.     UINT nToolBarId;
  219.     HINSTANCE hInstRes;
  220.     int nBmpId;
  221.     int cBmpImages;
  222. HWND hwndMB;
  223.     // COLORREF clrBk; //be as compatible as possible
  224. } SHMENUBARINFO;
  226. #define SHIDIM_FLAGS 0x0001 
  228. #define SHIDIF_DONEBUTTON           0x0001
  229. #define SHIDIF_SIZEDLG              0x0002
  230. #define SHIDIF_SIZEDLGFULLSCREEN    0x0004
  231. #define SHIDIF_SIPDOWN              0x0008
  232. #define SHIDIF_FULLSCREENNOMENUBAR  0x0010
  233. #define SHIDIF_EMPTYMENU            0x0020
  235. typedef struct SHINITDLGINFO
  236. {
  237.     DWORD dwMask;
  238.     HWND  hDlg;
  239.     DWORD dwFlags;
  240. } SHINITDLGINFO;
  242. #define SPI_GETSIPINFO          225
  243. #define SPI_APPBUTTONCHANGE     228
  245. typedef struct SIPINFO
  246. {
  247.     DWORD   cbSize;
  248.     DWORD   fdwFlags;
  249.     RECT    rcVisibleDesktop;
  250.     RECT    rcSipRect;
  251.     DWORD   dwImDataSize;
  252.     void   *pvImData;
  253. } SIPINFO;
  255. #define SHFS_SHOWTASKBAR            0x0001
  256. #define SHFS_HIDETASKBAR            0x0002
  257. #define SHFS_SHOWSIPBUTTON          0x0004
  258. #define SHFS_HIDESIPBUTTON          0x0008
  259. #define SHFS_SHOWSTARTICON          0x0010
  260. #define SHFS_HIDESTARTICON          0x0020
  262. static HMODULE AygShell = NULL;
  263. static HMODULE CoreDLL = NULL;
  264. static BOOL (WINAPI* FuncSipGetInfo)(SIPINFO *pSipInfo) = NULL;
  265. static BOOL (WINAPI* FuncSipShowIM)(DWORD) = NULL;
  266. static BOOL (WINAPI* FuncSHCreateMenuBar)( SHMENUBARINFO *pmb ) = NULL;
  267. static BOOL (WINAPI* FuncSHInitDialog)( SHINITDLGINFO *shdi ) = NULL;
  268. static BOOL (WINAPI* FuncSHFullScreen)( HWND, DWORD ) = NULL;
  269. static BOOL (WINAPI* FuncSHHandleWMActivate)( HWND, WPARAM, LPARAM, void*, DWORD ) = NULL;
  270. static BOOL (WINAPI* FuncSHHandleWMSettingChange)(HWND, WPARAM, LPARAM, void*) = NULL;
  271. static BOOL (WINAPI* FuncSHSendBackToFocusWindow)(UINT, WPARAM, LPARAM ) = NULL;
  272. static bool_t HHTaskbarTop = 0;
  273. static bool_t TaskBarHidden = 0;
  275. void MergeRect(RECT* r,HWND Wnd)
  276. {
  277. if (Wnd)
  278. {
  279. RECT a;
  280. GetWindowRect(Wnd,&a);
  282. if (a.bottom == r->top)
  283. r->top = a.top;
  285. if (a.top == r->bottom)
  286. r->bottom = a.bottom;
  287. }
  288. }
  290. void GetWorkArea(win* p,RECT* r)
  291. {
  292. SystemParametersInfo(SPI_GETWORKAREA,0,r,0);
  294. if (p->AygShellTB && p->WndTB)
  295. {
  296. RECT RectTB;
  297. GetWindowRect(p->WndTB, &RectTB);
  298. if (r->bottom > RectTB.top)
  299. r->bottom = RectTB.top;
  300. }
  302. if (TaskBarHidden)
  303. {
  304. MergeRect(r,FindWindow(T("HHTaskbar"),NULL));
  305. MergeRect(r,FindWindow(T("Tray"),NULL));
  306. }
  307. }
  309. void DIASet(int State,int Mask)
  310. {
  311. if ((Mask & DIA_SIP) && FuncSipShowIM)
  312. FuncSipShowIM((State & DIA_SIP)?SIPF_ON:SIPF_OFF);
  314. if (Mask & DIA_TASKBAR)
  315. {
  316. bool_t Hidden = !(State & DIA_TASKBAR);
  317. if (Hidden != TaskBarHidden)
  318. {
  319. win* p;
  320. HWND WndTaskbar = FindWindow(T("HHTaskbar"),NULL);
  321. HWND WndTray = FindWindow(T("Tray"),NULL); //for smartphone
  323. TaskBarHidden = Hidden;
  325. if (WndTaskbar)
  326. ShowWindow(WndTaskbar,Hidden ? SW_HIDE:SW_SHOWNA);
  328. if (WndTray)
  329. ShowWindow(WndTray,Hidden ? SW_HIDE:SW_SHOWNA);
  331. for (p=Main;p;p=p->Child)
  332. {
  333. if (FuncSHFullScreen)
  334. FuncSHFullScreen(p->Wnd,Hidden ? SHFS_HIDETASKBAR : SHFS_SHOWTASKBAR);
  336. if (!p->FullScreen)
  337. {
  338. RECT r;
  339. GetWorkArea(p,&r);
  340. SetWindowPos(p->Wnd,NULL, r.left, r.top, r.right-r.left, r.bottom-r.top, SWP_NOZORDER);
  341. }
  342. else
  343. {
  344. p->SaveScreen.x = GetSystemMetrics(SM_CXSCREEN);
  345. p->SaveScreen.y = GetSystemMetrics(SM_CYSCREEN);
  346. GetWorkArea(p,(RECT*)&p->SaveRect);
  347. }
  348. }
  349. }
  350. }
  351. }
  353. int DIAGet(int Mask)
  354. {
  355. int Value = 0;
  356. if ((Mask & DIA_TASKBAR) && !TaskBarHidden)
  357. Value |= DIA_TASKBAR;
  358. if ((Mask & DIA_SIP) && FuncSipGetInfo)
  359. {
  360. SIPINFO Info;
  361. Info.cbSize = sizeof(Info);
  362. if (FuncSipGetInfo(&Info) && (Info.fdwFlags & SIPF_ON))
  363. Value |= DIA_SIP;
  364. }
  365. return Value;
  366. }
  368. void WinSetFullScreen(win* p,bool_t State)
  369. {
  370. if (State != p->FullScreen)
  371. {
  372. // no need to hide HHTaskbar because we use TOPMOST and with aygshell we use SHFS_HIDETASKBAR
  373. HWND WndTaskbar = FindWindow(T("HHTaskbar"),NULL);
  374. HWND WndTray = FindWindow(T("Tray"),NULL); //for smartphone
  376. DEBUG_MSG1(DEBUG_WIN,T("FULLSCREEN %d"),State);
  378. p->FullScreen = State; // set flag before SetWindowPos so WM_SIZE,WM_MOVE has valid info
  380. if (State)
  381. {
  382. HWND Mode;
  383. if (FuncSHFullScreen)
  384. {
  385. Mode = HWND_TOP; //incoming calls on smartphones doesn't like topmost
  386. FuncSHFullScreen(p->Wnd,SHFS_HIDETASKBAR);
  387. FuncSHFullScreen(p->Wnd,SHFS_HIDESIPBUTTON);
  388. }
  389. else
  390. {
  391. Mode = HWND_TOPMOST;
  392. if (WndTaskbar)
  393. {
  394. RECT r;
  395. GetWindowRect(WndTaskbar,&r);
  396. HHTaskbarTop = r.top == 0 && r.left == 0;
  397. if (HHTaskbarTop)
  398. ShowWindow(WndTaskbar,SW_HIDE); // old-style with pocketpc
  399. }
  400. }
  402. if (p->WndTB)
  403. ShowWindow(p->WndTB,SW_HIDE);
  404. if (WndTray)
  405. ShowWindow(WndTray,SW_HIDE);
  407. p->SaveScreen.x = GetSystemMetrics(SM_CXSCREEN);
  408. p->SaveScreen.y = GetSystemMetrics(SM_CYSCREEN);
  409. GetWindowRect(p->Wnd,(RECT*)&p->SaveRect);
  410. SetWindowPos(p->Wnd,Mode, 0, 0, p->SaveScreen.x,p->SaveScreen.y,0);
  412. ShowCursor(FALSE);
  413. SetKeyboardBacklight(0);
  414. }
  415. else
  416. {
  417. ShowCursor(TRUE);
  418. SetKeyboardBacklight(1);
  420. if (p->WndTB)
  421. ShowWindow(p->WndTB,SW_SHOWNA);
  423. p->SaveRect[2] += GetSystemMetrics(SM_CXSCREEN) - p->SaveScreen.x;
  424. p->SaveRect[3] += GetSystemMetrics(SM_CYSCREEN) - p->SaveScreen.y;
  425. SetWindowPos(p->Wnd,HWND_NOTOPMOST,p->SaveRect[0],p->SaveRect[1],
  426. p->SaveRect[2]-p->SaveRect[0],p->SaveRect[3]-p->SaveRect[1],SWP_NOACTIVATE);
  428. if (!TaskBarHidden)
  429. {
  430. if (FuncSHFullScreen)
  431. FuncSHFullScreen(p->Wnd,SHFS_SHOWTASKBAR);
  432. else
  433. if (WndTaskbar && HHTaskbarTop)
  434. ShowWindow(WndTaskbar,SW_SHOWNA); // old-style with pocketpc
  435. }
  437. if (WndTray && !TaskBarHidden)
  438. ShowWindow(WndTray,SW_SHOWNA);
  439. }
  440. }
  441. }
  443. static void DestroyToolBar(win* p)
  444. {
  445. if (p->WndTB)
  446. {
  447. CommandBar_Destroy(p->WndTB);
  448. p->WndTB = NULL;
  449. }
  450. }
  452. void WinBitmap(win* p,int BitmapId16, int BitmapId32, int BitmapNum)
  453. {
  454. if (p->WndTB)
  455. {
  456. if (p->LogPixelSX >= 96*2)
  457. p->BitmapNo = CommandBar_AddBitmap(p->WndTB,p->Module,BitmapId32,BitmapNum,32,32);
  458. else
  459. p->BitmapNo = CommandBar_AddBitmap(p->WndTB,p->Module,BitmapId16,BitmapNum,16,16);
  460. }
  461. }
  463. static const menudef* SkipButtons(win* p,const menudef* i)
  464. {
  465. while (i->Level==0)
  466. {
  467. bool_t Skip = 0;
  469. if (p->TitleOK && i->Class == PLATFORM_ID && i->Id == PLATFORM_OK)
  470. {
  471. p->NeedOK = 1;
  472. Skip = 1;
  473. }
  475. if (p->TitleDone && i->Class == PLATFORM_ID && i->Id == PLATFORM_DONE)
  476. {
  477. p->NeedOK = 1;
  478. Skip = 1;
  479. }
  481. if (!Skip)
  482. break;
  484. ++i;
  485. }
  486. return i;
  487. }
  489. static void AddButton(win* p,int Pos,int Id,int Bitmap,tchar_t* Name,bool_t Check);
  491. static void CreateToolBar(win* p)
  492. {
  493. int Ver = QueryPlatform(PLATFORM_VER);
  494. RECT Rect,RectTB;
  495. p->WndTB = NULL;
  496. p->Menu3 = NULL;
  497. memset(&p->Menu2,0,sizeof(p->Menu2));
  498. p->AygShellTB = 0;
  499. p->TitleCancel = p->Smartphone && (p->Flags & WIN_DIALOG);
  500. p->TitleOK = p->TitleDone = !p->Smartphone && !TaskBarHidden && Ver<500;
  501. p->NeedOK = 0;
  503. if (FuncSHCreateMenuBar)
  504. {
  505. SHMENUBARINFO Info;
  506. memset(&Info,0,sizeof(Info));
  507. Info.cbSize = sizeof(Info);
  508. if (p->Smartphone)
  509. Info.cbSize += sizeof(COLORREF); //clrBk
  510. Info.hwndParent = p->Wnd;
  511. Info.nToolBarId = 0;
  512. Info.hInstRes = p->Module;
  513. Info.dwFlags = 0;
  514. if (!p->MenuDef)
  515. Info.dwFlags |= SHCMBF_EMPTYBAR;
  516. else
  517. {
  518. const menudef* i = p->MenuDef;
  519. int Mode = 0;
  521. i = SkipButtons(p,i);
  522. if (i->Level==0)
  523. {
  524. ++i;
  525. for (;i->Level>0;++i)
  526. Mode |= 1;  // submenu under first menu
  527. }
  528. i = SkipButtons(p,i);
  529. if (i->Level==0)
  530. {
  531. ++i;
  532. for (;i->Level>0;++i)
  533. Mode |= 2;  // submenu under second menu
  534. }
  536. switch (Mode)
  537. {
  538. case 0: Info.nToolBarId = IDR_MENU00; break;
  539. case 1: Info.nToolBarId = IDR_MENU10; break;
  540. case 2: Info.nToolBarId = IDR_MENU01; break;
  541. case 3: Info.nToolBarId = IDR_MENU11; break;
  542. }
  543. }
  545. if (!(p->Flags & WIN_DIALOG))
  546. Info.dwFlags |= SHCMBF_HIDESIPBUTTON;
  548. FuncSHCreateMenuBar(&Info);
  550. p->WndTB = Info.hwndMB;
  551. p->ToolBarHeight = 0;
  553. GetWindowRect(p->Wnd, &Rect);
  554. if (p->WndTB)
  555. {
  556. if (p->MenuDef)
  557. {
  558. TBBUTTONINFO Button;
  559. const menudef* i = p->MenuDef;
  560. int No = 0;
  562. while (i->Level>=0)
  563. {
  564. i = SkipButtons(p,i);
  565. if (i->Level<0)
  566. break;
  567. if (No<2)
  568. {
  569. int Id = No ? WIN_B : WIN_A;
  570. p->WinCmd[No] = i->Id;
  571. Button.cbSize = sizeof(Button);
  572. Button.dwMask = TBIF_TEXT;
  573. Button.pszText = (tchar_t*)LangStr(i->Class,i->Id);
  574. SendMessage(p->WndTB,TB_SETBUTTONINFO,Id,(LPARAM)&Button);
  575. ++i;
  577. if (i->Level>0)
  578. {
  579. p->Menu2[No] = (HMENU)SendMessage(p->WndTB,SHCMBM_GETSUBMENU,0,No ? WIN_B:WIN_A);
  580. if (p->Menu2[No])
  581. {
  582. DeleteMenu(p->Menu2[No],No ? WIN_B_B:WIN_A_A,MF_BYCOMMAND);
  583. i = MenuDef(p,i,0,&p->Menu2[No]);
  584. }
  585. }
  587. if (No==1 && !p->Smartphone && Ver<500)
  588. {
  589. TBBUTTON Sep;
  590. memset(&Sep,0,sizeof(Sep));
  591. Sep.fsStyle = TBSTYLE_SEP;
  592. SendMessage(p->WndTB,TB_INSERTBUTTON,No,(LPARAM)&Sep);
  593. ++No;
  594. }
  595. }
  596. else
  597. {
  598. if (p->Smartphone) 
  599. break;
  600. AddButton(p,No,i->Id,-2,(tchar_t*)LangStr(i->Class,i->Id),0);
  601. ++i;
  602. assert(i->Level<=0); // no submenu allowed (only for WIN_A,WIN_B)
  603. }
  604. ++No;
  605. }
  607. while (!p->Smartphone && SendMessage(p->WndTB,TB_BUTTONCOUNT,0,0)>No)
  608. SendMessage(p->WndTB,TB_DELETEBUTTON,No,0);
  609. }
  611. GetWindowRect(p->WndTB, &RectTB);
  612. if (Rect.bottom > RectTB.top)
  613. Rect.bottom = RectTB.top;
  614. //Rect.bottom -= (RectTB.bottom - RectTB.top);
  615. MoveWindow(p->Wnd,Rect.left,Rect.top,Rect.right - Rect.left,Rect.bottom - Rect.top,0);
  617. p->AygShellTB = 1;
  618. p->Flags |= WIN_BOTTOMTOOLBAR;
  619. if (p->Smartphone)
  620. p->Flags |= WIN_2BUTTON;
  622. if (p->Flags & WIN_DIALOG)
  623. SendMessage(p->WndTB,SHCMBM_OVERRIDEKEY,VK_ESCAPE,
  624. MAKELONG(SHMBOF_NODEFAULT|SHMBOF_NOTIFY,SHMBOF_NODEFAULT|SHMBOF_NOTIFY));
  625. }
  626. }
  628. if (!p->WndTB)
  629. {
  630. p->TitleOK = p->TitleDone = !p->Smartphone;
  631. p->TitleCancel = 1;
  632. p->WndTB = CommandBar_Create(p->Module,p->Wnd,TOOLBAR_ID);
  633. p->ToolBarHeight = CommandBar_Height(p->WndTB);
  634. if (p->MenuDef)
  635. {
  636. MenuDef(p,p->MenuDef,0,&p->Menu3);
  637. p->Menu2[0] = p->Menu3;
  638. p->Menu2[1] = p->Menu3;
  639. CommandBar_InsertMenubarEx(p->WndTB,NULL,(tchar_t*)p->Menu3,0);
  640. }
  641. CommandBar_Show(p->WndTB, TRUE);
  642. }
  643. }
  645. #else
  647. static WNDPROC OldToolBarProc = NULL;
  649. static LRESULT CALLBACK ToolBarProc( HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam )
  650. {
  651. if (Msg == WM_MOUSEACTIVATE)
  652. return MA_NOACTIVATE;
  654. if (Msg == WM_LBUTTONUP)
  655. {
  656. int i;
  657. int n=SendMessage(Wnd,TB_BUTTONCOUNT,0,0);
  658. for (i=0;i<n;++i)
  659. {
  660. TBBUTTON Button;
  661. RECT r;
  662. POINT p;
  664. SendMessage(Wnd,TB_GETBUTTON,i,(LPARAM)&Button);
  665. if ((Button.fsState & TBSTATE_PRESSED))
  666. {
  667. if (IsMenu((HMENU)Button.dwData))
  668. {
  669. SendMessage(Wnd,TB_GETRECT,Button.idCommand,(LPARAM)&r);
  670. p.x = LOWORD(lParam);
  671. p.y = HIWORD(lParam);
  672. if (PtInRect(&r,p))
  673. {
  674. p.x = r.left;
  675. p.y = r.bottom;
  676. ClientToScreen(Wnd,&p);
  677. TrackPopupMenu((HMENU)Button.dwData,TPM_LEFTALIGN|TPM_TOPALIGN,
  678. p.x,p.y,0,GetParent(Wnd),NULL);
  679. }
  680. }
  681. }
  682. }
  683. }
  684. return CallWindowProc(OldToolBarProc,Wnd,Msg,wParam,lParam);
  685. }
  687. static void DestroyToolBar(win* p)
  688. {
  689. DestroyWindow(p->WndTB);
  690. p->WndTB = NULL;
  691. }
  693. static void AddMenu(win* p)
  694. {
  695. TBBUTTONINFO Info;
  696. TBBUTTON Button;
  697. tchar_t Name[256];
  698. int Pos;
  700. p->TitleCancel = 1;
  701. p->TitleOK = 0;
  702. p->TitleDone = 1;
  703. p->NeedOK = 0;
  704. p->Menu3 = NULL;
  705. memset(&p->Menu2,0,sizeof(p->Menu2));
  707. if (p->MenuDef)
  708. {
  709. MenuDef(p,p->MenuDef,0,&p->Menu3);
  710. p->Menu2[0] = p->Menu3;
  711. p->Menu2[1] = p->Menu3;
  713. for (Pos=0;Pos<GetMenuItemCount(p->Menu3);++Pos)
  714. {
  715. GetMenuString(p->Menu3,Pos,Name,255,MF_BYPOSITION);
  717. memset(&Button,0,sizeof(Button));
  718. Button.iBitmap = -2;
  719. Button.idCommand = GetMenuItemID(p->Menu3,Pos);
  720. if (Button.idCommand < 0)
  721. Button.idCommand = TOOLBAR_ID+Pos+1;
  722. Button.fsState = TBSTATE_ENABLED;
  723. Button.fsStyle = (BYTE)(TBSTYLE_BUTTON | TBSTYLE_AUTOSIZE | BTNS_SHOWTEXT);
  724. if (!Button.idCommand)
  725. Button.fsStyle = TBSTYLE_SEP;
  727. Button.dwData = (DWORD) GetSubMenu(p->Menu3,Pos);
  728. Button.iString = 0;
  730. SendMessage(p->WndTB,TB_INSERTBUTTON,Pos,(LPARAM)&Button);
  732. Info.cbSize = sizeof(TBBUTTONINFO);
  733. Info.dwMask = TBIF_TEXT;
  734. Info.pszText = Name;
  736. SendMessage(p->WndTB,TB_SETBUTTONINFO,Button.idCommand,(LPARAM)&Info);
  737. }
  738. }
  740. SendMessage(p->WndTB,TB_AUTOSIZE,0,0);
  741. }
  743. void WinBitmap(win* p,int BitmapId16, int BitmapId32, int BitmapNum)
  744. {
  745. TBADDBITMAP Add;
  746. Add.hInst = p->Module;
  747. Add.nID = BitmapId16;
  748. p->BitmapNo = SendMessage(p->WndTB,TB_ADDBITMAP,BitmapNum,(LPARAM)&Add);
  749. }
  751. static void CreateToolBar(win* p)
  752. {
  753. RECT r;
  755. if ((p->Flags & WIN_NOMENU) == 0)
  756. {
  757. p->WndTB = CreateWindowEx(0, TOOLBARCLASSNAME, (LPCTSTR) NULL, 
  758. WS_CHILD|TBSTYLE_FLAT|TBSTYLE_LIST|WS_VISIBLE, 
  759. 0, 0, 0, 0, p->Wnd, (HMENU)TOOLBAR_ID, p->Module, NULL); 
  761. if (p->WndTB)
  762. {
  763. SendMessage(p->WndTB, TB_BUTTONSTRUCTSIZE, (WPARAM) sizeof(TBBUTTON), 0); 
  765. SendMessage(p->WndTB,TB_SETEXTENDEDSTYLE,0,TBSTYLE_EX_MIXEDBUTTONS);
  767. OldToolBarProc = (WNDPROC) GetWindowLong(p->WndTB,GWL_WNDPROC);
  768. SetWindowLong(p->WndTB,GWL_WNDPROC,(LONG)ToolBarProc);
  770. GetWindowRect(p->WndTB,&r);
  771. p->ToolBarHeight = r.bottom - r.top;
  773. AddMenu(p);
  774. }
  775. }
  776. }
  778. void DIASet(int State,int Mask)
  779. {
  780. }
  782. int DIAGet(int Mask)
  783. {
  784. return DIA_TASKBAR & Mask;
  785. }
  787. void WinSetFullScreen(win* p,bool_t State)
  788. {
  789. if (State != p->FullScreen)
  790. {
  791. p->FullScreen = State;
  792. if (State)
  793. {
  794. p->SaveStyle = GetWindowLong(p->Wnd,GWL_STYLE);
  795. GetWindowRect(p->Wnd,(RECT*)&p->SaveRect);
  797. SetWindowLong(p->Wnd,GWL_STYLE,WS_TABSTOP|WS_VISIBLE|WS_POPUP|WS_GROUP);
  798. #ifdef NDEBUG
  799. SetWindowPos(p->Wnd,HWND_TOPMOST,0,0,
  800. #else
  801. SetWindowPos(p->Wnd,HWND_NOTOPMOST,0,0,
  802. #endif
  803. GetSystemMetrics(SM_CXSCREEN),GetSystemMetrics(SM_CYSCREEN),SWP_FRAMECHANGED);
  804. }
  805. else
  806. {
  807. SetWindowLong(p->Wnd,GWL_STYLE,p->SaveStyle);
  808. SetWindowPos(p->Wnd,HWND_NOTOPMOST,p->SaveRect[0],p->SaveRect[1],
  809. p->SaveRect[2]-p->SaveRect[0],p->SaveRect[3]-p->SaveRect[1],SWP_FRAMECHANGED);
  810. }
  812. ShowWindow(p->WndTB,State ? SW_HIDE:SW_SHOWNA);
  813. InvalidateRect(p->Wnd,NULL,0);
  814. }
  815. }
  817. #endif
  819. static int GetDataDefType(wincontrol* i)
  820. {
  821. datadef DataDef;
  822. if (!NodeDataDef(i->Pin.Node,i->Pin.No,&DataDef))
  823. return 0;
  824. return DataDef.Type;
  825. }
  827. static void SetTrack(win* p,wincontrol* i,int Value)
  828. {
  829. tick_t Tick;
  830. datadef DataDef;
  831. if (!NodeDataDef(i->Pin.Node,i->Pin.No,&DataDef))
  832. return;
  834. if (DataDef.Format2 - DataDef.Format1 <= TRACKMAX)
  835. Value += DataDef.Format1;
  836. else
  837. Value = DataDef.Format1 + Scale(DataDef.Format2 - DataDef.Format1,Value,TRACKMAX);
  839. switch (DataDef.Type)
  840. {
  841. case TYPE_INT:
  842. i->Pin.Node->Set(i->Pin.Node,i->Pin.No,&Value,sizeof(Value));
  843. break;
  844. case TYPE_TICK:
  845. Tick = Value;
  846. i->Pin.Node->Set(i->Pin.Node,i->Pin.No,&Tick,sizeof(Tick));
  847. break;
  848. }
  849. }
  851. static void WinControlDisable(win* p,wincontrol* Control,bool_t v)
  852. {
  853. if (Control->Disabled != v)
  854. {
  855. wincontrol* i;
  856. Control->Disabled = v;
  857. if (Control->Control)
  858. EnableWindow(Control->Control,!v);
  859. if (Control->Edit)
  860. EnableWindow(Control->Edit,!v);
  861. for (i=p->Controls;i;i=i->Next)
  862. if (i->Ref == Control)
  863. EnableWindow(i->Control,!v);
  864. }
  865. }
  867. static void WinControlUpdate(win* p,wincontrol* i);
  868. static void WinControlFocus(win* p,wincontrol* Control,bool_t Set);
  870. static void WinControlSet(win* p,wincontrol* i,const datadef* DataDef,const void* Data,int Size,bool_t Update)
  871. {
  872. tchar_t DataOld[MAXDATA/sizeof(tchar_t)];
  873. if (i->Pin.Node->Get(i->Pin.Node,i->Pin.No,DataOld,Size)==ERR_NONE && memcmp(Data,DataOld,Size)==0)
  874. return;
  876. if (i->Pin.Node->Set(i->Pin.Node,i->Pin.No,Data,Size)==ERR_NONE)
  877. {
  878. p->Flags |= WIN_PROP_CHANGED;
  879. if (DataDef->Flags & DF_SOFTRESET)
  880. p->Flags |= WIN_PROP_SOFTRESET;
  881. if (DataDef->Flags & DF_RESTART)
  882. p->Flags |= WIN_PROP_RESTART;
  883. if (DataDef->Flags & DF_RESYNC)
  884. p->Flags |= WIN_PROP_RESYNC;
  885. if (Update)
  886. WinControlUpdate(p,i);
  887. }
  888. }
  890. static void WinControlCmd(win* p,wincontrol* i,HWND Control,int Cmd)
  891. {
  892. tchar_t s[256];
  893. datadef DataDef;
  894. switch (Cmd)
  895. {
  896. case CBN_CLOSEUP:
  897. if (i->ComboBox)
  898. p->ComboOpen = 0;
  899. break;
  901. case CBN_DROPDOWN:
  902. if (i->ComboBox)
  903. p->ComboOpen = 1;
  904. break;
  906. case LBN_SETFOCUS: //CBN_KILLFOCUS
  907. if (p->Smartphone)
  908. WinControlFocus(p,i,0);
  909. p->ComboOpen = 0;
  910. break;
  912. case EN_SETFOCUS:
  913. if (Control != i->Edit)
  914. DIASet(DIA_SIP,DIA_SIP);
  915. //no break
  916. case CBN_SETFOCUS:
  917. case BN_SETFOCUS:
  918. WinControlFocus(p,i,0);
  919. break;
  921. case EN_KILLFOCUS:
  922. if (Control != i->Edit)
  923. DIASet(0,DIA_SIP);
  924. break;
  926. case EN_CHANGE:
  927. if (!p->InUpdate && NodeDataDef(i->Pin.Node,i->Pin.No,&DataDef))
  928. {
  929. if (DataDef.Type == TYPE_STRING)
  930. {
  931. GetWindowText(Control,s,TSIZEOF(s));
  932. WinControlSet(p,i,&DataDef,s,sizeof(s),0);
  933. }
  934. else
  935. if (GetWindowText(Control,s,TSIZEOF(s))>0)
  936. {
  937. fraction f;
  938. tick_t t;
  939. int v = StringToInt(s,0);
  940. switch (DataDef.Type)
  941. {
  942. case TYPE_INT:
  943. if (DataDef.Flags & DF_PERCENT)
  944. v = ScaleRound(v,PERCENT_ONE,100);
  945. WinControlSet(p,i,&DataDef,&v,sizeof(v),0);
  946. break;
  948. case TYPE_TICK:
  949. if (DataDef.Flags & DF_MSEC)
  950. t = ScaleRound(v,TICKSPERSEC,1000);
  951. else
  952. t = v*TICKSPERSEC;
  953. WinControlSet(p,i,&DataDef,&t,sizeof(t),0);
  954. break;
  956. case TYPE_FRACTION:
  957. f.Num = v;
  958. f.Den = 100;
  959. WinControlSet(p,i,&DataDef,&f,sizeof(f),0);
  960. break;
  961. }
  962. }
  963. }
  964. break;
  966. case STN_CLICKED: //BN_CLICKED:
  967. case LBN_SELCHANGE: //STN_DBLCLK: CBN_SELCHANGE:
  968. if (i->Ref)
  969. WinControlFocus(p,i->Ref,1);
  970. else
  971. if (!p->InUpdate && NodeDataDef(i->Pin.Node,i->Pin.No,&DataDef))
  972. {
  973. if (DataDef.Type == TYPE_RESET)
  974. {
  975. int Zero = 0;
  976. wincontrol* j;
  977. for (j=p->Controls;j;j=j->Next)
  978. if (GetDataDefType(j)==TYPE_INT)
  979. WinControlSet(p,j,&DataDef,&Zero,sizeof(Zero),1);
  980. }
  981. else
  982. if (DataDef.Type == TYPE_BOOL)
  983. {
  984. bool_t Data;
  985. if (i->Pin.Node->Get(i->Pin.Node,i->Pin.No,&Data,sizeof(Data))==ERR_NONE)
  986. {
  987. Data = !Data;
  988. WinControlSet(p,i,&DataDef,&Data,sizeof(Data),1);
  989. }
  990. }
  991. else
  992. if (DataDef.Type == TYPE_INT)
  993. {
  994. int Data;
  995. if (p->Smartphone)
  996. {
  997. Data = SendMessage(Control,LB_GETCURSEL,0,0);
  998. if (Data>=0)
  999. Data = SendMessage(Control,LB_GETITEMDATA,Data,0);
  1000. else
  1001. Data=0;
  1002. }
  1003. else
  1004. {
  1005. Data = SendMessage(Control,CB_GETCURSEL,0,0);
  1006. if (Data>=0)
  1007. Data = SendMessage(Control,CB_GETITEMDATA,Data,0);
  1008. else
  1009. Data=0;
  1010. }
  1011. WinControlSet(p,i,&DataDef,&Data,sizeof(Data),0);
  1012. }
  1013. else
  1014. if (DataDef.Type == TYPE_HOTKEY)
  1015. {
  1016. int Data;
  1017. if (i->Pin.Node->Get(i->Pin.Node,i->Pin.No,&Data,sizeof(Data))==ERR_NONE)
  1018. {
  1019. if (!Data)
  1020. {
  1021. node* QueryKey = NodeCreate(QUERYKEY_ID);
  1022. if (QueryKey)
  1023. {
  1024. int Key;
  1025. int Key2;
  1026. ((win*)QueryKey)->Popup((win*)QueryKey,p);
  1027. QueryKey->Get(QueryKey,QUERYKEY_KEY,&Key,sizeof(Key));
  1028. QueryKey->Get(QueryKey,QUERYKEY_KEY2,&Key2,sizeof(Key2));
  1029. if (Key)
  1030. {
  1031. wincontrol* j; 
  1032. int Data2;
  1033. int KeyCode = Key & ~HOTKEY_KEEP;
  1034. int Key2Code = Key2 & ~HOTKEY_KEEP;
  1035. if (!Key2Code) Key2Code = KeyCode;
  1037. for (j=p->Controls;j;j=j->Next)
  1038. if (j!=i && NodeDataDef(j->Pin.Node,j->Pin.No,&DataDef) && DataDef.Type == TYPE_HOTKEY &&
  1039. j->Pin.Node->Get(j->Pin.Node,j->Pin.No,&Data2,sizeof(Data2))==ERR_NONE &&
  1040. ((Data2 & ~HOTKEY_KEEP) == KeyCode || (Data2 & ~HOTKEY_KEEP) == Key2Code))
  1041. {
  1042. Data2 = 0;
  1043. WinControlSet(p,j,&DataDef,&Data2,sizeof(Data2),1);
  1044. }
  1046. if (WinEssentialKey(KeyCode) && p->Smartphone)
  1047. Key &= ~HOTKEY_KEEP;
  1049. Data = Key;
  1050. WinControlSet(p,i,&DataDef,&Data,sizeof(Data),1);
  1051. }
  1052. NodeDelete(QueryKey);
  1053. }
  1054. }
  1055. else
  1056. {
  1057. Data = 0;
  1058. WinControlSet(p,i,&DataDef,&Data,sizeof(Data),1);
  1059. }
  1060. }
  1061. }
  1062. }
  1063. break;
  1064. }
  1065. }
  1067. static void WinControlUpdate(win* p,wincontrol* i)
  1068. {
  1069. datadef DataDef;
  1070. tchar_t Data[MAXDATA/sizeof(tchar_t)];
  1071. tchar_t s[256];
  1072. int Value;
  1073. int Result;
  1075. if (!NodeDataDef(i->Pin.Node,i->Pin.No,&DataDef))
  1076. return;
  1078. p->InUpdate = 1;
  1079. Result = i->Pin.Node->Get(i->Pin.Node,i->Pin.No,Data,DataDef.Size);
  1080. WinControlDisable(p,i,Result!=ERR_NONE);
  1082. if (Result != ERR_NONE && Result != ERR_NOT_SUPPORTED)
  1083. memset(Data,0,sizeof(Data));
  1085. switch (DataDef.Type)
  1086. {
  1087. case TYPE_HOTKEY:
  1088. HotKeyToString(s,TSIZEOF(s),*(int*)Data);
  1089. SetWindowText(i->Edit,s);
  1090. SetWindowText(i->Control,LangStr(PLATFORM_ID,*(int*)Data ? PLATFORM_CLEAR:PLATFORM_ASSIGN));
  1091. break;
  1093. case TYPE_BOOL:
  1094. SendMessage(i->Control,BM_SETCHECK,*(bool_t*)Data?BST_CHECKED:BST_UNCHECKED,0);
  1095. break;
  1097. case TYPE_INT:
  1098. if (DataDef.Flags & (DF_ENUMCLASS|DF_ENUMSTRING))
  1099. {
  1100. int GetCount;
  1101. int GetItemData;
  1102. int SetCurSel;
  1103. int No,Count;
  1105. #if defined(TARGET_WINCE)
  1106. if (p->Smartphone)
  1107. {
  1108. GetCount = LB_GETCOUNT;
  1109. GetItemData = LB_GETITEMDATA;
  1110. SetCurSel = LB_SETCURSEL;
  1111. }
  1112. else
  1113. #endif
  1114. {
  1115. GetCount = CB_GETCOUNT;
  1116. GetItemData = CB_GETITEMDATA;
  1117. SetCurSel = CB_SETCURSEL;
  1118. }
  1120. Count = SendMessage(i->Control,GetCount,0,0);
  1121. for (No=0;No<Count;++No)
  1122. if (SendMessage(i->Control,GetItemData,No,0) == *(int*)Data)
  1123. break;
  1124. if (No==Count)
  1125. No=-1;
  1126. SendMessage(i->Control,SetCurSel,No,0);
  1127. break;
  1128. }
  1129. else
  1130. if (DataDef.Flags & DF_MINMAX)
  1131. {
  1132. if (DataDef.Type == TYPE_TICK)
  1133. Value = *(tick_t*)Data;
  1134. else
  1135. Value = *(int*)Data;
  1137. if (DataDef.Format2 - DataDef.Format1 <= TRACKMAX)
  1138. Value -= DataDef.Format1;
  1139. else
  1140. Value = Scale(Value - DataDef.Format1,TRACKMAX,DataDef.Format2 - DataDef.Format1);
  1141. SendMessage(i->Control,TBM_SETPOS,1,Value);
  1142. break;
  1143. }
  1144. else
  1145. {
  1146. if (DataDef.Flags & DF_PERCENT)
  1147. {
  1148. if (*(int*)Data > 0)
  1149. IntToString(s,TSIZEOF(s),ScaleRound(*(int*)Data,100,PERCENT_ONE),0);
  1150. else
  1151. s[0]=0;
  1152. }
  1153. else
  1154. IntToString(s,TSIZEOF(s),*(int*)Data,0);
  1155. SetWindowText(i->Control,s);
  1156. SendMessage(i->Control,EM_SETSEL,tcslen(s),tcslen(s));
  1157. }
  1158. break;
  1160. case TYPE_STRING:
  1161. SetWindowText(i->Control,Data);
  1162. SendMessage(i->Control,EM_SETSEL,tcslen(s),tcslen(s));
  1163. break;
  1165. case TYPE_TICK:
  1166. if (DataDef.Flags & DF_MSEC)
  1167. stprintf_s(s,TSIZEOF(s),T("%d"),ScaleRound(*(tick_t*)Data,1000,TICKSPERSEC));
  1168. else
  1169. stprintf_s(s,TSIZEOF(s),T("%d"),ScaleRound(*(tick_t*)Data,1,TICKSPERSEC));
  1170. SetWindowText(i->Control,s);
  1171. SendMessage(i->Control,EM_SETSEL,tcslen(s),tcslen(s));
  1172. break;
  1174. case TYPE_FRACTION:
  1175. if (((fraction*)Data)->Num > 0)
  1176. stprintf_s(s,TSIZEOF(s),T("%d"),ScaleRound(((fraction*)Data)->Num,100,((fraction*)Data)->Den));
  1177. else
  1178. s[0] = 0;
  1179. SetWindowText(i->Control,s);
  1180. SendMessage(i->Control,EM_SETSEL,tcslen(s),tcslen(s));
  1181. break;
  1182. }
  1183. p->InUpdate = 0;
  1184. }
  1186. winunit WinPixelToUnitX(win* p,int Pixel) { return ScaleRound(Pixel,72,p->LogPixelSX); }
  1187. winunit WinPixelToUnitY(win* p,int Pixel) { return ScaleRound(Pixel,72,p->LogPixelSY); }
  1188. int WinUnitToPixelX(win* p,winunit Pos) { return ScaleRound(Pos,p->LogPixelSX,72); }
  1189. int WinUnitToPixelY(win* p,winunit Pos) { return ScaleRound(Pos,p->LogPixelSY,72); }
  1191. void WinProp( win* p, int* x0,int* x1)
  1192. {
  1193. *x0 = 2;
  1194. *x1 = p->LabelWidth + *x0;
  1196. if (*x1 > (p->Width*3)/4)
  1197. *x1 = (p->Width*3)/4;
  1199. *x1++;
  1200. }
  1202. static wincontrol* CreateControl(win* p,int Size)
  1203. {
  1204. wincontrol* Control = malloc(Size);
  1205. if (Control)
  1206. {
  1207. wincontrol** i;
  1208. memset(Control,0,Size);
  1209. for (i=&p->Controls;*i;i=&(*i)->Next);
  1210. *i = Control;
  1211. }
  1212. return Control;
  1213. }
  1215. static int CreateEnum(win* p, wincontrol* Control, int Left, int Top, int Width, int Height, const datadef* DataDef)
  1216. {
  1217. int No;
  1218. int Pos;
  1219. int AddString;
  1220. int ItemData;
  1221. int MaxWidth;
  1222. int FontSize;
  1223. int Plus = 0;
  1225. MaxWidth = WinUnitToPixelX(p,(DataDef->Flags & DF_ENUMSTRING) ? 80:180);
  1226. if (Width > MaxWidth)
  1227. Width = MaxWidth;
  1229. if (p->Smartphone)
  1230. {
  1231. Control->Control = CreateWindow(T("listbox"), NULL, WS_TABSTOP|WS_VISIBLE|WS_CHILD|LBS_NOTIFY|LBS_NOINTEGRALHEIGHT|((DataDef->Flags & DF_ENUMUNSORT)?0:LBS_SORT), 
  1232. Left, Top, Width, Height, p->WndDialog, NULL, p->Module, 0L);
  1234. Control->Edit = CreateWindow(UPDOWN_CLASS, NULL, WS_CHILD|WS_VISIBLE | UDS_HORZ |UDS_ALIGNRIGHT | UDS_ARROWKEYS |  UDS_SETBUDDYINT | UDS_WRAP | UDS_EXPANDABLE, 
  1235. 0, 0, 0, 0, p->WndDialog, NULL, p->Module, 0L);
  1237. SendMessage(Control->Edit, UDM_SETBUDDY, (WPARAM)Control->Control, 0);
  1239. AddString = LB_ADDSTRING;
  1240. ItemData = LB_SETITEMDATA;
  1242. FontSize = PROPSIZE;
  1243. SendMessage(Control->Edit,WM_SETFONT,(WPARAM)WinFont(p,&FontSize,1),0);
  1244. }
  1245. else
  1246. {
  1247. Control->Control = CreateWindow(T("COMBOBOX"), NULL, WS_VSCROLL|WS_TABSTOP|WS_VISIBLE|WS_CHILD|CBS_DROPDOWNLIST|((DataDef->Flags & DF_ENUMUNSORT)?0:CBS_SORT), 
  1248. Left, Top, Width, Height*(p->MenuSmall?10:15), p->WndDialog, NULL, p->Module, 0L);
  1250. Control->ComboBox = 1;
  1251. AddString = CB_ADDSTRING;
  1252. ItemData = CB_SETITEMDATA;
  1253. Plus = 6;
  1255. FontSize = PROPSIZE;
  1256. SendMessage(Control->Control,WM_SETFONT,(WPARAM)WinFont(p,&FontSize,1),0);
  1257. }
  1259. if (DataDef->Flags & DF_ENUMCLASS)
  1260. {
  1261. array List;
  1262. int *i;
  1263. NodeEnumClass(&List,DataDef->Format1);
  1264. for (i=ARRAYBEGIN(List,int);i!=ARRAYEND(List,int);++i)
  1265. {
  1266. Pos = SendMessage(Control->Control,AddString,0,(LPARAM)LangStr(*i,NODE_NAME));
  1267. SendMessage(Control->Control,ItemData,Pos,*i);
  1268. }
  1269. ArrayClear(&List);
  1270. }
  1271. else
  1272. if (DataDef->Flags & DF_ENUMSTRING)
  1273. {
  1274. int Id;
  1275. for (No=0;(Id=LangEnum(DataDef->Format1,No))!=0;++No)
  1276. {
  1277. Pos = SendMessage(Control->Control,AddString,0,(LPARAM)LangStr(DataDef->Format1,Id));
  1278. SendMessage(Control->Control,ItemData,Pos,Id);
  1279. }
  1280. }
  1282. return Plus;
  1283. }
  1285. static void CreateEditor(win* p, wincontrol* Control, int Left, int Top, int Width, int Height, const datadef* DataDef)
  1286. {
  1287. tchar_t Post[32];
  1288. int FontSize;
  1289. int Style = ES_NUMBER;
  1291. if (DataDef->Flags & DF_NEG)
  1292. Style = 0;
  1294. if (DataDef->Type==TYPE_STRING)
  1295. Style = ES_AUTOHSCROLL;
  1297. #ifdef TARGET_WIN32
  1298. if ((Width > 32) && DataDef->Type!=TYPE_STRING)
  1299. Width = 32;
  1300. #else
  1301. if ((Width > 30) && DataDef->Type!=TYPE_STRING)
  1302. Width = 30;
  1303. #endif
  1305. Control->Control = CreateWindow(T("EDIT"), NULL, WS_TABSTOP|WS_VISIBLE|WS_CHILD|Style, 
  1306. WinUnitToPixelX(p,Left), WinUnitToPixelY(p,Top), 
  1307. WinUnitToPixelX(p,Width), WinUnitToPixelY(p,Height), 
  1308. p->WndDialog, NULL, p->Module, 0L);
  1310. FontSize = PROPSIZE;
  1311. SendMessage(Control->Control,WM_SETFONT,(WPARAM)WinFont(p,&FontSize,1),0);
  1313. Control->Editor = 1;
  1314. Post[0] = 0;
  1316. if (DataDef->Flags & DF_KBYTE)
  1317. tcscpy_s(Post,TSIZEOF(Post),T("KB"));
  1318. else
  1319. if (DataDef->Flags & DF_MHZ)
  1320. tcscpy_s(Post,TSIZEOF(Post),T("Mhz"));
  1321. else
  1322. if (DataDef->Flags & DF_PERCENT)
  1323. tcscpy_s(Post,TSIZEOF(Post),T("%"));
  1324. else
  1325. if (DataDef->Type == TYPE_TICK)
  1326. tcscpy_s(Post,TSIZEOF(Post),(DataDef->Flags & DF_MSEC) ? T("msec"):T("sec"));
  1328. if (Post[0])
  1329. WinLabel(p,&Top,Left+Width+1,-1,Post,11,0,NULL);
  1330. }
  1332. wincontrol* WinPropNative(win* p, node* Node, int No)
  1333. {
  1334. wincontrol* Control = CreateControl(p,sizeof(wincontrol));
  1335. if (Control)
  1336. {
  1337. Control->Pin.Node = Node;
  1338. Control->Pin.No = No;
  1339. }
  1340. return Control;
  1341. }
  1343. wincontrol* WinPropValue(win* p, winunit* DlgTop, node* Node, int No)
  1344. {
  1345. int FontSize;
  1346. int Height,Width;
  1347. int Gap = WinUnitToPixelX(p,2);
  1348. int Top = WinUnitToPixelY(p,*DlgTop);
  1349. int Left;
  1350. winunit x,x0,x1,y1,y2;
  1351. wincontrol* Control;
  1352. datadef DataDef;
  1354. if (!NodeDataDef(Node,No,&DataDef))
  1355. return NULL;
  1357. Control = WinPropNative(p,Node,No);
  1358. if (!Control)
  1359. return NULL;
  1361. if (DataDef.Flags & DF_SHORTLABEL)
  1362. {
  1363. if (p->Smartphone)
  1364. x1 = 36;
  1365. else
  1366. x1 = 48;
  1367. x0 = 2;
  1368. Width = x1-x0-2; 
  1369. }
  1370. else
  1371. if ((DataDef.Flags & DF_CHECKLIST) && DataDef.Type==TYPE_BOOL)
  1372. {
  1373. x0 = 4+PROPSIZE;
  1374. x1 = 2;
  1375. Width = -1;
  1376. }
  1377. else
  1378. {
  1379. WinProp(p,&x0,&x1);
  1380. Width = x1-x0-2;
  1381. }
  1383. if (DataDef.Flags & DF_NOWRAP)
  1384. Width = -1;
  1386. y1 = *DlgTop;
  1387. if (DataDef.Type != TYPE_RESET)
  1388. WinLabel(p,&y1,x0,Width,DataDef.Name,PROPSIZE,0,Control);
  1389. else
  1390. x1 = x0;
  1392. y2 = *DlgTop + PROPSIZE+1;
  1393. Width = WinUnitToPixelX(p,PROPSIZE+1);
  1394. Height = WinUnitToPixelY(p,PROPSIZE+1);
  1395. Left = WinUnitToPixelX(p,x1);
  1397. switch (DataDef.Type)
  1398. {
  1399. case TYPE_RESET:
  1400. Control->Control = CreateWindow(T("BUTTON"),NULL,WS_TABSTOP|WS_VISIBLE|WS_CHILD|BS_PUSHBUTTON|BS_NOTIFY,
  1401. Left+Gap,Top,Width*5,WinUnitToPixelY(p,PROPSIZE+2), p->WndDialog, NULL, p->Module, NULL);
  1403. y2 += 2;
  1404. FontSize = PROPSIZE;
  1405. SendMessage(Control->Control,WM_SETFONT,(WPARAM)WinFont(p,&FontSize,0),0);
  1406. SetWindowText(Control->Control,DataDef.Name);
  1407. break;
  1409. case TYPE_HOTKEY:
  1410. x = (Width*7)/2;
  1411. Control->Edit = CreateWindow(T("EDIT"),NULL,ES_READONLY|ES_AUTOHSCROLL|WS_VISIBLE|WS_CHILD,
  1412. Left,Top,x,Height, p->WndDialog, NULL, p->Module, NULL );
  1414. Control->Control = CreateWindow(T("BUTTON"),NULL,WS_TABSTOP|WS_VISIBLE|WS_CHILD|BS_PUSHBUTTON|BS_NOTIFY,
  1415. Left+x+Gap,Top,(Width*5)/2,WinUnitToPixelY(p,PROPSIZE+2), p->WndDialog, NULL, p->Module, NULL);
  1417. FontSize = PROPSIZE;
  1418. SendMessage(Control->Edit,WM_SETFONT,(WPARAM)WinFont(p,&FontSize,1),0);
  1420. FontSize = PROPSIZE;
  1421. SendMessage(Control->Control,WM_SETFONT,(WPARAM)WinFont(p,&FontSize,0),0);
  1423. y2 += 2;
  1424. break;
  1426. case TYPE_BOOL:
  1427. Control->Control = CreateWindow(T("BUTTON"),NULL,WS_TABSTOP|WS_VISIBLE|WS_CHILD|BS_CHECKBOX|BS_NOTIFY,
  1428. Left,Top,Width,Height,p->WndDialog,NULL,p->Module,NULL);
  1429. break;
  1431. case TYPE_INT:
  1432. if (DataDef.Flags & (DF_ENUMCLASS|DF_ENUMSTRING))
  1433. {
  1434. y2 += CreateEnum(p,Control,Left,Top,WinUnitToPixelX(p,p->Width-x1),Height,&DataDef);
  1435. break;
  1436. }
  1437. else
  1438. if (DataDef.Flags & DF_MINMAX)
  1439. {
  1440. int Interval;
  1442. Width = p->Width-x1;
  1443. if (Width > 100)
  1444. Width = 100;
  1445. if (Width < 65 && !(DataDef.Flags & DF_NOWRAP))
  1446. {
  1447. y2 = y1 + PROPSIZE+1;
  1448. x1 = x0;
  1449. Width = p->Width-x1;
  1450. if (Width > 200)
  1451. Width = 200;
  1452. Left = WinUnitToPixelX(p,x1);
  1453. Top = WinUnitToPixelY(p,y1);
  1454. }
  1456. Control->Control = CreateWindowEx( 
  1457. 0,                    
  1458. TRACKBAR_CLASS,       
  1459. NULL,   
  1460. WS_TABSTOP|WS_CHILD | WS_VISIBLE | TBS_HORZ|TBS_BOTH|TBS_NOTICKS|TBS_FIXEDLENGTH, 
  1461. Left,Top,    
  1462. WinUnitToPixelX(p,Width), Height,   
  1463. p->WndDialog,
  1464. NULL,
  1465. p->Module,                     
  1466. NULL); 
  1468. Interval = DataDef.Format2 - DataDef.Format1;
  1469. if (Interval > TRACKMAX)
  1470. Interval = TRACKMAX;
  1472. SendMessage(Control->Control, TBM_SETRANGE, FALSE,MAKELONG(0,Interval));
  1473. SendMessage(Control->Control, TBM_SETPAGESIZE,0,Interval/32);
  1474. SendMessage(Control->Control, TBM_SETLINESIZE,0,Interval/32);
  1475. SendMessage(Control->Control, TBM_SETTHUMBLENGTH, WinUnitToPixelY(p,TRACKTHUMB),0);
  1476. break;
  1477. }
  1478. // no break
  1480. case TYPE_STRING:
  1481. case TYPE_TICK:
  1482. case TYPE_FRACTION:
  1483. CreateEditor(p,Control,x1,*DlgTop,p->Width-x1,PROPSIZE+1,&DataDef);
  1484. y2 += 1;
  1485. break;
  1486. }
  1487. SetWindowLong(Control->Control,GWL_USERDATA,(LONG)Control);
  1488. WinControlUpdate(p,Control);
  1489. *DlgTop = y1>y2?y1:y2;
  1490. return Control;
  1491. }
  1493. bool_t WinNoHotKey(int HotKey)
  1494. {
  1495. int Model = QueryPlatform(PLATFORM_MODEL);
  1496. if (Model == MODEL_TOSHIBA_E800) // record button mapping works on E800...
  1497. return 0;
  1499. HotKey &= ~HOTKEY_KEEP;
  1500. if (((HotKey & HOTKEY_MASK) == 0xC5 || HotKey == VK_ESCAPE || HotKey == VK_F1 || 
  1501.  HotKey == VK_F2 || HotKey == VK_F3 || HotKey == VK_F4 ||
  1502.  HotKey == VK_F6 || HotKey == VK_F7) && 
  1503. (QueryPlatform(PLATFORM_TYPENO) == TYPE_POCKETPC ||
  1504.  QueryPlatform(PLATFORM_TYPENO) == TYPE_SMARTPHONE))
  1505. return 1; // record, softkey1,2, talk, end, volume up/odwn
  1507. return 0;
  1508. }
  1510. bool_t WinEssentialKey(int HotKey)
  1511. {
  1512. HotKey &= ~HOTKEY_KEEP;
  1513. return 
  1514. HotKey == 0x86 || //action
  1515. HotKey == VK_RETURN ||
  1516. HotKey == VK_LEFT || // (need to be essential for D-pad rotation support too!)
  1517. HotKey == VK_RIGHT ||
  1518. HotKey == VK_UP ||
  1519. HotKey == VK_DOWN; // should use normal WM_KEYDOWN event for them
  1520. }
  1522. static void AddButton(win* p,int Pos,int Id,int Bitmap,tchar_t* Name,bool_t Check)
  1523. {
  1524. TBBUTTON Button;
  1525. memset(&Button,0,sizeof(Button));
  1526. Button.iBitmap = p->BitmapNo + Bitmap;
  1527. Button.idCommand = Id;
  1528. Button.fsState = TBSTATE_ENABLED;
  1529. Button.fsStyle = (BYTE)((Check ? TBSTYLE_CHECK : TBSTYLE_BUTTON) | TBSTYLE_AUTOSIZE | BTNS_SHOWTEXT);
  1530. Button.dwData = 0;
  1531. Button.iString = 0;
  1533. if (Id<0)
  1534. {
  1535. Button.idCommand = 0;
  1536. Button.fsStyle = TBSTYLE_SEP;
  1538. if (!p->AygShellTB && !(p->Flags & WIN_DIALOG) && GetSystemMetrics(SM_CXSCREEN)<=240)
  1539. return;
  1540. }
  1542. if (p->WndTB)
  1543. {
  1544. SendMessage(p->WndTB,TB_INSERTBUTTON,Pos,(LPARAM)&Button);
  1546. if (Name && Id>0)
  1547. {
  1548. TBBUTTONINFO Button;
  1549. Button.cbSize = sizeof(Button);
  1550. Button.dwMask = TBIF_TEXT;
  1551. Button.pszText = Name;
  1552. SendMessage(p->WndTB,TB_SETBUTTONINFO,Id,(LPARAM)&Button);
  1553. }
  1554. }
  1555. }
  1557. static int FindButton(win* p,int Id)
  1558. {
  1559. if (p->WndTB)
  1560. {
  1561. int i;
  1562. int n=SendMessage(p->WndTB,TB_BUTTONCOUNT,0,0);
  1563. for (i=0;i<n;++i)
  1564. {
  1565. TBBUTTON Button;
  1566. SendMessage(p->WndTB,TB_GETBUTTON,i,(LPARAM)&Button);
  1567. if (Button.idCommand == Id)
  1568. return i;
  1569. }
  1570. }
  1571. return -1;
  1572. }
  1574. void WinDeleteButton(win* p,int Id)
  1575. {
  1576. int No = FindButton(p,Id);
  1577. if (No>=0)
  1578. SendMessage(p->WndTB,TB_DELETEBUTTON,No,0);
  1579. }
  1581. void WinAddButton(win* p,int Id,int Bitmap,tchar_t* Name,bool_t Check)
  1582. {
  1583. if (p->WndTB)
  1584. AddButton(p,SendMessage(p->WndTB,TB_BUTTONCOUNT,0,0),Id,Bitmap,Name,Check);
  1585. }
  1587. win* WinGetObject(HWND Wnd)
  1588. {
  1589. return (win*) GetWindowLong(Wnd,GWL_USERDATA);
  1590. }
  1592. void WinSetObject(HWND Wnd,win* p)
  1593. {
  1594. SetWindowLong(Wnd,GWL_USERDATA,(LONG)p);
  1595. }
  1597. void WinRegisterHotKey(win* p,int Id,int HotKey)
  1598. {
  1599. #if defined(NDEBUG) || defined(TARGET_WINCE)
  1600. int Mod = MOD_KEYUP;
  1601. HotKey &= ~HOTKEY_KEEP;
  1602. //if (WinNoHotKey(HotKey)) return; //don't force, some devices support those hotkeys
  1603. if (HotKey & HOTKEY_ALT) Mod |= MOD_ALT;
  1604. if (HotKey & HOTKEY_SHIFT) Mod |= MOD_SHIFT;
  1605. if (HotKey & HOTKEY_CTRL) Mod |= MOD_CONTROL;
  1606. if (HotKey & HOTKEY_WIN) Mod |= MOD_WIN;
  1607. HotKey &= HOTKEY_MASK;
  1608. if (FuncUnregisterFunc1)
  1609. FuncUnregisterFunc1(Mod,HotKey);
  1610. RegisterHotKey(p->Wnd,Id,Mod,HotKey);
  1611. #endif
  1612. }
  1614. void WinUnRegisterHotKey(win* p,int Id)
  1615. {
  1616. #if defined(NDEBUG) || defined(TARGET_WINCE)
  1617. UnregisterHotKey(p->Wnd,Id);
  1618. #endif
  1619. }
  1621. wincontrol* WinPropLabel(win* p, winunit* Top, const tchar_t* LockedMsg, const tchar_t* Value)
  1622. {
  1623. wincontrol* Control;
  1624. int x0,x1;
  1625. int y2=*Top,y1=*Top;
  1626. WinProp(p,&x0,&x1);
  1627. Control = WinLabel(p,&y2,x1,-1,Value,PROPSIZE,LABEL_BOLD,NULL);
  1628. if (Control && !(p->Flags & WIN_NOTABSTOP))
  1629. Control->Disabled = 0; // tab stop
  1630. WinLabel(p,&y1,x0,x1-x0-2,LockedMsg,PROPSIZE,0,Control);
  1631. *Top = y1>y2 ? y1:y2;
  1632. return Control;
  1633. }
  1635. static void WinUpdateScroll(win* p);
  1636. static void WinNext(win* p,bool_t Prev);
  1638. int WinKeyState(int Key)
  1639. {
  1640. if (GetKeyState(VK_CONTROL)<0) Key |= HOTKEY_CTRL;
  1641. if (GetKeyState(VK_SHIFT)<0) Key |= HOTKEY_SHIFT;
  1642. if (GetKeyState(VK_MENU)<0) Key |= HOTKEY_ALT;
  1643. if (GetKeyState(VK_LWIN)<0 || GetKeyState(VK_RWIN)<0) Key |= HOTKEY_WIN;
  1644. //if (Key >= 0xC1 && Key <= 0xCF) Key |= HOTKEY_WIN; // h3800 ???
  1645. return Key;
  1646. }
  1648. void WinAllKeys(bool_t State)
  1649. {
  1650. if (FuncAllKeys)
  1651. FuncAllKeys(State);
  1652. }
  1654. void* WinCursorArrow()
  1655. {
  1656. #if defined(TARGET_WINCE)
  1657. return NULL;
  1658. #else
  1659. return LoadCursor(NULL,IDC_ARROW);
  1660. #endif
  1661. }
  1663. static void WinControlDelete(win* p,wincontrol* Control)
  1664. {
  1665. wincontrol** i;
  1666. for (i=&p->Controls;*i && *i!=Control;i=&(*i)->Next);
  1667. if (*i)
  1668. *i = Control->Next;
  1669. if (!Control->External)
  1670. {
  1671. if (Control->Control)
  1672. DestroyWindow(Control->Control);
  1673. if (Control->Edit)
  1674. DestroyWindow(Control->Edit);
  1675. }
  1676. free(Control);
  1677. }
  1679. static void WinClear( win* p)
  1680. {
  1681. p->Focus = NULL;
  1682. while (p->Controls)
  1683. WinControlDelete(p,p->Controls);
  1684. }
  1686. void WinBeginUpdate(win* p)
  1687. {
  1688. ShowWindow(p->WndDialog,SW_HIDE);
  1689. WinClear(p);
  1690. }
  1692. void WinEndUpdate(win* p)
  1693. {
  1694. if (!p->Focus)
  1695. WinNext(p,0);
  1696. ShowWindow(p->WndDialog,SW_SHOWNA);
  1697. WinUpdateScroll(p);
  1698. }
  1700. void WinMenuInsert(win* p,int No,int PrevId,int Id,const tchar_t* LockedMsg)
  1701. {
  1702. if (p->Menu2[No])
  1703. InsertMenu(p->Menu2[No],PrevId,MF_BYCOMMAND|MF_STRING,Id,LockedMsg);
  1704. }
  1706. bool_t WinMenuDelete(win* p,int No,int Id)
  1707. {
  1708. if (p->Menu2[No])
  1709. return DeleteMenu(p->Menu2[No],Id,MF_BYCOMMAND)!=0;
  1710. return 0;
  1711. }
  1713. bool_t WinMenuEnable(win* p,int No,int Id,bool_t State)
  1714. {
  1715. if (p->Menu2[No])
  1716. return EnableMenuItem(p->Menu2[No],Id,(State ? MF_ENABLED:MF_GRAYED)|MF_BYCOMMAND) != -1;
  1717. return 0;
  1718. }
  1720. int WinMenuFind(win* p,int Id)
  1721. {
  1722. int No;
  1723. MENUITEMINFO Info;
  1725. if (p->Menu3)
  1726. return 0;
  1728. Info.cbSize = sizeof(Info);
  1729. Info.fMask = 0;
  1731. for (No=0;No<2;++No)
  1732. {
  1733. if (p->Menu2[No] && GetMenuItemInfo(p->Menu2[No],Id,FALSE,&Info))
  1734. return No;
  1735. }
  1737. return 0;
  1738. }
  1740. bool_t WinMenuCheck(win* p,int No,int Id,bool_t State)
  1741. {
  1742. if (p->Menu2[No])
  1743. return CheckMenuItem(p->Menu2[No],Id,State?MF_CHECKED:MF_UNCHECKED) != -1;
  1744. return 0;
  1745. }
  1747. void WinTitle(win* p,const tchar_t* LockedMsg)
  1748. {
  1749. SetWindowText(p->Wnd,LockedMsg);
  1750. }
  1752. int WinClose(win* p)
  1753. {
  1754. PostMessage(p->Wnd,WM_CLOSE,0,0);
  1755. return ERR_NONE;
  1756. }
  1758. wincontrol* WinLabel(win* p,winunit* DlgTop,winunit DlgLeft,winunit DlgWidth,const tchar_t* Msg,int FontSize,int Flags,wincontrol* Ref)
  1759. {
  1760. tchar_t s[256];
  1761. wincontrol* Result = NULL;
  1762. SIZE Size;
  1763. HDC DC = GetDC(p->Wnd);
  1764. HFONT OldFont;
  1765. HFONT Font = (HFONT)WinFont(p,&FontSize,(Flags & LABEL_BOLD)!=0);
  1766. int Style = WS_VISIBLE | WS_CHILD;
  1767. int Left,Width;
  1768. int Extra = WinUnitToPixelX(p,2);
  1770. if (DlgLeft<0)
  1771. {
  1772. DlgLeft = 2;
  1773. DlgWidth = p->Width-4;
  1774. }
  1776. Left = WinUnitToPixelX(p,DlgLeft);
  1777. Width = DlgWidth>0 ? WinUnitToPixelX(p,DlgWidth) : -1;
  1779. if (Ref)
  1780. Style |= SS_NOTIFY;
  1782. if (Flags & LABEL_CENTER)
  1783. Style |= SS_CENTER;
  1784. else
  1785. Style |= SS_LEFTNOWORDWRAP;
  1787. OldFont = SelectObject(DC,Font);
  1789. if (Msg)
  1790. while (*Msg)
  1791. {
  1792. while (*Msg == 10)
  1793. {
  1794. ++Msg;
  1795. *DlgTop += FontSize/3; // smaller gaps
  1796. }
  1798. if (*Msg)
  1799. {
  1800. tchar_t* i;
  1802. wincontrol* Control = CreateControl(p,sizeof(wincontrol));
  1803. if (!Control)
  1804. break;
  1806. tcscpy_s(s,TSIZEOF(s),Msg);
  1808. i = tcschr(s,10);
  1809. if (i) *i = 0;
  1811. for (;;)
  1812. {
  1813. GetTextExtentPoint(DC,s,tcslen(s),&Size);
  1814. Size.cx += Extra;
  1816. if (!s[0] || !s[1] || Width<0 || Size.cx <= Width)
  1817. break;
  1819. i = tcsrchr(s,' ');
  1820. if (i)
  1821. *i = 0;
  1822. else
  1823. s[tcslen(s)-1] = 0;
  1824. }
  1826. Control->Disabled = 1; // no user input
  1827. Control->Ref = Ref;
  1828. Control->Control = CreateWindow(T("STATIC"),s,Style,Left,WinUnitToPixelY(p,*DlgTop),
  1829. Width>0 ? Width : Size.cx, WinUnitToPixelY(p,FontSize), p->WndDialog, NULL, p->Module, NULL );
  1831. SetWindowLong(Control->Control,GWL_USERDATA,(LONG)Control);
  1832. SendMessage(Control->Control,WM_SETFONT,(WPARAM)Font,0);
  1834. *DlgTop += FontSize;
  1835. Msg += tcslen(s);
  1837. while (*Msg == ' ') ++Msg;
  1838. if (*Msg == 10) ++Msg;
  1840. if (!Result)
  1841. Result = Control;
  1842. }
  1843. }
  1845. SelectObject(DC,OldFont);
  1846. ReleaseDC(p->Wnd,DC);
  1847. return Result;
  1848. }
  1850. void* WinFont(win* p,winunit* FontSize,bool_t Bold)
  1851. {
  1852. HFONT Font;
  1853. int Size = WinUnitToPixelY(p,*FontSize);
  1854. if (Size && Size < MAXFONTSIZE)
  1855. {
  1856. if (!FontCache[Size][Bold])
  1857. {
  1858. LOGFONT LogFont;
  1860. memset(&LogFont,0,sizeof(LogFont));
  1861. tcscpy_s(LogFont.lfFaceName,TSIZEOF(LogFont.lfFaceName),T("MS Sans Serif"));
  1863. LogFont.lfHeight = Size;
  1864. LogFont.lfWidth = 0;
  1866. switch (Context()->Lang)
  1867. {
  1868. case FOURCC('A','R','_','_'):
  1869. LogFont.lfCharSet = ARABIC_CHARSET;
  1870. break;
  1871. case FOURCC('C','H','T','_'):
  1872. LogFont.lfCharSet = CHINESEBIG5_CHARSET;
  1873. break;
  1874. case FOURCC('C','H','S','_'):
  1875. LogFont.lfCharSet = GB2312_CHARSET;
  1876. break;
  1877. case FOURCC('R','U','_','_'):
  1878. LogFont.lfCharSet = RUSSIAN_CHARSET;
  1879. break;
  1880. case FOURCC('J','A','_','_'):
  1881. LogFont.lfCharSet = SHIFTJIS_CHARSET;
  1882. break;
  1883. case FOURCC('T','R','_','_'):
  1884. LogFont.lfCharSet = TURKISH_CHARSET;
  1885. break;
  1886. case FOURCC('K','O','_','_'):
  1887. LogFont.lfCharSet = HANGEUL_CHARSET;
  1888. break;
  1889. default:
  1890. LogFont.lfCharSet = OEM_CHARSET;
  1891. }
  1893. if (Bold)
  1894. LogFont.lfWeight = FW_BOLD;
  1896. FontCache[Size][Bold] = CreateFontIndirect(&LogFont);
  1897. }
  1898. Font = FontCache[Size][Bold];
  1899. }
  1900. else
  1901. {
  1902. LOGFONT LogFont;
  1903. Font = (HFONT)GetStockObject(SYSTEM_FONT);
  1904. GetObject(Font,sizeof(LogFont),&LogFont);
  1905. *FontSize = WinPixelToUnitY(p,abs(LogFont.lfHeight));
  1906. }
  1907. return Font;
  1908. }
  1910. static void UpdateDPI(win* p)
  1911. {
  1912. HDC DC = GetDC(p->Wnd);
  1913. p->LogPixelSX = GetDeviceCaps(DC, LOGPIXELSY);
  1914. p->LogPixelSY = GetDeviceCaps(DC, LOGPIXELSX);
  1915. p->ScreenWidth = WinPixelToUnitY(p,GetDeviceCaps(DC,HORZRES));
  1916. p->MenuSmall = WinPixelToUnitY(p,GetDeviceCaps(DC,VERTRES)) < 210;
  1917. ReleaseDC(p->Wnd,DC);
  1918. }
  1920. static void VScroll(win* p,int Cmd,int Delta);
  1921. static void HScroll(win* p,int Cmd,int Delta);
  1923. static void UpdateDialogSize(win* p)
  1924. {
  1925. RECT r;
  1926. GetClientRect(p->WndDialog,&r);
  1928. if (!p->ScrollV)
  1929. r.right -= GetSystemMetrics(SM_CXVSCROLL);
  1931. if (!p->ScrollH)
  1932. r.bottom -= GetSystemMetrics(SM_CYHSCROLL);
  1934. p->Width = WinPixelToUnitX(p,r.right);
  1935. p->Height = WinPixelToUnitY(p,r.bottom);
  1936. }
  1938. static void WinControlFocus(win* p,wincontrol* Control,bool_t Set)
  1939. {
  1940. wincontrol* i;
  1942. if (p->Focus == Control)
  1943. return;
  1945. if (Control && Control->Disabled)
  1946. return;
  1948. if (p->Focus)
  1949. for (i=p->Controls;i;i=i->Next)
  1950. if (i->Ref == p->Focus)
  1951. InvalidateRect(i->Control,NULL,TRUE);
  1953. p->Focus = Control;
  1955. if (Control)
  1956. {
  1957. POINT o;
  1958. RECT r;
  1959. int Min=MAX_INT;
  1960. int Max=-MAX_INT;
  1962. if (Control->Control && GetParent(Control->Control)==p->WndDialog)
  1963. {
  1964. GetWindowRect(Control->Control,&r);
  1965. if (r.bottom > Max)
  1966. Max = r.bottom;
  1967. if (r.top < Min)
  1968. Min = r.top;
  1969. }
  1971. for (i=p->Controls;i;i=i->Next)
  1972. if (i->Ref == Control)
  1973. {
  1974. GetWindowRect(i->Control,&r);
  1975. if (r.bottom > Max)
  1976. Max = r.bottom;
  1977. if (r.top < Min)
  1978. Min = r.top;
  1979. InvalidateRect(i->Control,NULL,TRUE);
  1980. }
  1982. if (Max > Min)
  1983. {
  1984. o.x = o.y = 0;
  1985. ClientToScreen(p->WndDialog,&o);
  1986. GetClientRect(p->WndDialog,&r);
  1988. r.top += o.y;
  1989. r.bottom += o.y;
  1991. if (r.top > Min)
  1992. VScroll(p,0,Max-r.bottom);
  1993. else
  1994. if (r.bottom < Max)
  1995. VScroll(p,0,Min-r.top);
  1996. }
  1998. if (Set)
  1999. if (Control->Control)
  2000. SetFocus(Control->Control);
  2001. else
  2002. SetFocus(p->WndDialog);
  2003. }
  2004. else
  2005. if (Set)
  2006. SetFocus(p->WndDialog);
  2007. }
  2009. static void WinNext(win* p,bool_t Prev)
  2010. {
  2011. wincontrol* Start = p->Focus;
  2012. wincontrol* Last;
  2013. wincontrol* i;
  2015. if (!Start)
  2016. {
  2017. Start = p->Controls;
  2018. if (!Start)
  2019. return;
  2020. if (!Start->Disabled)
  2021. {
  2022. WinControlFocus(p,Start,1);
  2023. return;
  2024. }
  2025. }
  2027. Last = Start;
  2028. do
  2029. {
  2030. if (Prev)
  2031. {
  2032. for (i=p->Controls;i->Next && i->Next!=Last;i=i->Next);
  2033. }
  2034. else
  2035. {
  2036. i = Last->Next;
  2037. if (!i) 
  2038. i=p->Controls;
  2039. }
  2040. Last = i;
  2041. }
  2042. while (i && i!=Start && i->Disabled);
  2044. WinControlFocus(p,i,1);
  2045. }
  2047. void WinPropFocus(win* p, node* Node, int No, bool_t SetFocus)
  2048. {
  2049. wincontrol* Control;
  2050. for (Control=p->Controls;Control;Control=Control->Next)
  2051. if (Control->Pin.Node == Node && Control->Pin.No == No)
  2052. {
  2053. WinControlFocus(p,Control,SetFocus);
  2054. break;
  2055. }
  2056. }
  2058. void WinPropUpdate(win* p, node* Node, int No)
  2059. {
  2060. wincontrol* Control;
  2061. for (Control=p->Controls;Control;Control=Control->Next)
  2062. if (Control->Pin.Node == Node && Control->Pin.No == No)
  2063. WinControlUpdate(p,Control);
  2064. }
  2066. static LRESULT CALLBACK DialogProc(HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam)
  2067. {
  2068. wincontrol* i;
  2069. int Result;
  2070. win* p = (win*)GetWindowLong(Wnd,GWL_USERDATA);
  2072. if (p && p->DialogProc && p->DialogProc(p,Msg,wParam,lParam,&Result))
  2073. return Result;
  2075. switch (Msg)
  2076. {
  2077. case WM_CREATE:
  2078. p = (win*)((CREATESTRUCT*)lParam)->lpCreateParams;
  2079. p->WndDialog = Wnd;
  2080. p->Controls = NULL;
  2081. p->Focus = NULL;
  2082. SetWindowLong(Wnd,GWL_USERDATA,(LONG)p);
  2083. break;
  2085. case WM_COMMAND:
  2086. i = (wincontrol*) GetWindowLong((HWND)lParam,GWL_USERDATA);
  2087. if (VALIDCONTROL(i))
  2088. WinControlCmd(p,i,(HWND)lParam,HIWORD(wParam));
  2089. break;
  2091. case WM_SIZE:
  2092. if (p)
  2093. UpdateDialogSize(p);
  2094. break;
  2096. case WM_SETFOCUS:
  2097. if (p->Focus && p->Focus->Control)
  2098. SetFocus(p->Focus->Control);
  2099. break;
  2101. case WM_DESTROY:
  2102. p->WndDialog = NULL;
  2103. break;
  2105. case WM_HSCROLL:
  2106. if (!lParam || !(GetWindowLong((HWND)lParam,GWL_STYLE) & (TBS_BOTH|TBS_NOTICKS|TBS_FIXEDLENGTH)))
  2107. HScroll(p,LOWORD(wParam),0);
  2108. else
  2109. {
  2110. i = (wincontrol*) GetWindowLong((HWND)lParam,GWL_USERDATA);
  2111. if (VALIDCONTROL(i))
  2112. {
  2113. WinControlFocus(p,i,1);
  2114. SetTrack(p,i,SendMessage((HWND)lParam,TBM_GETPOS,0,0));
  2115. }
  2116. }
  2117. break;
  2118. case WM_VSCROLL:
  2119. if (!lParam || !(GetWindowLong((HWND)lParam,GWL_STYLE) & (TBS_BOTH|TBS_NOTICKS|TBS_FIXEDLENGTH)))
  2120. VScroll(p,LOWORD(wParam),0);
  2121. break;
  2123. case WM_KEYDOWN:
  2124. if (wParam == VK_ESCAPE)
  2125. WinClose(p);
  2126. if (p->ScrollV && wParam == VK_UP)
  2127. VScroll(p,SB_LINEUP,0);
  2128. if (p->ScrollV && wParam == VK_DOWN)
  2129. VScroll(p,SB_LINEDOWN,0);
  2130. if (p->ScrollH && wParam == VK_LEFT)
  2131. HScroll(p,SB_LINEUP,0);
  2132. if (p->ScrollH && wParam == VK_RIGHT)
  2133. HScroll(p,SB_LINEDOWN,0);
  2134. break;
  2136. #if defined(TARGET_WINCE)
  2137. case WM_CTLCOLOREDIT:
  2138. SetBkColor((HDC)wParam,GetSysColor(COLOR_BTNFACE));
  2139. return (LRESULT) GetSysColorBrush(COLOR_BTNFACE);
  2140. #endif
  2142. case WM_CTLCOLORSTATIC:
  2143. i = (wincontrol*)GetWindowLong((HWND)lParam,GWL_USERDATA);
  2144. if (i && p->Focus && p->Focus == i->Ref)
  2145. {
  2146. if (p->Smartphone)
  2147. {
  2148. SetTextColor((HDC)wParam,GetSysColor(COLOR_HIGHLIGHTTEXT));
  2149. SetBkColor((HDC)wParam,GetSysColor(COLOR_HIGHLIGHT));
  2150. return (LRESULT) GetSysColorBrush(COLOR_HIGHLIGHT);
  2151. }
  2152. SetTextColor((HDC)wParam,0xC00000);
  2153. }
  2154. SetBkColor((HDC)wParam,GetSysColor(DIALOG_COLOR));
  2155. return (LRESULT) GetSysColorBrush(DIALOG_COLOR);
  2156. }
  2158. return DefWindowProc(Wnd,Msg,wParam,lParam);
  2159. }
  2161. static void WinScroll(win* p,int dx,int dy)
  2162. {
  2163. ScrollWindowEx(p->WndDialog, dx, dy, NULL, NULL, NULL, NULL, SW_SCROLLCHILDREN | SW_ERASE | SW_INVALIDATE );
  2164. }
  2166. static void WinUpdateScroll(win* p)
  2167. {
  2168. SCROLLINFO Scroll;
  2170. POINT Offset;
  2171. RECT Page;
  2172. int MaxWidth,MinWidth;
  2173. int MaxHeight,MinHeight;
  2174. HWND Child;
  2175. int XVScroll = GetSystemMetrics(SM_CXVSCROLL);
  2176. int YHScroll = GetSystemMetrics(SM_CYHSCROLL);
  2178. if (p->InUpdateScroll || p->OwnDialogSize)
  2179. return;
  2181. p->InUpdateScroll = 1;
  2183. Offset.x = Offset.y = 0;
  2184. ClientToScreen(p->WndDialog,&Offset);
  2185. GetClientRect(p->WndDialog,&Page);
  2187. if (p->ScrollV)
  2188. Page.right += XVScroll;
  2190. if (p->ScrollH)
  2191. Page.bottom += YHScroll;
  2193. MinWidth = 0;
  2194. MinHeight = 0;
  2195. MaxWidth = 0;
  2196. MaxHeight = 0;
  2198. Child = GetWindow(p->WndDialog,GW_CHILD);
  2199. while (Child && IsWindow(Child))
  2200. {
  2201. RECT r;
  2202. GetWindowRect(Child,&r);
  2204. r.left -= Offset.x;
  2205. r.right -= Offset.x; 
  2206. r.top -= Offset.y;
  2207. r.bottom -= Offset.y; 
  2208. r.bottom += YHScroll;
  2210. if (r.left < MinWidth) MinWidth = r.left;
  2211. if (r.right > MaxWidth) MaxWidth = r.right;
  2212. if (r.top < MinHeight) MinHeight = r.top;
  2213. if (r.bottom > MaxHeight) MaxHeight = r.bottom;
  2215. Child = GetWindow(Child,GW_HWNDNEXT);
  2216. }
  2218. Scroll.cbSize = sizeof(Scroll);
  2219. Scroll.fMask =  SIF_PAGE | SIF_RANGE | SIF_POS;
  2221. if (MaxHeight < Page.bottom)
  2222. MaxHeight = Page.bottom-1;
  2224. p->ScrollV = MaxHeight-MinHeight > Page.bottom;
  2225. Scroll.nMin = MinHeight;
  2226. Scroll.nMax = MaxHeight;
  2227. Scroll.nPos = 0;
  2228. Scroll.nPage = Page.bottom;
  2229. SetScrollInfo(p->WndDialog,SB_VERT,&Scroll,TRUE);
  2231. if (p->ScrollV)
  2232. Page.right -= XVScroll;
  2234. if (MaxWidth < Page.right)
  2235. MaxWidth = Page.right-1;
  2237. p->ScrollH = MaxWidth-MinWidth > Page.right;
  2238. Scroll.nMin = MinWidth;
  2239. Scroll.nMax = MaxWidth;
  2240. Scroll.nPos = 0;
  2241. Scroll.nPage = Page.right;
  2242. SetScrollInfo(p->WndDialog,SB_HORZ,&Scroll,TRUE);
  2244. p->InUpdateScroll = 0;
  2245. }
  2247. static void VScroll(win* p,int Cmd,int Delta)
  2248. {
  2249. int Pos;
  2250. SCROLLINFO Scroll;
  2252. Scroll.cbSize = sizeof(Scroll);
  2253. Scroll.fMask  = SIF_ALL;
  2254. GetScrollInfo(p->WndDialog, SB_VERT, &Scroll);
  2256. Pos = Scroll.nPos;
  2258. if (Delta)
  2259. Scroll.nPos += Delta;
  2260. else
  2261. switch (Cmd)
  2262. {
  2263. case SB_TOP:
  2264. Scroll.nPos = Scroll.nMin;
  2265. break;
  2266. case SB_BOTTOM:
  2267. Scroll.nPos = Scroll.nMax;
  2268. break;
  2269. case SB_LINEUP:
  2270. Scroll.nPos -= WinUnitToPixelY(p,16);
  2271. break;
  2272. case SB_LINEDOWN:
  2273. Scroll.nPos += WinUnitToPixelY(p,16);
  2274. break;
  2275. case SB_PAGEUP:
  2276. Scroll.nPos -= Scroll.nPage;
  2277. break;
  2278. case SB_PAGEDOWN:
  2279. Scroll.nPos += Scroll.nPage;
  2280. break;
  2281. case SB_THUMBTRACK:
  2282. Scroll.nPos = Scroll.nTrackPos;
  2283. break;
  2284. default:
  2285. break;
  2286. }
  2288. Scroll.fMask = SIF_POS;
  2289. SetScrollInfo(p->WndDialog, SB_VERT, &Scroll, TRUE);
  2290. GetScrollInfo(p->WndDialog, SB_VERT, &Scroll);
  2292. if (Scroll.nPos != Pos)
  2293. WinScroll(p,0,Pos - Scroll.nPos);
  2294. }
  2296. static void HScroll(win* p,int Cmd,int Delta)
  2297. {
  2298. int Pos;
  2299. SCROLLINFO Scroll;
  2301. Scroll.cbSize = sizeof(Scroll);
  2302. Scroll.fMask  = SIF_ALL;
  2303. GetScrollInfo(p->WndDialog, SB_HORZ, &Scroll);
  2305. Pos = Scroll.nPos;
  2307. if (Delta)
  2308. Scroll.nPos += Delta;
  2309. else
  2310. switch (Cmd)
  2311. {
  2312. case SB_TOP:
  2313. Scroll.nPos = Scroll.nMin;
  2314. break;
  2315. case SB_BOTTOM:
  2316. Scroll.nPos = Scroll.nMax;
  2317. break;
  2318. case SB_LINEUP:
  2319. Scroll.nPos -= WinUnitToPixelX(p,16);
  2320. break;
  2321. case SB_LINEDOWN:
  2322. Scroll.nPos += WinUnitToPixelX(p,16);
  2323. break;
  2324. case SB_PAGEUP:
  2325. Scroll.nPos -= Scroll.nPage;
  2326. break;
  2327. case SB_PAGEDOWN:
  2328. Scroll.nPos += Scroll.nPage;
  2329. break;
  2330. case SB_THUMBTRACK:
  2331. Scroll.nPos = Scroll.nTrackPos;
  2332. break;
  2333. default:
  2334. break;
  2335. }
  2337. Scroll.fMask = SIF_POS;
  2338. SetScrollInfo(p->WndDialog, SB_HORZ, &Scroll, TRUE);
  2339. GetScrollInfo(p->WndDialog, SB_HORZ, &Scroll);
  2341. if (Scroll.nPos != Pos)
  2342. WinScroll(p,Pos - Scroll.nPos,0);
  2343. }
  2345. static bool_t OwnWindow(HWND Wnd)
  2346. {
  2347. tchar_t ClassName[64];
  2348. for (;Wnd;Wnd=GetParent(Wnd))
  2349. {
  2350. GetClassName(Wnd,ClassName,64);
  2351. if (tcscmp(ClassName,WinClass.lpszClassName)==0 || 
  2352. tcscmp(ClassName,T("VolumeBack"))==0)
  2353. return 1;
  2354. }
  2355. return 0;
  2356. }
  2358. void ForwardMenuButtons(win* p,int Msg,uint32_t wParam,uint32_t lParam)
  2359. {
  2360. #if defined(TARGET_WINCE)
  2361. if (p->WndTB && (wParam == VK_F1 || wParam == VK_F2) &&
  2362. (QueryPlatform(PLATFORM_TYPENO) == TYPE_POCKETPC || 
  2363.  QueryPlatform(PLATFORM_TYPENO) == TYPE_SMARTPHONE))
  2364. {
  2365. if (Msg == WM_KEYDOWN && !(lParam & (1<<30)))
  2366. {
  2367. PostMessage(p->WndTB,WM_HOTKEY,0,MAKELPARAM(0,wParam));
  2368. PostMessage(p->WndTB,WM_HOTKEY,0,MAKELPARAM(0x1000,wParam));
  2369. }
  2370. }
  2371. #endif
  2372. }
  2374. static LRESULT CALLBACK Proc(HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam)
  2375. {
  2376. int Result = 0;
  2377. win* p = (win*)GetWindowLong(Wnd,GWL_USERDATA);
  2379. switch (Msg)
  2380. {
  2381. #if defined(TARGET_WINCE)
  2382. case WM_HOTKEY:
  2383. if (p->Parent && HIWORD(lParam)==VK_ESCAPE)
  2384. {
  2385. HWND Focus = GetFocus();
  2386. wincontrol* i = (wincontrol*)GetWindowLong(Focus,GWL_USERDATA);
  2387. if (FuncSHSendBackToFocusWindow && ((VALIDCONTROL(i) && i->Editor) || (!VALIDCONTROL(i) && i)))
  2388. FuncSHSendBackToFocusWindow(Msg,wParam,lParam);
  2389. else
  2390. {
  2391. p->HotKeyEscape = !p->HotKeyEscape;
  2392. if (!p->HotKeyEscape)
  2393. PostMessage(p->Wnd,WM_CLOSE,0,0);
  2394. }
  2395. return 0;
  2396. }
  2397. break;
  2398. #endif
  2400. case WM_CREATE:
  2402. p = (win*)((CREATESTRUCT*)lParam)->lpCreateParams;
  2403. p->Wnd = Wnd;
  2404. p->Module = ((CREATESTRUCT*)lParam)->hInstance;
  2405. p->Result = 1;
  2406. p->Focus = NULL;
  2407. p->Closed = 0;
  2409. UpdateDPI(p);
  2411. #if defined(TARGET_WINCE)
  2412. p->Activate = malloc(sizeof(SHACTIVATEINFO));
  2413. if (p->Activate)
  2414. {
  2415. memset(p->Activate,0,sizeof(SHACTIVATEINFO));
  2416. ((SHACTIVATEINFO*)p->Activate)->cbSize = sizeof(SHACTIVATEINFO);
  2417. }
  2418. #endif
  2420. if (p->Proc)
  2421. p->Proc(p,MSG_PREPARE,0,0,&Result);
  2422. CreateToolBar(p);
  2424. SetWindowLong(Wnd,GWL_USERDATA,(LONG)p); // only after CreateToolBar (WM_MOVE)
  2426. if (p->Flags & WIN_DIALOG)
  2427. {
  2428. RECT r;
  2429. GetClientRect(p->Wnd,&r);
  2430. CreateWindow(DialogClass.lpszClassName,NULL,WS_CLIPCHILDREN|WS_CHILD|WS_VISIBLE,
  2431. 0,p->ToolBarHeight,r.right,r.bottom-p->ToolBarHeight,p->Wnd,NULL,DialogClass.hInstance,p);
  2432. }
  2434. if (p->Init)
  2435. p->Init(p);
  2437. if (!p->Focus)
  2438. WinNext(p,0);
  2439. break;
  2441. case WM_CLOSE:
  2443. p->Closed = 1;
  2444. p->Focus = NULL;
  2445. SetFocus(NULL);
  2447. if (p->Done)
  2448. p->Done(p);
  2450. if (p->WndDialog)
  2451. ShowWindow(p->WndDialog,SW_HIDE);
  2452. WinClear(p);
  2454. if (p->Parent)
  2455. {
  2456. EnableWindow(p->Parent->Wnd,TRUE);
  2457. p->Parent->Child = NULL;
  2458. SetForegroundWindow(p->Parent->Wnd);
  2459. DestroyWindow(p->Wnd);
  2460. }
  2461. break;
  2463. case WM_SETFOCUS:
  2464. if (p->WndDialog)
  2465. SetFocus(p->WndDialog);
  2466. if (!p->Parent)
  2467. WidcommAudio_Wnd(p->Wnd);
  2468. break;
  2470. case WM_SIZE:
  2471. if (p)
  2472. {
  2473. RECT r;
  2474. GetClientRect(p->Wnd,&r);
  2476. if (p->ToolBarHeight)
  2477. MoveWindow(p->WndTB,0,0,r.right,p->ToolBarHeight,TRUE);
  2479. if (p->WndDialog && !p->OwnDialogSize)
  2480. MoveWindow(p->WndDialog,0,p->ToolBarHeight,r.right,r.bottom-p->ToolBarHeight,TRUE);
  2481. }
  2482. break;
  2484. case WM_DESTROY:
  2485. WinSetFullScreen(p,0);
  2486. DestroyToolBar(p);
  2487. if (p->Menu3)
  2488. DestroyMenu(p->Menu3);
  2489. p->Wnd = NULL;
  2490. p->WndTB = NULL;
  2491. memset(p->Menu2,0,sizeof(p->Menu2));
  2492. break;
  2494. case WM_COMMAND:
  2495. if (LOWORD(wParam) == WIN_A)
  2496. wParam = p->WinCmd[0];
  2497. if (LOWORD(wParam) == WIN_B)
  2498. wParam = p->WinCmd[1];
  2499. if (LOWORD(wParam) == IDOK)
  2500. wParam = PLATFORM_OK;
  2501. if (p->Command && p->Command(p,LOWORD(wParam))==ERR_NONE)
  2502. return 0;
  2503. if (LOWORD(wParam) == PLATFORM_OK ||
  2504. LOWORD(wParam) == PLATFORM_DONE ||
  2505. LOWORD(wParam) == PLATFORM_CANCEL)
  2506. {
  2507. WinClose(p);
  2508. return 0;
  2509. }
  2510. break;
  2512. case WM_ACTIVATE:
  2513. if (LOWORD(wParam)!=WA_INACTIVE)
  2514. {
  2515. if (WidcommAudio_SkipActivate())
  2516. return 0;
  2517. if (!p->Parent)
  2518. WidcommAudio_Wnd(p->Wnd);
  2519. if (p->Child)
  2520. {
  2521. SetForegroundWindow(p->Child->Wnd);
  2522. return 0;
  2523. }
  2524. }
  2526. #if defined(TARGET_WINCE)
  2527. if (FuncSHHandleWMActivate && p->Activate && !TaskBarHidden)
  2528. FuncSHHandleWMActivate(Wnd, wParam, lParam, p->Activate, FALSE);
  2529. #endif
  2530. break;
  2532. case WM_SETTINGCHANGE:
  2533. #if defined(TARGET_WINCE) 
  2534. if (FuncSHHandleWMSettingChange && p->Activate && !TaskBarHidden)
  2535. FuncSHHandleWMSettingChange(Wnd, wParam, lParam, p->Activate);
  2536. #endif
  2537. UpdateDPI(p);
  2538. break;
  2539. }
  2541. if (p)
  2542. {
  2543. if (p->Proc && p->Proc(p,Msg,wParam,lParam,&Result))
  2544. return Result;
  2546. if (Msg == WM_ACTIVATE && !OwnWindow((HWND)lParam))
  2547. {
  2548. if (LOWORD(wParam)==WA_INACTIVE)
  2549. {
  2550. bool_t b = 1;
  2551. node* Player = Context()->Player;
  2552. if (Player && Main && !Main->Closed)
  2553. Player->Set(Player,PLAYER_BACKGROUND,&b,sizeof(b));
  2555. #if defined(TARGET_WINCE)
  2556. if (TaskBarHidden)
  2557. {
  2558. DIASet(DIA_TASKBAR,DIA_TASKBAR);
  2559. TaskBarHidden = 1;
  2560. }
  2561. #endif
  2562. }
  2563. else
  2564. {
  2565. bool_t b = 0;
  2566. node* Player = Context()->Player;
  2567. if (Player && Main && !Main->Closed)
  2568. Player->Set(Player,PLAYER_BACKGROUND,&b,sizeof(b));
  2570. #if defined(TARGET_WINCE)
  2571. if (TaskBarHidden)
  2572. {
  2573. TaskBarHidden = 0;
  2574. DIASet(0,DIA_TASKBAR);
  2575. }
  2576. #endif
  2577. }
  2578. }
  2580. #if defined(TARGET_WINCE)
  2581. if (Msg == WM_CREATE && !p->AygShellTB && ((p->Flags & WIN_DIALOG) || GetSystemMetrics(SM_CXSCREEN)>240))
  2582. CommandBar_AddAdornments(p->WndTB,p->NeedOK ? CMDBAR_OK:0,0);
  2583. #endif
  2584. if (p->WndDialog && (Msg == WM_CREATE || Msg == WM_SIZE))
  2585. WinUpdateScroll(p);
  2586. }
  2588. return DefWindowProc(Wnd,Msg,wParam,lParam);
  2589. }
  2591. static void HandleMessage(win* p,MSG* Msg)
  2592. {
  2593. int Result;
  2595. #if defined(TARGET_WINCE)
  2596. if (Msg->message == WM_HIBERNATE)
  2597. {
  2598. if (AvailMemory() < 256*1024) // don't mess up format_base buffering...
  2599. NodeHibernate();
  2600. }
  2601. #endif
  2603. if (Msg->message >= WM_APP + 0x200 && 
  2604. Msg->message <= WM_APP + 0x220)
  2605. {
  2606. // send to application window
  2607. win* Appl=p;
  2608. while (Appl->Parent)
  2609. Appl=Appl->Parent;
  2611. if (Appl->Proc(Appl,Msg->message,Msg->wParam,Msg->lParam,&Result))
  2612. return;
  2613. }
  2615. if (Msg->message == WM_KEYDOWN)
  2616. {
  2617. if (p->CaptureKeys && p->Proc && p->Proc(p,Msg->message,Msg->wParam,Msg->lParam,&Result))
  2618. return;
  2620. if (p->Focus)
  2621. {
  2622. int Type;
  2623. switch (Msg->wParam)
  2624. {
  2625. case VK_LEFT:
  2626. case VK_RIGHT:
  2627. if (!p->Focus->ListView)
  2628. {
  2629. Type = GetDataDefType(p->Focus);
  2630. if (!Type || Type == TYPE_BOOL || Type == TYPE_RESET || Type == TYPE_HOTKEY)
  2631. {
  2632. SendMessage(p->WndDialog,Msg->message,Msg->wParam,Msg->lParam);
  2633. return;
  2634. }
  2635. }
  2636. break;
  2637. case VK_RETURN:
  2638. Type = GetDataDefType(p->Focus);
  2639. if (Type == TYPE_BOOL || Type == TYPE_RESET || Type == TYPE_HOTKEY)
  2640. {
  2641. SendMessage(p->Focus->Control,BM_CLICK,0,0);
  2642. return;
  2643. }
  2644. if (p->Focus->ComboBox && !p->ComboOpen)
  2645. {
  2646. SendMessage(p->Focus->Control,CB_SHOWDROPDOWN,1,0);
  2647. return;
  2648. }
  2649. if (Type == TYPE_STRING)
  2650. {
  2651. SendMessage(p->WndDialog,Msg->message,Msg->wParam,Msg->lParam);
  2652. return;
  2653. }
  2654. break;
  2655. case VK_DOWN:
  2656. case VK_UP:
  2657. if (!p->ComboOpen && !p->Focus->ListView)
  2658. {
  2659. WinNext(p,Msg->wParam==VK_UP);
  2660. return;
  2661. }
  2662. break;
  2663. case VK_TAB:
  2664. WinNext(p,GetKeyState(VK_SHIFT)<0);
  2665. return;
  2666. }
  2667. }
  2668. }
  2670. TranslateMessage(Msg);
  2671. DispatchMessage(Msg);
  2672. }
  2674. int WinPopupClass(int Class,win* Parent)
  2675. {
  2676. int Result = 0;
  2677. node* p = NodeCreate(Class);
  2678. if (p && NodeIsClass(p->Class,WIN_CLASS))
  2679. {
  2680. Result = ((win*)p)->Popup((win*)p,Parent);
  2681. NodeDelete(p);
  2682. }
  2683. return Result;
  2684. }
  2686. static int Popup(win* p,win* Parent)
  2687. {
  2688. HWND Wnd;
  2689. MSG Msg;
  2690. int Style = WS_VISIBLE;
  2691. int ExStyle = 0;
  2692. int x,y;
  2693. int Width,Height;
  2694. int Priority;
  2696. // we need higher priority in main window for better user interface responses
  2697. // but open dialog and other parts can't have that, because of some buggy keyboard drivers...
  2698. Priority = ThreadPriority(NULL,Parent?0:-1);
  2700. p->Result = 0;
  2701. p->Parent = Parent;
  2703. p->BitmapNo = 0;
  2704. p->AygShellTB = 0;
  2706. #if defined(TARGET_WINCE)
  2707. if (AygShell && Parent)
  2708. ExStyle |= WS_EX_CAPTIONOKBTN;
  2710. if (Parent)
  2711. Style |= WS_POPUP;
  2713. {
  2714. RECT r;
  2715. GetWorkArea(p,&r);
  2716. x = r.left;
  2717. y = r.top;
  2718. Width = r.right - r.left;
  2719. Height = r.bottom - r.top;
  2720. }
  2721. #else
  2722. Style |= WS_OVERLAPPEDWINDOW;
  2723. y = x = CW_USEDEFAULT;
  2724. Width = WinUnitToPixelX(p,p->WinWidth);
  2725. Height = WinUnitToPixelY(p,p->WinHeight);
  2726. #endif
  2728. Wnd = CreateWindowEx(ExStyle,WinClass.lpszClassName,LangStr(p->Node.Class,NODE_NAME),Style,x,y,Width,Height,
  2729. Parent?Parent->Wnd:NULL,NULL,WinClass.hInstance,p);
  2731. if (Wnd)
  2732. {
  2733. if (p->Parent)
  2734. {
  2735. p->Parent->Child = p;
  2736. EnableWindow(p->Parent->Wnd,0);
  2737. }
  2738. else
  2739. Main = p;
  2741. while (p->Wnd && GetMessage(&Msg, NULL, 0, 0)) 
  2742. HandleMessage(p,&Msg);
  2744. if (Main == p)
  2745. Main = NULL;
  2746. }
  2748. ThreadPriority(NULL,Priority);
  2749. return p->Result;
  2750. }
  2752. static int Create(win* p)
  2753. {
  2754. UpdateDPI(p); // with NULL Wnd, because we need ScreenWidth
  2755. p->Smartphone = QueryPlatform(PLATFORM_TYPENO) == TYPE_SMARTPHONE;
  2756. p->Popup = Popup;
  2757. p->Closed = 1;
  2758. return ERR_NONE;
  2759. }
  2761. static const nodedef Win = 
  2762. {
  2763. CF_ABSTRACT,
  2764. WIN_CLASS,
  2765. NODE_CLASS,
  2766. PRI_DEFAULT,
  2767. (nodecreate)Create
  2768. };
  2770. void Win_Init()
  2771. {
  2772. HMODULE Module = Context()->LoadModule;
  2773. if (!Module) Module = GetModuleHandle(NULL);
  2775. InitCommonControls();
  2776. WidcommAudio_Init();
  2778. stprintf_s(WinClassName,TSIZEOF(WinClassName),T("%s_Win"),Context()->ProgramName);
  2780. memset(&WinClass,0,sizeof(WinClass));
  2781.     WinClass.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
  2782.     WinClass.lpfnWndProc = Proc;
  2783.     WinClass.cbClsExtra = 0;
  2784.     WinClass.cbWndExtra = 0;
  2785.     WinClass.hInstance = Module;
  2786. WinClass.hIcon = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(WIN_ICON));
  2787.     WinClass.hCursor = WinCursorArrow();
  2788.     WinClass.hbrBackground = NULL;
  2789.     WinClass.lpszMenuName = 0;
  2790.     WinClass.lpszClassName = WinClassName;
  2791. RegisterClass(&WinClass);
  2793. memset(&DialogClass,0,sizeof(DialogClass));
  2794.     DialogClass.style = CS_HREDRAW | CS_VREDRAW;
  2795.     DialogClass.lpfnWndProc = DialogProc;
  2796.     DialogClass.cbClsExtra = 0;
  2797.     DialogClass.cbWndExtra = 0;
  2798.     DialogClass.hInstance = Module;
  2799.     DialogClass.hCursor = WinCursorArrow();
  2800. #if defined(TARGET_WINCE)
  2801. DialogClass.hbrBackground = GetSysColorBrush(COLOR_STATIC);
  2802. #else
  2803. DialogClass.hbrBackground = GetSysColorBrush(COLOR_BTNFACE);
  2804. #endif
  2805.     DialogClass.lpszMenuName = 0;
  2806.     DialogClass.lpszClassName = T("DialogBase");
  2807. RegisterClass(&DialogClass);
  2809. memset(&FontCache,0,sizeof(FontCache));
  2811. #if defined(TARGET_WINCE)
  2812. if (Context()->ProgramId >= 3 && !QueryAdvanced(ADVANCED_OLDSHELL))
  2813. {
  2814. AygShell = LoadLibrary(T("aygshell.dll"));
  2815. *(FARPROC*)&FuncSHCreateMenuBar = GetProcAddress(AygShell,T("SHCreateMenuBar"));
  2816. *(FARPROC*)&FuncSHInitDialog = GetProcAddress(AygShell,T("SHInitDialog"));
  2817. *(FARPROC*)&FuncSHFullScreen = GetProcAddress(AygShell,T("SHFullScreen"));
  2818. *(FARPROC*)&FuncSHHandleWMActivate = GetProcAddress(AygShell,MAKEINTRESOURCE(84));
  2819. *(FARPROC*)&FuncSHHandleWMSettingChange = GetProcAddress(AygShell,MAKEINTRESOURCE(83));
  2820. *(FARPROC*)&FuncSHSendBackToFocusWindow = GetProcAddress(AygShell,MAKEINTRESOURCE(97));
  2821. }
  2822. CoreDLL = LoadLibrary(T("coredll.dll"));
  2823. *(FARPROC*)&FuncUnregisterFunc1 = GetProcAddress(CoreDLL,T("UnregisterFunc1"));
  2824. *(FARPROC*)&FuncAllKeys = GetProcAddress(CoreDLL,T("AllKeys")); //MAKEINTRESOURCE(1453));
  2825. *(FARPROC*)&FuncSipShowIM = GetProcAddress(CoreDLL,T("SipShowIM"));
  2826. *(FARPROC*)&FuncSipGetInfo = GetProcAddress(CoreDLL,T("SipGetInfo"));
  2827. #endif
  2828. NodeRegisterClass(&Win);
  2829. QueryKey_Init();
  2830. OpenFile_Init();
  2831. Interface_Init();
  2832. PlaylistWin_Init();
  2833. }
  2835. void Win_Done()
  2836. {
  2837. int No;
  2838. Interface_Done();
  2839. PlaylistWin_Done();
  2840. QueryKey_Done();
  2841. OpenFile_Done();
  2842. NodeUnRegisterClass(WIN_CLASS);
  2843. for (No=0;No<MAXFONTSIZE;++No)
  2844. {
  2845. if (FontCache[No][0])
  2846. DeleteObject(FontCache[No][0]);
  2847. if (FontCache[No][1])
  2848. DeleteObject(FontCache[No][1]);
  2849. }
  2850. UnregisterClass(DialogClass.lpszClassName,DialogClass.hInstance);
  2851. UnregisterClass(WinClass.lpszClassName,WinClass.hInstance);
  2852. WidcommAudio_Done();
  2853. #if defined(TARGET_WINCE)
  2854. if (CoreDLL)
  2855. FreeLibrary(CoreDLL);
  2856. if (AygShell)
  2857. FreeLibrary(AygShell);
  2858. #endif
  2859. }
  2861. void WinShowHTML(const tchar_t* Name)
  2862. {
  2863. SHELLEXECUTEINFO Info;
  2864. tchar_t Path[MAXPATH];
  2865. tchar_t Base[MAXPATH];
  2866. tchar_t* p;
  2868. GetModuleFileName(NULL,Base,MAXPATH);
  2869. p = tcsrchr(Base,'\');
  2870. if (p) *p=0;
  2871. AbsPath(Path,TSIZEOF(Path),Name,Base);
  2873. memset(&Info,0,sizeof(Info));
  2874. Info.cbSize = sizeof(Info);
  2875. Info.lpVerb = T("open");
  2876. Info.lpFile = Path;
  2877. Info.nShow = SW_SHOW;
  2879. DIASet(DIA_TASKBAR,DIA_TASKBAR);
  2880. ShellExecuteEx(&Info);
  2881. }
  2883. #endif