Mercurial > dwindows

comparison gtk3/dw.c @ 781:df6091308b3f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Have the basics of containers working now with the tree view widget.
author bsmith@81767d24-ef19-dc11-ae90-00e081727c95
date Mon, 21 Mar 2011 04:25:52 +0000
parents fda93b441c4d
children 5a4bfe989f50
comparison
equal deleted inserted replaced
780:fda93b441c4d 781:df6091308b3f
5343 } 5343 }
5344 5344
5345 static int _dw_container_setup(HWND handle, unsigned long *flags, char **titles, int count, int separator, int extra) 5345 static int _dw_container_setup(HWND handle, unsigned long *flags, char **titles, int count, int separator, int extra)
5346 { 5346 {
5347 int z; 5347 int z;
5348 char numbuf[20];
5348 GtkWidget *tree; 5349 GtkWidget *tree;
5349 GtkListStore *store; 5350 GtkListStore *store;
5350 GtkTreeViewColumn *col, *expander = NULL; 5351 GtkTreeViewColumn *col, *expander = NULL;
5351 GtkCellRenderer *rend; 5352 GtkCellRenderer *rend;
5352 GtkTreeSelection *sel; 5353 GtkTreeSelection *sel;
5353 int _locked_by_me = FALSE; 5354 int _locked_by_me = FALSE;
5354 GType *array = calloc(count + 2, sizeof(gint)); 5355 GType *array = calloc(count + 2, sizeof(gint));
5355 unsigned long *newflags = calloc(count, sizeof(unsigned long));
5356
5357 memcpy(newflags, flags, count * sizeof(unsigned long));
5358 5356
5359 DW_MUTEX_LOCK; 5357 DW_MUTEX_LOCK;
5360 /* Save some of the info so it is easily accessible */ 5358 /* Save some of the info so it is easily accessible */
5361 g_object_set_data(G_OBJECT(handle), "_dw_cont_col_flags", (gpointer)newflags);
5362 g_object_set_data(G_OBJECT(handle), "_dw_cont_columns", GINT_TO_POINTER(count)); 5359 g_object_set_data(G_OBJECT(handle), "_dw_cont_columns", GINT_TO_POINTER(count));
5360 g_object_set_data(G_OBJECT(handle), "_dw_cont_extra", GINT_TO_POINTER(extra));
5363 5361
5364 /* First param is row title/data */ 5362 /* First param is row title/data */
5365 array[0] = G_TYPE_POINTER; 5363 array[0] = G_TYPE_POINTER;
5366 /* First loop... create array to create the store */ 5364 /* First loop... create array to create the store */
5367 for(z=0;z<count;z++) 5365 for(z=0;z<count;z++)
5392 tree = _tree_setup(handle, GTK_TREE_MODEL(store)); 5390 tree = _tree_setup(handle, GTK_TREE_MODEL(store));
5393 g_object_set_data(G_OBJECT(tree), "_dw_tree_type", (gpointer)_DW_TREE_TYPE_CONTAINER); 5391 g_object_set_data(G_OBJECT(tree), "_dw_tree_type", (gpointer)_DW_TREE_TYPE_CONTAINER);
5394 /* Second loop... create the columns */ 5392 /* Second loop... create the columns */
5395 for(z=0;z<count;z++) 5393 for(z=0;z<count;z++)
5396 { 5394 {
5395 sprintf(numbuf, "_dw_cont_col%d", z);
5396 g_object_set_data(G_OBJECT(tree), numbuf, GINT_TO_POINTER(flags[z]));
5397 col = gtk_tree_view_column_new(); 5397 col = gtk_tree_view_column_new();
5398 if(flags[z] & DW_CFA_BITMAPORICON) 5398 if(flags[z] & DW_CFA_BITMAPORICON)
5399 { 5399 {
5400 rend = gtk_cell_renderer_pixbuf_new(); 5400 rend = gtk_cell_renderer_pixbuf_new();
5401 gtk_tree_view_column_pack_start(col, rend, FALSE); 5401 gtk_tree_view_column_pack_start(col, rend, FALSE);
5484 newflags[1] = DW_CFA_STRING | DW_CFA_LEFT | DW_CFA_HORZSEPARATOR; 5484 newflags[1] = DW_CFA_STRING | DW_CFA_LEFT | DW_CFA_HORZSEPARATOR;
5485 5485
5486 memcpy(&newtitles[2], titles, sizeof(char *) * count); 5486 memcpy(&newtitles[2], titles, sizeof(char *) * count);
5487 memcpy(&newflags[2], flags, sizeof(unsigned long) * count); 5487 memcpy(&newflags[2], flags, sizeof(unsigned long) * count);
5488 5488
5489 _dw_container_setup(handle, newflags, newtitles, count + 1, 1, 1); 5489 _dw_container_setup(handle, newflags, newtitles, count + 2, 1, 2);
5490 5490
5491 if ( newtitles) free(newtitles); 5491 if ( newtitles) free(newtitles);
5492 if ( newflags ) free(newflags); 5492 if ( newflags ) free(newflags);
5493 return TRUE; 5493 return TRUE;
5494 } 5494 }
5676 * handle: Handle to the container window (widget). 5676 * handle: Handle to the container window (widget).
5677 * rowcount: The number of items to be populated. 5677 * rowcount: The number of items to be populated.
5678 */ 5678 */
5679 void *dw_container_alloc(HWND handle, int rowcount) 5679 void *dw_container_alloc(HWND handle, int rowcount)
5680 { 5680 {
5681 #if 0 5681 int z, prevrowcount = 0;
5682 int z, count = 0, prevrowcount = 0; 5682 GtkWidget *cont;
5683 GtkWidget *clist; 5683 GtkListStore *store = NULL;
5684 GdkColor *fore, *back; 5684 int _locked_by_me = FALSE;
5685 char **blah; 5685
5686 int _locked_by_me = FALSE; 5686 DW_MUTEX_LOCK;
5687 5687 cont = (GtkWidget *)g_object_get_data(G_OBJECT(handle), "_dw_user");
5688 DW_MUTEX_LOCK; 5688
5689 clist = (GtkWidget *)g_object_get_data(G_OBJECT(handle), "_dw_user"); 5689 /* Make sure it is the correct tree type */
5690 if(!clist) 5690 if(cont && GTK_IS_TREE_VIEW(cont) && g_object_get_data(G_OBJECT(cont), "_dw_tree_type") == GINT_TO_POINTER(_DW_TREE_TYPE_CONTAINER))
5691 { 5691 store = (GtkListStore *)gtk_tree_view_get_model(GTK_TREE_VIEW(cont));
5692 DW_MUTEX_UNLOCK; 5692
5693 return NULL; 5693 if(store)
5694 } 5694 {
5695 5695 GtkTreeIter iter;
5696 count = (int)g_object_get_data(G_OBJECT(clist), "_dw_colcount"); 5696
5697 prevrowcount = (int)g_object_get_data(G_OBJECT(clist), "_dw_rowcount"); 5697 prevrowcount = (int)g_object_get_data(G_OBJECT(cont), "_dw_rowcount");
5698 5698
5699 if(!count) 5699 for(z=0;z<rowcount;z++)
5700 { 5700 {
5701 DW_MUTEX_UNLOCK; 5701 gtk_list_store_append(store, &iter);
5702 return NULL; 5702 }
5703 } 5703 g_object_set_data(G_OBJECT(cont), "_dw_insertpos", GINT_TO_POINTER(prevrowcount));
5704 5704 g_object_set_data(G_OBJECT(cont), "_dw_rowcount", GINT_TO_POINTER(rowcount + prevrowcount));
5705 blah = malloc(sizeof(char *) * count); 5705 }
5706 memset(blah, 0, sizeof(char *) * count); 5706 DW_MUTEX_UNLOCK;
5707 5707 return (void *)cont;
5708 fore = (GdkColor *)g_object_get_data(G_OBJECT(clist), "_dw_foregdk");
5709 back = (GdkColor *)g_object_get_data(G_OBJECT(clist), "_dw_backgdk");
5710 gtk_clist_freeze(GTK_CLIST(clist));
5711 for(z=0;z<rowcount;z++)
5712 {
5713 gtk_clist_append(GTK_CLIST(clist), blah);
5714 if(fore)
5715 gtk_clist_set_foreground(GTK_CLIST(clist), z + prevrowcount, fore);
5716 if(back)
5717 gtk_clist_set_background(GTK_CLIST(clist), z + prevrowcount, back);
5718 }
5719 g_object_set_data(G_OBJECT(clist), "_dw_insertpos", GINT_TO_POINTER(prevrowcount));
5720 g_object_set_data(G_OBJECT(clist), "_dw_rowcount", GINT_TO_POINTER(rowcount + prevrowcount));
5721 free(blah);
5722 DW_MUTEX_UNLOCK;
5723 return (void *)handle;
5724 #endif
5725 return NULL;
5726 } 5708 }
5727 5709
5728 /* 5710 /*
5729 * Internal representation of dw_container_set_item() extracted so we can pass 5711 * Internal representation of dw_container_set_item() extracted so we can pass
5730 * two data pointers; icon and text for dw_filesystem_set_item(). 5712 * two data pointers; icon and text for dw_filesystem_set_item().
5731 */ 5713 */
5732 void _dw_container_set_item(HWND handle, void *pointer, int column, int row, void *data, char *text) 5714 void _dw_container_set_item(HWND handle, void *pointer, int column, int row, void *data)
5733 { 5715 {
5734 #if 0 5716 char numbuf[20], textbuffer[100];
5735 char numbuf[10], textbuffer[100];
5736 int flag = 0; 5717 int flag = 0;
5737 GtkWidget *clist; 5718 GtkWidget *cont;
5738 int _locked_by_me = FALSE; 5719 GtkListStore *store = NULL;
5739 5720 int _locked_by_me = FALSE;
5740 DW_MUTEX_LOCK; 5721
5741 clist = (GtkWidget *)g_object_get_data(G_OBJECT(handle), "_dw_user"); 5722 DW_MUTEX_LOCK;
5742 if(!clist) 5723 cont = (GtkWidget *)g_object_get_data(G_OBJECT(handle), "_dw_user");
5743 { 5724
5744 DW_MUTEX_UNLOCK; 5725 /* Make sure it is the correct tree type */
5745 return; 5726 if(cont && GTK_IS_TREE_VIEW(cont) && g_object_get_data(G_OBJECT(cont), "_dw_tree_type") == GINT_TO_POINTER(_DW_TREE_TYPE_CONTAINER))
5746 } 5727 store = (GtkListStore *)gtk_tree_view_get_model(GTK_TREE_VIEW(cont));
5747 5728
5748 sprintf(numbuf, "%d", column); 5729 if(store)
5749 flag = (int)g_object_get_data(G_OBJECT(clist), numbuf); 5730 {
5750 row += (int)g_object_get_data(G_OBJECT(clist), "_dw_insertpos"); 5731 GtkTreeIter iter;
5751 5732
5752 if(flag & DW_CFA_BITMAPORICON) 5733 sprintf(numbuf, "_dw_cont_col%d", column);
5753 { 5734 flag = (int)g_object_get_data(G_OBJECT(cont), numbuf);
5754 long hicon = *((long *)data); 5735 if(pointer)
5755 GdkBitmap *bitmap = NULL; 5736 {
5756 GdkPixmap *pixmap = _find_pixmap(&bitmap, hicon, clist, NULL, NULL); 5737 row += (int)g_object_get_data(G_OBJECT(cont), "_dw_insertpos");
5757 5738 }
5758 if(pixmap) 5739
5759 gtk_clist_set_pixmap(GTK_CLIST(clist), row, column, pixmap, bitmap); 5740 if(gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(store), &iter, NULL, row))
5760 } 5741 {
5761 else if(flag & DW_CFA_STRINGANDICON) 5742 if(flag & DW_CFA_BITMAPORICON)
5762 { 5743 {
5763 long hicon = *((long *)data); 5744 long hicon = *((long *)data);
5764 GdkBitmap *bitmap = NULL; 5745 GdkPixbuf *pixbuf = _find_pixbuf(hicon, NULL, NULL);
5765 GdkPixmap *pixmap = _find_pixmap(&bitmap, hicon, clist, NULL, NULL); 5746
5766 5747 if(pixbuf)
5767 if(pixmap) 5748 gtk_list_store_set(store, &iter, column + 1, pixbuf, -1);
5768 gtk_clist_set_pixtext(GTK_CLIST(clist), row, column, text, 2, pixmap, bitmap); 5749 }
5769 } 5750 else if(flag & DW_CFA_STRING)
5770 else if(flag & DW_CFA_STRING) 5751 {
5771 { 5752 char *tmp = *((char **)data);
5772 char *tmp = *((char **)data); 5753 gtk_list_store_set(store, &iter, column + 1, tmp, -1);
5773 gtk_clist_set_text(GTK_CLIST(clist), row, column, tmp); 5754 }
5774 } 5755 else if(flag & DW_CFA_ULONG)
5775 else if(flag & DW_CFA_ULONG) 5756 {
5776 { 5757 ULONG tmp = *((ULONG *)data);
5777 ULONG tmp = *((ULONG *)data); 5758
5778 5759 gtk_list_store_set(store, &iter, column + 1, tmp, -1);
5779 sprintf(textbuffer, "%lu", tmp); 5760 }
5780 5761 else if(flag & DW_CFA_DATE)
5781 gtk_clist_set_text(GTK_CLIST(clist), row, column, textbuffer); 5762 {
5782 } 5763 struct tm curtm;
5783 else if(flag & DW_CFA_DATE) 5764 CDATE cdate = *((CDATE *)data);
5784 { 5765
5785 struct tm curtm; 5766 memset( &curtm, 0, sizeof(curtm) );
5786 CDATE cdate = *((CDATE *)data); 5767 curtm.tm_mday = cdate.day;
5787 5768 curtm.tm_mon = cdate.month - 1;
5788 memset( &curtm, 0, sizeof(curtm) ); 5769 curtm.tm_year = cdate.year - 1900;
5789 curtm.tm_mday = cdate.day; 5770
5790 curtm.tm_mon = cdate.month - 1; 5771 strftime(textbuffer, 100, "%x", &curtm);
5791 curtm.tm_year = cdate.year - 1900; 5772
5792 5773 gtk_list_store_set(store, &iter, column + 1, textbuffer, -1);
5793 strftime(textbuffer, 100, "%x", &curtm); 5774 }
5794 5775 else if(flag & DW_CFA_TIME)
5795 gtk_clist_set_text(GTK_CLIST(clist), row, column, textbuffer); 5776 {
5796 } 5777 struct tm curtm;
5797 else if(flag & DW_CFA_TIME) 5778 CTIME ctime = *((CTIME *)data);
5798 { 5779
5799 struct tm curtm; 5780 memset( &curtm, 0, sizeof(curtm) );
5800 CTIME ctime = *((CTIME *)data); 5781 curtm.tm_hour = ctime.hours;
5801 5782 curtm.tm_min = ctime.minutes;
5802 memset( &curtm, 0, sizeof(curtm) ); 5783 curtm.tm_sec = ctime.seconds;
5803 curtm.tm_hour = ctime.hours; 5784
5804 curtm.tm_min = ctime.minutes; 5785 strftime(textbuffer, 100, "%X", &curtm);
5805 curtm.tm_sec = ctime.seconds; 5786
5806 5787 gtk_list_store_set(store, &iter, column + 1, textbuffer, -1);
5807 strftime(textbuffer, 100, "%X", &curtm); 5788 }
5808 5789 }
5809 gtk_clist_set_text(GTK_CLIST(clist), row, column, textbuffer); 5790 }
5810 } 5791 DW_MUTEX_UNLOCK;
5811 DW_MUTEX_UNLOCK;
5812 #endif
5813 } 5792 }
5814 5793
5815 /* 5794 /*
5816 * Sets an item in specified row and column to the given data. 5795 * Sets an item in specified row and column to the given data.
5817 * Parameters: 5796 * Parameters:
5821 * row: Zero based row of data being set. 5800 * row: Zero based row of data being set.
5822 * data: Pointer to the data to be added. 5801 * data: Pointer to the data to be added.
5823 */ 5802 */
5824 void dw_container_set_item(HWND handle, void *pointer, int column, int row, void *data) 5803 void dw_container_set_item(HWND handle, void *pointer, int column, int row, void *data)
5825 { 5804 {
5826 _dw_container_set_item(handle, NULL, column, row, data, NULL); 5805 GtkTreeView *tree = pointer;
5806
5807 if(GTK_IS_TREE_VIEW(tree))
5808 {
5809 _dw_container_set_item(handle, NULL, column, row, data);
5810 }
5827 } 5811 }
5828 5812
5829 /* 5813 /*
5830 * Changes an existing item in specified row and column to the given data. 5814 * Changes an existing item in specified row and column to the given data.
5831 * Parameters: 5815 * Parameters:
5834 * row: Zero based row of data being set. 5818 * row: Zero based row of data being set.
5835 * data: Pointer to the data to be added. 5819 * data: Pointer to the data to be added.
5836 */ 5820 */
5837 void dw_container_change_item(HWND handle, int column, int row, void *data) 5821 void dw_container_change_item(HWND handle, int column, int row, void *data)
5838 { 5822 {
5839 _dw_container_set_item(handle, NULL, column, row, data, NULL); 5823 _dw_container_set_item(handle, NULL, column, row, data);
5840 } 5824 }
5841 5825
5842 /* 5826 /*
5843 * Changes an existing item in specified row and column to the given data. 5827 * Changes an existing item in specified row and column to the given data.
5844 * Parameters: 5828 * Parameters:
5875 * row: Zero based row of data being set. 5859 * row: Zero based row of data being set.
5876 * data: Pointer to the data to be added. 5860 * data: Pointer to the data to be added.
5877 */ 5861 */
5878 void dw_filesystem_set_file(HWND handle, void *pointer, int row, char *filename, HICN icon) 5862 void dw_filesystem_set_file(HWND handle, void *pointer, int row, char *filename, HICN icon)
5879 { 5863 {
5880 _dw_container_set_item(handle, pointer, 0, row, (void *)&icon, filename); 5864 GtkTreeView *tree = pointer;
5865
5866 if(GTK_IS_TREE_VIEW(tree))
5867 {
5868 _dw_container_set_item(handle, pointer, 0, row, (void *)&icon);
5869 _dw_container_set_item(handle, pointer, 1, row, (void *)&filename);
5870 }
5881 } 5871 }
5882 5872
5883 /* 5873 /*
5884 * Sets an item in specified row and column to the given data. 5874 * Sets an item in specified row and column to the given data.
5885 * Parameters: 5875 * Parameters:
5889 * row: Zero based row of data being set. 5879 * row: Zero based row of data being set.
5890 * data: Pointer to the data to be added. 5880 * data: Pointer to the data to be added.
5891 */ 5881 */
5892 void dw_filesystem_set_item(HWND handle, void *pointer, int column, int row, void *data) 5882 void dw_filesystem_set_item(HWND handle, void *pointer, int column, int row, void *data)
5893 { 5883 {
5894 _dw_container_set_item(handle, pointer, column + 1, row, data, NULL); 5884 GtkTreeView *tree = pointer;
5885
5886 if(GTK_IS_TREE_VIEW(tree))
5887 {
5888 _dw_container_set_item(handle, pointer, column + 2, row, data);
5889 }
5895 } 5890 }
5896 5891
5897 /* 5892 /*
5898 * Gets column type for a container column 5893 * Gets column type for a container column
5899 * Parameters: 5894 * Parameters:
5900 * handle: Handle to the container window (widget). 5895 * handle: Handle to the container window (widget).
5901 * column: Zero based column. 5896 * column: Zero based column.
5902 */ 5897 */
5903 int dw_container_get_column_type(HWND handle, int column) 5898 int dw_container_get_column_type(HWND handle, int column)
5904 { 5899 {
5905 char numbuf[10]; 5900 char numbuf[20];
5906 int flag, rc = 0; 5901 int flag, rc = 0;
5907 #if 0 5902 GtkWidget *cont;
5908 GtkWidget *clist; 5903 int _locked_by_me = FALSE;
5909 int _locked_by_me = FALSE; 5904
5910 5905 DW_MUTEX_LOCK;
5911 DW_MUTEX_LOCK; 5906 cont = (GtkWidget *)g_object_get_data(G_OBJECT(handle), "_dw_user");
5912 clist = (GtkWidget *)g_object_get_data(G_OBJECT(handle), "_dw_user"); 5907 if(!cont)
5913 if(!clist)
5914 { 5908 {
5915 DW_MUTEX_UNLOCK; 5909 DW_MUTEX_UNLOCK;
5916 return 0; 5910 return 0;
5917 } 5911 }
5918 5912
5919 sprintf(numbuf, "%d", column); 5913 sprintf(numbuf, "_dw_cont_col%d", column);
5920 flag = (int)g_object_get_data(G_OBJECT(clist), numbuf); 5914 flag = (int)g_object_get_data(G_OBJECT(cont), numbuf);
5921 5915
5922 if(flag & DW_CFA_BITMAPORICON) 5916 if(flag & DW_CFA_BITMAPORICON)
5923 rc = DW_CFA_BITMAPORICON; 5917 rc = DW_CFA_BITMAPORICON;
5924 else if(flag & DW_CFA_STRING) 5918 else if(flag & DW_CFA_STRING)
5925 rc = DW_CFA_STRING; 5919 rc = DW_CFA_STRING;
5930 else if(flag & DW_CFA_TIME) 5924 else if(flag & DW_CFA_TIME)
5931 rc = DW_CFA_TIME; 5925 rc = DW_CFA_TIME;
5932 else 5926 else
5933 rc = 0; 5927 rc = 0;
5934 DW_MUTEX_UNLOCK; 5928 DW_MUTEX_UNLOCK;
5935 #endif
5936 return rc; 5929 return rc;
5937 } 5930 }
5938 5931
5939 /* 5932 /*
5940 * Gets column type for a filesystem container column 5933 * Gets column type for a filesystem container column
5942 * handle: Handle to the container window (widget). 5935 * handle: Handle to the container window (widget).
5943 * column: Zero based column. 5936 * column: Zero based column.
5944 */ 5937 */
5945 int API dw_filesystem_get_column_type(HWND handle, int column) 5938 int API dw_filesystem_get_column_type(HWND handle, int column)
5946 { 5939 {
5947 return dw_container_get_column_type( handle, column + 1 ); 5940 return dw_container_get_column_type( handle, column + 2 );
5948 } 5941 }
5949 5942
5950 /* 5943 /*
5951 * Sets the width of a column in the container. 5944 * Sets the width of a column in the container.
5952 * Parameters: 5945 * Parameters: