コード例 #1
0
ファイル: table-relations.c プロジェクト: arthurnn/libgda
/**
 * table_relations_new
 *
 * Returns: a new #GtkWidget
 */
GtkWidget *
table_relations_new (TableInfo *tinfo)
{
	TableRelations *trels;

	g_return_val_if_fail (IS_TABLE_INFO (tinfo), NULL);

	trels = TABLE_RELATIONS (g_object_new (TABLE_RELATIONS_TYPE, NULL));

	trels->priv->tinfo = tinfo;
	trels->priv->tcnc = g_object_ref (table_info_get_connection (tinfo));
	g_signal_connect (trels->priv->tcnc, "meta-changed",
			  G_CALLBACK (meta_changed_cb), trels);
	
	/*
	 * Relations
	 */
	trels->priv->canvas = browser_canvas_db_relations_new (NULL);
	gtk_box_pack_start (GTK_BOX (trels), trels->priv->canvas, TRUE, TRUE, 0);
	gtk_widget_show (GTK_WIDGET (trels));

	/*
	 * initial update
	 */
	GdaMetaStruct *mstruct;
	mstruct = t_connection_get_meta_struct (trels->priv->tcnc);
	if (mstruct)
		meta_changed_cb (trels->priv->tcnc, mstruct, trels);

	return (GtkWidget*) trels;
}
コード例 #2
0
ファイル: relations-diagram.c プロジェクト: arthurnn/libgda
/**
 * relations_diagram_new
 *
 * Returns: a new #GtkWidget
 */
GtkWidget *
relations_diagram_new (TConnection *tcnc)
{
    RelationsDiagram *diagram;

    g_return_val_if_fail (T_IS_CONNECTION (tcnc), NULL);

    diagram = RELATIONS_DIAGRAM (g_object_new (RELATIONS_DIAGRAM_TYPE, NULL));

    diagram->priv->tcnc = g_object_ref (tcnc);
    g_signal_connect (diagram->priv->tcnc, "meta-changed",
                      G_CALLBACK (meta_changed_cb), diagram);
    g_signal_connect (tcnc, "favorites-changed",
                      G_CALLBACK (favorites_changed_cb), diagram);


    /* header */
    GtkWidget *hbox, *wid;
    hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
    gtk_box_pack_start (GTK_BOX (diagram), hbox, FALSE, FALSE, 0);

    GtkWidget *label;
    gchar *str;
    str = g_strdup_printf ("<b>%s</b>\n%s", _("Relations diagram"), _("Unsaved"));
    label = gdaui_bar_new (str);
    g_free (str);
    gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
    diagram->priv->header = GDAUI_BAR (label);

    wid = gdaui_bar_add_button_from_icon_name (GDAUI_BAR (label), "document-save");
    diagram->priv->save_button = wid;

    g_signal_connect (wid, "clicked",
                      G_CALLBACK (save_clicked_cb), diagram);

    gtk_widget_show_all (hbox);

    /* main contents */
    wid = browser_canvas_db_relations_new (NULL);
    diagram->priv->canvas = wid;
    gtk_box_pack_start (GTK_BOX (diagram), wid, TRUE, TRUE, 0);
    gtk_widget_show_all (wid);

    GdaMetaStruct *mstruct;
    mstruct = t_connection_get_meta_struct (diagram->priv->tcnc);
    if (mstruct)
        meta_changed_cb (diagram->priv->tcnc, mstruct, diagram);

    return (GtkWidget*) diagram;
}
コード例 #3
0
ファイル: objects-index.c プロジェクト: zzeroo/libgda
/**
 * objects_index_new:
 *
 *
 *
 * Returns:
 */
