home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Crawly Crypt Collection 1
/
crawlyvol1.bin
/
apps
/
spread
/
opusprg
/
opussrc
/
gr.pas
< prev
next >
Wrap
Pascal/Delphi Source File
|
1988-05-16
|
34KB
|
812 lines
{$M+}
{$E+}
PROGRAM Mock;
{$I i:\opus.i}
{$I i:\GCTV.inc}
{$I i:\gemsubs.def}
{$I i:\vdi_aes.def}
{$I i:\globsubs.def}
{$I d:\pascal\opus\xbios.def}
{$I d:\pascal\opus\stringfn.def}
PROCEDURE GET_NUM_SCR_ENTRIES ( direction : ExpandDirection );
{ right expansion is based on start_col;
left expansion is based on finish_col }
LABEL 1;
VAR x_tot,i,j,width : INTEGER;
BEGIN
IF start_row < logical_row_1 THEN
start_row := logical_row_1
ELSE IF start_row > n_rows THEN
start_row := n_rows;
IF start_col < logical_col_1 THEN
start_col := logical_col_1
ELSE IF start_col > n_cols THEN
start_col := n_cols;
IF finish_col > n_cols THEN
finish_col := n_cols
ELSE IF finish_col < logical_col_1 THEN
finish_col := logical_col_1;
Work_Rect(act_hdl,x_1,y_1,w_1,h_1);
1: h_entry := 0;
width := w_1-x_margin;
x_tot := 0;
i := 1;
IF direction = ExRight THEN BEGIN
WHILE i <= max_screen_cols DO BEGIN { right expand }
IF start_col+i-1 <= n_cols THEN
IF x_tot+col_width[start_col+i-1,pixels] < width THEN BEGIN
h_entry := h_entry+1;
x_tot := x_tot+col_width[start_col+i-1,pixels]
END
ELSE
i := max_screen_cols+1;
i := i+1
END;
IF (start_col > logical_col_1) AND
(h_entry > 0) THEN { left expand if possible }
IF x_tot+col_width[start_col-1,pixels] < width THEN BEGIN
start_col := start_col-1;
GOTO 1
END;
IF h_entry < 1 THEN
h_entry := 1;
finish_col := start_col+h_entry-1; { no need to check if > n_cols }
IF finish_col < n_cols THEN BEGIN
virtual_f_col := finish_col+1;
virtual_h_entry := h_entry+1
END
ELSE BEGIN
virtual_f_col := finish_col;
virtual_h_entry := h_entry
END
END
ELSE BEGIN
WHILE i <= max_screen_cols DO BEGIN { left expand }
IF finish_col-i+1 >= logical_col_1 THEN
IF x_tot+col_width[finish_col-i+1,pixels] < width THEN BEGIN
h_entry := h_entry+1;
x_tot := x_tot+col_width[finish_col-i+1,pixels]
END
ELSE
i := max_screen_cols+1;
i := i+1
END;
IF (finish_col < n_cols) AND
(h_entry > 0) THEN { right expand if possible }
IF x_tot+col_width[finish_col+1,pixels] < width THEN BEGIN
finish_col := finish_col+1;
GOTO 1
END;
IF h_entry < 1 THEN
h_entry := 1;
start_col := finish_col-h_entry+1; { no need to check if < }
IF finish_col < n_cols THEN BEGIN { logical_col_1 }
virtual_f_col := finish_col+1;
virtual_h_entry := h_entry+1
END
ELSE BEGIN
virtual_f_col := finish_col;
virtual_h_entry := h_entry
END
END;
v_entry := (h_1-y_margin) DIV cell_height;
finish_row := start_row+v_entry-1;
IF finish_row > n_rows THEN
finish_row := n_rows;
IF finish_row < n_rows THEN BEGIN
virtual_f_row := finish_row+1;
virtual_v_entry := v_entry+1
END
ELSE BEGIN
virtual_f_row := finish_row;
virtual_v_entry := v_entry
END;
IF data_row < start_row THEN
data_row := start_row
ELSE IF data_row > finish_row THEN
data_row := finish_row;
IF data_col < start_col THEN
data_col := start_col
ELSE IF data_col > finish_col THEN
data_col := finish_col
END; { GET_NUM_SCR_ENTRIES }
PROCEDURE DEF_VERT_GRID;
VAR i,j : INTEGER;
BEGIN
i := x_1+x_margin;
j := 1;
vert_grid[1] := i;
WHILE j <= virtual_h_entry DO BEGIN
i := i+col_width[start_col+j-1,pixels];
vert_grid[j+1] := i;
j := j+1
END
END; { DEF_VERT_GRID }
PROCEDURE DEF_SHEET_AREA;
BEGIN
get_num_scr_entries(ExRight);
def_vert_grid;
find_screen_pos(data_row,data_col,scr_row,scr_col); { keep current }
save_attr { most current attributes; ESSENTIAL!!! }
END; { DEF_SHEET_AREA }
FUNCTION DATA_CLIP : BOOLEAN;
BEGIN
data_clip := TRUE;
Work_Rect(act_hdl,x_1,y_1,w_1,h_1);
clip_x := x_1+x_margin+1;
clip_y := y_1+y_margin+1;
clip_w := w_1-(x_margin+1);
clip_h := h_1-(y_margin+1);
IF redraw_flag THEN BEGIN
IF redraw_x >= clip_x THEN BEGIN { redraw area within data area? }
clip_x := redraw_x;
clip_w := redraw_w
END
ELSE IF redraw_x+redraw_w > clip_x THEN { width within data area? }
clip_w := redraw_x+redraw_w-clip_x { set width then }
ELSE
data_clip := FALSE; { note that we could set w = 0, but }
clip_y := redraw_y; { Set_Clip doesn't seem to work with clip }
clip_h := redraw_h { width of zero }
END;
Set_Clip(clip_x,clip_y,clip_w,clip_h)
END; { DATA_CLIP }
PROCEDURE DRAW_SHEET ( extent : ExtentType;
row_start,row_end,col_start,col_end : INTEGER;
blit_flag : BOOLEAN );
LABEL 1;
VAR
i,j,k,offset,width,t,t2 : INTEGER;
BEGIN
{ extent determines which parts of the screen are painted and then
redrawn. if NoRowNames, for example, the row names as displayed
are protected from being redrawn by limiting the clipping
rectangle }
Work_Rect(act_hdl,x_1,y_1,w_1,h_1);
CASE extent OF
NoRowNames : Set_Clip(x_1+x_margin+1,y_1,w_1-x_margin-1,h_1);
NoColNames : Set_Clip(x_1,y_1+y_margin+1,w_1,h_1-(y_margin+1));
WholeSheet : IF redraw_flag THEN
Set_Clip(redraw_x,redraw_y,redraw_w,redraw_h)
ELSE
Set_Clip(x_1,y_1,w_1,h_1);
JustData : IF NOT data_clip THEN
GOTO 1;
END; { CASE extent }
IF NOT blit_flag THEN
Paint_Rect(x_1,y_1,w_1,h_1);
Line_Color(LightBlue);
Line_Style(Solid);
width := x_1+w_1;
Line(x_1,y_1+cell_height-1,width,y_1+cell_height-1);
IF freeze_row > 0 THEN
Line(x_1,y_1+y_margin,width,y_1+y_margin);
IF freeze_col > 0 THEN BEGIN
Line(x_1+38,y_1,x_1+38,y_1+h_1);
Line(vert_grid[1],y_1,vert_grid[1],y_1+h_1)
END
ELSE
Line(vert_grid[1],y_1,vert_grid[1],y_1+h_1);
t := y_1+y_margin-cell_height+1;
t2 := y_1+y_margin;
{ set up pts_in array so that we only have to calculate the }
{ vertical coordinates of the lines once }
FOR k := row_start TO row_end+1 DO
pts_in[k] := t+k*cell_height;
IF rez = 1 THEN { high }
offset := 3
ELSE
offset := 2;
FOR j := col_start+1 TO col_end+1 DO BEGIN { vertical lines... }
Line_Style(Solid); { these are easy }
Line(vert_grid[j],y_1,vert_grid[j],t2); { col title separators }
IF grid_flag THEN BEGIN
My_Line_Style ($AAAA); { grid }
FOR k := row_start TO row_end DO
Line(vert_grid[j],pts_in[k],vert_grid[j],pts_in[k+1]-offset)
END
END;
i := y_1+y_margin+row_start*cell_height;
Line_Style(Solid);
FOR j := row_start TO row_end DO BEGIN { horizontal lines }
Line(x_1,i,vert_grid[1],i); { row title separators }
i := i+cell_height
END;
{ The big problem in drawing the grid is avoiding shifting lines
when moving off screen; the screen is blitted in the pertinent
direction. Now if the pixels in every column of the same width
are not in exactly the same relative positions, a 'shift' of the
grid lines occurs upn blitting; this is most annoying. So the first
step in avoiding this is to break the lines up into segments and
process them all the same way. This also applies to the vertical grid
but for some reason that was easy to do. If it were that easy for
the horizontal lines...
For the horizontal grid, a line pattern of X X X X... is sufficient
for mono, if it's drawn as below; this avoids shifting lines when
the screen is blitted left to right. The line segments are all
processed in the same way. This also works in
color, but the 'grid' looks like a dim solid line; no way the monitor
has 640 pixels resolution. Does a different line-type work? Not that
I could discover; the VDI does NOT always start a line with the most
sig. bit of the line style ( why it works in mono I don't know ), and
varying the offsets from the vertgrids proved fruitless. So, by
DRAWING lines in color, segments which are different in each column
appear, and the shifting lines are back. Solution? Process the
segments by columns, doing all the rows in a column, and begin by
PLOTTING the pixels in the first row. Then for the remaining rows,
BLIT a 1-pixel high raster of the plotted points in the position of
each segment in that column, and plotting every row is just too slow.
This way, every segment is processed identically, and no more
shifting lines. }
IF grid_flag THEN BEGIN
IF rez = 2 THEN { med rez }
FOR j := col_start TO col_end DO BEGIN
i := y_1+y_margin+row_start*cell_height;
IF redraw_flag THEN
WHILE i < redraw_y DO BEGIN
i := i+cell_height;
row_start := row_start+1
END;
k := vert_grid[j]+2;
WHILE k < vert_grid[j+1]-2 DO BEGIN
Plot(k,i);
k := k+8
END;
FOR k := row_start+1 TO row_end DO BEGIN
Blit(screen_mfdb,screen_mfdb,vert_grid[j]+1,i,
vert_grid[j]+1,i+cell_height,
vert_grid[j+1]-vert_grid[j],1);
i := i+cell_height
END
END
ELSE BEGIN
My_Line_Style($AAAA); { grid }
i := y_1+y_margin+row_start*cell_height;
FOR j := row_start TO row_end DO BEGIN
FOR k := col_start TO col_end DO
Line(vert_grid[k]+2,i,vert_grid[k+1]-2,i);
i := i+cell_height
END
END
END;
1: END; (* DRAW_SHEET *)
PROCEDURE TOGGLE_INVERSE ( color,row,col : INTEGER );
{ proc to toggle inverse video on a CELL; uses a Paint_Rect call to do this
and is very fast as opposed to old method ( see DRAW_INVERSE_VIDEO ),
since no draw_string is called and needn't worry about format of cell }
{ accepts row,col as sheet not screen coordinates }
{ has already had it's clip rectangle set }
VAR x,y,w,h,l_scr_row,l_scr_col : INTEGER;
BEGIN
find_screen_pos(row,col,l_scr_row,l_scr_col);
x := vert_grid[l_scr_col]+1; { upper left corner }
y := y_1+y_margin+1+(l_scr_row-1)*cell_height; { of cell }
w := col_width[col,pixels]-1;
h := cell_height-1;
Draw_Mode(XOR_Mode);
Paint_Color(color);
Paint_Rect(x,y,w,h);
Paint_Color(White);
Draw_Mode(Replace_Mode)
END; { TOGGLE_INVERSE }
PROCEDURE PREP_CELL ( ptr : CellPtr; VAR temp : STRING );
BEGIN
temp := '';
IF ptr <> NIL THEN
IF ptr^.status <> Empty THEN
WITH ptr^ DO
CASE class OF
Val : prepare_num(ptr,temp);
Labl : temp := str^;
Expr :
IF NOT form_flag THEN { don't display formulas }
IF status < OK THEN { error! }
temp := error_msg[status]
ELSE
prepare_num(ptr,temp)
ELSE
temp := str^
END
END; { PREP_CELL }
PROCEDURE SET_STYLE ( format : INTEGER );
VAR style : INTEGER;
BEGIN
IF format & style_mask <> 0 THEN BEGIN
style := 0;
IF format & bold_mask <> 0 THEN
style := style | Bold;
IF format & italic_mask <> 0 THEN
style := style | Italics;
IF format & under_mask <> 0 THEN
style := style | Underlined;
Text_Style(style)
END
END; { SET_STYLE }
PROCEDURE DRAW_CELL ( row,col : INTEGER; force : BOOLEAN );
{ row,col are the positions within the sheet, not the screen positions }
LABEL 1;
VAR i,l_scr_row,l_scr_col : INTEGER;
in_range : BOOLEAN;
temp : STRING;
ptr : CellPtr;
a : AssignedStatus;
BEGIN
{ draw cell contents; i.e. extent = just_data, so... }
IF NOT data_clip THEN
GOTO 1;
temp := '';
{ now find out what screen row and col we're in }
find_screen_pos(row,col,l_scr_row,l_scr_col);
a := assigned(row,col,ptr);
{ the following lets me move among unassigned cells
without having to draw a blank cell for them, taking more time and
possibly writing over assigned ones adjacent to it that overlap.
However, I can punt this by passing a TRUE 'force' value. Useful
when I know for sure that I'm NOT moving, i.e. changing cell class,
updating on-screen cells from within a dialog routine ( sort, prec,
etc. ) }
IF (a = Void) OR (a = Desolate) THEN
IF NOT force THEN BEGIN { force = true forces a draw of the cell }
toggle_inverse(Black,row,col);
GOTO 1
END;
IF block_set THEN
in_range := (row >= b_s_row) AND (row <= b_e_row) AND
(col >= b_s_col) AND (col <= b_e_col)
ELSE
in_range := FALSE;
prep_cell(ptr,temp); { we know we're going to draw }
total := 0;
y_pos := y_1+y_margin+cell_height+(l_scr_row-1)*cell_height-1;
{ must first blank out the cell to be sure that when we draw
this one, nothing from adjacent cells spills into it }
Paint_Rect(vert_grid[l_scr_col]+1,y_pos-cell_height+2,
col_width[col,pixels]-1,cell_height-1);
IF ptr <> NIL THEN
WITH ptr^ DO BEGIN
set_style(format);
CASE find_just(ptr) OF
VDI_Left : Draw_Just(vert_grid[l_scr_col]+1,y_pos,
VDI_Left,temp);
VDI_Center : Draw_Just(vert_grid[l_scr_col]+1+
col_width[col,pixels] DIV 2,
y_pos,VDI_Center,temp);
VDI_Right : Draw_Just(vert_grid[l_scr_col+1],y_pos,
VDI_Right,temp)
END; { CASE }
Text_Style(Normal)
END; { WITH }
{ at this point the current cell has been drawn in replace mode
and ISN'T highlighted }
IF in_range THEN
toggle_inverse(Black,row,col);
IF (row = data_row) AND (col = data_col) THEN
toggle_inverse(Black,row,col);
1: END; { DRAW_CELL }
PROCEDURE DISPLAY_DATA ( extent : ExtentType;
row_begin,row_end,col_begin,
col_end : INTEGER );
LABEL 1,2,3;
VAR i,j,k,l,row,col,m,t,style : INTEGER;
found,over,quit : BOOLEAN;
temp : STRING;
ptr : CellPtr;
BEGIN
IF row_begin < logical_row_1 THEN
row_begin := logical_row_1
ELSE IF row_begin > n_rows THEN
row_begin := n_rows;
IF col_begin < logical_col_1 THEN
col_begin := logical_col_1
ELSE IF col_begin > n_cols THEN
col_begin := n_cols;
IF row_end < logical_row_1 THEN
row_end := logical_row_1
ELSE IF row_end > n_rows THEN
row_end := n_rows;
IF col_end < logical_col_1 THEN
col_end := logical_col_1
ELSE IF col_end > n_cols THEN
col_end := n_cols;
temp := '';
Work_Rect(act_hdl,x_1,y_1,w_1,h_1);
IF redraw_flag THEN
Set_Clip(redraw_x,redraw_y,redraw_w,redraw_h)
ELSE
Set_Clip(x_1,y_1,w_1,h_1);
Text_Color(Red);
{ draw row numbers; no_col_names means we aren't changing them and
that implies we have moved up or down and thus need to redraw the
row numbers }
IF (extent = WholeSheet) OR (extent = NoColNames) THEN BEGIN
j := y_1+cell_height+y_margin-1;
t := x_1+38 DIV 2;
IF freeze_row > 0 THEN BEGIN
int_to_string(freeze_row,temp);
Draw_Just(t,j-cell_height,VDI_Center,temp)
END;
FOR i := start_row TO row_begin-1 DO
j := j+cell_height;
FOR i := row_begin TO row_end DO BEGIN
int_to_string(i,temp);
Draw_Just(t,j,VDI_Center,temp);
j := j+cell_height
END
END;
{ draw column letters; if no_row_names we have moved left or right
and hence must redraw the col names }
IF (extent = WholeSheet) OR (extent = NoRowNames) THEN BEGIN
t := y_1+cell_height-2;
j := col_begin-start_col+1;
IF freeze_col > 0 THEN
Draw_Just(x_1+39+col_width[freeze_col,pixels] DIV 2,t,
VDI_Center,col_name[freeze_col]);
FOR i := col_begin TO col_end DO BEGIN
{ in the middle of a cell }
Draw_Just(vert_grid[j]+1+col_width[i,pixels] DIV 2,t,
VDI_Center,col_name[i]);
j := j+1
END
END;
{ first determine the y coordinates here rather than within the inner
loop for speed }
pts_in[1] := y_1+y_margin+(row_begin-start_row+1)*cell_height-1;
FOR i := 2 TO row_end-row_begin+1 DO
pts_in[i] := pts_in[i-1]+cell_height;
Text_Color(Black);
IF (extent = WholeSheet) OR (extent = NoColNames) THEN
IF freeze_col > 0 THEN BEGIN
clip_x := x_1+39;
clip_y := y_1+y_margin+1;
clip_w := col_width[freeze_col,pixels]-1;
clip_h := h_1-(y_margin+1);
IF redraw_flag THEN BEGIN
IF redraw_x > clip_x+clip_w THEN
GOTO 2
ELSE IF redraw_x >= clip_x THEN BEGIN
IF redraw_x+redraw_w > clip_x+clip_w THEN
clip_w := clip_w-(redraw_x-clip_x)
ELSE
clip_w := redraw_w;
clip_x := redraw_x
END
ELSE IF redraw_x+redraw_w > clip_x THEN BEGIN
clip_w := redraw_x+redraw_w-clip_x;
IF clip_w > col_width[freeze_col,pixels] THEN
clip_w := col_width[freeze_col,pixels]
END
ELSE
GOTO 2;
clip_y := redraw_y;
clip_h := redraw_h
END;
Set_Clip(clip_x,clip_y,clip_w,clip_h);
FOR i := row_begin TO row_end DO BEGIN
ptr := locate_cell(i,freeze_col);
IF ptr <> NIL THEN BEGIN
prep_cell(ptr,temp);
set_style(ptr^.format);
row := i+1-row_begin;
CASE find_just(ptr) OF
VDI_Left : Draw_Just(x_1+39,pts_in[row],
VDI_Left,temp);
VDI_Center : Draw_Just(x_1+39+
col_width[ptr^.c,pixels] DIV 2,
pts_in[row],VDI_Center,temp);
VDI_Right : Draw_Just(vert_grid[1],pts_in[row],
VDI_Right,temp)
END; { CASE }
Text_Style(Normal)
END
END
END;
2: IF (extent = WholeSheet) OR (extent = NoRowNames) THEN
IF freeze_row > 0 THEN BEGIN
clip_x := x_1+x_margin+1;
clip_y := y_1+cell_height;
clip_w := w_1-(x_margin+1);
clip_h := h_1-cell_height;
IF redraw_flag THEN BEGIN
IF redraw_x >= clip_x THEN BEGIN
clip_x := redraw_x;
clip_w := redraw_w
END
ELSE IF redraw_x+redraw_w > clip_x THEN
clip_w := redraw_x+redraw_w-clip_x
ELSE
GOTO 3;
clip_y := redraw_y;
clip_h := redraw_h
END;
Set_Clip(clip_x,clip_y,clip_w,clip_h);
m := y_1+y_margin-1;
FOR i := col_begin TO col_end DO BEGIN
ptr := locate_cell(freeze_row,i);
IF ptr <> NIL THEN BEGIN
prep_cell(ptr,temp);
set_style(ptr^.format);
k := ptr^.c-start_col+1;
CASE find_just(ptr) OF
VDI_Left : Draw_Just(vert_grid[k]+1,m,VDI_Left,temp);
VDI_Center : Draw_Just(vert_grid[k]+1+
col_width[ptr^.c,pixels] DIV 2,
m,VDI_Center,temp);
VDI_Right : Draw_Just(vert_grid[k+1],m,VDI_Right,temp)
END; { CASE }
Text_Style(Normal)
END
END
END;
{ draw cell contents; i.e. extent = just_data, so... }
3: IF NOT data_clip THEN
GOTO 1;
FOR i := row_begin TO row_end DO BEGIN
{ needn't blank out individual unassigned cells since this is
only called when the entire sheet has been redrawn and the
screen painted }
found := FALSE;
quit := FALSE;
ptr := data[i];
WHILE (ptr <> NIL) AND (NOT found) AND (NOT quit) DO
IF (ptr^.c >= col_begin) AND (ptr^.c <= col_end) THEN
found := TRUE
ELSE IF ptr^.c > col_end THEN
quit := TRUE
ELSE
ptr := ptr^.next;
over := FALSE;
row := i-row_begin+1;
IF found THEN
WHILE (ptr <> NIL) AND (NOT over) DO BEGIN
{ draw the current cell LAST because it may extend beyond the
borders of itself, and its neighbors might overwrite this
extension; want THIS cell to have precedence! }
IF (i <> data_row) OR (ptr^.c <> data_col) THEN BEGIN
prep_cell(ptr,temp);
{ here we could first blank out each cell or better yet
check if bounding cells extend into the current cell
and then blank it out; i.e. only the current cells
contents would be in that cell with no overflow from
other cells. But this would really slow things down,
and since this really only applies to labels, the
user should't have labels bigger than their cells
and then want numbers in adjacent cells to be
displayed properly; i.e. he might thus get something
like this :
A | B
Doug Harrison is a -9.0
rather than :
A | B
Doug Harri -9.0
This only apllies when the WHOLE window is redrawn;
DRAW_CELL does, if the cell is assigned, blank out
the cell first, and I think this is more
important, and it doesn't slow things down... }
set_style(ptr^.format);
k := ptr^.c-start_col+1;
CASE find_just(ptr) OF
VDI_Left : Draw_Just(vert_grid[k]+1,pts_in[row],
VDI_Left,temp);
VDI_Center : Draw_Just(vert_grid[k]+1+
col_width[ptr^.c,pixels] DIV 2,
pts_in[row],VDI_Center,temp);
VDI_Right : Draw_Just(vert_grid[k+1],pts_in[row],
VDI_Right,temp)
END; { CASE }
Text_Style(Normal)
END; { IF }
ptr := ptr^.next;
IF ptr <> NIL THEN
IF ptr^.c > col_end THEN
over := TRUE
END; { WHILE }
IF block_set THEN
IF (i >= b_s_row) AND (i <= b_e_row) THEN
FOR j := col_begin TO col_end DO
IF (j >= b_s_col) AND (j <= b_e_col) THEN
toggle_inverse(Black,i,j)
END; { FOR i }
{ so the output from this is such that ALL cells in a range are
highlighted }
draw_cell(data_row,data_col,FALSE);
1: END; (* DISPLAY_DATA *)
PROCEDURE SET_UP_CELL_NAME;
BEGIN
string_a_cell(data_row,data_col,col_row);
Set_Text(new_desk_ptr,editcell,col_row,s0,5)
END; { SET_UP_CELL_NAME }
PROCEDURE WRITE_CELL_NAME;
BEGIN
Set_Text(new_desk_ptr,editcell,' ',s0,5);
Hide_Mouse;
Obj_Draw(new_desk_ptr,editcell,Max_Depth,
0,0,screen_width,screen_height);
set_up_cell_name;
Obj_Draw(new_desk_ptr,editcell,Max_Depth,
0,0,screen_width,screen_height);
Show_Mouse
END; { WRITE_CELL_NAME }
PROCEDURE SHEET_REDRAW ( extent : ExtentType;
blit_flag : BOOLEAN;
direction : BlitDirection );
{ note that caller *MUST* call Begin_Update beforehand!!! }
VAR
v_slider_pos,h_slider_pos,
i,j,x,y,w,h,x2,y2,vert_pos : INTEGER;
PROCEDURE RESET_WINDOW;
BEGIN
def_sheet_area;
save_attr; { do it again in case we had to home cursor. }
{ Can't elimiate save_attr in def_sheet_area }
{ because other routines call it; i.e. }
{ MOVE_SHEET, and some of the column-movement }
{ routines }
IF (extent = WholeSheet) OR (extent = NoColNames) OR
((blit_flag) AND (direction > Right)) THEN BEGIN
v_slider_pos := TRUNC(1000.0*(start_row-1)/(n_rows-v_entry));
Wind_Set(act_hdl,WF_VSLSize,ROUND(1000.0*v_entry/n_rows),
0,0,0);
Wind_Set(act_hdl,WF_VSlide,v_slider_pos,0,0,0)
END;
IF (extent = WholeSheet) OR (extent = NoRowNames) OR
((blit_flag) AND (direction < Up)) THEN BEGIN
h_slider_pos := TRUNC(1000.0*(start_col-1)/(n_cols-h_entry));
Wind_Set(act_hdl,WF_HSLSize,ROUND(1000.0*h_entry/n_cols),
0,0,0);
Wind_Set(act_hdl,WF_HSlide,h_slider_pos,0,0,0)
END
END; (* RESET_WINDOW *)
PROCEDURE BLIT_LEFT;
BEGIN
IF o_s_col <= finish_col THEN BEGIN
x := x_1+x_margin+1;
w := w_1;
y := y_1;
h := h_1;
i := start_col;
j := 1;
WHILE i <= finish_col DO BEGIN
IF i = o_s_col THEN BEGIN
vert_pos := j;
i := 500
END
ELSE
i := i+1;
j := j+1
END;
x2 := vert_grid[vert_pos]+1;
y2 := y;
Blit(screen_mfdb,screen_mfdb,x,y,x2,y2,w,h);
Paint_Rect(x,y,x2-x,h_1);
draw_sheet(extent,1,virtual_v_entry,
1,o_s_col-start_col,TRUE);
display_data(NoRowNames,start_row,virtual_f_row,
start_col,o_s_col-1)
END
ELSE BEGIN
draw_sheet(extent,1,virtual_v_entry,1,virtual_h_entry,FALSE);
display_data(extent,start_row,virtual_f_row,
start_col,virtual_f_col)
END
END; { BLIT_LEFT }
PROCEDURE BLIT_RIGHT;
BEGIN
IF o_f_col >= start_col THEN BEGIN
i := o_s_col;
j := 1;
WHILE i <= o_f_col DO BEGIN
IF i = start_col THEN BEGIN
vert_pos := j;
i := 500
END
ELSE
i := i+1;
j := j+1
END;
x := old_vert_grid[vert_pos]+1;
y := y_1;
w := old_vert_grid[o_f_col-o_s_col+2]-old_vert_grid[vert_pos];
h := h_1;
x2 := x_1+x_margin+1;
y2 := y;
Blit(screen_mfdb,screen_mfdb,x,y,x2,y2,w,h);
Paint_Rect(x2+w,y,w_1,h_1);
draw_sheet(extent,1,virtual_v_entry,
h_entry-(finish_col-o_f_col)+1,
virtual_h_entry,TRUE);
display_data(NoRowNames,start_row,virtual_f_row,
o_f_col+1,virtual_f_col)
END
ELSE BEGIN
draw_sheet(extent,1,virtual_v_entry,1,virtual_h_entry,FALSE);
display_data(extent,start_row,virtual_f_row,
start_col,virtual_f_col)
END
END; { BLIT_RIGHT }
PROCEDURE BLIT_UP;
BEGIN
x := x_1;
y := y_1+y_margin+1;
w := w_1;
h := h_1;
x2 := x;
y2 := y+cell_height;
Blit(screen_mfdb,screen_mfdb,x,y,x2,y2,w,h);
Paint_Rect(x,y,w,cell_height-1);
draw_sheet(extent,1,1,1,virtual_h_entry,TRUE);
display_data(NoColNames,start_row,start_row,
start_col,virtual_f_col)
END; { BLIT_UP }
PROCEDURE BLIT_DOWN;
BEGIN
x := x_1;
y := y_1+y_margin+cell_height+1;
w := w_1;
h := cell_height*(v_entry-1)-1;
x2 := x;
y2 := y-cell_height;
Blit(screen_mfdb,screen_mfdb,x,y,x2,y2,w,h);
Paint_Rect(x,y2+h+1,w_1,h_1);
draw_sheet(extent,v_entry,virtual_v_entry,1,virtual_h_entry,TRUE);
display_data(NoColNames,finish_row,virtual_f_row,
start_col,virtual_f_col)
END; { BLIT_DOWN }
BEGIN { SHEET_REDRAW }
Hide_Mouse;
reset_window;
IF NOT blit_flag THEN BEGIN
draw_sheet(extent,1,virtual_v_entry,1,virtual_h_entry,FALSE);
display_data(extent,start_row,virtual_f_row,
start_col,virtual_f_col)
END
ELSE BEGIN
Set_Clip(x_1,y_1,w_1,h_1); {current because of Work_Rect}
CASE direction OF {in def_sheet_area}
Left : blit_left;
Right : blit_right;
Up : blit_up;
Down : blit_down
END
END;
Show_Mouse;
IF Front_Window = act_hdl THEN
write_cell_name
END; { SHEET_REDRAW }
BEGIN
END.