xwidget-platform.h File Reference

Platform wrapper functions (Linux, MSWindows): This file contains forward definitions and structs for platform support. Platform specific implementations are located in xwidget-linux.c and xwidget-mswin.c. Xlib compatibility definitions are located in xputty-mswin.h. More...

Go to the source code of this file.

Data Structures
struct	Metrics_t
	Metrics_t - struct to receive window size, position & visibility Pass this struct to os_get_window_metrics() More...

Functions
Display *	os_open_display (char *display_name)
	os_open_display - Connect to the display to use
void	os_close_display (Display *dpy)
	os_close_display - Close connection to the used display
Window	os_get_root_window (Xputty *main, int flag)
	os_get_root_window - get a pointer to the root window (desktop)
void	os_destroy_window (Widget_t *w)
	os_destroy_window - destroy a widget (close and remove from processing)
void	os_translate_coords (Widget_t *w, Window from_window, Window to_window, int from_x, int from_y, int *to_x, int *to_y)
	os_translate_coords - get x,y related to destination Window
void	os_get_window_metrics (Widget_t *w, Metrics_t *metrics)
	os_get_window_metrics - Get the Merics_t struct related to a Widget_t
void	os_set_window_min_size (Widget_t *w, int min_width, int min_height, int base_width, int base_height)
	os_set_window_min_size - Set the min and base size of a Widget_t
void	os_move_window (Display *dpy, Widget_t *w, int x, int y)
	os_move_window - Move a Widget_t
void	os_resize_window (Display *dpy, Widget_t *w, int x, int y)
	os_resize_window - Resize a Widget_t
void	os_get_surface_size (cairo_surface_t *surface, int *width, int *height)
	os_get_surface_size - get the size of the cairo surface
void	os_set_widget_surface_size (Widget_t *w, int width, int height)
	os_set_widget_surface_size - set the size of a Widget_t cairo surface
void	os_create_main_window_and_surface (Widget_t *w, Xputty *app, Window win, int x, int y, int width, int height)
	os_create_main_window_and_surface - create a Widget_t with a acairo surface this function is used mainly internal on create_window()
void	os_create_widget_window_and_surface (Widget_t *w, Xputty *app, Widget_t *parent, int x, int y, int width, int height)
	os_create_main_widget_and_surface - create a Widget_t with a acairo surface this function is used mainly internal on create_widget()
void	os_set_title (Widget_t *w, const char *title)
	os_set_title - Set the title of a Widget_t
void	os_widget_show (Widget_t *w)
	os_widget_show - Show a Widget_t
void	os_widget_hide (Widget_t *w)
	os_widget_hide - Hide a Widget_t
void	os_show_tooltip (Widget_t *wid, Widget_t *w)
	os_show_tooltip - Show a tooltip of a Widget_t
void	os_transparent_draw (void *w_, void *user_data)
	os_transparent_draw - Draw the Widget_t to the back buffer
void	os_expose_widget (Widget_t *w)
	os_expose_widget - Draw the the back buffer to the Widget_t surface
void	os_send_configure_event (Widget_t *w, int x, int y, int width, int height)
	os_send_configure_event - Send a configure event to a Widget_t
void	os_send_button_press_event (Widget_t *w)
	os_send_button_press_event - Send a button press event to a Widget_t see XButtonEvent
void	os_send_button_release_event (Widget_t *w)
	os_send_button_release_event - Send a button release event to a Widget_t see XButtonEvent
void	os_send_systray_message (Widget_t *w)
	os_send_send_systray_message - Send a systray event to a Widget_t only working on Linux for now
void	os_adjustment_callback (void *w_, void *user_data)
	os_adjustment_callback - called when a adjustment value have changed used internal for redraw the Widget_t
bool	os_get_keyboard_input (Widget_t *w, XKeyEvent *key, char *buf, size_t bufsize)
	os_ get_keyboard_input - Get the Keyboard input and convert it to utf8
int	os_grab_pointer (Widget_t *w)
	os_grab_pointer - grab the mouse pointer. Works only on linux
void	os_set_input_mask (Widget_t *w)
	os_set_input_mask - set the Event mask to a Widget_t only work on linux, stub on Windows
void	os_set_window_attrb (Widget_t *w)
	os_set_window_attrb - set the attribute mask to a Widget_t only work on linux, stub on Windows
void	os_set_transient_for_hint (Widget_t *parent, Widget_t *w)
	os_set_ transient_for_hint - set a Widget_t transient to a other Widget_t only work on linux, stub on Windows
int	os_get_screen_height (Widget_t *w)
	os_get_screen_height - Get the height of the used Display
int	os_get_screen_width (Widget_t *w)
	os_get_screen_width - Get the width of the used Display
bool	os_is_directory (const char *filename)
	os_is directory - check if a given path is a directory or a file
char *	os_get_home_dir ()
	os_get_home_dir - get the users home directory
void	os_free_pixmap (Widget_t *w, Pixmap pixmap)
	os_free_pixmap - Free the memory used by a Pixmap only Linux, stub otherwise
char *	utf8_from_locale (char *localestr)
	utf8_from_locale - convert active codepage to utf8 must be freed by the caller
char *	locale_from_utf8 (char *utf8str)
	locale_from_utf8 - convert utf8 to active codepage must be freed by the caller
void	os_quit (Widget_t *w)
	os_quit - quit the main loop and free all used memory
void	os_quit_widget (Widget_t *w)
	os_quit_widget - remove a Widget_t from the main loop and free it's used memory
Atom	os_register_widget_destroy (Widget_t *wid)
	os_register_widget_destroy - Get the needed Atom to send a widget destroy message
Atom	os_register_wm_delete_window (Widget_t *wid)
	os_register_wm_delete_window - Get the needed Atom to send a widget delete message
void	os_widget_event_loop (void *w_, void *event, Xputty *main, void *user_data)
	os_widget_event_loop - the Widget_t event loop on windows all messges goes into WndProc, so stub here
void	os_run_embedded (Xputty *main)
	os_run_embedded - the event handling when run embedded on windows all messges goes into WndProc, so stub here
void	os_main_run (Xputty *main)
	os_main_run - start the event loop
void	os_init_dnd (Xputty *main)
	os_init_dnd - register a Widget_t for handling drag and drop events only implemented on linux

Detailed Description

Platform wrapper functions (Linux, MSWindows): This file contains forward definitions and structs for platform support. Platform specific implementations are located in xwidget-linux.c and xwidget-mswin.c. Xlib compatibility definitions are located in xputty-mswin.h.

Definition in file xwidget-platform.h.

Function Documentation

locale_from_utf8()

char * locale_from_utf8

(

char *

utf8str

)

locale_from_utf8 - convert utf8 to active codepage must be freed by the caller

Parameters

*utf8str

- Pointer to char to convert

Returns

*char - the converted char in locale format

Definition at line 48 of file xwidget-linux.c.

                                      {
    char *s_to = NULL;
    asprintf(&s_to, "%s",utf8str);
    return s_to;
}

References asprintf(), and convert_cp().

os_adjustment_callback()

void os_adjustment_callback	(	void *	w_,
		void *	user_data
	)

os_adjustment_callback - called when a adjustment value have changed used internal for redraw the Widget_t

Parameters

*w_	- Pointer to the widget
*user_data	- additional user data or NULL

Definition at line 737 of file xwidget-linux.c.

                                                       {
   Widget_t *w = (Widget_t *)w_;
   transparent_draw(w, user_data);
}

References transparent_draw(), and Widget_t::widget.

Referenced by create_widget(), and create_window().

os_close_display()

void os_close_display

(

Display *

dpy

)

os_close_display - Close connection to the used display

Parameters

*dpy	- Display to close

Definition at line 58 of file xwidget-linux.c.

                                    {
    XCloseDisplay(dpy);
}

Referenced by main_quit().

os_create_main_window_and_surface()

