protected IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
{
if (msg == WM_WINCOMPOSE.DISABLE)
{
if (Process.GetCurrentProcess().Id != (int)wParam)
{
DisableEvent?.Invoke();
}
handled = true;
}
else if (msg == WM_WINCOMPOSE.EXIT)
{
if (Process.GetCurrentProcess().Id != (int)wParam)
{
ExitEvent?.Invoke();
}
handled = true;
}
else if (msg == WM_WINCOMPOSE.OPEN)
{
OpenEvent?.Invoke((MenuCommand)wParam);
handled = true;
}
return(IntPtr.Zero);
}
async protected virtual Task HandleOpen(OpenEvent <TModel> evt)
{
dynamic properties = new ExpandoObject();
properties.Template = evt.Object.Clone();
properties.Templates = ViewModel;
await App.Current.StateController.MoveToModal(OpenTransitionName, properties);
}
void Start()
{
if (openEvent == null)
{
openEvent = new OpenEvent();
}
_baseHingeRotation = transform.rotation;
_navMeshObstacle = GetComponent <NavMeshObstacle>();
}
public async Task<ActionResult<OpenEvent>> GetOpenListWithSlot()
{
// set up our embedded return
string facebookId = _userService.GetFbFromHeader(HttpContext);
OpenEvent rtnTimeslot = await _eventService.GetEventFrontPage(facebookId);
return Ok(rtnTimeslot);
}
void HandleOpen(OpenEvent <LMProject> arg)
{
if (ViewModel.LoadedProject != null)
{
// We get the selection instead of LoadedProject because it can be modified without saving.
// Also we don't use the selected VM directly because it's disposed on unload
LMProjectVM selectedVM = new LMProjectVM {
Model = ViewModel.Selection.First().Model
};
LMStateHelper.OpenProject(selectedVM);
}
}
/// <summary>
/// open a spreadsheet file
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void openToolStripMenuItem_Click(object sender, EventArgs e)
{
OpenFileDialog of = new OpenFileDialog();
of.Filter = "Spreadsheet Files (*.ss)|*.ss|All Files (*.*)|*.*";
of.DefaultExt = "*.ss";
of.FileName = "";
of.Title = "Open";
of.ShowDialog();
string fname = of.FileName;
OpenEvent?.Invoke(fname);
}
public void ShowWindow()
{
OpenEvent?.Invoke();
transform.SetAsLastSibling();
gameObject.SetActive(true);
transform.DOScale(Vector3.one * 0.8f, 0);
GetComponent <CanvasGroup>().DOFade(1, 0.3f);
GetComponent <CanvasGroup>().blocksRaycasts = true;
transform.DOScale(Vector3.one, 0.3f);
foreach (var item in _activeBtn)
{
item.enabled = true;
}
}
void Update()
{
if (Open)
{
EndV2 = GetV2(Input.mousePosition);
// print (GetLocalV2 (DragV2).ToString ("0.0000"));
if (!Out)
{
Vector2 V2 = GetULoacalV2(OutLong);
if ((V2.x != 0 && Mathf.Abs(DragV2.x) > V2.x) || (V2.y != 0 && Mathf.Abs(DragV2.y) > V2.y))
{
Out = true;
Father.onPress(Father.gameObject, true);
}
OpenEvent.Invoke();
}
}
}
public async Task <ActionResult <FrontPage> > GetFrontPage(UserSmall fbInfo)
{
//check if bearer token exists since we call this again if frontpage refreshes
FrontPage returnData = new FrontPage();
string token = HttpContext.Request.Headers["Authorization"].FirstOrDefault()?.Split(" ").Last();
if (token == null)
{
_logger.LogInformation(DateTime.Now.ToString() + " - calling GenerateUserToken");
token = await GenerateUserToken(fbInfo);
}
if (token == null)
{
return(Unauthorized(returnData));
}
else
{
returnData.SessionAuth = token;
}
// now we handle our normal user stuff
_logger.LogInformation(DateTime.Now.ToString() + " - calling GetUserAttribDetail");
returnData.UserInfo = await GetUserAttribDetail(fbInfo);
_logger.LogInformation(DateTime.Now.ToString() + " - finished GetUserAttribDetail");
// now we do the event stuff since we have a user
string FacebookId = fbInfo.FacebookId;
_logger.LogInformation(DateTime.Now.ToString() + " - calling GetEventFrontPage");
OpenEvent rtnTimeslot = await _eventService.GetEventFrontPage(FacebookId);
_logger.LogInformation(DateTime.Now.ToString() + " - finished GetEventFrontPage");
returnData.FlexSlot = rtnTimeslot.FlexSlot;
returnData.MoveFlag = rtnTimeslot.MoveFlag;
returnData.SignedUpTimeslot = rtnTimeslot.SignedUpTimeslot;
returnData.Timeslot = rtnTimeslot.Timeslot;
return(Ok(returnData));
}
private void OpenInternal(bool setAsLastSibling, params object[] args)
{
if (IsOpen)
{
return;
}
WasEnabled = !gameObject.activeSelf;
gameObject.SetActive(true);
_canvasGroup.blocksRaycasts = true;
if (setAsLastSibling)
{
transform.SetAsLastSibling();
}
if (_showFader)
{
_needCloseFader = true;
DialogFader.FadeIn(this, _faderDuration, () => FaderVisible = true);
}
_state = FormState.Opening;
OnOpen(args);
if (OpenEvent != null)
{
OpenEvent.Invoke();
}
if (_processRoutine != null)
{
StopCoroutine(_processRoutine);
}
_processRoutine = OpenAsync();
if (!IsClose) // form might be closed in OpenEvent handlers
{
StartCoroutine(_processRoutine);
}
}
protected virtual void OnOpenEvent()
{
OpenEvent?.Invoke(this, EventArgs.Empty);
}
public async void OnOpen(OpenEvent ev)
{
this.greetingService.RegisterClient(ev.Socket);
await ev.Socket.SendAsync("Welcome! Everything you say will be seen by everyone");
}
public static (SpeedscopeFile, ProcessingSummary) ToSpeedscopeFormat(this ProfileEventCollection collection)
{
var session = collection.Session;
var file = new SpeedscopeFile();
if (session.File != null)
{
file.Name = Path.GetFileNameWithoutExtension(session.File);
}
var summary = new ProcessingSummary();
foreach (var threadData in collection.ThreadSummaries)
{
string name = collection.ThreadSummaries.Count == 1 ? "Main Thread" : $"Thread {threadData.Id}";
var profileEvents = collection.GetEvents(threadData.Id);
var profile = new EventedProfile()
{
Unit = ValueUnit.Milliseconds,
StartValue = 0.0,
Name = name
};
file.Profiles.Add(profile);
var openEvents = new Dictionary <long, (int index, ProfileEvent)>();
var frameLookup = new Dictionary <string, (int index, Frame frame)>();
double maxValue = -1;
foreach (var profileEvent in profileEvents)
{
if (!frameLookup.TryGetValue(profileEvent.Name, out var frameInfo))
{
var frame = new Frame()
{
Name = profileEvent.Name
};
int index = file.Shared.Frames.Count;
file.Shared.Frames.Add(frame);
frameInfo = (index, frame);
frameLookup.Add(profileEvent.Name, frameInfo);
}
IEvent ssEvent;
if (profileEvent.EventType == ProfileEventType.StartMethod)
{
ssEvent = new OpenEvent()
{
At = profileEvent.Offset.TotalMilliseconds, Frame = frameInfo.index
};
openEvents.Add(profileEvent.Id, (frameInfo.index, profileEvent));
}
else if (profileEvent.EventType == ProfileEventType.EndMethod)
{
ssEvent = new CloseEvent()
{
At = profileEvent.Offset.TotalMilliseconds, Frame = frameInfo.index
};
openEvents.Remove(profileEvent.Id);
}
else
{
summary.DroppedEvents++;
continue;
}
profile.Events.Add(ssEvent);
if (ssEvent.At > maxValue)
{
maxValue = ssEvent.At;
}
}
profile.EndValue = maxValue;
if (openEvents.Count > 0)
{
summary.FixedUnbalancedOpenEvents += openEvents.Count;
foreach (var(id, (index, frameInfo)) in openEvents.OrderByDescending(kvp => kvp.Value.Item2.Offset))
{
var fakeCloseEvent = new CloseEvent()
{
At = maxValue,
Frame = index
};
profile.Events.Add(fakeCloseEvent);
}
}
}
return(file, summary);
}
public void DeletOpenEvent(OpenEvent handler)
{
ReviveOpenHandler -= handler;
}
public void AddOpenEvent(OpenEvent handler)
{
ReviveOpenHandler += handler;
}
void OnOpenEvent(OpenEvent e)
{
Open();
}
public void OnOpen(OpenEvent ev)
{
}
public Contur()
{
Open = new Command(() => { OpenEvent?.Invoke(this); });
}
public async Task <OpenEvent> GetEventFrontPage(string facebookId)
{
List <TimeslotLimited> finalTimeslot = new List <TimeslotLimited>();
OpenEvent rtnTimeslot = new OpenEvent();
DateTime limitTime = DateTime.UtcNow.AddHours(1);
var openSlot = await(from t in _context.Timeslot
where DateTime.UtcNow >= t.EventOpenTms &&
t.EventStartTms >= limitTime &&
!t.PrivateEventInd
orderby t.EventStartTms
select new TimeslotLimitedDb {
Id = t.Id,
EventStartTms = t.EventStartTms,
EventEndTms = t.EventEndTms,
EventClosed = t.EventClosed,
EventNote = t.EventNote,
IntlEventInd = t.IntlEventInd,
EventSlotCnt = t.EventSlotCnt,
OverbookCnt = t.OverbookCnt
}).ToListAsync();
//Since we can only have one signup per open weekend now, can use first or default here.
// No longer!
var userSignedupList = await(from es in _context.EventSignup
join u in _context.Users
on es.UserId equals u.Id
join t in _context.Timeslot
on es.TimeslotId equals t.Id
where u.FbId == facebookId &&
DateTime.UtcNow >= t.EventOpenTms &&
t.EventStartTms >= limitTime &&
!t.PrivateEventInd &&
!es.DeleteInd
select new {
es.Id,
es.TimeslotId,
es.AttendNbr,
es.ConfirmInd,
u.EventCnt,
es.FlexibleInd,
u.CountryCd
}).ToListAsync();
// default value - removing functionality for move
rtnTimeslot.MoveFlag = false;
if (userSignedupList is null)
{
rtnTimeslot.SignedUpTimeslot = 0;
}
foreach (TimeslotLimitedDb eventSlot in openSlot)
{
var userSignSlot = userSignedupList.Find(u => u.TimeslotId == eventSlot.Id);
if (userSignSlot != null)
{
if (userSignSlot.AttendNbr <= eventSlot.EventSlotCnt && userSignSlot.ConfirmInd)
{
eventSlot.UserSlot = "G";
}
else if (userSignSlot.AttendNbr <= eventSlot.EventSlotCnt)
{
eventSlot.UserSlot = "S";
}
else if (userSignSlot.AttendNbr <= eventSlot.EventSlotCnt + eventSlot.OverbookCnt)
{
eventSlot.UserSlot = "C";
}
else if (userSignSlot.TimeslotId != null)
{
eventSlot.UserSlot = "L";
}
}
var intlAttendee = !(userSignSlot?.CountryCd is null);
finalTimeslot.Add(new TimeslotLimited()
{
Id = eventSlot.Id,
EventStartTms = eventSlot.EventStartTms,
EventEndTms = eventSlot.EventEndTms,
UserSlot = eventSlot.UserSlot,
EventClosed = eventSlot.EventClosed,
EventNote = eventSlot.EventNote,
IntlEventInd = eventSlot.IntlEventInd == false ? intlAttendee : eventSlot.IntlEventInd,
});
}
//assign compiled list to return var
rtnTimeslot.Timeslot = finalTimeslot;
return(rtnTimeslot);
}
private void openToolStripMenuItem_Click(object sender, EventArgs e)
{
OpenEvent?.Invoke();
}
