Changeset 64

Show
Ignore:
Timestamp:
04/07/08 23:30:23 (6 months ago)
Author:
Chris Miller
Message:

Added compile-time versions.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/win32/dfl/application.d

    r54 r64  
    99 
    1010private import dfl.base, dfl.form, dfl.internal.winapi, dfl.event; 
    11 private import dfl.control, dfl.menu, dfl.drawing, dfl.label; 
     11private import dfl.control, dfl.drawing, dfl.label; 
    1212private import dfl.button, dfl.textbox, dfl.internal.wincom, dfl.environment; 
    13 private import dfl.resources; 
    1413private import dfl.internal.utf; 
     14 
     15version(DFL_NO_RESOURCES) 
     16{ 
     17} 
     18else 
     19{ 
     20    private import dfl.resources; 
     21} 
     22 
     23version(DFL_NO_MENUS) 
     24{ 
     25} 
     26else 
     27{ 
     28    private import dfl.menu; 
     29} 
    1530 
    1631 
    …… 
    9891004     
    9901005     
    991     // Returns its new unique menu ID. 
    992     package int addMenuItem(MenuItem menu) 
    993     { 
    994         if(nmenus == END_MENU_ID - FIRST_MENU_ID) 
    995             throw new DflException("Out of menus"); 
    996          
    997         typeof(menus) tempmenus; 
    998          
    999         // TODO: sort menu IDs in 'menus' so that looking for free ID is much faster. 
    1000          
    1001         prevMenuID++; 
    1002         if(prevMenuID >= END_MENU_ID || prevMenuID <= FIRST_MENU_ID) 
    1003         { 
    1004             prevMenuID = FIRST_MENU_ID; 
    1005             previdloop: 
    1006             for(;;) 
    1007             { 
    1008                 for(size_t iw; iw != nmenus; iw++) 
     1006    version(DFL_NO_MENUS) 
     1007    { 
     1008    } 
     1009    else 
     1010    { 
     1011        // Returns its new unique menu ID. 
     1012        package int addMenuItem(MenuItem menu) 
     1013        { 
     1014            if(nmenus == END_MENU_ID - FIRST_MENU_ID) 
     1015                throw new DflException("Out of menus"); 
     1016             
     1017            typeof(menus) tempmenus; 
     1018             
     1019            // TODO: sort menu IDs in 'menus' so that looking for free ID is much faster. 
     1020             
     1021            prevMenuID++; 
     1022            if(prevMenuID >= END_MENU_ID || prevMenuID <= FIRST_MENU_ID) 
     1023            { 
     1024                prevMenuID = FIRST_MENU_ID; 
     1025                previdloop: 
     1026                for(;;) 
    10091027                { 
    1010                     MenuItem mi; 
    1011                     mi = cast(MenuItem)menus[iw]; 
    1012                     if(mi) 
     1028                    for(size_t iw; iw != nmenus; iw++) 
    10131029                    { 
    1014                         if(prevMenuID == mi._menuID) 
     1030                        MenuItem mi; 
     1031                        mi = cast(MenuItem)menus[iw]; 
     1032                        if(mi) 
    10151033                        { 
    1016                             prevMenuID++; 
    1017                             continue previdloop; 
     1034                            if(prevMenuID == mi._menuID) 
     1035                            { 
     1036                                prevMenuID++; 
     1037                                continue previdloop; 
     1038                            } 
    10181039                        } 
    10191040                    } 
     1041                    break; 
    10201042                } 
    1021                 break; 
    1022             } 
    1023         } 
    1024         tempmenus = cast(Menu*)dfl.internal.clib.realloc(menus, Menu.sizeof * (nmenus + 1)); 
    1025         if(!tempmenus) 
    1026         { 
    1027             //throw new OutOfMemory; 
    1028             throw new DflException("Out of memory"); 
    1029         } 
    1030         menus = tempmenus; 
    1031          
    1032         menus[nmenus++] = menu; 
    1033          
    1034         return prevMenuID; 
    1035     } 
    1036      
    1037      
    1038     package void addContextMenu(ContextMenu menu) 
    1039     { 
    1040         if(nmenus == END_MENU_ID - FIRST_MENU_ID) 
    1041             throw new DflException("Out of menus"); 
    1042          
    1043         typeof(menus) tempmenus; 
    1044         int idx; 
    1045          
    1046         idx = nmenus; 
    1047         nmenus++; 
    1048         tempmenus = cast(Menu*)dfl.internal.clib.realloc(menus, Menu.sizeof * nmenus); 
    1049         if(!tempmenus) 
    1050         { 
    1051             nmenus--; 
    1052             //throw new OutOfMemory; 
    1053             throw new DflException("Out of memory"); 
    1054         } 
    1055         menus = tempmenus; 
    1056          
    1057         menus[idx] = menu; 
    1058     } 
    1059      
    1060      
    1061     package void removeMenu(Menu menu) 
    1062     { 
    1063         uint idx; 
    1064          
    1065         for(idx = 0; idx != nmenus; idx++) 
    1066         { 
    1067             if(menus[idx] is menu) 
    1068             { 
    1069                 goto found; 
    1070             } 
    1071         } 
    1072         return; 
    1073          
    1074         found: 
    1075         if(nmenus == 1) 
    1076         { 
    1077             dfl.internal.clib.free(menus); 
    1078             menus = null; 
    1079             nmenus--; 
    1080         } 
    1081         else 
    1082         { 
    1083             if(idx != nmenus - 1) 
    1084                 menus[idx] = menus[nmenus - 1]; // Move last one in its place 
    1085              
    1086             nmenus--; 
    1087             menus = cast(Menu*)dfl.internal.clib.realloc(menus, Menu.sizeof * nmenus); 
    1088             assert(menus != null); // Memory shrink shouldn't be a problem. 
    1089         } 
    1090     } 
    1091      
    1092      
    1093     package MenuItem lookupMenuID(int menuID) 
    1094     { 
    1095         uint idx; 
    1096         MenuItem mi; 
    1097          
    1098         for(idx = 0; idx != nmenus; idx++) 
    1099         { 
    1100             mi = cast(MenuItem)menus[idx]; 
    1101             if(mi && mi._menuID == menuID) 
    1102                 return mi; 
    1103         } 
    1104         return null; 
    1105     } 
    1106      
    1107      
    1108     package Menu lookupMenu(HMENU hmenu) 
    1109     { 
    1110         uint idx; 
    1111          
    1112         for(idx = 0; idx != nmenus; idx++) 
    1113         { 
    1114             if(menus[idx].handle == hmenu) 
    1115                 return menus[idx]; 
    1116         } 
    1117         return null; 
     1043            } 
     1044            tempmenus = cast(Menu*)dfl.internal.clib.realloc(menus, Menu.sizeof * (nmenus + 1)); 
     1045            if(!tempmenus) 
     1046            { 
     1047                //throw new OutOfMemory; 
     1048                throw new DflException("Out of memory"); 
     1049            } 
     1050            menus = tempmenus; 
     1051             
     1052            menus[nmenus++] = menu; 
     1053             
     1054            return prevMenuID; 
     1055        } 
     1056         
     1057         
     1058        package void addContextMenu(ContextMenu menu) 
     1059        { 
     1060            if(nmenus == END_MENU_ID - FIRST_MENU_ID) 
     1061                throw new DflException("Out of menus"); 
     1062             
     1063            typeof(menus) tempmenus; 
     1064            int idx; 
     1065             
     1066            idx = nmenus; 
     1067            nmenus++; 
     1068            tempmenus = cast(Menu*)dfl.internal.clib.realloc(menus, Menu.sizeof * nmenus); 
     1069            if(!tempmenus) 
     1070            { 
     1071                nmenus--; 
     1072                //throw new OutOfMemory; 
     1073                throw new DflException("Out of memory"); 
     1074            } 
     1075            menus = tempmenus; 
     1076             
     1077            menus[idx] = menu; 
     1078        } 
     1079         
     1080         
     1081        package void removeMenu(Menu menu) 
     1082        { 
     1083            uint idx; 
     1084             
     1085            for(idx = 0; idx != nmenus; idx++) 
     1086            { 
     1087                if(menus[idx] is menu) 
     1088                { 
     1089                    goto found; 
     1090                } 
     1091            } 
     1092            return; 
     1093             
     1094            found: 
     1095            if(nmenus == 1) 
     1096            { 
     1097                dfl.internal.clib.free(menus); 
     1098                menus = null; 
     1099                nmenus--; 
     1100            } 
     1101            else 
     1102            { 
     1103                if(idx != nmenus - 1) 
     1104                    menus[idx] = menus[nmenus - 1]; // Move last one in its place 
     1105                 
     1106                nmenus--; 
     1107                menus = cast(Menu*)dfl.internal.clib.realloc(menus, Menu.sizeof * nmenus); 
     1108                assert(menus != null); // Memory shrink shouldn't be a problem. 
     1109            } 
     1110        } 
     1111         
     1112         
     1113        package MenuItem lookupMenuID(int menuID) 
     1114        { 
     1115            uint idx; 
     1116            MenuItem mi; 
     1117             
     1118            for(idx = 0; idx != nmenus; idx++) 
     1119            { 
     1120                mi = cast(MenuItem)menus[idx]; 
     1121                if(mi && mi._menuID == menuID) 
     1122                    return mi; 
     1123            } 
     1124            return null; 
     1125        } 
     1126         
     1127         
     1128        package Menu lookupMenu(HMENU hmenu) 
     1129        { 
     1130            uint idx; 
     1131             
     1132            for(idx = 0; idx != nmenus; idx++) 
     1133            { 
     1134                if(menus[idx].handle == hmenu) 
     1135                    return menus[idx]; 
     1136            } 
     1137            return null; 
     1138        } 
    11181139    } 
    11191140     
    …… 
    11251146     
    11261147     
    1127     /// 
    1128     Resources resources() // getter 
    1129     { 
    1130         static Resources rc = null; 
    1131          
    1132         if(!rc) 
    1133         { 
    1134             synchronized 
    1135             { 
    1136                 if(!rc) 
     1148    version(DFL_NO_RESOURCES) 
     1149    { 
     1150    } 
     1151    else 
     1152    { 
     1153        /// 
     1154        Resources resources() // getter 
     1155        { 
     1156            static Resources rc = null; 
     1157             
     1158            if(!rc) 
     1159            { 
     1160                synchronized 
    11371161                { 
    1138                     rc = new Resources(getInstance()); 
     1162                    if(!rc) 
     1163                    { 
     1164                        rc = new Resources(getInstance()); 
     1165                    } 
    11391166                } 
    11401167            } 
    1141         } 
    1142         return rc; 
     1168           return rc; 
     1169        } 
    11431170    } 
    11441171     
    …… 
    13181345        DWORD tlsHook; // HHOOK. 
    13191346    Control[HWND] controls; 
    1320     ushort prevMenuID = FIRST_MENU_ID; 
    13211347    HINSTANCE hinst; 
    13221348    ApplicationContext ctx = null; 
    13231349     
    1324     // malloc() is needed so the menus can be garbage collected. 
    1325     uint nmenus = 0; // Number of -menus-. 
    1326     Menu* menus = null; // WARNING: malloc()'d memory! 
    1327      
    1328      
    1329     // Menus. 
    1330     const ushort FIRST_MENU_ID = 200; 
    1331     const ushort END_MENU_ID = 10000; 
    1332      
    1333     // Controls. 
    1334     const ushort FIRST_CTRL_ID = END_MENU_ID + 1; 
    1335     const ushort LAST_CTRL_ID = 65500; 
    1336      
    1337      
    1338     // Destroy all menu handles at program exit because Windows will not 
    1339     // unless it is assigned to a window. 
    1340     // Note that this is probably just a 16bit issue, but it still appeared in the 32bit docs. 
    1341     private void sdtorFreeAllMenus() 
    1342     { 
    1343         foreach(Menu m; menus[0 .. nmenus]) 
    1344         { 
    1345             DestroyMenu(m.handle); 
    1346         } 
    1347         nmenus = 0; 
    1348         dfl.internal.clib.free(menus); 
    1349         menus = null; 
     1350    version(DFL_NO_MENUS) 
     1351    { 
     1352    } 
     1353    else 
     1354    { 
     1355        ushort prevMenuID = FIRST_MENU_ID; 
     1356        // malloc() is needed so the menus can be garbage collected. 
     1357        uint nmenus = 0; // Number of -menus-. 
     1358        Menu* menus = null; // WARNING: malloc()'d memory! 
     1359         
     1360         
     1361        // Menus. 
     1362        const ushort FIRST_MENU_ID = 200; 
     1363        const ushort END_MENU_ID = 10000; 
     1364         
     1365        // Controls. 
     1366        const ushort FIRST_CTRL_ID = END_MENU_ID + 1; 
     1367        const ushort LAST_CTRL_ID = 65500; 
     1368         
     1369         
     1370        // Destroy all menu handles at program exit because Windows will not 
     1371        // unless it is assigned to a window. 
     1372        // Note that this is probably just a 16bit issue, but it still appeared in the 32bit docs. 
     1373        private void sdtorFreeAllMenus() 
     1374        { 
     1375            foreach(Menu m; menus[0 .. nmenus]) 
     1376            { 
     1377                DestroyMenu(m.handle); 
     1378            } 
     1379            nmenus = 0; 
     1380            dfl.internal.clib.free(menus); 
     1381            menus = null; 
     1382        } 
    13501383    } 
    13511384     
    …… 
    21272160static ~this() 
    21282161{ 
    2129     Application.sdtorFreeAllMenus(); 
     2162    version(DFL_NO_MENUS) 
     2163    { 
     2164    } 
     2165    else 
     2166    { 
     2167        Application.sdtorFreeAllMenus(); 
     2168    } 
    21302169     
    21312170    if(hmodRichtextbox) 

  • trunk/win32/dfl/control.d

    r62 r64  
    88private import dfl.internal.dlib, dfl.internal.clib; 
    99     
    10 private import dfl.base, dfl.menu, dfl.form, dfl.drawing; 
     10private import dfl.base, dfl.form, dfl.drawing; 
    1111private import dfl.internal.winapi, dfl.application, dfl.event, dfl.label; 
    1212private import dfl.internal.wincom, dfl.internal.utf, dfl.collections, dfl.internal.com; 
    1313 
    14 version(NO_DRAG_DROP) {} else 
     14 
     15version(NO_DRAG_DROP) 
     16    version = DFL_NO_DRAG_DROP; 
     17 
     18version(DFL_NO_DRAG_DROP) 
     19{ 
     20} 
     21else 
     22{ 
    1523    private import dfl.data; 
     24} 
     25 
     26version(DFL_NO_MENUS) 
     27{ 
     28} 
     29else 
     30{ 
     31    private import dfl.menu; 
     32} 
    1633 
    1734//version = RADIO_GROUP_LAYOUT; 
    …… 
    377394 
    378395 
    379 version(NO_DRAG_DROP) {} else 
     396version(DFL_NO_DRAG_DROP) {} else 
    380397{ 
    381398    /// 
    …… 
    10001017     
    10011018     
    1002     version(NO_DRAG_DROP) {} else 
     1019    version(DFL_NO_DRAG_DROP) {} else 
    10031020    { 
    10041021        /// 
    …… 
    13861403     
    13871404     
    1388     /// 
    1389     protected void onContextMenuChanged(EventArgs ea) 
    1390     { 
    1391         contextMenuChanged(this, ea); 
    1392     } 
    1393      
    1394     /// ditto 
    1395     void contextMenu(ContextMenu menu) // setter 
    1396     { 
    1397         if(cmenu is menu) 
    1398             return; 
    1399          
    1400         cmenu = menu; 
    1401          
    1402         if(isHandleCreated) 
    1403         { 
    1404             onContextMenuChanged(EventArgs.empty); 
    1405         } 
    1406     } 
    1407      
    1408      
    1409     /// 
    1410     ContextMenu contextMenu() // getter 
    1411     { 
    1412         return cmenu; 
     1405    version(DFL_NO_MENUS) 
     1406    { 
     1407    } 
     1408    else 
     1409    { 
     1410        /// 
     1411        protected void onContextMenuChanged(EventArgs ea) 
     1412        { 
     1413            contextMenuChanged(this, ea); 
     1414        } 
     1415         
     1416         
     1417        /// 
     1418        void contextMenu(ContextMenu menu) // setter 
     1419        { 
     1420            if(cmenu is menu) 
     1421                return; 
     1422             
     1423            cmenu = menu; 
     1424             
     1425            if(isHandleCreated) 
     1426            { 
     1427                onContextMenuChanged(EventArgs.empty); 
     1428            } 
     1429        } 
     1430         
     1431        /// ditto 
     1432        ContextMenu contextMenu() // getter 
     1433        { 
     1434            return cmenu; 
     1435        } 
    14131436    } 
    14141437     
    …… 
    28872910     
    28882911     
    2889     version(NO_DRAG_DROP) {} else 
     2912    version(DFL_NO_DRAG_DROP) {} else 
    28902913    { 
    28912914        private static class DropTarget: DflComObject, IDropTarget 
    …… 
    43794402        } 
    43804403         
    4381         version(NO_DRAG_DROP) {} else 
     4404        version(DFL_NO_DRAG_DROP) {} else 
    43824405        { 
    43834406            if(droptarget) 
    …… 
    49244947                        else 
    49254948                        { 
    4926                             MenuItem m; 
    4927                              
    4928                             m = cast(MenuItem)Application.lookupMenuID(LOWORD(msg.wParam)); 
    4929                             if(m) 
     4949                            version(DFL_NO_MENUS) 
    49304950                            { 
    4931                                 //msg.result = m.customMsg(*(cast(CustomMsg*)&msg)); 
    4932                                 m._reflectMenu(msg); 
    4933                                 //return; // ? 
     4951                            } 
     4952                            else 
     4953                            { 
     4954                                MenuItem m; 
     4955                                 
     4956                                m = cast(MenuItem)Application.lookupMenuID(LOWORD(msg.wParam)); 
     4957                                if(m) 
     4958                                { 
     4959                                    //msg.result = m.customMsg(*(cast(CustomMsg*)&msg)); 
     4960                                    m._reflectMenu(msg); 
     4961                                    //return; // ? 
     4962                                } 
    49344963                            } 
    49354964                        } 
    …… 
    49534982                    break; 
    49544983                 
    4955                 case WM_MENUSELECT: 
    4956                     { 
    4957                         UINT mflags; 
    4958                         UINT uitem; 
    4959                         int mid; 
    4960                         MenuItem m; 
    4961                          
    4962                         mflags = HIWORD(msg.wParam); 
    4963                         uitem = LOWORD(msg.wParam); // Depends on the flags. 
    4964                          
    4965                         if(mflags & MF_SYSMENU) 
    4966                             break; 
    4967                          
    4968                         if(mflags & MF_POPUP) 
     4984                version(DFL_NO_MENUS) 
     4985                { 
     4986                } 
     4987                else 
     4988                { 
     4989                    case WM_MENUSELECT: 
    49694990                        { 
    4970                             // -uitem- is an index. 
    4971                             mid = GetMenuItemID(cast(HMENU)msg.lParam, uitem); 
     4991                            UINT mflags; 
     4992                            UINT uitem; 
     4993                            int mid; 
     4994                            MenuItem m; 
     4995                             
     4996                            mflags = HIWORD(msg.wParam); 
     4997                            uitem = LOWORD(msg.wParam); // Depends on the flags. 
     4998                             
     4999                            if(mflags & MF_SYSMENU) 
     5000                                break; 
     5001                             
     5002                            if(mflags & MF_POPUP) 
     5003                            { 
     5004                                // -uitem- is an index. 
     5005                                mid = GetMenuItemID(cast(HMENU)msg.lParam, uitem); 
     5006                            } 
     5007                            else 
     5008                            { 
     5009                                // -uitem- is the item identifier. 
     5010                                mid = uitem; 
     5011                            } 
     5012                             
     5013                            m = cast(MenuItem)Application.lookupMenuID(mid); 
     5014                            if(m) 
     5015                            { 
     5016                                //msg.result = m.customMsg(*(cast(CustomMsg*)&msg)); 
     5017                                m._reflectMenu(msg); 
     5018                                //return; 
     5019                            } 
     5020                        } 
     5021                        break; 
     5022                     
     5023                    case WM_INITMENUPOPUP: 
     5024                        if(HIWORD(msg.lParam)) 
     5025                        { 
     5026                            // System menu. 
    49725027                        } 
    49735028                        else 
    49745029                        { 
    4975                             // -uitem- is the item identifier. 
    4976                             mid = uitem; 
     5030                            MenuItem m; 
     5031                             
     5032                            //m = cast(MenuItem)Application.lookupMenuID(GetMenuItemID(cast(HMENU)msg.wParam, LOWORD(msg.lParam))); 
     5033                            m = cast(MenuItem)Application.lookupMenu(cast(HMENU)msg.wParam); 
     5034                            if(m) 
     5035                            { 
     5036                                //msg.result = m.customMsg(*(cast(CustomMsg*)&msg)); 
     5037                                m._reflectMenu(msg); 
     5038                                //return; 
     5039                            } 
    49775040                        } 
    4978                          
    4979                        m = cast(MenuItem)Application.lookupMenuID(mid); 
    4980                        if(m) 
     5041                        break; 
     5042                     
     5043                    case WM_INITMENU: 
    49815044                        { 
    4982                             //msg.result = m.customMsg(*(cast(CustomMsg*)&msg)); 
    4983                             m._reflectMenu(msg); 
    4984                             //return; 
     5045                            ContextMenu m; 
     5046                             
     5047                            m = cast(ContextMenu)Application.lookupMenu(cast(HMENU)msg.wParam); 
     5048                            if(m) 
     5049                            { 
     5050                                //msg.result = m.customMsg(*(cast(CustomMsg*)&msg)); 
     5051                                m._reflectMenu(msg); 
     5052                                //return; 
     5053                            } 
    49855054                        } 
    4986                     } 
    4987                     break; 
    4988                  
    4989                 case WM_INITMENUPOPUP: 
    4990                     if(HIWORD(msg.lParam)) 
    4991                     { 
    4992                         // System menu. 
    4993                     } 
    4994                     else 
    4995                     { 
    4996                         MenuItem m; 
    4997                          
    4998                         //m = cast(MenuItem)Application.lookupMenuID(GetMenuItemID(cast(HMENU)msg.wParam, LOWORD(msg.lParam))); 
    4999                         m = cast(MenuItem)Application.lookupMenu(cast(HMENU)msg.wParam); 
    5000                         if(m) 
    5001                         { 
    5002                             //msg.result = m.customMsg(*(cast(CustomMsg*)&msg)); 
    5003                             m._reflectMenu(msg); 
    5004                             //return; 
    5005                         } 
    5006                     } 
    5007                     break; 
    5008                  
    5009                 case WM_INITMENU: 
    5010                     { 
    5011                         ContextMenu m; 
    5012                          
    5013                         m = cast(ContextMenu)Application.lookupMenu(cast(HMENU)msg.wParam); 
    5014                         if(m) 
    5015                         { 
    5016                             //msg.result = m.customMsg(*(cast(CustomMsg*)&msg)); 
    5017                             m._reflectMenu(msg); 
    5018                             //return; 
    5019                         } 
    5020                     } 
    5021                     break; 
     5055                        break; 
     5056                } 
    50225057            } 
    50235058             
    …… 
    51565191                break; 
    51575192             
    5158             case WM_CONTEXTMENU: 
    5159                 if(hwnd == cast(HWND)msg.wParam) 
    5160                 { 
    5161                     if(cmenu) 
     5193            version(DFL_NO_MENUS) 
     5194            { 
     5195            } 
     5196            else 
     5197            { 
     5198                case WM_CONTEXTMENU: 
     5199                    if(hwnd == cast(HWND)msg.wParam) 
    51625200                    { 
    5163                         // Shift+F10 causes xPos and yPos to be -1. 
    5164                          
    5165                         Point point; 
    5166                          
    5167                         if(msg.lParam == -1) 
    5168                             point = pointToScreen(Point(0, 0)); 
    5169                         else 
    5170                             point = Point(cast(short)LOWORD(msg.lParam), cast(short)HIWORD(msg.lParam)); 
    5171                          
    5172                         SetFocus(handle); // ? 
    5173                         cmenu.show(this, point); 
    5174                          
    5175                         return; 
     5201                        if(cmenu) 
     5202                        { 
     5203                            // Shift+F10 causes xPos and yPos to be -1. 
     5204                             
     5205                            Point point; 
     5206                             
     5207                            if(msg.lParam == -1) 
     5208                                point = pointToScreen(Point(0, 0)); 
     5209                            else 
     5210                                point = Point(cast(short)LOWORD(msg.lParam), cast(short)HIWORD(msg.lParam)); 
     5211                             
     5212                            SetFocus(handle); // ? 
     5213                            cmenu.show(this, point); 
     5214                             
     5215                            return; 
     5216                        } 
    51765217                    } 
    5177                 } 
    5178                break; 
     5218                   break; 
     5219            } 
    51795220             
    51805221            case WM_HELP: 
    …… 
    57985839    //EventHandler click; 
    57995840    Event!(Control, EventArgs) click; /// 
    5800     //EventHandler contextMenuChanged; 
    5801     Event!(Control, EventArgs) contextMenuChanged; /// 
     5841    version(DFL_NO_MENUS) 
     5842    { 
     5843    } 
     5844    else 
     5845    { 
     5846        //EventHandler contextMenuChanged; 
     5847        Event!(Control, EventArgs) contextMenuChanged; /// 
     5848    } 
    58025849    //ControlEventHandler controlAdded; 
    58035850    Event!(Control, ControlEventArgs) controlAdded; /// 
    …… 
    58765923    Event!(Control, EventArgs) visibleChanged; /// 
    58775924     
    5878     version(NO_DRAG_DROP) {} else 
     5925    version(DFL_NO_DRAG_DROP) {} else 
    58795926    { 
    58805927        //DragEventHandler dragDrop; 
    …… 
    60116058            killing = true; 
    60126059             
    6013             cmenu = cmenu.init; 
     6060            version(DFL_NO_MENUS) 
     6061            { 
     6062            } 
     6063            else 
     6064            { 
     6065                cmenu = cmenu.init; 
     6066            } 
    60146067            _ctrlname = _ctrlname.init; 
    60156068            otag = otag.init; 
    …… 
    68646917    //AnchorStyles anch = cast(AnchorStyles)(AnchorStyles.TOP | AnchorStyles.LEFT); 
    68656918    //bool cvalidation = true; 
    6866     ContextMenu cmenu; 
     6919    version(DFL_NO_MENUS) 
     6920    { 
     6921    } 
     6922    else 
     6923    { 
     6924        ContextMenu cmenu; 
     6925    } 
    68676926    DockStyle sdock = DockStyle.NONE; 
    68686927    Dstring _ctrlname; 
    …… 
    68836942    uint _disallowLayout = 0; 
    68846943     
    6885     version(NO_DRAG_DROP) {} else 
     6944    version(DFL_NO_DRAG_DROP) {} else 
    68866945    { 
    68876946        DropTarget droptarget = null; 

  • trunk/win32/dfl/form.d

    r61 r64  
    99 
    1010private import dfl.control, dfl.internal.winapi, dfl.event, dfl.drawing; 
    11 private import dfl.application, dfl.base, dfl.menu, dfl.internal.utf; 
     11private import dfl.application, dfl.base, dfl.internal.utf; 
    1212private import dfl.collections; 
    1313 
     14version(DFL_NO_MENUS) 
     15{ 
     16} 
     17else 
     18{ 
     19    private import dfl.menu; 
     20} 
    1421 
    1522version(NO_DFL_PARK_WINDOW) 
    …… 
    266273         
    267274        cp.className = FORM_CLASSNAME; 
    268         cp.menu = wmenu ? wmenu.handle : HMENU.init; 
     275        version(DFL_NO_MENUS) 
     276        { 
     277            cp.menu = HMENU.init; 
     278        } 
     279        else 
     280        { 
     281            cp.menu = wmenu ? wmenu.handle : HMENU.init; 
     282        } 
    269283         
    270284        //cp.parent = wparent ? wparent.handle : HWND.init; 
    …… 
    11251139        super.onHandleCreated(ea); 
    11261140         
    1127         if(wmenu) 
    1128             wmenu._setHwnd(handle); 
     1141        version(DFL_NO_MENUS) 
     1142        { 
     1143        } 
     1144        else 
     1145        { 
     1146            if(wmenu) 
     1147                wmenu._setHwnd(handle); 
     1148        } 
    11291149         
    11301150        _setIcon(); 
    …… 
    11871207     
    11881208     
    1189     /// 
    1190     final void menu(MainMenu menu) // setter 
    1191     { 
    1192         if(isHandleCreated) 
    1193         { 
    1194             HWND hwnd; 
    1195             hwnd = handle; 
    1196              
    1197             if(menu) 
    1198             { 
    1199                 SetMenu(hwnd, menu.handle); 
    1200                 menu._setHwnd(hwnd); 
     1209    version(DFL_NO_MENUS) 
     1210    { 
     1211    } 
     1212    else 
     1213    { 
     1214        /// 
     1215        final void menu(MainMenu menu) // setter 
     1216        { 
     1217            if(isHandleCreated) 
     1218            { 
     1219                HWND hwnd; 
     1220                hwnd = handle; 
     1221                 
     1222                if(menu) 
     1223                { 
     1224                    SetMenu(hwnd, menu.handle); 
     1225                    menu._setHwnd(hwnd); 
     1226                } 
     1227                else 
     1228                { 
     1229                    SetMenu(hwnd, HMENU.init); 
     1230                } 
     1231                 
     1232                if(wmenu) 
     1233                    wmenu._setHwnd(HWND.init); 
     1234                wmenu = menu; 
     1235                 
     1236                DrawMenuBar(hwnd); 
    12011237            } 
    12021238            else 
    12031239            { 
    1204                 SetMenu(hwnd, HMENU.init); 
    1205             } 
    1206              
    1207             if(wmenu) 
    1208                 wmenu._setHwnd(HWND.init); 
    1209             wmenu = menu; 
    1210              
    1211             DrawMenuBar(hwnd); 
    1212         } 
    1213         else 
    1214         { 
    1215             wmenu = menu; 
    1216             _recalcClientSize(); 
    1217         } 
    1218     } 
    1219      
    1220     /// ditto 
    1221     final MainMenu menu() // getter 
    1222     { 
    1223         return wmenu; 
    1224     } 
    1225      
    1226      
    1227     /+ 
    1228     /// 
    1229     final MainMenu mergedMenu() // getter 
    1230     { 
    1231         // Return menu belonging to active MDI child if maximized ? 
    1232     } 
    1233     +/ 
     1240                wmenu = menu; 
     1241                _recalcClientSize(); 
     1242            } 
     1243        } 
     1244         
     1245        /// ditto 
     1246        final MainMenu menu() // getter 
     1247        { 
     1248            return wmenu; 
     1249        } 
     1250         
     1251         
     1252        /+ 
     1253        /// 
     1254        final MainMenu mergedMenu() // getter 
     1255        { 
     1256            // Return menu belonging to active MDI child if maximized ? 
     1257        } 
     1258        +/ 
     1259    } 
    12341260     
    12351261     
    …… 
    25132539        //mfilter = null; 
    25142540         
    2515         if(wmenu) 
    2516             wmenu._setHwnd(HWND.init); 
     2541        version(DFL_NO_MENUS) 
     2542        { 
     2543        } 
     2544        else 
     2545        { 
     2546            if(wmenu) 
     2547                wmenu._setHwnd(HWND.init); 
     2548        } 
    25172549         
    25182550        super._destroying(); 
    …… 
    28702902         
    28712903        LONG wl = _style(); 
    2872         AdjustWindowRectEx(&r, wl, !(wl & WS_CHILD) && wmenu, _exStyl