static gboolean
qtcWindowMap(GtkWidget *widget, GdkEventKey *event, void *user_data)
{
QTC_UNUSED(event);
QTC_UNUSED(user_data);
QTC_DEF_WIDGET_PROPS(props, widget);
qtcWindowSetProperties(widget, qtcWidgetProps(props)->windowOpacity);
if (opts.menubarHiding & HIDE_KWIN) {
GtkWidget *menuBar = qtcWindowGetMenuBar(widget, 0);
if (menuBar) {
int size = (gtk_widget_get_visible(menuBar) ?
qtcWidgetGetAllocation(menuBar).height : 0);
qtcMenuEmitSize(menuBar, size);
qtcWindowMenuBarDBus(widget, size);
}
}
if(opts.statusbarHiding&HIDE_KWIN)
{
GtkWidget *statusBar=qtcWindowGetStatusBar(widget, 0);
if(statusBar)
qtcWindowStatusBarDBus(widget, !gtk_widget_get_visible(statusBar));
}
return false;
}
static gboolean
qtcTreeViewLeave(GtkWidget *widget, GdkEventMotion *event, void *data)
{
QTC_UNUSED(event);
QTC_UNUSED(data);
if (GTK_IS_TREE_VIEW(widget)) {
QtCTreeView *tv = qtcTreeViewLookupHash(widget, false);
if (tv) {
GtkTreeView *treeView = GTK_TREE_VIEW(widget);
QtcRect rect = {0, 0, -1, -1 };
QtcRect alloc = qtcWidgetGetAllocation(widget);
if (tv->path && tv->column) {
gtk_tree_view_get_background_area(
treeView, tv->path, tv->column, (GdkRectangle*)&rect);
}
if (tv->fullWidth) {
rect.x = 0;
rect.width = alloc.width;
}
if (tv->path) {
gtk_tree_path_free(tv->path);
}
tv->path = NULL;
tv->column = NULL;
gtk_tree_view_convert_bin_window_to_widget_coords(
treeView, rect.x, rect.y, &rect.x, &rect.y);
gtk_widget_queue_draw_area(
widget, rect.x, rect.y, rect.width, rect.height);
}
}
return false;
}
static gboolean
qtcMenuShellLeave(GtkWidget *widget, GdkEventCrossing *event, void *data)
{
QTC_UNUSED(data);
QTC_UNUSED(event);
if (GTK_IS_MENU_SHELL(widget) && GTK_IS_CONTAINER(widget)) {
GList *children = gtk_container_get_children(GTK_CONTAINER(widget));
for (GList *child = children;child;child = g_list_next(child)) {
if ((child->data) && GTK_IS_MENU_ITEM(child->data) &&
(gtk_widget_get_state(GTK_WIDGET(child->data)) !=
GTK_STATE_INSENSITIVE)) {
GtkWidget *submenu =
gtk_menu_item_get_submenu(GTK_MENU_ITEM(child->data));
GtkWidget *topLevel =
submenu ? gtk_widget_get_toplevel(submenu) : NULL;
if (submenu &&
((!GTK_IS_MENU(submenu)) ||
(!(gtk_widget_get_realized(submenu) &&
gtk_widget_get_visible(submenu) &&
gtk_widget_get_realized(topLevel) &&
gtk_widget_get_visible(topLevel))))) {
gtk_widget_set_state(GTK_WIDGET(child->data),
GTK_STATE_NORMAL);
}
}
}
if (children) {
g_list_free(children);
}
}
return false;
}
static gboolean
qtcComboBoxStyleSet(GtkWidget *widget, GtkStyle *prev_style, gpointer data)
{
QTC_UNUSED(data);
QTC_UNUSED(prev_style);
qtcComboBoxCleanup(widget);
return FALSE;
}
static gboolean
qtcEntryStyleSet(GtkWidget *widget, GtkStyle *previous_style, gpointer data)
{
QTC_UNUSED(previous_style);
QTC_UNUSED(data);
qtcEntryCleanup(widget);
return FALSE;
}
static gboolean
qtcMenuShellStyleSet(GtkWidget *widget, GtkStyle *prev_style, void *data)
{
QTC_UNUSED(data);
QTC_UNUSED(prev_style);
qtcMenuShellCleanup(widget);
return false;
}
static gboolean
qtcMenuShellDestroy(GtkWidget *widget, GdkEvent *event, void *data)
{
QTC_UNUSED(data);
QTC_UNUSED(event);
qtcMenuShellCleanup(widget);
return false;
}
static gboolean
qtcWidgetMapDestroy(GtkWidget *widget, GdkEvent *event, void *user_data)
{
QTC_UNUSED(event);
QTC_UNUSED(user_data);
qtcWidgetMapCleanup(widget);
return false;
}
static gboolean
qtcComboBoxDestroy(GtkWidget *widget, GdkEvent *event, gpointer data)
{
QTC_UNUSED(data);
QTC_UNUSED(event);
qtcComboBoxCleanup(widget);
return FALSE;
}
static void
qtcComboBoxStateChange(GtkWidget *widget, GdkEventMotion *event, gpointer data)
{
QTC_UNUSED(data);
QTC_UNUSED(event);
if (GTK_IS_CONTAINER(widget)) {
qtcComboBoxClearBgndColor(widget);
}
}
static gboolean
qtcEntryLeave(GtkWidget *widget, GdkEventCrossing *event, gpointer data)
{
QTC_UNUSED(event);
QTC_UNUSED(data);
if (GTK_IS_ENTRY(widget)) {
qtcEntryLastMo = NULL;
gtk_widget_queue_draw(widget);
}
return FALSE;
}
/* adds a progress bar */
void
qtcAnimationAddProgressBar(GtkWidget *progressbar, gboolean isEntry)
{
#if GTK_CHECK_VERSION(2, 12, 0)
gdouble fraction = isEntry ?
gtk_entry_get_progress_fraction(GTK_ENTRY(progressbar)) :
gtk_progress_bar_get_fraction(GTK_PROGRESS_BAR(progressbar));
if (fraction < 1.0 && fraction > 0.0) {
qtcAnimationAdd((GtkWidget*) progressbar, 0.0);
}
#else
QTC_UNUSED(progressbar);
QTC_UNUSED(isEntry);
#endif
}
static void
qtcAnimationOnConnectedWidgetDestruction(gpointer data, GObject *widget)
{
QTC_UNUSED(widget);
connected_widgets = g_slist_remove(connected_widgets, data);
g_free(data);
}
static gboolean
qtcWindowClientEvent(GtkWidget *widget, GdkEventClient *event, void *data)
{
QTC_UNUSED(data);
if (gdk_x11_atom_to_xatom(event->message_type) ==
qtc_x11_qtc_active_window) {
if (event->data.l[0]) {
qtcCurrentActiveWindow = widget;
} else if (qtcCurrentActiveWindow == widget) {
qtcCurrentActiveWindow = 0L;
}
gtk_widget_queue_draw(widget);
} else if (gdk_x11_atom_to_xatom(event->message_type) ==
qtc_x11_qtc_titlebar_size) {
qtcGetWindowBorderSize(true);
GtkWidget *menubar = qtcWindowGetMenuBar(widget, 0);
if (menubar) {
gtk_widget_queue_draw(menubar);
}
} else if (gdk_x11_atom_to_xatom(event->message_type) ==
qtc_x11_qtc_toggle_menubar) {
if (opts.menubarHiding & HIDE_KWIN && qtcWindowToggleMenuBar(widget)) {
gtk_widget_queue_draw(widget);
}
} else if (gdk_x11_atom_to_xatom(event->message_type) ==
qtc_x11_qtc_toggle_statusbar) {
if (opts.statusbarHiding & HIDE_KWIN &&
qtcWindowToggleStatusBar(widget)) {
gtk_widget_queue_draw(widget);
}
}
return false;
}
static void
subProcess(int argc, char **argv)
{
QTC_UNUSED(argc);
char buff3[1024] = {0};
read(0, buff3, sizeof(buff3));
assert(memcmp(argv[1], buff3, sizeof(buff3)) == 0);
write(1, argv[2], strlen(argv[2]) + 1);
}
static gboolean
qtcTreeViewMotion(GtkWidget *widget, GdkEventMotion *event, void *data)
{
QTC_UNUSED(data);
if (event && event->window && GTK_IS_TREE_VIEW(widget) &&
gtk_tree_view_get_bin_window(GTK_TREE_VIEW(widget)) == event->window) {
qtcTreeViewUpdatePosition(widget, event->x, event->y);
}
return false;
}
static gboolean
qtcMenuShellButtonPress(GtkWidget *widget, GdkEventButton *event, void *data)
{
QTC_UNUSED(data);
if (GTK_IS_MENU_BAR(widget)) {
// QtCurve's menubars have a 2 pixel border ->
// but want the left/top to be 'active'...
int nx, ny;
gdk_window_get_origin(gtk_widget_get_window(widget), &nx, &ny);
if ((event->x_root - nx) <= 2.0 || (event->y_root - ny) <= 2.0) {
if ((event->x_root - nx) <= 2.0) {
event->x_root += 2.0;
}
if ((event->y_root - ny) <= 2.0) {
event->y_root += 2.0;
}
GtkMenuShell *menuShell = GTK_MENU_SHELL(widget);
GList *children =
gtk_container_get_children(GTK_CONTAINER(menuShell));
bool rv = false;
for (GList *child = children;child;child = child->next) {
GtkWidget *item = child->data;
QtcRect alloc = qtcWidgetGetAllocation(item);
int cx = alloc.x + nx;
int cy = alloc.y + ny;
int cw = alloc.width;
int ch = alloc.height;
if (cx <= event->x_root && cy <= event->y_root &&
(cx + cw) > event->x_root && (cy + ch) > event->y_root) {
if (menuIsSelectable(item)) {
if (event->type == GDK_BUTTON_PRESS) {
if (item != menuShell->active_menu_item) {
menuShell->active = false;
gtk_menu_shell_select_item(menuShell, item);
menuShell->active = true;
} else {
menuShell->active = true;
gtk_menu_shell_deselect(menuShell);
menuShell->active = false;
}
}
rv = true;
}
break;
}
}
if (children) {
g_list_free(children);
}
return rv;
}
}
return false;
}
static gboolean
qtcMenuShellMotion(GtkWidget *widget, GdkEventMotion *event, void *data)
{
QTC_UNUSED(data);
QTC_UNUSED(event);
if (GTK_IS_MENU_SHELL(widget)) {
int pointer_x, pointer_y;
GdkModifierType pointer_mask;
gdk_window_get_pointer(gtk_widget_get_window(widget), &pointer_x,
&pointer_y, &pointer_mask);
if (GTK_IS_CONTAINER(widget)) {
GList *children = gtk_container_get_children(GTK_CONTAINER(widget));
for (GList *child = children;child;child = g_list_next(child)) {
if ((child->data) && GTK_IS_WIDGET(child->data) &&
(gtk_widget_get_state(GTK_WIDGET(child->data)) !=
GTK_STATE_INSENSITIVE)) {
QtcRect alloc =
qtcWidgetGetAllocation(GTK_WIDGET(child->data));
if ((pointer_x >= alloc.x) && (pointer_y >= alloc.y) &&
(pointer_x < (alloc.x + alloc.width)) &&
(pointer_y < (alloc.y + alloc.height))) {
gtk_widget_set_state(GTK_WIDGET(child->data),
GTK_STATE_PRELIGHT);
} else {
gtk_widget_set_state(GTK_WIDGET(child->data),
GTK_STATE_NORMAL);
}
}
}
if (children) {
g_list_free(children);
}
}
}
return false;
}
static void
mainProcess(int argc, char **argv)
{
QTC_UNUSED(argc);
srandom(time(NULL));
fillBuffer(buff1, sizeof(buff1));
fillBuffer(buff2, sizeof(buff2));
QtcPopenFD fds[] = {{
.orig = 0,
.replace = 0,
.mode = QTC_POPEN_WRITE
}, {
.orig = 1,
static gboolean
qtcComboBoxLeave(GtkWidget *widget, GdkEventMotion *event, gpointer data)
{
QTC_UNUSED(event);
if (GTK_IS_EVENT_BOX(widget)) {
GtkWidget *widget = (GtkWidget*)data;
if (qtcComboHover == widget) {
qtcComboHover = NULL;
gtk_widget_queue_draw(widget);
}
}
return FALSE;
}
/* This gets called by the glib main loop every once in a while. */
static gboolean
qtcAnimationTimeoutHandler(gpointer data)
{
QTC_UNUSED(data);
/*g_print("** TICK **\n");*/
/* enter threads as qtcAnimationUpdateInfo will use gtk/gdk. */
gdk_threads_enter();
g_hash_table_foreach_remove(animated_widgets, qtcAnimationUpdateInfo, NULL);
/* leave threads again */
gdk_threads_leave();
if (g_hash_table_size(animated_widgets) == 0) {
qtcAnimationStopTimer();
return FALSE;
}
return TRUE;
}
static gboolean
qtcWindowKeyRelease(GtkWidget *widget, GdkEventKey *event, void *user_data)
{
QTC_UNUSED(user_data);
// Ensure only ctrl/alt/shift/capsLock are pressed...
if (GDK_CONTROL_MASK & event->state && GDK_MOD1_MASK & event->state &&
!event->is_modifier && 0 == (event->state & 0xFF00)) {
bool toggled = false;
if (opts.menubarHiding & HIDE_KEYBOARD &&
(GDK_KEY_m == event->keyval || GDK_KEY_M == event->keyval)) {
toggled = qtcWindowToggleMenuBar(widget);
}
if (opts.statusbarHiding & HIDE_KEYBOARD &&
(GDK_KEY_s == event->keyval || GDK_KEY_S == event->keyval)) {
toggled = qtcWindowToggleStatusBar(widget);
}
if (toggled) {
gtk_widget_queue_draw(widget);
}
}
return false;
}
/* update the animation information for each widget. This will also queue a redraw
* and stop the animation if it is done. */
static gboolean
qtcAnimationUpdateInfo(gpointer key, gpointer value, gpointer user_data)
{
QTC_UNUSED(user_data);
AnimationInfo *animation_info = value;
GtkWidget *widget = key;
if ((widget == NULL) || (animation_info == NULL))
g_assert_not_reached();
/* remove the widget from the hash table if it is not drawable */
if (!gtk_widget_is_drawable(widget))
return TRUE;
if (GTK_IS_PROGRESS_BAR(widget)) {
gfloat fraction =
gtk_progress_bar_get_fraction(GTK_PROGRESS_BAR(widget));
/* stop animation for filled/not filled progress bars */
if (fraction <= 0.0 || fraction >= 1.0) {
return TRUE;
}
} else if (GTK_IS_ENTRY(widget)) {
gfloat fraction = gtk_entry_get_progress_fraction(GTK_ENTRY(widget));
/* stop animation for filled/not filled progress bars */
if(fraction <= 0.0 || fraction >= 1.0) {
return TRUE;
}
}
force_widget_redraw(widget);
/* stop at stop_time */
if(animation_info->stop_time != 0 &&
g_timer_elapsed(animation_info->timer, NULL) > animation_info->stop_time)
return TRUE;
return FALSE;
}
static gboolean
qtcWindowConfigure(GtkWidget *widget, GdkEventConfigure *event, void *data)
{
QTC_UNUSED(widget);
QtCWindow *window = (QtCWindow*)data;
if (window && (event->width != window->width ||
event->height != window->height)) {
window->width = event->width;
window->height = event->height;
// schedule delayed timeOut
if (!window->timer) {
g_object_ref(G_OBJECT(window->widget));
window->timer =
g_timeout_add(50, qtcWindowDelayedUpdate, window);
window->locked = false;
} else {
window->locked = true;
}
}
return false;
}
