public void LoadXML(string url, LoadHandler completeHandler, XMLResolverHandler resolverHandler)
{
LoadHelper loadHelper = new LoadHelper(url, completeHandler, this.ErrorHandler, this.ProgressHandler, resolverHandler);
IDownloader downloader = FactoryDownloader.GetDownloader(loadHelper);
downloader.StartDown(loadHelper);
}
public static void LoadTexture(string namePath)
{
if (!TextureDict.ContainsKey(namePath))
{
TextureDict.Add(namePath, LoadHandler.LoadTexture(namePath));
}
}
/// <summary>
///
/// </summary>
public MarkdownViewerOptions(ref MarkdownViewerConfiguration configuration)
{
//
this.configuration = configuration;
//
InitializeComponent();
//Iterate over all menu items and register their classes
string thisNamespace = typeof(MarkdownViewerOptions).Namespace;
foreach (TreeNode node in this.treeOptions.Nodes)
{
AbstractOptionsPanel optionsPanel = (AbstractOptionsPanel)Activator.CreateInstance(Type.GetType(thisNamespace + "." + node.Tag.ToString()));
this.SaveEvent += optionsPanel.SaveOptions;
this.LoadEvent += optionsPanel.LoadOptions;
//Add to map to store for changes
this.optionPanels.Add(node.Tag.ToString(), optionsPanel);
}
//
this.treeOptions.AfterSelect += treeOptions_AfterSelect;
//Start with the general options panel
this.splitOptions.Panel2.Controls.Add(this.optionPanels.First().Value);
this.treeOptions.Select();
//Set the according dialog result to their respective buttons
this.btnOptionsCancel.DialogResult = DialogResult.Cancel;
this.btnOptionsSave.DialogResult = DialogResult.OK;
//
this.LoadEvent(this.configuration.options);
}
public void Startup()
{
string AppdataPath = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles);
if (!Directory.Exists(AppdataPath + "\\FactuurX"))
{
Directory.CreateDirectory(AppdataPath + "\\FactuurX");
}
//if we dont have a settings file create one
if (!File.Exists(AppdataPath + "\\FactuurX\\settings.FACTXS"))
{
Settings settings = new Settings();
XmlSerializer ser = new XmlSerializer(typeof(Settings));
TextWriter textWriter = new StreamWriter(AppdataPath + "\\FactuurX\\settings.FACTXS");
ser.Serialize(textWriter, settings);
textWriter.Close();
}
LoadHandler loadHandler = new LoadHandler();
loadHandler.LoadSettings();
if (Form1.settings.LastProfilePath != null)
{
if (Form1.settings.LastProfilePath != "")
{
loadHandler.LoadProfile(Form1.settings.LastProfilePath);
}
}
}
IEnumerator LoadAdditiveAsync(string sceneName, LoadHandler loadHandler, int depth)
{
if (levelBundles != null && levelBundles.Count > 0)
{
foreach (AssetBundle bundle in levelBundles)
{
if (bundle.Contains(sceneName))
{
Debug.Log(bundle.name + " bundle contains scene: " + sceneName);
GetComponent <LoadScenes>().LoadLevelAsync(sceneName, true);
yield return(null);
break;
}
}
AsyncOperation asyncOp = SceneManager.LoadSceneAsync(sceneName, LoadSceneMode.Additive);
onLoading.Invoke(sceneName, asyncOp);
yield return(asyncOp);
FinishLoad(sceneName, loadHandler, depth);
}
else
{
AsyncOperation asyncOp = SceneManager.LoadSceneAsync(sceneName, LoadSceneMode.Additive);
onLoading.Invoke(sceneName, asyncOp);
yield return(asyncOp);
FinishLoad(sceneName, loadHandler, depth);
}
}
public void OnPointerUp(PointerEventData eventData)
{
if (eventData.dragging)
{
return;
}
selected = !selected;
if (selected)
{
ColorBlock cb = btn.colors;
cb.selectedColor = newColor;
cb.highlightedColor = newColor;
cb.pressedColor = newColor;
cb.disabledColor = newColor;
cb.normalColor = newColor;
btn.colors = cb;
LoadHandler.AddItem(gameObject.GetComponent <CreateItemButton>().ItemNameAndType);
}
else
{
ColorBlock cb = btn.colors;
cb.normalColor = Color.white;
cb.highlightedColor = Color.white;
cb.selectedColor = Color.white;
cb.selectedColor = Color.white;
cb.pressedColor = Color.white;
cb.disabledColor = Color.white;
btn.colors = cb;
LoadHandler.RemoveItem(gameObject.GetComponent <Image>().sprite.name);
}
}
/// <summary>
/// 加载Json文件
/// </summary>
/// <param name="url"></param>
/// <param name="completeHandler"></param>
public void LoadRes(string url, LoadHandler completeHandler)
{
string json = IOHelper.OpenText(Const.GetLocalFileUrl(url));
if (null != completeHandler)
{
completeHandler(new LoadedData(json, url, url));
}
}
public SqlPersistenceProviderFactory(string connectionString, bool serializeAsText, TimeSpan lockTimeout)
{
this.ConnectionString = connectionString;
this.LockTimeout = lockTimeout;
this.SerializeAsText = serializeAsText;
this.loadHandler = new LoadHandler(this);
this.createHandler = new CreateHandler(this);
this.updateHandler = new UpdateHandler(this);
this.unlockHandler = new UnlockHandler(this);
this.deleteHandler = new DeleteHandler(this);
}
public LoadHelper(string url, LoadHandler completeHandler, LoadHandler errorHandler, LoadHandler progressHandler, XMLResolverHandler resolverHandler = null)
{
this.CompleteHandler = completeHandler;
this.ErrorHandler = errorHandler;
this.ProgressHandler = progressHandler;
this.OriginalUrl = url;
this.ExtensionName = Path.GetExtension(url);
this._url = this.ConvertUrl(url, ExtensionName);
this.IsPublicRes = this.FileName.Contains("_public");
this.XMLResolver = resolverHandler;
}
void FinishLoad(string sceneName, LoadHandler loadHandler, int depth)
{
GameObject scene = GameObject.Find(sceneName);
loadingScenes.Remove(sceneName);
loadedScenes.Add(sceneName);
onLoaded.Invoke(sceneName);
if (loadHandler != null)
{
loadHandler(sceneName, depth);
}
}
public void LoadRes(string url, LoadHandler completeHandler, LoadHandler errorHandler, LoadHandler progressHandler)
{
LoadHelper loadHelper = new LoadHelper(url, completeHandler, errorHandler, progressHandler);
if (loadHelper.ExtensionName == ".xml" && loadHelper.XMLResolver == null)
{
Debug.LogError("加载xml文件 请使用 LoadXML方法");
}
IDownloader downloader = FactoryDownloader.GetDownloader(loadHelper);
downloader.StartDown(loadHelper);
}
// loads scene with callback
void Load(string sceneName, LoadHandler loadHandler, int depth)
{
if (IsLoaded(sceneName))
{
if (loadHandler != null)
{
loadHandler(sceneName, depth);
}
return;
}
loadingScenes.Add(sceneName);
StartCoroutine(LoadAdditiveAsync(sceneName, loadHandler, depth));
}
internal ISerializableObject Load(Type type, string table, IRestriction restriction, ISerializerTransaction transaction)
{
bool found = false;
bool multiple = false;
bool isLoaded = false;
DbDataReader reader = CreateDataReader(type, table, restriction, transaction);
ISerializableObject data = null;
if (reader.Read())
{
data = _objectPool.RetrieveObject(type, reader, ref isLoaded);
found = true;
}
if (reader.Read())
{
multiple = true;
}
reader.Close();
if (multiple)
{
throw new MultipleResultException("More than one Result found for the given Restriction ...");
}
if (data == null)
{
return(null);
}
bool doRelationLoading = found && isLoaded;
if (doRelationLoading)
{
ResolverData <ISerializableObject> rData = new ResolverData <ISerializableObject>();
rData.HandledItem = data;
rData.FieldsToResolve = AttributeWorker.RetrieveAllFields(data.GetType());
LoadHandler handler = new LoadHandler(this);
RelationResolver <ISerializableObject> res = new RelationResolver <ISerializableObject>();
res.Handler = handler;
res.StartRelationResolving(rData);
}
return(data);
}
internal T Load <T>(IRestriction restriction, int readerPosition, ISerializerTransaction transaction) where T : ISerializableObject
{
if (readerPosition < 0)
{
throw new ArgumentOutOfRangeException("The passed reader position is less than 0.");
}
bool found = false;
bool isLoaded = false;
DbDataReader reader = CreateDataReader(typeof(T), restriction, transaction);
T data = default(T);
for (int i = 0; i <= readerPosition; i++)
{
if (!reader.Read())
{
reader.Close();
throw new ArgumentOutOfRangeException("The passed reader position is too big.");
}
}
data = (T)_objectPool.RetrieveObject(typeof(T), reader, ref isLoaded);
found = true;
reader.Close();
if (data == null)
{
return(default(T));
}
bool doRelationLoading = found && isLoaded;
if (doRelationLoading)
{
ResolverData <ISerializableObject> rData = new ResolverData <ISerializableObject>();
rData.HandledItem = data;
rData.FieldsToResolve = AttributeWorker.RetrieveAllFields(data.GetType());
LoadHandler handler = new LoadHandler(this);
RelationResolver <ISerializableObject> res = new RelationResolver <ISerializableObject>();
res.Handler = handler;
res.StartRelationResolving(rData);
}
return(data);
}
private void AddLoader <T>(DataType dataType, string filename, int keyIdx = 0, bool isXML = false)
{
LoadHandler handle = new LoadHandler();
handle.dataType = dataType;
handle.path = filename;
handle.type = typeof(T);
handle.isXML = isXML;
handle.keyIdx = keyIdx;
mLoadHandles.Add(filename, handle);
DataChecker.GetInstance().Append(dataType, filename);
ResourceManager.Instance.LoadBytes(filename, OnLoadTextCallback);
}
public void OnReset()
{
index = 0;
storeCount = 0;
#if UNITY_EDITOR
allList.Clear();
getCount = 0;
freeCount = 0;
#endif
freeList.Clear();
usingList.Clear();
loadHandler = null;
obj = null;
}
private static void LoadWithElementFlags(Hashtable flags, LoadHandler loader)
{
var oldFlags = HtmlNode.ElementsFlags;
try
{
if (flags != null)
HtmlNode.ElementsFlags = flags;
loader();
}
finally
{
HtmlNode.ElementsFlags = oldFlags;
}
}
private static void LoadWithElementFlags(Hashtable flags, LoadHandler loader)
{
var oldFlags = HtmlNode.ElementsFlags;
try
{
if (flags != null)
{
HtmlNode.ElementsFlags = flags;
}
loader();
}
finally
{
HtmlNode.ElementsFlags = oldFlags;
}
}
private void Awake()
{
//Check if there is already an instance of PanelHolder
if (instance == null)
{
//if not, set it to this.
instance = this;
}
//If instance already exists:
else if (instance != this)
{
//Destroy this, this enforces our singleton pattern so there can only be one instance of PanelHolder.
Destroy(gameObject);
}
DontDestroyOnLoad(gameObject);
}
/// <summary>
/// 加载Json文件
/// </summary>
/// <param name="url"></param>
/// <param name="completeHandler"></param>
public void LoadRes(string url, LoadHandler completeHandler)
{
string result = string.Empty;
url = Const.GetLocalFileUrl(url);
if (!File.Exists(url))
{
return;
}
using (StreamReader sr = new StreamReader(url, Encoding.UTF8))
{
result = sr.ReadToEnd();
}
if (null != completeHandler)
{
completeHandler(new LoadedData(result, url, url));
}
}
public ClientServiceProtocol(String name,
String path,
LoadHandler loadHandler,
SaveHandler saveHandler,
SaveAsHandler saveAsHandler,
Graphic graphic,
Model model,
ChangePermissionsHandler clientChangePermissions,
GetPropertyValuesHandler getPropertyValuesHandler,
GetSubTagsHandler getSubTagsHandler,
ChangeHandler changeHandler,
RequestPortInfoHandler requestPortInfoHandler,
PropertyListHandler propertyListHandler,
LogMessageHandler logMessageHandler,
AnnounceHandler announceHandler,
RenounceHandler renounceHandler)
{
this.Name = name;
this.Path = path;
this.graphic = graphic;
this.model = model;
this.loadHandler = loadHandler;
this.saveHandler = saveHandler;
this.saveAsHandler = saveAsHandler;
this.clientChangePermissions = clientChangePermissions;
this.getPropertyValuesHandler = getPropertyValuesHandler;
this.getSubTagsHandler = getSubTagsHandler;
this.changeHandler = changeHandler;
this.requestPortInfoHandler = requestPortInfoHandler;
this.propertyListHandler = propertyListHandler;
this.logMessageHandler = logMessageHandler;
this.announceHandler = announceHandler;
this.renounceHandler = renounceHandler;
}
public ClientServiceProtocol(String name,
String path,
LoadHandler loadHandler,
SaveHandler saveHandler,
SaveAsHandler saveAsHandler,
Graphic graphic,
Model model,
ChangePermissionsHandler clientChangePermissions,
GetPropertyValuesHandler getPropertyValuesHandler,
GetSubTagsHandler getSubTagsHandler,
ChangeHandler changeHandler,
RequestPortInfoHandler requestPortInfoHandler,
PropertyListHandler propertyListHandler,
LogMessageHandler logMessageHandler,
AnnounceHandler announceHandler,
RenounceHandler renounceHandler)
{
this.Name = name;
this.Path = path;
this.graphic = graphic;
this.model = model;
this.loadHandler = loadHandler;
this.saveHandler = saveHandler;
this.saveAsHandler = saveAsHandler;
this.clientChangePermissions = clientChangePermissions;
this.getPropertyValuesHandler = getPropertyValuesHandler;
this.getSubTagsHandler = getSubTagsHandler;
this.changeHandler = changeHandler;
this.requestPortInfoHandler = requestPortInfoHandler;
this.propertyListHandler = propertyListHandler;
this.logMessageHandler = logMessageHandler;
this.announceHandler = announceHandler;
this.renounceHandler = renounceHandler;
}
internal void Save(ISerializableObject iso, ISerializerTransaction transaction)
{
AttributeWorker w = AttributeWorker.GetInstance(Target);
if (!IsManaged(iso))
{
// Console.WriteLine("SERIALIZE");
_objectPool.InsertObject(iso, _connection, transaction);
ResolverData <ISerializableObject> rData = new ResolverData <ISerializableObject>();
rData.HandledItem = iso;
rData.FieldsToResolve = AttributeWorker.RetrieveAllFields(iso.GetType());
LoadHandler handler = new LoadHandler(this);
RelationResolver <ISerializableObject> res = new RelationResolver <ISerializableObject>();
res.Handler = handler;
res.StartRelationResolving(rData);
}
else
{
// Console.WriteLine("UPDATE");
UpdateStates state = _objectPool.UpdateObject(iso, _connection, transaction);
if (state == UpdateStates.NO_ROWS_AFFECTED)
{
throw new SerializerException("entry could not be updated ...");
}
else if (state == UpdateStates.PRIMARYKEY_MODIFIED)
{
UpdateEventArgs args = new UpdateEventArgs(state);
OnUpdateEvent(args);
}
ResolverData <ISerializableObject> data = new ResolverData <ISerializableObject>();
data.HandledItem = iso;
data.FieldsToResolve = AttributeWorker.RetrieveAllFields(iso.GetType());
RelationResolver <ISerializableObject> res = new RelationResolver <ISerializableObject>();
res.Handler = new UpdateHandler(this);
res.StartRelationResolving(data);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Client"/> class.
/// </summary>
public Client()
: base()
{
LifeSpanHandler = new LifeSpanHandler();
DisplayHandler = new DisplayHandler();
LoadHandler = new LoadHandler();
RequestHandler = new RequestHandler();
KeyboardHandler = new KeyboardHandler();
// set events
LifeSpanHandler.BrowserCreated += (sender, e) => {
if (BrowserCreated != null)
{
BrowserCreated(this, e);
}
};
// native calls
V8NativeBrowserHandler = new V8NativeBrowserHandler(NativeFunctionAttribute.GetMethods <Client, Func <string, object> >(this));
}
/// <summary>
/// Initializes a new instance of the <see cref="Client"/> class.
/// </summary>
public Client()
: base()
{
LifeSpanHandler = new LifeSpanHandler();
DisplayHandler = new DisplayHandler();
LoadHandler = new LoadHandler();
RequestHandler = new RequestHandler();
KeyboardHandler = new KeyboardHandler();
// set events
LifeSpanHandler.BrowserCreated += (sender, e) =>
{
if (BrowserCreated != null)
{
BrowserCreated(this, e);
}
};
// native calls
NativeMessageHandler = new NativeMessageHandler();
}
public ClientHandler(BrowserDelegate browserDelegate)
: base(typeof (CefClient))
{
_delegate = browserDelegate;
_displayHandler = new DisplayHandler(browserDelegate);
_getDisplayHandlerCallback = OnGetDisplayHandler;
_lifeSpanHandler = new LifeSpanHandler(browserDelegate);
_getLifeSpanHandlerCallback = OnGetLifeSpanHandler;
_loadHandler = new LoadHandler(browserDelegate);
_getLoadHandlerCallback = OnGetLoadHandler;
_geolocationHandler = new GeolocationHandler(browserDelegate);
_getGeolocationHandlerCallback = OnGetGeolocationHandler;
_javaScriptDialogHandler = new JavaScriptDialogHandler(browserDelegate);
_getJavaScriptdialogHandler = OnGetJavaScriptHandler;
_contextMenuHandler = new ContextMenuHandler(browserDelegate);
_getContextMenuHandler = OnGetContextMenuHandler;
_processMessageReceivedCallback = OnProcessMessageReceived;
MarshalToNative(new CefClient {
Base = DedicatedBase,
GetDisplayHandler =
Marshal.GetFunctionPointerForDelegate(_getDisplayHandlerCallback),
GetLifeSpanHandler =
Marshal.GetFunctionPointerForDelegate(_getLifeSpanHandlerCallback),
GetLoadHandler =
Marshal.GetFunctionPointerForDelegate(_getLoadHandlerCallback),
GetGeolocationHandler =
Marshal.GetFunctionPointerForDelegate(_getGeolocationHandlerCallback),
OnProcessMessageReceived =
Marshal.GetFunctionPointerForDelegate(_processMessageReceivedCallback),
GetJsdialogHandler =
Marshal.GetFunctionPointerForDelegate(_getJavaScriptdialogHandler),
GetContextMenuHandler =
Marshal.GetFunctionPointerForDelegate(_getContextMenuHandler)
});
}
public static IEnumerator LoadAssets(bool simple, LoadHandler onProgress = null, LoadHandler onComplete = null)
{
var watcher = TimeWatcher.Watch("AssetManager.LoadAssets");
m_downloadAssetHashMap = HashListFile.ParseAssetHashListFile(hashFileName);
var main = LoadManifest();
yield return(main);
watcher.See("LoadManifest");
if (main != null)
{
m_manifest = main.GetAsset <AssetBundleManifest>();
}
var assets = simple ? m_preloadAssets : m_baseAssets;
int i = 1, count = assets.Length + 1;
foreach (var asset in assets)
{
var op = LoadAssetAsync(asset, typeof(Object));
onProgress?.Invoke(asset, 0, count, ++i);
yield return(op);
watcher.See("Load {0}", asset);
}
onComplete?.Invoke("", 1.0f, count, count);
watcher.See("Load Assets");
watcher.UnWatch(false);
Logger.LogDetail($"AssetManager: Assets load complete! {m_assets.Count} assets loaded.");
Logger.LogDetail($"AssetManager: Current Data Hash: <b><color=#EE6600>{dataHash}</color></b>");
}
private static void LoadWithElementFlags(IEnumerable <KeyValuePair <string, HtmlElementFlag> > flags, LoadHandler loader)
{
Dictionary <string, HtmlElementFlag> oldFlags = null;
try
{
if (flags != null)
{
oldFlags = HtmlNode.ElementsFlags.Clone();
HtmlNode.ElementsFlags.Reload(flags);
}
loader();
}
finally
{
if (oldFlags != null)
{
HtmlNode.ElementsFlags.Reload(oldFlags);
}
}
}
public Core(OPage page, ResponseFormats responseFormat, Mysql db)
{
LoadApplication += new LoadHandler(Core_LoadApplication);
this.db = db;
this.responseFormat = responseFormat;
ItemKey.populateItemTypeCache(this);
//QueryCache.populateQueryCache();
userProfileCache = new PrimitivesCache(this);
itemsCache = new NumberedItemsCache(this);
accessControlCache = new AccessControlCache(this);
primitiveTypes = ItemKey.GetPrimitiveTypes(this);
}
private static void LoadWithElementFlags(Dictionary<string, HtmlElementFlag> flags, LoadHandler loader)
{
var oldFlags = HtmlNode.ElementsFlags;
try
{
if (flags != null)
HtmlNode.ElementsFlags = flags;
loader();
}
finally
{
HtmlNode.ElementsFlags = oldFlags;
}
}
void Awake()
{
loadHandler = GameObject.FindObjectOfType<LoadHandler>();
}
public void Load()
{
ILoadHandler loadHandler = new LoadHandler();
loadHandler.Load(mfchLocalContextProvider);
}
public MainForm()
{
InitializeComponent();
_saveHandler = new SaveHandler();
_saveHandler.Register(new PTSaveFile());
_saveHandler.Register(new TQSaveFile());
_saveHandler.Register(new BMESaveFile());
_loadHandler = new LoadHandler();
_loadHandler.Register(new PTOpenFile());
_loadHandler.Register(new TQOpenFile());
var editor = m_editorForm.Editor;
var audioList = this.m_audioList = new AudioListForm();
audioList.OnPlayPressed += this.AudioList_onPlayPressed;
audioList.OnStopPressed += this.AudioList_onStopPressed;
audioList.OnInstrumentChanged += this.AudioList_onInstrumentChanged;
Logs.OnLogWrite += this.Logs_OnWrite;
m_deserializeDockContent = new DeserializeDockContent(GetContentFromPersistString);
m_notes = new NoteSelectForm(editor.EventsRenderer);
editor.OnSelectItem += Editor_OnSelectItem;
m_notes.OnSelectDataEvent += NoteSelect_OnSelectData;
editor.OnRequestEvent += Editor_OnRequestEvent;
m_audioList.List.SelectionChanged += AudioList_selectionChanged;
editor.OnUndoRedo += UndoManager_OnUndoRedo;
var eventsThemeList = editor.EventsThemeList;
var currentTheme = editor.CurrentEventsTheme;
foreach (var theme in eventsThemeList)
{
ToolStripMenuItem toolStripMenuItem = new ToolStripMenuItem(theme.GetName());
ThemeDropDownButton.DropDownItems.Add(toolStripMenuItem);
if (null != toolStripMenuItem && currentTheme == theme)
{
toolStripMenuItem.Checked = true;
ApplyEventsTheme(theme);
}
}
var zonesThemeList = editor.ZonesThemeList;
var currentZoneTheme = editor.CurrentZonesTheme;
foreach (var theme in zonesThemeList)
{
ToolStripMenuItem toolStripMenuItem = new ToolStripMenuItem(theme.GetName());
zoneRendererToolStripDropDownButton.DropDownItems.Add(toolStripMenuItem);
if (currentZoneTheme != theme)
{
continue;
}
toolStripMenuItem.Checked = true;
ApplyZonesTheme(theme);
}
var eventDisplayModes = GetAll <EventDisplayMode>();
var currentEventDisplayMode = editor.EventDisplayMode;
foreach (var eventDisplayMode in eventDisplayModes)
{
var toolStripMenuItem = new ToolStripMenuItem(eventDisplayMode.Value);
eventDisplayModeToolStripDropDownButton.DropDownItems.Add(toolStripMenuItem);
if (eventDisplayMode.Key != (int)currentEventDisplayMode)
{
continue;
}
toolStripMenuItem.Checked = true;
eventDisplayModeToolStripDropDownButton.Text = eventDisplayMode.Value;
}
AllowDrop = true;
}
public void AddJsonFiles(string filePath, LoadHandler loadHandler)
{
tobeLoadInfoQueue.Enqueue(new ToBeLoadInfo(filePath, loadHandler));
}
public ToBeLoadInfo(string path, LoadHandler onLoaded)
{
Path = path;
OnLoadHandler = onLoaded;
}
public SqlPersistenceProviderFactory(NameValueCollection parameters)
{
if (parameters == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("parameters");
}
this.connectionString = null;
this.LockTimeout = TimeSpan.Zero;
this.SerializeAsText = false;
foreach (string key in parameters.Keys)
{
switch (key)
{
case connectionStringNameParameter:
ConnectionStringSettings settings = ConfigurationManager.ConnectionStrings[parameters[key]];
if (settings == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(
SR2.GetString(SR2.ConnectionStringNameIncorrect, parameters[key]));
}
this.connectionString = settings.ConnectionString;
break;
case serializeAsTextParameter:
this.SerializeAsText = bool.Parse(parameters[key]);
break;
case lockTimeoutParameter:
this.LockTimeout = TimeSpan.Parse(parameters[key], CultureInfo.InvariantCulture);
break;
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(
key,
SR2.GetString(SR2.UnknownSqlPersistenceConfigurationParameter, key, connectionStringNameParameter, serializeAsTextParameter, lockTimeoutParameter));
}
}
if (this.connectionString == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(
SR2.GetString(SR2.ConnectionStringNameParameterRequired, connectionStringNameParameter));
}
this.loadHandler = new LoadHandler(this);
this.createHandler = new CreateHandler(this);
this.updateHandler = new UpdateHandler(this);
this.unlockHandler = new UnlockHandler(this);
this.deleteHandler = new DeleteHandler(this);
}
public Core(TPage page, ResponseFormats responseFormat, Mysql db, Template template)
{
HeadHooks += new HookHandler(Core_HeadHooks);
PrimitiveHeadHooks += new HookHandler(Core_PrimitiveHeadHooks);
FootHooks +=new HookHandler(Core_FootHooks);
PageHooks += new HookHandler(Core_Hooks);
PostHooks += new HookHandler(Core_PostHooks);
LoadApplication += new LoadHandler(Core_LoadApplication);
this.page = page;
this.db = db;
this.template = template;
this.responseFormat = responseFormat;
ItemKey.populateItemTypeCache(this);
//QueryCache.populateQueryCache();
userProfileCache = new PrimitivesCache(this);
itemsCache = new NumberedItemsCache(this);
accessControlCache = new AccessControlCache(this);
primitiveTypes = ItemKey.GetPrimitiveTypes(this);
}
public BrowserTabView()
{
InitializeComponent();
DataContextChanged += OnDataContextChanged;
//browser.BrowserSettings.BackgroundColor = Cef.ColorSetARGB(0, 255, 255, 255);
//Please remove the comments below to use the Experimental WpfImeKeyboardHandler.
//browser.WpfKeyboardHandler = new WpfImeKeyboardHandler(browser);
//Please remove the comments below to specify the color of the CompositionUnderline.
//var transparent = Colors.Transparent;
//var black = Colors.Black;
//ImeHandler.ColorBKCOLOR = Cef.ColorSetARGB(transparent.A, transparent.R, transparent.G, transparent.B);
//ImeHandler.ColorUNDERLINE = Cef.ColorSetARGB(black.A, black.R, black.G, black.B);
browser.RequestHandler = new ExampleRequestHandler();
var bindingOptions = new BindingOptions()
{
Binder = BindingOptions.DefaultBinder.Binder,
MethodInterceptor = new MethodInterceptorLogger() // intercept .net methods calls from js and log it
};
//To use the ResolveObject below and bind an object with isAsync:false we must set CefSharpSettings.WcfEnabled = true before
//the browser is initialized.
#if !NETCOREAPP
CefSharpSettings.WcfEnabled = true;
#endif
//If you call CefSharp.BindObjectAsync in javascript and pass in the name of an object which is not yet
//bound, then ResolveObject will be called, you can then register it
browser.JavascriptObjectRepository.ResolveObject += (sender, e) =>
{
var repo = e.ObjectRepository;
//When JavascriptObjectRepository.Settings.LegacyBindingEnabled = true
//This event will be raised with ObjectName == Legacy so you can bind your
//legacy objects
#if NETCOREAPP
if (e.ObjectName == "Legacy")
{
repo.Register("boundAsync", new AsyncBoundObject(), options: bindingOptions);
}
else
{
if (e.ObjectName == "boundAsync")
{
repo.Register("boundAsync", new AsyncBoundObject(), options: bindingOptions);
}
else if (e.ObjectName == "boundAsync2")
{
repo.Register("boundAsync2", new AsyncBoundObject(), options: bindingOptions);
}
}
#else
if (e.ObjectName == "Legacy")
{
repo.Register("bound", new BoundObject(), isAsync: false, options: BindingOptions.DefaultBinder);
repo.Register("boundAsync", new AsyncBoundObject(), isAsync: true, options: bindingOptions);
}
else
{
if (e.ObjectName == "bound")
{
repo.Register("bound", new BoundObject(), isAsync: false, options: BindingOptions.DefaultBinder);
}
else if (e.ObjectName == "boundAsync")
{
repo.Register("boundAsync", new AsyncBoundObject(), isAsync: true, options: bindingOptions);
}
else if (e.ObjectName == "boundAsync2")
{
repo.Register("boundAsync2", new AsyncBoundObject(), isAsync: true, options: bindingOptions);
}
}
#endif
};
browser.JavascriptObjectRepository.ObjectBoundInJavascript += (sender, e) =>
{
var name = e.ObjectName;
Debug.WriteLine($"Object {e.ObjectName} was bound successfully.");
};
browser.DisplayHandler = new DisplayHandler();
//This LifeSpanHandler implementaion demos hosting a popup in a ChromiumWebBrowser
//instance, it's still considered Experimental
//browser.LifeSpanHandler = new ExperimentalLifespanHandler();
browser.MenuHandler = new MenuHandler();
//Enable experimental Accessibility support
browser.AccessibilityHandler = new AccessibilityHandler(browser);
browser.IsBrowserInitializedChanged += (sender, args) =>
{
if ((bool)args.NewValue)
{
//Uncomment to enable support
//browser.GetBrowserHost().SetAccessibilityState(CefState.Enabled);
}
};
var downloadHandler = new DownloadHandler();
downloadHandler.OnBeforeDownloadFired += OnBeforeDownloadFired;
downloadHandler.OnDownloadUpdatedFired += OnDownloadUpdatedFired;
browser.DownloadHandler = downloadHandler;
browser.AudioHandler = new AudioHandler();
var loadHandler = new LoadHandler();
browser.LoadHandler = loadHandler;
#if false
var requestHandler = new RequestHandler();
browser.RequestHandler = requestHandler;
#endif
//Read an embedded bitmap into a memory stream then register it as a resource you can then load custom://cefsharp/images/beach.jpg
var beachImageStream = new MemoryStream();
CefSharp.Example.Properties.Resources.beach.Save(beachImageStream, System.Drawing.Imaging.ImageFormat.Jpeg);
browser.RegisterResourceHandler(CefExample.BaseUrl + "/images/beach.jpg", beachImageStream, Cef.GetMimeType("jpg"));
var dragHandler = new DragHandler();
dragHandler.RegionsChanged += OnDragHandlerRegionsChanged;
browser.DragHandler = dragHandler;
//browser.ResourceHandlerFactory = new InMemorySchemeAndResourceHandlerFactory();
//You can specify a custom RequestContext to share settings among groups of ChromiumWebBrowsers
//Also this is now the only way to access OnBeforePluginLoad - need to implement IRequestContextHandler
#if false
browser.RequestContext = new RequestContext(new RequestContextHandler());
//NOTE - This is very important for this example as the default page will not load otherwise
browser.RequestContext.RegisterSchemeHandlerFactory(CefSharpSchemeHandlerFactory.SchemeName, null, new CefSharpSchemeHandlerFactory());
browser.RequestContext.RegisterSchemeHandlerFactory("https", "cefsharp.example", new CefSharpSchemeHandlerFactory());
// ^^^ compare this (limited) set with the CefExample.Init()::settings.RegisterScheme(...) call series in CefExample.cs
#endif
//You can start setting preferences on a RequestContext that you created straight away, still needs to be called on the CEF UI thread.
//Cef.UIThreadTaskFactory.StartNew(delegate
//{
// string errorMessage;
// //Use this to check that settings preferences are working in your code
// var success = browser.RequestContext.SetPreference("webkit.webprefs.minimum_font_size", 24, out errorMessage);
//});
browser.RenderProcessMessageHandler = new RenderProcessMessageHandler();
browser.LoadError += (sender, args) =>
{
// Don't display an error for downloaded files.
if (args.ErrorCode == CefErrorCode.Aborted)
{
return;
}
//Don't display an error for external protocols that we allow the OS to
//handle in OnProtocolExecution().
if (args.ErrorCode == CefErrorCode.UnknownUrlScheme && args.Frame.Url.StartsWith("mailto"))
{
return;
}
// Display a load error message.
var errorBody = string.Format("<html><body bgcolor=\"white\"><h2>Failed to load URL {0} with error {1} ({2}).</h2></body></html>",
args.FailedUrl, args.ErrorText, args.ErrorCode);
args.Frame.LoadHtml(errorBody, base64Encode: true);
};
CefExample.RegisterTestResources(browser);
browser.JavascriptMessageReceived += OnBrowserJavascriptMessageReceived;
}
private static void LoadWithElementFlags(Dictionary <string, HtmlElementFlag> flags, LoadHandler loader)
{
var oldFlags = HtmlNode.ElementsFlags;
try
{
if (flags != null)
{
HtmlNode.ElementsFlags = flags;
}
loader();
}
finally
{
HtmlNode.ElementsFlags = oldFlags;
}
}
public GuiObjControl(InitHandler initHandler, RefreshHandler refHandler, LoadHandler loadHandler)
{
OnInit = initHandler;
OnRefresh = refHandler;
OnLoad = loadHandler;
}
public void SetLoadHandler(LoadHandler loadHandler)
{
onLoadHandler = loadHandler;
}