void os_create_main_window_and_surface	(	Widget_t *	w,
		Xputty *	app,
		Window	win,
		int	x,
		int	y,
		int	width,
		int	height
	)

os_create_main_window_and_surface - create a Widget_t with a acairo surface this function is used mainly internal on create_window()

Parameters

*w	- the Widget_t to create
*app	- the Xputty struct the Widget_t belongs to
*win	- the Parent Window were the Widget_t belongs to
x,y	- the position related to the Parent Window
*width,*height	- the Widget_t size

Definition at line 122 of file xwidget-linux.c.

                                                               {
    XSetWindowAttributes attributes;
    attributes.save_under = True;
    attributes.override_redirect = 0;
 
    long event_mask = StructureNotifyMask|ExposureMask|KeyPressMask 
                    |EnterWindowMask|LeaveWindowMask|ButtonReleaseMask
                    |ButtonPressMask|Button1MotionMask;
 
 
 
    w->widget = XCreateWindow(app->dpy, win , x, y, width, height, 0,
                            CopyFromParent, InputOutput, CopyFromParent,
                            CopyFromParent, &attributes);
    debug_print("XCreateWindow\n");
 
    XSetLocaleModifiers("");
    w->xim = XOpenIM(app->dpy, 0, 0, 0);
    if(!w->xim){
        XSetLocaleModifiers("@im=none");
        w->xim = XOpenIM(app->dpy, 0, 0, 0);
    }
 
    w->xic = XCreateIC(w->xim, XNInputStyle, XIMPreeditNothing | XIMStatusNothing,
                    XNClientWindow, w->widget, XNFocusWindow,  w->widget, NULL);
 
    XSetICFocus(w->xic);
 
    XSelectInput(app->dpy, w->widget, event_mask);
 
    os_set_window_min_size(w, width/2, height/2, width, height);
 
    w->surface =  cairo_xlib_surface_create (app->dpy, w->widget,  
                  DefaultVisual(app->dpy, DefaultScreen(app->dpy)), width, height);
}

References Xputty::childlist, childlist_add_child(), Xputty::dpy, os_set_window_min_size(), SetMouseTracking(), Widget_t::surface, szMainUIClassName, szWidgetUIClassName, Widget_t::widget, WndProc(), Widget_t::xic, and Widget_t::xim.

Referenced by create_window().

os_create_widget_window_and_surface()

void os_create_widget_window_and_surface	(	Widget_t *	w,
		Xputty *	app,
		Widget_t *	parent,
		int	x,
		int	y,
		int	width,
		int	height
	)

os_create_main_widget_and_surface - create a Widget_t with a acairo surface this function is used mainly internal on create_widget()

Parameters

*w	- the Widget_t to create
*app	- the Xputty struct the Widget_t belongs to
*parent	- the Parent Widget_t were the Widget_t belongs to
x,y	- the position related to the Parent Widget_t
*width,*height	- the Widget_t size

Definition at line 159 of file xwidget-linux.c.

                                                               {
    XSetWindowAttributes attributes;
    attributes.save_under = True;
    attributes.override_redirect = True;
 
    long event_mask = StructureNotifyMask|ExposureMask|KeyPressMask 
                    |EnterWindowMask|LeaveWindowMask|ButtonReleaseMask
                    |ButtonPressMask|Button1MotionMask;
 
 
 
    w->widget = XCreateWindow(app->dpy, parent->widget , x, y, width, height, 0,
                            CopyFromParent, InputOutput, CopyFromParent,
                            CopyFromParent|CWOverrideRedirect, &attributes);
    debug_print("XCreateWindow\n");
 
    XSetLocaleModifiers("");
    w->xim = XOpenIM(app->dpy, 0, 0, 0);
    if(!w->xim){
        XSetLocaleModifiers("@im=none");
        w->xim = XOpenIM(app->dpy, 0, 0, 0);
    }
 
    w->xic = XCreateIC(w->xim, XNInputStyle, XIMPreeditNothing | XIMStatusNothing,
                    XNClientWindow, w->widget, XNFocusWindow,  w->widget, NULL);
 
    XSetICFocus(w->xic);
 
    XSelectInput(app->dpy, w->widget, event_mask);
 
    w->surface =  cairo_xlib_surface_create (app->dpy, w->widget,  
                  DefaultVisual(app->dpy, DefaultScreen(app->dpy)), width, height);
}

References Xputty::childlist, childlist_add_child(), Xputty::dpy, SetMouseTracking(), Widget_t::surface, szWidgetUIClassName, Widget_t::widget, WndProc(), Widget_t::xic, and Widget_t::xim.

Referenced by create_widget().

os_destroy_window()

void os_destroy_window

(

Widget_t *

w

)

os_destroy_window - destroy a widget (close and remove from processing)

Parameters

*w	- widget to destroy

Definition at line 62 of file xwidget-linux.c.

                                    {
    if (w->xic) XDestroyIC(w->xic);
    if (w->xim) XCloseIM(w->xim);
    XUnmapWindow(w->app->dpy, w->widget);
    XDestroyWindow(w->app->dpy, w->widget);
}

References Widget_t::app, Xputty::dpy, Widget_t::widget, Widget_t::xic, and Widget_t::xim.

Referenced by destroy_widget().

os_expose_widget()

void os_expose_widget

(

Widget_t *

w

)

os_expose_widget - Draw the the back buffer to the Widget_t surface

Parameters

*w	- Pointer to the widget

Definition at line 222 of file xwidget-linux.c.

                                   {
    XEvent exp;
    memset(&exp, 0, sizeof(exp));
    exp.type = Expose;
    exp.xexpose.window = w->widget;
    XSendEvent(w->app->dpy, w->widget, False, ExposureMask, (XEvent *)&exp);
}

References Widget_t::app, Xputty::dpy, Widget_t::widget, and XEvent::window.

Referenced by _update_view(), and expose_widget().

os_free_pixmap()

void os_free_pixmap	(	Widget_t *	w,
		Pixmap	pixmap
	)

os_free_pixmap - Free the memory used by a Pixmap only Linux, stub otherwise

Parameters

*w	- Pointer to the widget
pixmap	- the pixmap to be freed

Definition at line 805 of file xwidget-linux.c.

                                                {
    XFreePixmap(w->app->dpy, pixmap);
}

References Widget_t::app, and Xputty::dpy.

os_get_home_dir()

char * os_get_home_dir

(

)

os_get_home_dir - get the users home directory

Returns

*char - return the users home directory must be freed by the caller

Definition at line 791 of file xwidget-linux.c.

                        {
    char *pPath = NULL;
    asprintf(&pPath, "%s", getenv("HOME"));
    assert(pPath != NULL);
    return pPath;
}

References asprintf().

os_get_keyboard_input()

bool os_get_keyboard_input	(	Widget_t *	w,
		XKeyEvent *	key,
		char *	buf,
		size_t	bufsize
	)

os_ get_keyboard_input - Get the Keyboard input and convert it to utf8

Parameters

*w	- Pointer to the widget
*key	- the XKeyEvent
*buf	- the buffer to write the key in utf8 format
bufsize	- the max buffer size to write to

Returns

bool - retrun true when the char is written to the buffer false on error

Definition at line 798 of file xwidget-linux.c.

                                                                                   {
    Status status;
    KeySym keysym;
    Xutf8LookupString(w->xic, key, buf, bufsize - 1, &keysym, &status);
    return (status == XLookupChars || status == XLookupBoth);
}

References utf8_from_locale(), XEvent::vk, XEvent::vk_is_final_char, and Widget_t::xic.

os_get_root_window()

Window os_get_root_window	(	Xputty *	main,
		int	flag
	)

os_get_root_window - get a pointer to the root window (desktop)

Parameters

*main	- pointer to the Xputty struct
flag	- Could be IS_WIDGET for NO decorated windows (popup etc.) or IS_WINDOW for decorated TopLevel Windows (Dialogs, MainWindow, etc)

Returns

