Maxon Developers Maxon Developers
    • Documentation
      • Cinema 4D Python API
      • Cinema 4D C++ API
      • Cineware API
      • ZBrush Python API
      • ZBrush GoZ API
      • Code Examples on Github
    • Forum
    • Downloads
    • Support
      • Support Procedures
      • Registered Developer Program
      • Plugin IDs
      • Contact Us
    • Categories
      • Overview
      • News & Information
      • Cinema 4D SDK Support
      • Cineware SDK Support
      • ZBrush 4D SDK Support
      • Bugs
      • General Talk
    • Recent
    • Tags
    • Users
    • Login

    DDesc BitmapButtons when changed

    Scheduled Pinned Locked Moved SDK Help
    5 Posts 0 Posters 409 Views
    Loading More Posts
    • Oldest to Newest
    • Newest to Oldest
    • Most Votes
    Reply
    • Reply as topic
    Log in to reply
    This topic has been deleted. Only users with topic management privileges can see it.
    • H Offline
      Helper
      last edited by

      THE POST BELOW IS MORE THAN 5 YEARS OLD. RELATED SUPPORT INFORMATION MIGHT BE OUTDATED OR DEPRECATED

      On 19/10/2010 at 21:54, xxxxxxxx wrote:

      User Information:
      Cinema 4D Version:   R12 
      Platform:   Windows  ;   Mac OSX  ; 
      Language(s) :     C++  ;

      ---------
      In R11.5 and earlier, the code to add a BitmapButton in a Dynamic Description and set the image by state works.

      In R12, when the image is set to a new state, it disappears, then it defaults to some partial size and causes bad auto-layout of the AM elements.

      None of the similar static descriptions are affected (despite using the same code to set the image by state and so on).

      What has changed?

      1 Reply Last reply Reply Quote 0
      • H Offline
        Helper
        last edited by

        THE POST BELOW IS MORE THAN 5 YEARS OLD. RELATED SUPPORT INFORMATION MIGHT BE OUTDATED OR DEPRECATED

        On 22/10/2010 at 07:21, xxxxxxxx wrote:

        I am surprised that you could add a BitmapButton to the user data at all. Afaik buttons are not supported by user data.

        cheers,
        Matthias

        1 Reply Last reply Reply Quote 0
        • H Offline
          Helper
          last edited by

          THE POST BELOW IS MORE THAN 5 YEARS OLD. RELATED SUPPORT INFORMATION MIGHT BE OUTDATED OR DEPRECATED

          On 22/10/2010 at 12:48, xxxxxxxx wrote:

          Not 'user data'; GetDDescription()

          1 Reply Last reply Reply Quote 0
          • H Offline
            Helper
            last edited by

            THE POST BELOW IS MORE THAN 5 YEARS OLD. RELATED SUPPORT INFORMATION MIGHT BE OUTDATED OR DEPRECATED

            On 26/10/2010 at 08:33, xxxxxxxx wrote:

            Please post some source code showing the problem.

            cheers,
            Matthias

            1 Reply Last reply Reply Quote 0
            • H Offline
              Helper
              last edited by

              THE POST BELOW IS MORE THAN 5 YEARS OLD. RELATED SUPPORT INFORMATION MIGHT BE OUTDATED OR DEPRECATED

              On 26/10/2010 at 10:55, xxxxxxxx wrote:

              It is not a code problem as far as I am aware.  Again, this works in all other builds except R12.  First, here are some images to illustrate the problem:

              The first two are static bitmap buttons (in the .res file).  These are working.

              http://www.kuroyumes-developmentzone.com/referenced/Before_Static.jpg

              http://www.kuroyumes-developmentzone.com/referenced/After_Static.jpg

              These are the dynamic bitmap buttons.  Note that the secondary image (for disabled) is not being displayed:

              http://www.kuroyumes-developmentzone.com/referenced/Before_Dynamic.jpg

              http://www.kuroyumes-developmentzone.com/referenced/After_Dynamic.jpg

              The same basic code is employed for static and dynamic bitmap changes on state change and it works in R11.5 and earlier (same code).  The code below is how I was instructed to achieve this type of bitmap state change using Descriptions in the Attribute Manager.  Something change in R12 (surprise) and it is not documented as far as I am aware.

              // NodeData.GetDDescription - Descriptions and Parameters  
              //*---------------------------------------------------------------------------*  
              Bool GreeblerObj::GetDDescription(GeListNode* node, Description* description, DESCFLAGS_DESC& flags)  
              //*---------------------------------------------------------------------------*  
              {  
                gcbArray->Flush();  
                nubArray->Flush();  
                //pipArray->Flush();  
                
                // Initial validity checks  
                if (CheckIsRunning(CHECKISRUNNING_EXTERNALRENDERING) || CheckIsRunning(CHECKISRUNNING_EDITORRENDERING))        return TRUE;  
                if (!(node && description))            return FALSE;  
                if (!description->LoadDescription(node->GetType())) return FALSE;  
                
                // Get necessary pointers  
                BaseDocument*    baseDoc =            node->GetDocument();  
                if (!baseDoc)                        return FALSE;  
                BaseObject*        obj =                static_cast<BaseObject*>(node);  
                if (!obj)                            return FALSE;  
                BaseContainer*    opBC =                obj->GetDataInstance();  
                if (!opBC)                            return FALSE;  
                
              #ifndef    C4D_R115  
                // important to check for speedup c4d!  
                const DescID *singleid = description->GetSingleDescID();  
                
                DescID cid = DescLevel(GREEBLER_NURN_RENDERINSTANCE,DTYPE_BOOL,0);  
                
                if (!singleid || cid.IsPartOf(*singleid,NULL)) // important to check for speedup c4d!  
                {  
                    BaseContainer *bc = description->GetParameterI(cid,NULL);  
                    bc->SetBool(DESC_HIDE, TRUE);  
                }  
                //if (!description->SetParameter(DescLevel(GREEBLER_NURN_RENDERINSTANCE,DTYPE_BOOL,0L), stateBC, DescLevel(GREEBLER_GROUP_NURN_SETTING)))    return FALSE;  
              #endif  
                
                // *************************  
                // Add Dynamic Descriptions  
                // *************************  
                // Custom Greeble Shapes  
                // - Add Shapes from those inserted into Document and specified under GREEBLER_GREEC_LIBRARY link  
                BaseObject*        libop =                opBC->GetObjectLink(GREEBLER_GREEC_LIBRARY, baseDoc);  
                if (libop)  
                {  
                    if (!GetDDesc_CGreebles(description, baseDoc, obj, opBC, libop))    return FALSE;  
                }  
                // Add Nurnie BitmapButtons and Frequency sliders  
                // - Add Objects from those inserted into Document and specified under GREEBLER_NURN_LIBRARY link  
                libop =                                opBC->GetObjectLink(GREEBLER_NURN_LIBRARY, baseDoc);  
                if (libop)  
                {  
                    if (!GetDDesc_Nurnies(description, baseDoc, obj, opBC, libop))        return FALSE;  
                }  
                /*  
                // Add Piping Elements  
                // - Add Objects from those inserted into Document and specified under GREEBLER_PIPE_LIBRARY link  
                libop =                                opBC->GetObjectLink(GREEBLER_PIPE_LIBRARY, baseDoc);  
                if (libop)  
                {  
                    if (!GetDDesc_Piping(description, baseDoc, obj, opBC, libop))        return FALSE;  
                }  
                */  
                
                flags |=    DESCFLAGS_DESC_LOADED|DESCFLAGS_DESC_RECURSIONLOCK;  
                return SUPER::GetDDescription(node,description,flags);  
              }  
              // GreeblerObj.GetDDesc_CGreebles  
              //*---------------------------------------------------------------------------*  
              Bool GreeblerObj::GetDDesc_CGreebles(Description* description, BaseDocument* baseDoc, BaseObject* obj, BaseContainer* opBC, BaseObject* libop)  
              //*---------------------------------------------------------------------------*  
              {  
                // Add Shape BitmapButtons and Frequency sliders  
                // (States and Frequencies stored in dynamic aarray!)  
                // - Custom Shape Bar and Array lists  
                BaseContainer        listBC;  
                BaseTag*            tag =            NULL;  
                BaseContainer*        gbc =            NULL;  
                LONG                col =            GREEBLER_GREEC_GREEBLES_COL1;  
                LONG                ccnt =            0L;  
                for (BaseObject* op = libop->GetDown(); op; op = op->GetNext())  
                {  
                    // Get existing GCBInfoTag (BaseContainer) or create new tag  
                    tag =            ProcessGCBInfoTag(baseDoc, obj, op, "ggicon");  
                    if (!tag)        continue;  
                    gcbArray->Append(tag);  
                    gbc =            tag->GetDataInstance();  
                    gbc->SetLong(TGCBINFO_ID,        GREEBLER_GREEC_BITMAP+ccnt);  
                    gbc->SetString(TGCBINFO_NAME,    op->GetName());  
                    gbc->SetLink(TGCBINFO_LINK,        obj);  
                    listBC.SetString(ccnt, op->GetName());  
                    // Add Descriptions  
                    // - BitmapButton (actual bitmap is supplied like stock bitmaps!)  
                    if (!description->SetParameter(DescLevel(GREEBLER_GREEC_BITMAP+ccnt,DTYPE_BUTTON,0L), bmbBC, DescLevel(col)))    return FALSE;  
                    // - Labels on Left  
                    if (col == GREEBLER_GREEC_GREEBLES_COL1)  
                    {  
                        nameBC.SetString(DESC_SHORT_NAME,    GeLoadString(GRES_GDD_NAME));  
                        freqBC.SetString(DESC_SHORT_NAME,    GeLoadString(GRES_GDD_FREQUENCY));  
                        rrndBC.SetString(DESC_SHORT_NAME,    GeLoadString(GRES_GDD_ROTRANDOM));  
                        rangBC.SetString(DESC_SHORT_NAME,    GeLoadString(GRES_GDD_ROTANGLE));  
                    }  
                    else  
                    {  
                        nameBC.SetString(DESC_SHORT_NAME,    String(""));  
                        freqBC.SetString(DESC_SHORT_NAME,    String(""));  
                        rrndBC.SetString(DESC_SHORT_NAME,    String(""));  
                        rangBC.SetString(DESC_SHORT_NAME,    String(""));  
                    }  
                    // - Name  
                    if (!description->SetParameter(DescLevel(GREEBLER_GREEC_NAME+ccnt,DTYPE_STATICTEXT,0L), nameBC, DescLevel(col)))    return FALSE;  
                    opBC->SetString(GREEBLER_GREEC_NAME+ccnt,    gbc->GetString(TGCBINFO_NAME));  
                    // - Frequency  
                    if (!description->SetParameter(DescLevel(GREEBLER_GREEC_FREQ+ccnt,DTYPE_REAL,0L), freqBC, DescLevel(col)))    return FALSE;  
                    opBC->SetReal(GREEBLER_GREEC_FREQ+ccnt,        gbc->GetReal(TGCBINFO_FREQUENCY));  
                    // - Random Surface Rotation  
                    if (!description->SetParameter(DescLevel(GREEBLER_GREEC_ROT_RANDOM+ccnt,DTYPE_BOOL,0L), rrndBC, DescLevel(col)))        return FALSE;  
                    opBC->SetBool(GREEBLER_GREEC_ROT_RANDOM+ccnt,    gbc->GetBool(TGCBINFO_ROTRANDOM));  
                    // - Surface Rotation  
                    if (!description->SetParameter(DescLevel(GREEBLER_GREEC_ROT_ANGLE+ccnt,DTYPE_REAL,0L), rangBC, DescLevel(col)))            return FALSE;  
                    opBC->SetReal(GREEBLER_GREEC_ROT_ANGLE+ccnt,    gbc->GetReal(TGCBINFO_ROTANGLE));  
                    // - State  
                    if (!description->SetParameter(DescLevel(GREEBLER_GREEC_STATE+ccnt,DTYPE_BOOL,0L), stateBC, DescLevel(col)))    return FALSE;  
                    opBC->SetBool(GREEBLER_GREEC_STATE+ccnt,    gbc->GetBool(TGCBINFO_STATE));  
                    ++ccnt;  
                    // Control Column Group in use  
                    ++col;  
                    if (col > GREEBLER_GREEC_GREEBLES_COL5)    col = GREEBLER_GREEC_GREEBLES_COL1;  
                }  
                opBC->SetLong(GREEBLER_GREEC_COUNT, ccnt);  
                // Fill in Bar and Array shape options  
                BaseContainer    shapeBC =            GetCustomDataTypeDefault(DTYPE_LONG);  
                shapeBC.SetString(DESC_SHORT_NAME,    "Shape");  
                shapeBC.SetBool(DESC_ANIMATE,        FALSE);  
                shapeBC.SetContainer(DESC_CYCLE,    listBC);  
                if (!description->SetParameter(DescLevel(GREEBLER_GREEC_BARS_OBJ,DTYPE_LONG,0L), shapeBC, DescLevel(GREEBLER_GROUP_GREEBLES_CUSTOM)))    return FALSE;  
                if (!description->SetParameter(DescLevel(GREEBLER_GREEC_ARRAY_OBJ,DTYPE_LONG,0L), shapeBC, DescLevel(GREEBLER_GROUP_GREEBLES_CUSTOM)))    return FALSE;  
                if (!description->SetParameter(DescLevel(GREEBLER_GREEC_RARRAY_OBJ,DTYPE_LONG,0L), shapeBC, DescLevel(GREEBLER_GROUP_GREEBLES_CUSTOM)))    return FALSE;  
                if (opBC->GetLong(GREEBLER_GREEC_BARS_OBJ) >= ccnt)        opBC->SetLong(GREEBLER_GREEC_BARS_OBJ, 0L);  
                if (opBC->GetLong(GREEBLER_GREEC_ARRAY_OBJ) >= ccnt)    opBC->SetLong(GREEBLER_GREEC_ARRAY_OBJ, 0L);  
                if (opBC->GetLong(GREEBLER_GREEC_RARRAY_OBJ) >= ccnt)    opBC->SetLong(GREEBLER_GREEC_RARRAY_OBJ, 0L);  
                return TRUE;  
              }  
              // NodeData.Message  
              //*---------------------------------------------------------------------------*  
              Bool GreeblerObj::Message(GeListNode* node, LONG type, void* data)  
              //*---------------------------------------------------------------------------*  
              {  
                //GePrint(MsgToString(type));  
                if (!node)    return FALSE;  
                if        (type == MSG_DESCRIPTION_GETBITMAP)  
                    return MsgGetBitmap(static_cast<DescriptionGetBitmap*>(data), static_cast<BaseObject*>(node));  
                else if (type == MSG_DESCRIPTION_COMMAND)  
                    return MsgCommand(static_cast<DescriptionCommand*>(data), static_cast<BaseObject*>(node));  
                else if (type == MSG_DESCRIPTION_POSTSETPARAMETER)  
                    return MsgPostSetParameter(static_cast<DescriptionPostSetValue*>(data), static_cast<BaseObject*>(node));  
                /*  
                else if (type == MSG_DESCRIPTION_CHECKDRAGANDDROP)  
                    return MsgCheckDragAndDrop(static_cast<BaseTag*>(node), static_cast<DescriptionCheckDragAndDrop*>(data));  
                */  
                return SUPER::Message(node,type,data);  
              }  
              // GreeblerObj.GetSSBitMap  
              //*---------------------------------------------------------------------------*  
              void GreeblerObj::GetSSBitMap(DescriptionGetBitmap* dgb, const Bool& enabled, const String& sfn)  
              //*---------------------------------------------------------------------------*  
              {  
                Filename    bg;  
                if (enabled)        bg =    stocksfn+Filename(sfn+"_T.tif");  
                else                bg =    stocksfn+Filename(sfn+"_F.tif");  
                if (!GeFExist(bg))    return;  
                AutoAlloc<BaseBitmap>    bm;  
                if (!bm)            return;  
                bm->Init(bg);  
                dgb->bmp =            bm.Release();  
              }  
              // GreeblerObj.MsgGetBitmap  
              //*---------------------------------------------------------------------------*  
              Bool GreeblerObj::MsgGetBitmap(DescriptionGetBitmap* dgb, BaseObject* op)  
              //*---------------------------------------------------------------------------*  
              {  
                if (!(dgb && op))        return TRUE;  
                BaseContainer*    bc =    op->GetDataInstance();  
                LONG            id =    dgb->id[0].id;  
                if (id == GREEBLER_INFO)  
                {  
                    Filename    bg =    GeGetPluginPath()+Filename("res")+Filename("banner.tif");  
                    if (!GeFExist(bg))    return TRUE;  
                    AutoAlloc<BaseBitmap>    bm;  
                    if (!bm)            return TRUE;  
                    bm->Init(bg);  
                    dgb->bmp =            bm.Release();  
                }  
                // Stock Greebles  
                else if (id == GREEBLER_BITMAP_CUBE)            GetSSBitMap(dgb, bc->GetBool(GREEBLER_SHAPE_CUBE),        "cube");  
                else if (id == GREEBLER_BITMAP_T)                GetSSBitMap(dgb, bc->GetBool(GREEBLER_SHAPE_T),            "Tshape");  
                else if (id == GREEBLER_BITMAP_L)                GetSSBitMap(dgb, bc->GetBool(GREEBLER_SHAPE_L),            "Lshape");  
                else if (id == GREEBLER_BITMAP_C)                GetSSBitMap(dgb, bc->GetBool(GREEBLER_SHAPE_C),            "Cshape");  
                else if (id == GREEBLER_BITMAP_H)                GetSSBitMap(dgb, bc->GetBool(GREEBLER_SHAPE_H),            "Hshape");  
                else if (id == GREEBLER_BITMAP_D)                GetSSBitMap(dgb, bc->GetBool(GREEBLER_SHAPE_D),            "Dshape");  
                else if (id == GREEBLER_BITMAP_BOX)                GetSSBitMap(dgb, bc->GetBool(GREEBLER_SHAPE_BOX),        "box");  
                else if (id == GREEBLER_BITMAP_CUBECC)            GetSSBitMap(dgb, bc->GetBool(GREEBLER_SHAPE_CUBECC),    "cubecc");  
                else if (id == GREEBLER_BITMAP_OBLOCT)            GetSSBitMap(dgb, bc->GetBool(GREEBLER_SHAPE_OBLOCT),    "obloct");  
                else if (id == GREEBLER_BITMAP_CYLINDER)        GetSSBitMap(dgb, bc->GetBool(GREEBLER_SHAPE_CYLINDER),    "cyl");  
                else if (id == GREEBLER_BITMAP_RING)            GetSSBitMap(dgb, bc->GetBool(GREEBLER_SHAPE_RING),        "ring");  
                else if (id == GREEBLER_BITMAP_REGPOLY)            GetSSBitMap(dgb, bc->GetBool(GREEBLER_SHAPE_REGPOLY),    "regpoly");  
                else if (id == GREEBLER_BITMAP_REGPOLYR)        GetSSBitMap(dgb, bc->GetBool(GREEBLER_SHAPE_REGPOLYR),    "regpolyr");  
                else if (id == GREEBLER_BITMAP_BARS)            GetSSBitMap(dgb, bc->GetBool(GREEBLER_SHAPE_BARS),        "bars");  
                else if (id == GREEBLER_BITMAP_ARRAY)            GetSSBitMap(dgb, bc->GetBool(GREEBLER_SHAPE_ARRAY),        "array");  
                else if (id == GREEBLER_BITMAP_RARRAY)            GetSSBitMap(dgb, bc->GetBool(GREEBLER_SHAPE_RARRAY),    "rarray");  
                else if (id == GREEBLER_GREE_BOXIMAGE)            GetSSBitMap(dgb, TRUE,                                    "box");  
                else if (id == GREEBLER_GREE_CYLIMAGE)            GetSSBitMap(dgb, TRUE,                                    "cyl");  
                else if (id == GREEBLER_GREE_RNGIMAGE)            GetSSBitMap(dgb, TRUE,                                    "ring");  
                else if (id == GREEBLER_GREE_POLIMAGE)            GetSSBitMap(dgb, TRUE,                                    "regpoly");  
                else if (id == GREEBLER_GREE_PLRIMAGE)            GetSSBitMap(dgb, TRUE,                                    "regpolyr");  
                // Custom Greebles  
                else if (id == GREEBLER_BITMAP_CBARS)            GetSSBitMap(dgb, bc->GetBool(GREEBLER_SHAPE_CBARS),        "bars");  
                else if (id == GREEBLER_BITMAP_CARRAY)            GetSSBitMap(dgb, bc->GetBool(GREEBLER_SHAPE_CARRAY),    "array");  
                else if (id == GREEBLER_BITMAP_CRARRAY)            GetSSBitMap(dgb, bc->GetBool(GREEBLER_SHAPE_CRARRAY),    "rarray");  
                else if ((id >= GREEBLER_GREEC_BITMAP) && (id < GREEBLER_GREEC_FREQ))  
                {  
                    // Get associated GCBInfo bitmap  
                    BaseBitmap*        ibm =            GetGCBInfoBitmap_Greebles(op, bc, id);  
                    if (!ibm)                        return TRUE;  
                    AutoAlloc<BaseBitmap>    bm;  
                    if (!bm)                        return TRUE;  
                    ibm->CopyTo(bm);  
                    dgb->bmp =                        bm.Release();  
                }  
                // Nurnies  
                else if (id == GREEBLER_BITMAP_NBARS)            GetSSBitMap(dgb, bc->GetBool(GREEBLER_OBJECT_NBARS),    "bars");  
                else if (id == GREEBLER_BITMAP_NARRAY)            GetSSBitMap(dgb, bc->GetBool(GREEBLER_OBJECT_NARRAY),    "array");  
                else if (id == GREEBLER_BITMAP_NRARRAY)            GetSSBitMap(dgb, bc->GetBool(GREEBLER_OBJECT_NRARRAY),    "rarray");  
                else if ((id >= GREEBLER_NURN_BITMAP) && (id <= GREEBLER_NURN_BITMAP_END))  
                {  
                    // Get associated GCBInfo bitmap  
                    BaseBitmap*        ibm =            GetGCBInfoBitmap_Nurnies(op, bc, id);  
                    if (!ibm)                        return TRUE;  
                    AutoAlloc<BaseBitmap>    bm;  
                    if (!bm)                        return TRUE;  
                    ibm->CopyTo(bm);  
                    dgb->bmp =                        bm.Release();  
                }  
                return TRUE;  
              }  
              // NodeData.GetDParameter  
              //*---------------------------------------------------------------------------*  
              Bool GreeblerObj::GetDParameter(GeListNode* node, const DescID& id, GeData& t_data, DESCFLAGS_GET& flags)  
              //*---------------------------------------------------------------------------*  
              {  
                if (!node)        return FALSE;  
                LONG    did =    id[0].id;  
                // Custom Greebles  
                if ((did >= GREEBLER_GREEC_BITMAP) && (did <= GREEBLER_GREEC_BITMAP_END))  
                {  
                    BitmapButtonStruct bbs(static_cast<PluginObject*>(node), id, cg_bm_dirty);  
                    t_data =        GeData(CUSTOMDATATYPE_BITMAPBUTTON, bbs);  
                    flags |=        DESCFLAGS_GET_PARAM_GET;  
                    --cg_bm_dirty;  
                }  
                // Nurnies  
                else if ((did >= GREEBLER_NURN_BITMAP) && (did <= GREEBLER_NURN_BITMAP_END))  
                {  
                    BitmapButtonStruct bbs(static_cast<PluginObject*>(node), id, nu_bm_dirty);  
                    t_data =        GeData(CUSTOMDATATYPE_BITMAPBUTTON, bbs);  
                    flags |=        DESCFLAGS_GET_PARAM_GET;  
                    --nu_bm_dirty;  
                }  
                else  
                {  
                    switch (did)  
                    {  
                        // BitmapButtons  
                        case GREEBLER_INFO:  
                        {  
                            BitmapButtonStruct bbs(static_cast<PluginObject*>(node), id, 0L);  
                            t_data =        GeData(CUSTOMDATATYPE_BITMAPBUTTON, bbs);  
                            flags |=        DESCFLAGS_GET_PARAM_GET;  
                            break;  
                        }  
                        case GREEBLER_BITMAP_CUBE:  
                        case GREEBLER_BITMAP_T:  
                        case GREEBLER_BITMAP_L:  
                        case GREEBLER_BITMAP_C:  
                        case GREEBLER_BITMAP_H:  
                        case GREEBLER_BITMAP_D:  
                        case GREEBLER_BITMAP_BOX:  
                        case GREEBLER_BITMAP_CUBECC:  
                        case GREEBLER_BITMAP_OBLOCT:  
                        case GREEBLER_BITMAP_CYLINDER:  
                        case GREEBLER_BITMAP_RING:  
                        case GREEBLER_BITMAP_REGPOLY:  
                        case GREEBLER_BITMAP_REGPOLYR:  
                        case GREEBLER_BITMAP_BARS:  
                        case GREEBLER_BITMAP_ARRAY:  
                        case GREEBLER_BITMAP_RARRAY:  
                        case GREEBLER_GREE_BOXIMAGE:  
                        case GREEBLER_GREE_CYLIMAGE:  
                        case GREEBLER_GREE_RNGIMAGE:  
                        case GREEBLER_GREE_POLIMAGE:  
                        case GREEBLER_GREE_PLRIMAGE:  
                        {  
                            BitmapButtonStruct bbs(static_cast<PluginObject*>(node), id, sg_bm_dirty);  
                            t_data =        GeData(CUSTOMDATATYPE_BITMAPBUTTON, bbs);  
                            flags |=        DESCFLAGS_GET_PARAM_GET;  
                            --sg_bm_dirty;  
                            break;  
                        }  
                        // Custom Greebles  
                        case GREEBLER_BITMAP_CBARS:  
                        case GREEBLER_BITMAP_CARRAY:  
                        case GREEBLER_BITMAP_CRARRAY:  
                        {  
                            BitmapButtonStruct bbs(static_cast<PluginObject*>(node), id, cg_bm_dirty);  
                            t_data =        GeData(CUSTOMDATATYPE_BITMAPBUTTON, bbs);  
                            flags |=        DESCFLAGS_GET_PARAM_GET;  
                            --cg_bm_dirty;  
                        }  
                        // Nurnies  
                        case GREEBLER_BITMAP_NBARS:  
                        case GREEBLER_BITMAP_NARRAY:  
                        case GREEBLER_BITMAP_NRARRAY:  
                        {  
                            BitmapButtonStruct bbs(static_cast<PluginObject*>(node), id, nu_bm_dirty);  
                            t_data =        GeData(CUSTOMDATATYPE_BITMAPBUTTON, bbs);  
                            flags |=        DESCFLAGS_GET_PARAM_GET;  
                            --nu_bm_dirty;  
                        }  
                        default:  
                            break;  
                    }  
                }  
                return SUPER::GetDParameter(node, id, t_data, flags);  
              }  
              // NodeData.SetDParameter  
              //*---------------------------------------------------------------------------*  
              Bool GreeblerObj::SetDParameter(GeListNode* node, const DescID& id, const GeData& t_data, DESCFLAGS_SET& flags)  
              //*---------------------------------------------------------------------------*  
              {  
                if (!node)        return FALSE;  
                LONG    did =    id[0].id;  
                // Info BitmapButton  
                if (did == GREEBLER_INFO)  
                {  
                    if (flags & DESCFLAGS_SET_USERINTERACTION)  
                    {  
                        // user clicked on button - open Dialog  
                        greebler->ShowHelpDialog();  
                    }  
                    flags |=    DESCFLAGS_SET_PARAM_SET;  
                }  
                // Cube BitmapButton  
                else if (did == GREEBLER_BITMAP_CUBE)  
                {  
                    if (flags & DESCFLAGS_SET_USERINTERACTION)  
                    {  
                        BaseContainer*    bc =    static_cast<PluginObject*>(node)->GetDataInstance();  
                        // user clicked on button - toggle state  
                        bc->SetBool(GREEBLER_SHAPE_CUBE, !bc->GetBool(GREEBLER_SHAPE_CUBE));  
                    }  
                    flags |=    DESCFLAGS_SET_PARAM_SET;  
                }  
                // T BitmapButton  
                else if (did == GREEBLER_BITMAP_T)  
                {  
                    if (flags & DESCFLAGS_SET_USERINTERACTION)  
                    {  
                        BaseContainer*    bc =    static_cast<PluginObject*>(node)->GetDataInstance();  
                        // user clicked on button - toggle state  
                        bc->SetBool(GREEBLER_SHAPE_T, !bc->GetBool(GREEBLER_SHAPE_T));  
                    }  
                    flags |=    DESCFLAGS_SET_PARAM_SET;  
                }  
                // L BitmapButton  
                else if (did == GREEBLER_BITMAP_L)  
                {  
                    if (flags & DESCFLAGS_SET_USERINTERACTION)  
                    {  
                        BaseContainer*    bc =    static_cast<PluginObject*>(node)->GetDataInstance();  
                        // user clicked on button - toggle state  
                        bc->SetBool(GREEBLER_SHAPE_L, !bc->GetBool(GREEBLER_SHAPE_L));  
                    }  
                    flags |=    DESCFLAGS_SET_PARAM_SET;  
                }  
                // C BitmapButton  
                else if (did == GREEBLER_BITMAP_C)  
                {  
                    if (flags & DESCFLAGS_SET_USERINTERACTION)  
                    {  
                        BaseContainer*    bc =    static_cast<PluginObject*>(node)->GetDataInstance();  
                        // user clicked on button - toggle state  
                        bc->SetBool(GREEBLER_SHAPE_C, !bc->GetBool(GREEBLER_SHAPE_C));  
                    }  
                    flags |=    DESCFLAGS_SET_PARAM_SET;  
                }  
                // H BitmapButton  
                else if (did == GREEBLER_BITMAP_H)  
                {  
                    if (flags & DESCFLAGS_SET_USERINTERACTION)  
                    {  
                        BaseContainer*    bc =    static_cast<PluginObject*>(node)->GetDataInstance();  
                        // user clicked on button - toggle state  
                        bc->SetBool(GREEBLER_SHAPE_H, !bc->GetBool(GREEBLER_SHAPE_H));  
                    }  
                    flags |=    DESCFLAGS_SET_PARAM_SET;  
                }  
                // D BitmapButton  
                else if (did == GREEBLER_BITMAP_D)  
                {  
                    if (flags & DESCFLAGS_SET_USERINTERACTION)  
                    {  
                        BaseContainer*    bc =    static_cast<PluginObject*>(node)->GetDataInstance();  
                        // user clicked on button - toggle state  
                        bc->SetBool(GREEBLER_SHAPE_D, !bc->GetBool(GREEBLER_SHAPE_D));  
                    }  
                    flags |=    DESCFLAGS_SET_PARAM_SET;  
                }  
                // Box BitmapButton  
                else if (did == GREEBLER_BITMAP_BOX)  
                {  
                    if (flags & DESCFLAGS_SET_USERINTERACTION)  
                    {  
                        BaseContainer*    bc =    static_cast<PluginObject*>(node)->GetDataInstance();  
                        // user clicked on button - toggle state  
                        bc->SetBool(GREEBLER_SHAPE_BOX, !bc->GetBool(GREEBLER_SHAPE_BOX));  
                    }  
                    flags |=    DESCFLAGS_SET_PARAM_SET;  
                }  
                // CubeCC BitmapButton  
                else if (did == GREEBLER_BITMAP_CUBECC)  
                {  
                    if (flags & DESCFLAGS_SET_USERINTERACTION)  
                    {  
                        BaseContainer*    bc =    static_cast<PluginObject*>(node)->GetDataInstance();  
                        // user clicked on button - toggle state  
                        bc->SetBool(GREEBLER_SHAPE_CUBECC, !bc->GetBool(GREEBLER_SHAPE_CUBECC));  
                    }  
                    flags |=    DESCFLAGS_SET_PARAM_SET;  
                }  
                // Oblong Octagon BitmapButton  
                else if (did == GREEBLER_BITMAP_OBLOCT)  
                {  
                    if (flags & DESCFLAGS_SET_USERINTERACTION)  
                    {  
                        BaseContainer*    bc =    static_cast<PluginObject*>(node)->GetDataInstance();  
                        // user clicked on button - toggle state  
                        bc->SetBool(GREEBLER_SHAPE_OBLOCT, !bc->GetBool(GREEBLER_SHAPE_OBLOCT));  
                    }  
                    flags |=    DESCFLAGS_SET_PARAM_SET;  
                }  
                // Cylinder BitmapButton  
                else if (did == GREEBLER_BITMAP_CYLINDER)  
                {  
                    if (flags & DESCFLAGS_SET_USERINTERACTION)  
                    {  
                        BaseContainer*    bc =    static_cast<PluginObject*>(node)->GetDataInstance();  
                        // user clicked on button - toggle state  
                        bc->SetBool(GREEBLER_SHAPE_CYLINDER, !bc->GetBool(GREEBLER_SHAPE_CYLINDER));  
                    }  
                    flags |=    DESCFLAGS_SET_PARAM_SET;  
                }  
                // Ring BitmapButton  
                else if (did == GREEBLER_BITMAP_RING)  
                {  
                    if (flags & DESCFLAGS_SET_USERINTERACTION)  
                    {  
                        BaseContainer*    bc =    static_cast<PluginObject*>(node)->GetDataInstance();  
                        // user clicked on button - toggle state  
                        bc->SetBool(GREEBLER_SHAPE_RING, !bc->GetBool(GREEBLER_SHAPE_RING));  
                    }  
                    flags |=    DESCFLAGS_SET_PARAM_SET;  
                }  
                // RegularPolygon BitmapButton  
                else if (did == GREEBLER_BITMAP_REGPOLY)  
                {  
                    if (flags & DESCFLAGS_SET_USERINTERACTION)  
                    {  
                        BaseContainer*    bc =    static_cast<PluginObject*>(node)->GetDataInstance();  
                        // user clicked on button - toggle state  
                        bc->SetBool(GREEBLER_SHAPE_REGPOLY, !bc->GetBool(GREEBLER_SHAPE_REGPOLY));  
                    }  
                    flags |=    DESCFLAGS_SET_PARAM_SET;  
                }  
                // RegularPolygonR BitmapButton  
                else if (did == GREEBLER_BITMAP_REGPOLYR)  
                {  
                    if (flags & DESCFLAGS_SET_USERINTERACTION)  
                    {  
                        BaseContainer*    bc =    static_cast<PluginObject*>(node)->GetDataInstance();  
                        // user clicked on button - toggle state  
                        bc->SetBool(GREEBLER_SHAPE_REGPOLYR, !bc->GetBool(GREEBLER_SHAPE_REGPOLYR));  
                    }  
                    flags |=    DESCFLAGS_SET_PARAM_SET;  
                }  
                // Bars BitmapButton  
                else if (did == GREEBLER_BITMAP_BARS)  
                {  
                    if (flags & DESCFLAGS_SET_USERINTERACTION)  
                    {  
                        BaseContainer*    bc =    static_cast<PluginObject*>(node)->GetDataInstance();  
                        // user clicked on button - toggle state  
                        bc->SetBool(GREEBLER_SHAPE_BARS, !bc->GetBool(GREEBLER_SHAPE_BARS));  
                    }  
                    flags |=    DESCFLAGS_SET_PARAM_SET;  
                }  
                // Array BitmapButton  
                else if (did == GREEBLER_BITMAP_ARRAY)  
                {  
                    if (flags & DESCFLAGS_SET_USERINTERACTION)  
                    {  
                        BaseContainer*    bc =    static_cast<PluginObject*>(node)->GetDataInstance();  
                        // user clicked on button - toggle state  
                        bc->SetBool(GREEBLER_SHAPE_ARRAY, !bc->GetBool(GREEBLER_SHAPE_ARRAY));  
                    }  
                    flags |=    DESCFLAGS_SET_PARAM_SET;  
                }  
                // Ring Array BitmapButton  
                else if (did == GREEBLER_BITMAP_RARRAY)  
                {  
                    if (flags & DESCFLAGS_SET_USERINTERACTION)  
                    {  
                        BaseContainer*    bc =    static_cast<PluginObject*>(node)->GetDataInstance();  
                        // user clicked on button - toggle state  
                        bc->SetBool(GREEBLER_SHAPE_RARRAY, !bc->GetBool(GREEBLER_SHAPE_RARRAY));  
                    }  
                    flags |=    DESCFLAGS_SET_PARAM_SET;  
                }  
                // Custom Greebles  
                // - Bars BitmapButton  
                else if (did == GREEBLER_BITMAP_CBARS)  
                {  
                    if (flags & DESCFLAGS_SET_USERINTERACTION)  
                    {  
                        BaseContainer*    bc =    static_cast<PluginObject*>(node)->GetDataInstance();  
                        // user clicked on button - toggle state  
                        bc->SetBool(GREEBLER_SHAPE_CBARS, !bc->GetBool(GREEBLER_SHAPE_CBARS));  
                    }  
                    flags |=    DESCFLAGS_SET_PARAM_SET;  
                }  
                // - Array BitmapButton  
                else if (did == GREEBLER_BITMAP_CARRAY)  
                {  
                    if (flags & DESCFLAGS_SET_USERINTERACTION)  
                    {  
                        BaseContainer*    bc =    static_cast<PluginObject*>(node)->GetDataInstance();  
                        // user clicked on button - toggle state  
                        bc->SetBool(GREEBLER_SHAPE_CARRAY, !bc->GetBool(GREEBLER_SHAPE_CARRAY));  
                    }  
                    flags |=    DESCFLAGS_SET_PARAM_SET;  
                }  
                // - Ring Array BitmapButton  
                else if (did == GREEBLER_BITMAP_CRARRAY)  
                {  
                    if (flags & DESCFLAGS_SET_USERINTERACTION)  
                    {  
                        BaseContainer*    bc =    static_cast<PluginObject*>(node)->GetDataInstance();  
                        // user clicked on button - toggle state  
                        bc->SetBool(GREEBLER_SHAPE_CRARRAY, !bc->GetBool(GREEBLER_SHAPE_CRARRAY));  
                    }  
                    flags |=    DESCFLAGS_SET_PARAM_SET;  
                }  
                // - Individual Shapes  
                else if ((did >= GREEBLER_GREEC_BITMAP) && (did < GREEBLER_GREEC_FREQ))  
                {  
                    if (flags & DESCFLAGS_SET_USERINTERACTION)  
                    {  
                        LONG            inc =    did-GREEBLER_GREEC_BITMAP;  
                        BaseContainer*    bc =    static_cast<PluginObject*>(node)->GetDataInstance();  
                        // user clicked on button - toggle state  
                        Bool            state =    !bc->GetBool(GREEBLER_GREEC_STATE+inc);  
                        bc->SetBool(GREEBLER_GREEC_STATE+inc, state);  
                        BaseTag*        tag =    SetGCBInfoTag_Greebles(node->GetDocument(), static_cast<BaseObject*>(node), did);  
                        if (tag)        tag->GetDataInstance()->SetBool(TGCBINFO_STATE, state);  
                    }  
                    flags |=    DESCFLAGS_SET_PARAM_SET;  
                }  
                // Nurnies  
                // - Bars BitmapButton  
                else if (did == GREEBLER_BITMAP_NBARS)  
                {  
                    if (flags & DESCFLAGS_SET_USERINTERACTION)  
                    {  
                        BaseContainer*    bc =    static_cast<PluginObject*>(node)->GetDataInstance();  
                        // user clicked on button - toggle state  
                        bc->SetBool(GREEBLER_OBJECT_NBARS, !bc->GetBool(GREEBLER_OBJECT_NBARS));  
                    }  
                    flags |=    DESCFLAGS_SET_PARAM_SET;  
                }  
                // - Array BitmapButton  
                else if (did == GREEBLER_BITMAP_NARRAY)  
                {  
                    if (flags & DESCFLAGS_SET_USERINTERACTION)  
                    {  
                        BaseContainer*    bc =    static_cast<PluginObject*>(node)->GetDataInstance();  
                        // user clicked on button - toggle state  
                        bc->SetBool(GREEBLER_OBJECT_NARRAY, !bc->GetBool(GREEBLER_OBJECT_NARRAY));  
                    }  
                    flags |=    DESCFLAGS_SET_PARAM_SET;  
                }  
                // - Ring Array BitmapButton  
                else if (did == GREEBLER_BITMAP_NRARRAY)  
                {  
                    if (flags & DESCFLAGS_SET_USERINTERACTION)  
                    {  
                        BaseContainer*    bc =    static_cast<PluginObject*>(node)->GetDataInstance();  
                        // user clicked on button - toggle state  
                        bc->SetBool(GREEBLER_OBJECT_NRARRAY, !bc->GetBool(GREEBLER_OBJECT_NRARRAY));  
                    }  
                    flags |=    DESCFLAGS_SET_PARAM_SET;  
                }  
                // - Individual Nurnie objects  
                else if ((did >= GREEBLER_NURN_BITMAP) && (did <= GREEBLER_NURN_BITMAP_END))  
                {  
                    if (flags & DESCFLAGS_SET_USERINTERACTION)  
                    {  
                        LONG            inc =    did-GREEBLER_NURN_BITMAP;  
                        BaseContainer*    bc =    static_cast<PluginObject*>(node)->GetDataInstance();  
                        // user clicked on button - toggle state  
                        Bool            state =    !bc->GetBool(GREEBLER_NURN_STATE+inc);  
                        bc->SetBool(GREEBLER_NURN_STATE+inc, state);  
                        BaseTag*        tag =    SetGCBInfoTag_Nurnies(node->GetDocument(), static_cast<BaseObject*>(node), did);  
                        if (tag)        tag->GetDataInstance()->SetBool(TGCBINFO_STATE, state);  
                    }  
                    flags |=    DESCFLAGS_SET_PARAM_SET;  
                }  
                return SUPER::SetDParameter(node, id, t_data, flags);  
              }  
              
              1 Reply Last reply Reply Quote 0
              • First post
                Last post