Changeset 67

Timestamp:

04/27/08 16:08:11 (4 months ago)

Author:

Chris Miller

Message:

Picture can now construct directly from a memory buffer. Other minor changes.

Files:

• trunk/win32/dfl/control.d (modified) (1 diff)
• trunk/win32/dfl/drawing.d (modified) (4 diffs)
• trunk/win32/dfl/internal/com.d (modified) (1 diff)
• trunk/win32/dfl/makelib.bat (modified) (1 diff)

trunk/win32/dfl/control.d

@@ -3260 +3260 @@
-        final DragDropEffects doDragDrop(dfl.data.IDataObject dataObj, DragDropEffects allowedEffects)
-        {
-volatile 
+
-            
-            DWORD effect;

trunk/win32/dfl/drawing.d

@@ -1132 +1132 @@
-    
-    
+    /// ditto
+    this(void[] mem)
+    {
+        this.ipic = _fromMemory(mem);
+        if(!this.ipic)
+            throw new DflException("Unable to load picture from memory");
+    }
+    
+    
-    private this(dfl.internal.wincom.IPicture ipic)
-    {
@@ -1142 +1151 @@
-    static Picture fromStream(DStream stm)
-    {
-
-
+
-        if(!ipic)
-            return null;
@@ -1154 +1162 @@
-    static Picture fromFile(Dstring fileName)
-    {
-
-
+
+
+
+
+
+
+
+
+
+
+
-        if(!ipic)
-            return null;
@@ -1494 +1511 @@
-        
-        ipic = _fromIStream(istm);
-        if(!ipic)
-        {
-            istm.Release();
-            return null;
-        }
-        
-        istm.Release();
-        
-        return ipic;
-    }
+    
+    
+    static dfl.internal.wincom.IPicture _fromMemory(void[] mem)
+    {
+        return _fromIStream(new MemoryIStream(mem));
+    }
+    
-}
-

trunk/win32/dfl/internal/com.d

@@ -356 +356 @@
-}
-
+
+class MemoryIStream: DflComObject, dfl.internal.wincom.IStream
+{
+    this(void[] memory)
+    {
+        this.mem = memory;
+    }
+    
+    
+    extern(Windows):
+    
+    override HRESULT QueryInterface(IID* riid, void** ppv)
+    {
+        if(*riid == _IID_IStream)
+        {
+            *ppv = cast(void*)cast(dfl.internal.wincom.IStream)this;
+            AddRef();
+            return S_OK;
+        }
+        else if(*riid == _IID_ISequentialStream)
+        {
+            *ppv = cast(void*)cast(dfl.internal.wincom.ISequentialStream)this;
+            AddRef();
+            return S_OK;
+        }
+        else if(*riid == _IID_IUnknown)
+        {
+            *ppv = cast(void*)cast(IUnknown)this;
+            AddRef();
+            return S_OK;
+        }
+        else
+        {
+            *ppv = null;
+            return E_NOINTERFACE;
+        }
+    }
+    
+    
+    HRESULT Read(void* pv, ULONG cb, ULONG* pcbRead)
+    {
+        // Shouldn't happen unless the mem changes, which doesn't happen yet.
+        if(seekpos > mem.length)
+            return S_FALSE; // ?
+        
+        size_t count = mem.length - seekpos;
+        if(count > cb)
+            count = cb;
+        
+        pv[0 .. count] = mem[seekpos .. seekpos + count];
+        seekpos += count;
+        
+        if(pcbRead)
+            *pcbRead = count;
+        return S_OK;
+    }
+    
+    
+    HRESULT Write(void* pv, ULONG cb, ULONG* pcbWritten)
+    {
+        //return STG_E_ACCESSDENIED;
+        return E_NOTIMPL;
+    }
+    
+    
+    HRESULT Seek(LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER* plibNewPosition)
+    {
+        //printf("seek move=%u, origin=0x%x\n", cast(uint)dlibMove.QuadPart, dwOrigin);
+        
+        auto toPos = cast(long)dlibMove.QuadPart;
+        switch(dwOrigin)
+        {
+            case STREAM_SEEK_SET:
+                break;
+            
+            case STREAM_SEEK_CUR:
+                toPos = cast(long)seekpos + toPos;
+                break;
+            
+            case STREAM_SEEK_END:
+                toPos = cast(long)mem.length - toPos;
+                break;
+            
+            default:
+                return STG_E_INVALIDFUNCTION;
+        }
+        
+        if(withinbounds(toPos))
+        {
+            seekpos = cast(size_t)toPos;
+            if(plibNewPosition)
+                plibNewPosition.QuadPart = seekpos;
+            return S_OK;
+        }
+        else
+        {
+            return 0x80030005; //STG_E_ACCESSDENIED; // Seeking past end needs write access.
+        }
+    }
+    
+    
+    HRESULT SetSize(ULARGE_INTEGER libNewSize)
+    {
+        return E_NOTIMPL;
+    }
+    
+    
+    HRESULT CopyTo(IStream pstm, ULARGE_INTEGER cb, ULARGE_INTEGER* pcbRead, ULARGE_INTEGER* pcbWritten)
+    {
+        // TODO: implement.
+        return E_NOTIMPL;
+    }
+    
+    
+    HRESULT Commit(DWORD grfCommitFlags)
+    {
+        return S_OK; // ?
+    }
+    
+    
+    HRESULT Revert()
+    {
+        return E_NOTIMPL; // ? S_FALSE ?
+    }
+    
+    
+    HRESULT LockRegion(ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
+    {
+        return E_NOTIMPL;
+    }
+    
+    
+    HRESULT UnlockRegion(ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
+    {
+        return E_NOTIMPL;
+    }
+    
+    
+    HRESULT Stat(STATSTG* pstatstg, DWORD grfStatFlag)
+    {
+        return E_NOTIMPL; // ?
+    }
+    
+    
+    HRESULT Clone(IStream* ppstm)
+    {
+        // Cloned stream needs its own seek position.
+        return E_NOTIMPL; // ?
+    }
+    
+    
+    extern(D):
+    
+    private:
+    void[] mem;
+    size_t seekpos = 0;
+    
+    
+    bool withinbounds(long pos)
+    {
+        if(pos < seekpos.min || pos > seekpos.max)
+            return false;
+        // Note: it IS within bounds if it's AT the end, it just can't read there.
+        return cast(size_t)pos <= mem.length;
+    }
+}
+

trunk/win32/dfl/makelib.bat

@@ -45 +45 @@
-
-if not "%dfl_debug_flags%" == "" goto dfl_debug_flags_set
-
+   
-:dfl_debug_flags_set
+
-if not "%dfl_release_flags%" == "" goto dfl_release_flags_set
-
-
-
-
-
-
+@rem
+@rem
+@rem
+@rem
+@rem
+   
-:dfl_release_flags_set
-