コード例 #1
0
ファイル: l_kasdok.c プロジェクト: zaharchuktv/linuxbuh
void l_kasdok(const char *data_dok,
              int tipz,  //1-приход 2-расход
              const char *nomdok,
              const char *kassa,
              GtkWidget *wpredok)
{
    class  kasdok_data data;
    data.datad.new_plus(data_dok);
    data.tipz=tipz;
    data.nomdok.new_plus(nomdok);
    data.kassa.new_plus(kassa);

//Чтение реквизитов документа
    l_kasdok_rd(&data,wpredok);

    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,-1);
//gdk_color_parse("black",&color);
//gtk_widget_modify_bg(data.window,GTK_STATE_NORMAL,&color);
    char bros[312];
    if(tipz == 1)
        sprintf(bros,"%s %s",name_system,gettext("Работа с приходным кассовым ордером"));
    if(tipz == 2)
        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);

    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);


    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_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(kasdok_key_press),&data);
    gtk_signal_connect_after(GTK_OBJECT(data.window),"key_release_event",GTK_SIGNAL_FUNC(iceb_key_release),&data.kl_shift);

    GtkWidget *hbox = gtk_hbox_new (FALSE, 1);
    gtk_container_add (GTK_CONTAINER (data.window), hbox);

    GtkWidget *vbox1 = gtk_vbox_new (FALSE, 1);
    GtkWidget *vbox2 = gtk_vbox_new (FALSE, 1);

    gtk_box_pack_start (GTK_BOX (hbox), vbox1, FALSE, FALSE, 0);
    gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
    gtk_widget_show(hbox);


    data.label_rek_dok=gtk_label_new ("");
    gtk_box_pack_start (GTK_BOX (vbox2),data.label_rek_dok,FALSE, FALSE, 0);

    data.label_red=gtk_label_new ("");
    gtk_box_pack_start (GTK_BOX (vbox2),data.label_red,FALSE, FALSE, 0);

    GdkColor color;
    gdk_color_parse("red",&color);
    gtk_widget_modify_fg(data.label_red,GTK_STATE_NORMAL,&color);

//формируем заголовок с реквизитами документа
    iceb_u_str string;

    l_kasdok_str_rek(&data,&string);

    gtk_widget_show(vbox1);
    gtk_widget_show(vbox2);

    data.sw = gtk_scrolled_window_new (NULL, NULL);
    gtk_widget_set_usize(GTK_WIDGET(data.sw),-1,200);

    gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (data.sw),GTK_SHADOW_ETCHED_IN);
    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (data.sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
//gtk_box_pack_start (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0);
    gtk_box_pack_end (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0);
    gtk_widget_show(data.sw);

//Кнопки
    GtkTooltips *tooltips[KOL_F_KL];

    sprintf(bros,"%sF1 %s",RFK,gettext("Шапка"));
    data.knopka[SFK1]=gtk_button_new_with_label(bros);
    gtk_signal_connect(GTK_OBJECT(data.knopka[SFK1]), "clicked",GTK_SIGNAL_FUNC(kasdok_knopka),&data);
    gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK1],TRUE,TRUE, 0);
    tooltips[SFK1]=gtk_tooltips_new();
    gtk_tooltips_set_tip(tooltips[SFK1],data.knopka[SFK1],gettext("Просмотр шапки документа"),NULL);
    gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK1]),(gpointer)SFK1);
    gtk_widget_show(data.knopka[SFK1]);

    sprintf(bros,"F2 %s",gettext("Ввести"));
    data.knopka[FK2]=gtk_button_new_with_label(bros);
    gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]), "clicked",GTK_SIGNAL_FUNC(kasdok_knopka),&data);
    gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK2],TRUE,TRUE, 0);
    tooltips[FK2]=gtk_tooltips_new();
    gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Ввод новой записи"),NULL);
    gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2);
    gtk_widget_show(data.knopka[FK2]);

    sprintf(bros,"%sF2 %s",RFK,gettext("Корректировать"));
    data.knopka[SFK2]=gtk_button_new_with_label(bros);
    gtk_signal_connect(GTK_OBJECT(data.knopka[SFK2]), "clicked",GTK_SIGNAL_FUNC(kasdok_knopka),&data);
    gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK2],TRUE,TRUE, 0);
    tooltips[SFK2]=gtk_tooltips_new();
    gtk_tooltips_set_tip(tooltips[SFK2],data.knopka[SFK2],gettext("Корректировка выбранной записи"),NULL);
    gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK2]),(gpointer)SFK2);
    gtk_widget_show(data.knopka[SFK2]);

    sprintf(bros,"F3 %s",gettext("Удалить"));
    data.knopka[FK3]=gtk_button_new_with_label(bros);
    gtk_signal_connect(GTK_OBJECT(data.knopka[FK3]), "clicked",GTK_SIGNAL_FUNC(kasdok_knopka),&data);
    gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK3],TRUE,TRUE, 0);
    tooltips[FK3]=gtk_tooltips_new();
    gtk_tooltips_set_tip(tooltips[FK3],data.knopka[FK3],gettext("Удалить выбранную запись"),NULL);
    gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK3]),(gpointer)FK3);
    gtk_widget_show(data.knopka[FK3]);

    sprintf(bros,"%sF3 %s",RFK,gettext("Удалить"));
    data.knopka[SFK3]=gtk_button_new_with_label(bros);
    gtk_signal_connect(GTK_OBJECT(data.knopka[SFK3]), "clicked",GTK_SIGNAL_FUNC(kasdok_knopka),&data);
    gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK3],TRUE,TRUE, 0);
    tooltips[SFK3]=gtk_tooltips_new();
    gtk_tooltips_set_tip(tooltips[SFK3],data.knopka[SFK3],gettext("Удалить документ"),NULL);
    gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK3]),(gpointer)SFK3);
    gtk_widget_show(data.knopka[SFK3]);

    sprintf(bros,"F4 %s",gettext("Проводки"));
    data.knopka[FK4]=gtk_button_new_with_label(bros);
    gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]), "clicked",GTK_SIGNAL_FUNC(kasdok_knopka),&data);
    gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK4],TRUE,TRUE, 0);
    tooltips[FK4]=gtk_tooltips_new();
    gtk_tooltips_set_tip(tooltips[FK4],data.knopka[FK4],gettext("Переход в режим работы с проводками для этого документа"),NULL);
    gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK4]),(gpointer)FK4);
    gtk_widget_show(data.knopka[FK4]);

    sprintf(bros,"F5 %s",gettext("Печать"));
    data.knopka[FK5]=gtk_button_new_with_label(bros);
    gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK5],TRUE,TRUE, 0);
    gtk_signal_connect(GTK_OBJECT(data.knopka[FK5]), "clicked",GTK_SIGNAL_FUNC(kasdok_knopka),&data);
    tooltips[FK5]=gtk_tooltips_new();
    gtk_tooltips_set_tip(tooltips[FK5],data.knopka[FK5],gettext("Распечатка документов"),NULL);
    gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK5]),(gpointer)FK5);
    gtk_widget_show(data.knopka[FK5]);


    sprintf(bros,"F7 %s",gettext("Подтверждение"));
    data.knopka[FK7]=gtk_button_new_with_label(bros);
    gtk_signal_connect(GTK_OBJECT(data.knopka[FK7]), "clicked",GTK_SIGNAL_FUNC(kasdok_knopka),&data);
    gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK7],TRUE,TRUE, 0);
    tooltips[FK7]=gtk_tooltips_new();
    gtk_tooltips_set_tip(tooltips[FK7],data.knopka[FK7],gettext("Подтверждение записи"),NULL);
    gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK7]),(gpointer)FK7);
    gtk_widget_show(data.knopka[FK7]);

    sprintf(bros,"%sF7 %s",RFK,gettext("Подтверждение"));
    data.knopka[SFK7]=gtk_button_new_with_label(bros);
    gtk_signal_connect(GTK_OBJECT(data.knopka[SFK7]), "clicked",GTK_SIGNAL_FUNC(kasdok_knopka),&data);
    gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK7],TRUE,TRUE, 0);
    tooltips[SFK7]=gtk_tooltips_new();
    gtk_tooltips_set_tip(tooltips[SFK7],data.knopka[SFK7],gettext("Подтверждение всех записей в документе"),NULL);
    gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK7]),(gpointer)SFK7);
    gtk_widget_show(data.knopka[SFK7]);

    sprintf(bros,"F8 %s",gettext("Снять под-ние"));
    data.knopka[FK8]=gtk_button_new_with_label(bros);
    gtk_signal_connect(GTK_OBJECT(data.knopka[FK8]), "clicked",GTK_SIGNAL_FUNC(kasdok_knopka),&data);
    gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK8],TRUE,TRUE, 0);
    tooltips[FK8]=gtk_tooltips_new();
    gtk_tooltips_set_tip(tooltips[FK8],data.knopka[FK8],gettext("Снять подтверждение со всего документа"),NULL);
    gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK8]),(gpointer)FK8);
    gtk_widget_show(data.knopka[FK8]);


    sprintf(bros,"F10 %s",gettext("Выход"));
    data.knopka[FK10]=gtk_button_new_with_label(bros);
    gtk_box_pack_start(GTK_BOX(vbox1),data.knopka[FK10],TRUE,TRUE, 0);
    tooltips[FK10]=gtk_tooltips_new();
    gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL);
    gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]), "clicked",GTK_SIGNAL_FUNC(kasdok_knopka),&data);
    gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10);
    gtk_widget_show(data.knopka[FK10]);

    gtk_widget_realize(data.window);
    gdk_window_set_cursor(data.window->window,gdk_cursor_new(ICEB_CURSOR));

    gtk_widget_grab_focus(data.knopka[FK10]);

    kasdok_create_list(&data);
    gtk_widget_show(data.window);

//if(metka == 0)
    gtk_window_maximize(GTK_WINDOW(data.window));
//gtk_window_fullscreen(GTK_WINDOW(data.window));


    gtk_main();



    if(wpredok != NULL)
        gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));

}
コード例 #2
0
ファイル: hex-document.c プロジェクト: krofna/ghex
gint
hex_document_export_html(HexDocument *doc, gchar *html_path, gchar *base_name,
                         guint start, guint end, guint cpl, guint lpp,
                         guint cpw)
{
  GtkWidget *progress_dialog, *progress_bar;
  FILE *file;
  int page, line, pos, lines, pages, c;
  gchar *page_name, b;
  gint update_pages;
  gchar *progress_str;

  lines = (end - start)/cpl;
  if((end - start)%cpl != 0)
    lines++;
  pages = lines/lpp;
  if(lines%lpp != 0)
    pages++;
  update_pages = pages/1000 + 1;

  /* top page */
  page_name = g_strdup_printf("%s/%s.html", html_path, base_name);
  file = fopen(page_name, "w");
  g_free(page_name);
  if(!file)
    return FALSE;
  fprintf(file, "<HTML>\n<HEAD>\n");
  fprintf(file, "<META HTTP-EQUIV=\"Content-Type\" "
          "CONTENT=\"text/html; charset=UTF-8\">\n");
  fprintf(file, "<META NAME=\"hexdata\" CONTENT=\"GHex export to HTML\">\n");
  fprintf(file, "</HEAD>\n<BODY>\n");

  fprintf(file, "<CENTER>");
  fprintf(file, "<TABLE BORDER=\"0\" CELLSPACING=\"0\" CELLPADDING=\"0\">\n");
  fprintf(file, "<TR>\n<TD COLSPAN=\"3\"><B>%s</B></TD>\n</TR>\n",
          doc->file_name?doc->file_name:doc->path_end);
  fprintf(file, "<TR>\n<TD COLSPAN=\"3\">&nbsp;</TD>\n</TR>\n");
  for(page = 0; page < pages; page++)
    {
      fprintf(file, "<TR>\n<TD>\n<A HREF=\"%s%08d.html\"><PRE>", base_name, page);
      fprintf(file, _("Page"));
      fprintf(file, " %d</PRE></A>\n</TD>\n<TD>&nbsp;</TD>\n<TD VALIGN=\"CENTER\"><PRE>%08x -", page+1, page*cpl*lpp);
      fprintf(file, " %08x</PRE></TD>\n</TR>\n", MIN((page+1)*cpl*lpp-1, doc->file_size-1));
    }
  fprintf(file, "</TABLE>\n</CENTER>\n");
  fprintf(file, "<HR WIDTH=\"100%%\">");
  fprintf(file, _("Hex dump generated by"));
  fprintf(file, " <B>"LIBGTKHEX_RELEASE_STRING"</B>\n");
  fprintf(file, "</BODY>\n</HTML>\n");
  fclose(file);

  progress_dialog = gtk_dialog_new();
  gtk_window_set_resizable(GTK_WINDOW(progress_dialog), FALSE);
  gtk_window_set_modal(GTK_WINDOW(progress_dialog), TRUE);
  g_signal_connect(G_OBJECT(progress_dialog), "delete-event",
                   G_CALLBACK(ignore_cb), NULL);
  gtk_window_set_title(GTK_WINDOW(progress_dialog),
                       _("Saving to HTML..."));
  progress_bar = gtk_progress_bar_new();
  gtk_widget_show(progress_bar);
  gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(progress_dialog))),
                    progress_bar);
  gtk_widget_show(progress_dialog);

  pos = start;
  g_object_ref(G_OBJECT(doc));
  for(page = 0; page < pages; page++)
    {
      if((page%update_pages) == 0)
        {
          gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progress_bar),
                                        (gdouble)page/(gdouble)pages);
          progress_str = g_strdup_printf("%d/%d", page, pages);
          gtk_progress_bar_set_text(GTK_PROGRESS_BAR(progress_bar),
                                    progress_str);
          g_free(progress_str);
          while(gtk_events_pending())
            gtk_main_iteration();
        }
      /* write page header */
      page_name = g_strdup_printf("%s/%s%08d.html",
                                  html_path, base_name, page);
      file = fopen(page_name, "w");
      g_free(page_name);
      if(!file)
        break;
      /* write header */
      fprintf(file, "<HTML>\n<HEAD>\n");
      fprintf(file, "<META HTTP-EQUIV=\"Content-Type\" CONTENT=\"text/html; charset=iso-8859-1\">\n");
      fprintf(file, "<META NAME=\"hexdata\" CONTENT=\"GHex export to HTML\">\n");
      fprintf(file, "</HEAD>\n<BODY>\n");
      /* write top table |previous|filename: page/pages|next| */
      fprintf(file, "<TABLE BORDER=\"0\" CELLSPACING=\"0\" WIDTH=\"100%%\">\n");
      fprintf(file, "<TR>\n<TD WIDTH=\"33%%\">\n");
      if(page > 0)
        {
          fprintf(file, "<A HREF=\"%s%08d.html\">", base_name, page-1);
          fprintf(file, _("Previous page"));
          fprintf(file, "</A>");
        }
      else
        fprintf(file, "&nbsp;");
      fprintf(file, "\n</TD>\n");
      fprintf(file, "<TD WIDTH=\"33%%\" ALIGN=\"CENTER\">\n");
      fprintf(file, "<A HREF=\"%s.html\">", base_name);
      fprintf(file, "%s:", doc->path_end);
      fprintf(file, "</A>");
      fprintf(file, " %d/%d", page+1, pages);
      fprintf(file, "\n</TD>\n");
      fprintf(file, "<TD WIDTH=\"33%%\" ALIGN=\"RIGHT\">\n");
      if(page < pages - 1)
        {
          fprintf(file, "<A HREF=\"%s%08d.html\">", base_name, page+1);
          fprintf(file, _("Next page"));
          fprintf(file, "</A>");
        }
      else
        fprintf(file, "&nbsp;");
      fprintf(file, "\n</TD>\n");
      fprintf(file, "</TR>\n</TABLE>\n");

      /* now the actual data */
      fprintf(file, "<CENTER>\n");
      fprintf(file, "<TABLE BORDER=\"1\" CELLSPACING=\"2\" CELLPADDING=\"2\">\n");
      fprintf(file, "<TR>\n<TD>\n");
      fprintf(file, "<TABLE BORDER=\"0\" CELLSPACING=\"0\" CELLPADDING=\"0\">\n");
      for(line = 0; line < lpp && pos + line*cpl < doc->file_size; line++)
        {
          /* offset of line*/
          fprintf(file, "<TR>\n<TD>\n");
          fprintf(file, "<PRE>%08x</PRE>\n", pos + line*cpl);
          fprintf(file, "</TD>\n</TR>\n");
        }
      fprintf(file, "</TABLE>\n");
      fprintf(file, "</TD>\n<TD>\n");
      fprintf(file, "<TABLE BORDER=\"0\" CELLSPACING=\"0\" CELLPADDING=\"0\">\n");
      c = 0;
      for(line = 0; line < lpp; line++)
        {
          /* hex data */
          fprintf(file, "<TR>\n<TD>\n<PRE>");
          while(pos + c < end)
            {
              fprintf(file, "%02x", hex_document_get_byte(doc, pos + c));
              c++;
              if(c%cpl == 0)
                break;
              if(c%cpw == 0)
                fprintf(file, " ");
            }
          fprintf(file, "</PRE>\n</TD>\n</TR>\n");
        }
      fprintf(file, "</TABLE>\n");
      fprintf(file, "</TD>\n<TD>\n");
      fprintf(file, "<TABLE BORDER=\"0\" CELLSPACING=\"0\" CELLPADDING=\"0\">\n");
      c = 0;
      for(line = 0; line < lpp; line++)
        {
          /* ascii data */
          fprintf(file, "<TR>\n<TD>\n<PRE>");
          while(pos + c < end)
            {
              b = hex_document_get_byte(doc, pos + c);
              if(b >= 0x20)
                fprintf(file, "%c", b);
              else
                fprintf(file, ".");
              c++;
              if(c%cpl == 0)
                break;
            }
          fprintf(file, "</PRE></TD>\n</TR>\n");
          if(pos >= end)
            line = lpp;
        }
      pos += c;
      fprintf(file, "</TD>\n</TR>\n");
      fprintf(file, "</TABLE>\n");
      fprintf(file, "</TABLE>\n</CENTER>\n");
      fprintf(file, "<HR WIDTH=\"100%%\">");
      fprintf(file, _("Hex dump generated by"));
      fprintf(file, " <B>" LIBGTKHEX_RELEASE_STRING "</B>\n");
      fprintf(file, "</BODY>\n</HTML>\n");
      fclose(file);
    }
  g_object_unref(G_OBJECT(doc));
  gtk_widget_destroy(progress_dialog);

  return TRUE;
}
コード例 #3
0
ファイル: l_uosmo_v.c プロジェクト: zaharchuktv/linuxbuh
int l_uosmo_v(class iceb_u_str *kod_podr,GtkWidget *wpredok)
{

class l_uosmo_v_data data;
char strsql[512];
iceb_u_str kikz;
data.kod_podr.new_plus(kod_podr->ravno());

data.rk.clear_data();

if(data.kod_podr.getdlinna() >  1)
 {
  data.rk.kod.new_plus(data.kod_podr.ravno());
  sprintf(strsql,"select * from Uosol where kod=%s",data.kod_podr.ravno());
  SQL_str row;
  SQLCURSOR cur;
  if(iceb_sql_readkey(strsql,&row,&cur,wpredok) < 1)
   {
    iceb_menu_soob(gettext("Не найдена запись для корректировки !"),wpredok);
    return(1);
   }
  data.rk.metka_sost=atoi(row[4]);
  data.rk.naim.new_plus(row[1]);
  kikz.plus(iceb_kikz(row[2],row[3],wpredok));
  data.rk.metka_sost=atoi(row[4]);
 }
else
 {
  sprintf(strsql,"%d",iceb_get_new_kod("Uosol",0,wpredok));
  data.rk.kod.new_plus(strsql);
 } 

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);

GtkWidget *label=NULL;

if(data.kod_podr.getdlinna() <= 1)
 {
  sprintf(strsql,"%s %s",name_system,gettext("Ввод новой записи"));
  label=gtk_label_new(gettext("Ввод новой записи"));
 }
