public IfNull(
object firstValue, ValueObjectType firstValueType,
object secondValue, ValueObjectType secondValueType)
{
this.Value1 = new ValueWrapper(firstValue, firstValueType);
this.Value2 = new ValueWrapper(secondValue, secondValueType);
}
/// <summary>
/// Creates a container for a single animation for an object
/// </summary>
public AnimationGroup()
{
Activations = new List <AnimationActivation>();
Effects = new List <AnimationEffect>();
EffectTiming = new ValueWrapper <double>();
HookedAnimations = new List <AfterAnimation>();
}
private void GetThreadName(ThreadWrapper threadWrapper, ValueWrapper threadObject, NuGenFrameRefresher threadActiveFrameRefresher)
{
List <ModuleWrapper> modules = threadWrapper.FindModulesByName(GetThreadNameMethod.BaseTypeDefinition.ModuleScope.Assembly.FileName);
if (modules.Count == 1)
{
ModuleWrapper module = modules[0];
FunctionWrapper getThreadNameFunction = module.GetFunction(GetThreadNameMethod.Token);
List <ValueWrapper> arguments = new List <ValueWrapper>(1);
arguments.Add(threadObject);
NuGenEvaluationHandler methodCaller = new NuGenEvaluationHandler(threadActiveFrameRefresher);
NuGenBaseEvaluationResult evaluationResult = methodCaller.CallFunction(getThreadNameFunction, arguments);
if (evaluationResult.IsSuccessful)
{
if (evaluationResult.Result != null && (CorElementType)evaluationResult.Result.ElementType == CorElementType.ELEMENT_TYPE_STRING)
{
ValueWrapper dereferencedResult = evaluationResult.Result.DereferenceValue();
if (dereferencedResult != null)
{
EvaluatedThreadName = NuGenHelperFunctions.ShowEscapeCharacters(dereferencedResult.GetStringValue(), true);
}
}
}
}
}
public IfNull(
object firstValue, ValueObjectType firstValueType,
string secondTableName, string secondColumnName)
{
this.Value1 = new ValueWrapper(firstValue, firstValueType);
this.Value2 = new ValueWrapper(secondTableName, secondColumnName);
}
public void Add(TKey key, TValue value)
{
var wrap = new ValueWrapper(key, value);
this.innerDict.Add(key, value);
this.orderedElements.Add(wrap);
}
static T GetEditorPref <T>(string key, T fallback = default(T))
{
var k = GetEditorPrefKey <T>(key);
if (!EditorPrefs.HasKey(k))
{
return(fallback);
}
var o = (object)fallback;
if (typeof(T) == typeof(string))
{
o = EditorPrefs.GetString(k, (string)o);
}
else if (typeof(T) == typeof(bool))
{
o = EditorPrefs.GetBool(k, (bool)o);
}
else if (typeof(T) == typeof(float))
{
o = EditorPrefs.GetFloat(k, (float)o);
}
else if (typeof(T) == typeof(int))
{
o = EditorPrefs.GetInt(k, (int)o);
}
else
{
return(ValueWrapper <T> .Deserialize(EditorPrefs.GetString(k)));
}
return((T)o);
}
static void SetEditorPref <T>(string key, T value)
{
var k = GetEditorPrefKey <T>(key);
if (typeof(T) == typeof(string))
{
EditorPrefs.SetString(k, (string)(object)value);
}
else if (typeof(T) == typeof(bool))
{
EditorPrefs.SetBool(k, (bool)(object)value);
}
else if (typeof(T) == typeof(float))
{
EditorPrefs.SetFloat(k, (float)(object)value);
}
else if (typeof(T) == typeof(int))
{
EditorPrefs.SetInt(k, (int)(object)value);
}
else
{
EditorPrefs.SetString(k, ValueWrapper <T> .Serialize(value));
}
}
public ABlackboardElement()
{
m_guid = Guid.NewGuid().ToString();
Type = typeof(T);
m_name = $"new {Type.Name}";
m_serializedType = Type.AssemblyQualifiedName;
object newValue;
if (Nullable.GetUnderlyingType(Type) != null)
{
newValue = (T)Activator.CreateInstance(Type);
}
else
{
T defaultT = default;
newValue = defaultT;
}
m_valueWrapper = new ValueWrapper()
{
Value = (T)newValue
};
}
public GroupConcat(bool distinct, string tableName, string columnName, string separator, OrderByList orderBy)
{
this.Distinct = distinct;
this.Value = new ValueWrapper(tableName, columnName);
this.Separator = separator;
this.OrderBy = orderBy;
}
private static void NotArray(ValueWrapper valueWrapper)
{
var message = typeof(DropdownAttribute).Name + " works only when the type of the field is equal to the element type of the array";
EditorGUILayout.HelpBox(message, MessageType.Warning);
valueWrapper.DrawDefaultField();
}
private static void FieldNull(ValueWrapper valueWrapper, DropdownAttribute attribute)
{
var message = $"{typeof(DropdownAttribute).Name} cannot find a values field with name \"{attribute.ValuesFieldName}\"";
EditorGUILayout.HelpBox(message, MessageType.Warning);
valueWrapper.DrawDefaultField();
}
public TValue this[TKey key]
{
get
{
TValue value = default;
if (TryGetValue(key, out value))
{
return(value);
}
else
{
throw new KeyNotFoundException();
}
}
set
{
ValueWrapper wrapper = default;
if (!dictionary.TryGetValue(key, out wrapper))
{
Add(key, value);
}
else
{
wrapper.value = value;
}
}
}
public GroupConcat(bool distinct, ValueWrapper value, string separator, OrderByList orderBy)
{
this.Distinct = distinct;
this.Value = value;
this.Separator = separator;
this.OrderBy = orderBy;
}
private static void NotObject(ValueWrapper wrapper)
{
string warning = typeof(ShowAssetPreviewAttribute).Name + " can only be used on Object fields";
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning);
wrapper.DrawDefaultField();
}
private static void NotIntFloat(ValueWrapper wrapper)
{
string warning = typeof(SliderAttribute).Name + " can only be used on int or float fields";
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning);
wrapper.DrawDefaultField();
}
/// <summary>Constructor of the class.</summary>
/// <param name="node">The class node.</param>
/// <param name="autoExpand">The value if nodes should get expanded.</param>
public ClassTreeNode(ClassNode node, ValueWrapper <bool> enableHierarchyView, ValueWrapper <bool> autoExpand)
: this(node, enableHierarchyView, autoExpand, null)
{
Contract.Requires(node != null);
Contract.Requires(enableHierarchyView != null);
Contract.Requires(autoExpand != null);
}
/// <summary>
/// Verifyes that handle corresponds instance of object and returns index of object.
/// Returns 0, if invalid handle.
/// </summary>
private int HandleToIndex(UInt32 handle)
{
if (handle == 0)
{
return(0);
}
var id = (byte)(handle >> 24);
var index = (int)(handle & 0xFFFFFF);
if (index >= _valueWrapperCount)
{
return(0);
}
ValueWrapper item = _items[index];
if (item.Value is null)
{
return(0);
}
if (id != item.InstanceId)
{
return(0);
}
return(index);
}
protected void InitMaterial()
{
selectedAxisSpace = isKeywordEnabled(Constants.Shader.AXIS_COLORS_LOCAL) ? Space.Local : Space.World;
useThreeLightSystem = isKeywordEnabled(Constants.Shader.SYMETRIC_COLORS_ON_KEYWORD);
useGradientLightXColors = isKeywordEnabled(Constants.Shader.AXIS_GRADIENT_ON_X_KEYWORD);
useGradientLightYColors = isKeywordEnabled(Constants.Shader.AXIS_GRADIENT_ON_Y_KEYWORD);
useGradientLightZColors = isKeywordEnabled(Constants.Shader.AXIS_GRADIENT_ON_Z_KEYWORD);
useVertexColors = isKeywordEnabled(Constants.Shader.VERTEX_COLOR_KEYWORD);
useMainTexture = isKeywordEnabled(Constants.Shader.USE_MAIN_TEXTURE_KEYWORD);
useGPUInstancing = material.enableInstancing;
useAmbientLight = isKeywordEnabled(Constants.Shader.AMBIENT_LIGHT_KEYWORD);
useDirectLight = isKeywordEnabled(Constants.Shader.DIRECT_LIGHT_KEYWORD);
useSpotLight = isKeywordEnabled(Constants.Shader.SPOT_LIGHT_KEYWORD);
usePointLight = isKeywordEnabled(Constants.Shader.POINT_LIGHT_KEYWORD);
selectedLightSourcesBlend = isKeywordEnabled(Constants.Shader.BLEND_LIGHT_SOURCES_KEYWORD) ? LightSourcesBlend.Multiple : LightSourcesBlend.Individual;
useGlobalGradient = isKeywordEnabled(Constants.Shader.GRADIENT_LOCAL_KEYWORD) || isKeywordEnabled(Constants.Shader.GRADIENT_WORLD_KEYWORD);
selectedGradientSpace = isKeywordEnabled(Constants.Shader.GRADIENT_LOCAL_KEYWORD) ? Space.Local : Space.World;
useCustomLightmapping = isKeywordEnabled(Constants.Shader.CUSTOM_LIGHTMAPPING_KEYWORD);
useUnityLightmapping = isKeywordEnabled(Constants.Shader.UNITY_LIGHTMAPPING_KEYWORD);
receiveCustomShadows = isKeywordEnabled(Constants.Shader.RECEIVE_CUSTOM_SHADOW_KEYWORD);
castCustomShadows = isKeywordEnabled(Constants.Shader.CAST_CUSTOM_SHADOW_ON_KEYWORD);
useFog = isKeywordEnabled(Constants.Shader.USE_FOG_KEYWORD);
if (useCustomLightmapping || useUnityLightmapping)
{
selectedUVChannel = (int)lightmapUVChannel.floatValue;
}
}
public IfNull(
string firstTableName, string firstColumnName,
string secondTableName, string secondColumnName)
{
this.Value1 = new ValueWrapper(firstTableName, firstColumnName);
this.Value2 = new ValueWrapper(secondTableName, secondColumnName);
}
private static void NotString(ValueWrapper wrapper)
{
string warning = typeof(ResizableTextAreaAttribute).Name + " can only be used on string fields";
EditorDrawUtility.DrawHelpBox(warning, MessageType.Warning);
wrapper.DrawDefaultField();
}
public Add(
object value1, ValueObjectType valueType1,
object value2, ValueObjectType valueType2)
{
this.Value1 = new ValueWrapper(value1, valueType1);
this.Value2 = new ValueWrapper(value2, valueType2);
}
public void Set(NodeConstantData nodeConstantData)
{
var constantType = Type.GetType(nodeConstantData.ConstantType);
SetType(Type.GetType(nodeConstantData.ConstantType));
ValueWrapper.SetFromString(nodeConstantData.Value);
}
private static void ValidateProperty(ValueWrapper wrapper, ValidateInputAttribute attribute)
{
var validationCallback = ReflectionUtility.GetMethod(wrapper.Target, attribute.CallbackName);
if (validationCallback == null || validationCallback.ReturnType != typeof(bool) || validationCallback.GetParameters().Length != 1)
{
WrongType();
return;
}
var fieldType = wrapper.Type;
Type parameterType = validationCallback.GetParameters()[0].ParameterType;
if (fieldType != parameterType)
{
FieldMismatch();
return;
}
if (!(bool)validationCallback.Invoke(wrapper.Target, new[] { wrapper.GetValue() }))
{
if (string.IsNullOrEmpty(attribute.Message))
{
EditorDrawUtility.DrawHelpBox(wrapper.DisplayName + " is not valid", MessageType.Error);
}
else
{
EditorDrawUtility.DrawHelpBox(attribute.Message, MessageType.Error);
}
}
}
public Add(
object value1, ValueObjectType valueType1,
string tableName2, string columnName2)
{
this.Value1 = new ValueWrapper(value1, valueType1);
this.Value2 = new ValueWrapper(tableName2, columnName2);
}
public Add(
string tableName1, string columnName1,
string tableName2, string columnName2)
{
this.Value1 = new ValueWrapper(tableName1, columnName1);
this.Value2 = new ValueWrapper(tableName2, columnName2);
}
public IfNull(
string firstTableName, string firstColumnName,
object secondValue, ValueObjectType secondValueType)
{
this.Value1 = new ValueWrapper(firstTableName, firstColumnName);
this.Value2 = new ValueWrapper(secondValue, secondValueType);
}
/// <summary>
/// Releases object from internal list. Its handle becomes invalid.
/// index must be valid
/// </summary>
private void RemoveInternal(int index)
{
int nextIndex = _items[index].NextIndex;
int prevIndex = _items[index].PrevIndex;
int nextIndex0 = _items[0].NextIndex;
int prevIndex0 = _items[0].PrevIndex;
ValueWrapper item = _items[index];
item.Value = null;
item.NextIndex = 0;
item.PrevIndex = prevIndex0;
_items[0].PrevIndex = index;
if (prevIndex0 > 0)
{
_items[prevIndex0].NextIndex = index;
}
_items[prevIndex].NextIndex = nextIndex;
if (nextIndex > 0)
{
_items[nextIndex].PrevIndex = prevIndex;
}
Count--;
}
public Divide(
object value1,
string tableName2, string column2
)
{
this.Value1 = new ValueWrapper(value1, ValueObjectType.Value);
this.Value2 = new ValueWrapper(tableName2, column2);
}
public Divide(
string tableName1, string column1,
object value2, ValueObjectType valueType2
)
{
this.Value1 = new ValueWrapper(tableName1, column1);
this.Value2 = new ValueWrapper(value2, valueType2);
}
public Divide(
string tableName1, string column1,
string tableName2, string column2
)
{
this.Value1 = new ValueWrapper(tableName1, column1);
this.Value2 = new ValueWrapper(tableName2, column2);
}
public Multiply(
object value1,
object value2
)
{
this.Value1 = new ValueWrapper(value1, ValueObjectType.Value);
this.Value2 = new ValueWrapper(value2, ValueObjectType.Value);
}
private bool OnException(object sender, Exception ex)
{
var result = new ValueWrapper<bool>(false);
if (Exception != null) Exception(sender, new EventArgs<Exception, ValueWrapper<bool>>(ex, result));
return result.Value;
}
void RegisterBuiltInValueType <T>(ReadWriteOperations <T> operations)
{
ValueInstantiator instantiator = BuiltInValue <T> .CreateInstantiator(operations);
ValueWrapper wrapper = BuiltInValue <T> .CreateWrapper(operations);
RegisterBuiltInType(typeof(T), StandardTypeSignature.Create, instantiator, wrapper);
}
public Multiply(
string tableName1, object value1, ValueObjectType valueType1,
string tableName2, object value2, ValueObjectType valueType2
)
{
this.Value1 = new ValueWrapper(tableName1, value1, valueType1);
this.Value2 = new ValueWrapper(tableName2, value2, valueType2);
}
public Multiply(
string tableName1, string column1,
object value2
)
{
this.Value1 = new ValueWrapper(tableName1, column1);
this.Value2 = new ValueWrapper(value2, ValueObjectType.Value);
}
public Divide(
object value1,
object value2
)
{
this.Value1 = new ValueWrapper(value1, ValueObjectType.Value);
this.Value2 = new ValueWrapper(value2, ValueObjectType.Value);
}
public RegisteredType(uint id, Type type, TypeSignatureCreator signatureCreator, ValueInstantiator instantiator, ValueWrapper wrapper)
{
Id = id;
Type = type;
TypeSignature = signatureCreator(id, type);
Instantiator = instantiator;
Wrapper = wrapper;
}
public Task SaveAsync(string value, CancellationToken cancellationToken)
{
this.valueWrapper = new ValueWrapper {
Value = value
};
return(Task.CompletedTask);
}
public int GetHashCode(ValueWrapper <T> obj)
{
if (obj.Val == null)
{
return(0);
}
return(_comparer.GetHashCode(obj.Val));
}
/// <summary>
/// Creates a prototype that can present a string
/// </summary>
public Text()
{
RenderName = GetType().FullName;
Parameter.Add("Text", TextValue = new ValueWrapper <string>());
Parameter.Add("FontSize", FontSize = new ValueWrapper <ScreenPos>());
Parameter.Add("Align", Align = new ValueWrapper <Align>());
Parameter.Add("Valign", Valign = new ValueWrapper <Valign>());
}
/// <summary>
/// Reserve space in the internal list of objects
/// </summary>
public void Reserve(int capacity)
{
if (capacity > _items.Length)
{
ValueWrapper[] oldItems = _items;
_items = new ValueWrapper[capacity];
oldItems.CopyTo(_items, 0);
}
}
public Replace(
string sourceTableName, string sourceColumn,
string searchTableName, string searchColumn,
string replaceWithTableName, string replaceWithColumn)
{
this.SourceValue = new ValueWrapper(sourceTableName, sourceColumn);
this.SearchValue = new ValueWrapper(searchTableName, searchColumn);
this.ReplaceWithValue = new ValueWrapper(replaceWithTableName, replaceWithColumn);
}
public Replace(
string sourceTableName, string sourceColumn,
object search, ValueObjectType searchType,
object replace, ValueObjectType replaceWithType)
{
this.SourceValue = new ValueWrapper(sourceTableName, sourceColumn);
this.SearchValue = new ValueWrapper(search, searchType);
this.ReplaceWithValue = new ValueWrapper(replace, replaceWithType);
}
public Replace(
object source, ValueObjectType sourceType,
string searchTableName, string searchColumn,
string replaceWithTableName, string replaceWithColumn)
{
this.SourceValue = new ValueWrapper(source, sourceType);
this.SearchValue = new ValueWrapper(searchTableName, searchColumn);
this.ReplaceWithValue = new ValueWrapper(replaceWithTableName, replaceWithColumn);
}
/// <summary>
/// Creates a Prototype for a single rectangle
/// </summary>
public Rect()
{
RenderName = GetType().FullName;
Parameter.Add("LineWidth", LineWidth = new ValueWrapper <double>()
{
Value = 1,
Exists = true
});
}
private void _listBox_ItemCheck(object sender, ItemCheckEventArgs e)
{
if (_ignoreItemCheck)
{
return;
}
_ignoreItemCheck = true;
try
{
ValueWrapper wrapper = (ValueWrapper)_listBox.Items[e.Index];
if (e.Index == 0)
{
if (e.NewValue == CheckState.Checked)
{
for (int n = 1; n < _listBox.Items.Count; n++)
{
_listBox.SetItemChecked(n, true);
}
}
else if (e.NewValue == CheckState.Unchecked)
{
for (int n = 1; n < _listBox.Items.Count; n++)
{
_listBox.SetItemChecked(n, false);
}
}
}
else
{
bool diff = false;
for (int n = 1; n < _listBox.Items.Count; n++)
{
if (n != e.Index && e.NewValue != _listBox.GetItemCheckState(n))
{
diff = true;
break;
}
}
if (diff)
{
_listBox.SetItemCheckState(0, CheckState.Indeterminate);
}
else
{
_listBox.SetItemCheckState(0, e.NewValue);
}
}
}
finally
{
_ignoreItemCheck = false;
}
}
/// <summary>
/// Puts object in internal list and returns its index there.
/// </summary>
private int AddInternal(TObject value)
{
ValueWrapper item0 = _items[0];
if (item0.PrevIndex == 0)
{
if (_valueWrapperCount == _items.Length)
{
ValueWrapper[] oldItems = _items;
_items = new ValueWrapper[oldItems.Length * 2];
oldItems.CopyTo(_items, 0);
}
_items[_valueWrapperCount] = new ValueWrapper();
item0.PrevIndex = _valueWrapperCount;
_valueWrapperCount++;
}
int currentIndex = item0.PrevIndex;
ValueWrapper currentItem = _items[currentIndex];
int nextIndex = currentItem.NextIndex;
int prevIndex = currentItem.PrevIndex;
int nextIndex0 = item0.NextIndex;
int prevIndex0 = item0.PrevIndex;
currentItem.Value = value;
currentItem.HasValue = true;
if (currentItem.InstanceId == 0xFF)
{
currentItem.InstanceId = 1;
}
else
{
currentItem.InstanceId++;
}
currentItem.NextIndex = nextIndex0;
currentItem.PrevIndex = 0;
item0.NextIndex = currentIndex;
item0.PrevIndex = prevIndex;
if (prevIndex > 0)
{
_items[prevIndex].NextIndex = 0;
}
if (nextIndex0 > 0)
{
_items[nextIndex0].PrevIndex = currentIndex;
}
Count++;
return(currentIndex);
}
/// <summary>
/// Sets the capacity to the actual number of elements in the internal list of objects,
/// if that number is less than a threshold value.
/// </summary>
public void TrimExcess()
{
if (_valueWrapperCount == _items.Length)
{
return;
}
ValueWrapper[] oldItems = _items;
_items = new ValueWrapper[_valueWrapperCount];
oldItems.CopyTo(_items, 0); // TODO: Verify
}
public Task <bool> RemoveAsync(CancellationToken cancellationToken)
{
if (this.valueWrapper != null)
{
this.valueWrapper = null;
return(Task.FromResult(true));
}
return(Task.FromResult(false));
}
public static void Add <T>(
this IDictionary <string, IValueWrapper> dictionary,
string key,
T value
)
{
ValueWrapper <T> valueWrapper = new ValueWrapper <T>(value);
dictionary.Add(key, valueWrapper);
}
public OperationsViewModel(IUnityContainer unityContainer, IInitData initData, ISettingsService settingsService)
{
InitData = initData;
SettingsService = settingsService;
IsOperationsViewEnabled = true;
IsCancellationRequested = new ValueWrapper<bool>(false);
GenerateDataGrid();
UnityContainer = unityContainer;
}
public void when_TryGetValue_called_with_nonexistent_key__should_return_false()
{
var mruCache = new MruCache<ValueWrapper<int>, object>(12);
object added = new object();
var key = new ValueWrapper<int>(0);
mruCache.Add(key, added);
object res;
Assert.IsFalse(mruCache.TryGetValue(new ValueWrapper<int>(1), out res));
Assert.IsNull(res);
}
public void when_TryGetValue_called_with_existing_key__should_return_what_it_was_provided()
{
var mruCache = new MruCache<ValueWrapper<int>, object>(12);
object added = new object();
var key = new ValueWrapper<int>(0);
mruCache.Add(key, added);
object res;
Assert.IsTrue(mruCache.TryGetValue(new ValueWrapper<int>(0), out res));
Assert.AreEqual(added, res);
}
public IEnumerable<IRowModel> AnalyzeAllPDFs(IEnumerable<IRowModel> filesToAnalyze, string[] wordsToAnalysis, string sourceFolder,
ValueWrapper<bool> isCancellationRequested, ReportProgessEvent reportProgress)
{
foreach (var file in filesToAnalyze)
{
if (isCancellationRequested.Value)
{
return filesToAnalyze;
}
try
{
if (file.Descriptions.Any())
{
file.Descriptions.Clear();
}
var dms = wordsToAnalysis.Select(x => new DescriptionModel {Word = x, Occurances = 0});
foreach (var descriptionModel in dms)
{
file.Descriptions.Add(descriptionModel);
}
var pdfReader = new PdfReader(Path.Combine(sourceFolder, file.FileName));
string text = string.Empty;
int numberOfPages = pdfReader.NumberOfPages;
for (int page = 1; page < numberOfPages; page++)
{
text = PdfTextExtractor.GetTextFromPage(pdfReader, page);
foreach (var word in file.Descriptions)
{
word.Occurances += Regex.Matches(text, word.Word).Count;
}
}
file.Analyzed = true;
pdfReader.Close();
}
catch (Exception)
{
continue;
}
if (OnFileAnalyzed != null)
{
OnFileAnalyzed.Invoke(file);
}
}
return filesToAnalyze;
}
public void DownloadFiles(IEnumerable<Uri> links, string destinationPath, ReportProgessEvent reportProgess, ValueWrapper<bool> isCancellationRequested)
{
var client = new WebClient();
var linksList = links.ToList();
int counter = 0;
string filename;
foreach (var link in linksList)
{
if (isCancellationRequested.Value)
{
return;
}
filename = Path.GetFileName(link.LocalPath);
reportProgess(counter++*100/linksList.Count);
try
{
client.DownloadFile(link, filename);
Thread.Sleep(500);
}
catch (Exception)
{
//zakladam ze wsyzstkie pliki sie pobiora bez przypalow.
}
var path = Path.Combine(destinationPath, filename);
if (File.Exists(path))
{
File.Delete(path);
}
File.Copy(filename, path);
if (OnFileDownloaded != null)
{
OnFileDownloaded.Invoke(path);
}
}
}
/// <summary>
/// The default Constructor.
/// </summary>
public SceneManager(GameWindow gameWindow, Camera camera, FontLibrary fontLibrary, string fontPath, IDirectoryHandler directoryHandler, IGameSettings gameSettings, ValueWrapper<bool> debug)
{
GameWindow = gameWindow;
SceneList = new List<Scene>();
_scenesToAdd = new List<Scene>();
_scenesToRemove = new List<Scene>();
Directories = directoryHandler;
FontPath = fontPath;
GameFontLibrary = fontLibrary;
DefaultFont = GameFontLibrary.GetFirstOrDefault(GameFontType.Default);
FontDrawing = new QFontDrawing();
FontDrawing.ProjectionMatrix = camera.ScreenProjectionMatrix;
ScreenCamera = camera;
ScreenCamera.Center = Vector2.Zero;
ScreenCamera.MaximumScale = new Vector2(10000, 10000);
GameSettings = gameSettings;
Debug = debug;
}
public GroupConcat(string tableName, string columnName)
{
this.Value = new ValueWrapper(tableName, columnName);
}
public GroupConcat(string tableName, string columnName, OrderByList orderBy)
{
this.Value = new ValueWrapper(tableName, columnName);
this.OrderBy = orderBy;
}
public GroupConcat(string tableName, string columnName, string separator)
{
this.Value = new ValueWrapper(tableName, columnName);
this.Separator = separator;
}
public GroupConcat(bool distinct, ValueWrapper value)
{
this.Distinct = distinct;
this.Value = value;
}