/** add a new spot to bandmap data
* \param call the call to add
* \param freq on which frequency heard
* \param node reporting node
*/
void bandmap_addspot( char *call, unsigned int freq, char node) {
/* - if a spot on that band and mode is already in list replace old entry
* with new one and set timeout to SPOT_NEW,
* otherwise add it to the list as new
* - if other call on same frequency (with some TOLERANCE) replace it and set
* timeout to SPOT_NEW
* - all frequencies from cluster are rounded to 100 Hz,
* remember all other frequencies exactly
* but display only rounded to 100 Hz - sort exact
*/
GList *found;
int band;
char mode;
/* add only HF spots */
if (freq > 30000000)
return;
band = freq2band(freq);
if (band < 0) /* no ham band */
return;
mode = freq2mode(freq, band);
/* acquire bandmap mutex */
pthread_mutex_lock( &bm_mutex );
/* look if call is already on list in that mode and band */
/* each call is allowed in every combination of band and mode
* but only once */
found = g_list_find_custom(allspots, call, (GCompareFunc)cmp_call);
while (found != NULL) {
/* if same band and mode -> found spot already in list */
if (((spot *)found->data)->band == band &&
((spot *)found->data)->mode == mode)
break;
found = g_list_find_custom(found->next, call, (GCompareFunc)cmp_call);
}
/* if already in list on that band and mode
* -> set timeout to SPOT_NEW, and set new freq and reporting node
* if freq has changed enough sort list anew by freq
*/
if (found) {
((spot*)found->data)->timeout = SPOT_NEW;
((spot*)found->data)->node = node;
if (abs(((spot*)found->data)->freq - freq) > TOLERANCE) {
((spot*)found->data)->freq = freq;
allspots = g_list_sort(allspots, (GCompareFunc)cmp_freq);
}
}
else {
/* if not in list already -> prepare new entry and
* insert in list at correct freq */
spot *entry = g_new(spot, 1);
entry -> call = g_strdup(call);
entry -> freq = freq;
entry -> mode = mode;
entry -> band = band;
entry -> node = node;
entry -> timeout = SPOT_NEW;
allspots = g_list_insert_sorted( allspots, entry, (GCompareFunc)cmp_freq);
/* lookup where it is */
found = g_list_find(allspots, entry);
}
/* check that spot is unique on freq +/- TOLERANCE Hz,
* drop other entries if needed */
if (found->prev &&
(abs(((spot*)(found->prev)->data)->freq - freq) < TOLERANCE)) {
spot *olddata;
olddata = found->prev->data;
allspots = g_list_remove_link(allspots, found->prev);
g_free (olddata->call);
g_free (olddata);
}
if (found->next &&
(abs(((spot*)(found->next)->data)->freq - freq) < TOLERANCE)) {
spot *olddata;
olddata = found->next->data;
allspots = g_list_remove_link(allspots, found->next);
g_free (olddata->call);
g_free (olddata);
}
pthread_mutex_unlock( &bm_mutex );
}
static int judge_forwards(struct gspan *gs, GList *right_most_path, GList *projection,
GHashTable *pm_forwards, int min_label)
{
int rmp0;
struct history *h;
GList *l1, *l2, *l3, *l4, *values = NULL;
rmp0 = GPOINTER_TO_INT(g_list_nth_data(right_most_path, 0));
for(l1 = g_list_first(projection); l1; l1 = g_list_next(l1)) {
struct pre_dfs *p = (struct pre_dfs *)l1->data;
struct node *last_node;
struct edge *last_edge;
h = alloc_history();
build_history(h,p);
last_edge = g_list_nth_data(h->edges, rmp0);
last_node = graph_get_node(gs->min_graph, last_edge->to);
for (l2 = g_list_first(last_node->edges); l2;
l2 = g_list_next(l2)) {
struct edge *e = (struct edge *)l2->data;
struct node *to_node;
struct dfs_code *dfsc;
struct pre_dfs *npdfs;
int to_id;
to_node = graph_get_node(gs->min_graph, e->to);
if (g_list_find(h->has_nodes,
GINT_TO_POINTER(e->to)) ||
to_node->label < min_label) {
#ifdef DEBUG
printf("here1\n");
#endif
continue;
}
to_id = ((struct dfs_code *)g_list_nth_data(
gs->min_dfs_codes, rmp0))->to;
dfsc = malloc(sizeof(struct dfs_code));
if (!dfsc) {
perror("malloc dfsc in jf()");
exit(1);
}
dfsc->from = to_id;
dfsc->to = to_id + 1;
dfsc->from_label = last_node->label;
dfsc->edge_label = e->label;
dfsc->to_label = to_node->label;
npdfs = malloc(sizeof(struct pre_dfs));
if (!npdfs) {
perror("malloc npdfs in jf()");
exit(1);
}
npdfs->id = 0;
npdfs->edge = e;
npdfs->prev = p;
if (g_hash_table_contains(pm_forwards, dfsc))
values = g_hash_table_lookup(
pm_forwards,dfsc);
values = g_list_append(values, npdfs);
g_hash_table_insert(pm_forwards, dfsc, values);
values = NULL;
}
free_history(h);
}
if (g_hash_table_size(pm_forwards) == 0) {
for(l1 = g_list_first(right_most_path); l1;
l1 = g_list_next(l1)) {
int rmp = GPOINTER_TO_INT(l1->data);
for (l2=g_list_first(projection); l2; l2 = g_list_next(l2)) {
struct pre_dfs *p = (struct pre_dfs *)l2->data;
struct edge *cur_edge;
struct node *cur_node;
struct node *cur_to;
h = alloc_history();
build_history(h, p);
cur_edge = g_list_nth_data(h->edges, rmp);
cur_node = graph_get_node(gs->min_graph,
cur_edge->from);
cur_to = graph_get_node(gs->min_graph,
cur_edge->to);
for (l3 = g_list_first(cur_node->edges); l3;
l3 = g_list_next(l3)) {
struct edge *e = (struct edge *)l3->data;
struct node *to_node;
to_node = graph_get_node(gs->min_graph, e->to);
if (cur_edge->to == to_node->id ||
g_list_find(h->has_nodes,
GINT_TO_POINTER(to_node->id)) ||
to_node->label < min_label) {
#ifdef DEBUG
printf("here2\n");
#endif
continue;
}
if (cur_edge->label < e->label ||
(cur_edge->label == e->label &&
cur_to->label <= to_node->label)) {
int from_id, to_id;
struct dfs_code *dfsc;
struct pre_dfs *npdfs;
from_id = ((struct dfs_code *)g_list_nth_data(
gs->min_dfs_codes, rmp))->from;
to_id = ((struct dfs_code *)g_list_nth_data(
gs->min_dfs_codes, rmp0))->to;
dfsc = malloc(sizeof(struct dfs_code));
if (!dfsc) {
perror("malloc dfsc in jf()");
exit(1);
}
dfsc->from = from_id;
dfsc->to = to_id + 1;
dfsc->from_label = cur_node->label;
dfsc->edge_label = e->label;
dfsc->to_label = to_node->label;
npdfs = malloc(sizeof(struct pre_dfs));
if (!npdfs) {
perror("malloc npdfs in jf()");
exit(1);
}
npdfs->id = 0;
npdfs->edge = e;
npdfs->prev = p;
if (g_hash_table_contains(pm_forwards, dfsc))
values = g_hash_table_lookup(
pm_forwards,dfsc);
values = g_list_append(values, npdfs);
g_hash_table_insert(pm_forwards, dfsc, values);
values = NULL;
}
}
free_history(h);
}
if (g_hash_table_size(pm_forwards) > 0)
break;
}
}
if (g_hash_table_size(pm_forwards) > 0)
return 1;
return 0;
}
void
ags_midi_set_property(GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *param_spec)
{
AgsMidi *midi;
pthread_mutex_t *midi_mutex;
midi = AGS_MIDI(gobject);
/* get midi mutex */
pthread_mutex_lock(ags_midi_get_class_mutex());
midi_mutex = midi->obj_mutex;
pthread_mutex_unlock(ags_midi_get_class_mutex());
switch(prop_id){
case PROP_AUDIO:
{
AgsAudio *audio;
audio = (AgsAudio *) g_value_get_object(value);
pthread_mutex_lock(midi_mutex);
if(midi->audio == (GObject *) audio){
pthread_mutex_unlock(midi_mutex);
return;
}
if(midi->audio != NULL){
g_object_unref(midi->audio);
}
if(audio != NULL){
g_object_ref(audio);
}
midi->audio = (GObject *) audio;
pthread_mutex_unlock(midi_mutex);
}
break;
case PROP_AUDIO_CHANNEL:
{
guint audio_channel;
audio_channel = g_value_get_uint(value);
pthread_mutex_lock(midi_mutex);
midi->audio_channel = audio_channel;
pthread_mutex_unlock(midi_mutex);
}
break;
case PROP_TIMESTAMP:
{
AgsTimestamp *timestamp;
timestamp = (AgsTimestamp *) g_value_get_object(value);
pthread_mutex_lock(midi_mutex);
if(timestamp == (AgsTimestamp *) midi->timestamp){
pthread_mutex_unlock(midi_mutex);
return;
}
if(midi->timestamp != NULL){
g_object_unref(G_OBJECT(midi->timestamp));
}
if(timestamp != NULL){
g_object_ref(G_OBJECT(timestamp));
}
midi->timestamp = timestamp;
pthread_mutex_unlock(midi_mutex);
}
break;
case PROP_TRACK:
{
AgsTrack *track;
track = (AgsTrack *) g_value_get_pointer(value);
pthread_mutex_lock(midi_mutex);
if(track == NULL ||
g_list_find(midi->track, track) != NULL){
pthread_mutex_unlock(midi_mutex);
return;
}
pthread_mutex_unlock(midi_mutex);
ags_midi_add_track(midi,
track,
FALSE);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec);
break;
}
}
static GList *
guillotine (gint32 image_ID,
gboolean interactive)
{
GList *images = NULL;
gint guide;
gint image_width;
gint image_height;
gboolean guides_found = FALSE;
GList *hguides, *hg;
GList *vguides, *vg;
image_width = gimp_image_width (image_ID);
image_height = gimp_image_height (image_ID);
hguides = g_list_append (NULL, GINT_TO_POINTER (0));
hguides = g_list_append (hguides, GINT_TO_POINTER (image_height));
vguides = g_list_append (NULL, GINT_TO_POINTER (0));
vguides = g_list_append (vguides, GINT_TO_POINTER (image_width));
for (guide = gimp_image_find_next_guide (image_ID, 0);
guide > 0;
guide = gimp_image_find_next_guide (image_ID, guide))
{
gint position = gimp_image_get_guide_position (image_ID, guide);
switch (gimp_image_get_guide_orientation (image_ID, guide))
{
case GIMP_ORIENTATION_HORIZONTAL:
if (! g_list_find (hguides, GINT_TO_POINTER (position)))
{
hguides = g_list_insert_sorted (hguides,
GINT_TO_POINTER (position),
guide_sort_func);
guides_found = TRUE;
}
break;
case GIMP_ORIENTATION_VERTICAL:
if (! g_list_find (vguides, GINT_TO_POINTER (position)))
{
vguides = g_list_insert_sorted (vguides,
GINT_TO_POINTER (position),
guide_sort_func);
guides_found = TRUE;
}
break;
case GIMP_ORIENTATION_UNKNOWN:
g_assert_not_reached ();
break;
}
}
if (guides_found)
{
gchar *filename;
gint h, v, hpad, vpad;
gint x, y;
gchar *hformat;
gchar *format;
filename = gimp_image_get_filename (image_ID);
if (! filename)
filename = g_strdup (_("Untitled"));
/* get the number horizontal and vertical slices */
h = g_list_length (hguides);
v = g_list_length (vguides);
/* need the number of digits of h and v for the padding */
hpad = log10(h) + 1;
vpad = log10(v) + 1;
/* format for the x-y coordinates in the filename */
hformat = g_strdup_printf ("%%0%i", MAX (hpad, vpad));
format = g_strdup_printf ("-%si-%si", hformat, hformat);
/* Do the actual dup'ing and cropping... this isn't a too naive a
* way to do this since we got copy-on-write tiles, either.
*/
for (y = 0, hg = hguides; hg && hg->next; y++, hg = hg->next)
{
for (x = 0, vg = vguides; vg && vg->next; x++, vg = vg->next)
{
gint32 new_image = gimp_image_duplicate (image_ID);
GString *new_filename;
gchar *fileextension;
gchar *fileindex;
gint pos;
if (new_image == -1)
{
g_warning ("Couldn't create new image.");
g_free (hformat);
g_free (format);
return images;
}
gimp_image_undo_disable (new_image);
gimp_image_crop (new_image,
GPOINTER_TO_INT (vg->next->data) -
GPOINTER_TO_INT (vg->data),
GPOINTER_TO_INT (hg->next->data) -
GPOINTER_TO_INT (hg->data),
GPOINTER_TO_INT (vg->data),
GPOINTER_TO_INT (hg->data));
new_filename = g_string_new (filename);
/* show the rough coordinates of the image in the title */
fileindex = g_strdup_printf (format, x, y);
/* get the position of the file extension - last . in filename */
fileextension = strrchr (new_filename->str, '.');
pos = fileextension - new_filename->str;
/* insert the coordinates before the extension */
g_string_insert (new_filename, pos, fileindex);
g_free (fileindex);
gimp_image_set_filename (new_image, new_filename->str);
g_string_free (new_filename, TRUE);
while ((guide = gimp_image_find_next_guide (new_image, 0)))
gimp_image_delete_guide (new_image, guide);
gimp_image_undo_enable (new_image);
if (interactive)
gimp_display_new (new_image);
images = g_list_prepend (images, GINT_TO_POINTER (new_image));
}
}
g_free (filename);
g_free (hformat);
g_free (format);
}
g_list_free (hguides);
g_list_free (vguides);
return g_list_reverse (images);
}
void
purple_media_end(PurpleMedia *media,
const gchar *session_id, const gchar *participant)
{
#ifdef USE_VV
GList *iter, *sessions = NULL, *participants = NULL;
g_return_if_fail(PURPLE_IS_MEDIA(media));
iter = purple_media_get_streams(media, session_id, participant);
/* Free matching streams */
for (; iter; iter = g_list_delete_link(iter, iter)) {
PurpleMediaStream *stream = iter->data;
g_signal_emit(media, purple_media_signals[STATE_CHANGED],
0, PURPLE_MEDIA_STATE_END,
stream->session->id, stream->participant);
media->priv->streams =
g_list_remove(media->priv->streams, stream);
if (g_list_find(sessions, stream->session) == NULL)
sessions = g_list_prepend(sessions, stream->session);
if (g_list_find_custom(participants, stream->participant,
(GCompareFunc)strcmp) == NULL)
participants = g_list_prepend(participants,
g_strdup(stream->participant));
purple_media_stream_free(stream);
}
iter = media->priv->streams;
/* Reduce to list of sessions to remove */
for (; iter; iter = g_list_next(iter)) {
PurpleMediaStream *stream = iter->data;
sessions = g_list_remove(sessions, stream->session);
}
/* Free sessions with no streams left */
for (; sessions; sessions = g_list_delete_link(sessions, sessions)) {
PurpleMediaSession *session = sessions->data;
g_signal_emit(media, purple_media_signals[STATE_CHANGED],
0, PURPLE_MEDIA_STATE_END,
session->id, NULL);
g_hash_table_remove(media->priv->sessions, session->id);
purple_media_session_free(session);
}
iter = media->priv->streams;
/* Reduce to list of participants to remove */
for (; iter; iter = g_list_next(iter)) {
PurpleMediaStream *stream = iter->data;
GList *tmp;
tmp = g_list_find_custom(participants,
stream->participant, (GCompareFunc)strcmp);
if (tmp != NULL) {
g_free(tmp->data);
participants = g_list_delete_link(participants, tmp);
}
}
/* Remove participants with no streams left (just emit the signal) */
for (; participants; participants =
g_list_delete_link(participants, participants)) {
gchar *participant = participants->data;
GList *link = g_list_find_custom(media->priv->participants,
participant, (GCompareFunc)strcmp);
g_signal_emit(media, purple_media_signals[STATE_CHANGED],
0, PURPLE_MEDIA_STATE_END,
NULL, participant);
if (link != NULL) {
g_free(link->data);
media->priv->participants = g_list_delete_link(
media->priv->participants, link);
}
g_free(participant);
}
/* Free the conference if no sessions left */
if (media->priv->sessions != NULL &&
g_hash_table_size(media->priv->sessions) == 0) {
g_signal_emit(media, purple_media_signals[STATE_CHANGED],
0, PURPLE_MEDIA_STATE_END,
NULL, NULL);
g_object_unref(media);
return;
}
#endif
}
/* Set focus to a registered focusable actor */
void xfdashboard_focus_manager_set_focus(XfdashboardFocusManager *self, XfdashboardFocusable *inFocusable)
{
XfdashboardFocusManagerPrivate *priv;
XfdashboardFocusable *oldFocusable;
g_return_if_fail(XFDASHBOARD_IS_FOCUS_MANAGER(self));
g_return_if_fail(XFDASHBOARD_IS_FOCUSABLE(inFocusable));
priv=self->priv;
oldFocusable=NULL;
/* Check if focusable actor is really registered */
if(g_list_find(priv->registeredFocusables, inFocusable)==NULL)
{
g_warning(_("Trying to focus an unregistered focusable actor"));
return;
}
/* Check if new focusable actor can be focussed. If it cannot be focussed
* move focus to next focusable actor. If no focusable actor can be found
* do not change focus at all.
*/
if(!xfdashboard_focusable_can_focus(inFocusable))
{
XfdashboardFocusable *newFocusable;
newFocusable=xfdashboard_focus_manager_get_next_focusable(self, inFocusable);
if(!newFocusable)
{
g_debug("Requested focusable actor '%s' cannot be focus but no other focusable actor was found",
G_OBJECT_TYPE_NAME(inFocusable));
return;
}
g_debug("Requested focusable actor '%s' cannot be focused - moving focus to '%s'",
G_OBJECT_TYPE_NAME(inFocusable),
newFocusable ? G_OBJECT_TYPE_NAME(newFocusable) : "<nothing>");
inFocusable=newFocusable;
}
/* Do nothing if current focused actor and new one are the same */
oldFocusable=priv->currentFocus;
if(oldFocusable==inFocusable)
{
g_debug("Current focused actor and new one are the same so do nothing.");
return;
}
/* Unset focus at current focused actor */
if(priv->currentFocus)
{
xfdashboard_focusable_unset_focus(priv->currentFocus);
priv->currentFocus=NULL;
}
/* Set focus to new focusable actor */
priv->currentFocus=inFocusable;
xfdashboard_focusable_set_focus(priv->currentFocus);
g_debug("Moved focus from '%s' to '%s'",
oldFocusable ? G_OBJECT_TYPE_NAME(oldFocusable) : "<nothing>",
G_OBJECT_TYPE_NAME(priv->currentFocus));
/* Emit signal for changed focus */
g_signal_emit(self, XfdashboardFocusManagerSignals[SIGNAL_CHANGED], 0, oldFocusable, priv->currentFocus);
}
static void
remove_notebook (GeditMultiNotebook *mnb,
GtkWidget *notebook)
{
GtkWidget *parent;
GtkWidget *grandpa;
GList *children;
GtkWidget *new_notebook;
GList *current;
if (mnb->priv->notebooks->next == NULL)
{
g_warning ("You are trying to remove the main notebook");
return;
}
current = g_list_find (mnb->priv->notebooks,
notebook);
if (current->next != NULL)
{
new_notebook = GTK_WIDGET (current->next->data);
}
else
{
new_notebook = GTK_WIDGET (mnb->priv->notebooks->data);
}
parent = gtk_widget_get_parent (notebook);
/* Now we destroy the widget, we get the children of parent and we destroy
parent too as the parent is an useless paned. Finally we add the child
into the grand parent */
g_object_ref (notebook);
mnb->priv->removing_notebook = TRUE;
gtk_widget_destroy (notebook);
mnb->priv->notebooks = g_list_remove (mnb->priv->notebooks,
notebook);
mnb->priv->removing_notebook = FALSE;
children = gtk_container_get_children (GTK_CONTAINER (parent));
if (children->next != NULL)
{
g_warning ("The parent is not a paned");
return;
}
grandpa = gtk_widget_get_parent (parent);
g_object_ref (children->data);
gtk_container_remove (GTK_CONTAINER (parent),
GTK_WIDGET (children->data));
gtk_widget_destroy (parent);
gtk_container_add (GTK_CONTAINER (grandpa),
GTK_WIDGET (children->data));
g_object_unref (children->data);
g_list_free (children);
disconnect_notebook_signals (mnb, notebook);
g_signal_emit (G_OBJECT (mnb), signals[NOTEBOOK_REMOVED], 0, notebook);
g_object_unref (notebook);
/* Let's make the active notebook grab the focus */
gtk_widget_grab_focus (new_notebook);
}
bool WebPopupMenuProxyGtk::typeAheadFind(GdkEventKey* event)
{
// If we were given a non-printable character just skip it.
gunichar unicodeCharacter = gdk_keyval_to_unicode(event->keyval);
if (!g_unichar_isprint(unicodeCharacter)) {
resetTypeAheadFindState();
return false;
}
glong charactersWritten;
GUniquePtr<gunichar2> utf16String(g_ucs4_to_utf16(&unicodeCharacter, 1, nullptr, &charactersWritten, nullptr));
if (!utf16String) {
resetTypeAheadFindState();
return false;
}
// If the character is the same as the last character, the user is probably trying to
// cycle through the menulist entries. This matches the WebCore behavior for collapsed menulists.
static const uint32_t searchTimeoutMs = 1000;
bool repeatingCharacter = unicodeCharacter != m_previousKeyEventCharacter;
if (event->time - m_previousKeyEventTimestamp > searchTimeoutMs)
m_currentSearchString = String(reinterpret_cast<UChar*>(utf16String.get()), charactersWritten);
else if (repeatingCharacter)
m_currentSearchString.append(String(reinterpret_cast<UChar*>(utf16String.get()), charactersWritten));
m_previousKeyEventTimestamp = event->time;
m_previousKeyEventCharacter = unicodeCharacter;
GUniquePtr<GList> children(gtk_container_get_children(GTK_CONTAINER(m_popup)));
if (!children)
return true;
// We case fold before searching, because strncmp does not handle non-ASCII characters.
GUniquePtr<gchar> searchStringWithCaseFolded(g_utf8_casefold(m_currentSearchString.utf8().data(), -1));
size_t prefixLength = strlen(searchStringWithCaseFolded.get());
// If a menu item has already been selected, start searching from the current
// item down the list. This will make multiple key presses of the same character
// advance the selection.
GList* currentChild = children.get();
if (m_currentlySelectedMenuItem) {
currentChild = g_list_find(children.get(), m_currentlySelectedMenuItem);
if (!currentChild) {
m_currentlySelectedMenuItem = nullptr;
currentChild = children.get();
}
// Repeating characters should iterate.
if (repeatingCharacter) {
if (GList* nextChild = g_list_next(currentChild))
currentChild = nextChild;
}
}
GList* firstChild = currentChild;
do {
currentChild = g_list_next(currentChild);
if (!currentChild)
currentChild = children.get();
GUniquePtr<gchar> itemText(g_utf8_casefold(gtk_menu_item_get_label(GTK_MENU_ITEM(currentChild->data)), -1));
if (!strncmp(searchStringWithCaseFolded.get(), itemText.get(), prefixLength)) {
gtk_menu_shell_select_item(GTK_MENU_SHELL(m_popup), GTK_WIDGET(currentChild->data));
break;
}
} while (currentChild != firstChild);
return true;
}
void
layers_actions_update (GimpActionGroup *group,
gpointer data)
{
GimpImage *image = action_data_get_image (data);
GimpLayer *layer = NULL;
GimpLayerMask *mask = NULL; /* layer mask */
gboolean fs = FALSE; /* floating sel */
gboolean ac = FALSE; /* active channel */
gboolean sel = FALSE;
gboolean alpha = FALSE; /* alpha channel present */
gboolean indexed = FALSE; /* is indexed */
gboolean lock_alpha = FALSE;
gboolean can_lock_alpha = FALSE;
gboolean text_layer = FALSE;
gboolean writable = FALSE;
gboolean children = FALSE;
GList *next = NULL;
GList *next_visible = NULL;
GList *prev = NULL;
if (image)
{
fs = (gimp_image_get_floating_selection (image) != NULL);
ac = (gimp_image_get_active_channel (image) != NULL);
sel = ! gimp_channel_is_empty (gimp_image_get_mask (image));
indexed = (gimp_image_base_type (image) == GIMP_INDEXED);
layer = gimp_image_get_active_layer (image);
if (layer)
{
GList *layer_list;
GList *list;
mask = gimp_layer_get_mask (layer);
lock_alpha = gimp_layer_get_lock_alpha (layer);
can_lock_alpha = gimp_layer_can_lock_alpha (layer);
alpha = gimp_drawable_has_alpha (GIMP_DRAWABLE (layer));
writable = ! gimp_item_is_content_locked (GIMP_ITEM (layer));
if (gimp_viewable_get_children (GIMP_VIEWABLE (layer)))
children = TRUE;
layer_list = gimp_item_get_container_iter (GIMP_ITEM (layer));
list = g_list_find (layer_list, layer);
if (list)
{
prev = g_list_previous (list);
next = g_list_next (list);
for (next_visible = next;
next_visible;
next_visible = g_list_next (next_visible))
{
if (gimp_item_get_visible (next_visible->data))
{
/* "next_visible" is actually "next_visible" and
* "writable" and "not group"
*/
if (gimp_item_is_content_locked (next_visible->data) ||
gimp_viewable_get_children (next_visible->data))
next_visible = NULL;
break;
}
}
}
text_layer = gimp_item_is_text_layer (GIMP_ITEM (layer));
}
}
#define SET_VISIBLE(action,condition) \
gimp_action_group_set_action_visible (group, action, (condition) != 0)
#define SET_SENSITIVE(action,condition) \
gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
#define SET_ACTIVE(action,condition) \
gimp_action_group_set_action_active (group, action, (condition) != 0)
#define SET_LABEL(action,label) \
gimp_action_group_set_action_label (group, action, label)
SET_VISIBLE ("layers-text-tool", text_layer && !ac);
SET_SENSITIVE ("layers-edit-attributes", layer && !fs && !ac);
if (layer && gimp_layer_is_floating_sel (layer))
{
SET_LABEL ("layers-new", C_("layers-action", "To _New Layer"));
SET_LABEL ("layers-new-last-values", C_("layers-action", "To _New Layer"));
}
else
{
SET_LABEL ("layers-new", C_("layers-action", "_New Layer..."));
SET_LABEL ("layers-new-last-values", C_("layers-action", "_New Layer"));
}
SET_SENSITIVE ("layers-new", image);
SET_SENSITIVE ("layers-new-last-values", image);
SET_SENSITIVE ("layers-new-from-visible", image);
SET_SENSITIVE ("layers-new-group", image && !indexed);
SET_SENSITIVE ("layers-duplicate", layer && !fs && !ac);
SET_SENSITIVE ("layers-delete", layer && !ac);
SET_SENSITIVE ("layers-select-top", layer && !fs && !ac && prev);
SET_SENSITIVE ("layers-select-bottom", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-select-previous", layer && !fs && !ac && prev);
SET_SENSITIVE ("layers-select-next", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-raise", layer && !fs && !ac && prev);
SET_SENSITIVE ("layers-raise-to-top", layer && !fs && !ac && prev);
SET_SENSITIVE ("layers-lower", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-lower-to-bottom", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-anchor", layer && fs && !ac);
SET_SENSITIVE ("layers-merge-down", layer && !fs && !ac && next_visible);
SET_VISIBLE ("layers-merge-group", children);
SET_SENSITIVE ("layers-merge-group", layer && !fs && !ac && children);
SET_SENSITIVE ("layers-merge-layers", layer && !fs && !ac);
SET_SENSITIVE ("layers-flatten-image", layer && !fs && !ac);
SET_VISIBLE ("layers-text-discard", text_layer && !ac);
SET_VISIBLE ("layers-text-to-vectors", text_layer && !ac);
SET_VISIBLE ("layers-text-along-vectors", text_layer && !ac);
SET_SENSITIVE ("layers-resize", writable && !ac);
SET_SENSITIVE ("layers-resize-to-image", writable && !ac);
SET_SENSITIVE ("layers-scale", writable && !ac);
SET_SENSITIVE ("layers-crop", writable && sel);
SET_SENSITIVE ("layers-alpha-add", writable && !children && !fs && !alpha);
SET_SENSITIVE ("layers-alpha-remove", writable && !children && !fs && alpha);
SET_SENSITIVE ("layers-lock-alpha", can_lock_alpha);
SET_ACTIVE ("layers-lock-alpha", lock_alpha);
SET_SENSITIVE ("layers-mask-add", layer && !fs && !ac && !mask && !children);
SET_SENSITIVE ("layers-mask-apply", writable && !fs && !ac && mask && !children);
SET_SENSITIVE ("layers-mask-delete", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-edit", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-show", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-disable", layer && !fs && !ac && mask);
SET_ACTIVE ("layers-mask-edit", mask && gimp_layer_mask_get_edit (mask));
SET_ACTIVE ("layers-mask-show", mask && gimp_layer_mask_get_show (mask));
SET_ACTIVE ("layers-mask-disable", mask && !gimp_layer_mask_get_apply (mask));
SET_SENSITIVE ("layers-mask-selection-replace", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-selection-add", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-selection-subtract", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-selection-intersect", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-alpha-selection-replace", layer && !fs && !ac);
SET_SENSITIVE ("layers-alpha-selection-add", layer && !fs && !ac);
SET_SENSITIVE ("layers-alpha-selection-subtract", layer && !fs && !ac);
SET_SENSITIVE ("layers-alpha-selection-intersect", layer && !fs && !ac);
#undef SET_VISIBLE
#undef SET_SENSITIVE
#undef SET_ACTIVE
#undef SET_LABEL
}
/*! \brief add a line object to the tiles
* \par Function Description
* This function takes a single line object and adds it to
* every tile that is touched by the line.
* It also adds all tiles that are touched by the object to
* the objects tile list.
* \param toplevel The TOPLEVEL structure
* \param object The line OBJECT to add
*/
static void s_tile_add_line_object (TOPLEVEL *toplevel, OBJECT *object)
{
TILE *t_current;
PAGE *p_current;
GList *found;
int i, j;
int v, w;
double x1, y1, x2, y2;
double bottom;
double m, b;
double x_size, y_size;
double x, y;
int start, end;
#if DEBUG
printf("name: %s\n", object->name);
#endif
g_return_if_fail (object != NULL);
g_return_if_fail (object->line != NULL);
p_current = o_get_page (toplevel, object);
if (p_current == NULL) {
return;
}
x_size = (double) toplevel->init_right / (double) MAX_TILES_X;
y_size = (double) toplevel->init_bottom / (double) MAX_TILES_Y;
x1 = (int) (object->line->x[0] / x_size);
x2 = (int) (object->line->x[1] / x_size);
y1 = (int) (object->line->y[0] / y_size);
y2 = (int) (object->line->y[1] / y_size);
bottom = x2 - x1;
if (bottom != 0.0) {
m = (double) (y2 - y1) / bottom;
b = y1 - m * x1;
start = min((int) x1, (int) x2);
end = max((int) x1, (int) x2);
for (i = start; i <= end; i++) {
x = i;
y = m * x + b;
if (floor(y) != ceil(y)) {
v = (int) x;
w = (int) floor(y);
if (v < 0 || w < 0 || v > MAX_TILES_X-1 || w > MAX_TILES_Y-1) {
return;
}
/* g_assert(v < MAX_TILES_X && w < MAX_TILES_Y && v >= 0 && w >= 0); */
t_current = &p_current->world_tiles[v][w];
found = g_list_find(t_current->objects, object);
if (!found) {
/*printf("%d %d\n", v, w);*/
t_current->objects = g_list_append(t_current->objects,
object);
object->tiles = g_list_append(object->tiles, t_current);
}
v = (int) x;
w = (int) ceil(y);
if (v < 0 || w < 0 || v > MAX_TILES_X-1 || w > MAX_TILES_Y-1) {
return;
}
/*g_assert(v < MAX_TILES_X && w < MAX_TILES_Y && v >= 0 && w >= 0);*/
t_current = &p_current->world_tiles[v][w];
found = g_list_find(t_current->objects, object);
if (!found) {
/*printf("%d %d\n", v, w);*/
t_current->objects = g_list_append(t_current->objects,
object);
object->tiles = g_list_append(object->tiles, t_current);
}
} else {
v = (int) x;
w = (int) floor(y);
if (v < 0 || w < 0 || v > MAX_TILES_X-1 || w > MAX_TILES_Y-1) {
return;
}
/*g_assert(v < MAX_TILES_X && w < MAX_TILES_Y && v >= 0 && w >= 0);*/
t_current = &p_current->world_tiles[v][w];
found = g_list_find(t_current->objects, object);
if (!found) {
/*printf("%d %d\n", v, w);*/
t_current->objects = g_list_append(t_current->objects,
object);
object->tiles = g_list_append(object->tiles, t_current);
}
}
}
if (m != 0.0) {
start = min((int) y1, (int) y2);
end = max((int) y1, (int) y2);
for (j = start; j <= end; j++) {
y = j;
x = (y - b) / m;
if (floor(x) != ceil(x)) {
w = (int) y;
v = (int) floor(x);
if (v < 0 || w < 0 || v > MAX_TILES_X-1 || w > MAX_TILES_Y-1) {
return;
}
/*g_assert(v < MAX_TILES_X && w < MAX_TILES_Y &&
v >= 0 && w >= 0);*/
t_current = &p_current->world_tiles[v][w];
found = g_list_find(t_current->objects, object);
if (!found) {
/*printf("%d %d\n", v, w);*/
t_current->objects =
g_list_append(t_current->objects, object);
object->tiles = g_list_append(object->tiles, t_current);
}
w = (int) y;
v = (int) ceil(x);
if (v < 0 || w < 0 || v > MAX_TILES_X-1 || w > MAX_TILES_Y-1) {
return;
}
/* g_assert(v < MAX_TILES_X && w < MAX_TILES_Y &&
v >= 0 && w >= 0);*/
t_current = &p_current->world_tiles[v][w];
found = g_list_find(t_current->objects, object);
if (!found) {
/*printf("%d %d\n", v, w);*/
t_current->objects =
g_list_append(t_current->objects, object);
object->tiles = g_list_append(object->tiles, t_current);
}
} else {
w = (int) y;
v = (int) floor(x);
if (v < 0 || w < 0 || v > MAX_TILES_X-1 || w > MAX_TILES_Y-1) {
return;
}
/*g_assert(v < MAX_TILES_X && w < MAX_TILES_Y &&
v >= 0 && w >= 0);*/
t_current = &p_current->world_tiles[v][w];
found = g_list_find(t_current->objects, object);
if (!found) {
/*printf("%d %d\n", v, w);*/
t_current->objects =
g_list_append(t_current->objects, object);
object->tiles = g_list_append(object->tiles, t_current);
}
}
}
}
} else {
start = min((int) y1, (int) y2);
end = max((int) y1, (int) y2);
for (j = start; j <= end; j++) {
y = j;
x = x1;
v = (int) x;
w = (int) y;
if (v < 0 || w < 0 || v > MAX_TILES_X-1 || w > MAX_TILES_Y-1) {
return;
}
/*g_assert(v < MAX_TILES_X && w < MAX_TILES_Y &&
v >= 0 && w >= 0);*/
t_current = &p_current->world_tiles[v][w];
found = g_list_find(t_current->objects, object);
if (!found) {
/*printf("%d %d\n", v, w);*/
t_current->objects = g_list_append(t_current->objects,
object);
object->tiles = g_list_append(object->tiles, t_current);
}
}
}
}
GList *textbuffer_find_text(TEXT_BUFFER_REC *buffer, LINE_REC *startline,
int level, int nolevel, const char *text,
int before, int after,
int regexp, int fullword, int case_sensitive)
{
#ifdef HAVE_REGEX_H
regex_t preg;
#endif
LINE_REC *line, *pre_line;
GList *matches;
GString *str;
int i, match_after, line_matched;
char * (*match_func)(const char *, const char *);
g_return_val_if_fail(buffer != NULL, NULL);
g_return_val_if_fail(text != NULL, NULL);
if (regexp) {
#ifdef HAVE_REGEX_H
int flags = REG_EXTENDED | REG_NOSUB |
(case_sensitive ? 0 : REG_ICASE);
if (regcomp(&preg, text, flags) != 0)
return NULL;
#else
return NULL;
#endif
}
matches = NULL; match_after = 0;
str = g_string_new(NULL);
line = startline != NULL ? startline : buffer->first_line;
if (fullword)
match_func = case_sensitive ? strstr_full : stristr_full;
else
match_func = case_sensitive ? strstr : stristr;
for (; line != NULL; line = line->next) {
line_matched = (line->info.level & level) != 0 &&
(line->info.level & nolevel) == 0;
if (*text != '\0') {
textbuffer_line2text(line, FALSE, str);
if (line_matched)
line_matched =
#ifdef HAVE_REGEX_H
regexp ? regexec(&preg, str->str, 0, NULL, 0) == 0 :
#endif
match_func(str->str, text) != NULL;
}
if (line_matched) {
/* add the -before lines */
pre_line = line;
for (i = 0; i < before; i++) {
if (pre_line->prev == NULL ||
g_list_find(matches, pre_line->prev) != NULL)
break;
pre_line = pre_line->prev;
}
for (; pre_line != line; pre_line = pre_line->next)
matches = g_list_append(matches, pre_line);
match_after = after;
}
if (line_matched || match_after > 0) {
/* matched */
matches = g_list_append(matches, line);
if ((!line_matched && --match_after == 0) ||
(line_matched && match_after == 0 && before > 0))
matches = g_list_append(matches, NULL);
}
}
#ifdef HAVE_REGEX_H
if (regexp) regfree(&preg);
#endif
g_string_free(str, TRUE);
return matches;
}
static int32_t dt_camera_capture_job_run(dt_job_t *job)
{
dt_camera_capture_t *params = dt_control_job_get_params(job);
int total;
char message[512] = { 0 };
double fraction = 0;
total = params->brackets ? params->count * params->brackets : params->count;
snprintf(message, sizeof(message), ngettext("capturing %d image", "capturing %d images", total), total);
dt_control_job_set_progress_message(job, message);
/* try to get exp program mode for nikon */
char *expprogram = (char *)dt_camctl_camera_get_property(darktable.camctl, NULL, "expprogram");
/* if fail, lets try fetching mode for cannon */
if(!expprogram)
expprogram = (char *)dt_camctl_camera_get_property(darktable.camctl, NULL, "autoexposuremode");
/* Fetch all values for shutterspeed and initialize current value */
GList *values = NULL;
gconstpointer original_value = NULL;
const char *cvalue = dt_camctl_camera_get_property(darktable.camctl, NULL, "shutterspeed");
const char *value = dt_camctl_camera_property_get_first_choice(darktable.camctl, NULL, "shutterspeed");
/* get values for bracketing */
if(params->brackets && expprogram && expprogram[0] == 'M' && value && cvalue)
{
do
{
// Add value to list
values = g_list_append(values, g_strdup(value));
// Check if current values is the same as original value, then lets store item ptr
if(strcmp(value, cvalue) == 0) original_value = g_list_last(values)->data;
} while((value = dt_camctl_camera_property_get_next_choice(darktable.camctl, NULL, "shutterspeed"))
!= NULL);
}
else
{
/* if this was an intended bracket capture bail out */
if(params->brackets)
{
dt_control_log(_("please set your camera to manual mode first!"));
return 1;
}
}
GList *current_value = g_list_find(values, original_value);
for(uint32_t i = 0; i < params->count; i++)
{
// Delay if active
if(params->delay) g_usleep(params->delay * G_USEC_PER_SEC);
for(uint32_t b = 0; b < (params->brackets * 2) + 1; b++)
{
// If bracket capture, lets set change shutterspeed
if(params->brackets)
{
if(b == 0)
{
// First bracket, step down time with (steps*brackets), also check so we never set the longest
// shuttertime which would be bulb mode
for(uint32_t s = 0; s < (params->steps * params->brackets); s++)
if(g_list_next(current_value) && g_list_next(g_list_next(current_value)))
current_value = g_list_next(current_value);
}
else
{
// Step up with (steps)
for(uint32_t s = 0; s < params->steps; s++)
if(g_list_previous(current_value)) current_value = g_list_previous(current_value);
}
}
// set the time property for bracket capture
if(params->brackets && current_value)
dt_camctl_camera_set_property_string(darktable.camctl, NULL, "shutterspeed", current_value->data);
// Capture image
dt_camctl_camera_capture(darktable.camctl, NULL);
fraction += 1.0 / total;
dt_control_job_set_progress(job, fraction);
}
// lets reset to original value before continue
if(params->brackets)
{
current_value = g_list_find(values, original_value);
dt_camctl_camera_set_property_string(darktable.camctl, NULL, "shutterspeed", current_value->data);
}
}
// free values
if(values)
{
g_list_free_full(values, g_free);
}
return 0;
}
MimeView *mimeview_create(void)
{
MimeView *mimeview;
GtkWidget *paned;
GtkWidget *scrolledwin;
GtkWidget *treeview;
GtkTreeStore *store;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkWidget *mime_vbox;
GtkWidget *popupmenu;
GtkItemFactory *popupfactory;
gint n_entries;
GtkWidget *reply_separator;
GtkWidget *reply_menuitem;
GList *child;
debug_print(_("Creating MIME view...\n"));
mimeview = g_new0(MimeView, 1);
scrolledwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_SHADOW_IN);
gtk_widget_set_size_request(scrolledwin, -1, 80);
store = gtk_tree_store_new(N_COLS, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_POINTER);
treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(G_OBJECT(store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), TRUE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview), COL_NAME);
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(treeview), FALSE);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
gtk_container_add(GTK_CONTAINER(scrolledwin), treeview);
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer, "ypad", 0, NULL);
column = gtk_tree_view_column_new_with_attributes
(_("Data type"), renderer, "text", COL_MIMETYPE, NULL);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer, "xalign", 1.0, "ypad", 0, NULL);
column = gtk_tree_view_column_new_with_attributes
(_("Size"), renderer, "text", COL_SIZE, NULL);
gtk_tree_view_column_set_alignment(column, 1.0);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer, "ypad", 0, NULL);
column = gtk_tree_view_column_new_with_attributes
(_("Name"), renderer, "text", COL_NAME, NULL);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
gtk_tree_view_enable_model_drag_source
(GTK_TREE_VIEW(treeview), GDK_BUTTON1_MASK,
mimeview_mime_types, 1, GDK_ACTION_COPY);
g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(mimeview_selection_changed), mimeview);
g_signal_connect(G_OBJECT(treeview), "button_press_event",
G_CALLBACK(mimeview_button_pressed), mimeview);
g_signal_connect(G_OBJECT(treeview), "key_press_event",
G_CALLBACK(mimeview_key_pressed), mimeview);
g_signal_connect_after(G_OBJECT (treeview),"drag-begin",
G_CALLBACK (mimeview_drag_begin), mimeview);
g_signal_connect(G_OBJECT (treeview),"drag-end",
G_CALLBACK (mimeview_drag_end), mimeview);
g_signal_connect(G_OBJECT(treeview), "drag-data-get",
G_CALLBACK(mimeview_drag_data_get), mimeview);
mime_vbox = gtk_vbox_new(FALSE, 0);
gtk_container_set_reallocate_redraws(GTK_CONTAINER(mime_vbox), TRUE);
paned = gtk_vpaned_new();
gtk_paned_add1(GTK_PANED(paned), scrolledwin);
gtk_paned_add2(GTK_PANED(paned), mime_vbox);
n_entries = sizeof(mimeview_popup_entries) /
sizeof(mimeview_popup_entries[0]);
popupmenu = menu_create_items(mimeview_popup_entries, n_entries,
"<MimeView>", &popupfactory, mimeview);
reply_menuitem = gtk_item_factory_get_item(popupfactory, "/Reply");
child = g_list_find(GTK_MENU_SHELL(popupmenu)->children,
reply_menuitem);
reply_separator = GTK_WIDGET(child->prev->data);
mimeview->paned = paned;
mimeview->scrolledwin = scrolledwin;
mimeview->treeview = treeview;
mimeview->store = store;
mimeview->selection = selection;
mimeview->mime_vbox = mime_vbox;
mimeview->popupmenu = popupmenu;
mimeview->popupfactory = popupfactory;
mimeview->reply_separator = reply_separator;
mimeview->reply_menuitem = reply_menuitem;
mimeview->type = -1;
return mimeview;
}
static void
rb_grilo_source_constructed (GObject *object)
{
RBGriloSource *source;
RBShell *shell;
RBShellPlayer *shell_player;
const GList *source_keys;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkWidget *scrolled;
GtkWidget *browserbox;
GtkWidget *vbox;
GtkWidget *mainbox;
GtkAdjustment *adjustment;
RB_CHAIN_GOBJECT_METHOD (rb_grilo_source_parent_class, constructed, object);
source = RB_GRILO_SOURCE (object);
g_object_get (source, "shell", &shell, NULL);
g_object_get (shell,
"db", &source->priv->db,
"shell-player", &shell_player,
NULL);
g_object_unref (shell);
g_object_get (source, "entry-type", &source->priv->entry_type, NULL);
source->priv->entry_view = rb_entry_view_new (source->priv->db, G_OBJECT (shell_player), TRUE, FALSE);
g_object_unref (shell_player);
g_signal_connect (source->priv->entry_view,
"notify::sort-order",
G_CALLBACK (notify_sort_order_cb),
source);
source_keys = grl_source_supported_keys (source->priv->grilo_source);
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_TRACK_NUMBER))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_TRACK_NUMBER, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_TRACK_NUMBER));
}
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_TITLE))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_TITLE, TRUE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_TITLE));
}
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_GENRE))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_GENRE, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_GENRE));
}
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_ARTIST))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_ARTIST, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_ARTIST));
}
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_ALBUM))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_ALBUM, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_ALBUM));
}
/*
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_DATE))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_YEAR, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_DATE));
}
*/
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_DURATION))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_DURATION, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_DURATION));
}
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_CHILDCOUNT));
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_URL));
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_THUMBNAIL));
/* probably add an image column too? */
source->priv->browser_model = gtk_tree_store_new (4, GRL_TYPE_MEDIA, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT);
source->priv->browser_view = gtk_tree_view_new ();
gtk_tree_view_set_model (GTK_TREE_VIEW (source->priv->browser_view), GTK_TREE_MODEL (source->priv->browser_model));
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_set_title (column, _("Browse"));
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (column, renderer, "text", 1);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column (GTK_TREE_VIEW (source->priv->browser_view), column);
gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (source->priv->browser_view), TRUE);
gtk_tree_view_set_expander_column (GTK_TREE_VIEW (source->priv->browser_view), column);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (source->priv->browser_view), TRUE);
gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (source->priv->browser_view), TRUE);
g_signal_connect (source->priv->browser_view, "row-expanded", G_CALLBACK (browser_row_expanded_cb), source);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (source->priv->browser_view));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); /* should be multiple eventually */
g_signal_connect (selection, "changed", G_CALLBACK (browser_selection_changed_cb), source);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN);
adjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled));
g_signal_connect (adjustment, "changed", G_CALLBACK (scroll_adjust_changed_cb), source);
g_signal_connect (adjustment, "value-changed", G_CALLBACK (scroll_adjust_value_changed_cb), source);
browserbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
/* search bar (if the source supports searching) */
if (grl_source_supported_operations (source->priv->grilo_source) & GRL_OP_SEARCH) {
source->priv->search_entry = rb_search_entry_new (FALSE);
g_object_set (source->priv->search_entry, "explicit-mode", TRUE, NULL);
g_signal_connect (source->priv->search_entry, "search", G_CALLBACK (search_cb), source);
g_signal_connect (source->priv->search_entry, "activate", G_CALLBACK (search_cb), source);
gtk_box_pack_start (GTK_BOX (browserbox), GTK_WIDGET (source->priv->search_entry), FALSE, FALSE, 6);
}
gtk_container_add (GTK_CONTAINER (scrolled), source->priv->browser_view);
gtk_box_pack_start (GTK_BOX (browserbox), scrolled, TRUE, TRUE, 0);
mainbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (source), mainbox, TRUE, TRUE, 0);
/* info bar */
source->priv->info_bar_label = gtk_label_new ("");
source->priv->info_bar = gtk_info_bar_new ();
gtk_info_bar_set_message_type (GTK_INFO_BAR (source->priv->info_bar), GTK_MESSAGE_INFO);
gtk_info_bar_add_button (GTK_INFO_BAR (source->priv->info_bar), _("Fetch more tracks"), GTK_RESPONSE_OK);
gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (source->priv->info_bar))),
source->priv->info_bar_label);
gtk_widget_show (GTK_WIDGET (source->priv->info_bar_label));
gtk_widget_set_no_show_all (GTK_WIDGET (source->priv->info_bar), TRUE);
g_signal_connect (source->priv->info_bar, "response", G_CALLBACK (fetch_more_cb), source);
/* don't allow the browser to be hidden? */
source->priv->paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
rb_source_bind_settings (RB_SOURCE (source), GTK_WIDGET (source->priv->entry_view), source->priv->paned, NULL);
gtk_paned_pack1 (GTK_PANED (source->priv->paned), browserbox, FALSE, FALSE);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (source->priv->entry_view), TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), source->priv->info_bar, FALSE, FALSE, 0);
gtk_paned_pack2 (GTK_PANED (source->priv->paned), vbox, TRUE, FALSE);
gtk_box_pack_start (GTK_BOX (mainbox), source->priv->paned, TRUE, TRUE, 0);
gtk_widget_show_all (GTK_WIDGET (source));
}
/* Build target list of registered focusable actors for requested binding but also check
* if this focus manager is a target.
*/
static GSList* _xfdashboard_focus_manager_get_targets_for_binding(XfdashboardFocusManager *self,
const XfdashboardBinding *inBinding)
{
XfdashboardFocusManagerPrivate *priv;
GList *focusablesIter;
GList *focusablesStartPoint;
XfdashboardFocusable *focusable;
GType targetType;
GSList *targets;
gboolean mustBeFocusable;
g_return_val_if_fail(XFDASHBOARD_IS_FOCUS_MANAGER(self), NULL);
g_return_val_if_fail(XFDASHBOARD_IS_BINDING(inBinding), NULL);
priv=self->priv;
targets=NULL;
mustBeFocusable=TRUE;
/* Get type of target */
targetType=g_type_from_name(xfdashboard_binding_get_target(inBinding));
if(!targetType)
{
g_warning(_("Cannot build target list for unknown type %s"),
xfdashboard_binding_get_target(inBinding));
return(NULL);
}
/* Determine if unfocusable targets should be included */
if(xfdashboard_binding_get_flags(inBinding) & XFDASHBOARD_BINDING_FLAGS_ALLOW_UNFOCUSABLE_TARGET)
{
mustBeFocusable=FALSE;
}
/* Check if class name of target at binding points to ourselve */
if(g_type_is_a(G_OBJECT_TYPE(self), targetType))
{
targets=g_slist_append(targets, g_object_ref(self));
}
/* Iterate through list of focusable actors to add each one
* matching the target class name to the list of targets.
* Begin with finding starting point of iteration.
*/
focusablesStartPoint=g_list_find(priv->registeredFocusables, priv->currentFocus);
if(!focusablesStartPoint) focusablesStartPoint=priv->registeredFocusables;
/* Iterate through list of registered focusable actors beginning at
* found starting point of iteration (might be begin of list of registered actors)
* and add each focusable actor matching target class name to target list.
*/
for(focusablesIter=focusablesStartPoint; focusablesIter; focusablesIter=g_list_next(focusablesIter))
{
focusable=(XfdashboardFocusable*)focusablesIter->data;
/* If focusable can be focused and matches target class name
* then add it to target list.
*/
if((!mustBeFocusable || xfdashboard_focusable_can_focus(focusable)) &&
g_type_is_a(G_OBJECT_TYPE(focusable), targetType))
{
targets=g_slist_append(targets, g_object_ref(focusable));
}
}
/* We have to continue search at the beginning of list of registered actors
* up to the found starting point of iteration. Add each focusable actor matching
* target class name to target list.
*/
for(focusablesIter=priv->registeredFocusables; focusablesIter!=focusablesStartPoint; focusablesIter=g_list_next(focusablesIter))
{
focusable=(XfdashboardFocusable*)focusablesIter->data;
/* If focusable can be focused and matches target class name
* then add it to target list.
*/
if((!mustBeFocusable || xfdashboard_focusable_can_focus(focusable)) &&
g_type_is_a(G_OBJECT_TYPE(focusable), targetType))
{
targets=g_slist_append(targets, g_object_ref(focusable));
}
}
/* Return list of targets found */
g_debug("Target list for action '%s' and target class '%s' has %d entries",
xfdashboard_binding_get_action(inBinding),
xfdashboard_binding_get_target(inBinding),
g_slist_length(targets));
return(targets);
}
void
gnc_split_register_load (SplitRegister *reg, GList * slist,
Account *default_account)
{
SRInfo *info;
Transaction *pending_trans;
CursorBuffer *cursor_buffer;
GHashTable *trans_table = NULL;
CellBlock *cursor_header;
CellBlock *lead_cursor;
CellBlock *split_cursor;
Transaction *blank_trans;
Transaction *find_trans;
Transaction *trans;
CursorClass find_class;
Split *find_trans_split;
Split *blank_split;
Split *find_split;
Split *split;
Table *table;
GList *node;
gboolean start_primary_color = TRUE;
gboolean found_pending = FALSE;
gboolean need_divider_upper = FALSE;
gboolean found_divider_upper = FALSE;
gboolean found_divider = FALSE;
gboolean has_last_num = FALSE;
gboolean multi_line;
gboolean dynamic;
gboolean we_own_slist = FALSE;
gboolean use_autoreadonly = qof_book_uses_autoreadonly(gnc_get_current_book());
VirtualCellLocation vcell_loc;
VirtualLocation save_loc;
int new_trans_split_row = -1;
int new_trans_row = -1;
int new_split_row = -1;
time64 present, autoreadonly_time = 0;
g_return_if_fail(reg);
table = reg->table;
g_return_if_fail(table);
info = gnc_split_register_get_info (reg);
g_return_if_fail(info);
ENTER("reg=%p, slist=%p, default_account=%p", reg, slist, default_account);
blank_split = xaccSplitLookup (&info->blank_split_guid,
gnc_get_current_book ());
pending_trans = xaccTransLookup (&info->pending_trans_guid,
gnc_get_current_book ());
/* make sure we have a blank split */
if (blank_split == NULL)
{
Transaction *new_trans;
gboolean currency_from_account = TRUE;
/* Determine the proper currency to use for this transaction.
* if default_account != NULL and default_account->commodity is
* a currency, then use that. Otherwise use the default currency.
*/
gnc_commodity * currency = gnc_account_or_default_currency(default_account, ¤cy_from_account);
if (default_account != NULL && !currency_from_account)
{
/* If we don't have a currency then pop up a warning dialog */
gnc_info_dialog(NULL, "%s",
_("Could not determine the account currency. "
"Using the default currency provided by your system."));
}
gnc_suspend_gui_refresh ();
new_trans = xaccMallocTransaction (gnc_get_current_book ());
xaccTransBeginEdit (new_trans);
xaccTransSetCurrency (new_trans, currency);
xaccTransSetDatePostedSecsNormalized(new_trans, info->last_date_entered);
blank_split = xaccMallocSplit (gnc_get_current_book ());
xaccSplitSetParent(blank_split, new_trans);
/* We don't want to commit this transaction yet, because the split
doesn't even belong to an account yet. But, we don't want to
set this transaction as the pending transaction either, because
we want to pretend that it hasn't been changed. We depend on
some other code (somewhere) to commit this transaction if we
really edit it, even though it's not marked as the pending
transaction. */
/* Wouldn't it be a bug to open this transaction if there was already a
pending transaction? */
g_assert(pending_trans == NULL);
info->blank_split_guid = *xaccSplitGetGUID (blank_split);
info->blank_split_edited = FALSE;
info->auto_complete = FALSE;
DEBUG("created new blank_split=%p", blank_split);
gnc_resume_gui_refresh ();
}
blank_trans = xaccSplitGetParent (blank_split);
DEBUG("blank_split=%p, blank_trans=%p, pending_trans=%p",
blank_split, blank_trans, pending_trans);
info->default_account = *xaccAccountGetGUID (default_account);
// gnc_table_leave_update (table, table->current_cursor_loc);
multi_line = (reg->style == REG_STYLE_JOURNAL);
dynamic = (reg->style == REG_STYLE_AUTO_LEDGER);
lead_cursor = gnc_split_register_get_passive_cursor (reg);
split_cursor = gnc_table_layout_get_cursor (table->layout, CURSOR_SPLIT);
/* figure out where we are going to. */
if (info->traverse_to_new)
{
find_trans = blank_trans;
find_split = NULL;
find_trans_split = blank_split;
find_class = CURSOR_CLASS_SPLIT;
}
else
{
find_trans = info->cursor_hint_trans;
find_split = info->cursor_hint_split;
find_trans_split = info->cursor_hint_trans_split;
find_class = info->cursor_hint_cursor_class;
}
save_loc = table->current_cursor_loc;
/* If the current cursor has changed we save the values for later
* possible restoration. */
if (gnc_table_current_cursor_changed (table, TRUE) &&
(find_split == gnc_split_register_get_current_split (reg)))
{
cursor_buffer = gnc_cursor_buffer_new ();
gnc_table_save_current_cursor (table, cursor_buffer);
}
else
cursor_buffer = NULL;
/* disable move callback -- we don't want the cascade of
* callbacks while we are fiddling with loading the register */
gnc_table_control_allow_move (table->control, FALSE);
/* invalidate the cursor */
{
VirtualLocation virt_loc;
gnc_virtual_location_init(&virt_loc);
gnc_table_move_cursor_gui (table, virt_loc);
}
/* make sure that the header is loaded */
vcell_loc.virt_row = 0;
vcell_loc.virt_col = 0;
cursor_header = gnc_table_layout_get_cursor (table->layout, CURSOR_HEADER);
gnc_table_set_vcell (table, cursor_header, NULL, TRUE, TRUE, vcell_loc);
vcell_loc.virt_row++;
/* get the current time and reset the dividing row */
present = gnc_time64_get_today_end ();
if (use_autoreadonly)
{
GDate *d = qof_book_get_autoreadonly_gdate(gnc_get_current_book());
// "d" is NULL if use_autoreadonly is FALSE
autoreadonly_time = d ? timespecToTime64(gdate_to_timespec(*d)) : 0;
g_date_free(d);
}
if (info->first_pass)
{
if (default_account)
{
const char *last_num = xaccAccountGetLastNum (default_account);
if (last_num)
{
NumCell *cell;
cell = (NumCell *) gnc_table_layout_get_cell(table->layout, NUM_CELL);
gnc_num_cell_set_last_num (cell, last_num);
has_last_num = TRUE;
}
}
/* load up account names into the transfer combobox menus */
gnc_split_register_load_xfer_cells (reg, default_account);
gnc_split_register_load_recn_cells (reg);
gnc_split_register_load_type_cells (reg);
}
if (info->separator_changed)
{
info->separator_changed = FALSE;
/* set the completion character for the xfer cells */
gnc_combo_cell_set_complete_char(
(ComboCell *) gnc_table_layout_get_cell(table->layout, MXFRM_CELL),
gnc_get_account_separator());
gnc_combo_cell_set_complete_char(
(ComboCell *) gnc_table_layout_get_cell(table->layout, XFRM_CELL),
gnc_get_account_separator());
/* set the confirmation callback for the reconcile cell */
gnc_recn_cell_set_confirm_cb(
(RecnCell *) gnc_table_layout_get_cell(table->layout, RECN_CELL),
gnc_split_register_recn_cell_confirm, reg);
}
table->model->dividing_row_upper = -1;
table->model->dividing_row = -1;
// Ensure that the transaction and splits being edited are in the split
// list we're about to load.
if (pending_trans != NULL)
{
for (node = xaccTransGetSplitList(pending_trans); node; node = node->next)
{
Split *pending_split = (Split*)node->data;
if (!xaccTransStillHasSplit(pending_trans, pending_split)) continue;
if (g_list_find(slist, pending_split) != NULL)
continue;
if (g_list_find_custom(slist, pending_trans,
_find_split_with_parent_txn) != NULL)
continue;
if (!we_own_slist)
{
// lazy-copy
slist = g_list_copy(slist);
we_own_slist = TRUE;
}
slist = g_list_append(slist, pending_split);
}
}
if (multi_line)
trans_table = g_hash_table_new (g_direct_hash, g_direct_equal);
/* populate the table */
for (node = slist; node; node = node->next)
{
split = node->data;
trans = xaccSplitGetParent (split);
if (!xaccTransStillHasSplit(trans, split))
continue;
if (pending_trans == trans)
found_pending = TRUE;
/* If the transaction has only one split, and it's not our
* pending_trans, then it's another register's blank split and
* we don't want to see it.
*/
else if (xaccTransCountSplits (trans) < 2)
continue;
/* Do not load splits from the blank transaction. */
if (trans == blank_trans)
continue;
if (multi_line)
{
/* Skip this split if its transaction has already been loaded. */
if (g_hash_table_lookup (trans_table, trans))
continue;
g_hash_table_insert (trans_table, trans, trans);
}
if (info->show_present_divider &&
use_autoreadonly &&
!found_divider_upper)
{
if (xaccTransGetDate (trans) >= autoreadonly_time)
{
table->model->dividing_row_upper = vcell_loc.virt_row;
found_divider_upper = TRUE;
}
else
{
need_divider_upper = TRUE;
}
}
if (info->show_present_divider &&
!found_divider &&
(xaccTransGetDate (trans) > present))
{
table->model->dividing_row = vcell_loc.virt_row;
found_divider = TRUE;
}
/* If this is the first load of the register,
* fill up the quickfill cells. */
if (info->first_pass)
add_quickfill_completions(reg->table->layout, trans, split, has_last_num);
if (trans == find_trans)
new_trans_row = vcell_loc.virt_row;
if (split == find_trans_split)
new_trans_split_row = vcell_loc.virt_row;
gnc_split_register_add_transaction (reg, trans, split,
lead_cursor, split_cursor,
multi_line, start_primary_color,
TRUE,
find_trans, find_split, find_class,
&new_split_row, &vcell_loc);
if (!multi_line)
start_primary_color = !start_primary_color;
}
if (multi_line)
g_hash_table_destroy (trans_table);
/* add the blank split at the end. */
if (pending_trans == blank_trans)
found_pending = TRUE;
/* No upper divider yet? Store it now */
if (info->show_present_divider &&
use_autoreadonly &&
!found_divider_upper && need_divider_upper)
{
table->model->dividing_row_upper = vcell_loc.virt_row;
found_divider_upper = TRUE;
}
if (blank_trans == find_trans)
new_trans_row = vcell_loc.virt_row;
if (blank_split == find_trans_split)
new_trans_split_row = vcell_loc.virt_row;
/* If we didn't find the pending transaction, it was removed
* from the account. */
if (!found_pending)
{
info->pending_trans_guid = *guid_null ();
if (xaccTransIsOpen (pending_trans))
xaccTransCommitEdit (pending_trans);
else if (pending_trans)
g_assert_not_reached();
pending_trans = NULL;
}
/* go to blank on first pass */
if (info->first_pass)
{
new_split_row = -1;
new_trans_split_row = -1;
new_trans_row = -1;
save_loc.vcell_loc = vcell_loc;
save_loc.phys_row_offset = 0;
save_loc.phys_col_offset = 0;
}
gnc_split_register_add_transaction (reg, blank_trans, blank_split,
lead_cursor, split_cursor,
multi_line, start_primary_color,
info->blank_split_edited, find_trans,
find_split, find_class, &new_split_row,
&vcell_loc);
/* resize the table to the sizes we just counted above */
/* num_virt_cols is always one. */
gnc_table_set_size (table, vcell_loc.virt_row, 1);
/* restore the cursor to its rightful position */
{
VirtualLocation trans_split_loc;
if (new_split_row > 0)
save_loc.vcell_loc.virt_row = new_split_row;
else if (new_trans_split_row > 0)
save_loc.vcell_loc.virt_row = new_trans_split_row;
else if (new_trans_row > 0)
save_loc.vcell_loc.virt_row = new_trans_row;
trans_split_loc = save_loc;
gnc_split_register_get_trans_split (reg, save_loc.vcell_loc,
&trans_split_loc.vcell_loc);
if (dynamic || multi_line || info->trans_expanded)
{
gnc_table_set_virt_cell_cursor(
table, trans_split_loc.vcell_loc,
gnc_split_register_get_active_cursor (reg));
gnc_split_register_set_trans_visible (reg, trans_split_loc.vcell_loc,
TRUE, multi_line);
info->trans_expanded = (reg->style == REG_STYLE_LEDGER);
}
else
{
save_loc = trans_split_loc;
info->trans_expanded = FALSE;
}
if (gnc_table_find_close_valid_cell (table, &save_loc, FALSE))
{
gnc_table_move_cursor_gui (table, save_loc);
new_split_row = save_loc.vcell_loc.virt_row;
if (find_split == gnc_split_register_get_current_split (reg))
gnc_table_restore_current_cursor (table, cursor_buffer);
}
gnc_cursor_buffer_destroy (cursor_buffer);
cursor_buffer = NULL;
}
/* Set up the hint transaction, split, transaction split, and column. */
info->cursor_hint_trans = gnc_split_register_get_current_trans (reg);
info->cursor_hint_split = gnc_split_register_get_current_split (reg);
info->cursor_hint_trans_split =
gnc_split_register_get_current_trans_split (reg, NULL);
info->cursor_hint_cursor_class =
gnc_split_register_get_current_cursor_class (reg);
info->hint_set_by_traverse = FALSE;
info->traverse_to_new = FALSE;
info->exact_traversal = FALSE;
info->first_pass = FALSE;
info->reg_loaded = TRUE;
gnc_split_register_set_cell_fractions(
reg, gnc_split_register_get_current_split (reg));
gnc_table_refresh_gui (table, TRUE);
gnc_split_register_show_trans (reg, table->current_cursor_loc.vcell_loc);
/* enable callback for cursor user-driven moves */
gnc_table_control_allow_move (table->control, TRUE);
if (we_own_slist)
g_list_free(slist);
LEAVE(" ");
}
void xfdashboard_focus_manager_register_after(XfdashboardFocusManager *self, XfdashboardFocusable *inFocusable, XfdashboardFocusable *inAfterFocusable)
{
XfdashboardFocusManagerPrivate *priv;
g_return_if_fail(XFDASHBOARD_IS_FOCUS_MANAGER(self));
g_return_if_fail(inFocusable);
g_return_if_fail(!inAfterFocusable || XFDASHBOARD_IS_FOCUSABLE(inAfterFocusable));
priv=self->priv;
/* Check if given focusable actor is really focusable and stylable */
if(!XFDASHBOARD_IS_FOCUSABLE(inFocusable))
{
g_warning(_("Object %s does not inherit %s and cannot be registered"),
G_OBJECT_TYPE_NAME(inFocusable),
g_type_name(XFDASHBOARD_TYPE_FOCUSABLE));
return;
}
if(!XFDASHBOARD_IS_STYLABLE(inFocusable))
{
g_warning(_("Object %s does not inherit %s and cannot be registered"),
G_OBJECT_TYPE_NAME(inFocusable),
g_type_name(XFDASHBOARD_TYPE_STYLABLE));
return;
}
/* Register focusable actor if not already registered */
if(g_list_find(priv->registeredFocusables, inFocusable)==NULL)
{
gint insertPosition;
g_debug("Registering focusable %s", G_OBJECT_TYPE_NAME(inFocusable));
/* If requested find position of focusable actor to insert new focusable actor after.
* Increase found position by one and add new focusable actor to list of registered
* focusable actors at this position. Otherwise add new focusable actor to end of list.
*/
insertPosition=-1;
if(inAfterFocusable)
{
insertPosition=g_list_index(priv->registeredFocusables, inAfterFocusable);
if(insertPosition!=-1) insertPosition++;
else
{
g_warning(_("Could not find registered focusable object %s to register object %s - appending to end of list."),
G_OBJECT_TYPE_NAME(inAfterFocusable),
G_OBJECT_TYPE_NAME(inFocusable));
}
}
priv->registeredFocusables=g_list_insert(priv->registeredFocusables, inFocusable, insertPosition);
/* Connect to signals to get notified if actor is going to be destroy,
* unrealized or hidden to remove it from list of focusable actors.
*/
g_signal_connect_swapped(inFocusable,
"destroy",
G_CALLBACK(_xfdashboard_focus_manager_on_focusable_destroy),
self);
g_signal_connect_swapped(inFocusable,
"realize",
G_CALLBACK(_xfdashboard_focus_manager_on_focusable_hide),
self);
g_signal_connect_swapped(inFocusable,
"hide",
G_CALLBACK(_xfdashboard_focus_manager_on_focusable_hide),
self);
/* Emit signal */
g_signal_emit(self, XfdashboardFocusManagerSignals[SIGNAL_REGISTERED], 0, inFocusable);
}
}
void
ags_machine_open_extended_response_callback(GtkWidget *widget, gint response, AgsMachine *machine)
{
GtkFileChooserDialog *file_chooser;
AgsFileSelection *file_selection;
GtkCheckButton *overwrite;
GtkCheckButton *create;
GSList *filenames;
gchar *current_folder;
GError *error;
file_chooser = (GtkFileChooserDialog *) gtk_widget_get_toplevel(widget);
if(response == GTK_RESPONSE_ACCEPT){
filenames = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(file_chooser));
overwrite = g_object_get_data((GObject *) widget, "overwrite\0");
create = g_object_get_data((GObject *) widget, "create\0");
current_folder = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(file_chooser));
//TODO:JK: you need to check against recently used
//TODO:JK: add more file types to AgsFileSelection
/* check for supported packed audio files */
file_selection = (AgsFileSelection *) gtk_file_chooser_get_extra_widget(GTK_FILE_CHOOSER(file_chooser));
if(file_selection != NULL && g_strcmp0(file_selection->directory, current_folder)){
gtk_widget_destroy(GTK_WIDGET(file_selection));
file_selection = NULL;
}
if(file_selection == NULL ||
(AGS_FILE_SELECTION_COMPLETED & (file_selection->flags)) == 0){
if((AGS_MACHINE_ACCEPT_SOUNDFONT2 & (machine->file_input_flags)) != 0){
GDir *current_directory;
GList *new_entry, *old_entry;
GSList *slist;
gchar *current_filename;
slist = filenames;
new_entry = NULL;
while(slist != NULL){
if(g_str_has_suffix(slist->data,
".sf2\0")){
AgsFileSelectionEntry *entry;
entry = ags_file_selection_entry_alloc();
entry->filename = slist->data;
new_entry = g_list_prepend(new_entry,
entry);
}
slist = slist->next;
}
old_entry = NULL;
if(file_selection == NULL){
if(new_entry != NULL){
file_selection = ags_file_selection_new();
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(file_chooser),
GTK_WIDGET(file_selection));
ags_file_selection_set_entry(file_selection,
new_entry);
ags_connectable_connect(AGS_CONNECTABLE(file_selection));
gtk_widget_show_all(GTK_WIDGET(file_selection));
return;
}
}else if(AGS_IS_FILE_SELECTION(file_selection)){
GList *really_new_entry;
GList *list;
old_entry = file_selection->entry;
list = new_entry;
really_new_entry = NULL;
/* check against existing entries */
if(new_entry != NULL){
while(list != NULL){
if(g_list_find(old_entry, list->data) == NULL){
really_new_entry = g_list_prepend(really_new_entry,
list->data);
}else{
free(list->data);
}
list = list->next;
}
g_list_free(new_entry);
}
ags_file_selection_set_entry(file_selection,
really_new_entry);
/* adding lost files */
//TODO:JK: figure out if you need to copy the GSList of filenames
gtk_file_chooser_select_all(GTK_FILE_CHOOSER(file_chooser));
current_directory = g_dir_open(current_folder,
0,
&error);
while((current_filename = (gchar *) g_dir_read_name(current_directory)) != NULL){
if(!g_strcmp0(".\0", current_filename) ||
!g_strcmp0("..\0", current_filename))
continue;
if(!ags_file_selection_contains_file(file_selection, current_filename) &&
g_slist_find(filenames, current_filename) == NULL){
gtk_file_chooser_unselect_filename(GTK_FILE_CHOOSER(file_chooser),
current_filename);
}
}
g_dir_close(current_directory);
return;
}
}
}
//TODO:JK: fix GSList filenames memory leak
ags_machine_open_files(machine,
filenames,
overwrite->toggle_button.active,
create->toggle_button.active);
}
}
void
channels_actions_update (GimpActionGroup *group,
gpointer data)
{
GimpImage *image = action_data_get_image (data);
GimpChannel *channel = NULL;
gboolean fs = FALSE;
gboolean component = FALSE;
GList *next = NULL;
GList *prev = NULL;
if (image)
{
fs = (gimp_image_get_floating_selection (image) != NULL);
if (GIMP_IS_COMPONENT_EDITOR (data))
{
if (GIMP_COMPONENT_EDITOR (data)->clicked_component != -1)
component = TRUE;
}
else
{
channel = gimp_image_get_active_channel (image);
if (channel)
{
GList *channel_list;
GList *list;
channel_list = gimp_item_get_container_iter (GIMP_ITEM (channel));
list = g_list_find (channel_list, channel);
if (list)
{
prev = g_list_previous (list);
next = g_list_next (list);
}
}
}
}
#define SET_SENSITIVE(action,condition) \
gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
SET_SENSITIVE ("channels-edit-attributes", !fs && channel);
SET_SENSITIVE ("channels-new", !fs && image);
SET_SENSITIVE ("channels-new-last-values", !fs && image);
SET_SENSITIVE ("channels-duplicate", !fs && (channel || component));
SET_SENSITIVE ("channels-delete", !fs && channel);
SET_SENSITIVE ("channels-raise", !fs && channel && prev);
SET_SENSITIVE ("channels-raise-to-top", !fs && channel && prev);
SET_SENSITIVE ("channels-lower", !fs && channel && next);
SET_SENSITIVE ("channels-lower-to-bottom", !fs && channel && next);
SET_SENSITIVE ("channels-selection-replace", !fs && (channel || component));
SET_SENSITIVE ("channels-selection-add", !fs && (channel || component));
SET_SENSITIVE ("channels-selection-subtract", !fs && (channel || component));
SET_SENSITIVE ("channels-selection-intersect", !fs && (channel || component));
#undef SET_SENSITIVE
items_actions_update (group, "channels", GIMP_ITEM (channel));
}
void
layers_actions_update (GimpActionGroup *group,
gpointer data)
{
GimpImage *image = action_data_get_image (data);
GimpLayer *layer = NULL;
GimpLayerMask *mask = NULL; /* layer mask */
gboolean fs = FALSE; /* floating sel */
gboolean ac = FALSE; /* active channel */
gboolean sel = FALSE;
gboolean alpha = FALSE; /* alpha channel present */
gboolean indexed = FALSE; /* is indexed */
gboolean lock_alpha = FALSE;
gboolean text_layer = FALSE;
GList *next = NULL;
GList *prev = NULL;
if (image)
{
fs = (gimp_image_floating_sel (image) != NULL);
ac = (gimp_image_get_active_channel (image) != NULL);
sel = ! gimp_channel_is_empty (gimp_image_get_mask (image));
indexed = (gimp_image_base_type (image) == GIMP_INDEXED);
layer = gimp_image_get_active_layer (image);
if (layer)
{
GList *list;
mask = gimp_layer_get_mask (layer);
lock_alpha = gimp_layer_get_lock_alpha (layer);
alpha = gimp_drawable_has_alpha (GIMP_DRAWABLE (layer));
list = g_list_find (GIMP_LIST (image->layers)->list, layer);
if (list)
{
prev = g_list_previous (list);
next = g_list_next (list);
}
if (layer)
text_layer = gimp_drawable_is_text_layer (GIMP_DRAWABLE (layer));
}
}
#define SET_VISIBLE(action,condition) \
gimp_action_group_set_action_visible (group, action, (condition) != 0)
#define SET_SENSITIVE(action,condition) \
gimp_action_group_set_action_sensitive (group, action, (condition) != 0)
#define SET_ACTIVE(action,condition) \
gimp_action_group_set_action_active (group, action, (condition) != 0)
SET_VISIBLE ("layers-text-tool", text_layer && !ac);
SET_SENSITIVE ("layers-edit-attributes", layer && !fs && !ac);
SET_SENSITIVE ("layers-new", image);
SET_SENSITIVE ("layers-new-last-values", image);
SET_SENSITIVE ("layers-duplicate", layer && !fs && !ac);
SET_SENSITIVE ("layers-delete", layer && !ac);
SET_SENSITIVE ("layers-select-top", layer && !fs && !ac && prev);
SET_SENSITIVE ("layers-select-bottom", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-select-previous", layer && !fs && !ac && prev);
SET_SENSITIVE ("layers-select-next", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-raise", layer && !fs && !ac && prev);
SET_SENSITIVE ("layers-raise-to-top", layer && !fs && !ac && prev);
SET_SENSITIVE ("layers-lower", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-lower-to-bottom", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-anchor", layer && fs && !ac);
SET_SENSITIVE ("layers-merge-down", layer && !fs && !ac && next);
SET_SENSITIVE ("layers-merge-layers", layer && !fs && !ac);
SET_SENSITIVE ("layers-flatten-image", layer && !fs && !ac);
SET_VISIBLE ("layers-text-discard", text_layer && !ac);
SET_VISIBLE ("layers-text-to-vectors", text_layer && !ac);
SET_VISIBLE ("layers-text-along-vectors", text_layer && !ac);
SET_VISIBLE ("layers-text-selection-replace", text_layer && !ac);
SET_VISIBLE ("layers-text-selection-add", text_layer && !ac);
SET_VISIBLE ("layers-text-selection-subtract", text_layer && !ac);
SET_VISIBLE ("layers-text-selection-intersect", text_layer && !ac);
SET_SENSITIVE ("layers-resize", layer && !ac);
SET_SENSITIVE ("layers-resize-to-image", layer && !ac);
SET_SENSITIVE ("layers-scale", layer && !ac);
SET_SENSITIVE ("layers-crop", layer && sel);
SET_SENSITIVE ("layers-alpha-add", layer && !fs && !alpha);
SET_SENSITIVE ("layers-alpha-remove", layer && !fs && alpha);
SET_SENSITIVE ("layers-lock-alpha", layer);
SET_ACTIVE ("layers-lock-alpha", lock_alpha);
SET_SENSITIVE ("layers-mask-add", layer && !fs && !ac && !mask);
SET_SENSITIVE ("layers-mask-apply", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-delete", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-edit", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-show", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-disable", layer && !fs && !ac && mask);
SET_ACTIVE ("layers-mask-edit", mask && gimp_layer_mask_get_edit (mask));
SET_ACTIVE ("layers-mask-show", mask && gimp_layer_mask_get_show (mask));
SET_ACTIVE ("layers-mask-disable", mask && !gimp_layer_mask_get_apply (mask));
SET_SENSITIVE ("layers-mask-selection-replace", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-selection-add", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-selection-subtract", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-mask-selection-intersect", layer && !fs && !ac && mask);
SET_SENSITIVE ("layers-alpha-selection-replace", layer && !fs && !ac);
SET_SENSITIVE ("layers-alpha-selection-add", layer && !fs && !ac);
SET_SENSITIVE ("layers-alpha-selection-subtract", layer && !fs && !ac);
SET_SENSITIVE ("layers-alpha-selection-intersect", layer && !fs && !ac);
#undef SET_VISIBLE
#undef SET_SENSITIVE
#undef SET_ACTIVE
}
gboolean
gst_device_monitor_start (GstDeviceMonitor * monitor)
{
guint cookie, i;
GList *pending = NULL, *started = NULL, *removed = NULL;
g_return_val_if_fail (GST_IS_DEVICE_MONITOR (monitor), FALSE);
GST_OBJECT_LOCK (monitor);
if (monitor->priv->filters->len == 0) {
GST_OBJECT_UNLOCK (monitor);
GST_WARNING_OBJECT (monitor, "No filters have been set, will expose all "
"devices found");
gst_device_monitor_add_filter (monitor, NULL, NULL);
GST_OBJECT_LOCK (monitor);
}
if (monitor->priv->providers->len == 0) {
GST_OBJECT_UNLOCK (monitor);
GST_WARNING_OBJECT (monitor, "No providers match the current filters");
return FALSE;
}
gst_bus_set_flushing (monitor->priv->bus, FALSE);
again:
cookie = monitor->priv->cookie;
g_list_free_full (pending, gst_object_unref);
pending = NULL;
removed = started;
started = NULL;
for (i = 0; i < monitor->priv->providers->len; i++) {
GstDeviceProvider *provider;
GList *find;
provider = g_ptr_array_index (monitor->priv->providers, i);
find = g_list_find (removed, provider);
if (find) {
/* this was already started, move to started list */
removed = g_list_remove_link (removed, find);
started = g_list_concat (started, find);
} else {
/* not started, add to pending list */
pending = g_list_append (pending, gst_object_ref (provider));
}
}
g_list_free_full (removed, gst_object_unref);
removed = NULL;
while (pending) {
GstDeviceProvider *provider = pending->data;
if (gst_device_provider_can_monitor (provider)) {
GST_OBJECT_UNLOCK (monitor);
if (!gst_device_provider_start (provider))
goto start_failed;
GST_OBJECT_LOCK (monitor);
}
started = g_list_prepend (started, provider);
pending = g_list_delete_link (pending, pending);
if (monitor->priv->cookie != cookie)
goto again;
}
monitor->priv->started = TRUE;
GST_OBJECT_UNLOCK (monitor);
g_list_free_full (started, gst_object_unref);
return TRUE;
start_failed:
{
GST_OBJECT_LOCK (monitor);
gst_bus_set_flushing (monitor->priv->bus, TRUE);
GST_OBJECT_UNLOCK (monitor);
while (started) {
GstDeviceProvider *provider = started->data;
gst_device_provider_stop (provider);
gst_object_unref (provider);
started = g_list_delete_link (started, started);
}
return FALSE;
}
}
/*! \brief Find page hierarchy below a page.
* \par Function Description
* This function traverses the hierarchy tree of pages and returns a
* flat list of pages that are below \a p_current. There are two \a
* flags that can be used to control the way that the return value is
* constructed: <B>HIERARCHY_NODUPS</B> returns a list without
* duplicate pages, and <B>HIERARCHY_POSTORDER</B> traverses the
* hierarchy tree and returns a postorder list instead of preorder.
*
* \param toplevel The TOPLEVEL structure.
* \param p_current The PAGE to traverse hierarchy for.
* \param flags Flags controlling form of return value.
* \return A GList of PAGE pointers.
*
* \warning
* Caller must destroy returned GList with g_list_free().
*/
GList *
s_hierarchy_traversepages (TOPLEVEL *toplevel, PAGE *p_current, gint flags)
{
OBJECT *o_current;
PAGE *child_page;
char *filename = NULL;
static GList *pages = NULL;
const GList *iter;
g_return_val_if_fail ((toplevel != NULL), NULL);
g_return_val_if_fail ((p_current != NULL), NULL);
/* init static variables the first time*/
if (!(flags & HIERARCHY_INNERLOOP)) {
pages = NULL;
}
/* preorder traversing */
if (!(flags & HIERARCHY_POSTORDER)) {
/* check whether we already visited this page */
if ((flags & HIERARCHY_NODUPS)
&& (g_list_find (pages, p_current) != NULL)) {
return pages; /* drop the page subtree */
}
pages = g_list_append (pages, p_current);
}
/* walk throught the page objects and search for underlaying schematics */
for (iter = s_page_objects (p_current);
iter != NULL ;
iter = g_list_next (iter)) {
o_current = (OBJECT *)iter->data;
/* only complex things like symbols can contain attributes */
if (o_current->type != OBJ_COMPLEX) continue;
filename =
o_attrib_search_attached_attribs_by_name (o_current, "source", 0);
/* if above is NULL, then look inside symbol */
if (filename == NULL) {
filename =
o_attrib_search_inherited_attribs_by_name (o_current, "source", 0);
}
if (filename == NULL) continue;
/* we got a schematic source attribute
lets load the page and dive into it */
child_page =
s_hierarchy_down_schematic_single (toplevel, filename, p_current, 0,
HIERARCHY_NORMAL_LOAD);
if (child_page != NULL) {
/* call the recursive function */
s_hierarchy_traversepages (toplevel, child_page, flags | HIERARCHY_INNERLOOP);
} else {
s_log_message (_("ERROR in s_hierarchy_traverse: "
"schematic not found: %s\n"),
filename);
}
g_free (filename);
filename = NULL;
}
/* postorder traversing */
if (flags & HIERARCHY_POSTORDER) {
/* check whether we already visited this page */
if ((flags & HIERARCHY_NODUPS)
&& (g_list_find (pages, p_current) != NULL)) {
return pages; /* don't append it */
}
pages = g_list_append (pages, p_current);
}
return pages;
}
unsigned long
add_widget_autopos (Dlg_head * h, void *w, widget_pos_flags_t pos_flags, const void *before)
{
Widget *widget = (Widget *) w;
/* Don't accept 0 widgets */
if (w == NULL)
abort ();
widget->x += h->x;
widget->y += h->y;
widget->owner = h;
widget->pos_flags = pos_flags;
widget->id = h->widget_id++;
if ((h->flags & DLG_REVERSE) != 0)
{
if (h->widgets == NULL || before == NULL)
{
h->widgets = g_list_prepend (h->widgets, widget);
h->current = h->widgets;
}
else
{
GList *b;
b = g_list_find (h->widgets, before);
/* don't accept widget not from dialog. This shouldn't happen */
if (b == NULL)
abort ();
h->widgets = g_list_insert_before (h->widgets, b, widget);
h->current = g_list_previous (b);
}
}
else
{
if (h->widgets == NULL || before == NULL)
{
h->widgets = g_list_append (h->widgets, widget);
h->current = g_list_last (h->widgets);
}
else
{
GList *b;
b = g_list_find (h->widgets, before);
/* don't accept widget not from dialog. This shouldn't happen */
if (b == NULL)
abort ();
b = g_list_next (b);
h->widgets = g_list_insert_before (h->widgets, b, widget);
if (b != NULL)
h->current = g_list_previous (b);
else
h->current = g_list_last (h->widgets);
}
}
/* widget has been added in runtime */
if (h->state == DLG_ACTIVE)
{
send_message (widget, WIDGET_INIT, 0);
send_message (widget, WIDGET_DRAW, 0);
send_message (widget, WIDGET_FOCUS, 0);
}
return widget->id;
}
/** Initializes a diagram with standard info and sets it to be called
* 'filename'.
* Returns TRUE if everything went ok, FALSE otherwise.
* Will return FALSE if filename is not a legal string in the current
* encoding.
*/
static gboolean
diagram_init(Diagram *dia, const char *filename)
{
gchar *newfilename = NULL;
GError *error = NULL;
dia->data = &dia->parent_instance; /* compatibility */
dia->pagebreak_color = prefs.new_diagram.pagebreak_color;
get_paper_info (&dia->data->paper, -1, &prefs.new_diagram);
dia->grid.width_x = prefs.grid.x;
dia->grid.width_y = prefs.grid.y;
dia->grid.width_w = prefs.grid.w;
dia->grid.hex_size = 1.0;
dia->grid.colour = prefs.new_diagram.grid_color;
dia->grid.hex = prefs.grid.hex;
dia->grid.visible_x = prefs.grid.vis_x;
dia->grid.visible_y = prefs.grid.vis_y;
dia->grid.dynamic = prefs.grid.dynamic;
dia->grid.major_lines = prefs.grid.major_lines;
dia->guides.nhguides = 0;
dia->guides.hguides = NULL;
dia->guides.nvguides = 0;
dia->guides.vguides = NULL;
if (dia->filename != NULL)
g_free(dia->filename);
/* Make sure the filename is absolute */
if (!g_path_is_absolute(filename)) {
gchar *pwd = g_get_current_dir();
newfilename = g_build_filename(pwd, filename, NULL);
g_free(pwd);
filename = newfilename;
}
/* All Diagram functions assumes filename in filesystem encoding */
dia->filename = g_filename_to_utf8(filename, -1, NULL, NULL, &error);
if (error != NULL) {
message_error(_("Couldn't convert filename '%s' to UTF-8: %s\n"),
dia_message_filename(filename), error->message);
g_error_free(error);
dia->filename = g_strdup(_("Error"));
return FALSE;
}
dia->unsaved = TRUE;
dia->mollified = FALSE;
dia->autosavefilename = NULL;
if (dia->undo)
undo_destroy(dia->undo);
dia->undo = new_undo_stack(dia);
if (!g_list_find(open_diagrams, dia))
open_diagrams = g_list_prepend(open_diagrams, dia);
if (app_is_interactive())
layer_dialog_update_diagram_list();
g_free(newfilename);
g_signal_connect (G_OBJECT(dia), "object_add", G_CALLBACK(_object_add), dia);
g_signal_connect (G_OBJECT(dia), "object_remove", G_CALLBACK(_object_remove), dia);
return TRUE;
}
void
purple_media_stream_info(PurpleMedia *media, PurpleMediaInfoType type,
const gchar *session_id, const gchar *participant,
gboolean local)
{
#ifdef USE_VV
g_return_if_fail(PURPLE_IS_MEDIA(media));
if (type == PURPLE_MEDIA_INFO_ACCEPT) {
GList *streams, *sessions = NULL, *participants = NULL;
g_return_if_fail(PURPLE_IS_MEDIA(media));
streams = purple_media_get_streams(media,
session_id, participant);
/* Emit stream acceptance */
for (; streams; streams =
g_list_delete_link(streams, streams)) {
PurpleMediaStream *stream = streams->data;
stream->accepted = TRUE;
g_signal_emit(media,
purple_media_signals[STREAM_INFO],
0, type, stream->session->id,
stream->participant, local);
if (g_list_find(sessions, stream->session) == NULL)
sessions = g_list_prepend(sessions,
stream->session);
if (g_list_find_custom(participants,
stream->participant,
(GCompareFunc)strcmp) == NULL)
participants = g_list_prepend(participants,
g_strdup(stream->participant));
}
/* Emit session acceptance */
for (; sessions; sessions =
g_list_delete_link(sessions, sessions)) {
PurpleMediaSession *session = sessions->data;
if (purple_media_accepted(media, session->id, NULL))
g_signal_emit(media, purple_media_signals[
STREAM_INFO], 0,
PURPLE_MEDIA_INFO_ACCEPT,
session->id, NULL, local);
}
/* Emit participant acceptance */
for (; participants; participants = g_list_delete_link(
participants, participants)) {
gchar *participant = participants->data;
if (purple_media_accepted(media, NULL, participant))
g_signal_emit(media, purple_media_signals[
STREAM_INFO], 0,
PURPLE_MEDIA_INFO_ACCEPT,
NULL, participant, local);
g_free(participant);
}
/* Emit conference acceptance */
if (purple_media_accepted(media, NULL, NULL))
g_signal_emit(media,
purple_media_signals[STREAM_INFO],
0, PURPLE_MEDIA_INFO_ACCEPT,
NULL, NULL, local);
return;
} else if (type == PURPLE_MEDIA_INFO_HANGUP ||
type == PURPLE_MEDIA_INFO_REJECT) {
GList *streams;
g_return_if_fail(PURPLE_IS_MEDIA(media));
streams = purple_media_get_streams(media,
session_id, participant);
/* Emit for stream */
for (; streams; streams =
g_list_delete_link(streams, streams)) {
PurpleMediaStream *stream = streams->data;
g_signal_emit(media,
purple_media_signals[STREAM_INFO],
0, type, stream->session->id,
stream->participant, local);
}
if (session_id != NULL && participant != NULL) {
/* Everything that needs to be emitted has been */
} else if (session_id == NULL && participant == NULL) {
/* Emit for everything in the conference */
GList *sessions = NULL;
GList *participants = media->priv->participants;
if (media->priv->sessions != NULL)
sessions = g_hash_table_get_values(
media->priv->sessions);
/* Emit for sessions */
for (; sessions; sessions = g_list_delete_link(
sessions, sessions)) {
PurpleMediaSession *session = sessions->data;
g_signal_emit(media, purple_media_signals[
STREAM_INFO], 0, type,
session->id, NULL, local);
}
/* Emit for participants */
for (; participants; participants =
g_list_next(participants)) {
gchar *participant = participants->data;
g_signal_emit(media, purple_media_signals[
STREAM_INFO], 0, type,
NULL, participant, local);
}
/* Emit for conference */
g_signal_emit(media,
purple_media_signals[STREAM_INFO],
0, type, NULL, NULL, local);
} else if (session_id != NULL) {
/* Emit just the specific session */
PurpleMediaSession *session =
purple_media_get_session(
media, session_id);
if (session == NULL) {
purple_debug_warning("media",
"Couldn't find session"
" to hangup/reject.\n");
} else {
g_signal_emit(media, purple_media_signals[
STREAM_INFO], 0, type,
session->id, NULL, local);
}
} else if (participant != NULL) {
/* Emit just the specific participant */
if (!g_list_find_custom(media->priv->participants,
participant, (GCompareFunc)strcmp)) {
purple_debug_warning("media",
"Couldn't find participant"
" to hangup/reject.\n");
} else {
g_signal_emit(media, purple_media_signals[
STREAM_INFO], 0, type, NULL,
participant, local);
}
}
purple_media_end(media, session_id, participant);
return;
}
g_signal_emit(media, purple_media_signals[STREAM_INFO],
0, type, session_id, participant, local);
#endif
}
void
diagram_selected_break_external(Diagram *dia)
{
GList *list;
GList *connected_list;
DiaObject *obj;
DiaObject *other_obj;
int i,j;
list = dia->data->selected;
while (list != NULL) {
obj = (DiaObject *)list->data;
/* Break connections between this object and objects not selected: */
for (i=0;i<obj->num_handles;i++) {
ConnectionPoint *con_point;
con_point = obj->handles[i]->connected_to;
if ( con_point == NULL )
break; /* Not connected */
other_obj = con_point->object;
if (g_list_find(dia->data->selected, other_obj) == NULL) {
/* other_obj is not selected, break connection */
Change *change = undo_unconnect(dia, obj, obj->handles[i]);
(change->apply)(change, dia);
object_add_updates(obj, dia);
}
}
/* Break connections from non selected objects to this object: */
for (i=0;i<obj->num_connections;i++) {
connected_list = obj->connections[i]->connected;
while (connected_list != NULL) {
other_obj = (DiaObject *)connected_list->data;
if (g_list_find(dia->data->selected, other_obj) == NULL) {
/* other_obj is not in list, break all connections
to obj from other_obj */
for (j=0;j<other_obj->num_handles;j++) {
ConnectionPoint *con_point;
con_point = other_obj->handles[j]->connected_to;
if (con_point && (con_point->object == obj)) {
Change *change;
connected_list = g_list_previous(connected_list);
change = undo_unconnect(dia, other_obj,
other_obj->handles[j]);
(change->apply)(change, dia);
if (connected_list == NULL)
connected_list = obj->connections[i]->connected;
}
}
}
connected_list = g_list_next(connected_list);
}
}
list = g_list_next(list);
}
}
static int judge_backwards(struct gspan *gs, GList *right_most_path, GList *projection,
GHashTable *pm_backwards)
{
GList *l1, *l2, *l3, *values = NULL;
int i;
int rmp0;
rmp0 = GPOINTER_TO_INT(g_list_nth_data(right_most_path, 0));
for (i=g_list_length(right_most_path)-2,l1=g_list_last(right_most_path);
i >= 0; i--, l1 = g_list_previous(l1)) {
int rmp = GPOINTER_TO_INT(l1->data);
int rmpi = GPOINTER_TO_INT(g_list_nth_data(right_most_path, i));
for(l2 = g_list_first(projection); l2; l2 = g_list_next(l2)) {
struct pre_dfs *p = (struct pre_dfs *)l2->data;
struct history *h;
struct edge *last_edge;
struct node *last_node, *to_node, *from_node;
struct edge *edge;
h = alloc_history();
build_history(h, p);
last_edge = (struct edge *)
g_list_nth_data(h->edges, rmp0);
last_node = graph_get_node(gs->min_graph,
last_edge->to);
edge = (struct edge *)
g_list_nth_data(h->edges, rmpi);
to_node = graph_get_node(gs->min_graph, edge->to);
from_node = graph_get_node(gs->min_graph, edge->from);
for (l3 = g_list_first(last_node->edges); l3;
l3 = g_list_next(l3)) {
struct edge *e = (struct edge *)l3->data;
if (g_list_find(h->has_edges,
GINT_TO_POINTER(e->id)))
continue;
if (!g_list_find(h->has_nodes,
GINT_TO_POINTER(e->to)))
continue;
if (e->to == edge->from &&
(e->label > edge->label ||
(e->label == edge->label &&
last_node->label >
to_node->label))) {
struct dfs_code *dfsc;
struct pre_dfs *npdfs;
int from_id;
int to_id;
from_id = ((struct dfs_code *)
g_list_nth_data(
gs->min_dfs_codes,
rmp0))->to;
to_id = ((struct dfs_code *)
g_list_nth_data(
gs->min_dfs_codes,
rmpi))->from;
#ifdef DEBUG
printf("!! %d %d %d ", i, rmp, rmpi);
print_dfs(g_list_nth_data(
gs->min_dfs_codes,
rmpi));
printf("\n");
print_id_list(right_most_path);
#endif
dfsc = malloc(sizeof(struct dfs_code));
if (!dfsc) {
perror("malloc dfsc in jb()");
exit(1);
}
dfsc->from = from_id;
dfsc->to = to_id;
dfsc->from_label = last_node->label;
dfsc->edge_label = e->label;
dfsc->to_label = from_node->label;
npdfs = malloc(sizeof(struct pre_dfs));
if (!npdfs) {
perror("malloc npdfs in jb()");
exit(1);
}
npdfs->id = 0;
npdfs->edge = e;
npdfs->prev = p;
if (g_hash_table_contains(pm_backwards,
dfsc))
values = g_hash_table_lookup(
pm_backwards,dfsc);
values = g_list_append(values, npdfs);
g_hash_table_insert(pm_backwards, dfsc,
values);
values = NULL;
}
}
free_history(h);
}
if (g_hash_table_size(pm_backwards) > 0)
return 1;
}
return 0;
}
int
diagram_is_selected(Diagram *diagram, DiaObject *obj)
{
return g_list_find(diagram->data->selected, obj) != NULL;
}
/***************************
* *
* Encodings dialog window *
* *
**************************/
void
gxi_edit_encodings_clicked_cb (GtkButton *button, GncXmlImportData *data)
{
GtkBuilder *builder;
GtkWidget *dialog;
GtkListStore *list_store;
GtkTreeStore *tree_store;
GtkTreeIter iter, parent, *parent_ptr;
GList *encodings_bak, *enc_iter;
const gchar *encoding;
system_encoding_type *system_enc;
gpointer enc_ptr;
gint i, j;
builder = gtk_builder_new();
gnc_builder_add_from_file (builder, "assistant-xml-encoding.glade", "Encodings Dialog");
dialog = GTK_WIDGET(gtk_builder_get_object (builder, "Encodings Dialog"));
data->encodings_dialog = dialog;
gtk_builder_connect_signals_full (builder, gnc_builder_connect_full_func, data);
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (data->assistant));
data->available_encs_view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "available_encs_view"));
data->custom_enc_entry = GTK_WIDGET(gtk_builder_get_object (builder, "custom_enc_entry"));
/* set up selected encodings list */
data->selected_encs_view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "selected_encs_view"));
list_store = gtk_list_store_new (ENC_NUM_COLS, G_TYPE_STRING, G_TYPE_POINTER);
for (enc_iter = data->encodings; enc_iter; enc_iter = enc_iter->next)
{
encoding = g_quark_to_string (GPOINTER_TO_UINT (enc_iter->data));
gtk_list_store_append (list_store, &iter);
gtk_list_store_set (list_store, &iter, ENC_COL_STRING, encoding,
ENC_COL_QUARK, enc_iter->data, -1);
}
gtk_tree_view_insert_column_with_attributes (
data->selected_encs_view, -1, NULL,
gtk_cell_renderer_text_new (), "text", ENC_COL_STRING, NULL);
gtk_tree_view_set_model (data->selected_encs_view,
GTK_TREE_MODEL (list_store));
g_object_unref (list_store);
/* set up system encodings list */
data->available_encs_view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "available_encs_view"));
tree_store = gtk_tree_store_new (ENC_NUM_COLS, G_TYPE_STRING, G_TYPE_POINTER);
for (i = 0, system_enc = system_encodings;
i < n_system_encodings;
i++, system_enc++)
{
if (i == 0)
{
/* first system encoding */
parent_ptr = NULL;
}
else
{
parent_ptr = &iter;
for (j = 0; j < system_enc->parent; j++)
if (gtk_tree_model_iter_parent (GTK_TREE_MODEL (tree_store),
&parent, &iter))
{
/* go up one level */
iter = parent;
}
else
{
/* no parent to toplevel element */
parent_ptr = NULL;
}
}
if (system_enc->encoding)
enc_ptr = GUINT_TO_POINTER (g_quark_from_string (system_enc->encoding));
else
enc_ptr = NULL;
gtk_tree_store_append (tree_store, &iter, parent_ptr);
gtk_tree_store_set (tree_store, &iter, ENC_COL_STRING,
gettext (system_enc->text), ENC_COL_QUARK, enc_ptr, -1);
}
gtk_tree_view_insert_column_with_attributes (
data->available_encs_view, -1, NULL,
gtk_cell_renderer_text_new (), "text", ENC_COL_STRING, NULL);
gtk_tree_view_set_model (data->available_encs_view,
GTK_TREE_MODEL (tree_store));
g_object_unref (tree_store);
/* run the dialog */
encodings_bak = g_list_copy (data->encodings);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
{
g_list_free (encodings_bak);
if (!g_list_find (data->encodings,
GUINT_TO_POINTER (data->default_encoding)))
{
/* choose top level encoding then */
data->default_encoding = GPOINTER_TO_UINT (data->encodings->data);
}
/* update whole page */
gxi_check_file (data);
gxi_update_default_enc_combo (data);
gxi_update_string_box (data);
gxi_update_conversion_forward (data);
}
else
{
g_list_free (data->encodings);
data->encodings = encodings_bak;
}
g_object_unref(G_OBJECT(builder));
gtk_widget_destroy (dialog);
data->encodings_dialog = NULL;
}
static void sig_statusbar_activity_hilight(WINDOW_REC *window, gpointer oldlevel)
{
GList *node;
g_return_if_fail(window != NULL);
node = g_list_find(activity_list, window);
if (actlist_sort == 1) {
/* Move the window to the first in the activity list */
if (node != NULL)
activity_list = g_list_delete_link(activity_list, node);
if (window->data_level != 0)
activity_list = g_list_prepend(activity_list, window);
statusbar_items_redraw("act");
return;
}
if (actlist_sort == 2) {
if (node != NULL) {
if (window->data_level == GPOINTER_TO_INT(oldlevel)) {
if (window->hilight_color != 0)
statusbar_items_redraw("act");
return;
}
activity_list = g_list_delete_link(activity_list, node);
}
if (window->data_level != 0)
activity_list = g_list_insert_sorted(activity_list, window, (GCompareFunc)
window_level_cmp);
statusbar_items_redraw("act");
return;
}
if (actlist_sort == 3) {
if (node != NULL)
activity_list = g_list_delete_link(activity_list, node);
if (window->data_level != 0)
activity_list = g_list_insert_sorted(activity_list, window, (GCompareFunc)
window_level_recent_cmp);
statusbar_items_redraw("act");
return;
}
if (node != NULL) {
/* already in activity list */
if (window->data_level == 0) {
/* remove from activity list */
activity_list = g_list_delete_link(activity_list, node);
statusbar_items_redraw("act");
} else if (window->data_level != GPOINTER_TO_INT(oldlevel) ||
window->hilight_color != 0) {
/* different level as last time (or maybe different
hilight color?), just redraw it. */
statusbar_items_redraw("act");
}
return;
}
if (window->data_level == 0)
return;
/* add window to activity list .. */
activity_list = g_list_insert_sorted(activity_list, window, (GCompareFunc)
window_refnum_cmp);
statusbar_items_redraw("act");
}