BasicLib/ClassBox.h

Go to the documentation of this file.

#ifndef  __JBXL_CPP_CLASS_BOX_H_
#define  __JBXL_CPP_CLASS_BOX_H_


#include  "common++.h"
#include  "tools++.h"



//
namespace jbxl {



class   CVFrame;

extern  CVFrame*  GLFrame;        

class  CVFrame
{
public:
    CVFrame() {}
    virtual ~CVFrame() {}
};


inline void  SetGlobalFrame(CVFrame* frm) { GLFrame = frm;}

inline void  ClearGlobalFrame() { GLFrame = NULL;}



class   CVDisplay;

extern  CVDisplay*  GLDisplay;        

class  CVDisplay
{
public:
    const char* title;

public:
    CVDisplay() { title = NULL;}
    virtual ~CVDisplay() {}
};


inline void  SetGlobalDisplay(CVDisplay* disp) { GLDisplay = disp;}

inline void  ClearGlobalDisplay() { GLDisplay = NULL;}



class   CVTextDocument;

extern  CVTextDocument*  GLTextDocument;        

class  CVTextDocument
{
public:

public:
    CVTextDocument() { m_locked = FALSE;}
    virtual ~CVTextDocument() {}

protected:
    BOOL    m_locked;

public:
    virtual void  lprintBuffer(Buffer, int) {}           // ロック付き. int mode
    virtual void  lprintString(char*,  int) {}
    virtual void  lprintFormat(char*, ...)  {}
    virtual void  lfprintFormat(int, char*, ...) {}

    virtual void  printBuffer(Buffer, int) {}            // ロックなし
    virtual void  printString(char*,  int) {}
    virtual void  printFormat(char*, ...)  {}
    virtual void  fprintFormat(int, char*, ...) {}

    virtual void  lock(void)   { m_locked = TRUE;}
    virtual void  unlock(void) { m_locked = FALSE;}
};


inline void  SetGlobalTextDocument(CVTextDocument* doc) { GLTextDocument = doc;}

inline void  ClearGlobalTextDocument() { GLTextDocument = NULL;}



class   CVCounter;

extern  CVCounter*  GLCounter;        

class  CVCounter
{
public:
    int        max;       
    int        pos;       
    int        fill;      
    bool    cancel;       
    bool    start;        
    const char* title;

public:
    CVCounter() {
        max    = 0;
        pos    = 0;
        fill   = 0;
        title  = NULL;
        cancel = false;
        start  = false;
    }

    virtual ~CVCounter() {}

    virtual void  Init()        {max=pos=fill=0; title=""; cancel=false;};
    virtual void  Clear()        {Init();}
    virtual void  SetMax(int m) {max = fill = m;}                
    virtual void  SetFill(int m){fill = m;}                      
    virtual void  SetPos(int p) {pos = p;}                       
    virtual void  PutFill()     {pos = fill;}                    
    virtual int   GetMax()      {return max;}                    
    virtual int   GetFill()     {return fill;}                   
    virtual int   GetPos()      {return pos;}                    
    
    virtual void  Start(int m=100, char* tn=NULL) {SetMax(m); title=tn; start=true;}    
    virtual void  Stop() {max=pos=fill=0; title=NULL; start=false;}    
    virtual void  StepIt(int n=1) {pos+=n;}                      

    virtual bool  isCanceled()    {return cancel;}               
    virtual void  ResetRate(int n, int m) {fill=m; pos+=m-n;}    
    virtual void  SetTitle(char* tn)    {title=tn;}              

    virtual CVCounter* GetUsableCounter() {return this;}         
    virtual CVCounter* MakeChildCounter(int n) {ResetRate(n,n); SetMax(n); return this;}    
    virtual void  DeleteChildCounter() {}                        

};


inline CVCounter*  GetUsableGlobalCounter() 
{ 
    if (GLCounter!=NULL) return GLCounter->GetUsableCounter(); 
    else return NULL;
}

inline void  SetGlobalCounter(CVCounter* counter) { GLCounter = counter;}

inline void  ClearGlobalCounter() { GLCounter = NULL;}




}        // namespace



#endif

---