WINDOW - return pointer to the parent Window to use

Examples

simple-example.c.

Definition at line 69 of file xwidget-linux.c.

                                                  {
    return DefaultRootWindow(main->dpy);
}

References Xputty::dpy, and IS_WIDGET.

Referenced by _configure_combobox_menu(), _configure_menu(), _popup_spinbox(), add_popup_spinbox(), create_combobox_menu(), create_menu(), create_tooltip(), mk_open_midi_keyboard(), open_directory_dialog(), open_file_dialog(), open_message_dialog(), open_midi_keyboard(), os_show_tooltip(), and save_file_dialog().

os_get_screen_height()

int os_get_screen_height

(

Widget_t *

w

)

os_get_screen_height - Get the height of the used Display

Parameters

*w	- Pointer to the widget

Returns

int - the height of the Display

Definition at line 776 of file xwidget-linux.c.

                                     {
    int snum = DefaultScreen(w->app->dpy);
    return DisplayHeight(w->app->dpy, snum);
}

References Widget_t::app, and Xputty::dpy.

Referenced by _configure_combobox_menu(), and _configure_menu().

os_get_screen_width()

int os_get_screen_width

(

Widget_t *

w

)

os_get_screen_width - Get the width of the used Display

Parameters

*w	- Pointer to the widget

Returns

int - the width of the Display

Definition at line 781 of file xwidget-linux.c.

                                    {
    int snum = DefaultScreen(w->app->dpy);
    return DisplayWidth(w->app->dpy, snum);
}

References Widget_t::app, and Xputty::dpy.

os_get_surface_size()

void os_get_surface_size	(	cairo_surface_t *	surface,
		int *	width,
		int *	height
	)

os_get_surface_size - get the size of the cairo surface

Parameters

*surface	- the cairo surface
*width,*height	- (Pointer) to get the size

Definition at line 113 of file xwidget-linux.c.

                                                                            {
    *width = cairo_xlib_surface_get_width(surface);
    *height = cairo_xlib_surface_get_height(surface);
}

Referenced by _draw_frame(), _draw_h_meter(), _draw_image(), _draw_image_button(), _draw_image_button_with_label(), _draw_image_knob(), _draw_image_slider(), _draw_playhead(), and _draw_v_meter().

os_get_window_metrics()

void os_get_window_metrics	(	Widget_t *	w,
		Metrics_t *	metrics
	)

os_get_window_metrics - Get the Merics_t struct related to a Widget_t

Parameters

*w	- Pointer to the widget
*metrics	- Pointer to the Metrics_t struct to hold the info for widget

Definition at line 80 of file xwidget-linux.c.

                                                             {
    Widget_t *wid = (Widget_t*)w_;
    XWindowAttributes attrs;
    XGetWindowAttributes(wid->app->dpy, (Window)wid->widget, &attrs);
    metrics->x = attrs.x;
    metrics->y = attrs.y;
    metrics->width = attrs.width;
    metrics->height = attrs.height;
    metrics->visible = (attrs.map_state == IsViewable);
}

References Widget_t::app, Xputty::dpy, Metrics_t::height, Widget_t::parent, Metrics_t::visible, Widget_t::widget, Metrics_t::width, Metrics_t::x, and Metrics_t::y.

Referenced by _buttons_released(), _combobox_entry_released(), _combobox_key_pressed(), _combobox_motion(), _configure_listbox(), _configure_listview(), _configure_menu(), _draw_accel_check_item(), _draw_accel_item(), _draw_base_button(), _draw_button(), _draw_buttons(), _draw_check_box(), _draw_check_button(), _draw_check_item(), _draw_combobox(), _draw_combobox_button(), _draw_combobox_entrys(), _draw_combobox_menu_slider(), _draw_frame(), _draw_h_meter(), _draw_hmeter_scale(), _draw_hslider(), _draw_image(), _draw_item(), _draw_knob(), _draw_label(), _draw_list(), _draw_listbox_item(), _draw_listbox_viewslider(), _draw_listviewslider(), _draw_menu_label(), _draw_menu_slider(), _draw_multi_list(), _draw_multi_listviewslider(), _draw_on_off_button(), _draw_spinbox(), _draw_submenu(), _draw_switch_image_button(), _draw_tabbox(), _draw_ti_button(), _draw_tooltip(), _draw_tuner(), _draw_v_meter(), _draw_value_item(), _draw_valuedisplay(), _draw_vmeter_scale(), _draw_vslider(), _draw_waveview(), _enter_submenu(), _has_pointer(), _list_entry_double_clicked(), _list_entry_released(), _list_key_pressed(), _list_motion(), _multi_list_entry_double_clicked(), _multi_list_entry_released(), _multi_list_key_pressed(), _reconfigure_combobox_viewport(), _reconfigure_listbox_viewport(), _reconfigure_listview_viewport(), _reconfigure_multi_listview_viewport(), _set_listbox_viewpoint(), _set_viewpoint(), _tab_button_released(), _update_list_view(), _update_view(), cmenu_add_submenu(), configure_event(), draw_hyperlink(), listview_remove_list(), menu_add_item(), menu_add_numeric_items(), menu_add_submenu(), menu_add_value_entry(), menubar_add_menu(), mk_draw_knob(), multi_listview_remove_list(), set_pattern(), tabbox_add_tab(), transparent_draw(), and widget_draw().

os_grab_pointer()

int os_grab_pointer

(

Widget_t *

w

)

os_grab_pointer - grab the mouse pointer. Works only on linux

Parameters

*w	- Pointer to the widget which will grab the mouse

Returns

int - Return 0 on error

Definition at line 742 of file xwidget-linux.c.

                                 {
    return XGrabPointer(w->app->dpy, DefaultRootWindow(w->app->dpy), True,
             ButtonPressMask|ButtonReleaseMask|PointerMotionMask,
             GrabModeAsync, GrabModeAsync, None, None, CurrentTime);
 
}

References Widget_t::app, and Xputty::dpy.

Referenced by _popup_spinbox(), pop_combobox_menu_show(), and pop_menu_show().

os_init_dnd()

void os_init_dnd

(

Xputty *

main

)

os_init_dnd - register a Widget_t for handling drag and drop events only implemented on linux

Parameters

*main

- pointer to the Xputty struct

Definition at line 1048 of file xwidget-linux.c.

                               {
    main->dnd_source_window = 0;
    main->dnd_version = 5;
    main->XdndAware = XInternAtom (main->dpy, "XdndAware", False);
    main->XdndTypeList = XInternAtom (main->dpy, "XdndTypeList", False);
    main->XdndSelection = XInternAtom (main->dpy, "XdndSelection", False);
    main->XdndStatus = XInternAtom (main->dpy, "XdndStatus", False);
    main->XdndEnter = XInternAtom (main->dpy, "XdndEnter", False);
    main->XdndPosition = XInternAtom (main->dpy, "XdndPosition", False);
    main->XdndLeave = XInternAtom (main->dpy, "XdndLeave", False);
    main->XdndDrop = XInternAtom (main->dpy, "XdndDrop", False);
    main->XdndActionCopy = XInternAtom (main->dpy, "XdndActionCopy", False);
    main->XdndFinished = XInternAtom (main->dpy, "XdndFinished", False);
    main->dnd_type_uri = XInternAtom (main->dpy, "text/uri-list", False);
    main->dnd_type_text = XInternAtom (main->dpy, "text/plain", False);
    main->dnd_type_utf8 = XInternAtom (main->dpy, "UTF8_STRING", False);
    main->dnd_type = None;
 
    main->selection = XInternAtom(main->dpy, "CLIPBOARD", 0);
    main->targets_atom = XInternAtom(main->dpy, "TARGETS", 0);
    main->text_atom = XInternAtom(main->dpy, "TEXT", 0);
    main->UTF8 = XInternAtom(main->dpy, "UTF8_STRING", 1);
    if (main->UTF8 == None) main->UTF8 = XA_STRING;    
}

