void CaptureApplicationToScreen(int ScreenID, std::string Application)
{
std::map<std::string, int>::iterator It = CapturedAppLst.find(Application);
if(It == CapturedAppLst.end())
{
screen_info *Screen = GetDisplayFromScreenID(ScreenID);
if(Screen)
{
CapturedAppLst[Application] = ScreenID;
DEBUG("CaptureApplicationToScreen() " << ScreenID << " " << Application)
}
}
std::vector<int> GetAllWindowIDsOnDisplay(int ScreenIndex)
{
screen_info *Screen = GetDisplayFromScreenID(ScreenIndex);
std::vector<int> ScreenWindowIDLst;
for(int WindowIndex = 0; WindowIndex < WindowLst.size(); ++WindowIndex)
{
window_info *Window = &WindowLst[WindowIndex];
if(!IsApplicationFloating(&WindowLst[WindowIndex]))
{
if(Window->X >= Screen->X && Window->X <= Screen->X + Screen->Width)
ScreenWindowIDLst.push_back(Window->WID);
}
}
return ScreenWindowIDLst;
}
std::vector<window_info*> GetAllWindowsOnDisplay(int ScreenIndex)
{
screen_info *Screen = GetDisplayFromScreenID(ScreenIndex);
std::vector<window_info*> ScreenWindowLst;
for(std::size_t WindowIndex = 0; WindowIndex < KWMTiling.WindowLst.size(); ++WindowIndex)
{
window_info *Window = &KWMTiling.WindowLst[WindowIndex];
if(IsWindowTilable(Window) &&
!IsWindowFloating(KWMTiling.WindowLst[WindowIndex].WID, NULL))
{
if(Screen == GetDisplayOfWindow(Window))
ScreenWindowLst.push_back(Window);
}
}
return ScreenWindowLst;
}
void GiveFocusToScreen(int ScreenIndex)
{
screen_info *Screen = GetDisplayFromScreenID(ScreenIndex);
if(Screen)
{
CGPoint CursorPos = CGPointMake(Screen->X + (Screen->Width / 2),
Screen->Y + (Screen->Height / 2));
CGEventRef MoveEvent = CGEventCreateMouseEvent(NULL, kCGEventLeftMouseDown, CursorPos, kCGMouseButtonLeft);
CGEventSetFlags(MoveEvent, 0);
CGEventPost(kCGHIDEventTap, MoveEvent);
CFRelease(MoveEvent);
DEBUG("GiveFocusToScreen() " << ScreenIndex)
UpdateActiveWindowList(Screen);
tree_node *NewFocusNode = GetFirstLeafNode(Screen->Space[Screen->ActiveSpace].RootNode);
SetWindowFocusByNode(NewFocusNode);
}
}
void MoveWindowToDisplay(window_info *Window, int Shift, bool Relative)
{
int NewScreenIndex = -1;
if(Relative)
NewScreenIndex = Shift == 1 ? GetIndexOfNextScreen() : GetIndexOfPrevScreen();
else
NewScreenIndex = Shift;
screen_info *NewScreen = GetDisplayFromScreenID(NewScreenIndex);
if(NewScreen && NewScreen != KWMScreen.Current)
{
space_info *SpaceOfWindow = GetActiveSpaceOfScreen(KWMScreen.Current);
SpaceOfWindow->FocusedWindowID = -1;
if(IsWindowFloating(Window->WID, NULL))
CenterWindow(NewScreen, Window);
else
AddWindowToTreeOfUnfocusedMonitor(NewScreen, Window);
}
}
void CycleFocusedWindowDisplay(int Shift, bool Relative)
{
screen_info *Screen = GetDisplayOfWindow(FocusedWindow);
int NewScreenIndex = -1;
if(Relative)
{
if(Shift == 1)
NewScreenIndex = (Screen->ID + 1 >= ActiveDisplaysCount) ? 0 : Screen->ID + 1;
else if(Shift == -1)
NewScreenIndex = (Screen->ID - 1 < 0) ? ActiveDisplaysCount - 1 : Screen->ID - 1;
}
else
{
NewScreenIndex = Shift;
}
if(NewScreenIndex != Screen->ID)
{
screen_info *NewScreen = GetDisplayFromScreenID(NewScreenIndex);
AddWindowToTreeOfUnfocusedMonitor(NewScreen);
}
}
void GiveFocusToScreen(unsigned int ScreenIndex, tree_node *FocusNode, bool Mouse, bool UpdateFocus)
{
screen_info *Screen = GetDisplayFromScreenID(ScreenIndex);
if(Screen && Screen != KWMScreen.Current)
{
KWMScreen.PrevSpace = KWMScreen.Current->ActiveSpace;
KWMScreen.Current = Screen;
Screen->ActiveSpace = GetActiveSpaceOfDisplay(Screen);
ShouldActiveSpaceBeManaged();
space_info *Space = GetActiveSpaceOfScreen(Screen);
DEBUG("GiveFocusToScreen() " << ScreenIndex << \
": Space transition ended " << KWMScreen.PrevSpace << \
" -> " << Screen->ActiveSpace);
if(UpdateFocus)
{
if(Space->Initialized && FocusNode)
{
DEBUG("Populated Screen 'Window -f Focus'");
UpdateActiveWindowList(Screen);
FilterWindowList(Screen);
SetWindowFocusByNode(FocusNode);
MoveCursorToCenterOfFocusedWindow();
}
else if(Space->Initialized && Space->RootNode)
{
DEBUG("Populated Screen Key/Mouse Focus");
UpdateActiveWindowList(Screen);
FilterWindowList(Screen);
bool WindowBelowCursor = IsAnyWindowBelowCursor();
if(Mouse && !WindowBelowCursor)
ClearFocusedWindow();
else if(Mouse && WindowBelowCursor)
FocusWindowBelowCursor();
if(!Mouse)
{
if(Space->FocusedWindowID == -1)
{
if(Space->Settings.Mode == SpaceModeBSP)
{
void *FocusNode = NULL;
GetFirstLeafNode(Space->RootNode, (void**)&FocusNode);
Space->FocusedWindowID = ((tree_node*)FocusNode)->WindowID;
}
else if(Space->Settings.Mode == SpaceModeMonocle)
{
if(Space->RootNode->List)
Space->FocusedWindowID = Space->RootNode->List->WindowID;
}
}
FocusWindowByID(Space->FocusedWindowID);
MoveCursorToCenterOfFocusedWindow();
}
}
else
{
if(!Space->Initialized ||
Space->Settings.Mode == SpaceModeFloating ||
!Space->RootNode)
{
DEBUG("Uninitialized Screen");
ClearFocusedWindow();
if(!Mouse)
CGWarpMouseCursorPosition(CGPointMake(Screen->X + (Screen->Width / 2), Screen->Y + (Screen->Height / 2)));
if(Space->Settings.Mode != SpaceModeFloating && !Space->RootNode)
{
CGPoint ClickPos = GetCursorPos();
CGEventRef ClickEvent = CGEventCreateMouseEvent(NULL, kCGEventLeftMouseDown, ClickPos, kCGMouseButtonLeft);
CGEventSetFlags(ClickEvent, 0);
CGEventPost(kCGHIDEventTap, ClickEvent);
CFRelease(ClickEvent);
ClickEvent = CGEventCreateMouseEvent(NULL, kCGEventLeftMouseUp, ClickPos, kCGMouseButtonLeft);
CGEventSetFlags(ClickEvent, 0);
CGEventPost(kCGHIDEventTap, ClickEvent);
CFRelease(ClickEvent);
}
}
}
}
}
}