else
 {
  sprintf(strsql,"%s %s",name_system,gettext("Корректировка записи"));
  iceb_u_str repl;
  repl.plus(gettext("Корректировка записи"));
  repl.ps_plus(kikz.ravno());
  label=gtk_label_new(repl.ravno_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(l_uosmo_v_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, 0);
GtkWidget *hbox[KOLENTER];
for(int i=0; i < KOLENTER; i++)
 hbox[i] = gtk_hbox_new (FALSE, 0);
GtkWidget *hboxknop = gtk_hbox_new (FALSE, 0);

gtk_container_add (GTK_CONTAINER (data.window), vbox);
gtk_container_add (GTK_CONTAINER (vbox), label);
for(int i=0; i < KOLENTER; i++)
 gtk_container_add (GTK_CONTAINER (vbox), hbox[i]);
gtk_container_add (GTK_CONTAINER (vbox), hboxknop);


label=gtk_label_new(gettext("Код"));
data.entry[E_KOD] = gtk_entry_new_with_max_length (10);
gtk_box_pack_start (GTK_BOX (hbox[E_KOD]), label, FALSE, FALSE, 0);

gtk_box_pack_start (GTK_BOX (hbox[E_KOD]), data.entry[E_KOD], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_KOD]), "activate",GTK_SIGNAL_FUNC(l_uosmo_v_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOD]),data.rk.kod.ravno_toutf());
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOD]),(gpointer)E_KOD);



label=gtk_label_new(gettext("Фамилия"));
data.entry[E_NAIM] = gtk_entry_new_with_max_length (60);
gtk_box_pack_start (GTK_BOX (hbox[E_NAIM]), label, FALSE, FALSE, 0);

gtk_box_pack_start (GTK_BOX (hbox[E_NAIM]), data.entry[E_NAIM], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_NAIM]), "activate",GTK_SIGNAL_FUNC(l_uosmo_v_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_NAIM]),data.rk.naim.ravno_toutf());
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_NAIM]),(gpointer)E_NAIM);

label=gtk_label_new(gettext("Состояние"));
gtk_box_pack_start (GTK_BOX (hbox[E_SOST]), label, FALSE, FALSE, 0);

class iceb_u_spisok menu_vib;
menu_vib.plus(gettext("Используется"));
menu_vib.plus(gettext("Неиспользуется"));

iceb_pm_vibor(&menu_vib,&data.opt,&data.rk.metka_sost);
gtk_box_pack_start (GTK_BOX (hbox[E_SOST]), data.opt, FALSE, FALSE, 0);

GtkTooltips *tooltips[KOL_PFK];

sprintf(strsql,"F2 %s",gettext("Запись"));
data.knopka[PFK2]=gtk_button_new_with_label(strsql);
tooltips[PFK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[PFK2],data.knopka[PFK2],gettext("Запись введеной в меню информации"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[PFK2]),"clicked",GTK_SIGNAL_FUNC(l_uosmo_v_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[PFK2]),(gpointer)PFK2);

sprintf(strsql,"F10 %s",gettext("Выход"));
data.knopka[PFK10]=gtk_button_new_with_label(strsql);
tooltips[PFK10]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[PFK10],data.knopka[PFK10],gettext("Завершение работы с меню без записи введенной информации"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[PFK10]),"clicked",GTK_SIGNAL_FUNC(l_uosmo_v_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[PFK10]),(gpointer)PFK10);

gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[PFK2], TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[PFK10], TRUE, TRUE, 0);

gtk_widget_grab_focus(data.entry[0]);

gtk_widget_show_all (data.window);

gtk_main();
if(data.voz == 0)
 kod_podr->new_plus(data.rk.kod.ravno());
return(data.voz);
}
コード例 #4
0
static void addressbook_edit_jpilot_create( gboolean *cancelled ) {
	GtkWidget *window;
	GtkWidget *vbox;
	GtkWidget *table;
	GtkWidget *label;
	GtkWidget *name_entry;
	GtkWidget *file_entry;
	GtkWidget *vbox_custom;
	GtkWidget *frame_custom;
	GtkWidget *custom_check[JPILOT_NUM_CUSTOM_LABEL];
	GtkWidget *custom_label[JPILOT_NUM_CUSTOM_LABEL];
	GtkWidget *hlbox;
	GtkWidget *hbbox;
	GtkWidget *hsep;
	GtkWidget *ok_btn;
	GtkWidget *cancel_btn;
	GtkWidget *check_btn;
	GtkWidget *file_btn;
	GtkWidget *hsbox;
	GtkWidget *statusbar;
	gint top, i;

	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_widget_set_size_request(window, 450, -1);
	gtk_container_set_border_width(GTK_CONTAINER(window), 0);
	gtk_window_set_title(GTK_WINDOW(window), _("Edit JPilot Entry"));
	gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
	gtk_window_set_modal(GTK_WINDOW(window), TRUE);	
	g_signal_connect(G_OBJECT(window), "delete_event",
			 G_CALLBACK(edit_jpilot_delete_event),
			 cancelled);
	g_signal_connect(G_OBJECT(window), "key_press_event",
			 G_CALLBACK(edit_jpilot_key_pressed),
			 cancelled);

	vbox = gtk_vbox_new(FALSE, 8);
	gtk_container_add(GTK_CONTAINER(window), vbox);
	gtk_container_set_border_width( GTK_CONTAINER(vbox), 0 );

	table = gtk_table_new(2 + JPILOT_NUM_CUSTOM_LABEL, 3, FALSE);
	gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
	gtk_container_set_border_width( GTK_CONTAINER(table), 8 );
	gtk_table_set_row_spacings(GTK_TABLE(table), 8);
	gtk_table_set_col_spacings(GTK_TABLE(table), 8);

	/* First row */
	top = 0;
	label = gtk_label_new(_("Name"));
	gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0);
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);

	name_entry = gtk_entry_new();
	gtk_table_attach(GTK_TABLE(table), name_entry, 1, 2, top, (top + 1), GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0);

	check_btn = gtk_button_new_with_label( _(" Check File "));
	gtk_table_attach(GTK_TABLE(table), check_btn, 2, 3, top, (top + 1), GTK_FILL, 0, 3, 0);

	/* Second row */
	top = 1;
	label = gtk_label_new(_("File"));
	gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0);
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);

	file_entry = gtk_entry_new();
	gtk_table_attach(GTK_TABLE(table), file_entry, 1, 2, top, (top + 1), GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0);

	file_btn = gtk_button_new_with_label( _(" ... "));
	gtk_table_attach(GTK_TABLE(table), file_btn, 2, 3, top, (top + 1), GTK_FILL, 0, 3, 0);

	/* Third row */
	top = 2;
	frame_custom = gtk_frame_new(_("Additional e-Mail address item(s)"));
	gtk_table_attach(GTK_TABLE(table), frame_custom, 1, 2, top, (top + JPILOT_NUM_CUSTOM_LABEL), GTK_FILL, 0, 0, 0);

	/* Now do custom labels. */
	vbox_custom = gtk_vbox_new (FALSE, 8);
	for( i = 0; i < JPILOT_NUM_CUSTOM_LABEL; i++ ) {
		hlbox = gtk_hbox_new( FALSE, 0 );
		custom_check[i] = gtk_check_button_new();
		custom_label[i] = gtk_label_new( "" );
		gtk_box_pack_start( GTK_BOX(hlbox), custom_check[i], FALSE, FALSE, 0 );
		gtk_box_pack_start( GTK_BOX(hlbox), custom_label[i], TRUE, TRUE, 0 );
		gtk_box_pack_start( GTK_BOX(vbox_custom), hlbox, TRUE, TRUE, 0 );
		gtk_misc_set_alignment(GTK_MISC(custom_label[i]), 0, 0.5);
		top++;
	}
	gtk_container_add (GTK_CONTAINER (frame_custom), vbox_custom);
	gtk_container_set_border_width( GTK_CONTAINER(vbox_custom), 8 );

	/* Status line */
	hsbox = gtk_hbox_new(FALSE, 0);
	gtk_box_pack_end(GTK_BOX(vbox), hsbox, FALSE, FALSE, 0);
	statusbar = gtk_statusbar_new();
	gtk_box_pack_start(GTK_BOX(hsbox), statusbar, TRUE, TRUE, 0);

	/* Button panel */
	gtkut_stock_button_set_create(&hbbox, &ok_btn, GTK_STOCK_OK,
				      &cancel_btn, GTK_STOCK_CANCEL,
				      NULL, NULL);
	gtk_box_pack_end(GTK_BOX(vbox), hbbox, FALSE, FALSE, 0);
	gtk_container_set_border_width( GTK_CONTAINER(hbbox), 0 );
	gtk_widget_grab_default(ok_btn);

	hsep = gtk_hseparator_new();
	gtk_box_pack_end(GTK_BOX(vbox), hsep, FALSE, FALSE, 0);

	g_signal_connect(G_OBJECT(ok_btn), "clicked",
			 G_CALLBACK(edit_jpilot_ok), cancelled);
	g_signal_connect(G_OBJECT(cancel_btn), "clicked",
			 G_CALLBACK(edit_jpilot_cancel), cancelled);
	g_signal_connect(G_OBJECT(file_btn), "clicked",
			 G_CALLBACK(edit_jpilot_file_select), NULL);
	g_signal_connect(G_OBJECT(check_btn), "clicked",
			 G_CALLBACK(edit_jpilot_file_check), NULL);

	gtk_widget_show_all(vbox);

	jpilotedit.window     = window;
	jpilotedit.name_entry = name_entry;
	jpilotedit.file_entry = file_entry;
	jpilotedit.hbbox      = hbbox;
	jpilotedit.ok_btn     = ok_btn;
	jpilotedit.cancel_btn = cancel_btn;
	jpilotedit.statusbar  = statusbar;
	jpilotedit.status_cid = gtk_statusbar_get_context_id( GTK_STATUSBAR(statusbar), "Edit JPilot Dialog" );
	for( i = 0; i < JPILOT_NUM_CUSTOM_LABEL; i++ ) {
		jpilotedit.custom_check[i] = custom_check[i];
		jpilotedit.custom_label[i] = custom_label[i];
	}
}
コード例 #5
0
void FenetrePropriete_initialiser( FenetrePropriete* fp, Scene* scene )
{
    fp->fenetre = gtk_window_new( GTK_WINDOW_TOPLEVEL );
    fp->scene = scene;
    fp->dernierLayout = (char*)malloc( 50 * sizeof( char ) );
    fp->dernierLayout = strcpy( fp->dernierLayout, "Initialisation" );

    gtk_window_set_position( GTK_WINDOW( fp->fenetre ), GTK_WIN_POS_CENTER );
    gtk_window_set_modal( GTK_WINDOW( fp->fenetre ), TRUE );
    gtk_window_set_title( GTK_WINDOW( fp->fenetre ), "Propriete de l'objet" );

    fp->entry1 = gtk_entry_new();
    fp->entry2 = gtk_entry_new();
    fp->entry3 = gtk_entry_new();

    gtk_widget_set_size_request(fp->entry1, 50, -1 );
    gtk_widget_set_size_request(fp->entry2, 70, -1 );
    gtk_widget_set_size_request(fp->entry3, 70, -1 );

    GtkWidget* text1 = gtk_label_new("Position X : ");
    GtkWidget* text2 = gtk_label_new("Position Y : ");
    GtkWidget* text3 = gtk_label_new("Position Z : ");

//***************************************************************************

    fp->barreObjet = gtk_hbutton_box_new();

    fp->objet = g_array_index( scene->selection->tSelection, Objet*, 0 );

    char buf[255];
    sprintf( buf, "%.3f", fp->objet->type.cube->tPoint[0].x );
    char buf1[255];
    sprintf( buf1, "%.3f", fp->objet->type.cube->tPoint[0].y );
    char buf2[255];
    sprintf( buf2, "%.3f", fp->objet->type.cube->tPoint[0].z );

    gtk_container_add( GTK_CONTAINER( fp->barreObjet ), text1 );
    gtk_container_add( GTK_CONTAINER( fp->barreObjet ), fp->entry1 );
    gtk_entry_set_text( GTK_ENTRY( fp->entry1 ), buf );

    gtk_container_add( GTK_CONTAINER( fp->barreObjet ), text2 );
    gtk_container_add( GTK_CONTAINER( fp->barreObjet ), fp->entry2 );
    gtk_entry_set_text( GTK_ENTRY( fp->entry2 ), buf1 );

    gtk_container_add( GTK_CONTAINER( fp->barreObjet ), text3 );
    gtk_container_add( GTK_CONTAINER( fp->barreObjet ), fp->entry3 );
    gtk_entry_set_text( GTK_ENTRY( fp->entry3 ), buf2 );

    gtk_button_box_set_layout( GTK_BUTTON_BOX( fp->barreObjet ), GTK_BUTTONBOX_START );

    g_object_ref( fp->barreObjet );

    //*************** Barre Bouton ***********************************

    fp->boutonOk = gtk_button_new_with_label("OK");
    fp->boutonAnnuler = gtk_button_new_with_label("Annuler");

    fp->barreBouton = gtk_hbutton_box_new();
    gtk_button_box_set_layout( GTK_BUTTON_BOX( fp->barreBouton ), GTK_BUTTONBOX_END );

    gtk_container_add( GTK_CONTAINER( fp->barreBouton ), fp->boutonOk );
    gtk_container_add( GTK_CONTAINER( fp->barreBouton ), fp->boutonAnnuler );

    g_object_ref( fp->barreBouton );

    //*******************************************************************

    fp->comboBoxGroupe = gtk_combo_box_text_new();

    int i = 0;
    int numGroupe = 0;

    for( i = 0; i < scene->nbGroupe; i++ )
    {
        Groupe* groupe = g_array_index( scene->tGroupe, Groupe*, i );
        gtk_combo_box_text_append_text( GTK_COMBO_BOX_TEXT( fp->comboBoxGroupe ), groupe->nom );

        if( fp->objet->numeroGroupe == groupe->id )
        {
            numGroupe = i;
        }
    }

    gtk_widget_set_size_request( GTK_WIDGET( fp->comboBoxGroupe ), 100, -1 );
    gtk_combo_box_set_active( GTK_COMBO_BOX( fp->comboBoxGroupe ), numGroupe );
    g_signal_emit_by_name( GTK_OBJECT( fp->comboBoxGroupe ), "changed", NULL );

     //*************** Barre de couleur *******************************
    fp->entryR = gtk_entry_new();
    fp->entryG = gtk_entry_new();
    fp->entryB = gtk_entry_new();
    fp->entryA = gtk_entry_new();

    GtkWidget* lab = gtk_label_new("Couleur RGBA [0-255]:");

    gtk_widget_set_size_request( fp->entryR, 30, -1 );
    gtk_widget_set_size_request( fp->entryG, 30, -1 );
    gtk_widget_set_size_request( fp->entryB, 30, -1 );
    gtk_widget_set_size_request( fp->entryA, 30, -1 );

    Color tColor;
    Objet_get_Color( fp->objet, tColor );

    char buf4[255];
    sprintf( buf4, "%.0f", tColor[0]*255 );
    char buf5[255];
    sprintf( buf5, "%.0f", tColor[1]*255 );
    char buf6[255];
    sprintf( buf6, "%.0f", tColor[2]*255 );
    char buf7[255];
    sprintf( buf7, "%.0f", tColor[3]);

    gtk_entry_set_text( GTK_ENTRY( fp->entryR ), buf4 );
    gtk_entry_set_text( GTK_ENTRY( fp->entryG ), buf5 );
    gtk_entry_set_text( GTK_ENTRY( fp->entryB ), buf6 );
    gtk_entry_set_text( GTK_ENTRY( fp->entryA ), buf7 );

    fp->barreCouleur = gtk_hbutton_box_new();
    gtk_button_box_set_layout( GTK_BUTTON_BOX( fp->barreCouleur ), GTK_BUTTONBOX_END );

    gtk_container_add( GTK_CONTAINER( fp->barreCouleur ), lab );
    gtk_container_add( GTK_CONTAINER( fp->barreCouleur ), fp->entryR );
    gtk_container_add( GTK_CONTAINER( fp->barreCouleur ), fp->entryG );
    gtk_container_add( GTK_CONTAINER( fp->barreCouleur ), fp->entryB );
    gtk_container_add( GTK_CONTAINER( fp->barreCouleur ), fp->entryA );

    g_object_ref( fp->barreCouleur );

//*********************************************************************************************
    fp->layout = gtk_vbox_new( FALSE, 10 );

    gtk_container_add( GTK_CONTAINER( fp->layout ), fp->barreObjet );
    gtk_container_add( GTK_CONTAINER( fp->layout ), fp->barreCouleur );
    gtk_container_add( GTK_CONTAINER( fp->layout ), fp->comboBoxGroupe );
    gtk_container_add( GTK_CONTAINER( fp->layout ), fp->barreBouton );

    gtk_container_add( GTK_CONTAINER( fp->fenetre ), fp->layout );

    gtk_widget_show_all(fp->fenetre);

    g_signal_connect_object( G_OBJECT( fp->boutonAnnuler ), "clicked", G_CALLBACK( gtk_widget_destroy ), fp->fenetre, G_CONNECT_SWAPPED );
    g_signal_connect( G_OBJECT( fp->boutonOk ), "clicked", G_CALLBACK( FenetrePropriete_validation ), fp );

}
コード例 #6
0
static gchar*
passphrase_mbox(const gchar *uid_hint, const gchar *pass_hint, gint prev_bad)
{
    gchar *the_passphrase = NULL;
    GtkWidget *vbox;
    GtkWidget *confirm_box;
    GtkWidget *window;
    GtkWidget *pass_entry;
    GtkWidget *ok_button;
    GtkWidget *cancel_button;

    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(window), _("Passphrase"));
    gtk_widget_set_size_request(window, 450, -1);
    gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
    gtk_window_set_modal(GTK_WINDOW(window), TRUE);
    gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE);
    g_signal_connect(G_OBJECT(window), "delete_event",
                     G_CALLBACK(passphrase_deleted), NULL);
    g_signal_connect(G_OBJECT(window), "key_press_event",
                     G_CALLBACK(passphrase_key_pressed), NULL);
    MANAGE_WINDOW_SIGNALS_CONNECT(window);
    manage_window_set_transient(GTK_WINDOW(window));

    vbox = gtk_vbox_new(FALSE, 8);
    gtk_container_add(GTK_CONTAINER(window), vbox);
    gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);

    if (uid_hint || pass_hint) {
        GtkWidget *label;
        label = create_description (uid_hint, pass_hint, prev_bad);
        gtk_box_pack_start (GTK_BOX(vbox), label, FALSE, FALSE, 0);
    }

    pass_entry = gtk_entry_new();
    gtk_box_pack_start(GTK_BOX(vbox), pass_entry, FALSE, FALSE, 0);
    gtk_entry_set_visibility(GTK_ENTRY(pass_entry), FALSE);
    gtk_widget_grab_focus(pass_entry);

    gtkut_stock_button_set_create(&confirm_box, &ok_button, GTK_STOCK_OK,
				  &cancel_button, GTK_STOCK_CANCEL,
				  NULL, NULL);
    gtk_box_pack_end(GTK_BOX(vbox), confirm_box, FALSE, FALSE, 0);
    gtk_widget_grab_default(ok_button);

    g_signal_connect(G_OBJECT(ok_button), "clicked",
                     G_CALLBACK(passphrase_ok_cb), NULL);
    g_signal_connect(G_OBJECT(pass_entry), "activate",
                     G_CALLBACK(passphrase_ok_cb), NULL);
    g_signal_connect(G_OBJECT(cancel_button), "clicked",
                     G_CALLBACK(passphrase_cancel_cb), NULL);

    gtk_window_set_position (GTK_WINDOW(window), GTK_WIN_POS_CENTER);
    if (grab_all)   
        gtk_window_set_policy (GTK_WINDOW(window), FALSE, FALSE, TRUE);
    
    gtk_widget_show_all(window);

    if (grab_all) {
        /* make sure that window is viewable
	 * FIXME: this is still not enough */
        gtk_widget_show_now(window);
	gdk_flush();
#ifdef GDK_WINDOWING_X11
	gdk_x11_display_grab(gdk_display_get_default());
#endif /* GDK_WINDOWING_X11 */
        if (gdk_pointer_grab(window->window, TRUE, 0,
                             window->window, NULL, GDK_CURRENT_TIME)) {
#ifdef GDK_WINDOWING_X11
            gdk_x11_display_ungrab(gdk_display_get_default());
#endif /* GDK_WINDOWING_X11 */
            g_warning("OOPS: Could not grab mouse\n");
            gtk_widget_destroy(window);
            return NULL;
        }
        if (gdk_keyboard_grab(window->window, FALSE, GDK_CURRENT_TIME)) {
            gdk_display_pointer_ungrab(gdk_display_get_default(),
			 	       GDK_CURRENT_TIME);
#ifdef GDK_WINDOWING_X11
            gdk_x11_display_ungrab(gdk_display_get_default());
#endif /* GDK_WINDOWING_X11 */
            g_warning("OOPS: Could not grab keyboard\n");
            gtk_widget_destroy(window);
            return NULL;
        }
    }

    gtk_main();

    if (grab_all) {
        gdk_display_keyboard_ungrab(gdk_display_get_default(),
				    GDK_CURRENT_TIME);
        gdk_display_pointer_ungrab(gdk_display_get_default(), GDK_CURRENT_TIME);
#ifdef GDK_WINDOWING_X11
        gdk_x11_display_ungrab(gdk_display_get_default());
#endif /* GDK_WINDOWING_X11 */
        gdk_flush();
    }

    manage_window_focus_out(window, NULL, NULL);

    if (pass_ack) {
        const gchar *entry_text;
        entry_text = gtk_entry_get_text(GTK_ENTRY(pass_entry));
        the_passphrase = g_locale_from_utf8(entry_text, -1, NULL, NULL, NULL);
        if (!the_passphrase)
            the_passphrase = g_strdup(entry_text);
    }
    gtk_widget_destroy(window);

    return the_passphrase;
}
コード例 #7
0
ファイル: sat-info.c プロジェクト: mstfkaratas/gpredict
/**
 * Show satellite info in a dialog
 *
 * @param sat Pointer to the sat info.
 * @param data Pointer to parent window or NULL.
 *
 * FIXME: see nice drawing at http://www.amsat.org/amsat-new/tools/keps_tutorial.php
 */