References Xputty::dnd_source_window, Xputty::dnd_type, Xputty::dnd_type_text, Xputty::dnd_type_uri, Xputty::dnd_type_utf8, Xputty::dnd_version, Xputty::dpy, Xputty::selection, Xputty::targets_atom, Xputty::text_atom, Xputty::UTF8, Xputty::XdndActionCopy, Xputty::XdndAware, Xputty::XdndDrop, Xputty::XdndEnter, Xputty::XdndFinished, Xputty::XdndLeave, Xputty::XdndPosition, Xputty::XdndSelection, Xputty::XdndStatus, and Xputty::XdndTypeList.

Referenced by main_init().

os_is_directory()

bool os_is_directory

(

const char *

filename

)

os_is directory - check if a given path is a directory or a file

Parameters

*filename

- the Path to check

Returns

bool - return true if path is directory, otrherwise false

Definition at line 786 of file xwidget-linux.c.

                                           {
    struct stat sb;
    return (stat(filename, &sb) == 0 && S_ISDIR(sb.st_mode));
}

Referenced by _draw_list(), and _draw_multi_list().

os_main_run()

void os_main_run

(

Xputty *

main

)

os_main_run - start the event loop

Parameters

*main

- pointer to the Xputty struct

Definition at line 845 of file xwidget-linux.c.

                               {
    Widget_t * wid = main->childlist->childs[0]; 
    Atom WM_DELETE_WINDOW;
    WM_DELETE_WINDOW = XInternAtom(main->dpy, "WM_DELETE_WINDOW", True);
    XSetWMProtocols(main->dpy, wid->widget, &WM_DELETE_WINDOW, 1);
 
    XEvent xev;
    int ew;
    Widget_t * w = NULL;
 
    while (main->run && (XNextEvent(main->dpy, &xev)>=0)) {
        if (XFilterEvent(&xev, None)) continue;
        ew = childlist_find_widget(main->childlist, xev.xany.window);
        if(ew  >= 0) {
            w = main->childlist->childs[ew];
            w->event_callback(w, &xev, main, NULL);
        }
 
        switch (xev.type) {
            case ButtonPress:
            {
                bool is_item = False;
                if(main->submenu != NULL) {
                    if (childlist_has_child(main->submenu->childlist)) {
                        Widget_t *slider = main->submenu->childlist->childs[1];
                        if (xev.xbutton.window == slider->widget) {
                            break;
                        }
                        Widget_t *view_port = main->submenu->childlist->childs[0];
                        int i = view_port->childlist->elem-1;
                        for(;i>-1;i--) {
                            Widget_t *w = view_port->childlist->childs[i];
                            if (xev.xbutton.window == w->widget) {
                                is_item = True;
                                break;
                            }
                        }
                    }
                }
                if(main->hold_grab != NULL && main->hold_grab->flags & IS_POPUP) {
                    if (childlist_has_child(main->hold_grab->childlist)) {
                        Widget_t *slider = main->hold_grab->childlist->childs[1];
                        if (xev.xbutton.window == slider->widget) {
                            break;
                        }
                        Widget_t *view_port = main->hold_grab->childlist->childs[0];
                        int i = view_port->childlist->elem-1;
                        for(;i>-1;i--) {
                            Widget_t *w = view_port->childlist->childs[i];
                            if (xev.xbutton.window == w->widget) {
                                is_item = True;
                                break;
                            }
                        }
                        if (xev.xbutton.window == view_port->widget) is_item = True;
                    }
                    if (!is_item) {
                        XUngrabPointer(main->dpy,CurrentTime);
                        widget_hide(main->hold_grab);
                        main->hold_grab = NULL;
                    }
                } else if(main->hold_grab != NULL && ((main->hold_grab->flags & IS_POPUP) == 0)) {
                    main->hold_grab->func.button_press_callback(main->hold_grab, &xev.xbutton, NULL);
                }
            }
            break;
            case ButtonRelease:
            {
                if(main->hold_grab != NULL && ((main->hold_grab->flags & IS_POPUP) == 0)) {
                    main->hold_grab->func.button_release_callback(main->hold_grab, &xev.xbutton, NULL);
                }
            }
            break;
            case KeyPress:
            {
                if (main->key_snooper != NULL && xev.xkey.window != main->key_snooper->widget) {
                    main->key_snooper->func.key_press_callback(main->key_snooper, &xev.xkey, NULL);
                }
            }
            break;
            case KeyRelease:
            {
                if (main->key_snooper != NULL && xev.xkey.window != main->key_snooper->widget) {
                    main->key_snooper->func.key_release_callback(main->key_snooper, &xev.xkey, NULL);
                }
            }
            break;
            case ClientMessage:
            {
                if (xev.xclient.data.l[0] == (long int)WM_DELETE_WINDOW &&
                        xev.xclient.window == wid->widget) {
                    main->run = false;
                } else if (xev.xclient.data.l[0] == (long int)WM_DELETE_WINDOW) {
                    int i = childlist_find_widget(main->childlist, xev.xclient.window);
                    if(i<1) return;
                    Widget_t *w = main->childlist->childs[i];
                    if(w->flags & HIDE_ON_DELETE) widget_hide(w);
                    else destroy_widget(main->childlist->childs[i],main);
                }
                break;
            }
        }
    }
}

References Func_t::button_press_callback, Func_t::button_release_callback, Xputty::childlist, Widget_t::childlist, childlist_find_widget(), childlist_has_child(), Childlist_t::childs, destroy_widget(), Xputty::dpy, Childlist_t::elem, Widget_t::event_callback, Widget_t::flags, Widget_t::func, HIDE_ON_DELETE, Xputty::hold_grab, IS_POPUP, Func_t::key_press_callback, Func_t::key_release_callback, Xputty::key_snooper, Xputty::run, Xputty::submenu, Widget_t::widget, widget_hide(), and XEvent::window.

Referenced by main_run().

os_move_window()

void os_move_window	(	Display *	dpy,
		Widget_t *	w,
		int	x,
		int	y
	)

os_move_window - Move a Widget_t

Parameters

*dpy	- Pointer to the Display the widget belongs to
*w	- Pointer to the widget
x,y	- the point to move to

Definition at line 105 of file xwidget-linux.c.

                                                             {
    XMoveWindow(dpy,w->widget, x, y);
}

References Widget_t::widget.

Referenced by _configure_combobox_menu(), _configure_menu(), _popup_spinbox(), _resize_childs(), _set_listbox_viewpoint(), _set_viewpoint(), and menu_remove_item().

os_open_display()

Display * os_open_display

(

char *

display_name

)

os_open_display - Connect to the display to use

Parameters

*display_name

- Display name could be 0 for default

Returns

Display - return pointer to the Display struct

Definition at line 54 of file xwidget-linux.c.

                                             {
    return XOpenDisplay(display_name);
}

Referenced by main_init().

os_quit()

void os_quit

(

Widget_t *

w

)

os_quit - quit the main loop and free all used memory

Parameters

*w	- Pointer to the widget request the quit call

Definition at line 809 of file xwidget-linux.c.

                          {
    //Atom WM_DELETE_WINDOW = XInternAtom(w->app->dpy, "WM_DELETE_WINDOW", True);
    Atom WM_DELETE_WINDOW = os_register_wm_delete_window(w);
    XClientMessageEvent xevent;
    xevent.type = ClientMessage;
    xevent.message_type = WM_DELETE_WINDOW;
    xevent.display = w->app->dpy;
    xevent.window = get_toplevel_widget(w->app)->widget;
    xevent.format = 16;
    xevent.data.l[0] = WM_DELETE_WINDOW;
    XSendEvent(w->app->dpy, w->widget, 0, 0, (XEvent *)&xevent);
}

References Widget_t::app, debug_lasterror(), Xputty::dpy, get_toplevel_widget(), os_register_wm_delete_window(), szMainUIClassName, szWidgetUIClassName, and Widget_t::widget.

