os2.c

elinks下lynx是最重要的二个文本浏览器, 在linux下非常实用, elinks也是gentoo安装过程中默认使用的浏览器, 这是elinks源代码

		if (hSw != NULLHANDLE && hab != NULLHANDLE && hmq != NULLHANDLE) {
			safe_strncpy(swData.szSwtitle, org_switch_title, MAXNAMEL);
			WinChangeSwitchEntry(hSw, &swData);

			if (swData.hwnd)
				WinSetWindowText(swData.hwnd, org_win_title);
			WinDestroyMsgQueue(hmq);
			WinTerminate(hab);
		}
		pib->pib_ultype = oldType;
		mem_free(org_switch_title);
		mem_free(org_win_title);
		break;
	case 0:
		if (url && *url) {
			safe_strncpy(new_title, url, MAXNAMEL - 10);
			strcat(new_title, " - Links");
			pib->pib_ultype = 3;
			hab = WinInitialize(0);
			hmq = WinCreateMsgQueue(hab, 0);
			if (hSw != NULLHANDLE && hab != NULLHANDLE && hmq != NULLHANDLE) {
				safe_strncpy(swData.szSwtitle, new_title, MAXNAMEL);
				WinChangeSwitchEntry(hSw, &swData);

				if (swData.hwnd)
					WinSetWindowText(swData.hwnd, new_title);
				WinDestroyMsgQueue(hmq);
				WinTerminate(hab);
			}
			pib->pib_ultype = oldType;
		}
		break;
	}
}
#endif

int
resize_window(int x, int y, int old_width, int old_height)
{
	A_DECL(VIOMODEINFO, vmi);

	resize_count++;
	if (is_xterm()) return -1;
	vmi->cb = sizeof(*vmi);
	if (VioGetMode(vmi, 0)) return -1;
	vmi->col = x;
	vmi->row = y;
	if (VioSetMode(vmi, 0)) return -1;
#if 0
	unsigned char cmdline[16];
	sprintf(cmdline, "mode ");
	snprint(cmdline + 5, 5, x);
	strcat(cmdline, ",");
	snprint(cmdline + strlen(cmdline), 5, y);
#endif
	return 0;
}


#if OS2_MOUSE

#ifdef HAVE_SYS_FMUTEX_H
_fmutex mouse_mutex;
int mouse_mutex_init = 0;
#endif
int mouse_h = -1;

struct os2_mouse_spec {
	int p[2];
	void (*fn)(void *, unsigned char *, int);
	void *data;
	unsigned char buffer[sizeof(struct term_event)];
	int bufptr;
	int terminate;
};