void show_sat_info(sat_t * sat, gpointer data)
{
    GtkWidget      *dialog;
    GtkWidget      *notebook;
    GtkWidget      *table;
    GtkWidget      *label;
    GtkWindow      *toplevel = NULL;
    gchar          *str;


    if (data != NULL)
        toplevel = GTK_WINDOW(data);

    /* create table */
    table = gtk_grid_new();
    gtk_grid_set_column_spacing(GTK_GRID(table), 5);
    gtk_grid_set_row_spacing(GTK_GRID(table), 5);
    gtk_container_set_border_width(GTK_CONTAINER(table), 10);

    /* satellite name */
    label = gtk_label_new(NULL);
    gtk_label_set_markup(GTK_LABEL(label), _("<b>Satellite name:</b>"));
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 0, 0, 1, 1);

    label = gtk_label_new(NULL);
    str = g_markup_printf_escaped(_("<b>%s</b>"), sat->nickname);
    gtk_label_set_markup(GTK_LABEL(label), str);
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 1, 0, 1, 1);
    g_free(str);

    /* operational status */
    label = gtk_label_new(_("Operational Status:"));
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 0, 1, 1, 1);

    switch (sat->tle.status)
    {

    case OP_STAT_OPERATIONAL:
        label = gtk_label_new(_("Operational"));
        break;

    case OP_STAT_NONOP:
        label = gtk_label_new(_("Non-operational"));
        break;

    case OP_STAT_PARTIAL:
        label = gtk_label_new(_("Partially operational"));
        break;

    case OP_STAT_STDBY:
        label = gtk_label_new(_("Backup/Standby"));
        break;

    case OP_STAT_SPARE:
        label = gtk_label_new(_("Spare"));
        break;

    case OP_STAT_EXTENDED:
        label = gtk_label_new(_("Extended Mission"));
        break;

    default:
        label = gtk_label_new(_("Unknown"));
        break;

    }

    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 1, 1, 1, 1);

    /* Catnum */
    label = gtk_label_new(_("Catalogue number:"));
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 0, 2, 1, 1);

    str = g_strdup_printf("%d", sat->tle.catnr);
    label = gtk_label_new(str);
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 1, 2, 1, 1);
    g_free(str);

    /* international designator */
    label = gtk_label_new(_("International designator:"));
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 0, 3, 1, 1);

    label = gtk_label_new(sat->tle.idesg);
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 1, 3, 1, 1);

    /* elset number */
    label = gtk_label_new(_("Element set number:"));
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 0, 4, 1, 1);

    str = g_strdup_printf("%d", sat->tle.elset);
    label = gtk_label_new(str);
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 1, 4, 1, 1);
    g_free(str);

    /* elset epoch */
    label = gtk_label_new(_("Epoch time:"));
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 0, 5, 1, 1);

    str = epoch_to_str(sat);
    label = gtk_label_new(str);
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 1, 5, 1, 1);
    g_free(str);

    /* Revolution Number @ Epoch */
    label = gtk_label_new(_("Orbit number @ epoch:"));
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 0, 6, 1, 1);

    str = g_strdup_printf("%d", sat->tle.revnum);
    label = gtk_label_new(str);
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 1, 6, 1, 1);
    g_free(str);

    /* ephermis type left out, since it is always 0 */

    /* separator */
    gtk_grid_attach(GTK_GRID(table),
                    gtk_separator_new(GTK_ORIENTATION_HORIZONTAL),
                    0, 7, 2, 1); 

    /* Orbit inclination */
    label = gtk_label_new(_("Inclination:"));
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 0, 8, 1, 1);

    str = g_strdup_printf("%.4f\302\260", sat->tle.xincl / de2ra);
    label = gtk_label_new(str);
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 1, 8, 1, 1);
    g_free(str);

    /* RAAN */
    label = gtk_label_new(_("RAAN:"));
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 0, 9, 1, 1);

    str = g_strdup_printf("%.4f\302\260", sat->tle.xnodeo / de2ra);
    label = gtk_label_new(str);
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 1, 9, 1, 1);
    g_free(str);

    /* Eccentricity */
    label = gtk_label_new(_("Eccentricity:"));
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 0, 10, 1, 1);

    str = g_strdup_printf("%.7f", sat->tle.eo);
    label = gtk_label_new(str);
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 1, 10, 1, 1);
    g_free(str);

    /* Argument of perigee */
    label = gtk_label_new(_("Arg. of perigee:"));
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 0, 11, 1, 1);

    str = g_strdup_printf("%.4f\302\260", sat->tle.omegao / de2ra);
    label = gtk_label_new(str);
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 1, 11, 1, 1);
    g_free(str);

    /* Mean Anomaly */
    label = gtk_label_new(_("Mean anomaly:"));
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 0, 12, 1, 1);

    str = g_strdup_printf("%.4f\302\260", sat->tle.xmo / de2ra);
    label = gtk_label_new(str);
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 1, 12, 1, 1);
    g_free(str);

    /* Mean Motion */
    label = gtk_label_new(_("Mean motion:"));
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 0, 13, 1, 1);

    str = g_strdup_printf("%.8f [rev/day]", sat->meanmo);
    label = gtk_label_new(str);
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 1, 13, 1, 1);
    g_free(str);

    /* one half of the first time derivative of mean motion */
    label = gtk_label_new(_("\302\275 d/dt (mean motion):"));
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 0, 14, 1, 1);

    str = g_strdup_printf("%.5e [rev/day<sup>2</sup>]",
                          sat->tle.xndt2o / (twopi / xmnpda / xmnpda));
    label = gtk_label_new(NULL);
    gtk_label_set_markup(GTK_LABEL(label), str);
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 1, 14, 1, 1);
    g_free(str);

    /* one sixth of the second time derivative of mean motion */
    label = gtk_label_new(NULL);
    gtk_label_set_markup(GTK_LABEL(label),
                         _("1/6 d<sup>2</sup>/dt<sup>2</sup> (mean motion):"));
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 0, 15, 1, 1);

    str = g_strdup_printf("%.5e [rev/day<sup>3</sup>]",
                          sat->tle.xndd6o * xmnpda / (twopi / xmnpda / xmnpda));
    label = gtk_label_new(NULL);
    gtk_label_set_markup(GTK_LABEL(label), str);
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 1, 15, 1, 1);
    g_free(str);

    /* B* drag term */
    label = gtk_label_new(_("B* drag term:"));
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 0, 16, 1, 1);

    str = g_strdup_printf("%.5e [R<sub>E</sub><sup>-1</sup>]",
                          sat->tle.bstar * ae);
    label = gtk_label_new(NULL);
    gtk_label_set_markup(GTK_LABEL(label), str);
    g_object_set(label, "xalign", 0.0, "yalign", 0.5, NULL);
    gtk_grid_attach(GTK_GRID(table), label, 1, 16, 1, 1);
    g_free(str);

    /* Orbit type */

    /* Next Event */

    gtk_widget_show_all(table);

    notebook = gtk_notebook_new();
    gtk_notebook_append_page(GTK_NOTEBOOK(notebook), table,
                             gtk_label_new(_("Orbit Info")));
    gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
                             create_transponder_table(sat->tle.catnr),
                             gtk_label_new(_("Transponders")));

    /* create dialog window with NULL parent */
    dialog = gtk_dialog_new_with_buttons(_("Satellite Info"),
                                         toplevel,
                                         GTK_DIALOG_DESTROY_WITH_PARENT,
                                         "_OK",
                                         GTK_RESPONSE_ACCEPT, NULL);

    /* allow interaction with other windows */
    gtk_window_set_modal(GTK_WINDOW(dialog), FALSE);

    g_signal_connect(dialog, "response", G_CALLBACK(gtk_widget_destroy), NULL);

    GtkWidget *content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
    gtk_box_pack_start(GTK_BOX(content_area), notebook, TRUE, TRUE, 0);

    gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);

    gtk_widget_show_all(dialog);
}
コード例 #8
0
static void xmi_msim_gui_layer_dialog_init(XmiMsimGuiLayerDialog *dialog) {
  gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
  gtk_window_set_destroy_with_parent(GTK_WINDOW(dialog), TRUE);
  gtk_dialog_add_buttons(GTK_DIALOG(dialog), "_Ok", GTK_RESPONSE_ACCEPT, "_Cancel", GTK_RESPONSE_REJECT, NULL);
  gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
  gtk_window_set_default_size(GTK_WINDOW(dialog), 200, 200);

  GtkWidget *contentArea = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
  GtkWidget *mainVBox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
  gtk_box_set_homogeneous(GTK_BOX(mainVBox), FALSE);
  gtk_container_set_border_width(GTK_CONTAINER(mainVBox),5);
  gtk_container_add(GTK_CONTAINER(contentArea), mainVBox);

  GtkListStore *store = gtk_list_store_new(N_COLUMNS_LAYER, G_TYPE_STRING, G_TYPE_DOUBLE, G_TYPE_INT);
  //construct tree
  GtkWidget *HBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
  gtk_box_set_homogeneous(GTK_BOX(HBox), FALSE);
  GtkWidget *compositionTreeView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
  GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
  gtk_cell_renderer_set_alignment(renderer, 0.5, 0.5);
  GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes("Element", renderer, "text", SYMBOL_COLUMN, NULL);
  gtk_tree_view_column_set_resizable(column, TRUE);
  gtk_tree_view_column_set_alignment(column, 0.5);
  gtk_tree_view_append_column(GTK_TREE_VIEW(compositionTreeView), column);

  renderer = gtk_cell_renderer_text_new();
  gtk_cell_renderer_set_alignment(renderer, 0.5, 0.5);
  column = gtk_tree_view_column_new_with_attributes("Weight fraction (%)", renderer, "text", WEIGHT_COLUMN, NULL);
  gtk_tree_view_column_set_resizable(column, TRUE);
  gtk_tree_view_column_set_alignment(column, 0.5);
  gtk_tree_view_append_column(GTK_TREE_VIEW(compositionTreeView), column);

  GtkWidget *scrolledWindow = gtk_scrolled_window_new(NULL, NULL);
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  gtk_widget_set_size_request(scrolledWindow, 220, 150);
  gtk_container_add(GTK_CONTAINER(scrolledWindow), compositionTreeView);
  GtkWidget *frame = gtk_frame_new(NULL);
  gtk_container_add(GTK_CONTAINER(frame), scrolledWindow);
  gtk_box_pack_start(GTK_BOX(HBox), frame, FALSE, FALSE, 3);

  //selections
  GtkTreeSelection *select = gtk_tree_view_get_selection(GTK_TREE_VIEW(compositionTreeView));
  gtk_tree_selection_set_mode(select, GTK_SELECTION_MULTIPLE);
  g_signal_connect(G_OBJECT(select), "changed", G_CALLBACK(element_selection_changed), (gpointer) dialog);


  //add/edit/remove
  GtkWidget *VBox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
  gtk_box_set_homogeneous(GTK_BOX(VBox), FALSE);
  GtkWidget *addButton = gtk_button_new_with_mnemonic("_Add");
  GtkWidget *editButton = gtk_button_new_with_mnemonic("_Edit");
  GtkWidget *removeButton = gtk_button_new_with_mnemonic("_Remove");
  GtkWidget *predefButton = gtk_button_new_with_label("Load from catalog");
  GtkWidget *addToCatalogButton = gtk_button_new_with_label("Add to catalog");

  gtk_widget_set_sensitive(addButton, TRUE);
  gtk_widget_set_sensitive(editButton, FALSE);
  gtk_widget_set_sensitive(removeButton, FALSE);
  gtk_widget_set_sensitive(predefButton, TRUE);
  gtk_widget_set_sensitive(addToCatalogButton, FALSE);

  gtk_box_pack_start(GTK_BOX(VBox), addButton, TRUE, FALSE, 3);
  gtk_box_pack_start(GTK_BOX(VBox), editButton, TRUE, FALSE, 3);
  gtk_box_pack_start(GTK_BOX(VBox), removeButton, TRUE, FALSE, 3);
  gtk_box_pack_start(GTK_BOX(VBox), predefButton, TRUE, FALSE, 3);
  gtk_box_pack_start(GTK_BOX(VBox), addToCatalogButton, TRUE, FALSE, 3);

  gtk_box_pack_start(GTK_BOX(HBox),VBox, FALSE, FALSE, 3);
  gtk_box_pack_start(GTK_BOX(mainVBox), HBox, FALSE, FALSE, 3);

  g_signal_connect(G_OBJECT(addButton), "clicked", G_CALLBACK(add_button_clicked), (gpointer) dialog);
  g_signal_connect(G_OBJECT(editButton), "clicked", G_CALLBACK(edit_button_clicked), (gpointer) dialog);
  g_signal_connect(G_OBJECT(removeButton), "clicked", G_CALLBACK(remove_button_clicked), (gpointer) dialog);
  g_signal_connect(G_OBJECT(predefButton), "clicked", G_CALLBACK(predef_button_clicked), (gpointer) dialog);
  g_signal_connect(G_OBJECT(addToCatalogButton), "clicked", G_CALLBACK(add_to_catalog_button_clicked), (gpointer) dialog);
  g_signal_connect(G_OBJECT(compositionTreeView), "row-activated", G_CALLBACK(element_row_activated), (gpointer) dialog);

  //Sum and normalize
  HBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
  gtk_box_set_homogeneous(GTK_BOX(HBox), FALSE);
  GtkWidget *label = gtk_label_new("Weights sum (%)");
  GtkWidget *sumLabel = gtk_label_new("");
  gtk_label_set_justify(GTK_LABEL(sumLabel), GTK_JUSTIFY_CENTER);
  GtkWidget *normalizeButton = gtk_button_new_with_label("Normalize");
  gtk_box_pack_start(GTK_BOX(HBox), label, FALSE, FALSE, 2);
  gtk_box_pack_start(GTK_BOX(HBox), sumLabel, TRUE, TRUE, 2);
  gtk_box_pack_start(GTK_BOX(HBox), normalizeButton, FALSE, FALSE, 2);
  gtk_box_pack_start(GTK_BOX(mainVBox), HBox, FALSE, FALSE, 3);
  g_signal_connect(G_OBJECT(normalizeButton), "clicked", G_CALLBACK(normalize_button_clicked), (gpointer) dialog);

  //separator
  GtkWidget *separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
  gtk_box_pack_start(GTK_BOX(mainVBox), separator, FALSE, FALSE, 3);

  //Density and thickness
  HBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
  gtk_box_set_homogeneous(GTK_BOX(HBox), FALSE);
  label = gtk_label_new(NULL);
  gtk_label_set_markup(GTK_LABEL(label),"Density (g/cm<sup>3</sup>)");
  GtkWidget *densityEntry = gtk_entry_new();
  gtk_widget_set_name(densityEntry, "color_entry");
  gtk_entry_set_activates_default(GTK_ENTRY(densityEntry), TRUE);
  gulong density_changed = g_signal_connect(G_OBJECT(densityEntry), "changed", G_CALLBACK(density_thickness_changed), (gpointer) dialog);
  gtk_box_pack_start(GTK_BOX(HBox), label, FALSE, FALSE, 2);
  gtk_box_pack_end(GTK_BOX(HBox), densityEntry, FALSE, FALSE, 2);
  gtk_box_pack_start(GTK_BOX(mainVBox), HBox, FALSE, FALSE, 3);
  HBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
  gtk_box_set_homogeneous(GTK_BOX(HBox), FALSE);
  label = gtk_label_new("Thickness (cm)");
  GtkWidget *thicknessEntry = gtk_entry_new();
  gtk_widget_set_name(thicknessEntry, "color_entry");
  gtk_entry_set_activates_default(GTK_ENTRY(thicknessEntry), TRUE);
  gulong thickness_changed = g_signal_connect(G_OBJECT(thicknessEntry), "changed", G_CALLBACK(density_thickness_changed), (gpointer) dialog);
  gtk_box_pack_start(GTK_BOX(HBox), label, FALSE, FALSE, 2);
  gtk_box_pack_end(GTK_BOX(HBox), thicknessEntry, FALSE, FALSE, 2);
  gtk_box_pack_start(GTK_BOX(mainVBox), HBox, FALSE, FALSE, 3);

  dialog->addButton = addButton;
  dialog->editButton = editButton;
  dialog->removeButton = removeButton;
  dialog->predefButton = predefButton;
  dialog->addToCatalogButton = addToCatalogButton;
  dialog->normalizeButton = normalizeButton;
  dialog->sumLabel = sumLabel;
  dialog->densityEntry = densityEntry;
  dialog->thicknessEntry = thicknessEntry;
  dialog->compositionTreeView = compositionTreeView;
  dialog->density_changed = density_changed;
  dialog->thickness_changed = thickness_changed;

  g_signal_connect(G_OBJECT(compositionTreeView), "key-press-event", G_CALLBACK(backspace_key_clicked), (gpointer) dialog);

  gtk_widget_show_all(contentArea);

}
コード例 #9
0
ファイル: llfilepicker.cpp プロジェクト: otwstephanie/hpa2oar
GtkWindow* LLFilePicker::buildFilePicker(bool is_save, bool is_folder, std::string context)
{
	if (LLWindowSDL::ll_try_gtk_init())
	{
		GtkWidget *win = NULL;
		GtkFileChooserAction pickertype =
			is_save?
			(is_folder?
			 GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER :
			 GTK_FILE_CHOOSER_ACTION_SAVE) :
			(is_folder?
			 GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER :
			 GTK_FILE_CHOOSER_ACTION_OPEN);

		win = gtk_file_chooser_dialog_new(NULL, NULL,
						  pickertype,
						  GTK_STOCK_CANCEL,
						   GTK_RESPONSE_CANCEL,
						  is_folder ?
						  GTK_STOCK_APPLY :
						  (is_save ? 
						   GTK_STOCK_SAVE :
						   GTK_STOCK_OPEN),
						   GTK_RESPONSE_ACCEPT,
						  (gchar *)NULL);
		mCurContextName = context;

		// get the default path for this usage context if it's been
		// seen before.
		std::map<std::string,std::string>::iterator
			this_path = mContextToPathMap.find(context);
		if (this_path != mContextToPathMap.end())
		{
			gtk_file_chooser_set_current_folder
				(GTK_FILE_CHOOSER(win),
				 this_path->second.c_str());
		}

#  if LL_X11
		// Make GTK tell the window manager to associate this
		// dialog with our non-GTK raw X11 window, which should try
		// to keep it on top etc.
		Window XWindowID = LLWindowSDL::get_SDL_XWindowID();
		if (None != XWindowID)
		{
			gtk_widget_realize(GTK_WIDGET(win)); // so we can get its gdkwin
			GdkWindow *gdkwin = gdk_window_foreign_new(XWindowID);
			gdk_window_set_transient_for(GTK_WIDGET(win)->window,
						     gdkwin);
		}
		else
		{
			llwarns << "Hmm, couldn't get xwid to use for transient." << llendl;
		}
#  endif //LL_X11

		g_signal_connect (GTK_FILE_CHOOSER(win),
				  "response",
				  G_CALLBACK(LLFilePicker::chooser_responder),
				  this);

		gtk_window_set_modal(GTK_WINDOW(win), TRUE);

		/* GTK 2.6: if (is_folder)
			gtk_file_chooser_set_show_hidden(GTK_FILE_CHOOSER(win),
			TRUE); */

		return GTK_WINDOW(win);
	}
	else
	{
		return NULL;
	}
}
コード例 #10
0
int zvb_alfabank_v(class iceb_u_str *nomerb,class iceb_u_str *pornom,GtkWidget *wpredok)
{

class zvb_alfabank_v_data data;
char strsql[512];
iceb_u_str kikz;


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);

