dwindows: gtk/dw.c comparison

comparison gtk/dw.c @ 1273:dfecd7b3c81e

Fix comparison of char * in dw_container_cursor and dw_container_delete_row Other changes due to removal of trailing spaces

author	mhessling@81767d24-ef19-dc11-ae90-00e081727c95
date	Sun, 30 Oct 2011 02:10:24 +0000
parents	5c200b371600
children	0b34e2cf0706

comparison

equal deleted inserted replaced

-:5c200b371600
+:dfecd7b3c81e
 #endif
 void _init_thread(void)
 {
 GdkColor *foreground = malloc(sizeof(GdkColor));
 foreground->pixel = foreground->red = foreground->green = foreground->blue = 0;
 pthread_setspecific(_dw_fg_color_key, foreground);
 pthread_setspecific(_dw_bg_color_key, NULL);
 }
 _dw_border_height = atoi(tmp);
 pthread_key_create(&_dw_fg_color_key, NULL);
 pthread_key_create(&_dw_bg_color_key, NULL);
 pthread_key_create(&_dw_mutex_key, NULL);
 _init_thread();
 gtk_rc_parse_string("style \"gtk-tooltips-style\" { bg[NORMAL] = \"#eeee00\" } widget \"gtk-tooltips\" style \"gtk-tooltips-style\"");
 #ifdef USE_GTKMOZEMBED
 return FALSE;
 fd = dwwait->data;
 fontname = gtk_font_selection_dialog_get_font_name(fd);
 if(fontname && (retfont = strdup(fontname)))
 {
 len = strlen(fontname);
 /* Convert to Dynamic Windows format if we can... */
 if(len > 0 && isdigit(fontname[len-1]))
 {
 int size;
 x=len-1;
 while(x > 0 && fontname[x] != ' ')
 {
 x--;
 }
 char *font = currfont ? strdup(currfont) : NULL;
 char *name = font ? strchr(font, '.') : NULL;
 int _locked_by_me = FALSE;
 char *retfont = NULL;
 DWDialog *dwwait;
 /* Detect Dynamic Windows style font name...
 * Format: ##.Fontname
 * and convert to a Pango name
 */
 if(name && isdigit(*font))
 {
 if(font)
 {
 gtk_font_selection_dialog_set_font_name(fd, font);
 free(font);
 }
 _dw_font_active = 1;
 dwwait = dw_dialog_new((void *)fd);
 g_signal_connect(G_OBJECT(fd->ok_button), "clicked", G_CALLBACK(_gtk_font_ok), dwwait);
 {
 pfont = pango_context_get_font_description( pcontext );
 if ( pfont )
 {
 int len, x;
 font = pango_font_description_to_string( pfont );
 retfont = strdup(font);
 len = strlen(font);
 /* Convert to Dynamic Windows format if we can... */
 if(len > 0 && isdigit(font[len-1]))
 {
 int size;
 x=len-1;
 while(x > 0 && font[x] != ' ')
 {
 x--;
 }
 }
 GdkColor _get_gdkcolor(unsigned long color)
 {
 GdkColor temp = _colors[0];
 if(color & DW_RGB_COLOR)
 {
 temp.pixel = 0;
 temp.red = DW_RED_VALUE(color) << 8;
 temp.green = DW_GREEN_VALUE(color) << 8;
 temp.blue = DW_BLUE_VALUE(color) << 8;
 {
 int z, rowcount = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(handle), "_dw_rowcount"));
 unsigned long odd = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(handle), "_dw_oddcol"));
 unsigned long even = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(handle), "_dw_evencol"));
 GdkColor *backcol = (GdkColor *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_backgdk");
 if(!backcol)
 backcol = &_colors[DW_CLR_WHITE];
 if(odd != DW_RGB_TRANSPARENT || even != DW_RGB_TRANSPARENT)
 {
 GdkColor oddcol = _get_gdkcolor(odd);
 GdkColor evencol = _get_gdkcolor(even);
 for(z=0;z<rowcount;z++)
 {
 int which = z % 2;
 if(which)
 gtk_clist_set_background(GTK_CLIST(handle), z, odd != DW_RGB_TRANSPARENT ? &oddcol : backcol);
 else if(!which)
 gtk_clist_set_background(GTK_CLIST(handle), z, even != DW_RGB_TRANSPARENT ? &evencol : backcol);
 }
 *       id: An ID to be used with dw_window_from_id() or 0L.
 */
 HWND dw_mle_new(unsigned long id)
 {
 GtkWidget *tmp, *tmpbox;
 #if GTK_MAJOR_VERSION < 2
 GtkWidget *scroller;
 #endif
 int _locked_by_me = FALSE;
 DW_MUTEX_LOCK;
 DW_MUTEX_UNLOCK;
 #endif
 }
 /* Internal function to update the progress bar
 * while in an indeterminate state.
 */
 gboolean _dw_update_progress_bar(gpointer data)
 {
 if(g_object_get_data(G_OBJECT(data), "_dw_alive"))
 {
 /* Check if we are indeterminate already */
 if(!gtk_object_get_data(GTK_OBJECT(handle), "_dw_alive"))
 {
 /* If not become indeterminate... and start a timer to continue */
 gtk_progress_bar_pulse(GTK_PROGRESS_BAR(handle));
 gtk_object_set_data(GTK_OBJECT(handle), "_dw_alive",
 GINT_TO_POINTER(gtk_timeout_add(100, (GtkFunction)_dw_update_progress_bar, (gpointer)handle)));
 }
 }
 else
 {
 int tag = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(handle), "_dw_alive"));
 if(tag)
 {
 /* Cancel the existing timer if one is there */
 gtk_timeout_remove(tag);
 gtk_object_set_data(GTK_OBJECT(handle), "_dw_alive", NULL);
 }
 /* Set the position like normal */
 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(handle), (gfloat)position/100);
 }
 rowcount = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(clist), "_dw_rowcount"));
 for(z=0;z<rowcount;z++)
 {
 rowdata = gtk_clist_get_row_data(GTK_CLIST(clist), z);
-if(rowdata == text)
+if ( strcmp(rowdata, text) == 0 )
 {
 gfloat pos;
 GtkAdjustment *adj = gtk_clist_get_vadjustment(GTK_CLIST(clist));
 _dw_unselect(clist);
 rowcount = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(clist), "_dw_rowcount"));
 for(z=0;z<rowcount;z++)
 {
 rowdata = gtk_clist_get_row_data(GTK_CLIST(clist), z);
-if(rowdata == text)
+if ( strcmp(rowdata, text) == 0 )
 {
 _dw_unselect(clist);
 gtk_clist_remove(GTK_CLIST(clist), z);
 static void _status_translate(GtkStatusIcon *status_icon, guint button, guint activate_time, gpointer user_data)
 {
 GdkEventButton event = { 0 };
 long x, y;
 gboolean retval;
 dw_pointer_query_pos(&x, &y);
 event.button = button;
 event.x = x;
 event.y = y;
 g_signal_emit_by_name(G_OBJECT(user_data), "button_press_event", &event, &retval);
 }
 #endif
 /*
 status = gtk_status_icon_new_from_pixbuf(pixbuf);
 if(bubbletext)
 gtk_status_icon_set_tooltip_text(status, bubbletext);
 g_object_set_data(G_OBJECT(handle), "_dw_taskbar", status);
 g_signal_connect(G_OBJECT (status), "popup-menu", G_CALLBACK (_status_translate), handle);
 gtk_status_icon_set_visible(status, TRUE);
 DW_MUTEX_UNLOCK;
 #endif
 }
 /*
 * Deletes an icon from the taskbar.
 */
 void dw_color_background_set(unsigned long value)
 {
 int _locked_by_me = FALSE;
 GdkColor *background = pthread_getspecific(_dw_bg_color_key);
 if(value == DW_CLR_DEFAULT)
 {
 if(background)
 {
 pthread_setspecific(_dw_bg_color_key, NULL);
 }
 }
 else
 {
 GdkColor color = _internal_color(value);
 DW_MUTEX_LOCK;
 	  gdk_color_alloc(_dw_cmap, &color);
 DW_MUTEX_UNLOCK;
 if(!background)
 {
 cairo_set_line_width(cr, 1);
 cairo_move_to(cr, x, y);
 cairo_stroke(cr);
 cairo_destroy(cr);
 }
 #endif
 if(gc)
 {
 gdk_draw_point(handle ? handle->window : pixmap->pixmap, gc, x, y);
 gdk_gc_unref(gc);
 }
 if(fill)
 cairo_fill(cr);
 cairo_stroke(cr);
 cairo_destroy(cr);
 }
 #endif
 if(gc && npoints)
 {
 points = alloca(npoints * sizeof(GdkPoint));
 /*
 * should check for NULL pointer return!
 for(i = 0; i < npoints; i++)
 {
 points[i].x = x[i];
 points[i].y = y[i];
 }
 gdk_draw_polygon(handle ? handle->window : pixmap->pixmap, gc, fill, points, npoints );
 gdk_gc_unref(gc);
 }
 DW_MUTEX_UNLOCK;
 }
 if(fill)
 cairo_fill(cr);
 cairo_stroke(cr);
 cairo_destroy(cr);
 }
 #endif
 if(gc)
 {
 gdk_draw_rectangle(handle ? handle->window : pixmap->pixmap, gc, fill, x, y, width, height);
 gdk_gc_unref(gc);
 }
 if(cr)
 {
 GdkColor *foreground = pthread_getspecific(_dw_fg_color_key);
 double a1 = atan2((y1-yorigin), (x1-xorigin));
 double a2 = atan2((y2-yorigin), (x2-xorigin));
 gdk_cairo_set_source_color (cr, foreground);
 cairo_set_line_width(cr, 1);
 /* TODO: Handle ellipses */
 if(flags & DW_DRAW_FULL)
 cairo_arc(cr, xorigin, yorigin, r, 0, M_PI*2);
 if(flags & DW_DRAW_FILL)
 cairo_fill(cr);
 cairo_stroke(cr);
 cairo_destroy(cr);
 }
 #endif
 if(gc)
 {
 double radius1 = 0, radius2 = 0;
 int alpha1, alpha2;
 }
 alpha1 = (int)(radius1 * 64.0);
 alpha2 = (int)((radius2 - radius1) * 64.0);
 while (alpha2 <= 0) alpha2 += 360*64;
 while (alpha1 > 360*64) alpha1 -= 360*64;
 gdk_draw_arc(handle ? handle->window : pixmap->pixmap, gc, FALSE, xorigin-r, yorigin-r, 2*r,2*r, alpha1, alpha2);
 gdk_gc_unref(gc);
 }
 DW_MUTEX_UNLOCK;
 }
 cr = cairo_create(destp->image);
 if(cr)
 {
 double xscale = 1, yscale = 1;
 if(srcwidth != -1 && srcheight != -1)
 {
 xscale = (double)width / (double)srcwidth;
 yscale = (double)height / (double)srcheight;
 cairo_scale(cr, xscale, yscale);
 }
 #if GTK_CHECK_VERSION(2,24,0)
 if(src)
 gdk_cairo_set_source_window (cr, gtk_widget_get_window(src), xdest -xsrc, ydest - ysrc);
 else
 #endif
 else if(srcp && srcp->pixmap && !srcp->bitmap)
 gdk_cairo_set_source_pixmap (cr, srcp->pixmap, (xdest - xsrc) / xscale, (ydest - ysrc) / yscale);
 else if(srcp && srcp->pixmap && srcp->bitmap)
 {
 cairo_pattern_t *mask_pattern;
 /* hack to get the mask pattern */
 gdk_cairo_set_source_pixmap(cr, srcp->bitmap, xdest / xscale, ydest / yscale);
 mask_pattern = cairo_get_source(cr);
 cairo_pattern_reference(mask_pattern);
 #if GTK_CHECK_VERSION(2,10,0)
 if((destp && destp->image) || (srcp && srcp->image))
 return _cairo_pixmap_bitblt(dest, destp, xdest, ydest, width, height, src, srcp, xsrc, ysrc, srcwidth, srcheight);
 #endif
 if((!dest && (!destp || !destp->pixmap)) || (!src && (!srcp || !srcp->pixmap)))
 return retval;
 if((srcwidth == -1 || srcheight == -1) && srcwidth != srcheight)
 return retval;
 * draw the resulting scaled copy and free the left over pixbufs.
 */
 GdkPixbuf *pbdst, *pbsrc = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, srcwidth, srcheight);
 /* Now that with have a pixbuf with alpha, copy from the drawable to create the source */
 gdk_pixbuf_get_from_drawable(pbsrc, src ? src->window : srcp->pixmap, NULL, xsrc, ysrc, 0, 0, srcwidth, srcheight);
 /* Scale the pixbuf to the desired size */
 pbdst = gdk_pixbuf_scale_simple(pbsrc, width, height, GDK_INTERP_BILINEAR);
 /* Create a new clipping mask from the scaled pixbuf */
 if( srcp && srcp->bitmap && srcp->pixbuf )
 {
 GdkBitmap *bitmap = gdk_pixmap_new(NULL, width, height, 1);
 GdkPixbuf *pborig = gdk_pixbuf_scale_simple(srcp->pixbuf, width, height, GDK_INTERP_BILINEAR);
 gdk_pixbuf_render_threshold_alpha(pborig, bitmap, 0, 0, 0, 0, width, height, 1);
 gdk_gc_set_clip_mask( gc, bitmap );
 gdk_gc_set_clip_origin( gc, xdest, ydest );
 gdk_bitmap_unref(bitmap);
 gdk_pixbuf_unref(pborig);
 }
 if(!eve)
 return DW_ERROR_NON_INIT;
 pthread_mutex_lock (&(eve->mutex));
 if(eve->posted)
 {
 pthread_mutex_unlock (&(eve->mutex));
 return DW_ERROR_NONE;
 }
 if(timeout != -1)
 {
 struct timeval now;
 struct timespec timeo;
 gettimeofday(&now, 0);
 timeo.tv_sec = now.tv_sec + (timeout / 1000);
 timeo.tv_nsec = now.tv_usec * 1000;
 rc = pthread_cond_timedwait(&(eve->event), &(eve->mutex), &timeo);
 }
 else
 rc = pthread_cond_wait(&(eve->event), &(eve->mutex));
 pthread_mutex_unlock (&(eve->mutex));
 if(!rc)
 return DW_ERROR_NONE;
 if(rc == ETIMEDOUT)
 return DW_ERROR_TIMEOUT;
 threadfunc = (void (*)(void *))tmp[0];
 /* Initialize colors */
 _init_thread();
 threadfunc(tmp[1]);
 free(tmp);
 /* Free colors */
 if((foreground = pthread_getspecific(_dw_fg_color_key)))
 free(foreground);
 if((background = pthread_getspecific(_dw_bg_color_key)))
 free(background);
 guint oldpos;
 /* Drop out if missing table */
 if(!cont)
 return;
 /* Check orientation */
 if(pos < 0)
 {
 /* Horz */
 pos = -(pos + 1);
 gtk_container_child_get(cont, widget, "left-attach", &oldpos, NULL);
 /* Do some sanity bounds checking */
 if(index < 0)
 index = 0;
 if(index > boxcount)
 index = boxcount;
 if(boxtype == DW_VERT)
 {
 x = 0;
 y = index;
 gtk_table_resize(GTK_TABLE(box), boxcount + 1, 1);
 }
 }
 else
 {
 GtkWidget *vbox = gtk_object_get_data(GTK_OBJECT(box), "_dw_vbox");
 if(!vbox)
 {
 vbox = gtk_vbox_new(FALSE, 0);
 gtk_object_set_data(GTK_OBJECT(box), "_dw_vbox", vbox);
 gtk_container_add(GTK_CONTAINER(box), vbox);
 gtk_widget_show(vbox);
 }
 gtk_container_set_border_width(GTK_CONTAINER(box), pad);
 if(GTK_IS_TABLE(item) || (tmpitem && GTK_IS_TABLE(tmpitem)))
 {
 GtkWidget *eventbox = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(item), "_dw_eventbox");
 /*
 * Pack windows (widgets) into a box at an arbitrary location.
 * Parameters:
 *       box: Window handle of the box to be packed into.
 *       item: Window handle of the item to be back.
 *       index: 0 based index of packed items.
 *       width: Width in pixels of the item or -1 to be self determined.
 *       height: Height in pixels of the item or -1 to be self determined.
 *       hsize: TRUE if the window (widget) should expand horizontally to fill space given.
 *       vsize: TRUE if the window (widget) should expand vertically to fill space given.
 *       pad: Number of pixels of padding around the item.
 *       vsize: TRUE if the window (widget) should expand vertically to fill space given.
 *       pad: Number of pixels of padding around the item.
 */
 void API dw_box_pack_start(HWND box, HWND item, int width, int height, int hsize, int vsize, int pad)
 {
 /* 65536 is the table limit on GTK...
 * seems like a high enough value we will never hit it here either.
 */
 _dw_box_pack(box, item, 65536, width, height, hsize, vsize, pad, "dw_box_pack_start()");
 }
 GtkWidget *mdi;
 #endif
 if(!handle)
 return;
 DW_MUTEX_LOCK;
 #if GTK_MAJOR_VERSION > 1
 if((mdi = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_mdi")) && GTK_IS_MDI(mdi))
 {
 gtk_mdi_move(GTK_MDI(mdi), handle, x, y);
 }
 else
 #endif
 {
 GdkWindow *window = NULL;
 if(GTK_IS_WINDOW(handle))
 {
 #if GTK_MAJOR_VERSION > 1
 gtk_window_move(GTK_WINDOW(handle), x, y);
 #else
 gtk_widget_set_uposition(handle, x, y);
 #endif
 }
 else if((window = gtk_widget_get_window(handle)))
 gdk_window_move(window, x, y);
 }
 DW_MUTEX_UNLOCK;
 GtkWidget *mdi;
 #endif
 if(!handle)
 return;
 DW_MUTEX_LOCK;
 #if GTK_MAJOR_VERSION > 1
 if((mdi = (GtkWidget *)gtk_object_get_data(GTK_OBJECT(handle), "_dw_mdi")) && GTK_IS_MDI(mdi))
 {
 gtk_mdi_move(GTK_MDI(mdi), handle, x, y);
 dw_window_set_size(handle, width, height);
 #if GTK_MAJOR_VERSION > 1
 gtk_window_move(GTK_WINDOW(handle), x, y);
 #else
 gtk_widget_set_uposition(handle, x, y);
 #endif
 }
 else if(handle->window)
 {
 gdk_window_resize(handle->window, width, height);
 gdk_window_move(handle->window, x, y);
 GtkFileFilter *filter2 = NULL;
 gchar *button;
 char *filename = NULL;
 char buf[1000];
 char mypath[PATH_MAX+1];
 switch (flags )
 {
 case DW_DIRECTORY_OPEN:
 action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;
 button = GTK_STOCK_OPEN;
 HPRINT API dw_print_new(char *jobname, unsigned long flags, unsigned int pages, void *drawfunc, void *drawdata)
 {
 #if GTK_CHECK_VERSION(2,10,0)
 GtkPrintOperation *op;
 int _locked_by_me = FALSE;
 if(!drawfunc)
 return NULL;
 DW_MUTEX_LOCK;
 if((op = gtk_print_operation_new()))
 {
 gtk_print_operation_set_n_pages(op, pages);
 gtk_print_operation_set_job_name(op, jobname ? jobname : "Dynamic Windows Print Job");
 g_object_set_data(G_OBJECT(op), "_dw_drawfunc", drawfunc);
 {
 #if GTK_CHECK_VERSION(2,10,0)
 GtkPrintOperationResult res;
 GtkPrintOperation *op = (GtkPrintOperation *)print;
 int _locked_by_me = FALSE;
 DW_MUTEX_LOCK;
 res = gtk_print_operation_run(op, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, NULL, NULL);
 DW_MUTEX_UNLOCK;
 return (res == GTK_PRINT_OPERATION_RESULT_ERROR ? DW_ERROR_UNKNOWN : DW_ERROR_NONE);
 #else
 return DW_ERROR_UNKNOWN;
 #endif
 }
 /*
 void API dw_print_cancel(HPRINT print)
 {
 #if GTK_CHECK_VERSION(2,10,0)
 int _locked_by_me = FALSE;
 GtkPrintOperation *op = (GtkPrintOperation *)print;
 DW_MUTEX_LOCK;
 gtk_print_operation_cancel(op);
 DW_MUTEX_UNLOCK;
 #endif
 }

Mercurial > dwindows

comparison gtk/dw.c @ 1273:dfecd7b3c81e