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: }
|