GtkWidget *label=NULL;

sprintf(strsql,"%s %s",gettext("Перечисление на картсчета"),gettext("Альфабанк"));
label=gtk_label_new(iceb_u_toutf(strsql));

sprintf(strsql,"%s %s",name_system,gettext("Перечисление на картсчета"));
gtk_window_set_title(GTK_WINDOW(data.window),iceb_u_toutf(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(zvb_alfabank_v_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, 0);
GtkWidget *hbox[KOLENTER];
for(int i=0; i < KOLENTER; i++)
 hbox[i] = gtk_hbox_new (FALSE, 0);
GtkWidget *hboxknop = gtk_hbox_new (FALSE, 0);

gtk_container_add (GTK_CONTAINER (data.window), vbox);
gtk_container_add (GTK_CONTAINER (vbox), label);
for(int i=0; i < KOLENTER; i++)
 gtk_box_pack_start (GTK_BOX (vbox),hbox[i], TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox),hboxknop, TRUE, TRUE, 0);


label=gtk_label_new(gettext("Номер заданный банком"));
gtk_box_pack_start (GTK_BOX (hbox[E_NOMERB]), label, FALSE, FALSE, 0);


data.entry[E_NOMERB] = gtk_entry_new_with_max_length (5);
gtk_box_pack_start (GTK_BOX (hbox[E_NOMERB]), data.entry[E_NOMERB], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_NOMERB]), "activate",GTK_SIGNAL_FUNC(zvb_alfabank_v_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_NOMERB]),data.nomerb.ravno_toutf());
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_NOMERB]),(gpointer)E_NOMERB);

label=gtk_label_new(gettext("Порядковий номер в текущей дате"));
gtk_box_pack_start (GTK_BOX (hbox[E_NOMERPP]), label, FALSE, FALSE, 0);

data.entry[E_NOMERPP] = gtk_entry_new_with_max_length (5);
gtk_box_pack_start (GTK_BOX (hbox[E_NOMERPP]), data.entry[E_NOMERPP], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_NOMERPP]), "activate",GTK_SIGNAL_FUNC(zvb_alfabank_v_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_NOMERPP]),data.pornom.ravno_toutf());
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_NOMERPP]),(gpointer)E_NOMERPP);


GtkTooltips *tooltips[KOL_FK];

sprintf(strsql,"F2 %s",gettext("Запись"));
data.knopka[FK2]=gtk_button_new_with_label(strsql);
tooltips[FK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Запись введеной в меню информации"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]),"clicked",GTK_SIGNAL_FUNC(zvb_alfabank_v_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2);
gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK2], TRUE, TRUE, 0);

sprintf(strsql,"F10 %s",gettext("Выход"));
data.knopka[FK10]=gtk_button_new_with_label(strsql);
tooltips[FK10]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы с меню без записи введенной информации"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]),"clicked",GTK_SIGNAL_FUNC(zvb_alfabank_v_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10);
gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK10], TRUE, TRUE, 0);

gtk_widget_grab_focus(data.entry[0]);

gtk_widget_show_all (data.window);

gtk_main();

if(wpredok != NULL)
  gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));
if(data.voz == 0)
 {
  nomerb->new_plus(data.nomerb.ravno());
  pornom->new_plus(data.pornom.ravno());  
 }

return(data.voz);
}
コード例 #11
0
ファイル: gnopts.c プロジェクト: BarclayII/slashem-up
void
ghack_settings_dialog()
{
    int i;
    static GtkWidget* dialog;
    static GtkWidget* swin;
    static GtkWidget* frame1;

    dialog = gnome_dialog_new (_("GnomeHack Settings"),
			    GNOME_STOCK_BUTTON_OK,
			    GNOME_STOCK_BUTTON_CANCEL,
			    NULL);
    gnome_dialog_close_hides (GNOME_DIALOG (dialog), FALSE);
    gtk_signal_connect (GTK_OBJECT (dialog), "key_press_event",
		      GTK_SIGNAL_FUNC (opt_sel_key_hit), tilesets );

    frame1 = gtk_frame_new (_("Choose one of the following tilesets:"));
    gtk_object_set_data (GTK_OBJECT (dialog), "frame1", frame1);
    gtk_widget_show (frame1);
    gtk_container_border_width (GTK_CONTAINER (frame1), 3);

    swin = gtk_scrolled_window_new (NULL, NULL);
    clist = gtk_clist_new (2);
    gtk_clist_column_titles_hide (GTK_CLIST (clist));
    gtk_widget_set_usize (GTK_WIDGET (clist), 100, 180);
    gtk_container_add (GTK_CONTAINER (swin), clist);
    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin),
	    GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);

    gtk_signal_connect (GTK_OBJECT (clist), "select_row",
			GTK_SIGNAL_FUNC (opt_sel_row_selected), NULL );

    gtk_container_add (GTK_CONTAINER (frame1), swin);
    gtk_box_pack_start_defaults (GTK_BOX (GNOME_DIALOG (dialog)->vbox), frame1);

    /* Add the tilesets into the list here... */
    for (i=0; i < no_tilesets; i++) {
	    gchar accelBuf[BUFSZ];
	    const char *text[3]={accelBuf, tilesets[i].name,NULL};
	    if ((tilesets[i].flags & ~TILESET_TRANSPARENT) != 0)
		continue;		/* Unsupported flag set */
	    sprintf( accelBuf, "%c ", tolower(tilesets[i].name[0]));
	    gtk_clist_insert (GTK_CLIST (clist), i, (char**)text);
    }


    gtk_clist_columns_autosize (GTK_CLIST (clist));
    gtk_widget_show_all (swin);

    /* Center the dialog over over parent */
    gnome_dialog_set_default( GNOME_DIALOG(dialog), 0);
    gtk_window_set_modal( GTK_WINDOW(dialog), TRUE);
    gnome_dialog_set_parent (GNOME_DIALOG (dialog),
	    GTK_WINDOW (ghack_get_main_window ()) );

    /* Run the dialog -- returning whichever button was pressed */
    i = gnome_dialog_run (GNOME_DIALOG (dialog));
    gnome_dialog_close (GNOME_DIALOG (dialog));

    /* They hit Quit or error */
    if (i != 0 ) {
	return;
    }
    if (gn_tileset < no_tilesets) {
	    if (tilesets[gn_tileset].file[0] != '/') {
		char *path;
		path = (char *)alloc(strlen(TILESETDIR) +
		  strlen(tilesets[gn_tileset].file) + 2);
		sprintf(path, TILESETDIR "/%s", tilesets[gn_tileset].file);
		ghack_free_glyphs();
		if (ghack_init_glyphs(path))
			  g_error ("ERROR:  Could not initialize glyphs.\n");
		free(path);
	    }
	    else {
		ghack_free_glyphs();
		if (ghack_init_glyphs(tilesets[gn_tileset].file))
			  g_error ("ERROR:  Could not initialize glyphs.\n");
	    }
	    ghack_reinit_map_window();
    } else {
	    /* This shouldn't happen */
	    g_warning("This shouldn't happen\n");
    }
}
コード例 #12
0
ファイル: dlg-open-with.c プロジェクト: cranes-bill/exred
/* create the "open with" dialog. */
void
dlg_open_with (FrWindow *window,
	       GList    *file_list)
{
	DialogData *data;
	GAppInfo *app;
	GList *scan, *app_names = NULL;
	char **editors;
	int i;
	GtkWidget *cancel_button;
	GtkTreeIter iter;
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *column;
	GtkIconTheme *theme;
	int icon_size;

	if (file_list == NULL)
		return;

	data = g_new0 (DialogData, 1);
	data->settings = g_settings_new (EXRED_SCHEMA_GENERAL);
	data->builder = _gtk_builder_new_from_file ("open-with.ui");
	if (data->builder == NULL) {
		g_free (data);
		return;
	}

	data->file_list = path_list_dup (file_list);
	data->window = window;

	/* Get the widgets. */

	data->dialog = _gtk_builder_get_widget (data->builder, "open_with_dialog");
	data->o_app_tree_view = _gtk_builder_get_widget (data->builder, "o_app_list_tree_view");
	data->o_recent_tree_view = _gtk_builder_get_widget (data->builder, "o_recent_tree_view");
	data->o_app_entry = _gtk_builder_get_widget (data->builder, "o_app_entry");
	data->o_del_button = _gtk_builder_get_widget (data->builder, "o_del_button");
	data->ok_button = _gtk_builder_get_widget (data->builder, "o_ok_button");
	cancel_button = _gtk_builder_get_widget (data->builder, "o_cancel_button");

	gtk_widget_set_sensitive (data->ok_button, FALSE);

	/* Set the signals handlers. */

	g_signal_connect (G_OBJECT (data->dialog),
			  "destroy",
			  G_CALLBACK (open_with__destroy_cb),
			  data);

	g_signal_connect (G_OBJECT (data->o_app_entry),
			  "changed",
			  G_CALLBACK (app_entry__changed_cb),
			  data);

	g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (data->o_app_tree_view))),
			  "changed",
			  G_CALLBACK (app_list_selection_changed_cb),
			  data);
	g_signal_connect (G_OBJECT (data->o_app_tree_view),
			  "row_activated",
			  G_CALLBACK (app_activated_cb),
			  data);

	g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (data->o_recent_tree_view))),
			  "changed",
			  G_CALLBACK (recent_list_selection_changed_cb),
			  data);
	g_signal_connect (G_OBJECT (data->o_recent_tree_view),
			  "row_activated",
			  G_CALLBACK (recent_activated_cb),
			  data);

	g_signal_connect (G_OBJECT (data->ok_button),
			  "clicked",
			  G_CALLBACK (open_cb),
			  data);
	g_signal_connect_swapped (G_OBJECT (cancel_button),
				  "clicked",
				  G_CALLBACK (gtk_widget_destroy),
				  G_OBJECT (data->dialog));
	g_signal_connect (G_OBJECT (data->o_del_button),
			  "clicked",
			  G_CALLBACK (delete_recent_cb),
			  data);

	/* Set data. */

	/* * registered applications list. */

	data->app_list = NULL;
	for (scan = data->file_list; scan; scan = scan->next) {
		const char *mime_type;
		const char *name = scan->data;

		mime_type = get_file_mime_type_for_path (name, FALSE);
		if ((mime_type != NULL) && ! g_content_type_is_unknown (mime_type))
			data->app_list = g_list_concat (data->app_list, g_app_info_get_all_for_type (mime_type));
	}

	data->app_model = GTK_TREE_MODEL (gtk_list_store_new (N_COLUMNS,
							      GDK_TYPE_PIXBUF,
							      G_TYPE_STRING,
							      G_TYPE_POINTER));

	gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (data->app_model),
					      TEXT_COLUMN,
					      GTK_SORT_ASCENDING);

	gtk_tree_view_set_model (GTK_TREE_VIEW (data->o_app_tree_view),
				 data->app_model);
	g_object_unref (G_OBJECT (data->app_model));

	theme = gtk_icon_theme_get_default ();
	icon_size = get_folder_pixbuf_size_for_list (GTK_WIDGET (data->dialog));

	for (scan = data->app_list; scan; scan = scan->next) {
		gboolean   found;
		char      *utf8_name;
		GdkPixbuf *icon_image = NULL;

		app = scan->data;

		found = FALSE;
		if (app_names != NULL) {
			GList *p;
			for (p = app_names; p && !found; p = p->next)
				if (g_strcmp0 ((char*)p->data, g_app_info_get_executable (app)) == 0)
					found = TRUE;
		}

		if (found)
			continue;

		app_names = g_list_prepend (app_names, (char*) g_app_info_get_executable (app));

		utf8_name = g_locale_to_utf8 (g_app_info_get_name (app), -1, NULL, NULL, NULL);	
		icon_image = get_icon_pixbuf (g_app_info_get_icon (app), icon_size, theme);
		
		gtk_list_store_append (GTK_LIST_STORE (data->app_model),
				       &iter);
		gtk_list_store_set (GTK_LIST_STORE (data->app_model),
				    &iter,
				    ICON_COLUMN, icon_image,
				    TEXT_COLUMN, utf8_name,
				    DATA_COLUMN, app,
				    -1);

		g_free (utf8_name);
	}

	column = gtk_tree_view_column_new ();

	renderer = gtk_cell_renderer_pixbuf_new ();
	gtk_tree_view_column_pack_start (column, renderer, FALSE);
	gtk_tree_view_column_set_attributes (column, renderer,
					     "pixbuf", ICON_COLUMN,
					     NULL);

	renderer = gtk_cell_renderer_text_new ();
	gtk_tree_view_column_pack_start (column,
					 renderer,
					 TRUE);
	gtk_tree_view_column_set_attributes (column, renderer,
					     "text", TEXT_COLUMN,
					     NULL);

	gtk_tree_view_append_column (GTK_TREE_VIEW (data->o_app_tree_view),
				     column);

	if (app_names)
		g_list_free (app_names);

	/* * recent editors list. */

	data->recent_model = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_STRING));
	gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (data->recent_model), 0, GTK_SORT_ASCENDING);

	gtk_tree_view_set_model (GTK_TREE_VIEW (data->o_recent_tree_view),
				 data->recent_model);
	g_object_unref (G_OBJECT (data->recent_model));

	editors = g_settings_get_strv (data->settings, PREF_GENERAL_EDITORS);
	for (i = 0; editors[i] != NULL; i++) {
		gtk_list_store_append (GTK_LIST_STORE (data->recent_model), &iter);
		gtk_list_store_set (GTK_LIST_STORE (data->recent_model), &iter,
				    0, editors[i],
				    -1);
	}
	g_strfreev (editors);

	renderer = gtk_cell_renderer_text_new ();
	column = gtk_tree_view_column_new_with_attributes (NULL,
							   renderer,
							   "text", 0,
							   NULL);
	gtk_tree_view_column_set_sort_column_id (column, 0);
	gtk_tree_view_append_column (GTK_TREE_VIEW (data->o_recent_tree_view),
				     column);

	/* Run dialog. */
	gtk_window_set_transient_for (GTK_WINDOW (data->dialog),
				      GTK_WINDOW (window));
	gtk_window_set_modal (GTK_WINDOW (data->dialog), TRUE);
	gtk_widget_show_all (data->dialog);
}
コード例 #13
0
ファイル: preferences.c プロジェクト: donovank/lxterminal
/* Initialize and display the preferences dialog. */
void terminal_preferences_dialog(GtkAction * action, LXTerminal * terminal)
{
    Setting * setting = copy_setting(get_setting());

    GtkBuilder * builder = gtk_builder_new();
    if ( ! gtk_builder_add_from_file(builder, PACKAGE_DATA_DIR "/lxterminal/lxterminal-preferences.ui", NULL))
    {
        g_object_unref(builder);
        return;
    }

    GtkDialog * dialog = GTK_DIALOG(gtk_builder_get_object(builder, "lxterminal_preferences"));
    gtk_window_set_title(GTK_WINDOW(dialog), _("LXTerminal"));
    gtk_window_set_icon_from_file(GTK_WINDOW(dialog), PACKAGE_DATA_DIR "/icons/hicolor/128x128/apps/lxterminal.png", NULL);

    GtkWidget * w = GTK_WIDGET(gtk_builder_get_object(builder, "terminal_font"));
    gtk_font_button_set_font_name(GTK_FONT_BUTTON(w), setting->font_name);
    g_signal_connect(G_OBJECT(w), "font-set", G_CALLBACK(preferences_dialog_font_set_event), setting);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "background_color"));
    gtk_color_button_set_color(GTK_COLOR_BUTTON(w), &setting->background_color);
    gtk_color_button_set_alpha(GTK_COLOR_BUTTON(w), setting->background_alpha);
    g_signal_connect(G_OBJECT(w), "color-set", 
        G_CALLBACK(preferences_dialog_background_color_set_event), setting);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "foreground_color"));
    gtk_color_button_set_color(GTK_COLOR_BUTTON(w), &setting->foreground_color);
    g_signal_connect(G_OBJECT(w), "color-set", 
        G_CALLBACK(preferences_dialog_foreground_color_set_event), setting);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "allow_bold"));
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), ! setting->disallow_bold);
    g_signal_connect(G_OBJECT(w), "toggled", 
        G_CALLBACK(preferences_dialog_allow_bold_toggled_event), setting);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "cursor_blink"));
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->cursor_blink);
    g_signal_connect(G_OBJECT(w), "toggled", 
        G_CALLBACK(preferences_dialog_generic_toggled_event), &setting->cursor_blink);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "cursor_style_block"));
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), ! setting->cursor_underline);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "cursor_style_underline"));
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->cursor_underline);
    g_signal_connect(G_OBJECT(w), "toggled", 
        G_CALLBACK(preferences_dialog_generic_toggled_event), &setting->cursor_underline);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "audible_bell"));
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->audible_bell);
    g_signal_connect(G_OBJECT(w), "toggled", 
        G_CALLBACK(preferences_dialog_generic_toggled_event), &setting->audible_bell);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "tab_position"));
    gtk_combo_box_set_active(GTK_COMBO_BOX(w), terminal_tab_get_position_id(setting->tab_position));
    g_signal_connect(G_OBJECT(w), "changed", 
        G_CALLBACK(preferences_dialog_tab_position_changed_event), setting);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "scrollback_lines"));
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(w), setting->scrollback);
    g_signal_connect(G_OBJECT(w), "value-changed", 
        G_CALLBACK(preferences_dialog_scrollback_value_changed_event), setting);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "hide_scroll_bar"));
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->hide_scroll_bar);
    g_signal_connect(G_OBJECT(w), "toggled", 
        G_CALLBACK(preferences_dialog_generic_toggled_event), &setting->hide_scroll_bar);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "hide_menu_bar"));
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->hide_menu_bar);
    g_signal_connect(G_OBJECT(w), "toggled", 
        G_CALLBACK(preferences_dialog_generic_toggled_event), &setting->hide_menu_bar);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "hide_close_button"));
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->hide_close_button);
    g_signal_connect(G_OBJECT(w), "toggled", 
        G_CALLBACK(preferences_dialog_generic_toggled_event), &setting->hide_close_button);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "hide_pointer"));
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->hide_pointer);
    g_signal_connect(G_OBJECT(w), "toggled", 
        G_CALLBACK(preferences_dialog_generic_toggled_event), &setting->hide_pointer);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "select_by_word"));
    gtk_entry_set_text(GTK_ENTRY(w), setting->word_selection_characters);
    g_signal_connect(G_OBJECT(w), "focus-out-event", 
        G_CALLBACK(preferences_dialog_generic_focus_out_event), setting->word_selection_characters);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "disable_f10"));
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->disable_f10);
    g_signal_connect(G_OBJECT(w), "toggled", 
        G_CALLBACK(preferences_dialog_generic_toggled_event), &setting->disable_f10);

    w = GTK_WIDGET(gtk_builder_get_object(builder, "disable_alt"));
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), setting->disable_alt);
    g_signal_connect(G_OBJECT(w), "toggled", 
        G_CALLBACK(preferences_dialog_generic_toggled_event), &setting->disable_alt);
    
    /* Shortcuts */
    w = GTK_WIDGET(gtk_builder_get_object(builder, NEW_WINDOW_ACCEL));
    gtk_entry_set_text(GTK_ENTRY(w), setting->new_window_accel);
    g_signal_connect(G_OBJECT(w), "focus-out-event", 
        G_CALLBACK(preferences_dialog_shortcut_focus_out_event), setting->new_window_accel);

    w = GTK_WIDGET(gtk_builder_get_object(builder, NEW_TAB_ACCEL));
    gtk_entry_set_text(GTK_ENTRY(w), setting->new_tab_accel);
    g_signal_connect(G_OBJECT(w), "focus-out-event", 
        G_CALLBACK(preferences_dialog_shortcut_focus_out_event), setting->new_tab_accel);

    w = GTK_WIDGET(gtk_builder_get_object(builder, CLOSE_TAB_ACCEL));
    gtk_entry_set_text(GTK_ENTRY(w), setting->close_tab_accel);
    g_signal_connect(G_OBJECT(w), "focus-out-event", 
        G_CALLBACK(preferences_dialog_shortcut_focus_out_event), setting->close_tab_accel);

    w = GTK_WIDGET(gtk_builder_get_object(builder, CLOSE_WINDOW_ACCEL));
    gtk_entry_set_text(GTK_ENTRY(w), setting->close_window_accel);
    g_signal_connect(G_OBJECT(w), "focus-out-event", 
        G_CALLBACK(preferences_dialog_shortcut_focus_out_event), setting->close_window_accel);

    w = GTK_WIDGET(gtk_builder_get_object(builder, COPY_ACCEL));
    gtk_entry_set_text(GTK_ENTRY(w), setting->copy_accel);
    g_signal_connect(G_OBJECT(w), "focus-out-event", 
        G_CALLBACK(preferences_dialog_shortcut_focus_out_event), setting->copy_accel);

    w = GTK_WIDGET(gtk_builder_get_object(builder, PASTE_ACCEL));
    gtk_entry_set_text(GTK_ENTRY(w), setting->paste_accel);
    g_signal_connect(G_OBJECT(w), "focus-out-event", 
        G_CALLBACK(preferences_dialog_shortcut_focus_out_event), setting->paste_accel);

    w = GTK_WIDGET(gtk_builder_get_object(builder, NAME_TAB_ACCEL));
    gtk_entry_set_text(GTK_ENTRY(w), setting->name_tab_accel);
    g_signal_connect(G_OBJECT(w), "focus-out-event", 
        G_CALLBACK(preferences_dialog_shortcut_focus_out_event), setting->name_tab_accel);

    w = GTK_WIDGET(gtk_builder_get_object(builder, PREVIOUS_TAB_ACCEL));
    gtk_entry_set_text(GTK_ENTRY(w), setting->previous_tab_accel);
    g_signal_connect(G_OBJECT(w), "focus-out-event", 
        G_CALLBACK(preferences_dialog_shortcut_focus_out_event), setting->previous_tab_accel);

    w = GTK_WIDGET(gtk_builder_get_object(builder, NEXT_TAB_ACCEL));
    gtk_entry_set_text(GTK_ENTRY(w), setting->next_tab_accel);
    g_signal_connect(G_OBJECT(w), "focus-out-event", 
        G_CALLBACK(preferences_dialog_shortcut_focus_out_event), setting->next_tab_accel);

    w = GTK_WIDGET(gtk_builder_get_object(builder, MOVE_TAB_LEFT_ACCEL));
    gtk_entry_set_text(GTK_ENTRY(w), setting->move_tab_left_accel);
    g_signal_connect(G_OBJECT(w), "focus-out-event", 
        G_CALLBACK(preferences_dialog_shortcut_focus_out_event), setting->move_tab_left_accel);

    w = GTK_WIDGET(gtk_builder_get_object(builder, MOVE_TAB_RIGHT_ACCEL));
    gtk_entry_set_text(GTK_ENTRY(w), setting->move_tab_right_accel);
    g_signal_connect(G_OBJECT(w), "focus-out-event", 
        G_CALLBACK(preferences_dialog_shortcut_focus_out_event), setting->move_tab_right_accel);

    g_object_unref(builder);

    gtk_window_set_modal(GTK_WINDOW(GTK_DIALOG(dialog)), TRUE);
    gtk_window_set_transient_for(GTK_WINDOW(GTK_DIALOG(dialog)), 
        GTK_WINDOW(terminal->window));

    int result = gtk_dialog_run(dialog);
    /* Dismiss dialog. */
    gtk_widget_destroy(GTK_WIDGET(dialog));
    if (result == GTK_RESPONSE_OK)
    {
        set_setting(setting);
        save_setting();
        terminal_settings_apply_to_all(terminal);
    }
    else
    {
        free_setting(setting);
    }
}
コード例 #14
0
ファイル: list.c プロジェクト: 3upperm2n/gpuSimulators
struct vi_list_popup_t *vi_list_popup_create(struct vi_list_t *list)
{
	struct vi_list_popup_t *popup;