Referenced by quit(), and quit_widget().

os_quit_widget()

void os_quit_widget

(

Widget_t *

w

)

os_quit_widget - remove a Widget_t from the main loop and free it's used memory

Parameters

*w	- Pointer to the widget request the quit call

Definition at line 822 of file xwidget-linux.c.

                                 {
    Atom QUIT_WIDGET = os_register_widget_destroy(w);
    XClientMessageEvent xevent;
    xevent.type = ClientMessage;
    xevent.message_type = QUIT_WIDGET;
    xevent.display = w->app->dpy;
    xevent.window = w->widget;
    xevent.format = 16;
    xevent.data.l[0] = 1;
    XSendEvent(w->app->dpy, w->widget, 0, 0, (XEvent *)&xevent);
}

References Widget_t::app, Xputty::dpy, os_register_widget_destroy(), and Widget_t::widget.

os_register_widget_destroy()

Atom os_register_widget_destroy

(

Widget_t *

wid

)

os_register_widget_destroy - Get the needed Atom to send a widget destroy message

Parameters

*wid	- Pointer to the widget request the quit call

Returns

ATOM - ATOM on linux, DWORD on windows

Definition at line 841 of file xwidget-linux.c.

                                                {
    return XInternAtom(wid->app->dpy, "WIDGET_DESTROY", False);
}

References Widget_t::app, and Xputty::dpy.

Referenced by os_quit_widget().

os_register_wm_delete_window()

Atom os_register_wm_delete_window

(

Widget_t *

wid

)

os_register_wm_delete_window - Get the needed Atom to send a widget delete message

Parameters

*wid	- Pointer to the widget request the quit call

Returns

ATOM - ATOM on linux, DWORD on windows

Definition at line 834 of file xwidget-linux.c.

                                                  {
    Atom WM_DELETE_WINDOW;
    WM_DELETE_WINDOW = XInternAtom(wid->app->dpy, "WM_DELETE_WINDOW", True);
    XSetWMProtocols(wid->app->dpy, wid->widget, &WM_DELETE_WINDOW, 1);
    return WM_DELETE_WINDOW;
}

References Widget_t::app, Xputty::dpy, and Widget_t::widget.

Referenced by childlist_add_child(), and os_quit().

os_resize_window()

void os_resize_window	(	Display *	dpy,
		Widget_t *	w,
		int	x,
		int	y
	)

os_resize_window - Resize a Widget_t

Parameters

*dpy	- Pointer to the Display the widget belongs to
*w	- Pointer to the Widget_t
x,y	- the new size

Definition at line 109 of file xwidget-linux.c.

                                                               {
    XResizeWindow(dpy, w->widget, x, y);
}

References Widget_t::widget.

Referenced by _configure_combobox_menu(), _configure_listbox(), _configure_listview(), _configure_menu(), _get_width(), and _resize_childs().

os_run_embedded()

void os_run_embedded

(

Xputty *

main

)

os_run_embedded - the event handling when run embedded on windows all messges goes into WndProc, so stub here

Parameters

*main

- pointer to the Xputty struct

Definition at line 950 of file xwidget-linux.c.

                                   {
 
    XEvent xev;
    int ew = -1;
 
    while (XPending(main->dpy) > 0) {
        XNextEvent(main->dpy, &xev);
        if (xev.type == ClientMessage || xev.type == SelectionNotify) {
            Widget_t * w = main->childlist->childs[0];
            w->event_callback(w, &xev, main, NULL);
        }
        ew = childlist_find_widget(main->childlist, xev.xany.window);
        if(ew  >= 0) {
            Widget_t * w = main->childlist->childs[ew];
            w->event_callback(w, &xev, main, NULL);
        }
        switch (xev.type) {
        case ButtonPress:
        {
            bool is_item = False;
            if(main->submenu != NULL) {
                if (childlist_has_child(main->submenu->childlist)) {
                    Widget_t *slider = main->submenu->childlist->childs[1];
                    if (xev.xbutton.window == slider->widget) {
                        break;
                    }
                    Widget_t *view_port = main->submenu->childlist->childs[0];
                    int i = view_port->childlist->elem-1;
                    for(;i>-1;i--) {
                        Widget_t *w = view_port->childlist->childs[i];
                        if (xev.xbutton.window == w->widget) {
                            is_item = True;
                            break;
                        }
                    }
                }
            }
            if(main->hold_grab != NULL && main->hold_grab->flags & IS_POPUP) {
                if (childlist_has_child(main->hold_grab->childlist)) {
                    Widget_t *slider = main->hold_grab->childlist->childs[1];
                    if (xev.xbutton.window == slider->widget) {
                        break;
                    }
                    Widget_t *view_port = main->hold_grab->childlist->childs[0];
                    int i = view_port->childlist->elem-1;
                    for(;i>-1;i--) {
                        Widget_t *w = view_port->childlist->childs[i];
                        if (xev.xbutton.window == w->widget) {
                            is_item = True;
                            break;
                        }
                    }
                    if (xev.xbutton.window == view_port->widget) is_item = True;
                }
                if (!is_item) {
                    XUngrabPointer(main->dpy,CurrentTime);
                    widget_hide(main->hold_grab);
                    main->hold_grab = NULL;
                }
            } else if(main->hold_grab != NULL && ((main->hold_grab->flags & IS_POPUP) == 0)) {
                main->hold_grab->func.button_press_callback(main->hold_grab, &xev.xbutton, NULL);
            }
        }
        break;
        case ButtonRelease:
        {
            if(main->hold_grab != NULL && ((main->hold_grab->flags & IS_POPUP) == 0)) {
                main->hold_grab->func.button_release_callback(main->hold_grab, &xev.xbutton, NULL);
            }
        }
        break;
        case KeyPress:
        {
            if (main->key_snooper != NULL && xev.xkey.window != main->key_snooper->widget) {
                main->key_snooper->func.key_press_callback(main->key_snooper, &xev.xkey, NULL);
            }
        }
        break;
        case KeyRelease:
        {
            if (main->key_snooper != NULL && xev.xkey.window != main->key_snooper->widget) {
                main->key_snooper->func.key_release_callback(main->key_snooper, &xev.xkey, NULL);
            }
        }
        break;
        case ClientMessage:
            if (xev.xclient.data.l[0] == (long int)XInternAtom(main->dpy, "WM_DELETE_WINDOW", True) ) {
                int i = childlist_find_widget(main->childlist, xev.xclient.window);
                if(i<1) return;
                Widget_t *w = main->childlist->childs[i];
                if(w->flags & HIDE_ON_DELETE) widget_hide(w);
                else destroy_widget(w, main);
            }
        break;
        }
    }
}

References Func_t::button_press_callback, Func_t::button_release_callback, Xputty::childlist, Widget_t::childlist, childlist_find_widget(), childlist_has_child(), Childlist_t::childs, destroy_widget(), Xputty::dpy, Childlist_t::elem, Widget_t::event_callback, Widget_t::flags, Widget_t::func, HIDE_ON_DELETE, Xputty::hold_grab, IS_POPUP, Func_t::key_press_callback, Func_t::key_release_callback, Xputty::key_snooper, Xputty::submenu, Widget_t::widget, widget_hide(), and XEvent::window.

Referenced by run_embedded().

os_send_button_press_event()

void os_send_button_press_event

(

Widget_t *

w

)

os_send_button_press_event - Send a button press event to a Widget_t see XButtonEvent

Parameters

*w	- Pointer to the widget

Definition at line 641 of file xwidget-linux.c.

                                             {
    XEvent event;
    memset(&event, 0, sizeof(XEvent));
    XWindowAttributes attr;
    XGetWindowAttributes(w->app->dpy, w->widget, &attr);
    event.type = ButtonPress;
    event.xbutton.same_screen = true;
    event.xbutton.root = None;
    event.xbutton.window = w->widget;
    event.xbutton.subwindow = None;
    event.xbutton.x = 1;
    event.xbutton.y = 1;
    event.xbutton.x_root = attr.x;
    event.xbutton.y_root = attr.y;
    event.xbutton.state = 0;
    event.xbutton.button = Button1;
    XSendEvent(w->app->dpy, PointerWindow, True, ButtonPressMask, &event);
}

