/[xlog]/xlog/src/hamlib-utils.c
ViewVC logotype

Diff of /xlog/src/hamlib-utils.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.2 by pa4tu, Sun Nov 10 19:27:04 2002 UTC revision 1.3 by pa4tu, Thu Nov 21 19:57:46 2002 UTC
# Line 44  Line 44 
44    
45  typedef struct  typedef struct
46  {  {
47          gchar **xpmdata;    gchar **xpmdata;
48          GdkPixmap *pixmap;    GdkPixmap *pixmap;
49          GdkBitmap *mask;    GdkBitmap *mask;
50  } typeLevel;  }
51    typeLevel;
52  typeLevel S[] =  
53  {  typeLevel S[] = {
54          { s0_xpm, NULL, NULL },    {s0_xpm, NULL, NULL},
55          { s1_xpm, NULL, NULL },    {s1_xpm, NULL, NULL},
56          { s2_xpm, NULL, NULL },    {s2_xpm, NULL, NULL},
57          { s3_xpm, NULL, NULL },    {s3_xpm, NULL, NULL},
58          { s4_xpm, NULL, NULL },    {s4_xpm, NULL, NULL},
59          { s5_xpm, NULL, NULL },    {s5_xpm, NULL, NULL},
60          { s6_xpm, NULL, NULL },    {s6_xpm, NULL, NULL},
61          { s7_xpm, NULL, NULL },    {s7_xpm, NULL, NULL},
62          { s8_xpm, NULL, NULL },    {s8_xpm, NULL, NULL},
63          { s9_xpm, NULL, NULL },    {s9_xpm, NULL, NULL},
64          { NULL, NULL, NULL }    {NULL, NULL, NULL}
65  };  };
66    
67  extern preferencestype preferences;  extern preferencestype preferences;
# Line 74  GdkPixmap *pixmap = NULL; Line 74  GdkPixmap *pixmap = NULL;
74  gint svalue[10];  gint svalue[10];
75    
76  /* Append a new entry in the driver list. It is called by rig_list_foreach */  /* Append a new entry in the driver list. It is called by rig_list_foreach */
77  static gint riglist_make_list(const struct rig_caps *caps, gpointer data)  static gint
78    riglist_make_list (const struct rig_caps *caps, gpointer data)
79  {  {
80          rigs = g_list_append(rigs, (gpointer)caps);    rigs = g_list_append (rigs, (gpointer) caps);
81          return 1; /* !=0, we want them all ! */    return 1;                     /* !=0, we want them all ! */
82  }  }
83    
84  /* Return a list with pointers of available drivers from hamlib */  /* Return a list with pointers of available drivers from hamlib */
85  GList *riglist_get_list(void)  GList *
86    riglist_get_list (void)
87  {  {
88          gint status;    gint status;
89    
90          rig_load_all_backends();    rig_load_all_backends ();
91          status = rig_list_foreach(riglist_make_list, NULL);    status = rig_list_foreach (riglist_make_list, NULL);
92          return rigs;    return rigs;
93  }  }
94    
95  /* lookup hamlib rigid associated with model name */  /* lookup hamlib rigid associated with model name */
96  gint get_rigid(gchar *rig)  gint
97    get_rigid (gchar * rig)
98  {  {
99          gint i, numrigs;    gint i, numrigs;
100          struct rig_caps *rcaps = NULL;    struct rig_caps *rcaps = NULL;
101    
102          numrigs = g_list_length(riglist);    numrigs = g_list_length (riglist);
103          for (i=0; i<numrigs; i++) {    for (i = 0; i < numrigs; i++)
104                  rcaps = (struct rig_caps *)g_list_nth_data(riglist, i);      {
105                  if (g_strcasecmp(rig, rcaps->model_name) == 0)        rcaps = (struct rig_caps *) g_list_nth_data (riglist, i);
106                          break;        if (g_strcasecmp (rig, rcaps->model_name) == 0)
107          }          break;
108          if (i > 0) return rcaps->rig_model;      }
109          else return(-1);    if (i > 0)
110        return rcaps->rig_model;
111      else
112        return (-1);
113  }  }
114    
115  /* load xpm data from s-meter pixmaps */  /* load xpm data from s-meter pixmaps */
116  void loadsmeter(GtkWidget *widget)  void
117    loadsmeter (GtkWidget * widget)
118  {  {
119          gint i = 0;    gint i = 0;
120    
121          while (S[i].xpmdata)    while (S[i].xpmdata)
122          {      {
123                  S[i].pixmap = gdk_pixmap_create_from_xpm_d(widget->window,        S[i].pixmap = gdk_pixmap_create_from_xpm_d (widget->window,
124                          &S[i].mask, NULL, S[i].xpmdata);                                                    &S[i].mask, NULL,
125                  i++;                                                    S[i].xpmdata);
126          }        i++;
127        }
128  }  }
129    
130    
131  /* copy a s-meter pixmap to pixmap depending on the value of smax */  /* copy a s-meter pixmap to pixmap depending on the value of smax */
132  static void draw_smeter(gint value)  static void
133    draw_smeter (gint value)
134  {  {
135          GtkWidget *drawingarea;    GtkWidget *drawingarea;
136          GdkGC *gc;    GdkGC *gc;
137          GdkRectangle rectangle;    GdkRectangle rectangle;
138    
139          drawingarea = lookup_widget(mainwindow, "smeterdrawingarea");    drawingarea = lookup_widget (mainwindow, "smeterdrawingarea");
140          gc = drawingarea->style->fg_gc[GTK_STATE_NORMAL];    gc = drawingarea->style->fg_gc[GTK_STATE_NORMAL];
141          /* clear background */    /* clear background */
142          gdk_draw_rectangle(pixmap, drawingarea->style->white_gc, TRUE, 0, 0,    gdk_draw_rectangle (pixmap, drawingarea->style->white_gc, TRUE, 0, 0,
143                  drawingarea->allocation.width, drawingarea->allocation.height);                        drawingarea->allocation.width,
144          gdk_draw_pixmap(pixmap, gc, S[value].pixmap, 0, 0, 0, 0,                        drawingarea->allocation.height);
145                  drawingarea->allocation.width, drawingarea->allocation.height);    gdk_draw_pixmap (pixmap, gc, S[value].pixmap, 0, 0, 0, 0,
146          rectangle.x = 0;                     drawingarea->allocation.width,
147          rectangle.y = 0;                     drawingarea->allocation.height);
148          rectangle.width = drawingarea->allocation.width;    rectangle.x = 0;
149          rectangle.height = drawingarea->allocation.height;    rectangle.y = 0;
150          gtk_widget_draw(drawingarea, &rectangle); /* see expose_event further down */    rectangle.width = drawingarea->allocation.width;
151      rectangle.height = drawingarea->allocation.height;
152      gtk_widget_draw (drawingarea, &rectangle);    /* see expose_event further down */
153  }  }
154    
155  /* return string with mode */  /* return string with mode */
156  gchar *getrigmode(gint mode)  gchar *
157    getrigmode (gint mode)
158  {  {
159          gchar *rigmode;    gchar *rigmode;
160    
161          switch(mode)    switch (mode)
162          {      {
163                  case RIG_MODE_AM:      case RIG_MODE_AM:
164                          rigmode = g_strdup("AM");        rigmode = g_strdup ("AM");
165                  break;        break;
166                  case RIG_MODE_CW:      case RIG_MODE_CW:
167                          rigmode = g_strdup("CW");        rigmode = g_strdup ("CW");
168                  break;        break;
169                  case RIG_MODE_USB:      case RIG_MODE_USB:
170                          rigmode = g_strdup("USB");        rigmode = g_strdup ("USB");
171                  break;        break;
172                  case RIG_MODE_LSB:      case RIG_MODE_LSB:
173                          rigmode = g_strdup("LSB");        rigmode = g_strdup ("LSB");
174                  break;        break;
175                  case RIG_MODE_RTTY:      case RIG_MODE_RTTY:
176                          rigmode = g_strdup("RTTY");        rigmode = g_strdup ("RTTY");
177                  break;        break;
178                  case RIG_MODE_FM:      case RIG_MODE_FM:
179                          rigmode = g_strdup("FM");        rigmode = g_strdup ("FM");
180                  break;        break;
181                  case RIG_MODE_WFM:      case RIG_MODE_WFM:
182                          rigmode = g_strdup("WFM");        rigmode = g_strdup ("WFM");
183                  break;        break;
184                  default:      default:
185                          rigmode = g_strdup("UNKNOWN");        rigmode = g_strdup ("UNKNOWN");
186                  break;        break;
187          }      }
188          return(rigmode);    return (rigmode);
189  }  }
190    
191  /* Retrieve frequency, mode, signal strength and power with hamlib commands.  /* Retrieve frequency, mode, signal strength and power with hamlib commands.
# Line 184  gchar *getrigmode(gint mode) Line 196  gchar *getrigmode(gint mode)
196   * the number of hamlib commands and each command is invoked seperately   * the number of hamlib commands and each command is invoked seperately
197   * when this function is called. This is needed to let hamlib recover from errors.   * when this function is called. This is needed to let hamlib recover from errors.
198   */   */
199  gint get_riginfo(void)  gint
200    get_riginfo (void)
201  {  {
202          gint retcode, strength, spoint, i, smax = 0, status;    gint retcode, strength, spoint, i, smax = 0, status;
203          freq_t freq;    freq_t freq;
204          rmode_t rmode;    rmode_t rmode;
205          pbwidth_t width;    pbwidth_t width;
206          ptt_t ptt;    ptt_t ptt;
207          value_t val;    value_t val;
208          GString *digits = g_string_new("");    GString *digits = g_string_new ("");
209          GtkWidget *frequencylabel;    GtkWidget *frequencylabel;
210          gchar *message;    gchar *message;
211          if (state.hlcounter == 0)    if (state.hlcounter == 0)
212          {      {
213                  retcode = rig_get_freq(myrig, RIG_VFO_CURR, &freq);        retcode = rig_get_freq (myrig, RIG_VFO_CURR, &freq);
214                  state.hlcounter++;        state.hlcounter++;
215                  if (retcode == RIG_OK)        if (retcode == RIG_OK)
216                  {          {
217                          state.rigfrequency = freq;            state.rigfrequency = freq;
218                          if ((preferences.hamlib == 2) || (preferences.hamlib == 4))            if ((preferences.hamlib == 2) || (preferences.hamlib == 4))
219                          {              {
220                                  if (preferences.round == 0)                if (preferences.round == 0)
221                                          g_string_sprintf(digits, "%Ld", freq);                  g_string_sprintf (digits, "%Ld", freq);
222                                  else                else
223                                          g_string_sprintf(digits, "%Ld", (long long)rintl(freq/pow(10,preferences.round)));                  g_string_sprintf (digits, "%Ld",
224                                  g_string_insert_c(digits, (digits->len) - 6 + preferences.round, '.');                                    (long long) rintl (freq /
225                                  g_strstrip(digits->str);                                                       pow (10,
226                                  g_strdelimit(digits->str, " ", '0');                                                            preferences.
227                                  digits = g_string_append(digits, " MHz");                                                            round)));
228                                  frequencylabel = lookup_widget(mainwindow, "frequencylabel");                g_string_insert_c (digits,
229                                  gtk_label_set_text(GTK_LABEL(frequencylabel), digits->str);                                   (digits->len) - 6 + preferences.round, '.');
230                                  g_string_free(digits, TRUE);                g_strstrip (digits->str);
231                          }                g_strdelimit (digits->str, " ", '0');
232                  }                digits = g_string_append (digits, " MHz");
233                  else if (retcode != -RIG_ENAVAIL)                frequencylabel = lookup_widget (mainwindow, "frequencylabel");
234                  {                gtk_label_set_text (GTK_LABEL (frequencylabel), digits->str);
235                          message = g_strdup_printf(_("Hamlib error %d: %s"), retcode, rigerror(retcode));                g_string_free (digits, TRUE);
236                          update_statusbar(message);              }
237                          g_free(message);          }
238                          return 1;        else if (retcode != -RIG_ENAVAIL)
239                  }          {
240          }            message =
241                g_strdup_printf (_("Hamlib error %d: %s"), retcode,
242          if (state.hlcounter == 1)                               rigerror (retcode));
243          {            update_statusbar (message);
244                  retcode = rig_get_mode(myrig, RIG_VFO_CURR, &rmode, &width);            g_free (message);
245                  state.hlcounter++;            return 1;
246                  if (retcode == RIG_OK )          }
247                  {      }
248                          state.rigmode = rmode;  
249                  }    if (state.hlcounter == 1)
250                  else if (retcode != -RIG_ENAVAIL)      {
251                  {        retcode = rig_get_mode (myrig, RIG_VFO_CURR, &rmode, &width);
252                          message = g_strdup_printf(_("Hamlib error %d: %s"), retcode, rigerror(retcode));        state.hlcounter++;
253                          update_statusbar(message);        if (retcode == RIG_OK)
254                          g_free(message);          {
255                          return 1;            state.rigmode = rmode;
256                  }          }
257          }        else if (retcode != -RIG_ENAVAIL)
258            {
259          /* are we transmitting or receiving ?*/            message =
260          if (state.hlcounter == 2)              g_strdup_printf (_("Hamlib error %d: %s"), retcode,
261          {                               rigerror (retcode));
262                  retcode = rig_get_ptt(myrig, RIG_VFO_CURR, &ptt);            update_statusbar (message);
263                  state.hlcounter++;            g_free (message);
264                  if (retcode == RIG_OK)            return 1;
265                  {          }
266                          if (ptt == RIG_PTT_OFF)      }
267                                  state.tx = FALSE;  
268                          else    /* are we transmitting or receiving ? */
269                                  state.tx = TRUE;    if (state.hlcounter == 2)
270                  }      {
271                  else if (retcode != -RIG_ENAVAIL)        retcode = rig_get_ptt (myrig, RIG_VFO_CURR, &ptt);
272                  {        state.hlcounter++;
273                          message = g_strdup_printf(_("Hamlib error %d: %s"), retcode, rigerror(retcode));        if (retcode == RIG_OK)
274                          update_statusbar(message);          {
275                          g_free(message);            if (ptt == RIG_PTT_OFF)
276                          return 1;              state.tx = FALSE;
277                  }            else
278          }              state.tx = TRUE;
279                                    }
280          if (state.hlcounter == 3)        else if (retcode != -RIG_ENAVAIL)
281          {          {
282                  if (!state.tx)            message =
283                  {              g_strdup_printf (_("Hamlib error %d: %s"), retcode,
284                          retcode = rig_get_strength(myrig, RIG_VFO_CURR, &strength);                               rigerror (retcode));
285                          state.hlcounter++;            update_statusbar (message);
286                          if (retcode == RIG_OK )            g_free (message);
287                          {            return 1;
288                                  if (strength >= 0) spoint = 9;          }
289                                  else if (strength < -60) spoint = 0;      }
290                                  else spoint = (gint)ceil((strength+60)/6);  
291      if (state.hlcounter == 3)
292                                  svalue[state.scounter] = spoint;      {
293                                  state.scounter++;        if (!state.tx)
294                                  if (state.scounter == 10) state.scounter = 0;          {
295              retcode = rig_get_strength (myrig, RIG_VFO_CURR, &strength);
296                                  /* find maximum of s-meter during last 3 seconds */            state.hlcounter++;
297                                  for (i = 0; i < 10; i++)            if (retcode == RIG_OK)
298                                          if (svalue[i] > smax) smax = svalue[i];              {
299                                  if (strength >= 0)
300                                  if ((preferences.hamlib ==3) || (preferences.hamlib == 4))                  spoint = 9;
301                                          draw_smeter(smax);                else if (strength < -60)
302                    spoint = 0;
303                                  if (smax == 0) smax = 1;                else
304                                  if ((state.rigmode == RIG_MODE_CW) || (state.rigmode == RIG_MODE_RTTY))                  spoint = (gint) ceil ((strength + 60) / 6);
305                                          state.rigrst = g_strdup_printf("5%d9", smax);  
306                                  else                svalue[state.scounter] = spoint;
307                                          state.rigrst = g_strdup_printf("5%d", smax);                state.scounter++;
308                          }                if (state.scounter == 10)
309                          else if (retcode != -RIG_ENAVAIL)                  state.scounter = 0;
310                          {  
311                                  message = g_strdup_printf(_("Hamlib error %d: %s"), retcode, rigerror(retcode));                /* find maximum of s-meter during last 3 seconds */
312                                  update_statusbar(message);                for (i = 0; i < 10; i++)
313                                  g_free(message);                  if (svalue[i] > smax)
314                                  return 1;                    smax = svalue[i];
315                          }  
316                  if ((preferences.hamlib == 3) || (preferences.hamlib == 4))
317                  }                  draw_smeter (smax);
318                  else  
319                  {                if (smax == 0)
320                          state.hlcounter++;                  smax = 1;
321                          if ((preferences.hamlib == 3) || (preferences.hamlib == 4))                if ((state.rigmode == RIG_MODE_CW)
322                                  draw_smeter(0);                    || (state.rigmode == RIG_MODE_RTTY))
323                  }                  state.rigrst = g_strdup_printf ("5%d9", smax);
324          }                else
325          if (state.hlcounter == 4)                  state.rigrst = g_strdup_printf ("5%d", smax);
326          {              }
327                  state.hlcounter = 0;            else if (retcode != -RIG_ENAVAIL)
328                  retcode = rig_get_level(myrig, RIG_VFO_CURR, RIG_LEVEL_RFPOWER, &val);              {
329                  if (retcode == RIG_OK)                message =
330                  {                  g_strdup_printf (_("Hamlib error %d: %s"), retcode,
331                          status = rig_power2mW(myrig, &state.rigpower, val.f, state.rigfrequency, state.rigmode);                                   rigerror (retcode));
332                  }                update_statusbar (message);
333                  else if (retcode != -RIG_ENAVAIL)                g_free (message);
334                  {                return 1;
335                          message = g_strdup_printf(_("Hamlib error %d: %s"), retcode, rigerror(retcode));              }
336                          update_statusbar(message);  
337                          g_free(message);          }
338                          return 1;        else
339                  }          {
340              state.hlcounter++;
341              if ((preferences.hamlib == 3) || (preferences.hamlib == 4))
342                draw_smeter (0);
343            }
344        }
345      if (state.hlcounter == 4)
346        {
347          state.hlcounter = 0;
348          retcode = rig_get_level (myrig, RIG_VFO_CURR, RIG_LEVEL_RFPOWER, &val);
349          if (retcode == RIG_OK)
350            {
351              status =
352                rig_power2mW (myrig, &state.rigpower, val.f, state.rigfrequency,
353                              state.rigmode);
354            }
355          else if (retcode != -RIG_ENAVAIL)
356            {
357              message =
358                g_strdup_printf (_("Hamlib error %d: %s"), retcode,
359                                 rigerror (retcode));
360              update_statusbar (message);
361              g_free (message);
362              return 1;
363          }          }
364          return 1;      }
365      return 1;
366  }  }
367    
368  /* set appearance of some widgets dependent on preferences.hamlib */  /* set appearance of some widgets dependent on preferences.hamlib */
369  void sethamlibwidgets(gint status)  void
370    sethamlibwidgets (gint status)
371  {  {
372          GtkWidget *mhzlabel, *mhzbutton, *bandoptionmenu, *bandentry, *frequencypixmap,    GtkWidget *mhzlabel, *mhzbutton, *bandoptionmenu, *bandentry,
373                  *frequencyhbox, *frequencyhandlebox, *frequencylabel, *modelabel, *modebutton,      *frequencypixmap, *frequencyhbox, *frequencyhandlebox, *frequencylabel,
374                  *modeoptionmenu, *modeentry, *rstlabel, *rstbutton, *smeterhandlebox, *smeterhbox,      *modelabel, *modebutton, *modeoptionmenu, *modeentry, *rstlabel,
375                  *smeterdrawingarea, *smeterpixmap, *powerlabel, *powerbutton, *powerhbox;      *rstbutton, *smeterhandlebox, *smeterhbox, *smeterdrawingarea,
376        *smeterpixmap, *powerlabel, *powerbutton, *powerhbox;
377          mhzlabel = lookup_widget(mainwindow, "mhzlabel");  
378          mhzbutton = lookup_widget(mainwindow, "mhzbutton");    mhzlabel = lookup_widget (mainwindow, "mhzlabel");
379          modelabel = lookup_widget(mainwindow, "modelabel");    mhzbutton = lookup_widget (mainwindow, "mhzbutton");
380          modebutton = lookup_widget(mainwindow, "modebutton");    modelabel = lookup_widget (mainwindow, "modelabel");
381          rstlabel = lookup_widget(mainwindow, "rstlabel");    modebutton = lookup_widget (mainwindow, "modebutton");
382          rstbutton = lookup_widget(mainwindow, "rstbutton");    rstlabel = lookup_widget (mainwindow, "rstlabel");
383          powerlabel = lookup_widget(mainwindow, "powerlabel");    rstbutton = lookup_widget (mainwindow, "rstbutton");
384          powerbutton = lookup_widget(mainwindow, "powerbutton");    powerlabel = lookup_widget (mainwindow, "powerlabel");
385          powerhbox = lookup_widget(mainwindow, "powerhbox");    powerbutton = lookup_widget (mainwindow, "powerbutton");
386          bandoptionmenu = lookup_widget(mainwindow, "bandoptionmenu");    powerhbox = lookup_widget (mainwindow, "powerhbox");
387          bandentry = lookup_widget(mainwindow, "bandentry");    bandoptionmenu = lookup_widget (mainwindow, "bandoptionmenu");
388          modeoptionmenu = lookup_widget(mainwindow, "modeoptionmenu");    bandentry = lookup_widget (mainwindow, "bandentry");
389          modeentry = lookup_widget(mainwindow, "modeentry");    modeoptionmenu = lookup_widget (mainwindow, "modeoptionmenu");
390          frequencypixmap = lookup_widget(mainwindow, "frequencypixmap");    modeentry = lookup_widget (mainwindow, "modeentry");
391          frequencyhbox = lookup_widget(mainwindow, "frequencyhbox");    frequencypixmap = lookup_widget (mainwindow, "frequencypixmap");
392          frequencyhandlebox = lookup_widget(mainwindow, "frequencyhandlebox");    frequencyhbox = lookup_widget (mainwindow, "frequencyhbox");
393          frequencylabel = lookup_widget(mainwindow, "frequencylabel");    frequencyhandlebox = lookup_widget (mainwindow, "frequencyhandlebox");
394          smeterhandlebox = lookup_widget(mainwindow, "smeterhandlebox");    frequencylabel = lookup_widget (mainwindow, "frequencylabel");
395          smeterhbox = lookup_widget(mainwindow, "smeterhbox");    smeterhandlebox = lookup_widget (mainwindow, "smeterhandlebox");
396          smeterdrawingarea = lookup_widget(mainwindow, "smeterdrawingarea");    smeterhbox = lookup_widget (mainwindow, "smeterhbox");
397          smeterpixmap = lookup_widget(mainwindow, "smeterpixmap");    smeterdrawingarea = lookup_widget (mainwindow, "smeterdrawingarea");
398      smeterpixmap = lookup_widget (mainwindow, "smeterpixmap");
399          if (status == 0) /* hamlib disabled */  
400          {    if (status == 0)              /* hamlib disabled */
401                  gtk_widget_show(mhzlabel);      {
402                  gtk_widget_hide(mhzbutton);        gtk_widget_show (mhzlabel);
403                  gtk_widget_show(modelabel);        gtk_widget_hide (mhzbutton);
404                  gtk_widget_hide(modebutton);        gtk_widget_show (modelabel);
405                  gtk_widget_show(rstlabel);        gtk_widget_hide (modebutton);
406                  gtk_widget_hide(rstbutton);        gtk_widget_show (rstlabel);
407                  if (GTK_WIDGET_VISIBLE(powerhbox))        gtk_widget_hide (rstbutton);
408                  {        if (GTK_WIDGET_VISIBLE (powerhbox))
409                          gtk_widget_show(powerlabel);          {
410                          gtk_widget_hide(powerbutton);            gtk_widget_show (powerlabel);
411                  }            gtk_widget_hide (powerbutton);
412                  gtk_widget_hide(frequencylabel);          }
413                  gtk_widget_hide(frequencypixmap);        gtk_widget_hide (frequencylabel);
414                  gtk_widget_hide(frequencyhbox);        gtk_widget_hide (frequencypixmap);
415                  gtk_widget_hide(frequencyhandlebox);        gtk_widget_hide (frequencyhbox);
416                  gtk_widget_hide(smeterhandlebox);        gtk_widget_hide (frequencyhandlebox);
417                  gtk_widget_hide(smeterhbox);        gtk_widget_hide (smeterhandlebox);
418                  gtk_widget_hide(smeterdrawingarea);        gtk_widget_hide (smeterhbox);
419                  gtk_widget_hide(smeterpixmap);        gtk_widget_hide (smeterdrawingarea);
420          }        gtk_widget_hide (smeterpixmap);
421          else if (status == 1) /* hamlib enabled */      }
422          {    else if (status == 1)         /* hamlib enabled */
423                  gtk_widget_hide(mhzlabel);      {
424                  gtk_widget_show(mhzbutton);        gtk_widget_hide (mhzlabel);
425                  gtk_widget_hide(modelabel);        gtk_widget_show (mhzbutton);
426                  gtk_widget_show(modebutton);        gtk_widget_hide (modelabel);
427                  gtk_widget_hide(rstlabel);        gtk_widget_show (modebutton);
428                  gtk_widget_show(rstbutton);        gtk_widget_hide (rstlabel);
429                  if (GTK_WIDGET_VISIBLE(powerhbox))        gtk_widget_show (rstbutton);
430                  {        if (GTK_WIDGET_VISIBLE (powerhbox))
431                          gtk_widget_hide(powerlabel);          {
432                          gtk_widget_show(powerbutton);            gtk_widget_hide (powerlabel);
433                  }            gtk_widget_show (powerbutton);
434                  gtk_widget_hide(bandoptionmenu);          }
435                  gtk_widget_hide(modeoptionmenu);        gtk_widget_hide (bandoptionmenu);
436                  gtk_widget_show(bandentry);        gtk_widget_hide (modeoptionmenu);
437                  gtk_widget_show(modeentry);        gtk_widget_show (bandentry);
438                  preferences.bandseditbox = 1;        gtk_widget_show (modeentry);
439                  preferences.modeseditbox = 1;        preferences.bandseditbox = 1;
440                  gtk_widget_hide(frequencylabel);        preferences.modeseditbox = 1;
441                  gtk_widget_hide(frequencypixmap);        gtk_widget_hide (frequencylabel);
442                  gtk_widget_hide(frequencyhbox);        gtk_widget_hide (frequencypixmap);
443                  gtk_widget_hide(frequencyhandlebox);        gtk_widget_hide (frequencyhbox);
444                  gtk_widget_hide(smeterhandlebox);        gtk_widget_hide (frequencyhandlebox);
445                  gtk_widget_hide(smeterhbox);        gtk_widget_hide (smeterhandlebox);
446                  gtk_widget_hide(smeterdrawingarea);        gtk_widget_hide (smeterhbox);
447                  gtk_widget_hide(smeterpixmap);        gtk_widget_hide (smeterdrawingarea);
448          }        gtk_widget_hide (smeterpixmap);
449          else if (status == 2) /* hamlib enabled with frequency on statusbar*/      }
450          {    else if (status == 2)         /* hamlib enabled with frequency on statusbar */
451                  gtk_widget_hide(mhzlabel);      {
452                  gtk_widget_show(mhzbutton);        gtk_widget_hide (mhzlabel);
453                  gtk_widget_hide(modelabel);        gtk_widget_show (mhzbutton);
454                  gtk_widget_show(modebutton);        gtk_widget_hide (modelabel);
455                  gtk_widget_hide(rstlabel);        gtk_widget_show (modebutton);
456                  gtk_widget_show(rstbutton);        gtk_widget_hide (rstlabel);
457                  if (GTK_WIDGET_VISIBLE(powerhbox))        gtk_widget_show (rstbutton);
458                  {        if (GTK_WIDGET_VISIBLE (powerhbox))
459                          gtk_widget_hide(powerlabel);          {
460                          gtk_widget_show(powerbutton);            gtk_widget_hide (powerlabel);
461                  }            gtk_widget_show (powerbutton);
462                  gtk_widget_hide(bandoptionmenu);          }
463                  gtk_widget_hide(modeoptionmenu);        gtk_widget_hide (bandoptionmenu);
464                  gtk_widget_show(bandentry);        gtk_widget_hide (modeoptionmenu);
465                  gtk_widget_show(modeentry);        gtk_widget_show (bandentry);
466                  preferences.bandseditbox = 1;        gtk_widget_show (modeentry);
467                  preferences.modeseditbox = 1;        preferences.bandseditbox = 1;
468                  gtk_widget_show(frequencylabel);        preferences.modeseditbox = 1;
469                  gtk_widget_show(frequencypixmap);        gtk_widget_show (frequencylabel);
470                  gtk_widget_show(frequencyhbox);        gtk_widget_show (frequencypixmap);
471                  gtk_widget_show(frequencyhandlebox);        gtk_widget_show (frequencyhbox);
472                  gtk_widget_hide(smeterhandlebox);        gtk_widget_show (frequencyhandlebox);
473                  gtk_widget_hide(smeterhbox);        gtk_widget_hide (smeterhandlebox);
474                  gtk_widget_hide(smeterdrawingarea);        gtk_widget_hide (smeterhbox);
475                  gtk_widget_hide(smeterpixmap);        gtk_widget_hide (smeterdrawingarea);
476          }        gtk_widget_hide (smeterpixmap);
477          else if (status == 3) /* hamlib enabled with s-meter on statusbar*/      }
478          {    else if (status == 3)         /* hamlib enabled with s-meter on statusbar */
479                  gtk_widget_hide(mhzlabel);      {
480                  gtk_widget_show(mhzbutton);        gtk_widget_hide (mhzlabel);
481                  gtk_widget_hide(modelabel);        gtk_widget_show (mhzbutton);
482                  gtk_widget_show(modebutton);        gtk_widget_hide (modelabel);
483                  gtk_widget_hide(rstlabel);        gtk_widget_show (modebutton);
484                  gtk_widget_show(rstbutton);        gtk_widget_hide (rstlabel);
485                  if (GTK_WIDGET_VISIBLE(powerhbox))        gtk_widget_show (rstbutton);
486                  {        if (GTK_WIDGET_VISIBLE (powerhbox))
487                          gtk_widget_hide(powerlabel);          {
488                          gtk_widget_show(powerbutton);            gtk_widget_hide (powerlabel);
489                  }            gtk_widget_show (powerbutton);
490                  gtk_widget_hide(bandoptionmenu);          }
491                  gtk_widget_hide(modeoptionmenu);        gtk_widget_hide (bandoptionmenu);
492                  gtk_widget_show(bandentry);        gtk_widget_hide (modeoptionmenu);
493                  gtk_widget_show(modeentry);        gtk_widget_show (bandentry);
494                  preferences.bandseditbox = 1;        gtk_widget_show (modeentry);
495                  preferences.modeseditbox = 1;        preferences.bandseditbox = 1;
496                  gtk_widget_hide(frequencylabel);        preferences.modeseditbox = 1;
497                  gtk_widget_hide(frequencypixmap);        gtk_widget_hide (frequencylabel);
498                  gtk_widget_hide(frequencyhbox);        gtk_widget_hide (frequencypixmap);
499                  gtk_widget_hide(frequencyhandlebox);        gtk_widget_hide (frequencyhbox);
500                  gtk_widget_show(smeterhandlebox);        gtk_widget_hide (frequencyhandlebox);
501                  gtk_widget_show(smeterhbox);        gtk_widget_show (smeterhandlebox);
502                  gtk_widget_show(smeterdrawingarea);        gtk_widget_show (smeterhbox);
503                  gtk_widget_show(smeterpixmap);        gtk_widget_show (smeterdrawingarea);
504          }        gtk_widget_show (smeterpixmap);
505          else if (status == 4) /* hamlib enabled with frequency and s-meter on statusbar*/      }
506          {    else if (status == 4)         /* hamlib enabled with frequency and s-meter on statusbar */
507                  gtk_widget_hide(mhzlabel);      {
508                  gtk_widget_show(mhzbutton);        gtk_widget_hide (mhzlabel);
509                  gtk_widget_hide(modelabel);        gtk_widget_show (mhzbutton);
510                  gtk_widget_show(modebutton);        gtk_widget_hide (modelabel);
511                  gtk_widget_hide(rstlabel);        gtk_widget_show (modebutton);
512                  gtk_widget_show(rstbutton);        gtk_widget_hide (rstlabel);
513                  if (GTK_WIDGET_VISIBLE(powerhbox))        gtk_widget_show (rstbutton);
514                  {        if (GTK_WIDGET_VISIBLE (powerhbox))
515                          gtk_widget_hide(powerlabel);          {
516                          gtk_widget_show(powerbutton);            gtk_widget_hide (powerlabel);
517                  }            gtk_widget_show (powerbutton);
518                  gtk_widget_hide(bandoptionmenu);          }
519                  gtk_widget_hide(modeoptionmenu);        gtk_widget_hide (bandoptionmenu);
520                  gtk_widget_show(bandentry);        gtk_widget_hide (modeoptionmenu);
521                  gtk_widget_show(modeentry);        gtk_widget_show (bandentry);
522                  preferences.bandseditbox = 1;        gtk_widget_show (modeentry);
523                  preferences.modeseditbox = 1;        preferences.bandseditbox = 1;
524                  gtk_widget_show(frequencylabel);        preferences.modeseditbox = 1;
525                  gtk_widget_show(frequencypixmap);        gtk_widget_show (frequencylabel);
526                  gtk_widget_show(frequencyhbox);        gtk_widget_show (frequencypixmap);
527                  gtk_widget_show(frequencyhandlebox);        gtk_widget_show (frequencyhbox);
528                  gtk_widget_show(smeterhandlebox);        gtk_widget_show (frequencyhandlebox);
529                  gtk_widget_show(smeterhbox);        gtk_widget_show (smeterhandlebox);
530                  gtk_widget_show(smeterdrawingarea);        gtk_widget_show (smeterhbox);
531                  gtk_widget_show(smeterpixmap);        gtk_widget_show (smeterdrawingarea);
532          }        gtk_widget_show (smeterpixmap);
533        }
534  }  }
535    
536  /* load s-meter pixmaps when main window is displayed */  /* load s-meter pixmaps when main window is displayed */
537  void on_mainwindow_show(GtkWidget *widget, gpointer user_data)  void
538    on_mainwindow_show (GtkWidget * widget, gpointer user_data)
539  {  {
540          GtkWidget *drawingarea;    GtkWidget *drawingarea;
541    
542          if ((preferences.hamlib ==3) || (preferences.hamlib == 4))    if ((preferences.hamlib == 3) || (preferences.hamlib == 4))
543          {      {
544                  drawingarea = lookup_widget(mainwindow, "smeterdrawingarea");        drawingarea = lookup_widget (mainwindow, "smeterdrawingarea");
545                  loadsmeter(drawingarea);        loadsmeter (drawingarea);
546          }      }
547  }  }
548    
549  /* create a new backing pixmap for the s-meter whenever the window is resized */  /* create a new backing pixmap for the s-meter whenever the window is resized */
550  gboolean on_smeterdrawingarea_configure_event(GtkWidget *widget,  gboolean
551          GdkEventConfigure *event, gpointer user_data)  on_smeterdrawingarea_configure_event (GtkWidget * widget,
552  {                                        GdkEventConfigure * event,
553          if ((preferences.hamlib ==3) || (preferences.hamlib == 4))                                        gpointer user_data)
554          {  {
555                  if (pixmap) gdk_pixmap_unref(pixmap);    if ((preferences.hamlib == 3) || (preferences.hamlib == 4))
556                  pixmap = gdk_pixmap_new(widget->window, widget->allocation.width,      {
557                          widget->allocation.height, -1);        if (pixmap)
558          }          gdk_pixmap_unref (pixmap);
559          return FALSE;        pixmap = gdk_pixmap_new (widget->window, widget->allocation.width,
560                                   widget->allocation.height, -1);
561        }
562      return FALSE;
563  }  }
564    
565  /* copy the background pixmap to the drawing area for the s-meter */  /* copy the background pixmap to the drawing area for the s-meter */
566  gboolean on_smeterdrawingarea_expose_event(GtkWidget *widget,  gboolean
567          GdkEventExpose *event, gpointer user_data)  on_smeterdrawingarea_expose_event (GtkWidget * widget,
568  {                                     GdkEventExpose * event, gpointer user_data)
569          if ((preferences.hamlib ==3) || (preferences.hamlib == 4))  {
570          gdk_draw_pixmap(widget->window, widget->style->fg_gc[GTK_WIDGET_STATE(widget)],    if ((preferences.hamlib == 3) || (preferences.hamlib == 4))
571                  pixmap, event->area.x, event->area.y, event->area.x, event->area.y,      gdk_draw_pixmap (widget->window,
572                  event->area.width, event->area.height);                       widget->style->fg_gc[GTK_WIDGET_STATE (widget)], pixmap,
573          return FALSE;                       event->area.x, event->area.y, event->area.x,
574                         event->area.y, event->area.width, event->area.height);
575      return FALSE;
576  }  }
577  #endif  #endif

Legend:
Removed from v.1.2  
changed lines
  Added in v.1.3

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26