	/* Initialize */
	popup = xcalloc(1, sizeof(struct vi_list_popup_t));
	popup->list = list;

	int i;
	int count;

	/* Create list of 'vi_list_item_t'  */
	popup->item_list = list_create();

	/* Create main window */
	GtkWidget *window;
	window = gtk_window_new(GTK_WINDOW_POPUP);
	popup->window = window;
	gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_MOUSE);
	gtk_widget_set_size_request(window, 200, 250);
	gtk_window_set_modal(GTK_WINDOW(window), TRUE);
	g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(vi_list_popup_destroy_event), popup);

	/* Close button */
	GtkWidget *image_close = gtk_image_new_from_file(vi_list_image_close_path);
	GtkWidget *event_box_close = gtk_event_box_new();
	popup->image_close = image_close;
	gtk_container_add(GTK_CONTAINER(event_box_close), image_close);
	gtk_widget_add_events(event_box_close, GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK);
	g_signal_connect(G_OBJECT(event_box_close), "enter-notify-event",
		G_CALLBACK(vi_list_popup_image_close_enter_notify_event), popup);
	g_signal_connect(G_OBJECT(event_box_close), "leave-notify-event",
		G_CALLBACK(vi_list_popup_image_close_leave_notify_event), popup);
	g_signal_connect(G_OBJECT(event_box_close), "button-press-event",
		G_CALLBACK(vi_list_popup_image_close_clicked_event), popup);

	/* Title */
	GtkWidget *title_label = gtk_label_new(list->title);
	GtkWidget *title_event_box = gtk_event_box_new();
	gtk_container_add(GTK_CONTAINER(title_event_box), title_label);

	/* Separator below title */
	GtkWidget *hsep = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);

	/* Scrolled window */
	GtkWidget *scrolled_window;
	scrolled_window = gtk_scrolled_window_new(NULL, NULL);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
		GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);

	/* Main table */
	GtkWidget *main_table;
	main_table = gtk_table_new(3, 2, FALSE);
	gtk_table_attach(GTK_TABLE(main_table), title_event_box, 0, 1, 0, 1, GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
	gtk_table_attach(GTK_TABLE(main_table), event_box_close, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
	gtk_table_attach(GTK_TABLE(main_table), hsep, 0, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
	gtk_table_attach_defaults(GTK_TABLE(main_table), scrolled_window, 0, 2, 2, 3);
	gtk_container_add(GTK_CONTAINER(window), main_table);

	GdkColor color;
	gdk_color_parse("#ffffa0", &color);

	GtkWidget *table;
	count = list->elem_list->count;
	table = gtk_table_new(count, 1, FALSE);
	for (i = 0; i < count; i++)
	{
		void *elem;
		char str[MAX_STRING_SIZE];
		struct vi_list_item_t *item;

		/* Get element */
		elem = list_get(list->elem_list, i);

		/* Create label */
		GtkWidget *label;
		if (list->get_elem_name)
			(*list->get_elem_name)(elem, str, sizeof str);
		else
			snprintf(str, sizeof str, "item-%d", i);
		label = gtk_label_new(str);
		gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
		gtk_label_set_use_markup(GTK_LABEL(label), TRUE);

		/* Set label font attributes */
		PangoAttrList *attrs;
		attrs = pango_attr_list_new();
		PangoAttribute *size_attr = pango_attr_size_new_absolute(12 << 10);
		pango_attr_list_insert(attrs, size_attr);
		gtk_label_set_attributes(GTK_LABEL(label), attrs);

		/* Event box */
		GtkWidget *event_box;
		event_box = gtk_event_box_new();
		gtk_widget_modify_bg(event_box, GTK_STATE_NORMAL, &color);
		gtk_container_add(GTK_CONTAINER(event_box), label);

		/* Create list_layout_item */
		item = vi_list_item_create();
		item->list = list;
		item->event_box = event_box;
		item->label = label;
		item->elem = elem;
		list_add(list->item_list, item);

		/* Events for event box */
		gtk_widget_add_events(event_box, GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK);
		g_signal_connect(G_OBJECT(event_box), "enter-notify-event",
			G_CALLBACK(vi_list_item_enter_notify_event), item);
		g_signal_connect(G_OBJECT(event_box), "leave-notify-event",
			G_CALLBACK(vi_list_item_leave_notify_event), item);
		g_signal_connect(G_OBJECT(event_box), "button-press-event",
			G_CALLBACK(vi_list_item_button_press_event), item);

		gtk_table_attach(GTK_TABLE(table), event_box, 0, 1, i, i + 1, GTK_FILL, GTK_FILL, 0, 0);
	}

	GtkWidget *viewport;
	viewport = gtk_viewport_new(NULL, NULL);
	gtk_widget_modify_bg(window, GTK_STATE_NORMAL, &color);
	gtk_container_add(GTK_CONTAINER(viewport), table);
	gtk_widget_modify_bg(viewport, GTK_STATE_NORMAL, &color);
	gtk_container_add(GTK_CONTAINER(scrolled_window), viewport);

	/* Return */
	return popup;
}
コード例 #15
0
ファイル: project_new_dialog.c プロジェクト: allanjos/issuedb
int project_new_dialog_open(GtkWidget *parent) {
  project_new_dialog_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

  gtk_window_set_transient_for(GTK_WINDOW(project_new_dialog_window), GTK_WINDOW(parent));

  gtk_window_set_position(GTK_WINDOW(project_new_dialog_window), GTK_WIN_POS_CENTER_ON_PARENT);

  gtk_window_set_modal(GTK_WINDOW(project_new_dialog_window), TRUE);

  gtk_window_set_default_size(GTK_WINDOW(project_new_dialog_window), 600, 200);

  gtk_window_set_title(GTK_WINDOW(project_new_dialog_window), "New Project");

  gtk_container_set_border_width(GTK_CONTAINER(project_new_dialog_window), 5);


  GtkWidget *sizer_top;

  sizer_top = gtk_vbox_new(FALSE, 0);
  gtk_container_add(GTK_CONTAINER(project_new_dialog_window), sizer_top);

  // Grid sizer

  GtkWidget *table_fields = gtk_table_new(2, 2, FALSE);

  gtk_box_pack_start(GTK_BOX(sizer_top), table_fields, TRUE, TRUE, 3);

  gtk_table_set_row_spacings(GTK_TABLE(table_fields), 3);
  gtk_table_set_col_spacings(GTK_TABLE(table_fields), 3);

  // Issue name

  GtkWidget *alignment_label = gtk_alignment_new(1, 0, 0, 0);
  gtk_table_attach(GTK_TABLE(table_fields), alignment_label, 0, 1, 1, 2, GTK_FILL, GTK_SHRINK, 0, 0);

  GtkWidget *label = gtk_label_new("Project name: ");
  gtk_container_add(GTK_CONTAINER(alignment_label), label);

  project_new_dialog_entry_name = gtk_entry_new();
  gtk_table_attach(GTK_TABLE(table_fields), project_new_dialog_entry_name, 1, 2, 1, 2, GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);

  gtk_entry_set_width_chars(GTK_ENTRY(project_new_dialog_entry_name), 30);

  // Status

  alignment_label = gtk_alignment_new(1, 0, 0, 0);
  gtk_table_attach(GTK_TABLE(table_fields), alignment_label, 0, 1, 5, 6, GTK_FILL, GTK_SHRINK, 0, 0);

  label = gtk_label_new("Status: ");
  gtk_container_add(GTK_CONTAINER(alignment_label), label);

  GtkWidget *alignment_status = gtk_alignment_new(0, 0, 0, 0);
  gtk_table_attach(GTK_TABLE(table_fields), alignment_status, 1, 2, 5, 6, GTK_FILL, GTK_SHRINK, 0, 0);

  project_new_dialog_combo_status = gtk_combo_box_new();
  gtk_container_add(GTK_CONTAINER(alignment_status), project_new_dialog_combo_status);

  // Data model

  GtkListStore *list_store_status = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
  GtkTreeIter iter_status;

  gtk_list_store_append(list_store_status, &iter_status);
  gtk_list_store_set(list_store_status, &iter_status, 0, "Active", 1, "A", -1);

  gtk_list_store_append(list_store_status, &iter_status);
  gtk_list_store_set(list_store_status, &iter_status, 0, "Inactive", 1, "I", -1);

  gtk_combo_box_set_model(GTK_COMBO_BOX(project_new_dialog_combo_status), GTK_TREE_MODEL(list_store_status));

  GtkCellRenderer *status_name_renderer;

  status_name_renderer = gtk_cell_renderer_text_new();
  gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(project_new_dialog_combo_status), status_name_renderer, TRUE);
  gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(project_new_dialog_combo_status), status_name_renderer, "text", 0, NULL);

  g_object_unref(G_OBJECT(list_store_status));

  gtk_combo_box_set_active(GTK_COMBO_BOX(project_new_dialog_combo_status), 0);

  // Buttons

  GtkWidget *sizer_buttons = gtk_hbox_new(FALSE, 3);

  gtk_box_pack_end(GTK_BOX(sizer_top), sizer_buttons, FALSE, FALSE, 3);

  // Close button

  GtkWidget *button_close = gtk_button_new_from_stock(GTK_STOCK_CLOSE);

  GdkPixbuf *pixbuf = gdk_pixbuf_new_from_xpm_data((const char **) close_16x16_xpm);
  GtkWidget *image = gtk_image_new_from_pixbuf(pixbuf);

  gtk_button_set_image(GTK_BUTTON(button_close), image);

  gtk_box_pack_end(GTK_BOX(sizer_buttons), button_close, FALSE, FALSE, 3);

  // Save button

  GtkWidget *button_save = gtk_button_new();

  gtk_button_set_label(GTK_BUTTON(button_save), "Save");

  pixbuf = gdk_pixbuf_new_from_xpm_data((const char **) save_16x16_xpm);
  image = gtk_image_new_from_pixbuf(pixbuf);

  gtk_button_set_image(GTK_BUTTON(button_save), image);

  gtk_box_pack_end(GTK_BOX(sizer_buttons), button_save, FALSE, FALSE, 3);

  // Close window using button
  
  g_signal_connect(G_OBJECT(button_close), "clicked",
                   G_CALLBACK(on_project_new_button_close_clicked), G_OBJECT(project_new_dialog_window));

  // Save issue information
  
  g_signal_connect(G_OBJECT(button_save), "clicked",
                   G_CALLBACK(on_project_new_button_save_clicked), G_OBJECT(project_new_dialog_window));


  gtk_widget_show_all(project_new_dialog_window);


  //gtk_widget_grab_focus(GTK_WIDGET(project_new_dialog_combo_project));


	return 0;
}
コード例 #16
0
ファイル: select-keys.c プロジェクト: Mortal/claws
static void 
create_dialog (struct select_keys_s *sk)
{
    GtkWidget *window;
    GtkWidget *vbox, *vbox2, *hbox;
    GtkWidget *bbox;
    GtkWidget *scrolledwin;
    GtkWidget *clist;
    GtkWidget *label;
    GtkWidget *select_btn, *cancel_btn, *dont_encrypt_btn, *other_btn;
    const char *titles[N_COL_TITLES];

    g_assert (!sk->window);
    window = gtkut_window_new (GTK_WINDOW_TOPLEVEL, "select-keys");
    gtk_widget_set_size_request (window, 560, 280);
    gtk_container_set_border_width (GTK_CONTAINER (window), 8);
    gtk_window_set_title (GTK_WINDOW (window), _("Select Keys"));
    gtk_window_set_modal (GTK_WINDOW (window), TRUE);
    g_signal_connect (G_OBJECT (window), "delete_event",
                      G_CALLBACK (delete_event_cb), sk);
    g_signal_connect (G_OBJECT (window), "key_press_event",
                      G_CALLBACK (key_pressed_cb), sk);
    MANAGE_WINDOW_SIGNALS_CONNECT (window);

    vbox = gtk_vbox_new (FALSE, 8);
    gtk_container_add (GTK_CONTAINER (window), vbox);

    hbox  = gtk_hbox_new(FALSE, 4);
    gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
    label = gtk_label_new ( "" );
    gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);

    hbox = gtk_hbox_new (FALSE, 8);
    gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
    gtk_container_set_border_width (GTK_CONTAINER (hbox), 2);

    scrolledwin = gtk_scrolled_window_new (NULL, NULL);
    gtk_box_pack_start (GTK_BOX (hbox), scrolledwin, TRUE, TRUE, 0);
    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwin),
                                    GTK_POLICY_AUTOMATIC,
                                    GTK_POLICY_AUTOMATIC);

    titles[COL_ALGO]     = _("Size");
    titles[COL_KEYID]    = _("Key ID");
    titles[COL_NAME]     = _("Name");
    titles[COL_EMAIL]    = _("Address");
    titles[COL_VALIDITY] = _("Trust");

    clist = gtk_cmclist_new_with_titles (N_COL_TITLES, (char**)titles);
    gtk_container_add (GTK_CONTAINER (scrolledwin), clist);
    gtk_cmclist_set_column_width (GTK_CMCLIST(clist), COL_ALGO,      70);
    gtk_cmclist_set_column_width (GTK_CMCLIST(clist), COL_KEYID,    120);
    gtk_cmclist_set_column_width (GTK_CMCLIST(clist), COL_NAME,     115);
    gtk_cmclist_set_column_width (GTK_CMCLIST(clist), COL_EMAIL,    140);
    gtk_cmclist_set_column_width (GTK_CMCLIST(clist), COL_VALIDITY,  20);
    gtk_cmclist_set_selection_mode (GTK_CMCLIST(clist), GTK_SELECTION_BROWSE);
    g_signal_connect (G_OBJECT(GTK_CMCLIST(clist)->column[COL_NAME].button),
		      "clicked",
                      G_CALLBACK(sort_keys_name), sk);
    g_signal_connect (G_OBJECT(GTK_CMCLIST(clist)->column[COL_EMAIL].button),
		      "clicked",
                      G_CALLBACK(sort_keys_email), sk);

    hbox = gtk_hbox_new (FALSE, 8);
    gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);

    /* TRANSLATORS: check that the accelerators in _Select, _Other and
     * Do_n't encrypt are different than the one in the stock Cancel
     * button */
    gtkut_stock_button_set_create (&bbox, 
                                   &select_btn, _("_Select"),
		   		   &other_btn, _("_Other"),
		    		   &dont_encrypt_btn, _("Do_n't encrypt"));
    
    cancel_btn = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
    gtkut_widget_set_can_default(cancel_btn, TRUE);
    gtk_box_pack_start(GTK_BOX(bbox), cancel_btn, TRUE, TRUE, 0);
    gtk_widget_show(cancel_btn);
    gtk_box_pack_end (GTK_BOX (hbox), bbox, FALSE, FALSE, 0);
    gtk_widget_grab_default (select_btn);

    g_signal_connect (G_OBJECT (select_btn), "clicked",
                      G_CALLBACK (select_btn_cb), sk);
    g_signal_connect (G_OBJECT(cancel_btn), "clicked",
                      G_CALLBACK (cancel_btn_cb), sk);
    g_signal_connect (G_OBJECT(dont_encrypt_btn), "clicked",
                      G_CALLBACK (dont_encrypt_btn_cb), sk);
    g_signal_connect (G_OBJECT (other_btn), "clicked",
                      G_CALLBACK (other_btn_cb), sk);

    vbox2 = gtk_vbox_new (FALSE, 4);
    gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 0);

    sk->window = window;
    sk->toplabel = GTK_LABEL (label);
    sk->clist  = GTK_CMCLIST (clist);
}
コード例 #17
0
static void create_bistable_properties_dialog (bistable_properties_D *dialog)
  {
  if (NULL != dialog->bistable_properties_dialog) return ;

  dialog->bistable_properties_dialog = gtk_dialog_new ();
  gtk_window_set_title (GTK_WINDOW (dialog->bistable_properties_dialog), _("Bistable Options"));
  gtk_window_set_resizable (GTK_WINDOW (dialog->bistable_properties_dialog), FALSE);
  gtk_window_set_modal (GTK_WINDOW (dialog->bistable_properties_dialog), TRUE) ;

  dialog->dialog_vbox1 = GTK_DIALOG (dialog->bistable_properties_dialog)->vbox;
  gtk_widget_show (dialog->dialog_vbox1);

  dialog->table = gtk_table_new (7, 2, FALSE);
  gtk_widget_show (dialog->table);
  gtk_container_set_border_width (GTK_CONTAINER (dialog->table), 2);
  gtk_box_pack_start (GTK_BOX (dialog->dialog_vbox1), dialog->table, TRUE, TRUE, 0);

  dialog->label1 = gtk_label_new (_("Number Of Samples:"));
  gtk_widget_show (dialog->label1);
  gtk_table_attach (GTK_TABLE (dialog->table), dialog->label1, 0, 1, 0, 1,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 2, 2);
  gtk_label_set_justify (GTK_LABEL (dialog->label1), GTK_JUSTIFY_RIGHT);
  gtk_misc_set_alignment (GTK_MISC (dialog->label1), 1, 0.5);

  dialog->number_of_samples_entry = gtk_entry_new ();
  gtk_widget_show (dialog->number_of_samples_entry);
  gtk_table_attach (GTK_TABLE (dialog->table), dialog->number_of_samples_entry, 1, 2, 0, 1,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 2, 2);
  gtk_entry_set_activates_default (GTK_ENTRY (dialog->number_of_samples_entry), TRUE) ;

  dialog->label2 = gtk_label_new (_("Convergence Tolerance:"));
  gtk_widget_show (dialog->label2);
  gtk_table_attach (GTK_TABLE (dialog->table), dialog->label2, 0, 1, 1, 2,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 2, 2);
  gtk_label_set_justify (GTK_LABEL (dialog->label2), GTK_JUSTIFY_RIGHT);
  gtk_misc_set_alignment (GTK_MISC (dialog->label2), 1, 0.5);

  dialog->convergence_tolerance_entry = gtk_entry_new ();
  gtk_widget_show (dialog->convergence_tolerance_entry);
  gtk_table_attach (GTK_TABLE (dialog->table), dialog->convergence_tolerance_entry, 1, 2, 1, 2,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 2, 2);
  gtk_entry_set_activates_default (GTK_ENTRY (dialog->convergence_tolerance_entry), TRUE) ;

  dialog->label3 = gtk_label_new (_("Radius of Effect [nm]:"));
  gtk_widget_show (dialog->label3);
  gtk_table_attach (GTK_TABLE (dialog->table), dialog->label3, 0, 1, 2, 3,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 2, 2);
  gtk_label_set_justify (GTK_LABEL (dialog->label3), GTK_JUSTIFY_RIGHT);
  gtk_misc_set_alignment (GTK_MISC (dialog->label3), 1, 0.5);

  dialog->radius_of_effect_entry = gtk_entry_new ();
  gtk_widget_show (dialog->radius_of_effect_entry);
  gtk_table_attach (GTK_TABLE (dialog->table), dialog->radius_of_effect_entry, 1, 2, 2, 3,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 2, 2);
  gtk_entry_set_activates_default (GTK_ENTRY (dialog->radius_of_effect_entry), TRUE) ;

  dialog->label4 = gtk_label_new (_("Relative Permittivity:"));
  gtk_widget_show (dialog->label4);
  gtk_table_attach (GTK_TABLE (dialog->table), dialog->label4, 0, 1, 3, 4,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 2, 2);
  gtk_label_set_justify (GTK_LABEL (dialog->label4), GTK_JUSTIFY_RIGHT);
  gtk_misc_set_alignment (GTK_MISC (dialog->label4), 1, 0.5);

  dialog->epsilonR_entry = gtk_entry_new ();
  gtk_widget_show (dialog->epsilonR_entry);
  gtk_table_attach (GTK_TABLE (dialog->table), dialog->epsilonR_entry, 1, 2, 3, 4,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 2, 2);
  gtk_entry_set_activates_default (GTK_ENTRY (dialog->epsilonR_entry), TRUE) ;

  dialog->label5 = gtk_label_new (_("Clock High:"));
  gtk_widget_show (dialog->label5);
  gtk_table_attach (GTK_TABLE (dialog->table), dialog->label5, 0, 1, 4, 5,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 2, 2);
  gtk_label_set_justify (GTK_LABEL (dialog->label5), GTK_JUSTIFY_RIGHT);
  gtk_misc_set_alignment (GTK_MISC (dialog->label5), 1, 0.5);

  dialog->clock_high_entry = gtk_entry_new ();
  gtk_widget_show (dialog->clock_high_entry);
  gtk_table_attach (GTK_TABLE (dialog->table), dialog->clock_high_entry, 1, 2, 4, 5,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 2, 2);
  gtk_entry_set_activates_default (GTK_ENTRY (dialog->clock_high_entry), TRUE) ;

  dialog->label6 = gtk_label_new (_("Clock Low:"));
  gtk_widget_show (dialog->label6);
  gtk_table_attach (GTK_TABLE (dialog->table), dialog->label6, 0, 1, 5, 6,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 2, 2);
  gtk_label_set_justify (GTK_LABEL (dialog->label6), GTK_JUSTIFY_RIGHT);
  gtk_misc_set_alignment (GTK_MISC (dialog->label6), 1, 0.5);

  dialog->clock_low_entry = gtk_entry_new ();
  gtk_widget_show (dialog->clock_low_entry);
  gtk_table_attach (GTK_TABLE (dialog->table), dialog->clock_low_entry, 1, 2, 5, 6,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 2, 2);
  gtk_entry_set_activates_default (GTK_ENTRY (dialog->clock_low_entry), TRUE) ;

  dialog->label6 = gtk_label_new (_("Clock Shift:"));
  gtk_widget_show (dialog->label6);
  gtk_table_attach (GTK_TABLE (dialog->table), dialog->label6, 0, 1, 6, 7,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 2, 2);
  gtk_label_set_justify (GTK_LABEL (dialog->label6), GTK_JUSTIFY_RIGHT);
  gtk_misc_set_alignment (GTK_MISC (dialog->label6), 1, 0.5);

  dialog->clock_shift_entry = gtk_entry_new ();
  gtk_widget_show (dialog->clock_shift_entry);
  gtk_table_attach (GTK_TABLE (dialog->table), dialog->clock_shift_entry, 1, 2, 6, 7,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 2, 2);
  gtk_entry_set_activates_default (GTK_ENTRY (dialog->clock_shift_entry), TRUE) ;

  dialog->label6 = gtk_label_new (_("Clock Amplitude Factor:"));
  gtk_widget_show (dialog->label6);
  gtk_table_attach (GTK_TABLE (dialog->table), dialog->label6, 0, 1, 7, 8,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 2, 2);
  gtk_label_set_justify (GTK_LABEL (dialog->label6), GTK_JUSTIFY_RIGHT);
  gtk_misc_set_alignment (GTK_MISC (dialog->label6), 1, 0.5);

  dialog->clock_amplitude_factor_entry = gtk_entry_new ();
  gtk_widget_show (dialog->clock_amplitude_factor_entry);
  gtk_table_attach (GTK_TABLE (dialog->table), dialog->clock_amplitude_factor_entry, 1, 2, 7, 8,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 2, 2);
  gtk_entry_set_activates_default (GTK_ENTRY (dialog->clock_amplitude_factor_entry), TRUE) ;

  dialog->label6 = gtk_label_new (_("Layer Separation:"));
  gtk_widget_show (dialog->label6);
  gtk_table_attach (GTK_TABLE (dialog->table), dialog->label6, 0, 1, 8, 9,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 2, 2);
  gtk_label_set_justify (GTK_LABEL (dialog->label6), GTK_JUSTIFY_RIGHT);
  gtk_misc_set_alignment (GTK_MISC (dialog->label6), 1, 0.5);

  dialog->layer_separation_entry = gtk_entry_new ();
  gtk_widget_show (dialog->layer_separation_entry);
  gtk_table_attach (GTK_TABLE (dialog->table), dialog->layer_separation_entry, 1, 2, 8, 9,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 2, 2);
  gtk_entry_set_activates_default (GTK_ENTRY (dialog->layer_separation_entry), TRUE) ;

  dialog->lblMaxIter = gtk_label_new (_("Maximum Iterations Per Sample:"));
  gtk_widget_show (dialog->lblMaxIter);
  gtk_table_attach (GTK_TABLE (dialog->table), dialog->lblMaxIter, 0, 1, 9, 10,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 2, 2);
  gtk_label_set_justify (GTK_LABEL (dialog->lblMaxIter), GTK_JUSTIFY_RIGHT);
  gtk_misc_set_alignment (GTK_MISC (dialog->lblMaxIter), 1, 0.5);

  dialog->max_iterations_per_sample_entry = gtk_entry_new ();
  gtk_widget_show (dialog->max_iterations_per_sample_entry);
  gtk_table_attach (GTK_TABLE (dialog->table), dialog->max_iterations_per_sample_entry, 1, 2, 9, 10,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 2, 2);
  gtk_entry_set_activates_default (GTK_ENTRY (dialog->max_iterations_per_sample_entry), TRUE) ;

  dialog->chkRandomizeCells = gtk_check_button_new_with_label (_("Randomize Simulation Order")) ;
  gtk_widget_show (dialog->chkRandomizeCells) ;
  gtk_table_attach (GTK_TABLE (dialog->table), dialog->chkRandomizeCells, 0, 2, 11, 12,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 2, 2);

  dialog->chkAnimate = gtk_check_button_new_with_label (_("Animate")) ;
  gtk_widget_show (dialog->chkAnimate) ;
  gtk_table_attach (GTK_TABLE (dialog->table), dialog->chkAnimate, 0, 2, 12, 13,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 2, 2);

  gtk_dialog_add_button (GTK_DIALOG (dialog->bistable_properties_dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL) ;
  gtk_dialog_add_button (GTK_DIALOG (dialog->bistable_properties_dialog), GTK_STOCK_OK, GTK_RESPONSE_OK) ;
  gtk_dialog_set_default_response (GTK_DIALOG (dialog->bistable_properties_dialog), GTK_RESPONSE_OK) ;
  }
コード例 #18
0
static void
add_or_remove (PlumaEncodingsComboBox *menu,
	       GtkTreeModel           *model)
{
	GtkTreeIter iter;
	gboolean add_item = FALSE;

	if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (menu), &iter))
	{
		gtk_tree_model_get (model, &iter,
				    ADD_COLUMN, &add_item,
				    -1);
	}

	if (!add_item)
	{
		menu->priv->activated_item = gtk_combo_box_get_active (GTK_COMBO_BOX (menu));
	}
	else
	{
		GtkWidget *dialog;

		GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (menu));

