void MacOSXWindow::moveResize( int left, int top, int width, int height ) const
{
MoveWindow( m_win, left, top, false );
SizeWindow( m_win, width, height, true );
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
logWndMsg(hWnd, Msg);
switch (Msg)
{
// General window painting.
case WM_PAINT:
{
RECT updRect;
if (!GetUpdateRect(hWnd, &updRect, false))
{
break;
}
PAINTSTRUCT ps;
HDC hdc;
BITMAP bitmap;
HDC hdcMem;
HGDIOBJ oldBitmap;
hdc = BeginPaint(hWnd, &ps);
hdcMem = CreateCompatibleDC(hdc);
oldBitmap = SelectObject(hdcMem, testImg);
GetObject(testImg, sizeof(bitmap), &bitmap);
BitBlt(hdc, 0, 0, bitmap.bmWidth, bitmap.bmHeight, hdcMem, 0, 0, SRCCOPY);
SelectObject(hdcMem, oldBitmap);
DeleteDC(hdcMem);
EndPaint(hWnd, &ps);
}
break;
/*
// Erasing the window background.
case WM_ERASEBKGND:
//
break;
*/
// Drawing the window frame.
case WM_NCPAINT:
//
break;
// Timer calls, these happen every minute and redraw the clock in a way that bypasses the other 3 messages.
case WM_TIMER:
//
break;
// Mouse button down msg for clock for some reason....
case 1128:
{
RECT rc;
GetWindowRect(hWnd, &rc);
int width = rc.right - rc.left;
int height = rc.bottom - rc.top;
SizeWindow(hWnd, width + 10, height);
MessageBoxA(0, "derp", "Derp", MB_OK);
}
break;
// Mouse button up msg for clock
case 1127:
{
//
}
break;
// Mouse right button down.
case WM_RBUTTONDOWN:
//
break;
// Mouse right button up.
case WM_RBUTTONUP:
//
break;
case WM_NCHITTEST:
{
short xPos = LOWORD(lParam);
short yPos = HIWORD(lParam);
char buf[200];
char ibuf[10];
memset(buf, 0, 200);
strcat(buf, "WM_NCHITTEST: ");
strcat(buf, itoa(xPos, ibuf, 10));
strcat(buf, ", ");
strcat(buf, itoa(yPos, ibuf, 10));
strcat(buf, "\r\n");
FILE *f = fopen("C:/debug.txt", "a+");
fwrite(buf, strlen(buf), 1, f);
fclose(f);
return HTCLIENT;
}
break;
// Let every other message pass so the clock doesn't die.
default:
return CallWindowProc(OldWndProc, hWnd, Msg, wParam, lParam);
}
return 0;
}
static int RLXAPI CreateSurface(int numberOfSparePages)
{
static GLint attrib[32];
GLint *pAttrib = attrib;
*pAttrib = AGL_RGBA; pAttrib++;
*pAttrib = AGL_DOUBLEBUFFER; pAttrib++;
*pAttrib = AGL_NONE; pAttrib++;
AGLPixelFormat fmt;
GLboolean ok;
g_pRLX->pGX->View.lpBackBuffer = NULL;
/* Choose an rgb pixel format */
GDHandle gdhDisplay;
ok = DMGetGDeviceByDisplayID((DisplayIDType)g_cgDisplayID, &gdhDisplay, false);
SYS_ASSERT(ok == noErr);
fmt = aglChoosePixelFormat(&gdhDisplay, 1, attrib);
SYS_AGLTRACE(0);
if(fmt == NULL)
{
ok = SYS_AGLTRACE(aglGetError());
return -1;
}
/* Create an AGL context */
g_pAGLC = aglCreateContext(fmt, NULL);
SYS_AGLTRACE(0);
if(g_pAGLC == NULL)
return -2;
/* Attach the window to the context */
ok = SYS_AGLTRACE(aglSetDrawable(g_pAGLC, GetWindowPort(g_hWnd)));
if(!ok)
return -3;
/* Make the context the current context */
ok = SYS_AGLTRACE(aglSetCurrentContext(g_pAGLC));
if(!ok)
return -4;
SizeWindow(g_hWnd, gl_lx, gl_ly, true);
if ((g_pRLX->Video.Config & RLXVIDEO_Windowed))
CenterWindow(g_hWnd);
ShowWindow(g_hWnd);
// copy portRect
GetPortBounds(GetWindowPort(g_hWnd), g_pRect);
/* Pixel format is no more needed */
aglDestroyPixelFormat(fmt);
if (!(g_pRLX->Video.Config & RLXVIDEO_Windowed))
{
HideMenuBar();
aglSetFullScreen(g_pAGLC, 0, 0, 0, 0);
GLint swap = !!(g_pRLX->pGX->View.Flags & GX_CAPS_VSYNC);
aglSetInteger(g_pAGLC, AGL_SWAP_INTERVAL, &swap);
SYS_AGLTRACE(0);
}
// Reset engine
GL_InstallExtensions();
GL_ResetViewport();
g_pRLX->pGX->Surfaces.maxSurface = numberOfSparePages;;
if (g_pRLX->pGX->View.Flags & GX_CAPS_MULTISAMPLING)
{
glEnable(GL_MULTISAMPLE_ARB);
}
return 0;
}
static pascal OSStatus SimpleWindowEventHandlerProc( EventHandlerCallRef inCallRef, EventRef inEvent, void* inUserData )
{
#pragma unused ( inCallRef )
HICommand command;
Point pt;
SInt16 value;
Rect r;
WindowGroupRef windowGroup;
WindowGroupAttributes windowGroupAttributes;
UInt32 eventKind = GetEventKind( inEvent );
UInt32 eventClass = GetEventClass( inEvent );
WindowRef window = (WindowRef) inUserData;
OSStatus err = eventNotHandledErr;
WindowStorage *windowStorage = (WindowStorage*) GetWRefCon( window );
switch ( eventClass )
{
case kEventClassWindow:
if ( eventKind == kEventWindowClose ) // Dispose extra window storage here
{
if ( windowStorage->overlayWindow != NULL ) SendWindowCloseEvent( windowStorage->overlayWindow );
DisposePtr( (Ptr) windowStorage );
}
else if ( eventKind == kEventWindowClickContentRgn )
{
if ( GetControlValueByID( window, 'Butn', 0 ) == 1 ) // If the "Line Tool" button is depressed
{
LineTool( window );
SetControlValueByID( window, 'Butn', 0, 0 ); // Pop the button back up
err = noErr;
}
}
else if ( (eventKind == kEventWindowBoundsChanging) || (eventKind == kEventWindowBoundsChanged) )
{
if ( windowStorage->overlayWindow != NULL ) // Resize the overlay window as well
{
(void) GetEventParameter( inEvent, kEventParamCurrentBounds, typeQDRectangle, NULL, sizeof(Rect), NULL, &r );
SizeWindow( windowStorage->overlayWindow, r.right-r.left, r.bottom-r.top, false );
}
}
break;
case kEventClassCommand:
if ( eventKind == kEventCommandProcess )
{
GetEventParameter( inEvent, kEventParamDirectObject, typeHICommand, NULL, sizeof(HICommand), NULL, &command );
if ( command.commandID == kHICommandOK ) // Change the window layering and attributes
{
value = GetControlValueByID( window, 'Rdio', 0 ); // Which group was chosen
windowGroupAttributes = 0; // Now set the attributes for the parent group
if ( GetControlValueByID( window, 'Chek', 0 ) == 1 ) windowGroupAttributes |= kWindowGroupAttrMoveTogether;
ChangeWindowGroupAttributes( g.windowGroups[value-1], windowGroupAttributes, ~windowGroupAttributes );
windowGroupAttributes = kWindowGroupAttrMoveTogether | kWindowGroupAttrLayerTogether | kWindowGroupAttrHideOnCollapse;
err = CreateWindowGroup( windowGroupAttributes, &windowGroup ); // We can only call SetWindowGroupParent() on an empty group, so create a new one
if ( err == noErr ) err = SetWindowGroupParent( windowGroup, g.windowGroups[value-1] ); // Set the new parent
if ( (err == noErr) && (windowStorage->overlayWindow != NULL) )
err = SetWindowGroup( windowStorage->overlayWindow, windowGroup ); // FIRST add the overlay window so that it is on top of the "normal" window
if ( err == noErr )
{
ReleaseWindowGroup( GetWindowGroup(window) ); // Release the old group
err = SetWindowGroup( window, windowGroup ); // Add the window to the new group
}
}
else if ( command.commandID == 'GAtr' ) // Get the window attributes
{
windowGroup = GetWindowGroupParent( GetWindowGroup(window) );
GetWindowGroupAttributes( windowGroup, &windowGroupAttributes );
SetControlValueByID( window, 'Chek', 0, ((windowGroupAttributes & kWindowGroupAttrMoveTogether) != 0) );
if ( windowGroup == g.windowGroups[0] ) SetControlValueByID( window, 'Rdio', 0, 1 );
else if ( windowGroup == g.windowGroups[1] ) SetControlValueByID( window, 'Rdio', 0, 2 );
else SetControlValueByID( window, 'Rdio', 0, 3 );
}
else if ( command.commandID == 'Poof' )
{
SetPortWindowPort( window );
GetMouse( &pt );
LocalToGlobal( &pt );
pt.v -= 50; // Draw the Poof 50 pixels above the mouse
PoofItGood( pt );
}
else if ( command.commandID == 'Over' )
{
if ( windowStorage->overlayWindow == NULL )
{
CreateOverlayWindow( window );
}
else
{
SendWindowCloseEvent( windowStorage->overlayWindow );
}
}
}
break;
}
return( err );
}
static int ioSetFullScreenActual(int fullScreen) {
Rect screen;
int width, height, maxWidth, maxHeight;
int oldWidth, oldHeight;
static Rect rememberOldLocation = {0,0,0,0};
GDHandle dominantGDevice;
windowDescriptorBlock * targetWindowBlock = windowBlockFromIndex(1);
extern Boolean gSqueakBrowserWasHeadlessButMadeFullScreen;
extern Boolean gSqueakBrowserSubProcess;
if (browserActiveAndDrawingContextOk()) {
if (!gSqueakBrowserWasHeadlessButMadeFullScreen) {
gSqueakBrowserWasHeadlessButMadeFullScreen = true;
SetUpMenus();
AdjustMenus();
}
sqShowWindowActual(1);
if (targetWindowBlock->context) //Set context to NULL, if screen is same size as fullscreen we wouldn't get new context
QDEndCGContext(GetWindowPort(targetWindowBlock->handle),&targetWindowBlock->context);
targetWindowBlock->context = NULL;
}
if ((targetWindowBlock == NULL) || (fullScreen && getFullScreenFlag() && !targetWindowBlock->isInvisible))
return 0;
dominantGDevice = getThatDominateGDevice(targetWindowBlock->handle);
if (dominantGDevice == null) {
success(false);
return 0;
}
screen = (**dominantGDevice).gdRect;
if (fullScreen) {
GetPortBounds(GetWindowPort(targetWindowBlock->handle),&rememberOldLocation);
oldWidth = rememberOldLocation.right - rememberOldLocation.left;
oldHeight = rememberOldLocation.bottom - rememberOldLocation.top;
if (targetWindowBlock->isInvisible) {
rememberOldLocation.top = 44;
rememberOldLocation.left = 8;
}
QDLocalToGlobalRect(GetWindowPort(targetWindowBlock->handle),&rememberOldLocation);
if (gSqueakBrowserSubProcess) {
ProcessSerialNumber psn = { 0, kCurrentProcess };
ProcessInfoRec info;
info.processName = NULL;
info.processAppSpec = NULL;
info.processInfoLength = sizeof(ProcessInfoRec);
GetProcessInformation(&psn,&info);
SetFrontProcess(&psn);
}
MenuBarHide();
width = screen.right - screen.left;
height = (screen.bottom - screen.top);
MoveWindow(targetWindowBlock->handle, screen.left, screen.top, true);
SizeWindow(targetWindowBlock->handle, width, height, true);
setFullScreenFlag(true);
} else {
MenuBarRestore();
if (gSqueakBrowserWasHeadlessButMadeFullScreen) {
HideWindow(targetWindowBlock->handle);
{
ProcessSerialNumber psn;
pid_t parent;
OSStatus err;
parent = getppid();
if (parent != 1) {
err = GetProcessForPID(parent,&psn);
if(err == 0)
SetFrontProcess(&psn);
}
}
}
if (EmptyRect(&rememberOldLocation)) {
/* get old window size */
width = (unsigned) getSavedWindowSize() >> 16;
height = getSavedWindowSize() & 0xFFFF;
/* minimum size is 1 x 1 */
width = (width > 0) ? width : 64;
height = (height > 0) ? height : 64;
/* maximum size is screen size inset slightly */
maxWidth = (screen.right - screen.left) - 16;
maxHeight = (screen.bottom - screen.top) - 52;
width = (width <= maxWidth) ? width : maxWidth;
height = (height <= maxHeight) ? height : maxHeight;
MoveWindow(targetWindowBlock->handle, 8, 44, true);
SizeWindow(targetWindowBlock->handle, width, height, true);
} else {
static void process_event(
EventRecord *event)
{
WindowPtr window;
short part_code;
Rect size_rect;
long new_size;
GrafPtr old_port;
switch(event->what)
{
case kHighLevelEvent:
AEProcessAppleEvent(event);
break;
case mouseDown:
/* Did we hit one of the floaters? */
part_code= FindWindow(event->where, &window);
switch (part_code)
{
case inSysWindow:
break;
case inMenuBar:
do_menu_command(MenuSelect(event->where));
break;
case inContent:
if(window != FrontWindow())
SelectWindow(window);
click_in_log_window(window,event->where,(event->modifiers & shiftKey) != 0);
break;
case inDrag:
#ifdef OP_PLATFORM_MAC_CARBON_FLAG
{
Rect tempRect;
GetRegionBounds(GetGrayRgn(), &tempRect);
DragWindow(window, event->where, &tempRect);
}
#else
DragWindow(window, event->where, &qd.screenBits.bounds);
#endif
break;
case inGrow:
#ifdef OP_PLATFORM_MAC_CARBON_FLAG
GetRegionBounds(GetGrayRgn(), &size_rect);
#else
size_rect = qd.screenBits.bounds;
#endif
InsetRect(&size_rect, 4, 4);
new_size= GrowWindow(window, event->where, &size_rect);
if(new_size)
{
/* Resize the window */
SizeWindow(window, LoWord(new_size), HiWord(new_size), true);
}
break;
case inGoAway:
if(TrackGoAway(window, event->where))
{
/* Close the window... */
handle_close(window);
}
break;
case inZoomIn:
case inZoomOut:
if(TrackBox(window, event->where, part_code))
{
GetPort(&old_port);
SetPortWindowPort(window);
#ifdef OP_PLATFORM_MAC_CARBON_FLAG
{
Rect windowBounds;
GetWindowPortBounds(window, &windowBounds);
EraseRect(&windowBounds);
}
#else
EraseRect(&window->portRect);
#endif
ZoomWindow(window, part_code, true);
SetPort(old_port);
}
break;
}
break;
case keyDown:
case autoKey:
if(!process_key(event, event->message&charCodeMask))
{
/* Not handled by anyone.. */
SysBeep(-1);
}
break;
case updateEvt:
/* Update the window.. */
update_window((WindowPtr)event->message);
break;
case activateEvt:
/* Activate event->message, event->modifiers&activeFlag.. */
break;
case osEvt:
switch ((event->message>>24) & 0xff)
{
case suspendResumeMessage:
if (event->message&resumeFlag)
{
/* resume */
#ifdef OP_PLATFORM_MAC_CARBON_FLAG
{
Cursor arrowCursor;
SetCursor(GetQDGlobalsArrow(&arrowCursor));
}
#else
SetCursor(&qd.arrow);
#endif
}
else
{
/* suspend */
}
break;
case mouseMovedMessage:
break;
}
break;
}
return;
}
void
TBarView::PlaceApplicationBar()
{
BRect screenFrame = (BScreen(Window())).Frame();
if (fState == kMiniState) {
if (!fInlineScrollView->IsHidden())
fInlineScrollView->Hide();
SizeWindow(screenFrame);
PositionWindow(screenFrame);
Window()->UpdateIfNeeded();
Invalidate();
return;
}
if (fInlineScrollView->IsHidden())
fInlineScrollView->Show();
BRect expandoFrame(0, 0, 0, 0);
if (fVertical) {
// left or right
expandoFrame.top = fTrayLocation != 0 ? fDragRegion->Frame().bottom + 1
: fBarMenuBar->Frame().bottom + 1;
expandoFrame.left = fDragRegion->Frame().left;
expandoFrame.right = expandoFrame.left + gMinimumWindowWidth;
expandoFrame.bottom = fState == kFullState ? screenFrame.bottom
: expandoFrame.top + 1;
} else {
// top or bottom
expandoFrame.top = 0;
expandoFrame.bottom = fBarApp->IconSize() + 4;
if (fBarMenuBar != NULL)
expandoFrame.left = fBarMenuBar->Frame().Width() + 1;
if (fTrayLocation != 0 && fDragRegion != NULL) {
expandoFrame.right = screenFrame.Width()
- fDragRegion->Frame().Width() - 1;
} else
expandoFrame.right = screenFrame.Width();
}
fInlineScrollView->DetachScrollers();
fInlineScrollView->MoveTo(expandoFrame.LeftTop());
fInlineScrollView->ResizeTo(expandoFrame.Width(), fVertical
? screenFrame.bottom - expandoFrame.top
: expandoFrame.Height());
fExpandoMenuBar->MoveTo(0, 0);
fExpandoMenuBar->ResizeTo(expandoFrame.Width(), expandoFrame.Height());
if (!fVertical) {
// Set the max item width based on icon size
fExpandoMenuBar->SetMaxItemWidth();
}
if (fState == kExpandoState)
fExpandoMenuBar->BuildItems();
SizeWindow(screenFrame);
PositionWindow(screenFrame);
fExpandoMenuBar->DoLayout();
// force menu to resize
CheckForScrolling();
Window()->UpdateIfNeeded();
Invalidate();
}
void GBWindow::SetSize(short width, short height) {
view->SetSize(width, height);
#if MAC
SizeWindow(window, view->Width(), view->Height(), true);
#endif
}
void
XResizeWindow(
Display* display, /* Display. */
Window window, /* Window. */
unsigned int width,
unsigned int height)
{
MacDrawable *macWin = (MacDrawable *) window;
GWorldPtr destPort;
destPort = TkMacGetDrawablePort(window);
if (destPort == NULL) {
return;
}
display->request++;
SetPort((GrafPtr) destPort);
if (Tk_IsTopLevel(macWin->winPtr)) {
if (!Tk_IsEmbedded(macWin->winPtr)) {
/*
* NOTE: we are not adding the new space to the update
* region. It is currently assumed that Tk will need
* to completely redraw anway.
*/
SizeWindow((WindowRef) destPort,
(short) width, (short) height, false);
TkMacInvalidateWindow(macWin, TK_WINDOW_ONLY);
TkMacInvalClipRgns(macWin->winPtr);
} else {
int deltaX, deltaY;
/*
* Find the Parent window -
* For an embedded window this will be its container.
*/
TkWindow *contWinPtr;
contWinPtr = TkpGetOtherWindow(macWin->winPtr);
if (contWinPtr != NULL) {
MacDrawable *macParent = contWinPtr->privatePtr;
TkMacInvalClipRgns(macParent->winPtr);
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW);
deltaX = macParent->xOff +
macWin->winPtr->changes.x - macWin->xOff;
deltaY = macParent->yOff +
macWin->winPtr->changes.y - macWin->yOff;
UpdateOffsets(macWin->winPtr, deltaX, deltaY);
} else {
/*
* This is the case where we are embedded in
* another app. At this point, we are assuming that
* the changes.x,y is not maintained, if you need
* the info get it from Tk_GetRootCoords,
* and that the toplevel sits at 0,0 when it is drawn.
*/
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW);
UpdateOffsets(macWin->winPtr, 0, 0);
}
}
} else {
/* TODO: update all xOff & yOffs */
int deltaX, deltaY, parentBorderwidth;
MacDrawable *macParent = macWin->winPtr->parentPtr->privatePtr;
if (macParent == NULL) {
return; /* TODO: Probably should be a panic */
}
TkMacInvalClipRgns(macParent->winPtr);
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW);
deltaX = - macWin->xOff;
deltaY = - macWin->yOff;
parentBorderwidth = macWin->winPtr->parentPtr->changes.border_width;
deltaX += macParent->xOff + parentBorderwidth +
macWin->winPtr->changes.x;
deltaY += macParent->yOff + parentBorderwidth +
macWin->winPtr->changes.y;
UpdateOffsets(macWin->winPtr, deltaX, deltaY);
}
}
void
XMoveResizeWindow(
Display* display, /* Display. */
Window window, /* Window. */
int x, int y,
unsigned int width,
unsigned int height)
{
MacDrawable *macWin = (MacDrawable *) window;
GWorldPtr destPort;
destPort = TkMacGetDrawablePort(window);
if (destPort == NULL) {
return;
}
SetPort((GrafPtr) destPort);
if (Tk_IsTopLevel(macWin->winPtr) && !Tk_IsEmbedded(macWin->winPtr)) {
/*
* NOTE: we are not adding the new space to the update
* region. It is currently assumed that Tk will need
* to completely redraw anway.
*/
SizeWindow((WindowRef) destPort,
(short) width, (short) height, false);
tkMacMoveWindow((WindowRef) destPort, x, y);
/* TODO: is the following right? */
TkMacInvalidateWindow(macWin, TK_WINDOW_ONLY);
TkMacInvalClipRgns(macWin->winPtr);
} else {
int deltaX, deltaY, parentBorderwidth;
Rect bounds;
MacDrawable *macParent;
/*
* Find the Parent window -
* For an embedded window this will be its container.
*/
if (Tk_IsEmbedded(macWin->winPtr)) {
TkWindow *contWinPtr;
contWinPtr = TkpGetOtherWindow(macWin->winPtr);
if (contWinPtr == NULL) {
panic("XMoveResizeWindow could not find container");
}
macParent = contWinPtr->privatePtr;
/*
* NOTE: Here we should handle out of process embedding.
*/
} else {
macParent = macWin->winPtr->parentPtr->privatePtr;
if (macParent == NULL) {
return; /* TODO: Probably should be a panic */
}
}
TkMacInvalClipRgns(macParent->winPtr);
TkMacInvalidateWindow(macWin, TK_PARENT_WINDOW);
deltaX = - macWin->xOff;
deltaY = - macWin->yOff;
/*
* If macWin->winPtr is an embedded window, don't offset by its
* parent's borderwidth...
*/
if (!Tk_IsEmbedded(macWin->winPtr)) {
parentBorderwidth = macWin->winPtr->parentPtr->changes.border_width;
} else {
parentBorderwidth = 0;
}
deltaX += macParent->xOff + parentBorderwidth +
macWin->winPtr->changes.x;
deltaY += macParent->yOff + parentBorderwidth +
macWin->winPtr->changes.y;
UpdateOffsets(macWin->winPtr, deltaX, deltaY);
TkMacWinBounds(macWin->winPtr, &bounds);
InvalRect(&bounds);
}
}
boolean playeropenmovieinwindow ( ptrfilespec f ) {
//
// 2006-06-23 creedon: FSRef-zed
//
// 7.0b4 PBS: open a movie in the QuickTime Player window and display it. If the window isn't already open, open it.
//
short movieresref;
OSErr err;
hdlwindowinfo hinfo;
FSSpec fs;
if (macgetfsspec (f, &fs) != noErr)
return (false);
if (!findplayerwindow (&hinfo))
playeropencommand (); // If the Player window doesn't exist, create a new one.
getwindowinfo (playerwindow, &playerwindowinfo);
playerdisposecurrentmovie (); // make sure the current movie has been disposed
SetGWorld (GetWindowPort (playerwindow), nil);
err = OpenMovieFile ( &fs, &movieresref, fsRdPerm);
if (err != noErr)
return (false);
NewMovieFromFile (¤tmovie, movieresref, nil, nil, newMovieActive, nil);
CloseMovieFile (movieresref);
SetMovieGWorld (currentmovie, GetWindowPort (playerwindow), nil);
GetMovieBox (currentmovie, ¤tmovierect);
OffsetRect (¤tmovierect, -currentmovierect.left, -currentmovierect.top);
SetMovieBox (currentmovie, ¤tmovierect);
currentcontroller = NewMovieController (currentmovie, ¤tmovierect, mcTopLeftMovie);
MCGetControllerBoundsRect (currentcontroller, ¤tmovierect);
//MCSetActionFilterWithRefCon (currentcontroller, NewMCActionFilterWithRefConProc(playermoviecontrollereventfilter), (long) playerwindow);
SizeWindow (playerwindow, currentmovierect.right, currentmovierect.bottom, false);
(**playerwindowinfo).contentrect = currentmovierect;
AlignWindow (playerwindow, false, nil, nil); // position for optimal playback
//MCDoAction (currentcontroller, mcActionSetKeysEnabled, (void *) true); /*enable keyboard input*/ /*No!*/
MoviesTask (nil, 0);
MCIdle (currentcontroller);
return (true);
} // playeropenmovieinwindow
static void setsize_window(MacWindow* macwin)
{
SizeWindow(macwin->ref, macwin->width, macwin->hight, 0);
}
void
TExpandoMenuBar::AddTeam(BList* team, BBitmap* icon, char* name,
char* signature)
{
int32 iconSize = static_cast<TBarApp*>(be_app)->IconSize();
desk_settings* settings = static_cast<TBarApp*>(be_app)->Settings();
float itemWidth = -1.0f;
if (fVertical)
itemWidth = fBarView->Bounds().Width();
else {
itemWidth = iconSize;
if (!settings->hideLabels)
itemWidth += gMinimumWindowWidth - kMinimumIconSize;
else
itemWidth += kIconPadding * 2;
}
float itemHeight = -1.0f;
TTeamMenuItem* item = new TTeamMenuItem(team, icon, name, signature,
itemWidth, itemHeight);
if (settings->trackerAlwaysFirst
&& strcasecmp(signature, kTrackerSignature) == 0) {
AddItem(item, 0);
} else if (settings->sortRunningApps) {
TTeamMenuItem* teamItem = dynamic_cast<TTeamMenuItem*>(ItemAt(0));
int32 firstApp = 0;
// if Tracker should always be the first item, we need to skip it
// when sorting in the current item
if (settings->trackerAlwaysFirst && teamItem != NULL
&& strcasecmp(teamItem->Signature(), kTrackerSignature) == 0) {
firstApp++;
}
BCollator collator;
BLocale::Default()->GetCollator(&collator);
int32 i = firstApp;
int32 itemCount = CountItems();
while (i < itemCount) {
teamItem = dynamic_cast<TTeamMenuItem*>(ItemAt(i));
if (teamItem != NULL && collator.Compare(teamItem->Label(), name)
> 0) {
AddItem(item, i);
break;
}
i++;
}
// was the item added to the list yet?
if (i == itemCount)
AddItem(item);
} else
AddItem(item);
if (fVertical && settings->superExpando && settings->expandNewTeams)
item->ToggleExpandState(false);
SizeWindow(1);
Window()->UpdateIfNeeded();
}
void
TBarView::ChangeState(int32 state, bool vertical, bool left, bool top)
{
bool vertSwap = (fVertical != vertical);
bool leftSwap = (fLeft != left);
fState = state;
fVertical = vertical;
fLeft = left;
fTop = top;
BRect screenFrame = (BScreen(Window())).Frame();
PlaceBeMenu();
if (fVertical){
#if SA_CLOCK
PlaceClock(); // tray dependent on clock location
#endif
PlaceTray(vertSwap, leftSwap, screenFrame);
} else {
PlaceTray(vertSwap, leftSwap, screenFrame);
#if SA_CLOCK
PlaceClock(); // clock is dependent on tray location
#endif
}
// We need to keep track of what apps are expanded.
BList expandedItems;
BString *signature = NULL;
if (fVertical && Expando() && static_cast<TBarApp *>(be_app)->Settings()->superExpando) {
// Get a list of the Signatures of expanded apps - Can't use team_id because
// there can be more than one team per application
if (fVertical && Expando() && vertical && fExpando) {
for (int index = 0; index < fExpando->CountItems(); index++) {
TTeamMenuItem *item = dynamic_cast<TTeamMenuItem *>(fExpando->ItemAt(index));
if (item != NULL && item->IsExpanded()) {
signature = new BString(item->Signature());
expandedItems.AddItem((void *)signature);
}
}
}
}
PlaceApplicationBar(screenFrame);
SizeWindow(screenFrame);
PositionWindow(screenFrame);
Window()->UpdateIfNeeded();
// Re-expand those apps.
if (expandedItems.CountItems() > 0) {
for (int sigIndex = expandedItems.CountItems(); sigIndex-- > 0;) {
signature = static_cast<BString *>(expandedItems.ItemAt(sigIndex));
if (signature == NULL)
continue;
// Start at the 'bottom' of the list working up.
// Prevents being thrown off by expanding items.
for (int teamIndex = fExpando->CountItems(); teamIndex-- > 0;) {
TTeamMenuItem *item = dynamic_cast<TTeamMenuItem *>(fExpando->ItemAt(teamIndex));
if (item != NULL && !signature->Compare(item->Signature())) {
item->ToggleExpandState(false);
break;
}
}
}
// Clean up expanded signature list.
while (!expandedItems.IsEmpty()) {
delete static_cast<BString *>(expandedItems.RemoveItem((int32)0));
}
fExpando->SizeWindow();
}
Invalidate();
}
//default window event handler
static OSStatus WindowEventHandler(EventHandlerCallRef nextHandler, EventRef event, void *userData)
{
OSStatus result = noErr;
uint32_t d_width;
uint32_t d_height;
UInt32 class = GetEventClass (event);
UInt32 kind = GetEventKind (event);
result = CallNextEventHandler(nextHandler, event);
aspect(&d_width,&d_height,A_NOZOOM);
if(class == kEventClassCommand)
{
HICommand theHICommand;
GetEventParameter( event, kEventParamDirectObject, typeHICommand, NULL, sizeof( HICommand ), NULL, &theHICommand );
switch ( theHICommand.commandID )
{
case kHICommandQuit:
mplayer_put_key(KEY_CLOSE_WIN);
break;
case kHalfScreenCmd:
if(vo_quartz_fs)
{
vo_fs = (!(vo_fs)); window_fullscreen();
}
SizeWindow(theWindow, (d_width/2), ((d_width/movie_aspect)/2), 1);
window_resized();
break;
case kNormalScreenCmd:
if(vo_quartz_fs)
{
vo_fs = (!(vo_fs)); window_fullscreen();
}
SizeWindow(theWindow, d_width, (d_width/movie_aspect), 1);
window_resized();
break;
case kDoubleScreenCmd:
if(vo_quartz_fs)
{
vo_fs = (!(vo_fs)); window_fullscreen();
}
SizeWindow(theWindow, (d_width*2), ((d_width/movie_aspect)*2), 1);
window_resized();
break;
case kFullScreenCmd:
vo_fs = (!(vo_fs)); window_fullscreen();
break;
case kKeepAspectCmd:
vo_keepaspect = (!(vo_keepaspect));
CheckMenuItem (aspectMenu, 1, vo_keepaspect);
window_resized();
break;
case kAspectOrgCmd:
movie_aspect = old_movie_aspect;
if(!vo_quartz_fs)
{
SizeWindow(theWindow, dstRect.right, (dstRect.right/movie_aspect),1);
}
window_resized();
break;
case kAspectFullCmd:
movie_aspect = 4.0f/3.0f;
if(!vo_quartz_fs)
{
SizeWindow(theWindow, dstRect.right, (dstRect.right/movie_aspect),1);
}
window_resized();
break;
case kAspectWideCmd:
movie_aspect = 16.0f/9.0f;
if(!vo_quartz_fs)
{
SizeWindow(theWindow, dstRect.right, (dstRect.right/movie_aspect),1);
}
window_resized();
break;
case kPanScanCmd:
vo_panscan = (!(vo_panscan));
CheckMenuItem (aspectMenu, 2, vo_panscan);
window_panscan();
window_resized();
break;
default:
result = eventNotHandledErr;
break;
}
}
else if(class == kEventClassWindow)
