www.c

web browser

#include <windows.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdarg.h>
#include "lib.h"
#include "scroll.h"
#include "wwwrc.h"
#include "WWWLib.h"
#include "HTReqMan.h"
#include "../HTBrowse.h"

#define VERSIONSTR "v0.1 beta"	//update this version for each release

// monitor size
#define MAXROWS         25
#define MAXCOLS         80

struct _HTView {
	HWND hWnd;
	char * name;
	ScrollInfo_t *  pScrollInfo;
	FontInfo_t *  pFontInfo;
	int rows;
	int cols;
	LineMode * pLm;
};

char WWWClassName[] = "WWWClass";
char VersionText[] = "WWW.EXE "VERSIONSTR".";

HINSTANCE HInstance;

HTView * PMonitorView = 0;
HTView * PDataView = 0;

extern HTRequest * LineMode_getConsole(LineMode * pLm);

typedef struct {	/* default */
    int zeroPad;	/* 0 */
    int leftJustify;	/* 0 */
    int showSign;	/* 0 */
    int width;		/* -1 */
    int precision;	/* -1 */
    char size;		/* 0 */
    int iArgs;		/* 0 */
} Crack_format_t;	/* = -2 */

#define Crack_format_INIT {0, 0, 0, -1, -1, 0, 0}

typedef struct {
    int freeMe;
    char * ptr;
    int ptrLen;
    int index;
    char terminate;
    Crack_format_t format;
} Crack_t;

#define Crack_INIT {0, 0, 0, 0, 0, Crack_format_INIT}

PRIVATE int _readInt(char * ptr, int * pDest)
{
    int i;
    int ret = 0;
    for (i = 0; ptr[i] >= '0' && ptr[i] <= '9'; i++) {
	ret *= 10;
	ret += ptr[i];
    }
    if (!i)
	return 0;
    *pDest = i;
    return i;
}

