gvwprn.c

GSview 4.6 PostScript previewer。Ghostscript在MS-Windows, OS/2 and Unix下的图形化接口

char *
get_ports(void)
{
char *buffer;
	if (is_win95 || is_winnt)
	    return get_queues();

	if ((buffer = (char *)malloc(PORT_BUF_SIZE)) == (char *)NULL)
	    return NULL;
	GetProfileStringA("ports", NULL, "", buffer, PORT_BUF_SIZE);
	return buffer;
}




/******************************************************************/
/* Print File to port or queue */
/* port==NULL means prompt for port or queue with dialog box */
int gp_printfile(char *filename, char *port);

/* This is messy because Microsoft changed the spooler interface */
/* between Window 3.1 and Windows 95/NT */
/* and didn't provide the spooler interface in Win32s */

/* This code requires several different versions */
/* Win16: Use OpenJob etc. */
int gp_printfile_win16(char *filename, char *port);

/* Win95, WinNT: Use OpenPrinter, WritePrinter etc. */
int gp_printfile_win32(char *filename, char *port);

/* Win32s: Pass to Win16 spooler via gsv16spl.exe */
int gp_printfile_gsv16spl(char *filename, char *port);

int gp_printfile(char *filename, char *port)
{
    gs_addmess("Printing file \042");
    if (filename)
        gs_addmess(filename);
    gs_addmess("\042 to printer \042");
    if (port)
        gs_addmess(port);
    gs_addmess("\042\n");

    if (is_win95 || is_winnt)
	return gp_printfile_win32(filename, port);
    return gp_printfile_gsv16spl(filename, port);
}

#define PRINT_BUF_SIZE 16384u

/* True Win32 method, using OpenPrinter, WritePrinter etc. */
int 
gp_printfile_win32(char *filename, char *port)
{
DWORD count;
char *buffer;
char portname[MAXSTR];
FILE *f;
HANDLE printer;
DOC_INFO_1 di;
DWORD written;
TCHAR wbuf[MAXSTR];

    if (!get_portname(portname, port))
	return FALSE;
    port = portname + 8;	/* skip over \\spool\ */

    if ((buffer = (char *)malloc(PRINT_BUF_SIZE)) == (char *)NULL)
        return FALSE;
	
    if ((f = fopen(filename, "rb")) == (FILE *)NULL) {
	free(buffer);
	return FALSE;
    }


    /* open a printer */
    if (!OpenPrinterA(port, &printer, NULL)) {
	char buf[256];
	sprintf(buf, "OpenPrinter() failed for \042%s\042, error code = %d", port, GetLastError());
	gserror(0, buf, MB_ICONHAND, SOUND_ERROR);
	free(buffer);
	return FALSE;
    }
    /* from here until ClosePrinter, should AbortPrinter on error */

    convert_multibyte(wbuf, filename, sizeof(wbuf)/sizeof(TCHAR));
    di.pDocName = wbuf;
    di.pOutputFile = NULL;
    di.pDatatype = TEXT("RAW");  /* for available types see EnumPrintProcessorDatatypes */
    if (!StartDocPrinter(printer, 1, (LPBYTE)&di)) {
	char buf[256];
	sprintf(buf, "StartDocPrinter() failed, error code = %d", GetLastError());
	gserror(0, buf, MB_ICONHAND, SOUND_ERROR);
	AbortPrinter(printer);
	free(buffer);
	return FALSE;
    }
   

    while ((count = fread(buffer, 1, PRINT_BUF_SIZE, f)) != 0 ) {
	if (!WritePrinter(printer, (LPVOID)buffer, count, &written)) {
	    free(buffer);
	    fclose(f);
	    AbortPrinter(printer);
	    return FALSE;
	}
    }
    fclose(f);
    free(buffer);

    if (!EndDocPrinter(printer)) {
	char buf[256];
	sprintf(buf, "EndDocPrinter() failed, error code = %d", GetLastError());
	gserror(0, buf, MB_ICONHAND, SOUND_ERROR);
	AbortPrinter(printer);
	return FALSE;
    }

    if (!ClosePrinter(printer)) {
	char buf[256];
	sprintf(buf, "ClosePrinter() failed, error code = %d", GetLastError());
	gserror(0, buf, MB_ICONHAND, SOUND_ERROR);
	return FALSE;
    }
    return TRUE;
}


