void
WMResizeScrollViewContent(WMScrollView *sPtr, unsigned int width,
unsigned int height)
{
int w, h, x;
w = width;
h = height;
x = 0;
if (sPtr->flags.relief == WRSimple) {
w += 2;
h += 2;
} else if (sPtr->flags.relief != WRFlat) {
w += 4;
h += 4;
x = 1;
}
if (sPtr->flags.hasVScroller) {
WMResizeWidget(sPtr->vScroller, 20, h);
width -= W_VIEW(sPtr->vScroller)->size.width;
}
if (sPtr->flags.hasHScroller) {
WMResizeWidget(sPtr->hScroller, w, 20);
WMMoveWidget(sPtr->hScroller, x, h);
height -= W_VIEW(sPtr->hScroller)->size.height;
}
W_ResizeView(sPtr->view, w, h);
W_ResizeView(sPtr->viewport, width, height);
}
void WMUnmapSubwidgets(WMWidget * w)
{
if (!W_VIEW(w)->flags.realized) {
makeChildrenAutomap(W_VIEW(w), False);
} else {
W_UnmapSubviews(W_VIEW(w));
}
}
void WMSetWidgetBackgroundPixmap(WMWidget *w, WMPixmap *pix)
{
if (!pix)
return;
W_SetViewBackgroundPixmap(W_VIEW(w), pix);
if (W_VIEW(w)->flags.mapped)
WMRedisplayWidget(w);
}
void WMMapSubwidgets(WMWidget * w)
{
/* make sure that subwidgets created after the parent was realized
* are mapped too */
if (!W_VIEW(w)->flags.realized) {
makeChildrenAutomap(W_VIEW(w), True);
} else {
W_MapSubviews(W_VIEW(w));
}
}
WMRuler *WMCreateRuler(WMWidget * parent)
{
Ruler *rPtr = wmalloc(sizeof(Ruler));
unsigned int w = WMWidgetWidth(parent);
rPtr->widgetClass = WC_Ruler;
rPtr->view = W_CreateView(W_VIEW(parent));
if (!rPtr->view) {
wfree(rPtr);
return NULL;
}
rPtr->view->self = rPtr;
rPtr->drawBuffer = (Pixmap) NULL;
W_ResizeView(rPtr->view, w, 40);
WMCreateEventHandler(rPtr->view, ExposureMask | StructureNotifyMask
| EnterWindowMask | LeaveWindowMask | FocusChangeMask
| ButtonReleaseMask | ButtonPressMask | KeyReleaseMask
| KeyPressMask | Button1MotionMask, handleEvents, rPtr);
rPtr->view->delegate = &_RulerViewDelegate;
rPtr->fg = WMBlackColor(rPtr->view->screen);
rPtr->fgGC = WMColorGC(rPtr->fg);
rPtr->bgGC = WMColorGC(WMGrayColor(rPtr->view->screen));
rPtr->font = WMSystemFontOfSize(rPtr->view->screen, 8);
rPtr->offset = 22;
rPtr->margins.left = 22;
rPtr->margins.body = 22;
rPtr->margins.first = 42;
rPtr->margins.right = (w < 502 ? w : 502);
rPtr->margins.tabs = NULL;
rPtr->flags.whichMarker = 0; /* none */
rPtr->flags.buttonPressed = False;
rPtr->flags.redraw = True;
rPtr->moveAction = NULL;
rPtr->releaseAction = NULL;
rPtr->pview = W_VIEW(parent);
return rPtr;
}
WMLabel *WMCreateLabel(WMWidget * parent)
{
Label *lPtr;
lPtr = wmalloc(sizeof(Label));
lPtr->widgetClass = WC_Label;
lPtr->view = W_CreateView(W_VIEW(parent));
if (!lPtr->view) {
wfree(lPtr);
return NULL;
}
lPtr->view->self = lPtr;
lPtr->textColor = WMRetainColor(lPtr->view->screen->black);
WMCreateEventHandler(lPtr->view, ExposureMask | StructureNotifyMask, handleEvents, lPtr);
W_ResizeView(lPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);
lPtr->flags.alignment = DEFAULT_ALIGNMENT;
lPtr->flags.relief = DEFAULT_RELIEF;
lPtr->flags.imagePosition = DEFAULT_IMAGE_POSITION;
lPtr->flags.noWrap = 1;
return lPtr;
}
WMSplitView *WMCreateSplitView(WMWidget * parent)
{
WMSplitView *sPtr;
sPtr = wmalloc(sizeof(WMSplitView));
sPtr->widgetClass = WC_SplitView;
sPtr->view = W_CreateView(W_VIEW(parent));
if (!sPtr->view) {
wfree(sPtr);
return NULL;
}
sPtr->view->self = sPtr;
WMSetViewNotifySizeChanges(sPtr->view, True);
WMCreateEventHandler(sPtr->view, ExposureMask | StructureNotifyMask
| ClientMessageMask, handleEvents, sPtr);
WMCreateEventHandler(sPtr->view, ButtonPressMask | ButtonReleaseMask
| EnterWindowMask | LeaveWindowMask, handleActionEvents, sPtr);
WMAddNotificationObserver(handleViewResized, sPtr, WMViewSizeDidChangeNotification, sPtr->view);
sPtr->subviews = WMCreateArrayWithDestructor(8, wfree);
return sPtr;
}
WMTabView *WMCreateTabView(WMWidget * parent)
{
TabView *tPtr;
WMScreen *scr = WMWidgetScreen(parent);
tPtr = wmalloc(sizeof(TabView));
tPtr->widgetClass = WC_TabView;
tPtr->view = W_CreateView(W_VIEW(parent));
if (!tPtr->view) {
wfree(tPtr);
return NULL;
}
tPtr->view->self = tPtr;
tPtr->view->delegate = &delegate;
tPtr->lightGray = WMCreateRGBColor(scr, 0xd9d9, 0xd9d9, 0xd9d9, False);
tPtr->tabColor = WMCreateRGBColor(scr, 0x8420, 0x8420, 0x8420, False);
tPtr->font = WMRetainFont(scr->normalFont);
tPtr->flags.type = WTTopTabsBevelBorder;
tPtr->flags.bordered = 1;
tPtr->flags.uniformTabs = 0;
tPtr->flags.enabled = 1;
WMCreateEventHandler(tPtr->view, ExposureMask | StructureNotifyMask | ButtonPressMask, handleEvents, tPtr);
WMResizeWidget(tPtr, DEFAULT_WIDTH, DEFAULT_HEIGHT);
tPtr->tabHeight = WMFontHeight(tPtr->font) + 3;
return tPtr;
}
WMScroller *WMCreateScroller(WMWidget * parent)
{
Scroller *sPtr;
sPtr = wmalloc(sizeof(Scroller));
sPtr->widgetClass = WC_Scroller;
sPtr->view = W_CreateView(W_VIEW(parent));
if (!sPtr->view) {
wfree(sPtr);
return NULL;
}
sPtr->view->self = sPtr;
sPtr->view->delegate = &_ScrollerViewDelegate;
sPtr->flags.documentFullyVisible = 1;
WMCreateEventHandler(sPtr->view, ExposureMask | StructureNotifyMask
| ClientMessageMask, handleEvents, sPtr);
W_ResizeView(sPtr->view, DEFAULT_WIDTH, DEFAULT_WIDTH);
sPtr->flags.arrowsPosition = DEFAULT_ARROWS_POSITION;
WMCreateEventHandler(sPtr->view, ButtonPressMask | ButtonReleaseMask
| EnterWindowMask | LeaveWindowMask | ButtonMotionMask, handleActionEvents, sPtr);
sPtr->flags.hitPart = WSNoPart;
sPtr->floatValue = 0.0;
sPtr->knobProportion = 1.0;
return sPtr;
}
WMBox *WMCreateBox(WMWidget * parent)
{
Box *bPtr;
bPtr = wmalloc(sizeof(Box));
bPtr->widgetClass = WC_Box;
bPtr->view = W_CreateView(W_VIEW(parent));
if (!bPtr->view) {
wfree(bPtr);
return NULL;
}
bPtr->view->self = bPtr;
bPtr->view->delegate = &delegate;
bPtr->subviews = WMCreateArrayWithDestructor(2, wfree);
WMCreateEventHandler(bPtr->view, StructureNotifyMask, handleEvents, bPtr);
WMResizeWidget(bPtr, DEFAULT_WIDTH, DEFAULT_HEIGHT);
return bPtr;
}
static void paintDot(TabView * tPtr, Drawable d, int x, int y)
{
WMScreen *scr = W_VIEW(tPtr)->screen;
Display *dpy = scr->display;
GC white = WMColorGC(scr->white);
GC black = WMColorGC(scr->black);
XFillRectangle(dpy, d, black, x, y, 2, 2);
XDrawPoint(dpy, d, white, x, y);
}
static void W_DrawLabel(WMTabViewItem * item, Drawable d, WMRect rect, Bool enabled)
{
WMScreen *scr = W_VIEW(item->tabView)->screen;
if (!item->label)
return;
WMDrawString(scr, d, enabled ? scr->black : scr->darkGray,
item->tabView->font, rect.pos.x, rect.pos.y, item->label, strlen(item->label));
}
WMTextField *WMCreateTextField(WMWidget * parent)
{
TextField *tPtr;
tPtr = wmalloc(sizeof(TextField));
tPtr->widgetClass = WC_TextField;
tPtr->view = W_CreateView(W_VIEW(parent));
if (!tPtr->view) {
wfree(tPtr);
return NULL;
}
tPtr->view->self = tPtr;
tPtr->view->delegate = &_TextFieldViewDelegate;
tPtr->view->attribFlags |= CWCursor;
tPtr->view->attribs.cursor = tPtr->view->screen->textCursor;
W_SetViewBackgroundColor(tPtr->view, tPtr->view->screen->white);
tPtr->text = wmalloc(MIN_TEXT_BUFFER);
tPtr->textLen = 0;
tPtr->bufferSize = MIN_TEXT_BUFFER;
tPtr->flags.enabled = 1;
WMCreateEventHandler(tPtr->view, ExposureMask | StructureNotifyMask | FocusChangeMask, handleEvents, tPtr);
tPtr->font = WMRetainFont(tPtr->view->screen->normalFont);
tPtr->flags.bordered = DEFAULT_BORDERED;
tPtr->flags.beveled = True;
tPtr->flags.alignment = DEFAULT_ALIGNMENT;
tPtr->offsetWidth = WMAX((tPtr->view->size.height - WMFontHeight(tPtr->font)) / 2, 1);
W_ResizeView(tPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);
WMCreateEventHandler(tPtr->view, EnterWindowMask | LeaveWindowMask
| ButtonReleaseMask | ButtonPressMask | KeyPressMask | Button1MotionMask,
handleTextFieldActionEvents, tPtr);
WMAddNotificationObserver(selectionNotification, tPtr->view,
WMSelectionOwnerDidChangeNotification, (void *)XA_PRIMARY);
WMAddNotificationObserver(realizeObserver, tPtr, WMViewRealizedNotification, tPtr->view);
tPtr->flags.cursorOn = 1;
return tPtr;
}
static void
drawTab(TabView *tPtr, Drawable d, int x, int y,
unsigned width, unsigned height, Bool selected)
{
WMScreen *scr = W_VIEW(tPtr)->screen;
Display *dpy = scr->display;
GC white = WMColorGC(selected ? scr->white : tPtr->lightGray);
GC black = WMColorGC(scr->black);
GC dark = WMColorGC(scr->darkGray);
GC light = WMColorGC(scr->gray);
XPoint trap[8];
trap[0].x = x + (selected ? 0 : 1);
trap[0].y = y + height - (selected ? 0 : 1);
trap[1].x = x + 3;
trap[1].y = y + height - 3;
trap[2].x = x + 10 - 3;
trap[2].y = y + 3;
trap[3].x = x + 10;
trap[3].y = y;
trap[4].x = x + width - 10;
trap[4].y = y;
trap[5].x = x + width - 10 + 3;
trap[5].y = y + 3;
trap[6].x = x + width - 3;
trap[6].y = y + height - 3;
trap[7].x = x + width - (selected ? 0 : 1);
trap[7].y = y + height - (selected ? 0 : 1);
XFillPolygon(dpy, d, selected ? light : WMColorGC(tPtr->tabColor), trap, 8,
Convex, CoordModeOrigin);
XDrawLine(dpy, d, white, trap[0].x, trap[0].y, trap[1].x, trap[1].y);
XDrawLine(dpy, d, white, trap[1].x, trap[1].y, trap[2].x, trap[2].y);
XDrawLine(dpy, d, white, trap[2].x, trap[2].y, trap[3].x, trap[3].y);
XDrawLine(dpy, d, white, trap[3].x, trap[3].y, trap[4].x, trap[4].y);
XDrawLine(dpy, d, dark, trap[4].x, trap[4].y, trap[5].x, trap[5].y);
XDrawLine(dpy, d, black, trap[5].x, trap[5].y, trap[6].x, trap[6].y);
XDrawLine(dpy, d, black, trap[6].x, trap[6].y, trap[7].x, trap[7].y);
XDrawLine(dpy, d, selected ? light : WMColorGC(scr->white),
trap[0].x, trap[0].y, trap[7].x, trap[7].y);
}
WMBrowser *WMCreateBrowser(WMWidget * parent)
{
WMBrowser *bPtr;
int i;
wassertrv(parent, NULL);
bPtr = wmalloc(sizeof(WMBrowser));
bPtr->widgetClass = WC_Browser;
bPtr->view = W_CreateView(W_VIEW(parent));
if (!bPtr->view) {
wfree(bPtr);
return NULL;
}
bPtr->view->self = bPtr;
bPtr->view->delegate = &_BrowserViewDelegate;
WMCreateEventHandler(bPtr->view, ExposureMask | StructureNotifyMask
| ClientMessageMask, handleEvents, bPtr);
/* default configuration */
bPtr->flags.hasScroller = DEFAULT_HAS_SCROLLER;
bPtr->titleHeight = DEFAULT_TITLE_HEIGHT;
bPtr->flags.isTitled = DEFAULT_IS_TITLED;
bPtr->maxVisibleColumns = DEFAULT_MAX_VISIBLE_COLUMNS;
WMResizeWidget(bPtr, DEFAULT_WIDTH, DEFAULT_HEIGHT);
bPtr->pathSeparator = wstrdup(DEFAULT_SEPARATOR);
if (bPtr->flags.hasScroller)
setupScroller(bPtr);
for (i = 0; i < bPtr->maxVisibleColumns; i++) {
WMAddBrowserColumn(bPtr);
}
bPtr->usedColumnCount = 0;
bPtr->selectedColumn = -1;
return bPtr;
}
static void paintItem(WMList * lPtr, int index, Drawable d, char *text, int state, WMRect * rect)
{
WMView *view = W_VIEW(lPtr);
W_Screen *scr = view->screen;
Display *display = scr->display;
WMFont *font = ((state & WLDSIsBranch) ? scr->boldFont : scr->normalFont);
WMColor *backColor = ((state & WLDSSelected) ? scr->white : view->backColor);
int width, height, x, y;
/* Parameter not used, but tell the compiler that it is ok */
(void) index;
width = rect->size.width;
height = rect->size.height;
x = rect->pos.x;
y = rect->pos.y;
XFillRectangle(display, d, WMColorGC(backColor), x, y, width, height);
if (text) {
int widthC, textLen;
/* Avoid overlaping... */
widthC = (state & WLDSIsBranch) ? width - 20 : width - 8;
textLen = strlen(text);
if (WMWidthOfString(font, text, textLen) > widthC) {
char *textBuf = createTruncatedString(font, text, &textLen, widthC);
W_PaintText(view, d, font, x + 4, y, widthC, WALeft, scr->black, False, textBuf, textLen);
wfree(textBuf);
} else {
W_PaintText(view, d, font, x + 4, y, widthC, WALeft, scr->black, False, text, textLen);
}
}
if (state & WLDSIsBranch) {
WMColor *lineColor = ((state & WLDSSelected) ? scr->gray : scr->white);
XDrawLine(display, d, WMColorGC(scr->darkGray), x + width - 11, y + 3,
x + width - 6, y + height / 2);
XDrawLine(display, d, WMColorGC(lineColor), x + width - 11, y + height - 5,
x + width - 6, y + height / 2);
XDrawLine(display, d, WMColorGC(scr->black), x + width - 12, y + 3,
x + width - 12, y + height - 5);
}
}
WMScrollView*
WMCreateScrollView(WMWidget *parent)
{
ScrollView *sPtr;
sPtr = wmalloc(sizeof(ScrollView));
memset(sPtr, 0, sizeof(ScrollView));
sPtr->widgetClass = WC_ScrollView;
sPtr->view = W_CreateView(W_VIEW(parent));
if (!sPtr->view) {
wfree(sPtr);
return NULL;
}
sPtr->viewport = W_CreateView(sPtr->view);
if (!sPtr->viewport) {
W_DestroyView(sPtr->view);
wfree(sPtr);
return NULL;
}
sPtr->view->self = sPtr;
sPtr->viewport->self = sPtr;
sPtr->view->delegate = &_ScrollViewViewDelegate;
sPtr->viewport->flags.mapWhenRealized = 1;
WMCreateEventHandler(sPtr->view, StructureNotifyMask|ExposureMask,
handleEvents, sPtr);
WMCreateEventHandler(sPtr->viewport, SubstructureNotifyMask,
handleViewportEvents, sPtr);
sPtr->lineScroll = 4;
sPtr->pageScroll = 0;
return sPtr;
}
void WMReparentWidget(WMWidget * w, WMWidget * newParent, int x, int y)
{
W_ReparentView(W_VIEW(w), W_VIEW(newParent), x, y);
}
unsigned int WMWidgetHeight(WMWidget * w)
{
return W_VIEW(w)->size.height;
}
static void paintTabView(TabView * tPtr)
{
Pixmap buffer;
WMScreen *scr = W_VIEW(tPtr)->screen;
Display *dpy = scr->display;
GC white = WMColorGC(scr->white);
int i;
if (tPtr->flags.type == WTTopTabsBevelBorder) {
int count = tPtr->visibleTabs;
int first = tPtr->firstVisible;
int moreAtLeft;
int moreAtRight;
int selectedIsVisible;
int ty;
int twidth, theight;
ty = 2;
theight = tPtr->tabHeight;
buffer = XCreatePixmap(dpy, W_VIEW(tPtr)->window,
W_VIEW(tPtr)->size.width, theight, W_VIEW(tPtr)->screen->depth);
XFillRectangle(dpy, buffer, WMColorGC(W_VIEW(tPtr)->backColor),
0, 0, W_VIEW(tPtr)->size.width, tPtr->tabHeight);
if (tPtr->flags.dontFitAll) {
moreAtLeft = first > 0;
moreAtRight = (first + count) < tPtr->itemCount;
if (tPtr->selectedItem >= first && tPtr->selectedItem < first + count)
selectedIsVisible = 1;
else
selectedIsVisible = 0;
} else {
moreAtLeft = 0;
moreAtRight = 0;
selectedIsVisible = 1;
}
if (moreAtRight) {
drawTab(tPtr, buffer, positionOfTab(tPtr, first + count), 0,
W_VIEW_WIDTH(tPtr->view), theight, False);
}
for (i = first + count - 1; i >= first; i--) {
if (!selectedIsVisible || i != tPtr->selectedItem) {
twidth = W_TabViewItemTabWidth(tPtr->items[i]);
drawTab(tPtr, buffer, positionOfTab(tPtr, i), 0, twidth, theight, False);
}
}
if (moreAtLeft) {
drawTab(tPtr, buffer, positionOfTab(tPtr, 0) - 2 * BUTTONED_SIDE_OFFSET,
0, BUTTONED_SIDE_OFFSET * 4, theight, False);
}
if (selectedIsVisible) {
int idx = tPtr->selectedItem;
drawTab(tPtr, buffer, positionOfTab(tPtr, idx),
0, W_TabViewItemTabWidth(tPtr->items[idx]), theight, True);
XDrawLine(dpy, buffer, white, 0, theight - 1, positionOfTab(tPtr, idx), theight - 1);
XDrawLine(dpy, buffer, white,
positionOfTab(tPtr, idx) + W_TabViewItemTabWidth(tPtr->items[idx]),
tPtr->tabHeight - 1, W_VIEW_WIDTH(tPtr->view) - 1, tPtr->tabHeight - 1);
} else {
XDrawLine(dpy, buffer, white, 0, theight - 1, W_VIEW_WIDTH(tPtr->view), theight - 1);
}
for (i = 0; i < count; i++) {
WMRect rect;
rect.pos.x = 15 + positionOfTab(tPtr, first + i);
rect.pos.y = ty;
rect.size.width = W_TabViewItemTabWidth(tPtr->items[first + i]);
rect.size.height = theight;
W_DrawLabel(tPtr->items[first + i], buffer, rect,
tPtr->flags.enabled && tPtr->items[first + i]->flags.enabled);
}
if (moreAtLeft) {
paintDot(tPtr, buffer, 4, 10);
paintDot(tPtr, buffer, 7, 10);
paintDot(tPtr, buffer, 10, 10);
}
if (moreAtRight) {
int x;
x = positionOfTab(tPtr, tPtr->firstVisible + tPtr->visibleTabs);
x = x + (W_VIEW_WIDTH(tPtr->view) - x) / 2;
paintDot(tPtr, buffer, x + 5, 10);
paintDot(tPtr, buffer, x + 8, 10);
paintDot(tPtr, buffer, x + 11, 10);
}
XCopyArea(dpy, buffer, W_VIEW(tPtr)->window, scr->copyGC, 0, 0,
W_VIEW_WIDTH(tPtr->view), theight, 0, 0);
XFreePixmap(dpy, buffer);
}
switch (tPtr->flags.type) {
case WTTopTabsBevelBorder:
drawRelief(scr, W_VIEW(tPtr)->window, 0, tPtr->tabHeight - 1,
W_VIEW(tPtr)->size.width, W_VIEW(tPtr)->size.height - tPtr->tabHeight + 1);
break;
case WTNoTabsBevelBorder:
W_DrawRelief(scr, W_VIEW(tPtr)->window, 0, 0, W_VIEW(tPtr)->size.width,
W_VIEW(tPtr)->size.height, WRRaised);
break;
case WTNoTabsLineBorder:
W_DrawRelief(scr, W_VIEW(tPtr)->window, 0, 0, W_VIEW(tPtr)->size.width,
W_VIEW(tPtr)->size.height, WRSimple);
break;
case WTNoTabsNoBorder:
break;
}
}
Window WMWidgetXID(WMWidget * w)
{
return W_VIEW(w)->window;
}
void WMRedisplayWidget(WMWidget * w)
{
W_RedisplayView(W_VIEW(w));
}
WMScreen *WMWidgetScreen(WMWidget * w)
{
return W_VIEW(w)->screen;
}
void *WMGetHangedData(WMWidget * widget)
{
return W_VIEW(widget)->hangedData;
}
void WMHangData(WMWidget * widget, void *data)
{
W_VIEW(widget)->hangedData = data;
}
void WMDestroyWidget(WMWidget * widget)
{
W_UnmapView(W_VIEW(widget));
W_DestroyView(W_VIEW(widget));
}
void WMUnmapWidget(WMWidget * w)
{
W_UnmapView(W_VIEW(w));
}
void WMSetFocusToWidget(WMWidget * widget)
{
W_SetFocusOfTopLevel(W_TopLevelOfView(W_VIEW(widget)), W_VIEW(widget));
}
/*
* WMRealizeWidget-
* Realizes the widget and all it's children.
*
*/
void WMRealizeWidget(WMWidget * w)
{
W_RealizeView(W_VIEW(w));
}
void WMMapWidget(WMWidget * w)
{
W_MapView(W_VIEW(w));
}
