Source Code Cross Referenced for Win32.java in  » Apache-Harmony-Java-SE » org-package » org » apache » harmony » awt » nativebridge » windows » Java Source Code / Java DocumentationJava Source Code and Java Documentation

Java Source Code / Java Documentation
1. 6.0 JDK Core
2. 6.0 JDK Modules
3. 6.0 JDK Modules com.sun
4. 6.0 JDK Modules com.sun.java
5. 6.0 JDK Modules sun
6. 6.0 JDK Platform
7. Ajax
8. Apache Harmony Java SE
9. Aspect oriented
10. Authentication Authorization
11. Blogger System
12. Build
13. Byte Code
14. Cache
15. Chart
16. Chat
17. Code Analyzer
18. Collaboration
19. Content Management System
20. Database Client
21. Database DBMS
22. Database JDBC Connection Pool
23. Database ORM
24. Development
25. EJB Server geronimo
26. EJB Server GlassFish
27. EJB Server JBoss 4.2.1
28. EJB Server resin 3.1.5
29. ERP CRM Financial
30. ESB
31. Forum
32. GIS
33. Graphic Library
34. Groupware
35. HTML Parser
36. IDE
37. IDE Eclipse
38. IDE Netbeans
39. Installer
40. Internationalization Localization
41. Inversion of Control
42. Issue Tracking
43. J2EE
44. JBoss
45. JMS
46. JMX
47. Library
48. Mail Clients
49. Net
50. Parser
51. PDF
52. Portal
53. Profiler
54. Project Management
55. Report
56. RSS RDF
57. Rule Engine
58. Science
59. Scripting
60. Search Engine
61. Security
62. Sevlet Container
63. Source Control
64. Swing Library
65. Template Engine
66. Test Coverage
67. Testing
68. UML
69. Web Crawler
70. Web Framework
71. Web Mail
72. Web Server
73. Web Services
74. Web Services apache cxf 2.0.1
75. Web Services AXIS2
76. Wiki Engine
77. Workflow Engines
78. XML
79. XML UI
Java
Java Tutorial
Java Open Source
Jar File Download
Java Articles
Java Products
Java by API
Photoshop Tutorials
Maya Tutorials
Flash Tutorials
3ds-Max Tutorials
Illustrator Tutorials
GIMP Tutorials
C# / C Sharp
C# / CSharp Tutorial
C# / CSharp Open Source
ASP.Net
ASP.NET Tutorial
JavaScript DHTML
JavaScript Tutorial
JavaScript Reference
HTML / CSS
HTML CSS Reference
C / ANSI-C
C Tutorial
C++
C++ Tutorial
Ruby
PHP
Python
Python Tutorial
Python Open Source
SQL Server / T-SQL
SQL Server / T-SQL Tutorial
Oracle PL / SQL
Oracle PL/SQL Tutorial
PostgreSQL
SQL / MySQL
MySQL Tutorial
VB.Net
VB.Net Tutorial
Flash / Flex / ActionScript
VBA / Excel / Access / Word
XML
XML Tutorial
Microsoft Office PowerPoint 2007 Tutorial
Microsoft Office Excel 2007 Tutorial
Microsoft Office Word 2007 Tutorial
Java Source Code / Java Documentation » Apache Harmony Java SE » org package » org.apache.harmony.awt.nativebridge.windows 
Source Cross Referenced  Class Diagram Java Document (Java Doc) 


00001:        /*
00002:         *  Licensed to the Apache Software Foundation (ASF) under one or more
00003:         *  contributor license agreements.  See the NOTICE file distributed with
00004:         *  this work for additional information regarding copyright ownership.
00005:         *  The ASF licenses this file to You under the Apache License, Version 2.0
00006:         *  (the "License"); you may not use this file except in compliance with
00007:         *  the License.  You may obtain a copy of the License at
00008:         *
00009:         *     http://www.apache.org/licenses/LICENSE-2.0
00010:         *
00011:         *  Unless required by applicable law or agreed to in writing, software
00012:         *  distributed under the License is distributed on an "AS IS" BASIS,
00013:         *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00014:         *  See the License for the specific language governing permissions and
00015:         *  limitations under the License.
00016:         */
00017:
00018:        /**
00019:         * @author Pavel Dolgov
00020:         * @version $Revision$
00021:         *
00022:         * This file is based on Win32 headers and has been generated by the nativebridge tool.
00023:         */package org.apache.harmony.awt.nativebridge.windows;
00024:
00025:        import org.apache.harmony.awt.nativebridge.*;
00026:
00027:        public class Win32 extends BasicLibWrapper {
00028:            static Win32 instance;
00029:
00030:            public static synchronized Win32 getInstance() {
00031:                if (instance == null) {
00032:                    instance = new Win32();
00033:                }
00034:                return instance;
00035:            }
00036:
00037:            private Win32() {
00038:                System.loadLibrary("Win32Wrapper"); //$NON-NLS-1$
00039:                init();
00040:            }
00041:
00042:            private static native void init();
00043:
00044:            public final int FillRect(long hDC, RECT lprc, long hbr) {
00045:                long tmp_0 = lprc == null ? 0 : lprc.longLockPointer();
00046:                int tmp_ret = FillRect(hDC, tmp_0, hbr);
00047:                if (lprc != null) {
00048:                    lprc.unlock();
00049:                }
00050:                return tmp_ret;
00051:            }
00052:
00053:            public final native int FillRect(long hDC, long lprc, long hbr);
00054:
00055:            public static class RECT extends CommonStructWrapper {
00056:
00057:                public static final int sizeof = 16;
00058:
00059:                RECT(boolean direct) {
00060:                    super (sizeof, direct);
00061:                }
00062:
00063:                RECT(VoidPointer base) {
00064:                    super (base);
00065:                }
00066:
00067:                RECT(long addr) {
00068:                    super (addr);
00069:                }
00070:
00071:                public final void set_left(int val) {
00072:                    byteBase.setInt32(0, val);
00073:                }
00074:
00075:                public final int get_left() {
00076:                    return byteBase.getInt32(0);
00077:                }
00078:
00079:                public final void set_top(int val) {
00080:                    byteBase.setInt32(4, val);
00081:                }
00082:
00083:                public final int get_top() {
00084:                    return byteBase.getInt32(4);
00085:                }
00086:
00087:                public final void set_right(int val) {
00088:                    byteBase.setInt32(8, val);
00089:                }
00090:
00091:                public final int get_right() {
00092:                    return byteBase.getInt32(8);
00093:                }
00094:
00095:                public final void set_bottom(int val) {
00096:                    byteBase.setInt32(12, val);
00097:                }
00098:
00099:                public final int get_bottom() {
00100:                    return byteBase.getInt32(12);
00101:                }
00102:
00103:                @Override
00104:                public int size() {
00105:                    return sizeof;
00106:                }
00107:            }
00108:
00109:            public final RECT createRECT(boolean direct) {
00110:                return new RECT(direct);
00111:            }
00112:
00113:            public final RECT createRECT(VoidPointer base) {
00114:                return new RECT(base);
00115:            }
00116:
00117:            public final RECT createRECT(long addr) {
00118:                return new RECT(addr);
00119:            }
00120:
00121:            public final native int LineTo(long param_0, int param_1,
00122:                    int param_2);
00123:
00124:            public final native int GetWindowLongW(long hWnd, int nIndex);
00125:
00126:            public final int PeekMessageW(MSG lpMsg, long hWnd,
00127:                    int wMsgFilterMin, int wMsgFilterMax, int wRemoveMsg) {
00128:                long tmp_0 = lpMsg == null ? 0 : lpMsg.longLockPointer();
00129:                int tmp_ret = PeekMessageW(tmp_0, hWnd, wMsgFilterMin,
00130:                        wMsgFilterMax, wRemoveMsg);
00131:                if (lpMsg != null) {
00132:                    lpMsg.unlock();
00133:                }
00134:                return tmp_ret;
00135:            }
00136:
00137:            public final native int PeekMessageW(long lpMsg, long hWnd,
00138:                    int wMsgFilterMin, int wMsgFilterMax, int wRemoveMsg);
00139:
00140:            public static class MSG extends CommonStructWrapper {
00141:
00142:                public static final int sizeof = NativeBridge.is64 ? 48 : 28;
00143:
00144:                MSG(boolean direct) {
00145:                    super (sizeof, direct);
00146:                }
00147:
00148:                MSG(VoidPointer base) {
00149:                    super (base);
00150:                }
00151:
00152:                MSG(long addr) {
00153:                    super (addr);
00154:                }
00155:
00156:                public final void set_hwnd(long val) {
00157:                    byteBase.setAddress(0, val);
00158:                }
00159:
00160:                public final long get_hwnd() {
00161:                    return byteBase.getAddress(0);
00162:                }
00163:
00164:                public final void set_message(int val) {
00165:                    byteBase.setInt32(NativeBridge.is64 ? 8 : 4, val);
00166:                }
00167:
00168:                public final int get_message() {
00169:                    return byteBase.getInt32(NativeBridge.is64 ? 8 : 4);
00170:                }
00171:
00172:                public final void set_wParam(long val) {
00173:                    byteBase.setCLong(NativeBridge.is64 ? 16 : 8, val);
00174:                }
00175:
00176:                public final long get_wParam() {
00177:                    return byteBase.getCLong(NativeBridge.is64 ? 16 : 8);
00178:                }
00179:
00180:                public final void set_lParam(long val) {
00181:                    byteBase.setCLong(NativeBridge.is64 ? 24 : 12, val);
00182:                }
00183:
00184:                public final long get_lParam() {
00185:                    return byteBase.getCLong(NativeBridge.is64 ? 24 : 12);
00186:                }
00187:
00188:                public final void set_time(int val) {
00189:                    byteBase.setInt32(NativeBridge.is64 ? 32 : 16, val);
00190:                }
00191:
00192:                public final int get_time() {
00193:                    return byteBase.getInt32(NativeBridge.is64 ? 32 : 16);
00194:                }
00195:
00196:                public final POINT get_pt() {
00197:                    return instance
00198:                            .createPOINT(getElementPointer(NativeBridge.is64 ? 36
00199:                                    : 20));
00200:                }
00201:
00202:                @Override
00203:                public int size() {
00204:                    return sizeof;
00205:                }
00206:            }
00207:
00208:            public final MSG createMSG(boolean direct) {
00209:                return new MSG(direct);
00210:            }
00211:
00212:            public final MSG createMSG(VoidPointer base) {
00213:                return new MSG(base);
00214:            }
00215:
00216:            public final MSG createMSG(long addr) {
00217:                return new MSG(addr);
00218:            }
00219:
00220:            public static class POINT extends CommonStructWrapper {
00221:
00222:                public static final int sizeof = 8;
00223:
00224:                POINT(boolean direct) {
00225:                    super (sizeof, direct);
00226:                }
00227:
00228:                POINT(VoidPointer base) {
00229:                    super (base);
00230:                }
00231:
00232:                POINT(long addr) {
00233:                    super (addr);
00234:                }
00235:
00236:                public final void set_x(int val) {
00237:                    byteBase.setInt32(0, val);
00238:                }
00239:
00240:                public final int get_x() {
00241:                    return byteBase.getInt32(0);
00242:                }
00243:
00244:                public final void set_y(int val) {
00245:                    byteBase.setInt32(4, val);
00246:                }
00247:
00248:                public final int get_y() {
00249:                    return byteBase.getInt32(4);
00250:                }
00251:
00252:                @Override
00253:                public int size() {
00254:                    return sizeof;
00255:                }
00256:            }
00257:
00258:            public final POINT createPOINT(boolean direct) {
00259:                return new POINT(direct);
00260:            }
00261:
00262:            public final POINT createPOINT(VoidPointer base) {
00263:                return new POINT(base);
00264:            }
00265:
00266:            public final POINT createPOINT(long addr) {
00267:                return new POINT(addr);
00268:            }
00269:
00270:            public final native int BitBlt(long param_0, int param_1,
00271:                    int param_2, int param_3, int param_4, long param_5,
00272:                    int param_6, int param_7, int param_8);
00273:
00274:            public final int GetSaveFileNameW(OPENFILENAMEW param_0) {
00275:                long tmp_0 = param_0 == null ? 0 : param_0.longLockPointer();
00276:                int tmp_ret = GetSaveFileNameW(tmp_0);
00277:                if (param_0 != null) {
00278:                    param_0.unlock();
00279:                }
00280:                return tmp_ret;
00281:            }
00282:
00283:            public final native int GetSaveFileNameW(long param_0);
00284:
00285:            public static class OPENFILENAMEW extends CommonStructWrapper {
00286:
00287:                public static final int sizeof = NativeBridge.is64 ? 152 : 88;
00288:
00289:                OPENFILENAMEW(boolean direct) {
00290:                    super (sizeof, direct);
00291:                }
00292:
00293:                OPENFILENAMEW(VoidPointer base) {
00294:                    super (base);
00295:                }
00296:
00297:                OPENFILENAMEW(long addr) {
00298:                    super (addr);
00299:                }
00300:
00301:                public final void set_lStructSize(int val) {
00302:                    byteBase.setInt32(0, val);
00303:                }
00304:
00305:                public final int get_lStructSize() {
00306:                    return byteBase.getInt32(0);
00307:                }
00308:
00309:                public final void set_hwndOwner(long val) {
00310:                    byteBase.setAddress(NativeBridge.is64 ? 8 : 4, val);
00311:                }
00312:
00313:                public final long get_hwndOwner() {
00314:                    return byteBase.getAddress(NativeBridge.is64 ? 8 : 4);
00315:                }
00316:
00317:                public final void set_hInstance(long val) {
00318:                    byteBase.setAddress(NativeBridge.is64 ? 16 : 8, val);
00319:                }
00320:
00321:                public final long get_hInstance() {
00322:                    return byteBase.getAddress(NativeBridge.is64 ? 16 : 8);
00323:                }
00324:
00325:                public final void set_lpstrFilter(Int16Pointer val) {
00326:                    byteBase.setPointer(NativeBridge.is64 ? 24 : 12, val);
00327:                }
00328:
00329:                public final Int16Pointer get_lpstrFilter() {
00330:                    return nb.createInt16Pointer(byteBase
00331:                            .getAddress(NativeBridge.is64 ? 24 : 12));
00332:                }
00333:
00334:                public final void set_lpstrCustomFilter(Int16Pointer val) {
00335:                    byteBase.setPointer(NativeBridge.is64 ? 32 : 16, val);
00336:                }
00337:
00338:                public final Int16Pointer get_lpstrCustomFilter() {
00339:                    return nb.createInt16Pointer(byteBase
00340:                            .getAddress(NativeBridge.is64 ? 32 : 16));
00341:                }
00342:
00343:                public final void set_nMaxCustFilter(int val) {
00344:                    byteBase.setInt32(NativeBridge.is64 ? 40 : 20, val);
00345:                }
00346:
00347:                public final int get_nMaxCustFilter() {
00348:                    return byteBase.getInt32(NativeBridge.is64 ? 40 : 20);
00349:                }
00350:
00351:                public final void set_nFilterIndex(int val) {
00352:                    byteBase.setInt32(NativeBridge.is64 ? 44 : 24, val);
00353:                }
00354:
00355:                public final int get_nFilterIndex() {
00356:                    return byteBase.getInt32(NativeBridge.is64 ? 44 : 24);
00357:                }
00358:
00359:                public final void set_lpstrFile(Int16Pointer val) {
00360:                    byteBase.setPointer(NativeBridge.is64 ? 48 : 28, val);
00361:                }
00362:
00363:                public final Int16Pointer get_lpstrFile() {
00364:                    return nb.createInt16Pointer(byteBase
00365:                            .getAddress(NativeBridge.is64 ? 48 : 28));
00366:                }
00367:
00368:                public final void set_nMaxFile(int val) {
00369:                    byteBase.setInt32(NativeBridge.is64 ? 56 : 32, val);
00370:                }
00371:
00372:                public final int get_nMaxFile() {
00373:                    return byteBase.getInt32(NativeBridge.is64 ? 56 : 32);
00374:                }
00375:
00376:                public final void set_lpstrFileTitle(Int16Pointer val) {
00377:                    byteBase.setPointer(NativeBridge.is64 ? 64 : 36, val);
00378:                }
00379:
00380:                public final Int16Pointer get_lpstrFileTitle() {
00381:                    return nb.createInt16Pointer(byteBase
00382:                            .getAddress(NativeBridge.is64 ? 64 : 36));
00383:                }
00384:
00385:                public final void set_nMaxFileTitle(int val) {
00386:                    byteBase.setInt32(NativeBridge.is64 ? 72 : 40, val);
00387:                }
00388:
00389:                public final int get_nMaxFileTitle() {
00390:                    return byteBase.getInt32(NativeBridge.is64 ? 72 : 40);
00391:                }
00392:
00393:                public final void set_lpstrInitialDir(Int16Pointer val) {
00394:                    byteBase.setPointer(NativeBridge.is64 ? 80 : 44, val);
00395:                }
00396:
00397:                public final Int16Pointer get_lpstrInitialDir() {
00398:                    return nb.createInt16Pointer(byteBase
00399:                            .getAddress(NativeBridge.is64 ? 80 : 44));
00400:                }
00401:
00402:                public final void set_lpstrTitle(Int16Pointer val) {
00403:                    byteBase.setPointer(NativeBridge.is64 ? 88 : 48, val);
00404:                }
00405:
00406:                public final Int16Pointer get_lpstrTitle() {
00407:                    return nb.createInt16Pointer(byteBase
00408:                            .getAddress(NativeBridge.is64 ? 88 : 48));
00409:                }
00410:
00411:                public final void set_Flags(int val) {
00412:                    byteBase.setInt32(NativeBridge.is64 ? 96 : 52, val);
00413:                }
00414:
00415:                public final int get_Flags() {
00416:                    return byteBase.getInt32(NativeBridge.is64 ? 96 : 52);
00417:                }
00418:
00419:                public final void set_nFileOffset(short val) {
00420:                    byteBase.setInt16(NativeBridge.is64 ? 100 : 56, val);
00421:                }
00422:
00423:                public final short get_nFileOffset() {
00424:                    return byteBase.getInt16(NativeBridge.is64 ? 100 : 56);
00425:                }
00426:
00427:                public final void set_nFileExtension(short val) {
00428:                    byteBase.setInt16(NativeBridge.is64 ? 102 : 58, val);
00429:                }
00430:
00431:                public final short get_nFileExtension() {
00432:                    return byteBase.getInt16(NativeBridge.is64 ? 102 : 58);
00433:                }
00434:
00435:                public final void set_lpstrDefExt(Int16Pointer val) {
00436:                    byteBase.setPointer(NativeBridge.is64 ? 104 : 60, val);
00437:                }
00438:
00439:                public final Int16Pointer get_lpstrDefExt() {
00440:                    return nb.createInt16Pointer(byteBase
00441:                            .getAddress(NativeBridge.is64 ? 104 : 60));
00442:                }
00443:
00444:                public final void set_lCustData(long val) {
00445:                    byteBase.setCLong(NativeBridge.is64 ? 112 : 64, val);
00446:                }
00447:
00448:                public final long get_lCustData() {
00449:                    return byteBase.getCLong(NativeBridge.is64 ? 112 : 64);
00450:                }
00451:
00452:                public final void set_lpfnHook(long val) {
00453:                    byteBase.setAddress(NativeBridge.is64 ? 120 : 68, val);
00454:                }
00455:
00456:                public final long get_lpfnHook() {
00457:                    return byteBase.getAddress(NativeBridge.is64 ? 120 : 68);
00458:                }
00459:
00460:                public final long LPOFNHOOKPROC(long param_0, int param_1,
00461:                        long param_2, long param_3) {
00462:                    long tmp_ret = instance.proxycall0(get_lpfnHook(), param_0,
00463:                            param_1, param_2, param_3);
00464:                    return tmp_ret;
00465:                }
00466:
00467:                public final void set_lpTemplateName(Int16Pointer val) {
00468:                    byteBase.setPointer(NativeBridge.is64 ? 128 : 72, val);
00469:                }
00470:
00471:                public final Int16Pointer get_lpTemplateName() {
00472:                    return nb.createInt16Pointer(byteBase
00473:                            .getAddress(NativeBridge.is64 ? 128 : 72));
00474:                }
00475:
00476:                public final void set_pvReserved(VoidPointer val) {
00477:                    byteBase.setPointer(NativeBridge.is64 ? 136 : 76, val);
00478:                }
00479:
00480:                public final VoidPointer get_pvReserved() {
00481:                    return nb.createInt8Pointer(byteBase
00482:                            .getAddress(NativeBridge.is64 ? 136 : 76));
00483:                }
00484:
00485:                public final void set_dwReserved(int val) {
00486:                    byteBase.setInt32(NativeBridge.is64 ? 144 : 80, val);
00487:                }
00488:
00489:                public final int get_dwReserved() {
00490:                    return byteBase.getInt32(NativeBridge.is64 ? 144 : 80);
00491:                }
00492:
00493:                public final void set_FlagsEx(int val) {
00494:                    byteBase.setInt32(NativeBridge.is64 ? 148 : 84, val);
00495:                }
00496:
00497:                public final int get_FlagsEx() {
00498:                    return byteBase.getInt32(NativeBridge.is64 ? 148 : 84);
00499:                }
00500:
00501:                @Override
00502:                public int size() {
00503:                    return sizeof;
00504:                }
00505:            }
00506:
00507:            public final OPENFILENAMEW createOPENFILENAMEW(boolean direct) {
00508:                return new OPENFILENAMEW(direct);
00509:            }
00510:
00511:            public final OPENFILENAMEW createOPENFILENAMEW(VoidPointer base) {
00512:                return new OPENFILENAMEW(base);
00513:            }
00514:
00515:            public final OPENFILENAMEW createOPENFILENAMEW(long addr) {
00516:                return new OPENFILENAMEW(addr);
00517:            }
00518:
00519:            final native long proxycall0(long fnptr, long param_0, int param_1,
00520:                    long param_2, long param_3);
00521:
00522:            public final native int CreateCaret(long hWnd, long hBitmap,
00523:                    int nWidth, int nHeight);
00524:
00525:            public final native int ImmDestroyContext(long param_0);
00526:
00527:            public final int ImmGetCompositionStringW(long param_0,
00528:                    int param_1, VoidPointer param_2, int param_3) {
00529:                long tmp_0 = param_2 == null ? 0 : param_2.longLockPointer();
00530:                int tmp_ret = ImmGetCompositionStringW(param_0, param_1, tmp_0,
00531:                        param_3);
00532:                if (param_2 != null) {
00533:                    param_2.unlock();
00534:                }
00535:                return tmp_ret;
00536:            }
00537:
00538:            public final native int ImmGetCompositionStringW(long param_0,
00539:                    int param_1, long param_2, int param_3);
00540:
00541:            public final native int GetSystemMetrics(int nIndex);
00542:
00543:            public final native int SetForegroundWindow(long hWnd);
00544:
00545:            public final native long SendMessageW(long hWnd, int Msg,
00546:                    long wParam, long lParam);
00547:
00548:            public final int GetThemeSysFont(VoidPointer hTheme, int iFontId,
00549:                    LOGFONTA plf) {
00550:                long tmp_0 = hTheme == null ? 0 : hTheme.longLockPointer();
00551:                long tmp_1 = plf == null ? 0 : plf.longLockPointer();
00552:                int tmp_ret = GetThemeSysFont(tmp_0, iFontId, tmp_1);
00553:                if (hTheme != null) {
00554:                    hTheme.unlock();
00555:                }
00556:                if (plf != null) {
00557:                    plf.unlock();
00558:                }
00559:                return tmp_ret;
00560:            }
00561:
00562:            public final native int GetThemeSysFont(long hTheme, int iFontId,
00563:                    long plf);
00564:
00565:            public static class LOGFONTA extends CommonStructWrapper {
00566:
00567:                public static final int sizeof = 60;
00568:
00569:                LOGFONTA(boolean direct) {
00570:                    super (sizeof, direct);
00571:                }
00572:
00573:                LOGFONTA(VoidPointer base) {
00574:                    super (base);
00575:                }
00576:
00577:                LOGFONTA(long addr) {
00578:                    super (addr);
00579:                }
00580:
00581:                public final void set_lfHeight(int val) {
00582:                    byteBase.setInt32(0, val);
00583:                }
00584:
00585:                public final int get_lfHeight() {
00586:                    return byteBase.getInt32(0);
00587:                }
00588:
00589:                public final void set_lfWidth(int val) {
00590:                    byteBase.setInt32(4, val);
00591:                }
00592:
00593:                public final int get_lfWidth() {
00594:                    return byteBase.getInt32(4);
00595:                }
00596:
00597:                public final void set_lfEscapement(int val) {
00598:                    byteBase.setInt32(8, val);
00599:                }
00600:
00601:                public final int get_lfEscapement() {
00602:                    return byteBase.getInt32(8);
00603:                }
00604:
00605:                public final void set_lfOrientation(int val) {
00606:                    byteBase.setInt32(12, val);
00607:                }
00608:
00609:                public final int get_lfOrientation() {
00610:                    return byteBase.getInt32(12);
00611:                }
00612:
00613:                public final void set_lfWeight(int val) {
00614:                    byteBase.setInt32(16, val);
00615:                }
00616:
00617:                public final int get_lfWeight() {
00618:                    return byteBase.getInt32(16);
00619:                }
00620:
00621:                public final void set_lfItalic(byte val) {
00622:                    byteBase.set(20, val);
00623:                }
00624:
00625:                public final byte get_lfItalic() {
00626:                    return byteBase.get(20);
00627:                }
00628:
00629:                public final void set_lfUnderline(byte val) {
00630:                    byteBase.set(21, val);
00631:                }
00632:
00633:                public final byte get_lfUnderline() {
00634:                    return byteBase.get(21);
00635:                }
00636:
00637:                public final void set_lfStrikeOut(byte val) {
00638:                    byteBase.set(22, val);
00639:                }
00640:
00641:                public final byte get_lfStrikeOut() {
00642:                    return byteBase.get(22);
00643:                }
00644:
00645:                public final void set_lfCharSet(byte val) {
00646:                    byteBase.set(23, val);
00647:                }
00648:
00649:                public final byte get_lfCharSet() {
00650:                    return byteBase.get(23);
00651:                }
00652:
00653:                public final void set_lfOutPrecision(byte val) {
00654:                    byteBase.set(24, val);
00655:                }
00656:
00657:                public final byte get_lfOutPrecision() {
00658:                    return byteBase.get(24);
00659:                }
00660:
00661:                public final void set_lfClipPrecision(byte val) {
00662:                    byteBase.set(25, val);
00663:                }
00664:
00665:                public final byte get_lfClipPrecision() {
00666:                    return byteBase.get(25);
00667:                }
00668:
00669:                public final void set_lfQuality(byte val) {
00670:                    byteBase.set(26, val);
00671:                }
00672:
00673:                public final byte get_lfQuality() {
00674:                    return byteBase.get(26);
00675:                }
00676:
00677:                public final void set_lfPitchAndFamily(byte val) {
00678:                    byteBase.set(27, val);
00679:                }
00680:
00681:                public final byte get_lfPitchAndFamily() {
00682:                    return byteBase.get(27);
00683:                }
00684:
00685:                public final Int8Pointer get_lfFaceName() {
00686:                    return nb.createInt8Pointer(getElementPointer(28));
00687:                }
00688:
00689:                @Override
00690:                public int size() {
00691:                    return sizeof;
00692:                }
00693:            }
00694:
00695:            public final LOGFONTA createLOGFONTA(boolean direct) {
00696:                return new LOGFONTA(direct);
00697:            }
00698:
00699:            public final LOGFONTA createLOGFONTA(VoidPointer base) {
00700:                return new LOGFONTA(base);
00701:            }
00702:
00703:            public final LOGFONTA createLOGFONTA(long addr) {
00704:                return new LOGFONTA(addr);
00705:            }
00706:
00707:            public final int SystemParametersInfoW(int uiAction, int uiParam,
00708:                    VoidPointer pvParam, int fWinIni) {
00709:                long tmp_0 = pvParam == null ? 0 : pvParam.longLockPointer();
00710:                int tmp_ret = SystemParametersInfoW(uiAction, uiParam, tmp_0,
00711:                        fWinIni);
00712:                if (pvParam != null) {
00713:                    pvParam.unlock();
00714:                }
00715:                return tmp_ret;
00716:            }
00717:
00718:            public final native int SystemParametersInfoW(int uiAction,
00719:                    int uiParam, long pvParam, int fWinIni);
00720:
00721:            public final native int GetCaretBlinkTime();
00722:
00723:            public final long CreateDCW(String param_0, String param_1,
00724:                    String param_2, DEVMODEW param_3) {
00725:                Int16Pointer _param_0 = null == param_0 ? null : nb
00726:                        .createInt16Pointer(param_0, false);
00727:                long tmp_0 = _param_0 == null ? 0 : _param_0.longLockPointer();
00728:                Int16Pointer _param_1 = null == param_1 ? null : nb
00729:                        .createInt16Pointer(param_1, false);
00730:                long tmp_1 = _param_1 == null ? 0 : _param_1.longLockPointer();
00731:                Int16Pointer _param_2 = null == param_2 ? null : nb
00732:                        .createInt16Pointer(param_2, false);
00733:                long tmp_2 = _param_2 == null ? 0 : _param_2.longLockPointer();
00734:                long tmp_3 = param_3 == null ? 0 : param_3.longLockPointer();
00735:                long tmp_ret = CreateDCW(tmp_0, tmp_1, tmp_2, tmp_3);
00736:                if (_param_0 != null) {
00737:                    _param_0.unlock();
00738:                    _param_0.free();
00739:                }
00740:                if (_param_1 != null) {
00741:                    _param_1.unlock();
00742:                    _param_1.free();
00743:                }
00744:                if (_param_2 != null) {
00745:                    _param_2.unlock();
00746:                    _param_2.free();
00747:                }
00748:                if (param_3 != null) {
00749:                    param_3.unlock();
00750:                }
00751:                return tmp_ret;
00752:            }
00753:
00754:            public final long CreateDCW(Int16Pointer param_0,
00755:                    Int16Pointer param_1, Int16Pointer param_2, DEVMODEW param_3) {
00756:                long tmp_0 = param_0 == null ? 0 : param_0.longLockPointer();
00757:                long tmp_1 = param_1 == null ? 0 : param_1.longLockPointer();
00758:                long tmp_2 = param_2 == null ? 0 : param_2.longLockPointer();
00759:                long tmp_3 = param_3 == null ? 0 : param_3.longLockPointer();
00760:                long tmp_ret = CreateDCW(tmp_0, tmp_1, tmp_2, tmp_3);
00761:                if (param_0 != null) {
00762:                    param_0.unlock();
00763:                }
00764:                if (param_1 != null) {
00765:                    param_1.unlock();
00766:                }
00767:                if (param_2 != null) {
00768:                    param_2.unlock();
00769:                }
00770:                if (param_3 != null) {
00771:                    param_3.unlock();
00772:                }
00773:                return tmp_ret;
00774:            }
00775:
00776:            public final native long CreateDCW(long param_0, long param_1,
00777:                    long param_2, long param_3);
00778:
00779:            public static class DEVMODEW extends CommonStructWrapper {
00780:
00781:                public static final int sizeof = 220;
00782:
00783:                DEVMODEW(boolean direct) {
00784:                    super (sizeof, direct);
00785:                }
00786:
00787:                DEVMODEW(VoidPointer base) {
00788:                    super (base);
00789:                }
00790:
00791:                DEVMODEW(long addr) {
00792:                    super (addr);
00793:                }
00794:
00795:                public final Int16Pointer get_dmDeviceName() {
00796:                    return nb.createInt16Pointer(getElementPointer(0));
00797:                }
00798:
00799:                public final void set_dmSpecVersion(short val) {
00800:                    byteBase.setInt16(64, val);
00801:                }
00802:
00803:                public final short get_dmSpecVersion() {
00804:                    return byteBase.getInt16(64);
00805:                }
00806:
00807:                public final void set_dmDriverVersion(short val) {
00808:                    byteBase.setInt16(66, val);
00809:                }
00810:
00811:                public final short get_dmDriverVersion() {
00812:                    return byteBase.getInt16(66);
00813:                }
00814:
00815:                public final void set_dmSize(short val) {
00816:                    byteBase.setInt16(68, val);
00817:                }
00818:
00819:                public final short get_dmSize() {
00820:                    return byteBase.getInt16(68);
00821:                }
00822:
00823:                public final void set_dmDriverExtra(short val) {
00824:                    byteBase.setInt16(70, val);
00825:                }
00826:
00827:                public final short get_dmDriverExtra() {
00828:                    return byteBase.getInt16(70);
00829:                }
00830:
00831:                public final void set_dmFields(int val) {
00832:                    byteBase.setInt32(72, val);
00833:                }
00834:
00835:                public final int get_dmFields() {
00836:                    return byteBase.getInt32(72);
00837:                }
00838:
00839:                public final void set_dmOrientation(short val) {
00840:                    byteBase.setInt16(76, val);
00841:                }
00842:
00843:                public final short get_dmOrientation() {
00844:                    return byteBase.getInt16(76);
00845:                }
00846:
00847:                public final void set_dmPaperSize(short val) {
00848:                    byteBase.setInt16(78, val);
00849:                }
00850:
00851:                public final short get_dmPaperSize() {
00852:                    return byteBase.getInt16(78);
00853:                }
00854:
00855:                public final void set_dmPaperLength(short val) {
00856:                    byteBase.setInt16(80, val);
00857:                }
00858:
00859:                public final short get_dmPaperLength() {
00860:                    return byteBase.getInt16(80);
00861:                }
00862:
00863:                public final void set_dmPaperWidth(short val) {
00864:                    byteBase.setInt16(82, val);
00865:                }
00866:
00867:                public final short get_dmPaperWidth() {
00868:                    return byteBase.getInt16(82);
00869:                }
00870:
00871:                public final void set_dmScale(short val) {
00872:                    byteBase.setInt16(84, val);
00873:                }
00874:
00875:                public final short get_dmScale() {
00876:                    return byteBase.getInt16(84);
00877:                }
00878:
00879:                public final void set_dmCopies(short val) {
00880:                    byteBase.setInt16(86, val);
00881:                }
00882:
00883:                public final short get_dmCopies() {
00884:                    return byteBase.getInt16(86);
00885:                }
00886:
00887:                public final void set_dmDefaultSource(short val) {
00888:                    byteBase.setInt16(88, val);
00889:                }
00890:
00891:                public final short get_dmDefaultSource() {
00892:                    return byteBase.getInt16(88);
00893:                }
00894:
00895:                public final void set_dmPrintQuality(short val) {
00896:                    byteBase.setInt16(90, val);
00897:                }
00898:
00899:                public final short get_dmPrintQuality() {
00900:                    return byteBase.getInt16(90);
00901:                }
00902:
00903:                public final POINTL get_dmPosition() {
00904:                    return instance.createPOINTL(getElementPointer(76));
00905:                }
00906:
00907:                public final void set_dmDisplayOrientation(int val) {
00908:                    byteBase.setInt32(84, val);
00909:                }
00910:
00911:                public final int get_dmDisplayOrientation() {
00912:                    return byteBase.getInt32(84);
00913:                }
00914:
00915:                public final void set_dmDisplayFixedOutput(int val) {
00916:                    byteBase.setInt32(88, val);
00917:                }
00918:
00919:                public final int get_dmDisplayFixedOutput() {
00920:                    return byteBase.getInt32(88);
00921:                }
00922:
00923:                public final void set_dmColor(short val) {
00924:                    byteBase.setInt16(92, val);
00925:                }
00926:
00927:                public final short get_dmColor() {
00928:                    return byteBase.getInt16(92);
00929:                }
00930:
00931:                public final void set_dmDuplex(short val) {
00932:                    byteBase.setInt16(94, val);
00933:                }
00934:
00935:                public final short get_dmDuplex() {
00936:                    return byteBase.getInt16(94);
00937:                }
00938:
00939:                public final void set_dmYResolution(short val) {
00940:                    byteBase.setInt16(96, val);
00941:                }
00942:
00943:                public final short get_dmYResolution() {
00944:                    return byteBase.getInt16(96);
00945:                }
00946:
00947:                public final void set_dmTTOption(short val) {
00948:                    byteBase.setInt16(98, val);
00949:                }
00950:
00951:                public final short get_dmTTOption() {
00952:                    return byteBase.getInt16(98);
00953:                }
00954:
00955:                public final void set_dmCollate(short val) {
00956:                    byteBase.setInt16(100, val);
00957:                }
00958:
00959:                public final short get_dmCollate() {
00960:                    return byteBase.getInt16(100);
00961:                }
00962:
00963:                public final Int16Pointer get_dmFormName() {
00964:                    return nb.createInt16Pointer(getElementPointer(102));
00965:                }
00966:
00967:                public final void set_dmLogPixels(short val) {
00968:                    byteBase.setInt16(166, val);
00969:                }
00970:
00971:                public final short get_dmLogPixels() {
00972:                    return byteBase.getInt16(166);
00973:                }
00974:
00975:                public final void set_dmBitsPerPel(int val) {
00976:                    byteBase.setInt32(168, val);
00977:                }
00978:
00979:                public final int get_dmBitsPerPel() {
00980:                    return byteBase.getInt32(168);
00981:                }
00982:
00983:                public final void set_dmPelsWidth(int val) {
00984:                    byteBase.setInt32(172, val);
00985:                }
00986:
00987:                public final int get_dmPelsWidth() {
00988:                    return byteBase.getInt32(172);
00989:                }
00990:
00991:                public final void set_dmPelsHeight(int val) {
00992:                    byteBase.setInt32(176, val);
00993:                }
00994:
00995:                public final int get_dmPelsHeight() {
00996:                    return byteBase.getInt32(176);
00997:                }
00998:
00999:                public final void set_dmDisplayFlags(int val) {
01000:                    byteBase.setInt32(180, val);
01001:                }
01002:
01003:                public final int get_dmDisplayFlags() {
01004:                    return byteBase.getInt32(180);
01005:                }
01006:
01007:                public final void set_dmNup(int val) {
01008:                    byteBase.setInt32(180, val);
01009:                }
01010:
01011:                public final int get_dmNup() {
01012:                    return byteBase.getInt32(180);
01013:                }
01014:
01015:                public final void set_dmDisplayFrequency(int val) {
01016:                    byteBase.setInt32(184, val);
01017:                }
01018:
01019:                public final int get_dmDisplayFrequency() {
01020:                    return byteBase.getInt32(184);
01021:                }
01022:
01023:                public final void set_dmICMMethod(int val) {
01024:                    byteBase.setInt32(188, val);
01025:                }
01026:
01027:                public final int get_dmICMMethod() {
01028:                    return byteBase.getInt32(188);
01029:                }
01030:
01031:                public final void set_dmICMIntent(int val) {
01032:                    byteBase.setInt32(192, val);
01033:                }
01034:
01035:                public final int get_dmICMIntent() {
01036:                    return byteBase.getInt32(192);
01037:                }
01038:
01039:                public final void set_dmMediaType(int val) {
01040:                    byteBase.setInt32(196, val);
01041:                }
01042:
01043:                public final int get_dmMediaType() {
01044:                    return byteBase.getInt32(196);
01045:                }
01046:
01047:                public final void set_dmDitherType(int val) {
01048:                    byteBase.setInt32(200, val);
01049:                }
01050:
01051:                public final int get_dmDitherType() {
01052:                    return byteBase.getInt32(200);
01053:                }
01054:
01055:                public final void set_dmReserved1(int val) {
01056:                    byteBase.setInt32(204, val);
01057:                }
01058:
01059:                public final int get_dmReserved1() {
01060:                    return byteBase.getInt32(204);
01061:                }
01062:
01063:                public final void set_dmReserved2(int val) {
01064:                    byteBase.setInt32(208, val);
01065:                }
01066:
01067:                public final int get_dmReserved2() {
01068:                    return byteBase.getInt32(208);
01069:                }
01070:
01071:                public final void set_dmPanningWidth(int val) {
01072:                    byteBase.setInt32(212, val);
01073:                }
01074:
01075:                public final int get_dmPanningWidth() {
01076:                    return byteBase.getInt32(212);
01077:                }
01078:
01079:                public final void set_dmPanningHeight(int val) {
01080:                    byteBase.setInt32(216, val);
01081:                }
01082:
01083:                public final int get_dmPanningHeight() {
01084:                    return byteBase.getInt32(216);
01085:                }
01086:
01087:                @Override
01088:                public int size() {
01089:                    return sizeof;
01090:                }
01091:            }
01092:
01093:            public final DEVMODEW createDEVMODEW(boolean direct) {
01094:                return new DEVMODEW(direct);
01095:            }
01096:
01097:            public final DEVMODEW createDEVMODEW(VoidPointer base) {
01098:                return new DEVMODEW(base);
01099:            }
01100:
01101:            public final DEVMODEW createDEVMODEW(long addr) {
01102:                return new DEVMODEW(addr);
01103:            }
01104:
01105:            public static class POINTL extends CommonStructWrapper {
01106:
01107:                public static final int sizeof = 8;
01108:
01109:                POINTL(boolean direct) {
01110:                    super (sizeof, direct);
01111:                }
01112:
01113:                POINTL(VoidPointer base) {
01114:                    super (base);
01115:                }
01116:
01117:                POINTL(long addr) {
01118:                    super (addr);
01119:                }
01120:
01121:                public final void set_x(int val) {
01122:                    byteBase.setInt32(0, val);
01123:                }
01124:
01125:                public final int get_x() {
01126:                    return byteBase.getInt32(0);
01127:                }
01128:
01129:                public final void set_y(int val) {
01130:                    byteBase.setInt32(4, val);
01131:                }
01132:
01133:                public final int get_y() {
01134:                    return byteBase.getInt32(4);
01135:                }
01136:
01137:                @Override
01138:                public int size() {
01139:                    return sizeof;
01140:                }
01141:            }
01142:
01143:            public final POINTL createPOINTL(boolean direct) {
01144:                return new POINTL(direct);
01145:            }
01146:
01147:            public final POINTL createPOINTL(VoidPointer base) {
01148:                return new POINTL(base);
01149:            }
01150:
01151:            public final POINTL createPOINTL(long addr) {
01152:                return new POINTL(addr);
01153:            }
01154:
01155:            public final native int Arc(long param_0, int param_1, int param_2,
01156:                    int param_3, int param_4, int param_5, int param_6,
01157:                    int param_7, int param_8);
01158:
01159:            public final native int ImmReleaseContext(long param_0, long param_1);
01160:
01161:            public final int PolyPolygon(long param_0, Win32.POINT param_1,
01162:                    Int32Pointer param_2, int param_3) {
01163:                long tmp_0 = param_1 == null ? 0 : param_1.longLockPointer();
01164:                long tmp_1 = param_2 == null ? 0 : param_2.longLockPointer();
01165:                int tmp_ret = PolyPolygon(param_0, tmp_0, tmp_1, param_3);
01166:                if (param_1 != null) {
01167:                    param_1.unlock();
01168:                }
01169:                if (param_2 != null) {
01170:                    param_2.unlock();
01171:                }
01172:                return tmp_ret;
01173:            }
01174:
01175:            public final native int PolyPolygon(long param_0, long param_1,
01176:                    long param_2, int param_3);
01177:
01178:            public final native long CreatePen(int param_0, int param_1,
01179:                    int param_2);
01180:
01181:            public final native short GetKeyState(int nVirtKey);
01182:
01183:            public final long CreateIconIndirect(ICONINFO piconinfo) {
01184:                long tmp_0 = piconinfo == null ? 0 : piconinfo
01185:                        .longLockPointer();
01186:                long tmp_ret = CreateIconIndirect(tmp_0);
01187:                if (piconinfo != null) {
01188:                    piconinfo.unlock();
01189:                }
01190:                return tmp_ret;
01191:            }
01192:
01193:            public final native long CreateIconIndirect(long piconinfo);
01194:
01195:            public static class ICONINFO extends CommonStructWrapper {
01196:
01197:                public static final int sizeof = NativeBridge.is64 ? 32 : 20;
01198:
01199:                ICONINFO(boolean direct) {
01200:                    super (sizeof, direct);
01201:                }
01202:
01203:                ICONINFO(VoidPointer base) {
01204:                    super (base);
01205:                }
01206:
01207:                ICONINFO(long addr) {
01208:                    super (addr);
01209:                }
01210:
01211:                public final void set_fIcon(int val) {
01212:                    byteBase.setInt32(0, val);
01213:                }
01214:
01215:                public final int get_fIcon() {
01216:                    return byteBase.getInt32(0);
01217:                }
01218:
01219:                public final void set_xHotspot(int val) {
01220:                    byteBase.setInt32(4, val);
01221:                }
01222:
01223:                public final int get_xHotspot() {
01224:                    return byteBase.getInt32(4);
01225:                }
01226:
01227:                public final void set_yHotspot(int val) {
01228:                    byteBase.setInt32(8, val);
01229:                }
01230:
01231:                public final int get_yHotspot() {
01232:                    return byteBase.getInt32(8);
01233:                }
01234:
01235:                public final void set_hbmMask(long val) {
01236:                    byteBase.setAddress(NativeBridge.is64 ? 16 : 12, val);
01237:                }
01238:
01239:                public final long get_hbmMask() {
01240:                    return byteBase.getAddress(NativeBridge.is64 ? 16 : 12);
01241:                }
01242:
01243:                public final void set_hbmColor(long val) {
01244:                    byteBase.setAddress(NativeBridge.is64 ? 24 : 16, val);
01245:                }
01246:
01247:                public final long get_hbmColor() {
01248:                    return byteBase.getAddress(NativeBridge.is64 ? 24 : 16);
01249:                }
01250:
01251:                @Override
01252:                public int size() {
01253:                    return sizeof;
01254:                }
01255:            }
01256:
01257:            public final ICONINFO createICONINFO(boolean direct) {
01258:                return new ICONINFO(direct);
01259:            }
01260:
01261:            public final ICONINFO createICONINFO(VoidPointer base) {
01262:                return new ICONINFO(base);
01263:            }
01264:
01265:            public final ICONINFO createICONINFO(long addr) {
01266:                return new ICONINFO(addr);
01267:            }
01268:
01269:            public final native int RoundRect(long param_0, int param_1,
01270:                    int param_2, int param_3, int param_4, int param_5,
01271:                    int param_6);
01272:
01273:            public final long ExtCreateRegion(XFORM param_0, int param_1,
01274:                    RGNDATA param_2) {
01275:                long tmp_0 = param_0 == null ? 0 : param_0.longLockPointer();
01276:                long tmp_1 = param_2 == null ? 0 : param_2.longLockPointer();
01277:                long tmp_ret = ExtCreateRegion(tmp_0, param_1, tmp_1);
01278:                if (param_0 != null) {
01279:                    param_0.unlock();
01280:                }
01281:                if (param_2 != null) {
01282:                    param_2.unlock();
01283:                }
01284:                return tmp_ret;
01285:            }
01286:
01287:            public final native long ExtCreateRegion(long param_0, int param_1,
01288:                    long param_2);
01289:
01290:            public static class RGNDATA extends CommonStructWrapper {
01291:
01292:                public static final int sizeof = 36;
01293:
01294:                RGNDATA(boolean direct) {
01295:                    super (sizeof, direct);
01296:                }
01297:
01298:                RGNDATA(VoidPointer base) {
01299:                    super (base);
01300:                }
01301:
01302:                RGNDATA(long addr) {
01303:                    super (addr);
01304:                }
01305:
01306:                public final RGNDATAHEADER get_rdh() {
01307:                    return instance.createRGNDATAHEADER(getElementPointer(0));
01308:                }
01309:
01310:                public final Int8Pointer get_Buffer() {
01311:                    return nb.createInt8Pointer(getElementPointer(32));
01312:                }
01313:
01314:                @Override
01315:                public int size() {
01316:                    return sizeof;
01317:                }
01318:            }
01319:
01320:            public final RGNDATA createRGNDATA(boolean direct) {
01321:                return new RGNDATA(direct);
01322:            }
01323:
01324:            public final RGNDATA createRGNDATA(VoidPointer base) {
01325:                return new RGNDATA(base);
01326:            }
01327:
01328:            public final RGNDATA createRGNDATA(long addr) {
01329:                return new RGNDATA(addr);
01330:            }
01331:
01332:            public static class XFORM extends CommonStructWrapper {
01333:
01334:                public static final int sizeof = 24;
01335:
01336:                XFORM(boolean direct) {
01337:                    super (sizeof, direct);
01338:                }
01339:
01340:                XFORM(VoidPointer base) {
01341:                    super (base);
01342:                }
01343:
01344:                XFORM(long addr) {
01345:                    super (addr);
01346:                }
01347:
01348:                public final void set_eM11(float val) {
01349:                    byteBase.setFloat(0, val);
01350:                }
01351:
01352:                public final float get_eM11() {
01353:                    return byteBase.getFloat(0);
01354:                }
01355:
01356:                public final void set_eM12(float val) {
01357:                    byteBase.setFloat(4, val);
01358:                }
01359:
01360:                public final float get_eM12() {
01361:                    return byteBase.getFloat(4);
01362:                }
01363:
01364:                public final void set_eM21(float val) {
01365:                    byteBase.setFloat(8, val);
01366:                }
01367:
01368:                public final float get_eM21() {
01369:                    return byteBase.getFloat(8);
01370:                }
01371:
01372:                public final void set_eM22(float val) {
01373:                    byteBase.setFloat(12, val);
01374:                }
01375:
01376:                public final float get_eM22() {
01377:                    return byteBase.getFloat(12);
01378:                }
01379:
01380:                public final void set_eDx(float val) {
01381:                    byteBase.setFloat(16, val);
01382:                }
01383:
01384:                public final float get_eDx() {
01385:                    return byteBase.getFloat(16);
01386:                }
01387:
01388:                public final void set_eDy(float val) {
01389:                    byteBase.setFloat(20, val);
01390:                }
01391:
01392:                public final float get_eDy() {
01393:                    return byteBase.getFloat(20);
01394:                }
01395:
01396:                @Override
01397:                public int size() {
01398:                    return sizeof;
01399:                }
01400:            }
01401:
01402:            public final XFORM createXFORM(boolean direct) {
01403:                return new XFORM(direct);
01404:            }
01405:
01406:            public final XFORM createXFORM(VoidPointer base) {
01407:                return new XFORM(base);
01408:            }
01409:
01410:            public final XFORM createXFORM(long addr) {
01411:                return new XFORM(addr);
01412:            }
01413:
01414:            public static class RGNDATAHEADER extends CommonStructWrapper {
01415:
01416:                public static final int sizeof = 32;
01417:
01418:                RGNDATAHEADER(boolean direct) {
01419:                    super (sizeof, direct);
01420:                }
01421:
01422:                RGNDATAHEADER(VoidPointer base) {
01423:                    super (base);
01424:                }
01425:
01426:                RGNDATAHEADER(long addr) {
01427:                    super (addr);
01428:                }
01429:
01430:                public final void set_dwSize(int val) {
01431:                    byteBase.setInt32(0, val);
01432:                }
01433:
01434:                public final int get_dwSize() {
01435:                    return byteBase.getInt32(0);
01436:                }
01437:
01438:                public final void set_iType(int val) {
01439:                    byteBase.setInt32(4, val);
01440:                }
01441:
01442:                public final int get_iType() {
01443:                    return byteBase.getInt32(4);
01444:                }
01445:
01446:                public final void set_nCount(int val) {
01447:                    byteBase.setInt32(8, val);
01448:                }
01449:
01450:                public final int get_nCount() {
01451:                    return byteBase.getInt32(8);
01452:                }
01453:
01454:                public final void set_nRgnSize(int val) {
01455:                    byteBase.setInt32(12, val);
01456:                }
01457:
01458:                public final int get_nRgnSize() {
01459:                    return byteBase.getInt32(12);
01460:                }
01461:
01462:                public final Win32.RECT get_rcBound() {
01463:                    return Win32.instance.createRECT(getElementPointer(16));
01464:                }
01465:
01466:                @Override
01467:                public int size() {
01468:                    return sizeof;
01469:                }
01470:            }
01471:
01472:            public final RGNDATAHEADER createRGNDATAHEADER(boolean direct) {
01473:                return new RGNDATAHEADER(direct);
01474:            }
01475:
01476:            public final RGNDATAHEADER createRGNDATAHEADER(VoidPointer base) {
01477:                return new RGNDATAHEADER(base);
01478:            }
01479:
01480:            public final RGNDATAHEADER createRGNDATAHEADER(long addr) {
01481:                return new RGNDATAHEADER(addr);
01482:            }
01483:
01484:            public final int GetThemeSysInt(VoidPointer hTheme, int iIntId,
01485:                    Int32Pointer piValue) {
01486:                long tmp_0 = hTheme == null ? 0 : hTheme.longLockPointer();
01487:                long tmp_1 = piValue == null ? 0 : piValue.longLockPointer();
01488:                int tmp_ret = GetThemeSysInt(tmp_0, iIntId, tmp_1);
01489:                if (hTheme != null) {
01490:                    hTheme.unlock();
01491:                }
01492:                if (piValue != null) {
01493:                    piValue.unlock();
01494:                }
01495:                return tmp_ret;
01496:            }
01497:
01498:            public final native int GetThemeSysInt(long hTheme, int iIntId,
01499:                    long piValue);
01500:
01501:            public final int TrackMouseEvent(TRACKMOUSEEVENT lpEventTrack) {
01502:                long tmp_0 = lpEventTrack == null ? 0 : lpEventTrack
01503:                        .longLockPointer();
01504:                int tmp_ret = TrackMouseEvent(tmp_0);
01505:                if (lpEventTrack != null) {
01506:                    lpEventTrack.unlock();
01507:                }
01508:                return tmp_ret;
01509:            }
01510:
01511:            public final native int TrackMouseEvent(long lpEventTrack);
01512:
01513:            public static class TRACKMOUSEEVENT extends CommonStructWrapper {
01514:
01515:                public static final int sizeof = NativeBridge.is64 ? 24 : 16;
01516:
01517:                TRACKMOUSEEVENT(boolean direct) {
01518:                    super (sizeof, direct);
01519:                }
01520:
01521:                TRACKMOUSEEVENT(VoidPointer base) {
01522:                    super (base);
01523:                }
01524:
01525:                TRACKMOUSEEVENT(long addr) {
01526:                    super (addr);
01527:                }
01528:
01529:                public final void set_cbSize(int val) {
01530:                    byteBase.setInt32(0, val);
01531:                }
01532:
01533:                public final int get_cbSize() {
01534:                    return byteBase.getInt32(0);
01535:                }
01536:
01537:                public final void set_dwFlags(int val) {
01538:                    byteBase.setInt32(4, val);
01539:                }
01540:
01541:                public final int get_dwFlags() {
01542:                    return byteBase.getInt32(4);
01543:                }
01544:
01545:                public final void set_hwndTrack(long val) {
01546:                    byteBase.setAddress(8, val);
01547:                }
01548:
01549:                public final long get_hwndTrack() {
01550:                    return byteBase.getAddress(8);
01551:                }
01552:
01553:                public final void set_dwHoverTime(int val) {
01554:                    byteBase.setInt32(NativeBridge.is64 ? 16 : 12, val);
01555:                }
01556:
01557:                public final int get_dwHoverTime() {
01558:                    return byteBase.getInt32(NativeBridge.is64 ? 16 : 12);
01559:                }
01560:
01561:                @Override
01562:                public int size() {
01563:                    return sizeof;
01564:                }
01565:            }
01566:
01567:            public final TRACKMOUSEEVENT createTRACKMOUSEEVENT(boolean direct) {
01568:                return new TRACKMOUSEEVENT(direct);
01569:            }
01570:
01571:            public final TRACKMOUSEEVENT createTRACKMOUSEEVENT(VoidPointer base) {
01572:                return new TRACKMOUSEEVENT(base);
01573:            }
01574:
01575:            public final TRACKMOUSEEVENT createTRACKMOUSEEVENT(long addr) {
01576:                return new TRACKMOUSEEVENT(addr);
01577:            }
01578:
01579:            public final long CreateWindowExW(int dwExStyle,
01580:                    String lpClassName, String lpWindowName, int dwStyle,
01581:                    int X, int Y, int nWidth, int nHeight, long hWndParent,
01582:                    long hMenu, long hInstance, VoidPointer lpParam) {
01583:                Int16Pointer _lpClassName = null == lpClassName ? null : nb
01584:                        .createInt16Pointer(lpClassName, false);
01585:                long tmp_0 = _lpClassName == null ? 0 : _lpClassName
01586:                        .longLockPointer();
01587:                Int16Pointer _lpWindowName = null == lpWindowName ? null : nb
01588:                        .createInt16Pointer(lpWindowName, false);
01589:                long tmp_1 = _lpWindowName == null ? 0 : _lpWindowName
01590:                        .longLockPointer();
01591:                long tmp_2 = lpParam == null ? 0 : lpParam.longLockPointer();
01592:                long tmp_ret = CreateWindowExW(dwExStyle, tmp_0, tmp_1,
01593:                        dwStyle, X, Y, nWidth, nHeight, hWndParent, hMenu,
01594:                        hInstance, tmp_2);
01595:                if (_lpClassName != null) {
01596:                    _lpClassName.unlock();
01597:                    _lpClassName.free();
01598:                }
01599:                if (_lpWindowName != null) {
01600:                    _lpWindowName.unlock();
01601:                    _lpWindowName.free();
01602:                }
01603:                if (lpParam != null) {
01604:                    lpParam.unlock();
01605:                }
01606:                return tmp_ret;
01607:            }
01608:
01609:            public final long CreateWindowExW(int dwExStyle,
01610:                    Int16Pointer lpClassName, Int16Pointer lpWindowName,
01611:                    int dwStyle, int X, int Y, int nWidth, int nHeight,
01612:                    long hWndParent, long hMenu, long hInstance,
01613:                    VoidPointer lpParam) {
01614:                long tmp_0 = lpClassName == null ? 0 : lpClassName
01615:                        .longLockPointer();
01616:                long tmp_1 = lpWindowName == null ? 0 : lpWindowName
01617:                        .longLockPointer();
01618:                long tmp_2 = lpParam == null ? 0 : lpParam.longLockPointer();
01619:                long tmp_ret = CreateWindowExW(dwExStyle, tmp_0, tmp_1,
01620:                        dwStyle, X, Y, nWidth, nHeight, hWndParent, hMenu,
01621:                        hInstance, tmp_2);
01622:                if (lpClassName != null) {
01623:                    lpClassName.unlock();
01624:                }
01625:                if (lpWindowName != null) {
01626:                    lpWindowName.unlock();
01627:                }
01628:                if (lpParam != null) {
01629:                    lpParam.unlock();
01630:                }
01631:                return tmp_ret;
01632:            }
01633:
01634:            public final native long CreateWindowExW(int dwExStyle,
01635:                    long lpClassName, long lpWindowName, int dwStyle, int X,
01636:                    int Y, int nWidth, int nHeight, long hWndParent,
01637:                    long hMenu, long hInstance, long lpParam);
01638:
01639:            public final native long SetClipboardViewer(long hWndNewViewer);
01640:
01641:            public final native int Ellipse(long param_0, int param_1,
01642:                    int param_2, int param_3, int param_4);
01643:
01644:            public final native int GetLastError();
01645:
01646:            public final void SHGetSettings(SHELLFLAGSTATE lpsfs, int dwMask) {
01647:                long tmp_0 = lpsfs == null ? 0 : lpsfs.longLockPointer();
01648:                SHGetSettings(tmp_0, dwMask);
01649:                if (lpsfs != null) {
01650:                    lpsfs.unlock();
01651:                }
01652:            }
01653:
01654:            public final native void SHGetSettings(long lpsfs, int dwMask);
01655:
01656:            public static class SHELLFLAGSTATE extends CommonStructWrapper {
01657:
01658:                public static final int sizeof = 56;
01659:
01660:                SHELLFLAGSTATE(boolean direct) {
01661:                    super (sizeof, direct);
01662:                }
01663:
01664:                SHELLFLAGSTATE(VoidPointer base) {
01665:                    super (base);
01666:                }
01667:
01668:                SHELLFLAGSTATE(long addr) {
01669:                    super (addr);
01670:                }
01671:
01672:                public final void set_fShowAllObjects(int val) {
01673:                    byteBase.setInt32(0, val);
01674:                }
01675:
01676:                public final int get_fShowAllObjects() {
01677:                    return byteBase.getInt32(0);
01678:                }
01679:
01680:                public final void set_fShowExtensions(int val) {
01681:                    byteBase.setInt32(4, val);
01682:                }
01683:
01684:                public final int get_fShowExtensions() {
01685:                    return byteBase.getInt32(4);
01686:                }
01687:
01688:                public final void set_fNoConfirmRecycle(int val) {
01689:                    byteBase.setInt32(8, val);
01690:                }
01691:
01692:                public final int get_fNoConfirmRecycle() {
01693:                    return byteBase.getInt32(8);
01694:                }
01695:
01696:                public final void set_fShowSysFiles(int val) {
01697:                    byteBase.setInt32(12, val);
01698:                }
01699:
01700:                public final int get_fShowSysFiles() {
01701:                    return byteBase.getInt32(12);
01702:                }
01703:
01704:                public final void set_fShowCompColor(int val) {
01705:                    byteBase.setInt32(16, val);
01706:                }
01707:
01708:                public final int get_fShowCompColor() {
01709:                    return byteBase.getInt32(16);
01710:                }
01711:
01712:                public final void set_fDoubleClickInWebView(int val) {
01713:                    byteBase.setInt32(20, val);
01714:                }
01715:
01716:                public final int get_fDoubleClickInWebView() {
01717:                    return byteBase.getInt32(20);
01718:                }
01719:
01720:                public final void set_fDesktopHTML(int val) {
01721:                    byteBase.setInt32(24, val);
01722:                }
01723:
01724:                public final int get_fDesktopHTML() {
01725:                    return byteBase.getInt32(24);
01726:                }
01727:
01728:                public final void set_fWin95Classic(int val) {
01729:                    byteBase.setInt32(28, val);
01730:                }
01731:
01732:                public final int get_fWin95Classic() {
01733:                    return byteBase.getInt32(28);
01734:                }
01735:
01736:                public final void set_fDontPrettyPath(int val) {
01737:                    byteBase.setInt32(32, val);
01738:                }
01739:
01740:                public final int get_fDontPrettyPath() {
01741:                    return byteBase.getInt32(32);
01742:                }
01743:
01744:                public final void set_fShowAttribCol(int val) {
01745:                    byteBase.setInt32(36, val);
01746:                }
01747:
01748:                public final int get_fShowAttribCol() {
01749:                    return byteBase.getInt32(36);
01750:                }
01751:
01752:                public final void set_fMapNetDrvBtn(int val) {
01753:                    byteBase.setInt32(40, val);
01754:                }
01755:
01756:                public final int get_fMapNetDrvBtn() {
01757:                    return byteBase.getInt32(40);
01758:                }
01759:
01760:                public final void set_fShowInfoTip(int val) {
01761:                    byteBase.setInt32(44, val);
01762:                }
01763:
01764:                public final int get_fShowInfoTip() {
01765:                    return byteBase.getInt32(44);
01766:                }
01767:
01768:                public final void set_fHideIcons(int val) {
01769:                    byteBase.setInt32(48, val);
01770:                }
01771:
01772:                public final int get_fHideIcons() {
01773:                    return byteBase.getInt32(48);
01774:                }
01775:
01776:                public final void set_fRestFlags(int val) {
01777:                    byteBase.setInt32(52, val);
01778:                }
01779:
01780:                public final int get_fRestFlags() {
01781:                    return byteBase.getInt32(52);
01782:                }
01783:
01784:                @Override
01785:                public int size() {
01786:                    return sizeof;
01787:                }
01788:            }
01789:
01790:            public final SHELLFLAGSTATE createSHELLFLAGSTATE(boolean direct) {
01791:                return new SHELLFLAGSTATE(direct);
01792:            }
01793:
01794:            public final SHELLFLAGSTATE createSHELLFLAGSTATE(VoidPointer base) {
01795:                return new SHELLFLAGSTATE(base);
01796:            }
01797:
01798:            public final SHELLFLAGSTATE createSHELLFLAGSTATE(long addr) {
01799:                return new SHELLFLAGSTATE(addr);
01800:            }
01801:
01802:            public final native long ImmAssociateContext(long param_0,
01803:                    long param_1);
01804:
01805:            public final native long ImmGetContext(long param_0);
01806:
01807:            public final native int GetPixel(long param_0, int param_1,
01808:                    int param_2);
01809:
01810:            public final native long GetDC(long hWnd);
01811:
01812:            public final native int GetBkMode(long param_0);
01813:
01814:            public final native long GetStockObject(int param_0);
01815:
01816:            public final native int ValidateRgn(long hWnd, long hRgn);
01817:
01818:            public final native void keybd_event(byte bVk, byte bScan,
01819:                    int dwFlags, long dwExtraInfo);
01820:
01821:            public final int DrawThemeBackground(VoidPointer hTheme, long hdc,
01822:                    int iPartId, int iStateId, Win32.RECT pRect,
01823:                    Win32.RECT pClipRect) {
01824:                long tmp_0 = hTheme == null ? 0 : hTheme.longLockPointer();
01825:                long tmp_1 = pRect == null ? 0 : pRect.longLockPointer();
01826:                long tmp_2 = pClipRect == null ? 0 : pClipRect
01827:                        .longLockPointer();
01828:                int tmp_ret = DrawThemeBackground(tmp_0, hdc, iPartId,
01829:                        iStateId, tmp_1, tmp_2);
01830:                if (hTheme != null) {
01831:                    hTheme.unlock();
01832:                }
01833:                if (pRect != null) {
01834:                    pRect.unlock();
01835:                }
01836:                if (pClipRect != null) {
01837:                    pClipRect.unlock();
01838:                }
01839:                return tmp_ret;
01840:            }
01841:
01842:            public final native int DrawThemeBackground(long hTheme, long hdc,
01843:                    int iPartId, int iStateId, long pRect, long pClipRect);
01844:
01845:            public final int GetMonitorInfoW(long hMonitor, MONITORINFO lpmi) {
01846:                long tmp_0 = lpmi == null ? 0 : lpmi.longLockPointer();
01847:                int tmp_ret = GetMonitorInfoW(hMonitor, tmp_0);
01848:                if (lpmi != null) {
01849:                    lpmi.unlock();
01850:                }
01851:                return tmp_ret;
01852:            }
01853:
01854:            public final native int GetMonitorInfoW(long hMonitor, long lpmi);
01855:
01856:            public static class MONITORINFO extends CommonStructWrapper {
01857:
01858:                public static final int sizeof = 40;
01859:
01860:                MONITORINFO(boolean direct) {
01861:                    super (sizeof, direct);
01862:                }
01863:
01864:                MONITORINFO(VoidPointer base) {
01865:                    super (base);
01866:                }
01867:
01868:                MONITORINFO(long addr) {
01869:                    super (addr);
01870:                }
01871:
01872:                public final void set_cbSize(int val) {
01873:                    byteBase.setInt32(0, val);
01874:                }
01875:
01876:                public final int get_cbSize() {
01877:                    return byteBase.getInt32(0);
01878:                }
01879:
01880:                public final Win32.RECT get_rcMonitor() {
01881:                    return Win32.instance.createRECT(getElementPointer(4));
01882:                }
01883:
01884:                public final Win32.RECT get_rcWork() {
01885:                    return Win32.instance.createRECT(getElementPointer(20));
01886:                }
01887:
01888:                public final void set_dwFlags(int val) {
01889:                    byteBase.setInt32(36, val);
01890:                }
01891:
01892:                public final int get_dwFlags() {
01893:                    return byteBase.getInt32(36);
01894:                }
01895:
01896:                @Override
01897:                public int size() {
01898:                    return sizeof;
01899:                }
01900:            }
01901:
01902:            public final MONITORINFO createMONITORINFO(boolean direct) {
01903:                return new MONITORINFO(direct);
01904:            }
01905:
01906:            public final MONITORINFO createMONITORINFO(VoidPointer base) {
01907:                return new MONITORINFO(base);
01908:            }
01909:
01910:            public final MONITORINFO createMONITORINFO(long addr) {
01911:                return new MONITORINFO(addr);
01912:            }
01913:
01914:            public final native int GetCurrentThreadId();
01915:
01916:            public final native int DeleteDC(long param_0);
01917:
01918:            public final long SHGetFileInfoW(String pszPath,
01919:                    int dwFileAttributes, SHFILEINFOW psfi, int cbFileInfo,
01920:                    int uFlags) {
01921:                Int16Pointer _pszPath = null == pszPath ? null : nb
01922:                        .createInt16Pointer(pszPath, false);
01923:                long tmp_0 = _pszPath == null ? 0 : _pszPath.longLockPointer();
01924:                long tmp_1 = psfi == null ? 0 : psfi.longLockPointer();
01925:                long tmp_ret = SHGetFileInfoW(tmp_0, dwFileAttributes, tmp_1,
01926:                        cbFileInfo, uFlags);
01927:                if (_pszPath != null) {
01928:                    _pszPath.unlock();
01929:                    _pszPath.free();
01930:                }
01931:                if (psfi != null) {
01932:                    psfi.unlock();
01933:                }
01934:                return tmp_ret;
01935:            }
01936:
01937:            public final long SHGetFileInfoW(Int16Pointer pszPath,
01938:                    int dwFileAttributes, SHFILEINFOW psfi, int cbFileInfo,
01939:                    int uFlags) {
01940:                long tmp_0 = pszPath == null ? 0 : pszPath.longLockPointer();
01941:                long tmp_1 = psfi == null ? 0 : psfi.longLockPointer();
01942:                long tmp_ret = SHGetFileInfoW(tmp_0, dwFileAttributes, tmp_1,
01943:                        cbFileInfo, uFlags);
01944:                if (pszPath != null) {
01945:                    pszPath.unlock();
01946:                }
01947:                if (psfi != null) {
01948:                    psfi.unlock();
01949:                }
01950:                return tmp_ret;
01951:            }
01952:
01953:            public final native long SHGetFileInfoW(long pszPath,
01954:                    int dwFileAttributes, long psfi, int cbFileInfo, int uFlags);
01955:
01956:            public static class SHFILEINFOW extends CommonStructWrapper {
01957:
01958:                public static final int sizeof = NativeBridge.is64 ? 696 : 692;
01959:
01960:                SHFILEINFOW(boolean direct) {
01961:                    super (sizeof, direct);
01962:                }
01963:
01964:                SHFILEINFOW(VoidPointer base) {
01965:                    super (base);
01966:                }
01967:
01968:                SHFILEINFOW(long addr) {
01969:                    super (addr);
01970:                }
01971:
01972:                public final void set_hIcon(long val) {
01973:                    byteBase.setAddress(0, val);
01974:                }
01975:
01976:                public final long get_hIcon() {
01977:                    return byteBase.getAddress(0);
01978:                }
01979:
01980:                public final void set_iIcon(int val) {
01981:                    byteBase.setInt32(NativeBridge.is64 ? 8 : 4, val);
01982:                }
01983:
01984:                public final int get_iIcon() {
01985:                    return byteBase.getInt32(NativeBridge.is64 ? 8 : 4);
01986:                }
01987:
01988:                public final void set_dwAttributes(int val) {
01989:                    byteBase.setInt32(NativeBridge.is64 ? 12 : 8, val);
01990:                }
01991:
01992:                public final int get_dwAttributes() {
01993:                    return byteBase.getInt32(NativeBridge.is64 ? 12 : 8);
01994:                }
01995:
01996:                public final Int16Pointer get_szDisplayName() {
01997:                    return nb
01998:                            .createInt16Pointer(getElementPointer(NativeBridge.is64 ? 16
01999:                                    : 12));
02000:                }
02001:
02002:                public final Int16Pointer get_szTypeName() {
02003:                    return nb
02004:                            .createInt16Pointer(getElementPointer(NativeBridge.is64 ? 536
02005:                                    : 532));
02006:                }
02007:
02008:                @Override
02009:                public int size() {
02010:                    return sizeof;
02011:                }
02012:            }
02013:
02014:            public final SHFILEINFOW createSHFILEINFOW(boolean direct) {
02015:                return new SHFILEINFOW(direct);
02016:            }
02017:
02018:            public final SHFILEINFOW createSHFILEINFOW(VoidPointer base) {
02019:                return new SHFILEINFOW(base);
02020:            }
02021:
02022:            public final SHFILEINFOW createSHFILEINFOW(long addr) {
02023:                return new SHFILEINFOW(addr);
02024:            }
02025:
02026:            public final long DispatchMessageW(Win32.MSG lpMsg) {
02027:                long tmp_0 = lpMsg == null ? 0 : lpMsg.longLockPointer();
02028:                long tmp_ret = DispatchMessageW(tmp_0);
02029:                if (lpMsg != null) {
02030:                    lpMsg.unlock();
02031:                }
02032:                return tmp_ret;
02033:            }
02034:
02035:            public final native long DispatchMessageW(long lpMsg);
02036:
02037:            public final native int PostThreadMessageW(int idThread, int Msg,
02038:                    long wParam, long lParam);
02039:
02040:            public final native int GetSysColor(int nIndex);
02041:
02042:            public final native long GetSystemMenu(long hWnd, int bRevert);
02043:
02044:            public final int SetPixelFormat(long param_0, int param_1,
02045:                    PIXELFORMATDESCRIPTOR param_2) {
02046:                long tmp_0 = param_2 == null ? 0 : param_2.longLockPointer();
02047:                int tmp_ret = SetPixelFormat(param_0, param_1, tmp_0);
02048:                if (param_2 != null) {
02049:                    param_2.unlock();
02050:                }
02051:                return tmp_ret;
02052:            }
02053:
02054:            public final native int SetPixelFormat(long param_0, int param_1,
02055:                    long param_2);
02056:
02057:            public static class PIXELFORMATDESCRIPTOR extends
02058:                    CommonStructWrapper {
02059:
02060:                public static final int sizeof = 40;
02061:
02062:                PIXELFORMATDESCRIPTOR(boolean direct) {
02063:                    super (sizeof, direct);
02064:                }
02065:
02066:                PIXELFORMATDESCRIPTOR(VoidPointer base) {
02067:                    super (base);
02068:                }
02069:
02070:                PIXELFORMATDESCRIPTOR(long addr) {
02071:                    super (addr);
02072:                }
02073:
02074:                public final void set_nSize(short val) {
02075:                    byteBase.setInt16(0, val);
02076:                }
02077:
02078:                public final short get_nSize() {
02079:                    return byteBase.getInt16(0);
02080:                }
02081:
02082:                public final void set_nVersion(short val) {
02083:                    byteBase.setInt16(2, val);
02084:                }
02085:
02086:                public final short get_nVersion() {
02087:                    return byteBase.getInt16(2);
02088:                }
02089:
02090:                public final void set_dwFlags(int val) {
02091:                    byteBase.setInt32(4, val);
02092:                }
02093:
02094:                public final int get_dwFlags() {
02095:                    return byteBase.getInt32(4);
02096:                }
02097:
02098:                public final void set_iPixelType(byte val) {
02099:                    byteBase.set(8, val);
02100:                }
02101:
02102:                public final byte get_iPixelType() {
02103:                    return byteBase.get(8);
02104:                }
02105:
02106:                public final void set_cColorBits(byte val) {
02107:                    byteBase.set(9, val);
02108:                }
02109:
02110:                public final byte get_cColorBits() {
02111:                    return byteBase.get(9);
02112:                }
02113:
02114:                public final void set_cRedBits(byte val) {
02115:                    byteBase.set(10, val);
02116:                }
02117:
02118:                public final byte get_cRedBits() {
02119:                    return byteBase.get(10);
02120:                }
02121:
02122:                public final void set_cRedShift(byte val) {
02123:                    byteBase.set(11, val);
02124:                }
02125:
02126:                public final byte get_cRedShift() {
02127:                    return byteBase.get(11);
02128:                }
02129:
02130:                public final void set_cGreenBits(byte val) {
02131:                    byteBase.set(12, val);
02132:                }
02133:
02134:                public final byte get_cGreenBits() {
02135:                    return byteBase.get(12);
02136:                }
02137:
02138:                public final void set_cGreenShift(byte val) {
02139:                    byteBase.set(13, val);
02140:                }
02141:
02142:                public final byte get_cGreenShift() {
02143:                    return byteBase.get(13);
02144:                }
02145:
02146:                public final void set_cBlueBits(byte val) {
02147:                    byteBase.set(14, val);
02148:                }
02149:
02150:                public final byte get_cBlueBits() {
02151:                    return byteBase.get(14);
02152:                }
02153:
02154:                public final void set_cBlueShift(byte val) {
02155:                    byteBase.set(15, val);
02156:                }
02157:
02158:                public final byte get_cBlueShift() {
02159:                    return byteBase.get(15);
02160:                }
02161:
02162:                public final void set_cAlphaBits(byte val) {
02163:                    byteBase.set(16, val);
02164:                }
02165:
02166:                public final byte get_cAlphaBits() {
02167:                    return byteBase.get(16);
02168:                }
02169:
02170:                public final void set_cAlphaShift(byte val) {
02171:                    byteBase.set(17, val);
02172:                }
02173:
02174:                public final byte get_cAlphaShift() {
02175:                    return byteBase.get(17);
02176:                }
02177:
02178:                public final void set_cAccumBits(byte val) {
02179:                    byteBase.set(18, val);
02180:                }
02181:
02182:                public final byte get_cAccumBits() {
02183:                    return byteBase.get(18);
02184:                }
02185:
02186:                public final void set_cAccumRedBits(byte val) {
02187:                    byteBase.set(19, val);
02188:                }
02189:
02190:                public final byte get_cAccumRedBits() {
02191:                    return byteBase.get(19);
02192:                }
02193:
02194:                public final void set_cAccumGreenBits(byte val) {
02195:                    byteBase.set(20, val);
02196:                }
02197:
02198:                public final byte get_cAccumGreenBits() {
02199:                    return byteBase.get(20);
02200:                }
02201:
02202:                public final void set_cAccumBlueBits(byte val) {
02203:                    byteBase.set(21, val);
02204:                }
02205:
02206:                public final byte get_cAccumBlueBits() {
02207:                    return byteBase.get(21);
02208:                }
02209:
02210:                public final void set_cAccumAlphaBits(byte val) {
02211:                    byteBase.set(22, val);
02212:                }
02213:
02214:                public final byte get_cAccumAlphaBits() {
02215:                    return byteBase.get(22);
02216:                }
02217:
02218:                public final void set_cDepthBits(byte val) {
02219:                    byteBase.set(23, val);
02220:                }
02221:
02222:                public final byte get_cDepthBits() {
02223:                    return byteBase.get(23);
02224:                }
02225:
02226:                public final void set_cStencilBits(byte val) {
02227:                    byteBase.set(24, val);
02228:                }
02229:
02230:                public final byte get_cStencilBits() {
02231:                    return byteBase.get(24);
02232:                }
02233:
02234:                public final void set_cAuxBuffers(byte val) {
02235:                    byteBase.set(25, val);
02236:                }
02237:
02238:                public final byte get_cAuxBuffers() {
02239:                    return byteBase.get(25);
02240:                }
02241:
02242:                public final void set_iLayerType(byte val) {
02243:                    byteBase.set(26, val);
02244:                }
02245:
02246:                public final byte get_iLayerType() {
02247:                    return byteBase.get(26);
02248:                }
02249:
02250:                public final void set_bReserved(byte val) {
02251:                    byteBase.set(27, val);
02252:                }
02253:
02254:                public final byte get_bReserved() {
02255:                    return byteBase.get(27);
02256:                }
02257:
02258:                public final void set_dwLayerMask(int val) {
02259:                    byteBase.setInt32(28, val);
02260:                }
02261:
02262:                public final int get_dwLayerMask() {
02263:                    return byteBase.getInt32(28);
02264:                }
02265:
02266:                public final void set_dwVisibleMask(int val) {
02267:                    byteBase.setInt32(32, val);
02268:                }
02269:
02270:                public final int get_dwVisibleMask() {
02271:                    return byteBase.getInt32(32);
02272:                }
02273:
02274:                public final void set_dwDamageMask(int val) {
02275:                    byteBase.setInt32(36, val);
02276:                }
02277:
02278:                public final int get_dwDamageMask() {
02279:                    return byteBase.getInt32(36);
02280:                }
02281:
02282:                @Override
02283:                public int size() {
02284:                    return sizeof;
02285:                }
02286:            }
02287:
02288:            public final PIXELFORMATDESCRIPTOR createPIXELFORMATDESCRIPTOR(
02289:                    boolean direct) {
02290:                return new PIXELFORMATDESCRIPTOR(direct);
02291:            }
02292:
02293:            public final PIXELFORMATDESCRIPTOR createPIXELFORMATDESCRIPTOR(
02294:                    VoidPointer base) {
02295:                return new PIXELFORMATDESCRIPTOR(base);
02296:            }
02297:
02298:            public final PIXELFORMATDESCRIPTOR createPIXELFORMATDESCRIPTOR(
02299:                    long addr) {
02300:                return new PIXELFORMATDESCRIPTOR(addr);
02301:            }
02302:
02303:            public final int GetCursorPos(Win32.POINT lpPoint) {
02304:                long tmp_0 = lpPoint == null ? 0 : lpPoint.longLockPointer();
02305:                int tmp_ret = GetCursorPos(tmp_0);
02306:                if (lpPoint != null) {
02307:                    lpPoint.unlock();
02308:                }
02309:                return tmp_ret;
02310:            }
02311:
02312:            public final native int GetCursorPos(long lpPoint);
02313:
02314:            public final native int PatBlt(long param_0, int param_1,
02315:                    int param_2, int param_3, int param_4, int param_5);
02316:
02317:            public final native long SetCursor(long hCursor);
02318:
02319:            public final int AppendMenuW(long hMenu, int uFlags,
02320:                    long uIDNewItem, String lpNewItem) {
02321:                Int16Pointer _lpNewItem = null == lpNewItem ? null : nb
02322:                        .createInt16Pointer(lpNewItem, false);
02323:                long tmp_0 = _lpNewItem == null ? 0 : _lpNewItem
02324:                        .longLockPointer();
02325:                int tmp_ret = AppendMenuW(hMenu, uFlags, uIDNewItem, tmp_0);
02326:                if (_lpNewItem != null) {
02327:                    _lpNewItem.unlock();
02328:                    _lpNewItem.free();
02329:                }
02330:                return tmp_ret;
02331:            }
02332:
02333:            public final int AppendMenuW(long hMenu, int uFlags,
02334:                    long uIDNewItem, Int16Pointer lpNewItem) {
02335:                long tmp_0 = lpNewItem == null ? 0 : lpNewItem
02336:                        .longLockPointer();
02337:                int tmp_ret = AppendMenuW(hMenu, uFlags, uIDNewItem, tmp_0);
02338:                if (lpNewItem != null) {
02339:                    lpNewItem.unlock();
02340:                }
02341:                return tmp_ret;
02342:            }
02343:
02344:            public final native int AppendMenuW(long hMenu, int uFlags,
02345:                    long uIDNewItem, long lpNewItem);
02346:
02347:            public final int SetWindowPlacement(long hWnd,
02348:                    WINDOWPLACEMENT lpwndpl) {
02349:                long tmp_0 = lpwndpl == null ? 0 : lpwndpl.longLockPointer();
02350:                int tmp_ret = SetWindowPlacement(hWnd, tmp_0);
02351:                if (lpwndpl != null) {
02352:                    lpwndpl.unlock();
02353:                }
02354:                return tmp_ret;
02355:            }
02356:
02357:            public final native int SetWindowPlacement(long hWnd, long lpwndpl);
02358:
02359:            public static class WINDOWPLACEMENT extends CommonStructWrapper {
02360:
02361:                public static final int sizeof = 44;
02362:
02363:                WINDOWPLACEMENT(boolean direct) {
02364:                    super (sizeof, direct);
02365:                }
02366:
02367:                WINDOWPLACEMENT(VoidPointer base) {
02368:                    super (base);
02369:                }
02370:
02371:                WINDOWPLACEMENT(long addr) {
02372:                    super (addr);
02373:                }
02374:
02375:                public final void set_length(int val) {
02376:                    byteBase.setInt32(0, val);
02377:                }
02378:
02379:                public final int get_length() {
02380:                    return byteBase.getInt32(0);
02381:                }
02382:
02383:                public final void set_flags(int val) {
02384:                    byteBase.setInt32(4, val);
02385:                }
02386:
02387:                public final int get_flags() {
02388:                    return byteBase.getInt32(4);
02389:                }
02390:
02391:                public final void set_showCmd(int val) {
02392:                    byteBase.setInt32(8, val);
02393:                }
02394:
02395:                public final int get_showCmd() {
02396:                    return byteBase.getInt32(8);
02397:                }
02398:
02399:                public final Win32.POINT get_ptMinPosition() {
02400:                    return Win32.instance.createPOINT(getElementPointer(12));
02401:                }
02402:
02403:                public final Win32.POINT get_ptMaxPosition() {
02404:                    return Win32.instance.createPOINT(getElementPointer(20));
02405:                }
02406:
02407:                public final Win32.RECT get_rcNormalPosition() {
02408:                    return Win32.instance.createRECT(getElementPointer(28));
02409:                }
02410:
02411:                @Override
02412:                public int size() {
02413:                    return sizeof;
02414:                }
02415:            }
02416:
02417:            public final WINDOWPLACEMENT createWINDOWPLACEMENT(boolean direct) {
02418:                return new WINDOWPLACEMENT(direct);
02419:            }
02420:
02421:            public final WINDOWPLACEMENT createWINDOWPLACEMENT(VoidPointer base) {
02422:                return new WINDOWPLACEMENT(base);
02423:            }
02424:
02425:            public final WINDOWPLACEMENT createWINDOWPLACEMENT(long addr) {
02426:                return new WINDOWPLACEMENT(addr);
02427:            }
02428:
02429:            public final native long ActivateKeyboardLayout(long hkl, int Flags);
02430:
02431:            public final native int CommDlgExtendedError();
02432:
02433:            public final int GlobalUnlock(VoidPointer hMem) {
02434:                long tmp_0 = hMem == null ? 0 : hMem.longLockPointer();
02435:                int tmp_ret = GlobalUnlock(tmp_0);
02436:                if (hMem != null) {
02437:                    hMem.unlock();
02438:                }
02439:                return tmp_ret;
02440:            }
02441:
02442:            public final native int GlobalUnlock(long hMem);
02443:
02444:            public final native int SetROP2(long param_0, int param_1);
02445:
02446:            public final int SHBindToParent(ITEMIDLIST pidl, GUID riid,
02447:                    PointerPointer ppv, PointerPointer ppidlLast) {
02448:                long tmp_0 = pidl == null ? 0 : pidl.longLockPointer();
02449:                long tmp_1 = riid == null ? 0 : riid.longLockPointer();
02450:                long tmp_2 = ppv == null ? 0 : ppv.longLockPointer();
02451:                long tmp_3 = ppidlLast == null ? 0 : ppidlLast
02452:                        .longLockPointer();
02453:                int tmp_ret = SHBindToParent(tmp_0, tmp_1, tmp_2, tmp_3);
02454:                if (pidl != null) {
02455:                    pidl.unlock();
02456:                }
02457:                if (riid != null) {
02458:                    riid.unlock();
02459:                }
02460:                if (ppv != null) {
02461:                    ppv.unlock();
02462:                }
02463:                if (ppidlLast != null) {
02464:                    ppidlLast.unlock();
02465:                }
02466:                return tmp_ret;
02467:            }
02468:
02469:            public final native int SHBindToParent(long pidl, long riid,
02470:                    long ppv, long ppidlLast);
02471:
02472:            public static class GUID extends CommonStructWrapper {
02473:
02474:                public static final int sizeof = 16;
02475:
02476:                GUID(boolean direct) {
02477:                    super (sizeof, direct);
02478:                }
02479:
02480:                GUID(VoidPointer base) {
02481:                    super (base);
02482:                }
02483:
02484:                GUID(long addr) {
02485:                    super (addr);
02486:                }
02487:
02488:                public final void set_Data1(int val) {
02489:                    byteBase.setInt32(0, val);
02490:                }
02491:
02492:                public final int get_Data1() {
02493:                    return byteBase.getInt32(0);
02494:                }
02495:
02496:                public final void set_Data2(short val) {
02497:                    byteBase.setInt16(4, val);
02498:                }
02499:
02500:                public final short get_Data2() {
02501:                    return byteBase.getInt16(4);
02502:                }
02503:
02504:                public final void set_Data3(short val) {
02505:                    byteBase.setInt16(6, val);
02506:                }
02507:
02508:                public final short get_Data3() {
02509:                    return byteBase.getInt16(6);
02510:                }
02511:
02512:                public final Int8Pointer get_Data4() {
02513:                    return nb.createInt8Pointer(getElementPointer(8));
02514:                }
02515:
02516:                @Override
02517:                public int size() {
02518:                    return sizeof;
02519:                }
02520:            }
02521:
02522:            public final GUID createGUID(boolean direct) {
02523:                return new GUID(direct);
02524:            }
02525:
02526:            public final GUID createGUID(VoidPointer base) {
02527:                return new GUID(base);
02528:            }
02529:
02530:            public final GUID createGUID(long addr) {
02531:                return new GUID(addr);
02532:            }
02533:
02534:            public static class ITEMIDLIST extends CommonStructWrapper {
02535:
02536:                public static final int sizeof = 4;
02537:
02538:                ITEMIDLIST(boolean direct) {
02539:                    super (sizeof, direct);
02540:                }
02541:
02542:                ITEMIDLIST(VoidPointer base) {
02543:                    super (base);
02544:                }
02545:
02546:                ITEMIDLIST(long addr) {
02547:                    super (addr);
02548:                }
02549:
02550:                public final SHITEMID get_mkid() {
02551:                    return instance.createSHITEMID(getElementPointer(0));
02552:                }
02553:
02554:                @Override
02555:                public int size() {
02556:                    return sizeof;
02557:                }
02558:            }
02559:
02560:            public final ITEMIDLIST createITEMIDLIST(boolean direct) {
02561:                return new ITEMIDLIST(direct);
02562:            }
02563:
02564:            public final ITEMIDLIST createITEMIDLIST(VoidPointer base) {
02565:                return new ITEMIDLIST(base);
02566:            }
02567:
02568:            public final ITEMIDLIST createITEMIDLIST(long addr) {
02569:                return new ITEMIDLIST(addr);
02570:            }
02571:
02572:            public static class SHITEMID extends CommonStructWrapper {
02573:
02574:                public static final int sizeof = 4;
02575:
02576:                SHITEMID(boolean direct) {
02577:                    super (sizeof, direct);
02578:                }
02579:
02580:                SHITEMID(VoidPointer base) {
02581:                    super (base);
02582:                }
02583:
02584:                SHITEMID(long addr) {
02585:                    super (addr);
02586:                }
02587:
02588:                public final void set_cb(short val) {
02589:                    byteBase.setInt16(0, val);
02590:                }
02591:
02592:                public final short get_cb() {
02593:                    return byteBase.getInt16(0);
02594:                }
02595:
02596:                public final Int8Pointer get_abID() {
02597:                    return nb.createInt8Pointer(getElementPointer(2));
02598:                }
02599:
02600:                @Override
02601:                public int size() {
02602:                    return sizeof;
02603:                }
02604:            }
02605:
02606:            public final SHITEMID createSHITEMID(boolean direct) {
02607:                return new SHITEMID(direct);
02608:            }
02609:
02610:            public final SHITEMID createSHITEMID(VoidPointer base) {
02611:                return new SHITEMID(base);
02612:            }
02613:
02614:            public final SHITEMID createSHITEMID(long addr) {
02615:                return new SHITEMID(addr);
02616:            }
02617:
02618:            public final int InSendMessageEx(VoidPointer lpReserved) {
02619:                long tmp_0 = lpReserved == null ? 0 : lpReserved
02620:                        .longLockPointer();
02621:                int tmp_ret = InSendMessageEx(tmp_0);
02622:                if (lpReserved != null) {
02623:                    lpReserved.unlock();
02624:                }
02625:                return tmp_ret;
02626:            }
02627:
02628:            public final native int InSendMessageEx(long lpReserved);
02629:
02630:            public final int GetLocaleInfoW(int Locale, int LCType,
02631:                    Int16Pointer lpLCData, int cchData) {
02632:                long tmp_0 = lpLCData == null ? 0 : lpLCData.longLockPointer();
02633:                int tmp_ret = GetLocaleInfoW(Locale, LCType, tmp_0, cchData);
02634:                if (lpLCData != null) {
02635:                    lpLCData.unlock();
02636:                }
02637:                return tmp_ret;
02638:            }
02639:
02640:            public final native int GetLocaleInfoW(int Locale, int LCType,
02641:                    long lpLCData, int cchData);
02642:
02643:            public final int SHGetDataFromIDListW(IShellFolder psf,
02644:                    Win32.ITEMIDLIST pidl, int nFormat, VoidPointer pv, int cb) {
02645:                long tmp_0 = psf == null ? 0 : psf.longLockPointer();
02646:                long tmp_1 = pidl == null ? 0 : pidl.longLockPointer();
02647:                long tmp_2 = pv == null ? 0 : pv.longLockPointer();
02648:                int tmp_ret = SHGetDataFromIDListW(tmp_0, tmp_1, nFormat,
02649:                        tmp_2, cb);
02650:                if (psf != null) {
02651:                    psf.unlock();
02652:                }
02653:                if (pidl != null) {
02654:                    pidl.unlock();
02655:                }
02656:                if (pv != null) {
02657:                    pv.unlock();
02658:                }
02659:                return tmp_ret;
02660:            }
02661:
02662:            public final native int SHGetDataFromIDListW(long psf, long pidl,
02663:                    int nFormat, long pv, int cb);
02664:
02665:            public static class IShellFolder extends CommonStructWrapper {
02666:
02667:                public static final int sizeof = NativeBridge.is64 ? 8 : 4;
02668:
02669:                IShellFolderVtbl vtbl;
02670:
02671:                IShellFolder(long addr) {
02672:                    super (addr);
02673:                    vtbl = get_lpVtbl();
02674:                }
02675:
02676:                public final IShellFolderVtbl get_lpVtbl() {
02677:                    return instance.createIShellFolderVtbl(byteBase
02678:                            .getAddress(0));
02679:                }
02680:
02681:                public final int QueryInterface(Win32.GUID riid,
02682:                        PointerPointer ppvObject) {
02683:                    return vtbl.QueryInterface(this , riid, ppvObject);
02684:                }
02685:
02686:                public final int AddRef() {
02687:                    return vtbl.AddRef(this );
02688:                }
02689:
02690:                public final int Release() {
02691:                    return vtbl.Release(this );
02692:                }
02693:
02694:                public final int ParseDisplayName(long hwnd, IBindCtx pbc,
02695:                        Int16Pointer pszDisplayName, Int32Pointer pchEaten,
02696:                        PointerPointer ppidl, Int32Pointer pdwAttributes) {
02697:                    return vtbl.ParseDisplayName(this , hwnd, pbc,
02698:                            pszDisplayName, pchEaten, ppidl, pdwAttributes);
02699:                }
02700:
02701:                public final int EnumObjects(long hwnd, int grfFlags,
02702:                        PointerPointer ppenumIDList) {
02703:                    return vtbl.EnumObjects(this , hwnd, grfFlags, ppenumIDList);
02704:                }
02705:
02706:                public final int BindToObject(Win32.ITEMIDLIST pidl,
02707:                        IBindCtx pbc, Win32.GUID riid, PointerPointer ppv) {
02708:                    return vtbl.BindToObject(this , pidl, pbc, riid, ppv);
02709:                }
02710:
02711:                public final int BindToStorage(Win32.ITEMIDLIST pidl,
02712:                        IBindCtx pbc, Win32.GUID riid, PointerPointer ppv) {
02713:                    return vtbl.BindToStorage(this , pidl, pbc, riid, ppv);
02714:                }
02715:
02716:                public final int CompareIDs(long lParam,
02717:                        Win32.ITEMIDLIST pidl1, Win32.ITEMIDLIST pidl2) {
02718:                    return vtbl.CompareIDs(this , lParam, pidl1, pidl2);
02719:                }
02720:
02721:                public final int CreateViewObject(long hwndOwner,
02722:                        Win32.GUID riid, PointerPointer ppv) {
02723:                    return vtbl.CreateViewObject(this , hwndOwner, riid, ppv);
02724:                }
02725:
02726:                public final int GetAttributesOf(int cidl,
02727:                        PointerPointer apidl, Int32Pointer rgfInOut) {
02728:                    return vtbl.GetAttributesOf(this , cidl, apidl, rgfInOut);
02729:                }
02730:
02731:                public final int GetUIObjectOf(long hwndOwner, int cidl,
02732:                        PointerPointer apidl, Win32.GUID riid,
02733:                        Int32Pointer rgfReserved, PointerPointer ppv) {
02734:                    return vtbl.GetUIObjectOf(this , hwndOwner, cidl, apidl,
02735:                            riid, rgfReserved, ppv);
02736:                }
02737:
02738:                public final int GetDisplayNameOf(Win32.ITEMIDLIST pidl,
02739:                        int uFlags, STRRET pName) {
02740:                    return vtbl.GetDisplayNameOf(this , pidl, uFlags, pName);
02741:                }
02742:
02743:                public final int SetNameOf(long hwnd, Win32.ITEMIDLIST pidl,
02744:                        String pszName, int uFlags, PointerPointer ppidlOut) {
02745:                    return vtbl.SetNameOf(this , hwnd, pidl, pszName, uFlags,
02746:                            ppidlOut);
02747:                }
02748:
02749:                public final int SetNameOf(long hwnd, Win32.ITEMIDLIST pidl,
02750:                        Int16Pointer pszName, int uFlags,
02751:                        PointerPointer ppidlOut) {
02752:                    return vtbl.SetNameOf(this , hwnd, pidl, pszName, uFlags,
02753:                            ppidlOut);
02754:                }
02755:
02756:                @Override
02757:                public int size() {
02758:                    return sizeof;
02759:                }
02760:            }
02761:
02762:            public final IShellFolder createIShellFolder(long addr) {
02763:                return new IShellFolder(addr);
02764:            }
02765:
02766:            public static class STRRET extends CommonStructWrapper {
02767:
02768:                public static final int sizeof = NativeBridge.is64 ? 272 : 264;
02769:
02770:                STRRET(boolean direct) {
02771:                    super (sizeof, direct);
02772:                }
02773:
02774:                STRRET(VoidPointer base) {
02775:                    super (base);
02776:                }
02777:
02778:                STRRET(long addr) {
02779:                    super (addr);
02780:                }
02781:
02782:                public final void set_uType(int val) {
02783:                    byteBase.setInt32(0, val);
02784:                }
02785:
02786:                public final int get_uType() {
02787:                    return byteBase.getInt32(0);
02788:                }
02789:
02790:                public final void set_pOleStr(Int16Pointer val) {
02791:                    byteBase.setPointer(NativeBridge.is64 ? 8 : 4, val);
02792:                }
02793:
02794:                public final Int16Pointer get_pOleStr() {
02795:                    return nb.createInt16Pointer(byteBase
02796:                            .getAddress(NativeBridge.is64 ? 8 : 4));
02797:                }
02798:
02799:                public final void set_uOffset(int val) {
02800:                    byteBase.setInt32(NativeBridge.is64 ? 8 : 4, val);
02801:                }
02802:
02803:                public final int get_uOffset() {
02804:                    return byteBase.getInt32(NativeBridge.is64 ? 8 : 4);
02805:                }
02806:
02807:                public final Int8Pointer get_cStr() {
02808:                    return nb
02809:                            .createInt8Pointer(getElementPointer(NativeBridge.is64 ? 8
02810:                                    : 4));
02811:                }
02812:
02813:                @Override
02814:                public int size() {
02815:                    return sizeof;
02816:                }
02817:            }
02818:
02819:            public final STRRET createSTRRET(boolean direct) {
02820:                return new STRRET(direct);
02821:            }
02822:
02823:            public final STRRET createSTRRET(VoidPointer base) {
02824:                return new STRRET(base);
02825:            }
02826:
02827:            public final STRRET createSTRRET(long addr) {
02828:                return new STRRET(addr);
02829:            }
02830:
02831:            public static class IBindCtx extends CommonStructWrapper {
02832:
02833:                public static final int sizeof = NativeBridge.is64 ? 8 : 4;
02834:
02835:                IBindCtxVtbl vtbl;
02836:
02837:                IBindCtx(long addr) {
02838:                    super (addr);
02839:                    vtbl = get_lpVtbl();
02840:                }
02841:
02842:                public final IBindCtxVtbl get_lpVtbl() {
02843:                    return instance.createIBindCtxVtbl(byteBase.getAddress(0));
02844:                }
02845:
02846:                public final int QueryInterface(Win32.GUID riid,
02847:                        PointerPointer ppvObject) {
02848:                    return vtbl.QueryInterface(this , riid, ppvObject);
02849:                }
02850:
02851:                public final int AddRef() {
02852:                    return vtbl.AddRef(this );
02853:                }
02854:
02855:                public final int Release() {
02856:                    return vtbl.Release(this );
02857:                }
02858:
02859:                public final int RegisterObjectBound(IUnknown punk) {
02860:                    return vtbl.RegisterObjectBound(this , punk);
02861:                }
02862:
02863:                public final int RevokeObjectBound(IUnknown punk) {
02864:                    return vtbl.RevokeObjectBound(this , punk);
02865:                }
02866:
02867:                public final int ReleaseBoundObjects() {
02868:                    return vtbl.ReleaseBoundObjects(this );
02869:                }
02870:
02871:                public final int SetBindOptions(BIND_OPTS pbindopts) {
02872:                    return vtbl.SetBindOptions(this , pbindopts);
02873:                }
02874:
02875:                public final int GetBindOptions(BIND_OPTS pbindopts) {
02876:                    return vtbl.GetBindOptions(this , pbindopts);
02877:                }
02878:
02879:                public final int GetRunningObjectTable(PointerPointer pprot) {
02880:                    return vtbl.GetRunningObjectTable(this , pprot);
02881:                }
02882:
02883:                public final int RegisterObjectParam(Int16Pointer pszKey,
02884:                        IUnknown punk) {
02885:                    return vtbl.RegisterObjectParam(this , pszKey, punk);
02886:                }
02887:
02888:                public final int GetObjectParam(Int16Pointer pszKey,
02889:                        PointerPointer ppunk) {
02890:                    return vtbl.GetObjectParam(this , pszKey, ppunk);
02891:                }
02892:
02893:                public final int EnumObjectParam(PointerPointer ppenum) {
02894:                    return vtbl.EnumObjectParam(this , ppenum);
02895:                }
02896:
02897:                public final int RevokeObjectParam(Int16Pointer pszKey) {
02898:                    return vtbl.RevokeObjectParam(this , pszKey);
02899:                }
02900:
02901:                @Override
02902:                public int size() {
02903:                    return sizeof;
02904:                }
02905:            }
02906:
02907:            public final IBindCtx createIBindCtx(long addr) {
02908:                return new IBindCtx(addr);
02909:            }
02910:
02911:            public static class IShellFolderVtbl extends CommonStructWrapper {
02912:
02913:                public static final int sizeof = NativeBridge.is64 ? 104 : 52;
02914:
02915:                IShellFolderVtbl(boolean direct) {
02916:                    super (sizeof, direct);
02917:                }
02918:
02919:                IShellFolderVtbl(VoidPointer base) {
02920:                    super (base);
02921:                }
02922:
02923:                IShellFolderVtbl(long addr) {
02924:                    super (addr);
02925:                }
02926:
02927:                public final void set_QueryInterface(long val) {
02928:                    byteBase.setAddress(0, val);
02929:                }
02930:
02931:                public final long get_QueryInterface() {
02932:                    return byteBase.getAddress(0);
02933:                }
02934:
02935:                public final int QueryInterface(Win32.IShellFolder This,
02936:                        Win32.GUID riid, PointerPointer ppvObject) {
02937:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
02938:                    long tmp_1 = riid == null ? 0 : riid.longLockPointer();
02939:                    long tmp_2 = ppvObject == null ? 0 : ppvObject
02940:                            .longLockPointer();
02941:                    int tmp_ret = instance.proxycall1(get_QueryInterface(),
02942:                            tmp_0, tmp_1, tmp_2);
02943:                    if (This != null) {
02944:                        This.unlock();
02945:                    }
02946:                    if (riid != null) {
02947:                        riid.unlock();
02948:                    }
02949:                    if (ppvObject != null) {
02950:                        ppvObject.unlock();
02951:                    }
02952:                    return tmp_ret;
02953:                }
02954:
02955:                public final void set_AddRef(long val) {
02956:                    byteBase.setAddress(NativeBridge.is64 ? 8 : 4, val);
02957:                }
02958:
02959:                public final long get_AddRef() {
02960:                    return byteBase.getAddress(NativeBridge.is64 ? 8 : 4);
02961:                }
02962:
02963:                public final int AddRef(Win32.IShellFolder This) {
02964:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
02965:                    int tmp_ret = instance.proxycall2(get_AddRef(), tmp_0);
02966:                    if (This != null) {
02967:                        This.unlock();
02968:                    }
02969:                    return tmp_ret;
02970:                }
02971:
02972:                public final void set_Release(long val) {
02973:                    byteBase.setAddress(NativeBridge.is64 ? 16 : 8, val);
02974:                }
02975:
02976:                public final long get_Release() {
02977:                    return byteBase.getAddress(NativeBridge.is64 ? 16 : 8);
02978:                }
02979:
02980:                public final int Release(Win32.IShellFolder This) {
02981:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
02982:                    int tmp_ret = instance.proxycall3(get_Release(), tmp_0);
02983:                    if (This != null) {
02984:                        This.unlock();
02985:                    }
02986:                    return tmp_ret;
02987:                }
02988:
02989:                public final void set_ParseDisplayName(long val) {
02990:                    byteBase.setAddress(NativeBridge.is64 ? 24 : 12, val);
02991:                }
02992:
02993:                public final long get_ParseDisplayName() {
02994:                    return byteBase.getAddress(NativeBridge.is64 ? 24 : 12);
02995:                }
02996:
02997:                public final int ParseDisplayName(Win32.IShellFolder This,
02998:                        long hwnd, Win32.IBindCtx pbc,
02999:                        Int16Pointer pszDisplayName, Int32Pointer pchEaten,
03000:                        PointerPointer ppidl, Int32Pointer pdwAttributes) {
03001:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03002:                    long tmp_1 = pbc == null ? 0 : pbc.longLockPointer();
03003:                    long tmp_2 = pszDisplayName == null ? 0 : pszDisplayName
03004:                            .longLockPointer();
03005:                    long tmp_3 = pchEaten == null ? 0 : pchEaten
03006:                            .longLockPointer();
03007:                    long tmp_4 = ppidl == null ? 0 : ppidl.longLockPointer();
03008:                    long tmp_5 = pdwAttributes == null ? 0 : pdwAttributes
03009:                            .longLockPointer();
03010:                    int tmp_ret = instance.proxycall4(get_ParseDisplayName(),
03011:                            tmp_0, hwnd, tmp_1, tmp_2, tmp_3, tmp_4, tmp_5);
03012:                    if (This != null) {
03013:                        This.unlock();
03014:                    }
03015:                    if (pbc != null) {
03016:                        pbc.unlock();
03017:                    }
03018:                    if (pszDisplayName != null) {
03019:                        pszDisplayName.unlock();
03020:                    }
03021:                    if (pchEaten != null) {
03022:                        pchEaten.unlock();
03023:                    }
03024:                    if (ppidl != null) {
03025:                        ppidl.unlock();
03026:                    }
03027:                    if (pdwAttributes != null) {
03028:                        pdwAttributes.unlock();
03029:                    }
03030:                    return tmp_ret;
03031:                }
03032:
03033:                public final void set_EnumObjects(long val) {
03034:                    byteBase.setAddress(NativeBridge.is64 ? 32 : 16, val);
03035:                }
03036:
03037:                public final long get_EnumObjects() {
03038:                    return byteBase.getAddress(NativeBridge.is64 ? 32 : 16);
03039:                }
03040:
03041:                public final int EnumObjects(Win32.IShellFolder This,
03042:                        long hwnd, int grfFlags, PointerPointer ppenumIDList) {
03043:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03044:                    long tmp_1 = ppenumIDList == null ? 0 : ppenumIDList
03045:                            .longLockPointer();
03046:                    int tmp_ret = instance.proxycall5(get_EnumObjects(), tmp_0,
03047:                            hwnd, grfFlags, tmp_1);
03048:                    if (This != null) {
03049:                        This.unlock();
03050:                    }
03051:                    if (ppenumIDList != null) {
03052:                        ppenumIDList.unlock();
03053:                    }
03054:                    return tmp_ret;
03055:                }
03056:
03057:                public final void set_BindToObject(long val) {
03058:                    byteBase.setAddress(NativeBridge.is64 ? 40 : 20, val);
03059:                }
03060:
03061:                public final long get_BindToObject() {
03062:                    return byteBase.getAddress(NativeBridge.is64 ? 40 : 20);
03063:                }
03064:
03065:                public final int BindToObject(Win32.IShellFolder This,
03066:                        Win32.ITEMIDLIST pidl, Win32.IBindCtx pbc,
03067:                        Win32.GUID riid, PointerPointer ppv) {
03068:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03069:                    long tmp_1 = pidl == null ? 0 : pidl.longLockPointer();
03070:                    long tmp_2 = pbc == null ? 0 : pbc.longLockPointer();
03071:                    long tmp_3 = riid == null ? 0 : riid.longLockPointer();
03072:                    long tmp_4 = ppv == null ? 0 : ppv.longLockPointer();
03073:                    int tmp_ret = instance.proxycall6(get_BindToObject(),
03074:                            tmp_0, tmp_1, tmp_2, tmp_3, tmp_4);
03075:                    if (This != null) {
03076:                        This.unlock();
03077:                    }
03078:                    if (pidl != null) {
03079:                        pidl.unlock();
03080:                    }
03081:                    if (pbc != null) {
03082:                        pbc.unlock();
03083:                    }
03084:                    if (riid != null) {
03085:                        riid.unlock();
03086:                    }
03087:                    if (ppv != null) {
03088:                        ppv.unlock();
03089:                    }
03090:                    return tmp_ret;
03091:                }
03092:
03093:                public final void set_BindToStorage(long val) {
03094:                    byteBase.setAddress(NativeBridge.is64 ? 48 : 24, val);
03095:                }
03096:
03097:                public final long get_BindToStorage() {
03098:                    return byteBase.getAddress(NativeBridge.is64 ? 48 : 24);
03099:                }
03100:
03101:                public final int BindToStorage(Win32.IShellFolder This,
03102:                        Win32.ITEMIDLIST pidl, Win32.IBindCtx pbc,
03103:                        Win32.GUID riid, PointerPointer ppv) {
03104:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03105:                    long tmp_1 = pidl == null ? 0 : pidl.longLockPointer();
03106:                    long tmp_2 = pbc == null ? 0 : pbc.longLockPointer();
03107:                    long tmp_3 = riid == null ? 0 : riid.longLockPointer();
03108:                    long tmp_4 = ppv == null ? 0 : ppv.longLockPointer();
03109:                    int tmp_ret = instance.proxycall7(get_BindToStorage(),
03110:                            tmp_0, tmp_1, tmp_2, tmp_3, tmp_4);
03111:                    if (This != null) {
03112:                        This.unlock();
03113:                    }
03114:                    if (pidl != null) {
03115:                        pidl.unlock();
03116:                    }
03117:                    if (pbc != null) {
03118:                        pbc.unlock();
03119:                    }
03120:                    if (riid != null) {
03121:                        riid.unlock();
03122:                    }
03123:                    if (ppv != null) {
03124:                        ppv.unlock();
03125:                    }
03126:                    return tmp_ret;
03127:                }
03128:
03129:                public final void set_CompareIDs(long val) {
03130:                    byteBase.setAddress(NativeBridge.is64 ? 56 : 28, val);
03131:                }
03132:
03133:                public final long get_CompareIDs() {
03134:                    return byteBase.getAddress(NativeBridge.is64 ? 56 : 28);
03135:                }
03136:
03137:                public final int CompareIDs(Win32.IShellFolder This,
03138:                        long lParam, Win32.ITEMIDLIST pidl1,
03139:                        Win32.ITEMIDLIST pidl2) {
03140:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03141:                    long tmp_1 = pidl1 == null ? 0 : pidl1.longLockPointer();
03142:                    long tmp_2 = pidl2 == null ? 0 : pidl2.longLockPointer();
03143:                    int tmp_ret = instance.proxycall8(get_CompareIDs(), tmp_0,
03144:                            lParam, tmp_1, tmp_2);
03145:                    if (This != null) {
03146:                        This.unlock();
03147:                    }
03148:                    if (pidl1 != null) {
03149:                        pidl1.unlock();
03150:                    }
03151:                    if (pidl2 != null) {
03152:                        pidl2.unlock();
03153:                    }
03154:                    return tmp_ret;
03155:                }
03156:
03157:                public final void set_CreateViewObject(long val) {
03158:                    byteBase.setAddress(NativeBridge.is64 ? 64 : 32, val);
03159:                }
03160:
03161:                public final long get_CreateViewObject() {
03162:                    return byteBase.getAddress(NativeBridge.is64 ? 64 : 32);
03163:                }
03164:
03165:                public final int CreateViewObject(Win32.IShellFolder This,
03166:                        long hwndOwner, Win32.GUID riid, PointerPointer ppv) {
03167:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03168:                    long tmp_1 = riid == null ? 0 : riid.longLockPointer();
03169:                    long tmp_2 = ppv == null ? 0 : ppv.longLockPointer();
03170:                    int tmp_ret = instance.proxycall9(get_CreateViewObject(),
03171:                            tmp_0, hwndOwner, tmp_1, tmp_2);
03172:                    if (This != null) {
03173:                        This.unlock();
03174:                    }
03175:                    if (riid != null) {
03176:                        riid.unlock();
03177:                    }
03178:                    if (ppv != null) {
03179:                        ppv.unlock();
03180:                    }
03181:                    return tmp_ret;
03182:                }
03183:
03184:                public final void set_GetAttributesOf(long val) {
03185:                    byteBase.setAddress(NativeBridge.is64 ? 72 : 36, val);
03186:                }
03187:
03188:                public final long get_GetAttributesOf() {
03189:                    return byteBase.getAddress(NativeBridge.is64 ? 72 : 36);
03190:                }
03191:
03192:                public final int GetAttributesOf(Win32.IShellFolder This,
03193:                        int cidl, PointerPointer apidl, Int32Pointer rgfInOut) {
03194:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03195:                    long tmp_1 = apidl == null ? 0 : apidl.longLockPointer();
03196:                    long tmp_2 = rgfInOut == null ? 0 : rgfInOut
03197:                            .longLockPointer();
03198:                    int tmp_ret = instance.proxycall10(get_GetAttributesOf(),
03199:                            tmp_0, cidl, tmp_1, tmp_2);
03200:                    if (This != null) {
03201:                        This.unlock();
03202:                    }
03203:                    if (apidl != null) {
03204:                        apidl.unlock();
03205:                    }
03206:                    if (rgfInOut != null) {
03207:                        rgfInOut.unlock();
03208:                    }
03209:                    return tmp_ret;
03210:                }
03211:
03212:                public final void set_GetUIObjectOf(long val) {
03213:                    byteBase.setAddress(NativeBridge.is64 ? 80 : 40, val);
03214:                }
03215:
03216:                public final long get_GetUIObjectOf() {
03217:                    return byteBase.getAddress(NativeBridge.is64 ? 80 : 40);
03218:                }
03219:
03220:                public final int GetUIObjectOf(Win32.IShellFolder This,
03221:                        long hwndOwner, int cidl, PointerPointer apidl,
03222:                        Win32.GUID riid, Int32Pointer rgfReserved,
03223:                        PointerPointer ppv) {
03224:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03225:                    long tmp_1 = apidl == null ? 0 : apidl.longLockPointer();
03226:                    long tmp_2 = riid == null ? 0 : riid.longLockPointer();
03227:                    long tmp_3 = rgfReserved == null ? 0 : rgfReserved
03228:                            .longLockPointer();
03229:                    long tmp_4 = ppv == null ? 0 : ppv.longLockPointer();
03230:                    int tmp_ret = instance.proxycall11(get_GetUIObjectOf(),
03231:                            tmp_0, hwndOwner, cidl, tmp_1, tmp_2, tmp_3, tmp_4);
03232:                    if (This != null) {
03233:                        This.unlock();
03234:                    }
03235:                    if (apidl != null) {
03236:                        apidl.unlock();
03237:                    }
03238:                    if (riid != null) {
03239:                        riid.unlock();
03240:                    }
03241:                    if (rgfReserved != null) {
03242:                        rgfReserved.unlock();
03243:                    }
03244:                    if (ppv != null) {
03245:                        ppv.unlock();
03246:                    }
03247:                    return tmp_ret;
03248:                }
03249:
03250:                public final void set_GetDisplayNameOf(long val) {
03251:                    byteBase.setAddress(NativeBridge.is64 ? 88 : 44, val);
03252:                }
03253:
03254:                public final long get_GetDisplayNameOf() {
03255:                    return byteBase.getAddress(NativeBridge.is64 ? 88 : 44);
03256:                }
03257:
03258:                public final int GetDisplayNameOf(Win32.IShellFolder This,
03259:                        Win32.ITEMIDLIST pidl, int uFlags, Win32.STRRET pName) {
03260:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03261:                    long tmp_1 = pidl == null ? 0 : pidl.longLockPointer();
03262:                    long tmp_2 = pName == null ? 0 : pName.longLockPointer();
03263:                    int tmp_ret = instance.proxycall12(get_GetDisplayNameOf(),
03264:                            tmp_0, tmp_1, uFlags, tmp_2);
03265:                    if (This != null) {
03266:                        This.unlock();
03267:                    }
03268:                    if (pidl != null) {
03269:                        pidl.unlock();
03270:                    }
03271:                    if (pName != null) {
03272:                        pName.unlock();
03273:                    }
03274:                    return tmp_ret;
03275:                }
03276:
03277:                public final void set_SetNameOf(long val) {
03278:                    byteBase.setAddress(NativeBridge.is64 ? 96 : 48, val);
03279:                }
03280:
03281:                public final long get_SetNameOf() {
03282:                    return byteBase.getAddress(NativeBridge.is64 ? 96 : 48);
03283:                }
03284:
03285:                public final int SetNameOf(Win32.IShellFolder This, long hwnd,
03286:                        Win32.ITEMIDLIST pidl, String pszName, int uFlags,
03287:                        PointerPointer ppidlOut) {
03288:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03289:                    long tmp_1 = pidl == null ? 0 : pidl.longLockPointer();
03290:                    Int16Pointer _pszName = null == pszName ? null : nb
03291:                            .createInt16Pointer(pszName, false);
03292:                    long tmp_2 = _pszName == null ? 0 : _pszName
03293:                            .longLockPointer();
03294:                    long tmp_3 = ppidlOut == null ? 0 : ppidlOut
03295:                            .longLockPointer();
03296:                    int tmp_ret = instance.proxycall13(get_SetNameOf(), tmp_0,
03297:                            hwnd, tmp_1, tmp_2, uFlags, tmp_3);
03298:                    if (This != null) {
03299:                        This.unlock();
03300:                    }
03301:                    if (pidl != null) {
03302:                        pidl.unlock();
03303:                    }
03304:                    if (_pszName != null) {
03305:                        _pszName.unlock();
03306:                        _pszName.free();
03307:                    }
03308:                    if (ppidlOut != null) {
03309:                        ppidlOut.unlock();
03310:                    }
03311:                    return tmp_ret;
03312:                }
03313:
03314:                public final int SetNameOf(Win32.IShellFolder This, long hwnd,
03315:                        Win32.ITEMIDLIST pidl, Int16Pointer pszName,
03316:                        int uFlags, PointerPointer ppidlOut) {
03317:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03318:                    long tmp_1 = pidl == null ? 0 : pidl.longLockPointer();
03319:                    long tmp_2 = pszName == null ? 0 : pszName
03320:                            .longLockPointer();
03321:                    long tmp_3 = ppidlOut == null ? 0 : ppidlOut
03322:                            .longLockPointer();
03323:                    int tmp_ret = instance.proxycall13(get_SetNameOf(), tmp_0,
03324:                            hwnd, tmp_1, tmp_2, uFlags, tmp_3);
03325:                    if (This != null) {
03326:                        This.unlock();
03327:                    }
03328:                    if (pidl != null) {
03329:                        pidl.unlock();
03330:                    }
03331:                    if (pszName != null) {
03332:                        pszName.unlock();
03333:                    }
03334:                    if (ppidlOut != null) {
03335:                        ppidlOut.unlock();
03336:                    }
03337:                    return tmp_ret;
03338:                }
03339:
03340:                @Override
03341:                public int size() {
03342:                    return sizeof;
03343:                }
03344:            }
03345:
03346:            public final IShellFolderVtbl createIShellFolderVtbl(boolean direct) {
03347:                return new IShellFolderVtbl(direct);
03348:            }
03349:
03350:            public final IShellFolderVtbl createIShellFolderVtbl(
03351:                    VoidPointer base) {
03352:                return new IShellFolderVtbl(base);
03353:            }
03354:
03355:            public final IShellFolderVtbl createIShellFolderVtbl(long addr) {
03356:                return new IShellFolderVtbl(addr);
03357:            }
03358:
03359:            public static class IUnknown extends CommonStructWrapper {
03360:
03361:                public static final int sizeof = NativeBridge.is64 ? 8 : 4;
03362:
03363:                IUnknownVtbl vtbl;
03364:
03365:                IUnknown(long addr) {
03366:                    super (addr);
03367:                    vtbl = get_lpVtbl();
03368:                }
03369:
03370:                public final IUnknownVtbl get_lpVtbl() {
03371:                    return instance.createIUnknownVtbl(byteBase.getAddress(0));
03372:                }
03373:
03374:                public final int QueryInterface(Win32.GUID riid,
03375:                        PointerPointer ppvObject) {
03376:                    return vtbl.QueryInterface(this , riid, ppvObject);
03377:                }
03378:
03379:                public final int AddRef() {
03380:                    return vtbl.AddRef(this );
03381:                }
03382:
03383:                public final int Release() {
03384:                    return vtbl.Release(this );
03385:                }
03386:
03387:                @Override
03388:                public int size() {
03389:                    return sizeof;
03390:                }
03391:            }
03392:
03393:            public final IUnknown createIUnknown(long addr) {
03394:                return new IUnknown(addr);
03395:            }
03396:
03397:            public static class BIND_OPTS extends CommonStructWrapper {
03398:
03399:                public static final int sizeof = 16;
03400:
03401:                BIND_OPTS(boolean direct) {
03402:                    super (sizeof, direct);
03403:                }
03404:
03405:                BIND_OPTS(VoidPointer base) {
03406:                    super (base);
03407:                }
03408:
03409:                BIND_OPTS(long addr) {
03410:                    super (addr);
03411:                }
03412:
03413:                public final void set_cbStruct(int val) {
03414:                    byteBase.setInt32(0, val);
03415:                }
03416:
03417:                public final int get_cbStruct() {
03418:                    return byteBase.getInt32(0);
03419:                }
03420:
03421:                public final void set_grfFlags(int val) {
03422:                    byteBase.setInt32(4, val);
03423:                }
03424:
03425:                public final int get_grfFlags() {
03426:                    return byteBase.getInt32(4);
03427:                }
03428:
03429:                public final void set_grfMode(int val) {
03430:                    byteBase.setInt32(8, val);
03431:                }
03432:
03433:                public final int get_grfMode() {
03434:                    return byteBase.getInt32(8);
03435:                }
03436:
03437:                public final void set_dwTickCountDeadline(int val) {
03438:                    byteBase.setInt32(12, val);
03439:                }
03440:
03441:                public final int get_dwTickCountDeadline() {
03442:                    return byteBase.getInt32(12);
03443:                }
03444:
03445:                @Override
03446:                public int size() {
03447:                    return sizeof;
03448:                }
03449:            }
03450:
03451:            public final BIND_OPTS createBIND_OPTS(boolean direct) {
03452:                return new BIND_OPTS(direct);
03453:            }
03454:
03455:            public final BIND_OPTS createBIND_OPTS(VoidPointer base) {
03456:                return new BIND_OPTS(base);
03457:            }
03458:
03459:            public final BIND_OPTS createBIND_OPTS(long addr) {
03460:                return new BIND_OPTS(addr);
03461:            }
03462:
03463:            public static class IBindCtxVtbl extends CommonStructWrapper {
03464:
03465:                public static final int sizeof = NativeBridge.is64 ? 104 : 52;
03466:
03467:                IBindCtxVtbl(boolean direct) {
03468:                    super (sizeof, direct);
03469:                }
03470:
03471:                IBindCtxVtbl(VoidPointer base) {
03472:                    super (base);
03473:                }
03474:
03475:                IBindCtxVtbl(long addr) {
03476:                    super (addr);
03477:                }
03478:
03479:                public final void set_QueryInterface(long val) {
03480:                    byteBase.setAddress(0, val);
03481:                }
03482:
03483:                public final long get_QueryInterface() {
03484:                    return byteBase.getAddress(0);
03485:                }
03486:
03487:                public final int QueryInterface(Win32.IBindCtx This,
03488:                        Win32.GUID riid, PointerPointer ppvObject) {
03489:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03490:                    long tmp_1 = riid == null ? 0 : riid.longLockPointer();
03491:                    long tmp_2 = ppvObject == null ? 0 : ppvObject
03492:                            .longLockPointer();
03493:                    int tmp_ret = instance.proxycall14(get_QueryInterface(),
03494:                            tmp_0, tmp_1, tmp_2);
03495:                    if (This != null) {
03496:                        This.unlock();
03497:                    }
03498:                    if (riid != null) {
03499:                        riid.unlock();
03500:                    }
03501:                    if (ppvObject != null) {
03502:                        ppvObject.unlock();
03503:                    }
03504:                    return tmp_ret;
03505:                }
03506:
03507:                public final void set_AddRef(long val) {
03508:                    byteBase.setAddress(NativeBridge.is64 ? 8 : 4, val);
03509:                }
03510:
03511:                public final long get_AddRef() {
03512:                    return byteBase.getAddress(NativeBridge.is64 ? 8 : 4);
03513:                }
03514:
03515:                public final int AddRef(Win32.IBindCtx This) {
03516:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03517:                    int tmp_ret = instance.proxycall15(get_AddRef(), tmp_0);
03518:                    if (This != null) {
03519:                        This.unlock();
03520:                    }
03521:                    return tmp_ret;
03522:                }
03523:
03524:                public final void set_Release(long val) {
03525:                    byteBase.setAddress(NativeBridge.is64 ? 16 : 8, val);
03526:                }
03527:
03528:                public final long get_Release() {
03529:                    return byteBase.getAddress(NativeBridge.is64 ? 16 : 8);
03530:                }
03531:
03532:                public final int Release(Win32.IBindCtx This) {
03533:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03534:                    int tmp_ret = instance.proxycall16(get_Release(), tmp_0);
03535:                    if (This != null) {
03536:                        This.unlock();
03537:                    }
03538:                    return tmp_ret;
03539:                }
03540:
03541:                public final void set_RegisterObjectBound(long val) {
03542:                    byteBase.setAddress(NativeBridge.is64 ? 24 : 12, val);
03543:                }
03544:
03545:                public final long get_RegisterObjectBound() {
03546:                    return byteBase.getAddress(NativeBridge.is64 ? 24 : 12);
03547:                }
03548:
03549:                public final int RegisterObjectBound(Win32.IBindCtx This,
03550:                        Win32.IUnknown punk) {
03551:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03552:                    long tmp_1 = punk == null ? 0 : punk.longLockPointer();
03553:                    int tmp_ret = instance.proxycall17(
03554:                            get_RegisterObjectBound(), tmp_0, tmp_1);
03555:                    if (This != null) {
03556:                        This.unlock();
03557:                    }
03558:                    if (punk != null) {
03559:                        punk.unlock();
03560:                    }
03561:                    return tmp_ret;
03562:                }
03563:
03564:                public final void set_RevokeObjectBound(long val) {
03565:                    byteBase.setAddress(NativeBridge.is64 ? 32 : 16, val);
03566:                }
03567:
03568:                public final long get_RevokeObjectBound() {
03569:                    return byteBase.getAddress(NativeBridge.is64 ? 32 : 16);
03570:                }
03571:
03572:                public final int RevokeObjectBound(Win32.IBindCtx This,
03573:                        Win32.IUnknown punk) {
03574:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03575:                    long tmp_1 = punk == null ? 0 : punk.longLockPointer();
03576:                    int tmp_ret = instance.proxycall18(get_RevokeObjectBound(),
03577:                            tmp_0, tmp_1);
03578:                    if (This != null) {
03579:                        This.unlock();
03580:                    }
03581:                    if (punk != null) {
03582:                        punk.unlock();
03583:                    }
03584:                    return tmp_ret;
03585:                }
03586:
03587:                public final void set_ReleaseBoundObjects(long val) {
03588:                    byteBase.setAddress(NativeBridge.is64 ? 40 : 20, val);
03589:                }
03590:
03591:                public final long get_ReleaseBoundObjects() {
03592:                    return byteBase.getAddress(NativeBridge.is64 ? 40 : 20);
03593:                }
03594:
03595:                public final int ReleaseBoundObjects(Win32.IBindCtx This) {
03596:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03597:                    int tmp_ret = instance.proxycall19(
03598:                            get_ReleaseBoundObjects(), tmp_0);
03599:                    if (This != null) {
03600:                        This.unlock();
03601:                    }
03602:                    return tmp_ret;
03603:                }
03604:
03605:                public final void set_SetBindOptions(long val) {
03606:                    byteBase.setAddress(NativeBridge.is64 ? 48 : 24, val);
03607:                }
03608:
03609:                public final long get_SetBindOptions() {
03610:                    return byteBase.getAddress(NativeBridge.is64 ? 48 : 24);
03611:                }
03612:
03613:                public final int SetBindOptions(Win32.IBindCtx This,
03614:                        Win32.BIND_OPTS pbindopts) {
03615:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03616:                    long tmp_1 = pbindopts == null ? 0 : pbindopts
03617:                            .longLockPointer();
03618:                    int tmp_ret = instance.proxycall20(get_SetBindOptions(),
03619:                            tmp_0, tmp_1);
03620:                    if (This != null) {
03621:                        This.unlock();
03622:                    }
03623:                    if (pbindopts != null) {
03624:                        pbindopts.unlock();
03625:                    }
03626:                    return tmp_ret;
03627:                }
03628:
03629:                public final void set_GetBindOptions(long val) {
03630:                    byteBase.setAddress(NativeBridge.is64 ? 56 : 28, val);
03631:                }
03632:
03633:                public final long get_GetBindOptions() {
03634:                    return byteBase.getAddress(NativeBridge.is64 ? 56 : 28);
03635:                }
03636:
03637:                public final int GetBindOptions(Win32.IBindCtx This,
03638:                        Win32.BIND_OPTS pbindopts) {
03639:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03640:                    long tmp_1 = pbindopts == null ? 0 : pbindopts
03641:                            .longLockPointer();
03642:                    int tmp_ret = instance.proxycall21(get_GetBindOptions(),
03643:                            tmp_0, tmp_1);
03644:                    if (This != null) {
03645:                        This.unlock();
03646:                    }
03647:                    if (pbindopts != null) {
03648:                        pbindopts.unlock();
03649:                    }
03650:                    return tmp_ret;
03651:                }
03652:
03653:                public final void set_GetRunningObjectTable(long val) {
03654:                    byteBase.setAddress(NativeBridge.is64 ? 64 : 32, val);
03655:                }
03656:
03657:                public final long get_GetRunningObjectTable() {
03658:                    return byteBase.getAddress(NativeBridge.is64 ? 64 : 32);
03659:                }
03660:
03661:                public final int GetRunningObjectTable(Win32.IBindCtx This,
03662:                        PointerPointer pprot) {
03663:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03664:                    long tmp_1 = pprot == null ? 0 : pprot.longLockPointer();
03665:                    int tmp_ret = instance.proxycall22(
03666:                            get_GetRunningObjectTable(), tmp_0, tmp_1);
03667:                    if (This != null) {
03668:                        This.unlock();
03669:                    }
03670:                    if (pprot != null) {
03671:                        pprot.unlock();
03672:                    }
03673:                    return tmp_ret;
03674:                }
03675:
03676:                public final void set_RegisterObjectParam(long val) {
03677:                    byteBase.setAddress(NativeBridge.is64 ? 72 : 36, val);
03678:                }
03679:
03680:                public final long get_RegisterObjectParam() {
03681:                    return byteBase.getAddress(NativeBridge.is64 ? 72 : 36);
03682:                }
03683:
03684:                public final int RegisterObjectParam(Win32.IBindCtx This,
03685:                        Int16Pointer pszKey, Win32.IUnknown punk) {
03686:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03687:                    long tmp_1 = pszKey == null ? 0 : pszKey.longLockPointer();
03688:                    long tmp_2 = punk == null ? 0 : punk.longLockPointer();
03689:                    int tmp_ret = instance.proxycall23(
03690:                            get_RegisterObjectParam(), tmp_0, tmp_1, tmp_2);
03691:                    if (This != null) {
03692:                        This.unlock();
03693:                    }
03694:                    if (pszKey != null) {
03695:                        pszKey.unlock();
03696:                    }
03697:                    if (punk != null) {
03698:                        punk.unlock();
03699:                    }
03700:                    return tmp_ret;
03701:                }
03702:
03703:                public final void set_GetObjectParam(long val) {
03704:                    byteBase.setAddress(NativeBridge.is64 ? 80 : 40, val);
03705:                }
03706:
03707:                public final long get_GetObjectParam() {
03708:                    return byteBase.getAddress(NativeBridge.is64 ? 80 : 40);
03709:                }
03710:
03711:                public final int GetObjectParam(Win32.IBindCtx This,
03712:                        Int16Pointer pszKey, PointerPointer ppunk) {
03713:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03714:                    long tmp_1 = pszKey == null ? 0 : pszKey.longLockPointer();
03715:                    long tmp_2 = ppunk == null ? 0 : ppunk.longLockPointer();
03716:                    int tmp_ret = instance.proxycall24(get_GetObjectParam(),
03717:                            tmp_0, tmp_1, tmp_2);
03718:                    if (This != null) {
03719:                        This.unlock();
03720:                    }
03721:                    if (pszKey != null) {
03722:                        pszKey.unlock();
03723:                    }
03724:                    if (ppunk != null) {
03725:                        ppunk.unlock();
03726:                    }
03727:                    return tmp_ret;
03728:                }
03729:
03730:                public final void set_EnumObjectParam(long val) {
03731:                    byteBase.setAddress(NativeBridge.is64 ? 88 : 44, val);
03732:                }
03733:
03734:                public final long get_EnumObjectParam() {
03735:                    return byteBase.getAddress(NativeBridge.is64 ? 88 : 44);
03736:                }
03737:
03738:                public final int EnumObjectParam(Win32.IBindCtx This,
03739:                        PointerPointer ppenum) {
03740:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03741:                    long tmp_1 = ppenum == null ? 0 : ppenum.longLockPointer();
03742:                    int tmp_ret = instance.proxycall25(get_EnumObjectParam(),
03743:                            tmp_0, tmp_1);
03744:                    if (This != null) {
03745:                        This.unlock();
03746:                    }
03747:                    if (ppenum != null) {
03748:                        ppenum.unlock();
03749:                    }
03750:                    return tmp_ret;
03751:                }
03752:
03753:                public final void set_RevokeObjectParam(long val) {
03754:                    byteBase.setAddress(NativeBridge.is64 ? 96 : 48, val);
03755:                }
03756:
03757:                public final long get_RevokeObjectParam() {
03758:                    return byteBase.getAddress(NativeBridge.is64 ? 96 : 48);
03759:                }
03760:
03761:                public final int RevokeObjectParam(Win32.IBindCtx This,
03762:                        Int16Pointer pszKey) {
03763:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03764:                    long tmp_1 = pszKey == null ? 0 : pszKey.longLockPointer();
03765:                    int tmp_ret = instance.proxycall26(get_RevokeObjectParam(),
03766:                            tmp_0, tmp_1);
03767:                    if (This != null) {
03768:                        This.unlock();
03769:                    }
03770:                    if (pszKey != null) {
03771:                        pszKey.unlock();
03772:                    }
03773:                    return tmp_ret;
03774:                }
03775:
03776:                @Override
03777:                public int size() {
03778:                    return sizeof;
03779:                }
03780:            }
03781:
03782:            public final IBindCtxVtbl createIBindCtxVtbl(boolean direct) {
03783:                return new IBindCtxVtbl(direct);
03784:            }
03785:
03786:            public final IBindCtxVtbl createIBindCtxVtbl(VoidPointer base) {
03787:                return new IBindCtxVtbl(base);
03788:            }
03789:
03790:            public final IBindCtxVtbl createIBindCtxVtbl(long addr) {
03791:                return new IBindCtxVtbl(addr);
03792:            }
03793:
03794:            public static class IUnknownVtbl extends CommonStructWrapper {
03795:
03796:                public static final int sizeof = NativeBridge.is64 ? 24 : 12;
03797:
03798:                IUnknownVtbl(boolean direct) {
03799:                    super (sizeof, direct);
03800:                }
03801:
03802:                IUnknownVtbl(VoidPointer base) {
03803:                    super (base);
03804:                }
03805:
03806:                IUnknownVtbl(long addr) {
03807:                    super (addr);
03808:                }
03809:
03810:                public final void set_QueryInterface(long val) {
03811:                    byteBase.setAddress(0, val);
03812:                }
03813:
03814:                public final long get_QueryInterface() {
03815:                    return byteBase.getAddress(0);
03816:                }
03817:
03818:                public final int QueryInterface(Win32.IUnknown This,
03819:                        Win32.GUID riid, PointerPointer ppvObject) {
03820:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03821:                    long tmp_1 = riid == null ? 0 : riid.longLockPointer();
03822:                    long tmp_2 = ppvObject == null ? 0 : ppvObject
03823:                            .longLockPointer();
03824:                    int tmp_ret = instance.proxycall27(get_QueryInterface(),
03825:                            tmp_0, tmp_1, tmp_2);
03826:                    if (This != null) {
03827:                        This.unlock();
03828:                    }
03829:                    if (riid != null) {
03830:                        riid.unlock();
03831:                    }
03832:                    if (ppvObject != null) {
03833:                        ppvObject.unlock();
03834:                    }
03835:                    return tmp_ret;
03836:                }
03837:
03838:                public final void set_AddRef(long val) {
03839:                    byteBase.setAddress(NativeBridge.is64 ? 8 : 4, val);
03840:                }
03841:
03842:                public final long get_AddRef() {
03843:                    return byteBase.getAddress(NativeBridge.is64 ? 8 : 4);
03844:                }
03845:
03846:                public final int AddRef(Win32.IUnknown This) {
03847:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03848:                    int tmp_ret = instance.proxycall28(get_AddRef(), tmp_0);
03849:                    if (This != null) {
03850:                        This.unlock();
03851:                    }
03852:                    return tmp_ret;
03853:                }
03854:
03855:                public final void set_Release(long val) {
03856:                    byteBase.setAddress(NativeBridge.is64 ? 16 : 8, val);
03857:                }
03858:
03859:                public final long get_Release() {
03860:                    return byteBase.getAddress(NativeBridge.is64 ? 16 : 8);
03861:                }
03862:
03863:                public final int Release(Win32.IUnknown This) {
03864:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
03865:                    int tmp_ret = instance.proxycall29(get_Release(), tmp_0);
03866:                    if (This != null) {
03867:                        This.unlock();
03868:                    }
03869:                    return tmp_ret;
03870:                }
03871:
03872:                @Override
03873:                public int size() {
03874:                    return sizeof;
03875:                }
03876:            }
03877:
03878:            public final IUnknownVtbl createIUnknownVtbl(boolean direct) {
03879:                return new IUnknownVtbl(direct);
03880:            }
03881:
03882:            public final IUnknownVtbl createIUnknownVtbl(VoidPointer base) {
03883:                return new IUnknownVtbl(base);
03884:            }
03885:
03886:            public final IUnknownVtbl createIUnknownVtbl(long addr) {
03887:                return new IUnknownVtbl(addr);
03888:            }
03889:
03890:            final native int proxycall1(long fnptr, long This, long riid,
03891:                    long ppvObject);
03892:
03893:            final native int proxycall2(long fnptr, long This);
03894:
03895:            final native int proxycall3(long fnptr, long This);
03896:
03897:            final native int proxycall4(long fnptr, long This, long hwnd,
03898:                    long pbc, long pszDisplayName, long pchEaten, long ppidl,
03899:                    long pdwAttributes);
03900:
03901:            final native int proxycall5(long fnptr, long This, long hwnd,
03902:                    int grfFlags, long ppenumIDList);
03903:
03904:            final native int proxycall6(long fnptr, long This, long pidl,
03905:                    long pbc, long riid, long ppv);
03906:
03907:            final native int proxycall7(long fnptr, long This, long pidl,
03908:                    long pbc, long riid, long ppv);
03909:
03910:            final native int proxycall8(long fnptr, long This, long lParam,
03911:                    long pidl1, long pidl2);
03912:
03913:            final native int proxycall9(long fnptr, long This, long hwndOwner,
03914:                    long riid, long ppv);
03915:
03916:            final native int proxycall10(long fnptr, long This, int cidl,
03917:                    long apidl, long rgfInOut);
03918:
03919:            final native int proxycall11(long fnptr, long This, long hwndOwner,
03920:                    int cidl, long apidl, long riid, long rgfReserved, long ppv);
03921:
03922:            final native int proxycall12(long fnptr, long This, long pidl,
03923:                    int uFlags, long pName);
03924:
03925:            final native int proxycall13(long fnptr, long This, long hwnd,
03926:                    long pidl, long pszName, int uFlags, long ppidlOut);
03927:
03928:            final native int proxycall14(long fnptr, long This, long riid,
03929:                    long ppvObject);
03930:
03931:            final native int proxycall15(long fnptr, long This);
03932:
03933:            final native int proxycall16(long fnptr, long This);
03934:
03935:            final native int proxycall17(long fnptr, long This, long punk);
03936:
03937:            final native int proxycall18(long fnptr, long This, long punk);
03938:
03939:            final native int proxycall19(long fnptr, long This);
03940:
03941:            final native int proxycall20(long fnptr, long This, long pbindopts);
03942:
03943:            final native int proxycall21(long fnptr, long This, long pbindopts);
03944:
03945:            final native int proxycall22(long fnptr, long This, long pprot);
03946:
03947:            final native int proxycall23(long fnptr, long This, long pszKey,
03948:                    long punk);
03949:
03950:            final native int proxycall24(long fnptr, long This, long pszKey,
03951:                    long ppunk);
03952:
03953:            final native int proxycall25(long fnptr, long This, long ppenum);
03954:
03955:            final native int proxycall26(long fnptr, long This, long pszKey);
03956:
03957:            final native int proxycall27(long fnptr, long This, long riid,
03958:                    long ppvObject);
03959:
03960:            final native int proxycall28(long fnptr, long This);
03961:
03962:            final native int proxycall29(long fnptr, long This);
03963:
03964:            public final int ScreenToClient(long hWnd, Win32.POINT lpPoint) {
03965:                long tmp_0 = lpPoint == null ? 0 : lpPoint.longLockPointer();
03966:                int tmp_ret = ScreenToClient(hWnd, tmp_0);
03967:                if (lpPoint != null) {
03968:                    lpPoint.unlock();
03969:                }
03970:                return tmp_ret;
03971:            }
03972:
03973:            public final native int ScreenToClient(long hWnd, long lpPoint);
03974:
03975:            public final native long GetParent(long hWnd);
03976:
03977:            public final native long SetFocus(long hWnd);
03978:
03979:            public final int DescribePixelFormat(long param_0, int param_1,
03980:                    int param_2, Win32.PIXELFORMATDESCRIPTOR param_3) {
03981:                long tmp_0 = param_3 == null ? 0 : param_3.longLockPointer();
03982:                int tmp_ret = DescribePixelFormat(param_0, param_1, param_2,
03983:                        tmp_0);
03984:                if (param_3 != null) {
03985:                    param_3.unlock();
03986:                }
03987:                return tmp_ret;
03988:            }
03989:
03990:            public final native int DescribePixelFormat(long param_0,
03991:                    int param_1, int param_2, long param_3);
03992:
03993:            public final native int SetTextColor(long param_0, int param_1);
03994:
03995:            public final native long MonitorFromWindow(long hwnd, int dwFlags);
03996:
03997:            public final int GetDIBits(long param_0, long param_1, int param_2,
03998:                    int param_3, VoidPointer param_4, BITMAPINFO param_5,
03999:                    int param_6) {
04000:                long tmp_0 = param_4 == null ? 0 : param_4.longLockPointer();
04001:                long tmp_1 = param_5 == null ? 0 : param_5.longLockPointer();
04002:                int tmp_ret = GetDIBits(param_0, param_1, param_2, param_3,
04003:                        tmp_0, tmp_1, param_6);
04004:                if (param_4 != null) {
04005:                    param_4.unlock();
04006:                }
04007:                if (param_5 != null) {
04008:                    param_5.unlock();
04009:                }
04010:                return tmp_ret;
04011:            }
04012:
04013:            public final native int GetDIBits(long param_0, long param_1,
04014:                    int param_2, int param_3, long param_4, long param_5,
04015:                    int param_6);
04016:
04017:            public static class BITMAPINFO extends CommonStructWrapper {
04018:
04019:                public static final int sizeof = 44;
04020:
04021:                BITMAPINFO(boolean direct) {
04022:                    super (sizeof, direct);
04023:                }
04024:
04025:                BITMAPINFO(VoidPointer base) {
04026:                    super (base);
04027:                }
04028:
04029:                BITMAPINFO(long addr) {
04030:                    super (addr);
04031:                }
04032:
04033:                public final BITMAPINFOHEADER get_bmiHeader() {
04034:                    return instance
04035:                            .createBITMAPINFOHEADER(getElementPointer(0));
04036:                }
04037:
04038:                public final Int8Pointer get_bmiColors() {
04039:                    return nb.createInt8Pointer(getElementPointer(40));
04040:                }
04041:
04042:                @Override
04043:                public int size() {
04044:                    return sizeof;
04045:                }
04046:            }
04047:
04048:            public final BITMAPINFO createBITMAPINFO(boolean direct) {
04049:                return new BITMAPINFO(direct);
04050:            }
04051:
04052:            public final BITMAPINFO createBITMAPINFO(VoidPointer base) {
04053:                return new BITMAPINFO(base);
04054:            }
04055:
04056:            public final BITMAPINFO createBITMAPINFO(long addr) {
04057:                return new BITMAPINFO(addr);
04058:            }
04059:
04060:            public static class BITMAPINFOHEADER extends CommonStructWrapper {
04061:
04062:                public static final int sizeof = 40;
04063:
04064:                BITMAPINFOHEADER(boolean direct) {
04065:                    super (sizeof, direct);
04066:                }
04067:
04068:                BITMAPINFOHEADER(VoidPointer base) {
04069:                    super (base);
04070:                }
04071:
04072:                BITMAPINFOHEADER(long addr) {
04073:                    super (addr);
04074:                }
04075:
04076:                public final void set_biSize(int val) {
04077:                    byteBase.setInt32(0, val);
04078:                }
04079:
04080:                public final int get_biSize() {
04081:                    return byteBase.getInt32(0);
04082:                }
04083:
04084:                public final void set_biWidth(int val) {
04085:                    byteBase.setInt32(4, val);
04086:                }
04087:
04088:                public final int get_biWidth() {
04089:                    return byteBase.getInt32(4);
04090:                }
04091:
04092:                public final void set_biHeight(int val) {
04093:                    byteBase.setInt32(8, val);
04094:                }
04095:
04096:                public final int get_biHeight() {
04097:                    return byteBase.getInt32(8);
04098:                }
04099:
04100:                public final void set_biPlanes(short val) {
04101:                    byteBase.setInt16(12, val);
04102:                }
04103:
04104:                public final short get_biPlanes() {
04105:                    return byteBase.getInt16(12);
04106:                }
04107:
04108:                public final void set_biBitCount(short val) {
04109:                    byteBase.setInt16(14, val);
04110:                }
04111:
04112:                public final short get_biBitCount() {
04113:                    return byteBase.getInt16(14);
04114:                }
04115:
04116:                public final void set_biCompression(int val) {
04117:                    byteBase.setInt32(16, val);
04118:                }
04119:
04120:                public final int get_biCompression() {
04121:                    return byteBase.getInt32(16);
04122:                }
04123:
04124:                public final void set_biSizeImage(int val) {
04125:                    byteBase.setInt32(20, val);
04126:                }
04127:
04128:                public final int get_biSizeImage() {
04129:                    return byteBase.getInt32(20);
04130:                }
04131:
04132:                public final void set_biXPelsPerMeter(int val) {
04133:                    byteBase.setInt32(24, val);
04134:                }
04135:
04136:                public final int get_biXPelsPerMeter() {
04137:                    return byteBase.getInt32(24);
04138:                }
04139:
04140:                public final void set_biYPelsPerMeter(int val) {
04141:                    byteBase.setInt32(28, val);
04142:                }
04143:
04144:                public final int get_biYPelsPerMeter() {
04145:                    return byteBase.getInt32(28);
04146:                }
04147:
04148:                public final void set_biClrUsed(int val) {
04149:                    byteBase.setInt32(32, val);
04150:                }
04151:
04152:                public final int get_biClrUsed() {
04153:                    return byteBase.getInt32(32);
04154:                }
04155:
04156:                public final void set_biClrImportant(int val) {
04157:                    byteBase.setInt32(36, val);
04158:                }
04159:
04160:                public final int get_biClrImportant() {
04161:                    return byteBase.getInt32(36);
04162:                }
04163:
04164:                @Override
04165:                public int size() {
04166:                    return sizeof;
04167:                }
04168:            }
04169:
04170:            public final BITMAPINFOHEADER createBITMAPINFOHEADER(boolean direct) {
04171:                return new BITMAPINFOHEADER(direct);
04172:            }
04173:
04174:            public final BITMAPINFOHEADER createBITMAPINFOHEADER(
04175:                    VoidPointer base) {
04176:                return new BITMAPINFOHEADER(base);
04177:            }
04178:
04179:            public final BITMAPINFOHEADER createBITMAPINFOHEADER(long addr) {
04180:                return new BITMAPINFOHEADER(addr);
04181:            }
04182:
04183:            public final int FormatMessageW(int dwFlags, VoidPointer lpSource,
04184:                    int dwMessageId, int dwLanguageId, Int16Pointer lpBuffer,
04185:                    int nSize, PointerPointer Arguments) {
04186:                long tmp_0 = lpSource == null ? 0 : lpSource.longLockPointer();
04187:                long tmp_1 = lpBuffer == null ? 0 : lpBuffer.longLockPointer();
04188:                long tmp_2 = Arguments == null ? 0 : Arguments
04189:                        .longLockPointer();
04190:                int tmp_ret = FormatMessageW(dwFlags, tmp_0, dwMessageId,
04191:                        dwLanguageId, tmp_1, nSize, tmp_2);
04192:                if (lpSource != null) {
04193:                    lpSource.unlock();
04194:                }
04195:                if (lpBuffer != null) {
04196:                    lpBuffer.unlock();
04197:                }
04198:                if (Arguments != null) {
04199:                    Arguments.unlock();
04200:                }
04201:                return tmp_ret;
04202:            }
04203:
04204:            public final native int FormatMessageW(int dwFlags, long lpSource,
04205:                    int dwMessageId, int dwLanguageId, long lpBuffer,
04206:                    int nSize, long Arguments);
04207:
04208:            public final int SHGetDesktopFolder(PointerPointer ppshf) {
04209:                long tmp_0 = ppshf == null ? 0 : ppshf.longLockPointer();
04210:                int tmp_ret = SHGetDesktopFolder(tmp_0);
04211:                if (ppshf != null) {
04212:                    ppshf.unlock();
04213:                }
04214:                return tmp_ret;
04215:            }
04216:
04217:            public final native int SHGetDesktopFolder(long ppshf);
04218:
04219:            public final int ImmSetCompositionWindow(long param_0,
04220:                    COMPOSITIONFORM param_1) {
04221:                long tmp_0 = param_1 == null ? 0 : param_1.longLockPointer();
04222:                int tmp_ret = ImmSetCompositionWindow(param_0, tmp_0);
04223:                if (param_1 != null) {
04224:                    param_1.unlock();
04225:                }
04226:                return tmp_ret;
04227:            }
04228:
04229:            public final native int ImmSetCompositionWindow(long param_0,
04230:                    long param_1);
04231:
04232:            public static class COMPOSITIONFORM extends CommonStructWrapper {
04233:
04234:                public static final int sizeof = 28;
04235:
04236:                COMPOSITIONFORM(boolean direct) {
04237:                    super (sizeof, direct);
04238:                }
04239:
04240:                COMPOSITIONFORM(VoidPointer base) {
04241:                    super (base);
04242:                }
04243:
04244:                COMPOSITIONFORM(long addr) {
04245:                    super (addr);
04246:                }
04247:
04248:                public final void set_dwStyle(int val) {
04249:                    byteBase.setInt32(0, val);
04250:                }
04251:
04252:                public final int get_dwStyle() {
04253:                    return byteBase.getInt32(0);
04254:                }
04255:
04256:                public final Win32.POINT get_ptCurrentPos() {
04257:                    return Win32.instance.createPOINT(getElementPointer(4));
04258:                }
04259:
04260:                public final Win32.RECT get_rcArea() {
04261:                    return Win32.instance.createRECT(getElementPointer(12));
04262:                }
04263:
04264:                @Override
04265:                public int size() {
04266:                    return sizeof;
04267:                }
04268:            }
04269:
04270:            public final COMPOSITIONFORM createCOMPOSITIONFORM(boolean direct) {
04271:                return new COMPOSITIONFORM(direct);
04272:            }
04273:
04274:            public final COMPOSITIONFORM createCOMPOSITIONFORM(VoidPointer base) {
04275:                return new COMPOSITIONFORM(base);
04276:            }
04277:
04278:            public final COMPOSITIONFORM createCOMPOSITIONFORM(long addr) {
04279:                return new COMPOSITIONFORM(addr);
04280:            }
04281:
04282:            public final int SendInput(int cInputs, INPUT pInputs, int cbSize) {
04283:                long tmp_0 = pInputs == null ? 0 : pInputs.longLockPointer();
04284:                int tmp_ret = SendInput(cInputs, tmp_0, cbSize);
04285:                if (pInputs != null) {
04286:                    pInputs.unlock();
04287:                }
04288:                return tmp_ret;
04289:            }
04290:
04291:            public final native int SendInput(int cInputs, long pInputs,
04292:                    int cbSize);
04293:
04294:            public static class INPUT extends CommonStructWrapper {
04295:
04296:                public static final int sizeof = NativeBridge.is64 ? 40 : 28;
04297:
04298:                INPUT(boolean direct) {
04299:                    super (sizeof, direct);
04300:                }
04301:
04302:                INPUT(VoidPointer base) {
04303:                    super (base);
04304:                }
04305:
04306:                INPUT(long addr) {
04307:                    super (addr);
04308:                }
04309:
04310:                public final void set_type(int val) {
04311:                    byteBase.setInt32(0, val);
04312:                }
04313:
04314:                public final int get_type() {
04315:                    return byteBase.getInt32(0);
04316:                }
04317:
04318:                public final MOUSEINPUT get_mi() {
04319:                    return instance
04320:                            .createMOUSEINPUT(getElementPointer(NativeBridge.is64 ? 8
04321:                                    : 4));
04322:                }
04323:
04324:                public final KEYBDINPUT get_ki() {
04325:                    return instance
04326:                            .createKEYBDINPUT(getElementPointer(NativeBridge.is64 ? 8
04327:                                    : 4));
04328:                }
04329:
04330:                public final HARDWAREINPUT get_hi() {
04331:                    return instance
04332:                            .createHARDWAREINPUT(getElementPointer(NativeBridge.is64 ? 8
04333:                                    : 4));
04334:                }
04335:
04336:                @Override
04337:                public int size() {
04338:                    return sizeof;
04339:                }
04340:            }
04341:
04342:            public final INPUT createINPUT(boolean direct) {
04343:                return new INPUT(direct);
04344:            }
04345:
04346:            public final INPUT createINPUT(VoidPointer base) {
04347:                return new INPUT(base);
04348:            }
04349:
04350:            public final INPUT createINPUT(long addr) {
04351:                return new INPUT(addr);
04352:            }
04353:
04354:            public static class MOUSEINPUT extends CommonStructWrapper {
04355:
04356:                public static final int sizeof = NativeBridge.is64 ? 32 : 24;
04357:
04358:                MOUSEINPUT(boolean direct) {
04359:                    super (sizeof, direct);
04360:                }
04361:
04362:                MOUSEINPUT(VoidPointer base) {
04363:                    super (base);
04364:                }
04365:
04366:                MOUSEINPUT(long addr) {
04367:                    super (addr);
04368:                }
04369:
04370:                public final void set_dx(int val) {
04371:                    byteBase.setInt32(0, val);
04372:                }
04373:
04374:                public final int get_dx() {
04375:                    return byteBase.getInt32(0);
04376:                }
04377:
04378:                public final void set_dy(int val) {
04379:                    byteBase.setInt32(4, val);
04380:                }
04381:
04382:                public final int get_dy() {
04383:                    return byteBase.getInt32(4);
04384:                }
04385:
04386:                public final void set_mouseData(int val) {
04387:                    byteBase.setInt32(8, val);
04388:                }
04389:
04390:                public final int get_mouseData() {
04391:                    return byteBase.getInt32(8);
04392:                }
04393:
04394:                public final void set_dwFlags(int val) {
04395:                    byteBase.setInt32(12, val);
04396:                }
04397:
04398:                public final int get_dwFlags() {
04399:                    return byteBase.getInt32(12);
04400:                }
04401:
04402:                public final void set_time(int val) {
04403:                    byteBase.setInt32(16, val);
04404:                }
04405:
04406:                public final int get_time() {
04407:                    return byteBase.getInt32(16);
04408:                }
04409:
04410:                public final void set_dwExtraInfo(long val) {
04411:                    byteBase.setCLong(NativeBridge.is64 ? 24 : 20, val);
04412:                }
04413:
04414:                public final long get_dwExtraInfo() {
04415:                    return byteBase.getCLong(NativeBridge.is64 ? 24 : 20);
04416:                }
04417:
04418:                @Override
04419:                public int size() {
04420:                    return sizeof;
04421:                }
04422:            }
04423:
04424:            public final MOUSEINPUT createMOUSEINPUT(boolean direct) {
04425:                return new MOUSEINPUT(direct);
04426:            }
04427:
04428:            public final MOUSEINPUT createMOUSEINPUT(VoidPointer base) {
04429:                return new MOUSEINPUT(base);
04430:            }
04431:
04432:            public final MOUSEINPUT createMOUSEINPUT(long addr) {
04433:                return new MOUSEINPUT(addr);
04434:            }
04435:
04436:            public static class HARDWAREINPUT extends CommonStructWrapper {
04437:
04438:                public static final int sizeof = 8;
04439:
04440:                HARDWAREINPUT(boolean direct) {
04441:                    super (sizeof, direct);
04442:                }
04443:
04444:                HARDWAREINPUT(VoidPointer base) {
04445:                    super (base);
04446:                }
04447:
04448:                HARDWAREINPUT(long addr) {
04449:                    super (addr);
04450:                }
04451:
04452:                public final void set_uMsg(int val) {
04453:                    byteBase.setInt32(0, val);
04454:                }
04455:
04456:                public final int get_uMsg() {
04457:                    return byteBase.getInt32(0);
04458:                }
04459:
04460:                public final void set_wParamL(short val) {
04461:                    byteBase.setInt16(4, val);
04462:                }
04463:
04464:                public final short get_wParamL() {
04465:                    return byteBase.getInt16(4);
04466:                }
04467:
04468:                public final void set_wParamH(short val) {
04469:                    byteBase.setInt16(6, val);
04470:                }
04471:
04472:                public final short get_wParamH() {
04473:                    return byteBase.getInt16(6);
04474:                }
04475:
04476:                @Override
04477:                public int size() {
04478:                    return sizeof;
04479:                }
04480:            }
04481:
04482:            public final HARDWAREINPUT createHARDWAREINPUT(boolean direct) {
04483:                return new HARDWAREINPUT(direct);
04484:            }
04485:
04486:            public final HARDWAREINPUT createHARDWAREINPUT(VoidPointer base) {
04487:                return new HARDWAREINPUT(base);
04488:            }
04489:
04490:            public final HARDWAREINPUT createHARDWAREINPUT(long addr) {
04491:                return new HARDWAREINPUT(addr);
04492:            }
04493:
04494:            public static class KEYBDINPUT extends CommonStructWrapper {
04495:
04496:                public static final int sizeof = NativeBridge.is64 ? 24 : 16;
04497:
04498:                KEYBDINPUT(boolean direct) {
04499:                    super (sizeof, direct);
04500:                }
04501:
04502:                KEYBDINPUT(VoidPointer base) {
04503:                    super (base);
04504:                }
04505:
04506:                KEYBDINPUT(long addr) {
04507:                    super (addr);
04508:                }
04509:
04510:                public final void set_wVk(short val) {
04511:                    byteBase.setInt16(0, val);
04512:                }
04513:
04514:                public final short get_wVk() {
04515:                    return byteBase.getInt16(0);
04516:                }
04517:
04518:                public final void set_wScan(short val) {
04519:                    byteBase.setInt16(2, val);
04520:                }
04521:
04522:                public final short get_wScan() {
04523:                    return byteBase.getInt16(2);
04524:                }
04525:
04526:                public final void set_dwFlags(int val) {
04527:                    byteBase.setInt32(4, val);
04528:                }
04529:
04530:                public final int get_dwFlags() {
04531:                    return byteBase.getInt32(4);
04532:                }
04533:
04534:                public final void set_time(int val) {
04535:                    byteBase.setInt32(8, val);
04536:                }
04537:
04538:                public final int get_time() {
04539:                    return byteBase.getInt32(8);
04540:                }
04541:
04542:                public final void set_dwExtraInfo(long val) {
04543:                    byteBase.setCLong(NativeBridge.is64 ? 16 : 12, val);
04544:                }
04545:
04546:                public final long get_dwExtraInfo() {
04547:                    return byteBase.getCLong(NativeBridge.is64 ? 16 : 12);
04548:                }
04549:
04550:                @Override
04551:                public int size() {
04552:                    return sizeof;
04553:                }
04554:            }
04555:
04556:            public final KEYBDINPUT createKEYBDINPUT(boolean direct) {
04557:                return new KEYBDINPUT(direct);
04558:            }
04559:
04560:            public final KEYBDINPUT createKEYBDINPUT(VoidPointer base) {
04561:                return new KEYBDINPUT(base);
04562:            }
04563:
04564:            public final KEYBDINPUT createKEYBDINPUT(long addr) {
04565:                return new KEYBDINPUT(addr);
04566:            }
04567:
04568:            public final int DeleteObject(VoidPointer param_0) {
04569:                long tmp_0 = param_0 == null ? 0 : param_0.longLockPointer();
04570:                int tmp_ret = DeleteObject(tmp_0);
04571:                if (param_0 != null) {
04572:                    param_0.unlock();
04573:                }
04574:                return tmp_ret;
04575:            }
04576:
04577:            public final native int DeleteObject(long param_0);
04578:
04579:            public final native int ImmIsIME(long param_0);
04580:
04581:            public final short RegisterClassExW(WNDCLASSEXW param_0) {
04582:                long tmp_0 = param_0 == null ? 0 : param_0.longLockPointer();
04583:                short tmp_ret = RegisterClassExW(tmp_0);
04584:                if (param_0 != null) {
04585:                    param_0.unlock();
04586:                }
04587:                return tmp_ret;
04588:            }
04589:
04590:            public final native short RegisterClassExW(long param_0);
04591:
04592:            public static class WNDCLASSEXW extends CommonStructWrapper {
04593:
04594:                public static final int sizeof = NativeBridge.is64 ? 80 : 48;
04595:
04596:                WNDCLASSEXW(boolean direct) {
04597:                    super (sizeof, direct);
04598:                }
04599:
04600:                WNDCLASSEXW(VoidPointer base) {
04601:                    super (base);
04602:                }
04603:
04604:                WNDCLASSEXW(long addr) {
04605:                    super (addr);
04606:                }
04607:
04608:                public final void set_cbSize(int val) {
04609:                    byteBase.setInt32(0, val);
04610:                }
04611:
04612:                public final int get_cbSize() {
04613:                    return byteBase.getInt32(0);
04614:                }
04615:
04616:                public final void set_style(int val) {
04617:                    byteBase.setInt32(4, val);
04618:                }
04619:
04620:                public final int get_style() {
04621:                    return byteBase.getInt32(4);
04622:                }
04623:
04624:                public final void set_lpfnWndProc(long val) {
04625:                    byteBase.setAddress(8, val);
04626:                }
04627:
04628:                public final long get_lpfnWndProc() {
04629:                    return byteBase.getAddress(8);
04630:                }
04631:
04632:                public final long WNDPROC(long param_0, int param_1,
04633:                        long param_2, long param_3) {
04634:                    long tmp_ret = instance.proxycall30(get_lpfnWndProc(),
04635:                            param_0, param_1, param_2, param_3);
04636:                    return tmp_ret;
04637:                }
04638:
04639:                public final void set_cbClsExtra(int val) {
04640:                    byteBase.setInt32(NativeBridge.is64 ? 16 : 12, val);
04641:                }
04642:
04643:                public final int get_cbClsExtra() {
04644:                    return byteBase.getInt32(NativeBridge.is64 ? 16 : 12);
04645:                }
04646:
04647:                public final void set_cbWndExtra(int val) {
04648:                    byteBase.setInt32(NativeBridge.is64 ? 20 : 16, val);
04649:                }
04650:
04651:                public final int get_cbWndExtra() {
04652:                    return byteBase.getInt32(NativeBridge.is64 ? 20 : 16);
04653:                }
04654:
04655:                public final void set_hInstance(long val) {
04656:                    byteBase.setAddress(NativeBridge.is64 ? 24 : 20, val);
04657:                }
04658:
04659:                public final long get_hInstance() {
04660:                    return byteBase.getAddress(NativeBridge.is64 ? 24 : 20);
04661:                }
04662:
04663:                public final void set_hIcon(long val) {
04664:                    byteBase.setAddress(NativeBridge.is64 ? 32 : 24, val);
04665:                }
04666:
04667:                public final long get_hIcon() {
04668:                    return byteBase.getAddress(NativeBridge.is64 ? 32 : 24);
04669:                }
04670:
04671:                public final void set_hCursor(long val) {
04672:                    byteBase.setAddress(NativeBridge.is64 ? 40 : 28, val);
04673:                }
04674:
04675:                public final long get_hCursor() {
04676:                    return byteBase.getAddress(NativeBridge.is64 ? 40 : 28);
04677:                }
04678:
04679:                public final void set_hbrBackground(long val) {
04680:                    byteBase.setAddress(NativeBridge.is64 ? 48 : 32, val);
04681:                }
04682:
04683:                public final long get_hbrBackground() {
04684:                    return byteBase.getAddress(NativeBridge.is64 ? 48 : 32);
04685:                }
04686:
04687:                public final void set_lpszMenuName(Int16Pointer val) {
04688:                    byteBase.setPointer(NativeBridge.is64 ? 56 : 36, val);
04689:                }
04690:
04691:                public final Int16Pointer get_lpszMenuName() {
04692:                    return nb.createInt16Pointer(byteBase
04693:                            .getAddress(NativeBridge.is64 ? 56 : 36));
04694:                }
04695:
04696:                public final void set_lpszClassName(Int16Pointer val) {
04697:                    byteBase.setPointer(NativeBridge.is64 ? 64 : 40, val);
04698:                }
04699:
04700:                public final Int16Pointer get_lpszClassName() {
04701:                    return nb.createInt16Pointer(byteBase
04702:                            .getAddress(NativeBridge.is64 ? 64 : 40));
04703:                }
04704:
04705:                public final void set_hIconSm(long val) {
04706:                    byteBase.setAddress(NativeBridge.is64 ? 72 : 44, val);
04707:                }
04708:
04709:                public final long get_hIconSm() {
04710:                    return byteBase.getAddress(NativeBridge.is64 ? 72 : 44);
04711:                }
04712:
04713:                @Override
04714:                public int size() {
04715:                    return sizeof;
04716:                }
04717:            }
04718:
04719:            public final WNDCLASSEXW createWNDCLASSEXW(boolean direct) {
04720:                return new WNDCLASSEXW(direct);
04721:            }
04722:
04723:            public final WNDCLASSEXW createWNDCLASSEXW(VoidPointer base) {
04724:                return new WNDCLASSEXW(base);
04725:            }
04726:
04727:            public final WNDCLASSEXW createWNDCLASSEXW(long addr) {
04728:                return new WNDCLASSEXW(addr);
04729:            }
04730:
04731:            final native long proxycall30(long fnptr, long param_0,
04732:                    int param_1, long param_2, long param_3);
04733:
04734:            public final native long GetWindowDC(long hWnd);
04735:
04736:            public final int RegisterClipboardFormatW(String lpszFormat) {
04737:                Int16Pointer _lpszFormat = null == lpszFormat ? null : nb
04738:                        .createInt16Pointer(lpszFormat, false);
04739:                long tmp_0 = _lpszFormat == null ? 0 : _lpszFormat
04740:                        .longLockPointer();
04741:                int tmp_ret = RegisterClipboardFormatW(tmp_0);
04742:                if (_lpszFormat != null) {
04743:                    _lpszFormat.unlock();
04744:                    _lpszFormat.free();
04745:                }
04746:                return tmp_ret;
04747:            }
04748:
04749:            public final int RegisterClipboardFormatW(Int16Pointer lpszFormat) {
04750:                long tmp_0 = lpszFormat == null ? 0 : lpszFormat
04751:                        .longLockPointer();
04752:                int tmp_ret = RegisterClipboardFormatW(tmp_0);
04753:                if (lpszFormat != null) {
04754:                    lpszFormat.unlock();
04755:                }
04756:                return tmp_ret;
04757:            }
04758:
04759:            public final native int RegisterClipboardFormatW(long lpszFormat);
04760:
04761:            public final native int EnumClipboardFormats(int format);
04762:
04763:            public final native long GetFocus();
04764:
04765:            public final native long CreateRectRgn(int param_0, int param_1,
04766:                    int param_2, int param_3);
04767:
04768:            public final native int DestroyCursor(long hCursor);
04769:
04770:            public final int GetCurrentThemeName(Int16Pointer pszThemeFileName,
04771:                    int cchMaxNameChars, Int16Pointer pszColorBuff,
04772:                    int cchMaxColorChars, Int16Pointer pszSizeBuff,
04773:                    int cchMaxSizeChars) {
04774:                long tmp_0 = pszThemeFileName == null ? 0 : pszThemeFileName
04775:                        .longLockPointer();
04776:                long tmp_1 = pszColorBuff == null ? 0 : pszColorBuff
04777:                        .longLockPointer();
04778:                long tmp_2 = pszSizeBuff == null ? 0 : pszSizeBuff
04779:                        .longLockPointer();
04780:                int tmp_ret = GetCurrentThemeName(tmp_0, cchMaxNameChars,
04781:                        tmp_1, cchMaxColorChars, tmp_2, cchMaxSizeChars);
04782:                if (pszThemeFileName != null) {
04783:                    pszThemeFileName.unlock();
04784:                }
04785:                if (pszColorBuff != null) {
04786:                    pszColorBuff.unlock();
04787:                }
04788:                if (pszSizeBuff != null) {
04789:                    pszSizeBuff.unlock();
04790:                }
04791:                return tmp_ret;
04792:            }
04793:
04794:            public final native int GetCurrentThemeName(long pszThemeFileName,
04795:                    int cchMaxNameChars, long pszColorBuff,
04796:                    int cchMaxColorChars, long pszSizeBuff, int cchMaxSizeChars);
04797:
04798:            public final native long GetClipboardData(int uFormat);
04799:
04800:            public final int MoveToEx(long param_0, int param_1, int param_2,
04801:                    Win32.POINT param_3) {
04802:                long tmp_0 = param_3 == null ? 0 : param_3.longLockPointer();
04803:                int tmp_ret = MoveToEx(param_0, param_1, param_2, tmp_0);
04804:                if (param_3 != null) {
04805:                    param_3.unlock();
04806:                }
04807:                return tmp_ret;
04808:            }
04809:
04810:            public final native int MoveToEx(long param_0, int param_1,
04811:                    int param_2, long param_3);
04812:
04813:            public final native int ImmNotifyIME(long param_0, int dwAction,
04814:                    int dwIndex, int dwValue);
04815:
04816:            public final long WindowFromPoint(Win32.POINT Point) {
04817:                long tmp_0 = Point == null ? 0 : Point.longLockPointer();
04818:                long tmp_ret = WindowFromPoint(tmp_0);
04819:                if (Point != null) {
04820:                    Point.unlock();
04821:                }
04822:                return tmp_ret;
04823:            }
04824:
04825:            public final native long WindowFromPoint(long Point);
04826:
04827:            public final native long SetCapture(long hWnd);
04828:
04829:            public final native int DestroyCaret();
04830:
04831:            public final int SetWindowTextW(long hWnd, String lpString) {
04832:                Int16Pointer _lpString = null == lpString ? null : nb
04833:                        .createInt16Pointer(lpString, false);
04834:                long tmp_0 = _lpString == null ? 0 : _lpString
04835:                        .longLockPointer();
04836:                int tmp_ret = SetWindowTextW(hWnd, tmp_0);
04837:                if (_lpString != null) {
04838:                    _lpString.unlock();
04839:                    _lpString.free();
04840:                }
04841:                return tmp_ret;
04842:            }
04843:
04844:            public final int SetWindowTextW(long hWnd, Int16Pointer lpString) {
04845:                long tmp_0 = lpString == null ? 0 : lpString.longLockPointer();
04846:                int tmp_ret = SetWindowTextW(hWnd, tmp_0);
04847:                if (lpString != null) {
04848:                    lpString.unlock();
04849:                }
04850:                return tmp_ret;
04851:            }
04852:
04853:            public final native int SetWindowTextW(long hWnd, long lpString);
04854:
04855:            public final int DrawFocusRect(long hDC, Win32.RECT lprc) {
04856:                long tmp_0 = lprc == null ? 0 : lprc.longLockPointer();
04857:                int tmp_ret = DrawFocusRect(hDC, tmp_0);
04858:                if (lprc != null) {
04859:                    lprc.unlock();
04860:                }
04861:                return tmp_ret;
04862:            }
04863:
04864:            public final native int DrawFocusRect(long hDC, long lprc);
04865:
04866:            public final long CreateBrushIndirect(LOGBRUSH param_0) {
04867:                long tmp_0 = param_0 == null ? 0 : param_0.longLockPointer();
04868:                long tmp_ret = CreateBrushIndirect(tmp_0);
04869:                if (param_0 != null) {
04870:                    param_0.unlock();
04871:                }
04872:                return tmp_ret;
04873:            }
04874:
04875:            public final native long CreateBrushIndirect(long param_0);
04876:
04877:            public static class LOGBRUSH extends CommonStructWrapper {
04878:
04879:                public static final int sizeof = NativeBridge.is64 ? 16 : 12;
04880:
04881:                LOGBRUSH(boolean direct) {
04882:                    super (sizeof, direct);
04883:                }
04884:
04885:                LOGBRUSH(VoidPointer base) {
04886:                    super (base);
04887:                }
04888:
04889:                LOGBRUSH(long addr) {
04890:                    super (addr);
04891:                }
04892:
04893:                public final void set_lbStyle(int val) {
04894:                    byteBase.setInt32(0, val);
04895:                }
04896:
04897:                public final int get_lbStyle() {
04898:                    return byteBase.getInt32(0);
04899:                }
04900:
04901:                public final void set_lbColor(int val) {
04902:                    byteBase.setInt32(4, val);
04903:                }
04904:
04905:                public final int get_lbColor() {
04906:                    return byteBase.getInt32(4);
04907:                }
04908:
04909:                public final void set_lbHatch(long val) {
04910:                    byteBase.setCLong(8, val);
04911:                }
04912:
04913:                public final long get_lbHatch() {
04914:                    return byteBase.getCLong(8);
04915:                }
04916:
04917:                @Override
04918:                public int size() {
04919:                    return sizeof;
04920:                }
04921:            }
04922:
04923:            public final LOGBRUSH createLOGBRUSH(boolean direct) {
04924:                return new LOGBRUSH(direct);
04925:            }
04926:
04927:            public final LOGBRUSH createLOGBRUSH(VoidPointer base) {
04928:                return new LOGBRUSH(base);
04929:            }
04930:
04931:            public final LOGBRUSH createLOGBRUSH(long addr) {
04932:                return new LOGBRUSH(addr);
04933:            }
04934:
04935:            public final native int MapVirtualKeyW(int uCode, int uMapType);
04936:
04937:            public final int GetRgnBox(long param_0, Win32.RECT param_1) {
04938:                long tmp_0 = param_1 == null ? 0 : param_1.longLockPointer();
04939:                int tmp_ret = GetRgnBox(param_0, tmp_0);
04940:                if (param_1 != null) {
04941:                    param_1.unlock();
04942:                }
04943:                return tmp_ret;
04944:            }
04945:
04946:            public final native int GetRgnBox(long param_0, long param_1);
04947:
04948:            public final native long GetActiveWindow();
04949:
04950:            public final int WideCharToMultiByte(int CodePage, int dwFlags,
04951:                    String lpWideCharStr, int cchWideChar,
04952:                    Int8Pointer lpMultiByteStr, int cbMultiByte,
04953:                    String lpDefaultChar, Int32Pointer lpUsedDefaultChar) {
04954:                Int16Pointer _lpWideCharStr = null == lpWideCharStr ? null : nb
04955:                        .createInt16Pointer(lpWideCharStr, false);
04956:                long tmp_0 = _lpWideCharStr == null ? 0 : _lpWideCharStr
04957:                        .longLockPointer();
04958:                long tmp_1 = lpMultiByteStr == null ? 0 : lpMultiByteStr
04959:                        .longLockPointer();
04960:                Int8Pointer _lpDefaultChar = null == lpDefaultChar ? null : nb
04961:                        .createInt8Pointer(lpDefaultChar, false);
04962:                long tmp_2 = _lpDefaultChar == null ? 0 : _lpDefaultChar
04963:                        .longLockPointer();
04964:                long tmp_3 = lpUsedDefaultChar == null ? 0 : lpUsedDefaultChar
04965:                        .longLockPointer();
04966:                int tmp_ret = WideCharToMultiByte(CodePage, dwFlags, tmp_0,
04967:                        cchWideChar, tmp_1, cbMultiByte, tmp_2, tmp_3);
04968:                if (_lpWideCharStr != null) {
04969:                    _lpWideCharStr.unlock();
04970:                    _lpWideCharStr.free();
04971:                }
04972:                if (lpMultiByteStr != null) {
04973:                    lpMultiByteStr.unlock();
04974:                }
04975:                if (_lpDefaultChar != null) {
04976:                    _lpDefaultChar.unlock();
04977:                    _lpDefaultChar.free();
04978:                }
04979:                if (lpUsedDefaultChar != null) {
04980:                    lpUsedDefaultChar.unlock();
04981:                }
04982:                return tmp_ret;
04983:            }
04984:
04985:            public final int WideCharToMultiByte(int CodePage, int dwFlags,
04986:                    Int16Pointer lpWideCharStr, int cchWideChar,
04987:                    Int8Pointer lpMultiByteStr, int cbMultiByte,
04988:                    Int8Pointer lpDefaultChar, Int32Pointer lpUsedDefaultChar) {
04989:                long tmp_0 = lpWideCharStr == null ? 0 : lpWideCharStr
04990:                        .longLockPointer();
04991:                long tmp_1 = lpMultiByteStr == null ? 0 : lpMultiByteStr
04992:                        .longLockPointer();
04993:                long tmp_2 = lpDefaultChar == null ? 0 : lpDefaultChar
04994:                        .longLockPointer();
04995:                long tmp_3 = lpUsedDefaultChar == null ? 0 : lpUsedDefaultChar
04996:                        .longLockPointer();
04997:                int tmp_ret = WideCharToMultiByte(CodePage, dwFlags, tmp_0,
04998:                        cchWideChar, tmp_1, cbMultiByte, tmp_2, tmp_3);
04999:                if (lpWideCharStr != null) {
05000:                    lpWideCharStr.unlock();
05001:                }
05002:                if (lpMultiByteStr != null) {
05003:                    lpMultiByteStr.unlock();
05004:                }
05005:                if (lpDefaultChar != null) {
05006:                    lpDefaultChar.unlock();
05007:                }
05008:                if (lpUsedDefaultChar != null) {
05009:                    lpUsedDefaultChar.unlock();
05010:                }
05011:                return tmp_ret;
05012:            }
05013:
05014:            public final native int WideCharToMultiByte(int CodePage,
05015:                    int dwFlags, long lpWideCharStr, int cchWideChar,
05016:                    long lpMultiByteStr, int cbMultiByte, long lpDefaultChar,
05017:                    long lpUsedDefaultChar);
05018:
05019:            public final native int IsThemeActive();
05020:
05021:            public final int GetThemeSysColor(VoidPointer hTheme, int iColorId) {
05022:                long tmp_0 = hTheme == null ? 0 : hTheme.longLockPointer();
05023:                int tmp_ret = GetThemeSysColor(tmp_0, iColorId);
05024:                if (hTheme != null) {
05025:                    hTheme.unlock();
05026:                }
05027:                return tmp_ret;
05028:            }
05029:
05030:            public final native int GetThemeSysColor(long hTheme, int iColorId);
05031:
05032:            public final long GlobalSize(VoidPointer hMem) {
05033:                long tmp_0 = hMem == null ? 0 : hMem.longLockPointer();
05034:                long tmp_ret = GlobalSize(tmp_0);
05035:                if (hMem != null) {
05036:                    hMem.unlock();
05037:                }
05038:                return tmp_ret;
05039:            }
05040:
05041:            public final native long GlobalSize(long hMem);
05042:
05043:            public final native int FillRgn(long param_0, long param_1,
05044:                    long param_2);
05045:
05046:            public final int DrawFrameControl(long param_0, Win32.RECT param_1,
05047:                    int param_2, int param_3) {
05048:                long tmp_0 = param_1 == null ? 0 : param_1.longLockPointer();
05049:                int tmp_ret = DrawFrameControl(param_0, tmp_0, param_2, param_3);
05050:                if (param_1 != null) {
05051:                    param_1.unlock();
05052:                }
05053:                return tmp_ret;
05054:            }
05055:
05056:            public final native int DrawFrameControl(long param_0,
05057:                    long param_1, int param_2, int param_3);
05058:
05059:            public final native int EmptyClipboard();
05060:
05061:            public final native int DestroyWindow(long hWnd);
05062:
05063:            public final int CloseThemeData(VoidPointer hTheme) {
05064:                long tmp_0 = hTheme == null ? 0 : hTheme.longLockPointer();
05065:                int tmp_ret = CloseThemeData(tmp_0);
05066:                if (hTheme != null) {
05067:                    hTheme.unlock();
05068:                }
05069:                return tmp_ret;
05070:            }
05071:
05072:            public final native int CloseThemeData(long hTheme);
05073:
05074:            public final int TextOutW(long param_0, int param_1, int param_2,
05075:                    String param_3, int param_4) {
05076:                Int16Pointer _param_3 = null == param_3 ? null : nb
05077:                        .createInt16Pointer(param_3, false);
05078:                long tmp_0 = _param_3 == null ? 0 : _param_3.longLockPointer();
05079:                int tmp_ret = TextOutW(param_0, param_1, param_2, tmp_0,
05080:                        param_4);
05081:                if (_param_3 != null) {
05082:                    _param_3.unlock();
05083:                    _param_3.free();
05084:                }
05085:                return tmp_ret;
05086:            }
05087:
05088:            public final int TextOutW(long param_0, int param_1, int param_2,
05089:                    Int16Pointer param_3, int param_4) {
05090:                long tmp_0 = param_3 == null ? 0 : param_3.longLockPointer();
05091:                int tmp_ret = TextOutW(param_0, param_1, param_2, tmp_0,
05092:                        param_4);
05093:                if (param_3 != null) {
05094:                    param_3.unlock();
05095:                }
05096:                return tmp_ret;
05097:            }
05098:
05099:            public final native int TextOutW(long param_0, int param_1,
05100:                    int param_2, long param_3, int param_4);
05101:
05102:            public final int GetCaretPos(Win32.POINT lpPoint) {
05103:                long tmp_0 = lpPoint == null ? 0 : lpPoint.longLockPointer();
05104:                int tmp_ret = GetCaretPos(tmp_0);
05105:                if (lpPoint != null) {
05106:                    lpPoint.unlock();
05107:                }
05108:                return tmp_ret;
05109:            }
05110:
05111:            public final native int GetCaretPos(long lpPoint);
05112:
05113:            public final int GetThemeSysSize(VoidPointer hTheme, int iSizeId) {
05114:                long tmp_0 = hTheme == null ? 0 : hTheme.longLockPointer();
05115:                int tmp_ret = GetThemeSysSize(tmp_0, iSizeId);
05116:                if (hTheme != null) {
05117:                    hTheme.unlock();
05118:                }
05119:                return tmp_ret;
05120:            }
05121:
05122:            public final native int GetThemeSysSize(long hTheme, int iSizeId);
05123:
05124:            public final native int SelectClipRgn(long param_0, long param_1);
05125:
05126:            public final int SHGetFolderLocation(long hwnd, int csidl,
05127:                    VoidPointer hToken, int dwFlags, PointerPointer ppidl) {
05128:                long tmp_0 = hToken == null ? 0 : hToken.longLockPointer();
05129:                long tmp_1 = ppidl == null ? 0 : ppidl.longLockPointer();
05130:                int tmp_ret = SHGetFolderLocation(hwnd, csidl, tmp_0, dwFlags,
05131:                        tmp_1);
05132:                if (hToken != null) {
05133:                    hToken.unlock();
05134:                }
05135:                if (ppidl != null) {
05136:                    ppidl.unlock();
05137:                }
05138:                return tmp_ret;
05139:            }
05140:
05141:            public final native int SHGetFolderLocation(long hwnd, int csidl,
05142:                    long hToken, int dwFlags, long ppidl);
05143:
05144:            public final native long ImmCreateContext();
05145:
05146:            public final int CLSIDFromString(Int16Pointer lpsz,
05147:                    Win32.GUID pclsid) {
05148:                long tmp_0 = lpsz == null ? 0 : lpsz.longLockPointer();
05149:                long tmp_1 = pclsid == null ? 0 : pclsid.longLockPointer();
05150:                int tmp_ret = CLSIDFromString(tmp_0, tmp_1);
05151:                if (lpsz != null) {
05152:                    lpsz.unlock();
05153:                }
05154:                if (pclsid != null) {
05155:                    pclsid.unlock();
05156:                }
05157:                return tmp_ret;
05158:            }
05159:
05160:            public final native int CLSIDFromString(long lpsz, long pclsid);
05161:
05162:            public final int StrRetToBufW(Win32.STRRET pstr,
05163:                    Win32.ITEMIDLIST pidl, Int16Pointer pszBuf, int cchBuf) {
05164:                long tmp_0 = pstr == null ? 0 : pstr.longLockPointer();
05165:                long tmp_1 = pidl == null ? 0 : pidl.longLockPointer();
05166:                long tmp_2 = pszBuf == null ? 0 : pszBuf.longLockPointer();
05167:                int tmp_ret = StrRetToBufW(tmp_0, tmp_1, tmp_2, cchBuf);
05168:                if (pstr != null) {
05169:                    pstr.unlock();
05170:                }
05171:                if (pidl != null) {
05172:                    pidl.unlock();
05173:                }
05174:                if (pszBuf != null) {
05175:                    pszBuf.unlock();
05176:                }
05177:                return tmp_ret;
05178:            }
05179:
05180:            public final native int StrRetToBufW(long pstr, long pidl,
05181:                    long pszBuf, int cchBuf);
05182:
05183:            public final native int SetPolyFillMode(long param_0, int param_1);
05184:
05185:            public final Int8Pointer LocalFree(VoidPointer hMem) {
05186:                long tmp_0 = hMem == null ? 0 : hMem.longLockPointer();
05187:                long tmp_ret = LocalFree(tmp_0);
05188:                if (hMem != null) {
05189:                    hMem.unlock();
05190:                }
05191:                return nb.createInt8Pointer(tmp_ret);
05192:            }
05193:
05194:            public final native long LocalFree(long hMem);
05195:
05196:            public final native long CreateCompatibleDC(long param_0);
05197:
05198:            public final native long CreateCompatibleBitmap(long param_0,
05199:                    int param_1, int param_2);
05200:
05201:            public final native long DefWindowProcW(long hWnd, int Msg,
05202:                    long wParam, long lParam);
05203:
05204:            public final native int CloseClipboard();
05205:
05206:            public final native long SetActiveWindow(long hWnd);
05207:
05208:            public final native int GetDeviceCaps(long param_0, int param_1);
05209:
05210:            public final native long CreatePatternBrush(long param_0);
05211:
05212:            public final native void mouse_event(int dwFlags, int dx, int dy,
05213:                    int dwData, long dwExtraInfo);
05214:
05215:            public final int EnumDisplayDevicesW(String lpDevice, int iDevNum,
05216:                    DISPLAY_DEVICEW lpDisplayDevice, int dwFlags) {
05217:                Int16Pointer _lpDevice = null == lpDevice ? null : nb
05218:                        .createInt16Pointer(lpDevice, false);
05219:                long tmp_0 = _lpDevice == null ? 0 : _lpDevice
05220:                        .longLockPointer();
05221:                long tmp_1 = lpDisplayDevice == null ? 0 : lpDisplayDevice
05222:                        .longLockPointer();
05223:                int tmp_ret = EnumDisplayDevicesW(tmp_0, iDevNum, tmp_1,
05224:                        dwFlags);
05225:                if (_lpDevice != null) {
05226:                    _lpDevice.unlock();
05227:                    _lpDevice.free();
05228:                }
05229:                if (lpDisplayDevice != null) {
05230:                    lpDisplayDevice.unlock();
05231:                }
05232:                return tmp_ret;
05233:            }
05234:
05235:            public final int EnumDisplayDevicesW(Int16Pointer lpDevice,
05236:                    int iDevNum, DISPLAY_DEVICEW lpDisplayDevice, int dwFlags) {
05237:                long tmp_0 = lpDevice == null ? 0 : lpDevice.longLockPointer();
05238:                long tmp_1 = lpDisplayDevice == null ? 0 : lpDisplayDevice
05239:                        .longLockPointer();
05240:                int tmp_ret = EnumDisplayDevicesW(tmp_0, iDevNum, tmp_1,
05241:                        dwFlags);
05242:                if (lpDevice != null) {
05243:                    lpDevice.unlock();
05244:                }
05245:                if (lpDisplayDevice != null) {
05246:                    lpDisplayDevice.unlock();
05247:                }
05248:                return tmp_ret;
05249:            }
05250:
05251:            public final native int EnumDisplayDevicesW(long lpDevice,
05252:                    int iDevNum, long lpDisplayDevice, int dwFlags);
05253:
05254:            public static class DISPLAY_DEVICEW extends CommonStructWrapper {
05255:
05256:                public static final int sizeof = 840;
05257:
05258:                DISPLAY_DEVICEW(boolean direct) {
05259:                    super (sizeof, direct);
05260:                }
05261:
05262:                DISPLAY_DEVICEW(VoidPointer base) {
05263:                    super (base);
05264:                }
05265:
05266:                DISPLAY_DEVICEW(long addr) {
05267:                    super (addr);
05268:                }
05269:
05270:                public final void set_cb(int val) {
05271:                    byteBase.setInt32(0, val);
05272:                }
05273:
05274:                public final int get_cb() {
05275:                    return byteBase.getInt32(0);
05276:                }
05277:
05278:                public final Int16Pointer get_DeviceName() {
05279:                    return nb.createInt16Pointer(getElementPointer(4));
05280:                }
05281:
05282:                public final Int16Pointer get_DeviceString() {
05283:                    return nb.createInt16Pointer(getElementPointer(68));
05284:                }
05285:
05286:                public final void set_StateFlags(int val) {
05287:                    byteBase.setInt32(324, val);
05288:                }
05289:
05290:                public final int get_StateFlags() {
05291:                    return byteBase.getInt32(324);
05292:                }
05293:
05294:                public final Int16Pointer get_DeviceID() {
05295:                    return nb.createInt16Pointer(getElementPointer(328));
05296:                }
05297:
05298:                public final Int16Pointer get_DeviceKey() {
05299:                    return nb.createInt16Pointer(getElementPointer(584));
05300:                }
05301:
05302:                @Override
05303:                public int size() {
05304:                    return sizeof;
05305:                }
05306:            }
05307:
05308:            public final DISPLAY_DEVICEW createDISPLAY_DEVICEW(boolean direct) {
05309:                return new DISPLAY_DEVICEW(direct);
05310:            }
05311:
05312:            public final DISPLAY_DEVICEW createDISPLAY_DEVICEW(VoidPointer base) {
05313:                return new DISPLAY_DEVICEW(base);
05314:            }
05315:
05316:            public final DISPLAY_DEVICEW createDISPLAY_DEVICEW(long addr) {
05317:                return new DISPLAY_DEVICEW(addr);
05318:            }
05319:
05320:            public final native int SetWindowLongW(long hWnd, int nIndex,
05321:                    int dwNewLong);
05322:
05323:            public final int Polygon(long param_0, Win32.POINT param_1,
05324:                    int param_2) {
05325:                long tmp_0 = param_1 == null ? 0 : param_1.longLockPointer();
05326:                int tmp_ret = Polygon(param_0, tmp_0, param_2);
05327:                if (param_1 != null) {
05328:                    param_1.unlock();
05329:                }
05330:                return tmp_ret;
05331:            }
05332:
05333:            public final native int Polygon(long param_0, long param_1,
05334:                    int param_2);
05335:
05336:            public final native int GetUpdateRgn(long hWnd, long hRgn,
05337:                    int bErase);
05338:
05339:            public final native int Pie(long param_0, int param_1, int param_2,
05340:                    int param_3, int param_4, int param_5, int param_6,
05341:                    int param_7, int param_8);
05342:
05343:            public final native long GetClipboardOwner();
05344:
05345:            public final native int ShowWindow(long hWnd, int nCmdShow);
05346:
05347:            public final int MapWindowPoints(long hWndFrom, long hWndTo,
05348:                    Win32.POINT lpPoints, int cPoints) {
05349:                long tmp_0 = lpPoints == null ? 0 : lpPoints.longLockPointer();
05350:                int tmp_ret = MapWindowPoints(hWndFrom, hWndTo, tmp_0, cPoints);
05351:                if (lpPoints != null) {
05352:                    lpPoints.unlock();
05353:                }
05354:                return tmp_ret;
05355:            }
05356:
05357:            public final native int MapWindowPoints(long hWndFrom, long hWndTo,
05358:                    long lpPoints, int cPoints);
05359:
05360:            public final int ChoosePixelFormat(long param_0,
05361:                    Win32.PIXELFORMATDESCRIPTOR param_1) {
05362:                long tmp_0 = param_1 == null ? 0 : param_1.longLockPointer();
05363:                int tmp_ret = ChoosePixelFormat(param_0, tmp_0);
05364:                if (param_1 != null) {
05365:                    param_1.unlock();
05366:                }
05367:                return tmp_ret;
05368:            }
05369:
05370:            public final native int ChoosePixelFormat(long param_0, long param_1);
05371:
05372:            public final int PolyPolyline(long param_0, Win32.POINT param_1,
05373:                    Int32Pointer param_2, int param_3) {
05374:                long tmp_0 = param_1 == null ? 0 : param_1.longLockPointer();
05375:                long tmp_1 = param_2 == null ? 0 : param_2.longLockPointer();
05376:                int tmp_ret = PolyPolyline(param_0, tmp_0, tmp_1, param_3);
05377:                if (param_1 != null) {
05378:                    param_1.unlock();
05379:                }
05380:                if (param_2 != null) {
05381:                    param_2.unlock();
05382:                }
05383:                return tmp_ret;
05384:            }
05385:
05386:            public final native int PolyPolyline(long param_0, long param_1,
05387:                    long param_2, int param_3);
05388:
05389:            public final native int GetRandomRgn(long param_0, long param_1,
05390:                    int param_2);
05391:
05392:            public final long ExtCreatePen(int param_0, int param_1,
05393:                    Win32.LOGBRUSH param_2, int param_3, Int32Pointer param_4) {
05394:                long tmp_0 = param_2 == null ? 0 : param_2.longLockPointer();
05395:                long tmp_1 = param_4 == null ? 0 : param_4.longLockPointer();
05396:                long tmp_ret = ExtCreatePen(param_0, param_1, tmp_0, param_3,
05397:                        tmp_1);
05398:                if (param_2 != null) {
05399:                    param_2.unlock();
05400:                }
05401:                if (param_4 != null) {
05402:                    param_4.unlock();
05403:                }
05404:                return tmp_ret;
05405:            }
05406:
05407:            public final native long ExtCreatePen(int param_0, int param_1,
05408:                    long param_2, int param_3, long param_4);
05409:
05410:            public final int ChangeDisplaySettingsExW(String lpszDeviceName,
05411:                    Win32.DEVMODEW lpDevMode, long hwnd, int dwflags,
05412:                    VoidPointer lParam) {
05413:                Int16Pointer _lpszDeviceName = null == lpszDeviceName ? null
05414:                        : nb.createInt16Pointer(lpszDeviceName, false);
05415:                long tmp_0 = _lpszDeviceName == null ? 0 : _lpszDeviceName
05416:                        .longLockPointer();
05417:                long tmp_1 = lpDevMode == null ? 0 : lpDevMode
05418:                        .longLockPointer();
05419:                long tmp_2 = lParam == null ? 0 : lParam.longLockPointer();
05420:                int tmp_ret = ChangeDisplaySettingsExW(tmp_0, tmp_1, hwnd,
05421:                        dwflags, tmp_2);
05422:                if (_lpszDeviceName != null) {
05423:                    _lpszDeviceName.unlock();
05424:                    _lpszDeviceName.free();
05425:                }
05426:                if (lpDevMode != null) {
05427:                    lpDevMode.unlock();
05428:                }
05429:                if (lParam != null) {
05430:                    lParam.unlock();
05431:                }
05432:                return tmp_ret;
05433:            }
05434:
05435:            public final int ChangeDisplaySettingsExW(
05436:                    Int16Pointer lpszDeviceName, Win32.DEVMODEW lpDevMode,
05437:                    long hwnd, int dwflags, VoidPointer lParam) {
05438:                long tmp_0 = lpszDeviceName == null ? 0 : lpszDeviceName
05439:                        .longLockPointer();
05440:                long tmp_1 = lpDevMode == null ? 0 : lpDevMode
05441:                        .longLockPointer();
05442:                long tmp_2 = lParam == null ? 0 : lParam.longLockPointer();
05443:                int tmp_ret = ChangeDisplaySettingsExW(tmp_0, tmp_1, hwnd,
05444:                        dwflags, tmp_2);
05445:                if (lpszDeviceName != null) {
05446:                    lpszDeviceName.unlock();
05447:                }
05448:                if (lpDevMode != null) {
05449:                    lpDevMode.unlock();
05450:                }
05451:                if (lParam != null) {
05452:                    lParam.unlock();
05453:                }
05454:                return tmp_ret;
05455:            }
05456:
05457:            public final native int ChangeDisplaySettingsExW(
05458:                    long lpszDeviceName, long lpDevMode, long hwnd,
05459:                    int dwflags, long lParam);
05460:
05461:            public final int GetRegionData(long param_0, int param_1,
05462:                    Win32.RGNDATA param_2) {
05463:                long tmp_0 = param_2 == null ? 0 : param_2.longLockPointer();
05464:                int tmp_ret = GetRegionData(param_0, param_1, tmp_0);
05465:                if (param_2 != null) {
05466:                    param_2.unlock();
05467:                }
05468:                return tmp_ret;
05469:            }
05470:
05471:            public final native int GetRegionData(long param_0, int param_1,
05472:                    long param_2);
05473:
05474:            public final int InflateRect(Win32.RECT lprc, int dx, int dy) {
05475:                long tmp_0 = lprc == null ? 0 : lprc.longLockPointer();
05476:                int tmp_ret = InflateRect(tmp_0, dx, dy);
05477:                if (lprc != null) {
05478:                    lprc.unlock();
05479:                }
05480:                return tmp_ret;
05481:            }
05482:
05483:            public final native int InflateRect(long lprc, int dx, int dy);
05484:
05485:            public final native int SetBkColor(long param_0, int param_1);
05486:
05487:            public final native long GetAncestor(long hwnd, int gaFlags);
05488:
05489:            public final int GetThemeSysBool(VoidPointer hTheme, int iBoolId) {
05490:                long tmp_0 = hTheme == null ? 0 : hTheme.longLockPointer();
05491:                int tmp_ret = GetThemeSysBool(tmp_0, iBoolId);
05492:                if (hTheme != null) {
05493:                    hTheme.unlock();
05494:                }
05495:                return tmp_ret;
05496:            }
05497:
05498:            public final native int GetThemeSysBool(long hTheme, int iBoolId);
05499:
05500:            public final int TranslateMessage(Win32.MSG lpMsg) {
05501:                long tmp_0 = lpMsg == null ? 0 : lpMsg.longLockPointer();
05502:                int tmp_ret = TranslateMessage(tmp_0);
05503:                if (lpMsg != null) {
05504:                    lpMsg.unlock();
05505:                }
05506:                return tmp_ret;
05507:            }
05508:
05509:            public final native int TranslateMessage(long lpMsg);
05510:
05511:            public final native long CreateSolidBrush(int param_0);
05512:
05513:            public final Int8Pointer OpenThemeData(long hwnd,
05514:                    String pszClassList) {
05515:                Int16Pointer _pszClassList = null == pszClassList ? null : nb
05516:                        .createInt16Pointer(pszClassList, false);
05517:                long tmp_0 = _pszClassList == null ? 0 : _pszClassList
05518:                        .longLockPointer();
05519:                long tmp_ret = OpenThemeData(hwnd, tmp_0);
05520:                if (_pszClassList != null) {
05521:                    _pszClassList.unlock();
05522:                    _pszClassList.free();
05523:                }
05524:                return nb.createInt8Pointer(tmp_ret);
05525:            }
05526:
05527:            public final Int8Pointer OpenThemeData(long hwnd,
05528:                    Int16Pointer pszClassList) {
05529:                long tmp_0 = pszClassList == null ? 0 : pszClassList
05530:                        .longLockPointer();
05531:                long tmp_ret = OpenThemeData(hwnd, tmp_0);
05532:                if (pszClassList != null) {
05533:                    pszClassList.unlock();
05534:                }
05535:                return nb.createInt8Pointer(tmp_ret);
05536:            }
05537:
05538:            public final native long OpenThemeData(long hwnd, long pszClassList);
05539:
05540:            public final int GetWindowPlacement(long hWnd,
05541:                    Win32.WINDOWPLACEMENT lpwndpl) {
05542:                long tmp_0 = lpwndpl == null ? 0 : lpwndpl.longLockPointer();
05543:                int tmp_ret = GetWindowPlacement(hWnd, tmp_0);
05544:                if (lpwndpl != null) {
05545:                    lpwndpl.unlock();
05546:                }
05547:                return tmp_ret;
05548:            }
05549:
05550:            public final native int GetWindowPlacement(long hWnd, long lpwndpl);
05551:
05552:            public final native int ReleaseCapture();
05553:
05554:            public final int MultiByteToWideChar(int CodePage, int dwFlags,
05555:                    String lpMultiByteStr, int cbMultiByte,
05556:                    Int16Pointer lpWideCharStr, int cchWideChar) {
05557:                Int8Pointer _lpMultiByteStr = null == lpMultiByteStr ? null
05558:                        : nb.createInt8Pointer(lpMultiByteStr, false);
05559:                long tmp_0 = _lpMultiByteStr == null ? 0 : _lpMultiByteStr
05560:                        .longLockPointer();
05561:                long tmp_1 = lpWideCharStr == null ? 0 : lpWideCharStr
05562:                        .longLockPointer();
05563:                int tmp_ret = MultiByteToWideChar(CodePage, dwFlags, tmp_0,
05564:                        cbMultiByte, tmp_1, cchWideChar);
05565:                if (_lpMultiByteStr != null) {
05566:                    _lpMultiByteStr.unlock();
05567:                    _lpMultiByteStr.free();
05568:                }
05569:                if (lpWideCharStr != null) {
05570:                    lpWideCharStr.unlock();
05571:                }
05572:                return tmp_ret;
05573:            }
05574:
05575:            public final int MultiByteToWideChar(int CodePage, int dwFlags,
05576:                    Int8Pointer lpMultiByteStr, int cbMultiByte,
05577:                    Int16Pointer lpWideCharStr, int cchWideChar) {
05578:                long tmp_0 = lpMultiByteStr == null ? 0 : lpMultiByteStr
05579:                        .longLockPointer();
05580:                long tmp_1 = lpWideCharStr == null ? 0 : lpWideCharStr
05581:                        .longLockPointer();
05582:                int tmp_ret = MultiByteToWideChar(CodePage, dwFlags, tmp_0,
05583:                        cbMultiByte, tmp_1, cchWideChar);
05584:                if (lpMultiByteStr != null) {
05585:                    lpMultiByteStr.unlock();
05586:                }
05587:                if (lpWideCharStr != null) {
05588:                    lpWideCharStr.unlock();
05589:                }
05590:                return tmp_ret;
05591:            }
05592:
05593:            public final native int MultiByteToWideChar(int CodePage,
05594:                    int dwFlags, long lpMultiByteStr, int cbMultiByte,
05595:                    long lpWideCharStr, int cchWideChar);
05596:
05597:            public final int PlaySoundW(String pszSound, long hmod, int fdwSound) {
05598:                Int16Pointer _pszSound = null == pszSound ? null : nb
05599:                        .createInt16Pointer(pszSound, false);
05600:                long tmp_0 = _pszSound == null ? 0 : _pszSound
05601:                        .longLockPointer();
05602:                int tmp_ret = PlaySoundW(tmp_0, hmod, fdwSound);
05603:                if (_pszSound != null) {
05604:                    _pszSound.unlock();
05605:                    _pszSound.free();
05606:                }
05607:                return tmp_ret;
05608:            }
05609:
05610:            public final int PlaySoundW(Int16Pointer pszSound, long hmod,
05611:                    int fdwSound) {
05612:                long tmp_0 = pszSound == null ? 0 : pszSound.longLockPointer();
05613:                int tmp_ret = PlaySoundW(tmp_0, hmod, fdwSound);
05614:                if (pszSound != null) {
05615:                    pszSound.unlock();
05616:                }
05617:                return tmp_ret;
05618:            }
05619:
05620:            public final native int PlaySoundW(long pszSound, long hmod,
05621:                    int fdwSound);
05622:
05623:            public final int GetObjectW(VoidPointer param_0, int param_1,
05624:                    VoidPointer param_2) {
05625:                long tmp_0 = param_0 == null ? 0 : param_0.longLockPointer();
05626:                long tmp_1 = param_2 == null ? 0 : param_2.longLockPointer();
05627:                int tmp_ret = GetObjectW(tmp_0, param_1, tmp_1);
05628:                if (param_0 != null) {
05629:                    param_0.unlock();
05630:                }
05631:                if (param_2 != null) {
05632:                    param_2.unlock();
05633:                }
05634:                return tmp_ret;
05635:            }
05636:
05637:            public final native int GetObjectW(long param_0, int param_1,
05638:                    long param_2);
05639:
05640:            public final long LoadCursorW(long hInstance, String lpCursorName) {
05641:                Int16Pointer _lpCursorName = null == lpCursorName ? null : nb
05642:                        .createInt16Pointer(lpCursorName, false);
05643:                long tmp_0 = _lpCursorName == null ? 0 : _lpCursorName
05644:                        .longLockPointer();
05645:                long tmp_ret = LoadCursorW(hInstance, tmp_0);
05646:                if (_lpCursorName != null) {
05647:                    _lpCursorName.unlock();
05648:                    _lpCursorName.free();
05649:                }
05650:                return tmp_ret;
05651:            }
05652:
05653:            public final long LoadCursorW(long hInstance,
05654:                    Int16Pointer lpCursorName) {
05655:                long tmp_0 = lpCursorName == null ? 0 : lpCursorName
05656:                        .longLockPointer();
05657:                long tmp_ret = LoadCursorW(hInstance, tmp_0);
05658:                if (lpCursorName != null) {
05659:                    lpCursorName.unlock();
05660:                }
05661:                return tmp_ret;
05662:            }
05663:
05664:            public final native long LoadCursorW(long hInstance,
05665:                    long lpCursorName);
05666:
05667:            public final native int EnableTheming(int fEnable);
05668:
05669:            public final native int IsIconic(long hWnd);
05670:
05671:            public final native int EnableWindow(long hWnd, int bEnable);
05672:
05673:            public final native int PostMessageW(long hWnd, int Msg,
05674:                    long wParam, long lParam);
05675:
05676:            public final Int8Pointer GlobalLock(VoidPointer hMem) {
05677:                long tmp_0 = hMem == null ? 0 : hMem.longLockPointer();
05678:                long tmp_ret = GlobalLock(tmp_0);
05679:                if (hMem != null) {
05680:                    hMem.unlock();
05681:                }
05682:                return nb.createInt8Pointer(tmp_ret);
05683:            }
05684:
05685:            public final native long GlobalLock(long hMem);
05686:
05687:            public final native int ReleaseDC(long hWnd, long hDC);
05688:
05689:            public final int GetKeyboardLayoutList(int nBuff,
05690:                    PointerPointer lpList) {
05691:                long tmp_0 = lpList == null ? 0 : lpList.longLockPointer();
05692:                int tmp_ret = GetKeyboardLayoutList(nBuff, tmp_0);
05693:                if (lpList != null) {
05694:                    lpList.unlock();
05695:                }
05696:                return tmp_ret;
05697:            }
05698:
05699:            public final native int GetKeyboardLayoutList(int nBuff, long lpList);
05700:
05701:            public final Int8Pointer SelectObject(long param_0,
05702:                    VoidPointer param_1) {
05703:                long tmp_0 = param_1 == null ? 0 : param_1.longLockPointer();
05704:                long tmp_ret = SelectObject(param_0, tmp_0);
05705:                if (param_1 != null) {
05706:                    param_1.unlock();
05707:                }
05708:                return nb.createInt8Pointer(tmp_ret);
05709:            }
05710:
05711:            public final native long SelectObject(long param_0, long param_1);
05712:
05713:            public final native long GetKeyboardLayout(int idThread);
05714:
05715:            public final int GetWindowRect(long hWnd, Win32.RECT lpRect) {
05716:                long tmp_0 = lpRect == null ? 0 : lpRect.longLockPointer();
05717:                int tmp_ret = GetWindowRect(hWnd, tmp_0);
05718:                if (lpRect != null) {
05719:                    lpRect.unlock();
05720:                }
05721:                return tmp_ret;
05722:            }
05723:
05724:            public final native int GetWindowRect(long hWnd, long lpRect);
05725:
05726:            public final int DrawEdge(long hdc, Win32.RECT qrc, int edge,
05727:                    int grfFlags) {
05728:                long tmp_0 = qrc == null ? 0 : qrc.longLockPointer();
05729:                int tmp_ret = DrawEdge(hdc, tmp_0, edge, grfFlags);
05730:                if (qrc != null) {
05731:                    qrc.unlock();
05732:                }
05733:                return tmp_ret;
05734:            }
05735:
05736:            public final native int DrawEdge(long hdc, long qrc, int edge,
05737:                    int grfFlags);
05738:
05739:            public final int GetMessageW(Win32.MSG lpMsg, long hWnd,
05740:                    int wMsgFilterMin, int wMsgFilterMax) {
05741:                long tmp_0 = lpMsg == null ? 0 : lpMsg.longLockPointer();
05742:                int tmp_ret = GetMessageW(tmp_0, hWnd, wMsgFilterMin,
05743:                        wMsgFilterMax);
05744:                if (lpMsg != null) {
05745:                    lpMsg.unlock();
05746:                }
05747:                return tmp_ret;
05748:            }
05749:
05750:            public final native int GetMessageW(long lpMsg, long hWnd,
05751:                    int wMsgFilterMin, int wMsgFilterMax);
05752:
05753:            public final native int GetPixelFormat(long param_0);
05754:
05755:            public final Int8Pointer SetClipboardData(int uFormat,
05756:                    VoidPointer hMem) {
05757:                long tmp_0 = hMem == null ? 0 : hMem.longLockPointer();
05758:                long tmp_ret = SetClipboardData(uFormat, tmp_0);
05759:                if (hMem != null) {
05760:                    hMem.unlock();
05761:                }
05762:                return nb.createInt8Pointer(tmp_ret);
05763:            }
05764:
05765:            public final native long SetClipboardData(int uFormat, long hMem);
05766:
05767:            public final native int MulDiv(int nNumber, int nNumerator,
05768:                    int nDenominator);
05769:
05770:            public final long CreateBitmap(int param_0, int param_1,
05771:                    int param_2, int param_3, VoidPointer param_4) {
05772:                long tmp_0 = param_4 == null ? 0 : param_4.longLockPointer();
05773:                long tmp_ret = CreateBitmap(param_0, param_1, param_2, param_3,
05774:                        tmp_0);
05775:                if (param_4 != null) {
05776:                    param_4.unlock();
05777:                }
05778:                return tmp_ret;
05779:            }
05780:
05781:            public final native long CreateBitmap(int param_0, int param_1,
05782:                    int param_2, int param_3, long param_4);
05783:
05784:            public final int GetClipboardFormatNameW(int format,
05785:                    Int16Pointer lpszFormatName, int cchMaxCount) {
05786:                long tmp_0 = lpszFormatName == null ? 0 : lpszFormatName
05787:                        .longLockPointer();
05788:                int tmp_ret = GetClipboardFormatNameW(format, tmp_0,
05789:                        cchMaxCount);
05790:                if (lpszFormatName != null) {
05791:                    lpszFormatName.unlock();
05792:                }
05793:                return tmp_ret;
05794:            }
05795:
05796:            public final native int GetClipboardFormatNameW(int format,
05797:                    long lpszFormatName, int cchMaxCount);
05798:
05799:            public final native int SetWindowPos(long hWnd,
05800:                    long hWndInsertAfter, int X, int Y, int cx, int cy,
05801:                    int uFlags);
05802:
05803:            public final native int ImmSetOpenStatus(long param_0, int param_1);
05804:
05805:            public final native int SetCaretPos(int X, int Y);
05806:
05807:            public final int GetOpenFileNameW(Win32.OPENFILENAMEW param_0) {
05808:                long tmp_0 = param_0 == null ? 0 : param_0.longLockPointer();
05809:                int tmp_ret = GetOpenFileNameW(tmp_0);
05810:                if (param_0 != null) {
05811:                    param_0.unlock();
05812:                }
05813:                return tmp_ret;
05814:            }
05815:
05816:            public final native int GetOpenFileNameW(long param_0);
05817:
05818:            public final long CreateDIBSection(long param_0,
05819:                    Win32.BITMAPINFO param_1, int param_2,
05820:                    PointerPointer param_3, VoidPointer param_4, int param_5) {
05821:                long tmp_0 = param_1 == null ? 0 : param_1.longLockPointer();
05822:                long tmp_1 = param_3 == null ? 0 : param_3.longLockPointer();
05823:                long tmp_2 = param_4 == null ? 0 : param_4.longLockPointer();
05824:                long tmp_ret = CreateDIBSection(param_0, tmp_0, param_2, tmp_1,
05825:                        tmp_2, param_5);
05826:                if (param_1 != null) {
05827:                    param_1.unlock();
05828:                }
05829:                if (param_3 != null) {
05830:                    param_3.unlock();
05831:                }
05832:                if (param_4 != null) {
05833:                    param_4.unlock();
05834:                }
05835:                return tmp_ret;
05836:            }
05837:
05838:            public final native long CreateDIBSection(long param_0,
05839:                    long param_1, int param_2, long param_3, long param_4,
05840:                    int param_5);
05841:
05842:            public final native int SetBkMode(long param_0, int param_1);
05843:
05844:            public final native int Rectangle(long param_0, int param_1,
05845:                    int param_2, int param_3, int param_4);
05846:
05847:            public final native int GetDoubleClickTime();
05848:
05849:            public final int GetClientRect(long hWnd, Win32.RECT lpRect) {
05850:                long tmp_0 = lpRect == null ? 0 : lpRect.longLockPointer();
05851:                int tmp_ret = GetClientRect(hWnd, tmp_0);
05852:                if (lpRect != null) {
05853:                    lpRect.unlock();
05854:                }
05855:                return tmp_ret;
05856:            }
05857:
05858:            public final native int GetClientRect(long hWnd, long lpRect);
05859:
05860:            public final native int UpdateWindow(long hWnd);
05861:
05862:            public final native long GlobalAlloc(int uFlags, long dwBytes);
05863:
05864:            public final native int ChangeClipboardChain(long hWndRemove,
05865:                    long hWndNewNext);
05866:
05867:            public final native int OpenClipboard(long hWndNewOwner);
05868:
05869:            public static class IDirectDraw7 extends CommonStructWrapper {
05870:
05871:                public static final int sizeof = NativeBridge.is64 ? 8 : 4;
05872:
05873:                IDirectDraw7Vtbl vtbl;
05874:
05875:                IDirectDraw7(long addr) {
05876:                    super (addr);
05877:                    vtbl = get_lpVtbl();
05878:                }
05879:
05880:                public final IDirectDraw7Vtbl get_lpVtbl() {
05881:                    return instance.createIDirectDraw7Vtbl(byteBase
05882:                            .getAddress(0));
05883:                }
05884:
05885:                public final int QueryInterface(Win32.GUID riid,
05886:                        PointerPointer ppvObj) {
05887:                    return vtbl.QueryInterface(this , riid, ppvObj);
05888:                }
05889:
05890:                public final int AddRef() {
05891:                    return vtbl.AddRef(this );
05892:                }
05893:
05894:                public final int Release() {
05895:                    return vtbl.Release(this );
05896:                }
05897:
05898:                public final int Compact() {
05899:                    return vtbl.Compact(this );
05900:                }
05901:
05902:                public final int CreateClipper(int param_1,
05903:                        PointerPointer param_2, Win32.IUnknown param_3) {
05904:                    return vtbl.CreateClipper(this , param_1, param_2, param_3);
05905:                }
05906:
05907:                public final int CreatePalette(int param_1,
05908:                        PALETTEENTRY param_2, PointerPointer param_3,
05909:                        Win32.IUnknown param_4) {
05910:                    return vtbl.CreatePalette(this , param_1, param_2, param_3,
05911:                            param_4);
05912:                }
05913:
05914:                public final int CreateSurface(DDSURFACEDESC2 param_1,
05915:                        PointerPointer param_2, Win32.IUnknown param_3) {
05916:                    return vtbl.CreateSurface(this , param_1, param_2, param_3);
05917:                }
05918:
05919:                public final int DuplicateSurface(IDirectDrawSurface7 param_1,
05920:                        PointerPointer param_2) {
05921:                    return vtbl.DuplicateSurface(this , param_1, param_2);
05922:                }
05923:
05924:                public final int EnumDisplayModes(int param_1,
05925:                        DDSURFACEDESC2 param_2, VoidPointer param_3,
05926:                        long param_4) {
05927:                    return vtbl.EnumDisplayModes(this , param_1, param_2,
05928:                            param_3, param_4);
05929:                }
05930:
05931:                public final int EnumSurfaces(int param_1,
05932:                        DDSURFACEDESC2 param_2, VoidPointer param_3,
05933:                        long param_4) {
05934:                    return vtbl.EnumSurfaces(this , param_1, param_2, param_3,
05935:                            param_4);
05936:                }
05937:
05938:                public final int FlipToGDISurface() {
05939:                    return vtbl.FlipToGDISurface(this );
05940:                }
05941:
05942:                public final int GetCaps(DDCAPS_DX7 param_1, DDCAPS_DX7 param_2) {
05943:                    return vtbl.GetCaps(this , param_1, param_2);
05944:                }
05945:
05946:                public final int GetDisplayMode(DDSURFACEDESC2 param_1) {
05947:                    return vtbl.GetDisplayMode(this , param_1);
05948:                }
05949:
05950:                public final int GetFourCCCodes(Int32Pointer param_1,
05951:                        Int32Pointer param_2) {
05952:                    return vtbl.GetFourCCCodes(this , param_1, param_2);
05953:                }
05954:
05955:                public final int GetGDISurface(PointerPointer param_1) {
05956:                    return vtbl.GetGDISurface(this , param_1);
05957:                }
05958:
05959:                public final int GetMonitorFrequency(Int32Pointer param_1) {
05960:                    return vtbl.GetMonitorFrequency(this , param_1);
05961:                }
05962:
05963:                public final int GetScanLine(Int32Pointer param_1) {
05964:                    return vtbl.GetScanLine(this , param_1);
05965:                }
05966:
05967:                public final int GetVerticalBlankStatus(Int32Pointer param_1) {
05968:                    return vtbl.GetVerticalBlankStatus(this , param_1);
05969:                }
05970:
05971:                public final int Initialize(Win32.GUID param_1) {
05972:                    return vtbl.Initialize(this , param_1);
05973:                }
05974:
05975:                public final int RestoreDisplayMode() {
05976:                    return vtbl.RestoreDisplayMode(this );
05977:                }
05978:
05979:                public final int SetCooperativeLevel(long param_1, int param_2) {
05980:                    return vtbl.SetCooperativeLevel(this , param_1, param_2);
05981:                }
05982:
05983:                public final int SetDisplayMode(int param_1, int param_2,
05984:                        int param_3, int param_4, int param_5) {
05985:                    return vtbl.SetDisplayMode(this , param_1, param_2, param_3,
05986:                            param_4, param_5);
05987:                }
05988:
05989:                public final int WaitForVerticalBlank(int param_1,
05990:                        VoidPointer param_2) {
05991:                    return vtbl.WaitForVerticalBlank(this , param_1, param_2);
05992:                }
05993:
05994:                public final int GetAvailableVidMem(DDSCAPS2 param_1,
05995:                        Int32Pointer param_2, Int32Pointer param_3) {
05996:                    return vtbl.GetAvailableVidMem(this , param_1, param_2,
05997:                            param_3);
05998:                }
05999:
06000:                public final int GetSurfaceFromDC(long param_1,
06001:                        PointerPointer param_2) {
06002:                    return vtbl.GetSurfaceFromDC(this , param_1, param_2);
06003:                }
06004:
06005:                public final int RestoreAllSurfaces() {
06006:                    return vtbl.RestoreAllSurfaces(this );
06007:                }
06008:
06009:                public final int TestCooperativeLevel() {
06010:                    return vtbl.TestCooperativeLevel(this );
06011:                }
06012:
06013:                public final int GetDeviceIdentifier(
06014:                        DDDEVICEIDENTIFIER2 param_1, int param_2) {
06015:                    return vtbl.GetDeviceIdentifier(this , param_1, param_2);
06016:                }
06017:
06018:                public final int StartModeTest(SIZE param_1, int param_2,
06019:                        int param_3) {
06020:                    return vtbl.StartModeTest(this , param_1, param_2, param_3);
06021:                }
06022:
06023:                public final int EvaluateMode(int param_1, Int32Pointer param_2) {
06024:                    return vtbl.EvaluateMode(this , param_1, param_2);
06025:                }
06026:
06027:                @Override
06028:                public int size() {
06029:                    return sizeof;
06030:                }
06031:            }
06032:
06033:            public final IDirectDraw7 createIDirectDraw7(long addr) {
06034:                return new IDirectDraw7(addr);
06035:            }
06036:
06037:            public static class IDirectDraw extends CommonStructWrapper {
06038:
06039:                public static final int sizeof = NativeBridge.is64 ? 8 : 4;
06040:
06041:                IDirectDrawVtbl vtbl;
06042:
06043:                IDirectDraw(long addr) {
06044:                    super (addr);
06045:                    vtbl = get_lpVtbl();
06046:                }
06047:
06048:                public final IDirectDrawVtbl get_lpVtbl() {
06049:                    return instance.createIDirectDrawVtbl(byteBase
06050:                            .getAddress(0));
06051:                }
06052:
06053:                public final int QueryInterface(Win32.GUID riid,
06054:                        PointerPointer ppvObj) {
06055:                    return vtbl.QueryInterface(this , riid, ppvObj);
06056:                }
06057:
06058:                public final int AddRef() {
06059:                    return vtbl.AddRef(this );
06060:                }
06061:
06062:                public final int Release() {
06063:                    return vtbl.Release(this );
06064:                }
06065:
06066:                public final int Compact() {
06067:                    return vtbl.Compact(this );
06068:                }
06069:
06070:                public final int CreateClipper(int param_1,
06071:                        PointerPointer param_2, Win32.IUnknown param_3) {
06072:                    return vtbl.CreateClipper(this , param_1, param_2, param_3);
06073:                }
06074:
06075:                public final int CreatePalette(int param_1,
06076:                        PALETTEENTRY param_2, PointerPointer param_3,
06077:                        Win32.IUnknown param_4) {
06078:                    return vtbl.CreatePalette(this , param_1, param_2, param_3,
06079:                            param_4);
06080:                }
06081:
06082:                public final int CreateSurface(DDSURFACEDESC param_1,
06083:                        PointerPointer param_2, Win32.IUnknown param_3) {
06084:                    return vtbl.CreateSurface(this , param_1, param_2, param_3);
06085:                }
06086:
06087:                public final int DuplicateSurface(IDirectDrawSurface param_1,
06088:                        PointerPointer param_2) {
06089:                    return vtbl.DuplicateSurface(this , param_1, param_2);
06090:                }
06091:
06092:                public final int EnumDisplayModes(int param_1,
06093:                        DDSURFACEDESC param_2, VoidPointer param_3, long param_4) {
06094:                    return vtbl.EnumDisplayModes(this , param_1, param_2,
06095:                            param_3, param_4);
06096:                }
06097:
06098:                public final int EnumSurfaces(int param_1,
06099:                        DDSURFACEDESC param_2, VoidPointer param_3, long param_4) {
06100:                    return vtbl.EnumSurfaces(this , param_1, param_2, param_3,
06101:                            param_4);
06102:                }
06103:
06104:                public final int FlipToGDISurface() {
06105:                    return vtbl.FlipToGDISurface(this );
06106:                }
06107:
06108:                public final int GetCaps(DDCAPS_DX7 param_1, DDCAPS_DX7 param_2) {
06109:                    return vtbl.GetCaps(this , param_1, param_2);
06110:                }
06111:
06112:                public final int GetDisplayMode(DDSURFACEDESC param_1) {
06113:                    return vtbl.GetDisplayMode(this , param_1);
06114:                }
06115:
06116:                public final int GetFourCCCodes(Int32Pointer param_1,
06117:                        Int32Pointer param_2) {
06118:                    return vtbl.GetFourCCCodes(this , param_1, param_2);
06119:                }
06120:
06121:                public final int GetGDISurface(PointerPointer param_1) {
06122:                    return vtbl.GetGDISurface(this , param_1);
06123:                }
06124:
06125:                public final int GetMonitorFrequency(Int32Pointer param_1) {
06126:                    return vtbl.GetMonitorFrequency(this , param_1);
06127:                }
06128:
06129:                public final int GetScanLine(Int32Pointer param_1) {
06130:                    return vtbl.GetScanLine(this , param_1);
06131:                }
06132:
06133:                public final int GetVerticalBlankStatus(Int32Pointer param_1) {
06134:                    return vtbl.GetVerticalBlankStatus(this , param_1);
06135:                }
06136:
06137:                public final int Initialize(Win32.GUID param_1) {
06138:                    return vtbl.Initialize(this , param_1);
06139:                }
06140:
06141:                public final int RestoreDisplayMode() {
06142:                    return vtbl.RestoreDisplayMode(this );
06143:                }
06144:
06145:                public final int SetCooperativeLevel(long param_1, int param_2) {
06146:                    return vtbl.SetCooperativeLevel(this , param_1, param_2);
06147:                }
06148:
06149:                public final int SetDisplayMode(int param_1, int param_2,
06150:                        int param_3) {
06151:                    return vtbl.SetDisplayMode(this , param_1, param_2, param_3);
06152:                }
06153:
06154:                public final int WaitForVerticalBlank(int param_1,
06155:                        VoidPointer param_2) {
06156:                    return vtbl.WaitForVerticalBlank(this , param_1, param_2);
06157:                }
06158:
06159:                @Override
06160:                public int size() {
06161:                    return sizeof;
06162:                }
06163:            }
06164:
06165:            public final IDirectDraw createIDirectDraw(long addr) {
06166:                return new IDirectDraw(addr);
06167:            }
06168:
06169:            public static class IEnumIDList extends CommonStructWrapper {
06170:
06171:                public static final int sizeof = NativeBridge.is64 ? 8 : 4;
06172:
06173:                IEnumIDListVtbl vtbl;
06174:
06175:                IEnumIDList(long addr) {
06176:                    super (addr);
06177:                    vtbl = get_lpVtbl();
06178:                }
06179:
06180:                public final IEnumIDListVtbl get_lpVtbl() {
06181:                    return instance.createIEnumIDListVtbl(byteBase
06182:                            .getAddress(0));
06183:                }
06184:
06185:                public final int QueryInterface(Win32.GUID riid,
06186:                        PointerPointer ppvObject) {
06187:                    return vtbl.QueryInterface(this , riid, ppvObject);
06188:                }
06189:
06190:                public final int AddRef() {
06191:                    return vtbl.AddRef(this );
06192:                }
06193:
06194:                public final int Release() {
06195:                    return vtbl.Release(this );
06196:                }
06197:
06198:                public final int Next(int celt, PointerPointer rgelt,
06199:                        Int32Pointer pceltFetched) {
06200:                    return vtbl.Next(this , celt, rgelt, pceltFetched);
06201:                }
06202:
06203:                public final int Skip(int celt) {
06204:                    return vtbl.Skip(this , celt);
06205:                }
06206:
06207:                public final int Reset() {
06208:                    return vtbl.Reset(this );
06209:                }
06210:
06211:                public final int Clone(PointerPointer ppenum) {
06212:                    return vtbl.Clone(this , ppenum);
06213:                }
06214:
06215:                @Override
06216:                public int size() {
06217:                    return sizeof;
06218:                }
06219:            }
06220:
06221:            public final IEnumIDList createIEnumIDList(long addr) {
06222:                return new IEnumIDList(addr);
06223:            }
06224:
06225:            public static class IDirectDrawClipper extends CommonStructWrapper {
06226:
06227:                public static final int sizeof = NativeBridge.is64 ? 8 : 4;
06228:
06229:                IDirectDrawClipperVtbl vtbl;
06230:
06231:                IDirectDrawClipper(long addr) {
06232:                    super (addr);
06233:                    vtbl = get_lpVtbl();
06234:                }
06235:
06236:                public final IDirectDrawClipperVtbl get_lpVtbl() {
06237:                    return instance.createIDirectDrawClipperVtbl(byteBase
06238:                            .getAddress(0));
06239:                }
06240:
06241:                public final int QueryInterface(Win32.GUID riid,
06242:                        PointerPointer ppvObj) {
06243:                    return vtbl.QueryInterface(this , riid, ppvObj);
06244:                }
06245:
06246:                public final int AddRef() {
06247:                    return vtbl.AddRef(this );
06248:                }
06249:
06250:                public final int Release() {
06251:                    return vtbl.Release(this );
06252:                }
06253:
06254:                public final int GetClipList(Win32.RECT param_1,
06255:                        Win32.RGNDATA param_2, Int32Pointer param_3) {
06256:                    return vtbl.GetClipList(this , param_1, param_2, param_3);
06257:                }
06258:
06259:                public final int GetHWnd(PointerPointer param_1) {
06260:                    return vtbl.GetHWnd(this , param_1);
06261:                }
06262:
06263:                public final int Initialize(Win32.IDirectDraw param_1,
06264:                        int param_2) {
06265:                    return vtbl.Initialize(this , param_1, param_2);
06266:                }
06267:
06268:                public final int IsClipListChanged(Int32Pointer param_1) {
06269:                    return vtbl.IsClipListChanged(this , param_1);
06270:                }
06271:
06272:                public final int SetClipList(Win32.RGNDATA param_1, int param_2) {
06273:                    return vtbl.SetClipList(this , param_1, param_2);
06274:                }
06275:
06276:                public final int SetHWnd(int param_1, long param_2) {
06277:                    return vtbl.SetHWnd(this , param_1, param_2);
06278:                }
06279:
06280:                @Override
06281:                public int size() {
06282:                    return sizeof;
06283:                }
06284:            }
06285:
06286:            public final IDirectDrawClipper createIDirectDrawClipper(long addr) {
06287:                return new IDirectDrawClipper(addr);
06288:            }
06289:
06290:            public static class IDirectDrawPalette extends CommonStructWrapper {
06291:
06292:                public static final int sizeof = NativeBridge.is64 ? 8 : 4;
06293:
06294:                IDirectDrawPaletteVtbl vtbl;
06295:
06296:                IDirectDrawPalette(long addr) {
06297:                    super (addr);
06298:                    vtbl = get_lpVtbl();
06299:                }
06300:
06301:                public final IDirectDrawPaletteVtbl get_lpVtbl() {
06302:                    return instance.createIDirectDrawPaletteVtbl(byteBase
06303:                            .getAddress(0));
06304:                }
06305:
06306:                public final int QueryInterface(Win32.GUID riid,
06307:                        PointerPointer ppvObj) {
06308:                    return vtbl.QueryInterface(this , riid, ppvObj);
06309:                }
06310:
06311:                public final int AddRef() {
06312:                    return vtbl.AddRef(this );
06313:                }
06314:
06315:                public final int Release() {
06316:                    return vtbl.Release(this );
06317:                }
06318:
06319:                public final int GetCaps(Int32Pointer param_1) {
06320:                    return vtbl.GetCaps(this , param_1);
06321:                }
06322:
06323:                public final int GetEntries(int param_1, int param_2,
06324:                        int param_3, PALETTEENTRY param_4) {
06325:                    return vtbl.GetEntries(this , param_1, param_2, param_3,
06326:                            param_4);
06327:                }
06328:
06329:                public final int Initialize(Win32.IDirectDraw param_1,
06330:                        int param_2, PALETTEENTRY param_3) {
06331:                    return vtbl.Initialize(this , param_1, param_2, param_3);
06332:                }
06333:
06334:                public final int SetEntries(int param_1, int param_2,
06335:                        int param_3, PALETTEENTRY param_4) {
06336:                    return vtbl.SetEntries(this , param_1, param_2, param_3,
06337:                            param_4);
06338:                }
06339:
06340:                @Override
06341:                public int size() {
06342:                    return sizeof;
06343:                }
06344:            }
06345:
06346:            public final IDirectDrawPalette createIDirectDrawPalette(long addr) {
06347:                return new IDirectDrawPalette(addr);
06348:            }
06349:
06350:            public static class IDirectDrawPaletteVtbl extends
06351:                    CommonStructWrapper {
06352:
06353:                public static final int sizeof = NativeBridge.is64 ? 56 : 28;
06354:
06355:                IDirectDrawPaletteVtbl(boolean direct) {
06356:                    super (sizeof, direct);
06357:                }
06358:
06359:                IDirectDrawPaletteVtbl(VoidPointer base) {
06360:                    super (base);
06361:                }
06362:
06363:                IDirectDrawPaletteVtbl(long addr) {
06364:                    super (addr);
06365:                }
06366:
06367:                public final void set_QueryInterface(long val) {
06368:                    byteBase.setAddress(0, val);
06369:                }
06370:
06371:                public final long get_QueryInterface() {
06372:                    return byteBase.getAddress(0);
06373:                }
06374:
06375:                public final int QueryInterface(Win32.IDirectDrawPalette This,
06376:                        Win32.GUID riid, PointerPointer ppvObj) {
06377:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
06378:                    long tmp_1 = riid == null ? 0 : riid.longLockPointer();
06379:                    long tmp_2 = ppvObj == null ? 0 : ppvObj.longLockPointer();
06380:                    int tmp_ret = instance.proxycall31(get_QueryInterface(),
06381:                            tmp_0, tmp_1, tmp_2);
06382:                    if (This != null) {
06383:                        This.unlock();
06384:                    }
06385:                    if (riid != null) {
06386:                        riid.unlock();
06387:                    }
06388:                    if (ppvObj != null) {
06389:                        ppvObj.unlock();
06390:                    }
06391:                    return tmp_ret;
06392:                }
06393:
06394:                public final void set_AddRef(long val) {
06395:                    byteBase.setAddress(NativeBridge.is64 ? 8 : 4, val);
06396:                }
06397:
06398:                public final long get_AddRef() {
06399:                    return byteBase.getAddress(NativeBridge.is64 ? 8 : 4);
06400:                }
06401:
06402:                public final int AddRef(Win32.IDirectDrawPalette This) {
06403:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
06404:                    int tmp_ret = instance.proxycall32(get_AddRef(), tmp_0);
06405:                    if (This != null) {
06406:                        This.unlock();
06407:                    }
06408:                    return tmp_ret;
06409:                }
06410:
06411:                public final void set_Release(long val) {
06412:                    byteBase.setAddress(NativeBridge.is64 ? 16 : 8, val);
06413:                }
06414:
06415:                public final long get_Release() {
06416:                    return byteBase.getAddress(NativeBridge.is64 ? 16 : 8);
06417:                }
06418:
06419:                public final int Release(Win32.IDirectDrawPalette This) {
06420:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
06421:                    int tmp_ret = instance.proxycall33(get_Release(), tmp_0);
06422:                    if (This != null) {
06423:                        This.unlock();
06424:                    }
06425:                    return tmp_ret;
06426:                }
06427:
06428:                public final void set_GetCaps(long val) {
06429:                    byteBase.setAddress(NativeBridge.is64 ? 24 : 12, val);
06430:                }
06431:
06432:                public final long get_GetCaps() {
06433:                    return byteBase.getAddress(NativeBridge.is64 ? 24 : 12);
06434:                }
06435:
06436:                public final int GetCaps(Win32.IDirectDrawPalette This,
06437:                        Int32Pointer param_1) {
06438:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
06439:                    long tmp_1 = param_1 == null ? 0 : param_1
06440:                            .longLockPointer();
06441:                    int tmp_ret = instance.proxycall34(get_GetCaps(), tmp_0,
06442:                            tmp_1);
06443:                    if (This != null) {
06444:                        This.unlock();
06445:                    }
06446:                    if (param_1 != null) {
06447:                        param_1.unlock();
06448:                    }
06449:                    return tmp_ret;
06450:                }
06451:
06452:                public final void set_GetEntries(long val) {
06453:                    byteBase.setAddress(NativeBridge.is64 ? 32 : 16, val);
06454:                }
06455:
06456:                public final long get_GetEntries() {
06457:                    return byteBase.getAddress(NativeBridge.is64 ? 32 : 16);
06458:                }
06459:
06460:                public final int GetEntries(Win32.IDirectDrawPalette This,
06461:                        int param_1, int param_2, int param_3,
06462:                        PALETTEENTRY param_4) {
06463:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
06464:                    long tmp_1 = param_4 == null ? 0 : param_4
06465:                            .longLockPointer();
06466:                    int tmp_ret = instance.proxycall35(get_GetEntries(), tmp_0,
06467:                            param_1, param_2, param_3, tmp_1);
06468:                    if (This != null) {
06469:                        This.unlock();
06470:                    }
06471:                    if (param_4 != null) {
06472:                        param_4.unlock();
06473:                    }
06474:                    return tmp_ret;
06475:                }
06476:
06477:                public final void set_Initialize(long val) {
06478:                    byteBase.setAddress(NativeBridge.is64 ? 40 : 20, val);
06479:                }
06480:
06481:                public final long get_Initialize() {
06482:                    return byteBase.getAddress(NativeBridge.is64 ? 40 : 20);
06483:                }
06484:
06485:                public final int Initialize(Win32.IDirectDrawPalette This,
06486:                        Win32.IDirectDraw param_1, int param_2,
06487:                        PALETTEENTRY param_3) {
06488:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
06489:                    long tmp_1 = param_1 == null ? 0 : param_1
06490:                            .longLockPointer();
06491:                    long tmp_2 = param_3 == null ? 0 : param_3
06492:                            .longLockPointer();
06493:                    int tmp_ret = instance.proxycall36(get_Initialize(), tmp_0,
06494:                            tmp_1, param_2, tmp_2);
06495:                    if (This != null) {
06496:                        This.unlock();
06497:                    }
06498:                    if (param_1 != null) {
06499:                        param_1.unlock();
06500:                    }
06501:                    if (param_3 != null) {
06502:                        param_3.unlock();
06503:                    }
06504:                    return tmp_ret;
06505:                }
06506:
06507:                public final void set_SetEntries(long val) {
06508:                    byteBase.setAddress(NativeBridge.is64 ? 48 : 24, val);
06509:                }
06510:
06511:                public final long get_SetEntries() {
06512:                    return byteBase.getAddress(NativeBridge.is64 ? 48 : 24);
06513:                }
06514:
06515:                public final int SetEntries(Win32.IDirectDrawPalette This,
06516:                        int param_1, int param_2, int param_3,
06517:                        PALETTEENTRY param_4) {
06518:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
06519:                    long tmp_1 = param_4 == null ? 0 : param_4
06520:                            .longLockPointer();
06521:                    int tmp_ret = instance.proxycall37(get_SetEntries(), tmp_0,
06522:                            param_1, param_2, param_3, tmp_1);
06523:                    if (This != null) {
06524:                        This.unlock();
06525:                    }
06526:                    if (param_4 != null) {
06527:                        param_4.unlock();
06528:                    }
06529:                    return tmp_ret;
06530:                }
06531:
06532:                @Override
06533:                public int size() {
06534:                    return sizeof;
06535:                }
06536:            }
06537:
06538:            public final IDirectDrawPaletteVtbl createIDirectDrawPaletteVtbl(
06539:                    boolean direct) {
06540:                return new IDirectDrawPaletteVtbl(direct);
06541:            }
06542:
06543:            public final IDirectDrawPaletteVtbl createIDirectDrawPaletteVtbl(
06544:                    VoidPointer base) {
06545:                return new IDirectDrawPaletteVtbl(base);
06546:            }
06547:
06548:            public final IDirectDrawPaletteVtbl createIDirectDrawPaletteVtbl(
06549:                    long addr) {
06550:                return new IDirectDrawPaletteVtbl(addr);
06551:            }
06552:
06553:            public static class IDirectDraw7Vtbl extends CommonStructWrapper {
06554:
06555:                public static final int sizeof = NativeBridge.is64 ? 240 : 120;
06556:
06557:                IDirectDraw7Vtbl(boolean direct) {
06558:                    super (sizeof, direct);
06559:                }
06560:
06561:                IDirectDraw7Vtbl(VoidPointer base) {
06562:                    super (base);
06563:                }
06564:
06565:                IDirectDraw7Vtbl(long addr) {
06566:                    super (addr);
06567:                }
06568:
06569:                public final void set_QueryInterface(long val) {
06570:                    byteBase.setAddress(0, val);
06571:                }
06572:
06573:                public final long get_QueryInterface() {
06574:                    return byteBase.getAddress(0);
06575:                }
06576:
06577:                public final int QueryInterface(Win32.IDirectDraw7 This,
06578:                        Win32.GUID riid, PointerPointer ppvObj) {
06579:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
06580:                    long tmp_1 = riid == null ? 0 : riid.longLockPointer();
06581:                    long tmp_2 = ppvObj == null ? 0 : ppvObj.longLockPointer();
06582:                    int tmp_ret = instance.proxycall38(get_QueryInterface(),
06583:                            tmp_0, tmp_1, tmp_2);
06584:                    if (This != null) {
06585:                        This.unlock();
06586:                    }
06587:                    if (riid != null) {
06588:                        riid.unlock();
06589:                    }
06590:                    if (ppvObj != null) {
06591:                        ppvObj.unlock();
06592:                    }
06593:                    return tmp_ret;
06594:                }
06595:
06596:                public final void set_AddRef(long val) {
06597:                    byteBase.setAddress(NativeBridge.is64 ? 8 : 4, val);
06598:                }
06599:
06600:                public final long get_AddRef() {
06601:                    return byteBase.getAddress(NativeBridge.is64 ? 8 : 4);
06602:                }
06603:
06604:                public final int AddRef(Win32.IDirectDraw7 This) {
06605:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
06606:                    int tmp_ret = instance.proxycall39(get_AddRef(), tmp_0);
06607:                    if (This != null) {
06608:                        This.unlock();
06609:                    }
06610:                    return tmp_ret;
06611:                }
06612:
06613:                public final void set_Release(long val) {
06614:                    byteBase.setAddress(NativeBridge.is64 ? 16 : 8, val);
06615:                }
06616:
06617:                public final long get_Release() {
06618:                    return byteBase.getAddress(NativeBridge.is64 ? 16 : 8);
06619:                }
06620:
06621:                public final int Release(Win32.IDirectDraw7 This) {
06622:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
06623:                    int tmp_ret = instance.proxycall40(get_Release(), tmp_0);
06624:                    if (This != null) {
06625:                        This.unlock();
06626:                    }
06627:                    return tmp_ret;
06628:                }
06629:
06630:                public final void set_Compact(long val) {
06631:                    byteBase.setAddress(NativeBridge.is64 ? 24 : 12, val);
06632:                }
06633:
06634:                public final long get_Compact() {
06635:                    return byteBase.getAddress(NativeBridge.is64 ? 24 : 12);
06636:                }
06637:
06638:                public final int Compact(Win32.IDirectDraw7 This) {
06639:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
06640:                    int tmp_ret = instance.proxycall41(get_Compact(), tmp_0);
06641:                    if (This != null) {
06642:                        This.unlock();
06643:                    }
06644:                    return tmp_ret;
06645:                }
06646:
06647:                public final void set_CreateClipper(long val) {
06648:                    byteBase.setAddress(NativeBridge.is64 ? 32 : 16, val);
06649:                }
06650:
06651:                public final long get_CreateClipper() {
06652:                    return byteBase.getAddress(NativeBridge.is64 ? 32 : 16);
06653:                }
06654:
06655:                public final int CreateClipper(Win32.IDirectDraw7 This,
06656:                        int param_1, PointerPointer param_2,
06657:                        Win32.IUnknown param_3) {
06658:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
06659:                    long tmp_1 = param_2 == null ? 0 : param_2
06660:                            .longLockPointer();
06661:                    long tmp_2 = param_3 == null ? 0 : param_3
06662:                            .longLockPointer();
06663:                    int tmp_ret = instance.proxycall42(get_CreateClipper(),
06664:                            tmp_0, param_1, tmp_1, tmp_2);
06665:                    if (This != null) {
06666:                        This.unlock();
06667:                    }
06668:                    if (param_2 != null) {
06669:                        param_2.unlock();
06670:                    }
06671:                    if (param_3 != null) {
06672:                        param_3.unlock();
06673:                    }
06674:                    return tmp_ret;
06675:                }
06676:
06677:                public final void set_CreatePalette(long val) {
06678:                    byteBase.setAddress(NativeBridge.is64 ? 40 : 20, val);
06679:                }
06680:
06681:                public final long get_CreatePalette() {
06682:                    return byteBase.getAddress(NativeBridge.is64 ? 40 : 20);
06683:                }
06684:
06685:                public final int CreatePalette(Win32.IDirectDraw7 This,
06686:                        int param_1, PALETTEENTRY param_2,
06687:                        PointerPointer param_3, Win32.IUnknown param_4) {
06688:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
06689:                    long tmp_1 = param_2 == null ? 0 : param_2
06690:                            .longLockPointer();
06691:                    long tmp_2 = param_3 == null ? 0 : param_3
06692:                            .longLockPointer();
06693:                    long tmp_3 = param_4 == null ? 0 : param_4
06694:                            .longLockPointer();
06695:                    int tmp_ret = instance.proxycall43(get_CreatePalette(),
06696:                            tmp_0, param_1, tmp_1, tmp_2, tmp_3);
06697:                    if (This != null) {
06698:                        This.unlock();
06699:                    }
06700:                    if (param_2 != null) {
06701:                        param_2.unlock();
06702:                    }
06703:                    if (param_3 != null) {
06704:                        param_3.unlock();
06705:                    }
06706:                    if (param_4 != null) {
06707:                        param_4.unlock();
06708:                    }
06709:                    return tmp_ret;
06710:                }
06711:
06712:                public final void set_CreateSurface(long val) {
06713:                    byteBase.setAddress(NativeBridge.is64 ? 48 : 24, val);
06714:                }
06715:
06716:                public final long get_CreateSurface() {
06717:                    return byteBase.getAddress(NativeBridge.is64 ? 48 : 24);
06718:                }
06719:
06720:                public final int CreateSurface(Win32.IDirectDraw7 This,
06721:                        DDSURFACEDESC2 param_1, PointerPointer param_2,
06722:                        Win32.IUnknown param_3) {
06723:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
06724:                    long tmp_1 = param_1 == null ? 0 : param_1
06725:                            .longLockPointer();
06726:                    long tmp_2 = param_2 == null ? 0 : param_2
06727:                            .longLockPointer();
06728:                    long tmp_3 = param_3 == null ? 0 : param_3
06729:                            .longLockPointer();
06730:                    int tmp_ret = instance.proxycall44(get_CreateSurface(),
06731:                            tmp_0, tmp_1, tmp_2, tmp_3);
06732:                    if (This != null) {
06733:                        This.unlock();
06734:                    }
06735:                    if (param_1 != null) {
06736:                        param_1.unlock();
06737:                    }
06738:                    if (param_2 != null) {
06739:                        param_2.unlock();
06740:                    }
06741:                    if (param_3 != null) {
06742:                        param_3.unlock();
06743:                    }
06744:                    return tmp_ret;
06745:                }
06746:
06747:                public final void set_DuplicateSurface(long val) {
06748:                    byteBase.setAddress(NativeBridge.is64 ? 56 : 28, val);
06749:                }
06750:
06751:                public final long get_DuplicateSurface() {
06752:                    return byteBase.getAddress(NativeBridge.is64 ? 56 : 28);
06753:                }
06754:
06755:                public final int DuplicateSurface(Win32.IDirectDraw7 This,
06756:                        IDirectDrawSurface7 param_1, PointerPointer param_2) {
06757:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
06758:                    long tmp_1 = param_1 == null ? 0 : param_1
06759:                            .longLockPointer();
06760:                    long tmp_2 = param_2 == null ? 0 : param_2
06761:                            .longLockPointer();
06762:                    int tmp_ret = instance.proxycall45(get_DuplicateSurface(),
06763:                            tmp_0, tmp_1, tmp_2);
06764:                    if (This != null) {
06765:                        This.unlock();
06766:                    }
06767:                    if (param_1 != null) {
06768:                        param_1.unlock();
06769:                    }
06770:                    if (param_2 != null) {
06771:                        param_2.unlock();
06772:                    }
06773:                    return tmp_ret;
06774:                }
06775:
06776:                public final void set_EnumDisplayModes(long val) {
06777:                    byteBase.setAddress(NativeBridge.is64 ? 64 : 32, val);
06778:                }
06779:
06780:                public final long get_EnumDisplayModes() {
06781:                    return byteBase.getAddress(NativeBridge.is64 ? 64 : 32);
06782:                }
06783:
06784:                public final int EnumDisplayModes(Win32.IDirectDraw7 This,
06785:                        int param_1, DDSURFACEDESC2 param_2,
06786:                        VoidPointer param_3, long param_4) {
06787:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
06788:                    long tmp_1 = param_2 == null ? 0 : param_2
06789:                            .longLockPointer();
06790:                    long tmp_2 = param_3 == null ? 0 : param_3
06791:                            .longLockPointer();
06792:                    int tmp_ret = instance.proxycall46(get_EnumDisplayModes(),
06793:                            tmp_0, param_1, tmp_1, tmp_2, param_4);
06794:                    if (This != null) {
06795:                        This.unlock();
06796:                    }
06797:                    if (param_2 != null) {
06798:                        param_2.unlock();
06799:                    }
06800:                    if (param_3 != null) {
06801:                        param_3.unlock();
06802:                    }
06803:                    return tmp_ret;
06804:                }
06805:
06806:                public final void set_EnumSurfaces(long val) {
06807:                    byteBase.setAddress(NativeBridge.is64 ? 72 : 36, val);
06808:                }
06809:
06810:                public final long get_EnumSurfaces() {
06811:                    return byteBase.getAddress(NativeBridge.is64 ? 72 : 36);
06812:                }
06813:
06814:                public final int EnumSurfaces(Win32.IDirectDraw7 This,
06815:                        int param_1, DDSURFACEDESC2 param_2,
06816:                        VoidPointer param_3, long param_4) {
06817:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
06818:                    long tmp_1 = param_2 == null ? 0 : param_2
06819:                            .longLockPointer();
06820:                    long tmp_2 = param_3 == null ? 0 : param_3
06821:                            .longLockPointer();
06822:                    int tmp_ret = instance.proxycall47(get_EnumSurfaces(),
06823:                            tmp_0, param_1, tmp_1, tmp_2, param_4);
06824:                    if (This != null) {
06825:                        This.unlock();
06826:                    }
06827:                    if (param_2 != null) {
06828:                        param_2.unlock();
06829:                    }
06830:                    if (param_3 != null) {
06831:                        param_3.unlock();
06832:                    }
06833:                    return tmp_ret;
06834:                }
06835:
06836:                public final void set_FlipToGDISurface(long val) {
06837:                    byteBase.setAddress(NativeBridge.is64 ? 80 : 40, val);
06838:                }
06839:
06840:                public final long get_FlipToGDISurface() {
06841:                    return byteBase.getAddress(NativeBridge.is64 ? 80 : 40);
06842:                }
06843:
06844:                public final int FlipToGDISurface(Win32.IDirectDraw7 This) {
06845:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
06846:                    int tmp_ret = instance.proxycall48(get_FlipToGDISurface(),
06847:                            tmp_0);
06848:                    if (This != null) {
06849:                        This.unlock();
06850:                    }
06851:                    return tmp_ret;
06852:                }
06853:
06854:                public final void set_GetCaps(long val) {
06855:                    byteBase.setAddress(NativeBridge.is64 ? 88 : 44, val);
06856:                }
06857:
06858:                public final long get_GetCaps() {
06859:                    return byteBase.getAddress(NativeBridge.is64 ? 88 : 44);
06860:                }
06861:
06862:                public final int GetCaps(Win32.IDirectDraw7 This,
06863:                        DDCAPS_DX7 param_1, DDCAPS_DX7 param_2) {
06864:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
06865:                    long tmp_1 = param_1 == null ? 0 : param_1
06866:                            .longLockPointer();
06867:                    long tmp_2 = param_2 == null ? 0 : param_2
06868:                            .longLockPointer();
06869:                    int tmp_ret = instance.proxycall49(get_GetCaps(), tmp_0,
06870:                            tmp_1, tmp_2);
06871:                    if (This != null) {
06872:                        This.unlock();
06873:                    }
06874:                    if (param_1 != null) {
06875:                        param_1.unlock();
06876:                    }
06877:                    if (param_2 != null) {
06878:                        param_2.unlock();
06879:                    }
06880:                    return tmp_ret;
06881:                }
06882:
06883:                public final void set_GetDisplayMode(long val) {
06884:                    byteBase.setAddress(NativeBridge.is64 ? 96 : 48, val);
06885:                }
06886:
06887:                public final long get_GetDisplayMode() {
06888:                    return byteBase.getAddress(NativeBridge.is64 ? 96 : 48);
06889:                }
06890:
06891:                public final int GetDisplayMode(Win32.IDirectDraw7 This,
06892:                        DDSURFACEDESC2 param_1) {
06893:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
06894:                    long tmp_1 = param_1 == null ? 0 : param_1
06895:                            .longLockPointer();
06896:                    int tmp_ret = instance.proxycall50(get_GetDisplayMode(),
06897:                            tmp_0, tmp_1);
06898:                    if (This != null) {
06899:                        This.unlock();
06900:                    }
06901:                    if (param_1 != null) {
06902:                        param_1.unlock();
06903:                    }
06904:                    return tmp_ret;
06905:                }
06906:
06907:                public final void set_GetFourCCCodes(long val) {
06908:                    byteBase.setAddress(NativeBridge.is64 ? 104 : 52, val);
06909:                }
06910:
06911:                public final long get_GetFourCCCodes() {
06912:                    return byteBase.getAddress(NativeBridge.is64 ? 104 : 52);
06913:                }
06914:
06915:                public final int GetFourCCCodes(Win32.IDirectDraw7 This,
06916:                        Int32Pointer param_1, Int32Pointer param_2) {
06917:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
06918:                    long tmp_1 = param_1 == null ? 0 : param_1
06919:                            .longLockPointer();
06920:                    long tmp_2 = param_2 == null ? 0 : param_2
06921:                            .longLockPointer();
06922:                    int tmp_ret = instance.proxycall51(get_GetFourCCCodes(),
06923:                            tmp_0, tmp_1, tmp_2);
06924:                    if (This != null) {
06925:                        This.unlock();
06926:                    }
06927:                    if (param_1 != null) {
06928:                        param_1.unlock();
06929:                    }
06930:                    if (param_2 != null) {
06931:                        param_2.unlock();
06932:                    }
06933:                    return tmp_ret;
06934:                }
06935:
06936:                public final void set_GetGDISurface(long val) {
06937:                    byteBase.setAddress(NativeBridge.is64 ? 112 : 56, val);
06938:                }
06939:
06940:                public final long get_GetGDISurface() {
06941:                    return byteBase.getAddress(NativeBridge.is64 ? 112 : 56);
06942:                }
06943:
06944:                public final int GetGDISurface(Win32.IDirectDraw7 This,
06945:                        PointerPointer param_1) {
06946:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
06947:                    long tmp_1 = param_1 == null ? 0 : param_1
06948:                            .longLockPointer();
06949:                    int tmp_ret = instance.proxycall52(get_GetGDISurface(),
06950:                            tmp_0, tmp_1);
06951:                    if (This != null) {
06952:                        This.unlock();
06953:                    }
06954:                    if (param_1 != null) {
06955:                        param_1.unlock();
06956:                    }
06957:                    return tmp_ret;
06958:                }
06959:
06960:                public final void set_GetMonitorFrequency(long val) {
06961:                    byteBase.setAddress(NativeBridge.is64 ? 120 : 60, val);
06962:                }
06963:
06964:                public final long get_GetMonitorFrequency() {
06965:                    return byteBase.getAddress(NativeBridge.is64 ? 120 : 60);
06966:                }
06967:
06968:                public final int GetMonitorFrequency(Win32.IDirectDraw7 This,
06969:                        Int32Pointer param_1) {
06970:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
06971:                    long tmp_1 = param_1 == null ? 0 : param_1
06972:                            .longLockPointer();
06973:                    int tmp_ret = instance.proxycall53(
06974:                            get_GetMonitorFrequency(), tmp_0, tmp_1);
06975:                    if (This != null) {
06976:                        This.unlock();
06977:                    }
06978:                    if (param_1 != null) {
06979:                        param_1.unlock();
06980:                    }
06981:                    return tmp_ret;
06982:                }
06983:
06984:                public final void set_GetScanLine(long val) {
06985:                    byteBase.setAddress(NativeBridge.is64 ? 128 : 64, val);
06986:                }
06987:
06988:                public final long get_GetScanLine() {
06989:                    return byteBase.getAddress(NativeBridge.is64 ? 128 : 64);
06990:                }
06991:
06992:                public final int GetScanLine(Win32.IDirectDraw7 This,
06993:                        Int32Pointer param_1) {
06994:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
06995:                    long tmp_1 = param_1 == null ? 0 : param_1
06996:                            .longLockPointer();
06997:                    int tmp_ret = instance.proxycall54(get_GetScanLine(),
06998:                            tmp_0, tmp_1);
06999:                    if (This != null) {
07000:                        This.unlock();
07001:                    }
07002:                    if (param_1 != null) {
07003:                        param_1.unlock();
07004:                    }
07005:                    return tmp_ret;
07006:                }
07007:
07008:                public final void set_GetVerticalBlankStatus(long val) {
07009:                    byteBase.setAddress(NativeBridge.is64 ? 136 : 68, val);
07010:                }
07011:
07012:                public final long get_GetVerticalBlankStatus() {
07013:                    return byteBase.getAddress(NativeBridge.is64 ? 136 : 68);
07014:                }
07015:
07016:                public final int GetVerticalBlankStatus(
07017:                        Win32.IDirectDraw7 This, Int32Pointer param_1) {
07018:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07019:                    long tmp_1 = param_1 == null ? 0 : param_1
07020:                            .longLockPointer();
07021:                    int tmp_ret = instance.proxycall55(
07022:                            get_GetVerticalBlankStatus(), tmp_0, tmp_1);
07023:                    if (This != null) {
07024:                        This.unlock();
07025:                    }
07026:                    if (param_1 != null) {
07027:                        param_1.unlock();
07028:                    }
07029:                    return tmp_ret;
07030:                }
07031:
07032:                public final void set_Initialize(long val) {
07033:                    byteBase.setAddress(NativeBridge.is64 ? 144 : 72, val);
07034:                }
07035:
07036:                public final long get_Initialize() {
07037:                    return byteBase.getAddress(NativeBridge.is64 ? 144 : 72);
07038:                }
07039:
07040:                public final int Initialize(Win32.IDirectDraw7 This,
07041:                        Win32.GUID param_1) {
07042:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07043:                    long tmp_1 = param_1 == null ? 0 : param_1
07044:                            .longLockPointer();
07045:                    int tmp_ret = instance.proxycall56(get_Initialize(), tmp_0,
07046:                            tmp_1);
07047:                    if (This != null) {
07048:                        This.unlock();
07049:                    }
07050:                    if (param_1 != null) {
07051:                        param_1.unlock();
07052:                    }
07053:                    return tmp_ret;
07054:                }
07055:
07056:                public final void set_RestoreDisplayMode(long val) {
07057:                    byteBase.setAddress(NativeBridge.is64 ? 152 : 76, val);
07058:                }
07059:
07060:                public final long get_RestoreDisplayMode() {
07061:                    return byteBase.getAddress(NativeBridge.is64 ? 152 : 76);
07062:                }
07063:
07064:                public final int RestoreDisplayMode(Win32.IDirectDraw7 This) {
07065:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07066:                    int tmp_ret = instance.proxycall57(
07067:                            get_RestoreDisplayMode(), tmp_0);
07068:                    if (This != null) {
07069:                        This.unlock();
07070:                    }
07071:                    return tmp_ret;
07072:                }
07073:
07074:                public final void set_SetCooperativeLevel(long val) {
07075:                    byteBase.setAddress(NativeBridge.is64 ? 160 : 80, val);
07076:                }
07077:
07078:                public final long get_SetCooperativeLevel() {
07079:                    return byteBase.getAddress(NativeBridge.is64 ? 160 : 80);
07080:                }
07081:
07082:                public final int SetCooperativeLevel(Win32.IDirectDraw7 This,
07083:                        long param_1, int param_2) {
07084:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07085:                    int tmp_ret = instance.proxycall58(
07086:                            get_SetCooperativeLevel(), tmp_0, param_1, param_2);
07087:                    if (This != null) {
07088:                        This.unlock();
07089:                    }
07090:                    return tmp_ret;
07091:                }
07092:
07093:                public final void set_SetDisplayMode(long val) {
07094:                    byteBase.setAddress(NativeBridge.is64 ? 168 : 84, val);
07095:                }
07096:
07097:                public final long get_SetDisplayMode() {
07098:                    return byteBase.getAddress(NativeBridge.is64 ? 168 : 84);
07099:                }
07100:
07101:                public final int SetDisplayMode(Win32.IDirectDraw7 This,
07102:                        int param_1, int param_2, int param_3, int param_4,
07103:                        int param_5) {
07104:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07105:                    int tmp_ret = instance.proxycall59(get_SetDisplayMode(),
07106:                            tmp_0, param_1, param_2, param_3, param_4, param_5);
07107:                    if (This != null) {
07108:                        This.unlock();
07109:                    }
07110:                    return tmp_ret;
07111:                }
07112:
07113:                public final void set_WaitForVerticalBlank(long val) {
07114:                    byteBase.setAddress(NativeBridge.is64 ? 176 : 88, val);
07115:                }
07116:
07117:                public final long get_WaitForVerticalBlank() {
07118:                    return byteBase.getAddress(NativeBridge.is64 ? 176 : 88);
07119:                }
07120:
07121:                public final int WaitForVerticalBlank(Win32.IDirectDraw7 This,
07122:                        int param_1, VoidPointer param_2) {
07123:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07124:                    long tmp_1 = param_2 == null ? 0 : param_2
07125:                            .longLockPointer();
07126:                    int tmp_ret = instance.proxycall60(
07127:                            get_WaitForVerticalBlank(), tmp_0, param_1, tmp_1);
07128:                    if (This != null) {
07129:                        This.unlock();
07130:                    }
07131:                    if (param_2 != null) {
07132:                        param_2.unlock();
07133:                    }
07134:                    return tmp_ret;
07135:                }
07136:
07137:                public final void set_GetAvailableVidMem(long val) {
07138:                    byteBase.setAddress(NativeBridge.is64 ? 184 : 92, val);
07139:                }
07140:
07141:                public final long get_GetAvailableVidMem() {
07142:                    return byteBase.getAddress(NativeBridge.is64 ? 184 : 92);
07143:                }
07144:
07145:                public final int GetAvailableVidMem(Win32.IDirectDraw7 This,
07146:                        DDSCAPS2 param_1, Int32Pointer param_2,
07147:                        Int32Pointer param_3) {
07148:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07149:                    long tmp_1 = param_1 == null ? 0 : param_1
07150:                            .longLockPointer();
07151:                    long tmp_2 = param_2 == null ? 0 : param_2
07152:                            .longLockPointer();
07153:                    long tmp_3 = param_3 == null ? 0 : param_3
07154:                            .longLockPointer();
07155:                    int tmp_ret = instance.proxycall61(
07156:                            get_GetAvailableVidMem(), tmp_0, tmp_1, tmp_2,
07157:                            tmp_3);
07158:                    if (This != null) {
07159:                        This.unlock();
07160:                    }
07161:                    if (param_1 != null) {
07162:                        param_1.unlock();
07163:                    }
07164:                    if (param_2 != null) {
07165:                        param_2.unlock();
07166:                    }
07167:                    if (param_3 != null) {
07168:                        param_3.unlock();
07169:                    }
07170:                    return tmp_ret;
07171:                }
07172:
07173:                public final void set_GetSurfaceFromDC(long val) {
07174:                    byteBase.setAddress(NativeBridge.is64 ? 192 : 96, val);
07175:                }
07176:
07177:                public final long get_GetSurfaceFromDC() {
07178:                    return byteBase.getAddress(NativeBridge.is64 ? 192 : 96);
07179:                }
07180:
07181:                public final int GetSurfaceFromDC(Win32.IDirectDraw7 This,
07182:                        long param_1, PointerPointer param_2) {
07183:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07184:                    long tmp_1 = param_2 == null ? 0 : param_2
07185:                            .longLockPointer();
07186:                    int tmp_ret = instance.proxycall62(get_GetSurfaceFromDC(),
07187:                            tmp_0, param_1, tmp_1);
07188:                    if (This != null) {
07189:                        This.unlock();
07190:                    }
07191:                    if (param_2 != null) {
07192:                        param_2.unlock();
07193:                    }
07194:                    return tmp_ret;
07195:                }
07196:
07197:                public final void set_RestoreAllSurfaces(long val) {
07198:                    byteBase.setAddress(NativeBridge.is64 ? 200 : 100, val);
07199:                }
07200:
07201:                public final long get_RestoreAllSurfaces() {
07202:                    return byteBase.getAddress(NativeBridge.is64 ? 200 : 100);
07203:                }
07204:
07205:                public final int RestoreAllSurfaces(Win32.IDirectDraw7 This) {
07206:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07207:                    int tmp_ret = instance.proxycall63(
07208:                            get_RestoreAllSurfaces(), tmp_0);
07209:                    if (This != null) {
07210:                        This.unlock();
07211:                    }
07212:                    return tmp_ret;
07213:                }
07214:
07215:                public final void set_TestCooperativeLevel(long val) {
07216:                    byteBase.setAddress(NativeBridge.is64 ? 208 : 104, val);
07217:                }
07218:
07219:                public final long get_TestCooperativeLevel() {
07220:                    return byteBase.getAddress(NativeBridge.is64 ? 208 : 104);
07221:                }
07222:
07223:                public final int TestCooperativeLevel(Win32.IDirectDraw7 This) {
07224:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07225:                    int tmp_ret = instance.proxycall64(
07226:                            get_TestCooperativeLevel(), tmp_0);
07227:                    if (This != null) {
07228:                        This.unlock();
07229:                    }
07230:                    return tmp_ret;
07231:                }
07232:
07233:                public final void set_GetDeviceIdentifier(long val) {
07234:                    byteBase.setAddress(NativeBridge.is64 ? 216 : 108, val);
07235:                }
07236:
07237:                public final long get_GetDeviceIdentifier() {
07238:                    return byteBase.getAddress(NativeBridge.is64 ? 216 : 108);
07239:                }
07240:
07241:                public final int GetDeviceIdentifier(Win32.IDirectDraw7 This,
07242:                        DDDEVICEIDENTIFIER2 param_1, int param_2) {
07243:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07244:                    long tmp_1 = param_1 == null ? 0 : param_1
07245:                            .longLockPointer();
07246:                    int tmp_ret = instance.proxycall65(
07247:                            get_GetDeviceIdentifier(), tmp_0, tmp_1, param_2);
07248:                    if (This != null) {
07249:                        This.unlock();
07250:                    }
07251:                    if (param_1 != null) {
07252:                        param_1.unlock();
07253:                    }
07254:                    return tmp_ret;
07255:                }
07256:
07257:                public final void set_StartModeTest(long val) {
07258:                    byteBase.setAddress(NativeBridge.is64 ? 224 : 112, val);
07259:                }
07260:
07261:                public final long get_StartModeTest() {
07262:                    return byteBase.getAddress(NativeBridge.is64 ? 224 : 112);
07263:                }
07264:
07265:                public final int StartModeTest(Win32.IDirectDraw7 This,
07266:                        SIZE param_1, int param_2, int param_3) {
07267:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07268:                    long tmp_1 = param_1 == null ? 0 : param_1
07269:                            .longLockPointer();
07270:                    int tmp_ret = instance.proxycall66(get_StartModeTest(),
07271:                            tmp_0, tmp_1, param_2, param_3);
07272:                    if (This != null) {
07273:                        This.unlock();
07274:                    }
07275:                    if (param_1 != null) {
07276:                        param_1.unlock();
07277:                    }
07278:                    return tmp_ret;
07279:                }
07280:
07281:                public final void set_EvaluateMode(long val) {
07282:                    byteBase.setAddress(NativeBridge.is64 ? 232 : 116, val);
07283:                }
07284:
07285:                public final long get_EvaluateMode() {
07286:                    return byteBase.getAddress(NativeBridge.is64 ? 232 : 116);
07287:                }
07288:
07289:                public final int EvaluateMode(Win32.IDirectDraw7 This,
07290:                        int param_1, Int32Pointer param_2) {
07291:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07292:                    long tmp_1 = param_2 == null ? 0 : param_2
07293:                            .longLockPointer();
07294:                    int tmp_ret = instance.proxycall67(get_EvaluateMode(),
07295:                            tmp_0, param_1, tmp_1);
07296:                    if (This != null) {
07297:                        This.unlock();
07298:                    }
07299:                    if (param_2 != null) {
07300:                        param_2.unlock();
07301:                    }
07302:                    return tmp_ret;
07303:                }
07304:
07305:                @Override
07306:                public int size() {
07307:                    return sizeof;
07308:                }
07309:            }
07310:
07311:            public final IDirectDraw7Vtbl createIDirectDraw7Vtbl(boolean direct) {
07312:                return new IDirectDraw7Vtbl(direct);
07313:            }
07314:
07315:            public final IDirectDraw7Vtbl createIDirectDraw7Vtbl(
07316:                    VoidPointer base) {
07317:                return new IDirectDraw7Vtbl(base);
07318:            }
07319:
07320:            public final IDirectDraw7Vtbl createIDirectDraw7Vtbl(long addr) {
07321:                return new IDirectDraw7Vtbl(addr);
07322:            }
07323:
07324:            public static class IDirectDrawClipperVtbl extends
07325:                    CommonStructWrapper {
07326:
07327:                public static final int sizeof = NativeBridge.is64 ? 72 : 36;
07328:
07329:                IDirectDrawClipperVtbl(boolean direct) {
07330:                    super (sizeof, direct);
07331:                }
07332:
07333:                IDirectDrawClipperVtbl(VoidPointer base) {
07334:                    super (base);
07335:                }
07336:
07337:                IDirectDrawClipperVtbl(long addr) {
07338:                    super (addr);
07339:                }
07340:
07341:                public final void set_QueryInterface(long val) {
07342:                    byteBase.setAddress(0, val);
07343:                }
07344:
07345:                public final long get_QueryInterface() {
07346:                    return byteBase.getAddress(0);
07347:                }
07348:
07349:                public final int QueryInterface(Win32.IDirectDrawClipper This,
07350:                        Win32.GUID riid, PointerPointer ppvObj) {
07351:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07352:                    long tmp_1 = riid == null ? 0 : riid.longLockPointer();
07353:                    long tmp_2 = ppvObj == null ? 0 : ppvObj.longLockPointer();
07354:                    int tmp_ret = instance.proxycall68(get_QueryInterface(),
07355:                            tmp_0, tmp_1, tmp_2);
07356:                    if (This != null) {
07357:                        This.unlock();
07358:                    }
07359:                    if (riid != null) {
07360:                        riid.unlock();
07361:                    }
07362:                    if (ppvObj != null) {
07363:                        ppvObj.unlock();
07364:                    }
07365:                    return tmp_ret;
07366:                }
07367:
07368:                public final void set_AddRef(long val) {
07369:                    byteBase.setAddress(NativeBridge.is64 ? 8 : 4, val);
07370:                }
07371:
07372:                public final long get_AddRef() {
07373:                    return byteBase.getAddress(NativeBridge.is64 ? 8 : 4);
07374:                }
07375:
07376:                public final int AddRef(Win32.IDirectDrawClipper This) {
07377:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07378:                    int tmp_ret = instance.proxycall69(get_AddRef(), tmp_0);
07379:                    if (This != null) {
07380:                        This.unlock();
07381:                    }
07382:                    return tmp_ret;
07383:                }
07384:
07385:                public final void set_Release(long val) {
07386:                    byteBase.setAddress(NativeBridge.is64 ? 16 : 8, val);
07387:                }
07388:
07389:                public final long get_Release() {
07390:                    return byteBase.getAddress(NativeBridge.is64 ? 16 : 8);
07391:                }
07392:
07393:                public final int Release(Win32.IDirectDrawClipper This) {
07394:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07395:                    int tmp_ret = instance.proxycall70(get_Release(), tmp_0);
07396:                    if (This != null) {
07397:                        This.unlock();
07398:                    }
07399:                    return tmp_ret;
07400:                }
07401:
07402:                public final void set_GetClipList(long val) {
07403:                    byteBase.setAddress(NativeBridge.is64 ? 24 : 12, val);
07404:                }
07405:
07406:                public final long get_GetClipList() {
07407:                    return byteBase.getAddress(NativeBridge.is64 ? 24 : 12);
07408:                }
07409:
07410:                public final int GetClipList(Win32.IDirectDrawClipper This,
07411:                        Win32.RECT param_1, Win32.RGNDATA param_2,
07412:                        Int32Pointer param_3) {
07413:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07414:                    long tmp_1 = param_1 == null ? 0 : param_1
07415:                            .longLockPointer();
07416:                    long tmp_2 = param_2 == null ? 0 : param_2
07417:                            .longLockPointer();
07418:                    long tmp_3 = param_3 == null ? 0 : param_3
07419:                            .longLockPointer();
07420:                    int tmp_ret = instance.proxycall71(get_GetClipList(),
07421:                            tmp_0, tmp_1, tmp_2, tmp_3);
07422:                    if (This != null) {
07423:                        This.unlock();
07424:                    }
07425:                    if (param_1 != null) {
07426:                        param_1.unlock();
07427:                    }
07428:                    if (param_2 != null) {
07429:                        param_2.unlock();
07430:                    }
07431:                    if (param_3 != null) {
07432:                        param_3.unlock();
07433:                    }
07434:                    return tmp_ret;
07435:                }
07436:
07437:                public final void set_GetHWnd(long val) {
07438:                    byteBase.setAddress(NativeBridge.is64 ? 32 : 16, val);
07439:                }
07440:
07441:                public final long get_GetHWnd() {
07442:                    return byteBase.getAddress(NativeBridge.is64 ? 32 : 16);
07443:                }
07444:
07445:                public final int GetHWnd(Win32.IDirectDrawClipper This,
07446:                        PointerPointer param_1) {
07447:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07448:                    long tmp_1 = param_1 == null ? 0 : param_1
07449:                            .longLockPointer();
07450:                    int tmp_ret = instance.proxycall72(get_GetHWnd(), tmp_0,
07451:                            tmp_1);
07452:                    if (This != null) {
07453:                        This.unlock();
07454:                    }
07455:                    if (param_1 != null) {
07456:                        param_1.unlock();
07457:                    }
07458:                    return tmp_ret;
07459:                }
07460:
07461:                public final void set_Initialize(long val) {
07462:                    byteBase.setAddress(NativeBridge.is64 ? 40 : 20, val);
07463:                }
07464:
07465:                public final long get_Initialize() {
07466:                    return byteBase.getAddress(NativeBridge.is64 ? 40 : 20);
07467:                }
07468:
07469:                public final int Initialize(Win32.IDirectDrawClipper This,
07470:                        Win32.IDirectDraw param_1, int param_2) {
07471:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07472:                    long tmp_1 = param_1 == null ? 0 : param_1
07473:                            .longLockPointer();
07474:                    int tmp_ret = instance.proxycall73(get_Initialize(), tmp_0,
07475:                            tmp_1, param_2);
07476:                    if (This != null) {
07477:                        This.unlock();
07478:                    }
07479:                    if (param_1 != null) {
07480:                        param_1.unlock();
07481:                    }
07482:                    return tmp_ret;
07483:                }
07484:
07485:                public final void set_IsClipListChanged(long val) {
07486:                    byteBase.setAddress(NativeBridge.is64 ? 48 : 24, val);
07487:                }
07488:
07489:                public final long get_IsClipListChanged() {
07490:                    return byteBase.getAddress(NativeBridge.is64 ? 48 : 24);
07491:                }
07492:
07493:                public final int IsClipListChanged(
07494:                        Win32.IDirectDrawClipper This, Int32Pointer param_1) {
07495:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07496:                    long tmp_1 = param_1 == null ? 0 : param_1
07497:                            .longLockPointer();
07498:                    int tmp_ret = instance.proxycall74(get_IsClipListChanged(),
07499:                            tmp_0, tmp_1);
07500:                    if (This != null) {
07501:                        This.unlock();
07502:                    }
07503:                    if (param_1 != null) {
07504:                        param_1.unlock();
07505:                    }
07506:                    return tmp_ret;
07507:                }
07508:
07509:                public final void set_SetClipList(long val) {
07510:                    byteBase.setAddress(NativeBridge.is64 ? 56 : 28, val);
07511:                }
07512:
07513:                public final long get_SetClipList() {
07514:                    return byteBase.getAddress(NativeBridge.is64 ? 56 : 28);
07515:                }
07516:
07517:                public final int SetClipList(Win32.IDirectDrawClipper This,
07518:                        Win32.RGNDATA param_1, int param_2) {
07519:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07520:                    long tmp_1 = param_1 == null ? 0 : param_1
07521:                            .longLockPointer();
07522:                    int tmp_ret = instance.proxycall75(get_SetClipList(),
07523:                            tmp_0, tmp_1, param_2);
07524:                    if (This != null) {
07525:                        This.unlock();
07526:                    }
07527:                    if (param_1 != null) {
07528:                        param_1.unlock();
07529:                    }
07530:                    return tmp_ret;
07531:                }
07532:
07533:                public final void set_SetHWnd(long val) {
07534:                    byteBase.setAddress(NativeBridge.is64 ? 64 : 32, val);
07535:                }
07536:
07537:                public final long get_SetHWnd() {
07538:                    return byteBase.getAddress(NativeBridge.is64 ? 64 : 32);
07539:                }
07540:
07541:                public final int SetHWnd(Win32.IDirectDrawClipper This,
07542:                        int param_1, long param_2) {
07543:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07544:                    int tmp_ret = instance.proxycall76(get_SetHWnd(), tmp_0,
07545:                            param_1, param_2);
07546:                    if (This != null) {
07547:                        This.unlock();
07548:                    }
07549:                    return tmp_ret;
07550:                }
07551:
07552:                @Override
07553:                public int size() {
07554:                    return sizeof;
07555:                }
07556:            }
07557:
07558:            public final IDirectDrawClipperVtbl createIDirectDrawClipperVtbl(
07559:                    boolean direct) {
07560:                return new IDirectDrawClipperVtbl(direct);
07561:            }
07562:
07563:            public final IDirectDrawClipperVtbl createIDirectDrawClipperVtbl(
07564:                    VoidPointer base) {
07565:                return new IDirectDrawClipperVtbl(base);
07566:            }
07567:
07568:            public final IDirectDrawClipperVtbl createIDirectDrawClipperVtbl(
07569:                    long addr) {
07570:                return new IDirectDrawClipperVtbl(addr);
07571:            }
07572:
07573:            public static class DDSCAPS2 extends CommonStructWrapper {
07574:
07575:                public static final int sizeof = 16;
07576:
07577:                DDSCAPS2(boolean direct) {
07578:                    super (sizeof, direct);
07579:                }
07580:
07581:                DDSCAPS2(VoidPointer base) {
07582:                    super (base);
07583:                }
07584:
07585:                DDSCAPS2(long addr) {
07586:                    super (addr);
07587:                }
07588:
07589:                public final void set_dwCaps(int val) {
07590:                    byteBase.setInt32(0, val);
07591:                }
07592:
07593:                public final int get_dwCaps() {
07594:                    return byteBase.getInt32(0);
07595:                }
07596:
07597:                public final void set_dwCaps2(int val) {
07598:                    byteBase.setInt32(4, val);
07599:                }
07600:
07601:                public final int get_dwCaps2() {
07602:                    return byteBase.getInt32(4);
07603:                }
07604:
07605:                public final void set_dwCaps3(int val) {
07606:                    byteBase.setInt32(8, val);
07607:                }
07608:
07609:                public final int get_dwCaps3() {
07610:                    return byteBase.getInt32(8);
07611:                }
07612:
07613:                public final void set_dwCaps4(int val) {
07614:                    byteBase.setInt32(12, val);
07615:                }
07616:
07617:                public final int get_dwCaps4() {
07618:                    return byteBase.getInt32(12);
07619:                }
07620:
07621:                public final void set_dwVolumeDepth(int val) {
07622:                    byteBase.setInt32(12, val);
07623:                }
07624:
07625:                public final int get_dwVolumeDepth() {
07626:                    return byteBase.getInt32(12);
07627:                }
07628:
07629:                @Override
07630:                public int size() {
07631:                    return sizeof;
07632:                }
07633:            }
07634:
07635:            public final DDSCAPS2 createDDSCAPS2(boolean direct) {
07636:                return new DDSCAPS2(direct);
07637:            }
07638:
07639:            public final DDSCAPS2 createDDSCAPS2(VoidPointer base) {
07640:                return new DDSCAPS2(base);
07641:            }
07642:
07643:            public final DDSCAPS2 createDDSCAPS2(long addr) {
07644:                return new DDSCAPS2(addr);
07645:            }
07646:
07647:            public static class DDSURFACEDESC extends CommonStructWrapper {
07648:
07649:                public static final int sizeof = NativeBridge.is64 ? 120 : 108;
07650:
07651:                DDSURFACEDESC(boolean direct) {
07652:                    super (sizeof, direct);
07653:                }
07654:
07655:                DDSURFACEDESC(VoidPointer base) {
07656:                    super (base);
07657:                }
07658:
07659:                DDSURFACEDESC(long addr) {
07660:                    super (addr);
07661:                }
07662:
07663:                public final void set_dwSize(int val) {
07664:                    byteBase.setInt32(0, val);
07665:                }
07666:
07667:                public final int get_dwSize() {
07668:                    return byteBase.getInt32(0);
07669:                }
07670:
07671:                public final void set_dwFlags(int val) {
07672:                    byteBase.setInt32(4, val);
07673:                }
07674:
07675:                public final int get_dwFlags() {
07676:                    return byteBase.getInt32(4);
07677:                }
07678:
07679:                public final void set_dwHeight(int val) {
07680:                    byteBase.setInt32(8, val);
07681:                }
07682:
07683:                public final int get_dwHeight() {
07684:                    return byteBase.getInt32(8);
07685:                }
07686:
07687:                public final void set_dwWidth(int val) {
07688:                    byteBase.setInt32(12, val);
07689:                }
07690:
07691:                public final int get_dwWidth() {
07692:                    return byteBase.getInt32(12);
07693:                }
07694:
07695:                public final void set_lPitch(int val) {
07696:                    byteBase.setInt32(16, val);
07697:                }
07698:
07699:                public final int get_lPitch() {
07700:                    return byteBase.getInt32(16);
07701:                }
07702:
07703:                public final void set_dwLinearSize(int val) {
07704:                    byteBase.setInt32(16, val);
07705:                }
07706:
07707:                public final int get_dwLinearSize() {
07708:                    return byteBase.getInt32(16);
07709:                }
07710:
07711:                public final void set_dwBackBufferCount(int val) {
07712:                    byteBase.setInt32(20, val);
07713:                }
07714:
07715:                public final int get_dwBackBufferCount() {
07716:                    return byteBase.getInt32(20);
07717:                }
07718:
07719:                public final void set_dwMipMapCount(int val) {
07720:                    byteBase.setInt32(24, val);
07721:                }
07722:
07723:                public final int get_dwMipMapCount() {
07724:                    return byteBase.getInt32(24);
07725:                }
07726:
07727:                public final void set_dwZBufferBitDepth(int val) {
07728:                    byteBase.setInt32(24, val);
07729:                }
07730:
07731:                public final int get_dwZBufferBitDepth() {
07732:                    return byteBase.getInt32(24);
07733:                }
07734:
07735:                public final void set_dwRefreshRate(int val) {
07736:                    byteBase.setInt32(24, val);
07737:                }
07738:
07739:                public final int get_dwRefreshRate() {
07740:                    return byteBase.getInt32(24);
07741:                }
07742:
07743:                public final void set_dwAlphaBitDepth(int val) {
07744:                    byteBase.setInt32(28, val);
07745:                }
07746:
07747:                public final int get_dwAlphaBitDepth() {
07748:                    return byteBase.getInt32(28);
07749:                }
07750:
07751:                public final void set_dwReserved(int val) {
07752:                    byteBase.setInt32(32, val);
07753:                }
07754:
07755:                public final int get_dwReserved() {
07756:                    return byteBase.getInt32(32);
07757:                }
07758:
07759:                public final void set_lpSurface(VoidPointer val) {
07760:                    byteBase.setPointer(NativeBridge.is64 ? 40 : 36, val);
07761:                }
07762:
07763:                public final VoidPointer get_lpSurface() {
07764:                    return nb.createInt8Pointer(byteBase
07765:                            .getAddress(NativeBridge.is64 ? 40 : 36));
07766:                }
07767:
07768:                public final DDCOLORKEY get_ddckCKDestOverlay() {
07769:                    return instance
07770:                            .createDDCOLORKEY(getElementPointer(NativeBridge.is64 ? 48
07771:                                    : 40));
07772:                }
07773:
07774:                public final DDCOLORKEY get_ddckCKDestBlt() {
07775:                    return instance
07776:                            .createDDCOLORKEY(getElementPointer(NativeBridge.is64 ? 56
07777:                                    : 48));
07778:                }
07779:
07780:                public final DDCOLORKEY get_ddckCKSrcOverlay() {
07781:                    return instance
07782:                            .createDDCOLORKEY(getElementPointer(NativeBridge.is64 ? 64
07783:                                    : 56));
07784:                }
07785:
07786:                public final DDCOLORKEY get_ddckCKSrcBlt() {
07787:                    return instance
07788:                            .createDDCOLORKEY(getElementPointer(NativeBridge.is64 ? 72
07789:                                    : 64));
07790:                }
07791:
07792:                public final DDPIXELFORMAT get_ddpfPixelFormat() {
07793:                    return instance
07794:                            .createDDPIXELFORMAT(getElementPointer(NativeBridge.is64 ? 80
07795:                                    : 72));
07796:                }
07797:
07798:                public final DDSCAPS get_ddsCaps() {
07799:                    return instance
07800:                            .createDDSCAPS(getElementPointer(NativeBridge.is64 ? 112
07801:                                    : 104));
07802:                }
07803:
07804:                @Override
07805:                public int size() {
07806:                    return sizeof;
07807:                }
07808:            }
07809:
07810:            public final DDSURFACEDESC createDDSURFACEDESC(boolean direct) {
07811:                return new DDSURFACEDESC(direct);
07812:            }
07813:
07814:            public final DDSURFACEDESC createDDSURFACEDESC(VoidPointer base) {
07815:                return new DDSURFACEDESC(base);
07816:            }
07817:
07818:            public final DDSURFACEDESC createDDSURFACEDESC(long addr) {
07819:                return new DDSURFACEDESC(addr);
07820:            }
07821:
07822:            public static class IDirectDrawSurface extends CommonStructWrapper {
07823:
07824:                public static final int sizeof = NativeBridge.is64 ? 8 : 4;
07825:
07826:                IDirectDrawSurface(boolean direct) {
07827:                    super (sizeof, direct);
07828:                }
07829:
07830:                IDirectDrawSurface(VoidPointer base) {
07831:                    super (base);
07832:                }
07833:
07834:                IDirectDrawSurface(long addr) {
07835:                    super (addr);
07836:                }
07837:
07838:                public final IDirectDrawSurfaceVtbl get_lpVtbl() {
07839:                    return instance.createIDirectDrawSurfaceVtbl(byteBase
07840:                            .getAddress(0));
07841:                }
07842:
07843:                @Override
07844:                public int size() {
07845:                    return sizeof;
07846:                }
07847:            }
07848:
07849:            public final IDirectDrawSurface createIDirectDrawSurface(
07850:                    boolean direct) {
07851:                return new IDirectDrawSurface(direct);
07852:            }
07853:
07854:            public final IDirectDrawSurface createIDirectDrawSurface(
07855:                    VoidPointer base) {
07856:                return new IDirectDrawSurface(base);
07857:            }
07858:
07859:            public final IDirectDrawSurface createIDirectDrawSurface(long addr) {
07860:                return new IDirectDrawSurface(addr);
07861:            }
07862:
07863:            public static class IDirectDrawVtbl extends CommonStructWrapper {
07864:
07865:                public static final int sizeof = NativeBridge.is64 ? 184 : 92;
07866:
07867:                IDirectDrawVtbl(boolean direct) {
07868:                    super (sizeof, direct);
07869:                }
07870:
07871:                IDirectDrawVtbl(VoidPointer base) {
07872:                    super (base);
07873:                }
07874:
07875:                IDirectDrawVtbl(long addr) {
07876:                    super (addr);
07877:                }
07878:
07879:                public final void set_QueryInterface(long val) {
07880:                    byteBase.setAddress(0, val);
07881:                }
07882:
07883:                public final long get_QueryInterface() {
07884:                    return byteBase.getAddress(0);
07885:                }
07886:
07887:                public final int QueryInterface(Win32.IDirectDraw This,
07888:                        Win32.GUID riid, PointerPointer ppvObj) {
07889:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07890:                    long tmp_1 = riid == null ? 0 : riid.longLockPointer();
07891:                    long tmp_2 = ppvObj == null ? 0 : ppvObj.longLockPointer();
07892:                    int tmp_ret = instance.proxycall77(get_QueryInterface(),
07893:                            tmp_0, tmp_1, tmp_2);
07894:                    if (This != null) {
07895:                        This.unlock();
07896:                    }
07897:                    if (riid != null) {
07898:                        riid.unlock();
07899:                    }
07900:                    if (ppvObj != null) {
07901:                        ppvObj.unlock();
07902:                    }
07903:                    return tmp_ret;
07904:                }
07905:
07906:                public final void set_AddRef(long val) {
07907:                    byteBase.setAddress(NativeBridge.is64 ? 8 : 4, val);
07908:                }
07909:
07910:                public final long get_AddRef() {
07911:                    return byteBase.getAddress(NativeBridge.is64 ? 8 : 4);
07912:                }
07913:
07914:                public final int AddRef(Win32.IDirectDraw This) {
07915:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07916:                    int tmp_ret = instance.proxycall78(get_AddRef(), tmp_0);
07917:                    if (This != null) {
07918:                        This.unlock();
07919:                    }
07920:                    return tmp_ret;
07921:                }
07922:
07923:                public final void set_Release(long val) {
07924:                    byteBase.setAddress(NativeBridge.is64 ? 16 : 8, val);
07925:                }
07926:
07927:                public final long get_Release() {
07928:                    return byteBase.getAddress(NativeBridge.is64 ? 16 : 8);
07929:                }
07930:
07931:                public final int Release(Win32.IDirectDraw This) {
07932:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07933:                    int tmp_ret = instance.proxycall79(get_Release(), tmp_0);
07934:                    if (This != null) {
07935:                        This.unlock();
07936:                    }
07937:                    return tmp_ret;
07938:                }
07939:
07940:                public final void set_Compact(long val) {
07941:                    byteBase.setAddress(NativeBridge.is64 ? 24 : 12, val);
07942:                }
07943:
07944:                public final long get_Compact() {
07945:                    return byteBase.getAddress(NativeBridge.is64 ? 24 : 12);
07946:                }
07947:
07948:                public final int Compact(Win32.IDirectDraw This) {
07949:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07950:                    int tmp_ret = instance.proxycall80(get_Compact(), tmp_0);
07951:                    if (This != null) {
07952:                        This.unlock();
07953:                    }
07954:                    return tmp_ret;
07955:                }
07956:
07957:                public final void set_CreateClipper(long val) {
07958:                    byteBase.setAddress(NativeBridge.is64 ? 32 : 16, val);
07959:                }
07960:
07961:                public final long get_CreateClipper() {
07962:                    return byteBase.getAddress(NativeBridge.is64 ? 32 : 16);
07963:                }
07964:
07965:                public final int CreateClipper(Win32.IDirectDraw This,
07966:                        int param_1, PointerPointer param_2,
07967:                        Win32.IUnknown param_3) {
07968:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07969:                    long tmp_1 = param_2 == null ? 0 : param_2
07970:                            .longLockPointer();
07971:                    long tmp_2 = param_3 == null ? 0 : param_3
07972:                            .longLockPointer();
07973:                    int tmp_ret = instance.proxycall81(get_CreateClipper(),
07974:                            tmp_0, param_1, tmp_1, tmp_2);
07975:                    if (This != null) {
07976:                        This.unlock();
07977:                    }
07978:                    if (param_2 != null) {
07979:                        param_2.unlock();
07980:                    }
07981:                    if (param_3 != null) {
07982:                        param_3.unlock();
07983:                    }
07984:                    return tmp_ret;
07985:                }
07986:
07987:                public final void set_CreatePalette(long val) {
07988:                    byteBase.setAddress(NativeBridge.is64 ? 40 : 20, val);
07989:                }
07990:
07991:                public final long get_CreatePalette() {
07992:                    return byteBase.getAddress(NativeBridge.is64 ? 40 : 20);
07993:                }
07994:
07995:                public final int CreatePalette(Win32.IDirectDraw This,
07996:                        int param_1, PALETTEENTRY param_2,
07997:                        PointerPointer param_3, Win32.IUnknown param_4) {
07998:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
07999:                    long tmp_1 = param_2 == null ? 0 : param_2
08000:                            .longLockPointer();
08001:                    long tmp_2 = param_3 == null ? 0 : param_3
08002:                            .longLockPointer();
08003:                    long tmp_3 = param_4 == null ? 0 : param_4
08004:                            .longLockPointer();
08005:                    int tmp_ret = instance.proxycall82(get_CreatePalette(),
08006:                            tmp_0, param_1, tmp_1, tmp_2, tmp_3);
08007:                    if (This != null) {
08008:                        This.unlock();
08009:                    }
08010:                    if (param_2 != null) {
08011:                        param_2.unlock();
08012:                    }
08013:                    if (param_3 != null) {
08014:                        param_3.unlock();
08015:                    }
08016:                    if (param_4 != null) {
08017:                        param_4.unlock();
08018:                    }
08019:                    return tmp_ret;
08020:                }
08021:
08022:                public final void set_CreateSurface(long val) {
08023:                    byteBase.setAddress(NativeBridge.is64 ? 48 : 24, val);
08024:                }
08025:
08026:                public final long get_CreateSurface() {
08027:                    return byteBase.getAddress(NativeBridge.is64 ? 48 : 24);
08028:                }
08029:
08030:                public final int CreateSurface(Win32.IDirectDraw This,
08031:                        Win32.DDSURFACEDESC param_1, PointerPointer param_2,
08032:                        Win32.IUnknown param_3) {
08033:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
08034:                    long tmp_1 = param_1 == null ? 0 : param_1
08035:                            .longLockPointer();
08036:                    long tmp_2 = param_2 == null ? 0 : param_2
08037:                            .longLockPointer();
08038:                    long tmp_3 = param_3 == null ? 0 : param_3
08039:                            .longLockPointer();
08040:                    int tmp_ret = instance.proxycall83(get_CreateSurface(),
08041:                            tmp_0, tmp_1, tmp_2, tmp_3);
08042:                    if (This != null) {
08043:                        This.unlock();
08044:                    }
08045:                    if (param_1 != null) {
08046:                        param_1.unlock();
08047:                    }
08048:                    if (param_2 != null) {
08049:                        param_2.unlock();
08050:                    }
08051:                    if (param_3 != null) {
08052:                        param_3.unlock();
08053:                    }
08054:                    return tmp_ret;
08055:                }
08056:
08057:                public final void set_DuplicateSurface(long val) {
08058:                    byteBase.setAddress(NativeBridge.is64 ? 56 : 28, val);
08059:                }
08060:
08061:                public final long get_DuplicateSurface() {
08062:                    return byteBase.getAddress(NativeBridge.is64 ? 56 : 28);
08063:                }
08064:
08065:                public final int DuplicateSurface(Win32.IDirectDraw This,
08066:                        Win32.IDirectDrawSurface param_1, PointerPointer param_2) {
08067:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
08068:                    long tmp_1 = param_1 == null ? 0 : param_1
08069:                            .longLockPointer();
08070:                    long tmp_2 = param_2 == null ? 0 : param_2
08071:                            .longLockPointer();
08072:                    int tmp_ret = instance.proxycall84(get_DuplicateSurface(),
08073:                            tmp_0, tmp_1, tmp_2);
08074:                    if (This != null) {
08075:                        This.unlock();
08076:                    }
08077:                    if (param_1 != null) {
08078:                        param_1.unlock();
08079:                    }
08080:                    if (param_2 != null) {
08081:                        param_2.unlock();
08082:                    }
08083:                    return tmp_ret;
08084:                }
08085:
08086:                public final void set_EnumDisplayModes(long val) {
08087:                    byteBase.setAddress(NativeBridge.is64 ? 64 : 32, val);
08088:                }
08089:
08090:                public final long get_EnumDisplayModes() {
08091:                    return byteBase.getAddress(NativeBridge.is64 ? 64 : 32);
08092:                }
08093:
08094:                public final int EnumDisplayModes(Win32.IDirectDraw This,
08095:                        int param_1, Win32.DDSURFACEDESC param_2,
08096:                        VoidPointer param_3, long param_4) {
08097:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
08098:                    long tmp_1 = param_2 == null ? 0 : param_2
08099:                            .longLockPointer();
08100:                    long tmp_2 = param_3 == null ? 0 : param_3
08101:                            .longLockPointer();
08102:                    int tmp_ret = instance.proxycall85(get_EnumDisplayModes(),
08103:                            tmp_0, param_1, tmp_1, tmp_2, param_4);
08104:                    if (This != null) {
08105:                        This.unlock();
08106:                    }
08107:                    if (param_2 != null) {
08108:                        param_2.unlock();
08109:                    }
08110:                    if (param_3 != null) {
08111:                        param_3.unlock();
08112:                    }
08113:                    return tmp_ret;
08114:                }
08115:
08116:                public final void set_EnumSurfaces(long val) {
08117:                    byteBase.setAddress(NativeBridge.is64 ? 72 : 36, val);
08118:                }
08119:
08120:                public final long get_EnumSurfaces() {
08121:                    return byteBase.getAddress(NativeBridge.is64 ? 72 : 36);
08122:                }
08123:
08124:                public final int EnumSurfaces(Win32.IDirectDraw This,
08125:                        int param_1, Win32.DDSURFACEDESC param_2,
08126:                        VoidPointer param_3, long param_4) {
08127:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
08128:                    long tmp_1 = param_2 == null ? 0 : param_2
08129:                            .longLockPointer();
08130:                    long tmp_2 = param_3 == null ? 0 : param_3
08131:                            .longLockPointer();
08132:                    int tmp_ret = instance.proxycall86(get_EnumSurfaces(),
08133:                            tmp_0, param_1, tmp_1, tmp_2, param_4);
08134:                    if (This != null) {
08135:                        This.unlock();
08136:                    }
08137:                    if (param_2 != null) {
08138:                        param_2.unlock();
08139:                    }
08140:                    if (param_3 != null) {
08141:                        param_3.unlock();
08142:                    }
08143:                    return tmp_ret;
08144:                }
08145:
08146:                public final void set_FlipToGDISurface(long val) {
08147:                    byteBase.setAddress(NativeBridge.is64 ? 80 : 40, val);
08148:                }
08149:
08150:                public final long get_FlipToGDISurface() {
08151:                    return byteBase.getAddress(NativeBridge.is64 ? 80 : 40);
08152:                }
08153:
08154:                public final int FlipToGDISurface(Win32.IDirectDraw This) {
08155:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
08156:                    int tmp_ret = instance.proxycall87(get_FlipToGDISurface(),
08157:                            tmp_0);
08158:                    if (This != null) {
08159:                        This.unlock();
08160:                    }
08161:                    return tmp_ret;
08162:                }
08163:
08164:                public final void set_GetCaps(long val) {
08165:                    byteBase.setAddress(NativeBridge.is64 ? 88 : 44, val);
08166:                }
08167:
08168:                public final long get_GetCaps() {
08169:                    return byteBase.getAddress(NativeBridge.is64 ? 88 : 44);
08170:                }
08171:
08172:                public final int GetCaps(Win32.IDirectDraw This,
08173:                        DDCAPS_DX7 param_1, DDCAPS_DX7 param_2) {
08174:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
08175:                    long tmp_1 = param_1 == null ? 0 : param_1
08176:                            .longLockPointer();
08177:                    long tmp_2 = param_2 == null ? 0 : param_2
08178:                            .longLockPointer();
08179:                    int tmp_ret = instance.proxycall88(get_GetCaps(), tmp_0,
08180:                            tmp_1, tmp_2);
08181:                    if (This != null) {
08182:                        This.unlock();
08183:                    }
08184:                    if (param_1 != null) {
08185:                        param_1.unlock();
08186:                    }
08187:                    if (param_2 != null) {
08188:                        param_2.unlock();
08189:                    }
08190:                    return tmp_ret;
08191:                }
08192:
08193:                public final void set_GetDisplayMode(long val) {
08194:                    byteBase.setAddress(NativeBridge.is64 ? 96 : 48, val);
08195:                }
08196:
08197:                public final long get_GetDisplayMode() {
08198:                    return byteBase.getAddress(NativeBridge.is64 ? 96 : 48);
08199:                }
08200:
08201:                public final int GetDisplayMode(Win32.IDirectDraw This,
08202:                        Win32.DDSURFACEDESC param_1) {
08203:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
08204:                    long tmp_1 = param_1 == null ? 0 : param_1
08205:                            .longLockPointer();
08206:                    int tmp_ret = instance.proxycall89(get_GetDisplayMode(),
08207:                            tmp_0, tmp_1);
08208:                    if (This != null) {
08209:                        This.unlock();
08210:                    }
08211:                    if (param_1 != null) {
08212:                        param_1.unlock();
08213:                    }
08214:                    return tmp_ret;
08215:                }
08216:
08217:                public final void set_GetFourCCCodes(long val) {
08218:                    byteBase.setAddress(NativeBridge.is64 ? 104 : 52, val);
08219:                }
08220:
08221:                public final long get_GetFourCCCodes() {
08222:                    return byteBase.getAddress(NativeBridge.is64 ? 104 : 52);
08223:                }
08224:
08225:                public final int GetFourCCCodes(Win32.IDirectDraw This,
08226:                        Int32Pointer param_1, Int32Pointer param_2) {
08227:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
08228:                    long tmp_1 = param_1 == null ? 0 : param_1
08229:                            .longLockPointer();
08230:                    long tmp_2 = param_2 == null ? 0 : param_2
08231:                            .longLockPointer();
08232:                    int tmp_ret = instance.proxycall90(get_GetFourCCCodes(),
08233:                            tmp_0, tmp_1, tmp_2);
08234:                    if (This != null) {
08235:                        This.unlock();
08236:                    }
08237:                    if (param_1 != null) {
08238:                        param_1.unlock();
08239:                    }
08240:                    if (param_2 != null) {
08241:                        param_2.unlock();
08242:                    }
08243:                    return tmp_ret;
08244:                }
08245:
08246:                public final void set_GetGDISurface(long val) {
08247:                    byteBase.setAddress(NativeBridge.is64 ? 112 : 56, val);
08248:                }
08249:
08250:                public final long get_GetGDISurface() {
08251:                    return byteBase.getAddress(NativeBridge.is64 ? 112 : 56);
08252:                }
08253:
08254:                public final int GetGDISurface(Win32.IDirectDraw This,
08255:                        PointerPointer param_1) {
08256:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
08257:                    long tmp_1 = param_1 == null ? 0 : param_1
08258:                            .longLockPointer();
08259:                    int tmp_ret = instance.proxycall91(get_GetGDISurface(),
08260:                            tmp_0, tmp_1);
08261:                    if (This != null) {
08262:                        This.unlock();
08263:                    }
08264:                    if (param_1 != null) {
08265:                        param_1.unlock();
08266:                    }
08267:                    return tmp_ret;
08268:                }
08269:
08270:                public final void set_GetMonitorFrequency(long val) {
08271:                    byteBase.setAddress(NativeBridge.is64 ? 120 : 60, val);
08272:                }
08273:
08274:                public final long get_GetMonitorFrequency() {
08275:                    return byteBase.getAddress(NativeBridge.is64 ? 120 : 60);
08276:                }
08277:
08278:                public final int GetMonitorFrequency(Win32.IDirectDraw This,
08279:                        Int32Pointer param_1) {
08280:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
08281:                    long tmp_1 = param_1 == null ? 0 : param_1
08282:                            .longLockPointer();
08283:                    int tmp_ret = instance.proxycall92(
08284:                            get_GetMonitorFrequency(), tmp_0, tmp_1);
08285:                    if (This != null) {
08286:                        This.unlock();
08287:                    }
08288:                    if (param_1 != null) {
08289:                        param_1.unlock();
08290:                    }
08291:                    return tmp_ret;
08292:                }
08293:
08294:                public final void set_GetScanLine(long val) {
08295:                    byteBase.setAddress(NativeBridge.is64 ? 128 : 64, val);
08296:                }
08297:
08298:                public final long get_GetScanLine() {
08299:                    return byteBase.getAddress(NativeBridge.is64 ? 128 : 64);
08300:                }
08301:
08302:                public final int GetScanLine(Win32.IDirectDraw This,
08303:                        Int32Pointer param_1) {
08304:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
08305:                    long tmp_1 = param_1 == null ? 0 : param_1
08306:                            .longLockPointer();
08307:                    int tmp_ret = instance.proxycall93(get_GetScanLine(),
08308:                            tmp_0, tmp_1);
08309:                    if (This != null) {
08310:                        This.unlock();
08311:                    }
08312:                    if (param_1 != null) {
08313:                        param_1.unlock();
08314:                    }
08315:                    return tmp_ret;
08316:                }
08317:
08318:                public final void set_GetVerticalBlankStatus(long val) {
08319:                    byteBase.setAddress(NativeBridge.is64 ? 136 : 68, val);
08320:                }
08321:
08322:                public final long get_GetVerticalBlankStatus() {
08323:                    return byteBase.getAddress(NativeBridge.is64 ? 136 : 68);
08324:                }
08325:
08326:                public final int GetVerticalBlankStatus(Win32.IDirectDraw This,
08327:                        Int32Pointer param_1) {
08328:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
08329:                    long tmp_1 = param_1 == null ? 0 : param_1
08330:                            .longLockPointer();
08331:                    int tmp_ret = instance.proxycall94(
08332:                            get_GetVerticalBlankStatus(), tmp_0, tmp_1);
08333:                    if (This != null) {
08334:                        This.unlock();
08335:                    }
08336:                    if (param_1 != null) {
08337:                        param_1.unlock();
08338:                    }
08339:                    return tmp_ret;
08340:                }
08341:
08342:                public final void set_Initialize(long val) {
08343:                    byteBase.setAddress(NativeBridge.is64 ? 144 : 72, val);
08344:                }
08345:
08346:                public final long get_Initialize() {
08347:                    return byteBase.getAddress(NativeBridge.is64 ? 144 : 72);
08348:                }
08349:
08350:                public final int Initialize(Win32.IDirectDraw This,
08351:                        Win32.GUID param_1) {
08352:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
08353:                    long tmp_1 = param_1 == null ? 0 : param_1
08354:                            .longLockPointer();
08355:                    int tmp_ret = instance.proxycall95(get_Initialize(), tmp_0,
08356:                            tmp_1);
08357:                    if (This != null) {
08358:                        This.unlock();
08359:                    }
08360:                    if (param_1 != null) {
08361:                        param_1.unlock();
08362:                    }
08363:                    return tmp_ret;
08364:                }
08365:
08366:                public final void set_RestoreDisplayMode(long val) {
08367:                    byteBase.setAddress(NativeBridge.is64 ? 152 : 76, val);
08368:                }
08369:
08370:                public final long get_RestoreDisplayMode() {
08371:                    return byteBase.getAddress(NativeBridge.is64 ? 152 : 76);
08372:                }
08373:
08374:                public final int RestoreDisplayMode(Win32.IDirectDraw This) {
08375:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
08376:                    int tmp_ret = instance.proxycall96(
08377:                            get_RestoreDisplayMode(), tmp_0);
08378:                    if (This != null) {
08379:                        This.unlock();
08380:                    }
08381:                    return tmp_ret;
08382:                }
08383:
08384:                public final void set_SetCooperativeLevel(long val) {
08385:                    byteBase.setAddress(NativeBridge.is64 ? 160 : 80, val);
08386:                }
08387:
08388:                public final long get_SetCooperativeLevel() {
08389:                    return byteBase.getAddress(NativeBridge.is64 ? 160 : 80);
08390:                }
08391:
08392:                public final int SetCooperativeLevel(Win32.IDirectDraw This,
08393:                        long param_1, int param_2) {
08394:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
08395:                    int tmp_ret = instance.proxycall97(
08396:                            get_SetCooperativeLevel(), tmp_0, param_1, param_2);
08397:                    if (This != null) {
08398:                        This.unlock();
08399:                    }
08400:                    return tmp_ret;
08401:                }
08402:
08403:                public final void set_SetDisplayMode(long val) {
08404:                    byteBase.setAddress(NativeBridge.is64 ? 168 : 84, val);
08405:                }
08406:
08407:                public final long get_SetDisplayMode() {
08408:                    return byteBase.getAddress(NativeBridge.is64 ? 168 : 84);
08409:                }
08410:
08411:                public final int SetDisplayMode(Win32.IDirectDraw This,
08412:                        int param_1, int param_2, int param_3) {
08413:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
08414:                    int tmp_ret = instance.proxycall98(get_SetDisplayMode(),
08415:                            tmp_0, param_1, param_2, param_3);
08416:                    if (This != null) {
08417:                        This.unlock();
08418:                    }
08419:                    return tmp_ret;
08420:                }
08421:
08422:                public final void set_WaitForVerticalBlank(long val) {
08423:                    byteBase.setAddress(NativeBridge.is64 ? 176 : 88, val);
08424:                }
08425:
08426:                public final long get_WaitForVerticalBlank() {
08427:                    return byteBase.getAddress(NativeBridge.is64 ? 176 : 88);
08428:                }
08429:
08430:                public final int WaitForVerticalBlank(Win32.IDirectDraw This,
08431:                        int param_1, VoidPointer param_2) {
08432:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
08433:                    long tmp_1 = param_2 == null ? 0 : param_2
08434:                            .longLockPointer();
08435:                    int tmp_ret = instance.proxycall99(
08436:                            get_WaitForVerticalBlank(), tmp_0, param_1, tmp_1);
08437:                    if (This != null) {
08438:                        This.unlock();
08439:                    }
08440:                    if (param_2 != null) {
08441:                        param_2.unlock();
08442:                    }
08443:                    return tmp_ret;
08444:                }
08445:
08446:                @Override
08447:                public int size() {
08448:                    return sizeof;
08449:                }
08450:            }
08451:
08452:            public final IDirectDrawVtbl createIDirectDrawVtbl(boolean direct) {
08453:                return new IDirectDrawVtbl(direct);
08454:            }
08455:
08456:            public final IDirectDrawVtbl createIDirectDrawVtbl(VoidPointer base) {
08457:                return new IDirectDrawVtbl(base);
08458:            }
08459:
08460:            public final IDirectDrawVtbl createIDirectDrawVtbl(long addr) {
08461:                return new IDirectDrawVtbl(addr);
08462:            }
08463:
08464:            public static class IEnumIDListVtbl extends CommonStructWrapper {
08465:
08466:                public static final int sizeof = NativeBridge.is64 ? 56 : 28;
08467:
08468:                IEnumIDListVtbl(boolean direct) {
08469:                    super (sizeof, direct);
08470:                }
08471:
08472:                IEnumIDListVtbl(VoidPointer base) {
08473:                    super (base);
08474:                }
08475:
08476:                IEnumIDListVtbl(long addr) {
08477:                    super (addr);
08478:                }
08479:
08480:                public final void set_QueryInterface(long val) {
08481:                    byteBase.setAddress(0, val);
08482:                }
08483:
08484:                public final long get_QueryInterface() {
08485:                    return byteBase.getAddress(0);
08486:                }
08487:
08488:                public final int QueryInterface(Win32.IEnumIDList This,
08489:                        Win32.GUID riid, PointerPointer ppvObject) {
08490:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
08491:                    long tmp_1 = riid == null ? 0 : riid.longLockPointer();
08492:                    long tmp_2 = ppvObject == null ? 0 : ppvObject
08493:                            .longLockPointer();
08494:                    int tmp_ret = instance.proxycall100(get_QueryInterface(),
08495:                            tmp_0, tmp_1, tmp_2);
08496:                    if (This != null) {
08497:                        This.unlock();
08498:                    }
08499:                    if (riid != null) {
08500:                        riid.unlock();
08501:                    }
08502:                    if (ppvObject != null) {
08503:                        ppvObject.unlock();
08504:                    }
08505:                    return tmp_ret;
08506:                }
08507:
08508:                public final void set_AddRef(long val) {
08509:                    byteBase.setAddress(NativeBridge.is64 ? 8 : 4, val);
08510:                }
08511:
08512:                public final long get_AddRef() {
08513:                    return byteBase.getAddress(NativeBridge.is64 ? 8 : 4);
08514:                }
08515:
08516:                public final int AddRef(Win32.IEnumIDList This) {
08517:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
08518:                    int tmp_ret = instance.proxycall101(get_AddRef(), tmp_0);
08519:                    if (This != null) {
08520:                        This.unlock();
08521:                    }
08522:                    return tmp_ret;
08523:                }
08524:
08525:                public final void set_Release(long val) {
08526:                    byteBase.setAddress(NativeBridge.is64 ? 16 : 8, val);
08527:                }
08528:
08529:                public final long get_Release() {
08530:                    return byteBase.getAddress(NativeBridge.is64 ? 16 : 8);
08531:                }
08532:
08533:                public final int Release(Win32.IEnumIDList This) {
08534:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
08535:                    int tmp_ret = instance.proxycall102(get_Release(), tmp_0);
08536:                    if (This != null) {
08537:                        This.unlock();
08538:                    }
08539:                    return tmp_ret;
08540:                }
08541:
08542:                public final void set_Next(long val) {
08543:                    byteBase.setAddress(NativeBridge.is64 ? 24 : 12, val);
08544:                }
08545:
08546:                public final long get_Next() {
08547:                    return byteBase.getAddress(NativeBridge.is64 ? 24 : 12);
08548:                }
08549:
08550:                public final int Next(Win32.IEnumIDList This, int celt,
08551:                        PointerPointer rgelt, Int32Pointer pceltFetched) {
08552:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
08553:                    long tmp_1 = rgelt == null ? 0 : rgelt.longLockPointer();
08554:                    long tmp_2 = pceltFetched == null ? 0 : pceltFetched
08555:                            .longLockPointer();
08556:                    int tmp_ret = instance.proxycall103(get_Next(), tmp_0,
08557:                            celt, tmp_1, tmp_2);
08558:                    if (This != null) {
08559:                        This.unlock();
08560:                    }
08561:                    if (rgelt != null) {
08562:                        rgelt.unlock();
08563:                    }
08564:                    if (pceltFetched != null) {
08565:                        pceltFetched.unlock();
08566:                    }
08567:                    return tmp_ret;
08568:                }
08569:
08570:                public final void set_Skip(long val) {
08571:                    byteBase.setAddress(NativeBridge.is64 ? 32 : 16, val);
08572:                }
08573:
08574:                public final long get_Skip() {
08575:                    return byteBase.getAddress(NativeBridge.is64 ? 32 : 16);
08576:                }
08577:
08578:                public final int Skip(Win32.IEnumIDList This, int celt) {
08579:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
08580:                    int tmp_ret = instance
08581:                            .proxycall104(get_Skip(), tmp_0, celt);
08582:                    if (This != null) {
08583:                        This.unlock();
08584:                    }
08585:                    return tmp_ret;
08586:                }
08587:
08588:                public final void set_Reset(long val) {
08589:                    byteBase.setAddress(NativeBridge.is64 ? 40 : 20, val);
08590:                }
08591:
08592:                public final long get_Reset() {
08593:                    return byteBase.getAddress(NativeBridge.is64 ? 40 : 20);
08594:                }
08595:
08596:                public final int Reset(Win32.IEnumIDList This) {
08597:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
08598:                    int tmp_ret = instance.proxycall105(get_Reset(), tmp_0);
08599:                    if (This != null) {
08600:                        This.unlock();
08601:                    }
08602:                    return tmp_ret;
08603:                }
08604:
08605:                public final void set_Clone(long val) {
08606:                    byteBase.setAddress(NativeBridge.is64 ? 48 : 24, val);
08607:                }
08608:
08609:                public final long get_Clone() {
08610:                    return byteBase.getAddress(NativeBridge.is64 ? 48 : 24);
08611:                }
08612:
08613:                public final int Clone(Win32.IEnumIDList This,
08614:                        PointerPointer ppenum) {
08615:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
08616:                    long tmp_1 = ppenum == null ? 0 : ppenum.longLockPointer();
08617:                    int tmp_ret = instance.proxycall106(get_Clone(), tmp_0,
08618:                            tmp_1);
08619:                    if (This != null) {
08620:                        This.unlock();
08621:                    }
08622:                    if (ppenum != null) {
08623:                        ppenum.unlock();
08624:                    }
08625:                    return tmp_ret;
08626:                }
08627:
08628:                @Override
08629:                public int size() {
08630:                    return sizeof;
08631:                }
08632:            }
08633:
08634:            public final IEnumIDListVtbl createIEnumIDListVtbl(boolean direct) {
08635:                return new IEnumIDListVtbl(direct);
08636:            }
08637:
08638:            public final IEnumIDListVtbl createIEnumIDListVtbl(VoidPointer base) {
08639:                return new IEnumIDListVtbl(base);
08640:            }
08641:
08642:            public final IEnumIDListVtbl createIEnumIDListVtbl(long addr) {
08643:                return new IEnumIDListVtbl(addr);
08644:            }
08645:
08646:            public static class SIZE extends CommonStructWrapper {
08647:
08648:                public static final int sizeof = 8;
08649:
08650:                SIZE(boolean direct) {
08651:                    super (sizeof, direct);
08652:                }
08653:
08654:                SIZE(VoidPointer base) {
08655:                    super (base);
08656:                }
08657:
08658:                SIZE(long addr) {
08659:                    super (addr);
08660:                }
08661:
08662:                public final void set_cx(int val) {
08663:                    byteBase.setInt32(0, val);
08664:                }
08665:
08666:                public final int get_cx() {
08667:                    return byteBase.getInt32(0);
08668:                }
08669:
08670:                public final void set_cy(int val) {
08671:                    byteBase.setInt32(4, val);
08672:                }
08673:
08674:                public final int get_cy() {
08675:                    return byteBase.getInt32(4);
08676:                }
08677:
08678:                @Override
08679:                public int size() {
08680:                    return sizeof;
08681:                }
08682:            }
08683:
08684:            public final SIZE createSIZE(boolean direct) {
08685:                return new SIZE(direct);
08686:            }
08687:
08688:            public final SIZE createSIZE(VoidPointer base) {
08689:                return new SIZE(base);
08690:            }
08691:
08692:            public final SIZE createSIZE(long addr) {
08693:                return new SIZE(addr);
08694:            }
08695:
08696:            public static class PALETTEENTRY extends CommonStructWrapper {
08697:
08698:                public static final int sizeof = 4;
08699:
08700:                PALETTEENTRY(boolean direct) {
08701:                    super (sizeof, direct);
08702:                }
08703:
08704:                PALETTEENTRY(VoidPointer base) {
08705:                    super (base);
08706:                }
08707:
08708:                PALETTEENTRY(long addr) {
08709:                    super (addr);
08710:                }
08711:
08712:                public final void set_peRed(byte val) {
08713:                    byteBase.set(0, val);
08714:                }
08715:
08716:                public final byte get_peRed() {
08717:                    return byteBase.get(0);
08718:                }
08719:
08720:                public final void set_peGreen(byte val) {
08721:                    byteBase.set(1, val);
08722:                }
08723:
08724:                public final byte get_peGreen() {
08725:                    return byteBase.get(1);
08726:                }
08727:
08728:                public final void set_peBlue(byte val) {
08729:                    byteBase.set(2, val);
08730:                }
08731:
08732:                public final byte get_peBlue() {
08733:                    return byteBase.get(2);
08734:                }
08735:
08736:                public final void set_peFlags(byte val) {
08737:                    byteBase.set(3, val);
08738:                }
08739:
08740:                public final byte get_peFlags() {
08741:                    return byteBase.get(3);
08742:                }
08743:
08744:                @Override
08745:                public int size() {
08746:                    return sizeof;
08747:                }
08748:            }
08749:
08750:            public final PALETTEENTRY createPALETTEENTRY(boolean direct) {
08751:                return new PALETTEENTRY(direct);
08752:            }
08753:
08754:            public final PALETTEENTRY createPALETTEENTRY(VoidPointer base) {
08755:                return new PALETTEENTRY(base);
08756:            }
08757:
08758:            public final PALETTEENTRY createPALETTEENTRY(long addr) {
08759:                return new PALETTEENTRY(addr);
08760:            }
08761:
08762:            public static class DDCAPS_DX7 extends CommonStructWrapper {
08763:
08764:                public static final int sizeof = 240;
08765:
08766:                DDCAPS_DX7(boolean direct) {
08767:                    super (sizeof, direct);
08768:                }
08769:
08770:                DDCAPS_DX7(VoidPointer base) {
08771:                    super (base);
08772:                }
08773:
08774:                DDCAPS_DX7(long addr) {
08775:                    super (addr);
08776:                }
08777:
08778:                public final void set_dwSize(int val) {
08779:                    byteBase.setInt32(0, val);
08780:                }
08781:
08782:                public final int get_dwSize() {
08783:                    return byteBase.getInt32(0);
08784:                }
08785:
08786:                public final void set_dwCaps(int val) {
08787:                    byteBase.setInt32(4, val);
08788:                }
08789:
08790:                public final int get_dwCaps() {
08791:                    return byteBase.getInt32(4);
08792:                }
08793:
08794:                public final void set_dwCaps2(int val) {
08795:                    byteBase.setInt32(8, val);
08796:                }
08797:
08798:                public final int get_dwCaps2() {
08799:                    return byteBase.getInt32(8);
08800:                }
08801:
08802:                public final void set_dwCKeyCaps(int val) {
08803:                    byteBase.setInt32(12, val);
08804:                }
08805:
08806:                public final int get_dwCKeyCaps() {
08807:                    return byteBase.getInt32(12);
08808:                }
08809:
08810:                public final void set_dwFXCaps(int val) {
08811:                    byteBase.setInt32(16, val);
08812:                }
08813:
08814:                public final int get_dwFXCaps() {
08815:                    return byteBase.getInt32(16);
08816:                }
08817:
08818:                public final void set_dwFXAlphaCaps(int val) {
08819:                    byteBase.setInt32(20, val);
08820:                }
08821:
08822:                public final int get_dwFXAlphaCaps() {
08823:                    return byteBase.getInt32(20);
08824:                }
08825:
08826:                public final void set_dwPalCaps(int val) {
08827:                    byteBase.setInt32(24, val);
08828:                }
08829:
08830:                public final int get_dwPalCaps() {
08831:                    return byteBase.getInt32(24);
08832:                }
08833:
08834:                public final void set_dwSVCaps(int val) {
08835:                    byteBase.setInt32(28, val);
08836:                }
08837:
08838:                public final int get_dwSVCaps() {
08839:                    return byteBase.getInt32(28);
08840:                }
08841:
08842:                public final void set_dwAlphaBltConstBitDepths(int val) {
08843:                    byteBase.setInt32(32, val);
08844:                }
08845:
08846:                public final int get_dwAlphaBltConstBitDepths() {
08847:                    return byteBase.getInt32(32);
08848:                }
08849:
08850:                public final void set_dwAlphaBltPixelBitDepths(int val) {
08851:                    byteBase.setInt32(36, val);
08852:                }
08853:
08854:                public final int get_dwAlphaBltPixelBitDepths() {
08855:                    return byteBase.getInt32(36);
08856:                }
08857:
08858:                public final void set_dwAlphaBltSurfaceBitDepths(int val) {
08859:                    byteBase.setInt32(40, val);
08860:                }
08861:
08862:                public final int get_dwAlphaBltSurfaceBitDepths() {
08863:                    return byteBase.getInt32(40);
08864:                }
08865:
08866:                public final void set_dwAlphaOverlayConstBitDepths(int val) {
08867:                    byteBase.setInt32(44, val);
08868:                }
08869:
08870:                public final int get_dwAlphaOverlayConstBitDepths() {
08871:                    return byteBase.getInt32(44);
08872:                }
08873:
08874:                public final void set_dwAlphaOverlayPixelBitDepths(int val) {
08875:                    byteBase.setInt32(48, val);
08876:                }
08877:
08878:                public final int get_dwAlphaOverlayPixelBitDepths() {
08879:                    return byteBase.getInt32(48);
08880:                }
08881:
08882:                public final void set_dwAlphaOverlaySurfaceBitDepths(int val) {
08883:                    byteBase.setInt32(52, val);
08884:                }
08885:
08886:                public final int get_dwAlphaOverlaySurfaceBitDepths() {
08887:                    return byteBase.getInt32(52);
08888:                }
08889:
08890:                public final void set_dwZBufferBitDepths(int val) {
08891:                    byteBase.setInt32(56, val);
08892:                }
08893:
08894:                public final int get_dwZBufferBitDepths() {
08895:                    return byteBase.getInt32(56);
08896:                }
08897:
08898:                public final void set_dwVidMemTotal(int val) {
08899:                    byteBase.setInt32(60, val);
08900:                }
08901:
08902:                public final int get_dwVidMemTotal() {
08903:                    return byteBase.getInt32(60);
08904:                }
08905:
08906:                public final void set_dwVidMemFree(int val) {
08907:                    byteBase.setInt32(64, val);
08908:                }
08909:
08910:                public final int get_dwVidMemFree() {
08911:                    return byteBase.getInt32(64);
08912:                }
08913:
08914:                public final void set_dwMaxVisibleOverlays(int val) {
08915:                    byteBase.setInt32(68, val);
08916:                }
08917:
08918:                public final int get_dwMaxVisibleOverlays() {
08919:                    return byteBase.getInt32(68);
08920:                }
08921:
08922:                public final void set_dwCurrVisibleOverlays(int val) {
08923:                    byteBase.setInt32(72, val);
08924:                }
08925:
08926:                public final int get_dwCurrVisibleOverlays() {
08927:                    return byteBase.getInt32(72);
08928:                }
08929:
08930:                public final void set_dwNumFourCCCodes(int val) {
08931:                    byteBase.setInt32(76, val);
08932:                }
08933:
08934:                public final int get_dwNumFourCCCodes() {
08935:                    return byteBase.getInt32(76);
08936:                }
08937:
08938:                public final void set_dwAlignBoundarySrc(int val) {
08939:                    byteBase.setInt32(80, val);
08940:                }
08941:
08942:                public final int get_dwAlignBoundarySrc() {
08943:                    return byteBase.getInt32(80);
08944:                }
08945:
08946:                public final void set_dwAlignSizeSrc(int val) {
08947:                    byteBase.setInt32(84, val);
08948:                }
08949:
08950:                public final int get_dwAlignSizeSrc() {
08951:                    return byteBase.getInt32(84);
08952:                }
08953:
08954:                public final void set_dwAlignBoundaryDest(int val) {
08955:                    byteBase.setInt32(88, val);
08956:                }
08957:
08958:                public final int get_dwAlignBoundaryDest() {
08959:                    return byteBase.getInt32(88);
08960:                }
08961:
08962:                public final void set_dwAlignSizeDest(int val) {
08963:                    byteBase.setInt32(92, val);
08964:                }
08965:
08966:                public final int get_dwAlignSizeDest() {
08967:                    return byteBase.getInt32(92);
08968:                }
08969:
08970:                public final void set_dwAlignStrideAlign(int val) {
08971:                    byteBase.setInt32(96, val);
08972:                }
08973:
08974:                public final int get_dwAlignStrideAlign() {
08975:                    return byteBase.getInt32(96);
08976:                }
08977:
08978:                public final Int32Pointer get_dwRops() {
08979:                    return nb.createInt32Pointer(getElementPointer(100));
08980:                }
08981:
08982:                public final DDSCAPS get_ddsOldCaps() {
08983:                    return instance.createDDSCAPS(getElementPointer(104));
08984:                }
08985:
08986:                public final void set_dwMinOverlayStretch(int val) {
08987:                    byteBase.setInt32(108, val);
08988:                }
08989:
08990:                public final int get_dwMinOverlayStretch() {
08991:                    return byteBase.getInt32(108);
08992:                }
08993:
08994:                public final void set_dwMaxOverlayStretch(int val) {
08995:                    byteBase.setInt32(112, val);
08996:                }
08997:
08998:                public final int get_dwMaxOverlayStretch() {
08999:                    return byteBase.getInt32(112);
09000:                }
09001:
09002:                public final void set_dwMinLiveVideoStretch(int val) {
09003:                    byteBase.setInt32(116, val);
09004:                }
09005:
09006:                public final int get_dwMinLiveVideoStretch() {
09007:                    return byteBase.getInt32(116);
09008:                }
09009:
09010:                public final void set_dwMaxLiveVideoStretch(int val) {
09011:                    byteBase.setInt32(120, val);
09012:                }
09013:
09014:                public final int get_dwMaxLiveVideoStretch() {
09015:                    return byteBase.getInt32(120);
09016:                }
09017:
09018:                public final void set_dwMinHwCodecStretch(int val) {
09019:                    byteBase.setInt32(124, val);
09020:                }
09021:
09022:                public final int get_dwMinHwCodecStretch() {
09023:                    return byteBase.getInt32(124);
09024:                }
09025:
09026:                public final void set_dwMaxHwCodecStretch(int val) {
09027:                    byteBase.setInt32(128, val);
09028:                }
09029:
09030:                public final int get_dwMaxHwCodecStretch() {
09031:                    return byteBase.getInt32(128);
09032:                }
09033:
09034:                public final void set_dwReserved1(int val) {
09035:                    byteBase.setInt32(132, val);
09036:                }
09037:
09038:                public final int get_dwReserved1() {
09039:                    return byteBase.getInt32(132);
09040:                }
09041:
09042:                public final void set_dwReserved2(int val) {
09043:                    byteBase.setInt32(136, val);
09044:                }
09045:
09046:                public final int get_dwReserved2() {
09047:                    return byteBase.getInt32(136);
09048:                }
09049:
09050:                public final void set_dwReserved3(int val) {
09051:                    byteBase.setInt32(140, val);
09052:                }
09053:
09054:                public final int get_dwReserved3() {
09055:                    return byteBase.getInt32(140);
09056:                }
09057:
09058:                public final void set_dwSVBCaps(int val) {
09059:                    byteBase.setInt32(144, val);
09060:                }
09061:
09062:                public final int get_dwSVBCaps() {
09063:                    return byteBase.getInt32(144);
09064:                }
09065:
09066:                public final void set_dwSVBCKeyCaps(int val) {
09067:                    byteBase.setInt32(148, val);
09068:                }
09069:
09070:                public final int get_dwSVBCKeyCaps() {
09071:                    return byteBase.getInt32(148);
09072:                }
09073:
09074:                public final void set_dwSVBFXCaps(int val) {
09075:                    byteBase.setInt32(152, val);
09076:                }
09077:
09078:                public final int get_dwSVBFXCaps() {
09079:                    return byteBase.getInt32(152);
09080:                }
09081:
09082:                public final Int32Pointer get_dwSVBRops() {
09083:                    return nb.createInt32Pointer(getElementPointer(156));
09084:                }
09085:
09086:                public final void set_dwVSBCaps(int val) {
09087:                    byteBase.setInt32(160, val);
09088:                }
09089:
09090:                public final int get_dwVSBCaps() {
09091:                    return byteBase.getInt32(160);
09092:                }
09093:
09094:                public final void set_dwVSBCKeyCaps(int val) {
09095:                    byteBase.setInt32(164, val);
09096:                }
09097:
09098:                public final int get_dwVSBCKeyCaps() {
09099:                    return byteBase.getInt32(164);
09100:                }
09101:
09102:                public final void set_dwVSBFXCaps(int val) {
09103:                    byteBase.setInt32(168, val);
09104:                }
09105:
09106:                public final int get_dwVSBFXCaps() {
09107:                    return byteBase.getInt32(168);
09108:                }
09109:
09110:                public final Int32Pointer get_dwVSBRops() {
09111:                    return nb.createInt32Pointer(getElementPointer(172));
09112:                }
09113:
09114:                public final void set_dwSSBCaps(int val) {
09115:                    byteBase.setInt32(176, val);
09116:                }
09117:
09118:                public final int get_dwSSBCaps() {
09119:                    return byteBase.getInt32(176);
09120:                }
09121:
09122:                public final void set_dwSSBCKeyCaps(int val) {
09123:                    byteBase.setInt32(180, val);
09124:                }
09125:
09126:                public final int get_dwSSBCKeyCaps() {
09127:                    return byteBase.getInt32(180);
09128:                }
09129:
09130:                public final void set_dwSSBFXCaps(int val) {
09131:                    byteBase.setInt32(184, val);
09132:                }
09133:
09134:                public final int get_dwSSBFXCaps() {
09135:                    return byteBase.getInt32(184);
09136:                }
09137:
09138:                public final Int32Pointer get_dwSSBRops() {
09139:                    return nb.createInt32Pointer(getElementPointer(188));
09140:                }
09141:
09142:                public final void set_dwMaxVideoPorts(int val) {
09143:                    byteBase.setInt32(192, val);
09144:                }
09145:
09146:                public final int get_dwMaxVideoPorts() {
09147:                    return byteBase.getInt32(192);
09148:                }
09149:
09150:                public final void set_dwCurrVideoPorts(int val) {
09151:                    byteBase.setInt32(196, val);
09152:                }
09153:
09154:                public final int get_dwCurrVideoPorts() {
09155:                    return byteBase.getInt32(196);
09156:                }
09157:
09158:                public final void set_dwSVBCaps2(int val) {
09159:                    byteBase.setInt32(200, val);
09160:                }
09161:
09162:                public final int get_dwSVBCaps2() {
09163:                    return byteBase.getInt32(200);
09164:                }
09165:
09166:                public final void set_dwNLVBCaps(int val) {
09167:                    byteBase.setInt32(204, val);
09168:                }
09169:
09170:                public final int get_dwNLVBCaps() {
09171:                    return byteBase.getInt32(204);
09172:                }
09173:
09174:                public final void set_dwNLVBCaps2(int val) {
09175:                    byteBase.setInt32(208, val);
09176:                }
09177:
09178:                public final int get_dwNLVBCaps2() {
09179:                    return byteBase.getInt32(208);
09180:                }
09181:
09182:                public final void set_dwNLVBCKeyCaps(int val) {
09183:                    byteBase.setInt32(212, val);
09184:                }
09185:
09186:                public final int get_dwNLVBCKeyCaps() {
09187:                    return byteBase.getInt32(212);
09188:                }
09189:
09190:                public final void set_dwNLVBFXCaps(int val) {
09191:                    byteBase.setInt32(216, val);
09192:                }
09193:
09194:                public final int get_dwNLVBFXCaps() {
09195:                    return byteBase.getInt32(216);
09196:                }
09197:
09198:                public final Int32Pointer get_dwNLVBRops() {
09199:                    return nb.createInt32Pointer(getElementPointer(220));
09200:                }
09201:
09202:                public final Win32.DDSCAPS2 get_ddsCaps() {
09203:                    return Win32.instance
09204:                            .createDDSCAPS2(getElementPointer(224));
09205:                }
09206:
09207:                @Override
09208:                public int size() {
09209:                    return sizeof;
09210:                }
09211:            }
09212:
09213:            public final DDCAPS_DX7 createDDCAPS_DX7(boolean direct) {
09214:                return new DDCAPS_DX7(direct);
09215:            }
09216:
09217:            public final DDCAPS_DX7 createDDCAPS_DX7(VoidPointer base) {
09218:                return new DDCAPS_DX7(base);
09219:            }
09220:
09221:            public final DDCAPS_DX7 createDDCAPS_DX7(long addr) {
09222:                return new DDCAPS_DX7(addr);
09223:            }
09224:
09225:            public static class DDSURFACEDESC2 extends CommonStructWrapper {
09226:
09227:                public static final int sizeof = NativeBridge.is64 ? 136 : 124;
09228:
09229:                DDSURFACEDESC2(boolean direct) {
09230:                    super (sizeof, direct);
09231:                }
09232:
09233:                DDSURFACEDESC2(VoidPointer base) {
09234:                    super (base);
09235:                }
09236:
09237:                DDSURFACEDESC2(long addr) {
09238:                    super (addr);
09239:                }
09240:
09241:                public final void set_dwSize(int val) {
09242:                    byteBase.setInt32(0, val);
09243:                }
09244:
09245:                public final int get_dwSize() {
09246:                    return byteBase.getInt32(0);
09247:                }
09248:
09249:                public final void set_dwFlags(int val) {
09250:                    byteBase.setInt32(4, val);
09251:                }
09252:
09253:                public final int get_dwFlags() {
09254:                    return byteBase.getInt32(4);
09255:                }
09256:
09257:                public final void set_dwHeight(int val) {
09258:                    byteBase.setInt32(8, val);
09259:                }
09260:
09261:                public final int get_dwHeight() {
09262:                    return byteBase.getInt32(8);
09263:                }
09264:
09265:                public final void set_dwWidth(int val) {
09266:                    byteBase.setInt32(12, val);
09267:                }
09268:
09269:                public final int get_dwWidth() {
09270:                    return byteBase.getInt32(12);
09271:                }
09272:
09273:                public final void set_lPitch(int val) {
09274:                    byteBase.setInt32(16, val);
09275:                }
09276:
09277:                public final int get_lPitch() {
09278:                    return byteBase.getInt32(16);
09279:                }
09280:
09281:                public final void set_dwLinearSize(int val) {
09282:                    byteBase.setInt32(16, val);
09283:                }
09284:
09285:                public final int get_dwLinearSize() {
09286:                    return byteBase.getInt32(16);
09287:                }
09288:
09289:                public final void set_dwBackBufferCount(int val) {
09290:                    byteBase.setInt32(20, val);
09291:                }
09292:
09293:                public final int get_dwBackBufferCount() {
09294:                    return byteBase.getInt32(20);
09295:                }
09296:
09297:                public final void set_dwDepth(int val) {
09298:                    byteBase.setInt32(20, val);
09299:                }
09300:
09301:                public final int get_dwDepth() {
09302:                    return byteBase.getInt32(20);
09303:                }
09304:
09305:                public final void set_dwMipMapCount(int val) {
09306:                    byteBase.setInt32(24, val);
09307:                }
09308:
09309:                public final int get_dwMipMapCount() {
09310:                    return byteBase.getInt32(24);
09311:                }
09312:
09313:                public final void set_dwRefreshRate(int val) {
09314:                    byteBase.setInt32(24, val);
09315:                }
09316:
09317:                public final int get_dwRefreshRate() {
09318:                    return byteBase.getInt32(24);
09319:                }
09320:
09321:                public final void set_dwSrcVBHandle(int val) {
09322:                    byteBase.setInt32(24, val);
09323:                }
09324:
09325:                public final int get_dwSrcVBHandle() {
09326:                    return byteBase.getInt32(24);
09327:                }
09328:
09329:                public final void set_dwAlphaBitDepth(int val) {
09330:                    byteBase.setInt32(28, val);
09331:                }
09332:
09333:                public final int get_dwAlphaBitDepth() {
09334:                    return byteBase.getInt32(28);
09335:                }
09336:
09337:                public final void set_dwReserved(int val) {
09338:                    byteBase.setInt32(32, val);
09339:                }
09340:
09341:                public final int get_dwReserved() {
09342:                    return byteBase.getInt32(32);
09343:                }
09344:
09345:                public final void set_lpSurface(VoidPointer val) {
09346:                    byteBase.setPointer(NativeBridge.is64 ? 40 : 36, val);
09347:                }
09348:
09349:                public final VoidPointer get_lpSurface() {
09350:                    return nb.createInt8Pointer(byteBase
09351:                            .getAddress(NativeBridge.is64 ? 40 : 36));
09352:                }
09353:
09354:                public final DDCOLORKEY get_ddckCKDestOverlay() {
09355:                    return instance
09356:                            .createDDCOLORKEY(getElementPointer(NativeBridge.is64 ? 48
09357:                                    : 40));
09358:                }
09359:
09360:                public final void set_dwEmptyFaceColor(int val) {
09361:                    byteBase.setInt32(NativeBridge.is64 ? 48 : 40, val);
09362:                }
09363:
09364:                public final int get_dwEmptyFaceColor() {
09365:                    return byteBase.getInt32(NativeBridge.is64 ? 48 : 40);
09366:                }
09367:
09368:                public final DDCOLORKEY get_ddckCKDestBlt() {
09369:                    return instance
09370:                            .createDDCOLORKEY(getElementPointer(NativeBridge.is64 ? 56
09371:                                    : 48));
09372:                }
09373:
09374:                public final DDCOLORKEY get_ddckCKSrcOverlay() {
09375:                    return instance
09376:                            .createDDCOLORKEY(getElementPointer(NativeBridge.is64 ? 64
09377:                                    : 56));
09378:                }
09379:
09380:                public final DDCOLORKEY get_ddckCKSrcBlt() {
09381:                    return instance
09382:                            .createDDCOLORKEY(getElementPointer(NativeBridge.is64 ? 72
09383:                                    : 64));
09384:                }
09385:
09386:                public final DDPIXELFORMAT get_ddpfPixelFormat() {
09387:                    return instance
09388:                            .createDDPIXELFORMAT(getElementPointer(NativeBridge.is64 ? 80
09389:                                    : 72));
09390:                }
09391:
09392:                public final void set_dwFVF(int val) {
09393:                    byteBase.setInt32(NativeBridge.is64 ? 80 : 72, val);
09394:                }
09395:
09396:                public final int get_dwFVF() {
09397:                    return byteBase.getInt32(NativeBridge.is64 ? 80 : 72);
09398:                }
09399:
09400:                public final Win32.DDSCAPS2 get_ddsCaps() {
09401:                    return Win32.instance
09402:                            .createDDSCAPS2(getElementPointer(NativeBridge.is64 ? 112
09403:                                    : 104));
09404:                }
09405:
09406:                public final void set_dwTextureStage(int val) {
09407:                    byteBase.setInt32(NativeBridge.is64 ? 128 : 120, val);
09408:                }
09409:
09410:                public final int get_dwTextureStage() {
09411:                    return byteBase.getInt32(NativeBridge.is64 ? 128 : 120);
09412:                }
09413:
09414:                @Override
09415:                public int size() {
09416:                    return sizeof;
09417:                }
09418:            }
09419:
09420:            public final DDSURFACEDESC2 createDDSURFACEDESC2(boolean direct) {
09421:                return new DDSURFACEDESC2(direct);
09422:            }
09423:
09424:            public final DDSURFACEDESC2 createDDSURFACEDESC2(VoidPointer base) {
09425:                return new DDSURFACEDESC2(base);
09426:            }
09427:
09428:            public final DDSURFACEDESC2 createDDSURFACEDESC2(long addr) {
09429:                return new DDSURFACEDESC2(addr);
09430:            }
09431:
09432:            public static class IDirectDrawSurface7 extends CommonStructWrapper {
09433:
09434:                public static final int sizeof = NativeBridge.is64 ? 8 : 4;
09435:
09436:                IDirectDrawSurface7Vtbl vtbl;
09437:
09438:                IDirectDrawSurface7(long addr) {
09439:                    super (addr);
09440:                    vtbl = get_lpVtbl();
09441:                }
09442:
09443:                public final IDirectDrawSurface7Vtbl get_lpVtbl() {
09444:                    return instance.createIDirectDrawSurface7Vtbl(byteBase
09445:                            .getAddress(0));
09446:                }
09447:
09448:                public final int QueryInterface(Win32.GUID riid,
09449:                        PointerPointer ppvObj) {
09450:                    return vtbl.QueryInterface(this , riid, ppvObj);
09451:                }
09452:
09453:                public final int AddRef() {
09454:                    return vtbl.AddRef(this );
09455:                }
09456:
09457:                public final int Release() {
09458:                    return vtbl.Release(this );
09459:                }
09460:
09461:                public final int AddAttachedSurface(IDirectDrawSurface7 param_1) {
09462:                    return vtbl.AddAttachedSurface(this , param_1);
09463:                }
09464:
09465:                public final int AddOverlayDirtyRect(Win32.RECT param_1) {
09466:                    return vtbl.AddOverlayDirtyRect(this , param_1);
09467:                }
09468:
09469:                public final int Blt(Win32.RECT param_1,
09470:                        IDirectDrawSurface7 param_2, Win32.RECT param_3,
09471:                        int param_4, DDBLTFX param_5) {
09472:                    return vtbl.Blt(this , param_1, param_2, param_3, param_4,
09473:                            param_5);
09474:                }
09475:
09476:                public final int BltBatch(DDBLTBATCH param_1, int param_2,
09477:                        int param_3) {
09478:                    return vtbl.BltBatch(this , param_1, param_2, param_3);
09479:                }
09480:
09481:                public final int BltFast(int param_1, int param_2,
09482:                        IDirectDrawSurface7 param_3, Win32.RECT param_4,
09483:                        int param_5) {
09484:                    return vtbl.BltFast(this , param_1, param_2, param_3,
09485:                            param_4, param_5);
09486:                }
09487:
09488:                public final int DeleteAttachedSurface(int param_1,
09489:                        IDirectDrawSurface7 param_2) {
09490:                    return vtbl.DeleteAttachedSurface(this , param_1, param_2);
09491:                }
09492:
09493:                public final int EnumAttachedSurfaces(VoidPointer param_1,
09494:                        long param_2) {
09495:                    return vtbl.EnumAttachedSurfaces(this , param_1, param_2);
09496:                }
09497:
09498:                public final int EnumOverlayZOrders(int param_1,
09499:                        VoidPointer param_2, long param_3) {
09500:                    return vtbl.EnumOverlayZOrders(this , param_1, param_2,
09501:                            param_3);
09502:                }
09503:
09504:                public final int Flip(IDirectDrawSurface7 param_1, int param_2) {
09505:                    return vtbl.Flip(this , param_1, param_2);
09506:                }
09507:
09508:                public final int GetAttachedSurface(Win32.DDSCAPS2 param_1,
09509:                        PointerPointer param_2) {
09510:                    return vtbl.GetAttachedSurface(this , param_1, param_2);
09511:                }
09512:
09513:                public final int GetBltStatus(int param_1) {
09514:                    return vtbl.GetBltStatus(this , param_1);
09515:                }
09516:
09517:                public final int GetCaps(Win32.DDSCAPS2 param_1) {
09518:                    return vtbl.GetCaps(this , param_1);
09519:                }
09520:
09521:                public final int GetClipper(PointerPointer param_1) {
09522:                    return vtbl.GetClipper(this , param_1);
09523:                }
09524:
09525:                public final int GetColorKey(int param_1, DDCOLORKEY param_2) {
09526:                    return vtbl.GetColorKey(this , param_1, param_2);
09527:                }
09528:
09529:                public final int GetDC(PointerPointer param_1) {
09530:                    return vtbl.GetDC(this , param_1);
09531:                }
09532:
09533:                public final int GetFlipStatus(int param_1) {
09534:                    return vtbl.GetFlipStatus(this , param_1);
09535:                }
09536:
09537:                public final int GetOverlayPosition(Int32Pointer param_1,
09538:                        Int32Pointer param_2) {
09539:                    return vtbl.GetOverlayPosition(this , param_1, param_2);
09540:                }
09541:
09542:                public final int GetPalette(PointerPointer param_1) {
09543:                    return vtbl.GetPalette(this , param_1);
09544:                }
09545:
09546:                public final int GetPixelFormat(DDPIXELFORMAT param_1) {
09547:                    return vtbl.GetPixelFormat(this , param_1);
09548:                }
09549:
09550:                public final int GetSurfaceDesc(Win32.DDSURFACEDESC2 param_1) {
09551:                    return vtbl.GetSurfaceDesc(this , param_1);
09552:                }
09553:
09554:                public final int Initialize(Win32.IDirectDraw param_1,
09555:                        Win32.DDSURFACEDESC2 param_2) {
09556:                    return vtbl.Initialize(this , param_1, param_2);
09557:                }
09558:
09559:                public final int IsLost() {
09560:                    return vtbl.IsLost(this );
09561:                }
09562:
09563:                public final int Lock(Win32.RECT param_1,
09564:                        Win32.DDSURFACEDESC2 param_2, int param_3,
09565:                        VoidPointer param_4) {
09566:                    return vtbl.Lock(this , param_1, param_2, param_3, param_4);
09567:                }
09568:
09569:                public final int ReleaseDC(long param_1) {
09570:                    return vtbl.ReleaseDC(this , param_1);
09571:                }
09572:
09573:                public final int Restore() {
09574:                    return vtbl.Restore(this );
09575:                }
09576:
09577:                public final int SetClipper(Win32.IDirectDrawClipper param_1) {
09578:                    return vtbl.SetClipper(this , param_1);
09579:                }
09580:
09581:                public final int SetColorKey(int param_1, DDCOLORKEY param_2) {
09582:                    return vtbl.SetColorKey(this , param_1, param_2);
09583:                }
09584:
09585:                public final int SetOverlayPosition(int param_1, int param_2) {
09586:                    return vtbl.SetOverlayPosition(this , param_1, param_2);
09587:                }
09588:
09589:                public final int SetPalette(Win32.IDirectDrawPalette param_1) {
09590:                    return vtbl.SetPalette(this , param_1);
09591:                }
09592:
09593:                public final int Unlock(Win32.RECT param_1) {
09594:                    return vtbl.Unlock(this , param_1);
09595:                }
09596:
09597:                public final int UpdateOverlay(Win32.RECT param_1,
09598:                        IDirectDrawSurface7 param_2, Win32.RECT param_3,
09599:                        int param_4, DDOVERLAYFX param_5) {
09600:                    return vtbl.UpdateOverlay(this , param_1, param_2, param_3,
09601:                            param_4, param_5);
09602:                }
09603:
09604:                public final int UpdateOverlayDisplay(int param_1) {
09605:                    return vtbl.UpdateOverlayDisplay(this , param_1);
09606:                }
09607:
09608:                public final int UpdateOverlayZOrder(int param_1,
09609:                        IDirectDrawSurface7 param_2) {
09610:                    return vtbl.UpdateOverlayZOrder(this , param_1, param_2);
09611:                }
09612:
09613:                public final int GetDDInterface(PointerPointer param_1) {
09614:                    return vtbl.GetDDInterface(this , param_1);
09615:                }
09616:
09617:                public final int PageLock(int param_1) {
09618:                    return vtbl.PageLock(this , param_1);
09619:                }
09620:
09621:                public final int PageUnlock(int param_1) {
09622:                    return vtbl.PageUnlock(this , param_1);
09623:                }
09624:
09625:                public final int SetSurfaceDesc(Win32.DDSURFACEDESC2 param_1,
09626:                        int param_2) {
09627:                    return vtbl.SetSurfaceDesc(this , param_1, param_2);
09628:                }
09629:
09630:                public final int SetPrivateData(Win32.GUID param_1,
09631:                        VoidPointer param_2, int param_3, int param_4) {
09632:                    return vtbl.SetPrivateData(this , param_1, param_2, param_3,
09633:                            param_4);
09634:                }
09635:
09636:                public final int GetPrivateData(Win32.GUID param_1,
09637:                        VoidPointer param_2, Int32Pointer param_3) {
09638:                    return vtbl.GetPrivateData(this , param_1, param_2, param_3);
09639:                }
09640:
09641:                public final int FreePrivateData(Win32.GUID param_1) {
09642:                    return vtbl.FreePrivateData(this , param_1);
09643:                }
09644:
09645:                public final int GetUniquenessValue(Int32Pointer param_1) {
09646:                    return vtbl.GetUniquenessValue(this , param_1);
09647:                }
09648:
09649:                public final int ChangeUniquenessValue() {
09650:                    return vtbl.ChangeUniquenessValue(this );
09651:                }
09652:
09653:                public final int SetPriority(int param_1) {
09654:                    return vtbl.SetPriority(this , param_1);
09655:                }
09656:
09657:                public final int GetPriority(Int32Pointer param_1) {
09658:                    return vtbl.GetPriority(this , param_1);
09659:                }
09660:
09661:                public final int SetLOD(int param_1) {
09662:                    return vtbl.SetLOD(this , param_1);
09663:                }
09664:
09665:                public final int GetLOD(Int32Pointer param_1) {
09666:                    return vtbl.GetLOD(this , param_1);
09667:                }
09668:
09669:                @Override
09670:                public int size() {
09671:                    return sizeof;
09672:                }
09673:            }
09674:
09675:            public final IDirectDrawSurface7 createIDirectDrawSurface7(long addr) {
09676:                return new IDirectDrawSurface7(addr);
09677:            }
09678:
09679:            public static class DDDEVICEIDENTIFIER2 extends CommonStructWrapper {
09680:
09681:                public static final int sizeof = 1072;
09682:
09683:                DDDEVICEIDENTIFIER2(boolean direct) {
09684:                    super (sizeof, direct);
09685:                }
09686:
09687:                DDDEVICEIDENTIFIER2(VoidPointer base) {
09688:                    super (base);
09689:                }
09690:
09691:                DDDEVICEIDENTIFIER2(long addr) {
09692:                    super (addr);
09693:                }
09694:
09695:                public final Int8Pointer get_szDriver() {
09696:                    return nb.createInt8Pointer(getElementPointer(0));
09697:                }
09698:
09699:                public final Int8Pointer get_szDescription() {
09700:                    return nb.createInt8Pointer(getElementPointer(512));
09701:                }
09702:
09703:                public final LARGE_INTEGER get_liDriverVersion() {
09704:                    return instance
09705:                            .createLARGE_INTEGER(getElementPointer(1024));
09706:                }
09707:
09708:                public final void set_dwVendorId(int val) {
09709:                    byteBase.setInt32(1032, val);
09710:                }
09711:
09712:                public final int get_dwVendorId() {
09713:                    return byteBase.getInt32(1032);
09714:                }
09715:
09716:                public final void set_dwDeviceId(int val) {
09717:                    byteBase.setInt32(1036, val);
09718:                }
09719:
09720:                public final int get_dwDeviceId() {
09721:                    return byteBase.getInt32(1036);
09722:                }
09723:
09724:                public final void set_dwSubSysId(int val) {
09725:                    byteBase.setInt32(1040, val);
09726:                }
09727:
09728:                public final int get_dwSubSysId() {
09729:                    return byteBase.getInt32(1040);
09730:                }
09731:
09732:                public final void set_dwRevision(int val) {
09733:                    byteBase.setInt32(1044, val);
09734:                }
09735:
09736:                public final int get_dwRevision() {
09737:                    return byteBase.getInt32(1044);
09738:                }
09739:
09740:                public final Win32.GUID get_guidDeviceIdentifier() {
09741:                    return Win32.instance.createGUID(getElementPointer(1048));
09742:                }
09743:
09744:                public final void set_dwWHQLLevel(int val) {
09745:                    byteBase.setInt32(1064, val);
09746:                }
09747:
09748:                public final int get_dwWHQLLevel() {
09749:                    return byteBase.getInt32(1064);
09750:                }
09751:
09752:                @Override
09753:                public int size() {
09754:                    return sizeof;
09755:                }
09756:            }
09757:
09758:            public final DDDEVICEIDENTIFIER2 createDDDEVICEIDENTIFIER2(
09759:                    boolean direct) {
09760:                return new DDDEVICEIDENTIFIER2(direct);
09761:            }
09762:
09763:            public final DDDEVICEIDENTIFIER2 createDDDEVICEIDENTIFIER2(
09764:                    VoidPointer base) {
09765:                return new DDDEVICEIDENTIFIER2(base);
09766:            }
09767:
09768:            public final DDDEVICEIDENTIFIER2 createDDDEVICEIDENTIFIER2(long addr) {
09769:                return new DDDEVICEIDENTIFIER2(addr);
09770:            }
09771:
09772:            public static class DDOVERLAYFX extends CommonStructWrapper {
09773:
09774:                public static final int sizeof = NativeBridge.is64 ? 72 : 56;
09775:
09776:                DDOVERLAYFX(boolean direct) {
09777:                    super (sizeof, direct);
09778:                }
09779:
09780:                DDOVERLAYFX(VoidPointer base) {
09781:                    super (base);
09782:                }
09783:
09784:                DDOVERLAYFX(long addr) {
09785:                    super (addr);
09786:                }
09787:
09788:                public final void set_dwSize(int val) {
09789:                    byteBase.setInt32(0, val);
09790:                }
09791:
09792:                public final int get_dwSize() {
09793:                    return byteBase.getInt32(0);
09794:                }
09795:
09796:                public final void set_dwAlphaEdgeBlendBitDepth(int val) {
09797:                    byteBase.setInt32(4, val);
09798:                }
09799:
09800:                public final int get_dwAlphaEdgeBlendBitDepth() {
09801:                    return byteBase.getInt32(4);
09802:                }
09803:
09804:                public final void set_dwAlphaEdgeBlend(int val) {
09805:                    byteBase.setInt32(8, val);
09806:                }
09807:
09808:                public final int get_dwAlphaEdgeBlend() {
09809:                    return byteBase.getInt32(8);
09810:                }
09811:
09812:                public final void set_dwReserved(int val) {
09813:                    byteBase.setInt32(12, val);
09814:                }
09815:
09816:                public final int get_dwReserved() {
09817:                    return byteBase.getInt32(12);
09818:                }
09819:
09820:                public final void set_dwAlphaDestConstBitDepth(int val) {
09821:                    byteBase.setInt32(16, val);
09822:                }
09823:
09824:                public final int get_dwAlphaDestConstBitDepth() {
09825:                    return byteBase.getInt32(16);
09826:                }
09827:
09828:                public final void set_dwAlphaDestConst(int val) {
09829:                    byteBase.setInt32(NativeBridge.is64 ? 24 : 20, val);
09830:                }
09831:
09832:                public final int get_dwAlphaDestConst() {
09833:                    return byteBase.getInt32(NativeBridge.is64 ? 24 : 20);
09834:                }
09835:
09836:                public final Win32.IDirectDrawSurface get_lpDDSAlphaDest() {
09837:                    return Win32.instance.createIDirectDrawSurface(byteBase
09838:                            .getAddress(NativeBridge.is64 ? 24 : 20));
09839:                }
09840:
09841:                public final void set_dwAlphaSrcConstBitDepth(int val) {
09842:                    byteBase.setInt32(NativeBridge.is64 ? 32 : 24, val);
09843:                }
09844:
09845:                public final int get_dwAlphaSrcConstBitDepth() {
09846:                    return byteBase.getInt32(NativeBridge.is64 ? 32 : 24);
09847:                }
09848:
09849:                public final void set_dwAlphaSrcConst(int val) {
09850:                    byteBase.setInt32(NativeBridge.is64 ? 40 : 28, val);
09851:                }
09852:
09853:                public final int get_dwAlphaSrcConst() {
09854:                    return byteBase.getInt32(NativeBridge.is64 ? 40 : 28);
09855:                }
09856:
09857:                public final Win32.IDirectDrawSurface get_lpDDSAlphaSrc() {
09858:                    return Win32.instance.createIDirectDrawSurface(byteBase
09859:                            .getAddress(NativeBridge.is64 ? 40 : 28));
09860:                }
09861:
09862:                public final DDCOLORKEY get_dckDestColorkey() {
09863:                    return instance
09864:                            .createDDCOLORKEY(getElementPointer(NativeBridge.is64 ? 48
09865:                                    : 32));
09866:                }
09867:
09868:                public final DDCOLORKEY get_dckSrcColorkey() {
09869:                    return instance
09870:                            .createDDCOLORKEY(getElementPointer(NativeBridge.is64 ? 56
09871:                                    : 40));
09872:                }
09873:
09874:                public final void set_dwDDFX(int val) {
09875:                    byteBase.setInt32(NativeBridge.is64 ? 64 : 48, val);
09876:                }
09877:
09878:                public final int get_dwDDFX() {
09879:                    return byteBase.getInt32(NativeBridge.is64 ? 64 : 48);
09880:                }
09881:
09882:                public final void set_dwFlags(int val) {
09883:                    byteBase.setInt32(NativeBridge.is64 ? 68 : 52, val);
09884:                }
09885:
09886:                public final int get_dwFlags() {
09887:                    return byteBase.getInt32(NativeBridge.is64 ? 68 : 52);
09888:                }
09889:
09890:                @Override
09891:                public int size() {
09892:                    return sizeof;
09893:                }
09894:            }
09895:
09896:            public final DDOVERLAYFX createDDOVERLAYFX(boolean direct) {
09897:                return new DDOVERLAYFX(direct);
09898:            }
09899:
09900:            public final DDOVERLAYFX createDDOVERLAYFX(VoidPointer base) {
09901:                return new DDOVERLAYFX(base);
09902:            }
09903:
09904:            public final DDOVERLAYFX createDDOVERLAYFX(long addr) {
09905:                return new DDOVERLAYFX(addr);
09906:            }
09907:
09908:            public static class DDBLTFX extends CommonStructWrapper {
09909:
09910:                public static final int sizeof = NativeBridge.is64 ? 128 : 100;
09911:
09912:                DDBLTFX(boolean direct) {
09913:                    super (sizeof, direct);
09914:                }
09915:
09916:                DDBLTFX(VoidPointer base) {
09917:                    super (base);
09918:                }
09919:
09920:                DDBLTFX(long addr) {
09921:                    super (addr);
09922:                }
09923:
09924:                public final void set_dwSize(int val) {
09925:                    byteBase.setInt32(0, val);
09926:                }
09927:
09928:                public final int get_dwSize() {
09929:                    return byteBase.getInt32(0);
09930:                }
09931:
09932:                public final void set_dwDDFX(int val) {
09933:                    byteBase.setInt32(4, val);
09934:                }
09935:
09936:                public final int get_dwDDFX() {
09937:                    return byteBase.getInt32(4);
09938:                }
09939:
09940:                public final void set_dwROP(int val) {
09941:                    byteBase.setInt32(8, val);
09942:                }
09943:
09944:                public final int get_dwROP() {
09945:                    return byteBase.getInt32(8);
09946:                }
09947:
09948:                public final void set_dwDDROP(int val) {
09949:                    byteBase.setInt32(12, val);
09950:                }
09951:
09952:                public final int get_dwDDROP() {
09953:                    return byteBase.getInt32(12);
09954:                }
09955:
09956:                public final void set_dwRotationAngle(int val) {
09957:                    byteBase.setInt32(16, val);
09958:                }
09959:
09960:                public final int get_dwRotationAngle() {
09961:                    return byteBase.getInt32(16);
09962:                }
09963:
09964:                public final void set_dwZBufferOpCode(int val) {
09965:                    byteBase.setInt32(20, val);
09966:                }
09967:
09968:                public final int get_dwZBufferOpCode() {
09969:                    return byteBase.getInt32(20);
09970:                }
09971:
09972:                public final void set_dwZBufferLow(int val) {
09973:                    byteBase.setInt32(24, val);
09974:                }
09975:
09976:                public final int get_dwZBufferLow() {
09977:                    return byteBase.getInt32(24);
09978:                }
09979:
09980:                public final void set_dwZBufferHigh(int val) {
09981:                    byteBase.setInt32(28, val);
09982:                }
09983:
09984:                public final int get_dwZBufferHigh() {
09985:                    return byteBase.getInt32(28);
09986:                }
09987:
09988:                public final void set_dwZBufferBaseDest(int val) {
09989:                    byteBase.setInt32(32, val);
09990:                }
09991:
09992:                public final int get_dwZBufferBaseDest() {
09993:                    return byteBase.getInt32(32);
09994:                }
09995:
09996:                public final void set_dwZDestConstBitDepth(int val) {
09997:                    byteBase.setInt32(36, val);
09998:                }
09999:
10000:                public final int get_dwZDestConstBitDepth() {
10001:                    return byteBase.getInt32(36);
10002:                }
10003:
10004:                public final void set_dwZDestConst(int val) {
10005:                    byteBase.setInt32(40, val);
10006:                }
10007:
10008:                public final int get_dwZDestConst() {
10009:                    return byteBase.getInt32(40);
10010:                }
10011:
10012:                public final Win32.IDirectDrawSurface get_lpDDSZBufferDest() {
10013:                    return Win32.instance.createIDirectDrawSurface(byteBase
10014:                            .getAddress(40));
10015:                }
10016:
10017:                public final void set_dwZSrcConstBitDepth(int val) {
10018:                    byteBase.setInt32(NativeBridge.is64 ? 48 : 44, val);
10019:                }
10020:
10021:                public final int get_dwZSrcConstBitDepth() {
10022:                    return byteBase.getInt32(NativeBridge.is64 ? 48 : 44);
10023:                }
10024:
10025:                public final void set_dwZSrcConst(int val) {
10026:                    byteBase.setInt32(NativeBridge.is64 ? 56 : 48, val);
10027:                }
10028:
10029:                public final int get_dwZSrcConst() {
10030:                    return byteBase.getInt32(NativeBridge.is64 ? 56 : 48);
10031:                }
10032:
10033:                public final Win32.IDirectDrawSurface get_lpDDSZBufferSrc() {
10034:                    return Win32.instance.createIDirectDrawSurface(byteBase
10035:                            .getAddress(NativeBridge.is64 ? 56 : 48));
10036:                }
10037:
10038:                public final void set_dwAlphaEdgeBlendBitDepth(int val) {
10039:                    byteBase.setInt32(NativeBridge.is64 ? 64 : 52, val);
10040:                }
10041:
10042:                public final int get_dwAlphaEdgeBlendBitDepth() {
10043:                    return byteBase.getInt32(NativeBridge.is64 ? 64 : 52);
10044:                }
10045:
10046:                public final void set_dwAlphaEdgeBlend(int val) {
10047:                    byteBase.setInt32(NativeBridge.is64 ? 68 : 56, val);
10048:                }
10049:
10050:                public final int get_dwAlphaEdgeBlend() {
10051:                    return byteBase.getInt32(NativeBridge.is64 ? 68 : 56);
10052:                }
10053:
10054:                public final void set_dwReserved(int val) {
10055:                    byteBase.setInt32(NativeBridge.is64 ? 72 : 60, val);
10056:                }
10057:
10058:                public final int get_dwReserved() {
10059:                    return byteBase.getInt32(NativeBridge.is64 ? 72 : 60);
10060:                }
10061:
10062:                public final void set_dwAlphaDestConstBitDepth(int val) {
10063:                    byteBase.setInt32(NativeBridge.is64 ? 76 : 64, val);
10064:                }
10065:
10066:                public final int get_dwAlphaDestConstBitDepth() {
10067:                    return byteBase.getInt32(NativeBridge.is64 ? 76 : 64);
10068:                }
10069:
10070:                public final void set_dwAlphaDestConst(int val) {
10071:                    byteBase.setInt32(NativeBridge.is64 ? 80 : 68, val);
10072:                }
10073:
10074:                public final int get_dwAlphaDestConst() {
10075:                    return byteBase.getInt32(NativeBridge.is64 ? 80 : 68);
10076:                }
10077:
10078:                public final Win32.IDirectDrawSurface get_lpDDSAlphaDest() {
10079:                    return Win32.instance.createIDirectDrawSurface(byteBase
10080:                            .getAddress(NativeBridge.is64 ? 80 : 68));
10081:                }
10082:
10083:                public final void set_dwAlphaSrcConstBitDepth(int val) {
10084:                    byteBase.setInt32(NativeBridge.is64 ? 88 : 72, val);
10085:                }
10086:
10087:                public final int get_dwAlphaSrcConstBitDepth() {
10088:                    return byteBase.getInt32(NativeBridge.is64 ? 88 : 72);
10089:                }
10090:
10091:                public final void set_dwAlphaSrcConst(int val) {
10092:                    byteBase.setInt32(NativeBridge.is64 ? 96 : 76, val);
10093:                }
10094:
10095:                public final int get_dwAlphaSrcConst() {
10096:                    return byteBase.getInt32(NativeBridge.is64 ? 96 : 76);
10097:                }
10098:
10099:                public final Win32.IDirectDrawSurface get_lpDDSAlphaSrc() {
10100:                    return Win32.instance.createIDirectDrawSurface(byteBase
10101:                            .getAddress(NativeBridge.is64 ? 96 : 76));
10102:                }
10103:
10104:                public final void set_dwFillColor(int val) {
10105:                    byteBase.setInt32(NativeBridge.is64 ? 104 : 80, val);
10106:                }
10107:
10108:                public final int get_dwFillColor() {
10109:                    return byteBase.getInt32(NativeBridge.is64 ? 104 : 80);
10110:                }
10111:
10112:                public final void set_dwFillDepth(int val) {
10113:                    byteBase.setInt32(NativeBridge.is64 ? 104 : 80, val);
10114:                }
10115:
10116:                public final int get_dwFillDepth() {
10117:                    return byteBase.getInt32(NativeBridge.is64 ? 104 : 80);
10118:                }
10119:
10120:                public final void set_dwFillPixel(int val) {
10121:                    byteBase.setInt32(NativeBridge.is64 ? 104 : 80, val);
10122:                }
10123:
10124:                public final int get_dwFillPixel() {
10125:                    return byteBase.getInt32(NativeBridge.is64 ? 104 : 80);
10126:                }
10127:
10128:                public final Win32.IDirectDrawSurface get_lpDDSPattern() {
10129:                    return Win32.instance.createIDirectDrawSurface(byteBase
10130:                            .getAddress(NativeBridge.is64 ? 104 : 80));
10131:                }
10132:
10133:                public final DDCOLORKEY get_ddckDestColorkey() {
10134:                    return instance
10135:                            .createDDCOLORKEY(getElementPointer(NativeBridge.is64 ? 112
10136:                                    : 84));
10137:                }
10138:
10139:                public final DDCOLORKEY get_ddckSrcColorkey() {
10140:                    return instance
10141:                            .createDDCOLORKEY(getElementPointer(NativeBridge.is64 ? 120
10142:                                    : 92));
10143:                }
10144:
10145:                @Override
10146:                public int size() {
10147:                    return sizeof;
10148:                }
10149:            }
10150:
10151:            public final DDBLTFX createDDBLTFX(boolean direct) {
10152:                return new DDBLTFX(direct);
10153:            }
10154:
10155:            public final DDBLTFX createDDBLTFX(VoidPointer base) {
10156:                return new DDBLTFX(base);
10157:            }
10158:
10159:            public final DDBLTFX createDDBLTFX(long addr) {
10160:                return new DDBLTFX(addr);
10161:            }
10162:
10163:            public static class DDPIXELFORMAT extends CommonStructWrapper {
10164:
10165:                public static final int sizeof = 32;
10166:
10167:                DDPIXELFORMAT(boolean direct) {
10168:                    super (sizeof, direct);
10169:                }
10170:
10171:                DDPIXELFORMAT(VoidPointer base) {
10172:                    super (base);
10173:                }
10174:
10175:                DDPIXELFORMAT(long addr) {
10176:                    super (addr);
10177:                }
10178:
10179:                public final void set_dwSize(int val) {
10180:                    byteBase.setInt32(0, val);
10181:                }
10182:
10183:                public final int get_dwSize() {
10184:                    return byteBase.getInt32(0);
10185:                }
10186:
10187:                public final void set_dwFlags(int val) {
10188:                    byteBase.setInt32(4, val);
10189:                }
10190:
10191:                public final int get_dwFlags() {
10192:                    return byteBase.getInt32(4);
10193:                }
10194:
10195:                public final void set_dwFourCC(int val) {
10196:                    byteBase.setInt32(8, val);
10197:                }
10198:
10199:                public final int get_dwFourCC() {
10200:                    return byteBase.getInt32(8);
10201:                }
10202:
10203:                public final void set_dwRGBBitCount(int val) {
10204:                    byteBase.setInt32(12, val);
10205:                }
10206:
10207:                public final int get_dwRGBBitCount() {
10208:                    return byteBase.getInt32(12);
10209:                }
10210:
10211:                public final void set_dwYUVBitCount(int val) {
10212:                    byteBase.setInt32(12, val);
10213:                }
10214:
10215:                public final int get_dwYUVBitCount() {
10216:                    return byteBase.getInt32(12);
10217:                }
10218:
10219:                public final void set_dwZBufferBitDepth(int val) {
10220:                    byteBase.setInt32(12, val);
10221:                }
10222:
10223:                public final int get_dwZBufferBitDepth() {
10224:                    return byteBase.getInt32(12);
10225:                }
10226:
10227:                public final void set_dwAlphaBitDepth(int val) {
10228:                    byteBase.setInt32(12, val);
10229:                }
10230:
10231:                public final int get_dwAlphaBitDepth() {
10232:                    return byteBase.getInt32(12);
10233:                }
10234:
10235:                public final void set_dwLuminanceBitCount(int val) {
10236:                    byteBase.setInt32(12, val);
10237:                }
10238:
10239:                public final int get_dwLuminanceBitCount() {
10240:                    return byteBase.getInt32(12);
10241:                }
10242:
10243:                public final void set_dwBumpBitCount(int val) {
10244:                    byteBase.setInt32(12, val);
10245:                }
10246:
10247:                public final int get_dwBumpBitCount() {
10248:                    return byteBase.getInt32(12);
10249:                }
10250:
10251:                public final void set_dwPrivateFormatBitCount(int val) {
10252:                    byteBase.setInt32(12, val);
10253:                }
10254:
10255:                public final int get_dwPrivateFormatBitCount() {
10256:                    return byteBase.getInt32(12);
10257:                }
10258:
10259:                public final void set_dwRBitMask(int val) {
10260:                    byteBase.setInt32(16, val);
10261:                }
10262:
10263:                public final int get_dwRBitMask() {
10264:                    return byteBase.getInt32(16);
10265:                }
10266:
10267:                public final void set_dwYBitMask(int val) {
10268:                    byteBase.setInt32(16, val);
10269:                }
10270:
10271:                public final int get_dwYBitMask() {
10272:                    return byteBase.getInt32(16);
10273:                }
10274:
10275:                public final void set_dwStencilBitDepth(int val) {
10276:                    byteBase.setInt32(16, val);
10277:                }
10278:
10279:                public final int get_dwStencilBitDepth() {
10280:                    return byteBase.getInt32(16);
10281:                }
10282:
10283:                public final void set_dwLuminanceBitMask(int val) {
10284:                    byteBase.setInt32(16, val);
10285:                }
10286:
10287:                public final int get_dwLuminanceBitMask() {
10288:                    return byteBase.getInt32(16);
10289:                }
10290:
10291:                public final void set_dwBumpDuBitMask(int val) {
10292:                    byteBase.setInt32(16, val);
10293:                }
10294:
10295:                public final int get_dwBumpDuBitMask() {
10296:                    return byteBase.getInt32(16);
10297:                }
10298:
10299:                public final void set_dwOperations(int val) {
10300:                    byteBase.setInt32(16, val);
10301:                }
10302:
10303:                public final int get_dwOperations() {
10304:                    return byteBase.getInt32(16);
10305:                }
10306:
10307:                public final void set_dwGBitMask(int val) {
10308:                    byteBase.setInt32(20, val);
10309:                }
10310:
10311:                public final int get_dwGBitMask() {
10312:                    return byteBase.getInt32(20);
10313:                }
10314:
10315:                public final void set_dwUBitMask(int val) {
10316:                    byteBase.setInt32(20, val);
10317:                }
10318:
10319:                public final int get_dwUBitMask() {
10320:                    return byteBase.getInt32(20);
10321:                }
10322:
10323:                public final void set_dwZBitMask(int val) {
10324:                    byteBase.setInt32(20, val);
10325:                }
10326:
10327:                public final int get_dwZBitMask() {
10328:                    return byteBase.getInt32(20);
10329:                }
10330:
10331:                public final void set_dwBumpDvBitMask(int val) {
10332:                    byteBase.setInt32(20, val);
10333:                }
10334:
10335:                public final int get_dwBumpDvBitMask() {
10336:                    return byteBase.getInt32(20);
10337:                }
10338:
10339:                public final void set_MultiSampleCaps_wFlipMSTypes(short val) {
10340:                    byteBase.setInt16(20, val);
10341:                }
10342:
10343:                public final short get_MultiSampleCaps_wFlipMSTypes() {
10344:                    return byteBase.getInt16(20);
10345:                }
10346:
10347:                public final void set_MultiSampleCaps_wBltMSTypes(short val) {
10348:                    byteBase.setInt16(22, val);
10349:                }
10350:
10351:                public final short get_MultiSampleCaps_wBltMSTypes() {
10352:                    return byteBase.getInt16(22);
10353:                }
10354:
10355:                public final void set_dwBBitMask(int val) {
10356:                    byteBase.setInt32(24, val);
10357:                }
10358:
10359:                public final int get_dwBBitMask() {
10360:                    return byteBase.getInt32(24);
10361:                }
10362:
10363:                public final void set_dwVBitMask(int val) {
10364:                    byteBase.setInt32(24, val);
10365:                }
10366:
10367:                public final int get_dwVBitMask() {
10368:                    return byteBase.getInt32(24);
10369:                }
10370:
10371:                public final void set_dwStencilBitMask(int val) {
10372:                    byteBase.setInt32(24, val);
10373:                }
10374:
10375:                public final int get_dwStencilBitMask() {
10376:                    return byteBase.getInt32(24);
10377:                }
10378:
10379:                public final void set_dwBumpLuminanceBitMask(int val) {
10380:                    byteBase.setInt32(24, val);
10381:                }
10382:
10383:                public final int get_dwBumpLuminanceBitMask() {
10384:                    return byteBase.getInt32(24);
10385:                }
10386:
10387:                public final void set_dwRGBAlphaBitMask(int val) {
10388:                    byteBase.setInt32(28, val);
10389:                }
10390:
10391:                public final int get_dwRGBAlphaBitMask() {
10392:                    return byteBase.getInt32(28);
10393:                }
10394:
10395:                public final void set_dwYUVAlphaBitMask(int val) {
10396:                    byteBase.setInt32(28, val);
10397:                }
10398:
10399:                public final int get_dwYUVAlphaBitMask() {
10400:                    return byteBase.getInt32(28);
10401:                }
10402:
10403:                public final void set_dwLuminanceAlphaBitMask(int val) {
10404:                    byteBase.setInt32(28, val);
10405:                }
10406:
10407:                public final int get_dwLuminanceAlphaBitMask() {
10408:                    return byteBase.getInt32(28);
10409:                }
10410:
10411:                public final void set_dwRGBZBitMask(int val) {
10412:                    byteBase.setInt32(28, val);
10413:                }
10414:
10415:                public final int get_dwRGBZBitMask() {
10416:                    return byteBase.getInt32(28);
10417:                }
10418:
10419:                public final void set_dwYUVZBitMask(int val) {
10420:                    byteBase.setInt32(28, val);
10421:                }
10422:
10423:                public final int get_dwYUVZBitMask() {
10424:                    return byteBase.getInt32(28);
10425:                }
10426:
10427:                @Override
10428:                public int size() {
10429:                    return sizeof;
10430:                }
10431:            }
10432:
10433:            public final DDPIXELFORMAT createDDPIXELFORMAT(boolean direct) {
10434:                return new DDPIXELFORMAT(direct);
10435:            }
10436:
10437:            public final DDPIXELFORMAT createDDPIXELFORMAT(VoidPointer base) {
10438:                return new DDPIXELFORMAT(base);
10439:            }
10440:
10441:            public final DDPIXELFORMAT createDDPIXELFORMAT(long addr) {
10442:                return new DDPIXELFORMAT(addr);
10443:            }
10444:
10445:            public static class IDirectDrawSurface7Vtbl extends
10446:                    CommonStructWrapper {
10447:
10448:                public static final int sizeof = NativeBridge.is64 ? 392 : 196;
10449:
10450:                IDirectDrawSurface7Vtbl(boolean direct) {
10451:                    super (sizeof, direct);
10452:                }
10453:
10454:                IDirectDrawSurface7Vtbl(VoidPointer base) {
10455:                    super (base);
10456:                }
10457:
10458:                IDirectDrawSurface7Vtbl(long addr) {
10459:                    super (addr);
10460:                }
10461:
10462:                public final void set_QueryInterface(long val) {
10463:                    byteBase.setAddress(0, val);
10464:                }
10465:
10466:                public final long get_QueryInterface() {
10467:                    return byteBase.getAddress(0);
10468:                }
10469:
10470:                public final int QueryInterface(Win32.IDirectDrawSurface7 This,
10471:                        Win32.GUID riid, PointerPointer ppvObj) {
10472:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
10473:                    long tmp_1 = riid == null ? 0 : riid.longLockPointer();
10474:                    long tmp_2 = ppvObj == null ? 0 : ppvObj.longLockPointer();
10475:                    int tmp_ret = instance.proxycall107(get_QueryInterface(),
10476:                            tmp_0, tmp_1, tmp_2);
10477:                    if (This != null) {
10478:                        This.unlock();
10479:                    }
10480:                    if (riid != null) {
10481:                        riid.unlock();
10482:                    }
10483:                    if (ppvObj != null) {
10484:                        ppvObj.unlock();
10485:                    }
10486:                    return tmp_ret;
10487:                }
10488:
10489:                public final void set_AddRef(long val) {
10490:                    byteBase.setAddress(NativeBridge.is64 ? 8 : 4, val);
10491:                }
10492:
10493:                public final long get_AddRef() {
10494:                    return byteBase.getAddress(NativeBridge.is64 ? 8 : 4);
10495:                }
10496:
10497:                public final int AddRef(Win32.IDirectDrawSurface7 This) {
10498:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
10499:                    int tmp_ret = instance.proxycall108(get_AddRef(), tmp_0);
10500:                    if (This != null) {
10501:                        This.unlock();
10502:                    }
10503:                    return tmp_ret;
10504:                }
10505:
10506:                public final void set_Release(long val) {
10507:                    byteBase.setAddress(NativeBridge.is64 ? 16 : 8, val);
10508:                }
10509:
10510:                public final long get_Release() {
10511:                    return byteBase.getAddress(NativeBridge.is64 ? 16 : 8);
10512:                }
10513:
10514:                public final int Release(Win32.IDirectDrawSurface7 This) {
10515:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
10516:                    int tmp_ret = instance.proxycall109(get_Release(), tmp_0);
10517:                    if (This != null) {
10518:                        This.unlock();
10519:                    }
10520:                    return tmp_ret;
10521:                }
10522:
10523:                public final void set_AddAttachedSurface(long val) {
10524:                    byteBase.setAddress(NativeBridge.is64 ? 24 : 12, val);
10525:                }
10526:
10527:                public final long get_AddAttachedSurface() {
10528:                    return byteBase.getAddress(NativeBridge.is64 ? 24 : 12);
10529:                }
10530:
10531:                public final int AddAttachedSurface(
10532:                        Win32.IDirectDrawSurface7 This,
10533:                        Win32.IDirectDrawSurface7 param_1) {
10534:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
10535:                    long tmp_1 = param_1 == null ? 0 : param_1
10536:                            .longLockPointer();
10537:                    int tmp_ret = instance.proxycall110(
10538:                            get_AddAttachedSurface(), tmp_0, tmp_1);
10539:                    if (This != null) {
10540:                        This.unlock();
10541:                    }
10542:                    if (param_1 != null) {
10543:                        param_1.unlock();
10544:                    }
10545:                    return tmp_ret;
10546:                }
10547:
10548:                public final void set_AddOverlayDirtyRect(long val) {
10549:                    byteBase.setAddress(NativeBridge.is64 ? 32 : 16, val);
10550:                }
10551:
10552:                public final long get_AddOverlayDirtyRect() {
10553:                    return byteBase.getAddress(NativeBridge.is64 ? 32 : 16);
10554:                }
10555:
10556:                public final int AddOverlayDirtyRect(
10557:                        Win32.IDirectDrawSurface7 This, Win32.RECT param_1) {
10558:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
10559:                    long tmp_1 = param_1 == null ? 0 : param_1
10560:                            .longLockPointer();
10561:                    int tmp_ret = instance.proxycall111(
10562:                            get_AddOverlayDirtyRect(), tmp_0, tmp_1);
10563:                    if (This != null) {
10564:                        This.unlock();
10565:                    }
10566:                    if (param_1 != null) {
10567:                        param_1.unlock();
10568:                    }
10569:                    return tmp_ret;
10570:                }
10571:
10572:                public final void set_Blt(long val) {
10573:                    byteBase.setAddress(NativeBridge.is64 ? 40 : 20, val);
10574:                }
10575:
10576:                public final long get_Blt() {
10577:                    return byteBase.getAddress(NativeBridge.is64 ? 40 : 20);
10578:                }
10579:
10580:                public final int Blt(Win32.IDirectDrawSurface7 This,
10581:                        Win32.RECT param_1, Win32.IDirectDrawSurface7 param_2,
10582:                        Win32.RECT param_3, int param_4, Win32.DDBLTFX param_5) {
10583:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
10584:                    long tmp_1 = param_1 == null ? 0 : param_1
10585:                            .longLockPointer();
10586:                    long tmp_2 = param_2 == null ? 0 : param_2
10587:                            .longLockPointer();
10588:                    long tmp_3 = param_3 == null ? 0 : param_3
10589:                            .longLockPointer();
10590:                    long tmp_4 = param_5 == null ? 0 : param_5
10591:                            .longLockPointer();
10592:                    int tmp_ret = instance.proxycall112(get_Blt(), tmp_0,
10593:                            tmp_1, tmp_2, tmp_3, param_4, tmp_4);
10594:                    if (This != null) {
10595:                        This.unlock();
10596:                    }
10597:                    if (param_1 != null) {
10598:                        param_1.unlock();
10599:                    }
10600:                    if (param_2 != null) {
10601:                        param_2.unlock();
10602:                    }
10603:                    if (param_3 != null) {
10604:                        param_3.unlock();
10605:                    }
10606:                    if (param_5 != null) {
10607:                        param_5.unlock();
10608:                    }
10609:                    return tmp_ret;
10610:                }
10611:
10612:                public final void set_BltBatch(long val) {
10613:                    byteBase.setAddress(NativeBridge.is64 ? 48 : 24, val);
10614:                }
10615:
10616:                public final long get_BltBatch() {
10617:                    return byteBase.getAddress(NativeBridge.is64 ? 48 : 24);
10618:                }
10619:
10620:                public final int BltBatch(Win32.IDirectDrawSurface7 This,
10621:                        DDBLTBATCH param_1, int param_2, int param_3) {
10622:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
10623:                    long tmp_1 = param_1 == null ? 0 : param_1
10624:                            .longLockPointer();
10625:                    int tmp_ret = instance.proxycall113(get_BltBatch(), tmp_0,
10626:                            tmp_1, param_2, param_3);
10627:                    if (This != null) {
10628:                        This.unlock();
10629:                    }
10630:                    if (param_1 != null) {
10631:                        param_1.unlock();
10632:                    }
10633:                    return tmp_ret;
10634:                }
10635:
10636:                public final void set_BltFast(long val) {
10637:                    byteBase.setAddress(NativeBridge.is64 ? 56 : 28, val);
10638:                }
10639:
10640:                public final long get_BltFast() {
10641:                    return byteBase.getAddress(NativeBridge.is64 ? 56 : 28);
10642:                }
10643:
10644:                public final int BltFast(Win32.IDirectDrawSurface7 This,
10645:                        int param_1, int param_2,
10646:                        Win32.IDirectDrawSurface7 param_3, Win32.RECT param_4,
10647:                        int param_5) {
10648:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
10649:                    long tmp_1 = param_3 == null ? 0 : param_3
10650:                            .longLockPointer();
10651:                    long tmp_2 = param_4 == null ? 0 : param_4
10652:                            .longLockPointer();
10653:                    int tmp_ret = instance.proxycall114(get_BltFast(), tmp_0,
10654:                            param_1, param_2, tmp_1, tmp_2, param_5);
10655:                    if (This != null) {
10656:                        This.unlock();
10657:                    }
10658:                    if (param_3 != null) {
10659:                        param_3.unlock();
10660:                    }
10661:                    if (param_4 != null) {
10662:                        param_4.unlock();
10663:                    }
10664:                    return tmp_ret;
10665:                }
10666:
10667:                public final void set_DeleteAttachedSurface(long val) {
10668:                    byteBase.setAddress(NativeBridge.is64 ? 64 : 32, val);
10669:                }
10670:
10671:                public final long get_DeleteAttachedSurface() {
10672:                    return byteBase.getAddress(NativeBridge.is64 ? 64 : 32);
10673:                }
10674:
10675:                public final int DeleteAttachedSurface(
10676:                        Win32.IDirectDrawSurface7 This, int param_1,
10677:                        Win32.IDirectDrawSurface7 param_2) {
10678:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
10679:                    long tmp_1 = param_2 == null ? 0 : param_2
10680:                            .longLockPointer();
10681:                    int tmp_ret = instance.proxycall115(
10682:                            get_DeleteAttachedSurface(), tmp_0, param_1, tmp_1);
10683:                    if (This != null) {
10684:                        This.unlock();
10685:                    }
10686:                    if (param_2 != null) {
10687:                        param_2.unlock();
10688:                    }
10689:                    return tmp_ret;
10690:                }
10691:
10692:                public final void set_EnumAttachedSurfaces(long val) {
10693:                    byteBase.setAddress(NativeBridge.is64 ? 72 : 36, val);
10694:                }
10695:
10696:                public final long get_EnumAttachedSurfaces() {
10697:                    return byteBase.getAddress(NativeBridge.is64 ? 72 : 36);
10698:                }
10699:
10700:                public final int EnumAttachedSurfaces(
10701:                        Win32.IDirectDrawSurface7 This, VoidPointer param_1,
10702:                        long param_2) {
10703:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
10704:                    long tmp_1 = param_1 == null ? 0 : param_1
10705:                            .longLockPointer();
10706:                    int tmp_ret = instance.proxycall116(
10707:                            get_EnumAttachedSurfaces(), tmp_0, tmp_1, param_2);
10708:                    if (This != null) {
10709:                        This.unlock();
10710:                    }
10711:                    if (param_1 != null) {
10712:                        param_1.unlock();
10713:                    }
10714:                    return tmp_ret;
10715:                }
10716:
10717:                public final void set_EnumOverlayZOrders(long val) {
10718:                    byteBase.setAddress(NativeBridge.is64 ? 80 : 40, val);
10719:                }
10720:
10721:                public final long get_EnumOverlayZOrders() {
10722:                    return byteBase.getAddress(NativeBridge.is64 ? 80 : 40);
10723:                }
10724:
10725:                public final int EnumOverlayZOrders(
10726:                        Win32.IDirectDrawSurface7 This, int param_1,
10727:                        VoidPointer param_2, long param_3) {
10728:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
10729:                    long tmp_1 = param_2 == null ? 0 : param_2
10730:                            .longLockPointer();
10731:                    int tmp_ret = instance.proxycall117(
10732:                            get_EnumOverlayZOrders(), tmp_0, param_1, tmp_1,
10733:                            param_3);
10734:                    if (This != null) {
10735:                        This.unlock();
10736:                    }
10737:                    if (param_2 != null) {
10738:                        param_2.unlock();
10739:                    }
10740:                    return tmp_ret;
10741:                }
10742:
10743:                public final void set_Flip(long val) {
10744:                    byteBase.setAddress(NativeBridge.is64 ? 88 : 44, val);
10745:                }
10746:
10747:                public final long get_Flip() {
10748:                    return byteBase.getAddress(NativeBridge.is64 ? 88 : 44);
10749:                }
10750:
10751:                public final int Flip(Win32.IDirectDrawSurface7 This,
10752:                        Win32.IDirectDrawSurface7 param_1, int param_2) {
10753:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
10754:                    long tmp_1 = param_1 == null ? 0 : param_1
10755:                            .longLockPointer();
10756:                    int tmp_ret = instance.proxycall118(get_Flip(), tmp_0,
10757:                            tmp_1, param_2);
10758:                    if (This != null) {
10759:                        This.unlock();
10760:                    }
10761:                    if (param_1 != null) {
10762:                        param_1.unlock();
10763:                    }
10764:                    return tmp_ret;
10765:                }
10766:
10767:                public final void set_GetAttachedSurface(long val) {
10768:                    byteBase.setAddress(NativeBridge.is64 ? 96 : 48, val);
10769:                }
10770:
10771:                public final long get_GetAttachedSurface() {
10772:                    return byteBase.getAddress(NativeBridge.is64 ? 96 : 48);
10773:                }
10774:
10775:                public final int GetAttachedSurface(
10776:                        Win32.IDirectDrawSurface7 This, Win32.DDSCAPS2 param_1,
10777:                        PointerPointer param_2) {
10778:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
10779:                    long tmp_1 = param_1 == null ? 0 : param_1
10780:                            .longLockPointer();
10781:                    long tmp_2 = param_2 == null ? 0 : param_2
10782:                            .longLockPointer();
10783:                    int tmp_ret = instance.proxycall119(
10784:                            get_GetAttachedSurface(), tmp_0, tmp_1, tmp_2);
10785:                    if (This != null) {
10786:                        This.unlock();
10787:                    }
10788:                    if (param_1 != null) {
10789:                        param_1.unlock();
10790:                    }
10791:                    if (param_2 != null) {
10792:                        param_2.unlock();
10793:                    }
10794:                    return tmp_ret;
10795:                }
10796:
10797:                public final void set_GetBltStatus(long val) {
10798:                    byteBase.setAddress(NativeBridge.is64 ? 104 : 52, val);
10799:                }
10800:
10801:                public final long get_GetBltStatus() {
10802:                    return byteBase.getAddress(NativeBridge.is64 ? 104 : 52);
10803:                }
10804:
10805:                public final int GetBltStatus(Win32.IDirectDrawSurface7 This,
10806:                        int param_1) {
10807:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
10808:                    int tmp_ret = instance.proxycall120(get_GetBltStatus(),
10809:                            tmp_0, param_1);
10810:                    if (This != null) {
10811:                        This.unlock();
10812:                    }
10813:                    return tmp_ret;
10814:                }
10815:
10816:                public final void set_GetCaps(long val) {
10817:                    byteBase.setAddress(NativeBridge.is64 ? 112 : 56, val);
10818:                }
10819:
10820:                public final long get_GetCaps() {
10821:                    return byteBase.getAddress(NativeBridge.is64 ? 112 : 56);
10822:                }
10823:
10824:                public final int GetCaps(Win32.IDirectDrawSurface7 This,
10825:                        Win32.DDSCAPS2 param_1) {
10826:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
10827:                    long tmp_1 = param_1 == null ? 0 : param_1
10828:                            .longLockPointer();
10829:                    int tmp_ret = instance.proxycall121(get_GetCaps(), tmp_0,
10830:                            tmp_1);
10831:                    if (This != null) {
10832:                        This.unlock();
10833:                    }
10834:                    if (param_1 != null) {
10835:                        param_1.unlock();
10836:                    }
10837:                    return tmp_ret;
10838:                }
10839:
10840:                public final void set_GetClipper(long val) {
10841:                    byteBase.setAddress(NativeBridge.is64 ? 120 : 60, val);
10842:                }
10843:
10844:                public final long get_GetClipper() {
10845:                    return byteBase.getAddress(NativeBridge.is64 ? 120 : 60);
10846:                }
10847:
10848:                public final int GetClipper(Win32.IDirectDrawSurface7 This,
10849:                        PointerPointer param_1) {
10850:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
10851:                    long tmp_1 = param_1 == null ? 0 : param_1
10852:                            .longLockPointer();
10853:                    int tmp_ret = instance.proxycall122(get_GetClipper(),
10854:                            tmp_0, tmp_1);
10855:                    if (This != null) {
10856:                        This.unlock();
10857:                    }
10858:                    if (param_1 != null) {
10859:                        param_1.unlock();
10860:                    }
10861:                    return tmp_ret;
10862:                }
10863:
10864:                public final void set_GetColorKey(long val) {
10865:                    byteBase.setAddress(NativeBridge.is64 ? 128 : 64, val);
10866:                }
10867:
10868:                public final long get_GetColorKey() {
10869:                    return byteBase.getAddress(NativeBridge.is64 ? 128 : 64);
10870:                }
10871:
10872:                public final int GetColorKey(Win32.IDirectDrawSurface7 This,
10873:                        int param_1, DDCOLORKEY param_2) {
10874:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
10875:                    long tmp_1 = param_2 == null ? 0 : param_2
10876:                            .longLockPointer();
10877:                    int tmp_ret = instance.proxycall123(get_GetColorKey(),
10878:                            tmp_0, param_1, tmp_1);
10879:                    if (This != null) {
10880:                        This.unlock();
10881:                    }
10882:                    if (param_2 != null) {
10883:                        param_2.unlock();
10884:                    }
10885:                    return tmp_ret;
10886:                }
10887:
10888:                public final void set_GetDC(long val) {
10889:                    byteBase.setAddress(NativeBridge.is64 ? 136 : 68, val);
10890:                }
10891:
10892:                public final long get_GetDC() {
10893:                    return byteBase.getAddress(NativeBridge.is64 ? 136 : 68);
10894:                }
10895:
10896:                public final int GetDC(Win32.IDirectDrawSurface7 This,
10897:                        PointerPointer param_1) {
10898:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
10899:                    long tmp_1 = param_1 == null ? 0 : param_1
10900:                            .longLockPointer();
10901:                    int tmp_ret = instance.proxycall124(get_GetDC(), tmp_0,
10902:                            tmp_1);
10903:                    if (This != null) {
10904:                        This.unlock();
10905:                    }
10906:                    if (param_1 != null) {
10907:                        param_1.unlock();
10908:                    }
10909:                    return tmp_ret;
10910:                }
10911:
10912:                public final void set_GetFlipStatus(long val) {
10913:                    byteBase.setAddress(NativeBridge.is64 ? 144 : 72, val);
10914:                }
10915:
10916:                public final long get_GetFlipStatus() {
10917:                    return byteBase.getAddress(NativeBridge.is64 ? 144 : 72);
10918:                }
10919:
10920:                public final int GetFlipStatus(Win32.IDirectDrawSurface7 This,
10921:                        int param_1) {
10922:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
10923:                    int tmp_ret = instance.proxycall125(get_GetFlipStatus(),
10924:                            tmp_0, param_1);
10925:                    if (This != null) {
10926:                        This.unlock();
10927:                    }
10928:                    return tmp_ret;
10929:                }
10930:
10931:                public final void set_GetOverlayPosition(long val) {
10932:                    byteBase.setAddress(NativeBridge.is64 ? 152 : 76, val);
10933:                }
10934:
10935:                public final long get_GetOverlayPosition() {
10936:                    return byteBase.getAddress(NativeBridge.is64 ? 152 : 76);
10937:                }
10938:
10939:                public final int GetOverlayPosition(
10940:                        Win32.IDirectDrawSurface7 This, Int32Pointer param_1,
10941:                        Int32Pointer param_2) {
10942:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
10943:                    long tmp_1 = param_1 == null ? 0 : param_1
10944:                            .longLockPointer();
10945:                    long tmp_2 = param_2 == null ? 0 : param_2
10946:                            .longLockPointer();
10947:                    int tmp_ret = instance.proxycall126(
10948:                            get_GetOverlayPosition(), tmp_0, tmp_1, tmp_2);
10949:                    if (This != null) {
10950:                        This.unlock();
10951:                    }
10952:                    if (param_1 != null) {
10953:                        param_1.unlock();
10954:                    }
10955:                    if (param_2 != null) {
10956:                        param_2.unlock();
10957:                    }
10958:                    return tmp_ret;
10959:                }
10960:
10961:                public final void set_GetPalette(long val) {
10962:                    byteBase.setAddress(NativeBridge.is64 ? 160 : 80, val);
10963:                }
10964:
10965:                public final long get_GetPalette() {
10966:                    return byteBase.getAddress(NativeBridge.is64 ? 160 : 80);
10967:                }
10968:
10969:                public final int GetPalette(Win32.IDirectDrawSurface7 This,
10970:                        PointerPointer param_1) {
10971:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
10972:                    long tmp_1 = param_1 == null ? 0 : param_1
10973:                            .longLockPointer();
10974:                    int tmp_ret = instance.proxycall127(get_GetPalette(),
10975:                            tmp_0, tmp_1);
10976:                    if (This != null) {
10977:                        This.unlock();
10978:                    }
10979:                    if (param_1 != null) {
10980:                        param_1.unlock();
10981:                    }
10982:                    return tmp_ret;
10983:                }
10984:
10985:                public final void set_GetPixelFormat(long val) {
10986:                    byteBase.setAddress(NativeBridge.is64 ? 168 : 84, val);
10987:                }
10988:
10989:                public final long get_GetPixelFormat() {
10990:                    return byteBase.getAddress(NativeBridge.is64 ? 168 : 84);
10991:                }
10992:
10993:                public final int GetPixelFormat(Win32.IDirectDrawSurface7 This,
10994:                        Win32.DDPIXELFORMAT param_1) {
10995:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
10996:                    long tmp_1 = param_1 == null ? 0 : param_1
10997:                            .longLockPointer();
10998:                    int tmp_ret = instance.proxycall128(get_GetPixelFormat(),
10999:                            tmp_0, tmp_1);
11000:                    if (This != null) {
11001:                        This.unlock();
11002:                    }
11003:                    if (param_1 != null) {
11004:                        param_1.unlock();
11005:                    }
11006:                    return tmp_ret;
11007:                }
11008:
11009:                public final void set_GetSurfaceDesc(long val) {
11010:                    byteBase.setAddress(NativeBridge.is64 ? 176 : 88, val);
11011:                }
11012:
11013:                public final long get_GetSurfaceDesc() {
11014:                    return byteBase.getAddress(NativeBridge.is64 ? 176 : 88);
11015:                }
11016:
11017:                public final int GetSurfaceDesc(Win32.IDirectDrawSurface7 This,
11018:                        Win32.DDSURFACEDESC2 param_1) {
11019:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11020:                    long tmp_1 = param_1 == null ? 0 : param_1
11021:                            .longLockPointer();
11022:                    int tmp_ret = instance.proxycall129(get_GetSurfaceDesc(),
11023:                            tmp_0, tmp_1);
11024:                    if (This != null) {
11025:                        This.unlock();
11026:                    }
11027:                    if (param_1 != null) {
11028:                        param_1.unlock();
11029:                    }
11030:                    return tmp_ret;
11031:                }
11032:
11033:                public final void set_Initialize(long val) {
11034:                    byteBase.setAddress(NativeBridge.is64 ? 184 : 92, val);
11035:                }
11036:
11037:                public final long get_Initialize() {
11038:                    return byteBase.getAddress(NativeBridge.is64 ? 184 : 92);
11039:                }
11040:
11041:                public final int Initialize(Win32.IDirectDrawSurface7 This,
11042:                        Win32.IDirectDraw param_1, Win32.DDSURFACEDESC2 param_2) {
11043:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11044:                    long tmp_1 = param_1 == null ? 0 : param_1
11045:                            .longLockPointer();
11046:                    long tmp_2 = param_2 == null ? 0 : param_2
11047:                            .longLockPointer();
11048:                    int tmp_ret = instance.proxycall130(get_Initialize(),
11049:                            tmp_0, tmp_1, tmp_2);
11050:                    if (This != null) {
11051:                        This.unlock();
11052:                    }
11053:                    if (param_1 != null) {
11054:                        param_1.unlock();
11055:                    }
11056:                    if (param_2 != null) {
11057:                        param_2.unlock();
11058:                    }
11059:                    return tmp_ret;
11060:                }
11061:
11062:                public final void set_IsLost(long val) {
11063:                    byteBase.setAddress(NativeBridge.is64 ? 192 : 96, val);
11064:                }
11065:
11066:                public final long get_IsLost() {
11067:                    return byteBase.getAddress(NativeBridge.is64 ? 192 : 96);
11068:                }
11069:
11070:                public final int IsLost(Win32.IDirectDrawSurface7 This) {
11071:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11072:                    int tmp_ret = instance.proxycall131(get_IsLost(), tmp_0);
11073:                    if (This != null) {
11074:                        This.unlock();
11075:                    }
11076:                    return tmp_ret;
11077:                }
11078:
11079:                public final void set_Lock(long val) {
11080:                    byteBase.setAddress(NativeBridge.is64 ? 200 : 100, val);
11081:                }
11082:
11083:                public final long get_Lock() {
11084:                    return byteBase.getAddress(NativeBridge.is64 ? 200 : 100);
11085:                }
11086:
11087:                public final int Lock(Win32.IDirectDrawSurface7 This,
11088:                        Win32.RECT param_1, Win32.DDSURFACEDESC2 param_2,
11089:                        int param_3, VoidPointer param_4) {
11090:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11091:                    long tmp_1 = param_1 == null ? 0 : param_1
11092:                            .longLockPointer();
11093:                    long tmp_2 = param_2 == null ? 0 : param_2
11094:                            .longLockPointer();
11095:                    long tmp_3 = param_4 == null ? 0 : param_4
11096:                            .longLockPointer();
11097:                    int tmp_ret = instance.proxycall132(get_Lock(), tmp_0,
11098:                            tmp_1, tmp_2, param_3, tmp_3);
11099:                    if (This != null) {
11100:                        This.unlock();
11101:                    }
11102:                    if (param_1 != null) {
11103:                        param_1.unlock();
11104:                    }
11105:                    if (param_2 != null) {
11106:                        param_2.unlock();
11107:                    }
11108:                    if (param_4 != null) {
11109:                        param_4.unlock();
11110:                    }
11111:                    return tmp_ret;
11112:                }
11113:
11114:                public final void set_ReleaseDC(long val) {
11115:                    byteBase.setAddress(NativeBridge.is64 ? 208 : 104, val);
11116:                }
11117:
11118:                public final long get_ReleaseDC() {
11119:                    return byteBase.getAddress(NativeBridge.is64 ? 208 : 104);
11120:                }
11121:
11122:                public final int ReleaseDC(Win32.IDirectDrawSurface7 This,
11123:                        long param_1) {
11124:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11125:                    int tmp_ret = instance.proxycall133(get_ReleaseDC(), tmp_0,
11126:                            param_1);
11127:                    if (This != null) {
11128:                        This.unlock();
11129:                    }
11130:                    return tmp_ret;
11131:                }
11132:
11133:                public final void set_Restore(long val) {
11134:                    byteBase.setAddress(NativeBridge.is64 ? 216 : 108, val);
11135:                }
11136:
11137:                public final long get_Restore() {
11138:                    return byteBase.getAddress(NativeBridge.is64 ? 216 : 108);
11139:                }
11140:
11141:                public final int Restore(Win32.IDirectDrawSurface7 This) {
11142:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11143:                    int tmp_ret = instance.proxycall134(get_Restore(), tmp_0);
11144:                    if (This != null) {
11145:                        This.unlock();
11146:                    }
11147:                    return tmp_ret;
11148:                }
11149:
11150:                public final void set_SetClipper(long val) {
11151:                    byteBase.setAddress(NativeBridge.is64 ? 224 : 112, val);
11152:                }
11153:
11154:                public final long get_SetClipper() {
11155:                    return byteBase.getAddress(NativeBridge.is64 ? 224 : 112);
11156:                }
11157:
11158:                public final int SetClipper(Win32.IDirectDrawSurface7 This,
11159:                        Win32.IDirectDrawClipper param_1) {
11160:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11161:                    long tmp_1 = param_1 == null ? 0 : param_1
11162:                            .longLockPointer();
11163:                    int tmp_ret = instance.proxycall135(get_SetClipper(),
11164:                            tmp_0, tmp_1);
11165:                    if (This != null) {
11166:                        This.unlock();
11167:                    }
11168:                    if (param_1 != null) {
11169:                        param_1.unlock();
11170:                    }
11171:                    return tmp_ret;
11172:                }
11173:
11174:                public final void set_SetColorKey(long val) {
11175:                    byteBase.setAddress(NativeBridge.is64 ? 232 : 116, val);
11176:                }
11177:
11178:                public final long get_SetColorKey() {
11179:                    return byteBase.getAddress(NativeBridge.is64 ? 232 : 116);
11180:                }
11181:
11182:                public final int SetColorKey(Win32.IDirectDrawSurface7 This,
11183:                        int param_1, DDCOLORKEY param_2) {
11184:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11185:                    long tmp_1 = param_2 == null ? 0 : param_2
11186:                            .longLockPointer();
11187:                    int tmp_ret = instance.proxycall136(get_SetColorKey(),
11188:                            tmp_0, param_1, tmp_1);
11189:                    if (This != null) {
11190:                        This.unlock();
11191:                    }
11192:                    if (param_2 != null) {
11193:                        param_2.unlock();
11194:                    }
11195:                    return tmp_ret;
11196:                }
11197:
11198:                public final void set_SetOverlayPosition(long val) {
11199:                    byteBase.setAddress(NativeBridge.is64 ? 240 : 120, val);
11200:                }
11201:
11202:                public final long get_SetOverlayPosition() {
11203:                    return byteBase.getAddress(NativeBridge.is64 ? 240 : 120);
11204:                }
11205:
11206:                public final int SetOverlayPosition(
11207:                        Win32.IDirectDrawSurface7 This, int param_1, int param_2) {
11208:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11209:                    int tmp_ret = instance.proxycall137(
11210:                            get_SetOverlayPosition(), tmp_0, param_1, param_2);
11211:                    if (This != null) {
11212:                        This.unlock();
11213:                    }
11214:                    return tmp_ret;
11215:                }
11216:
11217:                public final void set_SetPalette(long val) {
11218:                    byteBase.setAddress(NativeBridge.is64 ? 248 : 124, val);
11219:                }
11220:
11221:                public final long get_SetPalette() {
11222:                    return byteBase.getAddress(NativeBridge.is64 ? 248 : 124);
11223:                }
11224:
11225:                public final int SetPalette(Win32.IDirectDrawSurface7 This,
11226:                        Win32.IDirectDrawPalette param_1) {
11227:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11228:                    long tmp_1 = param_1 == null ? 0 : param_1
11229:                            .longLockPointer();
11230:                    int tmp_ret = instance.proxycall138(get_SetPalette(),
11231:                            tmp_0, tmp_1);
11232:                    if (This != null) {
11233:                        This.unlock();
11234:                    }
11235:                    if (param_1 != null) {
11236:                        param_1.unlock();
11237:                    }
11238:                    return tmp_ret;
11239:                }
11240:
11241:                public final void set_Unlock(long val) {
11242:                    byteBase.setAddress(NativeBridge.is64 ? 256 : 128, val);
11243:                }
11244:
11245:                public final long get_Unlock() {
11246:                    return byteBase.getAddress(NativeBridge.is64 ? 256 : 128);
11247:                }
11248:
11249:                public final int Unlock(Win32.IDirectDrawSurface7 This,
11250:                        Win32.RECT param_1) {
11251:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11252:                    long tmp_1 = param_1 == null ? 0 : param_1
11253:                            .longLockPointer();
11254:                    int tmp_ret = instance.proxycall139(get_Unlock(), tmp_0,
11255:                            tmp_1);
11256:                    if (This != null) {
11257:                        This.unlock();
11258:                    }
11259:                    if (param_1 != null) {
11260:                        param_1.unlock();
11261:                    }
11262:                    return tmp_ret;
11263:                }
11264:
11265:                public final void set_UpdateOverlay(long val) {
11266:                    byteBase.setAddress(NativeBridge.is64 ? 264 : 132, val);
11267:                }
11268:
11269:                public final long get_UpdateOverlay() {
11270:                    return byteBase.getAddress(NativeBridge.is64 ? 264 : 132);
11271:                }
11272:
11273:                public final int UpdateOverlay(Win32.IDirectDrawSurface7 This,
11274:                        Win32.RECT param_1, Win32.IDirectDrawSurface7 param_2,
11275:                        Win32.RECT param_3, int param_4,
11276:                        Win32.DDOVERLAYFX param_5) {
11277:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11278:                    long tmp_1 = param_1 == null ? 0 : param_1
11279:                            .longLockPointer();
11280:                    long tmp_2 = param_2 == null ? 0 : param_2
11281:                            .longLockPointer();
11282:                    long tmp_3 = param_3 == null ? 0 : param_3
11283:                            .longLockPointer();
11284:                    long tmp_4 = param_5 == null ? 0 : param_5
11285:                            .longLockPointer();
11286:                    int tmp_ret = instance.proxycall140(get_UpdateOverlay(),
11287:                            tmp_0, tmp_1, tmp_2, tmp_3, param_4, tmp_4);
11288:                    if (This != null) {
11289:                        This.unlock();
11290:                    }
11291:                    if (param_1 != null) {
11292:                        param_1.unlock();
11293:                    }
11294:                    if (param_2 != null) {
11295:                        param_2.unlock();
11296:                    }
11297:                    if (param_3 != null) {
11298:                        param_3.unlock();
11299:                    }
11300:                    if (param_5 != null) {
11301:                        param_5.unlock();
11302:                    }
11303:                    return tmp_ret;
11304:                }
11305:
11306:                public final void set_UpdateOverlayDisplay(long val) {
11307:                    byteBase.setAddress(NativeBridge.is64 ? 272 : 136, val);
11308:                }
11309:
11310:                public final long get_UpdateOverlayDisplay() {
11311:                    return byteBase.getAddress(NativeBridge.is64 ? 272 : 136);
11312:                }
11313:
11314:                public final int UpdateOverlayDisplay(
11315:                        Win32.IDirectDrawSurface7 This, int param_1) {
11316:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11317:                    int tmp_ret = instance.proxycall141(
11318:                            get_UpdateOverlayDisplay(), tmp_0, param_1);
11319:                    if (This != null) {
11320:                        This.unlock();
11321:                    }
11322:                    return tmp_ret;
11323:                }
11324:
11325:                public final void set_UpdateOverlayZOrder(long val) {
11326:                    byteBase.setAddress(NativeBridge.is64 ? 280 : 140, val);
11327:                }
11328:
11329:                public final long get_UpdateOverlayZOrder() {
11330:                    return byteBase.getAddress(NativeBridge.is64 ? 280 : 140);
11331:                }
11332:
11333:                public final int UpdateOverlayZOrder(
11334:                        Win32.IDirectDrawSurface7 This, int param_1,
11335:                        Win32.IDirectDrawSurface7 param_2) {
11336:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11337:                    long tmp_1 = param_2 == null ? 0 : param_2
11338:                            .longLockPointer();
11339:                    int tmp_ret = instance.proxycall142(
11340:                            get_UpdateOverlayZOrder(), tmp_0, param_1, tmp_1);
11341:                    if (This != null) {
11342:                        This.unlock();
11343:                    }
11344:                    if (param_2 != null) {
11345:                        param_2.unlock();
11346:                    }
11347:                    return tmp_ret;
11348:                }
11349:
11350:                public final void set_GetDDInterface(long val) {
11351:                    byteBase.setAddress(NativeBridge.is64 ? 288 : 144, val);
11352:                }
11353:
11354:                public final long get_GetDDInterface() {
11355:                    return byteBase.getAddress(NativeBridge.is64 ? 288 : 144);
11356:                }
11357:
11358:                public final int GetDDInterface(Win32.IDirectDrawSurface7 This,
11359:                        PointerPointer param_1) {
11360:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11361:                    long tmp_1 = param_1 == null ? 0 : param_1
11362:                            .longLockPointer();
11363:                    int tmp_ret = instance.proxycall143(get_GetDDInterface(),
11364:                            tmp_0, tmp_1);
11365:                    if (This != null) {
11366:                        This.unlock();
11367:                    }
11368:                    if (param_1 != null) {
11369:                        param_1.unlock();
11370:                    }
11371:                    return tmp_ret;
11372:                }
11373:
11374:                public final void set_PageLock(long val) {
11375:                    byteBase.setAddress(NativeBridge.is64 ? 296 : 148, val);
11376:                }
11377:
11378:                public final long get_PageLock() {
11379:                    return byteBase.getAddress(NativeBridge.is64 ? 296 : 148);
11380:                }
11381:
11382:                public final int PageLock(Win32.IDirectDrawSurface7 This,
11383:                        int param_1) {
11384:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11385:                    int tmp_ret = instance.proxycall144(get_PageLock(), tmp_0,
11386:                            param_1);
11387:                    if (This != null) {
11388:                        This.unlock();
11389:                    }
11390:                    return tmp_ret;
11391:                }
11392:
11393:                public final void set_PageUnlock(long val) {
11394:                    byteBase.setAddress(NativeBridge.is64 ? 304 : 152, val);
11395:                }
11396:
11397:                public final long get_PageUnlock() {
11398:                    return byteBase.getAddress(NativeBridge.is64 ? 304 : 152);
11399:                }
11400:
11401:                public final int PageUnlock(Win32.IDirectDrawSurface7 This,
11402:                        int param_1) {
11403:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11404:                    int tmp_ret = instance.proxycall145(get_PageUnlock(),
11405:                            tmp_0, param_1);
11406:                    if (This != null) {
11407:                        This.unlock();
11408:                    }
11409:                    return tmp_ret;
11410:                }
11411:
11412:                public final void set_SetSurfaceDesc(long val) {
11413:                    byteBase.setAddress(NativeBridge.is64 ? 312 : 156, val);
11414:                }
11415:
11416:                public final long get_SetSurfaceDesc() {
11417:                    return byteBase.getAddress(NativeBridge.is64 ? 312 : 156);
11418:                }
11419:
11420:                public final int SetSurfaceDesc(Win32.IDirectDrawSurface7 This,
11421:                        Win32.DDSURFACEDESC2 param_1, int param_2) {
11422:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11423:                    long tmp_1 = param_1 == null ? 0 : param_1
11424:                            .longLockPointer();
11425:                    int tmp_ret = instance.proxycall146(get_SetSurfaceDesc(),
11426:                            tmp_0, tmp_1, param_2);
11427:                    if (This != null) {
11428:                        This.unlock();
11429:                    }
11430:                    if (param_1 != null) {
11431:                        param_1.unlock();
11432:                    }
11433:                    return tmp_ret;
11434:                }
11435:
11436:                public final void set_SetPrivateData(long val) {
11437:                    byteBase.setAddress(NativeBridge.is64 ? 320 : 160, val);
11438:                }
11439:
11440:                public final long get_SetPrivateData() {
11441:                    return byteBase.getAddress(NativeBridge.is64 ? 320 : 160);
11442:                }
11443:
11444:                public final int SetPrivateData(Win32.IDirectDrawSurface7 This,
11445:                        Win32.GUID param_1, VoidPointer param_2, int param_3,
11446:                        int param_4) {
11447:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11448:                    long tmp_1 = param_1 == null ? 0 : param_1
11449:                            .longLockPointer();
11450:                    long tmp_2 = param_2 == null ? 0 : param_2
11451:                            .longLockPointer();
11452:                    int tmp_ret = instance.proxycall147(get_SetPrivateData(),
11453:                            tmp_0, tmp_1, tmp_2, param_3, param_4);
11454:                    if (This != null) {
11455:                        This.unlock();
11456:                    }
11457:                    if (param_1 != null) {
11458:                        param_1.unlock();
11459:                    }
11460:                    if (param_2 != null) {
11461:                        param_2.unlock();
11462:                    }
11463:                    return tmp_ret;
11464:                }
11465:
11466:                public final void set_GetPrivateData(long val) {
11467:                    byteBase.setAddress(NativeBridge.is64 ? 328 : 164, val);
11468:                }
11469:
11470:                public final long get_GetPrivateData() {
11471:                    return byteBase.getAddress(NativeBridge.is64 ? 328 : 164);
11472:                }
11473:
11474:                public final int GetPrivateData(Win32.IDirectDrawSurface7 This,
11475:                        Win32.GUID param_1, VoidPointer param_2,
11476:                        Int32Pointer param_3) {
11477:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11478:                    long tmp_1 = param_1 == null ? 0 : param_1
11479:                            .longLockPointer();
11480:                    long tmp_2 = param_2 == null ? 0 : param_2
11481:                            .longLockPointer();
11482:                    long tmp_3 = param_3 == null ? 0 : param_3
11483:                            .longLockPointer();
11484:                    int tmp_ret = instance.proxycall148(get_GetPrivateData(),
11485:                            tmp_0, tmp_1, tmp_2, tmp_3);
11486:                    if (This != null) {
11487:                        This.unlock();
11488:                    }
11489:                    if (param_1 != null) {
11490:                        param_1.unlock();
11491:                    }
11492:                    if (param_2 != null) {
11493:                        param_2.unlock();
11494:                    }
11495:                    if (param_3 != null) {
11496:                        param_3.unlock();
11497:                    }
11498:                    return tmp_ret;
11499:                }
11500:
11501:                public final void set_FreePrivateData(long val) {
11502:                    byteBase.setAddress(NativeBridge.is64 ? 336 : 168, val);
11503:                }
11504:
11505:                public final long get_FreePrivateData() {
11506:                    return byteBase.getAddress(NativeBridge.is64 ? 336 : 168);
11507:                }
11508:
11509:                public final int FreePrivateData(
11510:                        Win32.IDirectDrawSurface7 This, Win32.GUID param_1) {
11511:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11512:                    long tmp_1 = param_1 == null ? 0 : param_1
11513:                            .longLockPointer();
11514:                    int tmp_ret = instance.proxycall149(get_FreePrivateData(),
11515:                            tmp_0, tmp_1);
11516:                    if (This != null) {
11517:                        This.unlock();
11518:                    }
11519:                    if (param_1 != null) {
11520:                        param_1.unlock();
11521:                    }
11522:                    return tmp_ret;
11523:                }
11524:
11525:                public final void set_GetUniquenessValue(long val) {
11526:                    byteBase.setAddress(NativeBridge.is64 ? 344 : 172, val);
11527:                }
11528:
11529:                public final long get_GetUniquenessValue() {
11530:                    return byteBase.getAddress(NativeBridge.is64 ? 344 : 172);
11531:                }
11532:
11533:                public final int GetUniquenessValue(
11534:                        Win32.IDirectDrawSurface7 This, Int32Pointer param_1) {
11535:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11536:                    long tmp_1 = param_1 == null ? 0 : param_1
11537:                            .longLockPointer();
11538:                    int tmp_ret = instance.proxycall150(
11539:                            get_GetUniquenessValue(), tmp_0, tmp_1);
11540:                    if (This != null) {
11541:                        This.unlock();
11542:                    }
11543:                    if (param_1 != null) {
11544:                        param_1.unlock();
11545:                    }
11546:                    return tmp_ret;
11547:                }
11548:
11549:                public final void set_ChangeUniquenessValue(long val) {
11550:                    byteBase.setAddress(NativeBridge.is64 ? 352 : 176, val);
11551:                }
11552:
11553:                public final long get_ChangeUniquenessValue() {
11554:                    return byteBase.getAddress(NativeBridge.is64 ? 352 : 176);
11555:                }
11556:
11557:                public final int ChangeUniquenessValue(
11558:                        Win32.IDirectDrawSurface7 This) {
11559:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11560:                    int tmp_ret = instance.proxycall151(
11561:                            get_ChangeUniquenessValue(), tmp_0);
11562:                    if (This != null) {
11563:                        This.unlock();
11564:                    }
11565:                    return tmp_ret;
11566:                }
11567:
11568:                public final void set_SetPriority(long val) {
11569:                    byteBase.setAddress(NativeBridge.is64 ? 360 : 180, val);
11570:                }
11571:
11572:                public final long get_SetPriority() {
11573:                    return byteBase.getAddress(NativeBridge.is64 ? 360 : 180);
11574:                }
11575:
11576:                public final int SetPriority(Win32.IDirectDrawSurface7 This,
11577:                        int param_1) {
11578:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11579:                    int tmp_ret = instance.proxycall152(get_SetPriority(),
11580:                            tmp_0, param_1);
11581:                    if (This != null) {
11582:                        This.unlock();
11583:                    }
11584:                    return tmp_ret;
11585:                }
11586:
11587:                public final void set_GetPriority(long val) {
11588:                    byteBase.setAddress(NativeBridge.is64 ? 368 : 184, val);
11589:                }
11590:
11591:                public final long get_GetPriority() {
11592:                    return byteBase.getAddress(NativeBridge.is64 ? 368 : 184);
11593:                }
11594:
11595:                public final int GetPriority(Win32.IDirectDrawSurface7 This,
11596:                        Int32Pointer param_1) {
11597:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11598:                    long tmp_1 = param_1 == null ? 0 : param_1
11599:                            .longLockPointer();
11600:                    int tmp_ret = instance.proxycall153(get_GetPriority(),
11601:                            tmp_0, tmp_1);
11602:                    if (This != null) {
11603:                        This.unlock();
11604:                    }
11605:                    if (param_1 != null) {
11606:                        param_1.unlock();
11607:                    }
11608:                    return tmp_ret;
11609:                }
11610:
11611:                public final void set_SetLOD(long val) {
11612:                    byteBase.setAddress(NativeBridge.is64 ? 376 : 188, val);
11613:                }
11614:
11615:                public final long get_SetLOD() {
11616:                    return byteBase.getAddress(NativeBridge.is64 ? 376 : 188);
11617:                }
11618:
11619:                public final int SetLOD(Win32.IDirectDrawSurface7 This,
11620:                        int param_1) {
11621:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11622:                    int tmp_ret = instance.proxycall154(get_SetLOD(), tmp_0,
11623:                            param_1);
11624:                    if (This != null) {
11625:                        This.unlock();
11626:                    }
11627:                    return tmp_ret;
11628:                }
11629:
11630:                public final void set_GetLOD(long val) {
11631:                    byteBase.setAddress(NativeBridge.is64 ? 384 : 192, val);
11632:                }
11633:
11634:                public final long get_GetLOD() {
11635:                    return byteBase.getAddress(NativeBridge.is64 ? 384 : 192);
11636:                }
11637:
11638:                public final int GetLOD(Win32.IDirectDrawSurface7 This,
11639:                        Int32Pointer param_1) {
11640:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11641:                    long tmp_1 = param_1 == null ? 0 : param_1
11642:                            .longLockPointer();
11643:                    int tmp_ret = instance.proxycall155(get_GetLOD(), tmp_0,
11644:                            tmp_1);
11645:                    if (This != null) {
11646:                        This.unlock();
11647:                    }
11648:                    if (param_1 != null) {
11649:                        param_1.unlock();
11650:                    }
11651:                    return tmp_ret;
11652:                }
11653:
11654:                @Override
11655:                public int size() {
11656:                    return sizeof;
11657:                }
11658:            }
11659:
11660:            public final IDirectDrawSurface7Vtbl createIDirectDrawSurface7Vtbl(
11661:                    boolean direct) {
11662:                return new IDirectDrawSurface7Vtbl(direct);
11663:            }
11664:
11665:            public final IDirectDrawSurface7Vtbl createIDirectDrawSurface7Vtbl(
11666:                    VoidPointer base) {
11667:                return new IDirectDrawSurface7Vtbl(base);
11668:            }
11669:
11670:            public final IDirectDrawSurface7Vtbl createIDirectDrawSurface7Vtbl(
11671:                    long addr) {
11672:                return new IDirectDrawSurface7Vtbl(addr);
11673:            }
11674:
11675:            public static class DDCOLORKEY extends CommonStructWrapper {
11676:
11677:                public static final int sizeof = 8;
11678:
11679:                DDCOLORKEY(boolean direct) {
11680:                    super (sizeof, direct);
11681:                }
11682:
11683:                DDCOLORKEY(VoidPointer base) {
11684:                    super (base);
11685:                }
11686:
11687:                DDCOLORKEY(long addr) {
11688:                    super (addr);
11689:                }
11690:
11691:                public final void set_dwColorSpaceLowValue(int val) {
11692:                    byteBase.setInt32(0, val);
11693:                }
11694:
11695:                public final int get_dwColorSpaceLowValue() {
11696:                    return byteBase.getInt32(0);
11697:                }
11698:
11699:                public final void set_dwColorSpaceHighValue(int val) {
11700:                    byteBase.setInt32(4, val);
11701:                }
11702:
11703:                public final int get_dwColorSpaceHighValue() {
11704:                    return byteBase.getInt32(4);
11705:                }
11706:
11707:                @Override
11708:                public int size() {
11709:                    return sizeof;
11710:                }
11711:            }
11712:
11713:            public final DDCOLORKEY createDDCOLORKEY(boolean direct) {
11714:                return new DDCOLORKEY(direct);
11715:            }
11716:
11717:            public final DDCOLORKEY createDDCOLORKEY(VoidPointer base) {
11718:                return new DDCOLORKEY(base);
11719:            }
11720:
11721:            public final DDCOLORKEY createDDCOLORKEY(long addr) {
11722:                return new DDCOLORKEY(addr);
11723:            }
11724:
11725:            public static class DDBLTBATCH extends CommonStructWrapper {
11726:
11727:                public static final int sizeof = NativeBridge.is64 ? 40 : 20;
11728:
11729:                DDBLTBATCH(boolean direct) {
11730:                    super (sizeof, direct);
11731:                }
11732:
11733:                DDBLTBATCH(VoidPointer base) {
11734:                    super (base);
11735:                }
11736:
11737:                DDBLTBATCH(long addr) {
11738:                    super (addr);
11739:                }
11740:
11741:                public final Win32.RECT get_lprDest() {
11742:                    return Win32.instance.createRECT(byteBase.getAddress(0));
11743:                }
11744:
11745:                public final Win32.IDirectDrawSurface get_lpDDSSrc() {
11746:                    return Win32.instance.createIDirectDrawSurface(byteBase
11747:                            .getAddress(NativeBridge.is64 ? 8 : 4));
11748:                }
11749:
11750:                public final Win32.RECT get_lprSrc() {
11751:                    return Win32.instance.createRECT(byteBase
11752:                            .getAddress(NativeBridge.is64 ? 16 : 8));
11753:                }
11754:
11755:                public final void set_dwFlags(int val) {
11756:                    byteBase.setInt32(NativeBridge.is64 ? 24 : 12, val);
11757:                }
11758:
11759:                public final int get_dwFlags() {
11760:                    return byteBase.getInt32(NativeBridge.is64 ? 24 : 12);
11761:                }
11762:
11763:                public final Win32.DDBLTFX get_lpDDBltFx() {
11764:                    return Win32.instance.createDDBLTFX(byteBase
11765:                            .getAddress(NativeBridge.is64 ? 32 : 16));
11766:                }
11767:
11768:                @Override
11769:                public int size() {
11770:                    return sizeof;
11771:                }
11772:            }
11773:
11774:            public final DDBLTBATCH createDDBLTBATCH(boolean direct) {
11775:                return new DDBLTBATCH(direct);
11776:            }
11777:
11778:            public final DDBLTBATCH createDDBLTBATCH(VoidPointer base) {
11779:                return new DDBLTBATCH(base);
11780:            }
11781:
11782:            public final DDBLTBATCH createDDBLTBATCH(long addr) {
11783:                return new DDBLTBATCH(addr);
11784:            }
11785:
11786:            public static class DDSCAPS extends CommonStructWrapper {
11787:
11788:                public static final int sizeof = 4;
11789:
11790:                DDSCAPS(boolean direct) {
11791:                    super (sizeof, direct);
11792:                }
11793:
11794:                DDSCAPS(VoidPointer base) {
11795:                    super (base);
11796:                }
11797:
11798:                DDSCAPS(long addr) {
11799:                    super (addr);
11800:                }
11801:
11802:                public final void set_dwCaps(int val) {
11803:                    byteBase.setInt32(0, val);
11804:                }
11805:
11806:                public final int get_dwCaps() {
11807:                    return byteBase.getInt32(0);
11808:                }
11809:
11810:                @Override
11811:                public int size() {
11812:                    return sizeof;
11813:                }
11814:            }
11815:
11816:            public final DDSCAPS createDDSCAPS(boolean direct) {
11817:                return new DDSCAPS(direct);
11818:            }
11819:
11820:            public final DDSCAPS createDDSCAPS(VoidPointer base) {
11821:                return new DDSCAPS(base);
11822:            }
11823:
11824:            public final DDSCAPS createDDSCAPS(long addr) {
11825:                return new DDSCAPS(addr);
11826:            }
11827:
11828:            public static class LARGE_INTEGER extends CommonStructWrapper {
11829:
11830:                public static final int sizeof = 8;
11831:
11832:                LARGE_INTEGER(boolean direct) {
11833:                    super (sizeof, direct);
11834:                }
11835:
11836:                LARGE_INTEGER(VoidPointer base) {
11837:                    super (base);
11838:                }
11839:
11840:                LARGE_INTEGER(long addr) {
11841:                    super (addr);
11842:                }
11843:
11844:                public final void set_LowPart(int val) {
11845:                    byteBase.setInt32(0, val);
11846:                }
11847:
11848:                public final int get_LowPart() {
11849:                    return byteBase.getInt32(0);
11850:                }
11851:
11852:                public final void set_HighPart(int val) {
11853:                    byteBase.setInt32(4, val);
11854:                }
11855:
11856:                public final int get_HighPart() {
11857:                    return byteBase.getInt32(4);
11858:                }
11859:
11860:                public final void set_u_LowPart(int val) {
11861:                    byteBase.setInt32(0, val);
11862:                }
11863:
11864:                public final int get_u_LowPart() {
11865:                    return byteBase.getInt32(0);
11866:                }
11867:
11868:                public final void set_u_HighPart(int val) {
11869:                    byteBase.setInt32(4, val);
11870:                }
11871:
11872:                public final int get_u_HighPart() {
11873:                    return byteBase.getInt32(4);
11874:                }
11875:
11876:                public final void set_QuadPart(long val) {
11877:                    byteBase.setInt64(0, val);
11878:                }
11879:
11880:                public final long get_QuadPart() {
11881:                    return byteBase.getInt64(0);
11882:                }
11883:
11884:                @Override
11885:                public int size() {
11886:                    return sizeof;
11887:                }
11888:            }
11889:
11890:            public final LARGE_INTEGER createLARGE_INTEGER(boolean direct) {
11891:                return new LARGE_INTEGER(direct);
11892:            }
11893:
11894:            public final LARGE_INTEGER createLARGE_INTEGER(VoidPointer base) {
11895:                return new LARGE_INTEGER(base);
11896:            }
11897:
11898:            public final LARGE_INTEGER createLARGE_INTEGER(long addr) {
11899:                return new LARGE_INTEGER(addr);
11900:            }
11901:
11902:            public static class IDirectDrawSurfaceVtbl extends
11903:                    CommonStructWrapper {
11904:
11905:                public static final int sizeof = NativeBridge.is64 ? 288 : 144;
11906:
11907:                IDirectDrawSurfaceVtbl(boolean direct) {
11908:                    super (sizeof, direct);
11909:                }
11910:
11911:                IDirectDrawSurfaceVtbl(VoidPointer base) {
11912:                    super (base);
11913:                }
11914:
11915:                IDirectDrawSurfaceVtbl(long addr) {
11916:                    super (addr);
11917:                }
11918:
11919:                public final void set_QueryInterface(long val) {
11920:                    byteBase.setAddress(0, val);
11921:                }
11922:
11923:                public final long get_QueryInterface() {
11924:                    return byteBase.getAddress(0);
11925:                }
11926:
11927:                public final int QueryInterface(Win32.IDirectDrawSurface This,
11928:                        Win32.GUID riid, PointerPointer ppvObj) {
11929:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11930:                    long tmp_1 = riid == null ? 0 : riid.longLockPointer();
11931:                    long tmp_2 = ppvObj == null ? 0 : ppvObj.longLockPointer();
11932:                    int tmp_ret = instance.proxycall156(get_QueryInterface(),
11933:                            tmp_0, tmp_1, tmp_2);
11934:                    if (This != null) {
11935:                        This.unlock();
11936:                    }
11937:                    if (riid != null) {
11938:                        riid.unlock();
11939:                    }
11940:                    if (ppvObj != null) {
11941:                        ppvObj.unlock();
11942:                    }
11943:                    return tmp_ret;
11944:                }
11945:
11946:                public final void set_AddRef(long val) {
11947:                    byteBase.setAddress(NativeBridge.is64 ? 8 : 4, val);
11948:                }
11949:
11950:                public final long get_AddRef() {
11951:                    return byteBase.getAddress(NativeBridge.is64 ? 8 : 4);
11952:                }
11953:
11954:                public final int AddRef(Win32.IDirectDrawSurface This) {
11955:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11956:                    int tmp_ret = instance.proxycall157(get_AddRef(), tmp_0);
11957:                    if (This != null) {
11958:                        This.unlock();
11959:                    }
11960:                    return tmp_ret;
11961:                }
11962:
11963:                public final void set_Release(long val) {
11964:                    byteBase.setAddress(NativeBridge.is64 ? 16 : 8, val);
11965:                }
11966:
11967:                public final long get_Release() {
11968:                    return byteBase.getAddress(NativeBridge.is64 ? 16 : 8);
11969:                }
11970:
11971:                public final int Release(Win32.IDirectDrawSurface This) {
11972:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11973:                    int tmp_ret = instance.proxycall158(get_Release(), tmp_0);
11974:                    if (This != null) {
11975:                        This.unlock();
11976:                    }
11977:                    return tmp_ret;
11978:                }
11979:
11980:                public final void set_AddAttachedSurface(long val) {
11981:                    byteBase.setAddress(NativeBridge.is64 ? 24 : 12, val);
11982:                }
11983:
11984:                public final long get_AddAttachedSurface() {
11985:                    return byteBase.getAddress(NativeBridge.is64 ? 24 : 12);
11986:                }
11987:
11988:                public final int AddAttachedSurface(
11989:                        Win32.IDirectDrawSurface This,
11990:                        Win32.IDirectDrawSurface param_1) {
11991:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
11992:                    long tmp_1 = param_1 == null ? 0 : param_1
11993:                            .longLockPointer();
11994:                    int tmp_ret = instance.proxycall159(
11995:                            get_AddAttachedSurface(), tmp_0, tmp_1);
11996:                    if (This != null) {
11997:                        This.unlock();
11998:                    }
11999:                    if (param_1 != null) {
12000:                        param_1.unlock();
12001:                    }
12002:                    return tmp_ret;
12003:                }
12004:
12005:                public final void set_AddOverlayDirtyRect(long val) {
12006:                    byteBase.setAddress(NativeBridge.is64 ? 32 : 16, val);
12007:                }
12008:
12009:                public final long get_AddOverlayDirtyRect() {
12010:                    return byteBase.getAddress(NativeBridge.is64 ? 32 : 16);
12011:                }
12012:
12013:                public final int AddOverlayDirtyRect(
12014:                        Win32.IDirectDrawSurface This, Win32.RECT param_1) {
12015:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12016:                    long tmp_1 = param_1 == null ? 0 : param_1
12017:                            .longLockPointer();
12018:                    int tmp_ret = instance.proxycall160(
12019:                            get_AddOverlayDirtyRect(), tmp_0, tmp_1);
12020:                    if (This != null) {
12021:                        This.unlock();
12022:                    }
12023:                    if (param_1 != null) {
12024:                        param_1.unlock();
12025:                    }
12026:                    return tmp_ret;
12027:                }
12028:
12029:                public final void set_Blt(long val) {
12030:                    byteBase.setAddress(NativeBridge.is64 ? 40 : 20, val);
12031:                }
12032:
12033:                public final long get_Blt() {
12034:                    return byteBase.getAddress(NativeBridge.is64 ? 40 : 20);
12035:                }
12036:
12037:                public final int Blt(Win32.IDirectDrawSurface This,
12038:                        Win32.RECT param_1, Win32.IDirectDrawSurface param_2,
12039:                        Win32.RECT param_3, int param_4, Win32.DDBLTFX param_5) {
12040:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12041:                    long tmp_1 = param_1 == null ? 0 : param_1
12042:                            .longLockPointer();
12043:                    long tmp_2 = param_2 == null ? 0 : param_2
12044:                            .longLockPointer();
12045:                    long tmp_3 = param_3 == null ? 0 : param_3
12046:                            .longLockPointer();
12047:                    long tmp_4 = param_5 == null ? 0 : param_5
12048:                            .longLockPointer();
12049:                    int tmp_ret = instance.proxycall161(get_Blt(), tmp_0,
12050:                            tmp_1, tmp_2, tmp_3, param_4, tmp_4);
12051:                    if (This != null) {
12052:                        This.unlock();
12053:                    }
12054:                    if (param_1 != null) {
12055:                        param_1.unlock();
12056:                    }
12057:                    if (param_2 != null) {
12058:                        param_2.unlock();
12059:                    }
12060:                    if (param_3 != null) {
12061:                        param_3.unlock();
12062:                    }
12063:                    if (param_5 != null) {
12064:                        param_5.unlock();
12065:                    }
12066:                    return tmp_ret;
12067:                }
12068:
12069:                public final void set_BltBatch(long val) {
12070:                    byteBase.setAddress(NativeBridge.is64 ? 48 : 24, val);
12071:                }
12072:
12073:                public final long get_BltBatch() {
12074:                    return byteBase.getAddress(NativeBridge.is64 ? 48 : 24);
12075:                }
12076:
12077:                public final int BltBatch(Win32.IDirectDrawSurface This,
12078:                        Win32.DDBLTBATCH param_1, int param_2, int param_3) {
12079:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12080:                    long tmp_1 = param_1 == null ? 0 : param_1
12081:                            .longLockPointer();
12082:                    int tmp_ret = instance.proxycall162(get_BltBatch(), tmp_0,
12083:                            tmp_1, param_2, param_3);
12084:                    if (This != null) {
12085:                        This.unlock();
12086:                    }
12087:                    if (param_1 != null) {
12088:                        param_1.unlock();
12089:                    }
12090:                    return tmp_ret;
12091:                }
12092:
12093:                public final void set_BltFast(long val) {
12094:                    byteBase.setAddress(NativeBridge.is64 ? 56 : 28, val);
12095:                }
12096:
12097:                public final long get_BltFast() {
12098:                    return byteBase.getAddress(NativeBridge.is64 ? 56 : 28);
12099:                }
12100:
12101:                public final int BltFast(Win32.IDirectDrawSurface This,
12102:                        int param_1, int param_2,
12103:                        Win32.IDirectDrawSurface param_3, Win32.RECT param_4,
12104:                        int param_5) {
12105:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12106:                    long tmp_1 = param_3 == null ? 0 : param_3
12107:                            .longLockPointer();
12108:                    long tmp_2 = param_4 == null ? 0 : param_4
12109:                            .longLockPointer();
12110:                    int tmp_ret = instance.proxycall163(get_BltFast(), tmp_0,
12111:                            param_1, param_2, tmp_1, tmp_2, param_5);
12112:                    if (This != null) {
12113:                        This.unlock();
12114:                    }
12115:                    if (param_3 != null) {
12116:                        param_3.unlock();
12117:                    }
12118:                    if (param_4 != null) {
12119:                        param_4.unlock();
12120:                    }
12121:                    return tmp_ret;
12122:                }
12123:
12124:                public final void set_DeleteAttachedSurface(long val) {
12125:                    byteBase.setAddress(NativeBridge.is64 ? 64 : 32, val);
12126:                }
12127:
12128:                public final long get_DeleteAttachedSurface() {
12129:                    return byteBase.getAddress(NativeBridge.is64 ? 64 : 32);
12130:                }
12131:
12132:                public final int DeleteAttachedSurface(
12133:                        Win32.IDirectDrawSurface This, int param_1,
12134:                        Win32.IDirectDrawSurface param_2) {
12135:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12136:                    long tmp_1 = param_2 == null ? 0 : param_2
12137:                            .longLockPointer();
12138:                    int tmp_ret = instance.proxycall164(
12139:                            get_DeleteAttachedSurface(), tmp_0, param_1, tmp_1);
12140:                    if (This != null) {
12141:                        This.unlock();
12142:                    }
12143:                    if (param_2 != null) {
12144:                        param_2.unlock();
12145:                    }
12146:                    return tmp_ret;
12147:                }
12148:
12149:                public final void set_EnumAttachedSurfaces(long val) {
12150:                    byteBase.setAddress(NativeBridge.is64 ? 72 : 36, val);
12151:                }
12152:
12153:                public final long get_EnumAttachedSurfaces() {
12154:                    return byteBase.getAddress(NativeBridge.is64 ? 72 : 36);
12155:                }
12156:
12157:                public final int EnumAttachedSurfaces(
12158:                        Win32.IDirectDrawSurface This, VoidPointer param_1,
12159:                        long param_2) {
12160:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12161:                    long tmp_1 = param_1 == null ? 0 : param_1
12162:                            .longLockPointer();
12163:                    int tmp_ret = instance.proxycall165(
12164:                            get_EnumAttachedSurfaces(), tmp_0, tmp_1, param_2);
12165:                    if (This != null) {
12166:                        This.unlock();
12167:                    }
12168:                    if (param_1 != null) {
12169:                        param_1.unlock();
12170:                    }
12171:                    return tmp_ret;
12172:                }
12173:
12174:                public final void set_EnumOverlayZOrders(long val) {
12175:                    byteBase.setAddress(NativeBridge.is64 ? 80 : 40, val);
12176:                }
12177:
12178:                public final long get_EnumOverlayZOrders() {
12179:                    return byteBase.getAddress(NativeBridge.is64 ? 80 : 40);
12180:                }
12181:
12182:                public final int EnumOverlayZOrders(
12183:                        Win32.IDirectDrawSurface This, int param_1,
12184:                        VoidPointer param_2, long param_3) {
12185:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12186:                    long tmp_1 = param_2 == null ? 0 : param_2
12187:                            .longLockPointer();
12188:                    int tmp_ret = instance.proxycall166(
12189:                            get_EnumOverlayZOrders(), tmp_0, param_1, tmp_1,
12190:                            param_3);
12191:                    if (This != null) {
12192:                        This.unlock();
12193:                    }
12194:                    if (param_2 != null) {
12195:                        param_2.unlock();
12196:                    }
12197:                    return tmp_ret;
12198:                }
12199:
12200:                public final void set_Flip(long val) {
12201:                    byteBase.setAddress(NativeBridge.is64 ? 88 : 44, val);
12202:                }
12203:
12204:                public final long get_Flip() {
12205:                    return byteBase.getAddress(NativeBridge.is64 ? 88 : 44);
12206:                }
12207:
12208:                public final int Flip(Win32.IDirectDrawSurface This,
12209:                        Win32.IDirectDrawSurface param_1, int param_2) {
12210:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12211:                    long tmp_1 = param_1 == null ? 0 : param_1
12212:                            .longLockPointer();
12213:                    int tmp_ret = instance.proxycall167(get_Flip(), tmp_0,
12214:                            tmp_1, param_2);
12215:                    if (This != null) {
12216:                        This.unlock();
12217:                    }
12218:                    if (param_1 != null) {
12219:                        param_1.unlock();
12220:                    }
12221:                    return tmp_ret;
12222:                }
12223:
12224:                public final void set_GetAttachedSurface(long val) {
12225:                    byteBase.setAddress(NativeBridge.is64 ? 96 : 48, val);
12226:                }
12227:
12228:                public final long get_GetAttachedSurface() {
12229:                    return byteBase.getAddress(NativeBridge.is64 ? 96 : 48);
12230:                }
12231:
12232:                public final int GetAttachedSurface(
12233:                        Win32.IDirectDrawSurface This, Win32.DDSCAPS param_1,
12234:                        PointerPointer param_2) {
12235:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12236:                    long tmp_1 = param_1 == null ? 0 : param_1
12237:                            .longLockPointer();
12238:                    long tmp_2 = param_2 == null ? 0 : param_2
12239:                            .longLockPointer();
12240:                    int tmp_ret = instance.proxycall168(
12241:                            get_GetAttachedSurface(), tmp_0, tmp_1, tmp_2);
12242:                    if (This != null) {
12243:                        This.unlock();
12244:                    }
12245:                    if (param_1 != null) {
12246:                        param_1.unlock();
12247:                    }
12248:                    if (param_2 != null) {
12249:                        param_2.unlock();
12250:                    }
12251:                    return tmp_ret;
12252:                }
12253:
12254:                public final void set_GetBltStatus(long val) {
12255:                    byteBase.setAddress(NativeBridge.is64 ? 104 : 52, val);
12256:                }
12257:
12258:                public final long get_GetBltStatus() {
12259:                    return byteBase.getAddress(NativeBridge.is64 ? 104 : 52);
12260:                }
12261:
12262:                public final int GetBltStatus(Win32.IDirectDrawSurface This,
12263:                        int param_1) {
12264:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12265:                    int tmp_ret = instance.proxycall169(get_GetBltStatus(),
12266:                            tmp_0, param_1);
12267:                    if (This != null) {
12268:                        This.unlock();
12269:                    }
12270:                    return tmp_ret;
12271:                }
12272:
12273:                public final void set_GetCaps(long val) {
12274:                    byteBase.setAddress(NativeBridge.is64 ? 112 : 56, val);
12275:                }
12276:
12277:                public final long get_GetCaps() {
12278:                    return byteBase.getAddress(NativeBridge.is64 ? 112 : 56);
12279:                }
12280:
12281:                public final int GetCaps(Win32.IDirectDrawSurface This,
12282:                        Win32.DDSCAPS param_1) {
12283:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12284:                    long tmp_1 = param_1 == null ? 0 : param_1
12285:                            .longLockPointer();
12286:                    int tmp_ret = instance.proxycall170(get_GetCaps(), tmp_0,
12287:                            tmp_1);
12288:                    if (This != null) {
12289:                        This.unlock();
12290:                    }
12291:                    if (param_1 != null) {
12292:                        param_1.unlock();
12293:                    }
12294:                    return tmp_ret;
12295:                }
12296:
12297:                public final void set_GetClipper(long val) {
12298:                    byteBase.setAddress(NativeBridge.is64 ? 120 : 60, val);
12299:                }
12300:
12301:                public final long get_GetClipper() {
12302:                    return byteBase.getAddress(NativeBridge.is64 ? 120 : 60);
12303:                }
12304:
12305:                public final int GetClipper(Win32.IDirectDrawSurface This,
12306:                        PointerPointer param_1) {
12307:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12308:                    long tmp_1 = param_1 == null ? 0 : param_1
12309:                            .longLockPointer();
12310:                    int tmp_ret = instance.proxycall171(get_GetClipper(),
12311:                            tmp_0, tmp_1);
12312:                    if (This != null) {
12313:                        This.unlock();
12314:                    }
12315:                    if (param_1 != null) {
12316:                        param_1.unlock();
12317:                    }
12318:                    return tmp_ret;
12319:                }
12320:
12321:                public final void set_GetColorKey(long val) {
12322:                    byteBase.setAddress(NativeBridge.is64 ? 128 : 64, val);
12323:                }
12324:
12325:                public final long get_GetColorKey() {
12326:                    return byteBase.getAddress(NativeBridge.is64 ? 128 : 64);
12327:                }
12328:
12329:                public final int GetColorKey(Win32.IDirectDrawSurface This,
12330:                        int param_1, Win32.DDCOLORKEY param_2) {
12331:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12332:                    long tmp_1 = param_2 == null ? 0 : param_2
12333:                            .longLockPointer();
12334:                    int tmp_ret = instance.proxycall172(get_GetColorKey(),
12335:                            tmp_0, param_1, tmp_1);
12336:                    if (This != null) {
12337:                        This.unlock();
12338:                    }
12339:                    if (param_2 != null) {
12340:                        param_2.unlock();
12341:                    }
12342:                    return tmp_ret;
12343:                }
12344:
12345:                public final void set_GetDC(long val) {
12346:                    byteBase.setAddress(NativeBridge.is64 ? 136 : 68, val);
12347:                }
12348:
12349:                public final long get_GetDC() {
12350:                    return byteBase.getAddress(NativeBridge.is64 ? 136 : 68);
12351:                }
12352:
12353:                public final int GetDC(Win32.IDirectDrawSurface This,
12354:                        PointerPointer param_1) {
12355:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12356:                    long tmp_1 = param_1 == null ? 0 : param_1
12357:                            .longLockPointer();
12358:                    int tmp_ret = instance.proxycall173(get_GetDC(), tmp_0,
12359:                            tmp_1);
12360:                    if (This != null) {
12361:                        This.unlock();
12362:                    }
12363:                    if (param_1 != null) {
12364:                        param_1.unlock();
12365:                    }
12366:                    return tmp_ret;
12367:                }
12368:
12369:                public final void set_GetFlipStatus(long val) {
12370:                    byteBase.setAddress(NativeBridge.is64 ? 144 : 72, val);
12371:                }
12372:
12373:                public final long get_GetFlipStatus() {
12374:                    return byteBase.getAddress(NativeBridge.is64 ? 144 : 72);
12375:                }
12376:
12377:                public final int GetFlipStatus(Win32.IDirectDrawSurface This,
12378:                        int param_1) {
12379:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12380:                    int tmp_ret = instance.proxycall174(get_GetFlipStatus(),
12381:                            tmp_0, param_1);
12382:                    if (This != null) {
12383:                        This.unlock();
12384:                    }
12385:                    return tmp_ret;
12386:                }
12387:
12388:                public final void set_GetOverlayPosition(long val) {
12389:                    byteBase.setAddress(NativeBridge.is64 ? 152 : 76, val);
12390:                }
12391:
12392:                public final long get_GetOverlayPosition() {
12393:                    return byteBase.getAddress(NativeBridge.is64 ? 152 : 76);
12394:                }
12395:
12396:                public final int GetOverlayPosition(
12397:                        Win32.IDirectDrawSurface This, Int32Pointer param_1,
12398:                        Int32Pointer param_2) {
12399:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12400:                    long tmp_1 = param_1 == null ? 0 : param_1
12401:                            .longLockPointer();
12402:                    long tmp_2 = param_2 == null ? 0 : param_2
12403:                            .longLockPointer();
12404:                    int tmp_ret = instance.proxycall175(
12405:                            get_GetOverlayPosition(), tmp_0, tmp_1, tmp_2);
12406:                    if (This != null) {
12407:                        This.unlock();
12408:                    }
12409:                    if (param_1 != null) {
12410:                        param_1.unlock();
12411:                    }
12412:                    if (param_2 != null) {
12413:                        param_2.unlock();
12414:                    }
12415:                    return tmp_ret;
12416:                }
12417:
12418:                public final void set_GetPalette(long val) {
12419:                    byteBase.setAddress(NativeBridge.is64 ? 160 : 80, val);
12420:                }
12421:
12422:                public final long get_GetPalette() {
12423:                    return byteBase.getAddress(NativeBridge.is64 ? 160 : 80);
12424:                }
12425:
12426:                public final int GetPalette(Win32.IDirectDrawSurface This,
12427:                        PointerPointer param_1) {
12428:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12429:                    long tmp_1 = param_1 == null ? 0 : param_1
12430:                            .longLockPointer();
12431:                    int tmp_ret = instance.proxycall176(get_GetPalette(),
12432:                            tmp_0, tmp_1);
12433:                    if (This != null) {
12434:                        This.unlock();
12435:                    }
12436:                    if (param_1 != null) {
12437:                        param_1.unlock();
12438:                    }
12439:                    return tmp_ret;
12440:                }
12441:
12442:                public final void set_GetPixelFormat(long val) {
12443:                    byteBase.setAddress(NativeBridge.is64 ? 168 : 84, val);
12444:                }
12445:
12446:                public final long get_GetPixelFormat() {
12447:                    return byteBase.getAddress(NativeBridge.is64 ? 168 : 84);
12448:                }
12449:
12450:                public final int GetPixelFormat(Win32.IDirectDrawSurface This,
12451:                        Win32.DDPIXELFORMAT param_1) {
12452:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12453:                    long tmp_1 = param_1 == null ? 0 : param_1
12454:                            .longLockPointer();
12455:                    int tmp_ret = instance.proxycall177(get_GetPixelFormat(),
12456:                            tmp_0, tmp_1);
12457:                    if (This != null) {
12458:                        This.unlock();
12459:                    }
12460:                    if (param_1 != null) {
12461:                        param_1.unlock();
12462:                    }
12463:                    return tmp_ret;
12464:                }
12465:
12466:                public final void set_GetSurfaceDesc(long val) {
12467:                    byteBase.setAddress(NativeBridge.is64 ? 176 : 88, val);
12468:                }
12469:
12470:                public final long get_GetSurfaceDesc() {
12471:                    return byteBase.getAddress(NativeBridge.is64 ? 176 : 88);
12472:                }
12473:
12474:                public final int GetSurfaceDesc(Win32.IDirectDrawSurface This,
12475:                        Win32.DDSURFACEDESC param_1) {
12476:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12477:                    long tmp_1 = param_1 == null ? 0 : param_1
12478:                            .longLockPointer();
12479:                    int tmp_ret = instance.proxycall178(get_GetSurfaceDesc(),
12480:                            tmp_0, tmp_1);
12481:                    if (This != null) {
12482:                        This.unlock();
12483:                    }
12484:                    if (param_1 != null) {
12485:                        param_1.unlock();
12486:                    }
12487:                    return tmp_ret;
12488:                }
12489:
12490:                public final void set_Initialize(long val) {
12491:                    byteBase.setAddress(NativeBridge.is64 ? 184 : 92, val);
12492:                }
12493:
12494:                public final long get_Initialize() {
12495:                    return byteBase.getAddress(NativeBridge.is64 ? 184 : 92);
12496:                }
12497:
12498:                public final int Initialize(Win32.IDirectDrawSurface This,
12499:                        Win32.IDirectDraw param_1, Win32.DDSURFACEDESC param_2) {
12500:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12501:                    long tmp_1 = param_1 == null ? 0 : param_1
12502:                            .longLockPointer();
12503:                    long tmp_2 = param_2 == null ? 0 : param_2
12504:                            .longLockPointer();
12505:                    int tmp_ret = instance.proxycall179(get_Initialize(),
12506:                            tmp_0, tmp_1, tmp_2);
12507:                    if (This != null) {
12508:                        This.unlock();
12509:                    }
12510:                    if (param_1 != null) {
12511:                        param_1.unlock();
12512:                    }
12513:                    if (param_2 != null) {
12514:                        param_2.unlock();
12515:                    }
12516:                    return tmp_ret;
12517:                }
12518:
12519:                public final void set_IsLost(long val) {
12520:                    byteBase.setAddress(NativeBridge.is64 ? 192 : 96, val);
12521:                }
12522:
12523:                public final long get_IsLost() {
12524:                    return byteBase.getAddress(NativeBridge.is64 ? 192 : 96);
12525:                }
12526:
12527:                public final int IsLost(Win32.IDirectDrawSurface This) {
12528:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12529:                    int tmp_ret = instance.proxycall180(get_IsLost(), tmp_0);
12530:                    if (This != null) {
12531:                        This.unlock();
12532:                    }
12533:                    return tmp_ret;
12534:                }
12535:
12536:                public final void set_Lock(long val) {
12537:                    byteBase.setAddress(NativeBridge.is64 ? 200 : 100, val);
12538:                }
12539:
12540:                public final long get_Lock() {
12541:                    return byteBase.getAddress(NativeBridge.is64 ? 200 : 100);
12542:                }
12543:
12544:                public final int Lock(Win32.IDirectDrawSurface This,
12545:                        Win32.RECT param_1, Win32.DDSURFACEDESC param_2,
12546:                        int param_3, VoidPointer param_4) {
12547:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12548:                    long tmp_1 = param_1 == null ? 0 : param_1
12549:                            .longLockPointer();
12550:                    long tmp_2 = param_2 == null ? 0 : param_2
12551:                            .longLockPointer();
12552:                    long tmp_3 = param_4 == null ? 0 : param_4
12553:                            .longLockPointer();
12554:                    int tmp_ret = instance.proxycall181(get_Lock(), tmp_0,
12555:                            tmp_1, tmp_2, param_3, tmp_3);
12556:                    if (This != null) {
12557:                        This.unlock();
12558:                    }
12559:                    if (param_1 != null) {
12560:                        param_1.unlock();
12561:                    }
12562:                    if (param_2 != null) {
12563:                        param_2.unlock();
12564:                    }
12565:                    if (param_4 != null) {
12566:                        param_4.unlock();
12567:                    }
12568:                    return tmp_ret;
12569:                }
12570:
12571:                public final void set_ReleaseDC(long val) {
12572:                    byteBase.setAddress(NativeBridge.is64 ? 208 : 104, val);
12573:                }
12574:
12575:                public final long get_ReleaseDC() {
12576:                    return byteBase.getAddress(NativeBridge.is64 ? 208 : 104);
12577:                }
12578:
12579:                public final int ReleaseDC(Win32.IDirectDrawSurface This,
12580:                        long param_1) {
12581:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12582:                    int tmp_ret = instance.proxycall182(get_ReleaseDC(), tmp_0,
12583:                            param_1);
12584:                    if (This != null) {
12585:                        This.unlock();
12586:                    }
12587:                    return tmp_ret;
12588:                }
12589:
12590:                public final void set_Restore(long val) {
12591:                    byteBase.setAddress(NativeBridge.is64 ? 216 : 108, val);
12592:                }
12593:
12594:                public final long get_Restore() {
12595:                    return byteBase.getAddress(NativeBridge.is64 ? 216 : 108);
12596:                }
12597:
12598:                public final int Restore(Win32.IDirectDrawSurface This) {
12599:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12600:                    int tmp_ret = instance.proxycall183(get_Restore(), tmp_0);
12601:                    if (This != null) {
12602:                        This.unlock();
12603:                    }
12604:                    return tmp_ret;
12605:                }
12606:
12607:                public final void set_SetClipper(long val) {
12608:                    byteBase.setAddress(NativeBridge.is64 ? 224 : 112, val);
12609:                }
12610:
12611:                public final long get_SetClipper() {
12612:                    return byteBase.getAddress(NativeBridge.is64 ? 224 : 112);
12613:                }
12614:
12615:                public final int SetClipper(Win32.IDirectDrawSurface This,
12616:                        Win32.IDirectDrawClipper param_1) {
12617:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12618:                    long tmp_1 = param_1 == null ? 0 : param_1
12619:                            .longLockPointer();
12620:                    int tmp_ret = instance.proxycall184(get_SetClipper(),
12621:                            tmp_0, tmp_1);
12622:                    if (This != null) {
12623:                        This.unlock();
12624:                    }
12625:                    if (param_1 != null) {
12626:                        param_1.unlock();
12627:                    }
12628:                    return tmp_ret;
12629:                }
12630:
12631:                public final void set_SetColorKey(long val) {
12632:                    byteBase.setAddress(NativeBridge.is64 ? 232 : 116, val);
12633:                }
12634:
12635:                public final long get_SetColorKey() {
12636:                    return byteBase.getAddress(NativeBridge.is64 ? 232 : 116);
12637:                }
12638:
12639:                public final int SetColorKey(Win32.IDirectDrawSurface This,
12640:                        int param_1, Win32.DDCOLORKEY param_2) {
12641:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12642:                    long tmp_1 = param_2 == null ? 0 : param_2
12643:                            .longLockPointer();
12644:                    int tmp_ret = instance.proxycall185(get_SetColorKey(),
12645:                            tmp_0, param_1, tmp_1);
12646:                    if (This != null) {
12647:                        This.unlock();
12648:                    }
12649:                    if (param_2 != null) {
12650:                        param_2.unlock();
12651:                    }
12652:                    return tmp_ret;
12653:                }
12654:
12655:                public final void set_SetOverlayPosition(long val) {
12656:                    byteBase.setAddress(NativeBridge.is64 ? 240 : 120, val);
12657:                }
12658:
12659:                public final long get_SetOverlayPosition() {
12660:                    return byteBase.getAddress(NativeBridge.is64 ? 240 : 120);
12661:                }
12662:
12663:                public final int SetOverlayPosition(
12664:                        Win32.IDirectDrawSurface This, int param_1, int param_2) {
12665:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12666:                    int tmp_ret = instance.proxycall186(
12667:                            get_SetOverlayPosition(), tmp_0, param_1, param_2);
12668:                    if (This != null) {
12669:                        This.unlock();
12670:                    }
12671:                    return tmp_ret;
12672:                }
12673:
12674:                public final void set_SetPalette(long val) {
12675:                    byteBase.setAddress(NativeBridge.is64 ? 248 : 124, val);
12676:                }
12677:
12678:                public final long get_SetPalette() {
12679:                    return byteBase.getAddress(NativeBridge.is64 ? 248 : 124);
12680:                }
12681:
12682:                public final int SetPalette(Win32.IDirectDrawSurface This,
12683:                        Win32.IDirectDrawPalette param_1) {
12684:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12685:                    long tmp_1 = param_1 == null ? 0 : param_1
12686:                            .longLockPointer();
12687:                    int tmp_ret = instance.proxycall187(get_SetPalette(),
12688:                            tmp_0, tmp_1);
12689:                    if (This != null) {
12690:                        This.unlock();
12691:                    }
12692:                    if (param_1 != null) {
12693:                        param_1.unlock();
12694:                    }
12695:                    return tmp_ret;
12696:                }
12697:
12698:                public final void set_Unlock(long val) {
12699:                    byteBase.setAddress(NativeBridge.is64 ? 256 : 128, val);
12700:                }
12701:
12702:                public final long get_Unlock() {
12703:                    return byteBase.getAddress(NativeBridge.is64 ? 256 : 128);
12704:                }
12705:
12706:                public final int Unlock(Win32.IDirectDrawSurface This,
12707:                        VoidPointer param_1) {
12708:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12709:                    long tmp_1 = param_1 == null ? 0 : param_1
12710:                            .longLockPointer();
12711:                    int tmp_ret = instance.proxycall188(get_Unlock(), tmp_0,
12712:                            tmp_1);
12713:                    if (This != null) {
12714:                        This.unlock();
12715:                    }
12716:                    if (param_1 != null) {
12717:                        param_1.unlock();
12718:                    }
12719:                    return tmp_ret;
12720:                }
12721:
12722:                public final void set_UpdateOverlay(long val) {
12723:                    byteBase.setAddress(NativeBridge.is64 ? 264 : 132, val);
12724:                }
12725:
12726:                public final long get_UpdateOverlay() {
12727:                    return byteBase.getAddress(NativeBridge.is64 ? 264 : 132);
12728:                }
12729:
12730:                public final int UpdateOverlay(Win32.IDirectDrawSurface This,
12731:                        Win32.RECT param_1, Win32.IDirectDrawSurface param_2,
12732:                        Win32.RECT param_3, int param_4,
12733:                        Win32.DDOVERLAYFX param_5) {
12734:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12735:                    long tmp_1 = param_1 == null ? 0 : param_1
12736:                            .longLockPointer();
12737:                    long tmp_2 = param_2 == null ? 0 : param_2
12738:                            .longLockPointer();
12739:                    long tmp_3 = param_3 == null ? 0 : param_3
12740:                            .longLockPointer();
12741:                    long tmp_4 = param_5 == null ? 0 : param_5
12742:                            .longLockPointer();
12743:                    int tmp_ret = instance.proxycall189(get_UpdateOverlay(),
12744:                            tmp_0, tmp_1, tmp_2, tmp_3, param_4, tmp_4);
12745:                    if (This != null) {
12746:                        This.unlock();
12747:                    }
12748:                    if (param_1 != null) {
12749:                        param_1.unlock();
12750:                    }
12751:                    if (param_2 != null) {
12752:                        param_2.unlock();
12753:                    }
12754:                    if (param_3 != null) {
12755:                        param_3.unlock();
12756:                    }
12757:                    if (param_5 != null) {
12758:                        param_5.unlock();
12759:                    }
12760:                    return tmp_ret;
12761:                }
12762:
12763:                public final void set_UpdateOverlayDisplay(long val) {
12764:                    byteBase.setAddress(NativeBridge.is64 ? 272 : 136, val);
12765:                }
12766:
12767:                public final long get_UpdateOverlayDisplay() {
12768:                    return byteBase.getAddress(NativeBridge.is64 ? 272 : 136);
12769:                }
12770:
12771:                public final int UpdateOverlayDisplay(
12772:                        Win32.IDirectDrawSurface This, int param_1) {
12773:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12774:                    int tmp_ret = instance.proxycall190(
12775:                            get_UpdateOverlayDisplay(), tmp_0, param_1);
12776:                    if (This != null) {
12777:                        This.unlock();
12778:                    }
12779:                    return tmp_ret;
12780:                }
12781:
12782:                public final void set_UpdateOverlayZOrder(long val) {
12783:                    byteBase.setAddress(NativeBridge.is64 ? 280 : 140, val);
12784:                }
12785:
12786:                public final long get_UpdateOverlayZOrder() {
12787:                    return byteBase.getAddress(NativeBridge.is64 ? 280 : 140);
12788:                }
12789:
12790:                public final int UpdateOverlayZOrder(
12791:                        Win32.IDirectDrawSurface This, int param_1,
12792:                        Win32.IDirectDrawSurface param_2) {
12793:                    long tmp_0 = This == null ? 0 : This.longLockPointer();
12794:                    long tmp_1 = param_2 == null ? 0 : param_2
12795:                            .longLockPointer();
12796:                    int tmp_ret = instance.proxycall191(
12797:                            get_UpdateOverlayZOrder(), tmp_0, param_1, tmp_1);
12798:                    if (This != null) {
12799:                        This.unlock();
12800:                    }
12801:                    if (param_2 != null) {
12802:                        param_2.unlock();
12803:                    }
12804:                    return tmp_ret;
12805:                }
12806:
12807:                @Override
12808:                public int size() {
12809:                    return sizeof;
12810:                }
12811:            }
12812:
12813:            public final IDirectDrawSurfaceVtbl createIDirectDrawSurfaceVtbl(
12814:                    boolean direct) {
12815:                return new IDirectDrawSurfaceVtbl(direct);
12816:            }
12817:
12818:            public final IDirectDrawSurfaceVtbl createIDirectDrawSurfaceVtbl(
12819:                    VoidPointer base) {
12820:                return new IDirectDrawSurfaceVtbl(base);
12821:            }
12822:
12823:            public final IDirectDrawSurfaceVtbl createIDirectDrawSurfaceVtbl(
12824:                    long addr) {
12825:                return new IDirectDrawSurfaceVtbl(addr);
12826:            }
12827:
12828:            final native int proxycall31(long fnptr, long This, long riid,
12829:                    long ppvObj);
12830:
12831:            final native int proxycall32(long fnptr, long This);
12832:
12833:            final native int proxycall33(long fnptr, long This);
12834:
12835:            final native int proxycall34(long fnptr, long This, long param_1);
12836:
12837:            final native int proxycall35(long fnptr, long This, int param_1,
12838:                    int param_2, int param_3, long param_4);
12839:
12840:            final native int proxycall36(long fnptr, long This, long param_1,
12841:                    int param_2, long param_3);
12842:
12843:            final native int proxycall37(long fnptr, long This, int param_1,
12844:                    int param_2, int param_3, long param_4);
12845:
12846:            final native int proxycall38(long fnptr, long This, long riid,
12847:                    long ppvObj);
12848:
12849:            final native int proxycall39(long fnptr, long This);
12850:
12851:            final native int proxycall40(long fnptr, long This);
12852:
12853:            final native int proxycall41(long fnptr, long This);
12854:
12855:            final native int proxycall42(long fnptr, long This, int param_1,
12856:                    long param_2, long param_3);
12857:
12858:            final native int proxycall43(long fnptr, long This, int param_1,
12859:                    long param_2, long param_3, long param_4);
12860:
12861:            final native int proxycall44(long fnptr, long This, long param_1,
12862:                    long param_2, long param_3);
12863:
12864:            final native int proxycall45(long fnptr, long This, long param_1,
12865:                    long param_2);
12866:
12867:            final native int proxycall46(long fnptr, long This, int param_1,
12868:                    long param_2, long param_3, long param_4);
12869:
12870:            final native int proxycall47(long fnptr, long This, int param_1,
12871:                    long param_2, long param_3, long param_4);
12872:
12873:            final native int proxycall48(long fnptr, long This);
12874:
12875:            final native int proxycall49(long fnptr, long This, long param_1,
12876:                    long param_2);
12877:
12878:            final native int proxycall50(long fnptr, long This, long param_1);
12879:
12880:            final native int proxycall51(long fnptr, long This, long param_1,
12881:                    long param_2);
12882:
12883:            final native int proxycall52(long fnptr, long This, long param_1);
12884:
12885:            final native int proxycall53(long fnptr, long This, long param_1);
12886:
12887:            final native int proxycall54(long fnptr, long This, long param_1);
12888:
12889:            final native int proxycall55(long fnptr, long This, long param_1);
12890:
12891:            final native int proxycall56(long fnptr, long This, long param_1);
12892:
12893:            final native int proxycall57(long fnptr, long This);
12894:
12895:            final native int proxycall58(long fnptr, long This, long param_1,
12896:                    int param_2);
12897:
12898:            final native int proxycall59(long fnptr, long This, int param_1,
12899:                    int param_2, int param_3, int param_4, int param_5);
12900:
12901:            final native int proxycall60(long fnptr, long This, int param_1,
12902:                    long param_2);
12903:
12904:            final native int proxycall61(long fnptr, long This, long param_1,
12905:                    long param_2, long param_3);
12906:
12907:            final native int proxycall62(long fnptr, long This, long param_1,
12908:                    long param_2);
12909:
12910:            final native int proxycall63(long fnptr, long This);
12911:
12912:            final native int proxycall64(long fnptr, long This);
12913:
12914:            final native int proxycall65(long fnptr, long This, long param_1,
12915:                    int param_2);
12916:
12917:            final native int proxycall66(long fnptr, long This, long param_1,
12918:                    int param_2, int param_3);
12919:
12920:            final native int proxycall67(long fnptr, long This, int param_1,
12921:                    long param_2);
12922:
12923:            final native int proxycall68(long fnptr, long This, long riid,
12924:                    long ppvObj);
12925:
12926:            final native int proxycall69(long fnptr, long This);
12927:
12928:            final native int proxycall70(long fnptr, long This);
12929:
12930:            final native int proxycall71(long fnptr, long This, long param_1,
12931:                    long param_2, long param_3);
12932:
12933:            final native int proxycall72(long fnptr, long This, long param_1);
12934:
12935:            final native int proxycall73(long fnptr, long This, long param_1,
12936:                    int param_2);
12937:
12938:            final native int proxycall74(long fnptr, long This, long param_1);
12939:
12940:            final native int proxycall75(long fnptr, long This, long param_1,
12941:                    int param_2);
12942:
12943:            final native int proxycall76(long fnptr, long This, int param_1,
12944:                    long param_2);
12945:
12946:            final native int proxycall77(long fnptr, long This, long riid,
12947:                    long ppvObj);
12948:
12949:            final native int proxycall78(long fnptr, long This);
12950:
12951:            final native int proxycall79(long fnptr, long This);
12952:
12953:            final native int proxycall80(long fnptr, long This);
12954:
12955:            final native int proxycall81(long fnptr, long This, int param_1,
12956:                    long param_2, long param_3);
12957:
12958:            final native int proxycall82(long fnptr, long This, int param_1,
12959:                    long param_2, long param_3, long param_4);
12960:
12961:            final native int proxycall83(long fnptr, long This, long param_1,
12962:                    long param_2, long param_3);
12963:
12964:            final native int proxycall84(long fnptr, long This, long param_1,
12965:                    long param_2);
12966:
12967:            final native int proxycall85(long fnptr, long This, int param_1,
12968:                    long param_2, long param_3, long param_4);
12969:
12970:            final native int proxycall86(long fnptr, long This, int param_1,
12971:                    long param_2, long param_3, long param_4);
12972:
12973:            final native int proxycall87(long fnptr, long This);
12974:
12975:            final native int proxycall88(long fnptr, long This, long param_1,
12976:                    long param_2);
12977:
12978:            final native int proxycall89(long fnptr, long This, long param_1);
12979:
12980:            final native int proxycall90(long fnptr, long This, long param_1,
12981:                    long param_2);
12982:
12983:            final native int proxycall91(long fnptr, long This, long param_1);
12984:
12985:            final native int proxycall92(long fnptr, long This, long param_1);
12986:
12987:            final native int proxycall93(long fnptr, long This, long param_1);
12988:
12989:            final native int proxycall94(long fnptr, long This, long param_1);
12990:
12991:            final native int proxycall95(long fnptr, long This, long param_1);
12992:
12993:            final native int proxycall96(long fnptr, long This);
12994:
12995:            final native int proxycall97(long fnptr, long This, long param_1,
12996:                    int param_2);
12997:
12998:            final native int proxycall98(long fnptr, long This, int param_1,
12999:                    int param_2, int param_3);
13000:
13001:            final native int proxycall99(long fnptr, long This, int param_1,
13002:                    long param_2);
13003:
13004:            final native int proxycall100(long fnptr, long This, long riid,
13005:                    long ppvObject);
13006:
13007:            final native int proxycall101(long fnptr, long This);
13008:
13009:            final native int proxycall102(long fnptr, long This);
13010:
13011:            final native int proxycall103(long fnptr, long This, int celt,
13012:                    long rgelt, long pceltFetched);
13013:
13014:            final native int proxycall104(long fnptr, long This, int celt);
13015:
13016:            final native int proxycall105(long fnptr, long This);
13017:
13018:            final native int proxycall106(long fnptr, long This, long ppenum);
13019:
13020:            final native int proxycall107(long fnptr, long This, long riid,
13021:                    long ppvObj);
13022:
13023:            final native int proxycall108(long fnptr, long This);
13024:
13025:            final native int proxycall109(long fnptr, long This);
13026:
13027:            final native int proxycall110(long fnptr, long This, long param_1);
13028:
13029:            final native int proxycall111(long fnptr, long This, long param_1);
13030:
13031:            final native int proxycall112(long fnptr, long This, long param_1,
13032:                    long param_2, long param_3, int param_4, long param_5);
13033:
13034:            final native int proxycall113(long fnptr, long This, long param_1,
13035:                    int param_2, int param_3);
13036:
13037:            final native int proxycall114(long fnptr, long This, int param_1,
13038:                    int param_2, long param_3, long param_4, int param_5);
13039:
13040:            final native int proxycall115(long fnptr, long This, int param_1,
13041:                    long param_2);
13042:
13043:            final native int proxycall116(long fnptr, long This, long param_1,
13044:                    long param_2);
13045:
13046:            final native int proxycall117(long fnptr, long This, int param_1,
13047:                    long param_2, long param_3);
13048:
13049:            final native int proxycall118(long fnptr, long This, long param_1,
13050:                    int param_2);
13051:
13052:            final native int proxycall119(long fnptr, long This, long param_1,
13053:                    long param_2);
13054:
13055:            final native int proxycall120(long fnptr, long This, int param_1);
13056:
13057:            final native int proxycall121(long fnptr, long This, long param_1);
13058:
13059:            final native int proxycall122(long fnptr, long This, long param_1);
13060:
13061:            final native int proxycall123(long fnptr, long This, int param_1,
13062:                    long param_2);
13063:
13064:            final native int proxycall124(long fnptr, long This, long param_1);
13065:
13066:            final native int proxycall125(long fnptr, long This, int param_1);
13067:
13068:            final native int proxycall126(long fnptr, long This, long param_1,
13069:                    long param_2);
13070:
13071:            final native int proxycall127(long fnptr, long This, long param_1);
13072:
13073:            final native int proxycall128(long fnptr, long This, long param_1);
13074:
13075:            final native int proxycall129(long fnptr, long This, long param_1);
13076:
13077:            final native int proxycall130(long fnptr, long This, long param_1,
13078:                    long param_2);
13079:
13080:            final native int proxycall131(long fnptr, long This);
13081:
13082:            final native int proxycall132(long fnptr, long This, long param_1,
13083:                    long param_2, int param_3, long param_4);
13084:
13085:            final native int proxycall133(long fnptr, long This, long param_1);
13086:
13087:            final native int proxycall134(long fnptr, long This);
13088:
13089:            final native int proxycall135(long fnptr, long This, long param_1);
13090:
13091:            final native int proxycall136(long fnptr, long This, int param_1,
13092:                    long param_2);
13093:
13094:            final native int proxycall137(long fnptr, long This, int param_1,
13095:                    int param_2);
13096:
13097:            final native int proxycall138(long fnptr, long This, long param_1);
13098:
13099:            final native int proxycall139(long fnptr, long This, long param_1);
13100:
13101:            final native int proxycall140(long fnptr, long This, long param_1,
13102:                    long param_2, long param_3, int param_4, long param_5);
13103:
13104:            final native int proxycall141(long fnptr, long This, int param_1);
13105:
13106:            final native int proxycall142(long fnptr, long This, int param_1,
13107:                    long param_2);
13108:
13109:            final native int proxycall143(long fnptr, long This, long param_1);
13110:
13111:            final native int proxycall144(long fnptr, long This, int param_1);
13112:
13113:            final native int proxycall145(long fnptr, long This, int param_1);
13114:
13115:            final native int proxycall146(long fnptr, long This, long param_1,
13116:                    int param_2);
13117:
13118:            final native int proxycall147(long fnptr, long This, long param_1,
13119:                    long param_2, int param_3, int param_4);
13120:
13121:            final native int proxycall148(long fnptr, long This, long param_1,
13122:                    long param_2, long param_3);
13123:
13124:            final native int proxycall149(long fnptr, long This, long param_1);
13125:
13126:            final native int proxycall150(long fnptr, long This, long param_1);
13127:
13128:            final native int proxycall151(long fnptr, long This);
13129:
13130:            final native int proxycall152(long fnptr, long This, int param_1);
13131:
13132:            final native int proxycall153(long fnptr, long This, long param_1);
13133:
13134:            final native int proxycall154(long fnptr, long This, int param_1);
13135:
13136:            final native int proxycall155(long fnptr, long This, long param_1);
13137:
13138:            final native int proxycall156(long fnptr, long This, long riid,
13139:                    long ppvObj);
13140:
13141:            final native int proxycall157(long fnptr, long This);
13142:
13143:            final native int proxycall158(long fnptr, long This);
13144:
13145:            final native int proxycall159(long fnptr, long This, long param_1);
13146:
13147:            final native int proxycall160(long fnptr, long This, long param_1);
13148:
13149:            final native int proxycall161(long fnptr, long This, long param_1,
13150:                    long param_2, long param_3, int param_4, long param_5);
13151:
13152:            final native int proxycall162(long fnptr, long This, long param_1,
13153:                    int param_2, int param_3);
13154:
13155:            final native int proxycall163(long fnptr, long This, int param_1,
13156:                    int param_2, long param_3, long param_4, int param_5);
13157:
13158:            final native int proxycall164(long fnptr, long This, int param_1,
13159:                    long param_2);
13160:
13161:            final native int proxycall165(long fnptr, long This, long param_1,
13162:                    long param_2);
13163:
13164:            final native int proxycall166(long fnptr, long This, int param_1,
13165:                    long param_2, long param_3);
13166:
13167:            final native int proxycall167(long fnptr, long This, long param_1,
13168:                    int param_2);
13169:
13170:            final native int proxycall168(long fnptr, long This, long param_1,
13171:                    long param_2);
13172:
13173:            final native int proxycall169(long fnptr, long This, int param_1);
13174:
13175:            final native int proxycall170(long fnptr, long This, long param_1);
13176:
13177:            final native int proxycall171(long fnptr, long This, long param_1);
13178:
13179:            final native int proxycall172(long fnptr, long This, int param_1,
13180:                    long param_2);
13181:
13182:            final native int proxycall173(long fnptr, long This, long param_1);
13183:
13184:            final native int proxycall174(long fnptr, long This, int param_1);
13185:
13186:            final native int proxycall175(long fnptr, long This, long param_1,
13187:                    long param_2);
13188:
13189:            final native int proxycall176(long fnptr, long This, long param_1);
13190:
13191:            final native int proxycall177(long fnptr, long This, long param_1);
13192:
13193:            final native int proxycall178(long fnptr, long This, long param_1);
13194:
13195:            final native int proxycall179(long fnptr, long This, long param_1,
13196:                    long param_2);
13197:
13198:            final native int proxycall180(long fnptr, long This);
13199:
13200:            final native int proxycall181(long fnptr, long This, long param_1,
13201:                    long param_2, int param_3, long param_4);
13202:
13203:            final native int proxycall182(long fnptr, long This, long param_1);
13204:
13205:            final native int proxycall183(long fnptr, long This);
13206:
13207:            final native int proxycall184(long fnptr, long This, long param_1);
13208:
13209:            final native int proxycall185(long fnptr, long This, int param_1,
13210:                    long param_2);
13211:
13212:            final native int proxycall186(long fnptr, long This, int param_1,
13213:                    int param_2);
13214:
13215:            final native int proxycall187(long fnptr, long This, long param_1);
13216:
13217:            final native int proxycall188(long fnptr, long This, long param_1);
13218:
13219:            final native int proxycall189(long fnptr, long This, long param_1,
13220:                    long param_2, long param_3, int param_4, long param_5);
13221:
13222:            final native int proxycall190(long fnptr, long This, int param_1);
13223:
13224:            final native int proxycall191(long fnptr, long This, int param_1,
13225:                    long param_2);
13226:
13227:            public static class LOGFONTW extends CommonStructWrapper {
13228:
13229:                public static final int sizeof = 92;
13230:
13231:                LOGFONTW(boolean direct) {
13232:                    super (sizeof, direct);
13233:                }
13234:
13235:                LOGFONTW(VoidPointer base) {
13236:                    super (base);
13237:                }
13238:
13239:                LOGFONTW(long addr) {
13240:                    super (addr);
13241:                }
13242:
13243:                public final void set_lfHeight(int val) {
13244:                    byteBase.setInt32(0, val);
13245:                }
13246:
13247:                public final int get_lfHeight() {
13248:                    return byteBase.getInt32(0);
13249:                }
13250:
13251:                public final void set_lfWidth(int val) {
13252:                    byteBase.setInt32(4, val);
13253:                }
13254:
13255:                public final int get_lfWidth() {
13256:                    return byteBase.getInt32(4);
13257:                }
13258:
13259:                public final void set_lfEscapement(int val) {
13260:                    byteBase.setInt32(8, val);
13261:                }
13262:
13263:                public final int get_lfEscapement() {
13264:                    return byteBase.getInt32(8);
13265:                }
13266:
13267:                public final void set_lfOrientation(int val) {
13268:                    byteBase.setInt32(12, val);
13269:                }
13270:
13271:                public final int get_lfOrientation() {
13272:                    return byteBase.getInt32(12);
13273:                }
13274:
13275:                public final void set_lfWeight(int val) {
13276:                    byteBase.setInt32(16, val);
13277:                }
13278:
13279:                public final int get_lfWeight() {
13280:                    return byteBase.getInt32(16);
13281:                }
13282:
13283:                public final void set_lfItalic(byte val) {
13284:                    byteBase.set(20, val);
13285:                }
13286:
13287:                public final byte get_lfItalic() {
13288:                    return byteBase.get(20);
13289:                }
13290:
13291:                public final void set_lfUnderline(byte val) {
13292:                    byteBase.set(21, val);
13293:                }
13294:
13295:                public final byte get_lfUnderline() {
13296:                    return byteBase.get(21);
13297:                }
13298:
13299:                public final void set_lfStrikeOut(byte val) {
13300:                    byteBase.set(22, val);
13301:                }
13302:
13303:                public final byte get_lfStrikeOut() {
13304:                    return byteBase.get(22);
13305:                }
13306:
13307:                public final void set_lfCharSet(byte val) {
13308:                    byteBase.set(23, val);
13309:                }
13310:
13311:                public final byte get_lfCharSet() {
13312:                    return byteBase.get(23);
13313:                }
13314:
13315:                public final void set_lfOutPrecision(byte val) {
13316:                    byteBase.set(24, val);
13317:                }
13318:
13319:                public final byte get_lfOutPrecision() {
13320:                    return byteBase.get(24);
13321:                }
13322:
13323:                public final void set_lfClipPrecision(byte val) {
13324:                    byteBase.set(25, val);
13325:                }
13326:
13327:                public final byte get_lfClipPrecision() {
13328:                    return byteBase.get(25);
13329:                }
13330:
13331:                public final void set_lfQuality(byte val) {
13332:                    byteBase.set(26, val);
13333:                }
13334:
13335:                public final byte get_lfQuality() {
13336:                    return byteBase.get(26);
13337:                }
13338:
13339:                public final void set_lfPitchAndFamily(byte val) {
13340:                    byteBase.set(27, val);
13341:                }
13342:
13343:                public final byte get_lfPitchAndFamily() {
13344:                    return byteBase.get(27);
13345:                }
13346:
13347:                public final Int16Pointer get_lfFaceName() {
13348:                    return nb.createInt16Pointer(getElementPointer(28));
13349:                }
13350:
13351:                @Override
13352:                public int size() {
13353:                    return sizeof;
13354:                }
13355:            }
13356:
13357:            public final LOGFONTW createLOGFONTW(boolean direct) {
13358:                return new LOGFONTW(direct);
13359:            }
13360:
13361:            public final LOGFONTW createLOGFONTW(VoidPointer base) {
13362:                return new LOGFONTW(base);
13363:            }
13364:
13365:            public final LOGFONTW createLOGFONTW(long addr) {
13366:                return new LOGFONTW(addr);
13367:            }
13368:
13369:            public static class HIGHCONTRASTA extends CommonStructWrapper {
13370:
13371:                public static final int sizeof = NativeBridge.is64 ? 16 : 12;
13372:
13373:                HIGHCONTRASTA(boolean direct) {
13374:                    super (sizeof, direct);
13375:                }
13376:
13377:                HIGHCONTRASTA(VoidPointer base) {
13378:                    super (base);
13379:                }
13380:
13381:                HIGHCONTRASTA(long addr) {
13382:                    super (addr);
13383:                }
13384:
13385:                public final void set_cbSize(int val) {
13386:                    byteBase.setInt32(0, val);
13387:                }
13388:
13389:                public final int get_cbSize() {
13390:                    return byteBase.getInt32(0);
13391:                }
13392:
13393:                public final void set_dwFlags(int val) {
13394:                    byteBase.setInt32(4, val);
13395:                }
13396:
13397:                public final int get_dwFlags() {
13398:                    return byteBase.getInt32(4);
13399:                }
13400:
13401:                public final void set_lpszDefaultScheme(Int8Pointer val) {
13402:                    byteBase.setPointer(8, val);
13403:                }
13404:
13405:                public final Int8Pointer get_lpszDefaultScheme() {
13406:                    return nb.createInt8Pointer(byteBase.getAddress(8));
13407:                }
13408:
13409:                @Override
13410:                public int size() {
13411:                    return sizeof;
13412:                }
13413:            }
13414:
13415:            public final HIGHCONTRASTA createHIGHCONTRASTA(boolean direct) {
13416:                return new HIGHCONTRASTA(direct);
13417:            }
13418:
13419:            public final HIGHCONTRASTA createHIGHCONTRASTA(VoidPointer base) {
13420:                return new HIGHCONTRASTA(base);
13421:            }
13422:
13423:            public final HIGHCONTRASTA createHIGHCONTRASTA(long addr) {
13424:                return new HIGHCONTRASTA(addr);
13425:            }
13426:
13427:            public static class OFNOTIFYEXW extends CommonStructWrapper {
13428:
13429:                public static final int sizeof = NativeBridge.is64 ? 48 : 24;
13430:
13431:                OFNOTIFYEXW(boolean direct) {
13432:                    super (sizeof, direct);
13433:                }
13434:
13435:                OFNOTIFYEXW(VoidPointer base) {
13436:                    super (base);
13437:                }
13438:
13439:                OFNOTIFYEXW(long addr) {
13440:                    super (addr);
13441:                }
13442:
13443:                public final NMHDR get_hdr() {
13444:                    return instance.createNMHDR(getElementPointer(0));
13445:                }
13446:
13447:                public final Win32.OPENFILENAMEW get_lpOFN() {
13448:                    return Win32.instance.createOPENFILENAMEW(byteBase
13449:                            .getAddress(NativeBridge.is64 ? 24 : 12));
13450:                }
13451:
13452:                public final void set_psf(VoidPointer val) {
13453:                    byteBase.setPointer(NativeBridge.is64 ? 32 : 16, val);
13454:                }
13455:
13456:                public final VoidPointer get_psf() {
13457:                    return nb.createInt8Pointer(byteBase
13458:                            .getAddress(NativeBridge.is64 ? 32 : 16));
13459:                }
13460:
13461:                public final void set_pidl(VoidPointer val) {
13462:                    byteBase.setPointer(NativeBridge.is64 ? 40 : 20, val);
13463:                }
13464:
13465:                public final VoidPointer get_pidl() {
13466:                    return nb.createInt8Pointer(byteBase
13467:                            .getAddress(NativeBridge.is64 ? 40 : 20));
13468:                }
13469:
13470:                @Override
13471:                public int size() {
13472:                    return sizeof;
13473:                }
13474:            }
13475:
13476:            public final OFNOTIFYEXW createOFNOTIFYEXW(boolean direct) {
13477:                return new OFNOTIFYEXW(direct);
13478:            }
13479:
13480:            public final OFNOTIFYEXW createOFNOTIFYEXW(VoidPointer base) {
13481:                return new OFNOTIFYEXW(base);
13482:            }
13483:
13484:            public final OFNOTIFYEXW createOFNOTIFYEXW(long addr) {
13485:                return new OFNOTIFYEXW(addr);
13486:            }
13487:
13488:            public static class ICONMETRICSW extends CommonStructWrapper {
13489:
13490:                public static final int sizeof = 108;
13491:
13492:                ICONMETRICSW(boolean direct) {
13493:                    super (sizeof, direct);
13494:                }
13495:
13496:                ICONMETRICSW(VoidPointer base) {
13497:                    super (base);
13498:                }
13499:
13500:                ICONMETRICSW(long addr) {
13501:                    super (addr);
13502:                }
13503:
13504:                public final void set_cbSize(int val) {
13505:                    byteBase.setInt32(0, val);
13506:                }
13507:
13508:                public final int get_cbSize() {
13509:                    return byteBase.getInt32(0);
13510:                }
13511:
13512:                public final void set_iHorzSpacing(int val) {
13513:                    byteBase.setInt32(4, val);
13514:                }
13515:
13516:                public final int get_iHorzSpacing() {
13517:                    return byteBase.getInt32(4);
13518:                }
13519:
13520:                public final void set_iVertSpacing(int val) {
13521:                    byteBase.setInt32(8, val);
13522:                }
13523:
13524:                public final int get_iVertSpacing() {
13525:                    return byteBase.getInt32(8);
13526:                }
13527:
13528:                public final void set_iTitleWrap(int val) {
13529:                    byteBase.setInt32(12, val);
13530:                }
13531:
13532:                public final int get_iTitleWrap() {
13533:                    return byteBase.getInt32(12);
13534:                }
13535:
13536:                public final Win32.LOGFONTW get_lfFont() {
13537:                    return Win32.instance.createLOGFONTW(getElementPointer(16));
13538:                }
13539:
13540:                @Override
13541:                public int size() {
13542:                    return sizeof;
13543:                }
13544:            }
13545:
13546:            public final ICONMETRICSW createICONMETRICSW(boolean direct) {
13547:                return new ICONMETRICSW(direct);
13548:            }
13549:
13550:            public final ICONMETRICSW createICONMETRICSW(VoidPointer base) {
13551:                return new ICONMETRICSW(base);
13552:            }
13553:
13554:            public final ICONMETRICSW createICONMETRICSW(long addr) {
13555:                return new ICONMETRICSW(addr);
13556:            }
13557:
13558:            public static class TTPOLYGONHEADER extends CommonStructWrapper {
13559:
13560:                public static final int sizeof = 16;
13561:
13562:                TTPOLYGONHEADER(boolean direct) {
13563:                    super (sizeof, direct);
13564:                }
13565:
13566:                TTPOLYGONHEADER(VoidPointer base) {
13567:                    super (base);
13568:                }
13569:
13570:                TTPOLYGONHEADER(long addr) {
13571:                    super (addr);
13572:                }
13573:
13574:                public final void set_cb(int val) {
13575:                    byteBase.setInt32(0, val);
13576:                }
13577:
13578:                public final int get_cb() {
13579:                    return byteBase.getInt32(0);
13580:                }
13581:
13582:                public final void set_dwType(int val) {
13583:                    byteBase.setInt32(4, val);
13584:                }
13585:
13586:                public final int get_dwType() {
13587:                    return byteBase.getInt32(4);
13588:                }
13589:
13590:                public final POINTFX get_pfxStart() {
13591:                    return instance.createPOINTFX(getElementPointer(8));
13592:                }
13593:
13594:                @Override
13595:                public int size() {
13596:                    return sizeof;
13597:                }
13598:            }
13599:
13600:            public final TTPOLYGONHEADER createTTPOLYGONHEADER(boolean direct) {
13601:                return new TTPOLYGONHEADER(direct);
13602:            }
13603:
13604:            public final TTPOLYGONHEADER createTTPOLYGONHEADER(VoidPointer base) {
13605:                return new TTPOLYGONHEADER(base);
13606:            }
13607:
13608:            public final TTPOLYGONHEADER createTTPOLYGONHEADER(long addr) {
13609:                return new TTPOLYGONHEADER(addr);
13610:            }
13611:
13612:            public static class NONCLIENTMETRICSW extends CommonStructWrapper {
13613:
13614:                public static final int sizeof = 500;
13615:
13616:                NONCLIENTMETRICSW(boolean direct) {
13617:                    super (sizeof, direct);
13618:                }
13619:
13620:                NONCLIENTMETRICSW(VoidPointer base) {
13621:                    super (base);
13622:                }
13623:
13624:                NONCLIENTMETRICSW(long addr) {
13625:                    super (addr);
13626:                }
13627:
13628:                public final void set_cbSize(int val) {
13629:                    byteBase.setInt32(0, val);
13630:                }
13631:
13632:                public final int get_cbSize() {
13633:                    return byteBase.getInt32(0);
13634:                }
13635:
13636:                public final void set_iBorderWidth(int val) {
13637:                    byteBase.setInt32(4, val);
13638:                }
13639:
13640:                public final int get_iBorderWidth() {
13641:                    return byteBase.getInt32(4);
13642:                }
13643:
13644:                public final void set_iScrollWidth(int val) {
13645:                    byteBase.setInt32(8, val);
13646:                }
13647:
13648:                public final int get_iScrollWidth() {
13649:                    return byteBase.getInt32(8);
13650:                }
13651:
13652:                public final void set_iScrollHeight(int val) {
13653:                    byteBase.setInt32(12, val);
13654:                }
13655:
13656:                public final int get_iScrollHeight() {
13657:                    return byteBase.getInt32(12);
13658:                }
13659:
13660:                public final void set_iCaptionWidth(int val) {
13661:                    byteBase.setInt32(16, val);
13662:                }
13663:
13664:                public final int get_iCaptionWidth() {
13665:                    return byteBase.getInt32(16);
13666:                }
13667:
13668:                public final void set_iCaptionHeight(int val) {
13669:                    byteBase.setInt32(20, val);
13670:                }
13671:
13672:                public final int get_iCaptionHeight() {
13673:                    return byteBase.getInt32(20);
13674:                }
13675:
13676:                public final Win32.LOGFONTW get_lfCaptionFont() {
13677:                    return Win32.instance.createLOGFONTW(getElementPointer(24));
13678:                }
13679:
13680:                public final void set_iSmCaptionWidth(int val) {
13681:                    byteBase.setInt32(116, val);
13682:                }
13683:
13684:                public final int get_iSmCaptionWidth() {
13685:                    return byteBase.getInt32(116);
13686:                }
13687:
13688:                public final void set_iSmCaptionHeight(int val) {
13689:                    byteBase.setInt32(120, val);
13690:                }
13691:
13692:                public final int get_iSmCaptionHeight() {
13693:                    return byteBase.getInt32(120);
13694:                }
13695:
13696:                public final Win32.LOGFONTW get_lfSmCaptionFont() {
13697:                    return Win32.instance
13698:                            .createLOGFONTW(getElementPointer(124));
13699:                }
13700:
13701:                public final void set_iMenuWidth(int val) {
13702:                    byteBase.setInt32(216, val);
13703:                }
13704:
13705:                public final int get_iMenuWidth() {
13706:                    return byteBase.getInt32(216);
13707:                }
13708:
13709:                public final void set_iMenuHeight(int val) {
13710:                    byteBase.setInt32(220, val);
13711:                }
13712:
13713:                public final int get_iMenuHeight() {
13714:                    return byteBase.getInt32(220);
13715:                }
13716:
13717:                public final Win32.LOGFONTW get_lfMenuFont() {
13718:                    return Win32.instance
13719:                            .createLOGFONTW(getElementPointer(224));
13720:                }
13721:
13722:                public final Win32.LOGFONTW get_lfStatusFont() {
13723:                    return Win32.instance
13724:                            .createLOGFONTW(getElementPointer(316));
13725:                }
13726:
13727:                public final Win32.LOGFONTW get_lfMessageFont() {
13728:                    return Win32.instance
13729:                            .createLOGFONTW(getElementPointer(408));
13730:                }
13731:
13732:                @Override
13733:                public int size() {
13734:                    return sizeof;
13735:                }
13736:            }
13737:
13738:            public final NONCLIENTMETRICSW createNONCLIENTMETRICSW(
13739:                    boolean direct) {
13740:                return new NONCLIENTMETRICSW(direct);
13741:            }
13742:
13743:            public final NONCLIENTMETRICSW createNONCLIENTMETRICSW(
13744:                    VoidPointer base) {
13745:                return new NONCLIENTMETRICSW(base);
13746:            }
13747:
13748:            public final NONCLIENTMETRICSW createNONCLIENTMETRICSW(long addr) {
13749:                return new NONCLIENTMETRICSW(addr);
13750:            }
13751:
13752:            public static class MINMAXINFO extends CommonStructWrapper {
13753:
13754:                public static final int sizeof = 40;
13755:
13756:                MINMAXINFO(boolean direct) {
13757:                    super (sizeof, direct);
13758:                }
13759:
13760:                MINMAXINFO(VoidPointer base) {
13761:                    super (base);
13762:                }
13763:
13764:                MINMAXINFO(long addr) {
13765:                    super (addr);
13766:                }
13767:
13768:                public final Win32.POINT get_ptReserved() {
13769:                    return Win32.instance.createPOINT(getElementPointer(0));
13770:                }
13771:
13772:                public final Win32.POINT get_ptMaxSize() {
13773:                    return Win32.instance.createPOINT(getElementPointer(8));
13774:                }
13775:
13776:                public final Win32.POINT get_ptMaxPosition() {
13777:                    return Win32.instance.createPOINT(getElementPointer(16));
13778:                }
13779:
13780:                public final Win32.POINT get_ptMinTrackSize() {
13781:                    return Win32.instance.createPOINT(getElementPointer(24));
13782:                }
13783:
13784:                public final Win32.POINT get_ptMaxTrackSize() {
13785:                    return Win32.instance.createPOINT(getElementPointer(32));
13786:                }
13787:
13788:                @Override
13789:                public int size() {
13790:                    return sizeof;
13791:                }
13792:            }
13793:
13794:            public final MINMAXINFO createMINMAXINFO(boolean direct) {
13795:                return new MINMAXINFO(direct);
13796:            }
13797:
13798:            public final MINMAXINFO createMINMAXINFO(VoidPointer base) {
13799:                return new MINMAXINFO(base);
13800:            }
13801:
13802:            public final MINMAXINFO createMINMAXINFO(long addr) {
13803:                return new MINMAXINFO(addr);
13804:            }
13805:
13806:            public static class SHDESCRIPTIONID extends CommonStructWrapper {
13807:
13808:                public static final int sizeof = 20;
13809:
13810:                SHDESCRIPTIONID(boolean direct) {
13811:                    super (sizeof, direct);
13812:                }
13813:
13814:                SHDESCRIPTIONID(VoidPointer base) {
13815:                    super (base);
13816:                }
13817:
13818:                SHDESCRIPTIONID(long addr) {
13819:                    super (addr);
13820:                }
13821:
13822:                public final void set_dwDescriptionId(int val) {
13823:                    byteBase.setInt32(0, val);
13824:                }
13825:
13826:                public final int get_dwDescriptionId() {
13827:                    return byteBase.getInt32(0);
13828:                }
13829:
13830:                public final Win32.GUID get_clsid() {
13831:                    return Win32.instance.createGUID(getElementPointer(4));
13832:                }
13833:
13834:                @Override
13835:                public int size() {
13836:                    return sizeof;
13837:                }
13838:            }
13839:
13840:            public final SHDESCRIPTIONID createSHDESCRIPTIONID(boolean direct) {
13841:                return new SHDESCRIPTIONID(direct);
13842:            }
13843:
13844:            public final SHDESCRIPTIONID createSHDESCRIPTIONID(VoidPointer base) {
13845:                return new SHDESCRIPTIONID(base);
13846:            }
13847:
13848:            public final SHDESCRIPTIONID createSHDESCRIPTIONID(long addr) {
13849:                return new SHDESCRIPTIONID(addr);
13850:            }
13851:
13852:            public static class STYLESTRUCT extends CommonStructWrapper {
13853:
13854:                public static final int sizeof = 8;
13855:
13856:                STYLESTRUCT(boolean direct) {
13857:                    super (sizeof, direct);
13858:                }
13859:
13860:                STYLESTRUCT(VoidPointer base) {
13861:                    super (base);
13862:                }
13863:
13864:                STYLESTRUCT(long addr) {
13865:                    super (addr);
13866:                }
13867:
13868:                public final void set_styleOld(int val) {
13869:                    byteBase.setInt32(0, val);
13870:                }
13871:
13872:                public final int get_styleOld() {
13873:                    return byteBase.getInt32(0);
13874:                }
13875:
13876:                public final void set_styleNew(int val) {
13877:                    byteBase.setInt32(4, val);
13878:                }
13879:
13880:                public final int get_styleNew() {
13881:                    return byteBase.getInt32(4);
13882:                }
13883:
13884:                @Override
13885:                public int size() {
13886:                    return sizeof;
13887:                }
13888:            }
13889:
13890:            public final STYLESTRUCT createSTYLESTRUCT(boolean direct) {
13891:                return new STYLESTRUCT(direct);
13892:            }
13893:
13894:            public final STYLESTRUCT createSTYLESTRUCT(VoidPointer base) {
13895:                return new STYLESTRUCT(base);
13896:            }
13897:
13898:            public final STYLESTRUCT createSTYLESTRUCT(long addr) {
13899:                return new STYLESTRUCT(addr);
13900:            }
13901:
13902:            public static class TTPOLYCURVE extends CommonStructWrapper {
13903:
13904:                public static final int sizeof = 12;
13905:
13906:                TTPOLYCURVE(boolean direct) {
13907:                    super (sizeof, direct);
13908:                }
13909:
13910:                TTPOLYCURVE(VoidPointer base) {
13911:                    super (base);
13912:                }
13913:
13914:                TTPOLYCURVE(long addr) {
13915:                    super (addr);
13916:                }
13917:
13918:                public final void set_wType(short val) {
13919:                    byteBase.setInt16(0, val);
13920:                }
13921:
13922:                public final short get_wType() {
13923:                    return byteBase.getInt16(0);
13924:                }
13925:
13926:                public final void set_cpfx(short val) {
13927:                    byteBase.setInt16(2, val);
13928:                }
13929:
13930:                public final short get_cpfx() {
13931:                    return byteBase.getInt16(2);
13932:                }
13933:
13934:                public final Int8Pointer get_apfx() {
13935:                    return nb.createInt8Pointer(getElementPointer(4));
13936:                }
13937:
13938:                @Override
13939:                public int size() {
13940:                    return sizeof;
13941:                }
13942:            }
13943:
13944:            public final TTPOLYCURVE createTTPOLYCURVE(boolean direct) {
13945:                return new TTPOLYCURVE(direct);
13946:            }
13947:
13948:            public final TTPOLYCURVE createTTPOLYCURVE(VoidPointer base) {
13949:                return new TTPOLYCURVE(base);
13950:            }
13951:
13952:            public final TTPOLYCURVE createTTPOLYCURVE(long addr) {
13953:                return new TTPOLYCURVE(addr);
13954:            }
13955:
13956:            public static class MONITORINFOEXW extends CommonStructWrapper {
13957:
13958:                public static final int sizeof = 104;
13959:
13960:                MONITORINFOEXW(boolean direct) {
13961:                    super (sizeof, direct);
13962:                }
13963:
13964:                MONITORINFOEXW(VoidPointer base) {
13965:                    super (base);
13966:                }
13967:
13968:                MONITORINFOEXW(long addr) {
13969:                    super (addr);
13970:                }
13971:
13972:                public final Win32.MONITORINFO get_MONITORINFO() {
13973:                    return Win32.instance
13974:                            .createMONITORINFO(getElementPointer(0));
13975:                }
13976:
13977:                public final Int16Pointer get_szDevice() {
13978:                    return nb.createInt16Pointer(getElementPointer(40));
13979:                }
13980:
13981:                @Override
13982:                public int size() {
13983:                    return sizeof;
13984:                }
13985:            }
13986:
13987:            public final MONITORINFOEXW createMONITORINFOEXW(boolean direct) {
13988:                return new MONITORINFOEXW(direct);
13989:            }
13990:
13991:            public final MONITORINFOEXW createMONITORINFOEXW(VoidPointer base) {
13992:                return new MONITORINFOEXW(base);
13993:            }
13994:
13995:            public final MONITORINFOEXW createMONITORINFOEXW(long addr) {
13996:                return new MONITORINFOEXW(addr);
13997:            }
13998:
13999:            public static class WINDOWPOS extends CommonStructWrapper {
14000:
14001:                public static final int sizeof = NativeBridge.is64 ? 40 : 28;
14002:
14003:                WINDOWPOS(boolean direct) {
14004:                    super (sizeof, direct);
14005:                }
14006:
14007:                WINDOWPOS(VoidPointer base) {
14008:                    super (base);
14009:                }
14010:
14011:                WINDOWPOS(long addr) {
14012:                    super (addr);
14013:                }
14014:
14015:                public final void set_hwnd(long val) {
14016:                    byteBase.setAddress(0, val);
14017:                }
14018:
14019:                public final long get_hwnd() {
14020:                    return byteBase.getAddress(0);
14021:                }
14022:
14023:                public final void set_hwndInsertAfter(long val) {
14024:                    byteBase.setAddress(NativeBridge.is64 ? 8 : 4, val);
14025:                }
14026:
14027:                public final long get_hwndInsertAfter() {
14028:                    return byteBase.getAddress(NativeBridge.is64 ? 8 : 4);
14029:                }
14030:
14031:                public final void set_x(int val) {
14032:                    byteBase.setInt32(NativeBridge.is64 ? 16 : 8, val);
14033:                }
14034:
14035:                public final int get_x() {
14036:                    return byteBase.getInt32(NativeBridge.is64 ? 16 : 8);
14037:                }
14038:
14039:                public final void set_y(int val) {
14040:                    byteBase.setInt32(NativeBridge.is64 ? 20 : 12, val);
14041:                }
14042:
14043:                public final int get_y() {
14044:                    return byteBase.getInt32(NativeBridge.is64 ? 20 : 12);
14045:                }
14046:
14047:                public final void set_cx(int val) {
14048:                    byteBase.setInt32(NativeBridge.is64 ? 24 : 16, val);
14049:                }
14050:
14051:                public final int get_cx() {
14052:                    return byteBase.getInt32(NativeBridge.is64 ? 24 : 16);
14053:                }
14054:
14055:                public final void set_cy(int val) {
14056:                    byteBase.setInt32(NativeBridge.is64 ? 28 : 20, val);
14057:                }
14058:
14059:                public final int get_cy() {
14060:                    return byteBase.getInt32(NativeBridge.is64 ? 28 : 20);
14061:                }
14062:
14063:                public final void set_flags(int val) {
14064:                    byteBase.setInt32(NativeBridge.is64 ? 32 : 24, val);
14065:                }
14066:
14067:                public final int get_flags() {
14068:                    return byteBase.getInt32(NativeBridge.is64 ? 32 : 24);
14069:                }
14070:
14071:                @Override
14072:                public int size() {
14073:                    return sizeof;
14074:                }
14075:            }
14076:
14077:            public final WINDOWPOS createWINDOWPOS(boolean direct) {
14078:                return new WINDOWPOS(direct);
14079:            }
14080:
14081:            public final WINDOWPOS createWINDOWPOS(VoidPointer base) {
14082:                return new WINDOWPOS(base);
14083:            }
14084:
14085:            public final WINDOWPOS createWINDOWPOS(long addr) {
14086:                return new WINDOWPOS(addr);
14087:            }
14088:
14089:            public static class NMHDR extends CommonStructWrapper {
14090:
14091:                public static final int sizeof = NativeBridge.is64 ? 24 : 12;
14092:
14093:                NMHDR(boolean direct) {
14094:                    super (sizeof, direct);
14095:                }
14096:
14097:                NMHDR(VoidPointer base) {
14098:                    super (base);
14099:                }
14100:
14101:                NMHDR(long addr) {
14102:                    super (addr);
14103:                }
14104:
14105:                public final void set_hwndFrom(long val) {
14106:                    byteBase.setAddress(0, val);
14107:                }
14108:
14109:                public final long get_hwndFrom() {
14110:                    return byteBase.getAddress(0);
14111:                }
14112:
14113:                public final void set_idFrom(long val) {
14114:                    byteBase.setCLong(NativeBridge.is64 ? 8 : 4, val);
14115:                }
14116:
14117:                public final long get_idFrom() {
14118:                    return byteBase.getCLong(NativeBridge.is64 ? 8 : 4);
14119:                }
14120:
14121:                public final void set_code(int val) {
14122:                    byteBase.setInt32(NativeBridge.is64 ? 16 : 8, val);
14123:                }
14124:
14125:                public final int get_code() {
14126:                    return byteBase.getInt32(NativeBridge.is64 ? 16 : 8);
14127:                }
14128:
14129:                @Override
14130:                public int size() {
14131:                    return sizeof;
14132:                }
14133:            }
14134:
14135:            public final NMHDR createNMHDR(boolean direct) {
14136:                return new NMHDR(direct);
14137:            }
14138:
14139:            public final NMHDR createNMHDR(VoidPointer base) {
14140:                return new NMHDR(base);
14141:            }
14142:
14143:            public final NMHDR createNMHDR(long addr) {
14144:                return new NMHDR(addr);
14145:            }
14146:
14147:            public static class POINTFX extends CommonStructWrapper {
14148:
14149:                public static final int sizeof = 8;
14150:
14151:                POINTFX(boolean direct) {
14152:                    super (sizeof, direct);
14153:                }
14154:
14155:                POINTFX(VoidPointer base) {
14156:                    super (base);
14157:                }
14158:
14159:                POINTFX(long addr) {
14160:                    super (addr);
14161:                }
14162:
14163:                public final FIXED get_x() {
14164:                    return instance.createFIXED(getElementPointer(0));
14165:                }
14166:
14167:                public final FIXED get_y() {
14168:                    return instance.createFIXED(getElementPointer(4));
14169:                }
14170:
14171:                @Override
14172:                public int size() {
14173:                    return sizeof;
14174:                }
14175:            }
14176:
14177:            public final POINTFX createPOINTFX(boolean direct) {
14178:                return new POINTFX(direct);
14179:            }
14180:
14181:            public final POINTFX createPOINTFX(VoidPointer base) {
14182:                return new POINTFX(base);
14183:            }
14184:
14185:            public final POINTFX createPOINTFX(long addr) {
14186:                return new POINTFX(addr);
14187:            }
14188:
14189:            public static class FIXED extends CommonStructWrapper {
14190:
14191:                public static final int sizeof = 4;
14192:
14193:                FIXED(boolean direct) {
14194:                    super (sizeof, direct);
14195:                }
14196:
14197:                FIXED(VoidPointer base) {
14198:                    super (base);
14199:                }
14200:
14201:                FIXED(long addr) {
14202:                    super (addr);
14203:                }
14204:
14205:                public final void set_fract(short val) {
14206:                    byteBase.setInt16(0, val);
14207:                }
14208:
14209:                public final short get_fract() {
14210:                    return byteBase.getInt16(0);
14211:                }
14212:
14213:                public final void set_value(short val) {
14214:                    byteBase.setInt16(2, val);
14215:                }
14216:
14217:                public final short get_value() {
14218:                    return byteBase.getInt16(2);
14219:                }
14220:
14221:                @Override
14222:                public int size() {
14223:                    return sizeof;
14224:                }
14225:            }
14226:
14227:            public final FIXED createFIXED(boolean direct) {
14228:                return new FIXED(direct);
14229:            }
14230:
14231:            public final FIXED createFIXED(VoidPointer base) {
14232:                return new FIXED(base);
14233:            }
14234:
14235:            public final FIXED createFIXED(long addr) {
14236:                return new FIXED(addr);
14237:            }
14238:
14239:        }
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.