void
mouse_thread(void *p)
{
	int status;
	struct os2_mouse_spec *oms = p;
	A_DECL(HMOU, mh);
	A_DECL(MOUEVENTINFO, ms);
	A_DECL(USHORT, rd);
	A_DECL(USHORT, mask);

	signal(SIGPIPE, SIG_IGN);
	if (MouOpen(NULL, mh)) goto ret;
	mouse_h = *mh;
	*mask = MOUSE_MOTION_WITH_BN1_DOWN | MOUSE_BN1_DOWN |
		MOUSE_MOTION_WITH_BN2_DOWN | MOUSE_BN2_DOWN |
		MOUSE_MOTION_WITH_BN3_DOWN | MOUSE_BN3_DOWN |
		MOUSE_MOTION;
	MouSetEventMask(mask, *mh);
	*rd = MOU_WAIT;
	status = -1;

	while (1) {
		struct term_event ev;
		struct term_event_mouse mouse;
		int w, ww;

		if (MouReadEventQue(ms, rd, *mh)) break;
#ifdef HAVE_SYS_FMUTEX_H
		_fmutex_request(&mouse_mutex, _FMR_IGNINT);
#endif
		if (!oms->terminate) MouDrawPtr(*mh);
#ifdef HAVE_SYS_FMUTEX_H
		_fmutex_release(&mouse_mutex);
#endif
		mouse.x = ms->col;
		mouse.y = ms->row;
		/*DBG("status: %d %d %d", ms->col, ms->row, ms->fs);*/
		if (ms->fs & (MOUSE_BN1_DOWN | MOUSE_BN2_DOWN | MOUSE_BN3_DOWN))
			mouse.button = status = B_DOWN | (ms->fs & MOUSE_BN1_DOWN ? B_LEFT : ms->fs & MOUSE_BN2_DOWN ? B_MIDDLE : B_RIGHT);
		else if (ms->fs & (MOUSE_MOTION_WITH_BN1_DOWN | MOUSE_MOTION_WITH_BN2_DOWN | MOUSE_MOTION_WITH_BN3_DOWN)) {
			int b = ms->fs & MOUSE_MOTION_WITH_BN1_DOWN ? B_LEFT : ms->fs & MOUSE_MOTION_WITH_BN2_DOWN ? B_MIDDLE : B_RIGHT;

			if (status == -1)
				b |= B_DOWN;
			else
				b |= B_DRAG;
			mouse.button = status = b;
		} else {
			if (status == -1) continue;
			mouse.button = (status & BM_BUTT) | B_UP;
			status = -1;
		}

		set_mouse_term_event(&ev, mouse.x, mouse.y, mouse.button);
		if (hard_write(oms->p[1], (unsigned char *) &ev, sizeof(ev)) != sizeof(ev)) break;
	}
#ifdef HAVE_SYS_FMUTEX_H
	_fmutex_request(&mouse_mutex, _FMR_IGNINT);
#endif
	mouse_h = -1;
	MouClose(*mh);
#ifdef HAVE_SYS_FMUTEX_H
	_fmutex_release(&mouse_mutex);
#endif

ret:
	close(oms->p[1]);
	/*free(oms);*/
}

void
mouse_handle(struct os2_mouse_spec *oms)
{
	ssize_t r = safe_read(oms->p[0], oms->buffer + oms->bufptr,
		          sizeof(struct term_event) - oms->bufptr);

	if (r <= 0) {
		unhandle_mouse(oms);
		return;
	}

	oms->bufptr += r;
	if (oms->bufptr == sizeof(struct term_event)) {
		oms->bufptr = 0;
		oms->fn(oms->data, oms->buffer, sizeof(struct term_event));
	}
}

void *
handle_mouse(int cons, void (*fn)(void *, unsigned char *, int),
	     void *data)
{
	struct os2_mouse_spec *oms;

	if (is_xterm()) return NULL;
#ifdef HAVE_SYS_FMUTEX_H
	if (!mouse_mutex_init) {
		if (_fmutex_create(&mouse_mutex, 0)) return NULL;
		mouse_mutex_init = 1;
	}
#endif
		/* This is never freed but it's allocated only once */
	oms = malloc(sizeof(*oms));
	if (!oms) return NULL;
	oms->fn = fn;
	oms->data = data;
	oms->bufptr = 0;
	oms->terminate = 0;
	if (c_pipe(oms->p)) {
		free(oms);
		return NULL;
	}
	_beginthread(mouse_thread, NULL, 0x10000, (void *) oms);
	set_handlers(oms->p[0], (select_handler_T) mouse_handle, NULL, NULL, oms);

	return oms;
}

void
unhandle_mouse(void *om)
{
	struct os2_mouse_spec *oms = om;

	want_draw();
	oms->terminate = 1;
	clear_handlers(oms->p[0]);
	close(oms->p[0]);
	done_draw();
}

void
suspend_mouse(void *om)
{
}

void
resume_mouse(void *om)
{
}

