source: Sophya/trunk/SophyaPI/PI/Quartz/pibwdgquartz.cpp@ 4085

/*
 *  pibwdgquartz.cpp
 *  PI
 *
 *  Created by Bruno MANSOUX on 19/09/08.
 *
 */

#include "pibwdgquartz.h"
#include "PIContainerQuartz.h"

OSStatus BaseWdgQuartzEventHandler (EventHandlerCallRef myHandler,EventRef event, void *userData);

PIBaseWdgQuartz::PIBaseWdgQuartz(PIContainerGen *par, const char *nom, int sx, int sy, int px, int py)
: PIBaseWdgGen(par,nom,sx,sy,px,py)
{

 HIRect localHIRect;
        HIViewRef rootView;
        HIViewRef contentView;
        OSStatus err;
        fName = nom;
        
        rootView = ((PIWdg*)par)->GetHIViewRef();
        err = HIViewGetBounds (rootView, &localHIRect);

        err = HIScrollViewCreate(kHIScrollViewOptionsVertScroll | kHIScrollViewOptionsHorizScroll, &wdgHIView);
        err += HIViewSetVisible (wdgHIView, true);      
        
        err += HIViewFindByID(rootView, kHIViewWindowContentID, &contentView);
        err += HIViewAddSubview (contentView, wdgHIView);

        err += HIViewGetBounds (wdgHIView, &localHIRect);
        
        localHIRect.origin.x = (float)px;
        localHIRect.origin.y    = (float)py;
        localHIRect.size.width = (float)sx; 
        localHIRect.size.height = (float)sy;
        
        err = HIViewSetFrame (wdgHIView, &localHIRect);
        
        err += HIViewGetFrame (wdgHIView, &localHIRect);
        
        printf("PIBaseWdgQuartz::PIBaseWdgQuartz Set Frame (%g %g) [%g %g] err : %d nom:%s\n",
                                                                                        localHIRect.origin.x, localHIRect.origin.y,
                                                                                        localHIRect.size.width, localHIRect.size.height,
                                                                                        err,nom);

        err = InstallEventHandler (GetControlEventTarget (wdgHIView),
                                                                NewEventHandlerUPP (BaseWdgQuartzEventHandler),
                                                                GetEventTypeCount (basewdgSpec),
                                                                (const EventTypeSpec*)&basewdgSpec,
                                                                (void *) this,
                                                                NULL);

        HIViewRender(wdgHIView);
        mWGrC = new PIGraphicWin(this);
}

/* --Methode-- */
PIBaseWdgQuartz::~PIBaseWdgQuartz()
{
}

/* --Methode-- */
void PIBaseWdgQuartz::FinishCreate()
{
}

/* --Methode-- */
void PIBaseWdgQuartz::ActivatePtrCross()
{
}
 
/* --Methode-- */
void PIBaseWdgQuartz::ActivateButton(int bid)
{
}
 
/* --Methode-- */
void PIBaseWdgQuartz::ActivateMove(int bid)
{
}
 
/* --Methode-- */
void PIBaseWdgQuartz::ActivateKeyboard()
{
}
 
/* --Methode-- */
void PIBaseWdgQuartz::SelPointerShape(PIPointer ptr)
{
}
 
/* --Methode-- */
PIPointer PIBaseWdgQuartz::GetPointerShape()
{
        return PI_ArrowPointer;
}
 
/* --Methode-- */
void PIBaseWdgQuartz::AssignKeyboard()
{
}

/* --Methode-- */
void PIBaseWdgQuartz::GetLastEventInfo(PIKeyModifier& kmod, unsigned long& tm)
{
}

/* --Methode-- */
bool PIBaseWdgQuartz::IsVisible()
{
        return true;
}

/* --Methode-- */
void PIBaseWdgQuartz::Refresh()
{
//      return;
        printf("---->> PIBaseWdgQuartz::Refresh -%s- context:%lx\n",fName,mWGrC->GetCGContext());
        EventRef        rEvent;
        OSStatus err;
        
        err = CreateEvent( NULL,  kEventClassControl, kEventControlDraw,
                                GetCurrentEventTime(), kEventAttributeNone, &rEvent );
        SetEventParameter( rEvent, kEventParamCGContextRef, typeCGContextRef, sizeof (CGContextRef), mWGrC->GetCGContext());

        SendEventToEventTarget(rEvent, GetControlEventTarget (wdgHIView));
        
        HIRect hiRect;
        HIViewGetFrame(wdgHIView, &hiRect);

        printf(" cg : %lx ox : %g oy : %g width : %g height : %g \n",
                        mWGrC->GetCGContext(), hiRect.origin.x, hiRect.origin.y, hiRect.size.width, hiRect.size.height);
        // mWGrC->SetGCRect(hiRect.origin.x, hiRect.origin.y, hiRect.size.width, hiRect.size.height);   
        // Draw(mWGrC, 0, 0, XSize(), YSize());

        return;
}

/* --Methode-- */
void PIBaseWdgQuartz::eXposeProcess(CGContextRef cg, int x0, int y0, int dx, int dy)
{
        printf("PIBaseWdgQuartz::ExposeProcess -%s- to x:%d y:%d dx:%d dy:%d\n",fName,x0,y0,dx,dy);
        if (mWGrC->GetCGContext() == NULL) {
                mWGrC->SetCGContext(cg);
                printf("PIBaseWdgQuartz::ExposeProcess CHANGE context to %lx\n",cg);
                mWGrC->SetCTM(CGContextGetCTM(cg));
        }
        printf("PIBaseWdgQuartz::ExposeProcess set CTM to %lx\n",cg);
        CGContextSaveGState(mWGrC->GetCGContext());
        Draw(mWGrC, x0, y0, dx, dy);
//      CGContextRestoreGState (cg);
        CGContextRestoreGState (mWGrC->GetCGContext());

        return;
}
 