References Widget_t::app, Xputty::dpy, and Widget_t::widget.

Referenced by send_button_press_event().

os_send_button_release_event()

void os_send_button_release_event

(

Widget_t *

w

)

os_send_button_release_event - Send a button release event to a Widget_t see XButtonEvent

Parameters

*w	- Pointer to the widget

Definition at line 660 of file xwidget-linux.c.

                                               {
    XEvent event;
    memset(&event, 0, sizeof(XEvent));
    XWindowAttributes attr;
    XGetWindowAttributes(w->app->dpy, w->widget, &attr);
    event.type = ButtonRelease;
    event.xbutton.same_screen = true;
    event.xbutton.root = None;
    event.xbutton.window = w->widget;
    event.xbutton.subwindow = None;
    event.xbutton.x = 1;
    event.xbutton.y = 1;
    event.xbutton.x_root = attr.x;
    event.xbutton.y_root = attr.y;
    event.xbutton.state = 0;
    event.xbutton.button = Button1;
    XSendEvent(w->app->dpy, PointerWindow, True, ButtonReleaseMask, &event);
}

References Widget_t::app, Xputty::dpy, and Widget_t::widget.

Referenced by send_button_release_event().

os_send_configure_event()

void os_send_configure_event	(	Widget_t *	w,
		int	x,
		int	y,
		int	width,
		int	height
	)

os_send_configure_event - Send a configure event to a Widget_t

Parameters

*w	- Pointer to the widget
x,y	- the position to set
width,height	- the size to set

Definition at line 623 of file xwidget-linux.c.

                                                                              {
    XConfigureEvent notify;
    memset(&notify, 0, sizeof(notify));
    notify.type = ConfigureNotify;
    notify.display = w->app->dpy;
    notify.send_event = True;
    notify.event = w->widget;
    notify.window = w->widget;
    notify.x = x;
    notify.y = y;
    notify.width = width;
    notify.height = height;
    notify.border_width = 0;
    notify.above = None;
    notify.override_redirect = 1;
    XSendEvent( w->app->dpy, w->widget, true, StructureNotifyMask, (XEvent*)&notify );    
}

References Widget_t::app, Xputty::dpy, and Widget_t::widget.

Referenced by send_configure_event().

os_send_systray_message()

void os_send_systray_message

(

Widget_t *

w

)

os_send_send_systray_message - Send a systray event to a Widget_t only working on Linux for now

Parameters

*w	- Pointer to the widget

Definition at line 679 of file xwidget-linux.c.

                                          {
    XEvent event;
    Screen *xscreen;
    char buf[256];
    buf[0]=0;
    
    xscreen=DefaultScreenOfDisplay(w->app->dpy);
    sprintf(buf,"_NET_SYSTEM_TRAY_S%d",XScreenNumberOfScreen (xscreen));
    Atom selection_atom = XInternAtom (w->app->dpy,buf,0);
 
    Window tray = XGetSelectionOwner (w->app->dpy,selection_atom);
    Atom visualatom = XInternAtom(w->app->dpy, "_NET_SYSTEM_TRAY_VISUAL", False);
    VisualID value = XVisualIDFromVisual(DefaultVisual(w->app->dpy, DefaultScreen(w->app->dpy)));
    XChangeProperty(w->app->dpy, w->widget, visualatom, XA_VISUALID, 32,
            PropModeReplace, (unsigned char*)&value, 1);
 
    if ( tray != None) {
        XSelectInput (w->app->dpy,tray,StructureNotifyMask);
        /* get tray color and set as background */
        XColor c;
        XWindowAttributes attrs;
        XGetWindowAttributes(w->app->dpy, DefaultRootWindow(w->app->dpy), &attrs);
        
        XImage *image = NULL;
        default_error_handler = XSetErrorHandler(intern_error_handler);
        image = XGetImage(w->app->dpy, DefaultRootWindow(w->app->dpy),
                        attrs.width -2, attrs.height -2, 1, 1, AllPlanes, XYPixmap);
        XSetErrorHandler(default_error_handler);
        if (image) {
            c.pixel = XGetPixel(image, 0, 0);
            XQueryColor (w->app->dpy, DefaultColormap(w->app->dpy, DefaultScreen (w->app->dpy)), &c);
            double r = (double)c.red/65535.0;
            double g = (double)c.green/65535.0;
            double b = (double)c.blue/65535.0;
            set_systray_color(w->app, r, g, b, 1.0);
            XDestroyImage(image);
        }
    }
 
    memset(&event, 0, sizeof(event));
    event.xclient.type = ClientMessage;
    event.xclient.window = tray;
    event.xclient.message_type = XInternAtom (w->app->dpy, "_NET_SYSTEM_TRAY_OPCODE", False );
    event.xclient.format = 32;
    event.xclient.data.l[0] = CurrentTime;
    event.xclient.data.l[1] = SYSTEM_TRAY_REQUEST_DOCK;
    event.xclient.data.l[2] = w->widget;
    event.xclient.data.l[3] = 0;
    event.xclient.data.l[4] = 0;
 
    XSendEvent(w->app->dpy, tray, False, NoEventMask, &event);
}

References Widget_t::app, default_error_handler, Xputty::dpy, intern_error_handler(), set_systray_color(), and Widget_t::widget.

Referenced by send_systray_message().

os_set_input_mask()

void os_set_input_mask

(

Widget_t *

w

)

os_set_input_mask - set the Event mask to a Widget_t only work on linux, stub on Windows

Parameters

*w	- Pointer to the widget which will grab the mouse

Definition at line 749 of file xwidget-linux.c.

                                    {
    XSelectInput(w->app->dpy, w->widget,StructureNotifyMask|ExposureMask|KeyPressMask 
                |EnterWindowMask|LeaveWindowMask|ButtonReleaseMask
                |ButtonPressMask|Button1MotionMask|PointerMotionMask);    
}

References Widget_t::app, Xputty::dpy, and Widget_t::widget.

Referenced by add_midi_keyboard(), create_combobox_viewport(), create_listview_viewport(), create_multi_listview_viewport(), mk_open_midi_keyboard(), and open_midi_keyboard().

os_set_title()

void os_set_title	(	Widget_t *	w,
		const char *	title
	)

os_set_title - Set the title of a Widget_t

Parameters

*w	- Pointer to the widget
title	- the title to set

Examples

simple-example.c.

Definition at line 194 of file xwidget-linux.c.

                                                  {
    XStoreName(w->app->dpy, w->widget, title);
    XChangeProperty(w->app->dpy,  w->widget,
    XInternAtom(w->app->dpy, "_NET_WM_NAME", False),
        XInternAtom(w->app->dpy, "UTF8_STRING", False),
        8, PropModeReplace, (unsigned char *) title,
        strlen(title));
}

References Widget_t::app, Xputty::dpy, and Widget_t::widget.

Referenced by widget_set_title().

os_set_transient_for_hint()

void os_set_transient_for_hint	(	Widget_t *	parent,
		Widget_t *	w
	)

os_set_ transient_for_hint - set a Widget_t transient to a other Widget_t only work on linux, stub on Windows

Parameters

*parent	- Pointer to the parent widget
*w	- Pointer to the widget

Definition at line 771 of file xwidget-linux.c.

                                                              {
 
    XSetTransientForHint(parent->app->dpy,w->widget,parent->widget);
}

References Widget_t::app, Xputty::dpy, and Widget_t::widget.

Referenced by add_popup_spinbox(), create_combobox_menu(), create_menu(), and create_tooltip().

os_set_widget_surface_size()

void os_set_widget_surface_size	(	Widget_t *	w,
		int	width,
		int	height
	)