/* Start a 16-bit application gsv16spl.exe and pass printer data in */
/* global memory.  gsv16spl.exe then uses 16-bit spooler functions. */
/* Only works under Win16 and Win32s */
/* Intended for Win32s where 16-bit spooler functions are not available */
/* and Win32 spooler functions are not implemented. */
int
gp_printfile_gsv16spl(char *filename, char *port)
{
/* Get printer port list from win.ini */
char *buffer;
char portname[MAXSTR];
FILE *f;
unsigned int count;
int error = FALSE;
long lsize;
long ldone;
char pcdone[20];
MSG msg;
HINSTANCE hinst;
char command[MAXSTR];
HGLOBAL hmem;
LPBYTE data;

	if (!get_portname(portname, port))
	    return FALSE;

	if ((buffer = (char *)malloc(PRINT_BUF_SIZE)) == (char *)NULL)
	    return FALSE;

	hmem = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE, PRINT_BUF_SIZE+sizeof(WORD));
	if (hmem == (HGLOBAL)NULL) {
	    free(buffer);
	    gserror(0, "Can't allocate global memory for gsv16spl", 0, SOUND_ERROR);
	    return FALSE;
	}

	if ((f = fopen(filename, "rb")) == (FILE *)NULL) {
	    free(buffer);
	    GlobalFree(hmem);
	    return FALSE;
	}
	fseek(f, 0L, SEEK_END);
	lsize = ftell(f);
	if (lsize <= 0)
	    lsize = 1;
	fseek(f, 0L, SEEK_SET);

	data = (LPBYTE)GlobalLock(hmem);
	strcpy(((LPSTR)data)+2, portname);
	*((LPWORD)data) = (WORD)(strlen(portname)+1);
	GlobalUnlock(hmem);
	
	convert_widechar(command, szExePath, sizeof(command)-1);
	strcat(command, "gsv16spl.exe");
	sprintf(command+strlen(command), " %lu", (unsigned long)hwndimg);
	hinst = (HINSTANCE)WinExec(command, SW_SHOWMINNOACTIVE);
	if (hinst == NULL)
	{
	    fclose(f);
	    free(buffer);
	    GlobalFree(hmem);
	    gserror(IDS_CANNOTRUN, command, MB_ICONSTOP, SOUND_ERROR);
	    return FALSE;
	}

	if (hwndspl == (HWND)NULL) {
	    fclose(f);
	    free(buffer);
	    GlobalFree(hmem);
	    gserror(0, "gsv16spl didn't give us a window handle", 0, SOUND_ERROR);
	    return FALSE;	/* gsv16spl didn't SendMessage to us */
	}

	if (!SendMessage(hwndspl, WM_GSV16SPL, 0, (LPARAM)hmem)) {
	    fclose(f);
	    free(buffer);
	    GlobalFree(hmem);
	    gserror(0, "gsv16spl couldn't start printer job", 0, SOUND_ERROR);
	    return FALSE;
	}


	hDlgModeless = CreateDialogParamL(hlanguage, 
	    MAKEINTRESOURCE(IDD_CANCEL), hwndimg, CancelDlgProc, 0L);
	ldone = 0;

	data = (LPBYTE)GlobalLock(hmem);
	while (!error && hDlgModeless 
	  && (count = fread(buffer, 1, PRINT_BUF_SIZE, f)) != 0 ) {
	    *((LPWORD)data) = (WORD)count;
	    memcpy(((LPSTR)data)+2, buffer, count);
	    GlobalUnlock(hmem);
	    if (!SendMessage(hwndspl, WM_GSV16SPL, 0, (LPARAM)hmem))
		error = TRUE;
	    ldone += count;
	    sprintf(pcdone, "%d %%done", (int)(ldone * 100 / lsize));
	    SetWindowTextA(GetDlgItem(hDlgModeless, CANCEL_PCDONE), pcdone);
	    while (PeekMessage(&msg, hDlgModeless, 0, 0, PM_REMOVE)) {
		if ((hDlgModeless == 0) || !IsDialogMessage(hDlgModeless, &msg)) {
		    TranslateMessage(&msg);
		    DispatchMessage(&msg);
  		}
  	    }
	    data = (LPBYTE)GlobalLock(hmem);
  	}
	fclose(f);

	if (!hDlgModeless)
	    error=TRUE;

	if (error)
	    *((LPWORD)data) = 0xffff;	/* abort */
	else
	    *((LPWORD)data) = 0;	/* EOF */
	GlobalUnlock(hmem);
        SendMessage(hwndspl, WM_GSV16SPL, 0, (LPARAM)hmem);
	GlobalFree(hmem);
	free(buffer);

	DestroyWindow(hDlgModeless);
	hDlgModeless = 0;
	return !error;
}


