object.c

开放源码的编译器open watcom 1.6.0版的源代码

/* return pointer to the current object */

  {
    OBJECT * obj;
    OBJPTR   userobj;

    obj = GetPrimaryObject();
    userobj = NULL;
    if( obj != NULL ) {
        (*obj)(GET_OBJPTR, obj, &userobj, NULL );
    }
    return( userobj );
  }

LIST * WINEXP GetCurrObjectList( void )
/*************************************/

/* return pointer to the current object */

  {
    OBJECT * currobj;
    OBJPTR   userobj;
    LIST *   objlist;

    objlist = NULL;
    for( currobj = GetECurrObject(); currobj != NULL;
         currobj = GetNextECurrObject( currobj ) ) {
        userobj = NULL;
        (*currobj)(GET_OBJPTR, currobj, &userobj, NULL );
        if( userobj != NULL ) {
            ListAddElt( &objlist, userobj );
        }
    }
    return( objlist );
  }


extern CURROBJPTR GetECurrObject( void )
/**************************************/

/* return pointer to the current object */

  {
    OBJPTR   obj;
    OBJECT * currobj;

    currobj = GetCurrObj();
    (*currobj)(GET_OBJECT, currobj, &obj, NULL );
    return( obj );
  }


extern CURROBJPTR GetNextECurrObject( CURROBJPTR obj )
/****************************************************/

/* return pointer to the next current object in the list, after obj */

  {
    CURROBJPTR newobj;
    OBJECT *   currobj;

    currobj = GetCurrObj();
    (*currobj)(GET_OBJECT, currobj, &newobj, obj );
    return( newobj );
  }

extern void SetCurrObject( OBJPTR obj )
/*************************************/

/* make obj the only current object */

  {
    BOOL     reset;
    OBJECT * currobj;

    reset = TRUE;
    currobj = GetCurrObj();
    (*currobj)(ADD_OBJECT, currobj, obj, &reset );
  }

extern void AddCurrObject( OBJPTR obj )
/*************************************/

/* add obj to the list of current objects */

  {
    BOOL        reset;
    OBJECT *    currobj;
    CURROBJPTR  main_currobj;

    reset = FALSE;
    currobj = GetCurrObj();
    (*currobj)(ADD_OBJECT, currobj, obj, &reset );

    /* if the main object is in the list, remove it */
    /* so the main object can't be part of a multiple selection */
    main_currobj = GetCurrObjptr( GetMainObject() );
    if( main_currobj != NULL ) {
        DeleteCurrObject( main_currobj );
    }
  }

extern void DeleteCurrObject( OBJPTR obj )
/****************************************/

/* remove obj from the list of current objects */

  {
    OBJECT * currobj;
    BOOL     curritem;

    curritem = TRUE;
    currobj = GetCurrObj();
    (*currobj)(DELETE_OBJECT, currobj, obj, &curritem );
  }

extern void DeleteCurrObjptr( OBJPTR obj )
/****************************************/

/* Delete the current object associated with obj from the list of current
 * objects
 */

  {
    OBJECT * currobj;
    BOOL     curritem;

    curritem = FALSE;
    currobj = GetCurrObj();
    if( currobj != NULL ) {
        (*currobj)(DELETE_OBJECT, currobj, obj, &curritem );
    }
  }

extern CURROBJPTR GetPrimaryObject( void )
/****************************************/

/* return a pointer to the primary object */

  {
    CURROBJPTR primary;
    OBJECT *   currobj;
    BOOL       flag;

    currobj = GetCurrObj();
    flag = TRUE;
    (*currobj)(GET_PRIMARY, currobj, &primary, &flag );
    return( primary );
  }

extern void SetPrimaryObject( CURROBJPTR obj )
/********************************************/

/* return a pointer to the primary object */

  {
    OBJECT *   currobj;
    BOOL       flag;

    currobj = GetCurrObj();

    flag = FALSE;
    (*currobj)(GET_PRIMARY, currobj, &obj, &flag );
  }

extern void StartCurrObjMod( void )
/*********************************/
{
    OBJPTR *    currobj;

    currobj = GetCurrObj();
    Notify( currobj, CURR_OBJ_MOD_BEGIN, NULL );
} /* StartCurrObjMod */

extern void EndCurrObjMod( void )
/*******************************/
{
    OBJPTR *    currobj;

    currobj = GetCurrObj();
    Notify( currobj, CURR_OBJ_MOD_END, NULL );
} /* EndCurrObjMod */

extern OBJPTR GetObjptr( OBJECT * obj )
/*************************************/

/* Get a pointer to the object associated with the current object obj */

  {
    OBJPTR newobj;

    newobj = NULL;
    (*obj)(GET_OBJPTR, obj, &newobj, NULL );
    return( newobj );
  }

extern CURROBJPTR GetCurrObjptr( OBJPTR obj )
/*******************************************/

  {
    CURROBJPTR currobj;

    for( currobj = GetECurrObject(); currobj != NULL;
         currobj = GetNextECurrObject( currobj ) ) {
        if( GetObjptr( currobj ) == obj ) {
            return( currobj );
        }
    }
    return( NULL );
  }

extern BOOL DeleteCurrItem( OBJECT * obj )
/****************************************/

/* Delete the current item obj.  That is, destroy the current object window
 * but don't destroy the object associated with that current object
 */

  {
    return( (*obj)(DELETE_OBJECT, obj, NULL, NULL ));
  }

