ref: f4f19cdf1a8f0d2aa5f9fce10c896201528b5347
dir: /sys/src/cmd/aux/antiword/draw.c/
/*
* draw.c
* Copyright (C) 1998-2005 A.J. van Os; Released under GPL
*
* Description:
* Functions to deal with the Draw format
*/
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include "DeskLib:KeyCodes.h"
#include "DeskLib:Error.h"
#include "DeskLib:Menu.h"
#include "DeskLib:Template.h"
#include "DeskLib:Window.h"
#include "DeskLib:EventMsg.h"
#include "flexlib:flex.h"
#include "drawfile.h"
#include "antiword.h"
/* The work area must be a little bit larger than the diagram */
#define WORKAREA_EXTENSION 5
/* Diagram memory */
#define INITIAL_SIZE 32768 /* 32k */
#define EXTENSION_SIZE 4096 /* 4k */
/* Main window title */
#define WINDOW_TITLE_LEN 28
#define FILENAME_TITLE_LEN (WINDOW_TITLE_LEN - 10)
#if !defined(__GNUC__)
int
flex_alloc(flex_ptr anchor, int n)
{
void *pvTmp;
TRACE_MSG("flex_alloc");
if (anchor == NULL || n < 0) {
return 0;
}
if (n == 0) {
n = 1;
}
pvTmp = malloc(n);
if (pvTmp == NULL) {
return 0;
}
*anchor = pvTmp;
return 1;
} /* end of flex_alloc */
void
flex_free(flex_ptr anchor)
{
TRACE_MSG("flex_free");
if (anchor == NULL || *anchor == NULL) {
return;
}
free(*anchor);
*anchor = NULL;
} /* end of flex_free */
int
flex_extend(flex_ptr anchor, int newsize)
{
void *pvTmp;
TRACE_MSG("flex_extend");
if (anchor == NULL || newsize < 0) {
return 0;
}
if (newsize == 0) {
newsize = 1;
}
pvTmp = realloc(*anchor, newsize);
if (pvTmp == NULL) {
return 0;
}
*anchor = pvTmp;
return 1;
} /* end of flex_extend */
#endif /* !__GNUC__ */
/*
* vCreateMainWindow - create the Main window
*
* remark: does not return if the Main window can't be created
*/
static window_handle
tCreateMainWindow(void)
{
window_handle tMainWindow;
TRACE_MSG("tCreateMainWindow");
tMainWindow = Window_Create("MainWindow", template_TITLEMIN);
if (tMainWindow == 0) {
werr(1, "I can't find the 'MainWindow' template");
}
return tMainWindow;
} /* end of tCreateMainWindow */
/*
* vCreateScaleWindow - create the Scale view window
*
* remark: does not return if the Scale view window can't be created
*/
static window_handle
tCreateScaleWindow(void)
{
window_handle tScaleWindow;
TRACE_MSG("tCreateScaleWindow");
tScaleWindow = Window_Create("ScaleView", template_TITLEMIN);
if (tScaleWindow == 0) {
werr(1, "I can't find the 'ScaleView' template");
}
return tScaleWindow;
} /* end of tCreateScaleWindow */
/*
* pCreateDiagram - create and initialize a diagram
*
* remark: does not return if the diagram can't be created
*/
diagram_type *
pCreateDiagram(const char *szTask, const char *szFilename)
{
diagram_type *pDiag;
options_type tOptions;
window_handle tMainWindow, tScaleWindow;
wimp_box tBox;
TRACE_MSG("pCreateDiagram");
fail(szTask == NULL || szTask[0] == '\0');
/* Create the main window */
tMainWindow = tCreateMainWindow();
/* Create the scale view window */
tScaleWindow = tCreateScaleWindow();
/* Get the necessary memory */
pDiag = xmalloc(sizeof(diagram_type));
if (flex_alloc((flex_ptr)&pDiag->tInfo.data, INITIAL_SIZE) != 1) {
werr(1, "Memory allocation failed, unable to continue");
}
/* Initialize the diagram */
vGetOptions(&tOptions);
pDiag->tMainWindow = tMainWindow;
pDiag->tScaleWindow = tScaleWindow;
pDiag->iScaleFactorCurr = tOptions.iScaleFactor;
pDiag->iScaleFactorTemp = tOptions.iScaleFactor;
pDiag->tMemorySize = INITIAL_SIZE;
tBox.min.x = 0;
tBox.min.y = -(Drawfile_ScreenToDraw(32 + 3) * 8 + 1);
tBox.max.x = Drawfile_ScreenToDraw(16) * MIN_SCREEN_WIDTH + 1;
tBox.max.y = 0;
Error_CheckFatal(Drawfile_CreateDiagram(&pDiag->tInfo,
pDiag->tMemorySize, szTask, tBox));
DBG_DEC(pDiag->tInfo.length);
pDiag->lXleft = 0;
pDiag->lYtop = 0;
strncpy(pDiag->szFilename,
szBasename(szFilename), sizeof(pDiag->szFilename) - 1);
pDiag->szFilename[sizeof(pDiag->szFilename) - 1] = '\0';
/* Return success */
return pDiag;
} /* end of pCreateDiagram */
/*
* bDestroyDiagram - remove a diagram by freeing the memory it uses
*/
BOOL
bDestroyDiagram(event_pollblock *pEvent, void *pvReference)
{
diagram_type *pDiag;
window_handle tWindow;
TRACE_MSG("bDestroyDiagram");
fail(pEvent == NULL);
fail(pvReference == NULL);
if (pEvent == NULL || pvReference == NULL) {
return FALSE;
}
pDiag = (diagram_type *)pvReference;
switch (pEvent->type) {
case event_CLOSE:
tWindow = pEvent->data.openblock.window;
break;
case event_KEY:
tWindow = pEvent->data.key.caret.window;
break;
default:
DBG_DEC(pEvent->type);
return FALSE;
}
if (tWindow != pDiag->tMainWindow) {
return FALSE;
}
/* Delete the main window */
Window_Delete(pDiag->tMainWindow);
pDiag->tMainWindow = 0;
/* Delete the scale window */
Window_Delete(pDiag->tScaleWindow);
pDiag->tScaleWindow = 0;
#if defined(__GNUC__)
/*
* Remove all references to the diagram that will be free-ed
* by undoing the EventMsg_Claim's from within the Menu_Warn's
*/
while (EventMsg_ReleaseSpecific(message_MENUWARNING, window_ANY,
bSaveTextfile, pDiag))
; /* EMPTY */
while (EventMsg_ReleaseSpecific(message_MENUWARNING, window_ANY,
bSaveDrawfile, pDiag))
; /* EMPTY */
while (EventMsg_ReleaseSpecific(message_MENUWARNING, window_ANY,
bScaleOpenAction, pDiag))
; /* EMPTY */
#endif /* __GNUC__ */
/* Free the memory */
if (pDiag->tInfo.data != NULL && pDiag->tMemorySize != 0) {
flex_free((flex_ptr)&pDiag->tInfo.data);
}
/* Just to be on the save side */
pDiag->tInfo.data = NULL;
pDiag->tInfo.length = 0;
pDiag->tMemorySize = 0;
/* Destroy the diagram itself */
pDiag = xfree(pDiag);
return TRUE;
} /* end of bDestroyDiagram */
/*
* vExtendDiagramSize - make sure the diagram is big enough
*/
static void
vExtendDiagramSize(diagram_type *pDiag, size_t tSize)
{
TRACE_MSG("vExtendDiagramSize");
fail(pDiag == NULL || tSize % 4 != 0);
while (pDiag->tInfo.length + tSize > pDiag->tMemorySize) {
if (flex_extend((flex_ptr)&pDiag->tInfo.data,
pDiag->tMemorySize + EXTENSION_SIZE) != 1) {
werr(1, "Memory extend failed, unable to continue");
}
pDiag->tMemorySize += EXTENSION_SIZE;
NO_DBG_DEC(pDiag->tMemorySize);
}
TRACE_MSG("end of vExtendDiagramSize");
} /* end of vExtendDiagramSize */
/*
* vPrologue2 - prologue part 2; add a font list to a diagram
*/
void
vPrologue2(diagram_type *pDiag, int iWordVersion)
{
drawfile_object *pNew;
const font_table_type *pTmp;
char *pcTmp;
size_t tRealSize, tSize;
int iCount;
TRACE_MSG("vPrologue2");
fail(pDiag == NULL);
if (tGetFontTableLength() == 0) {
return;
}
tRealSize = offsetof(drawfile_object, data);
pTmp = NULL;
while ((pTmp = pGetNextFontTableRecord(pTmp)) != NULL) {
tRealSize += 2 + strlen(pTmp->szOurFontname);
}
DBG_DEC(tRealSize);
tSize = ROUND4(tRealSize);
vExtendDiagramSize(pDiag, tSize);
pNew = xmalloc(tSize);
memset(pNew, 0, tSize);
pNew->type = drawfile_TYPE_FONT_TABLE;
pNew->size = tSize;
pcTmp = (char *)&pNew->data.font_table.font_def[0].font_ref;
iCount = 0;
pTmp = NULL;
while ((pTmp = pGetNextFontTableRecord(pTmp)) != NULL) {
*pcTmp = ++iCount;
pcTmp++;
strcpy(pcTmp, pTmp->szOurFontname);
pcTmp += 1 + strlen(pTmp->szOurFontname);
}
Error_CheckFatal(Drawfile_AppendObject(&pDiag->tInfo,
pDiag->tMemorySize, pNew, TRUE));
pNew = xfree(pNew);
} /* end of vPrologue2 */
/*
* vSubstring2Diagram - put a sub string into a diagram
*/
void
vSubstring2Diagram(diagram_type *pDiag,
char *szString, size_t tStringLength, long lStringWidth,
UCHAR ucFontColor, USHORT usFontstyle, drawfile_fontref tFontRef,
USHORT usFontSize, USHORT usMaxFontSize)
{
drawfile_object *pNew;
long lSizeX, lSizeY, lOffset, l20, lYMove;
size_t tRealSize, tSize;
TRACE_MSG("vSubstring2Diagram");
fail(pDiag == NULL || szString == NULL);
fail(pDiag->lXleft < 0);
fail(tStringLength != strlen(szString));
fail(usFontSize < MIN_FONT_SIZE || usFontSize > MAX_FONT_SIZE);
fail(usMaxFontSize < MIN_FONT_SIZE || usMaxFontSize > MAX_FONT_SIZE);
fail(usFontSize > usMaxFontSize);
if (szString[0] == '\0' || tStringLength == 0) {
return;
}
if (tFontRef == 0) {
lOffset = Drawfile_ScreenToDraw(2);
l20 = Drawfile_ScreenToDraw(32 + 3);
lSizeX = Drawfile_ScreenToDraw(16);
lSizeY = Drawfile_ScreenToDraw(32);
} else {
lOffset = lToBaseLine(usMaxFontSize);
l20 = lWord2DrawUnits20(usMaxFontSize);
lSizeX = lWord2DrawUnits00(usFontSize);
lSizeY = lWord2DrawUnits00(usFontSize);
}
lYMove = 0;
/* Up for superscript */
if (bIsSuperscript(usFontstyle)) {
lYMove = lMilliPoints2DrawUnits((((long)usFontSize + 1) / 2) * 375);
}
/* Down for subscript */
if (bIsSubscript(usFontstyle)) {
lYMove = -lMilliPoints2DrawUnits((long)usFontSize * 125);
}
tRealSize = offsetof(drawfile_object, data);
tRealSize += sizeof(drawfile_text) + tStringLength;
tSize = ROUND4(tRealSize);
vExtendDiagramSize(pDiag, tSize);
pNew = xmalloc(tSize);
memset(pNew, 0, tSize);
pNew->type = drawfile_TYPE_TEXT;
pNew->size = tSize;
pNew->data.text.bbox.min.x = (int)pDiag->lXleft;
pNew->data.text.bbox.min.y = (int)(pDiag->lYtop + lYMove);
pNew->data.text.bbox.max.x = (int)(pDiag->lXleft + lStringWidth);
pNew->data.text.bbox.max.y = (int)(pDiag->lYtop + l20 + lYMove);
pNew->data.text.fill.value = (int)ulColor2Color(ucFontColor);
pNew->data.text.bg_hint.value = 0xffffff00; /* White */
pNew->data.text.style.font_ref = tFontRef;
pNew->data.text.style.reserved[0] = 0;
pNew->data.text.style.reserved[1] = 0;
pNew->data.text.style.reserved[2] = 0;
pNew->data.text.xsize = (int)lSizeX;
pNew->data.text.ysize = (int)lSizeY;
pNew->data.text.base.x = (int)pDiag->lXleft;
pNew->data.text.base.y = (int)(pDiag->lYtop + lOffset + lYMove);
strncpy(pNew->data.text.text, szString, tStringLength);
pNew->data.text.text[tStringLength] = '\0';
Error_CheckFatal(Drawfile_AppendObject(&pDiag->tInfo,
pDiag->tMemorySize, pNew, TRUE));
pNew = xfree(pNew);
/*draw_translateText(&pDiag->tInfo);*/
pDiag->lXleft += lStringWidth;
TRACE_MSG("leaving vSubstring2Diagram");
} /* end of vSubstring2Diagram */
/*
* vImage2Diagram - put an image into a diagram
*/
void
vImage2Diagram(diagram_type *pDiag, const imagedata_type *pImg,
UCHAR *pucImage, size_t tImageSize)
{
drawfile_object *pNew;
long lWidth, lHeight;
size_t tRealSize, tSize;
TRACE_MSG("vImage2Diagram");
fail(pDiag == NULL);
fail(pImg == NULL);
fail(pDiag->lXleft < 0);
fail(pImg->eImageType != imagetype_is_dib &&
pImg->eImageType != imagetype_is_jpeg);
DBG_DEC_C(pDiag->lXleft != 0, pDiag->lXleft);
lWidth = lPoints2DrawUnits(pImg->iHorSizeScaled);
lHeight = lPoints2DrawUnits(pImg->iVerSizeScaled);
DBG_DEC(lWidth);
DBG_DEC(lHeight);
pDiag->lYtop -= lHeight;
tRealSize = offsetof(drawfile_object, data);
switch (pImg->eImageType) {
case imagetype_is_dib:
tRealSize += sizeof(drawfile_sprite) + tImageSize;
tSize = ROUND4(tRealSize);
vExtendDiagramSize(pDiag, tSize);
pNew = xmalloc(tSize);
memset(pNew, 0, tSize);
pNew->type = drawfile_TYPE_SPRITE;
pNew->size = tSize;
pNew->data.sprite.bbox.min.x = (int)pDiag->lXleft;
pNew->data.sprite.bbox.min.y = (int)pDiag->lYtop;
pNew->data.sprite.bbox.max.x = (int)(pDiag->lXleft + lWidth);
pNew->data.sprite.bbox.max.y = (int)(pDiag->lYtop + lHeight);
memcpy(&pNew->data.sprite.header, pucImage, tImageSize);
break;
case imagetype_is_jpeg:
#if defined(DEBUG)
(void)bGetJpegInfo(pucImage, tImageSize);
#endif /* DEBUG */
tRealSize += sizeof(drawfile_jpeg) + tImageSize;
tSize = ROUND4(tRealSize);
vExtendDiagramSize(pDiag, tSize);
pNew = xmalloc(tSize);
memset(pNew, 0, tSize);
pNew->type = drawfile_TYPE_JPEG;
pNew->size = tSize;
pNew->data.jpeg.bbox.min.x = (int)pDiag->lXleft;
pNew->data.jpeg.bbox.min.y = (int)pDiag->lYtop;
pNew->data.jpeg.bbox.max.x = (int)(pDiag->lXleft + lWidth);
pNew->data.jpeg.bbox.max.y = (int)(pDiag->lYtop + lHeight);
pNew->data.jpeg.width = (int)lWidth;
pNew->data.jpeg.height = (int)lHeight;
pNew->data.jpeg.xdpi = 90;
pNew->data.jpeg.ydpi = 90;
pNew->data.jpeg.trfm.entries[0][0] = 0x10000;
pNew->data.jpeg.trfm.entries[0][1] = 0;
pNew->data.jpeg.trfm.entries[1][0] = 0;
pNew->data.jpeg.trfm.entries[1][1] = 0x10000;
pNew->data.jpeg.trfm.entries[2][0] = (int)pDiag->lXleft;
pNew->data.jpeg.trfm.entries[2][1] = (int)pDiag->lYtop;
pNew->data.jpeg.len = tImageSize;
memcpy(pNew->data.jpeg.data, pucImage, tImageSize);
break;
default:
DBG_DEC(pImg->eImageType);
pNew = NULL;
break;
}
Error_CheckFatal(Drawfile_AppendObject(&pDiag->tInfo,
pDiag->tMemorySize, pNew, TRUE));
pNew = xfree(pNew);
pDiag->lXleft = 0;
} /* end of vImage2Diagram */
/*
* bAddDummyImage - add a dummy image
*
* return TRUE when successful, otherwise FALSE
*/
BOOL
bAddDummyImage(diagram_type *pDiag, const imagedata_type *pImg)
{
drawfile_object *pNew;
int *piTmp;
long lWidth, lHeight;
size_t tRealSize, tSize;
TRACE_MSG("bAddDummyImage");
fail(pDiag == NULL);
fail(pImg == NULL);
fail(pDiag->lXleft < 0);
if (pImg->iVerSizeScaled <= 0 || pImg->iHorSizeScaled <= 0) {
return FALSE;
}
DBG_DEC_C(pDiag->lXleft != 0, pDiag->lXleft);
lWidth = lPoints2DrawUnits(pImg->iHorSizeScaled);
lHeight = lPoints2DrawUnits(pImg->iVerSizeScaled);
pDiag->lYtop -= lHeight;
tRealSize = offsetof(drawfile_object, data);
tRealSize += sizeof(drawfile_path) + (14 - 1) * sizeof(int);
tSize = ROUND4(tRealSize);
vExtendDiagramSize(pDiag, tSize);
pNew = xmalloc(tSize);
memset(pNew, 0, tSize);
pNew->type = drawfile_TYPE_PATH;
pNew->size = tSize;
pNew->data.path.bbox.min.x = (int)pDiag->lXleft;
pNew->data.path.bbox.min.y = (int)pDiag->lYtop;
pNew->data.path.bbox.max.x = (int)(pDiag->lXleft + lWidth);
pNew->data.path.bbox.max.y = (int)(pDiag->lYtop + lHeight);
pNew->data.path.fill.value = -1;
pNew->data.path.outline.value = 0x4d4d4d00; /* Gray 70 percent */
pNew->data.path.width = (int)lMilliPoints2DrawUnits(500);
pNew->data.path.style.flags = 0;
pNew->data.path.style.reserved = 0;
pNew->data.path.style.cap_width = 0;
pNew->data.path.style.cap_length = 0;
piTmp = pNew->data.path.path;
*piTmp++ = drawfile_PATH_MOVE_TO;
*piTmp++ = pNew->data.path.bbox.min.x;
*piTmp++ = pNew->data.path.bbox.min.y;
*piTmp++ = drawfile_PATH_LINE_TO;
*piTmp++ = pNew->data.path.bbox.min.x;
*piTmp++ = pNew->data.path.bbox.max.y;
*piTmp++ = drawfile_PATH_LINE_TO;
*piTmp++ = pNew->data.path.bbox.max.x;
*piTmp++ = pNew->data.path.bbox.max.y;
*piTmp++ = drawfile_PATH_LINE_TO;
*piTmp++ = pNew->data.path.bbox.max.x;
*piTmp++ = pNew->data.path.bbox.min.y;
*piTmp++ = drawfile_PATH_CLOSE_LINE;
*piTmp++ = drawfile_PATH_END_PATH;
Error_CheckFatal(Drawfile_AppendObject(&pDiag->tInfo,
pDiag->tMemorySize, pNew, TRUE));
pNew = xfree(pNew);
pDiag->lXleft = 0;
return TRUE;
} /* end of bAddDummyImage */
/*
* vMove2NextLine - move to the next line
*/
void
vMove2NextLine(diagram_type *pDiag, drawfile_fontref tFontRef,
USHORT usFontSize)
{
long l20;
TRACE_MSG("vMove2NextLine");
fail(pDiag == NULL);
fail(usFontSize < MIN_FONT_SIZE || usFontSize > MAX_FONT_SIZE);
if (tFontRef == 0) {
l20 = Drawfile_ScreenToDraw(32 + 3);
} else {
l20 = lWord2DrawUnits20(usFontSize);
}
pDiag->lYtop -= l20;
} /* end of vMove2NextLine */
/*
* Create an start of paragraph (Phase 1)
*/
void
vStartOfParagraph1(diagram_type *pDiag, long lBeforeIndentation)
{
TRACE_MSG("vStartOfParagraph1");
fail(pDiag == NULL);
fail(lBeforeIndentation < 0);
pDiag->lXleft = 0;
pDiag->lYtop -= lMilliPoints2DrawUnits(lBeforeIndentation);
} /* end of vStartOfParagraph1 */
/*
* Create an start of paragraph (Phase 2)
* DUMMY function
*/
void
vStartOfParagraph2(diagram_type *pDiag)
{
TRACE_MSG("vStartOfParagraph2");
} /* end of vStartOfParagraph2 */
/*
* Create an end of paragraph
*/
void
vEndOfParagraph(diagram_type *pDiag,
drawfile_fontref tFontRef, USHORT usFontSize, long lAfterIndentation)
{
TRACE_MSG("vEndOfParagraph");
fail(pDiag == NULL);
fail(usFontSize < MIN_FONT_SIZE || usFontSize > MAX_FONT_SIZE);
fail(lAfterIndentation < 0);
pDiag->lXleft = 0;
pDiag->lYtop -= lMilliPoints2DrawUnits(lAfterIndentation);
} /* end of vEndOfParagraph */
/*
* Create an end of page
*/
void
vEndOfPage(diagram_type *pDiag, long lAfterIndentation, BOOL bNewSection)
{
TRACE_MSG("vEndOfPage");
fail(pDiag == NULL);
fail(lAfterIndentation < 0);
pDiag->lXleft = 0;
pDiag->lYtop -= lMilliPoints2DrawUnits(lAfterIndentation);
} /* end of vEndOfPage */
/*
* vSetHeaders - set the headers
* DUMMY function
*/
void
vSetHeaders(diagram_type *pDiag, USHORT usIstd)
{
TRACE_MSG("vSetHeaders");
} /* end of vSetHeaders */
/*
* Create a start of list
* DUMMY function
*/
void
vStartOfList(diagram_type *pDiag, UCHAR ucNFC, BOOL bIsEndOfTable)
{
TRACE_MSG("vStartOfList");
} /* end of vStartOfList */
/*
* Create an end of list
* DUMMY function
*/
void
vEndOfList(diagram_type *pDiag)
{
TRACE_MSG("vEndOfList");
} /* end of vEndOfList */
/*
* Create a start of a list item
* DUMMY function
*/
void
vStartOfListItem(diagram_type *pDiag, BOOL bNoMarks)
{
TRACE_MSG("vStartOfListItem");
} /* end of vStartOfListItem */
/*
* Create an end of a table
* DUMMY function
*/
void
vEndOfTable(diagram_type *pDiag)
{
TRACE_MSG("vEndOfTable");
} /* end of vEndTable */
/*
* Add a table row
* DUMMY function
*
* Returns TRUE when conversion type is XML
*/
BOOL
bAddTableRow(diagram_type *pDiag, char **aszColTxt,
int iNbrOfColumns, const short *asColumnWidth, UCHAR ucBorderInfo)
{
TRACE_MSG("bAddTableRow");
return FALSE;
} /* end of bAddTableRow */
/*
* vForceRedraw - force a redraw of the main window
*/
static void
vForceRedraw(diagram_type *pDiag)
{
window_state tWindowState;
window_redrawblock tRedraw;
int x0, y0, x1, y1;
TRACE_MSG("vForceRedraw");
fail(pDiag == NULL);
DBG_DEC(pDiag->iScaleFactorCurr);
/* Read the size of the current diagram */
Drawfile_QueryBox(&pDiag->tInfo, &tRedraw.rect, TRUE);
/* Adjust the size of the work area */
x0 = tRedraw.rect.min.x * pDiag->iScaleFactorCurr / 100 - 1;
y0 = tRedraw.rect.min.y * pDiag->iScaleFactorCurr / 100 - 1;
x1 = tRedraw.rect.max.x * pDiag->iScaleFactorCurr / 100 + 1;
y1 = tRedraw.rect.max.y * pDiag->iScaleFactorCurr / 100 + 1;
/* Work area extension */
x0 -= WORKAREA_EXTENSION;
y0 -= WORKAREA_EXTENSION;
x1 += WORKAREA_EXTENSION;
y1 += WORKAREA_EXTENSION;
Window_SetExtent(pDiag->tMainWindow, x0, y0, x1, y1);
/* Widen the box slightly to be sure all the edges are drawn */
x0 -= 5;
y0 -= 5;
x1 += 5;
y1 += 5;
/* Force the redraw */
Window_ForceRedraw(pDiag->tMainWindow, x0, y0, x1, y1);
/* Reopen the window to show the correct size */
Error_CheckFatal(Wimp_GetWindowState(pDiag->tMainWindow, &tWindowState));
tWindowState.openblock.behind = -1;
Error_CheckFatal(Wimp_OpenWindow(&tWindowState.openblock));
} /* end of vForceRedraw */
/*
* vShowDiagram - put the diagram on the screen
*/
void
vShowDiagram(diagram_type *pDiag)
{
wimp_box tRect;
int x0, y0, x1, y1;
TRACE_MSG("vShowDiagram");
fail(pDiag == NULL);
Window_Show(pDiag->tMainWindow, open_NEARLAST);
Drawfile_QueryBox(&pDiag->tInfo, &tRect, TRUE);
/* Work area extension */
x0 = tRect.min.x - WORKAREA_EXTENSION;
y0 = tRect.min.y - WORKAREA_EXTENSION;
x1 = tRect.max.x + WORKAREA_EXTENSION;
y1 = tRect.max.y + WORKAREA_EXTENSION;
Window_SetExtent(pDiag->tMainWindow, x0, y0, x1, y1);
vForceRedraw(pDiag);
} /* end of vShowDiagram */
/*
* vMainButtonClick - handle mouse buttons clicks for the main screen
*/
void
vMainButtonClick(mouse_block *pMouse)
{
caret_block tCaret;
window_state ws;
TRACE_MSG("vMainButtonClick");
fail(pMouse == NULL);
DBG_DEC(pMouse->button.data.select);
DBG_DEC(pMouse->button.data.adjust);
DBG_DEC(pMouse->window);
DBG_DEC(pMouse->icon);
if (pMouse->window >= 0 &&
pMouse->icon == -1 &&
(pMouse->button.data.select || pMouse->button.data.adjust)) {
/* Get the input focus */
Error_CheckFatal(Wimp_GetWindowState(pMouse->window, &ws));
tCaret.window = pMouse->window;
tCaret.icon = -1;
tCaret.offset.x = pMouse->pos.x - ws.openblock.screenrect.min.x;
tCaret.offset.y = pMouse->pos.y - ws.openblock.screenrect.max.y;
tCaret.height = (int)BIT(25);
tCaret.index = 0;
Error_CheckFatal(Wimp_SetCaretPosition(&tCaret));
}
} /* end of vMainButtonClick */
/*
* bMainKeyPressed - handle pressed keys for the main window
*/
BOOL
bMainKeyPressed(event_pollblock *pEvent, void *pvReference)
{
diagram_type *pDiag;
TRACE_MSG("bMainKeyPressed");
fail(pEvent == NULL);
fail(pEvent->type != event_KEY);
fail(pvReference == NULL);
pDiag = (diagram_type *)pvReference;
fail(pEvent->data.key.caret.window != pDiag->tMainWindow);
switch (pEvent->data.key.code) {
case keycode_CTRL_F2: /* Ctrl F2 */
bDestroyDiagram(pEvent, pvReference);
break;
case keycode_F3: /* F3 */
bSaveDrawfile(pEvent, pvReference);
break;
case keycode_SHIFT_F3: /* Shift F3 */
bSaveTextfile(pEvent, pvReference);
break;
default:
DBG_DEC(pEvent->data.key.code);
Error_CheckFatal(Wimp_ProcessKey(pEvent->data.key.code));
}
return TRUE;
} /* end of bMainKeyPressed */
/*
* bRedrawMainWindow - redraw the main window
*/
BOOL
bRedrawMainWindow(event_pollblock *pEvent, void *pvReference)
{
window_redrawblock tBlock;
diagram_type *pDiag;
drawfile_info *pInfo;
double dScaleFactor;
BOOL bMore;
TRACE_MSG("bRedrawMainWindow");
fail(pEvent == NULL);
fail(pEvent->type != event_REDRAW);
fail(pvReference == NULL);
pDiag = (diagram_type *)pvReference;
fail(pDiag->tMainWindow != pEvent->data.openblock.window);
fail(pDiag->iScaleFactorCurr < MIN_SCALE_FACTOR);
fail(pDiag->iScaleFactorCurr > MAX_SCALE_FACTOR);
dScaleFactor = (double)pDiag->iScaleFactorCurr / 100.0;
pInfo = &pDiag->tInfo;
tBlock.window = pEvent->data.openblock.window;
Error_CheckFatal(Wimp_RedrawWindow(&tBlock, &bMore));
/* If there is no real diagram just go thru the motions */
while (bMore) {
if (pInfo->data != NULL && pInfo->length != 0) {
Error_CheckFatal(Drawfile_RenderDiagram(pInfo,
&tBlock, dScaleFactor));
}
Error_CheckFatal(Wimp_GetRectangle(&tBlock, &bMore));
}
return TRUE;
} /* end of bRedrawMainWindow */
/*
* bScaleOpenAction - action to be taken when the Scale view window opens
*/
BOOL
bScaleOpenAction(event_pollblock *pEvent, void *pvReference)
{
window_state tWindowState;
diagram_type *pDiag;
TRACE_MSG("bScaleOpenAction");
fail(pEvent == NULL);
fail(pEvent->type != event_SEND);
fail(pEvent->data.message.header.action != message_MENUWARN);
fail(pvReference == NULL);
pDiag = (diagram_type *)pvReference;
if (menu_currentopen != pDiag->pSaveMenu ||
pEvent->data.message.data.menuwarn.selection[0] != SAVEMENU_SCALEVIEW) {
return FALSE;
}
Error_CheckFatal(Wimp_GetWindowState(pDiag->tScaleWindow,
&tWindowState));
if (tWindowState.flags.data.open) {
/* The window is already open */
return TRUE;
}
DBG_MSG("vScaleOpenAction for real");
pDiag->iScaleFactorTemp = pDiag->iScaleFactorCurr;
vUpdateWriteableNumber(pDiag->tScaleWindow,
SCALE_SCALE_WRITEABLE, pDiag->iScaleFactorTemp);
Window_Show(pDiag->tScaleWindow, open_UNDERPOINTER);
return TRUE;
} /* end of bScaleOpenAction */
/*
* vSetTitle - set the title of a window
*/
void
vSetTitle(diagram_type *pDiag)
{
char szTitle[WINDOW_TITLE_LEN];
TRACE_MSG("vSetTitle");
fail(pDiag == NULL);
fail(pDiag->szFilename[0] == '\0');
(void)sprintf(szTitle, "%.*s at %d%%",
FILENAME_TITLE_LEN,
pDiag->szFilename,
pDiag->iScaleFactorCurr % 1000);
if (strlen(pDiag->szFilename) > FILENAME_TITLE_LEN) {
szTitle[FILENAME_TITLE_LEN - 1] = OUR_ELLIPSIS;
}
Window_SetTitle(pDiag->tMainWindow, szTitle);
} /* end of vSetTitle */
/*
* vScaleButtonClick - handle a mouse button click in the Scale view window
*/
void
vScaleButtonClick(mouse_block *pMouse, diagram_type *pDiag)
{
BOOL bCloseWindow, bRedraw;
TRACE_MSG("vScaleButtonClick");
fail(pMouse == NULL || pDiag == NULL);
fail(pMouse->window != pDiag->tScaleWindow);
bCloseWindow = FALSE;
bRedraw = FALSE;
switch (pMouse->icon) {
case SCALE_CANCEL_BUTTON:
bCloseWindow = TRUE;
pDiag->iScaleFactorTemp = pDiag->iScaleFactorCurr;
break;
case SCALE_SCALE_BUTTON:
bCloseWindow = TRUE;
bRedraw = pDiag->iScaleFactorCurr != pDiag->iScaleFactorTemp;
pDiag->iScaleFactorCurr = pDiag->iScaleFactorTemp;
break;
case SCALE_50_PCT:
pDiag->iScaleFactorTemp = 50;
break;
case SCALE_75_PCT:
pDiag->iScaleFactorTemp = 75;
break;
case SCALE_100_PCT:
pDiag->iScaleFactorTemp = 100;
break;
case SCALE_150_PCT:
pDiag->iScaleFactorTemp = 150;
break;
default:
DBG_DEC(pMouse->icon);
break;
}
if (bCloseWindow) {
/* Close the scale window */
Error_CheckFatal(Wimp_CloseWindow(pMouse->window));
if (bRedraw) {
/* Redraw the main window */
vSetTitle(pDiag);
vForceRedraw(pDiag);
}
} else {
vUpdateWriteableNumber(pMouse->window,
SCALE_SCALE_WRITEABLE,
pDiag->iScaleFactorTemp);
}
} /* end of vScaleButtonClick */
/*
* bScaleKeyPressed - handle pressed keys for the scale window
*/
BOOL
bScaleKeyPressed(event_pollblock *pEvent, void *pvReference)
{
icon_block tIcon;
diagram_type *pDiag;
caret_block *pCaret;
char *pcChar;
int iTmp;
TRACE_MSG("bScaleKeyPressed");
fail(pEvent == NULL);
fail(pEvent->type != event_KEY);
fail(pvReference == NULL);
pCaret = &pEvent->data.key.caret;
pDiag = (diagram_type *)pvReference;
fail(pEvent->data.key.caret.window != pDiag->tScaleWindow);
DBG_DEC_C(pCaret->icon != SCALE_SCALE_WRITEABLE, pCaret->icon);
DBG_DEC_C(pCaret->icon == SCALE_SCALE_WRITEABLE, pEvent->data.key.code);
if (pEvent->data.key.code != '\r' ||
pCaret->icon != SCALE_SCALE_WRITEABLE) {
Error_CheckFatal(Wimp_ProcessKey(pEvent->data.key.code));
return TRUE;
}
Error_CheckFatal(Wimp_GetIconState(pCaret->window, pCaret->icon, &tIcon));
if (!tIcon.flags.data.text || !tIcon.flags.data.indirected) {
werr(1, "Icon %d must be indirected text", (int)pCaret->icon);
}
iTmp = (int)strtol(tIcon.data.indirecttext.buffer, &pcChar, 10);
if (*pcChar != '\0' && *pcChar != '\r') {
DBG_DEC(*pcChar);
} else if (iTmp < MIN_SCALE_FACTOR) {
pDiag->iScaleFactorTemp = MIN_SCALE_FACTOR;
} else if (iTmp > MAX_SCALE_FACTOR) {
pDiag->iScaleFactorTemp = MAX_SCALE_FACTOR;
} else {
pDiag->iScaleFactorTemp = iTmp;
}
pDiag->iScaleFactorCurr = pDiag->iScaleFactorTemp;
/* Close the scale window */
Error_CheckFatal(Wimp_CloseWindow(pCaret->window));
/* Redraw the main window */
vSetTitle(pDiag);
vForceRedraw(pDiag);
return TRUE;
} /* end of bScaleKeyPressed */