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