def __init__(self, path):
ex = Excel.ApplicationClass()
ex.Visible = False
lst_xls = []
workbook = ex.Workbooks.Open(path)
ws = workbook.Worksheets[1]
rowCountF = max(ws.Range(i).End(xlDirecUp).Row for i in ["A65536", "B65536", "C65536", "D65536", "E65536", "F65536", "G65536", "H65536"])
# other method if column A is empty
# rowCountF = ws.Range("B65536").End(xlDirecUp).Row
# rowCountF = ws.Columns[1].End(xlDirecDown).Row
##get number of Coloun not empty ##
colCountF = max(ws.Range(i).End(xlDirecLeft).Column for i in ["ZZ1", "ZZ2", "ZZ3", "ZZ4", "ZZ5", "ZZ6", "ZZ7", "ZZ8", "ZZ9"])
# other methods
#colCountF = ws.Range("ZZ9").End(xlDirecLeft).Column
# colCountF = ws.Rows[1].End(xlDirecRight).Column
for i in range(1,rowCountF+1):
temp_lst = []
for j in range(1,colCountF+1):
try:
temp_lst.append(ws.Cells[i,j].Value2.ToString())
except:
temp_lst.append(ws.Cells[i,j].Value2)
lst_xls.append(temp_lst)
self.datas = lst_xls
self.first_flst = [x for x in lst_xls[0]] # or lst_xls[0]
#Get the specify index
self.type_fidx = self.first_flst.index("Type")
ex.Workbooks.Close()
ex.Quit()
#other proper way to make sure that you really closed and released all COM objects
Marshal.ReleaseComObject(workbook)
Marshal.ReleaseComObject(ex)
def testStoreSameObjectIncRefsOriginal(self):
frees = []
allocs = []
mapper = PythonMapper(GetAllocatingTestAllocator(allocs, frees))
deallocTypes = CreateTypes(mapper)
del allocs[:]
obj1 = object()
result1 = mapper.Store(obj1)
result2 = mapper.Store(obj1)
self.assertEquals(allocs, [(result1, Marshal.SizeOf(PyObject))],
"unexpected result")
self.assertEquals(result1, result2, "did not return same ptr")
self.assertEquals(mapper.RefCount(result1), 2, "did not incref")
mapper.DecRef(result1)
del frees[:]
mapper.DecRef(result1)
self.assertEquals(frees, [result1], "did not free memory")
result3 = mapper.Store(obj1)
self.assertEquals(
allocs, [(result1, Marshal.SizeOf(PyObject)),
(result3, Marshal.SizeOf(PyObject))],
"unexpected result -- failed to clear reverse mapping?")
mapper.Dispose()
deallocTypes()
def testInternExisting(self, mapper, addToCleanUp):
testString = "mars needs women" + self.getStringWithValues(1, 256)
bytes = self.byteArrayFromString(testString)
testData = self.ptrFromByteArray(bytes)
sp1 = mapper.PyString_FromString(testData)
addToCleanUp(lambda: Marshal.FreeHGlobal(sp1p))
sp2 = mapper.PyString_InternFromString(testData)
addToCleanUp(lambda: Marshal.FreeHGlobal(testData))
self.assertNotEquals(sp1, sp2)
self.assertFalse(mapper.Retrieve(sp1) is mapper.Retrieve(sp2))
self.assertEquals(mapper.RefCount(sp1), 1)
self.assertEquals(
mapper.RefCount(sp2), 2,
'failed to grab extra reference to induce immortality')
mapper.IncRef(sp1)
sp1p = Marshal.AllocHGlobal(Marshal.SizeOf(IntPtr))
CPyMarshal.WritePtr(sp1p, sp1)
mapper.PyString_InternInPlace(sp1p)
sp1i = CPyMarshal.ReadPtr(sp1p)
self.assertEquals(sp1i, sp2, 'failed to intern')
self.assertTrue(mapper.Retrieve(sp1i) is mapper.Retrieve(sp2))
self.assertEquals(mapper.RefCount(sp1), 1,
'failed to decref old string')
self.assertEquals(mapper.RefCount(sp2), 3,
'failed to incref interned string')
def CleanUp(_list):
if isinstance(_list, list):
for i in _list:
Marshal.ReleaseComObject(i)
else:
Marshal.ReleaseComObject(_list)
return None
def excelWorkbookAction(workbook):
worksheets = workbook.Worksheets
worksheet = worksheets[worksheetName] if worksheetName is not None else worksheets[1]
WriteRowsToWorksheet(worksheet, rows)
Marshal.FinalReleaseComObject(worksheet)
Marshal.FinalReleaseComObject(worksheets)
return
def testStoreTypeDictCreatesDictTypeWhichWorks(self, mapper, addToCleanUp):
typeBlock = Marshal.AllocHGlobal(Marshal.SizeOf(PyTypeObject))
addToCleanUp(lambda: Marshal.FreeHGlobal(typeBlock))
mapper.RegisterData("PyDict_Type", typeBlock)
class klass(object):
pass
dictPtr = mapper.Store(klass.__dict__)
self.assertEquals(
CPyMarshal.ReadPtrField(dictPtr, PyObject, "ob_type"), typeBlock,
"wrong type")
self.assertEquals(
mapper.PyDict_SetItemString(dictPtr, 'foo', mapper.Store('bar')),
0)
self.assertEquals(
mapper.PyDict_SetItem(dictPtr, mapper.Store('baz'),
mapper.Store('qux')), 0)
self.assertEquals(
mapper.Retrieve(mapper.PyDict_GetItemString(dictPtr, 'foo')),
'bar')
self.assertEquals(
mapper.Retrieve(mapper.PyDict_GetItem(dictPtr,
mapper.Store('baz'))), 'qux')
self.assertEquals(klass.foo, 'bar')
self.assertEquals(klass.baz, 'qux')
self.assertEquals(mapper.PyDict_Size(dictPtr), len(klass.__dict__))
def closeProperly(self):
if self.workbook is not None:
Marshal.ReleaseComObject(self.workbook)
if self.app is not None:
Marshal.ReleaseComObject(self.app)
self.workbook = None
self.app = None
def excelWorkbookAction(workbook):
worksheets = workbook.Worksheets
worksheet = worksheets[worksheetName] if worksheetName is not None else worksheets[1]
rows = ReadRowsTextFromWorksheet(worksheet)
Marshal.FinalReleaseComObject(worksheet)
Marshal.FinalReleaseComObject(worksheets)
return rows
def testPyType_Ready(self, mapper, addToCleanUp):
typePtr = Marshal.AllocHGlobal(Marshal.SizeOf(PyTypeObject()))
CPyMarshal.Zero(typePtr, Marshal.SizeOf(PyTypeObject()))
addToCleanUp(lambda: Marshal.FreeHGlobal(typePtr))
self.assertEquals(mapper.PyType_Ready(typePtr), 0, "wrong")
self.assertEquals(
CPyMarshal.ReadPtrField(typePtr, PyTypeObject, "ob_type"),
mapper.PyType_Type, "failed to fill in missing ob_type")
self.assertEquals(
CPyMarshal.ReadPtrField(typePtr, PyTypeObject, "tp_base"),
mapper.PyBaseObject_Type, "failed to fill in missing tp_base")
tp_dict = mapper.Retrieve(
CPyMarshal.ReadPtrField(typePtr, PyTypeObject, "tp_dict"))
self.assertEquals(mapper.Retrieve(typePtr).__dict__, tp_dict)
typeFlags = CPyMarshal.ReadIntField(typePtr, PyTypeObject, "tp_flags")
self.assertEquals(typeFlags & UInt32(Py_TPFLAGS.READY),
UInt32(Py_TPFLAGS.READY), "did not ready type")
self.assertEquals(
typeFlags & UInt32(Py_TPFLAGS.HAVE_CLASS),
UInt32(Py_TPFLAGS.HAVE_CLASS),
"we always set this flag, for no better reason than 'it makes ctypes kinda work'"
)
CPyMarshal.WritePtrField(typePtr, PyTypeObject, "ob_type", IntPtr.Zero)
self.assertEquals(mapper.PyType_Ready(typePtr), 0, "wrong")
self.assertEquals(
CPyMarshal.ReadPtrField(typePtr, PyTypeObject, "ob_type"),
IntPtr.Zero, "unexpectedly and unnecessarily rereadied type")
def closeProperly(self):
if self.document is not None:
Marshal.ReleaseComObject(self.document)
if self.wapp is not None:
Marshal.ReleaseComObject(self.wapp)
self.document = None
self.wapp = None
def testPyList_New_NonZeroLength(self):
allocs = []
mapper = PythonMapper(GetAllocatingTestAllocator(allocs, []))
deallocTypes = CreateTypes(mapper)
del allocs[:]
SIZE = 27
listPtr = mapper.PyList_New(SIZE)
listStruct = Marshal.PtrToStructure(listPtr, PyListObject)
self.assertEquals(listStruct.ob_refcnt, 1, "bad refcount")
self.assertEquals(listStruct.ob_type, mapper.PyList_Type, "bad type")
self.assertEquals(listStruct.ob_size, SIZE, "bad ob_size")
self.assertEquals(listStruct.allocated, SIZE, "bad allocated")
dataPtr = listStruct.ob_item
self.assertNotEquals(dataPtr, IntPtr.Zero, "failed to allocate space for data")
expectedAllocs = [(dataPtr, (SIZE * CPyMarshal.PtrSize)), (listPtr, Marshal.SizeOf(PyListObject))]
self.assertEquals(set(allocs), set(expectedAllocs), "allocated wrong")
for _ in range(SIZE):
self.assertEquals(CPyMarshal.ReadPtr(dataPtr), IntPtr.Zero, "failed to zero memory")
dataPtr = OffsetPtr(dataPtr, CPyMarshal.PtrSize)
mapper.Dispose()
deallocTypes()
def __enter__(self):
#$if $$notdemo
global EPLATFORMCLASS
with threading.RLock(): # Без этого не работает. Нужно разбираться.
self.ad = self.ent.like_dispatch.GetType().InvokeMember(
'AppDispatch', BindingFlags.Public | BindingFlags.GetProperty,
None, self.ent.like_dispatch, None)
try:
self.ad.GetType()
except:
EPLATFORMCLASS = 8
else:
EPLATFORMCLASS = 7
Marshal.GetIUnknownForObject(self.ad)
#$else
with threading.RLock(): # Без этого не работает. Нужно разбираться.
# self.ad = self.ent.like_dispatch.GetType().InvokeMember('AppDispatch', BindingFlags.Public | BindingFlags.InvokeMethod, None, self.ent.like_dispatch, None)
self.ad = self.ent.like_dispatch.GetType().InvokeMember(
'AppDispatch', BindingFlags.Public | BindingFlags.GetProperty,
None, self.ent.like_dispatch, None)
Marshal.GetIUnknownForObject(self.ad)
#$end if
UseAppDispatch.counter += 1
return self.ad
def xlr2list(xlrange):
"""Converts excel range to python list
"""
rows = xlrange.Rows
columns = xlrange.Columns
n = rows.Count
m = columns.Count
vals = [[0] * m for i in range(n)]
for i in range(n):
for j in range(m):
tmp = xlrange[i + 1, j + 1].Value2
try:
if int(tmp) == tmp:
tmp = int(tmp)
except:
# tmp = tmp.unicode('utf8')
pass
# print tmp
vals[i][j] = tmp
Marshal.FinalReleaseComObject(rows)
Marshal.FinalReleaseComObject(columns)
Marshal.FinalReleaseComObject(xlrange)
rows = None
columns = None
xlrange = None
return vals
def testStoreTupleCreatesTupleType(self):
allocs = []
mapper = PythonMapper(GetAllocatingTestAllocator(allocs, []))
typeBlock = Marshal.AllocHGlobal(Marshal.SizeOf(PyTypeObject()))
mapper.RegisterData("PyTuple_Type", typeBlock)
theTuple = (0, 1, 2)
tuplePtr = mapper.Store(theTuple)
self.assertEquals(
CPyMarshal.ReadPtrField(tuplePtr, PyTupleObject, "ob_type"),
typeBlock, "wrong type")
dataPtr = OffsetPtr(tuplePtr, Marshal.OffsetOf(PyTupleObject,
"ob_item"))
for i in range(3):
item = mapper.Retrieve(CPyMarshal.ReadPtr(dataPtr))
self.assertEquals(item, i, "did not store data")
dataPtr = OffsetPtr(dataPtr, CPyMarshal.PtrSize)
tuplePtr2 = mapper.Store(theTuple)
self.assertEquals(tuplePtr2, tuplePtr,
"didn't realise already had this tuple")
self.assertEquals(mapper.RefCount(tuplePtr), 2, "didn't incref")
mapper.Dispose()
Marshal.FreeHGlobal(typeBlock)
def readFromDatasetWithCompoundType(dset):
mtype = createMemType()
sizeof = H5T.getSize(mtype)
dspace = H5D.getSpace(dset)
npoints = H5S.getSimpleExtentNPoints(dspace)
shape = Array[Int64]((npoints * sizeof, ))
byteArray = Array.CreateInstance(Byte, shape)
H5D.read(dset, mtype, H5Array[Byte](byteArray))
ms = MemoryStream(byteArray)
reader = BinaryReader(ms)
for i in range(npoints):
if IntPtr.Size == 8:
print '%d,%s,%.2f,%.2f' % (reader.ReadInt32(
), Marshal.PtrToStringAnsi(IntPtr(
reader.ReadInt64())), reader.ReadDouble(), reader.ReadDouble())
else:
print '%d,%s,%.2f,%.2f' % (reader.ReadInt32(
), Marshal.PtrToStringAnsi(IntPtr(
reader.ReadInt32())), reader.ReadDouble(), reader.ReadDouble())
H5S.close(dspace)
H5T.close(mtype)
return None
def testBufferProtocol(self, mapper, later):
# should all be implemented in C really, but weaving cpy string type into
# our code feels too much like hard work for now
strPtr = mapper.PyString_Type
bufPtr = CPyMarshal.ReadPtrField(strPtr, PyTypeObject, 'tp_as_buffer')
self.assertNotEquals(bufPtr, IntPtr.Zero)
getreadbuffer = CPyMarshal.ReadFunctionPtrField(
bufPtr, PyBufferProcs, 'bf_getreadbuffer', dgt_int_ptrintptr)
getwritebuffer = CPyMarshal.ReadFunctionPtrField(
bufPtr, PyBufferProcs, 'bf_getwritebuffer', dgt_int_ptrintptr)
getcharbuffer = CPyMarshal.ReadFunctionPtrField(
bufPtr, PyBufferProcs, 'bf_getcharbuffer', dgt_int_ptrintptr)
getsegcount = CPyMarshal.ReadFunctionPtrField(bufPtr, PyBufferProcs,
'bf_getsegcount',
dgt_int_ptrptr)
ptrptr = Marshal.AllocHGlobal(Marshal.SizeOf(IntPtr))
later(lambda: Marshal.FreeHGlobal(ptrptr))
strptr = mapper.Store("hullo")
for getter in (getreadbuffer, getcharbuffer):
self.assertEquals(getter(strptr, 0, ptrptr), 5)
self.assertEquals(
CPyMarshal.ReadPtr(ptrptr),
CPyMarshal.GetField(strptr, PyStringObject, 'ob_sval'))
self.assertEquals(getter(strptr, 1, ptrptr), -1)
self.assertMapperHasError(mapper, SystemError)
self.assertEquals(getwritebuffer(strptr, 0, ptrptr), -1)
self.assertMapperHasError(mapper, SystemError)
self.assertEquals(getsegcount(strptr, ptrptr), 1)
self.assertEquals(CPyMarshal.ReadInt(ptrptr), 5)
self.assertEquals(getsegcount(strptr, IntPtr.Zero), 1)
def testTrueFalse(self, mapper, _):
truePtr = Marshal.AllocHGlobal(Marshal.SizeOf(PyIntObject))
mapper.RegisterData("_Py_TrueStruct", truePtr)
self.assertTrue(mapper.Retrieve(truePtr) is True)
self.assertEquals(
CPyMarshal.ReadPtrField(truePtr, PyIntObject, 'ob_type'),
mapper.PyBool_Type)
self.assertEquals(
CPyMarshal.ReadIntField(truePtr, PyIntObject, 'ob_refcnt'), 1)
self.assertEquals(
CPyMarshal.ReadIntField(truePtr, PyIntObject, 'ob_ival'), 1)
truePtr2 = mapper.Store(True)
self.assertEquals(truePtr2, truePtr)
self.assertEquals(mapper.RefCount(truePtr), 2)
falsePtr = Marshal.AllocHGlobal(Marshal.SizeOf(PyIntObject))
mapper.RegisterData("_Py_ZeroStruct", falsePtr)
self.assertTrue(mapper.Retrieve(falsePtr) is False)
self.assertEquals(
CPyMarshal.ReadPtrField(falsePtr, PyIntObject, 'ob_type'),
mapper.PyBool_Type)
self.assertEquals(
CPyMarshal.ReadIntField(falsePtr, PyIntObject, 'ob_refcnt'), 1)
self.assertEquals(
CPyMarshal.ReadIntField(falsePtr, PyIntObject, 'ob_ival'), 0)
falsePtr2 = mapper.Store(False)
self.assertEquals(falsePtr2, falsePtr)
self.assertEquals(mapper.RefCount(falsePtr), 2)
def testPyFile_Type(self, mapper, addToCleanUp):
typeBlock = Marshal.AllocHGlobal(Marshal.SizeOf(PyTypeObject))
addToCleanUp(lambda: Marshal.FreeHGlobal(typeBlock))
mapper.RegisterData("PyFile_Type", typeBlock)
self.assertEquals(mapper.PyFile_Type, typeBlock, "type address not stored")
self.assertEquals(mapper.Retrieve(typeBlock), file, "type not mapped")
def excel_read(origin = "A3", worksheetname="Levels"):
try:
xlapp = Marshal.GetActiveObject('Excel.Application')
ws = xlapp.sheets(worksheetname) #Name of the Excel Worksheet
except EnvironmentError:
try:
filepath = pick_file(file_ext='*')
except: sys.exit()
os.startfile(filepath)
from time import sleep
sleep(1)
try:
xlapp = Marshal.GetActiveObject('Excel.Application')
ws = xlapp.sheets(worksheetname) #Name of the Excel Worksheet
except:
forms.alert('Excel Application not open!\nOpen Excel file with worksheet "Levels" ')
dialogexcelnotopen.show()
sys.exit()
except:
print("Error")
import traceback
print(traceback.format_exc())
extent = ws.Cells(ws.UsedRange.Rows(ws.UsedRange.Rows.Count).Row,
ws.UsedRange.Columns(ws.UsedRange.Columns.Count).Column)
xlrng = ws.Range[origin, extent].Value2 # 2dimensional array
data_list = [[] for i in range(xlrng.GetUpperBound(0))]
for i in range(xlrng.GetLowerBound(0)-1, xlrng.GetUpperBound(0), 1):
for j in range(xlrng.GetLowerBound(1)-1, xlrng.GetUpperBound(1), 1):
data_list[i].append(xlrng[i,j])
Marshal.ReleaseComObject(xlapp)
return data_list
def testShrink(self):
allocs = []
frees = []
mapper = PythonMapper(GetAllocatingTestAllocator(allocs, frees))
deallocTypes = CreateTypes(mapper)
del allocs[:]
oldLength = 365
newLength = 20
ptrPtr = Marshal.AllocHGlobal(Marshal.SizeOf(IntPtr))
try:
strPtr = mapper.PyString_FromStringAndSize(IntPtr.Zero, oldLength)
Marshal.WriteIntPtr(ptrPtr, strPtr)
baseSize = Marshal.SizeOf(PyStringObject)
self.assertEquals(allocs, [(strPtr, oldLength + baseSize)],
"allocated wrong")
self.assertEquals(mapper._PyString_Resize(ptrPtr, newLength), 0,
"bad return on success")
self.assertHasStringType(strPtr, mapper)
self.assertStringObjectHasLength(strPtr, newLength)
self.assertEquals(allocs, [(strPtr, oldLength + baseSize)],
"unexpected extra alloc")
self.assertEquals(frees, [], "unexpected frees")
finally:
mapper.Dispose()
Marshal.FreeHGlobal(ptrPtr)
deallocTypes()
def test_PyTuple_Resize_TooBig(self, mapper, addDealloc):
tuplePtrPtr = Marshal.AllocHGlobal(CPyMarshal.PtrSize)
addDealloc(lambda: Marshal.FreeHGlobal(tuplePtrPtr))
tuplePtr = mapper.PyTuple_New(1)
CPyMarshal.WritePtr(tuplePtrPtr, tuplePtr)
self.assertEquals(mapper._PyTuple_Resize(tuplePtrPtr, 2000000000), -1)
self.assertEquals(CPyMarshal.ReadPtr(tuplePtrPtr), IntPtr.Zero)
def testActualiseFloat(self, mapper, call_later):
fptr = Marshal.AllocHGlobal(Marshal.SizeOf(PyFloatObject))
call_later(lambda: Marshal.FreeHGlobal(fptr))
CPyMarshal.WritePtrField(fptr, PyFloatObject, "ob_type",
mapper.PyFloat_Type)
CPyMarshal.WriteIntField(fptr, PyFloatObject, "ob_refcnt", 1)
CPyMarshal.WriteDoubleField(fptr, PyFloatObject, "ob_fval", 1.234)
self.assertEquals(mapper.Retrieve(fptr), 1.234)
def testReadDouble(self):
data = Marshal.AllocHGlobal(CPyMarshal.DoubleSize)
doubleStruct = DoubleStruct(2.2e22)
Marshal.StructureToPtr(doubleStruct, data, False)
self.assertEquals(CPyMarshal.ReadDouble(data), 2.2e22)
Marshal.FreeHGlobal(data)
def testWriteDouble(self):
data = Marshal.AllocHGlobal(CPyMarshal.DoubleSize)
CPyMarshal.WriteDouble(data, 2.2e22)
doubleStruct = PtrToStructure(data, DoubleStruct)
self.assertEquals(doubleStruct.value, 2.2e22)
Marshal.FreeHGlobal(data)
def testIgnoresBridgeObjectsNotAllocatedByAllocator(self):
obj = object()
ptr = Marshal.AllocHGlobal(Marshal.SizeOf(PyObject))
CPyMarshal.WriteIntField(ptr, PyObject, 'ob_refcnt', 2)
mapper = PythonMapper()
mapper.StoreBridge(ptr, obj)
mapper.Dispose()
def testPyType_IsSubtype_NullPtrs(self, mapper, CallLater):
type_size = Marshal.SizeOf(PyTypeObject)
ptr = Marshal.AllocHGlobal(type_size)
CallLater(lambda: Marshal.FreeHGlobal(ptr))
CPyMarshal.Zero(ptr, type_size)
self.assertTrue(mapper.PyType_IsSubtype(ptr, mapper.PyBaseObject_Type))
self.assertTrue(mapper.PyType_IsSubtype(ptr, ptr))
def testFills(self, mapper, addToCleanUp):
# TODO: if we set a lower value, numpy will crash inside arr_add_docstring
# I consider docstrings to be low-priority-enough that it's OK to fudge this
# for now. also, fixing it would be hard ;).
flagPtr = Marshal.AllocHGlobal(Marshal.SizeOf(Int32))
addToCleanUp(lambda: Marshal.FreeHGlobal(flagPtr))
mapper.RegisterData("Py_OptimizeFlag", flagPtr)
self.assertEquals(CPyMarshal.ReadInt(flagPtr), 2)
def testWriteDoubleField(self):
data = Marshal.AllocHGlobal(Marshal.SizeOf(PyFloatObject()))
CPyMarshal.Zero(data, Marshal.SizeOf(PyFloatObject()))
CPyMarshal.WriteDoubleField(data, PyFloatObject, "ob_fval", 7.6e-5)
dataStruct = PtrToStructure(data, PyFloatObject)
self.assertEquals(dataStruct.ob_fval, 7.6e-5)
Marshal.FreeHGlobal(data)
def testWorksWithNonString(self, mapper, addDealloc):
dataPtrPtr = Marshal.AllocHGlobal(CPyMarshal.PtrSize * 2)
sizePtr = CPyMarshal.Offset(dataPtrPtr, CPyMarshal.PtrSize)
addDealloc(lambda: Marshal.FreeHGlobal(dataPtrPtr))
self.assertEquals(
mapper.PyString_AsStringAndSize(mapper.Store(object()), dataPtrPtr,
sizePtr), -1)
self.assertMapperHasError(mapper, TypeError)
def testWritePtrField(self):
data = Marshal.AllocHGlobal(Marshal.SizeOf(PyObject()))
CPyMarshal.Zero(data, Marshal.SizeOf(PyObject()))
CPyMarshal.WritePtrField(data, PyObject, "ob_type", IntPtr(12345))
dataStruct = PtrToStructure(data, PyObject)
self.assertEquals(dataStruct.ob_type, IntPtr(12345), "failed to write")
Marshal.FreeHGlobal(data)