#if !GTK_CHECK_VERSION (2, 18, 0)
		if (!GTK_WIDGET_TOPLEVEL (toplevel))
#else
		if (!gtk_widget_is_toplevel (toplevel))
#endif
			toplevel = NULL;

		g_signal_handler_block (menu, menu->priv->changed_id);
		gtk_combo_box_set_active (GTK_COMBO_BOX (menu),
					  menu->priv->activated_item);
		g_signal_handler_unblock (menu, menu->priv->changed_id);

		dialog = pluma_encodings_dialog_new();

		if (toplevel != NULL)
		{
			GtkWindowGroup *wg;

			gtk_window_set_transient_for (GTK_WINDOW (dialog),
						      GTK_WINDOW (toplevel));

			wg = GTK_WINDOW (toplevel)->group;
			if (wg == NULL)
			{
				wg = gtk_window_group_new ();
				gtk_window_group_add_window (wg,
							     GTK_WINDOW (toplevel));
			}

			gtk_window_group_add_window (wg,
						     GTK_WINDOW (dialog));
		}

		gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);

		g_signal_connect (dialog,
				  "response",
				  G_CALLBACK (dialog_response_cb),
				  menu);

		gtk_widget_show (dialog);
	}
}
コード例 #19
0
ファイル: nullplugin.c プロジェクト: MozillaOnline/gecko-dev
/* create and display the dialog box */
void 
makeWidget(PluginInstance *This)
{
    GtkWidget *dialogWindow;
    GtkWidget *dialogMessage;
    GtkWidget *okButton;
    GtkWidget *cancelButton;
    char message[1024];
    MimeTypeElement *ele;

    if (!This) return;

    /* need to check whether we already pop up a dialog box for previous
       minetype in the same web page. It's require otherwise there will
       be 2 dialog boxes pop if there are 2 plugin in the same web page
    */
    if ((ele = isExist(&head, This->type)))
    {
        if (ele->pinst && ele->pinst->dialogBox)
        {
            GtkWidget *top_window = gtk_widget_get_toplevel(ele->pinst->dialogBox);
            if (top_window && GTK_WIDGET_VISIBLE(top_window))
            {   /* this will raise the toplevel window */
                gdk_window_show(top_window->window);
            }
        }
        return;
    }

    dialogWindow = gtk_dialog_new();
    This->dialogBox = dialogWindow;
    This->exists = TRUE;
    This->dialogBox = dialogWindow;
    addToList(&head, This);
    gtk_window_set_title(GTK_WINDOW(dialogWindow), PLUGIN_NAME);
    gtk_window_set_position(GTK_WINDOW(dialogWindow), GTK_WIN_POS_CENTER);
    gtk_window_set_modal(GTK_WINDOW(dialogWindow), FALSE);
    gtk_window_set_wmclass(GTK_WINDOW(dialogWindow), "Mozilla", "DefaultPlugin");
    gtk_container_set_border_width(GTK_CONTAINER(dialogWindow), 20);
    gtk_window_set_resizable(GTK_WINDOW(dialogWindow), FALSE);

    PR_snprintf(message, sizeof(message) - 1, MESSAGE, This->type);
    dialogMessage = AddWidget(gtk_label_new (message), 
                   GTK_DIALOG(dialogWindow)->vbox);

    okButton= AddWidget(gtk_button_new_with_label (OK_BUTTON), 
                   GTK_DIALOG(dialogWindow)->action_area);

    GTK_WIDGET_SET_FLAGS (okButton, GTK_CAN_DEFAULT);
    gtk_widget_grab_default(okButton);

    cancelButton= AddWidget(gtk_button_new_with_label (CANCEL_BUTTON), 
                   GTK_DIALOG(dialogWindow)->action_area);

    g_signal_connect (GTK_OBJECT(okButton),  "clicked",
                      G_CALLBACK(DialogOKClicked), This);

    g_signal_connect (GTK_OBJECT(cancelButton),  "clicked",
                      G_CALLBACK(DialogCancelClicked), This);

    g_signal_connect(GTK_OBJECT(dialogWindow), "key_press_event",
                     G_CALLBACK(DialogEscapePressed), NULL);

    /* hookup to when the dialog is destroyed */
    g_signal_connect(GTK_OBJECT(dialogWindow), "destroy",
                     G_CALLBACK(onDestroyWidget), This);

    gtk_widget_show_all(dialogWindow);
}
コード例 #20
0
ファイル: l_otrvr_p.c プロジェクト: zaharchuktv/linuxbuh
int l_otrvr_p(class l_otrvr_rek *poi,GtkWidget *wpredok)
{
    class l_otrvr_p_data data;
    char strsql[512];
    data.poi=poi;


    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);

    sprintf(strsql,"%s %s",name_system,gettext("Реквизиты поиска"));

    gtk_window_set_title (GTK_WINDOW (data.window),strsql);
    gtk_container_set_border_width (GTK_CONTAINER (data.window), 5);

    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_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(l_otrvr_p_v_key_press),&data);

    iceb_u_str zagolov;
    zagolov.new_plus(gettext("Реквизиты поиска"));

    GtkWidget *label=gtk_label_new(zagolov.ravno_toutf());

    GtkWidget *vbox = gtk_vbox_new (FALSE, 0);
    GtkWidget *hbox[KOLENTER];
    for(int i=0; i < KOLENTER; i++)
        hbox[i] = gtk_hbox_new (FALSE, 0);

    GtkWidget *hboxknop = gtk_hbox_new (FALSE, 0);

    gtk_container_add (GTK_CONTAINER (data.window), vbox);
    gtk_container_add (GTK_CONTAINER (vbox), label);

    GtkWidget *separator1=gtk_hseparator_new();
    gtk_container_add (GTK_CONTAINER (vbox), separator1);

    for(int i=0; i < KOLENTER; i++)
        gtk_container_add (GTK_CONTAINER (vbox), hbox[i]);

    GtkWidget *separator2=gtk_hseparator_new();
    gtk_container_add (GTK_CONTAINER (vbox), separator2);

    gtk_container_add (GTK_CONTAINER (vbox), hboxknop);

    GtkTooltips *tooltips_enter[KOLENTER];

    sprintf(strsql,"%s (,,)",gettext("Табельный номер"));
    data.knopka_enter[E_TABNOM]=gtk_button_new_with_label(iceb_u_toutf(strsql));
    gtk_box_pack_start (GTK_BOX (hbox[E_TABNOM]), data.knopka_enter[E_TABNOM], FALSE, FALSE, 0);
    gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_TABNOM]),"clicked",GTK_SIGNAL_FUNC(otrvr_t_v_e_knopka),&data);
    gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_TABNOM]),(gpointer)E_TABNOM);
    tooltips_enter[E_TABNOM]=gtk_tooltips_new();
    gtk_tooltips_set_tip(tooltips_enter[E_TABNOM],data.knopka_enter[E_TABNOM],gettext("Выбор табельного номера"),NULL);

    data.entry[E_TABNOM] = gtk_entry_new();
    gtk_box_pack_start (GTK_BOX (hbox[E_TABNOM]), data.entry[E_TABNOM],TRUE, TRUE, 0);
    gtk_signal_connect(GTK_OBJECT (data.entry[E_TABNOM]), "activate",GTK_SIGNAL_FUNC(l_otrvr_p_v_vvod),&data);
    gtk_entry_set_text(GTK_ENTRY(data.entry[E_TABNOM]),data.poi->tabnom.ravno());
    gtk_object_set_user_data(GTK_OBJECT(data.entry[E_TABNOM]),(gpointer)E_TABNOM);

    sprintf(strsql,"%s (,,)",gettext("Код табеля"));
    data.knopka_enter[E_KOD_TAB]=gtk_button_new_with_label(iceb_u_toutf(strsql));
    gtk_box_pack_start (GTK_BOX (hbox[E_KOD_TAB]), data.knopka_enter[E_KOD_TAB], FALSE, FALSE, 0);
    gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_KOD_TAB]),"clicked",GTK_SIGNAL_FUNC(otrvr_t_v_e_knopka),&data);
    gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_KOD_TAB]),(gpointer)E_KOD_TAB);
    tooltips_enter[E_KOD_TAB]=gtk_tooltips_new();
    gtk_tooltips_set_tip(tooltips_enter[E_KOD_TAB],data.knopka_enter[E_KOD_TAB],gettext("Выбор кода табеля"),NULL);

    data.entry[E_KOD_TAB] = gtk_entry_new();
    gtk_box_pack_start (GTK_BOX (hbox[E_KOD_TAB]), data.entry[E_KOD_TAB],TRUE, TRUE, 0);
    gtk_signal_connect(GTK_OBJECT (data.entry[E_KOD_TAB]), "activate",GTK_SIGNAL_FUNC(l_otrvr_p_v_vvod),&data);
    gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOD_TAB]),data.poi->kod_tab.ravno());
    gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOD_TAB]),(gpointer)E_KOD_TAB);

    sprintf(strsql,"%s (,,)",gettext("Подразделение"));
    data.knopka_enter[E_PODR]=gtk_button_new_with_label(iceb_u_toutf(strsql));
    gtk_box_pack_start (GTK_BOX (hbox[E_PODR]), data.knopka_enter[E_PODR], FALSE, FALSE, 0);
    gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_PODR]),"clicked",GTK_SIGNAL_FUNC(otrvr_t_v_e_knopka),&data);
    gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_PODR]),(gpointer)E_PODR);
    tooltips_enter[E_PODR]=gtk_tooltips_new();
    gtk_tooltips_set_tip(tooltips_enter[E_PODR],data.knopka_enter[E_PODR],gettext("Выбор подразделения"),NULL);

    data.entry[E_PODR] = gtk_entry_new();
    gtk_box_pack_start (GTK_BOX (hbox[E_PODR]), data.entry[E_PODR],TRUE, TRUE, 0);
    gtk_signal_connect(GTK_OBJECT (data.entry[E_PODR]), "activate",GTK_SIGNAL_FUNC(l_otrvr_p_v_vvod),&data);
    gtk_entry_set_text(GTK_ENTRY(data.entry[E_PODR]),data.poi->podr.ravno());
    gtk_object_set_user_data(GTK_OBJECT(data.entry[E_PODR]),(gpointer)E_PODR);



    sprintf(strsql,"%s",gettext("Коментарий"));
    label=gtk_label_new(iceb_u_toutf(strsql));
    gtk_box_pack_start (GTK_BOX (hbox[E_KOMENT]), label, FALSE, FALSE, 0);

    data.entry[E_KOMENT] = gtk_entry_new_with_max_length (40);
    gtk_box_pack_start (GTK_BOX (hbox[E_KOMENT]), data.entry[E_KOMENT],TRUE, TRUE, 0);
    gtk_signal_connect(GTK_OBJECT (data.entry[E_KOMENT]), "activate",GTK_SIGNAL_FUNC(l_otrvr_p_v_vvod),&data);
    gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOMENT]),data.poi->koment.ravno_toutf());
    gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOMENT]),(gpointer)E_KOMENT);


    GtkTooltips *tooltips[KOL_F_KL];

    sprintf(strsql,"F2 %s",gettext("Поиск"));
    data.knopka[FK2]=gtk_button_new_with_label(strsql);
    tooltips[FK2]=gtk_tooltips_new();
    gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Начать поиск"),NULL);
    gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]),"clicked",GTK_SIGNAL_FUNC(l_otrvr_p_v_knopka),&data);
    gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2);
    gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK2], TRUE, TRUE, 0);

    sprintf(strsql,"F4 %s",gettext("Очистить"));
    data.knopka[FK4]=gtk_button_new_with_label(strsql);
    tooltips[FK4]=gtk_tooltips_new();
    gtk_tooltips_set_tip(tooltips[FK4],data.knopka[FK4],gettext("Очистить меню от введенной информации"),NULL);
    gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]),"clicked",GTK_SIGNAL_FUNC(l_otrvr_p_v_knopka),&data);
    gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK4]),(gpointer)FK4);
    gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK4], TRUE, TRUE, 0);

    sprintf(strsql,"F10 %s",gettext("Выход"));
    data.knopka[FK10]=gtk_button_new_with_label(strsql);
    tooltips[FK10]=gtk_tooltips_new();
    gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL);
    gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]),"clicked",GTK_SIGNAL_FUNC(l_otrvr_p_v_knopka),&data);
    gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10);
    gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK10], TRUE, TRUE, 0);

    gtk_widget_grab_focus(data.entry[0]);

    gtk_widget_show_all (data.window);


    gtk_main();

    if(wpredok != NULL)
        gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));

    return(data.voz);



}
コード例 #21
0
static gboolean
handle_screenshot (XdpImplScreenshot *object,
                   GDBusMethodInvocation *invocation,
                   const char *arg_handle,
                   const char *arg_app_id,
                   const char *arg_parent_window,
                   GVariant *arg_options)
{
  g_autoptr(Request) request = NULL;
  const char *sender;
  ScreenshotDialogHandle *handle;
  g_autoptr(GError) error = NULL;
  g_autofree char *filename = NULL;
  gboolean success;
  gboolean modal;
  GtkWidget *dialog;
  GdkDisplay *display;
  GdkScreen *screen;
  ExternalWindow *external_parent = NULL;
  GtkWidget *fake_parent;

  sender = g_dbus_method_invocation_get_sender (invocation);

  request = request_new (sender, arg_app_id, arg_handle);

  org_gnome_shell_screenshot_call_screenshot_sync (shell,
                                                   FALSE,
                                                   TRUE,
                                                   "Screenshot",
                                                   &success,
                                                   &filename,
                                                   NULL, NULL);

  if (!g_variant_lookup (arg_options, "modal", "b", &modal))
    modal = TRUE;

  if (arg_parent_window)
    {
      external_parent = create_external_window_from_handle (arg_parent_window);
      if (!external_parent)
        g_warning ("Failed to associate portal window with parent window %s",
                   arg_parent_window);
    }

  if (external_parent)
    display = external_window_get_display (external_parent);
  else
    display = gdk_display_get_default ();
  screen = gdk_display_get_default_screen (display);

  fake_parent = g_object_new (GTK_TYPE_WINDOW,
                              "type", GTK_WINDOW_TOPLEVEL,
                              "screen", screen,
                              NULL);
  g_object_ref_sink (fake_parent);

  dialog = GTK_WIDGET (screenshot_dialog_new (arg_app_id, filename));
  gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (fake_parent));
  gtk_window_set_modal (GTK_WINDOW (dialog), modal);

  handle = g_new0 (ScreenshotDialogHandle, 1);
  handle->impl = object;
  handle->invocation = invocation;
  handle->request = g_object_ref (request);
  handle->dialog = g_object_ref (dialog);
  handle->external_parent = external_parent;
  handle->uri = g_filename_to_uri (filename, NULL, NULL);

  g_signal_connect (request, "handle-close", G_CALLBACK (handle_close), handle);

  g_signal_connect (dialog, "done", G_CALLBACK (screenshot_dialog_done), handle);

  gtk_widget_realize (dialog);

  if (external_parent)
    external_window_set_parent_of (external_parent, gtk_widget_get_window (dialog));

  gtk_widget_show (dialog);

  request_export (request, g_dbus_method_invocation_get_connection (invocation));

  return TRUE;
}
コード例 #22
0
void tourney_dialog_init(void)
{
        GtkWidget *vbox, *hbox, *w, *scrolled;
        GtkTreeViewColumn *column;

        if (tourney_dialog)
                return;

        vbox = gtk_vbox_new(FALSE, 4);

        /* Games spin button */
        hbox = gtk_hbox_new(FALSE, 0);
        w = gtk_label_new("Number of games:");
        gtk_box_pack_start(GTK_BOX(hbox), w, FALSE, FALSE, 0);
        tourney_games = gtk_spin_button_new_with_range(1., 1000., 1.);
        gtk_box_pack_start(GTK_BOX(hbox), tourney_games, FALSE, FALSE, 0);
        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

        /* Games list */
        tourney_store = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_INT,
                                           G_TYPE_INT);
        tourney_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(
                                                                tourney_store));
        gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tourney_view), TRUE);
        column = gtk_tree_view_column_new_with_attributes("Game",
                                                   gtk_cell_renderer_text_new(),
                                                          "text", 2, NULL);
        gtk_tree_view_append_column(GTK_TREE_VIEW(tourney_view), column);
        column = gtk_tree_view_column_new_with_attributes("Moves",
                                                   gtk_cell_renderer_text_new(),
                                                          "text", 1, NULL);
        gtk_tree_view_append_column(GTK_TREE_VIEW(tourney_view), column);
        column = gtk_tree_view_column_new_with_attributes("Winner",
                                                   gtk_cell_renderer_text_new(),
                                                          "text", 0, NULL);
        gtk_tree_view_append_column(GTK_TREE_VIEW(tourney_view), column);

        /* Scrolled container for tree view */
        scrolled = gtk_scrolled_window_new(NULL, NULL);
        gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
                                       GTK_POLICY_NEVER,
                                       GTK_POLICY_AUTOMATIC);
        gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled),
                                            GTK_SHADOW_IN);
        gtk_container_add(GTK_CONTAINER(scrolled), tourney_view);
        gtk_box_pack_start(GTK_BOX(vbox), scrolled, TRUE, TRUE, 0);

        /* Save games checkbox */
        hbox = gtk_hbox_new(FALSE, 0);
        tourney_save = gtk_check_button_new_with_label("Save games with "
                                                       "prefix:");
        gtk_box_pack_start(GTK_BOX(hbox), tourney_save, FALSE, FALSE, 0);
        tourney_prefix = gtk_entry_new();
        gtk_box_pack_start(GTK_BOX(hbox), tourney_prefix, TRUE, TRUE, 0);
        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

        /* Execute button */
        hbox = gtk_hbox_new(TRUE, 0);
        tourney_exec = gtk_button_new_from_stock(GTK_STOCK_EXECUTE);
        g_signal_connect(G_OBJECT(tourney_exec), "clicked",
                         G_CALLBACK(tourney_dialog_execute), NULL);
        gtk_widget_set_no_show_all(tourney_exec, TRUE);
        gtk_widget_show(tourney_exec);
        gtk_box_pack_start(GTK_BOX(hbox), tourney_exec, TRUE, TRUE, 0);

        /* Halt button */
        tourney_halt = gtk_button_new_from_stock(GTK_STOCK_STOP);
        g_signal_connect(G_OBJECT(tourney_halt), "clicked",
                         G_CALLBACK(tourney_dialog_stop), NULL);
        gtk_widget_set_no_show_all(tourney_halt, TRUE);
        gtk_widget_hide(tourney_halt);
        gtk_box_pack_start(GTK_BOX(hbox), tourney_halt, TRUE, TRUE, 0);

        /* Close button */
        w = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
        g_signal_connect(G_OBJECT(w), "clicked",
                         G_CALLBACK(tourney_dialog_close), NULL);
        gtk_box_pack_start(GTK_BOX(hbox), w, TRUE, TRUE, 0);
        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

        /* Create dialog window */
        tourney_dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL);
        g_signal_connect(G_OBJECT(tourney_dialog), "delete-event",
                         G_CALLBACK(gtk_widget_hide_on_delete), NULL);
        gtk_window_set_title(GTK_WINDOW(tourney_dialog), "Tournament");
        gtk_window_set_transient_for(GTK_WINDOW(tourney_dialog),
                                     GTK_WINDOW(window));
        gtk_window_set_modal(GTK_WINDOW(tourney_dialog), TRUE);
        gtk_container_add(GTK_CONTAINER(tourney_dialog), vbox);
        gtk_container_border_width(GTK_CONTAINER(tourney_dialog), 12);
        gtk_window_resize(GTK_WINDOW(tourney_dialog), 256, 384);
}
コード例 #23
0
/*
 *	move, copy needs a src, and dest.
 *	@fileops_str : "move" or "copy"
 *	@src : source file
 *	@dest: destinatin file.
 */