GtkWidget *
objects_index_new (TConnection *tcnc)
{
	ObjectsIndex *index;

	g_return_val_if_fail (T_IS_CONNECTION (tcnc), NULL);
	index = OBJECTS_INDEX (g_object_new (OBJECTS_INDEX_TYPE, NULL));

	index->priv->tcnc = g_object_ref (tcnc);
	g_signal_connect (index->priv->tcnc, "meta-changed",
			  G_CALLBACK (meta_changed_cb), index);

	/* header */
	GtkWidget *hbox, *wid;
	hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
	gtk_box_pack_start (GTK_BOX (index), hbox, FALSE, FALSE, 0);

	GtkWidget *label;
	gchar *str;

	str = g_strdup_printf ("<b>%s</b>", _("Tables' index"));
	label = gdaui_bar_new (str);
	g_free (str);
        gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
        gtk_widget_show (label);

	/* cloud */
	GdaMetaStruct *mstruct;
	GtkWidget *cloud;
	mstruct = t_connection_get_meta_struct (index->priv->tcnc);
	cloud = objects_cloud_new (mstruct, OBJECTS_CLOUD_TYPE_TABLE);
	objects_cloud_show_schemas (OBJECTS_CLOUD (cloud), TRUE);
	gtk_box_pack_start (GTK_BOX (index), cloud, TRUE, TRUE, 0);
	index->priv->cloud = OBJECTS_CLOUD (cloud);
	g_signal_connect (cloud, "selected",
			  G_CALLBACK (cloud_object_selected_cb), index);

	/* search entry */
	wid = gdaui_bar_add_search_entry (GDAUI_BAR (label));
	
	g_signal_connect (wid, "changed",
			  G_CALLBACK (find_changed_cb), index);

	return (GtkWidget*) index;
}
コード例 #4
0
ファイル: table-preferences.c プロジェクト: zzeroo/libgda
/**
 * table_preferences_new
 *
 * Returns: a new #GtkWidget
 */
