/*
* Clear from cursor position to end of display, inclusive.
*/
static void
ClearBelow (register TScreen *screen)
{
ClearRight(screen, -1);
if (screen->protected_mode != OFF_PROTECT) {
register int row;
for (row = screen->cur_row + 1; row <= screen->max_row; row++)
ClearInLine(screen, row, 0, screen->max_col + 1);
} else {
register int top;
if((top = screen->cur_row - screen->topline) <= screen->max_row) {
if(screen->scroll_amt)
FlushScroll(screen);
if(++top <= screen->max_row) {
ClearCurBackground(screen,
top * FontHeight(screen) + screen->border,
OriginX(screen),
(screen->max_row - top + 1) * FontHeight(screen),
Width(screen));
}
}
ClearBufRows(screen, screen->cur_row + 1, screen->max_row);
}
}
static long
params_to_pixels(TScreen *screen, String *params, Cardinal n)
{
int mult = 1;
const char *s;
int modifier;
switch (n > 2 ? 2 : n) {
case 2:
s = params[1];
if (CompareWidths(s, "PAGE", &modifier)) {
mult = (MaxRows(screen) + modifier) * FontHeight(screen);
} else if (CompareWidths(s, "HALFPAGE", &modifier)) {
mult = ((MaxRows(screen) + modifier) * FontHeight(screen)) / 2;
} else if (CompareWidths(s, "PIXEL", &modifier)) {
mult = 1;
} else {
/* else assume that it is Line */
mult = FontHeight(screen);
}
mult *= atoi(params[0]);
TRACE(("params_to_pixels(%s,%s) = %d\n", params[0], params[1], mult));
break;
case 1:
mult = atoi(params[0]) * FontHeight(screen); /* lines */
TRACE(("params_to_pixels(%s) = %d\n", params[0], mult));
break;
default:
mult = screen->scrolllines * FontHeight(screen);
TRACE(("params_to_pixels() = %d\n", mult));
break;
}
return mult;
}
/*
* Clear from cursor position to beginning of display, inclusive.
*/
static void
ClearAbove (register TScreen *screen)
{
if (screen->protected_mode != OFF_PROTECT) {
register int row;
for (row = 0; row <= screen->max_row; row++)
ClearInLine(screen, row, 0, screen->max_col + 1);
} else {
register int top, height;
if(screen->cursor_state)
HideCursor();
if((top = -screen->topline) <= screen->max_row) {
if(screen->scroll_amt)
FlushScroll(screen);
if((height = screen->cur_row + top) > screen->max_row)
height = screen->max_row;
if((height -= top) > 0) {
ClearCurBackground(screen,
top * FontHeight(screen) + screen->border,
OriginX(screen),
height * FontHeight(screen),
Width(screen));
}
}
ClearBufRows(screen, 0, screen->cur_row - 1);
}
if(screen->cur_row - screen->topline <= screen->max_row)
ClearLeft(screen);
}
/*
* Reverse scrolls the screen by amount lines, erases top, doesn't alter
* cursor position (i.e. cursor moves up amount relative to text).
* All done within the scrolling region, of course.
* Requires: amount > 0
*/
void
RevScroll(register TScreen *screen, register int amount)
{
register int i = screen->bot_marg - screen->top_marg + 1;
register int shift;
register int bot;
register int refreshtop;
register int refreshheight;
register int scrolltop;
register int scrollheight;
if(screen->cursor_state)
HideCursor();
if (amount > i)
amount = i;
if(screen->jumpscroll) {
if(screen->scroll_amt < 0) {
if(-screen->refresh_amt + amount > i)
FlushScroll(screen);
screen->scroll_amt -= amount;
screen->refresh_amt -= amount;
} else {
if(screen->scroll_amt > 0)
FlushScroll(screen);
screen->scroll_amt = -amount;
screen->refresh_amt = -amount;
}
} else {
shift = -screen->topline;
bot = screen->max_row - shift;
refreshheight = amount;
scrollheight = screen->bot_marg - screen->top_marg -
refreshheight + 1;
refreshtop = screen->top_marg + shift;
scrolltop = refreshtop + refreshheight;
if((i = screen->bot_marg - bot) > 0)
scrollheight -= i;
if((i = screen->top_marg + refreshheight - 1 - bot) > 0)
refreshheight -= i;
if (screen->multiscroll && amount == 1 &&
screen->topline == 0 && screen->top_marg == 0 &&
screen->bot_marg == screen->max_row) {
if (screen->incopy < 0 && screen->scrolls == 0)
CopyWait(screen);
screen->scrolls++;
}
scrolling_copy_area(screen, scrolltop-amount, scrollheight, -amount);
if(refreshheight > 0) {
ClearCurBackground(screen,
(int) refreshtop * FontHeight(screen) + screen->border,
(int) OriginX(screen),
(unsigned) refreshheight * FontHeight(screen),
(unsigned) Width(screen));
}
}
ScrnInsertLine(screen, screen->visbuf, screen->bot_marg, screen->top_marg,
amount, screen->max_col + 1);
}
void
WindowScroll(XtermWidget xw, int top, Bool always GCC_UNUSED)
{
TScreen *screen = TScreenOf(xw);
#if OPT_SCROLL_LOCK
if (screen->allowScrollLock && (screen->scroll_lock && !always)) {
if (screen->scroll_dirty) {
screen->scroll_dirty = False;
ScrnRefresh(xw, 0, 0, MaxRows(screen), MaxCols(screen), False);
}
} else
#endif
{
int i;
if (top < -screen->savedlines) {
top = -screen->savedlines;
} else if (top > 0) {
top = 0;
}
if ((i = screen->topline - top) != 0) {
int lines;
int scrolltop, scrollheight, refreshtop;
if (screen->cursor_state)
HideCursor();
lines = i > 0 ? i : -i;
if (lines > MaxRows(screen))
lines = MaxRows(screen);
scrollheight = screen->max_row - lines + 1;
if (i > 0)
refreshtop = scrolltop = 0;
else {
scrolltop = lines;
refreshtop = scrollheight;
}
scrolling_copy_area(xw, scrolltop, scrollheight, -i);
screen->topline = top;
ScrollSelection(screen, i, True);
xtermClear2(xw,
OriginX(screen),
OriginY(screen) + refreshtop * FontHeight(screen),
(unsigned) Width(screen),
(unsigned) (lines * FontHeight(screen)));
ScrnRefresh(xw, refreshtop, 0, lines, MaxCols(screen), False);
#if OPT_BLINK_CURS || OPT_BLINK_TEXT
RestartBlinking(screen);
#endif
}
}
ScrollBarDrawThumb(screen->scrollWidget);
}
/*
* If cursor not in scrolling region, returns. Else,
* inserts n blank lines at the cursor's position. Lines above the
* bottom margin are lost.
*/
void
InsertLine (register TScreen *screen, register int n)
{
register int i;
register int shift;
register int bot;
register int refreshtop;
register int refreshheight;
register int scrolltop;
register int scrollheight;
if (screen->cur_row < screen->top_marg ||
screen->cur_row > screen->bot_marg)
return;
if(screen->cursor_state)
HideCursor();
screen->do_wrap = 0;
if (n > (i = screen->bot_marg - screen->cur_row + 1))
n = i;
if(screen->jumpscroll) {
if(screen->scroll_amt <= 0 &&
screen->cur_row <= -screen->refresh_amt) {
if(-screen->refresh_amt + n > screen->max_row + 1)
FlushScroll(screen);
screen->scroll_amt -= n;
screen->refresh_amt -= n;
} else if(screen->scroll_amt)
FlushScroll(screen);
}
if(!screen->scroll_amt) {
shift = -screen->topline;
bot = screen->max_row - shift;
refreshheight = n;
scrollheight = screen->bot_marg - screen->cur_row - refreshheight + 1;
refreshtop = screen->cur_row + shift;
scrolltop = refreshtop + refreshheight;
if((i = screen->bot_marg - bot) > 0)
scrollheight -= i;
if((i = screen->cur_row + refreshheight - 1 - bot) > 0)
refreshheight -= i;
vertical_copy_area(screen, scrolltop-n, scrollheight, -n);
if(refreshheight > 0) {
ClearCurBackground(screen,
(int) refreshtop * FontHeight(screen) + screen->border,
(int) OriginX(screen),
(unsigned) refreshheight * FontHeight(screen),
(unsigned) Width(screen));
}
}
ScrnInsertLine(screen, screen->visbuf, screen->bot_marg, screen->cur_row, n,
screen->max_col + 1);
}
void WindowScroll(TScreen *screen,int top)
{
register int i, lines;
register int scrolltop, scrollheight, refreshtop;
register int x = 0;
if (top < -screen->savedlines)
top = -screen->savedlines;
else if (top > 0)
top = 0;
if((i = screen->topline - top) == 0)
{
ScrollBarDrawThumb(screen->scrollWidget);
return;
}
/*ScrollSelection(screen, i);*/
if(screen->cursor_state)
HideCursor();
lines = i > 0 ? i : -i;
if(lines > screen->max_row + 1)
lines = screen->max_row + 1;
scrollheight = screen->max_row - lines + 1;
if(i > 0)
refreshtop = scrolltop = 0;
else
{
scrolltop = lines;
refreshtop = scrollheight;
}
/*x = screen->scrollbar + screen->border;*/
x=OriginX(screen);
scrolling_copy_area(screen, scrolltop, scrollheight, -i);
screen->topline = top;
ScrollSelection(screen, i);
XClearArea(
screen->display,
/*TextWindow(screen),*/
VWindow(screen),
(int) x,
(int) refreshtop * FontHeight(screen) + screen->border,
(unsigned) Width(screen),
(unsigned) lines * FontHeight(screen),
FALSE);
ScrnRefresh(screen, refreshtop, 0, lines, screen->max_col + 1, False);
ScrollBarDrawThumb(screen->scrollWidget);
}
/*
* setCursorOnScreen - set cursor at specified row and column in edit window
*/
static void setCursorOnScreen( int row, int col )
{
window *w;
int x, y;
int width;
int funny;
if( BAD_ID( CurrentWindow ) ) {
return;
}
if( EditFlags.Quiet || EditFlags.NoSetCursor ) {
return;
}
funny = getCursorInfo( CurrentWindow, row, col, &x, &width );
w = WINDOW_FROM_ID( CurrentWindow );
y = row * FontHeight( WIN_FONT( w ) ) - cursorHeight;
width = (long) width * cursorType.width / 100L;
if( cursorWidth != width ) {
MyHideCaret( CurrentWindow );
DestroyCaret();
CreateCaret( CurrentWindow, (HBITMAP)NULLHANDLE, width, cursorHeight );
cursorWidth = width;
}
// adjust position for italic sillyness
SetCaretPos( x - funny, y );
MyShowCaret( CurrentWindow );
} /* setCursorOnScreen */
/*
* SetCursorOnLine - set cursor at specified column in single line text string
*/
void SetCursorOnLine( window_id id, int col, char *str, type_style *style )
{
window *w;
int x, y;
int width, height;
if( BAD_ID( id ) ) {
return;
}
w = WINDOW_FROM_ID( id );
// y = FontHeight( WIN_FONT( w ) ) - cursorHeight;
x = MyTextExtent( id, style, str, col - 1 );
width = MyTextExtent( id, style, str, col ) - x;
/* adjust so that Insert cursor is 0 width
* Also make the overstrike cursor the height of the insert cursor.
*/
width = (long) width * cursorType.width / 100L;
height = EditVars.InsertCursorType.height;
y = FontHeight( WIN_FONT( w ) ) - height;
MyHideCaret( id );
DestroyCaret();
// CreateCaret( id, (HBITMAP)NULLHANDLE, width, cursorHeight );
CreateCaret( id, (HBITMAP)NULLHANDLE, width, height );
SetCaretPos( x, y );
MyShowCaret( id );
} /* SetCursorOnLine */
void GetMenuSize(XlibMenu * menu)
{
int i = 0;
int winheight = 0;
int fontheight = 0;
int menuwidth = 0;
FcitxSkin *sc = &menu->owner->skin;
int dpi = sc->skinFont.respectDPI? menu->owner->dpi: 0;
FCITX_UNUSED(dpi);
winheight = sc->skinMenu.marginTop + sc->skinMenu.marginBottom;//菜单头和尾都空8个pixel
fontheight = FontHeight(menu->owner->menuFont, sc->skinFont.menuFontSize, dpi);
for (i = 0; i < utarray_len(&menu->menushell->shell); i++) {
if (GetMenuItem(menu->menushell, i)->type == MENUTYPE_SIMPLE || GetMenuItem(menu->menushell, i)->type == MENUTYPE_SUBMENU)
winheight += 6 + fontheight;
else if (GetMenuItem(menu->menushell, i)->type == MENUTYPE_DIVLINE)
winheight += 5;
int width = StringWidth(GetMenuItem(menu->menushell, i)->tipstr, menu->owner->menuFont, sc->skinFont.menuFontSize, dpi);
if (width > menuwidth)
menuwidth = width;
}
menu->height = winheight;
menu->width = menuwidth + sc->skinMenu.marginLeft + sc->skinMenu.marginRight + 15 + 20;
}
void
GraphColumn::DrawField(BField* field, BRect rect, BView* parent)
{
int number = ((BIntegerField*)field)->Value();
if (number > 100)
number = 100;
else if (number < 0)
number = 0;
BRect graphRect(rect);
graphRect.InsetBy(5, 3);
parent->StrokeRect(graphRect);
if (number > 0) {
graphRect.InsetBy(1, 1);
float val = graphRect.Width() * (float) number / 100;
graphRect.right = graphRect.left + val;
parent->SetHighColor(0, 0, 190);
parent->FillRect(graphRect);
}
parent->SetDrawingMode(B_OP_INVERT);
parent->SetHighColor(128, 128, 128);
char numstr[256];
sprintf(numstr, "%d%%", number);
float width = be_plain_font->StringWidth(numstr);
parent->MovePenTo(rect.left + rect.Width() / 2 - width / 2, rect.bottom - FontHeight());
parent->DrawString(numstr);
}
/*ARGSUSED*/
static void
ScrollTextUpDownBy(
Widget scrollbarWidget,
XtPointer client_data GCC_UNUSED,
XtPointer call_data)
{
XtermWidget xw = getXtermWidget(scrollbarWidget);
if (xw != 0) {
long pixels = (long) call_data;
TScreen *screen = TScreenOf(xw);
int rowOnScreen, newTopLine;
rowOnScreen = (int) (pixels / FontHeight(screen));
if (rowOnScreen == 0) {
if (pixels < 0)
rowOnScreen = -1;
else if (pixels > 0)
rowOnScreen = 1;
}
newTopLine = ROW2INX(screen, rowOnScreen);
WindowScroll(xw, newTopLine, True);
}
}
/*
* NewCursor - create a new cursor for a window
*/
void NewCursor( window_id id, cursor_type ct )
{
window *w;
int height;
int width;
if( BAD_ID( id ) ) {
return;
}
w = WINDOW_FROM_ID( id );
height = FontHeight( WIN_FONT( w ) );
width = FontAverageWidth( WIN_FONT( w ) );
height = (long) height * ct.height / 100L;
width = (long) width * ct.width / 100L;
MyHideCaret( id );
DestroyCaret();
cursorHeight = height;
cursorWidth = width;
if( !haveOldBlinkTime ) {
oldBlinkTime = GetCaretBlinkTime();
haveOldBlinkTime = TRUE;
}
CreateCaret( id, (HBITMAP)NULLHANDLE, cursorWidth, cursorHeight );
SetCursorBlinkRate( EditVars.CursorBlinkRate );
MyShowCaret( id );
cursorType = ct;
} /* NewCursor */
/**
*返回鼠标指向的菜单在menu中是第多少项
*/
int SelectShellIndex(XlibMenu * menu, int x, int y, int* offseth)
{
FcitxSkin *sc = &menu->owner->skin;
int i;
int winheight = sc->skinMenu.marginTop;
int fontheight;
int marginLeft = sc->skinMenu.marginLeft;
int dpi = sc->skinFont.respectDPI? menu->owner->dpi: 0;
if (x < marginLeft)
return -1;
fontheight = FontHeight(menu->owner->menuFont, sc->skinFont.menuFontSize, dpi);
for (i = 0; i < utarray_len(&menu->menushell->shell); i++) {
if (GetMenuItem(menu->menushell, i)->type == MENUTYPE_SIMPLE || GetMenuItem(menu->menushell, i)->type == MENUTYPE_SUBMENU) {
if (y > winheight + 1 && y < winheight + 6 + fontheight - 1) {
if (offseth)
*offseth = winheight;
return i;
}
winheight = winheight + 6 + fontheight;
} else if (GetMenuItem(menu->menushell, i)->type == MENUTYPE_DIVLINE)
winheight += 5;
}
return -1;
}
static void
AlternateScroll(Widget w, long amount)
{
XtermWidget xw;
TScreen *screen;
if ((xw = getXtermWidget(w)) != 0 &&
(screen = TScreenOf(xw)) != 0 &&
screen->alternateScroll && screen->whichBuf) {
ANSI reply;
amount /= FontHeight(screen);
memset(&reply, 0, sizeof(reply));
reply.a_type = ((xw->keyboard.flags & MODE_DECCKM)
? ANSI_SS3
: ANSI_CSI);
if (amount > 0) {
reply.a_final = 'B';
} else {
amount = -amount;
reply.a_final = 'A';
}
while (amount-- > 0) {
unparseseq(xw, &reply);
}
} else {
ScrollTextUpDownBy(w, (XtPointer) 0, (XtPointer) amount);
}
}
//根据Menu内容来绘制菜单内容
void DrawXlibMenu(XlibMenu * menu)
{
FcitxSkin *sc = &menu->owner->skin;
FcitxClassicUI *classicui = menu->owner;
Display* dpy = classicui->dpy;
GC gc = XCreateGC(dpy, menu->menuWindow, 0, NULL);
int i = 0;
int fontheight;
int iPosY = 0;
int dpi = sc->skinFont.respectDPI? menu->owner->dpi: 0;
FCITX_UNUSED(dpi);
fontheight = FontHeight(menu->owner->menuFont, sc->skinFont.menuFontSize, dpi);
SkinImage *background = LoadImage(sc, sc->skinMenu.backImg, false);
GetMenuSize(menu);
EnlargeCairoSurface(&menu->menu_cs, menu->width, menu->height);
if (background) {
cairo_t* cr = cairo_create(menu->menu_cs);
DrawResizableBackground(cr, background->image, menu->height, menu->width,
sc->skinMenu.marginLeft,
sc->skinMenu.marginTop,
sc->skinMenu.marginRight,
sc->skinMenu.marginBottom,
sc->skinMenu.fillV,
sc->skinMenu.fillH
);
cairo_destroy(cr);
}
iPosY = sc->skinMenu.marginTop;
for (i = 0; i < utarray_len(&menu->menushell->shell); i++) {
if (GetMenuItem(menu->menushell, i)->type == MENUTYPE_SIMPLE || GetMenuItem(menu->menushell, i)->type == MENUTYPE_SUBMENU) {
DisplayText(menu, i, iPosY, fontheight);
if (menu->menushell->mark == i)
MenuMark(menu, iPosY, i);
if (GetMenuItem(menu->menushell, i)->type == MENUTYPE_SUBMENU)
DrawArrow(menu, iPosY);
iPosY = iPosY + 6 + fontheight;
} else if (GetMenuItem(menu->menushell, i)->type == MENUTYPE_DIVLINE) {
DrawDivLine(menu, iPosY);
iPosY += 5;
}
}
XResizeWindow(dpy, menu->menuWindow, menu->width, menu->height);
_CAIRO_SETSIZE(menu->menu_x_cs, menu->width, menu->height);
cairo_t* c = cairo_create(menu->menu_x_cs);
cairo_set_operator(c, CAIRO_OPERATOR_SOURCE);
cairo_set_source_surface(c, menu->menu_cs, 0, 0);
cairo_rectangle(c, 0, 0, menu->width, menu->height);
cairo_clip(c);
cairo_paint(c);
cairo_destroy(c);
cairo_surface_flush(menu->menu_x_cs);
XFreeGC(dpy, gc);
}
static int params_to_pixels (TScreen *screen,String *params,int n)
{
register mult = 1;
register char *s;
switch (n > 2 ? 2 : n)
{
case 2:
s = params[1];
if (specialcmplowerwiths (s, "page"))
{
mult = (screen->max_row + 1) * FontHeight(screen);
}
else if (specialcmplowerwiths (s, "halfpage"))
{
mult = ((screen->max_row + 1) * FontHeight(screen)) >> 1;
}
else if (specialcmplowerwiths (s, "pixel"))
/*
* InvokeColSelHook - invoke column hook with specified data
*/
vi_rc InvokeColSelHook( int sc, int ec )
{
int j, i;
char wordbuff[MAX_STR];
char data[MAX_STR + 32];
int lne;
#ifndef __WIN__
int x1;
int has_bord;
#endif
#ifndef __WIN__
has_bord = WindowAuxInfo( CurrentWindow, WIND_INFO_HAS_BORDER );
x1 = WindowAuxInfo( CurrentWindow, WIND_INFO_X1 );
if( LastEvent != VI_KEY( MOUSEEVENT ) ) {
lne = WindowAuxInfo( CurrentWindow, WIND_INFO_Y1 ) + CurrentPos.line - LeftTopPos.line;
if( has_bord ) {
++lne;
}
} else {
lne = MouseRow;
}
#else
if( LastEvent != VI_KEY( FAKEMOUSE ) ) {
lne = (CurrentPos.line - LeftTopPos.line) * FontHeight( WIN_FONT( &EditWindow ) );
} else {
lne = MouseY;
}
#endif
j = 0;
if( ec - sc >= MAX_STR ) {
ec = sc + MAX_STR - 2;
}
for( i = sc - 1; i <= ec - 1; i++ ) {
wordbuff[j++] = CurrentLine->data[i];
}
wordbuff[j] = 0;
#ifndef __WIN__
sc = x1 + VirtualColumnOnCurrentLine( sc ) - LeftTopPos.column;
ec = x1 + VirtualColumnOnCurrentLine( ec ) - LeftTopPos.column;
if( !has_bord ) {
sc--;
ec--;
}
#else
sc = MyTextExtent( CurrentWindow, WIN_STYLE( &EditWindow ),
&CurrentLine->data[0], sc );
ec = MyTextExtent( CurrentWindow, WIN_STYLE( &EditWindow ),
&CurrentLine->data[0], ec );
#endif
MySprintf( data, "\"%s\" %d %d %d %d", wordbuff, lne, sc, ec, ec - sc + 1 );
return( SourceHookData( SRC_HOOK_MOUSE_CHARSEL, data ) );
} /* InvokeColSelHook */
static void
repaint_line(unsigned newChrSet)
{
register TScreen *screen = &term->screen;
int curcol = screen->cur_col;
int currow = screen->cur_row;
int len = screen->max_col + 1;
int width = len;
unsigned oldChrSet = SCRN_BUF_CSETS(screen, currow)[0];
/*
* Ignore repetition.
*/
if (oldChrSet == newChrSet)
return;
TRACE(("repaint_line(%2d,%2d) (%d)\n", currow, screen->cur_col, newChrSet));
HideCursor();
/* If switching from single-width, keep the cursor in the visible part
* of the line.
*/
if (CSET_DOUBLE(newChrSet)) {
width /= 2;
if (curcol > width)
curcol = width;
}
/*
* ScrnRefresh won't paint blanks for us if we're switching between a
* single-size and double-size font.
*/
if (CSET_DOUBLE(oldChrSet) != CSET_DOUBLE(newChrSet)) {
ClearCurBackground(
screen,
CursorY(screen, currow),
CurCursorX(screen, currow, 0),
FontHeight(screen),
len * CurFontWidth(screen, currow));
}
/* FIXME: do VT220 softchars allow double-sizes? */
memset(SCRN_BUF_CSETS(screen, currow), newChrSet, len);
screen->cur_col = 0;
ScrnRefresh(screen, currow, 0, 1, len, True);
screen->cur_col = curcol;
}
SkinImage* LoadImageWithText(FcitxClassicUI* classicui, FcitxSkin* sc, const char* name, const char* text, int w, int h, boolean active)
{
if (!text || strlen(text) == 0)
return NULL;
UnloadSingleImage(sc, name);
int len = fcitx_utf8_char_len(text);
char* iconText = strndup(text, len);
FcitxLog(DEBUG, "%s", iconText);
cairo_surface_t* newsurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, w, h);
cairo_t* c = cairo_create(newsurface);
int min = w > h? h: w;
min = min * 0.8;
cairo_set_operator(c, CAIRO_OPERATOR_SOURCE);
cairo_set_source_rgba(c ,1, 1, 1, 1.0);
cairo_paint(c);
FcitxConfigColor color;
if (sc->skinMainBar.bUseCustomTextIconColor) {
if (active)
color = sc->skinMainBar.textIconColor[0];
else
color = sc->skinMainBar.textIconColor[1];
}
else
color = sc->skinFont.menuFontColor[1];
int textw, texth;
StringSizeStrict(iconText, classicui->font, min, &textw, &texth);
int fh = FontHeight(classicui->font, min);
OutputString(c, iconText, classicui->font, min, (w - textw) * 0.5, (h - texth) * 0.5 - (fh - texth), &color);
cairo_destroy(c);
SkinImage* image = fcitx_utils_malloc0(sizeof(SkinImage));
image->name = strdup(name);
image->image = newsurface;
image->textIcon = true;
HASH_ADD_KEYPTR(hh, sc->imageTable, image->name, strlen(image->name), image);
return image;
}
/*ARGSUSED*/
static void ScrollTextUpDownBy(Widget scrollbarWidget,Opaque closure,
int pixels)
{
register TScreen *screen = &term->screen;
register int rowOnScreen, newTopLine;
rowOnScreen = pixels / FontHeight(screen);
if (rowOnScreen == 0)
{
if (pixels < 0)
rowOnScreen = -1;
else if (pixels > 0)
rowOnScreen = 1;
}
newTopLine = screen->topline + rowOnScreen;
WindowScroll(screen, newTopLine);
}
/*
* drawRepeatString - draw the current repeat string
*/
static void drawRepeatString( void )
{
int height;
RECT rect;
HDC hdc;
if( !AllowDisplay || BAD_ID( repeat_window_id ) ) {
return;
}
GetClientRect( repeat_window_id, &rect );
height = FontHeight( WIN_TEXT_FONT( &RepeatCountWindow ) );
rect.bottom = rect.top + height;
hdc = TextGetDC( repeat_window_id, WIN_TEXT_STYLE( &RepeatCountWindow ) );
FillRect( hdc, &rect, ColorBrush( WIN_TEXT_BACKCOLOR( &RepeatCountWindow ) ) );
TextReleaseDC( repeat_window_id, hdc );
WriteString( repeat_window_id, 0, rect.top, WIN_TEXT_STYLE( &RepeatCountWindow ), repString );
} /* drawRepeatString */
static void msgString( int line_no, char *str )
{
int height;
RECT rect;
HDC hdc;
if( !AllowDisplay || BAD_ID( MessageWindow ) ) {
return;
}
GetClientRect( MessageWindow, &rect );
height = FontHeight( WIN_FONT( &MessageBar ) );
rect.top += (line_no - 1) * height;
rect.bottom = rect.top + height;
hdc = TextGetDC( MessageWindow, WIN_STYLE( &MessageBar ) );
FillRect( hdc, &rect, ColorBrush( WIN_BACKCOLOR( &MessageBar ) ) );
TextReleaseDC( MessageWindow, hdc );
WriteString( MessageWindow, 0, rect.top, WIN_STYLE( &MessageBar ), str );
}
TInfoView::TInfoView(BRect frame)
: BBox(frame, "rgb", B_FOLLOW_ALL,
B_WILL_DRAW | B_FULL_UPDATE_ON_RESIZE | B_FRAME_EVENTS,
B_NO_BORDER)
{
SetFont(be_plain_font);
fFontHeight = FontHeight(this, true);
fMagView = NULL;
fSelectionColor = kBlack;
fCH1Loc.x = fCH1Loc.y = fCH2Loc.x = fCH2Loc.y = 0;
fInfoStr[0] = 0;
fRGBStr[0] = 0;
fCH1Str[0] = 0;
fCH2Str[0] = 0;
fInfoTextVisible = true;
}
/*
* DrawSceneTextArea()
* - updates scene text area within main drawing area
*
* PARAMETERS
* data - pointer to MyProgram structure
*
* RETURNS
* nothing
*/
void
DrawSceneTextArea(MyProgram *data)
{
pointType left_pt, right_pt;
int height;
XFont font;
int vert_spacing, text_offset;
font = GetWidgetFont( data->draw_area_widget );
height = FontHeight( font );
vert_spacing = 2 * DEFAULT_SCENE_TEXT_SPACING;
text_offset = DEFAULT_SCENE_TEXT_SPACING;
left_pt.x = DEFAULT_SCENE_BOT_LEFT_X;
left_pt.y = height + DEFAULT_SCENE_BOT_LEFT_Y + vert_spacing;
right_pt.x = DEFAULT_SCENE_TOP_RIGHT_X;
right_pt.y = left_pt.y;
DrawLine( left_pt.x, InvertY(left_pt.y), right_pt.x, InvertY(right_pt.y) );
DrawText( "Sound:", (left_pt.x+text_offset),
InvertY((left_pt.y-text_offset-height)) );
left_pt.y += (height + vert_spacing);
right_pt.y = left_pt.y;
DrawLine( left_pt.x, InvertY(left_pt.y), right_pt.x, InvertY(right_pt.y) );
DrawText( "Dialog:", (left_pt.x+text_offset),
InvertY((left_pt.y-text_offset-height)) );
left_pt.y += (height + vert_spacing);
right_pt.y = left_pt.y;
DrawLine( left_pt.x, InvertY(left_pt.y), right_pt.x, InvertY(right_pt.y) );
DrawText( "Action:", (left_pt.x+text_offset),
InvertY((left_pt.y-text_offset-height)) );
}
TWindow::TWindow(int32 pixelCount)
:
BWindow(BRect(0, 0, 0, 0), B_TRANSLATE_SYSTEM_NAME("Magnify"),
B_TITLED_WINDOW, B_OUTLINE_RESIZE)
{
GetPrefs(pixelCount);
// add info view
BRect infoRect(Bounds());
infoRect.InsetBy(-1, -1);
fInfo = new TInfoView(infoRect);
AddChild(fInfo);
fFontHeight = FontHeight(fInfo, true);
fInfoHeight = (fFontHeight * 2) + (3 * 5);
BRect fbRect(0, 0, (fHPixelCount*fPixelSize), (fHPixelCount*fPixelSize));
if (InfoIsShowing())
fbRect.OffsetBy(10, fInfoHeight);
fFatBits = new TMagnify(fbRect, this);
fInfo->AddChild(fFatBits);
fFatBits->SetSelection(fShowInfo);
fInfo->SetMagView(fFatBits);
ResizeWindow(fHPixelCount, fVPixelCount);
UpdateInfoBarOnResize();
AddShortcut('S', B_COMMAND_KEY, new BMessage(msg_save));
AddShortcut('C', B_COMMAND_KEY, new BMessage(msg_copy_image));
AddShortcut('T', B_COMMAND_KEY, new BMessage(msg_show_info));
AddShortcut('H', B_COMMAND_KEY, new BMessage(msg_add_cross_hair));
AddShortcut('H', B_SHIFT_KEY, new BMessage(msg_remove_cross_hair));
AddShortcut('G', B_COMMAND_KEY, new BMessage(msg_toggle_grid));
AddShortcut('F', B_COMMAND_KEY, new BMessage(msg_freeze));
AddShortcut('I', B_COMMAND_KEY, new BMessage(msg_stick));
AddShortcut('-', B_COMMAND_KEY, new BMessage(msg_shrink));
AddShortcut('=', B_COMMAND_KEY, new BMessage(msg_grow));
AddShortcut('/', B_COMMAND_KEY, new BMessage(msg_make_square));
AddShortcut(',', B_COMMAND_KEY, new BMessage(msg_shrink_pixel));
AddShortcut('.', B_COMMAND_KEY, new BMessage(msg_grow_pixel));
}
void PrintLegend (HDC hDC, PGRAPHSTRUCT pGraph, HWND hWndLegend,
RECT rectLegend)
{
PLEGEND pLegend ;
int yItemHeight ;
HFONT hFontItems ;
PLINE pLine ;
int iIndex ;
int iIndexNum ;
pLegend = LegendData (hWndLegend) ;
yItemHeight = pLegend->yItemHeight ;
hFontItems = pLegend->hFontItems ;
pLegend->hFontItems = hFontPrinterScales ;
SelectFont (hDC, pLegend->hFontItems) ;
pLegend->yItemHeight = FontHeight (hDC, TRUE) ;
iIndexNum = LBNumItems (pLegend->hWndItems) ;
for (iIndex = 0 ;
iIndex < iIndexNum ;
iIndex++)
{ // for
pLine = (PLINE) LBData (pLegend->hWndItems, iIndex) ;
DrawLegendItem (pLegend, pLine, iIndex * pLegend->yItemHeight, hDC) ;
} // for
pLegend->hFontItems = hFontItems ;
pLegend->yItemHeight = yItemHeight ;
SelectBrush (hDC, GetStockObject (HOLLOW_BRUSH)) ;
SelectPen (hDC, GetStockObject (BLACK_PEN)) ;
Rectangle (hDC, 0, 0,
rectLegend.right - rectLegend.left,
rectLegend.bottom - rectLegend.top) ;
}
/*
* Insert n blanks at the cursor's position, no wraparound
*/
void
InsertChar (register TScreen *screen, register int n)
{
if(screen->cursor_state)
HideCursor();
screen->do_wrap = 0;
if(screen->cur_row - screen->topline <= screen->max_row) {
if(!AddToRefresh(screen)) {
int col = screen->max_col + 1 - n;
if(screen->scroll_amt)
FlushScroll(screen);
#if OPT_DEC_CHRSET
if (CSET_DOUBLE(SCRN_BUF_CSETS(screen, screen->cur_row)[0])) {
col = (screen->max_col + 1) / 2 - n;
}
#endif
/*
* prevent InsertChar from shifting the end of a line over
* if it is being appended to
*/
if (non_blank_line (screen->visbuf, screen->cur_row,
screen->cur_col, screen->max_col + 1))
horizontal_copy_area(screen, screen->cur_col,
col - screen->cur_col,
n);
ClearCurBackground(
screen,
CursorY (screen, screen->cur_row),
CurCursorX (screen, screen->cur_row, screen->cur_col),
FontHeight(screen),
n * CurFontWidth(screen,screen->cur_row));
}
}
/* adjust screen->buf */
ScrnInsertChar(screen, n, screen->max_col + 1);
}
/*
* InvokeLineSelHook - invoke the mouse selection
*/
vi_rc InvokeLineSelHook( linenum s, linenum e )
{
char tmp[32];
int lne, col;
#ifndef __WIN__
int has_bord;
#endif
#ifndef __WIN__
if( LastEvent != VI_KEY( MOUSEEVENT ) ) {
has_bord = WindowAuxInfo( CurrentWindow, WIND_INFO_HAS_BORDER );
lne = WindowAuxInfo( CurrentWindow, WIND_INFO_Y1 ) + CurrentPos.line - LeftTopPos.line;
col = WindowAuxInfo( CurrentWindow, WIND_INFO_X1 ) + VirtualColumnOnCurrentLine( CurrentPos.column ) - LeftTopPos.column - 1;
if( has_bord ) {
++lne;
++col;
}
if( col < 0 ) {
col = 0;
}
} else {
col = MouseCol;
lne = MouseRow;
}
#else
if( LastEvent != VI_KEY( FAKEMOUSE ) ) {
/* assume we're not in insert mode *ouch* */
col = PixelFromColumnOnCurrentLine( CurrentPos.column );
lne = (CurrentPos.line - LeftTopPos.line) * FontHeight( WIN_FONT( &EditWindow ) );
} else {
col = MouseX;
lne = MouseY;
}
#endif
MySprintf( tmp, "%d %d %l %l", lne, col, s, e );
return( SourceHookData( SRC_HOOK_MOUSE_LINESEL, tmp ) );
} /* InvokeLineSelHook */
/*
* Deletes n chars at the cursor's position, no wraparound.
*/
void
DeleteChar (register TScreen *screen, register int n)
{
register int width;
if(screen->cursor_state)
HideCursor();
screen->do_wrap = 0;
if (n > (width = screen->max_col + 1 - screen->cur_col))
n = width;
if(screen->cur_row - screen->topline <= screen->max_row) {
if(!AddToRefresh(screen)) {
int col = screen->max_col + 1 - n;
if(screen->scroll_amt)
FlushScroll(screen);
#if OPT_DEC_CHRSET
if (CSET_DOUBLE(SCRN_BUF_CSETS(screen, screen->cur_row)[0])) {
col = (screen->max_col + 1) / 2 - n;
}
#endif
horizontal_copy_area(screen, screen->cur_col+n,
col - screen->cur_col,
-n);
ClearCurBackground (
screen,
CursorY (screen, screen->cur_row),
CurCursorX(screen, screen->cur_row, col),
FontHeight(screen),
n * CurFontWidth(screen,screen->cur_row));
}
}
/* adjust screen->buf */
ScrnDeleteChar (screen, n, screen->max_col + 1);
}
