gryf/wmaker
1
0
Fork 0
mirror of https://github.com/gryf/wmaker.git synced 2025-12-19 04:20:27 +01:00
Code Issues Projects Releases Wiki Activity
Files
12b8b8ba58d99a9a53b90fde904a3d870dc61a0e
wmaker/src/switchpanel.c
kojima 12b8b8ba58 bug fix
2004-10-25 00:42:25 +00:00

715 lines
19 KiB
C
Raw Blame History

/*
* Window Maker window manager
*
* Copyright (c) 1997-2004 Alfredo K. Kojima
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
* USA.
*/
#include "wconfig.h"
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#ifdef SHAPE
#include <X11/extensions/shape.h>
extern Bool wShapeSupported;
#endif
#include "WindowMaker.h"
#include "screen.h"
#include "wcore.h"
#include "framewin.h"
#include "window.h"
#include "defaults.h"
#include "switchpanel.h"
#include "funcs.h"
#include "xinerama.h"
struct SwitchPanel {
WScreen *scr;
WMWindow *win;
WMFrame *iconBox;
WMArray *icons;
WMArray *images;
WMArray *windows;
RImage *bg;
int current;
int firstVisible;
int visibleCount;
WMLabel *label;
RImage *defIcon;
RImage *tileTmp;
RImage *tile;
WMFont *font;
WMColor *white;
};
extern WPreferences wPreferences;
#define BORDER_SPACE 10
#define ICON_SIZE 48
#define ICON_TILE_SIZE 64
#define LABEL_HEIGHT 25
#define SCREEN_BORDER_SPACING 2*20
#define SCROLL_STEPS (ICON_TILE_SIZE/2)
static int canReceiveFocus(WWindow *wwin)
{
if (wwin->frame->workspace != wwin->screen_ptr->current_workspace)
return 0;
if (!wwin->flags.mapped)
{
if (!wwin->flags.shaded && !wwin->flags.miniaturized && !wwin->flags.hidden)
return 0;
else
return -1;
}
if (WFLAGP(wwin, no_focusable))
return 0;
return 1;
}
static void changeImage(WSwitchPanel *panel, int index, int selected)
{
WMFrame *icon = WMGetFromArray(panel->icons, index);
RImage *image= WMGetFromArray(panel->images, index);
if (!panel->bg && !panel->tile) {
if (!selected)
WMSetFrameRelief(icon, WRFlat);
}
if (image && icon) {
RImage *back;
int opaq= 255;
RImage *tile;
WMPoint pos;
Pixmap p;
if (canReceiveFocus(WMGetFromArray(panel->windows, index)) < 0)
opaq= 50;
pos= WMGetViewPosition(WMWidgetView(icon));
back= panel->tileTmp;
if (panel->bg)
RCopyArea(back, panel->bg,
BORDER_SPACE+pos.x-panel->firstVisible*ICON_TILE_SIZE, BORDER_SPACE+pos.y,
back->width, back->height,
0, 0);
else
{
RColor color;
WMScreen *wscr= WMWidgetScreen(icon);
color.red= 255;
color.red = WMRedComponentOfColor(WMGrayColor(wscr))>>8;
color.green = WMGreenComponentOfColor(WMGrayColor(wscr))>>8;
color.blue = WMBlueComponentOfColor(WMGrayColor(wscr))>>8;
RFillImage(back, &color);
}
if (selected)
{
tile= panel->tile;
RCombineArea(back, tile, 0, 0, tile->width, tile->height,
(back->width - tile->width)/2, (back->height - tile->height)/2);
}
RCombineAreaWithOpaqueness(back, image, 0, 0, image->width, image->height,
(back->width - image->width)/2, (back->height - image->height)/2,
opaq);
RConvertImage(panel->scr->rcontext, back, &p);
XSetWindowBackgroundPixmap(dpy, WMWidgetXID(icon), p);
XClearWindow(dpy, WMWidgetXID(icon));
XFreePixmap(dpy, p);
}
if (!panel->bg && !panel->tile) {
if (selected)
WMSetFrameRelief(icon, WRSimple);
}
}
static RImage *scaleDownIfNeeded(RImage *image)
{
if (image && ((image->width - ICON_SIZE) > 2 || (image->height - ICON_SIZE) > 2)) {
RImage *nimage;
nimage= RScaleImage(image, ICON_SIZE, (image->height * ICON_SIZE / image->width));
RReleaseImage(image);
image= nimage;
}
return image;
}
static void addIconForWindow(WSwitchPanel *panel, WMWidget *parent, WWindow *wwin,
int x, int y)
{
WMFrame *icon= WMCreateFrame(parent);
RImage *image = NULL;
WMSetFrameRelief(icon, WRFlat);
WMResizeWidget(icon, ICON_TILE_SIZE, ICON_TILE_SIZE);
WMMoveWidget(icon, x, y);
if (!WFLAGP(wwin, always_user_icon) && wwin->net_icon_image)
image = RRetainImage(wwin->net_icon_image);
// Make this use a caching thing. When there are many windows,
// it's very likely that most of them are instances of the same thing,
// so caching them should get performance acceptable in these cases.
if (!image)
image = wDefaultGetImage(panel->scr, wwin->wm_instance, wwin->wm_class);
if (!image && !panel->defIcon) {
char *file = wDefaultGetIconFile(panel->scr, NULL, NULL, False);
if (file) {
char *path = FindImage(wPreferences.icon_path, file);
if (path) {
image = RLoadImage(panel->scr->rcontext, path, 0);
wfree(path);
}
}
if (image)
panel->defIcon= scaleDownIfNeeded(image);
image= NULL;
}
if (!image && panel->defIcon)
image= RRetainImage(panel->defIcon);
image= scaleDownIfNeeded(image);
WMAddToArray(panel->images, image);
WMAddToArray(panel->icons, icon);
}
static void scrollIcons(WSwitchPanel *panel, int delta)
{
int nfirst= panel->firstVisible + delta;
int i;
int count= WMGetArrayItemCount(panel->windows);
// int nx, ox;
// struct timeval tv1, tv2;
if (count <= panel->visibleCount)
return;
if (nfirst < 0)
nfirst= 0;
else if (nfirst >= count-panel->visibleCount)
nfirst= count-panel->visibleCount;
if (nfirst == panel->firstVisible)
return;
/*
ox = -panel->firstVisible * ICON_TILE_SIZE;
nx = -nfirst * ICON_TILE_SIZE;
for (i= 0; i < SCROLL_STEPS; i++) {
unsigned int diff;
gettimeofday(&tv1, NULL);
WMMoveWidget(panel->iconBox, (nx*i + ox*(SCROLL_STEPS-i))/(SCROLL_STEPS-1), 0);
XSync(dpy, False);
gettimeofday(&tv2, NULL);
diff = (tv2.tv_sec-tv1.tv_sec)*10000+(tv2.tv_usec-tv1.tv_usec)/100;
if (diff < 200)
wusleep(300-diff);
}
*/
WMMoveWidget(panel->iconBox, -nfirst*ICON_TILE_SIZE, 0);
panel->firstVisible= nfirst;
for (i= panel->firstVisible; i < panel->firstVisible+panel->visibleCount; i++) {
changeImage(panel, i, i == panel->current);
}
}
/*
* 0 1 2
* 3 4 5
* 6 7 8
*/
static RImage *assemblePuzzleImage(RImage **images, int width, int height)
{
RImage *img= RCreateImage(width, height, 1);
RImage *tmp;
int tw, th;
RColor color;
if (!img)
return NULL;
color.red= 0;
color.green= 0;
color.blue= 0;
color.alpha= 255;
RFillImage(img, &color);
tw= width-images[0]->width-images[2]->width;
th= height-images[0]->height-images[6]->height;
if (tw <= 0 || th <= 0) {
//XXX
return NULL;
}
/* top */
if (tw > 0) {
tmp= RSmoothScaleImage(images[1], tw, images[1]->height);
RCopyArea(img, tmp, 0, 0, tmp->width, tmp->height,
images[0]->width, 0);
RReleaseImage(tmp);
}
/* bottom */
if (tw > 0) {
tmp= RSmoothScaleImage(images[7], tw, images[7]->height);
RCopyArea(img, tmp, 0, 0, tmp->width, tmp->height,
images[6]->width, height-images[6]->height);
RReleaseImage(tmp);
}
/* left */
if (th > 0) {
tmp= RSmoothScaleImage(images[3], images[3]->width, th);
RCopyArea(img, tmp, 0, 0, tmp->width, tmp->height,
0, images[0]->height);
RReleaseImage(tmp);
}
/* right */
if (th > 0) {
tmp= RSmoothScaleImage(images[5], images[5]->width, th);
RCopyArea(img, tmp, 0, 0, tmp->width, tmp->height,
width-images[5]->width, images[2]->height);
RReleaseImage(tmp);
}
/* center */
if (tw > 0 && th > 0) {
tmp= RSmoothScaleImage(images[4], tw, th);
RCopyArea(img, tmp, 0, 0, tmp->width, tmp->height,
images[0]->width, images[0]->height);
RReleaseImage(tmp);
}
/* corners */
RCopyArea(img, images[0], 0, 0, images[0]->width, images[0]->height,
0, 0);
RCopyArea(img, images[2], 0, 0, images[2]->width, images[2]->height,
width-images[2]->width, 0);
RCopyArea(img, images[6], 0, 0, images[6]->width, images[6]->height,
0, height-images[6]->height);
RCopyArea(img, images[8], 0, 0, images[8]->width, images[8]->height,
width-images[8]->width, height-images[8]->height);
return img;
}
static RImage *createBackImage(WScreen *scr, int width, int height)
{
return assemblePuzzleImage(wPreferences.swbackImage, width, height);
}
static RImage *getTile(WSwitchPanel *panel)
{
RImage *stile;
if (!wPreferences.swtileImage)
return NULL;
stile = RScaleImage(wPreferences.swtileImage, ICON_TILE_SIZE, ICON_TILE_SIZE);
if (!stile)
return wPreferences.swtileImage;
return stile;
}
static void
drawTitle(WSwitchPanel *panel, int index, char *title)
{
char *ntitle;
int width= WMWidgetWidth(panel->win);
int x;
ntitle= ShrinkString(panel->font, title, width-2*BORDER_SPACE);
if (panel->bg) {
if (strcmp(ntitle, title)!=0)
x= BORDER_SPACE;
else
{
int w= WMWidthOfString(panel->font, ntitle, strlen(ntitle));
x= BORDER_SPACE+(index-panel->firstVisible)*ICON_TILE_SIZE + ICON_TILE_SIZE/2 - w/2;
if (x < BORDER_SPACE)
x= BORDER_SPACE;
else if (x + w > width-BORDER_SPACE)
x= width-BORDER_SPACE-w;
}
XClearWindow(dpy, WMWidgetXID(panel->win));
WMDrawString(panel->scr->wmscreen,
WMWidgetXID(panel->win),
panel->white, panel->font,
x, WMWidgetHeight(panel->win) - BORDER_SPACE - LABEL_HEIGHT + WMFontHeight(panel->font)/2,
ntitle, strlen(ntitle));
} else {
WMSetLabelText(panel->label, ntitle);
}
free(ntitle);
}
static WMArray *makeWindowListArray(WScreen *scr, WWindow *curwin, int workspace)
{
WMArray *windows= WMCreateArray(10);
int fl;
WWindow *wwin;
for (fl= 0; fl < 2; fl++) {
for (wwin= curwin; wwin; wwin= wwin->prev) {
if (((!fl && canReceiveFocus(wwin) > 0) || (fl && canReceiveFocus(wwin) < 0)) &&
(!WFLAGP(wwin, skip_window_list) || wwin->flags.internal_window)) {
WMAddToArray(windows, wwin);
}
}
wwin = curwin;
/* start over from the beginning of the list */
while (wwin->next)
wwin = wwin->next;
for (wwin= curwin; wwin && wwin != curwin; wwin= wwin->prev) {
if (((!fl && canReceiveFocus(wwin) > 0) || (fl && canReceiveFocus(wwin) < 0)) &&
(!WFLAGP(wwin, skip_window_list) || wwin->flags.internal_window)) {
WMAddToArray(windows, wwin);
}
}
}
return windows;
}
WSwitchPanel *wInitSwitchPanel(WScreen *scr, WWindow *curwin, int workspace)
{
WWindow *wwin;
WSwitchPanel *panel= wmalloc(sizeof(WSwitchPanel));
WMFrame *viewport;
int i;
int width, height;
int iconsThatFitCount;
int count;
memset(panel, 0, sizeof(WSwitchPanel));
panel->scr= scr;
panel->windows= makeWindowListArray(scr, curwin, workspace);
count= WMGetArrayItemCount(panel->windows);
if (count == 0) {
WMFreeArray(panel->windows);
wfree(panel);
return NULL;
}
width= ICON_TILE_SIZE*count;
iconsThatFitCount= count;
if (width > WMScreenWidth(scr->wmscreen)) {
iconsThatFitCount = (WMScreenWidth(scr->wmscreen)-SCREEN_BORDER_SPACING)/ICON_TILE_SIZE;
width= iconsThatFitCount*ICON_TILE_SIZE;
}
panel->visibleCount= iconsThatFitCount;
height= LABEL_HEIGHT + ICON_TILE_SIZE;
panel->tileTmp= RCreateImage(ICON_TILE_SIZE, ICON_TILE_SIZE, 1);
panel->tile= getTile(panel);
if (panel->tile && wPreferences.swbackImage[8]) {
panel->bg= createBackImage(scr, width+2*BORDER_SPACE, height+2*BORDER_SPACE);
}
if (!panel->tileTmp || !panel->tile) {
if (panel->bg)
RReleaseImage(panel->bg);
panel->bg= NULL;
if (panel->tile)
RReleaseImage(panel->tile);
panel->tile= NULL;
if (panel->tileTmp)
RReleaseImage(panel->tileTmp);
panel->tileTmp= NULL;
}
panel->white= WMWhiteColor(scr->wmscreen);
panel->font= WMBoldSystemFontOfSize(scr->wmscreen, 12);
panel->icons= WMCreateArray(count);
panel->images= WMCreateArray(count);
panel->win = WMCreateWindow(scr->wmscreen, "");
if (!panel->bg) {
WMFrame *frame = WMCreateFrame(panel->win);
WMSetFrameRelief(frame, WRSimple);
WMSetViewExpandsToParent(WMWidgetView(frame), 0, 0, 0, 0);
panel->label = WMCreateLabel(panel->win);
WMResizeWidget(panel->label, width, LABEL_HEIGHT);
WMMoveWidget(panel->label, BORDER_SPACE, BORDER_SPACE+ICON_TILE_SIZE+5);
WMSetLabelRelief(panel->label, WRSimple);
WMSetWidgetBackgroundColor(panel->label, WMDarkGrayColor(scr->wmscreen));
WMSetLabelFont(panel->label, panel->font);
WMSetLabelTextColor(panel->label, panel->white);
height+= 5;
}
WMResizeWidget(panel->win, width + 2*BORDER_SPACE, height + 2*BORDER_SPACE);
viewport= WMCreateFrame(panel->win);
WMResizeWidget(viewport, width, ICON_TILE_SIZE);
WMMoveWidget(viewport, BORDER_SPACE, BORDER_SPACE);
WMSetFrameRelief(viewport, WRFlat);
panel->iconBox= WMCreateFrame(viewport);
WMMoveWidget(panel->iconBox, 0, 0);
WMResizeWidget(panel->iconBox, ICON_TILE_SIZE*count, ICON_TILE_SIZE);
WMSetFrameRelief(panel->iconBox, WRFlat);
WM_ITERATE_ARRAY(panel->windows, wwin, i) {
addIconForWindow(panel, panel->iconBox, wwin, i*ICON_TILE_SIZE, 0);
}
WMMapSubwidgets(panel->win);
WMRealizeWidget(panel->win);
WM_ITERATE_ARRAY(panel->windows, wwin, i) {
changeImage(panel, i, 0);
}
if (panel->bg) {
Pixmap pixmap, mask;
RConvertImageMask(scr->rcontext, panel->bg, &pixmap, &mask, 250);
XSetWindowBackgroundPixmap(dpy, WMWidgetXID(panel->win), pixmap);
#ifdef SHAPE
if (mask && wShapeSupported)
XShapeCombineMask(dpy, WMWidgetXID(panel->win),
ShapeBounding, 0, 0, mask, ShapeSet);
#endif
if (pixmap)
XFreePixmap(dpy, pixmap);
if (mask)
XFreePixmap(dpy, mask);
}
{
WMPoint center;
center= wGetPointToCenterRectInHead(scr, wGetHeadForPointerLocation(scr),
width+2*BORDER_SPACE, height+2*BORDER_SPACE);
WMMoveWidget(panel->win, center.x, center.y);
}
panel->current= WMGetFirstInArray(panel->windows, curwin);
if (panel->current >= 0)
changeImage(panel, panel->current, 1);
WMMapWidget(panel->win);
return panel;
}
void wSwitchPanelDestroy(WSwitchPanel *panel)
{
int i;
RImage *image;
if (panel->win)
WMUnmapWidget(panel->win);
if (panel->images) {
WM_ITERATE_ARRAY(panel->images, image, i) {
if (image)
RReleaseImage(image);
}
WMFreeArray(panel->images);
}
if (panel->win)
WMDestroyWidget(panel->win);
if (panel->icons)
WMFreeArray(panel->icons);
WMFreeArray(panel->windows);
if (panel->defIcon)
RReleaseImage(panel->defIcon);
if (panel->tile)
RReleaseImage(panel->tile);
if (panel->tileTmp)
RReleaseImage(panel->tileTmp);
if (panel->bg)
RReleaseImage(panel->bg);
if (panel->font)
WMReleaseFont(panel->font);
wfree(panel);
}
WWindow *wSwitchPanelSelectNext(WSwitchPanel *panel, int back)
{
WWindow *wwin;
int count = WMGetArrayItemCount(panel->windows);
if (count == 0)
return NULL;
if (panel->win)
changeImage(panel, panel->current, 0);
if (back)
panel->current--;
else
panel->current++;
wwin = WMGetFromArray(panel->windows, (count+panel->current)%count);
if (back)
{
if (panel->current < 0)
scrollIcons(panel, count);
else if (panel->current < panel->firstVisible)
scrollIcons(panel, -1);
}
else
{
if (panel->current >= count)
scrollIcons(panel, -count);
else if (panel->current - panel->firstVisible >= panel->visibleCount)
scrollIcons(panel, 1);
}
panel->current= (count+panel->current)%count;
if (panel->win) {
drawTitle(panel, panel->current, wwin->frame->title);
changeImage(panel, panel->current, 1);
}
return wwin;
}
WWindow *wSwitchPanelSelectFirst(WSwitchPanel *panel, int back)
{
WWindow *wwin;
int count = WMGetArrayItemCount(panel->windows);
if (count == 0)
return NULL;
if (panel->win)
changeImage(panel, panel->current, 0);
if (back) {
panel->current = count-1;
scrollIcons(panel, count);
} else {
panel->current = 0;
scrollIcons(panel, -count);
}
wwin = WMGetFromArray(panel->windows, panel->current);
if (panel->win) {
drawTitle(panel, panel->current, wwin->frame->title);
changeImage(panel, panel->current, 1);
}
return wwin;
}
WWindow *wSwitchPanelHandleEvent(WSwitchPanel *panel, XEvent *event)
{
WMFrame *icon;
int i;
if (!panel->win)
return NULL;
if (event->type == MotionNotify) {
int focus= -1;
WM_ITERATE_ARRAY(panel->icons, icon, i) {
if (WMWidgetXID(icon) == event->xmotion.window) {
focus= i;
break;
}
}
if (focus < 0)
focus= 0;
if (focus >= 0 && panel->current != focus) {
WWindow *wwin;
changeImage(panel, panel->current, 0);
changeImage(panel, focus, 1);
panel->current= focus;
wwin= WMGetFromArray(panel->windows, focus);
drawTitle(panel, panel->current, wwin->frame->title);
return wwin;
}
}
return NULL;
}
Window wSwitchPanelGetWindow(WSwitchPanel *swpanel)
{
if (!swpanel->win)
return None;
return WMWidgetXID(swpanel->win);
}
Reference in New Issue View Git Blame Copy Permalink