nyx/vim
1
0
Fork 0
mirror of https://github.com/vim/vim synced 2025-03-30 22:46:45 +02:00
Code Issues 1 Projects Releases Packages Wiki Activity Actions 3
vim/src/gui_photon.c
Bram Moolenaar dfccaf0f00 updated for version 7.0027
2004-12-31 20:56:11 +00:00

3077 lines
72 KiB
C
Raw Permalink Blame History

/* vi:set ts=8 sw=4 sts=4:
*
* VIM - Vi IMproved by Bram Moolenaar
* Photon GUI support by Julian Kinraid
*
* Do ":help uganda" in Vim to read copying and usage conditions.
* Do ":help credits" in Vim to see a list of people who contributed.
*
*
* Clipboard support is in os_qnx.c
* PhAttach() is called in os_qnx.c:qnx_init()
*/
#include "vim.h"
#ifdef FEAT_TOOLBAR
# include <photon/PxImage.h>
#endif
#if !defined(__QNX__)
/* Used when generating prototypes. */
# define PgColor_t int
# define PhEvent_t int
# define PhPoint_t int
# define PtWidget_t int
# define Pg_BLACK 0
# define PtCallbackF_t int
# define PtCallbackInfo_t int
# define PhTile_t int
# define PtWidget_t int
# define PhImage_t int
#endif
#define ARRAY_LENGTH(a) (sizeof(a) / sizeof(a[0]))
#define RGB(r,g,b) PgRGB(r,g,b)
#define EVENT_BUFFER_SIZE sizeof( PhEvent_t ) + 1000
/* Some defines for gui_mch_mousehide() */
#define MOUSE_HIDE TRUE
#define MOUSE_SHOW FALSE
/* Optional support for using a PtPanelGroup widget, needs work */
#undef USE_PANEL_GROUP
#ifdef USE_PANEL_GROUP
static char *empty_title = " ";
static char **panel_titles = NULL;
static ushort_t num_panels = 0;
static short pg_margin_left, pg_margin_right, pg_margin_top, pg_margin_bottom;
#endif
#define GUI_PH_MARGIN 4 /* Size of the bevel */
#define GUI_PH_MOUSE_TYPE Ph_CURSOR_INSERT
static PgColor_t gui_ph_mouse_color = Pg_BLACK;
static PhPoint_t gui_ph_raw_offset;
static PtWidget_t *gui_ph_timer_cursor; /* handle cursor blinking */
static PtWidget_t *gui_ph_timer_timeout; /* used in gui_mch_wait_for_chars */
static short is_timeout; /* Has the timeout occured? */
/*
* This is set inside the mouse callback for a right mouse
* button click, and used for the popup menus
*/
static PhPoint_t abs_mouse;
/* Try and avoid redraws while a resize is in progress */
static int is_ignore_draw = FALSE;
/* Used for converting to/from utf-8 and other charsets */
static struct PxTransCtrl *charset_translate;
/*
* Cursor blink functions.
*
* This is a simple state machine:
* BLINK_NONE not blinking at all
* BLINK_OFF blinking, cursor is not shown
* BLINK_ON blinking, cursor is shown
*/
static enum {
BLINK_NONE,
BLINK_OFF,
BLINK_ON
} blink_state = BLINK_NONE;
static long_u blink_waittime = 700;
static long_u blink_ontime = 400;
static long_u blink_offtime = 250;
static struct
{
int key_sym;
char_u vim_code0;
char_u vim_code1;
} special_keys[] =
{
{Pk_Up, 'k', 'u'},
{Pk_Down, 'k', 'd'},
{Pk_Left, 'k', 'l'},
{Pk_Right, 'k', 'r'},
{Pk_F1, 'k', '1'},
{Pk_F2, 'k', '2'},
{Pk_F3, 'k', '3'},
{Pk_F4, 'k', '4'},
{Pk_F5, 'k', '5'},
{Pk_F6, 'k', '6'},
{Pk_F7, 'k', '7'},
{Pk_F8, 'k', '8'},
{Pk_F9, 'k', '9'},
{Pk_F10, 'k', ';'},
{Pk_F11, 'F', '1'},
{Pk_F12, 'F', '2'},
{Pk_F13, 'F', '3'},
{Pk_F14, 'F', '4'},
{Pk_F15, 'F', '5'},
{Pk_F16, 'F', '6'},
{Pk_F17, 'F', '7'},
{Pk_F18, 'F', '8'},
{Pk_F19, 'F', '9'},
{Pk_F20, 'F', 'A'},
{Pk_F21, 'F', 'B'},
{Pk_F22, 'F', 'C'},
{Pk_F23, 'F', 'D'},
{Pk_F24, 'F', 'E'},
{Pk_F25, 'F', 'F'},
{Pk_F26, 'F', 'G'},
{Pk_F27, 'F', 'H'},
{Pk_F28, 'F', 'I'},
{Pk_F29, 'F', 'J'},
{Pk_F30, 'F', 'K'},
{Pk_F31, 'F', 'L'},
{Pk_F32, 'F', 'M'},
{Pk_F33, 'F', 'N'},
{Pk_F34, 'F', 'O'},
{Pk_F35, 'F', 'P'},
{Pk_Help, '%', '1'},
{Pk_BackSpace, 'k', 'b'},
{Pk_Insert, 'k', 'I'},
{Pk_Delete, 'k', 'D'},
{Pk_Home, 'k', 'h'},
{Pk_End, '@', '7'},
{Pk_Prior, 'k', 'P'},
{Pk_Next, 'k', 'N'},
{Pk_Print, '%', '9'},
{Pk_KP_Add, 'K', '6'},
{Pk_KP_Subtract,'K', '7'},
{Pk_KP_Divide, 'K', '8'},
{Pk_KP_Multiply,'K', '9'},
{Pk_KP_Enter, 'K', 'A'},
{Pk_KP_0, KS_EXTRA, KE_KINS}, /* Insert */
{Pk_KP_Decimal, KS_EXTRA, KE_KDEL}, /* Delete */
{Pk_KP_4, 'k', 'l'}, /* Left */
{Pk_KP_6, 'k', 'r'}, /* Right */
{Pk_KP_8, 'k', 'u'}, /* Up */
{Pk_KP_2, 'k', 'd'}, /* Down */
{Pk_KP_7, 'K', '1'}, /* Home */
{Pk_KP_1, 'K', '4'}, /* End */
{Pk_KP_9, 'K', '3'}, /* Page Up */
{Pk_KP_3, 'K', '5'}, /* Page Down */
{Pk_KP_5, '&', '8'}, /* Undo */
/* Keys that we want to be able to use any modifier with: */
{Pk_Return, CAR, NUL},
{Pk_space, ' ', NUL},
{Pk_Tab, TAB, NUL},
{Pk_Escape, ESC, NUL},
{NL, NL, NUL},
{CAR, CAR, NUL},
/* End of list marker: */
{0, 0, 0}
};
/****************************************************************************/
static PtCallbackF_t gui_ph_handle_timer_cursor;
static PtCallbackF_t gui_ph_handle_timer_timeout;
static PtCallbackF_t gui_ph_handle_window_cb;
static PtCallbackF_t gui_ph_handle_scrollbar;
static PtCallbackF_t gui_ph_handle_keyboard;
static PtCallbackF_t gui_ph_handle_mouse;
static PtCallbackF_t gui_ph_handle_pulldown_menu;
static PtCallbackF_t gui_ph_handle_menu;
static PtCallbackF_t gui_ph_handle_focus; /* focus change of text area */
static PtCallbackF_t gui_ph_handle_menu_resize;
/* When a menu is unrealized, give focus back to vimTextArea */
static PtCallbackF_t gui_ph_handle_menu_unrealized;
#ifdef USE_PANEL_GROUP
static void gui_ph_get_panelgroup_margins( short*, short*, short*, short* );
#endif
#ifdef FEAT_TOOLBAR
static PhImage_t *gui_ph_toolbar_find_icon( vimmenu_T *menu );
#endif
static void gui_ph_draw_start( void );
static void gui_ph_draw_end( void );
/* Set the text for the balloon */
static PtWidget_t * gui_ph_show_tooltip( PtWidget_t *window,
PtWidget_t *widget,
int position,
char *text,
char *font,
PgColor_t fill_color,
PgColor_t text_color );
/****************************************************************************/
static PtWidget_t * gui_ph_show_tooltip( PtWidget_t *window,
PtWidget_t *widget,
int position,
char *text,
char *font,
PgColor_t fill_color,
PgColor_t text_color )
{
PtArg_t arg;
vimmenu_T *menu;
char_u *tooltip;
PtSetArg( &arg, Pt_ARG_POINTER, &menu, 0 );
PtGetResources( widget, 1, &arg );
/* Override the text and position */
tooltip = text;
if( menu != NULL )
{
int index = MENU_INDEX_TIP;
if( menu->strings[ index ] != NULL )
tooltip = menu->strings[ index ];
}
return( PtInflateBalloon(
window,
widget,
/* Don't put the balloon at the bottom,
* it gets drawn over by gfx done in the PtRaw */
Pt_BALLOON_TOP,
tooltip,
font,
fill_color,
text_color ) );
}
static void
gui_ph_resize_container( void )
{
PhArea_t area;
PtWidgetArea( gui.vimWindow, &area );
PtWidgetPos ( gui.vimContainer, &area.pos );
PtSetResource( gui.vimContainer, Pt_ARG_AREA, &area, 0 );
}
static int
gui_ph_handle_menu_resize(
PtWidget_t *widget,
void *other,
PtCallbackInfo_t *info )
{
PtContainerCallback_t *sizes = info->cbdata;
PtWidget_t *container;
PhPoint_t below_menu;
int_u height;
height = sizes->new_dim.h;
/* Because vim treats the toolbar and menubar separatly,
* and here they're lumped together into a PtToolbarGroup,
* we only need either menu_height or toolbar_height set at once */
if( gui.menu_is_active )
{
gui.menu_height = height;
gui.toolbar_height = 0;
}
#ifdef FEAT_TOOLBAR
else
gui.toolbar_height = height;
#endif
below_menu.x = 0;
below_menu.y = height;
#ifdef USE_PANEL_GROUP
container = gui.vimPanelGroup;
#else
container = gui.vimContainer;
#endif
PtSetResource( container, Pt_ARG_POS, &below_menu, 0 );
gui_ph_resize_container();
#ifdef USE_PANEL_GROUP
gui_ph_get_panelgroup_margins(
&pg_margin_top, &pg_margin_bottom,
&pg_margin_left, &pg_margin_right );
#endif
return( Pt_CONTINUE );
}
/*
* Pt_ARG_TIMER_REPEAT isn't used because the on & off times
* are different
*/
static int
gui_ph_handle_timer_cursor(
PtWidget_t *widget,
void *data,
PtCallbackInfo_t *info )
{
if( blink_state == BLINK_ON )
{
gui_undraw_cursor();
blink_state = BLINK_OFF;
PtSetResource( gui_ph_timer_cursor, Pt_ARG_TIMER_INITIAL,
blink_offtime, 0 );
}
else
{
gui_update_cursor(TRUE, FALSE);
blink_state = BLINK_ON;
PtSetResource( gui_ph_timer_cursor, Pt_ARG_TIMER_INITIAL,
blink_ontime, 0 );
}
return( Pt_CONTINUE );
}
static int
gui_ph_handle_timer_timeout(PtWidget_t *widget, void *data, PtCallbackInfo_t *info)
{
is_timeout = TRUE;
return( Pt_CONTINUE );
}
static int
gui_ph_handle_window_cb( PtWidget_t *widget, void *data, PtCallbackInfo_t *info )
{
PhWindowEvent_t *we = info->cbdata;
ushort_t *width, *height;
switch( we->event_f ) {
case Ph_WM_CLOSE:
gui_shell_closed();
break;
case Ph_WM_FOCUS:
/* Just in case it's hidden and needs to be shown */
gui_mch_mousehide( MOUSE_SHOW );
if( we->event_state == Ph_WM_EVSTATE_FOCUS )
{
gui_focus_change(TRUE);
gui_mch_start_blink();
}
else
{
gui_focus_change(FALSE);
gui_mch_stop_blink();
}
break;
case Ph_WM_RESIZE:
PtGetResource( gui.vimWindow, Pt_ARG_WIDTH, &width, 0 );
PtGetResource( gui.vimWindow, Pt_ARG_HEIGHT, &height, 0 );
#ifdef USE_PANEL_GROUP
width -= (pg_margin_left + pg_margin_right);
height -= (pg_margin_top + pg_margin_bottom);
#endif
gui_resize_shell( *width, *height );
gui_set_shellsize( FALSE, FALSE );
is_ignore_draw = FALSE;
PtEndFlux( gui.vimContainer );
PtContainerRelease( gui.vimContainer );
break;
default:
break;
}
return( Pt_CONTINUE );
}
static int
gui_ph_handle_scrollbar( PtWidget_t *widget, void *data, PtCallbackInfo_t *info )
{
PtScrollbarCallback_t *scroll;
scrollbar_T *sb;
int value, dragging = FALSE;
scroll = info->cbdata;
sb = (scrollbar_T *) data;
if( sb != NULL )
{
value = scroll->position;
switch( scroll->action )
{
case Pt_SCROLL_DRAGGED:
dragging = TRUE;
break;
case Pt_SCROLL_SET:
/* FIXME: return straight away here? */
return( Pt_CONTINUE );
break;
}
gui_drag_scrollbar(sb, value, dragging);
}
return( Pt_CONTINUE );
}
static int
gui_ph_handle_keyboard( PtWidget_t *widget, void *data, PtCallbackInfo_t *info )
{
PhKeyEvent_t *key;
unsigned char string[6];
int len, i;
int ch, modifiers;
key = PhGetData( info->event );
ch = modifiers = len = 0;
if( p_mh )
gui_mch_mousehide( MOUSE_HIDE );
/* We're a good lil photon program, aren't we? yes we are, yeess wee arrr */
if( key->key_flags & Pk_KF_Compose )
{
return( Pt_CONTINUE );
}
if( (key->key_flags & Pk_KF_Cap_Valid) &&
PkIsKeyDown( key->key_flags ) )
{
#ifdef FEAT_MENU
/*
* Only show the menu if the Alt key is down, and the Shift & Ctrl
* keys aren't down, as well as the other conditions
*/
if( ( ( key->key_mods & Pk_KM_Alt ) &&
!( key->key_mods & Pk_KM_Shift ) &&
!( key->key_mods & Pk_KM_Ctrl ) ) &&
gui.menu_is_active &&
( *p_wak == 'y' ||
( *p_wak == 'm' &&
gui_is_menu_shortcut( key->key_cap ) ) ) )
{
/* Fallthrough and let photon look for the hotkey */
return( Pt_CONTINUE );
}
#endif
for( i = 0; special_keys[i].key_sym != 0; i++ )
{
if( special_keys[i].key_sym == key->key_cap )
{
len = 0;
if( special_keys[i].vim_code1 == NUL )
ch = special_keys[i].vim_code0;
else
{
/* Detect if a keypad number key has been pressed
* and change the key if Num Lock is on */
if( key->key_cap >= Pk_KP_Enter && key->key_cap <= Pk_KP_9
&& ( key->key_mods & Pk_KM_Num_Lock ) )
{
/* FIXME: For now, just map the key to a ascii value
* (see <photon/PkKeyDef.h>) */
ch = key->key_cap - 0xf080;
}
else
ch = TO_SPECIAL( special_keys[i].vim_code0,
special_keys[i].vim_code1 );
}
break;
}
}
if( key->key_mods & Pk_KM_Ctrl )
modifiers |= MOD_MASK_CTRL;
if( key->key_mods & Pk_KM_Alt )
modifiers |= MOD_MASK_ALT;
if( key->key_mods & Pk_KM_Shift )
modifiers |= MOD_MASK_SHIFT;
/* Is this not a special key? */
if( special_keys[i].key_sym == 0 )
{
ch = PhTo8859_1( key );
if( ch == -1
#ifdef FEAT_MBYTE
|| ( enc_utf8 && ch > 127 )
#endif
)
{
#ifdef FEAT_MBYTE
len = PhKeyToMb( string, key );
if( len > 0 )
{
static char buf[6];
int src_taken, dst_made;
if( enc_utf8 != TRUE )
{
PxTranslateFromUTF(
charset_translate,
string,
len,
&src_taken,
buf,
6,
&dst_made );
add_to_input_buf( buf, dst_made );
}
else
{
add_to_input_buf( string, len );
}
return( Pt_CONSUME );
}
len = 0;
#endif
ch = key->key_cap;
if( ch < 0xff )
{
/* FIXME: is this the right thing to do? */
if( modifiers & MOD_MASK_CTRL )
{
modifiers &= ~MOD_MASK_CTRL;
if( ( ch >= 'a' && ch <= 'z' ) ||
ch == '[' ||
ch == ']' ||
ch == '\\' )
ch = Ctrl_chr( ch );
else if( ch == '2' )
ch = NUL;
else if( ch == '6' )
ch = 0x1e;
else if( ch == '-' )
ch = 0x1f;
else
modifiers |= MOD_MASK_CTRL;
}
if( modifiers & MOD_MASK_ALT )
{
ch = Meta( ch );
modifiers &= ~MOD_MASK_ALT;
}
}
else
{
return( Pt_CONTINUE );
}
}
else
modifiers &= ~MOD_MASK_SHIFT;
}
ch = simplify_key( ch, &modifiers );
if( modifiers )
{
string[ len++ ] = CSI;
string[ len++ ] = KS_MODIFIER;
string[ len++ ] = modifiers;
}
if( IS_SPECIAL( ch ) )
{
string[ len++ ] = CSI;
string[ len++ ] = K_SECOND( ch );
string[ len++ ] = K_THIRD( ch );
}
else
{
string[ len++ ] = ch;
}
if (len == 1 && ((ch == Ctrl_C && ctrl_c_interrupts)
|| ch == intr_char))
{
trash_input_buf();
got_int = TRUE;
}
if (len == 1 && string[0] == CSI)
{
/* Turn CSI into K_CSI. */
string[ len++ ] = KS_EXTRA;
string[ len++ ] = KE_CSI;
}
if( len > 0 )
{
add_to_input_buf( string, len );
return( Pt_CONSUME );
}
}
return( Pt_CONTINUE );
}
static int
gui_ph_handle_mouse( PtWidget_t *widget, void *data, PtCallbackInfo_t *info )
{
PhPointerEvent_t *pointer;
PhRect_t *pos;
int button = 0, repeated_click, modifiers = 0x0;
short mouse_x, mouse_y;
pointer = PhGetData( info->event );
pos = PhGetRects( info->event );
gui_mch_mousehide( MOUSE_SHOW );
/*
* Coordinates need to be relative to the base window,
* not relative to the vimTextArea widget
*/
mouse_x = pos->ul.x + gui.border_width;
mouse_y = pos->ul.y + gui.border_width;
if( info->event->type == Ph_EV_PTR_MOTION_NOBUTTON )
{
gui_mouse_moved( mouse_x, mouse_y );
return( Pt_CONTINUE );
}
if( pointer->key_mods & Pk_KM_Shift )
modifiers |= MOUSE_SHIFT;
if( pointer->key_mods & Pk_KM_Ctrl )
modifiers |= MOUSE_CTRL;
if( pointer->key_mods & Pk_KM_Alt )
modifiers |= MOUSE_ALT;
/*
* FIXME More than one button may be involved, but for
* now just deal with one
*/
if( pointer->buttons & Ph_BUTTON_SELECT )
button = MOUSE_LEFT;
if( pointer->buttons & Ph_BUTTON_MENU )
{
button = MOUSE_RIGHT;
/* Need the absolute coordinates for the popup menu */
abs_mouse.x = pointer->pos.x;
abs_mouse.y = pointer->pos.y;
}
if( pointer->buttons & Ph_BUTTON_ADJUST )
button = MOUSE_MIDDLE;
/* Catch a real release (not phantom or other releases */
if( info->event->type == Ph_EV_BUT_RELEASE )
button = MOUSE_RELEASE;
if( info->event->type & Ph_EV_PTR_MOTION_BUTTON )
button = MOUSE_DRAG;
#if 0
/* Vim doesn't use button repeats */
if( info->event->type & Ph_EV_BUT_REPEAT )
button = MOUSE_DRAG;
#endif
/* Don't do anything if it is one of the phantom mouse release events */
if( ( button != MOUSE_RELEASE ) ||
( info->event->subtype == Ph_EV_RELEASE_REAL ) )
{
repeated_click = (pointer->click_count >= 2) ? TRUE : FALSE;
gui_send_mouse_event( button , mouse_x, mouse_y, repeated_click, modifiers );
}
return( Pt_CONTINUE );
}
/* Handle a focus change of the PtRaw widget */
static int
gui_ph_handle_focus( PtWidget_t *widget, void *data, PtCallbackInfo_t *info )
{
if( info->reason == Pt_CB_LOST_FOCUS )
{
PtRemoveEventHandler( gui.vimTextArea, Ph_EV_PTR_MOTION_NOBUTTON,
gui_ph_handle_mouse, NULL );
gui_mch_mousehide( MOUSE_SHOW );
}
else
{
PtAddEventHandler( gui.vimTextArea, Ph_EV_PTR_MOTION_NOBUTTON,
gui_ph_handle_mouse, NULL );
}
return( Pt_CONTINUE );
}
static void
gui_ph_handle_raw_draw( PtWidget_t *widget, PhTile_t *damage )
{
PhRect_t *r;
PhPoint_t offset;
PhPoint_t translation;
if( is_ignore_draw == TRUE )
return;
PtSuperClassDraw( PtBasic, widget, damage );
PgGetTranslation( &translation );
PgClearTranslation();
#if 0
/*
* This causes some wierd probems, with drawing being done from
* within this raw drawing function (rather than just simple clearing
* and text drawing done by gui_redraw)
*
* The main problem is when PhBlit is used, and the cursor appearing
* in places where it shouldn't
*/
out_flush();
#endif
PtWidgetOffset( widget, &offset );
PhTranslatePoint( &offset, PtWidgetPos( gui.vimTextArea, NULL ) );
#if 1
/* Redraw individual damage regions */
if( damage->next != NULL )
damage = damage->next;
while( damage != NULL )
{
r = &damage->rect;
gui_redraw(
r->ul.x - offset.x, r->ul.y - offset.y,
r->lr.x - r->ul.x + 1,
r->lr.y - r->ul.y + 1 );
damage = damage->next;
}
#else
/* Redraw the rectangle that covers all the damaged regions */
r = &damage->rect;
gui_redraw(
r->ul.x - offset.x, r->ul.y - offset.y,
r->lr.x - r->ul.x + 1,
r->lr.y - r->ul.y + 1 );
#endif
PgSetTranslation( &translation, 0 );
}
static int
gui_ph_handle_pulldown_menu(
PtWidget_t *widget,
void *data,
PtCallbackInfo_t *info )
{
if( data != NULL )
{
vimmenu_T *menu = (vimmenu_T *) data;
PtPositionMenu( menu->submenu_id, NULL );
PtRealizeWidget( menu->submenu_id );
}
return( Pt_CONTINUE );
}
/* This is used for pulldown/popup menus and also toolbar buttons */
static int
gui_ph_handle_menu( PtWidget_t *widget, void *data, PtCallbackInfo_t *info )
{
if( data != NULL )
{
vimmenu_T *menu = (vimmenu_T *) data;
gui_menu_cb( menu );
}
return( Pt_CONTINUE );
}
/* Stop focus from disappearing into the menubar... */
static int
gui_ph_handle_menu_unrealized(
PtWidget_t *widget,
void *data,
PtCallbackInfo_t *info )
{
PtGiveFocus( gui.vimTextArea, NULL );
return( Pt_CONTINUE );
}
static int
gui_ph_handle_window_open(
PtWidget_t *widget,
void *data,
PtCallbackInfo_t *info )
{
gui_set_shellsize( FALSE, TRUE );
return( Pt_CONTINUE );
}
/****************************************************************************/
#define DRAW_START gui_ph_draw_start()
#define DRAW_END gui_ph_draw_end()
/* TODO: Set a clipping rect? */
static void
gui_ph_draw_start( void )
{
PgSetRegion( PtWidgetRid( PtFindDisjoint( gui.vimTextArea ) ) );
PtWidgetOffset( gui.vimTextArea, &gui_ph_raw_offset );
PhTranslatePoint( &gui_ph_raw_offset, PtWidgetPos( gui.vimTextArea, NULL ) );
PgSetTranslation( &gui_ph_raw_offset, Pg_RELATIVE );
}
static void
gui_ph_draw_end( void )
{
gui_ph_raw_offset.x = -gui_ph_raw_offset.x;
gui_ph_raw_offset.y = -gui_ph_raw_offset.y;
PgSetTranslation( &gui_ph_raw_offset, Pg_RELATIVE );
}
#ifdef USE_PANEL_GROUP
static vimmenu_T *
gui_ph_find_buffer_item( char_u *name )
{
vimmenu_T *top_level = root_menu;
vimmenu_T *items = NULL;
while( top_level != NULL &&
( STRCMP( top_level->dname, "Buffers" ) != 0 ) )
top_level = top_level->next;
if( top_level != NULL )
{
items = top_level->children;
while( items != NULL &&
( STRCMP( items->dname, name ) != 0 ) )
items = items->next;
}
return( items );
}
static void
gui_ph_pg_set_buffer_num( int_u buf_num )
{
int i;
char search[16];
char *mark;
if( gui.vimTextArea == NULL || buf_num == 0 )
return;
search[0] = '(';
ultoa( buf_num, &search[1], 10 );
STRCAT( search, ")" );
for( i = 0; i < num_panels; i++ )
{
/* find the last "(" in the panel title and see if the buffer
* number in the title matches the one we're looking for */
mark = STRRCHR( panel_titles[ i ], '(' );
if( mark != NULL && STRCMP( mark, search ) == 0 )
{
PtSetResource( gui.vimPanelGroup, Pt_ARG_PG_CURRENT_INDEX,
i, 0 );
}
}
}
static int
gui_ph_handle_pg_change(
PtWidget_t *widget,
void *data,
PtCallbackInfo_t *info )
{
vimmenu_T *menu;
PtPanelGroupCallback_t *panel;
if( info->event != NULL )
{
panel = info->cbdata;
if( panel->new_panel != NULL )
{
menu = gui_ph_find_buffer_item( panel->new_panel );
if( menu )
gui_menu_cb( menu );
}
}
return( Pt_CONTINUE );
}
static void
gui_ph_get_panelgroup_margins(
short *top,
short *bottom,
short *left,
short *right )
{
unsigned short abs_raw_x, abs_raw_y, abs_panel_x, abs_panel_y;
const unsigned short *margin_top, *margin_bottom;
const unsigned short *margin_left, *margin_right;
PtGetAbsPosition( gui.vimTextArea, &abs_raw_x, &abs_raw_y );
PtGetAbsPosition( gui.vimPanelGroup, &abs_panel_x, &abs_panel_y );
PtGetResource( gui.vimPanelGroup, Pt_ARG_MARGIN_RIGHT, &margin_right, 0 );
PtGetResource( gui.vimPanelGroup, Pt_ARG_MARGIN_BOTTOM, &margin_bottom, 0 );
abs_raw_x -= abs_panel_x;
abs_raw_y -= abs_panel_y;
*top = abs_raw_y;
*bottom = *margin_bottom;
*left = abs_raw_x;
*right = *margin_right;
}
/* Used for the tabs for PtPanelGroup */
static int
gui_ph_is_buffer_item( vimmenu_T *menu, vimmenu_T *parent )
{
char *mark;
if( STRCMP( parent->dname, "Buffers" ) == 0 )
{
/* Look for '(' digits ')' */
mark = vim_strchr( menu->dname, '(' );
if( mark != NULL )
{
mark++;
while( isdigit( *mark ) )
mark++;
if( *mark == ')' )
return( TRUE);
}
}
return( FALSE );
}
static void
gui_ph_pg_add_buffer(char *name )
{
char **new_titles = NULL;
new_titles = (char **) alloc( ( num_panels + 1 ) * sizeof( char ** ) );
if( new_titles != NULL )
{
if( num_panels > 0 )
memcpy( new_titles, panel_titles, num_panels * sizeof( char ** ) );
new_titles[ num_panels++ ] = name;
PtSetResource( gui.vimPanelGroup, Pt_ARG_PG_PANEL_TITLES, new_titles,
num_panels );
vim_free( panel_titles );
panel_titles = new_titles;
}
}
static void
gui_ph_pg_remove_buffer( char *name )
{
int i;
char **new_titles = NULL;
/* If there is only 1 panel, we just use the temporary place holder */
if( num_panels > 1 )
{
new_titles = (char **) alloc( ( num_panels - 1 ) * sizeof( char ** ) );
if( new_titles != NULL )
{
char **s = new_titles;
/* Copy all the titles except the one we're removing */
for( i = 0; i < num_panels; i++ )
{
if( STRCMP( panel_titles[ i ], name ) != 0 )
{
*s++ = panel_titles[ i ];
}
}
num_panels--;
PtSetResource( gui.vimPanelGroup, Pt_ARG_PG_PANEL_TITLES, new_titles,
num_panels );
vim_free( panel_titles );
panel_titles = new_titles;
}
}
else
{
num_panels--;
PtSetResource( gui.vimPanelGroup, Pt_ARG_PG_PANEL_TITLES, &empty_title,
1 );
vim_free( panel_titles );
panel_titles = NULL;
}
}
/* When a buffer item is deleted from the buffer menu */
static int
gui_ph_handle_buffer_remove(
PtWidget_t *widget,
void *data,
PtCallbackInfo_t *info )
{
vimmenu_T *menu;
if( data != NULL )
{
menu = (vimmenu_T *) data;
gui_ph_pg_remove_buffer( menu->dname );
}
return( Pt_CONTINUE );
}
#endif
static int
gui_ph_pane_resize( PtWidget_t *widget, void *data, PtCallbackInfo_t *info )
{
if( PtWidgetIsRealized( widget ) )
{
is_ignore_draw = TRUE;
PtStartFlux( gui.vimContainer );
PtContainerHold( gui.vimContainer );
}
return( Pt_CONTINUE );
}
/****************************************************************************/
#ifdef FEAT_MBYTE
void
gui_ph_encoding_changed( int new_encoding )
{
/* Default encoding is latin1 */
char *charset = "latin1";
int i;
struct {
int encoding;
char *name;
} charsets[] = {
{ DBCS_JPN, "SHIFT_JIS" },
{ DBCS_KOR, "csEUCKR" },
{ DBCS_CHT, "big5" },
{ DBCS_CHS, "gb" }
};
for( i = 0; i < ARRAY_LENGTH( charsets ); i++ )
{
if( new_encoding == charsets[ i ].encoding )
charset = charsets[ i ].name;
}
charset_translate = PxTranslateSet( charset_translate, charset );
}
#endif
/****************************************************************************/
/****************************************************************************/
void
gui_mch_prepare(argc, argv)
int *argc;
char **argv;
{
PtInit( NULL );
}
int
gui_mch_init(void)
{
PtArg_t args[10];
int flags = 0, n = 0;
PhDim_t window_size = {100, 100}; /* Abitrary values */
PhPoint_t pos = {0, 0};
gui.event_buffer = (PhEvent_t *) alloc( EVENT_BUFFER_SIZE );
if( gui.event_buffer == NULL )
return( FAIL );
/* Get a translation so we can convert from ISO Latin-1 to UTF */
charset_translate = PxTranslateSet( NULL, "latin1" );
/* The +2 is for the 1 pixel dark line on each side */
gui.border_offset = gui.border_width = GUI_PH_MARGIN + 2;
/* Handle close events ourselves */
PtSetArg( &args[ n++ ], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_FALSE, Ph_WM_CLOSE );
PtSetArg( &args[ n++ ], Pt_ARG_WINDOW_NOTIFY_FLAGS, Pt_TRUE,
Ph_WM_CLOSE | Ph_WM_RESIZE | Ph_WM_FOCUS );
PtSetArg( &args[ n++ ], Pt_ARG_DIM, &window_size, 0 );
gui.vimWindow = PtCreateWidget( PtWindow, NULL, n, args );
if( gui.vimWindow == NULL )
return( FAIL );
PtAddCallback( gui.vimWindow, Pt_CB_WINDOW, gui_ph_handle_window_cb, NULL );
PtAddCallback( gui.vimWindow, Pt_CB_WINDOW_OPENING,
gui_ph_handle_window_open, NULL );
n = 0;
PtSetArg( &args[ n++ ], Pt_ARG_ANCHOR_FLAGS, Pt_ANCHOR_ALL, Pt_IS_ANCHORED );
PtSetArg( &args[ n++ ], Pt_ARG_DIM, &window_size, 0 );
PtSetArg( &args[ n++ ], Pt_ARG_POS, &pos, 0 );
#ifdef USE_PANEL_GROUP
/* Put in a temprary place holder title */
PtSetArg( &args[ n++ ], Pt_ARG_PG_PANEL_TITLES, &empty_title, 1 );
gui.vimPanelGroup = PtCreateWidget( PtPanelGroup, gui.vimWindow, n, args );
if( gui.vimPanelGroup == NULL )
return( FAIL );
PtAddCallback( gui.vimPanelGroup, Pt_CB_PG_PANEL_SWITCHING,
gui_ph_handle_pg_change, NULL );
#else
/* Turn off all edge decorations */
PtSetArg( &args[ n++ ], Pt_ARG_BASIC_FLAGS, Pt_FALSE, Pt_ALL );
PtSetArg( &args[ n++ ], Pt_ARG_BEVEL_WIDTH, 0, 0 );
PtSetArg( &args[ n++ ], Pt_ARG_MARGIN_WIDTH, 0, 0 );
PtSetArg( &args[ n++ ], Pt_ARG_MARGIN_HEIGHT, 0, 0 );
PtSetArg( &args[ n++ ], Pt_ARG_CONTAINER_FLAGS, Pt_TRUE, Pt_AUTO_EXTENT );
gui.vimContainer = PtCreateWidget( PtPane, gui.vimWindow, n, args );
if( gui.vimContainer == NULL )
return( FAIL );
PtAddCallback( gui.vimContainer, Pt_CB_RESIZE, gui_ph_pane_resize, NULL );
#endif
/* Size for the text area is set in gui_mch_set_text_area_pos */
n = 0;
PtSetArg( &args[ n++ ], Pt_ARG_RAW_DRAW_F, gui_ph_handle_raw_draw, 1 );
PtSetArg( &args[ n++ ], Pt_ARG_BEVEL_WIDTH, GUI_PH_MARGIN, 0 );
/*
* Using focus render also causes the whole widget to be redrawn
* whenever it changes focus, which is very annoying :p
*/
PtSetArg( &args[ n++ ], Pt_ARG_FLAGS, Pt_TRUE,
Pt_GETS_FOCUS | Pt_HIGHLIGHTED );
#ifndef FEAT_MOUSESHAPE
PtSetArg( &args[ n++ ], Pt_ARG_CURSOR_TYPE, GUI_PH_MOUSE_TYPE, 0 );
PtSetArg( &args[ n++ ], Pt_ARG_CURSOR_COLOR, gui_ph_mouse_color, 0 );
#endif
gui.vimTextArea = PtCreateWidget( PtRaw, Pt_DFLT_PARENT, n, args );
if( gui.vimTextArea == NULL)
return( FAIL );
/* TODO: use PtAddEventHandlers instead? */
/* Not using Ph_EV_BUT_REPEAT because vim wouldn't use it anyway */
PtAddEventHandler( gui.vimTextArea,
Ph_EV_BUT_PRESS | Ph_EV_BUT_RELEASE | Ph_EV_PTR_MOTION_BUTTON,
gui_ph_handle_mouse, NULL );
PtAddEventHandler( gui.vimTextArea, Ph_EV_KEY,
gui_ph_handle_keyboard, NULL );
PtAddCallback( gui.vimTextArea, Pt_CB_GOT_FOCUS,
gui_ph_handle_focus, NULL );
PtAddCallback( gui.vimTextArea, Pt_CB_LOST_FOCUS,
gui_ph_handle_focus, NULL );
/*
* Now that the text area widget has been created, set up the colours,
* which wil call PtSetResource from gui_mch_new_colors
*/
/*
* Create the two timers, not as accurate as using the kernel timer
* functions, but good enough
*/
gui_ph_timer_cursor = PtCreateWidget( PtTimer, gui.vimWindow, 0, NULL );
if( gui_ph_timer_cursor == NULL )
return( FAIL );
gui_ph_timer_timeout = PtCreateWidget( PtTimer, gui.vimWindow, 0, NULL );
if( gui_ph_timer_timeout == NULL )
return( FAIL );
PtAddCallback( gui_ph_timer_cursor, Pt_CB_TIMER_ACTIVATE,
gui_ph_handle_timer_cursor, NULL);
PtAddCallback( gui_ph_timer_timeout, Pt_CB_TIMER_ACTIVATE,
gui_ph_handle_timer_timeout, NULL);
#ifdef FEAT_MENU
n = 0;
PtSetArg( &args[ n++ ], Pt_ARG_WIDTH, window_size.w, 0 );
PtSetArg( &args[ n++ ], Pt_ARG_ANCHOR_FLAGS, Pt_ANCHOR_LEFT_RIGHT,
Pt_IS_ANCHORED );
gui.vimToolBarGroup = PtCreateWidget( PtToolbarGroup, gui.vimWindow,
n, args );
if( gui.vimToolBarGroup == NULL )
return( FAIL );
PtAddCallback( gui.vimToolBarGroup, Pt_CB_RESIZE,
gui_ph_handle_menu_resize, NULL );
n = 0;
flags = 0;
PtSetArg( &args[ n++ ], Pt_ARG_WIDTH, window_size.w, 0 );
if( ! vim_strchr( p_go, GO_MENUS ) )
{
flags |= Pt_DELAY_REALIZE;
PtSetArg( &args[ n++ ], Pt_ARG_FLAGS, Pt_TRUE, flags );
}
gui.vimMenuBar = PtCreateWidget( PtMenuBar, gui.vimToolBarGroup, n, args );
if( gui.vimMenuBar == NULL )
return( FAIL );
# ifdef FEAT_TOOLBAR
n = 0;
PtSetArg( &args[ n++ ], Pt_ARG_ANCHOR_FLAGS,
Pt_ANCHOR_LEFT_RIGHT |Pt_TOP_ANCHORED_TOP, Pt_IS_ANCHORED );
PtSetArg( &args[ n++ ], Pt_ARG_RESIZE_FLAGS, Pt_TRUE,
Pt_RESIZE_Y_AS_REQUIRED );
PtSetArg( &args[ n++ ], Pt_ARG_WIDTH, window_size.w, 0 );
flags = Pt_GETS_FOCUS;
if( ! vim_strchr( p_go, GO_TOOLBAR ) )
flags |= Pt_DELAY_REALIZE;
PtSetArg( &args[ n++ ], Pt_ARG_FLAGS, Pt_DELAY_REALIZE, flags );
gui.vimToolBar = PtCreateWidget( PtToolbar, gui.vimToolBarGroup, n, args );
if( gui.vimToolBar == NULL )
return( FAIL );
/*
* Size for the toolbar is fetched in gui_mch_show_toolbar, after
* the buttons have been added and the toolbar has resized it's height
* for the buttons to fit
*/
# endif
#endif
return( OK );
}
int
gui_mch_init_check(void)
{
return( (is_photon_available == TRUE) ? OK : FAIL );
}
int
gui_mch_open(void)
{
gui.norm_pixel = Pg_BLACK;
gui.back_pixel = Pg_WHITE;
set_normal_colors();
gui_check_colors();
gui.def_norm_pixel = gui.norm_pixel;
gui.def_back_pixel = gui.back_pixel;
highlight_gui_started();
if (gui_win_x != -1 && gui_win_y != -1)
gui_mch_set_winpos(gui_win_x, gui_win_y);
return( (PtRealizeWidget( gui.vimWindow ) == 0) ? OK : FAIL );
}
void
gui_mch_exit(int rc)
{
PtDestroyWidget( gui.vimWindow );
PxTranslateSet( charset_translate, NULL );
vim_free( gui.event_buffer );
#ifdef USE_PANEL_GROUPS
vim_free( panel_titles );
#endif
}
/****************************************************************************/
/* events */
/* When no events are available, photon will call this function, working is
* set to FALSE, and the gui_mch_update loop will exit. */
static int
exit_gui_mch_update( void *data )
{
*(int *)data = FALSE;
return( Pt_END );
}
void
gui_mch_update(void)
{
int working = TRUE;
PtAppAddWorkProc( NULL, exit_gui_mch_update, &working );
while( ( working == TRUE ) && !vim_is_input_buf_full())
{
PtProcessEvent();
}
}
int
gui_mch_wait_for_chars(int wtime)
{
is_timeout = FALSE;
if( wtime > 0 )
PtSetResource( gui_ph_timer_timeout, Pt_ARG_TIMER_INITIAL, wtime, 0 );
while( 1 )
{
PtProcessEvent();
if( input_available() )
{
PtSetResource( gui_ph_timer_timeout, Pt_ARG_TIMER_INITIAL, 0, 0 );
return( OK );
}
else if( is_timeout == TRUE )
return( FAIL );
}
}
#if defined( FEAT_BROWSE ) || defined( PROTO )
/*
* Put up a file requester.
* Returns the selected name in allocated memory, or NULL for Cancel.
* saving, select file to write
* title title for the window
* default_name default name (well duh!)
* ext not used (extension added)
* initdir initial directory, NULL for current dir
* filter not used (file name filter)
*/
char_u *
gui_mch_browse(
int saving,
char_u *title,
char_u *default_name,
char_u *ext,
char_u *initdir,
char_u *filter)
{
PtFileSelectionInfo_t file;
int flags;
char_u *default_path;
char_u *open_text = NULL;
flags = 0;
memset( &file, 0, sizeof( file ) );
default_path = alloc( MAXPATHL + 1 + NAME_MAX + 1 );
if( default_path != NULL )
{
if( saving == TRUE )
{
/* Don't need Pt_FSR_CONFIRM_EXISTING, vim will ask anyway */
flags |= Pt_FSR_NO_FCHECK;
open_text = "&Save";
}
/* combine the directory and filename into a single path */
if( initdir == NULL || *initdir == NUL )
{
mch_dirname( default_path, MAXPATHL );
initdir = default_path;
}
else
{
STRCPY( default_path, initdir );
initdir = default_path;
}
if( default_name != NULL )
{
if( default_path[ STRLEN( default_path ) - 1 ] != '/' )
STRCAT( default_path, "/" );
STRCAT( default_path, default_name );
}
/* TODO: add a filter? */
PtFileSelection(
gui.vimWindow,
NULL,
title,
default_path,
NULL,
open_text,
NULL,
NULL,
&file,
flags );
vim_free( default_path );
if( file.ret == Pt_FSDIALOG_BTN1 )
return( vim_strsave( file.path ) );
}
return( NULL );
}
#endif
#if defined( FEAT_GUI_DIALOG ) || defined( PROTO )
static PtWidget_t *gui_ph_dialog_text = NULL;
static int
gui_ph_dialog_close( int button, void *data )
{
PtModalCtrl_t *modal_ctrl = data;
char_u *dialog_text, *vim_text;
if( gui_ph_dialog_text != NULL )
{
PtGetResource( gui_ph_dialog_text, Pt_ARG_TEXT_STRING, &dialog_text, 0 );
PtGetResource( gui_ph_dialog_text, Pt_ARG_POINTER, &vim_text, 0 );
STRNCPY( vim_text, dialog_text, IOSIZE - 1 );
}
PtModalUnblock( modal_ctrl, (void *) button );
return( Pt_TRUE );
}
static int
gui_ph_dialog_text_enter( PtWidget_t *widget, void *data, PtCallbackInfo_t *info )
{
if( info->reason_subtype == Pt_EDIT_ACTIVATE )
gui_ph_dialog_close( 1, data );
return( Pt_CONTINUE );
}
static int
gui_ph_dialog_esc( PtWidget_t *widget, void *data, PtCallbackInfo_t *info )
{
PhKeyEvent_t *key;
key = PhGetData( info->event );
if( ( key->key_flags & Pk_KF_Cap_Valid ) && ( key->key_cap == Pk_Escape ) )
{
gui_ph_dialog_close( 0, data );
return( Pt_CONSUME );
}
return( Pt_PROCESS );
}
int
gui_mch_dialog(
int type,
char_u *title,
char_u *message,
char_u *buttons,
int default_button,
char_u *textfield)
{
char_u *str;
char_u **button_array;
char_u *buttons_copy;
int button_count;
int i, len;
int dialog_result = -1;
/* FIXME: the vertical option in guioptions is blatantly ignored */
/* FIXME: so is the type */
button_count = len = i = 0;
if( buttons == NULL || *buttons == NUL )
return( -1 );
/* There is one less separator than buttons, so bump up the button count */
button_count = 1;
/* Count string length and number of seperators */
for( str = buttons; *str; str++ )
{
len++;
if( *str == DLG_BUTTON_SEP )
button_count++;
}
if ( title == NULL )
title = "Vim";
buttons_copy = alloc( len + 1 );
button_array = (char_u **) alloc( button_count * sizeof( char_u * ) );
if( buttons_copy != NULL && button_array != NULL )
{
STRCPY( buttons_copy, buttons );
/*
* Convert DLG_BUTTON_SEP into NUL's and fill in
* button_array with the pointer to each NUL terminated string
*/
str = buttons_copy;
for( i = 0; i < button_count; i++ )
{
button_array[ i ] = str;
for( ; *str; str++ )
{
if( *str == DLG_BUTTON_SEP )
{
*str++ = NUL;
break;
}
}
}
#ifndef FEAT_GUI_TEXTDIALOG
dialog_result = PtAlert(
gui.vimWindow, NULL,
title,
NULL,
message, NULL,
button_count, (const char **) button_array, NULL,
default_button, 0, Pt_MODAL );
#else
/* Writing the dialog ourselves lets us add extra features, like
* trapping the escape key and returning 0 to vim */
{
int n;
PtArg_t args[5];
PtWidget_t *dialog, *pane;
PtModalCtrl_t modal_ctrl;
PtDialogInfo_t di;
memset( &di, 0, sizeof( di ) );
memset( &modal_ctrl, 0, sizeof( modal_ctrl ) );
n = 0;
PtSetArg( &args[n++], Pt_ARG_GROUP_ROWS_COLS, 0, 0 );
PtSetArg( &args[n++], Pt_ARG_WIDTH, 350, 0 );
PtSetArg( &args[n++], Pt_ARG_GROUP_ORIENTATION,
Pt_GROUP_VERTICAL, 0 );
PtSetArg( &args[n++], Pt_ARG_GROUP_FLAGS,
Pt_TRUE, Pt_GROUP_NO_KEYS | Pt_GROUP_STRETCH_HORIZONTAL );
PtSetArg( &args[n++], Pt_ARG_CONTAINER_FLAGS, Pt_FALSE, Pt_TRUE );
pane = PtCreateWidget( PtGroup, NULL, n, args );
n = 0;
PtSetArg( &args[n++], Pt_ARG_TEXT_STRING, message, 0 );
PtCreateWidget( PtLabel, pane, n, args );
if( textfield != NULL )
{
n = 0;
PtSetArg( &args[n++], Pt_ARG_MAX_LENGTH, IOSIZE - 1, 0 );
PtSetArg( &args[n++], Pt_ARG_TEXT_STRING, textfield, 0 );
PtSetArg( &args[n++], Pt_ARG_POINTER, textfield, 0 );
gui_ph_dialog_text = PtCreateWidget( PtText, pane, n, args );
PtAddCallback( gui_ph_dialog_text, Pt_CB_ACTIVATE,
gui_ph_dialog_text_enter, &modal_ctrl );
}
di.parent = gui.vimWindow;
di.pane = pane;
di.title = title;
di.buttons = (const char **) button_array;
di.nbtns = button_count;
di.def_btn = default_button;
/* This is just to give the dialog the close button.
* We check for the Escape key ourselves and return 0 */
di.esc_btn = button_count;
di.callback = gui_ph_dialog_close;
di.data = &modal_ctrl;
dialog = PtCreateDialog( &di );
PtAddFilterCallback( dialog, Ph_EV_KEY,
gui_ph_dialog_esc, &modal_ctrl );
if( gui_ph_dialog_text != NULL )
PtGiveFocus( gui_ph_dialog_text, NULL );
/* Open dialog, block the vim window and wait for the dialog to close */
PtRealizeWidget( dialog );
PtMakeModal( dialog, Ph_CURSOR_NOINPUT, Ph_CURSOR_DEFAULT_COLOR );
dialog_result = (int) PtModalBlock( &modal_ctrl, 0 );
PtDestroyWidget( dialog );
gui_ph_dialog_text = NULL;
}
#endif
}
vim_free( button_array );
vim_free( buttons_copy );
return( dialog_result );
}
#endif
/****************************************************************************/
/* window size/position/state */
int
gui_mch_get_winpos(int *x, int *y)
{
PhPoint_t *pos;
pos = PtWidgetPos( gui.vimWindow, NULL );
*x = pos->x;
*y = pos->y;
return( OK );
}
void
gui_mch_set_winpos(int x, int y)
{
PhPoint_t pos = { x, y };
PtSetResource( gui.vimWindow, Pt_ARG_POS, &pos, 0 );
}
void
gui_mch_set_shellsize(int width, int height,
int min_width, int min_height, int base_width, int base_height)
{
PhDim_t window_size = { width, height };
PhDim_t min_size = { min_width, min_height };
#ifdef USE_PANEL_GROUP
window_size.w += pg_margin_left + pg_margin_right;
window_size.h += pg_margin_top + pg_margin_bottom;
#endif
PtSetResource( gui.vimWindow, Pt_ARG_MINIMUM_DIM, &min_size, 0 );
PtSetResource( gui.vimWindow, Pt_ARG_DIM, &window_size, 0 );
if( ! PtWidgetIsRealized( gui.vimWindow ) )
gui_ph_resize_container();
}
/*
* Return the amount of screen space that hasn't been allocated (such as
* by the shelf).
*/
void
gui_mch_get_screen_dimensions(int *screen_w, int *screen_h)
{
PhRect_t console;
PhWindowQueryVisible( Ph_QUERY_WORKSPACE, 0,
PhInputGroup( NULL ), &console );
*screen_w = console.lr.x - console.ul.x + 1;
*screen_h = console.lr.y - console.ul.y + 1;
}
void
gui_mch_iconify(void)
{
PhWindowEvent_t event;
memset( &event, 0, sizeof (event) );
event.event_f = Ph_WM_HIDE;
event.event_state = Ph_WM_EVSTATE_HIDE;
event.rid = PtWidgetRid( gui.vimWindow );
PtForwardWindowEvent( &event );
}
#if defined(FEAT_EVAL) || defined(PROTO)
/*
* Bring the Vim window to the foreground.
*/
void
gui_mch_set_foreground()
{
PhWindowEvent_t event;
memset( &event, 0, sizeof (event) );
event.event_f = Ph_WM_TOFRONT;
event.event_state = Ph_WM_EVSTATE_FFRONT;
event.rid = PtWidgetRid( gui.vimWindow );
PtForwardWindowEvent( &event );
}
#endif
void
gui_mch_settitle(char_u *title, char_u *icon)
{
#ifdef USE_PANEL_GROUP
gui_ph_pg_set_buffer_num( curwin->w_buffer->b_fnum );
#endif
PtSetResource( gui.vimWindow, Pt_ARG_WINDOW_TITLE, title, 0 );
/* Not sure what to do with the icon text, set balloon text somehow? */
}
/****************************************************************************/
/* Scrollbar */
void
gui_mch_set_scrollbar_thumb(scrollbar_T *sb, int val, int size, int max)
{
int n = 0;
PtArg_t args[3];
PtSetArg( &args[ n++ ], Pt_ARG_MAXIMUM, max, 0 );
PtSetArg( &args[ n++ ], Pt_ARG_SLIDER_SIZE, size, 0 );
PtSetArg( &args[ n++ ], Pt_ARG_GAUGE_VALUE, val, 0 );
PtSetResources( sb->id, n, args );
}
void
gui_mch_set_scrollbar_pos(scrollbar_T *sb, int x, int y, int w, int h)
{
PhArea_t area = {{ x, y }, { w, h }};
PtSetResource( sb->id, Pt_ARG_AREA, &area, 0 );
}
void
gui_mch_create_scrollbar(scrollbar_T *sb, int orient)
{
int n = 0;
/* int anchor_flags = 0;*/
PtArg_t args[4];
/*
* Stop the scrollbar from being realized when the parent
* is realized, so it can be explicitly realized by vim.
*
* Also, don't let the scrollbar get focus
*/
PtSetArg( &args[ n++ ], Pt_ARG_FLAGS, Pt_DELAY_REALIZE,
Pt_DELAY_REALIZE | Pt_GETS_FOCUS );
PtSetArg( &args[ n++ ], Pt_ARG_SCROLLBAR_FLAGS, Pt_SCROLLBAR_SHOW_ARROWS, 0);
#if 0
/* Don't need this anchoring for the scrollbars */
if( orient == SBAR_HORIZ )
{
anchor_flags = Pt_BOTTOM_ANCHORED_BOTTOM |
Pt_LEFT_ANCHORED_LEFT | Pt_RIGHT_ANCHORED_RIGHT;
}
else
{
anchor_flags = Pt_BOTTOM_ANCHORED_BOTTOM | Pt_TOP_ANCHORED_TOP;
if( sb->wp != NULL )
{
if( sb == &sb->wp->w_scrollbars[ SBAR_LEFT ] )
anchor_flags |= Pt_LEFT_ANCHORED_LEFT;
else
anchor_flags |= Pt_RIGHT_ANCHORED_RIGHT;
}
}
PtSetArg( &args[ n++ ], Pt_ARG_ANCHOR_FLAGS, anchor_flags, Pt_IS_ANCHORED );
#endif
PtSetArg( &args[ n++ ], Pt_ARG_ORIENTATION,
(orient == SBAR_HORIZ) ? Pt_HORIZONTAL : Pt_VERTICAL, 0 );
#ifdef USE_PANEL_GROUP
sb->id = PtCreateWidget( PtScrollbar, gui.vimPanelGroup, n, args );
#else
sb->id = PtCreateWidget( PtScrollbar, gui.vimContainer, n, args );
#endif
PtAddCallback( sb->id, Pt_CB_SCROLLBAR_MOVE, gui_ph_handle_scrollbar, sb );
}
void
gui_mch_enable_scrollbar(scrollbar_T *sb, int flag)
{
if( flag != 0 )
PtRealizeWidget( sb->id );
else
PtUnrealizeWidget( sb->id );
}
void
gui_mch_destroy_scrollbar(scrollbar_T *sb)
{
PtDestroyWidget( sb->id );
sb->id = NULL;
}
/****************************************************************************/
/* Mouse functions */
#if defined(FEAT_MOUSESHAPE) || defined(PROTO)
/* The last set mouse pointer shape is remembered, to be used when it goes
* from hidden to not hidden. */
static int last_shape = 0;
/* Table for shape IDs. Keep in sync with the mshape_names[] table in
* misc2.c! */
static int mshape_ids[] =
{
Ph_CURSOR_POINTER, /* arrow */
Ph_CURSOR_NONE, /* blank */
Ph_CURSOR_INSERT, /* beam */
Ph_CURSOR_DRAG_VERTICAL, /* updown */
Ph_CURSOR_DRAG_VERTICAL, /* udsizing */
Ph_CURSOR_DRAG_HORIZONTAL, /* leftright */
Ph_CURSOR_DRAG_HORIZONTAL, /* lrsizing */
Ph_CURSOR_WAIT, /* busy */
Ph_CURSOR_DONT, /* no */
Ph_CURSOR_CROSSHAIR, /* crosshair */
Ph_CURSOR_FINGER, /* hand1 */
Ph_CURSOR_FINGER, /* hand2 */
Ph_CURSOR_FINGER, /* pencil */
Ph_CURSOR_QUESTION_POINT, /* question */
Ph_CURSOR_POINTER, /* right-arrow */
Ph_CURSOR_POINTER, /* up-arrow */
Ph_CURSOR_POINTER /* last one */
};
void
mch_set_mouse_shape(shape)
int shape;
{
int id;
if (!gui.in_use)
return;
if (shape == MSHAPE_HIDE || gui.pointer_hidden)
PtSetResource( gui.vimTextArea, Pt_ARG_CURSOR_TYPE, Ph_CURSOR_NONE,
0 );
else
{
if (shape >= MSHAPE_NUMBERED)
id = Ph_CURSOR_POINTER;
else
id = mshape_ids[shape];
PtSetResource( gui.vimTextArea, Pt_ARG_CURSOR_TYPE, id, 0 );
}
if (shape != MSHAPE_HIDE)
last_shape = shape;
}
#endif
void
gui_mch_mousehide(int hide)
{
if( gui.pointer_hidden != hide )
{
gui.pointer_hidden = hide;
#ifdef FEAT_MOUSESHAPE
if( hide )
PtSetResource( gui.vimTextArea, Pt_ARG_CURSOR_TYPE,
Ph_CURSOR_NONE, 0 );
else
mch_set_mouse_shape( last_shape );
#else
PtSetResource( gui.vimTextArea, Pt_ARG_CURSOR_TYPE,
( hide == MOUSE_SHOW ) ? GUI_PH_MOUSE_TYPE : Ph_CURSOR_NONE,
0 );
#endif
}
}
int
gui_mch_get_mouse_x(void)
{
PhCursorInfo_t info;
short x, y;
/* FIXME: does this return the correct position,
* with respect to the border? */
PhQueryCursor( PhInputGroup( NULL ), &info );
PtGetAbsPosition( gui.vimTextArea , &x, &y );
return( info.pos.x - x );
}
int
gui_mch_get_mouse_y(void)
{
PhCursorInfo_t info;
short x, y;
PhQueryCursor( PhInputGroup( NULL ), &info );
PtGetAbsPosition( gui.vimTextArea , &x, &y );
/* TODO: Add border offset? */
return( info.pos.y - y );
}
void
gui_mch_setmouse(int x, int y)
{
short abs_x, abs_y;
PtGetAbsPosition( gui.vimTextArea, &abs_x, &abs_y );
/* Add the border offset? */
PhMoveCursorAbs( PhInputGroup( NULL ), abs_x + x, abs_y + y );
}
/****************************************************************************/
/* Colours */
/*
* Return the RGB value of a pixel as a long.
*/
long_u
gui_mch_get_rgb(guicolor_T pixel)
{
return PgRGB(PgRedValue(pixel), PgGreenValue(pixel), PgBlueValue(pixel));
}
void
gui_mch_new_colors(void)
{
#if 0 /* Don't bother changing the cursor colour */
short color_diff;
/*
* If there isn't enough difference between the background colour and
* the mouse pointer colour then change the mouse pointer colour
*/
color_diff = gui_get_lightness(gui_ph_mouse_color)
- gui_get_lightness(gui.back_pixel);
if( abs( color_diff ) < 64 )
{
short r, g, b;
/* not a great algorithm... */
r = PgRedValue( gui_ph_mouse_color ) ^ 255;
g = PgGreenValue( gui_ph_mouse_color ) ^ 255;
b = PgBlueValue( gui_ph_mouse_color ) ^ 255;
#ifndef FEAT_MOUSESHAPE
gui_ph_mouse_color = PgRGB( r, g, b );
PtSetResource( gui.vimTextArea, Pt_ARG_CURSOR_COLOR,
gui_ph_mouse_color, 0 );
#endif
}
#endif
PtSetResource( gui.vimTextArea, Pt_ARG_FILL_COLOR, gui.back_pixel, 0 );
}
static int
hex_digit(int c)
{
if (VIM_ISDIGIT(c))
return( c - '0' );
c = TOLOWER_ASC(c);
if (c >= 'a' && c <= 'f')
return( c - 'a' + 10 );
return( -1000 );
}
/*
* This should be split out into a seperate file,
* every port does basically the same thing.
*
* This is the gui_w32.c version (i think..)
* Return INVALCOLOR when failed.
*/
guicolor_T
gui_mch_get_color(char_u *name)
{
int i;
int r, g, b;
typedef struct GuiColourTable
{
char *name;
guicolor_T colour;
} GuiColourTable;
static GuiColourTable table[] =
{
{"Black", RGB(0x00, 0x00, 0x00)},
{"DarkGray", RGB(0x80, 0x80, 0x80)},
{"DarkGrey", RGB(0x80, 0x80, 0x80)},
{"Gray", RGB(0xC0, 0xC0, 0xC0)},
{"Grey", RGB(0xC0, 0xC0, 0xC0)},
{"LightGray", RGB(0xD3, 0xD3, 0xD3)},
{"LightGrey", RGB(0xD3, 0xD3, 0xD3)},
{"White", RGB(0xFF, 0xFF, 0xFF)},
{"DarkRed", RGB(0x80, 0x00, 0x00)},
{"Red", RGB(0xFF, 0x00, 0x00)},
{"LightRed", RGB(0xFF, 0xA0, 0xA0)},
{"DarkBlue", RGB(0x00, 0x00, 0x80)},
{"Blue", RGB(0x00, 0x00, 0xFF)},
{"LightBlue", RGB(0xA0, 0xA0, 0xFF)},
{"DarkGreen", RGB(0x00, 0x80, 0x00)},
{"Green", RGB(0x00, 0xFF, 0x00)},
{"LightGreen", RGB(0xA0, 0xFF, 0xA0)},
{"DarkCyan", RGB(0x00, 0x80, 0x80)},
{"Cyan", RGB(0x00, 0xFF, 0xFF)},
{"LightCyan", RGB(0xA0, 0xFF, 0xFF)},
{"DarkMagenta", RGB(0x80, 0x00, 0x80)},
{"Magenta", RGB(0xFF, 0x00, 0xFF)},
{"LightMagenta", RGB(0xFF, 0xA0, 0xFF)},
{"Brown", RGB(0x80, 0x40, 0x40)},
{"Yellow", RGB(0xFF, 0xFF, 0x00)},
{"LightYellow", RGB(0xFF, 0xFF, 0xA0)},
{"SeaGreen", RGB(0x2E, 0x8B, 0x57)},
{"Orange", RGB(0xFF, 0xA5, 0x00)},
{"Purple", RGB(0xA0, 0x20, 0xF0)},
{"SlateBlue", RGB(0x6A, 0x5A, 0xCD)},
{"Violet", RGB(0xEE, 0x82, 0xEE)},
};
/* is name #rrggbb format? */
if( name[0] == '#' && STRLEN( name ) == 7 )
{
r = hex_digit( name[1] ) * 16 + hex_digit( name[2] );
g = hex_digit( name[3] ) * 16 + hex_digit( name[4] );
b = hex_digit( name[5] ) * 16 + hex_digit( name[6] );
if( r < 0 || g < 0 || b < 0 )
return INVALCOLOR;
return( RGB( r, g, b ) );
}
for( i = 0; i < ARRAY_LENGTH( table ); i++ )
{
if( STRICMP( name, table[i].name ) == 0 )
return( table[i].colour );
}
/*
* Last attempt. Look in the file "$VIMRUNTIME/rgb.txt".
*/
{
#define LINE_LEN 100
FILE *fd;
char line[LINE_LEN];
char_u *fname;
fname = expand_env_save((char_u *)"$VIMRUNTIME/rgb.txt");
if (fname == NULL)
return INVALCOLOR;
fd = fopen((char *)fname, "rt");
vim_free(fname);
if (fd == NULL)
return INVALCOLOR;
while (!feof(fd))
{
int len;
int pos;
char *color;
fgets(line, LINE_LEN, fd);
len = STRLEN(line);
if (len <= 1 || line[len-1] != '\n')
continue;
line[len-1] = '\0';
i = sscanf(line, "%d %d %d %n", &r, &g, &b, &pos);
if (i != 3)
continue;
color = line + pos;
if (STRICMP(color, name) == 0)
{
fclose(fd);
return( (guicolor_T) RGB(r,g,b) );
}
}
fclose(fd);
}
return INVALCOLOR;
}
void
gui_mch_set_fg_color(guicolor_T color)
{
PgSetTextColor( color );
}
void
gui_mch_set_bg_color(guicolor_T color)
{
PgSetFillColor( color );
}
void
gui_mch_invert_rectangle(int row, int col, int nr, int nc)
{
PhRect_t rect;
rect.ul.x = FILL_X( col );
rect.ul.y = FILL_Y( row );
/* FIXME: This has an off by one pixel problem */
rect.lr.x = rect.ul.x + nc * gui.char_width;
rect.lr.y = rect.ul.y + nr * gui.char_height;
if( nc > 0 )
rect.lr.x -= 1;
if( nr > 0 )
rect.lr.y -= 1;
DRAW_START;
PgSetDrawMode( Pg_DrawModeDSTINVERT );
PgDrawRect( &rect, Pg_DRAW_FILL );
PgSetDrawMode( Pg_DrawModeSRCCOPY );
DRAW_END;
}
void
gui_mch_clear_block(int row1, int col1, int row2, int col2)
{
PhRect_t block = {
{ FILL_X( col1 ), FILL_Y( row1 ) },
{ FILL_X( col2 + 1 ) - 1, FILL_Y( row2 + 1 ) - 1}
};
DRAW_START;
gui_mch_set_bg_color( gui.back_pixel );
PgDrawRect( &block, Pg_DRAW_FILL );
DRAW_END;
}
void
gui_mch_clear_all()
{
PhRect_t text_rect = {
{ gui.border_width, gui.border_width },
{ Columns * gui.char_width + gui.border_width - 1 ,
Rows * gui.char_height + gui.border_width - 1 }
};
if( is_ignore_draw == TRUE )
return;
DRAW_START;
gui_mch_set_bg_color( gui.back_pixel );
PgDrawRect( &text_rect, Pg_DRAW_FILL );
DRAW_END;
}
void
gui_mch_delete_lines(int row, int num_lines)
{
PhRect_t rect;
PhPoint_t delta;
rect.ul.x = FILL_X( gui.scroll_region_left );
rect.ul.y = FILL_Y( row + num_lines );
rect.lr.x = FILL_X( gui.scroll_region_right + 1 ) - 1;
rect.lr.y = FILL_Y( gui.scroll_region_bot + 1) - 1;
PtWidgetOffset( gui.vimTextArea, &gui_ph_raw_offset );
PhTranslatePoint( &gui_ph_raw_offset, PtWidgetPos(gui.vimTextArea, NULL));
PhTranslateRect( &rect, &gui_ph_raw_offset );
delta.x = 0;
delta.y = -num_lines * gui.char_height;
PgFlush();
PhBlit( PtWidgetRid( PtFindDisjoint( gui.vimTextArea ) ), &rect, &delta );
gui_clear_block(
gui.scroll_region_bot - num_lines + 1,
gui.scroll_region_left,
gui.scroll_region_bot,
gui.scroll_region_right );
}
void
gui_mch_insert_lines(int row, int num_lines)
{
PhRect_t rect;
PhPoint_t delta;
rect.ul.x = FILL_X( gui.scroll_region_left );
rect.ul.y = FILL_Y( row );
rect.lr.x = FILL_X( gui.scroll_region_right + 1 ) - 1;
rect.lr.y = FILL_Y( gui.scroll_region_bot - num_lines + 1 ) - 1;
PtWidgetOffset( gui.vimTextArea, &gui_ph_raw_offset );
PhTranslatePoint( &gui_ph_raw_offset, PtWidgetPos( gui.vimTextArea, NULL ) );
PhTranslateRect( &rect, &gui_ph_raw_offset );
delta.x = 0;
delta.y = num_lines * gui.char_height;
PgFlush();
PhBlit( PtWidgetRid( PtFindDisjoint( gui.vimTextArea ) ) , &rect, &delta );
gui_clear_block( row, gui.scroll_region_left,
row + num_lines - 1, gui.scroll_region_right );
}
void
gui_mch_draw_string(int row, int col, char_u *s, int len, int flags)
{
static char *utf8_buffer = NULL;
static int utf8_len = 0;
PhPoint_t pos = { TEXT_X( col ), TEXT_Y( row ) };
PhRect_t rect;
if( is_ignore_draw == TRUE )
return;
DRAW_START;
if( !( flags & DRAW_TRANSP ) )
{
PgDrawIRect(
FILL_X( col ), FILL_Y( row ),
FILL_X( col + len ) - 1, FILL_Y( row + 1 ) - 1,
Pg_DRAW_FILL );
}
if( flags & DRAW_UNDERL )
PgSetUnderline( gui.norm_pixel, Pg_TRANSPARENT, 0 );
if( charset_translate != NULL
#ifdef FEAT_MBYTE
&& enc_utf8 == 0
#endif
)
{
int src_taken, dst_made;
/* Use a static buffer to avoid large amounts of de/allocations */
if( utf8_len < len )
{
utf8_buffer = realloc( utf8_buffer, len * MB_LEN_MAX );
utf8_len = len;
}
PxTranslateToUTF(
charset_translate,
s,
len,
&src_taken,
utf8_buffer,
utf8_len,
&dst_made );
s = utf8_buffer;
len = dst_made;
}
PgDrawText( s, len, &pos, 0 );
if( flags & DRAW_BOLD )
{
/* FIXME: try and only calculate these values once... */
rect.ul.x = FILL_X( col ) + 1;
rect.ul.y = FILL_Y( row );
rect.lr.x = FILL_X( col + len ) - 1;
rect.lr.y = FILL_Y( row + 1) - 1;
/* PgSetUserClip( NULL ) causes the scrollbar to not redraw... */
#if 0
pos.x++;
PgSetUserClip( &rect );
PgDrawText( s, len, &pos, 0 );
PgSetUserClip( NULL );
#else
rect.lr.y -= ( p_linespace + 1 ) / 2;
/* XXX: DrawTextArea doesn't work with phditto */
PgDrawTextArea( s, len, &rect, Pg_TEXT_BOTTOM );
#endif
}
if( flags & DRAW_UNDERL )
PgSetUnderline( Pg_TRANSPARENT, Pg_TRANSPARENT, 0 );
DRAW_END;
}
/****************************************************************************/
/* Cursor */
void
gui_mch_draw_hollow_cursor(guicolor_T color)
{
PhRect_t r;
/* FIXME: Double width characters */
r.ul.x = FILL_X( gui.col );
r.ul.y = FILL_Y( gui.row );
r.lr.x = r.ul.x + gui.char_width - 1;
r.lr.y = r.ul.y + gui.char_height - 1;
DRAW_START;
PgSetStrokeColor( color );
PgDrawRect( &r, Pg_DRAW_STROKE );
DRAW_END;
}
void
gui_mch_draw_part_cursor(int w, int h, guicolor_T color)
{
PhRect_t r;
r.ul.x = FILL_X( gui.col );
r.ul.y = FILL_Y( gui.row ) + gui.char_height - h;
r.lr.x = r.ul.x + w - 1;
r.lr.y = r.ul.y + h - 1;
DRAW_START;
gui_mch_set_bg_color( color );
PgDrawRect( &r, Pg_DRAW_FILL );
DRAW_END;
}
void
gui_mch_set_blinking(long wait, long on, long off)
{
blink_waittime = wait;
blink_ontime = on;
blink_offtime = off;
}
void
gui_mch_start_blink(void)
{
/* Only turn on the timer on if none of the times are zero */
if( blink_waittime && blink_ontime && blink_offtime && gui.in_focus)
{
PtSetResource( gui_ph_timer_cursor, Pt_ARG_TIMER_INITIAL,
blink_waittime, 0 );
blink_state = BLINK_ON;
gui_update_cursor(TRUE, FALSE);
}
}
void
gui_mch_stop_blink(void)
{
PtSetResource( gui_ph_timer_cursor, Pt_ARG_TIMER_INITIAL, 0, 0 );
if( blink_state == BLINK_OFF )
gui_update_cursor(TRUE, FALSE);
blink_state = BLINK_NONE;
}
/****************************************************************************/
/* miscellaneous functions */
void
gui_mch_beep(void)
{
PtBeep();
}
void
gui_mch_flash(int msec)
{
PgSetFillXORColor( Pg_BLACK, Pg_WHITE );
PgSetDrawMode( Pg_DRAWMODE_XOR );
gui_mch_clear_all();
gui_mch_flush();
ui_delay( (long) msec, TRUE );
gui_mch_clear_all();
PgSetDrawMode( Pg_DRAWMODE_OPAQUE );
gui_mch_flush();
}
void
gui_mch_flush(void)
{
PgFlush();
}
void
gui_mch_set_text_area_pos(int x, int y, int w, int h)
{
PhArea_t area = {{x, y}, {w, h}};
PtSetResource( gui.vimTextArea, Pt_ARG_AREA, &area, 0 );
}
int
gui_mch_haskey(char_u *name)
{
int i;
for (i = 0; special_keys[i].key_sym != 0; i++)
if (name[0] == special_keys[i].vim_code0 &&
name[1] == special_keys[i].vim_code1)
return( OK );
return( FAIL );
}
/****************************************************************************/
/* Menu */
#ifdef FEAT_TOOLBAR
#include "toolbar.phi"
static PhImage_t *gui_ph_toolbar_images[] = {
&tb_new_phi,
&tb_open_phi,
&tb_save_phi,
&tb_undo_phi,
&tb_redo_phi,
&tb_cut_phi,
&tb_copy_phi,
&tb_paste_phi,
&tb_print_phi,
&tb_help_phi,
&tb_find_phi,
&tb_save_all_phi,
&tb_save_session_phi,
&tb_new_session_phi,
&tb_load_session_phi,
&tb_macro_phi,
&tb_replace_phi,
&tb_close_phi,
&tb_maximize_phi,
&tb_minimize_phi,
&tb_split_phi,
&tb_shell_phi,
&tb_find_prev_phi,
&tb_find_next_phi,
&tb_find_help_phi,
&tb_make_phi,
&tb_jump_phi,
&tb_ctags_phi,
&tb_vsplit_phi,
&tb_maxwidth_phi,
&tb_minwidth_phi
};
static PhImage_t *
gui_ph_toolbar_load_icon( char_u *iconfile )
{
static PhImage_t external_icon;
PhImage_t *temp_phi = NULL;
temp_phi = PxLoadImage( iconfile, NULL );
if( temp_phi != NULL )
{
/* The label widget will free the image/palette/etc. for us when
* it's destroyed */
temp_phi->flags |= Ph_RELEASE_IMAGE_ALL;
memcpy( &external_icon, temp_phi, sizeof( external_icon ) );
free( temp_phi );
temp_phi = &external_icon;
}
return( temp_phi );
}
/*
* This returns either a builtin icon image, an external image or NULL
* if it can't find either. The caller can't and doesn't need to try and
* free() the returned image, and it can't store the image pointer.
* (When setting the Pt_ARG_LABEL_IMAGE resource, the contents of the
* PhImage_t are copied, and the original PhImage_t aren't needed anymore).
*/
static PhImage_t *
gui_ph_toolbar_find_icon( vimmenu_T *menu )
{
char_u full_pathname[ MAXPATHL + 1 ];
PhImage_t *icon = NULL;
if( menu->icon_builtin == FALSE )
{
if( menu->iconfile != NULL )
/* TODO: use gui_find_iconfile() */
icon = gui_ph_toolbar_load_icon( menu->iconfile );
/* TODO: Restrict loading to just .png? Search for any format? */
if( ( icon == NULL ) &&
( ( gui_find_bitmap( menu->name, full_pathname, "gif" ) == OK ) ||
( gui_find_bitmap( menu->name, full_pathname, "png" ) == OK ) ) )
icon = gui_ph_toolbar_load_icon( full_pathname );
if( icon != NULL )
return( icon );
}
if( menu->iconidx >= 0 &&
( menu->iconidx < ARRAY_LENGTH( gui_ph_toolbar_images ) ) )
{
return( gui_ph_toolbar_images[ menu->iconidx ] );
}
return( NULL );
}
#endif
#if defined( FEAT_MENU ) || defined( PROTO )
void
gui_mch_enable_menu(int flag)
{
if( flag != 0 )
PtRealizeWidget( gui.vimMenuBar );
else
PtUnrealizeWidget( gui.vimMenuBar );
}
void
gui_mch_set_menu_pos(int x, int y, int w, int h)
{
/* Nothing */
}
/* Change the position of a menu button in the parent */
static void
gui_ph_position_menu( PtWidget_t *widget, int priority )
{
PtWidget_t *traverse;
vimmenu_T *menu;
traverse = PtWidgetChildBack( PtWidgetParent( widget ) );
/* Iterate through the list of widgets in traverse, until
* we find the position we want to insert our widget into */
/* TODO: traverse from front to back, possible speedup? */
while( traverse != NULL )
{
PtGetResource( traverse, Pt_ARG_POINTER, &menu, 0 );
if( menu != NULL &&
priority < menu->priority &&
widget != traverse )
{
/* Insert the widget before the current traverse widget */
PtWidgetInsert( widget, traverse, 1 );
return;
}
traverse = PtWidgetBrotherInFront( traverse );
}
}
/* the index is ignored because it's not useful for our purposes */
void
gui_mch_add_menu(vimmenu_T *menu, int index)
{
vimmenu_T *parent = menu->parent;
char_u *accel_key;
char_u mnemonic_str[MB_LEN_MAX];
int n;
PtArg_t args[5];
menu->submenu_id = menu->id = NULL;
if( menu_is_menubar( menu->name ) )
{
accel_key = vim_strchr( menu->name, '&' );
if( accel_key != NULL )
{
mnemonic_str[0] = accel_key[1];
mnemonic_str[1] = NUL;
}
/* Create the menu button */
n = 0;
PtSetArg( &args[ n++ ], Pt_ARG_TEXT_STRING, menu->dname, 0 );
PtSetArg( &args[ n++ ], Pt_ARG_ACCEL_TEXT, menu->actext, 0 );
if( accel_key != NULL )
PtSetArg( &args[ n++ ], Pt_ARG_ACCEL_KEY, mnemonic_str, 0 );
PtSetArg( &args[ n++ ], Pt_ARG_POINTER, menu, 0 );
if( parent != NULL )
PtSetArg( &args[ n++ ], Pt_ARG_BUTTON_TYPE, Pt_MENU_RIGHT, 0 );
menu->id = PtCreateWidget( PtMenuButton,
(parent == NULL) ? gui.vimMenuBar : parent->submenu_id,
n, args );
PtAddCallback( menu->id, Pt_CB_ARM, gui_ph_handle_pulldown_menu, menu );
/* Create the actual menu */
n = 0;
if( parent != NULL )
PtSetArg( &args[ n++ ], Pt_ARG_MENU_FLAGS, Pt_TRUE, Pt_MENU_CHILD );
menu->submenu_id = PtCreateWidget( PtMenu, menu->id, n, args );
if( parent == NULL )
{
PtAddCallback( menu->submenu_id, Pt_CB_UNREALIZED,
gui_ph_handle_menu_unrealized, menu );
if( menu->mnemonic != 0 )
{
PtAddHotkeyHandler( gui.vimWindow, tolower( menu->mnemonic ),
Pk_KM_Alt, 0, menu, gui_ph_handle_pulldown_menu );
}
}
gui_ph_position_menu( menu->id, menu->priority );
/* Redraw menubar here instead of gui_mch_draw_menubar */
if( gui.menu_is_active )
PtRealizeWidget( menu->id );
}
else if( menu_is_popup( menu->name ) )
{
menu->submenu_id = PtCreateWidget( PtMenu, gui.vimWindow, 0, NULL );
PtAddCallback( menu->submenu_id, Pt_CB_UNREALIZED,
gui_ph_handle_menu_unrealized, menu );
}
}
void
gui_mch_add_menu_item(vimmenu_T *menu, int index)
{
vimmenu_T *parent = menu->parent;
char_u *accel_key;
char_u mnemonic_str[MB_LEN_MAX];
int n;
PtArg_t args[13];
n = 0;
PtSetArg( &args[ n++ ], Pt_ARG_POINTER, menu, 0 );
#ifdef FEAT_TOOLBAR
if( menu_is_toolbar( parent->name ) )
{
if( menu_is_separator( menu->name ) )
{
PtSetArg( &args[ n++ ], Pt_ARG_SEP_FLAGS,
Pt_SEP_VERTICAL, Pt_SEP_ORIENTATION );
PtSetArg( &args[ n++ ], Pt_ARG_SEP_TYPE, Pt_ETCHED_IN, 0 );
PtSetArg( &args[ n++ ], Pt_ARG_ANCHOR_FLAGS,
Pt_TRUE, Pt_ANCHOR_TOP_BOTTOM );
PtSetArg( &args[ n++ ], Pt_ARG_WIDTH, 2, 0 );
menu->id = PtCreateWidget( PtSeparator, gui.vimToolBar, n, args );
}
else
{
if( strstr( (const char *) p_toolbar, "text" ) != NULL )
{
PtSetArg( &args[ n++ ], Pt_ARG_BALLOON_POSITION,
Pt_BALLOON_BOTTOM, 0 );
PtSetArg( &args[ n++ ], Pt_ARG_TEXT_STRING, menu->dname, 0 );
PtSetArg( &args[ n++ ], Pt_ARG_TEXT_FONT, "TextFont08", 0 );
}
if( ( strstr( (const char *) p_toolbar, "icons" ) != NULL ) &&
( gui_ph_toolbar_images != NULL ) )
{
PtSetArg( &args[ n++ ], Pt_ARG_LABEL_IMAGE,
gui_ph_toolbar_find_icon( menu ), 0 );
PtSetArg( &args[ n++ ], Pt_ARG_LABEL_TYPE, Pt_TEXT_IMAGE, 0 );
PtSetArg( &args[ n++ ], Pt_ARG_TEXT_IMAGE_SPACING, 0, 0 );
}
if( strstr( (const char *) p_toolbar, "tooltips" ) != NULL )
{
PtSetArg( &args[ n++ ], Pt_ARG_LABEL_BALLOON,
gui_ph_show_tooltip, 0 );
PtSetArg( &args[ n++ ], Pt_ARG_LABEL_FLAGS,
Pt_TRUE, Pt_SHOW_BALLOON );
}
PtSetArg( &args[ n++ ], Pt_ARG_MARGIN_HEIGHT, 1, 0 );
PtSetArg( &args[ n++ ], Pt_ARG_MARGIN_WIDTH, 1, 0 );
PtSetArg( &args[ n++ ], Pt_ARG_FLAGS, Pt_FALSE,
Pt_HIGHLIGHTED | Pt_GETS_FOCUS );
PtSetArg( &args[ n++ ], Pt_ARG_FILL_COLOR, Pg_TRANSPARENT, 0 );
menu->id = PtCreateWidget( PtButton, gui.vimToolBar, n, args );
PtAddCallback( menu->id, Pt_CB_ACTIVATE, gui_ph_handle_menu, menu );
}
/* Update toolbar if it's open */
if( PtWidgetIsRealized( gui.vimToolBar ) )
PtRealizeWidget( menu->id );
}
else
#endif
if( menu_is_separator( menu->name ) )
{
menu->id = PtCreateWidget( PtSeparator, parent->submenu_id, n, args );
}
else
{
accel_key = vim_strchr( menu->name, '&' );
if( accel_key != NULL )
{
mnemonic_str[0] = accel_key[1];
mnemonic_str[1] = NUL;
}
PtSetArg( &args[ n++ ], Pt_ARG_TEXT_STRING, menu->dname, 0 );
if( accel_key != NULL )
PtSetArg( &args[ n++ ], Pt_ARG_ACCEL_KEY, mnemonic_str,
0 );
PtSetArg( &args[ n++ ], Pt_ARG_ACCEL_TEXT, menu->actext, 0 );
menu->id = PtCreateWidget( PtMenuButton, parent->submenu_id, n, args );
PtAddCallback( menu->id, Pt_CB_ACTIVATE, gui_ph_handle_menu, menu );
#ifdef USE_PANEL_GROUP
if( gui_ph_is_buffer_item( menu, parent ) == TRUE )
{
PtAddCallback( menu->id, Pt_CB_DESTROYED,
gui_ph_handle_buffer_remove, menu );
gui_ph_pg_add_buffer( menu->dname );
}
#endif
}
gui_ph_position_menu( menu->id, menu->priority );
}
void
gui_mch_destroy_menu(vimmenu_T *menu)
{
if( menu->submenu_id != NULL )
PtDestroyWidget( menu->submenu_id );
if( menu->id != NULL )
PtDestroyWidget( menu->id );
menu->submenu_id = NULL;
menu->id = NULL;
}
void
gui_mch_menu_grey(vimmenu_T *menu, int grey)
{
long flags, mask, fields;
if( menu->id == NULL )
return;
flags = PtWidgetFlags( menu->id );
if( PtWidgetIsClass( menu->id, PtMenuButton ) &&
PtWidgetIsClass( PtWidgetParent( menu->id ), PtMenu ) )
{
fields = Pt_FALSE;
mask = Pt_SELECTABLE | Pt_HIGHLIGHTED;
}
else
{
fields = Pt_TRUE;
mask = Pt_BLOCKED | Pt_GHOST;
}
if( ! grey )
fields = ~fields;
PtSetResource( menu->id, Pt_ARG_FLAGS, fields,
mask );
}
void
gui_mch_menu_hidden(vimmenu_T *menu, int hidden)
{
/* TODO: [un]realize the widget? */
}
void
gui_mch_draw_menubar(void)
{
/* The only time a redraw is needed is when a menu button
* is added to the menubar, and that is detected and the bar
* redrawn in gui_mch_add_menu_item
*/
}
void
gui_mch_show_popupmenu(vimmenu_T *menu)
{
PtSetResource( menu->submenu_id, Pt_ARG_POS, &abs_mouse, 0 );
PtRealizeWidget( menu->submenu_id );
}
void
gui_mch_toggle_tearoffs(int enable)
{
/* No tearoffs yet */
}
#endif
#if defined( FEAT_TOOLBAR ) || defined( PROTO )
void
gui_mch_show_toolbar(int showit)
{
if( showit )
PtRealizeWidget( gui.vimToolBar );
else
PtUnrealizeWidget( gui.vimToolBar );
}
#endif
/****************************************************************************/
/* Fonts */
static GuiFont
gui_ph_get_font(
char_u *font_name,
int_u font_flags,
int_u font_size,
/* Check whether the resulting font has the font flags and size that
* was asked for */
int_u enforce
)
{
char_u *font_tag;
FontQueryInfo info;
int_u style;
font_tag = alloc( MAX_FONT_TAG );
if( font_tag != NULL )
{
if( PfGenerateFontName( font_name, font_flags, font_size,
font_tag ) != NULL )
{
/* Enforce some limits on the font used */
style = PHFONT_INFO_FIXED;
if( enforce & PF_STYLE_BOLD )
style |= PHFONT_INFO_BOLD;
if( enforce & PF_STYLE_ANTIALIAS )
style |= PHFONT_INFO_ALIAS;
if( enforce & PF_STYLE_ITALIC )
style |= PHFONT_INFO_ITALIC;
PfQueryFontInfo( font_tag, &info );
if( info.size == 0 )
font_size = 0;
/* Make sure font size matches, and that the font style
* at least has the bits we're checking for */
if( font_size == info.size &&
style == (info.style & style) )
return( (GuiFont) font_tag );
}
vim_free( font_tag );
}
return( NULL );
}
/*
* Split up the vim font name
*
* vim_font is in the form of
* <name>:s<height>:a:b:i
*
* a = antialias
* b = bold
* i = italic
*
*/
static int
gui_ph_parse_font_name(
char_u *vim_font,
char_u **font_name,
int_u *font_flags,
int_u *font_size )
{
char_u *mark;
int_u name_len, size;
mark = vim_strchr( vim_font, ':' );
if( mark == NULL )
name_len = STRLEN( vim_font );
else
name_len = (int_u) ( mark - vim_font );
*font_name = vim_strnsave( vim_font, name_len );
if( *font_name != NULL )
{
if( mark != NULL )
{
while( *mark != NUL && *mark++ == ':')
{
switch( tolower( *mark++ ) )
{
case 'a': *font_flags |= PF_STYLE_ANTIALIAS; break;
case 'b': *font_flags |= PF_STYLE_BOLD; break;
case 'i': *font_flags |= PF_STYLE_ITALIC; break;
case 's':
size = getdigits( &mark );
/* Restrict the size to some vague limits */
if( size < 1 || size > 100 )
size = 8;
*font_size = size;
break;
default:
break;
}
}
}
return( TRUE );
}
return( FALSE );
}
int
gui_mch_init_font(char_u *vim_font_name, int fontset)
{
char_u *font_tag;
char_u *font_name = NULL;
int_u font_flags = 0;
int_u font_size = 12;
FontQueryInfo info;
PhRect_t extent;
if( vim_font_name == NULL )
{
/* Default font */
vim_font_name = "PC Term";
}
if( STRCMP( vim_font_name, "*" ) == 0 )
{
font_tag = PtFontSelection( gui.vimWindow, NULL, NULL,
"pcterm12", -1, PHFONT_FIXED, NULL );
if( font_tag == NULL )
return( FAIL );
gui_mch_free_font( gui.norm_font );
gui.norm_font = font_tag;
PfQueryFontInfo( font_tag, &info );
font_name = vim_strsave( info.font );
}
else
{
if( gui_ph_parse_font_name( vim_font_name, &font_name, &font_flags,
&font_size ) == FALSE )
return( FAIL );
font_tag = gui_ph_get_font( font_name, font_flags, font_size, 0 );
if( font_tag == NULL )
{
vim_free( font_name );
return( FAIL );
}
gui_mch_free_font( gui.norm_font );
gui.norm_font = font_tag;
}
gui_mch_free_font( gui.bold_font );
gui.bold_font = gui_ph_get_font( font_name, font_flags | PF_STYLE_BOLD,
font_size, PF_STYLE_BOLD );
gui_mch_free_font( gui.ital_font );
gui.ital_font = gui_ph_get_font( font_name, font_flags | PF_STYLE_ITALIC,
font_size, PF_STYLE_ITALIC );
/* This extent was brought to you by the letter 'g' */
PfExtentText( &extent, NULL, font_tag, "g", 1 );
gui.char_width = extent.lr.x - extent.ul.x + 1;
gui.char_height = (- extent.ul.y) + extent.lr.y + 1;
gui.char_ascent = - extent.ul.y;
vim_free( font_name );
return( OK );
}
int
gui_mch_adjust_charsize(void)
{
FontQueryInfo info;
PfQueryFontInfo( gui.norm_font, &info );
gui.char_height = - info.ascender + info.descender + p_linespace;
gui.char_ascent = - info.ascender + p_linespace / 2;
return( OK );
}
GuiFont
gui_mch_get_font(char_u *vim_font_name, int report_error)
{
char_u *font_name;
char_u *font_tag;
int_u font_size = 12;
int_u font_flags = 0;
if( gui_ph_parse_font_name( vim_font_name, &font_name, &font_flags,
&font_size ) != FALSE )
{
font_tag = gui_ph_get_font( font_name, font_flags, font_size, -1 );
vim_free( font_name );
if( font_tag != NULL )
return( (GuiFont) font_tag );
}
if( report_error )
EMSG2(e_font, vim_font_name );
return( FAIL );
}
#if defined(FEAT_EVAL) || defined(PROTO)
/*
* Return the name of font "font" in allocated memory.
* Don't know how to get the actual name, thus use the provided name.
*/
char_u *
gui_mch_get_fontname(font, name)
GuiFont font;
char_u *name;
{
if (name == NULL)
return NULL;
return vim_strsave(name);
}
#endif
void
gui_mch_set_font(GuiFont font)
{
PgSetFont( font );
}
void
gui_mch_free_font(GuiFont font)
{
vim_free( font );
}
Reference in a new issue View git blame Copy permalink