FreeRDP/client/Mac/MRDPRailView.m

858 lines
26 KiB
Mathematica
Raw Normal View History

#include "MRDPRailView.h"
#define USE_RAIL_CVT
@implementation MRDPRailView
2012-08-02 21:04:44 +04:00
@synthesize mrdpRailWindow, windowIndex, activateWindow;
MRDPRailView * g_mrdpRailView;
struct kkey
{
int key_code;
int flags;
};
extern struct kkey g_keys[];
- (void) updateDisplay
{
boolean moveWindow = NO;
NSRect srcRectOuter;
NSRect destRectOuter;
2012-08-02 21:04:44 +04:00
rdpGdi * gdi;
2012-08-02 21:04:44 +04:00
if ((context == 0) || (context->gdi == 0))
return;
2012-08-02 21:04:44 +04:00
if (context->gdi->primary->hdc->hwnd->invalid->null)
return;
2012-08-02 21:04:44 +04:00
if (context->gdi->drawing != context->gdi->primary)
return;
2012-08-02 21:04:44 +04:00
gdi = context->gdi;
2012-08-02 21:04:44 +04:00
srcRectOuter = NSMakeRect(0, 0, self->width, self->height);
destRectOuter = [[self window] frame];
// cannot be bigger than our current screen size
NSRect screenSize = [[NSScreen mainScreen] frame];
if (destRectOuter.size.width > screenSize.size.width) {
destRectOuter.size.width = screenSize.size.width;
moveWindow = YES;
}
2012-08-02 21:04:44 +04:00
if (destRectOuter.size.height > screenSize.size.height) {
destRectOuter.size.height = screenSize.size.height;
2012-08-02 21:04:44 +04:00
moveWindow = YES;
}
2012-08-02 21:04:44 +04:00
if (destRectOuter.origin.x + destRectOuter.size.width > width)
destRectOuter.size.width = width - destRectOuter.origin.x;
2012-08-02 21:04:44 +04:00
[self setupBmiRep:destRectOuter.size.width :destRectOuter.size.height];
if (moveWindow) {
moveWindow = NO;
RAIL_WINDOW_MOVE_ORDER newWndLoc;
apple_to_windowMove(&destRectOuter, &newWndLoc);
newWndLoc.windowId = savedWindowId;
//skipMoveWindowOnce = TRUE;
//mac_send_rail_client_event(g_mrdpRailView->rdp_instance->context->channels, RDP_EVENT_TYPE_RAIL_CLIENT_WINDOW_MOVE, &newWndLoc);
}
2012-08-02 21:04:44 +04:00
destRectOuter.origin.y = height - destRectOuter.origin.y - destRectOuter.size.height;
2012-08-02 21:04:44 +04:00
rail_convert_color_space(pixelData, (char *) gdi->primary_buffer,
&destRectOuter, self->width, self->height);
2012-08-02 21:04:44 +04:00
if (moveWindow)
[self setNeedsDisplayInRect:destRectOuter];
else
[self setNeedsDisplayInRect:[self frame]];
gdi->primary->hdc->hwnd->ninvalid = 0;
}
/** *********************************************************************
* called when our view needs to be redrawn
***********************************************************************/
- (void) drawRect:(NSRect)dirtyRect
{
[bmiRep drawInRect:dirtyRect fromRect:dirtyRect operation:NSCompositeCopy fraction:1.0 respectFlipped:NO hints:nil];
2012-08-02 21:04:44 +04:00
if (pixelData) {
free(pixelData);
pixelData = NULL;
}
bmiRep = nil;
}
/** *********************************************************************
* become first responder so we can get keyboard and mouse events
***********************************************************************/
2012-08-02 21:04:44 +04:00
- (BOOL)acceptsFirstResponder
{
return YES;
}
- (BOOL)acceptsFirstMouse:(NSEvent *)theEvent
{
2012-08-02 21:04:44 +04:00
return NO;
}
/** *********************************************************************
* called when a mouse move event occurrs
2012-08-02 21:04:44 +04:00
*
* ideally we want to be called when the mouse moves over NSView client area,
* but in reality we get called any time the mouse moves anywhere on the screen;
* we could use NSTrackingArea class to handle this but this class is available
* on Mac OS X v10.5 and higher; since we want to be compatible with older
2012-08-02 21:04:44 +04:00
* versions, we do this manually.
*
* TODO: here is how it can be done using legacy methods
* http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/EventOverview/MouseTrackingEvents/MouseTrackingEvents.html#//apple_ref/doc/uid/10000060i-CH11-SW1
***********************************************************************/
- (void) mouseMoved:(NSEvent *)event
{
[super mouseMoved:event];
2012-08-02 21:04:44 +04:00
NSRect winFrame = [[self window] frame];
NSPoint loc = [event locationInWindow];
2012-08-02 21:04:44 +04:00
int x = (int) (winFrame.origin.x + loc.x);
int y = (int) (winFrame.origin.y + loc.y);
2012-08-02 21:04:44 +04:00
y = height - y;
2012-08-02 21:04:44 +04:00
// send mouse motion event to RDP server
rdp_instance->input->MouseEvent(rdp_instance->input, PTR_FLAGS_MOVE, x, y);
}
/** *********************************************************************
* called when left mouse button is pressed down
***********************************************************************/
- (void)mouseDown:(NSEvent *) event
{
[super mouseDown:event];
2012-08-02 21:04:44 +04:00
NSRect winFrame = [[self window] frame];
NSPoint loc = [event locationInWindow];
int x = (int) (winFrame.origin.x + loc.x);
int y = (int) (winFrame.origin.y + loc.y);
int yPos = (int) (winFrame.size.height - loc.y);
y = height - y;
if ((yPos >= 4) && (yPos <= 20))
titleBarClicked = YES;
2012-08-02 21:04:44 +04:00
else
titleBarClicked = NO;
2012-08-02 21:04:44 +04:00
savedDragLocation.x = loc.x;
savedDragLocation.y = loc.y;
2012-08-02 21:04:44 +04:00
rdp_instance->input->MouseEvent(rdp_instance->input, PTR_FLAGS_DOWN | PTR_FLAGS_BUTTON1, x, y);
}
/** *********************************************************************
* called when left mouse button is released
***********************************************************************/
- (void) mouseUp:(NSEvent *) event
{
[super mouseUp:event];
NSRect winFrame = [[self window] frame];
NSPoint loc = [event locationInWindow];
int x = (int) (winFrame.origin.x + loc.x);
int y = (int) (winFrame.origin.y + loc.y);
y = height - y;
2012-08-02 21:04:44 +04:00
rdp_instance->input->MouseEvent(rdp_instance->input, PTR_FLAGS_BUTTON1, x, y);
titleBarClicked = NO;
}
/** *********************************************************************
* called when right mouse button is pressed down
***********************************************************************/
- (void) rightMouseDown:(NSEvent *)event
{
[super rightMouseDown:event];
NSRect winFrame = [[self window] frame];
NSPoint loc = [event locationInWindow];
int x = (int) (winFrame.origin.x + loc.x);
int y = (int) (winFrame.origin.y + loc.y);
y = height - y;
rdp_instance->input->MouseEvent(rdp_instance->input, PTR_FLAGS_DOWN | PTR_FLAGS_BUTTON2, x, y);
}
/** *********************************************************************
* called when right mouse button is released
***********************************************************************/
- (void) rightMouseUp:(NSEvent *)event
{
[super rightMouseUp:event];
NSRect winFrame = [[self window] frame];
NSPoint loc = [event locationInWindow];
int x = (int) (winFrame.origin.x + loc.x);
int y = (int) (winFrame.origin.y + loc.y);
y = height - y;
2012-08-02 21:04:44 +04:00
rdp_instance->input->MouseEvent(rdp_instance->input, PTR_FLAGS_BUTTON2, x, y);
}
/** *********************************************************************
* called when middle mouse button is pressed
***********************************************************************/
- (void) otherMouseDown:(NSEvent *)event
{
[super otherMouseDown:event];
NSRect winFrame = [[self window] frame];
NSPoint loc = [event locationInWindow];
int x = (int) (winFrame.origin.x + loc.x);
int y = (int) (winFrame.origin.y + loc.y);
y = height - y;
rdp_instance->input->MouseEvent(rdp_instance->input, PTR_FLAGS_DOWN | PTR_FLAGS_BUTTON3, x, y);
}
/** *********************************************************************
* called when middle mouse button is released
***********************************************************************/
- (void) otherMouseUp:(NSEvent *)event
{
[super otherMouseUp:event];
NSRect winFrame = [[self window] frame];
NSPoint loc = [event locationInWindow];
int x = (int) (winFrame.origin.x + loc.x);
int y = (int) (winFrame.origin.y + loc.y);
y = height - y;
2012-08-02 21:04:44 +04:00
rdp_instance->input->MouseEvent(rdp_instance->input, PTR_FLAGS_BUTTON3, x, y);
}
- (void) scrollWheel:(NSEvent *)event
{
uint16 flags;
2012-08-02 21:04:44 +04:00
[super scrollWheel:event];
2012-08-02 21:04:44 +04:00
// we get more two finger trackpad scroll events
// than scrollWheel events, so we drop some
if (gestureEventInProgress) {
scrollWheelCount++;
if (scrollWheelCount % 8 != 0)
return;
}
if ([event scrollingDeltaY] < 0) {
2012-08-02 21:04:44 +04:00
flags = PTR_FLAGS_WHEEL | PTR_FLAGS_WHEEL_NEGATIVE | 0x0088;
}
else {
2012-08-02 21:04:44 +04:00
flags = PTR_FLAGS_WHEEL | 0x78;
}
2012-08-02 21:04:44 +04:00
rdp_instance->input->MouseEvent(rdp_instance->input, flags, 0, 0);
}
/** *********************************************************************
* called when mouse is moved with left button pressed
* note: invocation order is: mouseDown, mouseDragged, mouseUp
***********************************************************************/
- (void) mouseDragged:(NSEvent *)event
{
[super mouseDragged:event];
2012-08-02 21:04:44 +04:00
NSRect winFrame = [[self window] frame];
NSPoint loc = [event locationInWindow];
int x = (int) loc.x;
int y = (int) loc.y;
if (titleBarClicked) {
// window is being dragged to a new location
int newX = x - savedDragLocation.x;
int newY = y - savedDragLocation.y;
2012-08-02 21:04:44 +04:00
if ((newX == 0) && (newY == 0))
return;
2012-08-02 21:04:44 +04:00
winFrame.origin.x += newX;
winFrame.origin.y += newY;
2012-08-02 21:04:44 +04:00
[[self window] setFrame:winFrame display:YES];
return;
}
if (localMoveType == RAIL_WMSZ_LEFT) {
// left border resize taking place
int diff = (int) (loc.x - savedDragLocation.x);
if (diff == 0)
return;
2012-08-02 21:04:44 +04:00
if (diff < 0) {
diff = abs(diff);
winFrame.origin.x -= diff;
winFrame.size.width += diff;
}
else {
winFrame.origin.x += diff;
winFrame.size.width -= diff;
}
2012-08-02 21:04:44 +04:00
[[self window] setFrame:winFrame display:YES];
return;
}
if (localMoveType == RAIL_WMSZ_RIGHT) {
// right border resize taking place
int diff = (int) (loc.x - savedDragLocation.x);
if (diff == 0)
return;
2012-08-02 21:04:44 +04:00
savedDragLocation.x = loc.x;
savedDragLocation.y = loc.y;
2012-08-02 21:04:44 +04:00
winFrame.size.width += diff;
[[self window] setFrame:winFrame display:YES];
return;
}
if (localMoveType == RAIL_WMSZ_TOP) {
// top border resize taking place
int diff = (int) (loc.y - savedDragLocation.y);
if (diff == 0)
return;
2012-08-02 21:04:44 +04:00
savedDragLocation.x = loc.x;
savedDragLocation.y = loc.y;
2012-08-02 21:04:44 +04:00
winFrame.size.height += diff;
[[self window] setFrame:winFrame display:YES];
return;
}
2012-08-02 21:04:44 +04:00
if (localMoveType == RAIL_WMSZ_BOTTOM) {
// bottom border resize taking place
int diff = (int) (loc.y - savedDragLocation.y);
if (diff == 0)
return;
2012-08-02 21:04:44 +04:00
if (diff < 0) {
diff = abs(diff);
winFrame.origin.y -= diff;
winFrame.size.height += diff;
}
else {
winFrame.origin.y += diff;
winFrame.size.height -= diff;
}
2012-08-02 21:04:44 +04:00
[[self window] setFrame:winFrame display:YES];
return;
}
2012-08-02 21:04:44 +04:00
if (localMoveType == RAIL_WMSZ_TOPLEFT) {
// top left border resize taking place
int diff = (int) (loc.x - savedDragLocation.x);
if (diff != 0) {
if (diff < 0) {
diff = abs(diff);
winFrame.origin.x -= diff;
winFrame.size.width += diff;
}
else {
winFrame.origin.x += diff;
winFrame.size.width -= diff;
}
}
diff = (int) (loc.y - savedDragLocation.y);
if (diff != 0) {
savedDragLocation.y = loc.y;
winFrame.size.height += diff;
}
2012-08-02 21:04:44 +04:00
[[self window] setFrame:winFrame display:YES];
return;
}
if (localMoveType == RAIL_WMSZ_TOPRIGHT) {
// top right border resize taking place
int diff = (int) (loc.x - savedDragLocation.x);
if (diff != 0) {
winFrame.size.width += diff;
}
2012-08-02 21:04:44 +04:00
diff = (int) (loc.y - savedDragLocation.y);
if (diff != 0) {
winFrame.size.height += diff;
}
savedDragLocation.x = loc.x;
savedDragLocation.y = loc.y;
[[self window] setFrame:winFrame display:YES];
return;
}
2012-08-02 21:04:44 +04:00
if (localMoveType == RAIL_WMSZ_BOTTOMLEFT) {
// bottom left border resize taking place
int diff = (int) (loc.x - savedDragLocation.x);
if (diff != 0) {
if (diff < 0) {
diff = abs(diff);
winFrame.origin.x -= diff;
winFrame.size.width += diff;
}
else {
winFrame.origin.x += diff;
winFrame.size.width -= diff;
}
}
2012-08-02 21:04:44 +04:00
diff = (int) (loc.y - savedDragLocation.y);
if (diff != 0) {
if (diff < 0) {
diff = abs(diff);
winFrame.origin.y -= diff;
winFrame.size.height += diff;
}
else {
winFrame.origin.y += diff;
winFrame.size.height -= diff;
}
}
2012-08-02 21:04:44 +04:00
[[self window] setFrame:winFrame display:YES];
return;
}
2012-08-02 21:04:44 +04:00
if (localMoveType == RAIL_WMSZ_BOTTOMRIGHT) {
// bottom right border resize taking place
int diff = (int) (loc.x - savedDragLocation.x);
if (diff != 0) {
savedDragLocation.x = loc.x;
//savedDragLocation.y = loc.y;
winFrame.size.width += diff;
}
2012-08-02 21:04:44 +04:00
diff = (int) (loc.y - savedDragLocation.y);
if (diff != 0) {
if (diff < 0) {
diff = abs(diff);
winFrame.origin.y -= diff;
winFrame.size.height += diff;
}
else {
winFrame.origin.y += diff;
winFrame.size.height -= diff;
}
}
2012-08-02 21:04:44 +04:00
[[self window] setFrame:winFrame display:YES];
return;
}
2012-08-02 21:04:44 +04:00
x = (int) (winFrame.origin.x + loc.x);
y = (int) (winFrame.origin.y + loc.y);
y = height - y;
2012-08-02 21:04:44 +04:00
// send mouse motion event to RDP server
rdp_instance->input->MouseEvent(rdp_instance->input, PTR_FLAGS_MOVE, x, y);
}
/** *********************************************************************
* called when a key is pressed
***********************************************************************/
- (void) keyDown:(NSEvent *) event
{
int key;
2012-08-02 21:04:44 +04:00
key = [event keyCode];
rdp_instance->input->KeyboardEvent(rdp_instance->input, g_keys[key].flags | KBD_FLAGS_DOWN, g_keys[key].key_code);
}
/** *********************************************************************
* called when a key is released
***********************************************************************/
- (void) keyUp:(NSEvent *) event
{
int key;
key = [event keyCode];
rdp_instance->input->KeyboardEvent(rdp_instance->input, g_keys[key].flags | KBD_FLAGS_RELEASE, g_keys[key].key_code);
}
/** *********************************************************************
* called when shift, control, alt and meta keys are pressed/released
***********************************************************************/
- (void) flagsChanged:(NSEvent *) event
{
NSUInteger mf = [event modifierFlags];
2012-08-02 21:04:44 +04:00
// caps lock
if (mf == 0x10100) {
printf("TODO: caps lock is on\n");
kdcapslock = 1;
}
if (kdcapslock && (mf == 0x100)) {
kdcapslock = 0;
printf("TODO: caps lock is off\n");
}
// left shift
if ((kdlshift == 0) && ((mf & 2) != 0)) {
// left shift went down
rdp_instance->input->KeyboardEvent(rdp_instance->input, KBD_FLAGS_DOWN, 0x2a);
kdlshift = 1;
}
if ((kdlshift != 0) && ((mf & 2) == 0)) {
// left shift went up
rdp_instance->input->KeyboardEvent(rdp_instance->input, KBD_FLAGS_RELEASE, 0x2a);
kdlshift = 0;
}
2012-08-02 21:04:44 +04:00
// right shift
if ((kdrshift == 0) && ((mf & 4) != 0)) {
// right shift went down
rdp_instance->input->KeyboardEvent(rdp_instance->input, KBD_FLAGS_DOWN, 0x36);
kdrshift = 1;
}
if ((kdrshift != 0) && ((mf & 4) == 0)) {
// right shift went up
rdp_instance->input->KeyboardEvent(rdp_instance->input, KBD_FLAGS_RELEASE, 0x36);
kdrshift = 0;
}
2012-08-02 21:04:44 +04:00
// left ctrl
if ((kdlctrl == 0) && ((mf & 1) != 0)) {
// left ctrl went down
rdp_instance->input->KeyboardEvent(rdp_instance->input, KBD_FLAGS_DOWN, 0x1d);
kdlctrl = 1;
}
if ((kdlctrl != 0) && ((mf & 1) == 0)) {
// left ctrl went up
rdp_instance->input->KeyboardEvent(rdp_instance->input, KBD_FLAGS_RELEASE, 0x1d);
kdlctrl = 0;
}
2012-08-02 21:04:44 +04:00
// right ctrl
if ((kdrctrl == 0) && ((mf & 0x2000) != 0)) {
// right ctrl went down
rdp_instance->input->KeyboardEvent(rdp_instance->input, 1 | KBD_FLAGS_DOWN, 0x1d);
kdrctrl = 1;
}
if ((kdrctrl != 0) && ((mf & 0x2000) == 0)) {
// right ctrl went up
rdp_instance->input->KeyboardEvent(rdp_instance->input, 1 | KBD_FLAGS_RELEASE, 0x1d);
kdrctrl = 0;
}
2012-08-02 21:04:44 +04:00
// left alt
if ((kdlalt == 0) && ((mf & 0x20) != 0)) {
// left alt went down
rdp_instance->input->KeyboardEvent(rdp_instance->input, KBD_FLAGS_DOWN, 0x38);
kdlalt = 1;
}
if ((kdlalt != 0) && ((mf & 0x20) == 0)) {
// left alt went up
rdp_instance->input->KeyboardEvent(rdp_instance->input, KBD_FLAGS_RELEASE, 0x38);
kdlalt = 0;
}
2012-08-02 21:04:44 +04:00
// right alt
if ((kdralt == 0) && ((mf & 0x40) != 0)) {
// right alt went down
rdp_instance->input->KeyboardEvent(rdp_instance->input, 1 | KBD_FLAGS_DOWN, 0x38);
kdralt = 1;
}
if ((kdralt != 0) && ((mf & 0x40) == 0)) {
// right alt went up
rdp_instance->input->KeyboardEvent(rdp_instance->input, 1 | KBD_FLAGS_RELEASE, 0x38);
kdralt = 0;
}
2012-08-02 21:04:44 +04:00
// left meta
if ((kdlmeta == 0) && ((mf & 0x08) != 0)) {
// left meta went down
rdp_instance->input->KeyboardEvent(rdp_instance->input, 1 | KBD_FLAGS_DOWN, 0x5b);
kdlmeta = 1;
}
if ((kdlmeta != 0) && ((mf & 0x08) == 0)) {
// left meta went up
rdp_instance->input->KeyboardEvent(rdp_instance->input, 1 | KBD_FLAGS_RELEASE, 0x5b);
kdlmeta = 0;
}
2012-08-02 21:04:44 +04:00
// right meta
if ((kdrmeta == 0) && ((mf & 0x10) != 0)) {
// right meta went down
rdp_instance->input->KeyboardEvent(rdp_instance->input, 1 | KBD_FLAGS_DOWN, 0x5c);
kdrmeta = 1;
}
if ((kdrmeta != 0) && ((mf & 0x10) == 0)) {
// right meta went up
rdp_instance->input->KeyboardEvent(rdp_instance->input, 1 | KBD_FLAGS_RELEASE, 0x5c);
kdrmeta = 0;
}
}
- (void) setRdpInstance:(freerdp *) instance width:(int) w andHeight:(int) h windowID:(int) windowID
{
rdp_instance = instance;
context = instance->context;
width = w;
height = h;
savedWindowId = windowID;
2012-08-02 21:04:44 +04:00
NSRect tr = NSMakeRect(0, 0,
2012-08-02 21:04:44 +04:00
[[NSScreen mainScreen] frame].size.width,
[[NSScreen mainScreen] frame].size.height);
2012-08-02 21:04:44 +04:00
NSTrackingArea * trackingArea = [[NSTrackingArea alloc] initWithRect:tr options:NSTrackingMouseEnteredAndExited | NSTrackingMouseMoved | NSTrackingCursorUpdate | NSTrackingEnabledDuringMouseDrag | NSTrackingActiveAlways owner:self userInfo:nil];
2012-08-02 21:04:44 +04:00
[self addTrackingArea:trackingArea];
2012-08-02 21:04:44 +04:00
g_mrdpRailView = self;
[self becomeFirstResponder];
2012-08-02 21:04:44 +04:00
[self setAcceptsTouchEvents:YES];
// we want to be notified when window resizes....
[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(windowDidResize:) name:NSWindowDidResizeNotification object:nil];
// ...moves
[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(windowDidMove:) name:NSWindowDidMoveNotification object:nil];
// ...and becomes the key window
[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(windowDidBecomeKey:) name:NSWindowDidBecomeKeyNotification object:nil];
}
- (void) setupBmiRep:(int) frameWidth :(int) frameHeight
{
struct rgba_data
{
char red;
char green;
char blue;
char alpha;
};
2012-08-02 21:04:44 +04:00
if (pixelData)
free(pixelData);
2012-08-02 21:04:44 +04:00
pixelData = (char *) malloc(frameWidth * frameHeight * sizeof(struct rgba_data));
bmiRep = [[NSBitmapImageRep alloc] initWithBitmapDataPlanes:(unsigned char **) &pixelData
pixelsWide:frameWidth
pixelsHigh:frameHeight
bitsPerSample:8
samplesPerPixel:sizeof(struct rgba_data)
hasAlpha:YES
isPlanar:NO
colorSpaceName:NSDeviceRGBColorSpace
bitmapFormat:0
bytesPerRow:frameWidth * sizeof(struct rgba_data)
bitsPerPixel:0];
}
2012-08-02 21:04:44 +04:00
- (void) beginGestureWithEvent:(NSEvent *)event
{
gestureEventInProgress = YES;
}
- (void) endGestureWithEvent:(NSEvent *)event
{
gestureEventInProgress = NO;
}
/**
* called when a bordered window changes size
*/
- (void) windowDidResize:(NSNotification *) notification
{
// if we are not the source of this notification, just return
if ([notification object] != [self mrdpRailWindow])
return;
// let RDP server know that window has moved
RAIL_WINDOW_MOVE_ORDER windowMove;
NSRect r = [[self window] frame];
int diffInHeight = [[self window] frame].size.height - [self frame].size.height;
r.size.height -= diffInHeight;
apple_to_windowMove(&r, &windowMove);
windowMove.windowId = self->savedWindowId;
mac_send_rail_client_event(self->context->channels, RDP_EVENT_TYPE_RAIL_CLIENT_WINDOW_MOVE, &windowMove);
}
/**
* called when user moves a bordered window
*/
- (void) windowDidMove:(NSNotification *) notification
{
// if we are not the source of this notification, just return
if ([notification object] != [self mrdpRailWindow])
return;
// let RDP server know that window has moved
RAIL_WINDOW_MOVE_ORDER windowMove;
NSRect r = [[self window] frame];
int diffInHeight = [[self window] frame].size.height - [self frame].size.height;
r.size.height -= diffInHeight;
apple_to_windowMove(&r, &windowMove);
windowMove.windowId = self->savedWindowId;
mac_send_rail_client_event(self->context->channels, RDP_EVENT_TYPE_RAIL_CLIENT_WINDOW_MOVE, &windowMove);
}
/**
* called when a NSWindow becomes the key window
*/
- (void) windowDidBecomeKey:(NSNotification *) notification
{
// if we are not the source of this notification, just return
if ([notification object] != [self mrdpRailWindow])
return;
if (![self activateWindow])
return;
[[self window] setAcceptsMouseMovedEvents: YES];
//if ([self activateWindow])
mac_rail_send_activate(savedWindowId);
set_current_window(windowIndex);
}
- (void) releaseResources
{
[[NSNotificationCenter defaultCenter] removeObserver:self];
}
void rail_cvt_from_rect(char *dest, char *src, NSRect destRect, int destWidth, int destHeight, NSRect srcRect)
{
}
/** *********************************************************************
* color space conversion used specifically in RAIL
***********************************************************************/
2012-08-02 21:04:44 +04:00
void rail_convert_color_space(char *destBuf, char * srcBuf,
NSRect * destRect, int width, int height)
{
int i;
int j;
int numRows;
int srcX;
int srcY;
int destX;
int destY;
int pixelsPerRow;
int pixel;
int pixel1;
int pixel2;
int * src32;
int * dest32;
2012-08-02 21:04:44 +04:00
int destWidth = destRect->size.width;
int destHeight = destRect->size.height;
2012-08-02 21:04:44 +04:00
if ((!destBuf) || (!srcBuf)) {
return;
}
numRows = (destRect->origin.y + destHeight > height) ? height - destRect->origin.y : destHeight;
pixelsPerRow = destWidth;
srcX = destRect->origin.x;
srcY = destRect->origin.y;
destX = 0;
destY = 0;
2012-08-02 21:04:44 +04:00
for (i = 0; i < numRows; i++)
{
src32 = (int *) (srcBuf + ((srcY + i) * width + srcX) * 4);
dest32 = (int *) (destBuf + ((destY + i) * destWidth + destX) * 4);
2012-08-02 21:04:44 +04:00
for (j = 0; j < pixelsPerRow; j++)
{
pixel = *src32;
pixel1 = (pixel & 0x00ff0000) >> 16;
pixel2 = (pixel & 0x000000ff) << 16;
pixel = (pixel & 0xff00ff00) | pixel1 | pixel2;
*dest32 = pixel;
src32++;
dest32++;
}
}
2012-08-02 21:04:44 +04:00
destRect->origin.y = destHeight - destRect->origin.y - destRect->size.height;
return;
}
/**
* let RDP server know that window has moved
*/
void rail_MoveWindow(rdpRail * rail, rdpWindow * window)
{
if (g_mrdpRailView->isMoveSizeInProgress) {
return;
}
2012-08-02 21:04:44 +04:00
if (g_mrdpRailView->skipMoveWindowOnce) {
g_mrdpRailView->skipMoveWindowOnce = NO;
return;
}
2012-08-02 21:04:44 +04:00
// this rect is based on Windows co-ordinates...
NSRect r;
r.origin.x = window->windowOffsetX;
r.origin.y = window->windowOffsetY;
r.size.width = window->windowWidth;
r.size.height = window->windowHeight;
windows_to_apple_cords(&r);
[[g_mrdpRailView window] setFrame:r display:YES];
}
2012-08-02 21:04:44 +04:00
void mac_rail_send_activate(int window_id)
{
RAIL_ACTIVATE_ORDER activate;
activate.windowId = window_id;
activate.enabled = 1;
mac_send_rail_client_event(g_mrdpRailView->context->channels, RDP_EVENT_TYPE_RAIL_CLIENT_ACTIVATE, &activate);
}
@end
2012-08-02 21:04:44 +04:00