void
want_draw(void)
{
	A_DECL(NOPTRRECT, pa);
#ifdef HAVE_SYS_FMUTEX_H
	if (mouse_mutex_init) _fmutex_request(&mouse_mutex, _FMR_IGNINT);
#endif
	if (mouse_h != -1) {
		static int x = -1, y = -1;
		static int c = -1;

		if (x == -1 || y == -1 || (c != resize_count)) {
			get_terminal_size(1, &x, &y);
			c = resize_count;
		}

		pa->row = 0;
		pa->col = 0;
		pa->cRow = y - 1;
		pa->cCol = x - 1;
		MouRemovePtr(pa, mouse_h);
	}
}

void
done_draw(void)
{
#ifdef HAVE_SYS_FMUTEX_H
	if (mouse_mutex_init) _fmutex_release(&mouse_mutex);
#endif
}

#endif /* OS2_MOUSE */


int
get_ctl_handle(void)
{
	return get_input_handle();
}


int
get_system_env(void)
{
	int env = get_common_env();

	/* !!! FIXME: telnet */
	if (!is_xterm()) env |= ENV_OS2VIO;

	return env;
}


void
set_highpri(void)
{
	DosSetPriority(PRTYS_PROCESS, PRTYC_FOREGROUNDSERVER, 0, 0);
}


int
can_open_os_shell(int environment)
{
	if (environment & ENV_XWIN) return 0;
	return 1;
}


#if defined(HAVE_BEGINTHREAD)

int
start_thread(void (*fn)(void *, int), void *ptr, int l)
{
	int p[2];
	struct tdata *t;

	if (c_pipe(p) < 0) return -1;
	if (set_nonblocking_fd(p[0]) < 0) return -1;
	if (set_nonblocking_fd(p[1]) < 0) return -1;

	t = malloc(sizeof(*t) + l);
	if (!t) return -1;
	t->fn = fn;
	t->h = p[1];
	memcpy(t->data, ptr, l);
	if (_beginthread((void (*)(void *)) bgt, NULL, 65536, t) == -1) {
		close(p[0]);
		close(p[1]);
		mem_free(t);
		return -1;
	}

	return p[0];
}

#if defined(HAVE_READ_KBD)

int tp = -1;
int ti = -1;

void
input_thread(void *p)
{
	unsigned char c[2];
	int h = (int) p;

	signal(SIGPIPE, SIG_IGN);
	while (1) {
#if 0
		c[0] = _read_kbd(0, 1, 1);
		if (c[0]) if (safe_write(h, c, 1) <= 0) break;
		else {
			int w;
			printf("1");fflush(stdout);
			c[1] = _read_kbd(0, 1, 1);
			printf("2");fflush(stdout);
			w = safe_write(h, c, 2);
			printf("3");fflush(stdout);
			if (w <= 0) break;
			if (w == 1) if (safe_write(h, c+1, 1) <= 0) break;
			printf("4");fflush(stdout);
		}
#endif
		/* for the records:
		 * _read_kbd(0, 1, 1) will
		 * read a char, don't echo it, wait for one available and
		 * accept CTRL-C.
		 * Knowing that, I suggest we replace this call completly!
		 */
		*c = _read_kbd(0, 1, 1);
		write(h, c, 1);
	}
	close(h);
}

int
get_input_handle(void)
{
	int fd[2];

	if (ti != -1) return ti;
	if (is_xterm()) return 0;
	if (c_pipe(fd) < 0) return 0;
	ti = fd[0];
	tp = fd[1];
	_beginthread(input_thread, NULL, 0x10000, (void *) tp);
	return fd[0];
}

#endif

#endif


#ifdef USE_OPEN_PREALLOC
int
open_prealloc(unsigned char *name, int flags, int mode, off_t siz)
{
	/* This is good for OS/2, where this will prevent file fragmentation,
	 * preallocating the desired file size upon open(). */
	return open(name, flags | O_SIZE, mode, (unsigned long) siz);
}

void
prealloc_truncate(int h, off_t siz)
{
	ftruncate(h, siz);
}
#endif