void
start_gvwgs(void)
{
    BOOL flag;
    char progname[MAXSTR];
    char command[MAXSTR+MAXSTR];

    if (!is_win32s)
        sprintf(command,"%s \042%s\042 \042%s\042 \042%s\042", debug ? "/d" : "",
	    option.gsdll, printer.optname, printer.psname);
    else
        sprintf(command,"%s %s %s %s", debug ? "/d" : "",
	    option.gsdll, printer.optname, printer.psname);

    if (strlen(command) > MAXSTR-1) {
	/* command line too long */
	gserror(IDS_TOOLONG, command, MB_ICONHAND, SOUND_ERROR);
	if (!debug)
	    unlink(printer.psname);
	printer.psname[0] = '\0';
	if (!debug)
	    unlink(printer.optname);
	printer.optname[0] = '\0';
	return;
    }

    info_wait(IDS_WAIT);
    convert_widechar(progname, szExePath, sizeof(progname)-1);
#ifdef DECALPHA
    strcat(progname, "gvwgsda.exe");
#else
    strcat(progname, "gvwgs32.exe");
#endif
    flag = exec_pgm(progname, command, &printer.prog);
    if (!flag || !printer.prog.valid) {
	    cleanup_pgm(&printer.prog);
	    gserror(IDS_CANNOTRUN, progname, MB_ICONHAND, SOUND_ERROR);
	    if (!debug)
		unlink(printer.psname);
	    printer.psname[0] = '\0';
	    if (!debug)
		unlink(printer.optname);
	    printer.optname[0] = '\0';
	    info_wait(IDS_NOWAIT);
	    return;
    }

    info_wait(IDS_NOWAIT);

    /* if printing from command line, close GSview */
    if (print_exit && (print_count==0) && !(debug & DEBUG_GDI))
	gsview_command(IDM_EXIT);
    return;
}



