ReactGUI.Lib.dog

/////////////////////////////////////////////////////
// Structs for Proactive GUI
// This code is experimental and incomplete

struct GLOBAL{
    me GUI_Scalar: distanceBetween2Points(me GUI_Scalar: x1, me GUI_Scalar: y1, me GUI_Scalar: x2, me GUI_Scalar: y2) <- {
        me GUI_Scalar: deltaX <- abs(x2-x1)
        me GUI_Scalar: deltaY <- abs(y2-y1)
        return(sqrt(deltaX*deltaX + deltaY*deltaY))
    }
    me string: fetchStringField(our POV: info) <- {
        if(info==NULL){return("")}
        me string: retVal <- info.pItem.fetchString()
        if(info.pItem.value.format==fUnknown){retVal <- ""}
        return(retVal)
    }
    our POV: fetchField(our POV: info, me string: paramName) <- {
        if(info==NULL){return(NULL)}
        our POV: retVal <- info.pItem.fetchField(paramName)
        return(retVal)
    }
    our POV: safeFetchField(our POV: source, me string: paramName) <- {
        our POV: retPov <- fetchField(source, paramName)
        if(retPov==NULL){
            print("\n\nERROR: Parameter "+paramName+" was not found. Exiting.\n")
            logFatalError("Parameter "+paramName+" was not found in:\n"+source.stringify())
        }
        return(retPov)
    }
}

struct EventTrigger:inherits=<mode[tPrimaryClick, tSecondaryClick, tPrimaryUp, tPrimaryDn, tSecondaryUp, tSecondaryDn,
                                   tMouseMove, tMouseEnter, tMouseExit, tMouseHover, tDragStart, tKeyPress, tKeyUp, tKeyDn, tTimer
                                   // Add user or higher level trigger support
                                  ]> {}

struct EventType:inherits=<mode[eNullEvent, eNormalize, eAddInfon, eDeleteInfon, eEditString, eEditInt, eEditByType,
                                eMoveInfonInList, eMoveInfonToList, eGUI_PopupModal, eClosePopup,
                                eGUI_SetXY, eGUI_SetColor, eGUI_SetDragMode, eGUI_SetTimer, eGUI_setStr1, eGUI_setInt1,
                                eGUI_SetViewMode, eReqRedraw, eBlockEvents, eGUI_setActiveFlag,
                                eMouseMoved, ePrimaryClick, eSecondaryClick, eKeyTyped
                                // Add events for system events such as play_sound or fetch_file
                               ]> {}

struct GuiCoords{
    me GUI_Scalar: X  me GUI_Scalar: Y  me GUI_Scalar: W  me GUI_Scalar: H

    bool: isTouching(me GUI_Scalar: x, me GUI_Scalar: y) <- {
        return ((x >= X) and (x < X + W) and (y >= Y) and (y < Y + H))
    }
}

struct GuiDataRec{
    me int64: isActive   // 0=not active; 1=active, firstTime, 2=active, not first time
    me string: str1
    me string: str2
    me int64:  int1
    me int64:  int2
    me GuiCoords:coordinates
    me cdColor: color
    our POV: pov
    our ReactiveControl: ctrl
}

struct ProactEvent{
    me bool: done      // If done, don't repeat the action
    me EventTrigger: Trigger
    me GUI_Scalar: X
    me GUI_Scalar: Y
    me GUI_Scalar: W
    me GUI_Scalar: H
    our POV: topPov

    me EventType: eventType
    me string: dataIdTag
    me string: text
    me int64: int1
    our POV: infonX
    our POV: infonY
    me GUI_Scalar: arg1
    me GUI_Scalar: arg2
    me GUI_Scalar: arg3
    me GUI_Scalar: arg4
    our dashDrawing: popupDR
    their cdColor: NewColor

    // Event vars
    me GUI_Scalar: evX
    me GUI_Scalar: evY

