static int
updatedate_bar (struct session *sess)
{
static int type = 0;
static float pos = 0;
if (!is_session (sess))
return 0;
pos += 0.05;
if (pos >= 0.99)
{
if (type == 0)
{
type = 1;
gtk_progress_bar_set_orientation ((GtkProgressBar *) sess->gui->bar,
GTK_PROGRESS_RIGHT_TO_LEFT);
} else
{
type = 0;
gtk_progress_bar_set_orientation ((GtkProgressBar *) sess->gui->bar,
GTK_PROGRESS_LEFT_TO_RIGHT);
}
pos = 0.05;
}
gtk_progress_bar_update ((GtkProgressBar *) sess->gui->bar, pos);
return 1;
}
static int gtkProgressBarMapMethod(Ihandle* ih)
{
ih->handle = gtk_progress_bar_new();
if (!ih->handle)
return IUP_ERROR;
/* add to the parent, all GTK controls must call this. */
iupgtkAddToParent(ih);
gtk_widget_realize(ih->handle);
if (iupStrEqualNoCase(iupAttribGetStr(ih, "ORIENTATION"), "VERTICAL"))
{
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_orientable_set_orientation(GTK_ORIENTABLE(ih->handle), GTK_ORIENTATION_VERTICAL);
gtk_progress_bar_set_inverted(GTK_PROGRESS_BAR(ih->handle), TRUE);
#else
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(ih->handle), GTK_PROGRESS_BOTTOM_TO_TOP);
#endif
if (ih->userheight < ih->userwidth)
{
int tmp = ih->userheight;
ih->userheight = ih->userwidth;
ih->userwidth = tmp;
}
}
else
{
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_orientable_set_orientation(GTK_ORIENTABLE(ih->handle), GTK_ORIENTATION_HORIZONTAL);
#else
gtk_progress_bar_set_orientation((GtkProgressBar*)ih->handle, GTK_PROGRESS_LEFT_TO_RIGHT);
#endif
}
if (iupAttribGetBoolean(ih, "MARQUEE"))
{
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_progress_bar_pulse(GTK_PROGRESS_BAR(ih->handle));
#else
gtk_progress_set_activity_mode((GtkProgress*)ih->handle, TRUE);
#endif
ih->data->marquee = 1;
ih->data->timer = IupTimer();
IupSetCallback(ih->data->timer, "ACTION_CB", (Icallback)gtkProgressBarTimeCb);
IupSetAttribute(ih->data->timer, "TIME", "100");
iupAttribSet(ih->data->timer, "_IUP_PROGRESSBAR", (char*)ih);
gtk_progress_bar_set_pulse_step((GtkProgressBar*)ih->handle, 0.02);
}
else
ih->data->marquee = 0;
return IUP_NOERROR;
}
static void toggle_orientation(GtkWidget *widget, ProgressData *pdata){
switch(gtk_progress_bar_get_orientation(GTK_PROGRESS_BAR(pdata->pbar))){
case GTK_PROGRESS_LEFT_TO_RIGHT:
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(pdata->pbar), GTK_PROGRESS_RIGHT_TO_LEFT);
break;
case GTK_PROGRESS_RIGHT_TO_LEFT:
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(pdata->pbar), GTK_PROGRESS_LEFT_TO_RIGHT);
break;
default:
;
}
}
void cgraphics_progress_set_orientation(widget_t *widget, int flags)
{
// TODO: merge the new orient flags into the current flags
if(flags & cProgressRightLeft) {
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(widget->native), GTK_PROGRESS_RIGHT_TO_LEFT);
} else if(flags & cProgressBottomTop) {
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(widget->native), GTK_PROGRESS_BOTTOM_TO_TOP);
} else if(flags & cProgressTopBottom) {
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(widget->native), GTK_PROGRESS_TOP_TO_BOTTOM);
} else {
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(widget->native), GTK_PROGRESS_LEFT_TO_RIGHT);
}
}
static t_battmon *
battmon_new(void)
{
t_battmon *battmon;
battmon = g_new(t_battmon, 1);
init_options(&(battmon->options));
battmon->low = FALSE;
battmon->critical = FALSE;
battmon->vbox = gtk_vbox_new(FALSE, 0);
gtk_widget_show(battmon->vbox);
gtk_container_set_border_width(GTK_CONTAINER(battmon->vbox), border_width);
battmon->battstatus = gtk_progress_bar_new();
gtk_widget_show(battmon->battstatus);
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(battmon->battstatus), GTK_PROGRESS_LEFT_TO_RIGHT);
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(battmon->battstatus), 0.0);
battmon->ebox = gtk_event_box_new();
gtk_widget_show(battmon->ebox);
gtk_container_add(GTK_CONTAINER(battmon->ebox), battmon->battstatus);
gtk_box_pack_start(GTK_BOX(battmon->vbox), battmon->ebox, FALSE, FALSE, 0);
battmon->timeoutid = 0;
battmon->flag = FALSE;
return(battmon);
}
int main (int argc, char **argv)
{
GtkWidget *window = NULL;
GtkWidget *pbar = NULL;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
pbar = mtx_progress_bar_new ();
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(pbar),
GTK_PROGRESS_BOTTOM_TO_TOP);
gtk_container_add (GTK_CONTAINER (window), pbar);
/*gtk_widget_realize(pbar);*/
gtk_widget_show_all (window);
gtk_timeout_add(30,(GtkFunction)update_pbar,(gpointer)pbar);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
gtk_main ();
return 0;
}
bool wxGauge::Create( wxWindow *parent,
wxWindowID id,
int range,
const wxPoint& pos,
const wxSize& size,
long style,
const wxValidator& validator,
const wxString& name )
{
m_needParent = true;
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxGauge creation failed") );
return false;
}
m_rangeMax = range;
m_widget = gtk_progress_bar_new();
if ( style & wxGA_VERTICAL )
{
gtk_progress_bar_set_orientation( GTK_PROGRESS_BAR(m_widget),
GTK_PROGRESS_BOTTOM_TO_TOP );
}
m_parent->DoAddChild( this );
PostCreation(size);
SetInitialSize(size);
return true;
}
int main (int argc, char **argv)
{
GtkWidget *window = NULL;
GtkWidget *pbar = NULL;
gint timeout = 0;
#if GLIB_MINOR_VERSION < 32
g_thread_init(NULL);
#endif
gdk_threads_init();
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
pbar = mtx_progress_bar_new ();
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(pbar),
GTK_PROGRESS_BOTTOM_TO_TOP);
gtk_container_add (GTK_CONTAINER (window), pbar);
/*gtk_widget_realize(pbar);*/
gtk_widget_show_all (window);
timeout = g_timeout_add(30,(GSourceFunc)update_pbar_wrapper,(gpointer)pbar);
g_signal_connect (window, "delete_event",
G_CALLBACK (close_demo), GINT_TO_POINTER(timeout));
g_signal_connect (window, "destroy_event",
G_CALLBACK (close_demo), GINT_TO_POINTER(timeout));
gdk_threads_enter();
gtk_main ();
gdk_threads_leave();
return 0;
}
void iceb_gdite(class iceb_gdite_data *data,int metka_bar,GtkWidget *wpredok)
{
data->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_resizable(GTK_WINDOW(data->window),FALSE); /*запрет на изменение размеров окна*/
gtk_window_set_deletable(GTK_WINDOW(data->window),FALSE); /*Выключить кнопку close в рамке окна*/
if(wpredok != NULL)
{
// gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
//Удерживать окно над породившем его окном всегда
gtk_window_set_transient_for(GTK_WINDOW(data->window),GTK_WINDOW(wpredok));
}
//Закрыть окно если окно предок удалено
gtk_window_set_destroy_with_parent(GTK_WINDOW(data->window),TRUE);
/*Окно поверх всех окон*/
gtk_window_set_keep_above(GTK_WINDOW(data->window),TRUE);
char bros[312];
sprintf(bros,"%s %s",name_system,gettext("Ждите !"));
gtk_window_set_title (GTK_WINDOW (data->window),bros);
gtk_container_set_border_width (GTK_CONTAINER (data->window), 5);
GtkWidget *vbox=gtk_vbox_new(FALSE, 2);
gtk_container_add (GTK_CONTAINER (data->window), vbox);
GtkWidget *label=gtk_label_new(gettext("Ждите !"));
GdkColor color;
gdk_color_parse("red",&color);
gtk_widget_modify_fg(label,GTK_STATE_NORMAL,&color);
gtk_widget_set_size_request(GTK_WIDGET(label),300,-1);
gtk_box_pack_start(GTK_BOX (vbox), label, TRUE, TRUE, 0);
if(metka_bar == 0)
{
data->bar=gtk_progress_bar_new();
gtk_progress_bar_set_bar_style(GTK_PROGRESS_BAR(data->bar),GTK_PROGRESS_CONTINUOUS);
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(data->bar),GTK_PROGRESS_LEFT_TO_RIGHT);
gtk_box_pack_start (GTK_BOX (vbox), data->bar, FALSE, FALSE, 2);
}
//gtk_window_set_default_size (GTK_WINDOW (data->window),300,-1);
gtk_window_set_position( GTK_WINDOW(data->window),ICEB_POS_CENTER);
gtk_widget_show_all(data->window);
gdk_window_set_cursor(data->window->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
iceb_refresh();
}
GtkWidget* ProgressBar(){
progress = gtk_progress_bar_new();
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progress),0);
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(progress), "0%");
gtk_progress_bar_set_orientation(
GTK_PROGRESS_BAR(progress),
GTK_PROGRESS_LEFT_TO_RIGHT
);
return progress;
}
void sal_gui_progress(vm_t *vm)
{
obj_t *ptr;
GtkWidget *pb;
pb = gtk_progress_bar_new();
gtk_progress_bar_set_orientation(
GTK_PROGRESS_BAR(pb),
GTK_PROGRESS_LEFT_TO_RIGHT);
ptr = pointer_new("gui-progress", NULL);
ptr->data = pb;
sal_stack_push(vm->stack, ptr);
}
GimmixTooltip *gimmix_tooltip_new (void)
{
GimmixTooltip *tooltip;
GtkWidget *label1;
GtkWidget *label2;
/* main tooltip window */
tooltip = g_malloc (sizeof(GimmixTooltip));
tooltip->window = gtk_window_new (GTK_WINDOW_POPUP);
gtk_window_set_resizable (GTK_WINDOW(tooltip->window), FALSE);
gtk_window_set_decorated (GTK_WINDOW(tooltip->window), FALSE);
gtk_window_set_skip_taskbar_hint (GTK_WINDOW(tooltip->window), TRUE);
gtk_window_set_skip_pager_hint (GTK_WINDOW(tooltip->window), TRUE);
/* the two main layout boxes */
tooltip->hbox = gtk_hbox_new (FALSE, 4);
tooltip->vbox = gtk_vbox_new (FALSE, 0);
/* pack the boxes */
gtk_container_add (GTK_CONTAINER(tooltip->window), tooltip->hbox);
gtk_box_pack_end (GTK_BOX(tooltip->hbox), tooltip->vbox, FALSE, FALSE, 2);
/* tooltip icon */
tooltip->icon = gtk_image_new_from_pixbuf (NULL);
gtk_misc_set_padding (GTK_MISC(tooltip->icon), 4, 4);
gtk_box_pack_start (GTK_BOX(tooltip->hbox), tooltip->icon, TRUE, TRUE, 0);
/* labels */
label1 = gtk_label_new (NULL);
g_object_set (G_OBJECT(label1), "use-markup", TRUE, NULL);
gtk_box_pack_start (GTK_BOX(tooltip->vbox), label1, TRUE, FALSE, 1);
gtk_misc_set_alignment (GTK_MISC(label1), 0, 0);
label2 = gtk_label_new (NULL);
g_object_set (G_OBJECT(label2), "use-markup", TRUE, NULL);
gtk_box_pack_start (GTK_BOX(tooltip->vbox), label2, TRUE, FALSE, 1);
gtk_misc_set_alignment (GTK_MISC(label2), 0, 0);
/* And finally, the progress meter */
tooltip->progressbar = gtk_progress_bar_new ();
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR(tooltip->progressbar), GTK_PROGRESS_LEFT_TO_RIGHT);
gtk_widget_set_size_request (tooltip->progressbar, -1, 16);
gtk_box_pack_start (GTK_BOX(tooltip->vbox), tooltip->progressbar, TRUE, FALSE, 2);
return tooltip;
}
static GtkWidget *
progressbar_new(GladeXML *xml, GladeWidgetInfo *info)
{
GtkWidget *ret = gtk_progress_bar_new();
GList *tmp;
gfloat value = 0, lower = 0, upper = 100;
gfloat xalign = 0.5, yalign = 0.5;
for (tmp = info->attributes; tmp; tmp = tmp->next) {
GladeAttribute *attr = tmp->data;
if (!strcmp(attr->name, "value"))
value = g_strtod(attr->value, NULL);
else if (!strcmp(attr->name, "lower"))
lower = g_strtod(attr->value, NULL);
else if (!strcmp(attr->name, "upper"))
upper = g_strtod(attr->value, NULL);
else if (!strcmp(attr->name, "activity_mode"))
gtk_progress_set_activity_mode(GTK_PROGRESS(ret),
attr->value[0]=='T');
else if (!strcmp(attr->name, "bar_style"))
gtk_progress_bar_set_bar_style(GTK_PROGRESS_BAR(ret),
glade_enum_from_string(GTK_TYPE_PROGRESS_BAR_STYLE,
attr->value));
else if (!strcmp(attr->name, "orientation"))
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(ret),
glade_enum_from_string(
GTK_TYPE_PROGRESS_BAR_ORIENTATION, attr->value));
else if (!strcmp(attr->name, "show_text"))
gtk_progress_set_show_text(GTK_PROGRESS(ret),
attr->value[0] == 'T');
else if (!strcmp(attr->name, "text_xalign"))
xalign = g_strtod(attr->value, NULL);
else if (!strcmp(attr->name, "text_yalign"))
yalign = g_strtod(attr->value, NULL);
else if (!strcmp(attr->name, "format"))
gtk_progress_set_format_string(GTK_PROGRESS(ret),
attr->value);
}
gtk_progress_configure(GTK_PROGRESS(ret), value, lower, upper);
gtk_progress_set_text_alignment(GTK_PROGRESS(ret), xalign, yalign);
return ret;
}
void create_scene_detection_window()
{
GtkWidget *vbox, *button;
scene_detection_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
vbox = gtk_vbox_new(FALSE, 5);
gtk_window_set_title (GTK_WINDOW(scene_detection_window),
"Linux Video Studio - Scene detection");
gtk_container_set_border_width (GTK_CONTAINER (scene_detection_window), 20);
scene_detection_status_label = gtk_label_new(" ");
gtk_box_pack_start (GTK_BOX (vbox), scene_detection_status_label,
FALSE,FALSE, 10);
gtk_widget_show (scene_detection_status_label);
scene_detection_bar = gtk_progress_bar_new();
gtk_box_pack_start (GTK_BOX (vbox), scene_detection_bar,
FALSE, FALSE, 0);
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(scene_detection_bar),
GTK_PROGRESS_LEFT_TO_RIGHT);
gtk_progress_bar_set_bar_style(GTK_PROGRESS_BAR(scene_detection_bar),
GTK_PROGRESS_CONTINUOUS);
gtk_progress_set_show_text(GTK_PROGRESS(scene_detection_bar), 1);
gtk_progress_set_format_string(GTK_PROGRESS(scene_detection_bar), "%p\%");
gtk_widget_show(scene_detection_bar);
button = gtk_button_new();
gtk_signal_connect(GTK_OBJECT(button), "clicked",
(GtkSignalFunc)stop_scene_detection_process, NULL);
scene_detection_button_label = gtk_label_new(" Cancel ");
gtk_container_add (GTK_CONTAINER (button), scene_detection_button_label);
gtk_widget_show(scene_detection_button_label);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
gtk_container_add (GTK_CONTAINER (scene_detection_window), vbox);
gtk_widget_show(vbox);
gtk_grab_add(scene_detection_window);
gtk_widget_show(scene_detection_window);
}
bool wxGauge::Create( wxWindow *parent,
wxWindowID id,
int range,
const wxPoint& pos,
const wxSize& size,
long style,
const wxValidator& validator,
const wxString& name )
{
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxGauge creation failed") );
return false;
}
m_rangeMax = range;
m_widget = gtk_progress_bar_new();
g_object_ref(m_widget);
if ( style & wxGA_VERTICAL )
{
#ifdef __WXGTK3__
gtk_orientable_set_orientation(GTK_ORIENTABLE(m_widget), GTK_ORIENTATION_VERTICAL);
gtk_progress_bar_set_inverted(GTK_PROGRESS_BAR(m_widget), true);
#else
gtk_progress_bar_set_orientation( GTK_PROGRESS_BAR(m_widget),
GTK_PROGRESS_BOTTOM_TO_TOP );
#endif
}
// when using the gauge in indeterminate mode, we need this:
gtk_progress_bar_set_pulse_step(GTK_PROGRESS_BAR (m_widget), 0.05);
m_parent->DoAddChild( this );
PostCreation(size);
SetInitialSize(size);
return true;
}
int rest_oth_r(class rest_oth_data *datap)
{
printf("rest_oth_r-Начало работы\n");
iceb_u_str soob;
char strsql[300];
rest_oth_r_data data;
data.rk=datap;
data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER);
gtk_window_set_default_size (GTK_WINDOW (data.window),400,-1);
sprintf(strsql,"%s %s",name_system,gettext("Отчёт по оплаченным счетам"));
gtk_window_set_title(GTK_WINDOW(data.window),strsql);
gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL);
gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(rest_oth_r_key_press),&data);
GtkWidget *vbox=gtk_vbox_new(FALSE, 2);
gtk_container_add(GTK_CONTAINER(data.window), vbox);
data.label=gtk_label_new(gettext("Ждите !!!"));
gtk_box_pack_start(GTK_BOX(vbox),data.label,FALSE,FALSE,0);
soob.new_plus(strsql);
sprintf(strsql,"%s %s %s => %s %s",gettext("Расчет за период"),
data.rk->datan.ravno(),
data.rk->vremn.ravno_time(),
data.rk->datak.ravno(),
data.rk->vremk.ravno_time_end());
soob.new_plus(strsql);
GtkWidget *label=gtk_label_new(soob.ravno_toutf());
gtk_box_pack_start(GTK_BOX(vbox),label,FALSE,FALSE,0);
data.view=gtk_text_view_new();
gtk_widget_set_usize(GTK_WIDGET(data.view),400,300);
gtk_text_view_set_editable(GTK_TEXT_VIEW(data.view),FALSE); //Запрет на редактирование текста
PangoFontDescription *font_pango=pango_font_description_from_string("Nimbus Mono L, Bold 10");
gtk_widget_modify_font(GTK_WIDGET(data.view),font_pango);
pango_font_description_free(font_pango);
data.buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(data.view));
GtkWidget *sw=gtk_scrolled_window_new(NULL,NULL);
//gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
//gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_ALWAYS,GTK_POLICY_ALWAYS);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(sw),data.view);
data.bar=gtk_progress_bar_new();
gtk_progress_bar_set_bar_style(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_CONTINUOUS);
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_LEFT_TO_RIGHT);
gtk_box_pack_start (GTK_BOX (vbox), data.bar, FALSE, FALSE, 2);
sprintf(strsql,"F10 %s",gettext("Выход"));
data.knopka=gtk_button_new_with_label(strsql);
GtkTooltips *tooltops=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltops,data.knopka,gettext("Завершение работы в этом окне"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka),"clicked",GTK_SIGNAL_FUNC(rest_oth_r_v_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka),(gpointer)0);
gtk_box_pack_start (GTK_BOX (vbox), data.knopka, FALSE, FALSE, 2);
gtk_widget_set_sensitive(GTK_WIDGET(data.knopka),FALSE);//Недоступна
gtk_widget_show_all(data.window);
//gtk_window_set_decorated(GTK_WINDOW(data.window),FALSE); //Убирает рамку вокруг окна
gtk_idle_add((GtkFunction)rest_oth_r1,&data);
gtk_main();
//if(data.voz == 0)
// iceb_rabfil(&data.imaf,&data.naim,"",config_dev.metka_klav,NULL);
return(data.voz);
}
int taxi_oth_r(class taxi_oth_data *data)
{
char strsql[300];
short dn,mn,gn;
short dk,mk,gk;
short hasn=0,minn=0,sekn=0;
short hask=0,mink=0,sekk=0;
iceb_u_rsdat(&dn,&mn,&gn,data->datn.ravno(),1);
iceb_u_rsdat(&dk,&mk,&gk,data->datk.ravno(),1);
iceb_u_rstime(&hasn,&minn,&sekn,data->vremn.ravno());
if(data->vremk.getdlinna() <= 1)
{
hask=24;
mink=0;
sekk=0;
}
else
iceb_u_rstime(&hask,&mink,&sekk,data->vremk.ravno());
if(data->metkarr == 1) //По дате заказа
sprintf(strsql,"select kz,kv,suma,ktoi,kodk from Taxizak where \
(datz='%d-%d-%d' and vremz >= '%02d:%02d:%02d') or \
(datz='%d-%d-%d' and vremz <= '%02d:%02d:%02d') or \
(datz > '%d-%d-%d' and datz < '%d-%d-%d') order by kz asc",
gn,mn,dn,hasn,minn,sekn,
gk,mk,dk,hask,mink,sekk,
gn,mn,dn,gk,mk,dk);
if(data->metkarr == 0) //По дате записи заказа
{
struct tm bf;
bf.tm_mday=(int)dn;
bf.tm_mon=(int)(mn-1);
bf.tm_year=(int)(gn-1900);
bf.tm_hour=(int)hasn;
bf.tm_min=(int)minn;
bf.tm_sec=sekn;
time_t vremn=mktime(&bf);
bf.tm_mday=(int)dk;
bf.tm_mon=(int)(mk-1);
bf.tm_year=(int)(gk-1900);
bf.tm_hour=(int)hask;
bf.tm_min=(int)mink;
bf.tm_sec=sekk;
time_t vremk=mktime(&bf);
sprintf(strsql,"select kz,kv,suma,ktoi,kodk from Taxizak where \
vrem >= %ld and vrem <= %ld",vremn,vremk);
}
printf("taxi_oth_r-%s\n",strsql);
if((data->kolstr=data->cur.make_cursor(&bd,strsql)) < 0)
{
iceb_msql_error(&bd,gettext("Ошибка создания курсора !"),strsql,data->window);
return(1);
}
data->window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position( GTK_WINDOW(data->window),ICEB_POS_CENTER);
sprintf(strsql,"%s %s",NAME_SYSTEM,iceb_u_toutf("Расчет отчетов."));
gtk_window_set_title(GTK_WINDOW(data->window),strsql);
//gtk_signal_connect(GTK_OBJECT(data->window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL);
gtk_signal_connect(GTK_OBJECT(data->window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
GtkWidget *vbox=gtk_vbox_new(FALSE, 2);
gtk_container_add(GTK_CONTAINER(data->window), vbox);
GtkWidget *label=gtk_label_new(gettext("Ждите !!!"));
gtk_box_pack_start(GTK_BOX(vbox),label,FALSE,FALSE,0);
label=gtk_label_new(iceb_u_toutf("Расчет отчетов по водителям и операторам.."));
gtk_box_pack_start(GTK_BOX(vbox),label,FALSE,FALSE,0);
//GtkObject *adjustment=gtk_adjustment_new(0.,1.,data->kolstr,0.,0.,0.);
//data->bar=gtk_progress_bar_new_with_adjustment(GTK_ADJUSTMENT(adjustment));
data->bar=gtk_progress_bar_new();
gtk_progress_bar_set_bar_style(GTK_PROGRESS_BAR(data->bar),GTK_PROGRESS_CONTINUOUS);
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(data->bar),GTK_PROGRESS_LEFT_TO_RIGHT);
gtk_box_pack_start (GTK_BOX (vbox), data->bar, FALSE, FALSE, 2);
gtk_idle_add((GtkFunction)taxi_oth_r1,data);
gtk_widget_show_all(data->window);
gtk_main();
return(0);
}
//____________________________________________________
SliderDemoWidget::SliderDemoWidget( void )
{
// main widget
GtkWidget* mainWidget( gtk_hbox_new( false, 0 ) );
gtk_box_set_spacing( GTK_BOX( mainWidget ), 5 );
setWidget( mainWidget );
// setup
setName( "Sliders" );
setComments( "Shows the appearance of sliders, progress bars and scrollbars" );
setIconName( "measure" );
realize();
// horizontal sliders
{
// frame
GtkWidget* frame( gtk_frame_new( "Horizontal" ) );
gtk_box_pack_start( GTK_BOX( mainWidget ), frame, true, true, 0 );
gtk_widget_show( frame );
// container
GtkWidget* box( gtk_vbox_new( false, 0 ) );
gtk_container_set_border_width( GTK_CONTAINER( box ), 5 );
gtk_box_set_spacing( GTK_BOX( box ), 2 );
gtk_widget_show( box );
gtk_container_add( GTK_CONTAINER( frame ), box );
// scale
_horizontalSliders._scale = gtk_hscale_new_with_range( 0, 100, 1 );
gtk_scale_set_draw_value( GTK_SCALE( _horizontalSliders._scale ), false );
gtk_box_pack_start( GTK_BOX( box ), _horizontalSliders._scale, false, true, 0 );
gtk_widget_show( _horizontalSliders._scale );
// progress entry
_horizontalSliders._progressEntry = gtk_entry_new();
gtk_entry_set_text( GTK_ENTRY( _horizontalSliders._progressEntry ), "Progress Bar Entry" );
gtk_entry_set_progress_fraction( GTK_ENTRY( _horizontalSliders._progressEntry ), 0.25 );
gtk_box_pack_start( GTK_BOX( box ), _horizontalSliders._progressEntry, false, true, 0 );
gtk_widget_show( _horizontalSliders._progressEntry );
// progress bar
_horizontalSliders._progressBar = gtk_progress_bar_new();
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_orientable_set_orientation( GTK_ORIENTABLE( _horizontalSliders._progressBar ), GTK_ORIENTATION_HORIZONTAL );
#else
gtk_progress_bar_set_orientation( GTK_PROGRESS_BAR( _horizontalSliders._progressBar ), GTK_PROGRESS_LEFT_TO_RIGHT );
#endif
gtk_progress_set_show_text( GTK_PROGRESS( _horizontalSliders._progressBar ), true );
gtk_box_pack_start( GTK_BOX( box ), _horizontalSliders._progressBar, false, true, 0 );
gtk_widget_show( _horizontalSliders._progressBar );
// pulse progressBar
_pulseProgressBar = gtk_progress_bar_new();
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_orientable_set_orientation( GTK_ORIENTABLE( _pulseProgressBar ), GTK_ORIENTATION_HORIZONTAL );
#else
gtk_progress_bar_set_orientation( GTK_PROGRESS_BAR( _pulseProgressBar ), GTK_PROGRESS_LEFT_TO_RIGHT );
#endif
gtk_progress_bar_set_pulse_step( GTK_PROGRESS_BAR( _pulseProgressBar ), 0.01 );
gtk_box_pack_start( GTK_BOX( box ), _pulseProgressBar, false, true, 0 );
gtk_widget_show( _pulseProgressBar );
// scrollbar
GtkAdjustment* adjustment( GTK_ADJUSTMENT( gtk_adjustment_new( 25, 0, 110, 1, 1, 10 ) ) );
_horizontalSliders._scrollBar = gtk_hscrollbar_new( adjustment );
gtk_box_pack_start( GTK_BOX( box ), _horizontalSliders._scrollBar, false, true, 0 );
gtk_widget_show( _horizontalSliders._scrollBar );
}
// vertical sliders
{
// frame
GtkWidget* frame( gtk_frame_new( "Vertical" ) );
gtk_box_pack_start( GTK_BOX( mainWidget ), frame, false, true, 0 );
gtk_widget_show( frame );
// container
GtkWidget* box( gtk_hbox_new( false, 0 ) );
gtk_container_set_border_width( GTK_CONTAINER( box ), 5 );
gtk_box_set_spacing( GTK_BOX( box ), 5 );
gtk_widget_show( box );
gtk_container_add( GTK_CONTAINER( frame ), box );
// scale
_verticalSliders._scale = gtk_vscale_new_with_range( 0, 100, 1 );
gtk_scale_set_draw_value( GTK_SCALE( _verticalSliders._scale ), false );
gtk_box_pack_start( GTK_BOX( box ), _verticalSliders._scale, false, true, 0 );
gtk_widget_show( _verticalSliders._scale );
// progress bar
_verticalSliders._progressBar = gtk_progress_bar_new();
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_orientable_set_orientation( GTK_ORIENTABLE( _verticalSliders._progressBar ), GTK_ORIENTATION_VERTICAL );
#else
gtk_progress_bar_set_orientation( GTK_PROGRESS_BAR( _verticalSliders._progressBar ), GTK_PROGRESS_BOTTOM_TO_TOP );
#endif
gtk_progress_set_show_text( GTK_PROGRESS( _verticalSliders._progressBar ), true );
gtk_box_pack_start( GTK_BOX( box ), _verticalSliders._progressBar, false, true, 0 );
gtk_widget_show( _verticalSliders._progressBar );
// scrollbar
GtkAdjustment* adjustment( GTK_ADJUSTMENT( gtk_adjustment_new( 25, 0, 110, 1, 1, 10 ) ) );
_verticalSliders._scrollBar = gtk_vscrollbar_new( adjustment );
gtk_box_pack_start( GTK_BOX( box ), _verticalSliders._scrollBar, false, true, 0 );
gtk_widget_show( _verticalSliders._scrollBar );
}
// connections
connect( G_OBJECT( _horizontalSliders._scale ), "value-changed", GCallback( valueChanged ), this );
connect( G_OBJECT( _horizontalSliders._scrollBar ), "value-changed", GCallback( valueChanged ), this );
connect( G_OBJECT( _verticalSliders._scale ), "value-changed", GCallback( valueChanged ), this );
connect( G_OBJECT( _verticalSliders._scrollBar ), "value-changed", GCallback( valueChanged ), this );
// Initialize all
gtk_range_set_value( GTK_RANGE( _verticalSliders._scale ), 25 );
}
GtkWidget*
create_main_window (void)
{
GtkWidget *main_window;
GdkPixbuf *main_window_icon_pixbuf;
GtkWidget *hbox12;
GtkWidget *vbox30;
GtkWidget *expander1;
GtkWidget *hbox6;
GtkWidget *label11;
GtkWidget *vbox5;
GtkWidget *hbox7;
GtkWidget *label12;
GtkWidget *hbox9;
GtkWidget *server;
GtkWidget *connect;
GtkWidget *alignment7;
GtkWidget *hbox11;
GtkWidget *image7;
GtkWidget *label18;
GtkWidget *login_at_connect;
GtkWidget *hbox8;
GtkWidget *label14;
GtkWidget *table1;
GtkWidget *label13;
GtkWidget *label15;
GtkWidget *login;
GtkWidget *password;
GtkWidget *label17;
GtkWidget *label10;
GtkWidget *hbox1;
GtkWidget *frame1;
GtkWidget *alignment3;
GtkWidget *console_tabs;
GtkWidget *alignment4;
GtkWidget *vbox1;
GtkWidget *console_scroll;
GtkWidget *console_view;
GtkWidget *label4;
GtkWidget *hbox2;
GtkWidget *image1;
GtkWidget *cmd_entry;
GtkWidget *btn_cmdSend;
GtkWidget *label6;
GtkWidget *alignment5;
GtkWidget *pipe_scroll;
GtkWidget *pipe_view;
GtkWidget *label7;
GtkWidget *label2;
GtkWidget *vbox2;
GtkWidget *frame2;
GtkWidget *alignment2;
GtkWidget *vbox3;
GtkWidget *ctrlButton_0;
GtkWidget *ctrlButton_1;
GtkWidget *ctrlButton_2;
GtkWidget *ctrlButton_3;
GtkWidget *alignment6;
GtkWidget *hbox3;
GtkWidget *image2;
GtkWidget *hbox4;
GtkWidget *queue_progress;
GtkWidget *queue_usage;
GtkWidget *label9;
GtkWidget *image3;
GtkWidget *hbox5;
GtkWidget *belts_progress;
GtkWidget *belts_usage;
GtkWidget *ctrlButton_4;
GtkWidget *ctrlButton_5;
GtkWidget *ctrlButton_6;
GtkWidget *label5;
GtkWidget *label3;
GtkWidget *label8;
GtkWidget *image6;
main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (main_window), _("WebTester Server Console"));
gtk_window_set_resizable (GTK_WINDOW (main_window), FALSE);
main_window_icon_pixbuf = create_pixbuf ("wt32.png");
if (main_window_icon_pixbuf)
{
gtk_window_set_icon (GTK_WINDOW (main_window), main_window_icon_pixbuf);
gdk_pixbuf_unref (main_window_icon_pixbuf);
}
hbox12 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox12);
gtk_container_add (GTK_CONTAINER (main_window), hbox12);
vbox30 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox30);
gtk_box_pack_start (GTK_BOX (hbox12), vbox30, TRUE, TRUE, 0);
expander1 = gtk_expander_new (NULL);
gtk_widget_show (expander1);
gtk_box_pack_start (GTK_BOX (vbox30), expander1, FALSE, TRUE, 0);
gtk_widget_set_size_request (expander1, 640, -1);
gtk_expander_set_expanded (GTK_EXPANDER (expander1), TRUE);
hbox6 = gtk_hbox_new (FALSE, 2);
gtk_widget_show (hbox6);
gtk_container_add (GTK_CONTAINER (expander1), hbox6);
label11 = gtk_label_new ("");
gtk_widget_show (label11);
gtk_box_pack_start (GTK_BOX (hbox6), label11, FALSE, FALSE, 0);
gtk_widget_set_size_request (label11, 16, -1);
vbox5 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox5);
gtk_box_pack_start (GTK_BOX (hbox6), vbox5, FALSE, TRUE, 0);
hbox7 = gtk_hbox_new (FALSE, 6);
gtk_widget_show (hbox7);
gtk_box_pack_start (GTK_BOX (vbox5), hbox7, TRUE, TRUE, 0);
label12 = gtk_label_new (_("Server:Port"));
gtk_widget_show (label12);
gtk_box_pack_start (GTK_BOX (hbox7), label12, FALSE, FALSE, 0);
hbox9 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox9);
gtk_box_pack_start (GTK_BOX (hbox7), hbox9, TRUE, TRUE, 0);
server = gtk_entry_new ();
gtk_widget_show (server);
gtk_box_pack_start (GTK_BOX (hbox9), server, TRUE, TRUE, 0);
connect = gtk_toggle_button_new ();
gtk_widget_show (connect);
gtk_box_pack_start (GTK_BOX (hbox9), connect, FALSE, FALSE, 0);
alignment7 = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_widget_show (alignment7);
gtk_container_add (GTK_CONTAINER (connect), alignment7);
hbox11 = gtk_hbox_new (FALSE, 2);
gtk_widget_show (hbox11);
gtk_container_add (GTK_CONTAINER (alignment7), hbox11);
image7 = create_pixmap (main_window, "connect.png");
gtk_widget_show (image7);
gtk_box_pack_start (GTK_BOX (hbox11), image7, FALSE, FALSE, 0);
label18 = gtk_label_new (_("Connect"));
gtk_widget_show (label18);
gtk_box_pack_start (GTK_BOX (hbox11), label18, FALSE, FALSE, 0);
login_at_connect = gtk_check_button_new_with_mnemonic (_("Login at connect"));
gtk_widget_show (login_at_connect);
gtk_box_pack_start (GTK_BOX (vbox5), login_at_connect, FALSE, FALSE, 0);
hbox8 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox8);
gtk_box_pack_start (GTK_BOX (hbox6), hbox8, TRUE, TRUE, 0);
label14 = gtk_label_new ("");
gtk_widget_show (label14);
gtk_box_pack_start (GTK_BOX (hbox8), label14, FALSE, FALSE, 0);
gtk_widget_set_size_request (label14, 8, -1);
table1 = gtk_table_new (2, 2, FALSE);
gtk_widget_show (table1);
gtk_box_pack_start (GTK_BOX (hbox8), table1, TRUE, TRUE, 0);
gtk_table_set_col_spacings (GTK_TABLE (table1), 4);
label13 = gtk_label_new (_("Login"));
gtk_widget_show (label13);
gtk_table_attach (GTK_TABLE (table1), label13, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label13), 0, 0.5);
label15 = gtk_label_new (_("Password"));
gtk_widget_show (label15);
gtk_table_attach (GTK_TABLE (table1), label15, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label15), 0, 0.5);
login = gtk_entry_new ();
gtk_widget_show (login);
gtk_table_attach (GTK_TABLE (table1), login, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_widget_set_sensitive (login, FALSE);
password = gtk_entry_new ();
gtk_widget_show (password);
gtk_table_attach (GTK_TABLE (table1), password, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_widget_set_sensitive (password, FALSE);
gtk_entry_set_visibility (GTK_ENTRY (password), FALSE);
label17 = gtk_label_new ("");
gtk_widget_show (label17);
gtk_box_pack_start (GTK_BOX (hbox8), label17, FALSE, FALSE, 0);
gtk_widget_set_size_request (label17, 8, -1);
label10 = gtk_label_new (_("Connection"));
gtk_widget_show (label10);
gtk_expander_set_label_widget (GTK_EXPANDER (expander1), label10);
hbox1 = gtk_hbox_new (FALSE, 2);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox30), hbox1, TRUE, TRUE, 0);
frame1 = gtk_frame_new (NULL);
gtk_widget_show (frame1);
gtk_box_pack_start (GTK_BOX (hbox1), frame1, TRUE, TRUE, 0);
gtk_frame_set_label_align (GTK_FRAME (frame1), 0.5, 0.5);
alignment3 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment3);
gtk_container_add (GTK_CONTAINER (frame1), alignment3);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment3), 2, 4, 4, 4);
console_tabs = gtk_notebook_new ();
gtk_widget_show (console_tabs);
gtk_container_add (GTK_CONTAINER (alignment3), console_tabs);
alignment4 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment4);
gtk_container_add (GTK_CONTAINER (console_tabs), alignment4);
gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (console_tabs), alignment4,
TRUE, TRUE, GTK_PACK_START);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment4), 2, 2, 2, 2);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (alignment4), vbox1);
console_scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (console_scroll);
gtk_box_pack_start (GTK_BOX (vbox1), console_scroll, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (console_scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (console_scroll), GTK_SHADOW_IN);
console_view = gtk_text_view_new ();
gtk_widget_show (console_view);
gtk_container_add (GTK_CONTAINER (console_scroll), console_view);
gtk_text_view_set_editable (GTK_TEXT_VIEW (console_view), FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (console_view), GTK_WRAP_CHAR);
gtk_text_view_set_pixels_above_lines (GTK_TEXT_VIEW (console_view), 4);
gtk_text_view_set_pixels_below_lines (GTK_TEXT_VIEW (console_view), 4);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (console_view), 4);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (console_view), 4);
label4 = gtk_label_new ("");
gtk_widget_show (label4);
gtk_box_pack_start (GTK_BOX (vbox1), label4, FALSE, FALSE, 0);
gtk_widget_set_size_request (label4, 360, 3);
hbox2 = gtk_hbox_new (FALSE, 4);
gtk_widget_show (hbox2);
gtk_box_pack_start (GTK_BOX (vbox1), hbox2, FALSE, TRUE, 0);
image1 = create_pixmap (main_window, "go.png");
gtk_widget_show (image1);
gtk_box_pack_start (GTK_BOX (hbox2), image1, FALSE, TRUE, 0);
cmd_entry = gtk_entry_new ();
gtk_widget_show (cmd_entry);
gtk_box_pack_start (GTK_BOX (hbox2), cmd_entry, TRUE, TRUE, 0);
btn_cmdSend = gtk_button_new_with_mnemonic (_("Send"));
gtk_widget_show (btn_cmdSend);
gtk_box_pack_start (GTK_BOX (hbox2), btn_cmdSend, FALSE, FALSE, 0);
label6 = gtk_label_new (_("User's console"));
gtk_widget_show (label6);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (console_tabs), gtk_notebook_get_nth_page (GTK_NOTEBOOK (console_tabs), 0), label6);
alignment5 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment5);
gtk_container_add (GTK_CONTAINER (console_tabs), alignment5);
gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK (console_tabs), alignment5,
TRUE, TRUE, GTK_PACK_START);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment5), 2, 2, 2, 2);
pipe_scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (pipe_scroll);
gtk_container_add (GTK_CONTAINER (alignment5), pipe_scroll);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (pipe_scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (pipe_scroll), GTK_SHADOW_IN);
pipe_view = gtk_text_view_new ();
gtk_widget_show (pipe_view);
gtk_container_add (GTK_CONTAINER (pipe_scroll), pipe_view);
gtk_text_view_set_editable (GTK_TEXT_VIEW (pipe_view), FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (pipe_view), GTK_WRAP_CHAR);
gtk_text_view_set_pixels_above_lines (GTK_TEXT_VIEW (pipe_view), 4);
gtk_text_view_set_pixels_below_lines (GTK_TEXT_VIEW (pipe_view), 4);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (pipe_view), 4);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (pipe_view), 4);
label7 = gtk_label_new (_("Pipe"));
gtk_widget_show (label7);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (console_tabs), gtk_notebook_get_nth_page (GTK_NOTEBOOK (console_tabs), 1), label7);
gtk_label_set_line_wrap (GTK_LABEL (label7), TRUE);
label2 = gtk_label_new (_("<b>WebTester</b> Console"));
gtk_widget_show (label2);
gtk_frame_set_label_widget (GTK_FRAME (frame1), label2);
gtk_label_set_use_markup (GTK_LABEL (label2), TRUE);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
gtk_box_pack_start (GTK_BOX (hbox1), vbox2, FALSE, TRUE, 0);
frame2 = gtk_frame_new (NULL);
gtk_widget_show (frame2);
gtk_box_pack_start (GTK_BOX (vbox2), frame2, TRUE, TRUE, 0);
gtk_frame_set_label_align (GTK_FRAME (frame2), 0.5, 0.5);
alignment2 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment2);
gtk_container_add (GTK_CONTAINER (frame2), alignment2);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment2), 2, 4, 4, 4);
vbox3 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox3);
gtk_container_add (GTK_CONTAINER (alignment2), vbox3);
ctrlButton_0 = gtk_button_new_with_mnemonic (_("(Unassigned)"));
gtk_widget_show (ctrlButton_0);
gtk_box_pack_start (GTK_BOX (vbox3), ctrlButton_0, FALSE, FALSE, 0);
ctrlButton_1 = gtk_button_new_with_mnemonic (_("(Unassigned)"));
gtk_widget_show (ctrlButton_1);
gtk_box_pack_start (GTK_BOX (vbox3), ctrlButton_1, FALSE, FALSE, 0);
ctrlButton_2 = gtk_button_new_with_mnemonic (_("(Unassigned)"));
gtk_widget_show (ctrlButton_2);
gtk_box_pack_start (GTK_BOX (vbox3), ctrlButton_2, FALSE, FALSE, 0);
ctrlButton_3 = gtk_button_new_with_mnemonic (_("(Unassigned)"));
gtk_widget_show (ctrlButton_3);
gtk_box_pack_start (GTK_BOX (vbox3), ctrlButton_3, FALSE, FALSE, 0);
alignment6 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment6);
gtk_box_pack_start (GTK_BOX (vbox3), alignment6, FALSE, FALSE, 0);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment6), 2, 2, 0, 0);
hbox3 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox3);
gtk_container_add (GTK_CONTAINER (alignment6), hbox3);
image2 = create_pixmap (main_window, "queue.png");
gtk_widget_show (image2);
gtk_box_pack_start (GTK_BOX (hbox3), image2, FALSE, TRUE, 0);
hbox4 = gtk_hbox_new (FALSE, 1);
gtk_widget_show (hbox4);
gtk_box_pack_start (GTK_BOX (hbox3), hbox4, FALSE, TRUE, 0);
queue_progress = gtk_progress_bar_new ();
gtk_widget_show (queue_progress);
gtk_box_pack_start (GTK_BOX (hbox4), queue_progress, FALSE, FALSE, 0);
gtk_widget_set_size_request (queue_progress, 10, 48);
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (queue_progress), GTK_PROGRESS_BOTTOM_TO_TOP);
queue_usage = gtk_progress_bar_new ();
gtk_widget_show (queue_usage);
gtk_box_pack_start (GTK_BOX (hbox4), queue_usage, FALSE, FALSE, 0);
gtk_widget_set_size_request (queue_usage, 10, 48);
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (queue_usage), GTK_PROGRESS_BOTTOM_TO_TOP);
label9 = gtk_label_new ("");
gtk_widget_show (label9);
gtk_box_pack_start (GTK_BOX (hbox3), label9, FALSE, FALSE, 0);
gtk_widget_set_size_request (label9, 6, -1);
image3 = create_pixmap (main_window, "belts.png");
gtk_widget_show (image3);
gtk_box_pack_start (GTK_BOX (hbox3), image3, FALSE, FALSE, 0);
hbox5 = gtk_hbox_new (FALSE, 1);
gtk_widget_show (hbox5);
gtk_box_pack_start (GTK_BOX (hbox3), hbox5, FALSE, FALSE, 0);
belts_progress = gtk_progress_bar_new ();
gtk_widget_show (belts_progress);
gtk_box_pack_start (GTK_BOX (hbox5), belts_progress, FALSE, FALSE, 0);
gtk_widget_set_size_request (belts_progress, 10, 48);
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (belts_progress), GTK_PROGRESS_BOTTOM_TO_TOP);
belts_usage = gtk_progress_bar_new ();
gtk_widget_show (belts_usage);
gtk_box_pack_start (GTK_BOX (hbox5), belts_usage, FALSE, FALSE, 0);
gtk_widget_set_size_request (belts_usage, 10, 48);
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (belts_usage), GTK_PROGRESS_BOTTOM_TO_TOP);
ctrlButton_4 = gtk_button_new_with_mnemonic (_("(Unassigned)"));
gtk_widget_show (ctrlButton_4);
gtk_box_pack_start (GTK_BOX (vbox3), ctrlButton_4, FALSE, FALSE, 0);
ctrlButton_5 = gtk_button_new_with_mnemonic (_("(Unassigned)"));
gtk_widget_show (ctrlButton_5);
gtk_box_pack_start (GTK_BOX (vbox3), ctrlButton_5, FALSE, FALSE, 0);
ctrlButton_6 = gtk_button_new_with_mnemonic (_("(Unassigned)"));
gtk_widget_show (ctrlButton_6);
gtk_box_pack_start (GTK_BOX (vbox3), ctrlButton_6, FALSE, FALSE, 0);
label5 = gtk_label_new ("");
gtk_widget_show (label5);
gtk_box_pack_start (GTK_BOX (vbox3), label5, TRUE, FALSE, 0);
label3 = gtk_label_new (_("Control"));
gtk_widget_show (label3);
gtk_frame_set_label_widget (GTK_FRAME (frame2), label3);
gtk_label_set_use_markup (GTK_LABEL (label3), TRUE);
label8 = gtk_label_new (_("2007 (c) nazgul"));
gtk_widget_show (label8);
gtk_box_pack_start (GTK_BOX (vbox2), label8, FALSE, FALSE, 0);
image6 = create_pixmap (main_window, "wt.png");
gtk_widget_show (image6);
gtk_box_pack_start (GTK_BOX (hbox12), image6, TRUE, TRUE, 0);
g_signal_connect ((gpointer) main_window, "remove",
G_CALLBACK (on_main_window_remove),
NULL);
g_signal_connect ((gpointer) connect, "toggled",
G_CALLBACK (on_connect_toggled),
NULL);
g_signal_connect ((gpointer) login_at_connect, "toggled",
G_CALLBACK (on_login_at_connect_toggled),
NULL);
g_signal_connect ((gpointer) cmd_entry, "key_press_event",
G_CALLBACK (on_cmd_entry_key_press_event),
NULL);
g_signal_connect ((gpointer) btn_cmdSend, "clicked",
G_CALLBACK (on_btn_cmdSend_clicked),
NULL);
g_signal_connect ((gpointer) ctrlButton_0, "clicked",
G_CALLBACK (on_ctrlButton_clicked),
NULL);
g_signal_connect ((gpointer) ctrlButton_1, "clicked",
G_CALLBACK (on_ctrlButton_clicked),
NULL);
g_signal_connect ((gpointer) ctrlButton_2, "clicked",
G_CALLBACK (on_ctrlButton_clicked),
NULL);
g_signal_connect ((gpointer) ctrlButton_3, "clicked",
G_CALLBACK (on_ctrlButton_clicked),
NULL);
g_signal_connect ((gpointer) ctrlButton_4, "clicked",
G_CALLBACK (on_ctrlButton_clicked),
NULL);
g_signal_connect ((gpointer) ctrlButton_5, "clicked",
G_CALLBACK (on_ctrlButton_clicked),
NULL);
g_signal_connect ((gpointer) ctrlButton_6, "clicked",
G_CALLBACK (on_ctrlButton_clicked),
NULL);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (main_window, main_window, "main_window");
GLADE_HOOKUP_OBJECT (main_window, hbox12, "hbox12");
GLADE_HOOKUP_OBJECT (main_window, vbox30, "vbox30");
GLADE_HOOKUP_OBJECT (main_window, expander1, "expander1");
GLADE_HOOKUP_OBJECT (main_window, hbox6, "hbox6");
GLADE_HOOKUP_OBJECT (main_window, label11, "label11");
GLADE_HOOKUP_OBJECT (main_window, vbox5, "vbox5");
GLADE_HOOKUP_OBJECT (main_window, hbox7, "hbox7");
GLADE_HOOKUP_OBJECT (main_window, label12, "label12");
GLADE_HOOKUP_OBJECT (main_window, hbox9, "hbox9");
GLADE_HOOKUP_OBJECT (main_window, server, "server");
GLADE_HOOKUP_OBJECT (main_window, connect, "connect");
GLADE_HOOKUP_OBJECT (main_window, alignment7, "alignment7");
GLADE_HOOKUP_OBJECT (main_window, hbox11, "hbox11");
GLADE_HOOKUP_OBJECT (main_window, image7, "image7");
GLADE_HOOKUP_OBJECT (main_window, label18, "label18");
GLADE_HOOKUP_OBJECT (main_window, login_at_connect, "login_at_connect");
GLADE_HOOKUP_OBJECT (main_window, hbox8, "hbox8");
GLADE_HOOKUP_OBJECT (main_window, label14, "label14");
GLADE_HOOKUP_OBJECT (main_window, table1, "table1");
GLADE_HOOKUP_OBJECT (main_window, label13, "label13");
GLADE_HOOKUP_OBJECT (main_window, label15, "label15");
GLADE_HOOKUP_OBJECT (main_window, login, "login");
GLADE_HOOKUP_OBJECT (main_window, password, "password");
GLADE_HOOKUP_OBJECT (main_window, label17, "label17");
GLADE_HOOKUP_OBJECT (main_window, label10, "label10");
GLADE_HOOKUP_OBJECT (main_window, hbox1, "hbox1");
GLADE_HOOKUP_OBJECT (main_window, frame1, "frame1");
GLADE_HOOKUP_OBJECT (main_window, alignment3, "alignment3");
GLADE_HOOKUP_OBJECT (main_window, console_tabs, "console_tabs");
GLADE_HOOKUP_OBJECT (main_window, alignment4, "alignment4");
GLADE_HOOKUP_OBJECT (main_window, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT (main_window, console_scroll, "console_scroll");
GLADE_HOOKUP_OBJECT (main_window, console_view, "console_view");
GLADE_HOOKUP_OBJECT (main_window, label4, "label4");
GLADE_HOOKUP_OBJECT (main_window, hbox2, "hbox2");
GLADE_HOOKUP_OBJECT (main_window, image1, "image1");
GLADE_HOOKUP_OBJECT (main_window, cmd_entry, "cmd_entry");
GLADE_HOOKUP_OBJECT (main_window, btn_cmdSend, "btn_cmdSend");
GLADE_HOOKUP_OBJECT (main_window, label6, "label6");
GLADE_HOOKUP_OBJECT (main_window, alignment5, "alignment5");
GLADE_HOOKUP_OBJECT (main_window, pipe_scroll, "pipe_scroll");
GLADE_HOOKUP_OBJECT (main_window, pipe_view, "pipe_view");
GLADE_HOOKUP_OBJECT (main_window, label7, "label7");
GLADE_HOOKUP_OBJECT (main_window, label2, "label2");
GLADE_HOOKUP_OBJECT (main_window, vbox2, "vbox2");
GLADE_HOOKUP_OBJECT (main_window, frame2, "frame2");
GLADE_HOOKUP_OBJECT (main_window, alignment2, "alignment2");
GLADE_HOOKUP_OBJECT (main_window, vbox3, "vbox3");
GLADE_HOOKUP_OBJECT (main_window, ctrlButton_0, "ctrlButton_0");
GLADE_HOOKUP_OBJECT (main_window, ctrlButton_1, "ctrlButton_1");
GLADE_HOOKUP_OBJECT (main_window, ctrlButton_2, "ctrlButton_2");
GLADE_HOOKUP_OBJECT (main_window, ctrlButton_3, "ctrlButton_3");
GLADE_HOOKUP_OBJECT (main_window, alignment6, "alignment6");
GLADE_HOOKUP_OBJECT (main_window, hbox3, "hbox3");
GLADE_HOOKUP_OBJECT (main_window, image2, "image2");
GLADE_HOOKUP_OBJECT (main_window, hbox4, "hbox4");
GLADE_HOOKUP_OBJECT (main_window, queue_progress, "queue_progress");
GLADE_HOOKUP_OBJECT (main_window, queue_usage, "queue_usage");
GLADE_HOOKUP_OBJECT (main_window, label9, "label9");
GLADE_HOOKUP_OBJECT (main_window, image3, "image3");
GLADE_HOOKUP_OBJECT (main_window, hbox5, "hbox5");
GLADE_HOOKUP_OBJECT (main_window, belts_progress, "belts_progress");
GLADE_HOOKUP_OBJECT (main_window, belts_usage, "belts_usage");
GLADE_HOOKUP_OBJECT (main_window, ctrlButton_4, "ctrlButton_4");
GLADE_HOOKUP_OBJECT (main_window, ctrlButton_5, "ctrlButton_5");
GLADE_HOOKUP_OBJECT (main_window, ctrlButton_6, "ctrlButton_6");
GLADE_HOOKUP_OBJECT (main_window, label5, "label5");
GLADE_HOOKUP_OBJECT (main_window, label3, "label3");
GLADE_HOOKUP_OBJECT (main_window, label8, "label8");
GLADE_HOOKUP_OBJECT (main_window, image6, "image6");
return main_window;
}
void mater_udnz(GtkWidget *wpredok)
{
char strsql[512];
mater_udnz_data data;
data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(data.window),TRUE);
//gtk_window_set_default_size (GTK_WINDOW(data.window),400,300);
if(wpredok != NULL)
{
//Удерживать окно над породившем его окном всегда
gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok));
//Закрыть окно если окно предок удалено
gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE);
}
sprintf(strsql,"%s %s",name_system,gettext("Удаление неиспользуемых кодов материалов"));
gtk_window_set_title(GTK_WINDOW(data.window),strsql);
//gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL);
gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
GtkWidget *vbox=gtk_vbox_new(FALSE, 2);
gtk_container_add(GTK_CONTAINER(data.window), vbox);
data.label=gtk_label_new(gettext("Ждите !!!"));
gtk_box_pack_start(GTK_BOX(vbox),data.label,FALSE,FALSE,0);
GtkWidget *label=gtk_label_new(gettext("Удаление неиспользуемых кодов материалов"));
gtk_box_pack_start(GTK_BOX(vbox),label,FALSE,FALSE,0);
data.view=gtk_text_view_new();
gtk_widget_set_usize(GTK_WIDGET(data.view),400,300);
gtk_text_view_set_editable(GTK_TEXT_VIEW(data.view),FALSE); //Запрет на редактирование текста
PangoFontDescription *font_pango=pango_font_description_from_string(shrift_ravnohir.ravno());
gtk_widget_modify_font(GTK_WIDGET(data.view),font_pango);
pango_font_description_free(font_pango);
data.buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(data.view));
GtkWidget *sw=gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),GTK_SHADOW_ETCHED_IN);
//gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(sw),data.view);
data.bar=gtk_progress_bar_new();
gtk_progress_bar_set_bar_style(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_CONTINUOUS);
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_LEFT_TO_RIGHT);
gtk_box_pack_start (GTK_BOX (vbox), data.bar, FALSE, FALSE, 2);
//gtk_window_set_decorated(GTK_WINDOW(data.window),FALSE); //Убирает рамку вокруг окна
gtk_widget_show_all(data.window);
sprintf(strsql,"F10 %s",gettext("Выход"));
data.knopka=gtk_button_new_with_label(strsql);
GtkTooltips *tooltops=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltops,data.knopka,gettext("Завершение работы в этом окне"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka),"clicked",GTK_SIGNAL_FUNC(mater_r_v_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka),(gpointer)0);
gtk_box_pack_start (GTK_BOX (vbox), data.knopka, FALSE, FALSE, 2);
gtk_idle_add((GtkFunction)mater_udnz11,&data);
gtk_main();
}
static t_sload *
sload_new(void)
{
t_sload *sload;
GtkRcStyle *rc;
if (!tooltips) {
tooltips = gtk_tooltips_new();
}
sload = g_new(t_sload, 1);
sload->options.use_label = TRUE;
sload->options.label_text = g_strdup(DEFAULTTEXT);
gdk_color_parse(DEFAULTCOLOR, &sload->options.color);
sload->timeout_id = 0;
sload->cpu_history[0] = 0;
sload->cpu_history[1] = 0;
sload->cpu_history[2] = 0;
sload->cpu_history[3] = 0;
sload->ebox = gtk_event_box_new();
gtk_widget_show(sload->ebox);
sload->hbox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_widget_set_name(GTK_WIDGET(sload->hbox), "system_load");
gtk_container_set_border_width(GTK_CONTAINER(sload->hbox), border_width);
gtk_widget_show(GTK_WIDGET(sload->hbox));
sload->label = gtk_label_new(sload->options.label_text);
gtk_widget_show(sload->label);
gtk_box_pack_start(GTK_BOX(sload->hbox), GTK_WIDGET(sload->label),
FALSE, FALSE, 0);
sload->status = GTK_PROGRESS_BAR(gtk_progress_bar_new());
gtk_progress_bar_set_orientation(sload->status, GTK_PROGRESS_BOTTOM_TO_TOP);
rc = gtk_widget_get_modifier_style(GTK_WIDGET(sload->status));
if (!rc) {
rc = gtk_rc_style_new();
}
if (rc) {
rc->color_flags[GTK_STATE_PRELIGHT] |= GTK_RC_BG;
rc->bg[GTK_STATE_PRELIGHT] = sload->options.color;
}
gtk_widget_modify_style(GTK_WIDGET(sload->status), rc);
gtk_widget_show(GTK_WIDGET(sload->status));
gtk_box_pack_start(GTK_BOX(sload->hbox), GTK_WIDGET(sload->status),
FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(sload->ebox), GTK_WIDGET(sload->hbox));
return sload;
}
void go_ss_nbs(class go_rr *data_rr)
{
go_ss_nbs_r_data data;
data.rek_r=data_rr;
char strsql[512];
iceb_u_str soob;
printf("go_ss_nbs\n");
if(iceb_rsdatp(&data.dn,&data.mn,&data.gn,data.rek_r->datan.ravno(),
&data.dk,&data.mk,&data.gk,data.rek_r->datak.ravno(),NULL) != 0)
return;
data.godn=startgodb;
if(startgodb == 0 || startgodb > data.gn)
data.godn=data.gn;
data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER);
gtk_window_set_default_size (GTK_WINDOW (data.window),400,-1);
sprintf(strsql,"%s %s",name_system,gettext("Журнал ордер"));
gtk_window_set_title(GTK_WINDOW(data.window),strsql);
gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL);
gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(go_ss_nbs_r_key_press),&data);
GtkWidget *vbox=gtk_vbox_new(FALSE, 2);
gtk_container_add(GTK_CONTAINER(data.window), vbox);
data.label=gtk_label_new(gettext("Ждите !!!"));
gtk_box_pack_start(GTK_BOX(vbox),data.label,FALSE,FALSE,0);
sprintf(strsql,"%s %s",gettext("Расчет журнал-ордера по счету"),data.rek_r->shet.ravno());
soob.new_plus(strsql);
sprintf(strsql,"%s %d.%d.%d => %d.%d.%d",gettext("Расчет за период"),
data.dn,data.mn,data.gn,
data.dk,data.mk,data.gk);
soob.ps_plus(strsql);
GtkWidget *label=gtk_label_new(soob.ravno_toutf());
gtk_box_pack_start(GTK_BOX(vbox),label,FALSE,FALSE,0);
data.view=gtk_text_view_new();
gtk_widget_set_usize(GTK_WIDGET(data.view),400,300);
gtk_text_view_set_editable(GTK_TEXT_VIEW(data.view),FALSE); //Запрет на редактирование текста
PangoFontDescription *font_pango=pango_font_description_from_string(shrift_ravnohir.ravno());
gtk_widget_modify_font(GTK_WIDGET(data.view),font_pango);
pango_font_description_free(font_pango);
data.buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(data.view));
GtkWidget *sw=gtk_scrolled_window_new(NULL,NULL);
//gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
//gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_ALWAYS,GTK_POLICY_ALWAYS);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(sw),data.view);
data.bar=gtk_progress_bar_new();
gtk_progress_bar_set_bar_style(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_CONTINUOUS);
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_LEFT_TO_RIGHT);
gtk_box_pack_start (GTK_BOX (vbox), data.bar, FALSE, FALSE, 2);
gtk_widget_show_all(data.window);
sprintf(strsql,"F10 %s",gettext("Выход"));
data.knopka=gtk_button_new_with_label(strsql);
GtkTooltips *tooltops=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltops,data.knopka,gettext("Завершение работы в этом окне"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka),"clicked",GTK_SIGNAL_FUNC(go_ss_nbs_r_v_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka),(gpointer)0);
gtk_box_pack_start (GTK_BOX (vbox), data.knopka, FALSE, FALSE, 2);
//gtk_window_set_decorated(GTK_WINDOW(data.window),FALSE); //Убирает рамку вокруг окна
//gtk_widget_set_sensitive(GTK_WIDGET(data.knopka),FALSE);//Недоступна
gtk_idle_add((GtkFunction)go_ss_nbs_r1,&data);
gtk_main();
iceb_rabfil(&data.imaf,&data.naim,"",0,NULL);
}
/*!
\brief register_rt_range() creates the slider from the passed data,
and attaches it the the gui. This is called during gui tab loading to embed
sliders into regular tabs.
\param widget is the widget defined in Gui datamap file. Used
to load all the necessary attributes to stick the control in the right place.
*/
G_MODULE_EXPORT void register_rt_range(GtkWidget * widget)
{
gconstpointer *object = NULL;
Rtv_Map *rtv_map = NULL;
GHashTable *rt_sliders = NULL;
GHashTable *aw_sliders = NULL;
GHashTable *ww_sliders = NULL;
GHashTable *enr_sliders = NULL;
gchar * source = NULL;
const gchar *name = NULL;
TabIdent ident;
Rt_Slider *slider = NULL;
rtv_map = (Rtv_Map *)DATA_GET(global_data,"rtv_map");
source = (gchar *)OBJ_GET(widget,"source");
ident = (TabIdent)(GINT)OBJ_GET(widget,"tab_ident");
name = glade_get_widget_name(widget);
g_return_if_fail(rtv_map);
g_return_if_fail(source);
object = (gconstpointer *)g_hash_table_lookup(rtv_map->rtv_hash,source);
rt_sliders = (GHashTable *)DATA_GET(global_data,"rt_sliders");
aw_sliders = (GHashTable *)DATA_GET(global_data,"aw_sliders");
ww_sliders = (GHashTable *)DATA_GET(global_data,"ww_sliders");
enr_sliders = (GHashTable *)DATA_GET(global_data,"enr_sliders");
if (!rt_sliders)
{
rt_sliders = g_hash_table_new_full(g_str_hash,g_str_equal,g_free,dealloc_slider);
DATA_SET_FULL(global_data,"rt_sliders",rt_sliders,g_hash_table_destroy);
}
if (!aw_sliders)
{
aw_sliders = g_hash_table_new_full(g_str_hash,g_str_equal,g_free,dealloc_slider);
DATA_SET_FULL(global_data,"aw_sliders",aw_sliders,g_hash_table_destroy);
}
if (!ww_sliders)
{
ww_sliders = g_hash_table_new_full(g_str_hash,g_str_equal,g_free,dealloc_slider);
DATA_SET_FULL(global_data,"ww_sliders",ww_sliders,g_hash_table_destroy);
}
if (!enr_sliders)
{
enr_sliders = g_hash_table_new_full(g_str_hash,g_str_equal,g_free,dealloc_slider);
DATA_SET_FULL(global_data,"enr_sliders",enr_sliders,g_hash_table_destroy);
}
if (!(object))
{
MTXDBG(CRITICAL,_("ERROR! There is no datasource named \"%s\", Check config of widget %s\n"),source,(name == NULL ? "undefined":name));
return;
}
slider = (Rt_Slider *)g_malloc0(sizeof(Rt_Slider));
slider->ctrl_name = g_strdup((name == NULL ? "undefined":name));
slider->tbl = -1;
slider->table_num = -1;
slider->row = -1;
slider->history = (GArray *) DATA_GET(object,"history");
slider->friendly_name = (gchar *) DATA_GET(object,"dlog_gui_name");
slider->temp_dep = (GBOOLEAN)DATA_GET(object,"temp_dep");
if ((gchar *)DATA_GET(object,"real_lower"))
slider->lower = (GINT)strtol((gchar *)DATA_GET(object,"real_lower"),NULL,10);
else
printf(_("No \"real_lower\" value defined for control name %s, datasource %s\n"),slider->ctrl_name,source);
if ((gchar *)DATA_GET(object,"real_upper"))
slider->upper = (GINT)strtol((gchar *)DATA_GET(object,"real_upper"),NULL,10);
else
printf(_("No \"real_upper\" value defined for control name %s, datasource %s\n"),slider->ctrl_name,source);
slider->object = object;
slider->textval = NULL;
if (GTK_IS_SCALE(widget))
{
slider->type = MTX_RANGE;
slider->pbar = widget;
}
/* generic container (Table/box HOLDING a mtx pbar */
else if (GTK_IS_CONTAINER(widget))
{
GtkProgressBarOrientation orient;
/* We don't like GTK+'s progress bar, so rip it out and
* stick in my custom version instead. Get the orientation
* first...
*/
orient = (GtkProgressBarOrientation)(GINT)OBJ_GET(widget,"orientation");
slider->pbar = mtx_progress_bar_new();
mtx_progress_bar_set_hold_time(MTX_PROGRESS_BAR(slider->pbar),(GINT)DATA_GET(global_data,"pbar_hold_time"));
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(slider->pbar),orient);
gtk_container_add(GTK_CONTAINER(widget),slider->pbar);
slider->type = MTX_PROGRESS;
}
switch (ident)
{
case RUNTIME_TAB:
printf("inserted slider into runtime tab!\n");
g_hash_table_insert(rt_sliders,g_strdup(slider->ctrl_name),(gpointer)slider);
break;
case ENRICHMENTS_TAB:
g_hash_table_insert(enr_sliders,g_strdup(slider->ctrl_name),(gpointer)slider);
break;
case WARMUP_WIZ_TAB:
g_hash_table_insert(ww_sliders,g_strdup(slider->ctrl_name),(gpointer)slider);
break;
case ACCEL_WIZ_TAB:
g_hash_table_insert(aw_sliders,g_strdup(slider->ctrl_name),(gpointer)slider);
break;
default:
break;
}
}
/*!
\brief add_slider() creates the slider from the passed data, and attaches
it the the gui.
\param ctrl_name is the name of the slider as defined in the config file
\param tbl is the table number to bind this slider to
\param table_num is the table_num from the firmware that this slider is
bound to. (used for the sliders on the 3D view)
\param row is the row of the table (tbl) that this slider goes on
\param source is the data source for this slider
\param ident is the enumeration of the page this slider goes on
\returns a Struct Rt_Slider *
*/
G_MODULE_EXPORT Rt_Slider * add_slider(gchar *ctrl_name, gint tbl, gint table_num, gint row, gchar *source, TabIdent ident)
{
Rt_Slider *slider = NULL;
GtkWidget *label = NULL;
GtkWidget *pbar = NULL;
GtkWidget *table = NULL;
GtkWidget *hbox = NULL;
gchar * name = NULL;
Rtv_Map *rtv_map = NULL;
gconstpointer *object = NULL;
rtv_map = (Rtv_Map *)DATA_GET(global_data,"rtv_map");
object = (gconstpointer *)g_hash_table_lookup(rtv_map->rtv_hash,source);
if (!(object))
{
MTXDBG(CRITICAL,_("Request to create slider for non-existant datasource \"%s\"\n"),source);
return NULL;
}
if (ident == RUNTIME_TAB)
name = g_strdup_printf("runtime_rt_table%i",tbl);
else if (ident == WARMUP_WIZ_TAB)
name = g_strdup_printf("ww_rt_table%i",tbl);
else if (ident == VE3D_VIEWER_TAB)
name = g_strdup_printf("ve3d_rt_table%i_%i",tbl,table_num);
else
{
MTXDBG(CRITICAL,_("Page ident passed is not handled, ERROR, widget add aborted\n"));
return NULL;
}
table = lookup_widget(name);
if (!table)
{
MTXDBG(CRITICAL,_("Table \"%s\" was not found, RuntimeSlider map or runtime datamap has a typo\n"),name);
g_free(name);
return NULL;
}
g_free(name);
slider = (Rt_Slider *)g_malloc0(sizeof(Rt_Slider));
slider->ctrl_name = g_strdup(ctrl_name);
slider->tbl = tbl;
slider->table_num = table_num;
slider->row = row;
slider->last = 0.0;
slider->type = MTX_PROGRESS;
slider->friendly_name = (gchar *) DATA_GET(object,"dlog_gui_name");
slider->temp_dep = (GBOOLEAN)DATA_GET(object,"temp_dep");
if ((gchar *)DATA_GET(object,"real_lower"))
slider->lower = (GINT)strtol((gchar *)DATA_GET(object,"real_lower"),NULL,10);
else
MTXDBG(CRITICAL,_("No \"real_lower\" value defined for control name %s, datasource %s\n"),ctrl_name,source);
if ((gchar *)DATA_GET(object,"real_upper"))
slider->upper = (GINT)strtol((gchar *)DATA_GET(object,"real_upper"),NULL,10);
else
MTXDBG(CRITICAL,_("No \"real_upper\" value defined for control name %s, datasource %s\n"),ctrl_name,source);
slider->history = (GArray *) DATA_GET(object,"history");
slider->object = object;
hbox = gtk_hbox_new(FALSE,5);
label = gtk_label_new(NULL);
slider->label = label;
gtk_label_set_markup(GTK_LABEL(label),slider->friendly_name);
gtk_misc_set_alignment(GTK_MISC(label),0.0,0.5);
gtk_box_pack_start(GTK_BOX(hbox),label,TRUE,TRUE,0);
label = gtk_entry_new();
gtk_entry_set_has_frame(GTK_ENTRY(label),FALSE);
gtk_entry_set_width_chars(GTK_ENTRY(label),6);
gtk_entry_set_alignment(GTK_ENTRY(label),1);
gtk_entry_set_editable(GTK_ENTRY(label),FALSE);
/* PRELIGHT seems to not give the box as NORMAL does, not sure why */
gtk_widget_modify_base(GTK_WIDGET(label),GTK_STATE_NORMAL,>k_widget_get_style(slider->label)->bg[GTK_STATE_PRELIGHT]);
slider->textval = label;
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
if ((ident == RUNTIME_TAB) || (ident == VE3D_VIEWER_TAB))
{
if (((tbl+1) % 2) == 0)
gtk_size_group_add_widget(size_group_right,hbox);
else
gtk_size_group_add_widget(size_group_left,hbox);
}
gtk_table_attach (GTK_TABLE (table),hbox,
0,2,slider->row,(slider->row)+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
pbar = mtx_progress_bar_new();
/* 1.1 Seconds peak hold time */
mtx_progress_bar_set_hold_time(MTX_PROGRESS_BAR(pbar),1100);
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(pbar),
GTK_PROGRESS_LEFT_TO_RIGHT);
gtk_table_attach (GTK_TABLE (table),pbar,
2,3,slider->row,(slider->row)+1,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND|GTK_SHRINK),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND|GTK_SHRINK), 0, 0);
slider->pbar = pbar;
slider->parent = table;
gtk_widget_show_all(slider->parent);
return slider;
}
void r_poiprov(class prov_poi_data *rekv_m_poiprov,GtkWidget *wpredok)
{
char strsql[512];
r_poiprov_data data;
data.rek_poi=rekv_m_poiprov;
data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_modal(GTK_WINDOW(data.window),TRUE);
gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER);
gtk_window_set_default_size (GTK_WINDOW (data.window),400,-1);
gtk_window_set_resizable(GTK_WINDOW(data.window),FALSE); /*запрет на изменение размеров окна*/
gtk_window_set_deletable(GTK_WINDOW(data.window),FALSE); /*Выключить кнопку close в рамке окна*/
if(wpredok != NULL)
{
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
//Удерживать окно над породившем его окном всегда
gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok));
//Закрыть окно если окно предок удалено
gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE);
}
sprintf(strsql,"%s %s",name_system,gettext("Распечатка проводок"));
gtk_window_set_title(GTK_WINDOW(data.window),strsql);
//gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL);
gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
GtkWidget *vbox=gtk_vbox_new(FALSE, 2);
gtk_container_add(GTK_CONTAINER(data.window), vbox);
GtkWidget *label=gtk_label_new(gettext("Ждите !!!"));
gtk_widget_set_size_request(GTK_WIDGET(label),300,-1);
gtk_box_pack_start(GTK_BOX(vbox),label,FALSE,FALSE,0);
label=gtk_label_new(gettext("Распечатка проводок"));
gtk_box_pack_start(GTK_BOX(vbox),label,FALSE,FALSE,0);
data.bar=gtk_progress_bar_new();
gtk_progress_bar_set_bar_style(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_CONTINUOUS);
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_LEFT_TO_RIGHT);
gtk_box_pack_start (GTK_BOX (vbox), data.bar, FALSE, FALSE, 2);
//gtk_window_set_decorated(GTK_WINDOW(data.window),FALSE); //Убирает рамку вокруг окна
gtk_widget_show_all(data.window);
gtk_idle_add((GtkFunction)r_poiprov1,&data);
gtk_main();
if(wpredok != NULL)
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));
iceb_rabfil(&data.imaf,&data.naim,"",0,wpredok);
}
void i_alter_rtr(const char *imabaz,const char *host,const char *parol,GtkWidget *wpredok)
{
char strsql[300];
iceb_u_str soob;
alter_rtr_data data;
data.imabaz.plus(imabaz);
data.host.plus(host);
data.parol.plus(parol);
data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER);
gtk_window_set_default_size (GTK_WINDOW (data.window),400,-1);
sprintf(strsql,"%s %s",name_system,iceb_u_toutf("Преобразование таблиц"));
gtk_window_set_title(GTK_WINDOW(data.window),strsql);
gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL);
gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(alter_rtr_key_press),&data);
if(wpredok != NULL)
{
//Удерживать окно над породившем его окном всегда
gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok));
//Закрыть окно если окно предок удалено
gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE);
}
GtkWidget *vbox=gtk_vbox_new(FALSE, 2);
gtk_container_add(GTK_CONTAINER(data.window), vbox);
data.label=gtk_label_new(gettext("Ждите !!!"));
gtk_box_pack_start(GTK_BOX(vbox),data.label,FALSE,FALSE,0);
sprintf(strsql,"%s:%s","Преобразование таблиц базы данных",data.imabaz.ravno());
soob.new_plus(strsql);
GtkWidget *label=gtk_label_new(soob.ravno_toutf());
gtk_box_pack_start(GTK_BOX(vbox),label,FALSE,FALSE,0);
data.view=gtk_text_view_new();
gtk_widget_set_usize(GTK_WIDGET(data.view),400,300);
gtk_text_view_set_editable(GTK_TEXT_VIEW(data.view),FALSE); //Запрет на редактирование текста
PangoFontDescription *font_pango=pango_font_description_from_string("Nimbus Mono L, Bold 10");
gtk_widget_modify_font(GTK_WIDGET(data.view),font_pango);
pango_font_description_free(font_pango);
data.buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(data.view));
GtkWidget *sw=gtk_scrolled_window_new(NULL,NULL);
//gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
//gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_ALWAYS,GTK_POLICY_ALWAYS);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(sw),data.view);
data.bar=gtk_progress_bar_new();
gtk_progress_bar_set_bar_style(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_CONTINUOUS);
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_LEFT_TO_RIGHT);
gtk_box_pack_start (GTK_BOX (vbox), data.bar, FALSE, FALSE, 2);
gtk_widget_show_all(data.window);
sprintf(strsql,"F10 %s",gettext("Выход"));
data.knopka=gtk_button_new_with_label(strsql);
GtkTooltips *tooltops=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltops,data.knopka,gettext("Завершение работы в этом окне"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka),"clicked",GTK_SIGNAL_FUNC(alter_rtr_v_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka),(gpointer)0);
gtk_box_pack_start (GTK_BOX (vbox), data.knopka, FALSE, FALSE, 2);
//gtk_window_set_decorated(GTK_WINDOW(data.window),FALSE); //Убирает рамку вокруг окна
//gtk_widget_set_sensitive(GTK_WIDGET(data.knopka),FALSE);//Недоступна
gtk_idle_add((GtkFunction)alter_rtr1,&data);
gtk_main();
}
int impotvrw_r(const char *imaf_imp,
GtkWidget *wpredok)
{
char strsql[512];
iceb_u_spisok repl_s;
class impotvrw_r_data data;
data.imaf_imp=imaf_imp;
data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_modal(GTK_WINDOW(data.window),TRUE);
gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER);
gtk_window_set_default_size (GTK_WINDOW (data.window),400,-1);
sprintf(strsql,"%s %s",name_system,gettext("Импорт отработанного времени"));
gtk_window_set_title(GTK_WINDOW(data.window),strsql);
gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL);
gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(impotvrw_r_key_press),&data);
if(wpredok != NULL)
{
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
//Удерживать окно над породившем его окном всегда
gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok));
//Закрыть окно если окно предок удалено
gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE);
}
GtkWidget *vbox=gtk_vbox_new(FALSE, 2);
gtk_container_add(GTK_CONTAINER(data.window), vbox);
data.label=gtk_label_new(gettext("Ждите !!!"));
gtk_box_pack_start(GTK_BOX(vbox),data.label,FALSE,FALSE,0);
GtkWidget *label=gtk_label_new(gettext("Импорт отработанного времени"));
gtk_box_pack_start(GTK_BOX(vbox),label,FALSE,FALSE,0);
data.view=gtk_text_view_new();
gtk_widget_set_usize(GTK_WIDGET(data.view),450,300);
gtk_text_view_set_editable(GTK_TEXT_VIEW(data.view),FALSE); //Запрет на редактирование текста
//PangoFontDescription *font_pango=pango_font_description_from_string("Nimbus Mono L, Bold 12");
PangoFontDescription *font_pango=pango_font_description_from_string(shrift_ravnohir.ravno());
gtk_widget_modify_font(GTK_WIDGET(data.view),font_pango);
pango_font_description_free(font_pango);
data.buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(data.view));
GtkWidget *sw=gtk_scrolled_window_new(NULL,NULL);
//gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
//gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_ALWAYS,GTK_POLICY_ALWAYS);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(sw),data.view);
data.bar=gtk_progress_bar_new();
gtk_progress_bar_set_bar_style(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_CONTINUOUS);
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(data.bar),GTK_PROGRESS_LEFT_TO_RIGHT);
gtk_box_pack_start (GTK_BOX (vbox), data.bar, FALSE, FALSE, 2);
sprintf(strsql,"F10 %s",gettext("Выход"));
data.knopka=gtk_button_new_with_label(strsql);
GtkTooltips *tooltops=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltops,data.knopka,gettext("Завершение работы в этом окне"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka),"clicked",GTK_SIGNAL_FUNC(impotvrw_r_v_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka),(gpointer)0);
gtk_box_pack_start (GTK_BOX (vbox), data.knopka, FALSE, FALSE, 2);
gtk_widget_set_sensitive(GTK_WIDGET(data.knopka),FALSE);//Недоступна
gtk_widget_show_all(data.window);
//gtk_window_set_decorated(GTK_WINDOW(data.window),FALSE); //Убирает рамку вокруг окна
//gtk_widget_set_sensitive(GTK_WIDGET(data.knopka),FALSE);//Недоступна
gtk_idle_add((GtkFunction)impotvrw_r1,&data);
gtk_main();
if(wpredok != NULL)
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));
return(data.voz);
}
GtkWidget *
create_dialog (void)
{
GtkWidget *dlg;
GtkWidget *hbox, *vbox, *hbox2, *bbox;
GtkWidget *image;
GtkWidget *text;
GtkWidget *main_widget = NULL;
GtkWidget *topb = NULL;
/* create dialog window */
dlg = gtk_dialog_new ();
if (options.data.splash)
gtk_window_set_type_hint (GTK_WINDOW (dlg), GDK_WINDOW_TYPE_HINT_SPLASHSCREEN);
else
gtk_window_set_type_hint (GTK_WINDOW (dlg), GDK_WINDOW_TYPE_HINT_NORMAL);
gtk_window_set_title (GTK_WINDOW (dlg), options.data.dialog_title);
gtk_widget_set_name (dlg, "yad-dialog-window");
#ifndef G_OS_WIN32
if (options.parent)
{
gdk_window_set_transient_for (gtk_widget_get_window (dlg),
gdk_x11_window_foreign_new_for_display (gdk_display_get_default (),
options.parent));
}
#endif
if (options.data.no_escape)
g_signal_connect (G_OBJECT (dlg), "close", G_CALLBACK (ignore_close_cb) , NULL);
/* get buttons container */
bbox = gtk_dialog_get_action_area (GTK_DIALOG (dlg));
/* set window icon */
if (options.data.window_icon)
{
if (g_file_test (options.data.window_icon, G_FILE_TEST_EXISTS))
gtk_window_set_icon_from_file (GTK_WINDOW (dlg), options.data.window_icon, NULL);
else
gtk_window_set_icon_name (GTK_WINDOW (dlg), options.data.window_icon);
}
/* set window borders */
if (options.data.borders == -1)
options.data.borders = (gint) gtk_container_get_border_width (GTK_CONTAINER (dlg));
gtk_container_set_border_width (GTK_CONTAINER (dlg), (guint) options.data.borders);
/* set window size and position */
if (!options.data.geometry && !options.data.maximized && !options.data.fullscreen)
{
gtk_window_set_default_size (GTK_WINDOW (dlg), options.data.width, options.data.height);
if (options.data.center)
gtk_window_set_position (GTK_WINDOW (dlg), GTK_WIN_POS_CENTER);
else if (options.data.mouse)
gtk_window_set_position (GTK_WINDOW (dlg), GTK_WIN_POS_MOUSE);
}
/* set window behavior */
if (options.data.sticky)
gtk_window_stick (GTK_WINDOW (dlg));
gtk_window_set_keep_above (GTK_WINDOW (dlg), options.data.ontop);
gtk_window_set_decorated (GTK_WINDOW (dlg), !options.data.undecorated);
gtk_window_set_skip_taskbar_hint (GTK_WINDOW (dlg), options.data.skip_taskbar);
gtk_window_set_skip_pager_hint (GTK_WINDOW (dlg), options.data.skip_taskbar);
/* create timeout indicator widget */
if (options.data.timeout)
{
if (G_LIKELY (options.data.to_indicator) && g_ascii_strcasecmp (options.data.to_indicator, "none"))
{
topb = gtk_progress_bar_new ();
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (topb), 1.0);
gtk_widget_set_name (topb, "yad-timeout-indicator");
}
}
/* add top label widgets */
#if !GTK_CHECK_VERSION(3,0,0)
hbox = hbox2 = gtk_hbox_new (FALSE, 0);
#else
hbox = hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
#endif
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), hbox, TRUE, TRUE, 5);
#if !GTK_CHECK_VERSION(3,0,0)
vbox = gtk_vbox_new (FALSE, 0);
#else
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
#endif
/* add timeout indicator */
if (topb)
{
if (g_ascii_strcasecmp (options.data.to_indicator, "top") == 0)
{
#if !GTK_CHECK_VERSION(3,0,0)
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (topb), GTK_PROGRESS_LEFT_TO_RIGHT);
#endif
gtk_box_pack_start (GTK_BOX (vbox), topb, FALSE, FALSE, 2);
}
else if (g_ascii_strcasecmp (options.data.to_indicator, "bottom") == 0)
{
#if !GTK_CHECK_VERSION(3,0,0)
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (topb), GTK_PROGRESS_LEFT_TO_RIGHT);
#endif
gtk_box_pack_end (GTK_BOX (vbox), topb, FALSE, FALSE, 2);
}
else if (g_ascii_strcasecmp (options.data.to_indicator, "left") == 0)
{
#if !GTK_CHECK_VERSION(3,0,0)
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (topb), GTK_PROGRESS_BOTTOM_TO_TOP);
#endif
gtk_box_pack_start (GTK_BOX (hbox), topb, FALSE, FALSE, 2);
}
else if (g_ascii_strcasecmp (options.data.to_indicator, "right") == 0)
{
#if !GTK_CHECK_VERSION(3,0,0)
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (topb), GTK_PROGRESS_BOTTOM_TO_TOP);
#endif
gtk_box_pack_end (GTK_BOX (hbox), topb, FALSE, FALSE, 2);
}
if (settings.show_remain)
{
gchar *lbl = g_strdup_printf (_("%d sec"), options.data.timeout);
#if GTK_CHECK_VERSION(3,0,0)
gtk_progress_bar_set_show_text (GTK_PROGRESS_BAR (topb), TRUE);
#endif
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (topb), lbl);
g_free (lbl);
}
}
/* must be after indicator! */
gtk_box_pack_end (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
if (options.data.image_on_top)
{
#if !GTK_CHECK_VERSION(3,0,0)
hbox2 = gtk_hbox_new (FALSE, 0);
#else
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
#endif
gtk_box_pack_start (GTK_BOX (vbox), hbox2, FALSE, FALSE, 0);
}
if (options.data.dialog_image)
{
GdkPixbuf *pb = NULL;
pb = get_pixbuf (options.data.dialog_image, YAD_BIG_ICON);
image = gtk_image_new_from_pixbuf (pb);
if (pb)
g_object_unref (pb);
gtk_widget_set_name (image, "yad-dialog-image");
gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0);
gtk_box_pack_start (GTK_BOX (hbox2), image, FALSE, FALSE, 2);
}
if (options.data.dialog_text)
{
/* for dnd's tooltip we don't need text label */
if (options.mode != YAD_MODE_DND || !options.dnd_data.tooltip)
{
gchar *buf = g_strcompress (options.data.dialog_text);
text = gtk_label_new (NULL);
if (!options.data.no_markup)
gtk_label_set_markup (GTK_LABEL (text), buf);
else
gtk_label_set_text (GTK_LABEL (text), buf);
g_free (buf);
gtk_widget_set_name (text, "yad-dialog-label");
gtk_label_set_line_wrap (GTK_LABEL (text), TRUE);
gtk_label_set_selectable (GTK_LABEL (text), options.data.selectable_labels);
gtk_label_set_justify (GTK_LABEL (text), options.data.text_align);
switch (options.data.text_align)
{
case GTK_JUSTIFY_LEFT:
case GTK_JUSTIFY_FILL:
gtk_misc_set_alignment (GTK_MISC (text), 0.0, 0.5);
break;
case GTK_JUSTIFY_CENTER:
gtk_misc_set_alignment (GTK_MISC (text), 0.5, 0.5);
break;
case GTK_JUSTIFY_RIGHT:
gtk_misc_set_alignment (GTK_MISC (text), 1.0, 0.5);
break;
}
if (options.data.image_on_top)
gtk_box_pack_start (GTK_BOX (hbox2), text, TRUE, TRUE, 2);
else
gtk_box_pack_start (GTK_BOX (vbox), text, FALSE, FALSE, 2);
#if !GTK_CHECK_VERSION(3,0,0)
if (!options.data.fixed)
g_signal_connect (G_OBJECT (text), "size-allocate", G_CALLBACK (text_size_allocate_cb), NULL);
#endif
}
}
/* add main widget */
switch (options.mode)
{
case YAD_MODE_CALENDAR:
main_widget = calendar_create_widget (dlg);
break;
case YAD_MODE_COLOR:
main_widget = color_create_widget (dlg);
break;
case YAD_MODE_DND:
dnd_init (dlg);
break;
case YAD_MODE_ENTRY:
main_widget = entry_create_widget (dlg);
break;
case YAD_MODE_FILE:
main_widget = file_create_widget (dlg);
break;
case YAD_MODE_FONT:
main_widget = font_create_widget (dlg);
break;
case YAD_MODE_FORM:
main_widget = form_create_widget (dlg);
break;
#ifdef HAVE_HTML
case YAD_MODE_HTML:
main_widget = html_create_widget (dlg);
break;
#endif
case YAD_MODE_ICONS:
main_widget = icons_create_widget (dlg);
break;
case YAD_MODE_LIST:
main_widget = list_create_widget (dlg);
break;
case YAD_MODE_MULTI_PROGRESS:
main_widget = multi_progress_create_widget (dlg);
break;
case YAD_MODE_NOTEBOOK:
main_widget = notebook_create_widget (dlg);
break;
case YAD_MODE_PANED:
main_widget = paned_create_widget (dlg);
break;
case YAD_MODE_PROGRESS:
main_widget = progress_create_widget (dlg);
break;
case YAD_MODE_SCALE:
main_widget = scale_create_widget (dlg);
break;
case YAD_MODE_TEXTINFO:
main_widget = text_create_widget (dlg);
break;
default:
;
}
if (main_widget)
{
if (options.data.expander)
{
GtkWidget *exp;
exp = gtk_expander_new_with_mnemonic (options.data.expander);
gtk_expander_set_expanded (GTK_EXPANDER (exp), FALSE);
gtk_container_add (GTK_CONTAINER (exp), main_widget);
gtk_box_pack_start (GTK_BOX (vbox), exp, TRUE, TRUE, 2);
}
else
gtk_box_pack_start (GTK_BOX (vbox), main_widget, TRUE, TRUE, 2);
}
/* add buttons */
if (!options.data.no_buttons)
{
if (options.data.buttons)
{
GSList *tmp = options.data.buttons;
do
{
GtkWidget *btn;
YadButton *b = (YadButton *) tmp->data;
btn = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (btn), get_label (b->name, 2));
gtk_button_set_alignment (GTK_BUTTON (btn), 0.5, 0.5);
g_object_set_data (G_OBJECT (btn), "resp", GINT_TO_POINTER (b->response));
g_signal_connect (G_OBJECT (btn), "clicked", G_CALLBACK (btn_cb), b->cmd);
gtk_box_pack_start (GTK_BOX (bbox), btn, FALSE, FALSE, 0);
tmp = tmp->next;
}
while (tmp != NULL);
}
else
{
if (options.mode == YAD_MODE_PROGRESS || options.mode == YAD_MODE_MULTI_PROGRESS)
gtk_dialog_add_buttons (GTK_DIALOG (dlg), GTK_STOCK_CLOSE, YAD_RESPONSE_OK, NULL);
else
{
if (gtk_alternative_dialog_button_order (NULL))
gtk_dialog_add_buttons (GTK_DIALOG (dlg),
GTK_STOCK_OK, YAD_RESPONSE_OK, GTK_STOCK_CANCEL, YAD_RESPONSE_CANCEL, NULL);
else
gtk_dialog_add_buttons (GTK_DIALOG (dlg),
GTK_STOCK_CANCEL, YAD_RESPONSE_CANCEL, GTK_STOCK_OK, YAD_RESPONSE_OK, NULL);
}
gtk_dialog_set_default_response (GTK_DIALOG (dlg), YAD_RESPONSE_OK);
}
gtk_button_box_set_layout (GTK_BUTTON_BOX (gtk_dialog_get_action_area (GTK_DIALOG (dlg))),
options.data.buttons_layout);
}
/* show widgets */
gtk_widget_show_all (gtk_dialog_get_content_area (GTK_DIALOG (dlg)));
if (options.data.no_buttons)
gtk_widget_hide (bbox);
/* parse geometry, if given. must be after showing widget */
if (options.data.geometry && !options.data.maximized && !options.data.fullscreen)
{
gtk_widget_realize (dlg);
gtk_window_parse_geometry (GTK_WINDOW (dlg), options.data.geometry);
}
gtk_widget_show (dlg);
/* set maximized or fixed size after showing widget */
if (options.data.maximized)
gtk_window_maximize (GTK_WINDOW (dlg));
else if (options.data.fullscreen)
gtk_window_fullscreen (GTK_WINDOW (dlg));
else
{
gtk_window_set_resizable (GTK_WINDOW (dlg), !options.data.fixed);
if (options.data.fixed)
gtk_widget_set_size_request (dlg, options.data.width, options.data.height);
}
/* set timeout */
if (options.data.timeout)
{
g_timeout_add_seconds (options.data.timeout, timeout_cb, dlg);
g_timeout_add_seconds (1, timeout_indicator_cb, topb);
}
#ifndef G_OS_WIN32
/* print xid */
if (options.print_xid)
{
fprintf (stderr, "0x%lX", GDK_WINDOW_XID (gtk_widget_get_window (dlg)));
fflush (stderr);
}
#endif
return dlg;
}
static void *replay_routine()
{
if (total_records == 0)
return NULL;
sigset_t sig_set;
sigemptyset(&sig_set);
sigaddset(&sig_set, SIGINT);
pthread_sigmask(SIG_BLOCK, &sig_set, NULL);
pthread_context_t *ctx = register_thread("track replay thread",
NULL, replay_thread_cleanup_func);
running = TRUE;
while(running) {
stop = FALSE;
suspend = FALSE;
suspending = FALSE;
last_draw_idx = -1;
/* settings */
LOCK_UI();
replay_update_ui_helper(TRUE);
map_draw_back_layers(g_view.da->window);
RESET_LAST_POINT();
/* the record index in the containing block */
int last_time_offset = 0;
int span, orient, start_idx, end_idx, inc;
if (direction_forward) {
start_idx = 0;
end_idx = total_records - 1;
inc = 1;
orient = GTK_PROGRESS_LEFT_TO_RIGHT;
} else {
start_idx = total_records - 1;
end_idx = 0;
inc = -1;
orient = GTK_PROGRESS_RIGHT_TO_LEFT;
}
gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(progress_bar), orient);
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progress_bar), 0);
gtk_button_set_label(GTK_BUTTON(start_button), "stop");
gtk_widget_set_sensitive(start_button, TRUE);
gtk_widget_set_sensitive(suspend_button, TRUE);
gtk_widget_set_sensitive(toend_button, TRUE);
gtk_widget_set_sensitive(direction_button, FALSE);
speed = gtk_adjustment_get_value(adjustment);
/* calculate pixels in tile map */
replay_calculate_pixel();
UNLOCK_UI();
int i, from = start_idx, to;
/* FIXME: better to use sigjmp here */
for (i=start_idx; direction_forward? i<=end_idx : i>=end_idx; i+=inc) {
if (! running) {
goto EXIT;
} else if (stop) {
stop = FALSE;
goto STOP;
} else if (toend) {
toend = FALSE;
i = end_idx;
} else if (suspend) {
suspend = FALSE;
suspending = TRUE;
wait_ms(0, &replay_cond, &replay_lock, TRUE);
suspending = FALSE;
LOCK_UI();
gtk_button_set_label(GTK_BUTTON(suspend_button), "suspend");
UNLOCK_UI();
}
span = abs(replay_records[i].time_offset - last_time_offset) / speed;
if (span < 1 && i != end_idx)
continue;
if (span > 1)
span = 1; // don't wait too long
to = i;
LOCK_UI();
replay_update_ui(from, to);
UNLOCK_UI();
from = to + inc;
sleep(1);
last_time_offset = replay_records[i].time_offset;
}
last_draw_idx = end_idx;
/* draw current position */
draw_current_position();
STOP:
LOCK_UI();
replay_reset_states();
UNLOCK_UI();
/* wait for restart */
wait_ms(0, &replay_cond, &replay_lock, TRUE);
}
EXIT:
free(ctx);
return NULL;
}
GtkWidget *
progress_create_widget (GtkWidget * dlg)
{
GtkWidget *w;
GIOChannel *channel;
// fix it when vertical specified
#if GTK_CHECK_VERSION(3,0,0)
w = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
#else
w = gtk_vbox_new (FALSE, 0);
#endif
progress_bar = gtk_progress_bar_new ();
gtk_widget_set_name (progress_bar, "yad-progress-widget");
if (options.progress_data.log_on_top)
gtk_box_pack_end (GTK_BOX (w), progress_bar, FALSE, FALSE, 0);
else
gtk_box_pack_start (GTK_BOX (w), progress_bar, FALSE, FALSE, 0);
if (options.progress_data.percentage > 100)
options.progress_data.percentage = 100;
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress_bar), options.progress_data.percentage / 100.0);
if (options.progress_data.progress_text)
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (progress_bar), options.progress_data.progress_text);
#if GTK_CHECK_VERSION(3,0,0)
gtk_progress_bar_set_inverted (GTK_PROGRESS_BAR (progress_bar), options.progress_data.rtl);
#else
if (options.progress_data.rtl)
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (progress_bar), GTK_PROGRESS_RIGHT_TO_LEFT);
#endif
if (options.progress_data.log)
{
GtkWidget *ex, *sw;
ex = gtk_expander_new (options.progress_data.log);
gtk_expander_set_spacing (GTK_EXPANDER (ex), 2);
gtk_expander_set_expanded (GTK_EXPANDER (ex), options.progress_data.log_expanded);
gtk_box_pack_start (GTK_BOX (w), ex, TRUE, TRUE, 2);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), options.hscroll_policy, options.vscroll_policy);
gtk_container_add (GTK_CONTAINER (ex), sw);
progress_log = gtk_text_view_new ();
gtk_widget_set_name (progress_log, "yad-text-widget");
gtk_widget_set_size_request (progress_log, -1, options.progress_data.log_height);
gtk_container_add (GTK_CONTAINER (sw), progress_log);
log_buffer = gtk_text_buffer_new (NULL);
gtk_text_view_set_buffer (GTK_TEXT_VIEW (progress_log), log_buffer);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (progress_log), 5);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (progress_log), 5);
gtk_text_view_set_editable (GTK_TEXT_VIEW (progress_log), FALSE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (progress_log), FALSE);
}
#if GTK_CHECK_VERSION(3,0,0)
else
gtk_progress_bar_set_show_text (GTK_PROGRESS_BAR (progress_bar), TRUE);
#endif
channel = g_io_channel_unix_new (0);
g_io_channel_set_encoding (channel, NULL, NULL);
g_io_channel_set_flags (channel, G_IO_FLAG_NONBLOCK, NULL);
g_io_add_watch (channel, G_IO_IN | G_IO_HUP, handle_stdin, dlg);
return w;
}