os_set_widget_surface_size - set the size of a Widget_t cairo surface

Parameters

*w	- Pointer to the Widget_t the surface belongs to
*width,*height	- the size to set

Definition at line 118 of file xwidget-linux.c.

                                                                    {
    cairo_xlib_surface_set_size(w->surface, width, height);
}

References Widget_t::cr, and Widget_t::surface.

Referenced by _resize_surface().

os_set_window_attrb()

void os_set_window_attrb

(

Widget_t *

w

)

os_set_window_attrb - set the attribute mask to a Widget_t only work on linux, stub on Windows

Parameters

*w	- Pointer to the widget which will grab the mouse

Definition at line 755 of file xwidget-linux.c.

                                      {
    XSetWindowAttributes attributes;
    attributes.override_redirect = True;
    XChangeWindowAttributes(w->app->dpy, w->widget, CWOverrideRedirect, &attributes);
 
    Atom window_type = XInternAtom(w->app->dpy, "_NET_WM_WINDOW_TYPE", False);
    Atom window_type_popup = XInternAtom(w->app->dpy, "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU", False);
    XChangeProperty(w->app->dpy, w->widget, window_type,
        XA_ATOM, 32, PropModeReplace, (unsigned char *) &window_type_popup,1 );
 
    Atom window_state = XInternAtom(w->app->dpy, "_NET_WM_STATE", False);
    Atom window_state_modal = XInternAtom(w->app->dpy, "_NET_WM_STATE_MODAL", False);
    XChangeProperty(w->app->dpy, w->widget, window_state,
        XA_ATOM, 32, PropModeReplace, (unsigned char *) &window_state_modal, 1);
}

References Widget_t::app, Xputty::dpy, and Widget_t::widget.

Referenced by add_popup_spinbox(), create_combobox_menu(), create_menu(), and create_tooltip().

os_set_window_min_size()

void os_set_window_min_size	(	Widget_t *	w,
		int	min_width,
		int	min_height,
		int	base_width,
		int	base_height
	)

os_set_window_min_size - Set the min and base size of a Widget_t

Parameters

*w	- Pointer to the widget
min_width,min_height	- the min size to set
base_width,base_height	- the base size to set

Definition at line 91 of file xwidget-linux.c.

                                                             {
    XSizeHints* win_size_hints;
    win_size_hints = XAllocSizeHints();
    win_size_hints->flags =  PMinSize|PBaseSize|PWinGravity;
    win_size_hints->min_width = min_width;
    win_size_hints->min_height = min_height;
    win_size_hints->base_width = base_width;
    win_size_hints->base_height = base_height;
    win_size_hints->win_gravity = CenterGravity;
    XSetWMNormalHints(w->app->dpy, w->widget, win_size_hints);
    XFree(win_size_hints);
}

References Widget_t::app, Xputty::dpy, Metrics_t::height, Widget_t::metrics_min, Widget_t::widget, and Metrics_t::width.

Referenced by os_create_main_window_and_surface().

os_show_tooltip()

void os_show_tooltip	(	Widget_t *	wid,
		Widget_t *	w
	)

os_show_tooltip - Show a tooltip of a Widget_t

Parameters

*wid	- Pointer to the widget the tooltip belongs to
*w	- the tooltip Widget_t

Definition at line 211 of file xwidget-linux.c.

                                                 {
    unsigned int mask;
    int x, y, rx, ry;
    Window child, root;
    XQueryPointer(wid->app->dpy, wid->widget, &root, &child, &rx, &ry, &x, &y, &mask);
    int x1, y1;
    os_translate_coords(wid, wid->widget, os_get_root_window(wid->app, IS_WIDGET), x, y, &x1, &y1);
    XMoveWindow(w->app->dpy,w->widget,x1+10, y1-10);
    XMapWindow(w->app->dpy, w->widget);
}

References Widget_t::app, Xputty::dpy, IS_WIDGET, os_get_root_window(), os_translate_coords(), and Widget_t::widget.

Referenced by show_tooltip().

os_translate_coords()

void os_translate_coords	(	Widget_t *	w,
		Window	from_window,
		Window	to_window,
		int	from_x,
		int	from_y,
		int *	to_x,
		int *	to_y
	)

os_translate_coords - get x,y related to destination Window

Parameters

*w	- Widget_t pointer
from_window	- source Window
to_window	- destination Window
from_x,from_y	- point from the source Window
*to_x,*to_y	- (Pointer) point in the destination Window

Definition at line 73 of file xwidget-linux.c.

                                                                        {
    Window child;
    XTranslateCoordinates(w->app->dpy, from_window, to_window,
                          from_x, from_y, to_x, to_y, &child);
}

References Widget_t::app, and Xputty::dpy.

Referenced by _configure_combobox_menu(), _configure_menu(), _popup_spinbox(), add_popup_spinbox(), create_combobox_menu(), create_menu(), create_tooltip(), and os_show_tooltip().

os_transparent_draw()

void os_transparent_draw	(	void *	w_,
		void *	user_data
	)

os_transparent_draw - Draw the Widget_t to the back buffer

Parameters

*w_	- Pointer to the widget
*user_data	- additional user data or NULL

Definition at line 732 of file xwidget-linux.c.

                                                    {
   Widget_t *w = (Widget_t *)w_;
   transparent_draw(w, user_data);   
}

References transparent_draw(), and Widget_t::widget.

Referenced by _check_menu_state(), _enter_submenu(), _leave_submenu(), _set_entry(), add_button(), add_check_box(), add_check_button(), add_combobox(), add_hslider(), add_image_button(), add_image_knob(), add_image_toggle_button(), add_knob(), add_menu(), add_on_off_button(), add_switch_image_button(), add_toggle_button(), add_valuedisplay(), add_vslider(), create_widget(), listbox_add_entry(), menu_add_item(), menu_add_numeric_items(), and menu_add_value_entry().

os_widget_event_loop()

void os_widget_event_loop	(	void *	w_,
		void *	event,
		Xputty *	main,
		void *	user_data
	)

os_widget_event_loop - the Widget_t event loop on windows all messges goes into WndProc, so stub here

Parameters

*w_	- Pointer to the widget
*event	- the event to handle
*main	- pointer to the Xputty struct
*user_data	- additional user data could be NULL