    void: setTrigger(me EventTrigger: trigger, their GuiCoords:RA, our POV: TopPov<-NULL) <- {
        Trigger<-trigger; X<-RA.X; Y<-RA.Y; W<-RA.W; H<-RA.H;  topPov<-TopPov;
    }
    void: setInfonEvent(me EventType: evntType, our POV:infon1, our POV:infon2) <- {eventType<-evntType; infonX<-infon1; infonY<-infon2;}
    void: setNormalizeEvent(me EventType: evntType, me string: query) <- {eventType<-evntType; text<-query;}
    void: setGUI_Event(me EventType: evntType, our infon: target, me GUI_Scalar: a1, me GUI_Scalar: a2, me GUI_Scalar: a3, me GUI_Scalar: a4) <- {
        eventType<-evntType; arg1<-a1; arg2<-a2; arg3<-a3; arg4<-a4; done <- false;
    }
    void: setGUI_CallFunc(me EventType: evntType, me string: dataID)<-{eventType<-evntType; dataIdTag<-dataID; done <- false}
    void: setGUI_Event1(me EventType: evntType)<-{eventType<-evntType; done <- false}
    void: setGUI_Store_Str1(me string: dataID, me string: strVal)<-{eventType<-eGUI_setStr1; dataIdTag<-dataID; text<-strVal; done <- false}
    void: setGUI_Store_Int1(me string: dataID, me int64: intVal)<-{eventType<-eGUI_setInt1; dataIdTag<-dataID; int1<-intVal; done <- false}
    void: setGUI_ClosePopup(me string: dataID)<-{eventType<-eClosePopup; dataIdTag<-dataID; done <- false}
    void: setGUI_SetActiveFlag(me string: dataID, me bool: active)<-{eventType<-eGUI_setActiveFlag; dataIdTag<-dataID; int1<-active; done <- false}
    void: setGUI_popupEvent(me string: dataID, our POV:POVOfInfonToShow)<-{eventType<-eGUI_PopupModal; dataIdTag<-dataID; infonX<-POVOfInfonToShow; done <- false}
    void: setGUI_Color(me string: colorSlotID, their cdColor: newColor) <- {
        eventType<-eGUI_SetColor; text<-colorSlotID; NewColor<-newColor; done <- false;
    }

    bool: isTouching(me GUI_Scalar: x, me GUI_Scalar: y) <- {
        return ((x >= X) and (x < X + W) and (y >= Y) and (y < Y + H))
    }
}

struct ParamRec{
    our POV: sourcePov
    our POV: propertiesPov
    our POV: dataPov
    our POV: titlePov
    me string: title
    me GUI_Scalar: posX
    me GUI_Scalar: posY
    me GUI_Scalar: posW
    me GUI_Scalar: posH
    me string: text
    flag: startActive

    me string: viewStyleTag         // How will this be drawn
    me string: viewStyleTagArg      // arguments to modify it
    our ReactiveControl: viewStyleCtrl
    our GuiDataRec: parentCtrlsData
    their fontSpec: font
    me cdColor: foreGnd

    our POV: topPov // The top level Dash for this, if there is one.

    // Drag args
    flag: isADash  // Draggable, Z-Stackable, Can have multiple views of same data, has a config-dialog, can be on Dashboard
    our POV: screenPos   <- NULL
    our POV: xPov        <- NULL
    our POV: yPov        <- NULL
    our POV: width       <- NULL
    our POV: height      <- NULL

    void: init(our POV: source, me GUI_Scalar: X, me GUI_Scalar: Y, me GUI_Scalar: W, me GUI_Scalar: H) <- {
        sourcePov     <- source
        posX<-X; posY<-Y; posW<-W; posH<-H;
        propertiesPov <- fetchField(source, "properties")
        titlePov      <- fetchField(propertiesPov, "title")
        title         <- fetchStringField(titlePov)
        dataPov       <- fetchField(source, "data")
        screenPos     <- NULL
        xPov          <- NULL
        yPov          <- NULL
        screenPos <- fetchField(propertiesPov, "screenpos")
        if(screenPos!=NULL){
            xPov <- safeFetchField(screenPos, "xloc")
            yPov <- safeFetchField(screenPos, "yloc")
            posX<-xPov.pItem.fetchDouble()
            posY<-yPov.pItem.fetchDouble()
        }
    }
}

struct ReactiveControl{
   // our ParamRec: PR
    me int64: isActive
    me bool: expandsX()<-{return(false)}
    me bool: expandsY()<-{return(false)}
    void: setMetrics(our ParamRec: PR) <- {}
    void: draw(our dashDrawing: dr, our ParamRec: iPR) <- {}
    void: saveBack() <- {}
    void: processEntry(me string: buffer) <- {}

    me bool: mouseMoved(me GUI_Scalar:posX, me GUI_Scalar:posY) <- {return(false)}
    me bool: primaryClick(me GUI_Scalar:posX, me GUI_Scalar:posY) <- {return(false)}
    me bool: keyTyped(their GUI_KeyboardEvent: event) <- {return(false)}
}