static BOOL CurrObjExist( CURROBJPTR findobj )
/********************************************/

  {
    CURROBJPTR currobj;

    currobj = GetECurrObject();
    while( currobj != NULL ) {
        if( currobj == findobj ) {
            return( TRUE );
        }
        currobj = GetNextECurrObject( currobj );
    }
    return( FALSE );
  }

BOOL WINEXP ExecuteCurrObject( ACTION id, void * p1, void * p2 )
/***************************************************************/

/* Perform action id on each of the objects in the current object list.
 * Always ensure that each object about to have the action performed
 * on it is still valid.  Remember that the action can be destroy,
 * which will make that object no longer in the current object list,
 * and can also affect other objects in that list (ie it's children).
 */

  {
    CURROBJPTR currobj;
    CURROBJPTR nextobj;

    currobj = GetECurrObject();
    while( currobj != NULL ) {
        nextobj = GetNextECurrObject( currobj );
        if( ( nextobj == NULL ) && ( !CurrObjExist( currobj ) ) ) {
            currobj = GetECurrObject();
            nextobj = GetNextECurrObject( currobj );
        }
        if( GetECurrObject() != NULL ) {
            Forward( currobj, id, p1, p2 );
        }
        currobj = nextobj;
    }
    return( TRUE );
  }

extern void ObjMark( CURROBJPTR obj )
/***********************************/

/* invalidate the objects location for painting */

  {
    RECT   rect;
    HRGN   little;
    HRGN   large;
    POINT  offset;

    if( !IsMarkValid( obj )) {
        return;
    }
    Location( obj, &rect );
    GetOffset( &offset );
    OffsetRect( &rect, -offset.x, -offset.y );
    little = CreateRectRgn( rect.left, rect.top, rect.right, rect.bottom );
    InflateRect( &rect, SQUAREWIDTH/2, SQUAREWIDTH/2 );
    large = CreateRectRgn( rect.left, rect.top, rect.right, rect.bottom );
    CombineRgn( large, large, little, RGN_DIFF );
    InvalidateRgn( GetAppWnd(), large, TRUE );
    DeleteObject( large );
    DeleteObject( little );
  }

void WINEXP ResetCurrObject( BOOL draw )
/**************************************/

/* reset the current object */

  {
    CURROBJPTR currobj;
    CURROBJPTR nextobj;

    currobj = GetECurrObject();
    while( currobj != NULL ) {
        nextobj = GetNextECurrObject( currobj );
        if( draw ) {
            if( GetObjptr( currobj ) != GetMainObject() ) {
                ObjMark( currobj );
            }
        }
        DeleteCurrObject( currobj );
        currobj = nextobj;
    }
    if( draw ) {
        UpdateWindow( GetAppWnd() );
    }
  }

extern void MarkCurrObject( void )
/********************************/

/* mark the current object */

 {
    CURROBJPTR currobj;

    currobj = GetPrimaryObject();
    if( currobj != NULL ) {
        ObjMark( currobj );
    }
  }

void WINEXP ObjectDestroyed( OBJPTR obj )
/***************************************/

  {
    DeleteCurrObjptr( obj );
  }

BOOL WINEXP GetObjectParent( OBJECT * obj, OBJPTR * parent )
/**********************************************************/

  {
    return( (*obj)(GET_PARENT, obj, parent, NULL ));
  }

extern void UndoMove( OBJECT * obj )
/**********************************/

  {
    (*obj)(UNDO_MOVE, obj, NULL, NULL );
  }

extern void RemoveFromParent( OBJECT * obj )
/******************************************/

  {
    (*obj)(REMOVE_FROM_PARENT, obj, NULL, NULL );
  }

BOOL WINEXP GetPriority( OBJECT * obj, int * pri )
/************************************************/

  {
    return( (*obj)(GET_PRIORITY, obj, pri, NULL ));
  }

BOOL WINEXP ResizeIncrements( OBJECT * obj, POINT * pt )
/******************************************************/

  {
    if( ValidateAction( obj,  GET_RESIZE_INC, pt ) ) {
        return( (*obj)( GET_RESIZE_INC, obj, pt, NULL ));
    }
    return( FALSE );
  }


void WINEXP MakeObjectCurrent( OBJPTR obj )
/*****************************************/

/* make the passes object current */

 {
   ResetCurrObject( FALSE );
   SetCurrObject( obj );
 }


void WINEXP AddCurrentObject( OBJPTR obj )
/****************************************/

/* make the passes object current */

 {
   AddCurrObject( obj );
 }

extern BOOL GetAnchor( OBJECT * obj, POINT * p )
/**********************************************/


  {
    return( (*obj)(GET_ANCHOR, obj, p, NULL ));
  }


extern BOOL RequestScrollRect( RECT * r )
/***************************************/


  {
    OBJECT * obj;

    obj = GetMainObject();
    return( (*obj)(GET_SCROLL_RECT, obj, r, NULL ));
  }


extern BOOL IsMarkValid( OBJECT * obj )
/*************************************/


  {
    BOOL     isvalid;

    isvalid = TRUE;
    if( ValidateAction( obj,  IS_MARK_VALID, NULL ) ) {
        (*obj)( IS_MARK_VALID, obj, &isvalid, NULL );

    }
    return( isvalid );
  }

extern void WINEXP NewOffset( POINT point )
/*****************************************/
// Set the offset to 'point' and reset the scrolling stuff
{
    SetOffset( point );
    UpdateScroll();
    InvalidateRect( GetAppWnd(), NULL, TRUE );
}