Definition at line 230 of file xwidget-linux.c.

                                                                                {
    Widget_t *wid = (Widget_t*)w_;
    XEvent *xev = (XEvent*)event;
    
    switch(xev->type) {
        case ConfigureNotify:
            wid->func.configure_callback(w_, user_data);
            //transparent_draw(w_, user_data);
            debug_print("Widget_t ConfigureNotify \n");
        break;
 
        case VisibilityNotify:
            wid->func.visibiliy_change_callback(w_, user_data);
            debug_print("Widget_t VisibilityNotify \n");
        break;
 
        case Expose:
            if (xev->xexpose.count == 0) {
                if ((wid->flags & FAST_REDRAW) == 0) {
                    XEvent ev;
                    while (XCheckTypedWindowEvent(main->dpy, wid->widget, Expose, &ev)) {}
                }
                transparent_draw(w_, user_data);
                debug_print("Widget_t Expose \n");
            }
        break;
 
        case ButtonPress:
            if (wid->state == 4) break;
            if (wid->flags & HAS_TOOLTIP) hide_tooltip(wid);
            _button_press(wid, &xev->xbutton, user_data);
            debug_print("Widget_t  ButtonPress %i\n", xev->xbutton.button);
        break;
 
        case ButtonRelease:
        {
            XButtonEvent *xbutton = &xev->xbutton;
            _check_grab(wid, xbutton, main);
            _check_submenu(wid, xbutton, main);
            if (wid->state == 4) break;
            if (xbutton->button == Button1) {
                if ((wid->flags & IS_POPUP) == 0) {
                    if (xbutton->time < wid->double_click+300) {
                        wid->func.double_click_callback(wid, xbutton, user_data);
                        break;
                    }
                    wid->double_click = xbutton->time;
                }
            }
            _has_pointer(wid, &xev->xbutton);
            if(wid->flags & HAS_POINTER) wid->state = 1;
            else wid->state = 0;
            _check_enum(wid, xbutton);
            wid->func.button_release_callback(w_, xbutton, user_data);
            debug_print("Widget_t  ButtonRelease %i\n", xev->xbutton.button);
        }
        break;
 
        case KeyPress:
            if (wid->state == 4) break;
            _check_keymap(wid, xev->xkey);
            wid->func.key_press_callback(w_, &xev->xkey, user_data);
            debug_print("Widget_t KeyPress %u\n", xev->xkey.keycode);
        break;
 
        case KeyRelease:
        {
            if (wid->state == 4) break;
            unsigned short is_retriggered = 0;
            if(wid->flags & NO_AUTOREPEAT) {
                char keys[32];
                XQueryKeymap(main->dpy, keys);
 
                if((keys[xev->xkey.keycode>>3] & (0x1 << (xev->xkey.keycode % 8))) && 
                        (xev->xkey.keycode > 119 || xev->xkey.keycode < 110)) {
                    is_retriggered = 1;
                }
            }
            if (!is_retriggered) {
                wid->func.key_release_callback(w_, &xev->xkey, user_data);
                debug_print("Widget_t KeyRelease %u\n", xev->xkey.keycode);
            }
        }
        break;
 
        case LeaveNotify:
            wid->flags &= ~HAS_FOCUS;
            if (wid->state == 4) break;
            if(!(xev->xcrossing.state & Button1Mask) &&
               !(xev->xcrossing.state & Button2Mask) &&
               !(xev->xcrossing.state & Button3Mask)) {
                wid->state = 0;
                wid->func.leave_callback(w_, user_data);
            }
            if (wid->flags & HAS_TOOLTIP) hide_tooltip(wid);
            debug_print("Widget_t LeaveNotify \n");
        break;
 
        case EnterNotify:
            wid->flags |= HAS_FOCUS;
            if (wid->state == 4) break;
            if(!(xev->xcrossing.state & Button1Mask) &&
               !(xev->xcrossing.state & Button2Mask) &&
               !(xev->xcrossing.state & Button3Mask)) {
                wid->state = 1;
                wid->func.enter_callback(w_, user_data);
                if (wid->flags & HAS_TOOLTIP) show_tooltip(wid);
                else _hide_all_tooltips(wid);
            }
            debug_print("Widget_t EnterNotify \n");
        break;
 
        case MotionNotify:
            if (wid->state == 4) break;
            if (xev->xmotion.state) {
                adj_set_motion_state(wid, xev->xmotion.x, xev->xmotion.y);
            }
            wid->func.motion_callback(w_,&xev->xmotion, user_data);
            debug_print("Widget_t MotionNotify x = %i Y = %i \n",xev->xmotion.x,xev->xmotion.y );
        break;
 
        case SelectionRequest:
            if (xev->xselectionrequest.selection != main->selection) break;
            send_to_clipboard(wid, xev);
            break;
        case SelectionClear:
            break;
        case SelectionNotify:
            if (xev->xselection.property == None) {
                wid->xpaste_callback(wid, NULL);
                break;
            }
            if (xev->xselection.selection == main->selection) {
                receive_paste_from_clipboard(wid, xev);
                break;
            }
            debug_print("Widget_t SelectionNotify\n");
            handle_drag_data(wid, xev);
            break;
 
        case ClientMessage:
            if (xev->xclient.message_type == main->XdndPosition) {
                debug_print( "XdndPosition\n");
                send_dnd_status_event(wid, xev);
            } else if (xev->xclient.message_type == main->XdndEnter) {
                debug_print( "XdndEnter\n");
                handle_dnd_enter(main, xev);
            } else if (xev->xclient.message_type == main->XdndLeave) {
                debug_print( "XdndLeave\n");
                main->dnd_type   = None;
                main->dnd_source_window = 0;
                main->dnd_version = 0;
            } else if (xev->xclient.message_type == main->XdndDrop) {
                if ((DND_SOURCE_WIN(xev) != main->dnd_source_window) ||
                    main->dnd_type == None || main->dnd_source_window == 0) {
                    break;
                }
                XConvertSelection(main->dpy, main->XdndSelection,
                                   main->dnd_type, main->XdndSelection, wid->widget, CurrentTime);
 
                send_dnd_finished_event(wid, xev);
            } else if (xev->xclient.message_type == XInternAtom(wid->app->dpy, "WIDGET_DESTROY", 1)) {
                int ch = childlist_has_child(wid->childlist);
                if (ch) {
                    int i = ch;
                    for(;i>0;i--) {
                        quit_widget(wid->childlist->childs[i-1]);
                    }
                    quit_widget(wid);
                } else {
                    destroy_widget(wid,main);
                }
            }
            break;
        default:
        break;
    }
}

References _button_press(), _check_enum(), _check_grab(), _check_keymap(), _check_submenu(), _has_pointer(), _hide_all_tooltips(), adj_set_motion_state(), Widget_t::app, XEvent::button, Func_t::button_release_callback, Widget_t::childlist, childlist_has_child(), Childlist_t::childs, Func_t::configure_callback, destroy_widget(), Xputty::dnd_source_window, Xputty::dnd_type, Xputty::dnd_version, Widget_t::double_click, Func_t::double_click_callback, Xputty::dpy, Func_t::enter_callback, FAST_REDRAW, Widget_t::flags, Widget_t::func, handle_dnd_enter(), handle_drag_data(), HAS_FOCUS, HAS_POINTER, HAS_TOOLTIP, hide_tooltip(), IS_POPUP, Func_t::key_press_callback, Func_t::key_release_callback, XEvent::keycode, Func_t::leave_callback, Func_t::motion_callback, NO_AUTOREPEAT, quit_widget(), receive_paste_from_clipboard(), Xputty::selection, send_dnd_finished_event(), send_dnd_status_event(), send_to_clipboard(), show_tooltip(), XEvent::state, Widget_t::state, transparent_draw(), Func_t::visibiliy_change_callback, Widget_t::widget, XEvent::x, Xputty::XdndDrop, Xputty::XdndEnter, Xputty::XdndLeave, Xputty::XdndPosition, Xputty::XdndSelection, Widget_t::xpaste_callback, and XEvent::y.

Referenced by create_widget(), and widget_event_loop().

os_widget_hide()

void os_widget_hide

(

Widget_t *

w

)

os_widget_hide - Hide a Widget_t

Parameters

*w	- Pointer to the widget to hide

Definition at line 207 of file xwidget-linux.c.

                                 {
    XUnmapWindow(w->app->dpy, w->widget);
}

References Widget_t::app, Xputty::dpy, and Widget_t::widget.

Referenced by widget_hide(), and widget_hide_all().

os_widget_show()

void os_widget_show

(

Widget_t *

w

)

os_widget_show - Show a Widget_t

Parameters

*w	- Pointer to the widget to show

Definition at line 203 of file xwidget-linux.c.

                                 {
    XMapWindow(w->app->dpy, w->widget);
}

References Widget_t::app, Xputty::dpy, and Widget_t::widget.

Referenced by pop_widget_show_all(), submenu_widget_show_all(), widget_show(), and widget_show_all().

utf8_from_locale()

char * utf8_from_locale

(

char *

localestr

)

utf8_from_locale - convert active codepage to utf8 must be freed by the caller

Parameters

*localestr

- Pointer to char to convert

Returns

*char - the converted char in utf8 format

Definition at line 41 of file xwidget-linux.c.

                                        {
    char *s_to = NULL;
    asprintf(&s_to, "%s",localestr);
    return s_to;
}

References asprintf(), and convert_cp().

Referenced by _draw_multi_list(), HandleFiles(), and os_get_keyboard_input().