struct StringView: inherits=ReactiveControl{
    void: setMetrics(our ParamRec: PR) <- {
        me string: text <- PR.sourcePov.pItem.value.str
        me deltaSize: DSize <- getTextSize(text, PR.font)
        PR.posW <- DSize.width + Yborder*2
        PR.posH <- DSize.height + Xborder*2
    }
    void: draw(our dashDrawing: dr, our ParamRec: PR) <- {
        dr.addC(cmdSetColor, styler.White)
        me string: text
        if(PR.sourcePov.pItem.type!=NULL){
            text <- PR.sourcePov.pItem.type.asGiven+": "
        }
        text <+- PR.sourcePov.pItem.value.str
        dr.addTF(cmdRenderText, PR.posX, PR.posY, text, PR.font)
        dr.add1(cmdFill)
    }
    me bool: expandsX()<-{return(false)}
    me bool: expandsY()<-{return(false)}
}

struct NumberView: inherits=ReactiveControl{
    void: setMetrics(our ParamRec: PR) <- {
        me string: text <- toString(PR.sourcePov.pItem.value.num)
        me deltaSize: DSize <- getTextSize(text, PR.font)
        PR.posW <- DSize.width + Yborder*2
        PR.posH <- DSize.height + Xborder*2
    }
    void: draw(our dashDrawing: dr, our ParamRec: PR) <- {
        dr.addC(cmdSetColor, styler.White)
        me string: text
        if(PR.sourcePov.pItem.type!=NULL){
            text <- PR.sourcePov.pItem.type.asGiven+": "
        }
        text <+- toString(PR.sourcePov.pItem.value.num)
        dr.addTF(cmdRenderText, PR.posX, PR.posY, text, PR.font)
        dr.add1(cmdFill)
    }
    me bool: expandsX()<-{return(false)}
    me bool: expandsY()<-{return(false)}
}

struct WidgetMngr{
    me Map<string, our ReactiveControl>: viewStyleTags

    our ReactiveControl: getviewStyleTagCtrl(me string: key) <- {
        if(viewStyleTags.containsKey(key)){
            return(viewStyleTags[key])
        }
        return(NULL)
    }
    void: setviewStyleTagCtrl(me string: key, our ReactiveControl: ctrl) <- {
        key <- unicodeMgr.normalizeStr(key)
        viewStyleTags[key] <- ctrl
    }
    our StringView:  staticStringView
    our NumberView:  staticNumberView
    void: init() <- {
        Allocate(staticStringView)
        Allocate(staticNumberView)
        setviewStyleTagCtrl("genericString", staticStringView)
        setviewStyleTagCtrl("genericNumber", staticNumberView)
    }
}

struct Presenter{
    their GuiModelManager: modelMgr
    me string: crntFocusIDStr
    our GuiDataRec: crntGDR

    me List<our ProactEvent>: eventRegistry             // For events with a single target
    me List<our ProactEvent>: broadcastEventRegistry    // More than one target wants to know

    void: registerEvent(our ProactEvent: event) <- {eventRegistry.prepend(event)}
    void: registerBroadcastEvent(our ProactEvent: event) <- {broadcastEventRegistry.prepend(event)}

    void: grabFocus(me string: widgetID) <- {
        if(widgetID == crntFocusIDStr){return()}
        if(crntFocusIDStr!=""){
            our GuiDataRec: old_GDR <- modelMgr.fetchGuiData(crntFocusIDStr) // Get currently focused item
            old_GDR.isActive<-0
            //log("DEACTIVATING:"+crntFocusIDStr)
        }
        our GuiDataRec: new_GDR <- modelMgr.fetchGuiData(widgetID)
        if(new_GDR!=NULL){
            new_GDR.isActive <+- 1
            crntFocusIDStr <- widgetID
            crntGDR <- new_GDR
            //log("ACTIVATING:"+widgetID)
        }
    }
    void: clearFocus() <- {
        if(crntGDR!=NULL){
            print("clearFocus()-B")
            crntGDR.ctrl.saveBack()
            crntGDR.isActive <- 0
            crntGDR <- NULL
        }
    }
    void: reset() <- {eventRegistry.clear(); broadcastEventRegistry.clear()}

    // Returns true if mouse is currently over this.
    // Sets up the events to manage it.
    me bool: addMouseOverEvents(me GuiCoords:myCoords) <- {
        me bool: mouseIsOver <- myCoords.isTouching(crntMouseX, crntMouseY)
        our ProactEvent:: guiEvent;
        if(!mouseIsOver){ // Register to be notified when mouse enters
            guiEvent.setTrigger(tMouseMove, myCoords)
            guiEvent.setGUI_Event1(eReqRedraw)
            registerEvent(guiEvent)
        }else{  // Register to be notified when mouse has exited
            guiEvent.setTrigger(tMouseExit, myCoords)
            guiEvent.setGUI_Event1(eReqRedraw)
            registerBroadcastEvent(guiEvent)
        }
        return(mouseIsOver)
    }