FileOpsResponse*
fileops_move_copy_error_show_dialog (const char* fileops_str, GError* error,
	                             GFile* src, GFile* dest, GtkWindow* parent)
{
    FileOpsResponse* ret = NULL;
    switch (error->code)
    {
	case G_IO_ERROR_NOT_FOUND:
	    {
		GtkWidget* dialog;
	        dialog = gtk_message_dialog_new (NULL,
					     GTK_DIALOG_MODAL,
					     GTK_MESSAGE_WARNING,
					     GTK_BUTTONS_OK,
					     NULL);
	        gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
		char* primary_text = g_strdup_printf (_("Error while %s files"), fileops_str);
	        char* secondary_text = g_strdup (error->message);

		g_object_set (dialog,
	          "text", primary_text,
		  "secondary-text", secondary_text,
		  NULL);
		gtk_dialog_run (GTK_DIALOG (dialog));
		gtk_widget_destroy (dialog);
		g_free(secondary_text);
		g_free(primary_text);
	    }
	    break;
	case G_IO_ERROR_EXISTS:      //move, copy
	    //TODO: message dialog.
	    //      overwrite, replace, rename, //all overwrite, replace all, rename all.
	    ret = _show_skip_cancel_replace_rename_all_dialog (fileops_str, error->message, src, dest, parent);
	    break;
	case G_IO_ERROR_NOT_DIRECTORY: //move, copy destination
	    /*
	     * TODO: response: FILE_OPS_RESPONSE_CANCEL.
	     */
	    _show_simple_error_message_dialog (fileops_str, error->message, dest, parent);
	    break;
	case G_IO_ERROR_PERMISSION_DENIED: //delete, trash, move, copy
	    /*
	     * TODO: response: skip, cancel, //skip all
	     * NOTE: use @dest instead of @src here.
	     */
	    _show_skip_cancel_all_dialog (fileops_str, error->message, dest, parent);
	    break;
	case G_IO_ERROR_CANCELLED:   //operatin was cancelled
	    /*
	     * TODO: response: this is caused by progress_dialog.
	     */
	    _show_simple_error_message_dialog (fileops_str, error->message, dest, parent);
	    break;

	case G_IO_ERROR_IS_DIRECTORY:  //programming error.
	case G_IO_ERROR_INVALID_ARGUMENT: //programming error
	    _show_simple_error_message_dialog (fileops_str, "Programming error !", NULL, parent);
	    break;
	default: //all other errors are not handled.
	    _show_simple_error_message_dialog (fileops_str, "Unexpected error happens!", NULL, parent);
	    break;
    }

    return ret;
}
コード例 #24
0
void player_dialog_init(PlayerDialog *pd, PIECE player)
{
        GtkWidget *vbox, *hbox, *fbox, *w;
        GSList *group = NULL;
        int i, i_max;
        const char *label;

        pd->player = players + player;
        vbox = gtk_vbox_new(FALSE, 4);

        /* Controller combo box */
        hbox = gtk_hbox_new(FALSE, 0);
        w = gtk_label_new("Controller:");
        gtk_box_pack_start(GTK_BOX(hbox), w, FALSE, FALSE, 8);
        w = gtk_combo_box_new_text();
        i_max = number_of_ais();
        for (i = 0; i < i_max; i++) {
                AI *a = ai(i);

                label = "Human";
                if (a->func)
                        label = player_to_string(i);
                gtk_combo_box_append_text(GTK_COMBO_BOX(w), label);
        }
        gtk_combo_box_set_active(GTK_COMBO_BOX(w), 0);
        pd->combo = w;
        gtk_box_pack_start(GTK_BOX(hbox), w, FALSE, FALSE, 0);
        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

        /* Search box frame */
        w = gtk_frame_new("Search");
        gtk_box_pack_start(GTK_BOX(vbox), w, FALSE, FALSE, 4);
        fbox = gtk_vbox_new(FALSE, 4);
        gtk_container_add(GTK_CONTAINER(w), fbox);
        gtk_container_border_width(GTK_CONTAINER(fbox), 8);

        /* Search radio buttons */
        for (i = 0; i < SEARCHES; i++) {
                w = gtk_radio_button_new_with_label(group, search_to_string(i));
                group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(w));
                gtk_box_pack_start(GTK_BOX(fbox), w, FALSE, FALSE, 0);
                pd->search[i] = w;
        }

        /* Cache toggle button */
        pd->cache = gtk_check_button_new_with_label("Use search cache");
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pd->cache), TRUE);
        gtk_box_pack_start(GTK_BOX(fbox), pd->cache, FALSE, FALSE, 0);

        /* Threat-space search toggle button */
        pd->tss = gtk_check_button_new_with_label("Threat-space search");
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pd->tss), FALSE);
        /*gtk_box_pack_start(GTK_BOX(fbox), pd->tss, FALSE, FALSE, 0);*/

        /* Search depth spin button */
        w = labeled_spin_new("Depth in moves:", 1., MAX_DEPTH, 1., &pd->depth,
                             NULL);
        gtk_box_pack_start(GTK_BOX(fbox), w, FALSE, FALSE, 0);

        /* Minimum branching factor spin button */
        w = labeled_spin_new("Minimum branches:", 0., MAX_BRANCH, 2.,
                             &pd->branch, NULL);
        gtk_box_pack_start(GTK_BOX(fbox), w, FALSE, FALSE, 0);

        /* Ok button */
        hbox = gtk_hbox_new(TRUE, 0);
        w = gtk_hbox_new(FALSE, 0);
        gtk_box_pack_start(GTK_BOX(hbox), w, FALSE, FALSE, 0);
        w = gtk_button_new_from_stock(GTK_STOCK_OK);
        g_signal_connect(G_OBJECT(w), "clicked",
                         G_CALLBACK(player_dialog_ok), pd);
        gtk_box_pack_start(GTK_BOX(hbox), w, TRUE, TRUE, 0);
        gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);

        /* Create dialog window */
        pd->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
        g_signal_connect(G_OBJECT(pd->window), "delete-event",
                         G_CALLBACK(gtk_widget_hide_on_delete), NULL);
        label = "Mark Player";
        if (player)
                label = va("%s Player", piece_to_string(player));
        gtk_window_set_title(GTK_WINDOW(pd->window), label);
        gtk_window_set_transient_for(GTK_WINDOW(pd->window),
                                     GTK_WINDOW(window));
        gtk_window_set_modal(GTK_WINDOW(pd->window), TRUE);
        gtk_window_set_resizable(GTK_WINDOW(pd->window), FALSE);
        gtk_container_add(GTK_CONTAINER(pd->window), vbox);
        gtk_container_border_width(GTK_CONTAINER(pd->window), 12);
}
コード例 #25
0
ファイル: iceb_l_forop_p.c プロジェクト: zaharchuktv/linuxbuh
int iceb_l_forop_p(class forop_rek *rek_poi,GtkWidget *wpredok)
{
class iceb_l_forop_p_data data;
char strsql[512];
data.rk=rek_poi;

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);
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(forop_p_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, 0);
GtkWidget *hbox[KOLENTER];
for(int i=0; i < KOLENTER; i++)
 hbox[i] = gtk_hbox_new (FALSE, 0);
GtkWidget *hboxknop = gtk_hbox_new (FALSE, 0);

gtk_container_add (GTK_CONTAINER (data.window), vbox);
for(int i=0; i < KOLENTER; i++)
 gtk_container_add (GTK_CONTAINER (vbox), hbox[i]);
gtk_container_add (GTK_CONTAINER (vbox), hboxknop);


GtkWidget *label=gtk_label_new(gettext("Код"));
data.entry[E_KOD] = gtk_entry_new_with_max_length (10);
gtk_box_pack_start (GTK_BOX (hbox[E_KOD]), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox[E_KOD]), data.entry[E_KOD], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_KOD]), "activate",GTK_SIGNAL_FUNC(forop_p_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOD]),data.rk->kod.ravno_toutf());
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOD]),(gpointer)E_KOD);

label=gtk_label_new(gettext("Наименование"));
data.entry[E_NAIM] = gtk_entry_new_with_max_length (80);
gtk_box_pack_start (GTK_BOX (hbox[E_NAIM]), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox[E_NAIM]), data.entry[E_NAIM], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_NAIM]), "activate",GTK_SIGNAL_FUNC(forop_p_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_NAIM]),data.rk->naim.ravno_toutf());
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_NAIM]),(gpointer)E_NAIM);





//GtkWidget *knopka[KOL_PFK];
GtkTooltips *tooltips[KOL_PFK];

sprintf(strsql,"F2 %s",gettext("Поиск"));
data.knopka[PFK2]=gtk_button_new_with_label(strsql);
tooltips[PFK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[PFK2],data.knopka[PFK2],gettext("Начать поиск нужных записей"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[PFK2]),"clicked",GTK_SIGNAL_FUNC(forop_p_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[PFK2]),(gpointer)PFK2);

sprintf(strsql,"F4 %s",gettext("Очистить"));
data.knopka[PFK4]=gtk_button_new_with_label(strsql);
tooltips[PFK4]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[PFK4],data.knopka[PFK4],gettext("Очистить меню от введеноой информации"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[PFK4]),"clicked",GTK_SIGNAL_FUNC(forop_p_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[PFK4]),(gpointer)PFK4);


sprintf(strsql,"F10 %s",gettext("Выход"));
data.knopka[PFK10]=gtk_button_new_with_label(strsql);
tooltips[PFK10]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[PFK10],data.knopka[PFK10],gettext("Поиск не выполнять"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[PFK10]),"clicked",GTK_SIGNAL_FUNC(forop_p_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[PFK10]),(gpointer)PFK10);

gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[PFK2], TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[PFK4], TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[PFK10], TRUE, TRUE, 0);

gtk_widget_grab_focus(data.entry[0]);

gtk_widget_show_all (data.window);

gtk_main();

if(wpredok != NULL)
  gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));

return(data.voz);
}
コード例 #26
0
ファイル: go_m.c プロジェクト: zaharchuktv/linuxbuh
int   go_m(class go_rr *rek_ras)
{
    class go_data data;

    data.rek_r=rek_ras;

    if(data.rek_r->datan.getdlinna() == 0)
        data.rek_r->clear_data();

    char strsql[512];

    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);

    sprintf(strsql,"%s %s",name_system,gettext("Журнал ордер"));
    gtk_window_set_title (GTK_WINDOW (data.window),strsql);
    gtk_container_set_border_width (GTK_CONTAINER (data.window), 5);

    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_v_key_press),&data);

    GtkWidget *label=gtk_label_new(gettext("Расчет журнала-ордера по счету"));

    GtkWidget *vbox = gtk_vbox_new (FALSE, 0);
    GtkWidget *hbox[KOLENTER];
    for(int i=0; i < KOLENTER; i++)
        hbox[i] = gtk_hbox_new (FALSE, 0);

    GtkWidget *hboxradio = gtk_hbox_new (FALSE, 0);
    GtkWidget *hboxknop = gtk_hbox_new (FALSE, 0);

//Вставляем радиокнопки
    GSList *group;

    data.radiobutton[0]=gtk_radio_button_new_with_label(NULL,gettext("Расчет по субсчетам"));
    if(data.rek_r->metka_r == 0)
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data.radiobutton[0]),TRUE); //Устанавливем активной кнопку
    gtk_box_pack_start (GTK_BOX (hboxradio),data.radiobutton[0], TRUE, TRUE, 0);
    gtk_signal_connect(GTK_OBJECT(data.radiobutton[0]), "clicked",GTK_SIGNAL_FUNC(go_radio0),&data);