GtkWidget *
table_preferences_new (TableInfo *tinfo)
{
	TablePreferences *tpref;

	g_return_val_if_fail (IS_TABLE_INFO (tinfo), NULL);

	tpref = TABLE_PREFERENCES (g_object_new (TABLE_PREFERENCES_TYPE, NULL));

	tpref->priv->tinfo = tinfo;
	tpref->priv->tcnc = g_object_ref (table_info_get_connection (tinfo));
	g_signal_connect (tpref->priv->tcnc, "meta-changed",
			  G_CALLBACK (meta_changed_cb), tpref);
	g_signal_connect (tpref->priv->tcnc, "table-column-pref-changed",
			  G_CALLBACK (table_column_pref_changed_cb), tpref);

	GtkWidget *grid;
	grid = gtk_grid_new ();
	gtk_box_pack_start (GTK_BOX (tpref), grid, TRUE, TRUE, 0);
	gtk_grid_set_row_spacing (GTK_GRID (grid), 6);
	gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
	gtk_container_set_border_width (GTK_CONTAINER (grid), 6);

	/* left column */
	GtkWidget *label;
	gchar *str;
	label = gtk_label_new ("");
	str = g_strdup_printf ("<b>%s:</b>", _("Table's fields"));
	gtk_label_set_markup (GTK_LABEL (label), str);
	g_free (str);
	gtk_widget_set_halign (label, GTK_ALIGN_START);
	gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);

	GtkWidget *sw, *treeview;
	sw = gtk_scrolled_window_new (NULL, NULL);
	gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
					     GTK_SHADOW_ETCHED_IN);
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
					GTK_POLICY_NEVER,
					GTK_POLICY_AUTOMATIC);
	gtk_grid_attach (GTK_GRID (grid), sw, 0, 1, 1, 1);

	tpref->priv->columns_store = gtk_list_store_new (NUM_COLUMNS,
							 G_TYPE_POINTER, G_TYPE_GTYPE,
							 G_TYPE_STRING);
	treeview = ui_make_tree_view (GTK_TREE_MODEL (tpref->priv->columns_store));
	tpref->priv->columns_treeview = GTK_TREE_VIEW (treeview);
	gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
	gtk_container_add (GTK_CONTAINER (sw), treeview);

	/* treeview's columns */
	GtkTreeViewColumn *col;
	GtkCellRenderer *cell;
	cell = gtk_cell_renderer_text_new ();
	col = gtk_tree_view_column_new ();
	gtk_tree_view_column_pack_start (col, cell, TRUE);
	gtk_tree_view_column_set_cell_data_func (col, cell,
						 (GtkTreeCellDataFunc) cell_name_data_func, NULL, NULL);
	gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), col);
	
	/* selection handling */
	GtkTreeSelection *select;
	select = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
	gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
	g_signal_connect (G_OBJECT (select), "changed",
			  G_CALLBACK (selection_changed_cb), tpref);


	/* right column */
	label = gtk_label_new ("");
	str = g_strdup_printf ("<b>%s:</b>", _("Field's display preferences"));
	gtk_label_set_markup (GTK_LABEL (label), str);
	g_free (str);
	gtk_widget_set_halign (label, GTK_ALIGN_START);
	gtk_grid_attach (GTK_GRID (grid), label, 1, 0, 1, 1);

	tpref->priv->field_props = create_column_properties (tpref);
	gtk_grid_attach (GTK_GRID (grid), tpref->priv->field_props, 1, 1, 1, 1);

	/* show all */
	gtk_widget_show_all (grid);

	/*
	 * initial update
	 */
	GdaMetaStruct *mstruct;
	mstruct = t_connection_get_meta_struct (tpref->priv->tcnc);
	if (mstruct)
		meta_changed_cb (tpref->priv->tcnc, mstruct, tpref);
	selection_changed_cb (select, tpref);

	g_signal_connect (tpref->priv->columns_store, "row-changed",
			  G_CALLBACK (columns_model_row_changed_cb), tpref);

	return (GtkWidget*) tpref;
}
コード例 #5
0
ファイル: mgr-columns.c プロジェクト: arthurnn/libgda
static GSList *
mgr_columns_update_children (GdaTreeManager *manager, GdaTreeNode *node, const GSList *children_nodes,
			     gboolean *out_error, GError **error)
{
	MgrColumns *mgr = MGR_COLUMNS (manager);
	GSList *nodes_list = NULL;
	GHashTable *ehash = NULL;

	if (out_error)
		*out_error = FALSE;

	if (children_nodes)
		ehash = hash_for_existing_nodes (children_nodes);

	GdaMetaStruct *mstruct;
	mstruct = t_connection_get_meta_struct (mgr->priv->tcnc);
	if (!mstruct) {
		g_set_error (error, MGR_COLUMNS_ERROR, MGR_COLUMNS_NO_META_STRUCT,
                             "%s", _("Not ready"));
                if (out_error)
                        *out_error = TRUE;
		return NULL;
	}

	GdaMetaDbObject *dbo;
	GValue *schema_v = NULL, *name_v;
	if (mgr->priv->schema)
		g_value_set_string ((schema_v = gda_value_new (G_TYPE_STRING)), mgr->priv->schema);
	g_value_set_string ((name_v = gda_value_new (G_TYPE_STRING)), mgr->priv->table_name);
	dbo = gda_meta_struct_get_db_object (mstruct, NULL, schema_v, name_v);
	if (schema_v)
		gda_value_free (schema_v);
	gda_value_free (name_v);

	if (!dbo) {
		g_set_error (error, MGR_COLUMNS_ERROR, MGR_COLUMNS_TABLE_NOT_FOUND,
                             "%s", _("Table not found"));
                if (out_error)
                        *out_error = TRUE;
		return NULL;
	}
	if ((dbo->obj_type != GDA_META_DB_TABLE) && (dbo->obj_type != GDA_META_DB_VIEW)) {
		g_set_error (error, MGR_COLUMNS_ERROR, MGR_COLUMNS_WRONG_OBJ_TYPE,
                             "%s", _("Requested object is not a table or view"));
                if (out_error)
                        *out_error = TRUE;
		return NULL;
	}
	
	GdaMetaTable *dbotable;
	GSList *columns;
	gint index;
	dbotable = GDA_META_TABLE (dbo);
	
	for (columns = dbotable->columns, index = 0;
	     columns;
	     columns = columns->next, index ++) {
		GdaMetaTableColumn *col;
		col = GDA_META_TABLE_COLUMN (columns->data);
		GdaTreeNode* snode = NULL;
		GValue *av;

		if (ehash)
			snode = g_hash_table_lookup (ehash, col->column_name);
		if (snode) {
			/* use the same node */
			g_object_ref (G_OBJECT (snode));
		}
		else {
			/* column's name */
			snode = gda_tree_manager_create_node (manager, node, NULL);
			if (col->pkey)
				g_value_take_string ((av = gda_value_new (G_TYPE_STRING)),
						     g_strdup_printf ("<b>%s</b>", col->column_name));
			else
				g_value_set_string ((av = gda_value_new (G_TYPE_STRING)), col->column_name);
			gda_tree_node_set_node_attribute (snode, MGR_COLUMNS_COL_NAME_ATT_NAME, av, NULL);
			gda_value_free (av);
		}
			
		/* column's type */
		g_value_set_string ((av = gda_value_new (G_TYPE_STRING)), col->column_type);
		gda_tree_node_set_node_attribute (snode, MGR_COLUMNS_COL_TYPE_ATT_NAME, av, NULL);
		gda_value_free (av);
		
		/* NOT NULL */
		g_value_set_boolean ((av = gda_value_new (G_TYPE_BOOLEAN)), !col->nullok);
		gda_tree_node_set_node_attribute (snode, MGR_COLUMNS_COL_NOTNULL_ATT_NAME, av, NULL);
		gda_value_free (av);
		
		/* default value */
		g_value_set_string ((av = gda_value_new (G_TYPE_STRING)), col->default_value);
		gda_tree_node_set_node_attribute (snode, MGR_COLUMNS_COL_DEFAULT_ATT_NAME, av, NULL);
		gda_value_free (av);
		
		/* icon */
		UiIconType type = UI_ICON_COLUMN;
		GdkPixbuf *pixbuf;
		gboolean is_fk = column_is_fk_part (dbo, index);
		if (col->pkey)
			type = UI_ICON_COLUMN_PK;
		else if (!col->nullok) {
			if (is_fk)
				type = UI_ICON_COLUMN_FK_NN;
			else
				type = UI_ICON_COLUMN_NN;
		}
		else if (is_fk)
			type = UI_ICON_COLUMN_FK;
		
		pixbuf = ui_get_pixbuf_icon (type);
		av = gda_value_new (G_TYPE_OBJECT);
		g_value_set_object (av, pixbuf);
		gda_tree_node_set_node_attribute (snode, "icon", av, NULL);
		gda_value_free (av);

		/* details */
		GString *details = NULL;
		if (col->pkey)
			details = g_string_new (_("Primary key"));
		if (is_fk) {
			if (details)
				g_string_append (details, ", ");
			else
				details = g_string_new ("");
			g_string_append (details, _("Foreign key"));
		}
		const GValue *autoinc;
		autoinc = gda_meta_table_column_get_attribute (col, GDA_ATTRIBUTE_AUTO_INCREMENT);
		if (autoinc) {
			if (details)
				g_string_append (details, ", ");
			else
				details = g_string_new ("");
			g_string_append (details, _("Auto incremented"));
		}
		if (details) {
			g_value_set_string ((av = gda_value_new (G_TYPE_STRING)), details->str);
			gda_tree_node_set_node_attribute (snode, MGR_COLUMNS_COL_DETAILS, av, NULL);
			gda_value_free (av);
			g_string_free (details, TRUE);
		}

		nodes_list = g_slist_prepend (nodes_list, snode);		
	}

	if (ehash)
		g_hash_table_destroy (ehash);

	return g_slist_reverse (nodes_list);
}