    me bool: itemIsThing(our infon: item) <- {
        return(!item.value.items.isEmpty() and item.value.items.first().type.asGiven =="thing")
    }

    me string: chooseviewStyleTag(our ParamRec: PR) <- {
        me string: retval
        if(PR.sourcePov.pItem.value.timelike){return("timeView")}
        if(itemIsThing(PR.sourcePov.pItem)){return("3DThing")}
        if(PR.propertiesPov!=NULL){
            our POV: viewStyleTag <- fetchField(PR.propertiesPov, "viewStyleTag")
            if(viewStyleTag){
                me string: VSTagStr <- fetchStringField(viewStyleTag)
                return(VSTagStr)
            }
            viewStyleTag <- fetchField(PR.propertiesPov, "viewStyleTagDefault")
            if(viewStyleTag){
                me string: VSTagStr <- fetchStringField(viewStyleTag)
                return(VSTagStr)
            }
        }
        me string: itemsType
        if(PR.sourcePov!=NULL and PR.sourcePov.pItem.type!=NULL){
            itemsType <- PR.sourcePov.pItem.type.asGiven
        }
        if(itemsType!=""){retval<-itemsType}
        else if(PR.dataPov){
            switch(PR.dataPov.pItem.value.fType){
                case LST:{retval<-"genericList"}
                case STR:{retval<-"genericString"}
                case NUM:{retval<-"genericNumber"}
            }
        }
    if(retval=="note" or retval=="role" or retval=="title"){retval<-"genericString"}
    else if(retval=="subtasks" or retval=="members"){retval<-"genericList"}

        if(PR.viewStyleTagArg=="_edit"){retval<+-"_edit"}
        retval <- unicodeMgr.normalizeStr(retval)
        PR.viewStyleTag <- retval
        PR.viewStyleCtrl<- widgetMngr.getviewStyleTagCtrl(retval)
   // if(PR.viewStyleCtrl==NULL){print("1. NULL for :"+retval+"\n")} else {print("1. SUcCESS for:'"+retval+"'\n")}
        return(retval)
    }


    void: drawCircleButton(our dashDrawing: dr, me GUI_Scalar: posX, me GUI_Scalar: posY, me GUI_Scalar: radius, me GUI_Scalar: lineWidth, me string: symbol, me string: datasID) <- {
        me GuiCoords:myCoords{posX, posY, radius*2, radius*2}
        me bool: mouseIsOver <- addMouseOverEvents(myCoords)
        me cdColor: buttonColor
        if(mouseIsOver){buttonColor<-buttonBright} else {buttonColor<-buttonNormal}
        dr.addC(cmdSetColor, buttonColor)
        dr.add1(cmdRoundLineCap)
        dr.add2(cmdSetLineWidth, lineWidth)
       // cr.circle(posX + radius, posY + radius, radius)
        me GUI_Scalar: stickLen <- radius/3
        if (symbol=="+") {
            dr.addXY(cmdMoveTo, posX + radius, posY + radius/4)
            dr.addXY(cmdLineTo, posX + radius, posY + 7*radius/4)
            dr.addXY(cmdMoveTo, posX + radius/4, posY + radius)
            dr.addXY(cmdLineTo, posX + 7*radius/4, posY + radius)
        } else if (symbol=="-") {
            dr.addXY(cmdMoveTo, posX + radius/4, posY + radius)
            dr.addXY(cmdLineTo, posX + 7*radius/4, posY + radius)
        } else if (symbol=="<") {
            dr.addXY(cmdMoveTo, posX + radius, posY + radius - stickLen * sqrt(2.0))
            dr.addXY(cmdLineTo, posX + radius - stickLen * sqrt(2), posY + radius)
            dr.addXY(cmdLineTo, posX + radius, posY + radius + stickLen * sqrt(2.0))
        } else if (symbol==">") {
            dr.addXY(cmdMoveTo, posX + radius, posY + radius - stickLen * sqrt(2.0))
            dr.addXY(cmdLineTo, posX + radius + stickLen * sqrt(2), posY + radius)
            dr.addXY(cmdLineTo, posX + radius, posY + radius + stickLen * sqrt(2.0))
        } else if (symbol=="v") {
            dr.addXY(cmdMoveTo, posX  - stickLen * sqrt(2.0), posY )
            dr.addXY(cmdLineTo, posX, posY + radius)
            dr.addXY(cmdLineTo, posX  + stickLen * sqrt(2.0), posY)
        } else if (symbol=="menu") {
            dr.addXY(cmdMoveTo, posX + radius/4, posY + radius)
            dr.addXY(cmdLineTo, posX + 7*radius/4, posY + radius)

            dr.addXY(cmdMoveTo, posX + radius/4, posY + radius/4)
            dr.addXY(cmdLineTo, posX + 7*radius/4, posY + radius/4)

            dr.addXY(cmdMoveTo, posX + radius/4, posY + 7*radius/4)
            dr.addXY(cmdLineTo, posX + 7*radius/4, posY + 7*radius/4)
        }
        dr.add1(cmdStroke)
        dr.add1(cmdEdgedLineCap)
    }
me int: GV_LeftRight_Pad <- 5
me int: GV_innerVert_Pad <- 5
me int: GV_innerHorz_Pad <- 5
me int: GV_topBottom_Pad <- 5