#ifdef __BORLANDC__
#pragma argsused
#endif
BOOL CALLBACK _export
PageRangeDlgProc(HWND hDlg, UINT wmsg, WPARAM wParam, LPARAM lParam)
{
    int i;
    switch (wmsg) {
      case WM_INITDIALOG:
	{int print_method = (int)lParam;
	/* page reverse only for DSC and not ignoredsc */
	if ((psfile.dsc == (CDSC *)NULL) || psfile.print_ignoredsc) {
	    EnableWindow(GetDlgItem(hDlg, PAGE_REVERSE), FALSE);
	}
	else {
	    if (psfile.page_list.reverse)
		SendDlgItemMessage(hDlg, PAGE_REVERSE, BM_SETCHECK, 1, 0);
	}
	/* ignore DSC available only with DSC and PRINT_GDI */
	if ((psfile.dsc == (CDSC *)NULL) || print_method!=PRINT_GDI)
	    EnableWindow(GetDlgItem(hDlg, IDC_IGNOREDSC), FALSE);
	else
	    EnableWindow(GetDlgItem(hDlg, IDC_IGNOREDSC), TRUE);
	/* select all/even/odd */
	switch (psfile.print_oddeven) {
	    default:
	    case ALL_PAGES:
		i = IDC_ALL;
		break;
	    case ODD_PAGES:
		i = IDC_ODD;
		break;
	    case EVEN_PAGES:
		i = IDC_EVEN;
		break;
	}
	if ((psfile.dsc==(CDSC *)NULL) && print_method!=PRINT_GDI) {
	    i = IDC_ALL;
	    EnableWindow(GetDlgItem(hDlg, IDC_EVEN), FALSE);
	    EnableWindow(GetDlgItem(hDlg, IDC_ODD), FALSE);
	}
	SendDlgItemMessage(hDlg, i, BM_SETCHECK, 1, 0);

	/* page range */
	if ((psfile.dsc!=(CDSC *)NULL) || print_method==PRINT_GDI) {
	    char buf[32];
	    sprintf(buf, "%d", psfile.print_from);
	    SetDlgItemTextA(hDlg, IDC_FROM, buf);
	    sprintf(buf, "%d", psfile.print_to);
	    SetDlgItemTextA(hDlg, IDC_TO, buf);
	}
	else {
	    EnableWindow(GetDlgItem(hDlg, IDC_FROM), FALSE);
	    EnableWindow(GetDlgItem(hDlg, IDC_TO), FALSE);
	}
	}
	return TRUE;
      case WM_COMMAND:
	switch (LOWORD(wParam)) {
	    case IDC_IGNOREDSC:
		i = SendDlgItemMessage(hDlg, IDC_IGNOREDSC, BM_GETCHECK, 0, 0);
		if (i || (psfile.dsc == (CDSC *)NULL)) {
		  SendDlgItemMessage(hDlg, PAGE_REVERSE, BM_SETCHECK, 0, 0);
		  EnableWindow(GetDlgItem(hDlg, PAGE_REVERSE), FALSE);
		}
		else {
		  EnableWindow(GetDlgItem(hDlg, PAGE_REVERSE), TRUE);
		}
		return FALSE;
	    case IDOK:
		psfile.print_ignoredsc = SendDlgItemMessage(hDlg, 
			IDC_IGNOREDSC, BM_GETCHECK, 0, 0);
		psfile.page_list.reverse = SendDlgItemMessage(hDlg, 
			PAGE_REVERSE, BM_GETCHECK, 0, 0);
		psfile.print_from = GetDlgItemInt(hDlg, IDC_FROM, NULL, FALSE);
		psfile.print_to = GetDlgItemInt(hDlg, IDC_TO, NULL, FALSE);
		if (SendDlgItemMessage(hDlg, IDC_ODD, BM_GETCHECK, 0, 0))
		    psfile.print_oddeven = ODD_PAGES;
		else if (SendDlgItemMessage(hDlg, IDC_EVEN, BM_GETCHECK, 0, 0))
		    psfile.print_oddeven = EVEN_PAGES;
		else
		    psfile.print_oddeven = ALL_PAGES;
		EndDialog(hDlg, TRUE);
		return TRUE;
	    case IDCANCEL:
		EndDialog(hDlg, FALSE);
		return TRUE;
	    case ID_HELP:
		get_help();
		return TRUE;
	}
	break;
    }
    return FALSE;
}


void
set_page_range(void)
{
    if (psfile.dsc != (CDSC *)NULL) {
	BOOL print_it;
	int i;
	for (i=0; i< (int)(psfile.dsc->page_count); i++) {
	    print_it = FALSE;
	    if (((i+1) >= psfile.print_from) && ((i+1) <= psfile.print_to)) {
		if (psfile.print_oddeven == ALL_PAGES)
		    print_it = TRUE;
		else if ((psfile.print_oddeven == ODD_PAGES) && ((i%2)==0))
		    print_it = TRUE;
		else if ((psfile.print_oddeven == EVEN_PAGES) && ((i%2)==1))
		    print_it = TRUE;
	    }
	    psfile.page_list.select[i] = print_it;
	}
    }
}


/* Select pages to print or convert */
BOOL
get_page_range(HWND hwnd, int method)