//gtk_object_set_user_data(GTK_OBJECT(data.radiobutton0),(gpointer)"0");

    group=gtk_radio_button_group(GTK_RADIO_BUTTON(data.radiobutton[0]));

    data.radiobutton[1]=gtk_radio_button_new_with_label(group,gettext("Расчет по счетам"));
    if(data.rek_r->metka_r == 1)
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data.radiobutton[1]),TRUE); //Устанавливем активной кнопку
    gtk_signal_connect(GTK_OBJECT(data.radiobutton[1]), "clicked",GTK_SIGNAL_FUNC(go_radio1),&data);
    gtk_box_pack_start (GTK_BOX (hboxradio),data.radiobutton[1], TRUE, TRUE, 0);

    gtk_container_add (GTK_CONTAINER (data.window), vbox);
    gtk_container_add (GTK_CONTAINER (vbox), label);

    for(int i=0; i < KOLENTER; i++)
        gtk_container_add (GTK_CONTAINER (vbox), hbox[i]);

    gtk_container_add (GTK_CONTAINER (vbox), hboxradio);
    gtk_container_add (GTK_CONTAINER (vbox), hboxknop);

    GtkTooltips *tooltips_enter[KOLENTER];

    data.knopka_enter[E_SHET]=gtk_button_new_with_label(gettext("Счет"));
    gtk_box_pack_start (GTK_BOX (hbox[E_SHET]), data.knopka_enter[E_SHET], FALSE, FALSE, 0);
    gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_SHET]),"clicked",GTK_SIGNAL_FUNC(go_v_e_knopka),&data);
    gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_SHET]),(gpointer)E_SHET);
    tooltips_enter[E_SHET]=gtk_tooltips_new();
    gtk_tooltips_set_tip(tooltips_enter[E_SHET],data.knopka_enter[E_SHET],gettext("Выбор счёта в плане счетов"),NULL);

    data.entry[E_SHET] = gtk_entry_new();
    gtk_box_pack_start (GTK_BOX (hbox[E_SHET]), data.entry[E_SHET], TRUE, TRUE, 0);
    gtk_signal_connect(GTK_OBJECT (data.entry[E_SHET]), "activate",GTK_SIGNAL_FUNC(go_v_vvod),&data);
    gtk_entry_set_text(GTK_ENTRY(data.entry[E_SHET]),data.rek_r->shet.ravno_toutf());
    gtk_object_set_user_data(GTK_OBJECT(data.entry[E_SHET]),(gpointer)E_SHET);

    sprintf(strsql,"%s",gettext("Дата начала"));
    data.knopka_enter[E_DATAN]=gtk_button_new_with_label(iceb_u_toutf(strsql));
    gtk_box_pack_start (GTK_BOX (hbox[E_DATAN]), data.knopka_enter[E_DATAN], FALSE, FALSE, 0);
    gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_DATAN]),"clicked",GTK_SIGNAL_FUNC(go_v_e_knopka),&data);
    gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_DATAN]),(gpointer)E_DATAN);
    tooltips_enter[E_DATAN]=gtk_tooltips_new();
    gtk_tooltips_set_tip(tooltips_enter[E_DATAN],data.knopka_enter[E_DATAN],gettext("Выбор даты начала отчёта"),NULL);


    data.entry[E_DATAN] = gtk_entry_new_with_max_length (10);
    gtk_box_pack_start (GTK_BOX (hbox[E_DATAN]), data.entry[E_DATAN], TRUE, TRUE, 0);
    gtk_signal_connect(GTK_OBJECT (data.entry[E_DATAN]), "activate",GTK_SIGNAL_FUNC(go_v_vvod),&data);
    gtk_entry_set_text(GTK_ENTRY(data.entry[E_DATAN]),data.rek_r->datan.ravno_toutf());
    gtk_object_set_user_data(GTK_OBJECT(data.entry[E_DATAN]),(gpointer)E_DATAN);

    sprintf(strsql,"%s",gettext("Дата конца"));
    data.knopka_enter[E_DATAK]=gtk_button_new_with_label(iceb_u_toutf(strsql));
    gtk_box_pack_start (GTK_BOX (hbox[E_DATAK]), data.knopka_enter[E_DATAK], FALSE, FALSE, 0);
    gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_DATAK]),"clicked",GTK_SIGNAL_FUNC(go_v_e_knopka),&data);
    gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_DATAK]),(gpointer)E_DATAK);
    tooltips_enter[E_DATAK]=gtk_tooltips_new();
    gtk_tooltips_set_tip(tooltips_enter[E_DATAK],data.knopka_enter[E_DATAK],gettext("Выбор даты конца отчёта"),NULL);

    data.entry[E_DATAK] = gtk_entry_new_with_max_length (10);
    gtk_box_pack_start (GTK_BOX (hbox[E_DATAK]), data.entry[E_DATAK], TRUE, TRUE, 0);
    gtk_signal_connect(GTK_OBJECT (data.entry[E_DATAK]), "activate",GTK_SIGNAL_FUNC(go_v_vvod),&data);
    gtk_entry_set_text(GTK_ENTRY(data.entry[E_DATAK]),data.rek_r->datak.ravno_toutf());
    gtk_object_set_user_data(GTK_OBJECT(data.entry[E_DATAK]),(gpointer)E_DATAK);


    sprintf(strsql,"%s (,,)",gettext("Код группы контрагента"));
    data.knopka_enter[E_KODGR]=gtk_button_new_with_label(iceb_u_toutf(strsql));
    gtk_box_pack_start (GTK_BOX (hbox[E_KODGR]), data.knopka_enter[E_KODGR], FALSE, FALSE, 0);
    gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_KODGR]),"clicked",GTK_SIGNAL_FUNC(go_v_e_knopka),&data);
    gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_KODGR]),(gpointer)E_KODGR);
    tooltips_enter[E_KODGR]=gtk_tooltips_new();
    gtk_tooltips_set_tip(tooltips_enter[E_KODGR],data.knopka_enter[E_KODGR],gettext("Выбор группы контрагента"),NULL);

    data.entry[E_KODGR] = gtk_entry_new();
    gtk_box_pack_start (GTK_BOX (hbox[E_KODGR]), data.entry[E_KODGR], TRUE, TRUE, 0);
    gtk_signal_connect(GTK_OBJECT (data.entry[E_KODGR]), "activate",GTK_SIGNAL_FUNC(go_v_vvod),&data);
    gtk_entry_set_text(GTK_ENTRY(data.entry[E_KODGR]),data.rek_r->kodgr.ravno_toutf());
    gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KODGR]),(gpointer)E_KODGR);


    GtkTooltips *tooltips[KOL_F_KL];

    sprintf(strsql,"F2 %s",gettext("Расчет"));
    data.knopka[FK2]=gtk_button_new_with_label(strsql);
    tooltips[FK2]=gtk_tooltips_new();
    gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Начать расчет"),NULL);
    gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]),"clicked",GTK_SIGNAL_FUNC(go_v_knopka),&data);
    gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2);
    gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK2], TRUE, TRUE, 0);

    sprintf(strsql,"F3 %s",gettext("Реквизиты"));
    data.knopka[FK3]=gtk_button_new_with_label(strsql);
    tooltips[FK3]=gtk_tooltips_new();
    gtk_tooltips_set_tip(tooltips[FK3],data.knopka[FK3],gettext("Просмотр нужных реквизитов"),NULL);
    gtk_signal_connect(GTK_OBJECT(data.knopka[FK3]),"clicked",GTK_SIGNAL_FUNC(go_v_knopka),&data);
    gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK3]),(gpointer)FK3);
    gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK3], TRUE, TRUE, 0);

    sprintf(strsql,"F4 %s",gettext("Очистить"));
    data.knopka[FK4]=gtk_button_new_with_label(strsql);
    tooltips[FK4]=gtk_tooltips_new();
    gtk_tooltips_set_tip(tooltips[FK4],data.knopka[FK4],gettext("Очистить меню от введенной информации"),NULL);
    gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]),"clicked",GTK_SIGNAL_FUNC(go_v_knopka),&data);
    gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK4]),(gpointer)FK4);
    gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK4], TRUE, TRUE, 0);


    sprintf(strsql,"F10 %s",gettext("Выход"));
    data.knopka[FK10]=gtk_button_new_with_label(strsql);
    tooltips[FK10]=gtk_tooltips_new();
    gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL);
    gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]),"clicked",GTK_SIGNAL_FUNC(go_v_knopka),&data);
    gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10);
    gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK10], TRUE, TRUE, 0);

    gtk_widget_grab_focus(data.entry[0]);

    gtk_widget_show_all (data.window);

    gtk_main();

    if(data.voz == 0 && data.rek_r->metka_r == 1)
    {
        data.voz=go_m_mkz(rek_ras,NULL);
    }
    return(data.voz);

}
コード例 #27
0
ファイル: entry.c プロジェクト: bendavis78/zenity
void 
zenity_entry (ZenityData *data, ZenityEntryData *entry_data)
{
  GtkBuilder *builder = NULL;
  GtkWidget *dialog;
  GtkWidget *button;
  GObject *text;
  GSList *entries = NULL; 
  GSList *tmp;
  GObject *vbox;
  
  builder = zenity_util_load_ui_file ("zenity_entry_dialog", NULL);

  if (builder == NULL) {
    data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
    return;
  }
	
  gtk_builder_connect_signals (builder, NULL);
	
  dialog = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_entry_dialog"));
	
  g_signal_connect (G_OBJECT (dialog), "response",
                    G_CALLBACK (zenity_entry_dialog_response), data);

  if (data->dialog_title)
    gtk_window_set_title (GTK_WINDOW (dialog), data->dialog_title);
	
  zenity_util_set_window_icon (dialog, data->window_icon, ZENITY_IMAGE_FULLPATH ("zenity-entry.png"));

  if (data->width > -1 || data->height > -1)
    gtk_window_set_default_size (GTK_WINDOW (dialog), data->width, data->height);

  if (data->modal)
    gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
  
  if (data->ok_label) {
    button = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_entry_ok_button"));
    gtk_button_set_label (GTK_BUTTON (button), data->ok_label);
    gtk_button_set_image (GTK_BUTTON (button),
                          gtk_image_new_from_stock (GTK_STOCK_OK, GTK_ICON_SIZE_BUTTON));
  }

  if (data->cancel_label) {
    button = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_entry_cancel_button"));
    gtk_button_set_label (GTK_BUTTON (button), data->cancel_label);
    gtk_button_set_image (GTK_BUTTON (button),
                          gtk_image_new_from_stock (GTK_STOCK_CANCEL, GTK_ICON_SIZE_BUTTON));
  }

  text = gtk_builder_get_object (builder, "zenity_entry_text");

  if (entry_data->dialog_text)
    gtk_label_set_text_with_mnemonic (GTK_LABEL (text), g_strcompress (entry_data->dialog_text));
  
  vbox = gtk_builder_get_object (builder, "vbox4");
  
  zenity_entry_fill_entries(&entries, entry_data->data);
  
  n_entries = g_slist_length (entries);

  if (n_entries > 1) {
    entry = gtk_combo_box_text_new_with_entry ();

    for (tmp = entries; tmp; tmp = tmp->next) {
      gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (entry), tmp->data);
    }

    if (entry_data->entry_text) {
      gtk_combo_box_text_prepend_text (GTK_COMBO_BOX_TEXT (entry), entry_data->entry_text);
      gtk_combo_box_set_active (GTK_COMBO_BOX (entry), 0);
    }

    g_signal_connect (gtk_bin_get_child (GTK_BIN (entry)), "activate",
                      G_CALLBACK (zenity_entry_combo_activate_default),
                      GTK_WINDOW (dialog));
  } else {
    entry = gtk_entry_new();

    gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
    
    if (entry_data->entry_text)
      gtk_entry_set_text (GTK_ENTRY (entry), entry_data->entry_text);

    if (entry_data->hide_text)
      g_object_set (G_OBJECT (entry), "visibility", FALSE, NULL);
  }

  gtk_widget_show (entry);

  gtk_box_pack_end (GTK_BOX (vbox), entry, FALSE, FALSE, 0);

  gtk_label_set_mnemonic_widget (GTK_LABEL (text), entry);

  g_object_unref (builder);

  zenity_util_show_dialog (dialog, data->attach);

  if(data->timeout_delay > 0) {
    g_timeout_add_seconds (data->timeout_delay, (GSourceFunc) zenity_util_timeout_handle, dialog);
  }

  gtk_main ();
}
コード例 #28
0
ファイル: l_uosopp.c プロジェクト: zaharchuktv/linuxbuh
int l_uosopp(int metka, //0-воод и корректировка 1-выбор
iceb_u_str *kod,iceb_u_str *naimk,GtkWidget *wpredok)
{
l_uosoppdata data;
char bros[512];
GdkColor color;
data.metka_rr=metka;

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,-1);
//gdk_color_parse("black",&color);
//gtk_widget_modify_bg(data.window,GTK_STATE_NORMAL,&color);


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);

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);


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_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(l_uosoppkey_press),&data);
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_release_event",GTK_SIGNAL_FUNC(iceb_key_release),&data.kl_shift);

GtkWidget *hbox = gtk_hbox_new (FALSE, 1);
gtk_container_add (GTK_CONTAINER (data.window), hbox);

GtkWidget *vbox1 = gtk_vbox_new (FALSE, 1);
GtkWidget *vbox2 = gtk_vbox_new (FALSE, 1);

gtk_box_pack_start (GTK_BOX (hbox), vbox1, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
gtk_widget_show(hbox);

data.label_kolstr=gtk_label_new (gettext("Список операций приходов"));


gtk_box_pack_start (GTK_BOX (vbox2),data.label_kolstr,FALSE, FALSE, 0);

gtk_widget_show(vbox1);
gtk_widget_show(vbox2);

data.label_poisk=gtk_label_new ("");
/************
PangoFontDescription *font_pango=pango_font_description_from_string(shrift_ravnohir.ravno());
gtk_widget_modify_font(GTK_WIDGET(data.label_ost),font_pango);
pango_font_description_free(font_pango);
***************/

gdk_color_parse("red",&color);
gtk_widget_modify_fg(data.label_poisk,GTK_STATE_NORMAL,&color);

gtk_box_pack_start (GTK_BOX (vbox2),data.label_poisk,FALSE, FALSE, 0);

data.sw = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_usize(GTK_WIDGET(data.sw),-1,200);

gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (data.sw),GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (data.sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
//gtk_box_pack_start (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0);

//Кнопки
GtkTooltips *tooltips[KOL_F_KL];


sprintf(bros,"F2 %s",gettext("Ввести"));
data.knopka[FK2]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK2],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]), "clicked",GTK_SIGNAL_FUNC(l_uosoppknopka),&data);
tooltips[FK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Ввод новой записи"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2);
gtk_widget_show(data.knopka[FK2]);

sprintf(bros,"%sF2 %s",RFK,gettext("Корректировать"));
data.knopka[SFK2]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK2],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[SFK2]), "clicked",GTK_SIGNAL_FUNC(l_uosoppknopka),&data);
tooltips[SFK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[SFK2],data.knopka[SFK2],gettext("Корректировка выбранной записи"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK2]),(gpointer)SFK2);
gtk_widget_show(data.knopka[SFK2]);

sprintf(bros,"F3 %s",gettext("Удалить"));
data.knopka[FK3]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK3],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK3]), "clicked",GTK_SIGNAL_FUNC(l_uosoppknopka),&data);
tooltips[FK3]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK3],data.knopka[FK3],gettext("Удалить выбранную запись"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK3]),(gpointer)FK3);
gtk_widget_show(data.knopka[FK3]);

sprintf(bros,"%sF3 %s",RFK,gettext("Удалить"));
data.knopka[SFK3]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK3],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[SFK3]), "clicked",GTK_SIGNAL_FUNC(l_uosoppknopka),&data);
tooltips[SFK3]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[SFK3],data.knopka[SFK3],gettext("Удалить неиспользуемые коды операций"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK3]),(gpointer)SFK3);
gtk_widget_show(data.knopka[SFK3]);

sprintf(bros,"F4 %s",gettext("Поиск"));
data.knopka[FK4]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK4],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]), "clicked",GTK_SIGNAL_FUNC(l_uosoppknopka),&data);
tooltips[FK4]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK4],data.knopka[FK4],gettext("Поиск нужных записей"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK4]),(gpointer)FK4);
gtk_widget_show(data.knopka[FK4]);

sprintf(bros,"F5 %s",gettext("Печать"));
data.knopka[FK5]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK5],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK5]), "clicked",GTK_SIGNAL_FUNC(l_uosoppknopka),&data);
tooltips[FK5]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK5],data.knopka[FK5],gettext("Распечатка записей"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK5]),(gpointer)FK5);
gtk_widget_show(data.knopka[FK5]);


sprintf(bros,"F10 %s",gettext("Выход"));
data.knopka[FK10]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1),data.knopka[FK10],TRUE,TRUE, 0);
tooltips[FK10]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]), "clicked",GTK_SIGNAL_FUNC(l_uosoppknopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10);
gtk_widget_show(data.knopka[FK10]);


gtk_widget_realize(data.window);
gdk_window_set_cursor(data.window->window,gdk_cursor_new(ICEB_CURSOR));

gtk_widget_grab_focus(data.knopka[FK10]);

l_uosoppcreate_list(&data);
gtk_widget_show(data.window);

if(metka == 0)
  gtk_window_maximize(GTK_WINDOW(data.window));
//gtk_window_fullscreen(GTK_WINDOW(data.window));


gtk_main();


printf("l_uosopp end\n");
if(wpredok != NULL)
  gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));
if(data.metka_voz == 0)
 if(metka == 1)
  {
   kod->new_plus(data.kodv.ravno());
   naimk->new_plus(data.naimv.ravno());
  }
return(data.metka_voz);

}
コード例 #29
0
ファイル: gtk_dlg_std.c プロジェクト: NoSuchProcess/gcad3d
//=====================================================================
  void GUI_DialogYN (char* text, void *funcnam ) {
//=====================================================================
/// \code
/// GUI_DialogYN   dialogWindow with text, OK-Button and Cancel-Button.
/// <funcnam> is called with int-value UI_FuncOK or UI_FuncCancel.
///
/// Input:
///   text      multiple lines with \n
///   funcnam   callbackfunktion for button-press
///
/// funcnam prototyp:
/// int funcnam (MemObj *parent, void **data);
///   GUI_DATA_EVENT =*(int*)data[0]=UI_FuncOK|UI_FuncCancel
///
/// Example:
///   GUI_DialogYN ("OK to save file xy", f_CB_save);
///
///
/// //=====================================================================
///   int f_CB_save (MemObj *mo, void **data) {
/// //=====================================================================
///
///   int idat;
///
///   idat = GUI_DATA_EVENT;
///   printf("f_CB_save %d\n",idat);
///
///   switch(idat) {
///     case UI_FuncOK:
///       // save ...
///       break;
///     case UI_FuncCancel:
///       // skip saving ...
///       break;
///   }
///
///   return 0;
///
/// }
/// \endcode


  int         iRes;     // response
  GtkWidget   *wdlg;


  // printf("UI_DialogYN |%s|\n",text);


  if(UI_DialogYNWin) {     // cannot use GUI_is_alive
    // gdk_window_raise (UI_MainWin);
    return;
  }



  wdlg = gtk_message_dialog_new (
           GTK_WINDOW (UI_MainWin),  // keep on top of this else NULL
           GTK_DIALOG_DESTROY_WITH_PARENT,
           GTK_MESSAGE_QUESTION,
           GTK_BUTTONS_OK_CANCEL,
           "%s",text);


  gtk_window_set_transient_for (GTK_WINDOW(UI_MainWin), GTK_WINDOW(wdlg));
  gtk_window_set_modal (GTK_WINDOW (wdlg), TRUE);


  // does not wait (not modal):
  gtk_widget_show (wdlg);
  g_signal_connect_swapped (wdlg, "response",
                          G_CALLBACK (GUI_DialogYN_CB),
                          wdlg);

  UI_DialogYNWin  = wdlg;
  UI_DialogYNFunc = funcnam;

  return;

}
コード例 #30
0
ファイル: poigod_usl.c プロジェクト: zaharchuktv/linuxbuh
int poigod_usl(GtkWidget *wpredok)
{
char strsql[512];
iceb_u_str repl;
class poigod_usl_data data;


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(poigod_usl_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);

repl.plus(gettext("Распечатать список годов, за которые введена информация"));
sprintf(strsql,"%s:%s %s\n",gettext("База данных"),imabaz,organ);
repl.ps_plus(strsql);
repl.plus(gettext("Учёт услуг"));

GtkWidget *label=gtk_label_new(repl.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),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(poigod_usl_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)poigod_usl1,&data);

gtk_main();

if(wpredok != NULL)
  gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));

return(data.voz);
}