    void: draw_X_stack_XYwh(our dashDrawing: dr, our ParamRec: PR) <- {
        // Draw the list body
        me GUI_Scalar: xCur <- PR.posX
        me GUI_Scalar: maxH <- 0
        me int: count<- 0
        our POV: pov <- PR.sourcePov.pItem.value.items.front()
        while(pov){
            if(count>0){xCur <+- GV_innerHorz_Pad}
            dr.addC(cmdSetColor, surfaceBkgnd)
            our dashDrawing:: dr2
            our ParamRec:: iPR; iPR.init(pov, xCur, PR.posY, 0, 0); iPR.topPov <- PR.topPov
            chooseviewStyleTag(iPR)
            iPR.viewStyleTagArg <- PR.viewStyleTagArg
            drawItem(dr2, iPR)
            maxH <- max(maxH, iPR.posH)
            dr.add1(cmdFill)
            dr.addSubDrawing(dr2)
            xCur <+- vertListWidth
            count <+- 1
            pov <- pov.next
        }
        PR.posH <- maxH
        PR.posW <- xCur-PR.posX
    }
    void: draw_Y_stack_XYWh(our dashDrawing: dr, our ParamRec: PR) <- {
        // Draw the list body
        me GUI_Scalar: yCur <- PR.posY+GV_topBottom_Pad
        me List<our ParamRec>: itemParams
        // Calculate positioning
        me int: count<- 0
        our POV: pov <- PR.sourcePov.pItem.value.items.front()
        while(pov){
            if(count>0){yCur <+- GV_innerVert_Pad}
            our ParamRec:: innerPR; innerPR.init(pov, PR.posX+GV_LeftRight_Pad, yCur, PR.posW-(GV_LeftRight_Pad*2), 0)
            innerPR.topPov <- PR.topPov
            if(PR.viewStyleTagArg=="_edit"){innerPR.viewStyleTagArg <- PR.viewStyleTagArg}
            innerPR.font <- styler.defaultFont
            chooseviewStyleTag(innerPR)
            setNaturalDimensions(innerPR)
            if(innerPR.viewStyleCtrl!=NULL and innerPR.viewStyleCtrl.expandsX()){
                innerPR.posW <- PR.posW-10*2
            }
            //print("inner.posH:",innerPR.posH, "  vs:", innerPR.viewStyleTag,"\n")
            itemParams.append(innerPR)

            yCur <+- innerPR.posH
            count <+- 1
            pov <- pov.next
        }

        yCur <+- GV_topBottom_Pad
        PR.posH <- yCur-PR.posY   // return the height

        withEach iPR in itemParams{
            dr.addC(cmdSetColor, surfaceBkgnd)
            iPR.viewStyleTagArg <- PR.viewStyleTagArg
            drawItem(dr, iPR)
        }
    }
}

struct GuiModelManager{
    me Map<me string, our GuiDataRec>: guiData

    // TODO: Use these next 5 fields to better organize sessions
    our POV: session
    void: NewUserSession()  <- {}
    void: openUserSession() <- {}
    void: saveUserSession() <- {}
    void: sendSaveSignal()  <- {log("TODO: Request and save the model")}

    void: setGuiData(me string: dataID, our GuiDataRec: GDR) <- {guiData[dataID] <- GDR}
    void: setString(me string: dataID,  me string: val) <- {our GuiDataRec:: GDR; GDR.str1<-val; setGuiData(dataID, GDR)}
    void: setBool  (me string: dataID,  me bool:   val) <- {our GuiDataRec:: GDR; GDR.int1<-val; setGuiData(dataID, GDR)}
    void: setInt64 (me string: dataID,  me int64:  val) <- {our GuiDataRec:: GDR; GDR.int1<-val; setGuiData(dataID, GDR)}
    void: setColor (me string: dataID,  their cdColor: val)  <- {our GuiDataRec:: GDR; GDR.color<-val;       setGuiData(dataID, GDR)}
    void: setCoords(me string: dataID,  their GuiCoords: val)<- {our GuiDataRec:: GDR; GDR.coordinates<-val; setGuiData(dataID, GDR)}

