//------------------------------------------------------------------------
void pixel_map::draw(WindowRef window, const Rect *device_rect, const Rect *pmap_rect) const
{
if(m_pmap == nil || m_buf == NULL) return;
PixMapHandle pm = GetGWorldPixMap (m_pmap);
CGrafPtr port = GetWindowPort (window);
Rect dest_rect;
// Again, I used the Quicktime version.
// Good old 'CopyBits' does better interpolation when scaling
// but does not support all pixel depths.
MacSetRect (&dest_rect, 0, 0, this->width(), this->height());
ImageDescriptionHandle image_description;
MakeImageDescriptionForPixMap (pm, &image_description);
if (image_description != nil)
{
DecompressImage (GetPixBaseAddr (pm), image_description, GetPortPixMap (port), nil, &dest_rect, ditherCopy, nil);
DisposeHandle ((Handle) image_description);
}
}
int closeWindow(int windowIndex) {
wHandleType windowHandle;
windowHandle = windowHandleFromIndex(windowIndex);
if(windowHandle == NULL)
return 0;
if (windowBlockFromIndex(windowIndex)->context)
QDEndCGContext(GetWindowPort(windowBlockFromIndex(windowIndex)->handle),&windowBlockFromIndex(windowIndex)->context);
//CGContextRelease(windowBlockFromIndex(windowIndex)->context);
if (windowBlockFromIndex(windowIndex)->windowTrackingRef) {
ReleaseMouseTrackingRegion(windowBlockFromIndex(windowIndex)->windowTrackingRef );
windowBlockFromIndex(windowIndex)->windowTrackingRef = NULL;
}
windowBlockFromIndex(windowIndex)->context = NULL;
RemoveWindowBlock(windowBlockFromIndex(windowIndex));
DisposeWindow(windowHandle);
return 1;
}
void QMacWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoint &offset)
{
Q_UNUSED(offset);
// Get a context for the widget.
#ifndef QT_MAC_USE_COCOA
CGContextRef context;
CGrafPtr port = GetWindowPort(qt_mac_window_for(widget));
QDBeginCGContext(port, &context);
#else
extern CGContextRef qt_mac_graphicsContextFor(QWidget *);
CGContextRef context = qt_mac_graphicsContextFor(widget);
#endif
CGContextSaveGState(context);
// Flip context.
CGContextTranslateCTM(context, 0, widget->height());
CGContextScaleCTM(context, 1, -1);
// Clip to region.
const QVector<QRect> &rects = rgn.rects();
for (int i = 0; i < rects.size(); ++i) {
const QRect &rect = rects.at(i);
CGContextAddRect(context, CGRectMake(rect.x(), rect.y(), rect.width(), rect.height()));
}
CGContextClip(context);
// Draw the image onto the window.
const CGRect dest = CGRectMake(0, 0, widget->width(), widget->height());
const CGImageRef image = d_ptr->device.toMacCGImageRef();
qt_mac_drawCGImage(context, &dest, image);
CFRelease(image);
// Restore context.
CGContextRestoreGState(context);
#ifndef QT_MAC_USE_COCOA
QDEndCGContext(port, &context);
#else
CGContextFlush(context);
#endif
}
bool wxGLCanvas::Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name,
const int *attribList,
const wxPalette& WXUNUSED(palette))
{
m_needsUpdate = false;
m_macCanvasIsShown = false;
m_glFormat = WXGLChoosePixelFormat(attribList);
if ( !m_glFormat )
return false;
if ( !wxWindow::Create(parent, id, pos, size, style, name) )
return false;
m_dummyContext = WXGLCreateContext(m_glFormat, NULL);
static GLint gCurrentBufferName = 1;
m_bufferName = gCurrentBufferName++;
aglSetInteger (m_dummyContext, AGL_BUFFER_NAME, &m_bufferName);
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
if ( UMAGetSystemVersion() >= 0x1050 )
{
aglSetWindowRef(m_dummyContext, MacGetTopLevelWindowRef());
}
else
#endif
{
AGLDrawable drawable = (AGLDrawable)GetWindowPort(MAC_WXHWND(MacGetTopLevelWindowRef()));
aglSetDrawable(m_dummyContext, drawable);
}
m_macCanvasIsShown = true;
return true;
}
int
TkGenerateButtonEvent(
int x, /* X location of mouse */
int y, /* Y location of mouse */
Window window, /* X Window containing button event. */
unsigned int state) /* Button Key state suitable for X event */
{
MouseEventData med;
bzero(&med, sizeof(MouseEventData));
med.state = state;
med.window = window;
med.global.h = x;
med.global.v = y;
FindWindow(med.global, &med.whichWin);
med.activeNonFloating = ActiveNonFloatingWindow();
med.local = med.global;
QDGlobalToLocalPoint(GetWindowPort(med.whichWin), &med.local);
return GenerateButtonEvent(&med);
}
void wxOverlayImpl::Reset()
{
if ( m_overlayContext )
{
#ifndef __LP64__
OSStatus err = QDEndCGContext(GetWindowPort(m_overlayWindow), &m_overlayContext);
if ( err != noErr )
{
wxFAIL_MSG("Couldn't end the context on the overlay window");
}
#endif
m_overlayContext = NULL ;
}
// todo : don't dispose, only hide and reposition on next run
if (m_overlayWindow)
{
DisposeWindow(m_overlayWindow);
m_overlayWindow = NULL ;
}
}
void DrawImage( void )
{
OSErr err = noErr;
Handle hOpenTypeList = NewHandle(0);
long numTypes = 0;
FSSpec theFSSpec;
Rect bounds;
GraphicsImportComponent importer = 0;
BuildGraphicsImporterValidFileTypes( hOpenTypeList, &numTypes );
HLock( hOpenTypeList );
err = GetOneFileWithPreview(numTypes, (OSTypePtr)*hOpenTypeList, &theFSSpec, NULL);
DisposeHandle( hOpenTypeList );
if ( err ) return;
// locate and open a graphics importer component which can be used to draw the
// selected file. If a suitable importer is not found the ComponentInstance
// is set to NULL.
err = GetGraphicsImporterForFile( &theFSSpec, // specifies the file to be drawn
&importer ); // pointer to the returned GraphicsImporterComponent
// get the native size of the image associated with the importer
err = GraphicsImportGetNaturalBounds( importer, // importer instance
&bounds ); // returned bounds
OffsetRect( &bounds, 10, 45 );
window = NewCWindow( NULL, &bounds, "\pDraw Image", true, documentProc, (WindowPtr)-1, true, 0);
// set the graphics port for drawing
err = GraphicsImportSetGWorld( importer, // importer instance
GetWindowPort( window ), // destination graphics port or GWorld
NULL ); // destination GDevice, set to NULL uses GWorlds device
// draw the image
err = GraphicsImportDraw( importer );
// close the importer instance
CloseComponent( importer );
}
static PyObject *
MacOS_splash(PyObject *self, PyObject *args)
{
int resid = -1;
static DialogPtr curdialog = NULL;
DialogPtr olddialog;
WindowRef theWindow;
CGrafPtr thePort;
#if 0
short xpos, ypos, width, height, swidth, sheight;
#endif
if (!PyArg_ParseTuple(args, "|i", &resid))
return NULL;
olddialog = curdialog;
curdialog = NULL;
if ( resid != -1 ) {
curdialog = GetNewDialog(resid, NULL, (WindowPtr)-1);
if ( curdialog ) {
theWindow = GetDialogWindow(curdialog);
thePort = GetWindowPort(theWindow);
#if 0
width = thePort->portRect.right - thePort->portRect.left;
height = thePort->portRect.bottom - thePort->portRect.top;
swidth = qd.screenBits.bounds.right - qd.screenBits.bounds.left;
sheight = qd.screenBits.bounds.bottom - qd.screenBits.bounds.top - LMGetMBarHeight();
xpos = (swidth-width)/2;
ypos = (sheight-height)/5 + LMGetMBarHeight();
MoveWindow(theWindow, xpos, ypos, 0);
ShowWindow(theWindow);
#endif
DrawDialog(curdialog);
}
}
if (olddialog)
DisposeDialog(olddialog);
Py_INCREF(Py_None);
return Py_None;
}
static void ROM_WindowUpdate(_THIS, int numrects, SDL_Rect *rects)
{
GWorldPtr memworld;
GrafPtr saveport;
CGrafPtr thePort;
const BitMap *memBits;
const BitMap *winBits;
int i;
Rect update;
/* Copy from the offscreen GWorld to the window port */
GetPort(&saveport);
SetPortWindowPort(SDL_Window);
thePort = GetWindowPort(SDL_Window);
memworld = (GWorldPtr)GetWRefCon(SDL_Window);
#if TARGET_API_MAC_CARBON && ACCESSOR_CALLS_ARE_FUNCTIONS
memBits = GetPortBitMapForCopyBits((CGrafPtr) memworld);
#else
memBits = &((GrafPtr)memworld)->portBits;
#endif
#if TARGET_API_MAC_CARBON && ACCESSOR_CALLS_ARE_FUNCTIONS
winBits = GetPortBitMapForCopyBits(thePort);
#else
winBits = &SDL_Window->portBits;
#endif
for ( i=0; i<numrects; ++i ) {
update.left = rects[i].x;
update.right = rects[i].x+rects[i].w;
update.top = rects[i].y;
update.bottom = rects[i].y+rects[i].h;
CopyBits(memBits, winBits,
&update, &update, srcCopy, nil);
}
#if TARGET_API_MAC_CARBON
if ( QDIsPortBuffered(thePort) ) {
QDFlushPortBuffer(thePort, NULL);
}
#endif
SetPort(saveport);
}
/* DisplayDialogCmd(theDialog, dlogItemNo, cmd)
Displays the command in an IGOR-style dialog. See GBLoadWaveDialog.c
for an example.
dlogItemNo is the item number of the dialog item in which the command
is to be displayed. On the Macintosh, this must be a user item. On Windows,
it must be an EDITTEXT item.
Thread Safety: DisplayDialogCmd is not thread-safe.
*/
void
DisplayDialogCmd(DialogPtr theDialog, int dlogItemNo, const char* cmd)
{
WindowRef theWindow;
CGrafPtr thePort;
Rect box;
int font, size;
int lineHeight;
FontInfo info;
RgnHandle saveClipRgnH;
theWindow = GetDialogWindow(theDialog);
thePort = GetWindowPort(theWindow);
font = GetPortTextFont(thePort); // Save text characteristics.
size = GetPortTextSize(thePort);
TextFont(kFontIDMonaco);
TextSize(9);
GetFontInfo(&info);
lineHeight = info.ascent + info.descent + info.leading;
GetDBox(theDialog, dlogItemNo, &box);
saveClipRgnH = NewRgn();
if (saveClipRgnH != NULL) {
GetClip(saveClipRgnH);
ClipRect(&box);
InsetRect(&box, 2, 2);
EraseRect(&box);
if (*cmd != 0) {
MoveTo(box.left+2, box.top + info.ascent + 2);
DrawDialogCmd(cmd, lineHeight);
}
SetClip(saveClipRgnH);
DisposeRgn(saveClipRgnH);
}
TextFont(font); // Restore font, size, style.
TextSize(size);
}
void QuartzWindow::close() {
if (!is_open())
return;
CGrafPtr gp = GetWindowPort(my_window());
if (gp != NULL) // already closed by std handler
QDEndCGContext( gp, &myContext );
CGColorRelease((CGColorRef) _red);
CGColorRelease((CGColorRef) _yellow);
CGColorRelease((CGColorRef) _black);
CGColorRelease((CGColorRef) _gray);
CGColorRelease((CGColorRef) _white);
CGColorSpaceRelease(_color_space);
WindowSet::rm_window(my_window());
if (gp != NULL)
DisposeWindow(my_window());
_is_open = false;
DisposeEventHandlerUPP(_my_event_handler_upp);
DisposeEventHandlerUPP(_my_spy_event_handler_upp);
_my_event_handler = NULL;
_my_spy_event_handler = NULL;
_quartz_win = NULL;
}
static INT ActivateMacWin (GRAPH_WINDOW *gw, INT tool)
{
WindowPtr MacWindow;
MacWindow = MAC_WIN(gw);
DrawGrowIcon(MacWindow);
SetPort(GetWindowPort(MacWindow));
switch (tool)
{
case arrowTool : SetMyCursor(arrowCurs); break;
case crossTool : SetMyCursor(crossCurs); break;
case choiceTool : SetMyCursor(choiceCurs); break;
case circleTool : SetMyCursor(circleCurs); break;
case handTool : SetMyCursor(handCurs); break;
case heartTool : SetMyCursor(heartCurs); break;
case gnoedelTool : SetMyCursor(gnoedelCurs); break;
}
return (0);
}
bool wxGLContext::SetCurrent(const wxGLCanvas& win) const
{
if ( !m_glContext )
return false;
AGLDrawable drawable = (AGLDrawable)GetWindowPort(
MAC_WXHWND(win.MacGetTopLevelWindowRef()));
GLint bufnummer = win.GetAglBufferName();
aglSetInteger(m_glContext, AGL_BUFFER_NAME, &bufnummer);
//win.SetLastContext(m_glContext);
const_cast<wxGLCanvas&>(win).SetViewport();
if ( !aglSetDrawable(m_glContext, drawable) )
{
wxLogAGLError("aglSetDrawable");
return false;
}
return WXGLSetCurrentContext(m_glContext);
}
static void DrawToolBox (GRAPH_WINDOW *gw, INT tool)
{
Rect r,dstRect;
CGrafPtr myPort;
PicHandle toolBox;
WindowPtr theWindow;
theWindow = MAC_WIN(gw);
myPort = GetWindowPort(theWindow);
SetPort(myPort);
GetPortBounds(myPort,&r);
toolBox = GetPicture(TOOLBOX_RSRC_ID);
if (toolBox!=NULL)
{
SetRect(&dstRect,r.right-120,r.bottom-15,r.right-15,r.bottom);
DrawPicture(toolBox,&dstRect);
}
SetRect(&dstRect,r.right-119+tool*15,r.bottom-14,r.right-104+tool*15,r.bottom);
InvertRect(&dstRect);
}
static void langerrorupdate (void) {
langerrorsetrects ();
/*
eraserect ((**hw).contentrect);
*/
#if TARGET_API_MAC_CARBON == 1
drawthemeborder ((**langerrordata).textrect, (**langerrorwindowinfo).contentrect);
#endif
langerrordrawicon (false);
#ifdef gray3Dlook
pushbackcolor (&whitecolor);
eraserect ((**langerrordata).textrect);
#endif
// framerect ((**langerrordata).textrect);
langerrorframetext ();
langerrordrawtext (false);
//Timothy Paustian 10/5/00
//For some reason the buffer is not being flushed for this window.
//This should fix it.
#if TARGET_API_MAC_CARBON == 1
QDFlushPortBuffer (GetWindowPort (langerrorwindow), nil);
#endif
#ifdef gray3Dlook
popbackcolor ();
#endif
} /*langerrorupdate*/
MODULE_SCOPE int
TkMacOSXProcessMouseEvent(TkMacOSXEvent *eventPtr, MacEventStatus * statusPtr)
{
Tk_Window tkwin;
Point where, where2;
int result;
TkDisplay * dispPtr;
OSStatus err;
MouseEventData mouseEventData, * medPtr = &mouseEventData;
int isFrontProcess;
switch (eventPtr->eKind) {
case kEventMouseDown:
case kEventMouseUp:
case kEventMouseMoved:
case kEventMouseDragged:
case kEventMouseWheelMoved:
break;
default:
return false;
break;
}
err = ChkErr(GetEventParameter, eventPtr->eventRef,
kEventParamMouseLocation,
typeQDPoint, NULL,
sizeof(where), NULL,
&where);
if (err != noErr) {
GetGlobalMouse(&where);
}
err = ChkErr(GetEventParameter, eventPtr->eventRef,
kEventParamWindowRef,
typeWindowRef, NULL,
sizeof(WindowRef), NULL,
&medPtr->whichWin);
if (err == noErr) {
err = ChkErr(GetEventParameter, eventPtr->eventRef,
kEventParamWindowPartCode,
typeWindowPartCode, NULL,
sizeof(WindowPartCode), NULL,
&medPtr->windowPart);
}
if (err != noErr) {
medPtr->windowPart = FindWindow(where, &medPtr->whichWin);
}
medPtr->window = TkMacOSXGetXWindow(medPtr->whichWin);
if (medPtr->whichWin != NULL && medPtr->window == None) {
return false;
}
if (eventPtr->eKind == kEventMouseDown) {
if (IsWindowActive(medPtr->whichWin) && IsWindowPathSelectEvent(
medPtr->whichWin, eventPtr->eventRef)) {
ChkErr(WindowPathSelect, medPtr->whichWin, NULL, NULL);
return false;
}
if (medPtr->windowPart == inProxyIcon) {
TkMacOSXTrackingLoop(1);
err = ChkErr(TrackWindowProxyDrag, medPtr->whichWin, where);
TkMacOSXTrackingLoop(0);
if (err == errUserWantsToDragWindow) {
medPtr->windowPart = inDrag;
} else {
return false;
}
}
}
isFrontProcess = Tk_MacOSXIsAppInFront();
if (isFrontProcess) {
medPtr->state = ButtonModifiers2State(GetCurrentEventButtonState(),
GetCurrentEventKeyModifiers());
} else {
medPtr->state = ButtonModifiers2State(GetCurrentButtonState(),
GetCurrentKeyModifiers());
}
medPtr->global = where;
err = ChkErr(GetEventParameter, eventPtr->eventRef,
kEventParamWindowMouseLocation,
typeQDPoint, NULL,
sizeof(Point), NULL,
&medPtr->local);
if (err == noErr) {
if (medPtr->whichWin) {
Rect widths;
GetWindowStructureWidths(medPtr->whichWin, &widths);
medPtr->local.h -= widths.left;
medPtr->local.v -= widths.top;
}
} else {
medPtr->local = where;
if (medPtr->whichWin) {
QDGlobalToLocalPoint(GetWindowPort(medPtr->whichWin),
&medPtr->local);
}
}
medPtr->activeNonFloating = ActiveNonFloatingWindow();
dispPtr = TkGetDisplayList();
tkwin = Tk_IdToWindow(dispPtr->display, medPtr->window);
if (eventPtr->eKind != kEventMouseDown) {
int res = false;
switch (eventPtr->eKind) {
case kEventMouseUp:
/*
* The window manager only needs to know about mouse down
* events and sometimes we need to "eat" the mouse up.
* Otherwise, we just pass the event to Tk.
*/
if (TkMacOSXGetEatButtonUp()) {
TkMacOSXSetEatButtonUp(false);
} else {
res = GenerateButtonEvent(medPtr);
}
break;
case kEventMouseWheelMoved:
err = ChkErr(GetEventParameter, eventPtr->eventRef,
kEventParamMouseWheelDelta, typeLongInteger, NULL,
sizeof(long), NULL, &medPtr->delta);
if (err != noErr ) {
statusPtr->err = 1;
} else {
EventMouseWheelAxis axis;
err = ChkErr(GetEventParameter, eventPtr->eventRef,
kEventParamMouseWheelAxis, typeMouseWheelAxis,
NULL, sizeof(EventMouseWheelAxis), NULL, &axis);
if (err == noErr && axis == kEventMouseWheelAxisX) {
medPtr->state |= ShiftMask;
}
res = GenerateMouseWheelEvent(medPtr);
}
break;
case kEventMouseMoved:
case kEventMouseDragged:
res = GeneratePollingEvents(medPtr);
break;
default:
Tcl_Panic("Unknown mouse event !");
}
if (res) {
statusPtr->stopProcessing = 1;
}
return res;
}
TkMacOSXSetEatButtonUp(false);
if (medPtr->whichWin) {
/*
* We got a mouse down in a window
* See if this is the activate click
* This click moves the window forward. We don't want
* the corresponding mouse-up to be reported to the application
* or else it will mess up some Tk scripts.
*/
if (!(TkpIsWindowFloating(medPtr->whichWin))
&& (medPtr->whichWin != medPtr->activeNonFloating
|| !isFrontProcess)) {
int frontWindowOnly = 1;
int cmdDragGrow = ((medPtr->windowPart == inDrag ||
medPtr->windowPart == inGrow) && medPtr->state & Mod1Mask);
if (!cmdDragGrow) {
Tk_Window grabWin = GetGrabWindowForWindow(tkwin);
frontWindowOnly = !grabWin;
if (grabWin && grabWin != tkwin) {
TkMacOSXSetEatButtonUp(true);
BringWindowForward(TkMacOSXDrawableWindow(
((TkWindow*)grabWin)->window), isFrontProcess,
frontWindowOnly);
return false;
}
}
/*
* Clicks in the titlebar widgets are handled without bringing the
* window forward.
*/
if ((result = HandleWindowTitlebarMouseDown(medPtr, tkwin)) != -1) {
statusPtr->stopProcessing = 1;
return result;
} else {
/*
* Only windows with the kWindowNoActivatesAttribute can
* receive mouse events in the background.
*/
if (!(((TkWindow *)tkwin)->wmInfoPtr->attributes &
kWindowNoActivatesAttribute)) {
/*
* Allow background window dragging & growing with Command
* down.
*/
if (!cmdDragGrow) {
TkMacOSXSetEatButtonUp(true);
BringWindowForward(medPtr->whichWin, isFrontProcess,
frontWindowOnly);
}
/*
* Allow dragging & growing of windows that were/are in the
* background.
*/
if (!(medPtr->windowPart == inDrag ||
medPtr->windowPart == inGrow)) {
return false;
}
}
}
} else {
if ((result = HandleWindowTitlebarMouseDown(medPtr, tkwin)) != -1) {
statusPtr->stopProcessing = 1;
return result;
}
}
switch (medPtr->windowPart) {
case inDrag: {
WindowAttributes attributes;
GetWindowAttributes(medPtr->whichWin, &attributes);
if (!(attributes & kWindowAsyncDragAttribute)) {
TkMacOSXTrackingLoop(1);
DragWindow(medPtr->whichWin, where, NULL);
TkMacOSXTrackingLoop(0);
where2.h = where2.v = 0;
QDLocalToGlobalPoint(GetWindowPort(medPtr->whichWin),
&where2);
if (EqualPt(where, where2)) {
return false;
}
return true;
}
break;
}
case inGrow:
/*
* Generally the content region is the domain of Tk
* sub-windows. However, one exception is the grow
* region. A button down in this area will be handled
* by the window manager. Note: this means that Tk
* may not get button down events in this area!
*/
if (TkMacOSXGrowToplevel(medPtr->whichWin, where) == true) {
statusPtr->stopProcessing = 1;
return true;
} else {
return GenerateButtonEvent(medPtr);
}
break;
case inContent:
return GenerateButtonEvent(medPtr);
break;
default:
return false;
break;
}
}
return false;
}
//-------------------------------------------------------------------------------------------------//
void OSXCarbonWindow::create( const String& name, unsigned int width, unsigned int height,
bool fullScreen, const NameValuePairList *miscParams )
{
bool hasDepthBuffer;
String title = name;
size_t fsaa_samples = 0;
int left = 0;
int top = 0;
int depth = 32;
if( miscParams )
{
NameValuePairList::const_iterator opt = NULL;
// Full screen anti aliasing
opt = miscParams->find( "FSAA" );
if( opt != miscParams->end() )
fsaa_samples = StringConverter::parseUnsignedInt( opt->second );
opt = miscParams->find( "left" );
if( opt != miscParams->end() )
left = StringConverter::parseUnsignedInt( opt->second );
opt = miscParams->find( "top" );
if( opt != miscParams->end() )
top = StringConverter::parseUnsignedInt( opt->second );
opt = miscParams->find( "title" );
if( opt != miscParams->end() )
title = opt->second;
opt = miscParams->find( "depthBuffer" );
if( opt != miscParams->end() )
hasDepthBuffer = StringConverter::parseBool( opt->second );
opt = miscParams->find( "colourDepth" );
if( opt != miscParams->end() )
depth = StringConverter::parseUnsignedInt( opt->second );
}
if(fullScreen)
{
GLRenderSystem *rs = static_cast<GLRenderSystem*>(Root::getSingleton().getRenderSystem());
OSXContext *mainContext = (OSXContext*)rs->_getMainContext();
CGLContextObj share = NULL;
if(mainContext == 0)
{
share = NULL;
}
else if(mainContext->getContextType() == "AGL")
{
OSXCarbonContext* aglShare = static_cast<OSXCarbonContext*>(mainContext);
aglGetCGLContext(aglShare->getContext(), &((void*)share));
}
else if(mainContext->getContextType() == "CGL")
{
OSXCGLContext* cglShare = static_cast<OSXCGLContext*>(mainContext);
share = cglShare->getContext();
}
// create the context
createCGLFullscreen(width, height, depth, fsaa_samples, share);
}
else
{
int i = 0;
AGLPixelFormat pixelFormat;
GLint attribs[ 20 ];
attribs[ i++ ] = AGL_NO_RECOVERY;
attribs[ i++ ] = GL_TRUE;
attribs[ i++ ] = AGL_ACCELERATED;
attribs[ i++ ] = GL_TRUE;
attribs[ i++ ] = AGL_RGBA;
attribs[ i++ ] = AGL_DOUBLEBUFFER;
attribs[ i++ ] = AGL_ALPHA_SIZE;
attribs[ i++ ] = 8;
attribs[ i++ ] = AGL_STENCIL_SIZE;
attribs[ i++ ] = 8;
attribs[ i++ ] = AGL_DEPTH_SIZE;
attribs[ i++ ] = depth;
if(fsaa_samples > 1)
{
attribs[ i++ ] = AGL_MULTISAMPLE;
attribs[ i++ ] = 1;
attribs[ i++ ] = AGL_SAMPLE_BUFFERS_ARB;
attribs[ i++ ] = fsaa_samples;
}
attribs[ i++ ] = AGL_NONE;
pixelFormat = aglChoosePixelFormat( NULL, 0, attribs );
// Create the AGLContext from our pixel format
// Share it with main
GLRenderSystem *rs = static_cast<GLRenderSystem*>(Root::getSingleton().getRenderSystem());
OSXContext* mainContext = static_cast<OSXContext*>( rs->_getMainContext() );
if(mainContext == 0)
{
mAGLContext = aglCreateContext(pixelFormat, NULL);
}
else if(mainContext->getContextType() == "AGL")
{
OSXCarbonContext* context = static_cast<OSXCarbonContext*>( rs->_getMainContext() );
AGLContext shared = context->getContext();
mAGLContext = aglCreateContext(pixelFormat, context->getContext());
}
else
{
// If we do not have an AGL, we can not clone it using this window
LogManager::getSingleton().logMessage( "Warning: You asked to create a second window, "
"when the previous window was not of this type. OgreOSXCarbonWindow can only share "
"with an AGL context.");
}
NameValuePairList::const_iterator opt = 0;
if(miscParams)
opt = miscParams->find("externalWindowHandle");
if(!miscParams || opt == miscParams->end())
{
// create the window rect in global coords
::Rect windowRect;
windowRect.left = 0;
windowRect.top = 0;
windowRect.right = width;
windowRect.bottom = height;
// set the default attributes for the window
WindowAttributes windowAttrs = kWindowStandardDocumentAttributes; // default: "resize"
if (miscParams)
{
opt = miscParams->find("border");
if( opt != miscParams->end() )
{
String borderType = opt->second;
if( borderType == "none" )
windowAttrs = kWindowNoTitleBarAttribute;
else if( borderType == "fixed" )
windowAttrs = kWindowStandardFloatingAttributes;
}
}
windowAttrs |= kWindowStandardHandlerAttribute | kWindowInWindowMenuAttribute | kWindowHideOnFullScreenAttribute;
// Create the window
CreateNewWindow(kDocumentWindowClass, windowAttrs, &windowRect, &mWindow);
// Color the window background black
SetThemeWindowBackground (mWindow, kThemeBrushBlack, true);
// Set the title of our window
CFStringRef titleRef = CFStringCreateWithCString( kCFAllocatorDefault, title.c_str(), kCFStringEncodingASCII );
SetWindowTitleWithCFString( mWindow, titleRef );
// Center our window on the screen
RepositionWindow( mWindow, NULL, kWindowCenterOnMainScreen );
// Get our view
HIViewFindByID( HIViewGetRoot( mWindow ), kHIViewWindowContentID, &mView );
// Set up our UPP for Window Events
EventTypeSpec eventSpecs[] = {
{kEventClassWindow, kEventWindowActivated},
{kEventClassWindow, kEventWindowDeactivated},
{kEventClassWindow, kEventWindowShown},
{kEventClassWindow, kEventWindowHidden},
{kEventClassWindow, kEventWindowDragCompleted},
{kEventClassWindow, kEventWindowBoundsChanged},
{kEventClassWindow, kEventWindowExpanded},
{kEventClassWindow, kEventWindowCollapsed},
{kEventClassWindow, kEventWindowClosed},
{kEventClassWindow, kEventWindowClose}
};
EventHandlerUPP handlerUPP = NewEventHandlerUPP(WindowEventUtilities::_CarbonWindowHandler);
// Install the standard event handler for the window
EventTargetRef target = GetWindowEventTarget(mWindow);
InstallStandardEventHandler(target);
// We also need to install the WindowEvent Handler, we pass along the window with our requests
InstallEventHandler(target, handlerUPP, 10, eventSpecs, (void*)this, &mEventHandlerRef);
// Display and select our window
ShowWindow(mWindow);
SelectWindow(mWindow);
// Add our window to the window event listener class
WindowEventUtilities::_addRenderWindow(this);
}
else
{
// TODO: The Contol is going to report the incorrect location with a
// Metalic / Textured window. The default windows work just fine.
// First get the HIViewRef / ControlRef
mView = (HIViewRef)StringConverter::parseUnsignedLong(opt->second);
mWindow = GetControlOwner(mView);
// Lets try hiding the HIView
//HIViewSetVisible(mView, false);
// Get the rect bounds
::Rect ctrlBounds;
GetControlBounds(mView, &ctrlBounds);
GLint bufferRect[4];
bufferRect[0] = ctrlBounds.left; // left edge
bufferRect[1] = ctrlBounds.bottom; // bottom edge
bufferRect[2] = ctrlBounds.right - ctrlBounds.left; // width of buffer rect
bufferRect[3] = ctrlBounds.bottom - ctrlBounds.top; // height of buffer rect
aglSetInteger(mAGLContext, AGL_BUFFER_RECT, bufferRect);
aglEnable (mAGLContext, AGL_BUFFER_RECT);
mIsExternal = true;
}
// Set the drawable, and current context
// If you do this last, there is a moment before the rendering window pops-up
// This could go once inside each case above, before the window is displayed,
// if desired.
aglSetDrawable(mAGLContext, GetWindowPort(mWindow));
aglSetCurrentContext(mAGLContext);
// Give a copy of our context to the render system
mContext = new OSXCarbonContext(mAGLContext, pixelFormat);
}
mName = name;
mWidth = width;
mHeight = height;
mActive = true;
mClosed = false;
mCreated = true;
mIsFullScreen = fullScreen;
}
// This example is almost identical to the helloworld example, except that
// in this case, there are two styles instead of just one. ATSUSetRunStyle
// is used to apply a style to different parts of the text.
//
void DrawMultipleStylesContents(WindowRef window)
{
CFStringRef string;
UniChar *text;
UniCharCount length;
UniCharArrayOffset currentStart, currentEnd;
ATSUStyle style1, style2;
ATSUTextLayout layout;
ATSUFontID font;
Fixed pointSize;
ATSUAttributeTag tags[2];
ByteCount sizes[2];
ATSUAttributeValuePtr values[2];
Fixed lineWidth, ascent, descent;
CGContextRef cgContext;
float x, y, cgY, windowHeight;
ItemCount numSoftBreaks;
UniCharArrayOffset *theSoftBreaks;
int i;
GrafPtr port, savedPort;
Rect portBounds;
// Set up the graphics port
port = GetWindowPort(window);
GetPort(&savedPort);
SetPort(port);
GetPortBounds(port, &portBounds);
EraseRect(&portBounds);
// Create a style object. This is one of two objects necessary to draw using ATSUI.
// (The layout is the other.)
verify_noerr( ATSUCreateStyle(&style1) );
// Look up the font we are going to use, and set it in the style object, using
// the aforementioned "triple" (tag, size, value) semantics. This is how almost
// all settings in ATSUI are applied.
verify_noerr( ATSUFindFontFromName(kMultipleStylesFontName, strlen(kMultipleStylesFontName), kFontFullName, kFontNoPlatform, kFontNoScript, kFontNoLanguage, &font) );
tags[0] = kATSUFontTag;
sizes[0] = sizeof(ATSUFontID);
values[0] = &font;
verify_noerr( ATSUSetAttributes(style1, 1, tags, sizes, values) );
// Set the point size, also using a triple. You can actually set multiple triples at once,
// since the tag, size, and value parameters are arrays. Other examples do this, such as
// the vertical text example.
//
pointSize = Long2Fix(kMultipleStylesFontSize);
tags[0] = kATSUSizeTag;
sizes[0] = sizeof(Fixed);
values[0] = &pointSize;
verify_noerr( ATSUSetAttributes(style1, 1, tags, sizes, values) );
// Now we create the second of two objects necessary to draw text using ATSUI, the layout.
// You can specify a pointer to the text buffer at layout creation time, or later using
// the routine ATSUSetTextPointerLocation(). Below, we do it after layout creation time.
verify_noerr( ATSUCreateTextLayout(&layout) );
// Before assigning text to the layout, we must first convert the string we plan to draw
// from a CFStringRef into an array of UniChar.
string = CFStringCreateWithCString(NULL, "In this example, various parts of the text have different styles applied. The same style is used more than once.", kCFStringEncodingASCII);
// Extract the raw Unicode from the CFString, then dispose of the CFString
length = CFStringGetLength(string);
text = (UniChar *)malloc(length * sizeof(UniChar));
CFStringGetCharacters(string, CFRangeMake(0, length), text);
CFRelease(string);
// Attach the resulting UTF-16 Unicode text to the layout
verify_noerr( ATSUSetTextPointerLocation(layout, text, kATSUFromTextBeginning, kATSUToTextEnd, length) );
// Now we tie the two necessary objects, the layout and the style, together
verify_noerr( ATSUSetRunStyle(layout, style1, kATSUFromTextBeginning, kATSUToTextEnd) );
// Now, for this example we create a second style, and assign it to various runs within
// the text. For our example, the run offsets are hard-coded for simplicity's sake. In
// a real application, style runs are often assigned from external sources, such as user
// selection.
verify_noerr( ATSUCreateAndCopyStyle(style1, &style2) );
// Change the font for the second style
verify_noerr( ATSUFindFontFromName(kMultipleStylesFontName2, strlen(kMultipleStylesFontName2), kFontFullName, kFontNoPlatform, kFontNoScript, kFontNoLanguage, &font) );
tags[0] = kATSUFontTag;
sizes[0] = sizeof(ATSUFontID);
values[0] = &font;
verify_noerr( ATSUSetAttributes(style2, 1, tags, sizes, values) );
// Apply the new style to the text in various places
verify_noerr( ATSUSetRunStyle(layout, style2, 8, 7) ); // The word "example"
verify_noerr( ATSUSetRunStyle(layout, style2, 65, 7) ); // The word "applied"
verify_noerr( ATSUSetRunStyle(layout, style2, 83, 5) ); // The word "style"
verify_noerr( ATSUSetRunStyle(layout, style2, 107, 4) ); // The word "once"
// In this example, we are breaking text into lines.
// Therefore, we need to know the width of the line.
lineWidth = X2Fix(portBounds.right - portBounds.left - 2.0*kMultipleStylesMargin);
tags[0] = kATSULineWidthTag;
sizes[0] = sizeof(Fixed);
values[0] = &lineWidth;
verify_noerr( ATSUSetLayoutControls(layout, 1, tags, sizes, values) );
// Prepare the CGContext for drawing
QDBeginCGContext(port, &cgContext);
tags[0] = kATSUCGContextTag;
sizes[0] = sizeof(CGContextRef);
values[0] = &cgContext;
verify_noerr( ATSUSetLayoutControls(layout, 1, tags, sizes, values) );
// Prepare the coordinates for drawing. In our example, "x" and "y" are the coordinates
// in QD space. "cgY" contains the y coordinate in CG space.
//
windowHeight = portBounds.bottom - portBounds.top;
x = kMultipleStylesMargin; // leave a small left margin
y = kMultipleStylesMargin; // leave a small top margin
cgY = windowHeight - y; // Subtract the y coordinate from the height of the
// window to get the coordinate in CG-aware space.
// Break the text into lines
verify_noerr( ATSUBatchBreakLines(layout, kATSUFromTextBeginning, length, lineWidth, &numSoftBreaks) );
verify_noerr( ATSUGetSoftLineBreaks(layout, kATSUFromTextBeginning, kATSUToTextEnd, 0, NULL, &numSoftBreaks) );
theSoftBreaks = (UniCharArrayOffset *) malloc(numSoftBreaks * sizeof(UniCharArrayOffset));
verify_noerr( ATSUGetSoftLineBreaks(layout, kATSUFromTextBeginning, kATSUToTextEnd, numSoftBreaks, theSoftBreaks, &numSoftBreaks) );
// Loop over all the lines and draw them
currentStart = 0;
for (i=0; i <= numSoftBreaks; i++) {
currentEnd = ((numSoftBreaks > 0 ) && (numSoftBreaks > i)) ? theSoftBreaks[i] : length;
// This is the height of a line, the ascent and descent. Getting the values this way is the preferred method.
ATSUGetLineControl(layout, currentStart, kATSULineAscentTag, sizeof(ATSUTextMeasurement), &ascent, NULL);
ATSUGetLineControl(layout, currentStart, kATSULineDescentTag, sizeof(ATSUTextMeasurement), &descent, NULL);
// Make room for the area above the baseline
y += Fix2X(ascent);
cgY = windowHeight - y;
// Draw the text
verify_noerr( ATSUDrawText(layout, currentStart, currentEnd - currentStart, X2Fix(x), X2Fix(cgY)) );
// Make room for the area beloww the baseline
y += Fix2X(descent);
// Prepare for next line
currentStart = currentEnd;
}
// This is a one-shot window, so we are now ready to dispose of all our objects.
// Normally, we would want to keep everything around in case we needed to redraw or change
// the text at some point.
// Tear down the CGContext
CGContextFlush(cgContext);
QDEndCGContext(port, &cgContext);
// Deallocate string storage
free(text);
// Layout and styles also need to be disposed
verify_noerr( ATSUDisposeStyle(style1) );
verify_noerr( ATSUDisposeStyle(style2) );
verify_noerr( ATSUDisposeTextLayout(layout) );
// Restore the graphics port
SetPort(savedPort);
}
void TabbedWindow::ForceUpdate( void )
{
CGrafPtr port = GetWindowPort( fWindowRef );
QDFlushPortBuffer( port, NULL );
}
int _glfwPlatformOpenWindow( int width,
int height,
int redbits,
int greenbits,
int bluebits,
int alphabits,
int depthbits,
int stencilbits,
int mode,
_GLFWhints* hints )
{
OSStatus error;
ProcessSerialNumber psn;
unsigned int windowAttributes;
// TO DO: Refactor this function!
_glfwWin.WindowFunctions = ( _glfwWin.Fullscreen ?
&_glfwMacFSWindowFunctions :
&_glfwMacDWWindowFunctions );
// Windowed or fullscreen; AGL or CGL? Quite the mess...
// AGL appears to be the only choice for attaching OpenGL contexts to
// Carbon windows, but it leaves the user no control over fullscreen
// mode stretching. Solution: AGL for windowed, CGL for fullscreen.
if( !_glfwWin.Fullscreen )
{
// create AGL pixel format attribute list
GLint AGLpixelFormatAttributes[256];
int numAGLAttrs = 0;
AGLpixelFormatAttributes[numAGLAttrs++] = AGL_RGBA;
AGLpixelFormatAttributes[numAGLAttrs++] = AGL_DOUBLEBUFFER;
if( hints->Stereo )
{
AGLpixelFormatAttributes[numAGLAttrs++] = AGL_STEREO;
}
_setAGLAttribute( AGL_AUX_BUFFERS, hints->AuxBuffers);
_setAGLAttribute( AGL_RED_SIZE, redbits );
_setAGLAttribute( AGL_GREEN_SIZE, greenbits );
_setAGLAttribute( AGL_BLUE_SIZE, bluebits );
_setAGLAttribute( AGL_ALPHA_SIZE, alphabits );
_setAGLAttribute( AGL_DEPTH_SIZE, depthbits );
_setAGLAttribute( AGL_STENCIL_SIZE, stencilbits );
_setAGLAttribute( AGL_ACCUM_RED_SIZE, hints->AccumRedBits );
_setAGLAttribute( AGL_ACCUM_GREEN_SIZE, hints->AccumGreenBits );
_setAGLAttribute( AGL_ACCUM_BLUE_SIZE, hints->AccumBlueBits );
_setAGLAttribute( AGL_ACCUM_ALPHA_SIZE, hints->AccumAlphaBits );
if( hints->Samples > 1 )
{
_setAGLAttribute( AGL_SAMPLE_BUFFERS_ARB, 1 );
_setAGLAttribute( AGL_SAMPLES_ARB, hints->Samples );
AGLpixelFormatAttributes[numAGLAttrs++] = AGL_NO_RECOVERY;
}
AGLpixelFormatAttributes[numAGLAttrs++] = AGL_NONE;
// create pixel format descriptor
AGLDevice mainMonitor = GetMainDevice();
AGLPixelFormat pixelFormat = aglChoosePixelFormat( &mainMonitor,
1,
AGLpixelFormatAttributes );
if( pixelFormat == NULL )
{
fprintf( stderr, "glfwOpenWindow failing because it can't create a pixel format\n" );
return GL_FALSE;
}
// store pixel format's values for _glfwPlatformGetWindowParam's use
_getAGLAttribute( AGL_ACCELERATED, _glfwWin.Accelerated );
_getAGLAttribute( AGL_RED_SIZE, _glfwWin.RedBits );
_getAGLAttribute( AGL_GREEN_SIZE, _glfwWin.GreenBits );
_getAGLAttribute( AGL_BLUE_SIZE, _glfwWin.BlueBits );
_getAGLAttribute( AGL_ALPHA_SIZE, _glfwWin.AlphaBits );
_getAGLAttribute( AGL_DEPTH_SIZE, _glfwWin.DepthBits );
_getAGLAttribute( AGL_STENCIL_SIZE, _glfwWin.StencilBits );
_getAGLAttribute( AGL_ACCUM_RED_SIZE, _glfwWin.AccumRedBits );
_getAGLAttribute( AGL_ACCUM_GREEN_SIZE, _glfwWin.AccumGreenBits );
_getAGLAttribute( AGL_ACCUM_BLUE_SIZE, _glfwWin.AccumBlueBits );
_getAGLAttribute( AGL_ACCUM_ALPHA_SIZE, _glfwWin.AccumAlphaBits );
_getAGLAttribute( AGL_AUX_BUFFERS, _glfwWin.AuxBuffers );
_getAGLAttribute( AGL_STEREO, _glfwWin.Stereo );
_getAGLAttribute( AGL_SAMPLES_ARB, _glfwWin.Samples );
_glfwWin.RefreshRate = hints->RefreshRate;
// create AGL context
_glfwWin.AGLContext = aglCreateContext( pixelFormat, NULL );
aglDestroyPixelFormat( pixelFormat );
if( _glfwWin.AGLContext == NULL )
{
fprintf( stderr, "glfwOpenWindow failing because it can't create an OpenGL context\n" );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
if (_glfwLibrary.Unbundled)
{
if( GetCurrentProcess( &psn ) != noErr )
{
fprintf( stderr, "glfwOpenWindow failing because it can't get its PSN\n" );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
if( TransformProcessType( &psn, kProcessTransformToForegroundApplication ) != noErr )
{
fprintf( stderr, "glfwOpenWindow failing because it can't become a foreground application\n" );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
/* Keith Bauer 2007-07-12 - I don't believe this is desirable
if( SetFrontProcess( &psn ) != noErr )
{
fprintf( stderr, "glfwOpenWindow failing because it can't become the front process\n" );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
*/
}
// create window
Rect windowContentBounds;
windowContentBounds.left = 0;
windowContentBounds.top = 0;
windowContentBounds.right = width;
windowContentBounds.bottom = height;
windowAttributes = ( kWindowCloseBoxAttribute \
| kWindowCollapseBoxAttribute \
| kWindowStandardHandlerAttribute );
if( hints->WindowNoResize )
{
windowAttributes |= kWindowLiveResizeAttribute;
}
else
{
windowAttributes |= ( kWindowFullZoomAttribute | kWindowResizableAttribute );
}
error = CreateNewWindow( kDocumentWindowClass,
windowAttributes,
&windowContentBounds,
&( _glfwWin.MacWindow ) );
if( ( error != noErr ) || ( _glfwWin.MacWindow == NULL ) )
{
fprintf( stderr, "glfwOpenWindow failing because it can't create a window\n" );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
_glfwWin.WindowUPP = NewEventHandlerUPP( _glfwWindowEventHandler );
error = InstallWindowEventHandler( _glfwWin.MacWindow,
_glfwWin.WindowUPP,
GetEventTypeCount( GLFW_WINDOW_EVENT_TYPES ),
GLFW_WINDOW_EVENT_TYPES,
NULL,
NULL );
if( error != noErr )
{
fprintf( stderr, "glfwOpenWindow failing because it can't install window event handlers\n" );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
// Don't care if we fail here
(void)SetWindowTitleWithCFString( _glfwWin.MacWindow, CFSTR( "GLFW Window" ) );
(void)RepositionWindow( _glfwWin.MacWindow,
NULL,
kWindowCenterOnMainScreen );
if( !aglSetDrawable( _glfwWin.AGLContext,
GetWindowPort( _glfwWin.MacWindow ) ) )
{
fprintf( stderr, "glfwOpenWindow failing because it can't draw to the window\n" );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
// Make OpenGL context current
if( !aglSetCurrentContext( _glfwWin.AGLContext ) )
{
fprintf( stderr, "glfwOpenWindow failing because it can't make the OpenGL context current\n" );
_glfwPlatformCloseWindow();
return GL_FALSE;
}
// show window
ShowWindow( _glfwWin.MacWindow );
return GL_TRUE;
}
else
{
CGDisplayErr cgErr;
CGLError cglErr;
CFDictionaryRef optimalMode;
CGLPixelFormatObj CGLpfObj;
long numCGLvs = 0;
CGLPixelFormatAttribute CGLpixelFormatAttributes[64];
int numCGLAttrs = 0;
// variables for enumerating color depths
GLint rgbColorDepth;
GLint rgbaAccumDepth = 0;
int rgbChannelDepth = 0;
// CGL pixel format attributes
_setCGLAttribute( kCGLPFADisplayMask,
CGDisplayIDToOpenGLDisplayMask( kCGDirectMainDisplay ) );
if( hints->Stereo )
{
CGLpixelFormatAttributes[ numCGLAttrs++ ] = kCGLPFAStereo;
}
if( hints->Samples > 1 )
{
_setCGLAttribute( kCGLPFASamples, (CGLPixelFormatAttribute)hints->Samples );
_setCGLAttribute( kCGLPFASampleBuffers, (CGLPixelFormatAttribute)1 );
CGLpixelFormatAttributes[ numCGLAttrs++ ] = kCGLPFANoRecovery;
}
CGLpixelFormatAttributes[ numCGLAttrs++ ] = kCGLPFAFullScreen;
CGLpixelFormatAttributes[ numCGLAttrs++ ] = kCGLPFADoubleBuffer;
CGLpixelFormatAttributes[ numCGLAttrs++ ] = kCGLPFAAccelerated;
CGLpixelFormatAttributes[ numCGLAttrs++ ] = kCGLPFANoRecovery;
CGLpixelFormatAttributes[ numCGLAttrs++ ] = kCGLPFAMinimumPolicy;
_setCGLAttribute( kCGLPFAAccumSize,
(CGLPixelFormatAttribute)( hints->AccumRedBits \
+ hints->AccumGreenBits \
+ hints->AccumBlueBits \
+ hints->AccumAlphaBits ) );
_setCGLAttribute( kCGLPFAAlphaSize, (CGLPixelFormatAttribute)alphabits );
_setCGLAttribute( kCGLPFADepthSize, (CGLPixelFormatAttribute)depthbits );
_setCGLAttribute( kCGLPFAStencilSize, (CGLPixelFormatAttribute)stencilbits );
_setCGLAttribute( kCGLPFAAuxBuffers, (CGLPixelFormatAttribute)hints->AuxBuffers );
CGLpixelFormatAttributes[ numCGLAttrs++ ] = (CGLPixelFormatAttribute)NULL;
// create a suitable pixel format with above attributes..
cglErr = CGLChoosePixelFormat( CGLpixelFormatAttributes,
&CGLpfObj,
&numCGLvs );
if( cglErr != kCGLNoError )
{
return GL_FALSE;
}
// ..and create a rendering context using that pixel format
cglErr = CGLCreateContext( CGLpfObj, NULL, &_glfwWin.CGLContext );
if( cglErr != kCGLNoError )
{
return GL_FALSE;
}
// enumerate depth of RGB channels - unlike AGL, CGL works with
// a single parameter reflecting the full depth of the frame buffer
(void)CGLDescribePixelFormat( CGLpfObj, 0, kCGLPFAColorSize, &rgbColorDepth );
if( rgbColorDepth == 24 || rgbColorDepth == 32 )
{
rgbChannelDepth = 8;
}
if( rgbColorDepth == 16 )
{
rgbChannelDepth = 5;
}
// get pixel depth of accumulator - I haven't got the slightest idea
// how this number conforms to any other channel depth than 8 bits,
// so this might end up giving completely knackered results...
(void)CGLDescribePixelFormat( CGLpfObj, 0, kCGLPFAAccumSize, &rgbaAccumDepth );
if( rgbaAccumDepth == 32 )
{
rgbaAccumDepth = 8;
}
// store values of pixel format for _glfwPlatformGetWindowParam's use
_getCGLAttribute( kCGLPFAAccelerated, _glfwWin.Accelerated );
_getCGLAttribute( rgbChannelDepth, _glfwWin.RedBits );
_getCGLAttribute( rgbChannelDepth, _glfwWin.GreenBits );
_getCGLAttribute( rgbChannelDepth, _glfwWin.BlueBits );
_getCGLAttribute( kCGLPFAAlphaSize, _glfwWin.AlphaBits );
_getCGLAttribute( kCGLPFADepthSize, _glfwWin.DepthBits );
_getCGLAttribute( kCGLPFAStencilSize, _glfwWin.StencilBits );
_getCGLAttribute( rgbaAccumDepth, _glfwWin.AccumRedBits );
_getCGLAttribute( rgbaAccumDepth, _glfwWin.AccumGreenBits );
_getCGLAttribute( rgbaAccumDepth, _glfwWin.AccumBlueBits );
_getCGLAttribute( rgbaAccumDepth, _glfwWin.AccumAlphaBits );
_getCGLAttribute( kCGLPFAAuxBuffers, _glfwWin.AuxBuffers );
_getCGLAttribute( kCGLPFAStereo, _glfwWin.Stereo );
_glfwWin.RefreshRate = hints->RefreshRate;
// destroy our pixel format
(void)CGLDestroyPixelFormat( CGLpfObj );
// capture the display for our application
cgErr = CGCaptureAllDisplays();
if( cgErr != kCGErrorSuccess )
{
return GL_FALSE;
}
// find closest matching NON-STRETCHED display mode..
optimalMode = CGDisplayBestModeForParametersAndRefreshRateWithProperty( kCGDirectMainDisplay,
rgbColorDepth,
width,
/* Check further to the right -> */ height,
hints->RefreshRate,
NULL,
NULL );
if( optimalMode == NULL )
{
return GL_FALSE;
}
// ..and switch to that mode
cgErr = CGDisplaySwitchToMode( kCGDirectMainDisplay, optimalMode );
if( cgErr != kCGErrorSuccess )
{
return GL_FALSE;
}
// switch to our OpenGL context, and bring it up fullscreen
cglErr = CGLSetCurrentContext( _glfwWin.CGLContext );
if( cglErr != kCGLNoError )
{
return GL_FALSE;
}
cglErr = CGLSetFullScreen( _glfwWin.CGLContext );
if( cglErr != kCGLNoError )
{
return GL_FALSE;
}
return GL_TRUE;
}
}
/* krat: adding OpenGL support */
int Mac_GL_Init(_THIS)
{
#ifdef HAVE_OPENGL
AGLPixelFormat format;
int i = 0;
GLint attributes [ 24 ]; /* 24 is max possible in this setup */
GLboolean noerr;
attributes[i++] = AGL_RGBA;
if ( this->gl_config.red_size != 0 &&
this->gl_config.blue_size != 0 &&
this->gl_config.green_size != 0 ) {
attributes[i++] = AGL_RED_SIZE;
attributes[i++] = this->gl_config.red_size;
attributes[i++] = AGL_GREEN_SIZE;
attributes[i++] = this->gl_config.green_size;
attributes[i++] = AGL_BLUE_SIZE;
attributes[i++] = this->gl_config.blue_size;
attributes[i++] = AGL_ALPHA_SIZE;
attributes[i++] = this->gl_config.alpha_size;
}
if ( this->gl_config.double_buffer ) {
attributes[i++] = AGL_DOUBLEBUFFER;
}
if ( this->gl_config.depth_size != 0 ) {
attributes[i++] = AGL_DEPTH_SIZE;
attributes[i++] = this->gl_config.depth_size;
}
if ( this->gl_config.stencil_size != 0 ) {
attributes[i++] = AGL_STENCIL_SIZE;
attributes[i++] = this->gl_config.stencil_size;
}
if ( this->gl_config.accum_red_size != 0 &&
this->gl_config.accum_blue_size != 0 &&
this->gl_config.accum_green_size != 0 ) {
attributes[i++] = AGL_ACCUM_RED_SIZE;
attributes[i++] = this->gl_config.accum_red_size;
attributes[i++] = AGL_ACCUM_GREEN_SIZE;
attributes[i++] = this->gl_config.accum_green_size;
attributes[i++] = AGL_ACCUM_BLUE_SIZE;
attributes[i++] = this->gl_config.accum_blue_size;
attributes[i++] = AGL_ACCUM_ALPHA_SIZE;
attributes[i++] = this->gl_config.accum_alpha_size;
}
if ( this->gl_config.stereo ) {
attributes[i++] = AGL_STEREO;
}
#if defined(AGL_SAMPLE_BUFFERS_ARB) && defined(AGL_SAMPLES_ARB)
if ( this->gl_config.multisamplebuffers != 0 ) {
attributes[i++] = AGL_SAMPLE_BUFFERS_ARB;
attributes[i++] = this->gl_config.multisamplebuffers;
}
if ( this->gl_config.multisamplesamples != 0 ) {
attributes[i++] = AGL_SAMPLES_ARB;
attributes[i++] = this->gl_config.multisamplesamples;
}
#endif
attributes[i++] = AGL_ALL_RENDERERS;
attributes[i] = AGL_NONE;
format = aglChoosePixelFormat(NULL, 0, attributes);
if ( format == NULL ) {
SDL_SetError("Couldn't match OpenGL desired format");
return(-1);
}
glContext = aglCreateContext(format, NULL);
if ( glContext == NULL ) {
SDL_SetError("Couldn't create OpenGL context");
return(-1);
}
aglDestroyPixelFormat(format);
#if TARGET_API_MAC_CARBON
noerr = aglSetDrawable(glContext, GetWindowPort(SDL_Window));
#else
noerr = aglSetDrawable(glContext, (AGLDrawable)SDL_Window);
#endif
if(!noerr) {
SDL_SetError("Unable to bind GL context to window");
return(-1);
}
return(0);
#else
SDL_SetError("OpenGL support not configured");
return(-1);
#endif
}
static void aboutupdate (void) {
/*
1/22/91 dmb: openbitmap moves memory; its result cannot be assigned
into a double-dereferenced handle. (ahem!)
2.1b5 dmb: special case for nil cancoondata (during revert). also, removed
unneeded flbitmapactive logic
*/
register hdlwindowinfo hw = aboutwindowinfo;
Rect r;
displayedaboutdata = aboutdata;
#if TARGET_API_MAC_CARBON
aboutport = GetWindowPort(aboutwindow);
#else
aboutport = (CGrafPtr)aboutwindow;
#endif
flhavemiscrect = false;
if (aboutdata == nil) /*in the middle of a revert*/
return;
r = (**hw).contentrect;
eraserect (r);
shelldrawgrowicon (hw);
if ((**aboutdata).flbigwindow) {
ccdrawabout ();
// ccgetmsgrect (&r);
getmessagecontentrect (&r);
insetrect (&r, -1, -1);
#if TARGET_API_MAC_CARBON == 1
insetrect (&r, 0, -3);
r.bottom = r.top + 2;
DrawThemeSeparator (&r, kThemeStateActive);
#else
// grayframerect (r);
movepento (r.left, r.top);
pushpen ();
setgraypen ();
pendrawline (r.right, r.top);
poppen ();
#endif
flhavemiscrect = ccgettextitemrect (miscinfoitem, &miscinforect);
}
if (!(**aboutdata).flbootsplash) {
ccdrawagentpopup ();
ccdrawmsg ();
}
} /*aboutupdate*/
void DoEvent(EventRecord *event)
{
short part;
Boolean hit;
char key;
Rect tempRect;
WindowRef whichWindow;
switch (event->what)
{
case mouseDown:
part = FindWindow(event->where, &whichWindow);
switch (part)
{
case inMenuBar: /* process a moused menu command */
DoMenuCommand(MenuSelect(event->where));
break;
case inSysWindow:
break;
case inContent:
if (whichWindow != FrontWindow())
SelectWindow(whichWindow);
break;
case inDrag: /* pass screenBits.bounds */
GetRegionBounds(GetGrayRgn(), &tempRect);
DragWindow(whichWindow, event->where, &tempRect);
break;
case inGrow:
break;
case inGoAway:
DisposeWindow(whichWindow);
ExitToShell();
break;
case inZoomIn:
case inZoomOut:
hit = TrackBox(whichWindow, event->where, part);
if (hit)
{
SetPort(GetWindowPort(whichWindow)); // window must be current port
EraseRect(GetWindowPortBounds(whichWindow, &tempRect)); // inval/erase because of ZoomWindow bug
ZoomWindow(whichWindow, part, true);
InvalWindowRect(whichWindow, GetWindowPortBounds(whichWindow, &tempRect));
}
break;
}
break;
case keyDown:
case autoKey:
key = event->message & charCodeMask;
if (event->modifiers & cmdKey)
if (event->what == keyDown)
DoMenuCommand(MenuKey(key));
case activateEvt: /* if you needed to do something special */
break;
case updateEvt:
DrawWindow((WindowRef) event->message);
break;
case kHighLevelEvent:
AEProcessAppleEvent( event );
break;
case diskEvt:
break;
}
}
void QRasterWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoint &offset)
{
Q_D(QRasterWindowSurface);
// Not ready for painting yet, bail out. This can happen in
// QWidget::create_sys()
if (!d->image || rgn.rectCount() == 0)
return;
#ifdef Q_WS_WIN
QRect br = rgn.boundingRect();
if (!qt_widget_private(window())->isOpaque
&& window()->testAttribute(Qt::WA_TranslucentBackground)
&& (qt_widget_private(window())->data.window_flags & Qt::FramelessWindowHint))
{
QRect r = window()->frameGeometry();
QPoint frameOffset = qt_widget_private(window())->frameStrut().topLeft();
QRect dirtyRect = br.translated(offset + frameOffset);
SIZE size = {r.width(), r.height()};
POINT ptDst = {r.x(), r.y()};
POINT ptSrc = {0, 0};
BLENDFUNCTION blend = {AC_SRC_OVER, 0, (BYTE)(255.0 * window()->windowOpacity()), Q_AC_SRC_ALPHA};
RECT dirty = {dirtyRect.x(), dirtyRect.y(),
dirtyRect.x() + dirtyRect.width(), dirtyRect.y() + dirtyRect.height()};
Q_UPDATELAYEREDWINDOWINFO info = {sizeof(info), NULL, &ptDst, &size, d->image->hdc, &ptSrc, 0, &blend, Q_ULW_ALPHA, &dirty};
ptrUpdateLayeredWindowIndirect(window()->internalWinId(), &info);
} else
{
QPoint wOffset = qt_qwidget_data(widget)->wrect.topLeft();
HDC widget_dc = widget->getDC();
QRect wbr = br.translated(-wOffset);
BitBlt(widget_dc, wbr.x(), wbr.y(), wbr.width(), wbr.height(),
d->image->hdc, br.x() + offset.x(), br.y() + offset.y(), SRCCOPY);
widget->releaseDC(widget_dc);
}
#ifndef QT_NO_DEBUG
static bool flush = !qgetenv("QT_FLUSH_WINDOWSURFACE").isEmpty();
if (flush) {
SelectObject(qt_win_display_dc(), GetStockObject(BLACK_BRUSH));
Rectangle(qt_win_display_dc(), 0, 0, d->image->width() + 2, d->image->height() + 2);
BitBlt(qt_win_display_dc(), 1, 1, d->image->width(), d->image->height(),
d->image->hdc, 0, 0, SRCCOPY);
}
#endif
#endif
#ifdef Q_WS_X11
extern void *qt_getClipRects(const QRegion &r, int &num); // in qpaintengine_x11.cpp
extern QWidgetData* qt_widget_data(QWidget *);
QPoint wOffset = qt_qwidget_data(widget)->wrect.topLeft();
if (widget->window() != window()) {
XFreeGC(X11->display, d_ptr->gc);
d_ptr->gc = XCreateGC(X11->display, widget->handle(), 0, 0);
}
QRegion wrgn(rgn);
if (!wOffset.isNull())
wrgn.translate(-wOffset);
if (wrgn.rectCount() != 1) {
int num;
XRectangle *rects = (XRectangle *)qt_getClipRects(wrgn, num);
XSetClipRectangles(X11->display, d_ptr->gc, 0, 0, rects, num, YXBanded);
}
QPoint widgetOffset = offset + wOffset;
QRect clipRect = widget->rect().translated(widgetOffset).intersected(d_ptr->image->image.rect());
QRect br = rgn.boundingRect().translated(offset).intersected(clipRect);
QPoint wpos = br.topLeft() - widgetOffset;
#ifndef QT_NO_MITSHM
if (d_ptr->image->xshmpm) {
XCopyArea(X11->display, d_ptr->image->xshmpm, widget->handle(), d_ptr->gc,
br.x(), br.y(), br.width(), br.height(), wpos.x(), wpos.y());
d_ptr->needsSync = true;
} else if (d_ptr->image->xshmimg) {
XShmPutImage(X11->display, widget->handle(), d_ptr->gc, d_ptr->image->xshmimg,
br.x(), br.y(), wpos.x(), wpos.y(), br.width(), br.height(), False);
d_ptr->needsSync = true;
} else
#endif
{
int depth = widget->x11Info().depth();
const QImage &src = d->image->image;
if (src.format() != QImage::Format_RGB32 || depth < 24 || X11->bppForDepth.value(depth) != 32) {
Q_ASSERT(src.depth() >= 16);
const QImage sub_src(src.scanLine(br.y()) + br.x() * (uint(src.depth()) / 8),
br.width(), br.height(), src.bytesPerLine(), src.format());
QX11PixmapData *data = new QX11PixmapData(QPixmapData::PixmapType);
data->xinfo = widget->x11Info();
data->fromImage(sub_src, Qt::NoOpaqueDetection);
QPixmap pm = QPixmap(data);
XCopyArea(X11->display, pm.handle(), widget->handle(), d_ptr->gc, 0 , 0 , br.width(), br.height(), wpos.x(), wpos.y());
} else {
// qpaintengine_x11.cpp
extern void qt_x11_drawImage(const QRect &rect, const QPoint &pos, const QImage &image, Drawable hd, GC gc, Display *dpy, Visual *visual, int depth);
qt_x11_drawImage(br, wpos, src, widget->handle(), d_ptr->gc, X11->display, (Visual *)widget->x11Info().visual(), depth);
}
}
if (wrgn.rectCount() != 1)
XSetClipMask(X11->display, d_ptr->gc, XNone);
#endif // FALCON
#ifdef Q_WS_MAC
Q_UNUSED(offset);
// This is mainly done for native components like native "open file" dialog.
if (widget->testAttribute(Qt::WA_DontShowOnScreen)) {
return;
}
#ifdef QT_MAC_USE_COCOA
this->needsFlush = true;
this->regionToFlush += rgn;
// The actual flushing will be processed in [view drawRect:rect]
qt_mac_setNeedsDisplay(widget);
#else
// Get a context for the widget.
CGContextRef context;
CGrafPtr port = GetWindowPort(qt_mac_window_for(widget));
QDBeginCGContext(port, &context);
CGContextRetain(context);
CGContextSaveGState(context);
// Flip context.
CGContextTranslateCTM(context, 0, widget->height());
CGContextScaleCTM(context, 1, -1);
// Clip to region.
const QVector<QRect> &rects = rgn.rects();
for (int i = 0; i < rects.size(); ++i) {
const QRect &rect = rects.at(i);
CGContextAddRect(context, CGRectMake(rect.x(), rect.y(), rect.width(), rect.height()));
}
CGContextClip(context);
QRect r = rgn.boundingRect().intersected(d->image->image.rect());
const CGRect area = CGRectMake(r.x(), r.y(), r.width(), r.height());
CGImageRef image = CGBitmapContextCreateImage(d->image->cg);
CGImageRef subImage = CGImageCreateWithImageInRect(image, area);
qt_mac_drawCGImage(context, &area, subImage);
CGImageRelease(subImage);
CGImageRelease(image);
QDEndCGContext(port, &context);
// Restore context.
CGContextRestoreGState(context);
CGContextRelease(context);
#endif // QT_MAC_USE_COCOA
#endif // Q_WS_MAC
}
void wxTopLevelWindowMac::DoMoveWindow(int x, int y, int width, int height)
{
wxMacPortStateHelper help( (GrafPtr) GetWindowPort( (WindowRef) m_macWindow) ) ;
wxMacWindowClipper clip (this);
int former_x = m_x ;
int former_y = m_y ;
int former_w = m_width ;
int former_h = m_height ;
int actualWidth = width;
int actualHeight = height;
int actualX = x;
int actualY = y;
if ((m_minWidth != -1) && (actualWidth < m_minWidth))
actualWidth = m_minWidth;
if ((m_minHeight != -1) && (actualHeight < m_minHeight))
actualHeight = m_minHeight;
if ((m_maxWidth != -1) && (actualWidth > m_maxWidth))
actualWidth = m_maxWidth;
if ((m_maxHeight != -1) && (actualHeight > m_maxHeight))
actualHeight = m_maxHeight;
bool doMove = false ;
bool doResize = false ;
if ( actualX != former_x || actualY != former_y )
{
doMove = true ;
}
if ( actualWidth != former_w || actualHeight != former_h )
{
doResize = true ;
}
if ( doMove || doResize )
{
m_x = actualX ;
m_y = actualY ;
if ( doMove )
::MoveWindow((WindowRef)m_macWindow, m_x, m_y , false); // don't make frontmost
m_width = actualWidth ;
m_height = actualHeight ;
if ( doResize )
::SizeWindow((WindowRef)m_macWindow, m_width, m_height , true);
// the OS takes care of invalidating and erasing the new area so we only have to
// take care of refreshing for full repaints
if ( doResize && HasFlag(wxFULL_REPAINT_ON_RESIZE) )
Refresh() ;
if ( IsKindOf( CLASSINFO( wxFrame ) ) )
{
wxFrame* frame = (wxFrame*) this ;
#if wxUSE_STATUSBAR
frame->PositionStatusBar();
#endif
#if wxUSE_TOOLBAR
frame->PositionToolBar();
#endif
}
if ( doMove )
wxWindowMac::MacTopLevelWindowChangedPosition() ; // like this only children will be notified
MacRepositionScrollBars() ;
if ( doMove )
{
wxPoint point(m_x, m_y);
wxMoveEvent event(point, m_windowId);
event.SetEventObject(this);
GetEventHandler()->ProcessEvent(event) ;
}
if ( doResize )
{
MacRepositionScrollBars() ;
wxSize size(m_width, m_height);
wxSizeEvent event(size, m_windowId);
event.SetEventObject(this);
GetEventHandler()->ProcessEvent(event);
}
}
}
void OSXCarbonWindow::setFullscreen(bool fullScreen, unsigned int width, unsigned int height)
{
if (mIsFullScreen != fullScreen || width != mWidth || height != mHeight)
{
// Set the full screen flag
mIsFullScreen = fullScreen;
createAGLContext(mFSAA, mColourDepth);
if (mIsFullScreen)
{
GLRenderSystem *rs = static_cast<GLRenderSystem*>(Root::getSingleton().getRenderSystem());
CGLContextObj share = NULL;
aglGetCGLContext(mAGLContext, (void**)&share);
// Create the CGL context object if it doesn't already exist, sharing the AGL context.
if(!mCGLContext)
{
void *cglPixFormat;
aglGetCGLPixelFormat(mAGLPixelFormat, (void **)&cglPixFormat);
mCGLContext = OGRE_NEW OSXCGLContext(mCGLContextObj, (CGLPixelFormatObj) cglPixFormat);
}
// Create the context, keeping the current colour depth and FSAA settings
createCGLFullscreen(width, height, getColourDepth(), getFSAA(), share);
rs->_switchContext(mContext);
// Hide the Carbon window
HideWindow(mWindow);
// And tell the rendersystem to stop rendering to it too
WindowEventUtilities::_removeRenderWindow(this);
}
else
{
// Create a new AGL context and pixel format if necessary
createAGLContext(mFSAA, mColourDepth);
// Create a window if we haven't already, existence check is done within the functions
if(!mWindow)
{
if(mIsExternal)
createWindowFromExternal(mView);
else
createNewWindow(width, height, mWindowTitle);
}
// Destroy the current CGL context, we will create a new one when/if we go back to full screen
destroyCGLFullscreen();
// Set the drawable, and current context
// If you do this last, there is a moment before the rendering window pops-up
#if defined(MAC_OS_X_VERSION_10_4) && MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_4
aglSetDrawable(mAGLContext, GetWindowPort(mWindow));
#else
aglSetWindowRef(mAGLContext, mWindow);
#endif
aglSetCurrentContext(mAGLContext);
if(!mCarbonContext)
{
mCarbonContext = OGRE_NEW OSXCarbonContext(mAGLContext, mAGLPixelFormat);
}
GLRenderSystem *rs = static_cast<GLRenderSystem*>(Root::getSingleton().getRenderSystem());
mContext = mCarbonContext;
rs->_switchContext(mContext);
WindowEventUtilities::_addRenderWindow(this);
ShowWindow(mWindow);
SelectWindow(mWindow);
RepositionWindow(mWindow, NULL, kWindowCenterOnMainScreen);
}
mWidth = width;
mHeight = height;
}
}
Boolean MCScreenDC::open()
{
owndnd = False;
mouseMoveRgn = NewRgn();
SetRectRgn(mouseMoveRgn, 0, 0, 1, 1);
//create a invisible window, and set port to this window
//so that later on at the very first time MC select and set font
//will only affect in this invisible window, not other apps on the desk top,
// when MC is first started. The size of the window is random.
// Rect invisibleWinRect;
Rect invisibleWinRect;
SetRect(&invisibleWinRect, 0, 0, 20, 20);
invisibleWin = NewCWindow(nil, &invisibleWinRect, "\p", False,
kUtilityWindowClass, (WindowRef)(-1L), False, 0);
long response;
if (Gestalt(gestaltSystemVersion, &response) == noErr)
{
if (response >= 0x1030 && response < 0x1040)
MCantialiasedtextworkaround = True;
else
MCantialiasedtextworkaround = False;
}
SetGWorld(GetWindowPort(invisibleWin), GetMainDevice());
vis = new MCVisualInfo;
devdepth = 32;
black_pixel.red = black_pixel.green = black_pixel.blue = 0; //black pixel
white_pixel.red = white_pixel.green = white_pixel.blue = 0xFFFF; //white pixel
black_pixel.pixel = 0;
white_pixel.pixel = 0xFFFFFF;
redbits = greenbits = bluebits = 8;
redshift = 16;
greenshift = 8;
blueshift = 0;
vis->red_mask = 0x00FF0000;
vis->green_mask = 0x0000FF00;
vis->blue_mask = 0x000000FF;
MCzerocolor = MCbrushcolor = white_pixel;
alloccolor(MCbrushcolor);
MCselectioncolor = MCpencolor = black_pixel;
alloccolor(MCselectioncolor);
alloccolor(MCpencolor);
gray_pixel.red = gray_pixel.green = gray_pixel.blue = 0x8888;
alloccolor(gray_pixel);
background_pixel.red = background_pixel.green = background_pixel.blue = 0xffff;
alloccolor(background_pixel);
//query the system for the hilited text color, and set ours
RGBColor hiliteRGB;
LMGetHiliteRGB(&hiliteRGB);
MChilitecolor.red = hiliteRGB.red;
MChilitecolor.green = hiliteRGB.green;
MChilitecolor.blue = hiliteRGB.blue;
alloccolor(MChilitecolor);
MCColor *syscolors = getaccentcolors();
if (syscolors != NULL)
MCaccentcolor = syscolors[4];
else
{
MCaccentcolor.red = MCaccentcolor.green = 0x0000;
MCaccentcolor.blue = 0x8080;
}
alloccolor(MCaccentcolor);
grabbed = False;
tripleclick = doubleclick = False;
MCdoubletime = GetDblTime() * 1000 / 60;
opened = True;
mousewindow = new _Drawable;
activewindow = new _Drawable;
lastactivewindow = new _Drawable;
mousewindow->type = activewindow->type = lastactivewindow->type = DC_WINDOW;
mousewindow->handle.window = activewindow->handle.window
= lastactivewindow->handle.window = 0;
//get handle of application menu bar
menuBar = GetMenuBar();
SetMenuBar(menuBar); //set menu bar as current menulist
//create Apple menu
appleMenu = NewMenu(mApple, "\p\024"); //menu title is an apple icon
InsertMenuItem(appleMenu, "\pAbout...", 0);
InsertMenu(appleMenu, 0);
DrawMenuBar(); //draw the menu bar with the Apple menu
usetemp = False;
Handle tmem = Get1IndResource('TMEM', 1);
if (tmem != NULL)
{
char *ptr = *tmem;
if (*(ptr + 1))
usetemp = True;
}
MCtemplatescrollbar->alloccolors();
if (IsMacEmulatedLF()) // no AM
MCtemplatebutton->allocicons();
// preallocate these because GetItemMark can't distinguish them
submenuIDs[0] = 1;
submenuIDs[checkMark] = 1;
submenuIDs[diamondMark] = 1;
MCcursors[PI_NONE] = nil;
MCblinkrate = GetCaretTime() * 1000 / 60;
MCDisplay const *t_displays;
getdisplays(t_displays, false);
MCwbr = t_displays[0] . workarea;
//TSM - INIT TSM APPLICATION AND INSTALL REQUIRED APPLEVENT HANDLERS
TSMPositionToOffsetUPP = NewAEEventHandlerUPP(TSMPositionToOffset);
TSMOffsetToPositionUPP = NewAEEventHandlerUPP(TSMOffsetToPosition);
TSMUpdateHandlerUPP = NewAEEventHandlerUPP(TSMUpdateHandler);
TSMUnicodeNotFromInputUPP
= NewAEEventHandlerUPP(TSMUnicodeNotFromInputHandler);
AEInstallEventHandler(kTextServiceClass, kPos2Offset,
TSMPositionToOffsetUPP, 0L , False);
AEInstallEventHandler(kTextServiceClass, kOffset2Pos,
TSMOffsetToPositionUPP, 0L , False);
AEInstallEventHandler(kTextServiceClass, kUpdateActiveInputArea,
TSMUpdateHandlerUPP, 0L , False);
AEInstallEventHandler(kTextServiceClass, kUnicodeNotFromInputMethod,
TSMUnicodeNotFromInputUPP, 0L , False);
openIME();
dragdropUPP = NewDragReceiveHandlerUPP(DragReceiveHandler);
InstallReceiveHandler(dragdropUPP, NULL, NULL);
dragmoveUPP = NewDragTrackingHandlerUPP(DragTrackingHandler);
InstallTrackingHandler(dragmoveUPP, NULL, NULL);
s_animation_current_time = s_animation_start_time = CFAbsoluteTimeGetCurrent();
//// Dock Menu Initialization
EventTypeSpec t_menu_event_specs[1];
t_menu_event_specs[0] . eventClass = kEventClassMenu;
t_menu_event_specs[0] . eventKind = kEventMenuPopulate;
CreateNewMenu(0, 0, &f_icon_menu);
s_icon_menu_event_handler_upp = NewEventHandlerUPP((EventHandlerProcPtr)handleiconmenuevent);
InstallEventHandler(GetMenuEventTarget(f_icon_menu), s_icon_menu_event_handler_upp, 1, t_menu_event_specs, NULL, NULL);
t_menu_event_specs[0] . eventClass = kEventClassCommand;
t_menu_event_specs[0] . eventKind = kEventCommandProcess;
InstallEventHandler(GetApplicationEventTarget(), s_icon_menu_event_handler_upp, 1, t_menu_event_specs, NULL, NULL);
SetApplicationDockTileMenu(f_icon_menu);
//// Color Profile Initialization
CMGetDefaultProfileBySpace(cmRGBData, &m_dst_profile);
CMProfileLocation t_location;
t_location . locType = cmPathBasedProfile;
strcpy(t_location . u . pathLoc . path, "/System/Library/ColorSync/Profiles/sRGB Profile.icc");
CMOpenProfile(&m_srgb_profile, &t_location);
////
return True;
}
Bool
XQueryPointer(
Display* display,
Window w,
Window* root_return,
Window* child_return,
int* root_x_return,
int* root_y_return,
int* win_x_return,
int* win_y_return,
unsigned int* mask_return)
{
int getGlobal = (root_x_return && root_y_return);
int getLocal = (win_x_return && win_y_return);
if (getGlobal || getLocal) {
Point where, local;
OSStatus err = noErr;
int gotMouseLoc = 0;
EventRef ev = GetCurrentEvent();
if (ev && getLocal) {
err = ChkErr(GetEventParameter, ev, kEventParamWindowMouseLocation,
typeQDPoint, NULL, sizeof(Point), NULL, &local);
gotMouseLoc = (err == noErr);
}
if (getGlobal || !gotMouseLoc) {
if (ev) {
err = ChkErr(GetEventParameter, ev, kEventParamMouseLocation,
typeQDPoint, NULL, sizeof(Point), NULL, &where);
}
if (!ev || err != noErr) {
GetGlobalMouse(&where);
}
}
if (getLocal) {
WindowRef whichWin;
if (ev) {
err = ChkErr(GetEventParameter, ev, kEventParamWindowRef,
typeWindowRef, NULL, sizeof(WindowRef), NULL,
&whichWin);
}
if (!ev || err != noErr) {
FindWindow(where, &whichWin);
}
if (gotMouseLoc) {
if (whichWin) {
Rect widths;
ChkErr(GetWindowStructureWidths, whichWin, &widths);
local.h -= widths.left;
local.v -= widths.top;
}
} else {
local = where;
if (whichWin) {
QDGlobalToLocalPoint(GetWindowPort(whichWin), &local);
}
}
}
if (getGlobal) {
*root_x_return = where.h;
*root_y_return = where.v;
}
if (getLocal) {
*win_x_return = local.h;
*win_y_return = local.v;
}
}
if (mask_return) {
*mask_return = TkMacOSXButtonKeyState();
}
return True;
}
// -----------------------------------------------------------------------------
// HITestViewTrack
// -----------------------------------------------------------------------------
// This is overkill, and probably #ifdef'd out, but is here as an example of
// a custom tracking handler.
//
OSStatus HITestViewTrack(
EventRef inEvent,
HITestViewData* inData )
{
OSStatus err;
HIRect bounds;
HIPoint where;
ControlPartCode part;
Boolean inside;
Boolean wasInside;
Point qdPt;
MouseTrackingResult mouseResult;
PixMapHandle portPixMap;
// Extract the mouse location
err = GetEventParameter( inEvent, kEventParamMouseLocation, typeHIPoint,
NULL, sizeof( HIPoint ), NULL, &where );
require_noerr( err, ParameterMissing );
// Is the mouse location in the view?
err = HIViewGetBounds( inData->view, &bounds );
if ( CGRectContainsPoint( bounds, where ) )
part = 1;
else
part = kControlNoPart;
HiliteControl( inData->view, part );
wasInside = true;
// Need the port's pixMap's bounds to convert the mouse location
portPixMap = GetPortPixMap( GetWindowPort( GetControlOwner( inData->view ) ) );
// The tracking loop
while ( true )
{
// Check again to see if the mouse is in the view
if ( CGRectContainsPoint( bounds, where ) )
part = 1;
else
part = kControlNoPart;
inside = ( part != kControlNoPart );
// If that changed, update
if ( inside != wasInside )
HiliteControl( inData->view, part );
wasInside = inside;
// Watch the mouse for change
err = TrackMouseLocation( (GrafPtr)-1L, &qdPt, &mouseResult );
// Need to convert from global
QDGlobalToLocalPoint( GetWindowPort( GetControlOwner( inData->view ) ), &qdPt );
where.x = qdPt.h - (**portPixMap).bounds.left;
where.y = qdPt.v - (**portPixMap).bounds.top;
HIViewConvertPoint( &where, NULL, inData->view );
// Bail out when the mouse is released
if ( mouseResult == kMouseTrackingMouseReleased )
break;
}
// Restore the original highlight
HiliteControl( inData->view, kControlNoPart );
// Send back the part upon which the mouse was released
err = SetEventParameter( inEvent, kEventParamControlPart, typeControlPartCode,
sizeof( ControlPartCode ), &part );
ParameterMissing:
return err;
}
void CL_DisplayWindow_OpenGL::create_window(const CL_DisplayWindowDescription &desc)
{
OSStatus result;
const CL_OpenGLWindowDescription_Generic *gl_desc = 0;
gl_desc = dynamic_cast<const CL_OpenGLWindowDescription_Generic*>(desc.impl.get());
fullscreen_width = desc.get_size().width;
fullscreen_height = desc.get_size().height;
disp_ref_count++;
GLint gl_attribs_single[] =
{
AGL_RGBA,
AGL_RED_SIZE, 4,
AGL_GREEN_SIZE, 4,
AGL_BLUE_SIZE, 4,
AGL_DEPTH_SIZE, 16,
AGL_NONE
};
GLint gl_attribs[32];
int i = 0;
if( gl_desc )
{
if( gl_desc->rgba ) gl_attribs[i++] = AGL_RGBA;
if( gl_desc->doublebuffer ) gl_attribs[i++] = AGL_DOUBLEBUFFER;
//if( gl_desc->stereo ) gl_attribs[i++] = AGL_STEREO;
gl_attribs[i++] = AGL_BUFFER_SIZE;
gl_attribs[i++] = gl_desc->buffer_size;
gl_attribs[i++] = AGL_LEVEL;
gl_attribs[i++] = gl_desc->level;
gl_attribs[i++] = AGL_AUX_BUFFERS;
gl_attribs[i++] = gl_desc->aux_buffers;
gl_attribs[i++] = AGL_RED_SIZE;
gl_attribs[i++] = gl_desc->red_size;
gl_attribs[i++] = AGL_GREEN_SIZE;
gl_attribs[i++] = gl_desc->green_size;
gl_attribs[i++] = AGL_BLUE_SIZE;
gl_attribs[i++] = gl_desc->blue_size;
gl_attribs[i++] = AGL_DEPTH_SIZE;
gl_attribs[i++] = gl_desc->depth_size;
gl_attribs[i++] = AGL_STENCIL_SIZE;
gl_attribs[i++] = gl_desc->stencil_size;
gl_attribs[i++] = AGL_ACCUM_RED_SIZE;
gl_attribs[i++] = gl_desc->accum_red_size;
gl_attribs[i++] = AGL_ACCUM_GREEN_SIZE;
gl_attribs[i++] = gl_desc->accum_green_size;
gl_attribs[i++] = AGL_ACCUM_BLUE_SIZE;
gl_attribs[i++] = gl_desc->accum_blue_size;
gl_attribs[i++] = AGL_ACCUM_ALPHA_SIZE;
gl_attribs[i++] = gl_desc->accum_alpha_size;
gl_attribs[i++] = AGL_ACCUM_RED_SIZE;
gl_attribs[i++] = gl_desc->accum_red_size;
// gl_attribs[i++] = AGL_FULLSCREEN;
}
else
{
gl_attribs[i++] = AGL_RGBA;
gl_attribs[i++] = AGL_NO_RECOVERY;
gl_attribs[i++] = AGL_DOUBLEBUFFER;
gl_attribs[i++] = AGL_DEPTH_SIZE;
gl_attribs[i++] = 16;
}
/*
else
{
gl_attribs[i++] = AGL_RGBA;
gl_attribs[i++] = AGL_DOUBLEBUFFER;
gl_attribs[i++] = AGL_RED_SIZE;
gl_attribs[i++] = 4;
gl_attribs[i++] = AGL_GREEN_SIZE;
gl_attribs[i++] = 4;
gl_attribs[i++] = AGL_BLUE_SIZE;
gl_attribs[i++] = 4;
gl_attribs[i++] = AGL_DEPTH_SIZE;
gl_attribs[i++] = 16;
// gl_attribs[i++] = AGL_FULLSCREEN;
}
*/
gl_attribs[i] = AGL_NONE;
CGDirectDisplayID display = CGMainDisplayID();
GDHandle gdhDisplay, *pgdhDisplay;
int numDisplay;
pgdhDisplay = &gdhDisplay;
if (noErr == DMGetGDeviceByDisplayID ((DisplayIDType)display, pgdhDisplay, false))
numDisplay = 1;
else
{
pgdhDisplay = 0;
numDisplay = 0;
}
AGLPixelFormat pixelformat;
pixelformat = aglChoosePixelFormat(pgdhDisplay, numDisplay, gl_attribs);
win_context = aglCreateContext(pixelformat, share_context);
if (!share_context) share_context = win_context;
aglDestroyPixelFormat(pixelformat);
gl_attribs[i++] = AGL_FULLSCREEN;
gl_attribs[i] = AGL_NONE;
pixelformat = aglChoosePixelFormat(pgdhDisplay, numDisplay, gl_attribs);
fs_context = aglCreateContext(pixelformat, win_context);
aglDestroyPixelFormat(pixelformat);
if (!(win_context && fs_context))
{
printf("Requested visual not supported by your OpenGL implementation. Falling back on singlebuffered Visual!\n");
pixelformat = aglChoosePixelFormat(0, 0, gl_attribs_single);
win_context = aglCreateContext(pixelformat, share_context);
aglDestroyPixelFormat(pixelformat);
fs_context = 0;
}
WindowAttributes style = kWindowCloseBoxAttribute | kWindowStandardHandlerAttribute;
if (desc.get_allow_resize()) style |= kWindowResizableAttribute | kWindowFullZoomAttribute;
Rect window_rect;
SetRect(&window_rect, 50, 50, 50+desc.get_size().width, 50+desc.get_size().height);
result = CreateNewWindow(kDocumentWindowClass, style, &window_rect, &window_ref);
if (result != noErr)
printf("Could not create window, due to error %d\n", (int)result);
// set title of window:
set_title(desc.get_title());
// Set standard arrow cursor:
InitCursor(); // do we need to do this? -- iMBN, 13. may 2004
// Create input devices for window:
keyboard = CL_InputDevice(new CL_InputDevice_MacKeyboard(this));
mouse = CL_InputDevice(new CL_InputDevice_MacMouse(this));
get_ic()->clear();
get_ic()->add_keyboard(keyboard);
get_ic()->add_mouse(mouse);
// buffer_front = CL_PixelBuffer(new CL_PixelBuffer_OpenGL_Frame(CL_FRONT, gc));
// buffer_back = CL_PixelBuffer(new CL_PixelBuffer_OpenGL_Frame(CL_BACK, gc));
if (!aglSetDrawable(win_context, GetWindowPort(window_ref)))
{
printf("Unable to set drawable");
}
if (desc.is_fullscreen())
set_fullscreen(desc.get_size().width, desc.get_size().height, desc.get_bpp(), desc.get_refresh_rate());
else {
fullscreen = true; // not really, but need to fool set_windowed
set_windowed();
}
ShowWindow(window_ref);
}