replaced <code></code> with more concise {@code}
[idea/community.git] / platform / credential-store / src / windows / W32API.java
1 /* Copyright (c) 2007 Timothy Wall, All Rights Reserved
2  * 
3  * This library is free software; you can redistribute it and/or
4  * modify it under the terms of the GNU Lesser General Public
5  * License as published by the Free Software Foundation; either
6  * version 2.1 of the License, or (at your option) any later version.
7  * 
8  * This library is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11  * Lesser General Public License for more details.  
12  */
13 package com.intellij.credentialStore.windows;
14
15 import com.sun.jna.*;
16 import com.sun.jna.ptr.ByReference;
17 import com.sun.jna.win32.StdCallLibrary;
18
19 /** Base type for most W32 API libraries.  Provides standard options
20  * for unicode/ASCII mappings.  Set the system property {@code w32.ascii}
21  * to {@code true} to default to the ASCII mappings.
22  */
23 @SuppressWarnings("serial")
24 public interface W32API extends StdCallLibrary {    
25     class HANDLE extends PointerType {
26         private boolean immutable;
27         public HANDLE() { }
28         public HANDLE(Pointer p) { setPointer(p); immutable = true; }
29         
30         /** Override to the appropriate object for INVALID_HANDLE_VALUE. */
31         public Object fromNative(Object nativeValue, FromNativeContext context) {
32             Object o = super.fromNative(nativeValue, context);
33             if (INVALID_HANDLE_VALUE.equals(o))
34                 return INVALID_HANDLE_VALUE;
35             return o;
36         }
37         
38         public void setPointer(Pointer p) {
39             if (immutable)
40                 throw new UnsupportedOperationException("immutable reference");
41             super.setPointer(p);
42         }
43     }
44     
45         class WORD extends IntegerType {
46         public WORD() { this(0); }
47         public WORD(long value) { super(2, value); } 
48     }
49         
50         class DWORD extends IntegerType {
51         public DWORD() { this(0); }
52         public DWORD(long value) { super(4, value); } 
53     }
54         
55         class LONG extends IntegerType {
56         public LONG() { this(0); }
57         public LONG(long value) { super(Native.LONG_SIZE, value); } 
58     }
59     
60     class HDC extends HANDLE { }
61     class HICON extends HANDLE { }
62     class HBITMAP extends HANDLE { }
63     class HRGN extends HANDLE { }
64     class HWND extends HANDLE {
65         public HWND() { }
66         public HWND(Pointer p) { super(p); }
67     }
68     class HINSTANCE extends HANDLE { }
69     class HMODULE extends HINSTANCE { }
70     
71     /**
72      * The HRESULT data type is a 32-bit value is used to describe an error or warning.
73      */
74     class HRESULT extends NativeLong {
75         public HRESULT() {
76                 
77         }
78         
79         public HRESULT(int value) {
80                 super(value);
81         }
82     }
83
84     /** Constant value representing an invalid HANDLE. */
85     HANDLE INVALID_HANDLE_VALUE = new HANDLE(Pointer.createConstant(Pointer.SIZE==8?-1:0xFFFFFFFFL));
86
87     /** Special HWND value. */
88     HWND HWND_BROADCAST = new HWND(Pointer.createConstant(0xFFFF));
89
90     /** LPHANDLE */
91     class HANDLEByReference extends ByReference {
92         
93         public HANDLEByReference() {
94             this(null);
95         }
96         
97         public HANDLEByReference(HANDLE h) {
98             super(Pointer.SIZE);
99             setValue(h);
100         }
101         
102         public void setValue(HANDLE h) {
103             getPointer().setPointer(0, h != null ? h.getPointer() : null);
104         }
105         
106         public HANDLE getValue() {
107             Pointer p = getPointer().getPointer(0);
108             if (p == null)
109                 return null;
110             if (INVALID_HANDLE_VALUE.getPointer().equals(p)) 
111                 return INVALID_HANDLE_VALUE;
112             HANDLE h = new HANDLE();
113             h.setPointer(p);
114             return h;
115         }
116     }
117     
118     class LONG_PTR extends IntegerType { 
119         public LONG_PTR() { this(0); }
120         public LONG_PTR(long value) { super(Pointer.SIZE, value); }
121     }
122     
123     class SSIZE_T extends LONG_PTR {
124         public SSIZE_T() { this(0); }
125         public SSIZE_T(long value) { super(value); }
126     }
127     
128     class ULONG_PTR extends IntegerType { 
129         public ULONG_PTR() { this(0); }
130         public ULONG_PTR(long value) { super(Pointer.SIZE, value); }
131     }
132     
133     class SIZE_T extends ULONG_PTR {
134         public SIZE_T() { this(0); }
135         public SIZE_T(long value) { super(value); }
136     }
137     
138     class LPARAM extends LONG_PTR { 
139         public LPARAM() { this(0); }
140         public LPARAM(long value) { super(value); }
141     } 
142     
143     class LRESULT extends LONG_PTR { 
144         public LRESULT() { this(0); }
145         public LRESULT(long value) { super(value); }
146     }
147
148     class UINT_PTR extends IntegerType {
149         public UINT_PTR() { super(Pointer.SIZE); }
150         public UINT_PTR(long value) { super(Pointer.SIZE, value); }
151         public Pointer toPointer() { return Pointer.createConstant(longValue()); }
152     }
153
154     class WPARAM extends UINT_PTR {
155         public WPARAM() { this(0); }
156         public WPARAM(long value) { super(value); }
157     }
158 }