public override void DisableEvent(object eventId)
{
if (eventId is WidgetEvent)
{
var ev = (WidgetEvent)eventId;
switch (ev)
{
case WidgetEvent.KeyPressed:
Widget.KeyDown -= WidgetKeyDownHandler;
break;
case WidgetEvent.KeyReleased:
Widget.KeyUp -= WidgetKeyUpHandler;
break;
case WidgetEvent.ButtonPressed:
Widget.MouseDown -= WidgetMouseDownHandler;
break;
case WidgetEvent.ButtonReleased:
Widget.MouseUp -= WidgetMouseUpHandler;
break;
case WidgetEvent.MouseEntered:
Widget.MouseEnter -= WidgetMouseEnteredHandler;
break;
case WidgetEvent.MouseExited:
Widget.MouseLeave -= WidgetMouseExitedHandler;
break;
case WidgetEvent.MouseMoved:
Widget.MouseMove -= WidgetMouseMoveHandler;
break;
case WidgetEvent.BoundsChanged:
Widget.SizeChanged -= WidgetOnSizeChanged;
break;
case WidgetEvent.MouseScrolled:
Widget.MouseWheel -= WidgetMouseWheelHandler;
break;
}
enabledEvents &= ~ev;
if ((ev & dragDropEvents) != 0 && (enabledEvents & dragDropEvents) == 0)
{
// All drag&drop events have been disabled
Widget.DragOver -= WidgetDragOverHandler;
Widget.Drop -= WidgetDropHandler;
Widget.DragLeave -= WidgetDragLeaveHandler;
}
}
}
public virtual void OnWidgetEvent(WidgetEvent widgetEvent)
{
if (m_widgetEventListener != null)
{
m_widgetEventListener.OnWidgetEvent(widgetEvent);
}
else if (m_parentWidgetGroup != null)
{
m_parentWidgetGroup.OnWidgetEvent(widgetEvent);
}
}
// IWidgetEventListener
public void OnWidgetEvent(WidgetEvent widgetEvent)
{
if (widgetEvent.EventSource == m_createButton)
{
CreateGameController.OnGameCreateClicked();
}
else if (widgetEvent.EventSource == m_cancelButton)
{
CreateGameController.OnCancelClicked();
}
}
// IWidgetEventListener
public void OnWidgetEvent(WidgetEvent widgetEvent)
{
if (widgetEvent.EventSource == m_createButton)
{
CreateGameController.OnGameCreateClicked();
}
else if (widgetEvent.EventSource == m_cancelButton)
{
CreateGameController.OnCancelClicked();
}
}
public void Connect(WidgetEvent _event, Action _act)
{
if (!m_Dispatch.ContainsKey(_event))
{
m_Dispatch.Add(_event, new List <Action>());
}
List <Action> actionsList = m_Dispatch[_event];
actionsList.Add(_act);
}
private void AddListener(EventTriggerType trigger_type, WidgetEvent widget_event)
{
EventTrigger trigger = this.GetEventTrigger();
EventTrigger.Entry entry = new EventTrigger.Entry();
entry.eventID = trigger_type;
entry.callback = new EventTrigger.TriggerEvent();
entry.callback.AddListener(delegate(BaseEventData base_event) {
widget_event(base_event, this.data);
});
trigger.triggers.Add(entry);
}
public virtual void EnableEvent(object eventId)
{
if (eventId is WidgetEvent)
{
WidgetEvent ev = (WidgetEvent)eventId;
switch (ev)
{
case WidgetEvent.DragLeave:
Widget.DragLeave += HandleWidgetDragLeave;
break;
case WidgetEvent.KeyPressed:
Widget.KeyPressEvent += HandleKeyPressEvent;
break;
case WidgetEvent.KeyReleased:
Widget.KeyReleaseEvent += HandleKeyReleaseEvent;
break;
case WidgetEvent.GotFocus:
Widget.FocusInEvent += HandleWidgetFocusInEvent;
break;
case WidgetEvent.LostFocus:
Widget.FocusOutEvent += HandleWidgetFocusOutEvent;
break;
case WidgetEvent.MouseEntered:
AllocEventBox();
EventsRootWidget.Events |= Gdk.EventMask.EnterNotifyMask;
EventsRootWidget.EnterNotifyEvent += HandleEnterNotifyEvent;
break;
case WidgetEvent.MouseExited:
AllocEventBox();
EventsRootWidget.Events |= Gdk.EventMask.LeaveNotifyMask;
EventsRootWidget.LeaveNotifyEvent += HandleLeaveNotifyEvent;
break;
}
if ((ev & dragDropEvents) != 0 && (enabledEvents & dragDropEvents) == 0)
{
// Enabling a drag&drop event for the first time
Widget.DragDrop += HandleWidgetDragDrop;
Widget.DragMotion += HandleWidgetDragMotion;
Widget.DragDataReceived += HandleWidgetDragDataReceived;
}
if ((ev & sizeCheckEvents) != 0)
{
EnableSizeCheckEvents();
}
enabledEvents |= ev;
}
}
public MenuElement(string label, bool enabled = true, WidgetEvent action = null, List <MenuElement> children = null)
{
Label = label;
Enabled = enabled;
if (action != null)
{
Action = action;
}
if (children != null)
{
m_Children = children;
}
}
public virtual void DisableEvent(object eventId)
{
if (eventId is WidgetEvent)
{
WidgetEvent ev = (WidgetEvent)eventId;
switch (ev)
{
case WidgetEvent.DragLeave:
Widget.DragLeave -= HandleWidgetDragLeave;
break;
case WidgetEvent.KeyPressed:
Widget.KeyPressEvent -= HandleKeyPressEvent;
break;
case WidgetEvent.KeyReleased:
Widget.KeyReleaseEvent -= HandleKeyReleaseEvent;
break;
case WidgetEvent.GotFocus:
Widget.FocusInEvent -= HandleWidgetFocusInEvent;
break;
case WidgetEvent.LostFocus:
Widget.FocusOutEvent -= HandleWidgetFocusOutEvent;
break;
case WidgetEvent.MouseEntered:
EventsRootWidget.EnterNotifyEvent -= HandleEnterNotifyEvent;
break;
case WidgetEvent.MouseExited:
EventsRootWidget.LeaveNotifyEvent -= HandleLeaveNotifyEvent;
break;
}
enabledEvents &= ~ev;
if ((ev & dragDropEvents) != 0 && (enabledEvents & dragDropEvents) == 0)
{
// All drag&drop events have been disabled
Widget.DragDrop -= HandleWidgetDragDrop;
Widget.DragMotion -= HandleWidgetDragMotion;
Widget.DragDataReceived -= HandleWidgetDragDataReceived;
}
if ((ev & sizeCheckEvents) != 0)
{
DisableSizeCheckEvents();
}
}
}
public void Send(WidgetEvent _event)
{
if (m_Dispatch == null || !m_Dispatch.ContainsKey(_event))
{
return;
}
List <Action> actionsList = m_Dispatch[_event];
foreach (Action act in actionsList)
{
act.Invoke();
}
}
// IWidgetEventListener
public override void OnWidgetEvent(WidgetEvent widgetEvent)
{
if (widgetEvent.EventType == WidgetEvent.eEventType.mouseWheel)
{
WidgetEvent.MousWheelEventParameters wheelEvent =
(WidgetEvent.MousWheelEventParameters)widgetEvent.EventParameters;
Scroll(wheelEvent.delta);
}
else
{
base.OnWidgetEvent(widgetEvent);
}
}
private static void HandleUicolorwidgetEvent(WidgetEvent ev)
{
UIWidget widget = (UIWidget)ev.Target;
if (widget.Equals(null))
{
return;
}
if (ev.Type == UI_EVENT_TYPE.UI_EVENT_TYPE_CLICK)
{
if (widget.GetId() == "uicolorwidgetcode")
{
AtomicMain.AppLog("UIColorWidget support : " + widget.GetId() + " was pressed ");
AtomicMain.ViewCode("Components/code_uicolorwidget.cs", widget.GetParent());
}
if (widget.GetId() == "uicolorwidgetlayout")
{
AtomicMain.AppLog("UIColorWidget support : " + widget.GetId() + " was pressed ");
AtomicMain.ViewCode("Scenes/layout_uicolorwidget.ui.txt", widget.GetParent());
}
if (widget.GetId() == "uicolorwidgetred")
{
AtomicMain.AppLog("UIColorWidget action : " + widget.GetId() + " was pressed ");
UIColorWidget clw = (UIColorWidget)widget.FindWidget("colorwidgetdemo");
if (!clw.Equals(null))
{
clw.SetColorString("#FF1111");
}
}
if (widget.GetId() == "uicolorwidgetgreen")
{
AtomicMain.AppLog("UIColorWidget action : " + widget.GetId() + " was pressed ");
UIColorWidget clw = (UIColorWidget)widget.FindWidget("colorwidgetdemo");
if (!clw.Equals(null))
{
clw.SetColorString("#11FF11");
}
}
if (widget.GetId() == "uicolorwidgetblue")
{
AtomicMain.AppLog("UIColorWidget action : " + widget.GetId() + " was pressed ");
UIColorWidget clw = (UIColorWidget)widget.FindWidget("colorwidgetdemo");
if (!clw.Equals(null))
{
clw.SetColorString("#1111FF");
}
}
}
}
// IWidgetEventListener
public override void OnWidgetEvent(WidgetEvent widgetEvent)
{
if (widgetEvent.EventType == WidgetEvent.eEventType.mouseDrag)
{
WidgetEvent.MouseDragEventParameters dragEvent=
widgetEvent.EventParameters as WidgetEvent.MouseDragEventParameters;
this.SetLocalPosition(this.LocalX + dragEvent.deltaX, this.LocalY + dragEvent.deltaY);
}
else
{
base.OnWidgetEvent(widgetEvent);
}
}
private static void HandleUimenuwindowEvent(WidgetEvent ev)
{
UIWidget widget = (UIWidget)ev.Target;
string refid = (string)ev.RefID;
if (widget.Equals(null))
{
return;
}
if (ev.Type == UI_EVENT_TYPE.UI_EVENT_TYPE_CLICK)
{
if (widget.GetId() == "uimenuwindowcode")
{
AtomicMain.AppLog("UIMenuWindow support : " + widget.GetId() + " was pressed ");
AtomicMain.ViewCode("Components/code_uimenuwindow.cs", widget.GetParent());
}
if (widget.GetId() == "uimenuwindowlayout")
{
AtomicMain.AppLog("UIMenuWindow support : " + widget.GetId() + " was pressed ");
AtomicMain.ViewCode("Scenes/layout_uimenuwindow.ui.txt", widget.GetParent());
}
if (widget.GetId() == "uimenuwindowpush")
{
AtomicMain.AppLog("UIMenuWindow action : " + widget.GetId() + " was pressed ");
UIMenuWindow mymenuwindow = new UIMenuWindow(widget, "MenuWindowDemo");
UIMenuItemSource mis = new UIMenuItemSource();
mis.AddItem(new UIMenuItem("UISelectItem1", "item1"));
mis.AddItem(new UIMenuItem("UISelectItem2", "item2", "Ctrl+C"));
mis.AddItem(new UIMenuItem("UISelectItem3", "item3", "Ctrl+A", "DuckButton"));
mis.AddItem(new UIMenuItem("UISelectItem4", "item4", "Ctrl+O", "LogoAtomic"));
int xx = widget.GetX() + (widget.GetWidth() / 2);
int yy = widget.GetY() + (widget.GetHeight() / 2);
mymenuwindow.SubscribeToEvent <WidgetEvent> (mymenuwindow, HandleUimenuwindowEvent);
mymenuwindow.Show(mis, xx, yy);
}
if (widget.GetId() == "MenuWindowDemo")
{
AtomicMain.AppLog("UIMenuWindow event : " + widget.GetId() + " and " + refid + " was selected ");
}
}
else
{
if (widget.GetId() == "MenuWindowDemo")
{
AtomicMain.AppLog("UIMenuWindow event : " + widget.GetId() + " refid=" + refid + " event type=" + AtomicMain.EventReport((int)ev.Type));
}
}
}
// IWidgetEventListener
public override void OnWidgetEvent(WidgetEvent widgetEvent)
{
if (widgetEvent.EventType == WidgetEvent.eEventType.mouseDrag)
{
WidgetEvent.MouseDragEventParameters dragEvent =
widgetEvent.EventParameters as WidgetEvent.MouseDragEventParameters;
this.SetLocalPosition(this.LocalX + dragEvent.deltaX, this.LocalY + dragEvent.deltaY);
}
else
{
base.OnWidgetEvent(widgetEvent);
}
}
public TilesetAllInOne(int x, int y, int width, int height, WidgetEvent onClick)
{
Area = new Rectangle(x, y, width, height);
RenderRule.SetSize(width, height);
OnClick += onClick;
m_Attributes = new byte[Data.TileSet.TilesPerSet];
m_Tiles = new byte[Data.TileSet.TilesPerSet][];
m_Textures = new Texture2D[Data.TileSet.TilesPerSet][];
for (int i = 0; i < Data.TileSet.TilesPerSet; i++)
{
m_Tiles[i] = new byte[4];
m_Textures[i] = new Texture2D[4];
}
}
void SendToAll(WidgetEvent _event)
{
if (m_CurrentWidgets == null)
{
return;
}
foreach (IWidget widget in m_CurrentWidgets)
{
if (widget.gameObject.activeInHierarchy && widget.enabled)
{
widget.Send(_event);
}
}
}
private static void HandleAllTabcontainerEvent(WidgetEvent ev)
{
UIWidget widget = (UIWidget)ev.Target;
if (widget.Equals(null))
{
return;
}
if (widget.GetId() == "UITabContainerDemo" && ev.Type == UI_EVENT_TYPE.UI_EVENT_TYPE_TAB_CHANGED)
{
UITabContainer tcx = (UITabContainer)widget; // check the focus & stuff, or it gets a little spammy
AtomicMain.AppLog("UITabContainer event : " + widget.GetId() + " UI_EVENT_TYPE_TAB_CHANGED to " + tcx.GetCurrentPage().ToString()
+ " id: " + tcx.GetCurrentPageWidget().GetId());
}
}
public virtual void DisableEvent(object eventId)
{
if (eventId is WidgetEvent)
{
WidgetEvent ev = (WidgetEvent)eventId;
switch (ev)
{
case WidgetEvent.DragDropCheck:
dropCheckEventEnabled = false;
break;
case WidgetEvent.DragDrop:
dropEventEnabled = false;
break;
case WidgetEvent.DragOverCheck:
dragMotionCheckEventEnabled = false;
break;
case WidgetEvent.DragOver:
dragMotionEventEnabled = false;
break;
case WidgetEvent.DragLeave:
Widget.DragLeave -= HandleWidgetDragLeave;
break;
case WidgetEvent.KeyPressed:
Widget.KeyPressEvent -= HandleKeyPressEvent;
break;
case WidgetEvent.KeyReleased:
Widget.KeyReleaseEvent -= HandleKeyReleaseEvent;
break;
}
if (!dropEventEnabled && !dropCheckEventEnabled && !dragMotionCheckEventEnabled && !dragMotionEventEnabled)
{
if (dragEventsSet)
{
dragEventsSet = false;
Widget.DragDrop -= HandleWidgetDragDrop;
Widget.DragMotion -= HandleWidgetDragMotion;
Widget.DragDataReceived -= HandleWidgetDragDataReceived;
}
}
}
}
void SendToWidgetsWithFocus(WidgetEvent _event)
{
if (m_CurrentWidgets == null)
{
return;
}
List <IWidget> widgetWithFocus = m_CurrentWidgets.ToList().FindAll(item => item.HasFocus());
foreach (IWidget widget in widgetWithFocus)
{
if (widget.gameObject.activeInHierarchy && widget.enabled)
{
widget.Send(_event);
}
}
}
private static void HandleUiradiobuttonEvent(WidgetEvent ev)
{
UIWidget widget = (UIWidget)ev.Target;
if (widget.Equals(null))
{
return;
}
if (ev.Type == UI_EVENT_TYPE.UI_EVENT_TYPE_CLICK)
{
if (widget.GetId() == "uiradiobuttoncode")
{
AtomicMain.AppLog("UIRadioButton support : " + widget.GetId() + " was pressed ");
AtomicMain.ViewCode("Components/code_uiradiobutton.cs", widget.GetParent());
}
if (widget.GetId() == "uiradiobuttonlayout")
{
AtomicMain.AppLog("UIRadioButton support : " + widget.GetId() + " was pressed ");
AtomicMain.ViewCode("Scenes/layout_uiradiobutton.ui.txt", widget.GetParent());
}
if (widget.GetId() == "demoradio")
{
AtomicMain.AppLog("UIRadioButton event : " + widget.GetId() + " was pressed, state = " + widget.GetValue().ToString());
}
if (widget.GetId() == "radioset")
{
UIWidget demochk = widget.FindWidget("demoradio");
if (!demochk.Equals(null))
{
demochk.SetValue(1);
AtomicMain.AppLog("UIRadioButton action : " + widget.GetId() + " was pressed, set state to 1");
}
}
if (widget.GetId() == "radiounset")
{
UIWidget demochk = widget.FindWidget("demoradio");
if (!demochk.Equals(null))
{
demochk.SetValue(0);
AtomicMain.AppLog("UIRadioButton action : " + widget.GetId() + " was pressed, set state to 0");
}
}
}
}
private static void HandleUiinlineselectEvent(WidgetEvent ev)
{
UIWidget widget = (UIWidget)ev.Target;
if (widget.Equals(null))
{
return;
}
if (ev.Type == UI_EVENT_TYPE.UI_EVENT_TYPE_CLICK)
{
if (widget.GetId() == "uiinlineselectcode")
{
AtomicMain.AppLog("UIInlineSelect support : " + widget.GetId() + " was pressed ");
AtomicMain.ViewCode("Components/code_uiinlineselect.cs", widget.GetParent());
}
if (widget.GetId() == "uiinlineselectlayout")
{
AtomicMain.AppLog("UIInlineSelect support : " + widget.GetId() + " was pressed ");
AtomicMain.ViewCode("Scenes/layout_uiinlineselect.ui.txt", widget.GetParent());
}
}
else if (ev.Type == UI_EVENT_TYPE.UI_EVENT_TYPE_CHANGED)
{
if (widget.GetId() == "inlineselectdemo")
{
UIInlineSelect ils = (UIInlineSelect)widget;
if (!ils.Equals(null))
{
AtomicMain.AppLog("UIInlineSelect event : " + widget.GetId() + " changed value to " + ils.GetValue().ToString());
}
}
if (widget.GetId() == "ilsstep")
{
UISlider steps = (UISlider)widget;
if (!steps.Equals(null))
{
UIInlineSelect ils = (UIInlineSelect)widget.FindWidget("inlineselectdemo");
if (!ils.Equals(null))
{
ils.SetStepSize(steps.GetValue());
}
AtomicMain.AppLog("UIInlineSelect event : " + widget.GetId() + " step size changed to " + steps.GetValue().ToString());
}
}
}
}
private static void HandleAllSelectdropdownEvent(WidgetEvent ev)
{
UIWidget widget = (UIWidget)ev.Target;
if (widget.Equals(null))
{
return;
}
if (ev.Type == UI_EVENT_TYPE.UI_EVENT_TYPE_CHANGED)
{
if (widget.GetId() == "selectdropdowndemo")
{
AtomicMain.AppLog("UISelectDropdown event : " + widget.GetId() + " changed value to " + widget.GetText());
}
}
}
private static void HandleAllScrollcontainerEvent(WidgetEvent ev)
{
UIWidget widget = (UIWidget)ev.Target;
if (widget.Equals(null))
{
return;
}
if (ev.Type == UI_EVENT_TYPE.UI_EVENT_TYPE_CHANGED)
{
if (widget.GetId() == "scrollbardemo")
{
AtomicMain.AppLog("UIScrollBar action : " + widget.GetId() + " changed value to " + widget.GetValue().ToString());
}
}
}
private static void HandleUitexturewidgetEvent(WidgetEvent ev)
{
UIWidget widget = (UIWidget)ev.Target;
if (widget.Equals(null))
{
return;
}
if (ev.Type == UI_EVENT_TYPE.UI_EVENT_TYPE_CLICK)
{
if (widget.GetId() == "uitexturewidgetcode")
{
AtomicMain.AppLog("UITextureWidget support : " + widget.GetId() + " was pressed ");
AtomicMain.ViewCode("Components/code_uitexturewidget.cs", widget.GetParent());
}
if (widget.GetId() == "uitexturewidgetlayout")
{
AtomicMain.AppLog("UITextureWidget support : " + widget.GetId() + " was pressed ");
AtomicMain.ViewCode("Scenes/layout_uitexturewidget.ui.txt", widget.GetParent());
}
if (widget.GetId() == "uitexturewidgetch1")
{
AtomicMain.AppLog("UITextureWidget support : " + widget.GetId() + " was pressed ");
var cache = GetSubsystem <ResourceCache>();
UITextureWidget tw = (UITextureWidget)widget.FindWidget("UITextureWidgetDemo");
tw.SetTexture(cache.GetResource <Texture2D>("Textures/newbuilddetected_header.jpg"));
}
if (widget.GetId() == "uitexturewidgetch2")
{
AtomicMain.AppLog("UITextureWidget support : " + widget.GetId() + " was pressed ");
var cache = GetSubsystem <ResourceCache>();
UITextureWidget tw = (UITextureWidget)widget.FindWidget("UITextureWidgetDemo");
tw.SetTexture(cache.GetResource <Texture2D>("Textures/HSV21.png"));
}
if (widget.GetId() == "uitexturewidgetch3")
{
AtomicMain.AppLog("UITextureWidget support : " + widget.GetId() + " was pressed ");
var cache = GetSubsystem <ResourceCache>();
UITextureWidget tw = (UITextureWidget)widget.FindWidget("UITextureWidgetDemo");
tw.SetTexture(cache.GetResource <Texture2D>("Textures/planet.jpg"));
}
}
}
// IWidgetEventListener
public void OnWidgetEvent(WidgetEvent widgetEvent)
{
if (widgetEvent.EventSource == m_createButton)
{
CreateCharacterController.OnCreateCharacterClicked();
}
else if (widgetEvent.EventSource == m_cancelButton)
{
CreateCharacterController.OnCancelClicked();
}
else if (widgetEvent.EventSource == m_previousPortraitButton)
{
CreateCharacterController.OnPreviousPortraitClicked();
}
else if (widgetEvent.EventSource == m_nextPortraitButton)
{
CreateCharacterController.OnNextPortraitClicked();
}
}
// IWidgetEventListener
public void OnWidgetEvent(WidgetEvent widgetEvent)
{
if (widgetEvent.EventSource == m_createButton)
{
CreateCharacterController.OnCreateCharacterClicked();
}
else if (widgetEvent.EventSource == m_cancelButton)
{
CreateCharacterController.OnCancelClicked();
}
else if (widgetEvent.EventSource == m_previousPortraitButton)
{
CreateCharacterController.OnPreviousPortraitClicked();
}
else if (widgetEvent.EventSource == m_nextPortraitButton)
{
CreateCharacterController.OnNextPortraitClicked();
}
}
private static void HandleUibuttonEvent(WidgetEvent ev)
{
UIWidget widget = (UIWidget)ev.Target;
if (widget.Equals(null))
{
return;
}
if (ev.Type == UI_EVENT_TYPE.UI_EVENT_TYPE_CLICK)
{
if (widget.GetId() == "uibuttoncode")
{
AtomicMain.AppLog("UIButton support : " + widget.GetId() + " was pressed ");
AtomicMain.ViewCode("Components/code_uibutton.cs", widget.GetParent());
}
if (widget.GetId() == "uibuttonlayout")
{
AtomicMain.AppLog("UIButton support : " + widget.GetId() + " was pressed ");
AtomicMain.ViewCode("Scenes/layout_uibutton.ui.txt", widget.GetParent());
}
if (widget.GetId() == "demobutton")
{
AtomicMain.AppLog("UIButton action : " + widget.GetId() + " was pressed ");
}
if (widget.GetId() == "buttonducky")
{
AtomicMain.AppLog("UIButton action : " + widget.GetId() + " was pressed ");
}
if (widget.GetId() == "buttonready")
{
AtomicMain.AppLog("UIButton action : " + widget.GetId() + " was pressed ");
}
if (widget.GetId() == "buttonatomic")
{
AtomicMain.AppLog("UIButton action : " + widget.GetId() + " was pressed ");
}
if (widget.GetId() == "buttongreen")
{
AtomicMain.AppLog("UIButton action : " + widget.GetId() + " was pressed ");
}
}
}
private static void HandleUifontdescriptionEvent(WidgetEvent ev)
{
UIWidget widget = (UIWidget)ev.Target;
if (widget.Equals(null))
{
return;
}
if (ev.Type == UI_EVENT_TYPE.UI_EVENT_TYPE_CLICK)
{
if (widget.GetId() == "uifontdescriptioncode")
{
AtomicMain.AppLog("UIFontdescription support : " + widget.GetId() + " was pressed ");
AtomicMain.ViewCode("Components/code_uifontdescription.cs", widget.GetParent());
}
if (widget.GetId() == "uifontdescriptionlayout")
{
AtomicMain.AppLog("UIFontdescription support : " + widget.GetId() + " was pressed ");
AtomicMain.ViewCode("Scenes/layout_uifontdescription.ui.txt", widget.GetParent());
}
}
else if (ev.Type == UI_EVENT_TYPE.UI_EVENT_TYPE_CHANGED)
{
if (widget.GetId() == "fontstep")
{
UISlider uis = (UISlider)widget;
if (!uis.Equals(null))
{
UITextField mytext = (UITextField)widget.FindWidget("changetext");
UIFontDescription myfont = new UIFontDescription();
int mysize = (int)uis.GetValue();
myfont.SetSize(mysize);
myfont.SetId("Vera");
mytext.SetFontDescription(myfont);
mytext.SetText("Size " + mysize);
AtomicMain.AppLog("UIFontdescription action : " + widget.GetId() + " step size changed to " + mysize);
}
}
}
}
private static void HandleUiskinimageEvent(WidgetEvent ev)
{
UIWidget widget = (UIWidget)ev.Target;
if (widget.Equals(null))
{
return;
}
if (ev.Type == UI_EVENT_TYPE.UI_EVENT_TYPE_CLICK)
{
if (widget.GetId() == "uiskinimagecode")
{
AtomicMain.AppLog("UISkinImage support : " + widget.GetId() + " was pressed ");
AtomicMain.ViewCode("Components/code_uiskinimage.cs", widget.GetParent());
}
if (widget.GetId() == "uiskinimagelayout")
{
AtomicMain.AppLog("UISkinImage support : " + widget.GetId() + " was pressed ");
AtomicMain.ViewCode("Scenes/layout_uiskinimage.ui.txt", widget.GetParent());
}
}
}
private static void HandleUifinderwindowEvent(WidgetEvent ev)
{
UIWidget widget = (UIWidget)ev.Target;
if (widget.Equals(null))
{
return;
}
if (ev.Type == UI_EVENT_TYPE.UI_EVENT_TYPE_CLICK)
{
if (widget.GetId() == "uifinderwindowcode")
{
AtomicMain.AppLog("UIFinderWindow support : " + widget.GetId() + " was pressed ");
AtomicMain.ViewCode("Components/code_uifinderwindow.cs", widget.GetParent());
}
if (widget.GetId() == "uifinderwindowlayout")
{
AtomicMain.AppLog("UIFinderWindow support : " + widget.GetId() + " was pressed ");
AtomicMain.ViewCode("Scenes/layout_uifinderwindow.ui.txt", widget.GetParent());
}
if (widget.GetId() == "filefinder")
{
AtomicMain.AppLog("UIFinderWindow action : " + widget.GetId() + " was pressed ");
UIWidget someview = (UIWidget)widget.GetView();
UIFinderWindow windowf = new UIFinderWindow(someview, widget.GetId());
windowf.SubscribeToEvent <UIFinderCompleteEvent> (windowf, HandleFinderCompleteEvent);
windowf.FindFile("Find a File", "", 0, 0, 0);
}
if (widget.GetId() == "folderfinder")
{
AtomicMain.AppLog("UIFinderWindow action : " + widget.GetId() + " was pressed ");
UIWidget someview = (UIWidget)widget.GetView();
UIFinderWindow windowd = new UIFinderWindow(someview, widget.GetId());
windowd.SubscribeToEvent <UIFinderCompleteEvent> (windowd, HandleFinderCompleteEvent);
windowd.FindPath("Find a Folder", "", 0, 0, 0);
}
}
}
// IWidgetEventListener
public void OnWidgetEvent(WidgetEvent widgetEvent)
{
if (widgetEvent.EventSource == m_gameCreateButton)
{
SelectGameController.OnGameCreateClicked();
}
else if (widgetEvent.EventSource == m_gameDeleteButton)
{
SelectGameController.OnGameDeleteClicked();
}
else if (widgetEvent.EventSource == m_gameSelectButton)
{
SelectGameController.OnGameSelectClicked();
}
else if (widgetEvent.EventSource == m_gameScrollList && widgetEvent.EventType == WidgetEvent.eEventType.listSelectionChanged)
{
WidgetEvent.ListSelectionChangedEventParameters eventParameters=
(WidgetEvent.ListSelectionChangedEventParameters)widgetEvent.EventParameters;
OnSelectedGameChanged(eventParameters.ListIndex);
}
}
// IWidgetEventListener
public void OnWidgetEvent(WidgetEvent widgetEvent)
{
if (widgetEvent.EventSource == m_gameCreateButton)
{
SelectGameController.OnGameCreateClicked();
}
else if (widgetEvent.EventSource == m_gameDeleteButton)
{
SelectGameController.OnGameDeleteClicked();
}
else if (widgetEvent.EventSource == m_gameSelectButton)
{
SelectGameController.OnGameSelectClicked();
}
else if (widgetEvent.EventSource == m_gameScrollList && widgetEvent.EventType == WidgetEvent.eEventType.listSelectionChanged)
{
WidgetEvent.ListSelectionChangedEventParameters eventParameters =
(WidgetEvent.ListSelectionChangedEventParameters)widgetEvent.EventParameters;
OnSelectedGameChanged(eventParameters.ListIndex);
}
}
// IWidgetEventListener
public override void OnWidgetEvent(WidgetEvent widgetEvent)
{
bool handled = false;
if (widgetEvent.EventType == WidgetEvent.eEventType.buttonClick)
{
if (widgetEvent.EventSource == m_scrollUpButton)
{
OnScrollUpClicked();
handled = true;
}
else if (widgetEvent.EventSource == m_scrollDownButton)
{
OnScrollDownClicked();
handled = true;
}
}
if (!handled)
{
base.OnWidgetEvent(widgetEvent);
}
}
public override void DisableEvent(object eventId)
{
if (eventId is WidgetEvent) {
var ev = (WidgetEvent)eventId;
switch (ev) {
case WidgetEvent.KeyPressed:
Widget.KeyDown -= WidgetKeyDownHandler;
break;
case WidgetEvent.KeyReleased:
Widget.KeyUp -= WidgetKeyUpHandler;
break;
case WidgetEvent.ButtonPressed:
Widget.MouseDown -= WidgetMouseDownHandler;
break;
case WidgetEvent.ButtonReleased:
Widget.MouseUp -= WidgetMouseUpHandler;
break;
case WidgetEvent.MouseEntered:
Widget.MouseEnter -= WidgetMouseEnteredHandler;
break;
case WidgetEvent.MouseExited:
Widget.MouseLeave -= WidgetMouseExitedHandler;
break;
case WidgetEvent.MouseMoved:
Widget.MouseMove -= WidgetMouseMoveHandler;
break;
case WidgetEvent.BoundsChanged:
Widget.SizeChanged -= WidgetOnSizeChanged;
break;
case WidgetEvent.MouseScrolled:
Widget.MouseWheel -= WidgetMouseWheelHandler;
break;
}
enabledEvents &= ~ev;
if ((ev & dragDropEvents) != 0 && (enabledEvents & dragDropEvents) == 0) {
// All drag&drop events have been disabled
Widget.DragOver -= WidgetDragOverHandler;
Widget.Drop -= WidgetDropHandler;
Widget.DragLeave -= WidgetDragLeaveHandler;
}
}
}
public override void EnableEvent(object eventId)
{
if (eventId is WidgetEvent) {
var ev = (WidgetEvent)eventId;
switch (ev) {
case WidgetEvent.KeyPressed:
Widget.KeyDown += WidgetKeyDownHandler;
break;
case WidgetEvent.KeyReleased:
Widget.KeyDown += WidgetKeyUpHandler;
break;
case WidgetEvent.ButtonPressed:
Widget.MouseDown += WidgetMouseDownHandler;
break;
case WidgetEvent.ButtonReleased:
Widget.MouseUp += WidgetMouseUpHandler;
break;
case WidgetEvent.GotFocus:
Widget.GotFocus += WidgetGotFocusHandler;
break;
case WidgetEvent.LostFocus:
Widget.LostFocus += WidgetLostFocusHandler;
break;
case WidgetEvent.MouseEntered:
Widget.MouseEnter += WidgetMouseEnteredHandler;
break;
case WidgetEvent.MouseExited:
Widget.MouseLeave += WidgetMouseExitedHandler;
break;
case WidgetEvent.MouseMoved:
Widget.MouseMove += WidgetMouseMoveHandler;
break;
case WidgetEvent.BoundsChanged:
Widget.SizeChanged += WidgetOnSizeChanged;
break;
case WidgetEvent.MouseScrolled:
Widget.MouseWheel += WidgetMouseWheelHandler;
break;
}
if ((ev & dragDropEvents) != 0 && (enabledEvents & dragDropEvents) == 0) {
// Enabling a drag&drop event for the first time
Widget.DragOver += WidgetDragOverHandler;
Widget.Drop += WidgetDropHandler;
widget.DragLeave += WidgetDragLeaveHandler;
}
enabledEvents |= ev;
}
}
public virtual void OnWidgetEvent(WidgetEvent widgetEvent)
{
if (m_widgetEventListener != null)
{
m_widgetEventListener.OnWidgetEvent(widgetEvent);
}
else if (m_parentWidgetGroup != null)
{
m_parentWidgetGroup.OnWidgetEvent(widgetEvent);
}
}
// IWidgetEventListener
public void OnWidgetEvent(WidgetEvent widgetEvent)
{
if (widgetEvent.EventSource == m_createAccountButton)
{
loginController.OnCreateAccountClicked();
}
else if (widgetEvent.EventSource == m_loginButton)
{
loginController.OnLoginClicked();
}
else if (widgetEvent.EventSource == m_localHostCheckBox)
{
bool hostServerLocally= m_localHostCheckBox.Enabled;
m_localHostLabel.Visible= hostServerLocally;
m_serverText.Visible= !hostServerLocally;
// If we're turning on the server,
// show initialization status in the server status panel
SetServerStatusVisible(hostServerLocally);
// The the login controller about the change in server hosting
loginController.OnLocalHostToggled(hostServerLocally);
}
else if (widgetEvent.EventSource == m_serverOkButton)
{
// Hide the server status panel
SetServerStatusVisible(false);
}
}
public virtual void DisableEvent(object eventId)
{
if (eventId is WidgetEvent) {
WidgetEvent ev = (WidgetEvent) eventId;
switch (ev) {
case WidgetEvent.DragLeave:
Widget.DragLeave -= HandleWidgetDragLeave;
break;
case WidgetEvent.KeyPressed:
Widget.KeyPressEvent -= HandleKeyPressEvent;
break;
case WidgetEvent.KeyReleased:
Widget.KeyReleaseEvent -= HandleKeyReleaseEvent;
break;
case WidgetEvent.GotFocus:
Widget.FocusInEvent -= HandleWidgetFocusInEvent;
break;
case WidgetEvent.LostFocus:
Widget.FocusOutEvent -= HandleWidgetFocusOutEvent;
break;
case WidgetEvent.MouseEntered:
EventsRootWidget.EnterNotifyEvent -= HandleEnterNotifyEvent;
break;
case WidgetEvent.MouseExited:
EventsRootWidget.LeaveNotifyEvent -= HandleLeaveNotifyEvent;
break;
case WidgetEvent.ButtonPressed:
EventsRootWidget.Events &= ~Gdk.EventMask.ButtonPressMask;
EventsRootWidget.ButtonPressEvent -= HandleButtonPressEvent;
break;
case WidgetEvent.ButtonReleased:
EventsRootWidget.Events &= Gdk.EventMask.ButtonReleaseMask;
EventsRootWidget.ButtonReleaseEvent -= HandleButtonReleaseEvent;
break;
case WidgetEvent.MouseMoved:
EventsRootWidget.Events &= Gdk.EventMask.PointerMotionMask;
EventsRootWidget.MotionNotifyEvent -= HandleMotionNotifyEvent;
break;
}
enabledEvents &= ~ev;
if ((ev & dragDropEvents) != 0 && (enabledEvents & dragDropEvents) == 0) {
// All drag&drop events have been disabled
Widget.DragDrop -= HandleWidgetDragDrop;
Widget.DragMotion -= HandleWidgetDragMotion;
Widget.DragDataReceived -= HandleWidgetDragDataReceived;
}
if ((ev & sizeCheckEvents) != 0) {
DisableSizeCheckEvents ();
}
}
}
public virtual void EnableEvent(object eventId)
{
if (eventId is WidgetEvent) {
WidgetEvent ev = (WidgetEvent) eventId;
switch (ev) {
case WidgetEvent.DragLeave:
Widget.DragLeave += HandleWidgetDragLeave;
break;
case WidgetEvent.KeyPressed:
Widget.KeyPressEvent += HandleKeyPressEvent;
break;
case WidgetEvent.KeyReleased:
Widget.KeyReleaseEvent += HandleKeyReleaseEvent;
break;
case WidgetEvent.GotFocus:
Widget.FocusInEvent += HandleWidgetFocusInEvent;
break;
case WidgetEvent.LostFocus:
Widget.FocusOutEvent += HandleWidgetFocusOutEvent;
break;
case WidgetEvent.MouseEntered:
AllocEventBox ();
EventsRootWidget.Events |= Gdk.EventMask.EnterNotifyMask;
EventsRootWidget.EnterNotifyEvent += HandleEnterNotifyEvent;
break;
case WidgetEvent.MouseExited:
AllocEventBox ();
EventsRootWidget.Events |= Gdk.EventMask.LeaveNotifyMask;
EventsRootWidget.LeaveNotifyEvent += HandleLeaveNotifyEvent;
break;
case WidgetEvent.ButtonPressed:
AllocEventBox ();
EventsRootWidget.Events |= Gdk.EventMask.ButtonPressMask;
EventsRootWidget.ButtonPressEvent += HandleButtonPressEvent;
break;
case WidgetEvent.ButtonReleased:
AllocEventBox ();
EventsRootWidget.Events |= Gdk.EventMask.ButtonReleaseMask;
EventsRootWidget.ButtonReleaseEvent += HandleButtonReleaseEvent;
break;
case WidgetEvent.MouseMoved:
AllocEventBox ();
EventsRootWidget.Events |= Gdk.EventMask.PointerMotionMask;
EventsRootWidget.MotionNotifyEvent += HandleMotionNotifyEvent;
break;
}
if ((ev & dragDropEvents) != 0 && (enabledEvents & dragDropEvents) == 0) {
// Enabling a drag&drop event for the first time
Widget.DragDrop += HandleWidgetDragDrop;
Widget.DragMotion += HandleWidgetDragMotion;
Widget.DragDataReceived += HandleWidgetDragDataReceived;
}
if ((ev & sizeCheckEvents) != 0) {
EnableSizeCheckEvents ();
}
enabledEvents |= ev;
}
}
public virtual void EnableEvent(object eventId)
{
if (eventId is WidgetEvent) {
WidgetEvent ev = (WidgetEvent) eventId;
switch (ev) {
case WidgetEvent.DragLeave:
AllocEventBox ();
EventsRootWidget.DragLeave += HandleWidgetDragLeave;
break;
case WidgetEvent.DragStarted:
AllocEventBox ();
EventsRootWidget.DragBegin += HandleWidgetDragBegin;
break;
case WidgetEvent.KeyPressed:
Widget.KeyPressEvent += HandleKeyPressEvent;
break;
case WidgetEvent.KeyReleased:
Widget.KeyReleaseEvent += HandleKeyReleaseEvent;
break;
case WidgetEvent.GotFocus:
EventsRootWidget.AddEvents ((int)Gdk.EventMask.FocusChangeMask);
Widget.FocusGrabbed += HandleWidgetFocusInEvent;
break;
case WidgetEvent.LostFocus:
EventsRootWidget.AddEvents ((int)Gdk.EventMask.FocusChangeMask);
Widget.FocusOutEvent += HandleWidgetFocusOutEvent;
break;
case WidgetEvent.MouseEntered:
AllocEventBox ();
EventsRootWidget.AddEvents ((int)Gdk.EventMask.EnterNotifyMask);
EventsRootWidget.EnterNotifyEvent += HandleEnterNotifyEvent;
break;
case WidgetEvent.MouseExited:
AllocEventBox ();
EventsRootWidget.AddEvents ((int)Gdk.EventMask.LeaveNotifyMask);
EventsRootWidget.LeaveNotifyEvent += HandleLeaveNotifyEvent;
break;
case WidgetEvent.ButtonPressed:
AllocEventBox ();
EventsRootWidget.AddEvents ((int)Gdk.EventMask.ButtonPressMask);
EventsRootWidget.ButtonPressEvent += HandleButtonPressEvent;
break;
case WidgetEvent.ButtonReleased:
AllocEventBox ();
EventsRootWidget.AddEvents ((int)Gdk.EventMask.ButtonReleaseMask);
EventsRootWidget.ButtonReleaseEvent += HandleButtonReleaseEvent;
break;
case WidgetEvent.MouseMoved:
AllocEventBox ();
EventsRootWidget.AddEvents ((int)Gdk.EventMask.PointerMotionMask);
EventsRootWidget.MotionNotifyEvent += HandleMotionNotifyEvent;
break;
case WidgetEvent.BoundsChanged:
Widget.SizeAllocated += HandleWidgetBoundsChanged;
break;
case WidgetEvent.MouseScrolled:
AllocEventBox();
EventsRootWidget.AddEvents ((int)Gdk.EventMask.ScrollMask);
Widget.ScrollEvent += HandleScrollEvent;
break;
}
if ((ev & dragDropEvents) != 0 && (enabledEvents & dragDropEvents) == 0) {
// Enabling a drag&drop event for the first time
AllocEventBox ();
EventsRootWidget.DragDrop += HandleWidgetDragDrop;
EventsRootWidget.DragMotion += HandleWidgetDragMotion;
EventsRootWidget.DragDataReceived += HandleWidgetDragDataReceived;
}
if ((ev & WidgetEvent.PreferredSizeCheck) != 0) {
EnableSizeCheckEvents ();
}
enabledEvents |= ev;
}
}
// Events
public void OnWidgetEvent(WidgetEvent widgetEvent)
{
if (widgetEvent.EventType == WidgetEvent.eEventType.mouseMove)
{
UpdateCurrentNavRef();
}
if (widgetEvent.EventSource is HotspotWidget)
{
HotspotWidget hotspotWidget = widgetEvent.EventSource as HotspotWidget;
switch (widgetEvent.EventType)
{
case WidgetEvent.eEventType.mouseOver:
OnHotspotEntered(hotspotWidget);
break;
case WidgetEvent.eEventType.mouseOut:
OnHotspotExited();
break;
case WidgetEvent.eEventType.mouseClick:
OnHotspotClicked(hotspotWidget, widgetEvent);
break;
}
}
UpdateMouseCursor(widgetEvent);
}
public virtual void EnableEvent(object eventId)
{
if (eventId is WidgetEvent) {
WidgetEvent ev = (WidgetEvent) eventId;
switch (ev) {
case WidgetEvent.DragLeave:
AllocEventBox ();
EventsRootWidget.DragLeave += HandleWidgetDragLeave;
break;
case WidgetEvent.DragStarted:
AllocEventBox ();
EventsRootWidget.DragBegin += HandleWidgetDragBegin;
break;
case WidgetEvent.KeyPressed:
Widget.KeyPressEvent += HandleKeyPressEvent;
break;
case WidgetEvent.KeyReleased:
Widget.KeyReleaseEvent += HandleKeyReleaseEvent;
break;
case WidgetEvent.GotFocus:
EventsRootWidget.AddEvents ((int)Gdk.EventMask.FocusChangeMask);
Widget.FocusGrabbed += HandleWidgetFocusInEvent;
break;
case WidgetEvent.LostFocus:
EventsRootWidget.AddEvents ((int)Gdk.EventMask.FocusChangeMask);
Widget.FocusOutEvent += HandleWidgetFocusOutEvent;
break;
case WidgetEvent.MouseEntered:
AllocEventBox ();
EventsRootWidget.AddEvents ((int)Gdk.EventMask.EnterNotifyMask);
EventsRootWidget.EnterNotifyEvent += HandleEnterNotifyEvent;
break;
case WidgetEvent.MouseExited:
AllocEventBox ();
EventsRootWidget.AddEvents ((int)Gdk.EventMask.LeaveNotifyMask);
EventsRootWidget.LeaveNotifyEvent += HandleLeaveNotifyEvent;
break;
case WidgetEvent.ButtonPressed:
AllocEventBox ();
EventsRootWidget.AddEvents ((int)Gdk.EventMask.ButtonPressMask);
EventsRootWidget.ButtonPressEvent += HandleButtonPressEvent;
break;
case WidgetEvent.ButtonReleased:
AllocEventBox ();
EventsRootWidget.AddEvents ((int)Gdk.EventMask.ButtonReleaseMask);
EventsRootWidget.ButtonReleaseEvent += HandleButtonReleaseEvent;
break;
case WidgetEvent.MouseMoved:
AllocEventBox ();
EventsRootWidget.AddEvents ((int)Gdk.EventMask.PointerMotionMask);
EventsRootWidget.MotionNotifyEvent += HandleMotionNotifyEvent;
break;
case WidgetEvent.BoundsChanged:
Widget.SizeAllocated += HandleWidgetBoundsChanged;
break;
case WidgetEvent.MouseScrolled:
AllocEventBox();
EventsRootWidget.AddEvents ((int)Gdk.EventMask.ScrollMask);
Widget.ScrollEvent += HandleScrollEvent;
break;
case WidgetEvent.TextInput:
if (EditableWidget != null) {
EditableWidget.TextInserted += HandleTextInserted;
} else {
RunWhenRealized (delegate {
if (IMContext == null) {
IMContext = new Gtk.IMMulticontext ();
IMContext.ClientWindow = EventsRootWidget.GdkWindow;
IMContext.Commit += HandleImCommitEvent;
}
});
Widget.KeyPressEvent += HandleTextInputKeyPressEvent;
Widget.KeyReleaseEvent += HandleTextInputKeyReleaseEvent;
}
break;
}
if ((ev & dragDropEvents) != 0 && (enabledEvents & dragDropEvents) == 0) {
// Enabling a drag&drop event for the first time
AllocEventBox ();
EventsRootWidget.DragDrop += HandleWidgetDragDrop;
EventsRootWidget.DragMotion += HandleWidgetDragMotion;
EventsRootWidget.DragDataReceived += HandleWidgetDragDataReceived;
}
if ((ev & WidgetEvent.PreferredSizeCheck) != 0) {
EnableSizeCheckEvents ();
}
enabledEvents |= ev;
}
}
public virtual void DisableEvent(object eventId)
{
if (eventId is WidgetEvent) {
WidgetEvent ev = (WidgetEvent) eventId;
switch (ev) {
case WidgetEvent.DragLeave:
EventsRootWidget.DragLeave -= HandleWidgetDragLeave;
break;
case WidgetEvent.DragStarted:
EventsRootWidget.DragBegin -= HandleWidgetDragBegin;
break;
case WidgetEvent.KeyPressed:
Widget.KeyPressEvent -= HandleKeyPressEvent;
break;
case WidgetEvent.KeyReleased:
Widget.KeyReleaseEvent -= HandleKeyReleaseEvent;
break;
case WidgetEvent.GotFocus:
Widget.FocusInEvent -= HandleWidgetFocusInEvent;
break;
case WidgetEvent.LostFocus:
Widget.FocusOutEvent -= HandleWidgetFocusOutEvent;
break;
case WidgetEvent.MouseEntered:
EventsRootWidget.EnterNotifyEvent -= HandleEnterNotifyEvent;
break;
case WidgetEvent.MouseExited:
EventsRootWidget.LeaveNotifyEvent -= HandleLeaveNotifyEvent;
break;
case WidgetEvent.ButtonPressed:
if (!EventsRootWidget.IsRealized)
EventsRootWidget.Events &= ~Gdk.EventMask.ButtonPressMask;
EventsRootWidget.ButtonPressEvent -= HandleButtonPressEvent;
break;
case WidgetEvent.ButtonReleased:
if (!EventsRootWidget.IsRealized)
EventsRootWidget.Events &= Gdk.EventMask.ButtonReleaseMask;
EventsRootWidget.ButtonReleaseEvent -= HandleButtonReleaseEvent;
break;
case WidgetEvent.MouseMoved:
if (!EventsRootWidget.IsRealized)
EventsRootWidget.Events &= Gdk.EventMask.PointerMotionMask;
EventsRootWidget.MotionNotifyEvent -= HandleMotionNotifyEvent;
break;
case WidgetEvent.BoundsChanged:
Widget.SizeAllocated -= HandleWidgetBoundsChanged;
break;
case WidgetEvent.MouseScrolled:
if (!EventsRootWidget.IsRealized)
EventsRootWidget.Events &= ~Gdk.EventMask.ScrollMask;
Widget.ScrollEvent -= HandleScrollEvent;
break;
}
enabledEvents &= ~ev;
if ((ev & dragDropEvents) != 0 && (enabledEvents & dragDropEvents) == 0) {
// All drag&drop events have been disabled
EventsRootWidget.DragDrop -= HandleWidgetDragDrop;
EventsRootWidget.DragMotion -= HandleWidgetDragMotion;
EventsRootWidget.DragDataReceived -= HandleWidgetDragDataReceived;
}
if ((ev & WidgetEvent.PreferredSizeCheck) != 0) {
DisableSizeCheckEvents ();
}
if ((ev & WidgetEvent.GotFocus) == 0 && (enabledEvents & WidgetEvent.LostFocus) == 0 && !EventsRootWidget.IsRealized) {
EventsRootWidget.Events &= ~Gdk.EventMask.FocusChangeMask;
}
}
}
private void OnHotspotClicked(
HotspotWidget hotspotWidget,
WidgetEvent widgetEvent)
{
if (m_currentNavRef.IsValid)
{
WidgetEvent.MouseClickEventParameters eventParameters =
widgetEvent.EventParameters as WidgetEvent.MouseClickEventParameters;
Point2d clickPoint = new Point2d(eventParameters.worldX, eventParameters.worldY);
HotspotInfo hotspotInfo = hotspotWidget.Userdata as HotspotInfo;
switch (hotspotInfo.hotspotType)
{
case eHotspotType.energy_tank:
{
EnergyTankData energyTankData = hotspotInfo.hotspotEntity as EnergyTankData;
m_contextOverlayController.OnEnergyTankClicked(clickPoint, energyTankData);
}
break;
case eHotspotType.portal:
{
RoomPortal portal = hotspotInfo.hotspotEntity as RoomPortal;
m_contextOverlayController.OnPortalClicked(clickPoint, portal);
}
break;
}
}
}
private void UpdateMouseCursor(WidgetEvent widgetEvent)
{
if (widgetEvent.EventType == WidgetEvent.eEventType.mouseOver ||
widgetEvent.EventType == WidgetEvent.eEventType.mouseOut ||
widgetEvent.EventType == WidgetEvent.eEventType.mouseMove)
{
if (widgetEvent.EventSource is HotspotWidget)
{
HotspotWidget hotspotWidget = widgetEvent.EventSource as HotspotWidget;
HotspotInfo hotspotInfo = hotspotWidget.Userdata as HotspotInfo;
switch (hotspotInfo.hotspotType)
{
case eHotspotType.energy_tank:
{
EnergyTankData energyTankData = hotspotInfo.hotspotEntity as EnergyTankData;
if (energyTankData.ownership != GameConstants.eFaction.player)
{
// If our faction doesn't control the energy tank, we'll have to hack it
SetMouseCursorState(eMouseCursorState.hack_energy_tank);
}
else if (energyTankData.energy > 0)
{
// If our faction does control the energy tank, then we can drain it if it has energy
SetMouseCursorState(eMouseCursorState.drain_energy_tank);
}
else
{
// Otherwise all we can do is walk to it
SetMouseCursorState(eMouseCursorState.walk);
}
}
break;
case eHotspotType.portal:
{
Point2d hotspotCenter =
hotspotWidget.WorldPosition.Offset(new Vector2d(hotspotWidget.Width / 2.0f, hotspotWidget.Height / 2.0f));
Point2d screenCenter = new Point2d(Screen.width / 2.0f, Screen.height / 2.0f);
Vector2d vectorToHotspot = hotspotCenter - screenCenter;
MathConstants.eDirection currentHotspotDirection = MathConstants.GetDirectionForVector(vectorToHotspot);
switch (currentHotspotDirection)
{
case MathConstants.eDirection.left:
SetMouseCursorState(eMouseCursorState.door_left);
break;
case MathConstants.eDirection.right:
SetMouseCursorState(eMouseCursorState.door_right);
break;
case MathConstants.eDirection.up:
SetMouseCursorState(eMouseCursorState.door_up);
break;
case MathConstants.eDirection.down:
SetMouseCursorState(eMouseCursorState.door_down);
break;
default:
SetMouseCursorState(eMouseCursorState.walk);
break;
}
}
break;
default:
{
SetMouseCursorState(eMouseCursorState.defaultCursor);
}
break;
}
}
else if (widgetEvent.EventSource is TileGridWidget)
{
if (m_currentNavRef.IsValid)
{
SetMouseCursorState(eMouseCursorState.walk);
}
else
{
SetMouseCursorState(eMouseCursorState.defaultCursor);
}
}
else
{
SetMouseCursorState(eMouseCursorState.defaultCursor);
}
}
}
// Events
public void OnWidgetEvent(WidgetEvent widgetEvent)
{
bool handeled = false;
if (widgetEvent.EventSource == _chatInput)
{
if (widgetEvent.EventType == WidgetEvent.eEventType.textInputReturn)
{
string inputText = _chatInput.Text;
// Attempt to execute the chat string as a debug command first
// If it works, well get a valid result string back.
string commandResult = DebugRegistry.ExecuteDebugCommand(inputText);
_chatInput.Text= "";
if (commandResult.Length > 0)
{
_chatWindowController.OnSystemMessage(commandResult);
}
else
{
_chatWindowController.OnChatTextInput(inputText);
}
// No need to forward this event on
handeled = true;
}
else if (widgetEvent.EventType == WidgetEvent.eEventType.textInputTab)
{
string partialText= _chatInput.Text;
List<string> completions = DebugRegistry.CompleteDebugCommand(partialText);
if (completions.Count > 1)
{
foreach (string completion in completions)
{
_chatWindowController.OnSystemMessage(completion);
}
_chatInput.Text = partialText;
}
else if (completions.Count == 1)
{
_chatInput.Text = completions[0];
// Force the cursor to the end of the line
{
TextEditor editor = (TextEditor)GUIUtility.GetStateObject(typeof(TextEditor), GUIUtility.keyboardControl);
editor.selectPos = _chatInput.Text.Length + 1;
editor.pos = _chatInput.Text.Length + 1;
}
}
// No need to forward this event on
handeled = true;
}
}
// Forward unhanded events onto our parent
if (!handeled)
{
_rootWidgetGroup.ParentWidgetGroup.OnWidgetEvent(widgetEvent);
}
}
// Events
public void OnWidgetEvent(WidgetEvent widgetEvent)
{
switch (widgetEvent.EventType)
{
case WidgetEvent.eEventType.buttonClick:
{
if (widgetEvent.EventSource == m_logoutButton)
{
GameWorldController.OnLogoutClicked();
}
if (widgetEvent.EventSource == m_firstEventButton)
{
GameWorldController.OnFirstEventClicked();
}
if (widgetEvent.EventSource == m_previousEventButton)
{
GameWorldController.OnPreviousEventClicked();
}
if (widgetEvent.EventSource == m_playPauseEventButton)
{
GameWorldController.OnPlayPauseClicked();
}
if (widgetEvent.EventSource == m_nextEventButton)
{
GameWorldController.OnNextEventClicked();
}
if (widgetEvent.EventSource == m_lastEventButton)
{
GameWorldController.OnLastEventClicked();
}
} break;
case WidgetEvent.eEventType.mouseClick:
{
if (m_foregroundObjectTiles != null && widgetEvent.EventSource == m_foregroundObjectTiles)
{
WidgetEvent.MouseClickEventParameters eventParameters =
widgetEvent.EventParameters as WidgetEvent.MouseClickEventParameters;
GameWorldController.OnCharacterMoveToRequest(eventParameters.localX, eventParameters.localY);
}
} break;
case WidgetEvent.eEventType.mouseOver:
case WidgetEvent.eEventType.mouseOut:
case WidgetEvent.eEventType.mouseMove:
{
// Forward mouse events on to the overlay view for cursor updates
GameWorldController.OverlayController.View.OnWidgetEvent(widgetEvent);
} break;
}
}
// IWidgetEventListener
public override void OnWidgetEvent(WidgetEvent widgetEvent)
{
bool handled = false;
if (widgetEvent.EventType == WidgetEvent.eEventType.buttonClick)
{
if (widgetEvent.EventSource == m_scrollUpButton)
{
OnScrollUpClicked();
handled = true;
}
else if (widgetEvent.EventSource == m_scrollDownButton)
{
OnScrollDownClicked();
handled = true;
}
}
if (!handled)
{
base.OnWidgetEvent(widgetEvent);
}
}
