public HRESULT SetSize(ULARGE_INTEGER libNewSize) { return(((delegate * unmanaged <IStream *, ULARGE_INTEGER, int>)(lpVtbl[6]))((IStream *)Unsafe.AsPointer(ref this), libNewSize)); }
public int get_UpdateSequenceNumber(ULARGE_INTEGER[] puliUSN) { IVsProjectCfg projCfg = _innerCfg as IVsProjectCfg; if (projCfg != null) { return projCfg.get_UpdateSequenceNumber(puliUSN); } return VSConstants.E_NOTIMPL; }
public override long Seek(long offset, SeekOrigin origin) { var l = new LARGE_INTEGER(); var ul = new ULARGE_INTEGER[1]; ul[0] = new ULARGE_INTEGER(); l.QuadPart = offset; comStream.Seek(l, (uint)origin, ul); return (long)ul[0].QuadPart; }
void IStream.CopyTo(IStream pstm, ULARGE_INTEGER cb, ULARGE_INTEGER[] pcbRead, ULARGE_INTEGER[] pcbWritten) { throw new NotImplementedException(); }
void IStream.SetSize(ULARGE_INTEGER libNewSize) { throw new NotImplementedException(); }
public override void SetLength(long value) { ULARGE_INTEGER ularge_integer1 = new ULARGE_INTEGER(); ularge_integer1.QuadPart = (ulong) value; this.comStream.SetSize(ularge_integer1); }
/// <summary> /// Sets the length of the stream. /// </summary> /// <param name="value">The new lenght.</param> public override void SetLength(long value) { ULARGE_INTEGER ul = new ULARGE_INTEGER(); ul.QuadPart = (ulong)value; comStream.SetSize(ul); }
/// <summary> /// When overridden in a derived class, sets the length of the current stream. /// </summary> /// <param name="value">The desired length of the current stream in bytes.</param> /// <exception cref="T:System.IO.IOException">An I/O error occurs. </exception> /// <exception cref="T:System.NotSupportedException">The stream does not support both writing and seeking, such as if the stream is constructed from a pipe or console output. </exception> /// <exception cref="T:System.ObjectDisposedException">Methods were called after the stream was closed. </exception> public override void SetLength(long value) { if (_disposed) throw new ObjectDisposedException("ComStreamWrapper"); else if (!CanWrite) throw new InvalidOperationException(); ULARGE_INTEGER ul = new ULARGE_INTEGER(); ul.QuadPart = (ulong)value; _comStream.SetSize(ul); }
public void TestOpenCloseControlled() { const string strProviderName = "Sample Source Control Provider:{B0BAC05D-2000-41D1-A6C3-704E6C1A3DE2}"; const string strSolutionPersistanceKey = "SampleSourceControlProviderSolutionProperties"; const string strSolutionUserOptionsKey = "SampleSourceControlProvider"; int result = 0; // Create a solution SccProviderService target = GetSccProviderServiceInstance; solution.SolutionFile = Path.GetTempFileName(); MockIVsProject project = new MockIVsProject(Path.GetTempFileName()); solution.AddProject(project); // Check solution props VSQUERYSAVESLNPROPS[] saveSolnProps = new VSQUERYSAVESLNPROPS[1]; result = sccProvider.QuerySaveSolutionProps(null, saveSolnProps); Assert.AreEqual(VSConstants.S_OK, result); Assert.AreEqual<VSQUERYSAVESLNPROPS>(VSQUERYSAVESLNPROPS.QSP_HasNoProps, saveSolnProps[0]); // Add the solution to source control. Hashtable uncontrolled = new Hashtable(); uncontrolled[project as IVsSccProject2] = true; target.AddProjectsToSourceControl(ref uncontrolled, true); // Solution should be dirty now result = sccProvider.QuerySaveSolutionProps(null, saveSolnProps); Assert.AreEqual(VSConstants.S_OK, result); Assert.AreEqual<VSQUERYSAVESLNPROPS>(VSQUERYSAVESLNPROPS.QSP_HasDirtyProps, saveSolnProps[0]); // Set the project offline so we'll have something to save in the "suo" stream target.ToggleOfflineStatus(project); // Force the provider to write the solution info into a stream IStream pOptionsStream = new ComStreamFromDataStream(new MemoryStream()) as IStream; sccProvider.WriteUserOptions(pOptionsStream, strSolutionUserOptionsKey); // Move the stream position to the beginning LARGE_INTEGER liOffset; liOffset.QuadPart = 0; ULARGE_INTEGER[] ulPosition = new ULARGE_INTEGER[1]; pOptionsStream.Seek(liOffset, 0, ulPosition); // Write solution props BaseMock propertyBag = MockPropertyBagProvider.GetWritePropertyBag(); sccProvider.WriteSolutionProps(null, strSolutionPersistanceKey, propertyBag as IPropertyBag); // Close the solution to clean up the scc status int pfCancel = 0; target.OnQueryCloseProject(project, 0, ref pfCancel); target.OnQueryCloseSolution(null, ref pfCancel); Assert.AreEqual(pfCancel, 0, "Solution close was canceled"); target.OnBeforeCloseProject(project, 0); // Theoretically the project should have called this, but especially after an add to scc, some projects forget to call it // target.UnregisterSccProject(project); target.OnBeforeCloseSolution(null); target.OnAfterCloseSolution(null); // Now attempt the "reopen" // The solution reads the solution properties propertyBag = MockPropertyBagProvider.GetReadPropertyBag(); sccProvider.ReadSolutionProps(null, null, null, strSolutionPersistanceKey, 1, propertyBag as IPropertyBag); // The solution reads the user options from the stream where they were written before sccProvider.ReadUserOptions(pOptionsStream, strSolutionUserOptionsKey); // Then the projects are opened and register with the provider target.RegisterSccProject(project, "Project's location", "AuxPath", Path.GetDirectoryName(project.ProjectFile), strProviderName); // solution event fired for this project target.OnAfterOpenProject(project, 0); // Then solution completes opening target.OnAfterOpenSolution(null, 0); Assert.IsTrue(target.IsProjectControlled(null), "The solution's controlled status was not correctly persisted or read from property bag"); Assert.IsTrue(target.IsProjectControlled(project), "The project's controlled status was not correctly set"); Assert.IsTrue(target.IsProjectOffline(project), "The project's offline status was incorrectly persisted or read from suo stream"); }
public HRESULT UnlockRegion(ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, [NativeTypeName("DWORD")] uint dwLockType) { return(((delegate * unmanaged <IStreamInterleave *, ULARGE_INTEGER, ULARGE_INTEGER, uint, int>)(lpVtbl[11]))((IStreamInterleave *)Unsafe.AsPointer(ref this), libOffset, cb, dwLockType)); }
/// <summary> /// When overridden in a derived class, sets the position within the current stream. /// </summary> /// <param name="offset">A byte offset relative to the <paramref name="origin"/> parameter.</param> /// <param name="origin">A value of type <see cref="T:System.IO.SeekOrigin"/> indicating the reference point used to obtain the new position.</param> /// <returns> /// The new position within the current stream. /// </returns> /// <exception cref="T:System.IO.IOException">An I/O error occurs. </exception> /// <exception cref="T:System.NotSupportedException">The stream does not support seeking, such as if the stream is constructed from a pipe or console output. </exception> /// <exception cref="T:System.ObjectDisposedException">Methods were called after the stream was closed. </exception> public override long Seek(long offset, SeekOrigin origin) { if (_disposed) throw new ObjectDisposedException("ComStreamWrapper"); LARGE_INTEGER l = new LARGE_INTEGER(); ULARGE_INTEGER[] ul = new ULARGE_INTEGER[1]; ul[0] = new ULARGE_INTEGER(); l.QuadPart = offset; _comStream.Seek(l, (uint)origin, ul); return (long)ul[0].QuadPart; }
public virtual void get_UpdateSequenceNumber(ULARGE_INTEGER[] li){ CCITracing.TraceCall(); li[0] = new ULARGE_INTEGER(); li[0].QuadPart = 0; }
int IVsProjectCfg.get_UpdateSequenceNumber(ULARGE_INTEGER[] puliUSN) { // The documentation says this is obsolete, so don't do anything. if (puliUSN != null) { puliUSN[0] = new ULARGE_INTEGER(); puliUSN[0].QuadPart = 0; } return NativeMethods.E_NOTIMPL; }
public HRESULT CopyTo(IStream *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten) { return(((delegate * unmanaged <IStream *, IStream *, ULARGE_INTEGER, ULARGE_INTEGER *, ULARGE_INTEGER *, int>)(lpVtbl[7]))((IStream *)Unsafe.AsPointer(ref this), pstm, cb, pcbRead, pcbWritten)); }
public virtual void CopyTo(IStream pstm, ULARGE_INTEGER cb, ULARGE_INTEGER[] pcbRead, ULARGE_INTEGER[] pcbWritten) { long[] pcblRead = new long[1]; pcbWritten[0].QuadPart = (ulong)CopyTo(pstm, (long)cb.QuadPart, pcblRead); pcbRead[0].QuadPart = (ulong)pcblRead[0]; }
public override long Seek(long offset, SeekOrigin origin) { LARGE_INTEGER li = new LARGE_INTEGER(); ULARGE_INTEGER[] ul = new ULARGE_INTEGER[1]; ul[0] = new ULARGE_INTEGER(); li.QuadPart = offset; _comStream.Seek(li, (uint)origin, ul); return (long)ul[0].QuadPart; }
public override long Seek(long offset, SeekOrigin origin) { LARGE_INTEGER large_integer1 = new LARGE_INTEGER(); ULARGE_INTEGER[] ularge_integerArray1 = new ULARGE_INTEGER[] { new ULARGE_INTEGER() }; large_integer1.QuadPart = offset; this.comStream.Seek(large_integer1, (uint) origin, ularge_integerArray1); return (long) ularge_integerArray1[0].QuadPart; }
private static byte[] GetBufferFromIStream(IStream comStream) { LARGE_INTEGER zeroPos; zeroPos.QuadPart = 0; ULARGE_INTEGER[] streamPosition = new ULARGE_INTEGER[1]; comStream.Seek(zeroPos, (uint)STREAM_SEEK.STREAM_SEEK_CUR, streamPosition); comStream.Seek(zeroPos, (uint)STREAM_SEEK.STREAM_SEEK_SET, null); Microsoft.VisualStudio.OLE.Interop.STATSTG[] stat = new Microsoft.VisualStudio.OLE.Interop.STATSTG[1]; comStream.Stat(stat, (uint)STATFLAG.STATFLAG_NONAME); int bufferLength = (int)stat[0].cbSize.QuadPart; byte[] buffer = new byte[bufferLength]; uint bytesRead = 0; comStream.Read(buffer, (uint)buffer.Length, out bytesRead); // return the stream to its previous location LARGE_INTEGER newPos; newPos.QuadPart = (long)streamPosition[0].QuadPart; comStream.Seek(newPos, (uint)STREAM_SEEK.STREAM_SEEK_SET, null); return buffer; }
public virtual int get_UpdateSequenceNumber(ULARGE_INTEGER[] li) { if (li == null) { throw new ArgumentNullException("li"); } CCITracing.TraceCall(); li[0] = new ULARGE_INTEGER(); li[0].QuadPart = 0; return VSConstants.S_OK; }
int IVsProjectCfg.get_UpdateSequenceNumber(ULARGE_INTEGER[] puliUSN) { throw new NotImplementedException(); }
public virtual int get_UpdateSequenceNumber(ULARGE_INTEGER[] li) { Utilities.ArgumentNotNull("li", li); li[0] = new ULARGE_INTEGER(); li[0].QuadPart = 0; return VSConstants.S_OK; }
private IStream SaveDocumentWindowPositions(IVsUIShellDocumentWindowMgr windowsMgr) { if (windowsMgr == null) { Debug.Assert(false, "IVsUIShellDocumentWindowMgr", String.Empty, 0); return null; } IStream stream; NativeMethods.CreateStreamOnHGlobal(IntPtr.Zero, true, out stream); if (stream == null) { Debug.Assert(false, "CreateStreamOnHGlobal", String.Empty, 0); return null; } int hr = windowsMgr.SaveDocumentWindowPositions(0, stream); if (hr != VSConstants.S_OK) { Debug.Assert(false, "SaveDocumentWindowPositions", String.Empty, hr); return null; } // Move to the beginning of the stream // In preparation for reading LARGE_INTEGER l = new LARGE_INTEGER(); ULARGE_INTEGER[] ul = new ULARGE_INTEGER[1]; ul[0] = new ULARGE_INTEGER(); l.QuadPart = 0; //Seek to the beginning of the stream stream.Seek(l, 0, ul); return stream; }
void IStream.Seek(LARGE_INTEGER dlibMove, uint dwOrigin, ULARGE_INTEGER[] plibNewPosition) { var pos = base.Seek(dlibMove.QuadPart, (SeekOrigin)dwOrigin); plibNewPosition[0].QuadPart = (ulong)pos; }
public virtual void Seek(LARGE_INTEGER offset, uint origin, ULARGE_INTEGER[] newPosition) { newPosition[0].QuadPart = (ulong)Seek((long)offset.QuadPart, (int)origin); }
void IStream.UnlockRegion(ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, uint dwLockType) { throw new NotImplementedException(); }
public virtual void SetSize(ULARGE_INTEGER value) { dataStream.SetLength((long)value.QuadPart); }
public override void SetLength(long value) { var ul = new ULARGE_INTEGER { QuadPart = ((ulong)value) }; comStream.SetSize(ul); }
public virtual void UnlockRegion(ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, uint dwLockType) { }
public virtual int get_UpdateSequenceNumber(ULARGE_INTEGER[] li) { CCITracing.TraceCall(); li[0] = new ULARGE_INTEGER(); li[0].QuadPart = 0; return VSConstants.S_OK; }
private const int FAILURE = 1; /* for return value from main() */ /*--------------------------------------------------------------------------- * main (args.Length, args) * * The main program. Takes the command line arguments, copies the source file * to the destination file. * * Parameters * args.Length * Count of command-line arguments, including the name of the program. * args * Array of pointers to strings that contain individual command-line * arguments. * * Returns * Zero if program executed successfully, non-zero otherwise. * ---------------------------------------------------------------------------*/ private static int Main(string[] args) { var fResult = FAILURE; ulong liBytesRemaining; ULARGE_INTEGER liSrcFileSize = default, liMapSize, liOffset;