PRIVATE int Crack_next(Crack_t * pCrack, char * fmt, va_list pArgs)
{
    int innastring = 0;
    int scanIndex = pCrack->index;
    int used;
    static char shortRet[50];
    char sprintFmt[20];

    switch (fmt[scanIndex]) {
    case 0:
	return 0;
    case '%':
	scanIndex++;
	/* check for modifiers */
	if (fmt[scanIndex] == '0') {
	    pCrack->format.zeroPad = -1;
	    scanIndex++;
	}
	if (fmt[scanIndex] == '-') {
	    pCrack->format.leftJustify = -1;
	    scanIndex++;
	}
	if (fmt[scanIndex] == '+') {
	    pCrack->format.showSign = -1;
	    scanIndex++;
	}
	if ((used = _readInt(fmt+scanIndex, &pCrack->format.width)) > 0)
	    scanIndex += used;
	if (fmt[scanIndex] == '.') {
	    scanIndex++;
    	    if ((used = _readInt(fmt+scanIndex, &pCrack->format.precision)) > 0)
		scanIndex += used;
	    else
		pCrack->format.precision = 0;
	}
	if (fmt[scanIndex] == 'h' || fmt[scanIndex] == 'l' || fmt[scanIndex] == 'L') {
	    pCrack->format.size = fmt[scanIndex];
	    scanIndex++;
	}
	/* time for the format */
	switch (fmt[scanIndex]) {
	case 'd':
	case 'i':
	case 'o':
	case 'u':
	case 'x':
	case 'X':
	    strncpy(sprintFmt, fmt+pCrack->index, scanIndex+1-pCrack->index);
	    sprintFmt[scanIndex+1-pCrack->index] = 0;
	    if (!(pCrack->ptr = (char *)malloc(pCrack->format.width + pCrack->format.precision+20)))
		return 0;
	    pCrack->freeMe = 1;
	    switch (pCrack->format.size) {
	    case 0:
		pCrack->ptrLen = sprintf(pCrack->ptr, sprintFmt, *(int*)(pArgs+pCrack->format.iArgs));
		pCrack->format.iArgs += sizeof(int);
		break;
	    case 'h':
		pCrack->ptrLen = sprintf(pCrack->ptr, sprintFmt, *(short int*)(pArgs+pCrack->format.iArgs));
		pCrack->format.iArgs += sizeof(short int);
		break;
	    case 'l':
		pCrack->ptrLen = sprintf(pCrack->ptr, sprintFmt, *(long int*)(pArgs+pCrack->format.iArgs));
	        pCrack->format.iArgs += sizeof(long int);
		break;
	    default:
		free(pCrack->ptr);
		goto FMTSTRING; /* invalid arg combo */
	    }
	    pCrack->index = scanIndex+1;
	    return 1;
	case 'e':
	case 'E':
	case 'f':
	case 'g':
	case 'G':
	    strncpy(sprintFmt, fmt+pCrack->index, scanIndex+1-pCrack->index);
	    sprintFmt[scanIndex+1-pCrack->index] = 0;
	    if (!(pCrack->ptr = (char *)malloc(pCrack->format.width + pCrack->format.precision+20)))
		return 0;
	    pCrack->freeMe = 1;
	    switch (pCrack->format.size) {
	    case 0:
		pCrack->ptrLen = sprintf(pCrack->ptr, sprintFmt, *(double*)(pArgs+pCrack->format.iArgs));
		pCrack->format.iArgs += sizeof(double);
		break;
	    case 'L':
		pCrack->ptrLen = sprintf(pCrack->ptr, sprintFmt, *(long double*)(pArgs+pCrack->format.iArgs));
	        pCrack->format.iArgs += sizeof(long double);
		break;
	    default:
		free(pCrack->ptr);
		goto FMTSTRING; /* invalid arg combo */
	    }
	    pCrack->index = scanIndex+1;
	    return 1;
	case 'c':
	    shortRet[0] = *(char *)(pArgs+pCrack->format.iArgs);
	    pCrack->ptr = shortRet;
	    pCrack->freeMe = 0;
	    pCrack->ptrLen = 1;
	    pCrack->format.iArgs += sizeof(char);
	    pCrack->index = scanIndex+1;
	    return 1;
	case 's':
	    pCrack->ptr = *(char **)(pArgs+pCrack->format.iArgs);
	    pCrack->freeMe = 0;
	    pCrack->ptrLen = strlen(pCrack->ptr);
	    pCrack->format.iArgs += sizeof(char *);
	    pCrack->index = scanIndex+1;
	    return 1;
	case 'p':
	    pCrack->ptr = shortRet;
	    pCrack->freeMe = 0;
	    pCrack->ptrLen = sprintf(shortRet, "%p", *(void **)(pArgs+pCrack->format.iArgs));
	    pCrack->format.iArgs += sizeof(void *);
	    pCrack->index = scanIndex+1;
	    return 1;
	case 'n':
	    return 0;
	case '%':
	    shortRet[0] = '%';
	    pCrack->ptr = shortRet;
	    pCrack->freeMe = 0;
	    pCrack->ptrLen = 1;
	    pCrack->index = scanIndex+1;
	    return 1;
	}
    }
FMTSTRING:
    while (fmt[scanIndex] && fmt[scanIndex] != '%')
	scanIndex++;
    pCrack->ptr = fmt+pCrack->index;
    pCrack->freeMe = 0;
    pCrack->ptrLen = scanIndex - pCrack->index;
    pCrack->index = scanIndex;
    return 1;
}

PUBLIC int TextToAWindow(HTView * pView, const char * fmt, va_list pArgs)
{
    Crack_t crack = Crack_INIT;
    int totalLen = 0;

    while (Crack_next(&crack, fmt, pArgs)) {
	totalLen += crack.ptrLen;
        Scroll_WriteBlock(pView->pScrollInfo, pView->hWnd, (LPSTR)crack.ptr, crack.ptrLen);
	if (crack.freeMe)
	    free(crack.ptr);
    }
    return (totalLen);
}

