Exemple #1
0
static int
lWindowShouldClose(lua_State *L) {
	GLFWwindow * window = getwindow(L);
	lua_pushboolean(L, glfwWindowShouldClose(window));

	return 1;
}
Exemple #2
0
void
resize(void)
{
	Rectangle old, r;
	int dxo, dyo, dxn, dyn;
	Win *w;
	
	old = screen->r;
	dxo = Dx(old);
	dyo = Dy(old);
	if(getwindow(display, Refnone) < 0)
		sysfatal("resize failed: %r");
	dxn = Dx(screen->r);
	dyn = Dy(screen->r);
	freescreen(scr);
	scr = allocscreen(screen, display->white, 0);
	if(scr == nil)
		sysfatal("allocscreen: %r");
	for(w = wlist.next; w != &wlist; w = w->next){
		r = rectsubpt(w->entire, old.min);
		r.min.x = muldiv(r.min.x, dxn, dxo);
		r.max.x = muldiv(r.max.x, dxn, dxo);
		r.min.y = muldiv(r.min.y, dyn, dyo);
		r.max.y = muldiv(r.max.y, dyn, dyo);
		w->entire = rectaddpt(r, screen->r.min);
		w->inner = insetrect(w->entire, BORDSIZ);
		freeimage(w->im);
		w->im = allocwindow(scr, w->entire, Refbackup, 0);
		if(w->im == nil)
			sysfatal("allocwindow: %r");
		draw(w->im, w->inner, w->tab->cols[BACK], nil, ZP);
		border(w->im, w->entire, BORDSIZ, w->tab->cols[w == actw ? BORD : DISB], ZP);
		w->tab->draw(w);
	}
}
Exemple #3
0
static int
lSwapBuffers(lua_State *L) {
	GLFWwindow * window = getwindow(L);
	glfwSwapBuffers(window);

	return 0;
}
Exemple #4
0
static int
lDestroyWindow(lua_State *L) {
	GLFWwindow * window = getwindow(L);
	glfwDestroyWindow(window);

	return 0;
}
Exemple #5
0
void xmms_fullscreen_leave(GtkWidget * win)
{
	fullscreen_window_t *fwin;

	FULL_LOCK();
	fwin = getwindow(win);

	if (fwin->is_full && fwin->display->is_full)
	{
		/* Release our grabs */
		gdk_pointer_ungrab(GDK_CURRENT_TIME);
		gdk_keyboard_ungrab(GDK_CURRENT_TIME);

		/* Let the WM manage this window again */
		gdk_window_hide(fwin->window->window);
		gdk_window_set_override_redirect(fwin->window->window, FALSE);
		gdk_window_show(fwin->window->window);

		/* Restore size/position */
		gdk_window_move_resize(fwin->window->window, fwin->ox, fwin->oy,
				       fwin->owidth, fwin->oheight);

		XF86VidModeSwitchToMode(fwin->display->display,
					DefaultScreen(fwin->display->display),
					fwin->display->origmode);
		fwin->display->is_full = FALSE;
	}
	fwin->is_full = FALSE;
	FULL_UNLOCK();
}
/* Retrieve pending events, and return the number of events */
static int getPendingEvents(void) {
	int count = 0;
	while (1) {
		Mouse mouse;
		Rune rune;
		int charCode, modifiers;
		int mouse_event = nbrecv(mousectl->c, (void*)&mouse);
		int resize_event = nbrecv(mousectl->resizec, NULL);
		int kbd_event = nbrecv(keyboardctl->c, (void*)&rune);
		
		if (mouse_event) {
			//Process mouse event
			mouse_position.x = mouse.xy.x - screen->r.min.x;
			mouse_position.y = mouse.xy.y - screen->r.min.y;
			mouse_button_state = mouse.buttons;
			qlock(&evt_buf_lock);
			if ((evts_end+2)%EVT_BUFFER_SIZE != evts_start) {
				sqMouseEvent* evt = (sqMouseEvent*)&evts[evts_end++];
				evts_end %= EVT_BUFFER_SIZE;
				evt->type = EventTypeMouse;
				evt->timeStamp = ioMSecs();
				evt->x = mouse_position.x;
				evt->y = mouse_position.y;
				evt->buttons = ioGetButtonState();
				evt->modifiers = 0;
				evt->reserved1 = evt->windowIndex = 0;
				count++;
			}
			qunlock(&evt_buf_lock);
		}

		if (resize_event) {
			getwindow(display, Refnone);
			fullDisplayUpdate();
		}

		if (kbd_event && splitRune(rune, &charCode, &modifiers)) {
			//Process keyboard event
			qlock(&evt_buf_lock);
			if ((evts_end+2)%EVT_BUFFER_SIZE != evts_start) {
				sqKeyboardEvent* evt = (sqKeyboardEvent*)&evts[evts_end++];
				evts_end %= EVT_BUFFER_SIZE;
				evt->type = EventTypeKeyboard;
				evt->timeStamp = ioMSecs();
				evt->pressCode = EventKeyChar;
				evt->charCode = charCode;
				evt->modifiers = modifiers;
				evt->reserved1 = evt->windowIndex = 0;
				count++;
			}
			qunlock(&evt_buf_lock);
		}
		if (!(resize_event || kbd_event || mouse_event))
			break;
	}
	return count;
}
Exemple #7
0
gboolean xmms_fullscreen_init(GtkWidget * win)
{
	int event_base, error_base, dummy;
	fullscreen_window_t *fwin;
	gint i;
	XF86VidModeModeLine origmode;

	FULL_LOCK();
	fwin = getwindow(win);

	if (!XF86VidModeQueryExtension
	    (fwin->display->display, &event_base, &error_base))
	{
		FULL_UNLOCK();
		return FALSE;
	}

	if (!fwin->display->modes)
	{
		XF86VidModeGetAllModeLines(fwin->display->display,
					   DefaultScreen(fwin->display->display),
					   &fwin->display->num_modes,
					   &fwin->display->modes);

		if (!fwin->display->origmode)
		{
			XF86VidModeGetModeLine(fwin->display->display,
					       DefaultScreen(fwin->display->display),
					       &dummy, &origmode);
			for (i = 0; i < fwin->display->num_modes; i++)
			{
				if (fwin->display->modes[i]->hdisplay ==
				    origmode.hdisplay
				    && fwin->display->modes[i]->vdisplay ==
				    origmode.vdisplay)
				{
					fwin->display->origmode =
						fwin->display->modes[i];
					break;
				}
			}

			if (!fwin->display->origmode)
			{
				fprintf(stderr,
					"ERROR: Could not determine original mode.\n");
				FULL_UNLOCK();
				return FALSE;
			}

		}

		fwin->display->can_full = (fwin->display->num_modes > 1);
	}
	FULL_UNLOCK();
	return fwin->display->can_full;
}
Exemple #8
0
static int
lMakeContextCurrent(lua_State *L) {
	GLFWwindow * window = getwindow(L);
	glfwMakeContextCurrent(window);
	if (!gladLoadGLLoader((GLADloadproc) glfwGetProcAddress)) {
		return luaL_error(L, "Can't load GL");
	}

	return 0;
}
Exemple #9
0
gboolean xmms_fullscreen_in(GtkWidget * win)
{
	fullscreen_window_t *fwin;

	FULL_LOCK();
	fwin = getwindow(win);
	FULL_UNLOCK();

	if (fwin->display->is_full)
		return TRUE;
	else
		return FALSE;
}
Exemple #10
0
void
resizethread(void *v)
{
	USED(v);

	while(recv(mc->resizec, 0) == 1){
		lockdisplay(display);
		if(getwindow(display, Refnone) < 0)
			sysfatal("attach to window: %r");
		resize();
		unlockdisplay(display);
	}
}
Exemple #11
0
void xmms_fullscreen_unmark(GtkWidget * win)
{
	fullscreen_window_t *fwin;

	FULL_LOCK();
	fwin = getwindow(win);

	if (fwin->is_full)
	{
		fwin->is_full = FALSE;
		fwin->display->is_full = FALSE;
	}
	FULL_UNLOCK();
}
Exemple #12
0
/* called from graphics library */
void
eresized(int callgetwin)
{
	needresize = callgetwin + 1;

	/* new window? */
	/* was using Refmesg */
	if (needresize > 1 && getwindow(display, Refnone) < 0)
		sysfatal("can't reattach to window: %r");

	/* destroyed window? */
	if (Dx(screen->r) == 0 || Dy(screen->r) == 0)
		exits("window gone");

	reshape();
}
static WINDOW *
create_my_derwin(WINDOW *parent)
{
    PAIR ul, lr;
    WINDOW *result = 0;

    if (getwindow(parent, &ul, &lr)) {
	result = derwin(parent, lines_of(ul, lr), cols_of(ul, lr), pair_of(ul));
	if (result != 0) {
	    fill_window(result, 'd');
	    add_window(parent, result);
	}
    }
    if (result == 0)
	result = parent;
    return result;
}
static WINDOW *
create_my_window(WINDOW *current)
{
    PAIR ul, lr;
    WINDOW *result = 0;

    if (getwindow(stdscr, &ul, &lr)) {
	result = newwin(lines_of(ul, lr), cols_of(ul, lr), pair_of(ul));
	if (result != 0) {
	    fill_window(result, 'c');
	    add_window(stdscr, result);
	}
    }
    if (result == 0)
	result = current;
    return result;
}
Exemple #15
0
struct CACHE *viocmanager(struct CACHE * cacheobj)
{
    register struct VIOC *vioc = (struct VIOC *) cacheobj;
    if (vioc->cache.status & CACHE_MODIFIED) {
        register int length = VIOC_CHUNKSIZE;
        register struct FCB *fcb = vioc->fcb;
        register unsigned base = vioc->cache.keyval;
        register char *address = (char *) vioc->data;
        printf("\nviocmanager writing vbn %d\n",base);
        cachetouch(&fcb->cache);
        do {
            register unsigned sts;
            unsigned rvn,mapblk,maplen;
            register struct VCBDEV *vcbdev;
            if (fcb->highwater > 0 && base >= fcb->highwater) break;
            sts = getwindow(fcb,base,&rvn,&mapblk,&maplen);
            if (sts & 1) {
                if (maplen > (unsigned)length) maplen = length;
                if (fcb->highwater > 0 && base + maplen > fcb->highwater) {
                    maplen = fcb->head->fh2$l_highwater - base;
                }
                if (rvn > fcb->vcb->devices) {
                    sts = SS$_NOSUCHFILE;
                } else {
                    if (rvn < 2) {
                        vcbdev = fcb->vcb->vcbdev;
                    } else {
                        vcbdev = &fcb->vcb->vcbdev[rvn - 1];
                    }
                    if (vcbdev->dev == NULL) return NULL;
                    sts = phyio_write(vcbdev->dev->handle,mapblk,maplen * 512,address);
                }
            }
            if ((sts & 1) == 0) {
                return NULL;
            }
            length -= maplen;
            base += maplen;
            address += maplen * 512;
        } while (length > 0);
        cacheuntouch(&fcb->cache,1,0);
        cacheobj->status &= ~CACHE_MODIFIED;
    }
    return cacheobj;
}
Exemple #16
0
gboolean xmms_fullscreen_mark(GtkWidget * win)
{
	fullscreen_window_t *fwin;

	FULL_LOCK();
	fwin = getwindow(win);

	if (fwin->display->is_full)
	{
		FULL_UNLOCK();
		return FALSE;
	}
	else
	{
		fwin->is_full = TRUE;
		fwin->display->is_full = TRUE;
		FULL_UNLOCK();
		return TRUE;
	}
}
Exemple #17
0
GSList *xmms_fullscreen_modelist(GtkWidget * win)
{
	fullscreen_window_t *fwin;
	xmms_fullscreen_mode_t *ent;
	GSList *retlist = NULL;
	int i;

	FULL_LOCK();
	fwin = getwindow(win);

	for (i = 0; i < fwin->display->num_modes; i++)
	{
		ent = g_malloc(sizeof (*ent));
		ent->width = fwin->display->modes[i]->hdisplay;
		ent->height = fwin->display->modes[i]->vdisplay;
		retlist = g_slist_append(retlist, ent);
	}
	FULL_UNLOCK();

	return retlist;
}
static WINDOW *
create_my_subwin(WINDOW *parent)
{
    PAIR ul, lr;
    WINDOW *result = 0;

    if (getwindow(parent, &ul, &lr)) {
	result = subwin(parent,
			lines_of(ul, lr),
			cols_of(ul, lr),
			ul.y + getbegy(parent),
			ul.x + getbegx(parent));
	if (result != 0) {
	    fill_window(result, 's');
	    add_window(parent, result);
	}
    }
    if (result == 0)
	result = parent;
    return result;
}
Exemple #19
0
static void
resize(Vnc *v, int first)
{
    int fd;
    Point d;

    d = addpt(v->dim, Pt(2*Borderwidth, 2*Borderwidth));
    lockdisplay(display);

    if(getwindow(display, Refnone) < 0)
        sysfatal("internal error: can't get the window image");

    /*
     * limit the window to at most the vnc server's size
     */
    if(first || d.x < Dx(screen->r) || d.y < Dy(screen->r)) {
        fd = open("/dev/wctl", OWRITE);
        if(fd >= 0) {
            fprint(fd, "resize -dx %d -dy %d", d.x, d.y);
            close(fd);
        }
    }
    unlockdisplay(display);
}
Exemple #20
0
unsigned deallocfile(struct FCB *fcb)
{
    register unsigned sts = 1;
    /*
        First mark all file clusters as free in BITMAP.SYS
    */
    register unsigned vbn = 1;
    while (vbn <= fcb->hiblock) {
        register unsigned sts;
        unsigned rvn,mapblk,maplen;
        register struct VCBDEV *vcbdev;
        sts = getwindow(fcb,vbn,&rvn,&mapblk,&maplen);
        if ((sts & 1) == 0) break;
        if (rvn > fcb->vcb->devices) break;
        if (rvn < 2) {
            vcbdev = fcb->vcb->vcbdev;
        } else {
            vcbdev = &fcb->vcb->vcbdev[rvn - 1];
        }
        if (vcbdev->dev == NULL) {
            break;
        } else {
            unsigned *bitmap,blkcount,modmask;
            struct VIOC *vioc;
            register unsigned clustersz = vcbdev->home.hm2$w_cluster;
            register unsigned clusterno = mapblk / clustersz;
            sts = accesschunk(vcbdev->mapfcb,clusterno / 4096 + 2,
                              &vioc,(char **) &bitmap,&blkcount,1,&modmask);
            if (sts & 1) {
                register unsigned wordno = (clusterno % 4096) / (sizeof(unsigned) * 8);
                register unsigned bitno = clusterno % (sizeof(unsigned) * 8);
                do {
                    register unsigned mask = 1 << bitno;
                    vbn += clustersz;
                    maplen -= clustersz;
                    while (maplen > 0 && ++bitno < (sizeof(unsigned) * 8)) {
                        mask |= (mask << 1);
                        vbn += clustersz;
                        maplen -= clustersz;
                    }
                    bitmap[wordno++] |= mask;
                    bitno = 0;
                } while (maplen > 0 && wordno < blkcount / (sizeof(unsigned) * 8));
                sts = deaccesschunk(vioc,modmask,1);
            }
        }
    }
    /*
        Now reset file header bit map in INDEXF.SYS and
        update each of the file headers...
    */
    {
        unsigned rvn = fcb->rvn;
        unsigned modmask = fcb->modmask;
        struct HEAD *head = fcb->head;
        struct VIOC *headvioc = fcb->headvioc;
        do {
            struct fiddef extfid;
            register struct VCBDEV *vcbdev;
            if (rvn > fcb->vcb->devices) break;
            if (rvn < 2) {
                vcbdev = fcb->vcb->vcbdev;
            } else {
                vcbdev = &fcb->vcb->vcbdev[rvn - 1];
            }
            if (vcbdev->dev == NULL) {
                break;
            } else {
                unsigned *bitmap,viocmask;
                struct VIOC *vioc;
                register unsigned fileno = (head->fh2$w_fid.fid$b_nmx << 16) +
                         head->fh2$w_fid.fid$w_num - 1;
                register unsigned idxblk = fileno / 4096 +
                    vcbdev->home.hm2$w_cluster * 4 + 1;
                sts = accesschunk(vcbdev->idxfcb,idxblk,&vioc,
                                  (char **) &bitmap,NULL,1,&viocmask);
                if (sts & 1) {
                    bitmap[(fileno % 4096) / (sizeof(unsigned) * 8)] &=
                         ~(1 << (fileno % (sizeof(unsigned) * 8)));
                    sts = deaccesschunk(vioc,viocmask,1);
                } else {
                    break;
                }
            }
            head->fh2$w_fid.fid$w_num = 0;
            head->fh2$w_fid.fid$b_rvn = 0;
            head->fh2$w_fid.fid$b_nmx = 0;
            head->fh2$w_checksum = 0;
            memcpy(&extfid,&fcb->head->fh2$w_ext_fid,sizeof(struct fiddef));
            sts = deaccesshead(headvioc,head,modmask);
            if ((sts & 1) == 0) break;
            if (extfid.fid$b_rvn == 0) {
                extfid.fid$b_rvn = rvn;
            } else {
                rvn = extfid.fid$b_rvn;
            }
            if (extfid.fid$w_num != 0 || extfid.fid$b_nmx != 0) {
                sts = accesshead(fcb->vcb,&extfid,&headvioc,&head,&modmask,1);
                if ((sts & 1) == 0) break;
            } else {
                break;
            }
        } while (1);
        if (sts & 1) {
            fcb->headvioc = NULL;
            cacheuntouch(&fcb->cache,0,1);
            cachedelete(&fcb->cache);
        }
    }
    return sts;
}
Exemple #21
0
unsigned accesschunk(struct FCB *fcb,unsigned vbn,struct VIOC **retvioc,
                     char **retbuff,unsigned *retblocks,unsigned wrtblks,
                     unsigned *retmodmask)
{
    /*
        First find cache entry...
    */
    register struct VIOC *vioc;
    unsigned create = sizeof(struct VIOC);
    register unsigned base = (vbn - 1) / VIOC_CHUNKSIZE * VIOC_CHUNKSIZE + 1;
#ifdef DEBUG
    printf("Access chunk %8x %d (%x)\n",base,vbn,fcb->cache.keyval);
#endif
    if (wrtblks && ((fcb->cache.status & CACHE_WRITE) == 0)) return SS$_WRITLCK;
    if (vbn < 1 || vbn > fcb->hiblock) return SS$_ENDOFFILE;
    vioc = cachesearch((void *) &fcb->vioc,base,0,NULL,NULL,&create);
    if (vioc == NULL) return SS$_INSFMEM;
    /*
        If not found make one...
    */
    if (create == 0) {
        register unsigned length;
        register char *address;
        register unsigned mapbase = base;
        vioc->cache.status |= 0x400;    /* For debugging! */
        vioc->fcb = fcb;
        vioc->wrtmask = 0;
        vioc->modmask = 0;
        length = fcb->hiblock - mapbase + 1;
        if (length > VIOC_CHUNKSIZE) length = VIOC_CHUNKSIZE;
        address = (char *) vioc->data;
        do {
            if (fcb->highwater > 0 && mapbase >= fcb->highwater) {
                memset(address,0,length * 512);
                length = 0;
            } else {
                register unsigned sts;
                unsigned rvn,mapblk,maplen;
                register struct VCBDEV *vcbdev;
                sts = getwindow(fcb,mapbase,&rvn,&mapblk,&maplen);
                if (sts & 1) {
                    if (maplen > length) maplen = length;
                    if (fcb->highwater > 0 && mapbase + maplen > fcb->highwater) {
                        maplen = fcb->head->fh2$l_highwater - mapbase;
                    }
                    if (rvn > fcb->vcb->devices) {
                        sts = SS$_NOSUCHFILE;
                    } else {
                        if (rvn < 2) {
                            vcbdev = fcb->vcb->vcbdev;
                        } else {
                            vcbdev = &fcb->vcb->vcbdev[rvn - 1];
                        }
                        if (vcbdev->dev == NULL) return SS$_NOSUCHFILE;
                        sts = phyio_read(vcbdev->dev->handle,mapblk,maplen * 512,address);
                    }
                }
                if ((sts & 1) == 0) {
                    cacheuntouch(&vioc->cache,0,0);
                    cachefree(&vioc->cache);
                    return sts;
                }
                length -= maplen;
                mapbase += maplen;
                address += maplen * 512;
            }
        } while (length > 0);
    }
    if (wrtblks) {
        vioc->cache.status |= CACHE_WRITE;
        vioc->cache.objmanager = viocmanager;
    }
    /*
        Return result to caller...
    */
    *retvioc = vioc;
    *retbuff = vioc->data[vbn - base];
    if (wrtblks || retblocks != NULL || retmodmask != NULL) {
        register unsigned modmask = 0;
        register unsigned blocks = base + VIOC_CHUNKSIZE - vbn;
        if (blocks > fcb->hiblock - vbn) blocks = fcb->hiblock - vbn + 1;
            if (wrtblks) if (blocks > wrtblks) blocks = wrtblks;
        if (retblocks != NULL) *retblocks = blocks;
        if (wrtblks) {
            modmask = 1 << (vbn - base);
            if (blocks > 1) {
                while (--blocks > 0) modmask |= modmask << 1;
            }
            vioc->wrtmask |= modmask;
        }
        if (retmodmask != NULL) *retmodmask = modmask;
    }
    return SS$_NORMAL;
}
Exemple #22
0
void
mousethread(void *v)
{
	Text *t, *argt;
	int but;
	uint q0, q1;
	Window *w;
	Plumbmsg *pm;
	Mouse m;
	char *act;
	enum { MResize, MMouse, MPlumb, MWarnings, NMALT };
	static Alt alts[NMALT+1];

	USED(v);
	threadsetname("mousethread");
	alts[MResize].c = mousectl->resizec;
	alts[MResize].v = nil;
	alts[MResize].op = CHANRCV;
	alts[MMouse].c = mousectl->c;
	alts[MMouse].v = &mousectl->m;
	alts[MMouse].op = CHANRCV;
	alts[MPlumb].c = cplumb;
	alts[MPlumb].v = &pm;
	alts[MPlumb].op = CHANRCV;
	alts[MWarnings].c = cwarn;
	alts[MWarnings].v = nil;
	alts[MWarnings].op = CHANRCV;
	if(cplumb == nil)
		alts[MPlumb].op = CHANNOP;
	alts[NMALT].op = CHANEND;

	for(;;){
		qlock(&row.lk);
		flushwarnings();
		qunlock(&row.lk);
		flushimage(display, 1);
		switch(alt(alts)){
		case MResize:
			if(getwindow(display, Refnone) < 0)
				error("attach to window");
			draw(screen, screen->r, display->white, nil, ZP);
			iconinit();
			scrlresize();
			rowresize(&row, screen->clipr);
			break;
		case MPlumb:
			if(strcmp(pm->type, "text") == 0){
				act = plumblookup(pm->attr, "action");
				if(act==nil || strcmp(act, "showfile")==0)
					plumblook(pm);
				else if(strcmp(act, "showdata")==0)
					plumbshow(pm);
			}
			plumbfree(pm);
			break;
		case MWarnings:
			break;
		case MMouse:
			/*
			 * Make a copy so decisions are consistent; mousectl changes
			 * underfoot.  Can't just receive into m because this introduces
			 * another race; see /sys/src/libdraw/mouse.c.
			 */
			m = mousectl->m;
			qlock(&row.lk);
			t = rowwhich(&row, m.xy);
			if(t!=mousetext && mousetext!=nil && mousetext->w!=nil){
				winlock(mousetext->w, 'M');
				mousetext->eq0 = ~0;
				wincommit(mousetext->w, mousetext);
				winunlock(mousetext->w);
			}
			mousetext = t;
			if(t == nil)
				goto Continue;
			w = t->w;
			if(t==nil || m.buttons==0)
				goto Continue;
			but = 0;
			if(m.buttons == 1)
				but = 1;
			else if(m.buttons == 2)
				but = 2;
			else if(m.buttons == 4)
				but = 3;
			barttext = t;
			if(t->what==Body && ptinrect(m.xy, t->scrollr)){
				if(but){
					if(swapscrollbuttons){
						if(but == 1)
							but = 3;
						else if(but == 3)
							but = 1;
					}
					winlock(w, 'M');
					t->eq0 = ~0;
					textscroll(t, but);
					winunlock(w);
				}
				goto Continue;
			}
			/* scroll buttons, wheels, etc. */
			if(w != nil && (m.buttons & (8|16))){
				if(m.buttons & 8)
					but = Kscrolloneup;
				else
					but = Kscrollonedown;
				winlock(w, 'M');
				t->eq0 = ~0;
				texttype(t, but);
				winunlock(w);
				goto Continue;
			}
			if(ptinrect(m.xy, t->scrollr)){
				if(but){
					if(t->what == Columntag)
						rowdragcol(&row, t->col, but);
					else if(t->what == Tag){
						coldragwin(t->col, t->w, but);
						if(t->w)
							barttext = &t->w->body;
					}
					if(t->col)
						activecol = t->col;
				}
				goto Continue;
			}
			if(m.buttons){
				if(w)
					winlock(w, 'M');
				t->eq0 = ~0;
				if(w)
					wincommit(w, t);
				else
					textcommit(t, TRUE);
				if(m.buttons & 1){
					textselect(t);
					if(w)
						winsettag(w);
					argtext = t;
					seltext = t;
					if(t->col)
						activecol = t->col;	/* button 1 only */
					if(t->w!=nil && t==&t->w->body)
						activewin = t->w;
				}else if(m.buttons & 2){
					if(textselect2(t, &q0, &q1, &argt))
						execute(t, q0, q1, FALSE, argt);
				}else if(m.buttons & 4){
					if(textselect3(t, &q0, &q1))
						look3(t, q0, q1, FALSE);
				}
				if(w)
					winunlock(w);
				goto Continue;
			}
    Continue:
			qunlock(&row.lk);
			break;
		}
	}
}
Exemple #23
0
void
mousethread(void *)
{
	Plumbmsg *pm;
	Mouse m;
	Text *t;
	int but;
	enum { MResize, MMouse, MPlumb, MRefresh, NMALT };
	static Alt alts[NMALT+1];

	threadsetname("mousethread");
	alts[MResize].c = mousectl->resizec;
	alts[MResize].v = nil;
	alts[MResize].op = CHANRCV;
	alts[MMouse].c = mousectl->c;
	alts[MMouse].v = &mousectl->Mouse;
	alts[MMouse].op = CHANRCV;
	alts[MPlumb].c = cplumb;
	alts[MPlumb].v = &pm;
	alts[MPlumb].op = CHANRCV;
	alts[MRefresh].c = crefresh;
	alts[MRefresh].v = nil;
	alts[MRefresh].op = CHANRCV;
	if(cplumb == nil)
		alts[MPlumb].op = CHANNOP;
	alts[NMALT].op = CHANEND;

	for(;;){
		qlock(&row);
		flushrefresh();
		qunlock(&row);
		flushimage(display, 1);
		switch(alt(alts)){
		case MResize:
			if(getwindow(display, Refnone) < 0)
				error("resized");
			scrlresize();
			tmpresize();
			rowresize(&row, screen->clipr);
			break;
		case MPlumb:
			plumblook(pm);
			plumbfree(pm);
			break;
		case MRefresh:
			break;
		case MMouse:
			m = mousectl->Mouse;
			if(m.buttons == 0)
				continue;

			qlock(&row);
			but = 0;
			if(m.buttons == 1)
				but = 1;
			else if(m.buttons == 2)
				but = 2;
			else if(m.buttons == 4)
				but = 3;

			if(m.buttons & (8|16)){
				if(m.buttons & 8)
					but = Kscrolloneup;
				else
					but = Kscrollonedown;
				rowwhich(&row, m.xy, but, TRUE);
			}else	if(but){
				t = rowwhich(&row, m.xy, but, FALSE);
				if(t)
					textmouse(t, m.xy, but);
			}
			qunlock(&row);
			break;
		}
	}
}
Exemple #24
0
gboolean xmms_fullscreen_enter(GtkWidget * win, gint * w, gint * h)
{
	gint i, close, how_close = -1, t, dummy;
	gboolean retval = FALSE;
	fullscreen_window_t *fwin;

	FULL_LOCK();
	fwin = getwindow(win);

	if (!fwin->display->is_full && !fwin->is_full
	    && fwin->display->can_full)
	{
		for (close = 0; close < fwin->display->num_modes; close++)
		{
			if ((fwin->display->modes[close]->hdisplay >= *w) &&
			    (fwin->display->modes[close]->vdisplay >= *h))
			{
				how_close = fwin->display->modes[close]->hdisplay - *w;
				break;
			}
		}

		for (i = close + 1; i < fwin->display->num_modes; i++)
		{
			if (fwin->display->modes[i]->vdisplay < *h)
				continue;
			t = fwin->display->modes[i]->hdisplay - *w;
			if (t >= 0 && t < how_close)
			{
				close = i;
				how_close = t;
			}
		}

		if (close < fwin->display->num_modes)
		{
			*w = fwin->display->modes[close]->hdisplay;
			*h = fwin->display->modes[close]->vdisplay;

			/* Save the old position/size */
			gdk_window_get_root_origin(fwin->window->window, &fwin->ox, &fwin->oy);
			gdk_window_get_size(fwin->window->window, &fwin->owidth, &fwin->oheight);

			/* Move it. */
			gdk_window_move_resize(fwin->window->window, 0, 0,
					       fwin->display->modes[close]->hdisplay,
					       fwin->display->modes[close]->vdisplay);

			/* Tell the WM not to mess with this window (no more decor) */
			gdk_window_hide(fwin->window->window);
			gdk_window_set_override_redirect(fwin->window->window, TRUE);
			gdk_window_show(fwin->window->window);

			/*
			 * XXX: HACK
			 * Something is ungrabbing the pointer shortly
			 * after the above unmap/override_redirect=TRUE/map
			 * is done.  I don't know what at this time, only
			 * that it's not XMMS, and that it's very very evil.
			 */
			gdk_flush();
			xmms_usleep(50000);

			/* Steal the keyboard/mouse */
			/* XXX: FIXME, use timeouts.. */
			for (t = 0; t < 10; t++)
			{
				dummy = gdk_pointer_grab(fwin->window->window,
							 TRUE, 0,
							 fwin->window->window,
							 NULL,
							 GDK_CURRENT_TIME);

				if (dummy == GrabSuccess)
					break;

				gtk_main_iteration_do(FALSE);
				xmms_usleep(10000);
			}
			gdk_keyboard_grab(fwin->window->window, TRUE,
					  GDK_CURRENT_TIME);

			/* Do the video mode switch.. */
			XF86VidModeSwitchToMode(fwin->display->display,
						DefaultScreen(fwin->display->display),
						fwin->display->modes[close]);

			XF86VidModeSetViewPort(fwin->display->display,
					       DefaultScreen(fwin->display->display),
					       0, 0);

			retval = TRUE;

			fwin->is_full = TRUE;
			fwin->display->is_full = TRUE;
		}
	}

	FULL_UNLOCK();

	return retval;
}