    our GuiDataRec: fetchGuiData(me string: dataID) <-{
        itr Map<me string, our GuiDataRec>: it <- guiData.find(dataID)
        if(it == guiData.end()){return(NULL)}
        return(it.val)
    }

    me cdColor: getColor(me string: dataID, their cdColor: Default) <- {
        our GuiDataRec: result <- fetchGuiData(dataID)
        if(result==NULL){return(Default)}
        return(result.color)
    }
    me GuiCoords: getCoordinates(me string: dataID, their GuiCoords: Default) <- {
        our GuiDataRec: result <- fetchGuiData(dataID)
        if(result==NULL){return(Default)}
        return(result.coordinates)
    }
    me bool: getBool(me string: dataID, me bool: Default) <- {
        our GuiDataRec: result <- fetchGuiData(dataID)
        if(result==NULL){return(Default)}
        return(result.int1 != 0)
    }
    me int64: getInt64(me string: dataID, me int64: Default) <- {
        our GuiDataRec: result <- fetchGuiData(dataID)
        if(result==NULL){return(Default)}
        return(result.int1)
    }
    me string: getString(me string: dataID, me string: Default) <- {
        our GuiDataRec: result <- fetchGuiData(dataID)
        if(result==NULL){return(Default)}
        return(result.str1)
    }

}

struct ProactiveGUI{
    me Presenter: presenter
    me GuiModelManager: guiModelManager

    none:ProactiveGUI() <- {
        presenter.modelMgr <- guiModelManager
    }
}
struct DrawCmd:inherits=<mode[cmdMoveTo, cmdLineTo, cmdDrawRect, cmdRoundRect, cmdRoundTopRect, cmdRoundBotRect,
                                 cmdRenderText, cmdRenderTextCentered, cmdDrawImage, cmdDrawBkgndImage,
                                 cmdDrawCircle, cmdSetColor, cmdSetLineWidth, cmdRoundLineCap, cmdEdgedLineCap,
                                 cmdFill, cmdStroke, cmdSubDrawing, cmdRenderThing3D
                             ]> {}

struct Drawel{
    DrawCmd: cmd
    me GUI_Scalar: x
    me GUI_Scalar: y
    me GUI_Scalar: w
    me GUI_Scalar: h
    me GUI_Scalar: arg1
    me GUI_Scalar: arg2
    me string: text
    their fontSpec: font
    our dashDrawing: drawing
    our Thing3D: thing3D
    our Window3D: win3D

    void: render(their GUI_ctxt: cr)<-{
        //log("CMD:"+DrawCmdStrings[cmd]+" x:"+toString(x)+" y:"+toString(y)+" w:"+toString(w)+" h:"+toString(h)+" :"+text)
        switch(cmd){
        case cmdMoveTo:         {cr.moveTo(x,y)}
        case cmdLineTo:         {cr.lineTo(x,y)}
        case cmdDrawRect:       {cr.rectangle(x,y,w,h)}
        case cmdRoundRect:      {roundedRectangle(cr, x,y,w,h, arg1)}
        case cmdRoundTopRect:   {roundedTopRect(cr, x,y,w,h, arg1)}
        case cmdRoundBotRect:   {roundedBotmRect(cr, x,y,w,h, arg1)}
        case cmdRenderText:     {renderText(cr, text, font, x, y)}
        case cmdRenderTextCentered: {renderTextCentered(cr, text, font, x, y)}
        case cmdDrawImage:      {displayImage(cr, text, x, y, arg1)}
        case cmdDrawBkgndImage: {displayBackgroundImage(cr, text)}
        case cmdFill:           {cr.fillNow()}
        case cmdStroke:         {cr.strokeNow()}
        case cmdDrawCircle:     {cr.circle(x,y,arg1)}
        case cmdSetColor:       {cr.setRGBA(x,y,w,h)}
        case cmdSetLineWidth:   {cr.setLineWidth(x)}
        case cmdRoundLineCap:   {cr.setRoundLineCap()}
        case cmdEdgedLineCap:   {cr.setEdgedLineCap()}
        case cmdSubDrawing:     {drawing.render(cr)}

        case cmdRenderThing3D:  {thing3D.draw(cr, mat4ID, 0, win3D)}
        }
    }
}

struct dashDrawing{
    me List<our Drawel>: cmds

