| /* 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 separately, |
| * 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, RESIZE_BOTH ); |
| 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 weird problems, 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, RESIZE_BOTH ); |
| 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 ) |
| { |
| PhGC_t *gc; |
| |
| gc = PgGetGC(); |
| PgSetRegion( PtWidgetRid( PtFindDisjoint( gui.vimTextArea ) ) ); |
| PgClearClippingsCx( gc ); |
| PgClearTranslationCx( gc ); |
| |
| 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}; /* Arbitrary 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, |
| int direction) |
| { |
| 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 |
| } |
| } |
| |
| void |
| gui_mch_getmouse(int *x, int *y) |
| { |
| PhCursorInfo_t info; |
| short ix, iy; |
| |
| /* FIXME: does this return the correct position, |
| * with respect to the border? */ |
| PhQueryCursor( PhInputGroup( NULL ), &info ); |
| PtGetAbsPosition( gui.vimTextArea , &ix, &iy ); |
| |
| *x = info.pos.x - ix; |
| *y = info.pos.y - iy; |
| } |
| |
| 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 separate 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)}, |
| {"Gray10", RGB(0x1A, 0x1A, 0x1A)}, |
| {"Grey10", RGB(0x1A, 0x1A, 0x1A)}, |
| {"Gray20", RGB(0x33, 0x33, 0x33)}, |
| {"Grey20", RGB(0x33, 0x33, 0x33)}, |
| {"Gray30", RGB(0x4D, 0x4D, 0x4D)}, |
| {"Grey30", RGB(0x4D, 0x4D, 0x4D)}, |
| {"Gray40", RGB(0x66, 0x66, 0x66)}, |
| {"Grey40", RGB(0x66, 0x66, 0x66)}, |
| {"Gray50", RGB(0x7F, 0x7F, 0x7F)}, |
| {"Grey50", RGB(0x7F, 0x7F, 0x7F)}, |
| {"Gray60", RGB(0x99, 0x99, 0x99)}, |
| {"Grey60", RGB(0x99, 0x99, 0x99)}, |
| {"Gray70", RGB(0xB3, 0xB3, 0xB3)}, |
| {"Grey70", RGB(0xB3, 0xB3, 0xB3)}, |
| {"Gray80", RGB(0xCC, 0xCC, 0xCC)}, |
| {"Grey80", RGB(0xCC, 0xCC, 0xCC)}, |
| {"Gray90", RGB(0xE5, 0xE5, 0xE5)}, |
| {"Grey90", RGB(0xE5, 0xE5, 0xE5)}, |
| {"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_set_sp_color(guicolor_T 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 Terminal"; |
| } |
| |
| 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 ); |
| } |
| |
| /* |
| * Adjust gui.char_height (after 'linespace' was changed). |
| */ |
| int |
| gui_mch_adjust_charheight(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 ); |
| } |
| |