/* ============================================================================================================ */
/* ============================================================================================================ */
static int counterDraw = 0;
// Handler
OSStatus BaseWdgQuartzEventHandler (EventHandlerCallRef myHandler, EventRef event, void *userData)
{
        OSStatus status = noErr;
        
        counterDraw++;
        PIGetEventName(event);

        PIBaseWdgQuartz* wdg = (PIBaseWdgQuartz*) userData;
        printf("\n BaseWdgQuartzEventHandler -%s- (%d) : ", wdg->fName,counterDraw);
        printf("\n");

        CGContextRef cg;
        WindowRef           window;
    Rect                bounds;
        if (!wdg)
        return status;
        
    status = GetEventParameter (event, kEventParamCGContextRef, typeCGContextRef, NULL, sizeof (CGContextRef), NULL, &cg);

        switch(GetEventClass(event))
    {
/*        case kEventClassTablet:
        case kEventClassMouse:
            if (w->handleMouseEvent(event))
                result = noErr;
            break;
        case kEventClassKeyboard:
            if (w->handleKeyboardEvent(event))
                result = noErr;
            break;
            
*/        case kEventClassWindow: {
                        
            switch (GetEventKind(event))
                        {
                                case kEventWindowBoundsChanging:
                                        // left the code for live-resizing, but it is not used, because of window-refreshing issues...
                                        GetEventParameter( event, kEventParamCurrentBounds, typeQDRectangle, NULL, sizeof(Rect), NULL, &bounds );
                                        
//                                      wdg->adaptResize(bounds.left, bounds.top, bounds.right - bounds.left, bounds.bottom - bounds.top);
//                                      wdg->requestRedraw();
                                        status = noErr;
                                        break;
                                        
                                case kEventWindowBoundsChanged:
                                        InvalWindowRect(window, GetWindowPortBounds(window, &bounds));
                                        GetWindowBounds(window, kWindowContentRgn, &bounds);
//                                      wdg->adaptResize(bounds.left, bounds.top, bounds.right - bounds.left, bounds.bottom - bounds.top);
                                        status = noErr;
                                        break;
                    
                                case kEventWindowClose:
//                                      wdg->requestClose();
                                        status = noErr;
                                        break;
                                        
                                default: 
                                        break;
                        }
                break;  
                }
                case kEventClassControl : {                     
                        case kEventControlDraw: {
                                // wdg->SetQuartzCGContext(cg);
                                HIViewRef view = wdg->GetHIViewRef();
                                HIRect hiRect;
                                HIViewGetFrame(view, &hiRect);
                                // Pour le moment on rafraichit toute la vue
                                int ox = (int)(hiRect.origin.x);
                                int oy = (int)(hiRect.origin.x);
                                int dx = (int)(hiRect.size.width); 
                                int dy = (int)(hiRect.size.height);
                                printf("-->> PIbWdgquartz::BaseWdgQuartzEventHandler -%s- cg : %lx [%d %d] Frame [%d, %d] \n", wdg->fName,(unsigned long)cg, ox, oy, dx, dy);
                        
                                HIRect      bounds;
                                HIViewGetBounds ((HIViewRef) userData, &bounds);
                                printf("-->> PIbWdgquartz::BaseWdgQuartzEventHandler BOUNDS [%f %f] SIZE [%f, %f] \n",hiRect.origin.x,hiRect.origin.y,hiRect.size.width,hiRect.size.height);
                                //              err = HIViewSetFrame (wdgHIView, &localHIRect);
                                
                                wdg->eXposeProcess(cg, 0 , 0, dx, dy);
                        }
                        break;
                }
                        break;  
        default:
            printf("unknown: %g\n",GetEventClass(event));
            break;
    }
        
        /////
        
        
        
        if (status != noErr)
        {
                printf(" err = %d \n",status);
        }
        else
        {       
/*
 // wdg->SetQuartzCGContext(cg);
                HIViewRef view = wdg->GetHIViewRef();
                HIRect hiRect;
                HIViewGetFrame(view, &hiRect);
                // Pour le moment on rafraichit toute la vue
                int ox = (int)(hiRect.origin.x);
                int oy = (int)(hiRect.origin.x);
                int dx = (int)(hiRect.size.width); 
                int dy = (int)(hiRect.size.height);
                printf(" BaseWdgQuartzEventHandler cg : %lx [%d %d] Frame [%d, %d] \n", (unsigned long)cg, ox, oy, dx, dy);
                
                HIRect      bounds;
                HIViewGetBounds ((HIViewRef) userData, &bounds);
                printf(" BaseWdgQuartzEventHandler BOUNDS [%f %f] SIZE [%f, %f] \n",hiRect.origin.x,hiRect.origin.y,hiRect.size.width,hiRect.size.height);
//              err = HIViewSetFrame (wdgHIView, &localHIRect);
                
                wdg->eXposeProcess(cg, 0 , 0, dx, dy);
*/
        }

        return status;
}