    our Drawel: add1(me DrawCmd: dCmd) <-{our Drawel:: drl; drl.cmd<-dCmd; cmds.pushLast(drl); return(drl)}
    our Drawel: add2(me DrawCmd: dCmd, me GUI_Scalar: X) <-{our Drawel:: drl; drl.x<-X; drl.cmd<-dCmd; cmds.pushLast(drl); return(drl)}
    our Drawel: addXY(me DrawCmd: dCmd, me GUI_Scalar: X, me GUI_Scalar: Y) <-{our Drawel:: drl; drl.cmd<-dCmd; drl.x<-X drl.y<-Y; cmds.pushLast(drl); return(drl)}
    our Drawel: addT(me DrawCmd: dCmd, me string: T) <-{our Drawel:: drl; drl.cmd<-dCmd; drl.text<-T; cmds.pushLast(drl); return(drl)}
    our Drawel: addC(me DrawCmd: dCmd, me cdColor: C) <-{our Drawel:: drl{C.red,C.green,C.blue,C.alpha}; drl.cmd<-dCmd; cmds.pushLast(drl); return(drl)}
    our Drawel: addRA(me DrawCmd: dCmd, their GuiCoords:RA) <-{our Drawel:: drl{RA.X, RA.Y, RA.W, RA.H}; drl.cmd<-dCmd; cmds.pushLast(drl); return(drl)}
    our Drawel: addRAA(me DrawCmd: dCmd, their GuiCoords:RA, me GUI_Scalar: ARG) <-{our Drawel:: drl{RA.X,RA.Y,RA.W,RA.H,ARG}; drl.cmd<-dCmd; cmds.pushLast(drl); return(drl)}
    our Drawel: addTF(me DrawCmd: dCmd, me GUI_Scalar: X, me GUI_Scalar: Y, me string: T, their fontSpec: F) <-{our Drawel:: drl; drl.cmd<-dCmd; drl.x<-X drl.y<-Y; drl.text<-T; drl.font<-F; cmds.pushLast(drl); return(drl)}
    our Drawel: addSubDrawing(our dashDrawing: D)<-{our Drawel:: drl; drl.cmd<-cmdSubDrawing; drl.drawing<-D; cmds.pushLast(drl); return(drl)}
    our Drawel: add3D(our Thing3D: thing, our Window3D: win3D)<-{our Drawel:: drl; drl.cmd<-cmdRenderThing3D; drl.thing3D<-thing; drl.win3D<-win3D; cmds.pushLast(drl); return(drl)}

    me void: render(their GUI_ctxt: cr) <- {
        withEach cmd in cmds{
            cmd.render(cr)
        }
    }
}

struct ProactiveGUIWidget: inherits=DashboardWidget{
    me GUI_Scalar: pointerDragThreshold <- 10

    me bool: primaryBtnIsDown
    me GUI_Scalar: primaryButtonDownX
    me GUI_Scalar: primaryButtonDownY
    me bool: currentlyDraggingPointer
    our infon: dragInfonTargetX
    our infon: dragInfonTargetY
    me GUI_Scalar: preDragX
    me GUI_Scalar: preDragY

    void: updateReferencedVars(me GUI_Scalar: argA, me GUI_Scalar: argB) <- {
        dragInfonTargetX.value.num <- preDragX+(argA-primaryButtonDownX) // ref1 <- argA
        dragInfonTargetY.value.num <- preDragY+(argB-primaryButtonDownY) // ref2 <- argB
        requestRedraw()
        //log("DRAG X:"+toString(argA-primaryButtonDownX) + "  Y:"+toString(argB-primaryButtonDownY))
    }
    void: fetchVariableReference(our infon: numInfonX, our infon: numInfonY) <- {
        dragInfonTargetX <- numInfonX
        dragInfonTargetY <- numInfonY
        preDragX <- numInfonX.fetchDouble()
        preDragY <- numInfonY.fetchDouble()
    }

    void: clearVariableReference() <- {
        dragInfonTargetX <- NULL
        dragInfonTargetY <- NULL
    }

    void: cancelDragOperation() <- {
        currentlyDraggingPointer <- false
        updateReferencedVars(primaryButtonDownX, primaryButtonDownY)
        clearVariableReference()
    }


    our ProactEvent: findEventUnderCursor(me EventTrigger: trgrFound, me GUI_Scalar: eventX, me GUI_Scalar: eventY) <- {
        withEach eventNode in proactiveGUI.presenter.eventRegistry{
            if(eventNode.Trigger==trgrFound){
                if(eventNode.isTouching(eventX, eventY)){
                    return(eventNode)
                }
            }
        }
        return(NULL)
    }

    me void: lookForDragStartEvent(me GUI_Scalar: eventX, me GUI_Scalar: eventY) <- {
        our ProactEvent: eventNode <- findEventUnderCursor(tDragStart, eventX, eventY)
        if(eventNode){
            currentlyDraggingPointer <- true
            fetchVariableReference(eventNode.infonX.pItem, eventNode.infonY.pItem)
            updateReferencedVars(eventX, eventY)
        }
    }

