Show
Ignore:
Timestamp:
03/21/12 18:36:20 (2 years ago)
Author:
robert
Message:

Ran script to remove trailing spaces and tabs

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/src/osgViewer/GraphicsWindowCarbon.cpp

    r11628 r13041  
    1 /* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield  
     1/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield 
    22 * 
    3  * This library is open source and may be redistributed and/or modified under   
    4  * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or  
     3 * This library is open source and may be redistributed and/or modified under 
     4 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
    55 * (at your option) any later version.  The full license is in LICENSE file 
    66 * included with this distribution, and on the openscenegraph.org website. 
    7  *  
     7 * 
    88 * This library is distributed in the hope that it will be useful, 
    99 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
    10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  
     10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    1111 * OpenSceneGraph Public License for more details. 
    1212*/ 
     
    3434// Carbon-Eventhandler to handle the click in the close-widget and the resize of windows 
    3535 
    36 static pascal OSStatus GraphicsWindowEventHandler(EventHandlerCallRef nextHandler, EventRef event, void* userData)  
     36static pascal OSStatus GraphicsWindowEventHandler(EventHandlerCallRef nextHandler, EventRef event, void* userData) 
    3737{ 
    3838    WindowRef           window; 
    3939    Rect                bounds; 
    4040    OSStatus            result = eventNotHandledErr; /* report failure by default */ 
    41      
     41 
    4242    OSG_INFO << "GraphicsWindowEventHandler" << std::endl; 
    4343 
     
    4545    if (!w) 
    4646        return result; 
    47      
     47 
    4848    GetEventParameter(event, kEventParamDirectObject, typeWindowRef, NULL, 
    4949                         sizeof(window), NULL, &window); 
    50                           
     50 
    5151    switch(GetEventClass(event)) 
    5252    { 
     
    5656                result = noErr; 
    5757            break; 
    58                 
     58 
    5959        case kEventClassKeyboard: 
    6060            if (w->handleKeyboardEvent(event)) 
    6161                result = noErr; 
    6262            break; 
    63              
     63 
    6464        case kEventClassWindow: { 
    65          
     65 
    6666            switch (GetEventKind(event)) 
    6767                { 
     
    6969                        // left the code for live-resizing, but it is not used, because of window-refreshing issues... 
    7070                        GetEventParameter( event, kEventParamCurrentBounds, typeQDRectangle, NULL, sizeof(Rect), NULL, &bounds ); 
    71                          
     71 
    7272                        w->adaptResize(bounds.left, bounds.top, bounds.right - bounds.left, bounds.bottom - bounds.top); 
    7373                        w->requestRedraw(); 
    7474                        result = noErr; 
    7575                        break; 
    76                              
     76 
    7777                    case kEventWindowBoundsChanged: 
    7878                        InvalWindowRect(window, GetWindowPortBounds(window, &bounds)); 
     
    8181                        result = noErr; 
    8282                        break; 
    83                      
     83 
    8484                    case kEventWindowClose: 
    8585                        w->requestClose(); 
    8686                        result = noErr; 
    8787                        break; 
    88           
    89                     default:  
     88 
     89                    default: 
    9090                        break; 
    9191                } 
     
    9595            break; 
    9696    } 
    97      
     97 
    9898    //if (result == eventNotHandledErr) 
    9999    //    result = CallNextEventHandler (nextHandler, event); 
    100          
     100 
    101101    return result; 
    102102} 
     
    105105static bool s_quit_requested = false; 
    106106 
    107 // Application eventhandler -- listens for a quit-event  
     107// Application eventhandler -- listens for a quit-event 
    108108static pascal OSStatus ApplicationEventHandler(EventHandlerCallRef inHandlerCallRef, EventRef inEvent, void *inUserData) 
    109109{ 
    110      
     110 
    111111    HICommand commandStruct; 
    112112 
     
    120120            err = noErr; 
    121121            break; 
    122                      
    123     } 
    124      
     122 
     123    } 
     124 
    125125    return err; 
    126126} 
     
    158158            _keymap[49                ] = osgGA::GUIEventAdapter::KEY_Space; 
    159159            _keymap[117                ] = osgGA::GUIEventAdapter::KEY_Delete; 
    160              
     160 
    161161            _keymap[122                    ] = osgGA::GUIEventAdapter::KEY_F1; 
    162162            _keymap[120                    ] = osgGA::GUIEventAdapter::KEY_F2; 
     
    171171            _keymap[103                    ] = osgGA::GUIEventAdapter::KEY_F11; 
    172172            _keymap[111                    ] = osgGA::GUIEventAdapter::KEY_F12; 
    173              
     173 
    174174            _keymap[75                    ] = osgGA::GUIEventAdapter::KEY_KP_Divide; 
    175175            _keymap[67                    ] = osgGA::GUIEventAdapter::KEY_KP_Multiply; 
     
    189189 
    190190        } 
    191          
     191 
    192192        ~CarbonKeyboardMap() { 
    193193        } 
    194          
     194 
    195195        unsigned int remapKey(unsigned int key, unsigned int rawkey) 
    196196        { 
     
    216216    CarbonWindowAdapter(GraphicsWindowCarbon* win) : MenubarController::WindowAdapter(), _win(win) {} 
    217217    virtual bool valid() {return (_win.valid() && _win->valid()); } 
    218     virtual void getWindowBounds(CGRect& rect)  
     218    virtual void getWindowBounds(CGRect& rect) 
    219219    { 
    220220        Rect windowBounds; 
     
    225225        rect.size.height = windowBounds.bottom - windowBounds.top; 
    226226    } 
    227          
     227 
    228228    osgViewer::GraphicsWindow* getWindow()  { return _win.get(); } 
    229 private:  
     229private: 
    230230    osg::observer_ptr<GraphicsWindowCarbon> _win; 
    231231}; 
     
    238238 
    239239    // getEventQueue()->setCurrentEventState(osgGA::GUIEventAdapter::getAccumulatedEventState().get()); 
    240      
     240 
    241241    _lastModifierKeys = 0; 
    242242    _windowTitleHeight = 0; 
     
    272272        { 
    273273            err = ChangeWindowAttributes(getNativeWindowRef(), kWindowNoTitleBarAttribute | kWindowNoShadowAttribute, kWindowStandardDocumentAttributes); 
    274             SetWindowBounds(getNativeWindowRef(), kWindowContentRgn, &bounds);     
     274            SetWindowBounds(getNativeWindowRef(), kWindowContentRgn, &bounds); 
    275275        } 
    276276 
     
    280280            return false; 
    281281        } 
    282          
     282 
    283283        // update titlebar-height 
    284284        Rect titleRect; 
    285285        GetWindowBounds(_window, kWindowTitleBarRgn, &titleRect); 
    286286        _windowTitleHeight = abs(titleRect.bottom - titleRect.top); 
    287          
    288         // sth: I don't know why I have to reattach the context to the window here, If I don't do this  I get blank areas, where the titlebar was.  
     287 
     288        // sth: I don't know why I have to reattach the context to the window here, If I don't do this  I get blank areas, where the titlebar was. 
    289289        // InvalWindowRect doesn't help here :-/ 
    290          
     290 
    291291        aglSetDrawable(_context, 0); 
    292292        aglSetDrawable(_context, GetWindowPort(_window)); 
    293                  
     293 
    294294        MenubarController::instance()->update(); 
    295295    } 
     
    300300 
    301301WindowAttributes GraphicsWindowCarbon::computeWindowAttributes(bool useWindowDecoration, bool supportsResize) { 
    302     WindowAttributes attr;  
    303      
    304     if (useWindowDecoration)  
     302    WindowAttributes attr; 
     303 
     304    if (useWindowDecoration) 
    305305    { 
    306306        if (supportsResize) 
     
    309309            attr = (kWindowStandardDocumentAttributes | kWindowStandardHandlerAttribute) & ~kWindowResizableAttribute; 
    310310    } 
    311     else  
     311    else 
    312312    { 
    313313        attr = kWindowNoTitleBarAttribute | kWindowNoShadowAttribute | kWindowStandardHandlerAttribute; 
     
    324324        { kEventClassWindow, kEventWindowBoundsChanged}, 
    325325        { kEventClassWindow, kEventWindowClose}, 
    326          
     326 
    327327        {kEventClassMouse, kEventMouseDown}, 
    328328        {kEventClassMouse, kEventMouseUp}, 
     
    339339        {kEventClassKeyboard, kEventHotKeyReleased}, 
    340340    }; 
    341      
     341 
    342342    InstallWindowEventHandler(_window, NewEventHandlerUPP(GraphicsWindowEventHandler),  GetEventTypeCount(windEventList), windEventList, this, NULL); 
    343343 } 
     
    349349    if (!_initialized) return false; 
    350350    if (!_traits) return false; 
    351   
     351 
    352352    OSG_INFO << "GraphicsWindowCarbon::realizeImplementation" << std::endl; 
    353      
     353 
    354354    setWindowDecoration(_traits->windowDecoration); 
    355355    useCursor(_traits->useCursor); 
     
    358358    DarwinWindowingSystemInterface* wsi = dynamic_cast<DarwinWindowingSystemInterface*>(osg::GraphicsContext::getWindowingSystemInterface()); 
    359359    int screenLeft = 0, screenTop = 0; 
    360     if (wsi)  
     360    if (wsi) 
    361361    { 
    362362        wsi->getScreenTopLeft((*_traits), screenLeft, screenTop); 
    363363    } 
    364      
    365     WindowData *windowData = ( _traits.get() && _traits->inheritedWindowData.get() ) ? static_cast<osgViewer::GraphicsWindowCarbon::WindowData*>(_traits->inheritedWindowData.get()) : 0;  
    366       
     364 
     365    WindowData *windowData = ( _traits.get() && _traits->inheritedWindowData.get() ) ? static_cast<osgViewer::GraphicsWindowCarbon::WindowData*>(_traits->inheritedWindowData.get()) : 0; 
     366 
    367367    _ownsWindow = (windowData) ? (windowData->getNativeWindowRef() == NULL) : true; 
    368      
     368 
    369369    if (_ownsWindow) { 
    370          
     370 
    371371        // create the window 
    372372        Rect bounds = {_traits->y + screenTop, _traits->x + screenLeft, _traits->y + _traits->height + screenTop, _traits->x + _traits->width + screenLeft}; 
    373373        OSStatus err = 0; 
    374374        WindowAttributes attr = computeWindowAttributes(_useWindowDecoration, _traits->supportsResize); 
    375          
     375 
    376376        err = CreateNewWindow(kDocumentWindowClass, attr, &bounds, &_window); 
    377377 
     
    386386         _window = windowData->getNativeWindowRef(); 
    387387    } 
    388      
     388 
    389389    Rect titleRect; 
    390390    GetWindowBounds(_window, kWindowTitleBarRgn, &titleRect); 
    391391    _windowTitleHeight = abs(titleRect.bottom - titleRect.top); 
    392      
     392 
    393393    if ((_ownsWindow) || (windowData && windowData->installEventHandler())) 
    394394        installEventHandler(); 
    395      
     395 
    396396    // set the window title 
    397397    setWindowName(_traits->windowName); 
    398      
     398 
    399399    // create the context 
    400400    AGLContext sharedContextCarbon = NULL; 
    401      
     401 
    402402    GraphicsHandleCarbon* graphicsHandleCarbon = dynamic_cast<GraphicsHandleCarbon*>(_traits->sharedContext); 
    403     if (graphicsHandleCarbon)  
     403    if (graphicsHandleCarbon) 
    404404    { 
    405405        sharedContextCarbon = graphicsHandleCarbon->getAGLContext(); 
     
    412412    } 
    413413 
    414       
     414 
    415415    if ( windowData && windowData->getAGLDrawable() ) { 
    416         aglSetDrawable(_context, (AGLDrawable)*(windowData->getAGLDrawable()) );  
    417                  
     416        aglSetDrawable(_context, (AGLDrawable)*(windowData->getAGLDrawable()) ); 
     417 
    418418    } else { 
    419         aglSetDrawable(_context, GetWindowPort(_window));  
    420         ShowWindow(_window);  
     419        aglSetDrawable(_context, GetWindowPort(_window)); 
     420        ShowWindow(_window); 
    421421        MenubarController::instance()->attachWindow( new CarbonWindowAdapter(this) ); 
    422422    } 
    423      
     423 
    424424    makeCurrent(); 
    425425 
     
    436436        // versions of OSX. 
    437437        cgerr =  CGLEnable( ctx, static_cast <CGLContextEnable>(313) ); 
    438 #endif     
     438#endif 
    439439        if (cgerr != kCGLNoError ) 
    440440        { 
    441441            OSG_INFO << "GraphicsWindowCarbon::realizeImplementation: multi-threaded OpenGL Execution not available" << std::endl; 
    442         }  
     442        } 
    443443    } 
    444444 
     
    460460bool GraphicsWindowCarbon::makeCurrentImplementation() 
    461461{ 
    462          
     462 
    463463    return (aglSetCurrentContext(_context) == GL_TRUE); 
    464464} 
     
    488488    MenubarController* mbc = MenubarController::instance(); 
    489489    if (mbc) mbc->detachWindow(this); 
    490      
     490 
    491491    if (_pixelFormat) 
    492492    { 
     
    494494        _pixelFormat = NULL; 
    495495    } 
    496   
    497     if (_context)  
     496 
     497    if (_context) 
    498498    { 
    499499        aglSetDrawable(_context, NULL); 
     
    502502        _context = NULL; 
    503503    } 
    504   
     504 
    505505    if (_ownsWindow && _window) DisposeWindow(_window); 
    506506    _window = NULL; 
     
    532532    aglUpdateContext(_context); 
    533533    MenubarController::instance()->update(); 
    534      
     534 
    535535    getEventQueue()->windowResize(x,y,width, height, getEventQueue()->getTime()); 
    536536} 
     
    542542 
    543543    static unsigned int lastEmulatedMouseButton = 0; 
    544     // mouse down event    
     544    // mouse down event 
    545545    Point wheresMyMouse; 
    546546    GetEventParameter (theEvent, kEventParamWindowMouseLocation, typeQDPoint, NULL, sizeof(wheresMyMouse), NULL, &wheresMyMouse); 
    547      
     547 
    548548    wheresMyMouse.v -= _windowTitleHeight; 
    549549    if (_useWindowDecoration && (wheresMyMouse.v < 0)) 
    550550        return false; 
    551      
     551 
    552552    Point wheresMyMouseGlobal; 
    553553    GetEventParameter (theEvent, kEventParamMouseLocation, typeQDPoint, NULL, sizeof(wheresMyMouse), NULL, &wheresMyMouseGlobal); 
    554      
     554 
    555555    EventMouseButton mouseButton = 0; 
    556556    GetEventParameter (theEvent, kEventParamMouseButton, typeMouseButton, NULL, sizeof(mouseButton), NULL, &mouseButton); 
    557      
     557 
    558558    UInt32 modifierKeys; 
    559559    GetEventParameter (theEvent,kEventParamKeyModifiers,typeUInt32, NULL,sizeof(modifierKeys), NULL,&modifierKeys); 
    560      
    561      
     560 
     561 
    562562    WindowRef win; 
    563563    int fwres = FindWindow(wheresMyMouseGlobal, &win); 
     
    574574        if (mouseButton==3) mouseButton = 2; 
    575575        else if (mouseButton==2) mouseButton = 3; 
    576          
     576 
    577577        // check tablet pointer device and map it to a mouse button 
    578578        TabletProximityRec    theTabletRecord;    // The Tablet Proximity Record 
     
    582582                                      sizeof(TabletProximityRec), 
    583583                                      NULL, (void *)&theTabletRecord)) 
    584         {             
     584        { 
    585585            osgGA::GUIEventAdapter::TabletPointerType pointerType; 
    586586            switch(theTabletRecord.pointerType) 
     
    589589                    pointerType = osgGA::GUIEventAdapter::PEN; 
    590590                    break; 
    591                      
     591 
    592592                case 2: // puck 
    593593                    pointerType = osgGA::GUIEventAdapter::PUCK; 
    594594                    break; 
    595                      
     595 
    596596                case 3: // eraser 
    597597                    pointerType = osgGA::GUIEventAdapter::ERASER; 
     
    602602                   break; 
    603603            } 
    604              
     604 
    605605            getEventQueue()->penProximity(pointerType, (theTabletRecord.enterProximity != 0)); 
    606606        } 
     
    608608        // get tilt and rotation from the pen 
    609609        TabletPointRec theTabletPointRecord; 
    610         if(noErr == GetEventParameter(theEvent,  kEventParamTabletPointRec, typeTabletPointRec, NULL,  
    611                 sizeof(TabletPointRec), NULL, (void *)&theTabletPointRecord))  
     610        if(noErr == GetEventParameter(theEvent,  kEventParamTabletPointRec, typeTabletPointRec, NULL, 
     611                sizeof(TabletPointRec), NULL, (void *)&theTabletPointRecord)) 
    612612        { 
    613613            int penRotation = (int)theTabletPointRecord.rotation * 9 / 575; //to get angle between 0 to 360 grad 
     
    619619            ); 
    620620        } 
    621              
     621 
    622622        switch(GetEventKind(theEvent)) 
    623623        { 
     
    627627                    float my = wheresMyMouse.v; 
    628628                    transformMouseXY(mx, my); 
    629                      
     629 
    630630                    lastEmulatedMouseButton = 0; 
    631                      
    632                     if (mouseButton == 1)  
     631 
     632                    if (mouseButton == 1) 
    633633                    { 
    634634                        if( modifierKeys & cmdKey ) 
     
    641641                        } 
    642642                    } 
    643                      
    644                     if (clickCount > 1)  
     643 
     644                    if (clickCount > 1) 
    645645                        getEventQueue()->mouseDoubleButtonPress(mx,my, mouseButton); 
    646646                    else 
     
    662662                } 
    663663                break; 
    664                  
     664 
    665665            case kEventMouseDragged: 
    666666                { 
    667667                    // get pressure from the pen, only when mouse/pen is dragged 
    668668                    TabletPointRec    theTabletRecord; 
    669                     if(noErr == GetEventParameter(theEvent,  kEventParamTabletPointRec, typeTabletPointRec, NULL,  
     669                    if(noErr == GetEventParameter(theEvent,  kEventParamTabletPointRec, typeTabletPointRec, NULL, 
    670670                                    sizeof(TabletPointRec), NULL, (void *)&theTabletRecord)) { 
    671                      
     671 
    672672                        getEventQueue()->penPressure(theTabletRecord.pressure / 65535.0f); 
    673673                    } 
    674                      
     674 
    675675                    float mx = wheresMyMouse.h; 
    676676                    float my = wheresMyMouse.v; 
     
    679679                } 
    680680                break; 
    681                  
     681 
    682682            case kEventMouseMoved: 
    683683                { 
     
    688688                } 
    689689                break; 
    690                  
     690 
    691691            // mouse with scroll-wheels 
    692692            case kEventMouseWheelMoved: 
     
    708708                } 
    709709                break; 
    710              
     710 
    711711            // new trackpads and mighty mouse, (not officially documented, see http://developer.apple.com/qa/qa2005/qa1453.html ) 
    712712            case 11: 
     
    717717                        kEventParamMouseWheelSmoothHorizontalDelta     = 'saxx' // typeSInt32 
    718718                    }; 
    719                      
     719 
    720720                    SInt32 scroll_delta_x = 0; 
    721721                    SInt32 scroll_delta_y = 0; 
     
    729729                } 
    730730                break; 
    731   
     731 
    732732            default: 
    733733                return false; 
    734734        } 
    735735    } 
    736      
     736 
    737737    return true; 
    738738} 
     
    743743{ 
    744744    handleModifierKeys(theEvent); 
    745          
     745 
    746746    OSStatus status; 
    747      
     747 
    748748    UInt32 rawkey; 
    749749    GetEventParameter (theEvent,kEventParamKeyCode,typeUInt32, NULL,sizeof(rawkey), NULL,&rawkey); 
    750      
     750 
    751751    // OSG_INFO << "key code: " << rawkey << " modifiers: " << modifierKeys << std::endl; 
    752              
     752 
    753753    UInt32 dataSize; 
    754754    /* jbw check return status so that we don't allocate a huge array */ 
     
    756756    if (status != noErr) return false; 
    757757    if (dataSize<=1) return false; 
    758      
     758 
    759759    UniChar* uniChars = new UniChar[dataSize+1]; 
    760760    GetEventParameter( theEvent, kEventParamKeyUnicodes, typeUnicodeText, NULL, dataSize, NULL, (void*)uniChars ); 
    761      
     761 
    762762    unsigned int keychar = remapCarbonKey(static_cast<unsigned long>(uniChars[0]), rawkey); 
    763      
     763 
    764764    switch(GetEventKind(theEvent)) 
    765765    { 
     
    773773            break; 
    774774        } 
    775          
     775 
    776776        case kEventRawKeyUp: 
    777         {                  
     777        { 
    778778            //OSG_INFO << "GraphicsWindowCarbon::keyPress" << std::endl; 
    779779            //getEventQueue()->getCurrentEventState()->setModKeyMask(modifierMask); 
     
    781781            break; 
    782782        } 
    783          
     783 
    784784        default: 
    785785             break; 
    786      
     786 
    787787    } 
    788788 
     
    798798        getEventQueue()->keyPress(keySymbol); 
    799799    } 
    800      
     800 
    801801    if (!(modifierKey & modifierMask) && (_lastModifierKeys & modifierMask)) 
    802802    { 
     
    805805} 
    806806 
    807 bool GraphicsWindowCarbon::handleModifierKeys(EventRef theEvent)  
     807bool GraphicsWindowCarbon::handleModifierKeys(EventRef theEvent) 
    808808{ 
    809809    UInt32 modifierKeys; 
     
    813813    if (_lastModifierKeys == modifierKeys) 
    814814        return false; 
    815          
     815 
    816816    handleModifierKey(modifierKeys, shiftKey, osgGA::GUIEventAdapter::KEY_Shift_L); 
    817817    handleModifierKey(modifierKeys, controlKey, osgGA::GUIEventAdapter::KEY_Control_L); 
    818818    handleModifierKey(modifierKeys, optionKey, osgGA::GUIEventAdapter::KEY_Alt_L); 
    819819    handleModifierKey(modifierKeys, cmdKey, osgGA::GUIEventAdapter::KEY_Super_L); 
    820      
    821     // Caps lock needs some special handling, i did not find a way to get informed when the caps-lock-key gets released     
     820 
     821    // Caps lock needs some special handling, i did not find a way to get informed when the caps-lock-key gets released 
    822822    if ((modifierKeys & alphaLock) && !(_lastModifierKeys & alphaLock)) 
    823823    { 
     
    825825        getEventQueue()->keyRelease(osgGA::GUIEventAdapter::KEY_Caps_Lock); 
    826826    } 
    827      
     827 
    828828    if (!(modifierKeys & alphaLock) && (_lastModifierKeys & alphaLock)) 
    829829    { 
     
    831831        getEventQueue()->keyRelease(osgGA::GUIEventAdapter::KEY_Caps_Lock); 
    832832    } 
    833      
     833 
    834834    _lastModifierKeys = modifierKeys; 
    835835    return true; 
     
    841841{ 
    842842    if (!_realized) return; 
    843      
     843 
    844844    EventRef theEvent; 
    845845    EventTargetRef theTarget = GetEventDispatcherTarget(); 
     
    848848        switch(GetEventClass(theEvent)) 
    849849        { 
    850             case kEventClassMouse:  
     850            case kEventClassMouse: 
    851851                    { 
    852852                    // handle the menubar 
    853853                    Point wheresMyMouse; 
    854854                    GetEventParameter (theEvent, kEventParamMouseLocation, typeQDPoint, NULL, sizeof(wheresMyMouse), NULL, &wheresMyMouse); 
    855                      
     855 
    856856                    EventMouseButton mouseButton = 0; 
    857857                    GetEventParameter (theEvent, kEventParamMouseButton, typeMouseButton, NULL, sizeof(mouseButton), NULL, &mouseButton); 
    858                      
     858 
    859859                    WindowRef win; 
    860860                    int fwres = FindWindow(wheresMyMouse, &win); 
     
    875875                } 
    876876                break; 
    877              
    878             case kEventClassAppleEvent:  
     877 
     878            case kEventClassAppleEvent: 
    879879                { 
    880880                    EventRecord eventRecord; 
     
    887887        } 
    888888        SendEventToEventTarget (theEvent, theTarget); 
    889         ReleaseEvent(theEvent);         
    890     }   
     889        ReleaseEvent(theEvent); 
     890    } 
    891891    if (_closeRequested) 
    892892        getEventQueue()->closeWindow(); 
    893          
     893 
    894894    if (s_quit_requested) { 
    895895        getEventQueue()->quitApplication(); 
    896896        s_quit_requested = false; 
    897897    } 
    898              
     898 
    899899} 
    900900 
     
    904904    int screenLeft(0), screenTop(0); 
    905905    DarwinWindowingSystemInterface* wsi = dynamic_cast<DarwinWindowingSystemInterface*>(osg::GraphicsContext::getWindowingSystemInterface()); 
    906    if (wsi)  
     906   if (wsi) 
    907907    { 
    908908        wsi->getScreenTopLeft((*_traits), screenLeft, screenTop); 
    909909    } 
    910      
     910 
    911911    Rect bounds = {y + screenTop, x + screenLeft, y + height + screenTop, x + width + screenLeft}; 
    912912    SetWindowBounds(getNativeWindowRef(), kWindowContentRgn, &bounds); 
     
    923923    int screenLeft(0), screenTop(0); 
    924924    if (wsi) { 
    925          
     925 
    926926        // get the screen containing the window 
    927927        unsigned int screenNdx = wsi->getScreenContaining(x,y,w,h); 
    928          
     928 
    929929        // update traits 
    930930        _traits->screenNum = screenNdx; 
    931          
     931 
    932932        // get top left of screen 
    933933        wsi->getScreenTopLeft((*_traits), screenLeft, screenTop); 
    934934    } 
    935      
     935 
    936936    resized(x-screenLeft,y-screenTop,w,h); 
    937937} 
     
    962962        return; 
    963963    } 
    964      
     964 
    965965    CGDirectDisplayID displayId = wsi->getDisplayID((*_traits)); 
    966966    CGDisplayErr err = (cursorOn ? CGDisplayShowCursor(displayId) : CGDisplayHideCursor(displayId)); 
     
    978978 
    979979    UInt32 cursor; 
    980     switch (mouseCursor)  
     980    switch (mouseCursor) 
    981981    { 
    982982        case NoCursor: 
     
    10031003            OSG_WARN << "GraphicsWindowCarbon::setCursor doesn't implement cursor: type = " << mouseCursor << std::endl; 
    10041004    } 
    1005      
     1005 
    10061006    _currentCursor = mouseCursor; 
    10071007    SetThemeCursor(cursor); 
     
    10161016} 
    10171017 
    1018 void GraphicsWindowCarbon::setWindowName (const std::string& name)  
     1018void GraphicsWindowCarbon::setWindowName (const std::string& name) 
    10191019{ 
    10201020    _traits->windowName = name; 
    1021     if (!_traits->windowName.empty())  
     1021    if (!_traits->windowName.empty()) 
    10221022    { 
    10231023        CFStringRef windowtitle = CFStringCreateWithBytes( kCFAllocatorDefault, (const UInt8*)(_traits->windowName.c_str()), _traits->windowName.length(),kCFStringEncodingUTF8, false ); 
     
    10691069    } 
    10701070 
    1071     virtual osg::GraphicsContext* createGraphicsContext(osg::GraphicsContext::Traits* traits)  
     1071    virtual osg::GraphicsContext* createGraphicsContext(osg::GraphicsContext::Traits* traits) 
    10721072    { 
    10731073        _init();