PUBLIC int OutputConsole(const char* fmt, va_list pArgs)
{
    return (TextToAWindow(PMonitorView, fmt, pArgs));
}

PUBLIC int OutputData(HTView * pView, const char * fmt, ...)
{
    va_list pArgs;
    int len;

    va_start(pArgs, fmt);
    len = TextToAWindow(pView ? pView : PMonitorView, fmt, pArgs);
    va_end(pArgs);
    return (len);
}

#ifndef _WIN32
typedef MINMAXINFO FAR* LPMINMAXINFO;
#endif

#ifdef _WIN32
#define WINCALLBACK CALLBACK
#else
#define WINCALLBACK CALLBACK _export
#endif

LRESULT WINCALLBACK monitorWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
static int sized = 0;
    HTView * pView = (HTView *)GetWindowLong(hWnd, 0); /* valid for all events except for WM_CREATE */
    switch (uMsg)
    	{
    	case WM_USER+1:	//we just got a data set
    	    return (0);

    	case WM_CREATE:
    	    {
    	    HMENU hMenu = GetMenu(hWnd);
	    pView = (HTView *)((CREATESTRUCT *)lParam)->lpCreateParams;
	    SetWindowLong(hWnd, 0, (long)pView);
//	    	pView->pScrollInfo->control = Scroll_control_autoWrap | Scroll_control_crBegetsLf | Scroll_control_lfBegetsCr | Scroll_control_BSbegetsSpace;// | Scroll_control_literal;
    	    Scroll_ResetScreen(hWnd, pView->pScrollInfo, pView->pFontInfo);
    	    MoveWindow(hWnd, 0, 0, pView->pScrollInfo->maxTrackSize.x, pView->pScrollInfo->maxTrackSize.y, FALSE);
    	    return (0);
    	    }

#define USEMINMAX
#ifdef USEMINMAX
    	case WM_GETMINMAXINFO:
    	    {
    	    LPMINMAXINFO pMax = (LPMINMAXINFO)lParam;
			if (pView)
    			pMax->ptMaxTrackSize = pView->pScrollInfo->maxTrackSize;
    	    }
    	    break;
#endif

    	case WM_COMMAND:
    	    switch ((WORD) wParam)
    	    	{
//	    	    case IDM_CRBEGETSLF:
//	    	    	pView->pScrollInfo->control ^= Scroll_control_crBegetsLf;
//	    	    	CheckMenuItem(GetMenu(hWnd), (UINT)IDM_CRBEGETSLF, (pView->pScrollInfo->control & Scroll_control_crBegetsLf) ? MF_CHECKED : MF_UNCHECKED);
//    	    	    break;

    	    	case IDM_FONT:
    	    	    if (Lib_SelectWorkingFont(hWnd, pView->pFontInfo))
    	    	      Scroll_ResetScreen(hWnd, pView->pScrollInfo, pView->pFontInfo) ;
      	    	return (TRUE);
    	    	    break;

    	    	case IDM_ABOUT:
    	    	    while (MessageBox(hWnd, "It's a program, all right?", "About LineMode", MB_OKCANCEL) != IDOK);
    	    	    break;

    	    	case IDM_EXIT:
    	    	    PostMessage(hWnd, WM_CLOSE, 0, 0L);
    	    	    break ;
    	    	}
    	    break;

    	case WM_PAINT:
    	    Scroll_Paint(pView->pScrollInfo, pView->pFontInfo, hWnd, Scroll_cursorShow);
    	    break ;

    	case WM_SIZE:
    	    {
static int recursing = 0;
    	    RECT rect;
    	    LONG style;
    	    WORD xScroll = GetSystemMetrics(SM_CXVSCROLL);
    	    WORD yScroll = GetSystemMetrics(SM_CYHSCROLL);
    	    if (recursing == 1)
    	    	return (0);
    	    rect.left = 0;
    	    rect.top = 0;
    	    rect.right = LOWORD(lParam)+xScroll-1;
    	    rect.bottom = HIWORD(lParam)+yScroll-1;
    	    style = GetWindowLong(hWnd, GWL_STYLE);
    	    AdjustWindowRect(&rect, style, TRUE);
    	    if (style & (WS_VSCROLL | WS_HSCROLL) && rect.right-rect.left == pView->pScrollInfo->maxTrackSize.x && rect.bottom-rect.top == pView->pScrollInfo->maxTrackSize.y)
    	    	{
    	    	recursing = 1;
    	    	Scroll_SetSize(pView->pScrollInfo, hWnd, (WORD)(HIWORD(lParam)+yScroll), (WORD)(LOWORD(lParam)+xScroll));
    	    	recursing = 0;
    	    	}
    	    else
    	    	Scroll_SetSize(pView->pScrollInfo, hWnd, HIWORD(lParam), LOWORD(lParam));
    	    return (0);
    	    }
    	    break ;

    	case WM_HSCROLL:
#ifdef _WIN32
    	    Scroll_SetHorz(pView->pScrollInfo, hWnd, LOWORD(wParam), HIWORD(wParam));
#else
    	    Scroll_SetHorz(pView->pScrollInfo, hWnd, (WORD) wParam, LOWORD(lParam));
#endif
    	    break ;

    	case WM_VSCROLL:
#ifdef _WIN32
    	    Scroll_SetVert(pView->pScrollInfo, hWnd, LOWORD(wParam), HIWORD(wParam));
#else
    	    Scroll_SetVert(pView->pScrollInfo, hWnd, (WORD) wParam, LOWORD(lParam));
#endif
    	    break ;

    	case WM_CHAR:
    	    {
#ifdef _WIN32
    	    BYTE bOut = LOBYTE(LOWORD(wParam));
#else
    	    BYTE bOut = LOBYTE(wParam);
#endif

	    if (pView->pLm && 
		bufferInput(&bOut, 1, 0, LineMode_getConsole(pView->pLm), 0) == -1)
    	    	PostMessage(hWnd, WM_QUIT, 0, 0);
    	    Scroll_WriteBlock(pView->pScrollInfo, hWnd, &bOut, 1);
    	    }
    	    break ;

    	case WM_SETFOCUS:
    	    Scroll_SetFocus(hWnd, pView->pScrollInfo);
    	    break ;

    	case WM_KILLFOCUS:
    	    Scroll_KillFocus(hWnd, pView->pScrollInfo);
    	    break ;

    	case WM_DESTROY:
    	    {
    	    Scroll_DestroyInfo(pView->pScrollInfo);
    	    Font_DestroyInfo(pView->pFontInfo);
    	    PostMessage(hWnd, WM_QUIT, 0, 0);
    	    }
    	    break ;

    	default:
    	    return (DefWindowProc(hWnd, uMsg, wParam, lParam));
    	}
    return 0L;
    } // end of monitorWndProc()

int makeArgcArgv(HINSTANCE hInstance, char*** pArgv, char* commandLine)
{
    int argc;
static char* argv[20];
static char argv0[256];
    char* ptr = commandLine;
    char lookFor = 0;
    enum {nowAt_start, nowAt_text} nowAt;
    *pArgv = argv;
    argc = 0;
    GetModuleFileName(hInstance, argv0, sizeof(argv0));
    argv[argc++] = argv0;
    for (nowAt = nowAt_start;;) {
        if (!*ptr)
            return (argc);
        if (lookFor) {
            if (*ptr == lookFor) {
                nowAt = nowAt_start;
                lookFor = 0;
                *ptr = 0;   /* remove the quote */
            } else if (nowAt == nowAt_start) {
                argv[argc++] = ptr;