    void: checkBroadcastEvents(me EventTrigger: trgr, me GUI_Scalar: X, me GUI_Scalar: Y) <- {
        withEach eventNode in proactiveGUI.presenter.broadcastEventRegistry{
            if(eventNode.Trigger==trgr){
                if(!eventNode.isTouching(X, Y)){
                    proactiveGUI.guiModelManager.processCommand(eventNode)
                }
            }
        }
    }

    me bool: mouseMoved(their GUI_MotionEvent: event) <- {
        me bool: retVal <- false
        crntMouseX <- event.x
        crntMouseY <- event.y
        if(primaryBtnIsDown){
            if(currentlyDraggingPointer){
                updateReferencedVars(crntMouseX, crntMouseY)
            } else {
                me GUI_Scalar: distanceMoved <- distanceBetween2Points(primaryButtonDownX, primaryButtonDownY, crntMouseX, crntMouseY)
                if(distanceMoved>pointerDragThreshold){
                    lookForDragStartEvent(crntMouseX, crntMouseY)
                }
            }
            retVal <- true
        } else {
            //log("Registry: A:"+toString(proactiveGUI.presenter.eventRegistry.size())+" B:"+toString(proactiveGUI.presenter.broadcastEventRegistry.size()) +"   X:"+toString(crntMouseX) +"   Y:"+toString(crntMouseY))
            our ProactEvent: eventNode <- findEventUnderCursor(tMouseMove, event.x, event.y)
            if(eventNode){
                if(!eventNode.done){
                    proactiveGUI.guiModelManager.processCommand(eventNode)
                    eventNode.done <- true
                }
                retVal <- true
            }
            //log("Registry2_size:"+toString(proactiveGUI.presenter.broadcastEventRegistry.size()))
            checkBroadcastEvents(tMouseExit, event.x, event.y)
        }
        return(retVal)
    }

    me bool: primaryUp(their GUI_ButtonEvent: event) <- {
        primaryBtnIsDown <- false
        if(currentlyDraggingPointer){
            if(event.x != crntMouseX  or  event.y != crntMouseY){
                crntMouseX <- event.x
                crntMouseY <- event.y
                updateReferencedVars(crntMouseX, crntMouseY)
            }
            currentlyDraggingPointer <- false
            proactiveGUI.guiModelManager.sendSaveSignal()
            clearVariableReference()
            return(true)
        } else{
            our ProactEvent: eventNode <- findEventUnderCursor(tPrimaryUp, event.x, event.y)
            if(eventNode){
                proactiveGUI.guiModelManager.processCommand(eventNode)
                return(true)
            }
        }
        return(false)
    }
    me bool: primaryDn(their GUI_ButtonEvent: event) <- {
        primaryBtnIsDown <- true
        primaryButtonDownX <- event.x
        primaryButtonDownY <- event.y
        return(false)
    }
    me bool: primaryClick(their GUI_ButtonEvent: event) <- {
        me bool: retval <- false
        our ProactEvent: eventNode <- findEventUnderCursor(tPrimaryClick, event.x, event.y)
        if(eventNode){
            eventNode.evX <- event.x
            eventNode.evY <- event.y
            proactiveGUI.guiModelManager.processCommand(eventNode)
            retval <- true
        }
        checkBroadcastEvents(tPrimaryClick, event.x, event.y)
        return(retval)
    }

    me bool: secondaryClick(their GUI_ButtonEvent: event) <- {
        if(currentlyDraggingPointer){
            cancelDragOperation()
            return(true)
        } else {
            our ProactEvent: eventNode <- findEventUnderCursor(tSecondaryClick, event.x, event.y)
            if(eventNode){
                proactiveGUI.guiModelManager.processCommand(eventNode)
                return(true)
            }
        }
        return(false)
    }

    me bool: keyTyped(their GUI_KeyboardEvent: event) <- {
        me bool: retval <- false
        our GuiDataRec: GDR <- proactiveGUI.presenter.crntGDR
        if(GDR!=NULL and GDR.ctrl!=NULL){
            retval <- GDR.ctrl.keyTyped(event)
        }
        return(retval)
    }
    their GUI_canvas: initProactiveGUI() <- {
        primaryBtnIsDown <- false
        currentlyDraggingPointer <- false
        return(init("ProactiveGUI"))
    }

}

struct GLOBAL{
    me GUI_Scalar: crntMouseX
    me GUI_Scalar: crntMouseY
    me WidgetMngr: widgetMngr
}