1371 lines
37 KiB
C
1371 lines
37 KiB
C
/* $Id: wmpager.c,v 1.4 2002/08/16 17:22:26 essmann Exp $
|
|
*
|
|
* Copyright (c) 2001 Bruno Essmann <essmann@users.sourceforge.net>
|
|
* All rights reserved.
|
|
*/
|
|
|
|
#include <X11/Xlib.h>
|
|
#include <X11/Xutil.h>
|
|
#include <X11/Xatom.h>
|
|
#include <X11/xpm.h>
|
|
#include <X11/extensions/shape.h>
|
|
#include <sys/time.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "buttons.xpm"
|
|
#include "screen.xpm"
|
|
|
|
/*
|
|
* Constants
|
|
*/
|
|
|
|
#define AUTHOR "Bruno Essmann <essmann@users.sourceforge.net>"
|
|
#define APPLICATION "wmpager"
|
|
#define VERSION "1.2"
|
|
#define BUILD_REV "$Revision: 1.4 $"
|
|
#define BUILD_DATE "$Date: 2002/08/16 17:22:26 $"
|
|
|
|
#define XA_WIN_WORKSPACE "_WIN_WORKSPACE"
|
|
#define XA_WIN_WORKSPACE_NAMES "_WIN_WORKSPACE_NAMES"
|
|
|
|
#define WMPAGER_ENV "WMPAGER"
|
|
#define WMPAGER_DEFAULT_INSTALL_DIR "/usr/local/share/wmpager/"
|
|
#define WMPAGER_USER_DIR ".wmpager/"
|
|
|
|
#define TOOLTIP_SUPPORT 1
|
|
#define TOOLTIP_FONT "-*-helvetica-bold-r-normal-*-12-*-*-*-*-*-*-*"
|
|
#define TOOLTIP_OUTSIDE 0
|
|
#define TOOLTIP_SHOW_DELAY 750
|
|
#define TOOLTIP_RESHOW_DELAY 1500
|
|
|
|
#define TOOLTIP_SPACE 12
|
|
#define TOOLTIP_TOP 0
|
|
#define TOOLTIP_BOTTOM 1
|
|
#define TOOLTIP_LEFT 0
|
|
#define TOOLTIP_RIGHT 2
|
|
|
|
/*
|
|
* Prototypes
|
|
*/
|
|
|
|
void usage (int bVerbose);
|
|
void info ();
|
|
void setVerbose (int bVerbose);
|
|
int isVerbose ();
|
|
|
|
void initApplicationName (char* szApplicationName);
|
|
char* getApplicationName ();
|
|
|
|
void initDisplay (char* szDisplay);
|
|
void destroyDisplay ();
|
|
Display* getDisplay ();
|
|
|
|
Pixel getWhitePixel ();
|
|
Pixel getBlackPixel ();
|
|
int getDefaultScreen ();
|
|
int getDefaultDepth ();
|
|
void initWindow (int nArgc, char** szArgv);
|
|
void destroyWindow ();
|
|
GC getWindowGraphics ();
|
|
GC getMainGraphics ();
|
|
void initWindowMask (char* szInstallDir, char* szButtonTheme);
|
|
void redrawWindow ();
|
|
void getWindowOrigin (Window w, int* nX, int* nY);
|
|
|
|
void loop (long nTooltipShowDelay, long nTooltipReshowDelay);
|
|
|
|
void initButtons (int nButtons, int nColumns, int nRows);
|
|
int getButtonCount ();
|
|
int getButtonRowCount ();
|
|
int getButtonColumnCount ();
|
|
int getButtonWidth ();
|
|
int getButtonHeight ();
|
|
int getButtonAt (int nLocationX, int nLocationY);
|
|
void getButtonLocation (int nButton, int* nLocationX, int* nLocationY);
|
|
|
|
void initTime ();
|
|
long currentTimeMillis ();
|
|
|
|
void initScreens ();
|
|
int getScreenCount ();
|
|
char* getScreenName (int nScreen);
|
|
int getCurrentScreen ();
|
|
void setCurrentScreen (int nCurrentScreen);
|
|
void gotoScreen (int nWorkspace);
|
|
|
|
void initTooltip (int bTooltipSupport, char* szFontName, int bTooltipOutside);
|
|
void destroyTooltip ();
|
|
int hasTooltipSupport ();
|
|
void showTooltip (int nButton, int nMouseX, int nMouseY);
|
|
void hideTooltip ();
|
|
int hasTooltip ();
|
|
void drawTooltipBalloon (Pixmap pix, GC gc, int x, int y, int w, int h, int side);
|
|
Pixmap createTooltipPixmap (int width, int height, int side, Pixmap *mask);
|
|
|
|
/*
|
|
* Main
|
|
*/
|
|
|
|
int main (int nArgc, char** szArgv) {
|
|
char* szDisplay= NULL;
|
|
char* szTheme= NULL;
|
|
char* szInstallDir= NULL;
|
|
char* szTooltipFont= TOOLTIP_FONT;
|
|
long nTooltipShowDelay= TOOLTIP_SHOW_DELAY;
|
|
long nTooltipReshowDelay= TOOLTIP_RESHOW_DELAY;
|
|
int nWorkspaces= -1;
|
|
int bVerbose= 0;
|
|
int nSizeX= -1, nSizeY= -1;
|
|
int bTooltipSupport= TOOLTIP_SUPPORT;
|
|
int bTooltipOutside= TOOLTIP_OUTSIDE;
|
|
int i;
|
|
initApplicationName(szArgv[0]);
|
|
/* we no longer use the WMPAGER environment variable
|
|
* szInstallDir= (char*) getenv(WMPAGER_ENV);
|
|
* instead we simply use a default installation directory
|
|
*/
|
|
szInstallDir= WMPAGER_DEFAULT_INSTALL_DIR;
|
|
i= 1;
|
|
while (i < nArgc) {
|
|
if (strcmp("-h", szArgv[i]) == 0 || strcmp("--help", szArgv[i]) == 0) {
|
|
usage(1);
|
|
} else if (strcmp("-v", szArgv[i]) == 0 || strcmp("--verbose", szArgv[i]) == 0) {
|
|
bVerbose= 1;
|
|
} else if (strcmp("-w", szArgv[i]) == 0 || strcmp("--workspaces", szArgv[i]) == 0) {
|
|
i+= 1;
|
|
if (i < nArgc) {
|
|
sscanf(szArgv[i], "%d", &nWorkspaces);
|
|
if (nWorkspaces <= 0 || nWorkspaces > 9) {
|
|
fprintf(stderr, "%s: illegal number of workspaces '%s' for option '%s' (has to be 1-9)\n\n", getApplicationName(), szArgv[i], szArgv[i-1]);
|
|
usage(0);
|
|
}
|
|
} else {
|
|
fprintf(stderr, "%s: workspace count expected for '%s'\n\n", getApplicationName(), szArgv[i-1]);
|
|
usage(0);
|
|
}
|
|
} else if (strcmp("-s", szArgv[i]) == 0 || strcmp("--size", szArgv[i]) == 0) {
|
|
i+= 1;
|
|
if (i < nArgc) {
|
|
sscanf(szArgv[i], "%dx%d", &nSizeX, &nSizeY);
|
|
if (nSizeX <= 0 || nSizeX > 3 || nSizeY <= 0 || nSizeY > 3) {
|
|
fprintf(stderr, "%s: illegal size '%s' for option '%s' (has to be 1x1 .. 3x3)\n\n", getApplicationName(), szArgv[i], szArgv[i-1]);
|
|
usage(0);
|
|
}
|
|
} else {
|
|
fprintf(stderr, "%s: size argument expected for '%s'\n\n", getApplicationName(), szArgv[i-1]);
|
|
usage(0);
|
|
}
|
|
} else if (strcmp("-i", szArgv[i]) == 0 || strcmp("--installdir", szArgv[i]) == 0) {
|
|
i+= 1;
|
|
if (i < nArgc) {
|
|
struct stat buf;
|
|
szInstallDir= szArgv[i];
|
|
if (stat(szInstallDir, &buf) != 0) {
|
|
fprintf(stderr, "%s: cannot access installation directory '%s'\n\n", getApplicationName(), szArgv[i]);
|
|
usage(0);
|
|
}
|
|
} else {
|
|
fprintf(stderr, "%s: display argument expected for '%s'\n\n", getApplicationName(), szArgv[i-1]);
|
|
usage(0);
|
|
}
|
|
} else if (strcmp("--disable-tooltips", szArgv[i]) == 0) {
|
|
bTooltipSupport= 0;
|
|
} else if (strcmp("--tooltip-outside", szArgv[i]) == 0) {
|
|
bTooltipOutside= 1;
|
|
} else if (strcmp("--tooltip-font", szArgv[i]) == 0) {
|
|
i+= 1;
|
|
if (i < nArgc) {
|
|
szTooltipFont= szArgv[i];
|
|
} else {
|
|
fprintf(stderr, "%s: font argument expected for '%s'\n\n", getApplicationName(), szArgv[i-1]);
|
|
usage(0);
|
|
}
|
|
} else if (strcmp("--tooltip-delay", szArgv[i]) == 0) {
|
|
i+= 1;
|
|
if (i < nArgc) {
|
|
long nDelay= -1;
|
|
sscanf(szArgv[i], "%ld", &nDelay);
|
|
if (nDelay < 0) {
|
|
fprintf(stderr, "%s: illegal tooltip delay '%s' for option '%s'\n\n", getApplicationName(), szArgv[i], szArgv[i-1]);
|
|
usage(0);
|
|
}
|
|
nTooltipShowDelay= nDelay;
|
|
} else {
|
|
fprintf(stderr, "%s: delay argument expected for '%s'\n\n", getApplicationName(), szArgv[i-1]);
|
|
usage(0);
|
|
}
|
|
} else if (strcmp("--tooltip-reshow", szArgv[i]) == 0) {
|
|
i+= 1;
|
|
if (i < nArgc) {
|
|
long nDelay= -1;
|
|
sscanf(szArgv[i], "%ld", &nDelay);
|
|
if (nDelay < 0) {
|
|
fprintf(stderr, "%s: illegal tooltip delay '%s' for option '%s'\n\n", getApplicationName(), szArgv[i], szArgv[i-1]);
|
|
usage(0);
|
|
}
|
|
nTooltipReshowDelay= nDelay;
|
|
} else {
|
|
fprintf(stderr, "%s: delay argument expected for '%s'\n\n", getApplicationName(), szArgv[i-1]);
|
|
usage(0);
|
|
}
|
|
} else if (strcmp("-d", szArgv[i]) == 0 || strcmp("--display", szArgv[i]) == 0) {
|
|
i+= 1;
|
|
if (i < nArgc) {
|
|
szDisplay= szArgv[i];
|
|
} else {
|
|
fprintf(stderr, "%s: display argument expected for '%s'\n\n", getApplicationName(), szArgv[i-1]);
|
|
usage(0);
|
|
}
|
|
} else if (strcmp("-t", szArgv[i]) == 0 || strcmp("--theme", szArgv[i]) == 0) {
|
|
i+= 1;
|
|
if (i < nArgc) {
|
|
szTheme= szArgv[i];
|
|
} else {
|
|
fprintf(stderr, "%s: theme argument expected for '%s'\n\n", getApplicationName(), szArgv[i-1]);
|
|
usage(0);
|
|
}
|
|
} else {
|
|
fprintf(stderr, "%s: unknown option '%s'\n\n", getApplicationName(), szArgv[i]);
|
|
usage(0);
|
|
}
|
|
i+= 1;
|
|
}
|
|
setVerbose(bVerbose);
|
|
if (isVerbose()) {
|
|
char* szRealDisplay= (szDisplay == NULL) ? (char*) getenv("DISPLAY") : szDisplay;
|
|
if (szRealDisplay == NULL) {
|
|
szRealDisplay= "localhost:0.0";
|
|
}
|
|
info();
|
|
fprintf(
|
|
stdout,
|
|
"[ ] startup options:\n" \
|
|
"[ ] - verbose= true\n" \
|
|
"[ ] - display= '%s'\n" \
|
|
"[ ] - installdir= '%s'\n" \
|
|
"[ ] - theme= '%s'\n" \
|
|
"[ ] - workspaces= '%d'\n" \
|
|
"[ ] - size= '%dx%d'\n" \
|
|
"[ ] - tooltip support= %s\n" \
|
|
"[ ] - tooltip font= %s\n" \
|
|
"[ ] - tooltip show delay= %ld\n" \
|
|
"[ ] - tooltip reshow delay= %ld\n" \
|
|
"[ ] - tooltip outside= %s\n",
|
|
szRealDisplay,
|
|
szInstallDir == NULL ? "<undefined>" : szInstallDir,
|
|
szTheme == NULL ? "<built-in>" : szTheme,
|
|
nWorkspaces,
|
|
nSizeX, nSizeY,
|
|
bTooltipSupport ? "true" : "false",
|
|
szTooltipFont,
|
|
nTooltipShowDelay, nTooltipReshowDelay,
|
|
bTooltipOutside ? "true" : "false"
|
|
);
|
|
}
|
|
initTime();
|
|
initDisplay(szDisplay);
|
|
initWindow(nArgc, szArgv);
|
|
initScreens();
|
|
initButtons(nWorkspaces, nSizeX, nSizeY);
|
|
initWindowMask(szInstallDir, szTheme);
|
|
initTooltip(bTooltipSupport, szTooltipFont, bTooltipOutside);
|
|
loop(nTooltipShowDelay, nTooltipReshowDelay);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Verbose
|
|
*/
|
|
|
|
static int _bVerbose;
|
|
|
|
void setVerbose (int bVerbose) {
|
|
_bVerbose= bVerbose;
|
|
}
|
|
|
|
int isVerbose () {
|
|
return _bVerbose;
|
|
}
|
|
|
|
/*
|
|
* Usage
|
|
*/
|
|
|
|
#define USAGE \
|
|
"usage: %s [options]\n\n" \
|
|
"where options include:\n" \
|
|
" -h --help display usage and version information\n" \
|
|
" -v --verbose verbose message output\n" \
|
|
" -d --display <name> the display to use (defaults to the\n" \
|
|
" 'DISPLAY' environment variable)\n" \
|
|
" -s --size <w>x<h> number of buttons (default depends on the\n" \
|
|
" number of workspaces you have, i.e. 2x2 for 4\n" \
|
|
" workspaces, 2x3 for 6, maximum is 3x3)\n" \
|
|
" -w --workspaces <count> number of workspace buttons to display\n" \
|
|
" (default is the number of workspaces you have,\n" \
|
|
" maximum is 9)\n" \
|
|
" -t --theme <theme.xpm> the button theme to use, extension\n" \
|
|
" '.xpm' is optional, for more information about\n" \
|
|
" themes see docu (default is the built-in theme)\n" \
|
|
" -i --installdir <dir> specifies the installation directory location,\n" \
|
|
" this location is automatically searched for themes\n" \
|
|
" (defaults to the '/usr/local/share/wmpager/'\n" \
|
|
" and the user specific '~/.wmpager' directory)\n" \
|
|
" --disable-tooltips do not display any tooltip windows\n" \
|
|
" --tooltip-font <font> use the specified font as tooltip font\n" \
|
|
" (default is helvetica, bold, roman, 12 point)\n" \
|
|
" --tooltip-delay <millis> set the delay before the tooltip window\n" \
|
|
" is popped up (default is 750 milliseconds)\n" \
|
|
" --tooltip-reshow <millis> set the tooltip reshow delay (triggered\n" \
|
|
" when moving from button to button (default is\n" \
|
|
" 1500 milliseconds)\n" \
|
|
" --tooltip-outside display tooltip window outside of docklet\n"
|
|
|
|
void usage (int bVerbose) {
|
|
if (bVerbose) {
|
|
info();
|
|
fprintf(stdout, USAGE, getApplicationName());
|
|
exit(0);
|
|
} else {
|
|
fprintf(stderr, USAGE, getApplicationName());
|
|
exit(-1);
|
|
}
|
|
}
|
|
|
|
void info () {
|
|
char* szRev= strdup(BUILD_REV);
|
|
char* szDate= strdup(BUILD_DATE);
|
|
szRev= &szRev[11];
|
|
szRev[strlen(szRev) - 2]= '\0';
|
|
szDate= &szDate[7];
|
|
szDate[strlen(szDate) - 2]= '\0';
|
|
fprintf(stdout, "%s %s (build %s, %s)\n\n", APPLICATION, VERSION, szRev, szDate);
|
|
}
|
|
|
|
/*
|
|
* Application
|
|
*/
|
|
|
|
static char* _szApplicationName;
|
|
|
|
char* getApplicationName () {
|
|
return _szApplicationName;
|
|
}
|
|
|
|
void initApplicationName (char* szApplicationName) {
|
|
if (szApplicationName == NULL) {
|
|
_szApplicationName= APPLICATION;
|
|
} else {
|
|
_szApplicationName= strdup(szApplicationName);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Display
|
|
*/
|
|
|
|
static Display* _display;
|
|
|
|
Display* getDisplay () {
|
|
return _display;
|
|
}
|
|
|
|
void destroyDisplay () {
|
|
XCloseDisplay(getDisplay());
|
|
}
|
|
|
|
void initDisplay (char* szDisplay) {
|
|
if (szDisplay == NULL && ((char*) getenv("DISPLAY")) == NULL) {
|
|
szDisplay= ":0.0";
|
|
}
|
|
if (isVerbose()) {
|
|
char* szRealDisplay= (szDisplay == NULL) ? (char*) getenv("DISPLAY") : szDisplay;
|
|
if (szRealDisplay == NULL) {
|
|
szRealDisplay= "localhost:0.0";
|
|
}
|
|
fprintf(stdout, "[%8ld] initializing display '%s'\n", currentTimeMillis(), szRealDisplay);
|
|
}
|
|
_display= XOpenDisplay(szDisplay);
|
|
if (_display == NULL) {
|
|
fprintf(
|
|
stderr,
|
|
"%s: couldn't open display '%s'.\n",
|
|
getApplicationName(),
|
|
(szDisplay == NULL) ? ((char*) getenv("DISPLAY")) : szDisplay
|
|
);
|
|
exit(-1);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Window
|
|
*/
|
|
|
|
static int _nDefaultScreen, _nDefaultDepth;
|
|
static Window _wRoot, _wMain, _wIcon;
|
|
static GC _gcMain, _gcWindow;
|
|
static XpmAttributes _attrButtonTheme;
|
|
static Pixmap _pButtonTheme, _pButtonThemeMask;
|
|
static XpmAttributes _attrWindow;
|
|
static Pixmap _pWindow, _pWindowMask;
|
|
static Pixel _pWhite, _pBlack;
|
|
|
|
Pixel getWhitePixel () {
|
|
return _pWhite;
|
|
}
|
|
|
|
Pixel getBlackPixel () {
|
|
return _pBlack;
|
|
}
|
|
|
|
int getDefaultScreen () {
|
|
return _nDefaultScreen;
|
|
}
|
|
|
|
int getDefaultDepth () {
|
|
return _nDefaultDepth;
|
|
}
|
|
|
|
Window getRootWindow () {
|
|
return _wRoot;
|
|
}
|
|
|
|
Window getMainWindow () {
|
|
return _wMain;
|
|
}
|
|
|
|
Window getIconWindow () {
|
|
return _wIcon;
|
|
}
|
|
|
|
GC getMainGraphics () {
|
|
return _gcMain;
|
|
}
|
|
|
|
GC getWindowGraphics () {
|
|
return _gcWindow;
|
|
}
|
|
|
|
void initWindow (int nArgc, char** szArgv) {
|
|
char* szApplicationName= getApplicationName();
|
|
Display* display= getDisplay();
|
|
XSizeHints *xsizehints;
|
|
XWMHints* xwmhints;
|
|
XClassHint* xclasshint;
|
|
XTextProperty* xtApplication;
|
|
XGCValues xgcMain;
|
|
|
|
if (isVerbose()) {
|
|
fprintf(stdout, "[%8ld] initializing application window\n", currentTimeMillis());
|
|
}
|
|
|
|
_nDefaultScreen= DefaultScreen(display);
|
|
_nDefaultDepth= DefaultDepth(display, _nDefaultScreen);
|
|
_wRoot= RootWindow(display, _nDefaultScreen);
|
|
|
|
XSelectInput(display, _wRoot, PropertyChangeMask);
|
|
|
|
_pWhite= WhitePixel(display, _nDefaultScreen);
|
|
_pBlack= BlackPixel(display, _nDefaultScreen);
|
|
|
|
xsizehints= XAllocSizeHints();
|
|
xsizehints->flags= USSize | USPosition;
|
|
xsizehints->width= xsizehints->height= 64;
|
|
|
|
_wMain= XCreateSimpleWindow(display, _wRoot, 0, 0, 64, 64, 5, _pWhite, _pBlack);
|
|
if (_wMain == 0) {
|
|
fprintf(stderr, "Cannot create main window.\n");
|
|
exit(-1);
|
|
}
|
|
|
|
_wIcon= XCreateSimpleWindow(display, _wMain, 0, 0, 64, 64, 5, _pWhite, _pBlack);
|
|
if (_wIcon == 0) {
|
|
fprintf(stderr, "Cannot create icon window.\n");
|
|
exit(-1);
|
|
}
|
|
|
|
xwmhints= XAllocWMHints();
|
|
xwmhints->flags= WindowGroupHint | IconWindowHint | StateHint;
|
|
xwmhints->icon_window= _wIcon;
|
|
xwmhints->window_group= _wMain;
|
|
xwmhints->initial_state= WithdrawnState;
|
|
XSetWMHints(display, _wMain, xwmhints);
|
|
|
|
xclasshint= XAllocClassHint();
|
|
xclasshint->res_name= APPLICATION;
|
|
xclasshint->res_class= APPLICATION;
|
|
XSetClassHint(display, _wMain, xclasshint);
|
|
|
|
XSetWMNormalHints(display, _wMain, xsizehints);
|
|
|
|
xtApplication= (XTextProperty*) malloc(sizeof(XTextProperty));
|
|
if (XStringListToTextProperty(&szApplicationName, 1, xtApplication) == 0) {
|
|
fprintf(stderr, "Cannot set window title.\n");
|
|
exit(-1);
|
|
}
|
|
XSetWMName(display, _wMain, xtApplication);
|
|
|
|
_gcMain= XCreateGC(display, _wMain, (GCForeground | GCBackground), &xgcMain);
|
|
if (_gcMain == NULL) {
|
|
fprintf(stderr, "Cannot create graphics context.\n");
|
|
exit(-1);
|
|
}
|
|
|
|
XSelectInput(display, _wMain, ExposureMask | ButtonPressMask | PointerMotionMask | StructureNotifyMask | LeaveWindowMask);
|
|
XSelectInput(display, _wIcon, ExposureMask | ButtonPressMask | PointerMotionMask | StructureNotifyMask | LeaveWindowMask);
|
|
|
|
XSetCommand(display, _wMain, szArgv, nArgc);
|
|
|
|
XMapWindow(display, _wMain);
|
|
}
|
|
|
|
void destroyWindow () {
|
|
XFreeGC(getDisplay(), getWindowGraphics());
|
|
XFreeGC(getDisplay(), getMainGraphics());
|
|
XDestroyWindow(getDisplay(), getMainWindow());
|
|
XDestroyWindow(getDisplay(), getIconWindow());
|
|
}
|
|
|
|
void initWindowMask (char* szInstallDir, char* szButtonTheme) {
|
|
Display* display= getDisplay();
|
|
GC gc;
|
|
Window wRoot= getRootWindow();
|
|
Window wMain= getMainWindow();
|
|
Window wIcon= getIconWindow();
|
|
XGCValues xgc, xgcWindow;
|
|
Pixmap pOpaque, pTransparent, pMask;
|
|
char* mask= (char*) malloc(512);
|
|
int i;
|
|
|
|
if (isVerbose()) {
|
|
fprintf(stdout, "[%8ld] initializing window mask\n", currentTimeMillis());
|
|
}
|
|
for (i= 0; i < 512; i++) {
|
|
mask[i]= 0x00;
|
|
}
|
|
pTransparent= XCreateBitmapFromData(display, wRoot, mask, 64, 64);
|
|
if (pTransparent == 0) {
|
|
fprintf(stderr, "%s: couldn't create window mask (transparent).\n", getApplicationName());
|
|
exit(-1);
|
|
}
|
|
pMask= XCreateBitmapFromData(display, wRoot, mask, 64, 64);
|
|
if (pMask == 0) {
|
|
fprintf(stderr, "%s: couldn't create window mask (mask buffer).\n", getApplicationName());
|
|
exit(-1);
|
|
}
|
|
|
|
for (i= 0; i < 512; i++) {
|
|
mask[i]= 0xff;
|
|
}
|
|
pOpaque= XCreateBitmapFromData(display, wRoot, mask, 64, 64);
|
|
if (pOpaque == 0) {
|
|
fprintf(stderr, "%s: couldn't create window mask (opaque).\n", getApplicationName());
|
|
exit(-1);
|
|
}
|
|
|
|
gc= XCreateGC(display, pMask, (GCForeground | GCBackground), &xgc);
|
|
if (gc == NULL) {
|
|
fprintf(stderr, "%s: couldn't create window mask (mask graphics).\n", getApplicationName());
|
|
exit(-1);
|
|
}
|
|
for (i= 0; i < getButtonCount(); i++) {
|
|
int nButtonX, nButtonY;
|
|
getButtonLocation(i, &nButtonX, &nButtonY);
|
|
XCopyArea(display, pOpaque, pMask, gc, nButtonX, nButtonY, getButtonWidth(), getButtonHeight(), nButtonX, nButtonY);
|
|
}
|
|
|
|
XFreePixmap(display, pOpaque);
|
|
XFreePixmap(display, pTransparent);
|
|
XFreeGC(display, gc);
|
|
|
|
XShapeCombineMask(display, wMain, ShapeBounding, 0, 0, pMask, ShapeSet);
|
|
XShapeCombineMask(display, wIcon, ShapeBounding, 0, 0, pMask, ShapeSet);
|
|
|
|
if (isVerbose()) {
|
|
fprintf(stdout, "[%8ld] initializing button theme '%s'\n", currentTimeMillis(),
|
|
szButtonTheme == NULL ? "<built-in>" : szButtonTheme);
|
|
}
|
|
|
|
_attrButtonTheme.valuemask|= (XpmReturnPixels | XpmReturnExtensions);
|
|
if (szButtonTheme == NULL) {
|
|
if (
|
|
XpmCreatePixmapFromData(
|
|
display, wRoot, buttons_xpm, &_pButtonTheme, &_pButtonThemeMask, &_attrButtonTheme
|
|
) != XpmSuccess
|
|
) {
|
|
fprintf(stderr, "%s: couldn't create button theme.\n", getApplicationName());
|
|
exit(-1);
|
|
}
|
|
} else {
|
|
int bCheckAgain= 0;
|
|
struct stat buf;
|
|
/* check for absolute button theme pathname */
|
|
if (stat(szButtonTheme, &buf) == -1) {
|
|
char* szNewTheme= (char*) malloc(strlen(szButtonTheme) + 4);
|
|
strcpy(szNewTheme, szButtonTheme);
|
|
strcat(szNewTheme, ".xpm");
|
|
if (isVerbose()) {
|
|
fprintf(stdout, "[%8ld] theme file '%s' not found, trying '%s'\n", currentTimeMillis(), szButtonTheme, szNewTheme);
|
|
}
|
|
/* check for absolute button theme pathname (with .xpm added) */
|
|
if (stat(szNewTheme, &buf) == 0) {
|
|
szButtonTheme= szNewTheme;
|
|
if (isVerbose()) {
|
|
fprintf(stdout, "[%8ld] initializing button theme '%s'\n", currentTimeMillis(), szButtonTheme);
|
|
}
|
|
} else {
|
|
bCheckAgain= 1;
|
|
free(szNewTheme);
|
|
}
|
|
}
|
|
if (bCheckAgain && szInstallDir != NULL) {
|
|
char* szNewTheme= (char*) malloc(strlen(szInstallDir) + strlen(szButtonTheme) + 5);
|
|
strcpy(szNewTheme, szInstallDir);
|
|
if (szNewTheme[strlen(szNewTheme) - 1] != '/') {
|
|
strcat(szNewTheme, "/");
|
|
}
|
|
strcat(szNewTheme, szButtonTheme);
|
|
if (stat(szNewTheme, &buf) == 0) {
|
|
bCheckAgain= 0;
|
|
szButtonTheme= szNewTheme;
|
|
if (isVerbose()) {
|
|
fprintf(stdout, "[%8ld] initializing button theme '%s'\n", currentTimeMillis(), szButtonTheme);
|
|
}
|
|
} else {
|
|
strcat(szNewTheme, ".xpm");
|
|
if (stat(szNewTheme, &buf) == 0) {
|
|
bCheckAgain= 0;
|
|
szButtonTheme= szNewTheme;
|
|
if (isVerbose()) {
|
|
fprintf(stdout, "[%8ld] initializing button theme '%s'\n", currentTimeMillis(), szButtonTheme);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (bCheckAgain) {
|
|
/* as a goody check the ~/.wmpager directory if it exists */
|
|
char* szHome= (char*) getenv("HOME");
|
|
if (szHome) {
|
|
/* one really shouldn't copy&paste but hey this is a q&d tool */
|
|
char* szNewTheme= (char*) malloc(strlen(szHome) + strlen(szButtonTheme) + strlen(WMPAGER_USER_DIR) + 5);
|
|
strcpy(szNewTheme, szHome);
|
|
if (szNewTheme[strlen(szNewTheme) - 1] != '/') {
|
|
strcat(szNewTheme, "/");
|
|
}
|
|
strcat(szNewTheme, WMPAGER_USER_DIR);
|
|
strcat(szNewTheme, szButtonTheme);
|
|
if (stat(szNewTheme, &buf) == 0) {
|
|
bCheckAgain= 0;
|
|
szButtonTheme= szNewTheme;
|
|
if (isVerbose()) {
|
|
fprintf(stdout, "[%8ld] initializing button theme '%s'\n", currentTimeMillis(), szButtonTheme);
|
|
}
|
|
} else {
|
|
strcat(szNewTheme, ".xpm");
|
|
if (stat(szNewTheme, &buf) == 0) {
|
|
bCheckAgain= 0;
|
|
szButtonTheme= szNewTheme;
|
|
if (isVerbose()) {
|
|
fprintf(stdout, "[%8ld] initializing button theme '%s'\n", currentTimeMillis(), szButtonTheme);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (
|
|
XpmReadFileToPixmap(
|
|
display, wRoot, szButtonTheme, &_pButtonTheme, &_pButtonThemeMask, &_attrButtonTheme
|
|
) != XpmSuccess
|
|
) {
|
|
fprintf(stderr, "%s: couldn't read button theme '%s'.\n", getApplicationName(), szButtonTheme);
|
|
exit(-1);
|
|
}
|
|
}
|
|
|
|
if (isVerbose()) {
|
|
fprintf(stdout, "[%8ld] initializing screen buffer\n", currentTimeMillis());
|
|
}
|
|
|
|
_attrWindow.valuemask|= (XpmReturnPixels | XpmReturnExtensions);
|
|
if (
|
|
XpmCreatePixmapFromData(
|
|
display, wRoot, screen_xpm, &_pWindow, &_pWindowMask, &_attrWindow
|
|
) != XpmSuccess
|
|
) {
|
|
fprintf(stderr, "%s: couldn't create screen buffer.\n", getApplicationName());
|
|
exit(-1);
|
|
}
|
|
|
|
_gcWindow= XCreateGC(_display, _pWindow, (GCForeground | GCBackground), &xgcWindow);
|
|
if (gc == NULL) {
|
|
fprintf(stderr, "%s: couldn't create screen buffer graphics.\n", getApplicationName());
|
|
exit(-1);
|
|
}
|
|
}
|
|
|
|
void redrawWindow () {
|
|
XEvent event;
|
|
int i;
|
|
int w= getButtonWidth();
|
|
int h= getButtonHeight();
|
|
for (i= 0; i < getButtonCount(); i++) {
|
|
int x, y, xoff, yoff;
|
|
xoff= 51;
|
|
yoff= 10;
|
|
if (i == getCurrentScreen()) {
|
|
xoff= 0;
|
|
yoff= 0;
|
|
}
|
|
getButtonLocation(i, &x, &y);
|
|
XSetClipMask(_display, _gcWindow, _pWindowMask);
|
|
XSetClipOrigin(_display, _gcWindow, 0, 0);
|
|
XCopyArea(_display, _pButtonTheme, _pWindow, _gcWindow, xoff + x - 7, y - 7, w, h, x, y);
|
|
XCopyArea(_display, _pButtonTheme, _pWindow, _gcWindow, xoff, 0, w, 1, x, y);
|
|
XCopyArea(_display, _pButtonTheme, _pWindow, _gcWindow, xoff, 0, 1, h, x, y);
|
|
XCopyArea(_display, _pButtonTheme, _pWindow, _gcWindow, xoff + 50, 0, 1, h, x + w - 1, y);
|
|
XCopyArea(_display, _pButtonTheme, _pWindow, _gcWindow, xoff, 50, w, 1, x, y + h - 1);
|
|
XSetClipMask(_display, _gcWindow, _pButtonThemeMask);
|
|
XSetClipOrigin(_display, _gcWindow, (x + (w - 10) / 2) - i * 10, -51 - yoff + y + (h - 10) / 2);
|
|
XCopyArea(_display, _pButtonTheme, _pWindow, _gcWindow, i * 10, 51 + yoff, 10, 10, x + (w - 10) / 2, y + (h - 10) / 2);
|
|
}
|
|
while (XCheckTypedWindowEvent(_display, _wMain, Expose, &event));
|
|
XCopyArea(_display, _pWindow, _wMain, _gcMain, 0, 0, 64, 64, 0, 0);
|
|
while (XCheckTypedWindowEvent(_display, _wIcon, Expose, &event));
|
|
XCopyArea(_display, _pWindow, _wIcon, _gcMain, 0, 0, 64, 64, 0, 0);
|
|
}
|
|
|
|
void getWindowOrigin (Window w, int* nX, int* nY) {
|
|
Window wWindow, wParent, wRoot;
|
|
Window* wChildren;
|
|
unsigned int nChildren;
|
|
unsigned int ww, wh, wb, wd;
|
|
int wx, wy;
|
|
|
|
wParent= w;
|
|
do {
|
|
wWindow= wParent;
|
|
if (!XQueryTree(getDisplay(), wParent, &wRoot, &wParent, &wChildren, &nChildren)) {
|
|
return;
|
|
}
|
|
if (wChildren) {
|
|
XFree(wChildren);
|
|
}
|
|
} while (wParent != wRoot);
|
|
|
|
if (XGetGeometry(getDisplay(), wWindow, &wRoot, &wx, &wy, &ww, &wh, &wb, &wd)) {
|
|
if (nX) {
|
|
*nX= wx;
|
|
}
|
|
if (nY) {
|
|
*nY= wy;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Event Loop
|
|
*/
|
|
|
|
void loop (long nTooltipShowDelay, long nTooltipReshowDelay) {
|
|
Display* display= getDisplay();
|
|
XEvent event;
|
|
long nTooltipTimer= -1, nTooltipHideTimer= -1, nNow;
|
|
int nTooltipButton, nTooltipX, nTooltipY;
|
|
|
|
if (isVerbose()) {
|
|
fprintf(stdout, "[%8ld] starting event loop\n", currentTimeMillis());
|
|
}
|
|
for (;;) {
|
|
while (XPending(display) || (nTooltipTimer == -1)) {
|
|
XNextEvent(display, &event);
|
|
switch (event.type) {
|
|
case Expose:
|
|
if (event.xexpose.count == 0) {
|
|
redrawWindow();
|
|
}
|
|
break;
|
|
case ConfigureNotify:
|
|
redrawWindow();
|
|
break;
|
|
case MotionNotify:
|
|
if (hasTooltipSupport()) {
|
|
if (!hasTooltip()) {
|
|
nTooltipTimer= currentTimeMillis();
|
|
nTooltipX= event.xbutton.x;
|
|
nTooltipY= event.xbutton.y;
|
|
nTooltipButton= getButtonAt(event.xbutton.x, event.xbutton.y);
|
|
} else {
|
|
int nButton= getButtonAt(event.xbutton.x, event.xbutton.y);
|
|
if (nButton != nTooltipButton) {
|
|
hideTooltip();
|
|
nTooltipTimer= -1;
|
|
nTooltipX= event.xbutton.x;
|
|
nTooltipY= event.xbutton.y;
|
|
nTooltipButton= nButton;
|
|
showTooltip(nTooltipButton, nTooltipX, nTooltipY);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case LeaveNotify:
|
|
if (hasTooltip()) {
|
|
hideTooltip();
|
|
nTooltipHideTimer= currentTimeMillis();
|
|
}
|
|
nTooltipTimer= -1;
|
|
break;
|
|
case ButtonPress:
|
|
{
|
|
int nButton= getButtonAt(event.xbutton.x, event.xbutton.y);
|
|
if (isVerbose()) {
|
|
fprintf(stdout, "[%8ld] button %d pressed\n", currentTimeMillis(), nButton);
|
|
}
|
|
if (nButton != -1) {
|
|
if (hasTooltip()) {
|
|
hideTooltip();
|
|
nTooltipHideTimer= currentTimeMillis();
|
|
}
|
|
setCurrentScreen(nButton);
|
|
gotoScreen(nButton);
|
|
}
|
|
}
|
|
break;
|
|
case PropertyNotify:
|
|
if (strcmp(XA_WIN_WORKSPACE, XGetAtomName(getDisplay(), event.xproperty.atom)) == 0) {
|
|
setCurrentScreen(-1);
|
|
if (isVerbose()) {
|
|
fprintf(stdout, "[%8ld] new current workspace (%d= %s)\n",
|
|
currentTimeMillis(), getCurrentScreen(), getScreenName(getCurrentScreen()));
|
|
}
|
|
redrawWindow();
|
|
}
|
|
break;
|
|
case DestroyNotify:
|
|
if (isVerbose()) {
|
|
fprintf(stdout, "[%8ld] quit application\n", currentTimeMillis());
|
|
}
|
|
destroyTooltip();
|
|
destroyWindow();
|
|
destroyDisplay();
|
|
exit(0);
|
|
break;
|
|
}
|
|
}
|
|
usleep(50000);
|
|
nNow= currentTimeMillis();
|
|
if (
|
|
nTooltipTimer != -1 &&
|
|
(
|
|
(nNow > nTooltipTimer + nTooltipShowDelay) ||
|
|
(nNow < nTooltipHideTimer + nTooltipReshowDelay)
|
|
)
|
|
) {
|
|
showTooltip(nTooltipButton, nTooltipX, nTooltipY);
|
|
nTooltipTimer= -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Button Helpers
|
|
*/
|
|
|
|
static int _nButtons;
|
|
static int _nButtonRows, _nButtonColumns;
|
|
static int _nButtonWidth, _nButtonHeight;
|
|
|
|
int getButtonCount () {
|
|
return _nButtons;
|
|
}
|
|
|
|
int getButtonRowCount () {
|
|
return _nButtonRows;
|
|
}
|
|
|
|
int getButtonColumnCount () {
|
|
return _nButtonColumns;
|
|
}
|
|
|
|
int getButtonWidth () {
|
|
return _nButtonWidth;
|
|
}
|
|
|
|
int getButtonHeight () {
|
|
return _nButtonHeight;
|
|
}
|
|
|
|
int getButtonAt (int nLocationX, int nLocationY) {
|
|
int i, nButtonX, nButtonY;
|
|
for (i= 0; i < _nButtons; i++) {
|
|
getButtonLocation(i, &nButtonX, &nButtonY);
|
|
if (
|
|
nLocationX >= nButtonX && nLocationX < nButtonX + _nButtonWidth &&
|
|
nLocationY >= nButtonY && nLocationY < nButtonY + _nButtonHeight
|
|
) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void getButtonLocation (int nButton, int* nLocationX, int* nLocationY) {
|
|
if (nButton < 0 || nButton > _nButtons) {
|
|
*nLocationX= *nLocationY= 0;
|
|
} else {
|
|
*nLocationX= *nLocationY= 7;
|
|
while (nButton >= _nButtonColumns) {
|
|
*nLocationY+= _nButtonHeight + 3;
|
|
nButton-= _nButtonColumns;
|
|
}
|
|
while (nButton > 0) {
|
|
*nLocationX+= _nButtonWidth + 3;
|
|
nButton--;
|
|
}
|
|
}
|
|
}
|
|
|
|
void initButtons (int nButtons, int nColumns, int nRows) {
|
|
if (nButtons != -1) {
|
|
_nButtons= nButtons;
|
|
} else {
|
|
_nButtons= getScreenCount();
|
|
if (_nButtons > 9) {
|
|
/* only handle nine screens at most */
|
|
_nButtons= 9;
|
|
}
|
|
}
|
|
if (nColumns == -1 || nRows == -1) {
|
|
switch (_nButtons) {
|
|
case 1:
|
|
_nButtonRows= _nButtonColumns= 1;
|
|
break;
|
|
case 2:
|
|
_nButtonColumns= 1;
|
|
_nButtonRows= 2;
|
|
break;
|
|
case 3:
|
|
/* fallthrough */
|
|
case 4:
|
|
_nButtonColumns= _nButtonRows= 2;
|
|
break;
|
|
case 5:
|
|
/* fallthrough */
|
|
case 6:
|
|
_nButtonColumns= 2;
|
|
_nButtonRows= 3;
|
|
break;
|
|
default:
|
|
_nButtonColumns= _nButtonRows= 3;
|
|
break;
|
|
}
|
|
} else {
|
|
_nButtonColumns= nColumns;
|
|
_nButtonRows= nRows;
|
|
}
|
|
if (_nButtons > _nButtonColumns * _nButtonRows) {
|
|
_nButtons= _nButtonColumns * _nButtonRows;
|
|
}
|
|
if (isVerbose()) {
|
|
fprintf(stdout, "[%8ld] initializing buttons\n", currentTimeMillis());
|
|
fprintf(stdout, "[%8ld] - %d workspace buttons\n", currentTimeMillis(), _nButtons);
|
|
fprintf(stdout, "[%8ld] - button layout %dx%d\n", currentTimeMillis(), _nButtonColumns, _nButtonRows);
|
|
}
|
|
|
|
if (_nButtonColumns == 1) {
|
|
_nButtonWidth= 51;
|
|
} else if (_nButtonColumns == 2) {
|
|
_nButtonWidth= 24;
|
|
} else {
|
|
_nButtonWidth= 15;
|
|
}
|
|
|
|
if (_nButtonRows == 1) {
|
|
_nButtonHeight= 51;
|
|
} else if (_nButtonRows == 2) {
|
|
_nButtonHeight= 24;
|
|
} else {
|
|
_nButtonHeight= 15;
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
* Time
|
|
*/
|
|
|
|
static struct timeval _tStart;
|
|
|
|
void initTime () {
|
|
if (isVerbose()) {
|
|
fprintf(stdout, "[ ] initializing time\n");
|
|
}
|
|
gettimeofday(&_tStart, NULL);
|
|
}
|
|
|
|
long currentTimeMillis () {
|
|
struct timeval tNow;
|
|
struct timeval tElapsed;
|
|
|
|
gettimeofday(&tNow, NULL);
|
|
|
|
if (_tStart.tv_usec > tNow.tv_usec) {
|
|
tNow.tv_usec+= 1000000;
|
|
tNow.tv_sec--;
|
|
}
|
|
tElapsed.tv_sec= tNow.tv_sec - _tStart.tv_sec;
|
|
tElapsed.tv_usec= tNow.tv_usec - _tStart.tv_usec;
|
|
return (tElapsed.tv_sec * 1000) + (tElapsed.tv_usec / 1000);
|
|
}
|
|
|
|
/*
|
|
* Screen Handling
|
|
*/
|
|
|
|
static Atom _xaWinWorkspace;
|
|
static Atom _xaWinWorkspaceNames;
|
|
static int _nScreens;
|
|
static char** _szScreenNames;
|
|
static int _nLastScreen;
|
|
|
|
int getScreenCount () {
|
|
return _nScreens;
|
|
}
|
|
|
|
char* getScreenName (int nScreen) {
|
|
if (nScreen < 0 || nScreen >= _nScreens) {
|
|
return NULL;
|
|
}
|
|
return _szScreenNames[nScreen];
|
|
}
|
|
|
|
void gotoScreen (int nWorkspace) {
|
|
XEvent event;
|
|
event.type= ClientMessage;
|
|
event.xclient.type= ClientMessage;
|
|
event.xclient.window= getRootWindow();
|
|
event.xclient.message_type= _xaWinWorkspace;
|
|
event.xclient.format= 32;
|
|
event.xclient.data.l[0]= nWorkspace;
|
|
event.xclient.data.l[1]= currentTimeMillis();
|
|
XSendEvent(getDisplay(), getRootWindow(), False, SubstructureNotifyMask, (XEvent*) &event);
|
|
}
|
|
|
|
int getCurrentScreen () {
|
|
return _nLastScreen;
|
|
}
|
|
|
|
void setCurrentScreen (int nCurrentScreen) {
|
|
if (nCurrentScreen == -1) {
|
|
long nScreen= _nLastScreen;
|
|
Atom xaType;
|
|
int nFormat;
|
|
unsigned long nItems, nBytesAfter;
|
|
unsigned char* data;
|
|
|
|
XGetWindowProperty(
|
|
getDisplay(), getRootWindow(), _xaWinWorkspace,
|
|
0, 8192, False, XA_CARDINAL, &xaType, &nFormat, &nItems, &nBytesAfter, &data
|
|
);
|
|
if ((nFormat == 32) && (nItems == 1) && (nBytesAfter == 0)) {
|
|
nScreen= *(long*) data;
|
|
}
|
|
if (xaType != None) {
|
|
XFree(data);
|
|
}
|
|
_nLastScreen= nScreen;
|
|
} else {
|
|
_nLastScreen= nCurrentScreen;
|
|
}
|
|
}
|
|
|
|
void initScreens () {
|
|
XTextProperty tp;
|
|
|
|
if (isVerbose()) {
|
|
fprintf(stdout, "[%8ld] initializing window maker communication\n", currentTimeMillis());
|
|
}
|
|
_xaWinWorkspace= XInternAtom(getDisplay(), XA_WIN_WORKSPACE, False);
|
|
_xaWinWorkspaceNames= XInternAtom(getDisplay(), XA_WIN_WORKSPACE_NAMES, False);
|
|
XGetTextProperty(getDisplay(), getRootWindow(), &tp, _xaWinWorkspaceNames);
|
|
XTextPropertyToStringList(&tp, &_szScreenNames, &_nScreens);
|
|
_nLastScreen= -1;
|
|
setCurrentScreen(-1);
|
|
if (_nLastScreen == -1) {
|
|
fprintf(
|
|
stderr,
|
|
"%s: couldn't determine current workspace.\n" \
|
|
"Make sure your WindowMaker has Gnome support enabled!\n",
|
|
getApplicationName()
|
|
);
|
|
setCurrentScreen(0);
|
|
}
|
|
if (isVerbose()) {
|
|
int i;
|
|
fprintf(stdout, "[%8ld] - %d worspaces found\n", currentTimeMillis(), getScreenCount());
|
|
for (i= 0; i < getScreenCount(); i++) {
|
|
fprintf(stdout, "[%8ld] - workspace %d: %s\n", currentTimeMillis(), i, getScreenName(i));
|
|
}
|
|
fprintf(stdout, "[%8ld] - current workspace is %d (%s)\n", currentTimeMillis(),
|
|
getCurrentScreen(), getScreenName(getCurrentScreen()));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Tooltip
|
|
*/
|
|
|
|
int _bTooltip= 0, _bTooltipSupport, _bTooltipOutside;
|
|
XFontStruct* _fTooltip;
|
|
int _nFontHeight, _nFontY;
|
|
int _nScreenWidth, _nScreenHeight;
|
|
GC _gcMono= 0;
|
|
Window _wTooltip;
|
|
|
|
int hasTooltipSupport () {
|
|
return _bTooltipSupport;
|
|
}
|
|
|
|
void showTooltip (int nButton, int nMouseX, int nMouseY) {
|
|
Pixmap pixmap, mask;
|
|
int nMainWinX, nMainWinY;
|
|
int nButtonX, nButtonY, nButtonWidth, nButtonHeight;
|
|
int nTextY, nX, nY, nWidth, nHeight, nSide;
|
|
char* szText;
|
|
|
|
if (!_bTooltipSupport) {
|
|
return;
|
|
}
|
|
if (_bTooltip) {
|
|
hideTooltip();
|
|
}
|
|
_bTooltip= 1;
|
|
if (isVerbose()) {
|
|
fprintf(stdout, "[%8ld] showing tooltip for button %d (%s) at %d, %d\n", currentTimeMillis(),
|
|
nButton, getScreenName(nButton), nMouseX, nMouseY);
|
|
}
|
|
|
|
szText= strdup(getScreenName(nButton));
|
|
nWidth= XTextWidth(_fTooltip, szText, strlen(szText)) + 16;
|
|
nHeight= _nFontHeight + 4;
|
|
if (nHeight < 16) {
|
|
nHeight= 16;
|
|
}
|
|
if (nWidth < nHeight) {
|
|
nWidth= nHeight;
|
|
}
|
|
if (isVerbose()) {
|
|
fprintf(stdout, "[%8ld] tooltip size: %d, %d\n", currentTimeMillis(), nWidth, nHeight);
|
|
}
|
|
|
|
getWindowOrigin(getIconWindow(), &nMainWinX, &nMainWinY);
|
|
if (_bTooltipOutside) {
|
|
nButtonX= nMainWinX;
|
|
nButtonY= nMainWinY;
|
|
nButtonWidth= 64;
|
|
nButtonHeight= 64;
|
|
} else {
|
|
getButtonLocation(nButton, &nButtonX, &nButtonY);
|
|
nButtonX+= nMainWinX;
|
|
nButtonY+= nMainWinY;
|
|
nButtonWidth= getButtonWidth();
|
|
nButtonHeight= getButtonHeight();
|
|
}
|
|
|
|
if (nButtonX + nWidth > _nScreenWidth) {
|
|
nSide= TOOLTIP_RIGHT;
|
|
nX= nButtonX - nWidth + nButtonWidth / 2;
|
|
if (nX < 0) {
|
|
nX= 0;
|
|
}
|
|
} else {
|
|
nSide= TOOLTIP_LEFT;
|
|
nX= nButtonX + nButtonWidth / 2;
|
|
}
|
|
if (nX + nWidth > _nScreenWidth) {
|
|
nX= _nScreenWidth - nWidth;
|
|
}
|
|
|
|
if (nButtonY - (nHeight + TOOLTIP_SPACE) < 0) {
|
|
nSide|= TOOLTIP_TOP;
|
|
nY= nButtonY + nButtonHeight - 1;
|
|
nTextY= TOOLTIP_SPACE;
|
|
} else {
|
|
nSide|= TOOLTIP_BOTTOM;
|
|
nY= nButtonY - (nHeight + TOOLTIP_SPACE);
|
|
nTextY= 0;
|
|
}
|
|
|
|
pixmap= createTooltipPixmap(nWidth, nHeight, nSide, &mask);
|
|
|
|
XSetForeground(getDisplay(), getMainGraphics(), getBlackPixel());
|
|
XSetFont(getDisplay(), getMainGraphics(), _fTooltip->fid);
|
|
XDrawString(getDisplay(), pixmap, getMainGraphics(),
|
|
8, nTextY + (nHeight - _nFontHeight) / 2 + _nFontY, szText, strlen(szText));
|
|
|
|
XSetWindowBackgroundPixmap(getDisplay(), _wTooltip, pixmap);
|
|
|
|
XResizeWindow(getDisplay(), _wTooltip, nWidth, nHeight + TOOLTIP_SPACE);
|
|
XShapeCombineMask(getDisplay(), _wTooltip, ShapeBounding, 0, 0, mask, ShapeSet);
|
|
XFreePixmap(getDisplay(), mask);
|
|
XMoveWindow(getDisplay(), _wTooltip, nX, nY);
|
|
XMapRaised(getDisplay(), _wTooltip);
|
|
XFreePixmap(getDisplay(), pixmap);
|
|
|
|
free(szText);
|
|
}
|
|
|
|
void hideTooltip () {
|
|
if (!_bTooltipSupport) {
|
|
return;
|
|
}
|
|
if (_bTooltip) {
|
|
if (isVerbose()) {
|
|
fprintf(stdout, "[%8ld] hiding tooltip\n", currentTimeMillis());
|
|
}
|
|
XUnmapWindow(getDisplay(), _wTooltip);
|
|
_bTooltip= 0;
|
|
}
|
|
}
|
|
|
|
int hasTooltip () {
|
|
if (!_bTooltipSupport) {
|
|
return 0;
|
|
}
|
|
return _bTooltip;
|
|
}
|
|
|
|
void initTooltip (int bTooltipSupport, char* szFontName, int bTooltipOutside) {
|
|
XSetWindowAttributes attribs;
|
|
unsigned long vmask;
|
|
|
|
_bTooltipSupport= bTooltipSupport;
|
|
if (!_bTooltipSupport) {
|
|
if (isVerbose()) {
|
|
fprintf(stdout, "[%8ld] initializing tooltips (disabled)\n", currentTimeMillis());
|
|
}
|
|
return;
|
|
}
|
|
if (isVerbose()) {
|
|
fprintf(stdout, "[%8ld] initializing tooltips\n", currentTimeMillis());
|
|
}
|
|
_bTooltipOutside= bTooltipOutside;
|
|
_fTooltip= XLoadQueryFont(getDisplay(), szFontName);
|
|
if (!_fTooltip) {
|
|
fprintf(stderr, "%s: couldn't allocate font '%s'.\n", getApplicationName(), szFontName);
|
|
exit(-1);
|
|
}
|
|
_nFontHeight= _fTooltip->ascent + _fTooltip->descent;
|
|
_nFontY= _fTooltip->ascent;
|
|
_nScreenWidth= WidthOfScreen(ScreenOfDisplay(getDisplay(), getDefaultScreen()));
|
|
_nScreenHeight= HeightOfScreen(ScreenOfDisplay(getDisplay(), getDefaultScreen()));
|
|
if (isVerbose()) {
|
|
fprintf(stdout, "[%8ld] configuring tooltip font:\n" \
|
|
"[%8ld] - '%s'\n[%8ld] - font-height= %d, font-ascent= %d\n" \
|
|
"[%8ld] configuring screen size: %dx%d\n",
|
|
currentTimeMillis(), currentTimeMillis(), szFontName, currentTimeMillis(), _nFontHeight, _nFontY,
|
|
currentTimeMillis(), _nScreenWidth, _nScreenHeight
|
|
);
|
|
}
|
|
|
|
vmask= CWSaveUnder | CWOverrideRedirect | CWBorderPixel;
|
|
attribs.save_under= True;
|
|
attribs.override_redirect= True;
|
|
attribs.border_pixel= 0;
|
|
_wTooltip= XCreateWindow(getDisplay(), getRootWindow(), 1, 1, 10, 10, 1,
|
|
CopyFromParent, CopyFromParent, CopyFromParent, vmask, &attribs);
|
|
if (_wMain == 0) {
|
|
fprintf(stderr, "Cannot create tooltip window.\n");
|
|
exit(-1);
|
|
}
|
|
}
|
|
|
|
void destroyTooltip () {
|
|
if (!_bTooltipSupport) {
|
|
return;
|
|
}
|
|
if (_gcMono) {
|
|
XFreeGC(getDisplay(), _gcMono);
|
|
_gcMono= 0;
|
|
}
|
|
XDestroyWindow(getDisplay(), _wTooltip);
|
|
}
|
|
|
|
void drawTooltipBalloon (Pixmap pix, GC gc, int x, int y, int w, int h, int side) {
|
|
Display* display= getDisplay();
|
|
int rad = h*3/10;
|
|
XPoint pt[3];
|
|
|
|
XFillArc(display, pix, gc, x, y, rad, rad, 90*64, 90*64);
|
|
XFillArc(display, pix, gc, x, y+h-1-rad, rad, rad, 180*64, 90*64);
|
|
|
|
XFillArc(display, pix, gc, x+w-1-rad, y, rad, rad, 0*64, 90*64);
|
|
XFillArc(display, pix, gc, x+w-1-rad, y+h-1-rad, rad, rad, 270*64, 90*64);
|
|
|
|
XFillRectangle(display, pix, gc, x, y+rad/2, w, h-rad);
|
|
XFillRectangle(display, pix, gc, x+rad/2, y, w-rad, h);
|
|
|
|
if (side & TOOLTIP_BOTTOM) {
|
|
pt[0].y = y+h-1;
|
|
pt[1].y = y+h-1+TOOLTIP_SPACE;
|
|
pt[2].y = y+h-1;
|
|
} else {
|
|
pt[0].y = y;
|
|
pt[1].y = y-TOOLTIP_SPACE;
|
|
pt[2].y = y;
|
|
}
|
|
if (side & TOOLTIP_RIGHT) {
|
|
pt[0].x = x+w-h+2*h/16;
|
|
pt[1].x = x+w-h+11*h/16;
|
|
pt[2].x = x+w-h+7*h/16;
|
|
} else {
|
|
pt[0].x = x+h-2*h/16;
|
|
pt[1].x = x+h-11*h/16;
|
|
pt[2].x = x+h-7*h/16;
|
|
}
|
|
XFillPolygon(display, pix, gc, pt, 3, Convex, CoordModeOrigin);
|
|
}
|
|
|
|
Pixmap createTooltipPixmap (int width, int height, int side, Pixmap *mask) {
|
|
Display* display= getDisplay();
|
|
Window wRoot= getRootWindow();
|
|
GC gc= getMainGraphics();
|
|
Pixmap bitmap;
|
|
Pixmap pixmap;
|
|
int x, y;
|
|
|
|
bitmap = XCreatePixmap(display, wRoot, width+TOOLTIP_SPACE, height+TOOLTIP_SPACE, 1);
|
|
|
|
if (!_gcMono) {
|
|
_gcMono= XCreateGC(display, bitmap, 0, NULL);
|
|
}
|
|
XSetForeground(display, _gcMono, 0);
|
|
XFillRectangle(display, bitmap, _gcMono, 0, 0, width+TOOLTIP_SPACE, height+TOOLTIP_SPACE);
|
|
|
|
pixmap = XCreatePixmap(display, wRoot, width+TOOLTIP_SPACE, height+TOOLTIP_SPACE, getDefaultDepth());
|
|
XSetForeground(display, gc, getBlackPixel());
|
|
XFillRectangle(display, pixmap, gc, 0, 0, width+TOOLTIP_SPACE, height+TOOLTIP_SPACE);
|
|
|
|
if (side & TOOLTIP_BOTTOM) {
|
|
y = 0;
|
|
} else {
|
|
y = TOOLTIP_SPACE;
|
|
}
|
|
x = 0;
|
|
|
|
XSetForeground(display, _gcMono, 1);
|
|
drawTooltipBalloon(bitmap, _gcMono, x, y, width, height, side);
|
|
XSetForeground(display, gc, getWhitePixel());
|
|
drawTooltipBalloon(pixmap, gc, x+1, y+1, width-2, height-2, side);
|
|
|
|
*mask = bitmap;
|
|
|
|
return pixmap;
|
|
}
|
|
|
|
|