/// <summary>
/// Refreshes all pending Delete/Update entity objects of current DataContext according to the specified mode.
/// Nothing will do on Pending Insert entity objects.
/// </summary>
/// <param name="context"></param>
/// <param name="refreshMode">A value that specifies how optimistic concurrency conflicts are handled.</param>
public void RefreshPendingChanges(DataContext context, RefreshMode refreshMode)
{
ChangeSet changeSet = context.GetChangeSet();
if (changeSet != null)
{
context.Refresh(refreshMode, changeSet.Deletes);
context.Refresh(refreshMode, changeSet.Updates);
}
}
/// <summary>
///
/// </summary>
/// <param name="aControl"></param>
/// <param name="status"></param>
/// <param name="bRecursion"></param>
/// <param name="mode"></param>
public static void RefreshControl(Control aControl, EditState status, bool bRecursion = true, RefreshMode mode = RefreshMode.Normal)
{
if (aControl == null)
return;
Color colorTrue = Color.White;
Color colorFalse = Color.WhiteSmoke;
//正常的是编辑状态下可用
bool bInEdit = status.In(EditState.Edit, EditState.AddNew);
bool bControlEnabled = mode == RefreshMode.Normal ? bInEdit : !bInEdit;
if (aControl is GridControl)
{
//Grid列按列自身的RefreshMode处理
GridControl grid = aControl as GridControl;
GridView view = grid.MainView as GridView;
switch (mode)
{
//反向Grid，一般用于索引数据，如Index
case RefreshMode.Unnatural: RefreshControl(grid, !bInEdit); break;
//正向Grid，一般用于主数据
case RefreshMode.Normal: RefreshControl(view, bControlEnabled); break;
default: break;
}
}
else if (bRecursion && (aControl is PanelControl || aControl is LayoutControl || aControl is SplitGroupPanel
|| aControl is Form || aControl is XtraTabPage || aControl is XtraTabControl || aControl is BaseUserControl
|| aControl is SplitContainerControl))
{
foreach (Control c in aControl.Controls)
{
RefreshControl(c, status, bRecursion, mode);
}
}
else
RefreshControl(aControl, bControlEnabled, colorTrue, colorFalse);
}
public LinkType()
{
_refreshMode = RefreshMode.OnChange;
_refreshInterval = 4.0;
_viewRefreshMode = ViewRefreshMode.Never;
_viewRefreshTime = 4.0;
_viewBoundScale = 1.0;
}
public NativeWindow(GraphicsMode mode, WindowOptions options)
{
if (options.ScreenMode == ScreenMode.Native)
{
options.Width = DisplayDevice.Default.Width;
options.Height = DisplayDevice.Default.Height;
}
GameWindowFlags windowFlags = GameWindowFlags.Default;
if (options.ScreenMode == ScreenMode.FixedWindow)
windowFlags = GameWindowFlags.FixedWindow;
else if (options.ScreenMode == ScreenMode.Fullscreen || options.ScreenMode == ScreenMode.Native)
windowFlags = GameWindowFlags.Fullscreen;
this.refreshMode = options.RefreshMode;
this.internalWindow = new InternalWindow(
this,
options.Width,
options.Height,
mode,
options.Title,
windowFlags);
this.internalWindow.MakeCurrent();
this.internalWindow.CursorVisible = true;
if (!options.SystemCursorVisible)
this.internalWindow.Cursor = MouseCursor.Empty;
this.internalWindow.VSync = (options.RefreshMode != RefreshMode.VSync) ? VSyncMode.Off : VSyncMode.On;
Log.Core.Write("Window Specification: {0}Mode: {1}{0}VSync: {2}{0}SwapInterval: {3}{0}",
Environment.NewLine,
this.internalWindow.Context.GraphicsMode,
this.internalWindow.VSync,
this.internalWindow.Context.SwapInterval);
// Retrieve icon from executable file and set it as window icon
Assembly entryAssembly = Assembly.GetEntryAssembly();
if (entryAssembly != null)
{
string executablePath = Path.GetFullPath(entryAssembly.Location);
if (File.Exists(executablePath))
{
this.internalWindow.Icon = Icon.ExtractAssociatedIcon(executablePath);
}
}
if (options.ScreenMode == ScreenMode.FullWindow)
this.internalWindow.WindowState = WindowState.Fullscreen;
DualityApp.TargetResolution = new Vector2(this.internalWindow.ClientSize.Width, this.internalWindow.ClientSize.Height);
DualityApp.Mouse.Source = new GameWindowMouseInputSource(this.internalWindow);
DualityApp.Keyboard.Source = new GameWindowKeyboardInputSource(this.internalWindow);
DualityApp.UserDataChanged += this.OnUserDataChanged;
// Determine OpenGL capabilities and log them
GraphicsBackend.LogOpenGLSpecs();
}
public Icon(string href, RefreshMode refreshMode, int refreshInterval, int x, int y, int w, int h)
{
this._href = href;
this._refreshMode = refreshMode;
this._refreshInterval = refreshInterval;
this._x = x;
this._y = y;
this._w = w;
this._h = h;
}
public ScreenOverlay(string name, string snippet, bool visibility, string imgHref,
ScreenXY sxy, OverlayXY oxy, Size size, RefreshMode mode, int refreshInterval)
{
this._name = name;
this._snippet = snippet;
this._visibility = visibility;
this._imgHref = imgHref;
this._sxy = sxy;
this._oxy = oxy;
this._size = size;
this._refreshMode = mode;
this._refreshInterval = refreshInterval;
}
/// <summary>
/// Refresh non-detached entities
/// </summary>
/// <param name="dbContext">context of the entities</param>
/// <param name="refreshMode">store or client wins</param>
/// <param name="entityType">when specified only entities of that type are refreshed. when null all non-detached entities are modified</param>
/// <returns></returns>
public static DbContext RefreshEntites(this DbContext dbContext, RefreshMode refreshMode, Type entityType)
{
//https://christianarg.wordpress.com/2013/06/13/entityframework-refreshall-loaded-entities-from-database/
var objectContext = ((IObjectContextAdapter)dbContext).ObjectContext;
var refreshableObjects = objectContext.ObjectStateManager
.GetObjectStateEntries(EntityState.Added | EntityState.Deleted | EntityState.Modified | EntityState.Unchanged)
.Where(x => entityType == null || x.Entity.GetType() == entityType)
.Where(entry => entry.EntityKey != null)
.Select(e => e.Entity)
.ToArray();
objectContext.Refresh(refreshMode, refreshableObjects);
return(dbContext);
}
/// <summary>
/// Persists to the content database changes made by the current user to one or more lists using the specified failure mode;
/// or, if a concurrency conflict is found, populates the <see cref="P:Microsoft.SharePoint.Linq.DataContext.ChangeConflicts"/> property.
/// </summary>
/// <param name="mode">Specifies how the list item changing system of the LINQ to SharePoint provider will respond when it
/// finds that a list item has been changed by another process since it was retrieved.
/// </param>
public void SubmitChangesSilently(RefreshMode mode)
{
try
{
SubmitChanges();
}
catch (ChangeConflictException)
{
foreach (ObjectChangeConflict changedListItem in this.ChangeConflicts)
{
changedListItem.Resolve(mode);
}
this.SubmitChanges();
}
}
private void handle(PopulationAnalysisEvent eventToHandle, RefreshMode refreshMode)
{
if (!canHandle(eventToHandle))
{
return;
}
if (refreshMode == RefreshMode.RefreshDataAndPlot)
{
ShouldRefreshData = true;
}
else
{
ShouldRefreshChart = true;
}
}
public void Resolve(RefreshMode refreshMode, bool autoResolveDeletes)
{
if (autoResolveDeletes && IsDeleted)
{
ResolveDelete();
}
else
{
if (Database == null)
{
throw System.Data.Linq.Error.RefreshOfDeletedObject();
}
TrackedObject.Refresh(refreshMode, Database);
IsResolved = true;
}
}
private async Task InitScreenAsync(RefreshMode refreshMode)
{
Console.WriteLine("InitScreen begin");
await Reset();
send_command(0x01); // DRIVER_OUTPUT_CONTROL
send_data(EPD_HEIGHT - 1 & 0xFF);
send_data(EPD_HEIGHT - 1 >> 8 & 0xFF);
send_data(0x00); // GD = 0 SM = 0 TB = 0
send_command(0x0C); // BOOSTER_SOFT_START_CONTROL
send_data(0xD7);
send_data(0xD6);
send_data(0x9D);
send_command(0x2C); // WRITE_VCOM_REGISTER
send_data(0xA8); // VCOM 7C
send_command(0x3A); // SET_DUMMY_LINE_PERIOD
send_data(0x1A); // 4 dummy lines per gate
send_command(0x3B); // SET_GATE_TIME
send_data(0x08); // 2us per line
send_command(0X3C); // BORDER_WAVEFORM_CONTROL
send_data(0x03);
send_command(0X11); // DATA_ENTRY_MODE_SETTING
send_data(0x03); // X increment; Y increment
// WRITE_LUT_REGISTER
send_command(0x32);
switch (refreshMode)
{
case RefreshMode.Full: send_data(lut_full_update); break;
case RefreshMode.Partial: send_data(lut_partial_update); break;
default: throw new ArgumentException(nameof(refreshMode));
}
IsInitialized = true;
Console.WriteLine("InitScreen end");
}
get => new MixtureSettings()
{
widthScale = 1.0f,
heightScale = 1.0f,
depthScale = 1.0f,
width = 1024,
height = 1024,
depth = 1,
sizeMode = OutputSizeMode.InheritFromParent,
dimension = OutputDimension.InheritFromParent,
outputChannels = OutputChannel.InheritFromParent,
outputPrecision = OutputPrecision.InheritFromParent,
editFlags = ~EditFlags.POTSize,
doubleBuffered = false,
wrapMode = OutputWrapMode.InheritFromParent,
filterMode = OutputFilterMode.InheritFromParent,
refreshMode = RefreshMode.OnLoad,
};
public async Task InitializeAsync(RefreshMode refreshMode)
{
Console.WriteLine("Initialize begin");
// Configure raspberry pi
Pi.Init <BootstrapWiringPi>();
gpio = Pi.Gpio;
gpio[BUSY_PIN].PinMode = GpioPinDriveMode.Input;
gpio[DC_PIN].PinMode = GpioPinDriveMode.Output;
gpio[RST_PIN].PinMode = GpioPinDriveMode.Output;
gpio[CS_PIN].PinMode = GpioPinDriveMode.Output;
Pi.Spi.Channel0Frequency = 2000000;
spi = Pi.Spi.Channel0;
await InitScreenAsync(refreshMode);
Console.WriteLine("Initialize end");
}
public override XElement ToXElement()
{
XElement xml = base.NewXElement("Link");
if (Href.HasValue())
{
xml.Add(NewXElement("href", Href));
}
if (RefreshMode != KmlLinkRefreshMode.OnChange)
{
xml.Add(NewXElement("refreshMode", RefreshMode.ToCamelCase()));
}
if (RefreshMode == KmlLinkRefreshMode.OnInterval)
{
xml.Add(NewXElement("refreshInterval", RefreshInterval.TotalSeconds));
}
return(xml);
}
/// <summary>
/// Resolve member conflicts using the mode specified and resetting the baseline 'Original' values
/// to match the more recent 'Database' values.
/// </summary>
/// <param name="refreshMode">The mode that determines how the current values are
/// changed in order to resolve the conflict</param>
/// <param name="autoResolveDeletes">If true conflicts resulting from the modified
/// object no longer existing in the database will be automatically resolved.</param>
public void Resolve(RefreshMode refreshMode, bool autoResolveDeletes)
{
if (autoResolveDeletes && this.IsDeleted)
{
this.ResolveDelete();
}
else
{
// We make these calls explicity rather than simply calling
// DataContext.Refresh (which does virtually the same thing)
// since we want to cache the database value read.
if (this.Database == null)
{
throw Error.RefreshOfDeletedObject();
}
trackedObject.Refresh(refreshMode, this.Database);
this.isResolved = true;
}
}
public void RefreshReflectionAt(RefreshMode refresh, Vector3 position)
{
CreateData();
CreateCubemap();
int resolution = GetComponent <ReflectionProbe>().resolution;
RenderPair pair;
if (!targets.TryGetValue(resolution, out pair))
{
refreshing = null;
return;
}
Camera camera = Camera;
camera.transform.position = position;
camera.targetTexture = pair.Render;
SetCameraSettings(camera);
switch (refresh)
{
case RefreshMode.Default:
break;
case RefreshMode.Instant:
RefreshInstant(pair, camera);
break;
case RefreshMode.Face:
refreshing = StartCoroutine(RefreshFace(pair, camera));
break;
case RefreshMode.Overtime:
refreshing = StartCoroutine(RefreshOvertime(pair, camera));
break;
}
camera.gameObject.SetActive(false);
}
public virtual int ApplyChanges(RefreshMode refreshMode)
{
int i = 0;
try
{
i = this.ObjectContext.SaveChanges();
}
catch (OptimisticConcurrencyException ex)
{
foreach (var state in ex.StateEntries)
{
this.ObjectContext.Refresh(refreshMode, state.Entity);
}
i = this.ObjectContext.SaveChanges(false);
}
return(i);
}
public override int GetHashCode()
{
unchecked
{
int hashCode = Enabled.GetHashCode();
hashCode = (hashCode * 397) ^ ResponseKindsToCache.GetHashCode();
hashCode = (hashCode * 397) ^ ResponseKindsToIgnore.GetHashCode();
hashCode = (hashCode * 397) ^ RefreshMode.GetHashCode();
hashCode = (hashCode * 397) ^ RefreshTime.GetHashCode();
hashCode = (hashCode * 397) ^ ExpirationTime.GetHashCode();
hashCode = (hashCode * 397) ^ FailedRefreshDelay.GetHashCode();
hashCode = (hashCode * 397) ^ RequestGroupingBehavior.GetHashCode();
hashCode = (hashCode * 397) ^ RefreshBehavior.GetHashCode();
hashCode = (hashCode * 397) ^ RevokedResponseBehavior.GetHashCode();
hashCode = (hashCode * 397) ^ ExpirationBehavior.GetHashCode();
hashCode = (hashCode * 397) ^ CacheResponsesWhenSupressedBehavior.GetHashCode();
hashCode = (hashCode * 397) ^ NotIgnoredResponseBehavior.GetHashCode();
return(hashCode);
}
}
internal override void Refresh(RefreshMode mode, object freshInstance)
{
SynchDependentData();
UpdateDirtyMemberCache();
var type = freshInstance.GetType();
foreach (var persistentDataMember in this.type.PersistentDataMembers)
{
var refreshMode = persistentDataMember.IsDbGenerated ? RefreshMode.OverwriteCurrentValues : mode;
if (refreshMode != 0 && !persistentDataMember.IsAssociation && (Type.Type == type || persistentDataMember.DeclaringType.Type.IsAssignableFrom(type)))
{
var boxedValue = persistentDataMember.StorageAccessor.GetBoxedValue(freshInstance);
RefreshMember(persistentDataMember, refreshMode, boxedValue);
}
}
original = CreateDataCopy(freshInstance);
if (mode == RefreshMode.OverwriteCurrentValues)
{
ResetDirtyMemberTracking();
}
}
internal override void RefreshMember(MetaDataMember mm, RefreshMode mode, object freshValue)
{
if (mode != 0 && (!HasChangedValue(mm) || mode == RefreshMode.OverwriteCurrentValues))
{
var boxedValue = mm.StorageAccessor.GetBoxedValue(current);
if (!object.Equals(freshValue, boxedValue))
{
mm.StorageAccessor.SetBoxedValue(ref current, freshValue);
foreach (var item in GetAssociationsForKey(mm))
{
if (!item.Association.IsMany)
{
var source = tracker.services.GetDeferredSourceFactory(item).CreateDeferredSource(current);
if (item.StorageAccessor.HasValue(current))
{
AssignMember(current, item, source.Cast <object>().SingleOrDefault());
}
}
}
}
}
}
internal override void Refresh(RefreshMode mode, object freshInstance)
{
SynchDependentData();
UpdateDirtyMemberCache();
Type c = freshInstance.GetType();
foreach (MetaDataMember member in type.PersistentDataMembers)
{
RefreshMode mode2 = member.IsDbGenerated ? RefreshMode.OverwriteCurrentValues : mode;
if (((mode2 != RefreshMode.KeepCurrentValues) && !member.IsAssociation) &&
((Type.Type == c) || member.DeclaringType.Type.IsAssignableFrom(c)))
{
object boxedValue = member.StorageAccessor.GetBoxedValue(freshInstance);
RefreshMember(member, mode2, boxedValue);
}
}
original = CreateDataCopy(freshInstance);
if (mode == RefreshMode.OverwriteCurrentValues)
{
ResetDirtyMemberTracking();
}
}
public RefreshButton([NotNull] string param)
{
Assert.ArgumentNotNull(param, "param");
switch (param.ToLower())
{
case "all":
this.mode = RefreshMode.Everything;
return;
case "sites":
this.mode = RefreshMode.Instances;
return;
case "installer":
this.mode = RefreshMode.Installer;
return;
case "caches":
this.mode = RefreshMode.Caches;
return;
default:
throw new NotSupportedException("The {0} type is not supported".FormatWith(param));
}
}
public int SaveChanges(bool refreshOnConcurrencyException, RefreshMode refreshMode = RefreshMode.KeepChanges)
{
try
{
return(SaveChanges());
}
catch (DbUpdateConcurrencyException ex)
{
foreach (DbEntityEntry entry in ex.Entries)
{
if (refreshMode == RefreshMode.KeepChanges)
{
entry.OriginalValues.SetValues(entry.GetDatabaseValues());
}
else
{
entry.Reload();
}
}
return(SaveChanges());
}
}
internal override void RefreshMember(MetaDataMember mm, RefreshMode mode, object freshValue)
{
System.Diagnostics.Debug.Assert(!mm.IsAssociation);
if (mode == RefreshMode.KeepCurrentValues)
{
return;
}
bool hasUserChange = this.HasChangedValue(mm);
// we don't want to overwrite any modified values, unless
// the mode is original wins
if (hasUserChange && mode != RefreshMode.OverwriteCurrentValues)
{
return;
}
object currentValue = mm.StorageAccessor.GetBoxedValue(this.current);
if (!object.Equals(freshValue, currentValue))
{
mm.StorageAccessor.SetBoxedValue(ref this.current, freshValue);
// update all singleton associations that are affected by a change to this member
foreach (MetaDataMember am in this.GetAssociationsForKey(mm))
{
if (!am.Association.IsMany)
{
IEnumerable ds = this.tracker.services.GetDeferredSourceFactory(am).CreateDeferredSource(this.current);
if (am.StorageAccessor.HasValue(this.current))
{
this.AssignMember(this.current, am, ds.Cast <Object>().SingleOrDefault());
}
}
}
}
}
public void Resolve(RefreshMode mode, object originalListItem, object databaseListItem)
{
SPListItem originalItem = originalListItem as SPListItem;
SPListItem databaseItem = databaseListItem as SPListItem;
if (databaseItem == null || originalItem == null)
{
return;
}
//SPAttachmentCollection originalValue = originalItem["Attachments"] as SPAttachmentCollection;
//SPAttachmentCollection databaseValue = databaseItem["Attachments"] as SPAttachmentCollection;
//switch (mode)
//{
// case RefreshMode.KeepChanges:
// if (_contentAttachments != originalValue)
// {
// databaseItem["Attachments"] = _contentAttachments;
// }
// else if (_contentAttachments == originalValue &&
// _contentAttachments != databaseValue)
// {
// _contentAttachments = databaseValue;
// }
// break;
// case RefreshMode.KeepCurrentValues:
// databaseItem["Attachments"] = _contentAttachments;
// break;
// case RefreshMode.OverwriteCurrentValues:
// _contentAttachments = databaseValue;
// break;
// default:
// break;
//}
}
static public void AutoRefresh(this ObjectContext ctx,
RefreshMode refreshMode, IEnumerable collection)
{
var csInEF = ctx.Connection.ConnectionString;
string csForEF;
if (csInEF.StartsWith("name="))
{ // old EF
var csName = csInEF.Replace("name=", "").Trim();
csForEF =
System.Configuration.ConfigurationManager.ConnectionStrings[csName].ConnectionString;
}
else
csForEF = csInEF;
var newConnectionString = new
System.Data.EntityClient.EntityConnectionStringBuilder(csForEF).ProviderConnectionString;
if (!connectionStrings.Contains(newConnectionString))
{
connectionStrings.Add(newConnectionString);
SqlDependency.Start(newConnectionString);
}
ServiceBrokerUtility.ctx = ctx;
ServiceBrokerUtility.refreshMode = refreshMode;
AutoRefresh(collection);
}
/// <summary> /// Refresh the item by making the value passed in the current /// Database value, and refreshing the current values using the /// mode specified. /// </summary> internal abstract void Refresh(RefreshMode mode, object freshInstance);
/// <summary> /// Refresh the item by making the value passed in the current /// Database value, and refreshing the current values using the /// mode specified. /// </summary> internal abstract void Refresh(RefreshMode mode, object freshInstance);
/// <summary> /// Does the refresh operation for a single member. This method does not /// update the baseline 'original' value. You must call /// Refresh(RefreshMode.KeepCurrentValues, freshInstance) to finish the refresh /// after refreshing individual members. /// </summary> /// <param name="member"></param> /// <param name="mode"></param> /// <param name="freshValue"></param> internal abstract void RefreshMember(MetaDataMember member, RefreshMode mode, object freshValue);
public RefreshButton()
{
this.mode = RefreshMode.Undefined;
}
public void Refresh(RefreshMode clientWins, object articles)
{
this.Refresh(clientWins, articles);
}
public void Refresh(RefreshMode refreshMode, IEnumerable colection)
{
}
/// <summary>
/// Resolve member conflicts using the mode specified and resetting the baseline 'Original' values
/// to match the more recent 'Database' values.
/// </summary>
/// <param name="refreshMode">The mode that determines how the current values are
/// changed in order to resolve the conflict</param>
public void Resolve(RefreshMode refreshMode)
{
this.Resolve(refreshMode, false);
}
public void Refresh(RefreshMode mode, IDataObject dataObject)
{
if (dataObject == null) throw new ArgumentNullException("dataObject");
if (_managedProxies[dataObject.Identity] != dataObject)
{
throw new ArgumentException("Data object is not tracked by this store.", "dataObject");
}
if (mode == RefreshMode.ClientWins)
{
// We just lookup the new version number
UpdateVersionFromSparqlResult(
ExecuteSparql(new SparqlQueryContext(String.Format(GetVersionSparql, dataObject.Identity))),
dataObject);
}
else
{
var managed = _managedProxies[dataObject.Identity];
BindDataObject(managed);
// Reset all updates for the bound object
_addTriples.RemoveAll(t => t.Subject == managed.Identity);
_deletePatterns.RemoveAll(t => t.Subject == managed.Identity);
}
}
public void RefreshReflection(RefreshMode refresh = RefreshMode.Default)
{
RefreshReflectionAt(refresh, transform.position);
}
/// <summary>
/// Updates the current value using the specified strategy.
/// </summary>
public void Resolve(RefreshMode refreshMode) {
this.conflict.TrackedObject.RefreshMember(this.metaMember, refreshMode, this.databaseValue);
this.isResolved = true;
this.conflict.OnMemberResolved();
}
public NativeWindow(GraphicsMode mode, WindowOptions options)
{
if (options.ScreenMode == ScreenMode.Native)
{
options.Width = DisplayDevice.Default.Width;
options.Height = DisplayDevice.Default.Height;
}
GameWindowFlags windowFlags = GameWindowFlags.Default;
if (options.ScreenMode == ScreenMode.FixedWindow)
windowFlags = GameWindowFlags.FixedWindow;
else if (options.ScreenMode == ScreenMode.Fullscreen || options.ScreenMode == ScreenMode.Native)
windowFlags = GameWindowFlags.Fullscreen;
this.refreshMode = options.RefreshMode;
this.internalWindow = new InternalWindow(
this,
options.Width,
options.Height,
mode,
options.Title,
windowFlags);
this.internalWindow.MakeCurrent();
this.internalWindow.CursorVisible = true;
if (!options.SystemCursorVisible)
this.internalWindow.Cursor = MouseCursor.Empty;
this.internalWindow.VSync = (options.RefreshMode != RefreshMode.VSync) ? VSyncMode.Off : VSyncMode.On;
Log.Core.Write(
"Window Specification: " + Environment.NewLine +
"Buffers: {0}" + Environment.NewLine +
"Samples: {1}" + Environment.NewLine +
"ColorFormat: {2}" + Environment.NewLine +
"AccumulatorFormat: {3}" + Environment.NewLine +
"Depth: {4}" + Environment.NewLine +
"Stencil: {5}" + Environment.NewLine +
"VSync: {6}" + Environment.NewLine +
"SwapInterval: {7}",
this.internalWindow.Context.GraphicsMode.Buffers,
this.internalWindow.Context.GraphicsMode.Samples,
this.internalWindow.Context.GraphicsMode.ColorFormat,
this.internalWindow.Context.GraphicsMode.AccumulatorFormat,
this.internalWindow.Context.GraphicsMode.Depth,
this.internalWindow.Context.GraphicsMode.Stencil,
this.internalWindow.VSync,
this.internalWindow.Context.SwapInterval);
// Retrieve icon from executable file and set it as window icon
Assembly entryAssembly = Assembly.GetEntryAssembly();
if (entryAssembly != null)
{
string executablePath = Path.GetFullPath(entryAssembly.Location);
if (File.Exists(executablePath))
{
this.internalWindow.Icon = Icon.ExtractAssociatedIcon(executablePath);
}
}
if (options.ScreenMode == ScreenMode.FullWindow)
this.internalWindow.WindowState = WindowState.Fullscreen;
DualityApp.TargetResolution = new Vector2(this.internalWindow.ClientSize.Width, this.internalWindow.ClientSize.Height);
// Register events and input
this.HookIntoDuality();
// Determine OpenGL capabilities and log them
GraphicsBackend.LogOpenGLSpecs();
}
public NativeWindow(GraphicsMode mode, WindowOptions options)
{
if (options.ScreenMode == ScreenMode.Native && DisplayDevice.Default != null)
{
options.Width = DisplayDevice.Default.Width;
options.Height = DisplayDevice.Default.Height;
}
GameWindowFlags windowFlags = GameWindowFlags.Default;
if (options.ScreenMode == ScreenMode.FixedWindow)
windowFlags = GameWindowFlags.FixedWindow;
else if (options.ScreenMode == ScreenMode.Fullscreen || options.ScreenMode == ScreenMode.Native)
windowFlags = GameWindowFlags.Fullscreen;
this.refreshMode = options.RefreshMode;
this.internalWindow = new InternalWindow(
this,
options.Width,
options.Height,
mode,
options.Title,
windowFlags);
this.internalWindow.MakeCurrent();
this.internalWindow.CursorVisible = true;
if (!options.SystemCursorVisible)
this.internalWindow.Cursor = MouseCursor.Empty;
this.internalWindow.VSync = (options.RefreshMode != RefreshMode.VSync) ? VSyncMode.Off : VSyncMode.On;
Log.Core.Write(
"Window Specification: " + Environment.NewLine +
" Buffers: {0}" + Environment.NewLine +
" Samples: {1}" + Environment.NewLine +
" ColorFormat: {2}" + Environment.NewLine +
" AccumFormat: {3}" + Environment.NewLine +
" Depth: {4}" + Environment.NewLine +
" Stencil: {5}" + Environment.NewLine +
" VSync: {6}" + Environment.NewLine +
" SwapInterval: {7}",
this.internalWindow.Context.GraphicsMode.Buffers,
this.internalWindow.Context.GraphicsMode.Samples,
this.internalWindow.Context.GraphicsMode.ColorFormat,
this.internalWindow.Context.GraphicsMode.AccumulatorFormat,
this.internalWindow.Context.GraphicsMode.Depth,
this.internalWindow.Context.GraphicsMode.Stencil,
this.internalWindow.VSync,
this.internalWindow.Context.SwapInterval);
// Retrieve icon from executable file and set it as window icon
string executablePath = null;
try
{
Assembly entryAssembly = Assembly.GetEntryAssembly();
if (entryAssembly != null)
{
executablePath = Path.GetFullPath(entryAssembly.Location);
if (File.Exists(executablePath))
{
this.internalWindow.Icon = Icon.ExtractAssociatedIcon(executablePath);
}
}
}
// As described in issue 301 (https://github.com/AdamsLair/duality/issues/301), the
// icon extraction can fail with an exception under certain circumstances. Don't fail
// just because of an icon. Log the error and continue.
catch (Exception e)
{
Log.Core.WriteError(
"There was an exception while trying to extract the " +
"window icon from the game's main executable '{0}'. This is " +
"uncritical, but still an error: {1}",
executablePath,
Log.Exception(e));
}
if (options.ScreenMode == ScreenMode.FullWindow)
this.internalWindow.WindowState = WindowState.Fullscreen;
DualityApp.TargetResolution = new Vector2(this.internalWindow.ClientSize.Width, this.internalWindow.ClientSize.Height);
// Register events and input
this.HookIntoDuality();
// Determine OpenGL capabilities and log them
GraphicsBackend.LogOpenGLSpecs();
}
/// <summary>
/// ストレージ オブジェクトをデータ ソース内のデータで更新します。
/// </summary>
/// <param name="refreshMode">更新モードを表す値。</param>
/// <param name="obj">更新するストレージ オブジェクト。</param>
public override void RefreshObject(RefreshMode refreshMode, StorageObject obj)
{
this.Target.RefreshObject(refreshMode, obj);
}
public void Refresh(RefreshMode refreshMode, Entity entity)
{
base.Refresh(refreshMode.Map(), entity);
}
public void Refresh(RefreshMode mode)
{
_objectContext.DetectChanges();
_objectContext.Refresh(mode, _objectContext.EventGolfs);
}
/// <summary>
/// Refresh internal tracking state using the original value and mode
/// specified.
/// </summary>
internal override void Refresh(RefreshMode mode, object freshInstance) {
this.SynchDependentData();
// This must be done prior to updating original values
this.UpdateDirtyMemberCache();
// Apply the refresh strategy to each data member
Type instanceType = freshInstance.GetType();
foreach (MetaDataMember mm in type.PersistentDataMembers) {
var memberMode = mm.IsDbGenerated ? RefreshMode.OverwriteCurrentValues : mode;
if (memberMode != RefreshMode.KeepCurrentValues) {
if (!mm.IsAssociation && (this.Type.Type == instanceType || mm.DeclaringType.Type.IsAssignableFrom(instanceType))) {
object freshValue = mm.StorageAccessor.GetBoxedValue(freshInstance);
this.RefreshMember(mm, memberMode, freshValue);
}
}
}
// Make the new data the current original value
this.original = this.CreateDataCopy(freshInstance);
if (mode == RefreshMode.OverwriteCurrentValues) {
this.ResetDirtyMemberTracking();
}
}
internal override void RefreshMember(MetaDataMember mm, RefreshMode mode, object freshValue) {
System.Diagnostics.Debug.Assert(!mm.IsAssociation);
if (mode == RefreshMode.KeepCurrentValues) {
return;
}
bool hasUserChange = this.HasChangedValue(mm);
// we don't want to overwrite any modified values, unless
// the mode is original wins
if (hasUserChange && mode != RefreshMode.OverwriteCurrentValues)
return;
object currentValue = mm.StorageAccessor.GetBoxedValue(this.current);
if (!object.Equals(freshValue, currentValue)) {
mm.StorageAccessor.SetBoxedValue(ref this.current, freshValue);
// update all singleton associations that are affected by a change to this member
foreach (MetaDataMember am in this.GetAssociationsForKey(mm)) {
if (!am.Association.IsMany) {
IEnumerable ds = this.tracker.services.GetDeferredSourceFactory(am).CreateDeferredSource(this.current);
if (am.StorageAccessor.HasValue(this.current)) {
this.AssignMember(this.current, am, ds.Cast<Object>().SingleOrDefault());
}
}
}
}
}
/// <summary>
/// Resolve member conflicts using the mode specified and resetting the baseline 'Original' values
/// to match the more recent 'Database' values.
/// </summary>
/// <param name="refreshMode">The mode that determines how the current values are
/// changed in order to resolve the conflict</param>
/// <param name="autoResolveDeletes">If true conflicts resulting from the modified
/// object no longer existing in the database will be automatically resolved.</param>
public void Resolve(RefreshMode refreshMode, bool autoResolveDeletes)
{
if(autoResolveDeletes && this.IsDeleted)
{
this.ResolveDelete();
}
else
{
// We make these calls explicity rather than simply calling
// DataContext.Refresh (which does virtually the same thing)
// since we want to cache the database value read.
if(this.Database == null)
{
throw Error.RefreshOfDeletedObject();
}
trackedObject.Refresh(refreshMode, this.Database);
this.isResolved = true;
}
}
public void Refresh(RefreshMode refreshMode, object entity)
{
}
public void Resolve(RefreshMode refreshMode)
{
throw new NotImplementedException();
}
public void Resolve (RefreshMode refreshMode)
{
throw new NotImplementedException ();
}
public void Resolve (RefreshMode refreshMode, bool autoResolveDeletes)
{
throw new NotImplementedException ();
}
/// <summary> /// Does the refresh operation for a single member. This method does not /// update the baseline 'original' value. You must call /// Refresh(RefreshMode.KeepCurrentValues, freshInstance) to finish the refresh /// after refreshing individual members. /// </summary> /// <param name="member"></param> /// <param name="mode"></param> /// <param name="freshValue"></param> internal abstract void RefreshMember(MetaDataMember member, RefreshMode mode, object freshValue);
public void Resolve(RefreshMode mode, object originalListItem, object databaseListItem)
{
SPListItem originalItem = originalListItem as SPListItem;
SPListItem databaseItem = databaseListItem as SPListItem;
if (databaseItem == null || originalItem == null) return;
//SPAttachmentCollection originalValue = originalItem["Attachments"] as SPAttachmentCollection;
//SPAttachmentCollection databaseValue = databaseItem["Attachments"] as SPAttachmentCollection;
//switch (mode)
//{
// case RefreshMode.KeepChanges:
// if (_contentAttachments != originalValue)
// {
// databaseItem["Attachments"] = _contentAttachments;
// }
// else if (_contentAttachments == originalValue &&
// _contentAttachments != databaseValue)
// {
// _contentAttachments = databaseValue;
// }
// break;
// case RefreshMode.KeepCurrentValues:
// databaseItem["Attachments"] = _contentAttachments;
// break;
// case RefreshMode.OverwriteCurrentValues:
// _contentAttachments = databaseValue;
// break;
// default:
// break;
//}
}
public void Refresh(RefreshMode refreshMode, IEnumerable <Entity> collection)
{
base.Refresh(refreshMode.Map(), collection);
}
public void Refresh(DataContext dataContext, RefreshMode mode, object entity) {
dataContext.Refresh(mode, entity);
}
public NativeWindow(GraphicsMode mode, WindowOptions options)
{
if ((options.ScreenMode & (ScreenMode.ChangeResolution | ScreenMode.FullWindow)) != 0)
{
if (DisplayDevice.Default != null)
{
options.Size = new Point2(
DisplayDevice.Default.Width,
DisplayDevice.Default.Height);
}
}
screenMode = options.ScreenMode & (ScreenMode.FullWindow | ScreenMode.FixedSize | ScreenMode.ChangeResolution);
GameWindowFlags windowFlags = GameWindowFlags.Default;
if ((screenMode & ScreenMode.FixedSize) != 0)
{
windowFlags = GameWindowFlags.FixedWindow;
}
else if ((screenMode & ScreenMode.ChangeResolution) != 0)
{
windowFlags = GameWindowFlags.Fullscreen;
}
VSyncMode vsyncMode;
switch (options.RefreshMode)
{
default:
case RefreshMode.NoSync:
case RefreshMode.ManualSync:
vsyncMode = VSyncMode.Off;
break;
case RefreshMode.VSync:
vsyncMode = VSyncMode.On;
break;
case RefreshMode.AdaptiveVSync:
vsyncMode = VSyncMode.Adaptive;
break;
}
this.refreshMode = options.RefreshMode;
this.internalWindow = new InternalWindow(
this,
options.Size.X,
options.Size.Y,
mode,
options.Title,
windowFlags);
this.internalWindow.MakeCurrent();
this.internalWindow.CursorVisible = true;
if (!options.SystemCursorVisible)
{
this.internalWindow.Cursor = MouseCursor.Empty;
}
this.internalWindow.VSync = vsyncMode;
App.Log(
"Window Specification: " + Environment.NewLine +
" Buffers: {0}" + Environment.NewLine +
" Samples: {1}" + Environment.NewLine +
" ColorFormat: {2}" + Environment.NewLine +
" AccumFormat: {3}" + Environment.NewLine +
" Depth: {4}" + Environment.NewLine +
" Stencil: {5}" + Environment.NewLine +
" VSync: {6}" + Environment.NewLine +
" SwapInterval: {7}",
this.internalWindow.Context.GraphicsMode.Buffers,
this.internalWindow.Context.GraphicsMode.Samples,
this.internalWindow.Context.GraphicsMode.ColorFormat,
this.internalWindow.Context.GraphicsMode.AccumulatorFormat,
this.internalWindow.Context.GraphicsMode.Depth,
this.internalWindow.Context.GraphicsMode.Stencil,
this.internalWindow.VSync,
this.internalWindow.Context.SwapInterval);
// Retrieve icon from executable file and set it as window icon
string executablePath = null;
try {
Assembly entryAssembly = Assembly.GetEntryAssembly();
if (entryAssembly != null)
{
executablePath = Path.GetFullPath(entryAssembly.Location);
if (File.Exists(executablePath))
{
this.internalWindow.Icon = Icon.ExtractAssociatedIcon(executablePath);
}
}
}
// As described in issue 301 (https://github.com/AdamsLair/duality/issues/301), the
// icon extraction can fail with an exception under certain circumstances. Don't fail
// just because of an icon. Log the error and continue.
catch (Exception e) {
App.Log(
"There was an exception while trying to extract the " +
"window icon from the game's main executable '{0}'. This is " +
"uncritical, but still an error: {1}",
executablePath,
e);
}
if ((screenMode & ScreenMode.FullWindow) != 0)
{
this.internalWindow.WindowState = WindowState.Fullscreen;
}
DualityApp.WindowSize = new Point2(this.internalWindow.ClientSize.Width,
this.internalWindow.ClientSize.Height);
// Register events and input
this.HookIntoDuality();
// Determine OpenGL capabilities and log them
GraphicsBackend.LogOpenGLSpecs();
}
public RefreshButton()
{
this.mode = RefreshMode.Undefined;
}